Created
May 8, 2015 10:32
-
-
Save HillLiu/af1b6e632b9d083eef4b to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
if (!window["googleNDT_"]) { | |
/** @type {number} */ | |
window["googleNDT_"] = (new Date).getTime(); | |
} | |
/** @type {number} */ | |
window["_googCsaX"] = 4; | |
/** @type {number} */ | |
window._googCsaRelSearch = 2631661; | |
/** @type {number} */ | |
window.googleGws = 1; | |
(function() { | |
/** | |
* @param {?} str | |
* @return {?} | |
*/ | |
function getComputedStyle(str) { | |
return parseFloat(str.replace("px", "")) || 0; | |
} | |
/** | |
* @param {string} obj | |
* @param {boolean} recurring | |
* @return {?} | |
*/ | |
function setShortStyleProperty(obj, recurring) { | |
if ("string" == typeof obj) { | |
/** @type {(HTMLElement|null)} */ | |
obj = document.getElementById(obj); | |
} | |
var current = document.defaultView || {}; | |
var subtract = recurring ? obj.offsetHeight : obj.offsetWidth; | |
/** @type {Array} */ | |
var tokens = recurring ? ["Top", "Bottom"] : ["Right", "Left"]; | |
var resolveValues; | |
/** @type {Array} */ | |
resolveValues = setFillAndStroke() ? ["margin"] : ["border", "margin", "padding"]; | |
/** @type {number} */ | |
var length = resolveValues.length; | |
/** @type {number} */ | |
var nTokens = tokens.length; | |
if (current && current.getComputedStyle) { | |
var computedStyle = current.getComputedStyle(obj, false); | |
/** @type {number} */ | |
current = 0; | |
for (;current < length;current++) { | |
/** @type {number} */ | |
var ti = 0; | |
for (;ti < nTokens;ti++) { | |
subtract += getComputedStyle(computedStyle.getPropertyValue([resolveValues[current], tokens[ti].toLowerCase()].join("-"))); | |
} | |
} | |
} else { | |
computedStyle = obj.currentStyle; | |
if (!setFillAndStroke()) { | |
/** @type {number} */ | |
ti = 0; | |
for (;ti < nTokens;ti++) { | |
subtract += getComputedStyle(computedStyle[["border", tokens[ti], "Width"].join("")]); | |
} | |
} | |
/** @type {number} */ | |
current = 0; | |
for (;current < length;current++) { | |
if ("border" != resolveValues[current]) { | |
/** @type {number} */ | |
ti = 0; | |
for (;ti < nTokens;ti++) { | |
subtract += getComputedStyle(computedStyle[[resolveValues[current], tokens[ti]].join("")]); | |
} | |
} | |
} | |
} | |
return subtract; | |
} | |
/** @type {number} */ | |
window.googleAltLoader = 4; | |
/** @type {string} */ | |
var io = "3.0"; | |
/** @type {string} */ | |
var xformed = "8180cc552d14dcbcfafe6ec1162573e3bc809143"; | |
/** @type {string} */ | |
var offset = "ads"; | |
/** @type {string} */ | |
var SNAP_VERSION = "search"; | |
/** @type {string} */ | |
var firstByIndex = "//ajax.googleapis.com/ajax"; | |
/** @type {string} */ | |
var opts = "//www.google.com/uds"; | |
/** @type {string} */ | |
var name = "www.google.com"; | |
var p; | |
var global = this; | |
/** | |
* @param {?} value | |
* @return {?} | |
*/ | |
var isArray = 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 isFunction = Object.prototype.toString.call(value); | |
if ("[object Window]" == isFunction) { | |
return "object"; | |
} | |
if ("[object Array]" == isFunction || "number" == typeof value.length && ("undefined" != typeof value.splice && ("undefined" != typeof value.propertyIsEnumerable && !value.propertyIsEnumerable("splice")))) { | |
return "array"; | |
} | |
if ("[object Function]" == isFunction || "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 {string} depth | |
* @return {?} | |
*/ | |
var spaces = function(depth) { | |
return null != depth; | |
}; | |
/** | |
* @param {?} arg | |
* @return {?} | |
*/ | |
var isObject = function(arg) { | |
return "string" == typeof arg; | |
}; | |
/** | |
* @param {Function} fn | |
* @param {Object} obj | |
* @param {?} exports | |
* @return {?} | |
*/ | |
var program = function(fn, obj, exports) { | |
return fn.call.apply(fn.bind, arguments); | |
}; | |
/** | |
* @param {Function} fn | |
* @param {Object} obj | |
* @param {?} $var_args$$ | |
* @return {?} | |
*/ | |
var $goog$bindJs_$ = function(fn, obj, $var_args$$) { | |
if (!fn) { | |
throw Error(); | |
} | |
if (2 < arguments.length) { | |
/** @type {Array.<?>} */ | |
var args = Array.prototype.slice.call(arguments, 2); | |
return function() { | |
/** @type {Array.<?>} */ | |
var newArgs = Array.prototype.slice.call(arguments); | |
Array.prototype.unshift.apply(newArgs, args); | |
return fn.apply(obj, newArgs); | |
}; | |
} | |
return function() { | |
return fn.apply(obj, arguments); | |
}; | |
}; | |
/** | |
* @param {Function} dataAndEvents | |
* @param {Object} obj | |
* @param {?} bytesRead | |
* @return {?} | |
*/ | |
var wrapper = function(dataAndEvents, obj, bytesRead) { | |
/** @type {function (Function, Object, ?): ?} */ | |
wrapper = Function.prototype.bind && -1 != Function.prototype.bind.toString().indexOf("native code") ? program : $goog$bindJs_$; | |
return wrapper.apply(null, arguments); | |
}; | |
/** | |
* @param {Function} fn | |
* @param {Function} name | |
* @return {?} | |
*/ | |
var defer = function(fn, name) { | |
/** @type {Array.<?>} */ | |
var args = Array.prototype.slice.call(arguments, 1); | |
return function() { | |
/** @type {Array.<?>} */ | |
var newArgs = args.slice(); | |
newArgs.push.apply(newArgs, arguments); | |
return fn.apply(this, newArgs); | |
}; | |
}; | |
/** @type {function (): number} */ | |
var _randomVal = Date.now || function() { | |
return+new Date; | |
}; | |
/** | |
* @param {Function} obj | |
* @param {Function} type | |
* @return {undefined} | |
*/ | |
var isPlainObject = function(obj, type) { | |
/** | |
* @return {undefined} | |
*/ | |
function Fn() { | |
} | |
Fn.prototype = type.prototype; | |
obj.pk = type.prototype; | |
obj.prototype = new Fn; | |
/** @type {Function} */ | |
obj.prototype.constructor = obj; | |
/** | |
* @param {?} opt_context | |
* @param {?} method | |
* @param {?} dataAndEvents | |
* @return {?} | |
*/ | |
obj.jk = function(opt_context, method, dataAndEvents) { | |
/** @type {Array} */ | |
var args = Array(arguments.length - 2); | |
/** @type {number} */ | |
var i = 2; | |
for (;i < arguments.length;i++) { | |
args[i - 2] = arguments[i]; | |
} | |
return type.prototype[method].apply(opt_context, args); | |
}; | |
}; | |
/** @type {function (this:Function, (Object|null|undefined), ...[*]): Function} */ | |
Function.prototype.bind = Function.prototype.bind || function(walkers, dataAndEvents) { | |
if (1 < arguments.length) { | |
/** @type {Array.<?>} */ | |
var args = Array.prototype.slice.call(arguments, 1); | |
args.unshift(this, walkers); | |
return wrapper.apply(null, args); | |
} | |
return wrapper(this, walkers); | |
}; | |
/** @type {Array} */ | |
var codeSegments = ["iPhone OS 5_", "iPhone OS 4_", "SC-02C Build/GINGERBREAD"]; | |
/** @type {string} */ | |
var ua = window.navigator ? window.navigator.userAgent : ""; | |
/** | |
* @return {?} | |
*/ | |
var createTextNode = function() { | |
return 5 == rgbToHex(newRed) || (6 == rgbToHex(newRed) || 7 == rgbToHex(newRed)); | |
}; | |
/** @type {RegExp} */ | |
var newRed = /MSIE\s+(\d+)\./; | |
/** @type {RegExp} */ | |
var r = /Opera\/.*Version\/(\d+)\./; | |
/** @type {RegExp} */ | |
var elems = /Firefox\/(\d+)\./; | |
/** @type {RegExp} */ | |
var angle = /Version\/(\d+)\..*Safari/; | |
/** | |
* @param {Object} r | |
* @return {?} | |
*/ | |
var rgbToHex = function(r) { | |
r = (r = r.exec(ua)) ? r[1] : ""; | |
return 0 < r.length && (r = parseInt(r, 10)) ? r : null; | |
}; | |
/** | |
* @return {?} | |
*/ | |
var endsWith = function() { | |
/** @type {number} */ | |
var i = 0; | |
for (;i < codeSegments.length;i++) { | |
if (-1 != ua.indexOf(codeSegments[i])) { | |
return true; | |
} | |
} | |
return false; | |
}; | |
/** | |
* @param {string} text | |
* @return {?} | |
*/ | |
var trim = function(text) { | |
/** @type {string} */ | |
text = String(text); | |
if (/^\s*$/.test(text) ? 0 : /^[\],:{}\s\u2028\u2029]*$/.test(text.replace(/\\["\\\/bfnrtu]/g, "@").replace(/"[^"\\\n\r\u2028\u2029\x00-\x08\x0a-\x1f]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, "]").replace(/(?:^|:|,)(?:[\s\u2028\u2029]*\[)+/g, ""))) { | |
try { | |
return eval("(" + text + ")"); | |
} catch (b) { | |
} | |
} | |
throw Error("Invalid JSON string: " + text); | |
}; | |
/** | |
* @return {undefined} | |
*/ | |
var ke = function() { | |
this.zd = void 0; | |
}; | |
/** | |
* @param {?} options | |
* @param {Object} value | |
* @param {Array} ret | |
* @return {undefined} | |
*/ | |
var walk = function(options, value, ret) { | |
if (null == value) { | |
ret.push("null"); | |
} else { | |
if ("object" == typeof value) { | |
if ("array" == isArray(value)) { | |
/** @type {Object} */ | |
var text = value; | |
value = text.length; | |
ret.push("["); | |
/** @type {string} */ | |
var c = ""; | |
/** @type {number} */ | |
var j = 0; | |
for (;j < value;j++) { | |
ret.push(c); | |
c = text[j]; | |
walk(options, options.zd ? options.zd.call(text, String(j), c) : c, ret); | |
/** @type {string} */ | |
c = ","; | |
} | |
ret.push("]"); | |
return; | |
} | |
if (value instanceof String || (value instanceof Number || value instanceof Boolean)) { | |
/** @type {*} */ | |
value = value.valueOf(); | |
} else { | |
ret.push("{"); | |
/** @type {string} */ | |
j = ""; | |
for (text in value) { | |
if (Object.prototype.hasOwnProperty.call(value, text)) { | |
c = value[text]; | |
if ("function" != typeof c) { | |
ret.push(j); | |
encode(text, ret); | |
ret.push(":"); | |
walk(options, options.zd ? options.zd.call(value, text, c) : c, ret); | |
/** @type {string} */ | |
j = ","; | |
} | |
} | |
} | |
ret.push("}"); | |
return; | |
} | |
} | |
switch(typeof value) { | |
case "string": | |
encode(value, ret); | |
break; | |
case "number": | |
ret.push(isFinite(value) && !isNaN(value) ? value : "null"); | |
break; | |
case "boolean": | |
ret.push(value); | |
break; | |
case "function": | |
break; | |
default: | |
throw Error("Unknown type: " + typeof value);; | |
} | |
} | |
}; | |
var flags = { | |
'"' : '\\"', | |
"\\" : "\\\\", | |
"/" : "\\/", | |
"\b" : "\\b", | |
"\f" : "\\f", | |
"\n" : "\\n", | |
"\r" : "\\r", | |
"\t" : "\\t", | |
"\x0B" : "\\u000b" | |
}; | |
/** @type {RegExp} */ | |
var nbspRegExp = /\uffff/.test("\uffff") ? /[\\\"\x00-\x1f\x7f-\uffff]/g : /[\\\"\x00-\x1f\x7f-\xff]/g; | |
/** | |
* @param {string} text | |
* @param {Array} string | |
* @return {undefined} | |
*/ | |
var encode = function(text, string) { | |
string.push('"', text.replace(nbspRegExp, function(key) { | |
var value = flags[key]; | |
if (!value) { | |
/** @type {string} */ | |
value = "\\u" + (key.charCodeAt(0) | 65536).toString(16).substr(1); | |
/** @type {string} */ | |
flags[key] = value; | |
} | |
return value; | |
}), '"'); | |
}; | |
/** | |
* @param {string} path | |
* @param {Object} imageElement | |
* @return {undefined} | |
*/ | |
var loadImage = function(path, imageElement) { | |
var source = imageElement || new Image; | |
source.onload = source.onerror = executeScript(source); | |
/** @type {string} */ | |
source.src = path; | |
}; | |
/** | |
* @param {Array} command | |
* @return {undefined} | |
*/ | |
var execCommand = function(command) { | |
/** @type {number} */ | |
var i = 0; | |
for (;i < command.length;i++) { | |
loadImage(command[i]); | |
} | |
}; | |
/** | |
* @param {Node} source | |
* @return {?} | |
*/ | |
var executeScript = function(source) { | |
return function() { | |
/** @type {null} */ | |
source.onload = source.onerror = null; | |
}; | |
}; | |
/** | |
* @param {?} n | |
* @param {?} num | |
* @return {undefined} | |
*/ | |
var plural = function(n, num) { | |
/** @type {number} */ | |
this.qc = Math.ceil(n); | |
/** @type {number} */ | |
this.oc = Math.floor(num); | |
}; | |
/** | |
* @return {?} | |
*/ | |
plural.prototype.da = function() { | |
return this.qc + "px - " + this.oc + "px"; | |
}; | |
/** | |
* @param {?} n | |
* @return {?} | |
*/ | |
plural.prototype.S = function(n) { | |
/** @type {number} */ | |
n = parseInt(n, 10); | |
return isNaN(n) ? null : Math.max(this.qc, Math.min(this.oc, n)); | |
}; | |
/** | |
* @param {string} c | |
* @return {?} | |
*/ | |
plural.prototype.ca = function(c) { | |
return this.S(c); | |
}; | |
/** @type {string} */ | |
var url_or_hash = (window._googCsaAlwaysHttps ? "https:" : "") + "//www.google.com/uds"; | |
/** @type {string} */ | |
var parameter = (window._googCsaAlwaysHttps ? "https:" : "") + "//ads.google.com/uds"; | |
/** @type {string} */ | |
var reqUrl = (window._googCsaAlwaysHttps ? "https:" : "") + "//afs.googlesyndication.com/uds"; | |
/** | |
* @return {?} | |
*/ | |
var onload = function() { | |
if ("undefined" != typeof gwsHost_) { | |
return gwsHost_; | |
} | |
if ("undefined" != typeof name) { | |
return(window._googCsaAlwaysHttps ? "https://" : "//") + name; | |
} | |
/** @type {string} */ | |
var url = ""; | |
if ("undefined" != typeof opts) { | |
/** @type {string} */ | |
url = opts; | |
} else { | |
if (window.google) { | |
if (window.google.loader) { | |
if (window.google.loader.ServiceBase) { | |
url = window.google.loader.ServiceBase; | |
} | |
} | |
} | |
} | |
if (1 == window.googleSynd) { | |
if (url == reqUrl) { | |
/** @type {string} */ | |
url = parameter; | |
} | |
} | |
/** @type {string} */ | |
url = url ? url : url_or_hash; | |
return url.match(/(.+)\/uds$/)[1]; | |
}; | |
/** | |
* @param {?} standalone | |
* @param {?} version | |
* @param {?} encoding | |
* @param {?} vn | |
* @param {?} dataAndEvents | |
* @return {undefined} | |
*/ | |
var XMLDeclaration = function(standalone, version, encoding, vn, dataAndEvents) { | |
this.fj = standalone; | |
this.lj = version; | |
this.Ui = encoding; | |
this.version = vn; | |
this.Ie = dataAndEvents; | |
}; | |
onload(); | |
var oSpace = {}; | |
/** | |
* @param {?} opt_attributes | |
* @param {string} str | |
* @return {?} | |
*/ | |
XMLDeclaration.prototype.log = function(opt_attributes, str) { | |
var n; | |
if (true === window.IS_GOOGLE_AFS_IFRAME_ && window.parent == window) { | |
/** @type {boolean} */ | |
n = false; | |
} else { | |
/** @type {string} */ | |
n = (window.google && (window.google.loader && window.google.loader.GoogleApisBase) ? window.google.loader.GoogleApisBase : firstByIndex ? firstByIndex : (window._googCsaAlwaysHttps ? "https:" : "") + "//ajax.googleapis.com/ajax") + "/services/js/error"; | |
var data = {}; | |
/** @type {string} */ | |
data.mn = this.fj + "." + this.lj; | |
data.vh = this.Ui; | |
data.v = this.version; | |
data.em = opt_attributes.message; | |
/** @type {string} */ | |
data.cem = str; | |
/** @type {Array} */ | |
var tagNameArr = []; | |
var name; | |
for (name in data) { | |
if (data.hasOwnProperty(name)) { | |
if (data[name]) { | |
tagNameArr.push([name, encodeURIComponent(data[name])].join("=")); | |
} | |
} | |
} | |
/** @type {Element} */ | |
data = document.createElement("img"); | |
/** @type {string} */ | |
n = n + "?" + tagNameArr.join("&"); | |
if (oSpace[n]) { | |
/** @type {boolean} */ | |
n = false; | |
} else { | |
/** @type {string} */ | |
data.src = [n, "&nc", (new Date).getTime()].join(""); | |
/** @type {boolean} */ | |
n = oSpace[n] = true; | |
} | |
} | |
return n; | |
}; | |
/** | |
* @param {Function} callback | |
* @param {string} obj | |
* @return {?} | |
*/ | |
var _handle = function(callback, obj) { | |
var options = util; | |
return function() { | |
/** @type {Array.<?>} */ | |
var err = Array.prototype.slice.call(arguments, 0) || []; | |
try { | |
return callback.apply(this, err); | |
} catch (backtrace) { | |
err = backtrace; | |
if ("string" == (typeof err).toLowerCase()) { | |
err = { | |
message : err | |
}; | |
} | |
var data = err.message; | |
if (obj) { | |
if (-1 == data.indexOf(options.Ie)) { | |
options.log(err, obj); | |
} | |
} | |
throw-1 != data.indexOf(options.Ie) ? data : options.Ie + data; | |
} | |
}; | |
}; | |
/** | |
* @param {string} fn | |
* @return {?} | |
*/ | |
var removeListener = function(fn) { | |
return "google.ads.search.Ads: " + fn; | |
}; | |
/** @type {string} */ | |
var expires = "unknown"; | |
if (window.google && window.google.ads) { | |
var err = window.google.ads; | |
if (err && err.LoadArgs) { | |
var results = err.LoadArgs.match(/file=([^&]*)/); | |
expires = results && results[1] ? results[1] : ""; | |
} else { | |
/** @type {string} */ | |
expires = ""; | |
} | |
} else { | |
if ("undefined" != typeof offset) { | |
/** @type {string} */ | |
expires = offset; | |
} | |
} | |
/** @type {string} */ | |
var version = "unknown"; | |
if (window.google && window.google.ads) { | |
var er = window.google.ads; | |
if (er && er.LoadArgs) { | |
var arr = er.LoadArgs.match(/packages=([^&]*)/); | |
version = arr && arr[1] ? arr[1] : ""; | |
} else { | |
/** @type {string} */ | |
version = ""; | |
} | |
} else { | |
if ("undefined" != typeof SNAP_VERSION) { | |
/** @type {string} */ | |
version = SNAP_VERSION; | |
} | |
} | |
/** @type {string} */ | |
var reason_start = "unknown"; | |
if (window.google && window.google.ads) { | |
reason_start = window.google.ads.JSHash; | |
} else { | |
if ("undefined" != typeof xformed) { | |
/** @type {string} */ | |
reason_start = xformed; | |
} | |
} | |
/** @type {string} */ | |
var play_context = "unknown"; | |
if (window.google && window.google.ads) { | |
play_context = window.google.ads.Version; | |
} else { | |
if ("undefined" != typeof io) { | |
/** @type {string} */ | |
play_context = io; | |
} | |
} | |
var util = new XMLDeclaration(expires, version, reason_start, play_context, "google.ads.search.Ads: "); | |
/** | |
* @param {Function} obj | |
* @param {string} value | |
* @return {?} | |
*/ | |
var cb = function(obj, value) { | |
return value ? _handle(obj, value) : _handle(obj); | |
}; | |
/** | |
* @param {string} match | |
* @return {undefined} | |
*/ | |
var token = function(match) { | |
/** @type {Array} */ | |
this.Fd = []; | |
/** @type {Array} */ | |
this.ce = []; | |
match = match.split("#"); | |
this.gg = match[0]; | |
/** @type {string} */ | |
this.ad = 1 < match.length ? decodeURI(match[1]) : ""; | |
/** @type {number} */ | |
this.maxLength = 1999; | |
}; | |
/** | |
* @param {?} object | |
* @param {string} data | |
* @param {number} msg | |
* @param {boolean} dataAndEvents | |
* @return {undefined} | |
*/ | |
var callback = function(object, data, msg, dataAndEvents) { | |
if (msg || (0 === msg || false === msg)) { | |
(dataAndEvents ? object.Fd : object.ce).push([encodeURIComponent(data), encodeURIComponent("" + msg)]); | |
} | |
}; | |
/** | |
* @param {?} options | |
* @return {?} | |
*/ | |
var require = function(options) { | |
var res = options.gg; | |
/** @type {boolean} */ | |
var c = -1 != options.gg.indexOf("?"); | |
var i; | |
/** @type {number} */ | |
i = 0; | |
for (;i < options.ce.length;i++) { | |
var number = (c ? "&" : "?") + options.ce[i].join("="); | |
if (number.length + res.length <= options.maxLength) { | |
res += number; | |
/** @type {boolean} */ | |
c = true; | |
} | |
} | |
/** @type {number} */ | |
i = 0; | |
for (;i < options.Fd.length;i++) { | |
if (options.Fd[i][0].length + 3 + res.length <= options.maxLength) { | |
res += (c ? "&" : "?") + options.Fd[i].join("="); | |
/** @type {boolean} */ | |
c = true; | |
} | |
} | |
res = res.substring(0, options.maxLength); | |
res = res.replace(/%\w?$/, ""); | |
if (options.ad) { | |
res += "#" + encodeURI(options.ad); | |
} | |
return res; | |
}; | |
/** @type {string} */ | |
var protocol = (window._googCsaAlwaysHttps ? "https:" : "") + "//www.google.com"; | |
/** @type {RegExp} */ | |
var ignore = /^https?:\/\//; | |
/** | |
* @param {string} path | |
* @return {?} | |
*/ | |
var resolveModule = function(path) { | |
return ignore.test(path) ? path : "/" == path.charAt(0) ? protocol + path : protocol + "/" + path; | |
}; | |
/** @type {RegExp} */ | |
var re = /\/aclk\?.*/; | |
var sorted = { | |
ads : 0, | |
plas : 1, | |
singleProduct : 2, | |
relatedsearch : 3 | |
}; | |
/** @type {string} */ | |
var ret = (window._googCsaAlwaysHttps ? "https:" : "") + "//www.google.com/csi?s=csa&v=3&action="; | |
/** @type {boolean} */ | |
var hasFocus = 42 == Math.floor(100 * Math.random()); | |
var items = {}; | |
/** | |
* @param {string} token | |
* @param {number} execAsap | |
* @return {undefined} | |
*/ | |
var handler = function(token, execAsap) { | |
this.Zg = execAsap || (new Date).getTime(); | |
/** @type {string} */ | |
this.action = token; | |
}; | |
/** | |
* @param {string} dataAndEvents | |
* @return {?} | |
*/ | |
handler.prototype.clone = function(dataAndEvents) { | |
return new handler(dataAndEvents, this.Zg); | |
}; | |
/** | |
* @param {Object} data | |
* @param {string} x | |
* @return {undefined} | |
*/ | |
var process = function(data, x) { | |
if (delta) { | |
if (hasFocus) { | |
items[data.action] = items[data.action] || []; | |
items[data.action].push([x, (new Date).getTime() - data.Zg].join(".")); | |
} | |
} | |
}; | |
/** | |
* @param {string} name | |
* @return {undefined} | |
*/ | |
var removeNode = function(name) { | |
var props = delta; | |
props.action = props.action ? props.action + ("," + name) : name; | |
}; | |
/** | |
* @return {undefined} | |
*/ | |
var restore = function() { | |
if (delta && (hasFocus && "//afs.googlesyndication.com" != onload())) { | |
var tests = items; | |
items = {}; | |
var testName; | |
for (testName in tests) { | |
if (tests.hasOwnProperty(testName)) { | |
var test = tests[testName]; | |
if (test) { | |
if (0 < test.length) { | |
loadImage([ret, testName, "&rt=", test.join(",")].join("")); | |
} | |
} | |
} | |
} | |
} | |
}; | |
/** @type {null} */ | |
var delta = null; | |
if (window._googCsa && window._googCsa.t) { | |
delta = new handler("ppla", window._googCsa.t); | |
} else { | |
if (window.googleNDT_ && !window.googleLT_) { | |
delta = new handler("pplnd", window.googleNDT_); | |
} else { | |
if (window.googleLT_) { | |
delta = new handler("pplal", window.googleLT_); | |
} | |
} | |
} | |
var arr2 = { | |
"google-hotels" : true | |
}; | |
var nb = window.caps_ && window.caps_.largeFonts; | |
/** @type {number} */ | |
var threshold = !window.IS_GOOGLE_AFS_IFRAME_ || nb ? 8 : 6; | |
/** @type {number} */ | |
var pageCount = !window.IS_GOOGLE_AFS_IFRAME_ || nb ? 24 : 16; | |
var ELEMENT_NODE = new plural(8, pageCount); | |
/** | |
* @param {Object} value | |
* @param {string} sel | |
* @return {?} | |
*/ | |
var matches = function(value, sel) { | |
var match = value.a.S(sel); | |
if (null == match && !value.K) { | |
throw removeListener(value.key + " has an invalid value. Valid input values: [" + value.a.da() + "]."); | |
} | |
return match; | |
}; | |
/** | |
* @param {Object} obj | |
* @param {Array} a | |
* @return {undefined} | |
*/ | |
var win = function(obj, a) { | |
/** @type {number} */ | |
var i = 0; | |
for (;i < a.length;i++) { | |
obj[a[i].key] = a[i]; | |
} | |
}; | |
/** | |
* @return {?} | |
*/ | |
var detect = function() { | |
var suiteView = randomName(); | |
var dateSQL = any(); | |
return isUndefined(suiteView, function(dataAndEvents, word) { | |
return dateSQL.hasOwnProperty(word); | |
}); | |
}; | |
/** | |
* @param {?} value | |
* @return {?} | |
*/ | |
var isFunction = function(value) { | |
/** @type {boolean} */ | |
var b = 8 == rgbToHex(newRed); | |
var hex = rgbToHex(r); | |
var isArray = rgbToHex(elems); | |
var c = rgbToHex(angle); | |
return!!(obj.S(value.waitForAds) && (!b && ((null == hex || 11 < hex) && ((null == isArray || 3 < isArray) && (null == c || 4 < c))))); | |
}; | |
/** | |
* @param {string} x | |
* @return {?} | |
*/ | |
var round = function(x) { | |
return(x = x.match(/slave-(\d+)-/)) ? parseInt(x[1], 10) + 1 : 1; | |
}; | |
/** | |
* @param {string} body | |
* @param {string} arg | |
* @param {Object} data | |
* @return {?} | |
*/ | |
var send = function(body, arg, data) { | |
/** @type {Array} */ | |
var _results = []; | |
/** @type {number} */ | |
var root = 0; | |
var item; | |
for (;item = data[root];root++) { | |
item = new token(item); | |
callback(item, body, arg); | |
_results.push(require(item)); | |
} | |
return _results; | |
}; | |
/** | |
* @param {Array} text | |
* @return {?} | |
*/ | |
var generate = function(text) { | |
/** @type {Array} */ | |
var _results = []; | |
/** @type {number} */ | |
var currentIndex = 0; | |
for (;currentIndex < text.length;currentIndex++) { | |
var view = new token(text[currentIndex]); | |
callback(view, "nc", [Math.round(9E6 * Math.random()), (new Date).getTime()].join("")); | |
_results.push(require(view)); | |
} | |
return _results; | |
}; | |
/** | |
* @param {Object} c | |
* @return {?} | |
*/ | |
var tmpl = function(c) { | |
var i = c.pubId; | |
return/^pub-.*/.test(i) || ("gcsc" in c || i in arr2); | |
}; | |
/** @type {null} */ | |
var readyList = null; | |
/** @type {null} */ | |
var all = null; | |
/** | |
* @param {string} from_instance | |
* @return {undefined} | |
*/ | |
var copy = function(from_instance) { | |
/** @type {string} */ | |
this.sessionId = from_instance; | |
this.state = {}; | |
/** @type {null} */ | |
this.Ka = null; | |
/** @type {boolean} */ | |
this.P = false; | |
}; | |
copy = cb(copy, "fsI"); | |
p = copy.prototype; | |
/** | |
* @param {string} k | |
* @return {?} | |
*/ | |
p.se = function(k) { | |
return this.state.hasOwnProperty(k) ? this.state[k].value : null; | |
}; | |
p.se = cb(copy.prototype.se, "fsiGS"); | |
/** | |
* @param {string} id | |
* @param {string} isXML | |
* @return {undefined} | |
*/ | |
p.Dd = function(id, isXML) { | |
if (!this.state.hasOwnProperty(id)) { | |
this.state[id] = new e; | |
} | |
this.ub(id, isXML); | |
}; | |
p.Dd = cb(copy.prototype.Dd, "fsiSS"); | |
/** | |
* @param {string} k | |
* @return {?} | |
*/ | |
p.le = function(k) { | |
return this.state[k].value; | |
}; | |
p.le = cb(copy.prototype.le, "fsiGI"); | |
/** | |
* @param {string} id | |
* @param {string} tag | |
* @return {undefined} | |
*/ | |
p.Lb = function(id, tag) { | |
if (!this.state.hasOwnProperty(id)) { | |
this.state[id] = new node; | |
} | |
this.ub(id, tag); | |
}; | |
p.Lb = cb(copy.prototype.Lb, "fsiSI"); | |
/** | |
* @param {string} key | |
* @param {boolean} deepDataAndEvents | |
* @return {undefined} | |
*/ | |
p.Kb = function(key, deepDataAndEvents) { | |
if (!this.state.hasOwnProperty(key)) { | |
this.state[key] = new C; | |
} | |
this.ub(key, deepDataAndEvents); | |
}; | |
p.Kb = cb(copy.prototype.Kb, "fsiSB"); | |
/** | |
* @param {string} id | |
* @param {Object} n | |
* @param {Function} obj | |
* @return {undefined} | |
*/ | |
p.aa = function(id, n, obj) { | |
if (null == readyList) { | |
acc(); | |
} | |
if (readyList != scope || n != e) { | |
if (!this.state.hasOwnProperty(id)) { | |
this.state[id] = new n; | |
} | |
n = this.state[id]; | |
n.bb = obj || null; | |
if (n.bb) { | |
if (null != n.value) { | |
n.bb(this, this.sessionId, id, n.value); | |
} | |
} | |
} | |
}; | |
p.aa = cb(copy.prototype.aa, "fsiSTC"); | |
/** | |
* @return {?} | |
*/ | |
p.Fb = function() { | |
return!!(this.Ka && (this.Ka.parentNode && this.Ka.contentWindow)); | |
}; | |
p.Fb = cb(copy.prototype.Fb, "fsiHVI"); | |
/** | |
* @param {string} id | |
* @param {string} value | |
* @return {undefined} | |
*/ | |
p.ub = function(id, value) { | |
var item = this.state[id]; | |
value = item.xa(id, value); | |
if (null != value) { | |
if (item.value != value) { | |
item = this.state[id]; | |
/** @type {string} */ | |
item.value = value; | |
/** @type {boolean} */ | |
this.P = item.P = true; | |
} | |
} | |
}; | |
p.ub = cb(copy.prototype.ub, "fsiS"); | |
/** | |
* @return {undefined} | |
*/ | |
p.ud = function() { | |
if (this.P) { | |
var k; | |
for (k in this.state) { | |
if (this.state.hasOwnProperty(k)) { | |
var r = this.state[k]; | |
if (r.P) { | |
/** @type {boolean} */ | |
r.P = false; | |
if (r.bb) { | |
r.bb(this, this.sessionId, k, r.value); | |
} | |
} | |
} | |
} | |
/** @type {boolean} */ | |
this.P = false; | |
} | |
}; | |
p.ud = cb(copy.prototype.ud, "fsiNC"); | |
/** | |
* @param {boolean} recurring | |
* @return {?} | |
*/ | |
p.fd = function(recurring) { | |
/** @type {Array} */ | |
var tagNameArr = ["FSXDC"]; | |
var key; | |
for (key in this.state) { | |
if (this.state.hasOwnProperty(key)) { | |
var current = this.state[key]; | |
if (recurring || current.P) { | |
var querystring = current.Ia(); | |
tagNameArr.push([encodeURIComponent(key), current.Id, querystring].join(":")); | |
/** @type {boolean} */ | |
current.P = false; | |
} | |
} | |
} | |
/** @type {boolean} */ | |
this.P = false; | |
return tagNameArr.join(","); | |
}; | |
p.fd = cb(copy.prototype.fd, "fsiGCM"); | |
/** | |
* @param {(Array|string)} path | |
* @return {undefined} | |
*/ | |
p.cd = function(path) { | |
if (path && (path.split && (path = path.split(","), "FSXDC" == path[0]))) { | |
/** @type {number} */ | |
var i = 1; | |
for (;i < path.length;i++) { | |
var m = path[i].split(":"); | |
/** @type {string} */ | |
var key = decodeURIComponent(m[0]); | |
if (!this.state.hasOwnProperty(key)) { | |
this.state[key] = new (tmp[parseInt(m[1], 10)]); | |
} | |
m = this.state[key].Fa(m[2]); | |
this.ub(key, m); | |
} | |
this.ud(); | |
} | |
}; | |
p.cd = cb(copy.prototype.cd, "fsiECM"); | |
/** | |
* @param {string} x | |
* @param {string} str | |
* @return {undefined} | |
*/ | |
var out = function(x, str) { | |
util.log({ | |
message : x | |
}, str); | |
}; | |
out = cb(out, "fsLE"); | |
/** | |
* @return {undefined} | |
*/ | |
var C = function() { | |
/** @type {null} */ | |
this.bb = this.value = null; | |
/** @type {boolean} */ | |
this.P = false; | |
}; | |
C = cb(C, "fsB"); | |
p = C.prototype; | |
/** @type {number} */ | |
p.Id = 0; | |
/** @type {number} */ | |
p.Fc = 1; | |
/** | |
* @param {string} timer | |
* @param {string} putativeSpy | |
* @return {?} | |
*/ | |
p.xa = function(timer, putativeSpy) { | |
return!!putativeSpy; | |
}; | |
p.xa = cb(C.prototype.xa, "fsbGVV"); | |
/** | |
* @return {?} | |
*/ | |
p.yb = function() { | |
return this.value ? 1 : 0; | |
}; | |
p.yb = cb(C.prototype.yb, "fsbTB"); | |
/** | |
* @param {number} dataAndEvents | |
* @return {?} | |
*/ | |
p.Ib = function(dataAndEvents) { | |
return!!dataAndEvents; | |
}; | |
p.Ib = cb(C.prototype.Ib, "fsbPFB"); | |
/** | |
* @return {?} | |
*/ | |
p.Ia = function() { | |
return this.value ? "t" : "f"; | |
}; | |
p.Ia = cb(C.prototype.Ia, "fsbTES"); | |
/** | |
* @param {string} reset | |
* @return {?} | |
*/ | |
p.Fa = function(reset) { | |
return "t" == reset; | |
}; | |
p.Fa = cb(C.prototype.Fa, "fsbPES"); | |
/** | |
* @return {undefined} | |
*/ | |
var node = function() { | |
/** @type {null} */ | |
this.bb = this.value = null; | |
/** @type {boolean} */ | |
this.P = false; | |
}; | |
node = cb(node, "fsSI"); | |
p = node.prototype; | |
/** @type {number} */ | |
p.Id = 1; | |
/** @type {number} */ | |
p.Fc = 14; | |
/** @type {number} */ | |
p.xf = (1 << node.prototype.Fc) - 1; | |
/** | |
* @param {string} timer | |
* @param {string} b | |
* @return {?} | |
*/ | |
p.xa = function(timer, b) { | |
/** @type {number} */ | |
var num2 = parseInt(b, 10); | |
if (isNaN(num2)) { | |
return out("Tried to set int value to a non-number ( " + timer + " = " + b + ")", "sIGVV"), null; | |
} | |
if (num2 > this.xf) { | |
out("Tried to set int value to a number too large ( " + timer + " = " + b + ")", "sIGVV"); | |
num2 = this.xf; | |
} | |
if (0 > num2) { | |
out("Tried to set int value to a number too small ( " + timer + " = " + b + ")", "sIGVV"); | |
/** @type {number} */ | |
num2 = 0; | |
} | |
return num2; | |
}; | |
p.xa = cb(node.prototype.xa, "fssiGVV"); | |
/** | |
* @return {?} | |
*/ | |
p.yb = function() { | |
return this.value || 0; | |
}; | |
p.yb = cb(node.prototype.yb, "fssiTB"); | |
/** | |
* @param {number} dataAndEvents | |
* @return {?} | |
*/ | |
p.Ib = function(dataAndEvents) { | |
return dataAndEvents; | |
}; | |
p.Ib = cb(node.prototype.Ib, "fssiPFB"); | |
/** | |
* @return {?} | |
*/ | |
p.Ia = function() { | |
return this.value + ""; | |
}; | |
p.Ia = cb(node.prototype.Ia, "fssiTES"); | |
/** | |
* @param {?} m1 | |
* @return {?} | |
*/ | |
p.Fa = function(m1) { | |
return parseInt(m1, 10); | |
}; | |
p.Fa = cb(node.prototype.Fa, "fssiPES"); | |
/** | |
* @return {undefined} | |
*/ | |
var e = function() { | |
/** @type {null} */ | |
this.bb = this.value = null; | |
/** @type {boolean} */ | |
this.P = false; | |
}; | |
e = cb(e, "fsES"); | |
p = e.prototype; | |
/** @type {number} */ | |
p.Id = 2; | |
/** | |
* @param {string} timer | |
* @param {boolean} right | |
* @return {?} | |
*/ | |
p.xa = function(timer, right) { | |
return right = right ? right.toString() : ""; | |
}; | |
p.xa = cb(e.prototype.xa, "fsesGVV"); | |
/** | |
* @return {?} | |
*/ | |
p.Ia = function() { | |
return this.value ? encodeURIComponent(this.value) : ""; | |
}; | |
p.Ia = cb(e.prototype.Ia, "fsesTES"); | |
/** | |
* @param {?} part | |
* @return {?} | |
*/ | |
p.Fa = function(part) { | |
return decodeURIComponent(part); | |
}; | |
p.Fa = cb(e.prototype.Fa, "fsesPES"); | |
/** @type {Array} */ | |
var tmp = [C, node, e]; | |
/** | |
* @param {Object} obj | |
* @return {?} | |
*/ | |
var _ = function(obj) { | |
if (null == readyList) { | |
acc(); | |
} | |
return readyList.Ha(obj); | |
}; | |
_ = cb(_, "fsSC"); | |
/** | |
* @param {Object} obj | |
* @param {Function} deepDataAndEvents | |
* @return {undefined} | |
*/ | |
var formatted = function(obj, deepDataAndEvents) { | |
if (null == readyList) { | |
acc(); | |
} | |
if (null == all) { | |
all = {}; | |
errors(); | |
} | |
/** @type {Function} */ | |
obj.Ka = deepDataAndEvents; | |
/** @type {Object} */ | |
all[obj.sessionId] = obj; | |
}; | |
formatted = cb(formatted, "fsLFC"); | |
/** | |
* @return {undefined} | |
*/ | |
var errors = function() { | |
window.setInterval(foo, 500); | |
readyList.za(); | |
}; | |
errors = cb(errors, "fsIL"); | |
/** | |
* @return {undefined} | |
*/ | |
var foo = function() { | |
var id; | |
for (id in all) { | |
if (all.hasOwnProperty(id)) { | |
var target = all[id]; | |
if (!target.Fb()) { | |
/** @type {null} */ | |
target.Ka = null; | |
delete all[id]; | |
} | |
} | |
} | |
}; | |
foo = cb(foo, "fsCDI"); | |
/** | |
* @return {undefined} | |
*/ | |
var acc = function() { | |
that.Ee(); | |
/** @type {({Cd: function (string): undefined, Ha: ?, Ud: function (HTMLElement): undefined, ba: function (): undefined, cf: function (Object, string, Text): undefined, qe: function (Object, string): ?, uf: string, za: function (): undefined}|{Ee: function (): undefined, Ha: ?, Qe: (Document|Window), ba: function (Event): undefined, za: function (): undefined}|{Ha: ?, Zd: function (string, string): undefined, ba: function (): undefined, be: function (Node, number): undefined, me: function (?): ?, za: function (): undefined})} */ | |
readyList = that.Qe ? that : createTextNode() ? scope : _this; | |
}; | |
acc = cb(acc, "fsLT"); | |
var scope = { | |
uf : "exists", | |
/** | |
* @param {Object} parent | |
* @return {?} | |
*/ | |
Ha : function(parent) { | |
if (!parent.P) { | |
return true; | |
} | |
var k; | |
for (k in parent.state) { | |
if (parent.state.hasOwnProperty(k)) { | |
var p = parent.state[k]; | |
if (p.P && p.yb) { | |
var pl = p.Fc; | |
var b = p.yb(); | |
/** @type {string} */ | |
var name = k + ":"; | |
scope.Cd(name + scope.uf); | |
/** @type {number} */ | |
var extension = 0; | |
/** @type {number} */ | |
var c = 1; | |
for (;extension < pl;extension++, c <<= 1) { | |
/** @type {string} */ | |
var newName = name + extension; | |
if (b & c) { | |
scope.Cd(newName); | |
} else { | |
scope.Ud(newName); | |
} | |
} | |
/** @type {boolean} */ | |
p.P = false; | |
} | |
} | |
} | |
/** @type {boolean} */ | |
parent.P = false; | |
return true; | |
} | |
}; | |
scope.Ha = cb(scope.Ha, "fsnbtSC"); | |
/** | |
* @return {undefined} | |
*/ | |
scope.za = function() { | |
window.setInterval(scope.ba, 50); | |
}; | |
scope.za = cb(scope.za, "fsnbtIL"); | |
/** | |
* @return {undefined} | |
*/ | |
scope.ba = function() { | |
var id; | |
for (id in all) { | |
if (all.hasOwnProperty(id)) { | |
var e = all[id]; | |
if (e.Fb()) { | |
var udataCur = e.Ka.contentWindow; | |
var i; | |
for (i in e.state) { | |
if (e.state.hasOwnProperty(i)) { | |
scope.cf(e, i, udataCur); | |
} | |
} | |
e.ud(); | |
} | |
} | |
} | |
}; | |
scope.ba = cb(scope.ba, "fsnbtEC"); | |
/** | |
* @param {Object} e | |
* @param {string} k | |
* @param {Text} value | |
* @return {undefined} | |
*/ | |
scope.cf = function(e, k, value) { | |
/** @type {function (Object, string): ?} */ | |
var lookupIterator = scope.qe; | |
/** @type {string} */ | |
var startPage = k + ":"; | |
if (lookupIterator(value, startPage + scope.uf)) { | |
var input = e.state[k]; | |
var il = input.Fc; | |
/** @type {number} */ | |
var node = 0; | |
/** @type {number} */ | |
var i = 0; | |
/** @type {number} */ | |
var n = 1; | |
for (;i < il;i++, n <<= 1) { | |
var iterator = lookupIterator(value, startPage + i); | |
if (null === iterator) { | |
return; | |
} | |
if (iterator) { | |
node += n; | |
} | |
} | |
value = input.Ib(node); | |
e.ub(k, value); | |
} | |
}; | |
scope.cf = cb(scope.cf, "fsnbtSV"); | |
/** | |
* @param {Object} obj | |
* @param {string} key | |
* @return {?} | |
*/ | |
scope.qe = function(obj, key) { | |
/** @type {null} */ | |
var rv = null; | |
try { | |
/** @type {boolean} */ | |
rv = key in obj; | |
} catch (d) { | |
out(key, "fsnbtGSB2"); | |
} | |
return rv; | |
}; | |
scope.qe = cb(scope.qe, "fsnbtGSB"); | |
/** | |
* @param {string} name | |
* @return {undefined} | |
*/ | |
scope.Cd = function(name) { | |
if (!document.getElementById(name)) { | |
/** @type {Element} */ | |
var img = document.createElement("img"); | |
/** @type {string} */ | |
img.name = name; | |
/** @type {string} */ | |
img.id = name; | |
/** @type {number} */ | |
img.height = 0; | |
/** @type {number} */ | |
img.width = 0; | |
document.body.appendChild(img); | |
} | |
}; | |
scope.Cd = cb(scope.Cd, "fsnbtSSB"); | |
/** | |
* @param {HTMLElement} table | |
* @return {undefined} | |
*/ | |
scope.Ud = function(table) { | |
if (table = document.getElementById(table)) { | |
table.parentNode.removeChild(table); | |
} | |
}; | |
scope.Ud = cb(scope.Ud, "fsnbtCSB"); | |
var that = { | |
/** | |
* @param {Object} stream | |
* @return {?} | |
*/ | |
Ha : function(stream) { | |
if (stream.P) { | |
if (!that.Qe) { | |
return false; | |
} | |
that.Qe.postMessage(stream.fd(false), "*"); | |
} | |
return true; | |
} | |
}; | |
that.Ha = cb(that.Ha, "fspmtSC"); | |
/** | |
* @return {undefined} | |
*/ | |
that.za = function() { | |
if (window.attachEvent) { | |
window.attachEvent("onmessage", that.ba); | |
} else { | |
if (window.addEventListener) { | |
window.addEventListener("message", that.ba, false); | |
} | |
} | |
}; | |
that.za = cb(that.za, "fspmtIL"); | |
/** | |
* @param {Event} e | |
* @return {undefined} | |
*/ | |
that.ba = function(e) { | |
if (e = e ? e : window.event) { | |
var id; | |
for (id in all) { | |
if (all.hasOwnProperty(id)) { | |
var t = all[id]; | |
if (t.Fb() && e.source == t.Ka.contentWindow) { | |
t.cd(e.data); | |
break; | |
} | |
} | |
} | |
} | |
}; | |
that.ba = cb(that.ba, "fspmtEC"); | |
/** | |
* @return {undefined} | |
*/ | |
that.Ee = function() { | |
/** @type {Window} */ | |
var win = window.parent; | |
try { | |
/** @type {(Document|Window|null)} */ | |
var root = win.postMessage ? win : win.document.postMessage ? win.document : null; | |
if (root) { | |
if (root.postMessage) { | |
/** @type {(Document|Window)} */ | |
that.Qe = root; | |
} | |
} | |
} catch (c) { | |
} | |
}; | |
that.Ee = cb(that.Ee, "fspmtLPM"); | |
var _this = { | |
/** | |
* @param {Object} stream | |
* @return {?} | |
*/ | |
Ha : function(stream) { | |
if (stream.P) { | |
if (!window.relay) { | |
return false; | |
} | |
_this.Zd(window.relay, stream.fd(true)); | |
} | |
return true; | |
} | |
}; | |
_this.Ha = cb(_this.Ha, "fsnitSC"); | |
/** | |
* @return {undefined} | |
*/ | |
_this.za = function() { | |
window.setInterval(_this.ba, 5); | |
}; | |
_this.za = cb(_this.za, "fsnitIL"); | |
/** | |
* @return {undefined} | |
*/ | |
_this.ba = function() { | |
var id; | |
for (id in all) { | |
if (all.hasOwnProperty(id)) { | |
var e = all[id]; | |
var start = _this.me(e); | |
if (start) { | |
e.cd(start); | |
} | |
} | |
} | |
}; | |
_this.ba = cb(_this.ba, "fsnitEC"); | |
/** | |
* @param {?} e | |
* @return {?} | |
*/ | |
_this.me = function(e) { | |
try { | |
if (e.Fb()) { | |
var win = e.Ka.contentWindow; | |
if (win.frames && (win.frames.length && (0 < win.frames.length && win.frames[win.frames.length - 1].name))) { | |
return win.frames[win.frames.length - 1].name; | |
} | |
} | |
} catch (c) { | |
} | |
return null; | |
}; | |
_this.me = cb(_this.me, "fsnitGM"); | |
/** | |
* @param {string} uri | |
* @param {string} name | |
* @return {undefined} | |
*/ | |
_this.Zd = function(uri, name) { | |
/** @type {Element} */ | |
var iframe = document.createElement("iframe"); | |
/** @type {string} */ | |
iframe.style.position = "absolute"; | |
/** @type {string} */ | |
iframe.style.top = "0"; | |
/** @type {string} */ | |
iframe.style.left = "0"; | |
/** @type {string} */ | |
iframe.style.display = "none"; | |
/** @type {string} */ | |
iframe.width = "0"; | |
/** @type {string} */ | |
iframe.height = "0"; | |
/** @type {string} */ | |
iframe.src = uri + "crossdomain.xml"; | |
/** @type {string} */ | |
iframe.name = name; | |
/** | |
* @return {undefined} | |
*/ | |
iframe.onload = function() { | |
_this.be(this, 100); | |
}; | |
document.body.appendChild(iframe); | |
}; | |
_this.Zd = cb(_this.Zd, "fsnitCRI"); | |
/** | |
* @param {Node} t | |
* @param {number} milliseconds | |
* @return {undefined} | |
*/ | |
_this.be = function(t, milliseconds) { | |
window.setTimeout(function() { | |
t.parentNode.removeChild(t); | |
}, milliseconds); | |
}; | |
_this.be = cb(_this.be, "fsnitDMI"); | |
if (window.IS_GOOGLE_AFS_IFRAME_) { | |
/** | |
* @param {Object} done | |
* @return {?} | |
*/ | |
var scale = function(done) { | |
return function(id, dataAndEvents) { | |
return "undefined" == typeof done[id] ? dataAndEvents || null : done[id]; | |
}; | |
}; | |
/** | |
* @param {Object} arg | |
* @return {?} | |
*/ | |
var _filter = function(arg) { | |
return function(x, elt) { | |
if (arg.hasOwnProperty(x)) { | |
var codeSegments = arg[x].split(","); | |
/** @type {number} */ | |
var i = 0; | |
for (;i < codeSegments.length;i++) { | |
if (codeSegments[i] == elt) { | |
return true; | |
} | |
} | |
return false; | |
} | |
return true; | |
}; | |
}; | |
/** | |
* @param {string} data | |
* @param {Object} b | |
* @return {?} | |
*/ | |
var equals = function(data, b) { | |
return!b.clickBg && !b.mclickBg || (!data.clickableBackgrounds || b.isHighendMobile && !b.mclickBg) ? false : true; | |
}; | |
/** | |
* @param {Object} expr | |
* @return {?} | |
*/ | |
var eval = function(expr) { | |
return 6 == rgbToHex(newRed) ? true : "_blank" == (expr.linkTarget ? expr.linkTarget : "_top"); | |
}; | |
/** | |
* @param {Object} actual | |
* @param {Function} message | |
* @return {?} | |
*/ | |
var equal = function(actual, message) { | |
return 1 == (true === actual.heightConstrained && !!message.mayLimitHeight); | |
}; | |
} | |
if (window.IS_GOOGLE_AFS_IFRAME_) { | |
/** @type {number} */ | |
var Rb = 1; | |
/** | |
* @return {?} | |
*/ | |
var min = function() { | |
return "e" + Rb++; | |
}; | |
/** | |
* @param {?} dataAndEvents | |
* @return {undefined} | |
*/ | |
var TemplateClass = function(dataAndEvents) { | |
this.vb = dataAndEvents; | |
}; | |
/** | |
* @return {?} | |
*/ | |
TemplateClass.prototype.f = function() { | |
return this.vb; | |
}; | |
var result = new TemplateClass(""); | |
} | |
var hasMembers; | |
/** @type {function (string): ?} */ | |
var pad = String.prototype.trim ? function(buf) { | |
return buf.trim(); | |
} : function(lastLine) { | |
return lastLine.replace(/^[\s\xa0]+|[\s\xa0]+$/g, ""); | |
}; | |
/** | |
* @param {string} requestUrl | |
* @return {?} | |
*/ | |
var complete = function(requestUrl) { | |
if (!rhtml.test(requestUrl)) { | |
return requestUrl; | |
} | |
if (-1 != requestUrl.indexOf("&")) { | |
requestUrl = requestUrl.replace(rreturn, "&"); | |
} | |
if (-1 != requestUrl.indexOf("<")) { | |
requestUrl = requestUrl.replace(rCurrLoc, "<"); | |
} | |
if (-1 != requestUrl.indexOf(">")) { | |
requestUrl = requestUrl.replace(rclass, ">"); | |
} | |
if (-1 != requestUrl.indexOf('"')) { | |
requestUrl = requestUrl.replace(badChars, """); | |
} | |
if (-1 != requestUrl.indexOf("'")) { | |
requestUrl = requestUrl.replace(normalizr, "'"); | |
} | |
if (-1 != requestUrl.indexOf("\x00")) { | |
requestUrl = requestUrl.replace(newlineRe, "�"); | |
} | |
return requestUrl; | |
}; | |
/** @type {RegExp} */ | |
var rreturn = /&/g; | |
/** @type {RegExp} */ | |
var rCurrLoc = /</g; | |
/** @type {RegExp} */ | |
var rclass = />/g; | |
/** @type {RegExp} */ | |
var badChars = /"/g; | |
/** @type {RegExp} */ | |
var normalizr = /'/g; | |
/** @type {RegExp} */ | |
var newlineRe = /\x00/g; | |
/** @type {RegExp} */ | |
var rhtml = /[\x00&<>"']/; | |
/** | |
* @return {?} | |
*/ | |
var randomColor = function() { | |
return Math.floor(2147483648 * Math.random()).toString(36) + Math.abs(Math.floor(2147483648 * Math.random()) ^ _randomVal()).toString(36); | |
}; | |
/** | |
* @param {(boolean|number|string)} a | |
* @param {(boolean|number|string)} b | |
* @return {?} | |
*/ | |
var cmp = function(a, b) { | |
return a < b ? -1 : a > b ? 1 : 0; | |
}; | |
var aProt = Array.prototype; | |
/** @type {function (?, number, ?): ?} */ | |
var promote = aProt.indexOf ? function(object, mapper, graphics) { | |
return aProt.indexOf.call(object, mapper, graphics); | |
} : function(arr, obj, fromIndex) { | |
fromIndex = null == fromIndex ? 0 : 0 > fromIndex ? Math.max(0, arr.length + fromIndex) : fromIndex; | |
if (isObject(arr)) { | |
return isObject(obj) && 1 == obj.length ? arr.indexOf(obj, fromIndex) : -1; | |
} | |
for (;fromIndex < arr.length;fromIndex++) { | |
if (fromIndex in arr && arr[fromIndex] === obj) { | |
return fromIndex; | |
} | |
} | |
return-1; | |
}; | |
/** @type {function (Array, Function, ?): ?} */ | |
var repeat = aProt.filter ? function(next_scope, mapper, graphics) { | |
return aProt.filter.call(next_scope, mapper, graphics); | |
} : function(arr, f, opt_this) { | |
var e = arr.length; | |
/** @type {Array} */ | |
var res = []; | |
/** @type {number} */ | |
var resLength = 0; | |
var arr2 = isObject(arr) ? arr.split("") : arr; | |
/** @type {number} */ | |
var i = 0; | |
for (;i < e;i++) { | |
if (i in arr2) { | |
var val = arr2[i]; | |
if (f.call(opt_this, val, i, arr)) { | |
res[resLength++] = val; | |
} | |
} | |
} | |
return res; | |
}; | |
/** @type {function (?, Function, ?): ?} */ | |
var connect = aProt.map ? function(next_scope, mapper, graphics) { | |
return aProt.map.call(next_scope, mapper, graphics); | |
} : function(arr, f, opt_obj) { | |
var e = arr.length; | |
/** @type {Array} */ | |
var res = Array(e); | |
var arr2 = isObject(arr) ? arr.split("") : arr; | |
/** @type {number} */ | |
var i = 0; | |
for (;i < e;i++) { | |
if (i in arr2) { | |
res[i] = f.call(opt_obj, arr2[i], i, arr); | |
} | |
} | |
return res; | |
}; | |
/** | |
* @param {Object} obj | |
* @param {Function} f | |
* @return {?} | |
*/ | |
var isUndefined = function(obj, f) { | |
var copy = {}; | |
var key; | |
for (key in obj) { | |
if (f.call(void 0, obj[key], key, obj)) { | |
copy[key] = obj[key]; | |
} | |
} | |
return copy; | |
}; | |
/** | |
* @param {Array} ev | |
* @return {?} | |
*/ | |
var _fn = function(ev) { | |
/** @type {number} */ | |
var argLength = arguments.length; | |
if (1 == argLength && "array" == isArray(arguments[0])) { | |
return _fn.apply(null, arguments[0]); | |
} | |
var wkw = {}; | |
/** @type {number} */ | |
var i = 0; | |
for (;i < argLength;i++) { | |
/** @type {boolean} */ | |
wkw[arguments[i]] = true; | |
} | |
return wkw; | |
}; | |
_fn("area base br col command embed hr img input keygen link meta param source track wbr".split(" ")); | |
/** @type {RegExp} */ | |
var _problemUrlChars = /<[^>]*>|&[^;]+;/g; | |
/** | |
* @param {string} url | |
* @param {?} opt_attributes | |
* @return {?} | |
*/ | |
var getQuery = function(url, opt_attributes) { | |
return opt_attributes ? url.replace(_problemUrlChars, "") : url; | |
}; | |
/** @type {RegExp} */ | |
var regex = RegExp("[A-Za-z\u00c0-\u00d6\u00d8-\u00f6\u00f8-\u02b8\u0300-\u0590\u0800-\u1fff\u200e\u2c00-\ufb1c\ufe00-\ufe6f\ufefd-\uffff]"); | |
/** @type {RegExp} */ | |
var regexp = RegExp("^[^A-Za-z\u00c0-\u00d6\u00d8-\u00f6\u00f8-\u02b8\u0300-\u0590\u0800-\u1fff\u200e\u2c00-\ufb1c\ufe00-\ufe6f\ufefd-\uffff]*[\u0591-\u07ff\u200f\ufb1d-\ufdff\ufe70-\ufefc]"); | |
/** @type {RegExp} */ | |
var STACK_TRACE_REGEXP = /^http:\/\/.*/; | |
/** @type {RegExp} */ | |
var rspace = /\s+/; | |
/** @type {RegExp} */ | |
var reParent = /\d/; | |
/** | |
* @return {undefined} | |
*/ | |
var current = function() { | |
/** @type {string} */ | |
this.wj = ""; | |
this.Ih = ParseUser; | |
}; | |
var ParseUser = {}; | |
/** | |
* @return {undefined} | |
*/ | |
var Sprite = function() { | |
/** @type {string} */ | |
this.Se = ""; | |
this.Jh = random; | |
}; | |
/** | |
* @return {?} | |
*/ | |
Sprite.prototype.kg = function() { | |
return 1; | |
}; | |
var random = {}; | |
/** | |
* @return {undefined} | |
*/ | |
var type = function() { | |
/** @type {string} */ | |
this.Se = ""; | |
this.Hh = listener; | |
/** @type {null} */ | |
this.vi = null; | |
}; | |
/** | |
* @return {?} | |
*/ | |
type.prototype.kg = function() { | |
return this.vi; | |
}; | |
var listener = {}; | |
/** | |
* @return {?} | |
*/ | |
var tryIt = function() { | |
return null; | |
}; | |
/** | |
* @param {Function} func | |
* @return {?} | |
*/ | |
var once = function(func) { | |
/** @type {Arguments} */ | |
var functions = arguments; | |
/** @type {number} */ | |
var length = functions.length; | |
return function() { | |
var memo; | |
/** @type {number} */ | |
var i = 0; | |
for (;i < length;i++) { | |
memo = functions[i].apply(this, arguments); | |
} | |
return memo; | |
}; | |
}; | |
/** | |
* @param {?} a | |
* @param {?} b | |
* @param {number} x | |
* @return {?} | |
*/ | |
var Number = function(a, b, x) { | |
return a + x * (b - a); | |
}; | |
var userAgent; | |
a: { | |
var nav = global.navigator; | |
if (nav) { | |
var originalUserAgent = nav.userAgent; | |
if (originalUserAgent) { | |
userAgent = originalUserAgent; | |
break a; | |
} | |
} | |
/** @type {string} */ | |
userAgent = ""; | |
} | |
/** | |
* @return {?} | |
*/ | |
var isBogus = function() { | |
return-1 != userAgent.indexOf("Edge"); | |
}; | |
/** @type {boolean} */ | |
var os = -1 != userAgent.indexOf("Opera") || -1 != userAgent.indexOf("OPR"); | |
/** @type {boolean} */ | |
var isValid = -1 != userAgent.indexOf("Edge") || (-1 != userAgent.indexOf("Trident") || -1 != userAgent.indexOf("MSIE")); | |
/** @type {boolean} */ | |
var strict = -1 != userAgent.indexOf("Gecko") && (!(-1 != userAgent.toLowerCase().indexOf("webkit") && !isBogus()) && (!(-1 != userAgent.indexOf("Trident") || -1 != userAgent.indexOf("MSIE")) && !isBogus())); | |
/** @type {boolean} */ | |
var documentElement = -1 != userAgent.toLowerCase().indexOf("webkit") && !isBogus(); | |
/** | |
* @return {?} | |
*/ | |
var valueAccessor = function() { | |
var ua = userAgent; | |
if (strict) { | |
return/rv\:([^\);]+)(\)|;)/.exec(ua); | |
} | |
if (isValid && isBogus()) { | |
return/Edge\/([\d\.]+)/.exec(ua); | |
} | |
if (isValid) { | |
return/\b(?:MSIE|rv)[: ]([^\);]+)(\)|;)/.exec(ua); | |
} | |
if (documentElement) { | |
return/WebKit\/(\S+)/.exec(ua); | |
} | |
}; | |
/** | |
* @return {?} | |
*/ | |
var iframeCssFixes = function() { | |
var doc = global.document; | |
return doc ? doc.documentMode : void 0; | |
}; | |
var cDigit = function() { | |
if (os && global.opera) { | |
var v = global.opera.version; | |
return "function" == isArray(v) ? v() : v; | |
} | |
/** @type {string} */ | |
v = ""; | |
var value = valueAccessor(); | |
if (value) { | |
v = value ? value[1] : ""; | |
} | |
return isValid && (!isBogus() && (value = iframeCssFixes(), value > parseFloat(v))) ? String(value) : v; | |
}(); | |
var opt_nodes = {}; | |
/** | |
* @param {string} ms | |
* @return {?} | |
*/ | |
var format = function(ms) { | |
var node; | |
if (!(node = opt_nodes[ms])) { | |
/** @type {number} */ | |
node = 0; | |
var v1Subs = pad(String(cDigit)).split("."); | |
var v2Subs = pad(String(ms)).split("."); | |
/** @type {number} */ | |
var subCount = Math.max(v1Subs.length, v2Subs.length); | |
/** @type {number} */ | |
var subIdx = 0; | |
for (;0 == node && subIdx < subCount;subIdx++) { | |
var value = v1Subs[subIdx] || ""; | |
var v2Sub = v2Subs[subIdx] || ""; | |
/** @type {RegExp} */ | |
var re = RegExp("(\\d*)(\\D*)", "g"); | |
/** @type {RegExp} */ | |
var regex = RegExp("(\\d*)(\\D*)", "g"); | |
do { | |
/** @type {Array} */ | |
var a = re.exec(value) || ["", "", ""]; | |
/** @type {Array} */ | |
var b = regex.exec(v2Sub) || ["", "", ""]; | |
if (0 == a[0].length && 0 == b[0].length) { | |
break; | |
} | |
node = cmp(0 == a[1].length ? 0 : parseInt(a[1], 10), 0 == b[1].length ? 0 : parseInt(b[1], 10)) || (cmp(0 == a[2].length, 0 == b[2].length) || cmp(a[2], b[2])); | |
} while (0 == node); | |
} | |
/** @type {boolean} */ | |
node = opt_nodes[ms] = 0 <= node; | |
} | |
return node; | |
}; | |
var DOC = global.document; | |
var checkStart = iframeCssFixes(); | |
var Pc = !DOC || (!isValid || !checkStart && isBogus()) ? void 0 : checkStart || ("CSS1Compat" == DOC.compatMode ? parseInt(cDigit, 10) : 5); | |
/** | |
* @param {number} x | |
* @param {number} y | |
* @return {undefined} | |
*/ | |
var Rect = function(x, y) { | |
this.x = void 0 !== x ? x : 0; | |
this.y = void 0 !== y ? y : 0; | |
}; | |
/** | |
* @return {?} | |
*/ | |
Rect.prototype.clone = function() { | |
return new Rect(this.x, this.y); | |
}; | |
/** | |
* @return {?} | |
*/ | |
Rect.prototype.ceil = function() { | |
/** @type {number} */ | |
this.x = Math.ceil(this.x); | |
/** @type {number} */ | |
this.y = Math.ceil(this.y); | |
return this; | |
}; | |
/** | |
* @return {?} | |
*/ | |
Rect.prototype.floor = function() { | |
/** @type {number} */ | |
this.x = Math.floor(this.x); | |
/** @type {number} */ | |
this.y = Math.floor(this.y); | |
return this; | |
}; | |
/** | |
* @return {?} | |
*/ | |
Rect.prototype.round = function() { | |
/** @type {number} */ | |
this.x = Math.round(this.x); | |
/** @type {number} */ | |
this.y = Math.round(this.y); | |
return this; | |
}; | |
/** | |
* @param {?} w | |
* @param {?} h | |
* @return {undefined} | |
*/ | |
var Node = function(w, h) { | |
this.width = w; | |
this.height = h; | |
}; | |
/** | |
* @return {?} | |
*/ | |
Node.prototype.clone = function() { | |
return new Node(this.width, this.height); | |
}; | |
/** | |
* @return {?} | |
*/ | |
Node.prototype.ceil = function() { | |
/** @type {number} */ | |
this.width = Math.ceil(this.width); | |
/** @type {number} */ | |
this.height = Math.ceil(this.height); | |
return this; | |
}; | |
/** | |
* @return {?} | |
*/ | |
Node.prototype.floor = function() { | |
/** @type {number} */ | |
this.width = Math.floor(this.width); | |
/** @type {number} */ | |
this.height = Math.floor(this.height); | |
return this; | |
}; | |
/** | |
* @return {?} | |
*/ | |
Node.prototype.round = function() { | |
/** @type {number} */ | |
this.width = Math.round(this.width); | |
/** @type {number} */ | |
this.height = Math.round(this.height); | |
return this; | |
}; | |
if (!(!strict && !isValid)) { | |
if (!(isValid && (isValid && (isBogus() || 9 <= Pc)))) { | |
if (strict) { | |
format("1.9.1"); | |
} | |
} | |
} | |
if (isValid) { | |
format("9"); | |
} | |
/** | |
* @param {Error} el | |
* @return {?} | |
*/ | |
var isNode = function(el) { | |
return el ? new target(getWindow(el)) : hasMembers || (hasMembers = new target); | |
}; | |
/** | |
* @param {Object} el | |
* @return {?} | |
*/ | |
var getWindow = function(el) { | |
return 9 == el.nodeType ? el : el.ownerDocument || el.document; | |
}; | |
/** | |
* @param {(Document|string)} el | |
* @return {undefined} | |
*/ | |
var target = function(el) { | |
this.Rb = el || (global.document || document); | |
}; | |
/** | |
* @param {?} value | |
* @return {?} | |
*/ | |
target.prototype.lg = function(value) { | |
return isObject(value) ? this.Rb.getElementById(value) : value; | |
}; | |
/** | |
* @param {string} name | |
* @return {?} | |
*/ | |
target.prototype.createElement = function(name) { | |
return this.Rb.createElement(name); | |
}; | |
/** | |
* @param {?} text | |
* @param {string} val | |
* @return {?} | |
*/ | |
var toDom = function(text, val) { | |
var fragment = text.Rb; | |
var node = fragment.createElement("DIV"); | |
if (isValid) { | |
/** @type {string} */ | |
node.innerHTML = "<br>" + val; | |
node.removeChild(node.firstChild); | |
} else { | |
/** @type {string} */ | |
node.innerHTML = val; | |
} | |
if (1 == node.childNodes.length) { | |
node = node.removeChild(node.firstChild); | |
} else { | |
fragment = fragment.createDocumentFragment(); | |
for (;node.firstChild;) { | |
fragment.appendChild(node.firstChild); | |
} | |
node = fragment; | |
} | |
return node; | |
}; | |
/** | |
* @param {Element} element | |
* @param {Element} child | |
* @return {undefined} | |
*/ | |
target.prototype.appendChild = function(element, child) { | |
element.appendChild(child); | |
}; | |
/** | |
* @param {Object} parent | |
* @param {Object} descendant | |
* @return {?} | |
*/ | |
target.prototype.contains = function(parent, descendant) { | |
if (parent.contains && 1 == descendant.nodeType) { | |
return parent == descendant || parent.contains(descendant); | |
} | |
if ("undefined" != typeof parent.compareDocumentPosition) { | |
return parent == descendant || Boolean(parent.compareDocumentPosition(descendant) & 16); | |
} | |
for (;descendant && parent != descendant;) { | |
descendant = descendant.parentNode; | |
} | |
return descendant == parent; | |
}; | |
if (isValid) { | |
format(8); | |
} | |
var lowerTagName = {}; | |
var n = {}; | |
var me = {}; | |
var elem = {}; | |
var wildcardName = {}; | |
/** | |
* @return {?} | |
*/ | |
var fun = function() { | |
throw Error("Do not instantiate directly"); | |
}; | |
/** @type {null} */ | |
fun.prototype.Na = null; | |
/** | |
* @return {?} | |
*/ | |
fun.prototype.toString = function() { | |
return this.content; | |
}; | |
/** | |
* @param {string} object | |
* @param {?} elt | |
* @return {?} | |
*/ | |
var indexOf = function(object, elt) { | |
return null != object && object.fb === elt; | |
}; | |
/** | |
* @param {string} putativeSpy | |
* @return {?} | |
*/ | |
var sorter = function(putativeSpy) { | |
if (null != putativeSpy) { | |
switch(putativeSpy.Na) { | |
case 1: | |
return 1; | |
case -1: | |
return-1; | |
case 0: | |
return 0; | |
} | |
} | |
return null; | |
}; | |
/** | |
* @return {undefined} | |
*/ | |
var src = function() { | |
fun.call(this); | |
}; | |
isPlainObject(src, fun); | |
src.prototype.fb = lowerTagName; | |
/** | |
* @param {?} value | |
* @return {?} | |
*/ | |
var $ = function(value) { | |
return null != value && value.fb === lowerTagName ? value : value instanceof type ? func(value instanceof type && (value.constructor === type && value.Hh === listener) ? value.Se : "type_error:SafeHtml", value.kg()) : func(complete(String(String(value))), sorter(value)); | |
}; | |
/** | |
* @return {undefined} | |
*/ | |
var model = function() { | |
fun.call(this); | |
}; | |
isPlainObject(model, fun); | |
model.prototype.fb = {}; | |
/** @type {number} */ | |
model.prototype.Na = 1; | |
/** | |
* @return {undefined} | |
*/ | |
var value = function() { | |
fun.call(this); | |
}; | |
isPlainObject(value, fun); | |
value.prototype.fb = n; | |
/** @type {number} */ | |
value.prototype.Na = 1; | |
/** | |
* @return {undefined} | |
*/ | |
var req = function() { | |
fun.call(this); | |
}; | |
isPlainObject(req, fun); | |
req.prototype.fb = me; | |
/** @type {number} */ | |
req.prototype.Na = 1; | |
/** | |
* @return {undefined} | |
*/ | |
var source = function() { | |
fun.call(this); | |
}; | |
isPlainObject(source, fun); | |
source.prototype.fb = elem; | |
/** @type {number} */ | |
source.prototype.Na = 1; | |
/** | |
* @param {?} obj | |
* @param {number} silent | |
* @return {undefined} | |
*/ | |
var view = function(obj, silent) { | |
/** @type {string} */ | |
this.content = String(obj); | |
this.Na = null != silent ? silent : null; | |
}; | |
isPlainObject(view, fun); | |
view.prototype.fb = wildcardName; | |
/** | |
* @param {Function} fn | |
* @return {?} | |
*/ | |
var when = function(fn) { | |
/** | |
* @param {?} c | |
* @return {undefined} | |
*/ | |
function handler(c) { | |
this.content = c; | |
} | |
handler.prototype = fn.prototype; | |
return function(opt_message) { | |
return new handler(String(opt_message)); | |
}; | |
}; | |
var func = function(b) { | |
/** | |
* @param {?} value | |
* @return {undefined} | |
*/ | |
function __(value) { | |
this.content = value; | |
} | |
__.prototype = b.prototype; | |
return function(opt_message, lvl) { | |
var o = new __(String(opt_message)); | |
if (void 0 !== lvl) { | |
/** @type {number} */ | |
o.Na = lvl; | |
} | |
return o; | |
}; | |
}(src); | |
when(model); | |
when(value); | |
var fix_xhr = when(req); | |
var log = when(source); | |
/** | |
* @param {Object} o | |
* @param {?} iterable | |
* @return {?} | |
*/ | |
var beget = function(o, iterable) { | |
/** | |
* @return {undefined} | |
*/ | |
function F() { | |
} | |
/** @type {Object} */ | |
F.prototype = o; | |
var object = new F; | |
var key; | |
for (key in iterable) { | |
object[key] = iterable[key]; | |
} | |
return object; | |
}; | |
/** | |
* @param {Function} o | |
* @return {?} | |
*/ | |
var validator = function(o) { | |
/** | |
* @param {?} content | |
* @return {undefined} | |
*/ | |
function node(content) { | |
this.content = content; | |
} | |
node.prototype = o.prototype; | |
return function(data) { | |
return(data = String(data)) ? new node(data) : ""; | |
}; | |
}; | |
/** | |
* @param {string} str | |
* @return {?} | |
*/ | |
var is = function(str) { | |
return(str = String(str)) ? new view(str, void 0) : ""; | |
}; | |
var apply = function(b) { | |
/** | |
* @param {?} count | |
* @return {undefined} | |
*/ | |
function c(count) { | |
this.content = count; | |
} | |
c.prototype = b.prototype; | |
return function(obj, lvl) { | |
/** @type {string} */ | |
var o = String(obj); | |
if (!o) { | |
return ""; | |
} | |
o = new c(o); | |
if (void 0 !== lvl) { | |
/** @type {number} */ | |
o.Na = lvl; | |
} | |
return o; | |
}; | |
}(src); | |
validator(model); | |
validator(value); | |
validator(req); | |
var valid = validator(source); | |
/** | |
* @param {?} selector | |
* @return {?} | |
*/ | |
var parent = function(selector) { | |
return $(selector); | |
}; | |
/** | |
* @param {?} values | |
* @return {?} | |
*/ | |
var start = function(values) { | |
return indexOf(values, lowerTagName) ? (values = String(values.content).replace(rLt, "").replace(rQuot, "<"), String(values).replace(rApos, boundary)) : complete(String(values)); | |
}; | |
/** | |
* @param {Object} a | |
* @return {?} | |
*/ | |
var slice = function(a) { | |
if (indexOf(a, me)) { | |
return a.content.replace(/([^"'\s])$/, "$1 "); | |
} | |
/** @type {string} */ | |
a = String(a); | |
/** @type {string} */ | |
a = exclude.test(a) ? a : "zSoyz"; | |
return a; | |
}; | |
/** | |
* @param {?} content | |
* @return {?} | |
*/ | |
var replace = function(content) { | |
if (indexOf(content, n)) { | |
return String(content).replace(r20, block); | |
} | |
if (content instanceof Sprite) { | |
content = content instanceof Sprite && (content.constructor === Sprite && content.Jh === random) ? content.Se : "type_error:SafeUrl"; | |
/** @type {string} */ | |
content = String(content).replace(r20, block); | |
} else { | |
/** @type {string} */ | |
content = String(content); | |
/** @type {string} */ | |
content = supportedTransforms.test(content) ? content.replace(r20, block) : "#zSoyz"; | |
} | |
return content; | |
}; | |
/** | |
* @param {string} type | |
* @return {?} | |
*/ | |
var toString = function(type) { | |
if (indexOf(type, elem)) { | |
return type.content; | |
} | |
if (null == type) { | |
/** @type {string} */ | |
type = ""; | |
} else { | |
if (type instanceof current) { | |
type = type instanceof current && (type.constructor === current && type.Ih === ParseUser) ? type.wj : "type_error:SafeStyle"; | |
} else { | |
/** @type {string} */ | |
type = String(type); | |
/** @type {string} */ | |
type = manipulation_rcheckableType.test(type) ? type : "zSoyz"; | |
} | |
} | |
return type; | |
}; | |
/** | |
* @param {string} value | |
* @return {?} | |
*/ | |
var quote = function(value) { | |
var key = sorter(value); | |
if (null == key) { | |
/** @type {number} */ | |
var string = key = 0; | |
/** @type {boolean} */ | |
var multiple = false; | |
value = getQuery(value + "", indexOf(value, lowerTagName)).split(rspace); | |
/** @type {number} */ | |
var index = 0; | |
for (;index < value.length;index++) { | |
var url = value[index]; | |
if (regexp.test(getQuery(url, void 0))) { | |
key++; | |
string++; | |
} else { | |
if (STACK_TRACE_REGEXP.test(url)) { | |
/** @type {boolean} */ | |
multiple = true; | |
} else { | |
if (regex.test(getQuery(url, void 0))) { | |
string++; | |
} else { | |
if (reParent.test(url)) { | |
/** @type {boolean} */ | |
multiple = true; | |
} | |
} | |
} | |
} | |
} | |
/** @type {number} */ | |
key = 0 == string ? multiple ? 1 : 0 : 0.4 < key / string ? -1 : 1; | |
} | |
return key; | |
}; | |
var _entryCharToButtonIdMap = { | |
"\x00" : "�", | |
"\t" : "	", | |
"\n" : " ", | |
"\x0B" : "", | |
"\f" : "", | |
"\r" : " ", | |
" " : " ", | |
'"' : """, | |
"&" : "&", | |
"'" : "'", | |
"-" : "-", | |
"/" : "/", | |
"<" : "<", | |
"=" : "=", | |
">" : ">", | |
"`" : "`", | |
"\u0085" : "…", | |
"\u00a0" : " ", | |
"\u2028" : "
", | |
"\u2029" : "
" | |
}; | |
/** | |
* @param {?} timeoutKey | |
* @return {?} | |
*/ | |
var boundary = function(timeoutKey) { | |
return _entryCharToButtonIdMap[timeoutKey]; | |
}; | |
var special = { | |
"\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 {?} type | |
* @return {?} | |
*/ | |
var block = function(type) { | |
return special[type]; | |
}; | |
/** @type {RegExp} */ | |
var rApos = /[\x00\x22\x27\x3c\x3e]/g; | |
/** @type {RegExp} */ | |
var r20 = /[\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 manipulation_rcheckableType = /^(?!-*(?:expression|(?:moz-)?binding))(?:[.#]?-?(?:[_a-z0-9-]+)(?:-[_a-z0-9-]+)*-?|-?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[a-z]{1,2}|%)?|!important|)$/i; | |
/** @type {RegExp} */ | |
var supportedTransforms = /^(?![^#?]*\/(?:\.|%2E){2}(?:[\/?#]|$))(?:(?:https?|mailto):|[^&:\/?#]*(?:[\/?#]|$))/i; | |
/** @type {RegExp} */ | |
var exclude = /^(?!style|on|action|archive|background|cite|classid|codebase|data|dsync|href|longdesc|src|usemap)(?:[a-z0-9_$:-]*)$/i; | |
/** @type {RegExp} */ | |
var rLt = /<(?:!|\/?([a-zA-Z][a-zA-Z0-9:\-]*))(?:[^>'"]|"[^"]*"|'[^']*')*>/g; | |
/** @type {RegExp} */ | |
var rQuot = /</g; | |
/** | |
* @param {?} opt_attributes | |
* @return {?} | |
*/ | |
var animate = function(opt_attributes) { | |
return func("<span class='individualLabel " + (opt_attributes.X ? start(opt_attributes.X) : "") + "'>" + $(opt_attributes.text) + "</span>"); | |
}; | |
if (window.IS_GOOGLE_AFS_IFRAME_) { | |
/** | |
* @param {?} clear | |
* @param {Function} opt_rightAlign | |
* @return {undefined} | |
*/ | |
var Renderer = function(clear, opt_rightAlign) { | |
this.Yh = clear; | |
this.C = opt_rightAlign || animate; | |
}; | |
/** | |
* @return {?} | |
*/ | |
Renderer.prototype.f = function() { | |
return this.C({ | |
text : this.Yh, | |
X : null | |
}); | |
}; | |
} | |
/** | |
* @param {?} opt_attributes | |
* @return {?} | |
*/ | |
var getStyle = function(opt_attributes) { | |
/** @type {string} */ | |
var later = ""; | |
opt_attributes = opt_attributes.elements; | |
var valuesLen = opt_attributes.length; | |
/** @type {number} */ | |
var i = 0; | |
for (;i < valuesLen;i++) { | |
later += $(opt_attributes[i]); | |
} | |
return func(later); | |
}; | |
if (window.IS_GOOGLE_AFS_IFRAME_) { | |
/** | |
* @param {?} lb | |
* @param {Function} value | |
* @return {undefined} | |
*/ | |
var Float32Array = function(lb, value) { | |
this.D = min(); | |
this.lb = lb; | |
this.C = value || createSvgElement_; | |
}; | |
/** | |
* @return {?} | |
*/ | |
Float32Array.prototype.f = function() { | |
/** @type {Array} */ | |
var eventPath = []; | |
/** @type {number} */ | |
var l = 0; | |
for (;l < this.lb.length;l++) { | |
eventPath.push(this.lb[l].f()); | |
} | |
return this.C({ | |
uid : this.D, | |
yd : eventPath | |
}); | |
}; | |
/** | |
* @param {?} d | |
* @return {?} | |
*/ | |
Float32Array.prototype.G = function(d) { | |
/** @type {Array} */ | |
var vars = []; | |
/** @type {number} */ | |
var j = 0; | |
for (;j < this.lb.length;j++) { | |
if (this.lb[j].G) { | |
/** @type {Array} */ | |
vars = vars.concat(this.lb[j].G(d)); | |
} | |
} | |
return vars; | |
}; | |
/** | |
* @param {Window} d | |
* @param {Object} opts | |
* @return {undefined} | |
*/ | |
Float32Array.prototype.W = function(d, opts) { | |
/** @type {number} */ | |
var i = 0; | |
for (;i < this.lb.length;i++) { | |
var t = this.lb[i]; | |
if (t.W) { | |
t.W(d, opts); | |
} | |
} | |
}; | |
/** | |
* @param {?} opt_attributes | |
* @return {?} | |
*/ | |
var createSvgElement_ = function(opt_attributes) { | |
return getStyle({ | |
elements : opt_attributes.yd | |
}); | |
}; | |
} | |
/** | |
* @return {?} | |
*/ | |
var innerHeight = function() { | |
return log("display: -moz-inline-box; display:inline-block; zoom: 1; *display: inline;"); | |
}; | |
/** | |
* @param {?} opt_attributes | |
* @return {?} | |
*/ | |
var errorHandler = function(opt_attributes) { | |
return log("-webkit-box-shadow: " + toString(opt_attributes.value) + "; -moz-box-shadow: " + toString(opt_attributes.value) + "; box-shadow: " + toString(opt_attributes.value) + ";"); | |
}; | |
/** | |
* @param {?} opt_attributes | |
* @return {?} | |
*/ | |
var reject = function(opt_attributes) { | |
return fix_xhr('target="' + (opt_attributes.j ? "_blank" : "_top") + '"'); | |
}; | |
/** | |
* @param {Text} params | |
* @return {?} | |
*/ | |
var load = function(params) { | |
/** @type {string} */ | |
var direction = params.Tb ? "right" : "left"; | |
/** @type {string} */ | |
params = "" + ('<div style="overflow: hidden;"><div style="float: ' + start(toString(direction)) + "; width: " + start(toString(params.oa + "px")) + ';">' + $(params.Pa) + '</div><div style="margin-' + start(toString(direction)) + ": " + start(toString(params.oa + params.$a + "px")) + ';">' + $(params.Qa) + "</div></div>"); | |
return func(params); | |
}; | |
/** | |
* @param {Text} options | |
* @return {?} | |
*/ | |
var bind = function(options) { | |
/** @type {string} */ | |
var corners = options.Tb ? "right" : "left"; | |
return options = "" + ('<div style="overflow: hidden;"><div style="float: ' + corners + "; width: " + (options.oa + "px") + ';">' + options.Pa + '</div><div style="margin-' + corners + ": " + (options.oa + options.$a + "px") + ';">' + options.Qa + "</div></div>"); | |
}; | |
if (window.IS_GOOGLE_AFS_IFRAME_) { | |
/** | |
* @param {?} endRow | |
* @param {?} endColumn | |
* @param {?} isInt | |
* @param {?} R | |
* @param {Function} success | |
* @return {undefined} | |
*/ | |
var Range = function(endRow, endColumn, isInt, R, success) { | |
this.D = min(); | |
this.ma = endRow; | |
this.Yb = endColumn; | |
this.vb = isInt; | |
this.R = R; | |
this.C = success || fail; | |
}; | |
/** | |
* @return {?} | |
*/ | |
Range.prototype.f = function() { | |
return this.C({ | |
uid : this.D, | |
url : this.ma, | |
ya : this.Yb, | |
text : this.vb, | |
j : this.R | |
}); | |
}; | |
/** | |
* @param {string} self | |
* @param {Object} pos | |
* @return {?} | |
*/ | |
var contains = function(self, pos) { | |
/** @type {Array} */ | |
var configList = []; | |
if (self.ctc) { | |
configList.push(new Range(self.ctc.u, (window._googCsaAlwaysHttps ? "https:" : "") + "//www.google.com/images/afs/mobile/button_ctc.png", self.ctc.bt, pos.j, void 0)); | |
} | |
if (self.ctd) { | |
configList.push(new Range(self.u, (window._googCsaAlwaysHttps ? "https:" : "") + "//www.google.com/images/afs/mobile/ctd-dl-icon.png", self.ctd.ps, pos.j, void 0)); | |
} | |
if (1 <= configList.length) { | |
if (!(self.ctc && self.ctc.coa || self.ctd)) { | |
configList.push(new Range(self.u, (window._googCsaAlwaysHttps ? "https:" : "") + "//www.google.com/images/afs/mobile/button_visit_site.png", pos.ek, pos.j, void 0)); | |
} | |
} | |
return configList; | |
}; | |
/** | |
* @param {string} value | |
* @param {Object} m | |
* @return {?} | |
*/ | |
var h = function(value, m) { | |
var left = contains(value, m); | |
return 1 < left.length ? new Float32Array(left, decode) : result; | |
}; | |
} | |
/** | |
* @param {Element} item | |
* @param {string} className | |
* @return {?} | |
*/ | |
var addClass = function(item, className) { | |
if (item.classList) { | |
return item.classList.contains(className); | |
} | |
var codeSegments = item.className.split(" "); | |
/** @type {number} */ | |
var i = 0; | |
for (;i < codeSegments.length;i++) { | |
if (codeSegments[i] == className) { | |
return true; | |
} | |
} | |
return false; | |
}; | |
/** | |
* @param {Element} elem | |
* @param {string} c | |
* @return {undefined} | |
*/ | |
var removeClass = function(elem, c) { | |
if (elem.classList) { | |
elem.classList.remove(c); | |
} else { | |
var tail = elem.className.split(" "); | |
/** @type {Array} */ | |
var context = []; | |
/** @type {number} */ | |
var i = 0; | |
for (;i < tail.length;i++) { | |
if (tail[i] != c) { | |
context.push(tail[i]); | |
} | |
} | |
/** @type {string} */ | |
elem.className = context.join(" "); | |
} | |
}; | |
/** | |
* @param {Element} elem | |
* @param {string} name | |
* @return {undefined} | |
*/ | |
var close = function(elem, name) { | |
if (elem.classList) { | |
elem.classList.add(name); | |
} else { | |
if (elem.className) { | |
if (!addClass(elem, name)) { | |
elem.className += " " + name; | |
} | |
} else { | |
/** @type {string} */ | |
elem.className = name; | |
} | |
} | |
}; | |
/** | |
* @param {Object} node | |
* @param {string} selector | |
* @param {string} className | |
* @return {?} | |
*/ | |
var qsa = function(node, selector, className) { | |
/** @type {Array} */ | |
var paragraph = []; | |
if ("getElementsByClassName" in document) { | |
node = node.getElementsByClassName(className); | |
/** @type {number} */ | |
var _i = 0; | |
var child; | |
for (;child = node[_i];_i++) { | |
if (child.nodeName) { | |
if (child.nodeName.toLowerCase() == selector) { | |
paragraph.push(child); | |
} | |
} | |
} | |
} else { | |
node = node.getElementsByTagName(selector); | |
/** @type {number} */ | |
_i = 0; | |
for (;child = node[_i];_i++) { | |
if (addClass(child, className)) { | |
paragraph.push(child); | |
} | |
} | |
} | |
return paragraph; | |
}; | |
/** | |
* @param {?} v23 | |
* @param {?} id | |
* @return {?} | |
*/ | |
var parseFloat = function(v23, id) { | |
var ret = v23.getElementById(id); | |
if (!ret) { | |
throw "Could not find element with id: " + id; | |
} | |
return ret; | |
}; | |
/** | |
* @param {Object} element | |
* @param {?} id | |
* @return {?} | |
*/ | |
var visit = function(element, id) { | |
for (;element.parentNode;) { | |
if (element = element.parentNode, element.id == id) { | |
return true; | |
} | |
} | |
return false; | |
}; | |
/** | |
* @param {Object} result | |
* @return {?} | |
*/ | |
var fragment = function(result) { | |
/** @type {Element} */ | |
var tip = document.createElement("div"); | |
result = isObject(result) ? result : result.content; | |
/** @type {string} */ | |
tip.innerHTML = "<table><tbody>" + result + "</tbody></table>"; | |
var elem; | |
try { | |
/** @type {(Node|null)} */ | |
elem = tip.firstChild.firstChild.firstChild; | |
} catch (d) { | |
return null; | |
} | |
return 1 == elem.nodeType && "tr" == elem.tagName.toLowerCase() ? elem : null; | |
}; | |
/** | |
* @param {Element} element | |
* @return {?} | |
*/ | |
var runTest = function(element) { | |
var parent = element.parentNode; | |
var next = element.nextSibling; | |
/** @type {Element} */ | |
var d = document.createElement("div"); | |
d.appendChild(element); | |
if (parent) { | |
if (next) { | |
parent.insertBefore(d, next); | |
} else { | |
parent.appendChild(d); | |
} | |
} | |
return d; | |
}; | |
/** | |
* @param {Window} target | |
* @param {?} scope | |
* @param {?} attr | |
* @return {?} | |
*/ | |
var link = function(target, scope, attr) { | |
return function() { | |
if (300 <= target.innerWidth) { | |
/** @type {string} */ | |
parseFloat(target.document, scope).style.display = "block"; | |
/** @type {string} */ | |
parseFloat(target.document, attr).style.display = "none"; | |
} else { | |
/** @type {string} */ | |
parseFloat(target.document, scope).style.display = "none"; | |
/** @type {string} */ | |
parseFloat(target.document, attr).style.display = "block"; | |
} | |
}; | |
}; | |
/** | |
* @param {Object} el | |
* @param {string} type | |
* @param {Function} eventName | |
* @return {undefined} | |
*/ | |
var addEvent = function(el, type, eventName) { | |
if (el.addEventListener) { | |
el.addEventListener(type, eventName, false); | |
} else { | |
if (el.attachEvent) { | |
el.attachEvent("on" + type, eventName); | |
} else { | |
var postfix = el["on" + type]; | |
el["on" + type] = null != postfix ? once(eventName, postfix) : eventName; | |
} | |
} | |
}; | |
/** | |
* @param {Object} el | |
* @param {Function} fn | |
* @return {undefined} | |
*/ | |
var attach = function(el, fn) { | |
addEvent(el, "mousedown", fn); | |
addEvent(el, "mousedown", function(el, sType, fn) { | |
/** @type {boolean} */ | |
var f = false; | |
return function() { | |
if (!f) { | |
if (el.removeEventListener) { | |
el.removeEventListener(sType, fn, false); | |
} else { | |
if (el.detachEvent) { | |
el.detachEvent("on" + sType, fn); | |
} | |
} | |
/** @type {boolean} */ | |
f = true; | |
} | |
}; | |
}(el, "mousedown", fn)); | |
}; | |
/** | |
* @param {?} opt_attributes | |
* @return {?} | |
*/ | |
var loop = function(opt_attributes) { | |
return func('<div id="' + start(opt_attributes.Bc) + '" style="display:' + start(toString(opt_attributes.yc ? "none" : "block")) + ';"><div>' + $(opt_attributes.Ba) + "</div>" + parent(load({ | |
Pa : apply("" + (opt_attributes.ea && opt_attributes.ga ? '<div class="ctd-itd"><a class="ctd-il" href="' + start(replace(opt_attributes.jc)) + '"><span class="ctd-ico-s"></span><img class="ctd-ico' + (opt_attributes.dc ? " rc" : "") + '" ' + slice(opt_attributes.ga) + '="45" src="' + start(replace(opt_attributes.ea)) + '" alt></a>' + (opt_attributes.I && opt_attributes.L ? end({ | |
I : opt_attributes.I, | |
L : opt_attributes.L, | |
fc : false | |
}) : "") + "</div>" : "")), | |
Qa : apply('<div class="ctd-td-cr">' + (!opt_attributes.I || (!opt_attributes.L || opt_attributes.ea && opt_attributes.ga) ? "" : end({ | |
I : opt_attributes.I, | |
L : opt_attributes.L, | |
fc : true | |
})) + $(opt_attributes.Ca) + '<div class="ctd-text" id="' + start(opt_attributes.Qb) + '">' + $(opt_attributes.od) + "</div></div>"), | |
oa : opt_attributes.ea && opt_attributes.ga ? 45 : 0, | |
$a : 0, | |
Tb : opt_attributes.g | |
})) + "</div>"); | |
}; | |
/** | |
* @param {?} opt_attributes | |
* @return {?} | |
*/ | |
var push = function(opt_attributes) { | |
return func('<div id="' + start(opt_attributes.Bc) + '" style="display:' + start(toString(opt_attributes.yc ? "none" : "block")) + ';"><div>' + $(opt_attributes.Ba) + "</div>" + parent(load({ | |
Pa : apply("" + (opt_attributes.ea && opt_attributes.ga ? '<div class="ctd-itd"><a class="ctd-il" href="' + start(replace(opt_attributes.jc)) + '"><span class="ctd-ico-s"></span><img class="ctd-ico' + (opt_attributes.dc ? " rc" : "") + '" ' + slice(opt_attributes.ga) + '="45" src="' + start(replace(opt_attributes.ea)) + '" alt></a>' + (opt_attributes.I && opt_attributes.L ? end({ | |
I : opt_attributes.I, | |
L : opt_attributes.L, | |
fc : false | |
}) : "") + "</div>" : "")), | |
Qa : apply('<div class="ctd-td-cr">' + (!opt_attributes.I || (!opt_attributes.L || opt_attributes.ea && opt_attributes.ga) ? "" : end({ | |
I : opt_attributes.I, | |
L : opt_attributes.L, | |
fc : true | |
})) + '<div class="ctd-text" id="' + start(opt_attributes.Qb) + '">' + $(opt_attributes.Ca) + "</div></div>"), | |
oa : opt_attributes.ea && opt_attributes.ga ? 45 : 0, | |
$a : 0, | |
Tb : opt_attributes.g | |
})) + "</div>"); | |
}; | |
/** | |
* @param {?} opt_attributes | |
* @return {?} | |
*/ | |
var ready = function(opt_attributes) { | |
return func("<div>" + (opt_attributes.ea && opt_attributes.ga ? '<a class="ctd-i-mini" href="' + start(replace(opt_attributes.jc)) + '"><img class="ctd-ico' + (opt_attributes.dc ? " rc-mini" : "") + '" style="' + start(toString(opt_attributes.ga)) + ': inherit; vertical-align: text-bottom;" src="' + start(replace(opt_attributes.ea)) + '"></a>' : "") + $(opt_attributes.Wi) + (opt_attributes.I && opt_attributes.L ? " " + end({ | |
I : opt_attributes.I, | |
L : opt_attributes.L, | |
fc : true | |
}) : "") + $(opt_attributes.Xi) + "</div>"); | |
}; | |
/** | |
* @param {?} opt_attributes | |
* @return {?} | |
*/ | |
var end = function(opt_attributes) { | |
return func('<div class="ctd-rate"><div class="ctd-rate-bg"><div class="ctd-rate-fg" style="width: ' + start(toString(opt_attributes.I / 5 * 100)) + '%;"></div></div><div class="ctd-rate-txt' + (opt_attributes.fc ? " inline" : "") + '">(<span class="ctd-usr-ico"></span>' + $(opt_attributes.L) + ")</div></div>"); | |
}; | |
/** | |
* @param {?} res | |
* @return {?} | |
*/ | |
var loaded = function(res) { | |
return func('<img class="adIcon" src="' + start(replace(res.sa)) + '"/>'); | |
}; | |
/** | |
* @param {?} rest | |
* @return {?} | |
*/ | |
var parseStartTag = function(rest) { | |
return func('<iframe class="adIcon" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" allowTransparency="true" sandbox="" src="' + start(replace(rest.sa)) + '"></iframe>'); | |
}; | |
if (window.IS_GOOGLE_AFS_IFRAME_) { | |
/** | |
* @param {?} opt_vars | |
* @param {?} opt_size | |
* @return {undefined} | |
*/ | |
var Player = function(opt_vars, opt_size) { | |
this.Pj = opt_vars; | |
this.C = opt_size; | |
}; | |
/** | |
* @return {?} | |
*/ | |
Player.prototype.f = function() { | |
return this.C({ | |
sa : this.Pj | |
}); | |
}; | |
} | |
/** | |
* @param {Object} doc | |
* @return {?} | |
*/ | |
var getOffset = function(doc) { | |
var el = getWindow(doc); | |
var pos = new Rect(0, 0); | |
var node; | |
node = el ? getWindow(el) : document; | |
var opt_useFirstChild; | |
if (!(opt_useFirstChild = !isValid || isValid && (isBogus() || 9 <= Pc))) { | |
/** @type {boolean} */ | |
opt_useFirstChild = "CSS1Compat" == isNode(node).Rb.compatMode; | |
} | |
if (doc == (opt_useFirstChild ? node.documentElement : node.body)) { | |
return pos; | |
} | |
var viewport; | |
a: { | |
try { | |
viewport = doc.getBoundingClientRect(); | |
} catch (g) { | |
viewport = { | |
left : 0, | |
top : 0, | |
right : 0, | |
bottom : 0 | |
}; | |
break a; | |
} | |
if (isValid) { | |
if (doc.ownerDocument.body) { | |
doc = doc.ownerDocument; | |
viewport.left -= doc.documentElement.clientLeft + doc.body.clientLeft; | |
viewport.top -= doc.documentElement.clientTop + doc.body.clientTop; | |
} | |
} | |
} | |
doc = isNode(el).Rb; | |
el = documentElement || "CSS1Compat" != doc.compatMode ? doc.body || doc.documentElement : doc.documentElement; | |
doc = doc.parentWindow || doc.defaultView; | |
el = isValid && (format("10") && doc.pageYOffset != el.scrollTop) ? new Rect(el.scrollLeft, el.scrollTop) : new Rect(doc.pageXOffset || el.scrollLeft, doc.pageYOffset || el.scrollTop); | |
pos.x = viewport.left + el.x; | |
pos.y = viewport.top + el.y; | |
return pos; | |
}; | |
if (isValid) { | |
format(12); | |
} | |
/** | |
* @param {?} opt_attributes | |
* @return {?} | |
*/ | |
var createDocument = function(opt_attributes) { | |
return func(g({ | |
text : opt_attributes.text.c, | |
Aa : opt_attributes.text.rtl, | |
g : opt_attributes.g | |
})); | |
}; | |
/** | |
* @param {?} opt_attributes | |
* @return {?} | |
*/ | |
var forEach = function(opt_attributes) { | |
return func(g({ | |
text : opt_attributes.text, | |
Aa : 0 > quote(opt_attributes.text), | |
g : opt_attributes.g | |
})); | |
}; | |
/** | |
* @param {?} opt_attributes | |
* @return {?} | |
*/ | |
var g = function(opt_attributes) { | |
return func(0 < opt_attributes.text.toString().length ? '<span dir="' + (opt_attributes.Aa ? "rtl" : "ltr") + '">' + $(opt_attributes.text) + "</span>" + (opt_attributes.g ? "‏" : "‎") : ""); | |
}; | |
/** | |
* @param {?} opt_attributes | |
* @return {?} | |
*/ | |
var exports = function(opt_attributes) { | |
return func('<a id="' + start(opt_attributes.uid) + '" href="' + start(replace(opt_attributes.url)) + '" class="titleLink"' + slice(reject(opt_attributes)) + ">" + parent(createDocument(opt_attributes)) + "</a>"); | |
}; | |
/** | |
* @param {?} opt_attributes | |
* @return {?} | |
*/ | |
var test = function(opt_attributes) { | |
return func('<div class="ctcT"><img src="//www.google.com/images/mobile_ad/phone_icon-lb32.png" class="ctcCOI" /><a id="' + start(opt_attributes.uid) + '" href="' + start(replace(opt_attributes.url)) + '"' + slice(reject(opt_attributes)) + ">" + parent(g({ | |
text : opt_attributes.rj, | |
Aa : false, | |
g : opt_attributes.g | |
})) + "</a>" + (opt_attributes.cg ? '<span class="ctcLD"> (' + parent(forEach({ | |
text : opt_attributes.cg, | |
g : opt_attributes.g | |
})) + ")</span>" : "") + "</div>" + (opt_attributes.Oi ? "" : '<span class="ctcCO">' + parent(createDocument(opt_attributes)) + "</span>")); | |
}; | |
/** | |
* @param {?} opt_attributes | |
* @return {?} | |
*/ | |
var execute = function(opt_attributes) { | |
return func('<a id="' + start(opt_attributes.uid) + '" href="' + start(replace(opt_attributes.url)) + '" class="domainLink"' + slice(reject(opt_attributes)) + ">" + parent(g({ | |
text : opt_attributes.text, | |
Aa : false, | |
g : opt_attributes.g | |
})) + "</a>"); | |
}; | |
/** | |
* @param {?} opt_attributes | |
* @return {?} | |
*/ | |
var flush = function(opt_attributes) { | |
var props = func; | |
var config; | |
config = opt_attributes.ah; | |
var o = opt_attributes.bh; | |
opt_attributes = opt_attributes.g; | |
/** @type {string} */ | |
var name = ""; | |
if (o && 0 < o.c.toString().length) { | |
var green = config.rtl || o.rtl; | |
/** @type {string} */ | |
name = name + g({ | |
Aa : green, | |
g : opt_attributes, | |
text : apply(createDocument({ | |
text : config, | |
g : green | |
}) + " " + createDocument({ | |
text : o, | |
g : green | |
})) | |
}); | |
} else { | |
name += createDocument({ | |
text : config, | |
g : opt_attributes | |
}); | |
} | |
config = func(name); | |
return props('<span class="descText">' + $(config) + "</span>"); | |
}; | |
/** | |
* @param {?} opt_attributes | |
* @return {?} | |
*/ | |
var write = function(opt_attributes) { | |
return func('<a id="' + start(opt_attributes.uid) + '" href="' + start(replace(opt_attributes.url)) + '" class="textLink"' + slice(reject(opt_attributes)) + ">" + flush(opt_attributes) + "</a>"); | |
}; | |
/** | |
* @param {?} opt_attributes | |
* @return {?} | |
*/ | |
var use = function(opt_attributes) { | |
return func("<div>" + $(opt_attributes.Ba) + "</div>" + $(opt_attributes.Ca) + "<br />" + $(opt_attributes.od)); | |
}; | |
/** | |
* @param {?} opt_attributes | |
* @return {?} | |
*/ | |
var limit = function(opt_attributes) { | |
return func("<div>" + $(opt_attributes.Ba) + "</div>" + $(opt_attributes.Ca)); | |
}; | |
/** | |
* @param {Object} data | |
* @return {?} | |
*/ | |
var onSuccess = function(data) { | |
/** @type {string} */ | |
var options = ""; | |
switch(data.rc) { | |
case 1: | |
options += "oneLine"; | |
break; | |
case 2: | |
options += "twoLine"; | |
break; | |
case 3: | |
options += "threeLine"; | |
} | |
options = is(options); | |
/** @type {string} */ | |
data = "" + ('<div class="adStd ' + start(options) + '"' + (data.cb ? 'data-click-s="' + start(data.url) + '"' + slice(fix_xhr('data-click-trg="' + (data.j ? "_blank" : "_top") + '"')) : "") + ">" + $(data.content) + "</div>"); | |
return func(data); | |
}; | |
/** | |
* @param {?} object | |
* @return {?} | |
*/ | |
var freeze = function(object) { | |
freeze[" "](object); | |
return object; | |
}; | |
/** | |
* @return {undefined} | |
*/ | |
freeze[" "] = function() { | |
}; | |
if (isValid) { | |
format("9"); | |
} | |
if (!!documentElement) { | |
format("528"); | |
} | |
if (!(strict && format("1.9b"))) { | |
if (!(isValid && format("8"))) { | |
if (!(os && format("9.5"))) { | |
if (documentElement) { | |
format("528"); | |
} | |
} | |
} | |
} | |
if (!(strict && !format("8"))) { | |
if (isValid) { | |
format("9"); | |
} | |
} | |
/** | |
* @param {?} y | |
* @param {?} x | |
* @param {?} node | |
* @param {?} ypos | |
* @param {?} mass | |
* @param {?} xpos | |
* @param {?} coordinates | |
* @param {?} round | |
* @return {undefined} | |
*/ | |
var Point = function(y, x, node, ypos, mass, xpos, coordinates, round) { | |
this.Dc = y; | |
this.pf = x; | |
this.nf = node; | |
this.qf = ypos; | |
this.of = mass; | |
this.rf = xpos; | |
this.Gd = coordinates; | |
this.sf = round; | |
}; | |
/** | |
* @return {?} | |
*/ | |
Point.prototype.clone = function() { | |
return new Point(this.Dc, this.pf, this.nf, this.qf, this.of, this.rf, this.Gd, this.sf); | |
}; | |
/** | |
* @param {Object} options | |
* @param {number} a | |
* @return {?} | |
*/ | |
var number = function(options, a) { | |
if (0 == a) { | |
return options.Dc; | |
} | |
if (1 == a) { | |
return options.Gd; | |
} | |
var c = Number(options.Dc, options.nf, a); | |
var b = Number(options.nf, options.of, a); | |
var y = Number(options.of, options.Gd, a); | |
c = Number(c, b, a); | |
b = Number(b, y, a); | |
return Number(c, b, a); | |
}; | |
/** | |
* @param {?} b | |
* @return {?} | |
*/ | |
var loadConfig = function(b) { | |
var x = point; | |
/** @type {number} */ | |
var args = (b - x.Dc) / (x.Gd - x.Dc); | |
if (0 >= args) { | |
return 0; | |
} | |
if (1 <= args) { | |
return 1; | |
} | |
/** @type {number} */ | |
var triggerArguments = 0; | |
/** @type {number} */ | |
var lastArgs = 1; | |
/** @type {number} */ | |
var f = 0; | |
for (;8 > f;f++) { | |
var a = number(x, args); | |
/** @type {number} */ | |
var c = (number(x, args + 1E-6) - a) / 1E-6; | |
if (1E-6 > Math.abs(a - b)) { | |
return args; | |
} | |
if (1E-6 > Math.abs(c)) { | |
break; | |
} else { | |
if (a < b) { | |
/** @type {number} */ | |
triggerArguments = args; | |
} else { | |
/** @type {number} */ | |