Created
June 8, 2019 18:53
-
-
Save extensionsapp/3d44545f0904694684511d241d359461 to your computer and use it in GitHub Desktop.
This file has been truncated, but you can view the full file.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| 'use strict'; | |
| var k; | |
| /** | |
| * @param {!Object} options | |
| * @return {?} | |
| */ | |
| var aa = function(options) { | |
| /** @type {number} */ | |
| var i = 0; | |
| return function() { | |
| return i < options.length ? { | |
| done : false, | |
| value : options[i++] | |
| } : { | |
| done : true | |
| }; | |
| }; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var ba = function(a) { | |
| var b = "undefined" != typeof Symbol && Symbol.iterator && a[Symbol.iterator]; | |
| return b ? b.call(a) : { | |
| next : aa(a) | |
| }; | |
| }; | |
| /** | |
| * @param {!Node} a | |
| * @return {?} | |
| */ | |
| var ca = function(a) { | |
| var item; | |
| /** @type {!Array} */ | |
| var classNames = []; | |
| for (; !(item = a.next()).done;) { | |
| classNames.push(item.value); | |
| } | |
| return classNames; | |
| }; | |
| /** @type {!Function} */ | |
| var da = "function" == typeof Object.create ? Object.create : function(a) { | |
| /** | |
| * @return {undefined} | |
| */ | |
| var GUI = function() { | |
| }; | |
| /** @type {!Object} */ | |
| GUI.prototype = a; | |
| return new GUI; | |
| }; | |
| var ea; | |
| if ("function" == typeof Object.setPrototypeOf) { | |
| /** @type {function(!Object, ?): !Object} */ | |
| ea = Object.setPrototypeOf; | |
| } else { | |
| var fa; | |
| a: { | |
| var ha = { | |
| $k : true | |
| }; | |
| var ia = {}; | |
| try { | |
| ia.__proto__ = ha; | |
| fa = ia.$k; | |
| break a; | |
| } catch (a) { | |
| } | |
| /** @type {boolean} */ | |
| fa = false; | |
| } | |
| /** @type {(function(!Object, !Function): ?|null)} */ | |
| ea = fa ? function(a, b) { | |
| /** @type {!Function} */ | |
| a.__proto__ = b; | |
| if (a.__proto__ !== b) { | |
| throw new TypeError(a + " is not extensible"); | |
| } | |
| return a; | |
| } : null; | |
| } | |
| /** @type {(function(!Object, !Function): ?|null)} */ | |
| var ja = ea; | |
| /** | |
| * @param {!Function} c | |
| * @param {!Function} b | |
| * @return {undefined} | |
| */ | |
| var ka = function(c, b) { | |
| c.prototype = da(b.prototype); | |
| /** @type {!Function} */ | |
| c.prototype.constructor = c; | |
| if (ja) { | |
| ja(c, b); | |
| } else { | |
| var key; | |
| for (key in b) { | |
| if ("prototype" != key) { | |
| if (Object.defineProperties) { | |
| /** @type {(ObjectPropertyDescriptor<?>|undefined)} */ | |
| var d = Object.getOwnPropertyDescriptor(b, key); | |
| if (d) { | |
| Object.defineProperty(c, key, d); | |
| } | |
| } else { | |
| c[key] = b[key]; | |
| } | |
| } | |
| } | |
| } | |
| c.D = b.prototype; | |
| }; | |
| /** | |
| * @param {string} data | |
| * @param {!Function} fn | |
| * @param {?} a | |
| * @return {?} | |
| */ | |
| var la = function(data, fn, a) { | |
| if (data instanceof String) { | |
| /** @type {string} */ | |
| data = String(data); | |
| } | |
| var tldCount = data.length; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < tldCount; i++) { | |
| var id = data[i]; | |
| if (fn.call(a, id, i, data)) { | |
| return { | |
| rj : i, | |
| pk : id | |
| }; | |
| } | |
| } | |
| return { | |
| rj : -1, | |
| pk : void 0 | |
| }; | |
| }; | |
| /** @type {!Function} */ | |
| var ma = "function" == typeof Object.defineProperties ? Object.defineProperty : function(object, name, descriptor) { | |
| if (object != Array.prototype && object != Object.prototype) { | |
| object[name] = descriptor.value; | |
| } | |
| }; | |
| var na = "undefined" != typeof window && window === this ? this : "undefined" != typeof global && null != global ? global : this; | |
| /** | |
| * @param {string} v | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var oa = function(v, a) { | |
| if (a) { | |
| var p = na; | |
| v = v.split("."); | |
| /** @type {number} */ | |
| var x = 0; | |
| for (; x < v.length - 1; x++) { | |
| var i = v[x]; | |
| if (!(i in p)) { | |
| p[i] = {}; | |
| } | |
| p = p[i]; | |
| } | |
| v = v[v.length - 1]; | |
| x = p[v]; | |
| a = a(x); | |
| if (a != x && null != a) { | |
| ma(p, v, { | |
| configurable : true, | |
| writable : true, | |
| value : a | |
| }); | |
| } | |
| } | |
| }; | |
| oa("Array.prototype.findIndex", function(position) { | |
| return position ? position : function(fn, b) { | |
| return la(this, fn, b).rj; | |
| }; | |
| }); | |
| /** | |
| * @param {string} fn | |
| * @param {string} args | |
| * @param {string} p | |
| * @return {?} | |
| */ | |
| var pa = function(fn, args, p) { | |
| if (null == fn) { | |
| throw new TypeError("The 'this' value for String.prototype." + p + " must not be null or undefined"); | |
| } | |
| if (args instanceof RegExp) { | |
| throw new TypeError("First argument to String.prototype." + p + " must not be a regular expression"); | |
| } | |
| return fn + ""; | |
| }; | |
| oa("String.prototype.endsWith", function(position) { | |
| return position ? position : function(chars, index) { | |
| var buffer = pa(this, chars, "endsWith"); | |
| /** @type {string} */ | |
| chars = chars + ""; | |
| if (void 0 === index) { | |
| index = buffer.length; | |
| } | |
| /** @type {number} */ | |
| index = Math.max(0, Math.min(index | 0, buffer.length)); | |
| /** @type {number} */ | |
| var chars_len = chars.length; | |
| for (; 0 < chars_len && 0 < index;) { | |
| if (buffer[--index] != chars[--chars_len]) { | |
| return false; | |
| } | |
| } | |
| return 0 >= chars_len; | |
| }; | |
| }); | |
| oa("Array.prototype.find", function(position) { | |
| return position ? position : function(fn, b) { | |
| return la(this, fn, b).pk; | |
| }; | |
| }); | |
| oa("String.prototype.startsWith", function(position) { | |
| return position ? position : function(value, tmp) { | |
| var that = pa(this, value, "startsWith"); | |
| /** @type {string} */ | |
| value = value + ""; | |
| var x = that.length; | |
| /** @type {number} */ | |
| var w_seq_type = value.length; | |
| /** @type {number} */ | |
| tmp = Math.max(0, Math.min(tmp | 0, that.length)); | |
| /** @type {number} */ | |
| var v_seq_type = 0; | |
| for (; v_seq_type < w_seq_type && tmp < x;) { | |
| if (that[tmp++] != value[v_seq_type++]) { | |
| return false; | |
| } | |
| } | |
| return v_seq_type >= w_seq_type; | |
| }; | |
| }); | |
| oa("String.prototype.repeat", function(position) { | |
| return position ? position : function(flags) { | |
| var filename = pa(this, null, "repeat"); | |
| if (0 > flags || 1342177279 < flags) { | |
| throw new RangeError("Invalid count value"); | |
| } | |
| /** @type {number} */ | |
| flags = flags | 0; | |
| /** @type {string} */ | |
| var src = ""; | |
| for (; flags;) { | |
| if (flags & 1 && (src = src + filename), flags = flags >>> 1) { | |
| filename = filename + filename; | |
| } | |
| } | |
| return src; | |
| }; | |
| }); | |
| /** | |
| * @return {undefined} | |
| */ | |
| var qa = function() { | |
| /** | |
| * @return {undefined} | |
| */ | |
| qa = function() { | |
| }; | |
| if (!na.Symbol) { | |
| na.Symbol = ra; | |
| } | |
| }; | |
| /** | |
| * @param {number} v | |
| * @param {!Object} n | |
| * @return {undefined} | |
| */ | |
| var sa = function(v, n) { | |
| /** @type {number} */ | |
| this.a = v; | |
| ma(this, "description", { | |
| configurable : true, | |
| writable : true, | |
| value : n | |
| }); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| sa.prototype.toString = function() { | |
| return this.a; | |
| }; | |
| var ra = function() { | |
| /** | |
| * @param {string} dir | |
| * @return {?} | |
| */ | |
| function toDest(dir) { | |
| if (this instanceof toDest) { | |
| throw new TypeError("Symbol is not a constructor"); | |
| } | |
| return new sa("jscomp_symbol_" + (dir || "") + "_" + widgetUniqueIDIndex++, dir); | |
| } | |
| /** @type {number} */ | |
| var widgetUniqueIDIndex = 0; | |
| return toDest; | |
| }(); | |
| /** | |
| * @return {undefined} | |
| */ | |
| var ua = function() { | |
| qa(); | |
| var $iterator$ = na.Symbol.iterator; | |
| if (!$iterator$) { | |
| $iterator$ = na.Symbol.iterator = na.Symbol("Symbol.iterator"); | |
| } | |
| if ("function" != typeof Array.prototype[$iterator$]) { | |
| ma(Array.prototype, $iterator$, { | |
| configurable : true, | |
| writable : true, | |
| value : function() { | |
| return ta(aa(this)); | |
| } | |
| }); | |
| } | |
| /** | |
| * @return {undefined} | |
| */ | |
| ua = function() { | |
| }; | |
| }; | |
| /** | |
| * @param {!Object} g | |
| * @return {?} | |
| */ | |
| var ta = function(g) { | |
| ua(); | |
| g = { | |
| next : g | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| g[na.Symbol.iterator] = function() { | |
| return this; | |
| }; | |
| return g; | |
| }; | |
| /** | |
| * @param {string} s | |
| * @param {!Function} f | |
| * @return {?} | |
| */ | |
| var va = function(s, f) { | |
| ua(); | |
| if (s instanceof String) { | |
| /** @type {string} */ | |
| s = s + ""; | |
| } | |
| /** @type {number} */ | |
| var index = 0; | |
| var iterable = { | |
| next : function() { | |
| if (index < s.length) { | |
| /** @type {number} */ | |
| var i = index++; | |
| return { | |
| value : f(i, s[i]), | |
| done : false | |
| }; | |
| } | |
| /** | |
| * @return {?} | |
| */ | |
| iterable.next = function() { | |
| return { | |
| done : true, | |
| value : void 0 | |
| }; | |
| }; | |
| return iterable.next(); | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| iterable[Symbol.iterator] = function() { | |
| return iterable; | |
| }; | |
| return iterable; | |
| }; | |
| oa("Array.prototype.keys", function(position) { | |
| return position ? position : function() { | |
| return va(this, function(b) { | |
| return b; | |
| }); | |
| }; | |
| }); | |
| oa("Array.prototype.values", function(position) { | |
| return position ? position : function() { | |
| return va(this, function(b, canCreateDiscussions) { | |
| return canCreateDiscussions; | |
| }); | |
| }; | |
| }); | |
| oa("Number.parseInt", function(fn) { | |
| return fn || parseInt; | |
| }); | |
| oa("Promise", function(a) { | |
| /** | |
| * @return {undefined} | |
| */ | |
| function b() { | |
| /** @type {null} */ | |
| this.a = null; | |
| } | |
| /** | |
| * @param {?} onSuccess | |
| * @return {?} | |
| */ | |
| function resolve(onSuccess) { | |
| return onSuccess instanceof Promise ? onSuccess : new Promise(function(exec) { | |
| exec(onSuccess); | |
| }); | |
| } | |
| if (a) { | |
| return a; | |
| } | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| b.prototype.b = function(name) { | |
| if (null == this.a) { | |
| /** @type {!Array} */ | |
| this.a = []; | |
| var footerBox = this; | |
| this.c(function() { | |
| footerBox.h(); | |
| }); | |
| } | |
| this.a.push(name); | |
| }; | |
| var i = na.setTimeout; | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| b.prototype.c = function(name) { | |
| i(name, 0); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| b.prototype.h = function() { | |
| for (; this.a && this.a.length;) { | |
| var a = this.a; | |
| /** @type {!Array} */ | |
| this.a = []; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < a.length; ++i) { | |
| var b = a[i]; | |
| /** @type {null} */ | |
| a[i] = null; | |
| try { | |
| b(); | |
| } catch (input) { | |
| this.g(input); | |
| } | |
| } | |
| } | |
| /** @type {null} */ | |
| this.a = null; | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| b.prototype.g = function(name) { | |
| this.c(function() { | |
| throw name; | |
| }); | |
| }; | |
| /** | |
| * @param {?} callback | |
| * @return {undefined} | |
| */ | |
| var Promise = function(callback) { | |
| /** @type {number} */ | |
| this.b = 0; | |
| this.c = void 0; | |
| /** @type {!Array} */ | |
| this.a = []; | |
| var result = this.g(); | |
| try { | |
| callback(result.resolve, result.reject); | |
| } catch (errMsg) { | |
| result.reject(errMsg); | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Promise.prototype.g = function() { | |
| /** | |
| * @param {!Function} n | |
| * @return {?} | |
| */ | |
| function lookup(n) { | |
| return function(family) { | |
| if (!m) { | |
| /** @type {boolean} */ | |
| m = true; | |
| n.call(GIVEN_WHEN_THEN_REGEX, family); | |
| } | |
| }; | |
| } | |
| var GIVEN_WHEN_THEN_REGEX = this; | |
| /** @type {boolean} */ | |
| var m = false; | |
| return { | |
| resolve : lookup(this.C), | |
| reject : lookup(this.h) | |
| }; | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| Promise.prototype.C = function(name) { | |
| if (name === this) { | |
| this.h(new TypeError("A Promise cannot resolve to itself")); | |
| } else { | |
| if (name instanceof Promise) { | |
| this.L(name); | |
| } else { | |
| a: { | |
| switch(typeof name) { | |
| case "object": | |
| /** @type {boolean} */ | |
| var nameChanges = null != name; | |
| break a; | |
| case "function": | |
| /** @type {boolean} */ | |
| nameChanges = true; | |
| break a; | |
| default: | |
| /** @type {boolean} */ | |
| nameChanges = false; | |
| } | |
| } | |
| if (nameChanges) { | |
| this.G(name); | |
| } else { | |
| this.o(name); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| Promise.prototype.G = function(type) { | |
| var name = void 0; | |
| try { | |
| name = type.then; | |
| } catch (incr) { | |
| this.h(incr); | |
| return; | |
| } | |
| if ("function" == typeof name) { | |
| this.K(name, type); | |
| } else { | |
| this.o(type); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| Promise.prototype.h = function(type) { | |
| this.m(2, type); | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| Promise.prototype.o = function(type) { | |
| this.m(1, type); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| Promise.prototype.m = function(name, value) { | |
| if (0 != this.b) { | |
| throw Error("Cannot settle(" + name + ", " + value + "): Promise already settled in state" + this.b); | |
| } | |
| /** @type {string} */ | |
| this.b = name; | |
| /** @type {string} */ | |
| this.c = value; | |
| this.w(); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Promise.prototype.w = function() { | |
| if (null != this.a) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < this.a.length; ++i) { | |
| k.b(this.a[i]); | |
| } | |
| /** @type {null} */ | |
| this.a = null; | |
| } | |
| }; | |
| var k = new b; | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| Promise.prototype.L = function(name) { | |
| var result = this.g(); | |
| name.Df(result.resolve, result.reject); | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| Promise.prototype.K = function(type, value) { | |
| var wrapper = this.g(); | |
| try { | |
| type.call(value, wrapper.resolve, wrapper.reject); | |
| } catch (m) { | |
| wrapper.reject(m); | |
| } | |
| }; | |
| /** | |
| * @param {!Function} a | |
| * @param {!Function} fn | |
| * @return {?} | |
| */ | |
| Promise.prototype.then = function(a, fn) { | |
| /** | |
| * @param {!Function} callback | |
| * @param {(!Function|boolean)} event | |
| * @return {?} | |
| */ | |
| function callback(callback, event) { | |
| return "function" == typeof callback ? function(reason) { | |
| try { | |
| cast(callback(reason)); | |
| } catch (allNewFiles) { | |
| update(allNewFiles); | |
| } | |
| } : event; | |
| } | |
| var cast; | |
| var update; | |
| var thenPromise = new Promise(function(boolean, res) { | |
| cast = boolean; | |
| update = res; | |
| }); | |
| this.Df(callback(a, cast), callback(fn, update)); | |
| return thenPromise; | |
| }; | |
| /** | |
| * @param {undefined} fn | |
| * @return {?} | |
| */ | |
| Promise.prototype.catch = function(fn) { | |
| return this.then(void 0, fn); | |
| }; | |
| /** | |
| * @param {?} l | |
| * @param {?} fn | |
| * @return {undefined} | |
| */ | |
| Promise.prototype.Df = function(l, fn) { | |
| /** | |
| * @return {undefined} | |
| */ | |
| function t() { | |
| switch(a.b) { | |
| case 1: | |
| l(a.c); | |
| break; | |
| case 2: | |
| fn(a.c); | |
| break; | |
| default: | |
| throw Error("Unexpected state: " + a.b); | |
| } | |
| } | |
| var a = this; | |
| if (null == this.a) { | |
| k.b(t); | |
| } else { | |
| this.a.push(t); | |
| } | |
| }; | |
| /** @type {function(?): ?} */ | |
| Promise.resolve = resolve; | |
| /** | |
| * @param {?} reason | |
| * @return {?} | |
| */ | |
| Promise.reject = function(reason) { | |
| return new Promise(function(canCreateDiscussions, reject$2) { | |
| reject$2(reason); | |
| }); | |
| }; | |
| /** | |
| * @param {!Object} context | |
| * @return {?} | |
| */ | |
| Promise.race = function(context) { | |
| return new Promise(function(leftPx, audioOffsetCallback) { | |
| var ret = ba(context); | |
| var result = ret.next(); | |
| for (; !result.done; result = ret.next()) { | |
| resolve(result.value).Df(leftPx, audioOffsetCallback); | |
| } | |
| }); | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| Promise.all = function(b) { | |
| var n2 = ba(b); | |
| var e = n2.next(); | |
| return e.done ? resolve([]) : new Promise(function(setter, audioOffsetCallback) { | |
| /** | |
| * @param {number} index | |
| * @return {?} | |
| */ | |
| function d(index) { | |
| return function(x2) { | |
| result[index] = x2; | |
| w--; | |
| if (0 == w) { | |
| setter(result); | |
| } | |
| }; | |
| } | |
| /** @type {!Array} */ | |
| var result = []; | |
| /** @type {number} */ | |
| var w = 0; | |
| do { | |
| result.push(void 0); | |
| w++; | |
| resolve(e.value).Df(d(result.length - 1), audioOffsetCallback); | |
| e = n2.next(); | |
| } while (!e.done); | |
| }); | |
| }; | |
| return Promise; | |
| }); | |
| oa("Object.is", function(position) { | |
| return position ? position : function(a, b) { | |
| return a === b ? 0 !== a || 1 / a === 1 / b : a !== a && b !== b; | |
| }; | |
| }); | |
| oa("Array.prototype.includes", function(position) { | |
| return position ? position : function(b, index) { | |
| var result = this; | |
| if (result instanceof String) { | |
| /** @type {string} */ | |
| result = String(result); | |
| } | |
| var length = result.length; | |
| index = index || 0; | |
| if (0 > index) { | |
| /** @type {number} */ | |
| index = Math.max(index + length, 0); | |
| } | |
| for (; index < length; index++) { | |
| var a = result[index]; | |
| if (a === b || Object.is(a, b)) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| }; | |
| }); | |
| oa("String.prototype.includes", function(position) { | |
| return position ? position : function(final, startIndex) { | |
| return -1 !== pa(this, final, "includes").indexOf(final, startIndex || 0); | |
| }; | |
| }); | |
| oa("Array.from", function(position) { | |
| return position ? position : function(a, fn, validator) { | |
| fn = null != fn ? fn : function(canCreateDiscussions) { | |
| return canCreateDiscussions; | |
| }; | |
| /** @type {!Array} */ | |
| var values = []; | |
| var tmp = "undefined" != typeof Symbol && Symbol.iterator && a[Symbol.iterator]; | |
| if ("function" == typeof tmp) { | |
| a = tmp.call(a); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; !(tmp = a.next()).done;) { | |
| values.push(fn.call(validator, tmp.value, i++)); | |
| } | |
| } else { | |
| tmp = a.length; | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < tmp; i++) { | |
| values.push(fn.call(validator, a[i], i)); | |
| } | |
| } | |
| return values; | |
| }; | |
| }); | |
| /** | |
| * @param {!Object} proto | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| var wa = function(proto, name) { | |
| return Object.prototype.hasOwnProperty.call(proto, name); | |
| }; | |
| oa("WeakMap", function(TransitionController) { | |
| /** | |
| * @return {undefined} | |
| */ | |
| function Array() { | |
| } | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| function add(name) { | |
| if (!wa(name, style)) { | |
| var node = new Array; | |
| ma(name, style, { | |
| value : node | |
| }); | |
| } | |
| } | |
| /** | |
| * @param {string} key | |
| * @return {undefined} | |
| */ | |
| function wrapObjectMethod(key) { | |
| var original = Object[key]; | |
| if (original) { | |
| /** | |
| * @param {!Object} date | |
| * @return {?} | |
| */ | |
| Object[key] = function(date) { | |
| if (date instanceof Array) { | |
| return date; | |
| } | |
| add(date); | |
| return original(date); | |
| }; | |
| } | |
| } | |
| if (function() { | |
| if (!TransitionController || !Object.seal) { | |
| return false; | |
| } | |
| try { | |
| var h = Object.seal({}); | |
| var m = Object.seal({}); | |
| var c = new TransitionController([[h, 2], [m, 3]]); | |
| if (2 != c.get(h) || 3 != c.get(m)) { | |
| return false; | |
| } | |
| c.delete(h); | |
| c.set(m, 4); | |
| return !c.has(h) && 4 == c.get(m); | |
| } catch (p) { | |
| return false; | |
| } | |
| }()) { | |
| return TransitionController; | |
| } | |
| /** @type {string} */ | |
| var style = "$jscomp_hidden_" + Math.random(); | |
| wrapObjectMethod("freeze"); | |
| wrapObjectMethod("preventExtensions"); | |
| wrapObjectMethod("seal"); | |
| /** @type {number} */ | |
| var buf = 0; | |
| /** | |
| * @param {!Object} b | |
| * @return {undefined} | |
| */ | |
| var g = function(b) { | |
| this.va = (buf = buf + (Math.random() + 1)).toString(); | |
| if (b) { | |
| b = ba(b); | |
| var result; | |
| for (; !(result = b.next()).done;) { | |
| result = result.value; | |
| this.set(result[0], result[1]); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @param {!Object} type | |
| * @return {?} | |
| */ | |
| g.prototype.set = function(name, type) { | |
| add(name); | |
| if (!wa(name, style)) { | |
| throw Error("WeakMap key fail: " + name); | |
| } | |
| /** @type {!Object} */ | |
| name[style][this.va] = type; | |
| return this; | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {?} | |
| */ | |
| g.prototype.get = function(name) { | |
| return wa(name, style) ? name[style][this.va] : void 0; | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {?} | |
| */ | |
| g.prototype.has = function(name) { | |
| return wa(name, style) && wa(name[style], this.va); | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {?} | |
| */ | |
| g.prototype.delete = function(name) { | |
| return wa(name, style) && wa(name[style], this.va) ? delete name[style][this.va] : false; | |
| }; | |
| return g; | |
| }); | |
| oa("Object.values", function(position) { | |
| return position ? position : function(b) { | |
| /** @type {!Array} */ | |
| var bulletList = []; | |
| var i; | |
| for (i in b) { | |
| if (wa(b, i)) { | |
| bulletList.push(b[i]); | |
| } | |
| } | |
| return bulletList; | |
| }; | |
| }); | |
| oa("Map", function(Map) { | |
| if (function() { | |
| if (!Map || "function" != typeof Map || !Map.prototype.entries || "function" != typeof Object.seal) { | |
| return false; | |
| } | |
| try { | |
| var key = Object.seal({ | |
| x : 4 | |
| }); | |
| var map = new Map(ba([[key, "s"]])); | |
| if ("s" != map.get(key) || 1 != map.size || map.get({ | |
| x : 4 | |
| }) || map.set({ | |
| x : 4 | |
| }, "t") != map || 2 != map.size) { | |
| return false; | |
| } | |
| var deletedChar = map.entries(); | |
| var item = deletedChar.next(); | |
| if (item.done || item.value[0] != key || "s" != item.value[1]) { | |
| return false; | |
| } | |
| item = deletedChar.next(); | |
| return item.done || 4 != item.value[0].x || "t" != item.value[1] || !deletedChar.next().done ? false : true; | |
| } catch (t) { | |
| return false; | |
| } | |
| }()) { | |
| return Map; | |
| } | |
| ua(); | |
| /** @type {!WeakMap} */ | |
| var priv = new WeakMap; | |
| /** | |
| * @param {!Object} args | |
| * @return {undefined} | |
| */ | |
| var Map = function(args) { | |
| this.b = {}; | |
| this.a = clear(); | |
| /** @type {number} */ | |
| this.size = 0; | |
| if (args) { | |
| args = ba(args); | |
| var result; | |
| for (; !(result = args.next()).done;) { | |
| result = result.value; | |
| this.set(result[0], result[1]); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {?} name | |
| * @param {!Object} type | |
| * @return {?} | |
| */ | |
| Map.prototype.set = function(name, type) { | |
| name = 0 === name ? 0 : name; | |
| var p = run(this, name); | |
| if (!p.list) { | |
| /** @type {!Array} */ | |
| p.list = this.b[p.id] = []; | |
| } | |
| if (p.Ab) { | |
| /** @type {!Object} */ | |
| p.Ab.value = type; | |
| } else { | |
| p.Ab = { | |
| next : this.a, | |
| Wc : this.a.Wc, | |
| head : this.a, | |
| key : name, | |
| value : type | |
| }; | |
| p.list.push(p.Ab); | |
| this.a.Wc.next = p.Ab; | |
| this.a.Wc = p.Ab; | |
| this.size++; | |
| } | |
| return this; | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @return {?} | |
| */ | |
| Map.prototype.delete = function(data) { | |
| data = run(this, data); | |
| return data.Ab && data.list ? (data.list.splice(data.index, 1), data.list.length || delete this.b[data.id], data.Ab.Wc.next = data.Ab.next, data.Ab.next.Wc = data.Ab.Wc, data.Ab.head = null, this.size--, true) : false; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Map.prototype.clear = function() { | |
| this.b = {}; | |
| this.a = this.a.Wc = clear(); | |
| /** @type {number} */ | |
| this.size = 0; | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {?} | |
| */ | |
| Map.prototype.has = function(name) { | |
| return !!run(this, name).Ab; | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| Map.prototype.get = function(value) { | |
| return (value = run(this, value).Ab) && value.value; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Map.prototype.entries = function() { | |
| return apply(this, function(dataItemObj) { | |
| return [dataItemObj.key, dataItemObj.value]; | |
| }); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Map.prototype.keys = function() { | |
| return apply(this, function(shortcutKeyObject) { | |
| return shortcutKeyObject.key; | |
| }); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Map.prototype.values = function() { | |
| return apply(this, function(select_ele) { | |
| return select_ele.value; | |
| }); | |
| }; | |
| /** | |
| * @param {!Function} fun | |
| * @param {!Object} obj | |
| * @return {undefined} | |
| */ | |
| Map.prototype.forEach = function(fun, obj) { | |
| var entries = this.entries(); | |
| var t; | |
| for (; !(t = entries.next()).done;) { | |
| t = t.value; | |
| fun.call(obj, t[1], t[0], this); | |
| } | |
| }; | |
| /** @type {function(): ?} */ | |
| Map.prototype[Symbol.iterator] = Map.prototype.entries; | |
| /** | |
| * @param {number} index | |
| * @param {!Object} key | |
| * @return {?} | |
| */ | |
| var run = function(index, key) { | |
| var type = key && typeof key; | |
| if ("object" == type || "function" == type) { | |
| if (priv.has(key)) { | |
| type = priv.get(key); | |
| } else { | |
| /** @type {string} */ | |
| type = "" + ++nextGuid; | |
| priv.set(key, type); | |
| } | |
| } else { | |
| /** @type {string} */ | |
| type = "p_" + key; | |
| } | |
| var result = index.b[type]; | |
| if (result && wa(index.b, type)) { | |
| /** @type {number} */ | |
| index = 0; | |
| for (; index < result.length; index++) { | |
| var entry = result[index]; | |
| if (key !== key && entry.key !== entry.key || key === entry.key) { | |
| return { | |
| id : type, | |
| list : result, | |
| index : index, | |
| Ab : entry | |
| }; | |
| } | |
| } | |
| } | |
| return { | |
| id : type, | |
| list : result, | |
| index : -1, | |
| Ab : void 0 | |
| }; | |
| }; | |
| /** | |
| * @param {(number|string)} b | |
| * @param {!Function} callback | |
| * @return {?} | |
| */ | |
| var apply = function(b, callback) { | |
| var a = b.a; | |
| return ta(function() { | |
| if (a) { | |
| for (; a.head != b.a;) { | |
| a = a.Wc; | |
| } | |
| for (; a.next != a.head;) { | |
| return a = a.next, { | |
| done : false, | |
| value : callback(a) | |
| }; | |
| } | |
| /** @type {null} */ | |
| a = null; | |
| } | |
| return { | |
| done : true, | |
| value : void 0 | |
| }; | |
| }); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var clear = function() { | |
| var head = {}; | |
| return head.Wc = head.next = head.head = head; | |
| }; | |
| /** @type {number} */ | |
| var nextGuid = 0; | |
| return Map; | |
| }); | |
| oa("Set", function(fn) { | |
| if (function() { | |
| if (!fn || "function" != typeof fn || !fn.prototype.entries || "function" != typeof Object.seal) { | |
| return false; | |
| } | |
| try { | |
| var value = Object.seal({ | |
| x : 4 | |
| }); | |
| var object = new fn(ba([value])); | |
| if (!object.has(value) || 1 != object.size || object.add(value) != object || 1 != object.size || object.add({ | |
| x : 4 | |
| }) != object || 2 != object.size) { | |
| return false; | |
| } | |
| var deletedChar = object.entries(); | |
| var item = deletedChar.next(); | |
| if (item.done || item.value[0] != value || item.value[1] != value) { | |
| return false; | |
| } | |
| item = deletedChar.next(); | |
| return item.done || item.value[0] == value || 4 != item.value[0].x || item.value[1] != item.value[0] ? false : deletedChar.next().done; | |
| } catch (g) { | |
| return false; | |
| } | |
| }()) { | |
| return fn; | |
| } | |
| ua(); | |
| /** | |
| * @param {!Object} b | |
| * @return {undefined} | |
| */ | |
| var Set = function(b) { | |
| /** @type {!Map} */ | |
| this.Va = new Map; | |
| if (b) { | |
| b = ba(b); | |
| var item; | |
| for (; !(item = b.next()).done;) { | |
| this.add(item.value); | |
| } | |
| } | |
| /** @type {number} */ | |
| this.size = this.Va.size; | |
| }; | |
| /** | |
| * @param {?} key | |
| * @return {?} | |
| */ | |
| Set.prototype.add = function(key) { | |
| key = 0 === key ? 0 : key; | |
| this.Va.set(key, key); | |
| this.size = this.Va.size; | |
| return this; | |
| }; | |
| /** | |
| * @param {!Object} key | |
| * @return {?} | |
| */ | |
| Set.prototype.delete = function(key) { | |
| key = this.Va.delete(key); | |
| this.size = this.Va.size; | |
| return key; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Set.prototype.clear = function() { | |
| this.Va.clear(); | |
| /** @type {number} */ | |
| this.size = 0; | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {?} | |
| */ | |
| Set.prototype.has = function(name) { | |
| return this.Va.has(name); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Set.prototype.entries = function() { | |
| return this.Va.entries(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Set.prototype.values = function() { | |
| return this.Va.values(); | |
| }; | |
| /** @type {function(): ?} */ | |
| Set.prototype.keys = Set.prototype.values; | |
| /** @type {function(): ?} */ | |
| Set.prototype[Symbol.iterator] = Set.prototype.values; | |
| /** | |
| * @param {!Function} self | |
| * @param {!Object} obj | |
| * @return {undefined} | |
| */ | |
| Set.prototype.forEach = function(self, obj) { | |
| var overlayFrag = this; | |
| this.Va.forEach(function(signedAuthToken) { | |
| return self.call(obj, signedAuthToken, signedAuthToken, overlayFrag); | |
| }); | |
| }; | |
| return Set; | |
| }); | |
| var xa = xa || {}; | |
| /** @type {!global this} */ | |
| var l = this || self; | |
| /** | |
| * @param {?} type | |
| * @return {?} | |
| */ | |
| var q = function(type) { | |
| return void 0 !== type; | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {?} | |
| */ | |
| var r = function(type) { | |
| return "string" == typeof type; | |
| }; | |
| /** | |
| * @param {!Object} val | |
| * @return {?} | |
| */ | |
| var ya = function(val) { | |
| return "boolean" == typeof val; | |
| }; | |
| /** | |
| * @param {?} b | |
| * @return {?} | |
| */ | |
| var Aa = function(b) { | |
| return "number" == typeof b; | |
| }; | |
| /** | |
| * @param {string} keys | |
| * @param {(!Function|string)} result | |
| * @return {undefined} | |
| */ | |
| var Ba = function(keys, result) { | |
| keys = keys.split("."); | |
| var ret = l; | |
| if (!(keys[0] in ret || "undefined" == typeof ret.execScript)) { | |
| ret.execScript("var " + keys[0]); | |
| } | |
| var p; | |
| for (; keys.length && (p = keys.shift());) { | |
| if (!keys.length && q(result)) { | |
| /** @type {(!Function|string)} */ | |
| ret[p] = result; | |
| } else { | |
| if (ret[p] && ret[p] !== Object.prototype[p]) { | |
| ret = ret[p]; | |
| } else { | |
| ret = ret[p] = {}; | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {?} p | |
| * @return {?} | |
| */ | |
| var Ea = function(p) { | |
| if (p && p != l) { | |
| return Ca(p.document); | |
| } | |
| if (null === Da) { | |
| Da = Ca(l.document); | |
| } | |
| return Da; | |
| }; | |
| /** @type {!RegExp} */ | |
| var Fa = /^[\w+/_-]+[=]{0,2}$/; | |
| /** @type {null} */ | |
| var Da = null; | |
| /** | |
| * @param {!Object} header | |
| * @return {?} | |
| */ | |
| var Ca = function(header) { | |
| return (header = header.querySelector && header.querySelector("script[nonce]")) && (header = header.nonce || header.getAttribute("nonce")) && Fa.test(header) ? header : ""; | |
| }; | |
| /** | |
| * @param {string} path | |
| * @param {string} end | |
| * @return {?} | |
| */ | |
| var Ga = function(path, end) { | |
| path = path.split("."); | |
| end = end || l; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < path.length; i++) { | |
| if (end = end[path[i]], null == end) { | |
| return null; | |
| } | |
| } | |
| return end; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Ha = function() { | |
| }; | |
| /** | |
| * @param {!Object} x | |
| * @return {undefined} | |
| */ | |
| var Ia = function(x) { | |
| x.Ch = void 0; | |
| /** | |
| * @return {?} | |
| */ | |
| x.N = function() { | |
| return x.Ch ? x.Ch : x.Ch = new x; | |
| }; | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| var Ja = function(value) { | |
| /** @type {string} */ | |
| var s = typeof value; | |
| if ("object" == s) { | |
| if (value) { | |
| if (value instanceof Array) { | |
| return "array"; | |
| } | |
| if (value instanceof Object) { | |
| return s; | |
| } | |
| /** @type {string} */ | |
| var oldCondition = Object.prototype.toString.call(value); | |
| if ("[object Window]" == oldCondition) { | |
| return "object"; | |
| } | |
| if ("[object Array]" == oldCondition || "number" == typeof value.length && "undefined" != typeof value.splice && "undefined" != typeof value.propertyIsEnumerable && !value.propertyIsEnumerable("splice")) { | |
| return "array"; | |
| } | |
| if ("[object Function]" == oldCondition || "undefined" != typeof value.call && "undefined" != typeof value.propertyIsEnumerable && !value.propertyIsEnumerable("call")) { | |
| return "function"; | |
| } | |
| } else { | |
| return "null"; | |
| } | |
| } else { | |
| if ("function" == s && "undefined" == typeof value.call) { | |
| return "object"; | |
| } | |
| } | |
| return s; | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| var Ka = function(value) { | |
| return "array" == Ja(value); | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @return {?} | |
| */ | |
| var La = function(obj) { | |
| var type = Ja(obj); | |
| return "array" == type || "object" == type && "number" == typeof obj.length; | |
| }; | |
| /** | |
| * @param {string} val | |
| * @return {?} | |
| */ | |
| var Ma = function(val) { | |
| return "function" == Ja(val); | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| var Na = function(value) { | |
| /** @type {string} */ | |
| var type = typeof value; | |
| return "object" == type && null != value || "function" == type; | |
| }; | |
| /** | |
| * @param {string} var_args | |
| * @return {?} | |
| */ | |
| var Qa = function(var_args) { | |
| return var_args[Oa] || (var_args[Oa] = ++Pa); | |
| }; | |
| /** @type {string} */ | |
| var Oa = "closure_uid_" + (1E9 * Math.random() >>> 0); | |
| /** @type {number} */ | |
| var Pa = 0; | |
| /** | |
| * @param {!Function} op | |
| * @param {!Object} obj | |
| * @param {string} val | |
| * @return {?} | |
| */ | |
| var Ra = function(op, obj, val) { | |
| return op.call.apply(op.bind, arguments); | |
| }; | |
| /** | |
| * @param {!Function} key | |
| * @param {!Object} arr | |
| * @param {string} val | |
| * @return {?} | |
| */ | |
| var Sa = function(key, arr, val) { | |
| if (!key) { | |
| throw Error(); | |
| } | |
| if (2 < arguments.length) { | |
| /** @type {!Array<?>} */ | |
| var cmd_args = Array.prototype.slice.call(arguments, 2); | |
| return function() { | |
| /** @type {!Array<?>} */ | |
| var cookie = Array.prototype.slice.call(arguments); | |
| Array.prototype.unshift.apply(cookie, cmd_args); | |
| return key.apply(arr, cookie); | |
| }; | |
| } | |
| return function() { | |
| return key.apply(arr, arguments); | |
| }; | |
| }; | |
| /** | |
| * @param {!Function} key | |
| * @param {!Object} obj | |
| * @param {string} val | |
| * @return {?} | |
| */ | |
| var v = function(key, obj, val) { | |
| if (Function.prototype.bind && -1 != Function.prototype.bind.toString().indexOf("native code")) { | |
| /** @type {function(!Function, !Object, string): ?} */ | |
| v = Ra; | |
| } else { | |
| /** @type {function(!Function, !Object, string): ?} */ | |
| v = Sa; | |
| } | |
| return v.apply(null, arguments); | |
| }; | |
| /** | |
| * @param {!Function} name | |
| * @param {?} num | |
| * @return {?} | |
| */ | |
| var Ta = function(name, num) { | |
| /** @type {!Array<?>} */ | |
| var c = Array.prototype.slice.call(arguments, 1); | |
| return function() { | |
| /** @type {!Array<?>} */ | |
| var word = c.slice(); | |
| word.push.apply(word, arguments); | |
| return name.apply(this, word); | |
| }; | |
| }; | |
| /** @type {function(): number} */ | |
| var Ua = Date.now || function() { | |
| return +new Date; | |
| }; | |
| /** | |
| * @param {!Function} x | |
| * @param {!Function} name | |
| * @return {undefined} | |
| */ | |
| var x = function(x, name) { | |
| /** | |
| * @return {undefined} | |
| */ | |
| function Date() { | |
| } | |
| Date.prototype = name.prototype; | |
| x.D = name.prototype; | |
| x.prototype = new Date; | |
| /** @type {!Function} */ | |
| x.prototype.constructor = x; | |
| /** | |
| * @param {?} cmds | |
| * @param {?} options | |
| * @param {?} f | |
| * @return {?} | |
| */ | |
| x.vs = function(cmds, options, f) { | |
| /** @type {!Array} */ | |
| var args = Array(arguments.length - 2); | |
| /** @type {number} */ | |
| var i = 2; | |
| for (; i < arguments.length; i++) { | |
| args[i - 2] = arguments[i]; | |
| } | |
| return name.prototype[options].apply(cmds, args); | |
| }; | |
| }; | |
| /** | |
| * @param {?} opt_msg | |
| * @return {undefined} | |
| */ | |
| var Va = function(opt_msg) { | |
| if (Error.captureStackTrace) { | |
| Error.captureStackTrace(this, Va); | |
| } else { | |
| /** @type {string} */ | |
| var stack = Error().stack; | |
| if (stack) { | |
| /** @type {string} */ | |
| this.stack = stack; | |
| } | |
| } | |
| if (opt_msg) { | |
| /** @type {string} */ | |
| this.message = String(opt_msg); | |
| } | |
| }; | |
| x(Va, Error); | |
| /** @type {string} */ | |
| Va.prototype.name = "CustomError"; | |
| var Wa; | |
| /** | |
| * @param {string} list | |
| * @param {!NodeList} values | |
| * @return {undefined} | |
| */ | |
| var Xa = function(list, values) { | |
| list = list.split("%s"); | |
| /** @type {string} */ | |
| var name = ""; | |
| /** @type {number} */ | |
| var ext = list.length - 1; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < ext; i++) { | |
| /** @type {string} */ | |
| name = name + (list[i] + (i < values.length ? values[i] : "%s")); | |
| } | |
| Va.call(this, name + list[ext]); | |
| }; | |
| x(Xa, Va); | |
| /** @type {string} */ | |
| Xa.prototype.name = "AssertionError"; | |
| /** | |
| * @param {string} tag | |
| * @param {?} indent | |
| * @param {string} key | |
| * @param {number} prop | |
| * @return {undefined} | |
| */ | |
| var Ya = function(tag, indent, key, prop) { | |
| /** @type {string} */ | |
| var result = "Assertion failed"; | |
| if (key) { | |
| /** @type {string} */ | |
| result = result + (": " + key); | |
| /** @type {number} */ | |
| var k = prop; | |
| } else { | |
| if (tag) { | |
| /** @type {string} */ | |
| result = result + (": " + tag); | |
| k = indent; | |
| } | |
| } | |
| throw new Xa("" + result, k || []); | |
| }; | |
| /** | |
| * @param {string} value | |
| * @param {string} input | |
| * @param {!Object} i | |
| * @return {?} | |
| */ | |
| var z = function(value, input, i) { | |
| if (!value) { | |
| Ya("", null, input, Array.prototype.slice.call(arguments, 2)); | |
| } | |
| return value; | |
| }; | |
| /** | |
| * @param {string} opt_message | |
| * @param {!Object} var_args | |
| * @return {?} | |
| */ | |
| var Za = function(opt_message, var_args) { | |
| throw new Xa("Failure" + (opt_message ? ": " + opt_message : ""), Array.prototype.slice.call(arguments, 1)); | |
| }; | |
| /** | |
| * @param {?} a | |
| * @param {string} b | |
| * @param {?} cb | |
| * @return {?} | |
| */ | |
| var ab = function(a, b, cb) { | |
| if (!Aa(a)) { | |
| Ya("Expected number but got %s: %s.", [Ja(a), a], b, Array.prototype.slice.call(arguments, 2)); | |
| } | |
| return a; | |
| }; | |
| /** | |
| * @param {!Object} key | |
| * @param {string} w | |
| * @param {?} s | |
| * @return {?} | |
| */ | |
| var bb = function(key, w, s) { | |
| if (!r(key)) { | |
| Ya("Expected string but got %s: %s.", [Ja(key), key], w, Array.prototype.slice.call(arguments, 2)); | |
| } | |
| return key; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {string} f | |
| * @param {?} er | |
| * @return {?} | |
| */ | |
| var cb = function(a, f, er) { | |
| if (!Ma(a)) { | |
| Ya("Expected function but got %s: %s.", [Ja(a), a], f, Array.prototype.slice.call(arguments, 2)); | |
| } | |
| return a; | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @param {string} f | |
| * @param {?} size | |
| * @return {?} | |
| */ | |
| var db = function(name, f, size) { | |
| if (!Na(name)) { | |
| Ya("Expected object but got %s: %s.", [Ja(name), name], f, Array.prototype.slice.call(arguments, 2)); | |
| } | |
| return name; | |
| }; | |
| /** | |
| * @param {!Object} input | |
| * @param {string} message | |
| * @param {?} errorValue | |
| * @return {?} | |
| */ | |
| var eb = function(input, message, errorValue) { | |
| if (!Ka(input)) { | |
| Ya("Expected array but got %s: %s.", [Ja(input), input], message, Array.prototype.slice.call(arguments, 2)); | |
| } | |
| return input; | |
| }; | |
| /** | |
| * @param {!Object} Y | |
| * @param {string} X | |
| * @param {?} options | |
| * @return {?} | |
| */ | |
| var fb = function(Y, X, options) { | |
| if (!ya(Y)) { | |
| Ya("Expected boolean but got %s: %s.", [Ja(Y), Y], X, Array.prototype.slice.call(arguments, 2)); | |
| } | |
| return Y; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} b | |
| * @param {?} variableNames | |
| * @return {?} | |
| */ | |
| var gb = function(a, b, variableNames) { | |
| if (!(Na(a) && 1 == a.nodeType)) { | |
| Ya("Expected Element but got %s: %s.", [Ja(a), a], b, Array.prototype.slice.call(arguments, 2)); | |
| } | |
| return a; | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @param {!Function} name | |
| * @param {string} n | |
| * @param {?} rn | |
| * @return {?} | |
| */ | |
| var ib = function(node, name, n, rn) { | |
| if (!(node instanceof name)) { | |
| Ya("Expected instanceof %s but got %s.", [hb(name), hb(node)], n, Array.prototype.slice.call(arguments, 3)); | |
| } | |
| return node; | |
| }; | |
| /** | |
| * @param {!Object} object | |
| * @return {?} | |
| */ | |
| var hb = function(object) { | |
| return object instanceof Function ? object.displayName || object.name || "unknown type name" : object instanceof Object ? object.constructor.displayName || object.constructor.name || Object.prototype.toString.call(object) : null === object ? "null" : typeof object; | |
| }; | |
| /** | |
| * @param {!Object} currentA | |
| * @return {?} | |
| */ | |
| var jb = function(currentA) { | |
| return currentA[currentA.length - 1]; | |
| }; | |
| /** @type {function(!Array, !Object): ?} */ | |
| var kb = Array.prototype.indexOf ? function(a, val) { | |
| z(null != a.length); | |
| return Array.prototype.indexOf.call(a, val, void 0); | |
| } : function(target, val) { | |
| if (r(target)) { | |
| return r(val) && 1 == val.length ? target.indexOf(val, 0) : -1; | |
| } | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < target.length; i++) { | |
| if (i in target && target[i] === val) { | |
| return i; | |
| } | |
| } | |
| return -1; | |
| }; | |
| /** @type {function(!Object, !Function, !Function): undefined} */ | |
| var A = Array.prototype.forEach ? function(key, newChild, a) { | |
| z(null != key.length); | |
| Array.prototype.forEach.call(key, newChild, a); | |
| } : function(key, b, a) { | |
| var ll = key.length; | |
| var t = r(key) ? key.split("") : key; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < ll; i++) { | |
| if (i in t) { | |
| b.call(a, t[i], i, key); | |
| } | |
| } | |
| }; | |
| /** @type {function(!Array, !Function): ?} */ | |
| var lb = Array.prototype.filter ? function(url, p1__3354_SHARP_) { | |
| z(null != url.length); | |
| return Array.prototype.filter.call(url, p1__3354_SHARP_, void 0); | |
| } : function(path, fn) { | |
| var length = path.length; | |
| /** @type {!Array} */ | |
| var d = []; | |
| /** @type {number} */ | |
| var e = 0; | |
| var value = r(path) ? path.split("") : path; | |
| /** @type {number} */ | |
| var key = 0; | |
| for (; key < length; key++) { | |
| if (key in value) { | |
| var val = value[key]; | |
| if (fn.call(void 0, val, key, path)) { | |
| d[e++] = val; | |
| } | |
| } | |
| } | |
| return d; | |
| }; | |
| /** @type {function(!Object, !Function, !Object): ?} */ | |
| var mb = Array.prototype.map ? function(obj, container, name) { | |
| z(null != obj.length); | |
| return Array.prototype.map.call(obj, container, name); | |
| } : function(data, fn, thisp) { | |
| var length = data.length; | |
| /** @type {!Array} */ | |
| var result = Array(length); | |
| var a = r(data) ? data.split("") : data; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < length; i++) { | |
| if (i in a) { | |
| result[i] = fn.call(thisp, a[i], i, data); | |
| } | |
| } | |
| return result; | |
| }; | |
| /** @type {function(!Object, !Function, boolean): ?} */ | |
| var nb = Array.prototype.reduce ? function(moduleName, p1__3354_SHARP_, refC) { | |
| z(null != moduleName.length); | |
| return Array.prototype.reduce.call(moduleName, p1__3354_SHARP_, refC); | |
| } : function(data, fn, jpegEncoded) { | |
| /** @type {boolean} */ | |
| var result = jpegEncoded; | |
| A(data, function(elem, i) { | |
| result = fn.call(void 0, result, elem, i, data); | |
| }); | |
| return result; | |
| }; | |
| /** @type {function(!NodeList, !Function): ?} */ | |
| var ob = Array.prototype.some ? function(a, p1__3354_SHARP_) { | |
| z(null != a.length); | |
| return Array.prototype.some.call(a, p1__3354_SHARP_, void 0); | |
| } : function(arr, f) { | |
| var arrSize = arr.length; | |
| var arr2 = r(arr) ? arr.split("") : arr; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < arrSize; i++) { | |
| if (i in arr2 && f.call(void 0, arr2[i], i, arr)) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| }; | |
| /** @type {function(!Array, !Function): ?} */ | |
| var pb = Array.prototype.every ? function(obj, p1__3354_SHARP_) { | |
| z(null != obj.length); | |
| return Array.prototype.every.call(obj, p1__3354_SHARP_, void 0); | |
| } : function(path, fn) { | |
| var length = path.length; | |
| var keys = r(path) ? path.split("") : path; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < length; i++) { | |
| if (i in keys && !fn.call(void 0, keys[i], i, path)) { | |
| return false; | |
| } | |
| } | |
| return true; | |
| }; | |
| /** | |
| * @param {!Object} s | |
| * @param {!Function} e | |
| * @return {?} | |
| */ | |
| var qb = function(s, e) { | |
| /** @type {number} */ | |
| var c = 0; | |
| A(s, function(change, b, data) { | |
| if (e.call(void 0, change, b, data)) { | |
| ++c; | |
| } | |
| }, void 0); | |
| return c; | |
| }; | |
| /** | |
| * @param {!Object} arr | |
| * @param {number} x | |
| * @return {?} | |
| */ | |
| var rb = function(arr, x) { | |
| a: { | |
| var arrSize = arr.length; | |
| var arr2 = r(arr) ? arr.split("") : arr; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < arrSize; i++) { | |
| if (i in arr2 && x.call(void 0, arr2[i], i, arr)) { | |
| /** @type {number} */ | |
| x = i; | |
| break a; | |
| } | |
| } | |
| /** @type {number} */ | |
| x = -1; | |
| } | |
| return 0 > x ? null : r(arr) ? arr.charAt(x) : arr[x]; | |
| }; | |
| /** | |
| * @param {string} object | |
| * @param {number} callback | |
| * @return {?} | |
| */ | |
| var sb = function(object, callback) { | |
| a: { | |
| var arraylike = r(object) ? object.split("") : object; | |
| /** @type {number} */ | |
| var index = object.length - 1; | |
| for (; 0 <= index; index--) { | |
| if (index in arraylike && callback.call(void 0, arraylike[index], index, object)) { | |
| /** @type {number} */ | |
| callback = index; | |
| break a; | |
| } | |
| } | |
| /** @type {number} */ | |
| callback = -1; | |
| } | |
| return 0 > callback ? null : r(object) ? object.charAt(callback) : object[callback]; | |
| }; | |
| /** | |
| * @param {!Array} data | |
| * @param {!Object} func | |
| * @return {?} | |
| */ | |
| var tb = function(data, func) { | |
| return 0 <= kb(data, func); | |
| }; | |
| /** | |
| * @param {!Array} a | |
| * @param {!Array} b | |
| * @return {undefined} | |
| */ | |
| var ub = function(a, b) { | |
| if (!tb(a, b)) { | |
| a.push(b); | |
| } | |
| }; | |
| /** | |
| * @param {!Array} size | |
| * @param {number} value | |
| * @return {?} | |
| */ | |
| var xb = function(size, value) { | |
| value = kb(size, value); | |
| var condition; | |
| if (condition = 0 <= value) { | |
| wb(size, value); | |
| } | |
| return condition; | |
| }; | |
| /** | |
| * @param {!Array} d | |
| * @param {number} precision | |
| * @return {undefined} | |
| */ | |
| var wb = function(d, precision) { | |
| z(null != d.length); | |
| Array.prototype.splice.call(d, precision, 1); | |
| }; | |
| /** | |
| * @param {!Array} end_time | |
| * @return {?} | |
| */ | |
| var yb = function(end_time) { | |
| return Array.prototype.concat.apply([], arguments); | |
| }; | |
| /** | |
| * @param {?} strip1 | |
| * @return {?} | |
| */ | |
| var zb = function(strip1) { | |
| return Array.prototype.concat.apply([], arguments); | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @return {?} | |
| */ | |
| var Ab = 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} array | |
| * @param {!Object} key | |
| * @return {undefined} | |
| */ | |
| var Bb = function(array, key) { | |
| /** @type {number} */ | |
| var i = 1; | |
| for (; i < arguments.length; i++) { | |
| var a = arguments[i]; | |
| if (La(a)) { | |
| var start = array.length || 0; | |
| var add = a.length || 0; | |
| array.length = start + add; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < add; i++) { | |
| array[start + i] = a[i]; | |
| } | |
| } else { | |
| array.push(a); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!NodeList} db | |
| * @param {?} config | |
| * @param {number} options | |
| * @param {!Function} path | |
| * @return {undefined} | |
| */ | |
| var Db = function(db, config, options, path) { | |
| z(null != db.length); | |
| Array.prototype.splice.apply(db, Cb(arguments, 1)); | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @param {number} indent | |
| * @param {?} settings | |
| * @return {?} | |
| */ | |
| var Cb = function(obj, indent, settings) { | |
| z(null != obj.length); | |
| return 2 >= arguments.length ? Array.prototype.slice.call(obj, indent) : Array.prototype.slice.call(obj, indent, settings); | |
| }; | |
| /** | |
| * @param {!Object} code | |
| * @param {!Function} opts | |
| * @return {?} | |
| */ | |
| var Eb = function(code, opts) { | |
| return yb.apply([], mb(code, opts, void 0)); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| var Hb = function(a) { | |
| var b = Fb(a); | |
| if (b && (!a || !(a instanceof b.Location) && a instanceof b.Element)) { | |
| Za("Argument is not a Location (or a non-Element mock); got: %s", Gb(a)); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} obj | |
| * @return {undefined} | |
| */ | |
| var Ib = function(a, obj) { | |
| var b = Fb(a); | |
| if (b && "undefined" != typeof b[obj]) { | |
| if (!(a && (a instanceof b[obj] || !(a instanceof b.Location || a instanceof b.Element)))) { | |
| Za("Argument is not a %s (or a non-Element, non-Location mock); got: %s", obj, Gb(a)); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Array} value | |
| * @return {?} | |
| */ | |
| var Gb = function(value) { | |
| if (Na(value)) { | |
| try { | |
| return value.constructor.displayName || value.constructor.name || Object.prototype.toString.call(value); | |
| } catch (b) { | |
| return "<object could not be stringified>"; | |
| } | |
| } else { | |
| return void 0 === value ? "undefined" : null === value ? "null" : typeof value; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} elem | |
| * @return {?} | |
| */ | |
| var Fb = function(elem) { | |
| try { | |
| var doc = elem && elem.ownerDocument; | |
| var win = doc && (doc.defaultView || doc.parentWindow); | |
| win = win || l; | |
| if (win.Element && win.Location) { | |
| return win; | |
| } | |
| } catch (d) { | |
| } | |
| return null; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var Jb = function() { | |
| return null; | |
| }; | |
| /** | |
| * @param {!Function} KPIComponentCore | |
| * @return {?} | |
| */ | |
| var Kb = function(KPIComponentCore) { | |
| /** @type {number} */ | |
| var b = b || 0; | |
| return function() { | |
| return KPIComponentCore.apply(this, Array.prototype.slice.call(arguments, 0, b)); | |
| }; | |
| }; | |
| /** | |
| * @param {!Function} tag | |
| * @return {?} | |
| */ | |
| var Lb = function(tag) { | |
| /** @type {boolean} */ | |
| var b = false; | |
| var child; | |
| return function() { | |
| if (!b) { | |
| child = tag(); | |
| /** @type {boolean} */ | |
| b = true; | |
| } | |
| return child; | |
| }; | |
| }; | |
| /** | |
| * @param {!Object} c | |
| * @param {!Function} b | |
| * @param {!Object} t | |
| * @return {undefined} | |
| */ | |
| var Mb = function(c, b, t) { | |
| var id; | |
| for (id in c) { | |
| b.call(t, c[id], id, c); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Function} f | |
| * @return {?} | |
| */ | |
| var Nb = function(a, f) { | |
| var i; | |
| for (i in a) { | |
| if (f.call(void 0, a[i], i, a)) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @return {?} | |
| */ | |
| var Ob = function(data) { | |
| /** @type {!Array} */ | |
| var indexedRows = []; | |
| /** @type {number} */ | |
| var callbackCount = 0; | |
| var i; | |
| for (i in data) { | |
| indexedRows[callbackCount++] = data[i]; | |
| } | |
| return indexedRows; | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @return {?} | |
| */ | |
| var Pb = function(o) { | |
| /** @type {!Array} */ | |
| var bBag = []; | |
| /** @type {number} */ | |
| var callbackCount = 0; | |
| var i; | |
| for (i in o) { | |
| /** @type {string} */ | |
| bBag[callbackCount++] = i; | |
| } | |
| return bBag; | |
| }; | |
| /** | |
| * @param {!Object} menu | |
| * @param {string} type | |
| * @return {?} | |
| */ | |
| var Qb = function(menu, type) { | |
| return null !== menu && type in menu; | |
| }; | |
| /** | |
| * @param {!Object} val | |
| * @param {string} key | |
| * @return {?} | |
| */ | |
| var Rb = function(val, key) { | |
| var k; | |
| for (k in val) { | |
| if (val[k] == key) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var Tb = function() { | |
| var a = Sb; | |
| var j; | |
| for (j in a) { | |
| return false; | |
| } | |
| return true; | |
| }; | |
| /** | |
| * @param {!Object} feature | |
| * @param {string} id | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| var Ub = function(feature, id, type) { | |
| if (null !== feature && id in feature) { | |
| throw Error('The object already contains the key "' + id + '"'); | |
| } | |
| /** @type {!Object} */ | |
| feature[id] = type; | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| var Vb = function(value) { | |
| var valueCopy = {}; | |
| var i; | |
| for (i in value) { | |
| valueCopy[i] = value[i]; | |
| } | |
| return valueCopy; | |
| }; | |
| /** @type {!Array<string>} */ | |
| var Wb = "constructor hasOwnProperty isPrototypeOf propertyIsEnumerable toLocaleString toString valueOf".split(" "); | |
| /** | |
| * @param {!Object} obj | |
| * @param {!Object} data | |
| * @return {undefined} | |
| */ | |
| var Xb = function(obj, data) { | |
| 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 < Wb.length; jX++) { | |
| j = Wb[jX]; | |
| if (Object.prototype.hasOwnProperty.call(a, j)) { | |
| obj[j] = a[j]; | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {?} a | |
| * @return {?} | |
| */ | |
| var Yb = function(a) { | |
| /** @type {number} */ | |
| var argl = arguments.length; | |
| if (1 == argl && Ka(arguments[0])) { | |
| return Yb.apply(null, arguments[0]); | |
| } | |
| if (argl % 2) { | |
| throw Error("Uneven number of arguments"); | |
| } | |
| var rv = {}; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < argl; i = i + 2) { | |
| rv[arguments[i]] = arguments[i + 1]; | |
| } | |
| return rv; | |
| }; | |
| /** | |
| * @param {!Array} obj | |
| * @return {?} | |
| */ | |
| var Zb = function(obj) { | |
| /** @type {number} */ | |
| var argl = arguments.length; | |
| if (1 == argl && Ka(arguments[0])) { | |
| return Zb.apply(null, arguments[0]); | |
| } | |
| var LANGUAGES = {}; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < argl; i++) { | |
| /** @type {boolean} */ | |
| LANGUAGES[arguments[i]] = true; | |
| } | |
| return LANGUAGES; | |
| }; | |
| var $b = { | |
| 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 | |
| }; | |
| /** | |
| * @param {?} options | |
| * @param {!Function} value | |
| * @return {undefined} | |
| */ | |
| var cc = function(options, value) { | |
| this.a = options === ac && value || ""; | |
| this.b = bc; | |
| }; | |
| /** @type {boolean} */ | |
| cc.prototype.Gc = true; | |
| /** | |
| * @return {?} | |
| */ | |
| cc.prototype.Db = function() { | |
| return this.a; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| cc.prototype.toString = function() { | |
| return "Const{" + this.a + "}"; | |
| }; | |
| /** | |
| * @param {!Object} val | |
| * @return {?} | |
| */ | |
| var dc = function(val) { | |
| if (val instanceof cc && val.constructor === cc && val.b === bc) { | |
| return val.a; | |
| } | |
| Za("expected object of type Const, got '" + val + "'"); | |
| return "type_error:Const"; | |
| }; | |
| /** | |
| * @param {string} b | |
| * @return {?} | |
| */ | |
| var ec = function(b) { | |
| return new cc(ac, b); | |
| }; | |
| var bc = {}; | |
| var ac = {}; | |
| var fc = ec(""); | |
| /** @type {!RegExp} */ | |
| var gc = /[A-Za-z\u00c0-\u00d6\u00d8-\u00f6\u00f8-\u02b8\u0300-\u0590\u0900-\u1fff\u200e\u2c00-\ud801\ud804-\ud839\ud83c-\udbff\uf900-\ufb1c\ufe00-\ufe6f\ufefd-\uffff]/; | |
| /** @type {!RegExp} */ | |
| var hc = /^[^A-Za-z\u00c0-\u00d6\u00d8-\u00f6\u00f8-\u02b8\u0300-\u0590\u0900-\u1fff\u200e\u2c00-\ud801\ud804-\ud839\ud83c-\udbff\uf900-\ufb1c\ufe00-\ufe6f\ufefd-\uffff]*[\u0591-\u06ef\u06fa-\u08ff\u200f\ud802-\ud803\ud83a-\ud83b\ufb1d-\ufdff\ufe70-\ufefc]/; | |
| /** @type {!RegExp} */ | |
| var ic = /^http:\/\/.*/; | |
| /** @type {!RegExp} */ | |
| var jc = /^(ar|ckb|dv|he|iw|fa|nqo|ps|sd|ug|ur|yi|.*[-_](Adlm|Arab|Hebr|Nkoo|Rohg|Thaa))(?!.*[-_](Latn|Cyrl)($|-|_))($|-|_)/i; | |
| /** | |
| * @param {!Array} str | |
| * @return {?} | |
| */ | |
| var kc = function(str) { | |
| return jc.test(str); | |
| }; | |
| /** @type {!RegExp} */ | |
| var lc = /\s+/; | |
| /** @type {!RegExp} */ | |
| var mc = /[\d\u06f0-\u06f9]/; | |
| /** | |
| * @param {string} value | |
| * @return {?} | |
| */ | |
| var nc = function(value) { | |
| /** @type {number} */ | |
| var touchStretch = 0; | |
| /** @type {number} */ | |
| var been_met = 0; | |
| /** @type {boolean} */ | |
| var screenName = false; | |
| value = value.split(lc); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < value.length; i++) { | |
| var string = value[i]; | |
| if (hc.test(string)) { | |
| touchStretch++; | |
| been_met++; | |
| } else { | |
| if (ic.test(string)) { | |
| /** @type {boolean} */ | |
| screenName = true; | |
| } else { | |
| if (gc.test(string)) { | |
| been_met++; | |
| } else { | |
| if (mc.test(string)) { | |
| /** @type {boolean} */ | |
| screenName = true; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| return -1 == (0 == been_met ? screenName ? 1 : 0 : .4 < touchStretch / been_met ? -1 : 1); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var pc = function() { | |
| /** @type {string} */ | |
| this.a = ""; | |
| this.b = oc; | |
| }; | |
| k = pc.prototype; | |
| /** @type {boolean} */ | |
| k.Gc = true; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Db = function() { | |
| return this.a.toString(); | |
| }; | |
| /** @type {boolean} */ | |
| k.Ah = true; | |
| /** | |
| * @return {?} | |
| */ | |
| k.fd = function() { | |
| return 1; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.toString = function() { | |
| return "TrustedResourceUrl{" + this.a + "}"; | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {?} | |
| */ | |
| var rc = function(name) { | |
| return qc(name).toString(); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var qc = function(a) { | |
| if (a instanceof pc && a.constructor === pc && a.b === oc) { | |
| return a.a; | |
| } | |
| Za("expected object of type TrustedResourceUrl, got '" + a + "' of type " + Ja(a)); | |
| return "type_error:TrustedResourceUrl"; | |
| }; | |
| /** @type {!RegExp} */ | |
| var sc = /^([^?#]*)(\?[^#]*)?(#[\s\S]*)?/; | |
| var oc = {}; | |
| /** | |
| * @param {number} key | |
| * @return {?} | |
| */ | |
| var tc = function(key) { | |
| var shobj = new pc; | |
| /** @type {number} */ | |
| shobj.a = key; | |
| return shobj; | |
| }; | |
| /** | |
| * @param {string} prefix | |
| * @param {string} name | |
| * @param {string} val | |
| * @return {?} | |
| */ | |
| var uc = function(prefix, name, val) { | |
| if (null == val) { | |
| return name; | |
| } | |
| if (r(val)) { | |
| return val ? prefix + encodeURIComponent(val) : ""; | |
| } | |
| var s; | |
| for (s in val) { | |
| var v = val[s]; | |
| v = Ka(v) ? v : [v]; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < v.length; i++) { | |
| var value = v[i]; | |
| if (null != value) { | |
| if (!name) { | |
| /** @type {string} */ | |
| name = prefix; | |
| } | |
| /** @type {string} */ | |
| name = name + ((name.length > prefix.length ? "&" : "") + encodeURIComponent(s) + "=" + encodeURIComponent(String(value))); | |
| } | |
| } | |
| } | |
| return name; | |
| }; | |
| /** | |
| * @param {string} value | |
| * @param {string} prefix | |
| * @return {?} | |
| */ | |
| var vc = function(value, prefix) { | |
| return 0 == value.lastIndexOf(prefix, 0); | |
| }; | |
| /** | |
| * @param {string} v | |
| * @param {string} n | |
| * @return {?} | |
| */ | |
| var wc = function(v, n) { | |
| /** @type {number} */ | |
| var key = v.length - n.length; | |
| return 0 <= key && v.indexOf(n, key) == key; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {?} | |
| */ | |
| var xc = function(a) { | |
| return /^[\s\xa0]*$/.test(a); | |
| }; | |
| /** @type {function(string): ?} */ | |
| var zc = String.prototype.trim ? function(a) { | |
| return a.trim(); | |
| } : function(a) { | |
| return /^[\s\xa0]*([\s\S]*?)[\s\xa0]*$/.exec(a)[1]; | |
| }; | |
| /** | |
| * @param {string} b | |
| * @param {string} a | |
| * @return {?} | |
| */ | |
| var Ac = function(b, a) { | |
| /** @type {string} */ | |
| b = String(b).toLowerCase(); | |
| /** @type {string} */ | |
| a = String(a).toLowerCase(); | |
| return b < a ? -1 : b == a ? 0 : 1; | |
| }; | |
| /** | |
| * @param {string} commaParam | |
| * @return {?} | |
| */ | |
| var Bc = function(commaParam) { | |
| return commaParam.replace(/(\r\n|\r|\n)/g, "<br>"); | |
| }; | |
| /** | |
| * @param {!Object} root | |
| * @param {!Object} progression | |
| * @return {?} | |
| */ | |
| var Jc = function(root, progression) { | |
| if (progression) { | |
| root = root.replace(Cc, "&").replace(Dc, "<").replace(Ec, ">").replace(Fc, """).replace(Gc, "'").replace(Hc, "�"); | |
| } else { | |
| if (!Ic.test(root)) { | |
| return root; | |
| } | |
| if (-1 != root.indexOf("&")) { | |
| root = root.replace(Cc, "&"); | |
| } | |
| if (-1 != root.indexOf("<")) { | |
| root = root.replace(Dc, "<"); | |
| } | |
| if (-1 != root.indexOf(">")) { | |
| root = root.replace(Ec, ">"); | |
| } | |
| if (-1 != root.indexOf('"')) { | |
| root = root.replace(Fc, """); | |
| } | |
| if (-1 != root.indexOf("'")) { | |
| root = root.replace(Gc, "'"); | |
| } | |
| if (-1 != root.indexOf("\x00")) { | |
| root = root.replace(Hc, "�"); | |
| } | |
| } | |
| return root; | |
| }; | |
| /** @type {!RegExp} */ | |
| var Cc = /&/g; | |
| /** @type {!RegExp} */ | |
| var Dc = /</g; | |
| /** @type {!RegExp} */ | |
| var Ec = />/g; | |
| /** @type {!RegExp} */ | |
| var Fc = /"/g; | |
| /** @type {!RegExp} */ | |
| var Gc = /'/g; | |
| /** @type {!RegExp} */ | |
| var Hc = /\x00/g; | |
| /** @type {!RegExp} */ | |
| var Ic = /[\x00&<>"']/; | |
| /** | |
| * @param {string} type | |
| * @param {string} str | |
| * @return {?} | |
| */ | |
| var Kc = function(type, str) { | |
| return -1 != type.indexOf(str); | |
| }; | |
| /** | |
| * @param {string} prefix | |
| * @return {?} | |
| */ | |
| var Mc = function(prefix) { | |
| return Kc(Lc.toLowerCase(), prefix.toLowerCase()); | |
| }; | |
| /** | |
| * @param {string} field | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var Oc = function(field, a) { | |
| /** @type {number} */ | |
| var center = 0; | |
| field = zc(String(field)).split("."); | |
| a = zc(String(a)).split("."); | |
| /** @type {number} */ | |
| var numlabels = Math.max(field.length, a.length); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; 0 == center && i < numlabels; i++) { | |
| var value = field[i] || ""; | |
| var url = a[i] || ""; | |
| do { | |
| /** @type {!Array} */ | |
| value = /(\d*)(\D*)(.*)/.exec(value) || ["", "", "", ""]; | |
| /** @type {!Array} */ | |
| url = /(\d*)(\D*)(.*)/.exec(url) || ["", "", "", ""]; | |
| if (0 == value[0].length && 0 == url[0].length) { | |
| break; | |
| } | |
| center = Nc(0 == value[1].length ? 0 : parseInt(value[1], 10), 0 == url[1].length ? 0 : parseInt(url[1], 10)) || Nc(0 == value[2].length, 0 == url[2].length) || Nc(value[2], url[2]); | |
| value = value[3]; | |
| url = url[3]; | |
| } while (0 == center); | |
| } | |
| return center; | |
| }; | |
| /** | |
| * @param {number} a | |
| * @param {number} b | |
| * @return {?} | |
| */ | |
| var Nc = function(a, b) { | |
| return a < b ? -1 : a > b ? 1 : 0; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Qc = function() { | |
| /** @type {string} */ | |
| this.a = ""; | |
| this.b = Pc; | |
| }; | |
| k = Qc.prototype; | |
| /** @type {boolean} */ | |
| k.Gc = true; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Db = function() { | |
| return this.a.toString(); | |
| }; | |
| /** @type {boolean} */ | |
| k.Ah = true; | |
| /** | |
| * @return {?} | |
| */ | |
| k.fd = function() { | |
| return 1; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.toString = function() { | |
| return "SafeUrl{" + this.a + "}"; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {?} | |
| */ | |
| var Sc = function(a) { | |
| return Rc(a).toString(); | |
| }; | |
| /** | |
| * @param {string} options | |
| * @return {?} | |
| */ | |
| var Rc = function(options) { | |
| if (options instanceof Qc && options.constructor === Qc && options.b === Pc) { | |
| return options.a; | |
| } | |
| Za("expected object of type SafeUrl, got '" + options + "' of type " + Ja(options)); | |
| return "type_error:SafeUrl"; | |
| }; | |
| /** @type {!RegExp} */ | |
| var Tc = /^(?:audio\/(?:3gpp2|3gpp|aac|L16|midi|mp3|mp4|mpeg|oga|ogg|opus|x-m4a|x-wav|wav|webm)|image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp|x-icon)|text\/csv|video\/(?:mpeg|mp4|ogg|webm|quicktime))(?:;\w+=(?:\w+|"[\w;=]+"))*$/i; | |
| /** @type {!RegExp} */ | |
| var Uc = /^data:([^,]*);base64,[a-z0-9+\/]+=*$/i; | |
| /** @type {!RegExp} */ | |
| var Vc = /^(?:(?:https?|mailto|ftp):|[^:/?#]*(?:[/?#]|$))/i; | |
| /** | |
| * @param {!Object} type | |
| * @return {?} | |
| */ | |
| var Xc = function(type) { | |
| if (type instanceof Qc) { | |
| return type; | |
| } | |
| type = "object" == typeof type && type.Gc ? type.Db() : String(type); | |
| if (!Vc.test(type)) { | |
| /** @type {string} */ | |
| type = "about:invalid#zClosurez"; | |
| } | |
| return Wc(type); | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {string} b | |
| * @return {?} | |
| */ | |
| var Yc = function(a, b) { | |
| if (a instanceof Qc) { | |
| return a; | |
| } | |
| a = "object" == typeof a && a.Gc ? a.Db() : String(a); | |
| if (b && /^data:/i.test(a)) { | |
| b = a.replace(/(%0A|%0D)/g, ""); | |
| var o = b.match(Uc); | |
| o = o && Tc.test(o[1]); | |
| b = Wc(o ? b : "about:invalid#zClosurez"); | |
| if (b.Db() == a) { | |
| return b; | |
| } | |
| } | |
| if (!z(Vc.test(a), "%s does not match the safe URL pattern", a)) { | |
| /** @type {string} */ | |
| a = "about:invalid#zClosurez"; | |
| } | |
| return Wc(a); | |
| }; | |
| var Pc = {}; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var Wc = function(a) { | |
| var exportsB = new Qc; | |
| /** @type {!Object} */ | |
| exportsB.a = a; | |
| return exportsB; | |
| }; | |
| Wc("about:blank"); | |
| /** | |
| * @return {undefined} | |
| */ | |
| var $c = function() { | |
| /** @type {string} */ | |
| this.a = ""; | |
| this.b = Zc; | |
| }; | |
| /** @type {boolean} */ | |
| $c.prototype.Gc = true; | |
| var Zc = {}; | |
| /** | |
| * @return {?} | |
| */ | |
| $c.prototype.Db = function() { | |
| return this.a; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| $c.prototype.toString = function() { | |
| return "SafeStyle{" + this.a + "}"; | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| var ad = function(value) { | |
| if (value instanceof $c && value.constructor === $c && value.b === Zc) { | |
| return value.a; | |
| } | |
| Za("expected object of type SafeStyle, got '" + value + "' of type " + Ja(value)); | |
| return "type_error:SafeStyle"; | |
| }; | |
| /** | |
| * @param {string} s | |
| * @return {?} | |
| */ | |
| var bd = function(s) { | |
| var out = new $c; | |
| /** @type {string} */ | |
| out.a = s; | |
| return out; | |
| }; | |
| var cd = bd(""); | |
| /** | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| var ed = function(b) { | |
| /** @type {string} */ | |
| var matcher = ""; | |
| var key; | |
| for (key in b) { | |
| if (!/^[-_a-zA-Z0-9]+$/.test(key)) { | |
| throw Error("Name allows only [-_a-zA-Z0-9], got: " + key); | |
| } | |
| var value = b[key]; | |
| if (null != value) { | |
| value = Ka(value) ? mb(value, dd).join(" ") : dd(value); | |
| /** @type {string} */ | |
| matcher = matcher + (key + ":" + value + ";"); | |
| } | |
| } | |
| return matcher ? bd(matcher) : cd; | |
| }; | |
| /** | |
| * @param {string} date | |
| * @return {?} | |
| */ | |
| var dd = function(date) { | |
| if (date instanceof Qc) { | |
| return 'url("' + Sc(date).replace(/</g, "%3c").replace(/[\\"]/g, "\\$&") + '")'; | |
| } | |
| date = date instanceof cc ? dc(date) : fd(String(date)); | |
| if (/[{;}]/.test(date)) { | |
| throw new Xa("Value does not allow [{;}], got: %s.", [date]); | |
| } | |
| return date; | |
| }; | |
| /** | |
| * @param {string} t | |
| * @return {?} | |
| */ | |
| var fd = function(t) { | |
| var index = t.replace(gd, "$1").replace(gd, "$1").replace(hd, "url"); | |
| if (id.test(index)) { | |
| if (jd.test(t)) { | |
| return Za("String value disallows comments, got: " + t), "zClosurez"; | |
| } | |
| /** @type {boolean} */ | |
| var redTurn = index = true; | |
| /** @type {number} */ | |
| var offset = 0; | |
| for (; offset < t.length; offset++) { | |
| var gSelectedPieceIndex = t.charAt(offset); | |
| if ("'" == gSelectedPieceIndex && redTurn) { | |
| /** @type {boolean} */ | |
| index = !index; | |
| } else { | |
| if ('"' == gSelectedPieceIndex && index) { | |
| /** @type {boolean} */ | |
| redTurn = !redTurn; | |
| } | |
| } | |
| } | |
| if (!index || !redTurn) { | |
| return Za("String value requires balanced quotes, got: " + t), "zClosurez"; | |
| } | |
| if (!kd(t)) { | |
| return Za("String value requires balanced square brackets and one identifier per pair of brackets, got: " + t), "zClosurez"; | |
| } | |
| } else { | |
| return Za("String value allows only [-,.\"'%_!# a-zA-Z0-9\\[\\]] and simple functions, got: " + t), "zClosurez"; | |
| } | |
| return ld(t); | |
| }; | |
| /** | |
| * @param {string} ch | |
| * @return {?} | |
| */ | |
| var kd = function(ch) { | |
| /** @type {boolean} */ | |
| var b = true; | |
| /** @type {!RegExp} */ | |
| var c = /^[-_a-zA-Z0-9]$/; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < ch.length; i++) { | |
| var e = ch.charAt(i); | |
| if ("]" == e) { | |
| if (b) { | |
| return false; | |
| } | |
| /** @type {boolean} */ | |
| b = true; | |
| } else { | |
| if ("[" == e) { | |
| if (!b) { | |
| return false; | |
| } | |
| /** @type {boolean} */ | |
| b = false; | |
| } else { | |
| if (!b && !c.test(e)) { | |
| return false; | |
| } | |
| } | |
| } | |
| } | |
| return b; | |
| }; | |
| /** @type {!RegExp} */ | |
| var id = /^[-,."'%_!# a-zA-Z0-9\[\]]+$/; | |
| /** @type {!RegExp} */ | |
| var hd = /\b(url\([ \t\n]*)('[ -&(-\[\]-~]*'|"[ !#-\[\]-~]*"|[!#-&*-\[\]-~]*)([ \t\n]*\))/g; | |
| /** @type {!RegExp} */ | |
| var gd = /\b(hsl|hsla|rgb|rgba|matrix|calc|minmax|fit-content|repeat|(rotate|scale|translate)(X|Y|Z|3d)?)\([-+*/0-9a-z.%\[\], ]+\)/g; | |
| /** @type {!RegExp} */ | |
| var jd = /\/\*/; | |
| /** | |
| * @param {string} e | |
| * @return {?} | |
| */ | |
| var ld = function(e) { | |
| return e.replace(hd, function(id, soundDir, a, datahome) { | |
| /** @type {string} */ | |
| var name = ""; | |
| a = a.replace(/^(['"])(.*)\1$/, function(canCreateDiscussions, content_script, isSlidingUp) { | |
| /** @type {string} */ | |
| name = content_script; | |
| return isSlidingUp; | |
| }); | |
| id = Xc(a).Db(); | |
| return soundDir + name + id + name + datahome; | |
| }); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var nd = function() { | |
| /** @type {string} */ | |
| this.a = ""; | |
| this.b = md; | |
| }; | |
| /** @type {boolean} */ | |
| nd.prototype.Gc = true; | |
| var md = {}; | |
| /** | |
| * @param {string} name | |
| * @param {!Object} val | |
| * @return {?} | |
| */ | |
| var pd = function(name, val) { | |
| if (Kc(name, "<")) { | |
| throw Error("Selector does not allow '<', got: " + name); | |
| } | |
| var d = name.replace(/('|")((?!\1)[^\r\n\f\\]|\\[\s\S])*\1/g, ""); | |
| if (!/^[-_a-zA-Z0-9#.:* ,>+~[\]()=^$|]+$/.test(d)) { | |
| throw Error("Selector allows only [-_a-zA-Z0-9#.:* ,>+~[\\]()=^$|] and strings, got: " + name); | |
| } | |
| a: { | |
| var games = { | |
| "(" : ")", | |
| "[" : "]" | |
| }; | |
| /** @type {!Array} */ | |
| var filtered = []; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < d.length; i++) { | |
| var g = d[i]; | |
| if (games[g]) { | |
| filtered.push(games[g]); | |
| } else { | |
| if (Rb(games, g) && filtered.pop() != g) { | |
| /** @type {boolean} */ | |
| d = false; | |
| break a; | |
| } | |
| } | |
| } | |
| /** @type {boolean} */ | |
| d = 0 == filtered.length; | |
| } | |
| if (!d) { | |
| throw Error("() and [] in selector must be balanced, got: " + name); | |
| } | |
| if (!(val instanceof $c)) { | |
| val = ed(val); | |
| } | |
| /** @type {string} */ | |
| name = name + "{" + ad(val).replace(/</g, "\\3C ") + "}"; | |
| return od(name); | |
| }; | |
| /** | |
| * @param {!Array} context | |
| * @return {?} | |
| */ | |
| var rd = function(context) { | |
| /** @type {string} */ | |
| var value = ""; | |
| /** | |
| * @param {undefined} b | |
| * @return {undefined} | |
| */ | |
| var e = function(b) { | |
| if (Ka(b)) { | |
| A(b, e); | |
| } else { | |
| value = value + qd(b); | |
| } | |
| }; | |
| A(arguments, e); | |
| return od(value); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| nd.prototype.Db = function() { | |
| return this.a; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| nd.prototype.toString = function() { | |
| return "SafeStyleSheet{" + this.a + "}"; | |
| }; | |
| /** | |
| * @param {string} key | |
| * @return {?} | |
| */ | |
| var qd = function(key) { | |
| if (key instanceof nd && key.constructor === nd && key.b === md) { | |
| return key.a; | |
| } | |
| Za("expected object of type SafeStyleSheet, got '" + key + "' of type " + Ja(key)); | |
| return "type_error:SafeStyleSheet"; | |
| }; | |
| /** | |
| * @param {string} value | |
| * @return {?} | |
| */ | |
| var od = function(value) { | |
| var cfg = new nd; | |
| /** @type {string} */ | |
| cfg.a = value; | |
| return cfg; | |
| }; | |
| var sd = od(""); | |
| var Lc; | |
| a: { | |
| /** @type {!Navigator} */ | |
| var td = l.navigator; | |
| if (td) { | |
| /** @type {string} */ | |
| var ud = td.userAgent; | |
| if (ud) { | |
| /** @type {string} */ | |
| Lc = ud; | |
| break a; | |
| } | |
| } | |
| /** @type {string} */ | |
| Lc = ""; | |
| } | |
| /** | |
| * @param {string} str | |
| * @return {?} | |
| */ | |
| var B = function(str) { | |
| return Kc(Lc, str); | |
| }; | |
| /** | |
| * @param {?} v | |
| * @return {?} | |
| */ | |
| var vd = function(v) { | |
| /** @type {!RegExp} */ | |
| var b = /(\w[\w ]+)\/([^\s]+)\s*(?:\((.*?)\))?/g; | |
| /** @type {!Array} */ | |
| var newNodeLists = []; | |
| var t_numtype; | |
| for (; t_numtype = b.exec(v);) { | |
| newNodeLists.push([t_numtype[1], t_numtype[2], t_numtype[3] || void 0]); | |
| } | |
| return newNodeLists; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var wd = function() { | |
| return B("Trident") || B("MSIE"); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var xd = function() { | |
| return B("Firefox") || B("FxiOS"); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var zd = function() { | |
| return B("Safari") && !(yd() || B("Coast") || B("Opera") || B("Edge") || B("Edg/") || xd() || B("Silk") || B("Android")); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var yd = function() { | |
| return (B("Chrome") || B("CriOS")) && !B("Edge"); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Ad = function() { | |
| /** | |
| * @param {!Array} r | |
| * @return {?} | |
| */ | |
| function lookUpValueWithKeys(r) { | |
| r = rb(r, opacity); | |
| return data[r] || ""; | |
| } | |
| var w = Lc; | |
| if (!wd()) { | |
| w = vd(w); | |
| var data = {}; | |
| A(w, function(chunks) { | |
| data[chunks[0]] = chunks[1]; | |
| }); | |
| var opacity = Ta(Qb, data); | |
| if (B("Opera")) { | |
| lookUpValueWithKeys(["Version", "Opera"]); | |
| } else { | |
| if (B("Edge")) { | |
| lookUpValueWithKeys(["Edge"]); | |
| } else { | |
| if (B("Edg/")) { | |
| lookUpValueWithKeys(["Edg"]); | |
| } else { | |
| if (yd()) { | |
| lookUpValueWithKeys(["Chrome", "CriOS"]); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Cd = function() { | |
| /** @type {string} */ | |
| this.a = ""; | |
| this.c = Bd; | |
| /** @type {null} */ | |
| this.b = null; | |
| }; | |
| k = Cd.prototype; | |
| /** @type {boolean} */ | |
| k.Ah = true; | |
| /** | |
| * @return {?} | |
| */ | |
| k.fd = function() { | |
| return this.b; | |
| }; | |
| /** @type {boolean} */ | |
| k.Gc = true; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Db = function() { | |
| return this.a.toString(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.toString = function() { | |
| return "SafeHtml{" + this.a + "}"; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var Dd = function(a) { | |
| if (a instanceof Cd && a.constructor === Cd && a.c === Bd) { | |
| return a.a; | |
| } | |
| Za("expected object of type SafeHtml, got '" + a + "' of type " + Ja(a)); | |
| return "type_error:SafeHtml"; | |
| }; | |
| /** | |
| * @param {string} options | |
| * @return {?} | |
| */ | |
| var Fd = function(options) { | |
| if (options instanceof Cd) { | |
| return options; | |
| } | |
| /** @type {boolean} */ | |
| var error = "object" == typeof options; | |
| /** @type {null} */ | |
| var finalMatrix = null; | |
| if (error && options.Ah) { | |
| finalMatrix = options.fd(); | |
| } | |
| return Ed(Jc(error && options.Gc ? options.Db() : String(options)), finalMatrix); | |
| }; | |
| /** | |
| * @param {string} settings | |
| * @return {?} | |
| */ | |
| var Gd = function(settings) { | |
| if (settings instanceof Cd) { | |
| return settings; | |
| } | |
| settings = Fd(settings); | |
| return Ed(Bc(Dd(settings).toString()), settings.fd()); | |
| }; | |
| /** @type {!RegExp} */ | |
| var Hd = /^[a-zA-Z0-9-]+$/; | |
| var Id = { | |
| action : true, | |
| cite : true, | |
| data : true, | |
| formaction : true, | |
| href : true, | |
| manifest : true, | |
| poster : true, | |
| src : true | |
| }; | |
| var Jd = { | |
| 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} i | |
| * @param {!Object} point | |
| * @param {string} f | |
| * @return {?} | |
| */ | |
| var Ld = function(i, point, f) { | |
| /** @type {string} */ | |
| var a = String(i); | |
| if (!Hd.test(a)) { | |
| throw Error("Invalid tag name <" + a + ">."); | |
| } | |
| if (a.toUpperCase() in Jd) { | |
| throw Error("Tag name <" + a + "> is not allowed for SafeHtml."); | |
| } | |
| return Kd(String(i), point, f); | |
| }; | |
| /** | |
| * @param {!Object} y0 | |
| * @return {?} | |
| */ | |
| var Nd = function(y0) { | |
| var item = Fd(Md); | |
| var max = item.fd(); | |
| /** @type {!Array} */ | |
| var drilldownLevelLabels = []; | |
| /** | |
| * @param {string} r | |
| * @return {undefined} | |
| */ | |
| var f = function(r) { | |
| if (Ka(r)) { | |
| A(r, f); | |
| } else { | |
| r = Fd(r); | |
| drilldownLevelLabels.push(Dd(r).toString()); | |
| r = r.fd(); | |
| if (0 == max) { | |
| /** @type {string} */ | |
| max = r; | |
| } else { | |
| if (0 != r && max != r) { | |
| /** @type {null} */ | |
| max = null; | |
| } | |
| } | |
| } | |
| }; | |
| A(y0, f); | |
| return Ed(drilldownLevelLabels.join(Dd(item).toString()), max); | |
| }; | |
| /** | |
| * @param {!Object} n22 | |
| * @return {?} | |
| */ | |
| var Od = function(n22) { | |
| return Nd(Array.prototype.slice.call(arguments)); | |
| }; | |
| var Bd = {}; | |
| /** | |
| * @param {string} i | |
| * @param {!Array} m | |
| * @return {?} | |
| */ | |
| var Ed = function(i, m) { | |
| return Pd(i, m); | |
| }; | |
| /** | |
| * @param {string} v | |
| * @param {number} i | |
| * @return {?} | |
| */ | |
| var Pd = function(v, i) { | |
| var c = new Cd; | |
| /** @type {string} */ | |
| c.a = v; | |
| /** @type {number} */ | |
| c.b = i; | |
| return c; | |
| }; | |
| /** | |
| * @param {string} f | |
| * @param {!Object} a | |
| * @param {!Object} c | |
| * @return {?} | |
| */ | |
| var Kd = function(f, a, c) { | |
| /** @type {null} */ | |
| var item = null; | |
| /** @type {string} */ | |
| var s = ""; | |
| if (a) { | |
| for (k in a) { | |
| if (!Hd.test(k)) { | |
| throw Error('Invalid attribute name "' + k + '".'); | |
| } | |
| var id = a[k]; | |
| if (null != id) { | |
| /** @type {string} */ | |
| var vf = f; | |
| /** @type {string} */ | |
| var key = k; | |
| if (id instanceof cc) { | |
| id = dc(id); | |
| } else { | |
| if ("style" == key.toLowerCase()) { | |
| if (!Na(id)) { | |
| throw Error('The "style" attribute requires goog.html.SafeStyle or map of style properties, ' + typeof id + " given: " + id); | |
| } | |
| if (!(id instanceof $c)) { | |
| id = ed(id); | |
| } | |
| id = ad(id); | |
| } else { | |
| if (/^on/i.test(key)) { | |
| throw Error('Attribute "' + key + '" requires goog.string.Const value, "' + id + '" given.'); | |
| } | |
| if (key.toLowerCase() in Id) { | |
| if (id instanceof pc) { | |
| id = rc(id); | |
| } else { | |
| if (id instanceof Qc) { | |
| id = Sc(id); | |
| } else { | |
| if (r(id)) { | |
| id = Xc(id).Db(); | |
| } else { | |
| throw Error('Attribute "' + key + '" on tag "' + vf + '" requires goog.html.SafeUrl, goog.string.Const, or string, value "' + id + '" given.'); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| if (id.Gc) { | |
| id = id.Db(); | |
| } | |
| z(r(id) || Aa(id), "String or number value expected, got " + typeof id + " with value: " + id); | |
| /** @type {string} */ | |
| key = key + '="' + Jc(String(id)) + '"'; | |
| /** @type {string} */ | |
| s = s + (" " + key); | |
| } | |
| } | |
| } | |
| /** @type {string} */ | |
| var k = "<" + f + s; | |
| if (null != c) { | |
| if (!Ka(c)) { | |
| /** @type {!Array} */ | |
| c = [c]; | |
| } | |
| } else { | |
| /** @type {!Array} */ | |
| c = []; | |
| } | |
| if (true === $b[f.toLowerCase()]) { | |
| z(!c.length, "Void tag <" + f + "> does not allow content."); | |
| /** @type {string} */ | |
| k = k + ">"; | |
| } else { | |
| item = Od(c); | |
| /** @type {string} */ | |
| k = k + (">" + Dd(item).toString() + "</" + f + ">"); | |
| item = item.fd(); | |
| } | |
| if (f = a && a.dir) { | |
| if (/^(ltr|rtl|auto)$/i.test(f)) { | |
| /** @type {number} */ | |
| item = 0; | |
| } else { | |
| /** @type {null} */ | |
| item = null; | |
| } | |
| } | |
| return Pd(k, item); | |
| }; | |
| Pd("<!DOCTYPE html>", 0); | |
| var Md = Pd("", 0); | |
| var Qd = Pd("<br>", 0); | |
| /** | |
| * @param {!Object} date | |
| * @param {string} name | |
| * @param {string} prefixAgnostic | |
| * @return {?} | |
| */ | |
| var Rd = function(date, name, prefixAgnostic) { | |
| bb(dc(date), "must provide justification"); | |
| z(!xc(dc(date)), "must provide non-empty justification"); | |
| return Pd(name, prefixAgnostic || null); | |
| }; | |
| /** | |
| * @param {string} p_dom_object_id | |
| * @return {?} | |
| */ | |
| var Sd = function(p_dom_object_id) { | |
| var str = ec("Output of CSS sanitizer"); | |
| bb(dc(str), "must provide justification"); | |
| z(!xc(dc(str)), "must provide non-empty justification"); | |
| return bd(p_dom_object_id); | |
| }; | |
| var Td = { | |
| MATH : true, | |
| SCRIPT : true, | |
| STYLE : true, | |
| SVG : true, | |
| TEMPLATE : true | |
| }; | |
| var Ud = Lb(function() { | |
| if ("undefined" === typeof document) { | |
| return false; | |
| } | |
| /** @type {!Element} */ | |
| var a = document.createElement("div"); | |
| /** @type {!Element} */ | |
| var b = document.createElement("div"); | |
| b.appendChild(document.createElement("div")); | |
| a.appendChild(b); | |
| if (!a.firstChild) { | |
| return false; | |
| } | |
| /** @type {(Node|null)} */ | |
| b = a.firstChild.firstChild; | |
| a.innerHTML = Dd(Md); | |
| return !b.parentElement; | |
| }); | |
| /** | |
| * @param {!Object} a | |
| * @param {string} f | |
| * @return {undefined} | |
| */ | |
| var Vd = function(a, f) { | |
| if (Ud()) { | |
| for (; a.lastChild;) { | |
| a.removeChild(a.lastChild); | |
| } | |
| } | |
| a.innerHTML = Dd(f); | |
| }; | |
| /** | |
| * @param {!Object} t | |
| * @param {!Object} d | |
| * @return {undefined} | |
| */ | |
| var Wd = function(t, d) { | |
| if (Td[t.tagName.toUpperCase()]) { | |
| throw Error("goog.dom.safe.setInnerHtml cannot be used to set content of " + t.tagName + "."); | |
| } | |
| Vd(t, d); | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @param {!Object} id | |
| * @return {undefined} | |
| */ | |
| var Xd = function(e, id) { | |
| Ib(e, "HTMLIFrameElement"); | |
| e.src = rc(id); | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @param {!Object} url | |
| * @return {undefined} | |
| */ | |
| var Yd = function(node, url) { | |
| Ib(node, "HTMLScriptElement"); | |
| node.src = qc(url); | |
| if (url = Ea()) { | |
| node.setAttribute("nonce", url); | |
| } | |
| }; | |
| /** | |
| * @param {string} link | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| var Zd = function(link, value) { | |
| Hb(link); | |
| value = value instanceof Qc ? value : Yc(value); | |
| link.href = Rc(value); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| var $d = function(a, value) { | |
| Hb(a); | |
| value = value instanceof Qc ? value : Yc(value); | |
| a.replace(Rc(value)); | |
| }; | |
| /** | |
| * @param {string} item | |
| * @return {undefined} | |
| */ | |
| var ae = function(item) { | |
| item = item instanceof Qc ? item : Yc(item); | |
| l.open(Rc(item), "", void 0, void 0); | |
| }; | |
| /** | |
| * @param {string} selector | |
| * @return {?} | |
| */ | |
| var be = function(selector) { | |
| return selector.replace(/(\r\n|\r|\n)/g, "\n"); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| var ce = function(name) { | |
| return name.replace(/[\t\r\n ]+/g, " ").replace(/^[\t\r\n ]+|[\t\r\n ]+$/g, ""); | |
| }; | |
| /** | |
| * @param {string} p | |
| * @return {?} | |
| */ | |
| var de = function(p) { | |
| return encodeURIComponent(String(p)); | |
| }; | |
| /** | |
| * @param {string} key | |
| * @return {?} | |
| */ | |
| var ee = function(key) { | |
| return decodeURIComponent(key.replace(/\+/g, " ")); | |
| }; | |
| /** | |
| * @param {!Object} test | |
| * @return {?} | |
| */ | |
| var fe = function(test) { | |
| return test = Jc(test, void 0); | |
| }; | |
| /** | |
| * @param {string} min | |
| * @return {?} | |
| */ | |
| var ie = function(min) { | |
| return Kc(min, "&") ? "document" in l ? ge(min) : he(min) : min; | |
| }; | |
| /** | |
| * @param {string} value | |
| * @return {?} | |
| */ | |
| var ge = function(value) { | |
| var svrComps = { | |
| "&" : "&", | |
| "<" : "<", | |
| ">" : ">", | |
| """ : '"' | |
| }; | |
| var e = l.document.createElement("div"); | |
| return value.replace(je, function(i, n) { | |
| var c = svrComps[i]; | |
| if (c) { | |
| return c; | |
| } | |
| if ("#" == n.charAt(0)) { | |
| /** @type {number} */ | |
| n = Number("0" + n.substr(1)); | |
| if (!isNaN(n)) { | |
| /** @type {string} */ | |
| c = String.fromCharCode(n); | |
| } | |
| } | |
| if (!c) { | |
| Wd(e, Rd(ec("Single HTML entity."), i + " ")); | |
| c = e.firstChild.nodeValue.slice(0, -1); | |
| } | |
| return svrComps[i] = c; | |
| }); | |
| }; | |
| /** | |
| * @param {string} att | |
| * @return {?} | |
| */ | |
| var he = function(att) { | |
| return att.replace(/&([^;]+);/g, function(b, entity) { | |
| switch(entity) { | |
| case "amp": | |
| return "&"; | |
| case "lt": | |
| return "<"; | |
| case "gt": | |
| return ">"; | |
| case "quot": | |
| return '"'; | |
| default: | |
| return "#" != entity.charAt(0) || (entity = Number("0" + entity.substr(1)), isNaN(entity)) ? b : String.fromCharCode(entity); | |
| } | |
| }); | |
| }; | |
| /** @type {!RegExp} */ | |
| var je = /&([^;\s<&]+);?/g; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var ke = function(a) { | |
| return String(a).replace(/([-()\[\]{}+?*.$\^|,:#<!\\])/g, "\\$1").replace(/\x08/g, "\\x08"); | |
| }; | |
| /** @type {function(string, number): ?} */ | |
| var le = String.prototype.repeat ? function(indentPerLevel, level) { | |
| return indentPerLevel.repeat(level); | |
| } : function(inputHrStr, startIndex) { | |
| return Array(startIndex + 1).join(inputHrStr); | |
| }; | |
| /** | |
| * @param {string} value | |
| * @return {?} | |
| */ | |
| var me = function(value) { | |
| return null == value ? "" : String(value); | |
| }; | |
| /** | |
| * @param {string} b | |
| * @return {?} | |
| */ | |
| var ne = function(b) { | |
| return Array.prototype.join.call(arguments, ""); | |
| }; | |
| /** | |
| * @param {string} err | |
| * @return {?} | |
| */ | |
| var oe = function(err) { | |
| /** @type {number} */ | |
| var ret = Number(err); | |
| return 0 == ret && xc(err) ? NaN : ret; | |
| }; | |
| /** | |
| * @param {string} obj | |
| * @return {?} | |
| */ | |
| var pe = function(obj) { | |
| return String(obj).replace(/\-([a-z])/g, function(b, shortMonthName) { | |
| return shortMonthName.toUpperCase(); | |
| }); | |
| }; | |
| /** | |
| * @param {string} text | |
| * @return {?} | |
| */ | |
| var qe = function(text) { | |
| var enable_keys = r(void 0) ? ke(void 0) : "\\s"; | |
| return text.replace(new RegExp("(^" + (enable_keys ? "|[" + enable_keys + "]+" : "") + ")([a-z])", "g"), function(canCreateDiscussions, isSlidingUp, shortMonthName) { | |
| return isSlidingUp + shortMonthName.toUpperCase(); | |
| }); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var re = function() { | |
| return B("iPhone") && !B("iPod") && !B("iPad"); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var se = function() { | |
| return re() || B("iPad") || B("iPod"); | |
| }; | |
| /** | |
| * @param {number} context | |
| * @return {?} | |
| */ | |
| var te = function(context) { | |
| var p = Lc; | |
| /** @type {string} */ | |
| var filter = ""; | |
| if (B("Windows")) { | |
| /** @type {!RegExp} */ | |
| filter = /Windows (?:NT|Phone) ([0-9.]+)/; | |
| /** @type {string} */ | |
| filter = (p = filter.exec(p)) ? p[1] : "0.0"; | |
| } else { | |
| if (se()) { | |
| /** @type {!RegExp} */ | |
| filter = /(?:iPhone|iPod|iPad|CPU)\s+OS\s+(\S+)/; | |
| /** @type {(null|string)} */ | |
| filter = (p = filter.exec(p)) && p[1].replace(/_/g, "."); | |
| } else { | |
| if (B("Macintosh")) { | |
| /** @type {!RegExp} */ | |
| filter = /Mac OS X ([0-9_.]+)/; | |
| /** @type {string} */ | |
| filter = (p = filter.exec(p)) ? p[1].replace(/_/g, ".") : "10"; | |
| } else { | |
| if (Mc("KaiOS")) { | |
| /** @type {!RegExp} */ | |
| filter = /(?:KaiOS)\/(\S+)/i; | |
| /** @type {(null|string)} */ | |
| filter = (p = filter.exec(p)) && p[1]; | |
| } else { | |
| if (B("Android")) { | |
| /** @type {!RegExp} */ | |
| filter = /Android\s+([^\);]+)(\)|;)/; | |
| /** @type {(null|string)} */ | |
| filter = (p = filter.exec(p)) && p[1]; | |
| } else { | |
| if (B("CrOS")) { | |
| /** @type {!RegExp} */ | |
| filter = /(?:CrOS\s+(?:i686|x86_64)\s+([0-9.]+))/; | |
| /** @type {(null|string)} */ | |
| filter = (p = filter.exec(p)) && p[1]; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| return 0 <= Oc(filter || "", context); | |
| }; | |
| /** | |
| * @param {?} str | |
| * @return {?} | |
| */ | |
| var ue = function(str) { | |
| ue[" "](str); | |
| return str; | |
| }; | |
| /** @type {function(): undefined} */ | |
| ue[" "] = Ha; | |
| /** | |
| * @param {!Object} source | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| var ve = function(source, name) { | |
| try { | |
| return ue(source[name]), true; | |
| } catch (c) { | |
| } | |
| return false; | |
| }; | |
| /** | |
| * @param {!HTMLDocument} args | |
| * @param {!Object} i | |
| * @param {!Function} makeNode | |
| * @return {?} | |
| */ | |
| var we = function(args, i, makeNode) { | |
| return Object.prototype.hasOwnProperty.call(args, i) ? args[i] : args[i] = makeNode(i); | |
| }; | |
| var C = { | |
| Gg : false, | |
| Fg : false, | |
| ai : false, | |
| ei : false, | |
| Ig : false, | |
| Jg : false, | |
| vk : false | |
| }; | |
| /** @type {boolean} */ | |
| C.Fe = C.Gg || C.Fg || C.ai || C.Ig || C.ei || C.Jg; | |
| /** | |
| * @return {?} | |
| */ | |
| C.Md = function() { | |
| return Lc; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| C.hh = function() { | |
| return l.navigator || null; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| C.ys = function() { | |
| return C.hh(); | |
| }; | |
| C.cb = C.Fe ? C.Jg : B("Opera"); | |
| C.V = C.Fe ? C.Gg : wd(); | |
| C.vb = C.Fe ? C.Fg : B("Edge"); | |
| C.li = C.vb || C.V; | |
| C.Ja = C.Fe ? C.ai : B("Gecko") && !(Mc("WebKit") && !B("Edge")) && !(B("Trident") || B("MSIE")) && !B("Edge"); | |
| C.Ka = C.Fe ? C.ei || C.Ig : Mc("WebKit") && !B("Edge"); | |
| /** | |
| * @return {?} | |
| */ | |
| C.yn = function() { | |
| return C.Ka && B("Mobile"); | |
| }; | |
| C.Mg = C.Ig || C.yn(); | |
| C.ee = C.Ka; | |
| /** | |
| * @return {?} | |
| */ | |
| C.Dl = function() { | |
| var navigator = C.hh(); | |
| return navigator && navigator.platform || ""; | |
| }; | |
| C.xr = C.Dl(); | |
| /** @type {boolean} */ | |
| C.ci = false; | |
| /** @type {boolean} */ | |
| C.gi = false; | |
| /** @type {boolean} */ | |
| C.bi = false; | |
| /** @type {boolean} */ | |
| C.ii = false; | |
| /** @type {boolean} */ | |
| C.Ee = false; | |
| /** @type {boolean} */ | |
| C.ae = false; | |
| /** @type {boolean} */ | |
| C.$d = false; | |
| /** @type {boolean} */ | |
| C.Hg = false; | |
| /** @type {boolean} */ | |
| C.xk = false; | |
| /** @type {boolean} */ | |
| C.wk = false; | |
| /** @type {boolean} */ | |
| C.jc = C.ci || C.gi || C.bi || C.ii || C.Ee || C.ae || C.$d || C.Hg; | |
| C.yb = C.jc ? C.ci : B("Macintosh"); | |
| C.Fd = C.jc ? C.gi : B("Windows"); | |
| /** | |
| * @return {?} | |
| */ | |
| C.xn = function() { | |
| return B("Linux") || B("CrOS"); | |
| }; | |
| C.Pq = C.jc ? C.bi : C.xn(); | |
| /** | |
| * @return {?} | |
| */ | |
| C.Cn = function() { | |
| var r = C.hh(); | |
| return !!r && Kc(r.appVersion || "", "X11"); | |
| }; | |
| C.rs = C.jc ? C.ii : C.Cn(); | |
| C.Kc = C.jc ? C.Ee : B("Android"); | |
| C.vc = C.jc ? C.ae : re(); | |
| C.Lc = C.jc ? C.$d : B("iPad"); | |
| C.Mk = C.jc ? C.Hg : B("iPod"); | |
| C.oi = C.jc ? C.ae || C.$d || C.Hg : se(); | |
| C.Kq = C.jc ? C.xk : Mc("KaiOS"); | |
| var xe; | |
| if (C.jc) { | |
| /** @type {boolean} */ | |
| xe = C.wk; | |
| } else { | |
| xe = Mc("GAFP"); | |
| } | |
| C.Aq = xe; | |
| /** | |
| * @return {?} | |
| */ | |
| C.Ve = function() { | |
| /** @type {string} */ | |
| var _value = ""; | |
| var value = C.em(); | |
| if (value) { | |
| _value = value ? value[1] : ""; | |
| } | |
| return C.V && (value = C.Xi(), null != value && value > parseFloat(_value)) ? String(value) : _value; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| C.em = function() { | |
| var full_conversation_url = C.Md(); | |
| if (C.Ja) { | |
| return /rv:([^\);]+)(\)|;)/.exec(full_conversation_url); | |
| } | |
| if (C.vb) { | |
| return /Edge\/([\d\.]+)/.exec(full_conversation_url); | |
| } | |
| if (C.V) { | |
| return /\b(?:MSIE|rv)[: ]([^\);]+)(\)|;)/.exec(full_conversation_url); | |
| } | |
| if (C.Ka) { | |
| return /WebKit\/(\S+)/.exec(full_conversation_url); | |
| } | |
| if (C.cb) { | |
| return /(?:Version)[ \/]?(\S+)/.exec(full_conversation_url); | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| C.Xi = function() { | |
| var document = l.document; | |
| return document ? document.documentMode : void 0; | |
| }; | |
| C.VERSION = C.Ve(); | |
| /** | |
| * @param {string} key | |
| * @param {!Object} val1 | |
| * @return {?} | |
| */ | |
| C.compare = function(key, val1) { | |
| return Oc(key, val1); | |
| }; | |
| C.Bn = {}; | |
| /** | |
| * @param {!Object} name | |
| * @return {?} | |
| */ | |
| C.Ea = function(name) { | |
| return C.vk || we(C.Bn, name, function() { | |
| return 0 <= Oc(C.VERSION, name); | |
| }); | |
| }; | |
| /** @type {function(!Object): ?} */ | |
| C.ub = C.Ea; | |
| /** | |
| * @param {number} documentMode | |
| * @return {?} | |
| */ | |
| C.kb = function(documentMode) { | |
| return Number(C.Fk) >= documentMode; | |
| }; | |
| /** @type {function(number): ?} */ | |
| C.As = C.kb; | |
| var ye; | |
| /** @type {!HTMLDocument} */ | |
| var ze = l.document; | |
| ye = ze && C.V ? C.Xi() || ("CSS1Compat" == ze.compatMode ? parseInt(C.VERSION, 10) : 5) : void 0; | |
| C.Fk = ye; | |
| C.product = {}; | |
| /** @type {boolean} */ | |
| C.product.$h = false; | |
| /** @type {boolean} */ | |
| C.product.ae = false; | |
| /** @type {boolean} */ | |
| C.product.$d = false; | |
| /** @type {boolean} */ | |
| C.product.Ee = false; | |
| /** @type {boolean} */ | |
| C.product.Zh = false; | |
| /** @type {boolean} */ | |
| C.product.di = false; | |
| /** @type {boolean} */ | |
| C.product.ce = C.Gg || C.Fg || C.Jg || C.product.$h || C.product.ae || C.product.$d || C.product.Ee || C.product.Zh || C.product.di; | |
| C.product.cb = C.cb; | |
| C.product.V = C.V; | |
| C.product.vb = C.vb; | |
| C.product.Lg = C.product.ce ? C.product.$h : xd(); | |
| /** | |
| * @return {?} | |
| */ | |
| C.product.wn = function() { | |
| return re() || B("iPod"); | |
| }; | |
| C.product.vc = C.product.ce ? C.product.ae : C.product.wn(); | |
| C.product.Lc = C.product.ce ? C.product.$d : B("iPad"); | |
| C.product.Kc = C.product.ce ? C.product.Ee : B("Android") && !(yd() || xd() || B("Opera") || B("Silk")); | |
| C.product.Ge = C.product.ce ? C.product.Zh : yd(); | |
| /** | |
| * @return {?} | |
| */ | |
| C.product.An = function() { | |
| return zd() && !se(); | |
| }; | |
| C.product.ee = C.product.ce ? C.product.di : C.product.An(); | |
| /** @type {null} */ | |
| var Ae = null; | |
| /** @type {null} */ | |
| var Be = null; | |
| /** | |
| * @param {!Array} args | |
| * @param {boolean} data | |
| * @return {?} | |
| */ | |
| var Ce = function(args, data) { | |
| z(La(args), "encodeByteArray takes an array as a parameter"); | |
| if (!Ae) { | |
| Ae = {}; | |
| Be = {}; | |
| /** @type {number} */ | |
| var v = 0; | |
| for (; 65 > v; v++) { | |
| /** @type {string} */ | |
| Ae[v] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".charAt(v); | |
| /** @type {string} */ | |
| Be[v] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.".charAt(v); | |
| } | |
| } | |
| /** @type {(null|{})} */ | |
| data = data ? Be : Ae; | |
| /** @type {!Array} */ | |
| v = []; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < args.length; i = i + 3) { | |
| var j = args[i]; | |
| /** @type {boolean} */ | |
| var negate = i + 1 < args.length; | |
| var name = negate ? args[i + 1] : 0; | |
| /** @type {boolean} */ | |
| var deep = i + 2 < args.length; | |
| var key = deep ? args[i + 2] : 0; | |
| /** @type {number} */ | |
| var i3 = j >> 2; | |
| /** @type {number} */ | |
| j = (j & 3) << 4 | name >> 4; | |
| /** @type {number} */ | |
| name = (name & 15) << 2 | key >> 6; | |
| /** @type {number} */ | |
| key = key & 63; | |
| if (!deep) { | |
| /** @type {number} */ | |
| key = 64; | |
| if (!negate) { | |
| /** @type {number} */ | |
| name = 64; | |
| } | |
| } | |
| v.push(data[i3], data[j], data[name], data[key]); | |
| } | |
| return v.join(""); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var De = function() { | |
| }; | |
| /** @type {boolean} */ | |
| var Ee = "function" == typeof Uint8Array; | |
| /** | |
| * @param {!Object} item | |
| * @param {number} i | |
| * @param {number} n | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| var He = function(item, i, n, a) { | |
| /** @type {null} */ | |
| item.a = null; | |
| if (!i) { | |
| /** @type {!Array} */ | |
| i = []; | |
| } | |
| item.m = void 0; | |
| /** @type {number} */ | |
| item.g = -1; | |
| /** @type {number} */ | |
| item.b = i; | |
| a: { | |
| var t = item.b.length; | |
| /** @type {number} */ | |
| i = -1; | |
| if (t && (i = t - 1, t = item.b[i], !(null === t || "object" != typeof t || Ka(t) || Ee && t instanceof Uint8Array))) { | |
| /** @type {number} */ | |
| item.h = i - item.g; | |
| item.c = t; | |
| break a; | |
| } | |
| if (-1 < n) { | |
| /** @type {number} */ | |
| item.h = Math.max(n, i + 1 - item.g); | |
| /** @type {null} */ | |
| item.c = null; | |
| } else { | |
| /** @type {number} */ | |
| item.h = Number.MAX_VALUE; | |
| } | |
| } | |
| item.o = {}; | |
| if (a) { | |
| /** @type {number} */ | |
| n = 0; | |
| for (; n < a.length; n++) { | |
| i = a[n]; | |
| if (i < item.h) { | |
| i = i + item.g; | |
| item.b[i] = item.b[i] || Fe; | |
| } else { | |
| Ge(item); | |
| item.c[i] = item.c[i] || Fe; | |
| } | |
| } | |
| } | |
| }; | |
| /** @type {!Array} */ | |
| var Fe = Object.freeze ? Object.freeze([]) : []; | |
| /** | |
| * @param {!Object} b | |
| * @return {undefined} | |
| */ | |
| var Ge = function(b) { | |
| var i = b.h + b.g; | |
| if (!b.b[i]) { | |
| b.c = b.b[i] = {}; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {number} i | |
| * @return {?} | |
| */ | |
| var Ie = function(a, i) { | |
| if (i < a.h) { | |
| i = i + a.g; | |
| var d = a.b[i]; | |
| return d === Fe ? a.b[i] = [] : d; | |
| } | |
| if (a.c) { | |
| return d = a.c[i], d === Fe ? a.c[i] = [] : d; | |
| } | |
| }; | |
| /** | |
| * @param {string} e | |
| * @param {string} s | |
| * @return {?} | |
| */ | |
| var Je = function(e, s) { | |
| e = Ie(e, 1); | |
| return null == e ? s : e; | |
| }; | |
| /** | |
| * @param {!Object} c | |
| * @param {number} i | |
| * @param {?} value | |
| * @return {undefined} | |
| */ | |
| var D = function(c, i, value) { | |
| if (i < c.h) { | |
| c.b[i + c.g] = value; | |
| } else { | |
| Ge(c); | |
| c.c[i] = value; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} result | |
| * @param {!Function} r | |
| * @param {number} i | |
| * @return {undefined} | |
| */ | |
| var Ke = function(result, r, i) { | |
| if (!result.a) { | |
| result.a = {}; | |
| } | |
| if (!result.a[i]) { | |
| var d = Ie(result, i); | |
| /** @type {!Array} */ | |
| var dataTicks = []; | |
| /** @type {number} */ | |
| var j = 0; | |
| for (; j < d.length; j++) { | |
| dataTicks[j] = new r(d[j]); | |
| } | |
| /** @type {!Array} */ | |
| result.a[i] = dataTicks; | |
| } | |
| }; | |
| /** | |
| * @param {string} msg | |
| * @param {number} f | |
| * @param {?} c | |
| * @return {undefined} | |
| */ | |
| var Le = function(msg, f, c) { | |
| if (!msg.a) { | |
| msg.a = {}; | |
| } | |
| var r = c ? c.Jb() : c; | |
| msg.a[f] = c; | |
| D(msg, f, r); | |
| }; | |
| /** | |
| * @param {!Object} msg | |
| * @param {number} f | |
| * @param {!Object} item | |
| * @return {undefined} | |
| */ | |
| var Me = function(msg, f, item) { | |
| if (!msg.a) { | |
| msg.a = {}; | |
| } | |
| item = item || []; | |
| /** @type {!Array} */ | |
| var Y = []; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < item.length; i++) { | |
| Y[i] = item[i].Jb(); | |
| } | |
| /** @type {!Object} */ | |
| msg.a[f] = item; | |
| D(msg, f, Y); | |
| }; | |
| /** | |
| * @param {!Object} scope | |
| * @param {number} i | |
| * @param {!Function} result | |
| * @return {?} | |
| */ | |
| var Ne = function(scope, i, result) { | |
| Ke(scope, result, i); | |
| var d = scope.a[i]; | |
| if (!d) { | |
| /** @type {!Array} */ | |
| d = scope.a[i] = []; | |
| } | |
| result = new result; | |
| scope = Ie(scope, i); | |
| d.push(result); | |
| scope.push(result.Jb()); | |
| return result; | |
| }; | |
| /** | |
| * @param {(number|string)} scope | |
| * @return {undefined} | |
| */ | |
| var Oe = function(scope) { | |
| if (scope.a) { | |
| var i; | |
| for (i in scope.a) { | |
| var c = scope.a[i]; | |
| if (Ka(c)) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < c.length; i++) { | |
| if (c[i]) { | |
| c[i].Jb(); | |
| } | |
| } | |
| } else { | |
| if (c) { | |
| c.Jb(); | |
| } | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| De.prototype.Jb = function() { | |
| Oe(this); | |
| return this.b; | |
| }; | |
| /** @type {function(): ?} */ | |
| De.prototype.vd = Ee ? function() { | |
| /** @type {function(this:Uint8Array, string=): *} */ | |
| var toJSON = Uint8Array.prototype.toJSON; | |
| /** | |
| * @param {string=} p0 | |
| * @return {*} | |
| */ | |
| Uint8Array.prototype.toJSON = function() { | |
| return Ce(this); | |
| }; | |
| try { | |
| return JSON.stringify(this.b && this.Jb(), Pe); | |
| } finally { | |
| /** @type {function(this:Uint8Array, string=): *} */ | |
| Uint8Array.prototype.toJSON = toJSON; | |
| } | |
| } : function() { | |
| return JSON.stringify(this.b && this.Jb(), Pe); | |
| }; | |
| /** | |
| * @param {?} sometotal | |
| * @param {(number|string)} value | |
| * @return {?} | |
| */ | |
| var Pe = function(sometotal, value) { | |
| return Aa(value) && (isNaN(value) || Infinity === value || -Infinity === value) ? String(value) : value; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| De.prototype.toString = function() { | |
| Oe(this); | |
| return this.b.toString(); | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {?} | |
| */ | |
| var Re = function(a) { | |
| return new a.constructor(Qe(a.Jb())); | |
| }; | |
| /** | |
| * @param {!Object} array | |
| * @return {?} | |
| */ | |
| var Qe = function(array) { | |
| if (Ka(array)) { | |
| /** @type {!Array} */ | |
| var a = Array(array.length); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < array.length; i++) { | |
| var v = array[i]; | |
| if (null != v) { | |
| a[i] = "object" == typeof v ? Qe(z(v)) : v; | |
| } | |
| } | |
| return a; | |
| } | |
| if (Ee && array instanceof Uint8Array) { | |
| return new Uint8Array(array); | |
| } | |
| a = {}; | |
| for (i in array) { | |
| v = array[i]; | |
| if (null != v) { | |
| a[i] = "object" == typeof v ? Qe(z(v)) : v; | |
| } | |
| } | |
| return a; | |
| }; | |
| /** | |
| * @param {undefined} ___j | |
| * @return {undefined} | |
| */ | |
| var Te = function(___j) { | |
| He(this, ___j, -1, Se); | |
| }; | |
| x(Te, De); | |
| /** @type {!Array} */ | |
| var Se = [1, 2, 3, 4]; | |
| /** | |
| * @param {string} url | |
| * @return {?} | |
| */ | |
| var Ue = function(url) { | |
| if (!url) { | |
| return ""; | |
| } | |
| url = url.split("#")[0].split("?")[0]; | |
| url = url.toLowerCase(); | |
| if (0 == url.indexOf("//")) { | |
| /** @type {string} */ | |
| url = window.location.protocol + url; | |
| } | |
| if (!/^[\w\-]*:\/\//.test(url)) { | |
| /** @type {string} */ | |
| url = window.location.href; | |
| } | |
| var path = url.substring(url.indexOf("://") + 3); | |
| var query = path.indexOf("/"); | |
| if (-1 != query) { | |
| path = path.substring(0, query); | |
| } | |
| url = url.substring(0, url.indexOf("://")); | |
| if ("http" !== url && "https" !== url && "chrome-extension" !== url && "file" !== url && "android-app" !== url && "chrome-search" !== url && "app" !== url) { | |
| throw Error("Invalid URI scheme in origin: " + url); | |
| } | |
| /** @type {string} */ | |
| query = ""; | |
| var lastSlash = path.indexOf(":"); | |
| if (-1 != lastSlash) { | |
| var singleQuote = path.substring(lastSlash + 1); | |
| path = path.substring(0, lastSlash); | |
| if ("http" === url && "80" !== singleQuote || "https" === url && "443" !== singleQuote) { | |
| /** @type {string} */ | |
| query = ":" + singleQuote; | |
| } | |
| } | |
| return url + "://" + path + query; | |
| }; | |
| var Ve = { | |
| ascii_tlds : "aarp abarth abb abbott abbvie abc able abogado abudhabi ac academy accenture accountant accountants aco actor ad adac ads adult ae aeg aero aetna af afamilycompany afl africa ag agakhan agency ai aig aigo airbus airforce airtel akdn al alfaromeo alibaba alipay allfinanz allstate ally alsace alstom am americanexpress americanfamily amex amfam amica amsterdam analytics android anquan anz ao aol apartments app apple aq aquarelle ar arab aramco archi army arpa art arte as asda asia associates at athleta attorney au auction audi audible audio auspost author auto autos avianca aw aws ax axa az azure ba baby baidu banamex bananarepublic band bank bar barcelona barclaycard barclays barefoot bargains baseball basketball bauhaus bayern bb bbc bbt bbva bcg bcn bd be beats beauty beer bentley berlin best bestbuy bet bf bg bh bharti bi bible bid bike bing bingo bio biz bj black blackfriday blockbuster blog bloomberg blue bm bms bmw bn bnl bnpparibas bo boats boehringer bofa bom bond boo book booking bosch bostik boston bot boutique box br bradesco bridgestone broadway broker brother brussels bs bt budapest bugatti build builders business buy buzz bv bw by bz bzh ca cab cafe cal call calvinklein cam camera camp cancerresearch canon capetown capital capitalone car caravan cards care career careers cars cartier casa case caseih cash casino cat catering catholic cba cbn cbre cbs cc cd ceb center ceo cern cf cfa cfd cg ch chanel channel charity chase chat cheap chintai christmas chrome chrysler church ci cipriani circle cisco citadel citi citic city cityeats ck cl claims cleaning click clinic clinique clothing cloud club clubmed cm cn co coach codes coffee college cologne com comcast commbank community company compare computer comsec condos construction consulting contact contractors cooking cookingchannel cool coop corsica country coupon coupons courses cr credit creditcard creditunion cricket crown crs cruise cruises csc cu cuisinella cv cw cx cy cymru cyou cz dabur dad dance data date dating datsun day dclk dds de deal dealer deals degree delivery dell deloitte delta democrat dental dentist desi design dev dhl diamonds diet digital direct directory discount discover dish diy dj dk dm dnp do docs doctor dodge dog doha domains dot download drive dtv dubai duck dunlop duns dupont durban dvag dvr dz earth eat ec eco edeka edu education ee eg email emerck energy engineer engineering enterprises epson equipment er ericsson erni es esq estate esurance et etisalat eu eurovision eus events everbank exchange expert exposed express extraspace fage fail fairwinds faith family fan fans farm farmers fashion fast fedex feedback ferrari ferrero fi fiat fidelity fido film final finance financial fire firestone firmdale fish fishing fit fitness fj fk flickr flights flir florist flowers fly fm fo foo food foodnetwork football ford forex forsale forum foundation fox fr free fresenius frl frogans frontdoor frontier ftr fujitsu fujixerox fun fund furniture futbol fyi ga gal gallery gallo gallup game games gap garden gb gbiz gd gdn ge gea gent genting george gf gg ggee gh gi gift gifts gives giving gl glade glass gle global globo gm gmail gmbh gmo gmx gn godaddy gold goldpoint golf goo goodyear goog google gop got gov gp gq gr grainger graphics gratis green gripe grocery group gs gt gu guardian gucci guge guide guitars guru gw gy hair hamburg hangout haus hbo hdfc hdfcbank health healthcare help helsinki here hermes hgtv hiphop hisamitsu hitachi hiv hk hkt hm hn hockey holdings holiday homedepot homegoods homes homesense honda honeywell horse hospital host hosting hot hoteles hotels hotmail house how hr hsbc ht hu hughes hyatt hyundai ibm icbc ice icu id ie ieee ifm ikano il im imamat imdb immo immobilien in inc industries infiniti info ing ink institute insurance insure int intel international intuit investments io ipiranga iq ir irish is iselect ismaili ist istanbul it itau itv iveco jaguar java jcb jcp je jeep jetzt jewelry jio jll jm jmp jnj jo jobs joburg jot joy jp jpmorgan jprs juegos juniper kaufen kddi ke kerryhotels kerrylogistics kerryproperties kfh kg kh ki kia kim kinder kindle kitchen kiwi km kn koeln komatsu kosher kp kpmg kpn kr krd kred kuokgroup kw ky kyoto kz la lacaixa ladbrokes lamborghini lamer lancaster lancia lancome land landrover lanxess lasalle lat latino latrobe law lawyer lb lc lds lease leclerc lefrak legal lego lexus lgbt li liaison lidl life lifeinsurance lifestyle lighting like lilly limited limo lincoln linde link lipsy live living lixil lk llc loan loans locker locus loft lol london lotte lotto love lpl lplfinancial lr ls lt ltd ltda lu lundbeck lupin luxe luxury lv ly ma macys madrid maif maison makeup man management mango map market marketing markets marriott marshalls maserati mattel mba mc mckinsey md me med media meet melbourne meme memorial men menu merckmsd metlife mg mh miami microsoft mil mini mint mit mitsubishi mk ml mlb mls mm mma mn mo mobi mobile mobily moda moe moi mom monash money monster mopar mormon mortgage moscow moto motorcycles mov movie movistar mp mq mr ms msd mt mtn mtr mu museum mutual mv mw mx my mz na nab nadex nagoya name nationwide natura navy nba nc ne nec net netbank netflix network neustar new newholland news next nextdirect nexus nf nfl ng ngo nhk ni nico nike nikon ninja nissan nissay nl no nokia northwesternmutual norton now nowruz nowtv np nr nra nrw ntt nu nyc nz obi observer off office okinawa olayan olayangroup oldnavy ollo om omega one ong onl online onyourside ooo open oracle orange org organic origins osaka otsuka ott ovh pa page panasonic paris pars partners parts party passagens pay pccw pe pet pf pfizer pg ph pharmacy phd philips phone photo photography photos physio piaget pics pictet pictures pid pin ping pink pioneer pizza pk pl place play playstation plumbing plus pm pn pnc pohl poker politie porn post pr pramerica praxi press prime pro prod productions prof progressive promo properties property protection pru prudential ps pt pub pw pwc py qa qpon quebec quest qvc racing radio raid re read realestate realtor realty recipes red redstone redumbrella rehab reise reisen reit reliance ren rent rentals repair report republican rest restaurant review reviews rexroth rich richardli ricoh rightathome ril rio rip rmit ro rocher rocks rodeo rogers room rs rsvp ru rugby ruhr run rw rwe ryukyu sa saarland safe safety sakura sale salon samsclub samsung sandvik sandvikcoromant sanofi sap sarl sas save saxo sb sbi sbs sc sca scb schaeffler schmidt scholarships school schule schwarz science scjohnson scor scot sd se search seat secure security seek select sener services ses seven sew sex sexy sfr sg sh shangrila sharp shaw shell shia shiksha shoes shop shopping shouji show showtime shriram si silk sina singles site sj sk ski skin sky skype sl sling sm smart smile sn sncf so soccer social softbank software sohu solar solutions song sony soy space sport spot spreadbetting sr srl srt ss st stada staples star starhub statebank statefarm stc stcgroup stockholm storage store stream studio study style su sucks supplies supply support surf surgery suzuki sv swatch swiftcover swiss sx sy sydney symantec systems sz tab taipei talk taobao target tatamotors tatar tattoo tax taxi tc tci td tdk team tech technology tel telefonica temasek tennis teva tf tg th thd theater theatre tiaa tickets tienda tiffany tips tires tirol tj tjmaxx tjx tk tkmaxx tl tm tmall tn to today tokyo tools top toray toshiba total tours town toyota toys tr trade trading training travel travelchannel travelers travelersinsurance trust trv tt tube tui tunes tushu tv tvs tw tz ua ubank ubs uconnect ug uk unicom university uno uol ups us uy uz va vacations vana vanguard vc ve vegas ventures verisign versicherung vet vg vi viajes video vig viking villas vin vip virgin visa vision vistaprint viva vivo vlaanderen vn vodka volkswagen volvo vote voting voto voyage vu vuelos wales walmart walter wang wanggou warman watch watches weather weatherchannel webcam weber website wed wedding weibo weir wf whoswho wien wiki williamhill win windows wine winners wme wolterskluwer woodside work works world wow ws wtc wtf xbox xerox xfinity xihuan xin xn--11b4c3d xn--1ck2e1b xn--1qqw23a xn--2scrj9c xn--30rr7y xn--3bst00m xn--3ds443g xn--3e0b707e xn--3hcrj9c xn--3oq18vl8pn36a xn--3pxu8k xn--42c2d9a xn--45br5cyl xn--45brj9c xn--45q11c xn--4gbrim xn--54b7fta0cc xn--55qw42g xn--55qx5d xn--5su34j936bgsg xn--5tzm5g xn--6frz82g xn--6qq986b3xl xn--80adxhks xn--80ao21a xn--80aqecdr1a xn--80asehdb xn--80aswg xn--8y0a063a xn--90a3ac xn--90ae xn--90ais xn--9dbq2a xn--9et52u xn--9krt00a xn--b4w605ferd xn--bck1b9a5dre4c xn--c1avg xn--c2br7g xn--cck2b3b xn--cg4bki xn--clchc0ea0b2g2a9gcd xn--czr694b xn--czrs0t xn--czru2d xn--d1acj3b xn--d1alf xn--e1a4c xn--eckvdtc9d xn--efvy88h xn--estv75g xn--fct429k xn--fhbei xn--fiq228c5hs xn--fiq64b xn--fiqs8s xn--fiqz9s xn--fjq720a xn--flw351e xn--fpcrj9c3d xn--fzc2c9e2c xn--fzys8d69uvgm xn--g2xx48c xn--gckr3f0f xn--gecrj9c xn--gk3at1e xn--h2breg3eve xn--h2brj9c xn--h2brj9c8c xn--hxt814e xn--i1b6b1a6a2e xn--imr513n xn--io0a7i xn--j1aef xn--j1amh xn--j6w193g xn--jlq61u9w7b xn--jvr189m xn--kcrx77d1x4a xn--kprw13d xn--kpry57d xn--kpu716f xn--kput3i xn--l1acc xn--lgbbat1ad8j xn--mgb9awbf xn--mgba3a3ejt xn--mgba3a4f16a xn--mgba7c0bbn0a xn--mgbaakc7dvf xn--mgbaam7a8h xn--mgbab2bd xn--mgbah1a3hjkrd xn--mgbai9azgqp6j xn--mgbayh7gpa xn--mgbb9fbpob xn--mgbbh1a xn--mgbbh1a71e xn--mgbc0a9azcg xn--mgbca7dzdo xn--mgberp4a5d4ar xn--mgbgu82a xn--mgbi4ecexp xn--mgbpl2fh xn--mgbt3dhd xn--mgbtx2b xn--mgbx4cd0ab xn--mix891f xn--mk1bu44c xn--mxtq1m xn--ngbc5azd xn--ngbe9e0a xn--ngbrx xn--node xn--nqv7f xn--nqv7fs00ema xn--nyqy26a xn--o3cw4h xn--ogbpf8fl xn--otu796d xn--p1acf xn--p1ai xn--pbt977c xn--pgbs0dh xn--pssy2u xn--q9jyb4c xn--qcka1pmc xn--qxam xn--rhqv96g xn--rovu88b xn--rvc1e0am3e xn--s9brj9c xn--ses554g xn--t60b56a xn--tckwe xn--tiq49xqyj xn--unup4y xn--vermgensberater-ctb xn--vermgensberatung-pwb xn--vhquv xn--vuq861b xn--w4r85el8fhu5dnra xn--w4rs40l xn--wgbh1c xn--wgbl6a xn--xhq521b xn--xkc2al3hye2a xn--xkc2dl3a5ee0h xn--y9a3aq xn--yfro4i67o xn--ygbi2ammx xn--zfr164b xxx xyz yachts yahoo yamaxun yandex ye yodobashi yoga yokohama you youtube yt yun za zappos zara zero zip zm zone zuerich zw".split(" "), | |
| unicode_tlds : "\u0915\u0949\u092e \u30bb\u30fc\u30eb \u4f5b\u5c71 \u0cad\u0cbe\u0cb0\u0ca4 \u6148\u5584 \u96c6\u56e2 \u5728\u7ebf \ud55c\uad6d \u0b2d\u0b3e\u0b30\u0b24 \u5927\u4f17\u6c7d\u8f66 \u70b9\u770b \u0e04\u0e2d\u0e21 \u09ad\u09be\u09f0\u09a4 \u09ad\u09be\u09b0\u09a4 \u516b\u5366 \u0645\u0648\u0642\u0639 \u09ac\u09be\u0982\u09b2\u09be \u516c\u76ca \u516c\u53f8 \u9999\u683c\u91cc\u62c9 \u7f51\u7ad9 \u79fb\u52a8 \u6211\u7231\u4f60 \u043c\u043e\u0441\u043a\u0432\u0430 \u049b\u0430\u0437 \u043a\u0430\u0442\u043e\u043b\u0438\u043a \u043e\u043d\u043b\u0430\u0439\u043d \u0441\u0430\u0439\u0442 \u8054\u901a \u0441\u0440\u0431 \u0431\u0433 \u0431\u0435\u043b \u05e7\u05d5\u05dd \u65f6\u5c1a \u5fae\u535a \u6de1\u9a6c\u9521 \u30d5\u30a1\u30c3\u30b7\u30e7\u30f3 \u043e\u0440\u0433 \u0928\u0947\u091f \u30b9\u30c8\u30a2 \uc0bc\uc131 \u0b9a\u0bbf\u0b99\u0bcd\u0b95\u0baa\u0bcd\u0baa\u0bc2\u0bb0\u0bcd \u5546\u6807 \u5546\u5e97 \u5546\u57ce \u0434\u0435\u0442\u0438 \u043c\u043a\u0434 \u0435\u044e \u30dd\u30a4\u30f3\u30c8 \u65b0\u95fb \u5de5\u884c \u5bb6\u96fb \u0643\u0648\u0645 \u4e2d\u6587\u7f51 \u4e2d\u4fe1 \u4e2d\u56fd \u4e2d\u570b \u5a31\u4e50 \u8c37\u6b4c \u0c2d\u0c3e\u0c30\u0c24\u0c4d \u0dbd\u0d82\u0d9a\u0dcf \u96fb\u8a0a\u76c8\u79d1 \u8d2d\u7269 \u30af\u30e9\u30a6\u30c9 \u0aad\u0abe\u0ab0\u0aa4 \u901a\u8ca9 \u092d\u093e\u0930\u0924\u092e\u094d \u092d\u093e\u0930\u0924 \u092d\u093e\u0930\u094b\u0924 \u7f51\u5e97 \u0938\u0902\u0917\u0920\u0928 \u9910\u5385 \u7f51\u7edc \u043a\u043e\u043c \u0443\u043a\u0440 \u9999\u6e2f \u8bfa\u57fa\u4e9a \u98df\u54c1 \u98de\u5229\u6d66 \u53f0\u6e7e \u53f0\u7063 \u624b\u8868 \u624b\u673a \u043c\u043e\u043d \u0627\u0644\u062c\u0632\u0627\u0626\u0631 \u0639\u0645\u0627\u0646 \u0627\u0631\u0627\u0645\u0643\u0648 \u0627\u06cc\u0631\u0627\u0646 \u0627\u0644\u0639\u0644\u064a\u0627\u0646 \u0627\u062a\u0635\u0627\u0644\u0627\u062a \u0627\u0645\u0627\u0631\u0627\u062a \u0628\u0627\u0632\u0627\u0631 \u0645\u0648\u0631\u064a\u062a\u0627\u0646\u064a\u0627 \u067e\u0627\u06a9\u0633\u062a\u0627\u0646 \u0627\u0644\u0627\u0631\u062f\u0646 \u0645\u0648\u0628\u0627\u064a\u0644\u064a \u0628\u0627\u0631\u062a \u0628\u06be\u0627\u0631\u062a \u0627\u0644\u0645\u063a\u0631\u0628 \u0627\u0628\u0648\u0638\u0628\u064a \u0627\u0644\u0633\u0639\u0648\u062f\u064a\u0629 \u0680\u0627\u0631\u062a \u0643\u0627\u062b\u0648\u0644\u064a\u0643 \u0633\u0648\u062f\u0627\u0646 \u0647\u0645\u0631\u0627\u0647 \u0639\u0631\u0627\u0642 \u0645\u0644\u064a\u0633\u064a\u0627 \u6fb3\u9580 \ub2f7\ucef4 \u653f\u5e9c \u0634\u0628\u0643\u0629 \u0628\u064a\u062a\u0643 \u0639\u0631\u0628 \u10d2\u10d4 \u673a\u6784 \u7ec4\u7ec7\u673a\u6784 \u5065\u5eb7 \u0e44\u0e17\u0e22 \u0633\u0648\u0631\u064a\u0629 \u62db\u8058 \u0440\u0443\u0441 \u0440\u0444 \u73e0\u5b9d \u062a\u0648\u0646\u0633 \u5927\u62ff \u307f\u3093\u306a \u30b0\u30fc\u30b0\u30eb \u03b5\u03bb \u4e16\u754c \u66f8\u7c4d \u0d2d\u0d3e\u0d30\u0d24\u0d02 \u0a2d\u0a3e\u0a30\u0a24 \u7f51\u5740 \ub2f7\ub137 \u30b3\u30e0 \u5929\u4e3b\u6559 \u6e38\u620f verm\u00f6gensberater verm\u00f6gensberatung \u4f01\u4e1a \u4fe1\u606f \u5609\u91cc\u5927\u9152\u5e97 \u5609\u91cc \u0645\u0635\u0631 \u0642\u0637\u0631 \u5e7f\u4e1c \u0b87\u0bb2\u0b99\u0bcd\u0b95\u0bc8 \u0b87\u0ba8\u0bcd\u0ba4\u0bbf\u0baf\u0bbe \u0570\u0561\u0575 \u65b0\u52a0\u5761 \u0641\u0644\u0633\u0637\u064a\u0646 \u653f\u52a1".split(" ") | |
| }; | |
| var We = !C.V || C.kb(9); | |
| var Xe = !C.Ja && !C.V || C.V && C.kb(9) || C.Ja && C.Ea("1.9.1"); | |
| var Ye = C.V && !C.Ea("9"); | |
| var Ze = C.V || C.cb || C.Ka; | |
| var $e = C.V; | |
| var af = C.V && !C.kb(9); | |
| /** | |
| * @param {number} functions | |
| * @param {string} create | |
| * @return {?} | |
| */ | |
| var bf = function(functions, create) { | |
| return functions + Math.random() * (create - functions); | |
| }; | |
| /** | |
| * @param {number} a | |
| * @param {number} e | |
| * @return {undefined} | |
| */ | |
| var cf = function(a, e) { | |
| this.x = q(a) ? a : 0; | |
| this.a = q(e) ? e : 0; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| cf.prototype.toString = function() { | |
| return "(" + this.x + ", " + this.a + ")"; | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @return {?} | |
| */ | |
| cf.prototype.Oc = function(item) { | |
| return item instanceof cf && df(this, item); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| var df = function(a, b) { | |
| return a == b ? true : a && b ? a.x == b.x && a.a == b.a : false; | |
| }; | |
| /** | |
| * @param {number} a | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| var ef = function(a, b) { | |
| return new cf(a.x - b.x, a.a - b.a); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| cf.prototype.ceil = function() { | |
| /** @type {number} */ | |
| this.x = Math.ceil(this.x); | |
| /** @type {number} */ | |
| this.a = Math.ceil(this.a); | |
| return this; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| cf.prototype.floor = function() { | |
| /** @type {number} */ | |
| this.x = Math.floor(this.x); | |
| /** @type {number} */ | |
| this.a = Math.floor(this.a); | |
| return this; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| cf.prototype.round = function() { | |
| /** @type {number} */ | |
| this.x = Math.round(this.x); | |
| /** @type {number} */ | |
| this.a = Math.round(this.a); | |
| return this; | |
| }; | |
| /** | |
| * @param {number} x | |
| * @param {number} value | |
| * @return {undefined} | |
| */ | |
| var ff = function(x, value) { | |
| /** @type {number} */ | |
| this.width = x; | |
| /** @type {number} */ | |
| this.height = value; | |
| }; | |
| k = ff.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| k.toString = function() { | |
| return "(" + this.width + " x " + this.height + ")"; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.aspectRatio = function() { | |
| return this.width / this.height; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.ceil = function() { | |
| /** @type {number} */ | |
| this.width = Math.ceil(this.width); | |
| /** @type {number} */ | |
| this.height = Math.ceil(this.height); | |
| return this; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.floor = function() { | |
| /** @type {number} */ | |
| this.width = Math.floor(this.width); | |
| /** @type {number} */ | |
| this.height = Math.floor(this.height); | |
| return this; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.round = function() { | |
| /** @type {number} */ | |
| this.width = Math.round(this.width); | |
| /** @type {number} */ | |
| this.height = Math.round(this.height); | |
| return this; | |
| }; | |
| /** | |
| * @param {!Object} v | |
| * @return {?} | |
| */ | |
| var jf = function(v) { | |
| return v ? new gf(hf(v)) : Wa || (Wa = new gf); | |
| }; | |
| /** | |
| * @param {!Object} n | |
| * @return {?} | |
| */ | |
| var kf = function(n) { | |
| return r(n) ? document.getElementById(n) : n; | |
| }; | |
| /** | |
| * @param {string} tagName | |
| * @param {!Object} start | |
| * @return {?} | |
| */ | |
| var lf = function(tagName, start) { | |
| return (start || document).getElementsByTagName(String(tagName)); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @param {!Object} f | |
| * @return {?} | |
| */ | |
| var nf = function(name, f) { | |
| var parent = f || document; | |
| return parent.querySelectorAll && parent.querySelector ? parent.querySelectorAll("." + name) : mf(document, "*", name, f); | |
| }; | |
| /** | |
| * @param {string} value | |
| * @param {!Object} name | |
| * @return {?} | |
| */ | |
| var E = function(value, name) { | |
| var parent = name || document; | |
| /** @type {null} */ | |
| var setValue = null; | |
| if (parent.getElementsByClassName) { | |
| setValue = parent.getElementsByClassName(value)[0]; | |
| } else { | |
| setValue = of("*", value, name); | |
| } | |
| return setValue || null; | |
| }; | |
| /** | |
| * @param {string} name | |
| * @param {string} n | |
| * @return {?} | |
| */ | |
| var F = function(name, n) { | |
| n = E(name, n); | |
| return z(n, "No element found with className: " + name); | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @param {string} name | |
| * @param {!Object} type | |
| * @param {!Object} result | |
| * @return {?} | |
| */ | |
| var mf = function(data, name, type, result) { | |
| data = result || data; | |
| /** @type {string} */ | |
| name = name && "*" != name ? String(name).toUpperCase() : ""; | |
| if (data.querySelectorAll && data.querySelector && (name || type)) { | |
| return data.querySelectorAll(name + (type ? "." + type : "")); | |
| } | |
| if (type && data.getElementsByClassName) { | |
| data = data.getElementsByClassName(type); | |
| if (name) { | |
| result = {}; | |
| /** @type {number} */ | |
| var i = 0; | |
| /** @type {number} */ | |
| var j = 0; | |
| var object; | |
| for (; object = data[j]; j++) { | |
| if (name == object.nodeName) { | |
| result[i++] = object; | |
| } | |
| } | |
| /** @type {number} */ | |
| result.length = i; | |
| return result; | |
| } | |
| return data; | |
| } | |
| data = data.getElementsByTagName(name || "*"); | |
| if (type) { | |
| result = {}; | |
| /** @type {number} */ | |
| j = i = 0; | |
| for (; object = data[j]; j++) { | |
| name = object.className; | |
| if ("function" == typeof name.split && tb(name.split(/\s+/), type)) { | |
| result[i++] = object; | |
| } | |
| } | |
| /** @type {number} */ | |
| result.length = i; | |
| return result; | |
| } | |
| return data; | |
| }; | |
| /** | |
| * @param {string} value | |
| * @param {string} message | |
| * @param {!Object} name | |
| * @return {?} | |
| */ | |
| var of = function(value, message, name) { | |
| /** @type {!HTMLDocument} */ | |
| var key = document; | |
| var parent = name || key; | |
| /** @type {string} */ | |
| var selector = value && "*" != value ? String(value).toUpperCase() : ""; | |
| return parent.querySelectorAll && parent.querySelector && (selector || message) ? parent.querySelector(selector + (message ? "." + message : "")) : mf(key, value, message, name)[0] || null; | |
| }; | |
| /** | |
| * @param {!Element} a | |
| * @param {!Object} b | |
| * @return {undefined} | |
| */ | |
| var qf = function(a, b) { | |
| Mb(b, function(value, key) { | |
| if (value && "object" == typeof value && value.Gc) { | |
| value = value.Db(); | |
| } | |
| 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 (pf.hasOwnProperty(key)) { | |
| a.setAttribute(pf[key], value); | |
| } else { | |
| if (vc(key, "aria-") || vc(key, "data-")) { | |
| a.setAttribute(key, value); | |
| } else { | |
| /** @type {string} */ | |
| a[key] = value; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| }); | |
| }; | |
| var pf = { | |
| cellpadding : "cellPadding", | |
| cellspacing : "cellSpacing", | |
| colspan : "colSpan", | |
| frameborder : "frameBorder", | |
| height : "height", | |
| maxlength : "maxLength", | |
| nonce : "nonce", | |
| role : "role", | |
| rowspan : "rowSpan", | |
| type : "type", | |
| usemap : "useMap", | |
| valign : "vAlign", | |
| width : "width" | |
| }; | |
| /** | |
| * @param {!Object} doc | |
| * @return {?} | |
| */ | |
| var sf = function(doc) { | |
| doc = doc.document; | |
| doc = rf(doc) ? doc.documentElement : doc.body; | |
| return new ff(doc.clientWidth, doc.clientHeight); | |
| }; | |
| /** | |
| * @param {!Document} doc | |
| * @return {?} | |
| */ | |
| var uf = function(doc) { | |
| var body = tf(doc); | |
| doc = doc.parentWindow || doc.defaultView; | |
| return C.V && C.Ea("10") && doc.pageYOffset != body.scrollTop ? new cf(body.scrollLeft, body.scrollTop) : new cf(doc.pageXOffset || body.scrollLeft, doc.pageYOffset || body.scrollTop); | |
| }; | |
| /** | |
| * @param {!Document} document | |
| * @return {?} | |
| */ | |
| var tf = function(document) { | |
| return document.scrollingElement ? document.scrollingElement : !C.Ka && rf(document) ? document.documentElement : document.body || document.documentElement; | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @return {?} | |
| */ | |
| var vf = function(node) { | |
| return node ? node.parentWindow || node.defaultView : window; | |
| }; | |
| /** | |
| * @param {string} tag | |
| * @param {string} i | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| var G = function(tag, i, value) { | |
| return wf(document, arguments); | |
| }; | |
| /** | |
| * @param {!HTMLDocument} d | |
| * @param {!Object} args | |
| * @return {?} | |
| */ | |
| var wf = function(d, args) { | |
| /** @type {string} */ | |
| var result = String(args[0]); | |
| var t = args[1]; | |
| if (!We && t && (t.name || t.type)) { | |
| /** @type {!Array} */ | |
| result = ["<", result]; | |
| if (t.name) { | |
| result.push(' name="', fe(t.name), '"'); | |
| } | |
| if (t.type) { | |
| result.push(' type="', fe(t.type), '"'); | |
| var e = {}; | |
| Xb(e, t); | |
| delete e.type; | |
| t = e; | |
| } | |
| result.push(">"); | |
| /** @type {string} */ | |
| result = result.join(""); | |
| } | |
| result = d.createElement(result); | |
| if (t) { | |
| if (r(t)) { | |
| result.className = t; | |
| } else { | |
| if (Ka(t)) { | |
| result.className = t.join(" "); | |
| } else { | |
| qf(result, t); | |
| } | |
| } | |
| } | |
| if (2 < args.length) { | |
| xf(d, result, args, 2); | |
| } | |
| return result; | |
| }; | |
| /** | |
| * @param {!Document} d | |
| * @param {!Object} f | |
| * @param {!Object} c | |
| * @param {number} i | |
| * @return {undefined} | |
| */ | |
| var xf = function(d, f, c, i) { | |
| /** | |
| * @param {!Object} n | |
| * @return {undefined} | |
| */ | |
| function c(n) { | |
| if (n) { | |
| f.appendChild(r(n) ? d.createTextNode(n) : n); | |
| } | |
| } | |
| for (; i < c.length; i++) { | |
| var x = c[i]; | |
| if (!La(x) || Na(x) && 0 < x.nodeType) { | |
| c(x); | |
| } else { | |
| A(yf(x) ? Ab(x) : x, c); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| var zf = function(name) { | |
| return document.createElement(String(name)); | |
| }; | |
| /** | |
| * @param {string} text | |
| * @return {?} | |
| */ | |
| var Af = function(text) { | |
| return document.createTextNode(String(text)); | |
| }; | |
| /** | |
| * @param {!Object} doc | |
| * @param {string} value | |
| * @return {?} | |
| */ | |
| var Bf = function(doc, value) { | |
| var d = doc.createElement("DIV"); | |
| if ($e) { | |
| Wd(d, Od(Qd, value)); | |
| d.removeChild(z(d.firstChild)); | |
| } else { | |
| Wd(d, value); | |
| } | |
| if (1 == d.childNodes.length) { | |
| d = d.removeChild(z(d.firstChild)); | |
| } else { | |
| doc = doc.createDocumentFragment(); | |
| for (; d.firstChild;) { | |
| doc.appendChild(d.firstChild); | |
| } | |
| /** @type {!Object} */ | |
| d = doc; | |
| } | |
| return d; | |
| }; | |
| /** | |
| * @param {!Document} doc | |
| * @return {?} | |
| */ | |
| var rf = function(doc) { | |
| return "CSS1Compat" == doc.compatMode; | |
| }; | |
| /** | |
| * @param {!Object} elem | |
| * @return {?} | |
| */ | |
| var Cf = function(elem) { | |
| if (1 != elem.nodeType) { | |
| return false; | |
| } | |
| switch(elem.tagName) { | |
| case "APPLET": | |
| case "AREA": | |
| case "BASE": | |
| case "BR": | |
| case "COL": | |
| case "COMMAND": | |
| case "EMBED": | |
| case "FRAME": | |
| case "HR": | |
| case "IMG": | |
| case "INPUT": | |
| case "IFRAME": | |
| case "ISINDEX": | |
| case "KEYGEN": | |
| case "LINK": | |
| case "NOFRAMES": | |
| case "NOSCRIPT": | |
| case "META": | |
| case "OBJECT": | |
| case "PARAM": | |
| case "SCRIPT": | |
| case "SOURCE": | |
| case "STYLE": | |
| case "TRACK": | |
| case "WBR": | |
| return false; | |
| } | |
| return true; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Object} b | |
| * @return {undefined} | |
| */ | |
| var Df = function(a, b) { | |
| z(null != a && null != b, "goog.dom.appendChild expects non-null arguments"); | |
| a.appendChild(b); | |
| }; | |
| /** | |
| * @param {!Object} msg | |
| * @param {?} var_args | |
| * @return {undefined} | |
| */ | |
| var Ef = function(msg, var_args) { | |
| xf(hf(msg), msg, arguments, 1); | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @return {undefined} | |
| */ | |
| var Ff = function(o) { | |
| var c; | |
| for (; c = o.firstChild;) { | |
| o.removeChild(c); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Object} b | |
| * @return {undefined} | |
| */ | |
| var Gf = function(a, b) { | |
| z(null != a && null != b, "goog.dom.insertSiblingBefore expects non-null arguments"); | |
| if (b.parentNode) { | |
| b.parentNode.insertBefore(a, b); | |
| } | |
| }; | |
| /** | |
| * @param {?} a | |
| * @param {!Object} b | |
| * @return {undefined} | |
| */ | |
| var Hf = function(a, b) { | |
| z(null != a && null != b, "goog.dom.insertSiblingAfter expects non-null arguments"); | |
| if (b.parentNode) { | |
| b.parentNode.insertBefore(a, b.nextSibling); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} body | |
| * @param {number} n | |
| * @param {number} e | |
| * @return {undefined} | |
| */ | |
| var If = function(body, n, e) { | |
| z(null != body, "goog.dom.insertChildAt expects a non-null parent"); | |
| body.insertBefore(n, body.childNodes[e] || null); | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| var Jf = function(b) { | |
| return b && b.parentNode ? b.parentNode.removeChild(b) : null; | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| var Kf = function(b) { | |
| return Xe && void 0 != b.children ? b.children : lb(b.childNodes, function(nodeToInspect) { | |
| return 1 == nodeToInspect.nodeType; | |
| }); | |
| }; | |
| /** | |
| * @param {!HTMLElement} b | |
| * @return {?} | |
| */ | |
| var Mf = function(b) { | |
| return q(b.firstElementChild) ? b.firstElementChild : Lf(b.firstChild, true); | |
| }; | |
| /** | |
| * @param {!Object} c | |
| * @param {boolean} dir | |
| * @return {?} | |
| */ | |
| var Lf = function(c, dir) { | |
| for (; c && 1 != c.nodeType;) { | |
| c = dir ? c.nextSibling : c.previousSibling; | |
| } | |
| return c; | |
| }; | |
| /** | |
| * @param {!Object} child | |
| * @return {?} | |
| */ | |
| var Nf = function(child) { | |
| return Na(child) && 1 == child.nodeType; | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @return {?} | |
| */ | |
| var Of = function(item) { | |
| var current; | |
| if (Ze && !(C.V && C.Ea("9") && !C.Ea("10") && l.SVGElement && item instanceof l.SVGElement) && (current = item.parentElement)) { | |
| return current; | |
| } | |
| current = item.parentNode; | |
| return Nf(current) ? current : null; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {string} b | |
| * @return {?} | |
| */ | |
| var Pf = 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 {!Object} a | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| var Sf = function(a, b) { | |
| if (a == b) { | |
| return 0; | |
| } | |
| if (a.compareDocumentPosition) { | |
| return a.compareDocumentPosition(b) & 2 ? 1 : -1; | |
| } | |
| if (C.V && !C.kb(9)) { | |
| if (9 == a.nodeType) { | |
| return -1; | |
| } | |
| if (9 == b.nodeType) { | |
| return 1; | |
| } | |
| } | |
| if ("sourceIndex" in a || a.parentNode && "sourceIndex" in a.parentNode) { | |
| /** @type {boolean} */ | |
| var r = 1 == a.nodeType; | |
| /** @type {boolean} */ | |
| var s = 1 == b.nodeType; | |
| if (r && s) { | |
| return a.sourceIndex - b.sourceIndex; | |
| } | |
| var x = a.parentNode; | |
| var c = b.parentNode; | |
| return x == c ? Qf(a, b) : !r && Pf(x, b) ? -1 * Rf(a, b) : !s && Pf(c, a) ? Rf(b, a) : (r ? a.sourceIndex : x.sourceIndex) - (s ? b.sourceIndex : c.sourceIndex); | |
| } | |
| s = hf(a); | |
| r = s.createRange(); | |
| r.selectNode(a); | |
| r.collapse(true); | |
| a = s.createRange(); | |
| a.selectNode(b); | |
| a.collapse(true); | |
| return r.compareBoundaryPoints(l.Range.START_TO_END, a); | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var Rf = function(b, a) { | |
| var c = b.parentNode; | |
| if (c == a) { | |
| return -1; | |
| } | |
| for (; a.parentNode != c;) { | |
| a = a.parentNode; | |
| } | |
| return Qf(a, b); | |
| }; | |
| /** | |
| * @param {!Object} instance | |
| * @param {!Object} c | |
| * @return {?} | |
| */ | |
| var Qf = function(instance, c) { | |
| for (; c = c.previousSibling;) { | |
| if (c == instance) { | |
| return -1; | |
| } | |
| } | |
| return 1; | |
| }; | |
| /** | |
| * @param {?} a | |
| * @return {?} | |
| */ | |
| var Tf = function(a) { | |
| 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} el | |
| * @return {?} | |
| */ | |
| var hf = function(el) { | |
| z(el, "Node cannot be null or undefined."); | |
| return 9 == el.nodeType ? el : el.ownerDocument || el.document; | |
| }; | |
| /** | |
| * @param {!Element} elem | |
| * @return {?} | |
| */ | |
| var Uf = function(elem) { | |
| return elem.contentDocument || elem.contentWindow.document; | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| var H = function(node, value) { | |
| z(null != node, "goog.dom.setTextContent expects a non-null value for node"); | |
| if ("textContent" in node) { | |
| /** @type {string} */ | |
| node.textContent = value; | |
| } else { | |
| if (3 == node.nodeType) { | |
| /** @type {string} */ | |
| node.data = String(value); | |
| } else { | |
| if (node.firstChild && 3 == node.firstChild.nodeType) { | |
| for (; node.lastChild != node.firstChild;) { | |
| node.removeChild(z(node.lastChild)); | |
| } | |
| /** @type {string} */ | |
| node.firstChild.data = String(value); | |
| } else { | |
| Ff(node); | |
| var document = hf(node); | |
| node.appendChild(document.createTextNode(String(value))); | |
| } | |
| } | |
| } | |
| }; | |
| var Vf = { | |
| SCRIPT : 1, | |
| STYLE : 1, | |
| HEAD : 1, | |
| IFRAME : 1, | |
| OBJECT : 1 | |
| }; | |
| var Wf = { | |
| IMG : " ", | |
| BR : "\n" | |
| }; | |
| /** | |
| * @param {!Element} input | |
| * @param {string} init | |
| * @return {undefined} | |
| */ | |
| var Xf = function(input, init) { | |
| if (init) { | |
| /** @type {number} */ | |
| input.tabIndex = 0; | |
| } else { | |
| /** @type {number} */ | |
| input.tabIndex = -1; | |
| input.removeAttribute("tabIndex"); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} target | |
| * @return {?} | |
| */ | |
| var Yf = function(target) { | |
| return C.V && !C.Ea("9") ? (target = target.getAttributeNode("tabindex"), null != target && target.specified) : target.hasAttribute("tabindex"); | |
| }; | |
| /** | |
| * @param {number} a | |
| * @return {?} | |
| */ | |
| var Zf = function(a) { | |
| a = a.tabIndex; | |
| return Aa(a) && 0 <= a && 32768 > a; | |
| }; | |
| /** | |
| * @param {!Object} d | |
| * @return {?} | |
| */ | |
| var ag = function(d) { | |
| if (Ye && null !== d && "innerText" in d) { | |
| d = be(d.innerText); | |
| } else { | |
| /** @type {!Array} */ | |
| var b = []; | |
| $f(d, b, true); | |
| /** @type {string} */ | |
| d = b.join(""); | |
| } | |
| d = d.replace(/ \xAD /g, " ").replace(/\xAD/g, ""); | |
| d = d.replace(/\u200B/g, ""); | |
| if (!Ye) { | |
| d = d.replace(/ +/g, " "); | |
| } | |
| if (" " != d) { | |
| d = d.replace(/^\s*/, ""); | |
| } | |
| return d; | |
| }; | |
| /** | |
| * @param {!Object} str | |
| * @return {?} | |
| */ | |
| var bg = function(str) { | |
| /** @type {!Array} */ | |
| var b = []; | |
| $f(str, b, false); | |
| return b.join(""); | |
| }; | |
| /** | |
| * @param {!Object} d | |
| * @param {!Array} name | |
| * @param {string} id | |
| * @return {undefined} | |
| */ | |
| var $f = function(d, name, id) { | |
| if (!(d.nodeName in Vf)) { | |
| if (3 == d.nodeType) { | |
| if (id) { | |
| name.push(String(d.nodeValue).replace(/(\r\n|\r|\n)/g, "")); | |
| } else { | |
| name.push(d.nodeValue); | |
| } | |
| } else { | |
| if (d.nodeName in Wf) { | |
| name.push(Wf[d.nodeName]); | |
| } else { | |
| d = d.firstChild; | |
| for (; d;) { | |
| $f(d, name, id); | |
| d = d.nextSibling; | |
| } | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} y | |
| * @return {?} | |
| */ | |
| var yf = function(y) { | |
| if (y && "number" == typeof y.length) { | |
| if (Na(y)) { | |
| return "function" == typeof y.item || "string" == typeof y.item; | |
| } | |
| if (Ma(y)) { | |
| return "function" == typeof y.item; | |
| } | |
| } | |
| return false; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var dg = function(a) { | |
| return cg(a, function(options) { | |
| return r(options.className) && tb(options.className.split(/\s+/), "gt-baf-entry-clickable"); | |
| }, void 0); | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @param {!Function} doc | |
| * @param {number} scrollLeft | |
| * @return {?} | |
| */ | |
| var cg = function(node, doc, scrollLeft) { | |
| /** @type {number} */ | |
| var firstColLeft = 0; | |
| for (; node && (null == scrollLeft || firstColLeft <= scrollLeft);) { | |
| z("parentNode" != node.name); | |
| if (doc(node)) { | |
| return node; | |
| } | |
| node = node.parentNode; | |
| firstColLeft++; | |
| } | |
| return null; | |
| }; | |
| /** | |
| * @param {!HTMLDocument} doc | |
| * @return {?} | |
| */ | |
| var eg = function(doc) { | |
| try { | |
| var context = doc && doc.activeElement; | |
| return context && context.nodeName ? context : null; | |
| } catch (c) { | |
| return null; | |
| } | |
| }; | |
| /** | |
| * @param {string} opt_document | |
| * @return {undefined} | |
| */ | |
| var gf = function(opt_document) { | |
| this.a = opt_document || l.document || document; | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {?} | |
| */ | |
| gf.prototype.j = function(type) { | |
| return r(type) ? this.a.getElementById(type) : type; | |
| }; | |
| /** @type {function(!Object): ?} */ | |
| gf.prototype.c = gf.prototype.j; | |
| /** | |
| * @param {string} a | |
| * @param {string} b | |
| * @return {?} | |
| */ | |
| gf.prototype.Ld = function(a, b) { | |
| return E(a, b || this.a); | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @param {string} value | |
| * @param {string} str | |
| * @return {?} | |
| */ | |
| gf.prototype.b = function(name, value, str) { | |
| return wf(this.a, arguments); | |
| }; | |
| /** | |
| * @param {(number|string)} row | |
| * @param {string} tag | |
| * @return {?} | |
| */ | |
| var fg = function(row, tag) { | |
| return row.a.createElement(String(tag)); | |
| }; | |
| /** | |
| * @param {!Object} doc | |
| * @return {?} | |
| */ | |
| var gg = function(doc) { | |
| doc = doc.a; | |
| return doc.parentWindow || doc.defaultView; | |
| }; | |
| k = gf.prototype; | |
| /** @type {function(!Object, !Object): undefined} */ | |
| k.appendChild = Df; | |
| /** @type {function(!Object, ?): undefined} */ | |
| k.Zi = Ef; | |
| /** @type {function(!Object): undefined} */ | |
| k.Tf = Ff; | |
| /** @type {function(!Object): ?} */ | |
| k.bj = Jf; | |
| /** @type {function(!Object): ?} */ | |
| k.$i = Kf; | |
| /** @type {function(!HTMLElement): ?} */ | |
| k.Yi = Mf; | |
| /** @type {function(!Object): ?} */ | |
| k.un = Nf; | |
| /** @type {function(string, string): ?} */ | |
| k.contains = Pf; | |
| /** @type {function(!Object, string): undefined} */ | |
| k.Uf = H; | |
| /** @type {function(!Object): ?} */ | |
| k.aj = ag; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var hg = function() { | |
| this.Ac = this.Ac; | |
| this.Ga = this.Ga; | |
| }; | |
| /** @type {boolean} */ | |
| hg.prototype.Ac = false; | |
| /** | |
| * @return {undefined} | |
| */ | |
| hg.prototype.Qa = function() { | |
| if (!this.Ac) { | |
| /** @type {boolean} */ | |
| this.Ac = true; | |
| this.X(); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} c | |
| * @param {?} match | |
| * @return {undefined} | |
| */ | |
| var jg = function(c, match) { | |
| match = Ta(ig, match); | |
| if (c.Ac) { | |
| if (q(void 0)) { | |
| match.call(void 0); | |
| } else { | |
| match(); | |
| } | |
| } else { | |
| if (!c.Ga) { | |
| /** @type {!Array} */ | |
| c.Ga = []; | |
| } | |
| c.Ga.push(q(void 0) ? v(match, void 0) : match); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| hg.prototype.X = function() { | |
| if (this.Ga) { | |
| for (; this.Ga.length;) { | |
| this.Ga.shift()(); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {boolean} value | |
| * @return {undefined} | |
| */ | |
| var ig = function(value) { | |
| if (value && "function" == typeof value.Qa) { | |
| value.Qa(); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} input | |
| * @param {string} options | |
| * @return {undefined} | |
| */ | |
| var kg = function(input, options) { | |
| /** @type {!Object} */ | |
| this.type = input; | |
| this.a = this.target = options; | |
| /** @type {boolean} */ | |
| this.defaultPrevented = this.c = false; | |
| /** @type {boolean} */ | |
| this.Nj = true; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| kg.prototype.stopPropagation = function() { | |
| /** @type {boolean} */ | |
| this.c = true; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| kg.prototype.preventDefault = function() { | |
| /** @type {boolean} */ | |
| this.defaultPrevented = true; | |
| /** @type {boolean} */ | |
| this.Nj = false; | |
| }; | |
| /** @type {function(T): T} */ | |
| var lg = Object.freeze || function(otherTokenValues) { | |
| return otherTokenValues; | |
| }; | |
| var mg = !C.V || C.kb(9); | |
| var ng = !C.V || C.kb(9); | |
| var og = C.V && !C.Ea("9"); | |
| var pg = function() { | |
| if (!l.addEventListener || !Object.defineProperty) { | |
| return false; | |
| } | |
| /** @type {boolean} */ | |
| var a = false; | |
| /** @type {!Object} */ | |
| var options = Object.defineProperty({}, "passive", { | |
| get : function() { | |
| /** @type {boolean} */ | |
| a = true; | |
| } | |
| }); | |
| try { | |
| l.addEventListener("test", Ha, options); | |
| l.removeEventListener("test", Ha, options); | |
| } catch (c) { | |
| } | |
| return a; | |
| }(); | |
| var qg; | |
| /** @type {string} */ | |
| qg = C.Ka ? "webkitTransitionEnd" : C.cb ? "otransitionend" : "transitionend"; | |
| var rg = { | |
| Oe : "mousedown", | |
| Pe : "mouseup", | |
| Ne : "mousecancel", | |
| ir : "mousemove", | |
| kr : "mouseover", | |
| jr : "mouseout", | |
| er : "mouseenter", | |
| gr : "mouseleave" | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @param {!Object} target | |
| * @return {undefined} | |
| */ | |
| var tg = function(e, target) { | |
| kg.call(this, e ? e.type : ""); | |
| /** @type {null} */ | |
| this.relatedTarget = this.a = this.target = null; | |
| /** @type {number} */ | |
| this.button = this.screenY = this.screenX = this.clientY = this.clientX = 0; | |
| /** @type {string} */ | |
| this.key = ""; | |
| /** @type {number} */ | |
| this.keyCode = 0; | |
| /** @type {boolean} */ | |
| this.metaKey = this.shiftKey = this.altKey = this.ctrlKey = false; | |
| /** @type {null} */ | |
| this.state = null; | |
| /** @type {boolean} */ | |
| this.g = false; | |
| /** @type {number} */ | |
| this.pointerId = 0; | |
| /** @type {string} */ | |
| this.pointerType = ""; | |
| /** @type {null} */ | |
| this.b = null; | |
| if (e) { | |
| var type = this.type = e.type; | |
| var relevantTouch = e.changedTouches && e.changedTouches.length ? e.changedTouches[0] : null; | |
| this.target = e.target || e.srcElement; | |
| /** @type {!Object} */ | |
| this.a = target; | |
| if (target = e.relatedTarget) { | |
| if (C.Ja) { | |
| if (!ve(target, "nodeName")) { | |
| /** @type {null} */ | |
| target = null; | |
| } | |
| } | |
| } else { | |
| if ("mouseover" == type) { | |
| target = e.fromElement; | |
| } else { | |
| if ("mouseout" == type) { | |
| target = e.toElement; | |
| } | |
| } | |
| } | |
| /** @type {!Object} */ | |
| this.relatedTarget = target; | |
| if (relevantTouch) { | |
| 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; | |
| } else { | |
| this.clientX = void 0 !== e.clientX ? e.clientX : e.pageX; | |
| this.clientY = void 0 !== e.clientY ? e.clientY : e.pageY; | |
| this.screenX = e.screenX || 0; | |
| this.screenY = e.screenY || 0; | |
| } | |
| this.button = e.button; | |
| this.keyCode = e.keyCode || 0; | |
| this.key = e.key || ""; | |
| this.ctrlKey = e.ctrlKey; | |
| this.altKey = e.altKey; | |
| this.shiftKey = e.shiftKey; | |
| this.metaKey = e.metaKey; | |
| this.g = C.yb ? e.metaKey : e.ctrlKey; | |
| this.pointerId = e.pointerId || 0; | |
| this.pointerType = r(e.pointerType) ? e.pointerType : sg[e.pointerType] || ""; | |
| this.state = e.state; | |
| /** @type {!Object} */ | |
| this.b = e; | |
| if (e.defaultPrevented) { | |
| this.preventDefault(); | |
| } | |
| } | |
| }; | |
| x(tg, kg); | |
| /** @type {!Array} */ | |
| var ug = lg([1, 4, 2]); | |
| var sg = lg({ | |
| 2 : "touch", | |
| 3 : "pen", | |
| 4 : "mouse" | |
| }); | |
| /** | |
| * @param {!Object} e | |
| * @return {?} | |
| */ | |
| var vg = function(e) { | |
| return (mg ? 0 == e.b.button : "click" == e.type ? true : !!(e.b.button & ug[0])) && !(C.Ka && C.yb && e.ctrlKey); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| tg.prototype.stopPropagation = function() { | |
| tg.D.stopPropagation.call(this); | |
| if (this.b.stopPropagation) { | |
| this.b.stopPropagation(); | |
| } else { | |
| /** @type {boolean} */ | |
| this.b.cancelBubble = true; | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| tg.prototype.preventDefault = function() { | |
| tg.D.preventDefault.call(this); | |
| var e = this.b; | |
| if (e.preventDefault) { | |
| e.preventDefault(); | |
| } else { | |
| if (e.returnValue = false, og) { | |
| try { | |
| if (e.ctrlKey || 112 <= e.keyCode && 123 >= e.keyCode) { | |
| /** @type {number} */ | |
| e.keyCode = -1; | |
| } | |
| } catch (b) { | |
| } | |
| } | |
| } | |
| }; | |
| /** @type {string} */ | |
| var wg = "closure_listenable_" + (1E6 * Math.random() | 0); | |
| /** | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| var xg = function(b) { | |
| return !(!b || !b[wg]); | |
| }; | |
| /** @type {number} */ | |
| var yg = 0; | |
| /** | |
| * @param {!Object} callback | |
| * @param {string} link | |
| * @param {!Object} src | |
| * @param {?} bandages | |
| * @param {?} REPLACED | |
| * @return {undefined} | |
| */ | |
| var zg = 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.capture = !!bandages; | |
| this.jg = REPLACED; | |
| /** @type {number} */ | |
| this.key = ++yg; | |
| /** @type {boolean} */ | |
| this.ye = this.Cf = false; | |
| }; | |
| /** | |
| * @param {!Object} req | |
| * @return {undefined} | |
| */ | |
| var Ag = function(req) { | |
| /** @type {boolean} */ | |
| req.ye = true; | |
| /** @type {null} */ | |
| req.listener = null; | |
| /** @type {null} */ | |
| req.a = null; | |
| /** @type {null} */ | |
| req.src = null; | |
| /** @type {null} */ | |
| req.jg = null; | |
| }; | |
| /** | |
| * @param {string} src | |
| * @return {undefined} | |
| */ | |
| var Bg = function(src) { | |
| /** @type {string} */ | |
| this.src = src; | |
| this.a = {}; | |
| /** @type {number} */ | |
| this.b = 0; | |
| }; | |
| /** | |
| * @param {string} key | |
| * @param {string} value | |
| * @param {boolean} deps | |
| * @param {!Function} name | |
| * @param {!Object} d | |
| * @return {?} | |
| */ | |
| Bg.prototype.add = function(key, value, deps, name, d) { | |
| var i = key.toString(); | |
| key = this.a[i]; | |
| if (!key) { | |
| /** @type {!Array} */ | |
| key = this.a[i] = []; | |
| this.b++; | |
| } | |
| var p = Cg(key, value, name, d); | |
| if (-1 < p) { | |
| value = key[p]; | |
| if (!deps) { | |
| /** @type {boolean} */ | |
| value.Cf = false; | |
| } | |
| } else { | |
| value = new zg(value, this.src, i, !!name, d); | |
| /** @type {boolean} */ | |
| value.Cf = deps; | |
| key.push(value); | |
| } | |
| return value; | |
| }; | |
| /** | |
| * @param {!Object} event | |
| * @param {?} data | |
| * @return {?} | |
| */ | |
| var Dg = function(event, data) { | |
| var type = data.type; | |
| if (!(type in event.a)) { | |
| return false; | |
| } | |
| var renderedHtml = xb(event.a[type], data); | |
| if (renderedHtml) { | |
| Ag(data); | |
| if (0 == event.a[type].length) { | |
| delete event.a[type]; | |
| event.b--; | |
| } | |
| } | |
| return renderedHtml; | |
| }; | |
| /** | |
| * @param {string} m | |
| * @param {boolean} b | |
| * @return {?} | |
| */ | |
| Bg.prototype.Mf = function(m, b) { | |
| m = this.a[m.toString()]; | |
| /** @type {!Array} */ | |
| var homeSortedByRow = []; | |
| if (m) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < m.length; ++i) { | |
| var a = m[i]; | |
| if (a.capture == b) { | |
| homeSortedByRow.push(a); | |
| } | |
| } | |
| } | |
| return homeSortedByRow; | |
| }; | |
| /** | |
| * @param {string} data | |
| * @param {string} num | |
| * @param {!Object} max | |
| * @param {string} item | |
| * @return {?} | |
| */ | |
| Bg.prototype.Ze = function(data, num, max, item) { | |
| data = this.a[data.toString()]; | |
| /** @type {number} */ | |
| var min = -1; | |
| if (data) { | |
| min = Cg(data, num, max, item); | |
| } | |
| return -1 < min ? data[min] : null; | |
| }; | |
| /** | |
| * @param {string} target | |
| * @param {?} name | |
| * @return {?} | |
| */ | |
| Bg.prototype.hasListener = function(target, name) { | |
| var err = q(target); | |
| var args = err ? target.toString() : ""; | |
| var result = q(name); | |
| return Nb(this.a, function(listeners) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < listeners.length; ++i) { | |
| if (!(err && listeners[i].type != args || result && listeners[i].capture != name)) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| }); | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {!Object} b | |
| * @param {!Function} num | |
| * @param {!Object} word | |
| * @return {?} | |
| */ | |
| var Cg = function(a, b, num, word) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < a.length; ++i) { | |
| var item = a[i]; | |
| if (!item.ye && item.listener == b && item.capture == !!num && item.jg == word) { | |
| return i; | |
| } | |
| } | |
| return -1; | |
| }; | |
| /** @type {string} */ | |
| var Eg = "closure_lm_" + (1E6 * Math.random() | 0); | |
| var Fg = {}; | |
| /** @type {number} */ | |
| var Gg = 0; | |
| /** | |
| * @param {!Object} options | |
| * @param {string} name | |
| * @param {!Function} val | |
| * @param {!Object} e | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| var I = function(options, name, val, e, value) { | |
| if (e && e.once) { | |
| return Hg(options, name, val, e, value); | |
| } | |
| if (Ka(name)) { | |
| /** @type {number} */ | |
| var curPos = 0; | |
| for (; curPos < name.length; curPos++) { | |
| I(options, name[curPos], val, e, value); | |
| } | |
| return null; | |
| } | |
| val = Ig(val); | |
| return xg(options) ? options.M(name, val, Na(e) ? !!e.capture : !!e, value) : Jg(options, name, val, false, e, value); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} q | |
| * @param {!Object} m | |
| * @param {!Object} o | |
| * @param {?} options | |
| * @param {!Object} callback | |
| * @return {?} | |
| */ | |
| var Jg = function(a, q, m, o, options, callback) { | |
| if (!q) { | |
| throw Error("Invalid event type"); | |
| } | |
| /** @type {boolean} */ | |
| var context = Na(options) ? !!options.capture : !!options; | |
| var fn = Kg(a); | |
| if (!fn) { | |
| a[Eg] = fn = new Bg(a); | |
| } | |
| m = fn.add(q, m, o, context, callback); | |
| if (m.a) { | |
| return m; | |
| } | |
| o = Lg(); | |
| /** @type {!Object} */ | |
| m.a = o; | |
| /** @type {!Object} */ | |
| o.src = a; | |
| /** @type {!Object} */ | |
| o.listener = m; | |
| if (a.addEventListener) { | |
| if (!pg) { | |
| /** @type {boolean} */ | |
| options = context; | |
| } | |
| if (void 0 === options) { | |
| /** @type {boolean} */ | |
| options = false; | |
| } | |
| a.addEventListener(q.toString(), o, options); | |
| } else { | |
| if (a.attachEvent) { | |
| a.attachEvent(Mg(q.toString()), o); | |
| } else { | |
| if (a.addListener && a.removeListener) { | |
| z("change" === q, "MediaQueryList only has a change event"); | |
| a.addListener(o); | |
| } else { | |
| throw Error("addEventListener and attachEvent are unavailable."); | |
| } | |
| } | |
| } | |
| Gg++; | |
| return m; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var Lg = function() { | |
| /** @type {function(!Object, !Object): ?} */ | |
| var proxyCallbackFunction = Ng; | |
| /** @type {function(?): ?} */ | |
| var f = ng ? 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} a | |
| * @param {string} m | |
| * @param {string} b | |
| * @param {!Object} v | |
| * @param {!Object} r | |
| * @return {?} | |
| */ | |
| var Hg = function(a, m, b, v, r) { | |
| if (Ka(m)) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < m.length; i++) { | |
| Hg(a, m[i], b, v, r); | |
| } | |
| return null; | |
| } | |
| b = Ig(b); | |
| return xg(a) ? a.Hh(m, b, Na(v) ? !!v.capture : !!v, r) : Jg(a, m, b, true, v, r); | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @param {string} name | |
| * @param {boolean} e | |
| * @param {!Object} value | |
| * @param {string} key | |
| * @return {undefined} | |
| */ | |
| var Og = function(node, name, e, value, key) { | |
| if (Ka(name)) { | |
| /** @type {number} */ | |
| var curPos = 0; | |
| for (; curPos < name.length; curPos++) { | |
| Og(node, name[curPos], e, value, key); | |
| } | |
| } else { | |
| /** @type {boolean} */ | |
| value = Na(value) ? !!value.capture : !!value; | |
| e = Ig(e); | |
| if (xg(node)) { | |
| node.Ma(name, e, value, key); | |
| } else { | |
| if (node && (node = Kg(node)) && (name = node.Ze(name, e, value, key))) { | |
| Pg(name); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} opts | |
| * @return {?} | |
| */ | |
| var Pg = function(opts) { | |
| if (Aa(opts) || !opts || opts.ye) { | |
| return false; | |
| } | |
| var s = opts.src; | |
| if (xg(s)) { | |
| return Dg(s.$b, opts); | |
| } | |
| var type = opts.type; | |
| var d = opts.a; | |
| if (s.removeEventListener) { | |
| s.removeEventListener(type, d, opts.capture); | |
| } else { | |
| if (s.detachEvent) { | |
| s.detachEvent(Mg(type), d); | |
| } else { | |
| if (s.addListener && s.removeListener) { | |
| s.removeListener(d); | |
| } | |
| } | |
| } | |
| Gg--; | |
| if (type = Kg(s)) { | |
| Dg(type, opts); | |
| if (0 == type.b) { | |
| /** @type {null} */ | |
| type.src = null; | |
| /** @type {null} */ | |
| s[Eg] = null; | |
| } | |
| } else { | |
| Ag(opts); | |
| } | |
| return true; | |
| }; | |
| /** | |
| * @param {!Object} m | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| var Qg = function(m, name) { | |
| if (!m) { | |
| return 0; | |
| } | |
| if (xg(m)) { | |
| return m.Nh(name); | |
| } | |
| m = Kg(m); | |
| if (!m) { | |
| return 0; | |
| } | |
| /** @type {number} */ | |
| var c = 0; | |
| name = name && name.toString(); | |
| var i; | |
| for (i in m.a) { | |
| if (!name || i == name) { | |
| var crossfilterable_layers = m.a[i].concat(); | |
| /** @type {number} */ | |
| var layer_i = 0; | |
| for (; layer_i < crossfilterable_layers.length; ++layer_i) { | |
| if (Pg(crossfilterable_layers[layer_i])) { | |
| ++c; | |
| } | |
| } | |
| } | |
| } | |
| return c; | |
| }; | |
| /** | |
| * @param {string} type | |
| * @return {?} | |
| */ | |
| var Mg = function(type) { | |
| return type in Fg ? Fg[type] : Fg[type] = "on" + type; | |
| }; | |
| /** | |
| * @param {!Object} i | |
| * @param {!Object} input | |
| * @param {boolean} table | |
| * @param {!Object} obj | |
| * @return {?} | |
| */ | |
| var Sg = function(i, input, table, obj) { | |
| /** @type {boolean} */ | |
| var openMBItem = true; | |
| if (i = Kg(i)) { | |
| if (input = i.a[input.toString()]) { | |
| input = input.concat(); | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < input.length; i++) { | |
| var item = input[i]; | |
| if (item && item.capture == table && !item.ye) { | |
| item = Rg(item, obj); | |
| /** @type {boolean} */ | |
| openMBItem = openMBItem && false !== item; | |
| } | |
| } | |
| } | |
| } | |
| return openMBItem; | |
| }; | |
| /** | |
| * @param {!Object} query | |
| * @param {!Object} result | |
| * @return {?} | |
| */ | |
| var Rg = function(query, result) { | |
| var l = query.listener; | |
| var modifier = query.jg || query.src; | |
| if (query.Cf) { | |
| Pg(query); | |
| } | |
| return l.call(modifier, result); | |
| }; | |
| /** | |
| * @param {!Object} n | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var Tg = function(n, a) { | |
| z(xg(n), "Can not use goog.events.dispatchEvent with non-goog.events.Listenable instance."); | |
| n.dispatchEvent(a); | |
| }; | |
| /** | |
| * @param {!Object} s | |
| * @param {!Object} obj | |
| * @return {?} | |
| */ | |
| var Ng = function(s, obj) { | |
| if (s.ye) { | |
| return true; | |
| } | |
| if (!ng) { | |
| var data = obj || Ga("window.event"); | |
| obj = new tg(data, this); | |
| /** @type {boolean} */ | |
| var result = true; | |
| if (!(0 > data.keyCode || void 0 != data.returnValue)) { | |
| a: { | |
| /** @type {boolean} */ | |
| var i = false; | |
| if (0 == data.keyCode) { | |
| try { | |
| /** @type {number} */ | |
| data.keyCode = -1; | |
| break a; | |
| } catch (g) { | |
| /** @type {boolean} */ | |
| i = true; | |
| } | |
| } | |
| if (i || void 0 == data.returnValue) { | |
| /** @type {boolean} */ | |
| data.returnValue = true; | |
| } | |
| } | |
| /** @type {!Array} */ | |
| data = []; | |
| i = obj.a; | |
| for (; i; i = i.parentNode) { | |
| data.push(i); | |
| } | |
| s = s.type; | |
| /** @type {number} */ | |
| i = data.length - 1; | |
| for (; !obj.c && 0 <= i; i--) { | |
| obj.a = data[i]; | |
| var r = Sg(data[i], s, true, obj); | |
| result = result && r; | |
| } | |
| /** @type {number} */ | |
| i = 0; | |
| for (; !obj.c && i < data.length; i++) { | |
| obj.a = data[i]; | |
| r = Sg(data[i], s, false, obj); | |
| result = result && r; | |
| } | |
| } | |
| return result; | |
| } | |
| return Rg(s, new tg(obj, this)); | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| var Kg = function(value) { | |
| value = value[Eg]; | |
| return value instanceof Bg ? value : null; | |
| }; | |
| /** @type {string} */ | |
| var Ug = "__closure_events_fn_" + (1E9 * Math.random() >>> 0); | |
| /** | |
| * @param {!Function} d | |
| * @return {?} | |
| */ | |
| var Ig = function(d) { | |
| z(d, "Listener can not be null."); | |
| if (Ma(d)) { | |
| return d; | |
| } | |
| z(d.handleEvent, "An object listener must have handleEvent method."); | |
| if (!d[Ug]) { | |
| /** | |
| * @param {!Object} id | |
| * @return {?} | |
| */ | |
| d[Ug] = function(id) { | |
| return d.handleEvent(id); | |
| }; | |
| } | |
| return d[Ug]; | |
| }; | |
| /** | |
| * @param {!Event} event | |
| * @return {?} | |
| */ | |
| var Wg = function(event) { | |
| if (event.altKey && !event.ctrlKey || event.metaKey || 112 <= event.keyCode && 123 >= event.keyCode) { | |
| return false; | |
| } | |
| if (Vg(event.keyCode)) { | |
| return true; | |
| } | |
| 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 !C.Ja; | |
| default: | |
| return 166 > event.keyCode || 183 < event.keyCode; | |
| } | |
| }; | |
| /** | |
| * @param {number} b | |
| * @param {number} a | |
| * @param {(boolean|string)} i | |
| * @param {undefined} p | |
| * @param {string} actual | |
| * @param {string} expected | |
| * @return {?} | |
| */ | |
| var Yg = function(b, a, i, p, actual, expected) { | |
| if (C.Ka && !C.Ea("525")) { | |
| return true; | |
| } | |
| if (C.yb && actual) { | |
| return Vg(b); | |
| } | |
| if (actual && !p) { | |
| return false; | |
| } | |
| if (!C.Ja) { | |
| if (Aa(a)) { | |
| a = Xg(a); | |
| } | |
| var g = 17 == a || 18 == a || C.yb && 91 == a; | |
| if ((!i || C.yb) && g || C.yb && 16 == a && (p || expected)) { | |
| return false; | |
| } | |
| } | |
| if ((C.Ka || C.vb) && p && i) { | |
| switch(b) { | |
| 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 (C.V && p && a == b) { | |
| return false; | |
| } | |
| switch(b) { | |
| case 13: | |
| return C.Ja ? expected || actual ? false : !(i && p) : true; | |
| case 27: | |
| return !(C.Ka || C.vb || C.Ja); | |
| } | |
| return C.Ja && (p || actual || expected) ? false : Vg(b); | |
| }; | |
| /** | |
| * @param {number} actual | |
| * @return {?} | |
| */ | |
| var Vg = function(actual) { | |
| if (48 <= actual && 57 >= actual || 96 <= actual && 106 >= actual || 65 <= actual && 90 >= actual || (C.Ka || C.vb) && 0 == actual) { | |
| return true; | |
| } | |
| switch(actual) { | |
| 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: | |
| case 163: | |
| return true; | |
| case 173: | |
| return C.Ja; | |
| default: | |
| return false; | |
| } | |
| }; | |
| /** | |
| * @param {number} key | |
| * @return {?} | |
| */ | |
| var Xg = function(key) { | |
| if (C.Ja) { | |
| key = Zg(key); | |
| } else { | |
| if (C.yb && C.Ka) { | |
| switch(key) { | |
| case 93: | |
| /** @type {number} */ | |
| key = 91; | |
| } | |
| } | |
| } | |
| return key; | |
| }; | |
| /** | |
| * @param {number} gen_id | |
| * @return {?} | |
| */ | |
| var Zg = function(gen_id) { | |
| switch(gen_id) { | |
| case 61: | |
| return 187; | |
| case 59: | |
| return 186; | |
| case 173: | |
| return 189; | |
| case 224: | |
| return 91; | |
| case 0: | |
| return 224; | |
| default: | |
| return gen_id; | |
| } | |
| }; | |
| /** | |
| * @param {!Event} target | |
| * @param {!Array} arr | |
| * @return {undefined} | |
| */ | |
| var $g = function(target, arr) { | |
| arr = Ab(arr); | |
| var i = eg(document); | |
| if (i) { | |
| var idx = arr.indexOf(i); | |
| i = idx + 1 === arr.length ? 0 : idx + 1; | |
| /** @type {number} */ | |
| idx = 0 > idx - 1 ? arr.length - 1 : idx - 1; | |
| switch(target.keyCode) { | |
| case 39: | |
| arr[i].focus(); | |
| break; | |
| case 37: | |
| arr[idx].focus(); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} t | |
| * @param {!Function} d | |
| * @return {undefined} | |
| */ | |
| var ah = function(t, d) { | |
| I(t, "click", d, false); | |
| I(t, "keypress", function(e) { | |
| if (13 === e.keyCode) { | |
| d(e); | |
| } | |
| }, false); | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {string} b | |
| * @param {string} q | |
| * @param {number} numReadyFiles | |
| * @return {undefined} | |
| */ | |
| var bh = function(a, b, q, numReadyFiles) { | |
| if (window.__gaTracker) { | |
| __gaTracker("send", "event", a, b, q, numReadyFiles); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} c | |
| * @return {undefined} | |
| */ | |
| var jh = function(c) { | |
| /** @type {boolean} */ | |
| this.b = false; | |
| /** @type {!Array} */ | |
| this.a = []; | |
| this.c = {}; | |
| /** @type {number} */ | |
| var title = 0; | |
| for (; title < J(c, 1); title++) { | |
| var val = ch(c, title); | |
| var el = K(val, 0); | |
| /** @type {string} */ | |
| var i = ""; | |
| if (dh(val, 3)) { | |
| i = K(val, 3); | |
| } | |
| if (el in this.c) { | |
| el = this.c[el]; | |
| } else { | |
| val = new eh(el, i); | |
| this.c[el] = val; | |
| this.a.push(val); | |
| el = val; | |
| } | |
| /** @type {number} */ | |
| val = 0; | |
| for (; val < ch(c, title).b(); val++) { | |
| var a = ch(c, title).c(val); | |
| i = a; | |
| i = 0 == J(i, 2) ? -Qa(i) : fh(i, 2, 0); | |
| var n = el; | |
| if (i in n.b) { | |
| i = n.b[i]; | |
| } else { | |
| var x = new gh; | |
| n.b[i] = x; | |
| n.a.push(x); | |
| i = x; | |
| } | |
| n = K(a, 0); | |
| x = K(a, 4); | |
| var len = dh(a, 3) ? hh(a, 3) : -1; | |
| /** @type {!Array} */ | |
| var stack = []; | |
| /** @type {number} */ | |
| var sort = 0; | |
| for (; sort < J(a, 1); sort++) { | |
| stack.push(fh(a, 1, sort)); | |
| } | |
| a = i; | |
| if (!(n in a.b)) { | |
| x = new ih(n, x, len, stack); | |
| a.b[n] = x; | |
| a.a.push(x); | |
| } | |
| this.b |= 1 < i.a.length; | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {(number|string)} a | |
| * @return {?} | |
| */ | |
| var kh = 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 d = 0; | |
| /** @type {number} */ | |
| var j = 0; | |
| for (; j < i.a.length; j++) { | |
| d = d + i.a[j].a.length; | |
| } | |
| b = b + d; | |
| } | |
| /** @type {number} */ | |
| i = x = 0; | |
| for (; i < a.a.length; i++) { | |
| d = a.a[i]; | |
| /** @type {number} */ | |
| var e = j = 0; | |
| for (; e < d.a.length; e++) { | |
| var element = d.a[e]; | |
| /** @type {number} */ | |
| var dups = 0; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < element.a.length; i++) { | |
| /** @type {number} */ | |
| dups = dups + (element.a[i].a ? 1 : 0); | |
| } | |
| /** @type {number} */ | |
| j = j + dups; | |
| } | |
| /** @type {number} */ | |
| x = x + j; | |
| } | |
| return b - x; | |
| }; | |
| /** | |
| * @param {!Object} fn | |
| * @return {?} | |
| */ | |
| var lh = function(fn) { | |
| /** @type {!Array} */ | |
| var _whitespaceCharClass = []; | |
| /** @type {number} */ | |
| var j = 0; | |
| for (; j < fn.a.length; j++) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < fn.a[j].a.length; i++) { | |
| Array.prototype.push.apply(_whitespaceCharClass, fn.a[j].a[i].a); | |
| } | |
| } | |
| return _whitespaceCharClass; | |
| }; | |
| /** | |
| * @param {!Object} fn | |
| * @return {undefined} | |
| */ | |
| var mh = function(fn) { | |
| /** @type {number} */ | |
| var j = 0; | |
| for (; j < fn.a.length; j++) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < fn.a[j].a.length; i++) { | |
| fn.a[j].a[i].a.sort(function(_pointM, _pointB) { | |
| return _pointB.Wb - _pointM.Wb; | |
| }); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} q | |
| * @param {number} value | |
| * @return {undefined} | |
| */ | |
| var eh = function(q, value) { | |
| /** @type {string} */ | |
| this.g = q; | |
| /** @type {number} */ | |
| this.c = value; | |
| /** @type {!Array} */ | |
| this.a = []; | |
| this.b = {}; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| eh.prototype.Wb = function() { | |
| /** @type {number} */ | |
| var widestInView = 0; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < this.a.length; i++) { | |
| /** @type {number} */ | |
| widestInView = Math.max(widestInView, this.a[i].Wb()); | |
| } | |
| return widestInView; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var oh = function(a) { | |
| /** @type {number} */ | |
| var e = 0; | |
| for (; e < a.a.length; e++) { | |
| if (nh(a.a[e])) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var gh = function() { | |
| /** @type {!Array} */ | |
| this.a = []; | |
| this.b = {}; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| gh.prototype.Wb = function() { | |
| /** @type {number} */ | |
| var widestInView = 0; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < this.a.length; i++) { | |
| /** @type {number} */ | |
| widestInView = Math.max(widestInView, this.a[i].Wb); | |
| } | |
| return widestInView; | |
| }; | |
| /** | |
| * @param {(number|string)} a | |
| * @return {?} | |
| */ | |
| var nh = function(a) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < a.a.length; i++) { | |
| if (a.a[i].a) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| }; | |
| /** | |
| * @param {string} index | |
| * @param {?} ch | |
| * @param {?} hash | |
| * @param {!Object} badrs | |
| * @return {undefined} | |
| */ | |
| var ih = function(index, ch, hash, badrs) { | |
| /** @type {string} */ | |
| this.text = index; | |
| this.nf = ch; | |
| this.Wb = hash; | |
| /** @type {!Object} */ | |
| this.Bg = badrs; | |
| /** @type {boolean} */ | |
| this.a = false; | |
| /** @type {number} */ | |
| this.b = 0; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var L = function() { | |
| hg.call(this); | |
| this.$b = new Bg(this); | |
| this.bl = this; | |
| /** @type {null} */ | |
| this.Mh = null; | |
| }; | |
| x(L, hg); | |
| /** @type {boolean} */ | |
| L.prototype[wg] = true; | |
| k = L.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Nf = function() { | |
| return this.Mh; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| k.Vd = function(a) { | |
| /** @type {!Object} */ | |
| this.Mh = a; | |
| }; | |
| /** | |
| * @param {string} type | |
| * @param {!Object} listener | |
| * @param {string} eventName | |
| * @param {!Object} callback | |
| * @return {undefined} | |
| */ | |
| k.addEventListener = function(type, listener, eventName, callback) { | |
| I(this, type, listener, eventName, callback); | |
| }; | |
| /** | |
| * @param {string} type | |
| * @param {!Array} listener | |
| * @param {?} evt | |
| * @param {string} f | |
| * @return {undefined} | |
| */ | |
| k.removeEventListener = function(type, listener, evt, f) { | |
| Og(this, type, listener, evt, f); | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {?} | |
| */ | |
| k.dispatchEvent = function(type) { | |
| ph(this); | |
| var obj = this.Nf(); | |
| if (obj) { | |
| /** @type {!Array} */ | |
| var a = []; | |
| /** @type {number} */ | |
| var name = 1; | |
| for (; obj; obj = obj.Nf()) { | |
| a.push(obj); | |
| z(1E3 > ++name, "infinite loop"); | |
| } | |
| } | |
| obj = this.bl; | |
| name = type.type || type; | |
| if (r(type)) { | |
| type = new kg(type, obj); | |
| } else { | |
| if (type instanceof kg) { | |
| type.target = type.target || obj; | |
| } else { | |
| /** @type {!Object} */ | |
| var result = type; | |
| type = new kg(name, obj); | |
| Xb(type, result); | |
| } | |
| } | |
| /** @type {boolean} */ | |
| result = true; | |
| if (a) { | |
| /** @type {number} */ | |
| var i = a.length - 1; | |
| for (; !type.c && 0 <= i; i--) { | |
| var current = type.a = a[i]; | |
| result = qh(current, name, true, type) && result; | |
| } | |
| } | |
| if (!type.c) { | |
| current = type.a = obj; | |
| result = qh(current, name, true, type) && result; | |
| if (!type.c) { | |
| result = qh(current, name, false, type) && result; | |
| } | |
| } | |
| if (a) { | |
| /** @type {number} */ | |
| i = 0; | |
| for (; !type.c && i < a.length; i++) { | |
| current = type.a = a[i]; | |
| result = qh(current, name, false, type) && result; | |
| } | |
| } | |
| return result; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.X = function() { | |
| L.D.X.call(this); | |
| this.Nh(); | |
| /** @type {null} */ | |
| this.Mh = null; | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @param {string} type | |
| * @param {!Function} name | |
| * @param {string} selector | |
| * @return {?} | |
| */ | |
| k.M = function(value, type, name, selector) { | |
| ph(this); | |
| return this.$b.add(String(value), type, false, name, selector); | |
| }; | |
| /** | |
| * @param {string} value | |
| * @param {string} element | |
| * @param {!Function} key | |
| * @param {!Object} selector | |
| * @return {?} | |
| */ | |
| k.Hh = function(value, element, key, selector) { | |
| return this.$b.add(String(value), element, true, key, selector); | |
| }; | |
| /** | |
| * @param {number} name | |
| * @param {number} type | |
| * @param {!Function} obj | |
| * @param {string} context | |
| * @return {?} | |
| */ | |
| k.Ma = function(name, type, obj, context) { | |
| var self = this.$b; | |
| /** @type {string} */ | |
| name = String(name).toString(); | |
| if (name in self.a) { | |
| var f = self.a[name]; | |
| type = Cg(f, type, obj, context); | |
| if (-1 < type) { | |
| Ag(f[type]); | |
| wb(f, type); | |
| if (0 == f.length) { | |
| delete self.a[name]; | |
| self.b--; | |
| } | |
| /** @type {boolean} */ | |
| self = true; | |
| } else { | |
| /** @type {boolean} */ | |
| self = false; | |
| } | |
| } else { | |
| /** @type {boolean} */ | |
| self = false; | |
| } | |
| return self; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {?} | |
| */ | |
| k.Nh = function(a) { | |
| if (this.$b) { | |
| var gadgets = this.$b; | |
| a = a && a.toString(); | |
| /** @type {number} */ | |
| var c = 0; | |
| var attri; | |
| for (attri in gadgets.a) { | |
| if (!a || attri == a) { | |
| var keywordResults = gadgets.a[attri]; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < keywordResults.length; i++) { | |
| ++c; | |
| Ag(keywordResults[i]); | |
| } | |
| delete gadgets.a[attri]; | |
| gadgets.b--; | |
| } | |
| } | |
| /** @type {number} */ | |
| gadgets = c; | |
| } else { | |
| /** @type {number} */ | |
| gadgets = 0; | |
| } | |
| return gadgets; | |
| }; | |
| /** | |
| * @param {!Object} that | |
| * @param {string} event | |
| * @param {boolean} capture | |
| * @param {!Object} key | |
| * @return {?} | |
| */ | |
| var qh = function(that, event, capture, key) { | |
| event = that.$b.a[String(event)]; | |
| if (!event) { | |
| return true; | |
| } | |
| event = event.concat(); | |
| /** @type {boolean} */ | |
| var e = true; | |
| /** @type {number} */ | |
| var k = 0; | |
| for (; k < event.length; ++k) { | |
| var listener = event[k]; | |
| if (listener && !listener.ye && listener.capture == capture) { | |
| var listenerFn = listener.listener; | |
| var listenerHandler = listener.jg || listener.src; | |
| if (listener.Cf) { | |
| Dg(that.$b, listener); | |
| } | |
| /** @type {boolean} */ | |
| e = false !== listenerFn.call(listenerHandler, key) && e; | |
| } | |
| } | |
| return e && 0 != key.Nj; | |
| }; | |
| /** | |
| * @param {string} cell | |
| * @param {boolean} expected | |
| * @return {?} | |
| */ | |
| L.prototype.Mf = function(cell, expected) { | |
| return this.$b.Mf(String(cell), expected); | |
| }; | |
| /** | |
| * @param {string} c | |
| * @param {boolean} m | |
| * @param {!Object} d | |
| * @param {string} s | |
| * @return {?} | |
| */ | |
| L.prototype.Ze = function(c, m, d, s) { | |
| return this.$b.Ze(String(c), m, d, s); | |
| }; | |
| /** | |
| * @param {string} value | |
| * @param {?} eventType | |
| * @return {?} | |
| */ | |
| L.prototype.hasListener = function(value, eventType) { | |
| return this.$b.hasListener(q(value) ? String(value) : void 0, eventType); | |
| }; | |
| /** | |
| * @param {?} s | |
| * @return {undefined} | |
| */ | |
| var ph = function(s) { | |
| z(s.$b, "Event target is not initialized. Did you call the superclass (goog.events.EventTarget) constructor?"); | |
| }; | |
| /** | |
| * @param {number} compiler | |
| * @param {string} reflectorHost | |
| * @return {undefined} | |
| */ | |
| var rh = function(compiler, reflectorHost) { | |
| /** @type {number} */ | |
| this.c = compiler; | |
| /** @type {string} */ | |
| this.g = reflectorHost; | |
| /** @type {number} */ | |
| this.b = 0; | |
| /** @type {null} */ | |
| this.a = null; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| rh.prototype.get = function() { | |
| if (0 < this.b) { | |
| this.b--; | |
| var a = this.a; | |
| this.a = a.next; | |
| /** @type {null} */ | |
| a.next = null; | |
| } else { | |
| a = this.c(); | |
| } | |
| return a; | |
| }; | |
| /** | |
| * @param {!Object} opts | |
| * @param {!Object} data | |
| * @return {undefined} | |
| */ | |
| var sh = function(opts, data) { | |
| opts.g(data); | |
| if (100 > opts.b) { | |
| opts.b++; | |
| data.next = opts.a; | |
| /** @type {!Object} */ | |
| opts.a = data; | |
| } | |
| }; | |
| /** | |
| * @param {?} val | |
| * @return {undefined} | |
| */ | |
| var th = function(val) { | |
| l.setTimeout(function() { | |
| throw val; | |
| }, 0); | |
| }; | |
| var uh; | |
| /** | |
| * @return {?} | |
| */ | |
| var vh = function() { | |
| var Channel = l.MessageChannel; | |
| if ("undefined" === typeof Channel && "undefined" !== typeof window && window.postMessage && window.addEventListener && !B("Presto")) { | |
| /** | |
| * @return {undefined} | |
| */ | |
| Channel = function() { | |
| /** @type {!Element} */ | |
| var el = document.createElement("IFRAME"); | |
| /** @type {string} */ | |
| el.style.display = "none"; | |
| Xd(el, tc(dc(fc))); | |
| document.documentElement.appendChild(el); | |
| var target = el.contentWindow; | |
| el = target.document; | |
| el.open(); | |
| el.write(Dd(Md)); | |
| el.close(); | |
| /** @type {string} */ | |
| var value = "callImmediate" + Math.random(); | |
| /** @type {string} */ | |
| var url = "file:" == target.location.protocol ? "*" : target.location.protocol + "//" + target.location.host; | |
| el = v(function(options) { | |
| if (("*" == url || options.origin == url) && options.data == value) { | |
| this.port1.onmessage(); | |
| } | |
| }, this); | |
| target.addEventListener("message", el, false); | |
| this.port1 = {}; | |
| this.port2 = { | |
| postMessage : function() { | |
| target.postMessage(value, url); | |
| } | |
| }; | |
| }; | |
| } | |
| if ("undefined" !== typeof Channel && !wd()) { | |
| var channel = new Channel; | |
| var b = {}; | |
| var t = b; | |
| /** | |
| * @return {undefined} | |
| */ | |
| channel.port1.onmessage = function() { | |
| if (q(b.next)) { | |
| b = b.next; | |
| var callback_send_audio_to_audio_player = b.Oi; | |
| /** @type {null} */ | |
| b.Oi = null; | |
| callback_send_audio_to_audio_player(); | |
| } | |
| }; | |
| return function(canCreateDiscussions) { | |
| t.next = { | |
| Oi : canCreateDiscussions | |
| }; | |
| t = t.next; | |
| channel.port2.postMessage(0); | |
| }; | |
| } | |
| return "undefined" !== typeof document && "onreadystatechange" in document.createElement("SCRIPT") ? function(notify_success) { | |
| /** @type {!Element} */ | |
| var el = document.createElement("SCRIPT"); | |
| /** | |
| * @return {undefined} | |
| */ | |
| el.onreadystatechange = function() { | |
| /** @type {null} */ | |
| el.onreadystatechange = null; | |
| el.parentNode.removeChild(el); | |
| /** @type {null} */ | |
| el = null; | |
| notify_success(); | |
| /** @type {null} */ | |
| notify_success = null; | |
| }; | |
| document.documentElement.appendChild(el); | |
| } : function(e) { | |
| l.setTimeout(e, 0); | |
| }; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var wh = function() { | |
| /** @type {null} */ | |
| this.b = this.a = null; | |
| }; | |
| var yh = new rh(function() { | |
| return new xh; | |
| }, function(applyViewModelsSpy) { | |
| applyViewModelsSpy.reset(); | |
| }); | |
| /** | |
| * @param {string} key | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| wh.prototype.add = function(key, a) { | |
| var value = yh.get(); | |
| value.set(key, a); | |
| if (this.b) { | |
| this.b.next = value; | |
| } else { | |
| z(!this.a); | |
| this.a = value; | |
| } | |
| this.b = value; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var Ah = function() { | |
| var target = zh; | |
| /** @type {null} */ | |
| var point = null; | |
| if (target.a) { | |
| point = target.a; | |
| target.a = target.a.next; | |
| if (!target.a) { | |
| /** @type {null} */ | |
| target.b = null; | |
| } | |
| /** @type {null} */ | |
| point.next = null; | |
| } | |
| return point; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var xh = function() { | |
| /** @type {null} */ | |
| this.next = this.a = this.Pc = null; | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| xh.prototype.set = function(value, name) { | |
| /** @type {!Object} */ | |
| this.Pc = value; | |
| /** @type {!Object} */ | |
| this.a = name; | |
| /** @type {null} */ | |
| this.next = null; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| xh.prototype.reset = function() { | |
| /** @type {null} */ | |
| this.next = this.a = this.Pc = null; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {(Object|string)} b | |
| * @return {undefined} | |
| */ | |
| var Eh = function(a, b) { | |
| if (!Bh) { | |
| Ch(); | |
| } | |
| if (!Dh) { | |
| Bh(); | |
| /** @type {boolean} */ | |
| Dh = true; | |
| } | |
| zh.add(a, b); | |
| }; | |
| var Bh; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Ch = function() { | |
| if (l.Promise && l.Promise.resolve) { | |
| var loadPropPromise = l.Promise.resolve(void 0); | |
| /** | |
| * @return {undefined} | |
| */ | |
| Bh = function() { | |
| loadPropPromise.then(Fh); | |
| }; | |
| } else { | |
| /** | |
| * @return {undefined} | |
| */ | |
| Bh = function() { | |
| /** @type {function(): undefined} */ | |
| var fn = Fh; | |
| if (!Ma(l.setImmediate) || l.Window && l.Window.prototype && !B("Edge") && l.Window.prototype.setImmediate == l.setImmediate) { | |
| if (!uh) { | |
| uh = vh(); | |
| } | |
| uh(fn); | |
| } else { | |
| l.setImmediate(fn); | |
| } | |
| }; | |
| } | |
| }; | |
| /** @type {boolean} */ | |
| var Dh = false; | |
| var zh = new wh; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Fh = function() { | |
| var callback; | |
| for (; callback = Ah();) { | |
| try { | |
| callback.Pc.call(callback.a); | |
| } catch (path) { | |
| th(path); | |
| } | |
| sh(yh, callback); | |
| } | |
| /** @type {boolean} */ | |
| Dh = false; | |
| }; | |
| /** | |
| * @param {?} object | |
| * @return {?} | |
| */ | |
| var Gh = function(object) { | |
| if (!object) { | |
| return false; | |
| } | |
| try { | |
| return !!object.$goog_Thenable; | |
| } catch (b) { | |
| return false; | |
| } | |
| }; | |
| /** | |
| * @param {?} realPrint | |
| * @return {undefined} | |
| */ | |
| var Jh = function(realPrint) { | |
| /** @type {number} */ | |
| this.a = 0; | |
| this.m = void 0; | |
| /** @type {null} */ | |
| this.g = this.b = this.c = null; | |
| /** @type {boolean} */ | |
| this.h = this.o = false; | |
| if (realPrint != Ha) { | |
| try { | |
| var _activeFade = this; | |
| realPrint.call(void 0, function(mercatorX) { | |
| Hh(_activeFade, 2, mercatorX); | |
| }, function(ex) { | |
| if (!(ex instanceof Ih)) { | |
| try { | |
| if (ex instanceof Error) { | |
| throw ex; | |
| } | |
| throw Error("Promise rejected."); | |
| } catch (d) { | |
| } | |
| } | |
| Hh(_activeFade, 3, ex); | |
| }); | |
| } catch (isCreditCard_1) { | |
| Hh(this, 3, isCreditCard_1); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Kh = function() { | |
| /** @type {null} */ | |
| this.next = this.context = this.c = this.b = this.a = null; | |
| /** @type {boolean} */ | |
| this.g = false; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Kh.prototype.reset = function() { | |
| /** @type {null} */ | |
| this.context = this.c = this.b = this.a = null; | |
| /** @type {boolean} */ | |
| this.g = false; | |
| }; | |
| var Lh = new rh(function() { | |
| return new Kh; | |
| }, function(applyViewModelsSpy) { | |
| applyViewModelsSpy.reset(); | |
| }); | |
| /** | |
| * @param {string} value | |
| * @param {string} fn | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| var Mh = function(value, fn, name) { | |
| var app = Lh.get(); | |
| /** @type {string} */ | |
| app.b = value; | |
| /** @type {string} */ | |
| app.c = fn; | |
| /** @type {string} */ | |
| app.context = name; | |
| return app; | |
| }; | |
| /** | |
| * @param {!Float64Array} a | |
| * @param {undefined} b | |
| * @param {!Function} c | |
| * @return {undefined} | |
| */ | |
| var Oh = function(a, b, c) { | |
| if (!Nh(a, b, c, null)) { | |
| Eh(Ta(b, a)); | |
| } | |
| }; | |
| /** | |
| * @param {!Array} expr | |
| * @return {undefined} | |
| */ | |
| var Ph = function(expr) { | |
| new Jh(function(cb, fastfunc) { | |
| var bucketCount = expr.length; | |
| /** @type {!Array} */ | |
| var items = []; | |
| if (bucketCount) { | |
| /** | |
| * @param {undefined} key | |
| * @param {?} value | |
| * @return {undefined} | |
| */ | |
| var set = function(key, value) { | |
| bucketCount--; | |
| items[key] = value; | |
| if (0 == bucketCount) { | |
| cb(items); | |
| } | |
| }; | |
| /** | |
| * @param {?} a | |
| * @return {undefined} | |
| */ | |
| var g = function(a) { | |
| fastfunc(a); | |
| }; | |
| /** @type {number} */ | |
| var i = 0; | |
| var item; | |
| for (; i < expr.length; i++) { | |
| item = expr[i]; | |
| Oh(item, Ta(set, i), g); | |
| } | |
| } else { | |
| cb(items); | |
| } | |
| }); | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {string} b | |
| * @param {!Function} f | |
| * @return {?} | |
| */ | |
| Jh.prototype.then = function(a, b, f) { | |
| if (null != a) { | |
| cb(a, "opt_onFulfilled should be a function."); | |
| } | |
| if (null != b) { | |
| cb(b, "opt_onRejected should be a function. Did you pass opt_context as the second argument instead of the third?"); | |
| } | |
| return Qh(this, Ma(a) ? a : null, Ma(b) ? b : null, f); | |
| }; | |
| /** @type {boolean} */ | |
| Jh.prototype.$goog_Thenable = true; | |
| /** | |
| * @param {?} el | |
| * @return {undefined} | |
| */ | |
| Jh.prototype.cancel = function(el) { | |
| if (0 == this.a) { | |
| Eh(function() { | |
| var childIterator = new Ih(el); | |
| Rh(this, childIterator); | |
| }, this); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {?} tension | |
| * @return {undefined} | |
| */ | |
| var Rh = 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.g || (p++, b.a == a && (value = b), !(value && 1 < p))); b = b.next) { | |
| if (!value) { | |
| paths = b; | |
| } | |
| } | |
| if (value) { | |
| if (0 == c.a && 1 == p) { | |
| Rh(c, tension); | |
| } else { | |
| if (paths) { | |
| p = paths; | |
| z(c.b); | |
| z(null != p); | |
| if (p.next == c.g) { | |
| c.g = p; | |
| } | |
| p.next = p.next.next; | |
| } else { | |
| Sh(c); | |
| } | |
| Uh(c, value, 3, tension); | |
| } | |
| } | |
| } | |
| /** @type {null} */ | |
| a.c = null; | |
| } else { | |
| Hh(a, 3, tension); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} b | |
| * @return {undefined} | |
| */ | |
| var Wh = function(a, b) { | |
| if (!(a.b || 2 != a.a && 3 != a.a)) { | |
| Vh(a); | |
| } | |
| z(null != b.b); | |
| if (a.g) { | |
| /** @type {string} */ | |
| a.g.next = b; | |
| } else { | |
| /** @type {string} */ | |
| a.b = b; | |
| } | |
| /** @type {string} */ | |
| a.g = b; | |
| }; | |
| /** | |
| * @param {string} t | |
| * @param {!Function} i | |
| * @param {!Function} p | |
| * @param {!Function} c | |
| * @return {?} | |
| */ | |
| var Qh = function(t, i, p, c) { | |
| var e = Mh(null, null, null); | |
| e.a = new Jh(function(error, f) { | |
| e.b = i ? function(name) { | |
| try { | |
| var m = i.call(c, name); | |
| error(m); | |
| } catch (onExit) { | |
| f(onExit); | |
| } | |
| } : error; | |
| e.c = p ? function(name) { | |
| try { | |
| var a = p.call(c, name); | |
| if (!q(a) && name instanceof Ih) { | |
| f(name); | |
| } else { | |
| error(a); | |
| } | |
| } catch (onExit) { | |
| f(onExit); | |
| } | |
| } : f; | |
| }); | |
| /** @type {string} */ | |
| e.a.c = t; | |
| Wh(t, e); | |
| return e.a; | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| Jh.prototype.G = function(type) { | |
| z(1 == this.a); | |
| /** @type {number} */ | |
| this.a = 0; | |
| Hh(this, 2, type); | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| Jh.prototype.C = function(name) { | |
| z(1 == this.a); | |
| /** @type {number} */ | |
| this.a = 0; | |
| Hh(this, 3, name); | |
| }; | |
| /** | |
| * @param {!Object} m | |
| * @param {number} key | |
| * @param {?} x | |
| * @return {undefined} | |
| */ | |
| var Hh = function(m, key, x) { | |
| if (0 == m.a) { | |
| if (m === x) { | |
| /** @type {number} */ | |
| key = 3; | |
| /** @type {!TypeError} */ | |
| x = new TypeError("Promise cannot resolve to itself"); | |
| } | |
| /** @type {number} */ | |
| m.a = 1; | |
| if (!Nh(x, m.G, m.C, m)) { | |
| m.m = x; | |
| /** @type {number} */ | |
| m.a = key; | |
| /** @type {null} */ | |
| m.c = null; | |
| Vh(m); | |
| if (!(3 != key || x instanceof Ih)) { | |
| Xh(m, x); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {?} a | |
| * @param {string} b | |
| * @param {!Function} c | |
| * @param {!Function} d | |
| * @return {?} | |
| */ | |
| var Nh = function(a, b, c, d) { | |
| if (a instanceof Jh) { | |
| return null != b && cb(b, "opt_onFulfilled should be a function."), null != c && cb(c, "opt_onRejected should be a function. Did you pass opt_context as the second argument instead of the third?"), Wh(a, Mh(b || Ha, c || null, d)), true; | |
| } | |
| if (Gh(a)) { | |
| return a.then(b, c, d), true; | |
| } | |
| if (Na(a)) { | |
| try { | |
| var h = a.then; | |
| if (Ma(h)) { | |
| return Yh(a, h, b, c, d), true; | |
| } | |
| } catch (f) { | |
| return c.call(d, f), true; | |
| } | |
| } | |
| return false; | |
| }; | |
| /** | |
| * @param {?} url | |
| * @param {!Function} c | |
| * @param {?} a | |
| * @param {!Function} f | |
| * @param {!Function} o | |
| * @return {undefined} | |
| */ | |
| var Yh = function(url, c, a, f, o) { | |
| /** @type {boolean} */ | |
| var t = false; | |
| /** | |
| * @param {?} aid | |
| * @return {undefined} | |
| */ | |
| var b = function(aid) { | |
| if (!t) { | |
| /** @type {boolean} */ | |
| t = true; | |
| a.call(o, aid); | |
| } | |
| }; | |
| /** | |
| * @param {?} value | |
| * @return {undefined} | |
| */ | |
| var h = function(value) { | |
| if (!t) { | |
| /** @type {boolean} */ | |
| t = true; | |
| f.call(o, value); | |
| } | |
| }; | |
| try { | |
| c.call(url, b, h); | |
| } catch (device_id) { | |
| h(device_id); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| var Vh = function(a) { | |
| if (!a.o) { | |
| /** @type {boolean} */ | |
| a.o = true; | |
| Eh(a.w, a); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| var Sh = 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; | |
| } | |
| if (null != a) { | |
| z(null != a.b); | |
| } | |
| return a; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Jh.prototype.w = function() { | |
| var QueryLanguageComponent; | |
| for (; QueryLanguageComponent = Sh(this);) { | |
| Uh(this, QueryLanguageComponent, this.a, this.m); | |
| } | |
| /** @type {boolean} */ | |
| this.o = false; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Object} b | |
| * @param {number} c | |
| * @param {?} t | |
| * @return {undefined} | |
| */ | |
| var Uh = function(a, b, c, t) { | |
| if (3 == c && b.c && !b.g) { | |
| for (; a && a.h; a = a.c) { | |
| /** @type {boolean} */ | |
| a.h = false; | |
| } | |
| } | |
| if (b.a) { | |
| /** @type {null} */ | |
| b.a.c = null; | |
| Zh(b, c, t); | |
| } else { | |
| try { | |
| if (b.g) { | |
| b.b.call(b.context); | |
| } else { | |
| Zh(b, c, t); | |
| } | |
| } catch (sectionId) { | |
| $h.call(null, sectionId); | |
| } | |
| } | |
| sh(Lh, b); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {number} result | |
| * @param {?} b | |
| * @return {undefined} | |
| */ | |
| var Zh = function(a, result, b) { | |
| if (2 == result) { | |
| a.b.call(a.context, b); | |
| } else { | |
| if (a.c) { | |
| a.c.call(a.context, b); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} val | |
| * @param {?} txt | |
| * @return {undefined} | |
| */ | |
| var Xh = function(val, txt) { | |
| /** @type {boolean} */ | |
| val.h = true; | |
| Eh(function() { | |
| if (val.h) { | |
| $h.call(null, txt); | |
| } | |
| }); | |
| }; | |
| /** @type {function(?): undefined} */ | |
| var $h = th; | |
| /** | |
| * @param {?} p1__3354_SHARP_ | |
| * @return {undefined} | |
| */ | |
| var Ih = function(p1__3354_SHARP_) { | |
| Va.call(this, p1__3354_SHARP_); | |
| }; | |
| x(Ih, Va); | |
| /** @type {string} */ | |
| Ih.prototype.name = "cancel"; | |
| /** | |
| * @param {number} player | |
| * @param {string} dt | |
| * @return {undefined} | |
| */ | |
| var ai = function(player, dt) { | |
| L.call(this); | |
| this.g = player || 1; | |
| this.c = dt || l; | |
| this.h = v(this.m, this); | |
| this.o = Ua(); | |
| }; | |
| x(ai, L); | |
| /** @type {boolean} */ | |
| ai.prototype.b = false; | |
| /** @type {null} */ | |
| ai.prototype.a = null; | |
| /** | |
| * @param {!Object} o | |
| * @param {number} t | |
| * @return {undefined} | |
| */ | |
| var bi = function(o, t) { | |
| /** @type {number} */ | |
| o.g = t; | |
| if (o.a && o.b) { | |
| o.stop(); | |
| o.start(); | |
| } else { | |
| if (o.a) { | |
| o.stop(); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| ai.prototype.m = function() { | |
| if (this.b) { | |
| /** @type {number} */ | |
| var now = Ua() - this.o; | |
| if (0 < now && now < .8 * this.g) { | |
| this.a = this.c.setTimeout(this.h, this.g - now); | |
| } else { | |
| if (this.a) { | |
| this.c.clearTimeout(this.a); | |
| /** @type {null} */ | |
| this.a = null; | |
| } | |
| this.dispatchEvent("tick"); | |
| if (this.b) { | |
| this.stop(); | |
| this.start(); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| ai.prototype.start = function() { | |
| /** @type {boolean} */ | |
| this.b = true; | |
| if (!this.a) { | |
| this.a = this.c.setTimeout(this.h, this.g); | |
| this.o = Ua(); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| ai.prototype.stop = function() { | |
| /** @type {boolean} */ | |
| this.b = false; | |
| if (this.a) { | |
| this.c.clearTimeout(this.a); | |
| /** @type {null} */ | |
| this.a = null; | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| ai.prototype.X = function() { | |
| ai.D.X.call(this); | |
| this.stop(); | |
| delete this.c; | |
| }; | |
| /** | |
| * @param {!Function} value | |
| * @param {number} start | |
| * @param {!Object} data | |
| * @return {?} | |
| */ | |
| var ci = function(value, start, data) { | |
| if (Ma(value)) { | |
| if (data) { | |
| value = v(value, data); | |
| } | |
| } else { | |
| if (value && "function" == typeof value.handleEvent) { | |
| value = v(value.handleEvent, value); | |
| } else { | |
| throw Error("Invalid listener argument"); | |
| } | |
| } | |
| return 2147483647 < Number(start) ? -1 : l.setTimeout(value, start || 0); | |
| }; | |
| /** | |
| * @param {?} name | |
| * @return {undefined} | |
| */ | |
| var di = function(name) { | |
| l.clearTimeout(name); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var ei = function() { | |
| /** | |
| * @return {undefined} | |
| */ | |
| function reset() { | |
| /** @type {number} */ | |
| e[0] = 1732584193; | |
| /** @type {number} */ | |
| e[1] = 4023233417; | |
| /** @type {number} */ | |
| e[2] = 2562383102; | |
| /** @type {number} */ | |
| e[3] = 271733878; | |
| /** @type {number} */ | |
| e[4] = 3285377520; | |
| /** @type {number} */ | |
| knobTranslate = fillTranslate = 0; | |
| } | |
| /** | |
| * @param {number} a | |
| * @return {undefined} | |
| */ | |
| function fn(a) { | |
| /** @type {!Array} */ | |
| var r = require; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; 64 > i; i = i + 4) { | |
| /** @type {number} */ | |
| r[i / 4] = a[i] << 24 | a[i + 1] << 16 | a[i + 2] << 8 | a[i + 3]; | |
| } | |
| /** @type {number} */ | |
| i = 16; | |
| for (; 80 > i; i++) { | |
| /** @type {number} */ | |
| a = r[i - 3] ^ r[i - 8] ^ r[i - 14] ^ r[i - 16]; | |
| /** @type {number} */ | |
| r[i] = (a << 1 | a >>> 31) & 4294967295; | |
| } | |
| a = e[0]; | |
| var b = e[1]; | |
| var c = e[2]; | |
| var d = e[3]; | |
| var l = e[4]; | |
| /** @type {number} */ | |
| i = 0; | |
| for (; 80 > i; i++) { | |
| if (40 > i) { | |
| if (20 > i) { | |
| /** @type {number} */ | |
| var y = d ^ b & (c ^ d); | |
| /** @type {number} */ | |
| var _ = 1518500249; | |
| } else { | |
| /** @type {number} */ | |
| y = b ^ c ^ d; | |
| /** @type {number} */ | |
| _ = 1859775393; | |
| } | |
| } else { | |
| if (60 > i) { | |
| /** @type {number} */ | |
| y = b & c | d & (b | c); | |
| /** @type {number} */ | |
| _ = 2400959708; | |
| } else { | |
| /** @type {number} */ | |
| y = b ^ c ^ d; | |
| /** @type {number} */ | |
| _ = 3395469782; | |
| } | |
| } | |
| /** @type {number} */ | |
| y = ((a << 5 | a >>> 27) & 4294967295) + y + l + _ + r[i] & 4294967295; | |
| l = d; | |
| d = c; | |
| /** @type {number} */ | |
| c = (b << 30 | b >>> 2) & 4294967295; | |
| /** @type {number} */ | |
| b = a; | |
| /** @type {number} */ | |
| a = y; | |
| } | |
| /** @type {number} */ | |
| e[0] = e[0] + a & 4294967295; | |
| /** @type {number} */ | |
| e[1] = e[1] + b & 4294967295; | |
| /** @type {number} */ | |
| e[2] = e[2] + c & 4294967295; | |
| /** @type {number} */ | |
| e[3] = e[3] + d & 4294967295; | |
| /** @type {number} */ | |
| e[4] = e[4] + l & 4294967295; | |
| } | |
| /** | |
| * @param {!Object} value | |
| * @param {number} n | |
| * @return {undefined} | |
| */ | |
| function callback(value, n) { | |
| if ("string" === typeof value) { | |
| /** @type {string} */ | |
| value = unescape(encodeURIComponent(value)); | |
| /** @type {!Array} */ | |
| var i = []; | |
| /** @type {number} */ | |
| var n = 0; | |
| /** @type {number} */ | |
| var valLength = value.length; | |
| for (; n < valLength; ++n) { | |
| i.push(value.charCodeAt(n)); | |
| } | |
| /** @type {!Array} */ | |
| value = i; | |
| } | |
| if (!n) { | |
| n = value.length; | |
| } | |
| /** @type {number} */ | |
| i = 0; | |
| if (0 == fillTranslate) { | |
| for (; i + 64 < n;) { | |
| fn(value.slice(i, i + 64)); | |
| /** @type {number} */ | |
| i = i + 64; | |
| knobTranslate = knobTranslate + 64; | |
| } | |
| } | |
| for (; i < n;) { | |
| if (ret[fillTranslate++] = value[i++], knobTranslate++, 64 == fillTranslate) { | |
| /** @type {number} */ | |
| fillTranslate = 0; | |
| fn(ret); | |
| for (; i + 64 < n;) { | |
| fn(value.slice(i, i + 64)); | |
| /** @type {number} */ | |
| i = i + 64; | |
| knobTranslate = knobTranslate + 64; | |
| } | |
| } | |
| } | |
| } | |
| /** | |
| * @return {?} | |
| */ | |
| function password() { | |
| /** @type {!Array} */ | |
| var api = []; | |
| /** @type {number} */ | |
| var num = 8 * knobTranslate; | |
| if (56 > fillTranslate) { | |
| callback(h, 56 - fillTranslate); | |
| } else { | |
| callback(h, 64 - (fillTranslate - 56)); | |
| } | |
| /** @type {number} */ | |
| var i = 63; | |
| for (; 56 <= i; i--) { | |
| /** @type {number} */ | |
| ret[i] = num & 255; | |
| /** @type {number} */ | |
| num = num >>> 8; | |
| } | |
| fn(ret); | |
| /** @type {number} */ | |
| i = num = 0; | |
| for (; 5 > i; i++) { | |
| /** @type {number} */ | |
| var cbs = 24; | |
| for (; 0 <= cbs; cbs = cbs - 8) { | |
| /** @type {number} */ | |
| api[num++] = e[i] >> cbs & 255; | |
| } | |
| } | |
| return api; | |
| } | |
| /** @type {!Array} */ | |
| var e = []; | |
| /** @type {!Array} */ | |
| var ret = []; | |
| /** @type {!Array} */ | |
| var require = []; | |
| /** @type {!Array} */ | |
| var h = [128]; | |
| /** @type {number} */ | |
| var j = 1; | |
| for (; 64 > j; ++j) { | |
| /** @type {number} */ | |
| h[j] = 0; | |
| } | |
| var fillTranslate; | |
| var knobTranslate; | |
| reset(); | |
| return { | |
| reset : reset, | |
| update : callback, | |
| digest : password, | |
| El : function() { | |
| var crossfilterable_layers = password(); | |
| /** @type {string} */ | |
| var ref = ""; | |
| /** @type {number} */ | |
| var layer_i = 0; | |
| for (; layer_i < crossfilterable_layers.length; layer_i++) { | |
| /** @type {string} */ | |
| ref = ref + ("0123456789ABCDEF".charAt(Math.floor(crossfilterable_layers[layer_i] / 16)) + "0123456789ABCDEF".charAt(crossfilterable_layers[layer_i] % 16)); | |
| } | |
| return ref; | |
| } | |
| }; | |
| }; | |
| /** | |
| * @param {!Array} args | |
| * @param {?} callback | |
| * @param {?} address | |
| * @return {?} | |
| */ | |
| var gi = function(args, callback, address) { | |
| /** @type {!Array} */ | |
| var w = []; | |
| /** @type {!Array} */ | |
| var queue = []; | |
| if (1 == (Ka(address) ? 2 : 1)) { | |
| return queue = [callback, args], A(w, function(messageFunction) { | |
| queue.push(messageFunction); | |
| }), fi(queue.join(" ")); | |
| } | |
| /** @type {!Array} */ | |
| var array = []; | |
| /** @type {!Array} */ | |
| var html = []; | |
| A(address, function(result) { | |
| html.push(result.key); | |
| array.push(result.value); | |
| }); | |
| /** @type {number} */ | |
| address = Math.floor((new Date).getTime() / 1E3); | |
| /** @type {!Array} */ | |
| queue = 0 == array.length ? [address, callback, args] : [array.join(":"), address, callback, args]; | |
| A(w, function(messageFunction) { | |
| queue.push(messageFunction); | |
| }); | |
| args = fi(queue.join(" ")); | |
| /** @type {!Array} */ | |
| args = [address, args]; | |
| if (!(0 == html.length)) { | |
| args.push(html.join("")); | |
| } | |
| return args.join("_"); | |
| }; | |
| /** | |
| * @param {string} id | |
| * @return {?} | |
| */ | |
| var fi = function(id) { | |
| var b = ei(); | |
| b.update(id); | |
| return b.El().toLowerCase(); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var hi = function() { | |
| /** @type {!HTMLDocument} */ | |
| this.a = document || { | |
| cookie : "" | |
| }; | |
| }; | |
| k = hi.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| k.isEnabled = function() { | |
| return navigator.cookieEnabled; | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @param {!Object} name | |
| * @param {string} v | |
| * @param {string} i | |
| * @param {string} id | |
| * @param {string} height | |
| * @return {undefined} | |
| */ | |
| k.set = function(value, name, v, i, id, height) { | |
| if (/[;=\s]/.test(value)) { | |
| throw Error('Invalid cookie name "' + value + '"'); | |
| } | |
| if (/[;\r\n]/.test(name)) { | |
| throw Error('Invalid cookie value "' + name + '"'); | |
| } | |
| if (!q(v)) { | |
| /** @type {number} */ | |
| v = -1; | |
| } | |
| /** @type {string} */ | |
| id = id ? ";domain=" + id : ""; | |
| /** @type {string} */ | |
| i = i ? ";path=" + i : ""; | |
| /** @type {string} */ | |
| height = height ? ";secure" : ""; | |
| /** @type {string} */ | |
| v = 0 > v ? "" : 0 == v ? ";expires=" + (new Date(1970, 1, 1)).toUTCString() : ";expires=" + (new Date(Ua() + 1E3 * v)).toUTCString(); | |
| /** @type {string} */ | |
| this.a.cookie = value + "=" + name + id + i + v + height; | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @param {?} b | |
| * @return {?} | |
| */ | |
| k.get = function(name, b) { | |
| /** @type {string} */ | |
| var message = name + "="; | |
| var spheres = (this.a.cookie || "").split(";"); | |
| /** @type {number} */ | |
| var iter_sph = 0; | |
| var channel; | |
| for (; iter_sph < spheres.length; iter_sph++) { | |
| channel = zc(spheres[iter_sph]); | |
| if (0 == channel.lastIndexOf(message, 0)) { | |
| return channel.substr(message.length); | |
| } | |
| if (channel == name) { | |
| return ""; | |
| } | |
| } | |
| return b; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Mb = function() { | |
| return ii(this).keys; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.bc = function() { | |
| return ii(this).values; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Lf = function() { | |
| return this.a.cookie ? (this.a.cookie || "").split(";").length : 0; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {?} | |
| */ | |
| var ii = function(a) { | |
| a = (a.a.cookie || "").split(";"); | |
| /** @type {!Array} */ | |
| var results = []; | |
| /** @type {!Array} */ | |
| var gridlineValues = []; | |
| var i; | |
| var namespace; | |
| /** @type {number} */ | |
| var j = 0; | |
| for (; j < a.length; j++) { | |
| namespace = zc(a[j]); | |
| i = namespace.indexOf("="); | |
| if (-1 == i) { | |
| results.push(""); | |
| gridlineValues.push(namespace); | |
| } else { | |
| results.push(namespace.substring(0, i)); | |
| gridlineValues.push(namespace.substring(i + 1)); | |
| } | |
| } | |
| return { | |
| keys : results, | |
| values : gridlineValues | |
| }; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {?} | |
| */ | |
| var ji = function(a) { | |
| var end = Ue(String(l.location.href)); | |
| var query = l.__OVERRIDE_SID; | |
| if (null == query) { | |
| query = (new hi).get("SID"); | |
| } | |
| if (query && (end = (query = 0 == end.indexOf("https:") || 0 == end.indexOf("chrome-extension:")) ? l.__SAPISID : l.__APISID, null == end && (end = (new hi).get(query ? "SAPISID" : "APISID")), end)) { | |
| /** @type {string} */ | |
| query = query ? "SAPISIDHASH" : "APISIDHASH"; | |
| /** @type {string} */ | |
| var origin = String(l.location.href); | |
| return origin && end && query ? [query, gi(Ue(origin), end, a || null)].join(" ") : null; | |
| } | |
| return null; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {?} b | |
| * @param {?} c | |
| * @return {undefined} | |
| */ | |
| var ki = function(a, b, c) { | |
| this.reset(a, b, c, void 0, void 0); | |
| }; | |
| /** @type {null} */ | |
| ki.prototype.a = null; | |
| /** @type {number} */ | |
| var li = 0; | |
| /** | |
| * @param {string} a | |
| * @param {?} b | |
| * @param {?} c | |
| * @param {!Object} f | |
| * @param {!Object} data | |
| * @return {undefined} | |
| */ | |
| ki.prototype.reset = function(a, b, c, f, data) { | |
| if (!("number" == typeof data)) { | |
| li++; | |
| } | |
| if (!f) { | |
| Ua(); | |
| } | |
| delete this.a; | |
| }; | |
| /** | |
| * @param {string} g | |
| * @return {undefined} | |
| */ | |
| var mi = function(g) { | |
| /** @type {string} */ | |
| this.g = g; | |
| /** @type {null} */ | |
| this.b = this.c = this.a = null; | |
| }; | |
| /** | |
| * @param {string} op | |
| * @param {!Object} b | |
| * @return {undefined} | |
| */ | |
| var ni = function(op, b) { | |
| /** @type {string} */ | |
| this.name = op; | |
| /** @type {!Object} */ | |
| this.value = b; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| ni.prototype.toString = function() { | |
| return this.name; | |
| }; | |
| var oi = new ni("SEVERE", 1E3); | |
| var pi = new ni("WARNING", 900); | |
| var qi = new ni("INFO", 800); | |
| var ri = new ni("CONFIG", 700); | |
| var si = new ni("FINE", 500); | |
| /** | |
| * @return {?} | |
| */ | |
| mi.prototype.getParent = function() { | |
| return this.a; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var ti = function(a) { | |
| if (a.c) { | |
| return a.c; | |
| } | |
| if (a.a) { | |
| return ti(a.a); | |
| } | |
| Za("Root logger has no level set."); | |
| return null; | |
| }; | |
| /** | |
| * @param {string} value | |
| * @param {string} data | |
| * @param {!Object} fn | |
| * @return {undefined} | |
| */ | |
| mi.prototype.log = function(value, data, fn) { | |
| if (value.value >= ti(this).value) { | |
| if (Ma(data)) { | |
| data = data(); | |
| } | |
| value = new ki(value, String(data), this.g); | |
| if (fn) { | |
| /** @type {!Object} */ | |
| value.a = fn; | |
| } | |
| fn = this; | |
| for (; fn;) { | |
| fn = fn.getParent(); | |
| } | |
| } | |
| }; | |
| var ui = {}; | |
| /** @type {null} */ | |
| var vi = null; | |
| /** | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| var wi = function(name) { | |
| if (!vi) { | |
| vi = new mi(""); | |
| ui[""] = vi; | |
| vi.c = ri; | |
| } | |
| var view; | |
| if (!(view = ui[name])) { | |
| view = new mi(name); | |
| var i = name.lastIndexOf("."); | |
| var key = name.substr(i + 1); | |
| i = wi(name.substr(0, i)); | |
| if (!i.b) { | |
| i.b = {}; | |
| } | |
| i.b[key] = view; | |
| view.a = i; | |
| ui[name] = view; | |
| } | |
| return view; | |
| }; | |
| /** | |
| * @param {!Object} d | |
| * @param {string} i | |
| * @return {undefined} | |
| */ | |
| var xi = function(d, i) { | |
| if (d) { | |
| d.log(oi, i, void 0); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} fields | |
| * @param {string} row | |
| * @return {undefined} | |
| */ | |
| var yi = function(fields, row) { | |
| if (fields) { | |
| fields.log(pi, row, void 0); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} b | |
| * @return {undefined} | |
| */ | |
| var zi = function(a, b) { | |
| if (a) { | |
| a.log(qi, b, void 0); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} id | |
| * @return {undefined} | |
| */ | |
| var Ai = function(a, id) { | |
| if (a) { | |
| a.log(si, id, void 0); | |
| } | |
| }; | |
| /** | |
| * @param {number} compiler | |
| * @return {undefined} | |
| */ | |
| var Bi = function(compiler) { | |
| z(0 < compiler, "Initial value must be greater than zero."); | |
| z(3E5 >= compiler, "Max value should be at least as large as initial value."); | |
| if (q(.1)) { | |
| z(true, "Randomness factor should be between 0 and 1."); | |
| } | |
| if (q(void 0)) { | |
| z(false, "Backoff factor should be greater than 1"); | |
| } | |
| if (q(void 0)) { | |
| z(false, "Decay factor should be greater than 1"); | |
| } | |
| this.a = this.b = this.c = compiler; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Bi.prototype.reset = function() { | |
| this.a = this.b = this.c; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Bi.prototype.aa = function() { | |
| return this.b; | |
| }; | |
| /** | |
| * @param {string} a$jscomp$404 | |
| * @return {?} | |
| */ | |
| var Ci = function(a$jscomp$404) { | |
| /** @type {string} */ | |
| a$jscomp$404 = String(a$jscomp$404); | |
| if (/^\s*$/.test(a$jscomp$404) ? 0 : /^[\],:{}\s\u2028\u2029]*$/.test(a$jscomp$404.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$404 + ")"); | |
| } catch (b) { | |
| } | |
| } | |
| throw Error("Invalid JSON string: " + a$jscomp$404); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Di = function() { | |
| }; | |
| /** | |
| * @param {!Function} v | |
| * @return {?} | |
| */ | |
| Di.prototype.vd = function(v) { | |
| /** @type {!Array} */ | |
| var b = []; | |
| Ei(this, v, b); | |
| return b.join(""); | |
| }; | |
| /** | |
| * @param {?} $chkb | |
| * @param {string} value | |
| * @param {!Array} text | |
| * @return {undefined} | |
| */ | |
| var Ei = function($chkb, value, text) { | |
| if (null == value) { | |
| text.push("null"); | |
| } else { | |
| if ("object" == typeof value) { | |
| if (Ka(value)) { | |
| /** @type {string} */ | |
| var p = value; | |
| value = p.length; | |
| text.push("["); | |
| /** @type {string} */ | |
| var e = ""; | |
| /** @type {number} */ | |
| var n = 0; | |
| for (; n < value; n++) { | |
| text.push(e); | |
| Ei($chkb, p[n], text); | |
| /** @type {string} */ | |
| e = ","; | |
| } | |
| text.push("]"); | |
| return; | |
| } | |
| if (value instanceof String || value instanceof Number || value instanceof Boolean) { | |
| /** @type {*} */ | |
| value = value.valueOf(); | |
| } else { | |
| text.push("{"); | |
| /** @type {string} */ | |
| e = ""; | |
| for (p in value) { | |
| if (Object.prototype.hasOwnProperty.call(value, p)) { | |
| n = value[p]; | |
| if ("function" != typeof n) { | |
| text.push(e); | |
| Fi(p, text); | |
| text.push(":"); | |
| Ei($chkb, n, text); | |
| /** @type {string} */ | |
| e = ","; | |
| } | |
| } | |
| } | |
| text.push("}"); | |
| return; | |
| } | |
| } | |
| switch(typeof value) { | |
| case "string": | |
| Fi(value, text); | |
| break; | |
| case "number": | |
| text.push(isFinite(value) && !isNaN(value) ? String(value) : "null"); | |
| break; | |
| case "boolean": | |
| text.push(String(value)); | |
| break; | |
| case "function": | |
| text.push("null"); | |
| break; | |
| default: | |
| throw Error("Unknown type: " + typeof value); | |
| } | |
| } | |
| }; | |
| var Gi = { | |
| '"' : '\\"', | |
| "\\" : "\\\\", | |
| "/" : "\\/", | |
| "\b" : "\\b", | |
| "\f" : "\\f", | |
| "\n" : "\\n", | |
| "\r" : "\\r", | |
| "\t" : "\\t", | |
| "\x0B" : "\\u000b" | |
| }; | |
| /** @type {!RegExp} */ | |
| var Hi = /\uffff/.test("\uffff") ? /[\\"\x00-\x1f\x7f-\uffff]/g : /[\\"\x00-\x1f\x7f-\xff]/g; | |
| /** | |
| * @param {string} context | |
| * @param {!Array} t | |
| * @return {undefined} | |
| */ | |
| var Fi = function(context, t) { | |
| t.push('"', context.replace(Hi, function(c) { | |
| var fbo = Gi[c]; | |
| if (!fbo) { | |
| /** @type {string} */ | |
| fbo = "\\u" + (c.charCodeAt(0) | 65536).toString(16).substr(1); | |
| /** @type {string} */ | |
| Gi[c] = fbo; | |
| } | |
| return fbo; | |
| }), '"'); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Ii = function() { | |
| }; | |
| /** @type {null} */ | |
| Ii.prototype.a = null; | |
| /** | |
| * @param {!Object} s | |
| * @return {?} | |
| */ | |
| var Ki = function(s) { | |
| var a; | |
| if (!(a = s.a)) { | |
| a = {}; | |
| if (Ji(s)) { | |
| /** @type {boolean} */ | |
| a[0] = true; | |
| /** @type {boolean} */ | |
| a[1] = true; | |
| } | |
| a = s.a = a; | |
| } | |
| return a; | |
| }; | |
| var Li; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Mi = function() { | |
| }; | |
| x(Mi, Ii); | |
| /** | |
| * @param {!Object} name | |
| * @return {?} | |
| */ | |
| var Ni = function(name) { | |
| return (name = Ji(name)) ? new ActiveXObject(name) : new XMLHttpRequest; | |
| }; | |
| /** | |
| * @param {!Object} s | |
| * @return {?} | |
| */ | |
| var Ji = function(s) { | |
| if (!s.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), s.b = p; | |
| } catch (e) { | |
| } | |
| } | |
| throw Error("Could not create ActiveXObject. ActiveX might be disabled, or MSXML might not be installed"); | |
| } | |
| return s.b; | |
| }; | |
| Li = new Mi; | |
| var Oi = "StopIteration" in l ? l.StopIteration : { | |
| message : "StopIteration", | |
| stack : "" | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Pi = function() { | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Pi.prototype.next = function() { | |
| throw Oi; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Pi.prototype.xc = function() { | |
| return this; | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| var Qi = function(b) { | |
| if (b instanceof Pi) { | |
| return b; | |
| } | |
| if ("function" == typeof b.xc) { | |
| return b.xc(false); | |
| } | |
| if (La(b)) { | |
| /** @type {number} */ | |
| var i = 0; | |
| var pi = new Pi; | |
| /** | |
| * @return {?} | |
| */ | |
| pi.next = function() { | |
| for (;;) { | |
| if (i >= b.length) { | |
| throw Oi; | |
| } | |
| if (i in b) { | |
| return b[i++]; | |
| } | |
| i++; | |
| } | |
| }; | |
| return pi; | |
| } | |
| throw Error("Not implemented"); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Function} f | |
| * @param {!Function} context | |
| * @return {undefined} | |
| */ | |
| var Ri = function(a, f, context) { | |
| if (La(a)) { | |
| try { | |
| A(a, f, context); | |
| } catch (d) { | |
| if (d !== Oi) { | |
| throw d; | |
| } | |
| } | |
| } else { | |
| a = Qi(a); | |
| try { | |
| for (;;) { | |
| f.call(context, a.next(), void 0, a); | |
| } | |
| } catch (d) { | |
| if (d !== Oi) { | |
| throw d; | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var Ti = function(a) { | |
| /** @type {function(!Node): ?} */ | |
| var fn = Si; | |
| var vals = Qi(a); | |
| a = new Pi; | |
| /** | |
| * @return {?} | |
| */ | |
| a.next = function() { | |
| for (;;) { | |
| var elem = vals.next(); | |
| if (fn.call(void 0, elem, void 0, vals)) { | |
| return elem; | |
| } | |
| } | |
| }; | |
| return a; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var Vi = function(a) { | |
| /** @type {function(string, ?, !Object): ?} */ | |
| var fn = Ui; | |
| var vals = Qi(a); | |
| a = new Pi; | |
| /** | |
| * @return {?} | |
| */ | |
| a.next = function() { | |
| var event = vals.next(); | |
| return fn.call(void 0, event, void 0, vals); | |
| }; | |
| return a; | |
| }; | |
| /** | |
| * @param {!Object} i | |
| * @param {!Function} a | |
| * @param {!Object} b | |
| * @return {undefined} | |
| */ | |
| var Wi = function(i, a, b) { | |
| i = Qi(i); | |
| try { | |
| for (; a.call(b, i.next(), void 0, i);) { | |
| } | |
| } catch (d) { | |
| if (d !== Oi) { | |
| throw d; | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} selector | |
| * @return {?} | |
| */ | |
| var Xi = function(selector) { | |
| try { | |
| return Qi(selector).next(); | |
| } catch (b) { | |
| if (b != Oi) { | |
| throw b; | |
| } | |
| return null; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {?} b | |
| * @return {undefined} | |
| */ | |
| var Yi = function(a, b) { | |
| this.Va = {}; | |
| /** @type {!Array} */ | |
| this.a = []; | |
| /** @type {number} */ | |
| this.c = this.b = 0; | |
| /** @type {number} */ | |
| var m = arguments.length; | |
| if (1 < m) { | |
| if (m % 2) { | |
| throw Error("Uneven number of arguments"); | |
| } | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < m; i = i + 2) { | |
| this.set(arguments[i], arguments[i + 1]); | |
| } | |
| } else { | |
| if (a) { | |
| if (a instanceof Yi) { | |
| m = a.Mb(); | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < m.length; i++) { | |
| this.set(m[i], a.get(m[i])); | |
| } | |
| } else { | |
| for (i in a) { | |
| this.set(i, a[i]); | |
| } | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Yi.prototype.Lf = function() { | |
| return this.b; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Yi.prototype.bc = function() { | |
| Zi(this); | |
| /** @type {!Array} */ | |
| var newNodeLists = []; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < this.a.length; i++) { | |
| newNodeLists.push(this.Va[this.a[i]]); | |
| } | |
| return newNodeLists; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Yi.prototype.Mb = function() { | |
| Zi(this); | |
| return this.a.concat(); | |
| }; | |
| /** | |
| * @param {?} a | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| var aj = function(a, b) { | |
| return $i(a.Va, b); | |
| }; | |
| /** | |
| * @param {!Object} paths | |
| * @param {string} fn | |
| * @return {?} | |
| */ | |
| Yi.prototype.Oc = function(paths, fn) { | |
| if (this === paths) { | |
| return true; | |
| } | |
| if (this.b != paths.Lf()) { | |
| return false; | |
| } | |
| fn = fn || bj; | |
| Zi(this); | |
| var key; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; key = this.a[i]; i++) { | |
| if (!fn(this.get(key), paths.get(key))) { | |
| return false; | |
| } | |
| } | |
| return true; | |
| }; | |
| /** | |
| * @param {?} a | |
| * @param {?} b | |
| * @return {?} | |
| */ | |
| var bj = function(a, b) { | |
| return a === b; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Yi.prototype.hd = function() { | |
| this.Va = {}; | |
| /** @type {number} */ | |
| this.c = this.b = this.a.length = 0; | |
| }; | |
| /** | |
| * @param {!Object} arr | |
| * @return {undefined} | |
| */ | |
| var Zi = function(arr) { | |
| if (arr.b != arr.a.length) { | |
| /** @type {number} */ | |
| var i = 0; | |
| /** @type {number} */ | |
| var offset = 0; | |
| for (; i < arr.a.length;) { | |
| var d = arr.a[i]; | |
| if ($i(arr.Va, d)) { | |
| arr.a[offset++] = d; | |
| } | |
| i++; | |
| } | |
| /** @type {number} */ | |
| arr.a.length = offset; | |
| } | |
| if (arr.b != arr.a.length) { | |
| var e = {}; | |
| /** @type {number} */ | |
| offset = i = 0; | |
| for (; i < arr.a.length;) { | |
| d = arr.a[i]; | |
| if (!$i(e, d)) { | |
| arr.a[offset++] = d; | |
| /** @type {number} */ | |
| e[d] = 1; | |
| } | |
| i++; | |
| } | |
| /** @type {number} */ | |
| arr.a.length = offset; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @param {?} defaultValue | |
| * @return {?} | |
| */ | |
| Yi.prototype.get = function(name, defaultValue) { | |
| return $i(this.Va, name) ? this.Va[name] : defaultValue; | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| Yi.prototype.set = function(value, name) { | |
| if (!$i(this.Va, value)) { | |
| this.b++; | |
| this.a.push(value); | |
| this.c++; | |
| } | |
| /** @type {!Object} */ | |
| this.Va[value] = name; | |
| }; | |
| /** | |
| * @param {!Function} a | |
| * @param {!Object} obj | |
| * @return {undefined} | |
| */ | |
| Yi.prototype.forEach = function(a, obj) { | |
| var grandchildren = this.Mb(); | |
| /** @type {number} */ | |
| var cc = 0; | |
| for (; cc < grandchildren.length; cc++) { | |
| var j = grandchildren[cc]; | |
| var data = this.get(j); | |
| a.call(obj, data, j, this); | |
| } | |
| }; | |
| /** | |
| * @param {boolean} indexed | |
| * @return {?} | |
| */ | |
| Yi.prototype.xc = function(indexed) { | |
| Zi(this); | |
| /** @type {number} */ | |
| var offset = 0; | |
| var newLibraryVersion = this.c; | |
| var results = this; | |
| var pi = new Pi; | |
| /** | |
| * @return {?} | |
| */ | |
| pi.next = function() { | |
| if (newLibraryVersion != results.c) { | |
| throw Error("The map has changed since the iterator was created"); | |
| } | |
| if (offset >= results.a.length) { | |
| throw Oi; | |
| } | |
| var j = results.a[offset++]; | |
| return indexed ? j : results.Va[j]; | |
| }; | |
| return pi; | |
| }; | |
| /** | |
| * @param {?} m | |
| * @param {!Object} key | |
| * @return {?} | |
| */ | |
| var $i = function(m, key) { | |
| return Object.prototype.hasOwnProperty.call(m, key); | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @return {?} | |
| */ | |
| var cj = function(data) { | |
| if (data.bc && "function" == typeof data.bc) { | |
| return data.bc(); | |
| } | |
| if (r(data)) { | |
| return data.split(""); | |
| } | |
| if (La(data)) { | |
| /** @type {!Array} */ | |
| var map_entry = []; | |
| var tldCount = data.length; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < tldCount; i++) { | |
| map_entry.push(data[i]); | |
| } | |
| return map_entry; | |
| } | |
| return Ob(data); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Function} f | |
| * @param {!Object} o | |
| * @return {undefined} | |
| */ | |
| var dj = function(a, f, o) { | |
| if (a.forEach && "function" == typeof a.forEach) { | |
| a.forEach(f, o); | |
| } else { | |
| if (La(a) || r(a)) { | |
| A(a, f, o); | |
| } else { | |
| if (a.Mb && "function" == typeof a.Mb) { | |
| var data = a.Mb(); | |
| } else { | |
| if (a.bc && "function" == typeof a.bc) { | |
| data = void 0; | |
| } else { | |
| if (La(a) || r(a)) { | |
| /** @type {!Array} */ | |
| data = []; | |
| var m = a.length; | |
| /** @type {number} */ | |
| var k = 0; | |
| for (; k < m; k++) { | |
| data.push(k); | |
| } | |
| } else { | |
| data = Pb(a); | |
| } | |
| } | |
| } | |
| m = cj(a); | |
| k = m.length; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < k; i++) { | |
| f.call(o, m[i], data && data[i], a); | |
| } | |
| } | |
| } | |
| }; | |
| /** @type {!RegExp} */ | |
| var ej = /^(?:([^:/?#.]+):)?(?:\/\/(?:([^/?#]*)@)?([^/#?]*?)(?::([0-9]+))?(?=[/#?]|$))?([^?#]+)?(?:\?([^#]*))?(?:#([\s\S]*))?$/; | |
| /** | |
| * @param {string} s | |
| * @param {!Function} callback | |
| * @return {undefined} | |
| */ | |
| var fj = function(s, callback) { | |
| if (s) { | |
| s = s.split("&"); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < s.length; i++) { | |
| var idx = s[i].indexOf("="); | |
| /** @type {null} */ | |
| var stdout = null; | |
| if (0 <= idx) { | |
| var t = s[i].substring(0, idx); | |
| stdout = s[i].substring(idx + 1); | |
| } else { | |
| t = s[i]; | |
| } | |
| callback(t, stdout ? ee(stdout) : ""); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} args | |
| * @param {string} text | |
| * @return {?} | |
| */ | |
| var gj = function(args, text) { | |
| if (!text) { | |
| return args; | |
| } | |
| var start = args.indexOf("#"); | |
| if (0 > start) { | |
| start = args.length; | |
| } | |
| var i = args.indexOf("?"); | |
| if (0 > i || i > start) { | |
| i = start; | |
| /** @type {string} */ | |
| var next = ""; | |
| } else { | |
| next = args.substring(i + 1, start); | |
| } | |
| /** @type {!Array} */ | |
| args = [args.substr(0, i), next, args.substr(start)]; | |
| start = args[1]; | |
| args[1] = text ? start ? start + "&" + text : text : start; | |
| return args[0] + (args[1] ? "?" + args[1] : "") + args[2]; | |
| }; | |
| /** | |
| * @param {string} key | |
| * @param {string} message | |
| * @param {!Array} result | |
| * @return {undefined} | |
| */ | |
| var hj = function(key, message, result) { | |
| bb(key); | |
| if (Ka(message)) { | |
| eb(message); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < message.length; i++) { | |
| hj(key, String(message[i]), result); | |
| } | |
| } else { | |
| if (null != message) { | |
| result.push(key + ("" === message ? "" : "=" + de(message))); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Array} arr | |
| * @param {number} n | |
| * @return {?} | |
| */ | |
| var ij = function(arr, n) { | |
| z(0 == Math.max(arr.length - (n || 0), 0) % 2, "goog.uri.utils: Key/value lists must be even in length."); | |
| /** @type {!Array} */ | |
| var values = []; | |
| n = n || 0; | |
| for (; n < arr.length; n = n + 2) { | |
| hj(arr[n], arr[n + 1], values); | |
| } | |
| return values.join("&"); | |
| }; | |
| /** | |
| * @param {!Object} v | |
| * @return {?} | |
| */ | |
| var jj = function(v) { | |
| /** @type {!Array} */ | |
| var values = []; | |
| var m; | |
| for (m in v) { | |
| hj(m, v[m], values); | |
| } | |
| return values.join("&"); | |
| }; | |
| /** | |
| * @param {string} bundle | |
| * @param {string} code | |
| * @return {?} | |
| */ | |
| var kj = function(bundle, code) { | |
| var objtxt = 2 == arguments.length ? ij(arguments[1], 0) : ij(arguments, 1); | |
| return gj(bundle, objtxt); | |
| }; | |
| /** | |
| * @param {string} properties | |
| * @param {string} value | |
| * @param {string} result | |
| * @return {?} | |
| */ | |
| var lj = function(properties, value, result) { | |
| /** @type {string} */ | |
| result = null != result ? "=" + de(result) : ""; | |
| return gj(properties, value + result); | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {number} i | |
| * @param {string} value | |
| * @param {number} bits | |
| * @return {?} | |
| */ | |
| var mj = function(a, i, value, bits) { | |
| var n = value.length; | |
| for (; 0 <= (i = a.indexOf(value, i)) && i < bits;) { | |
| var id = a.charCodeAt(i - 1); | |
| if (38 == id || 63 == id) { | |
| if (id = a.charCodeAt(i + n), !id || 61 == id || 38 == id || 35 == id) { | |
| return i; | |
| } | |
| } | |
| i = i + (n + 1); | |
| } | |
| return -1; | |
| }; | |
| /** @type {!RegExp} */ | |
| var nj = /#|$/; | |
| /** | |
| * @return {?} | |
| */ | |
| var oj = function() { | |
| var r = l.location.href; | |
| var i = r.search(nj); | |
| var start = mj(r, 0, "authuser", i); | |
| if (0 > start) { | |
| return null; | |
| } | |
| var end = r.indexOf("&", start); | |
| if (0 > end || end > i) { | |
| end = i; | |
| } | |
| start = start + 9; | |
| return ee(r.substr(start, end - start)); | |
| }; | |
| /** @type {!RegExp} */ | |
| var pj = /[?&]($|#)/; | |
| /** | |
| * @param {string} n | |
| * @param {string} type | |
| * @return {?} | |
| */ | |
| var qj = function(n, type) { | |
| z(0 > n.indexOf("#") && 0 > n.indexOf("?"), "goog.uri.utils: Fragment or query identifiers are not supported: [%s]", n); | |
| if (wc(n, "/")) { | |
| n = n.substr(0, n.length - 1); | |
| } | |
| if (vc(type, "/")) { | |
| type = type.substr(1); | |
| } | |
| return ne(n, "/", type); | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var rj = function(a) { | |
| L.call(this); | |
| this.headers = new Yi; | |
| this.Eg = a || null; | |
| /** @type {boolean} */ | |
| this.Rb = false; | |
| /** @type {null} */ | |
| this.Dg = this.wa = null; | |
| /** @type {string} */ | |
| this.yj = this.ve = ""; | |
| /** @type {number} */ | |
| this.Rd = 0; | |
| /** @type {string} */ | |
| this.mf = ""; | |
| /** @type {boolean} */ | |
| this.Qd = this.Bh = this.ng = this.ah = false; | |
| /** @type {number} */ | |
| this.Be = 0; | |
| /** @type {null} */ | |
| this.zg = null; | |
| /** @type {string} */ | |
| this.Mj = ""; | |
| /** @type {boolean} */ | |
| this.Cg = this.tf = false; | |
| }; | |
| x(rj, L); | |
| rj.prototype.F = wi("goog.net.XhrIo"); | |
| /** @type {!RegExp} */ | |
| var sj = /^https?$/i; | |
| /** @type {!Array} */ | |
| var tj = ["POST", "PUT"]; | |
| /** @type {!Array} */ | |
| var uj = []; | |
| /** | |
| * @param {string} str | |
| * @param {string} start | |
| * @param {string} url | |
| * @param {string} type | |
| * @param {string} version | |
| * @param {number} id | |
| * @param {boolean} idOther | |
| * @return {?} | |
| */ | |
| var vj = function(str, start, url, type, version, id, idOther) { | |
| var self = new rj; | |
| uj.push(self); | |
| if (start) { | |
| self.M("complete", start); | |
| } | |
| self.Hh("ready", self.jl); | |
| if (id) { | |
| /** @type {number} */ | |
| self.Be = Math.max(0, id); | |
| } | |
| if (idOther) { | |
| /** @type {boolean} */ | |
| self.tf = idOther; | |
| } | |
| self.send(str, url, type, version); | |
| return self; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| rj.prototype.jl = function() { | |
| this.Qa(); | |
| xb(uj, this); | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @param {string} type | |
| * @param {string} b | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| rj.prototype.send = function(data, type, b, a) { | |
| if (this.wa) { | |
| throw Error("[goog.net.XhrIo] Object is active with another request=" + this.ve + "; newUri=" + data); | |
| } | |
| type = type ? type.toUpperCase() : "GET"; | |
| /** @type {!Object} */ | |
| this.ve = data; | |
| /** @type {string} */ | |
| this.mf = ""; | |
| /** @type {number} */ | |
| this.Rd = 0; | |
| /** @type {string} */ | |
| this.yj = type; | |
| /** @type {boolean} */ | |
| this.ah = false; | |
| /** @type {boolean} */ | |
| this.Rb = true; | |
| this.wa = this.Eg ? Ni(this.Eg) : Ni(Li); | |
| this.Dg = this.Eg ? Ki(this.Eg) : Ki(Li); | |
| this.wa.onreadystatechange = v(this.Ij, this); | |
| try { | |
| Ai(this.F, wj(this, "Opening Xhr")); | |
| /** @type {boolean} */ | |
| this.Bh = true; | |
| this.wa.open(type, String(data), true); | |
| /** @type {boolean} */ | |
| this.Bh = false; | |
| } catch (calItem) { | |
| Ai(this.F, wj(this, "Error opening Xhr: " + calItem.message)); | |
| this.Jf(5, calItem); | |
| return; | |
| } | |
| data = b || ""; | |
| var r = new Yi(this.headers); | |
| if (a) { | |
| dj(a, function(f, g) { | |
| r.set(g, f); | |
| }); | |
| } | |
| a = rb(r.Mb(), xj); | |
| b = l.FormData && data instanceof l.FormData; | |
| if (!(!tb(tj, type) || a || b)) { | |
| r.set("Content-Type", "application/x-www-form-urlencoded;charset=utf-8"); | |
| } | |
| r.forEach(function(uuid, i) { | |
| this.wa.setRequestHeader(i, uuid); | |
| }, this); | |
| if (this.Mj) { | |
| this.wa.responseType = this.Mj; | |
| } | |
| if ("withCredentials" in this.wa && this.wa.withCredentials !== this.tf) { | |
| this.wa.withCredentials = this.tf; | |
| } | |
| try { | |
| yj(this); | |
| if (0 < this.Be) { | |
| this.Cg = zj(this.wa); | |
| Ai(this.F, wj(this, "Will abort after " + this.Be + "ms if incomplete, xhr2 " + this.Cg)); | |
| if (this.Cg) { | |
| this.wa.timeout = this.Be; | |
| this.wa.ontimeout = v(this.yd, this); | |
| } else { | |
| this.zg = ci(this.yd, this.Be, this); | |
| } | |
| } | |
| Ai(this.F, wj(this, "Sending request")); | |
| /** @type {boolean} */ | |
| this.ng = true; | |
| this.wa.send(data); | |
| /** @type {boolean} */ | |
| this.ng = false; | |
| } catch (calItem) { | |
| Ai(this.F, wj(this, "Send error: " + calItem.message)); | |
| this.Jf(5, calItem); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} sweep | |
| * @return {?} | |
| */ | |
| var zj = function(sweep) { | |
| return C.V && C.Ea(9) && Aa(sweep.timeout) && q(sweep.ontimeout); | |
| }; | |
| /** | |
| * @param {string} p_Interval | |
| * @return {?} | |
| */ | |
| var xj = function(p_Interval) { | |
| return "content-type" == p_Interval.toLowerCase(); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| rj.prototype.yd = function() { | |
| if ("undefined" != typeof xa && this.wa) { | |
| /** @type {string} */ | |
| this.mf = "Timed out after " + this.Be + "ms, aborting"; | |
| /** @type {number} */ | |
| this.Rd = 8; | |
| Ai(this.F, wj(this, this.mf)); | |
| this.dispatchEvent("timeout"); | |
| this.abort(8); | |
| } | |
| }; | |
| /** | |
| * @param {number} partKeys | |
| * @param {?} calItem | |
| * @return {undefined} | |
| */ | |
| rj.prototype.Jf = function(partKeys, calItem) { | |
| /** @type {boolean} */ | |
| this.Rb = false; | |
| if (this.wa) { | |
| /** @type {boolean} */ | |
| this.Qd = true; | |
| this.wa.abort(); | |
| /** @type {boolean} */ | |
| this.Qd = false; | |
| } | |
| this.mf = calItem; | |
| /** @type {number} */ | |
| this.Rd = partKeys; | |
| Aj(this); | |
| Bj(this); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| var Aj = function(a) { | |
| if (!a.ah) { | |
| /** @type {boolean} */ | |
| a.ah = true; | |
| a.dispatchEvent("complete"); | |
| a.dispatchEvent("error"); | |
| } | |
| }; | |
| /** | |
| * @param {number} callback | |
| * @return {undefined} | |
| */ | |
| rj.prototype.abort = function(callback) { | |
| if (this.wa && this.Rb) { | |
| Ai(this.F, wj(this, "Aborting")); | |
| /** @type {boolean} */ | |
| this.Rb = false; | |
| /** @type {boolean} */ | |
| this.Qd = true; | |
| this.wa.abort(); | |
| /** @type {boolean} */ | |
| this.Qd = false; | |
| this.Rd = callback || 7; | |
| this.dispatchEvent("complete"); | |
| this.dispatchEvent("abort"); | |
| Bj(this); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| rj.prototype.X = function() { | |
| if (this.wa) { | |
| if (this.Rb) { | |
| /** @type {boolean} */ | |
| this.Rb = false; | |
| /** @type {boolean} */ | |
| this.Qd = true; | |
| this.wa.abort(); | |
| /** @type {boolean} */ | |
| this.Qd = false; | |
| } | |
| Bj(this, true); | |
| } | |
| rj.D.X.call(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| rj.prototype.Ij = function() { | |
| if (!this.Ac) { | |
| if (this.Bh || this.ng || this.Qd) { | |
| Cj(this); | |
| } else { | |
| this.vo(); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| rj.prototype.vo = function() { | |
| Cj(this); | |
| }; | |
| /** | |
| * @param {!Object} self | |
| * @return {undefined} | |
| */ | |
| var Cj = function(self) { | |
| if (self.Rb && "undefined" != typeof xa) { | |
| if (self.Dg[1] && 4 == Dj(self) && 2 == self.cd()) { | |
| Ai(self.F, wj(self, "Local request error detected and ignored")); | |
| } else { | |
| if (self.ng && 4 == Dj(self)) { | |
| ci(self.Ij, 0, self); | |
| } else { | |
| if (self.dispatchEvent("readystatechange"), 4 == Dj(self)) { | |
| Ai(self.F, wj(self, "Request complete")); | |
| /** @type {boolean} */ | |
| self.Rb = false; | |
| try { | |
| if (Ej(self)) { | |
| self.dispatchEvent("complete"); | |
| self.dispatchEvent("success"); | |
| } else { | |
| /** @type {number} */ | |
| self.Rd = 6; | |
| try { | |
| var generatorMark = 2 < Dj(self) ? self.wa.statusText : ""; | |
| } catch (controlFlowAction) { | |
| Ai(self.F, "Can not get status: " + controlFlowAction.message); | |
| /** @type {string} */ | |
| generatorMark = ""; | |
| } | |
| /** @type {string} */ | |
| self.mf = generatorMark + " [" + self.cd() + "]"; | |
| Aj(self); | |
| } | |
| } finally { | |
| Bj(self); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} config | |
| * @param {boolean} _newfeed | |
| * @return {undefined} | |
| */ | |
| var Bj = function(config, _newfeed) { | |
| if (config.wa) { | |
| yj(config); | |
| var script = config.wa; | |
| /** @type {(function(): undefined|null)} */ | |
| var initSoundcloud = config.Dg[0] ? Ha : null; | |
| /** @type {null} */ | |
| config.wa = null; | |
| /** @type {null} */ | |
| config.Dg = null; | |
| if (!_newfeed) { | |
| config.dispatchEvent("ready"); | |
| } | |
| try { | |
| /** @type {(function(): undefined|null)} */ | |
| script.onreadystatechange = initSoundcloud; | |
| } catch (controlFlowAction) { | |
| xi(config.F, "Problem encountered resetting onreadystatechange: " + controlFlowAction.message); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} config | |
| * @return {undefined} | |
| */ | |
| var yj = function(config) { | |
| if (config.wa && config.Cg) { | |
| /** @type {null} */ | |
| config.wa.ontimeout = null; | |
| } | |
| if (config.zg) { | |
| di(config.zg); | |
| /** @type {null} */ | |
| config.zg = null; | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| rj.prototype.tb = function() { | |
| return !!this.wa; | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @return {?} | |
| */ | |
| var Ej = function(data) { | |
| var v = data.cd(); | |
| a: { | |
| switch(v) { | |
| case 200: | |
| case 201: | |
| case 202: | |
| case 204: | |
| case 206: | |
| case 304: | |
| case 1223: | |
| /** @type {boolean} */ | |
| var validationVM = true; | |
| break a; | |
| default: | |
| /** @type {boolean} */ | |
| validationVM = false; | |
| } | |
| } | |
| if (!validationVM) { | |
| if (v = 0 === v) { | |
| /** @type {(null|string)} */ | |
| data = String(data.ve).match(ej)[1] || null; | |
| if (!data && l.self && l.self.location) { | |
| data = l.self.location.protocol; | |
| data = data.substr(0, data.length - 1); | |
| } | |
| /** @type {boolean} */ | |
| v = !sj.test(data ? data.toLowerCase() : ""); | |
| } | |
| /** @type {boolean} */ | |
| validationVM = v; | |
| } | |
| return validationVM; | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @return {?} | |
| */ | |
| var Dj = function(o) { | |
| return o.wa ? o.wa.readyState : 0; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| rj.prototype.cd = function() { | |
| try { | |
| return 2 < Dj(this) ? this.wa.status : -1; | |
| } catch (a) { | |
| return -1; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @return {?} | |
| */ | |
| var Fj = function(data) { | |
| try { | |
| return data.wa ? data.wa.responseText : ""; | |
| } catch (controlFlowAction) { | |
| return Ai(data.F, "Can not get responseText: " + controlFlowAction.message), ""; | |
| } | |
| }; | |
| /** | |
| * @param {string} data | |
| * @return {?} | |
| */ | |
| var Gj = function(data) { | |
| if (data.wa) { | |
| a: { | |
| data = data.wa.responseText; | |
| if (l.JSON) { | |
| try { | |
| var value = l.JSON.parse(data); | |
| z("object" == typeof value); | |
| var crypted = value; | |
| break a; | |
| } catch (d) { | |
| } | |
| } | |
| crypted = Ci(data); | |
| } | |
| return crypted; | |
| } | |
| }; | |
| /** | |
| * @param {number} k | |
| * @return {?} | |
| */ | |
| rj.prototype.getResponseHeader = function(k) { | |
| if (this.wa && 4 == Dj(this)) { | |
| return k = this.wa.getResponseHeader(k), null === k ? void 0 : k; | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| rj.prototype.getAllResponseHeaders = function() { | |
| return this.wa && 4 == Dj(this) ? this.wa.getAllResponseHeaders() || "" : ""; | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @param {string} msg | |
| * @return {?} | |
| */ | |
| var wj = function(node, msg) { | |
| return msg + " [" + node.yj + " " + node.ve + " " + node.cd() + "]"; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {?} f | |
| * @param {?} newFilter | |
| * @return {undefined} | |
| */ | |
| var Hj = function(a, f, newFilter) { | |
| vj(a.url, function(result) { | |
| result = result.target; | |
| if (Ej(result)) { | |
| f(Fj(result)); | |
| } else { | |
| newFilter(result.cd()); | |
| } | |
| }, a.b, a.body, a.a, a.c, a.withCredentials); | |
| }; | |
| /** | |
| * @param {undefined} ___j | |
| * @return {undefined} | |
| */ | |
| var Ij = function(___j) { | |
| He(this, ___j, -1, null); | |
| }; | |
| x(Ij, De); | |
| /** | |
| * @param {undefined} ___j | |
| * @return {undefined} | |
| */ | |
| var Jj = function(___j) { | |
| He(this, ___j, -1, null); | |
| }; | |
| x(Jj, De); | |
| /** | |
| * @param {undefined} ___j | |
| * @return {undefined} | |
| */ | |
| var Mj = function(___j) { | |
| He(this, ___j, -1, Kj); | |
| }; | |
| x(Mj, De); | |
| /** @type {!Array} */ | |
| var Kj = [2]; | |
| /** | |
| * @param {undefined} ___j | |
| * @return {undefined} | |
| */ | |
| var Oj = function(___j) { | |
| He(this, ___j, 29, Nj); | |
| }; | |
| x(Oj, De); | |
| /** @type {!Array} */ | |
| var Nj = [3, 20, 27]; | |
| /** | |
| * @param {undefined} ___j | |
| * @return {undefined} | |
| */ | |
| var Qj = function(___j) { | |
| He(this, ___j, 17, Pj); | |
| }; | |
| x(Qj, De); | |
| /** @type {!Array} */ | |
| var Pj = [3, 5]; | |
| /** | |
| * @param {!Object} msg | |
| * @return {undefined} | |
| */ | |
| var Rj = function(msg) { | |
| var len = Ua().toString(); | |
| D(msg, 4, len); | |
| }; | |
| /** | |
| * @param {undefined} ___j | |
| * @return {undefined} | |
| */ | |
| var Tj = function(___j) { | |
| He(this, ___j, 6, Sj); | |
| }; | |
| x(Tj, De); | |
| /** @type {!Array} */ | |
| var Sj = [5]; | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| var Uj = function(name) { | |
| He(this, name, -1, null); | |
| }; | |
| x(Uj, De); | |
| var Vj = new function() { | |
| /** @type {function(!Object): undefined} */ | |
| this.a = Uj; | |
| }; | |
| /** | |
| * @param {undefined} e | |
| * @param {string} date | |
| * @param {string} bcString | |
| * @param {?} name | |
| * @param {string} itter | |
| * @param {string} f | |
| * @param {string} forceClassBase | |
| * @param {?} rmapper | |
| * @param {string} m | |
| * @param {boolean} s | |
| * @return {undefined} | |
| */ | |
| var Xj = function(e, date, bcString, name, itter, f, forceClassBase, rmapper, m, s) { | |
| L.call(this); | |
| this.ea = e; | |
| this.O = date || Ha; | |
| this.h = new Qj; | |
| this.ma = name; | |
| /** @type {!Array} */ | |
| this.a = []; | |
| /** @type {string} */ | |
| this.T = ""; | |
| this.ra = Ta(bf, 0, 1); | |
| this.G = itter || null; | |
| this.m = bcString || null; | |
| this.C = forceClassBase || false; | |
| this.K = m || null; | |
| /** @type {boolean} */ | |
| this.Y = this.oa = false; | |
| /** @type {number} */ | |
| this.W = this.R = -1; | |
| /** @type {null} */ | |
| this.c = null; | |
| this.F = wi("playlog.clearcut.ClearcutBase"); | |
| /** @type {boolean} */ | |
| this.tf = !rmapper; | |
| /** @type {number} */ | |
| this.L = 0; | |
| /** @type {number} */ | |
| this.Na = 1; | |
| this.Z = f || false; | |
| e = new Jj; | |
| D(e, 1, 1); | |
| if (!f) { | |
| f = new Ij; | |
| /** @type {string} */ | |
| date = document.documentElement.getAttribute("lang"); | |
| D(f, 5, date); | |
| Le(e, 11, f); | |
| } | |
| Le(this.h, 1, e); | |
| D(this.h, 2, this.ea); | |
| this.g = new Bi(1E4); | |
| this.b = new ai(this.g.aa()); | |
| jg(this, this.b); | |
| I(this.b, "tick", Kb(Wj(this, s)), false, this); | |
| this.w = new ai(6E5); | |
| jg(this, this.w); | |
| I(this.w, "tick", Kb(Wj(this, s)), false, this); | |
| if (!this.C) { | |
| this.w.start(); | |
| } | |
| if (!this.Z) { | |
| I(vf(), "beforeunload", this.o, false, this); | |
| I(vf(), "unload", this.o, false, this); | |
| I(document, "pagehide", this.o, false, this); | |
| } | |
| }; | |
| x(Xj, L); | |
| /** | |
| * @param {!Object} that | |
| * @param {boolean} b | |
| * @return {?} | |
| */ | |
| var Wj = function(that, b) { | |
| return b ? function() { | |
| b().then(that.flush.bind(that)); | |
| } : that.flush; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Xj.prototype.X = function() { | |
| this.o(); | |
| Xj.D.X.call(this); | |
| }; | |
| /** | |
| * @param {!Object} m | |
| * @return {?} | |
| */ | |
| var Yj = function(m) { | |
| if (!m.G) { | |
| /** @type {string} */ | |
| m.G = .01 > m.ra() ? "https://www.google.com/log?format=json&hasfast=true" : "https://play.google.com/log?format=json&hasfast=true"; | |
| } | |
| return m.G; | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| Xj.prototype.log = function(name) { | |
| name = Re(name); | |
| /** @type {number} */ | |
| var Y = this.Na++; | |
| D(name, 21, Y); | |
| if (!Ie(name, 1)) { | |
| /** @type {string} */ | |
| Y = name; | |
| var len = Ua().toString(); | |
| D(Y, 1, len); | |
| } | |
| if (this.c) { | |
| Y = Re(this.c); | |
| Le(name, 16, Y); | |
| } | |
| for (; 1E3 <= this.a.length;) { | |
| this.a.shift(); | |
| ++this.L; | |
| } | |
| this.a.push(name); | |
| this.dispatchEvent(new Zj(name)); | |
| if (!(this.C || this.b.b)) { | |
| this.b.start(); | |
| } | |
| }; | |
| /** | |
| * @param {?} callback | |
| * @param {?} sync | |
| * @return {undefined} | |
| */ | |
| Xj.prototype.flush = function(callback, sync) { | |
| if (0 == this.a.length) { | |
| if (callback) { | |
| callback(); | |
| } | |
| } else { | |
| var obj = Ua(); | |
| if (this.W > obj && this.R < obj) { | |
| zi(this.F, "Not flushing because server requested delay."); | |
| if (sync) { | |
| sync("throttled"); | |
| } | |
| } else { | |
| var msg = Re(this.h); | |
| Rj(msg); | |
| Me(msg, 3, this.a); | |
| D(msg, 14, this.L); | |
| obj = {}; | |
| var depth = this.O(); | |
| if (depth) { | |
| obj.Authorization = depth; | |
| } | |
| var prev = Yj(this); | |
| if (this.m) { | |
| obj["X-Goog-AuthUser"] = this.m; | |
| prev = lj(prev, "authuser", this.m); | |
| } | |
| if (this.K) { | |
| obj["X-Goog-PageId"] = this.K; | |
| prev = lj(prev, "pageId", this.K); | |
| } | |
| if (depth && this.T == depth) { | |
| zi(this.F, "XHR with unauthorized request not retried"); | |
| if (sync) { | |
| sync("stale-auth-token"); | |
| } | |
| } else { | |
| zi(this.F, "Flushing log to clearcut."); | |
| /** @type {!Array} */ | |
| this.a = []; | |
| if (this.b.b) { | |
| this.b.stop(); | |
| } | |
| /** @type {number} */ | |
| this.L = 0; | |
| var props = msg.vd(); | |
| obj = { | |
| url : prev, | |
| body : props, | |
| g : 1, | |
| a : obj, | |
| b : "POST", | |
| withCredentials : this.tf, | |
| c : 0 | |
| }; | |
| prev = v(function(elem) { | |
| this.g.reset(); | |
| bi(this.b, this.g.aa()); | |
| if (elem) { | |
| try { | |
| /** @type {*} */ | |
| var nonce = JSON.parse(elem.replace(")]}'\n", "")); | |
| var n = new Tj(nonce); | |
| } catch (p) { | |
| yi(this.F, "Response parse failed: " + p); | |
| } | |
| if (n) { | |
| elem = Je(n, "-1"); | |
| /** @type {number} */ | |
| elem = Number(elem); | |
| if (0 < elem) { | |
| this.R = Ua(); | |
| this.W = this.R + elem; | |
| } | |
| if (n.c) { | |
| if (!n.a) { | |
| n.a = {}; | |
| } | |
| if (Vj.a) { | |
| if (!n.a[175237375] && n.c[175237375]) { | |
| n.a[175237375] = new Vj.a(n.c[175237375]); | |
| } | |
| n = n.a[175237375]; | |
| } else { | |
| n = n.c[175237375]; | |
| } | |
| } else { | |
| n = void 0; | |
| } | |
| if (n) { | |
| n = Je(n, -1); | |
| if (-1 != n) { | |
| this.g = new Bi(1 > n ? 1 : n); | |
| bi(this.b, this.g.aa()); | |
| } | |
| } | |
| } | |
| } | |
| if (callback) { | |
| callback(); | |
| } | |
| }, this); | |
| props = v(function(stat) { | |
| Ke(msg, Oj, 3); | |
| var collector = msg.a[3]; | |
| if (collector == Fe) { | |
| /** @type {!Array} */ | |
| collector = msg.a[3] = []; | |
| } | |
| var c = this.g; | |
| /** @type {number} */ | |
| c.a = Math.min(3E5, 2 * c.a); | |
| /** @type {number} */ | |
| c.b = Math.min(3E5, c.a + Math.round(.2 * (Math.random() - .5) * c.a)); | |
| bi(this.b, this.g.aa()); | |
| if (401 == stat && depth) { | |
| this.T = depth; | |
| } | |
| if (500 <= stat && 600 > stat || 401 == stat || 0 == stat) { | |
| this.a = collector.concat(this.a); | |
| if (!(this.C || this.b.b)) { | |
| this.b.start(); | |
| } | |
| } | |
| yi(this.F, "Flush failed. Status code: " + stat); | |
| if (sync) { | |
| sync("net-send-failed", stat); | |
| } | |
| }, this); | |
| this.ma(obj, prev, props); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Xj.prototype.o = function() { | |
| if (this.oa) { | |
| ak(this); | |
| } | |
| if (this.Y) { | |
| bk(this); | |
| } | |
| this.flush(); | |
| }; | |
| /** | |
| * @param {!Object} fields | |
| * @return {undefined} | |
| */ | |
| var ak = function(fields) { | |
| zi(fields.F, "Flushing log using sendBeacon."); | |
| ck(fields, 32, 10, function(result, summary) { | |
| result = lj(result, "format", "json"); | |
| return vf().navigator.sendBeacon(result, summary.vd()); | |
| }); | |
| }; | |
| /** | |
| * @param {!Object} fields | |
| * @return {undefined} | |
| */ | |
| var bk = function(fields) { | |
| zi(fields.F, "Flushing log using Image GET."); | |
| ck(fields, 6, 5, v(function(data, result) { | |
| result = result.vd(); | |
| /** @type {!Array} */ | |
| var a = []; | |
| /** @type {number} */ | |
| var cnt = 0; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < result.length; i++) { | |
| var n = result.charCodeAt(i); | |
| if (255 < n) { | |
| /** @type {number} */ | |
| a[cnt++] = n & 255; | |
| /** @type {number} */ | |
| n = n >> 8; | |
| } | |
| a[cnt++] = n; | |
| } | |
| result = Ce(a, true); | |
| result = kj(data, "format", "base64json", "p", result); | |
| /** @type {!Image} */ | |
| data = new Image; | |
| Ib(data, "HTMLImageElement"); | |
| result = result instanceof Qc ? result : Yc(result, /^data:image\//i.test(result)); | |
| data.src = Rc(result); | |
| return true; | |
| }, fields)); | |
| }; | |
| /** | |
| * @param {!Object} f | |
| * @param {number} n | |
| * @param {number} max | |
| * @param {!Function} check | |
| * @return {undefined} | |
| */ | |
| var ck = function(f, n, max, check) { | |
| if (0 != f.a.length) { | |
| var b = Yj(f); | |
| var len = b.search(nj); | |
| /** @type {number} */ | |
| var a = 0; | |
| var i; | |
| /** @type {!Array} */ | |
| var path = []; | |
| for (; 0 <= (i = mj(b, a, "format", len));) { | |
| path.push(b.substring(a, i)); | |
| /** @type {number} */ | |
| a = Math.min(b.indexOf("&", i) + 1 || len, len); | |
| } | |
| path.push(b.substr(a)); | |
| /** @type {string} */ | |
| b = path.join("").replace(pj, "$1"); | |
| b = kj(b, "auth", f.O(), "authuser", f.m || "0"); | |
| /** @type {number} */ | |
| len = 0; | |
| for (; len < max && f.a.length; ++len) { | |
| a = f.a.slice(0, n); | |
| i = Re(f.h); | |
| Rj(i); | |
| Me(i, 3, a); | |
| if (!check(b, i)) { | |
| break; | |
| } | |
| f.a = f.a.slice(a.length); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Zj = function() { | |
| /** @type {string} */ | |
| this.type = "event-logged"; | |
| }; | |
| x(Zj, kg); | |
| /** | |
| * @param {?} elId | |
| * @param {?} c | |
| * @param {?} d | |
| * @param {?} k | |
| * @param {?} cb | |
| * @param {?} Container | |
| * @param {?} BeforeAlignEvent | |
| * @return {undefined} | |
| */ | |
| var dk = function(elId, c, d, k, cb, Container, BeforeAlignEvent) { | |
| Xj.call(this, elId, ji, c, Hj, d, k, cb, void 0, Container, BeforeAlignEvent); | |
| }; | |
| x(dk, Xj); | |
| /** | |
| * @param {!Object} X | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| var ek = function(X, a) { | |
| this.a = new dk(375, X, void 0, false, true); | |
| jg(this, this.a); | |
| this.a.oa = !!vf().navigator.sendBeacon && (C.product.Ge || C.product.Lg && C.Ea(45)); | |
| /** @type {boolean} */ | |
| this.a.Y = true; | |
| if (a && 0 < a.length) { | |
| X = new Te; | |
| D(X, 3, a || []); | |
| a = this.a; | |
| if (X) { | |
| if (!a.c) { | |
| a.c = new Mj; | |
| } | |
| X = X.vd(); | |
| D(a.c, 4, X); | |
| } else { | |
| if (a.c) { | |
| D(a.c, 4, void 0); | |
| } | |
| } | |
| } | |
| /** @type {number} */ | |
| this.g = 0; | |
| this.b = new ai(1E3); | |
| jg(this, this.b); | |
| I(this.b, "tick", this.c, false, this); | |
| this.b.start(); | |
| }; | |
| x(ek, L); | |
| /** | |
| * @return {undefined} | |
| */ | |
| ek.prototype.X = function() { | |
| this.b.stop(); | |
| Og(this.b, "tick", this.c, false, this); | |
| this.c(); | |
| ek.D.X.call(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| ek.prototype.c = function() { | |
| if (0 < this.g) { | |
| this.a.flush(v(this.h, this)); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| ek.prototype.h = function() { | |
| /** @type {number} */ | |
| this.g = 0; | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| ek.prototype.log = function(name) { | |
| this.a.log(name); | |
| if (900 <= ++this.g) { | |
| this.c(); | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| C.product.Ve = function() { | |
| if (C.product.Lg) { | |
| return C.product.je(/Firefox\/([0-9.]+)/); | |
| } | |
| if (C.product.V || C.product.vb || C.product.cb) { | |
| return C.VERSION; | |
| } | |
| if (C.product.Ge) { | |
| return se() ? C.product.je(/CriOS\/([0-9.]+)/) : C.product.je(/Chrome\/([0-9.]+)/); | |
| } | |
| if (C.product.ee && !se()) { | |
| return C.product.je(/Version\/([0-9.]+)/); | |
| } | |
| if (C.product.vc || C.product.Lc) { | |
| var a = C.product.Ui(/Version\/(\S+).*Mobile\/(\S+)/); | |
| if (a) { | |
| return a[1] + "." + a[2]; | |
| } | |
| } else { | |
| if (C.product.Kc) { | |
| return (a = C.product.je(/Android\s+([0-9.]+)/)) ? a : C.product.je(/Version\/([0-9.]+)/); | |
| } | |
| } | |
| return ""; | |
| }; | |
| /** | |
| * @param {!Object} match | |
| * @return {?} | |
| */ | |
| C.product.je = function(match) { | |
| return (match = C.product.Ui(match)) ? match[1] : ""; | |
| }; | |
| /** | |
| * @param {!Object} block | |
| * @return {?} | |
| */ | |
| C.product.Ui = function(block) { | |
| return block.exec(C.Md()); | |
| }; | |
| C.product.VERSION = C.product.Ve(); | |
| /** | |
| * @param {!Object} bits | |
| * @return {?} | |
| */ | |
| C.product.ub = function(bits) { | |
| return 0 <= Oc(C.product.VERSION, bits); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var fk = function() { | |
| this.a = C.product.V ? C.product.ub(9) : C.product.Ge && C.product.ub(25) || C.product.V && C.product.ub(8) || C.vb || C.product.Lg && C.product.ub(19) || C.product.cb && C.product.ub(12.1) || C.product.ee && C.product.ub(5.1) || C.product.Lc && C.product.ub(3.2) || C.product.Kc && C.product.ub(2.1); | |
| }; | |
| Ia(fk); | |
| /** | |
| * @param {number} n | |
| * @param {string} i | |
| * @return {?} | |
| */ | |
| var ik = function(n, i) { | |
| var re = gk[i]; | |
| i = hk[i]; | |
| re = null != re ? Ab(re) : []; | |
| if (n.a && null != i) { | |
| /** @type {number} */ | |
| n = 0; | |
| for (; n < i.length; n++) { | |
| re.push(i[n]); | |
| } | |
| } | |
| return re; | |
| }; | |
| /** | |
| * @param {string} b | |
| * @return {?} | |
| */ | |
| var kk = function(b) { | |
| return 0 <= b.indexOf("-i0-") && !jk(b); | |
| }; | |
| /** | |
| * @param {string} subArray | |
| * @return {?} | |
| */ | |
| var jk = function(subArray) { | |
| return 0 <= subArray.indexOf("-i0-handwrit"); | |
| }; | |
| var gk = { | |
| af : ["latn-002-t-k0-und"], | |
| 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 : ["latn-002-t-k0-und"], | |
| da : ["da-t-k0-und"], | |
| de : ["de-t-k0-und", "de-ch-t-k0-und", "en-us-t-k0-intl"], | |
| el : ["el-t-i0-und", "el-t-k0-und"], | |
| en : ["en-t-k0-und", "en-t-k0-dvorak"], | |
| es : ["es-t-k0-und", "en-us-t-k0-intl"], | |
| 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 : ["fr-t-k0-und", "en-us-t-k0-intl"], | |
| ga : ["latn-002-t-k0-und"], | |
| gl : ["gl-t-k0-und"], | |
| gu : ["gu-t-i0-und", "gu-t-k0-und", "gu-t-und-latn-k0-qwerty"], | |
| ha : ["latn-002-t-k0-und"], | |
| hi : ["hi-t-i0-und", "hi-t-k0-und", "hi-t-k0-qwerty"], | |
| hr : ["hr-t-k0-und"], | |
| ht : ["fr-t-k0-und"], | |
| hu : ["hu-t-k0-101key"], | |
| hy : ["hy-hyr-t-k0-und", "hy-hyt-t-k0-und"], | |
| id : ["latn-002-t-k0-und"], | |
| ig : ["latn-002-t-k0-und"], | |
| is : ["is-t-k0-und"], | |
| it : ["it-t-k0-und", "en-us-t-k0-intl"], | |
| iw : ["he-t-i0-und", "he-t-k0-und"], | |
| jw : ["latn-002-t-k0-und"], | |
| 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 : ["fr-t-k0-und", "en-us-t-k0-intl"], | |
| lo : ["lo-t-k0-und"], | |
| lt : ["lt-t-k0-und"], | |
| lv : ["lv-t-k0-und"], | |
| mg : ["latn-002-t-k0-und"], | |
| 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", "hi-t-k0-qwerty"], | |
| ms : ["latn-002-t-k0-und"], | |
| 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", "en-us-t-k0-intl"], | |
| no : ["no-t-k0-und"], | |
| ny : ["latn-002-t-k0-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", "en-us-t-k0-intl"], | |
| ro : ["ro-t-k0-und", "ro-t-k0-legacy", "ro-t-k0-extended"], | |
| ru : ["ru-t-i0-und", "ru-t-k0-und"], | |
| rw : ["latn-002-t-k0-und"], | |
| 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 : ["latn-002-t-k0-und"], | |
| so : ["latn-002-t-k0-und"], | |
| sq : ["sq-t-k0-und"], | |
| sr : ["sr-t-i0-und", "sr-cyrl-t-k0-und", "sr-latn-t-k0-und"], | |
| st : ["latn-002-t-k0-und"], | |
| su : ["latn-002-t-k0-und"], | |
| sv : ["sv-t-k0-und"], | |
| sw : ["latn-002-t-k0-und"], | |
| 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 : ["latn-002-t-k0-und"], | |
| tl : ["latn-002-t-k0-und"], | |
| 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 : ["latn-002-t-k0-und"], | |
| xh : ["latn-002-t-k0-und"], | |
| yi : ["yi-t-k0-und"], | |
| yo : ["latn-002-t-k0-und"], | |
| yue : ["yue-hant-t-i0-und", "zh-hant-t-i0-cangjie-1982"], | |
| zu : ["latn-002-t-k0-und"], | |
| "zh-CN" : "zh-t-i0-pinyin zh-t-i0-wubi-1986 zh-hant-t-i0-und zh-hant-t-i0-cangjie-1982 zh-hant-t-i0-pinyin yue-hant-t-i0-und".split(" "), | |
| "zh-TW" : ["zh-hant-t-i0-und", "zh-hant-t-i0-cangjie-1982", "zh-hant-t-i0-pinyin", "yue-hant-t-i0-und"] | |
| }; | |
| var hk = { | |
| af : ["af-t-i0-handwrit"], | |
| am : ["am-t-i0-handwrit"], | |
| ar : ["ar-t-i0-handwrit"], | |
| auto : ["mul-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"], | |
| hy : ["hy-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"], | |
| ka : ["ka-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"], | |
| 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"], | |
| 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"] | |
| }; | |
| /** | |
| * @param {undefined} ___j | |
| * @return {undefined} | |
| */ | |
| var lk = function(___j) { | |
| He(this, ___j, -1, null); | |
| }; | |
| x(lk, De); | |
| /** | |
| * @return {?} | |
| */ | |
| lk.prototype.ie = function() { | |
| return Ie(this, 1); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| lk.prototype.sb = function() { | |
| return Ie(this, 4); | |
| }; | |
| /** | |
| * @param {undefined} s | |
| * @return {undefined} | |
| */ | |
| var mk = function(s) { | |
| He(this, s, -1, null); | |
| }; | |
| x(mk, De); | |
| /** | |
| * @param {undefined} ___j | |
| * @return {undefined} | |
| */ | |
| var nk = function(___j) { | |
| He(this, ___j, -1, null); | |
| }; | |
| x(nk, De); | |
| /** | |
| * @param {undefined} m | |
| * @return {undefined} | |
| */ | |
| var ok = function(m) { | |
| He(this, m, -1, null); | |
| }; | |
| x(ok, De); | |
| /** | |
| * @param {undefined} ___j | |
| * @return {undefined} | |
| */ | |
| var qk = function(___j) { | |
| He(this, ___j, -1, pk); | |
| }; | |
| x(qk, De); | |
| /** @type {!Array} */ | |
| var pk = [1]; | |
| /** | |
| * @param {undefined} v | |
| * @return {undefined} | |
| */ | |
| var rk = function(v) { | |
| He(this, v, -1, null); | |
| }; | |
| x(rk, De); | |
| /** | |
| * @param {undefined} n | |
| * @return {undefined} | |
| */ | |
| var sk = function(n) { | |
| He(this, n, -1, null); | |
| }; | |
| x(sk, De); | |
| /** | |
| * @param {undefined} ___j | |
| * @return {undefined} | |
| */ | |
| var tk = function(___j) { | |
| He(this, ___j, -1, null); | |
| }; | |
| x(tk, De); | |
| /** | |
| * @param {undefined} n | |
| * @return {undefined} | |
| */ | |
| var uk = function(n) { | |
| He(this, n, -1, null); | |
| }; | |
| x(uk, De); | |
| /** | |
| * @param {undefined} url | |
| * @return {undefined} | |
| */ | |
| var vk = function(url) { | |
| He(this, url, -1, null); | |
| }; | |
| x(vk, De); | |
| /** | |
| * @return {?} | |
| */ | |
| vk.prototype.ab = function() { | |
| return Ie(this, 1); | |
| }; | |
| /** | |
| * @param {undefined} ___j | |
| * @return {undefined} | |
| */ | |
| var wk = function(___j) { | |
| He(this, ___j, -1, null); | |
| }; | |
| x(wk, De); | |
| /** | |
| * @param {undefined} ___j | |
| * @return {undefined} | |
| */ | |
| var yk = function(___j) { | |
| He(this, ___j, -1, xk); | |
| }; | |
| x(yk, De); | |
| /** @type {!Array} */ | |
| var xk = [1, 3, 4]; | |
| /** | |
| * @param {undefined} ___j | |
| * @return {undefined} | |
| */ | |
| var zk = function(___j) { | |
| He(this, ___j, -1, null); | |
| }; | |
| x(zk, De); | |
| /** | |
| * @param {undefined} ___j | |
| * @return {undefined} | |
| */ | |
| var Ak = function(___j) { | |
| He(this, ___j, -1, null); | |
| }; | |
| x(Ak, De); | |
| /** | |
| * @return {?} | |
| */ | |
| Ak.prototype.Tb = function() { | |
| return Ie(this, 1); | |
| }; | |
| /** | |
| * @param {undefined} ___j | |
| * @return {undefined} | |
| */ | |
| var Bk = function(___j) { | |
| He(this, ___j, -1, null); | |
| }; | |
| x(Bk, De); | |
| /** | |
| * @param {undefined} ___j | |
| * @return {undefined} | |
| */ | |
| var Ek = function(___j) { | |
| He(this, ___j, -1, Dk); | |
| }; | |
| x(Ek, De); | |
| /** @type {!Array} */ | |
| var Dk = [1]; | |
| /** | |
| * @return {?} | |
| */ | |
| Ek.prototype.sb = function() { | |
| return Ie(this, 5); | |
| }; | |
| /** | |
| * @param {undefined} ___j | |
| * @return {undefined} | |
| */ | |
| var Fk = function(___j) { | |
| He(this, ___j, -1, null); | |
| }; | |
| x(Fk, De); | |
| /** | |
| * @param {undefined} ___j | |
| * @return {undefined} | |
| */ | |
| var Hk = function(___j) { | |
| He(this, ___j, -1, Gk); | |
| }; | |
| x(Hk, De); | |
| /** @type {!Array} */ | |
| var Gk = [2]; | |
| /** | |
| * @param {undefined} ___j | |
| * @return {undefined} | |
| */ | |
| var Ik = function(___j) { | |
| He(this, ___j, -1, null); | |
| }; | |
| x(Ik, De); | |
| /** | |
| * @param {undefined} ___j | |
| * @return {undefined} | |
| */ | |
| var Jk = function(___j) { | |
| He(this, ___j, -1, null); | |
| }; | |
| x(Jk, De); | |
| /** | |
| * @param {undefined} ___j | |
| * @return {undefined} | |
| */ | |
| var Kk = function(___j) { | |
| He(this, ___j, -1, null); | |
| }; | |
| x(Kk, De); | |
| /** | |
| * @param {undefined} ___j | |
| * @return {undefined} | |
| */ | |
| var Lk = function(___j) { | |
| He(this, ___j, -1, null); | |
| }; | |
| x(Lk, De); | |
| /** | |
| * @param {undefined} ___j | |
| * @return {undefined} | |
| */ | |
| var Nk = function(___j) { | |
| He(this, ___j, -1, Mk); | |
| }; | |
| x(Nk, De); | |
| /** @type {!Array} */ | |
| var Mk = [3, 4]; | |
| /** | |
| * @param {undefined} ___j | |
| * @return {undefined} | |
| */ | |
| var Pk = function(___j) { | |
| He(this, ___j, -1, Ok); | |
| }; | |
| x(Pk, De); | |
| /** @type {!Array} */ | |
| var Ok = [3]; | |
| /** | |
| * @param {undefined} ___j | |
| * @return {undefined} | |
| */ | |
| var Rk = function(___j) { | |
| He(this, ___j, -1, Qk); | |
| }; | |
| x(Rk, De); | |
| /** @type {!Array} */ | |
| var Qk = [2]; | |
| /** | |
| * @param {undefined} ___j | |
| * @return {undefined} | |
| */ | |
| var Tk = function(___j) { | |
| He(this, ___j, -1, Sk); | |
| }; | |
| x(Tk, De); | |
| /** @type {!Array} */ | |
| var Sk = [26, 80]; | |
| /** | |
| * @return {?} | |
| */ | |
| Tk.prototype.$e = function() { | |
| return Ie(this, 1); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Uk = function() { | |
| /** @type {number} */ | |
| this.h = 0; | |
| /** @type {string} */ | |
| this.G = this.o = this.g = this.c = this.w = ""; | |
| /** @type {number} */ | |
| this.m = this.b = this.C = 0; | |
| fk.N(); | |
| /** @type {null} */ | |
| this.a = null; | |
| }; | |
| var Vk = { | |
| bh : 27, | |
| btn : 1, | |
| clks : 2, | |
| clkt : 3, | |
| pb : 4, | |
| sel : 5, | |
| selalt : 6, | |
| tws_confirm : 7, | |
| tws_lsugg : 8, | |
| tws_revert : 9, | |
| tws_spell : 10, | |
| is : 11 | |
| }; | |
| Ia(Uk); | |
| /** | |
| * @return {?} | |
| */ | |
| var Wk = function() { | |
| var MSG = DATA.DisplayLanguage; | |
| var content_panes = Uk.N(); | |
| /** @type {number} */ | |
| content_panes.h = 2; | |
| content_panes.w = MSG; | |
| return content_panes; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {?} | |
| */ | |
| var Xk = function(a) { | |
| /** @type {number} */ | |
| var b = 0; | |
| if (0 <= a.indexOf("-k0-")) { | |
| /** @type {number} */ | |
| b = 2; | |
| } else { | |
| if (kk(a)) { | |
| /** @type {number} */ | |
| b = 1; | |
| } else { | |
| if (jk(a)) { | |
| /** @type {number} */ | |
| b = 5; | |
| } | |
| } | |
| } | |
| return b; | |
| }; | |
| /** | |
| * @param {?} connection | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| var Yk = function(connection, name) { | |
| if (r(name)) { | |
| name = Vk[name]; | |
| name = null != name ? name : 0; | |
| } | |
| /** @type {!Object} */ | |
| connection.C = name; | |
| }; | |
| /** | |
| * @param {!Object} n | |
| * @return {undefined} | |
| */ | |
| Uk.prototype.store = function(n) { | |
| D(n, 65, this.h); | |
| D(n, 16, this.c); | |
| D(n, 14, this.o); | |
| D(n, 1, this.g); | |
| D(n, 50, this.w); | |
| D(n, 52, this.G); | |
| D(n, 32, this.b); | |
| }; | |
| /** | |
| * @param {!Array} a | |
| * @param {number} i | |
| * @return {?} | |
| */ | |
| var $k = function(a, i) { | |
| var node = a[i - 1]; | |
| if (null == node || Zk(node)) { | |
| a = a[a.length - 1]; | |
| if (Zk(a)) { | |
| node = a[i]; | |
| } | |
| } | |
| return node; | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @return {?} | |
| */ | |
| var Zk = function(o) { | |
| return Na(o) && !La(o); | |
| }; | |
| /** | |
| * @param {!NodeList} props | |
| * @param {number} src | |
| * @return {?} | |
| */ | |
| var al = function(props, src) { | |
| if (!props[src]) { | |
| /** @type {!Array} */ | |
| props[src] = []; | |
| } | |
| return props[src]; | |
| }; | |
| /** | |
| * @param {!Array} key | |
| * @param {!Array} val | |
| * @return {?} | |
| */ | |
| var cl = function(key, val) { | |
| return key === val ? true : pb(key, function(s, d) { | |
| if (Zk(s)) { | |
| d = db(s); | |
| var i; | |
| for (i in d) { | |
| s = d[i]; | |
| var f = $k(val, +i); | |
| if (!bl(s, f)) { | |
| return false; | |
| } | |
| } | |
| return true; | |
| } | |
| i = $k(val, d + 1); | |
| return bl(s, i); | |
| }) && pb(val, function(query, canCreateDiscussions) { | |
| if (Zk(query)) { | |
| query = db(query); | |
| var q; | |
| for (q in query) { | |
| if (null == $k(key, +q)) { | |
| return false; | |
| } | |
| } | |
| return true; | |
| } | |
| return null == query == (null == $k(key, canCreateDiscussions + 1)); | |
| }); | |
| }; | |
| /** | |
| * @param {number} b | |
| * @param {number} c | |
| * @return {?} | |
| */ | |
| var bl = function(b, c) { | |
| return b === c || null == b && null == c || !(true !== b && 1 !== b || true !== c && 1 !== c) || !(false !== b && 0 !== b || false !== c && 0 !== c) ? true : Ka(b) && Ka(c) ? cl(eb(b), eb(c)) : false; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var dl = function() { | |
| }; | |
| /** | |
| * @param {!Array} options | |
| * @param {!Array} value | |
| * @param {number} i | |
| * @return {undefined} | |
| */ | |
| var el = function(options, value, i) { | |
| options = options.$a = value = value || []; | |
| if (options.length) { | |
| /** @type {number} */ | |
| var j = options.length - 1; | |
| value = options[j]; | |
| if (Zk(value) && (delete options[j], j < i)) { | |
| /** @type {number} */ | |
| j = 0; | |
| var prop; | |
| for (prop in value) { | |
| /** @type {number} */ | |
| var index = +prop; | |
| if (index <= i) { | |
| options[index - 1] = value[prop]; | |
| delete value[prop]; | |
| } else { | |
| j++; | |
| } | |
| } | |
| if (j) { | |
| /** @type {!Array} */ | |
| options[i] = value; | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {number} n | |
| * @return {?} | |
| */ | |
| var dh = function(a, n) { | |
| return null != a.$a[n]; | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @param {number} n | |
| * @param {number} array | |
| * @return {?} | |
| */ | |
| var fl = function(data, n, array) { | |
| data = data.$a[n]; | |
| return null != data ? data : array; | |
| }; | |
| /** | |
| * @param {!Object} v | |
| * @param {number} r | |
| * @return {?} | |
| */ | |
| var gl = function(v, r) { | |
| return !!fl(v, r, void 0); | |
| }; | |
| /** | |
| * @param {?} number | |
| * @param {number} date | |
| * @return {?} | |
| */ | |
| var hh = function(number, date) { | |
| return fl(number, date, 0); | |
| }; | |
| /** | |
| * @param {!Object} v | |
| * @param {number} c | |
| * @param {string} b | |
| * @return {?} | |
| */ | |
| var K = function(v, c, b) { | |
| return fl(v, c, b || ""); | |
| }; | |
| /** | |
| * @param {string} str | |
| * @param {number} c | |
| * @param {number} event | |
| * @return {?} | |
| */ | |
| var fh = function(str, c, event) { | |
| return al(str.$a, c)[event]; | |
| }; | |
| /** | |
| * @param {!Object} callback | |
| * @param {number} id | |
| * @param {!Function} input | |
| * @return {?} | |
| */ | |
| var hl = function(callback, id, input) { | |
| return al(callback.$a, id)[input]; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {number} b | |
| * @param {!Function} Set | |
| * @return {?} | |
| */ | |
| var il = function(a, b, Set) { | |
| /** @type {!Array} */ | |
| var courses = []; | |
| /** @type {number} */ | |
| var x = 0; | |
| for (; x < J(a, b); x++) { | |
| courses.push(new Set(hl(a, b, x))); | |
| } | |
| return courses; | |
| }; | |
| /** | |
| * @param {!Object} p | |
| * @param {number} n | |
| * @return {?} | |
| */ | |
| var J = function(p, n) { | |
| return p.$a[n] ? p.$a[n].length : 0; | |
| }; | |
| /** | |
| * @param {!Object} root | |
| * @return {?} | |
| */ | |
| dl.prototype.Oc = function(root) { | |
| root = root && ib(root, dl); | |
| return !!root && cl(this.$a, root.$a); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| dl.prototype.Jb = function() { | |
| return this.$a; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {?} | |
| */ | |
| var jl = function(a) { | |
| var transaction = a.a(); | |
| a = a.$a; | |
| var sa = {}; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < a.length; i++) { | |
| if (void 0 !== a[i] && null !== a[i]) { | |
| /** @type {boolean} */ | |
| var s = false; | |
| var k = void 0; | |
| var e = void 0; | |
| var key; | |
| for (key in transaction) { | |
| if (e = transaction[key], k = key, e.H == i) { | |
| /** @type {boolean} */ | |
| s = true; | |
| break; | |
| } | |
| } | |
| if (s) { | |
| if (e = z(e), e.xa) { | |
| if (e.J) { | |
| /** @type {!Array} */ | |
| sa[k] = []; | |
| /** @type {number} */ | |
| s = 0; | |
| for (; s < a[i].length; s++) { | |
| sa[k].push(e.xa(a[i][s])); | |
| } | |
| } else { | |
| sa[k] = e.xa(a[i]); | |
| } | |
| } else { | |
| sa[k] = a[i]; | |
| } | |
| } | |
| } | |
| } | |
| return sa; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| dl.prototype.toString = function() { | |
| return JSON.stringify(jl(this)); | |
| }; | |
| /** | |
| * @param {!Function} key | |
| * @param {!Array} message | |
| * @return {?} | |
| */ | |
| var kl = function(key, message) { | |
| /** @type {!Array} */ | |
| var time = []; | |
| key = new key(time); | |
| var values = ib(key, dl).a(); | |
| var i; | |
| for (i in message) { | |
| var f = z(values[i]); | |
| var keys = message[i]; | |
| if (f.ya) { | |
| if (keys instanceof Array) { | |
| /** @type {!Array} */ | |
| var processed = []; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < keys.length; i++) { | |
| processed.push(f.ya(keys[i]).Jb()); | |
| } | |
| } else { | |
| processed = f.ya(keys).Jb(); | |
| } | |
| } else { | |
| processed = keys; | |
| } | |
| time[f.H] = processed; | |
| } | |
| return key; | |
| }; | |
| /** | |
| * @param {!Array} key | |
| * @return {undefined} | |
| */ | |
| var ll = function(key) { | |
| el(this, key, 1); | |
| }; | |
| x(ll, dl); | |
| var ml = { | |
| romanization : { | |
| H : 0, | |
| J : false | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| ll.prototype.a = function() { | |
| return ml; | |
| }; | |
| /** | |
| * @param {!Array} count | |
| * @return {undefined} | |
| */ | |
| var nl = function(count) { | |
| el(this, count, 3); | |
| }; | |
| x(nl, dl); | |
| var ol = { | |
| source_span_index : { | |
| H : 0, | |
| J : false | |
| }, | |
| target_span_index : { | |
| H : 1, | |
| J : false | |
| }, | |
| direction : { | |
| H : 2, | |
| J : false | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| nl.prototype.a = function() { | |
| return ol; | |
| }; | |
| /** | |
| * @param {!Array} c | |
| * @return {undefined} | |
| */ | |
| var pl = function(c) { | |
| el(this, c, 2); | |
| }; | |
| x(pl, dl); | |
| var ql = { | |
| begin : { | |
| H : 0, | |
| J : false | |
| }, | |
| end : { | |
| H : 1, | |
| J : false | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| pl.prototype.a = function() { | |
| return ql; | |
| }; | |
| /** | |
| * @param {!Array} props | |
| * @return {undefined} | |
| */ | |
| var rl = function(props) { | |
| el(this, props, 3); | |
| }; | |
| x(rl, dl); | |
| var sl = { | |
| source_span : { | |
| H : 0, | |
| ya : function(obj) { | |
| return kl(pl, obj); | |
| }, | |
| xa : function(a) { | |
| return jl(new pl(a)); | |
| }, | |
| J : true | |
| }, | |
| target_span : { | |
| H : 1, | |
| ya : function(obj) { | |
| return kl(pl, obj); | |
| }, | |
| xa : function(a) { | |
| return jl(new pl(a)); | |
| }, | |
| J : true | |
| }, | |
| link : { | |
| H : 2, | |
| ya : function(obj) { | |
| return kl(nl, obj); | |
| }, | |
| xa : function(a) { | |
| return jl(new nl(a)); | |
| }, | |
| J : true | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| rl.prototype.a = function() { | |
| return sl; | |
| }; | |
| /** | |
| * @param {!Array} fn | |
| * @return {undefined} | |
| */ | |
| var tl = function(fn) { | |
| el(this, fn, 2); | |
| }; | |
| x(tl, dl); | |
| var ul = { | |
| model_path : { | |
| H : 0, | |
| J : false | |
| }, | |
| label : { | |
| H : 1, | |
| J : false | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| tl.prototype.a = function() { | |
| return ul; | |
| }; | |
| /** | |
| * @param {!Array} node | |
| * @return {undefined} | |
| */ | |
| var vl = function(node) { | |
| el(this, node, 2); | |
| }; | |
| x(vl, dl); | |
| var wl = { | |
| checkpoint_md5 : { | |
| H : 0, | |
| J : false | |
| }, | |
| launch_doc : { | |
| H : 1, | |
| J : false | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| vl.prototype.a = function() { | |
| return wl; | |
| }; | |
| /** | |
| * @param {!Array} fn | |
| * @return {undefined} | |
| */ | |
| var xl = function(fn) { | |
| el(this, fn, 1); | |
| }; | |
| x(xl, dl); | |
| var yl = { | |
| model_tracking : { | |
| H : 0, | |
| ya : function(obj) { | |
| return kl(vl, obj); | |
| }, | |
| xa : function(a) { | |
| return jl(new vl(a)); | |
| }, | |
| J : false | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| xl.prototype.a = function() { | |
| return yl; | |
| }; | |
| /** | |
| * @param {!Array} fn | |
| * @return {undefined} | |
| */ | |
| var zl = function(fn) { | |
| el(this, fn, 9); | |
| }; | |
| x(zl, dl); | |
| var Al = { | |
| trans : { | |
| H : 0, | |
| J : false | |
| }, | |
| orig : { | |
| H : 1, | |
| J : false | |
| }, | |
| translit : { | |
| H : 2, | |
| J : false | |
| }, | |
| src_translit : { | |
| H : 3, | |
| J : false | |
| }, | |
| backend : { | |
| H : 4, | |
| J : false | |
| }, | |
| model : { | |
| H : 5, | |
| J : true | |
| }, | |
| word_alignment : { | |
| H : 6, | |
| ya : function(obj) { | |
| return kl(rl, obj); | |
| }, | |
| xa : function(a) { | |
| return jl(new rl(a)); | |
| }, | |
| J : false | |
| }, | |
| model_specification : { | |
| H : 7, | |
| ya : function(obj) { | |
| return kl(tl, obj); | |
| }, | |
| xa : function(a) { | |
| return jl(new tl(a)); | |
| }, | |
| J : true | |
| }, | |
| translation_engine_debug_info : { | |
| H : 8, | |
| ya : function(obj) { | |
| return kl(xl, obj); | |
| }, | |
| xa : function(a) { | |
| return jl(new xl(a)); | |
| }, | |
| J : true | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| zl.prototype.a = function() { | |
| return Al; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| zl.prototype.dd = function() { | |
| return K(this, 0); | |
| }; | |
| /** | |
| * @param {!Array} fn | |
| * @return {undefined} | |
| */ | |
| var Bl = function(fn) { | |
| el(this, fn, 4); | |
| }; | |
| x(Bl, dl); | |
| var Cl = { | |
| gender : { | |
| H : 0, | |
| J : false | |
| }, | |
| translation : { | |
| H : 1, | |
| J : false | |
| }, | |
| sentences : { | |
| H : 2, | |
| ya : function(obj) { | |
| return kl(zl, obj); | |
| }, | |
| xa : function(a) { | |
| return jl(new zl(a)); | |
| }, | |
| J : true | |
| }, | |
| romanization : { | |
| H : 3, | |
| ya : function(obj) { | |
| return kl(ll, obj); | |
| }, | |
| xa : function(a) { | |
| return jl(new ll(a)); | |
| }, | |
| J : false | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Bl.prototype.a = function() { | |
| return Cl; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Bl.prototype.Cb = function() { | |
| return K(this, 1); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Bl.prototype.sc = function() { | |
| return J(this, 2); | |
| }; | |
| /** | |
| * @param {number} id | |
| * @return {?} | |
| */ | |
| Bl.prototype.hb = function(id) { | |
| return new zl(hl(this, 2, id)); | |
| }; | |
| /** | |
| * @param {!Array} fn | |
| * @return {undefined} | |
| */ | |
| var Dl = function(fn) { | |
| el(this, fn, 2); | |
| }; | |
| x(Dl, dl); | |
| var El = { | |
| gendered_translations : { | |
| H : 0, | |
| ya : function(obj) { | |
| return kl(Bl, obj); | |
| }, | |
| xa : function(a) { | |
| return jl(new Bl(a)); | |
| }, | |
| J : true | |
| }, | |
| status : { | |
| H : 1, | |
| J : false | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Dl.prototype.a = function() { | |
| return El; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Dl.prototype.cd = function() { | |
| return fl(this, 1, 0); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var M = function() { | |
| /** @type {null} */ | |
| this.b = null; | |
| this.a = Uk.N(); | |
| }; | |
| x(M, hg); | |
| Ia(M); | |
| /** | |
| * @param {!Object} c | |
| * @return {undefined} | |
| */ | |
| var Fl = function(c) { | |
| var b = oj() || "0"; | |
| c.b = new ek(b, EXPERIMENT_IDS); | |
| jg(c, c.b); | |
| }; | |
| /** | |
| * @param {!Object} val | |
| * @param {!Array} msg | |
| * @param {!Object} ver | |
| * @param {number} c | |
| * @param {!Array} n | |
| * @return {undefined} | |
| */ | |
| var Il = function(val, msg, ver, c, n) { | |
| msg = Gl(val, 237, msg, void 0, void 0, void 0, n); | |
| if (null != ver) { | |
| n = new qk; | |
| var src_a = val.a.a; | |
| if (null != src_a) { | |
| D(n, 1, src_a || []); | |
| } | |
| D(n, 2, Hl(ver)); | |
| Le(msg, 83, n); | |
| } | |
| if (q(c) && 0 != c) { | |
| D(msg, 74, c); | |
| } | |
| N(val, msg); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {number} f | |
| * @param {?} m | |
| * @return {undefined} | |
| */ | |
| var Jl = function(a, f, m) { | |
| N(a, Gl(a, 190, f, m, true, 0)); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {number} f | |
| * @param {number} err | |
| * @param {boolean} r | |
| * @return {undefined} | |
| */ | |
| var Kl = function(a, f, err, r) { | |
| N(a, Gl(a, 78, f, err, r, 0)); | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @param {!Object} rev | |
| * @return {undefined} | |
| */ | |
| var Ll = function(b, rev) { | |
| var a = O(b, 21); | |
| var delim = new Ik; | |
| D(delim, 1, 3); | |
| Le(a, 56, delim); | |
| if (null != rev) { | |
| delim = new qk; | |
| var src_a = b.a.a; | |
| if (null != src_a) { | |
| D(delim, 1, src_a || []); | |
| } | |
| D(delim, 2, Hl(rev)); | |
| Le(a, 83, delim); | |
| } | |
| N(b, a); | |
| }; | |
| var Ml = {}; | |
| var Nl = (Ml.st = 231, Ml.unst = 232, Ml.sw = 229, Ml.lnk = 230, Ml); | |
| /** | |
| * @param {!Object} array | |
| * @param {number} len | |
| * @param {?} c | |
| * @return {undefined} | |
| */ | |
| var Ol = function(array, len, c) { | |
| var a = O(array, 148); | |
| var delim = new nk; | |
| D(delim, 1, len); | |
| if (c) { | |
| D(delim, 5, c); | |
| } | |
| Le(a, 63, delim); | |
| N(array, a); | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @param {number} id | |
| * @return {undefined} | |
| */ | |
| var Pl = function(obj, id) { | |
| id = O(obj, id); | |
| var delim = new zk; | |
| D(delim, 1, 1); | |
| Le(id, 46, delim); | |
| N(obj, id); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {boolean} def | |
| * @param {number} c | |
| * @param {!Array} err | |
| * @param {number} source | |
| * @param {string} URL | |
| * @return {undefined} | |
| */ | |
| var Ql = function(a, def, c, err, source, URL) { | |
| def = O(a, def ? 84 : 85); | |
| var delim = new zk; | |
| D(delim, 1, 1); | |
| D(delim, 2, c); | |
| D(delim, 3, err); | |
| D(delim, 4, source + 1); | |
| if (0 < URL.length) { | |
| D(delim, 5, URL); | |
| } | |
| Le(def, 46, delim); | |
| N(a, def); | |
| }; | |
| /** | |
| * @param {undefined} T | |
| * @param {?} p | |
| * @param {number} val | |
| * @return {undefined} | |
| */ | |
| var Sl = function(T, p, val) { | |
| N(T, Rl(T, 251, p, val)); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {number} fn | |
| * @return {undefined} | |
| */ | |
| var Ul = function(a, fn) { | |
| N(a, Tl(a, 71, fn)); | |
| }; | |
| /** | |
| * @param {!Object} maxRadius | |
| * @param {number} num | |
| * @return {undefined} | |
| */ | |
| var Vl = function(maxRadius, num) { | |
| N(maxRadius, Tl(maxRadius, 72, num)); | |
| }; | |
| /** | |
| * @param {!Object} array | |
| * @param {?} len | |
| * @return {undefined} | |
| */ | |
| var Wl = function(array, len) { | |
| var a = O(array, 244); | |
| D(a, 74, len); | |
| N(array, a); | |
| }; | |
| /** | |
| * @param {undefined} prop | |
| * @param {?} link | |
| * @return {undefined} | |
| */ | |
| var Yl = function(prop, link) { | |
| N(prop, Xl(prop, 245, link)); | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @return {undefined} | |
| */ | |
| var Zl = function(b) { | |
| N(b, O(b, 223)); | |
| }; | |
| /** | |
| * @param {!Object} c | |
| * @return {undefined} | |
| */ | |
| var $l = function(c) { | |
| var b = M.N(); | |
| var a = O(b, 22); | |
| var delim = new Ik; | |
| D(delim, 1, 3); | |
| D(delim, 2, c); | |
| Le(a, 56, delim); | |
| N(b, a); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| M.prototype.c = function() { | |
| N(this, O(this, 145)); | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @param {number} v | |
| * @param {!Array} V | |
| * @param {?} URL | |
| * @param {?} filename | |
| * @param {!Array} len | |
| * @param {number} s | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var am = function(obj, v, V, URL, filename, len, s, a) { | |
| v = O(obj, v); | |
| var delim = new Kk; | |
| D(delim, 1, V); | |
| D(delim, 4, 1); | |
| D(delim, 7, URL); | |
| D(delim, 5, filename); | |
| if (len) { | |
| D(delim, 8, len); | |
| } | |
| if (q(s)) { | |
| D(delim, 6, s + 1); | |
| } | |
| Le(v, 43, delim); | |
| if (null != a) { | |
| V = new qk; | |
| D(V, 2, Hl(a)); | |
| a = obj.a.a; | |
| if (null != a) { | |
| D(V, 1, a || []); | |
| } | |
| Le(v, 83, V); | |
| } | |
| N(obj, v); | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @return {undefined} | |
| */ | |
| var bm = function(b) { | |
| var a = O(b, 1); | |
| D(a, 53, b.a.C); | |
| N(b, a); | |
| Yk(b.a, 0); | |
| }; | |
| /** | |
| * @param {!Object} array | |
| * @param {number} value | |
| * @param {number} term | |
| * @param {?} URL | |
| * @return {undefined} | |
| */ | |
| var cm = function(array, value, term, URL) { | |
| value = O(array, value); | |
| var delim = new Lk; | |
| D(delim, 1, term); | |
| D(delim, 2, URL); | |
| Le(value, 75, delim); | |
| N(array, value); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| M.prototype.g = function() { | |
| N(this, O(this, 25)); | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @param {string} m | |
| * @return {undefined} | |
| */ | |
| var dm = function(b, m) { | |
| var a = O(b, 339); | |
| var d = new qk; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < m.length; i++) { | |
| var f = Hl(fl(m[i], 0, 0)); | |
| Ie(d, 1).push(f); | |
| } | |
| m = Ie(d, 1); | |
| /** @type {string} */ | |
| b.a.a = m; | |
| Le(a, 83, d); | |
| N(b, a); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {number} s | |
| * @return {?} | |
| */ | |
| var O = function(a, s) { | |
| var t = new Tk; | |
| a.a.store(t); | |
| D(t, 31, s); | |
| return t; | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @param {number} id | |
| * @param {number} c | |
| * @param {?} d | |
| * @param {boolean} v | |
| * @param {number} V | |
| * @param {number} key | |
| * @return {?} | |
| */ | |
| var Gl = function(obj, id, c, d, v, V, key) { | |
| var delim = new lk; | |
| D(delim, 1, c); | |
| if (q(d)) { | |
| D(delim, 4, d); | |
| } | |
| if (q(v)) { | |
| D(delim, 2, v); | |
| } | |
| if (q(V) && 0 != V) { | |
| D(delim, 3, V); | |
| } | |
| if (q(key) && 0 != key) { | |
| D(delim, 5, key); | |
| } | |
| obj = O(obj, id); | |
| Le(obj, 61, delim); | |
| return obj; | |
| }; | |
| /** | |
| * @param {string} s | |
| * @param {number} id | |
| * @param {number} text | |
| * @param {boolean} length | |
| * @return {?} | |
| */ | |
| var em = function(s, id, text, length) { | |
| var delim = new rk; | |
| D(delim, 1, text + 1); | |
| D(delim, 2, length); | |
| s = O(s, id); | |
| Le(s, 60, delim); | |
| return s; | |
| }; | |
| /** | |
| * @param {string} o | |
| * @param {number} id | |
| * @param {number} msg | |
| * @param {string} i | |
| * @param {!Array} res | |
| * @param {!Array} args | |
| * @param {boolean} req | |
| * @param {number} options | |
| * @return {?} | |
| */ | |
| var fm = function(o, id, msg, i, res, args, req, options) { | |
| var code = new yk; | |
| /** @type {!Array} */ | |
| var e = []; | |
| /** @type {number} */ | |
| var pos = 0; | |
| for (; pos < msg.length; pos++) { | |
| var details = msg[pos]; | |
| var h = new sk; | |
| D(h, 1, details[0]); | |
| D(h, 2, !!details[1]); | |
| e.push(h); | |
| } | |
| Me(code, 1, e); | |
| msg = new wk; | |
| D(msg, 1, !!i); | |
| Le(code, 2, msg); | |
| /** @type {!Array} */ | |
| i = []; | |
| /** @type {number} */ | |
| msg = 0; | |
| for (; msg < res.length; msg++) { | |
| e = new vk; | |
| D(e, 1, res[msg]); | |
| i.push(e); | |
| } | |
| Me(code, 3, i); | |
| /** @type {!Array} */ | |
| res = []; | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < args.length; i++) { | |
| msg = args[i]; | |
| e = new tk; | |
| D(e, 1, !!msg[0]); | |
| D(e, 2, !!msg[1]); | |
| res.push(e); | |
| } | |
| Me(code, 4, res); | |
| if (req) { | |
| args = new uk; | |
| D(args, 1, true); | |
| Le(code, 5, args); | |
| } | |
| if (0 != options) { | |
| D(code, 6, options); | |
| } | |
| o = O(o, id); | |
| Le(o, 66, code); | |
| return o; | |
| }; | |
| /** | |
| * @param {string} c | |
| * @param {number} id | |
| * @return {?} | |
| */ | |
| var gm = function(c, id) { | |
| c = O(c, id); | |
| id = new Ek; | |
| D(id, 1, []); | |
| D(id, 4, 1); | |
| Le(c, 59, id); | |
| return c; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {number} n | |
| * @param {?} arr | |
| * @param {?} err | |
| * @return {?} | |
| */ | |
| var Rl = function(a, n, arr, err) { | |
| var delim = new Bk; | |
| D(delim, 1, err); | |
| a = O(a, n); | |
| D(a, 74, arr); | |
| Le(a, 71, delim); | |
| return a; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {number} fn | |
| * @param {number} value | |
| * @return {?} | |
| */ | |
| var Tl = function(a, fn, value) { | |
| var delim = new Fk; | |
| D(delim, 1, value); | |
| a = O(a, fn); | |
| Le(a, 44, delim); | |
| return a; | |
| }; | |
| /** | |
| * @param {string} c | |
| * @param {number} id | |
| * @param {?} URL | |
| * @return {?} | |
| */ | |
| var Xl = function(c, id, URL) { | |
| c = O(c, id); | |
| id = new Ek; | |
| D(id, 5, URL); | |
| if (q(void 0)) { | |
| D(id, 6, void 0); | |
| } | |
| Le(c, 59, id); | |
| return c; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {?} c | |
| * @return {undefined} | |
| */ | |
| var N = function(a, c) { | |
| if (a.b) { | |
| var X = new Oj; | |
| c = c.vd(); | |
| D(X, 8, c); | |
| a.b.log(X); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} num | |
| * @return {?} | |
| */ | |
| var Hl = function(num) { | |
| switch(num) { | |
| case 2: | |
| return 1; | |
| case 1: | |
| return 2; | |
| default: | |
| return 0; | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var hm = function() { | |
| /** @type {!Array} */ | |
| this.g = []; | |
| this.b = {}; | |
| this.a = {}; | |
| /** @type {boolean} */ | |
| this.h = false; | |
| /** @type {number} */ | |
| this.Oh = 1; | |
| this.Qe = {}; | |
| /** @type {null} */ | |
| this.c = null; | |
| /** @type {string} */ | |
| this.o = ""; | |
| I(window, "beforeunload", this.G, false, this); | |
| }; | |
| Ia(hm); | |
| /** | |
| * @param {string} path | |
| * @param {string} value | |
| * @param {string} options | |
| * @return {?} | |
| */ | |
| var im = function(path, value, options) { | |
| if (null == value) { | |
| return "1"; | |
| } | |
| switch(Ja(value)) { | |
| case "string": | |
| return path = value, !(64 < path.length) || null != options && options || (path = path.substr(0, 64)), de(path); | |
| case "number": | |
| return "" + value; | |
| case "boolean": | |
| return value ? "1" : "0"; | |
| case "array": | |
| /** @type {!Array} */ | |
| var arr = []; | |
| var name; | |
| for (name in value) { | |
| arr.push(im(path, value[name], options)); | |
| } | |
| return arr.join(","); | |
| case "object": | |
| /** @type {!Array} */ | |
| arr = []; | |
| for (name in value) { | |
| arr.push(jm(path, name, value[name], options)); | |
| } | |
| return arr.join(","); | |
| default: | |
| return ""; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} file | |
| * @param {string} c | |
| * @param {string} d | |
| * @param {string} options | |
| * @return {?} | |
| */ | |
| var jm = function(file, c, d, options) { | |
| return [de(c), im(file, d, options || "smtalt" == c)].join("="); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @param {string} num | |
| * @return {undefined} | |
| */ | |
| hm.prototype.log = function(name, num) { | |
| this.g.push([name, num]); | |
| if (!this.h) { | |
| /** @type {boolean} */ | |
| this.h = true; | |
| ci(this.m, 0, this); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} d | |
| * @param {string} x | |
| * @param {string} obj | |
| * @param {string} name | |
| * @param {!Object} value | |
| * @return {undefined} | |
| */ | |
| var mm = function(d, x, obj, name, value) { | |
| /** @type {string} */ | |
| x = d.o + "/gen204?" + jm(d, obj, name) + "&" + jm(d, "client", x, true); | |
| if (value) { | |
| /** @type {string} */ | |
| x = x + km(d, value); | |
| } | |
| lm(d, x); | |
| }; | |
| /** | |
| * @param {!Object} m | |
| * @param {(Object|string)} s | |
| * @return {?} | |
| */ | |
| var km = function(m, s) { | |
| /** @type {string} */ | |
| var pix_color = ""; | |
| if (q(s)) { | |
| Mb(s, function(d, apexdist) { | |
| if (d instanceof Array) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < d.length; i++) { | |
| /** @type {string} */ | |
| pix_color = pix_color + ("&" + jm(this, apexdist, d[i])); | |
| } | |
| } else { | |
| pix_color = pix_color + ("&" + jm(this, apexdist, d)); | |
| } | |
| }, m); | |
| } | |
| return pix_color; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| hm.prototype.m = function() { | |
| /** @type {number} */ | |
| var key = 0; | |
| for (; key < this.g.length; key++) { | |
| var keySave = this.g[key]; | |
| nm(this, keySave[0], keySave[1]); | |
| } | |
| /** @type {!Array} */ | |
| this.g = []; | |
| /** @type {boolean} */ | |
| this.h = false; | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @param {string} prefix | |
| * @param {string} ast | |
| * @return {undefined} | |
| */ | |
| var nm = function(item, prefix, ast) { | |
| lm(item, item.o + "/gen204?" + (item.c ? ["client=", item.c, "&"].join("") : "") + jm(item, prefix, ast)); | |
| }; | |
| /** | |
| * @param {!Object} method | |
| * @param {string} b | |
| * @return {undefined} | |
| */ | |
| var lm = function(method, b) { | |
| /** @type {!Image} */ | |
| var d = new Image; | |
| /** @type {number} */ | |
| var a = method.Oh++; | |
| /** @type {!Image} */ | |
| method.Qe[a] = d; | |
| /** @type {function(): undefined} */ | |
| d.onload = d.onerror = function() { | |
| delete hm.N().Qe[a]; | |
| }; | |
| /** @type {string} */ | |
| d.src = b; | |
| /** @type {null} */ | |
| d = null; | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @param {string} key | |
| * @param {?} data | |
| * @param {string} callback | |
| * @return {undefined} | |
| */ | |
| var pm = function(options, key, data, callback) { | |
| /** @type {null} */ | |
| var special = null; | |
| if (key in options.b) { | |
| special = options.b[key]; | |
| } | |
| options.b[key] = om(special, data, callback); | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| var qm = function(value, name) { | |
| /** @type {number} */ | |
| var e = 0; | |
| /** @type {null} */ | |
| var result = null; | |
| if (name in value.a) { | |
| result = value.a[name]; | |
| e = result[0]; | |
| result = result[1]; | |
| } | |
| result = om(result, 1, "accumulate"); | |
| /** @type {!Array} */ | |
| value.a[name] = [e, result]; | |
| di(value.a[name][0]); | |
| e = ci(v(value.w, value, name), 2E3); | |
| value.a[name][0] = e; | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| hm.prototype.w = function(name) { | |
| nm(this, name, this.a[name][1]); | |
| if (name in this.a) { | |
| di(this.a[name][0]); | |
| delete this.a[name]; | |
| } | |
| }; | |
| /** | |
| * @param {number} str | |
| * @param {number} res | |
| * @param {string} callback | |
| * @return {?} | |
| */ | |
| var rm = function(str, res, callback) { | |
| if (!(null != res)) { | |
| /** @type {number} */ | |
| res = 1; | |
| } | |
| if ("accumulate" == callback) { | |
| if (isNaN(str)) { | |
| /** @type {number} */ | |
| str = parseInt(str, 10); | |
| } | |
| if (isNaN(res)) { | |
| /** @type {number} */ | |
| res = parseInt(res, 10); | |
| } | |
| str = str + res; | |
| } else { | |
| /** @type {number} */ | |
| str = res; | |
| } | |
| return str; | |
| }; | |
| /** | |
| * @param {!Array} target | |
| * @param {?} data | |
| * @param {string} callback | |
| * @return {?} | |
| */ | |
| var om = function(target, data, callback) { | |
| if ("object" == Ja(data)) { | |
| if ("object" != Ja(target)) { | |
| target = {}; | |
| } | |
| var key; | |
| for (key in data) { | |
| target[key] = rm(key in target ? target[key] : null, data[key], callback); | |
| } | |
| } else { | |
| target = rm(target, data, callback); | |
| } | |
| return target; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var sm = function(a) { | |
| /** @type {!Array} */ | |
| var ret = []; | |
| var f; | |
| for (f in a.b) { | |
| ret.push(jm(a, f, a.b[f])); | |
| } | |
| a.b = {}; | |
| return ret.join("&"); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| hm.prototype.G = function() { | |
| this.m(); | |
| var b; | |
| for (b in this.a) { | |
| if (0 != this.a[b]) { | |
| this.w(b); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @param {undefined} key | |
| * @return {undefined} | |
| */ | |
| var tm = function(data, key) { | |
| /** @type {string} */ | |
| this.b = this.m = this.c = ""; | |
| /** @type {null} */ | |
| this.w = null; | |
| /** @type {string} */ | |
| this.g = this.h = ""; | |
| /** @type {boolean} */ | |
| this.o = false; | |
| var str; | |
| if (data instanceof tm) { | |
| this.o = q(key) ? key : data.o; | |
| um(this, data.c); | |
| this.m = data.m; | |
| this.b = data.b; | |
| vm(this, data.w); | |
| wm(this, data.h); | |
| xm(this, ym(data.a)); | |
| this.g = data.g; | |
| } else { | |
| if (data && (str = String(data).match(ej))) { | |
| /** @type {boolean} */ | |
| this.o = !!key; | |
| um(this, str[1] || "", true); | |
| this.m = zm(str[2] || ""); | |
| this.b = zm(str[3] || "", true); | |
| vm(this, str[4]); | |
| wm(this, str[5] || "", true); | |
| xm(this, str[6] || "", true); | |
| this.g = zm(str[7] || ""); | |
| } else { | |
| /** @type {boolean} */ | |
| this.o = !!key; | |
| this.a = new Am(null, this.o); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| tm.prototype.toString = function() { | |
| /** @type {!Array} */ | |
| var log = []; | |
| var settings = this.c; | |
| if (settings) { | |
| log.push(Bm(settings, Cm, true), ":"); | |
| } | |
| var body = this.b; | |
| if (body || "file" == settings) { | |
| log.push("//"); | |
| if (settings = this.m) { | |
| log.push(Bm(settings, Cm, true), "@"); | |
| } | |
| log.push(de(body).replace(/%25([0-9a-fA-F]{2})/g, "%$1")); | |
| body = this.w; | |
| if (null != body) { | |
| log.push(":", String(body)); | |
| } | |
| } | |
| if (body = this.h) { | |
| if (this.b && "/" != body.charAt(0)) { | |
| log.push("/"); | |
| } | |
| log.push(Bm(body, "/" == body.charAt(0) ? Dm : Em, true)); | |
| } | |
| if (body = this.a.toString()) { | |
| log.push("?", body); | |
| } | |
| if (body = this.g) { | |
| log.push("#", Bm(body, Fm)); | |
| } | |
| return log.join(""); | |
| }; | |
| /** | |
| * @param {!Object} arg | |
| * @return {?} | |
| */ | |
| tm.prototype.resolve = function(arg) { | |
| var target = new tm(this); | |
| /** @type {boolean} */ | |
| var D = !!arg.c; | |
| if (D) { | |
| um(target, arg.c); | |
| } else { | |
| /** @type {boolean} */ | |
| D = !!arg.m; | |
| } | |
| if (D) { | |
| target.m = arg.m; | |
| } else { | |
| /** @type {boolean} */ | |
| D = !!arg.b; | |
| } | |
| if (D) { | |
| target.b = arg.b; | |
| } else { | |
| /** @type {boolean} */ | |
| D = null != arg.w; | |
| } | |
| var h = arg.h; | |
| if (D) { | |
| vm(target, arg.w); | |
| } else { | |
| if (D = !!arg.h) { | |
| if ("/" != h.charAt(0)) { | |
| if (this.b && !this.h) { | |
| /** @type {string} */ | |
| h = "/" + h; | |
| } else { | |
| var b = target.h.lastIndexOf("/"); | |
| if (-1 != b) { | |
| h = target.h.substr(0, b + 1) + h; | |
| } | |
| } | |
| } | |
| b = h; | |
| if (".." == b || "." == b) { | |
| /** @type {string} */ | |
| h = ""; | |
| } else { | |
| if (Kc(b, "./") || Kc(b, "/.")) { | |
| h = vc(b, "/"); | |
| b = b.split("/"); | |
| /** @type {!Array} */ | |
| var path = []; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < b.length;) { | |
| var bc = b[i++]; | |
| if ("." == bc) { | |
| if (h && i == b.length) { | |
| path.push(""); | |
| } | |
| } else { | |
| if (".." == bc) { | |
| if (1 < path.length || 1 == path.length && "" != path[0]) { | |
| path.pop(); | |
| } | |
| if (h && i == b.length) { | |
| path.push(""); | |
| } | |
| } else { | |
| path.push(bc); | |
| /** @type {boolean} */ | |
| h = true; | |
| } | |
| } | |
| } | |
| /** @type {string} */ | |
| h = path.join("/"); | |
| } else { | |
| h = b; | |
| } | |
| } | |
| } | |
| } | |
| if (D) { | |
| wm(target, h); | |
| } else { | |
| /** @type {boolean} */ | |
| D = "" !== arg.a.toString(); | |
| } | |
| if (D) { | |
| xm(target, ym(arg.a)); | |
| } else { | |
| /** @type {boolean} */ | |
| D = !!arg.g; | |
| } | |
| if (D) { | |
| target.g = arg.g; | |
| } | |
| return target; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} b | |
| * @param {boolean} asc | |
| * @return {undefined} | |
| */ | |
| var um = function(a, b, asc) { | |
| a.c = asc ? zm(b, true) : b; | |
| if (a.c) { | |
| a.c = a.c.replace(/:$/, ""); | |
| } | |
| }; | |
| /** | |
| * @param {!Window} obj | |
| * @param {number} val | |
| * @return {undefined} | |
| */ | |
| var vm = function(obj, val) { | |
| if (val) { | |
| /** @type {number} */ | |
| val = Number(val); | |
| if (isNaN(val) || 0 > val) { | |
| throw Error("Bad port number " + val); | |
| } | |
| /** @type {number} */ | |
| obj.w = val; | |
| } else { | |
| /** @type {null} */ | |
| obj.w = null; | |
| } | |
| }; | |
| /** | |
| * @param {string} el | |
| * @param {string} name | |
| * @param {boolean} p | |
| * @return {undefined} | |
| */ | |
| var wm = function(el, name, p) { | |
| el.h = p ? zm(name, true) : name; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} b | |
| * @param {boolean} undefOnly | |
| * @return {undefined} | |
| */ | |
| var xm = function(a, b, undefOnly) { | |
| if (b instanceof Am) { | |
| /** @type {string} */ | |
| a.a = b; | |
| Gm(a.a, a.o); | |
| } else { | |
| if (!undefOnly) { | |
| b = Bm(b, Hm); | |
| } | |
| a.a = new Am(b, a.o); | |
| } | |
| }; | |
| /** | |
| * @param {string} obj | |
| * @param {string} num | |
| * @param {!Array} c | |
| * @return {undefined} | |
| */ | |
| var Jm = function(obj, num, c) { | |
| if (!Ka(c)) { | |
| /** @type {!Array} */ | |
| c = [String(c)]; | |
| } | |
| Im(obj.a, num, c); | |
| }; | |
| /** | |
| * @param {(number|string)} a | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| var Km = function(a, value) { | |
| return a.a.get(value); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var Lm = function(a) { | |
| return a instanceof tm ? new tm(a) : new tm(a, void 0); | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {string} b | |
| * @return {?} | |
| */ | |
| var zm = function(a, b) { | |
| return a ? b ? decodeURI(a.replace(/%25/g, "%2525")) : decodeURIComponent(a) : ""; | |
| }; | |
| /** | |
| * @param {string} n | |
| * @param {!RegExp} c | |
| * @param {boolean} processPercent | |
| * @return {?} | |
| */ | |
| var Bm = function(n, c, processPercent) { | |
| return r(n) ? (n = encodeURI(n).replace(c, Mm), processPercent && (n = n.replace(/%25([0-9a-fA-F]{2})/g, "%$1")), n) : null; | |
| }; | |
| /** | |
| * @param {(number|string)} n | |
| * @return {?} | |
| */ | |
| var Mm = function(n) { | |
| n = n.charCodeAt(0); | |
| return "%" + (n >> 4 & 15).toString(16) + (n & 15).toString(16); | |
| }; | |
| /** @type {!RegExp} */ | |
| var Cm = /[#\/\?@]/g; | |
| /** @type {!RegExp} */ | |
| var Em = /[#\?:]/g; | |
| /** @type {!RegExp} */ | |
| var Dm = /[#\?]/g; | |
| /** @type {!RegExp} */ | |
| var Hm = /[#\?@]/g; | |
| /** @type {!RegExp} */ | |
| var Fm = /#/g; | |
| /** | |
| * @param {string} c | |
| * @param {?} initlength | |
| * @return {undefined} | |
| */ | |
| var Am = function(c, initlength) { | |
| /** @type {null} */ | |
| this.b = this.a = null; | |
| this.c = c || null; | |
| /** @type {boolean} */ | |
| this.h = !!initlength; | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @return {undefined} | |
| */ | |
| var Nm = function(o) { | |
| if (!o.a) { | |
| o.a = new Yi; | |
| /** @type {number} */ | |
| o.b = 0; | |
| if (o.c) { | |
| fj(o.c, function(key, b) { | |
| o.add(ee(key), b); | |
| }); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Am.prototype.Lf = function() { | |
| Nm(this); | |
| return this.b; | |
| }; | |
| /** | |
| * @param {!Object} key | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| Am.prototype.add = function(key, value) { | |
| Nm(this); | |
| /** @type {null} */ | |
| this.c = null; | |
| key = Om(this, key); | |
| var values = this.a.get(key); | |
| if (!values) { | |
| this.a.set(key, values = []); | |
| } | |
| values.push(value); | |
| this.b = ab(this.b) + 1; | |
| return this; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Object} x | |
| * @return {undefined} | |
| */ | |
| var Pm = function(a, x) { | |
| Nm(a); | |
| x = Om(a, x); | |
| if (aj(a.a, x)) { | |
| /** @type {null} */ | |
| a.c = null; | |
| /** @type {number} */ | |
| a.b = ab(a.b) - a.a.get(x).length; | |
| a = a.a; | |
| if ($i(a.Va, x)) { | |
| delete a.Va[x]; | |
| a.b--; | |
| a.c++; | |
| if (a.a.length > 2 * a.b) { | |
| Zi(a); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| var Qm = function(o, value) { | |
| Nm(o); | |
| value = Om(o, value); | |
| return aj(o.a, value); | |
| }; | |
| k = Am.prototype; | |
| /** | |
| * @param {!Function} f | |
| * @param {!Object} o | |
| * @return {undefined} | |
| */ | |
| k.forEach = function(f, o) { | |
| Nm(this); | |
| this.a.forEach(function(y0, i) { | |
| A(y0, function(optionalInit) { | |
| f.call(o, optionalInit, i, this); | |
| }, this); | |
| }, this); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Mb = function() { | |
| Nm(this); | |
| var effectInstances = this.a.bc(); | |
| var b = this.a.Mb(); | |
| /** @type {!Array} */ | |
| var bulletList = []; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < b.length; i++) { | |
| var e = effectInstances[i]; | |
| /** @type {number} */ | |
| var g = 0; | |
| for (; g < e.length; g++) { | |
| bulletList.push(b[i]); | |
| } | |
| } | |
| return bulletList; | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {?} | |
| */ | |
| k.bc = function(name) { | |
| Nm(this); | |
| /** @type {!Array} */ | |
| var b = []; | |
| if (r(name)) { | |
| if (Qm(this, name)) { | |
| b = yb(b, this.a.get(Om(this, name))); | |
| } | |
| } else { | |
| name = this.a.bc(); | |
| /** @type {number} */ | |
| var curPos = 0; | |
| for (; curPos < name.length; curPos++) { | |
| b = yb(b, name[curPos]); | |
| } | |
| } | |
| return b; | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @param {!Object} name | |
| * @return {?} | |
| */ | |
| k.set = function(value, name) { | |
| Nm(this); | |
| /** @type {null} */ | |
| this.c = null; | |
| value = Om(this, value); | |
| if (Qm(this, value)) { | |
| /** @type {number} */ | |
| this.b = ab(this.b) - this.a.get(value).length; | |
| } | |
| this.a.set(value, [name]); | |
| this.b = ab(this.b) + 1; | |
| return this; | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @param {string} b | |
| * @return {?} | |
| */ | |
| k.get = function(value, b) { | |
| if (!value) { | |
| return b; | |
| } | |
| value = this.bc(value); | |
| return 0 < value.length ? String(value[0]) : b; | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @param {string} val | |
| * @param {!Object} c | |
| * @return {undefined} | |
| */ | |
| var Im = function(obj, val, c) { | |
| Pm(obj, val); | |
| if (0 < c.length) { | |
| /** @type {null} */ | |
| obj.c = null; | |
| obj.a.set(Om(obj, val), Ab(c)); | |
| obj.b = ab(obj.b) + c.length; | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Am.prototype.toString = function() { | |
| if (this.c) { | |
| return this.c; | |
| } | |
| if (!this.a) { | |
| return ""; | |
| } | |
| /** @type {!Array} */ | |
| var a = []; | |
| var commands = this.a.Mb(); | |
| /** @type {number} */ | |
| var j = 0; | |
| for (; j < commands.length; j++) { | |
| var path = commands[j]; | |
| var element = de(path); | |
| path = this.bc(path); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < path.length; i++) { | |
| var w = element; | |
| if ("" !== path[i]) { | |
| /** @type {string} */ | |
| w = w + ("=" + de(path[i])); | |
| } | |
| a.push(w); | |
| } | |
| } | |
| return this.c = a.join("&"); | |
| }; | |
| /** | |
| * @param {!Object} color | |
| * @return {?} | |
| */ | |
| var ym = function(color) { | |
| var result = new Am; | |
| result.c = color.c; | |
| if (color.a) { | |
| result.a = new Yi(color.a); | |
| result.b = color.b; | |
| } | |
| return result; | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @param {!Object} val | |
| * @return {?} | |
| */ | |
| var Om = function(o, val) { | |
| /** @type {string} */ | |
| val = String(val); | |
| if (o.h) { | |
| /** @type {string} */ | |
| val = val.toLowerCase(); | |
| } | |
| return val; | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @param {number} h | |
| * @return {undefined} | |
| */ | |
| var Gm = function(b, h) { | |
| if (h && !b.h) { | |
| Nm(b); | |
| /** @type {null} */ | |
| b.c = null; | |
| b.a.forEach(function(apexdist, n) { | |
| var un = n.toLowerCase(); | |
| if (n != un) { | |
| Pm(this, n); | |
| Im(this, un, apexdist); | |
| } | |
| }, b); | |
| } | |
| /** @type {number} */ | |
| b.h = h; | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| Am.prototype.g = function(name) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < arguments.length; i++) { | |
| dj(arguments[i], function(i, object3D) { | |
| this.add(object3D, i); | |
| }, this); | |
| } | |
| }; | |
| var Rm = { | |
| Es : true | |
| }; | |
| var Sm = { | |
| Hs : true | |
| }; | |
| var Tm = { | |
| Gs : true | |
| }; | |
| var Um = { | |
| Ds : true | |
| }; | |
| var Vm = { | |
| Cs : true | |
| }; | |
| var Wm = { | |
| Fs : true | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var Xm = function() { | |
| throw Error("Do not instantiate directly"); | |
| }; | |
| /** @type {null} */ | |
| Xm.prototype.Hd = null; | |
| /** | |
| * @return {?} | |
| */ | |
| Xm.prototype.Ya = function() { | |
| return this.content; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Xm.prototype.toString = function() { | |
| return this.content; | |
| }; | |
| /** | |
| * @param {!Object} string | |
| * @return {?} | |
| */ | |
| var Ym = function(string) { | |
| if (string.kc === Wm) { | |
| return Fd(string.toString()); | |
| } | |
| if (string.kc !== Rm) { | |
| throw Error("Sanitized content was not of kind TEXT or HTML."); | |
| } | |
| return Rd(ec("Soy SanitizedContent of kind HTML produces SafeHtml-contract-compliant value."), string.toString(), string.Hd); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Zm = function() { | |
| Xm.call(this); | |
| }; | |
| x(Zm, Xm); | |
| Zm.prototype.kc = Rm; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var $m = function() { | |
| Xm.call(this); | |
| }; | |
| x($m, Xm); | |
| $m.prototype.kc = Sm; | |
| /** @type {number} */ | |
| $m.prototype.Hd = 1; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var an = function() { | |
| Xm.call(this); | |
| }; | |
| x(an, Xm); | |
| an.prototype.kc = Tm; | |
| /** @type {number} */ | |
| an.prototype.Hd = 1; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var bn = function() { | |
| Xm.call(this); | |
| }; | |
| x(bn, Xm); | |
| bn.prototype.kc = Um; | |
| /** @type {number} */ | |
| bn.prototype.Hd = 1; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var cn = function() { | |
| Xm.call(this); | |
| }; | |
| x(cn, Xm); | |
| cn.prototype.kc = Vm; | |
| /** @type {number} */ | |
| cn.prototype.Hd = 1; | |
| /** | |
| * @param {string} token | |
| * @param {!Array} str | |
| * @param {!Function} b | |
| * @return {?} | |
| */ | |
| var dn = function(token, str, b) { | |
| if (str = null != token && token.kc === str) { | |
| z(token.constructor === b); | |
| } | |
| return str; | |
| }; | |
| /** | |
| * @param {string} queryObj | |
| * @return {?} | |
| */ | |
| var en = function(queryObj) { | |
| if (null != queryObj) { | |
| switch(queryObj.Hd) { | |
| case 1: | |
| return 1; | |
| case -1: | |
| return -1; | |
| case 0: | |
| return 0; | |
| } | |
| } | |
| return null; | |
| }; | |
| /** | |
| * @param {string} value | |
| * @return {?} | |
| */ | |
| var Q = function(value) { | |
| return dn(value, Rm, Zm) ? value : value instanceof Cd ? P(Dd(value).toString(), value.fd()) : P(fe(String(String(value))), en(value)); | |
| }; | |
| var P = function(WebSocket) { | |
| /** | |
| * @param {string} text | |
| * @return {undefined} | |
| */ | |
| function ws(text) { | |
| /** @type {string} */ | |
| this.content = text; | |
| } | |
| ws.prototype = WebSocket.prototype; | |
| return function(caller, to) { | |
| caller = new ws(String(caller)); | |
| if (void 0 !== to) { | |
| /** @type {number} */ | |
| caller.Hd = to; | |
| } | |
| return caller; | |
| }; | |
| }(Zm); | |
| /** | |
| * @param {!Object} a | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| var fn = function(a, b) { | |
| return Ma(a) && Ma(b) ? a.kc !== b.kc ? false : a.toString() === b.toString() : a instanceof Xm && b instanceof Xm ? a.kc != b.kc ? false : a.toString() == b.toString() : a == b; | |
| }; | |
| /** | |
| * @param {!Object} var_args | |
| * @return {?} | |
| */ | |
| var gn = function(var_args) { | |
| return var_args instanceof Xm ? !!var_args.Ya() : !!var_args; | |
| }; | |
| /** | |
| * @param {string} commaParam | |
| * @return {?} | |
| */ | |
| var hn = function(commaParam) { | |
| return commaParam.replace(/<\//g, "<\\/").replace(/\]\]>/g, "]]\\>"); | |
| }; | |
| /** | |
| * @param {string} val | |
| * @return {?} | |
| */ | |
| var R = function(val) { | |
| if (dn(val, Rm, Zm)) { | |
| val = val.Ya(); | |
| /** @type {string} */ | |
| val = String(val).replace(jn, "").replace(kn, "<"); | |
| /** @type {string} */ | |
| val = String(val).replace(ln, mn); | |
| } else { | |
| val = fe(String(val)); | |
| } | |
| return val; | |
| }; | |
| /** @type {!RegExp} */ | |
| var nn = /['()]/g; | |
| /** | |
| * @param {string} data | |
| * @return {?} | |
| */ | |
| var on = function(data) { | |
| return "%" + data.charCodeAt(0).toString(16); | |
| }; | |
| /** | |
| * @param {string} target | |
| * @return {?} | |
| */ | |
| var pn = function(target) { | |
| target = de(String(target)); | |
| /** @type {number} */ | |
| nn.lastIndex = 0; | |
| return nn.test(target) ? target.replace(nn, on) : target; | |
| }; | |
| /** | |
| * @param {string} id | |
| * @return {?} | |
| */ | |
| var tn = function(id) { | |
| if (dn(id, Sm, $m) || dn(id, Tm, an)) { | |
| /** @type {string} */ | |
| id = String(id).replace(qn, rn); | |
| } else { | |
| if (id instanceof Qc) { | |
| /** @type {string} */ | |
| id = String(Sc(id)).replace(qn, rn); | |
| } else { | |
| if (id instanceof pc) { | |
| /** @type {string} */ | |
| id = String(rc(id)).replace(qn, rn); | |
| } else { | |
| /** @type {string} */ | |
| id = String(id); | |
| if (sn.test(id)) { | |
| /** @type {string} */ | |
| id = id.replace(qn, rn); | |
| } else { | |
| Za("Bad value `%s` for |filterNormalizeUri", [id]); | |
| /** @type {string} */ | |
| id = "about:invalid#zSoyz"; | |
| } | |
| } | |
| } | |
| } | |
| return id; | |
| }; | |
| /** | |
| * @param {string} v | |
| * @return {?} | |
| */ | |
| var vn = function(v) { | |
| if (dn(v, Vm, cn)) { | |
| v = hn(v.Ya()); | |
| } else { | |
| if (null == v) { | |
| /** @type {string} */ | |
| v = ""; | |
| } else { | |
| if (v instanceof $c) { | |
| v = hn(ad(v)); | |
| } else { | |
| if (v instanceof nd) { | |
| v = hn(qd(v)); | |
| } else { | |
| /** @type {string} */ | |
| v = String(v); | |
| if (!un.test(v)) { | |
| Za("Bad value `%s` for |filterCssValue", [v]); | |
| /** @type {string} */ | |
| v = "zSoyz"; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| return v; | |
| }; | |
| /** | |
| * @param {string} trackingPeriod | |
| * @param {string} value | |
| * @param {!Object} object | |
| * @param {string} tag | |
| * @return {?} | |
| */ | |
| var wn = function(trackingPeriod, value, object, tag) { | |
| if (!trackingPeriod) { | |
| trackingPeriod = object instanceof Function ? object.displayName || object.name || "unknown type name" : object instanceof Object ? object.constructor.displayName || object.constructor.name || Object.prototype.toString.call(object) : null === object ? "null" : typeof object; | |
| Za("expected param " + value + " of type " + tag + (", but got " + trackingPeriod) + "."); | |
| } | |
| return object; | |
| }; | |
| var xn = { | |
| "\x00" : "�", | |
| "\t" : "	", | |
| "\n" : " ", | |
| "\x0B" : "", | |
| "\f" : "", | |
| "\r" : " ", | |
| " " : " ", | |
| '"' : """, | |
| "&" : "&", | |
| "'" : "'", | |
| "-" : "-", | |
| "/" : "/", | |
| "<" : "<", | |
| "=" : "=", | |
| ">" : ">", | |
| "`" : "`", | |
| "\u0085" : "…", | |
| "\u00a0" : " ", | |
| "\u2028" : "
", | |
| "\u2029" : "
" | |
| }; | |
| /** | |
| * @param {?} num | |
| * @return {?} | |
| */ | |
| var mn = function(num) { | |
| return xn[num]; | |
| }; | |
| var yn = { | |
| "\x00" : "\\x00", | |
| "\b" : "\\x08", | |
| "\t" : "\\t", | |
| "\n" : "\\n", | |
| "\x0B" : "\\x0b", | |
| "\f" : "\\f", | |
| "\r" : "\\r", | |
| '"' : "\\x22", | |
| $ : "\\x24", | |
| "&" : "\\x26", | |
| "'" : "\\x27", | |
| "(" : "\\x28", | |
| ")" : "\\x29", | |
| "*" : "\\x2a", | |
| "+" : "\\x2b", | |
| "," : "\\x2c", | |
| "-" : "\\x2d", | |
| "." : "\\x2e", | |
| "/" : "\\/", | |
| ":" : "\\x3a", | |
| "<" : "\\x3c", | |
| "=" : "\\x3d", | |
| ">" : "\\x3e", | |
| "?" : "\\x3f", | |
| "[" : "\\x5b", | |
| "\\" : "\\\\", | |
| "]" : "\\x5d", | |
| "^" : "\\x5e", | |
| "{" : "\\x7b", | |
| "|" : "\\x7c", | |
| "}" : "\\x7d", | |
| "\u0085" : "\\x85", | |
| "\u2028" : "\\u2028", | |
| "\u2029" : "\\u2029" | |
| }; | |
| /** | |
| * @param {?} ballNumber | |
| * @return {?} | |
| */ | |
| var zn = function(ballNumber) { | |
| return yn[ballNumber]; | |
| }; | |
| var An = { | |
| "\x00" : "%00", | |
| "\u0001" : "%01", | |
| "\u0002" : "%02", | |
| "\u0003" : "%03", | |
| "\u0004" : "%04", | |
| "\u0005" : "%05", | |
| "\u0006" : "%06", | |
| "\u0007" : "%07", | |
| "\b" : "%08", | |
| "\t" : "%09", | |
| "\n" : "%0A", | |
| "\x0B" : "%0B", | |
| "\f" : "%0C", | |
| "\r" : "%0D", | |
| "\u000e" : "%0E", | |
| "\u000f" : "%0F", | |
| "\u0010" : "%10", | |
| "\u0011" : "%11", | |
| "\u0012" : "%12", | |
| "\u0013" : "%13", | |
| "\u0014" : "%14", | |
| "\u0015" : "%15", | |
| "\u0016" : "%16", | |
| "\u0017" : "%17", | |
| "\u0018" : "%18", | |
| "\u0019" : "%19", | |
| "\u001a" : "%1A", | |
| "\u001b" : "%1B", | |
| "\u001c" : "%1C", | |
| "\u001d" : "%1D", | |
| "\u001e" : "%1E", | |
| "\u001f" : "%1F", | |
| " " : "%20", | |
| '"' : "%22", | |
| "'" : "%27", | |
| "(" : "%28", | |
| ")" : "%29", | |
| "<" : "%3C", | |
| ">" : "%3E", | |
| "\\" : "%5C", | |
| "{" : "%7B", | |
| "}" : "%7D", | |
| "\u007f" : "%7F", | |
| "\u0085" : "%C2%85", | |
| "\u00a0" : "%C2%A0", | |
| "\u2028" : "%E2%80%A8", | |
| "\u2029" : "%E2%80%A9", | |
| "\uff01" : "%EF%BC%81", | |
| "\uff03" : "%EF%BC%83", | |
| "\uff04" : "%EF%BC%84", | |
| "\uff06" : "%EF%BC%86", | |
| "\uff07" : "%EF%BC%87", | |
| "\uff08" : "%EF%BC%88", | |
| "\uff09" : "%EF%BC%89", | |
| "\uff0a" : "%EF%BC%8A", | |
| "\uff0b" : "%EF%BC%8B", | |
| "\uff0c" : "%EF%BC%8C", | |
| "\uff0f" : "%EF%BC%8F", | |
| "\uff1a" : "%EF%BC%9A", | |
| "\uff1b" : "%EF%BC%9B", | |
| "\uff1d" : "%EF%BC%9D", | |
| "\uff1f" : "%EF%BC%9F", | |
| "\uff20" : "%EF%BC%A0", | |
| "\uff3b" : "%EF%BC%BB", | |
| "\uff3d" : "%EF%BC%BD" | |
| }; | |
| /** | |
| * @param {?} el | |
| * @return {?} | |
| */ | |
| var rn = function(el) { | |
| return An[el]; | |
| }; | |
| /** @type {!RegExp} */ | |
| var ln = /[\x00\x22\x27\x3c\x3e]/g; | |
| /** @type {!RegExp} */ | |
| var Bn = /[\x00\x08-\x0d\x22\x26\x27\/\x3c-\x3e\x5b-\x5d\x7b\x7d\x85\u2028\u2029]/g; | |
| /** @type {!RegExp} */ | |
| var qn = /[\x00- \x22\x27-\x29\x3c\x3e\\\x7b\x7d\x7f\x85\xa0\u2028\u2029\uff01\uff03\uff04\uff06-\uff0c\uff0f\uff1a\uff1b\uff1d\uff1f\uff20\uff3b\uff3d]/g; | |
| /** @type {!RegExp} */ | |
| var un = /^(?!-*(?:expression|(?:moz-)?binding))(?:(?:[.#]?-?(?:[_a-z0-9-]+)(?:-[_a-z0-9-]+)*-?|(?:rgb|hsl)a?\([0-9.%,\u0020]+\)|-?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[a-z]{1,4}|%)?|!important)(?:\s+|$))*$/i; | |
| /** @type {!RegExp} */ | |
| var sn = /^(?![^#?]*\/(?:\.|%2E){2}(?:[\/?#]|$))(?:(?:https?|mailto):|[^&:\/?#]*(?:[\/?#]|$))/i; | |
| /** @type {!RegExp} */ | |
| var Cn = /^(?!on|src|(?:action|archive|background|cite|classid|codebase|content|data|dsync|href|http-equiv|longdesc|style|usemap)\s*$)(?:[a-z0-9_$:-]*)$/i; | |
| /** | |
| * @param {?} num | |
| * @return {?} | |
| */ | |
| var Dn = function(num) { | |
| return String(num).replace(Bn, zn); | |
| }; | |
| /** @type {!RegExp} */ | |
| var jn = /<(?:!|\/?([a-zA-Z][a-zA-Z0-9:\-]*))(?:[^>'"]|"[^"]*"|'[^']*')*>/g; | |
| /** @type {!RegExp} */ | |
| var kn = /</g; | |
| /** | |
| * @param {string} self | |
| * @return {?} | |
| */ | |
| var Fn = function(self) { | |
| var tmp = self.a; | |
| var boxInput = self.$m; | |
| var hparent = self.an; | |
| var cn = self.cn; | |
| var p = self.pp; | |
| var bound = self.qp; | |
| var tagName = P; | |
| /** @type {string} */ | |
| self = '<div class="tlid-community-instant-vt-card community-instant-vt-card"></div><div class="tlid-community-instant-hide-card community-instant-hide-card">' + En({ | |
| uj : self.gn, | |
| tj : self.fn, | |
| Fj : self.hn, | |
| Ni : self.dn | |
| }) + '</div><div class="tlid-community-instant-help-card community-instant-help-card">' + En({ | |
| uj : hparent, | |
| tj : boxInput, | |
| Fj : cn, | |
| Ni : tmp | |
| }) + '</div><div class="tlid-community-instant-thanks-card community-instant-thanks-card">'; | |
| p = P('<div class="community-instant-thanks-content"><div class="tlid-community-instant-close community-instant-close"></div><div class="tlid-community-instant-thanks community-instant-thanks">' + Q(bound) + '</div><div class="community-instant-continue-wrapper"><div class="tlid-community-instant-continue community-instant-continue">' + Q(p) + "</div></div></div>"); | |
| return tagName(self + p + "</div>"); | |
| }; | |
| /** @type {string} */ | |
| Fn.a = "trans.common.templates.communityInstantCard"; | |
| /** | |
| * @param {!Object} data | |
| * @return {?} | |
| */ | |
| var Gn = function(data) { | |
| var x = data.In; | |
| var items = data.Hn; | |
| var u = data.rp; | |
| var value = data.fp; | |
| var list = data.url; | |
| return P('<div id="' + R(data.id) + '" class="cp-promo" style="display:none"><div class="cp-promo-c"><div class="cp-dismiss"></div><a href="' + R(tn(list)) + '" target="_blank" class="cp-promo-href"><div class="cp-promo-graphic"></div><div class="cp-promo-text-c"><div class="cp-promo-text"><div class="cp-promo-title">' + Q(u) + '</div><div class="cp-promo-subtext">' + Q(value) + '</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">' + | |
| Q(x) + '</div><div class="cp-promo-link-subtext">' + Q(items) + "</div></div></div></a></div></div>"); | |
| }; | |
| /** @type {string} */ | |
| Gn.a = "trans.common.templates.communityPromotion"; | |
| /** | |
| * @param {!Object} p | |
| * @return {?} | |
| */ | |
| var Hn = function(p) { | |
| var x = p.Ae; | |
| var u = p.jp; | |
| var y = p.yl; | |
| var r = p.up; | |
| var s = p.Yn; | |
| var value = p.Zn; | |
| var element = p.Xn; | |
| /** @type {string} */ | |
| p = '<div class="community-instant-card">' + P('<div><div class="tlid-community-instant-header community-instant-header"><div class="community-instant-icon"></div><div class="community-instant-header-text">' + Q(p.Zm) + '</div><div class="community-instant-placeholder"></div><div class="tlid-community-instant-help community-instant-help"></div><div class="tlid-community-instant-hide community-instant-hide"></div></div></div>') + '<div class="community-instant-body"><div class="community-instant-content"><div class="community-instant-source">' + | |
| Q(x) + '</div><div class="community-instant-target">' + Q(u) + '</div></div><div class="community-instant-footer"><div class="community-instant-counter">' + Q(y + 1) + "/" + Q(r) + '</div><div class="community-instant-dots">'; | |
| /** @type {number} */ | |
| r = Math.max(0, Math.ceil(r - 0)); | |
| /** @type {number} */ | |
| x = 0; | |
| for (; x < r; x++) { | |
| /** @type {string} */ | |
| p = p + (fn(1 * x, y) ? '<div class="community-instant-dot-active"></div>' : '<div class="community-instant-dot"></div>'); | |
| } | |
| /** @type {string} */ | |
| p = p + ('</div><div class="community-instant-placeholder"></div><div class="tlid-community-instant-yes community-instant-yes"><div class="community-instant-yes-icon"></div>' + Q(value) + '</div><div class="tlid-community-instant-no community-instant-no"><div class="community-instant-no-icon"></div>' + Q(element) + '</div><div class="tlid-community-instant-skip community-instant-skip"><div class="community-instant-skip-icon"></div>' + Q(s) + "</div></div></div></div>"); | |
| return P(p); | |
| }; | |
| /** @type {string} */ | |
| Hn.a = "trans.common.templates.communityVtCard"; | |
| /** | |
| * @param {?} config | |
| * @return {?} | |
| */ | |
| var En = function(config) { | |
| var x = config.tj; | |
| var value = config.Fj; | |
| var items = config.Ni; | |
| return P('<div class="community-instant-info-card"><div class="tlid-community-instant-close community-instant-close"></div><div class="community-instant-help-content"><div class="community-instant-help-title">' + Q(config.uj) + '</div><div class="community-instant-help-body">' + Q(x) + '</div></div><div class="community-instant-help-footer">' + (items ? '<div class="tlid-community-instant-cancel community-instant-cancel">' + Q(items) + "</div>" : "") + (value ? '<div class="tlid-community-instant-ok community-instant-ok">' + | |
| Q(value) + "</div>" : "") + "</div></div>"); | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @return {?} | |
| */ | |
| var In = function(options) { | |
| return P('<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">' + Q(options.label) + "</div></div>"); | |
| }; | |
| /** @type {string} */ | |
| In.a = "trans.common.templates.speechInput"; | |
| /** | |
| * @param {?} p | |
| * @return {?} | |
| */ | |
| var Jn = function(p) { | |
| var u = p.Ae; | |
| var d = p.Fn; | |
| var x = p.Gn; | |
| var m = p.Xh; | |
| var value = p.Jp; | |
| return P('<div class="gt-ex-info">' + (p.Zo ? '<span class="gt-ex-quote">\x3c!--This SVG renders a quotation mark.--\x3e<svg viewBox="0 0 24 24"><path d="M6 17h3l2-4V7H5v6h3zm8 0h3l2-4V7h-6v6h3z"></path><path d="M0 0h24v24H0z" fill="none"></path></svg></span>' : "") + '<div class="gt-ex-top"><div class="gt-ex-text" dir="' + R(p.bp) + '">' + Q(u) + '</div></div><div class="gt-ex-mt" style="display:none"><span class="gt-cd-mt" dir="' + R(m) + '"></span><br><span class="gt-cd-mt-label">' + Q(value) + | |
| '</span><span class="gt-ex-credit"><a class="gt-ex-link" target="_blank" href="' + R(tn(d)) + '">' + Q(x) + "</a></span></div></div>"); | |
| }; | |
| /** @type {string} */ | |
| Jn.a = "trans.common.templates.exampleSentence"; | |
| /** | |
| * @param {!Object} version | |
| * @return {?} | |
| */ | |
| var Kn = function(version) { | |
| var l = version.ho; | |
| version = version.io; | |
| return P('<div class="st-stp1">' + (l ? "" : '<div class="st-stp1-text"><div>' + Q(version) + "</div></div>") + '<div id="st-buttons"></div>' + (l ? '<div class="st-stp1-epu-text">' + Q(version) + "</div>" : "") + "</div>"); | |
| }; | |
| /** @type {string} */ | |
| Kn.a = "trans.common.templates.submitTranslation"; | |
| /** | |
| * @return {?} | |
| */ | |
| var Ln = function() { | |
| return P('<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>'); | |
| }; | |
| /** @type {string} */ | |
| Ln.a = "trans.common.templates.cardContainer"; | |
| /** | |
| * @return {?} | |
| */ | |
| var Mn = function() { | |
| return P('<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" role="button" tabindex="0"><span class="jfk-button-img"></span><span class="cd-expand-label"></span></div>'); | |
| }; | |
| /** @type {string} */ | |
| Mn.a = "trans.common.templates.card"; | |
| /** | |
| * @return {?} | |
| */ | |
| var Nn = function() { | |
| return P('<span class="gt-ct-text"></span><span class="gt-ct-translit" style="display:none"></span><div class="gt-ct-tts goog-inline-block"></div>'); | |
| }; | |
| /** @type {string} */ | |
| Nn.a = "trans.common.templates.lexiconTitle"; | |
| /** | |
| * @param {!Object} options | |
| * @return {?} | |
| */ | |
| var On = function(options) { | |
| var i = options.Bl; | |
| var name = options.Hk; | |
| var object = options.Cl; | |
| var result = options.Ul; | |
| var length = options.ip; | |
| var locations = options.hp; | |
| var key = options.Xh; | |
| var obj = options.ll; | |
| /** @type {string} */ | |
| options = '<div class="gt-def-info" lang="' + R(options.Ca) + '">' + (name ? '<span class="gt-def-num">' + Q(i) + "</span>" : "") + '<div class="gt-def-row">' + Q(object) + '<div class="gt-mt-md" style="display:none"><span class="gt-cd-mt"></span></div></div>' + (result ? '<div class="gt-def-example"><q>' + Q(result) + '</q><div class="gt-mt-ex" style="display:none"><q class="gt-cd-mt" dir="' + R(key) + '"></q></div></div>' : ""); | |
| if (0 < locations.length) { | |
| /** @type {string} */ | |
| options = options + ('<div class="gt-def-synonym"><span class="gt-def-synonym-title">' + Q(length) + ': </span><span class="gt-def-synonyms-group"></span><span class="gt-def-synonyms-group"></span>'); | |
| length = locations.length; | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < length; i++) { | |
| object = locations[i]; | |
| result = object.length; | |
| /** @type {number} */ | |
| key = 0; | |
| for (; key < result; key++) { | |
| var value = object[key]; | |
| /** @type {string} */ | |
| var str = name ? "" : key != result - 1 ? ", " : i != length - 1 ? "; " : ""; | |
| /** @type {string} */ | |
| options = options + ((obj ? name ? '<span class="gt-cd-cl"> ' + Q(value) + " </span>" : '<span class="gt-cd-cl">' + Q(value) + "</span>" : '<span class="gt-cd-ncl">' + Q(value) + "</span>") + str); | |
| } | |
| } | |
| /** @type {string} */ | |
| options = options + "</div>"; | |
| } | |
| return P(options + "</div>"); | |
| }; | |
| /** @type {string} */ | |
| On.a = "trans.common.templates.definitionRow"; | |
| /** | |
| * @param {boolean} t | |
| * @return {?} | |
| */ | |
| var Pn = function(t) { | |
| var b = t.Il; | |
| var x = t.Zl; | |
| var u = t.$l; | |
| var value = t.Co; | |
| t = t.Xd; | |
| return P((t ? "" : '<div class="gt-card-expand-wrapper gt-card-collapsed">') + '<div class="gt-baf-cell gt-baf-pos-head">' + (value ? '<span class="gt-cd-pos">' + Q(value) + "</span>" : "") + (b ? '<div class="gt-cd-pos-pop">' + Q(x) + '<div class="help-icon-container tlid-frequency-help-icon-container"><div class="help-icon tlid-frequency-help-icon"></div><div class="help-tooltip tlid-frequency-help-tooltip"><p>' + Q(u) + "</p></div></div></div>" : "") + "</div>" + (t ? "" : "</div>")); | |
| }; | |
| /** @type {string} */ | |
| Pn.a = "trans.common.templates.partOfSpeechEntryHeading"; | |
| /** | |
| * @param {string} c | |
| * @return {?} | |
| */ | |
| var Qn = function(c) { | |
| var cc = c.Eh; | |
| var u = c.nf; | |
| var d = c.lp; | |
| var cl = c.Xd; | |
| var x = c.Rp; | |
| c = c.Sp; | |
| return P((cl ? "" : '<div class="gt-card-expand-wrapper gt-card-collapsed">') + '<div class="gt-baf-cell gt-baf-term-text-parent"' + (d ? ' style="direction: ' + R(vn(d)) + ';"' : "") + '><span class="gt-baf-term-text' + (cc ? " gt-baf-word-selected" : "") + '">' + (u ? '<span class="gt-baf-cell gt-baf-previous-word gt-baf-previous-word-mobile">' + Q(u) + "</span>" : "") + '<span class="' + R(c) + '">' + Q(x) + "</span></span></div>" + (cl ? "" : "</div>")); | |
| }; | |
| /** @type {string} */ | |
| Qn.a = "trans.common.templates.termText"; | |
| /** | |
| * @param {boolean} p | |
| * @return {?} | |
| */ | |
| var Rn = function(p) { | |
| var m = p.Ef; | |
| var d = p.Fl; | |
| var samples = p.Bg; | |
| p = p.Xd; | |
| /** @type {string} */ | |
| d = (p ? "" : '<div class="gt-card-expand-wrapper gt-card-collapsed">') + '<div class="gt-baf-cell gt-baf-translations gt-baf-translations-mobile"' + (d ? ' style="direction: ' + R(vn(d)) + ';"' : "") + ">"; | |
| var l = samples.length; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < l; i++) { | |
| var x = samples[i]; | |
| /** @type {string} */ | |
| d = d + ("<span" + (m ? ' class="' + R(m) + '"' : "") + ">" + Q(x) + "</span>" + (i != l - 1 ? ", " : "")); | |
| } | |
| return P(d + ("</div>" + (p ? "" : "</div>"))); | |
| }; | |
| /** @type {string} */ | |
| Rn.a = "trans.common.templates.translationsCell"; | |
| /** | |
| * @param {string} options | |
| * @return {?} | |
| */ | |
| var Tn = function(options) { | |
| var frames_per_block = options.Wb; | |
| var withoutRoot = options.Xd; | |
| /** @type {string} */ | |
| options = (withoutRoot ? "" : '<div class="gt-card-expand-wrapper gt-card-collapsed">') + '<div class="gt-baf-cell gt-baf-entry-score" title="' + R(options.Jc) + '">'; | |
| /** @type {number} */ | |
| var audio_data_index = Math.max(0, Math.ceil(frames_per_block + 1 - 1)); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < audio_data_index; i++) { | |
| var option = P(Sn({ | |
| className : "filled" | |
| })); | |
| /** @type {string} */ | |
| options = options + option; | |
| } | |
| if (3 > frames_per_block) { | |
| /** @type {number} */ | |
| frames_per_block = Math.max(0, Math.ceil(4 - (frames_per_block + 1))); | |
| /** @type {number} */ | |
| audio_data_index = 0; | |
| for (; audio_data_index < frames_per_block; audio_data_index++) { | |
| i = P(Sn({ | |
| className : "empty" | |
| })); | |
| /** @type {string} */ | |
| options = options + i; | |
| } | |
| } | |
| return P(options + ("</div>" + (withoutRoot ? "" : "</div>"))); | |
| }; | |
| /** @type {string} */ | |
| Tn.a = "trans.common.templates.backAndForthViewEntryScore"; | |
| /** | |
| * @param {!Object} style | |
| * @return {?} | |
| */ | |
| var Sn = function(style) { | |
| return P('<div class="' + R(style.className) + ' gt-score-dot"></div>'); | |
| }; | |
| /** @type {boolean} */ | |
| var Un = null != window.KNOWLEDGE_PANEL; | |
| /** @type {boolean} */ | |
| var Vn = null != window.MSG_SPEECH_INPUT_TURN_ON; | |
| /** @type {boolean} */ | |
| var Wn = null != window.ADD_INFLECTION; | |
| var Xn = { | |
| es : { | |
| en : true | |
| }, | |
| fr : { | |
| en : true | |
| }, | |
| it : { | |
| en : true | |
| }, | |
| nl : { | |
| en : true | |
| }, | |
| pt : { | |
| en : true | |
| }, | |
| en : { | |
| tr : true | |
| } | |
| }; | |
| /** | |
| * @param {string} m | |
| * @param {!Object} key | |
| * @return {?} | |
| */ | |
| function Yn(m, key) { | |
| if ("auto" === m) { | |
| throw Error('detectedSourceLanguage should not be "auto". Did you mean shouldRequestGenderedTranslations()?'); | |
| } | |
| return !!Xn[key] && !!Xn[key][m]; | |
| } | |
| /** | |
| * @param {(Object|boolean)} file | |
| * @param {!Object} result | |
| * @return {?} | |
| */ | |
| var Zn = function(file, result) { | |
| try { | |
| return JSON.parse(file); | |
| } catch (err) { | |
| var wru = hm.N(); | |
| /** @type {(Object|boolean)} */ | |
| result.js = file; | |
| result.error = err.message; | |
| wru.log("jsonParseErr", result); | |
| throw err; | |
| } | |
| }; | |
| /** | |
| * @param {string} value | |
| * @return {?} | |
| */ | |
| var $n = function(value) { | |
| return function() { | |
| return value; | |
| }; | |
| }; | |
| /** | |
| * @param {number} a | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| var ao = function(a, name) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < name.length - 2; i = i + 3) { | |
| var b = name.charAt(i + 2); | |
| /** @type {number} */ | |
| b = "a" <= b ? b.charCodeAt(0) - 87 : Number(b); | |
| /** @type {number} */ | |
| b = "+" == name.charAt(i + 1) ? a >>> b : a << b; | |
| /** @type {number} */ | |
| a = "+" == name.charAt(i) ? a + b & 4294967295 : a ^ b; | |
| } | |
| return a; | |
| }; | |
| /** @type {null} */ | |
| var bo = null; | |
| /** | |
| * @param {number} a | |
| * @return {?} | |
| */ | |
| var co = function(a) { | |
| if (null !== bo) { | |
| var d = bo; | |
| } else { | |
| d = $n(String.fromCharCode(84)); | |
| var parseFloat = $n(String.fromCharCode(75)); | |
| /** @type {!Array} */ | |
| d = [d(), d()]; | |
| d[1] = parseFloat(); | |
| d = (bo = window[d.join(parseFloat())] || "") || ""; | |
| } | |
| var b = $n(String.fromCharCode(116)); | |
| parseFloat = $n(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 s = []; | |
| /** @type {number} */ | |
| var i = 0; | |
| /** @type {number} */ | |
| var f = 0; | |
| for (; f < a.length; f++) { | |
| var tmp = a.charCodeAt(f); | |
| if (128 > tmp) { | |
| s[i++] = tmp; | |
| } else { | |
| if (2048 > tmp) { | |
| /** @type {number} */ | |
| s[i++] = tmp >> 6 | 192; | |
| } else { | |
| if (55296 == (tmp & 64512) && f + 1 < a.length && 56320 == (a.charCodeAt(f + 1) & 64512)) { | |
| /** @type {number} */ | |
| tmp = 65536 + ((tmp & 1023) << 10) + (a.charCodeAt(++f) & 1023); | |
| /** @type {number} */ | |
| s[i++] = tmp >> 18 | 240; | |
| /** @type {number} */ | |
| s[i++] = tmp >> 12 & 63 | 128; | |
| } else { | |
| /** @type {number} */ | |
| s[i++] = tmp >> 12 | 224; | |
| } | |
| /** @type {number} */ | |
| s[i++] = tmp >> 6 & 63 | 128; | |
| } | |
| /** @type {number} */ | |
| s[i++] = tmp & 63 | 128; | |
| } | |
| } | |
| /** @type {number} */ | |
| a = d; | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < s.length; i++) { | |
| a = a + s[i]; | |
| a = ao(a, "+-a^+6"); | |
| } | |
| a = ao(a, "+-3^+b+-f"); | |
| /** @type {number} */ | |
| a = a ^ (Number(b[1]) || 0); | |
| if (0 > a) { | |
| /** @type {number} */ | |
| a = (a & 2147483647) + 2147483648; | |
| } | |
| /** @type {number} */ | |
| a = a % 1E6; | |
| return parseFloat + (a.toString() + "." + (a ^ d)); | |
| }; | |
| /** | |
| * @param {!Array} fn | |
| * @return {undefined} | |
| */ | |
| var eo = function(fn) { | |
| el(this, fn, 4); | |
| }; | |
| x(eo, dl); | |
| var fo = { | |
| word_postproc : { | |
| H : 0, | |
| J : false | |
| }, | |
| score : { | |
| H : 1, | |
| J : false | |
| }, | |
| has_preceding_space : { | |
| H : 2, | |
| J : false | |
| }, | |
| attach_to_next_token : { | |
| H : 3, | |
| J : false | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| eo.prototype.a = function() { | |
| return fo; | |
| }; | |
| /** | |
| * @param {!Array} value | |
| * @return {undefined} | |
| */ | |
| var go = function(value) { | |
| el(this, value, 2); | |
| }; | |
| x(go, dl); | |
| var ho = { | |
| begin : { | |
| H : 0, | |
| J : false | |
| }, | |
| end : { | |
| H : 1, | |
| J : false | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| go.prototype.a = function() { | |
| return ho; | |
| }; | |
| /** | |
| * @param {!Array} meta | |
| * @return {undefined} | |
| */ | |
| var io = function(meta) { | |
| el(this, meta, 7); | |
| }; | |
| x(io, dl); | |
| var jo = { | |
| src_phrase : { | |
| H : 0, | |
| J : false | |
| }, | |
| alternative : { | |
| H : 2, | |
| ya : function(obj) { | |
| return kl(eo, obj); | |
| }, | |
| xa : function(a) { | |
| return jl(new eo(a)); | |
| }, | |
| J : true | |
| }, | |
| srcunicodeoffsets : { | |
| H : 3, | |
| ya : function(obj) { | |
| return kl(go, obj); | |
| }, | |
| xa : function(a) { | |
| return jl(new go(a)); | |
| }, | |
| J : true | |
| }, | |
| raw_src_segment : { | |
| H : 4, | |
| J : false | |
| }, | |
| start_pos : { | |
| H : 5, | |
| J : false | |
| }, | |
| end_pos : { | |
| H : 6, | |
| J : false | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| io.prototype.a = function() { | |
| return jo; | |
| }; | |
| /** | |
| * @param {!Object} code | |
| * @param {number} arg | |
| * @return {?} | |
| */ | |
| var ko = function(code, arg) { | |
| return new eo(hl(code, 2, arg)); | |
| }; | |
| /** | |
| * @param {!Object} code | |
| * @param {number} value | |
| * @return {?} | |
| */ | |
| var lo = function(code, value) { | |
| return new go(hl(code, 3, value)); | |
| }; | |
| /** | |
| * @param {!Array} c | |
| * @return {undefined} | |
| */ | |
| var mo = function(c) { | |
| el(this, c, 8); | |
| }; | |
| x(mo, dl); | |
| var no = { | |
| word : { | |
| H : 0, | |
| J : false | |
| }, | |
| styles : { | |
| H : 1, | |
| J : true | |
| }, | |
| has_preceding_space : { | |
| H : 2, | |
| J : false | |
| }, | |
| attach_to_next_token : { | |
| H : 3, | |
| J : false | |
| }, | |
| confidence : { | |
| H : 4, | |
| J : false | |
| }, | |
| start_pos : { | |
| H : 5, | |
| J : false | |
| }, | |
| end_pos : { | |
| H : 6, | |
| J : false | |
| }, | |
| not_from_first_segment : { | |
| H : 7, | |
| J : false | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| mo.prototype.a = function() { | |
| return no; | |
| }; | |
| /** | |
| * @param {!Array} key | |
| * @return {undefined} | |
| */ | |
| var oo = function(key) { | |
| el(this, key, 3); | |
| }; | |
| x(oo, dl); | |
| var po = { | |
| gloss : { | |
| H : 0, | |
| J : false | |
| }, | |
| definition_id : { | |
| H : 1, | |
| J : false | |
| }, | |
| example : { | |
| H : 2, | |
| J : false | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| oo.prototype.a = function() { | |
| return po; | |
| }; | |
| /** | |
| * @param {!Array} fn | |
| * @return {undefined} | |
| */ | |
| var qo = function(fn) { | |
| el(this, fn, 3); | |
| }; | |
| x(qo, dl); | |
| var ro = { | |
| pos : { | |
| H : 0, | |
| J : false | |
| }, | |
| entry : { | |
| H : 1, | |
| ya : function(obj) { | |
| return kl(oo, obj); | |
| }, | |
| xa : function(a) { | |
| return jl(new oo(a)); | |
| }, | |
| J : true | |
| }, | |
| base_form : { | |
| H : 2, | |
| J : false | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| qo.prototype.a = function() { | |
| return ro; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| qo.prototype.b = function() { | |
| return J(this, 1); | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {?} | |
| */ | |
| qo.prototype.c = function(type) { | |
| return new oo(hl(this, 1, type)); | |
| }; | |
| /** | |
| * @param {!Array} node | |
| * @return {undefined} | |
| */ | |
| var so = function(node) { | |
| el(this, node, 6); | |
| }; | |
| x(so, dl); | |
| var to = { | |
| word : { | |
| H : 0, | |
| J : false | |
| }, | |
| reverse_translation : { | |
| H : 1, | |
| J : true | |
| }, | |
| synset_id : { | |
| H : 2, | |
| J : true | |
| }, | |
| score : { | |
| H : 3, | |
| J : false | |
| }, | |
| previous_word : { | |
| H : 4, | |
| J : false | |
| }, | |
| gender : { | |
| H : 5, | |
| J : false | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| so.prototype.a = function() { | |
| return to; | |
| }; | |
| /** | |
| * @param {!Array} fn | |
| * @return {undefined} | |
| */ | |
| var uo = function(fn) { | |
| el(this, fn, 5); | |
| }; | |
| x(uo, dl); | |
| var vo = { | |
| pos : { | |
| H : 0, | |
| J : false | |
| }, | |
| terms : { | |
| H : 1, | |
| J : true | |
| }, | |
| entry : { | |
| H : 2, | |
| ya : function(obj) { | |
| return kl(so, obj); | |
| }, | |
| xa : function(a) { | |
| return jl(new so(a)); | |
| }, | |
| J : true | |
| }, | |
| base_form : { | |
| H : 3, | |
| J : false | |
| }, | |
| pos_enum : { | |
| H : 4, | |
| J : false | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| uo.prototype.a = function() { | |
| return vo; | |
| }; | |
| /** | |
| * @param {string} val | |
| * @param {number} m | |
| * @return {?} | |
| */ | |
| var wo = function(val, m) { | |
| return fh(val, 1, m); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| uo.prototype.b = function() { | |
| return J(this, 2); | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {?} | |
| */ | |
| uo.prototype.c = function(type) { | |
| return new so(hl(this, 2, type)); | |
| }; | |
| /** | |
| * @param {!Array} fn | |
| * @return {undefined} | |
| */ | |
| var xo = function(fn) { | |
| el(this, fn, 17); | |
| }; | |
| x(xo, dl); | |
| var yo = { | |
| animacy : { | |
| H : 0, | |
| J : false | |
| }, | |
| inflection_aspect : { | |
| H : 1, | |
| J : false | |
| }, | |
| grammatical_case : { | |
| H : 2, | |
| J : false | |
| }, | |
| degree : { | |
| H : 3, | |
| J : false | |
| }, | |
| gender : { | |
| H : 4, | |
| J : false | |
| }, | |
| mood : { | |
| H : 5, | |
| J : false | |
| }, | |
| nonfinite_form : { | |
| H : 6, | |
| J : false | |
| }, | |
| number : { | |
| H : 7, | |
| J : false | |
| }, | |
| person : { | |
| H : 8, | |
| J : false | |
| }, | |
| polarity : { | |
| H : 9, | |
| J : false | |
| }, | |
| referent : { | |
| H : 10, | |
| J : false | |
| }, | |
| strength : { | |
| H : 11, | |
| J : false | |
| }, | |
| tense : { | |
| H : 12, | |
| J : false | |
| }, | |
| imperfect_suffix : { | |
| H : 13, | |
| J : false | |
| }, | |
| voice : { | |
| H : 14, | |
| J : false | |
| }, | |
| infinitive_number : { | |
| H : 15, | |
| J : false | |
| }, | |
| precedes : { | |
| H : 16, | |
| J : false | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| xo.prototype.a = function() { | |
| return yo; | |
| }; | |
| /** | |
| * @param {!Array} fn | |
| * @return {undefined} | |
| */ | |
| var zo = function(fn) { | |
| el(this, fn, 2); | |
| }; | |
| x(zo, dl); | |
| var Ao = { | |
| written_form : { | |
| H : 0, | |
| J : false | |
| }, | |
| features : { | |
| H : 1, | |
| ya : function(obj) { | |
| return kl(xo, obj); | |
| }, | |
| xa : function(a) { | |
| return jl(new xo(a)); | |
| }, | |
| J : false | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| zo.prototype.a = function() { | |
| return Ao; | |
| }; | |
| /** | |
| * @param {!Array} fn | |
| * @return {undefined} | |
| */ | |
| var Bo = function(fn) { | |
| el(this, fn, 4); | |
| }; | |
| x(Bo, dl); | |
| var Co = { | |
| title : { | |
| H : 0, | |
| J : false | |
| }, | |
| description : { | |
| H : 1, | |
| J : false | |
| }, | |
| image_url : { | |
| H : 2, | |
| J : false | |
| }, | |
| image_ref_url : { | |
| H : 3, | |
| J : false | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Bo.prototype.a = function() { | |
| return Co; | |
| }; | |
| /** | |
| * @param {!Array} value | |
| * @return {undefined} | |
| */ | |
| var Do = function(value) { | |
| el(this, value, 4); | |
| }; | |
| x(Do, dl); | |
| var Eo = { | |
| srclangs : { | |
| H : 0, | |
| J : true | |
| }, | |
| extended_srclangs : { | |
| H : 3, | |
| J : true | |
| }, | |
| detected_target : { | |
| H : 1, | |
| J : false | |
| }, | |
| srclangs_confidences : { | |
| H : 2, | |
| J : true | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Do.prototype.a = function() { | |
| return Eo; | |
| }; | |
| /** | |
| * @param {!Array} fn | |
| * @return {undefined} | |
| */ | |
| var Fo = function(fn) { | |
| el(this, fn, 1); | |
| }; | |
| x(Fo, dl); | |
| var Go = { | |
| word : { | |
| H : 0, | |
| J : true | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Fo.prototype.a = function() { | |
| return Go; | |
| }; | |
| /** | |
| * @param {!Array} fn | |
| * @return {undefined} | |
| */ | |
| var Ho = function(fn) { | |
| el(this, fn, 6); | |
| }; | |
| x(Ho, dl); | |
| var Io = { | |
| spell_html_res : { | |
| H : 0, | |
| J : false | |
| }, | |
| spell_res : { | |
| H : 1, | |
| J : false | |
| }, | |
| correction_type : { | |
| H : 2, | |
| J : true | |
| }, | |
| correction_translation : { | |
| H : 3, | |
| J : false | |
| }, | |
| related : { | |
| H : 4, | |
| J : false | |
| }, | |
| confident : { | |
| H : 5, | |
| J : false | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Ho.prototype.a = function() { | |
| return Io; | |
| }; | |
| /** | |
| * @param {!Array} fn | |
| * @return {undefined} | |
| */ | |
| var Jo = function(fn) { | |
| el(this, fn, 2); | |
| }; | |
| x(Jo, dl); | |
| var Ko = { | |
| synonym : { | |
| H : 0, | |
| J : true | |
| }, | |
| definition_id : { | |
| H : 1, | |
| J : false | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Jo.prototype.a = function() { | |
| return Ko; | |
| }; | |
| /** | |
| * @param {!Array} fn | |
| * @return {undefined} | |
| */ | |
| var Lo = function(fn) { | |
| el(this, fn, 3); | |
| }; | |
| x(Lo, dl); | |
| var Mo = { | |
| pos : { | |
| H : 0, | |
| J : false | |
| }, | |
| entry : { | |
| H : 1, | |
| ya : function(obj) { | |
| return kl(Jo, obj); | |
| }, | |
| xa : function(a) { | |
| return jl(new Jo(a)); | |
| }, | |
| J : true | |
| }, | |
| base_form : { | |
| H : 2, | |
| J : false | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Lo.prototype.a = function() { | |
| return Mo; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Lo.prototype.b = function() { | |
| return J(this, 1); | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {?} | |
| */ | |
| Lo.prototype.c = function(type) { | |
| return new Jo(hl(this, 1, type)); | |
| }; | |
| /** | |
| * @param {!Array} fn | |
| * @return {undefined} | |
| */ | |
| var No = function(fn) { | |
| el(this, fn, 6); | |
| }; | |
| x(No, dl); | |
| var Oo = { | |
| text : { | |
| H : 0, | |
| J : false | |
| }, | |
| source : { | |
| H : 1, | |
| J : false | |
| }, | |
| link : { | |
| H : 2, | |
| J : false | |
| }, | |
| translation : { | |
| H : 3, | |
| J : false | |
| }, | |
| source_type : { | |
| H : 4, | |
| J : false | |
| }, | |
| definition_id : { | |
| H : 5, | |
| J : false | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| No.prototype.a = function() { | |
| return Oo; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| No.prototype.Cb = function() { | |
| return K(this, 3); | |
| }; | |
| /** | |
| * @param {!Array} fn | |
| * @return {undefined} | |
| */ | |
| var Po = function(fn) { | |
| el(this, fn, 1); | |
| }; | |
| x(Po, dl); | |
| var Qo = { | |
| example : { | |
| H : 0, | |
| ya : function(obj) { | |
| return kl(No, obj); | |
| }, | |
| xa : function(a) { | |
| return jl(new No(a)); | |
| }, | |
| J : true | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Po.prototype.a = function() { | |
| return Qo; | |
| }; | |
| /** | |
| * @param {!Array} fn | |
| * @return {undefined} | |
| */ | |
| var Ro = function(fn) { | |
| el(this, fn, 19); | |
| }; | |
| x(Ro, dl); | |
| var So = { | |
| sentences : { | |
| H : 0, | |
| ya : function(obj) { | |
| return kl(zl, obj); | |
| }, | |
| xa : function(a) { | |
| return jl(new zl(a)); | |
| }, | |
| J : true | |
| }, | |
| dict : { | |
| H : 1, | |
| ya : function(obj) { | |
| return kl(uo, obj); | |
| }, | |
| xa : function(a) { | |
| return jl(new uo(a)); | |
| }, | |
| J : true | |
| }, | |
| src : { | |
| H : 2, | |
| J : false | |
| }, | |
| err : { | |
| H : 3, | |
| J : false | |
| }, | |
| styled_words : { | |
| H : 4, | |
| ya : function(obj) { | |
| return kl(mo, obj); | |
| }, | |
| xa : function(key) { | |
| return jl(new mo(key)); | |
| }, | |
| J : true | |
| }, | |
| alternative_translations : { | |
| H : 5, | |
| ya : function(obj) { | |
| return kl(io, obj); | |
| }, | |
| xa : function(a) { | |
| return jl(new io(a)); | |
| }, | |
| J : true | |
| }, | |
| confidence : { | |
| H : 6, | |
| J : false | |
| }, | |
| spell : { | |
| H : 7, | |
| ya : function(obj) { | |
| return kl(Ho, obj); | |
| }, | |
| xa : function(a) { | |
| return jl(new Ho(a)); | |
| }, | |
| J : false | |
| }, | |
| autocorrection : { | |
| H : 10, | |
| J : false | |
| }, | |
| ld_result : { | |
| H : 8, | |
| ya : function(obj) { | |
| return kl(Do, obj); | |
| }, | |
| xa : function(a) { | |
| return jl(new Do(a)); | |
| }, | |
| J : false | |
| }, | |
| server_time : { | |
| H : 9, | |
| J : false | |
| }, | |
| synsets : { | |
| H : 11, | |
| ya : function(obj) { | |
| return kl(Lo, obj); | |
| }, | |
| xa : function(a) { | |
| return jl(new Lo(a)); | |
| }, | |
| J : true | |
| }, | |
| definitions : { | |
| H : 12, | |
| ya : function(obj) { | |
| return kl(qo, obj); | |
| }, | |
| xa : function(a) { | |
| return jl(new qo(a)); | |
| }, | |
| J : true | |
| }, | |
| examples : { | |
| H : 13, | |
| ya : function(obj) { | |
| return kl(Po, obj); | |
| }, | |
| xa : function(a) { | |
| return jl(new Po(a)); | |
| }, | |
| J : false | |
| }, | |
| related_words : { | |
| H : 14, | |
| ya : function(obj) { | |
| return kl(Fo, obj); | |
| }, | |
| xa : function(a) { | |
| return jl(new Fo(a)); | |
| }, | |
| J : false | |
| }, | |
| knowledge_results : { | |
| H : 15, | |
| ya : function(obj) { | |
| return kl(Bo, obj); | |
| }, | |
| xa : function(a) { | |
| return jl(new Bo(a)); | |
| }, | |
| J : true | |
| }, | |
| query_inflections : { | |
| H : 16, | |
| ya : function(obj) { | |
| return kl(zo, obj); | |
| }, | |
| xa : function(a) { | |
| return jl(new zo(a)); | |
| }, | |
| J : true | |
| }, | |
| target_inflections : { | |
| H : 17, | |
| ya : function(obj) { | |
| return kl(zo, obj); | |
| }, | |
| xa : function(a) { | |
| return jl(new zo(a)); | |
| }, | |
| J : true | |
| }, | |
| gendered_translation_result : { | |
| H : 18, | |
| ya : function(obj) { | |
| return kl(Dl, obj); | |
| }, | |
| xa : function(options) { | |
| return jl(new Dl(options)); | |
| }, | |
| J : false | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Ro.prototype.a = function() { | |
| return So; | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| var To = function(value) { | |
| return new Ho(value.$a[7]); | |
| }; | |
| /** | |
| * @param {!Object} oldParentItem | |
| * @return {?} | |
| */ | |
| var Uo = function(oldParentItem) { | |
| return new Fo(oldParentItem.$a[14]); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Ro.prototype.sc = function() { | |
| return J(this, 0); | |
| }; | |
| /** | |
| * @param {number} id | |
| * @return {?} | |
| */ | |
| Ro.prototype.hb = function(id) { | |
| return new zl(hl(this, 0, id)); | |
| }; | |
| /** | |
| * @param {!Object} k | |
| * @param {number} i | |
| * @return {?} | |
| */ | |
| var ch = function(k, i) { | |
| return new uo(hl(k, 1, i)); | |
| }; | |
| /** | |
| * @param {!Object} code | |
| * @param {number} key | |
| * @return {?} | |
| */ | |
| var Vo = function(code, key) { | |
| return new io(hl(code, 5, key)); | |
| }; | |
| /** | |
| * @param {number} l | |
| * @param {number} a | |
| * @return {undefined} | |
| */ | |
| var Wo = function(l, a) { | |
| /** @type {number} */ | |
| this.b = l; | |
| /** @type {string} */ | |
| this.a = ""; | |
| if (a) { | |
| /** @type {number} */ | |
| this.a = a; | |
| } | |
| /** @type {number} */ | |
| this.c = 0; | |
| this.F = M.N(); | |
| }; | |
| /** | |
| * @param {number} fn | |
| * @return {?} | |
| */ | |
| var Xo = function(fn) { | |
| fn = fn.bc("q").join(""); | |
| return co(fn); | |
| }; | |
| /** | |
| * @param {!Object} s | |
| * @param {string} prefix | |
| * @param {string} result | |
| * @param {number} key | |
| * @param {!Object} e | |
| * @param {number} prop | |
| * @return {?} | |
| */ | |
| var Yo = function(s, prefix, result, key, e, prop) { | |
| result = result.toString(); | |
| result = result + Xo(key); | |
| key = key.toString(); | |
| /** @type {string} */ | |
| var method = "POST"; | |
| /** @type {string} */ | |
| prefix = prefix + ("?" + result); | |
| if (2E3 > prefix.length + key.length) { | |
| /** @type {string} */ | |
| method = "GET"; | |
| /** @type {string} */ | |
| prefix = prefix + ("&" + key); | |
| /** @type {string} */ | |
| key = ""; | |
| } | |
| ++s.c; | |
| return vj(prefix, function(context) { | |
| --s.c; | |
| e(context); | |
| }, method, key, void 0, prop); | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @param {string} type | |
| * @param {!Object} actual | |
| * @param {!Object} key | |
| * @param {!Object} props | |
| * @param {?} attrs | |
| * @param {!Object} option | |
| * @param {!Array} target | |
| * @param {number} m | |
| * @return {?} | |
| */ | |
| var Zo = function(value, type, actual, key, props, attrs, option, target, m) { | |
| /** @type {string} */ | |
| var table_id_prefix = value.a + "/translate_a/t"; | |
| var _ = new Am; | |
| var fn = new Am; | |
| _.set("client", value.b); | |
| _.set("sl", type); | |
| _.set("tl", actual); | |
| _.set("hl", key); | |
| _.set("v", "1.0"); | |
| if (null != option) { | |
| _.set("source", option); | |
| } | |
| if (target) { | |
| _.g(target); | |
| } | |
| if (type = !Ka(props) || Ka(props) && 1 == props.length) { | |
| fn.set("q", props); | |
| } else { | |
| Im(fn, "q", props); | |
| } | |
| props = v(value.h, value, type, attrs); | |
| return Yo(value, table_id_prefix, _, fn, props, m); | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @param {!Object} url | |
| * @param {!Object} response | |
| * @param {string} f | |
| * @return {undefined} | |
| */ | |
| var $o = function(value, url, response, f) { | |
| var self = new Am; | |
| var data = new Am; | |
| self.set("client", value.b); | |
| self.set("sl", response); | |
| /** @type {string} */ | |
| response = value.a + "/translate_a/single"; | |
| self.set("dt", "rm"); | |
| data.set("q", url); | |
| Yo(value, response, self, data, v(value.o, value, f), void 0); | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @param {!Object} target | |
| * @param {!Object} args | |
| * @param {!Object} m | |
| * @param {!Object} fn | |
| * @param {!Object} xs | |
| * @param {string} f | |
| * @param {!Object} name | |
| * @param {!Array} s | |
| * @param {!Object} min | |
| * @param {?} value | |
| * @return {undefined} | |
| */ | |
| var ap = function(data, target, args, m, fn, xs, f, name, s, min, value) { | |
| /** @type {string} */ | |
| var table_id_prefix = data.a + "/translate_a/single"; | |
| var self = new Am; | |
| var newSession = new Am; | |
| self.set("client", data.b); | |
| self.set("sl", target); | |
| self.set("tl", args); | |
| self.set("hl", m); | |
| Im(self, "dt", xs); | |
| if (null != name) { | |
| self.set("ie", name); | |
| self.set("oe", name); | |
| } | |
| if (min) { | |
| self.set("dj", "1"); | |
| } | |
| if (s) { | |
| self.g(s); | |
| } | |
| newSession.set("q", fn); | |
| Yo(data, table_id_prefix, self, newSession, v(data.g, data, f, value), void 0); | |
| }; | |
| /** | |
| * @param {!Object} args | |
| * @param {string} fn | |
| * @param {!Object} name | |
| * @param {!Object} src | |
| * @param {!Array} opts | |
| * @param {string} version | |
| * @param {boolean} res | |
| * @param {!Object} encoding | |
| * @param {!Object} val | |
| * @param {?} dest | |
| * @return {undefined} | |
| */ | |
| var bp = function(args, fn, name, src, opts, version, res, encoding, val, dest) { | |
| /** @type {!Array<string>} */ | |
| var array = "at bd ex ld md qc rw rm ss t".split(" "); | |
| if (res) { | |
| /** @type {!Array<string>} */ | |
| array = "at bd ex ld md qca rw rm ss t".split(" "); | |
| } | |
| if (Un) { | |
| array.push("kr"); | |
| } | |
| if (Wn && Xn[name] && (Xn[name][fn] || "auto" === fn)) { | |
| array.push("gt"); | |
| } | |
| ap(args, fn, name, src, opts, array, version, encoding, val, void 0, dest); | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| Wo.prototype.o = function(type, value) { | |
| value = value.target; | |
| if (cp(value)) { | |
| value = dp(value, "handleTransliterationResult_"); | |
| value = new Ro(value); | |
| if (0 < value.sc()) { | |
| type(K(value.hb(0), 3)); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @param {string} value | |
| * @param {!Object} data | |
| * @return {undefined} | |
| */ | |
| Wo.prototype.g = function(name, value, data) { | |
| data = data.target; | |
| if (cp(data)) { | |
| value = dp(data, "handleSingleResult_"); | |
| if (Ka(value)) { | |
| value = new Ro(value); | |
| } | |
| name(value); | |
| } else { | |
| ep(this, data); | |
| if (value) { | |
| value(data.cd()); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @param {string} value | |
| * @param {!Object} item | |
| * @return {undefined} | |
| */ | |
| Wo.prototype.h = function(type, value, item) { | |
| item = item.target; | |
| if (Ej(item)) { | |
| item = dp(item, "handleTextResult_"); | |
| /** @type {!Array} */ | |
| var result = []; | |
| if (type) { | |
| result.push(Ka(item) ? item[0] : item); | |
| } else { | |
| if (Ka(item)) { | |
| /** @type {number} */ | |
| type = 0; | |
| for (; type < item.length; ++type) { | |
| result.push(Ka(item[type]) ? item[type][0] : item[type]); | |
| } | |
| } | |
| } | |
| value(result); | |
| } else { | |
| ep(this, item); | |
| value(null, item.Rd); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} b | |
| * @return {?} | |
| */ | |
| var dp = function(a, b) { | |
| return Zn(Fj(a), { | |
| "class" : "trans.common.TranslationAPI", | |
| func : b, | |
| url : String(a.ve) | |
| }); | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @return {?} | |
| */ | |
| var cp = function(data) { | |
| return Ej(data) && ("[" == Fj(data)[0] || "{" == Fj(data)[0]); | |
| }; | |
| var fp = {}; | |
| var gp = (fp[1] = 15, fp[2] = 16, fp[3] = 17, fp[4] = 18, fp[5] = 19, fp[6] = 20, fp[7] = 21, fp[8] = 22, fp[9] = 23, fp); | |
| /** | |
| * @param {!Object} api | |
| * @param {!Object} item | |
| * @return {undefined} | |
| */ | |
| var ep = function(api, item) { | |
| var p = item.Rd; | |
| Ol(api.F, 156, p in gp ? gp[p] : 0); | |
| api = hm.N(); | |
| /** @type {string} */ | |
| p = String(item.ve); | |
| item = Fj(item); | |
| api.log("invalidResponse", { | |
| q : p.substring(0, 500), | |
| ql : p.length, | |
| r : item.substring(0, 500), | |
| rl : item.length | |
| }); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Wo.prototype.m = function() { | |
| return this.c; | |
| }; | |
| var hp; | |
| var ip = { | |
| Xp : "activedescendant", | |
| bq : "atomic", | |
| cq : "autocomplete", | |
| fq : "busy", | |
| iq : "checked", | |
| jq : "colindex", | |
| oq : "controls", | |
| qq : "describedby", | |
| uq : "disabled", | |
| wq : "dropeffect", | |
| xq : "expanded", | |
| yq : "flowto", | |
| Bq : "grabbed", | |
| Fq : "haspopup", | |
| Hq : "hidden", | |
| Jq : "invalid", | |
| Lq : "label", | |
| Mq : "labelledby", | |
| Nq : "level", | |
| Tq : "live", | |
| lr : "multiline", | |
| nr : "multiselectable", | |
| vr : "orientation", | |
| wr : "owns", | |
| yr : "posinset", | |
| Ar : "pressed", | |
| Er : "readonly", | |
| Gr : "relevant", | |
| Hr : "required", | |
| Lr : "rowindex", | |
| Or : "selected", | |
| Qr : "setsize", | |
| SORT : "sort", | |
| ls : "valuemax", | |
| ns : "valuemin", | |
| os : "valuenow", | |
| qs : "valuetext" | |
| }; | |
| var jp = { | |
| Yp : "alert", | |
| Zp : "alertdialog", | |
| $p : "application", | |
| aq : "article", | |
| eq : "banner", | |
| gq : "button", | |
| hq : "checkbox", | |
| kq : "columnheader", | |
| lq : "combobox", | |
| mq : "complementary", | |
| nq : "contentinfo", | |
| pq : "definition", | |
| rq : "dialog", | |
| tq : "directory", | |
| vq : "document", | |
| zq : "form", | |
| Cq : "grid", | |
| Dq : "gridcell", | |
| Eq : "group", | |
| Gq : "heading", | |
| Iq : "img", | |
| Oq : "link", | |
| Qq : "list", | |
| Rq : "listbox", | |
| Sq : "listitem", | |
| Uq : "log", | |
| Vq : "main", | |
| Wq : "marquee", | |
| Xq : "math", | |
| Yq : "menu", | |
| Zq : "menubar", | |
| $q : "menuitem", | |
| cr : "menuitemcheckbox", | |
| dr : "menuitemradio", | |
| pr : "navigation", | |
| qr : "note", | |
| rr : "option", | |
| zr : "presentation", | |
| Br : "progressbar", | |
| Cr : "radio", | |
| Dr : "radiogroup", | |
| Fr : "region", | |
| Ir : "row", | |
| Jr : "rowgroup", | |
| Kr : "rowheader", | |
| Mr : "scrollbar", | |
| Nr : "search", | |
| Pr : "separator", | |
| Rr : "slider", | |
| Sr : "spinbutton", | |
| Tr : "status", | |
| Ur : "tab", | |
| Vr : "tablist", | |
| Wr : "tabpanel", | |
| Xr : "textbox", | |
| Yr : "textinfo", | |
| Zr : "timer", | |
| $r : "toolbar", | |
| fs : "tooltip", | |
| gs : "tree", | |
| hs : "treegrid", | |
| ks : "treeitem" | |
| }; | |
| Zb("A AREA BUTTON HEAD INPUT LINK MENU META OPTGROUP OPTION PROGRESS STYLE SELECT SOURCE TEXTAREA TITLE TRACK".split(" ")); | |
| /** @type {!Array<string>} */ | |
| var kp = "combobox grid group listbox menu menubar radiogroup row rowgroup tablist textbox toolbar tree treegrid".split(" "); | |
| /** | |
| * @param {!Object} o | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| var lp = function(o, value) { | |
| if (value) { | |
| z(Rb(jp, value), "No such ARIA role " + value); | |
| o.setAttribute("role", value); | |
| } else { | |
| o.removeAttribute("role"); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} s | |
| * @param {string} name | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| var np = function(s, name, value) { | |
| if (Ka(value)) { | |
| value = value.join(" "); | |
| } | |
| var match = mp(name); | |
| if ("" === value || void 0 == value) { | |
| if (!hp) { | |
| hp = { | |
| atomic : false, | |
| autocomplete : "none", | |
| dropeffect : "none", | |
| haspopup : false, | |
| live : "off", | |
| multiline : false, | |
| multiselectable : false, | |
| orientation : "vertical", | |
| readonly : false, | |
| relevant : "additions text", | |
| required : false, | |
| sort : "none", | |
| busy : false, | |
| disabled : false, | |
| hidden : false, | |
| invalid : "false" | |
| }; | |
| } | |
| value = hp; | |
| if (name in value) { | |
| s.setAttribute(match, value[name]); | |
| } else { | |
| s.removeAttribute(match); | |
| } | |
| } else { | |
| s.setAttribute(match, value); | |
| } | |
| }; | |
| /** | |
| * @param {string} val | |
| * @param {string} key | |
| * @return {?} | |
| */ | |
| var op = function(val, key) { | |
| val = val.getAttribute(mp(key)); | |
| return null == val || void 0 == val ? "" : String(val); | |
| }; | |
| /** | |
| * @param {string} node | |
| * @return {?} | |
| */ | |
| var pp = function(node) { | |
| var value = op(node, "activedescendant"); | |
| return hf(node).getElementById(value); | |
| }; | |
| /** | |
| * @param {!Object} arr | |
| * @param {string} str | |
| * @return {undefined} | |
| */ | |
| var qp = function(arr, str) { | |
| /** @type {string} */ | |
| var p = ""; | |
| if (str) { | |
| p = str.id; | |
| z(p, "The active element should have an id."); | |
| } | |
| np(arr, "activedescendant", p); | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| var rp = function(obj, name) { | |
| np(obj, "label", name); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| var mp = function(name) { | |
| z(name, "ARIA attribute cannot be empty."); | |
| z(Rb(ip, name), "No such ARIA attribute " + name); | |
| return "aria-" + name; | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| var sp = function(value) { | |
| if (value.classList) { | |
| return value.classList; | |
| } | |
| value = value.className; | |
| return r(value) && value.match(/\S+/g) || []; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} c | |
| * @return {?} | |
| */ | |
| var tp = function(a, c) { | |
| return a.classList ? a.classList.contains(c) : tb(sp(a), c); | |
| }; | |
| /** | |
| * @param {!Object} text | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| var T = function(text, name) { | |
| if (text.classList) { | |
| text.classList.add(name); | |
| } else { | |
| if (!tp(text, name)) { | |
| text.className += 0 < text.className.length ? " " + name : name; | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @param {!Array} x | |
| * @return {undefined} | |
| */ | |
| var up = function(e, x) { | |
| if (e.classList) { | |
| A(x, function(skeletonId) { | |
| T(e, skeletonId); | |
| }); | |
| } else { | |
| var aggregates = {}; | |
| A(sp(e), function(summaryIndex) { | |
| /** @type {boolean} */ | |
| aggregates[summaryIndex] = true; | |
| }); | |
| A(x, function(summaryIndex) { | |
| /** @type {boolean} */ | |
| aggregates[summaryIndex] = true; | |
| }); | |
| /** @type {string} */ | |
| e.className = ""; | |
| var className; | |
| for (className in aggregates) { | |
| e.className += 0 < e.className.length ? " " + className : className; | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} x | |
| * @param {string} type | |
| * @return {undefined} | |
| */ | |
| var U = function(x, type) { | |
| if (x.classList) { | |
| x.classList.remove(type); | |
| } else { | |
| if (tp(x, type)) { | |
| x.className = lb(sp(x), function(name) { | |
| return name != type; | |
| }).join(" "); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} val | |
| * @param {!Array} file | |
| * @return {undefined} | |
| */ | |
| var vp = function(val, file) { | |
| if (val.classList) { | |
| A(file, function(unbindFinished) { | |
| U(val, unbindFinished); | |
| }); | |
| } else { | |
| val.className = lb(sp(val), function(new_tuple) { | |
| return !tb(file, new_tuple); | |
| }).join(" "); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @param {string} name | |
| * @param {string} x | |
| * @return {undefined} | |
| */ | |
| var V = function(item, name, x) { | |
| if (x) { | |
| T(item, name); | |
| } else { | |
| U(item, name); | |
| } | |
| }; | |
| /** | |
| * @param {string} id | |
| * @param {string} p | |
| * @param {?} callback | |
| * @return {undefined} | |
| */ | |
| var yp = function(id, p, callback) { | |
| z(p, "Soy template may not be null."); | |
| p = wp(p(callback || xp, void 0, void 0)); | |
| Vd(z(id), p); | |
| }; | |
| /** | |
| * @param {!Function} p | |
| * @param {?} sx | |
| * @return {?} | |
| */ | |
| var Ap = function(p, sx) { | |
| z(p, "Soy template may not be null."); | |
| var clonedI = jf(); | |
| p = p(sx || xp, void 0, void 0); | |
| p = wp(p); | |
| zp(p.Db()); | |
| return Bf(clonedI.a, p); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @param {?} cols | |
| * @param {string} options | |
| * @param {!Object} block | |
| * @return {?} | |
| */ | |
| var Bp = function(name, cols, options, block) { | |
| z(name, "Soy template may not be null."); | |
| name = name(cols || xp, void 0, options); | |
| block = fg(block || jf(), "DIV"); | |
| name = wp(name); | |
| zp(name.Db()); | |
| Vd(block, name); | |
| if (1 == block.childNodes.length) { | |
| name = block.firstChild; | |
| if (1 == name.nodeType) { | |
| /** @type {string} */ | |
| block = name; | |
| } | |
| } | |
| return block; | |
| }; | |
| /** | |
| * @param {string} src | |
| * @return {?} | |
| */ | |
| var wp = function(src) { | |
| if (!Na(src)) { | |
| return Fd(String(src)); | |
| } | |
| if (src instanceof Xm) { | |
| return Ym(src); | |
| } | |
| Za("Soy template output is unsafe for use as HTML: " + src); | |
| return Fd("zSoyz"); | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var zp = function(a) { | |
| var arr = a.match(Cp); | |
| z(!arr, "This template starts with a %s, which cannot be a child of a <div>, as required by soy internals. Consider using goog.soy.renderElement instead.\nTemplate output: %s", arr && arr[0], a); | |
| }; | |
| /** @type {!RegExp} */ | |
| var Cp = /^<(body|caption|col|colgroup|head|html|tr|td|th|tbody|thead|tfoot)>/i; | |
| var xp = {}; | |
| /** | |
| * @param {number} left1 | |
| * @param {number} right1 | |
| * @param {number} b | |
| * @param {number} margin | |
| * @return {undefined} | |
| */ | |
| var Dp = 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; | |
| }; | |
| k = Dp.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| k.toString = function() { | |
| return "(" + this.top + "t, " + this.right + "r, " + this.bottom + "b, " + this.left + "l)"; | |
| }; | |
| /** | |
| * @param {!Object} other | |
| * @return {?} | |
| */ | |
| k.contains = function(other) { | |
| return this && other ? other instanceof Dp ? 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.a >= this.top && other.a <= this.bottom : false; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.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 {?} | |
| */ | |
| k.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 {?} | |
| */ | |
| k.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 Ep = 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; | |
| }; | |
| /** | |
| * @param {!Object} bou_Pos | |
| * @return {?} | |
| */ | |
| var Fp = function(bou_Pos) { | |
| return new Dp(bou_Pos.top, bou_Pos.left + bou_Pos.width, bou_Pos.top + bou_Pos.height, bou_Pos.left); | |
| }; | |
| k = Ep.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| k.toString = function() { | |
| return "(" + this.left + ", " + this.top + " - " + this.width + "w x " + this.height + "h)"; | |
| }; | |
| /** | |
| * @param {!Object} other | |
| * @return {?} | |
| */ | |
| k.contains = function(other) { | |
| return other instanceof cf ? other.x >= this.left && other.x <= this.left + this.width && other.a >= this.top && other.a <= this.top + this.height : this.left <= other.left && this.left + this.width >= other.left + other.width && this.top <= other.top && this.top + this.height >= other.top + other.height; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.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 {?} | |
| */ | |
| k.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 {?} | |
| */ | |
| k.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 {!Object} obj | |
| * @param {string} name | |
| * @param {!Object} val | |
| * @return {undefined} | |
| */ | |
| var Hp = function(obj, name, val) { | |
| if (r(name)) { | |
| if (name = Gp(obj, name)) { | |
| /** @type {!Object} */ | |
| obj.style[name] = val; | |
| } | |
| } else { | |
| var key; | |
| for (key in name) { | |
| /** @type {!Object} */ | |
| val = obj; | |
| var state = name[key]; | |
| var k = Gp(val, key); | |
| if (k) { | |
| val.style[k] = state; | |
| } | |
| } | |
| } | |
| }; | |
| var Ip = {}; | |
| /** | |
| * @param {!Object} target | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| var Gp = function(target, name) { | |
| var prev = Ip[name]; | |
| if (!prev) { | |
| var k = pe(name); | |
| prev = k; | |
| if (void 0 === target.style[k]) { | |
| k = (C.Ka ? "Webkit" : C.Ja ? "Moz" : C.V ? "ms" : C.cb ? "O" : null) + qe(k); | |
| if (void 0 !== target.style[k]) { | |
| prev = k; | |
| } | |
| } | |
| Ip[name] = prev; | |
| } | |
| return prev; | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @param {string} prop | |
| * @return {?} | |
| */ | |
| var Jp = function(b, prop) { | |
| var d = hf(b); | |
| return d.defaultView && d.defaultView.getComputedStyle && (b = d.defaultView.getComputedStyle(b, null)) ? b[prop] || b.getPropertyValue(prop) || "" : ""; | |
| }; | |
| /** | |
| * @param {!Object} el | |
| * @param {string} property | |
| * @return {?} | |
| */ | |
| var Kp = function(el, property) { | |
| return el.currentStyle ? el.currentStyle[property] : null; | |
| }; | |
| /** | |
| * @param {!Object} el | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| var Lp = function(el, name) { | |
| return Jp(el, name) || Kp(el, name) || el.style && el.style[name]; | |
| }; | |
| /** | |
| * @param {!Object} img | |
| * @param {!Object} a | |
| * @param {number} b | |
| * @return {undefined} | |
| */ | |
| var Np = function(img, a, b) { | |
| if (a instanceof cf) { | |
| var l = a.x; | |
| a = a.a; | |
| } else { | |
| /** @type {!Object} */ | |
| l = a; | |
| /** @type {number} */ | |
| a = b; | |
| } | |
| img.style.left = Mp(l, false); | |
| img.style.top = Mp(a, false); | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @return {?} | |
| */ | |
| var Op = function(node) { | |
| node = node ? hf(node) : document; | |
| return !C.V || C.kb(9) || rf(jf(node).a) ? node.documentElement : node.body; | |
| }; | |
| /** | |
| * @param {!Object} d | |
| * @return {?} | |
| */ | |
| var Pp = function(d) { | |
| var b = d.body; | |
| d = d.documentElement; | |
| return new cf(b.scrollLeft || d.scrollLeft, b.scrollTop || d.scrollTop); | |
| }; | |
| /** | |
| * @param {!Object} element | |
| * @return {?} | |
| */ | |
| var Qp = function(element) { | |
| try { | |
| var anchorBoundingBoxViewport = element.getBoundingClientRect(); | |
| } catch (c) { | |
| return { | |
| left : 0, | |
| top : 0, | |
| right : 0, | |
| bottom : 0 | |
| }; | |
| } | |
| if (C.V && 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 {!Element} element | |
| * @return {?} | |
| */ | |
| var Rp = function(element) { | |
| if (C.V && !C.kb(8)) { | |
| return z(element && "offsetParent" in element), element.offsetParent; | |
| } | |
| var document = hf(element); | |
| var value = Lp(element, "position"); | |
| /** @type {boolean} */ | |
| var nearest = "fixed" == value || "absolute" == value; | |
| element = element.parentNode; | |
| for (; element && element != document; element = element.parentNode) { | |
| if (11 == element.nodeType && element.host && (element = element.host), value = Lp(element, "position"), nearest = nearest && "static" == value && element != document.documentElement && element != document.body, !nearest && (element.scrollWidth > element.clientWidth || element.scrollHeight > element.clientHeight || "fixed" == value || "absolute" == value || "relative" == value)) { | |
| return element; | |
| } | |
| } | |
| return null; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {?} | |
| */ | |
| var Tp = function(a) { | |
| var visibleRect = new Dp(0, Infinity, Infinity, 0); | |
| var d = jf(a); | |
| var x = d.a.body; | |
| var b = d.a.documentElement; | |
| var offset = tf(d.a); | |
| for (; a = Rp(a);) { | |
| if (!(C.V && 0 == a.clientWidth || C.Ka && 0 == a.clientHeight && a == x) && a != x && a != b && "visible" != Lp(a, "overflow")) { | |
| var t = Sp(a); | |
| var p = new cf(a.clientLeft, a.clientTop); | |
| t.x += p.x; | |
| t.a += p.a; | |
| /** @type {number} */ | |
| visibleRect.top = Math.max(visibleRect.top, t.a); | |
| /** @type {number} */ | |
| visibleRect.right = Math.min(visibleRect.right, t.x + a.clientWidth); | |
| /** @type {number} */ | |
| visibleRect.bottom = Math.min(visibleRect.bottom, t.a + a.clientHeight); | |
| /** @type {number} */ | |
| visibleRect.left = Math.max(visibleRect.left, t.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); | |
| d = sf(gg(d) || window); | |
| /** @type {number} */ | |
| visibleRect.right = Math.min(visibleRect.right, x + d.width); | |
| /** @type {number} */ | |
| visibleRect.bottom = Math.min(visibleRect.bottom, offset + d.height); | |
| return 0 <= visibleRect.top && 0 <= visibleRect.left && visibleRect.bottom > visibleRect.top && visibleRect.right > visibleRect.left ? visibleRect : null; | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @param {!Object} data | |
| * @return {undefined} | |
| */ | |
| var Wp = function(item, data) { | |
| data = data || tf(document); | |
| var c = data || tf(document); | |
| var p = Sp(item); | |
| var a = Sp(c); | |
| var x = Up(c); | |
| if (c == tf(document)) { | |
| /** @type {number} */ | |
| var i = p.x - c.scrollLeft; | |
| /** @type {number} */ | |
| p = p.a - c.scrollTop; | |
| if (C.V && !C.kb(10)) { | |
| i = i + x.left; | |
| p = p + x.top; | |
| } | |
| } else { | |
| /** @type {number} */ | |
| i = p.x - a.x - x.left; | |
| /** @type {number} */ | |
| p = p.a - a.a - x.top; | |
| } | |
| item = Vp(item); | |
| /** @type {number} */ | |
| x = c.clientHeight - item.height; | |
| a = c.scrollLeft; | |
| var y = c.scrollTop; | |
| a = a + Math.min(i, Math.max(i - (c.clientWidth - item.width), 0)); | |
| y = y + Math.min(p, Math.max(p - x, 0)); | |
| c = new cf(a, y); | |
| data.scrollLeft = c.x; | |
| data.scrollTop = c.a; | |
| }; | |
| /** | |
| * @param {!Object} v | |
| * @return {?} | |
| */ | |
| var Sp = function(v) { | |
| var a = hf(v); | |
| db(v, "Parameter is required"); | |
| var outsetMap = new cf(0, 0); | |
| var win = Op(a); | |
| if (v == win) { | |
| return outsetMap; | |
| } | |
| v = Qp(v); | |
| a = uf(jf(a).a); | |
| outsetMap.x = v.left + a.x; | |
| outsetMap.a = v.top + a.a; | |
| return outsetMap; | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var Yp = function(b, a) { | |
| b = Xp(b); | |
| a = Xp(a); | |
| return new cf(b.x - a.x, b.a - a.a); | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @return {?} | |
| */ | |
| var Zp = function(e) { | |
| e = Qp(e); | |
| return new cf(e.left, e.top); | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @return {?} | |
| */ | |
| var Xp = function(e) { | |
| z(e); | |
| if (1 == e.nodeType) { | |
| return Zp(e); | |
| } | |
| e = e.changedTouches ? e.changedTouches[0] : e; | |
| return new cf(e.clientX, e.clientY); | |
| }; | |
| /** | |
| * @param {!Element} s | |
| * @param {!Object} v | |
| * @param {number} value | |
| * @return {undefined} | |
| */ | |
| var $p = function(s, v, value) { | |
| if (v instanceof ff) { | |
| value = v.height; | |
| v = v.width; | |
| } else { | |
| if (void 0 == value) { | |
| throw Error("missing height argument"); | |
| } | |
| } | |
| s.style.width = Mp(v, true); | |
| s.style.height = Mp(value, true); | |
| }; | |
| /** | |
| * @param {!Object} c | |
| * @param {string} isFirst | |
| * @return {?} | |
| */ | |
| var Mp = function(c, isFirst) { | |
| if ("number" == typeof c) { | |
| /** @type {string} */ | |
| c = (isFirst ? Math.round(c) : c) + "px"; | |
| } | |
| return c; | |
| }; | |
| /** | |
| * @param {!Object} element | |
| * @return {?} | |
| */ | |
| var aq = function(element) { | |
| /** @type {function(!Object): ?} */ | |
| var _getNativeElement = Vp; | |
| if ("none" != Lp(element, "display")) { | |
| return _getNativeElement(element); | |
| } | |
| var style = element.style; | |
| var oldDisplay = style.display; | |
| var oldVis = style.visibility; | |
| var oPos = style.position; | |
| /** @type {string} */ | |
| style.visibility = "hidden"; | |
| /** @type {string} */ | |
| style.position = "absolute"; | |
| /** @type {string} */ | |
| style.display = "inline"; | |
| element = _getNativeElement(element); | |
| style.display = oldDisplay; | |
| style.position = oPos; | |
| style.visibility = oldVis; | |
| return element; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var Vp = function(a) { | |
| var b = a.offsetWidth; | |
| var liHeight = a.offsetHeight; | |
| var matched = C.Ka && !b && !liHeight; | |
| return q(b) && !matched || !a.getBoundingClientRect ? new ff(b, liHeight) : (a = Qp(a), new ff(a.right - a.left, a.bottom - a.top)); | |
| }; | |
| /** | |
| * @param {!Object} v | |
| * @return {?} | |
| */ | |
| var bq = function(v) { | |
| var foo = Sp(v); | |
| v = aq(v); | |
| return new Ep(foo.x, foo.a, v.width, v.height); | |
| }; | |
| /** | |
| * @param {!Object} style | |
| * @param {(number|string)} value | |
| * @return {undefined} | |
| */ | |
| var cq = function(style, value) { | |
| z(style); | |
| style = style.style; | |
| if ("opacity" in style) { | |
| /** @type {(number|string)} */ | |
| style.opacity = value; | |
| } else { | |
| if ("MozOpacity" in style) { | |
| /** @type {(number|string)} */ | |
| style.MozOpacity = value; | |
| } else { | |
| if ("filter" in style) { | |
| /** @type {string} */ | |
| style.filter = "" === value ? "" : "alpha(opacity=" + 100 * Number(value) + ")"; | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {boolean} b | |
| * @return {undefined} | |
| */ | |
| var X = function(a, b) { | |
| /** @type {string} */ | |
| a.style.display = b ? "" : "none"; | |
| }; | |
| /** | |
| * @param {!Element} selector | |
| * @return {?} | |
| */ | |
| var dq = function(selector) { | |
| return "none" != selector.style.display; | |
| }; | |
| /** | |
| * @param {string} value | |
| * @return {?} | |
| */ | |
| var fq = function(value) { | |
| var node = jf(void 0); | |
| var body = node.a; | |
| if (C.V && body.createStyleSheet) { | |
| return node = body.createStyleSheet(), eq(node, value), node; | |
| } | |
| body = mf(node.a, "HEAD", void 0, void 0)[0]; | |
| if (!body) { | |
| var e = mf(node.a, "BODY", void 0, void 0)[0]; | |
| body = node.b("HEAD"); | |
| e.parentNode.insertBefore(body, e); | |
| } | |
| e = node.b("STYLE"); | |
| eq(e, value); | |
| node.appendChild(body, e); | |
| return e; | |
| }; | |
| /** | |
| * @param {(Element|StyleSheet)} b | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var eq = function(b, a) { | |
| a = qd(a); | |
| if (C.V && q(b.cssText)) { | |
| /** @type {string} */ | |
| b.cssText = a; | |
| } else { | |
| /** @type {string} */ | |
| b.innerHTML = a; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} el | |
| * @return {?} | |
| */ | |
| var gq = function(el) { | |
| return "rtl" == Lp(el, "direction"); | |
| }; | |
| /** @type {(null|string)} */ | |
| var hq = C.Ja ? "MozUserSelect" : C.Ka || C.vb ? "WebkitUserSelect" : null; | |
| /** | |
| * @param {!Object} elem | |
| * @param {boolean} value | |
| * @param {!Function} query | |
| * @return {undefined} | |
| */ | |
| var iq = function(elem, value, query) { | |
| query = query ? null : elem.getElementsByTagName("*"); | |
| if (hq) { | |
| if (value = value ? "none" : "", elem.style && (elem.style[hq] = value), query) { | |
| /** @type {number} */ | |
| elem = 0; | |
| var node; | |
| for (; node = query[elem]; elem++) { | |
| if (node.style) { | |
| /** @type {boolean} */ | |
| node.style[hq] = value; | |
| } | |
| } | |
| } | |
| } else { | |
| if (C.V || C.cb) { | |
| if (value = value ? "on" : "", elem.setAttribute("unselectable", value), query) { | |
| /** @type {number} */ | |
| elem = 0; | |
| for (; node = query[elem]; elem++) { | |
| node.setAttribute("unselectable", value); | |
| } | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} style | |
| * @param {!Object} el | |
| * @param {string} boxSizing | |
| * @return {undefined} | |
| */ | |
| var jq = function(style, el, boxSizing) { | |
| style = style.style; | |
| if (C.Ja) { | |
| /** @type {string} */ | |
| style.MozBoxSizing = boxSizing; | |
| } else { | |
| if (C.Ka) { | |
| /** @type {string} */ | |
| style.WebkitBoxSizing = boxSizing; | |
| } else { | |
| /** @type {string} */ | |
| style.boxSizing = boxSizing; | |
| } | |
| } | |
| /** @type {string} */ | |
| style.width = Math.max(el.width, 0) + "px"; | |
| /** @type {string} */ | |
| style.height = Math.max(el.height, 0) + "px"; | |
| }; | |
| /** | |
| * @param {!Node} elem | |
| * @param {string} value | |
| * @param {string} propertyName | |
| * @param {string} prop | |
| * @return {?} | |
| */ | |
| var kq = function(elem, value, propertyName, prop) { | |
| if (/^\d+px?$/.test(value)) { | |
| return parseInt(value, 10); | |
| } | |
| var propertyMethodPostfix = elem.style[propertyName]; | |
| var componentPropertyValue = elem.runtimeStyle[propertyName]; | |
| elem.runtimeStyle[propertyName] = elem.currentStyle[propertyName]; | |
| /** @type {string} */ | |
| elem.style[propertyName] = value; | |
| value = elem.style[prop]; | |
| elem.style[propertyName] = propertyMethodPostfix; | |
| elem.runtimeStyle[propertyName] = componentPropertyValue; | |
| return +value; | |
| }; | |
| /** | |
| * @param {!Array} v | |
| * @param {string} o | |
| * @return {?} | |
| */ | |
| var lq = function(v, o) { | |
| return (o = Kp(v, o)) ? kq(v, o, "left", "pixelLeft") : 0; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} b | |
| * @return {?} | |
| */ | |
| var mq = function(a, b) { | |
| if (C.V) { | |
| var c = lq(a, b + "Left"); | |
| var d = lq(a, b + "Right"); | |
| var fltScore = lq(a, b + "Top"); | |
| a = lq(a, b + "Bottom"); | |
| return new Dp(fltScore, d, a, c); | |
| } | |
| c = Jp(a, b + "Left"); | |
| d = Jp(a, b + "Right"); | |
| fltScore = Jp(a, b + "Top"); | |
| a = Jp(a, b + "Bottom"); | |
| return new Dp(parseFloat(fltScore), parseFloat(d), parseFloat(a), parseFloat(c)); | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {?} | |
| */ | |
| var nq = function(name) { | |
| return mq(name, "padding"); | |
| }; | |
| var oq = { | |
| thin : 2, | |
| medium : 4, | |
| thick : 6 | |
| }; | |
| /** | |
| * @param {!Array} style | |
| * @param {string} prop | |
| * @return {?} | |
| */ | |
| var pq = function(style, prop) { | |
| if ("none" == Kp(style, prop + "Style")) { | |
| return 0; | |
| } | |
| prop = Kp(style, prop + "Width"); | |
| return prop in oq ? oq[prop] : kq(style, prop, "left", "pixelLeft"); | |
| }; | |
| /** | |
| * @param {!Array} x | |
| * @return {?} | |
| */ | |
| var Up = function(x) { | |
| if (C.V && !C.kb(9)) { | |
| var left = pq(x, "borderLeft"); | |
| var right = pq(x, "borderRight"); | |
| var top = pq(x, "borderTop"); | |
| x = pq(x, "borderBottom"); | |
| return new Dp(top, right, x, left); | |
| } | |
| left = Jp(x, "borderLeftWidth"); | |
| right = Jp(x, "borderRightWidth"); | |
| top = Jp(x, "borderTopWidth"); | |
| x = Jp(x, "borderBottomWidth"); | |
| return new Dp(parseFloat(top), parseFloat(right), parseFloat(x), parseFloat(left)); | |
| }; | |
| /** | |
| * @param {string} url | |
| * @return {?} | |
| */ | |
| var qq = function(url) { | |
| var reverseItemData = {}; | |
| A(url.split(/\s*;\s*/), function(c) { | |
| if (c = c.match(/\s*([\w-]+)\s*:(.+)/)) { | |
| var updatedReverseItemControlData = zc(c[2]); | |
| reverseItemData[pe(c[1].toLowerCase())] = updatedReverseItemControlData; | |
| } | |
| }); | |
| return reverseItemData; | |
| }; | |
| /** | |
| * @param {!Array} val | |
| * @return {undefined} | |
| */ | |
| var rq = function(val) { | |
| hg.call(this); | |
| /** @type {!Array} */ | |
| this.m = val; | |
| this.c = {}; | |
| }; | |
| x(rq, hg); | |
| /** @type {!Array} */ | |
| var sq = []; | |
| /** | |
| * @param {!Object} value | |
| * @param {string} type | |
| * @param {!Function} d | |
| * @param {string} path | |
| * @return {?} | |
| */ | |
| rq.prototype.M = function(value, type, d, path) { | |
| return tq(this, value, type, d, path); | |
| }; | |
| /** | |
| * @param {!Object} y4 | |
| * @param {!Object} d | |
| * @param {!Object} name | |
| * @param {string} i | |
| * @return {undefined} | |
| */ | |
| var uq = function(y4, d, name, i) { | |
| tq(y4, d, "click", name, false, i); | |
| }; | |
| /** | |
| * @param {!Object} d | |
| * @param {!Object} t | |
| * @param {string} c | |
| * @param {!Object} o | |
| * @param {string} depth | |
| * @param {string} root | |
| * @return {?} | |
| */ | |
| var tq = function(d, t, c, o, depth, root) { | |
| if (!Ka(c)) { | |
| if (c) { | |
| sq[0] = c.toString(); | |
| } | |
| c = sq; | |
| } | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < c.length; i++) { | |
| var year = I(t, c[i], o || d.handleEvent, depth || false, root || d.m || d); | |
| if (!year) { | |
| break; | |
| } | |
| d.c[year.key] = year; | |
| } | |
| return d; | |
| }; | |
| /** | |
| * @param {string} text | |
| * @param {string} props | |
| * @param {string} d | |
| * @param {!Object} key | |
| * @return {?} | |
| */ | |
| rq.prototype.Hh = function(text, props, d, key) { | |
| return vq(this, text, props, d, key); | |
| }; | |
| /** | |
| * @param {!Object} $scope | |
| * @param {string} data | |
| * @param {string} filter | |
| * @param {!Object} code | |
| * @param {!Object} name | |
| * @param {string} baseFolder | |
| * @return {?} | |
| */ | |
| var vq = function($scope, data, filter, code, name, baseFolder) { | |
| if (Ka(filter)) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < filter.length; i++) { | |
| vq($scope, data, filter[i], code, name, baseFolder); | |
| } | |
| } else { | |
| data = Hg(data, filter, code || $scope.handleEvent, name, baseFolder || $scope.m || $scope); | |
| if (!data) { | |
| return $scope; | |
| } | |
| /** @type {string} */ | |
| $scope.c[data.key] = data; | |
| } | |
| return $scope; | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @param {string} type | |
| * @param {!Object} f | |
| * @param {!Object} a | |
| * @param {string} s | |
| * @return {?} | |
| */ | |
| rq.prototype.Ma = function(options, type, f, a, s) { | |
| if (Ka(type)) { | |
| /** @type {number} */ | |
| var j = 0; | |
| for (; j < type.length; j++) { | |
| this.Ma(options, type[j], f, a, s); | |
| } | |
| } else { | |
| f = f || this.handleEvent; | |
| /** @type {boolean} */ | |
| a = Na(a) ? !!a.capture : !!a; | |
| s = s || this.m || this; | |
| f = Ig(f); | |
| /** @type {boolean} */ | |
| a = !!a; | |
| type = xg(options) ? options.Ze(type, f, a, s) : options ? (options = Kg(options)) ? options.Ze(type, f, a, s) : null : null; | |
| if (type) { | |
| Pg(type); | |
| delete this.c[type.key]; | |
| } | |
| } | |
| return this; | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @return {undefined} | |
| */ | |
| var wq = function(data) { | |
| Mb(data.c, function(options_obejct, text) { | |
| if (this.c.hasOwnProperty(text)) { | |
| Pg(options_obejct); | |
| } | |
| }, data); | |
| data.c = {}; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| rq.prototype.X = function() { | |
| rq.D.X.call(this); | |
| wq(this); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| rq.prototype.handleEvent = function() { | |
| throw Error("EventHandler.handleEvent not implemented"); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var xq = function() { | |
| }; | |
| Ia(xq); | |
| /** @type {number} */ | |
| xq.prototype.a = 0; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var zq = function(a) { | |
| L.call(this); | |
| this.a = a || jf(); | |
| this.Na = yq; | |
| /** @type {null} */ | |
| this.va = null; | |
| /** @type {boolean} */ | |
| this.Ba = false; | |
| /** @type {null} */ | |
| this.v = null; | |
| this.R = void 0; | |
| /** @type {null} */ | |
| this.L = this.o = this.G = this.oa = null; | |
| /** @type {boolean} */ | |
| this.zb = false; | |
| }; | |
| x(zq, L); | |
| zq.prototype.Yd = xq.N(); | |
| /** @type {null} */ | |
| var yq = null; | |
| /** | |
| * @param {number} hierarchyIn | |
| * @param {boolean} value | |
| * @return {?} | |
| */ | |
| var Aq = function(hierarchyIn, value) { | |
| switch(hierarchyIn) { | |
| case 1: | |
| return value ? "disable" : "enable"; | |
| case 2: | |
| return value ? "highlight" : "unhighlight"; | |
| case 4: | |
| return value ? "activate" : "deactivate"; | |
| case 8: | |
| return value ? "select" : "unselect"; | |
| case 16: | |
| return value ? "check" : "uncheck"; | |
| case 32: | |
| return value ? "focus" : "blur"; | |
| case 64: | |
| return value ? "open" : "close"; | |
| } | |
| throw Error("Invalid component state"); | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @return {?} | |
| */ | |
| var Bq = function(o) { | |
| return o.va || (o.va = ":" + (o.Yd.a++).toString(36)); | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| var Cq = function(o, value) { | |
| if (o.G && o.G.L) { | |
| var L = o.G.L; | |
| var id_source = o.va; | |
| if (id_source in L) { | |
| delete L[id_source]; | |
| } | |
| Ub(o.G.L, value, o); | |
| } | |
| /** @type {string} */ | |
| o.va = value; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| zq.prototype.j = function() { | |
| return this.v; | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {?} | |
| */ | |
| var Dq = function(name) { | |
| name = name.v; | |
| z(name, "Can not call getElementStrict before rendering/decorating."); | |
| return name; | |
| }; | |
| /** | |
| * @param {string} params | |
| * @return {?} | |
| */ | |
| zq.prototype.Ld = function(params) { | |
| return this.v ? this.a.Ld(params, this.v) : null; | |
| }; | |
| /** | |
| * @param {!Object} s | |
| * @return {?} | |
| */ | |
| var Y = function(s) { | |
| if (!s.R) { | |
| s.R = new rq(s); | |
| } | |
| return z(s.R); | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @param {!Object} value | |
| * @return {undefined} | |
| */ | |
| var Fq = function(o, value) { | |
| if (o == value) { | |
| throw Error("Unable to set parent component"); | |
| } | |
| if (value && o.G && o.va && Eq(o.G, o.va) && o.G != value) { | |
| throw Error("Unable to set parent component"); | |
| } | |
| /** @type {!Object} */ | |
| o.G = value; | |
| zq.D.Vd.call(o, value); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| zq.prototype.getParent = function() { | |
| return this.G; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| zq.prototype.Vd = function(a) { | |
| if (this.G && this.G != a) { | |
| throw Error("Method not supported"); | |
| } | |
| zq.D.Vd.call(this, a); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| zq.prototype.Ra = function() { | |
| this.v = fg(this.a, "DIV"); | |
| }; | |
| /** | |
| * @param {!Object} result | |
| * @return {undefined} | |
| */ | |
| zq.prototype.Za = function(result) { | |
| Gq(this, result); | |
| }; | |
| /** | |
| * @param {!Object} c | |
| * @param {!Object} t | |
| * @param {string} child | |
| * @return {undefined} | |
| */ | |
| var Gq = function(c, t, child) { | |
| if (c.Ba) { | |
| throw Error("Component already rendered"); | |
| } | |
| if (!c.v) { | |
| c.Ra(); | |
| } | |
| if (t) { | |
| t.insertBefore(c.v, child || null); | |
| } else { | |
| c.a.a.body.appendChild(c.v); | |
| } | |
| if (!(c.G && !c.G.Ba)) { | |
| c.ia(); | |
| } | |
| }; | |
| k = zq.prototype; | |
| /** | |
| * @param {?} value | |
| * @return {undefined} | |
| */ | |
| k.na = function(value) { | |
| if (this.Ba) { | |
| throw Error("Component already rendered"); | |
| } | |
| if (value && this.jd(value)) { | |
| /** @type {boolean} */ | |
| this.zb = true; | |
| var i = hf(value); | |
| if (!(this.a && this.a.a == i)) { | |
| this.a = jf(value); | |
| } | |
| this.Fa(value); | |
| this.ia(); | |
| } else { | |
| throw Error("Invalid element to decorate"); | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.jd = function() { | |
| return true; | |
| }; | |
| /** | |
| * @param {boolean} value | |
| * @return {undefined} | |
| */ | |
| k.Fa = function(value) { | |
| /** @type {boolean} */ | |
| this.v = value; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.ia = function() { | |
| /** @type {boolean} */ | |
| this.Ba = true; | |
| Hq(this, function(f) { | |
| if (!f.Ba && f.j()) { | |
| f.ia(); | |
| } | |
| }); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.xb = function() { | |
| Hq(this, function(p) { | |
| if (p.Ba) { | |
| p.xb(); | |
| } | |
| }); | |
| if (this.R) { | |
| wq(this.R); | |
| } | |
| /** @type {boolean} */ | |
| this.Ba = false; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.X = function() { | |
| if (this.Ba) { | |
| this.xb(); | |
| } | |
| if (this.R) { | |
| this.R.Qa(); | |
| delete this.R; | |
| } | |
| Hq(this, function(a) { | |
| a.Qa(); | |
| }); | |
| if (!this.zb && this.v) { | |
| Jf(this.v); | |
| } | |
| /** @type {null} */ | |
| this.G = this.oa = this.v = this.L = this.o = null; | |
| zq.D.X.call(this); | |
| }; | |
| /** | |
| * @param {number} b | |
| * @param {string} i | |
| * @return {undefined} | |
| */ | |
| k.qb = function(b, i) { | |
| this.Gd(b, Iq(this), i); | |
| }; | |
| /** | |
| * @param {!Object} c | |
| * @param {number} i | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| k.Gd = function(c, i, a) { | |
| z(!!c, "Provided element must not be null."); | |
| if (c.Ba && (a || !this.Ba)) { | |
| throw Error("Component already rendered"); | |
| } | |
| if (0 > i || i > Iq(this)) { | |
| throw Error("Child component index out of bounds"); | |
| } | |
| if (!(this.L && this.o)) { | |
| this.L = {}; | |
| /** @type {!Array} */ | |
| this.o = []; | |
| } | |
| if (c.getParent() == this) { | |
| var b = Bq(c); | |
| /** @type {!Object} */ | |
| this.L[b] = c; | |
| xb(this.o, c); | |
| } else { | |
| Ub(this.L, Bq(c), c); | |
| } | |
| Fq(c, this); | |
| Db(this.o, i, 0, c); | |
| if (c.Ba && this.Ba && c.getParent() == this) { | |
| a = this.oc(); | |
| i = a.childNodes[i] || null; | |
| if (i != c.j()) { | |
| a.insertBefore(c.j(), i); | |
| } | |
| } else { | |
| if (a) { | |
| if (!this.v) { | |
| this.Ra(); | |
| } | |
| i = Jq(this, i + 1); | |
| Gq(c, this.oc(), i ? i.v : null); | |
| } else { | |
| if (this.Ba && !c.Ba && c.v && c.v.parentNode && 1 == c.v.parentNode.nodeType) { | |
| c.ia(); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.oc = function() { | |
| return this.v; | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| var Kq = function(b) { | |
| if (null == b.Na) { | |
| b.Na = gq(b.Ba ? b.v : b.a.a.body); | |
| } | |
| return b.Na; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var Iq = function(a) { | |
| return a.o ? a.o.length : 0; | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @param {string} type | |
| * @return {?} | |
| */ | |
| var Eq = function(node, type) { | |
| if (node.L && type) { | |
| node = node.L; | |
| type = (null !== node && type in node ? node[type] : void 0) || null; | |
| } else { | |
| /** @type {null} */ | |
| type = null; | |
| } | |
| return type; | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @param {number} key | |
| * @return {?} | |
| */ | |
| var Jq = function(b, key) { | |
| return b.o ? b.o[key] || null : null; | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @param {!Function} f | |
| * @param {!Function} context | |
| * @return {undefined} | |
| */ | |
| var Hq = function(options, f, context) { | |
| if (options.o) { | |
| A(options.o, f, context); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @param {!Object} id | |
| * @return {?} | |
| */ | |
| var Lq = function(options, id) { | |
| return options.o && id ? kb(options.o, id) : -1; | |
| }; | |
| /** | |
| * @param {?} element | |
| * @param {boolean} options | |
| * @return {?} | |
| */ | |
| zq.prototype.removeChild = function(element, options) { | |
| if (element) { | |
| var target = r(element) ? element : Bq(element); | |
| element = Eq(this, target); | |
| if (target && element) { | |
| var translation = this.L; | |
| if (target in translation) { | |
| delete translation[target]; | |
| } | |
| xb(this.o, element); | |
| if (options) { | |
| element.xb(); | |
| if (element.v) { | |
| Jf(element.v); | |
| } | |
| } | |
| Fq(element, null); | |
| } | |
| } | |
| if (!element) { | |
| throw Error("Child is not in parent component"); | |
| } | |
| return element; | |
| }; | |
| /** | |
| * @param {undefined} a | |
| * @param {!Object} f | |
| * @return {undefined} | |
| */ | |
| var Nq = function(a, f) { | |
| L.call(this); | |
| if (a) { | |
| Mq(this, a, f); | |
| } | |
| }; | |
| x(Nq, L); | |
| k = Nq.prototype; | |
| /** @type {null} */ | |
| k.v = null; | |
| /** @type {null} */ | |
| k.rg = null; | |
| /** @type {null} */ | |
| k.Fh = null; | |
| /** @type {null} */ | |
| k.sg = null; | |
| /** @type {number} */ | |
| k.Ob = -1; | |
| /** @type {number} */ | |
| k.Ec = -1; | |
| /** @type {boolean} */ | |
| k.kh = false; | |
| var Oq = { | |
| 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 Pq = { | |
| 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 Qq = !C.Ka || C.Ea("525"); | |
| var Rq = C.yb && C.Ja; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| Nq.prototype.a = function(type) { | |
| if (C.Ka || C.vb) { | |
| if (17 == this.Ob && !type.ctrlKey || 18 == this.Ob && !type.altKey || C.yb && 91 == this.Ob && !type.metaKey) { | |
| /** @type {number} */ | |
| this.Ec = this.Ob = -1; | |
| } | |
| } | |
| if (-1 == this.Ob) { | |
| if (type.ctrlKey && 17 != type.keyCode) { | |
| /** @type {number} */ | |
| this.Ob = 17; | |
| } else { | |
| if (type.altKey && 18 != type.keyCode) { | |
| /** @type {number} */ | |
| this.Ob = 18; | |
| } else { | |
| if (type.metaKey && 91 != type.keyCode) { | |
| /** @type {number} */ | |
| this.Ob = 91; | |
| } | |
| } | |
| } | |
| } | |
| if (Qq && !Yg(type.keyCode, this.Ob, type.shiftKey, type.ctrlKey, type.altKey, type.metaKey)) { | |
| this.handleEvent(type); | |
| } else { | |
| this.Ec = Xg(type.keyCode); | |
| if (Rq) { | |
| this.kh = type.altKey; | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| Nq.prototype.b = function(name) { | |
| /** @type {number} */ | |
| this.Ec = this.Ob = -1; | |
| this.kh = name.altKey; | |
| }; | |
| /** | |
| * @param {!Object} event | |
| * @return {undefined} | |
| */ | |
| Nq.prototype.handleEvent = function(event) { | |
| var e = event.b; | |
| var altKey = e.altKey; | |
| if (C.V && "keypress" == event.type) { | |
| var keyCode = this.Ec; | |
| var charCode = 13 != keyCode && 27 != keyCode ? e.keyCode : 0; | |
| } else { | |
| if ((C.Ka || C.vb) && "keypress" == event.type) { | |
| keyCode = this.Ec; | |
| charCode = 0 <= e.charCode && 63232 > e.charCode && Vg(keyCode) ? e.charCode : 0; | |
| } else { | |
| if (C.cb && !C.Ka) { | |
| keyCode = this.Ec; | |
| charCode = Vg(keyCode) ? e.keyCode : 0; | |
| } else { | |
| if ("keypress" == event.type) { | |
| if (Rq) { | |
| altKey = this.kh; | |
| } | |
| if (e.keyCode == e.charCode) { | |
| if (32 > e.keyCode) { | |
| keyCode = e.keyCode; | |
| /** @type {number} */ | |
| charCode = 0; | |
| } else { | |
| keyCode = this.Ec; | |
| charCode = e.charCode; | |
| } | |
| } else { | |
| keyCode = e.keyCode || this.Ec; | |
| charCode = e.charCode || 0; | |
| } | |
| } else { | |
| keyCode = e.keyCode || this.Ec; | |
| charCode = e.charCode || 0; | |
| } | |
| if (C.yb && 63 == charCode && 224 == keyCode) { | |
| /** @type {number} */ | |
| keyCode = 191; | |
| } | |
| } | |
| } | |
| } | |
| var pointermove = keyCode = Xg(keyCode); | |
| if (keyCode) { | |
| if (63232 <= keyCode && keyCode in Oq) { | |
| pointermove = Oq[keyCode]; | |
| } else { | |
| if (25 == keyCode && event.shiftKey) { | |
| /** @type {number} */ | |
| pointermove = 9; | |
| } | |
| } | |
| } else { | |
| if (e.keyIdentifier && e.keyIdentifier in Pq) { | |
| pointermove = Pq[e.keyIdentifier]; | |
| } | |
| } | |
| if (!(C.Ja && Qq && "keypress" == event.type && !Yg(pointermove, this.Ob, event.shiftKey, event.ctrlKey, altKey, event.metaKey))) { | |
| /** @type {boolean} */ | |
| event = pointermove == this.Ob; | |
| this.Ob = pointermove; | |
| e = new Sq(pointermove, charCode, event, e); | |
| e.altKey = altKey; | |
| this.dispatchEvent(e); | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Nq.prototype.j = function() { | |
| return this.v; | |
| }; | |
| /** | |
| * @param {!Object} t | |
| * @param {number} d | |
| * @param {!Object} options | |
| * @return {undefined} | |
| */ | |
| var Mq = function(t, d, options) { | |
| if (t.sg) { | |
| Tq(t); | |
| } | |
| /** @type {number} */ | |
| t.v = d; | |
| t.rg = I(t.v, "keypress", t, options); | |
| t.Fh = I(t.v, "keydown", t.a, options, t); | |
| t.sg = I(t.v, "keyup", t.b, options, t); | |
| }; | |
| /** | |
| * @param {!Object} m | |
| * @return {undefined} | |
| */ | |
| var Tq = function(m) { | |
| if (m.rg) { | |
| Pg(m.rg); | |
| Pg(m.Fh); | |
| Pg(m.sg); | |
| /** @type {null} */ | |
| m.rg = null; | |
| /** @type {null} */ | |
| m.Fh = null; | |
| /** @type {null} */ | |
| m.sg = null; | |
| } | |
| /** @type {null} */ | |
| m.v = null; | |
| /** @type {number} */ | |
| m.Ob = -1; | |
| /** @type {number} */ | |
| m.Ec = -1; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Nq.prototype.X = function() { | |
| Nq.D.X.call(this); | |
| Tq(this); | |
| }; | |
| /** | |
| * @param {string} keyCode | |
| * @param {?} fn | |
| * @param {boolean} repeat | |
| * @param {?} event | |
| * @return {undefined} | |
| */ | |
| var Sq = function(keyCode, fn, repeat, event) { | |
| tg.call(this, event); | |
| /** @type {string} */ | |
| this.type = "key"; | |
| /** @type {string} */ | |
| this.keyCode = keyCode; | |
| /** @type {boolean} */ | |
| this.repeat = repeat; | |
| }; | |
| x(Sq, tg); | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Uq = function() { | |
| }; | |
| var Vq; | |
| Ia(Uq); | |
| var Wq = { | |
| button : "pressed", | |
| checkbox : "checked", | |
| menuitem : "selected", | |
| menuitemcheckbox : "checked", | |
| menuitemradio : "checked", | |
| radio : "checked", | |
| tab : "selected", | |
| treeitem : "selected" | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Uq.prototype.nd = function() { | |
| }; | |
| /** | |
| * @param {!Object} v | |
| * @return {?} | |
| */ | |
| Uq.prototype.Eb = function(v) { | |
| return v.a.b("DIV", Xq(this, v).join(" "), v.Ya()); | |
| }; | |
| /** | |
| * @param {!Object} val | |
| * @return {?} | |
| */ | |
| Uq.prototype.fc = function(val) { | |
| return val; | |
| }; | |
| /** | |
| * @param {!Object} i | |
| * @param {string} b | |
| * @param {string} s | |
| * @return {undefined} | |
| */ | |
| var Zq = function(i, b, s) { | |
| if (i = i.j ? i.j() : i) { | |
| /** @type {!Array} */ | |
| var a = [b]; | |
| if (C.V && !C.Ea("7")) { | |
| a = Yq(sp(i), b); | |
| a.push(b); | |
| } | |
| (s ? up : vp)(i, a); | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Uq.prototype.md = function() { | |
| return true; | |
| }; | |
| /** | |
| * @param {string} m | |
| * @param {!Object} v | |
| * @return {?} | |
| */ | |
| Uq.prototype.eb = function(m, v) { | |
| if (v.id) { | |
| Cq(m, v.id); | |
| } | |
| var el = this.fc(v); | |
| if (el && el.firstChild) { | |
| $q(m, el.firstChild.nextSibling ? Ab(el.childNodes) : el.firstChild); | |
| } else { | |
| /** @type {null} */ | |
| m.pd = null; | |
| } | |
| /** @type {number} */ | |
| var d = 0; | |
| var undefined = this.za(); | |
| var last = this.za(); | |
| /** @type {boolean} */ | |
| var resultTest = false; | |
| /** @type {boolean} */ | |
| var treatLastLineAsNormal = false; | |
| /** @type {boolean} */ | |
| var s = false; | |
| var r = Ab(sp(v)); | |
| A(r, function(input) { | |
| if (resultTest || input != undefined) { | |
| if (treatLastLineAsNormal || input != last) { | |
| /** @type {number} */ | |
| d = d | this.g(input); | |
| } else { | |
| /** @type {boolean} */ | |
| treatLastLineAsNormal = true; | |
| } | |
| } else { | |
| /** @type {boolean} */ | |
| resultTest = true; | |
| if (last == undefined) { | |
| /** @type {boolean} */ | |
| treatLastLineAsNormal = true; | |
| } | |
| } | |
| if (1 == this.g(input)) { | |
| gb(el); | |
| if (Yf(el) && Zf(el)) { | |
| Xf(el, false); | |
| } | |
| } | |
| }, this); | |
| m.qd = d; | |
| if (!resultTest) { | |
| r.push(undefined); | |
| if (last == undefined) { | |
| /** @type {boolean} */ | |
| treatLastLineAsNormal = true; | |
| } | |
| } | |
| if (!treatLastLineAsNormal) { | |
| r.push(last); | |
| } | |
| if (m = m.lc) { | |
| r.push.apply(r, m); | |
| } | |
| if (C.V && !C.Ea("7")) { | |
| var root = Yq(r); | |
| if (0 < root.length) { | |
| r.push.apply(r, root); | |
| /** @type {boolean} */ | |
| s = true; | |
| } | |
| } | |
| if (!resultTest || !treatLastLineAsNormal || m || s) { | |
| v.className = r.join(" "); | |
| } | |
| return v; | |
| }; | |
| /** | |
| * @param {!Object} button | |
| * @return {undefined} | |
| */ | |
| Uq.prototype.ej = function(button) { | |
| if (Kq(button)) { | |
| this.oh(button.j(), true); | |
| } | |
| if (button.isEnabled()) { | |
| this.le(button, button.isVisible()); | |
| } | |
| }; | |
| /** | |
| * @param {string} obj | |
| * @param {!Object} n | |
| * @param {string} parentNode | |
| * @return {undefined} | |
| */ | |
| var ar = function(obj, n, parentNode) { | |
| if (obj = parentNode || obj.nd()) { | |
| z(n, "The element passed as a first parameter cannot be null."); | |
| parentNode = n.getAttribute("role") || null; | |
| if (obj != parentNode) { | |
| lp(n, obj); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {boolean} id | |
| * @param {!Object} m | |
| * @param {!Array} name | |
| * @return {undefined} | |
| */ | |
| var cr = function(id, m, name) { | |
| z(m); | |
| z(name); | |
| var p = m.gb; | |
| if (null != p) { | |
| rp(name, p); | |
| } | |
| if (!m.isVisible()) { | |
| np(name, "hidden", !m.isVisible()); | |
| } | |
| if (!m.isEnabled()) { | |
| id.uc(name, 1, !m.isEnabled()); | |
| } | |
| if (br(m, 8)) { | |
| id.uc(name, 8, m.Eh()); | |
| } | |
| if (br(m, 16)) { | |
| id.uc(name, 16, m.Ha(16)); | |
| } | |
| if (br(m, 64)) { | |
| id.uc(name, 64, m.Ha(64)); | |
| } | |
| }; | |
| k = Uq.prototype; | |
| /** | |
| * @param {!Object} type | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| k.Yf = function(type, value) { | |
| iq(type, !value, !C.V && !C.cb); | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| k.oh = function(name, value) { | |
| Zq(name, this.za() + "-rtl", value); | |
| }; | |
| /** | |
| * @param {!Object} template | |
| * @return {?} | |
| */ | |
| k.nh = function(template) { | |
| var t; | |
| return br(template, 32) && (t = template.j()) ? Yf(t) && Zf(t) : false; | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| k.le = function(type, value) { | |
| var day; | |
| if (br(type, 32) && (day = type.j())) { | |
| if (!value && type.Ha(32)) { | |
| try { | |
| day.blur(); | |
| } catch (d) { | |
| } | |
| if (type.Ha(32)) { | |
| type.Zf(null); | |
| } | |
| } | |
| if ((Yf(day) && Zf(day)) != value) { | |
| Xf(day, value); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} arr | |
| * @param {?} a | |
| * @return {undefined} | |
| */ | |
| k.setVisible = function(arr, a) { | |
| X(arr, a); | |
| if (arr) { | |
| np(arr, "hidden", !a); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @param {!Array} text | |
| * @param {string} c | |
| * @return {undefined} | |
| */ | |
| k.Od = function(item, text, c) { | |
| var d = item.j(); | |
| if (d) { | |
| var a = this.a(text); | |
| if (a) { | |
| Zq(item, a, c); | |
| } | |
| this.uc(d, text, c); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @param {string} value | |
| * @param {string} str | |
| * @return {undefined} | |
| */ | |
| k.uc = function(name, value, str) { | |
| if (!Vq) { | |
| Vq = { | |
| 1 : "disabled", | |
| 8 : "selected", | |
| 16 : "checked", | |
| 64 : "expanded" | |
| }; | |
| } | |
| z(name, "The element passed as a first parameter cannot be null."); | |
| value = Vq[value]; | |
| var key = name.getAttribute("role") || null; | |
| if (key) { | |
| key = Wq[key] || value; | |
| value = "checked" == value || "selected" == value ? key : value; | |
| } | |
| if (value) { | |
| np(name, value, str); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} c | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| k.qc = function(c, a) { | |
| var b = this.fc(c); | |
| if (b) { | |
| Ff(b); | |
| if (a) { | |
| if (r(a)) { | |
| H(b, a); | |
| } else { | |
| /** | |
| * @param {!Object} n | |
| * @return {undefined} | |
| */ | |
| c = function(n) { | |
| if (n) { | |
| var parser = hf(b); | |
| b.appendChild(r(n) ? parser.createTextNode(n) : n); | |
| } | |
| }; | |
| if (Ka(a)) { | |
| A(a, c); | |
| } else { | |
| if (!La(a) || "nodeType" in a) { | |
| c(a); | |
| } else { | |
| A(Ab(a), c); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.za = function() { | |
| return "goog-control"; | |
| }; | |
| /** | |
| * @param {string} m | |
| * @param {!Object} s | |
| * @return {?} | |
| */ | |
| var Xq = function(m, s) { | |
| var c = m.za(); | |
| /** @type {!Array} */ | |
| var g = [c]; | |
| var r = m.za(); | |
| if (r != c) { | |
| g.push(r); | |
| } | |
| c = s.qd; | |
| /** @type {!Array} */ | |
| r = []; | |
| for (; c;) { | |
| /** @type {number} */ | |
| var a = c & -c; | |
| r.push(m.a(a)); | |
| /** @type {number} */ | |
| c = c & ~a; | |
| } | |
| g.push.apply(g, r); | |
| if (m = s.lc) { | |
| g.push.apply(g, m); | |
| } | |
| if (C.V && !C.Ea("7")) { | |
| g.push.apply(g, Yq(g)); | |
| } | |
| return g; | |
| }; | |
| /** | |
| * @param {!Array} b | |
| * @param {string} m | |
| * @return {?} | |
| */ | |
| var Yq = function(b, m) { | |
| /** @type {!Array} */ | |
| var pairs_buf = []; | |
| if (m) { | |
| b = yb(b, [m]); | |
| } | |
| A([], function(d) { | |
| if (!(!pb(d, Ta(tb, b)) || m && !tb(d, m))) { | |
| pairs_buf.push(d.join("_")); | |
| } | |
| }); | |
| return pairs_buf; | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {?} | |
| */ | |
| Uq.prototype.a = function(name) { | |
| if (!this.b) { | |
| dr(this); | |
| } | |
| return this.b[name]; | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {?} | |
| */ | |
| Uq.prototype.g = function(type) { | |
| if (!this.R) { | |
| if (!this.b) { | |
| dr(this); | |
| } | |
| var stats = this.b; | |
| var R = {}; | |
| var i; | |
| for (i in stats) { | |
| /** @type {string} */ | |
| R[stats[i]] = i; | |
| } | |
| this.R = R; | |
| } | |
| /** @type {number} */ | |
| type = parseInt(this.R[type], 10); | |
| return isNaN(type) ? 0 : type; | |
| }; | |
| /** | |
| * @param {!Object} index | |
| * @return {undefined} | |
| */ | |
| var dr = function(index) { | |
| var cls = index.za(); | |
| /** @type {boolean} */ | |
| var dd = !Kc(cls.replace(/\xa0|\s/g, " "), " "); | |
| z(dd, "ControlRenderer has an invalid css class: '" + cls + "'"); | |
| index.b = { | |
| 1 : cls + "-disabled", | |
| 2 : cls + "-hover", | |
| 4 : cls + "-active", | |
| 8 : cls + "-selected", | |
| 16 : cls + "-checked", | |
| 32 : cls + "-focused", | |
| 64 : cls + "-open" | |
| }; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var er = function() { | |
| }; | |
| x(er, Uq); | |
| Ia(er); | |
| k = er.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| k.nd = function() { | |
| return "button"; | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @param {string} value | |
| * @param {string} str | |
| * @return {undefined} | |
| */ | |
| k.uc = function(name, value, str) { | |
| switch(value) { | |
| case 8: | |
| case 16: | |
| z(name, "The button DOM element cannot be null."); | |
| np(name, "pressed", str); | |
| break; | |
| default: | |
| case 64: | |
| case 1: | |
| er.D.uc.call(this, name, value, str); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @return {?} | |
| */ | |
| k.Eb = function(data) { | |
| var v = er.D.Eb.call(this, data); | |
| fr(v, data.h); | |
| var realVal = data.aa(); | |
| if (realVal) { | |
| this.Vf(v, realVal); | |
| } | |
| if (br(data, 16)) { | |
| this.uc(v, 16, data.Ha(16)); | |
| } | |
| return v; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Object} s | |
| * @return {?} | |
| */ | |
| k.eb = function(a, s) { | |
| s = er.D.eb.call(this, a, s); | |
| var url_str = this.aa(s); | |
| a.ea = url_str; | |
| a.h = s.title; | |
| if (br(a, 16)) { | |
| this.uc(s, 16, a.Ha(16)); | |
| } | |
| return s; | |
| }; | |
| /** @type {function(): undefined} */ | |
| k.aa = Ha; | |
| /** @type {function(): undefined} */ | |
| k.Vf = Ha; | |
| /** | |
| * @param {!Object} n | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| var fr = function(n, name) { | |
| if (n) { | |
| if (name) { | |
| /** @type {string} */ | |
| n.title = name; | |
| } else { | |
| n.removeAttribute("title"); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {?} val | |
| * @param {(Object|string)} axis | |
| * @param {number} state | |
| * @return {undefined} | |
| */ | |
| var hr = function(val, axis, state) { | |
| var orie = Kq(axis); | |
| var Y = val.za() + "-collapse-left"; | |
| val = val.za() + "-collapse-right"; | |
| gr(axis, orie ? val : Y, !!(state & 1)); | |
| gr(axis, orie ? Y : val, !!(state & 2)); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| er.prototype.za = function() { | |
| return "goog-button"; | |
| }; | |
| /** | |
| * @param {string} key | |
| * @param {!Function} attribute | |
| * @return {undefined} | |
| */ | |
| var jr = function(key, attribute) { | |
| if (!key) { | |
| throw Error("Invalid class name " + key); | |
| } | |
| if (!Ma(attribute)) { | |
| throw Error("Invalid decorator function " + attribute); | |
| } | |
| /** @type {!Function} */ | |
| ir[key] = attribute; | |
| }; | |
| var kr = {}; | |
| var ir = {}; | |
| /** | |
| * @param {!Object} url | |
| * @param {string} c | |
| * @param {?} resort | |
| * @return {undefined} | |
| */ | |
| var lr = function(url, c, resort) { | |
| zq.call(this, resort); | |
| if (!c) { | |
| c = this.constructor; | |
| var p; | |
| for (; c;) { | |
| p = Qa(c); | |
| if (p = kr[p]) { | |
| break; | |
| } | |
| c = c.D ? c.D.constructor : null; | |
| } | |
| c = p ? Ma(p.N) ? p.N() : new p : null; | |
| } | |
| /** @type {string} */ | |
| this.c = c; | |
| this.pd = q(url) ? url : null; | |
| /** @type {null} */ | |
| this.gb = null; | |
| }; | |
| x(lr, zq); | |
| k = lr.prototype; | |
| /** @type {null} */ | |
| k.pd = null; | |
| /** @type {number} */ | |
| k.qd = 0; | |
| /** @type {number} */ | |
| k.sf = 39; | |
| /** @type {number} */ | |
| k.Mc = 255; | |
| /** @type {number} */ | |
| k.rf = 0; | |
| /** @type {boolean} */ | |
| k.$f = true; | |
| /** @type {null} */ | |
| k.lc = null; | |
| /** @type {boolean} */ | |
| k.vh = true; | |
| /** @type {boolean} */ | |
| k.xf = false; | |
| /** @type {null} */ | |
| k.qh = null; | |
| /** | |
| * @param {!Object} err | |
| * @param {number} res | |
| * @return {undefined} | |
| */ | |
| var nr = function(err, res) { | |
| if (err.Ba && res != err.vh) { | |
| mr(err, res); | |
| } | |
| /** @type {number} */ | |
| err.vh = res; | |
| }; | |
| /** | |
| * @param {?} node | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| var or = function(node, value) { | |
| if (value) { | |
| if (node.lc) { | |
| if (!tb(node.lc, value)) { | |
| node.lc.push(value); | |
| } | |
| } else { | |
| /** @type {!Array} */ | |
| node.lc = [value]; | |
| } | |
| Zq(node, value, true); | |
| } | |
| }; | |
| /** | |
| * @param {?} obj | |
| * @param {string} node | |
| * @return {undefined} | |
| */ | |
| var pr = function(obj, node) { | |
| if (node && obj.lc && xb(obj.lc, node)) { | |
| if (0 == obj.lc.length) { | |
| /** @type {null} */ | |
| obj.lc = null; | |
| } | |
| Zq(obj, node, false); | |
| } | |
| }; | |
| /** | |
| * @param {?} a | |
| * @param {string} b | |
| * @param {boolean} variableNames | |
| * @return {undefined} | |
| */ | |
| var gr = function(a, b, variableNames) { | |
| if (variableNames) { | |
| or(a, b); | |
| } else { | |
| pr(a, b); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| lr.prototype.Ra = function() { | |
| var value = this.c.Eb(this); | |
| this.v = value; | |
| ar(this.c, value, this.C()); | |
| if (!this.xf) { | |
| this.c.Yf(value, false); | |
| } | |
| if (!this.isVisible()) { | |
| this.c.setVisible(value, false); | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| lr.prototype.C = function() { | |
| return this.qh; | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @param {string} content | |
| * @return {undefined} | |
| */ | |
| var qr = function(options, content) { | |
| /** @type {string} */ | |
| options.gb = content; | |
| if (options = options.j()) { | |
| rp(options, content); | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| lr.prototype.oc = function() { | |
| return this.c.fc(this.j()); | |
| }; | |
| /** | |
| * @param {!Object} params | |
| * @return {?} | |
| */ | |
| lr.prototype.jd = function(params) { | |
| return this.c.md(params); | |
| }; | |
| /** | |
| * @param {!Object} x | |
| * @return {undefined} | |
| */ | |
| lr.prototype.Fa = function(x) { | |
| this.v = x = this.c.eb(this, x); | |
| ar(this.c, x, this.C()); | |
| if (!this.xf) { | |
| this.c.Yf(x, false); | |
| } | |
| /** @type {boolean} */ | |
| this.$f = "none" != x.style.display; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| lr.prototype.ia = function() { | |
| lr.D.ia.call(this); | |
| cr(this.c, this, Dq(this)); | |
| this.c.ej(this); | |
| if (this.sf & -2 && (this.vh && mr(this, true), br(this, 32))) { | |
| var date = this.j(); | |
| if (date) { | |
| var x = this.w || (this.w = new Nq); | |
| Mq(x, date); | |
| Y(this).M(x, "key", this.ib).M(date, "focus", this.hm).M(date, "blur", this.Zf); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} opts | |
| * @param {number} depth | |
| * @return {undefined} | |
| */ | |
| var mr = function(opts, depth) { | |
| var obj = Y(opts); | |
| var x = opts.j(); | |
| if (depth) { | |
| obj.M(x, rg.Oe, opts.Fb).M(x, [rg.Pe, rg.Ne], opts.Nb).M(x, "mouseover", opts.ph).M(x, "mouseout", opts.wh); | |
| if (opts.hf != Ha) { | |
| obj.M(x, "contextmenu", opts.hf); | |
| } | |
| if (C.V) { | |
| if (!C.Ea(9)) { | |
| obj.M(x, "dblclick", opts.ij); | |
| } | |
| if (!opts.K) { | |
| opts.K = new rr(opts); | |
| jg(opts, opts.K); | |
| } | |
| } | |
| } else { | |
| obj.Ma(x, rg.Oe, opts.Fb).Ma(x, [rg.Pe, rg.Ne], opts.Nb).Ma(x, "mouseover", opts.ph).Ma(x, "mouseout", opts.wh); | |
| if (opts.hf != Ha) { | |
| obj.Ma(x, "contextmenu", opts.hf); | |
| } | |
| if (C.V) { | |
| if (!C.Ea(9)) { | |
| obj.Ma(x, "dblclick", opts.ij); | |
| } | |
| ig(opts.K); | |
| /** @type {null} */ | |
| opts.K = null; | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| lr.prototype.xb = function() { | |
| lr.D.xb.call(this); | |
| if (this.w) { | |
| Tq(this.w); | |
| } | |
| if (this.isVisible() && this.isEnabled()) { | |
| this.c.le(this, false); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| lr.prototype.X = function() { | |
| lr.D.X.call(this); | |
| if (this.w) { | |
| this.w.Qa(); | |
| delete this.w; | |
| } | |
| delete this.c; | |
| /** @type {null} */ | |
| this.K = this.lc = this.pd = null; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| lr.prototype.Ya = function() { | |
| return this.pd; | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| lr.prototype.g = function(name) { | |
| this.c.qc(this.j(), name); | |
| /** @type {!Object} */ | |
| this.pd = name; | |
| }; | |
| /** | |
| * @param {string} p | |
| * @param {?} q | |
| * @return {undefined} | |
| */ | |
| var $q = function(p, q) { | |
| p.pd = q; | |
| }; | |
| k = lr.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Bb = function() { | |
| var body = this.Ya(); | |
| if (!body) { | |
| return ""; | |
| } | |
| body = r(body) ? body : Ka(body) ? mb(body, bg).join("") : ag(body); | |
| return ce(body); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.isVisible = function() { | |
| return this.$f; | |
| }; | |
| /** | |
| * @param {boolean} v | |
| * @param {boolean} x | |
| * @return {?} | |
| */ | |
| k.setVisible = function(v, x) { | |
| return x || this.$f != v && this.dispatchEvent(v ? "show" : "hide") ? ((x = this.j()) && this.c.setVisible(x, v), this.isEnabled() && this.c.le(this, v), this.$f = v, true) : false; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.isEnabled = function() { | |
| return !this.Ha(1); | |
| }; | |
| /** | |
| * @param {boolean} num | |
| * @return {undefined} | |
| */ | |
| k.sa = function(num) { | |
| var d = this.getParent(); | |
| if (!(d && "function" == typeof d.isEnabled && !d.isEnabled() || !sr(this, 1, !num))) { | |
| if (!num) { | |
| tr(this, false); | |
| ur(this, false); | |
| } | |
| if (this.isVisible()) { | |
| this.c.le(this, num); | |
| } | |
| vr(this, 1, !num, true); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} m | |
| * @param {boolean} b | |
| * @return {undefined} | |
| */ | |
| var ur = function(m, b) { | |
| if (sr(m, 2, b)) { | |
| vr(m, 2, b); | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| lr.prototype.tb = function() { | |
| return this.Ha(4); | |
| }; | |
| /** | |
| * @param {undefined} key | |
| * @param {boolean} value | |
| * @return {undefined} | |
| */ | |
| var tr = function(key, value) { | |
| if (sr(key, 4, value)) { | |
| vr(key, 4, value); | |
| } | |
| }; | |
| k = lr.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Eh = function() { | |
| return this.Ha(8); | |
| }; | |
| /** | |
| * @param {boolean} i | |
| * @return {undefined} | |
| */ | |
| k.xd = function(i) { | |
| if (sr(this, 8, i)) { | |
| vr(this, 8, i); | |
| } | |
| }; | |
| /** | |
| * @param {boolean} i | |
| * @return {undefined} | |
| */ | |
| k.wd = function(i) { | |
| if (sr(this, 16, i)) { | |
| vr(this, 16, i); | |
| } | |
| }; | |
| /** | |
| * @param {boolean} a | |
| * @return {undefined} | |
| */ | |
| k.ze = function(a) { | |
| if (sr(this, 32, a)) { | |
| vr(this, 32, a); | |
| } | |
| }; | |
| /** | |
| * @param {boolean} r | |
| * @return {undefined} | |
| */ | |
| k.bb = function(r) { | |
| if (sr(this, 64, r)) { | |
| vr(this, 64, r); | |
| } | |
| }; | |
| /** | |
| * @param {number} object | |
| * @return {?} | |
| */ | |
| k.Ha = function(object) { | |
| return !!(this.qd & object); | |
| }; | |
| /** | |
| * @param {!Object} s | |
| * @param {number} i | |
| * @param {boolean} t | |
| * @param {string} force | |
| * @return {undefined} | |
| */ | |
| var vr = function(s, i, t, force) { | |
| if (force || 1 != i) { | |
| if (br(s, i) && t != s.Ha(i)) { | |
| s.c.Od(s, i, t); | |
| /** @type {number} */ | |
| s.qd = t ? s.qd | i : s.qd & ~i; | |
| } | |
| } else { | |
| s.sa(!t); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @param {number} value | |
| * @return {?} | |
| */ | |
| var br = function(node, value) { | |
| return !!(node.sf & value); | |
| }; | |
| /** | |
| * @param {number} op | |
| * @param {boolean} result | |
| * @return {undefined} | |
| */ | |
| lr.prototype.Sa = function(op, result) { | |
| if (this.Ba && this.Ha(op) && !result) { | |
| throw Error("Component already rendered"); | |
| } | |
| if (!result && this.Ha(op)) { | |
| vr(this, op, false); | |
| } | |
| /** @type {number} */ | |
| this.sf = result ? this.sf | op : this.sf & ~op; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {number} opt_max | |
| * @return {?} | |
| */ | |
| var wr = function(a, opt_max) { | |
| return !!(a.Mc & opt_max) && br(a, opt_max); | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @param {number} id | |
| * @param {boolean} name | |
| * @return {?} | |
| */ | |
| var sr = function(item, id, name) { | |
| return br(item, id) && item.Ha(id) != name && (!(item.rf & id) || item.dispatchEvent(Aq(id, name))) && !item.Ac; | |
| }; | |
| k = lr.prototype; | |
| /** | |
| * @param {!Object} event | |
| * @return {undefined} | |
| */ | |
| k.ph = function(event) { | |
| if ((!event.relatedTarget || !Pf(this.j(), event.relatedTarget)) && this.dispatchEvent("enter") && this.isEnabled() && wr(this, 2)) { | |
| ur(this, true); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} event | |
| * @return {undefined} | |
| */ | |
| k.wh = function(event) { | |
| if (!(event.relatedTarget && Pf(this.j(), event.relatedTarget) || !this.dispatchEvent("leave"))) { | |
| if (wr(this, 4)) { | |
| tr(this, false); | |
| } | |
| if (wr(this, 2)) { | |
| ur(this, false); | |
| } | |
| } | |
| }; | |
| /** @type {function(): undefined} */ | |
| k.hf = Ha; | |
| /** | |
| * @param {!Object} e | |
| * @return {undefined} | |
| */ | |
| k.Fb = function(e) { | |
| if (this.isEnabled()) { | |
| if (wr(this, 2)) { | |
| ur(this, true); | |
| } | |
| if (vg(e)) { | |
| if (wr(this, 4)) { | |
| tr(this, true); | |
| } | |
| if (this.c && this.c.nh(this)) { | |
| this.j().focus(); | |
| } | |
| } | |
| } | |
| if (!this.xf && vg(e)) { | |
| e.preventDefault(); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} submitButton | |
| * @return {undefined} | |
| */ | |
| k.Nb = function(submitButton) { | |
| if (this.isEnabled()) { | |
| if (wr(this, 2)) { | |
| ur(this, true); | |
| } | |
| if (this.tb() && this.rd(submitButton) && wr(this, 4)) { | |
| tr(this, false); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} keyReads | |
| * @return {undefined} | |
| */ | |
| k.ij = function(keyReads) { | |
| if (this.isEnabled()) { | |
| this.rd(keyReads); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @return {?} | |
| */ | |
| k.rd = function(options) { | |
| if (wr(this, 16)) { | |
| this.wd(!this.Ha(16)); | |
| } | |
| if (wr(this, 8)) { | |
| this.xd(true); | |
| } | |
| if (wr(this, 64)) { | |
| this.bb(!this.Ha(64)); | |
| } | |
| var event = new kg("action", this); | |
| if (options) { | |
| event.altKey = options.altKey; | |
| event.ctrlKey = options.ctrlKey; | |
| event.metaKey = options.metaKey; | |
| event.shiftKey = options.shiftKey; | |
| event.g = options.g; | |
| } | |
| return this.dispatchEvent(event); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.hm = function() { | |
| if (wr(this, 32)) { | |
| this.ze(true); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.Zf = function() { | |
| if (wr(this, 4)) { | |
| tr(this, false); | |
| } | |
| if (wr(this, 32)) { | |
| this.ze(false); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} event | |
| * @return {?} | |
| */ | |
| k.ib = function(event) { | |
| return this.isVisible() && this.isEnabled() && this.me(event) ? (event.preventDefault(), event.stopPropagation(), true) : false; | |
| }; | |
| /** | |
| * @param {!Object} event | |
| * @return {?} | |
| */ | |
| k.me = function(event) { | |
| return 13 == event.keyCode && this.rd(event); | |
| }; | |
| if (!Ma(lr)) { | |
| throw Error("Invalid component class " + lr); | |
| } | |
| if (!Ma(Uq)) { | |
| throw Error("Invalid renderer class " + Uq); | |
| } | |
| var xr = Qa(lr); | |
| /** @type {function(): undefined} */ | |
| kr[xr] = Uq; | |
| jr("goog-control", function() { | |
| return new lr(null); | |
| }); | |
| /** | |
| * @param {number} x | |
| * @return {undefined} | |
| */ | |
| var rr = function(x) { | |
| hg.call(this); | |
| /** @type {number} */ | |
| this.b = x; | |
| /** @type {boolean} */ | |
| this.a = false; | |
| this.c = new rq(this); | |
| jg(this, this.c); | |
| x = Dq(this.b); | |
| this.c.M(x, "mousedown", this.h).M(x, "mouseup", this.o).M(x, "click", this.g); | |
| }; | |
| x(rr, hg); | |
| var yr = !C.V || C.kb(9); | |
| /** | |
| * @return {undefined} | |
| */ | |
| rr.prototype.h = function() { | |
| /** @type {boolean} */ | |
| this.a = false; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| rr.prototype.o = function() { | |
| /** @type {boolean} */ | |
| this.a = true; | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @param {string} type | |
| * @return {?} | |
| */ | |
| var zr = function(options, type) { | |
| if (!yr) { | |
| 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 {!Object} type | |
| * @return {undefined} | |
| */ | |
| rr.prototype.g = function(type) { | |
| if (this.a) { | |
| /** @type {boolean} */ | |
| this.a = false; | |
| } else { | |
| var e = type.b; | |
| var button = e.button; | |
| var stk = e.type; | |
| var evt = zr(e, "mousedown"); | |
| this.b.Fb(new tg(evt, type.a)); | |
| evt = zr(e, "mouseup"); | |
| this.b.Nb(new tg(evt, type.a)); | |
| if (!yr) { | |
| e.button = button; | |
| e.type = stk; | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| rr.prototype.X = function() { | |
| /** @type {null} */ | |
| this.b = null; | |
| rr.D.X.call(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Ar = function() { | |
| }; | |
| x(Ar, er); | |
| Ia(Ar); | |
| k = Ar.prototype; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.nd = function() { | |
| }; | |
| /** | |
| * @param {!Object} m | |
| * @return {?} | |
| */ | |
| k.Eb = function(m) { | |
| nr(m, false); | |
| m.Mc &= -256; | |
| m.Sa(32, false); | |
| return m.a.b("BUTTON", { | |
| "class" : Xq(this, m).join(" "), | |
| disabled : !m.isEnabled(), | |
| title : m.h || "", | |
| value : m.aa() || "" | |
| }, m.Bb() || ""); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| k.md = function(a) { | |
| return "BUTTON" == a.tagName || "INPUT" == a.tagName && ("button" == a.type || "submit" == a.type || "reset" == a.type); | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @param {!Object} k | |
| * @return {?} | |
| */ | |
| k.eb = function(e, k) { | |
| nr(e, false); | |
| e.Mc &= -256; | |
| e.Sa(32, false); | |
| if (k.disabled) { | |
| var endColorCoords = bb(this.a(1)); | |
| T(k, endColorCoords); | |
| } | |
| return Ar.D.eb.call(this, e, k); | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @return {undefined} | |
| */ | |
| k.ej = function(item) { | |
| Y(item).M(item.j(), "click", item.rd); | |
| }; | |
| /** @type {function(): undefined} */ | |
| k.Yf = Ha; | |
| /** @type {function(): undefined} */ | |
| k.oh = Ha; | |
| /** | |
| * @param {?} toggler | |
| * @return {?} | |
| */ | |
| k.nh = function(toggler) { | |
| return toggler.isEnabled(); | |
| }; | |
| /** @type {function(): undefined} */ | |
| k.le = Ha; | |
| /** | |
| * @param {!Object} item | |
| * @param {number} file | |
| * @param {boolean} x | |
| * @return {undefined} | |
| */ | |
| k.Od = function(item, file, x) { | |
| Ar.D.Od.call(this, item, file, x); | |
| if ((item = item.j()) && 1 == file) { | |
| /** @type {boolean} */ | |
| item.disabled = x; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {?} | |
| */ | |
| k.aa = function(type) { | |
| return type.value; | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| k.Vf = function(name, value) { | |
| if (name) { | |
| /** @type {string} */ | |
| name.value = value; | |
| } | |
| }; | |
| /** @type {function(): undefined} */ | |
| k.uc = Ha; | |
| /** | |
| * @param {?} path | |
| * @param {?} x | |
| * @param {?} y | |
| * @return {undefined} | |
| */ | |
| var Br = function(path, x, y) { | |
| lr.call(this, path, x || Ar.N(), y); | |
| }; | |
| x(Br, lr); | |
| k = Br.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| k.aa = function() { | |
| return this.ea; | |
| }; | |
| /** | |
| * @param {boolean} name | |
| * @return {undefined} | |
| */ | |
| k.Wf = function(name) { | |
| /** @type {boolean} */ | |
| this.ea = name; | |
| this.c.Vf(this.j(), name); | |
| }; | |
| /** | |
| * @param {!Function} key | |
| * @return {undefined} | |
| */ | |
| k.Nd = function(key) { | |
| /** @type {!Function} */ | |
| this.h = key; | |
| fr(this.j(), key); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.X = function() { | |
| Br.D.X.call(this); | |
| delete this.ea; | |
| delete this.h; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.ia = function() { | |
| Br.D.ia.call(this); | |
| if (br(this, 32)) { | |
| var x = this.j(); | |
| if (x) { | |
| Y(this).M(x, "keyup", this.me); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} event | |
| * @return {?} | |
| */ | |
| k.me = function(event) { | |
| return 13 == event.keyCode && "key" == event.type || 32 == event.keyCode && "keyup" == event.type ? this.rd(event) : 32 == event.keyCode; | |
| }; | |
| jr("goog-button", function() { | |
| return new Br(null); | |
| }); | |
| /** | |
| * @param {!Object} item | |
| * @return {?} | |
| */ | |
| var Cr = function(item) { | |
| item = item || {}; | |
| var s = item.attributes; | |
| var v = item.content; | |
| var prev = item.disabled; | |
| var x = item.id; | |
| var url = item.Ls; | |
| var value = item.title; | |
| var releaseAuthor = item.Lp; | |
| var m = item.value; | |
| var tagName = P; | |
| /** @type {string} */ | |
| x = '<div role="button"' + (x ? ' id="' + R(x) + '"' : "") + ' class="'; | |
| var obj = item || {}; | |
| item = obj.ws; | |
| var c = obj.disabled; | |
| var type = obj.checked; | |
| var w = obj.width; | |
| /** @type {string} */ | |
| var d = "goog-inline-block jfk-button "; | |
| obj = obj.style; | |
| switch(Na(obj) ? obj.toString() : obj) { | |
| case 0: | |
| /** @type {string} */ | |
| d = d + "jfk-button-standard"; | |
| break; | |
| case 2: | |
| /** @type {string} */ | |
| d = d + "jfk-button-action"; | |
| break; | |
| case 3: | |
| /** @type {string} */ | |
| d = d + "jfk-button-primary"; | |
| break; | |
| case 1: | |
| /** @type {string} */ | |
| d = d + "jfk-button-default"; | |
| break; | |
| case 4: | |
| /** @type {string} */ | |
| d = d + "jfk-button-flat"; | |
| break; | |
| case 5: | |
| /** @type {string} */ | |
| d = d + "jfk-button-mini"; | |
| break; | |
| case 6: | |
| /** @type {string} */ | |
| d = d + "jfk-button-contrast"; | |
| break; | |
| default: | |
| /** @type {string} */ | |
| d = d + "jfk-button-standard"; | |
| } | |
| /** @type {string} */ | |
| d = d + ((fn(w, 1) ? " jfk-button-narrow" : "") + (type ? " jfk-button-checked" : "") + (item ? " " + item : "") + (c ? " jfk-button-disabled" : "")); | |
| /** @type {string} */ | |
| prev = x + R(d) + '"' + (prev ? ' aria-disabled="true"' : ' tabindex="' + (url ? R(url) : "0") + '"') + (value ? releaseAuthor ? ' data-tooltip="' + R(value) + '"' : ' title="' + R(value) + '"' : "") + (m ? ' value="' + R(m) + '"' : ""); | |
| if (s) { | |
| if (dn(s, Um, bn)) { | |
| s = s.Ya().replace(/([^"'\s])$/, "$1 "); | |
| } else { | |
| /** @type {string} */ | |
| s = String(s); | |
| if (!Cn.test(s)) { | |
| Za("Bad value `%s` for |filterHtmlAttributes", [s]); | |
| /** @type {string} */ | |
| s = "zSoyz"; | |
| } | |
| } | |
| /** @type {string} */ | |
| s = " " + s; | |
| } else { | |
| /** @type {string} */ | |
| s = ""; | |
| } | |
| return tagName(prev + s + ">" + Q(null != v ? v : "") + "</div>"); | |
| }; | |
| /** @type {string} */ | |
| Cr.a = "jfk.templates.button.strict"; | |
| /** | |
| * @param {string} _f | |
| * @param {string} c | |
| * @param {number} val | |
| * @return {undefined} | |
| */ | |
| var Dr = function(_f, c, val) { | |
| hg.call(this); | |
| /** @type {string} */ | |
| this.Hc = _f; | |
| this.c = c || 0; | |
| /** @type {number} */ | |
| this.a = val; | |
| this.b = v(this.ih, this); | |
| }; | |
| x(Dr, hg); | |
| k = Dr.prototype; | |
| /** @type {number} */ | |
| k.va = 0; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.X = function() { | |
| Dr.D.X.call(this); | |
| this.stop(); | |
| delete this.Hc; | |
| delete this.a; | |
| }; | |
| /** | |
| * @param {number} s | |
| * @return {undefined} | |
| */ | |
| k.start = function(s) { | |
| this.stop(); | |
| this.va = ci(this.b, q(s) ? s : this.c); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.stop = function() { | |
| if (this.tb()) { | |
| di(this.va); | |
| } | |
| /** @type {number} */ | |
| this.va = 0; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.tb = function() { | |
| return 0 != this.va; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.ih = function() { | |
| /** @type {number} */ | |
| this.va = 0; | |
| if (this.Hc) { | |
| this.Hc.call(this.a); | |
| } | |
| }; | |
| /** | |
| * @param {string} originalBaseURL | |
| * @return {?} | |
| */ | |
| var Gr = function(originalBaseURL) { | |
| return ie(zc(originalBaseURL.replace(Er, function(b, data) { | |
| return Fr.test(data) ? "" : " "; | |
| }).replace(/[\t\n ]+/g, " "))); | |
| }; | |
| /** @type {!RegExp} */ | |
| var Fr = /^(?:abbr|acronym|address|b|em|i|small|strong|su[bp]|u)$/i; | |
| /** @type {!RegExp} */ | |
| var Er = /<[!\/]?([a-z0-9]+)([\/ ][^>]*)?>/gi; | |
| C.platform = {}; | |
| /** | |
| * @return {?} | |
| */ | |
| C.platform.Ve = function() { | |
| if (C.Fd) { | |
| /** @type {!RegExp} */ | |
| var match = /Windows NT ([0-9.]+)/; | |
| return (match = match.exec(C.Md())) ? match[1] : "0"; | |
| } | |
| return C.yb ? (match = /10[_.][0-9_.]+/, (match = match.exec(C.Md())) ? match[0].replace(/_/g, ".") : "10") : C.Kc ? (match = /Android\s+([^\);]+)(\)|;)/, (match = match.exec(C.Md())) ? match[1] : "") : C.vc || C.Lc || C.Mk ? (match = /(?:iPhone|CPU)\s+OS\s+(\S+)/, (match = match.exec(C.Md())) ? match[1].replace(/_/g, ".") : "") : ""; | |
| }; | |
| C.platform.VERSION = C.platform.Ve(); | |
| /** | |
| * @param {!Object} bits | |
| * @return {?} | |
| */ | |
| C.platform.ub = function(bits) { | |
| return 0 <= Oc(C.platform.VERSION, bits); | |
| }; | |
| /** | |
| * @param {number} m | |
| * @param {number} l | |
| * @param {(Object|string)} p | |
| * @param {!Object} shape | |
| * @param {!Object} obj | |
| * @param {!Object} i | |
| * @param {number} n | |
| * @param {!Object} parent | |
| * @param {!Object} after | |
| * @return {?} | |
| */ | |
| var Kr = function(m, l, p, shape, obj, i, n, parent, after) { | |
| z(p); | |
| var padding = Hr(p); | |
| var result = bq(m); | |
| var a = Tp(m); | |
| if (a) { | |
| var b = new Ep(a.left, a.top, a.right - a.left, a.bottom - a.top); | |
| /** @type {number} */ | |
| a = Math.max(result.left, b.left); | |
| /** @type {number} */ | |
| var t = Math.min(result.left + result.width, b.left + b.width); | |
| if (a <= t) { | |
| /** @type {number} */ | |
| var c = Math.max(result.top, b.top); | |
| /** @type {number} */ | |
| b = Math.min(result.top + result.height, b.top + b.height); | |
| if (c <= b) { | |
| /** @type {number} */ | |
| result.left = a; | |
| /** @type {number} */ | |
| result.top = c; | |
| /** @type {number} */ | |
| result.width = t - a; | |
| /** @type {number} */ | |
| result.height = b - c; | |
| } | |
| } | |
| } | |
| a = jf(m); | |
| c = jf(p); | |
| if (a.a != c.a) { | |
| t = a.a.body; | |
| c = gg(c); | |
| b = new cf(0, 0); | |
| var p = vf(hf(t)); | |
| if (ve(p, "parent")) { | |
| var n = t; | |
| do { | |
| var a = p == c ? Sp(n) : Zp(z(n)); | |
| b.x += a.x; | |
| b.a += a.a; | |
| } while (p && p != c && p != p.parent && (n = p.frameElement) && (p = p.parent)); | |
| } | |
| t = ef(b, Sp(t)); | |
| if (!(!C.V || C.kb(9) || rf(a.a))) { | |
| t = ef(t, uf(a.a)); | |
| } | |
| result.left += t.x; | |
| result.top += t.a; | |
| } | |
| m = Ir(m, l); | |
| l = result.left; | |
| if (m & 4) { | |
| l = l + result.width; | |
| } else { | |
| if (m & 2) { | |
| l = l + result.width / 2; | |
| } | |
| } | |
| result = new cf(l, result.top + (m & 1 ? result.height : 0)); | |
| result = ef(result, padding); | |
| if (obj) { | |
| result.x += (m & 4 ? -1 : 1) * obj.x; | |
| result.a += (m & 1 ? -1 : 1) * obj.a; | |
| } | |
| if (n) { | |
| if (after) { | |
| /** @type {!Object} */ | |
| var pos = after; | |
| } else { | |
| if (pos = Tp(p)) { | |
| pos.top -= padding.a; | |
| pos.right -= padding.x; | |
| pos.bottom -= padding.a; | |
| pos.left -= padding.x; | |
| } | |
| } | |
| } | |
| return Jr(result, p, shape, i, pos, n, parent); | |
| }; | |
| /** | |
| * @param {!Object} el | |
| * @return {?} | |
| */ | |
| var Hr = function(el) { | |
| if (el = el.offsetParent) { | |
| /** @type {boolean} */ | |
| var src = "HTML" == el.tagName || "BODY" == el.tagName; | |
| if (!src || "static" != Lp(el, "position")) { | |
| var dom = Sp(el); | |
| if (!src) { | |
| src = gq(el); | |
| var w; | |
| if (w = src) { | |
| w = C.product.ee && C.product.ub(10); | |
| var h = C.oi && C.platform.ub(10); | |
| w = C.Ja || w || h; | |
| } | |
| src = w ? -el.scrollLeft : !src || C.li && C.Ea("8") || "visible" == Lp(el, "overflowX") ? el.scrollLeft : el.scrollWidth - el.clientWidth - el.scrollLeft; | |
| dom = ef(dom, new cf(src, el.scrollTop)); | |
| } | |
| } | |
| } | |
| return dom || new cf; | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @param {!Object} el | |
| * @param {!Object} s | |
| * @param {!Object} pos | |
| * @param {!Object} node | |
| * @param {number} data | |
| * @param {!Object} e | |
| * @return {?} | |
| */ | |
| var Jr = function(options, el, s, pos, node, data, e) { | |
| options = new cf(options.x, options.a); | |
| var a = Ir(el, s); | |
| s = aq(el); | |
| e = e ? new ff(e.width, e.height) : new ff(s.width, s.height); | |
| options = new cf(options.x, options.a); | |
| e = new ff(e.width, e.height); | |
| /** @type {number} */ | |
| var block = 0; | |
| if (pos || 0 != a) { | |
| if (a & 4) { | |
| options.x -= e.width + (pos ? pos.right : 0); | |
| } else { | |
| if (a & 2) { | |
| options.x -= e.width / 2; | |
| } else { | |
| if (pos) { | |
| options.x += pos.left; | |
| } | |
| } | |
| } | |
| if (a & 1) { | |
| options.a -= e.height + (pos ? pos.bottom : 0); | |
| } else { | |
| if (pos) { | |
| options.a += pos.top; | |
| } | |
| } | |
| } | |
| if (data) { | |
| if (node) { | |
| /** @type {!Object} */ | |
| pos = options; | |
| /** @type {!Object} */ | |
| a = e; | |
| /** @type {number} */ | |
| block = 0; | |
| if (65 == (data & 65) && (pos.x < node.left || pos.x >= node.right)) { | |
| /** @type {number} */ | |
| data = data & -2; | |
| } | |
| if (132 == (data & 132) && (pos.a < node.top || pos.a >= node.bottom)) { | |
| /** @type {number} */ | |
| data = data & -5; | |
| } | |
| if (pos.x < node.left && data & 1) { | |
| pos.x = node.left; | |
| /** @type {number} */ | |
| block = block | 1; | |
| } | |
| if (data & 16) { | |
| var left = pos.x; | |
| if (pos.x < node.left) { | |
| pos.x = node.left; | |
| /** @type {number} */ | |
| block = block | 4; | |
| } | |
| if (pos.x + a.width > node.right) { | |
| /** @type {number} */ | |
| a.width = Math.min(node.right - pos.x, left + a.width - node.left); | |
| /** @type {number} */ | |
| a.width = Math.max(a.width, 0); | |
| /** @type {number} */ | |
| block = block | 4; | |
| } | |
| } | |
| if (pos.x + a.width > node.right && data & 1) { | |
| /** @type {number} */ | |
| pos.x = Math.max(node.right - a.width, node.left); | |
| /** @type {number} */ | |
| block = block | 1; | |
| } | |
| if (data & 2) { | |
| /** @type {number} */ | |
| block = block | ((pos.x < node.left ? 16 : 0) | (pos.x + a.width > node.right ? 32 : 0)); | |
| } | |
| if (pos.a < node.top && data & 4) { | |
| pos.a = node.top; | |
| /** @type {number} */ | |
| block = block | 2; | |
| } | |
| if (data & 32) { | |
| left = pos.a; | |
| if (pos.a < node.top) { | |
| pos.a = node.top; | |
| /** @type {number} */ | |
| block = block | 8; | |
| } | |
| if (pos.a + a.height > node.bottom) { | |
| /** @type {number} */ | |
| a.height = Math.min(node.bottom - pos.a, left + a.height - node.top); | |
| /** @type {number} */ | |
| a.height = Math.max(a.height, 0); | |
| /** @type {number} */ | |
| block = block | 8; | |
| } | |
| } | |
| if (pos.a + a.height > node.bottom && data & 4) { | |
| /** @type {number} */ | |
| pos.a = Math.max(node.bottom - a.height, node.top); | |
| /** @type {number} */ | |
| block = block | 2; | |
| } | |
| if (data & 8) { | |
| /** @type {number} */ | |
| block = block | ((pos.a < node.top ? 64 : 0) | (pos.a + a.height > node.bottom ? 128 : 0)); | |
| } | |
| /** @type {number} */ | |
| node = block; | |
| } else { | |
| /** @type {number} */ | |
| node = 256; | |
| } | |
| /** @type {!Object} */ | |
| block = node; | |
| } | |
| data = new Ep(0, 0, 0, 0); | |
| data.left = options.x; | |
| data.top = options.a; | |
| data.width = e.width; | |
| data.height = e.height; | |
| /** @type {number} */ | |
| node = block; | |
| if (node & 496) { | |
| return node; | |
| } | |
| Np(el, new cf(data.left, data.top)); | |
| e = new ff(data.width, data.height); | |
| if (!(s == e || s && e && s.width == e.width && s.height == e.height)) { | |
| /** @type {!Object} */ | |
| s = e; | |
| options = hf(el); | |
| e = rf(jf(options).a); | |
| if (!C.V || C.Ea("10") || e && C.Ea("8")) { | |
| jq(el, s, "border-box"); | |
| } else { | |
| options = el.style; | |
| if (e) { | |
| e = nq(el); | |
| el = Up(el); | |
| /** @type {number} */ | |
| options.pixelWidth = s.width - el.left - e.left - e.right - el.right; | |
| /** @type {number} */ | |
| options.pixelHeight = s.height - el.top - e.top - e.bottom - el.bottom; | |
| } else { | |
| options.pixelWidth = s.width; | |
| options.pixelHeight = s.height; | |
| } | |
| } | |
| } | |
| return node; | |
| }; | |
| /** | |
| * @param {!Object} out | |
| * @param {number} type | |
| * @return {?} | |
| */ | |
| var Ir = function(out, type) { | |
| return (type & 8 && gq(out) ? type ^ 4 : type) & -9; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Lr = function() { | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Lr.prototype.c = function() { | |
| }; | |
| /** | |
| * @param {string} g | |
| * @param {?} margin | |
| * @return {undefined} | |
| */ | |
| var Mr = function(g, margin) { | |
| /** @type {string} */ | |
| this.g = g; | |
| /** @type {boolean} */ | |
| this.m = !!margin; | |
| this.o = { | |
| 0 : this.g + "-arrowright", | |
| 1 : this.g + "-arrowup", | |
| 2 : this.g + "-arrowdown", | |
| 3 : this.g + "-arrowleft" | |
| }; | |
| }; | |
| x(Mr, Lr); | |
| k = Mr.prototype; | |
| /** @type {boolean} */ | |
| k.og = false; | |
| /** @type {number} */ | |
| k.Og = 2; | |
| /** @type {number} */ | |
| k.Ii = 20; | |
| /** @type {number} */ | |
| k.Qg = 3; | |
| /** @type {number} */ | |
| k.Kh = -5; | |
| /** @type {boolean} */ | |
| k.wf = false; | |
| /** | |
| * @param {?} cell | |
| * @param {number} cols | |
| * @param {string} c | |
| * @param {!Array} n | |
| * @param {string} data | |
| * @return {undefined} | |
| */ | |
| var Nr = function(cell, cols, c, n, data) { | |
| if (null != cols) { | |
| /** @type {number} */ | |
| cell.Qg = cols; | |
| } | |
| if (null != c) { | |
| /** @type {string} */ | |
| cell.Og = c; | |
| } | |
| if (Aa(n)) { | |
| /** @type {number} */ | |
| cell.Ii = Math.max(n, 15); | |
| } | |
| if (Aa(data)) { | |
| /** @type {string} */ | |
| cell.Kh = data; | |
| } | |
| }; | |
| /** | |
| * @param {string} type | |
| * @param {string} value | |
| * @param {string} str | |
| * @return {undefined} | |
| */ | |
| Mr.prototype.c = function(type, value, str) { | |
| z(this.h, "Must call setElements first."); | |
| type = this.Og; | |
| if (2 == type) { | |
| /** @type {number} */ | |
| type = 0; | |
| } | |
| Or(this, this.Qg, type, 2 == this.Og ? Pr(this.Qg) ? this.a.offsetHeight / 2 : this.a.offsetWidth / 2 : this.Ii, 0, str); | |
| }; | |
| /** | |
| * @param {!Object} args | |
| * @param {number} left | |
| * @param {?} src | |
| * @param {number} node | |
| * @param {number} obj | |
| * @param {?} f | |
| * @return {undefined} | |
| */ | |
| var Or = function(args, left, src, node, obj, f) { | |
| if (args.b) { | |
| var g = Qr(left, src); | |
| var e = args.b; | |
| var h = aq(e); | |
| /** @type {number} */ | |
| h = (Pr(left) ? h.height / 2 : h.width / 2) - node; | |
| var result = Ir(e, g); | |
| var rect; | |
| if (rect = Tp(e)) { | |
| e = Fp(bq(e)); | |
| if (Pr(left)) { | |
| if (e.top < rect.top && !(result & 1)) { | |
| /** @type {number} */ | |
| h = h - (rect.top - e.top); | |
| } else { | |
| if (e.bottom > rect.bottom && result & 1) { | |
| /** @type {number} */ | |
| h = h - (e.bottom - rect.bottom); | |
| } | |
| } | |
| } else { | |
| if (e.left < rect.left && !(result & 4)) { | |
| /** @type {number} */ | |
| h = h - (rect.left - e.left); | |
| } else { | |
| if (e.right > rect.right && result & 4) { | |
| /** @type {number} */ | |
| h = h - (e.right - rect.right); | |
| } | |
| } | |
| } | |
| } | |
| /** @type {number} */ | |
| e = h; | |
| e = Pr(left) ? new cf(args.Kh, e) : new cf(e, args.Kh); | |
| /** @type {number} */ | |
| h = Pr(left) ? 6 : 9; | |
| if (args.wf && 2 == obj) { | |
| /** @type {number} */ | |
| h = Pr(left) ? 4 : 1; | |
| } | |
| /** @type {number} */ | |
| result = left ^ 3; | |
| if (Pr(left) && "rtl" == args.b.dir) { | |
| /** @type {number} */ | |
| result = left; | |
| } | |
| g = Kr(args.b, Qr(result, src), args.a, g, e, f, args.og ? h : 0, void 0, null); | |
| if (2 != obj && g & 496) { | |
| Or(args, left ^ 3, src, node, args.wf && 0 == obj ? 1 : 2, f); | |
| return; | |
| } | |
| if (!(!args.m || g & 496)) { | |
| /** @type {number} */ | |
| obj = parseFloat(args.a.style.left); | |
| /** @type {number} */ | |
| f = parseFloat(args.a.style.top); | |
| z(!isNaN(obj) && !isNaN(f), "Could not parse position."); | |
| if (!(isFinite(obj) && 0 == obj % 1 && isFinite(f) && 0 == f % 1)) { | |
| Np(args.a, Math.round(obj), Math.round(f)); | |
| } | |
| } | |
| } | |
| Rr(args, left, src, node); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {number} i | |
| * @param {number} m | |
| * @param {number} b | |
| * @return {undefined} | |
| */ | |
| var Rr = function(a, i, m, b) { | |
| var t = a.h; | |
| Mb(a.o, function(attrs) { | |
| V(t, attrs, false); | |
| }, a); | |
| T(t, a.o[i]); | |
| /** @type {string} */ | |
| t.style.top = t.style.left = t.style.right = t.style.bottom = ""; | |
| if (a.b) { | |
| m = Yp(a.b, a.a); | |
| b = Sr(a.b, i); | |
| if (Pr(i)) { | |
| /** @type {string} */ | |
| t.style.top = Tr(m.a + b.a, a.a.offsetHeight - 15) + "px"; | |
| } else { | |
| /** @type {string} */ | |
| t.style.left = Tr(m.x + b.x, a.a.offsetWidth - 15) + "px"; | |
| } | |
| } else { | |
| /** @type {string} */ | |
| t.style[0 == m ? Pr(i) ? "top" : "left" : Pr(i) ? "bottom" : "right"] = b + "px"; | |
| } | |
| }; | |
| /** | |
| * @param {?} a | |
| * @param {number} opt_max | |
| * @return {?} | |
| */ | |
| var Tr = function(a, opt_max) { | |
| return 15 > opt_max ? 15 : Math.min(Math.max(a, 15), opt_max); | |
| }; | |
| /** | |
| * @param {number} option | |
| * @param {?} header | |
| * @return {?} | |
| */ | |
| var Qr = function(option, header) { | |
| switch(option) { | |
| case 2: | |
| return 0 == header ? 1 : 5; | |
| case 1: | |
| return 0 == header ? 0 : 4; | |
| case 0: | |
| return 0 == header ? 12 : 13; | |
| default: | |
| return 0 == header ? 8 : 9; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} s | |
| * @param {number} prefix | |
| * @return {?} | |
| */ | |
| var Sr = function(s, prefix) { | |
| /** @type {number} */ | |
| var pd = 0; | |
| /** @type {number} */ | |
| var itemHeight = 0; | |
| s = aq(s); | |
| switch(prefix) { | |
| case 2: | |
| /** @type {number} */ | |
| pd = s.width / 2; | |
| break; | |
| case 1: | |
| /** @type {number} */ | |
| pd = s.width / 2; | |
| itemHeight = s.height; | |
| break; | |
| case 0: | |
| /** @type {number} */ | |
| itemHeight = s.height / 2; | |
| break; | |
| case 3: | |
| pd = s.width; | |
| /** @type {number} */ | |
| itemHeight = s.height / 2; | |
| } | |
| return new cf(pd, itemHeight); | |
| }; | |
| /** | |
| * @param {number} b | |
| * @return {?} | |
| */ | |
| var Pr = function(b) { | |
| return 0 == b || 3 == b; | |
| }; | |
| /** | |
| * @param {string} b | |
| * @return {undefined} | |
| */ | |
| var Ur = function(b) { | |
| hg.call(this); | |
| this.b = b || jf(); | |
| }; | |
| x(Ur, hg); | |
| /** | |
| * @return {undefined} | |
| */ | |
| Ur.prototype.h = function() { | |
| lp(this.j(), "tooltip"); | |
| np(this.j(), "live", "polite"); | |
| }; | |
| /** | |
| * @param {?} fragment | |
| * @return {undefined} | |
| */ | |
| var Vr = function(fragment) { | |
| Ur.call(this, fragment); | |
| this.a = this.b.b("DIV", "jfk-tooltip-contentId"); | |
| this.g = this.b.b("DIV", "jfk-tooltip-arrow", this.b.b("DIV", "jfk-tooltip-arrowimplbefore"), this.b.b("DIV", "jfk-tooltip-arrowimplafter")); | |
| this.c = this.b.b("DIV", { | |
| "class" : "jfk-tooltip", | |
| role : "tooltip" | |
| }, this.a, this.g); | |
| this.h(); | |
| }; | |
| x(Vr, Ur); | |
| /** | |
| * @return {?} | |
| */ | |
| Vr.prototype.j = function() { | |
| return this.c; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Vr.prototype.X = function() { | |
| Vr.D.X.call(this); | |
| if (this.c) { | |
| Jf(this.c); | |
| } | |
| }; | |
| /** | |
| * @param {?} p1__3354_SHARP_ | |
| * @return {undefined} | |
| */ | |
| var Wr = function(p1__3354_SHARP_) { | |
| Vr.call(this, p1__3354_SHARP_); | |
| }; | |
| x(Wr, Vr); | |
| /** | |
| * @return {undefined} | |
| */ | |
| Wr.prototype.h = function() { | |
| lp(this.j(), "tooltip"); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| var Yr = function(a) { | |
| var titleEscaped = a.getAttribute("title"); | |
| if (titleEscaped) { | |
| Xr(a, titleEscaped); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Object} b | |
| * @param {!Object} r | |
| * @return {undefined} | |
| */ | |
| var Xr = function(a, b, r) { | |
| if (!r) { | |
| r = b instanceof Cd ? Gr(Dd(b).toString()) : b; | |
| } | |
| a.removeAttribute("title"); | |
| a.removeAttribute("data-tooltip-contained"); | |
| a.removeAttribute("data-tooltip"); | |
| if (b) { | |
| if (b instanceof Cd) { | |
| /** @type {!Object} */ | |
| a.a = b; | |
| } else { | |
| a.setAttribute("data-tooltip", b); | |
| /** @type {null} */ | |
| a.a = null; | |
| } | |
| a.setAttribute("aria-label", r); | |
| } else { | |
| /** @type {null} */ | |
| a.a = null; | |
| a.removeAttribute("aria-label"); | |
| } | |
| a = jf(a) || jf(); | |
| b = Qa(a.a); | |
| if (!Zr[b]) { | |
| Zr[b] = new $r(a); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @param {number} indent | |
| * @return {undefined} | |
| */ | |
| var as = function(value, indent) { | |
| /** @type {string} */ | |
| var x = ""; | |
| switch(indent) { | |
| case 0: | |
| /** @type {string} */ | |
| x = x + "l"; | |
| break; | |
| case 2: | |
| /** @type {string} */ | |
| x = x + "t"; | |
| break; | |
| case 3: | |
| /** @type {string} */ | |
| x = x + "r"; | |
| break; | |
| default: | |
| /** @type {string} */ | |
| x = x + "b"; | |
| } | |
| value.setAttribute("data-tooltip-align", x + ",c"); | |
| }; | |
| var Zr = {}; | |
| /** | |
| * @param {!Object} prop | |
| * @return {undefined} | |
| */ | |
| var $r = function(prop) { | |
| rq.call(this); | |
| /** @type {!Object} */ | |
| this.K = prop; | |
| this.L = new Dr(this.Z, 0, this); | |
| jg(this, this.L); | |
| var message = vf(); | |
| this.w = Ma(message.MutationObserver) ? new message.MutationObserver(v(this.W, this)) : null; | |
| prop = prop.a; | |
| this.M(prop, "mouseout mousedown click blur focusout keydown".split(" "), this.T, true); | |
| this.M(prop, ["mouseover", "focus", "focusin"], this.oa, true); | |
| }; | |
| x($r, rq); | |
| /** | |
| * @return {undefined} | |
| */ | |
| $r.prototype.X = function() { | |
| bs(this); | |
| $r.D.X.call(this); | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @param {!Object} e | |
| * @return {undefined} | |
| */ | |
| var cs = function(options, e) { | |
| switch(e.type) { | |
| case "mousedown": | |
| case "mouseover": | |
| case "mouseout": | |
| case "click": | |
| /** @type {boolean} */ | |
| options.R = false; | |
| break; | |
| case "keydown": | |
| /** @type {boolean} */ | |
| options.R = true; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| $r.prototype.oa = function(name) { | |
| if (this.w) { | |
| this.w.disconnect(); | |
| } | |
| cs(this, name); | |
| var node = name.target; | |
| /** @type {boolean} */ | |
| name = "focus" == name.type || "focusin" == name.type; | |
| var c = this.a && Pf(this.a.a, node); | |
| if (this.R || !name || c) { | |
| /** @type {!Object} */ | |
| this.Y = name; | |
| if (name = node && node.getAttribute && this.w) { | |
| name = node.getAttribute("role") || null; | |
| name = tb(kp, name); | |
| } | |
| if (name) { | |
| this.w.observe(node, { | |
| attributes : true | |
| }); | |
| if (name = pp(node)) { | |
| /** @type {!Object} */ | |
| node = name; | |
| } | |
| } | |
| this.g = node; | |
| } else { | |
| /** @type {null} */ | |
| this.g = null; | |
| } | |
| ds(this); | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| $r.prototype.T = function(type) { | |
| cs(this, type); | |
| var name = type.target; | |
| /** @type {boolean} */ | |
| type = "mousedown" == type.type || "click" == type.type; | |
| name = this.a && Pf(this.a.a, name); | |
| if (!(type && name)) { | |
| /** @type {null} */ | |
| this.g = null; | |
| ds(this); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| $r.prototype.W = function(name) { | |
| A(name, v(function(mutation) { | |
| var g = pp(mutation.target); | |
| if (g && "aria-activedescendant" == mutation.attributeName) { | |
| this.g = g; | |
| ds(this); | |
| } | |
| }, this)); | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @return {undefined} | |
| */ | |
| var ds = function(o) { | |
| if (!(o.L.tb() && o.b && o.o)) { | |
| bs(o); | |
| var tiles_bullet = null != o.o ? o.o : 50; | |
| o.L.start(o.b ? tiles_bullet : 300); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} params | |
| * @return {undefined} | |
| */ | |
| var bs = function(params) { | |
| if (params.G) { | |
| di(params.G); | |
| /** @type {number} */ | |
| params.G = 0; | |
| /** @type {null} */ | |
| params.b = null; | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| $r.prototype.Z = function() { | |
| if (!this.g) { | |
| es(this); | |
| /** @type {null} */ | |
| this.o = this.b = null; | |
| } else { | |
| if (!(this.b && this.a && Pf(this.a.j(), this.g)) || this.b.getAttribute("data-tooltip-unhoverable")) { | |
| var b = cg(this.g, function(img) { | |
| return img.getAttribute && (img.getAttribute("data-tooltip-contained") || img.getAttribute("data-tooltip") || img.a) && !img.getAttribute("data-tooltip-suspended"); | |
| }); | |
| /** @type {boolean} */ | |
| var p = false; | |
| if (this.b && this.b != b) { | |
| es(this); | |
| /** @type {null} */ | |
| this.o = this.b = null; | |
| /** @type {boolean} */ | |
| p = true; | |
| } | |
| if (!this.b && b && (this.b = b, fs(this, b))) { | |
| var realVal = Md; | |
| if (b.getAttribute("data-tooltip-contained")) { | |
| var c = nf("jfk-tooltip-data", b); | |
| /** @type {number} */ | |
| var t = 0; | |
| for (; t < c.length; t++) { | |
| if (c[t].parentNode == b) { | |
| realVal = c[t].cloneNode(true); | |
| break; | |
| } | |
| } | |
| } else { | |
| realVal = b.a ? b.a : Gd(b.getAttribute("data-tooltip")); | |
| } | |
| c = b.getAttribute("data-tooltip-align"); | |
| t = b.getAttribute("data-tooltip-class"); | |
| var a = b.getAttribute("data-tooltip-offset"); | |
| /** @type {number} */ | |
| a = xc(me(a)) ? -1 : Number(a); | |
| var id = b.getAttribute("data-tooltip-hide-delay"); | |
| /** @type {(null|number)} */ | |
| id = xc(me(id)) ? null : Number(id); | |
| if (!p && (b = b.getAttribute("data-tooltip-delay"), b = Math.max(0, b - 300))) { | |
| this.G = ci(Ta(this.O, this.b, realVal, c, a, t, id), b, this); | |
| return; | |
| } | |
| this.O(this.b, realVal, c, a, t, id); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {?} context | |
| * @param {!Element} elem | |
| * @return {?} | |
| */ | |
| var fs = function(context, elem) { | |
| return elem.getAttribute("data-tooltip-only-on-overflow") && elem.offsetWidth >= elem.scrollWidth && elem.offsetHeight >= elem.scrollHeight || context.Y && "mouse" == elem.getAttribute("data-tooltip-trigger") ? false : true; | |
| }; | |
| /** | |
| * @param {string} val | |
| * @return {?} | |
| */ | |
| var gs = function(val) { | |
| if (val) { | |
| switch(val.toLowerCase().split(",")[0]) { | |
| case "l": | |
| return 0; | |
| case "t": | |
| return 2; | |
| case "r": | |
| return 3; | |
| } | |
| } | |
| return 1; | |
| }; | |
| /** | |
| * @param {string} type | |
| * @param {!Object} value | |
| * @param {string} x | |
| * @param {string} b | |
| * @param {!Function} a | |
| * @param {!Object} e | |
| * @return {undefined} | |
| */ | |
| $r.prototype.O = function(type, value, x, b, a, e) { | |
| /** @type {number} */ | |
| this.G = 0; | |
| /** @type {!Object} */ | |
| this.o = e; | |
| if (!this.a) { | |
| this.a = new Wr(this.K); | |
| es(this); | |
| Df(this.K.a.body, this.a.j()); | |
| jg(this, this.a); | |
| this.h = new Mr("jfk-tooltip", true); | |
| /** @type {boolean} */ | |
| this.h.og = true; | |
| /** @type {boolean} */ | |
| this.h.wf = true; | |
| e = this.h; | |
| var g = this.a.g; | |
| e.a = this.a.j(); | |
| e.h = g; | |
| } | |
| a: { | |
| if (x) { | |
| switch(x.toLowerCase().split(",")[1]) { | |
| case "l": | |
| /** @type {number} */ | |
| e = 0; | |
| break a; | |
| case "r": | |
| /** @type {number} */ | |
| e = 1; | |
| break a; | |
| } | |
| } | |
| /** @type {number} */ | |
| e = 2; | |
| } | |
| Nr(this.h, gs(x), e, void 0, b); | |
| U(this.a.j(), "jfk-tooltip-hide"); | |
| if (this.C != a) { | |
| if (this.C && !xc(me(this.C))) { | |
| U(this.a.j(), this.C); | |
| } | |
| if (!xc(me(a))) { | |
| T(this.a.j(), a); | |
| } | |
| /** @type {!Function} */ | |
| this.C = a; | |
| } | |
| Np(this.a.j(), 0, 0); | |
| if (value instanceof Cd) { | |
| Wd(this.a.a, value); | |
| } else { | |
| Ff(this.a.a); | |
| for (; x = value.firstChild;) { | |
| this.a.a.appendChild(x); | |
| } | |
| } | |
| /** @type {string} */ | |
| this.h.b = type; | |
| this.h.c(null, 0); | |
| }; | |
| /** | |
| * @param {(number|string)} selector | |
| * @return {undefined} | |
| */ | |
| var es = function(selector) { | |
| if (selector.a) { | |
| T(selector.a.j(), "jfk-tooltip-hide"); | |
| } | |
| }; | |
| /** | |
| * @param {?} a | |
| * @param {?} b | |
| * @param {string} status | |
| * @param {string} size | |
| * @return {undefined} | |
| */ | |
| var is = function(a, b, status, size) { | |
| Br.call(this, a, hs.N(), b); | |
| this.m = status || 0; | |
| this.O = size || 0; | |
| /** @type {boolean} */ | |
| this.Ta = false; | |
| }; | |
| x(is, Br); | |
| /** | |
| * @param {!Object} config | |
| * @param {!Array} local | |
| * @return {undefined} | |
| */ | |
| var ks = function(config, local) { | |
| if (config.m != local) { | |
| /** @type {!Array} */ | |
| config.m = local; | |
| js(config); | |
| } | |
| }; | |
| k = is.prototype; | |
| /** | |
| * @param {number} x | |
| * @return {undefined} | |
| */ | |
| k.Nd = function(x) { | |
| /** @type {number} */ | |
| this.h = x; | |
| var j = this.j(); | |
| if (j) { | |
| if (this.Ta) { | |
| Xr(j, x, void 0); | |
| } else { | |
| if (x) { | |
| /** @type {number} */ | |
| j.title = x; | |
| } else { | |
| j.removeAttribute("title"); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {boolean} v | |
| * @return {undefined} | |
| */ | |
| k.sa = function(v) { | |
| if (this.isEnabled() != v) { | |
| is.D.sa.call(this, v); | |
| js(this); | |
| } | |
| }; | |
| /** | |
| * @param {boolean} a | |
| * @return {undefined} | |
| */ | |
| k.ze = function(a) { | |
| is.D.ze.call(this, a); | |
| ls(this, false); | |
| }; | |
| /** | |
| * @param {!Object} key_event | |
| * @return {undefined} | |
| */ | |
| k.Fb = function(key_event) { | |
| is.D.Fb.call(this, key_event); | |
| if (this.isEnabled()) { | |
| ls(this, true); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} key_event | |
| * @return {undefined} | |
| */ | |
| k.Nb = function(key_event) { | |
| is.D.Nb.call(this, key_event); | |
| if (this.isEnabled()) { | |
| ls(this, true); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} args | |
| * @param {string} tags | |
| * @return {undefined} | |
| */ | |
| var ls = function(args, tags) { | |
| if (args.j()) { | |
| V(args.j(), "jfk-button-clear-outline", tags); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @return {undefined} | |
| */ | |
| var js = function(options) { | |
| if (options.j()) { | |
| ms(options.c, options); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var hs = function() { | |
| this.K = this.za() + "-standard"; | |
| this.c = this.za() + "-action"; | |
| this.L = this.za() + "-primary"; | |
| this.m = this.za() + "-default"; | |
| this.w = this.za() + "-flat"; | |
| this.C = this.za() + "-narrow"; | |
| this.G = this.za() + "-mini"; | |
| this.o = this.za() + "-contrast"; | |
| }; | |
| x(hs, er); | |
| Ia(hs); | |
| k = hs.prototype; | |
| /** | |
| * @param {!Array} config | |
| * @param {boolean} email | |
| * @param {!Object} options | |
| * @return {undefined} | |
| */ | |
| k.zd = function(config, email, options) { | |
| if (config) { | |
| ks(options, config); | |
| } | |
| if (email && options.O != email) { | |
| /** @type {boolean} */ | |
| options.O = email; | |
| js(options); | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.za = function() { | |
| return "jfk-button"; | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @return {?} | |
| */ | |
| k.Eb = function(data) { | |
| ib(data, is, "Button is expected to be instance of jfk.Button"); | |
| var b = data.a; | |
| var c = Bp(Cr, { | |
| disabled : !data.isEnabled(), | |
| checked : data.Ha(16), | |
| style : data.m, | |
| title : data.h, | |
| Lp : data.Ta, | |
| value : data.aa(), | |
| width : data.O | |
| }, void 0, b); | |
| b.Zi(c, data.Ya()); | |
| this.eb(data, c); | |
| return c; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Object} origin | |
| * @return {?} | |
| */ | |
| k.eb = function(a, origin) { | |
| hs.D.eb.call(this, a, origin); | |
| if (!this.h) { | |
| this.h = Yb(this.K, Ta(this.zd, 0, null), this.c, Ta(this.zd, 2, null), this.L, Ta(this.zd, 3, null), this.m, Ta(this.zd, 1, null), this.w, Ta(this.zd, 4, null), this.G, Ta(this.zd, 5, null), this.o, Ta(this.zd, 6, null), this.C, Ta(this.zd, null, 1)); | |
| } | |
| var d = sp(origin); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < d.length; ++i) { | |
| var b = this.h[d[i]]; | |
| if (b) { | |
| b(a); | |
| } | |
| } | |
| if (d = origin.getAttribute("data-tooltip")) { | |
| a.h = d; | |
| /** @type {boolean} */ | |
| a.Ta = true; | |
| } | |
| return origin; | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {?} | |
| */ | |
| k.aa = function(type) { | |
| return type.getAttribute("value") || ""; | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| k.Vf = function(name, value) { | |
| if (name) { | |
| name.setAttribute("value", value); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @param {!Object} c | |
| * @return {undefined} | |
| */ | |
| var ms = function(o, c) { | |
| /** | |
| * @param {boolean} context | |
| * @param {string} fallback | |
| * @return {undefined} | |
| */ | |
| function map(context, fallback) { | |
| (context ? update : arg).push(fallback); | |
| } | |
| z(c.j(), "Button element must already exist when updating style."); | |
| /** @type {!Array} */ | |
| var update = []; | |
| /** @type {!Array} */ | |
| var arg = []; | |
| var b = c.m; | |
| map(0 == b, o.K); | |
| map(2 == b, o.c); | |
| map(3 == b, o.L); | |
| map(4 == b, o.w); | |
| map(5 == b, o.G); | |
| map(1 == b, o.m); | |
| map(6 == b, o.o); | |
| map(1 == c.O, o.C); | |
| map(!c.isEnabled(), o.za() + "-disabled"); | |
| vp(c.j(), arg); | |
| up(c.j(), update); | |
| }; | |
| /** | |
| * @param {?} s | |
| * @param {?} v | |
| * @return {undefined} | |
| */ | |
| var ns = function(s, v) { | |
| zq.call(this); | |
| this.Y = v; | |
| this.Xa = s; | |
| /** @type {string} */ | |
| this.Bf = this.text = this.Pa = this.Ca = ""; | |
| /** @type {null} */ | |
| this.data = null; | |
| this.Gb = hm.N(); | |
| }; | |
| x(ns, zq); | |
| k = ns.prototype; | |
| /** | |
| * @param {!Object} type | |
| * @param {?} data | |
| * @param {!Object} i | |
| * @param {!Object} str | |
| * @return {?} | |
| */ | |
| k.update = function(type, data, i, str) { | |
| /** @type {!Object} */ | |
| this.text = type; | |
| this.Ca = data; | |
| /** @type {!Object} */ | |
| this.Pa = i; | |
| /** @type {!Object} */ | |
| this.data = str; | |
| this.setVisible(false); | |
| return false; | |
| }; | |
| /** | |
| * @param {boolean} a | |
| * @return {undefined} | |
| */ | |
| k.setVisible = function(a) { | |
| var m3 = this.j(); | |
| if (m3) { | |
| X(m3, a); | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.isVisible = function() { | |
| var data = this.j(); | |
| return data ? dq(data) : false; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.fk = function() { | |
| return {}; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Tb = function() { | |
| return this.Y; | |
| }; | |
| /** | |
| * @param {string} name | |
| * @param {string} type | |
| * @return {undefined} | |
| */ | |
| k.log = function(name, type) { | |
| var data = {}; | |
| data.dt = this.Y; | |
| data.sl = this.Ca; | |
| data.tl = this.Pa; | |
| data.hl = this.Xa; | |
| data.q = this.text; | |
| /** @type {string} */ | |
| data.e = name; | |
| if (null != type) { | |
| Xb(data, type); | |
| } | |
| Xb(data, this.fk()); | |
| this.Gb.log("lexicon", data); | |
| type = this.Ca; | |
| data = this.Pa; | |
| if (window.__gaTracker) { | |
| __gaTracker("set", "dimension1", this.Xa); | |
| __gaTracker("set", "dimension2", type + "|" + data); | |
| __gaTracker("set", "dimension3", type); | |
| __gaTracker("set", "dimension4", data); | |
| } | |
| bh("lexicon", this.Y + ":" + name, "", 1); | |
| }; | |
| /** | |
| * @param {?} mode | |
| * @param {?} name | |
| * @param {number} action | |
| * @param {?} callback | |
| * @param {?} config | |
| * @return {undefined} | |
| */ | |
| var os = function(mode, name, action, callback, config) { | |
| ns.call(this, mode, name); | |
| /** @type {null} */ | |
| this.Zc = this.b = null; | |
| /** @type {number} */ | |
| this.W = action; | |
| this.dk = callback; | |
| this.Z = config; | |
| /** @type {null} */ | |
| this.O = this.h = null; | |
| /** @type {boolean} */ | |
| this.m = false; | |
| /** @type {string} */ | |
| this.ma = "More"; | |
| /** @type {boolean} */ | |
| this.Bc = false; | |
| /** @type {string} */ | |
| this.Da = "Less"; | |
| /** @type {!Array} */ | |
| this.Vb = []; | |
| new Wo("mt"); | |
| /** @type {boolean} */ | |
| this.Gi = false; | |
| this.F = M.N(); | |
| /** @type {!Array} */ | |
| this.c = []; | |
| }; | |
| x(os, ns); | |
| k = os.prototype; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.Ra = function() { | |
| os.D.Ra.call(this); | |
| this.Fa(zf("DIV")); | |
| }; | |
| /** | |
| * @param {?} a | |
| * @return {undefined} | |
| */ | |
| k.Fa = function(a) { | |
| os.D.Fa.call(this, a); | |
| T(this.j(), "gt-cd"); | |
| T(this.j(), "gt-cd-" + this.Y); | |
| Xf(this.j(), true); | |
| this.j().appendChild(Ap(Mn)); | |
| this.Zc = E("gt-cd-tl", this.j()); | |
| this.b = E("gt-cd-c", this.j()); | |
| this.h = E("cd-expand-button", this.j()); | |
| this.O = E("cd-expand-label", this.j()); | |
| X(this.h, false); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.X = function() { | |
| this.Ud(); | |
| os.D.X.call(this); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.ie = function() { | |
| return this.Z; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Ye = function() { | |
| return this.c.length; | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @return {?} | |
| */ | |
| k.gh = function(obj) { | |
| return this.c.indexOf(obj); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.Ud = function() { | |
| /** @type {!Array} */ | |
| this.c = []; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.sb = function() { | |
| return this.Ye(); | |
| }; | |
| /** | |
| * @param {string} value | |
| * @param {?} fn | |
| * @param {!Object} n | |
| * @param {!Object} args | |
| * @return {?} | |
| */ | |
| k.update = function(value, fn, n, args) { | |
| os.D.update.call(this, value, fn, n, args); | |
| /** @type {boolean} */ | |
| this.m = this.Bc = false; | |
| Jf(null); | |
| X(this.h, false); | |
| U(this.h, "collapse"); | |
| ps(this, value); | |
| return false; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.ia = function() { | |
| var minc = this; | |
| os.D.ia.call(this); | |
| if (this.h) { | |
| ah(this.h, this.tp.bind(this)); | |
| } | |
| Y(this).M(this, "a", v(this.Aj, this, "clks"), false); | |
| Y(this).M(this, "b", v(this.Aj, this, "clkt"), false); | |
| if (this.j()) { | |
| Y(this).M(this.j(), "focusout", function(event) { | |
| if (!Pf(minc.j(), event.relatedTarget)) { | |
| U(minc.j(), "clear-outline"); | |
| } | |
| }); | |
| Y(this).M(this.j(), "mousedown", function() { | |
| T(minc.j(), "clear-outline"); | |
| }); | |
| Y(this).M(this.j(), "mouseup", function() { | |
| T(minc.j(), "clear-outline"); | |
| }); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.tp = function() { | |
| /** @type {boolean} */ | |
| this.m = !this.m; | |
| this.Ce(this.m); | |
| if (this.m) { | |
| T(this.h, "collapse"); | |
| H(this.O, this.Da); | |
| this.log("expand"); | |
| Jl(this.F, this.Z, this.sb()); | |
| } else { | |
| U(this.h, "collapse"); | |
| H(this.O, this.ma); | |
| this.log("collapse"); | |
| var Symbol = this.F; | |
| var BidirectionalSubject = this.sb(); | |
| N(Symbol, Gl(Symbol, 189, this.Z, BidirectionalSubject, true, 0)); | |
| } | |
| }; | |
| /** | |
| * @param {string} message | |
| * @param {!Object} x | |
| * @return {undefined} | |
| */ | |
| k.Aj = function(message, x) { | |
| x = x.target; | |
| var Symbol = this.F; | |
| N(Symbol, Gl(Symbol, 79, this.Z, this.Ye(), this.Bc, this.gh(x) + 1)); | |
| x = ag(x); | |
| this.log(message, { | |
| clk : x | |
| }); | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| var ps = function(node, name) { | |
| var f = G("DIV"); | |
| var queryIndex = node.W.indexOf("%1$s"); | |
| if (-1 != queryIndex) { | |
| var path = node.W.slice(0, queryIndex); | |
| queryIndex = node.W.slice(queryIndex + 4, node.W.length); | |
| if (path) { | |
| Ef(f, path); | |
| } | |
| path = G("SPAN", { | |
| "class" : "gt-card-ttl-txt" | |
| }); | |
| Hp(path, "direction", kc(node.Ca) ? "rtl" : "ltr"); | |
| H(path, name); | |
| f.appendChild(path); | |
| if (queryIndex) { | |
| Ef(f, queryIndex); | |
| } | |
| if (node.Zc) { | |
| Ff(node.Zc); | |
| node.Zc.appendChild(f); | |
| } | |
| } else { | |
| if (node.Zc) { | |
| H(node.Zc, node.dk); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Window} params | |
| * @param {!Object} obj | |
| * @param {number} val | |
| * @return {undefined} | |
| */ | |
| var qs = function(params, obj, val) { | |
| /** @type {boolean} */ | |
| params.Bc = true; | |
| X(params.h, true); | |
| if (null != obj) { | |
| /** @type {!Object} */ | |
| params.ma = obj; | |
| } | |
| if (null != val) { | |
| /** @type {number} */ | |
| params.Da = val; | |
| } | |
| H(params.O, params.ma); | |
| }; | |
| /** | |
| * @param {boolean} size | |
| * @return {undefined} | |
| */ | |
| os.prototype.Ce = function(size) { | |
| var obj; | |
| var n; | |
| var stars = nf("gt-card-expand-wrapper", this.j()); | |
| /** @type {number} */ | |
| var t = 0; | |
| for (; t < stars.length; t++) { | |
| obj = stars[t]; | |
| Hp(obj, "max-height", Jp(obj, "height")); | |
| n = obj.firstChild; | |
| var offset = mq(n, "margin"); | |
| n = aq(n).height + offset.top + offset.bottom; | |
| Hp(obj, "max-height", size ? n + "px" : 0); | |
| if (size) { | |
| U(obj, "gt-card-collapsed"); | |
| T(obj, "gt-card-expanded"); | |
| np(obj, "hidden", false); | |
| Hg(obj, qg, function(mutationEvent) { | |
| Hp(mutationEvent.target, "max-height", "unset"); | |
| }, false); | |
| } else { | |
| U(obj, "gt-card-expanded"); | |
| T(obj, "gt-card-collapsed"); | |
| np(obj, "hidden", true); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @param {!Function} node | |
| * @return {?} | |
| */ | |
| var rs = function(obj, node) { | |
| if (node) { | |
| return obj; | |
| } | |
| obj = G("DIV", { | |
| "class" : "gt-card-expand-wrapper gt-card-collapsed" | |
| }, obj); | |
| np(obj, "hidden", true); | |
| return obj; | |
| }; | |
| /** | |
| * @param {boolean} from | |
| * @param {string} d | |
| * @param {!Object} v | |
| * @return {undefined} | |
| */ | |
| var ss = function(from, d, v) { | |
| from.Vb.push([d, v]); | |
| }; | |
| /** | |
| * @param {string} context | |
| * @param {!Object} callback | |
| * @return {?} | |
| */ | |
| var us = function(context, callback) { | |
| /** @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(canCreateDiscussions, isSlidingUp, dontForceConstraints, forceExecution, mmCoreSecondsYear, i, p, b) { | |
| if ("%" == i) { | |
| return "%"; | |
| } | |
| var s = keysToSend.shift(); | |
| if ("undefined" == typeof s) { | |
| throw Error("[goog.string.format] Not enough arguments"); | |
| } | |
| arguments[0] = s; | |
| return ts[i].apply(null, arguments); | |
| }); | |
| }; | |
| var ts = { | |
| s : function(name, value, input) { | |
| return isNaN(input) || "" == input || name.length >= Number(input) ? name : name = -1 < value.indexOf("-", 0) ? name + le(" ", Number(input) - name.length) : le(" ", Number(input) - name.length) + name; | |
| }, | |
| f : function(i, name, n, val, c) { | |
| val = i.toString(); | |
| if (!(isNaN(c) || "" == c)) { | |
| /** @type {string} */ | |
| val = parseFloat(i).toFixed(c); | |
| } | |
| /** @type {string} */ | |
| var prefix = 0 > Number(i) ? "-" : 0 <= name.indexOf("+") ? "+" : 0 <= name.indexOf(" ") ? " " : ""; | |
| if (0 <= Number(i)) { | |
| /** @type {string} */ | |
| val = prefix + val; | |
| } | |
| if (isNaN(n) || val.length >= Number(n)) { | |
| return val; | |
| } | |
| /** @type {string} */ | |
| val = isNaN(c) ? Math.abs(Number(i)).toString() : Math.abs(Number(i)).toFixed(c); | |
| /** @type {number} */ | |
| i = Number(n) - val.length - prefix.length; | |
| return val = 0 <= name.indexOf("-", 0) ? prefix + val + le(" ", i) : prefix + le(0 <= name.indexOf("0", 0) ? "0" : " ", i) + val; | |
| }, | |
| d : function(h, a, c, d, s, v, cb, n) { | |
| return ts.f(parseInt(h, 10), a, c, d, 0, v, cb, n); | |
| } | |
| }; | |
| /** @type {function(?, string, ?, string, ?, ?, ?, ?): ?} */ | |
| ts.i = ts.d; | |
| /** @type {function(?, string, ?, string, ?, ?, ?, ?): ?} */ | |
| ts.u = ts.d; | |
| /** | |
| * @param {?} iter | |
| * @param {!Array} cmds | |
| * @param {string} name | |
| * @param {!Object} e | |
| * @param {?} f | |
| * @param {string} d | |
| * @param {string} options | |
| * @return {undefined} | |
| */ | |
| var vs = function(iter, cmds, name, e, f, d, options) { | |
| os.call(this, iter, null != name && name ? "mbd" : "bd", MSG_TRANSLATIONS_OF, "", 11); | |
| /** @type {string} */ | |
| this.g = name; | |
| this.T = null != e ? e : false; | |
| /** @type {string} */ | |
| this.Aa = ""; | |
| /** @type {string} */ | |
| this.Aa = this.g && this.T ? "gt-baf-cell gt-baf-word" : this.g ? "gt-baf-cell gt-baf-word-clickable" : "gt-baf-word-clickable"; | |
| /** @type {(null|string)} */ | |
| this.C = this.T ? null : "gt-baf-back"; | |
| this.hc = d || ""; | |
| this.ic = options || ""; | |
| /** @type {null} */ | |
| this.w = null; | |
| /** @type {boolean} */ | |
| this.ra = false; | |
| this.ea = null != f ? f : true; | |
| this.K = {}; | |
| this.K[1] = cmds[2]; | |
| this.K[2] = cmds[1]; | |
| this.K[3] = cmds[0]; | |
| this.Ta = cmds[3]; | |
| }; | |
| x(vs, os); | |
| /** | |
| * @param {!Object} d | |
| * @param {?} b | |
| * @param {!Object} result | |
| * @param {!Object} params | |
| * @return {?} | |
| */ | |
| vs.prototype.update = function(d, b, result, params) { | |
| vs.D.update.call(this, d, b, result, params); | |
| if (!params || 0 == J(params, 1)) { | |
| return false; | |
| } | |
| Ff(this.b); | |
| this.Ud(); | |
| this.w = new jh(params); | |
| ws(this, this.w); | |
| d = G("TBODY"); | |
| b = G("TABLE", { | |
| "class" : "gt-baf-table" | |
| }, d); | |
| result = this.w.a; | |
| /** @type {number} */ | |
| var k = 0; | |
| for (; k < result.length; k++) { | |
| var a = result[k]; | |
| var num = xs(this, a, this.g && this.ea && 0 === k); | |
| Df(d, num); | |
| a = a.a; | |
| /** @type {number} */ | |
| var i = num = 0; | |
| for (; i < a.length; i++) { | |
| var result = a[i]; | |
| if (!this.g && this.w.b && 0 < i) { | |
| var offset = nh(result); | |
| var b = G("DIV", { | |
| "class" : "gt-baf-cell gt-baf-sep" | |
| }); | |
| offset = rs(b, offset); | |
| if (!this.g) { | |
| offset = G("TD", { | |
| colspan : 4 | |
| }, offset); | |
| offset = G("TR", null, offset); | |
| } | |
| Df(d, offset); | |
| } | |
| result = result.a; | |
| /** @type {number} */ | |
| offset = 0; | |
| for (; offset < result.length; offset++) { | |
| b = result[offset]; | |
| var height = params.hb(0).dd(); | |
| b = ys(this, b, height, num); | |
| d.appendChild(b); | |
| num++; | |
| } | |
| } | |
| this.b.appendChild(b); | |
| if (0 < kh(this.w)) { | |
| a = this.Ta.replace("%1$s", kh(this.w).toLocaleString(this.Xa)); | |
| qs(this, a, MSG_FEWER_TRANSLATIONS_LABEL); | |
| } | |
| } | |
| this.setVisible(true); | |
| return true; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| vs.prototype.ia = function() { | |
| vs.D.ia.call(this); | |
| T(this.j(), "gt-cd-baf"); | |
| Y(this).M(this.j(), "click", this.Hb); | |
| Y(this).M(this.j(), "mouseover", this.jb); | |
| Y(this).M(this.j(), "mouseout", this.gb); | |
| }; | |
| /** | |
| * @param {?} node | |
| * @param {!Object} fn | |
| * @return {undefined} | |
| */ | |
| var ws = function(node, fn) { | |
| var vals = lh(fn); | |
| vals = vals.sort(function(p, size) { | |
| return size.Wb - p.Wb; | |
| }); | |
| /** @type {number} */ | |
| var next_tick_ts = 0; | |
| /** @type {boolean} */ | |
| node.ra = false; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < vals.length; i++) { | |
| var a = vals[i]; | |
| if (-1 < a.Wb) { | |
| /** @type {boolean} */ | |
| node.ra = true; | |
| } | |
| /** @type {number} */ | |
| a.b = .05 <= a.Wb ? 3 : .0025 <= a.Wb ? 2 : 1; | |
| /** @type {boolean} */ | |
| a.a = 12 > i || 3 == a.b; | |
| /** @type {number} */ | |
| next_tick_ts = next_tick_ts + (a.a ? 0 : 1); | |
| } | |
| if (4 >= next_tick_ts) { | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < vals.length; i++) { | |
| /** @type {boolean} */ | |
| vals[i].a = true; | |
| } | |
| } | |
| if (fn.b) { | |
| mh(fn); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @param {!NodeList} chartIds | |
| * @return {?} | |
| */ | |
| var zs = function(data, chartIds) { | |
| /** @type {!Array} */ | |
| var uvalues = []; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < chartIds.length; i++) { | |
| var v = G("SPAN", null, chartIds[i]); | |
| if (null != data.C) { | |
| T(v, data.C); | |
| data.c.push(v); | |
| } | |
| uvalues.push(v); | |
| if (i < chartIds.length - 1) { | |
| uvalues.push(Af(", ")); | |
| } | |
| } | |
| return uvalues; | |
| }; | |
| /** | |
| * @param {?} s | |
| * @param {!Object} b | |
| * @param {!Array} x | |
| * @return {?} | |
| */ | |
| var xs = function(s, b, x) { | |
| var l = b.c; | |
| if (l) { | |
| s.Bf = l; | |
| ps(s, l); | |
| } | |
| b = Bp(Pn, { | |
| Il : x, | |
| Zl : s.hc, | |
| $l : s.ic, | |
| Co : b.g, | |
| Xd : oh(b) | |
| }); | |
| if (x) { | |
| x = F("tlid-frequency-help-icon", b); | |
| var f = F("tlid-frequency-help-icon-container", b); | |
| var res = F("tlid-frequency-help-tooltip", b); | |
| Y(s).M(x, "click", function() { | |
| V(f, "show-tooltip", !tp(f, "show-tooltip")); | |
| }); | |
| Y(s).M(document, "click", function(value) { | |
| var body = gb(value.target); | |
| if (tp(f, "show-tooltip")) { | |
| value = body.classList.contains("tlid-frequency-help-icon"); | |
| body = Pf(res, body); | |
| if (!(value || body)) { | |
| U(f, "show-tooltip"); | |
| } | |
| } | |
| }); | |
| } | |
| s = G("TD", { | |
| colspan : 4 | |
| }, b); | |
| return G("TR", null, s); | |
| }; | |
| /** | |
| * @param {!Object} descriptor | |
| * @param {!Array} languageCode | |
| * @return {?} | |
| */ | |
| var As = function(descriptor, languageCode) { | |
| return kc(languageCode) !== kc(descriptor.Xa) ? kc(languageCode) ? "rtl" : "ltr" : ""; | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @param {!Object} c | |
| * @param {!Object} a | |
| * @param {string} val | |
| * @return {?} | |
| */ | |
| var ys = function(o, c, a, val) { | |
| if (o.g) { | |
| var y = c.text; | |
| var value = null != c.nf ? c.nf : ""; | |
| /** @type {boolean} */ | |
| var i = y === a; | |
| a = c.a; | |
| /** @type {string} */ | |
| val = o.T ? "gt-baf-entry-clickable" : "gt-baf-entry"; | |
| if (i) { | |
| /** @type {string} */ | |
| val = val + " gt-baf-entry-selected"; | |
| } | |
| val = G("TR", { | |
| "class" : val | |
| }); | |
| var b = G("TD"); | |
| y = Bp(Qn, { | |
| Eh : i, | |
| nf : value, | |
| lp : As(o, o.Pa), | |
| Xd : a, | |
| Rp : y, | |
| Sp : o.Aa | |
| }); | |
| Df(b, y); | |
| y = G("TD"); | |
| value = Bp(Rn, { | |
| Ef : null != o.C ? o.C : "", | |
| Fl : As(o, o.Ca), | |
| Bg : c.Bg, | |
| Xd : a | |
| }); | |
| Df(y, value); | |
| Df(val, b); | |
| Df(val, y); | |
| b = c.b; | |
| c = o.K[c.b]; | |
| if (o.g && o.ea && b && c) { | |
| c = Bp(Tn, { | |
| Wb : b, | |
| Jc : c, | |
| Xd : a | |
| }); | |
| a = G("TD"); | |
| Df(a, c); | |
| Df(val, a); | |
| } | |
| if (o.C) { | |
| c = nf(o.C, val); | |
| A(c, function(wrap) { | |
| this.c.push(wrap); | |
| }, o); | |
| } | |
| c = o.T ? F("gt-baf-word", val) : F("gt-baf-word-clickable", val); | |
| o.c.push(c); | |
| return val; | |
| } | |
| value = c.text; | |
| i = c.nf; | |
| y = c.a; | |
| a = Bs(o, c.b, y); | |
| /** @type {null} */ | |
| b = null; | |
| if (i) { | |
| b = Cs(i, y); | |
| } | |
| value = Ds(o, value, i, y); | |
| c = zs(o, c.Bg); | |
| c = Es(o, c, y); | |
| c = G("TR", null, a, b, value, c); | |
| if (kc(o.Ca) != kc(o.Xa) && 1 == val % 2) { | |
| T(c, "gt-baf-translations-alt"); | |
| } | |
| return c; | |
| }; | |
| /** | |
| * @param {!Object} result | |
| * @param {!Object} i | |
| * @param {!Object} replacement | |
| * @return {?} | |
| */ | |
| var Bs = function(result, i, replacement) { | |
| if (!result.ra || !result.ea) { | |
| return result = G("DIV", { | |
| "class" : "gt-baf-cell" | |
| }), replacement = rs(result, replacement), G("TD", null, replacement); | |
| } | |
| result = G("DIV", { | |
| "class" : "gt-baf-cell gt-baf-marker-container", | |
| title : result.K[i] | |
| }); | |
| i = us("width: %dpx", 8 * i); | |
| i = G("DIV", { | |
| "class" : "gt-baf-cts", | |
| style : i | |
| }); | |
| Df(result, i); | |
| replacement = rs(result, replacement); | |
| return G("TD", null, replacement); | |
| }; | |
| /** | |
| * @param {string} i | |
| * @param {!Function} a | |
| * @return {?} | |
| */ | |
| var Cs = function(i, a) { | |
| var b = G("DIV", { | |
| "class" : "gt-baf-cell gt-baf-previous-word" | |
| }); | |
| H(b, i); | |
| i = rs(b, a); | |
| return G("TD", null, i); | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @param {string} context | |
| * @param {boolean} character | |
| * @param {!Function} replacement | |
| * @return {?} | |
| */ | |
| var Ds = function(value, context, character, replacement) { | |
| /** @type {string} */ | |
| var arStl = ""; | |
| if (kc(value.Pa) !== kc(value.Xa)) { | |
| arStl = us("direction: %s", kc(value.Pa) ? "rtl" : "ltr"); | |
| } | |
| context = G("SPAN", value.Aa, context); | |
| value.c.push(context); | |
| value = G("DIV", "gt-baf-cell", context); | |
| value = rs(value, replacement); | |
| if (!replacement) { | |
| T(value, "gt-card-widen-wrapper"); | |
| } | |
| return G("TD", character ? null : { | |
| colspan : 2, | |
| style : arStl | |
| }, value); | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @param {!Object} e | |
| * @param {!Object} d | |
| * @return {?} | |
| */ | |
| var Es = function(item, e, d) { | |
| item = kc(item.Ca) !== kc(item.Xa) ? us("direction: %s", kc(item.Ca) ? "rtl" : "ltr") : ""; | |
| e = G("DIV", { | |
| "class" : "gt-baf-cell gt-baf-translations", | |
| style : item | |
| }, e); | |
| d = rs(e, d); | |
| return G("TD", { | |
| style : "width: 100%" | |
| }, d); | |
| }; | |
| /** | |
| * @param {boolean} value | |
| * @return {undefined} | |
| */ | |
| vs.prototype.Ce = function(value) { | |
| vs.D.Ce.call(this, value); | |
| var stars = nf("gt-card-widen-wrapper", this.j()); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < stars.length; i++) { | |
| var obj = stars[i]; | |
| var container = E("gt-baf-cell", obj); | |
| var offset = mq(container, "margin"); | |
| container = container.scrollWidth + offset.left + offset.right + 1; | |
| Hp(obj, "max-width", value ? container + "px" : 0); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| vs.prototype.Hb = function(type) { | |
| var i = dg(type.target); | |
| if (null != i) { | |
| type = E("gt-baf-word", i); | |
| if (null != type) { | |
| this.dispatchEvent(new kg("b", type)); | |
| } | |
| } else { | |
| if (tp(type.target, "gt-baf-word-clickable")) { | |
| this.dispatchEvent(new kg("b", type.target)); | |
| } else { | |
| if (tp(type.target, "gt-baf-back")) { | |
| this.dispatchEvent(new kg("a", type.target)); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| vs.prototype.jb = function(type) { | |
| if (tp(type.target, "gt-baf-back")) { | |
| var result = mf(document, null, "gt-baf-back", this.j()); | |
| type = ag(type.target); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < result.length; i++) { | |
| if (ag(result[i]) == type) { | |
| T(result[i], "gt-baf-hl"); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| vs.prototype.gb = function() { | |
| var result = mf(document, null, "gt-baf-hl", this.j()); | |
| /** @type {number} */ | |
| var k = 0; | |
| for (; k < result.length; k++) { | |
| U(result[k], "gt-baf-hl"); | |
| } | |
| }; | |
| /** | |
| * @param {string} tree | |
| * @return {undefined} | |
| */ | |
| var Gs = function(tree) { | |
| this.a = null != tree ? new Am(Fs(tree)) : new Am; | |
| /** @type {string} */ | |
| this.b = "home"; | |
| if (Qm(this.a, "view")) { | |
| this.b = this.a.get("view"); | |
| Pm(this.a, "view"); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} f | |
| * @param {string} text | |
| * @return {?} | |
| */ | |
| var Hs = function(f, text) { | |
| /** @type {string} */ | |
| f.b = text; | |
| return f; | |
| }; | |
| /** | |
| * @param {!Object} out | |
| * @param {!Object} name | |
| * @param {!Object} host | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| var Js = function(out, name, host, a) { | |
| Is(out); | |
| out.a.set("op", "translate").set("sl", name).set("tl", host); | |
| if (null != a && !xc(a)) { | |
| out.a.set("text", a); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} element | |
| * @param {!Object} type | |
| * @param {!Object} test | |
| * @param {!Object} update | |
| * @return {undefined} | |
| */ | |
| var Ks = function(element, type, test, update) { | |
| Is(element); | |
| element.a.set("op", "star").set("sl", type).set("tl", test).set("text", update); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| var Is = function(a) { | |
| Pm(a.a, "op"); | |
| Pm(a.a, "sl"); | |
| Pm(a.a, "tl"); | |
| Pm(a.a, "text"); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Gs.prototype.Ua = function() { | |
| return Ls(this, "sl"); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Gs.prototype.qa = function() { | |
| return Ls(this, "tl"); | |
| }; | |
| /** | |
| * @param {string} args | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| var Ls = function(args, value) { | |
| /** @type {string} */ | |
| var parts = ""; | |
| if (Qm(args.a, value)) { | |
| parts = args.a.get(value); | |
| parts = ee(parts); | |
| } | |
| return parts; | |
| }; | |
| /** | |
| * @param {(number|string)} a | |
| * @param {string} b | |
| * @return {?} | |
| */ | |
| var Ms = function(a, b) { | |
| return Qm(a.a, "op") && a.a.get("op") === b; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Gs.prototype.toString = function() { | |
| /** @type {string} */ | |
| var s_str = "view=" + this.b; | |
| var a1 = this.a; | |
| Nm(a1); | |
| if (!(0 == a1.b)) { | |
| /** @type {string} */ | |
| s_str = s_str + ("&" + this.a.toString()); | |
| } | |
| return s_str; | |
| }; | |
| /** | |
| * @param {string} root | |
| * @return {?} | |
| */ | |
| function Fs(root) { | |
| if (root.startsWith("view=")) { | |
| return root; | |
| } | |
| var b = new Gs; | |
| if (root.startsWith("op=")) { | |
| switch(root = new Am(root), root.get("op")) { | |
| case "showhistory": | |
| return Hs(b, "history").toString(); | |
| case "showsaved": | |
| return Hs(b, "saved").toString(); | |
| case "star": | |
| if (Qm(root, "sl") && Qm(root, "tl") && Qm(root, "text") && Qm(root, "page")) { | |
| switch(root.get("page")) { | |
| case "history": | |
| Hs(b, "history"); | |
| break; | |
| default: | |
| Hs(b, "home"); | |
| } | |
| Ks(b, root.get("sl"), root.get("tl"), root.get("text")); | |
| } | |
| return b.toString(); | |
| default: | |
| return Hs(b, "home").toString(); | |
| } | |
| } else { | |
| root = root.split(/[|\/]/); | |
| Hs(b, "home"); | |
| /** @type {string} */ | |
| var record = ""; | |
| /** @type {string} */ | |
| var value = ""; | |
| /** @type {string} */ | |
| var val = ""; | |
| if (0 < root.length && 0 < root[0].length) { | |
| record = root[0]; | |
| } | |
| if (1 < root.length && 0 < root[1].length) { | |
| value = root[1]; | |
| } | |
| if (2 < root.length && 0 < root[2].length) { | |
| val = root[2]; | |
| } | |
| if (0 < record.length && 0 < value.length) { | |
| if (0 < val.length) { | |
| Js(b, record, value, val); | |
| } else { | |
| Js(b, record, value); | |
| } | |
| if (3 < root.length && "share" === root[3]) { | |
| b.a.set("op", "share"); | |
| } | |
| } | |
| return b.toString(); | |
| } | |
| } | |
| /** | |
| * @param {?} name | |
| * @param {?} module | |
| * @return {undefined} | |
| */ | |
| var Ns = function(name, module) { | |
| kg.call(this, "navigate"); | |
| this.Vh = name; | |
| this.zn = module; | |
| }; | |
| x(Ns, kg); | |
| /** | |
| * @return {?} | |
| */ | |
| var Ps = function() { | |
| return !Os() && (B("iPod") || B("iPhone") || B("Android") || B("IEMobile")); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var Os = function() { | |
| return B("iPad") || B("Android") && !B("Mobile") || B("Silk"); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var Qs = function() { | |
| return !Ps() && !Os(); | |
| }; | |
| /** | |
| * @param {!Array} r | |
| * @param {!Array} params | |
| * @return {?} | |
| */ | |
| var Rs = function(r, params) { | |
| /** @type {!Array} */ | |
| r = [r]; | |
| /** @type {number} */ | |
| var i = params.length - 1; | |
| for (; 0 <= i; --i) { | |
| r.push(typeof params[i], params[i]); | |
| } | |
| return r.join("\x0B"); | |
| }; | |
| /** | |
| * @param {string} id | |
| * @param {!Object} options | |
| * @param {!Object} node | |
| * @param {!Object} value | |
| * @return {undefined} | |
| */ | |
| var $s = function(id, options, node, value) { | |
| L.call(this); | |
| if (id && !options) { | |
| throw Error("Can't use invisible history without providing a blank page."); | |
| } | |
| if (node) { | |
| /** @type {!Object} */ | |
| var x = node; | |
| } else { | |
| x = "history_state" + Ss; | |
| var key = Ld("input", { | |
| type : "text", | |
| name : x, | |
| id : x, | |
| style : ec("display:none") | |
| }); | |
| document.write(Dd(key)); | |
| x = kf(x); | |
| } | |
| this.w = x; | |
| this.a = node ? vf(hf(node)) : window; | |
| /** @type {!Object} */ | |
| this.G = options; | |
| if (C.V && !options) { | |
| this.G = "https" == window.location.protocol ? tc(dc(ec("https:///"))) : tc(dc(ec('javascript:""'))); | |
| } | |
| this.b = new ai(150); | |
| jg(this, this.b); | |
| /** @type {boolean} */ | |
| this.g = !id; | |
| this.c = new rq(this); | |
| if (id || Ws) { | |
| if (value) { | |
| /** @type {!Object} */ | |
| var i = value; | |
| } else { | |
| id = "history_iframe" + Ss; | |
| value = this.G; | |
| options = { | |
| id : id, | |
| style : ec("display:none"), | |
| sandbox : void 0 | |
| }; | |
| if (value) { | |
| rc(value); | |
| } | |
| node = {}; | |
| node.src = value || null; | |
| /** @type {null} */ | |
| node.srcdoc = null; | |
| value = { | |
| sandbox : "" | |
| }; | |
| x = {}; | |
| for (i in node) { | |
| z(i.toLowerCase() == i, "Must be lower case"); | |
| x[i] = node[i]; | |
| } | |
| for (i in value) { | |
| z(i.toLowerCase() == i, "Must be lower case"); | |
| x[i] = value[i]; | |
| } | |
| for (i in options) { | |
| /** @type {string} */ | |
| key = i.toLowerCase(); | |
| if (key in node) { | |
| throw Error('Cannot override "' + key + '" attribute, got "' + i + '" with value "' + options[i] + '"'); | |
| } | |
| if (key in value) { | |
| delete x[key]; | |
| } | |
| x[i] = options[i]; | |
| } | |
| i = Kd("iframe", x, void 0); | |
| document.write(Dd(i)); | |
| i = kf(id); | |
| } | |
| this.C = i; | |
| /** @type {boolean} */ | |
| this.O = true; | |
| } | |
| if (Ws) { | |
| this.c.M(this.a, "load", this.oo); | |
| /** @type {boolean} */ | |
| this.R = this.L = false; | |
| } | |
| if (this.g) { | |
| Xs(this, Ys(this), true); | |
| } else { | |
| Zs(this, this.w.value); | |
| } | |
| Ss++; | |
| }; | |
| x($s, L); | |
| /** @type {boolean} */ | |
| $s.prototype.m = false; | |
| /** @type {boolean} */ | |
| $s.prototype.o = false; | |
| /** @type {null} */ | |
| $s.prototype.h = null; | |
| var at = function(route, decimal_sep) { | |
| var d = decimal_sep || Rs; | |
| return function() { | |
| var mem = this || l; | |
| mem = mem.closure_memoize_cache_ || (mem.closure_memoize_cache_ = {}); | |
| var key = d(Qa(route), arguments); | |
| return mem.hasOwnProperty(key) ? mem[key] : mem[key] = route.apply(this, arguments); | |
| }; | |
| }(function() { | |
| return C.V ? C.kb(8) : "onhashchange" in l; | |
| }); | |
| var Ws = C.V && !C.kb(8); | |
| k = $s.prototype; | |
| /** @type {null} */ | |
| k.we = null; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.X = function() { | |
| $s.D.X.call(this); | |
| this.c.Qa(); | |
| this.sa(false); | |
| }; | |
| /** | |
| * @param {string} v | |
| * @return {undefined} | |
| */ | |
| k.sa = function(v) { | |
| if (v != this.m) { | |
| if (Ws && !this.L) { | |
| /** @type {string} */ | |
| this.R = v; | |
| } else { | |
| if (v) { | |
| if (C.cb ? this.c.M(this.a.document, bt, this.T) : C.Ja && this.c.M(this.a, "pageshow", this.xo), at() && this.g) { | |
| this.c.M(this.a, "hashchange", this.qo); | |
| /** @type {boolean} */ | |
| this.m = true; | |
| this.dispatchEvent(new Ns(Ys(this), false)); | |
| } else { | |
| if (!C.V || Ps() || this.L) { | |
| this.c.M(this.b, "tick", v(this.K, this, true)); | |
| /** @type {boolean} */ | |
| this.m = true; | |
| if (!Ws) { | |
| this.h = Ys(this); | |
| this.dispatchEvent(new Ns(Ys(this), false)); | |
| } | |
| this.b.start(); | |
| } | |
| } | |
| } else { | |
| /** @type {boolean} */ | |
| this.m = false; | |
| wq(this.c); | |
| this.b.stop(); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.oo = function() { | |
| /** @type {boolean} */ | |
| this.L = true; | |
| if (this.w.value) { | |
| Zs(this, this.w.value, true); | |
| } | |
| this.sa(this.R); | |
| }; | |
| /** | |
| * @param {!Object} settings | |
| * @return {undefined} | |
| */ | |
| k.xo = function(settings) { | |
| if (settings.b.persisted) { | |
| this.sa(false); | |
| this.sa(true); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.qo = function() { | |
| var a = ct(this.a); | |
| if (a != this.h) { | |
| dt(this, a, true); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} f | |
| * @return {?} | |
| */ | |
| var Ys = function(f) { | |
| return null != f.we ? f.we : f.g ? ct(f.a) : et(f) || ""; | |
| }; | |
| /** | |
| * @param {string} id | |
| * @return {?} | |
| */ | |
| var ct = function(id) { | |
| id = id.location.href; | |
| var idx = id.indexOf("#"); | |
| return 0 > idx ? "" : id.substring(idx + 1); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} def | |
| * @param {string} c | |
| * @return {undefined} | |
| */ | |
| var ft = function(a, def, c) { | |
| if (Ys(a) != def) { | |
| if (a.g) { | |
| Xs(a, def, c); | |
| if (!at()) { | |
| if (C.V && !Ps()) { | |
| Zs(a, def, c, void 0); | |
| } | |
| } | |
| if (a.m) { | |
| a.K(false); | |
| } | |
| } else { | |
| Zs(a, def, c); | |
| a.we = a.h = a.w.value = def; | |
| a.dispatchEvent(new Ns(def, false)); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} b | |
| * @param {string} n | |
| * @return {undefined} | |
| */ | |
| var Xs = function(a, b, n) { | |
| a = a.a.location; | |
| var uri = a.href.split("#")[0]; | |
| var r = Kc(a.href, "#"); | |
| if (Ws || r || b) { | |
| /** @type {string} */ | |
| uri = uri + ("#" + b); | |
| } | |
| if (uri != a.href) { | |
| b = uri; | |
| uri = ec("URL taken from location.href."); | |
| bb(dc(uri), "must provide justification"); | |
| z(!xc(dc(uri)), "must provide non-empty justification"); | |
| b = Wc(b); | |
| if (n) { | |
| $d(a, b); | |
| } else { | |
| Zd(a, b); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} args | |
| * @param {string} data | |
| * @param {string} id | |
| * @param {string} newTitle | |
| * @return {undefined} | |
| */ | |
| var Zs = function(args, data, id, newTitle) { | |
| if (args.O || data != et(args)) { | |
| if (args.O = false, data = de(data), C.V) { | |
| var doc = Uf(args.C); | |
| doc.open("text/html", id ? "replace" : void 0); | |
| id = Od(Ld("title", {}, newTitle || args.a.document.title), Ld("body", {}, data)); | |
| doc.write(Dd(id)); | |
| doc.close(); | |
| } else { | |
| ib(args.G, pc, "this.iframeSrc_ must be set on calls to setIframeToken_"); | |
| /** @type {string} */ | |
| doc = rc(args.G) + "#" + data; | |
| if (args = args.C.contentWindow) { | |
| if (id) { | |
| $d(args.location, doc); | |
| } else { | |
| Zd(args.location, doc); | |
| } | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} args | |
| * @return {?} | |
| */ | |
| var et = function(args) { | |
| if (C.V) { | |
| return args = Uf(args.C), args.body ? ee(args.body.innerHTML) : null; | |
| } | |
| var value = args.C.contentWindow; | |
| if (value) { | |
| try { | |
| var c = ee(ct(value)); | |
| } catch (d) { | |
| return args.o || (1 != args.o && bi(args.b, 1E4), args.o = true), null; | |
| } | |
| if (args.o) { | |
| if (0 != args.o) { | |
| bi(args.b, 150); | |
| } | |
| /** @type {boolean} */ | |
| args.o = false; | |
| } | |
| return c || null; | |
| } | |
| return null; | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| $s.prototype.K = function(type) { | |
| if (this.g) { | |
| var title = ct(this.a); | |
| if (title != this.h) { | |
| dt(this, title, type); | |
| } | |
| } | |
| if (!this.g || Ws) { | |
| if (title = et(this) || "", null == this.we || title == this.we) { | |
| /** @type {null} */ | |
| this.we = null; | |
| if (title != this.h) { | |
| dt(this, title, type); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} link | |
| * @param {boolean} size | |
| * @return {undefined} | |
| */ | |
| var dt = function(a, link, size) { | |
| a.h = a.w.value = link; | |
| if (a.g) { | |
| if (Ws) { | |
| Zs(a, link); | |
| } | |
| Xs(a, link); | |
| } else { | |
| Zs(a, link); | |
| } | |
| a.dispatchEvent(new Ns(Ys(a), size)); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| $s.prototype.T = function() { | |
| this.b.stop(); | |
| this.b.start(); | |
| }; | |
| /** @type {!Array} */ | |
| var bt = ["mousedown", "keydown", "mousemove"]; | |
| /** @type {number} */ | |
| var Ss = 0; | |
| /** | |
| * @param {string} col | |
| * @param {!Object} a | |
| * @param {number} b | |
| * @return {undefined} | |
| */ | |
| var gt = function(col, a, b) { | |
| var sharedEventDispatcher = this; | |
| L.call(this); | |
| this.b = new $s(false, void 0, a, b); | |
| /** @type {null} */ | |
| this.c = null; | |
| /** @type {number} */ | |
| this.h = 0; | |
| this.g = col || false; | |
| I(this.b, "navigate", function(cmd) { | |
| if (cmd.zn) { | |
| sharedEventDispatcher.dispatchEvent({ | |
| type : "c", | |
| Vh : cmd.Vh | |
| }); | |
| } | |
| }, false); | |
| }; | |
| x(gt, L); | |
| /** | |
| * @param {!Object} f | |
| * @param {string} options | |
| * @param {string} name | |
| * @param {string} label | |
| * @return {undefined} | |
| */ | |
| var it = function(f, options, name, label) { | |
| /** @type {string} */ | |
| var b = ""; | |
| /** @type {string} */ | |
| var val = ""; | |
| /** @type {string} */ | |
| var value = ""; | |
| if (f.g) { | |
| options = new Gs(options); | |
| b = options.Ua(); | |
| val = options.qa(); | |
| value = Ls(options, "text"); | |
| } else { | |
| /** @type {!Array} */ | |
| var o = []; | |
| A(options.split(/[|\/]/), function(key) { | |
| o.push(ee(key)); | |
| }); | |
| b = me(o[0]); | |
| val = me(o[1]); | |
| if (2 < o.length) { | |
| value = o[2]; | |
| } | |
| } | |
| if (!xc(b) && !xc(val) && 0 <= name.indexOf(b) && ("auto" === val || 0 <= label.indexOf(val))) { | |
| ht(f.c, b, val, value, "bh"); | |
| } else { | |
| ht(f.c, "", "", "", "bh"); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} v | |
| * @param {string} l | |
| * @param {string} c | |
| * @param {string} strings | |
| * @return {undefined} | |
| */ | |
| var jt = function(v, l, c, strings) { | |
| var params = new Gs(l); | |
| l = params.Ua(); | |
| params = params.qa(); | |
| if (!xc(l) && !xc(params) && 0 <= c.indexOf(l) && ("auto" === params || 0 <= strings.indexOf(params))) { | |
| ht(v.c, l, params, "", "bh"); | |
| } else { | |
| ht(v.c, "", "", "", "bh"); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @param {string} s | |
| * @param {string} name | |
| * @param {string} val | |
| * @param {string} i | |
| * @return {?} | |
| */ | |
| var lt = function(b, s, name, val, i) { | |
| s = null != s ? s : "auto"; | |
| name = null != name ? name : "en"; | |
| if (b.g) { | |
| b = kt(b); | |
| Js(b, s, name, val); | |
| if (null != i && "share" === i) { | |
| b.a.set("op", "share"); | |
| } | |
| s = b.toString(); | |
| } else { | |
| /** @type {string} */ | |
| s = s + "/" + name + "/" + de(val); | |
| if (i) { | |
| /** @type {string} */ | |
| s = s + ("/" + i); | |
| } | |
| } | |
| return s; | |
| }; | |
| /** | |
| * @param {!Object} arg | |
| * @return {?} | |
| */ | |
| var kt = function(arg) { | |
| if (!arg.g) { | |
| throw Error("Should never be invoked without new URL fragment schema"); | |
| } | |
| return new Gs(Ys(arg.b)); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} b | |
| * @param {string} callback | |
| * @param {string} key | |
| * @param {string} msg | |
| * @param {string} context | |
| * @return {undefined} | |
| */ | |
| var mt = function(a, b, callback, key, msg, context) { | |
| a.a(lt(a, b, callback, key, context), !msg || null != context); | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| gt.prototype.a = function(name, value) { | |
| /** @type {number} */ | |
| var dy = (new Date).getTime(); | |
| if (2E3 < dy - this.h) { | |
| ft(this.b, name, false); | |
| } else { | |
| ft(this.b, name, true); | |
| } | |
| /** @type {number} */ | |
| this.h = value ? 0 : dy; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var nt = function() { | |
| }; | |
| x(nt, er); | |
| Ia(nt); | |
| k = nt.prototype; | |
| /** | |
| * @param {!Object} v | |
| * @return {?} | |
| */ | |
| k.Eb = function(v) { | |
| var e = Xq(this, v); | |
| e = v.a.b("DIV", "goog-inline-block " + e.join(" "), this.Ff(v.Ya(), v.a)); | |
| fr(e, v.h); | |
| return e; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.nd = function() { | |
| return "button"; | |
| }; | |
| /** | |
| * @param {!Object} element | |
| * @return {?} | |
| */ | |
| k.fc = function(element) { | |
| return element && element.firstChild && element.firstChild.firstChild; | |
| }; | |
| /** | |
| * @param {string} i | |
| * @param {!Object} t | |
| * @return {?} | |
| */ | |
| k.Ff = function(i, t) { | |
| return t.b("DIV", "goog-inline-block " + (this.za() + "-outer-box"), t.b("DIV", "goog-inline-block " + (this.za() + "-inner-box"), i)); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| k.md = function(a) { | |
| return "DIV" == a.tagName; | |
| }; | |
| /** | |
| * @param {!Object} buf | |
| * @param {!Object} e | |
| * @return {?} | |
| */ | |
| k.eb = function(buf, e) { | |
| z(e); | |
| ot(e, true); | |
| ot(e, false); | |
| a: { | |
| var pt = buf.a.Yi(e); | |
| var i = this.za() + "-outer-box"; | |
| if (pt && tp(pt, i) && (pt = buf.a.Yi(pt), i = this.za() + "-inner-box", pt && tp(pt, i))) { | |
| /** @type {boolean} */ | |
| pt = true; | |
| break a; | |
| } | |
| /** @type {boolean} */ | |
| pt = false; | |
| } | |
| if (!pt) { | |
| e.appendChild(this.Ff(e.childNodes, buf.a)); | |
| } | |
| up(e, ["goog-inline-block", this.za()]); | |
| return nt.D.eb.call(this, buf, e); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.za = function() { | |
| return "goog-custom-button"; | |
| }; | |
| /** | |
| * @param {!HTMLElement} element | |
| * @param {boolean} fromStart | |
| * @return {undefined} | |
| */ | |
| var ot = 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 ("" == zc(path)) { | |
| element.removeChild(node); | |
| } else { | |
| node.nodeValue = fromStart ? path.replace(/^[\s\xa0]+/, "") : path.replace(/[\s\xa0]+$/, ""); | |
| break; | |
| } | |
| } else { | |
| break; | |
| } | |
| node = next; | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {?} elem | |
| * @param {?} value | |
| * @param {?} normal | |
| * @return {undefined} | |
| */ | |
| var pt = function(elem, value, normal) { | |
| Br.call(this, elem, value || nt.N(), normal); | |
| this.Sa(16, true); | |
| }; | |
| x(pt, Br); | |
| jr("goog-toggle-button", function() { | |
| return new pt(null); | |
| }); | |
| /** | |
| * @param {?} name | |
| * @param {string} item | |
| * @param {?} onload | |
| * @param {?} onerror | |
| * @return {undefined} | |
| */ | |
| var qt = function(name, item, onload, onerror) { | |
| pt.call(this, name, onload || er.N(), onerror); | |
| this.O = name; | |
| this.m = item || null; | |
| /** @type {null} */ | |
| this.b = null; | |
| }; | |
| x(qt, pt); | |
| /** | |
| * @param {boolean} data | |
| * @return {undefined} | |
| */ | |
| qt.prototype.wd = function(data) { | |
| qt.D.wd.call(this, data); | |
| rt(this); | |
| }; | |
| /** | |
| * @param {boolean} v | |
| * @return {undefined} | |
| */ | |
| qt.prototype.sa = function(v) { | |
| qt.D.sa.call(this, v); | |
| rt(this); | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @return {undefined} | |
| */ | |
| var rt = function(item) { | |
| if (item.isEnabled()) { | |
| if (null != item.m) { | |
| item.g(item.Ha(16) ? item.m : item.O); | |
| } | |
| } else { | |
| if (item.b) { | |
| item.g(item.b); | |
| /** @type {null} */ | |
| item.b = null; | |
| } else { | |
| item.g(""); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var tt = function() { | |
| is.call(this); | |
| /** @type {boolean} */ | |
| this.b = false; | |
| st(this); | |
| }; | |
| x(tt, is); | |
| /** | |
| * @param {number} object | |
| * @return {undefined} | |
| */ | |
| var st = function(object) { | |
| if (object.b) { | |
| pr(object, "unstarred"); | |
| or(object, "starred"); | |
| } else { | |
| pr(object, "starred"); | |
| or(object, "unstarred"); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var ut = function() { | |
| }; | |
| x(ut, er); | |
| Ia(ut); | |
| /** | |
| * @param {!Object} v | |
| * @return {?} | |
| */ | |
| ut.prototype.Eb = function(v) { | |
| var b = v.a.b("DIV", Xq(this, v).join(" ")); | |
| var button = v.a.b("SPAN"); | |
| var tmp = v.a.b("SPAN"); | |
| T(b, "gt-icon-c"); | |
| /** @type {string} */ | |
| tmp.className = "gt-icon-text"; | |
| /** @type {string} */ | |
| button.className = "gt-icon"; | |
| b.appendChild(button); | |
| if (v.Ya()) { | |
| b.appendChild(tmp); | |
| this.qc(b, v.Ya()); | |
| } | |
| return b; | |
| }; | |
| /** | |
| * @param {!Node} node | |
| * @param {boolean} a | |
| * @return {undefined} | |
| */ | |
| ut.prototype.qc = function(node, a) { | |
| if (node && (node = q(node.lastElementChild) ? node.lastElementChild : Lf(node.lastChild, false))) { | |
| H(node, a); | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| ut.prototype.za = function() { | |
| return "trans-tool-button"; | |
| }; | |
| /** | |
| * @param {!Object} c | |
| * @param {!HTMLElement} v | |
| * @return {?} | |
| */ | |
| ut.prototype.eb = function(c, v) { | |
| var node = c.Ya(); | |
| v = ut.D.eb.call(this, c, v); | |
| c.pd = node; | |
| node = c.a.b("SPAN"); | |
| var button = c.a.b("SPAN"); | |
| T(v, "gt-icon-c"); | |
| /** @type {string} */ | |
| button.className = "gt-icon-text"; | |
| /** @type {string} */ | |
| node.className = "gt-icon"; | |
| Ff(v); | |
| v.appendChild(node); | |
| if (c.Ya()) { | |
| v.appendChild(button); | |
| this.qc(v, c.Ya()); | |
| } | |
| return v; | |
| }; | |
| /** | |
| * @param {number} compiler | |
| * @param {string} reflectorHost | |
| * @return {undefined} | |
| */ | |
| var vt = function(compiler, reflectorHost) { | |
| /** @type {number} */ | |
| this.c = compiler; | |
| this.h = reflectorHost || false; | |
| }; | |
| x(vt, er); | |
| /** | |
| * @param {!Object} v | |
| * @return {?} | |
| */ | |
| vt.prototype.Eb = function(v) { | |
| var b = v.a.b("DIV", Xq(this, v).join(" ") + " goog-inline-block"); | |
| var button = v.a.b("SPAN"); | |
| if (this.c) { | |
| T(b, this.c); | |
| } | |
| /** @type {string} */ | |
| button.className = "jfk-button-img"; | |
| b.appendChild(button); | |
| if (v.Ya()) { | |
| this.qc(b, v.Ya()); | |
| } | |
| return b; | |
| }; | |
| /** | |
| * @param {!Element} type | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| vt.prototype.qc = function(type, a) { | |
| if (type && !this.h) { | |
| Xr(type, a, void 0); | |
| as(type, 2); | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| vt.prototype.za = function() { | |
| return "goog-toolbar-button"; | |
| }; | |
| /** | |
| * @param {!Object} v | |
| * @param {!HTMLElement} a | |
| * @return {?} | |
| */ | |
| vt.prototype.eb = function(v, a) { | |
| var arrow = v.a.b("SPAN"); | |
| if (this.c) { | |
| T(a, this.c); | |
| } | |
| /** @type {string} */ | |
| arrow.className = "jfk-button-img"; | |
| Ff(a); | |
| a.appendChild(arrow); | |
| if (v.Ya()) { | |
| this.qc(a, v.Ya()); | |
| } | |
| return a = vt.D.eb.call(this, v, a); | |
| }; | |
| /** | |
| * @param {string} text | |
| * @param {?} obj | |
| * @param {?} prop | |
| * @param {!Object} bytes | |
| * @return {undefined} | |
| */ | |
| var wt = function(text, obj, prop, bytes) { | |
| /** @type {string} */ | |
| this.text = text; | |
| this.Ca = obj; | |
| this.Pa = prop; | |
| /** @type {!Object} */ | |
| this.data = bytes; | |
| }; | |
| /** | |
| * @param {string} q | |
| * @param {number} value | |
| * @param {number} key | |
| * @param {(Object|string)} observer | |
| * @return {undefined} | |
| */ | |
| var xt = function(q, value, key, observer) { | |
| /** @type {string} */ | |
| this.g = q; | |
| /** @type {number} */ | |
| this.c = value; | |
| /** @type {number} */ | |
| this.h = key; | |
| /** @type {(Object|string)} */ | |
| this.o = observer; | |
| /** @type {!Array} */ | |
| this.a = []; | |
| /** @type {number} */ | |
| this.b = -1; | |
| I(this.g, "action", this.Eo, false, this); | |
| I(this.c, "action", this.fo, false, this); | |
| I(this.h, "action", this.wp, false, this); | |
| }; | |
| k = xt.prototype; | |
| /** | |
| * @param {string} name | |
| * @param {string} type | |
| * @param {string} fn | |
| * @param {!Object} callback | |
| * @return {undefined} | |
| */ | |
| k.push = function(name, type, fn, callback) { | |
| this.a.splice(++this.b); | |
| this.a.push(new wt(name, type, fn, callback)); | |
| yt(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.reset = function() { | |
| /** @type {!Array} */ | |
| this.a = []; | |
| /** @type {number} */ | |
| this.b = -1; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.Eo = function() { | |
| if (0 < this.b) { | |
| --this.b; | |
| yt(this); | |
| } | |
| hm.N().log("lxprev"); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.fo = function() { | |
| if (this.b < this.a.length - 1) { | |
| ++this.b; | |
| yt(this); | |
| } | |
| hm.N().log("lxnext"); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.wp = function() { | |
| if (1 < this.a.length) { | |
| this.a.splice(1); | |
| /** @type {number} */ | |
| this.b = 0; | |
| yt(this); | |
| } | |
| hm.N().log("lxclear"); | |
| }; | |
| /** | |
| * @param {!Object} that | |
| * @return {undefined} | |
| */ | |
| var yt = function(that) { | |
| var options = that.a[that.b]; | |
| that.o.update(options.text, options.Ca, options.Pa, options.data); | |
| that.g.sa(1 < that.b); | |
| that.c.sa(that.b < that.a.length - 1); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var zt = function() { | |
| /** @type {number} */ | |
| this.b = 0; | |
| /** @type {!Array} */ | |
| this.a = []; | |
| }; | |
| Ia(zt); | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| zt.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 zt.N().a[i]; | |
| }; | |
| /** @type {!Object} */ | |
| obj.src = name; | |
| /** @type {null} */ | |
| obj = null; | |
| }; | |
| C.Ia = {}; | |
| /** @type {boolean} */ | |
| C.Ia.yk = false; | |
| /** @type {boolean} */ | |
| C.Ia.ad = false; | |
| /** @type {string} */ | |
| C.Ia.Id = ""; | |
| /** | |
| * @return {undefined} | |
| */ | |
| C.Ia.lf = function() { | |
| if (navigator.plugins && navigator.plugins.length) { | |
| /** @type {!Plugin} */ | |
| var mimeType = navigator.plugins["Shockwave Flash"]; | |
| if (mimeType && (C.Ia.ad = true, mimeType.description)) { | |
| C.Ia.Id = C.Ia.Pf(mimeType.description); | |
| return; | |
| } | |
| if (navigator.plugins["Shockwave Flash 2.0"]) { | |
| /** @type {boolean} */ | |
| C.Ia.ad = true; | |
| /** @type {string} */ | |
| C.Ia.Id = "2.0.0.11"; | |
| return; | |
| } | |
| } | |
| if (navigator.mimeTypes && navigator.mimeTypes.length && (mimeType = navigator.mimeTypes["application/x-shockwave-flash"], C.Ia.ad = !(!mimeType || !mimeType.enabledPlugin), C.Ia.ad)) { | |
| C.Ia.Id = C.Ia.Pf(mimeType.enabledPlugin.description); | |
| return; | |
| } | |
| if ("undefined" != typeof ActiveXObject) { | |
| try { | |
| var axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.7"); | |
| /** @type {boolean} */ | |
| C.Ia.ad = true; | |
| C.Ia.Id = C.Ia.Pf(axo.GetVariable("$version")); | |
| return; | |
| } catch (c) { | |
| } | |
| try { | |
| axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.6"); | |
| /** @type {boolean} */ | |
| C.Ia.ad = true; | |
| /** @type {string} */ | |
| C.Ia.Id = "6.0.21"; | |
| return; | |
| } catch (c) { | |
| } | |
| try { | |
| axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash"); | |
| /** @type {boolean} */ | |
| C.Ia.ad = true; | |
| C.Ia.Id = C.Ia.Pf(axo.GetVariable("$version")); | |
| } catch (c) { | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {?} | |
| */ | |
| C.Ia.Pf = function(a) { | |
| a = a.match(/[\d]+/g); | |
| if (!a) { | |
| return ""; | |
| } | |
| /** @type {number} */ | |
| a.length = 3; | |
| return a.join("."); | |
| }; | |
| if (!C.Ia.yk) { | |
| C.Ia.lf(); | |
| } | |
| /** @type {boolean} */ | |
| C.Ia.Kk = C.Ia.ad; | |
| /** @type {string} */ | |
| C.Ia.VERSION = C.Ia.Id; | |
| /** | |
| * @param {!Object} bits | |
| * @return {?} | |
| */ | |
| C.Ia.ub = function(bits) { | |
| return 0 <= Oc(C.Ia.VERSION, bits); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var At = function() { | |
| L.call(this); | |
| /** @type {string} */ | |
| this.url = ""; | |
| }; | |
| x(At, L); | |
| /** | |
| * @return {undefined} | |
| */ | |
| At.prototype.De = function() { | |
| this.dispatchEvent(new Bt(this.url)); | |
| }; | |
| /** | |
| * @param {string} url | |
| * @return {undefined} | |
| */ | |
| At.prototype.play = function(url) { | |
| /** @type {string} */ | |
| this.url = url; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| At.prototype.c = function() { | |
| this.dispatchEvent(new Ct(this.url)); | |
| }; | |
| /** | |
| * @param {string} url | |
| * @return {undefined} | |
| */ | |
| var Dt = function(url) { | |
| kg.call(this, "sound_play_start"); | |
| /** @type {string} */ | |
| this.url = url; | |
| }; | |
| x(Dt, kg); | |
| /** | |
| * @param {string} data | |
| * @return {undefined} | |
| */ | |
| var Et = function(data) { | |
| kg.call(this, "sound_finished"); | |
| /** @type {string} */ | |
| this.url = data; | |
| }; | |
| x(Et, kg); | |
| /** | |
| * @param {string} url | |
| * @return {undefined} | |
| */ | |
| var Bt = function(url) { | |
| kg.call(this, "sound_interrupted"); | |
| /** @type {string} */ | |
| this.url = url; | |
| }; | |
| x(Bt, kg); | |
| /** | |
| * @param {string} url | |
| * @return {undefined} | |
| */ | |
| var Ct = function(url) { | |
| kg.call(this, "sound_error"); | |
| /** @type {string} */ | |
| this.url = url; | |
| }; | |
| x(Ct, kg); | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Ft = function() { | |
| At.call(this); | |
| /** @type {function(new:Audio, string=): ?} */ | |
| this.o = Audio; | |
| /** @type {!Audio} */ | |
| this.a = new this.o; | |
| this.b = {}; | |
| }; | |
| x(Ft, At); | |
| /** | |
| * @return {?} | |
| */ | |
| Ft.prototype.Wh = function() { | |
| return !this.a.paused; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Ft.prototype.De = function() { | |
| Ft.D.De.call(this); | |
| this.a.pause(); | |
| }; | |
| /** | |
| * @param {!Object} i | |
| * @return {undefined} | |
| */ | |
| Ft.prototype.play = function(i) { | |
| Ft.D.play.call(this, i); | |
| Gt(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 = Ht(this, i); | |
| /** @type {boolean} */ | |
| this.a.autoplay = true; | |
| } | |
| }; | |
| /** | |
| * @param {string} data | |
| * @return {undefined} | |
| */ | |
| Ft.prototype.nk = function(data) { | |
| l.setTimeout(v(this.m, this, data), 1E3); | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @param {!Object} c | |
| * @return {?} | |
| */ | |
| var Ht = function(b, c) { | |
| var t = new b.o; | |
| t.setAttribute("src", c); | |
| I(t, "play", b.h, false, b); | |
| I(t, "ended", b.g, false, b); | |
| I(t, "error", b.c, false, b); | |
| t.load(); | |
| return t; | |
| }; | |
| /** | |
| * @param {!Object} rhs | |
| * @param {!Object} lhs | |
| * @return {undefined} | |
| */ | |
| var Gt = function(rhs, lhs) { | |
| Og(lhs, "play", rhs.h); | |
| Og(lhs, "ended", rhs.g); | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| Ft.prototype.m = function(name) { | |
| if (null != this.b[name]) { | |
| Gt(this, this.b[name]); | |
| /** @type {null} */ | |
| this.b[name] = null; | |
| } | |
| this.b[name] = Ht(this, name); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Ft.prototype.h = function() { | |
| Og(this.a, "play", this.h); | |
| this.dispatchEvent(new Dt(this.url)); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Ft.prototype.g = function() { | |
| Og(this.a, "ended", this.g); | |
| this.dispatchEvent(new Et(this.url)); | |
| }; | |
| /** | |
| * @param {number} a | |
| * @return {undefined} | |
| */ | |
| var It = function(a) { | |
| At.call(this); | |
| /** @type {number} */ | |
| this.a = a; | |
| /** @type {boolean} */ | |
| this.b = false; | |
| }; | |
| x(It, At); | |
| k = It.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Wh = function() { | |
| return this.b; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.De = function() { | |
| /** @type {boolean} */ | |
| this.b = false; | |
| if (null != this.a.o) { | |
| this.a.o(); | |
| } | |
| Jt(); | |
| It.D.De.call(this); | |
| }; | |
| /** | |
| * @param {?} a | |
| * @return {undefined} | |
| */ | |
| k.play = function(a) { | |
| It.D.play.call(this, a); | |
| l.setTimeout(v(this.Ho, this), 0); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.Ho = function() { | |
| /** @type {boolean} */ | |
| this.b = true; | |
| var c = v(this.xp, this); | |
| l.SoundStopCB_ = c; | |
| if (null != this.a.g) { | |
| this.a.g("SoundStopCB_"); | |
| } | |
| try { | |
| if (null != this.a.c) { | |
| this.a.c(this.gk()); | |
| } else { | |
| /** @type {boolean} */ | |
| this.b = false; | |
| Jt(); | |
| this.c(); | |
| return; | |
| } | |
| var c = v(this.gk, this); | |
| l._TTSSoundFile = c; | |
| } catch (c) { | |
| /** @type {boolean} */ | |
| this.b = false; | |
| Jt(); | |
| this.c(); | |
| return; | |
| } | |
| if (null != this.a.h) { | |
| this.a.h(); | |
| } else { | |
| /** @type {boolean} */ | |
| this.b = false; | |
| Jt(); | |
| this.c(); | |
| } | |
| }; | |
| /** | |
| * @param {string} data | |
| * @return {undefined} | |
| */ | |
| k.nk = function(data) { | |
| var value = zt.N(); | |
| l.setTimeout(v(value.c, value, data), 1E3); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.gk = function() { | |
| return this.url.substring(1); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.xp = function() { | |
| /** @type {boolean} */ | |
| this.b = false; | |
| Jt(); | |
| this.dispatchEvent(new Et(this.url)); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Jt = function() { | |
| /** @type {null} */ | |
| l.SoundStopCB_ = null; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Kt = function() { | |
| /** @type {string} */ | |
| this.a = ""; | |
| /** @type {null} */ | |
| this.b = null; | |
| /** @type {boolean} */ | |
| this.c = false; | |
| /** @type {null} */ | |
| this.F = null; | |
| }; | |
| Ia(Kt); | |
| /** | |
| * @return {?} | |
| */ | |
| Kt.prototype.get = function() { | |
| if (null != this.a && 0 != this.a.length) { | |
| var type = kf(this.a); | |
| if (!this.c && (Lt("audio/mpeg") ? (this.b = new Ft, type = "html5") : null != type && "OBJECT" == type.tagName && C.Ia.Kk ? (this.b = new It(type), type = "flash") : (this.b = null, type = "none"), this.c = true, !this.g && this.F)) { | |
| /** @type {boolean} */ | |
| this.g = true; | |
| /** @type {number} */ | |
| var mp3 = Lt("audio/mpeg") ? 1 : 0; | |
| /** @type {number} */ | |
| var ogg = Lt("audio/ogg") ? 1 : 0; | |
| /** @type {number} */ | |
| var wav = Lt("audio/wav") ? 1 : 0; | |
| a: { | |
| try { | |
| var f = G("AUDIO"); | |
| if (null != f && null != f.volume) { | |
| var vol = f.volume; | |
| break a; | |
| } | |
| } catch (g) { | |
| } | |
| /** @type {number} */ | |
| vol = -1; | |
| } | |
| this.F.log("ttsaudio", { | |
| mp3 : mp3, | |
| ogg : ogg, | |
| wav : wav, | |
| vol : vol, | |
| type : type | |
| }); | |
| } | |
| } | |
| return this.b; | |
| }; | |
| /** | |
| * @param {string} playType | |
| * @return {?} | |
| */ | |
| var Lt = function(playType) { | |
| try { | |
| var audio = G("AUDIO"); | |
| return null != audio && null != audio.canPlayType && null != audio.load && null != audio.play && null != audio.paused && null != audio.pause && "no" != audio.canPlayType(playType) && "" != audio.canPlayType(playType); | |
| } catch (c) { | |
| return false; | |
| } | |
| }; | |
| /** | |
| * @param {number} n | |
| * @param {?} k | |
| * @param {number} m | |
| * @return {undefined} | |
| */ | |
| var Mt = function(n, k, m) { | |
| L.call(this); | |
| this.K = k; | |
| this.m = m ? m : 0; | |
| this.F = M.N(); | |
| this.C = Kt.N(); | |
| /** @type {number} */ | |
| this.C.a = n; | |
| this.C.F = k; | |
| this.b = this.C.get(); | |
| /** @type {null} */ | |
| this.G = this.c = null; | |
| /** @type {number} */ | |
| this.a = this.o = 0; | |
| this.g = {}; | |
| /** @type {number} */ | |
| this.h = 0; | |
| /** @type {boolean} */ | |
| this.w = false; | |
| /** @type {null} */ | |
| this.R = null; | |
| }; | |
| x(Mt, L); | |
| /** | |
| * @param {number} value | |
| * @param {!Object} name | |
| * @param {boolean} g | |
| * @param {string} r | |
| * @param {!Object} min | |
| * @return {undefined} | |
| */ | |
| Mt.prototype.set = function(value, name, g, r, min) { | |
| /** @type {number} */ | |
| this.c = value; | |
| /** @type {!Object} */ | |
| this.o = name; | |
| /** @type {boolean} */ | |
| this.G = g; | |
| if (null != r) { | |
| /** @type {string} */ | |
| this.R = r; | |
| } | |
| if (null != min) { | |
| this.g = Vb(min); | |
| } | |
| this.g.total = value.length; | |
| this.g.ttslocation = this.m; | |
| Nt(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Mt.prototype.start = function() { | |
| if (this.b.Wh()) { | |
| this.b.De(); | |
| } | |
| I(this.b, "sound_play_start", this.W, false, this); | |
| I(this.b, "sound_finished", this.T, false, this); | |
| I(this.b, "sound_interrupted", this.L, false, this); | |
| I(this.b, "sound_error", this.O, false, this); | |
| /** @type {number} */ | |
| this.h = (new Date).getTime(); | |
| Ot(this, "ttsstart", this.g); | |
| var pornResult = this.F; | |
| var val = this.m; | |
| var stylesheetURL = this.o; | |
| var f = this.c.length; | |
| var valueProgess = this.R; | |
| if (null != valueProgess) { | |
| am(pornResult, 31, val, stylesheetURL, f, void 0, void 0, valueProgess); | |
| } else { | |
| am(pornResult, 31, val, stylesheetURL, f); | |
| } | |
| this.b.play(this.c[this.a]); | |
| Pt(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Mt.prototype.stop = function() { | |
| if (this.c && this.b.Wh()) { | |
| var g = Vb(this.g); | |
| g.idx = this.a; | |
| /** @type {number} */ | |
| g.time = (new Date).getTime() - this.h; | |
| Ot(this, "ttsstop", g); | |
| am(this.F, 32, this.m, this.o, this.c.length, this.G[this.a], this.a); | |
| Nt(this); | |
| this.b.De(); | |
| Qt(this); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} proto | |
| * @return {undefined} | |
| */ | |
| var Nt = function(proto) { | |
| /** @type {number} */ | |
| proto.a = 0; | |
| /** @type {boolean} */ | |
| proto.w = false; | |
| Og(proto.b, "sound_play_start", proto.W, false, proto); | |
| Og(proto.b, "sound_finished", proto.T, false, proto); | |
| Og(proto.b, "sound_interrupted", proto.L, false, proto); | |
| Og(proto.b, "sound_error", proto.O, false, proto); | |
| }; | |
| /** | |
| * @param {?} self | |
| * @param {string} end | |
| * @param {string} code | |
| * @return {undefined} | |
| */ | |
| var Ot = function(self, end, code) { | |
| if (self.K) { | |
| self.K.log(end, code); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Mt.prototype.W = function() { | |
| if (!this.w) { | |
| this.dispatchEvent(new Rt(this.c)); | |
| var g = Vb(this.g); | |
| g.idx = this.a; | |
| /** @type {number} */ | |
| g.time = (new Date).getTime() - this.h; | |
| Ot(this, "ttsplaystart", g); | |
| am(this.F, 33, this.m, this.o, this.c.length, this.G[this.a], this.a); | |
| /** @type {boolean} */ | |
| this.w = true; | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Mt.prototype.T = function() { | |
| this.a += 1; | |
| if (this.a < this.c.length) { | |
| this.b.play(this.c[this.a]); | |
| Pt(this); | |
| } else { | |
| Qt(this); | |
| Nt(this); | |
| var g = Vb(this.g); | |
| g.idx = this.a; | |
| /** @type {number} */ | |
| g.time = (new Date).getTime() - this.h; | |
| Ot(this, "ttsfinish", g); | |
| am(this.F, 34, this.m, this.o, this.c.length); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Mt.prototype.L = function() { | |
| var g = Vb(this.g); | |
| g.idx = this.a; | |
| /** @type {number} */ | |
| g.time = (new Date).getTime() - this.h; | |
| Ot(this, "ttsinterrupted", g); | |
| Qt(this); | |
| Nt(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Mt.prototype.O = function() { | |
| var g = Vb(this.g); | |
| g.idx = this.a; | |
| /** @type {number} */ | |
| g.time = (new Date).getTime() - this.h; | |
| Ot(this, "ttserror", g); | |
| Ol(this.F, 155); | |
| Qt(this); | |
| Nt(this); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| var Qt = function(a) { | |
| a.dispatchEvent(new St(a.c)); | |
| }; | |
| /** | |
| * @param {!Object} x | |
| * @return {undefined} | |
| */ | |
| var Pt = function(x) { | |
| var falseySection = x.c[x.a + 1]; | |
| if (null != falseySection) { | |
| x.b.nk(falseySection); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Rt = function() { | |
| kg.call(this, "play_start_playlist"); | |
| }; | |
| x(Rt, kg); | |
| /** | |
| * @return {undefined} | |
| */ | |
| var St = function() { | |
| kg.call(this, "stop_playlist"); | |
| }; | |
| x(St, kg); | |
| /** | |
| * @param {?} i_f | |
| * @return {undefined} | |
| */ | |
| var Tt = function(i_f) { | |
| this.F = i_f; | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @param {string} value | |
| * @param {string} key | |
| * @return {undefined} | |
| */ | |
| Tt.prototype.g = function(name, value, key) { | |
| Ut(name, value, key, v(this.b, this), v(this.c, this)); | |
| }; | |
| /** | |
| * @param {!Object} s | |
| * @param {string} a | |
| * @param {!Object} f | |
| * @param {number} k | |
| * @param {?} v | |
| * @return {undefined} | |
| */ | |
| var Ut = function(s, a, f, k, v) { | |
| /** @type {!Array} */ | |
| var s = []; | |
| k(s, a); | |
| /** @type {string} */ | |
| a = ""; | |
| /** @type {number} */ | |
| k = 0; | |
| for (; k < s.length; k++) { | |
| var arrObj0 = zc(a + s[k]); | |
| if (arrObj0.length <= f) { | |
| /** @type {string} */ | |
| a = a + s[k]; | |
| } else { | |
| if (!xc(a)) { | |
| s.push(zc(a)); | |
| /** @type {string} */ | |
| a = ""; | |
| } | |
| arrObj0 = zc(s[k]); | |
| if (arrObj0.length <= f) { | |
| a = s[k]; | |
| } else { | |
| v(s, arrObj0, f); | |
| } | |
| } | |
| } | |
| if (!xc(a)) { | |
| s.push(zc(a)); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @param {string} value | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| Tt.prototype.c = function(type, value, a) { | |
| /** @type {number} */ | |
| var key = 0; | |
| for (; key < value.length; key = key + a) { | |
| type.push(value.substr(key, a)); | |
| } | |
| }; | |
| /** @type {!RegExp} */ | |
| var Vt = / /g; | |
| /** @type {!RegExp} */ | |
| var Wt = /([?.,;:!][ ]+)|([\u3001\u3002\uff01\uff08\uff09\uff0c\uff0e\uff1a\uff1b\uff1f][ ]?)/g; | |
| /** | |
| * @param {!Object} name | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| Tt.prototype.b = function(name, value) { | |
| Xt(name, value, Vt); | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| Tt.prototype.a = function(name, value) { | |
| Xt(name, value, Wt); | |
| /** @type {number} */ | |
| value = 0; | |
| for (; value < name.length; value++) { | |
| var b = { | |
| length : name[value].length | |
| }; | |
| if (this.F) { | |
| this.F.log("tbphrase", b); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} that | |
| * @param {string} value | |
| * @param {!RegExp} range | |
| * @return {undefined} | |
| */ | |
| var Xt = function(that, value, range) { | |
| /** @type {number} */ | |
| var length = 0; | |
| for (; range.test(value);) { | |
| var pos = range.lastIndex; | |
| if (pos > length) { | |
| that.push(value.substr(length, pos - length)); | |
| } | |
| length = pos; | |
| } | |
| if (value.length > length) { | |
| that.push(value.substr(length)); | |
| } | |
| }; | |
| /** @type {!Array} */ | |
| var Yt = [0, 200]; | |
| var Zt = { | |
| 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, | |
| et : 1, | |
| fi : 1, | |
| fr : 1, | |
| hi : 1, | |
| hr : 1, | |
| hu : 1, | |
| hy : 1, | |
| id : 1, | |
| is : 1, | |
| it : 1, | |
| ja : 1, | |
| jw : 1, | |
| km : 1, | |
| ko : 1, | |
| la : 1, | |
| lv : 1, | |
| mk : 1, | |
| ml : 1, | |
| mr : 1, | |
| my : 1, | |
| ne : 1, | |
| nl : 1, | |
| no : 1, | |
| pl : 1, | |
| pt : 1, | |
| ro : 1, | |
| ru : 1, | |
| si : 1, | |
| sk : 1, | |
| sq : 1, | |
| sr : 1, | |
| su : 1, | |
| sv : 1, | |
| sw : 1, | |
| ta : 1, | |
| te : 1, | |
| th : 1, | |
| tl : 1, | |
| tr : 1, | |
| vi : 1, | |
| uk : 1, | |
| zh : 1, | |
| "zh-cn" : 1, | |
| "zh-tw" : 1 | |
| }; | |
| /** | |
| * @param {!NodeList} n | |
| * @param {number} a | |
| * @return {undefined} | |
| */ | |
| var $t = function(n, a) { | |
| /** @type {number} */ | |
| this.a = a; | |
| /** @type {!Array} */ | |
| var val = []; | |
| /** @type {boolean} */ | |
| var weight_col = true; | |
| /** @type {number} */ | |
| var i = n.length - 1; | |
| for (; 0 <= i; i--) { | |
| /** @type {number} */ | |
| var type = n[i] | 0; | |
| if (!(weight_col && type == a)) { | |
| /** @type {number} */ | |
| val[i] = type; | |
| /** @type {boolean} */ | |
| weight_col = false; | |
| } | |
| } | |
| /** @type {!Array} */ | |
| this.b = val; | |
| }; | |
| var au = {}; | |
| /** | |
| * @param {number} a | |
| * @return {?} | |
| */ | |
| var bu = function(a) { | |
| return -128 <= a && 128 > a ? we(au, a, function(b) { | |
| return new $t([b | 0], 0 > b ? -1 : 0); | |
| }) : new $t([a | 0], 0 > a ? -1 : 0); | |
| }; | |
| /** | |
| * @param {number} s | |
| * @return {?} | |
| */ | |
| var eu = function(s) { | |
| if (isNaN(s) || !isFinite(s)) { | |
| return cu; | |
| } | |
| if (0 > s) { | |
| return du(eu(-s)); | |
| } | |
| /** @type {!Array} */ | |
| var b = []; | |
| /** @type {number} */ | |
| var e = 1; | |
| /** @type {number} */ | |
| var $orderCol = 0; | |
| for (; s >= e; $orderCol++) { | |
| /** @type {number} */ | |
| b[$orderCol] = s / e | 0; | |
| /** @type {number} */ | |
| e = e * 4294967296; | |
| } | |
| return new $t(b, 0); | |
| }; | |
| /** | |
| * @param {string} str | |
| * @param {number} radix | |
| * @return {?} | |
| */ | |
| var fu = function(str, radix) { | |
| if (0 == str.length) { | |
| throw Error("number format error: empty string"); | |
| } | |
| radix = radix || 10; | |
| if (2 > radix || 36 < radix) { | |
| throw Error("radix out of range: " + radix); | |
| } | |
| if ("-" == str.charAt(0)) { | |
| return du(fu(str.substring(1), radix)); | |
| } | |
| if (0 <= str.indexOf("-")) { | |
| throw Error('number format error: interior "-" character'); | |
| } | |
| var y = eu(Math.pow(radix, 8)); | |
| var date = cu; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < str.length; i = i + 8) { | |
| /** @type {number} */ | |
| var x = Math.min(8, str.length - i); | |
| /** @type {number} */ | |
| var value = parseInt(str.substring(i, i + x), radix); | |
| if (8 > x) { | |
| x = eu(Math.pow(radix, x)); | |
| date = gu(date, x).add(eu(value)); | |
| } else { | |
| date = gu(date, y); | |
| date = date.add(eu(value)); | |
| } | |
| } | |
| return date; | |
| }; | |
| var cu = bu(0); | |
| var hu = bu(1); | |
| var iu = bu(16777216); | |
| /** | |
| * @param {!Object} dir | |
| * @return {?} | |
| */ | |
| var ju = function(dir) { | |
| if (-1 == dir.a) { | |
| return -ju(du(dir)); | |
| } | |
| /** @type {number} */ | |
| var base_cost = 0; | |
| /** @type {number} */ | |
| var count = 1; | |
| /** @type {number} */ | |
| var query = 0; | |
| for (; query < dir.b.length; query++) { | |
| /** @type {number} */ | |
| base_cost = base_cost + ku(dir, query) * count; | |
| /** @type {number} */ | |
| count = count * 4294967296; | |
| } | |
| return base_cost; | |
| }; | |
| /** | |
| * @param {number} radix | |
| * @return {?} | |
| */ | |
| $t.prototype.toString = function(radix) { | |
| radix = radix || 10; | |
| if (2 > radix || 36 < radix) { | |
| throw Error("radix out of range: " + radix); | |
| } | |
| if (lu(this)) { | |
| return "0"; | |
| } | |
| if (-1 == this.a) { | |
| return "-" + du(this).toString(radix); | |
| } | |
| var one = eu(Math.pow(radix, 6)); | |
| var s = this; | |
| /** @type {string} */ | |
| var result = ""; | |
| for (;;) { | |
| var t = mu(s, one).a; | |
| s = nu(s, gu(t, one)); | |
| /** @type {string} */ | |
| var digits = ((0 < s.b.length ? s.b[0] : s.a) >>> 0).toString(radix); | |
| s = t; | |
| if (lu(s)) { | |
| return digits + result; | |
| } | |
| for (; 6 > digits.length;) { | |
| /** @type {string} */ | |
| digits = "0" + digits; | |
| } | |
| /** @type {string} */ | |
| result = "" + digits + result; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {number} b | |
| * @return {?} | |
| */ | |
| var ou = function(a, b) { | |
| return 0 > b ? 0 : b < a.b.length ? a.b[b] : a.a; | |
| }; | |
| /** | |
| * @param {number} a | |
| * @param {number} fn | |
| * @return {?} | |
| */ | |
| var ku = function(a, fn) { | |
| a = ou(a, fn); | |
| return 0 <= a ? a : 4294967296 + a; | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @return {?} | |
| */ | |
| var lu = function(o) { | |
| if (0 != o.a) { | |
| return false; | |
| } | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < o.b.length; i++) { | |
| if (0 != o.b[i]) { | |
| return false; | |
| } | |
| } | |
| return true; | |
| }; | |
| /** | |
| * @param {!Object} right | |
| * @return {?} | |
| */ | |
| $t.prototype.Oc = function(right) { | |
| if (this.a != right.a) { | |
| return false; | |
| } | |
| /** @type {number} */ | |
| var complexSize = Math.max(this.b.length, right.b.length); | |
| /** @type {number} */ | |
| var c = 0; | |
| for (; c < complexSize; c++) { | |
| if (ou(this, c) != ou(right, c)) { | |
| return false; | |
| } | |
| } | |
| return true; | |
| }; | |
| /** | |
| * @param {!Object} key | |
| * @return {?} | |
| */ | |
| $t.prototype.compare = function(key) { | |
| key = nu(this, key); | |
| return -1 == key.a ? -1 : lu(key) ? 0 : 1; | |
| }; | |
| /** | |
| * @param {!Object} p | |
| * @return {?} | |
| */ | |
| var du = function(p) { | |
| var inputsSize = p.b.length; | |
| /** @type {!Array} */ | |
| var options = []; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < inputsSize; i++) { | |
| /** @type {number} */ | |
| options[i] = ~p.b[i]; | |
| } | |
| return (new $t(options, ~p.a)).add(hu); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| $t.prototype.abs = function() { | |
| return -1 == this.a ? du(this) : this; | |
| }; | |
| /** | |
| * @param {string} key | |
| * @return {?} | |
| */ | |
| $t.prototype.add = function(key) { | |
| /** @type {number} */ | |
| var vSectors = Math.max(this.b.length, key.b.length); | |
| /** @type {!Array} */ | |
| var pixels = []; | |
| /** @type {number} */ | |
| var a = 0; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i <= vSectors; i++) { | |
| /** @type {number} */ | |
| var b = a + (ou(this, i) & 65535) + (ou(key, i) & 65535); | |
| /** @type {number} */ | |
| var g = (b >>> 16) + (ou(this, i) >>> 16) + (ou(key, i) >>> 16); | |
| /** @type {number} */ | |
| a = g >>> 16; | |
| /** @type {number} */ | |
| b = b & 65535; | |
| /** @type {number} */ | |
| g = g & 65535; | |
| /** @type {number} */ | |
| pixels[i] = g << 16 | b; | |
| } | |
| return new $t(pixels, pixels[pixels.length - 1] & -2147483648 ? -1 : 0); | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| var nu = function(o, value) { | |
| return o.add(du(value)); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| var gu = function(a, b) { | |
| if (lu(a) || lu(b)) { | |
| return cu; | |
| } | |
| if (-1 == a.a) { | |
| return -1 == b.a ? gu(du(a), du(b)) : du(gu(du(a), b)); | |
| } | |
| if (-1 == b.a) { | |
| return du(gu(a, du(b))); | |
| } | |
| if (0 > a.compare(iu) && 0 > b.compare(iu)) { | |
| return eu(ju(a) * ju(b)); | |
| } | |
| var N = a.b.length + b.b.length; | |
| /** @type {!Array} */ | |
| var pixels = []; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < 2 * N; i++) { | |
| /** @type {number} */ | |
| pixels[i] = 0; | |
| } | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < a.b.length; i++) { | |
| /** @type {number} */ | |
| var j = 0; | |
| for (; j < b.b.length; j++) { | |
| /** @type {number} */ | |
| var g = ou(a, i) >>> 16; | |
| /** @type {number} */ | |
| var n = ou(a, i) & 65535; | |
| /** @type {number} */ | |
| var m6 = ou(b, j) >>> 16; | |
| /** @type {number} */ | |
| var factor = ou(b, j) & 65535; | |
| pixels[2 * i + 2 * j] += n * factor; | |
| pu(pixels, 2 * i + 2 * j); | |
| pixels[2 * i + 2 * j + 1] += g * factor; | |
| pu(pixels, 2 * i + 2 * j + 1); | |
| pixels[2 * i + 2 * j + 1] += n * m6; | |
| pu(pixels, 2 * i + 2 * j + 1); | |
| pixels[2 * i + 2 * j + 2] += g * m6; | |
| pu(pixels, 2 * i + 2 * j + 2); | |
| } | |
| } | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < N; i++) { | |
| /** @type {number} */ | |
| pixels[i] = pixels[2 * i + 1] << 16 | pixels[2 * i]; | |
| } | |
| i = N; | |
| for (; i < 2 * N; i++) { | |
| /** @type {number} */ | |
| pixels[i] = 0; | |
| } | |
| return new $t(pixels, 0); | |
| }; | |
| /** | |
| * @param {!Array} result | |
| * @param {number} index | |
| * @return {undefined} | |
| */ | |
| var pu = function(result, index) { | |
| for (; (result[index] & 65535) != result[index];) { | |
| result[index + 1] += result[index] >>> 16; | |
| result[index] &= 65535; | |
| index++; | |
| } | |
| }; | |
| /** | |
| * @param {number} a | |
| * @param {number} b | |
| * @return {undefined} | |
| */ | |
| var qu = function(a, b) { | |
| /** @type {number} */ | |
| this.a = a; | |
| /** @type {number} */ | |
| this.b = b; | |
| }; | |
| /** | |
| * @param {!Object} v | |
| * @param {string} e | |
| * @return {?} | |
| */ | |
| var mu = function(v, e) { | |
| if (lu(e)) { | |
| throw Error("division by zero"); | |
| } | |
| if (lu(v)) { | |
| return new qu(cu, cu); | |
| } | |
| if (-1 == v.a) { | |
| return e = mu(du(v), e), new qu(du(e.a), du(e.b)); | |
| } | |
| if (-1 == e.a) { | |
| return e = mu(v, du(e)), new qu(du(e.a), e.b); | |
| } | |
| if (30 < v.b.length) { | |
| if (-1 == v.a || -1 == e.a) { | |
| throw Error("slowDivide_ only works with positive integers."); | |
| } | |
| var n = hu; | |
| /** @type {string} */ | |
| var d = e; | |
| for (; 0 >= d.compare(v);) { | |
| n = ru(n, 1); | |
| d = ru(d, 1); | |
| } | |
| var r = su(n, 1); | |
| var w = su(d, 1); | |
| d = su(d, 2); | |
| n = su(n, 2); | |
| for (; !lu(d);) { | |
| var c = w.add(d); | |
| if (0 >= c.compare(v)) { | |
| r = r.add(n); | |
| w = c; | |
| } | |
| d = su(d, 1); | |
| n = su(n, 1); | |
| } | |
| e = nu(v, gu(r, e)); | |
| return new qu(r, e); | |
| } | |
| r = cu; | |
| for (; 0 <= v.compare(e);) { | |
| /** @type {number} */ | |
| n = Math.max(1, Math.floor(ju(v) / ju(e))); | |
| /** @type {number} */ | |
| d = Math.ceil(Math.log(n) / Math.LN2); | |
| /** @type {number} */ | |
| d = 48 >= d ? 1 : Math.pow(2, d - 48); | |
| w = eu(n); | |
| c = gu(w, e); | |
| for (; -1 == c.a || 0 < c.compare(v);) { | |
| /** @type {number} */ | |
| n = n - d; | |
| w = eu(n); | |
| c = gu(w, e); | |
| } | |
| if (lu(w)) { | |
| w = hu; | |
| } | |
| r = r.add(w); | |
| v = nu(v, c); | |
| } | |
| return new qu(r, v); | |
| }; | |
| /** | |
| * @param {!Object} target | |
| * @return {?} | |
| */ | |
| $t.prototype.and = function(target) { | |
| /** @type {number} */ | |
| var G = Math.max(this.b.length, target.b.length); | |
| /** @type {!Array} */ | |
| var buttons = []; | |
| /** @type {number} */ | |
| var btn = 0; | |
| for (; btn < G; btn++) { | |
| /** @type {number} */ | |
| buttons[btn] = ou(this, btn) & ou(target, btn); | |
| } | |
| return new $t(buttons, this.a & target.a); | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @return {?} | |
| */ | |
| $t.prototype.or = function(obj) { | |
| /** @type {number} */ | |
| var pairValue = Math.max(this.b.length, obj.b.length); | |
| /** @type {!Array} */ | |
| var someParameters = []; | |
| /** @type {number} */ | |
| var value = 0; | |
| for (; value < pairValue; value++) { | |
| /** @type {number} */ | |
| someParameters[value] = ou(this, value) | ou(obj, value); | |
| } | |
| return new $t(someParameters, this.a | obj.a); | |
| }; | |
| /** | |
| * @param {!Object} s1 | |
| * @return {?} | |
| */ | |
| $t.prototype.xor = function(s1) { | |
| /** @type {number} */ | |
| var eleSize = Math.max(this.b.length, s1.b.length); | |
| /** @type {!Array} */ | |
| var mostRecentPublicUser = []; | |
| /** @type {number} */ | |
| var x = 0; | |
| for (; x < eleSize; x++) { | |
| /** @type {number} */ | |
| mostRecentPublicUser[x] = ou(this, x) ^ ou(s1, x); | |
| } | |
| return new $t(mostRecentPublicUser, this.a ^ s1.a); | |
| }; | |
| /** | |
| * @param {!Object} val | |
| * @param {number} pos | |
| * @return {?} | |
| */ | |
| var ru = function(val, pos) { | |
| /** @type {number} */ | |
| var n = pos >> 5; | |
| /** @type {number} */ | |
| pos = pos % 32; | |
| var numTarget = val.b.length + n + (0 < pos ? 1 : 0); | |
| /** @type {!Array} */ | |
| var yinBuffer = []; | |
| /** @type {number} */ | |
| var t = 0; | |
| for (; t < numTarget; t++) { | |
| yinBuffer[t] = 0 < pos ? ou(val, t - n) << pos | ou(val, t - n - 1) >>> 32 - pos : ou(val, t - n); | |
| } | |
| return new $t(yinBuffer, val.a); | |
| }; | |
| /** | |
| * @param {!Object} fn | |
| * @param {number} n | |
| * @return {?} | |
| */ | |
| var su = function(fn, n) { | |
| /** @type {number} */ | |
| var n1 = n >> 5; | |
| /** @type {number} */ | |
| n = n % 32; | |
| /** @type {number} */ | |
| var diff = fn.b.length - n1; | |
| /** @type {!Array} */ | |
| var ITFData = []; | |
| /** @type {number} */ | |
| var n2 = 0; | |
| for (; n2 < diff; n2++) { | |
| ITFData[n2] = 0 < n ? ou(fn, n2 + n1) >>> n | ou(fn, n2 + n1 + 1) << 32 - n : ou(fn, n2 + n1); | |
| } | |
| return new $t(ITFData, fn.a); | |
| }; | |
| /** | |
| * @param {number} a | |
| * @param {number} c | |
| * @return {undefined} | |
| */ | |
| var tu = function(a, c) { | |
| /** @type {number} */ | |
| this.a = a; | |
| /** @type {number} */ | |
| this.c = c; | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| tu.prototype.Oc = function(value) { | |
| return this.c == value.c && this.a.Oc(Vb(value.a)); | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @return {undefined} | |
| */ | |
| var wu = function(value) { | |
| /** @type {null} */ | |
| this.b = null; | |
| var step = cu; | |
| if (value instanceof $t) { | |
| if (0 != value.a || 0 > value.compare(cu) || 0 < value.compare(uu)) { | |
| throw Error("The address does not look like an IPv4."); | |
| } | |
| step = Vb(value); | |
| } else { | |
| if (!vu.test(value)) { | |
| throw Error(value + " does not look like an IPv4 address."); | |
| } | |
| var tempLayoutArray = value.split("."); | |
| if (4 != tempLayoutArray.length) { | |
| throw Error(value + " does not look like an IPv4 address."); | |
| } | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < tempLayoutArray.length; i++) { | |
| var val = oe(tempLayoutArray[i]); | |
| if (isNaN(val) || 0 > val || 255 < val || 1 != tempLayoutArray[i].length && vc(tempLayoutArray[i], "0")) { | |
| throw Error("In " + value + ", octet " + i + " is not valid"); | |
| } | |
| val = eu(val); | |
| step = ru(step, 8).or(val); | |
| } | |
| } | |
| tu.call(this, step, 4); | |
| }; | |
| x(wu, tu); | |
| /** @type {!RegExp} */ | |
| var vu = /^[0-9.]*$/; | |
| var uu = nu(ru(hu, 32), hu); | |
| /** | |
| * @return {?} | |
| */ | |
| wu.prototype.toString = function() { | |
| if (this.b) { | |
| return this.b; | |
| } | |
| var ip = ku(this.a, 0); | |
| /** @type {!Array} */ | |
| var components = []; | |
| /** @type {number} */ | |
| var j = 3; | |
| for (; 0 <= j; j--) { | |
| /** @type {string} */ | |
| components[j] = String(ip & 255); | |
| /** @type {number} */ | |
| ip = ip >>> 8; | |
| } | |
| return this.b = components.join("."); | |
| }; | |
| /** | |
| * @param {number} value | |
| * @return {undefined} | |
| */ | |
| var Au = function(value) { | |
| /** @type {null} */ | |
| this.b = null; | |
| var step = cu; | |
| if (value instanceof $t) { | |
| if (0 != value.a || 0 > value.compare(cu) || 0 < value.compare(xu)) { | |
| throw Error("The address does not look like a valid IPv6."); | |
| } | |
| step = Vb(value); | |
| } else { | |
| if (!yu.test(value)) { | |
| throw Error(value + " is not a valid IPv6 address."); | |
| } | |
| var a = value.split(":"); | |
| if (-1 != a[a.length - 1].indexOf(".")) { | |
| value = ku(Vb((new wu(a[a.length - 1])).a), 0); | |
| /** @type {!Array} */ | |
| var b = []; | |
| b.push((value >>> 16 & 65535).toString(16)); | |
| b.push((value & 65535).toString(16)); | |
| wb(a, a.length - 1); | |
| Bb(a, b); | |
| value = a.join(":"); | |
| } | |
| b = value.split("::"); | |
| if (2 < b.length || 1 == b.length && 8 != a.length) { | |
| throw Error(value + " is not a valid IPv6 address."); | |
| } | |
| if (1 < b.length) { | |
| a = b[0].split(":"); | |
| b = b[1].split(":"); | |
| if (1 == a.length && "" == a[0]) { | |
| /** @type {!Array} */ | |
| a = []; | |
| } | |
| if (1 == b.length && "" == b[0]) { | |
| /** @type {!Array} */ | |
| b = []; | |
| } | |
| /** @type {number} */ | |
| var o = 8 - (a.length + b.length); | |
| if (1 > o) { | |
| /** @type {!Array} */ | |
| a = []; | |
| } else { | |
| /** @type {!Array} */ | |
| var dy = []; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < o; i++) { | |
| /** @type {string} */ | |
| dy[i] = "0"; | |
| } | |
| a = zb(a, dy, b); | |
| } | |
| } | |
| if (8 != a.length) { | |
| throw Error(value + " is not a valid IPv6 address"); | |
| } | |
| /** @type {number} */ | |
| b = 0; | |
| for (; b < a.length; b++) { | |
| o = fu(a[b], 16); | |
| if (0 > o.compare(cu) || 0 < o.compare(zu)) { | |
| throw Error(a[b] + " in " + value + " is not a valid hextet."); | |
| } | |
| step = ru(step, 16).or(o); | |
| } | |
| } | |
| tu.call(this, step, 6); | |
| }; | |
| x(Au, tu); | |
| /** @type {!RegExp} */ | |
| var yu = /^([a-fA-F0-9]*:){2}[a-fA-F0-9:.]*$/; | |
| var zu = bu(65535); | |
| var xu = nu(ru(hu, 128), hu); | |
| /** | |
| * @return {?} | |
| */ | |
| Au.prototype.toString = function() { | |
| if (this.b) { | |
| return this.b; | |
| } | |
| /** @type {!Array} */ | |
| var p = []; | |
| /** @type {number} */ | |
| var c = 3; | |
| for (; 0 <= c; c--) { | |
| var a = ku(this.a, c); | |
| /** @type {number} */ | |
| var i = a & 65535; | |
| p.push((a >>> 16).toString(16)); | |
| p.push(i.toString(16)); | |
| } | |
| /** @type {number} */ | |
| a = c = -1; | |
| /** @type {number} */ | |
| var j = i = 0; | |
| /** @type {number} */ | |
| var m = 0; | |
| for (; m < p.length; m++) { | |
| if ("0" == p[m]) { | |
| j++; | |
| if (-1 == a) { | |
| /** @type {number} */ | |
| a = m; | |
| } | |
| if (j > i) { | |
| /** @type {number} */ | |
| i = j; | |
| /** @type {number} */ | |
| c = a; | |
| } | |
| } else { | |
| /** @type {number} */ | |
| a = -1; | |
| /** @type {number} */ | |
| j = 0; | |
| } | |
| } | |
| if (0 < i) { | |
| if (c + i == p.length) { | |
| p.push(""); | |
| } | |
| p.splice(c, i, ""); | |
| if (0 == c) { | |
| /** @type {!Array<?>} */ | |
| p = [""].concat(p); | |
| } | |
| } | |
| return this.b = p.join(":"); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Bu = function() { | |
| }; | |
| var Cu; | |
| var Du = { | |
| http : 1, | |
| https : 1, | |
| ftp : 1 | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} be | |
| * @return {?} | |
| */ | |
| var Eu = function(a, be) { | |
| try { | |
| var v = Lm(a); | |
| } catch (m) { | |
| return false; | |
| } | |
| if (!(a = v.c && !Du[v.c.toLowerCase()] || !v.b)) { | |
| v = v.b; | |
| a: { | |
| a = v.split("."); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < a.length; i++) { | |
| if (!a[i]) { | |
| /** @type {boolean} */ | |
| var s = false; | |
| break a; | |
| } | |
| } | |
| if (1 < a.length) { | |
| be = a[a.length - 1].toLowerCase(); | |
| if (!Cu) { | |
| try { | |
| s = Ve; | |
| } catch (m) { | |
| throw Error("Variable CFG_twsfe_likelyurl_module_file has not been loaded. This is probaly due the configuration data not being properly included."); | |
| } | |
| a = {}; | |
| var h = s.ascii_tlds; | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < h.length; i++) { | |
| var f = h[i]; | |
| /** @type {number} */ | |
| a[f.toLowerCase()] = 1; | |
| } | |
| s = s.unicode_tlds; | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < s.length; i++) { | |
| f = s[i]; | |
| /** @type {number} */ | |
| a[f.toLowerCase()] = 1; | |
| } | |
| /** @type {!Object} */ | |
| Cu = a; | |
| } | |
| /** @type {boolean} */ | |
| s = !!Cu[be]; | |
| } else { | |
| /** @type {boolean} */ | |
| s = !be; | |
| } | |
| } | |
| if (!s) { | |
| try { | |
| var term = vc(v, "[") && wc(v, "]") ? new Au(v.substring(1, v.length - 1)) : new wu(v); | |
| } catch (m) { | |
| /** @type {null} */ | |
| term = null; | |
| } | |
| /** @type {boolean} */ | |
| s = null != term; | |
| } | |
| /** @type {boolean} */ | |
| a = !s; | |
| } | |
| return a ? false : true; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {?} | |
| */ | |
| var Fu = function(a) { | |
| a = zc(a); | |
| if (0 <= a.search(/[\s\xa0@]/)) { | |
| return false; | |
| } | |
| if (Eu(a, false)) { | |
| return true; | |
| } | |
| var valueProgess = a.replace(/%([0-9A-Fa-f][0-9A-Fa-f])/g, function(canCreateDiscussions, b) { | |
| return String.fromCharCode(Number("0x" + b)); | |
| }); | |
| return Eu(valueProgess, false) ? true : Eu("http://" + a, true) || Eu("http://" + valueProgess, true); | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @param {string} value | |
| * @return {?} | |
| */ | |
| Bu.prototype.a = function(name, value) { | |
| if ("string" != typeof name) { | |
| throw Error("Pattern is not a string."); | |
| } | |
| /** @type {!Arguments} */ | |
| var theArgs = arguments; | |
| return name.replace(/%(\d+)\$\w/g, function(canCreateDiscussions, i) { | |
| /** @type {number} */ | |
| i = parseInt(i, 10); | |
| return 0 < i && i < theArgs.length ? theArgs[i] : canCreateDiscussions; | |
| }); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var Gu = function() { | |
| var a = (new tm(l.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; | |
| }; | |
| /** | |
| * @param {!Object} c | |
| * @return {undefined} | |
| */ | |
| var Hu = function(c) { | |
| /** @type {string} */ | |
| var wrapper = ""; | |
| /** @type {number} */ | |
| var j = 0; | |
| for (; j < J(c, 5); j++) { | |
| var val = Vo(c, j); | |
| if (dh(val, 4) && 0 < K(val, 4).length) { | |
| wrapper = K(val, 4); | |
| } else { | |
| /** @type {string} */ | |
| (new io(val.Jb())).$a[4] = wrapper; | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} canvas | |
| * @return {?} | |
| */ | |
| var Iu = function(canvas) { | |
| canvas = lb(il(canvas, 0, zl), function(cX1) { | |
| return dh(cX1, 4); | |
| }); | |
| canvas = mb(canvas, function(v) { | |
| return fl(v, 4, 0); | |
| }); | |
| return nb(canvas, function(event, object) { | |
| return event && 1 == object; | |
| }, 0 < canvas.length); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {?} ud | |
| * @param {(!Function|RegExp|string)} un | |
| * @param {?} mode | |
| * @param {?} reason | |
| * @param {string} p | |
| * @param {string} altCss | |
| * @return {undefined} | |
| */ | |
| var Ju = function(a, ud, un, mode, reason, p, altCss) { | |
| L.call(this); | |
| /** @type {!Object} */ | |
| this.a = a; | |
| this.ea = hm.N(); | |
| this.F = M.N(); | |
| this.ma = new Tt(this.ea); | |
| this.Na = ud; | |
| /** @type {string} */ | |
| this.O = this.Y = this.h = this.c = ""; | |
| /** @type {number} */ | |
| this.W = 0; | |
| /** @type {boolean} */ | |
| this.m = false; | |
| this.b = new Mt("tts", hm.N(), un); | |
| /** @type {boolean} */ | |
| this.Z = null != this.b.b && (C.Kc && Kc(C.Md(), "UCBrowser") ? false : true); | |
| this.G = C.product.Lc || C.product.vc; | |
| I(this.b, "stop_playlist", this.R, false, this); | |
| I(this.a, "action", this.lk, false, this); | |
| if (null != this.a.j()) { | |
| I(this.a.j(), "click", this.Dp, false, this); | |
| } | |
| /** @type {(null|string)} */ | |
| this.T = (a = /(sa=[^#&]+)/.exec(window.location.href)) ? a[0] : null; | |
| /** @type {(null|string)} */ | |
| this.C = (a = /ttsspeed=([^&]+)/.exec(window.location.href)) ? a[0] : null; | |
| /** @type {(null|string)} */ | |
| this.K = (a = /gl=([^&]+)/.exec(window.location.href)) ? a[0] : null; | |
| /** @type {number} */ | |
| this.g = 0; | |
| /** @type {boolean} */ | |
| this.ra = !!mode; | |
| /** @type {boolean} */ | |
| this.Aa = !!reason; | |
| this.L = p || null; | |
| this.oa = altCss || null; | |
| /** @type {string} */ | |
| this.o = ""; | |
| this.Da = new Bu; | |
| /** @type {null} */ | |
| this.w = null; | |
| }; | |
| x(Ju, L); | |
| /** | |
| * @return {undefined} | |
| */ | |
| Ju.prototype.X = function() { | |
| Ju.D.X.call(this); | |
| Og(this.b, "stop_playlist", this.R, false, this); | |
| Og(this.a, "action", this.lk, false, this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Ju.prototype.R = function() { | |
| this.a.wd(false); | |
| }; | |
| /** | |
| * @param {?} global | |
| * @param {number} result | |
| * @param {?} message | |
| * @param {number} e | |
| * @param {number} tag | |
| * @param {?} num | |
| * @return {?} | |
| */ | |
| var Ku = function(global, result, message, e, tag, num) { | |
| result = ne("/translate_tts?ie=UTF-8&q=", de(result), "&tl=", message, "&total=", e, "&idx=", tag, "&textlen=", result.length, co(result), global.Na, num); | |
| if (global.K) { | |
| /** @type {string} */ | |
| result = result + ("&" + global.K); | |
| } | |
| return result; | |
| }; | |
| k = Ju.prototype; | |
| /** | |
| * @param {string} c | |
| * @param {number} x | |
| * @param {string} target | |
| * @param {string} data | |
| * @param {string} w | |
| * @return {undefined} | |
| */ | |
| k.update = function(c, x, target, data, w) { | |
| /** @type {!RegExp} */ | |
| var reJSChar = /([^?.,;:!"#$%&'()*+\-/<=>?@[\]^_`{|}~\u3001\u3002\uff01\uff08\uff09\uff0c\uff0e\uff1a\uff1b\uff1f])/; | |
| /** @type {string} */ | |
| this.o = ""; | |
| if (null != target) { | |
| /** @type {number} */ | |
| var a = 0; | |
| for (; a < J(target, 5); a++) { | |
| var i = Vo(target, a); | |
| var ch = hh(lo(i, 0), 0); | |
| var index = hh(lo(i, 0), 1); | |
| ch = K(i, 4).substring(ch, index); | |
| i = K(ko(i, 0), 0); | |
| if (ch == i && reJSChar.test(ch)) { | |
| this.o = K(target, 2); | |
| break; | |
| } | |
| } | |
| } | |
| /** @type {number} */ | |
| this.g = 0; | |
| if (this.Z) { | |
| if (xc(c)) { | |
| Lu(this, false); | |
| this.a.sa(false); | |
| } else { | |
| if (c != this.c || x != this.h || w != this.w) { | |
| /** @type {string} */ | |
| this.c = c; | |
| /** @type {number} */ | |
| this.h = x; | |
| this.w = w || null; | |
| /** @type {boolean} */ | |
| target = false; | |
| } else { | |
| /** @type {boolean} */ | |
| target = true; | |
| } | |
| if (!target) { | |
| this.b.stop(); | |
| /** @type {boolean} */ | |
| this.m = !this.Z || !x || xc(c) || this.G && c.length > Yt[Zt[x.toLowerCase()]] ? false : x.toLowerCase() in Zt; | |
| } | |
| Lu(this, this.Aa || this.m); | |
| this.a.sa(this.m); | |
| } | |
| } else { | |
| Lu(this, false); | |
| this.a.sa(false); | |
| } | |
| if (null != data) { | |
| if (this.a.isEnabled() && null != this.L) { | |
| this.a.j().setAttribute("data-tooltip", this.L); | |
| } else { | |
| if (!this.a.isEnabled() && null != this.oa) { | |
| this.a.j().setAttribute("data-tooltip", this.Da.a(this.oa, data)); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.play = function() { | |
| if (this.c != this.Y || this.h != this.O || this.g != this.W) { | |
| if (this.G) { | |
| /** @type {!Array} */ | |
| var pts = [this.c]; | |
| } else { | |
| pts = Yt[Zt[this.h.toLowerCase()]]; | |
| /** @type {!Array} */ | |
| var p = []; | |
| var value = this.ma; | |
| var cl = this.c.replace(/[ \u3000\n\r\t\s]+/g, " "); | |
| Ut(p, cl, pts, v(value.a, value), v(value.g, value)); | |
| /** @type {!Array} */ | |
| pts = p; | |
| } | |
| /** @type {!Array} */ | |
| p = []; | |
| /** @type {!Array} */ | |
| value = []; | |
| /** @type {string} */ | |
| cl = ""; | |
| if (null != this.T) { | |
| /** @type {string} */ | |
| cl = cl + ("&" + this.T); | |
| } | |
| if (null != this.C) { | |
| /** @type {string} */ | |
| cl = cl + ("&ttsspeed=" + this.C); | |
| } else { | |
| if (0 != this.g) { | |
| /** @type {string} */ | |
| cl = cl + ("&ttsspeed=" + this.g); | |
| } | |
| } | |
| if (this.o) { | |
| /** @type {string} */ | |
| cl = cl + ("&hint=" + this.o); | |
| } | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < pts.length; i++) { | |
| p.push(Ku(this, pts[i], this.h, pts.length, i, cl)); | |
| value.push(pts[i].length); | |
| } | |
| this.b.set(p, this.c.length, value, this.w, { | |
| textlen : this.c.length, | |
| tl : this.h | |
| }); | |
| this.Y = this.c; | |
| this.O = this.h; | |
| this.W = this.g; | |
| } | |
| this.b.start(); | |
| if (this.ra) { | |
| /** @type {number} */ | |
| this.g = 0 === this.g ? .24 : 0; | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.stop = function() { | |
| this.b.stop(); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.lk = function() { | |
| if (this.a.Ha(16)) { | |
| this.play(); | |
| } else { | |
| this.stop(); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} c | |
| * @return {undefined} | |
| */ | |
| k.Dp = function(c) { | |
| if (!this.a.isEnabled()) { | |
| c.stopPropagation(); | |
| this.dispatchEvent("userInteractionWhileDisabled"); | |
| c = this.F; | |
| N(c, O(c, 306)); | |
| mm(this.ea, "webapp", "dia", "click", { | |
| dias : "vo" | |
| }); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} me | |
| * @param {boolean} val | |
| * @return {undefined} | |
| */ | |
| var Lu = function(me, val) { | |
| me.a.setVisible(val); | |
| if (!val) { | |
| me.b.stop(); | |
| } | |
| }; | |
| /** | |
| * @param {number} a | |
| * @return {?} | |
| */ | |
| var Mu = function(a) { | |
| if (0 == a) { | |
| return 0; | |
| } | |
| if (1 == a) { | |
| return 1; | |
| } | |
| /** @type {number} */ | |
| var r = .4 * a; | |
| /** @type {number} */ | |
| var x = .4 + -.2 * a; | |
| /** @type {number} */ | |
| r = r + a * (x - r); | |
| return r + a * (x + a * (.2 + .8 * a - x) - r); | |
| }; | |
| /** | |
| * @param {number} a | |
| * @return {?} | |
| */ | |
| var Nu = function(a) { | |
| if (0 == a) { | |
| return 0; | |
| } | |
| if (1 == a) { | |
| return 1; | |
| } | |
| /** @type {number} */ | |
| var g = 0 * a; | |
| /** @type {number} */ | |
| var r = 1 * a; | |
| /** @type {number} */ | |
| g = g + a * (r - g); | |
| return g + a * (r + a * (1 + 0 * a - r) - g); | |
| }; | |
| /** | |
| * @param {number} b | |
| * @return {?} | |
| */ | |
| var Ou = function(b) { | |
| /** @type {number} */ | |
| var a = b - 0; | |
| if (0 >= a) { | |
| return 0; | |
| } | |
| if (1 <= a) { | |
| return 1; | |
| } | |
| /** @type {number} */ | |
| var p = 0; | |
| /** @type {number} */ | |
| var ext = 1; | |
| /** @type {number} */ | |
| var d = 0; | |
| /** @type {number} */ | |
| var f = 0; | |
| for (; 8 > f; f++) { | |
| d = Mu(a); | |
| /** @type {number} */ | |
| var width = (Mu(a + 1E-6) - d) / 1E-6; | |
| if (1E-6 > Math.abs(d - b)) { | |
| return a; | |
| } | |
| if (1E-6 > Math.abs(width)) { | |
| break; | |
| } else { | |
| if (d < b) { | |
| /** @type {number} */ | |
| p = a; | |
| } else { | |
| /** @type {number} */ | |
| ext = a; | |
| } | |
| /** @type {number} */ | |
| a = a - (d - b) / width; | |
| } | |
| } | |
| /** @type {number} */ | |
| f = 0; | |
| for (; 1E-6 < Math.abs(d - b) && 8 > f; f++) { | |
| if (d < b) { | |
| /** @type {number} */ | |
| p = a; | |
| /** @type {number} */ | |
| a = (a + ext) / 2; | |
| } else { | |
| /** @type {number} */ | |
| ext = a; | |
| /** @type {number} */ | |
| a = (a + p) / 2; | |
| } | |
| d = Mu(a); | |
| } | |
| return a; | |
| }; | |
| /** | |
| * @param {?} result | |
| * @return {?} | |
| */ | |
| var Pu = function(result) { | |
| /** @type {!Array} */ | |
| var output = []; | |
| if (result.sentences) { | |
| /** @type {number} */ | |
| var i = 0; | |
| var args; | |
| for (; args = result.sentences[i]; i++) { | |
| if (args.trans) { | |
| output.push(args.trans); | |
| } | |
| } | |
| } | |
| return output.join(""); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var Qu = function() { | |
| /** @type {!Array} */ | |
| var vertices = Array(51); | |
| /** @type {number} */ | |
| var vertexIndexA = 0; | |
| for (; 51 > vertexIndexA; vertexIndexA++) { | |
| vertices[vertexIndexA] = Nu(Ou(vertexIndexA / 50)); | |
| } | |
| return function(b) { | |
| if (0 >= b) { | |
| return 0; | |
| } | |
| if (1 <= b) { | |
| return 1; | |
| } | |
| /** @type {number} */ | |
| var a = 50 * b; | |
| /** @type {number} */ | |
| b = Math.floor(a); | |
| /** @type {number} */ | |
| a = a - b; | |
| return vertices[b] * (1 - a) + vertices[b + 1] * a; | |
| }; | |
| }; | |
| /** | |
| * @param {?} mode | |
| * @param {string} size | |
| * @return {undefined} | |
| */ | |
| var Ru = function(mode, size) { | |
| ns.call(this, mode, "ttl"); | |
| /** @type {null} */ | |
| this.b = this.c = null; | |
| this.g = new qt(MSG_LISTEN, void 0, new vt("trans-listen-button")); | |
| this.h = new Ju(this.g, "&client=" + (size ? size : "webapp") + "&prev=lc", 7); | |
| }; | |
| x(Ru, ns); | |
| /** | |
| * @return {undefined} | |
| */ | |
| Ru.prototype.Ra = function() { | |
| Ru.D.Ra.call(this); | |
| this.Fa(zf("DIV")); | |
| }; | |
| /** | |
| * @param {!Array} x | |
| * @return {undefined} | |
| */ | |
| Ru.prototype.Fa = function(x) { | |
| Ru.D.Fa.call(this, x); | |
| this.j().appendChild(Ap(Nn)); | |
| this.c = E("gt-ct-text", this.j()); | |
| x = E("gt-ct-tts", this.j()); | |
| this.b = E("gt-ct-translit", this.j()); | |
| this.g.na(x); | |
| }; | |
| /** | |
| * @param {string} c | |
| * @param {?} data | |
| * @param {!Object} i | |
| * @param {!Object} args | |
| * @return {?} | |
| */ | |
| Ru.prototype.update = function(c, data, i, args) { | |
| Ru.D.update.call(this, c, data, i, args); | |
| H(this.c, c); | |
| this.h.update(c, data); | |
| if (this.data) { | |
| /** @type {!Array} */ | |
| c = []; | |
| if (0 < this.data.sc()) { | |
| /** @type {number} */ | |
| data = 0; | |
| for (; data < this.data.sc(); data++) { | |
| i = this.data.hb(data); | |
| if (dh(i, 3) && "" != K(i, 3)) { | |
| c.push(K(i, 3)); | |
| } | |
| } | |
| } | |
| if (0 < c.length) { | |
| H(this.b, c.join(" ")); | |
| X(this.b, true); | |
| } else { | |
| X(this.b, false); | |
| } | |
| } | |
| this.setVisible(true); | |
| return true; | |
| }; | |
| /** | |
| * @param {string} mode | |
| * @param {?} size | |
| * @param {?} intSetSource | |
| * @param {?} numberOfSets | |
| * @param {string} numberOfPairs | |
| * @return {undefined} | |
| */ | |
| var Su = function(mode, size, intSetSource, numberOfSets, numberOfPairs) { | |
| ns.call(this, mode, "cm"); | |
| this.ea = size; | |
| this.C = new Ru(mode, numberOfPairs ? numberOfPairs : "webapp"); | |
| /** @type {null} */ | |
| this.w = null; | |
| this.ra = intSetSource; | |
| this.b = new zq; | |
| this.qb(this.b); | |
| this.c = new zq; | |
| this.qb(this.c); | |
| /** @type {null} */ | |
| this.g = this.m = this.K = this.O = this.T = null; | |
| /** @type {!Array} */ | |
| this.h = []; | |
| /** @type {boolean} */ | |
| this.Z = !!numberOfSets; | |
| this.ma = Uk.N(); | |
| this.F = M.N(); | |
| }; | |
| x(Su, ns); | |
| k = Su.prototype; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.Ra = function() { | |
| Su.D.Ra.call(this); | |
| this.Fa(zf("DIV")); | |
| }; | |
| /** | |
| * @param {!Object} x | |
| * @return {undefined} | |
| */ | |
| k.Fa = function(x) { | |
| Su.D.Fa.call(this, x); | |
| this.j().appendChild(Ap(Ln)); | |
| this.C.na(E("gt-cc-tc", this.j())); | |
| this.w = E("gt-cc-t", this.j()); | |
| X(this.w, false); | |
| this.b.na(E("gt-cc-l-i", this.j())); | |
| this.c.na(E("gt-cc-r-i", this.j())); | |
| x = E("gt-cc-bc", this.j()); | |
| this.T = new Br("", new vt("prev-button")); | |
| this.T.Za(x); | |
| this.O = new Br("", new vt("next-button")); | |
| this.O.Za(x); | |
| this.K = new Br("", new vt("big-clear-button")); | |
| this.K.Za(x); | |
| this.m = E("gt-cc-exp", this.j()); | |
| this.g = new xt(this.T, this.O, this.K, this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.ia = function() { | |
| Su.D.ia.call(this); | |
| Y(this).M(this, "a", this.Hm); | |
| Y(this).M(this, "b", this.Qm); | |
| Y(this).M(this.m, "click", this.zm); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.zm = function() { | |
| X(this.m, false); | |
| A(this.h, function(varTable) { | |
| varTable.setVisible(true); | |
| }); | |
| var temperature = {}; | |
| var valueProgess = this.F; | |
| Hq(this.b, function(state) { | |
| if (state.isVisible()) { | |
| Kl(valueProgess, state.ie(), state.sb(), state.Bc); | |
| /** @type {string} */ | |
| temperature[state.Tb()] = state.Bc ? "e" : "ne"; | |
| } | |
| }); | |
| Jl(this.F, 15, Iq(this.b)); | |
| this.log("expand", temperature); | |
| }; | |
| /** | |
| * @param {?} a | |
| * @return {undefined} | |
| */ | |
| k.Hm = function(a) { | |
| a = ag(a.target); | |
| Tu(this, this.Ca, this.Pa, a, false, "clks"); | |
| }; | |
| /** | |
| * @param {?} a | |
| * @return {undefined} | |
| */ | |
| k.Qm = function(a) { | |
| a = ag(a.target); | |
| Tu(this, this.Pa, this.Ca, a, false, "clkt"); | |
| }; | |
| /** | |
| * @param {!Object} $this | |
| * @return {undefined} | |
| */ | |
| k.Fm = function($this) { | |
| var url = $this.text; | |
| if (!(50 < url.length)) { | |
| var item = this.g.a[0]; | |
| if ($this.o) { | |
| Tu(this, item.Pa, item.Ca, url, true, "sel"); | |
| } else { | |
| Tu(this, item.Ca, item.Pa, url, true, "sel"); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @param {string} key | |
| * @param {!Object} by | |
| * @param {?} f | |
| * @param {boolean} swap | |
| * @param {string} container | |
| * @return {undefined} | |
| */ | |
| var Tu = function(value, key, by, f, swap, container) { | |
| if (f != value.text || key != value.Ca) { | |
| if ("zh-TW" == key) { | |
| /** @type {string} */ | |
| key = "zh-CN"; | |
| } | |
| Yk(value.ma, container); | |
| if (swap) { | |
| H(value.C.c, "..."); | |
| bp(value.ea, key, by, value.Xa, f, v(value.W, value, f, key, by), false, "UTF-8", new Am("source=" + container)); | |
| } else { | |
| value.dispatchEvent("translationRefreshed"); | |
| ht(value.ra, key, by, f, container); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} id | |
| * @return {undefined} | |
| */ | |
| Su.prototype.setVisible = function(id) { | |
| var value = this.j(); | |
| /** @type {boolean} */ | |
| value = !(!value || !E("gender-promo-visible", value)); | |
| Su.D.setVisible.call(this, id || value); | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {?} v | |
| * @param {?} x | |
| * @param {!Object} key | |
| * @return {?} | |
| */ | |
| Su.prototype.update = function(a, v, x, key) { | |
| Su.D.update.call(this, a, v, x, key); | |
| /** @type {boolean} */ | |
| var val = 1 != this.g.a.length; | |
| X(this.w, val); | |
| V(this.j(), "show-as-one-card", this.Z && val); | |
| /** @type {number} */ | |
| var hasUtf = 0; | |
| /** @type {number} */ | |
| var $3 = 0; | |
| /** @type {boolean} */ | |
| var h = true; | |
| /** @type {!Array} */ | |
| this.h = []; | |
| Hq(this.b, function(c) { | |
| var t = c.update(a, v, x, key); | |
| /** @type {number} */ | |
| hasUtf = hasUtf | t; | |
| if (t) { | |
| if (h) { | |
| /** @type {boolean} */ | |
| h = false; | |
| } else { | |
| if (!c.Gi) { | |
| c.setVisible(false); | |
| this.h.push(c); | |
| } | |
| } | |
| } | |
| }, this); | |
| Uu(this, this.b); | |
| /** @type {boolean} */ | |
| val = 0 < this.h.length; | |
| X(this.m, val); | |
| Hq(this.c, function(client) { | |
| /** @type {number} */ | |
| $3 = $3 | client.update(a, v, x, key); | |
| }, this); | |
| var value = hasUtf || $3; | |
| this.setVisible(value); | |
| this.C.update(a, v, x, key); | |
| if (value) { | |
| var obj = {}; | |
| var valueProgess = this.F; | |
| Hq(this.b, function(state) { | |
| if (state.isVisible()) { | |
| Kl(valueProgess, state.ie(), state.sb(), state.Bc); | |
| /** @type {string} */ | |
| obj[state.Tb()] = state.Bc ? "e" : "ne"; | |
| } | |
| }); | |
| Hq(this.c, function(state) { | |
| if (state.isVisible()) { | |
| Kl(valueProgess, state.ie(), state.sb(), state.Bc); | |
| /** @type {string} */ | |
| obj[state.Tb()] = state.Bc ? "e" : "ne"; | |
| } | |
| }); | |
| /** @type {string} */ | |
| obj[this.Tb()] = val ? "e" : "ne"; | |
| this.log("show", obj); | |
| Kl(this.F, 15, Iq(this.b), true); | |
| } | |
| return value; | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @param {string} value | |
| * @param {string} val | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| Su.prototype.W = function(type, value, val, a) { | |
| this.g.push(type, value, val, a); | |
| if (!this.isVisible()) { | |
| type = this.g; | |
| if (1 < type.a.length) { | |
| type.a.splice(type.a.length - 1); | |
| /** @type {number} */ | |
| type.b = type.a.length - 1; | |
| yt(type); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Function} receiver | |
| * @param {!Object} connection | |
| * @return {undefined} | |
| */ | |
| var Uu = function(receiver, connection) { | |
| /** @type {!Array} */ | |
| var c = []; | |
| Hq(connection, function(node) { | |
| if (node.isVisible() || tb(this.h, node)) { | |
| var e = node.Bf || node.text; | |
| if (tb(c, e)) { | |
| if (node.Zc) { | |
| H(node.Zc, node.dk); | |
| } | |
| } else { | |
| c.push(e); | |
| } | |
| } | |
| }, receiver); | |
| }; | |
| var Vu = { | |
| ji : { | |
| 1E3 : { | |
| other : "0K" | |
| }, | |
| 1E4 : { | |
| other : "00K" | |
| }, | |
| 1E5 : { | |
| other : "000K" | |
| }, | |
| 1E6 : { | |
| other : "0M" | |
| }, | |
| 1E7 : { | |
| other : "00M" | |
| }, | |
| 1E8 : { | |
| other : "000M" | |
| }, | |
| 1E9 : { | |
| other : "0B" | |
| }, | |
| 1E10 : { | |
| other : "00B" | |
| }, | |
| 1E11 : { | |
| other : "000B" | |
| }, | |
| 1E12 : { | |
| other : "0T" | |
| }, | |
| 1E13 : { | |
| other : "00T" | |
| }, | |
| 1E14 : { | |
| other : "000T" | |
| } | |
| }, | |
| Bk : { | |
| 1E3 : { | |
| other : "0 thousand" | |
| }, | |
| 1E4 : { | |
| other : "00 thousand" | |
| }, | |
| 1E5 : { | |
| other : "000 thousand" | |
| }, | |
| 1E6 : { | |
| other : "0 million" | |
| }, | |
| 1E7 : { | |
| other : "00 million" | |
| }, | |
| 1E8 : { | |
| other : "000 million" | |
| }, | |
| 1E9 : { | |
| other : "0 billion" | |
| }, | |
| 1E10 : { | |
| other : "00 billion" | |
| }, | |
| 1E11 : { | |
| other : "000 billion" | |
| }, | |
| 1E12 : { | |
| other : "0 trillion" | |
| }, | |
| 1E13 : { | |
| other : "00 trillion" | |
| }, | |
| 1E14 : { | |
| other : "000 trillion" | |
| } | |
| } | |
| }; | |
| var Wu = Vu; | |
| Wu = Vu; | |
| var Xu = { | |
| AED : [2, "dh", "\u062f.\u0625."], | |
| ALL : [0, "Lek", "Lek"], | |
| AUD : [2, "$", "AU$"], | |
| BDT : [2, "\u09f3", "Tk"], | |
| BGN : [2, "lev", "lev"], | |
| BRL : [2, "R$", "R$"], | |
| CAD : [2, "$", "C$"], | |
| CDF : [2, "FrCD", "CDF"], | |
| CHF : [2, "CHF", "CHF"], | |
| CLP : [0, "$", "CL$"], | |
| CNY : [2, "\u00a5", "RMB\u00a5"], | |
| COP : [32, "$", "COL$"], | |
| CRC : [0, "\u20a1", "CR\u20a1"], | |
| CZK : [50, "K\u010d", "K\u010d"], | |
| DKK : [50, "kr.", "kr."], | |
| DOP : [2, "RD$", "RD$"], | |
| EGP : [2, "\u00a3", "LE"], | |
| ETB : [2, "Birr", "Birr"], | |
| EUR : [2, "\u20ac", "\u20ac"], | |
| GBP : [2, "\u00a3", "GB\u00a3"], | |
| HKD : [2, "$", "HK$"], | |
| HRK : [2, "kn", "kn"], | |
| HUF : [34, "Ft", "Ft"], | |
| IDR : [0, "Rp", "Rp"], | |
| ILS : [34, "\u20aa", "IL\u20aa"], | |
| INR : [2, "\u20b9", "Rs"], | |
| IRR : [0, "Rial", "IRR"], | |
| ISK : [0, "kr", "kr"], | |
| JMD : [2, "$", "JA$"], | |
| JPY : [0, "\u00a5", "JP\u00a5"], | |
| KRW : [0, "\u20a9", "KR\u20a9"], | |
| LKR : [2, "Rs", "SLRs"], | |
| LTL : [2, "Lt", "Lt"], | |
| MNT : [0, "\u20ae", "MN\u20ae"], | |
| MVR : [2, "Rf", "MVR"], | |
| MXN : [2, "$", "Mex$"], | |
| MYR : [2, "RM", "RM"], | |
| NOK : [50, "kr", "NOkr"], | |
| PAB : [2, "B/.", "B/."], | |
| PEN : [2, "S/.", "S/."], | |
| PHP : [2, "\u20b1", "PHP"], | |
| PKR : [0, "Rs", "PKRs."], | |
| PLN : [50, "z\u0142", "z\u0142"], | |
| RON : [2, "RON", "RON"], | |
| RSD : [0, "din", "RSD"], | |
| RUB : [50, "\u20bd", "RUB"], | |
| SAR : [2, "Rial", "Rial"], | |
| SEK : [50, "kr", "kr"], | |
| SGD : [2, "$", "S$"], | |
| THB : [2, "\u0e3f", "THB"], | |
| TRY : [2, "\u20ba", "TRY"], | |
| TWD : [2, "NT$", "NT$"], | |
| TZS : [0, "TSh", "TSh"], | |
| UAH : [2, "\u0433\u0440\u043d.", "UAH"], | |
| USD : [2, "$", "US$"], | |
| UYU : [2, "$", "$U"], | |
| VND : [48, "\u20ab", "VN\u20ab"], | |
| YER : [0, "Rial", "Rial"], | |
| ZAR : [2, "R", "ZAR"] | |
| }; | |
| var Yu = { | |
| Ek : ".", | |
| ni : ",", | |
| Ok : "%", | |
| Fi : "0", | |
| Rk : "+", | |
| wi : "-", | |
| Ik : "E", | |
| Qk : "\u2030", | |
| Lk : "\u221e", | |
| Nk : "NaN", | |
| ki : "#,##0.###", | |
| Sk : "#E0", | |
| Pk : "#,##0%", | |
| Ck : "\u00a4#,##0.00", | |
| Kg : "USD" | |
| }; | |
| var Zu = Yu; | |
| Zu = Yu; | |
| /** | |
| * @param {string} body | |
| * @return {undefined} | |
| */ | |
| var bv = function(body) { | |
| /** @type {number} */ | |
| this.m = 40; | |
| /** @type {number} */ | |
| this.a = 1; | |
| /** @type {number} */ | |
| this.L = 0; | |
| /** @type {number} */ | |
| this.b = 3; | |
| /** @type {number} */ | |
| this.w = this.c = 0; | |
| /** @type {boolean} */ | |
| this.W = false; | |
| /** @type {string} */ | |
| this.O = this.Ga = ""; | |
| this.G = Zu.wi; | |
| /** @type {string} */ | |
| this.C = ""; | |
| /** @type {number} */ | |
| this.g = 1; | |
| /** @type {boolean} */ | |
| this.o = false; | |
| /** @type {!Array} */ | |
| this.h = []; | |
| /** @type {boolean} */ | |
| this.K = this.T = false; | |
| /** @type {number} */ | |
| this.R = 0; | |
| if ("number" == typeof body) { | |
| switch(body) { | |
| case 1: | |
| $u(this, Zu.ki); | |
| break; | |
| case 2: | |
| $u(this, Zu.Sk); | |
| break; | |
| case 3: | |
| $u(this, Zu.Pk); | |
| break; | |
| case 4: | |
| body = Zu.Ck; | |
| /** @type {!Array} */ | |
| var outChance = ["0"]; | |
| /** @type {number} */ | |
| var dLn = Xu[Zu.Kg][0] & 7; | |
| if (0 < dLn) { | |
| outChance.push("."); | |
| /** @type {number} */ | |
| var d = 0; | |
| for (; d < dLn; d++) { | |
| outChance.push("0"); | |
| } | |
| } | |
| body = body.replace(/0.00/g, outChance.join("")); | |
| $u(this, body); | |
| break; | |
| case 5: | |
| av(this, 1); | |
| break; | |
| case 6: | |
| av(this, 2); | |
| break; | |
| default: | |
| throw Error("Unsupported pattern type."); | |
| } | |
| } else { | |
| $u(this, body); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @param {string} text | |
| * @return {undefined} | |
| */ | |
| var $u = function(item, text) { | |
| text.replace(/ /g, "\u00a0"); | |
| /** @type {!Array} */ | |
| var pos = [0]; | |
| item.Ga = cv(item, text, pos); | |
| var x = pos[0]; | |
| /** @type {number} */ | |
| var j = -1; | |
| /** @type {number} */ | |
| var i = 0; | |
| /** @type {number} */ | |
| var l = 0; | |
| /** @type {number} */ | |
| var n = 0; | |
| /** @type {number} */ | |
| var m = -1; | |
| var len = text.length; | |
| /** @type {boolean} */ | |
| var sorted = true; | |
| for (; pos[0] < len && sorted; pos[0]++) { | |
| switch(text.charAt(pos[0])) { | |
| case "#": | |
| if (0 < l) { | |
| n++; | |
| } else { | |
| i++; | |
| } | |
| if (0 <= m && 0 > j) { | |
| m++; | |
| } | |
| break; | |
| case "0": | |
| if (0 < n) { | |
| throw Error('Unexpected "0" in pattern "' + text + '"'); | |
| } | |
| l++; | |
| if (0 <= m && 0 > j) { | |
| m++; | |
| } | |
| break; | |
| case ",": | |
| if (0 < m) { | |
| item.h.push(m); | |
| } | |
| /** @type {number} */ | |
| m = 0; | |
| break; | |
| case ".": | |
| if (0 <= j) { | |
| throw Error('Multiple decimal separators in pattern "' + text + '"'); | |
| } | |
| /** @type {number} */ | |
| j = i + l + n; | |
| break; | |
| case "E": | |
| if (item.K) { | |
| throw Error('Multiple exponential symbols in pattern "' + text + '"'); | |
| } | |
| /** @type {boolean} */ | |
| item.K = true; | |
| /** @type {number} */ | |
| item.w = 0; | |
| if (pos[0] + 1 < len && "+" == text.charAt(pos[0] + 1)) { | |
| pos[0]++; | |
| /** @type {boolean} */ | |
| item.W = true; | |
| } | |
| for (; pos[0] + 1 < len && "0" == text.charAt(pos[0] + 1);) { | |
| pos[0]++; | |
| item.w++; | |
| } | |
| if (1 > i + l || 1 > item.w) { | |
| throw Error('Malformed exponential pattern "' + text + '"'); | |
| } | |
| /** @type {boolean} */ | |
| sorted = false; | |
| break; | |
| default: | |
| pos[0]--; | |
| /** @type {boolean} */ | |
| sorted = false; | |
| } | |
| } | |
| if (0 == l && 0 < i && 0 <= j) { | |
| /** @type {number} */ | |
| l = j; | |
| if (0 == l) { | |
| l++; | |
| } | |
| /** @type {number} */ | |
| n = i - l; | |
| /** @type {number} */ | |
| i = l - 1; | |
| /** @type {number} */ | |
| l = 1; | |
| } | |
| if (0 > j && 0 < n || 0 <= j && (j < i || j > i + l) || 0 == m) { | |
| throw Error('Malformed pattern "' + text + '"'); | |
| } | |
| /** @type {number} */ | |
| n = i + l + n; | |
| /** @type {number} */ | |
| item.b = 0 <= j ? n - j : 0; | |
| if (0 <= j) { | |
| /** @type {number} */ | |
| item.c = i + l - j; | |
| if (0 > item.c) { | |
| /** @type {number} */ | |
| item.c = 0; | |
| } | |
| } | |
| /** @type {number} */ | |
| item.a = (0 <= j ? j : n) - i; | |
| if (item.K) { | |
| /** @type {number} */ | |
| item.m = i + item.a; | |
| if (0 == item.b && 0 == item.a) { | |
| /** @type {number} */ | |
| item.a = 1; | |
| } | |
| } | |
| item.h.push(Math.max(0, m)); | |
| /** @type {boolean} */ | |
| item.T = 0 == j || j == n; | |
| /** @type {number} */ | |
| x = pos[0] - x; | |
| item.O = cv(item, text, pos); | |
| if (pos[0] < text.length && ";" == text.charAt(pos[0])) { | |
| pos[0]++; | |
| if (1 != item.g) { | |
| /** @type {boolean} */ | |
| item.o = true; | |
| } | |
| item.G = cv(item, text, pos); | |
| pos[0] += x; | |
| item.C = cv(item, text, pos); | |
| } else { | |
| item.G += item.Ga; | |
| item.C += item.O; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @param {number} next | |
| * @return {undefined} | |
| */ | |
| var av = function(node, next) { | |
| /** @type {number} */ | |
| node.R = next; | |
| $u(node, Zu.ki); | |
| /** @type {number} */ | |
| node.c = 0; | |
| /** @type {number} */ | |
| node.b = 2; | |
| if (0 < node.c) { | |
| throw Error("Can't combine significant digits and minimum fraction digits"); | |
| } | |
| /** @type {number} */ | |
| node.L = 2; | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @param {number} s | |
| * @return {?} | |
| */ | |
| var kv = function(o, s) { | |
| if (isNaN(s)) { | |
| return Zu.Nk; | |
| } | |
| /** @type {!Array} */ | |
| var res = []; | |
| /** @type {number} */ | |
| var v = s; | |
| /** @type {number} */ | |
| var i = s; | |
| if (0 == o.R) { | |
| var content = dv; | |
| } else { | |
| /** @type {number} */ | |
| v = Math.abs(v); | |
| /** @type {number} */ | |
| i = Math.abs(i); | |
| content = ev(o, 1 >= v ? 0 : fv(v)).Xg; | |
| i = gv(i, -content); | |
| hv(o, i); | |
| v = gv(v, -content); | |
| v = hv(o, v); | |
| content = ev(o, content + fv(v.vj)); | |
| } | |
| s = gv(s, -content.Xg); | |
| res.push(content.prefix); | |
| /** @type {boolean} */ | |
| v = 0 > s || 0 == s && 0 > 1 / s; | |
| res.push(v ? o.G : o.Ga); | |
| if (isFinite(s)) { | |
| if (s = s * (v ? -1 : 1) * o.g, o.K) { | |
| if (0 == s) { | |
| iv(o, s, o.a, res); | |
| jv(o, 0, res); | |
| } else { | |
| /** @type {number} */ | |
| i = Math.log(s) / Math.log(10); | |
| z(!q(void 0) || false); | |
| /** @type {number} */ | |
| i = Math.floor(i + 2E-15); | |
| s = gv(s, -i); | |
| var j = o.a; | |
| if (1 < o.m && o.m > o.a) { | |
| /** @type {number} */ | |
| j = i % o.m; | |
| if (0 > j) { | |
| j = o.m + j; | |
| } | |
| s = gv(s, j); | |
| /** @type {number} */ | |
| i = i - j; | |
| /** @type {number} */ | |
| j = 1; | |
| } else { | |
| if (1 > o.a) { | |
| i++; | |
| s = gv(s, -1); | |
| } else { | |
| /** @type {number} */ | |
| i = i - (o.a - 1); | |
| s = gv(s, o.a - 1); | |
| } | |
| } | |
| iv(o, s, j, res); | |
| jv(o, i, res); | |
| } | |
| } else { | |
| iv(o, s, o.a, res); | |
| } | |
| } else { | |
| res.push(Zu.Lk); | |
| } | |
| res.push(v ? o.C : o.O); | |
| res.push(content.Yj); | |
| return res.join(""); | |
| }; | |
| /** | |
| * @param {number} f | |
| * @param {number} val | |
| * @return {?} | |
| */ | |
| var hv = function(f, val) { | |
| var width = gv(val, f.b); | |
| if (0 < f.L) { | |
| width = lv(width, f.L, f.b); | |
| } | |
| /** @type {number} */ | |
| width = Math.round(width); | |
| if (isFinite(width)) { | |
| /** @type {number} */ | |
| val = Math.floor(gv(width, -f.b)); | |
| /** @type {number} */ | |
| f = Math.floor(width - gv(val, f.b)); | |
| } else { | |
| /** @type {number} */ | |
| f = 0; | |
| } | |
| return { | |
| vj : val, | |
| Yl : f | |
| }; | |
| }; | |
| /** | |
| * @param {!Object} v | |
| * @param {number} d | |
| * @param {number} i | |
| * @param {!Array} value | |
| * @return {undefined} | |
| */ | |
| var iv = function(v, d, i, value) { | |
| if (v.c > v.b) { | |
| throw Error("Min value must be less than max value"); | |
| } | |
| if (!value) { | |
| /** @type {!Array} */ | |
| value = []; | |
| } | |
| d = hv(v, d); | |
| var k = d.vj; | |
| var result = d.Yl; | |
| /** @type {boolean} */ | |
| var c = 0 < v.c || 0 < result || false; | |
| d = v.c; | |
| if (c) { | |
| d = v.c; | |
| } | |
| /** @type {string} */ | |
| var b = ""; | |
| var y = k; | |
| for (; 1E20 < y;) { | |
| /** @type {string} */ | |
| b = "0" + b; | |
| /** @type {number} */ | |
| y = Math.round(gv(y, -1)); | |
| } | |
| /** @type {string} */ | |
| b = y + b; | |
| var str = Zu.Ek; | |
| y = Zu.Fi.charCodeAt(0); | |
| /** @type {number} */ | |
| var j = b.length; | |
| /** @type {number} */ | |
| var n = 0; | |
| if (0 < k || 0 < i) { | |
| /** @type {number} */ | |
| k = j; | |
| for (; k < i; k++) { | |
| value.push(String.fromCharCode(y)); | |
| } | |
| if (2 <= v.h.length) { | |
| /** @type {number} */ | |
| i = 1; | |
| for (; i < v.h.length; i++) { | |
| n = n + v.h[i]; | |
| } | |
| } | |
| /** @type {number} */ | |
| i = j - n; | |
| if (0 < i) { | |
| k = v.h; | |
| /** @type {number} */ | |
| n = j = 0; | |
| var x; | |
| var l = Zu.ni; | |
| /** @type {number} */ | |
| var w = b.length; | |
| /** @type {number} */ | |
| var m = 0; | |
| for (; m < w; m++) { | |
| if (value.push(String.fromCharCode(y + 1 * Number(b.charAt(m)))), 1 < w - m) { | |
| if (x = k[n], m < i) { | |
| /** @type {number} */ | |
| var y = i - m; | |
| if (1 === x || 0 < x && 1 === y % x) { | |
| value.push(l); | |
| } | |
| } else { | |
| if (n < k.length) { | |
| if (m === i) { | |
| /** @type {number} */ | |
| n = n + 1; | |
| } else { | |
| if (x === m - i - j + 1) { | |
| value.push(l); | |
| j = j + x; | |
| /** @type {number} */ | |
| n = n + 1; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } else { | |
| /** @type {string} */ | |
| i = b; | |
| b = v.h; | |
| k = Zu.ni; | |
| /** @type {number} */ | |
| x = i.length; | |
| /** @type {!Array} */ | |
| l = []; | |
| /** @type {number} */ | |
| j = b.length - 1; | |
| for (; 0 <= j && 0 < x; j--) { | |
| n = b[j]; | |
| /** @type {number} */ | |
| w = 0; | |
| for (; w < n && 0 <= x - w - 1; w++) { | |
| l.push(String.fromCharCode(y + 1 * Number(i.charAt(x - w - 1)))); | |
| } | |
| /** @type {number} */ | |
| x = x - n; | |
| if (0 < x) { | |
| l.push(k); | |
| } | |
| } | |
| value.push.apply(value, l.reverse()); | |
| } | |
| } else { | |
| if (!c) { | |
| value.push(String.fromCharCode(y)); | |
| } | |
| } | |
| if (v.T || c) { | |
| value.push(str); | |
| } | |
| /** @type {string} */ | |
| result = String(result); | |
| /** @type {!Array<string>} */ | |
| c = result.split("e+"); | |
| if (2 == c.length) { | |
| /** @type {string} */ | |
| result = String(lv(parseFloat(c[0]), v.L, 1)); | |
| /** @type {string} */ | |
| result = result.replace(".", ""); | |
| result = result + le("0", parseInt(c[1], 10) - result.length + 1); | |
| } | |
| if (v.b + 1 > result.length) { | |
| result = "1" + le("0", v.b - result.length) + result; | |
| } | |
| v = result.length; | |
| for (; "0" == result.charAt(v - 1) && v > d + 1;) { | |
| v--; | |
| } | |
| /** @type {number} */ | |
| k = 1; | |
| for (; k < v; k++) { | |
| value.push(String.fromCharCode(y + 1 * Number(result.charAt(k)))); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} f | |
| * @param {number} a | |
| * @param {!Array} item | |
| * @return {undefined} | |
| */ | |
| var jv = function(f, a, item) { | |
| item.push(Zu.Ik); | |
| if (0 > a) { | |
| /** @type {number} */ | |
| a = -a; | |
| item.push(Zu.wi); | |
| } else { | |
| if (f.W) { | |
| item.push(Zu.Rk); | |
| } | |
| } | |
| /** @type {string} */ | |
| a = "" + a; | |
| var d = Zu.Fi; | |
| /** @type {number} */ | |
| var i = a.length; | |
| for (; i < f.w; i++) { | |
| item.push(d); | |
| } | |
| item.push(a); | |
| }; | |
| /** | |
| * @param {!Object} params | |
| * @param {string} value | |
| * @param {!Object} context | |
| * @return {?} | |
| */ | |
| var cv = function(params, value, context) { | |
| /** @type {string} */ | |
| var pix_color = ""; | |
| /** @type {boolean} */ | |
| var enabled = false; | |
| var valueLength = value.length; | |
| for (; context[0] < valueLength; context[0]++) { | |
| var pix_base = value.charAt(context[0]); | |
| if ("'" == pix_base) { | |
| if (context[0] + 1 < valueLength && "'" == value.charAt(context[0] + 1)) { | |
| context[0]++; | |
| /** @type {string} */ | |
| pix_color = pix_color + "'"; | |
| } else { | |
| /** @type {boolean} */ | |
| enabled = !enabled; | |
| } | |
| } else { | |
| if (enabled) { | |
| /** @type {string} */ | |
| pix_color = pix_color + pix_base; | |
| } else { | |
| switch(pix_base) { | |
| case "#": | |
| case "0": | |
| case ",": | |
| case ".": | |
| case ";": | |
| return pix_color; | |
| case "\u00a4": | |
| if (context[0] + 1 < valueLength && "\u00a4" == value.charAt(context[0] + 1)) { | |
| context[0]++; | |
| /** @type {string} */ | |
| pix_color = pix_color + Zu.Kg; | |
| } else { | |
| pix_color = pix_color + Xu[Zu.Kg][1]; | |
| } | |
| break; | |
| case "%": | |
| if (!params.o && 1 != params.g) { | |
| throw Error("Too many percent/permill"); | |
| } | |
| if (params.o && 100 != params.g) { | |
| throw Error("Inconsistent use of percent/permill characters"); | |
| } | |
| /** @type {number} */ | |
| params.g = 100; | |
| /** @type {boolean} */ | |
| params.o = false; | |
| /** @type {string} */ | |
| pix_color = pix_color + Zu.Ok; | |
| break; | |
| case "\u2030": | |
| if (!params.o && 1 != params.g) { | |
| throw Error("Too many percent/permill"); | |
| } | |
| if (params.o && 1E3 != params.g) { | |
| throw Error("Inconsistent use of percent/permill characters"); | |
| } | |
| /** @type {number} */ | |
| params.g = 1E3; | |
| /** @type {boolean} */ | |
| params.o = false; | |
| /** @type {string} */ | |
| pix_color = pix_color + Zu.Qk; | |
| break; | |
| default: | |
| /** @type {string} */ | |
| pix_color = pix_color + pix_base; | |
| } | |
| } | |
| } | |
| } | |
| return pix_color; | |
| }; | |
| var dv = { | |
| prefix : "", | |
| Yj : "", | |
| Xg : 0 | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @param {number} i | |
| * @return {?} | |
| */ | |
| var ev = function(data, i) { | |
| data = 1 == data.R ? Wu.ji : Wu.Bk; | |
| if (null == data) { | |
| data = Wu.ji; | |
| } | |
| if (3 > i) { | |
| return dv; | |
| } | |
| /** @type {number} */ | |
| i = Math.min(14, i); | |
| var val = data[gv(1, i)]; | |
| --i; | |
| for (; !val && 3 <= i;) { | |
| val = data[gv(1, i)]; | |
| i--; | |
| } | |
| if (!val) { | |
| return dv; | |
| } | |
| data = val.other; | |
| return data && "0" != data ? (data = /([^0]*)(0+)(.*)/.exec(data)) ? { | |
| prefix : data[1], | |
| Yj : data[3], | |
| Xg : i + 1 - (data[2].length - 1) | |
| } : dv : dv; | |
| }; | |
| /** | |
| * @param {number} y | |
| * @return {?} | |
| */ | |
| var fv = function(y) { | |
| if (!isFinite(y)) { | |
| return 0 < y ? y : 0; | |
| } | |
| /** @type {number} */ | |
| var fv2 = 0; | |
| for (; 1 <= (y = y / 10);) { | |
| fv2++; | |
| } | |
| return fv2; | |
| }; | |
| /** | |
| * @param {number} value | |
| * @param {number} id | |
| * @return {?} | |
| */ | |
| var gv = function(value, id) { | |
| z(0 == id % 1, 'Cannot shift by fractional digits "%s".', id); | |
| if (!value || !isFinite(value) || 0 == id) { | |
| return value; | |
| } | |
| /** @type {!Array<string>} */ | |
| value = String(value).split("e"); | |
| return parseFloat(value[0] + "e" + (parseInt(value[1] || 0, 10) + id)); | |
| }; | |
| /** | |
| * @param {number} value | |
| * @param {number} to | |
| * @return {?} | |
| */ | |
| var mv = function(value, to) { | |
| z(0 == to % 1, 'Cannot round to fractional digits "%s".', to); | |
| return value && isFinite(value) ? gv(Math.round(gv(value, to)), -to) : value; | |
| }; | |
| /** | |
| * @param {number} dx | |
| * @param {number} dy | |
| * @param {number} accountForTranslation | |
| * @return {?} | |
| */ | |
| var lv = function(dx, dy, accountForTranslation) { | |
| if (!dx) { | |
| return dx; | |
| } | |
| /** @type {number} */ | |
| dy = dy - fv(dx) - 1; | |
| return dy < -accountForTranslation ? mv(dx, -accountForTranslation) : mv(dx, dy); | |
| }; | |
| /** | |
| * @param {number} h | |
| * @param {number} s | |
| * @param {number} c | |
| * @return {undefined} | |
| */ | |
| var nv = function(h, s, c) { | |
| zq.call(this); | |
| /** @type {number} */ | |
| this.h = h; | |
| /** @type {number} */ | |
| this.b = s; | |
| /** @type {number} */ | |
| this.c = c; | |
| this.g = new bv("######"); | |
| }; | |
| x(nv, zq); | |
| /** | |
| * @param {!Object} table | |
| * @return {?} | |
| */ | |
| nv.prototype.jd = function(table) { | |
| return table && "DIV" == table.tagName && E("cc-ctr", table) && E("cc-msg", table) ? true : false; | |
| }; | |
| /** | |
| * @param {!Object} res | |
| * @return {undefined} | |
| */ | |
| var qv = function(res) { | |
| ov(res, false); | |
| pv(res, 0); | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @param {number} x | |
| * @return {undefined} | |
| */ | |
| var pv = function(options, x) { | |
| x = kv(options.g, x); | |
| var p = kv(options.g, options.h); | |
| H(E("cc-ctr", options.j()), x + "/" + p); | |
| }; | |
| /** | |
| * @param {!Object} col | |
| * @param {boolean} a | |
| * @return {undefined} | |
| */ | |
| var ov = function(col, a) { | |
| if (a) { | |
| var title = E("cc-ctr", col.j()); | |
| var j = col.c; | |
| U(title, col.b); | |
| T(title, j); | |
| } else { | |
| title = E("cc-ctr", col.j()); | |
| j = col.b; | |
| U(title, col.c); | |
| T(title, j); | |
| } | |
| X(E("cc-msg", col.j()), a); | |
| }; | |
| /** | |
| * @param {string} options | |
| * @param {string} callback | |
| * @return {undefined} | |
| */ | |
| var rv = function(options, callback) { | |
| hg.call(this); | |
| /** @type {number} */ | |
| this.c = this.b = 0; | |
| /** @type {string} */ | |
| this.Hc = options; | |
| /** @type {string} */ | |
| this.g = callback; | |
| this.a = new Dr(v(this.fm, this), 0, this); | |
| }; | |
| x(rv, hg); | |
| k = rv.prototype; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.X = function() { | |
| this.a.Qa(); | |
| delete this.Hc; | |
| delete this.g; | |
| rv.D.X.call(this); | |
| }; | |
| /** | |
| * @param {number} position | |
| * @param {number} speed | |
| * @return {undefined} | |
| */ | |
| k.start = function(position, speed) { | |
| this.stop(); | |
| speed = speed || 0; | |
| /** @type {number} */ | |
| this.b = Math.max(position || 0, 0); | |
| this.c = 0 > speed ? -1 : Ua() + speed; | |
| this.a.start(0 > speed ? this.b : Math.min(this.b, speed)); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.stop = function() { | |
| this.a.stop(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.tb = function() { | |
| return this.a.tb(); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.fm = function() { | |
| if (!this.Hc.call(this.g)) { | |
| if (0 > this.c) { | |
| this.a.start(this.b); | |
| } else { | |
| /** @type {number} */ | |
| var timeLeft = this.c - Ua(); | |
| if (!(0 >= timeLeft)) { | |
| this.a.start(Math.min(this.b, timeLeft)); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {number} d | |
| * @return {undefined} | |
| */ | |
| var tv = function(d) { | |
| L.call(this); | |
| /** @type {number} */ | |
| this.v = d; | |
| this.a = this.v.value; | |
| this.b = new rq(this); | |
| this.g = Ua(); | |
| if (sv) { | |
| this.b.M(d, "paste", this.ge); | |
| } else { | |
| this.b.M(d, ["keydown", "blur", "focus", "mouseover", "input"], this.ym); | |
| } | |
| this.c = new rv(v(this.Pi, this)); | |
| }; | |
| x(tv, L); | |
| var sv = C.Ka || C.V || C.vb || C.Ja && C.Ea("1.9"); | |
| k = tv.prototype; | |
| /** @type {string} */ | |
| k.Fc = "init"; | |
| k.F = wi("goog.events.PasteHandler"); | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.X = function() { | |
| tv.D.X.call(this); | |
| this.b.Qa(); | |
| /** @type {null} */ | |
| this.b = null; | |
| this.c.Qa(); | |
| /** @type {null} */ | |
| this.c = null; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Pi = function() { | |
| if (this.a == this.v.value) { | |
| return false; | |
| } | |
| zi(this.F, "detected textchange after paste"); | |
| this.dispatchEvent("after_paste"); | |
| return true; | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @return {undefined} | |
| */ | |
| k.ge = function(e) { | |
| e = new tg(e.b); | |
| /** @type {string} */ | |
| e.type = "paste"; | |
| this.dispatchEvent(e); | |
| ci(function() { | |
| if (!this.Pi()) { | |
| this.c.start(50, 200); | |
| } | |
| }, 0, this); | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @return {undefined} | |
| */ | |
| k.ym = function(e) { | |
| switch(this.Fc) { | |
| case "init": | |
| switch(e.type) { | |
| case "blur": | |
| /** @type {string} */ | |
| this.Fc = "init"; | |
| break; | |
| case "focus": | |
| /** @type {string} */ | |
| this.Fc = "focused"; | |
| break; | |
| case "mouseover": | |
| /** @type {string} */ | |
| this.Fc = "init"; | |
| if (this.v.value != this.a) { | |
| zi(this.F, "paste by dragdrop while on init!"); | |
| this.ge(e); | |
| } | |
| break; | |
| default: | |
| xi(this.F, "unexpected event " + e.type + "during init"); | |
| }break; | |
| case "focused": | |
| switch(e.type) { | |
| case "input": | |
| var b = this.g + 400; | |
| if (Ua() > b || "focus" == this.h) { | |
| zi(this.F, "paste by textchange while focused!"); | |
| this.ge(e); | |
| } | |
| break; | |
| case "blur": | |
| /** @type {string} */ | |
| this.Fc = "init"; | |
| break; | |
| case "keydown": | |
| zi(this.F, "key down ... looking for ctrl+v"); | |
| if (C.yb && C.cb && 0 == e.keyCode || C.yb && C.cb && 17 == e.keyCode) { | |
| break; | |
| } | |
| /** @type {string} */ | |
| this.Fc = "typing"; | |
| break; | |
| case "mouseover": | |
| if (this.v.value != this.a) { | |
| zi(this.F, "paste by dragdrop while focused!"); | |
| this.ge(e); | |
| } | |
| break; | |
| default: | |
| xi(this.F, "unexpected event " + e.type + " during focused"); | |
| }break; | |
| case "typing": | |
| switch(e.type) { | |
| case "input": | |
| /** @type {string} */ | |
| this.Fc = "focused"; | |
| break; | |
| case "blur": | |
| /** @type {string} */ | |
| this.Fc = "init"; | |
| break; | |
| case "keydown": | |
| if (e.ctrlKey && 86 == e.keyCode || e.shiftKey && 45 == e.keyCode || e.metaKey && 86 == e.keyCode) { | |
| zi(this.F, "paste by ctrl+v while keypressed!"); | |
| this.ge(e); | |
| } | |
| break; | |
| case "mouseover": | |
| if (this.v.value != this.a) { | |
| zi(this.F, "paste by dragdrop while keypressed!"); | |
| this.ge(e); | |
| } | |
| break; | |
| default: | |
| xi(this.F, "unexpected event " + e.type + " during keypressed"); | |
| }break; | |
| default: | |
| xi(this.F, "invalid " + this.Fc + " state"); | |
| } | |
| this.g = Ua(); | |
| this.a = this.v.value; | |
| zi(this.F, e.type + " -> " + this.Fc); | |
| this.h = e.type; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var uv = function() { | |
| }; | |
| x(uv, Uq); | |
| Ia(uv); | |
| k = uv.prototype; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.nd = function() { | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @param {!Object} item | |
| * @return {?} | |
| */ | |
| k.eb = function(e, item) { | |
| nr(e, false); | |
| e.Mc &= -256; | |
| e.Sa(32, false); | |
| uv.D.eb.call(this, e, item); | |
| e.g(item.value); | |
| return item; | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @return {?} | |
| */ | |
| k.Eb = function(e) { | |
| nr(e, false); | |
| e.Mc &= -256; | |
| e.Sa(32, false); | |
| return e.a.b("TEXTAREA", { | |
| "class" : Xq(this, e).join(" "), | |
| disabled : !e.isEnabled() | |
| }, e.Ya() || ""); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| k.md = function(a) { | |
| return "TEXTAREA" == a.tagName; | |
| }; | |
| /** @type {function(): undefined} */ | |
| k.oh = Ha; | |
| /** | |
| * @param {?} toggler | |
| * @return {?} | |
| */ | |
| k.nh = function(toggler) { | |
| return toggler.isEnabled(); | |
| }; | |
| /** @type {function(): undefined} */ | |
| k.le = Ha; | |
| /** | |
| * @param {!Object} item | |
| * @param {number} file | |
| * @param {boolean} x | |
| * @return {undefined} | |
| */ | |
| k.Od = function(item, file, x) { | |
| uv.D.Od.call(this, item, file, x); | |
| if ((item = item.j()) && 1 == file) { | |
| /** @type {boolean} */ | |
| item.disabled = x; | |
| } | |
| }; | |
| /** @type {function(): undefined} */ | |
| k.uc = Ha; | |
| /** | |
| * @param {!HTMLElement} b | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| k.qc = function(b, a) { | |
| if (b) { | |
| /** @type {!Object} */ | |
| b.value = a; | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.za = function() { | |
| return "goog-textarea"; | |
| }; | |
| /** | |
| * @param {string} path | |
| * @param {!Array} x | |
| * @param {?} key | |
| * @return {undefined} | |
| */ | |
| var vv = function(path, x, key) { | |
| lr.call(this, path, x || uv.N(), key); | |
| nr(this, false); | |
| /** @type {boolean} */ | |
| this.xf = true; | |
| if (x = this.j()) { | |
| this.c.Yf(x, true); | |
| } | |
| /** @type {boolean} */ | |
| this.pe = "" != path; | |
| if (!path) { | |
| /** @type {string} */ | |
| this.pd = ""; | |
| } | |
| }; | |
| x(vv, lr); | |
| /** @type {boolean} */ | |
| var wv = !(C.V && !C.kb(11)); | |
| k = vv.prototype; | |
| /** @type {boolean} */ | |
| k.qe = false; | |
| /** @type {boolean} */ | |
| k.kg = false; | |
| /** @type {boolean} */ | |
| k.pe = false; | |
| /** @type {number} */ | |
| k.Uc = 0; | |
| /** @type {number} */ | |
| k.Ih = 0; | |
| /** @type {boolean} */ | |
| k.oj = false; | |
| /** @type {boolean} */ | |
| k.wg = false; | |
| /** @type {boolean} */ | |
| k.Qh = false; | |
| /** @type {boolean} */ | |
| k.Ph = false; | |
| /** @type {string} */ | |
| k.Td = ""; | |
| /** | |
| * @param {!Object} d | |
| * @return {?} | |
| */ | |
| var xv = function(d) { | |
| return d.m.top + d.m.bottom + d.Y.top + d.Y.bottom; | |
| }; | |
| /** | |
| * @param {!Object} d | |
| * @return {?} | |
| */ | |
| var yv = function(d) { | |
| var idx = d.Ih; | |
| var items = d.j(); | |
| if (idx && items && d.wg) { | |
| /** @type {number} */ | |
| idx = idx - xv(d); | |
| } | |
| return idx; | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| vv.prototype.b = function(name) { | |
| this.g(String(name)); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| vv.prototype.aa = function() { | |
| return this.j().value != this.Td || zv(this) || this.pe ? this.j().value : ""; | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| vv.prototype.g = function(name) { | |
| vv.D.g.call(this, name); | |
| /** @type {boolean} */ | |
| this.pe = "" != name; | |
| Av(this); | |
| }; | |
| /** | |
| * @param {boolean} v | |
| * @return {undefined} | |
| */ | |
| vv.prototype.sa = function(v) { | |
| vv.D.sa.call(this, v); | |
| /** @type {boolean} */ | |
| this.j().disabled = !v; | |
| }; | |
| /** | |
| * @param {!Object} exports | |
| * @return {undefined} | |
| */ | |
| var Av = function(exports) { | |
| if (exports.j()) { | |
| exports.O(); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} chunk | |
| * @return {?} | |
| */ | |
| var zv = function(chunk) { | |
| z(chunk.j()); | |
| return "placeholder" in chunk.j(); | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @return {undefined} | |
| */ | |
| var Bv = function(data) { | |
| if (data.Td) { | |
| if (zv(data)) { | |
| data.j().placeholder = data.Td; | |
| } else { | |
| if (!(!data.j() || data.pe || data.kg)) { | |
| T(z(data.j()), "textarea-placeholder-input"); | |
| data.j().value = data.Td; | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| vv.prototype.ia = function() { | |
| vv.D.ia.call(this); | |
| var x = this.j(); | |
| Hp(x, { | |
| overflowY : "hidden", | |
| overflowX : "auto", | |
| boxSizing : "border-box", | |
| MsBoxSizing : "border-box", | |
| WebkitBoxSizing : "border-box", | |
| MozBoxSizing : "border-box" | |
| }); | |
| this.m = nq(x); | |
| this.Y = Up(x); | |
| Y(this).M(x, "scroll", this.O).M(x, "focus", this.O).M(x, "keyup", this.O).M(x, "mouseup", this.hc).M(x, "blur", this.jb); | |
| Bv(this); | |
| Av(this); | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| var Cv = function(b) { | |
| if (!b.oj) { | |
| var m = b.j().cloneNode(false); | |
| Hp(m, { | |
| position : "absolute", | |
| height : "auto", | |
| top : "-9999px", | |
| margin : "0", | |
| padding : "1px", | |
| border : "1px solid #000", | |
| overflow : "hidden" | |
| }); | |
| Df(b.a.a.body, m); | |
| var pos = m.scrollHeight; | |
| /** @type {string} */ | |
| m.style.padding = "10px"; | |
| var i = m.scrollHeight; | |
| /** @type {boolean} */ | |
| b.Qh = i > pos; | |
| /** @type {string} */ | |
| m.style.borderWidth = "10px"; | |
| /** @type {boolean} */ | |
| b.Ph = m.scrollHeight > i; | |
| /** @type {string} */ | |
| m.style.height = "100px"; | |
| if (100 != m.offsetHeight) { | |
| /** @type {boolean} */ | |
| b.wg = true; | |
| } | |
| Jf(m); | |
| /** @type {boolean} */ | |
| b.oj = true; | |
| } | |
| m = b.j(); | |
| if (isNaN(b.m.top)) { | |
| b.m = nq(m); | |
| b.Y = Up(m); | |
| } | |
| pos = b.j().scrollHeight; | |
| var p = b.j(); | |
| /** @type {number} */ | |
| i = p.offsetHeight - p.clientHeight; | |
| if (!b.Qh) { | |
| var m = b.m; | |
| /** @type {number} */ | |
| i = i - (m.top + m.bottom); | |
| } | |
| if (!b.Ph) { | |
| p = Up(p); | |
| /** @type {number} */ | |
| i = i - (p.top + p.bottom); | |
| } | |
| pos = pos + (0 < i ? i : 0); | |
| if (b.wg) { | |
| /** @type {number} */ | |
| pos = pos - xv(b); | |
| } else { | |
| if (!b.Qh) { | |
| i = b.m; | |
| pos = pos + (i.top + i.bottom); | |
| } | |
| if (!b.Ph) { | |
| b = Up(m); | |
| pos = pos + (b.top + b.bottom); | |
| } | |
| } | |
| return pos; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {number} b | |
| * @return {undefined} | |
| */ | |
| var Dv = function(a, b) { | |
| if (a.Uc != b) { | |
| /** @type {number} */ | |
| a.Uc = b; | |
| /** @type {string} */ | |
| a.j().style.height = b + "px"; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} drop | |
| * @return {undefined} | |
| */ | |
| var Ev = function(drop) { | |
| var b = drop.j(); | |
| /** @type {string} */ | |
| b.style.height = "auto"; | |
| var expRecords = b.value.match(/\n/g) || []; | |
| b.rows = expRecords.length + 1; | |
| /** @type {number} */ | |
| drop.Uc = 0; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| vv.prototype.jb = function() { | |
| if (!zv(this)) { | |
| /** @type {boolean} */ | |
| this.kg = false; | |
| if ("" == this.j().value) { | |
| /** @type {boolean} */ | |
| this.pe = false; | |
| Bv(this); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| vv.prototype.O = function(type) { | |
| if (!this.qe) { | |
| var t = this.j(); | |
| if (!zv(this) && type && "focus" == type.type) { | |
| if (t.value == this.Td && this.Td && !this.kg) { | |
| U(t, "textarea-placeholder-input"); | |
| /** @type {string} */ | |
| t.value = ""; | |
| } | |
| /** @type {boolean} */ | |
| this.kg = true; | |
| /** @type {boolean} */ | |
| this.pe = "" != t.value; | |
| } | |
| /** @type {boolean} */ | |
| var rate = false; | |
| /** @type {boolean} */ | |
| this.qe = true; | |
| type = this.Uc; | |
| if (t.scrollHeight) { | |
| /** @type {boolean} */ | |
| var coordinates = false; | |
| /** @type {boolean} */ | |
| var y = false; | |
| var i = Cv(this); | |
| var f = t.offsetHeight; | |
| var groups = yv(this); | |
| /** @type {number} */ | |
| var e = 0; | |
| var isIE = this.j(); | |
| if (e && isIE && this.wg) { | |
| /** @type {number} */ | |
| e = e - xv(this); | |
| } | |
| if (groups && i < groups) { | |
| Dv(this, groups); | |
| /** @type {boolean} */ | |
| coordinates = true; | |
| } else { | |
| if (e && i > e) { | |
| Dv(this, e); | |
| /** @type {string} */ | |
| t.style.overflowY = ""; | |
| /** @type {boolean} */ | |
| y = true; | |
| } else { | |
| if (f != i) { | |
| Dv(this, i); | |
| } else { | |
| if (!this.Uc) { | |
| this.Uc = i; | |
| } | |
| } | |
| } | |
| } | |
| if (!(coordinates || y || !wv)) { | |
| /** @type {boolean} */ | |
| rate = true; | |
| } | |
| } else { | |
| Ev(this); | |
| } | |
| /** @type {boolean} */ | |
| this.qe = false; | |
| if (rate) { | |
| t = this.j(); | |
| if (!this.qe) { | |
| /** @type {boolean} */ | |
| this.qe = true; | |
| if (y = t.scrollHeight) { | |
| i = Cv(this); | |
| rate = yv(this); | |
| if (!(rate && i <= rate)) { | |
| coordinates = this.m; | |
| /** @type {string} */ | |
| t.style.paddingBottom = coordinates.bottom + 1 + "px"; | |
| if (Cv(this) == i) { | |
| /** @type {string} */ | |
| t.style.paddingBottom = coordinates.bottom + y + "px"; | |
| /** @type {number} */ | |
| t.scrollTop = 0; | |
| /** @type {number} */ | |
| y = Cv(this) - y; | |
| if (y >= rate) { | |
| Dv(this, y); | |
| } else { | |
| Dv(this, rate); | |
| } | |
| } | |
| /** @type {string} */ | |
| t.style.paddingBottom = coordinates.bottom + "px"; | |
| } | |
| } else { | |
| Ev(this); | |
| } | |
| /** @type {boolean} */ | |
| this.qe = false; | |
| } | |
| } | |
| if (type != this.Uc) { | |
| this.dispatchEvent("resize"); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| vv.prototype.hc = function() { | |
| var elem = this.j(); | |
| var top = elem.offsetHeight; | |
| if (elem.filters && elem.filters.length && (elem = elem.filters.item("DXImageTransform.Microsoft.DropShadow"))) { | |
| /** @type {number} */ | |
| top = top - elem.offX; | |
| } | |
| if (top != this.Uc) { | |
| this.Uc = this.Ih = top; | |
| } | |
| }; | |
| /** | |
| * @param {?} time | |
| * @param {?} extraStringData | |
| * @return {undefined} | |
| */ | |
| var Fv = function(time, extraStringData) { | |
| vv.call(this, time); | |
| /** @type {boolean} */ | |
| this.ic = !!extraStringData; | |
| /** @type {string} */ | |
| this.ra = ""; | |
| /** @type {null} */ | |
| this.Aa = null; | |
| /** @type {number} */ | |
| this.T = 0; | |
| /** @type {boolean} */ | |
| this.Z = this.ma = false; | |
| /** @type {null} */ | |
| this.Da = null; | |
| }; | |
| x(Fv, vv); | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| Fv.prototype.b = function(name) { | |
| Fv.D.b.call(this, name); | |
| this.W("set"); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Fv.prototype.ia = function() { | |
| Fv.D.ia.call(this); | |
| I(this.j(), "compositionstart", v(this.Hb, this), false, this); | |
| I(this.j(), "compositionend", v(this.Gb, this), false, this); | |
| this.Da = new Nq(this.j()); | |
| I(this.Da, "key", function(event) { | |
| Gv(this, "key", { | |
| keyCode : event.keyCode | |
| }); | |
| }, false, this); | |
| I(this.j(), "input", function() { | |
| Gv(this, "input"); | |
| }, false, this); | |
| I(new tv(this.j()), "paste", function() { | |
| /** @type {boolean} */ | |
| this.ma = true; | |
| Gv(this, "paste"); | |
| }, false, this); | |
| I(this.j(), "drop", function() { | |
| Gv(this, "drop"); | |
| }, false, this); | |
| this.Aa = new ai(1E3); | |
| I(this.Aa, "tick", function() { | |
| this.W("timer"); | |
| }, false, this); | |
| this.Aa.start(); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Fv.prototype.Hb = function() { | |
| /** @type {boolean} */ | |
| this.Z = true; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Fv.prototype.Gb = function() { | |
| /** @type {boolean} */ | |
| this.Z = false; | |
| Gv(this, "input"); | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @param {string} type | |
| * @param {?} attrs | |
| * @return {undefined} | |
| */ | |
| var Gv = function(value, type, attrs) { | |
| ci(v(value.W, value, type, attrs), 0, value); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @param {!Object} value | |
| * @return {undefined} | |
| */ | |
| Fv.prototype.W = function(name, value) { | |
| if (!this.Z) { | |
| if (this.ic && "key" == name && value && 13 == value.keyCode) { | |
| this.dispatchEvent("enter"); | |
| } else { | |
| var event = this.aa(); | |
| if ("" == event.trim() && event != this.ra) { | |
| this.dispatchEvent("clear"); | |
| } | |
| if (event != this.ra) { | |
| this.T += 1; | |
| this.ra = event; | |
| event = new kg("change"); | |
| if (this.ma) { | |
| /** @type {boolean} */ | |
| this.ma = false; | |
| /** @type {string} */ | |
| name = "paste"; | |
| } | |
| /** @type {string} */ | |
| event.fe = name; | |
| if (null != value) { | |
| Xb(event, value); | |
| } | |
| this.dispatchEvent(event); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {?} formatters | |
| * @return {?} | |
| */ | |
| var Hv = function(formatters) { | |
| return zc(formatters.aa()); | |
| }; | |
| /** | |
| * @param {?} animation | |
| * @return {?} | |
| */ | |
| var Iv = function(animation) { | |
| var t = animation.T; | |
| /** @type {number} */ | |
| animation.T = 0; | |
| return t; | |
| }; | |
| /** | |
| * @param {?} requestWaterMask | |
| * @param {!Object} f | |
| * @return {undefined} | |
| */ | |
| var Jv = function(requestWaterMask, f) { | |
| L.call(this); | |
| this.Jd = requestWaterMask; | |
| /** @type {!Array} */ | |
| this.a = []; | |
| if (null != f) { | |
| this.Vd(f); | |
| } | |
| }; | |
| x(Jv, L); | |
| /** | |
| * @param {!Object} obj | |
| * @param {?} val | |
| * @return {undefined} | |
| */ | |
| Jv.prototype.update = function(obj, val) { | |
| /** @type {number} */ | |
| var i = this.a.length = 0; | |
| for (; i < obj.length; ++i) { | |
| this.a.push(obj[i]); | |
| } | |
| this.dispatchEvent({ | |
| type : this.Jd, | |
| data : this.a, | |
| selected : null != val ? val : null | |
| }); | |
| }; | |
| /** | |
| * @param {number} endpoint | |
| * @param {?} consul | |
| * @return {undefined} | |
| */ | |
| var Kv = function(endpoint, consul) { | |
| L.call(this); | |
| /** @type {boolean} */ | |
| this.T = !!consul; | |
| /** @type {string} */ | |
| this.a = ""; | |
| /** @type {number} */ | |
| this.W = endpoint; | |
| /** @type {string} */ | |
| this.c = this.b = ""; | |
| this.L = new Jv("srcSuggestionUpdated", this); | |
| this.K = new Jv("staticSrcSuggestionUpdated", this); | |
| this.R = new Jv("staticTgtSuggestionUpdated", this); | |
| /** @type {!Array} */ | |
| this.Y = []; | |
| this.ra = new Jv("srcEmphasizeUpdated", this); | |
| this.Z = new Jv("tgtEmphasizeUpdated", this); | |
| /** @type {number} */ | |
| this.ea = this.oa = 0; | |
| /** @type {!Array} */ | |
| this.o = []; | |
| /** @type {!Array} */ | |
| this.m = []; | |
| /** @type {!Array} */ | |
| this.C = []; | |
| /** @type {!Array} */ | |
| this.O = []; | |
| /** @type {boolean} */ | |
| this.G = false; | |
| /** @type {string} */ | |
| this.w = ""; | |
| }; | |
| x(Kv, L); | |
| /** | |
| * @param {!Object} o | |
| * @param {string} level | |
| * @return {undefined} | |
| */ | |
| var Lv = function(o, level) { | |
| /** @type {!Array} */ | |
| var nodes = []; | |
| if (level) { | |
| var _ = "auto" == o.a ? o.c : o.a; | |
| /** @type {number} */ | |
| var commonIndex = -1; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < level.length; ++i) { | |
| if (level[i] == _) { | |
| if ("auto" != o.a) { | |
| /** @type {number} */ | |
| commonIndex = i; | |
| } | |
| } else { | |
| nodes.push(level[i]); | |
| } | |
| } | |
| /** @type {boolean} */ | |
| level = -1 != commonIndex && 3 > commonIndex; | |
| } else { | |
| /** @type {boolean} */ | |
| level = false; | |
| } | |
| if (!(level || o.G)) { | |
| o.L.update(nodes ? nodes.slice(0, 3) : []); | |
| } | |
| }; | |
| /** | |
| * @param {string} o | |
| * @return {undefined} | |
| */ | |
| var Nv = function(o) { | |
| var b = o.K; | |
| var c = o.a; | |
| o = Mv(o.C, o.o); | |
| b.update(o, c); | |
| }; | |
| /** | |
| * @param {!Object} p | |
| * @return {undefined} | |
| */ | |
| var Ov = function(p) { | |
| var q = p.R; | |
| var c = p.b; | |
| p = Mv(p.O, p.m); | |
| q.update(p, c); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @param {number} value | |
| * @return {undefined} | |
| */ | |
| Kv.prototype.g = function(name, value) { | |
| value = null != value ? value : 0; | |
| if (3 == value || 4 == value || 5 == value) { | |
| /** @type {boolean} */ | |
| this.G = true; | |
| } | |
| if (6 == value) { | |
| /** @type {string} */ | |
| this.w = name; | |
| } | |
| if ("zh-TW" == name) { | |
| /** @type {string} */ | |
| name = "zh-CN"; | |
| } | |
| if ("auto" != name) { | |
| Pv(this, ""); | |
| } | |
| if (this.a != name) { | |
| Qv(this, this.K, name, this.o); | |
| var f = this.a; | |
| /** @type {string} */ | |
| this.a = name; | |
| if (this.T) { | |
| Rv(this.a, this.o); | |
| } | |
| if (this.W && f != this.a) { | |
| this.W(kc(this.a) ? "rtl" : "ltr"); | |
| } | |
| name = "auto" == f ? void 0 : v(this.h, this, f, 6); | |
| /** @type {number} */ | |
| this.oa = value; | |
| Sv(this, this.a, "srcLanguageUpdated", value, name); | |
| } | |
| }; | |
| /** | |
| * @param {string} type | |
| * @param {number} value | |
| * @return {undefined} | |
| */ | |
| Kv.prototype.h = function(type, value) { | |
| value = null != value ? value : 0; | |
| if (!(6 != value && 5 != value || "zh-CN" != type || "zh-TW" != this.w)) { | |
| /** @type {string} */ | |
| type = "zh-TW"; | |
| } | |
| if (5 == value) { | |
| this.w = this.b; | |
| } | |
| Qv(this, this.R, type, this.m); | |
| if (this.b != type) { | |
| var b1 = this.b; | |
| /** @type {string} */ | |
| this.b = type; | |
| if (this.T) { | |
| Rv(this.b, this.m); | |
| } | |
| /** @type {number} */ | |
| this.ea = value; | |
| Sv(this, this.b, "tgtLanguageUpdated", value, v(this.g, this, b1, 6)); | |
| } | |
| }; | |
| /** | |
| * @param {number} data | |
| * @param {!Object} cell | |
| * @param {number} v | |
| * @param {string} path | |
| * @return {undefined} | |
| */ | |
| var Qv = function(data, cell, v, path) { | |
| var a = Ab(cell.a); | |
| /** @type {boolean} */ | |
| var i = "auto" != v; | |
| /** @type {number} */ | |
| var k = 0; | |
| for (; k < a.length; k++) { | |
| if (v == a[k]) { | |
| /** @type {boolean} */ | |
| i = false; | |
| break; | |
| } | |
| } | |
| if (data.T && "auto" != v) { | |
| k = a.length; | |
| /** @type {!Array<?>} */ | |
| path = a = [v].concat(path instanceof Array ? path : ca(ba(path)), a instanceof Array ? a : ca(ba(a))); | |
| data = {}; | |
| /** @type {number} */ | |
| var j = i = 0; | |
| for (; j < path.length;) { | |
| var key = path[j++]; | |
| var value = key; | |
| /** @type {string} */ | |
| value = Na(value) ? "o" + Qa(value) : (typeof value).charAt(0) + value; | |
| if (!Object.prototype.hasOwnProperty.call(data, value)) { | |
| /** @type {boolean} */ | |
| data[value] = true; | |
| path[i++] = key; | |
| } | |
| } | |
| /** @type {number} */ | |
| path.length = i; | |
| a.length = k; | |
| } else { | |
| if (i) { | |
| data = {}; | |
| if (0 < path.length) { | |
| /** @type {boolean} */ | |
| data[path[0]] = true; | |
| } | |
| if (1 < path.length) { | |
| /** @type {boolean} */ | |
| data[path[1]] = true; | |
| } | |
| /** @type {number} */ | |
| k = a.length - 1; | |
| for (; 0 <= k; k--) { | |
| if (!data[a[k]]) { | |
| /** @type {number} */ | |
| a[k] = v; | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| cell.update(a, v); | |
| }; | |
| /** | |
| * @param {!Object} me | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| var Pv = function(me, value) { | |
| if ("auto" == value) { | |
| /** @type {string} */ | |
| value = ""; | |
| } | |
| if (me.c != value) { | |
| /** @type {string} */ | |
| me.c = value; | |
| me.dispatchEvent({ | |
| type : "detectSrcUpdated", | |
| data : me.c | |
| }); | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Kv.prototype.ma = function() { | |
| return this.a; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Kv.prototype.Na = function() { | |
| return this.b; | |
| }; | |
| /** | |
| * @param {!Object} $this | |
| * @return {undefined} | |
| */ | |
| var Tv = function($this) { | |
| var dictEndThroughEnd = DATA.RecentLanguages.recent_sl; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < dictEndThroughEnd.length; ++i) { | |
| $this.o.push(dictEndThroughEnd[i]); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} stored | |
| * @return {undefined} | |
| */ | |
| var Uv = function(stored) { | |
| var dictEndThroughEnd = DATA.RecentLanguages.recent_tl; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < dictEndThroughEnd.length; ++i) { | |
| stored.m.push(dictEndThroughEnd[i]); | |
| } | |
| }; | |
| /** | |
| * @param {?} versions | |
| * @return {undefined} | |
| */ | |
| var Vv = function(versions) { | |
| /** @type {!Array} */ | |
| versions.C = []; | |
| /** @type {!Array} */ | |
| versions.O = []; | |
| var e = window.DEFAULT_SOURCES || []; | |
| var userlinks = window.DEFAULT_TARGETS || []; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < e.length; i++) { | |
| ub(versions.C, e[i]); | |
| } | |
| /** @type {number} */ | |
| e = 0; | |
| for (; e < userlinks.length; e++) { | |
| ub(versions.O, userlinks[e]); | |
| } | |
| }; | |
| /** | |
| * @param {!NodeList} locs | |
| * @return {?} | |
| */ | |
| var Wv = function(locs) { | |
| if (!locs || 0 == locs.length) { | |
| return ""; | |
| } | |
| /** @type {!Array} */ | |
| var b = []; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < locs.length; ++i) { | |
| b.push(locs[i]); | |
| } | |
| return b.join("|"); | |
| }; | |
| /** | |
| * @param {!Object} s | |
| * @param {!Object} index | |
| * @param {string} reason | |
| * @param {number} request | |
| * @param {string} ignore | |
| * @return {undefined} | |
| */ | |
| var Sv = function(s, index, reason, request, ignore) { | |
| s.dispatchEvent({ | |
| type : reason, | |
| data : index, | |
| Li : 6 == request | |
| }); | |
| if (ignore && (3 == request || 4 == request) && s.a == s.b && "zh-CN" != s.a) { | |
| ignore(); | |
| } | |
| if (!(4 != request && 3 != request)) { | |
| s.dispatchEvent("languageSelected"); | |
| } | |
| }; | |
| /** | |
| * @param {!NodeList} a | |
| * @param {?} v | |
| * @return {?} | |
| */ | |
| var Xv = function(a, v) { | |
| /** @type {!Array} */ | |
| var rgs = []; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < a.length && !(a[i] != v && rgs.push(a[i]), 3 <= rgs.length); ++i) { | |
| } | |
| return rgs; | |
| }; | |
| /** | |
| * @param {string} undefined | |
| * @param {!Array} opts | |
| * @return {undefined} | |
| */ | |
| var Rv = function(undefined, opts) { | |
| if ("auto" != undefined) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < opts.length && opts[i] != undefined; ++i) { | |
| } | |
| if (i == opts.length) { | |
| opts.unshift(undefined); | |
| if (10 < opts.length) { | |
| opts.pop(); | |
| } | |
| } else { | |
| opts.splice(i, 1); | |
| opts.unshift(undefined); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!NodeList} a | |
| * @param {!NodeList} b | |
| * @return {?} | |
| */ | |
| var Mv = function(a, b) { | |
| var cmp = {}; | |
| /** @type {!Array} */ | |
| var r = []; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < b.length && 3 > r.length; i++) { | |
| r.push(b[i]); | |
| /** @type {boolean} */ | |
| cmp[b[i]] = true; | |
| } | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < a.length && 3 > r.length; i++) { | |
| if (null == cmp[a[i]]) { | |
| /** @type {boolean} */ | |
| cmp[a[i]] = true; | |
| r.push(a[i]); | |
| } | |
| } | |
| return r; | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @param {number} add | |
| * @return {?} | |
| */ | |
| var aw = function(e, add) { | |
| /** @type {number} */ | |
| var end = 0; | |
| /** @type {number} */ | |
| var value = 0; | |
| if (Yv(e)) { | |
| end = e.selectionStart; | |
| value = add ? -1 : e.selectionEnd; | |
| } else { | |
| if (Zv()) { | |
| var start = $v(e); | |
| var range = start[0]; | |
| start = start[1]; | |
| if (range.inRange(start)) { | |
| range.setEndPoint("EndToStart", start); | |
| if ("textarea" == e.type) { | |
| e = start.duplicate(); | |
| var origText = range.text; | |
| end = origText; | |
| start = value = e.text; | |
| /** @type {boolean} */ | |
| var h = false; | |
| for (; !h;) { | |
| if (0 == range.compareEndPoints("StartToEnd", range)) { | |
| /** @type {boolean} */ | |
| h = true; | |
| } else { | |
| range.moveEnd("character", -1); | |
| if (range.text == origText) { | |
| /** @type {string} */ | |
| end = end + "\r\n"; | |
| } else { | |
| /** @type {boolean} */ | |
| h = true; | |
| } | |
| } | |
| } | |
| if (add) { | |
| /** @type {!Array} */ | |
| add = [end.length, -1]; | |
| } else { | |
| /** @type {boolean} */ | |
| add = false; | |
| for (; !add;) { | |
| if (0 == e.compareEndPoints("StartToEnd", e)) { | |
| /** @type {boolean} */ | |
| add = true; | |
| } else { | |
| e.moveEnd("character", -1); | |
| if (e.text == value) { | |
| /** @type {string} */ | |
| start = start + "\r\n"; | |
| } else { | |
| /** @type {boolean} */ | |
| add = true; | |
| } | |
| } | |
| } | |
| /** @type {!Array} */ | |
| add = [end.length, end.length + start.length]; | |
| } | |
| return add; | |
| } | |
| end = range.text.length; | |
| value = add ? -1 : range.text.length + start.text.length; | |
| } | |
| } | |
| } | |
| return [end, value]; | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @return {?} | |
| */ | |
| var $v = function(e) { | |
| var doc = e.ownerDocument || e.document; | |
| var c = doc.selection.createRange(); | |
| if ("textarea" == e.type) { | |
| doc = doc.body.createTextRange(); | |
| doc.moveToElementText(e); | |
| } else { | |
| doc = e.createTextRange(); | |
| } | |
| return [doc, c]; | |
| }; | |
| /** | |
| * @param {!Object} parent | |
| * @param {number} x | |
| * @return {?} | |
| */ | |
| var bw = function(parent, x) { | |
| if ("textarea" == parent.type) { | |
| x = be(parent.value.substring(0, x)).length; | |
| } | |
| return x; | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @return {?} | |
| */ | |
| var Yv = function(obj) { | |
| try { | |
| return "number" == typeof obj.selectionStart; | |
| } catch (b) { | |
| return false; | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var Zv = function() { | |
| return C.V && !C.Ea("9"); | |
| }; | |
| /** | |
| * @param {number} value | |
| * @param {number} cfg | |
| * @param {string} resource | |
| * @param {string} callback | |
| * @return {undefined} | |
| */ | |
| var cw = function(value, cfg, resource, callback) { | |
| var L = DATA.DisplayLanguage; | |
| var c = DATA.MaxSingleQueryLength; | |
| /** @type {number} */ | |
| this.b = value; | |
| /** @type {number} */ | |
| this.h = cfg; | |
| this.L = L; | |
| /** @type {string} */ | |
| this.g = resource; | |
| this.c = c; | |
| this.a = callback || null; | |
| /** @type {boolean} */ | |
| this.o = false; | |
| this.m = new hm; | |
| /** @type {string} */ | |
| this.m.c = "webapp"; | |
| this.F = M.N(); | |
| }; | |
| /** | |
| * @param {!Object} exports | |
| * @return {undefined} | |
| */ | |
| var dw = function(exports) { | |
| I(exports.b, "change", exports.w, false, exports); | |
| I(document, "selectionchange", exports.C, false, exports); | |
| I(new tv(exports.b.j()), "paste", exports.G, false, exports); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| cw.prototype.w = function(name) { | |
| var t = this.b.aa().length; | |
| if (this.a) { | |
| pv(this.a, t); | |
| } | |
| /** @type {boolean} */ | |
| var y = "set" == name.fe; | |
| /** @type {boolean} */ | |
| name = "key" == name.fe; | |
| if (t > this.c) { | |
| if (!dq(this.g.j()) && !name || y) { | |
| this.g.setVisible(true); | |
| name = this.h.c; | |
| if ("" == name) { | |
| name = this.h.a; | |
| } | |
| /** @type {number} */ | |
| y = t - this.c; | |
| mm(this.m, "webapp", "ov", "1", { | |
| sl : this.h.a, | |
| tl : this.h.b, | |
| dl : name, | |
| hl : this.L, | |
| ql : t, | |
| ol : y | |
| }); | |
| name = this.F; | |
| N(name, Rl(name, 250, t, y)); | |
| if (this.a) { | |
| ov(this.a, true); | |
| } | |
| t = this.b.aa().substring(this.c); | |
| this.g.g = t; | |
| t = this.g; | |
| y = { | |
| maximum_input_count : kv(t.Y, this.c) | |
| }; | |
| name = ew(t.W, y); | |
| H(E("snck-msg", t.j()), name); | |
| y = ew(t.Z, y); | |
| H(E("ovfl-xlt", t.j()), y); | |
| } | |
| this.b.g(this.b.aa().substring(0, this.c)); | |
| if (this.a) { | |
| pv(this.a, this.c); | |
| } | |
| } else { | |
| if (t < this.c && this.a) { | |
| ov(this.a, false); | |
| } | |
| if (y || 0 == t) { | |
| fw(this); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} slot | |
| * @return {undefined} | |
| */ | |
| var fw = function(slot) { | |
| /** @type {string} */ | |
| slot.g.g = ""; | |
| slot.g.setVisible(false); | |
| if (slot.a) { | |
| ov(slot.a, false); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| cw.prototype.C = function() { | |
| var a = aw(this.b.j(), false); | |
| var c = this.b.aa().length; | |
| /** @type {boolean} */ | |
| this.o = 0 != c && 0 == a[0] && a[1] == c; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| cw.prototype.G = function() { | |
| if (this.o) { | |
| fw(this); | |
| } | |
| }; | |
| /** | |
| * @param {string} b | |
| * @return {undefined} | |
| */ | |
| var gw = function(b) { | |
| this.b = b || ""; | |
| /** @type {null} */ | |
| this.a = this.wa = null; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var hw = function() { | |
| var mixElem = Km(new tm(window.location.href, true), "authuser"); | |
| return mixElem ? "&authuser=" + mixElem : ""; | |
| }; | |
| /** | |
| * @param {!Object} message | |
| * @param {number} x | |
| * @param {!Object} e | |
| * @param {!Array} a | |
| * @return {?} | |
| */ | |
| var iw = function(message, x, e, a) { | |
| message = { | |
| root : message.b, | |
| path : "/v1/crowdplatform/text/translation/submit", | |
| method : "POST", | |
| body : { | |
| client : { | |
| client_id : 3 | |
| }, | |
| question : { | |
| question_metadata : { | |
| question_id : x.encrypted_question_id | |
| } | |
| }, | |
| answer : { | |
| opinions : [] | |
| } | |
| }, | |
| params : { | |
| $trace : "true" | |
| } | |
| }; | |
| var arr = message.body.answer; | |
| var b = Km(new tm(window.location.href, true), "source"); | |
| arr.answer_metadata = { | |
| channel_type : 3 | |
| }; | |
| if (b) { | |
| /** @type {!Array} */ | |
| arr.answer_metadata.user_promotion_labels = [b]; | |
| } | |
| /** @type {!Array} */ | |
| arr = arr.opinions; | |
| /** @type {number} */ | |
| b = 0; | |
| for (; b < e.length; ++b) { | |
| var m = e[b].match(/(im)?(perfect)_?([0-9])?/); | |
| if (m) { | |
| /** @type {boolean} */ | |
| var h = !m[1]; | |
| /** @type {number} */ | |
| m = m[3] ? Number.parseInt(m[3], 10) - 1 : 0; | |
| if (m < x.target_options.length) { | |
| arr.push({ | |
| value : x.target_options[m], | |
| Np : h ? 2 : 3 | |
| }); | |
| } | |
| } | |
| } | |
| /** @type {number} */ | |
| x = 0; | |
| for (; x < a.length; ++x) { | |
| arr.push({ | |
| value : a[x], | |
| Np : 1 | |
| }); | |
| } | |
| return message; | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @param {string} xml | |
| * @param {string} name | |
| * @param {string} f | |
| * @return {undefined} | |
| */ | |
| var jw = function(data, xml, name, f) { | |
| if (window.gapi && window.gapi.client) { | |
| window.gapi.client.request({ | |
| root : data.b, | |
| path : "/v1/crowdplatform/text/translation/list", | |
| method : "POST", | |
| body : { | |
| client : { | |
| client_id : 3 | |
| }, | |
| source_language : xml, | |
| target_language : name, | |
| question_type : 2 | |
| }, | |
| params : { | |
| $trace : "true" | |
| } | |
| }).then(function(results) { | |
| /** @type {!Array} */ | |
| var mRule = []; | |
| if (results = results.result.questions) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < results.length; ++i) { | |
| var rule = { | |
| type : "vt", | |
| source : results[i].sourceText, | |
| encrypted_question_id : results[i].questionMetadata.questionId | |
| }; | |
| var currentFacets = results[i].validationTexts; | |
| if (currentFacets) { | |
| /** @type {!Array} */ | |
| var allSubNames = rule.target_options = []; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < currentFacets.length && 5 > i; ++i) { | |
| allSubNames.push(currentFacets[i].value); | |
| } | |
| } | |
| mRule.push(rule); | |
| } | |
| } | |
| f({ | |
| activities : mRule | |
| }); | |
| }.bind(data), function() { | |
| f(null); | |
| }); | |
| } else { | |
| /** @type {string} */ | |
| xml = "/community_v2/as?client=webapp" + hw() + "&sl=" + xml + "&tl=" + name + "&surt=vt"; | |
| if (name = Km(new tm(window.location.href, true), "e")) { | |
| /** @type {string} */ | |
| xml = xml + ("&e=" + name); | |
| } | |
| if (data.wa) { | |
| data.wa.abort(); | |
| } | |
| data.wa = vj(xml, v(data.c, data, f), "POST", data.a ? data.a.toString() : void 0); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| gw.prototype.c = function(type, value) { | |
| value = value.target; | |
| if (Ej(value)) { | |
| try { | |
| var obj = Gj(value); | |
| if (obj.vf && obj.vf.length) { | |
| /** @type {!Array} */ | |
| value = []; | |
| /** @type {!Array} */ | |
| var d = []; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < obj.vf.length; ++i) { | |
| value.push(obj.vf[i].encrypted_experiment_name); | |
| d.push(obj.vf[i].encrypted_question_id); | |
| } | |
| this.a = new Am; | |
| Im(this.a, "cpqn", value); | |
| Im(this.a, "cpqi", d); | |
| } | |
| type(obj); | |
| } catch (f) { | |
| } | |
| } else { | |
| type(null); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| gw.prototype.abort = function() { | |
| if (this.wa) { | |
| this.wa.abort(); | |
| } | |
| }; | |
| /** | |
| * @param {!Function} options | |
| * @return {?} | |
| */ | |
| var kw = function(options) { | |
| var self = new Am; | |
| self.set("as", options.encrypted_experiment_name); | |
| self.set("qid", options.encrypted_question_id); | |
| self.set("xt", window.USAGE || window.xsrfToken); | |
| return self; | |
| }; | |
| /** | |
| * @param {string} key | |
| * @param {string} service | |
| * @param {number} opts | |
| * @param {string} src | |
| * @param {string} xform | |
| * @param {string} exh | |
| * @param {!Object} t | |
| * @return {undefined} | |
| */ | |
| var lw = function(key, service, opts, src, xform, exh, t) { | |
| /** @type {!Array} */ | |
| var cb = []; | |
| if (window.gapi && window.gapi.client) { | |
| window.gapi.client.request(iw(key, opts, t, cb)).then(function() { | |
| }.bind(key), function() { | |
| }); | |
| } else { | |
| /** @type {string} */ | |
| key = "/community/submit_answer?client=webapp" + hw() + "&sl=" + xform + "&tl=" + exh + "&surt=" + src + "&i=" + service; | |
| if (0 < t.length) { | |
| service = new Am; | |
| Im(service, "answer", t); | |
| /** @type {string} */ | |
| key = key + ("&" + service.toString()); | |
| } | |
| t = kw(opts); | |
| t.set("q", opts.source); | |
| if (0 < cb.length) { | |
| Im(t, "ffa", cb); | |
| } | |
| vj(key, function(mutationEvent) { | |
| Gj(mutationEvent.target); | |
| }, "POST", t.toString()); | |
| } | |
| }; | |
| /** | |
| * @param {string} options | |
| * @param {string} req | |
| * @param {!Object} type | |
| * @param {string} res | |
| * @param {string} next | |
| * @param {string} api | |
| * @return {undefined} | |
| */ | |
| var mw = function(options, req, type, res, next, api) { | |
| if (window.gapi && window.gapi.client) { | |
| window.gapi.client.request({ | |
| root : options.b, | |
| path : "/v1/crowdplatform/text/translation/submit", | |
| method : "POST", | |
| body : { | |
| client : { | |
| client_id : 3 | |
| }, | |
| question : { | |
| question_metadata : { | |
| question_id : type.encrypted_question_id | |
| } | |
| }, | |
| answer : { | |
| skip_reason : 3 | |
| } | |
| }, | |
| params : { | |
| $trace : "true" | |
| } | |
| }).then(function() { | |
| }.bind(options), function() { | |
| }); | |
| } else { | |
| /** @type {string} */ | |
| options = "/community/submit_answer?client=webapp" + hw() + "&sl=" + next + "&tl=" + api + "&surt=" + res + "&i=" + req + "&sk=1"; | |
| type = kw(type); | |
| vj(options, function(mutationEvent) { | |
| Gj(mutationEvent.target); | |
| }, "POST", type.toString()); | |
| } | |
| }; | |
| /** | |
| * @param {number} val | |
| * @param {?} opt_validate | |
| * @param {?} eventStr | |
| * @param {number} a | |
| * @return {undefined} | |
| */ | |
| var qw = function(val, opt_validate, eventStr, a) { | |
| /** @type {number} */ | |
| this.v = val; | |
| /** @type {number} */ | |
| this.L = this.o = this.b = 0; | |
| this.C = opt_validate; | |
| this.Ga = eventStr; | |
| /** @type {null} */ | |
| this.c = null; | |
| /** @type {string} */ | |
| this.R = this.K = this.G = this.w = this.m = ""; | |
| this.F = hm.N(); | |
| this.g = new rq(this); | |
| this.h = new rq(this); | |
| /** @type {number} */ | |
| this.a = a; | |
| yp(this.v, Fn, { | |
| $m : this.a.COMMUNITY_INSTANT_HELP_BODY, | |
| an : this.a.COMMUNITY_INSTANT_HELP_HEADER, | |
| cn : this.a.COMMUNITY_INSTANT_OK_BUTTON, | |
| dn : this.a.COMMUNITY_INSTANT_CANCEL_BUTTON, | |
| fn : this.a.COMMUNITY_INSTANT_CLOSE_BODY, | |
| gn : this.a.COMMUNITY_INSTANT_CLOSE_HEADER, | |
| hn : this.a.COMMUNITY_INSTANT_OK_BUTTON, | |
| qp : this.a.COMMUNITY_INSTANT_THANK_YOU, | |
| pp : this.a.COMMUNITY_INSTANT_CONTRIBUTE_MORE | |
| }); | |
| nw(this); | |
| ow(this); | |
| pw(this); | |
| }; | |
| /** | |
| * @param {boolean} a | |
| * @return {undefined} | |
| */ | |
| qw.prototype.setVisible = function(a) { | |
| X(this.v, a); | |
| }; | |
| /** | |
| * @param {!Object} self | |
| * @return {undefined} | |
| */ | |
| var sw = function(self) { | |
| wq(self.h); | |
| if (self.b >= self.c.activities.length) { | |
| self.Ga(); | |
| } else { | |
| /** @type {number} */ | |
| self.L = 5; | |
| var data = self.c.activities[self.b].source; | |
| var x = self.c.activities[self.b].target_options[0]; | |
| var b = F("tlid-community-instant-vt-card", self.v); | |
| yp(b, Hn, { | |
| Ca : self.K, | |
| Pa : self.R, | |
| Ae : data, | |
| jp : x, | |
| yl : self.o, | |
| up : self.L, | |
| Zm : self.a.COMMUNITY_INSTANT_TITLE, | |
| Yn : self.a.COMMUNITY_INSTANT_SKIP_BUTTON, | |
| Zn : self.a.COMMUNITY_INSTANT_YES_BUTTON, | |
| Xn : self.a.COMMUNITY_INSTANT_NO_BUTTON | |
| }); | |
| data = F("tlid-community-instant-yes", b); | |
| x = F("tlid-community-instant-no", b); | |
| self.h.M(data, "click", function() { | |
| lw(self.C, self.b, self.c.activities[self.b], self.m, self.w, self.G, ["vt_perfect"]); | |
| rw(self); | |
| }); | |
| self.h.M(x, "click", function() { | |
| lw(self.C, self.b, self.c.activities[self.b], self.m, self.w, self.G, ["vt_imperfect"]); | |
| rw(self); | |
| }); | |
| data = F("tlid-community-instant-skip", b); | |
| x = F("tlid-community-instant-hide", b); | |
| b = F("tlid-community-instant-help", b); | |
| self.h.M(data, "click", function() { | |
| mw(self.C, self.b, self.c.activities[self.b], self.m, self.w, self.G); | |
| ++self.b; | |
| sw(self); | |
| }); | |
| self.h.M(x, "click", function() { | |
| tw(self); | |
| uw(self, "collapse"); | |
| }); | |
| self.h.M(b, "click", function(event) { | |
| event.stopPropagation(); | |
| T(self.v, "show-help"); | |
| uw(self, "help"); | |
| }); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} self | |
| * @return {undefined} | |
| */ | |
| var rw = function(self) { | |
| ++self.b; | |
| ++self.o; | |
| if (self.o >= self.L) { | |
| /** @type {number} */ | |
| self.o = 0; | |
| T(self.v, "show-thanks"); | |
| uw(self, "show_thanks"); | |
| } else { | |
| sw(self); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} id | |
| * @return {undefined} | |
| */ | |
| var tw = function(id) { | |
| T(id.v, "show-hide-confirmation"); | |
| }; | |
| /** | |
| * @param {!Object} self | |
| * @return {undefined} | |
| */ | |
| var nw = function(self) { | |
| var x = F("tlid-community-instant-help-card", self.v); | |
| var res = F("tlid-community-instant-close", x); | |
| self.g.M(res, "click", function() { | |
| U(self.v, "show-help"); | |
| sw(self); | |
| uw(self, "help_close"); | |
| }); | |
| x = F("tlid-community-instant-ok", x); | |
| self.g.M(x, "click", function() { | |
| U(self.v, "show-help"); | |
| sw(self); | |
| uw(self, "help_ok"); | |
| }); | |
| }; | |
| /** | |
| * @param {!Object} self | |
| * @return {undefined} | |
| */ | |
| var ow = function(self) { | |
| var x = F("tlid-community-instant-hide-card", self.v); | |
| var res = F("tlid-community-instant-cancel", x); | |
| self.g.M(res, "click", function() { | |
| U(self.v, "show-hide-confirmation"); | |
| sw(self); | |
| uw(self, "hide_cancel"); | |
| }); | |
| res = F("tlid-community-instant-close", x); | |
| self.g.M(res, "click", function() { | |
| U(self.v, "show-hide-confirmation"); | |
| sw(self); | |
| uw(self, "hide_cancel"); | |
| }); | |
| x = F("tlid-community-instant-ok", x); | |
| self.g.M(x, "click", function() { | |
| U(self.v, "show-hide-confirmation"); | |
| sw(self); | |
| uw(self, "hide_ok"); | |
| }); | |
| }; | |
| /** | |
| * @param {!Object} self | |
| * @return {undefined} | |
| */ | |
| var pw = function(self) { | |
| var x = F("tlid-community-instant-thanks-card", self.v); | |
| var res = F("tlid-community-instant-continue", x); | |
| x = F("tlid-community-instant-close", x); | |
| self.g.M(res, "click", function() { | |
| U(self.v, "show-thanks"); | |
| sw(self); | |
| uw(self, "thanks_continue"); | |
| }); | |
| self.g.M(x, "click", function() { | |
| U(self.v, "show-thanks"); | |
| tw(self); | |
| uw(self, "thanks_close"); | |
| }); | |
| }; | |
| /** | |
| * @param {!Object} store | |
| * @param {string} type | |
| * @return {undefined} | |
| */ | |
| var uw = function(store, type) { | |
| mm(store.F, "t", "communitycard", type, void 0); | |
| }; | |
| /** | |
| * @param {string} item | |
| * @param {number} value | |
| * @param {number} p | |
| * @param {?} G | |
| * @return {undefined} | |
| */ | |
| var xw = function(item, value, p, G) { | |
| /** @type {function(!Object): ?} */ | |
| var C = vw; | |
| /** @type {function(!Object): ?} */ | |
| var L = ww; | |
| var MSG = DATA.CrowdComputeHostname; | |
| var h = { | |
| COMMUNITY_INSTANT_CANCEL_BUTTON : DATA.Messages.COMMUNITY_INSTANT_CANCEL_BUTTON, | |
| COMMUNITY_INSTANT_CLOSE_HEADER : DATA.Messages.COMMUNITY_INSTANT_CLOSE_HEADER, | |
| COMMUNITY_INSTANT_CLOSE_BODY : DATA.Messages.COMMUNITY_INSTANT_CLOSE_BODY, | |
| COMMUNITY_INSTANT_CONTRIBUTE_MORE : DATA.Messages.COMMUNITY_INSTANT_CONTRIBUTE_MORE, | |
| COMMUNITY_INSTANT_HELP_HEADER : DATA.Messages.COMMUNITY_INSTANT_HELP_HEADER, | |
| COMMUNITY_INSTANT_HELP_BODY : DATA.Messages.COMMUNITY_INSTANT_HELP_BODY, | |
| COMMUNITY_INSTANT_NO_BUTTON : DATA.Messages.COMMUNITY_INSTANT_NO_BUTTON, | |
| COMMUNITY_INSTANT_OK_BUTTON : DATA.Messages.COMMUNITY_INSTANT_OK_BUTTON, | |
| COMMUNITY_INSTANT_SKIP_BUTTON : DATA.Messages.COMMUNITY_INSTANT_SKIP_BUTTON, | |
| COMMUNITY_INSTANT_THANK_YOU : DATA.Messages.COMMUNITY_INSTANT_THANK_YOU, | |
| COMMUNITY_INSTANT_TITLE : DATA.Messages.COMMUNITY_INSTANT_TITLE, | |
| COMMUNITY_INSTANT_YES_BUTTON : DATA.Messages.COMMUNITY_INSTANT_YES_BUTTON | |
| }; | |
| /** @type {number} */ | |
| this.a = value; | |
| /** @type {number} */ | |
| this.b = p; | |
| /** @type {function(!Object): ?} */ | |
| this.C = C; | |
| /** @type {function(!Object): ?} */ | |
| this.L = L; | |
| this.G = G; | |
| /** @type {string} */ | |
| this.w = this.m = ""; | |
| this.g = new gw(MSG); | |
| this.h = new qw(item, this.g, v(this.o, this), h); | |
| this.c = new Dr(this.o, 50, this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| xw.prototype.reset = function() { | |
| this.G(); | |
| }; | |
| /** | |
| * @param {string} arg | |
| * @return {undefined} | |
| */ | |
| xw.prototype.setVisible = function(arg) { | |
| if (arg) { | |
| /** @type {boolean} */ | |
| arg = this.m != this.a() || this.w != this.b(); | |
| this.h.setVisible(true); | |
| if (arg) { | |
| this.c.start(); | |
| } | |
| } else { | |
| this.g.abort(); | |
| this.c.stop(); | |
| this.h.setVisible(false); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| xw.prototype.o = function() { | |
| if (window.gapi && window.gapi.client) { | |
| var a = this.a(); | |
| var value = this.b(); | |
| jw(this.g, a, value, v(this.K, this, a, value)); | |
| } else { | |
| this.c.start(); | |
| } | |
| }; | |
| /** | |
| * @param {number} name | |
| * @param {number} value | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| xw.prototype.K = function(name, value, a) { | |
| if (a) { | |
| /** @type {number} */ | |
| this.m = name; | |
| /** @type {number} */ | |
| this.w = value; | |
| var d = this.C(name); | |
| var next = this.L(value); | |
| var self = this.h; | |
| /** @type {string} */ | |
| self.c = a; | |
| /** @type {number} */ | |
| self.b = 0; | |
| if (!self.c.activities || self.b >= self.c.activities.length) { | |
| name = E("tlid-community-instant-vt-card", self.v); | |
| U(self.v, "show-help"); | |
| U(self.v, "show-hide-confirmation"); | |
| U(self.v, "show-thanks"); | |
| Ff(name); | |
| } else { | |
| /** @type {number} */ | |
| self.w = name; | |
| /** @type {number} */ | |
| self.G = value; | |
| self.K = d; | |
| self.R = next; | |
| self.m = self.c.activities[0].type; | |
| uw(self, "update"); | |
| sw(self); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Function} _at_B | |
| * @param {?} _at_O | |
| * @param {?} other | |
| * @param {number} event | |
| * @param {?} a | |
| * @param {number} b | |
| * @param {!Array} input | |
| * @param {!Object} isBinaryData | |
| * @return {undefined} | |
| */ | |
| var yw = function(_at_B, _at_O, other, event, a, b, input, isBinaryData) { | |
| zq.call(this); | |
| this.c = hm.N(); | |
| /** @type {!Function} */ | |
| this.T = _at_B; | |
| this.O = _at_O; | |
| this.Y = other; | |
| /** @type {number} */ | |
| this.W = event; | |
| this.Z = a; | |
| /** @type {number} */ | |
| this.b = b; | |
| /** @type {!Array} */ | |
| this.m = input; | |
| this.h = null != isBinaryData ? isBinaryData : null; | |
| this.F = M.N(); | |
| /** @type {boolean} */ | |
| this.w = false; | |
| }; | |
| x(yw, zq); | |
| /** | |
| * @param {string} arg | |
| * @return {undefined} | |
| */ | |
| yw.prototype.setVisible = function(arg) { | |
| if (arg && !this.w) { | |
| this.c.log("community-promo", "show-" + this.b); | |
| Ul(this.F, this.m); | |
| X(this.g, true); | |
| } else { | |
| X(this.g, false); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} target | |
| * @return {undefined} | |
| */ | |
| yw.prototype.Fa = function(target) { | |
| yw.D.Fa.call(this, target); | |
| this.g = Ap(Gn, { | |
| In : this.T, | |
| Hn : this.O, | |
| rp : this.Y, | |
| fp : this.W, | |
| url : this.Z, | |
| id : this.b | |
| }); | |
| target.appendChild(this.g); | |
| var p = E("cp-dismiss", target); | |
| Y(this).M(p, "click", this.C); | |
| target = E("cp-promo-href", target); | |
| Y(this).M(target, "click", this.K); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| yw.prototype.C = function() { | |
| this.c.log("community-promo", "dismiss-" + this.b); | |
| lm(this.c, "/translate/uc?ua=dcp&uav=" + this.b); | |
| var valueProgess = this.F; | |
| N(valueProgess, Tl(valueProgess, 74, this.m)); | |
| this.setVisible(false); | |
| /** @type {boolean} */ | |
| this.w = true; | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| yw.prototype.K = function(type) { | |
| this.c.log("community-promo", "click-" + this.b); | |
| Vl(this.F, this.m); | |
| var _ref; | |
| if (_ref = this.h) { | |
| var h = this.h; | |
| _ref = h.a(); | |
| h = h.b(); | |
| /** @type {boolean} */ | |
| _ref = "en" == _ref && "es" == h || "es" == _ref && "en" == h ? true : false; | |
| } | |
| if (_ref) { | |
| this.h.reset(); | |
| type.preventDefault(); | |
| type.stopPropagation(); | |
| } | |
| }; | |
| /** | |
| * @param {number} a | |
| * @param {string} b | |
| * @return {undefined} | |
| */ | |
| var zw = function(a, b) { | |
| /** @type {number} */ | |
| this.a = a; | |
| this.b = b || null; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| zw.prototype.ab = function() { | |
| return this.a; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| zw.prototype.Cb = function() { | |
| return this.b; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Aw = function() { | |
| }; | |
| x(Aw, Uq); | |
| Ia(Aw); | |
| k = Aw.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| k.nd = function() { | |
| return "menuitem"; | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @return {?} | |
| */ | |
| k.Eb = function(data) { | |
| var x = G("DIV", null, data.ab()); | |
| T(x, "gt-is-sg"); | |
| var t = G("DIV", null, ""); | |
| T(t, data.Vi ? "gt-is-ld-top" : "gt-is-ld"); | |
| /** @type {!Array} */ | |
| t = ["DIV", Xq(this, data), t]; | |
| var v = G("SPAN"); | |
| if (data.$c) { | |
| var c = new Br(null, new vt); | |
| c.Za(v); | |
| T(c.j(), "gt-is-flag"); | |
| Xr(c.j(), data.dh, void 0); | |
| c.setVisible(false); | |
| data.ac = c; | |
| v.id = Bq(c); | |
| } | |
| c = G("DIV"); | |
| T(c, "gt-is-ca"); | |
| var wrapper = new Br; | |
| wrapper.v = c; | |
| data.zc = wrapper; | |
| /** @type {!Array<?>} */ | |
| t = t.concat([x, v, c]); | |
| if (data.Mo) { | |
| x = G("DIV", null, data.Cb()); | |
| t.push(x); | |
| T(x, "gt-is-tr"); | |
| } | |
| x = G.apply(null, t); | |
| x.id = Bq(data); | |
| return data.v = x; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| k.md = function(a) { | |
| return "DIV" == a.tagName; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.za = function() { | |
| return "gt-is-itm"; | |
| }; | |
| /** | |
| * @param {!Array} t | |
| * @param {number} object | |
| * @param {boolean} value | |
| * @return {undefined} | |
| */ | |
| k.Od = function(t, object, value) { | |
| Aw.D.Od.call(this, t, object, value); | |
| if (2 == object && t.$c && t.ac && !t.he) { | |
| t.ac.setVisible(value); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} xform | |
| * @param {?} type | |
| * @param {?} data | |
| * @param {string} linkedEntities | |
| * @param {?} force | |
| * @param {?} value | |
| * @param {?} lstn | |
| * @return {undefined} | |
| */ | |
| var Bw = function(xform, type, data, linkedEntities, force, value, lstn) { | |
| lr.call(this, xform.ab(), value || Aw.N(), lstn); | |
| /** @type {!Object} */ | |
| this.xe = xform; | |
| this.$c = type; | |
| this.dh = data; | |
| /** @type {null} */ | |
| this.zc = null; | |
| /** @type {string} */ | |
| this.Vi = linkedEntities; | |
| this.Mo = force; | |
| /** @type {boolean} */ | |
| this.he = false; | |
| this.Sa(1, false); | |
| }; | |
| x(Bw, lr); | |
| /** | |
| * @return {?} | |
| */ | |
| Bw.prototype.ab = function() { | |
| return this.xe.ab(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Bw.prototype.Cb = function() { | |
| return this.xe.Cb(); | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @return {undefined} | |
| */ | |
| Bw.prototype.Fb = function(e) { | |
| if (this.$c && Pf(this.ac.j(), e.target)) { | |
| /** @type {boolean} */ | |
| this.he = true; | |
| this.ac.Fb(e); | |
| } else { | |
| if (this.zc && Pf(this.zc.j(), e.target)) { | |
| this.zc.Fb(e); | |
| } else { | |
| Bw.D.Fb.call(this, e); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @return {undefined} | |
| */ | |
| Bw.prototype.Nb = function(e) { | |
| if (this.zc && Pf(this.zc.j(), e.target)) { | |
| this.zc.Nb(e); | |
| } else { | |
| if (this.$c && Pf(this.ac.j(), e.target) && this.he) { | |
| this.ac.Nb(e); | |
| /** @type {boolean} */ | |
| this.he = false; | |
| if (!this.Ha(2)) { | |
| this.ac.setVisible(false); | |
| } | |
| } else { | |
| if (this.$c) { | |
| var w = this.getParent(); | |
| A(w.b, function(result) { | |
| if (result.he) { | |
| /** @type {boolean} */ | |
| result.he = false; | |
| tr(result.ac, false); | |
| } | |
| if (result != this) { | |
| result.ac.setVisible(false); | |
| } | |
| }); | |
| } | |
| Bw.D.Nb.call(this, e); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {?} from | |
| * @param {?} k | |
| * @param {?} v | |
| * @param {?} udir | |
| * @return {undefined} | |
| */ | |
| var Cw = function(from, k, v, udir) { | |
| /** @type {string} */ | |
| var id = "md"; | |
| if (null != udir && udir) { | |
| /** @type {string} */ | |
| id = "m" + id; | |
| } | |
| os.call(this, from, id, MSG_DEFINITIONS_OF, "", 7); | |
| this.K = k; | |
| this.C = null != v ? v : true; | |
| }; | |
| x(Cw, os); | |
| /** | |
| * @param {number} b | |
| * @param {?} a | |
| * @param {number} i | |
| * @param {!Object} n | |
| * @return {?} | |
| */ | |
| Cw.prototype.update = function(b, a, i, n) { | |
| Cw.D.update.call(this, b, a, i, n); | |
| if (!n || 0 == J(n, 12) && 0 == J(n, 15)) { | |
| return false; | |
| } | |
| Ff(this.b); | |
| this.Ud(); | |
| /** @type {number} */ | |
| this.g = 0; | |
| b = J(n, 12); | |
| /** @type {boolean} */ | |
| a = 3 > b; | |
| /** @type {number} */ | |
| var c = i = 0; | |
| for (; c < J(n, 12); c++) { | |
| i = i + (new qo(hl(n, 12, c))).b(); | |
| } | |
| i = 5 > i ? i : 3; | |
| /** @type {number} */ | |
| c = this.w = 0; | |
| for (; c < b; ++c) { | |
| var p = new qo(hl(n, 12, c)); | |
| var k = K(new qo(hl(n, 12, c)), 2); | |
| var node = G("DIV", { | |
| "class" : "gt-cd-pos" | |
| }); | |
| this.b.appendChild(node); | |
| H(node, K(p, 0)); | |
| /** @type {!Object} */ | |
| node = n; | |
| /** @type {boolean} */ | |
| var el = a; | |
| /** @type {number} */ | |
| var d = i; | |
| /** @type {number} */ | |
| var link = Math.ceil(d / b); | |
| var obj = G("DIV", { | |
| "class" : "gt-def-list" | |
| }); | |
| /** @type {string} */ | |
| var dir = kc(this.Ca) ? "rtl" : "ltr"; | |
| Hp(obj, { | |
| direction : dir | |
| }); | |
| /** @type {number} */ | |
| dir = 0; | |
| for (; dir < p.b(); ++dir) { | |
| var target = p.c(dir); | |
| var parent = K(target, 0); | |
| var g = K(target, 2); | |
| var c = node; | |
| /** @type {!Array} */ | |
| var item = []; | |
| /** @type {number} */ | |
| var a = 0; | |
| for (; a < J(c, 11); ++a) { | |
| var tParentMatrix = new Lo(hl(c, 11, a)); | |
| /** @type {number} */ | |
| var name = 0; | |
| for (; name < tParentMatrix.b(); ++name) { | |
| var c = tParentMatrix.c(name); | |
| if (K(target, 1) == K(c, 1)) { | |
| /** @type {!Array} */ | |
| var newTabSet = []; | |
| /** @type {number} */ | |
| var a = 0; | |
| for (; a < J(c, 0); ++a) { | |
| ub(newTabSet, fh(c, 0, a)); | |
| } | |
| ub(item, newTabSet); | |
| } | |
| } | |
| } | |
| /** @type {!Array} */ | |
| c = item; | |
| if (target = 1 > dir || el && dir < link && this.w < d) { | |
| this.w += 1; | |
| } | |
| parent = Dw(this, dir + 1, parent, g, c, target); | |
| obj.appendChild(parent); | |
| this.g += 1; | |
| } | |
| this.b.appendChild(obj); | |
| } | |
| /** @type {number} */ | |
| c = 0; | |
| for (; c < J(n, 15); c++) { | |
| el = new Bo(hl(n, 15, c)); | |
| d = K(el, 1); | |
| node = K(el, 2); | |
| p = G("DIV", { | |
| "class" : "gt-def-row" | |
| }); | |
| d = G("DIV", { | |
| "class" : "gt-kp-desc" | |
| }, d); | |
| link = G("A"); | |
| link.setAttribute("href", K(el, 3)); | |
| link.setAttribute("target", "_blank"); | |
| el = G("IMG", { | |
| "class" : "gt-kp-image" | |
| }); | |
| el.setAttribute("src", node); | |
| link.appendChild(el); | |
| p.appendChild(link); | |
| p.appendChild(d); | |
| this.b.appendChild(p); | |
| } | |
| if (k) { | |
| this.Bf = k; | |
| ps(this, k); | |
| } | |
| if (!a && this.g > 1 * b || a && this.g > i) { | |
| n = MSG_N_MORE_DEFINITIONS_LABEL.replace("%1$s", (this.g - this.w).toLocaleString(this.Xa)); | |
| qs(this, n, MSG_FEWER_DEFINITIONS_LABEL); | |
| } else { | |
| n = nf("gt-card-expand-wrapper", this.j()); | |
| /** @type {number} */ | |
| k = 0; | |
| for (; k < n.length; k++) { | |
| b = n[k]; | |
| if (E("gt-def-synonym", b)) { | |
| U(b, "gt-card-expand-wrapper"); | |
| } | |
| } | |
| } | |
| this.setVisible(true); | |
| return true; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Cw.prototype.ia = function() { | |
| Cw.D.ia.call(this); | |
| Y(this).M(this.j(), "click", this.T); | |
| }; | |
| /** | |
| * @param {?} a | |
| * @return {undefined} | |
| */ | |
| Cw.prototype.Fa = function(a) { | |
| Cw.D.Fa.call(this, a); | |
| }; | |
| /** | |
| * @param {boolean} self | |
| * @param {?} r | |
| * @param {string} d | |
| * @param {!Object} g | |
| * @param {!Object} handler | |
| * @param {!Function} replacement | |
| * @return {?} | |
| */ | |
| var Dw = function(self, r, d, g, handler, replacement) { | |
| /** @type {string} */ | |
| var oppositeDirection = kc(self.Pa) ? "rtl" : "ltr"; | |
| r = Bp(On, { | |
| Bl : r.toLocaleString(self.Xa), | |
| Hk : self.K, | |
| Cl : d, | |
| Ul : g, | |
| ip : MSG_SYNONYMS_LOWERCASE, | |
| hp : handler, | |
| Xh : oppositeDirection, | |
| ll : self.C, | |
| Ca : self.Ca | |
| }); | |
| if (self.C) { | |
| A(nf("gt-cd-cl", r), function(wrap) { | |
| this.c.push(wrap); | |
| }, self); | |
| } | |
| ss(self, E("gt-mt-md", r), d); | |
| if (d = E("gt-ex-mt", r)) { | |
| ss(self, d, g); | |
| } | |
| if ((g = E("gt-def-synonym-title", r)) && kc(self.Xa) != kc(self.Ca)) { | |
| self = kc(self.Xa); | |
| Hp(g, "direction", self ? "rtl" : "ltr"); | |
| Hp(g, "padding-" + (self ? "left" : "right"), "8px"); | |
| } | |
| return rs(r, replacement); | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| Cw.prototype.T = function(type) { | |
| if (tp(type.target, "gt-cd-cl")) { | |
| this.dispatchEvent(new kg("a", type.target)); | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Cw.prototype.sb = function() { | |
| return this.C ? this.Ye() : this.g; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {?} | |
| */ | |
| var Fw = function(a) { | |
| Ew(); | |
| return od(a); | |
| }; | |
| /** | |
| * @param {undefined} name | |
| * @return {?} | |
| */ | |
| var Gw = function(name) { | |
| Ew(); | |
| return tc(name); | |
| }; | |
| /** @type {function(): undefined} */ | |
| var Ew = Ha; | |
| /** | |
| * @param {?} from | |
| * @param {?} k | |
| * @param {?} init_using_data | |
| * @return {undefined} | |
| */ | |
| var Hw = function(from, k, init_using_data) { | |
| /** @type {string} */ | |
| var id = "ex"; | |
| if (null != init_using_data && init_using_data) { | |
| /** @type {string} */ | |
| id = "m" + id; | |
| } | |
| this.K = k; | |
| os.call(this, from, id, MSG_EXAMPLES_OF, MSG_EXAMPLES, 9); | |
| this.g = new Po; | |
| /** @type {string} */ | |
| this.C = this.w = "ltr"; | |
| }; | |
| x(Hw, os); | |
| /** | |
| * @param {number} a | |
| * @param {?} obj | |
| * @param {!Object} result | |
| * @param {!Object} node | |
| * @return {?} | |
| */ | |
| Hw.prototype.update = function(a, obj, result, node) { | |
| Hw.D.update.call(this, a, obj, result, node); | |
| Ff(this.b); | |
| this.g = new Po(node.$a[13]); | |
| if (0 == J(this.g, 0)) { | |
| return false; | |
| } | |
| this.setVisible(true); | |
| if (3 <= J(this.g, 0)) { | |
| a = MSG_N_MORE_EXAMPLES_LABEL.replace("%1$s", (J(this.g, 0) - 1).toLocaleString(this.Xa)); | |
| qs(this, a, MSG_FEWER_EXAMPLES_LABEL); | |
| } | |
| /** @type {string} */ | |
| this.w = kc(this.Ca) ? "rtl" : "ltr"; | |
| /** @type {string} */ | |
| this.C = kc(this.Pa) ? "rtl" : "ltr"; | |
| /** @type {number} */ | |
| a = 0; | |
| for (; a < J(this.g, 0); ++a) { | |
| /** @type {boolean} */ | |
| obj = 0 == a || 1 == a && 2 == J(this.g, 0); | |
| var word = new No(hl(this.g, 0, a)); | |
| result = K(word, 1); | |
| node = K(word, 2); | |
| var f = MSG_MT_FROM_GOOGLE; | |
| /** @type {string} */ | |
| var w = this.w; | |
| word = K(word, 0); | |
| Ew(); | |
| word = Pd(word, null); | |
| result = Bp(Jn, { | |
| bp : w, | |
| Ae : word, | |
| Fn : node, | |
| Gn : result, | |
| Xh : this.C, | |
| Jp : f, | |
| Zo : this.K | |
| }); | |
| obj = rs(result, obj); | |
| this.b.appendChild(obj); | |
| } | |
| return true; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Hw.prototype.fk = function() { | |
| var res = {}; | |
| res.total = J(this.g, 0); | |
| return res; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Hw.prototype.sb = function() { | |
| return J(this.g, 0); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Iw = function() { | |
| }; | |
| Ia(Iw); | |
| /** | |
| * @param {!Event} event | |
| * @return {undefined} | |
| */ | |
| var Jw = function(event) { | |
| a: { | |
| var touch = event.changedTouches[0]; | |
| switch(event.type) { | |
| case "touchstart": | |
| /** @type {string} */ | |
| var type = "mousedown"; | |
| break; | |
| case "touchmove": | |
| /** @type {string} */ | |
| type = "mousemove"; | |
| break; | |
| case "touchend": | |
| /** @type {string} */ | |
| type = "mouseup"; | |
| 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 Kw = C.product.vc || C.product.Lc || C.product.Kc; | |
| /** | |
| * @param {?} visualElementId | |
| * @param {!HTMLElement} wwd | |
| * @return {undefined} | |
| */ | |
| var Lw = function(visualElementId, wwd) { | |
| if (Kw) { | |
| wwd.addEventListener("touchstart", Jw, true); | |
| wwd.addEventListener("touchmove", Jw, true); | |
| wwd.addEventListener("touchend", Jw, true); | |
| wwd.addEventListener("touchcancel", Jw, true); | |
| } | |
| }; | |
| /** | |
| * @param {number} compiler | |
| * @return {undefined} | |
| */ | |
| var Mw = function(compiler) { | |
| /** @type {number} */ | |
| this.c = compiler; | |
| }; | |
| Ia(Mw); | |
| /** | |
| * @param {!Element} a | |
| * @param {boolean} b | |
| * @return {undefined} | |
| */ | |
| var Nw = function(a, b) { | |
| if (a) { | |
| /** @type {number} */ | |
| a.tabIndex = b ? 0 : -1; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {?} | |
| */ | |
| Mw.prototype.m = function(name) { | |
| return name.a.b("DIV", Ow(this, name).join(" ")); | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {?} | |
| */ | |
| Mw.prototype.h = function(type) { | |
| return type; | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {?} | |
| */ | |
| Mw.prototype.b = function(type) { | |
| return "DIV" == type.tagName; | |
| }; | |
| /** | |
| * @param {!Object} context | |
| * @param {?} v | |
| * @param {!Object} h | |
| * @return {?} | |
| */ | |
| var Rw = function(context, v, h) { | |
| if (h.id) { | |
| Cq(v, h.id); | |
| } | |
| var low = context.a(); | |
| /** @type {boolean} */ | |
| var e = false; | |
| var data = sp(h); | |
| if (data) { | |
| A(data, function(high) { | |
| if (high == low) { | |
| /** @type {boolean} */ | |
| e = true; | |
| } else { | |
| if (high) { | |
| if (high == low + "-disabled") { | |
| v.sa(false); | |
| } else { | |
| if (high == low + "-horizontal") { | |
| Pw(v, "horizontal"); | |
| } else { | |
| if (high == low + "-vertical") { | |
| Pw(v, "vertical"); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| }, context); | |
| } | |
| if (!e) { | |
| T(h, low); | |
| } | |
| Qw(context, v, context.h(h)); | |
| return h; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {?} item | |
| * @param {!Node} target | |
| * @return {undefined} | |
| */ | |
| var Qw = function(a, item, target) { | |
| if (target) { | |
| var t = target.firstChild; | |
| var r; | |
| for (; t && t.parentNode == target;) { | |
| r = t.nextSibling; | |
| if (1 == t.nodeType) { | |
| var data = a.g(t); | |
| if (data) { | |
| data.v = t; | |
| if (!item.isEnabled()) { | |
| data.sa(false); | |
| } | |
| item.qb(data); | |
| data.na(t); | |
| } | |
| } else { | |
| if (!(t.nodeValue && "" != zc(t.nodeValue))) { | |
| target.removeChild(t); | |
| } | |
| } | |
| t = r; | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {?} | |
| */ | |
| Mw.prototype.g = function(name) { | |
| a: { | |
| z(name); | |
| name = sp(name); | |
| /** @type {number} */ | |
| var j = 0; | |
| var nameLength = name.length; | |
| for (; j < nameLength; j++) { | |
| var template = name[j]; | |
| if (template = template in ir ? ir[template]() : null) { | |
| name = template; | |
| break a; | |
| } | |
| } | |
| /** @type {null} */ | |
| name = null; | |
| } | |
| return name; | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| Mw.prototype.o = function(name) { | |
| name = name.j(); | |
| z(name, "The container DOM element cannot be null."); | |
| iq(name, true, C.Ja); | |
| if (C.V) { | |
| /** @type {boolean} */ | |
| name.hideFocus = true; | |
| } | |
| var components = this.c; | |
| if (components) { | |
| lp(name, components); | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Mw.prototype.a = function() { | |
| return "goog-container"; | |
| }; | |
| /** | |
| * @param {string} key | |
| * @param {!Object} config | |
| * @return {?} | |
| */ | |
| var Ow = function(key, config) { | |
| key = key.a(); | |
| /** @type {!Array} */ | |
| var classes = [key, "horizontal" == config.Sd ? key + "-horizontal" : key + "-vertical"]; | |
| if (!config.isEnabled()) { | |
| classes.push(key + "-disabled"); | |
| } | |
| return classes; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var Sw = function() { | |
| return "vertical"; | |
| }; | |
| /** | |
| * @param {string} firename | |
| * @param {string} fn | |
| * @param {?} disposer | |
| * @return {undefined} | |
| */ | |
| var Tw = function(firename, fn, disposer) { | |
| zq.call(this, disposer); | |
| this.ld = fn || Mw.N(); | |
| this.Sd = firename || Sw(); | |
| }; | |
| x(Tw, zq); | |
| k = Tw.prototype; | |
| /** @type {null} */ | |
| k.ue = null; | |
| /** @type {null} */ | |
| k.ef = null; | |
| /** @type {null} */ | |
| k.ld = null; | |
| /** @type {null} */ | |
| k.Sd = null; | |
| /** @type {boolean} */ | |
| k.Sc = true; | |
| /** @type {boolean} */ | |
| k.kd = true; | |
| /** @type {boolean} */ | |
| k.Kd = true; | |
| /** @type {number} */ | |
| k.Oa = -1; | |
| /** @type {null} */ | |
| k.mb = null; | |
| /** @type {boolean} */ | |
| k.Vc = false; | |
| /** @type {null} */ | |
| k.Nc = null; | |
| /** | |
| * @param {!Object} target | |
| * @return {?} | |
| */ | |
| var Uw = function(target) { | |
| return target.ue || target.j(); | |
| }; | |
| /** | |
| * @param {!Object} that | |
| * @param {!Object} b | |
| * @return {undefined} | |
| */ | |
| var Xw = function(that, b) { | |
| if (that.Kd) { | |
| var iptWrapper = Uw(that); | |
| var previousButtonBar = that.Ba; | |
| /** @type {!Object} */ | |
| that.ue = b; | |
| var QueryLanguageComponent = Uw(that); | |
| if (previousButtonBar) { | |
| that.ue = iptWrapper; | |
| Vw(that, false); | |
| /** @type {!Object} */ | |
| that.ue = b; | |
| Mq(Ww(that), QueryLanguageComponent); | |
| Vw(that, true); | |
| } | |
| } else { | |
| throw Error("Can't set key event target for container that doesn't support keyboard focus!"); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} t | |
| * @return {?} | |
| */ | |
| var Ww = function(t) { | |
| return t.ef || (t.ef = new Nq(Uw(t))); | |
| }; | |
| k = Tw.prototype; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.Ra = function() { | |
| this.v = this.ld.m(this); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.oc = function() { | |
| return this.ld.h(this.j()); | |
| }; | |
| /** | |
| * @param {!Array} file | |
| * @return {?} | |
| */ | |
| k.jd = function(file) { | |
| return this.ld.b(file); | |
| }; | |
| /** | |
| * @param {!Object} r | |
| * @return {undefined} | |
| */ | |
| k.Fa = function(r) { | |
| this.v = Rw(this.ld, this, r); | |
| if ("none" == r.style.display) { | |
| /** @type {boolean} */ | |
| this.Sc = false; | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.ia = function() { | |
| Tw.D.ia.call(this); | |
| Hq(this, function(advform) { | |
| if (advform.Ba) { | |
| Yw(this, advform); | |
| } | |
| }, this); | |
| var header = this.j(); | |
| this.ld.o(this); | |
| this.setVisible(this.Sc, true); | |
| Y(this).M(this, "enter", this.sh).M(this, "highlight", this.cf).M(this, "unhighlight", this.mh).M(this, "open", this.Dm).M(this, "close", this.gm).M(header, rg.Oe, this.Fb).M(hf(header), [rg.Pe, rg.Ne], this.um).M(header, [rg.Oe, rg.Pe, rg.Ne, "mouseover", "mouseout", "contextmenu"], this.mm); | |
| if (this.Kd) { | |
| Vw(this, true); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @param {boolean} isKanban | |
| * @return {undefined} | |
| */ | |
| var Vw = function(data, isKanban) { | |
| var item = Y(data); | |
| var x = Uw(data); | |
| if (isKanban) { | |
| item.M(x, "focus", data.dj).M(x, "blur", data.Xf).M(Ww(data), "key", data.ib); | |
| } else { | |
| item.Ma(x, "focus", data.dj).Ma(x, "blur", data.Xf).Ma(Ww(data), "key", data.ib); | |
| } | |
| }; | |
| k = Tw.prototype; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.xb = function() { | |
| this.Ic(-1); | |
| if (this.mb) { | |
| this.mb.bb(false); | |
| } | |
| /** @type {boolean} */ | |
| this.Vc = false; | |
| Tw.D.xb.call(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.X = function() { | |
| Tw.D.X.call(this); | |
| if (this.ef) { | |
| this.ef.Qa(); | |
| /** @type {null} */ | |
| this.ef = null; | |
| } | |
| /** @type {null} */ | |
| this.ld = this.mb = this.Nc = this.ue = null; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.sh = function() { | |
| return true; | |
| }; | |
| /** | |
| * @param {!Event} e | |
| * @return {undefined} | |
| */ | |
| k.cf = function(e) { | |
| var m = Lq(this, e.target); | |
| if (-1 < m && m != this.Oa) { | |
| var out = Zw(this); | |
| if (out) { | |
| ur(out, false); | |
| } | |
| this.Oa = m; | |
| out = Zw(this); | |
| if (this.Vc) { | |
| tr(out, true); | |
| } | |
| if (this.mb && out != this.mb) { | |
| if (br(out, 64)) { | |
| out.bb(true); | |
| } else { | |
| this.mb.bb(false); | |
| } | |
| } | |
| } | |
| m = this.j(); | |
| z(m, "The DOM element for the container cannot be null."); | |
| if (null != e.target.j()) { | |
| np(m, "activedescendant", e.target.j().id); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} dd | |
| * @return {undefined} | |
| */ | |
| k.mh = function(dd) { | |
| if (dd.target == Zw(this)) { | |
| /** @type {number} */ | |
| this.Oa = -1; | |
| } | |
| dd = this.j(); | |
| z(dd, "The DOM element for the container cannot be null."); | |
| dd.removeAttribute(mp("activedescendant")); | |
| }; | |
| /** | |
| * @param {?} node | |
| * @return {undefined} | |
| */ | |
| k.Dm = function(node) { | |
| if ((node = node.target) && node != this.mb && node.getParent() == this) { | |
| if (this.mb) { | |
| this.mb.bb(false); | |
| } | |
| this.mb = node; | |
| } | |
| }; | |
| /** | |
| * @param {!Event} to | |
| * @return {undefined} | |
| */ | |
| k.gm = function(to) { | |
| if (to.target == this.mb) { | |
| /** @type {null} */ | |
| this.mb = null; | |
| } | |
| var j = this.j(); | |
| var p = to.target.j(); | |
| if (j && to.target.Ha(2) && p) { | |
| qp(j, p); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} event | |
| * @return {undefined} | |
| */ | |
| k.Fb = function(event) { | |
| if (this.kd) { | |
| /** @type {boolean} */ | |
| this.Vc = true; | |
| } | |
| var t = Uw(this); | |
| if (t && Yf(t) && Zf(t)) { | |
| t.focus(); | |
| } else { | |
| event.preventDefault(); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.um = function() { | |
| /** @type {boolean} */ | |
| this.Vc = false; | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @return {undefined} | |
| */ | |
| k.mm = function(e) { | |
| a: { | |
| var t = e.target; | |
| if (this.Nc) { | |
| var touch = this.j(); | |
| for (; t && t !== touch;) { | |
| var id = t.id; | |
| if (id in this.Nc) { | |
| t = this.Nc[id]; | |
| break a; | |
| } | |
| t = t.parentNode; | |
| } | |
| } | |
| /** @type {null} */ | |
| t = null; | |
| } | |
| if (t) { | |
| switch(e.type) { | |
| case rg.Oe: | |
| t.Fb(e); | |
| break; | |
| case rg.Pe: | |
| case rg.Ne: | |
| t.Nb(e); | |
| break; | |
| case "mouseover": | |
| t.ph(e); | |
| break; | |
| case "mouseout": | |
| t.wh(e); | |
| break; | |
| case "contextmenu": | |
| t.hf(e); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.dj = function() { | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.Xf = function() { | |
| this.Ic(-1); | |
| /** @type {boolean} */ | |
| this.Vc = false; | |
| if (this.mb) { | |
| this.mb.bb(false); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @return {?} | |
| */ | |
| k.ib = function(e) { | |
| return this.isEnabled() && this.isVisible() && (0 != Iq(this) || this.ue) && this.df(e) ? (e.preventDefault(), e.stopPropagation(), true) : false; | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @return {?} | |
| */ | |
| k.df = function(e) { | |
| var options = Zw(this); | |
| if (options && "function" == typeof options.ib && options.ib(e) || this.mb && this.mb != options && "function" == typeof this.mb.ib && this.mb.ib(e)) { | |
| return true; | |
| } | |
| if (e.shiftKey || e.ctrlKey || e.metaKey || e.altKey) { | |
| return false; | |
| } | |
| switch(e.keyCode) { | |
| case 27: | |
| if (this.Kd) { | |
| Uw(this).blur(); | |
| } else { | |
| return false; | |
| } | |
| break; | |
| case 36: | |
| $w(this); | |
| break; | |
| case 35: | |
| ax(this); | |
| break; | |
| case 38: | |
| if ("vertical" == this.Sd) { | |
| bx(this); | |
| } else { | |
| return false; | |
| } | |
| break; | |
| case 37: | |
| if ("horizontal" == this.Sd) { | |
| if (Kq(this)) { | |
| cx(this); | |
| } else { | |
| bx(this); | |
| } | |
| } else { | |
| return false; | |
| } | |
| break; | |
| case 40: | |
| if ("vertical" == this.Sd) { | |
| cx(this); | |
| } else { | |
| return false; | |
| } | |
| break; | |
| case 39: | |
| if ("horizontal" == this.Sd) { | |
| if (Kq(this)) { | |
| bx(this); | |
| } else { | |
| cx(this); | |
| } | |
| } else { | |
| return false; | |
| } | |
| break; | |
| default: | |
| return false; | |
| } | |
| return true; | |
| }; | |
| /** | |
| * @param {?} chart | |
| * @param {!Object} f | |
| * @return {undefined} | |
| */ | |
| var Yw = function(chart, f) { | |
| var s = f.j(); | |
| s = s.id || (s.id = Bq(f)); | |
| if (!chart.Nc) { | |
| chart.Nc = {}; | |
| } | |
| /** @type {!Object} */ | |
| chart.Nc[s] = f; | |
| }; | |
| /** | |
| * @param {?} root | |
| * @param {boolean} query | |
| * @return {undefined} | |
| */ | |
| Tw.prototype.qb = function(root, query) { | |
| ib(root, lr, "The child of a container must be a control"); | |
| Tw.D.qb.call(this, root, query); | |
| }; | |
| /** | |
| * @param {number} b | |
| * @param {?} a | |
| * @param {string} indent | |
| * @return {undefined} | |
| */ | |
| Tw.prototype.Gd = function(b, a, indent) { | |
| ib(b, lr); | |
| b.rf |= 2; | |
| b.rf |= 64; | |
| b.Sa(32, false); | |
| nr(b, false); | |
| var nativeObjectObject = b.getParent() == this ? Lq(this, b) : -1; | |
| Tw.D.Gd.call(this, b, a, indent); | |
| if (b.Ba && this.Ba) { | |
| Yw(this, b); | |
| } | |
| b = nativeObjectObject; | |
| if (-1 == b) { | |
| b = Iq(this); | |
| } | |
| if (b == this.Oa) { | |
| /** @type {number} */ | |
| this.Oa = Math.min(Iq(this) - 1, a); | |
| } else { | |
| if (b > this.Oa && a <= this.Oa) { | |
| this.Oa++; | |
| } else { | |
| if (b < this.Oa && a > this.Oa) { | |
| this.Oa--; | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @param {boolean} value | |
| * @return {?} | |
| */ | |
| Tw.prototype.removeChild = function(e, value) { | |
| e = r(e) ? Eq(this, e) : e; | |
| ib(e, lr); | |
| if (e) { | |
| var config = Lq(this, e); | |
| if (-1 != config) { | |
| if (config == this.Oa) { | |
| ur(e, false); | |
| /** @type {number} */ | |
| this.Oa = -1; | |
| } else { | |
| if (config < this.Oa) { | |
| this.Oa--; | |
| } | |
| } | |
| } | |
| var token = e.j(); | |
| if (token && token.id && this.Nc) { | |
| config = this.Nc; | |
| token = token.id; | |
| if (token in config) { | |
| delete config[token]; | |
| } | |
| } | |
| } | |
| e = Tw.D.removeChild.call(this, e, value); | |
| nr(e, true); | |
| return e; | |
| }; | |
| /** | |
| * @param {!Object} params | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| var Pw = function(params, name) { | |
| if (params.j()) { | |
| throw Error("Component already rendered"); | |
| } | |
| /** @type {string} */ | |
| params.Sd = name; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Tw.prototype.isVisible = function() { | |
| return this.Sc; | |
| }; | |
| /** | |
| * @param {boolean} v | |
| * @param {number} name | |
| * @return {?} | |
| */ | |
| Tw.prototype.setVisible = function(v, name) { | |
| if (name || this.Sc != v && this.dispatchEvent(v ? "show" : "hide")) { | |
| /** @type {boolean} */ | |
| this.Sc = v; | |
| var m3 = this.j(); | |
| if (m3) { | |
| X(m3, v); | |
| if (this.Kd) { | |
| Nw(Uw(this), this.kd && this.Sc); | |
| } | |
| if (!name) { | |
| this.dispatchEvent(this.Sc ? "aftershow" : "afterhide"); | |
| } | |
| } | |
| return true; | |
| } | |
| return false; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Tw.prototype.isEnabled = function() { | |
| return this.kd; | |
| }; | |
| /** | |
| * @param {boolean} enable | |
| * @return {undefined} | |
| */ | |
| Tw.prototype.sa = function(enable) { | |
| if (this.kd != enable && this.dispatchEvent(enable ? "enable" : "disable")) { | |
| if (enable) { | |
| /** @type {boolean} */ | |
| this.kd = true; | |
| Hq(this, function(td1) { | |
| if (td1.qk) { | |
| delete td1.qk; | |
| } else { | |
| td1.sa(true); | |
| } | |
| }); | |
| } else { | |
| Hq(this, function(option) { | |
| if (option.isEnabled()) { | |
| option.sa(false); | |
| } else { | |
| /** @type {boolean} */ | |
| option.qk = true; | |
| } | |
| }); | |
| /** @type {boolean} */ | |
| this.Vc = this.kd = false; | |
| } | |
| if (this.Kd) { | |
| Nw(Uw(this), enable && this.Sc); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} row | |
| * @param {boolean} value | |
| * @return {undefined} | |
| */ | |
| var dx = function(row, value) { | |
| if (value != row.Kd && row.Ba) { | |
| Vw(row, value); | |
| } | |
| /** @type {boolean} */ | |
| row.Kd = value; | |
| if (row.kd && row.Sc) { | |
| Nw(Uw(row), value); | |
| } | |
| }; | |
| /** | |
| * @param {number} i | |
| * @return {undefined} | |
| */ | |
| Tw.prototype.Ic = function(i) { | |
| if (i = Jq(this, i)) { | |
| ur(i, true); | |
| } else { | |
| if (-1 < this.Oa) { | |
| ur(Zw(this), false); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var Zw = function(a) { | |
| return Jq(a, a.Oa); | |
| }; | |
| /** | |
| * @param {!Object} string | |
| * @return {undefined} | |
| */ | |
| var $w = function(string) { | |
| ex(string, function(arcIndex, steps) { | |
| return (arcIndex + 1) % steps; | |
| }, Iq(string) - 1); | |
| }; | |
| /** | |
| * @param {!Object} n | |
| * @return {undefined} | |
| */ | |
| var ax = function(n) { | |
| ex(n, function(b, a) { | |
| b--; | |
| return 0 > b ? a - 1 : b; | |
| }, 0); | |
| }; | |
| /** | |
| * @param {!Object} i | |
| * @return {undefined} | |
| */ | |
| var cx = function(i) { | |
| ex(i, function(arcIndex, steps) { | |
| return (arcIndex + 1) % steps; | |
| }, i.Oa); | |
| }; | |
| /** | |
| * @param {!Object} arr | |
| * @return {undefined} | |
| */ | |
| var bx = function(arr) { | |
| ex(arr, function(b, a) { | |
| b--; | |
| return 0 > b ? a - 1 : b; | |
| }, arr.Oa); | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @param {!Function} f | |
| * @param {number} i | |
| * @return {undefined} | |
| */ | |
| var ex = function(b, f, i) { | |
| i = 0 > i ? Lq(b, b.mb) : i; | |
| var el = Iq(b); | |
| i = f.call(b, i, el); | |
| /** @type {number} */ | |
| var e = 0; | |
| for (; e <= el;) { | |
| var a = Jq(b, i); | |
| if (a && b.Mi(a)) { | |
| b.Ic(i); | |
| break; | |
| } | |
| e++; | |
| i = f.call(b, i, el); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| Tw.prototype.Mi = function(a) { | |
| return a.isVisible() && a.isEnabled() && br(a, 2); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var fx = function() { | |
| }; | |
| x(fx, Uq); | |
| Ia(fx); | |
| /** | |
| * @return {?} | |
| */ | |
| fx.prototype.za = function() { | |
| return "goog-menuheader"; | |
| }; | |
| /** | |
| * @param {?} path | |
| * @param {?} scope | |
| * @param {?} options | |
| * @return {undefined} | |
| */ | |
| var gx = function(path, scope, options) { | |
| lr.call(this, path, options || fx.N(), scope); | |
| this.Sa(1, false); | |
| this.Sa(2, false); | |
| this.Sa(4, false); | |
| this.Sa(32, false); | |
| /** @type {number} */ | |
| this.qd = 1; | |
| }; | |
| x(gx, lr); | |
| jr("goog-menuheader", function() { | |
| return new gx(null); | |
| }); | |
| /** | |
| * @return {undefined} | |
| */ | |
| var hx = function() { | |
| /** @type {!Array} */ | |
| this.c = []; | |
| }; | |
| x(hx, Uq); | |
| Ia(hx); | |
| /** | |
| * @param {?} path | |
| * @param {number} i | |
| * @return {?} | |
| */ | |
| var ix = function(path, i) { | |
| var parent = path.c[i]; | |
| if (!parent) { | |
| switch(i) { | |
| case 0: | |
| parent = path.za() + "-highlight"; | |
| break; | |
| case 1: | |
| parent = path.za() + "-checkbox"; | |
| break; | |
| case 2: | |
| parent = path.za() + "-content"; | |
| } | |
| path.c[i] = parent; | |
| } | |
| return parent; | |
| }; | |
| k = hx.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| k.nd = function() { | |
| return "menuitem"; | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| k.Eb = function(b) { | |
| var navButtonDiv = b.a.b("DIV", Xq(this, b).join(" "), jx(this, b.Ya(), b.a)); | |
| kx(this, b, navButtonDiv, br(b, 8) || br(b, 16)); | |
| return navButtonDiv; | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @return {?} | |
| */ | |
| k.fc = function(e) { | |
| return e && e.firstChild; | |
| }; | |
| /** | |
| * @param {!Object} chunk | |
| * @param {!Object} n | |
| * @return {?} | |
| */ | |
| k.eb = function(chunk, n) { | |
| z(n); | |
| var w = Mf(n); | |
| var formArgs = ix(this, 2); | |
| if (!(w && tp(w, formArgs))) { | |
| n.appendChild(jx(this, n.childNodes, chunk.a)); | |
| } | |
| if (tp(n, "goog-option")) { | |
| chunk.Sa(16, true); | |
| if (chunk && n) { | |
| kx(this, chunk, n, true); | |
| } | |
| } | |
| return hx.D.eb.call(this, chunk, n); | |
| }; | |
| /** | |
| * @param {!Element} b | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| k.qc = function(b, a) { | |
| var c = this.fc(b); | |
| var d = lx(this, b) ? c.firstChild : null; | |
| hx.D.qc.call(this, b, a); | |
| if (d && !lx(this, b)) { | |
| c.insertBefore(d, c.firstChild || null); | |
| } | |
| }; | |
| /** | |
| * @param {boolean} t | |
| * @param {string} f | |
| * @param {!Object} self | |
| * @return {?} | |
| */ | |
| var jx = function(t, f, self) { | |
| t = ix(t, 2); | |
| return self.b("DIV", t, f); | |
| }; | |
| /** | |
| * @param {boolean} b | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var lx = function(b, a) { | |
| return (a = b.fc(a)) ? (a = a.firstChild, b = ix(b, 1), !!a && Nf(a) && tp(a, b)) : false; | |
| }; | |
| /** | |
| * @param {boolean} a | |
| * @param {!Object} o | |
| * @param {!Object} el | |
| * @param {string} t | |
| * @return {undefined} | |
| */ | |
| var kx = function(a, o, el, t) { | |
| ar(a, el, o.C()); | |
| cr(a, o, el); | |
| if (t != lx(a, el)) { | |
| V(el, "goog-option", t); | |
| el = a.fc(el); | |
| if (t) { | |
| a = ix(a, 1); | |
| el.insertBefore(o.a.b("DIV", a), el.firstChild || null); | |
| } else { | |
| el.removeChild(el.firstChild); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {?} | |
| */ | |
| hx.prototype.a = function(type) { | |
| switch(type) { | |
| case 2: | |
| return ix(this, 0); | |
| case 16: | |
| case 8: | |
| return "goog-option-selected"; | |
| default: | |
| return hx.D.a.call(this, type); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {?} | |
| */ | |
| hx.prototype.g = function(name) { | |
| var handleEventAtTarget = ix(this, 0); | |
| switch(name) { | |
| case "goog-option-selected": | |
| return 16; | |
| case handleEventAtTarget: | |
| return 2; | |
| default: | |
| return hx.D.g.call(this, name); | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| hx.prototype.za = function() { | |
| return "goog-menuitem"; | |
| }; | |
| /** | |
| * @param {?} items | |
| * @param {?} data | |
| * @param {?} init | |
| * @param {?} end | |
| * @return {undefined} | |
| */ | |
| var mx = function(items, data, init, end) { | |
| lr.call(this, items, end || hx.N(), init); | |
| this.oa = data; | |
| }; | |
| x(mx, lr); | |
| k = mx.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| k.aa = function() { | |
| var a = this.oa; | |
| return null != a ? a : this.Bb(); | |
| }; | |
| /** | |
| * @param {number} i | |
| * @param {boolean} b | |
| * @return {undefined} | |
| */ | |
| k.Sa = function(i, b) { | |
| mx.D.Sa.call(this, i, b); | |
| switch(i) { | |
| case 8: | |
| if (this.Ha(16) && !b) { | |
| this.wd(false); | |
| } | |
| if ((i = this.j()) && this && i) { | |
| kx(this.c, this, i, b); | |
| } | |
| break; | |
| case 16: | |
| if ((i = this.j()) && this && i) { | |
| kx(this.c, this, i, b); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Bb = function() { | |
| var a = this.Ya(); | |
| return Ka(a) ? (a = mb(a, function(iframe) { | |
| return Nf(iframe) && (tp(iframe, "goog-menuitem-accel") || tp(iframe, "goog-menuitem-mnemonic-separator")) ? "" : bg(iframe); | |
| }).join(""), ce(a)) : mx.D.Bb.call(this); | |
| }; | |
| /** | |
| * @param {!Object} event | |
| * @return {undefined} | |
| */ | |
| k.Nb = function(event) { | |
| var spot = this.getParent(); | |
| if (spot) { | |
| var x = spot.ea; | |
| /** @type {null} */ | |
| spot.ea = null; | |
| if (x && Aa(event.clientX) && df(x, new cf(event.clientX, event.clientY))) { | |
| return; | |
| } | |
| } | |
| mx.D.Nb.call(this, event); | |
| }; | |
| /** | |
| * @param {!Object} event | |
| * @return {?} | |
| */ | |
| k.me = function(event) { | |
| return event.keyCode == this.Cj && this.rd(event) ? true : mx.D.me.call(this, event); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.dm = function() { | |
| return this.Cj; | |
| }; | |
| jr("goog-menuitem", function() { | |
| return new mx(null); | |
| }); | |
| /** | |
| * @return {?} | |
| */ | |
| mx.prototype.C = function() { | |
| return br(this, 16) ? "menuitemcheckbox" : br(this, 8) ? "menuitemradio" : mx.D.C.call(this); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| mx.prototype.getParent = function() { | |
| return lr.prototype.getParent.call(this); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| mx.prototype.Nf = function() { | |
| return lr.prototype.Nf.call(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var nx = function() { | |
| }; | |
| x(nx, Uq); | |
| Ia(nx); | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| nx.prototype.Eb = function(a) { | |
| return a.a.b("DIV", this.za()); | |
| }; | |
| /** | |
| * @param {!Object} m | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| nx.prototype.eb = function(m, value) { | |
| if (value.id) { | |
| Cq(m, value.id); | |
| } | |
| if ("HR" == value.tagName) { | |
| /** @type {!Object} */ | |
| var c = value; | |
| value = this.Eb(m); | |
| Gf(value, c); | |
| Jf(c); | |
| } else { | |
| T(value, this.za()); | |
| } | |
| return value; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| nx.prototype.qc = function() { | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| nx.prototype.za = function() { | |
| return "goog-menuseparator"; | |
| }; | |
| /** | |
| * @param {?} this__3994__auto__ | |
| * @param {?} entry__3995__auto__ | |
| * @return {undefined} | |
| */ | |
| var ox = function(this__3994__auto__, entry__3995__auto__) { | |
| lr.call(this, null, this__3994__auto__ || nx.N(), entry__3995__auto__); | |
| this.Sa(1, false); | |
| this.Sa(2, false); | |
| this.Sa(4, false); | |
| this.Sa(32, false); | |
| /** @type {number} */ | |
| this.qd = 1; | |
| }; | |
| x(ox, lr); | |
| /** | |
| * @return {undefined} | |
| */ | |
| ox.prototype.ia = function() { | |
| ox.D.ia.call(this); | |
| var p = this.j(); | |
| z(p, "The DOM element for the separator cannot be null."); | |
| lp(p, "separator"); | |
| }; | |
| jr("goog-menuseparator", function() { | |
| return new ox; | |
| }); | |
| /** | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| var px = function(value) { | |
| this.c = value || "menu"; | |
| }; | |
| x(px, Mw); | |
| Ia(px); | |
| /** | |
| * @param {!Object} type | |
| * @return {?} | |
| */ | |
| px.prototype.b = function(type) { | |
| return "UL" == type.tagName || px.D.b.call(this, type); | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {?} | |
| */ | |
| px.prototype.g = function(type) { | |
| return "HR" == type.tagName ? new ox : px.D.g.call(this, type); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| px.prototype.a = function() { | |
| return "goog-menu"; | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| px.prototype.o = function(name) { | |
| px.D.o.call(this, name); | |
| name = name.j(); | |
| z(name, "The menu DOM element cannot be null."); | |
| np(name, "haspopup", "true"); | |
| }; | |
| /** | |
| * @param {?} data | |
| * @return {undefined} | |
| */ | |
| var qx = function(data) { | |
| ox.call(this, nx.N(), data); | |
| }; | |
| x(qx, ox); | |
| jr("goog-menuseparator", function() { | |
| return new ox; | |
| }); | |
| /** | |
| * @param {?} zoom | |
| * @param {?} rx | |
| * @return {undefined} | |
| */ | |
| var rx = function(zoom, rx) { | |
| Tw.call(this, "vertical", rx || px.N(), zoom); | |
| dx(this, false); | |
| }; | |
| x(rx, Tw); | |
| /** @type {boolean} */ | |
| rx.prototype.O = true; | |
| /** | |
| * @param {!Object} m | |
| * @param {boolean} b | |
| * @return {?} | |
| */ | |
| var sx = function(m, b) { | |
| if (Pf(m.j(), b)) { | |
| return true; | |
| } | |
| /** @type {number} */ | |
| var j = 0; | |
| var d = Iq(m); | |
| for (; j < d; j++) { | |
| var a = Jq(m, j); | |
| if ("function" == typeof a.rh && a.rh(b)) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| }; | |
| k = rx.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| k.sb = function() { | |
| return Iq(this); | |
| }; | |
| /** | |
| * @param {string} b | |
| * @param {?} v | |
| * @param {!Object} c | |
| * @return {?} | |
| */ | |
| k.setVisible = function(b, v, c) { | |
| if ((v = rx.D.setVisible.call(this, b, v)) && b && this.Ba && this.O) { | |
| Uw(this).focus(); | |
| } | |
| if (b && c && Aa(c.clientX)) { | |
| this.ea = new cf(c.clientX, c.clientY); | |
| } else { | |
| /** @type {null} */ | |
| this.ea = null; | |
| } | |
| return v; | |
| }; | |
| /** | |
| * @param {?} args | |
| * @return {?} | |
| */ | |
| k.sh = function(args) { | |
| if (this.O) { | |
| Uw(this).focus(); | |
| } | |
| return rx.D.sh.call(this, args); | |
| }; | |
| /** | |
| * @param {!Object} cX1 | |
| * @return {undefined} | |
| */ | |
| k.qj = function(cX1) { | |
| /** @type {!RegExp} */ | |
| var child = new RegExp("^" + ke(cX1), "i"); | |
| ex(this, function(c, Base) { | |
| var center = 0 > c ? 0 : c; | |
| /** @type {boolean} */ | |
| var fitSupport = false; | |
| do { | |
| ++c; | |
| if (c == Base) { | |
| /** @type {number} */ | |
| c = 0; | |
| /** @type {boolean} */ | |
| fitSupport = true; | |
| } | |
| var environment = Jq(this, c).Bb(); | |
| if (environment && environment.match(child)) { | |
| return c; | |
| } | |
| } while (!fitSupport || c != center); | |
| return this.Oa; | |
| }, this.Oa); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| k.Mi = function(a) { | |
| return a.isEnabled() && a.isVisible() && br(a, 2); | |
| }; | |
| /** | |
| * @param {!Array} f | |
| * @return {undefined} | |
| */ | |
| k.Fa = function(f) { | |
| var b = this.ld; | |
| var cs = mf(this.a.a, "DIV", b.a() + "-content", f); | |
| var pos = cs.length; | |
| /** @type {number} */ | |
| var p = 0; | |
| for (; p < pos; p++) { | |
| Qw(b, this, cs[p]); | |
| } | |
| rx.D.Fa.call(this, f); | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @return {?} | |
| */ | |
| k.df = function(e) { | |
| var err = rx.D.df.call(this, e); | |
| if (!err) { | |
| Hq(this, function(self) { | |
| if (!err && self.dm && self.Cj == e.keyCode) { | |
| if (this.isEnabled()) { | |
| this.Ic(Lq(this, self)); | |
| } | |
| err = self.ib(e); | |
| } | |
| }, this); | |
| } | |
| return err; | |
| }; | |
| /** | |
| * @param {!Object} start | |
| * @return {undefined} | |
| */ | |
| k.Ic = function(start) { | |
| rx.D.Ic.call(this, start); | |
| if (start = Jq(this, start)) { | |
| Wp(start.j(), this.j()); | |
| } | |
| }; | |
| /** | |
| * @param {?} a | |
| * @param {?} b | |
| * @param {?} rev | |
| * @return {undefined} | |
| */ | |
| var ux = function(a, b, rev) { | |
| mx.call(this, a, b, rev); | |
| this.Sa(8, true); | |
| }; | |
| x(ux, mx); | |
| /** | |
| * @return {?} | |
| */ | |
| ux.prototype.rd = function() { | |
| return this.dispatchEvent("action"); | |
| }; | |
| jr("goog-option", function() { | |
| return new ux(null); | |
| }); | |
| /** | |
| * @param {number} a | |
| * @param {string} scalar | |
| * @param {number} array | |
| * @return {undefined} | |
| */ | |
| var vx = function(a, scalar, array) { | |
| /** @type {number} */ | |
| this.a = a; | |
| /** @type {string} */ | |
| this.g = scalar; | |
| /** @type {number} */ | |
| this.w = array; | |
| }; | |
| x(vx, Lr); | |
| /** | |
| * @param {!Object} type | |
| * @param {string} value | |
| * @param {string} input | |
| * @return {undefined} | |
| */ | |
| vx.prototype.c = function(type, value, input) { | |
| Kr(this.a, this.g, type, value, void 0, input, this.w); | |
| }; | |
| /** | |
| * @param {?} api | |
| * @param {?} next | |
| * @param {boolean} data | |
| * @param {string} req | |
| * @return {undefined} | |
| */ | |
| var wx = function(api, next, data, req) { | |
| vx.call(this, api, next); | |
| /** @type {number} */ | |
| this.h = data ? 5 : 0; | |
| this.o = req || void 0; | |
| }; | |
| x(wx, vx); | |
| /** | |
| * @return {?} | |
| */ | |
| wx.prototype.m = function() { | |
| return this.h; | |
| }; | |
| /** | |
| * @param {!Function} name | |
| * @return {undefined} | |
| */ | |
| wx.prototype.b = function(name) { | |
| /** @type {!Function} */ | |
| this.h = name; | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @param {string} value | |
| * @param {string} input | |
| * @param {string} result | |
| * @return {undefined} | |
| */ | |
| wx.prototype.c = function(name, value, input, result) { | |
| var index = Kr(this.a, this.g, name, value, null, input, 10, result, this.o); | |
| if (index & 496) { | |
| var max = xx(index, this.g); | |
| value = xx(index, value); | |
| index = Kr(this.a, max, name, value, null, input, 10, result, this.o); | |
| if (index & 496) { | |
| max = xx(index, max); | |
| value = xx(index, value); | |
| Kr(this.a, max, name, value, null, input, this.h, result, this.o); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {number} a | |
| * @param {number} d | |
| * @return {?} | |
| */ | |
| var xx = function(a, d) { | |
| if (a & 48) { | |
| /** @type {number} */ | |
| d = d ^ 4; | |
| } | |
| if (a & 192) { | |
| /** @type {number} */ | |
| d = d ^ 1; | |
| } | |
| return d; | |
| }; | |
| /** | |
| * @param {?} data | |
| * @param {?} undefined | |
| * @param {boolean} opts | |
| * @param {boolean} options | |
| * @return {undefined} | |
| */ | |
| var yx = function(data, undefined, opts, options) { | |
| wx.call(this, data, undefined, opts || options); | |
| if (opts || options) { | |
| this.b(65 | (options ? 32 : 132)); | |
| } | |
| }; | |
| x(yx, wx); | |
| /** | |
| * @return {undefined} | |
| */ | |
| var zx = function() { | |
| }; | |
| x(zx, nt); | |
| Ia(zx); | |
| /** | |
| * @param {!Object} parent | |
| * @return {?} | |
| */ | |
| zx.prototype.fc = function(parent) { | |
| return zx.D.fc.call(this, parent && parent.firstChild); | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @param {!Object} f | |
| * @return {?} | |
| */ | |
| zx.prototype.eb = function(options, f) { | |
| var str = mf(document, "*", "goog-menu", f)[0]; | |
| if (str) { | |
| X(str, false); | |
| Df(hf(str).body, str); | |
| var data = new rx; | |
| data.na(str); | |
| options.qf(data); | |
| } | |
| return zx.D.eb.call(this, options, f); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @param {!Object} container | |
| * @return {?} | |
| */ | |
| zx.prototype.Ff = function(name, container) { | |
| return zx.D.Ff.call(this, [container.b("DIV", "goog-inline-block " + (this.za() + "-caption"), name), container.b("DIV", "goog-inline-block " + (this.za() + "-dropdown"), "\u00a0")], container); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| zx.prototype.za = function() { | |
| return "goog-menu-button"; | |
| }; | |
| /** | |
| * @param {?} module | |
| * @param {undefined} views | |
| * @param {?} options | |
| * @param {?} d | |
| * @param {!Object} lazyLayout | |
| * @return {undefined} | |
| */ | |
| var Ax = function(module, views, options, d, lazyLayout) { | |
| Br.call(this, module, options || zx.N(), d); | |
| this.Sa(64, true); | |
| this.m = new yx(null, 9); | |
| if (views) { | |
| this.qf(views); | |
| } | |
| /** @type {null} */ | |
| this.ma = null; | |
| this.O = new ai(500); | |
| if (!(!C.product.vc && !C.product.Lc || C.Ea("533.17.9"))) { | |
| /** @type {boolean} */ | |
| this.pg = true; | |
| } | |
| this.Dd = lazyLayout || px.N(); | |
| }; | |
| x(Ax, Br); | |
| k = Ax.prototype; | |
| /** @type {boolean} */ | |
| k.pg = false; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.ia = function() { | |
| Ax.D.ia.call(this); | |
| Bx(this, true); | |
| if (this.b) { | |
| Cx(this, this.b, true); | |
| } | |
| np(Dq(this), "haspopup", !!this.b); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.xb = function() { | |
| Ax.D.xb.call(this); | |
| Bx(this, false); | |
| if (this.b) { | |
| this.bb(false); | |
| this.b.xb(); | |
| Cx(this, this.b, false); | |
| var QueryLanguageComponent = this.b.j(); | |
| if (QueryLanguageComponent) { | |
| Jf(QueryLanguageComponent); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.X = function() { | |
| Ax.D.X.call(this); | |
| if (this.b) { | |
| this.b.Qa(); | |
| delete this.b; | |
| } | |
| delete this.Gb; | |
| this.O.Qa(); | |
| }; | |
| /** | |
| * @param {!Object} width | |
| * @return {undefined} | |
| */ | |
| k.Fb = function(width) { | |
| Ax.D.Fb.call(this, width); | |
| if (this.tb()) { | |
| this.bb(!this.Ha(64), width); | |
| if (this.b) { | |
| this.b.Vc = this.Ha(64); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} key_event | |
| * @return {undefined} | |
| */ | |
| k.Nb = function(key_event) { | |
| Ax.D.Nb.call(this, key_event); | |
| if (this.b && !this.tb()) { | |
| /** @type {boolean} */ | |
| this.b.Vc = false; | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.rd = function() { | |
| tr(this, false); | |
| return true; | |
| }; | |
| /** | |
| * @param {!Event} mutationEvent | |
| * @return {undefined} | |
| */ | |
| k.tm = function(mutationEvent) { | |
| if (this.b && this.b.isVisible() && !this.rh(mutationEvent.target)) { | |
| this.bb(false); | |
| } | |
| }; | |
| /** | |
| * @param {boolean} b | |
| * @return {?} | |
| */ | |
| k.rh = function(b) { | |
| return b && Pf(this.j(), b) || this.b && sx(this.b, b) || false; | |
| }; | |
| /** | |
| * @param {!Object} params | |
| * @return {?} | |
| */ | |
| k.me = function(params) { | |
| if (32 == params.keyCode) { | |
| if (params.preventDefault(), "keyup" != params.type) { | |
| return true; | |
| } | |
| } else { | |
| if ("key" != params.type) { | |
| return false; | |
| } | |
| } | |
| if (this.b && this.b.isVisible()) { | |
| /** @type {boolean} */ | |
| var isKYCDocument = 13 == params.keyCode || 32 == params.keyCode; | |
| var sidebar = this.b.ib(params); | |
| return 27 == params.keyCode || isKYCDocument ? (this.bb(false), true) : sidebar; | |
| } | |
| return 40 == params.keyCode || 38 == params.keyCode || 32 == params.keyCode || 13 == params.keyCode ? (this.bb(true, params), true) : false; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.uh = function() { | |
| this.bb(false); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.Bm = function() { | |
| if (!this.tb()) { | |
| this.bb(false); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| k.Zf = function(a) { | |
| if (!this.pg) { | |
| this.bb(false); | |
| } | |
| Ax.D.Zf.call(this, a); | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @return {?} | |
| */ | |
| var Dx = function(options) { | |
| if (!options.b) { | |
| options.qf(new rx(options.a, options.Dd)); | |
| } | |
| return options.b || null; | |
| }; | |
| /** | |
| * @param {string} options | |
| * @return {?} | |
| */ | |
| Ax.prototype.qf = function(options) { | |
| var e = this.b; | |
| if (options != e && (e && (this.bb(false), this.Ba && Cx(this, e, false), delete this.b), this.Ba && np(Dq(this), "haspopup", !!options), options)) { | |
| /** @type {string} */ | |
| this.b = options; | |
| Fq(options, this); | |
| options.setVisible(false); | |
| var v2pushes = this.pg; | |
| if (options.O = v2pushes) { | |
| dx(options, true); | |
| } | |
| if (this.Ba) { | |
| Cx(this, options, true); | |
| } | |
| } | |
| return e; | |
| }; | |
| /** | |
| * @param {!Object} message | |
| * @param {number} e | |
| * @return {undefined} | |
| */ | |
| var Ex = function(message, e) { | |
| if (e) { | |
| /** @type {number} */ | |
| message.m = e; | |
| message.Gb = e.a; | |
| } | |
| }; | |
| /** | |
| * @param {?} elem | |
| * @param {?} options | |
| * @return {undefined} | |
| */ | |
| var Fx = function(elem, options) { | |
| elem.ma = options; | |
| }; | |
| k = Ax.prototype; | |
| /** | |
| * @param {number} a | |
| * @return {undefined} | |
| */ | |
| k.ff = function(a) { | |
| Dx(this).qb(a, true); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.sb = function() { | |
| return this.b ? Iq(this.b) : 0; | |
| }; | |
| /** | |
| * @param {string} v | |
| * @param {?} key | |
| * @return {?} | |
| */ | |
| k.setVisible = function(v, key) { | |
| if ((v = Ax.D.setVisible.call(this, v, key)) && !this.isVisible()) { | |
| this.bb(false); | |
| } | |
| return v; | |
| }; | |
| /** | |
| * @param {boolean} v | |
| * @return {undefined} | |
| */ | |
| k.sa = function(v) { | |
| Ax.D.sa.call(this, v); | |
| if (!this.isEnabled()) { | |
| this.bb(false); | |
| } | |
| }; | |
| /** | |
| * @param {boolean} a | |
| * @param {!Object} b | |
| * @return {undefined} | |
| */ | |
| k.bb = function(a, b) { | |
| Ax.D.bb.call(this, a); | |
| if (this.b && this.Ha(64) == a) { | |
| if (a) { | |
| if (!this.b.Ba) { | |
| this.b.Za(); | |
| } | |
| this.Hb = Tp(this.j()); | |
| this.jb = bq(this.j()); | |
| Gx(this); | |
| if (!b || 40 != b.keyCode && 38 != b.keyCode) { | |
| this.b.Ic(-1); | |
| } else { | |
| $w(this.b); | |
| } | |
| } else { | |
| tr(this, false); | |
| /** @type {boolean} */ | |
| this.b.Vc = false; | |
| var helper = this.j(); | |
| if (helper) { | |
| np(helper, "activedescendant", ""); | |
| np(helper, "owns", ""); | |
| } | |
| if (null != this.T) { | |
| this.T = void 0; | |
| if (helper = this.b.j()) { | |
| $p(helper, "", ""); | |
| } | |
| } | |
| } | |
| this.b.setVisible(a, false, b); | |
| if (!this.Ac) { | |
| b = Y(this); | |
| helper = a ? b.M : b.Ma; | |
| helper.call(b, this.a.a, "mousedown", this.tm, true); | |
| if (this.pg) { | |
| helper.call(b, this.b, "blur", this.Bm); | |
| } | |
| helper.call(b, this.O, "tick", this.Bd); | |
| if (a) { | |
| this.O.start(); | |
| } else { | |
| this.O.stop(); | |
| } | |
| } | |
| } | |
| if (this.b && this.b.j()) { | |
| Dq(this.b).removeAttribute(mp("hidden")); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} self | |
| * @return {undefined} | |
| */ | |
| var Gx = function(self) { | |
| if (self.b.Ba) { | |
| var b = self.m; | |
| self.m.a = self.Gb || self.j(); | |
| var c = self.b.j(); | |
| if (!self.b.isVisible()) { | |
| /** @type {string} */ | |
| c.style.visibility = "hidden"; | |
| X(c, true); | |
| } | |
| if (!self.T && self.m.m && self.m.h & 32) { | |
| self.T = aq(c); | |
| } | |
| b.c(c, b.g ^ 1, self.ma, self.T); | |
| if (!self.b.isVisible()) { | |
| X(c, false); | |
| /** @type {string} */ | |
| c.style.visibility = "visible"; | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Ax.prototype.Bd = function() { | |
| var b = bq(this.j()); | |
| var bounds = Tp(this.j()); | |
| var a = this.jb; | |
| if (!(a = !(a == b || a && b && a.left == b.left && a.width == b.width && a.top == b.top && a.height == b.height))) { | |
| a = this.Hb; | |
| /** @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.jb = b; | |
| this.Hb = bounds; | |
| Gx(this); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @param {string} fn | |
| * @param {!Object} path | |
| * @return {undefined} | |
| */ | |
| var Cx = function(data, fn, path) { | |
| var item = Y(data); | |
| path = path ? item.M : item.Ma; | |
| path.call(item, fn, "action", data.uh); | |
| path.call(item, fn, "close", data.ic); | |
| path.call(item, fn, "highlight", data.ud); | |
| path.call(item, fn, "unhighlight", data.Ad); | |
| }; | |
| /** | |
| * @param {!Object} v | |
| * @param {string} fn | |
| * @return {undefined} | |
| */ | |
| var Bx = function(v, fn) { | |
| var list = Y(v); | |
| (fn ? list.M : list.Ma).call(list, v.j(), "keydown", v.Cd); | |
| }; | |
| /** | |
| * @param {!Function} target | |
| * @return {undefined} | |
| */ | |
| Ax.prototype.ud = function(target) { | |
| if (target = target.target.j()) { | |
| Hx(this, target); | |
| } | |
| }; | |
| /** | |
| * @param {!Event} event | |
| * @return {undefined} | |
| */ | |
| Ax.prototype.Cd = function(event) { | |
| if (br(this, 32) && this.j() && this.b && this.b.isVisible()) { | |
| event.stopPropagation(); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Ax.prototype.Ad = function() { | |
| if (!Zw(this.b)) { | |
| var m = this.j(); | |
| z(m, "The menu button DOM element cannot be null."); | |
| np(m, "activedescendant", ""); | |
| np(m, "owns", ""); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| Ax.prototype.ic = function(type) { | |
| if (this.Ha(64) && type.target instanceof mx) { | |
| type = type.target; | |
| var list_element_param = type.j(); | |
| if (type.isVisible() && type.Ha(2) && null != list_element_param) { | |
| Hx(this, list_element_param); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @param {string} param | |
| * @return {undefined} | |
| */ | |
| var Hx = function(obj, param) { | |
| obj = obj.j(); | |
| z(obj, "The menu button DOM element cannot be null."); | |
| param = pp(param) || param; | |
| if (!param.id) { | |
| var clonedI = xq.N(); | |
| /** @type {string} */ | |
| param.id = ":" + (clonedI.a++).toString(36); | |
| } | |
| qp(obj, param); | |
| np(obj, "owns", param.id); | |
| }; | |
| jr("goog-menu-button", function() { | |
| return new Ax(null); | |
| }); | |
| /** | |
| * @param {undefined} ver | |
| * @return {undefined} | |
| */ | |
| var Jx = function(ver) { | |
| L.call(this); | |
| /** @type {!Array} */ | |
| this.a = []; | |
| Ix(this, ver); | |
| }; | |
| x(Jx, L); | |
| /** @type {null} */ | |
| Jx.prototype.b = null; | |
| /** | |
| * @return {?} | |
| */ | |
| Jx.prototype.sb = function() { | |
| return this.a.length; | |
| }; | |
| /** | |
| * @param {!Object} context | |
| * @param {!Object} x | |
| * @return {undefined} | |
| */ | |
| var Ix = function(context, x) { | |
| if (x) { | |
| A(x, function(options_obejct) { | |
| Kx(options_obejct, false); | |
| }, context); | |
| Bb(context.a, x); | |
| } | |
| }; | |
| /** | |
| * @param {(number|string)} options | |
| * @param {!Function} b | |
| * @param {?} lg | |
| * @return {undefined} | |
| */ | |
| var Lx = function(options, b, lg) { | |
| if (b) { | |
| Kx(b, false); | |
| Db(options.a, lg, 0, b); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} all | |
| * @return {?} | |
| */ | |
| var Mx = function(all) { | |
| var b = all.b; | |
| return b ? kb(all.a, b) : -1; | |
| }; | |
| /** | |
| * @param {!Object} wt | |
| * @return {undefined} | |
| */ | |
| var Nx = function(wt) { | |
| var a = wt.a; | |
| if (!Ka(a)) { | |
| /** @type {number} */ | |
| var $orderCol = a.length - 1; | |
| for (; 0 <= $orderCol; $orderCol--) { | |
| delete a[$orderCol]; | |
| } | |
| } | |
| /** @type {number} */ | |
| a.length = 0; | |
| /** @type {null} */ | |
| wt.b = null; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Jx.prototype.X = function() { | |
| Jx.D.X.call(this); | |
| delete this.a; | |
| /** @type {null} */ | |
| this.b = null; | |
| }; | |
| /** | |
| * @param {string} opts | |
| * @param {boolean} i | |
| * @return {undefined} | |
| */ | |
| var Kx = function(opts, i) { | |
| if (opts && "function" == typeof opts.xd) { | |
| opts.xd(i); | |
| } | |
| }; | |
| /** | |
| * @param {?} a | |
| * @param {?} b | |
| * @param {?} c | |
| * @param {?} quality | |
| * @param {?} type | |
| * @return {undefined} | |
| */ | |
| var Ox = function(a, b, c, quality, type) { | |
| Ax.call(this, a, b, c, quality, type || new px("listbox")); | |
| this.Z = this.Ya(); | |
| /** @type {null} */ | |
| this.ra = null; | |
| /** @type {string} */ | |
| this.qh = "listbox"; | |
| }; | |
| x(Ox, Ax); | |
| k = Ox.prototype; | |
| /** @type {null} */ | |
| k.La = null; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.ia = function() { | |
| Ox.D.ia.call(this); | |
| Px(this); | |
| Qx(this); | |
| }; | |
| /** | |
| * @param {!Array} other | |
| * @return {undefined} | |
| */ | |
| k.Fa = function(other) { | |
| Ox.D.Fa.call(this, other); | |
| if (other = this.Bb()) { | |
| /** @type {!Array} */ | |
| this.Z = other; | |
| Px(this); | |
| } else { | |
| if (!Rx(this)) { | |
| Sx(this, 0); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.X = function() { | |
| Ox.D.X.call(this); | |
| if (this.La) { | |
| this.La.Qa(); | |
| /** @type {null} */ | |
| this.La = null; | |
| } | |
| /** @type {null} */ | |
| this.Z = null; | |
| }; | |
| /** | |
| * @param {!Event} s | |
| * @return {undefined} | |
| */ | |
| k.uh = function(s) { | |
| Tx(this, s.target); | |
| Ox.D.uh.call(this, s); | |
| s.stopPropagation(); | |
| this.dispatchEvent("action"); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.Gm = function() { | |
| var data = Rx(this); | |
| Ox.D.Wf.call(this, data && data.aa()); | |
| Px(this); | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @return {?} | |
| */ | |
| k.qf = function(options) { | |
| var self = Ox.D.qf.call(this, options); | |
| if (options != self) { | |
| if (this.La) { | |
| Nx(this.La); | |
| } | |
| if (options) { | |
| if (this.La) { | |
| Hq(options, function(styles) { | |
| Ux(styles); | |
| var options = this.La; | |
| Lx(options, styles, options.sb()); | |
| }, this); | |
| } else { | |
| Vx(this, options); | |
| } | |
| } | |
| } | |
| return self; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| k.ff = function(a) { | |
| Ux(a); | |
| Ox.D.ff.call(this, a); | |
| if (this.La) { | |
| var options = this.La; | |
| Lx(options, a, options.sb()); | |
| } else { | |
| Vx(this, Dx(this)); | |
| } | |
| Wx(this); | |
| }; | |
| /** | |
| * @param {!Object} t | |
| * @param {string} b | |
| * @return {undefined} | |
| */ | |
| var Tx = function(t, b) { | |
| if (t.La) { | |
| var button = Rx(t); | |
| var model = t.La; | |
| if (b != model.b) { | |
| Kx(model.b, false); | |
| /** @type {string} */ | |
| model.b = b; | |
| Kx(b, true); | |
| } | |
| model.dispatchEvent("select"); | |
| if (b != button) { | |
| t.dispatchEvent("change"); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {undefined} template | |
| * @param {number} idx | |
| * @return {undefined} | |
| */ | |
| var Sx = function(template, idx) { | |
| if (template.La) { | |
| Tx(template, template.La.a[idx] || null); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} n | |
| * @return {undefined} | |
| */ | |
| Ox.prototype.Wf = function(n) { | |
| if (null != n && this.La) { | |
| /** @type {number} */ | |
| var attri = 0; | |
| var options; | |
| for (; options = this.La.a[attri] || null; attri++) { | |
| if (options && "function" == typeof options.aa && options.aa() == n) { | |
| Tx(this, options); | |
| return; | |
| } | |
| } | |
| } | |
| Tx(this, null); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Ox.prototype.aa = function() { | |
| var formatters = Rx(this); | |
| return formatters ? formatters.aa() : null; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var Rx = function(a) { | |
| return a.La ? a.La.b : null; | |
| }; | |
| /** | |
| * @param {!Object} g | |
| * @param {!Object} b | |
| * @return {undefined} | |
| */ | |
| var Vx = function(g, b) { | |
| g.La = new Jx; | |
| if (b) { | |
| Hq(b, function(styles) { | |
| Ux(styles); | |
| var options = this.La; | |
| Lx(options, styles, options.sb()); | |
| }, g); | |
| } | |
| Qx(g); | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @return {undefined} | |
| */ | |
| var Qx = function(item) { | |
| if (item.La) { | |
| Y(item).M(item.La, "select", item.Gm); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} self | |
| * @return {undefined} | |
| */ | |
| var Px = function(self) { | |
| var v = Rx(self); | |
| self.g(v ? v.Bb() : self.Z); | |
| var target = self.c.fc(self.j()); | |
| if (target && self.a.un(target)) { | |
| if (null == self.ra) { | |
| self.ra = op(target, "label"); | |
| } | |
| v = v ? v.j() : null; | |
| rp(target, v ? op(v, "label") : self.ra); | |
| Wx(self); | |
| } | |
| }; | |
| /** | |
| * @param {number} context | |
| * @return {undefined} | |
| */ | |
| var Wx = function(context) { | |
| var obj = context.c; | |
| if (obj && (obj = obj.fc(context.j()))) { | |
| var arr = Dq(context); | |
| if (!obj.id) { | |
| /** @type {string} */ | |
| obj.id = ":" + (xq.N().a++).toString(36); | |
| } | |
| lp(obj, "option"); | |
| np(arr, "activedescendant", obj.id); | |
| if (context.La) { | |
| arr = Ab(context.La.a); | |
| np(obj, "setsize", Xx(arr)); | |
| context = Mx(context.La); | |
| np(obj, "posinset", 0 <= context ? Xx(Cb(arr, 0, context + 1)) : 0); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} x | |
| * @return {?} | |
| */ | |
| var Xx = function(x) { | |
| return qb(x, function(b) { | |
| return b instanceof mx; | |
| }); | |
| }; | |
| /** | |
| * @param {!Object} u | |
| * @return {undefined} | |
| */ | |
| var Ux = function(u) { | |
| /** @type {string} */ | |
| u.qh = u instanceof mx ? "option" : "separator"; | |
| }; | |
| /** | |
| * @param {boolean} c | |
| * @param {!Object} key | |
| * @return {undefined} | |
| */ | |
| Ox.prototype.bb = function(c, key) { | |
| Ox.D.bb.call(this, c, key); | |
| if (this.Ha(64)) { | |
| Dx(this).Ic(this.La ? Mx(this.La) : -1); | |
| } else { | |
| Wx(this); | |
| } | |
| }; | |
| jr("goog-select", function() { | |
| return new Ox(null); | |
| }); | |
| /** | |
| * @param {number} i | |
| * @param {number} node | |
| * @param {!Object} root | |
| * @param {string} index | |
| * @param {number} e | |
| * @param {string} data | |
| * @param {?} el | |
| * @param {?} context | |
| * @param {?} h | |
| * @return {undefined} | |
| */ | |
| var $x = function(i, node, root, index, e, data, el, context, h) { | |
| root = new Yx(root); | |
| Ox.call(this, "", root, el, context); | |
| if (this.m.b) { | |
| this.m.b(33); | |
| } | |
| /** @type {number} */ | |
| this.Da = i; | |
| this.hc = i.id; | |
| Cq(root, this.hc + "-menu"); | |
| /** @type {!Array} */ | |
| this.Y = []; | |
| /** @type {null} */ | |
| this.W = null; | |
| this.Aa = null != data ? data : ""; | |
| /** @type {boolean} */ | |
| this.Zd = !!h; | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < node.length; i++) { | |
| var item; | |
| data = null != index && i < index.length && null != index[i] ? index[i] : node[i]; | |
| if ("separator" != data) { | |
| item = new ux(node[i], data); | |
| } else { | |
| item = new qx; | |
| } | |
| this.ff(item); | |
| } | |
| this.na(this.Da); | |
| a: { | |
| node = null != e ? e : Zx(this, 0); | |
| /** @type {number} */ | |
| e = 0; | |
| for (; index = this.b ? Jq(this.b, e) : null; e++) { | |
| if (index instanceof mx && index.aa() == node) { | |
| /** @type {number} */ | |
| node = e; | |
| break a; | |
| } | |
| } | |
| /** @type {number} */ | |
| node = -1; | |
| } | |
| if (0 <= node) { | |
| Sx(this, node); | |
| } | |
| }; | |
| x($x, Ox); | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| $x.prototype.g = function(name) { | |
| if (this.Zd) { | |
| name = this.Aa; | |
| } else { | |
| if (this.Aa) { | |
| /** @type {string} */ | |
| name = this.Aa + " " + name; | |
| } | |
| } | |
| $x.D.g.call(this, name); | |
| }; | |
| /** | |
| * @param {!Object} n | |
| * @return {undefined} | |
| */ | |
| var ay = function(n) { | |
| if (n.W) { | |
| di(n.W); | |
| /** @type {null} */ | |
| n.W = null; | |
| } | |
| n.W = ci(function() { | |
| /** @type {!Array} */ | |
| n.Y = []; | |
| }, 1E3); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| $x.prototype.X = function() { | |
| Jf(this.Da); | |
| /** @type {null} */ | |
| this.Da = null; | |
| $x.D.X.call(this); | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @return {?} | |
| */ | |
| $x.prototype.ib = function(e) { | |
| if (!this.Ha(64) && 48 <= e.keyCode && 90 >= e.keyCode) { | |
| ay(this); | |
| this.Y.push(String.fromCharCode(e.keyCode)); | |
| e = this.Y.join(""); | |
| /** @type {!RegExp} */ | |
| var stringPrefixes = new RegExp("^" + ke(e), "i"); | |
| var end = this.La ? Mx(this.La) : -1; | |
| var start = end; | |
| if (-1 < start && 1 < e.length) { | |
| start--; | |
| } | |
| var ControlDeltaX = this.sb(); | |
| var i = 0 > start ? 0 : start; | |
| /** @type {boolean} */ | |
| var isArray = false; | |
| /** @type {boolean} */ | |
| var evt_start = false; | |
| do { | |
| ++start; | |
| if (start == ControlDeltaX) { | |
| /** @type {number} */ | |
| start = 0; | |
| /** @type {boolean} */ | |
| isArray = true; | |
| } | |
| var stream = this.b ? Jq(this.b, start) : null; | |
| if (stream instanceof mx && (stream = stream.Bb()) && stream.match(stringPrefixes)) { | |
| /** @type {boolean} */ | |
| evt_start = true; | |
| break; | |
| } | |
| if (isArray && start == i && 3 == e.length) { | |
| stream = e.split(""); | |
| if (stream[1] == stream[2]) { | |
| /** @type {!RegExp} */ | |
| stringPrefixes = new RegExp("^" + stream[1], "i"); | |
| /** @type {!Array} */ | |
| this.Y = [stream[1]]; | |
| /** @type {boolean} */ | |
| isArray = false; | |
| } | |
| } | |
| } while (!isArray || start != i); | |
| if (evt_start && start != end) { | |
| Sx(this, start); | |
| } | |
| return true; | |
| } | |
| return $x.D.ib.call(this, e); | |
| }; | |
| /** | |
| * @param {string} m | |
| * @param {number} _value | |
| * @return {?} | |
| */ | |
| var Zx = function(m, _value) { | |
| /** @type {string} */ | |
| var c = ""; | |
| m = m.b ? Jq(m.b, _value) : null; | |
| if (m instanceof mx) { | |
| c = m.aa(); | |
| } | |
| return c; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| $x.prototype.aa = function() { | |
| var url = this.La ? Mx(this.La) : -1; | |
| return -1 != url ? Zx(this, url) : ""; | |
| }; | |
| /** | |
| * @param {number} s | |
| * @param {?} pos | |
| * @param {?} normal | |
| * @return {undefined} | |
| */ | |
| var Yx = function(s, pos, normal) { | |
| /** @type {number} */ | |
| this.b = s; | |
| /** @type {!Array} */ | |
| this.m = []; | |
| /** @type {!Array} */ | |
| this.K = []; | |
| rx.call(this, pos, normal); | |
| }; | |
| x(Yx, rx); | |
| k = Yx.prototype; | |
| k.gj = G("DIV", { | |
| id : "goog-menuitem-group-", | |
| "class" : "goog-menuitem-group" | |
| }); | |
| /** @type {boolean} */ | |
| k.yh = false; | |
| /** @type {number} */ | |
| k.Wd = 0; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.Ra = function() { | |
| Yx.D.Ra.call(this); | |
| this.j().id = Bq(this); | |
| }; | |
| /** | |
| * @param {number} result | |
| * @param {number} key | |
| * @param {string} c | |
| * @return {undefined} | |
| */ | |
| k.Gd = function(result, key, c) { | |
| if (this.yh) { | |
| this.c = key == Iq(this) ? this.g[key - 1] : this.g[key]; | |
| } | |
| Yx.D.Gd.call(this, result, key, c); | |
| if (this.c) { | |
| /** @type {null} */ | |
| this.c = null; | |
| by(this); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} c | |
| * @param {boolean} index | |
| * @return {?} | |
| */ | |
| k.removeChild = function(c, index) { | |
| if (r(c)) { | |
| c = Eq(this, c); | |
| } | |
| var key = Lq(this, c); | |
| if (this.yh) { | |
| this.c = 0 == key ? this.g[key + 1] : this.g[key]; | |
| } | |
| c = Yx.D.removeChild.call(this, c, index); | |
| if (this.c) { | |
| /** @type {null} */ | |
| this.c = null; | |
| by(this); | |
| } | |
| return c; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.oc = function() { | |
| var o; | |
| if (this.c) { | |
| o = this.c; | |
| } else { | |
| o = Yx.D.oc.call(this); | |
| } | |
| return o; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| k.Za = function(a) { | |
| Yx.D.Za.call(this, a); | |
| by(this); | |
| Lw(Iw.N(), this.j()); | |
| }; | |
| /** | |
| * @param {!Object} n | |
| * @return {undefined} | |
| */ | |
| k.na = function(n) { | |
| Yx.D.na.call(this, n); | |
| by(this); | |
| Lw(Iw.N(), this.j()); | |
| }; | |
| /** | |
| * @param {!Object} m | |
| * @return {undefined} | |
| */ | |
| var by = function(m) { | |
| /** @type {boolean} */ | |
| m.yh = true; | |
| cy(m); | |
| var b = m.j(); | |
| /** @type {string} */ | |
| b.innerHTML = ""; | |
| /** @type {!Array} */ | |
| var defs = []; | |
| /** @type {number} */ | |
| var tableId = 0; | |
| /** @type {!Element} */ | |
| var header = document.createElement("table"); | |
| var containerTR = header.insertRow(-1); | |
| /** @type {number} */ | |
| var i = 0; | |
| var iframe; | |
| for (; iframe = m.h[i]; i++) { | |
| var def = containerTR.insertCell(containerTR.cells.length); | |
| def.appendChild(iframe); | |
| if (tp(iframe, "goog-groupmenu-separator")) { | |
| defs.push(def); | |
| containerTR = header.insertRow(header.rows.length); | |
| } else { | |
| tableId++; | |
| } | |
| } | |
| /** @type {number} */ | |
| i = 0; | |
| for (; def = defs[i]; i++) { | |
| def.setAttribute("colspan", tableId); | |
| } | |
| b.appendChild(header); | |
| }; | |
| /** | |
| * @param {!Window} w | |
| * @param {?} y | |
| * @param {number} orient | |
| * @return {?} | |
| */ | |
| var dy = function(w, y, orient) { | |
| if (!tb(w.h, y.Zb)) { | |
| w.h.push(y.Zb); | |
| } | |
| if (Jq(w, orient + 1)) { | |
| y.Zb = w.gj.cloneNode(true); | |
| y.Zb.id += y.Ej; | |
| y.Ej++; | |
| /** @type {number} */ | |
| y.gg = 1; | |
| } | |
| return y; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| var cy = function(a) { | |
| /** @type {!Array} */ | |
| a.h = []; | |
| a.g = {}; | |
| var wunderlist_list = a.gj.cloneNode(true); | |
| wunderlist_list.id += 1; | |
| var w = { | |
| Zb : wunderlist_list, | |
| Ej : 2, | |
| gg : 1 | |
| }; | |
| Hq(a, function(val, opts) { | |
| w.Zb.appendChild(val.j()); | |
| this.g[opts] = w.Zb; | |
| if (w.gg == this.b) { | |
| w = dy(this, w, opts); | |
| } else { | |
| if (val instanceof mx) { | |
| w.gg++; | |
| } | |
| } | |
| if (tb(this.K, opts)) { | |
| U(w.Zb, "goog-menuitem-group"); | |
| T(w.Zb, "goog-groupmenu-separator"); | |
| this.g[opts] = w.Zb; | |
| w = dy(this, w, opts); | |
| } | |
| }, a); | |
| if (!(1 == w.gg || tb(a.h, w.Zb))) { | |
| a.h.push(w.Zb); | |
| } | |
| }; | |
| /** | |
| * @param {string} arr | |
| * @param {?} b | |
| * @param {!Object} c | |
| * @return {?} | |
| */ | |
| Yx.prototype.setVisible = function(arr, b, c) { | |
| if ((arr = Yx.D.setVisible.call(this, arr, b, c)) && this.Wd) { | |
| di(this.Wd); | |
| /** @type {number} */ | |
| this.Wd = 0; | |
| } | |
| return arr; | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @return {?} | |
| */ | |
| Yx.prototype.df = function(o) { | |
| var result = Yx.D.df.call(this, o); | |
| if (result) { | |
| return result; | |
| } | |
| switch(o.keyCode) { | |
| case 37: | |
| return ex(this, v(this.w, this), this.Oa), true; | |
| case 39: | |
| return ex(this, v(this.C, this), this.Oa), true; | |
| default: | |
| return 48 <= o.keyCode && 90 >= o.keyCode ? (ey(this), this.m.push(String.fromCharCode(o.keyCode)), this.qj(this.m.join("")), true) : false; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @return {undefined} | |
| */ | |
| var ey = function(item) { | |
| if (item.Wd) { | |
| di(item.Wd); | |
| /** @type {number} */ | |
| item.Wd = 0; | |
| } | |
| item.Wd = ci(function() { | |
| /** @type {!Array} */ | |
| this.m = []; | |
| }, 1E3, item); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| Yx.prototype.qj = function(a) { | |
| /** @type {!RegExp} */ | |
| var child = new RegExp("^" + ke(a), "i"); | |
| var NINETY_EIGHT_HOURS = this.Oa; | |
| if (-1 < NINETY_EIGHT_HOURS && 1 < a.length) { | |
| NINETY_EIGHT_HOURS--; | |
| } | |
| ex(this, function(m, p) { | |
| var parameters = 0 > m ? 0 : m; | |
| /** @type {boolean} */ | |
| var optionalMinutes = false; | |
| do { | |
| ++m; | |
| if (m == p) { | |
| /** @type {number} */ | |
| m = 0; | |
| /** @type {boolean} */ | |
| optionalMinutes = true; | |
| } | |
| var environment = Jq(this, m).Bb(); | |
| if (environment && environment.match(child)) { | |
| return m; | |
| } | |
| } while (!optionalMinutes || m != parameters); | |
| return this.Oa; | |
| }, NINETY_EIGHT_HOURS); | |
| }; | |
| /** | |
| * @param {number} type | |
| * @param {number} value | |
| * @return {?} | |
| */ | |
| Yx.prototype.w = function(type, value) { | |
| /** @type {number} */ | |
| type = type - this.b; | |
| var yInt; | |
| if (0 > type) { | |
| yInt = type + value + (Math.ceil(value / this.b) * this.b - value) + this.b; | |
| } | |
| return yInt || type; | |
| }; | |
| /** | |
| * @param {?} name | |
| * @param {number} value | |
| * @return {?} | |
| */ | |
| Yx.prototype.C = function(name, value) { | |
| name = name + this.b; | |
| var F; | |
| if (name > value) { | |
| /** @type {number} */ | |
| F = name - value - (Math.ceil(value / this.b) * this.b - value) - this.b; | |
| } | |
| return F || name; | |
| }; | |
| /** | |
| * @param {number} value | |
| * @param {!Array} diff | |
| * @return {undefined} | |
| */ | |
| var gy = function(value, diff) { | |
| this.a = fy; | |
| /** @type {number} */ | |
| this.b = value; | |
| this.c = Zb(diff); | |
| }; | |
| /** @type {null} */ | |
| var fy = null; | |
| /** | |
| * @param {string} token | |
| * @param {!Function} cb | |
| * @return {undefined} | |
| */ | |
| var iy = function(token, cb) { | |
| /** @type {!Array} */ | |
| var args = ["sl", "tl", "src", "trg", "ts"]; | |
| if (!fy && "openDatabase" in window) { | |
| try { | |
| /** @type {!Database} */ | |
| fy = window.openDatabase("GoogleTranslateMobileWebApp", "1.0", "Google Translate Mobile Web App", 5E5); | |
| } catch (e) { | |
| } | |
| } | |
| if (fy) { | |
| var arg = new gy(token, args); | |
| hy(arg, token, args, function(fallbackReleases) { | |
| if (cb) { | |
| cb(fallbackReleases, arg); | |
| } | |
| }); | |
| } else { | |
| if (cb) { | |
| cb(false, null); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Function} callback | |
| * @return {?} | |
| */ | |
| var jy = function(callback) { | |
| return function(errData) { | |
| if (callback) { | |
| callback(false, errData.code); | |
| } | |
| }; | |
| }; | |
| /** | |
| * @param {(number|string)} p | |
| * @param {string} v | |
| * @param {!Array} data | |
| * @param {!Function} callback | |
| * @return {undefined} | |
| */ | |
| var hy = function(p, v, data, callback) { | |
| /** @type {!Array} */ | |
| var params = []; | |
| params.push("CREATE TABLE IF NOT EXISTS", v); | |
| /** @type {!Array} */ | |
| v = []; | |
| /** @type {number} */ | |
| var i = 0; | |
| var nbElts = data.length; | |
| for (; i < nbElts; i++) { | |
| v.push(data[i] + " TEXT"); | |
| } | |
| params.push("(", v.join(","), ")"); | |
| p.a.transaction(function(tx) { | |
| tx.executeSql(params.join(" ")); | |
| }, jy(callback), callback ? Ta(callback, true, null) : Ha); | |
| }; | |
| /** | |
| * @param {!Object} fn | |
| * @param {!Array} dict | |
| * @return {?} | |
| */ | |
| var ky = function(fn, dict) { | |
| var tp; | |
| for (tp in dict) { | |
| if (!Qb(fn.c, tp)) { | |
| return false; | |
| } | |
| } | |
| return true; | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @param {!Array} o | |
| * @param {string} value | |
| * @param {!Function} callback | |
| * @return {undefined} | |
| */ | |
| var my = function(options, o, value, callback) { | |
| /** @type {!Array} */ | |
| var gridimages = [["ts"]]; | |
| if (ky(options, o)) { | |
| /** @type {!Array} */ | |
| var sql = []; | |
| sql.push("SELECT * FROM", options.b); | |
| /** @type {!Array} */ | |
| var g = []; | |
| /** @type {!Array} */ | |
| var arrVal = []; | |
| ly(o, g, arrVal); | |
| if (g.length) { | |
| sql.push("WHERE", g.join(" AND ")); | |
| } | |
| if (gridimages && 0 < gridimages.length) { | |
| /** @type {!Array} */ | |
| o = []; | |
| /** @type {number} */ | |
| g = 0; | |
| for (; g < gridimages.length; ++g) { | |
| o.push(gridimages[g][0] + " " + (gridimages[g][1] ? "ASC" : "DESC")); | |
| } | |
| sql.push("ORDER BY", o.join(",")); | |
| } | |
| if (value) { | |
| sql.push("LIMIT", value); | |
| } | |
| /** @type {!Array} */ | |
| var intervalOptions = []; | |
| options.a.transaction(function(t) { | |
| t.executeSql(sql.join(" "), arrVal, function(i, rslt) { | |
| /** @type {number} */ | |
| i = 0; | |
| var patchLen = rslt.rows.length; | |
| for (; i < patchLen; i++) { | |
| intervalOptions.push(rslt.rows.item(i)); | |
| } | |
| }); | |
| }, jy(callback), callback ? Ta(callback, true, intervalOptions || null) : Ha); | |
| } else { | |
| if (callback) { | |
| callback(false, -1); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} mapObject | |
| * @param {!Object} depth | |
| * @param {!Function} body | |
| * @return {undefined} | |
| */ | |
| var oy = function(mapObject, depth, body) { | |
| ny(mapObject, [depth], body); | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @param {!Array} p | |
| * @param {!Function} success | |
| * @return {undefined} | |
| */ | |
| var ny = function(e, p, success) { | |
| /** @type {number} */ | |
| var j = 0; | |
| var pl = p.length; | |
| for (; j < pl; j++) { | |
| if (!ky(e, p[j])) { | |
| if (success) { | |
| success(false, -1); | |
| } | |
| return; | |
| } | |
| } | |
| /** @type {!Array} */ | |
| var observers = []; | |
| /** @type {number} */ | |
| j = 0; | |
| pl = p.length; | |
| for (; j < pl; j++) { | |
| var value = p[j]; | |
| /** @type {!Array} */ | |
| var foundNonValidAttributes = []; | |
| /** @type {!Array} */ | |
| var m = []; | |
| /** @type {!Array} */ | |
| var drilldownLevelLabels = []; | |
| var k; | |
| for (k in value) { | |
| foundNonValidAttributes.push(k); | |
| m.push(value[k]); | |
| drilldownLevelLabels.push("?"); | |
| } | |
| observers.push([["INSERT INTO", e.b, "(", foundNonValidAttributes.join(","), ") VALUES (", drilldownLevelLabels.join(","), ")"].join(" "), m]); | |
| } | |
| e.a.transaction(function(tx) { | |
| /** @type {number} */ | |
| var l = 0; | |
| /** @type {number} */ | |
| var i = observers.length; | |
| for (; l < i; l++) { | |
| tx.executeSql(observers[l][0], observers[l][1]); | |
| } | |
| }, jy(success), success ? Ta(success, true, null) : Ha); | |
| }; | |
| /** | |
| * @param {!Object} context | |
| * @param {!Arguments} what | |
| * @param {!Function} callback | |
| * @return {undefined} | |
| */ | |
| var py = function(context, what, callback) { | |
| if (ky(context, what)) { | |
| /** @type {!Array} */ | |
| var block = []; | |
| block.push("DELETE FROM", context.b); | |
| /** @type {!Array} */ | |
| var e = []; | |
| /** @type {!Array} */ | |
| var arrVal = []; | |
| ly(what, e, arrVal); | |
| if (e.length) { | |
| block.push("WHERE", e.join(" AND ")); | |
| } | |
| context.a.transaction(function(t) { | |
| t.executeSql(block.join(" "), arrVal); | |
| }, jy(callback), callback ? Ta(callback, true, null) : Ha); | |
| } else { | |
| if (callback) { | |
| callback(false, -1); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} parent | |
| * @param {!Array} src | |
| * @param {!Array} val | |
| * @return {undefined} | |
| */ | |
| var ly = function(parent, src, val) { | |
| var i; | |
| for (i in parent) { | |
| src.push(i + "=?"); | |
| val.push(parent[i]); | |
| } | |
| }; | |
| /** | |
| * @param {number} a | |
| * @return {undefined} | |
| */ | |
| var qy = function(a) { | |
| /** @type {number} */ | |
| this.a = a; | |
| }; | |
| /** | |
| * @param {string} t | |
| * @param {!Function} val | |
| * @return {undefined} | |
| */ | |
| var ry = function(t, val) { | |
| iy(t, function(elem, s) { | |
| /** @type {null} */ | |
| var handle = null; | |
| if (elem) { | |
| handle = new qy(s); | |
| } | |
| if (val) { | |
| val(elem, handle); | |
| } | |
| }); | |
| }; | |
| /** | |
| * @param {string} s | |
| * @param {!Object} n | |
| * @param {!Object} c | |
| * @param {!Object} e | |
| * @return {undefined} | |
| */ | |
| var uy = function(s, n, c, e) { | |
| var t = sy.a; | |
| ty(t, s, n, c, function(res) { | |
| if (res) { | |
| res = {}; | |
| /** @type {string} */ | |
| res.sl = s; | |
| /** @type {!Object} */ | |
| res.tl = n; | |
| /** @type {!Object} */ | |
| res.src = c; | |
| res.trg = (new Di).vd(e); | |
| /** @type {number} */ | |
| res.ts = (new Date).getTime(); | |
| oy(t.a, res, function() { | |
| }); | |
| } | |
| }); | |
| }; | |
| /** | |
| * @param {(number|string)} result | |
| * @param {string} x | |
| * @param {!Object} y | |
| * @param {!Object} d | |
| * @param {!Function} e | |
| * @return {undefined} | |
| */ | |
| var ty = function(result, x, y, d, e) { | |
| var p = {}; | |
| if (x) { | |
| /** @type {string} */ | |
| p.sl = x; | |
| } | |
| if (y) { | |
| /** @type {!Object} */ | |
| p.tl = y; | |
| } | |
| if (d) { | |
| /** @type {!Object} */ | |
| p.src = d; | |
| } | |
| py(result.a, p, function(context) { | |
| if (e) { | |
| e(context); | |
| } | |
| }); | |
| }; | |
| /** | |
| * @param {(number|string)} val | |
| * @param {string} type | |
| * @param {!Object} filePath | |
| * @param {string} c | |
| * @param {!Function} e | |
| * @param {!Function} f | |
| * @return {undefined} | |
| */ | |
| var vy = function(val, type, filePath, c, e, f) { | |
| var opts = {}; | |
| if (type) { | |
| /** @type {string} */ | |
| opts.sl = type; | |
| } | |
| if (filePath) { | |
| /** @type {!Object} */ | |
| opts.tl = filePath; | |
| } | |
| if (c) { | |
| /** @type {string} */ | |
| opts.src = c; | |
| } | |
| my(val.a, opts, e, function(widthCtrl, add) { | |
| /** @type {!Array} */ | |
| var b = []; | |
| if (widthCtrl) { | |
| /** @type {number} */ | |
| var j = 0; | |
| var n = add.length; | |
| for (; j < n; j++) { | |
| var u = {}; | |
| var k; | |
| for (k in add[j]) { | |
| u[k] = add[j][k]; | |
| } | |
| var josh = Zn(u.trg, { | |
| "class" : "trans.common.WebSqlTranslations" | |
| }); | |
| u.trg = josh; | |
| b.push(u); | |
| } | |
| } | |
| if (f) { | |
| f(widthCtrl, b); | |
| } | |
| }); | |
| }; | |
| /** | |
| * @param {(number|string)} crc | |
| * @param {string} type | |
| * @param {!Object} n | |
| * @param {string} d | |
| * @param {number} e | |
| * @param {!Function} f | |
| * @return {undefined} | |
| */ | |
| var wy = function(crc, type, n, d, e, f) { | |
| vy(crc, type, n, d, e, function(widthCtrl, wholeDoc) { | |
| if (f) { | |
| f(widthCtrl, wholeDoc); | |
| } | |
| }); | |
| }; | |
| /** | |
| * @param {number} y | |
| * @return {undefined} | |
| */ | |
| var xy = function(y) { | |
| /** @type {number} */ | |
| this.a = y; | |
| }; | |
| /** | |
| * @param {!Function} context | |
| * @return {undefined} | |
| */ | |
| var yy = function(context) { | |
| ry("TranslationHistory", function(isFront, isBgroundImg) { | |
| isBgroundImg = isFront ? new xy(isBgroundImg) : null; | |
| if (context) { | |
| context(isFront, isBgroundImg); | |
| } | |
| }); | |
| }; | |
| var zy = ec("//www.gstatic.com/inputtools/js/ita/inputtools_3.js"); | |
| var Ay = ec("//www.gstatic.com/inputtools/js/ita/inputtools_d_3.js"); | |
| /** | |
| * @param {string} K | |
| * @return {undefined} | |
| */ | |
| var Cy = function(K) { | |
| /** @type {function(): undefined} */ | |
| var R = By; | |
| /** @type {!Array} */ | |
| this.h = []; | |
| /** @type {function(): undefined} */ | |
| this.R = R; | |
| this.K = K || null; | |
| /** @type {boolean} */ | |
| this.g = this.a = false; | |
| this.c = void 0; | |
| /** @type {boolean} */ | |
| this.G = this.C = this.m = false; | |
| /** @type {number} */ | |
| this.o = 0; | |
| /** @type {null} */ | |
| this.b = null; | |
| /** @type {number} */ | |
| this.w = 0; | |
| }; | |
| /** | |
| * @param {?} a | |
| * @return {undefined} | |
| */ | |
| Cy.prototype.cancel = function(a) { | |
| if (this.a) { | |
| if (this.c instanceof Cy) { | |
| this.c.cancel(); | |
| } | |
| } else { | |
| if (this.b) { | |
| var b1 = this.b; | |
| delete this.b; | |
| if (a) { | |
| b1.cancel(a); | |
| } else { | |
| b1.w--; | |
| if (0 >= b1.w) { | |
| b1.cancel(); | |
| } | |
| } | |
| } | |
| if (this.R) { | |
| this.R.call(this.K, this); | |
| } else { | |
| /** @type {boolean} */ | |
| this.G = true; | |
| } | |
| if (!this.a) { | |
| Dy(this, new Ey(this)); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| Cy.prototype.L = function(type, value) { | |
| /** @type {boolean} */ | |
| this.m = false; | |
| Fy(this, type, value); | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @param {boolean} data | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| var Fy = function(item, data, value) { | |
| /** @type {boolean} */ | |
| item.a = true; | |
| /** @type {string} */ | |
| item.c = value; | |
| /** @type {boolean} */ | |
| item.g = !data; | |
| Gy(item); | |
| }; | |
| /** | |
| * @param {!Object} object | |
| * @return {undefined} | |
| */ | |
| var Iy = function(object) { | |
| if (object.a) { | |
| if (!object.G) { | |
| throw new Hy(object); | |
| } | |
| /** @type {boolean} */ | |
| object.G = false; | |
| } | |
| }; | |
| /** | |
| * @param {string} val | |
| * @return {undefined} | |
| */ | |
| Cy.prototype.Se = function(val) { | |
| Iy(this); | |
| Jy(val); | |
| Fy(this, true, val); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} b | |
| * @return {undefined} | |
| */ | |
| var Dy = function(a, b) { | |
| Iy(a); | |
| Jy(b); | |
| Fy(a, false, b); | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var Jy = function(a) { | |
| z(!(a instanceof Cy), "An execution sequence may not be initiated with a blocking Deferred."); | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @param {!Object} position | |
| * @param {!Function} doc | |
| * @param {!Object} r | |
| * @return {undefined} | |
| */ | |
| var Ky = function(value, position, doc, r) { | |
| z(!value.C, "Blocking Deferreds can not be re-used"); | |
| value.h.push([position, doc, r]); | |
| if (value.a) { | |
| Gy(value); | |
| } | |
| }; | |
| /** | |
| * @param {!Function} a | |
| * @param {!Function} f | |
| * @param {!Function} fn | |
| * @return {?} | |
| */ | |
| Cy.prototype.then = function(a, f, fn) { | |
| var savedPos; | |
| var stripDates; | |
| var b = new Jh(function(i, isSlidingUp) { | |
| savedPos = i; | |
| stripDates = isSlidingUp; | |
| }); | |
| Ky(this, savedPos, function(resp) { | |
| if (resp instanceof Ey) { | |
| b.cancel(); | |
| } else { | |
| stripDates(resp); | |
| } | |
| }); | |
| return b.then(a, f, fn); | |
| }; | |
| /** @type {boolean} */ | |
| Cy.prototype.$goog_Thenable = true; | |
| /** | |
| * @param {!Object} o | |
| * @return {?} | |
| */ | |
| var Ly = function(o) { | |
| return ob(o.h, function(b) { | |
| return Ma(b[1]); | |
| }); | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @return {undefined} | |
| */ | |
| var Gy = function(obj) { | |
| if (obj.o && obj.a && Ly(obj)) { | |
| var value = obj.o; | |
| var o = My[value]; | |
| if (o) { | |
| l.clearTimeout(o.va); | |
| delete My[value]; | |
| } | |
| /** @type {number} */ | |
| obj.o = 0; | |
| } | |
| if (obj.b) { | |
| obj.b.w--; | |
| delete obj.b; | |
| } | |
| value = obj.c; | |
| /** @type {boolean} */ | |
| var fn = o = false; | |
| for (; obj.h.length && !obj.m;) { | |
| var c = obj.h.shift(); | |
| var f = c[0]; | |
| var right = c[1]; | |
| c = c[2]; | |
| if (f = obj.g ? right : f) { | |
| try { | |
| var item = f.call(c || obj.K, value); | |
| if (q(item)) { | |
| obj.g = obj.g && (item == value || item instanceof Error); | |
| obj.c = value = item; | |
| } | |
| if (Gh(value) || "function" === typeof l.Promise && value instanceof l.Promise) { | |
| /** @type {boolean} */ | |
| fn = true; | |
| /** @type {boolean} */ | |
| obj.m = true; | |
| } | |
| } catch (sequence_values) { | |
| value = sequence_values; | |
| /** @type {boolean} */ | |
| obj.g = true; | |
| if (!Ly(obj)) { | |
| /** @type {boolean} */ | |
| o = true; | |
| } | |
| } | |
| } | |
| } | |
| obj.c = value; | |
| if (fn) { | |
| item = v(obj.L, obj, true); | |
| fn = v(obj.L, obj, false); | |
| if (value instanceof Cy) { | |
| Ky(value, item, fn); | |
| /** @type {boolean} */ | |
| value.C = true; | |
| } else { | |
| value.then(item, fn); | |
| } | |
| } | |
| if (o) { | |
| value = new Ny(value); | |
| My[value.va] = value; | |
| obj.o = value.va; | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Hy = function() { | |
| Va.call(this); | |
| }; | |
| x(Hy, Va); | |
| /** @type {string} */ | |
| Hy.prototype.message = "Deferred has already fired"; | |
| /** @type {string} */ | |
| Hy.prototype.name = "AlreadyCalledError"; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Ey = function() { | |
| Va.call(this); | |
| }; | |
| x(Ey, Va); | |
| /** @type {string} */ | |
| Ey.prototype.message = "Deferred was canceled"; | |
| /** @type {string} */ | |
| Ey.prototype.name = "CanceledError"; | |
| /** | |
| * @param {(RegExp|string)} a | |
| * @return {undefined} | |
| */ | |
| var Ny = function(a) { | |
| this.va = l.setTimeout(v(this.a, this), 0); | |
| /** @type {(RegExp|string)} */ | |
| this.Jf = a; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Ny.prototype.a = function() { | |
| z(My[this.va], "Cannot throw an error that is not scheduled."); | |
| delete My[this.va]; | |
| throw this.Jf; | |
| }; | |
| var My = {}; | |
| /** | |
| * @param {!Object} id | |
| * @param {string} target | |
| * @return {?} | |
| */ | |
| var Ry = function(id, target) { | |
| var self = target || {}; | |
| target = self.document || document; | |
| var rcInstance = rc(id); | |
| var tag = zf("SCRIPT"); | |
| var pt = { | |
| Oj : tag, | |
| yd : void 0 | |
| }; | |
| var mk = new Cy(pt); | |
| /** @type {null} */ | |
| var x = null; | |
| var dt = null != self.timeout ? self.timeout : 5E3; | |
| if (0 < dt) { | |
| x = window.setTimeout(function() { | |
| Oy(tag, true); | |
| Dy(mk, new Py(1, "Timeout reached for loading script " + rcInstance)); | |
| }, dt); | |
| pt.yd = x; | |
| } | |
| /** @type {function(): undefined} */ | |
| tag.onload = tag.onreadystatechange = function() { | |
| if (!(tag.readyState && "loaded" != tag.readyState && "complete" != tag.readyState)) { | |
| Oy(tag, self.kl || false, x); | |
| mk.Se(null); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| tag.onerror = function() { | |
| Oy(tag, true, x); | |
| Dy(mk, new Py(0, "Error while loading script " + rcInstance)); | |
| }; | |
| pt = self.attributes || {}; | |
| Xb(pt, { | |
| type : "text/javascript", | |
| charset : "UTF-8" | |
| }); | |
| qf(tag, pt); | |
| Yd(tag, id); | |
| Qy(target).appendChild(tag); | |
| return mk; | |
| }; | |
| /** | |
| * @param {!Object} s | |
| * @return {?} | |
| */ | |
| var Qy = function(s) { | |
| var response = lf("HEAD", s); | |
| return response && 0 != response.length ? response[0] : s.documentElement; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var By = function() { | |
| if (this && this.Oj) { | |
| var a = this.Oj; | |
| if (a && "SCRIPT" == a.tagName) { | |
| Oy(a, true, this.yd); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @param {boolean} n | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| var Oy = function(b, n, a) { | |
| if (null != a) { | |
| l.clearTimeout(a); | |
| } | |
| /** @type {function(): undefined} */ | |
| b.onload = Ha; | |
| /** @type {function(): undefined} */ | |
| b.onerror = Ha; | |
| /** @type {function(): undefined} */ | |
| b.onreadystatechange = Ha; | |
| if (n) { | |
| window.setTimeout(function() { | |
| Jf(b); | |
| }, 0); | |
| } | |
| }; | |
| /** | |
| * @param {string} codeOrNull | |
| * @param {string} options | |
| * @return {undefined} | |
| */ | |
| var Py = function(codeOrNull, options) { | |
| /** @type {string} */ | |
| var baseurl = "Jsloader error (code #" + codeOrNull + ")"; | |
| if (options) { | |
| /** @type {string} */ | |
| baseurl = baseurl + (": " + options); | |
| } | |
| Va.call(this, baseurl); | |
| /** @type {string} */ | |
| this.code = codeOrNull; | |
| }; | |
| x(Py, Va); | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Sy = function() { | |
| /** @type {boolean} */ | |
| this.c = this.b = false; | |
| /** @type {!Array} */ | |
| this.a = []; | |
| }; | |
| Ia(Sy); | |
| var Ty = ec("//www.gstatic.cn/inputtools/js/ita/inputtools_1.js"); | |
| var Uy = ec("//www.gstatic.cn/inputtools/js/ita/inputtools_d_1.js"); | |
| /** | |
| * @return {undefined} | |
| */ | |
| Sy.prototype.g = function() { | |
| /** @type {boolean} */ | |
| this.c = true; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < this.a.length; ++i) { | |
| this.a[i](); | |
| } | |
| }; | |
| /** | |
| * @param {string} url | |
| * @param {!Function} texurl | |
| * @return {undefined} | |
| */ | |
| Sy.prototype.load = function(url, texurl) { | |
| if (this.b) { | |
| if (this.b && !this.c) { | |
| this.a.push(url); | |
| } else { | |
| url(); | |
| } | |
| } else { | |
| /** @type {boolean} */ | |
| this.b = true; | |
| this.a.push(url); | |
| /** @type {boolean} */ | |
| url = 0 <= l.location.href.indexOf("?deb=static") || 0 <= l.location.href.indexOf("&deb=static"); | |
| Ry(tc(dc(texurl ? url ? Uy : Ty : url ? Ay : zy))).then(v(this.g, this)); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Wy = function() { | |
| this.g = fk.N(); | |
| this.c = {}; | |
| this.b = {}; | |
| this.a = {}; | |
| this.a["gt-input-tool"] = new Vy; | |
| }; | |
| Ia(Wy); | |
| /** | |
| * @param {string} a | |
| * @param {?} b | |
| * @param {string} c | |
| * @return {?} | |
| */ | |
| var Yy = function(a, b, c) { | |
| b = Xy(a, b, c); | |
| if (q(b)) { | |
| a = b.zj; | |
| } else { | |
| a: { | |
| a = ik(a.g, c); | |
| if (null != a) { | |
| /** @type {number} */ | |
| c = 0; | |
| for (; c < a.length; c++) { | |
| if (kk(a[c])) { | |
| a = a[c]; | |
| break a; | |
| } | |
| } | |
| } | |
| /** @type {string} */ | |
| a = ""; | |
| } | |
| a = a || ""; | |
| } | |
| return a; | |
| }; | |
| /** | |
| * @param {string} ctx | |
| * @param {?} value | |
| * @param {string} key | |
| * @return {?} | |
| */ | |
| var Xy = function(ctx, value, key) { | |
| if (ctx = Zy(ctx, value)) { | |
| return ctx.a[key]; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} s | |
| * @param {!Object} name | |
| * @param {boolean} isPk | |
| * @return {?} | |
| */ | |
| var Zy = function(s, name, isPk) { | |
| var dir = s.a[name]; | |
| if (isPk && !q(dir)) { | |
| dir = new Vy; | |
| s.a[name] = dir; | |
| } | |
| return dir; | |
| }; | |
| /** | |
| * @param {?} key | |
| * @param {string} value | |
| * @param {?} other | |
| * @return {undefined} | |
| */ | |
| var $y = function(key, value, other) { | |
| var data = { | |
| ua : "itui" | |
| }; | |
| data.uav = r(key) ? key : key ? 1 : 0; | |
| /** @type {string} */ | |
| data.sl = value; | |
| /** @type {string} */ | |
| data.tl = "und"; | |
| data.hl = other; | |
| /** @type {!Image} */ | |
| var textureimg = new Image; | |
| /** @type {string} */ | |
| textureimg.src = "/translate/uc?" + jj(data); | |
| /** | |
| * @return {undefined} | |
| */ | |
| textureimg.onload = function() { | |
| /** @type {null} */ | |
| textureimg.onload = null; | |
| }; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Vy = function() { | |
| this.a = {}; | |
| var i; | |
| for (i in az) { | |
| this.a[i] = new bz(az[i], ""); | |
| } | |
| }; | |
| var az = { | |
| iw : false, | |
| ja : false, | |
| vi : false, | |
| "zh-CN" : false | |
| }; | |
| /** | |
| * @param {!Object} index | |
| * @param {boolean} key | |
| * @param {string} x | |
| * @return {undefined} | |
| */ | |
| Vy.prototype.update = function(index, key, x) { | |
| var c = this.a[index]; | |
| if (q(c)) { | |
| /** @type {boolean} */ | |
| c.isEnabled = key; | |
| /** @type {string} */ | |
| c.zj = x; | |
| } else { | |
| this.a[index] = new bz(key, x); | |
| } | |
| }; | |
| /** | |
| * @param {boolean} state | |
| * @param {?} noBack | |
| * @return {undefined} | |
| */ | |
| var bz = function(state, noBack) { | |
| /** @type {boolean} */ | |
| this.isEnabled = state; | |
| this.zj = noBack; | |
| }; | |
| /** | |
| * @param {number} objSource | |
| * @param {?} objDestination | |
| * @param {?} other | |
| * @param {!Array} r | |
| * @param {number} w | |
| * @param {!Object} d | |
| * @return {undefined} | |
| */ | |
| var cz = function(objSource, objDestination, other, r, w, d) { | |
| L.call(this); | |
| this.C = fk.N(); | |
| /** @type {number} */ | |
| this.h = objSource; | |
| this.Y = other; | |
| this.ea = objDestination; | |
| /** @type {null} */ | |
| this.g = this.b = null; | |
| /** @type {string} */ | |
| this.o = this.L = ""; | |
| this.G = this.h.id; | |
| /** @type {string} */ | |
| this.a = ""; | |
| /** @type {boolean} */ | |
| this.m = this.c = false; | |
| hm.N(); | |
| /** @type {!Array} */ | |
| this.R = r; | |
| /** @type {number} */ | |
| this.W = w; | |
| /** @type {!Array} */ | |
| this.Z = kc(r) ? [5, 4] : [1, 0]; | |
| /** @type {!Array} */ | |
| this.oa = [30, 0, 0, 0]; | |
| this.w = Wy.N(); | |
| this.O = Uk.N(); | |
| this.F = M.N(); | |
| /** @type {boolean} */ | |
| this.K = true; | |
| if (null != d) { | |
| d.a(this, "change"); | |
| } | |
| }; | |
| x(cz, L); | |
| /** | |
| * @param {!Object} o | |
| * @param {string} i | |
| * @return {undefined} | |
| */ | |
| var fz = function(o, i) { | |
| if (null == o.b) { | |
| /** @type {string} */ | |
| o.o = i; | |
| if ((null != gk[i] || o.C.a && null != hk[i]) && o.K) { | |
| /** @type {boolean} */ | |
| o.K = false; | |
| Sy.N().load(v(o.lf, o), o.W); | |
| } | |
| } else { | |
| if (o.L != i) { | |
| if (o.L = i, null != gk[i] || o.C.a && null != hk[i]) { | |
| var b = ik(o.C, i); | |
| var a = Yy(o.w, o.G, i); | |
| var c = o.w; | |
| var G = o.G; | |
| var p = Xy(c, G, i); | |
| i = q(p) ? p.isEnabled : kk(Yy(c, G, i)); | |
| /** @type {boolean} */ | |
| o.m = true; | |
| o.a = tb(b, a) ? a : b[0]; | |
| o.b.disableCurrentInputTool(); | |
| /** @type {string} */ | |
| o.c = i; | |
| o.b.setInputTools(b); | |
| o.b.activateInputTool(o.a); | |
| if (o.c) { | |
| o.b.enableCurrentInputTool(); | |
| } else { | |
| o.b.disableCurrentInputTool(); | |
| } | |
| if (null == o.g) { | |
| o.g = o.b.showControl({ | |
| ui : "kd", | |
| container : o.h | |
| }); | |
| } | |
| o.b.localize(o.R); | |
| o.g.show(); | |
| dz(o); | |
| ez(o); | |
| /** @type {boolean} */ | |
| o.m = false; | |
| b = o.c ? o.a : ""; | |
| o.O.b = r(b) ? Xk(b) : b; | |
| } else { | |
| o.b.disableCurrentInputTool(); | |
| if (null != o.g) { | |
| o.g.hide(); | |
| } | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} d | |
| * @return {undefined} | |
| */ | |
| var dz = function(d) { | |
| if (null != d.b) { | |
| d.b.repositionKeyboard(d.Y, d.Z, d.oa); | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| cz.prototype.isEnabled = function() { | |
| return null != this.b && this.c; | |
| }; | |
| /** | |
| * @param {(number|string)} content | |
| * @return {?} | |
| */ | |
| var gz = function(content) { | |
| return content.isEnabled() && kk(content.a); | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| cz.prototype.T = function(type) { | |
| dz(this); | |
| if (!this.m && (this.a != type.currInputToolName || this.c != type.currInputToolActive)) { | |
| this.a = type.currInputToolName; | |
| this.c = type.currInputToolActive; | |
| ez(this); | |
| type = this.c; | |
| var b = this.L; | |
| var R = this.R; | |
| var minHeight = this.G; | |
| var a = this.a; | |
| Zy(this.w, minHeight, true).update(b, type, a); | |
| $y((type ? "1" : "0") + "." + minHeight + "." + a, b, R); | |
| type = this.c ? this.a : ""; | |
| this.O.b = r(type) ? Xk(type) : type; | |
| if (this.c) { | |
| if (0 <= this.a.indexOf("-k0-")) { | |
| type = this.F; | |
| N(type, O(type, 171)); | |
| } else { | |
| if (kk(this.a)) { | |
| type = this.F; | |
| N(type, O(type, 172)); | |
| } else { | |
| if (jk(this.a)) { | |
| type = this.F; | |
| N(type, O(type, 146)); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| this.dispatchEvent("change"); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| cz.prototype.lf = function() { | |
| var s = new google.elements.inputtools.InputToolsController; | |
| s.setAutoDirection(false); | |
| s.setApplicationName("translate"); | |
| s.addPageElements([this.ea]); | |
| s.addEventListener(google.elements.inputtools.EventType.INPUT_TOOL_ENABLED, this.T, this); | |
| this.b = s; | |
| if ("" != this.o) { | |
| fz(this, this.o); | |
| /** @type {string} */ | |
| this.o = ""; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} target | |
| * @return {undefined} | |
| */ | |
| var ez = function(target) { | |
| var sub = E("ita-kd-inputtool-icon", target.h); | |
| if (null != sub) { | |
| var QueryLanguageComponent = kk(target.a) ? target.isEnabled() ? window.MSG_IME_OFF || "" : window.MSG_IME_ON || "" : 0 <= target.a.indexOf("-k0-") ? target.isEnabled() ? window.MSG_VK_OFF || "" : window.MSG_VK_ON || "" : jk(target.a) ? target.isEnabled() ? window.MSG_HW_OFF || "" : window.MSG_HW_ON || "" : ""; | |
| Xr(sub, QueryLanguageComponent, void 0); | |
| as(sub, 2); | |
| } | |
| target = E("ita-kd-dropdown", target.h); | |
| if (null != target) { | |
| Xr(target, window.MSG_CHANGE_ITA || "", void 0); | |
| as(target, 2); | |
| } | |
| }; | |
| wi("goog.dom.SavedRange"); | |
| /** | |
| * @param {string} type | |
| * @param {?} menuItems | |
| * @param {?} name | |
| * @param {undefined} value | |
| * @param {number} error_messages | |
| * @return {undefined} | |
| */ | |
| var iz = function(type, menuItems, name, value, error_messages) { | |
| /** @type {boolean} */ | |
| this.h = !!menuItems; | |
| /** @type {null} */ | |
| this.g = null; | |
| /** @type {number} */ | |
| this.c = 0; | |
| /** @type {boolean} */ | |
| this.L = false; | |
| /** @type {boolean} */ | |
| this.K = !name; | |
| if (type) { | |
| hz(this, type, value); | |
| } | |
| this.depth = void 0 != error_messages ? error_messages : this.c || 0; | |
| if (this.h) { | |
| this.depth *= -1; | |
| } | |
| }; | |
| x(iz, Pi); | |
| /** | |
| * @param {!Object} args | |
| * @param {string} target | |
| * @param {number} id | |
| * @param {number} num | |
| * @return {undefined} | |
| */ | |
| var hz = function(args, target, id, num) { | |
| if (args.g = target) { | |
| args.c = Aa(id) ? id : 1 != args.g.nodeType ? 0 : args.h ? -1 : 1; | |
| } | |
| if (Aa(num)) { | |
| /** @type {number} */ | |
| args.depth = num; | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| iz.prototype.next = function() { | |
| if (this.L) { | |
| if (!this.g || this.K && 0 == this.depth) { | |
| throw Oi; | |
| } | |
| var c = this.g; | |
| /** @type {number} */ | |
| var quote = this.h ? -1 : 1; | |
| if (this.c == quote) { | |
| var QueryLanguageComponent = this.h ? c.lastChild : c.firstChild; | |
| if (QueryLanguageComponent) { | |
| hz(this, QueryLanguageComponent); | |
| } else { | |
| hz(this, c, -1 * quote); | |
| } | |
| } else { | |
| if (QueryLanguageComponent = this.h ? c.previousSibling : c.nextSibling) { | |
| hz(this, QueryLanguageComponent); | |
| } else { | |
| hz(this, c.parentNode, -1 * quote); | |
| } | |
| } | |
| this.depth += this.c * (this.h ? -1 : 1); | |
| } else { | |
| /** @type {boolean} */ | |
| this.L = true; | |
| } | |
| c = this.g; | |
| if (!this.g) { | |
| throw Oi; | |
| } | |
| return c; | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| iz.prototype.Oc = function(value) { | |
| return value.g == this.g && (!this.g || value.c == this.c); | |
| }; | |
| /** | |
| * @param {number} pos | |
| * @return {undefined} | |
| */ | |
| iz.prototype.splice = function(pos) { | |
| var g = this.g; | |
| /** @type {number} */ | |
| var args = this.h ? 1 : -1; | |
| if (this.c == args) { | |
| /** @type {number} */ | |
| this.c = -1 * args; | |
| this.depth += this.c * (this.h ? -1 : 1); | |
| } | |
| /** @type {boolean} */ | |
| this.h = !this.h; | |
| iz.prototype.next.call(this); | |
| /** @type {boolean} */ | |
| this.h = !this.h; | |
| args = La(arguments[0]) ? arguments[0] : arguments; | |
| /** @type {number} */ | |
| var callbackPosition = args.length - 1; | |
| for (; 0 <= callbackPosition; callbackPosition--) { | |
| Hf(args[callbackPosition], g); | |
| } | |
| Jf(g); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var jz = function() { | |
| }; | |
| /** | |
| * @param {!Object} doc | |
| * @return {?} | |
| */ | |
| var kz = 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} r | |
| * @return {?} | |
| */ | |
| var lz = function(r) { | |
| /** @type {!Array} */ | |
| var xmlCells = []; | |
| /** @type {number} */ | |
| var c = 0; | |
| var complexSize = r.bf(); | |
| for (; c < complexSize; c++) { | |
| xmlCells.push(r.ke(c)); | |
| } | |
| return xmlCells; | |
| }; | |
| /** | |
| * @param {!Object} msg | |
| * @return {?} | |
| */ | |
| var mz = function(msg) { | |
| return msg.Dh() ? msg.cc() : msg.Cc(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| jz.prototype.Dh = function() { | |
| return false; | |
| }; | |
| /** | |
| * @param {?} obj2 | |
| * @param {?} speed | |
| * @return {undefined} | |
| */ | |
| var nz = function(obj2, speed) { | |
| iz.call(this, obj2, speed, true); | |
| }; | |
| x(nz, iz); | |
| /** | |
| * @param {!Object} a | |
| * @param {string} b | |
| * @param {!Node} t | |
| * @param {?} pos | |
| * @param {?} prevByte | |
| * @return {undefined} | |
| */ | |
| var oz = function(a, b, t, pos, prevByte) { | |
| /** @type {null} */ | |
| this.b = this.a = null; | |
| /** @type {number} */ | |
| this.G = this.C = 0; | |
| /** @type {boolean} */ | |
| this.o = !!prevByte; | |
| if (a) { | |
| /** @type {!Object} */ | |
| this.a = a; | |
| /** @type {string} */ | |
| this.C = b; | |
| /** @type {!Node} */ | |
| this.b = t; | |
| this.G = pos; | |
| if (1 == a.nodeType && "BR" != a.tagName) { | |
| if (a = a.childNodes, b = a[b]) { | |
| /** @type {string} */ | |
| this.a = b; | |
| /** @type {number} */ | |
| this.C = 0; | |
| } else { | |
| if (a.length) { | |
| this.a = jb(a); | |
| } | |
| /** @type {boolean} */ | |
| var f = true; | |
| } | |
| } | |
| if (1 == t.nodeType) { | |
| if (this.b = t.childNodes[pos]) { | |
| /** @type {number} */ | |
| this.G = 0; | |
| } else { | |
| /** @type {!Node} */ | |
| this.b = t; | |
| } | |
| } | |
| } | |
| iz.call(this, this.o ? this.b : this.a, this.o, true); | |
| if (f) { | |
| try { | |
| this.next(); | |
| } catch (g) { | |
| if (g != Oi) { | |
| throw g; | |
| } | |
| } | |
| } | |
| }; | |
| x(oz, nz); | |
| /** | |
| * @return {?} | |
| */ | |
| oz.prototype.w = function() { | |
| return this.a; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| oz.prototype.m = function() { | |
| return this.L && (this.g != (this.o ? this.a : this.b) ? false : this.o ? this.C ? -1 != this.c : 1 == this.c : !this.G || 1 != this.c); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| oz.prototype.next = function() { | |
| if (this.m()) { | |
| throw Oi; | |
| } | |
| return oz.D.next.call(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var pz = function() { | |
| }; | |
| /** | |
| * @param {!Object} actual | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| var qz = function(actual, value) { | |
| value = value.Xe(); | |
| try { | |
| return 0 <= actual.yc(value, 0, 0) && 0 >= actual.yc(value, 1, 1); | |
| } catch (c) { | |
| if (!C.V) { | |
| throw c; | |
| } | |
| return false; | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| pz.prototype.xc = function() { | |
| return new oz(this.mc(), this.Rc(), this.Qc(), this.ed()); | |
| }; | |
| /** | |
| * @param {number} a | |
| * @return {undefined} | |
| */ | |
| var rz = function(a) { | |
| /** @type {number} */ | |
| this.a = a; | |
| }; | |
| x(rz, pz); | |
| /** | |
| * @param {!Object} i | |
| * @return {?} | |
| */ | |
| var tz = function(i) { | |
| var self = hf(i).createRange(); | |
| if (3 == i.nodeType) { | |
| self.setStart(i, 0); | |
| self.setEnd(i, i.length); | |
| } else { | |
| if (sz(i)) { | |
| var el; | |
| /** @type {!Object} */ | |
| var target = i; | |
| for (; (el = target.firstChild) && sz(el);) { | |
| target = el; | |
| } | |
| self.setStart(target, 0); | |
| /** @type {!Object} */ | |
| target = i; | |
| for (; (el = target.lastChild) && sz(el);) { | |
| target = el; | |
| } | |
| self.setEnd(target, 1 == target.nodeType ? target.childNodes.length : target.length); | |
| } else { | |
| el = i.parentNode; | |
| i = kb(el.childNodes, i); | |
| self.setStart(el, i); | |
| self.setEnd(el, i + 1); | |
| } | |
| } | |
| return self; | |
| }; | |
| /** | |
| * @param {!Object} startNode | |
| * @param {?} startOffset | |
| * @param {?} endNode | |
| * @param {?} endOffset | |
| * @return {?} | |
| */ | |
| var uz = function(startNode, startOffset, endNode, endOffset) { | |
| var wrange = hf(startNode).createRange(); | |
| wrange.setStart(startNode, startOffset); | |
| wrange.setEnd(endNode, endOffset); | |
| return wrange; | |
| }; | |
| k = rz.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Xe = function() { | |
| return this.a; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.jh = function() { | |
| return this.a.commonAncestorContainer; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.mc = function() { | |
| return this.a.startContainer; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Rc = function() { | |
| return this.a.startOffset; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Qc = function() { | |
| return this.a.endContainer; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.ed = function() { | |
| return this.a.endOffset; | |
| }; | |
| /** | |
| * @param {!Object} range | |
| * @param {number} method | |
| * @param {number} matchAny | |
| * @return {?} | |
| */ | |
| k.yc = function(range, method, matchAny) { | |
| return this.a.compareBoundaryPoints(1 == matchAny ? 1 == method ? l.Range.START_TO_START : l.Range.START_TO_END : 1 == method ? l.Range.END_TO_START : l.Range.END_TO_END, range); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.nc = function() { | |
| return this.a.collapsed; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.cj = function() { | |
| return this.a.toString(); | |
| }; | |
| /** | |
| * @param {?} a | |
| * @return {undefined} | |
| */ | |
| k.select = function(a) { | |
| var message = vf(hf(this.mc())); | |
| this.pf(message.getSelection(), a); | |
| }; | |
| /** | |
| * @param {!Selection} s | |
| * @return {undefined} | |
| */ | |
| k.pf = function(s) { | |
| s.removeAllRanges(); | |
| s.addRange(this.a); | |
| }; | |
| /** | |
| * @param {number} a | |
| * @return {undefined} | |
| */ | |
| var vz = function(a) { | |
| /** @type {number} */ | |
| this.a = a; | |
| }; | |
| x(vz, rz); | |
| /** | |
| * @param {!Object} config | |
| * @param {?} options | |
| * @return {undefined} | |
| */ | |
| vz.prototype.pf = function(config, options) { | |
| if (!options || this.nc()) { | |
| vz.D.pf.call(this, config, options); | |
| } else { | |
| config.collapse(this.Qc(), this.ed()); | |
| config.extend(this.mc(), this.Rc()); | |
| } | |
| }; | |
| /** | |
| * @param {number} compiler | |
| * @return {undefined} | |
| */ | |
| var wz = function(compiler) { | |
| /** @type {null} */ | |
| this.b = this.a = this.o = null; | |
| /** @type {number} */ | |
| this.h = this.g = -1; | |
| /** @type {number} */ | |
| this.c = compiler; | |
| }; | |
| x(wz, pz); | |
| var xz = wi("goog.dom.browserrange.IeRange"); | |
| /** | |
| * @param {!Object} node | |
| * @return {?} | |
| */ | |
| var yz = function(node) { | |
| var nodeRange = hf(node).body.createTextRange(); | |
| if (1 == node.nodeType) { | |
| nodeRange.moveToElementText(node); | |
| if (sz(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("character", offset); | |
| } | |
| nodeRange.moveEnd("character", node.length); | |
| } | |
| return nodeRange; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| wz.prototype.Xe = function() { | |
| return this.c; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| wz.prototype.jh = function() { | |
| if (!this.o) { | |
| var c = this.c.text; | |
| var e = this.c.duplicate(); | |
| var a = c.replace(/ +$/, ""); | |
| if (a = c.length - a.length) { | |
| e.moveEnd("character", -a); | |
| } | |
| a = e.parentElement(); | |
| e = e.htmlText.replace(/(\r\n|\r|\n)+/g, " ").length; | |
| if (this.nc() && 0 < e) { | |
| return this.o = a; | |
| } | |
| for (; e > a.outerHTML.replace(/(\r\n|\r|\n)+/g, " ").length;) { | |
| a = a.parentNode; | |
| } | |
| for (; 1 == a.childNodes.length && a.innerText == zz(a.firstChild) && sz(a.firstChild);) { | |
| a = a.firstChild; | |
| } | |
| if (0 == c.length) { | |
| a = Az(this, a); | |
| } | |
| this.o = a; | |
| } | |
| return this.o; | |
| }; | |
| /** | |
| * @param {!Object} that | |
| * @param {!Node} d | |
| * @return {?} | |
| */ | |
| var Az = function(that, d) { | |
| var children = d.childNodes; | |
| /** @type {number} */ | |
| var i = 0; | |
| var length = children.length; | |
| for (; i < length; i++) { | |
| var item = children[i]; | |
| if (sz(item)) { | |
| var value = yz(item); | |
| /** @type {boolean} */ | |
| var isCrossDomainUrl = value.htmlText != item.outerHTML; | |
| if (that.nc() && isCrossDomainUrl ? 0 <= that.yc(value, 1, 1) && 0 >= that.yc(value, 1, 0) : that.c.inRange(value)) { | |
| return Az(that, item); | |
| } | |
| } | |
| } | |
| return d; | |
| }; | |
| k = wz.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| k.mc = function() { | |
| if (!this.a) { | |
| this.a = Bz(this, 1); | |
| if (this.nc()) { | |
| this.b = this.a; | |
| } | |
| } | |
| return this.a; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Rc = function() { | |
| if (0 > this.g) { | |
| this.g = Cz(this, 1); | |
| if (this.nc()) { | |
| this.h = this.g; | |
| } | |
| } | |
| return this.g; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Qc = function() { | |
| if (this.nc()) { | |
| return this.mc(); | |
| } | |
| if (!this.b) { | |
| this.b = Bz(this, 0); | |
| } | |
| return this.b; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.ed = function() { | |
| if (this.nc()) { | |
| return this.Rc(); | |
| } | |
| if (0 > this.h) { | |
| this.h = Cz(this, 0); | |
| if (this.nc()) { | |
| this.g = this.h; | |
| } | |
| } | |
| return this.h; | |
| }; | |
| /** | |
| * @param {!Object} num | |
| * @param {number} method | |
| * @param {number} matchAny | |
| * @return {?} | |
| */ | |
| k.yc = function(num, method, matchAny) { | |
| return this.c.compareEndPoints((1 == method ? "Start" : "End") + "To" + (1 == matchAny ? "Start" : "End"), num); | |
| }; | |
| /** | |
| * @param {!Object} result | |
| * @param {number} url | |
| * @param {!Object} row | |
| * @return {?} | |
| */ | |
| var Bz = function(result, url, row) { | |
| row = row || result.jh(); | |
| if (!row || !row.firstChild) { | |
| return row; | |
| } | |
| /** @type {boolean} */ | |
| var _linkTypeIsUrl = 1 == url; | |
| /** @type {number} */ | |
| var currentNumber = 0; | |
| var connectNumber = row.childNodes.length; | |
| for (; currentNumber < connectNumber; currentNumber++) { | |
| /** @type {number} */ | |
| var g = _linkTypeIsUrl ? currentNumber : connectNumber - currentNumber - 1; | |
| var item = row.childNodes[g]; | |
| try { | |
| var remaining = Dz(item); | |
| } catch (p) { | |
| continue; | |
| } | |
| var txt = remaining.Xe(); | |
| if (result.nc()) { | |
| if (!sz(item)) { | |
| if (0 == result.yc(txt, 1, 1)) { | |
| /** @type {number} */ | |
| result.g = result.h = g; | |
| break; | |
| } | |
| } else { | |
| if (qz(remaining, result)) { | |
| return Bz(result, url, item); | |
| } | |
| } | |
| } else { | |
| if (qz(result, remaining)) { | |
| if (!sz(item)) { | |
| if (_linkTypeIsUrl) { | |
| /** @type {number} */ | |
| result.g = g; | |
| } else { | |
| /** @type {number} */ | |
| result.h = g + 1; | |
| } | |
| break; | |
| } | |
| return Bz(result, url, item); | |
| } | |
| if (0 > result.yc(txt, 1, 0) && 0 < result.yc(txt, 0, 1)) { | |
| return Bz(result, url, item); | |
| } | |
| } | |
| } | |
| return row; | |
| }; | |
| /** | |
| * @param {!Object} r | |
| * @param {number} a | |
| * @return {?} | |
| */ | |
| var Cz = function(r, a) { | |
| /** @type {boolean} */ | |
| var isStartEndpoint = 1 == a; | |
| var c = isStartEndpoint ? r.mc() : r.Qc(); | |
| if (1 == c.nodeType) { | |
| c = c.childNodes; | |
| var len = c.length; | |
| /** @type {number} */ | |
| var sign = isStartEndpoint ? 1 : -1; | |
| /** @type {number} */ | |
| var i = isStartEndpoint ? 0 : len - 1; | |
| for (; 0 <= i && i < len; i = i + sign) { | |
| var p = c[i]; | |
| if (!sz(p) && 0 == r.c.compareEndPoints((1 == a ? "Start" : "End") + "To" + (1 == a ? "Start" : "End"), Dz(p).Xe())) { | |
| return isStartEndpoint ? i : i + 1; | |
| } | |
| } | |
| return -1 == i ? 0 : i; | |
| } | |
| r = r.c.duplicate(); | |
| a = yz(c); | |
| r.setEndPoint(isStartEndpoint ? "EndToEnd" : "StartToStart", a); | |
| r = r.text.length; | |
| return isStartEndpoint ? c.length - r : r; | |
| }; | |
| /** | |
| * @param {!Node} oDom | |
| * @return {?} | |
| */ | |
| var zz = function(oDom) { | |
| return 3 == oDom.nodeType ? oDom.nodeValue : oDom.innerText; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| wz.prototype.nc = function() { | |
| return 0 == this.c.compareEndPoints("StartToEnd", this.c); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| wz.prototype.cj = function() { | |
| return this.c.text; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| wz.prototype.select = function() { | |
| this.c.select(); | |
| }; | |
| /** | |
| * @param {number} a | |
| * @return {undefined} | |
| */ | |
| var Ez = function(a) { | |
| /** @type {number} */ | |
| this.a = a; | |
| }; | |
| x(Ez, rz); | |
| /** | |
| * @param {!Selection} s | |
| * @return {undefined} | |
| */ | |
| Ez.prototype.pf = function(s) { | |
| s.collapse(this.mc(), this.Rc()); | |
| if (!(this.Qc() == this.mc() && this.ed() == this.Rc())) { | |
| s.extend(this.Qc(), this.ed()); | |
| } | |
| if (0 == s.rangeCount) { | |
| s.addRange(this.a); | |
| } | |
| }; | |
| /** | |
| * @param {number} a | |
| * @return {undefined} | |
| */ | |
| var Fz = function(a) { | |
| /** @type {number} */ | |
| this.a = a; | |
| }; | |
| x(Fz, rz); | |
| /** | |
| * @param {!Object} sel | |
| * @param {number} b | |
| * @param {number} externals | |
| * @return {?} | |
| */ | |
| Fz.prototype.yc = function(sel, b, externals) { | |
| return C.Ea("528") ? Fz.D.yc.call(this, sel, b, externals) : this.a.compareBoundaryPoints(1 == externals ? 1 == b ? l.Range.START_TO_START : l.Range.END_TO_START : 1 == b ? l.Range.START_TO_END : l.Range.END_TO_END, sel); | |
| }; | |
| /** | |
| * @param {!Selection} s | |
| * @param {?} topic | |
| * @return {undefined} | |
| */ | |
| Fz.prototype.pf = function(s, topic) { | |
| if (topic) { | |
| s.setBaseAndExtent(this.Qc(), this.ed(), this.mc(), this.Rc()); | |
| } else { | |
| s.setBaseAndExtent(this.mc(), this.Rc(), this.Qc(), this.ed()); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} pane | |
| * @return {?} | |
| */ | |
| var Gz = function(pane) { | |
| return af ? new wz(pane, hf(pane.parentElement())) : C.Ka ? new Fz(pane) : C.Ja ? new vz(pane) : C.cb ? new Ez(pane) : new rz(pane); | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| var Dz = function(b) { | |
| if (C.V && !C.kb(9)) { | |
| var a = new wz(yz(b), hf(b)); | |
| if (sz(b)) { | |
| var el; | |
| /** @type {!Object} */ | |
| var p = b; | |
| for (; (el = p.firstChild) && sz(el);) { | |
| p = el; | |
| } | |
| a.a = p; | |
| /** @type {number} */ | |
| a.g = 0; | |
| /** @type {!Object} */ | |
| p = b; | |
| for (; (el = p.lastChild) && sz(el);) { | |
| p = el; | |
| } | |
| a.b = p; | |
| a.h = 1 == p.nodeType ? p.childNodes.length : p.length; | |
| /** @type {!Object} */ | |
| a.o = b; | |
| } else { | |
| a.a = a.b = a.o = b.parentNode; | |
| a.g = kb(a.o.childNodes, b); | |
| a.h = a.g + 1; | |
| } | |
| b = a; | |
| } else { | |
| b = C.Ka ? new Fz(tz(b)) : C.Ja ? new vz(tz(b)) : C.cb ? new Ez(tz(b)) : new rz(tz(b)); | |
| } | |
| return b; | |
| }; | |
| /** | |
| * @param {!Object} el | |
| * @return {?} | |
| */ | |
| var sz = function(el) { | |
| return Cf(el) || 3 == el.nodeType; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Hz = function() { | |
| /** @type {null} */ | |
| this.c = this.b = this.h = this.a = this.o = null; | |
| /** @type {boolean} */ | |
| this.g = false; | |
| }; | |
| x(Hz, jz); | |
| /** | |
| * @param {(Object|string)} value | |
| * @param {!Function} error_messages | |
| * @return {?} | |
| */ | |
| var Iz = function(value, error_messages) { | |
| var h = new Hz; | |
| /** @type {(Object|string)} */ | |
| h.o = value; | |
| /** @type {boolean} */ | |
| h.g = !!error_messages; | |
| return h; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Object} opt_max | |
| * @return {?} | |
| */ | |
| var Jz = function(a, opt_max) { | |
| return Iz(Dz(a), opt_max); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Hz.prototype.Tb = function() { | |
| return "text"; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Hz.prototype.fh = function() { | |
| return Kz(this).Xe(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Hz.prototype.bf = function() { | |
| return 1; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Hz.prototype.ke = function() { | |
| return this; | |
| }; | |
| /** | |
| * @param {!Object} that | |
| * @return {?} | |
| */ | |
| var Kz = function(that) { | |
| var b; | |
| if (!(b = that.o)) { | |
| b = that.cc(); | |
| var x = that.dc(); | |
| var a = that.Cc(); | |
| var n = that.Dc(); | |
| if (C.V && !C.kb(9)) { | |
| var r = b; | |
| var j = x; | |
| var s = a; | |
| var m = n; | |
| /** @type {boolean} */ | |
| var pos = false; | |
| if (1 == r.nodeType) { | |
| if (j > r.childNodes.length) { | |
| xi(xz, "Cannot have startOffset > startNode child count"); | |
| } | |
| j = r.childNodes[j]; | |
| /** @type {boolean} */ | |
| pos = !j; | |
| r = j || r.lastChild || r; | |
| /** @type {number} */ | |
| j = 0; | |
| } | |
| var range = yz(r); | |
| if (j) { | |
| range.move("character", j); | |
| } | |
| if (r == s && j == m) { | |
| range.collapse(true); | |
| } else { | |
| if (pos) { | |
| range.collapse(false); | |
| } | |
| /** @type {boolean} */ | |
| pos = false; | |
| if (1 == s.nodeType) { | |
| if (m > s.childNodes.length) { | |
| xi(xz, "Cannot have endOffset > endNode child count"); | |
| } | |
| s = (j = s.childNodes[m]) || s.lastChild || s; | |
| /** @type {number} */ | |
| m = 0; | |
| /** @type {boolean} */ | |
| pos = !j; | |
| } | |
| r = yz(s); | |
| r.collapse(!pos); | |
| if (m) { | |
| r.moveEnd("character", m); | |
| } | |
| range.setEndPoint("EndToEnd", r); | |
| } | |
| m = new wz(range, hf(b)); | |
| m.a = b; | |
| m.g = x; | |
| m.b = a; | |
| m.h = n; | |
| b = m; | |
| } else { | |
| b = C.Ka ? new Fz(uz(b, x, a, n)) : C.Ja ? new vz(uz(b, x, a, n)) : C.cb ? new Ez(uz(b, x, a, n)) : new rz(uz(b, x, a, n)); | |
| } | |
| b = that.o = b; | |
| } | |
| return b; | |
| }; | |
| k = Hz.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Qf = function() { | |
| return Kz(this).jh(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.cc = function() { | |
| return this.a || (this.a = Kz(this).mc()); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.dc = function() { | |
| return null != this.h ? this.h : this.h = Kz(this).Rc(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Cc = function() { | |
| return this.b || (this.b = Kz(this).Qc()); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Dc = function() { | |
| return null != this.c ? this.c : this.c = Kz(this).ed(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Dh = function() { | |
| return this.g; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Sf = function() { | |
| return Kz(this).nc(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Rf = function() { | |
| return Kz(this).cj(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.xc = function() { | |
| return new oz(this.cc(), this.dc(), this.Cc(), this.Dc()); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.select = function() { | |
| Kz(this).select(this.g); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Lz = function() { | |
| }; | |
| x(Lz, jz); | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Mz = function() { | |
| /** @type {null} */ | |
| this.c = this.b = this.a = null; | |
| }; | |
| x(Mz, Lz); | |
| k = Mz.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Tb = function() { | |
| return "control"; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.fh = function() { | |
| return this.a || document.body.createControlRange(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.bf = function() { | |
| return this.a ? this.a.length : 0; | |
| }; | |
| /** | |
| * @param {number} a | |
| * @return {?} | |
| */ | |
| k.ke = function(a) { | |
| return Jz(this.a.item(a)); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Qf = function() { | |
| return Tf.apply(null, Nz(this)); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.cc = function() { | |
| return Oz(this)[0]; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.dc = function() { | |
| return 0; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Cc = function() { | |
| var a = Oz(this); | |
| var b = jb(a); | |
| return rb(a, function(c) { | |
| return Pf(c, b); | |
| }); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Dc = function() { | |
| return this.Cc().childNodes.length; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var Nz = 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 Oz = function(a) { | |
| if (!a.c) { | |
| a.c = Nz(a).concat(); | |
| a.c.sort(function(a, b) { | |
| return a.sourceIndex - b.sourceIndex; | |
| }); | |
| } | |
| return a.c; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Mz.prototype.Sf = function() { | |
| return !this.a || !this.a.length; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Mz.prototype.Rf = function() { | |
| return ""; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Mz.prototype.xc = function() { | |
| return new Pz(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| Mz.prototype.select = function() { | |
| if (this.a) { | |
| this.a.select(); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} base | |
| * @return {undefined} | |
| */ | |
| var Pz = function(base) { | |
| /** @type {null} */ | |
| this.o = this.b = this.a = null; | |
| if (base) { | |
| this.o = Oz(base); | |
| this.a = this.o.shift(); | |
| this.b = jb(this.o) || this.a; | |
| } | |
| iz.call(this, this.a, false, true); | |
| }; | |
| x(Pz, nz); | |
| /** | |
| * @return {?} | |
| */ | |
| Pz.prototype.w = function() { | |
| return this.a; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Pz.prototype.m = function() { | |
| return !this.depth && !this.o.length; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Pz.prototype.next = function() { | |
| if (this.m()) { | |
| throw Oi; | |
| } | |
| if (!this.depth) { | |
| var article = this.o.shift(); | |
| hz(this, article, 1, 1); | |
| return article; | |
| } | |
| return Pz.D.next.call(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var Qz = function() { | |
| this.F = wi("goog.dom.MultiRange"); | |
| /** @type {!Array} */ | |
| this.a = []; | |
| /** @type {!Array} */ | |
| this.g = []; | |
| /** @type {null} */ | |
| this.c = this.b = null; | |
| }; | |
| x(Qz, Lz); | |
| k = Qz.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Tb = function() { | |
| return "mutli"; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.fh = function() { | |
| if (1 < this.a.length) { | |
| yi(this.F, "getBrowserRangeObject called on MultiRange with more than 1 range"); | |
| } | |
| return this.a[0]; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.bf = function() { | |
| return this.a.length; | |
| }; | |
| /** | |
| * @param {number} key | |
| * @return {?} | |
| */ | |
| k.ke = function(key) { | |
| if (!this.g[key]) { | |
| this.g[key] = Iz(Gz(this.a[key]), void 0); | |
| } | |
| return this.g[key]; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Qf = function() { | |
| if (!this.c) { | |
| /** @type {!Array} */ | |
| var searchPipeline = []; | |
| /** @type {number} */ | |
| var j = 0; | |
| var rown = this.bf(); | |
| for (; j < rown; j++) { | |
| searchPipeline.push(this.ke(j).Qf()); | |
| } | |
| this.c = Tf.apply(null, searchPipeline); | |
| } | |
| return this.c; | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| var Sz = function(value) { | |
| if (!value.b) { | |
| value.b = lz(value); | |
| value.b.sort(function(l, r) { | |
| var t = l.cc(); | |
| l = l.dc(); | |
| var b = r.cc(); | |
| r = r.dc(); | |
| return t == b && l == r ? 0 : Rz(t, l, b, r) ? 1 : -1; | |
| }); | |
| } | |
| return value.b; | |
| }; | |
| k = Qz.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| k.cc = function() { | |
| return Sz(this)[0].cc(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.dc = function() { | |
| return Sz(this)[0].dc(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Cc = function() { | |
| return jb(Sz(this)).Cc(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Dc = function() { | |
| return jb(Sz(this)).Dc(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Sf = function() { | |
| return 0 == this.a.length || 1 == this.a.length && this.ke(0).Sf(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Rf = function() { | |
| return mb(lz(this), function(a) { | |
| return a.Rf(); | |
| }).join(""); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.xc = function() { | |
| return new Tz(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.select = function() { | |
| var selection = kz(vf(hf(C.V ? this.Qf() : this.cc()))); | |
| selection.removeAllRanges(); | |
| /** @type {number} */ | |
| var j = 0; | |
| var rown = this.bf(); | |
| for (; j < rown; j++) { | |
| selection.addRange(this.ke(j).fh()); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} event | |
| * @return {undefined} | |
| */ | |
| var Tz = function(event) { | |
| /** @type {null} */ | |
| this.a = null; | |
| /** @type {number} */ | |
| this.b = 0; | |
| if (event) { | |
| this.a = mb(Sz(event), function(b) { | |
| return Qi(b); | |
| }); | |
| } | |
| iz.call(this, event ? this.w() : null, false, true); | |
| }; | |
| x(Tz, nz); | |
| /** | |
| * @return {?} | |
| */ | |
| Tz.prototype.w = function() { | |
| return this.a[0].w(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Tz.prototype.m = function() { | |
| return this.a[this.b].m(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| Tz.prototype.next = function() { | |
| try { | |
| var b = this.a[this.b]; | |
| var nextNote = b.next(); | |
| hz(this, b.g, b.c, b.depth); | |
| return nextNote; | |
| } catch (c) { | |
| if (c !== Oi || this.a.length - 1 == this.b) { | |
| throw c; | |
| } | |
| this.b++; | |
| return this.next(); | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var Vz = function() { | |
| var el = kz(window); | |
| return el && Uz(el); | |
| }; | |
| /** | |
| * @param {!Object} sel | |
| * @return {?} | |
| */ | |
| var Uz = function(sel) { | |
| /** @type {boolean} */ | |
| var item = false; | |
| if (sel.createRange) { | |
| try { | |
| var i = sel.createRange(); | |
| } catch (e) { | |
| return null; | |
| } | |
| } else { | |
| if (sel.rangeCount) { | |
| if (1 < sel.rangeCount) { | |
| item = new Qz; | |
| /** @type {number} */ | |
| i = 0; | |
| var len = sel.rangeCount; | |
| for (; i < len; i++) { | |
| item.a.push(sel.getRangeAt(i)); | |
| } | |
| return item; | |
| } | |
| i = sel.getRangeAt(0); | |
| item = Rz(sel.anchorNode, sel.anchorOffset, sel.focusNode, sel.focusOffset); | |
| } else { | |
| return null; | |
| } | |
| } | |
| if ((sel = i) && sel.addElement) { | |
| item = new Mz; | |
| /** @type {!Object} */ | |
| item.a = sel; | |
| sel = item; | |
| } else { | |
| sel = Iz(Gz(sel), item); | |
| } | |
| return sel; | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @param {!Object} x | |
| * @param {!Object} a | |
| * @param {!Object} n | |
| * @return {?} | |
| */ | |
| var Rz = function(b, x, a, n) { | |
| if (b == a) { | |
| return n < x; | |
| } | |
| var c; | |
| if (1 == b.nodeType && x) { | |
| if (c = b.childNodes[x]) { | |
| b = c; | |
| /** @type {number} */ | |
| x = 0; | |
| } else { | |
| if (Pf(b, a)) { | |
| return true; | |
| } | |
| } | |
| } | |
| if (1 == a.nodeType && n) { | |
| if (c = a.childNodes[n]) { | |
| a = c; | |
| /** @type {number} */ | |
| n = 0; | |
| } else { | |
| if (Pf(a, b)) { | |
| return false; | |
| } | |
| } | |
| } | |
| return 0 < (Sf(b, a) || x - n); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var Wz = function() { | |
| var a = Vz(); | |
| return null != a && !a.Sf() && 0 < a.Rf().length; | |
| }; | |
| /** | |
| * @param {!Object} element | |
| * @return {undefined} | |
| */ | |
| var Xz = function(element) { | |
| Vz(); | |
| Jz(element, void 0).select(); | |
| element.setAttribute("tabIndex", "-1"); | |
| }; | |
| /** | |
| * @param {number} v | |
| * @return {?} | |
| */ | |
| var Yz = function(v) { | |
| var x = G("TEXTAREA", { | |
| id : "hdt" | |
| }); | |
| Hp(x, { | |
| position : "absolute", | |
| top : uf(document).a + "px", | |
| left : "-1000px" | |
| }); | |
| Df(document.body, x); | |
| x.focus(); | |
| H(x, v); | |
| /** @type {number} */ | |
| v = 0; | |
| if (Yv(x)) { | |
| /** @type {number} */ | |
| x.selectionStart = v; | |
| } else { | |
| if (Zv()) { | |
| var c = $v(x); | |
| var d = c[0]; | |
| if (d.inRange(c[1])) { | |
| v = bw(x, v); | |
| d.collapse(true); | |
| d.move("character", v); | |
| d.select(); | |
| } | |
| } | |
| } | |
| v = x.value.length; | |
| if (Yv(x)) { | |
| /** @type {number} */ | |
| x.selectionEnd = v; | |
| } else { | |
| if (Zv()) { | |
| d = $v(x); | |
| c = d[1]; | |
| if (d[0].inRange(c)) { | |
| v = bw(x, v); | |
| d = bw(x, aw(x, true)[0]); | |
| c.collapse(true); | |
| c.moveEnd("character", v - d); | |
| c.select(); | |
| } | |
| } | |
| } | |
| return x; | |
| }; | |
| /** | |
| * @param {number} x | |
| * @param {?} miniBatchSize | |
| * @param {string} eta | |
| * @param {?} lmbda | |
| * @param {string} n | |
| * @param {number} w | |
| * @param {!Array} input | |
| * @return {undefined} | |
| */ | |
| var Zz = function(x, miniBatchSize, eta, lmbda, n, w, input) { | |
| input = void 0 === input ? function() { | |
| } : input; | |
| this.L = hm.N(); | |
| this.G = miniBatchSize; | |
| /** @type {string} */ | |
| this.g = eta; | |
| this.C = lmbda; | |
| this.o = n || null; | |
| /** @type {number} */ | |
| this.w = w; | |
| /** @type {!Array} */ | |
| this.m = input; | |
| /** @type {number} */ | |
| this.b = this.c = this.a = 0; | |
| this.F = M.N(); | |
| this.delay = new Dr(this.vg, 3E3, this); | |
| /** @type {number} */ | |
| this.h = x; | |
| I(x, "copy", this.ik, false, this); | |
| I(x, "mouseup", this.jk, false, this); | |
| I(x, "contextmenu", this.hj, false, this); | |
| I(x, "click", this.hk, false, this); | |
| I(l, "blur", this.flush, false, this); | |
| I(l, "beforeunload", this.flush, false, this); | |
| }; | |
| x(Zz, hg); | |
| k = Zz.prototype; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.flush = function() { | |
| this.delay.stop(); | |
| if (0 < this.a + this.c + this.b) { | |
| this.vg(); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.X = function() { | |
| this.flush(); | |
| this.delay.Qa(); | |
| Og(this.h, "copy", this.ik, false, this); | |
| Og(this.h, "mouseup", this.jk, false, this); | |
| Og(this.h, "contextmenu", this.hj, false, this); | |
| Og(this.h, "click", this.hk, false, this); | |
| Og(l, "blur", this.flush, false, this); | |
| Og(l, "beforeunload", this.flush, false, this); | |
| Zz.D.X.call(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.ik = function() { | |
| this.delay.stop(); | |
| if (q(this.w)) { | |
| var a = this.w().length; | |
| var b = null != l.getSelection ? l.getSelection().toString().length : document.selection && "Control" != document.selection.type ? document.selection.createRange().text.length : 0; | |
| this.vg(1, a, b); | |
| Il(this.F, this.g, this.m(), a, b); | |
| } else { | |
| this.vg(1); | |
| Il(this.F, this.g, this.m()); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @param {?} a | |
| * @param {?} b | |
| * @return {undefined} | |
| */ | |
| k.vg = function(data, a, b) { | |
| data = { | |
| cpy : data || 0, | |
| clk : this.a, | |
| sel : this.c, | |
| ctx : this.b | |
| }; | |
| if (null != a && null != b) { | |
| data.ql = a; | |
| data.cpl = b; | |
| } | |
| if (null != this.o) { | |
| data.sl = this.o.a(); | |
| data.tl = this.o.b(); | |
| } | |
| mm(this.L, this.C, "ilog", this.G, data); | |
| /** @type {number} */ | |
| this.b = this.c = this.a = 0; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.jk = function() { | |
| if (Wz()) { | |
| this.c++; | |
| var Symbol = this.F; | |
| N(Symbol, Gl(Symbol, 211, this.g)); | |
| if (59 <= this.c) { | |
| this.flush(); | |
| } else { | |
| this.delay.start(); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| k.hk = function(a) { | |
| if (vg(a)) { | |
| this.a++; | |
| a = this.F; | |
| N(a, Gl(a, 212, this.g)); | |
| if (59 <= this.a) { | |
| this.flush(); | |
| } else { | |
| this.delay.start(); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.hj = function() { | |
| this.b++; | |
| var Symbol = this.F; | |
| N(Symbol, Gl(Symbol, 210, this.g)); | |
| if (59 <= this.b) { | |
| this.flush(); | |
| } else { | |
| this.delay.start(); | |
| } | |
| }; | |
| var $z = { | |
| 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 : "end", | |
| 36 : "home", | |
| 37 : "left", | |
| 38 : "up", | |
| 39 : "right", | |
| 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} y | |
| * @param {number} radius | |
| * @param {?} tile | |
| * @param {number} value | |
| * @param {string} q | |
| * @param {(Object|string)} a | |
| * @param {!Array} b | |
| * @param {number} h | |
| * @param {number} s | |
| * @return {undefined} | |
| */ | |
| var aA = function(y, radius, tile, value, q, a, b, h, s) { | |
| /** @type {number} */ | |
| this.a = y; | |
| /** @type {number} */ | |
| this.h = radius; | |
| this.G = tile; | |
| /** @type {number} */ | |
| this.c = value; | |
| /** @type {string} */ | |
| this.g = q; | |
| /** @type {(Object|string)} */ | |
| this.o = a; | |
| /** @type {!Array} */ | |
| this.m = b; | |
| /** @type {number} */ | |
| this.w = h; | |
| /** @type {number} */ | |
| this.b = s; | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @return {?} | |
| */ | |
| var gA = function(e) { | |
| var obj = e.b; | |
| obj = (obj = obj && "composed" in obj && obj && "composedPath" in obj && obj.composed && obj.composedPath()) && 0 < obj.length ? obj[0] : e.target; | |
| return bA(cA(dA(eA((new fA).keyCode(e.keyCode || 0).key(e.key || "").shiftKey(!!e.shiftKey).altKey(!!e.altKey).ctrlKey(!!e.ctrlKey).metaKey(!!e.metaKey).target(e.target), obj), function() { | |
| return e.preventDefault(); | |
| }), function() { | |
| return e.stopPropagation(); | |
| })); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var fA = function() { | |
| /** @type {null} */ | |
| this.c = null; | |
| /** @type {string} */ | |
| this.g = ""; | |
| /** @type {null} */ | |
| this.G = this.o = this.m = this.C = this.h = this.b = this.a = this.w = null; | |
| }; | |
| k = fA.prototype; | |
| /** | |
| * @param {number} value | |
| * @return {?} | |
| */ | |
| k.keyCode = function(value) { | |
| /** @type {number} */ | |
| this.c = value; | |
| return this; | |
| }; | |
| /** | |
| * @param {string} type | |
| * @return {?} | |
| */ | |
| k.key = function(type) { | |
| /** @type {string} */ | |
| this.g = type; | |
| return this; | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {?} | |
| */ | |
| k.shiftKey = function(type) { | |
| /** @type {!Object} */ | |
| this.w = type; | |
| return this; | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {?} | |
| */ | |
| k.altKey = function(type) { | |
| /** @type {!Object} */ | |
| this.a = type; | |
| return this; | |
| }; | |
| /** | |
| * @param {string} type | |
| * @return {?} | |
| */ | |
| k.ctrlKey = function(type) { | |
| /** @type {string} */ | |
| this.b = type; | |
| return this; | |
| }; | |
| /** | |
| * @param {!Function} type | |
| * @return {?} | |
| */ | |
| k.metaKey = function(type) { | |
| /** @type {!Function} */ | |
| this.h = type; | |
| return this; | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {?} | |
| */ | |
| k.target = function(type) { | |
| /** @type {!Object} */ | |
| this.C = type; | |
| return this; | |
| }; | |
| /** | |
| * @param {!Object} eventGesture | |
| * @param {!Array} isFlick | |
| * @return {?} | |
| */ | |
| var eA = function(eventGesture, isFlick) { | |
| /** @type {!Array} */ | |
| eventGesture.m = isFlick; | |
| return eventGesture; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| var dA = function(a, b) { | |
| /** @type {!Object} */ | |
| a.o = b; | |
| return a; | |
| }; | |
| /** | |
| * @param {!Window} map | |
| * @param {!Function} value | |
| * @return {?} | |
| */ | |
| var cA = function(map, value) { | |
| /** @type {!Function} */ | |
| map.G = value; | |
| return map; | |
| }; | |
| /** | |
| * @param {!Object} d | |
| * @return {?} | |
| */ | |
| var bA = function(d) { | |
| return new aA(ab(d.c), d.g, fb(d.w), fb(d.a), fb(d.b), fb(d.h), z(d.C), z(d.m), cb(d.o), cb(d.G)); | |
| }; | |
| /** | |
| * @param {number} a | |
| * @return {undefined} | |
| */ | |
| var jA = function(a) { | |
| L.call(this); | |
| this.b = this.c = {}; | |
| /** @type {number} */ | |
| this.h = 0; | |
| this.O = Zb(hA); | |
| this.W = Zb(iA); | |
| /** @type {boolean} */ | |
| this.m = true; | |
| /** @type {null} */ | |
| this.o = null; | |
| /** @type {number} */ | |
| this.a = a; | |
| I(this.a, "keydown", this.w, void 0, this); | |
| I(this.a, "synthetic-keydown", this.C, void 0, this); | |
| if (C.Fd) { | |
| I(this.a, "keypress", this.K, void 0, this); | |
| I(this.a, "synthetic-keypress", this.R, void 0, this); | |
| } | |
| I(this.a, "keyup", this.G, void 0, this); | |
| I(this.a, "synthetic-keyup", this.L, void 0, this); | |
| }; | |
| var kA; | |
| x(jA, L); | |
| /** | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var lA = function(a) { | |
| this.a = a || null; | |
| /** @type {(null|{})} */ | |
| this.next = a ? null : {}; | |
| }; | |
| /** @type {!Array} */ | |
| var hA = [27, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 19]; | |
| /** @type {!Array<string>} */ | |
| var iA = "color date datetime datetime-local email month number password search tel text time url week".split(" "); | |
| /** | |
| * @param {!Object} type | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| jA.prototype.T = function(type, value) { | |
| mA(this.c, nA(arguments), type); | |
| }; | |
| /** | |
| * @param {!Array} s | |
| * @return {?} | |
| */ | |
| var nA = function(s) { | |
| if (r(s[1])) { | |
| s = mb(oA(s[1]), function(event) { | |
| ab(event.keyCode, "A non-modifier key is needed in each stroke."); | |
| return pA(event.key || "", event.keyCode, event.Un); | |
| }); | |
| } else { | |
| /** @type {!Array} */ | |
| var f = s; | |
| /** @type {number} */ | |
| var i = 1; | |
| if (Ka(s[1])) { | |
| f = s[1]; | |
| /** @type {number} */ | |
| i = 0; | |
| } | |
| /** @type {!Array} */ | |
| s = []; | |
| for (; i < f.length; i = i + 2) { | |
| s.push(pA("", f[i], f[i + 1])); | |
| } | |
| } | |
| return s; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| jA.prototype.X = function() { | |
| jA.D.X.call(this); | |
| this.c = {}; | |
| Og(this.a, "keydown", this.w, false, this); | |
| Og(this.a, "synthetic-keydown", this.C, false, this); | |
| if (C.Fd) { | |
| Og(this.a, "keypress", this.K, false, this); | |
| Og(this.a, "synthetic-keypress", this.R, false, this); | |
| } | |
| Og(this.a, "keyup", this.G, false, this); | |
| Og(this.a, "synthetic-keyup", this.L, false, this); | |
| /** @type {null} */ | |
| this.a = null; | |
| }; | |
| /** | |
| * @param {string} src | |
| * @return {?} | |
| */ | |
| var oA = function(src) { | |
| src = src.replace(/[ +]*\+[ +]*/g, "+").replace(/[ ]+/g, " ").toLowerCase(); | |
| src = src.split(" "); | |
| /** @type {!Array} */ | |
| var handlers = []; | |
| var s; | |
| /** @type {number} */ | |
| var j = 0; | |
| for (; s = src[j]; j++) { | |
| var k = s.split("+"); | |
| /** @type {null} */ | |
| var first = null; | |
| /** @type {null} */ | |
| var left = null; | |
| /** @type {number} */ | |
| s = 0; | |
| var key; | |
| /** @type {number} */ | |
| var l = 0; | |
| for (; key = k[l]; l++) { | |
| 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; | |
| } | |
| if (!(null === left)) { | |
| Za("At most one non-modifier key can be in a stroke."); | |
| } | |
| k = void 0; | |
| first = key; | |
| if (!kA) { | |
| left = {}; | |
| for (k in $z) { | |
| left[$z[k]] = Xg(parseInt(k, 10)); | |
| } | |
| kA = left; | |
| } | |
| left = kA[first]; | |
| ab(left, "Key name not found in goog.events.KeyNames: " + key); | |
| first = key; | |
| break; | |
| } | |
| handlers.push({ | |
| key : first, | |
| keyCode : left, | |
| Un : s | |
| }); | |
| } | |
| return handlers; | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| jA.prototype.G = function(type) { | |
| type = gA(type); | |
| if (C.Ja) { | |
| qA(this, type); | |
| } | |
| if (C.Fd && !this.g && rA(type)) { | |
| sA(this, type, true); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| jA.prototype.L = function(type) { | |
| type = type.b(); | |
| if (C.Ja) { | |
| qA(this, type); | |
| } | |
| if (C.Fd && !this.g && rA(type)) { | |
| sA(this, type, true); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} shape | |
| * @param {!Object} fn | |
| * @return {undefined} | |
| */ | |
| var qA = function(shape, fn) { | |
| if (32 == shape.o && 32 == fn.a) { | |
| (0, fn.b)(); | |
| } | |
| /** @type {null} */ | |
| shape.o = null; | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @return {?} | |
| */ | |
| var rA = function(value) { | |
| return C.Fd && value.g && value.c; | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| jA.prototype.K = function(type) { | |
| type = gA(type); | |
| if (32 < type.a && rA(type)) { | |
| /** @type {boolean} */ | |
| this.g = true; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| jA.prototype.R = function(type) { | |
| type = type.b(); | |
| if (32 < type.a && rA(type)) { | |
| /** @type {boolean} */ | |
| this.g = true; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @param {string} acc | |
| * @param {!Object} val | |
| * @return {undefined} | |
| */ | |
| var mA = function(obj, acc, val) { | |
| var w = acc.shift(); | |
| A(w, function(part) { | |
| if ((part = obj[part]) && (0 == acc.length || part.a)) { | |
| throw Error("Keyboard shortcut conflicts with existing shortcut"); | |
| } | |
| }); | |
| if (acc.length) { | |
| A(w, function(key) { | |
| key = key.toString(); | |
| var value = new lA; | |
| key = key in obj ? obj[key] : obj[key] = value; | |
| value = acc.slice(0); | |
| mA(z(key.next, "An internal node must have a next map"), value, val); | |
| }); | |
| } else { | |
| A(w, function(key) { | |
| obj[key] = new lA(val); | |
| }); | |
| } | |
| }; | |
| /** | |
| * @param {?} d | |
| * @param {!NodeList} pos | |
| * @return {?} | |
| */ | |
| var tA = function(d, pos) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < pos.length; i++) { | |
| var b = d[pos[i]]; | |
| if (b) { | |
| return b; | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} n | |
| * @param {!Object} context | |
| * @param {number} width | |
| * @return {?} | |
| */ | |
| var pA = function(n, context, width) { | |
| width = width || 0; | |
| /** @type {!Array} */ | |
| context = ["c_" + context + "_" + width]; | |
| if ("" != n) { | |
| context.push("n_" + n + "_" + width); | |
| } | |
| return context; | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| jA.prototype.w = function(name) { | |
| sA(this, gA(name)); | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| jA.prototype.C = function(type) { | |
| sA(this, type.b()); | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @param {!Object} node | |
| * @param {!Object} value | |
| * @return {undefined} | |
| */ | |
| var sA = function(obj, node, value) { | |
| a: { | |
| var i = node.a; | |
| if ("" != node.h) { | |
| var a = node.h; | |
| if ("Control" == a || "Shift" == a || "Meta" == a || "AltGraph" == a) { | |
| /** @type {boolean} */ | |
| i = false; | |
| break a; | |
| } | |
| } else { | |
| if (16 == i || 17 == i || 18 == i) { | |
| /** @type {boolean} */ | |
| i = false; | |
| break a; | |
| } | |
| } | |
| a = node.w; | |
| /** @type {boolean} */ | |
| var hasSongChanged = "TEXTAREA" == a.tagName || "INPUT" == a.tagName || "BUTTON" == a.tagName || "SELECT" == a.tagName; | |
| var isReplayingSong = !hasSongChanged && (a.isContentEditable || a.ownerDocument && "on" == a.ownerDocument.designMode); | |
| /** @type {boolean} */ | |
| i = !hasSongChanged && !isReplayingSong || obj.O[i] ? true : isReplayingSong ? false : node.c || node.g || node.o ? true : "INPUT" == a.tagName && obj.W[a.type] ? 13 == i : "INPUT" == a.tagName || "BUTTON" == a.tagName ? 32 != i : false; | |
| } | |
| if (i) { | |
| if (!value && rA(node)) { | |
| /** @type {boolean} */ | |
| obj.g = false; | |
| } else { | |
| value = Xg(node.a); | |
| i = pA(node.h, value, (node.G ? 1 : 0) | (node.g ? 2 : 0) | (node.c ? 4 : 0) | (node.o ? 8 : 0)); | |
| if (a = tA(obj.b, i)) { | |
| /** @type {boolean} */ | |
| a = !(1500 <= Ua() - obj.h); | |
| } | |
| if (!a) { | |
| obj.b = obj.c; | |
| obj.h = Ua(); | |
| } | |
| if ((a = tA(obj.b, i)) && a.next) { | |
| obj.b = a.next; | |
| obj.h = Ua(); | |
| } | |
| if (a) { | |
| if (a.next) { | |
| (0, node.b)(); | |
| } else { | |
| obj.b = obj.c; | |
| obj.h = Ua(); | |
| if (obj.m) { | |
| (0, node.b)(); | |
| } | |
| i = bb(a.a, "A terminal node must have a string shortcut identifier."); | |
| a = obj.dispatchEvent(new uA("shortcut", i, node.m)); | |
| if (!(a = a & obj.dispatchEvent(new uA("shortcut_" + i, i, node.m)))) { | |
| (0, node.b)(); | |
| } | |
| if (C.Ja) { | |
| /** @type {!Object} */ | |
| obj.o = value; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {?} q | |
| * @param {string} id | |
| * @param {?} re | |
| * @return {undefined} | |
| */ | |
| var uA = function(q, id, re) { | |
| kg.call(this, q, re); | |
| /** @type {string} */ | |
| this.identifier = id; | |
| }; | |
| x(uA, kg); | |
| /** | |
| * @param {number} compiler | |
| * @return {undefined} | |
| */ | |
| var vA = function(compiler) { | |
| /** @type {number} */ | |
| this.c = compiler; | |
| this.g = hm.N(); | |
| this.F = M.N(); | |
| this.a = new jA(document); | |
| /** @type {boolean} */ | |
| this.a.m = false; | |
| this.a.T("CTRL_SHIFT_S", 83, (C.yb ? 8 : 2) | 1); | |
| I(this.a, "shortcut", this.b, false, this); | |
| }; | |
| x(vA, hg); | |
| /** | |
| * @return {undefined} | |
| */ | |
| vA.prototype.X = function() { | |
| vA.D.X.call(this); | |
| Og(this.a, "shortcut", this.b, false, this); | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| vA.prototype.b = function(type) { | |
| if ("CTRL_SHIFT_S" == type.identifier) { | |
| Tg(this.c.b, "action"); | |
| type = this.F; | |
| N(type, O(type, 289)); | |
| this.g.log("swaplang"); | |
| } | |
| }; | |
| /** | |
| * @param {number} value | |
| * @param {?} p | |
| * @param {string} g | |
| * @param {string} d | |
| * @param {!Object} e | |
| * @param {?} islongclick | |
| * @return {undefined} | |
| */ | |
| var xA = function(value, p, g, d, e, islongclick) { | |
| L.call(this); | |
| /** @type {number} */ | |
| this.v = value; | |
| this.b = G("DIV", "sl-sugg-button-container"); | |
| this.C = p; | |
| value = E("sl-sugg-button-container", this.v) ? Kf(this.v.firstElementChild) : Kf(this.v); | |
| this.g = g ? g : value.length; | |
| Ff(this.v); | |
| /** @type {boolean} */ | |
| this.c = !!d; | |
| /** @type {boolean} */ | |
| this.o = !!e; | |
| /** @type {!Array} */ | |
| this.a = []; | |
| g = this.c ? this.g + 1 : this.g; | |
| /** @type {number} */ | |
| d = 0; | |
| for (; d < g; ++d) { | |
| e = new is(""); | |
| e.Sa(16, true); | |
| I(e, "action", this.R, false, this); | |
| e.Za(this.b); | |
| hr(e.c, e, 0 == d ? 2 : 3); | |
| this.a.push(e); | |
| } | |
| this.v.appendChild(this.b); | |
| /** @type {!Array} */ | |
| this.h = []; | |
| this.m = G("DIV", "ls-left-arrow"); | |
| this.w = G("DIV", "ls-right-arrow"); | |
| /** @type {number} */ | |
| this.G = 0; | |
| if (islongclick) { | |
| this.v.insertBefore(this.m, this.v.firstChild); | |
| this.v.appendChild(this.w); | |
| I(this.m, "mouseover", function() { | |
| wA(this, 2); | |
| }, false, this); | |
| I(this.m, "mouseout", function() { | |
| clearTimeout(this.G); | |
| }, false, this); | |
| I(this.w, "mouseover", function() { | |
| wA(this, -2); | |
| }, false, this); | |
| I(this.w, "mouseout", function() { | |
| clearTimeout(this.G); | |
| }, false, this); | |
| } | |
| this.F = M.N(); | |
| }; | |
| x(xA, L); | |
| /** | |
| * @param {!Object} o | |
| * @param {number} offset | |
| * @return {undefined} | |
| */ | |
| var wA = function(o, offset) { | |
| o.b.scrollLeft -= offset; | |
| /** @type {number} */ | |
| o.G = setTimeout(function() { | |
| wA(o, offset); | |
| }, 10); | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| xA.prototype.L = function(type) { | |
| var t = type.selected; | |
| type = type.data.slice(0, this.g); | |
| var a = this.h.slice(); | |
| a.length = this.g; | |
| a: { | |
| a = Ab(a).sort(); | |
| var b = Ab(type).sort(); | |
| if (La(a) && La(b) && a.length == b.length) { | |
| var m = a.length; | |
| /** @type {number} */ | |
| var n = 0; | |
| for (; n < m; n++) { | |
| if (a[n] !== b[n]) { | |
| /** @type {boolean} */ | |
| a = false; | |
| break a; | |
| } | |
| } | |
| /** @type {boolean} */ | |
| a = true; | |
| } else { | |
| /** @type {boolean} */ | |
| a = false; | |
| } | |
| } | |
| /** @type {boolean} */ | |
| a = !a; | |
| /** @type {!Object} */ | |
| this.h = type; | |
| /** @type {number} */ | |
| type = 0; | |
| if (this.c && this.o) { | |
| /** @type {number} */ | |
| type = 1; | |
| } | |
| /** @type {number} */ | |
| b = 0; | |
| for (; b < this.h.length; b++) { | |
| m = this.a[type]; | |
| n = this.h[b]; | |
| if (a) { | |
| m.Wf(n); | |
| var s = this.C(n); | |
| m.g(s); | |
| } | |
| yA(this, m, m.aa() == t, n); | |
| type++; | |
| } | |
| for (; type < this.g; type++) { | |
| this.a[type].setVisible(false); | |
| } | |
| if (this.c) { | |
| type = this.a[this.o ? 0 : this.a.length - 1]; | |
| type.Wf("auto"); | |
| type.g(detect_language); | |
| yA(this, type, type.aa() == t); | |
| } | |
| X(this.v, true); | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| xA.prototype.R = function(type) { | |
| var patch = type.a.aa(); | |
| if (type.a.Ha(16)) { | |
| a: { | |
| var value = type.a; | |
| /** @type {number} */ | |
| var i = 0; | |
| /** @type {number} */ | |
| var gapValue = 0; | |
| for (; i < this.a.length; i++) { | |
| var c = this.a[i]; | |
| if (c && c.isVisible()) { | |
| if (value == c) { | |
| /** @type {number} */ | |
| value = gapValue; | |
| break a; | |
| } | |
| gapValue++; | |
| } | |
| } | |
| /** @type {number} */ | |
| value = -1; | |
| } | |
| Ql(this.F, this.c, 2, patch, value, ""); | |
| } else { | |
| type.a.wd(true); | |
| } | |
| Wp(type.a.j(), this.v); | |
| this.dispatchEvent({ | |
| type : "click", | |
| data : patch | |
| }); | |
| }; | |
| /** | |
| * @param {!Object} curve | |
| * @param {!Object} t | |
| * @param {boolean} f | |
| * @param {number} i | |
| * @return {undefined} | |
| */ | |
| var yA = function(curve, t, f, i) { | |
| t.setVisible(true); | |
| t.wd(f); | |
| if (f) { | |
| Wp(t.j(), curve.b); | |
| } | |
| if (i) { | |
| /** @type {string} */ | |
| t.j().id = "sugg-item-" + i; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| xA.prototype.K = function(type) { | |
| if (this.c) { | |
| var c = this.a[this.o ? 0 : this.a.length - 1]; | |
| if ("" == type.data) { | |
| c.g(detect_language); | |
| } else { | |
| type = source_language_detected.replace(/%\d\$s/g, this.C(type.data)); | |
| c.g(type); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {number} a | |
| * @return {undefined} | |
| */ | |
| var zA = function(a) { | |
| /** @type {number} */ | |
| this.a = a; | |
| /** @type {null} */ | |
| this.b = this.m = this.h = this.o = this.g = null; | |
| /** @type {boolean} */ | |
| this.R = false; | |
| /** @type {null} */ | |
| this.c = null; | |
| /** | |
| * @return {?} | |
| */ | |
| this.C = function() { | |
| return ""; | |
| }; | |
| this.w = hm.N(); | |
| this.oa = Uk.N(); | |
| this.F = M.N(); | |
| /** @type {null} */ | |
| this.G = null; | |
| }; | |
| /** | |
| * @param {!Object} self | |
| * @param {!Object} o | |
| * @return {undefined} | |
| */ | |
| var CA = function(self, o) { | |
| if (o.Sj) { | |
| self.g = o.Sj; | |
| AA(self.g, self.O, self); | |
| BA(self, self.a, "srcLanguageUpdated", self.Im); | |
| BA(self, self.a, "detectSrcUpdated", self.rm); | |
| } | |
| if (o.ak) { | |
| self.o = o.ak; | |
| AA(self.o, self.T, self); | |
| BA(self, self.a, "tgtLanguageUpdated", self.Rm); | |
| } | |
| if (o.Pj) { | |
| self.K = o.Pj; | |
| BA(self, self.K, "action", self.Ga); | |
| } | |
| if (o.Rj) { | |
| self.W = o.Rj; | |
| BA(self, self.W, "action", v(self.L, self, "src", true)); | |
| } | |
| if (o.$j) { | |
| self.Y = o.$j; | |
| BA(self, self.Y, "action", v(self.L, self, "tgt", false)); | |
| } | |
| if (o.Tj) { | |
| self.h = o.Tj; | |
| BA(self, self.h, "click", self.Jm); | |
| var h = self.h; | |
| I(self.a, "staticSrcSuggestionUpdated", h.L, false, h); | |
| h = self.h; | |
| I(self.a, "detectSrcUpdated", h.K, false, h); | |
| } | |
| if (o.bk) { | |
| self.m = o.bk; | |
| BA(self, self.m, "click", self.Sm); | |
| h = self.m; | |
| I(self.a, "staticTgtSuggestionUpdated", h.L, false, h); | |
| } | |
| if (o.Yc) { | |
| self.b = o.Yc; | |
| BA(self, self.b, "action", self.Pm); | |
| } | |
| if (o.ck) { | |
| self.c = o.ck; | |
| BA(self, new Nq(self.c.j()), "key", self.mj); | |
| BA(self, new tv(self.c.j()), "paste", self.mj); | |
| } | |
| if (o.fb) { | |
| self.C = o.fb; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} p | |
| * @param {boolean} value | |
| * @return {undefined} | |
| */ | |
| var EA = function(p, value) { | |
| if ((p.R = value) && p.b) { | |
| p.b.sa(false); | |
| } else { | |
| DA(p); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Object} b | |
| * @param {string} name | |
| * @param {!Function} d | |
| * @return {undefined} | |
| */ | |
| var BA = function(a, b, name, d) { | |
| if (b) { | |
| I(b, name, d, false, a); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| zA.prototype.O = function() { | |
| var c = this.g; | |
| var g = this.a.g; | |
| var BidirectionalSubject = Wv(this.a.Y); | |
| FA(this, c, g, BidirectionalSubject, "slc"); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| zA.prototype.T = function() { | |
| var o = this.o; | |
| var left = this.a.h; | |
| var BidirectionalSubject = Wv(this.a.Z.a); | |
| FA(this, o, left, BidirectionalSubject, "tlc", true); | |
| }; | |
| /** | |
| * @param {!Window} query | |
| * @param {string} opts | |
| * @param {!Object} config | |
| * @return {undefined} | |
| */ | |
| var GA = function(query, opts, config) { | |
| var G = {}; | |
| /** @type {!Object} */ | |
| G.lpk = config; | |
| query.G = G; | |
| /** @type {string} */ | |
| query.G.lsa = opts; | |
| mm(query.w, "webapp", "lsa", opts, G); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| zA.prototype.Ga = function() { | |
| if (this.g && this.g.isVisible()) { | |
| GA(this, "lso", "src"); | |
| Pl(this.F, 217); | |
| } else { | |
| if (this.o && this.o.isVisible()) { | |
| GA(this, "lso", "tgt"); | |
| Pl(this.F, 219); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| zA.prototype.L = function(type, value) { | |
| GA(this, "lsc", type); | |
| Pl(this.F, value ? 218 : 220); | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @param {string} data | |
| * @param {!Function} c | |
| * @param {string} d | |
| * @param {string} o | |
| * @param {boolean} i | |
| * @return {undefined} | |
| */ | |
| var FA = function(item, data, c, d, o, i) { | |
| var hex = data.aa(); | |
| var text = HA(item); | |
| var val = IA(item, i); | |
| c.call(item.a, hex, 4); | |
| if (null != data.R) { | |
| Xb(text, data.R); | |
| } | |
| if ("" != d) { | |
| /** @type {string} */ | |
| text.emphlang = d; | |
| } | |
| data = Wv(item.a.L.a); | |
| if (!(i || "" == data)) { | |
| /** @type {string} */ | |
| text.bslang = data; | |
| } | |
| if ("" != val) { | |
| text.sugglang = val; | |
| } | |
| item.G = text; | |
| item.G[o] = hex; | |
| mm(item.w, "webapp", o, hex, text); | |
| }; | |
| k = zA.prototype; | |
| /** | |
| * @param {!Object} simpleselect | |
| * @return {undefined} | |
| */ | |
| k.Im = function(simpleselect) { | |
| if (this.g.aa() != simpleselect.data) { | |
| JA(this.g, simpleselect.data); | |
| } | |
| DA(this); | |
| if (simpleselect.Li) { | |
| KA(this, "slauto", HA(this)); | |
| Pl(this.F, 221); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.rm = function() { | |
| DA(this); | |
| }; | |
| /** | |
| * @param {!Object} simpleselect | |
| * @return {undefined} | |
| */ | |
| k.Rm = function(simpleselect) { | |
| if (this.o.aa() != simpleselect.data) { | |
| JA(this.o, simpleselect.data); | |
| } | |
| DA(this); | |
| if (simpleselect.Li) { | |
| KA(this, "tlauto", HA(this)); | |
| Pl(this.F, 222); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @return {undefined} | |
| */ | |
| k.Jm = function(e) { | |
| if (e.data == this.a.a) { | |
| e.target.dispatchEvent({ | |
| type : "clickSelected" | |
| }); | |
| e.preventDefault(); | |
| } else { | |
| var c = this.a.g; | |
| var send = IA(this); | |
| var prev = HA(this, e.data); | |
| c.call(this.a, e.data, 3); | |
| prev.sugglang = send; | |
| KA(this, "ssuggclick", prev); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @return {undefined} | |
| */ | |
| k.Sm = function(e) { | |
| if (e.data == this.a.b) { | |
| e.target.dispatchEvent({ | |
| type : "clickSelected" | |
| }); | |
| e.preventDefault(); | |
| } else { | |
| var c = this.a.h; | |
| var send = IA(this, true); | |
| var prev = HA(this, e.data); | |
| c.call(this.a, e.data, 3); | |
| prev.sugglang = send; | |
| KA(this, "tsuggclick", prev); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.Pm = function() { | |
| var e = HA(this); | |
| var value = this.a.a; | |
| var c = this.a.b; | |
| var a = value; | |
| if ("auto" == value && (a = this.a.c, !a)) { | |
| return; | |
| } | |
| if ((value = this.C()) && this.c) { | |
| this.c.b(value); | |
| Yk(this.oa, 28); | |
| } | |
| KA(this, "swapclick", e); | |
| e = this.a; | |
| e.g(c, 5); | |
| e.h(a, 5); | |
| e.dispatchEvent("languageSelected"); | |
| pm(this.w, "swap", 1, "accumulate"); | |
| c = this.F; | |
| a = O(c, 89); | |
| e = new zk; | |
| D(e, 1, 1); | |
| Le(a, 46, e); | |
| N(c, a); | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @return {undefined} | |
| */ | |
| k.mj = function(e) { | |
| if ("paste" == e.type || 2 > zc(this.c.aa()).length) { | |
| /** @type {boolean} */ | |
| this.a.G = false; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} i | |
| * @return {?} | |
| */ | |
| var HA = function(a, i) { | |
| var data = {}; | |
| data.sl = a.a.a; | |
| data.tl = a.a.b; | |
| if (i) { | |
| /** @type {string} */ | |
| data.val = i; | |
| } | |
| if (i = a.a.c) { | |
| /** @type {string} */ | |
| data.dsl = i; | |
| } | |
| if (a.c) { | |
| data.ql = zc(a.c.aa()).length; | |
| } | |
| return data; | |
| }; | |
| /** | |
| * @param {!Object} self | |
| * @return {undefined} | |
| */ | |
| var LA = function(self) { | |
| pm(self.w, "ssel", self.a.oa); | |
| pm(self.w, "tsel", self.a.ea); | |
| }; | |
| /** | |
| * @param {!Window} w | |
| * @param {string} s | |
| * @param {string} ch | |
| * @return {undefined} | |
| */ | |
| var KA = function(w, s, ch) { | |
| /** @type {string} */ | |
| w.G = ch; | |
| w.w.log(s, ch); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {boolean} be | |
| * @return {?} | |
| */ | |
| var IA = function(a, be) { | |
| return be ? Wv(a.a.R.a) : Wv(a.a.K.a); | |
| }; | |
| /** | |
| * @param {!Object} p | |
| * @return {undefined} | |
| */ | |
| var DA = function(p) { | |
| if (p.b && !p.R) { | |
| var b = p.a.a; | |
| if ("auto" == b) { | |
| b = p.a.c; | |
| } | |
| if ("zh-CN" == b && "zh-TW" == p.a.w) { | |
| /** @type {string} */ | |
| b = "zh-TW"; | |
| } | |
| if ("" == b || b == p.a.b) { | |
| p.b.sa(false); | |
| } else { | |
| p.b.sa(true); | |
| } | |
| } | |
| }; | |
| /** @type {number} */ | |
| var MA = 0; | |
| /** @type {!RegExp} */ | |
| var NA = /^[a-zA-Z0-9_\-]*$/; | |
| /** | |
| * @param {string} state | |
| * @return {?} | |
| */ | |
| var OA = function(state) { | |
| z(state.match(NA), "ControlType.create contains invalid characters" + state); | |
| return state + "+" + MA++; | |
| }; | |
| /** | |
| * @param {number} t | |
| * @param {number} c | |
| * @return {undefined} | |
| */ | |
| var PA = function(t, c) { | |
| hg.call(this); | |
| /** @type {null} */ | |
| this.c = null; | |
| /** @type {number} */ | |
| this.g = c; | |
| /** @type {!Array} */ | |
| this.a = []; | |
| if (t > this.g) { | |
| throw Error("[goog.structs.SimplePool] Initial cannot be greater than max"); | |
| } | |
| /** @type {number} */ | |
| c = 0; | |
| for (; c < t; c++) { | |
| this.a.push(this.b()); | |
| } | |
| }; | |
| x(PA, hg); | |
| /** | |
| * @param {!Object} mutable | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| var QA = function(mutable, value) { | |
| /** @type {string} */ | |
| mutable.c = value; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {undefined} b | |
| * @return {undefined} | |
| */ | |
| var SA = function(a, b) { | |
| if (a.a.length < a.g) { | |
| a.a.push(b); | |
| } else { | |
| RA(b); | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| PA.prototype.b = function() { | |
| return this.c ? this.c() : {}; | |
| }; | |
| /** | |
| * @param {!Object} year | |
| * @return {undefined} | |
| */ | |
| var RA = function(year) { | |
| if (Na(year)) { | |
| if (Ma(year.Qa)) { | |
| year.Qa(); | |
| } else { | |
| var mainWord; | |
| for (mainWord in year) { | |
| delete year[mainWord]; | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| PA.prototype.X = function() { | |
| PA.D.X.call(this); | |
| var a = this.a; | |
| for (; a.length;) { | |
| RA(a.pop()); | |
| } | |
| delete this.a; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var VA = function() { | |
| /** @type {!Array} */ | |
| this.a = []; | |
| this.b = new Yi; | |
| /** @type {number} */ | |
| this.L = this.K = this.R = this.m = 0; | |
| this.c = new Yi; | |
| /** @type {number} */ | |
| this.o = this.C = 0; | |
| /** @type {number} */ | |
| this.Ga = 1; | |
| this.g = new PA(0, 4E3); | |
| /** | |
| * @return {?} | |
| */ | |
| this.g.b = function() { | |
| return new TA; | |
| }; | |
| this.G = new PA(0, 50); | |
| /** | |
| * @return {?} | |
| */ | |
| this.G.b = function() { | |
| return new UA; | |
| }; | |
| var a = this; | |
| this.w = new PA(0, 2E3); | |
| QA(this.w, function() { | |
| return a.Ga++; | |
| }); | |
| this.h = {}; | |
| }; | |
| VA.prototype.F = wi("goog.debug.Trace"); | |
| /** | |
| * @return {undefined} | |
| */ | |
| var UA = function() { | |
| /** @type {number} */ | |
| this.Yh = this.time = this.count = 0; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| UA.prototype.toString = function() { | |
| /** @type {!Array} */ | |
| var sb = []; | |
| sb.push(this.type, " ", this.count, " (", Math.round(10 * this.time) / 10, " ms)"); | |
| if (this.Yh) { | |
| sb.push(" [VarAlloc = ", this.Yh, "]"); | |
| } | |
| return sb.join(""); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var TA = function() { | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {?} b | |
| * @param {number} c | |
| * @param {string} horizontal | |
| * @return {?} | |
| */ | |
| var YA = function(a, b, c, horizontal) { | |
| /** @type {!Array} */ | |
| var t = []; | |
| if (-1 == c) { | |
| t.push(" "); | |
| } else { | |
| t.push(WA(a.b - c)); | |
| } | |
| t.push(" ", XA(a.b - b)); | |
| if (0 == a.a) { | |
| t.push(" Start "); | |
| } else { | |
| if (1 == a.a) { | |
| t.push(" Done "); | |
| t.push(WA(a.h - a.startTime), " ms "); | |
| } else { | |
| t.push(" Comment "); | |
| } | |
| } | |
| t.push(horizontal, a); | |
| if (0 < a.g) { | |
| t.push("[VarAlloc ", a.g, "] "); | |
| } | |
| return t.join(""); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| TA.prototype.toString = function() { | |
| return null == this.type ? z(this.c) : "[" + this.type + "] " + this.c; | |
| }; | |
| var ZA = { | |
| Os : true | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| VA.prototype.Nh = function() { | |
| this.h = {}; | |
| }; | |
| /** | |
| * @param {!Object} that | |
| * @return {undefined} | |
| */ | |
| var $A = function(that) { | |
| if (that.h.stop) { | |
| Ri(that.b, function(s) { | |
| this.h.stop(s.id, ZA); | |
| }, that); | |
| } | |
| that.b.hd(); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| VA.prototype.reset = function() { | |
| $A(this); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < this.a.length; i++) { | |
| var c = this.a[i]; | |
| if (c.id) { | |
| if (!aj(this.b, c.id)) { | |
| SA(this.w, c.id); | |
| SA(this.g, c); | |
| } | |
| } else { | |
| SA(this.g, c); | |
| } | |
| } | |
| /** @type {number} */ | |
| this.a.length = 0; | |
| this.m = Ua(); | |
| /** @type {number} */ | |
| this.o = this.C = this.L = this.K = this.R = 0; | |
| i = this.c.Mb(); | |
| /** @type {number} */ | |
| c = 0; | |
| for (; c < i.length; c++) { | |
| var end = this.c.get(i[c]); | |
| /** @type {number} */ | |
| end.count = 0; | |
| /** @type {number} */ | |
| end.time = 0; | |
| /** @type {number} */ | |
| end.Yh = 0; | |
| SA(this.G, end); | |
| } | |
| this.c.hd(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| VA.prototype.toString = function() { | |
| /** @type {!Array} */ | |
| var _ = []; | |
| /** @type {number} */ | |
| var id = -1; | |
| /** @type {!Array} */ | |
| var c = []; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < this.a.length; i++) { | |
| var r = this.a[i]; | |
| if (1 == r.a) { | |
| c.pop(); | |
| } | |
| _.push(" ", YA(r, this.m, id, c.join(""))); | |
| id = r.b; | |
| _.push("\n"); | |
| if (0 == r.a) { | |
| c.push("| "); | |
| } | |
| } | |
| if (0 != this.b.Lf()) { | |
| var now = Ua(); | |
| _.push(" Unstopped timers:\n"); | |
| Ri(this.b, function(snapshot) { | |
| _.push(" ", snapshot, " (", now - snapshot.startTime, " ms, started at ", XA(snapshot.startTime), ")\n"); | |
| }); | |
| } | |
| id = this.c.Mb(); | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < id.length; i++) { | |
| c = this.c.get(id[i]); | |
| if (1 < c.count) { | |
| _.push(" TOTAL ", c, "\n"); | |
| } | |
| } | |
| _.push("Total tracers created ", this.C, "\n", "Total comments created ", this.o, "\n", "Overhead start: ", this.R, " ms\n", "Overhead end: ", this.K, " ms\n", "Overhead comment: ", this.L, " ms\n"); | |
| return _.join(""); | |
| }; | |
| /** | |
| * @param {number} a | |
| * @return {?} | |
| */ | |
| var WA = function(a) { | |
| /** @type {number} */ | |
| a = Math.round(a); | |
| /** @type {string} */ | |
| var hugStr = ""; | |
| if (1E3 > a) { | |
| /** @type {string} */ | |
| hugStr = " "; | |
| } | |
| if (100 > a) { | |
| /** @type {string} */ | |
| hugStr = " "; | |
| } | |
| if (10 > a) { | |
| /** @type {string} */ | |
| hugStr = " "; | |
| } | |
| return hugStr + a; | |
| }; | |
| /** | |
| * @param {number} n12ths | |
| * @return {?} | |
| */ | |
| var XA = function(n12ths) { | |
| /** @type {number} */ | |
| n12ths = Math.round(n12ths); | |
| return String(100 + n12ths / 1E3 % 60).substring(1, 3) + "." + String(1E3 + n12ths % 1E3).substring(1, 4); | |
| }; | |
| new VA; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var aB = function() { | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| aB.prototype.stopPropagation = function() { | |
| /** @type {boolean} */ | |
| this.g = true; | |
| this.h(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| aB.prototype.c = function() { | |
| return this.g || false; | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| var bB = function(name) { | |
| /** @type {!Array} */ | |
| this.a = []; | |
| /** @type {string} */ | |
| this.name = name; | |
| }; | |
| bB.prototype.c = wi("wireless.events.browser.Dispatcher"); | |
| /** | |
| * @param {string} type | |
| * @param {string} value | |
| * @return {?} | |
| */ | |
| bB.prototype.dispatchEvent = function(type, value) { | |
| /** @type {boolean} */ | |
| var deep = "*" == type.a.charAt(0); | |
| var result; | |
| if (this.handleEvent(type, value)) { | |
| /** @type {boolean} */ | |
| result = true; | |
| } | |
| /** @type {string} */ | |
| var msg = (value || "") + this.name + "->"; | |
| /** @type {number} */ | |
| var f = -1; | |
| var c; | |
| for (; (!result || deep) && (c = this.a[++f]);) { | |
| result = c.dispatchEvent(type, msg) || result; | |
| } | |
| if (!(result || value)) { | |
| yi(this.c, "Event not handled: " + type.a + " type: " + (type ? type.type : "none") + " customArg: " + type.b); | |
| } | |
| return result; | |
| }; | |
| /** | |
| * @param {string} g | |
| * @param {?} name | |
| * @return {undefined} | |
| */ | |
| var cB = function(g, name) { | |
| bB.call(this, name); | |
| /** @type {string} */ | |
| this.g = g; | |
| /** @type {!Array} */ | |
| this.b = []; | |
| this.L = {}; | |
| }; | |
| x(cB, bB); | |
| var dB = new cB(void 0, "root"); | |
| Ba("_e", function(e, a, err, ele) { | |
| e = e || {}; | |
| /** @type {number} */ | |
| e.a = a; | |
| /** @type {number} */ | |
| e.b = err; | |
| e.o = ele || e.currentTarget || null; | |
| e.h = e.stopPropagation; | |
| /** @type {function(): undefined} */ | |
| e.stopPropagation = aB.prototype.stopPropagation; | |
| /** @type {function(): ?} */ | |
| e.c = aB.prototype.c; | |
| return dB.dispatchEvent(e); | |
| }); | |
| /** | |
| * @param {!Object} _ | |
| * @param {string} id | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| var eB = function(_, id, name) { | |
| z(id, _.name + " - registerHandler: Missing controlType."); | |
| z(name, _.name + " - registerHandler: Missing handlerFunc. controlType: " + id); | |
| z(!_.L[id], _.name + " - registerHandler: Handler already defined. controlType: " + id); | |
| /** @type {number} */ | |
| name = _.b.push(name, _.g) - 2; | |
| /** @type {string} */ | |
| _.L[id] = name; | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @param {string} json | |
| * @return {?} | |
| */ | |
| cB.prototype.handleEvent = function(options, json) { | |
| var name = this.L[options.a]; | |
| if (q(name)) { | |
| return fB(this, options, options.a, options.b, json), this.b[name].call(this.b[name + 1], options, options.a, options.b), true; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @param {!Object} options | |
| * @param {string} op | |
| * @param {?} result | |
| * @param {string} prefix | |
| * @return {undefined} | |
| */ | |
| var fB = function(value, options, op, result, prefix) { | |
| if (!(")" == op.slice(-1))) { | |
| zi(value.c, v(function() { | |
| /** @type {string} */ | |
| var name = ""; | |
| if (options) { | |
| /** @type {string} */ | |
| name = "BrowserType=" + options.type; | |
| if (options.which) { | |
| /** @type {string} */ | |
| name = name + (" key=" + options.which); | |
| } | |
| /** @type {string} */ | |
| name = " (" + name + ")"; | |
| } | |
| /** @type {string} */ | |
| var b = ""; | |
| if (q(result)) { | |
| /** @type {string} */ | |
| b = " customArg: " + result; | |
| } | |
| return (prefix || "") + this.name + " handling event: " + op + b + name; | |
| }, value)); | |
| } | |
| }; | |
| /** | |
| * @param {string} midiOutObj | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| var gB = function(midiOutObj, name) { | |
| /** @type {string} */ | |
| this.Code = midiOutObj; | |
| /** @type {string} */ | |
| this.Name = name; | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @param {number} p | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var kB = function(data, p, a) { | |
| /** @type {string} */ | |
| this.va = p.va + "_" + data.Code; | |
| if ("rcnt" == a) { | |
| this.va += "_r"; | |
| } else { | |
| if ("srch" == a) { | |
| this.va += "_s"; | |
| } | |
| } | |
| hB[this.va] = this; | |
| /** @type {number} */ | |
| this.b = p; | |
| /** @type {string} */ | |
| this.a = a; | |
| this.Ub = data.Name; | |
| this.code = data.Code; | |
| this.v = Bp(iB, { | |
| id : this.va, | |
| name : data.Name, | |
| code : data.Code, | |
| Se : jB | |
| }); | |
| }; | |
| var lB = {}; | |
| var mB = (lB.rglr = 0, lB.rcnt = 2, lB.srch = 3, lB); | |
| /** | |
| * @return {?} | |
| */ | |
| kB.prototype.j = function() { | |
| return this.v; | |
| }; | |
| /** | |
| * @param {undefined} data | |
| * @return {undefined} | |
| */ | |
| kB.prototype.Te = function(data) { | |
| this.b.Te(this.Ub, this.code, this.a, data); | |
| }; | |
| var hB = {}; | |
| /** | |
| * @param {!Object} node | |
| * @return {?} | |
| */ | |
| var nB = function(node) { | |
| if (node && node.parentNode && node.parentNode.children) { | |
| /** @type {number} */ | |
| var i = 0; | |
| /** @type {number} */ | |
| var c = 0; | |
| var parent = node.parentNode; | |
| for (; i < parent.children.length; i++) { | |
| var body = parent.children[i]; | |
| if (dq(body) && tp(body, "language_list_item_wrapper")) { | |
| if (node == body) { | |
| return c; | |
| } | |
| c++; | |
| } | |
| } | |
| } | |
| return -1; | |
| }; | |
| /** | |
| * @param {!Event} event | |
| * @param {?} from | |
| * @param {?} k | |
| * @return {undefined} | |
| */ | |
| var oB = function(event, from, k) { | |
| if (from = hB[k]) { | |
| from.Te(nB(event.currentTarget)); | |
| } | |
| }; | |
| /** @type {null} */ | |
| var pB = null; | |
| var jB = OA("changeLanguage"); | |
| var qB = OA("searchEdited"); | |
| /** | |
| * @param {string} tScreened2 | |
| * @param {number} x | |
| * @return {undefined} | |
| */ | |
| var uB = function(tScreened2, x) { | |
| hg.call(this); | |
| /** @type {!Array} */ | |
| this.a = []; | |
| /** @type {!Array} */ | |
| this.c = []; | |
| /** @type {!Array} */ | |
| this.g = []; | |
| /** @type {string} */ | |
| this.va = tScreened2; | |
| /** @type {null} */ | |
| this.C = null; | |
| /** @type {!Array} */ | |
| this.L = []; | |
| this.ra = new L; | |
| this.v = G("DIV", "language-list"); | |
| /** @type {number} */ | |
| this.h = x; | |
| this.o = Bp(rB, { | |
| Se : qB, | |
| Jn : this.va, | |
| Kn : this.h.o | |
| }); | |
| Df(this.v, this.o); | |
| X(this.o, false); | |
| this.G = new is; | |
| this.G.na(E("back-image-black", this.o)); | |
| this.G.Nd(this.h.b); | |
| qr(this.G, this.h.b); | |
| I(this.G, "action", this.ma, false, this); | |
| if (x = E("clear-image-black", this.o)) { | |
| this.O = new is; | |
| this.O.na(x); | |
| this.O.Nd(this.h.a); | |
| qr(this.O, this.h.a); | |
| I(this.O, "action", this.Y, false, this); | |
| X(x, false); | |
| } | |
| this.m = G("DIV", "language-list-unfiltered-langs-" + this.va); | |
| this.ea = G("DIV", "language_list_languages language_list_" + tScreened2); | |
| Df(this.ea, this.m); | |
| Df(this.v, this.ea); | |
| this.b = G("DIV", "language_list_languages language_list_" + tScreened2); | |
| Df(this.v, this.b); | |
| X(this.b, false); | |
| /** @type {string} */ | |
| this.T = ""; | |
| this.w = sB(this.h.h, this.m); | |
| X(this.w, false); | |
| this.Da = sB(this.h.c, this.m); | |
| tB[this.va] = this; | |
| /** @type {number} */ | |
| this.Aa = 0; | |
| this.F = M.N(); | |
| /** @type {string} */ | |
| this.Na = ""; | |
| this.R = {}; | |
| }; | |
| x(uB, hg); | |
| var tB = {}; | |
| /** | |
| * @param {?} header | |
| * @param {!Function} value | |
| * @param {!Object} obj | |
| * @return {undefined} | |
| */ | |
| var AA = function(header, value, obj) { | |
| I(header.ra, "returned", value, false, obj); | |
| }; | |
| /** | |
| * @param {!Object} self | |
| * @param {!Function} locale | |
| * @return {undefined} | |
| */ | |
| var JA = function(self, locale) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < self.a.length; i++) { | |
| if (self.a[i].code === locale) { | |
| if (null != self.C) { | |
| self.C.setAttribute("aria-label", self.a[i].Ub); | |
| H(self.C, self.a[i].Ub); | |
| } | |
| self.W(self.a[i].Ub, self.a[i].code); | |
| /** @type {!Function} */ | |
| self.T = locale; | |
| break; | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| uB.prototype.aa = function() { | |
| return this.T; | |
| }; | |
| /** | |
| * @param {?} zipFileName | |
| * @param {?} callback | |
| * @param {?} circleID | |
| * @return {undefined} | |
| */ | |
| var wB = function(zipFileName, callback, circleID) { | |
| vB(tB[circleID], (new tg(zipFileName)).target.value); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} n | |
| * @return {undefined} | |
| */ | |
| var vB = function(a, n) { | |
| var p = E("clear-image-black", a.o); | |
| /** @type {string} */ | |
| a.Na = n; | |
| if ("" === n) { | |
| X(a.m.parentElement, true); | |
| X(a.b, false); | |
| if (p) { | |
| X(p, false); | |
| } | |
| } else { | |
| X(a.m.parentElement, false); | |
| X(a.b, true); | |
| if (p) { | |
| X(p, true); | |
| } | |
| a = Kf(a.b); | |
| /** @type {number} */ | |
| p = 0; | |
| for (; p < a.length; p++) { | |
| var b = a[p]; | |
| /** @type {string} */ | |
| var e = n; | |
| var f = ag(b); | |
| /** @type {boolean} */ | |
| var QueryLanguageComponent = 0 == Ac(e, f.substr(0, e.length)); | |
| X(b, QueryLanguageComponent); | |
| b = E("language_list_item", b); | |
| b.innerHTML = f; | |
| if (QueryLanguageComponent) { | |
| e = f.substr(0, e.length); | |
| f = f.replace(e, "<b>" + e + "</b>"); | |
| b.innerHTML = f; | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {?} a | |
| * @param {undefined} b | |
| * @param {string} n | |
| * @param {number} V | |
| * @return {undefined} | |
| */ | |
| uB.prototype.Te = function(a, b, n, V) { | |
| JA(this, b); | |
| Ql(this.F, "sl_list" == this.va, mB[n], b, V, "srch" == n ? this.Na : ""); | |
| /** @type {string} */ | |
| this.R.ct = (Ua() - this.Aa).toString(); | |
| /** @type {string} */ | |
| this.R.stp = n; | |
| this.close(); | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| uB.prototype.W = function(type, value) { | |
| if ("auto" != value) { | |
| type = new gB(value, type); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < this.c.length; i++) { | |
| if (this.c[i].code === value) { | |
| xB(this, i, 1); | |
| break; | |
| } | |
| } | |
| value = new kB(type, this, "rcnt"); | |
| If(this.w, value.j(), 1); | |
| this.c.splice(0, 0, value); | |
| if (5 < this.c.length) { | |
| xB(this, 5, this.c.length - 5); | |
| } | |
| X(this.w, true); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} p | |
| * @return {undefined} | |
| */ | |
| var zB = function(p) { | |
| p.Aa = Ua(); | |
| p.ma(); | |
| yB(p, p.a); | |
| yB(p, p.c); | |
| yB(p, p.g); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < p.a.length; i++) { | |
| var f = p.a[i]; | |
| var previous = p.L.includes(f.code); | |
| V(f.j(), "item-emphasized", previous); | |
| } | |
| Pl(p.F, "sl_list" === p.va ? 82 : 83); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| uB.prototype.close = function() { | |
| Tg(this.ra, "returned"); | |
| }; | |
| /** | |
| * @param {!Object} c | |
| * @param {!NodeList} res | |
| * @return {undefined} | |
| */ | |
| var yB = function(c, res) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < res.length; i++) { | |
| V(res[i].j(), "item-selected", res[i].code === c.T); | |
| var link = E("language_list_item", res[i].j()); | |
| /** @type {string} */ | |
| var url = ""; | |
| if (res[i].code === c.T) { | |
| url = c.h.g.replace("%1$s", res[i].Ub); | |
| } | |
| link.setAttribute("aria-label", url); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} w | |
| * @param {number} pos | |
| * @param {number} removeCount | |
| * @return {undefined} | |
| */ | |
| var xB = function(w, pos, removeCount) { | |
| /** @type {number} */ | |
| var i = pos; | |
| for (; i < pos + removeCount; i++) { | |
| Jf(w.c[i].j()); | |
| } | |
| w.c.splice(pos, removeCount); | |
| X(w.w, 0 < w.c.length); | |
| }; | |
| /** | |
| * @param {!Object} r | |
| * @param {!NodeList} b | |
| * @return {undefined} | |
| */ | |
| var BB = function(r, b) { | |
| xB(r, 0, r.c.length); | |
| X(r.w, 0 < b.length); | |
| /** @type {number} */ | |
| var bi = 0; | |
| for (; bi < b.length && 5 > bi; bi++) { | |
| var m = new gB(b[bi], ""); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < r.a.length; i++) { | |
| if (r.a[i].code === b[bi]) { | |
| m.Name = r.a[i].Ub; | |
| } | |
| } | |
| m = AB(r, m, r.w, "rcnt"); | |
| r.c.push(m); | |
| } | |
| /** @type {!NodeList} */ | |
| r.L = b; | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @return {undefined} | |
| */ | |
| var DB = function(obj) { | |
| X(obj.o, true); | |
| obj.Y(); | |
| CB(obj).focus(); | |
| }; | |
| /** | |
| * @param {!Object} params | |
| * @return {undefined} | |
| */ | |
| var EB = function(params) { | |
| if (!dq(params.o)) { | |
| DB(params); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| uB.prototype.ma = function() { | |
| this.Y(); | |
| X(this.o, false); | |
| }; | |
| /** | |
| * @param {boolean} a | |
| * @return {undefined} | |
| */ | |
| uB.prototype.setVisible = function(a) { | |
| X(this.v, a); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| uB.prototype.isVisible = function() { | |
| return dq(this.v); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| uB.prototype.Y = function() { | |
| /** @type {string} */ | |
| CB(this).value = ""; | |
| vB(this, ""); | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @return {?} | |
| */ | |
| var CB = function(o) { | |
| return gb(o.v.querySelector("#" + o.va + "-search-box")); | |
| }; | |
| /** | |
| * @param {!Object} c | |
| * @param {string} b | |
| * @param {!Object} f | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var AB = function(c, b, f, a) { | |
| a = new kB(b, c, a); | |
| if ("auto" === b.Code) { | |
| If(c.m, a.j(), 0); | |
| } else { | |
| Df(f, a.j()); | |
| } | |
| return a; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| var sB = function(a, b) { | |
| a = Bp(FB, { | |
| text : a | |
| }); | |
| Df(b, a); | |
| return a; | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| uB.prototype.K = function(type) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < this.a.length; i++) { | |
| Jf(this.a[i].j()); | |
| } | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < this.g.length; i++) { | |
| Jf(this.g[i].j()); | |
| } | |
| /** @type {!Array} */ | |
| this.a = []; | |
| /** @type {!Array} */ | |
| this.g = []; | |
| if (null != type) { | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < type.length; i++) { | |
| var a = AB(this, type[i], this.Da, "rglr"); | |
| this.a.push(a); | |
| if ("auto" != type[i].Code) { | |
| a = AB(this, type[i], this.b, "srch"); | |
| this.g.push(a); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| uB.prototype.X = function() { | |
| uB.D.X.call(this); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| uB.prototype.j = function() { | |
| return this.v; | |
| }; | |
| /** | |
| * @param {number} a | |
| * @return {undefined} | |
| */ | |
| var GB = function(a) { | |
| /** @type {number} */ | |
| this.a = a; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| GB.prototype.Cb = function() { | |
| return null; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| GB.prototype.ab = function() { | |
| return this.a; | |
| }; | |
| var HB = { | |
| "* ARIA-CHECKED" : true, | |
| "* ARIA-COLCOUNT" : true, | |
| "* ARIA-COLINDEX" : true, | |
| "* ARIA-DESCRIBEDBY" : true, | |
| "* ARIA-DISABLED" : true, | |
| "* ARIA-GOOG-EDITABLE" : true, | |
| "* ARIA-LABEL" : true, | |
| "* ARIA-LABELLEDBY" : true, | |
| "* ARIA-MULTILINE" : true, | |
| "* ARIA-MULTISELECTABLE" : true, | |
| "* ARIA-ORIENTATION" : true, | |
| "* ARIA-PLACEHOLDER" : true, | |
| "* ARIA-READONLY" : true, | |
| "* ARIA-REQUIRED" : true, | |
| "* ARIA-ROLEDESCRIPTION" : true, | |
| "* ARIA-ROWCOUNT" : true, | |
| "* ARIA-ROWINDEX" : true, | |
| "* ARIA-SELECTED" : true, | |
| "* ABBR" : true, | |
| "* ACCEPT" : true, | |
| "* ACCESSKEY" : true, | |
| "* ALIGN" : true, | |
| "* ALT" : true, | |
| "* AUTOCOMPLETE" : true, | |
| "* AXIS" : true, | |
| "* BGCOLOR" : true, | |
| "* BORDER" : true, | |
| "* CELLPADDING" : true, | |
| "* CELLSPACING" : true, | |
| "* CHAROFF" : true, | |
| "* CHAR" : true, | |
| "* CHECKED" : true, | |
| "* CLEAR" : true, | |
| "* COLOR" : true, | |
| "* COLSPAN" : true, | |
| "* COLS" : true, | |
| "* COMPACT" : true, | |
| "* COORDS" : true, | |
| "* DATETIME" : true, | |
| "* DIR" : true, | |
| "* DISABLED" : true, | |
| "* ENCTYPE" : true, | |
| "* FACE" : true, | |
| "* FRAME" : true, | |
| "* HEIGHT" : true, | |
| "* HREFLANG" : true, | |
| "* HSPACE" : true, | |
| "* ISMAP" : true, | |
| "* LABEL" : true, | |
| "* LANG" : true, | |
| "* MAX" : true, | |
| "* MAXLENGTH" : true, | |
| "* METHOD" : true, | |
| "* MULTIPLE" : true, | |
| "* NOHREF" : true, | |
| "* NOSHADE" : true, | |
| "* NOWRAP" : true, | |
| "* OPEN" : true, | |
| "* READONLY" : true, | |
| "* REQUIRED" : true, | |
| "* REL" : true, | |
| "* REV" : true, | |
| "* ROLE" : true, | |
| "* ROWSPAN" : true, | |
| "* ROWS" : true, | |
| "* RULES" : true, | |
| "* SCOPE" : true, | |
| "* SELECTED" : true, | |
| "* SHAPE" : true, | |
| "* SIZE" : true, | |
| "* SPAN" : true, | |
| "* START" : true, | |
| "* SUMMARY" : true, | |
| "* TABINDEX" : true, | |
| "* TITLE" : true, | |
| "* TYPE" : true, | |
| "* VALIGN" : true, | |
| "* VALUE" : true, | |
| "* VSPACE" : true, | |
| "* WIDTH" : true | |
| }; | |
| var IB = { | |
| "* USEMAP" : true, | |
| "* ACTION" : true, | |
| "* CITE" : true, | |
| "* HREF" : true, | |
| "* LONGDESC" : true, | |
| "* SRC" : true, | |
| "LINK HREF" : true, | |
| "* FOR" : true, | |
| "* HEADERS" : true, | |
| "* NAME" : true, | |
| "A TARGET" : true, | |
| "* CLASS" : true, | |
| "* ID" : true, | |
| "* STYLE" : true | |
| }; | |
| var JB = {}; | |
| /** | |
| * @param {string} k | |
| * @return {?} | |
| */ | |
| function KB(k) { | |
| if (C.product.V && !C.Ea(9)) { | |
| return [0, 0, 0, 0]; | |
| } | |
| var c = JB.hasOwnProperty(k) ? JB[k] : null; | |
| if (c) { | |
| return c; | |
| } | |
| if (65536 < Object.keys(JB).length) { | |
| JB = {}; | |
| } | |
| /** @type {!Array} */ | |
| var p = [0, 0, 0, 0]; | |
| c = LB(k, /\\[0-9A-Fa-f]{6}\s?/g); | |
| c = LB(c, /\\[0-9A-Fa-f]{1,5}\s/g); | |
| c = LB(c, /\\./g); | |
| c = c.replace(/:not\(([^\)]*)\)/g, " $1 "); | |
| c = c.replace(/{[^]*/gm, ""); | |
| c = MB(c, p, /(\[[^\]]+\])/g, 2); | |
| c = MB(c, p, /(#[^#\s\+>~\.\[:]+)/g, 1); | |
| c = MB(c, p, /(\.[^\s\+>~\.\[:]+)/g, 2); | |
| c = MB(c, p, /(::[^\s\+>~\.\[:]+|:first-line|:first-letter|:before|:after)/gi, 3); | |
| c = MB(c, p, /(:[\w-]+\([^\)]*\))/gi, 2); | |
| c = MB(c, p, /(:[^\s\+>~\.\[:]+)/g, 2); | |
| c = c.replace(/[\*\s\+>~]/g, " "); | |
| c = c.replace(/[#\.]/g, " "); | |
| MB(c, p, /([^\s\+>~\.\[:]+)/g, 3); | |
| /** @type {!Array} */ | |
| c = p; | |
| return JB[k] = c; | |
| } | |
| /** | |
| * @param {string} common | |
| * @param {!Array} value | |
| * @param {!RegExp} projectId | |
| * @param {number} callback | |
| * @return {?} | |
| */ | |
| function MB(common, value, projectId, callback) { | |
| return common.replace(projectId, function(inRevIdx) { | |
| value[callback] += 1; | |
| return Array(inRevIdx.length + 1).join(" "); | |
| }); | |
| } | |
| /** | |
| * @param {string} i | |
| * @param {!RegExp} k | |
| * @return {?} | |
| */ | |
| function LB(i, k) { | |
| return i.replace(k, function(inRevIdx) { | |
| return Array(inRevIdx.length + 1).join("A"); | |
| }); | |
| } | |
| var NB = { | |
| rgb : true, | |
| rgba : true, | |
| alpha : true, | |
| rect : true, | |
| image : true, | |
| "linear-gradient" : true, | |
| "radial-gradient" : true, | |
| "repeating-linear-gradient" : true, | |
| "repeating-radial-gradient" : true, | |
| "cubic-bezier" : true, | |
| matrix : true, | |
| perspective : true, | |
| rotate : true, | |
| rotate3d : true, | |
| rotatex : true, | |
| rotatey : true, | |
| steps : true, | |
| rotatez : true, | |
| scale : true, | |
| scale3d : true, | |
| scalex : true, | |
| scaley : true, | |
| scalez : true, | |
| skew : true, | |
| skewx : true, | |
| skewy : true, | |
| translate : true, | |
| translate3d : true, | |
| translatex : true, | |
| translatey : true, | |
| translatez : true | |
| }; | |
| /** @type {!RegExp} */ | |
| var OB = /[\n\f\r"'()*<>]/g; | |
| var PB = { | |
| "\n" : "%0a", | |
| "\f" : "%0c", | |
| "\r" : "%0d", | |
| '"' : "%22", | |
| "'" : "%27", | |
| "(" : "%28", | |
| ")" : "%29", | |
| "*" : "%2a", | |
| "<" : "%3c", | |
| ">" : "%3e" | |
| }; | |
| /** | |
| * @param {?} i | |
| * @return {?} | |
| */ | |
| function QB(i) { | |
| return z(PB[i]); | |
| } | |
| /** | |
| * @param {string} result | |
| * @param {string} name | |
| * @param {string} c | |
| * @return {?} | |
| */ | |
| var RB = function(result, name, c) { | |
| name = zc(name); | |
| if ("" == name) { | |
| return null; | |
| } | |
| if (0 == Ac("url(", name.substr(0, 4))) { | |
| if (!name.endsWith(")") || 1 < (name ? name.split("(").length - 1 : 0) || 1 < (name ? name.split(")").length - 1 : 0) || !c) { | |
| /** @type {null} */ | |
| result = null; | |
| } else { | |
| a: { | |
| name = name.substring(4, name.length - 1); | |
| /** @type {number} */ | |
| var level = 0; | |
| for (; 2 > level; level++) { | |
| /** @type {string} */ | |
| var adjustedLevel = "\"'".charAt(level); | |
| if (name.charAt(0) == adjustedLevel && name.charAt(name.length - 1) == adjustedLevel) { | |
| name = name.substring(1, name.length - 1); | |
| break a; | |
| } | |
| } | |
| } | |
| /** @type {(null|string)} */ | |
| result = c ? (result = c(name, result)) && "about:invalid#zClosurez" != Sc(result) ? 'url("' + Sc(result).replace(OB, QB) + '")' : null : null; | |
| } | |
| return result; | |
| } | |
| if (0 < name.indexOf("(")) { | |
| if (/"|'/.test(name)) { | |
| return null; | |
| } | |
| /** @type {!RegExp} */ | |
| result = /([\-\w]+)\(/g; | |
| for (; c = result.exec(name);) { | |
| if (!(c[1] in NB)) { | |
| return null; | |
| } | |
| } | |
| } | |
| return name; | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @param {string} key | |
| * @return {?} | |
| */ | |
| function SB(obj, key) { | |
| obj = l[obj]; | |
| return obj && obj.prototype ? (key = Object.getOwnPropertyDescriptor(obj.prototype, key)) && key.get || null : null; | |
| } | |
| /** | |
| * @param {!Object} s | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| function TB(s, name) { | |
| return (s = l[s]) && s.prototype && s.prototype[name] || null; | |
| } | |
| var UB = SB("Element", "attributes") || SB("Node", "attributes"); | |
| var VB = TB("Element", "hasAttribute"); | |
| var WB = TB("Element", "getAttribute"); | |
| var XB = TB("Element", "setAttribute"); | |
| var YB = TB("Element", "removeAttribute"); | |
| var ZB = TB("Element", "getElementsByTagName"); | |
| var $B = TB("Element", "matches") || TB("Element", "msMatchesSelector"); | |
| var aC = SB("Node", "nodeName"); | |
| var bC = SB("Node", "nodeType"); | |
| var cC = SB("Node", "parentNode"); | |
| var dC = SB("HTMLElement", "style") || SB("Element", "style"); | |
| var eC = SB("HTMLStyleElement", "sheet"); | |
| var fC = TB("CSSStyleDeclaration", "getPropertyValue"); | |
| var gC = TB("CSSStyleDeclaration", "setProperty"); | |
| /** | |
| * @param {!Function} val | |
| * @param {!Object} type | |
| * @param {string} key | |
| * @param {!Function} obtainGETData | |
| * @return {?} | |
| */ | |
| function hC(val, type, key, obtainGETData) { | |
| if (val) { | |
| return val.apply(type); | |
| } | |
| val = type[key]; | |
| if (!obtainGETData(val)) { | |
| throw Error("Clobbering detected"); | |
| } | |
| return val; | |
| } | |
| /** | |
| * @param {!Function} _ | |
| * @param {!Object} data | |
| * @param {string} property | |
| * @param {!Array} exclude | |
| * @return {?} | |
| */ | |
| function iC(_, data, property, exclude) { | |
| if (_) { | |
| return _.apply(data, exclude); | |
| } | |
| if (C.product.V && 10 > document.documentMode) { | |
| if (!data[property].call) { | |
| throw Error("IE Clobbering detected"); | |
| } | |
| } else { | |
| if ("function" != typeof data[property]) { | |
| throw Error("Clobbering detected"); | |
| } | |
| } | |
| return data[property].apply(data, exclude); | |
| } | |
| /** | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| function jC(b) { | |
| return hC(UB, b, "attributes", function(obj) { | |
| return obj instanceof NamedNodeMap; | |
| }); | |
| } | |
| /** | |
| * @param {!Object} identifier | |
| * @param {string} text | |
| * @param {string} type | |
| * @return {undefined} | |
| */ | |
| function kC(identifier, text, type) { | |
| try { | |
| iC(XB, identifier, "setAttribute", [text, type]); | |
| } catch (d) { | |
| if (-1 == d.message.indexOf("A security problem occurred")) { | |
| throw d; | |
| } | |
| } | |
| } | |
| /** | |
| * @param {!Element} key | |
| * @return {?} | |
| */ | |
| function lC(key) { | |
| mC(key); | |
| return hC(dC, key, "style", function(object) { | |
| return object instanceof CSSStyleDeclaration; | |
| }); | |
| } | |
| /** | |
| * @param {!Node} elem | |
| * @return {undefined} | |
| */ | |
| function mC(elem) { | |
| if (!(elem instanceof HTMLElement)) { | |
| throw Error("Not an HTMLElement"); | |
| } | |
| } | |
| /** | |
| * @param {!Element} type | |
| * @return {?} | |
| */ | |
| function nC(type) { | |
| mC(type); | |
| return hC(eC, type, "sheet", function(object) { | |
| return object instanceof CSSStyleSheet; | |
| }); | |
| } | |
| /** | |
| * @param {!Element} key | |
| * @return {?} | |
| */ | |
| function oC(key) { | |
| return hC(aC, key, "nodeName", function(matchPart) { | |
| return "string" == typeof matchPart; | |
| }); | |
| } | |
| /** | |
| * @param {!Element} head | |
| * @return {?} | |
| */ | |
| function pC(head) { | |
| return hC(bC, head, "nodeType", function(index) { | |
| return "number" == typeof index; | |
| }); | |
| } | |
| /** | |
| * @param {!Element} el | |
| * @return {?} | |
| */ | |
| function qC(el) { | |
| return hC(cC, el, "parentNode", function(opts) { | |
| return !(opts && "string" == typeof opts.name && opts.name && "parentnode" == opts.name.toLowerCase()); | |
| }); | |
| } | |
| /** | |
| * @param {!Object} style | |
| * @param {string} locale | |
| * @return {?} | |
| */ | |
| function rC(style, locale) { | |
| return iC(fC, style, style.getPropertyValue ? "getPropertyValue" : "getAttribute", [locale]) || ""; | |
| } | |
| /** | |
| * @param {!Object} element | |
| * @param {string} replacement | |
| * @param {string} i | |
| * @return {undefined} | |
| */ | |
| function sC(element, replacement, i) { | |
| iC(gC, element, element.setProperty ? "setProperty" : "setAttribute", [replacement, i]); | |
| } | |
| /** @type {(RegExp|null)} */ | |
| var tC = C.V && 10 > document.documentMode ? null : /\s*([^\s'",]+[^'",]*(('([^'\r\n\f\\]|\\[^])*')|("([^"\r\n\f\\]|\\[^])*")|[^'",])*)/g; | |
| var uC = { | |
| "-webkit-border-horizontal-spacing" : true, | |
| "-webkit-border-vertical-spacing" : true | |
| }; | |
| /** | |
| * @param {!Object} s | |
| * @param {string} b | |
| * @param {string} areMutuallyExclusive | |
| * @return {?} | |
| */ | |
| var xC = function(s, b, areMutuallyExclusive) { | |
| /** @type {!Array} */ | |
| var sentences = []; | |
| s = vC(Ab(s.cssRules)); | |
| A(s, function(rule) { | |
| if (b && !/[a-zA-Z][\w-:\.]*/.test(b)) { | |
| throw Error("Invalid container id"); | |
| } | |
| if (!(b && C.product.V && 10 == document.documentMode && /\\['"]/.test(rule.selectorText))) { | |
| var u = b ? rule.selectorText.replace(tC, "#" + b + " $1") : rule.selectorText; | |
| sentences.push(pd(u, wC(rule.style, areMutuallyExclusive))); | |
| } | |
| }); | |
| return rd(sentences); | |
| }; | |
| /** | |
| * @param {!Arguments} a | |
| * @return {?} | |
| */ | |
| var vC = function(a) { | |
| return lb(a, function(rule) { | |
| return rule instanceof CSSStyleRule || rule.type == CSSRule.STYLE_RULE; | |
| }); | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {number} b | |
| * @param {string} areMutuallyExclusive | |
| * @return {?} | |
| */ | |
| var zC = function(a, b, areMutuallyExclusive) { | |
| a = yC("<style>" + a + "</style>"); | |
| return null == a || null == a.sheet ? sd : xC(a.sheet, void 0 != b ? b : null, areMutuallyExclusive); | |
| }; | |
| /** | |
| * @param {string} body | |
| * @return {?} | |
| */ | |
| var yC = function(body) { | |
| if (C.V && !C.Ea(10) || "function" != typeof l.DOMParser) { | |
| return null; | |
| } | |
| body = Rd(ec("Never attached to DOM."), "<html><head></head><body>" + body + "</body></html>"); | |
| return (new DOMParser).parseFromString(Dd(body), "text/html").body.children[0]; | |
| }; | |
| /** | |
| * @param {!Arguments} el | |
| * @param {string} c | |
| * @return {?} | |
| */ | |
| var wC = function(el, c) { | |
| if (!el) { | |
| return cd; | |
| } | |
| /** @type {!CSSStyleDeclaration} */ | |
| var elementStyle = document.createElement("div").style; | |
| var placeholder = AC(el); | |
| A(placeholder, function(k) { | |
| var key = C.Ka && k in uC ? k : k.replace(/^-(?:apple|css|epub|khtml|moz|mso?|o|rim|wap|webkit|xv)-(?=[a-z])/i, ""); | |
| if (!(vc(key, "--") || vc(key, "var"))) { | |
| k = rC(el, k); | |
| k = RB(key, k, c); | |
| if (null != k) { | |
| sC(elementStyle, key, k); | |
| } | |
| } | |
| }); | |
| return Sd(elementStyle.cssText || ""); | |
| }; | |
| /** | |
| * @param {!Object} element | |
| * @return {undefined} | |
| */ | |
| var CC = function(element) { | |
| /** @type {!Array<?>} */ | |
| var w = Array.from(iC(ZB, element, "getElementsByTagName", ["STYLE"])); | |
| var b = Eb(w, function(css) { | |
| return Ab(nC(css).cssRules); | |
| }); | |
| b = vC(b); | |
| b.sort(function(d, r) { | |
| d = KB(d.selectorText); | |
| a: { | |
| r = KB(r.selectorText); | |
| /** @type {number} */ | |
| var cell_amount = Math.min(d.length, r.length); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < cell_amount; i++) { | |
| var j = d[i]; | |
| var s = r[i]; | |
| /** @type {number} */ | |
| j = j > s ? 1 : j < s ? -1 : 0; | |
| if (0 != j) { | |
| /** @type {number} */ | |
| d = j; | |
| break a; | |
| } | |
| } | |
| d = d.length; | |
| r = r.length; | |
| /** @type {number} */ | |
| d = d > r ? 1 : d < r ? -1 : 0; | |
| } | |
| return -d; | |
| }); | |
| /** @type {!TreeWalker} */ | |
| element = document.createTreeWalker(element, NodeFilter.SHOW_ELEMENT, null, false); | |
| var d; | |
| for (; d = element.nextNode();) { | |
| A(b, function(rule) { | |
| if (iC($B, d, d.matches ? "matches" : "msMatchesSelector", [rule.selectorText]) && rule.style) { | |
| BC(d, rule.style); | |
| } | |
| }); | |
| } | |
| A(w, Jf); | |
| }; | |
| /** | |
| * @param {!Object} c | |
| * @param {!Arguments} cell | |
| * @return {undefined} | |
| */ | |
| var BC = function(c, cell) { | |
| var dataVars = AC(c.style); | |
| var data = AC(cell); | |
| A(data, function(k) { | |
| if (!(0 <= dataVars.indexOf(k))) { | |
| var keyCell = rC(cell, k); | |
| sC(c.style, k, keyCell); | |
| } | |
| }); | |
| }; | |
| /** | |
| * @param {!Array} o | |
| * @return {?} | |
| */ | |
| var AC = function(o) { | |
| if (La(o)) { | |
| o = Ab(o); | |
| } else { | |
| o = Pb(o); | |
| xb(o, "cssText"); | |
| } | |
| return o; | |
| }; | |
| /** @type {boolean} */ | |
| var DC = "undefined" != typeof WeakMap && -1 != WeakMap.toString().indexOf("[native code]"); | |
| /** @type {number} */ | |
| var EC = 0; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var FC = function() { | |
| /** @type {!Array} */ | |
| this.c = []; | |
| /** @type {!Array} */ | |
| this.b = []; | |
| /** @type {string} */ | |
| this.a = "data-elementweakmap-index-" + EC++; | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @param {!Object} obj | |
| * @return {?} | |
| */ | |
| FC.prototype.set = function(name, obj) { | |
| if (iC(VB, name, "hasAttribute", [this.a])) { | |
| /** @type {number} */ | |
| var i = parseInt(iC(WB, name, "getAttribute", [this.a]) || null, 10); | |
| /** @type {!Object} */ | |
| this.b[i] = obj; | |
| } else { | |
| /** @type {number} */ | |
| i = this.b.push(obj) - 1; | |
| kC(name, this.a, i.toString()); | |
| this.c.push(name); | |
| } | |
| return this; | |
| }; | |
| /** | |
| * @param {!Object} num | |
| * @return {?} | |
| */ | |
| FC.prototype.get = function(num) { | |
| if (iC(VB, num, "hasAttribute", [this.a])) { | |
| return num = parseInt(iC(WB, num, "getAttribute", [this.a]) || null, 10), this.b[num]; | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| FC.prototype.clear = function() { | |
| this.c.forEach(function(testItemData) { | |
| iC(YB, testItemData, "removeAttribute", [this.a]); | |
| }, this); | |
| /** @type {!Array} */ | |
| this.c = []; | |
| /** @type {!Array} */ | |
| this.b = []; | |
| }; | |
| var GC = wi("goog.html.sanitizer.SafeDomTreeProcessor"); | |
| var HC = !C.V || C.kb(10); | |
| /** @type {boolean} */ | |
| var IC = !C.V || null == document.documentMode; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var JC = function() { | |
| }; | |
| var KC = { | |
| APPLET : true, | |
| AUDIO : true, | |
| BASE : true, | |
| BGSOUND : true, | |
| EMBED : true, | |
| FORM : true, | |
| IFRAME : true, | |
| ISINDEX : true, | |
| KEYGEN : true, | |
| LAYER : true, | |
| LINK : true, | |
| META : true, | |
| OBJECT : true, | |
| SCRIPT : true, | |
| SVG : true, | |
| STYLE : true, | |
| TEMPLATE : true, | |
| VIDEO : true | |
| }; | |
| var LC = { | |
| A : true, | |
| ABBR : true, | |
| ACRONYM : true, | |
| ADDRESS : true, | |
| AREA : true, | |
| ARTICLE : true, | |
| ASIDE : true, | |
| B : true, | |
| BDI : true, | |
| BDO : true, | |
| BIG : true, | |
| BLOCKQUOTE : true, | |
| BR : true, | |
| BUTTON : true, | |
| CAPTION : true, | |
| CENTER : true, | |
| CITE : true, | |
| CODE : true, | |
| COL : true, | |
| COLGROUP : true, | |
| DATA : true, | |
| DATALIST : true, | |
| DD : true, | |
| DEL : true, | |
| DETAILS : true, | |
| DFN : true, | |
| DIALOG : true, | |
| DIR : true, | |
| DIV : true, | |
| DL : true, | |
| DT : true, | |
| EM : true, | |
| FIELDSET : true, | |
| FIGCAPTION : true, | |
| FIGURE : true, | |
| FONT : true, | |
| FOOTER : true, | |
| FORM : true, | |
| H1 : true, | |
| H2 : true, | |
| H3 : true, | |
| H4 : true, | |
| H5 : true, | |
| H6 : true, | |
| HEADER : true, | |
| HGROUP : true, | |
| HR : true, | |
| I : true, | |
| IMG : true, | |
| INPUT : true, | |
| INS : true, | |
| KBD : true, | |
| LABEL : true, | |
| LEGEND : true, | |
| LI : true, | |
| MAIN : true, | |
| MAP : true, | |
| MARK : true, | |
| MENU : true, | |
| METER : true, | |
| NAV : true, | |
| NOSCRIPT : true, | |
| OL : true, | |
| OPTGROUP : true, | |
| OPTION : true, | |
| OUTPUT : true, | |
| P : true, | |
| PRE : true, | |
| PROGRESS : true, | |
| Q : true, | |
| S : true, | |
| SAMP : true, | |
| SECTION : true, | |
| SELECT : true, | |
| SMALL : true, | |
| SOURCE : true, | |
| SPAN : true, | |
| STRIKE : true, | |
| STRONG : true, | |
| STYLE : true, | |
| SUB : true, | |
| SUMMARY : true, | |
| SUP : true, | |
| TABLE : true, | |
| TBODY : true, | |
| TD : true, | |
| TEXTAREA : true, | |
| TFOOT : true, | |
| TH : true, | |
| THEAD : true, | |
| TIME : true, | |
| TR : true, | |
| TT : true, | |
| U : true, | |
| UL : true, | |
| VAR : true, | |
| WBR : true | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @return {undefined} | |
| */ | |
| var PC = function(options) { | |
| options = options || new MC; | |
| NC(options); | |
| this.a = Vb(options.a); | |
| this.g = Vb(options.C); | |
| this.h = Vb(options.L); | |
| this.w = options.w; | |
| A(options.o, function(date) { | |
| if (!vc(date, "data-")) { | |
| throw new Xa('Only "data-" attributes allowed, got: %s.', [date]); | |
| } | |
| if (vc(date, "data-sanitizer-")) { | |
| throw new Xa('Attributes with "%s" prefix are not allowed, got: %s.', ["data-sanitizer-", date]); | |
| } | |
| /** @type {function(string): ?} */ | |
| this.a["* " + date.toUpperCase()] = OC; | |
| }, this); | |
| this.m = options.c; | |
| this.c = options.G; | |
| /** @type {null} */ | |
| this.b = null; | |
| this.o = options.m; | |
| }; | |
| x(PC, JC); | |
| /** | |
| * @param {?} resolve | |
| * @return {?} | |
| */ | |
| var QC = function(resolve) { | |
| return function(b, y) { | |
| return (b = resolve(zc(b), y)) && "about:invalid#zClosurez" != Sc(b) ? Sc(b) : null; | |
| }; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var MC = function() { | |
| this.a = {}; | |
| A([HB, IB], function(headers) { | |
| A(Pb(headers), function(index) { | |
| /** @type {function(string): ?} */ | |
| this.a[index] = OC; | |
| }, this); | |
| }, this); | |
| this.b = {}; | |
| /** @type {!Array} */ | |
| this.o = []; | |
| this.C = Vb(KC); | |
| this.L = Vb(LC); | |
| /** @type {boolean} */ | |
| this.w = false; | |
| /** @type {function(!Object): ?} */ | |
| this.Ga = Xc; | |
| /** @type {function(): ?} */ | |
| this.R = this.h = this.K = this.c = Jb; | |
| /** @type {null} */ | |
| this.G = null; | |
| /** @type {boolean} */ | |
| this.g = this.m = false; | |
| }; | |
| /** | |
| * @param {?} defaults | |
| * @param {!Function} extend | |
| * @return {?} | |
| */ | |
| var RC = function(defaults, extend) { | |
| return function(options, defaultConfig, defaultOptions, settings) { | |
| options = defaults(options, defaultConfig, defaultOptions, settings); | |
| return null == options ? null : extend(options, defaultConfig, defaultOptions, settings); | |
| }; | |
| }; | |
| /** | |
| * @param {!Object} settings | |
| * @param {!Object} pos | |
| * @param {string} name | |
| * @param {!Function} value | |
| * @return {undefined} | |
| */ | |
| var SC = function(settings, pos, name, value) { | |
| if (settings[name] && !pos[name]) { | |
| settings[name] = RC(settings[name], value); | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| var TC = function() { | |
| var multipleChoice = new MC; | |
| return new PC(multipleChoice); | |
| }; | |
| /** | |
| * @param {!Object} c | |
| * @return {undefined} | |
| */ | |
| var NC = function(c) { | |
| if (c.g) { | |
| throw Error("HtmlSanitizer.Builder.build() can only be used once."); | |
| } | |
| SC(c.a, c.b, "* USEMAP", UC); | |
| var sliderFeLineGsValue = QC(c.Ga); | |
| A(["* ACTION", "* CITE", "* HREF"], function(skeletonId) { | |
| SC(this.a, this.b, skeletonId, sliderFeLineGsValue); | |
| }, c); | |
| var a = QC(c.c); | |
| A(["* LONGDESC", "* SRC", "LINK HREF"], function(skeletonId) { | |
| SC(this.a, this.b, skeletonId, a); | |
| }, c); | |
| A(["* FOR", "* HEADERS", "* NAME"], function(skeletonId) { | |
| SC(this.a, this.b, skeletonId, Ta(VC, this.K)); | |
| }, c); | |
| SC(c.a, c.b, "A TARGET", Ta(WC, ["_blank", "_self"])); | |
| SC(c.a, c.b, "* CLASS", Ta(XC, c.h)); | |
| SC(c.a, c.b, "* ID", Ta(YC, c.h)); | |
| SC(c.a, c.b, "* STYLE", Ta(c.R, a)); | |
| /** @type {boolean} */ | |
| c.g = true; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {string} b | |
| * @return {?} | |
| */ | |
| var ZC = function(a, b) { | |
| if (!a) { | |
| /** @type {string} */ | |
| a = "*"; | |
| } | |
| return (a + " " + b).toUpperCase(); | |
| }; | |
| /** | |
| * @param {string} cX1 | |
| * @return {?} | |
| */ | |
| var OC = function(cX1) { | |
| return zc(cX1); | |
| }; | |
| /** | |
| * @param {!Array} a | |
| * @param {string} b | |
| * @return {?} | |
| */ | |
| var WC = function(a, b) { | |
| b = zc(b); | |
| return tb(a, b.toLowerCase()) ? b : null; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @return {?} | |
| */ | |
| var UC = function(a) { | |
| return (a = zc(a)) && "#" == a.charAt(0) ? a : null; | |
| }; | |
| /** | |
| * @param {?} f | |
| * @param {string} a | |
| * @param {?} b | |
| * @return {?} | |
| */ | |
| var VC = function(f, a, b) { | |
| return f(zc(a), b); | |
| }; | |
| /** | |
| * @param {?} g | |
| * @param {string} b | |
| * @param {?} n | |
| * @return {?} | |
| */ | |
| var XC = function(g, b, n) { | |
| b = b.split(/(?:\s+)/); | |
| /** @type {!Array} */ | |
| var qs = []; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < b.length; i++) { | |
| var r = g(b[i], n); | |
| if (r) { | |
| qs.push(r); | |
| } | |
| } | |
| return 0 == qs.length ? null : qs.join(" "); | |
| }; | |
| /** | |
| * @param {?} f | |
| * @param {string} a | |
| * @param {?} b | |
| * @return {?} | |
| */ | |
| var YC = function(f, a, b) { | |
| return f(zc(a), b); | |
| }; | |
| /** | |
| * @param {!Object} t | |
| * @param {string} e | |
| * @return {?} | |
| */ | |
| var aD = function(t, e) { | |
| /** @type {boolean} */ | |
| var p = !("STYLE" in t.g) && "STYLE" in t.h; | |
| p = "*" == t.c && p ? "sanitizer-" + (Math.floor(2147483648 * Math.random()).toString(36) + Math.abs(Math.floor(2147483648 * Math.random()) ^ Ua()).toString(36)) : t.c; | |
| t.b = p; | |
| if (HC) { | |
| /** @type {string} */ | |
| p = e; | |
| if (HC) { | |
| e = zf("SPAN"); | |
| if (t.b && "*" == t.c) { | |
| e.id = t.b; | |
| } | |
| if (t.o) { | |
| p = yC("<div>" + p + "</div>"); | |
| z(p, "Older browsers that don't support inert parsing should not get to this branch"); | |
| CC(p); | |
| p = p.innerHTML; | |
| } | |
| p = Rd(ec("Never attached to DOM."), p); | |
| /** @type {!Element} */ | |
| var element = document.createElement("template"); | |
| if (IC && "content" in element) { | |
| Vd(element, p); | |
| element = element.content; | |
| } else { | |
| /** @type {!HTMLDocument} */ | |
| var e = document.implementation.createHTMLDocument("x"); | |
| /** @type {!HTMLBodyElement} */ | |
| element = e.body; | |
| Vd(e.body, p); | |
| } | |
| /** @type {!TreeWalker} */ | |
| p = document.createTreeWalker(element, NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT, null, false); | |
| element = DC ? new WeakMap : new FC; | |
| for (; e = p.nextNode();) { | |
| c: { | |
| /** @type {!Object} */ | |
| var f = t; | |
| /** @type {!Node} */ | |
| var data = e; | |
| var i = pC(data); | |
| switch(i) { | |
| case 3: | |
| data = $C(f, data); | |
| break c; | |
| case 1: | |
| /** @type {!Node} */ | |
| i = data; | |
| if (!(1 == pC(i))) { | |
| Za("Expected Node of type Element but got Node of type %s", pC(i)); | |
| } | |
| data = f; | |
| /** @type {!Node} */ | |
| f = i; | |
| if ("TEMPLATE" == oC(f).toUpperCase()) { | |
| /** @type {null} */ | |
| data = null; | |
| } else { | |
| i = oC(f).toUpperCase(); | |
| if (i in data.g) { | |
| /** @type {null} */ | |
| var id = null; | |
| } else { | |
| if (data.h[i]) { | |
| /** @type {!Element} */ | |
| id = document.createElement(i); | |
| } else { | |
| id = zf("SPAN"); | |
| if (data.w) { | |
| kC(id, "data-sanitizer-original-tag", i.toLowerCase()); | |
| } | |
| } | |
| } | |
| if (id) { | |
| var root = id; | |
| var types = jC(f); | |
| if (null != types) { | |
| /** @type {number} */ | |
| var j = 0; | |
| for (; i = types[j]; j++) { | |
| if (i.specified) { | |
| var o = data; | |
| /** @type {!Node} */ | |
| var j = f; | |
| var value = i; | |
| var k = value.name; | |
| if (vc(k, "data-sanitizer-")) { | |
| /** @type {null} */ | |
| o = null; | |
| } else { | |
| var a = oC(j); | |
| value = value.value; | |
| var defaults = { | |
| tagName : zc(a).toLowerCase(), | |
| attributeName : zc(k).toLowerCase() | |
| }; | |
| var b = { | |
| xl : void 0 | |
| }; | |
| if ("style" == defaults.attributeName) { | |
| b.xl = lC(j); | |
| } | |
| j = ZC(a, k); | |
| if (j in o.a) { | |
| o = o.a[j]; | |
| o = o(value, defaults, b); | |
| } else { | |
| k = ZC(null, k); | |
| if (k in o.a) { | |
| o = o.a[k]; | |
| o = o(value, defaults, b); | |
| } else { | |
| /** @type {null} */ | |
| o = null; | |
| } | |
| } | |
| } | |
| if (!(null === o)) { | |
| kC(root, i.name, o); | |
| } | |
| } | |
| } | |
| } | |
| data = id; | |
| } else { | |
| /** @type {null} */ | |
| data = null; | |
| } | |
| } | |
| break c; | |
| default: | |
| yi(GC, "Dropping unknown node type: " + i); | |
| /** @type {null} */ | |
| data = null; | |
| } | |
| } | |
| if (data) { | |
| if (1 == pC(data) && element.set(e, data), e = qC(e), f = false, e) { | |
| i = pC(e); | |
| id = oC(e).toLowerCase(); | |
| root = qC(e); | |
| if (11 != i || root) { | |
| if ("body" == id && root && (i = qC(root)) && !qC(i)) { | |
| /** @type {boolean} */ | |
| f = true; | |
| } | |
| } else { | |
| /** @type {boolean} */ | |
| f = true; | |
| } | |
| /** @type {null} */ | |
| i = null; | |
| if (f || !e) { | |
| /** @type {string} */ | |
| i = e; | |
| } else { | |
| if (1 == pC(e)) { | |
| i = element.get(e); | |
| } | |
| } | |
| if (i.content) { | |
| i = i.content; | |
| } | |
| i.appendChild(data); | |
| } | |
| } else { | |
| Ff(e); | |
| } | |
| } | |
| if (element.clear) { | |
| element.clear(); | |
| } | |
| /** @type {string} */ | |
| t = e; | |
| } else { | |
| t = zf("SPAN"); | |
| } | |
| if (0 < jC(t).length) { | |
| e = zf("SPAN"); | |
| e.appendChild(t); | |
| /** @type {string} */ | |
| t = e; | |
| } | |
| /** @type {string} */ | |
| t = (new XMLSerializer).serializeToString(t); | |
| /** @type {string} */ | |
| t = t.slice(t.indexOf(">") + 1, t.lastIndexOf("</")); | |
| } else { | |
| /** @type {string} */ | |
| t = ""; | |
| } | |
| return Rd(ec("Output of HTML sanitizer"), t); | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @param {!Node} a | |
| * @return {?} | |
| */ | |
| var $C = function(b, a) { | |
| var c = a.data; | |
| if ((a = qC(a)) && "style" == oC(a).toLowerCase() && !("STYLE" in b.g) && "STYLE" in b.h) { | |
| c = qd(zC(c, b.b, v(function(d, tabWidth) { | |
| return this.m(d, { | |
| xs : tabWidth | |
| }); | |
| }, b))); | |
| } | |
| return document.createTextNode(c); | |
| }; | |
| /** | |
| * @param {string} alreadyFailedWithException | |
| * @return {?} | |
| */ | |
| var bD = function(alreadyFailedWithException) { | |
| return aD(TC(), alreadyFailedWithException); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var cD = function() { | |
| }; | |
| x(cD, Uq); | |
| Ia(cD); | |
| /** | |
| * @return {?} | |
| */ | |
| cD.prototype.nd = function() { | |
| return "menuitem"; | |
| }; | |
| /** | |
| * @param {!Object} p | |
| * @return {?} | |
| */ | |
| cD.prototype.Eb = function(p) { | |
| var data = bD(p.Ed); | |
| var d = Bf(document, data); | |
| data = d.querySelector("div"); | |
| if (!data) { | |
| throw Error("Invalid item label"); | |
| } | |
| data.innerHTML = p.ab(); | |
| up(data, ["gt-is-sp", "gt-is-cont"]); | |
| /** @type {!Array} */ | |
| data = ["DIV", Xq(this, p)]; | |
| var header = G("DIV"); | |
| T(header, "gt-is-ld"); | |
| d = G("DIV", null, d); | |
| T(d, "gt-is-lb"); | |
| /** @type {!Array<?>} */ | |
| data = data.concat([header, d]); | |
| if (p.Vb) { | |
| d = G("A", { | |
| href : "#" | |
| }, p.Vb); | |
| T(d, "gt-is-act"); | |
| var options = new lr; | |
| options.na(d); | |
| Fq(options, p); | |
| d.addEventListener("mouseup", function(event) { | |
| if (options.tb()) { | |
| event.stopPropagation(); | |
| } | |
| }); | |
| data.push(d); | |
| } | |
| data = G.apply(null, data); | |
| data.id = Bq(p); | |
| return p.v = data; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| cD.prototype.md = function(a) { | |
| return "DIV" == a.tagName; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| cD.prototype.za = function() { | |
| return "gt-is-itm"; | |
| }; | |
| /** | |
| * @param {!Object} state | |
| * @param {string} scope | |
| * @param {?} options | |
| * @param {?} reason | |
| * @param {number} a | |
| * @return {undefined} | |
| */ | |
| var dD = function(state, scope, options, reason, a) { | |
| a = void 0 === a ? "" : a; | |
| lr.call(this, state.ab(), options || cD.N(), reason); | |
| /** @type {!Object} */ | |
| this.xe = state; | |
| /** @type {string} */ | |
| this.Ed = scope; | |
| /** @type {number} */ | |
| this.Vb = a; | |
| this.Sa(1, false); | |
| }; | |
| x(dD, lr); | |
| /** | |
| * @return {?} | |
| */ | |
| dD.prototype.ab = function() { | |
| return this.xe.ab(); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| dD.prototype.Cb = function() { | |
| return this.xe.Cb(); | |
| }; | |
| /** | |
| * @param {?} q | |
| * @return {undefined} | |
| */ | |
| var eD = function(q) { | |
| kg.call(this, q); | |
| }; | |
| x(eD, kg); | |
| jf(window.document); | |
| new L; | |
| /** | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| var fD = function(b) { | |
| var target = b.getBoundingClientRect(); | |
| if (C.V) { | |
| var p = Xp(b); | |
| b = aq(b); | |
| target.left = p.x; | |
| target.right = p.x + b.width; | |
| target.top = p.a; | |
| target.bottom = p.a + b.height; | |
| } | |
| return target; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {number} b | |
| * @return {?} | |
| */ | |
| var gD = function(a, b) { | |
| var data = jf(a); | |
| /** @type {number} */ | |
| var i = 0; | |
| if (Aa(b)) { | |
| /** @type {number} */ | |
| i = b; | |
| } else { | |
| if (C.V && !C.Ea(9)) { | |
| if (b = data.a.selection.createRange()) { | |
| try { | |
| var c = a.createTextRange(); | |
| var e = c.duplicate(); | |
| c.moveToBookmark(b.getBookmark()); | |
| e.setEndPoint("EndToStart", c); | |
| i = e.text.length; | |
| } catch (n) { | |
| } | |
| } | |
| } else { | |
| i = a.selectionStart; | |
| } | |
| } | |
| /** @type {string} */ | |
| c = "_h#" + Qa(a); | |
| var t = data.j(c); | |
| if (t) { | |
| data.Tf(t); | |
| } else { | |
| t = data.b("PRE", { | |
| id : c | |
| }); | |
| } | |
| if (!t.parentNode) { | |
| data.a.body.appendChild(t); | |
| } | |
| /** @type {!Array} */ | |
| var hash = []; | |
| A(a.value, function(n, i, l) { | |
| hash.push(" " == n && i + 1 != l.length && " " == l[i + 1] ? "\u00a0" : n); | |
| }); | |
| /** @type {string} */ | |
| hash = hash.join(""); | |
| data.appendChild(t, data.a.createTextNode(String(hash.substring(0, i)))); | |
| c = fg(data, "SPAN"); | |
| c.appendChild(data.a.createTextNode("\u200b")); | |
| data.appendChild(t, c); | |
| data.appendChild(t, data.a.createTextNode(String(hash.substring(i) + " "))); | |
| data = sp(a); | |
| A(data, function(skeletonId) { | |
| T(t, skeletonId); | |
| }); | |
| /** @type {string} */ | |
| var divStyle = "white-space:pre-wrap;word-wrap:pre-wrap;position:absolute;z-index:-9;visibility:hidden;display:block;"; | |
| A("font-family font-size font-weight font-style text-transform text-decoration letter-spacing word-spacing line-height text-align vertical-align direction width height margin-top margin-right 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".split(" "), function(b) { | |
| try { | |
| var w; | |
| if (w = Jp(a, b) || Kp(a, b) || a.style[b]) { | |
| divStyle = divStyle + (b + ":" + w + ";"); | |
| } | |
| } catch (t) { | |
| } | |
| }); | |
| t.style.cssText = divStyle; | |
| data = Lp(a, "overflowX"); | |
| t.style.overflowX = data && "visible" != data ? data : "auto"; | |
| data = Lp(a, "overflowY"); | |
| t.style.overflowY = data && "visible" != data ? data : "auto"; | |
| t.scrollTop = a.scrollTop; | |
| t.scrollLeft = a.scrollLeft; | |
| Np(t, Sp(a)); | |
| data = fD(c); | |
| return "INPUT" == a.tagName.toUpperCase() ? new cf(data.left, Math.ceil(Xp(a).a + aq(a).height)) : new cf(data.left, Math.ceil(data.bottom)); | |
| }; | |
| /** | |
| * @param {number} compiler | |
| * @param {?} callback | |
| * @return {undefined} | |
| */ | |
| var hD = function(compiler, callback) { | |
| zq.call(this, callback); | |
| /** @type {number} */ | |
| this.c = compiler; | |
| }; | |
| x(hD, zq); | |
| /** @type {string} */ | |
| hD.prototype.b = "info"; | |
| /** @type {boolean} */ | |
| hD.prototype.g = false; | |
| var iD = { | |
| info : "jfk-butterBar-info", | |
| error : "jfk-butterBar-error", | |
| warning : "jfk-butterBar-warning", | |
| promo : "jfk-butterBar-promo" | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| hD.prototype.Tb = function() { | |
| return this.b; | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var jD = function(b, a) { | |
| /** @type {string} */ | |
| b.c = a; | |
| if (a = b.j()) { | |
| var t = b.a; | |
| t.Tf(a); | |
| t.Zi(a, b.c); | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| hD.prototype.isVisible = function() { | |
| var b = this.j(); | |
| return null != b && tp(b, "jfk-butterBar-shown"); | |
| }; | |
| /** | |
| * @param {string} arg | |
| * @return {undefined} | |
| */ | |
| hD.prototype.setVisible = function(arg) { | |
| z(this.Ba, "setVisible must only be called after the butter bar is rendered."); | |
| V(this.j(), "jfk-butterBar-shown", arg); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| hD.prototype.Ra = function() { | |
| this.v = this.a.b("DIV", "jfk-butterBar"); | |
| z(this.j(), "The DOM element for the butter bar cannot be null."); | |
| var value = this.j(); | |
| if (value) { | |
| np(value, "live", "assertive"); | |
| np(value, "atomic", "true"); | |
| } | |
| jD(this, this.c); | |
| this.g = this.g; | |
| if (value = this.j()) { | |
| V(value, "jfk-butterBar-mini", this.g); | |
| } | |
| value = this.b; | |
| if (this.oc()) { | |
| var M = this.j(); | |
| var access_token = iD[value]; | |
| U(M, iD[this.b]); | |
| T(M, access_token); | |
| } | |
| this.b = value; | |
| }; | |
| /** | |
| * @param {number} t | |
| * @param {number} value | |
| * @param {(Object|string)} node | |
| * @return {undefined} | |
| */ | |
| var kD = function(t, value, node) { | |
| L.call(this); | |
| this.w = node.client; | |
| /** @type {number} */ | |
| this.g = t; | |
| /** @type {number} */ | |
| this.a = value; | |
| this.o = node.pn; | |
| /** @type {boolean} */ | |
| this.Y = false; | |
| this.C = node.Wo; | |
| this.R = node.qn; | |
| this.zb = node.vl || null; | |
| this.O = node.ba; | |
| this.Je = node.Xa; | |
| this.Aa = node.gp; | |
| this.Me = node.Ip; | |
| /** @type {null} */ | |
| this.K = null; | |
| this.T = node.Gp; | |
| this.ra = node.Mn; | |
| /** @type {number} */ | |
| this.L = 0; | |
| this.m = {}; | |
| this.$c = node.il; | |
| this.dh = node.Xl; | |
| this.Zd = node.$o; | |
| this.Ta = node.us; | |
| this.Bd = node.vn; | |
| /** @type {boolean} */ | |
| this.Dd = !!node.Is; | |
| /** @type {boolean} */ | |
| this.Z = !!node.rn; | |
| /** @type {boolean} */ | |
| this.ma = !!node.ss; | |
| this.Ie = node.cp || "Did you mean: <div>%1$s</div>"; | |
| this.Ed = node.Js || "Translating <div>%1$s</div>"; | |
| this.He = node.Ks || "Undo"; | |
| this.uf = node.Ns || 500; | |
| t = new hD(""); | |
| t.Za(kf("gt-bbar")); | |
| t.setVisible(false); | |
| /** @type {number} */ | |
| this.W = t; | |
| /** @type {string} */ | |
| this.c = this.b = this.h = ""; | |
| this.G = hm.N(); | |
| if ("async_translate_onebox" == this.w) { | |
| /** @type {string} */ | |
| this.G.o = "/translate"; | |
| } | |
| this.ea = new rq(this); | |
| this.Ke = new Nq(this.o.j()); | |
| this.Da = Uk.N(); | |
| this.F = M.N(); | |
| /** @type {boolean} */ | |
| this.oa = true; | |
| if (this.Zd) { | |
| this.ea.M(this.Ke, "key", this.hc).M(this.o, "change", this.ud); | |
| } | |
| this.ea.M(this.a, "action", this.gb).M(this.o.j(), "blur", this.Hb).M(this.o.j(), "focus", this.ic).M(this.O, "srcLanguageUpdated", this.Na).M(this.O, "tgtLanguageUpdated", this.Na); | |
| if (null != this.R) { | |
| this.ea.M(this.R, "change", this.Ad); | |
| } | |
| }; | |
| x(kD, L); | |
| /** | |
| * @return {undefined} | |
| */ | |
| kD.prototype.update = function() { | |
| if (0 != this.h.length || this.ma) { | |
| if (this.oa) { | |
| mD(this, this.g.a[0]); | |
| this.L++; | |
| this.m[this.L] = {}; | |
| this.m[this.L][0] = Ua(); | |
| nD(this.Aa, this.h, this.b, this.c, v(this.Cd, this, this.h, this.b, this.c, this.L)); | |
| } | |
| } else { | |
| lD(this); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} mix | |
| * @return {undefined} | |
| */ | |
| var pD = function(mix) { | |
| var c = mix.a; | |
| if (c.c) { | |
| c.removeChild(c.c, true); | |
| } | |
| /** @type {null} */ | |
| c.c = null; | |
| oD(mix, !!Iq(mix.a)); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| kD.prototype.Ad = function() { | |
| if (gz(this.R)) { | |
| lD(this); | |
| } | |
| }; | |
| /** | |
| * @param {string} type | |
| * @return {?} | |
| */ | |
| kD.prototype.hc = function(type) { | |
| if (!this.a.isVisible()) { | |
| return false; | |
| } | |
| if (27 == type.keyCode) { | |
| var text = qD(this.g.a); | |
| mm(this.G, this.w, "is", "0", { | |
| q : this.h, | |
| sl : this.b, | |
| tl : this.c, | |
| sn : text.length, | |
| s : text | |
| }); | |
| text = this.F; | |
| var peersDiv = rD(this); | |
| var NINETY_EIGHT_HOURS = sD(this); | |
| N(text, fm(text, 204, peersDiv, NINETY_EIGHT_HOURS, tD(this), [], null != this.a.h, 0)); | |
| lD(this); | |
| } | |
| if (13 == type.keyCode && -1 == this.a.Oa) { | |
| text = qD(this.g.a); | |
| mm(this.G, this.w, "is", "8", { | |
| q : this.h, | |
| sl : this.b, | |
| tl : this.c, | |
| sn : text.length, | |
| s : text | |
| }); | |
| text = this.F; | |
| peersDiv = rD(this); | |
| NINETY_EIGHT_HOURS = sD(this); | |
| N(text, fm(text, 205, peersDiv, NINETY_EIGHT_HOURS, tD(this), [], null != this.a.h, 0)); | |
| lD(this); | |
| } | |
| if (36 == type.keyCode || 35 == type.keyCode) { | |
| return false; | |
| } | |
| text = this.a.ib(type); | |
| if (!(38 != type.keyCode && 40 != type.keyCode || -1 == this.a.Oa)) { | |
| type = Zw(this.a); | |
| if (type != this.a.c && this.o.aa() != type.ab()) { | |
| /** @type {boolean} */ | |
| this.Y = true; | |
| Yk(this.Da, "is"); | |
| this.o.b(type.ab()); | |
| mD(this); | |
| } | |
| } | |
| return text; | |
| }; | |
| /** | |
| * @param {string} f | |
| * @return {undefined} | |
| */ | |
| kD.prototype.ud = function(f) { | |
| if (this.Y) { | |
| /** @type {boolean} */ | |
| this.Y = false; | |
| } else { | |
| if (this.R && gz(this.R)) { | |
| lD(this); | |
| } else { | |
| if ("set" == f.fe) { | |
| lD(this); | |
| } else { | |
| ci(v(this.Le, this, f), 0); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| kD.prototype.Le = function() { | |
| var h = Kc(this.o.aa(), "\n") ? "" : uD(this.o.aa()); | |
| var b = this.O.a; | |
| var c = this.O.b; | |
| if (h != this.h || b != this.b || c != this.c) { | |
| this.h = h; | |
| this.b = b; | |
| this.c = c; | |
| this.update(); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| var uD = function(b) { | |
| return b.replace(/[ \n\t\r\f,\.\?!]+/g, " ").replace(/^ /, ""); | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| kD.prototype.gb = function(type) { | |
| var matchFeedback = rD(this); | |
| var label = sD(this); | |
| var Hook$consumptionResolved = tD(this); | |
| /** @type {!Array} */ | |
| var TableCode = []; | |
| /** @type {boolean} */ | |
| var content = null != this.a.h; | |
| if (type.target == this.a.h) { | |
| content = this.F; | |
| N(content, fm(content, 185, matchFeedback, label, Hook$consumptionResolved, TableCode, true, 1)); | |
| vD(this, "it", "translationSelected", ""); | |
| } else { | |
| if (type.target == this.a.g) { | |
| type = this.F; | |
| N(type, fm(type, 181, matchFeedback, label, Hook$consumptionResolved, TableCode, content, 1)); | |
| vD(this, "ss", "spellingSelected", label); | |
| } else { | |
| if (type.target.getParent && type.target.getParent() === this.a.g) { | |
| vD(this, "ss", "ignoreSpellingSuggestion", ""); | |
| } else { | |
| if (type.target == this.a.c) { | |
| type = this.F; | |
| N(type, fm(type, 183, matchFeedback, label, Hook$consumptionResolved, TableCode, content, 1)); | |
| vD(this, "ls", "languageSelected", Hook$consumptionResolved[0]); | |
| } else { | |
| type = type.target; | |
| a: { | |
| var c = this.a.b; | |
| /** @type {number} */ | |
| var j = 0; | |
| for (; j < c.length; j++) { | |
| if (c[j] == type) { | |
| /** @type {number} */ | |
| c = j; | |
| break a; | |
| } | |
| } | |
| /** @type {number} */ | |
| c = -1; | |
| } | |
| j = this.F; | |
| N(j, fm(j, 142, matchFeedback, label, Hook$consumptionResolved, TableCode, content, c + 1)); | |
| wD(this, type.ab(), "2"); | |
| } | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} args | |
| * @param {number} opts | |
| * @param {string} name | |
| * @param {string} data | |
| * @return {undefined} | |
| */ | |
| var vD = function(args, opts, name, data) { | |
| var segment = qD(args.g.a); | |
| mm(args.G, args.w, "is", "b", { | |
| q : args.h, | |
| sl : args.b, | |
| tl : args.c, | |
| sn : segment.length, | |
| s : segment, | |
| si : 0, | |
| sy : opts | |
| }); | |
| lD(args); | |
| args.dispatchEvent(new eD(name, data)); | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @param {undefined} t | |
| * @param {string} opts | |
| * @return {undefined} | |
| */ | |
| var wD = function(o, t, opts) { | |
| var val = qD(o.g.a); | |
| /** @type {number} */ | |
| var si = 0; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < val.length; i++) { | |
| if (val[i] == t) { | |
| /** @type {number} */ | |
| si = i + 1; | |
| break; | |
| } | |
| } | |
| mm(o.G, o.w, "is", opts, { | |
| q : o.h, | |
| sl : o.b, | |
| tl : o.c, | |
| sn : val.length, | |
| s : val, | |
| si : si | |
| }); | |
| o.h = uD(t); | |
| Yk(o.Da, "is"); | |
| o.o.b(t); | |
| if ("2" == opts) { | |
| lD(o); | |
| o.o.j().blur(); | |
| o.dispatchEvent("suggestionSelected"); | |
| } else { | |
| o.update(); | |
| o.dispatchEvent("suggestionCopied"); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| kD.prototype.Na = function() { | |
| lD(this); | |
| }; | |
| /** | |
| * @param {string} data | |
| * @param {?} options | |
| * @param {?} reference | |
| * @param {string} value | |
| * @param {!Object} e | |
| * @return {undefined} | |
| */ | |
| kD.prototype.Cd = function(data, options, reference, value, e) { | |
| this.m[value][1] = Ua(); | |
| if (0 == this.h.length && !this.ma || 0 == e.length && !this.Z) { | |
| lD(this); | |
| } else { | |
| if (0 == e.length) { | |
| xD(this); | |
| } else { | |
| if (this.b != options || this.c != reference) { | |
| xD(this); | |
| } else { | |
| if (this.T) { | |
| this.m[value][2] = Ua(); | |
| if (this.K) { | |
| this.K.abort(); | |
| } | |
| this.K = Zo(this.Me, this.b, this.c, this.Je, e, v(this.Yd, this, data, value, e), "is", void 0, this.uf); | |
| } else { | |
| yD(this, data, mb(e, function(canCreateDiscussions) { | |
| return new zw(canCreateDiscussions); | |
| }), value); | |
| } | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {undefined} a | |
| * @param {string} i | |
| * @param {!Object} list | |
| * @param {string} items | |
| * @param {!Node} constructorEdge | |
| * @return {undefined} | |
| */ | |
| kD.prototype.Yd = function(a, i, list, items, constructorEdge) { | |
| if (null == items) { | |
| zD(this, a, list, constructorEdge); | |
| Ol(this.F, 145); | |
| } else { | |
| this.m[i][3] = Ua(); | |
| if (list.length == items.length) { | |
| yD(this, a, mb(list, function(canCreateDiscussions, right) { | |
| return new zw(list[right], items[right]); | |
| }), i); | |
| } else { | |
| AD(this); | |
| Ol(this.F, 146); | |
| yD(this, a, mb(list, function(canCreateDiscussions) { | |
| return new zw(canCreateDiscussions); | |
| }), i); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} p | |
| * @return {undefined} | |
| */ | |
| var xD = function(p) { | |
| BD(p.a, []); | |
| /** @type {!Array} */ | |
| p.g.a = []; | |
| mD(p); | |
| var a = p.a; | |
| if (!(a.o && 0 != a.o.length)) { | |
| oD(p, false); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @return {undefined} | |
| */ | |
| var lD = function(o) { | |
| CD(o.Aa); | |
| if (o.K) { | |
| o.K.abort(); | |
| } | |
| oD(o, false); | |
| var node = o.a; | |
| /** @type {!Array} */ | |
| var newNodeLists = []; | |
| for (; node.o && 0 != node.o.length;) { | |
| newNodeLists.push(node.removeChild(Jq(node, 0), true)); | |
| } | |
| /** @type {!Array} */ | |
| node.b = []; | |
| /** @type {null} */ | |
| node.c = null; | |
| /** @type {null} */ | |
| node.g = null; | |
| /** @type {null} */ | |
| node.h = null; | |
| node = o.g; | |
| /** @type {!Array} */ | |
| node.a = []; | |
| /** @type {null} */ | |
| node.b = null; | |
| /** @type {null} */ | |
| node.c = null; | |
| mD(o); | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @param {string} source | |
| * @param {!Object} o | |
| * @param {string} n | |
| * @return {undefined} | |
| */ | |
| var yD = function(obj, source, o, n) { | |
| /** @type {number} */ | |
| var pornResult = obj.m[n][1] - obj.m[n][0]; | |
| if (obj.T) { | |
| /** @type {number} */ | |
| var prev = obj.m[n][3] - obj.m[n][2]; | |
| } | |
| delete obj.m[n]; | |
| if (0 != o.length) { | |
| /** @type {!Object} */ | |
| var v = o; | |
| if (o.length > obj.ra) { | |
| v = Cb(o, 0, obj.ra); | |
| } | |
| obj.g.a = v; | |
| o = {}; | |
| if (obj.T) { | |
| /** @type {(number|undefined)} */ | |
| o.td = prev; | |
| } | |
| if (obj.L > n) { | |
| DD(obj, false); | |
| ED(obj, pornResult, source, v, o, false); | |
| } else { | |
| /** @type {!Array} */ | |
| var listener = []; | |
| A(v, function(f, pokemon) { | |
| pokemon = new Bw(f, this.$c, this.dh, 0 == pokemon && !this.Z, this.T, this.zb); | |
| listener.push(pokemon); | |
| if ((pokemon = this.g.b) && pokemon.ab() == f.ab()) { | |
| /** @type {string} */ | |
| f = ""; | |
| /** @type {(boolean|undefined)} */ | |
| var x = void 0 === x ? false : x; | |
| pokemon = qD(this.g.a); | |
| if (tb(pokemon, f)) { | |
| /** @type {string} */ | |
| f = ""; | |
| } | |
| if (f) { | |
| f = new GB(f); | |
| x = new dD(f, x ? this.Ed : this.Ie, void 0, void 0, x ? this.He : void 0); | |
| /** @type {string} */ | |
| this.g.b = f; | |
| FD(this.a, x); | |
| GD(this.a, true); | |
| oD(this, true); | |
| } else { | |
| /** @type {null} */ | |
| this.g.b = null; | |
| FD(this.a, null); | |
| oD(this, !!Iq(this.a)); | |
| } | |
| } | |
| }, obj); | |
| BD(obj.a, listener); | |
| if (6 < HD(obj.g)) { | |
| pD(obj); | |
| } | |
| if (obj.Z) { | |
| GD(obj.a, !!obj.a.h); | |
| } | |
| mD(obj, v[0]); | |
| if (!obj.Bd) { | |
| n = uf(jf(document).a); | |
| prev = gD(obj.o.j(), obj.o.aa().length); | |
| var clonedI = Sp(Of(obj.a.j())); | |
| /** @type {number} */ | |
| prev.x = 0; | |
| prev.a += n.a; | |
| prev.a -= clonedI.a; | |
| Np(obj.a.j(), prev); | |
| } | |
| if (obj.$c) { | |
| ID(obj); | |
| } | |
| JD(obj); | |
| oD(obj, true); | |
| DD(obj, true); | |
| ED(obj, pornResult, source, v, o, true); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} t | |
| * @param {boolean} foo | |
| * @return {undefined} | |
| */ | |
| var oD = function(t, foo) { | |
| if (!t.Ta) { | |
| t.a.setVisible(foo); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var rD = function(a) { | |
| /** @type {!Array} */ | |
| var newNodeLists = []; | |
| a = a.a.b; | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < a.length; i++) { | |
| newNodeLists.push([a[i].ab(), a[i].Cb()]); | |
| } | |
| return newNodeLists; | |
| }; | |
| /** | |
| * @param {!Object} test | |
| * @return {?} | |
| */ | |
| var sD = function(test) { | |
| return test.a.g ? test.a.g.ab() : ""; | |
| }; | |
| /** | |
| * @param {string} value | |
| * @return {?} | |
| */ | |
| var tD = function(value) { | |
| value = value.a.c ? value.a.c.xe.a : ""; | |
| return "" != value ? [value] : []; | |
| }; | |
| /** | |
| * @param {!Object} config | |
| * @param {boolean} id | |
| * @return {undefined} | |
| */ | |
| var DD = function(config, id) { | |
| var data = config.F; | |
| var d = rD(config); | |
| var root_child0_child1 = sD(config); | |
| N(data, fm(data, id ? 141 : 203, d, root_child0_child1, tD(config), [], null != config.a.h, 0)); | |
| }; | |
| /** | |
| * @param {!Object} query | |
| * @param {?} geocode | |
| * @return {undefined} | |
| */ | |
| var mD = function(query, geocode) { | |
| if (query.C) { | |
| if (geocode) { | |
| var file = query.o.aa(); | |
| if (vc(geocode.ab(), file)) { | |
| query.C.b(geocode.ab()); | |
| } else { | |
| query.C.b(file); | |
| } | |
| } else { | |
| query.C.b(""); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} context | |
| * @return {undefined} | |
| */ | |
| var ID = function(context) { | |
| A(context.a.b, function(new_msg1) { | |
| if (new_msg1.ac) { | |
| I(new_msg1.ac, "action", this.Vb, false, this); | |
| } | |
| }, context); | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| kD.prototype.Vb = function(type) { | |
| var y = this.a.b; | |
| A(y, function(data, canCreateDiscussions) { | |
| if (data.ac == type.target) { | |
| var offset = G("SPAN", null, (window.MSG_SUGGESTION_FLAGGED || "").replace("%1$s", data.ab())); | |
| var isPCM = G("SPAN", null, " "); | |
| data = G("A", { | |
| href : "javascript:;" | |
| }, window.MSG_DISMISS || ""); | |
| offset = G("DIV", null, offset, isPCM, data); | |
| jD(this.W, offset); | |
| this.W.setVisible(true); | |
| I(data, "click", this.Gb, false, this); | |
| KD(this, canCreateDiscussions + 1, y); | |
| } | |
| }, this); | |
| }; | |
| /** | |
| * @param {!Object} context | |
| * @return {undefined} | |
| */ | |
| var JD = function(context) { | |
| A(context.a.b, function(new_msg1) { | |
| if (new_msg1.zc) { | |
| I(new_msg1.zc, "action", this.jb, false, this); | |
| } | |
| }, context); | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| kD.prototype.jb = function(type) { | |
| A(this.a.b, function(state) { | |
| if (state.zc == type.target) { | |
| wD(this, state.ab(), "a"); | |
| } | |
| }, this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| kD.prototype.Gb = function() { | |
| this.W.setVisible(false); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| kD.prototype.Hb = function() { | |
| if (this.a) { | |
| if (this.Dd) { | |
| xD(this); | |
| /** @type {boolean} */ | |
| this.oa = false; | |
| } else { | |
| oD(this, false); | |
| } | |
| } | |
| if (this.C) { | |
| this.C.b(""); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| kD.prototype.ic = function() { | |
| /** @type {boolean} */ | |
| this.oa = true; | |
| }; | |
| /** | |
| * @param {!Object} opts | |
| * @param {string} value | |
| * @param {!Object} code | |
| * @return {undefined} | |
| */ | |
| var KD = function(opts, value, code) { | |
| code = mb(code, function(state) { | |
| return state.ab(); | |
| }); | |
| mm(opts.G, opts.w, "is", "3", { | |
| q : opts.h, | |
| sl : opts.b, | |
| tl : opts.c, | |
| sn : code.length, | |
| s : code, | |
| si : value | |
| }); | |
| }; | |
| /** | |
| * @param {!Object} d | |
| * @return {?} | |
| */ | |
| var qD = function(d) { | |
| return d ? mb(d, function(data) { | |
| return data ? data.ab() : ""; | |
| }) : []; | |
| }; | |
| /** | |
| * @param {!Array} x | |
| * @return {?} | |
| */ | |
| var LD = function(x) { | |
| if (!x) { | |
| return []; | |
| } | |
| x = mb(x, function(enable_keys) { | |
| return enable_keys ? enable_keys.Cb() : ""; | |
| }); | |
| return lb(x, function(b) { | |
| return null != b; | |
| }); | |
| }; | |
| /** | |
| * @param {!Object} res | |
| * @param {string} obj | |
| * @param {string} type | |
| * @param {!Object} string | |
| * @param {!Object} item | |
| * @param {string} saveIcon | |
| * @return {undefined} | |
| */ | |
| var ED = function(res, obj, type, string, item, saveIcon) { | |
| string = qD(string); | |
| obj = { | |
| q : type, | |
| sl : res.b, | |
| tl : res.c, | |
| sd : obj, | |
| sn : string.length, | |
| s : string | |
| }; | |
| var p; | |
| for (p in item) { | |
| obj[p] = item[p]; | |
| } | |
| mm(res.G, res.w, "is", saveIcon ? "1" : "7", obj); | |
| }; | |
| /** | |
| * @param {!Object} opts | |
| * @return {undefined} | |
| */ | |
| var AD = function(opts) { | |
| var str = opts.g.a; | |
| var s = qD(str); | |
| str = LD(str); | |
| mm(opts.G, opts.w, "is", "6", { | |
| q : opts.h, | |
| sl : opts.b, | |
| tl : opts.c, | |
| sn : s.length, | |
| s : s, | |
| tn : str.length, | |
| st : str | |
| }); | |
| }; | |
| /** | |
| * @param {!Object} res | |
| * @param {(Object|string)} params | |
| * @param {!Object} options | |
| * @param {!Node} constructor | |
| * @return {undefined} | |
| */ | |
| var zD = function(res, params, options, constructor) { | |
| params = { | |
| q : params, | |
| sl : res.b, | |
| tl : res.c, | |
| sn : options.length, | |
| s : options | |
| }; | |
| if (constructor) { | |
| /** @type {!Node} */ | |
| params.ec = constructor; | |
| } | |
| mm(res.G, res.w, "is", "9", params); | |
| }; | |
| /** | |
| * @param {string} name | |
| * @param {?} opts | |
| * @param {?} w | |
| * @param {number} data | |
| * @return {undefined} | |
| */ | |
| var MD = function(name, opts, w, data) { | |
| var string = Qs(); | |
| /** @type {string} */ | |
| this.g = name; | |
| this.C = opts; | |
| this.R = w; | |
| /** @type {number} */ | |
| this.w = data; | |
| this.G = void 0 === string ? false : string; | |
| /** @type {string} */ | |
| this.a = ""; | |
| this.b = new Dr(this.K, 300, this); | |
| /** @type {number} */ | |
| this.c = this.h = 0; | |
| /** @type {boolean} */ | |
| this.m = false; | |
| this.o = hm.N(); | |
| I(this.g, "change", this.L, false, this); | |
| this.b.start(void 0); | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| MD.prototype.L = function(type) { | |
| /** @type {string} */ | |
| var id = ""; | |
| if (type.fe) { | |
| id = type.fe; | |
| } | |
| if ("paste" == id) { | |
| this.h++; | |
| pm(this.o, "pc", 1, "accumulate"); | |
| } | |
| if ("set" == id) { | |
| this.c++; | |
| } | |
| this.b.start(void 0); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| MD.prototype.K = function() { | |
| if (this.C) { | |
| this.b.stop(); | |
| var m = zc(this.g.aa()); | |
| if (m != this.a) { | |
| if (this.w && this.w()) { | |
| this.b.start(300); | |
| } else { | |
| if (!(2E3 < de(m).length && 0 == this.h && 0 == this.c) || this.G) { | |
| /** @type {number} */ | |
| this.c = this.h = 0; | |
| /** @type {boolean} */ | |
| var val = m.substring(0, this.a.length) == this.a; | |
| if ((m = this.a.substring(0, m.length) == m) || 0 != this.a.length && val && !this.m) { | |
| pm(this.o, "otf", "2"); | |
| } else { | |
| pm(this.o, "otf", "1"); | |
| } | |
| /** @type {boolean} */ | |
| this.m = m; | |
| this.R(); | |
| } | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| MD.prototype.reset = function(name) { | |
| this.b.stop(); | |
| this.a = zc(this.g.aa()); | |
| if (!name) { | |
| /** @type {boolean} */ | |
| this.m = false; | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var ND = function() { | |
| L.call(this); | |
| /** @type {number} */ | |
| this.a = 0; | |
| /** @type {null} */ | |
| this.endTime = this.startTime = null; | |
| }; | |
| x(ND, L); | |
| /** | |
| * @return {undefined} | |
| */ | |
| ND.prototype.c = function() { | |
| this.b("begin"); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| ND.prototype.g = function() { | |
| this.b("end"); | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| ND.prototype.b = function(type) { | |
| this.dispatchEvent(type); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Array} c | |
| * @return {undefined} | |
| */ | |
| var OD = function(a, c) { | |
| if (!Ka(c)) { | |
| /** @type {!Array} */ | |
| c = [c]; | |
| } | |
| z(0 < c.length, "At least one Css3Property should be specified."); | |
| c = mb(c, function(res) { | |
| if (r(res)) { | |
| return res; | |
| } | |
| db(res, "Expected css3 property to be an object."); | |
| /** @type {string} */ | |
| var seconds = res.Kj + " " + res.duration + "s " + res.timing + " " + res.delay + "s"; | |
| z(res.Kj && Aa(res.duration) && res.timing && Aa(res.delay), "Unexpected css3 property value: %s", seconds); | |
| return seconds; | |
| }); | |
| Hp(a, "transition", c.join(",")); | |
| }; | |
| var PD = Lb(function() { | |
| if (C.V) { | |
| return C.Ea("10.0"); | |
| } | |
| var element = zf("DIV"); | |
| /** @type {(null|string)} */ | |
| var name = C.Ka ? "-webkit" : C.Ja ? "-moz" : C.V ? "-ms" : C.cb ? "-o" : null; | |
| var style = { | |
| transition : "opacity 1s linear" | |
| }; | |
| if (name) { | |
| /** @type {string} */ | |
| style[name + "-transition"] = "opacity 1s linear"; | |
| } | |
| Wd(element, Ld("div", { | |
| style : style | |
| })); | |
| element = element.firstChild; | |
| z(element.nodeType == Node.ELEMENT_NODE); | |
| name = element.style[pe("transition")]; | |
| return "" != ("undefined" !== typeof name ? name : element.style[Gp(element, "transition")] || ""); | |
| }); | |
| /** | |
| * @param {number} value | |
| * @param {!Array} meta | |
| * @param {number} w | |
| * @param {number} h | |
| * @param {!Object} media | |
| * @return {undefined} | |
| */ | |
| var QD = function(value, meta, w, h, media) { | |
| ND.call(this); | |
| /** @type {number} */ | |
| this.v = value; | |
| /** @type {!Array} */ | |
| this.m = meta; | |
| /** @type {number} */ | |
| this.w = w; | |
| /** @type {number} */ | |
| this.h = h; | |
| this.G = Ka(media) ? media : [media]; | |
| }; | |
| x(QD, ND); | |
| k = QD.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| k.play = function() { | |
| if (1 == this.a) { | |
| return false; | |
| } | |
| this.c(); | |
| this.b("play"); | |
| this.startTime = Ua(); | |
| /** @type {number} */ | |
| this.a = 1; | |
| if (PD()) { | |
| return Hp(this.v, this.w), this.o = ci(this.Do, void 0, this), true; | |
| } | |
| this.lh(false); | |
| return false; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.Do = function() { | |
| aq(this.v); | |
| OD(this.v, this.G); | |
| Hp(this.v, this.h); | |
| this.o = ci(v(this.lh, this, false), 1E3 * this.m); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.stop = function() { | |
| if (1 == this.a) { | |
| this.lh(true); | |
| } | |
| }; | |
| /** | |
| * @param {boolean} px | |
| * @return {undefined} | |
| */ | |
| k.lh = function(px) { | |
| Hp(this.v, "transition", ""); | |
| di(this.o); | |
| Hp(this.v, this.h); | |
| this.endTime = Ua(); | |
| /** @type {number} */ | |
| this.a = 0; | |
| if (px) { | |
| this.b("stop"); | |
| } else { | |
| this.b("finish"); | |
| } | |
| this.g(); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.X = function() { | |
| this.stop(); | |
| QD.D.X.call(this); | |
| }; | |
| /** | |
| * @param {string} val | |
| * @param {string} model | |
| * @return {undefined} | |
| */ | |
| var SD = function(val, model) { | |
| L.call(this); | |
| this.c = new rq(this); | |
| val = val || null; | |
| RD(this); | |
| /** @type {string} */ | |
| this.v = val; | |
| if (model) { | |
| /** @type {string} */ | |
| this.oe = model; | |
| } | |
| }; | |
| x(SD, L); | |
| k = SD.prototype; | |
| /** @type {null} */ | |
| k.v = null; | |
| /** @type {boolean} */ | |
| k.Ki = true; | |
| /** @type {null} */ | |
| k.Ji = null; | |
| /** @type {boolean} */ | |
| k.re = false; | |
| /** @type {number} */ | |
| k.Gh = -1; | |
| /** @type {string} */ | |
| k.oe = "toggle_display"; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Tb = function() { | |
| return this.oe; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.j = function() { | |
| return this.v; | |
| }; | |
| /** | |
| * @param {boolean} autoHide | |
| * @return {undefined} | |
| */ | |
| k.setAutoHide = function(autoHide) { | |
| RD(this); | |
| /** @type {boolean} */ | |
| this.Ki = autoHide; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| var RD = function(a) { | |
| if (a.re) { | |
| throw Error("Can not change this state of the popup while showing."); | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| SD.prototype.isVisible = function() { | |
| return this.re; | |
| }; | |
| /** | |
| * @param {!Object} x | |
| * @return {undefined} | |
| */ | |
| SD.prototype.setVisible = function(x) { | |
| if (this.o) { | |
| this.o.stop(); | |
| } | |
| if (this.h) { | |
| this.h.stop(); | |
| } | |
| if (x) { | |
| if (!this.re && this.dispatchEvent("beforeshow")) { | |
| if (!this.v) { | |
| throw Error("Caller must call setElement before trying to show the popup"); | |
| } | |
| this.m(); | |
| x = hf(this.v); | |
| if (this.Ki) { | |
| if (this.c.M(x, "mousedown", this.Hj, true), C.V) { | |
| try { | |
| var node = x.activeElement; | |
| } catch (d) { | |
| } | |
| for (; node && "IFRAME" == node.nodeName;) { | |
| try { | |
| var pos = Uf(node); | |
| } catch (d) { | |
| break; | |
| } | |
| x = pos; | |
| node = x.activeElement; | |
| } | |
| this.c.M(x, "mousedown", this.Hj, true); | |
| this.c.M(x, "deactivate", this.Gj); | |
| } else { | |
| this.c.M(x, "blur", this.Gj); | |
| } | |
| } | |
| if ("toggle_display" == this.oe) { | |
| /** @type {string} */ | |
| this.v.style.visibility = "visible"; | |
| X(this.v, true); | |
| } else { | |
| if ("move_offscreen" == this.oe) { | |
| this.m(); | |
| } | |
| } | |
| /** @type {boolean} */ | |
| this.re = true; | |
| this.Gh = Ua(); | |
| if (this.o) { | |
| Hg(this.o, "end", this.fj, false, this); | |
| this.o.play(); | |
| } else { | |
| this.fj(); | |
| } | |
| } | |
| } else { | |
| TD(this); | |
| } | |
| }; | |
| /** @type {function(): undefined} */ | |
| SD.prototype.m = Ha; | |
| /** | |
| * @param {!Object} el | |
| * @param {!Object} x | |
| * @return {undefined} | |
| */ | |
| var TD = function(el, x) { | |
| if (el.re && el.dispatchEvent({ | |
| type : "beforehide", | |
| target : x | |
| })) { | |
| if (el.c) { | |
| wq(el.c); | |
| } | |
| /** @type {boolean} */ | |
| el.re = false; | |
| Ua(); | |
| if (el.h) { | |
| Hg(el.h, "end", Ta(el.Ri, x), false, el); | |
| el.h.play(); | |
| } else { | |
| el.Ri(x); | |
| } | |
| } | |
| }; | |
| k = SD.prototype; | |
| /** | |
| * @param {!Object} url | |
| * @return {undefined} | |
| */ | |
| k.Ri = function(url) { | |
| if ("toggle_display" == this.oe) { | |
| this.jn(); | |
| } else { | |
| if ("move_offscreen" == this.oe) { | |
| /** @type {string} */ | |
| this.v.style.top = "-10000px"; | |
| } | |
| } | |
| this.dispatchEvent({ | |
| type : "hide", | |
| target : url | |
| }); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.jn = function() { | |
| /** @type {string} */ | |
| this.v.style.visibility = "hidden"; | |
| X(this.v, false); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.fj = function() { | |
| this.dispatchEvent("show"); | |
| }; | |
| /** | |
| * @param {!Object} v | |
| * @return {undefined} | |
| */ | |
| k.Hj = function(v) { | |
| v = v.target; | |
| if (!(Pf(this.v, v) || UD(this, v) || 150 > Ua() - this.Gh)) { | |
| TD(this, v); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @return {undefined} | |
| */ | |
| k.Gj = function(item) { | |
| var element = hf(this.v); | |
| if ("undefined" != typeof document.activeElement) { | |
| if (item = element.activeElement, !item || Pf(this.v, item) || "BODY" == item.tagName) { | |
| return; | |
| } | |
| } else { | |
| if (item.target != element) { | |
| return; | |
| } | |
| } | |
| if (!(150 > Ua() - this.Gh)) { | |
| TD(this); | |
| } | |
| }; | |
| /** | |
| * @param {?} cond | |
| * @param {!Function} body | |
| * @return {?} | |
| */ | |
| var UD = function(cond, body) { | |
| return ob(cond.Ji || [], function(target) { | |
| return body === target || Pf(target, body); | |
| }); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| SD.prototype.X = function() { | |
| SD.D.X.call(this); | |
| this.c.Qa(); | |
| ig(this.o); | |
| ig(this.h); | |
| delete this.v; | |
| delete this.c; | |
| delete this.Ji; | |
| }; | |
| /** | |
| * @param {?} usernames | |
| * @param {string} medias | |
| * @return {undefined} | |
| */ | |
| var VD = function(usernames, medias) { | |
| this.L = medias || void 0; | |
| SD.call(this, usernames); | |
| }; | |
| x(VD, SD); | |
| /** | |
| * @return {undefined} | |
| */ | |
| VD.prototype.m = function() { | |
| if (this.L) { | |
| /** @type {boolean} */ | |
| var a = !this.isVisible() && "move_offscreen" != this.Tb(); | |
| var k = this.j(); | |
| if (a) { | |
| /** @type {string} */ | |
| k.style.visibility = "hidden"; | |
| X(k, true); | |
| } | |
| this.L.c(k, 8, this.Bj); | |
| if (a) { | |
| X(k, false); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {?} f | |
| * @param {string} g | |
| * @return {undefined} | |
| */ | |
| var WD = function(f, g) { | |
| VD.call(this, f); | |
| /** @type {string} */ | |
| this.g = g; | |
| /** @type {number} */ | |
| this.a = 0; | |
| /** @type {null} */ | |
| this.b = null; | |
| /** @type {number} */ | |
| this.w = 0; | |
| this.setVisible(true); | |
| this.setVisible(false); | |
| T(this.j(), "round-trip-popup"); | |
| T(this.g, "round-trip-content"); | |
| }; | |
| x(WD, VD); | |
| /** | |
| * @return {undefined} | |
| */ | |
| WD.prototype.K = function() { | |
| di(this.w); | |
| if (1 == this.a) { | |
| Hg(this.b, "finish", v(this.K, this)); | |
| } else { | |
| if (0 == this.a) { | |
| this.w = ci(v(this.C, this, -1), 200); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {number} name | |
| * @return {undefined} | |
| */ | |
| WD.prototype.C = function(name) { | |
| if (this.a != name && (0 != this.a || !(this.isVisible() && 1 == name || !this.isVisible() && -1 == name))) { | |
| var value = this.isVisible(); | |
| this.setVisible(true); | |
| /** @type {number} */ | |
| var x = -Math.ceil(aq(this.g).width); | |
| if (gq(this.j())) { | |
| /** @type {number} */ | |
| x = -x; | |
| } | |
| /** @type {number} */ | |
| var y = 1 == name ? x : 0; | |
| /** @type {number} */ | |
| x = 1 == name ? 0 : x; | |
| this.setVisible(value); | |
| if (PD()) { | |
| /** @type {number} */ | |
| value = .2; | |
| if (0 != this.a) { | |
| /** @type {number} */ | |
| var j = parseInt(Jp(this.g, "left"), 10); | |
| this.G(); | |
| /** @type {number} */ | |
| value = value * ((x - j) / (x - y)); | |
| /** @type {number} */ | |
| y = j; | |
| } | |
| /** @type {number} */ | |
| this.a = name; | |
| this.b = new QD(this.g, value, { | |
| left : y + "px" | |
| }, { | |
| left : x + "px" | |
| }, "left " + value + "s"); | |
| this.b.play(); | |
| Hg(this.b, "finish", v(this.G, this)); | |
| if (-1 == name) { | |
| Hg(this.b, "finish", v(this.setVisible, this, false)); | |
| } else { | |
| this.setVisible(true); | |
| } | |
| } else { | |
| Hp(this.g, "left", x + "px"); | |
| this.setVisible(1 == name ? true : false); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| WD.prototype.G = function() { | |
| if (0 != this.a) { | |
| this.b.stop(); | |
| ci(v(Qg, this, this.b)); | |
| /** @type {number} */ | |
| this.a = 0; | |
| /** @type {null} */ | |
| this.b = null; | |
| } | |
| }; | |
| /** | |
| * @param {string} v | |
| * @return {undefined} | |
| */ | |
| var YD = function(v) { | |
| this.v = v || null; | |
| this.a = G("DIV", "gt-hl-layer", Af("")); | |
| /** @type {null} */ | |
| this.b = null; | |
| if (this.v) { | |
| Gf(this.a, this.v); | |
| XD(this); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} instance | |
| * @param {number} i | |
| * @param {number} j | |
| * @param {string} color | |
| * @param {number} id | |
| * @return {undefined} | |
| */ | |
| var $D = function(instance, i, j, color, id) { | |
| var c = color || "gt-hl-text"; | |
| color = instance.v && (instance.v.value || ag(instance.v)); | |
| XD(instance); | |
| Ff(instance.a); | |
| if (i != j || id) { | |
| if (0 < i) { | |
| var v = color.substring(0, i); | |
| ZD(instance.a, v, 0, id); | |
| } | |
| if (i < j) { | |
| v = color.substring(i, j); | |
| c = G("SPAN", c); | |
| ZD(c, v, i, id); | |
| Df(instance.a, c); | |
| } | |
| if (j < color.length) { | |
| v = color.substring(j); | |
| ZD(instance.a, v, j, id); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @return {undefined} | |
| */ | |
| var XD = function(o) { | |
| var e; | |
| var b = o.v; | |
| var a = hf(b); | |
| if ((e = C.V && b.currentStyle) && rf(jf(a).a) && "auto" != e.width && "auto" != e.height && !e.boxSizing) { | |
| a = kq(b, e.width, "width", "pixelWidth"); | |
| b = kq(b, e.height, "height", "pixelHeight"); | |
| e = new ff(a, b); | |
| } else { | |
| e = new ff(b.offsetWidth, b.offsetHeight); | |
| a = nq(b); | |
| b = Up(b); | |
| e = new ff(e.width - b.left - a.left - a.right - b.right, e.height - b.top - a.top - a.bottom - b.bottom); | |
| } | |
| b = o.a; | |
| a = hf(b); | |
| var val = rf(jf(a).a); | |
| if (!C.V || C.Ea("10") || val && C.Ea("8")) { | |
| jq(b, e, "content-box"); | |
| } else { | |
| a = b.style; | |
| if (val) { | |
| a.pixelWidth = e.width; | |
| a.pixelHeight = e.height; | |
| } else { | |
| val = nq(b); | |
| b = Up(b); | |
| a.pixelWidth = e.width + b.left + val.left + val.right + b.right; | |
| a.pixelHeight = e.height + b.top + val.top + val.bottom + b.bottom; | |
| } | |
| } | |
| a = Sp(o.v); | |
| b = o.a; | |
| e = a.x; | |
| a = a.a; | |
| val = Sp(b); | |
| if (e instanceof cf) { | |
| a = e.a; | |
| e = e.x; | |
| } | |
| /** @type {number} */ | |
| e = ab(e) - val.x; | |
| Np(b, b.offsetLeft + e, b.offsetTop + (Number(a) - val.a)); | |
| b = nq(o.v); | |
| Hp(o.a, "paddingLeft", b.left + "px"); | |
| Hp(o.a, "paddingRight", b.right + "px"); | |
| o.a.dir = o.v.dir; | |
| }; | |
| /** | |
| * @param {!Object} pos | |
| * @param {string} self | |
| * @param {number} start | |
| * @param {number} segments | |
| * @return {undefined} | |
| */ | |
| var ZD = function(pos, self, start, segments) { | |
| segments = segments || []; | |
| /** @type {number} */ | |
| var i = 0; | |
| var last; | |
| for (; last = segments[i]; i++) { | |
| if (!(0 > last.We - start)) { | |
| if (last.We - start >= self.length) { | |
| break; | |
| } | |
| if (0 < last.We - start) { | |
| var verticalrailid = self.substring(0, last.We - start); | |
| aE(pos, verticalrailid); | |
| } | |
| var c = last.className || "gt-hl-text"; | |
| verticalrailid = self.substring(last.We - start, last.Uh - start); | |
| c = G("SPAN", c); | |
| aE(c, verticalrailid); | |
| Df(pos, c); | |
| self = self.substring(last.Uh - start); | |
| start = last.Uh; | |
| } | |
| } | |
| if (self) { | |
| aE(pos, self); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} x | |
| * @param {string} s | |
| * @return {undefined} | |
| */ | |
| var aE = function(x, s) { | |
| s = be(s).split("\n"); | |
| /** @type {number} */ | |
| var j = 0; | |
| var chans = s.length; | |
| for (; j < chans; j++) { | |
| if (0 < j) { | |
| Df(x, G("BR")); | |
| } | |
| Df(x, Af(s[j])); | |
| } | |
| }; | |
| /** | |
| * @param {string} data | |
| * @param {(!Function|RegExp|string)} options | |
| * @return {undefined} | |
| */ | |
| var bE = function(data, options) { | |
| this.a = data instanceof cf ? data : new cf(data, options); | |
| }; | |
| x(bE, Lr); | |
| /** | |
| * @param {!Object} name | |
| * @param {string} value | |
| * @param {string} c | |
| * @param {string} x | |
| * @return {undefined} | |
| */ | |
| bE.prototype.c = function(name, value, c, x) { | |
| z(name); | |
| var a = Pp(hf(name)); | |
| var newX = this.a.x + a.x; | |
| a = this.a.a + a.a; | |
| var data = Hr(name); | |
| /** @type {number} */ | |
| newX = newX - data.x; | |
| /** @type {number} */ | |
| a = a - data.a; | |
| Jr(new cf(newX, a), name, value, c, null, null, x); | |
| }; | |
| /** | |
| * @param {?} type | |
| * @param {?} html | |
| * @return {undefined} | |
| */ | |
| var cE = function(type, html) { | |
| bE.call(this, type, html); | |
| }; | |
| x(cE, bE); | |
| /** @type {number} */ | |
| cE.prototype.g = 0; | |
| /** | |
| * @param {string} name | |
| * @return {undefined} | |
| */ | |
| cE.prototype.b = function(name) { | |
| /** @type {string} */ | |
| this.g = name; | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @param {number} value | |
| * @param {string} c | |
| * @param {string} x | |
| * @return {undefined} | |
| */ | |
| cE.prototype.c = function(name, value, c, x) { | |
| var e = Op(name); | |
| e = Tp(e); | |
| var n = tf(jf(name).a); | |
| n = new cf(this.a.x + n.scrollLeft, this.a.a + n.scrollTop); | |
| /** @type {number} */ | |
| var val = value; | |
| var ret = Jr(n, name, val, c, e, 10, x); | |
| if (0 != (ret & 496)) { | |
| if (ret & 16 || ret & 32) { | |
| /** @type {number} */ | |
| val = val ^ 4; | |
| } | |
| if (ret & 64 || ret & 128) { | |
| /** @type {number} */ | |
| val = val ^ 1; | |
| } | |
| ret = Jr(n, name, val, c, e, 10, x); | |
| if (0 != (ret & 496)) { | |
| Jr(n, name, value, c, e, this.g, x); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {?} x | |
| * @param {?} y | |
| * @return {undefined} | |
| */ | |
| var dE = function(x, y) { | |
| rx.call(this, x, y); | |
| /** @type {boolean} */ | |
| this.O = true; | |
| dx(this, true); | |
| this.setVisible(false, true); | |
| this.b = new Yi; | |
| }; | |
| x(dE, rx); | |
| k = dE.prototype; | |
| /** @type {boolean} */ | |
| k.ek = false; | |
| /** @type {number} */ | |
| k.xj = 0; | |
| /** @type {null} */ | |
| k.Lb = null; | |
| /** | |
| * @param {!Object} element | |
| * @return {undefined} | |
| */ | |
| k.Fa = function(element) { | |
| dE.D.Fa.call(this, element); | |
| if (element = element.getAttribute("for") || element.htmlFor) { | |
| eE(this, this.a.j(element), 1); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.ia = function() { | |
| dE.D.ia.call(this); | |
| this.b.forEach(this.zf, this); | |
| var list = Y(this); | |
| list.M(this, "action", this.Lh); | |
| list.M(this.a.a, "mousedown", this.Ta, true); | |
| }; | |
| /** | |
| * @param {!Object} item | |
| * @param {!Object} obj | |
| * @param {?} value | |
| * @param {number} count | |
| * @param {string} index | |
| * @param {!Object} me | |
| * @return {undefined} | |
| */ | |
| var eE = function(item, obj, value, count, index, me) { | |
| if (!(obj && aj(item.b, Qa(obj)))) { | |
| value = item.Ug(obj, value, count, index, me); | |
| if (item.Ba) { | |
| item.zf(value); | |
| } | |
| obj = Ta(item.uo, obj); | |
| if (item.j()) { | |
| Y(item).M(item.j(), "keydown", obj); | |
| } | |
| } | |
| }; | |
| k = dE.prototype; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Object} v | |
| * @return {undefined} | |
| */ | |
| k.uo = function(a, v) { | |
| if (27 == v.keyCode) { | |
| a.focus(); | |
| } else { | |
| if (a = Jq(this, this.Oa)) { | |
| a = a.j(); | |
| var b = new tg(v.b, a); | |
| /** @type {!Object} */ | |
| b.target = a; | |
| if (32 == v.keyCode || 13 == v.keyCode) { | |
| if (xg(a)) { | |
| qh(a, "keydown", false, b); | |
| } else { | |
| Sg(a, "keydown", false, b); | |
| } | |
| } | |
| if (32 == v.keyCode) { | |
| this.Tc(); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {boolean} a | |
| * @param {!Object} b | |
| * @param {number} info | |
| * @param {string} obj | |
| * @param {!Object} userId | |
| * @return {?} | |
| */ | |
| k.Ug = function(a, b, info, obj, userId) { | |
| if (!a) { | |
| return null; | |
| } | |
| b = { | |
| v : a, | |
| Zj : b, | |
| Pn : info, | |
| Jd : obj ? "contextmenu" : "mousedown", | |
| Bj : userId | |
| }; | |
| this.b.set(Qa(a), b); | |
| return b; | |
| }; | |
| /** | |
| * @param {?} len | |
| * @return {undefined} | |
| */ | |
| k.zf = function(len) { | |
| Y(this).M(len.v, len.Jd, this.xg); | |
| if ("contextmenu" != len.Jd) { | |
| Y(this).M(len.v, "keydown", this.zo); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.Hf = function() { | |
| if (this.Ba) { | |
| var points = this.b.Mb(); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < points.length; i++) { | |
| this.Wg(this.b.get(points[i])); | |
| } | |
| } | |
| this.b.hd(); | |
| }; | |
| /** | |
| * @param {!Object} newPaths | |
| * @return {undefined} | |
| */ | |
| k.Wg = function(newPaths) { | |
| Y(this).Ma(newPaths.v, newPaths.Jd, this.xg); | |
| }; | |
| /** | |
| * @param {!Object} node | |
| * @param {!Object} _ | |
| * @param {string} val | |
| * @return {undefined} | |
| */ | |
| k.fg = function(node, _, val) { | |
| _ = q(node.Zj) ? new wx(node.v, node.Zj, true) : new cE(_, val); | |
| if (_.b) { | |
| _.b(5); | |
| } | |
| var value = node.Pn; | |
| val = node.Bj; | |
| var url = node.v; | |
| node = this.isVisible(); | |
| var b; | |
| if (!(b = this.isVisible())) { | |
| /** @type {boolean} */ | |
| b = 150 > Ua() - this.xj; | |
| } | |
| if (b && this.ek) { | |
| this.Tc(); | |
| } else { | |
| this.Lb = url || null; | |
| if (this.dispatchEvent("beforeshow")) { | |
| value = "undefined" != typeof value ? value : 8; | |
| if (!node) { | |
| /** @type {string} */ | |
| this.j().style.visibility = "hidden"; | |
| } | |
| X(this.j(), true); | |
| _.c(this.j(), value, val); | |
| if (!node) { | |
| /** @type {string} */ | |
| this.j().style.visibility = "visible"; | |
| } | |
| this.Ic(-1); | |
| this.setVisible(true); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.Tc = function() { | |
| if (this.isVisible()) { | |
| this.setVisible(false); | |
| if (!this.isVisible()) { | |
| this.xj = Ua(); | |
| /** @type {null} */ | |
| this.Lb = null; | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.Lh = function() { | |
| this.Tc(); | |
| }; | |
| /** | |
| * @param {!Object} webcal | |
| * @return {undefined} | |
| */ | |
| k.xg = function(webcal) { | |
| fE(this, webcal); | |
| }; | |
| /** | |
| * @param {!Object} event | |
| * @return {undefined} | |
| */ | |
| k.zo = function(event) { | |
| if (!(32 != event.keyCode && 13 != event.keyCode && 40 != event.keyCode)) { | |
| fE(this, event); | |
| } | |
| if (40 == event.keyCode) { | |
| $w(this); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} self | |
| * @param {!Object} event | |
| * @return {undefined} | |
| */ | |
| var fE = function(self, event) { | |
| var statKeys = self.b.Mb(); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < statKeys.length; i++) { | |
| var start = self.b.get(statKeys[i]); | |
| if (start.v == event.a) { | |
| self.fg(start, event.clientX, event.clientY); | |
| event.preventDefault(); | |
| event.stopPropagation(); | |
| break; | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Event} mutationEvent | |
| * @return {undefined} | |
| */ | |
| dE.prototype.Ta = function(mutationEvent) { | |
| if (this.isVisible() && !sx(this, mutationEvent.target)) { | |
| this.Tc(); | |
| } | |
| }; | |
| /** | |
| * @param {?} init | |
| * @return {undefined} | |
| */ | |
| dE.prototype.Xf = function(init) { | |
| dE.D.Xf.call(this, init); | |
| this.Tc(); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| dE.prototype.X = function() { | |
| dE.D.X.call(this); | |
| if (this.b) { | |
| this.b.hd(); | |
| delete this.b; | |
| } | |
| }; | |
| /** | |
| * @param {!Image} context | |
| * @param {string} timing | |
| * @param {number} startOpacity | |
| * @param {number} endOpacity | |
| * @return {?} | |
| */ | |
| var gE = function(context, timing, startOpacity, endOpacity) { | |
| return new QD(context, .218, { | |
| opacity : startOpacity | |
| }, { | |
| opacity : endOpacity | |
| }, { | |
| Kj : "opacity", | |
| duration : .218, | |
| timing : timing, | |
| delay : 0 | |
| }); | |
| }; | |
| /** | |
| * @param {string} c | |
| * @return {undefined} | |
| */ | |
| var hE = function(c) { | |
| L.call(this); | |
| /** @type {string} */ | |
| this.v = c; | |
| /** @type {string} */ | |
| c = C.V ? "focusout" : "blur"; | |
| this.a = I(this.v, C.V ? "focusin" : "focus", this, !C.V); | |
| this.b = I(this.v, c, this, !C.V); | |
| }; | |
| x(hE, L); | |
| /** | |
| * @param {!Object} source | |
| * @return {undefined} | |
| */ | |
| hE.prototype.handleEvent = function(source) { | |
| var evt = new tg(source.b); | |
| /** @type {string} */ | |
| evt.type = "focusin" == source.type || "focus" == source.type ? "focusin" : "focusout"; | |
| this.dispatchEvent(evt); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| hE.prototype.X = function() { | |
| hE.D.X.call(this); | |
| Pg(this.a); | |
| Pg(this.b); | |
| delete this.v; | |
| }; | |
| /** | |
| * @param {string} frustum2DWidth | |
| * @param {?} mode | |
| * @param {?} connectionProvider | |
| * @return {undefined} | |
| */ | |
| var iE = function(frustum2DWidth, mode, connectionProvider) { | |
| dE.call(this, mode, connectionProvider); | |
| this.w = new Yi; | |
| this.g = frustum2DWidth || 5; | |
| /** @type {null} */ | |
| this.C = null; | |
| /** @type {boolean} */ | |
| this.K = false; | |
| /** @type {!Array} */ | |
| this.h = Array(this.g); | |
| /** @type {!Array} */ | |
| this.Y = Array(this.g); | |
| this.W = hm.N(); | |
| this.F = M.N(); | |
| /** @type {null} */ | |
| this.Z = this.m = this.Jc = null; | |
| /** @type {boolean} */ | |
| this.ek = true; | |
| }; | |
| x(iE, dE); | |
| /** @type {string} */ | |
| var jE = ""; | |
| /** | |
| * @return {undefined} | |
| */ | |
| iE.prototype.Ra = function() { | |
| iE.D.Ra.call(this); | |
| /** @type {number} */ | |
| var a = 0; | |
| for (; a < this.g; ++a) { | |
| this.qb(new mx(""), true); | |
| } | |
| if ("" != jE) { | |
| this.m = new mx(jE); | |
| or(this.m, "gt-edit-menuitem"); | |
| this.qb(this.m, true); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| iE.prototype.Za = function(a) { | |
| iE.D.Za.call(this, a); | |
| T(this.j(), "alt-menu"); | |
| }; | |
| /** | |
| * @param {string} i | |
| * @return {undefined} | |
| */ | |
| iE.prototype.Rh = function(i) { | |
| i = this.w.get(Qa(i)); | |
| /** @type {number} */ | |
| var start = 0; | |
| for (; start < J(i, 2) && start < this.g; ++start) { | |
| var node = Jq(this, start); | |
| node.g(K(ko(i, start), 0)); | |
| /** @type {number} */ | |
| node.oa = start; | |
| node.setVisible(true, true); | |
| } | |
| for (; start < this.g; ++start) { | |
| Jq(this, start).setVisible(false); | |
| } | |
| if (this.m) { | |
| this.m.setVisible(true, true); | |
| } | |
| }; | |
| /** | |
| * @param {!Window} f | |
| * @param {!Object} o | |
| * @param {!Object} i | |
| * @return {undefined} | |
| */ | |
| var kE = function(f, o, i) { | |
| f.w.set(Qa(o), i); | |
| eE(f, o, 9, 8, false, new Dp(-2, 1, -2, 1)); | |
| }; | |
| k = iE.prototype; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.Hf = function() { | |
| iE.D.Hf.call(this); | |
| if (null != this.Jc) { | |
| this.Jc.b(); | |
| } | |
| this.w.hd(); | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {?} b | |
| * @return {?} | |
| */ | |
| k.setVisible = function(a, b) { | |
| var other = this.Lb; | |
| this.Z = other; | |
| if (a && null != other) { | |
| lE(this, other); | |
| qm(this.W, "altshow"); | |
| var b = this.F; | |
| N(b, O(b, 207)); | |
| } else { | |
| if (null != this.C) { | |
| $D(this.C, 0, 0); | |
| } | |
| } | |
| if (null != other) { | |
| if (a) { | |
| this.Vg(other); | |
| } else { | |
| this.Sg(other); | |
| } | |
| } | |
| b = iE.D.setVisible.call(this, a, b); | |
| if (a && null != this.j()) { | |
| iq(this.j(), false); | |
| } | |
| return b; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Bb = function() { | |
| if (null != this.Z) { | |
| var a = ag(this.Z); | |
| if (null != a) { | |
| return a; | |
| } | |
| } | |
| return ""; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.Tc = function() { | |
| iE.D.Tc.call(this); | |
| if (this.K) { | |
| /** @type {number} */ | |
| var id = 0; | |
| for (; id < this.h.length; id++) { | |
| var m = this.h[id]; | |
| di(m.w); | |
| m.G(); | |
| m.C(-1); | |
| m.G(); | |
| m.setVisible(false); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} t | |
| * @return {undefined} | |
| */ | |
| k.Vg = function(t) { | |
| T(t, "trans-target"); | |
| if (null === this.Jc) { | |
| /** @type {string} */ | |
| t.title = ""; | |
| } else { | |
| this.Jc.b(t); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} s | |
| * @return {undefined} | |
| */ | |
| k.Sg = function(s) { | |
| U(s, "trans-target"); | |
| if (null === this.Jc) { | |
| /** @type {string} */ | |
| s.title = ""; | |
| } else { | |
| this.Jc.a(s); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} event | |
| * @return {?} | |
| */ | |
| k.ib = function(event) { | |
| if (event.shiftKey || event.ctrlKey || event.altKey || 36 == event.keyCode || 35 == event.keyCode) { | |
| return false; | |
| } | |
| var continueOn = iE.D.ib.call(this, event); | |
| if (!continueOn && (37 == event.keyCode || 39 == event.keyCode)) { | |
| var parent = gq(this.Lb.parentNode.parentNode); | |
| /** @type {null} */ | |
| var type = null; | |
| if (!parent && 37 == event.keyCode || parent && 39 == event.keyCode) { | |
| /** @type {boolean} */ | |
| type = false; | |
| } | |
| if (!parent && 39 == event.keyCode || parent && 37 == event.keyCode) { | |
| /** @type {boolean} */ | |
| type = true; | |
| } | |
| if (this.Ng(type) && (parent = this.Lb, (parent = type ? q(parent.nextElementSibling) ? parent.nextElementSibling : Lf(parent.nextSibling, true) : q(parent.previousElementSibling) ? parent.previousElementSibling : Lf(parent.previousSibling, false)) && parent != this.Lb)) { | |
| return this.Tc(), this.Qj(type), this.fg(parent ? this.b.get(Qa(parent)) : null, 0, 0), mE(this), event.preventDefault(), event.stopPropagation(), true; | |
| } | |
| } | |
| return continueOn; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {number} fn | |
| * @param {number} rev | |
| * @return {undefined} | |
| */ | |
| k.fg = function(a, fn, rev) { | |
| if (gq((a.v || this.Lb).parentNode.parentNode)) { | |
| Hp(this.j(), "direction", "rtl"); | |
| } else { | |
| Hp(this.j(), "direction", ""); | |
| } | |
| if (this.K) { | |
| /** @type {number} */ | |
| var id = 0; | |
| for (; id < this.h.length; id++) { | |
| nE(this, id); | |
| H(this.h[id].g, "..."); | |
| } | |
| } | |
| this.Rh(a.v); | |
| iE.D.fg.call(this, a, fn, rev); | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @param {?} i | |
| * @param {string} c | |
| * @return {undefined} | |
| */ | |
| var oE = function(o, i, c) { | |
| if (!(!o.K || i >= o.g || "" == c)) { | |
| H(o.h[i].g, c); | |
| nE(o, i); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} size | |
| * @param {?} i | |
| * @return {undefined} | |
| */ | |
| var nE = function(size, i) { | |
| Kr(Jq(size, i).j(), 12, size.h[i].j(), 8, new cf(1, 0)); | |
| }; | |
| k = iE.prototype; | |
| /** | |
| * @param {string} key | |
| * @return {undefined} | |
| */ | |
| k.cf = function(key) { | |
| iE.D.cf.call(this, key); | |
| var value = this.Lb; | |
| if (null != value) { | |
| qm(this.W, "altmenuhl"); | |
| var b = this.F; | |
| N(b, O(b, 209)); | |
| lE(this, value); | |
| key = this.Of(key.target); | |
| if (-1 != key && key != this.g) { | |
| di(this.Y[key]); | |
| this.Y[key] = ci(this.Ln, 300, this); | |
| if (this.K) { | |
| value = this.h[key]; | |
| if (gq(this.Lb.parentNode.parentNode)) { | |
| T(value.j(), "rtl"); | |
| Hp(value.j(), "direction", "rtl"); | |
| } else { | |
| U(value.j(), "rtl"); | |
| Hp(value.j(), "direction", ""); | |
| } | |
| nE(this, key); | |
| di(value.w); | |
| if (0 == value.a) { | |
| value.w = ci(v(value.C, value, 1), 300); | |
| } else { | |
| value.C(1); | |
| } | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.Ln = function() { | |
| qm(this.W, "altmenuhold"); | |
| var b = this.F; | |
| N(b, O(b, 208)); | |
| }; | |
| /** | |
| * @param {string} key | |
| * @return {undefined} | |
| */ | |
| k.mh = function(key) { | |
| iE.D.mh.call(this, key); | |
| key = this.Of(key.target); | |
| if (-1 != key && key != this.g) { | |
| di(this.Y[key]); | |
| if (this.K) { | |
| this.h[key].K(); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} T | |
| * @return {?} | |
| */ | |
| k.Of = function(T) { | |
| return Lq(this, T); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Ng = function() { | |
| return true; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.Qj = function() { | |
| }; | |
| /** | |
| * @param {!Object} result | |
| * @param {?} reference | |
| * @param {number} arr | |
| * @param {string} params | |
| * @param {!Object} scope | |
| * @return {?} | |
| */ | |
| k.Ug = function(result, reference, arr, params, scope) { | |
| if ((result = iE.D.Ug.call(this, result, reference, arr, params, scope)) && "mousedown" == result.Jd) { | |
| /** @type {string} */ | |
| result.Jd = "click"; | |
| } | |
| return result; | |
| }; | |
| /** | |
| * @param {?} len | |
| * @return {undefined} | |
| */ | |
| k.zf = function(len) { | |
| iE.D.zf.call(this, len); | |
| Y(this).M(len.v, "mouseover", this.Da); | |
| Y(this).M(len.v, "mouseout", this.T); | |
| Y(this).M(len.v, "contextmenu", this.ra); | |
| Y(this).M(len.v, "mousemove", this.Aa); | |
| }; | |
| /** | |
| * @param {!Object} varValue | |
| * @return {undefined} | |
| */ | |
| k.Wg = function(varValue) { | |
| iE.D.Wg.call(this, varValue); | |
| Y(this).Ma(varValue.v, "mouseover", this.Da); | |
| Y(this).Ma(varValue.v, "mouseout", this.T); | |
| Y(this).Ma(varValue.v, "contextmenu", this.ra); | |
| Y(this).Ma(varValue.v, "mousemove", this.Aa); | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @param {string} c | |
| * @return {undefined} | |
| */ | |
| var lE = function(e, c) { | |
| if (null != e.C && (c = e.w.get(Qa(c))) && (e = e.C, e.b)) { | |
| var node = e.v && (e.v.value || ag(e.v)); | |
| /** @type {number} */ | |
| var i = -1; | |
| /** @type {number} */ | |
| var index = -1; | |
| /** @type {boolean} */ | |
| var tempMatch = false; | |
| /** @type {number} */ | |
| var A = 0; | |
| for (; A < J(e.b, 5); A++) { | |
| var d = Vo(e.b, A); | |
| if (0 != J(d, 2) && (0 == hh(d, 5) && (tempMatch = node.indexOf(K(d, 4), index + 1), 0 <= tempMatch ? (i = tempMatch, index = i + K(d, 4).length, tempMatch = true) : tempMatch = false), Vo(e.b, A).Jb() == c.Jb())) { | |
| if (tempMatch) { | |
| /** @type {!Array} */ | |
| node = []; | |
| /** @type {number} */ | |
| index = 0; | |
| for (; index < J(c, 3); ++index) { | |
| node.push({ | |
| We : i + hh(lo(c, index), 0), | |
| Uh : i + hh(lo(c, index), 1) | |
| }); | |
| } | |
| $D(e, 0, 0, void 0, node); | |
| } else { | |
| i = node.indexOf(K(c, 0)); | |
| if (0 <= i) { | |
| $D(e, i, i + K(c, 0).length); | |
| } | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} d | |
| * @param {boolean} lazyLayout | |
| * @return {undefined} | |
| */ | |
| var pE = function(d, lazyLayout) { | |
| if (lazyLayout) { | |
| Wi(d.b.xc(false), function(tmpl) { | |
| if ("" == this.a.aj(tmpl.v)) { | |
| T(tmpl.v, "trans-target-empty"); | |
| this.a.Uf(tmpl.v, "_"); | |
| } | |
| return true; | |
| }, d); | |
| } else { | |
| Wi(d.b.xc(false), function(res) { | |
| if (tp(res.v, "trans-target-empty")) { | |
| U(res.v, "trans-target-empty"); | |
| this.a.Uf(res.v, ""); | |
| } | |
| return true; | |
| }, d); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @return {undefined} | |
| */ | |
| iE.prototype.Da = function(data) { | |
| if (!Wz() && this.isEnabled()) { | |
| T(data.target, "trans-target-highlight"); | |
| lE(this, data.target); | |
| pE(this, true); | |
| qm(this.W, "althighlight"); | |
| data = this.F; | |
| N(data, O(data, 206)); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| iE.prototype.T = function(type) { | |
| U(type.target, "trans-target-highlight"); | |
| if (!(null == this.C || this.isVisible())) { | |
| $D(this.C, 0, 0); | |
| } | |
| pE(this, false); | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| iE.prototype.Aa = function(type) { | |
| if (Wz()) { | |
| this.T(type); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| iE.prototype.ra = function(type) { | |
| if (!Wz()) { | |
| this.T(type); | |
| Jz(type.target, void 0).select(); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} d | |
| * @return {undefined} | |
| */ | |
| var mE = function(d) { | |
| Wi(d.b.xc(false), function(res) { | |
| U(res.v, "trans-target-highlight"); | |
| return true; | |
| }, d); | |
| }; | |
| /** | |
| * @param {!Object} c | |
| * @return {undefined} | |
| */ | |
| iE.prototype.Lh = function(c) { | |
| if (c && c.a && c.a.Lb) { | |
| c.h = c.a.Lb; | |
| } | |
| iE.D.Lh.call(this, c); | |
| }; | |
| /** | |
| * @param {?} p1__3354_SHARP_ | |
| * @return {undefined} | |
| */ | |
| iE.prototype.xg = function(p1__3354_SHARP_) { | |
| if (Wz()) { | |
| mE(this); | |
| } else { | |
| if (this.kd) { | |
| iE.D.xg.call(this, p1__3354_SHARP_); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {?} a | |
| * @param {?} b | |
| * @param {?} rev | |
| * @return {undefined} | |
| */ | |
| var qE = function(a, b, rev) { | |
| /** @type {null} */ | |
| this.ma = this.c = null; | |
| iE.call(this, a, b, rev); | |
| }; | |
| x(qE, iE); | |
| k = qE.prototype; | |
| /** | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| k.Qj = function(value) { | |
| /** @type {string} */ | |
| this.c = value; | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {?} b | |
| * @return {?} | |
| */ | |
| k.setVisible = function(a, b) { | |
| b = qE.D.setVisible.call(this, a, b); | |
| /** @type {null} */ | |
| this.c = null; | |
| if (a) { | |
| this.ma = this.Bb(); | |
| } else { | |
| if (null != this.ma && this.ma != this.Bb()) { | |
| this.dispatchEvent(new kg("action", this)); | |
| } | |
| } | |
| return b; | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @return {undefined} | |
| */ | |
| k.Vg = function(value) { | |
| qE.D.Vg.call(this, value); | |
| T(value, "trans-edit"); | |
| /** @type {boolean} */ | |
| value.contentEditable = true; | |
| Xw(this, value); | |
| Uw(this).focus(); | |
| Xf(Uw(this), true); | |
| Y(this).M(value, "keydown", this.jj); | |
| Y(this).M(value, "mouseout", this.hg); | |
| Y(this).M(value, "mouseover", this.hg); | |
| if (null != this.c) { | |
| value = Jz(value, void 0); | |
| var d = this.c ? value.dc() : value.Dc(); | |
| var i = mz(value); | |
| value = i; | |
| var url = d; | |
| var node = new Hz; | |
| node.g = Rz(value, url, i, d); | |
| if (Nf(value) && !Cf(value)) { | |
| var n = value.parentNode; | |
| url = kb(n.childNodes, value); | |
| value = n; | |
| } | |
| if (Nf(i) && !Cf(i)) { | |
| n = i.parentNode; | |
| d = kb(n.childNodes, i); | |
| i = n; | |
| } | |
| if (node.g) { | |
| node.a = i; | |
| node.h = d; | |
| /** @type {!Object} */ | |
| node.b = value; | |
| node.c = url; | |
| } else { | |
| /** @type {!Object} */ | |
| node.a = value; | |
| node.h = url; | |
| node.b = i; | |
| node.c = d; | |
| } | |
| node.select(); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} candidate | |
| * @return {undefined} | |
| */ | |
| k.Sg = function(candidate) { | |
| qE.D.Sg.call(this, candidate); | |
| U(candidate, "trans-edit"); | |
| /** @type {boolean} */ | |
| candidate.contentEditable = false; | |
| if (Uw(this)) { | |
| Xf(Uw(this), false); | |
| } | |
| Y(this).Ma(candidate, "keydown", this.jj); | |
| Y(this).Ma(candidate, "mouseout", this.hg); | |
| Y(this).Ma(candidate, "mouseover", this.hg); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.hg = function() { | |
| var state = Vz(); | |
| if (!(null == state || state.cc() == state.Cc() && state.dc() == state.Dc())) { | |
| this.setVisible(state.cc() == state.Cc()); | |
| } | |
| }; | |
| /** | |
| * @param {!Event} event | |
| * @return {?} | |
| */ | |
| k.jj = function(event) { | |
| /** @type {number} */ | |
| var removeCritText = 0; | |
| for (; removeCritText < this.g; ++removeCritText) { | |
| Jq(this, removeCritText).setVisible(false); | |
| } | |
| if (this.m) { | |
| this.m.setVisible(false); | |
| } | |
| if (13 == event.keyCode || 3 == event.keyCode) { | |
| return null === Zw(this) ? (this.Tc(), event.stopPropagation(), event.preventDefault(), true) : false; | |
| } | |
| if (!(null === Zw(this) || !Wg(event) && 37 != event.keyCode && 39 != event.keyCode)) { | |
| this.Lb.focus(); | |
| this.Ic(Lq(this, null)); | |
| } | |
| return false; | |
| }; | |
| /** | |
| * @param {string} isCellColor | |
| * @return {?} | |
| */ | |
| k.Ng = function(isCellColor) { | |
| var msg = Vz(); | |
| if (msg.cc() == msg.Cc() && msg.dc() == msg.Dc()) { | |
| var color = msg.Dh() ? msg.dc() : msg.Dc(); | |
| msg = Jz(mz(msg), void 0); | |
| if (!isCellColor && color == msg.dc() || isCellColor && color == msg.Dc()) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| }; | |
| /** | |
| * @param {?} tag | |
| * @param {?} attributes | |
| * @param {?} content | |
| * @return {undefined} | |
| */ | |
| var rE = function(tag, attributes, content) { | |
| iE.call(this, tag, attributes, content); | |
| /** @type {null} */ | |
| this.c = null; | |
| }; | |
| x(rE, iE); | |
| k = rE.prototype; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| k.Za = function(a) { | |
| rE.D.Za.call(this, a); | |
| this.c = new sE(""); | |
| this.qb(this.c, true); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| k.Rh = function(a) { | |
| rE.D.Rh.call(this, a); | |
| this.c.j().firstChild.value = this.a.aj(a); | |
| }; | |
| /** | |
| * @param {string} a | |
| * @param {?} b | |
| * @return {?} | |
| */ | |
| k.setVisible = function(a, b) { | |
| b = rE.D.setVisible.call(this, a, b); | |
| if (a && null != this.j() && (Uw(this) == this.c.j().firstChild || Uw(this) == this.c.j().firstChild.nextSibling)) { | |
| ur(this.c, true); | |
| } | |
| return b; | |
| }; | |
| /** | |
| * @param {!Event} e | |
| * @return {undefined} | |
| */ | |
| k.cf = function(e) { | |
| rE.D.cf.call(this, e); | |
| if (e.target == this.c) { | |
| Xw(this, this.c.j().firstChild); | |
| } else { | |
| Xw(this, this.j()); | |
| } | |
| Uw(this).focus(); | |
| /** @type {number} */ | |
| Uw(this).tabIndex = 0; | |
| }; | |
| /** | |
| * @param {string} name | |
| * @return {?} | |
| */ | |
| k.Of = function(name) { | |
| return name == this.c ? -1 : rE.D.Of.call(this, name); | |
| }; | |
| /** | |
| * @param {!Object} event | |
| * @return {?} | |
| */ | |
| k.ib = function(event) { | |
| return 9 == event.keyCode ? (this.c.Ha(2) ? (Uw(this) == this.c.j().firstChild ? Xw(this, this.c.j().firstChild.nextSibling) : Xw(this, this.c.j().firstChild), Uw(this).focus(), Uw(this).tabIndex = 0) : ur(this.c, true), event.preventDefault(), event.stopPropagation(), true) : rE.D.ib.call(this, event); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| k.Ng = function() { | |
| return null === Zw(this) || !(Zw(this) instanceof sE); | |
| }; | |
| /** | |
| * @param {?} path | |
| * @param {?} scope | |
| * @param {?} options | |
| * @return {undefined} | |
| */ | |
| var sE = function(path, scope, options) { | |
| lr.call(this, path, options || tE.N(), scope); | |
| this.Sa(4, false); | |
| }; | |
| x(sE, lr); | |
| /** | |
| * @param {!Object} ast | |
| * @return {undefined} | |
| */ | |
| sE.prototype.Fb = function(ast) { | |
| if (ast.target == this.j().firstChild.nextSibling) { | |
| this.dispatchEvent("action"); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| sE.prototype.ia = function() { | |
| sE.D.ia.call(this); | |
| Y(this).M(this.j().firstChild, "keydown", function(event) { | |
| if (32 == event.keyCode) { | |
| event.stopPropagation(); | |
| } | |
| }); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| sE.prototype.Bb = function() { | |
| return this.j().firstChild.value; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var tE = function() { | |
| }; | |
| x(tE, Uq); | |
| Ia(tE); | |
| /** | |
| * @param {!Object} v | |
| * @return {?} | |
| */ | |
| tE.prototype.Eb = function(v) { | |
| var input = v.a.b("INPUT", { | |
| value : v.Ya(), | |
| id : "alt-input-text", | |
| type : "text" | |
| }); | |
| var tags = v.a.b("INPUT", { | |
| value : "", | |
| id : "alt-input-submit", | |
| "class" : "", | |
| type : "button" | |
| }); | |
| return v.a.b("DIV", { | |
| id : "alt-input" | |
| }, input, tags); | |
| }; | |
| /** | |
| * @param {number} y | |
| * @param {number} radius | |
| * @param {?} shape | |
| * @param {!Object} t | |
| * @param {(Object|string)} o | |
| * @param {number} value | |
| * @return {undefined} | |
| */ | |
| var uE = function(y, radius, shape, t, o, value) { | |
| /** @type {number} */ | |
| this.a = y; | |
| /** @type {number} */ | |
| this.w = radius; | |
| this.C = shape; | |
| /** @type {!Object} */ | |
| this.G = t; | |
| I(this.a.j(), "focus", function() { | |
| T(t, "focus"); | |
| }); | |
| I(this.a.j(), "blur", function() { | |
| U(t, "focus"); | |
| }); | |
| /** @type {number} */ | |
| this.c = value; | |
| if (null != this.c) { | |
| I(this.c, "action", this.K, false, this); | |
| } | |
| /** @type {boolean} */ | |
| this.h = false; | |
| /** @type {null} */ | |
| this.g = null; | |
| /** @type {boolean} */ | |
| this.b = false; | |
| /** @type {null} */ | |
| this.m = null; | |
| /** @type {(Object|string)} */ | |
| this.o = o; | |
| /** @type {boolean} */ | |
| this.L = false; | |
| this.F = M.N(); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| uE.prototype.K = function() { | |
| /** @type {boolean} */ | |
| this.b = false; | |
| this.a.b(""); | |
| this.a.j().focus(); | |
| var b = this.F; | |
| N(b, O(b, 27)); | |
| this.c.setVisible(false); | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @return {undefined} | |
| */ | |
| var vE = function(o) { | |
| /** @type {boolean} */ | |
| o.h = false; | |
| U(o.G, "full-edit"); | |
| X(o.C, true); | |
| X(o.w, false); | |
| X(o.o, o.L); | |
| o.a.setVisible(false); | |
| o.a.ze(false); | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| uE.prototype.R = function(name) { | |
| /** @type {boolean} */ | |
| this.b = false; | |
| if ("" != this.a.aa()) { | |
| this.c.setVisible(true); | |
| if (this.a.aa() != this.m) { | |
| /** @type {boolean} */ | |
| this.b = true; | |
| } | |
| } | |
| name(); | |
| }; | |
| /** | |
| * @param {?} options | |
| * @param {?} params | |
| * @param {?} m | |
| * @param {number} b | |
| * @param {string} variableNames | |
| * @return {undefined} | |
| */ | |
| var wE = function(options, params, m, b, variableNames) { | |
| zq.call(this); | |
| /** @type {number} */ | |
| this.b = b; | |
| hm.N(); | |
| this.c = new is(options); | |
| ks(this.c, 2); | |
| /** @type {null} */ | |
| this.m = null; | |
| this.w = new is(params); | |
| /** @type {null} */ | |
| this.h = null; | |
| this.O = m; | |
| this.K = variableNames || false; | |
| /** @type {null} */ | |
| this.C = this.g = null; | |
| }; | |
| x(wE, zq); | |
| k = wE.prototype; | |
| /** | |
| * @param {boolean} obj | |
| * @return {undefined} | |
| */ | |
| k.sa = function(obj) { | |
| this.c.sa(obj); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.Ra = function() { | |
| wE.D.Ra.call(this); | |
| this.Fa(zf("DIV")); | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @return {undefined} | |
| */ | |
| k.Fa = function(b) { | |
| wE.D.Fa.call(this, b); | |
| if (null != this.b && !this.b.zb) { | |
| this.b.na(b); | |
| } | |
| T(b, "st-wrap"); | |
| b.appendChild(Ap(Kn, { | |
| ho : this.K, | |
| io : this.O | |
| })); | |
| this.g = E("st-stp1", b); | |
| b = kf("st-buttons"); | |
| this.c.Za(b); | |
| this.c.Vd(this); | |
| Y(this).M(this.c, "action", this.qm); | |
| this.w.Za(b); | |
| this.w.Vd(this); | |
| Y(this).M(this.w, "action", this.Bp); | |
| }; | |
| /** | |
| * @param {undefined} a | |
| * @return {undefined} | |
| */ | |
| k.qm = function(a) { | |
| X(this.g, false); | |
| if (null != this.b) { | |
| this.b.setVisible(true); | |
| } | |
| if (null != this.m) { | |
| this.m(a); | |
| } | |
| }; | |
| /** | |
| * @param {undefined} incr | |
| * @return {undefined} | |
| */ | |
| k.Bp = function(incr) { | |
| X(this.g, false); | |
| if (null != this.h) { | |
| this.h(incr); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.reset = function() { | |
| if (this.C) { | |
| di(this.C); | |
| } | |
| /** @type {null} */ | |
| this.C = null; | |
| ks(this.c, 2); | |
| cq(this.j(), 1); | |
| X(this.j(), true); | |
| X(this.g, true); | |
| if (null != this.b) { | |
| this.b.setVisible(false); | |
| } | |
| }; | |
| var xE = C.V || C.Ka || C.cb || C.vb || false; | |
| if (!(C.product.Ge && C.product.ub("4") || C.product.ee && C.Ea("533") || C.Ja && C.Ea("2.0") || C.V && C.Ea("10"))) { | |
| if (C.cb) { | |
| Ad(); | |
| } | |
| } | |
| /** | |
| * @param {!Object} node | |
| * @param {!Object} options | |
| * @param {number} d | |
| * @param {number} weights | |
| * @param {number} i | |
| * @param {string} w | |
| * @param {string} c | |
| * @param {string} g | |
| * @param {string} p | |
| * @return {undefined} | |
| */ | |
| var yE = function(node, options, d, weights, i, w, c, g, p) { | |
| zq.call(this, node); | |
| this.c = c || null; | |
| if (null != this.c) { | |
| node = this.c; | |
| c = v(this.vm, this); | |
| node.g = v(node.R, node, c); | |
| c = node.a.j(); | |
| var result = new Nq(c); | |
| I(result, "key", node.g, false, node); | |
| result = new tv(c); | |
| I(result, "paste", node.g, false, node); | |
| I(c, "keyup", node.g, false, node); | |
| } | |
| /** @type {null} */ | |
| this.h = null; | |
| /** @type {string} */ | |
| this.C = "auto"; | |
| /** @type {string} */ | |
| this.Z = this.m = ""; | |
| this.Da = new Wo("mt"); | |
| this.jb = !!options && xE && !C.V; | |
| this.T = null != i ? i : 0; | |
| /** @type {null} */ | |
| this.b = null; | |
| if (this.jb) { | |
| this.b = new qE; | |
| } else { | |
| this.b = new rE; | |
| } | |
| if (p) { | |
| this.b.sa(false); | |
| } | |
| if (0 < this.T) { | |
| /** @type {null} */ | |
| options = this.b; | |
| /** @type {boolean} */ | |
| options.K = true; | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < options.g; i++) { | |
| node = G("DIV", "goog-menu", ""); | |
| p = G("DIV", null, node); | |
| node = new WD(p, node); | |
| /** @type {!Object} */ | |
| options.h[i] = node; | |
| document.body.appendChild(p); | |
| } | |
| } | |
| this.b.Za(d); | |
| this.g = g || null; | |
| this.ra = null != weights ? weights : -1; | |
| this.O = hm.N(); | |
| this.K = new Yi; | |
| /** @type {string} */ | |
| this.Aa = "t"; | |
| /** @type {null} */ | |
| this.W = this.Y = null; | |
| this.w = w || null; | |
| /** @type {boolean} */ | |
| this.ea = false; | |
| if (null != this.w) { | |
| d = v(this.gb, this); | |
| /** @type {number} */ | |
| this.w.m = d; | |
| d = v(this.pm, this); | |
| /** @type {number} */ | |
| this.w.h = d; | |
| } | |
| /** @type {null} */ | |
| this.ma = null; | |
| this.F = M.N(); | |
| }; | |
| x(yE, zq); | |
| /** | |
| * @param {!Object} o | |
| * @param {number} b | |
| * @param {number} i | |
| * @param {!Object} m | |
| * @param {number} d | |
| * @return {?} | |
| */ | |
| var HE = function(o, b, i, m, d) { | |
| if (null != o.w) { | |
| var c = o.w; | |
| X(c.j(), false); | |
| X(c.g, false); | |
| if (null != c.b) { | |
| c.b.setVisible(false); | |
| } | |
| } | |
| if (b) { | |
| o.h = new Ro(b); | |
| /** @type {null} */ | |
| o.W = null; | |
| } | |
| if (i) { | |
| /** @type {number} */ | |
| o.C = i; | |
| } | |
| if (m) { | |
| /** @type {!Object} */ | |
| o.m = m; | |
| } | |
| if (d) { | |
| /** @type {number} */ | |
| o.Z = d; | |
| } | |
| if (zE(o)) { | |
| vE(o.c); | |
| if (null != o.g) { | |
| o.g.a(false); | |
| } | |
| } | |
| if (o.h) { | |
| /** @type {boolean} */ | |
| b = 0 != nf("alt-edited").length; | |
| o.a.Tf(o.j()); | |
| o.b.Hf(); | |
| if (o.ma) { | |
| o.ma.b = o.h; | |
| } | |
| /** @type {string} */ | |
| m = ""; | |
| /** @type {number} */ | |
| i = d = 0; | |
| for (; i < J(o.h, 5); i++) { | |
| if (AE(o.h, i)) { | |
| /** @type {string} */ | |
| m = m + " "; | |
| } | |
| /** @type {string} */ | |
| m = m + BE(o.h, i); | |
| d = d + J(Vo(o.h, i), 2); | |
| } | |
| if (0 == d) { | |
| return false; | |
| } | |
| /** @type {!Array} */ | |
| m = []; | |
| /** @type {boolean} */ | |
| d = false; | |
| Hu(o.h); | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < J(o.h, 5); i++) { | |
| c = Vo(o.h, i); | |
| var a = ko(c, 0); | |
| if (AE(o.h, i)) { | |
| o.a.appendChild(o.j(), o.a.a.createTextNode(" ")); | |
| } else { | |
| if ("km" == o.m || "lo" == o.m) { | |
| o.a.appendChild(o.j(), C.Ka ? Bf(document, Ld("WBR")) : C.cb ? Af("­") : C.V ? Af("​") : Bf(document, Ld("WBR"))); | |
| } | |
| } | |
| if (dh(c, 4) && 0 < K(c, 4).length && 0 == hh(c, 5)) { | |
| m.push(K(c, 4)); | |
| } | |
| var e; | |
| var v = BE(o.h, i); | |
| if (xc(v)) { | |
| if (!(0 == v.length)) { | |
| e = CE(v); | |
| } | |
| } else { | |
| e = o.a.b("SPAN", null, v); | |
| a = hh(a, 1); | |
| z(0 <= a, "Invalid confidence value: " + a); | |
| z(1E3 >= a, "Invalid confidence value: " + a); | |
| if (0 <= o.ra && a < o.ra) { | |
| T(e, "alt-low-conf"); | |
| } | |
| if (aj(o.K, o.C + "." + o.m + "." + K(c, 0))) { | |
| a = o.K.get(o.C + "." + o.m + "." + K(c, 0)); | |
| if (a != DE(c, 0)) { | |
| o.a.Uf(e, a); | |
| T(e, "alt-edited"); | |
| /** @type {boolean} */ | |
| d = true; | |
| EE(o, true); | |
| } | |
| } | |
| if (null != o.b.Jc) { | |
| o.b.Jc.a(e); | |
| } else { | |
| /** @type {string} */ | |
| e.title = ""; | |
| } | |
| kE(o.b, e, c); | |
| } | |
| if (e) { | |
| o.a.appendChild(o.j(), e); | |
| } | |
| } | |
| if (null != o.c) { | |
| /** @type {string} */ | |
| e = o.C + "." + o.m; | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < m.length; ++i) { | |
| /** @type {string} */ | |
| e = e + ("." + m[i]); | |
| } | |
| if (aj(o.K, e)) { | |
| FE(o, false); | |
| /** @type {boolean} */ | |
| d = true; | |
| GE(o, o.K.get(e)); | |
| if (null != o.g) { | |
| o.g.a(false); | |
| } | |
| EE(o, true); | |
| } | |
| } | |
| if (!d) { | |
| EE(o, false); | |
| FE(o, false); | |
| } | |
| if (d || b) { | |
| o.dispatchEvent("action"); | |
| } | |
| return 0 < J(o.h, 5); | |
| } | |
| EE(o, false); | |
| FE(o, false); | |
| return false; | |
| }; | |
| /** | |
| * @param {?} v | |
| * @return {?} | |
| */ | |
| var CE = function(v) { | |
| v = Bc(fe(v)).split("<br>"); | |
| /** @type {!DocumentFragment} */ | |
| var editNode = document.createDocumentFragment(); | |
| /** @type {number} */ | |
| var c = 0; | |
| A(v, function(val) { | |
| if (0 != c) { | |
| editNode.appendChild(G("BR")); | |
| } | |
| c++; | |
| if ("" != val) { | |
| editNode.appendChild(Af(ie(val))); | |
| } | |
| }); | |
| return editNode; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {string} be | |
| * @return {?} | |
| */ | |
| var IE = function(a, be) { | |
| if (zE(a)) { | |
| return a.c.a.aa(); | |
| } | |
| /** @type {!Array} */ | |
| var attrs = []; | |
| if (a.j() && a.j().childNodes) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < a.j().childNodes.length; ++i) { | |
| var x = a.j().childNodes[i]; | |
| attrs[i] = be && "BR" == x.tagName ? "\n" : ag(x); | |
| } | |
| } | |
| return attrs.join(""); | |
| }; | |
| /** | |
| * @param {number} s | |
| * @param {number} c | |
| * @param {undefined} n | |
| * @param {string} o | |
| * @return {?} | |
| */ | |
| var KE = function(s, c, n, o) { | |
| /** @type {number} */ | |
| s = 0; | |
| for (; s < J(c, 5); s++) { | |
| var p = Vo(c, s); | |
| if (n.Oc(p)) { | |
| /** @type {number} */ | |
| n = c; | |
| /** @type {number} */ | |
| c = s; | |
| /** @type {number} */ | |
| p = -1; | |
| s = J(n, 5); | |
| /** @type {number} */ | |
| var i = c; | |
| for (; 0 <= i; i--) { | |
| if (0 == hh(Vo(n, i), 5)) { | |
| /** @type {number} */ | |
| p = i; | |
| break; | |
| } | |
| } | |
| /** @type {number} */ | |
| i = c + 1; | |
| for (; i <= J(n, 5); i++) { | |
| if (0 == hh(Vo(n, i), 5)) { | |
| /** @type {number} */ | |
| s = i; | |
| break; | |
| } | |
| } | |
| if (null != o && o) { | |
| c = JE(n, p, s); | |
| } else { | |
| if (o = n, n = p, o) { | |
| /** @type {number} */ | |
| p = c + 1; | |
| /** @type {number} */ | |
| i = c; | |
| c = BE(o, c).length; | |
| for (; 64 > c && (p != s || i != n);) { | |
| if (p < s) { | |
| c = c + (BE(o, p++).length + 1); | |
| } | |
| if (64 > c && i > n) { | |
| c = c + (BE(o, --i).length + 1); | |
| } | |
| } | |
| c = JE(o, i, p); | |
| } else { | |
| /** @type {string} */ | |
| c = ""; | |
| } | |
| } | |
| return c; | |
| } | |
| } | |
| return ""; | |
| }; | |
| /** | |
| * @param {!Object} m | |
| * @param {number} x | |
| * @param {number} o | |
| * @return {?} | |
| */ | |
| var JE = function(m, x, o) { | |
| /** @type {!Array} */ | |
| var sb = []; | |
| sb.push(BE(m, x)); | |
| x = x + 1; | |
| for (; x < o; x++) { | |
| if (AE(m, x)) { | |
| sb.push(" "); | |
| } | |
| sb.push(BE(m, x)); | |
| } | |
| return sb.join(""); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {number} b | |
| * @return {?} | |
| */ | |
| var AE = function(a, b) { | |
| if (0 == b) { | |
| return false; | |
| } | |
| var result = Vo(a, b); | |
| var e = Vo(a, b - 1); | |
| return gl(ko(result, 0), 2) && !gl(ko(e, 0), 3) && !wc(BE(a, b - 1), "\n"); | |
| }; | |
| k = yE.prototype; | |
| /** | |
| * @return {?} | |
| */ | |
| k.$e = function() { | |
| return this.m; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.Ra = function() { | |
| this.Fa(fg(this.a, "span")); | |
| }; | |
| /** | |
| * @param {?} a | |
| * @return {undefined} | |
| */ | |
| k.Fa = function(a) { | |
| yE.D.Fa.call(this, a); | |
| HE(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.ia = function() { | |
| yE.D.ia.call(this); | |
| Y(this).M(this.b, "action", this.Ta); | |
| if (null != this.g && null != this.g.b) { | |
| Y(this).M(this.g.b, "click", this.Tm); | |
| uq(Y(this), this.g.b, this.F.g, this.F); | |
| } | |
| Y(this).M(this.b, "show", this.Em); | |
| if (this.j()) { | |
| Y(this).M(this.j(), "keydown", function(event) { | |
| if (32 == event.keyCode) { | |
| event.stopPropagation(); | |
| } | |
| }, true); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.X = function() { | |
| yE.D.X.call(this); | |
| this.b.Qa(); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.vm = function() { | |
| this.w.sa(this.c.b); | |
| EE(this, this.c.b); | |
| }; | |
| /** | |
| * @param {!Object} result | |
| * @return {undefined} | |
| */ | |
| var LE = function(result) { | |
| if (null != result.g) { | |
| result.g.a(true); | |
| } | |
| var options = result.c; | |
| var m = IE(result); | |
| T(options.G, "full-edit"); | |
| options.c.setVisible(true); | |
| options.m = m; | |
| options.a.g(m); | |
| options.a.setVisible(true); | |
| options.a.ze(true); | |
| X(options.w, true); | |
| X(options.C, false); | |
| options.L = dq(options.o); | |
| X(options.o, false); | |
| m = options.a.j(); | |
| m.focus(); | |
| m.setSelectionRange(m.value.length, m.value.length); | |
| /** @type {boolean} */ | |
| options.h = true; | |
| result.ea = dq(result.w.j()); | |
| result.w.reset(); | |
| if (null != result.g) { | |
| result.w.sa(dq(result.g.b)); | |
| } else { | |
| result.w.sa(false); | |
| } | |
| EE(result, false); | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @return {undefined} | |
| */ | |
| yE.prototype.Ta = function(o) { | |
| if ("hide" != o.type || o.target == this.b) { | |
| if (o.target == this.b.m && null != this.c) { | |
| this.O.log("editpopupclk"); | |
| var b = this.F; | |
| N(b, O(b, 233)); | |
| LE(this); | |
| } else { | |
| var c = o.h; | |
| if (null == c && null != o.a) { | |
| c = o.a.Lb; | |
| } | |
| b = o.target.Bb(); | |
| if (null != c && null != o.target) { | |
| var value = c; | |
| var a = z(this.b.w.get(Qa(value))); | |
| this.a.Uf(value, b); | |
| if (b == DE(a, 0)) { | |
| U(value, "alt-edited"); | |
| if (0 == nf("alt-edited").length) { | |
| EE(this, false); | |
| FE(this, false); | |
| } | |
| } else { | |
| T(value, "alt-edited"); | |
| EE(this, true); | |
| FE(this, true); | |
| } | |
| if (null != this.K) { | |
| this.K.set(this.C + "." + this.m + "." + K(a, 0), b); | |
| } | |
| a = z(this.b.w.get(Qa(c))); | |
| if (null != this.K) { | |
| this.K.set(this.C + "." + this.m + "." + K(a, 0), b); | |
| } | |
| value = DE(a, 0); | |
| c = Lq(this.b, o.target); | |
| value = { | |
| sl : this.C, | |
| tl : this.m, | |
| utrans : b, | |
| gtrans : value, | |
| index : c, | |
| ophrase : K(a, 0), | |
| osentence : K(a, 4), | |
| tsentence : KE(this, this.h, a) | |
| }; | |
| if (0 < J(a, 2)) { | |
| value.confidence = hh(ko(a, 0), 1); | |
| } | |
| if (o.target instanceof sE || -1 == c) { | |
| /** @type {number} */ | |
| value.manual = 1; | |
| c = this.F; | |
| N(c, O(c, 240)); | |
| } else { | |
| o = this.F; | |
| a = O(o, 239); | |
| var key = new Rk; | |
| var delim = Ne(Ne(key, 2, Pk), 3, Nk); | |
| D(delim, 1, c); | |
| Le(a, 27, key); | |
| N(o, a); | |
| } | |
| var i; | |
| for (i in value) { | |
| if (r(value[i]) && 64 < value[i].length) { | |
| /** @type {number} */ | |
| value.tr = 1; | |
| value[i] = value[i].substr(0, 64); | |
| } | |
| } | |
| this.O.log("usealt", value, null); | |
| i = new kg("usealt"); | |
| i.text = b; | |
| this.dispatchEvent(i); | |
| this.dispatchEvent("action"); | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} t | |
| * @param {!Object} e | |
| * @return {undefined} | |
| */ | |
| var GE = function(t, e) { | |
| if (t.j()) { | |
| if (null == t.Y) { | |
| t.W = Ab(t.a.$i(t.j())); | |
| } | |
| /** @type {!Object} */ | |
| t.Y = e; | |
| var newNodeLists; | |
| if (newNodeLists = t.j().childNodes && 0 < t.j().childNodes.length) { | |
| newNodeLists = (newNodeLists = t.j().childNodes[0]) ? aj(t.b.b, Qa(newNodeLists)) : false; | |
| } | |
| if (newNodeLists) { | |
| t.a.Tf(t.j()); | |
| t.b.Hf(); | |
| e = t.a.b("SPAN", "alt-edited", t.Y); | |
| t.a.appendChild(t.j(), e); | |
| kE(t.b, e, new io); | |
| } else { | |
| t.j().innerHTML = Bc(fe(e)); | |
| } | |
| } | |
| }; | |
| k = yE.prototype; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.Tm = function() { | |
| if (null != this.c && zE(this)) { | |
| var options = this.c; | |
| options.c.setVisible(true); | |
| options.a.g(options.m); | |
| options.a.j().focus(); | |
| options.g(null); | |
| } else { | |
| if (zE(this)) { | |
| if (null != this.g) { | |
| this.g.a(false); | |
| } | |
| vE(this.c); | |
| } | |
| this.K.hd(); | |
| /** @type {null} */ | |
| this.Y = null; | |
| HE(this); | |
| this.dispatchEvent("action"); | |
| } | |
| this.O.log("clkundo", void 0, null); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.pm = function() { | |
| if (zE(this)) { | |
| if (this.c.b) { | |
| GE(this, this.c.a.aa()); | |
| /** @type {boolean} */ | |
| this.ea = true; | |
| } | |
| vE(this.c); | |
| if (null != this.g) { | |
| this.g.a(false); | |
| } | |
| if (this.c.b) { | |
| EE(this, true); | |
| } | |
| this.w.sa(true); | |
| X(this.w.j(), this.ea); | |
| this.dispatchEvent("action"); | |
| } | |
| var b = this.F; | |
| N(b, O(b, 215)); | |
| this.O.log("clkcancel", void 0, null); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| k.Em = function() { | |
| var c = this.b.w.get(Qa(this.b.Lb)); | |
| if (c) { | |
| if (0 < this.T) { | |
| var data = new Am("source=baf"); | |
| if (1 == this.T) { | |
| /** @type {!Array} */ | |
| var b = []; | |
| /** @type {number} */ | |
| var g = 0; | |
| var f = J(c, 2); | |
| for (; g < f; g++) { | |
| b.push(DE(c, g)); | |
| } | |
| Zo(this.Da, this.m, this.C, ME(this), b, v(this.Uo, this), void 0, data, void 0); | |
| } else { | |
| /** @type {number} */ | |
| g = 0; | |
| f = J(c, 2); | |
| for (; g < f; g++) { | |
| b = DE(c, g); | |
| ap(this.Da, this.m, this.C, ME(this), b, ["at", "t"], v(this.Vo, this, g), void 0, data); | |
| } | |
| } | |
| } | |
| data = new kg("click"); | |
| data.text = this.b.Bb(); | |
| data.m = J(this.h, 5); | |
| this.dispatchEvent(data); | |
| data = {}; | |
| data.confidence = hh(ko(c, 0), 1); | |
| if (this.C && this.m && this.Z) { | |
| data.segments = J(this.h, 5); | |
| data.sl = this.C; | |
| data.tl = this.m; | |
| data.hl = this.Z; | |
| } | |
| c = this.F; | |
| N(c, O(c, 238)); | |
| this.O.log("phrsclk", data, null); | |
| } | |
| }; | |
| /** | |
| * @param {?} n | |
| * @param {?} s | |
| * @return {undefined} | |
| */ | |
| k.Vo = function(n, s) { | |
| if (1 == this.T || 1 < J(s, 5)) { | |
| var res = s.hb(0).dd(); | |
| /** @type {number} */ | |
| var data = 1; | |
| var condition = s.sc(); | |
| for (; data < condition; data++) { | |
| res = res + (" " + s.hb(data).dd()); | |
| } | |
| data = res; | |
| } else { | |
| if (1 == J(s, 5)) { | |
| /** @type {!Array} */ | |
| res = []; | |
| s = Vo(s, 0); | |
| /** @type {number} */ | |
| data = 0; | |
| /** @type {number} */ | |
| condition = Math.min(this.T, J(s, 2)); | |
| for (; data < condition; data++) { | |
| res.push(DE(s, data)); | |
| } | |
| /** @type {string} */ | |
| data = res.join(", "); | |
| } else { | |
| /** @type {string} */ | |
| data = "..."; | |
| } | |
| } | |
| oE(this.b, n, data); | |
| }; | |
| /** | |
| * @param {!NodeList} serverElements | |
| * @return {undefined} | |
| */ | |
| k.Uo = function(serverElements) { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < serverElements.length; i++) { | |
| oE(this.b, i, serverElements[i]); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {boolean} fn | |
| * @return {undefined} | |
| */ | |
| var EE = function(a, fn) { | |
| if (null != a.g && null != a.g.b) { | |
| X(a.g.b, fn); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @param {boolean} a | |
| * @return {undefined} | |
| */ | |
| var FE = function(obj, a) { | |
| if (null != obj.w) { | |
| if (a) { | |
| obj.w.reset(); | |
| } | |
| X(obj.w.j(), a); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| yE.prototype.gb = function() { | |
| /** @type {!Array} */ | |
| var a = []; | |
| var w; | |
| if (null != this.W) { | |
| w = this.W; | |
| } else { | |
| w = Kf(this.j()); | |
| } | |
| var blob = { | |
| segment : [] | |
| }; | |
| /** @type {null} */ | |
| var script = null; | |
| /** @type {number} */ | |
| var offset = 0; | |
| /** @type {number} */ | |
| var k = 0; | |
| for (; k < w.length; k++) { | |
| var c = Vo(this.h, k); | |
| if (null != c) { | |
| var match = ag(w[k]); | |
| a: { | |
| var m = match; | |
| var n = c; | |
| if (0 == J(n, 2)) { | |
| /** @type {number} */ | |
| m = 0; | |
| } else { | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < J(n, 2); ++i) { | |
| if (m == DE(n, i)) { | |
| /** @type {number} */ | |
| m = i; | |
| break a; | |
| } | |
| } | |
| /** @type {number} */ | |
| m = -1; | |
| } | |
| } | |
| n = zc(K(c, 4)); | |
| i = KE(this, this.h, c, true); | |
| if (0 != n.length) { | |
| if (0 == a.length || n != a[a.length - 1]) { | |
| a.push(n); | |
| script = NE(this, a.length - 1); | |
| /** @type {number} */ | |
| offset = 0; | |
| script = { | |
| source : n, | |
| original_target : i, | |
| segment_source : script, | |
| phrase_correction : [] | |
| }; | |
| blob.segment.push(script); | |
| } | |
| if (0 != m) { | |
| n = DE(c, 0).length; | |
| m = { | |
| alternative_index : m, | |
| edited_phrase : match, | |
| source_span : [], | |
| target_span : [{ | |
| start : offset, | |
| end : offset + n | |
| }] | |
| }; | |
| script.phrase_correction.push(m); | |
| /** @type {number} */ | |
| n = 0; | |
| for (; n < J(c, 3); ++n) { | |
| i = lo(c, n); | |
| m.source_span.push({ | |
| start : hh(i, 0), | |
| end : hh(i, 1) | |
| }); | |
| } | |
| } | |
| offset = offset + match.length; | |
| if (gl(ko(c, 0), 2)) { | |
| offset++; | |
| } | |
| } | |
| } | |
| } | |
| if (zE(this)) { | |
| this.dispatchEvent("action"); | |
| vE(this.c); | |
| if (null != this.g) { | |
| this.g.a(false); | |
| } | |
| EE(this, true); | |
| if (this.c.a.aa() != IE(this)) { | |
| GE(this, this.c.a.aa()); | |
| } | |
| /** @type {string} */ | |
| w = this.C + "." + this.m; | |
| /** @type {number} */ | |
| k = 0; | |
| for (; k < a.length; ++k) { | |
| /** @type {string} */ | |
| w = w + ("." + a[k]); | |
| } | |
| a = this.c.a.aa(); | |
| this.K.set(w, a); | |
| /** @type {boolean} */ | |
| blob.contains_full_edit = true; | |
| } | |
| blob.edited_target = IE(this, true); | |
| a = new Am; | |
| a.set("ue", JSON.stringify(blob)); | |
| a.set("sl", this.C); | |
| a.set("tl", this.m); | |
| vj("/translate_suggestion?client=" + this.Aa, void 0, "POST", a.toString(), void 0, 1E4); | |
| }; | |
| /** | |
| * @param {!Object} m | |
| * @param {number} r | |
| * @return {?} | |
| */ | |
| var NE = function(m, r) { | |
| if (r < m.h.sc()) { | |
| switch(m = m.h.hb(r), fl(m, 4, 0)) { | |
| case 0: | |
| return 1; | |
| case 1: | |
| return 2; | |
| case 2: | |
| return 3; | |
| case 10: | |
| return 4; | |
| case 3: | |
| return 5; | |
| } | |
| } | |
| return 0; | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @return {?} | |
| */ | |
| var zE = function(o) { | |
| return null != o.c && o.c.h; | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {number} b | |
| * @return {?} | |
| */ | |
| var BE = function(a, b) { | |
| a = Vo(a, b); | |
| return 0 == J(a, 2) ? K(a, 0) : DE(a, 0); | |
| }; | |
| /** | |
| * @param {!Object} i | |
| * @param {number} start | |
| * @return {?} | |
| */ | |
| var DE = function(i, start) { | |
| return K(ko(i, start), 0); | |
| }; | |
| /** | |
| * @param {string} result | |
| * @return {?} | |
| */ | |
| var ME = function(result) { | |
| result = result.Z; | |
| if (0 === result.length && null != kf("hl")) { | |
| result = kf("hl").value; | |
| } | |
| return result; | |
| }; | |
| /** | |
| * @param {!Array} fn | |
| * @return {undefined} | |
| */ | |
| var OE = function(fn) { | |
| el(this, fn, 7); | |
| }; | |
| x(OE, dl); | |
| var PE = { | |
| translation_id : { | |
| H : 0, | |
| J : false | |
| }, | |
| sl : { | |
| H : 1, | |
| J : false | |
| }, | |
| tl : { | |
| H : 2, | |
| J : false | |
| }, | |
| source : { | |
| H : 3, | |
| J : false | |
| }, | |
| trans : { | |
| H : 4, | |
| J : false | |
| }, | |
| write_timestamp : { | |
| H : 5, | |
| J : false | |
| }, | |
| label : { | |
| H : 6, | |
| J : true | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| OE.prototype.a = function() { | |
| return PE; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| OE.prototype.dd = function() { | |
| return K(this, 4); | |
| }; | |
| /** | |
| * @param {!Array} fn | |
| * @return {undefined} | |
| */ | |
| var QE = function(fn) { | |
| el(this, fn, 7); | |
| }; | |
| x(QE, dl); | |
| var RE = { | |
| total : { | |
| H : 0, | |
| J : false | |
| }, | |
| token : { | |
| H : 1, | |
| J : false | |
| }, | |
| translations : { | |
| H : 2, | |
| ya : function(obj) { | |
| return kl(OE, obj); | |
| }, | |
| xa : function(error) { | |
| return jl(new OE(error)); | |
| }, | |
| J : true | |
| }, | |
| error : { | |
| H : 3, | |
| J : false | |
| }, | |
| timestamp : { | |
| H : 4, | |
| J : false | |
| }, | |
| id : { | |
| H : 5, | |
| J : false | |
| }, | |
| max_translations : { | |
| H : 6, | |
| J : false | |
| } | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| QE.prototype.a = function() { | |
| return RE; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var SE = function() { | |
| var c = DATA.Usage; | |
| this.g = DATA.DisplayLanguage; | |
| /** @type {string} */ | |
| this.a = ""; | |
| this.c = c; | |
| /** @type {string} */ | |
| this.h = ""; | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @param {string} value | |
| * @return {undefined} | |
| */ | |
| SE.prototype.b = function(name, value) { | |
| value = value.target; | |
| if (Ej(value) && "" != Fj(value) && null != Gj(value)) { | |
| value = Gj(value); | |
| value = new QE(value); | |
| var time = K(value, 1); | |
| if (null != time && "" != time) { | |
| this.a = time; | |
| } | |
| } else { | |
| value = new QE; | |
| value.$a[3] = this.h; | |
| } | |
| name(value); | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @param {string} out | |
| * @param {string} f | |
| * @param {string} options | |
| * @param {string} close | |
| * @return {undefined} | |
| */ | |
| var TE = function(value, out, f, options, close) { | |
| /** @type {string} */ | |
| var f = window.location.href; | |
| out = new tm(out); | |
| if (f = Km(new tm(f, true), "authuser")) { | |
| out.a.set("authuser", f); | |
| } | |
| out = out.toString(); | |
| /** @type {string} */ | |
| out = out + ("&hl=" + value.g); | |
| if (value.c) { | |
| /** @type {string} */ | |
| out = out + ("&xt=" + value.c); | |
| } | |
| if (null != close) { | |
| vj(out, v(value.b, value, f), options, close); | |
| } else { | |
| vj(out, v(value.b, value, f), options); | |
| } | |
| }; | |
| /** | |
| * @param {string} json | |
| * @param {string} e | |
| * @param {string} type | |
| * @param {string} value | |
| * @param {string} time | |
| * @param {string} h | |
| * @return {undefined} | |
| */ | |
| SE.prototype.Cb = function(json, e, type, value, time, h) { | |
| var c = { | |
| cm : "g" | |
| }; | |
| if (null != e && "all" != e) { | |
| /** @type {string} */ | |
| c.sl = e; | |
| } | |
| if (null != type && "all" != type) { | |
| /** @type {string} */ | |
| c.tl = type; | |
| } | |
| if (null != value && "" != value) { | |
| /** @type {string} */ | |
| c.q = value; | |
| } | |
| if (null != time && "" != time) { | |
| /** @type {string} */ | |
| c.utrans = time; | |
| } | |
| if (null != h && "0" != h) { | |
| /** @type {string} */ | |
| c.od = h; | |
| } | |
| if ("" != this.a) { | |
| c.tk = this.a; | |
| /** @type {string} */ | |
| this.a = ""; | |
| } | |
| TE(this, "/translate_a/sg?client=webapp&" + jj(c), json, "GET"); | |
| }; | |
| /** | |
| * @param {!Object} session_id | |
| * @param {string} f | |
| * @param {!Object} t | |
| * @param {?} o | |
| * @param {string} c | |
| * @param {?} p | |
| * @param {?} altCss | |
| * @return {undefined} | |
| */ | |
| var UE = function(session_id, f, t, o, c, p, altCss) { | |
| var obj = { | |
| cm : "a" | |
| }; | |
| /** @type {!Object} */ | |
| obj.sl = t; | |
| obj.tl = o; | |
| /** @type {string} */ | |
| obj.ql = c.length + ""; | |
| if (altCss) { | |
| /** @type {string} */ | |
| obj.edit = "1"; | |
| } | |
| t = {}; | |
| /** @type {string} */ | |
| t.q = c; | |
| t.utrans = p; | |
| TE(session_id, "/translate_a/sg?client=webapp&" + jj(obj), f, "POST", jj(t)); | |
| }; | |
| /** | |
| * @param {!Object} session_id | |
| * @param {string} f | |
| * @param {number} x | |
| * @return {undefined} | |
| */ | |
| var VE = function(session_id, f, x) { | |
| var where = { | |
| cm : "d" | |
| }; | |
| /** @type {string} */ | |
| where.count = x.length + ""; | |
| var mark = {}; | |
| /** @type {number} */ | |
| mark.id = x; | |
| TE(session_id, "/translate_a/sg?client=webapp&" + jj(where), f, "POST", jj(mark)); | |
| }; | |
| var Sb = {}; | |
| /** @type {null} */ | |
| var WE = null; | |
| /** | |
| * @param {boolean} b | |
| * @return {undefined} | |
| */ | |
| var XE = function(b) { | |
| b = Qa(b); | |
| delete Sb[b]; | |
| if (Tb() && WE) { | |
| WE.stop(); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var ZE = function() { | |
| if (!WE) { | |
| WE = new Dr(function() { | |
| YE(); | |
| }, 20); | |
| } | |
| var sched = WE; | |
| if (!sched.tb()) { | |
| sched.start(); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var YE = function() { | |
| var box = Ua(); | |
| Mb(Sb, function(search) { | |
| $E(search, box); | |
| }); | |
| if (!Tb()) { | |
| ZE(); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @param {!Object} k | |
| * @param {number} d | |
| * @param {?} l | |
| * @return {undefined} | |
| */ | |
| var aF = function(e, k, d, l) { | |
| ND.call(this); | |
| if (!Ka(e) || !Ka(k)) { | |
| throw Error("Start and end parameters must be arrays"); | |
| } | |
| if (e.length != k.length) { | |
| throw Error("Start and end points must be the same length"); | |
| } | |
| /** @type {!Object} */ | |
| this.o = e; | |
| /** @type {!Object} */ | |
| this.K = k; | |
| /** @type {number} */ | |
| this.duration = d; | |
| this.L = l; | |
| /** @type {!Array} */ | |
| this.coords = []; | |
| /** @type {number} */ | |
| this.progress = 0; | |
| /** @type {null} */ | |
| this.G = null; | |
| }; | |
| x(aF, ND); | |
| /** | |
| * @param {number} grid | |
| * @return {?} | |
| */ | |
| aF.prototype.play = function(grid) { | |
| if (grid || 0 == this.a) { | |
| /** @type {number} */ | |
| this.progress = 0; | |
| this.coords = this.o; | |
| } else { | |
| if (1 == this.a) { | |
| return false; | |
| } | |
| } | |
| XE(this); | |
| this.startTime = grid = Ua(); | |
| if (-1 == this.a) { | |
| this.startTime -= this.duration * this.progress; | |
| } | |
| this.endTime = this.startTime + this.duration; | |
| this.G = this.startTime; | |
| if (!this.progress) { | |
| this.c(); | |
| } | |
| this.b("play"); | |
| if (-1 == this.a) { | |
| this.b("resume"); | |
| } | |
| /** @type {number} */ | |
| this.a = 1; | |
| var indexLookupKey = Qa(this); | |
| if (!(indexLookupKey in Sb)) { | |
| Sb[indexLookupKey] = this; | |
| } | |
| ZE(); | |
| $E(this, grid); | |
| return true; | |
| }; | |
| /** | |
| * @param {boolean} force | |
| * @return {undefined} | |
| */ | |
| aF.prototype.stop = function(force) { | |
| XE(this); | |
| /** @type {number} */ | |
| this.a = 0; | |
| if (force) { | |
| /** @type {number} */ | |
| this.progress = 1; | |
| } | |
| bF(this, this.progress); | |
| this.b("stop"); | |
| this.g(); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| aF.prototype.X = function() { | |
| if (!(0 == this.a)) { | |
| this.stop(false); | |
| } | |
| this.b("destroy"); | |
| aF.D.X.call(this); | |
| }; | |
| /** | |
| * @param {!Object} e | |
| * @param {number} value | |
| * @return {undefined} | |
| */ | |
| var $E = function(e, value) { | |
| ab(e.startTime); | |
| ab(e.endTime); | |
| ab(e.G); | |
| if (value < e.startTime) { | |
| /** @type {number} */ | |
| e.endTime = value + e.endTime - e.startTime; | |
| /** @type {number} */ | |
| e.startTime = value; | |
| } | |
| /** @type {number} */ | |
| e.progress = (value - e.startTime) / (e.endTime - e.startTime); | |
| if (1 < e.progress) { | |
| /** @type {number} */ | |
| e.progress = 1; | |
| } | |
| /** @type {number} */ | |
| e.G = value; | |
| bF(e, e.progress); | |
| if (1 == e.progress) { | |
| /** @type {number} */ | |
| e.a = 0; | |
| XE(e); | |
| e.b("finish"); | |
| e.g(); | |
| } else { | |
| if (1 == e.a) { | |
| e.C(); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @param {number} key | |
| * @return {undefined} | |
| */ | |
| var bF = function(o, key) { | |
| if (Ma(o.L)) { | |
| key = o.L(key); | |
| } | |
| /** @type {!Array} */ | |
| o.coords = Array(o.o.length); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < o.o.length; i++) { | |
| o.coords[i] = (o.K[i] - o.o[i]) * key + o.o[i]; | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| aF.prototype.C = function() { | |
| this.b("animate"); | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| aF.prototype.b = function(name) { | |
| this.dispatchEvent(new cF(name, this)); | |
| }; | |
| /** | |
| * @param {?} curIndex | |
| * @param {!Object} anim | |
| * @return {undefined} | |
| */ | |
| var cF = function(curIndex, anim) { | |
| kg.call(this, curIndex); | |
| this.coords = anim.coords; | |
| this.x = anim.coords[0]; | |
| this.duration = anim.duration; | |
| this.progress = anim.progress; | |
| this.state = anim.a; | |
| }; | |
| x(cF, kg); | |
| /** | |
| * @param {number} height | |
| * @param {?} interval | |
| * @param {?} c | |
| * @param {?} d | |
| * @param {?} e | |
| * @return {undefined} | |
| */ | |
| var dF = function(height, interval, c, d, e) { | |
| aF.call(this, interval, c, d, e); | |
| /** @type {number} */ | |
| this.h = height; | |
| }; | |
| x(dF, aF); | |
| /** @type {function(): undefined} */ | |
| dF.prototype.m = Ha; | |
| /** | |
| * @return {undefined} | |
| */ | |
| dF.prototype.C = function() { | |
| this.m(); | |
| dF.D.C.call(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| dF.prototype.g = function() { | |
| this.m(); | |
| dF.D.g.call(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| dF.prototype.c = function() { | |
| this.m(); | |
| dF.D.c.call(this); | |
| }; | |
| /** | |
| * @param {?} element | |
| * @param {!Array} n | |
| * @param {!Array} model | |
| * @param {?} row | |
| * @param {?} rowNumber | |
| * @return {undefined} | |
| */ | |
| var eF = function(element, n, model, row, rowNumber) { | |
| if (Aa(n)) { | |
| /** @type {!Array} */ | |
| n = [n]; | |
| } | |
| if (Aa(model)) { | |
| /** @type {!Array} */ | |
| model = [model]; | |
| } | |
| dF.call(this, element, n, model, row, rowNumber); | |
| if (1 != n.length || 1 != model.length) { | |
| throw Error("Start and end points must be 1D"); | |
| } | |
| /** @type {number} */ | |
| this.w = -1; | |
| }; | |
| x(eF, dF); | |
| /** @type {number} */ | |
| var fF = 1 / 1024; | |
| /** | |
| * @return {undefined} | |
| */ | |
| eF.prototype.m = function() { | |
| var dx = this.coords[0]; | |
| if (Math.abs(dx - this.w) >= fF) { | |
| cq(this.h, dx); | |
| this.w = dx; | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| eF.prototype.c = function() { | |
| /** @type {number} */ | |
| this.w = -1; | |
| eF.D.c.call(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| eF.prototype.g = function() { | |
| /** @type {number} */ | |
| this.w = -1; | |
| eF.D.g.call(this); | |
| }; | |
| /** | |
| * @param {?} p1__3354_SHARP_ | |
| * @param {?} bodyIdentifier | |
| * @param {?} cb | |
| * @return {undefined} | |
| */ | |
| var gF = function(p1__3354_SHARP_, bodyIdentifier, cb) { | |
| eF.call(this, p1__3354_SHARP_, 0, 1, bodyIdentifier, cb); | |
| }; | |
| x(gF, eF); | |
| /** | |
| * @param {?} p1__3354_SHARP_ | |
| * @param {?} bodyIdentifier | |
| * @param {?} cb | |
| * @return {undefined} | |
| */ | |
| var hF = function(p1__3354_SHARP_, bodyIdentifier, cb) { | |
| eF.call(this, p1__3354_SHARP_, 1, 0, bodyIdentifier, cb); | |
| }; | |
| x(hF, eF); | |
| /** | |
| * @return {undefined} | |
| */ | |
| hF.prototype.c = function() { | |
| /** @type {string} */ | |
| this.h.style.display = ""; | |
| hF.D.c.call(this); | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| hF.prototype.g = function() { | |
| /** @type {string} */ | |
| this.h.style.display = "none"; | |
| hF.D.g.call(this); | |
| }; | |
| /** | |
| * @param {?} p1__3354_SHARP_ | |
| * @param {?} bodyIdentifier | |
| * @param {?} cb | |
| * @return {undefined} | |
| */ | |
| var iF = function(p1__3354_SHARP_, bodyIdentifier, cb) { | |
| eF.call(this, p1__3354_SHARP_, 0, 1, bodyIdentifier, cb); | |
| }; | |
| x(iF, eF); | |
| /** | |
| * @return {undefined} | |
| */ | |
| iF.prototype.c = function() { | |
| /** @type {string} */ | |
| this.h.style.display = ""; | |
| iF.D.c.call(this); | |
| }; | |
| /** | |
| * @param {?} name | |
| * @param {string} g | |
| * @param {?} margin | |
| * @return {undefined} | |
| */ | |
| var jF = function(name, g, margin) { | |
| /** @type {string} */ | |
| var id = "rw"; | |
| if (null != margin && margin) { | |
| /** @type {string} */ | |
| id = "m" + id; | |
| } | |
| /** @type {string} */ | |
| this.g = g; | |
| os.call(this, name, id, MSG_SEE_ALSO, MSG_SEE_ALSO, 10); | |
| /** @type {boolean} */ | |
| this.Gi = true; | |
| }; | |
| x(jF, os); | |
| /** | |
| * @param {!Object} b | |
| * @param {!Function} e | |
| * @param {!Object} a | |
| * @param {!Object} parent | |
| * @return {?} | |
| */ | |
| jF.prototype.update = function(b, e, a, parent) { | |
| jF.D.update.call(this, b, e, a, parent); | |
| if (!parent || 0 == J(Uo(parent), 0)) { | |
| return false; | |
| } | |
| if (b = this.j()) { | |
| rp(b, ag(this.Zc)); | |
| } | |
| Ff(this.b); | |
| this.Ud(); | |
| a = b = G("DIV", { | |
| "class" : "gt-rw-div" | |
| }); | |
| /** @type {boolean} */ | |
| e = 15 < J(Uo(parent), 0); | |
| /** @type {number} */ | |
| var key = 0; | |
| for (; key < J(Uo(parent), 0); ++key) { | |
| var node = Uo(parent); | |
| var i = fh(node, 0, key); | |
| node = G("SPAN", { | |
| "class" : "gt-cd-cl" | |
| }); | |
| H(node, i); | |
| lp(node, "option"); | |
| /** @type {number} */ | |
| node.tabIndex = -1; | |
| this.c.push(node); | |
| if (10 == key && e) { | |
| var d = G("DIV", { | |
| "class" : "gt-rw-div" | |
| }); | |
| a = d; | |
| d = e ? G("SPAN", { | |
| "class" : "gt-card-fadein-wrapper" | |
| }, d) : d; | |
| Hp(d, { | |
| display : "none" | |
| }); | |
| } | |
| if (!this.g) { | |
| if (0 != key && key != J(Uo(parent), 0)) { | |
| a.appendChild(Af(", ")); | |
| } | |
| } | |
| a.appendChild(node); | |
| } | |
| /** @type {string} */ | |
| a = kc(this.Ca) ? "rtl" : "ltr"; | |
| Hp(this.b, { | |
| direction : a | |
| }); | |
| this.b.appendChild(b); | |
| if (d) { | |
| this.b.appendChild(d); | |
| } | |
| if (e) { | |
| parent = MSG_N_MORE_RELATED_LABEL.replace("%1$s", (J(Uo(parent), 0) - 7).toLocaleString(this.Xa)); | |
| qs(this, parent, MSG_FEWER_RELATED_LABEL); | |
| } | |
| kF(this, Ab(Kf(b))); | |
| this.setVisible(true); | |
| return true; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| jF.prototype.ia = function() { | |
| jF.D.ia.call(this); | |
| var j = this.j(); | |
| if (j) { | |
| lp(j, "listbox"); | |
| ah(j, this.w.bind(this)); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} h | |
| * @param {!Array} skip | |
| * @return {undefined} | |
| */ | |
| var kF = function(h, skip) { | |
| if (h.g) { | |
| Qg(h.j(), "keydown"); | |
| I(h.j(), "keydown", function($r) { | |
| $g($r, skip); | |
| }, false); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} name | |
| * @return {undefined} | |
| */ | |
| jF.prototype.w = function(name) { | |
| if (tp(name.target, "gt-cd-cl")) { | |
| this.dispatchEvent(new kg("a", name.target)); | |
| } | |
| }; | |
| /** | |
| * @param {boolean} a | |
| * @return {undefined} | |
| */ | |
| jF.prototype.Ce = function(a) { | |
| /** @type {!Array} */ | |
| var soundsForWeek = []; | |
| var stars = nf("gt-card-fadein-wrapper", this.j()); | |
| if (this.g) { | |
| if (a) { | |
| var parent = Ab(nf("gt-cd-cl", this.j())); | |
| } else { | |
| parent = E("gt-rw-div", this.j()); | |
| parent = Ab(Kf(parent)); | |
| } | |
| kF(this, parent); | |
| } | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < stars.length; i++) { | |
| parent = stars[i]; | |
| if (a) { | |
| soundsForWeek.push(new iF(parent, 218)); | |
| } else { | |
| soundsForWeek.push(new hF(parent, 218)); | |
| } | |
| } | |
| /** @type {number} */ | |
| i = 0; | |
| for (; i < soundsForWeek.length; i++) { | |
| soundsForWeek[i].play(); | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var lF = function() { | |
| }; | |
| /** | |
| * @param {string} result | |
| * @return {?} | |
| */ | |
| var mF = function(result) { | |
| var node = G("SPAN"); | |
| /** @type {string} */ | |
| node.style.color = "transparent"; | |
| /** @type {string} */ | |
| node.style.background = "transparent"; | |
| /** @type {string} */ | |
| node.style.top = "-1000px"; | |
| /** @type {string} */ | |
| node.style.left = "-1000px"; | |
| /** @type {string} */ | |
| node.style.position = "absolute"; | |
| Df(document.body, node); | |
| H(node, result); | |
| result = node.offsetWidth; | |
| Jf(node); | |
| return result; | |
| }; | |
| Ia(lF); | |
| /** | |
| * @return {undefined} | |
| */ | |
| var nF = function() { | |
| lF.N(); | |
| }; | |
| Ia(nF); | |
| /** | |
| * @param {string} a | |
| * @return {?} | |
| */ | |
| var oF = function(a) { | |
| var fa = mF(a); | |
| a = mF(a.substr(0, 1)); | |
| return fa != a; | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var pF = function() { | |
| uB.apply(this, arguments); | |
| }; | |
| ka(pF, uB); | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| pF.prototype.K = function(type) { | |
| uB.prototype.K.call(this, type); | |
| qF(this.ea); | |
| qF(this.b); | |
| this.j().addEventListener("keydown", v(this.Ta, this), false); | |
| }; | |
| /** | |
| * @param {!Object} element | |
| * @return {undefined} | |
| */ | |
| var qF = function(element) { | |
| V(element, "tw-ll-top", true); | |
| element.addEventListener("scroll", function() { | |
| V(element, "tw-ll-top", 0 >= element.scrollTop); | |
| }); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var rF = function(a) { | |
| return eg(document) === CB(a); | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {?} | |
| */ | |
| pF.prototype.oa = function(type) { | |
| return eg(document) === type.j(); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @return {?} | |
| */ | |
| var sF = function(a) { | |
| a = Jp(a.m, "columnCount"); | |
| return parseInt(a, 10) || 1; | |
| }; | |
| /** | |
| * @param {!Object} key | |
| * @return {undefined} | |
| */ | |
| pF.prototype.Ta = function(key) { | |
| if (this.isVisible()) { | |
| switch(key.keyCode) { | |
| case 27: | |
| this.close(); | |
| break; | |
| case 13: | |
| if (rF(this)) { | |
| var length = tF(this); | |
| if (dq(this.b) && null != length) { | |
| length.Te(nB(length.j())); | |
| key.preventDefault(); | |
| } | |
| } else { | |
| length = (dq(this.b) ? this.g : this.a).find(this.oa) || null; | |
| if (null != length) { | |
| length.Te(nB(length.j())); | |
| key.preventDefault(); | |
| } | |
| } | |
| break; | |
| case 40: | |
| if (rF(this)) { | |
| length = tF(this); | |
| if (null != length) { | |
| CB(this).blur(); | |
| length.j().focus(); | |
| key.preventDefault(); | |
| } | |
| } else { | |
| uF(this, key); | |
| } | |
| break; | |
| case 38: | |
| if (!rF(this)) { | |
| vF(this, key); | |
| } | |
| break; | |
| case 39: | |
| if (!rF(this) && (length = sF(this), 1 < length)) { | |
| /** @type {number} */ | |
| var size = Math.ceil(this.a.length / length); | |
| var i = (dq(this.b) ? this.g : this.a).findIndex(this.oa) + size; | |
| if (i >= this.a.length) { | |
| /** @type {number} */ | |
| i = i - length * size; | |
| } | |
| if (0 > i) { | |
| i = i + size; | |
| } | |
| this.a[i].j().focus(); | |
| key.preventDefault(); | |
| } | |
| break; | |
| case 37: | |
| if (!rF(this)) { | |
| length = sF(this); | |
| if (1 < length) { | |
| /** @type {number} */ | |
| size = Math.ceil(this.a.length / length); | |
| /** @type {number} */ | |
| i = (dq(this.b) ? this.g : this.a).findIndex(this.oa) - size; | |
| if (0 > i) { | |
| /** @type {number} */ | |
| i = i + length * size; | |
| } | |
| if (i >= this.a.length) { | |
| /** @type {number} */ | |
| i = i - size; | |
| } | |
| this.a[i].j().focus(); | |
| key.preventDefault(); | |
| } | |
| } | |
| break; | |
| default: | |
| this.Z(key); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} params | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| var uF = function(params, type) { | |
| var node = eg(document); | |
| if (node) { | |
| var stop = params.a.find(function(options) { | |
| return "auto" === options.code; | |
| }); | |
| var piv = params.a.find(function(settings) { | |
| return "auto" !== settings.code; | |
| }); | |
| var el = node; | |
| for (;;) { | |
| if (!(el = stop && el === stop.j() ? piv.j() : el.nextElementSibling)) { | |
| el = !dq(params.b) && stop ? stop.j() : node.parentElement.children[0]; | |
| } | |
| if (el === node) { | |
| break; | |
| } | |
| if (0 <= el.tabIndex && dq(el)) { | |
| el.focus(); | |
| type.preventDefault(); | |
| break; | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} params | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| var vF = function(params, type) { | |
| var node = eg(document); | |
| if (node) { | |
| var stop = params.a.find(function(options) { | |
| return "auto" === options.code; | |
| }); | |
| var piv = sb(params.a, function(settings) { | |
| return "auto" !== settings.code; | |
| }); | |
| var el = node; | |
| for (;;) { | |
| if (!(el = stop && el === stop.j() ? piv.j() : el.previousElementSibling)) { | |
| el = !dq(params.b) && stop ? stop.j() : jb(node.parentElement.children); | |
| } | |
| if (el === node) { | |
| break; | |
| } | |
| if (0 <= el.tabIndex && dq(el)) { | |
| el.focus(); | |
| type.preventDefault(); | |
| break; | |
| } | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {string} params | |
| * @return {?} | |
| */ | |
| var tF = function(params) { | |
| if (dq(params.b)) { | |
| return params = params.g.find(function(val) { | |
| return dq(val.j()); | |
| }), null != params ? params : null; | |
| } | |
| var options = jb(params.a); | |
| return "auto" === options.code ? options : params.a[0]; | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {undefined} | |
| */ | |
| pF.prototype.Z = function(type) { | |
| if (!(rF(this) || !Vg(type.keyCode) || type.altKey || type.ctrlKey || type.metaKey)) { | |
| EB(this); | |
| CB(this).focus(); | |
| } | |
| }; | |
| /** | |
| * @param {?} a | |
| * @param {?} b | |
| * @param {?} expression | |
| * @param {number} compiler | |
| * @return {undefined} | |
| */ | |
| var wF = function(a, b, expression, compiler) { | |
| this.Ca = a; | |
| this.Pa = b; | |
| this.Ae = expression; | |
| /** @type {number} */ | |
| this.c = compiler; | |
| /** @type {null} */ | |
| this.b = this.a = null; | |
| }; | |
| /** | |
| * @param {number} a | |
| * @return {undefined} | |
| */ | |
| var xF = function(a) { | |
| /** @type {number} */ | |
| this.a = a; | |
| hm.N(); | |
| }; | |
| /** | |
| * @param {!Function} _$$mdAnimate_ | |
| * @return {undefined} | |
| */ | |
| var yF = function(_$$mdAnimate_) { | |
| ry("TranslationStarred", function(isFront, isBgroundImg) { | |
| isBgroundImg = isFront ? new xF(isBgroundImg) : null; | |
| if (_$$mdAnimate_) { | |
| _$$mdAnimate_(isFront, isBgroundImg); | |
| } | |
| }); | |
| }; | |
| /** | |
| * @param {(number|string)} variables | |
| * @param {string} type | |
| * @param {!Object} a | |
| * @param {string} h | |
| * @param {!Function} b | |
| * @return {undefined} | |
| */ | |
| var zF = function(variables, type, a, h, b) { | |
| wy(variables.a, type, a, h, 0, b); | |
| }; | |
| /** | |
| * @param {number} y | |
| * @param {number} w | |
| * @param {(Object|string)} o | |
| * @param {!Array} m | |
| * @return {undefined} | |
| */ | |
| var AF = function(y, w, o, m) { | |
| /** @type {number} */ | |
| this.a = y; | |
| /** @type {number} */ | |
| this.w = w; | |
| /** @type {(Object|string)} */ | |
| this.o = o; | |
| this.h = "AUTO" === this.o.toUpperCase() && w.src ? w.src : null; | |
| /** @type {!Array} */ | |
| this.m = m; | |
| this.b = this.fb(); | |
| /** @type {null} */ | |
| this.g = this.c = null; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| AF.prototype.fb = function() { | |
| return Pu(this.w); | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| AF.prototype.Ua = function() { | |
| return this.o; | |
| }; | |
| /** | |
| * @param {!Object} obj | |
| * @return {?} | |
| */ | |
| var BF = function(obj) { | |
| return "AUTO" === obj.o.toUpperCase() && null != obj.h ? obj.h : obj.o; | |
| }; | |
| /** | |
| * @return {?} | |
| */ | |
| AF.prototype.qa = function() { | |
| return this.m; | |
| }; | |
| /** | |
| * @param {!Object} options | |
| * @param {number} args | |
| * @return {undefined} | |
| */ | |
| var CF = function(options, args) { | |
| /** @type {number} */ | |
| options.w = args; | |
| options.b = options.fb(); | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {number} b | |
| * @return {undefined} | |
| */ | |
| var DF = function(a, b) { | |
| if (!xc(a.b)) { | |
| /** @type {number} */ | |
| a.b = b; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} a | |
| * @param {!Object} b | |
| * @return {?} | |
| */ | |
| var EF = function(a, b) { | |
| return a.a === b.a && a.b === b.b && BF(a) === BF(b) && a.qa() === b.qa(); | |
| }; | |
| /** | |
| * @param {!Object} b | |
| * @param {string} a | |
| * @return {?} | |
| */ | |
| var FF = function(b, a) { | |
| var inventoryKeys = b.a.toLowerCase(); | |
| b = b.fb().toLowerCase(); | |
| a = a.toLowerCase(); | |
| return inventoryKeys.includes(a) || b.includes(a); | |
| }; | |
| /** | |
| * @param {!Object} res | |
| * @return {?} | |
| */ | |
| var GF = function(res) { | |
| return res.fb() !== res.b; | |
| }; | |
| /** | |
| * @param {!Object} data | |
| * @return {?} | |
| */ | |
| var HF = function(data) { | |
| /** @type {*} */ | |
| var result = JSON.parse(JSON.stringify(data.w)); | |
| z(result instanceof Object, "Translation result isn't JSON"); | |
| result = new AF(data.a, result, data.o, data.m); | |
| if (null != data.c) { | |
| result.c = data.c; | |
| } | |
| if (null != data.g) { | |
| result.g = data.g; | |
| } | |
| if (null != data.h) { | |
| result.h = data.h; | |
| } | |
| DF(result, data.b); | |
| return result; | |
| }; | |
| /** | |
| * @param {number} resultTrue | |
| * @return {?} | |
| */ | |
| var IF = function(resultTrue) { | |
| return 1 == resultTrue % 10 && 11 != resultTrue % 100 ? "one" : 2 == resultTrue % 10 && 12 != resultTrue % 100 ? "two" : 3 == resultTrue % 10 && 13 != resultTrue % 100 ? "few" : "other"; | |
| }; | |
| /** @type {function(number): ?} */ | |
| var JF = IF; | |
| /** @type {function(number): ?} */ | |
| JF = IF; | |
| /** | |
| * @param {string} b | |
| * @param {?} a | |
| * @return {?} | |
| */ | |
| var KF = function(b, a) { | |
| if (void 0 === a) { | |
| /** @type {string} */ | |
| a = b + ""; | |
| /** @type {number} */ | |
| var ol = a.indexOf("."); | |
| /** @type {number} */ | |
| a = Math.min(-1 == ol ? 0 : a.length - ol - 1, 3); | |
| } | |
| return 1 == (b | 0) && 0 == a ? "one" : "other"; | |
| }; | |
| /** @type {function(string, ?): ?} */ | |
| var LF = KF; | |
| /** @type {function(string, ?): ?} */ | |
| LF = KF; | |
| /** | |
| * @param {string} g | |
| * @return {undefined} | |
| */ | |
| var PF = function(g) { | |
| /** @type {string} */ | |
| this.g = g; | |
| /** @type {null} */ | |
| this.b = this.a = this.h = null; | |
| g = Zu; | |
| var b = Wu; | |
| if (MF !== g || NF !== b) { | |
| /** @type {string} */ | |
| MF = g; | |
| NF = b; | |
| OF = new bv(1); | |
| } | |
| this.o = OF; | |
| }; | |
| /** @type {null} */ | |
| var MF = null; | |
| /** @type {null} */ | |
| var NF = null; | |
| /** @type {null} */ | |
| var OF = null; | |
| /** @type {!RegExp} */ | |
| var QF = /'([{}#].*?)'/g; | |
| /** @type {!RegExp} */ | |
| var RF = /''/g; | |
| /** | |
| * @param {!Object} obj | |
| * @param {string} indent | |
| * @return {?} | |
| */ | |
| var SF = function(obj, indent) { | |
| return ew(obj, indent); | |
| }; | |
| /** | |
| * @param {!Object} d | |
| * @param {string} str | |
| * @return {?} | |
| */ | |
| var ew = function(d, str) { | |
| d.lf(); | |
| if (!d.b || 0 == d.b.length) { | |
| return ""; | |
| } | |
| d.a = Ab(d.h); | |
| /** @type {!Array} */ | |
| var c = []; | |
| TF(d, d.b, str, false, c); | |
| /** @type {string} */ | |
| str = c.join(""); | |
| z(-1 == str.search("#"), "Not all # were replaced."); | |
| for (; 0 < d.a.length;) { | |
| /** @type {string} */ | |
| str = str.replace(d.c(d.a), d.a.pop()); | |
| } | |
| return str; | |
| }; | |
| /** | |
| * @param {!Object} id | |
| * @param {!NodeList} m | |
| * @param {!Object} d | |
| * @param {boolean} _ | |
| * @param {!Object} a | |
| * @return {undefined} | |
| */ | |
| var TF = function(id, m, d, _, a) { | |
| /** @type {number} */ | |
| var k = 0; | |
| for (; k < m.length; k++) { | |
| switch(m[k].type) { | |
| case 4: | |
| a.push(m[k].value); | |
| break; | |
| case 3: | |
| var n = m[k].value; | |
| /** @type {!Object} */ | |
| var node = id; | |
| /** @type {!Object} */ | |
| var result = a; | |
| var s = d[n]; | |
| if (q(s)) { | |
| node.a.push(s); | |
| result.push(node.c(node.a)); | |
| } else { | |
| result.push("Undefined parameter - " + n); | |
| } | |
| break; | |
| case 2: | |
| n = m[k].value; | |
| /** @type {!Object} */ | |
| node = id; | |
| /** @type {!Object} */ | |
| result = d; | |
| /** @type {boolean} */ | |
| s = _; | |
| /** @type {!Object} */ | |
| var s1 = a; | |
| var i = n.yf; | |
| if (q(result[i])) { | |
| i = n[result[i]]; | |
| if (!q(i)) { | |
| i = n.other; | |
| eb(i, "Invalid option or missing other option for select block."); | |
| } | |
| TF(node, i, result, s, s1); | |
| } else { | |
| s1.push("Undefined parameter - " + i); | |
| } | |
| break; | |
| case 0: | |
| n = m[k].value; | |
| UF(id, n, d, LF, _, a); | |
| break; | |
| case 1: | |
| n = m[k].value; | |
| UF(id, n, d, JF, _, a); | |
| break; | |
| default: | |
| Za("Unrecognized block type: " + m[k].type); | |
| } | |
| } | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @param {string} res | |
| * @param {!Object} s | |
| * @param {string} key | |
| * @param {boolean} items | |
| * @param {!Object} fields | |
| * @return {undefined} | |
| */ | |
| var UF = function(value, res, s, key, items, fields) { | |
| var i = res.yf; | |
| var h = res.Hi; | |
| /** @type {number} */ | |
| var top = +s[i]; | |
| if (isNaN(top)) { | |
| fields.push("Undefined or invalid parameter - " + i); | |
| } else { | |
| /** @type {number} */ | |
| h = top - h; | |
| i = res[s[i]]; | |
| if (!q(i)) { | |
| z(0 <= h, "Argument index smaller than offset."); | |
| key = key(h); | |
| bb(key, "Invalid plural key."); | |
| i = res[key]; | |
| if (!q(i)) { | |
| i = res.other; | |
| } | |
| eb(i, "Invalid option or missing other option for plural block."); | |
| } | |
| /** @type {!Array} */ | |
| res = []; | |
| TF(value, i, s, items, res); | |
| /** @type {string} */ | |
| s = res.join(""); | |
| bb(s, "Empty block in plural."); | |
| if (items) { | |
| fields.push(s); | |
| } else { | |
| value = kv(value.o, h); | |
| fields.push(s.replace(/#/g, value)); | |
| } | |
| } | |
| }; | |
| /** | |
| * @return {undefined} | |
| */ | |
| PF.prototype.lf = function() { | |
| if (this.g) { | |
| /** @type {!Array} */ | |
| this.h = []; | |
| var min = VF(this, this.g); | |
| this.b = WF(this, min); | |
| /** @type {null} */ | |
| this.g = null; | |
| } | |
| }; | |
| /** | |
| * @param {!Object} value | |
| * @param {string} opt_pass | |
| * @return {?} | |
| */ | |
| var VF = function(value, opt_pass) { | |
| var left = value.h; | |
| var c = v(value.c, value); | |
| opt_pass = opt_pass.replace(RF, function() { | |
| left.push("'"); | |
| return c(left); | |
| }); | |
| return opt_pass = opt_pass.replace(QF, function(canCreateDiscussions, merge) { | |
| left.push(merge); | |
| return c(left); | |
| }); | |
| }; | |
| /** | |
| * @param {string} x | |
| * @return {?} | |
| */ | |
| var XF = function(x) { | |
| /** @type {number} */ | |
| var s = 0; | |
| /** @type {!Array} */ | |
| var deadPool = []; | |
| /** @type {!Array} */ | |
| var d = []; | |
| /** @type {!RegExp} */ | |
| var e = /[{}]/g; | |
| /** @type {number} */ | |
| e.lastIndex = 0; | |
| var o; | |
| for (; o = e.exec(x);) { | |
| /** @type {number} */ | |
| var i = o.index; | |
| if ("}" == o[0]) { | |
| o = deadPool.pop(); | |
| z(q(o) && "{" == o, "No matching { for }."); | |
| if (0 == deadPool.length) { | |
| o = { | |
| type : 1 | |
| }; | |
| o.value = x.substring(s, i); | |
| d.push(o); | |
| /** @type {number} */ | |
| s = i + 1; | |
| } | |
| } else { | |
| if (0 == deadPool.length) { | |
| s = x.substring(s, i); | |
| if ("" != s) { | |
| d.push({ | |
| type : 0, | |
| value : s | |
| }); | |
| } | |
| /** @type {number} */ | |
| s = i + 1; | |
| } | |
| deadPool.push("{"); | |
| } | |
| } | |
| z(0 == deadPool.length, "There are mismatched { or } in the pattern."); | |
| s = x.substring(s); | |
| if ("" != s) { | |
| d.push({ | |
| type : 0, | |
| value : s | |
| }); | |
| } | |
| return d; | |
| }; | |
| /** @type {!RegExp} */ | |
| var YF = /^\s*(\w+)\s*,\s*plural\s*,(?:\s*offset:(\d+))?/; | |
| /** @type {!RegExp} */ | |
| var ZF = /^\s*(\w+)\s*,\s*selectordinal\s*,/; | |
| /** @type {!RegExp} */ | |
| var $F = /^\s*(\w+)\s*,\s*select\s*,/; | |
| /** | |
| * @param {?} data | |
| * @param {string} opts | |
| * @return {?} | |
| */ | |
| var WF = function(data, opts) { | |
| /** @type {!Array} */ | |
| var formsFound = []; | |
| opts = XF(opts); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < opts.length; i++) { | |
| var form = {}; | |
| if (0 == opts[i].type) { | |
| /** @type {number} */ | |
| form.type = 4; | |
| form.value = opts[i].value; | |
| } else { | |
| if (1 == opts[i].type) { | |
| var f = opts[i].value; | |
| switch(YF.test(f) ? 0 : ZF.test(f) ? 1 : $F.test(f) ? 2 : /^\s*\w+\s*/.test(f) ? 3 : 5) { | |
| case 2: | |
| /** @type {number} */ | |
| form.type = 2; | |
| form.value = aG(data, opts[i].value); | |
| break; | |
| case 0: | |
| /** @type {number} */ | |
| form.type = 0; | |
| form.value = bG(data, opts[i].value); | |
| break; | |
| case 1: | |
| /** @type {number} */ | |
| form.type = 1; | |
| form.value = cG(data, opts[i].value); | |
| break; | |
| case 3: | |
| /** @type {number} */ | |
| form.type = 3; | |
| form.value = opts[i].value; | |
| break; | |
| default: | |
| Za("Unknown block type for pattern: " + opts[i].value); | |
| } | |
| } else { | |
| Za("Unknown part of the pattern."); | |
| } | |
| } | |
| formsFound.push(form); | |
| } | |
| return formsFound; | |
| }; | |
| /** | |
| * @param {?} message | |
| * @param {string} e | |
| * @return {?} | |
| */ | |
| var aG = function(message, e) { | |
| /** @type {string} */ | |
| var c = ""; | |
| e = e.replace($F, function(canCreateDiscussions, savedC) { | |
| /** @type {string} */ | |
| c = savedC; | |
| return ""; | |
| }); | |
| var entities = {}; | |
| entities.yf = c; | |
| e = XF(e); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < e.length;) { | |
| var b = e[i].value; | |
| bb(b, "Missing select key element."); | |
| i++; | |
| z(i < e.length, "Missing or invalid select value element."); | |
| if (1 == e[i].type) { | |
| var predicate = WF(message, e[i].value); | |
| } else { | |
| Za("Expected block type."); | |
| } | |
| entities[b.replace(/\s/g, "")] = predicate; | |
| i++; | |
| } | |
| eb(entities.other, "Missing other key in select statement."); | |
| return entities; | |
| }; | |
| /** | |
| * @param {?} str | |
| * @param {string} a | |
| * @return {?} | |
| */ | |
| var bG = function(str, a) { | |
| /** @type {string} */ | |
| var c = ""; | |
| /** @type {number} */ | |
| var hex = 0; | |
| a = a.replace(YF, function(canCreateDiscussions, n, obj) { | |
| /** @type {string} */ | |
| c = n; | |
| if (obj) { | |
| /** @type {number} */ | |
| hex = parseInt(obj, 10); | |
| } | |
| return ""; | |
| }); | |
| var result = {}; | |
| result.yf = c; | |
| result.Hi = hex; | |
| a = XF(a); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < a.length;) { | |
| var coords = a[i].value; | |
| bb(coords, "Missing plural key element."); | |
| i++; | |
| z(i < a.length, "Missing or invalid plural value element."); | |
| if (1 == a[i].type) { | |
| var h = WF(str, a[i].value); | |
| } else { | |
| Za("Expected block type."); | |
| } | |
| result[coords.replace(/\s*(?:=)?(\w+)\s*/, "$1")] = h; | |
| i++; | |
| } | |
| eb(result.other, "Missing other key in plural statement."); | |
| return result; | |
| }; | |
| /** | |
| * @param {?} message | |
| * @param {string} path | |
| * @return {?} | |
| */ | |
| var cG = function(message, path) { | |
| /** @type {string} */ | |
| var c = ""; | |
| path = path.replace(ZF, function(canCreateDiscussions, savedC) { | |
| /** @type {string} */ | |
| c = savedC; | |
| return ""; | |
| }); | |
| var result = {}; | |
| result.yf = c; | |
| /** @type {number} */ | |
| result.Hi = 0; | |
| path = XF(path); | |
| /** @type {number} */ | |
| var i = 0; | |
| for (; i < path.length;) { | |
| var coords = path[i].value; | |
| bb(coords, "Missing ordinal key element."); | |
| i++; | |
| z(i < path.length, "Missing or invalid ordinal value element."); | |
| if (1 == path[i].type) { | |
| var stashSha = WF(message, path[i].value); | |
| } else { | |
| Za("Expected block type."); | |
| } | |
| result[coords.replace(/\s*(?:=)?(\w+)\s*/, "$1")] = stashSha; | |
| i++; | |
| } | |
| eb(result.other, "Missing other key in selectordinal statement."); | |
| return result; | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @return {?} | |
| */ | |
| PF.prototype.c = function(type) { | |
| z(0 < type.length, "Literal array is empty."); | |
| return "\ufddf_" + (type.length - 1).toString(10) + "_"; | |
| }; | |
| /** | |
| * @param {number} canvas | |
| * @param {number} w | |
| * @param {?} s | |
| * @param {number} l | |
| * @return {undefined} | |
| */ | |
| var fG = function(canvas, w, s, l) { | |
| /** @type {number} */ | |
| this.T = canvas; | |
| /** @type {number} */ | |
| this.W = w; | |
| this.L = s; | |
| /** @type {number} */ | |
| this.b = l; | |
| this.F = M.N(); | |
| /** @type {number} */ | |
| this.G = 1E4; | |
| /** @type {number} */ | |
| this.h = 0; | |
| this.Ga = new bv("######"); | |
| this.R = new PF(DATA.TooManyPhrases); | |
| /** @type {null} */ | |
| this.o = null; | |
| /** @type {!Array} */ | |
| this.g = []; | |
| if ("openDatabase" in window) { | |
| /** @type {boolean} */ | |
| canvas = true; | |
| try { | |
| window.openDatabase("", "", "", 0); | |
| } catch (e) { | |
| /** @type {boolean} */ | |
| canvas = false; | |
| } | |
| } else { | |
| /** @type {boolean} */ | |
| canvas = false; | |
| } | |
| /** @type {number} */ | |
| this.c = canvas; | |
| /** @type {boolean} */ | |
| this.C = false; | |
| if (this.c) { | |
| dG(this); | |
| } | |
| this.w = new SE; | |
| /** @type {!Array} */ | |
| this.a = []; | |
| /** @type {boolean} */ | |
| this.m = false; | |
| eG(this); | |
| }; | |
| /** | |
| * @param {!Object} info | |
| * @return {undefined} | |
| */ | |
| var dG = function(info) { | |
| yF(function(followRedirect, res) { | |
| if (followRedirect && res) { | |
| /** @type {!Object} */ | |
| info.o = res; | |
| zF(info.o, null, null, null, function(canCreateDiscussions, value) { | |
| if (canCreateDiscussions) { | |
| info.g = mb(value, function(data) { | |
| return new wF(data.sl, data.tl, data.src, data.trg); | |
| }); | |
| info.g.reverse(); | |
| } | |
| /** @type {boolean} */ | |
| info.C = true; | |
| gG(info); | |
| }); | |
| } | |
| }); | |
| }; | |
| /** | |
| * @param {!Object} f | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| var hG = function(f, a) { | |
| if (dh(a, 6) && (a = Number(K(a, 6, "")))) { | |
| /** @type {string} */ | |
| f.G = a; | |
| } | |
| }; | |
| /** | |
| * @param {!Window} a | |
| * @return {undefined} | |
| */ | |
| var eG = function(a) { | |
| if (DATA.SignedIn) { | |
| a.w.Cb(function(advform) { | |
| return iG(a, advform); | |
| }, "", "", "", "", "1"); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} o | |
| * @return {undefined} | |
| */ | |
| var gG = function(o) { | |
| if ((!o.c || o.C) && o.m) { | |
| var n = o.F; | |
| N(n, Xl(n, 241, o.g.length)); | |
| n = o.F; | |
| N(n, Xl(n, 242, o.a.length)); | |
| n = {}; | |
| mm(o.b, "webapp", "stld", "b", (n.wc = o.g.length, n.gc = o.a.length, n)); | |
| n = o.g.concat(o.a); | |
| o.h = n.length; | |
| o.T(n); | |
| } | |
| }; | |
| /** | |
| * @param {!Object} f | |
| * @param {!Object} options | |
| * @param {number} number | |
| * @return {?} | |
| */ | |
| var jG = function(f, options, number) { | |
| if (f.c && !f.o) { | |
| return false; | |
| } | |
| var a = BF(options); | |
| var e = options.qa(); | |
| var t = options.a; | |
| /** | |
| * @return {undefined} | |
| */ | |
| var _render = function() { | |
| /** @type {boolean} */ | |
| var h = 0 === number; | |
| f.h += h ? 1 : -1; | |
| f.W(options, h); | |
| }; | |
| if (0 === number) { | |
| if (300 < t.length) { | |
| return f.L(DATA.PhraseTooLong), a = {}, mm(f.b, "webapp", "stlm", "l", (a.sz = t.length, a)), Wl(f.F, t.length), false; | |
| } | |
| if (f.h >= f.G) { | |
| return t = {}, mm(f.b, "webapp", "stlm", "n", (t.sz = f.h + 1, t)), Yl(f.F, f.h + 1), f.L(SF(f.R, { | |
| saved_phrase_limit : kv(f.Ga, f.G) | |
| })), false; | |
| } | |
| UE(f.w, v(f.O, f, options, _render), a, e, t, options.b, GF(options)); | |
| } else { | |
| if (1 == number) { | |
| if (null != options.c) { | |
| VE(f.w, v(f.K, f, options, _render), [options.c]); | |
| } else { | |
| if (f.c) { | |
| ty(f.o.a, a, e, t, _render); | |
| } | |
| } | |
| } else { | |
| throw "Unexpected operation"; | |
| } | |
| } | |
| return true; | |
| }; | |
| /** | |
| * @param {!Object} type | |
| * @param {string} value | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| fG.prototype.O = function(type, value, a) { | |
| hG(this, a); | |
| if (a && !K(a, 3) && K(a, 5)) { | |
| type.c = K(a, 5); | |
| /** @type {number} */ | |
| type.g = Number(K(a, 4, "")); | |
| var obj = {}; | |
| obj.trans = type.b; | |
| obj = { | |
| sentences : [obj] | |
| }; | |
| type = new wF(BF(type), type.qa(), type.a, obj); | |
| type.a = K(a, 5); | |
| type.b = oe(K(a, 4, "")); | |
| this.a.push(type); | |
| value(true); | |
| } else { | |
| mm(this.b, "webapp", "stfl", "a"); | |
| Ol(this.F, 151); | |
| } | |
| }; | |
| /** | |
| * @param {?} type | |
| * @param {string} value | |
| * @param {string} a | |
| * @return {undefined} | |
| */ | |
| fG.prototype.K = function(type, value, a) { | |
| hG(this, a); | |
| if (a && !K(a, 3)) { | |
| mm(this.b, "webapp", "stsu", "d"); | |
| a = this.F; | |
| N(a, O(a, 234)); | |
| type = kG(this, type); | |
| if (-1 === type) { | |
| mm(this.b, "webapp", "stfl", "u"); | |
| Ol(this.F, 154); | |
| } else { | |
| mm(this.b, "webapp", "stsu", "u"); | |
| a = this.F; | |
| N(a, O(a, 235)); | |
| Db(this.a, type, 1); | |
| } | |
| value(true); | |
| } else { | |
| mm(this.b, "webapp", "stfl", "d"); | |
| O |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment