1 (function() { var goog = goog || {};
3 goog.isDef = function(val) {
6 goog.exportPath_ = function(name, opt_object, opt_objectToExportTo) {
7 var parts = name.split("."), cur = opt_objectToExportTo || goog.global;
8 parts[0] in cur || !cur.execScript || cur.execScript("var " + parts[0]);
9 for (var part;parts.length && (part = parts.shift());) {
10 !parts.length && goog.isDef(opt_object) ? cur[part] = opt_object : cur = cur[part] ? cur[part] : cur[part] = {};
13 goog.define = function(name, defaultValue) {
14 var value = defaultValue;
15 goog.exportPath_(name, value);
19 goog.TRUSTED_SITE = !0;
20 goog.STRICT_MODE_COMPATIBLE = !1;
21 goog.provide = function(name) {
22 goog.constructNamespace_(name);
24 goog.constructNamespace_ = function(name, opt_obj) {
25 goog.exportPath_(name, opt_obj);
27 goog.module = function(name) {
28 if (!goog.isString(name) || !name) {
29 throw Error("Invalid module identifier");
31 if (!goog.isInModuleLoader_()) {
32 throw Error("Module " + name + " has been loaded incorrectly.");
34 if (goog.moduleLoaderState_.moduleName) {
35 throw Error("goog.module may only be called once per module.");
37 goog.moduleLoaderState_.moduleName = name;
39 goog.module.get = function(name) {
40 return goog.module.getInternal_(name);
42 goog.module.getInternal_ = function() {
44 goog.moduleLoaderState_ = null;
45 goog.isInModuleLoader_ = function() {
46 return null != goog.moduleLoaderState_;
48 goog.module.declareTestMethods = function() {
49 if (!goog.isInModuleLoader_()) {
50 throw Error("goog.module.declareTestMethods must be called from within a goog.module");
52 goog.moduleLoaderState_.declareTestMethods = !0;
54 goog.module.declareLegacyNamespace = function() {
55 goog.moduleLoaderState_.declareLegacyNamespace = !0;
57 goog.setTestOnly = function(opt_message) {
59 throw opt_message = opt_message || "", Error("Importing test-only code into non-debug environment" + (opt_message ? ": " + opt_message : "."));
62 goog.forwardDeclare = function() {
64 goog.getObjectByName = function(name, opt_obj) {
65 for (var parts = name.split("."), cur = opt_obj || goog.global, part;part = parts.shift();) {
66 if (goog.isDefAndNotNull(cur[part])) {
74 goog.globalize = function(obj, opt_global) {
75 var global = opt_global || goog.global, x;
80 goog.addDependency = function(relPath, provides, requires, opt_isModule) {
81 if (goog.DEPENDENCIES_ENABLED) {
82 for (var provide, require, path = relPath.replace(/\\/g, "/"), deps = goog.dependencies_, i = 0;provide = provides[i];i++) {
83 deps.nameToPath[provide] = path, deps.pathIsModule[path] = !!opt_isModule;
85 for (var j = 0;require = requires[j];j++) {
86 path in deps.requires || (deps.requires[path] = {}), deps.requires[path][require] = !0;
90 goog.useStrictRequires = !1;
91 goog.ENABLE_DEBUG_LOADER = !0;
92 goog.logToConsole_ = function(msg) {
93 goog.global.console && goog.global.console.error(msg);
95 goog.require = function() {
98 goog.nullFunction = function() {
100 goog.identityFunction = function(opt_returnValue) {
101 return opt_returnValue;
103 goog.abstractMethod = function() {
104 throw Error("unimplemented abstract method");
106 goog.addSingletonGetter = function(ctor) {
107 ctor.getInstance = function() {
108 if (ctor.instance_) {
109 return ctor.instance_;
111 goog.DEBUG && (goog.instantiatedSingletons_[goog.instantiatedSingletons_.length] = ctor);
112 return ctor.instance_ = new ctor;
115 goog.instantiatedSingletons_ = [];
116 goog.LOAD_MODULE_USING_EVAL = !0;
117 goog.SEAL_MODULE_EXPORTS = goog.DEBUG;
118 goog.loadedModules_ = {};
119 goog.DEPENDENCIES_ENABLED = !1;
120 goog.DEPENDENCIES_ENABLED && (goog.included_ = {}, goog.dependencies_ = {pathIsModule:{}, nameToPath:{}, requires:{}, visited:{}, written:{}}, goog.inHtmlDocument_ = function() {
121 var doc = goog.global.document;
122 return "undefined" != typeof doc && "write" in doc;
123 }, goog.findBasePath_ = function() {
124 if (goog.global.CLOSURE_BASE_PATH) {
125 goog.basePath = goog.global.CLOSURE_BASE_PATH;
127 if (goog.inHtmlDocument_()) {
128 for (var doc = goog.global.document, scripts = doc.getElementsByTagName("script"), i = scripts.length - 1;0 <= i;--i) {
129 var script = scripts[i], src = script.src, qmark = src.lastIndexOf("?"), l = -1 == qmark ? src.length : qmark;
130 if ("base.js" == src.substr(l - 7, 7)) {
131 goog.basePath = src.substr(0, l - 7);
137 }, goog.importScript_ = function(src, opt_sourceText) {
138 var importScript = goog.global.CLOSURE_IMPORT_SCRIPT || goog.writeScriptTag_;
139 importScript(src, opt_sourceText) && (goog.dependencies_.written[src] = !0);
140 }, goog.IS_OLD_IE_ = goog.global.document && goog.global.document.all && !goog.global.atob, goog.importModule_ = function(src) {
141 var bootstrap = 'goog.retrieveAndExecModule_("' + src + '");';
142 goog.importScript_("", bootstrap) && (goog.dependencies_.written[src] = !0);
143 }, goog.queuedModules_ = [], goog.retrieveAndExecModule_ = function(src) {
144 for (var separator;-1 != (separator = src.indexOf("/./"));) {
145 src = src.substr(0, separator) + src.substr(separator + 2);
147 for (;-1 != (separator = src.indexOf("/../"));) {
148 var previousComponent = src.lastIndexOf("/", separator - 1);
149 src = src.substr(0, previousComponent) + src.substr(separator + 3);
151 var importScript = goog.global.CLOSURE_IMPORT_SCRIPT || goog.writeScriptTag_, scriptText = null, xhr = new goog.global.XMLHttpRequest;
152 xhr.onload = function() {
153 scriptText = this.responseText;
155 xhr.open("get", src, !1);
157 scriptText = xhr.responseText;
158 if (null != scriptText) {
159 var execModuleScript = goog.wrapModule_(src, scriptText), isOldIE = goog.IS_OLD_IE_;
160 isOldIE ? goog.queuedModules_.push(execModuleScript) : importScript(src, execModuleScript);
161 goog.dependencies_.written[src] = !0;
163 throw Error("load of " + src + "failed");
165 }, goog.wrapModule_ = function(srcUrl, scriptText) {
166 return goog.LOAD_MODULE_USING_EVAL && goog.isDef(goog.global.JSON) ? "goog.loadModule(" + goog.global.JSON.stringify(scriptText + "\n//# sourceURL=" + srcUrl + "\n") + ");" : 'goog.loadModule(function(exports) {"use strict";' + scriptText + "\n;return exports});\n//# sourceURL=" + srcUrl + "\n";
167 }, goog.loadQueuedModules_ = function() {
168 var count = goog.queuedModules_.length;
170 var queue = goog.queuedModules_;
171 goog.queuedModules_ = [];
172 for (var i = 0;i < count;i++) {
173 var entry = queue[i];
174 goog.globalEval(entry);
177 }, goog.loadModule = function(moduleDef) {
179 goog.moduleLoaderState_ = {moduleName:void 0, declareTestMethods:!1};
181 if (goog.isFunction(moduleDef)) {
182 exports = moduleDef.call(goog.global, {});
184 if (goog.isString(moduleDef)) {
185 exports = goog.loadModuleFromSource_.call(goog.global, moduleDef);
187 throw Error("Invalid module definition");
190 var moduleName = goog.moduleLoaderState_.moduleName;
191 if (!goog.isString(moduleName) || !moduleName) {
192 throw Error('Invalid module name "' + moduleName + '"');
194 goog.moduleLoaderState_.declareLegacyNamespace ? goog.constructNamespace_(moduleName, exports) : goog.SEAL_MODULE_EXPORTS && Object.seal && Object.seal(exports);
195 goog.loadedModules_[moduleName] = exports;
196 if (goog.moduleLoaderState_.declareTestMethods) {
197 for (var entry in exports) {
198 if (0 === entry.indexOf("test", 0) || "tearDown" == entry || "setUp" == entry || "setUpPage" == entry || "tearDownPage" == entry) {
199 goog.global[entry] = exports[entry];
204 goog.moduleLoaderState_ = null;
206 }, goog.loadModuleFromSource_ = function(JSCompiler_OptimizeArgumentsArray_p0) {
208 eval(JSCompiler_OptimizeArgumentsArray_p0);
210 }, goog.writeScriptTag_ = function(src, opt_sourceText) {
211 if (goog.inHtmlDocument_()) {
212 var doc = goog.global.document;
213 if ("complete" == doc.readyState) {
214 var isDeps = /\bdeps.js$/.test(src);
218 throw Error('Cannot write "' + src + '" after document load');
220 var isOldIE = goog.IS_OLD_IE_;
221 if (void 0 === opt_sourceText) {
223 var state = " onreadystatechange='goog.onScriptLoad_(this, " + ++goog.lastNonModuleScriptIndex_ + ")' ";
224 doc.write('<script type="text/javascript" src="' + src + '"' + state + ">\x3c/script>");
226 doc.write('<script type="text/javascript" src="' + src + '">\x3c/script>');
229 doc.write('<script type="text/javascript">' + opt_sourceText + "\x3c/script>");
234 }, goog.lastNonModuleScriptIndex_ = 0, goog.onScriptLoad_ = function(script, scriptIndex) {
235 "complete" == script.readyState && goog.lastNonModuleScriptIndex_ == scriptIndex && goog.loadQueuedModules_();
237 }, goog.writeScripts_ = function() {
238 function visitNode(path) {
239 if (!(path in deps.written)) {
240 if (!(path in deps.visited) && (deps.visited[path] = !0, path in deps.requires)) {
241 for (var requireName in deps.requires[path]) {
242 if (!goog.isProvided_(requireName)) {
243 if (requireName in deps.nameToPath) {
244 visitNode(deps.nameToPath[requireName]);
246 throw Error("Undefined nameToPath for " + requireName);
251 path in seenScript || (seenScript[path] = !0, scripts.push(path));
254 var scripts = [], seenScript = {}, deps = goog.dependencies_, path$$0;
255 for (path$$0 in goog.included_) {
256 deps.written[path$$0] || visitNode(path$$0);
258 for (var i = 0;i < scripts.length;i++) {
259 path$$0 = scripts[i], goog.dependencies_.written[path$$0] = !0;
261 var moduleState = goog.moduleLoaderState_;
262 goog.moduleLoaderState_ = null;
263 for (i = 0;i < scripts.length;i++) {
264 if (path$$0 = scripts[i]) {
265 deps.pathIsModule[path$$0] ? goog.importModule_(goog.basePath + path$$0) : goog.importScript_(goog.basePath + path$$0);
267 throw goog.moduleLoaderState_ = moduleState, Error("Undefined script input");
270 goog.moduleLoaderState_ = moduleState;
271 }, goog.getPathFromDeps_ = function(rule) {
272 return rule in goog.dependencies_.nameToPath ? goog.dependencies_.nameToPath[rule] : null;
273 }, goog.findBasePath_(), goog.global.CLOSURE_NO_DEPS || goog.importScript_(goog.basePath + "deps.js"));
274 goog.typeOf = function(value) {
275 var s = typeof value;
278 if (value instanceof Array) {
281 if (value instanceof Object) {
284 var className = Object.prototype.toString.call(value);
285 if ("[object Window]" == className) {
288 if ("[object Array]" == className || "number" == typeof value.length && "undefined" != typeof value.splice && "undefined" != typeof value.propertyIsEnumerable && !value.propertyIsEnumerable("splice")) {
291 if ("[object Function]" == className || "undefined" != typeof value.call && "undefined" != typeof value.propertyIsEnumerable && !value.propertyIsEnumerable("call")) {
298 if ("function" == s && "undefined" == typeof value.call) {
304 goog.isNull = function(val) {
307 goog.isDefAndNotNull = function(val) {
310 goog.isArray = function(val) {
311 return "array" == goog.typeOf(val);
313 goog.isArrayLike = function(val) {
314 var type = goog.typeOf(val);
315 return "array" == type || "object" == type && "number" == typeof val.length;
317 goog.isDateLike = function(val) {
318 return goog.isObject(val) && "function" == typeof val.getFullYear;
320 goog.isString = function(val) {
321 return "string" == typeof val;
323 goog.isBoolean = function(val) {
324 return "boolean" == typeof val;
326 goog.isNumber = function(val) {
327 return "number" == typeof val;
329 goog.isFunction = function(val) {
330 return "function" == goog.typeOf(val);
332 goog.isObject = function(val) {
333 var type = typeof val;
334 return "object" == type && null != val || "function" == type;
336 goog.getUid = function(obj) {
337 return obj[goog.UID_PROPERTY_] || (obj[goog.UID_PROPERTY_] = ++goog.uidCounter_);
339 goog.hasUid = function(obj) {
340 return!!obj[goog.UID_PROPERTY_];
342 goog.removeUid = function(obj) {
343 "removeAttribute" in obj && obj.removeAttribute(goog.UID_PROPERTY_);
345 delete obj[goog.UID_PROPERTY_];
349 goog.UID_PROPERTY_ = "closure_uid_" + (1E9 * Math.random() >>> 0);
350 goog.uidCounter_ = 0;
351 goog.getHashCode = goog.getUid;
352 goog.removeHashCode = goog.removeUid;
353 goog.cloneObject = function(obj) {
354 var type = goog.typeOf(obj);
355 if ("object" == type || "array" == type) {
359 var clone = "array" == type ? [] : {}, key;
361 clone[key] = goog.cloneObject(obj[key]);
367 goog.bindNative_ = function(fn, selfObj, var_args) {
368 return fn.call.apply(fn.bind, arguments);
370 goog.bindJs_ = function(fn, selfObj, var_args) {
374 if (2 < arguments.length) {
375 var boundArgs = Array.prototype.slice.call(arguments, 2);
377 var newArgs = Array.prototype.slice.call(arguments);
378 Array.prototype.unshift.apply(newArgs, boundArgs);
379 return fn.apply(selfObj, newArgs);
383 return fn.apply(selfObj, arguments);
386 goog.bind = function(fn, selfObj, var_args) {
387 Function.prototype.bind && -1 != Function.prototype.bind.toString().indexOf("native code") ? goog.bind = goog.bindNative_ : goog.bind = goog.bindJs_;
388 return goog.bind.apply(null, arguments);
390 goog.partial = function(fn, var_args) {
391 var args = Array.prototype.slice.call(arguments, 1);
393 var newArgs = args.slice();
394 newArgs.push.apply(newArgs, arguments);
395 return fn.apply(this, newArgs);
398 goog.mixin = function(target, source) {
399 for (var x in source) {
400 target[x] = source[x];
403 goog.now = goog.TRUSTED_SITE && Date.now || function() {
406 goog.globalEval = function(script) {
407 if (goog.global.execScript) {
408 goog.global.execScript(script, "JavaScript");
410 if (goog.global.eval) {
411 if (null == goog.evalWorksForGlobals_ && (goog.global.eval("var _et_ = 1;"), "undefined" != typeof goog.global._et_ ? (delete goog.global._et_, goog.evalWorksForGlobals_ = !0) : goog.evalWorksForGlobals_ = !1), goog.evalWorksForGlobals_) {
412 goog.global.eval(script);
414 var doc = goog.global.document, scriptElt = doc.createElement("script");
415 scriptElt.type = "text/javascript";
416 scriptElt.defer = !1;
417 scriptElt.appendChild(doc.createTextNode(script));
418 doc.body.appendChild(scriptElt);
419 doc.body.removeChild(scriptElt);
422 throw Error("goog.globalEval not available");
426 goog.evalWorksForGlobals_ = null;
427 goog.getCssName = function(className, opt_modifier) {
428 var getMapping = function(cssName) {
429 return goog.cssNameMapping_[cssName] || cssName;
430 }, renameByParts = function(cssName) {
431 for (var parts = cssName.split("-"), mapped = [], i = 0;i < parts.length;i++) {
432 mapped.push(getMapping(parts[i]));
434 return mapped.join("-");
436 rename = goog.cssNameMapping_ ? "BY_WHOLE" == goog.cssNameMappingStyle_ ? getMapping : renameByParts : function(a) {
439 return opt_modifier ? className + "-" + rename(opt_modifier) : rename(className);
441 goog.setCssNameMapping = function(mapping, opt_style) {
442 goog.cssNameMapping_ = mapping;
443 goog.cssNameMappingStyle_ = opt_style;
445 goog.getMsg = function(str, opt_values) {
446 opt_values && (str = str.replace(/\{\$([^}]+)}/g, function(match, key) {
447 return key in opt_values ? opt_values[key] : match;
451 goog.getMsgWithFallback = function(a) {
454 goog.exportSymbol = function(publicPath, object, opt_objectToExportTo) {
455 goog.exportPath_(publicPath, object, opt_objectToExportTo);
457 goog.exportProperty = function(object, publicName, symbol) {
458 object[publicName] = symbol;
460 goog.inherits = function(childCtor, parentCtor) {
461 function tempCtor() {
463 tempCtor.prototype = parentCtor.prototype;
464 childCtor.superClass_ = parentCtor.prototype;
465 childCtor.prototype = new tempCtor;
466 childCtor.prototype.constructor = childCtor;
467 childCtor.base = function(me, methodName, var_args) {
468 var args = Array.prototype.slice.call(arguments, 2);
469 return parentCtor.prototype[methodName].apply(me, args);
472 goog.base = function(me, opt_methodName, var_args) {
473 var caller = arguments.callee.caller;
474 if (goog.STRICT_MODE_COMPATIBLE || goog.DEBUG && !caller) {
475 throw Error("arguments.caller not defined. goog.base() cannot be used with strict mode code. See http://www.ecma-international.org/ecma-262/5.1/#sec-C");
477 if (caller.superClass_) {
478 return caller.superClass_.constructor.apply(me, Array.prototype.slice.call(arguments, 1));
480 for (var args = Array.prototype.slice.call(arguments, 2), foundCaller = !1, ctor = me.constructor;ctor;ctor = ctor.superClass_ && ctor.superClass_.constructor) {
481 if (ctor.prototype[opt_methodName] === caller) {
485 return ctor.prototype[opt_methodName].apply(me, args);
489 if (me[opt_methodName] === caller) {
490 return me.constructor.prototype[opt_methodName].apply(me, args);
492 throw Error("goog.base called from a method of one name to a method of a different name");
494 goog.scope = function(fn) {
495 fn.call(goog.global);
497 goog.MODIFY_FUNCTION_PROTOTYPES = !0;
498 goog.MODIFY_FUNCTION_PROTOTYPES && (Function.prototype.bind = Function.prototype.bind || function(selfObj, var_args) {
499 if (1 < arguments.length) {
500 var args = Array.prototype.slice.call(arguments, 1);
501 args.unshift(this, selfObj);
502 return goog.bind.apply(null, args);
504 return goog.bind(this, selfObj);
505 }, Function.prototype.partial = function(var_args) {
506 var args = Array.prototype.slice.call(arguments);
507 args.unshift(this, null);
508 return goog.bind.apply(null, args);
509 }, Function.prototype.inherits = function(parentCtor) {
510 goog.inherits(this, parentCtor);
511 }, Function.prototype.mixin = function(source) {
512 goog.mixin(this.prototype, source);
514 goog.defineClass = function(superClass, def) {
515 var constructor = def.constructor, statics = def.statics;
516 constructor && constructor != Object.prototype.constructor || (constructor = function() {
517 throw Error("cannot instantiate an interface (no constructor defined).");
519 var cls = goog.defineClass.createSealingConstructor_(constructor, superClass);
520 superClass && goog.inherits(cls, superClass);
521 delete def.constructor;
523 goog.defineClass.applyProperties_(cls.prototype, def);
524 null != statics && (statics instanceof Function ? statics(cls) : goog.defineClass.applyProperties_(cls, statics));
527 goog.defineClass.SEAL_CLASS_INSTANCES = goog.DEBUG;
528 goog.defineClass.createSealingConstructor_ = function(ctr, superClass) {
529 if (goog.defineClass.SEAL_CLASS_INSTANCES && Object.seal instanceof Function) {
530 if (superClass && superClass.prototype && superClass.prototype[goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_]) {
533 var wrappedCtr = function() {
534 var instance = ctr.apply(this, arguments) || this;
535 instance[goog.UID_PROPERTY_] = instance[goog.UID_PROPERTY_];
536 this.constructor === wrappedCtr && Object.seal(instance);
543 goog.defineClass.OBJECT_PROTOTYPE_FIELDS_ = "constructor hasOwnProperty isPrototypeOf propertyIsEnumerable toLocaleString toString valueOf".split(" ");
544 goog.defineClass.applyProperties_ = function(target, source) {
545 for (var key in source) {
546 Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
548 for (var i = 0;i < goog.defineClass.OBJECT_PROTOTYPE_FIELDS_.length;i++) {
549 key = goog.defineClass.OBJECT_PROTOTYPE_FIELDS_[i], Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
552 goog.tagUnsealableClass = function() {
554 goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_ = "goog_defineClass_legacy_unsealable";
556 goog.debug.Error = function(opt_msg) {
557 if (Error.captureStackTrace) {
558 Error.captureStackTrace(this, goog.debug.Error);
560 var stack = Error().stack;
561 stack && (this.stack = stack);
563 opt_msg && (this.message = String(opt_msg));
565 goog.inherits(goog.debug.Error, Error);
566 goog.debug.Error.prototype.name = "CustomError";
568 goog.dom.NodeType = {ELEMENT:1, ATTRIBUTE:2, TEXT:3, CDATA_SECTION:4, ENTITY_REFERENCE:5, ENTITY:6, PROCESSING_INSTRUCTION:7, COMMENT:8, DOCUMENT:9, DOCUMENT_TYPE:10, DOCUMENT_FRAGMENT:11, NOTATION:12};
570 goog.string.DETECT_DOUBLE_ESCAPING = !1;
571 goog.string.Unicode = {NBSP:"\u00a0"};
572 goog.string.startsWith = function(str, prefix) {
573 return 0 == str.lastIndexOf(prefix, 0);
575 goog.string.endsWith = function(str, suffix) {
576 var l = str.length - suffix.length;
577 return 0 <= l && str.indexOf(suffix, l) == l;
579 goog.string.caseInsensitiveStartsWith = function(str, prefix) {
580 return 0 == goog.string.caseInsensitiveCompare(prefix, str.substr(0, prefix.length));
582 goog.string.caseInsensitiveEndsWith = function(str, suffix) {
583 return 0 == goog.string.caseInsensitiveCompare(suffix, str.substr(str.length - suffix.length, suffix.length));
585 goog.string.caseInsensitiveEquals = function(str1, str2) {
586 return str1.toLowerCase() == str2.toLowerCase();
588 goog.string.subs = function(str, var_args) {
589 for (var splitParts = str.split("%s"), returnString = "", subsArguments = Array.prototype.slice.call(arguments, 1);subsArguments.length && 1 < splitParts.length;) {
590 returnString += splitParts.shift() + subsArguments.shift();
592 return returnString + splitParts.join("%s");
594 goog.string.collapseWhitespace = function(str) {
595 return str.replace(/[\s\xa0]+/g, " ").replace(/^\s+|\s+$/g, "");
597 goog.string.isEmptyOrWhitespace = function(str) {
598 return/^[\s\xa0]*$/.test(str);
600 goog.string.isEmptyString = function(str) {
601 return 0 == str.length;
603 goog.string.isEmpty = goog.string.isEmptyOrWhitespace;
604 goog.string.isEmptyOrWhitespaceSafe = function(str) {
605 return goog.string.isEmptyOrWhitespace(goog.string.makeSafe(str));
607 goog.string.isEmptySafe = goog.string.isEmptyOrWhitespaceSafe;
608 goog.string.isBreakingWhitespace = function(str) {
609 return!/[^\t\n\r ]/.test(str);
611 goog.string.isAlpha = function(str) {
612 return!/[^a-zA-Z]/.test(str);
614 goog.string.isNumeric = function(str) {
615 return!/[^0-9]/.test(str);
617 goog.string.isAlphaNumeric = function(str) {
618 return!/[^a-zA-Z0-9]/.test(str);
620 goog.string.isSpace = function(ch) {
623 goog.string.isUnicodeChar = function(ch) {
624 return 1 == ch.length && " " <= ch && "~" >= ch || "\u0080" <= ch && "\ufffd" >= ch;
626 goog.string.stripNewlines = function(str) {
627 return str.replace(/(\r\n|\r|\n)+/g, " ");
629 goog.string.canonicalizeNewlines = function(str) {
630 return str.replace(/(\r\n|\r|\n)/g, "\n");
632 goog.string.normalizeWhitespace = function(str) {
633 return str.replace(/\xa0|\s/g, " ");
635 goog.string.normalizeSpaces = function(str) {
636 return str.replace(/\xa0|[ \t]+/g, " ");
638 goog.string.collapseBreakingSpaces = function(str) {
639 return str.replace(/[\t\r\n ]+/g, " ").replace(/^[\t\r\n ]+|[\t\r\n ]+$/g, "");
641 goog.string.trim = goog.TRUSTED_SITE && String.prototype.trim ? function(str) {
644 return str.replace(/^[\s\xa0]+|[\s\xa0]+$/g, "");
646 goog.string.trimLeft = function(str) {
647 return str.replace(/^[\s\xa0]+/, "");
649 goog.string.trimRight = function(str) {
650 return str.replace(/[\s\xa0]+$/, "");
652 goog.string.caseInsensitiveCompare = function(str1, str2) {
653 var test1 = String(str1).toLowerCase(), test2 = String(str2).toLowerCase();
654 return test1 < test2 ? -1 : test1 == test2 ? 0 : 1;
656 goog.string.numerateCompareRegExp_ = /(\.\d+)|(\d+)|(\D+)/g;
657 goog.string.numerateCompare = function(str1, str2) {
667 for (var tokens1 = str1.toLowerCase().match(goog.string.numerateCompareRegExp_), tokens2 = str2.toLowerCase().match(goog.string.numerateCompareRegExp_), count = Math.min(tokens1.length, tokens2.length), i = 0;i < count;i++) {
668 var a = tokens1[i], b = tokens2[i];
670 var num1 = parseInt(a, 10);
672 var num2 = parseInt(b, 10);
673 if (!isNaN(num2) && num1 - num2) {
677 return a < b ? -1 : 1;
680 return tokens1.length != tokens2.length ? tokens1.length - tokens2.length : str1 < str2 ? -1 : 1;
682 goog.string.urlEncode = function(str) {
683 return encodeURIComponent(String(str));
685 goog.string.urlDecode = function(str) {
686 return decodeURIComponent(str.replace(/\+/g, " "));
688 goog.string.newLineToBr = function(str, opt_xml) {
689 return str.replace(/(\r\n|\r|\n)/g, opt_xml ? "<br />" : "<br>");
691 goog.string.htmlEscape = function(str, opt_isLikelyToContainHtmlChars) {
692 if (opt_isLikelyToContainHtmlChars) {
693 str = str.replace(goog.string.AMP_RE_, "&").replace(goog.string.LT_RE_, "<").replace(goog.string.GT_RE_, ">").replace(goog.string.QUOT_RE_, """).replace(goog.string.SINGLE_QUOTE_RE_, "'").replace(goog.string.NULL_RE_, "�"), goog.string.DETECT_DOUBLE_ESCAPING && (str = str.replace(goog.string.E_RE_, "e"));
695 if (!goog.string.ALL_RE_.test(str)) {
698 -1 != str.indexOf("&") && (str = str.replace(goog.string.AMP_RE_, "&"));
699 -1 != str.indexOf("<") && (str = str.replace(goog.string.LT_RE_, "<"));
700 -1 != str.indexOf(">") && (str = str.replace(goog.string.GT_RE_, ">"));
701 -1 != str.indexOf('"') && (str = str.replace(goog.string.QUOT_RE_, """));
702 -1 != str.indexOf("'") && (str = str.replace(goog.string.SINGLE_QUOTE_RE_, "'"));
703 -1 != str.indexOf("\x00") && (str = str.replace(goog.string.NULL_RE_, "�"));
704 goog.string.DETECT_DOUBLE_ESCAPING && -1 != str.indexOf("e") && (str = str.replace(goog.string.E_RE_, "e"));
708 goog.string.AMP_RE_ = /&/g;
709 goog.string.LT_RE_ = /</g;
710 goog.string.GT_RE_ = />/g;
711 goog.string.QUOT_RE_ = /"/g;
712 goog.string.SINGLE_QUOTE_RE_ = /'/g;
713 goog.string.NULL_RE_ = /\x00/g;
714 goog.string.E_RE_ = /e/g;
715 goog.string.ALL_RE_ = goog.string.DETECT_DOUBLE_ESCAPING ? /[\x00&<>"'e]/ : /[\x00&<>"']/;
716 goog.string.unescapeEntities = function(str) {
717 return goog.string.contains(str, "&") ? "document" in goog.global ? goog.string.unescapeEntitiesUsingDom_(str) : goog.string.unescapePureXmlEntities_(str) : str;
719 goog.string.unescapeEntitiesWithDocument = function(str, document) {
720 return goog.string.contains(str, "&") ? goog.string.unescapeEntitiesUsingDom_(str, document) : str;
722 goog.string.unescapeEntitiesUsingDom_ = function(str, opt_document) {
723 var seen = {"&":"&", "<":"<", ">":">", """:'"'}, div;
724 div = opt_document ? opt_document.createElement("div") : goog.global.document.createElement("div");
725 return str.replace(goog.string.HTML_ENTITY_PATTERN_, function(s, entity) {
730 if ("#" == entity.charAt(0)) {
731 var n = Number("0" + entity.substr(1));
732 isNaN(n) || (value = String.fromCharCode(n));
734 value || (div.innerHTML = s + " ", value = div.firstChild.nodeValue.slice(0, -1));
735 return seen[s] = value;
738 goog.string.unescapePureXmlEntities_ = function(str) {
739 return str.replace(/&([^;]+);/g, function(s, entity) {
750 if ("#" == entity.charAt(0)) {
751 var n = Number("0" + entity.substr(1));
753 return String.fromCharCode(n);
760 goog.string.HTML_ENTITY_PATTERN_ = /&([^;\s<&]+);?/g;
761 goog.string.whitespaceEscape = function(str, opt_xml) {
762 return goog.string.newLineToBr(str.replace(/ /g, "  "), opt_xml);
764 goog.string.preserveSpaces = function(str) {
765 return str.replace(/(^|[\n ]) /g, "$1" + goog.string.Unicode.NBSP);
767 goog.string.stripQuotes = function(str, quoteChars) {
768 for (var length = quoteChars.length, i = 0;i < length;i++) {
769 var quoteChar = 1 == length ? quoteChars : quoteChars.charAt(i);
770 if (str.charAt(0) == quoteChar && str.charAt(str.length - 1) == quoteChar) {
771 return str.substring(1, str.length - 1);
776 goog.string.truncate = function(str, chars, opt_protectEscapedCharacters) {
777 opt_protectEscapedCharacters && (str = goog.string.unescapeEntities(str));
778 str.length > chars && (str = str.substring(0, chars - 3) + "...");
779 opt_protectEscapedCharacters && (str = goog.string.htmlEscape(str));
782 goog.string.truncateMiddle = function(str, chars, opt_protectEscapedCharacters, opt_trailingChars) {
783 opt_protectEscapedCharacters && (str = goog.string.unescapeEntities(str));
784 if (opt_trailingChars && str.length > chars) {
785 opt_trailingChars > chars && (opt_trailingChars = chars);
786 var endPoint = str.length - opt_trailingChars, startPoint = chars - opt_trailingChars;
787 str = str.substring(0, startPoint) + "..." + str.substring(endPoint);
789 if (str.length > chars) {
790 var half = Math.floor(chars / 2), endPos = str.length - half, half = half + chars % 2;
791 str = str.substring(0, half) + "..." + str.substring(endPos);
794 opt_protectEscapedCharacters && (str = goog.string.htmlEscape(str));
797 goog.string.specialEscapeChars_ = {"\x00":"\\0", "\b":"\\b", "\f":"\\f", "\n":"\\n", "\r":"\\r", "\t":"\\t", "\x0B":"\\x0B", '"':'\\"', "\\":"\\\\"};
798 goog.string.jsEscapeCache_ = {"'":"\\'"};
799 goog.string.quote = function(s) {
804 for (var sb = ['"'], i = 0;i < s.length;i++) {
805 var ch = s.charAt(i), cc = ch.charCodeAt(0);
806 sb[i + 1] = goog.string.specialEscapeChars_[ch] || (31 < cc && 127 > cc ? ch : goog.string.escapeChar(ch));
811 goog.string.escapeString = function(str) {
812 for (var sb = [], i = 0;i < str.length;i++) {
813 sb[i] = goog.string.escapeChar(str.charAt(i));
817 goog.string.escapeChar = function(c) {
818 if (c in goog.string.jsEscapeCache_) {
819 return goog.string.jsEscapeCache_[c];
821 if (c in goog.string.specialEscapeChars_) {
822 return goog.string.jsEscapeCache_[c] = goog.string.specialEscapeChars_[c];
824 var rv = c, cc = c.charCodeAt(0);
825 if (31 < cc && 127 > cc) {
829 if (rv = "\\x", 16 > cc || 256 < cc) {
833 rv = "\\u", 4096 > cc && (rv += "0");
835 rv += cc.toString(16).toUpperCase();
837 return goog.string.jsEscapeCache_[c] = rv;
839 goog.string.contains = function(str, subString) {
840 return-1 != str.indexOf(subString);
842 goog.string.caseInsensitiveContains = function(str, subString) {
843 return goog.string.contains(str.toLowerCase(), subString.toLowerCase());
845 goog.string.countOf = function(s, ss) {
846 return s && ss ? s.split(ss).length - 1 : 0;
848 goog.string.removeAt = function(s, index, stringLength) {
850 0 <= index && index < s.length && 0 < stringLength && (resultStr = s.substr(0, index) + s.substr(index + stringLength, s.length - index - stringLength));
853 goog.string.remove = function(s, ss) {
854 var re = new RegExp(goog.string.regExpEscape(ss), "");
855 return s.replace(re, "");
857 goog.string.removeAll = function(s, ss) {
858 var re = new RegExp(goog.string.regExpEscape(ss), "g");
859 return s.replace(re, "");
861 goog.string.regExpEscape = function(s) {
862 return String(s).replace(/([-()\[\]{}+?*.$\^|,:#<!\\])/g, "\\$1").replace(/\x08/g, "\\x08");
864 goog.string.repeat = function(string, length) {
865 return Array(length + 1).join(string);
867 goog.string.padNumber = function(num, length, opt_precision) {
868 var s = goog.isDef(opt_precision) ? num.toFixed(opt_precision) : String(num), index = s.indexOf(".");
869 -1 == index && (index = s.length);
870 return goog.string.repeat("0", Math.max(0, length - index)) + s;
872 goog.string.makeSafe = function(obj) {
873 return null == obj ? "" : String(obj);
875 goog.string.buildString = function(var_args) {
876 return Array.prototype.join.call(arguments, "");
878 goog.string.getRandomString = function() {
879 return Math.floor(2147483648 * Math.random()).toString(36) + Math.abs(Math.floor(2147483648 * Math.random()) ^ goog.now()).toString(36);
881 goog.string.compareVersions = function(version1, version2) {
882 for (var order = 0, v1Subs = goog.string.trim(String(version1)).split("."), v2Subs = goog.string.trim(String(version2)).split("."), subCount = Math.max(v1Subs.length, v2Subs.length), subIdx = 0;0 == order && subIdx < subCount;subIdx++) {
883 var v1Sub = v1Subs[subIdx] || "", v2Sub = v2Subs[subIdx] || "", v1CompParser = RegExp("(\\d*)(\\D*)", "g"), v2CompParser = RegExp("(\\d*)(\\D*)", "g");
885 var v1Comp = v1CompParser.exec(v1Sub) || ["", "", ""], v2Comp = v2CompParser.exec(v2Sub) || ["", "", ""];
886 if (0 == v1Comp[0].length && 0 == v2Comp[0].length) {
889 var v1CompNum = 0 == v1Comp[1].length ? 0 : parseInt(v1Comp[1], 10), v2CompNum = 0 == v2Comp[1].length ? 0 : parseInt(v2Comp[1], 10), order = goog.string.compareElements_(v1CompNum, v2CompNum) || goog.string.compareElements_(0 == v1Comp[2].length, 0 == v2Comp[2].length) || goog.string.compareElements_(v1Comp[2], v2Comp[2]);
890 } while (0 == order);
894 goog.string.compareElements_ = function(left, right) {
895 return left < right ? -1 : left > right ? 1 : 0;
897 goog.string.HASHCODE_MAX_ = 4294967296;
898 goog.string.hashCode = function(str) {
899 for (var result = 0, i = 0;i < str.length;++i) {
900 result = 31 * result + str.charCodeAt(i), result %= goog.string.HASHCODE_MAX_;
904 goog.string.uniqueStringCounter_ = 2147483648 * Math.random() | 0;
905 goog.string.createUniqueString = function() {
906 return "goog_" + goog.string.uniqueStringCounter_++;
908 goog.string.toNumber = function(str) {
909 var num = Number(str);
910 return 0 == num && goog.string.isEmpty(str) ? NaN : num;
912 goog.string.isLowerCamelCase = function(str) {
913 return/^[a-z]+([A-Z][a-z]*)*$/.test(str);
915 goog.string.isUpperCamelCase = function(str) {
916 return/^([A-Z][a-z]*)+$/.test(str);
918 goog.string.toCamelCase = function(str) {
919 return String(str).replace(/\-([a-z])/g, function(all, match) {
920 return match.toUpperCase();
923 goog.string.toSelectorCase = function(str) {
924 return String(str).replace(/([A-Z])/g, "-$1").toLowerCase();
926 goog.string.toTitleCase = function(str, opt_delimiters) {
927 var delimiters = goog.isString(opt_delimiters) ? goog.string.regExpEscape(opt_delimiters) : "\\s", delimiters = delimiters ? "|[" + delimiters + "]+" : "", regexp = new RegExp("(^" + delimiters + ")([a-z])", "g");
928 return str.replace(regexp, function(all, p1, p2) {
929 return p1 + p2.toUpperCase();
932 goog.string.parseInt = function(value) {
933 isFinite(value) && (value = String(value));
934 return goog.isString(value) ? /^\s*-?0x/i.test(value) ? parseInt(value, 16) : parseInt(value, 10) : NaN;
936 goog.string.splitLimit = function(str, separator, limit) {
937 for (var parts = str.split(separator), returnVal = [];0 < limit && parts.length;) {
938 returnVal.push(parts.shift()), limit--;
940 parts.length && returnVal.push(parts.join(separator));
944 goog.asserts.ENABLE_ASSERTS = goog.DEBUG;
945 goog.asserts.AssertionError = function(messagePattern, messageArgs) {
946 messageArgs.unshift(messagePattern);
947 goog.debug.Error.call(this, goog.string.subs.apply(null, messageArgs));
950 goog.inherits(goog.asserts.AssertionError, goog.debug.Error);
951 goog.asserts.AssertionError.prototype.name = "AssertionError";
952 goog.asserts.DEFAULT_ERROR_HANDLER = function(e) {
955 goog.asserts.errorHandler_ = goog.asserts.DEFAULT_ERROR_HANDLER;
956 goog.asserts.doAssertFailure_ = function(defaultMessage, defaultArgs, givenMessage, givenArgs) {
957 var message = "Assertion failed";
959 var message = message + (": " + givenMessage), args = givenArgs
961 defaultMessage && (message += ": " + defaultMessage, args = defaultArgs);
963 var e = new goog.asserts.AssertionError("" + message, args || []);
964 goog.asserts.errorHandler_(e);
966 goog.asserts.setErrorHandler = function(errorHandler) {
967 goog.asserts.ENABLE_ASSERTS && (goog.asserts.errorHandler_ = errorHandler);
969 goog.asserts.assert = function(condition, opt_message, var_args) {
970 goog.asserts.ENABLE_ASSERTS && !condition && goog.asserts.doAssertFailure_("", null, opt_message, Array.prototype.slice.call(arguments, 2));
973 goog.asserts.fail = function(opt_message, var_args) {
974 goog.asserts.ENABLE_ASSERTS && goog.asserts.errorHandler_(new goog.asserts.AssertionError("Failure" + (opt_message ? ": " + opt_message : ""), Array.prototype.slice.call(arguments, 1)));
976 goog.asserts.assertNumber = function(value, opt_message, var_args) {
977 goog.asserts.ENABLE_ASSERTS && !goog.isNumber(value) && goog.asserts.doAssertFailure_("Expected number but got %s: %s.", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));
980 goog.asserts.assertString = function(value, opt_message, var_args) {
981 goog.asserts.ENABLE_ASSERTS && !goog.isString(value) && goog.asserts.doAssertFailure_("Expected string but got %s: %s.", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));
984 goog.asserts.assertFunction = function(value, opt_message, var_args) {
985 goog.asserts.ENABLE_ASSERTS && !goog.isFunction(value) && goog.asserts.doAssertFailure_("Expected function but got %s: %s.", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));
988 goog.asserts.assertObject = function(value, opt_message, var_args) {
989 goog.asserts.ENABLE_ASSERTS && !goog.isObject(value) && goog.asserts.doAssertFailure_("Expected object but got %s: %s.", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));
992 goog.asserts.assertArray = function(value, opt_message, var_args) {
993 goog.asserts.ENABLE_ASSERTS && !goog.isArray(value) && goog.asserts.doAssertFailure_("Expected array but got %s: %s.", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));
996 goog.asserts.assertBoolean = function(value, opt_message, var_args) {
997 goog.asserts.ENABLE_ASSERTS && !goog.isBoolean(value) && goog.asserts.doAssertFailure_("Expected boolean but got %s: %s.", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));
1000 goog.asserts.assertElement = function(value, opt_message, var_args) {
1001 !goog.asserts.ENABLE_ASSERTS || goog.isObject(value) && value.nodeType == goog.dom.NodeType.ELEMENT || goog.asserts.doAssertFailure_("Expected Element but got %s: %s.", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));
1004 goog.asserts.assertInstanceof = function(value, type, opt_message, var_args) {
1005 !goog.asserts.ENABLE_ASSERTS || value instanceof type || goog.asserts.doAssertFailure_("instanceof check failed.", null, opt_message, Array.prototype.slice.call(arguments, 3));
1008 goog.asserts.assertObjectPrototypeIsIntact = function() {
1009 for (var key in Object.prototype) {
1010 goog.asserts.fail(key + " should not be enumerable in Object.prototype.");
1014 goog.NATIVE_ARRAY_PROTOTYPES = goog.TRUSTED_SITE;
1015 goog.array.ASSUME_NATIVE_FUNCTIONS = !1;
1016 goog.array.peek = function(array) {
1017 return array[array.length - 1];
1019 goog.array.last = goog.array.peek;
1020 goog.array.ARRAY_PROTOTYPE_ = Array.prototype;
1021 goog.array.indexOf = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || goog.array.ARRAY_PROTOTYPE_.indexOf) ? function(arr, obj, opt_fromIndex) {
1022 goog.asserts.assert(null != arr.length);
1023 return goog.array.ARRAY_PROTOTYPE_.indexOf.call(arr, obj, opt_fromIndex);
1024 } : function(arr, obj, opt_fromIndex) {
1025 var fromIndex = null == opt_fromIndex ? 0 : 0 > opt_fromIndex ? Math.max(0, arr.length + opt_fromIndex) : opt_fromIndex;
1026 if (goog.isString(arr)) {
1027 return goog.isString(obj) && 1 == obj.length ? arr.indexOf(obj, fromIndex) : -1;
1029 for (var i = fromIndex;i < arr.length;i++) {
1030 if (i in arr && arr[i] === obj) {
1036 goog.array.lastIndexOf = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || goog.array.ARRAY_PROTOTYPE_.lastIndexOf) ? function(arr, obj, opt_fromIndex) {
1037 goog.asserts.assert(null != arr.length);
1038 var fromIndex = null == opt_fromIndex ? arr.length - 1 : opt_fromIndex;
1039 return goog.array.ARRAY_PROTOTYPE_.lastIndexOf.call(arr, obj, fromIndex);
1040 } : function(arr, obj, opt_fromIndex) {
1041 var fromIndex = null == opt_fromIndex ? arr.length - 1 : opt_fromIndex;
1042 0 > fromIndex && (fromIndex = Math.max(0, arr.length + fromIndex));
1043 if (goog.isString(arr)) {
1044 return goog.isString(obj) && 1 == obj.length ? arr.lastIndexOf(obj, fromIndex) : -1;
1046 for (var i = fromIndex;0 <= i;i--) {
1047 if (i in arr && arr[i] === obj) {
1053 goog.array.forEach = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || goog.array.ARRAY_PROTOTYPE_.forEach) ? function(arr, f, opt_obj) {
1054 goog.asserts.assert(null != arr.length);
1055 goog.array.ARRAY_PROTOTYPE_.forEach.call(arr, f, opt_obj);
1056 } : function(arr, f, opt_obj) {
1057 for (var l = arr.length, arr2 = goog.isString(arr) ? arr.split("") : arr, i = 0;i < l;i++) {
1058 i in arr2 && f.call(opt_obj, arr2[i], i, arr);
1061 goog.array.forEachRight = function(arr, f, opt_obj) {
1062 for (var l = arr.length, arr2 = goog.isString(arr) ? arr.split("") : arr, i = l - 1;0 <= i;--i) {
1063 i in arr2 && f.call(opt_obj, arr2[i], i, arr);
1066 goog.array.filter = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || goog.array.ARRAY_PROTOTYPE_.filter) ? function(arr, f, opt_obj) {
1067 goog.asserts.assert(null != arr.length);
1068 return goog.array.ARRAY_PROTOTYPE_.filter.call(arr, f, opt_obj);
1069 } : function(arr, f, opt_obj) {
1070 for (var l = arr.length, res = [], resLength = 0, arr2 = goog.isString(arr) ? arr.split("") : arr, i = 0;i < l;i++) {
1073 f.call(opt_obj, val, i, arr) && (res[resLength++] = val);
1078 goog.array.map = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || goog.array.ARRAY_PROTOTYPE_.map) ? function(arr, f, opt_obj) {
1079 goog.asserts.assert(null != arr.length);
1080 return goog.array.ARRAY_PROTOTYPE_.map.call(arr, f, opt_obj);
1081 } : function(arr, f, opt_obj) {
1082 for (var l = arr.length, res = Array(l), arr2 = goog.isString(arr) ? arr.split("") : arr, i = 0;i < l;i++) {
1083 i in arr2 && (res[i] = f.call(opt_obj, arr2[i], i, arr));
1087 goog.array.reduce = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || goog.array.ARRAY_PROTOTYPE_.reduce) ? function(arr, f, val, opt_obj) {
1088 goog.asserts.assert(null != arr.length);
1089 opt_obj && (f = goog.bind(f, opt_obj));
1090 return goog.array.ARRAY_PROTOTYPE_.reduce.call(arr, f, val);
1091 } : function(arr, f, val$$0, opt_obj) {
1093 goog.array.forEach(arr, function(val, index) {
1094 rval = f.call(opt_obj, rval, val, index, arr);
1098 goog.array.reduceRight = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || goog.array.ARRAY_PROTOTYPE_.reduceRight) ? function(arr, f, val, opt_obj) {
1099 goog.asserts.assert(null != arr.length);
1100 opt_obj && (f = goog.bind(f, opt_obj));
1101 return goog.array.ARRAY_PROTOTYPE_.reduceRight.call(arr, f, val);
1102 } : function(arr, f, val$$0, opt_obj) {
1104 goog.array.forEachRight(arr, function(val, index) {
1105 rval = f.call(opt_obj, rval, val, index, arr);
1109 goog.array.some = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || goog.array.ARRAY_PROTOTYPE_.some) ? function(arr, f, opt_obj) {
1110 goog.asserts.assert(null != arr.length);
1111 return goog.array.ARRAY_PROTOTYPE_.some.call(arr, f, opt_obj);
1112 } : function(arr, f, opt_obj) {
1113 for (var l = arr.length, arr2 = goog.isString(arr) ? arr.split("") : arr, i = 0;i < l;i++) {
1114 if (i in arr2 && f.call(opt_obj, arr2[i], i, arr)) {
1120 goog.array.every = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || goog.array.ARRAY_PROTOTYPE_.every) ? function(arr, f, opt_obj) {
1121 goog.asserts.assert(null != arr.length);
1122 return goog.array.ARRAY_PROTOTYPE_.every.call(arr, f, opt_obj);
1123 } : function(arr, f, opt_obj) {
1124 for (var l = arr.length, arr2 = goog.isString(arr) ? arr.split("") : arr, i = 0;i < l;i++) {
1125 if (i in arr2 && !f.call(opt_obj, arr2[i], i, arr)) {
1131 goog.array.count = function(arr$$0, f, opt_obj) {
1133 goog.array.forEach(arr$$0, function(element, index, arr) {
1134 f.call(opt_obj, element, index, arr) && ++count;
1138 goog.array.find = function(arr, f, opt_obj) {
1139 var i = goog.array.findIndex(arr, f, opt_obj);
1140 return 0 > i ? null : goog.isString(arr) ? arr.charAt(i) : arr[i];
1142 goog.array.findIndex = function(arr, f, opt_obj) {
1143 for (var l = arr.length, arr2 = goog.isString(arr) ? arr.split("") : arr, i = 0;i < l;i++) {
1144 if (i in arr2 && f.call(opt_obj, arr2[i], i, arr)) {
1150 goog.array.findRight = function(arr, f, opt_obj) {
1151 var i = goog.array.findIndexRight(arr, f, opt_obj);
1152 return 0 > i ? null : goog.isString(arr) ? arr.charAt(i) : arr[i];
1154 goog.array.findIndexRight = function(arr, f, opt_obj) {
1155 for (var l = arr.length, arr2 = goog.isString(arr) ? arr.split("") : arr, i = l - 1;0 <= i;i--) {
1156 if (i in arr2 && f.call(opt_obj, arr2[i], i, arr)) {
1162 goog.array.contains = function(arr, obj) {
1163 return 0 <= goog.array.indexOf(arr, obj);
1165 goog.array.isEmpty = function(arr) {
1166 return 0 == arr.length;
1168 goog.array.clear = function(arr) {
1169 if (!goog.isArray(arr)) {
1170 for (var i = arr.length - 1;0 <= i;i--) {
1176 goog.array.insert = function(arr, obj) {
1177 goog.array.contains(arr, obj) || arr.push(obj);
1179 goog.array.insertAt = function(arr, obj, opt_i) {
1180 goog.array.splice(arr, opt_i, 0, obj);
1182 goog.array.insertArrayAt = function(arr, elementsToAdd, opt_i) {
1183 goog.partial(goog.array.splice, arr, opt_i, 0).apply(null, elementsToAdd);
1185 goog.array.insertBefore = function(arr, obj, opt_obj2) {
1187 2 == arguments.length || 0 > (i = goog.array.indexOf(arr, opt_obj2)) ? arr.push(obj) : goog.array.insertAt(arr, obj, i);
1189 goog.array.remove = function(arr, obj) {
1190 var i = goog.array.indexOf(arr, obj), rv;
1191 (rv = 0 <= i) && goog.array.removeAt(arr, i);
1194 goog.array.removeAt = function(arr, i) {
1195 goog.asserts.assert(null != arr.length);
1196 return 1 == goog.array.ARRAY_PROTOTYPE_.splice.call(arr, i, 1).length;
1198 goog.array.removeIf = function(arr, f, opt_obj) {
1199 var i = goog.array.findIndex(arr, f, opt_obj);
1200 return 0 <= i ? (goog.array.removeAt(arr, i), !0) : !1;
1202 goog.array.removeAllIf = function(arr, f, opt_obj) {
1203 var removedCount = 0;
1204 goog.array.forEachRight(arr, function(val, index) {
1205 f.call(opt_obj, val, index, arr) && goog.array.removeAt(arr, index) && removedCount++;
1207 return removedCount;
1209 goog.array.concat = function(var_args) {
1210 return goog.array.ARRAY_PROTOTYPE_.concat.apply(goog.array.ARRAY_PROTOTYPE_, arguments);
1212 goog.array.join = function(var_args) {
1213 return goog.array.ARRAY_PROTOTYPE_.concat.apply(goog.array.ARRAY_PROTOTYPE_, arguments);
1215 goog.array.toArray = function(object) {
1216 var length = object.length;
1218 for (var rv = Array(length), i = 0;i < length;i++) {
1225 goog.array.clone = goog.array.toArray;
1226 goog.array.extend = function(arr1, var_args) {
1227 for (var i = 1;i < arguments.length;i++) {
1228 var arr2 = arguments[i], isArrayLike;
1229 if (goog.isArray(arr2) || (isArrayLike = goog.isArrayLike(arr2)) && Object.prototype.hasOwnProperty.call(arr2, "callee")) {
1230 arr1.push.apply(arr1, arr2);
1233 for (var len1 = arr1.length, len2 = arr2.length, j = 0;j < len2;j++) {
1234 arr1[len1 + j] = arr2[j];
1242 goog.array.splice = function(arr, index, howMany, var_args) {
1243 goog.asserts.assert(null != arr.length);
1244 return goog.array.ARRAY_PROTOTYPE_.splice.apply(arr, goog.array.slice(arguments, 1));
1246 goog.array.slice = function(arr, start, opt_end) {
1247 goog.asserts.assert(null != arr.length);
1248 return 2 >= arguments.length ? goog.array.ARRAY_PROTOTYPE_.slice.call(arr, start) : goog.array.ARRAY_PROTOTYPE_.slice.call(arr, start, opt_end);
1250 goog.array.removeDuplicates = function(arr, opt_rv, opt_hashFn) {
1251 for (var returnArray = opt_rv || arr, defaultHashFn = function() {
1252 return goog.isObject(current) ? "o" + goog.getUid(current) : (typeof current).charAt(0) + current;
1253 }, hashFn = opt_hashFn || defaultHashFn, seen = {}, cursorInsert = 0, cursorRead = 0;cursorRead < arr.length;) {
1254 var current = arr[cursorRead++], key = hashFn(current);
1255 Object.prototype.hasOwnProperty.call(seen, key) || (seen[key] = !0, returnArray[cursorInsert++] = current);
1257 returnArray.length = cursorInsert;
1259 goog.array.binarySearch = function(arr, target, opt_compareFn) {
1260 return goog.array.binarySearch_(arr, opt_compareFn || goog.array.defaultCompare, !1, target);
1262 goog.array.binarySelect = function(arr, evaluator, opt_obj) {
1263 return goog.array.binarySearch_(arr, evaluator, !0, void 0, opt_obj);
1265 goog.array.binarySearch_ = function(arr, compareFn, isEvaluator, opt_target, opt_selfObj) {
1266 for (var left = 0, right = arr.length, found;left < right;) {
1267 var middle = left + right >> 1, compareResult;
1268 compareResult = isEvaluator ? compareFn.call(opt_selfObj, arr[middle], middle, arr) : compareFn(opt_target, arr[middle]);
1269 0 < compareResult ? left = middle + 1 : (right = middle, found = !compareResult);
1271 return found ? left : ~left;
1273 goog.array.sort = function(arr, opt_compareFn) {
1274 arr.sort(opt_compareFn || goog.array.defaultCompare);
1276 goog.array.stableSort = function(arr, opt_compareFn) {
1277 function stableCompareFn(obj1, obj2) {
1278 return valueCompareFn(obj1.value, obj2.value) || obj1.index - obj2.index;
1280 for (var i = 0;i < arr.length;i++) {
1281 arr[i] = {index:i, value:arr[i]};
1283 var valueCompareFn = opt_compareFn || goog.array.defaultCompare;
1284 goog.array.sort(arr, stableCompareFn);
1285 for (i = 0;i < arr.length;i++) {
1286 arr[i] = arr[i].value;
1289 goog.array.sortByKey = function(arr, keyFn, opt_compareFn) {
1290 var keyCompareFn = opt_compareFn || goog.array.defaultCompare;
1291 goog.array.sort(arr, function(a, b) {
1292 return keyCompareFn(keyFn(a), keyFn(b));
1295 goog.array.sortObjectsByKey = function(arr, key, opt_compareFn) {
1296 goog.array.sortByKey(arr, function(obj) {
1300 goog.array.isSorted = function(arr, opt_compareFn, opt_strict) {
1301 for (var compare = opt_compareFn || goog.array.defaultCompare, i = 1;i < arr.length;i++) {
1302 var compareResult = compare(arr[i - 1], arr[i]);
1303 if (0 < compareResult || 0 == compareResult && opt_strict) {
1309 goog.array.equals = function(arr1, arr2, opt_equalsFn) {
1310 if (!goog.isArrayLike(arr1) || !goog.isArrayLike(arr2) || arr1.length != arr2.length) {
1313 for (var l = arr1.length, equalsFn = opt_equalsFn || goog.array.defaultCompareEquality, i = 0;i < l;i++) {
1314 if (!equalsFn(arr1[i], arr2[i])) {
1320 goog.array.compare3 = function(arr1, arr2, opt_compareFn) {
1321 for (var compare = opt_compareFn || goog.array.defaultCompare, l = Math.min(arr1.length, arr2.length), i = 0;i < l;i++) {
1322 var result = compare(arr1[i], arr2[i]);
1327 return goog.array.defaultCompare(arr1.length, arr2.length);
1329 goog.array.defaultCompare = function(a, b) {
1330 return a > b ? 1 : a < b ? -1 : 0;
1332 goog.array.defaultCompareEquality = function(a, b) {
1335 goog.array.binaryInsert = function(array, value, opt_compareFn) {
1336 var index = goog.array.binarySearch(array, value, opt_compareFn);
1337 return 0 > index ? (goog.array.insertAt(array, value, -(index + 1)), !0) : !1;
1339 goog.array.binaryRemove = function(array, value, opt_compareFn) {
1340 var index = goog.array.binarySearch(array, value, opt_compareFn);
1341 return 0 <= index ? goog.array.removeAt(array, index) : !1;
1343 goog.array.bucket = function(array, sorter, opt_obj) {
1344 for (var buckets = {}, i = 0;i < array.length;i++) {
1345 var value = array[i], key = sorter.call(opt_obj, value, i, array);
1346 if (goog.isDef(key)) {
1347 var bucket = buckets[key] || (buckets[key] = []);
1353 goog.array.toObject = function(arr, keyFunc, opt_obj) {
1355 goog.array.forEach(arr, function(element, index) {
1356 ret[keyFunc.call(opt_obj, element, index, arr)] = element;
1360 goog.array.range = function(startOrEnd, opt_end, opt_step) {
1361 var array = [], start = 0, end = startOrEnd, step = opt_step || 1;
1362 void 0 !== opt_end && (start = startOrEnd, end = opt_end);
1363 if (0 > step * (end - start)) {
1367 for (var i = start;i < end;i += step) {
1371 for (i = start;i > end;i += step) {
1377 goog.array.repeat = function(value, n) {
1378 for (var array = [], i = 0;i < n;i++) {
1383 goog.array.flatten = function(var_args) {
1384 for (var result = [], i = 0;i < arguments.length;i++) {
1385 var element = arguments[i];
1386 if (goog.isArray(element)) {
1387 for (var c = 0;c < element.length;c += 8192) {
1388 for (var chunk = goog.array.slice(element, c, c + 8192), recurseResult = goog.array.flatten.apply(null, chunk), r = 0;r < recurseResult.length;r++) {
1389 result.push(recurseResult[r]);
1393 result.push(element);
1398 goog.array.rotate = function(array, n) {
1399 goog.asserts.assert(null != array.length);
1400 array.length && (n %= array.length, 0 < n ? goog.array.ARRAY_PROTOTYPE_.unshift.apply(array, array.splice(-n, n)) : 0 > n && goog.array.ARRAY_PROTOTYPE_.push.apply(array, array.splice(0, -n)));
1403 goog.array.moveItem = function(arr, fromIndex, toIndex) {
1404 goog.asserts.assert(0 <= fromIndex && fromIndex < arr.length);
1405 goog.asserts.assert(0 <= toIndex && toIndex < arr.length);
1406 var removedItems = goog.array.ARRAY_PROTOTYPE_.splice.call(arr, fromIndex, 1);
1407 goog.array.ARRAY_PROTOTYPE_.splice.call(arr, toIndex, 0, removedItems[0]);
1409 goog.array.zip = function(var_args) {
1410 if (!arguments.length) {
1413 for (var result = [], i = 0;;i++) {
1414 for (var value = [], j = 0;j < arguments.length;j++) {
1415 var arr = arguments[j];
1416 if (i >= arr.length) {
1424 goog.array.shuffle = function(arr, opt_randFn) {
1425 for (var randFn = opt_randFn || Math.random, i = arr.length - 1;0 < i;i--) {
1426 var j = Math.floor(randFn() * (i + 1)), tmp = arr[i];
1432 goog.math.randomInt = function(a) {
1433 return Math.floor(Math.random() * a);
1435 goog.math.uniformRandom = function(a, b) {
1436 return a + Math.random() * (b - a);
1438 goog.math.clamp = function(value, min, max) {
1439 return Math.min(Math.max(value, min), max);
1441 goog.math.modulo = function(a, b) {
1443 return 0 > r * b ? r + b : r;
1445 goog.math.lerp = function(a, b, x) {
1446 return a + x * (b - a);
1448 goog.math.nearlyEquals = function(a, b, opt_tolerance) {
1449 return Math.abs(a - b) <= (opt_tolerance || 1E-6);
1451 goog.math.standardAngle = function(angle) {
1452 return goog.math.modulo(angle, 360);
1454 goog.math.standardAngleInRadians = function(angle) {
1455 return goog.math.modulo(angle, 2 * Math.PI);
1457 goog.math.toRadians = function(angleDegrees) {
1458 return angleDegrees * Math.PI / 180;
1460 goog.math.toDegrees = function(angleRadians) {
1461 return 180 * angleRadians / Math.PI;
1463 goog.math.angleDx = function(degrees, radius) {
1464 return radius * Math.cos(goog.math.toRadians(degrees));
1466 goog.math.angleDy = function(degrees, radius) {
1467 return radius * Math.sin(goog.math.toRadians(degrees));
1469 goog.math.angle = function(x1, y1, x2, y2) {
1470 return goog.math.standardAngle(goog.math.toDegrees(Math.atan2(y2 - y1, x2 - x1)));
1472 goog.math.angleDifference = function(startAngle, endAngle) {
1473 var d = goog.math.standardAngle(endAngle) - goog.math.standardAngle(startAngle);
1474 180 < d ? d -= 360 : -180 >= d && (d = 360 + d);
1477 goog.math.sign = function(x) {
1478 return 0 == x ? 0 : 0 > x ? -1 : 1;
1480 goog.math.longestCommonSubsequence = function(array1, array2, opt_compareFn, opt_collectorFn) {
1481 for (var compare = opt_compareFn || function(a, b) {
1483 }, collect = opt_collectorFn || function(i1) {
1485 }, length1 = array1.length, length2 = array2.length, arr = [], i = 0;i < length1 + 1;i++) {
1486 arr[i] = [], arr[i][0] = 0;
1488 for (var j = 0;j < length2 + 1;j++) {
1491 for (i = 1;i <= length1;i++) {
1492 for (j = 1;j <= length2;j++) {
1493 compare(array1[i - 1], array2[j - 1]) ? arr[i][j] = arr[i - 1][j - 1] + 1 : arr[i][j] = Math.max(arr[i - 1][j], arr[i][j - 1]);
1496 for (var result = [], i = length1, j = length2;0 < i && 0 < j;) {
1497 compare(array1[i - 1], array2[j - 1]) ? (result.unshift(collect(i - 1, j - 1)), i--, j--) : arr[i - 1][j] > arr[i][j - 1] ? i-- : j--;
1501 goog.math.sum = function(var_args) {
1502 return goog.array.reduce(arguments, function(sum, value) {
1506 goog.math.average = function(var_args) {
1507 return goog.math.sum.apply(null, arguments) / arguments.length;
1509 goog.math.sampleVariance = function(var_args) {
1510 var sampleSize = arguments.length;
1511 if (2 > sampleSize) {
1514 var mean = goog.math.average.apply(null, arguments), variance = goog.math.sum.apply(null, goog.array.map(arguments, function(val) {
1515 return Math.pow(val - mean, 2);
1516 })) / (sampleSize - 1);
1519 goog.math.standardDeviation = function(var_args) {
1520 return Math.sqrt(goog.math.sampleVariance.apply(null, arguments));
1522 goog.math.isInt = function(num) {
1523 return isFinite(num) && 0 == num % 1;
1525 goog.math.isFiniteNumber = function(num) {
1526 return isFinite(num) && !isNaN(num);
1528 goog.math.log10Floor = function(num) {
1530 var x = Math.round(Math.log(num) * Math.LOG10E);
1531 return x - (parseFloat("1e" + x) > num);
1533 return 0 == num ? -Infinity : NaN;
1535 goog.math.safeFloor = function(num, opt_epsilon) {
1536 goog.asserts.assert(!goog.isDef(opt_epsilon) || 0 < opt_epsilon);
1537 return Math.floor(num + (opt_epsilon || 2E-15));
1539 goog.math.safeCeil = function(num, opt_epsilon) {
1540 goog.asserts.assert(!goog.isDef(opt_epsilon) || 0 < opt_epsilon);
1541 return Math.ceil(num - (opt_epsilon || 2E-15));
1543 goog.math.Coordinate = function(opt_x, opt_y) {
1544 this.x = goog.isDef(opt_x) ? opt_x : 0;
1545 this.y = goog.isDef(opt_y) ? opt_y : 0;
1547 goog.math.Coordinate.prototype.clone = function() {
1548 return new goog.math.Coordinate(this.x, this.y);
1550 goog.DEBUG && (goog.math.Coordinate.prototype.toString = function() {
1551 return "(" + this.x + ", " + this.y + ")";
1553 goog.math.Coordinate.equals = function(a, b) {
1554 return a == b ? !0 : a && b ? a.x == b.x && a.y == b.y : !1;
1556 goog.math.Coordinate.distance = function(a, b) {
1557 var dx = a.x - b.x, dy = a.y - b.y;
1558 return Math.sqrt(dx * dx + dy * dy);
1560 goog.math.Coordinate.magnitude = function(a) {
1561 return Math.sqrt(a.x * a.x + a.y * a.y);
1563 goog.math.Coordinate.azimuth = function(a) {
1564 return goog.math.angle(0, 0, a.x, a.y);
1566 goog.math.Coordinate.squaredDistance = function(a, b) {
1567 var dx = a.x - b.x, dy = a.y - b.y;
1568 return dx * dx + dy * dy;
1570 goog.math.Coordinate.difference = function(a, b) {
1571 return new goog.math.Coordinate(a.x - b.x, a.y - b.y);
1573 goog.math.Coordinate.sum = function(a, b) {
1574 return new goog.math.Coordinate(a.x + b.x, a.y + b.y);
1576 goog.math.Coordinate.prototype.ceil = function() {
1577 this.x = Math.ceil(this.x);
1578 this.y = Math.ceil(this.y);
1581 goog.math.Coordinate.prototype.floor = function() {
1582 this.x = Math.floor(this.x);
1583 this.y = Math.floor(this.y);
1586 goog.math.Coordinate.prototype.round = function() {
1587 this.x = Math.round(this.x);
1588 this.y = Math.round(this.y);
1591 goog.math.Coordinate.prototype.translate = function(tx, opt_ty) {
1592 tx instanceof goog.math.Coordinate ? (this.x += tx.x, this.y += tx.y) : (this.x += tx, goog.isNumber(opt_ty) && (this.y += opt_ty));
1595 goog.math.Coordinate.prototype.scale = function(sx, opt_sy) {
1596 var sy = goog.isNumber(opt_sy) ? opt_sy : sx;
1601 goog.math.Size = function(width, height) {
1603 this.height = height;
1605 goog.math.Size.equals = function(a, b) {
1606 return a == b ? !0 : a && b ? a.width == b.width && a.height == b.height : !1;
1608 goog.math.Size.prototype.clone = function() {
1609 return new goog.math.Size(this.width, this.height);
1611 goog.DEBUG && (goog.math.Size.prototype.toString = function() {
1612 return "(" + this.width + " x " + this.height + ")";
1614 goog.math.Size.prototype.area = function() {
1615 return this.width * this.height;
1617 goog.math.Size.prototype.isEmpty = function() {
1620 goog.math.Size.prototype.ceil = function() {
1621 this.width = Math.ceil(this.width);
1622 this.height = Math.ceil(this.height);
1625 goog.math.Size.prototype.floor = function() {
1626 this.width = Math.floor(this.width);
1627 this.height = Math.floor(this.height);
1630 goog.math.Size.prototype.round = function() {
1631 this.width = Math.round(this.width);
1632 this.height = Math.round(this.height);
1635 goog.math.Size.prototype.scale = function(sx, opt_sy) {
1636 var sy = goog.isNumber(opt_sy) ? opt_sy : sx;
1642 goog.object.forEach = function(obj, f, opt_obj) {
1643 for (var key in obj) {
1644 f.call(opt_obj, obj[key], key, obj);
1647 goog.object.filter = function(obj, f, opt_obj) {
1650 f.call(opt_obj, obj[key], key, obj) && (res[key] = obj[key]);
1654 goog.object.map = function(obj, f, opt_obj) {
1657 res[key] = f.call(opt_obj, obj[key], key, obj);
1661 goog.object.some = function(obj, f, opt_obj) {
1662 for (var key in obj) {
1663 if (f.call(opt_obj, obj[key], key, obj)) {
1669 goog.object.every = function(obj, f, opt_obj) {
1670 for (var key in obj) {
1671 if (!f.call(opt_obj, obj[key], key, obj)) {
1677 goog.object.getCount = function(obj) {
1684 goog.object.getAnyKey = function(obj) {
1685 for (var key in obj) {
1689 goog.object.getAnyValue = function(obj) {
1690 for (var key in obj) {
1694 goog.object.contains = function(obj, val) {
1695 return goog.object.containsValue(obj, val);
1697 goog.object.getValues = function(obj) {
1698 var res = [], i = 0, key;
1700 res[i++] = obj[key];
1704 goog.object.getKeys = function(obj) {
1705 var res = [], i = 0, key;
1711 goog.object.getValueByKeys = function(obj, var_args) {
1712 for (var isArrayLike = goog.isArrayLike(var_args), keys = isArrayLike ? var_args : arguments, i = isArrayLike ? 0 : 1;i < keys.length && (obj = obj[keys[i]], goog.isDef(obj));i++) {
1716 goog.object.containsKey = function(obj, key) {
1719 goog.object.containsValue = function(obj, val) {
1720 for (var key in obj) {
1721 if (obj[key] == val) {
1727 goog.object.findKey = function(obj, f, opt_this) {
1728 for (var key in obj) {
1729 if (f.call(opt_this, obj[key], key, obj)) {
1734 goog.object.findValue = function(obj, f, opt_this) {
1735 var key = goog.object.findKey(obj, f, opt_this);
1736 return key && obj[key];
1738 goog.object.isEmpty = function(obj) {
1739 for (var key in obj) {
1744 goog.object.clear = function(obj) {
1745 for (var i in obj) {
1749 goog.object.remove = function(obj, key) {
1751 (rv = key in obj) && delete obj[key];
1754 goog.object.add = function(obj, key, val) {
1756 throw Error('The object already contains the key "' + key + '"');
1758 goog.object.set(obj, key, val);
1760 goog.object.get = function(obj, key, opt_val) {
1761 return key in obj ? obj[key] : opt_val;
1763 goog.object.set = function(obj, key, value) {
1766 goog.object.setIfUndefined = function(obj, key, value) {
1767 return key in obj ? obj[key] : obj[key] = value;
1769 goog.object.equals = function(a, b) {
1771 if (!(k in b) || a[k] !== b[k]) {
1782 goog.object.clone = function(obj) {
1785 res[key] = obj[key];
1789 goog.object.unsafeClone = function(obj) {
1790 var type = goog.typeOf(obj);
1791 if ("object" == type || "array" == type) {
1795 var clone = "array" == type ? [] : {}, key;
1797 clone[key] = goog.object.unsafeClone(obj[key]);
1803 goog.object.transpose = function(obj) {
1804 var transposed = {}, key;
1806 transposed[obj[key]] = key;
1810 goog.object.PROTOTYPE_FIELDS_ = "constructor hasOwnProperty isPrototypeOf propertyIsEnumerable toLocaleString toString valueOf".split(" ");
1811 goog.object.extend = function(target, var_args) {
1812 for (var key, source, i = 1;i < arguments.length;i++) {
1813 source = arguments[i];
1814 for (key in source) {
1815 target[key] = source[key];
1817 for (var j = 0;j < goog.object.PROTOTYPE_FIELDS_.length;j++) {
1818 key = goog.object.PROTOTYPE_FIELDS_[j], Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
1822 goog.object.create = function(var_args) {
1823 var argLength = arguments.length;
1824 if (1 == argLength && goog.isArray(arguments[0])) {
1825 return goog.object.create.apply(null, arguments[0]);
1827 if (argLength % 2) {
1828 throw Error("Uneven number of arguments");
1830 for (var rv = {}, i = 0;i < argLength;i += 2) {
1831 rv[arguments[i]] = arguments[i + 1];
1835 goog.object.createSet = function(var_args) {
1836 var argLength = arguments.length;
1837 if (1 == argLength && goog.isArray(arguments[0])) {
1838 return goog.object.createSet.apply(null, arguments[0]);
1840 for (var rv = {}, i = 0;i < argLength;i++) {
1841 rv[arguments[i]] = !0;
1845 goog.object.createImmutableView = function(obj) {
1847 Object.isFrozen && !Object.isFrozen(obj) && (result = Object.create(obj), Object.freeze(result));
1850 goog.object.isImmutableView = function(obj) {
1851 return!!Object.isFrozen && Object.isFrozen(obj);
1854 goog.labs.userAgent = {};
1855 goog.labs.userAgent.util = {};
1856 goog.labs.userAgent.util.getNativeUserAgentString_ = function() {
1857 var navigator = goog.labs.userAgent.util.getNavigator_();
1859 var userAgent = navigator.userAgent;
1866 goog.labs.userAgent.util.getNavigator_ = function() {
1867 return goog.global.navigator;
1869 goog.labs.userAgent.util.userAgent_ = goog.labs.userAgent.util.getNativeUserAgentString_();
1870 goog.labs.userAgent.util.setUserAgent = function(opt_userAgent) {
1871 goog.labs.userAgent.util.userAgent_ = opt_userAgent || goog.labs.userAgent.util.getNativeUserAgentString_();
1873 goog.labs.userAgent.util.getUserAgent = function() {
1874 return goog.labs.userAgent.util.userAgent_;
1876 goog.labs.userAgent.util.matchUserAgent = function(str) {
1877 var userAgent = goog.labs.userAgent.util.getUserAgent();
1878 return goog.string.contains(userAgent, str);
1880 goog.labs.userAgent.util.matchUserAgentIgnoreCase = function(str) {
1881 var userAgent = goog.labs.userAgent.util.getUserAgent();
1882 return goog.string.caseInsensitiveContains(userAgent, str);
1884 goog.labs.userAgent.util.extractVersionTuples = function(userAgent) {
1885 for (var versionRegExp = RegExp("(\\w[\\w ]+)/([^\\s]+)\\s*(?:\\((.*?)\\))?", "g"), data = [], match;match = versionRegExp.exec(userAgent);) {
1886 data.push([match[1], match[2], match[3] || void 0]);
1890 goog.labs.userAgent.browser = {};
1891 goog.labs.userAgent.browser.matchOpera_ = function() {
1892 return goog.labs.userAgent.util.matchUserAgent("Opera") || goog.labs.userAgent.util.matchUserAgent("OPR");
1894 goog.labs.userAgent.browser.matchIE_ = function() {
1895 return goog.labs.userAgent.util.matchUserAgent("Trident") || goog.labs.userAgent.util.matchUserAgent("MSIE");
1897 goog.labs.userAgent.browser.matchFirefox_ = function() {
1898 return goog.labs.userAgent.util.matchUserAgent("Firefox");
1900 goog.labs.userAgent.browser.matchSafari_ = function() {
1901 return goog.labs.userAgent.util.matchUserAgent("Safari") && !goog.labs.userAgent.util.matchUserAgent("Chrome") && !goog.labs.userAgent.util.matchUserAgent("CriOS") && !goog.labs.userAgent.util.matchUserAgent("Android");
1903 goog.labs.userAgent.browser.matchCoast_ = function() {
1904 return goog.labs.userAgent.util.matchUserAgent("Coast");
1906 goog.labs.userAgent.browser.matchIosWebview_ = function() {
1907 return(goog.labs.userAgent.util.matchUserAgent("iPad") || goog.labs.userAgent.util.matchUserAgent("iPhone")) && !goog.labs.userAgent.browser.matchSafari_() && !goog.labs.userAgent.browser.matchChrome_() && !goog.labs.userAgent.browser.matchCoast_() && goog.labs.userAgent.util.matchUserAgent("AppleWebKit");
1909 goog.labs.userAgent.browser.matchChrome_ = function() {
1910 return goog.labs.userAgent.util.matchUserAgent("Chrome") || goog.labs.userAgent.util.matchUserAgent("CriOS");
1912 goog.labs.userAgent.browser.matchAndroidBrowser_ = function() {
1913 return!goog.labs.userAgent.browser.isChrome() && goog.labs.userAgent.util.matchUserAgent("Android");
1915 goog.labs.userAgent.browser.isOpera = goog.labs.userAgent.browser.matchOpera_;
1916 goog.labs.userAgent.browser.isIE = goog.labs.userAgent.browser.matchIE_;
1917 goog.labs.userAgent.browser.isFirefox = goog.labs.userAgent.browser.matchFirefox_;
1918 goog.labs.userAgent.browser.isSafari = goog.labs.userAgent.browser.matchSafari_;
1919 goog.labs.userAgent.browser.isCoast = goog.labs.userAgent.browser.matchCoast_;
1920 goog.labs.userAgent.browser.isIosWebview = goog.labs.userAgent.browser.matchIosWebview_;
1921 goog.labs.userAgent.browser.isChrome = goog.labs.userAgent.browser.matchChrome_;
1922 goog.labs.userAgent.browser.isAndroidBrowser = goog.labs.userAgent.browser.matchAndroidBrowser_;
1923 goog.labs.userAgent.browser.isSilk = function() {
1924 return goog.labs.userAgent.util.matchUserAgent("Silk");
1926 goog.labs.userAgent.browser.getVersion = function() {
1927 function lookUpValueWithKeys(keys) {
1928 var key = goog.array.find(keys, versionMapHasKey);
1929 return versionMap[key] || "";
1931 var userAgentString = goog.labs.userAgent.util.getUserAgent();
1932 if (goog.labs.userAgent.browser.isIE()) {
1933 return goog.labs.userAgent.browser.getIEVersion_(userAgentString);
1935 var versionTuples = goog.labs.userAgent.util.extractVersionTuples(userAgentString), versionMap = {};
1936 goog.array.forEach(versionTuples, function(tuple) {
1937 var key = tuple[0], value = tuple[1];
1938 versionMap[key] = value;
1940 var versionMapHasKey = goog.partial(goog.object.containsKey, versionMap);
1941 if (goog.labs.userAgent.browser.isOpera()) {
1942 return lookUpValueWithKeys(["Version", "Opera", "OPR"]);
1944 if (goog.labs.userAgent.browser.isChrome()) {
1945 return lookUpValueWithKeys(["Chrome", "CriOS"]);
1947 var tuple = versionTuples[2];
1948 return tuple && tuple[1] || "";
1950 goog.labs.userAgent.browser.isVersionOrHigher = function(version) {
1951 return 0 <= goog.string.compareVersions(goog.labs.userAgent.browser.getVersion(), version);
1953 goog.labs.userAgent.browser.getIEVersion_ = function(userAgent) {
1954 var rv = /rv: *([\d\.]*)/.exec(userAgent);
1958 var version = "", msie = /MSIE +([\d\.]+)/.exec(userAgent);
1959 if (msie && msie[1]) {
1960 var tridentVersion = /Trident\/(\d.\d)/.exec(userAgent);
1961 if ("7.0" == msie[1]) {
1962 if (tridentVersion && tridentVersion[1]) {
1963 switch(tridentVersion[1]) {
1985 goog.labs.userAgent.engine = {};
1986 goog.labs.userAgent.engine.isPresto = function() {
1987 return goog.labs.userAgent.util.matchUserAgent("Presto");
1989 goog.labs.userAgent.engine.isTrident = function() {
1990 return goog.labs.userAgent.util.matchUserAgent("Trident") || goog.labs.userAgent.util.matchUserAgent("MSIE");
1992 goog.labs.userAgent.engine.isWebKit = function() {
1993 return goog.labs.userAgent.util.matchUserAgentIgnoreCase("WebKit");
1995 goog.labs.userAgent.engine.isGecko = function() {
1996 return goog.labs.userAgent.util.matchUserAgent("Gecko") && !goog.labs.userAgent.engine.isWebKit() && !goog.labs.userAgent.engine.isTrident();
1998 goog.labs.userAgent.engine.getVersion = function() {
1999 var userAgentString = goog.labs.userAgent.util.getUserAgent();
2000 if (userAgentString) {
2001 var tuples = goog.labs.userAgent.util.extractVersionTuples(userAgentString), engineTuple = tuples[1];
2003 return "Gecko" == engineTuple[0] ? goog.labs.userAgent.engine.getVersionForKey_(tuples, "Firefox") : engineTuple[1];
2005 var browserTuple = tuples[0], info;
2006 if (browserTuple && (info = browserTuple[2])) {
2007 var match = /Trident\/([^\s;]+)/.exec(info);
2015 goog.labs.userAgent.engine.isVersionOrHigher = function(version) {
2016 return 0 <= goog.string.compareVersions(goog.labs.userAgent.engine.getVersion(), version);
2018 goog.labs.userAgent.engine.getVersionForKey_ = function(tuples, key) {
2019 var pair = goog.array.find(tuples, function(pair) {
2020 return key == pair[0];
2022 return pair && pair[1] || "";
2024 goog.userAgent = {};
2025 goog.userAgent.ASSUME_IE = !1;
2026 goog.userAgent.ASSUME_GECKO = !1;
2027 goog.userAgent.ASSUME_WEBKIT = !1;
2028 goog.userAgent.ASSUME_MOBILE_WEBKIT = !1;
2029 goog.userAgent.ASSUME_OPERA = !1;
2030 goog.userAgent.ASSUME_ANY_VERSION = !1;
2031 goog.userAgent.BROWSER_KNOWN_ = goog.userAgent.ASSUME_IE || goog.userAgent.ASSUME_GECKO || goog.userAgent.ASSUME_MOBILE_WEBKIT || goog.userAgent.ASSUME_WEBKIT || goog.userAgent.ASSUME_OPERA;
2032 goog.userAgent.getUserAgentString = function() {
2033 return goog.labs.userAgent.util.getUserAgent();
2035 goog.userAgent.getNavigator = function() {
2036 return goog.global.navigator || null;
2038 goog.userAgent.OPERA = goog.userAgent.BROWSER_KNOWN_ ? goog.userAgent.ASSUME_OPERA : goog.labs.userAgent.browser.isOpera();
2039 goog.userAgent.IE = goog.userAgent.BROWSER_KNOWN_ ? goog.userAgent.ASSUME_IE : goog.labs.userAgent.browser.isIE();
2040 goog.userAgent.GECKO = goog.userAgent.BROWSER_KNOWN_ ? goog.userAgent.ASSUME_GECKO : goog.labs.userAgent.engine.isGecko();
2041 goog.userAgent.WEBKIT = goog.userAgent.BROWSER_KNOWN_ ? goog.userAgent.ASSUME_WEBKIT || goog.userAgent.ASSUME_MOBILE_WEBKIT : goog.labs.userAgent.engine.isWebKit();
2042 goog.userAgent.isMobile_ = function() {
2043 return goog.userAgent.WEBKIT && goog.labs.userAgent.util.matchUserAgent("Mobile");
2045 goog.userAgent.MOBILE = goog.userAgent.ASSUME_MOBILE_WEBKIT || goog.userAgent.isMobile_();
2046 goog.userAgent.SAFARI = goog.userAgent.WEBKIT;
2047 goog.userAgent.determinePlatform_ = function() {
2048 var navigator = goog.userAgent.getNavigator();
2049 return navigator && navigator.platform || "";
2051 goog.userAgent.PLATFORM = goog.userAgent.determinePlatform_();
2052 goog.userAgent.ASSUME_MAC = !1;
2053 goog.userAgent.ASSUME_WINDOWS = !1;
2054 goog.userAgent.ASSUME_LINUX = !1;
2055 goog.userAgent.ASSUME_X11 = !1;
2056 goog.userAgent.ASSUME_ANDROID = !1;
2057 goog.userAgent.ASSUME_IPHONE = !1;
2058 goog.userAgent.ASSUME_IPAD = !1;
2059 goog.userAgent.PLATFORM_KNOWN_ = goog.userAgent.ASSUME_MAC || goog.userAgent.ASSUME_WINDOWS || goog.userAgent.ASSUME_LINUX || goog.userAgent.ASSUME_X11 || goog.userAgent.ASSUME_ANDROID || goog.userAgent.ASSUME_IPHONE || goog.userAgent.ASSUME_IPAD;
2060 goog.userAgent.initPlatform_ = function() {
2061 goog.userAgent.detectedMac_ = goog.string.contains(goog.userAgent.PLATFORM, "Mac");
2062 goog.userAgent.detectedWindows_ = goog.string.contains(goog.userAgent.PLATFORM, "Win");
2063 goog.userAgent.detectedLinux_ = goog.string.contains(goog.userAgent.PLATFORM, "Linux");
2064 var ua = goog.userAgent.getUserAgentString();
2065 goog.userAgent.detectedAndroid_ = !!ua && goog.string.contains(ua, "Android");
2066 goog.userAgent.detectedIPhone_ = !!ua && goog.string.contains(ua, "iPhone");
2067 goog.userAgent.detectedIPad_ = !!ua && goog.string.contains(ua, "iPad");
2069 goog.userAgent.PLATFORM_KNOWN_ || goog.userAgent.initPlatform_();
2070 goog.userAgent.MAC = goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_MAC : goog.userAgent.detectedMac_;
2071 goog.userAgent.WINDOWS = goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_WINDOWS : goog.userAgent.detectedWindows_;
2072 goog.userAgent.LINUX = goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_LINUX : goog.userAgent.detectedLinux_;
2073 goog.userAgent.isX11_ = function() {
2074 var navigator = goog.userAgent.getNavigator();
2075 return!!navigator && goog.string.contains(navigator.appVersion || "", "X11");
2077 goog.userAgent.X11 = goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_X11 : goog.userAgent.isX11_();
2078 goog.userAgent.ANDROID = goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_ANDROID : goog.userAgent.detectedAndroid_;
2079 goog.userAgent.IPHONE = goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_IPHONE : goog.userAgent.detectedIPhone_;
2080 goog.userAgent.IPAD = goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_IPAD : goog.userAgent.detectedIPad_;
2081 goog.userAgent.determineVersion_ = function() {
2082 var version = "", re;
2083 if (goog.userAgent.OPERA && goog.global.opera) {
2084 var operaVersion = goog.global.opera.version;
2085 return goog.isFunction(operaVersion) ? operaVersion() : operaVersion;
2087 goog.userAgent.GECKO ? re = /rv\:([^\);]+)(\)|;)/ : goog.userAgent.IE ? re = /\b(?:MSIE|rv)[: ]([^\);]+)(\)|;)/ : goog.userAgent.WEBKIT && (re = /WebKit\/(\S+)/);
2089 var arr = re.exec(goog.userAgent.getUserAgentString()), version = arr ? arr[1] : ""
2091 if (goog.userAgent.IE) {
2092 var docMode = goog.userAgent.getDocumentMode_();
2093 if (docMode > parseFloat(version)) {
2094 return String(docMode);
2099 goog.userAgent.getDocumentMode_ = function() {
2100 var doc = goog.global.document;
2101 return doc ? doc.documentMode : void 0;
2103 goog.userAgent.VERSION = goog.userAgent.determineVersion_();
2104 goog.userAgent.compare = function(v1, v2) {
2105 return goog.string.compareVersions(v1, v2);
2107 goog.userAgent.isVersionOrHigherCache_ = {};
2108 goog.userAgent.isVersionOrHigher = function(version) {
2109 return goog.userAgent.ASSUME_ANY_VERSION || goog.userAgent.isVersionOrHigherCache_[version] || (goog.userAgent.isVersionOrHigherCache_[version] = 0 <= goog.string.compareVersions(goog.userAgent.VERSION, version));
2111 goog.userAgent.isVersion = goog.userAgent.isVersionOrHigher;
2112 goog.userAgent.isDocumentModeOrHigher = function(documentMode) {
2113 return goog.userAgent.IE && goog.userAgent.DOCUMENT_MODE >= documentMode;
2115 goog.userAgent.isDocumentMode = goog.userAgent.isDocumentModeOrHigher;
2116 var JSCompiler_inline_result$$0;
2117 var doc$$inline_1 = goog.global.document;
2118 if (doc$$inline_1 && goog.userAgent.IE) {
2119 var mode$$inline_2 = goog.userAgent.getDocumentMode_();
2120 JSCompiler_inline_result$$0 = mode$$inline_2 || ("CSS1Compat" == doc$$inline_1.compatMode ? parseInt(goog.userAgent.VERSION, 10) : 5);
2122 JSCompiler_inline_result$$0 = void 0;
2124 goog.userAgent.DOCUMENT_MODE = JSCompiler_inline_result$$0;
2125 goog.dom.BrowserFeature = {CAN_ADD_NAME_OR_TYPE_ATTRIBUTES:!goog.userAgent.IE || goog.userAgent.isDocumentModeOrHigher(9), CAN_USE_CHILDREN_ATTRIBUTE:!goog.userAgent.GECKO && !goog.userAgent.IE || goog.userAgent.IE && goog.userAgent.isDocumentModeOrHigher(9) || goog.userAgent.GECKO && goog.userAgent.isVersionOrHigher("1.9.1"), CAN_USE_INNER_TEXT:goog.userAgent.IE && !goog.userAgent.isVersionOrHigher("9"), CAN_USE_PARENT_ELEMENT_PROPERTY:goog.userAgent.IE || goog.userAgent.OPERA || goog.userAgent.WEBKIT,
2126 INNER_HTML_NEEDS_SCOPED_ELEMENT:goog.userAgent.IE, LEGACY_IE_RANGES:goog.userAgent.IE && !goog.userAgent.isDocumentModeOrHigher(9)};
2127 goog.dom.TagName = {A:"A", ABBR:"ABBR", ACRONYM:"ACRONYM", ADDRESS:"ADDRESS", APPLET:"APPLET", AREA:"AREA", ARTICLE:"ARTICLE", ASIDE:"ASIDE", AUDIO:"AUDIO", B:"B", BASE:"BASE", BASEFONT:"BASEFONT", BDI:"BDI", BDO:"BDO", BIG:"BIG", BLOCKQUOTE:"BLOCKQUOTE", BODY:"BODY", BR:"BR", BUTTON:"BUTTON", CANVAS:"CANVAS", CAPTION:"CAPTION", CENTER:"CENTER", CITE:"CITE", CODE:"CODE", COL:"COL", COLGROUP:"COLGROUP", COMMAND:"COMMAND", DATA:"DATA", DATALIST:"DATALIST", DD:"DD", DEL:"DEL", DETAILS:"DETAILS", DFN:"DFN",
2128 DIALOG:"DIALOG", DIR:"DIR", DIV:"DIV", DL:"DL", DT:"DT", EM:"EM", EMBED:"EMBED", FIELDSET:"FIELDSET", FIGCAPTION:"FIGCAPTION", FIGURE:"FIGURE", FONT:"FONT", FOOTER:"FOOTER", FORM:"FORM", FRAME:"FRAME", FRAMESET:"FRAMESET", H1:"H1", H2:"H2", H3:"H3", H4:"H4", H5:"H5", H6:"H6", HEAD:"HEAD", HEADER:"HEADER", HGROUP:"HGROUP", HR:"HR", HTML:"HTML", I:"I", IFRAME:"IFRAME", IMG:"IMG", INPUT:"INPUT", INS:"INS", ISINDEX:"ISINDEX", KBD:"KBD", KEYGEN:"KEYGEN", LABEL:"LABEL", LEGEND:"LEGEND", LI:"LI", LINK:"LINK",
2129 MAP:"MAP", MARK:"MARK", MATH:"MATH", MENU:"MENU", META:"META", METER:"METER", NAV:"NAV", NOFRAMES:"NOFRAMES", NOSCRIPT:"NOSCRIPT", OBJECT:"OBJECT", OL:"OL", OPTGROUP:"OPTGROUP", OPTION:"OPTION", OUTPUT:"OUTPUT", P:"P", PARAM:"PARAM", PRE:"PRE", PROGRESS:"PROGRESS", Q:"Q", RP:"RP", RT:"RT", RUBY:"RUBY", S:"S", SAMP:"SAMP", SCRIPT:"SCRIPT", SECTION:"SECTION", SELECT:"SELECT", SMALL:"SMALL", SOURCE:"SOURCE", SPAN:"SPAN", STRIKE:"STRIKE", STRONG:"STRONG", STYLE:"STYLE", SUB:"SUB", SUMMARY:"SUMMARY",
2130 SUP:"SUP", SVG:"SVG", TABLE:"TABLE", TBODY:"TBODY", TD:"TD", TEXTAREA:"TEXTAREA", TFOOT:"TFOOT", TH:"TH", THEAD:"THEAD", TIME:"TIME", TITLE:"TITLE", TR:"TR", TRACK:"TRACK", TT:"TT", U:"U", UL:"UL", VAR:"VAR", VIDEO:"VIDEO", WBR:"WBR"};
2131 goog.dom.ASSUME_QUIRKS_MODE = !1;
2132 goog.dom.ASSUME_STANDARDS_MODE = !1;
2133 goog.dom.COMPAT_MODE_KNOWN_ = goog.dom.ASSUME_QUIRKS_MODE || goog.dom.ASSUME_STANDARDS_MODE;
2134 goog.dom.getDomHelper = function(opt_element) {
2135 return opt_element ? new goog.dom.DomHelper(goog.dom.getOwnerDocument(opt_element)) : goog.dom.defaultDomHelper_ || (goog.dom.defaultDomHelper_ = new goog.dom.DomHelper);
2137 goog.dom.getDocument = function() {
2140 goog.dom.getElement = function(element) {
2141 return goog.dom.getElementHelper_(document, element);
2143 goog.dom.getElementHelper_ = function(doc, element) {
2144 return goog.isString(element) ? doc.getElementById(element) : element;
2146 goog.dom.getRequiredElement = function(id) {
2147 return goog.dom.getRequiredElementHelper_(document, id);
2149 goog.dom.getRequiredElementHelper_ = function(doc, id) {
2150 goog.asserts.assertString(id);
2151 var element = goog.dom.getElementHelper_(doc, id);
2152 return element = goog.asserts.assertElement(element, "No element found with id: " + id);
2154 goog.dom.$ = goog.dom.getElement;
2155 goog.dom.getElementsByTagNameAndClass = function(opt_tag, opt_class, opt_el) {
2156 return goog.dom.getElementsByTagNameAndClass_(document, opt_tag, opt_class, opt_el);
2158 goog.dom.getElementsByClass = function(className, opt_el) {
2159 var parent = opt_el || document;
2160 return goog.dom.canUseQuerySelector_(parent) ? parent.querySelectorAll("." + className) : goog.dom.getElementsByTagNameAndClass_(document, "*", className, opt_el);
2162 goog.dom.getElementByClass = function(className, opt_el) {
2163 var parent = opt_el || document, retVal = null;
2164 return(retVal = goog.dom.canUseQuerySelector_(parent) ? parent.querySelector("." + className) : goog.dom.getElementsByTagNameAndClass_(document, "*", className, opt_el)[0]) || null;
2166 goog.dom.getRequiredElementByClass = function(className, opt_root) {
2167 var retValue = goog.dom.getElementByClass(className, opt_root);
2168 return goog.asserts.assert(retValue, "No element found with className: " + className);
2170 goog.dom.canUseQuerySelector_ = function(parent) {
2171 return!(!parent.querySelectorAll || !parent.querySelector);
2173 goog.dom.getElementsByTagNameAndClass_ = function(doc, opt_tag, opt_class, opt_el) {
2174 var parent = opt_el || doc, tagName = opt_tag && "*" != opt_tag ? opt_tag.toUpperCase() : "";
2175 if (goog.dom.canUseQuerySelector_(parent) && (tagName || opt_class)) {
2176 var query = tagName + (opt_class ? "." + opt_class : "");
2177 return parent.querySelectorAll(query);
2179 if (opt_class && parent.getElementsByClassName) {
2180 var els = parent.getElementsByClassName(opt_class);
2182 for (var arrayLike = {}, len = 0, i = 0, el;el = els[i];i++) {
2183 tagName == el.nodeName && (arrayLike[len++] = el);
2185 arrayLike.length = len;
2190 els = parent.getElementsByTagName(tagName || "*");
2193 for (i = len = 0;el = els[i];i++) {
2194 var className = el.className;
2195 "function" == typeof className.split && goog.array.contains(className.split(/\s+/), opt_class) && (arrayLike[len++] = el);
2197 arrayLike.length = len;
2202 goog.dom.$$ = goog.dom.getElementsByTagNameAndClass;
2203 goog.dom.setProperties = function(element, properties) {
2204 goog.object.forEach(properties, function(val, key) {
2205 "style" == key ? element.style.cssText = val : "class" == key ? element.className = val : "for" == key ? element.htmlFor = val : key in goog.dom.DIRECT_ATTRIBUTE_MAP_ ? element.setAttribute(goog.dom.DIRECT_ATTRIBUTE_MAP_[key], val) : goog.string.startsWith(key, "aria-") || goog.string.startsWith(key, "data-") ? element.setAttribute(key, val) : element[key] = val;
2208 goog.dom.DIRECT_ATTRIBUTE_MAP_ = {cellpadding:"cellPadding", cellspacing:"cellSpacing", colspan:"colSpan", frameborder:"frameBorder", height:"height", maxlength:"maxLength", role:"role", rowspan:"rowSpan", type:"type", usemap:"useMap", valign:"vAlign", width:"width"};
2209 goog.dom.getViewportSize = function(opt_window) {
2210 return goog.dom.getViewportSize_(opt_window || window);
2212 goog.dom.getViewportSize_ = function(win) {
2213 var doc = win.document, el = goog.dom.isCss1CompatMode_(doc) ? doc.documentElement : doc.body;
2214 return new goog.math.Size(el.clientWidth, el.clientHeight);
2216 goog.dom.getDocumentHeight = function() {
2217 return goog.dom.getDocumentHeight_(window);
2219 goog.dom.getDocumentHeight_ = function(win) {
2220 var doc = win.document, height = 0;
2222 var body = doc.body, docEl = doc.documentElement;
2223 if (!docEl || !body) {
2226 var vh = goog.dom.getViewportSize_(win).height;
2227 if (goog.dom.isCss1CompatMode_(doc) && docEl.scrollHeight) {
2228 height = docEl.scrollHeight != vh ? docEl.scrollHeight : docEl.offsetHeight;
2230 var sh = docEl.scrollHeight, oh = docEl.offsetHeight;
2231 docEl.clientHeight != oh && (sh = body.scrollHeight, oh = body.offsetHeight);
2232 height = sh > vh ? sh > oh ? sh : oh : sh < oh ? sh : oh;
2237 goog.dom.getPageScroll = function(opt_window) {
2238 var win = opt_window || goog.global || window;
2239 return goog.dom.getDomHelper(win.document).getDocumentScroll();
2241 goog.dom.getDocumentScroll = function() {
2242 return goog.dom.getDocumentScroll_(document);
2244 goog.dom.getDocumentScroll_ = function(doc) {
2245 var el = goog.dom.getDocumentScrollElement_(doc), win = goog.dom.getWindow_(doc);
2246 return goog.userAgent.IE && goog.userAgent.isVersionOrHigher("10") && win.pageYOffset != el.scrollTop ? new goog.math.Coordinate(el.scrollLeft, el.scrollTop) : new goog.math.Coordinate(win.pageXOffset || el.scrollLeft, win.pageYOffset || el.scrollTop);
2248 goog.dom.getDocumentScrollElement = function() {
2249 return goog.dom.getDocumentScrollElement_(document);
2251 goog.dom.getDocumentScrollElement_ = function(doc) {
2252 return!goog.userAgent.WEBKIT && goog.dom.isCss1CompatMode_(doc) ? doc.documentElement : doc.body || doc.documentElement;
2254 goog.dom.getWindow = function(opt_doc) {
2255 return opt_doc ? goog.dom.getWindow_(opt_doc) : window;
2257 goog.dom.getWindow_ = function(doc) {
2258 return doc.parentWindow || doc.defaultView;
2260 goog.dom.createDom = function(tagName, opt_attributes, var_args) {
2261 return goog.dom.createDom_(document, arguments);
2263 goog.dom.createDom_ = function(doc, args) {
2264 var tagName = args[0], attributes = args[1];
2265 if (!goog.dom.BrowserFeature.CAN_ADD_NAME_OR_TYPE_ATTRIBUTES && attributes && (attributes.name || attributes.type)) {
2266 var tagNameArr = ["<", tagName];
2267 attributes.name && tagNameArr.push(' name="', goog.string.htmlEscape(attributes.name), '"');
2268 if (attributes.type) {
2269 tagNameArr.push(' type="', goog.string.htmlEscape(attributes.type), '"');
2271 goog.object.extend(clone, attributes);
2275 tagNameArr.push(">");
2276 tagName = tagNameArr.join("");
2278 var element = doc.createElement(tagName);
2279 attributes && (goog.isString(attributes) ? element.className = attributes : goog.isArray(attributes) ? element.className = attributes.join(" ") : goog.dom.setProperties(element, attributes));
2280 2 < args.length && goog.dom.append_(doc, element, args, 2);
2283 goog.dom.append_ = function(doc, parent, args, startIndex) {
2284 function childHandler(child) {
2285 child && parent.appendChild(goog.isString(child) ? doc.createTextNode(child) : child);
2287 for (var i = startIndex;i < args.length;i++) {
2289 goog.isArrayLike(arg) && !goog.dom.isNodeLike(arg) ? goog.array.forEach(goog.dom.isNodeList(arg) ? goog.array.toArray(arg) : arg, childHandler) : childHandler(arg);
2292 goog.dom.$dom = goog.dom.createDom;
2293 goog.dom.createElement = function(name) {
2294 return document.createElement(name);
2296 goog.dom.createTextNode = function(content) {
2297 return document.createTextNode(String(content));
2299 goog.dom.createTable = function(rows, columns, opt_fillWithNbsp) {
2300 return goog.dom.createTable_(document, rows, columns, !!opt_fillWithNbsp);
2302 goog.dom.createTable_ = function(doc, rows, columns, fillWithNbsp) {
2303 for (var rowHtml = ["<tr>"], i = 0;i < columns;i++) {
2304 rowHtml.push(fillWithNbsp ? "<td> </td>" : "<td></td>");
2306 rowHtml.push("</tr>");
2307 for (var rowHtml = rowHtml.join(""), totalHtml = ["<table>"], i = 0;i < rows;i++) {
2308 totalHtml.push(rowHtml);
2310 totalHtml.push("</table>");
2311 var elem = doc.createElement(goog.dom.TagName.DIV);
2312 elem.innerHTML = totalHtml.join("");
2313 return elem.removeChild(elem.firstChild);
2315 goog.dom.htmlToDocumentFragment = function(htmlString) {
2316 return goog.dom.htmlToDocumentFragment_(document, htmlString);
2318 goog.dom.htmlToDocumentFragment_ = function(doc, htmlString) {
2319 var tempDiv = doc.createElement("div");
2320 goog.dom.BrowserFeature.INNER_HTML_NEEDS_SCOPED_ELEMENT ? (tempDiv.innerHTML = "<br>" + htmlString, tempDiv.removeChild(tempDiv.firstChild)) : tempDiv.innerHTML = htmlString;
2321 if (1 == tempDiv.childNodes.length) {
2322 return tempDiv.removeChild(tempDiv.firstChild);
2324 for (var fragment = doc.createDocumentFragment();tempDiv.firstChild;) {
2325 fragment.appendChild(tempDiv.firstChild);
2329 goog.dom.isCss1CompatMode = function() {
2330 return goog.dom.isCss1CompatMode_(document);
2332 goog.dom.isCss1CompatMode_ = function(doc) {
2333 return goog.dom.COMPAT_MODE_KNOWN_ ? goog.dom.ASSUME_STANDARDS_MODE : "CSS1Compat" == doc.compatMode;
2335 goog.dom.canHaveChildren = function(node) {
2336 if (node.nodeType != goog.dom.NodeType.ELEMENT) {
2339 switch(node.tagName) {
2340 case goog.dom.TagName.APPLET:
2342 case goog.dom.TagName.AREA:
2344 case goog.dom.TagName.BASE:
2346 case goog.dom.TagName.BR:
2348 case goog.dom.TagName.COL:
2350 case goog.dom.TagName.COMMAND:
2352 case goog.dom.TagName.EMBED:
2354 case goog.dom.TagName.FRAME:
2356 case goog.dom.TagName.HR:
2358 case goog.dom.TagName.IMG:
2360 case goog.dom.TagName.INPUT:
2362 case goog.dom.TagName.IFRAME:
2364 case goog.dom.TagName.ISINDEX:
2366 case goog.dom.TagName.KEYGEN:
2368 case goog.dom.TagName.LINK:
2370 case goog.dom.TagName.NOFRAMES:
2372 case goog.dom.TagName.NOSCRIPT:
2374 case goog.dom.TagName.META:
2376 case goog.dom.TagName.OBJECT:
2378 case goog.dom.TagName.PARAM:
2380 case goog.dom.TagName.SCRIPT:
2382 case goog.dom.TagName.SOURCE:
2384 case goog.dom.TagName.STYLE:
2386 case goog.dom.TagName.TRACK:
2388 case goog.dom.TagName.WBR:
2393 goog.dom.appendChild = function(parent, child) {
2394 parent.appendChild(child);
2396 goog.dom.append = function(parent, var_args) {
2397 goog.dom.append_(goog.dom.getOwnerDocument(parent), parent, arguments, 1);
2399 goog.dom.removeChildren = function(node) {
2400 for (var child;child = node.firstChild;) {
2401 node.removeChild(child);
2404 goog.dom.insertSiblingBefore = function(newNode, refNode) {
2405 refNode.parentNode && refNode.parentNode.insertBefore(newNode, refNode);
2407 goog.dom.insertSiblingAfter = function(newNode, refNode) {
2408 refNode.parentNode && refNode.parentNode.insertBefore(newNode, refNode.nextSibling);
2410 goog.dom.insertChildAt = function(parent, child, index) {
2411 parent.insertBefore(child, parent.childNodes[index] || null);
2413 goog.dom.removeNode = function(node) {
2414 return node && node.parentNode ? node.parentNode.removeChild(node) : null;
2416 goog.dom.replaceNode = function(newNode, oldNode) {
2417 var parent = oldNode.parentNode;
2418 parent && parent.replaceChild(newNode, oldNode);
2420 goog.dom.flattenElement = function(element) {
2421 var child, parent = element.parentNode;
2422 if (parent && parent.nodeType != goog.dom.NodeType.DOCUMENT_FRAGMENT) {
2423 if (element.removeNode) {
2424 return element.removeNode(!1);
2426 for (;child = element.firstChild;) {
2427 parent.insertBefore(child, element);
2429 return goog.dom.removeNode(element);
2432 goog.dom.getChildren = function(element) {
2433 return goog.dom.BrowserFeature.CAN_USE_CHILDREN_ATTRIBUTE && void 0 != element.children ? element.children : goog.array.filter(element.childNodes, function(node) {
2434 return node.nodeType == goog.dom.NodeType.ELEMENT;
2437 goog.dom.getFirstElementChild = function(node) {
2438 return void 0 != node.firstElementChild ? node.firstElementChild : goog.dom.getNextElementNode_(node.firstChild, !0);
2440 goog.dom.getLastElementChild = function(node) {
2441 return void 0 != node.lastElementChild ? node.lastElementChild : goog.dom.getNextElementNode_(node.lastChild, !1);
2443 goog.dom.getNextElementSibling = function(node) {
2444 return void 0 != node.nextElementSibling ? node.nextElementSibling : goog.dom.getNextElementNode_(node.nextSibling, !0);
2446 goog.dom.getPreviousElementSibling = function(node) {
2447 return void 0 != node.previousElementSibling ? node.previousElementSibling : goog.dom.getNextElementNode_(node.previousSibling, !1);
2449 goog.dom.getNextElementNode_ = function(node, forward) {
2450 for (;node && node.nodeType != goog.dom.NodeType.ELEMENT;) {
2451 node = forward ? node.nextSibling : node.previousSibling;
2455 goog.dom.getNextNode = function(node) {
2459 if (node.firstChild) {
2460 return node.firstChild;
2462 for (;node && !node.nextSibling;) {
2463 node = node.parentNode;
2465 return node ? node.nextSibling : null;
2467 goog.dom.getPreviousNode = function(node) {
2471 if (!node.previousSibling) {
2472 return node.parentNode;
2474 for (node = node.previousSibling;node && node.lastChild;) {
2475 node = node.lastChild;
2479 goog.dom.isNodeLike = function(obj) {
2480 return goog.isObject(obj) && 0 < obj.nodeType;
2482 goog.dom.isElement = function(obj) {
2483 return goog.isObject(obj) && obj.nodeType == goog.dom.NodeType.ELEMENT;
2485 goog.dom.isWindow = function(obj) {
2486 return goog.isObject(obj) && obj.window == obj;
2488 goog.dom.getParentElement = function(element) {
2490 if (goog.dom.BrowserFeature.CAN_USE_PARENT_ELEMENT_PROPERTY) {
2491 var isIe9 = goog.userAgent.IE && goog.userAgent.isVersionOrHigher("9") && !goog.userAgent.isVersionOrHigher("10");
2492 if (!(isIe9 && goog.global.SVGElement && element instanceof goog.global.SVGElement) && (parent = element.parentElement)) {
2496 parent = element.parentNode;
2497 return goog.dom.isElement(parent) ? parent : null;
2499 goog.dom.contains = function(parent, descendant) {
2500 if (parent.contains && descendant.nodeType == goog.dom.NodeType.ELEMENT) {
2501 return parent == descendant || parent.contains(descendant);
2503 if ("undefined" != typeof parent.compareDocumentPosition) {
2504 return parent == descendant || Boolean(parent.compareDocumentPosition(descendant) & 16);
2506 for (;descendant && parent != descendant;) {
2507 descendant = descendant.parentNode;
2509 return descendant == parent;
2511 goog.dom.compareNodeOrder = function(node1, node2) {
2512 if (node1 == node2) {
2515 if (node1.compareDocumentPosition) {
2516 return node1.compareDocumentPosition(node2) & 2 ? 1 : -1;
2518 if (goog.userAgent.IE && !goog.userAgent.isDocumentModeOrHigher(9)) {
2519 if (node1.nodeType == goog.dom.NodeType.DOCUMENT) {
2522 if (node2.nodeType == goog.dom.NodeType.DOCUMENT) {
2526 if ("sourceIndex" in node1 || node1.parentNode && "sourceIndex" in node1.parentNode) {
2527 var isElement1 = node1.nodeType == goog.dom.NodeType.ELEMENT, isElement2 = node2.nodeType == goog.dom.NodeType.ELEMENT;
2528 if (isElement1 && isElement2) {
2529 return node1.sourceIndex - node2.sourceIndex;
2531 var parent1 = node1.parentNode, parent2 = node2.parentNode;
2532 return parent1 == parent2 ? goog.dom.compareSiblingOrder_(node1, node2) : !isElement1 && goog.dom.contains(parent1, node2) ? -1 * goog.dom.compareParentsDescendantNodeIe_(node1, node2) : !isElement2 && goog.dom.contains(parent2, node1) ? goog.dom.compareParentsDescendantNodeIe_(node2, node1) : (isElement1 ? node1.sourceIndex : parent1.sourceIndex) - (isElement2 ? node2.sourceIndex : parent2.sourceIndex);
2534 var doc = goog.dom.getOwnerDocument(node1), range1, range2;
2535 range1 = doc.createRange();
2536 range1.selectNode(node1);
2537 range1.collapse(!0);
2538 range2 = doc.createRange();
2539 range2.selectNode(node2);
2540 range2.collapse(!0);
2541 return range1.compareBoundaryPoints(goog.global.Range.START_TO_END, range2);
2543 goog.dom.compareParentsDescendantNodeIe_ = function(textNode, node) {
2544 var parent = textNode.parentNode;
2545 if (parent == node) {
2548 for (var sibling = node;sibling.parentNode != parent;) {
2549 sibling = sibling.parentNode;
2551 return goog.dom.compareSiblingOrder_(sibling, textNode);
2553 goog.dom.compareSiblingOrder_ = function(node1, node2) {
2554 for (var s = node2;s = s.previousSibling;) {
2561 goog.dom.findCommonAncestor = function(var_args) {
2562 var i, count = arguments.length;
2567 return arguments[0];
2569 var paths = [], minLength = Infinity;
2570 for (i = 0;i < count;i++) {
2571 for (var ancestors = [], node = arguments[i];node;) {
2572 ancestors.unshift(node), node = node.parentNode;
2574 paths.push(ancestors);
2575 minLength = Math.min(minLength, ancestors.length);
2578 for (i = 0;i < minLength;i++) {
2579 for (var first = paths[0][i], j = 1;j < count;j++) {
2580 if (first != paths[j][i]) {
2588 goog.dom.getOwnerDocument = function(node) {
2589 goog.asserts.assert(node, "Node cannot be null or undefined.");
2590 return node.nodeType == goog.dom.NodeType.DOCUMENT ? node : node.ownerDocument || node.document;
2592 goog.dom.getFrameContentDocument = function(frame) {
2593 var doc = frame.contentDocument || frame.contentWindow.document;
2596 goog.dom.getFrameContentWindow = function(frame) {
2597 return frame.contentWindow || goog.dom.getWindow(goog.dom.getFrameContentDocument(frame));
2599 goog.dom.setTextContent = function(node, text) {
2600 goog.asserts.assert(null != node, "goog.dom.setTextContent expects a non-null value for node");
2601 if ("textContent" in node) {
2602 node.textContent = text;
2604 if (node.nodeType == goog.dom.NodeType.TEXT) {
2607 if (node.firstChild && node.firstChild.nodeType == goog.dom.NodeType.TEXT) {
2608 for (;node.lastChild != node.firstChild;) {
2609 node.removeChild(node.lastChild);
2611 node.firstChild.data = text;
2613 goog.dom.removeChildren(node);
2614 var doc = goog.dom.getOwnerDocument(node);
2615 node.appendChild(doc.createTextNode(String(text)));
2620 goog.dom.getOuterHtml = function(element) {
2621 if ("outerHTML" in element) {
2622 return element.outerHTML;
2624 var doc = goog.dom.getOwnerDocument(element), div = doc.createElement("div");
2625 div.appendChild(element.cloneNode(!0));
2626 return div.innerHTML;
2628 goog.dom.findNode = function(root, p) {
2629 var rv = [], found = goog.dom.findNodes_(root, p, rv, !0);
2630 return found ? rv[0] : void 0;
2632 goog.dom.findNodes = function(root, p) {
2634 goog.dom.findNodes_(root, p, rv, !1);
2637 goog.dom.findNodes_ = function(root, p, rv, findOne) {
2639 for (var child = root.firstChild;child;) {
2640 if (p(child) && (rv.push(child), findOne) || goog.dom.findNodes_(child, p, rv, findOne)) {
2643 child = child.nextSibling;
2648 goog.dom.TAGS_TO_IGNORE_ = {SCRIPT:1, STYLE:1, HEAD:1, IFRAME:1, OBJECT:1};
2649 goog.dom.PREDEFINED_TAG_VALUES_ = {IMG:" ", BR:"\n"};
2650 goog.dom.isFocusableTabIndex = function(element) {
2651 return goog.dom.hasSpecifiedTabIndex_(element) && goog.dom.isTabIndexFocusable_(element);
2653 goog.dom.setFocusableTabIndex = function(element, enable) {
2654 enable ? element.tabIndex = 0 : (element.tabIndex = -1, element.removeAttribute("tabIndex"));
2656 goog.dom.isFocusable = function(element) {
2658 return(focusable = goog.dom.nativelySupportsFocus_(element) ? !element.disabled && (!goog.dom.hasSpecifiedTabIndex_(element) || goog.dom.isTabIndexFocusable_(element)) : goog.dom.isFocusableTabIndex(element)) && goog.userAgent.IE ? goog.dom.hasNonZeroBoundingRect_(element) : focusable;
2660 goog.dom.hasSpecifiedTabIndex_ = function(element) {
2661 var attrNode = element.getAttributeNode("tabindex");
2662 return goog.isDefAndNotNull(attrNode) && attrNode.specified;
2664 goog.dom.isTabIndexFocusable_ = function(element) {
2665 var index = element.tabIndex;
2666 return goog.isNumber(index) && 0 <= index && 32768 > index;
2668 goog.dom.nativelySupportsFocus_ = function(element) {
2669 return element.tagName == goog.dom.TagName.A || element.tagName == goog.dom.TagName.INPUT || element.tagName == goog.dom.TagName.TEXTAREA || element.tagName == goog.dom.TagName.SELECT || element.tagName == goog.dom.TagName.BUTTON;
2671 goog.dom.hasNonZeroBoundingRect_ = function(element) {
2672 var rect = goog.isFunction(element.getBoundingClientRect) ? element.getBoundingClientRect() : {height:element.offsetHeight, width:element.offsetWidth};
2673 return goog.isDefAndNotNull(rect) && 0 < rect.height && 0 < rect.width;
2675 goog.dom.getTextContent = function(node) {
2677 if (goog.dom.BrowserFeature.CAN_USE_INNER_TEXT && "innerText" in node) {
2678 textContent = goog.string.canonicalizeNewlines(node.innerText);
2681 goog.dom.getTextContent_(node, buf, !0);
2682 textContent = buf.join("");
2684 textContent = textContent.replace(/ \xAD /g, " ").replace(/\xAD/g, "");
2685 textContent = textContent.replace(/\u200B/g, "");
2686 goog.dom.BrowserFeature.CAN_USE_INNER_TEXT || (textContent = textContent.replace(/ +/g, " "));
2687 " " != textContent && (textContent = textContent.replace(/^\s*/, ""));
2690 goog.dom.getRawTextContent = function(node) {
2692 goog.dom.getTextContent_(node, buf, !1);
2693 return buf.join("");
2695 goog.dom.getTextContent_ = function(node, buf, normalizeWhitespace) {
2696 if (!(node.nodeName in goog.dom.TAGS_TO_IGNORE_)) {
2697 if (node.nodeType == goog.dom.NodeType.TEXT) {
2698 normalizeWhitespace ? buf.push(String(node.nodeValue).replace(/(\r\n|\r|\n)/g, "")) : buf.push(node.nodeValue);
2700 if (node.nodeName in goog.dom.PREDEFINED_TAG_VALUES_) {
2701 buf.push(goog.dom.PREDEFINED_TAG_VALUES_[node.nodeName]);
2703 for (var child = node.firstChild;child;) {
2704 goog.dom.getTextContent_(child, buf, normalizeWhitespace), child = child.nextSibling;
2710 goog.dom.getNodeTextLength = function(node) {
2711 return goog.dom.getTextContent(node).length;
2713 goog.dom.getNodeTextOffset = function(node, opt_offsetParent) {
2714 for (var root = opt_offsetParent || goog.dom.getOwnerDocument(node).body, buf = [];node && node != root;) {
2715 for (var cur = node;cur = cur.previousSibling;) {
2716 buf.unshift(goog.dom.getTextContent(cur));
2718 node = node.parentNode;
2720 return goog.string.trimLeft(buf.join("")).replace(/ +/g, " ").length;
2722 goog.dom.getNodeAtOffset = function(parent, offset, opt_result) {
2723 for (var stack = [parent], pos = 0, cur = null;0 < stack.length && pos < offset;) {
2724 if (cur = stack.pop(), !(cur.nodeName in goog.dom.TAGS_TO_IGNORE_)) {
2725 if (cur.nodeType == goog.dom.NodeType.TEXT) {
2726 var text = cur.nodeValue.replace(/(\r\n|\r|\n)/g, "").replace(/ +/g, " "), pos = pos + text.length
2728 if (cur.nodeName in goog.dom.PREDEFINED_TAG_VALUES_) {
2729 pos += goog.dom.PREDEFINED_TAG_VALUES_[cur.nodeName].length;
2731 for (var i = cur.childNodes.length - 1;0 <= i;i--) {
2732 stack.push(cur.childNodes[i]);
2738 goog.isObject(opt_result) && (opt_result.remainder = cur ? cur.nodeValue.length + offset - pos - 1 : 0, opt_result.node = cur);
2741 goog.dom.isNodeList = function(val) {
2742 if (val && "number" == typeof val.length) {
2743 if (goog.isObject(val)) {
2744 return "function" == typeof val.item || "string" == typeof val.item;
2746 if (goog.isFunction(val)) {
2747 return "function" == typeof val.item;
2752 goog.dom.getAncestorByTagNameAndClass = function(element, opt_tag, opt_class) {
2753 if (!opt_tag && !opt_class) {
2756 var tagName = opt_tag ? opt_tag.toUpperCase() : null;
2757 return goog.dom.getAncestor(element, function(node) {
2758 return(!tagName || node.nodeName == tagName) && (!opt_class || goog.isString(node.className) && goog.array.contains(node.className.split(/\s+/), opt_class));
2761 goog.dom.getAncestorByClass = function(element, className) {
2762 return goog.dom.getAncestorByTagNameAndClass(element, null, className);
2764 goog.dom.getAncestor = function(element, matcher, opt_includeNode, opt_maxSearchSteps) {
2765 opt_includeNode || (element = element.parentNode);
2766 for (var ignoreSearchSteps = null == opt_maxSearchSteps, steps = 0;element && (ignoreSearchSteps || steps <= opt_maxSearchSteps);) {
2767 if (matcher(element)) {
2770 element = element.parentNode;
2775 goog.dom.getActiveElement = function(doc) {
2777 return doc && doc.activeElement;
2782 goog.dom.getPixelRatio = function() {
2783 var win = goog.dom.getWindow(), isFirefoxMobile = goog.userAgent.GECKO && goog.userAgent.MOBILE;
2784 return goog.isDef(win.devicePixelRatio) && !isFirefoxMobile ? win.devicePixelRatio : win.matchMedia ? goog.dom.matchesPixelRatio_(.75) || goog.dom.matchesPixelRatio_(1.5) || goog.dom.matchesPixelRatio_(2) || goog.dom.matchesPixelRatio_(3) || 1 : 1;
2786 goog.dom.matchesPixelRatio_ = function(pixelRatio) {
2787 var win = goog.dom.getWindow(), query = "(-webkit-min-device-pixel-ratio: " + pixelRatio + "),(min--moz-device-pixel-ratio: " + pixelRatio + "),(min-resolution: " + pixelRatio + "dppx)";
2788 return win.matchMedia(query).matches ? pixelRatio : 0;
2790 goog.dom.DomHelper = function(opt_document) {
2791 this.document_ = opt_document || goog.global.document || document;
2793 goog.dom.DomHelper.prototype.getDomHelper = goog.dom.getDomHelper;
2794 goog.dom.DomHelper.prototype.getDocument = function() {
2795 return this.document_;
2797 goog.dom.DomHelper.prototype.getElement = function(element) {
2798 return goog.dom.getElementHelper_(this.document_, element);
2800 goog.dom.DomHelper.prototype.getRequiredElement = function(id) {
2801 return goog.dom.getRequiredElementHelper_(this.document_, id);
2803 goog.dom.DomHelper.prototype.$ = goog.dom.DomHelper.prototype.getElement;
2804 goog.dom.DomHelper.prototype.getElementsByTagNameAndClass = function(opt_tag, opt_class, opt_el) {
2805 return goog.dom.getElementsByTagNameAndClass_(this.document_, opt_tag, opt_class, opt_el);
2807 goog.dom.DomHelper.prototype.getElementsByClass = function(className, opt_el) {
2808 var doc = opt_el || this.document_;
2809 return goog.dom.getElementsByClass(className, doc);
2811 goog.dom.DomHelper.prototype.getElementByClass = function(className, opt_el) {
2812 var doc = opt_el || this.document_;
2813 return goog.dom.getElementByClass(className, doc);
2815 goog.dom.DomHelper.prototype.getRequiredElementByClass = function(className, opt_root) {
2816 var root = opt_root || this.document_;
2817 return goog.dom.getRequiredElementByClass(className, root);
2819 goog.dom.DomHelper.prototype.$$ = goog.dom.DomHelper.prototype.getElementsByTagNameAndClass;
2820 goog.dom.DomHelper.prototype.setProperties = goog.dom.setProperties;
2821 goog.dom.DomHelper.prototype.getViewportSize = function(opt_window) {
2822 return goog.dom.getViewportSize(opt_window || this.getWindow());
2824 goog.dom.DomHelper.prototype.getDocumentHeight = function() {
2825 return goog.dom.getDocumentHeight_(this.getWindow());
2827 goog.dom.DomHelper.prototype.createDom = function(tagName, opt_attributes, var_args) {
2828 return goog.dom.createDom_(this.document_, arguments);
2830 goog.dom.DomHelper.prototype.$dom = goog.dom.DomHelper.prototype.createDom;
2831 goog.dom.DomHelper.prototype.createElement = function(name) {
2832 return this.document_.createElement(name);
2834 goog.dom.DomHelper.prototype.createTextNode = function(content) {
2835 return this.document_.createTextNode(String(content));
2837 goog.dom.DomHelper.prototype.createTable = function(rows, columns, opt_fillWithNbsp) {
2838 return goog.dom.createTable_(this.document_, rows, columns, !!opt_fillWithNbsp);
2840 goog.dom.DomHelper.prototype.htmlToDocumentFragment = function(htmlString) {
2841 return goog.dom.htmlToDocumentFragment_(this.document_, htmlString);
2843 goog.dom.DomHelper.prototype.isCss1CompatMode = function() {
2844 return goog.dom.isCss1CompatMode_(this.document_);
2846 goog.dom.DomHelper.prototype.getWindow = function() {
2847 return goog.dom.getWindow_(this.document_);
2849 goog.dom.DomHelper.prototype.getDocumentScrollElement = function() {
2850 return goog.dom.getDocumentScrollElement_(this.document_);
2852 goog.dom.DomHelper.prototype.getDocumentScroll = function() {
2853 return goog.dom.getDocumentScroll_(this.document_);
2855 goog.dom.DomHelper.prototype.getActiveElement = function(opt_doc) {
2856 return goog.dom.getActiveElement(opt_doc || this.document_);
2858 goog.dom.DomHelper.prototype.appendChild = goog.dom.appendChild;
2859 goog.dom.DomHelper.prototype.append = goog.dom.append;
2860 goog.dom.DomHelper.prototype.canHaveChildren = goog.dom.canHaveChildren;
2861 goog.dom.DomHelper.prototype.removeChildren = goog.dom.removeChildren;
2862 goog.dom.DomHelper.prototype.insertSiblingBefore = goog.dom.insertSiblingBefore;
2863 goog.dom.DomHelper.prototype.insertSiblingAfter = goog.dom.insertSiblingAfter;
2864 goog.dom.DomHelper.prototype.insertChildAt = goog.dom.insertChildAt;
2865 goog.dom.DomHelper.prototype.removeNode = goog.dom.removeNode;
2866 goog.dom.DomHelper.prototype.replaceNode = goog.dom.replaceNode;
2867 goog.dom.DomHelper.prototype.flattenElement = goog.dom.flattenElement;
2868 goog.dom.DomHelper.prototype.getChildren = goog.dom.getChildren;
2869 goog.dom.DomHelper.prototype.getFirstElementChild = goog.dom.getFirstElementChild;
2870 goog.dom.DomHelper.prototype.getLastElementChild = goog.dom.getLastElementChild;
2871 goog.dom.DomHelper.prototype.getNextElementSibling = goog.dom.getNextElementSibling;
2872 goog.dom.DomHelper.prototype.getPreviousElementSibling = goog.dom.getPreviousElementSibling;
2873 goog.dom.DomHelper.prototype.getNextNode = goog.dom.getNextNode;
2874 goog.dom.DomHelper.prototype.getPreviousNode = goog.dom.getPreviousNode;
2875 goog.dom.DomHelper.prototype.isNodeLike = goog.dom.isNodeLike;
2876 goog.dom.DomHelper.prototype.isElement = goog.dom.isElement;
2877 goog.dom.DomHelper.prototype.isWindow = goog.dom.isWindow;
2878 goog.dom.DomHelper.prototype.getParentElement = goog.dom.getParentElement;
2879 goog.dom.DomHelper.prototype.contains = goog.dom.contains;
2880 goog.dom.DomHelper.prototype.compareNodeOrder = goog.dom.compareNodeOrder;
2881 goog.dom.DomHelper.prototype.findCommonAncestor = goog.dom.findCommonAncestor;
2882 goog.dom.DomHelper.prototype.getOwnerDocument = goog.dom.getOwnerDocument;
2883 goog.dom.DomHelper.prototype.getFrameContentDocument = goog.dom.getFrameContentDocument;
2884 goog.dom.DomHelper.prototype.getFrameContentWindow = goog.dom.getFrameContentWindow;
2885 goog.dom.DomHelper.prototype.setTextContent = goog.dom.setTextContent;
2886 goog.dom.DomHelper.prototype.getOuterHtml = goog.dom.getOuterHtml;
2887 goog.dom.DomHelper.prototype.findNode = goog.dom.findNode;
2888 goog.dom.DomHelper.prototype.findNodes = goog.dom.findNodes;
2889 goog.dom.DomHelper.prototype.isFocusableTabIndex = goog.dom.isFocusableTabIndex;
2890 goog.dom.DomHelper.prototype.setFocusableTabIndex = goog.dom.setFocusableTabIndex;
2891 goog.dom.DomHelper.prototype.isFocusable = goog.dom.isFocusable;
2892 goog.dom.DomHelper.prototype.getTextContent = goog.dom.getTextContent;
2893 goog.dom.DomHelper.prototype.getNodeTextLength = goog.dom.getNodeTextLength;
2894 goog.dom.DomHelper.prototype.getNodeTextOffset = goog.dom.getNodeTextOffset;
2895 goog.dom.DomHelper.prototype.getNodeAtOffset = goog.dom.getNodeAtOffset;
2896 goog.dom.DomHelper.prototype.isNodeList = goog.dom.isNodeList;
2897 goog.dom.DomHelper.prototype.getAncestorByTagNameAndClass = goog.dom.getAncestorByTagNameAndClass;
2898 goog.dom.DomHelper.prototype.getAncestorByClass = goog.dom.getAncestorByClass;
2899 goog.dom.DomHelper.prototype.getAncestor = goog.dom.getAncestor;
2900 goog.debug.entryPointRegistry = {};
2901 goog.debug.EntryPointMonitor = function() {
2903 goog.debug.entryPointRegistry.refList_ = [];
2904 goog.debug.entryPointRegistry.monitors_ = [];
2905 goog.debug.entryPointRegistry.monitorsMayExist_ = !1;
2906 goog.debug.entryPointRegistry.register = function(callback) {
2907 goog.debug.entryPointRegistry.refList_[goog.debug.entryPointRegistry.refList_.length] = callback;
2908 if (goog.debug.entryPointRegistry.monitorsMayExist_) {
2909 for (var monitors = goog.debug.entryPointRegistry.monitors_, i = 0;i < monitors.length;i++) {
2910 callback(goog.bind(monitors[i].wrap, monitors[i]));
2914 goog.debug.entryPointRegistry.monitorAll = function(monitor) {
2915 goog.debug.entryPointRegistry.monitorsMayExist_ = !0;
2916 for (var transformer = goog.bind(monitor.wrap, monitor), i = 0;i < goog.debug.entryPointRegistry.refList_.length;i++) {
2917 goog.debug.entryPointRegistry.refList_[i](transformer);
2919 goog.debug.entryPointRegistry.monitors_.push(monitor);
2921 goog.debug.entryPointRegistry.unmonitorAllIfPossible = function(monitor) {
2922 var monitors = goog.debug.entryPointRegistry.monitors_;
2923 goog.asserts.assert(monitor == monitors[monitors.length - 1], "Only the most recent monitor can be unwrapped.");
2924 for (var transformer = goog.bind(monitor.unwrap, monitor), i = 0;i < goog.debug.entryPointRegistry.refList_.length;i++) {
2925 goog.debug.entryPointRegistry.refList_[i](transformer);
2929 goog.disposable = {};
2930 goog.disposable.IDisposable = function() {
2932 goog.Disposable = function() {
2933 goog.Disposable.MONITORING_MODE != goog.Disposable.MonitoringMode.OFF && (goog.Disposable.instances_[goog.getUid(this)] = this);
2934 this.disposed_ = this.disposed_;
2935 this.onDisposeCallbacks_ = this.onDisposeCallbacks_;
2937 goog.Disposable.MonitoringMode = {OFF:0, PERMANENT:1, INTERACTIVE:2};
2938 goog.Disposable.MONITORING_MODE = 0;
2939 goog.Disposable.INCLUDE_STACK_ON_CREATION = !0;
2940 goog.Disposable.instances_ = {};
2941 goog.Disposable.getUndisposedObjects = function() {
2943 for (id in goog.Disposable.instances_) {
2944 goog.Disposable.instances_.hasOwnProperty(id) && ret.push(goog.Disposable.instances_[Number(id)]);
2948 goog.Disposable.clearUndisposedObjects = function() {
2949 goog.Disposable.instances_ = {};
2951 goog.Disposable.prototype.disposed_ = !1;
2952 goog.Disposable.prototype.isDisposed = function() {
2953 return this.disposed_;
2955 goog.Disposable.prototype.dispose = function() {
2956 if (!this.disposed_ && (this.disposed_ = !0, this.disposeInternal(), goog.Disposable.MONITORING_MODE != goog.Disposable.MonitoringMode.OFF)) {
2957 var uid = goog.getUid(this);
2958 if (goog.Disposable.MONITORING_MODE == goog.Disposable.MonitoringMode.PERMANENT && !goog.Disposable.instances_.hasOwnProperty(uid)) {
2959 throw Error(this + " did not call the goog.Disposable base constructor or was disposed of after a clearUndisposedObjects call");
2961 delete goog.Disposable.instances_[uid];
2964 goog.Disposable.prototype.disposeInternal = function() {
2965 if (this.onDisposeCallbacks_) {
2966 for (;this.onDisposeCallbacks_.length;) {
2967 this.onDisposeCallbacks_.shift()();
2971 goog.Disposable.isDisposed = function(obj) {
2972 return obj && "function" == typeof obj.isDisposed ? obj.isDisposed() : !1;
2974 goog.dispose = function(obj) {
2975 obj && "function" == typeof obj.dispose && obj.dispose();
2977 goog.disposeAll = function(var_args) {
2978 for (var i = 0, len = arguments.length;i < len;++i) {
2979 var disposable = arguments[i];
2980 goog.isArrayLike(disposable) ? goog.disposeAll.apply(null, disposable) : goog.dispose(disposable);
2984 goog.events.EventId = function(eventId) {
2987 goog.events.EventId.prototype.toString = function() {
2990 goog.events.Event = function(type, opt_target) {
2991 this.type = type instanceof goog.events.EventId ? String(type) : type;
2992 this.currentTarget = this.target = opt_target;
2993 this.defaultPrevented = this.propagationStopped_ = !1;
2994 this.returnValue_ = !0;
2996 goog.events.Event.prototype.disposeInternal = function() {
2998 goog.events.Event.prototype.dispose = function() {
3000 goog.events.Event.prototype.stopPropagation = function() {
3001 this.propagationStopped_ = !0;
3003 goog.events.Event.prototype.preventDefault = function() {
3004 this.defaultPrevented = !0;
3005 this.returnValue_ = !1;
3007 goog.events.Event.stopPropagation = function(e) {
3008 e.stopPropagation();
3010 goog.events.Event.preventDefault = function(e) {
3014 goog.reflect.object = function(type, object) {
3017 goog.reflect.sinkValue = function(x) {
3018 goog.reflect.sinkValue[" "](x);
3021 goog.reflect.sinkValue[" "] = goog.nullFunction;
3022 goog.reflect.canAccessProperty = function(obj, prop) {
3024 return goog.reflect.sinkValue(obj[prop]), !0;
3029 goog.events.BrowserFeature = {HAS_W3C_BUTTON:!goog.userAgent.IE || goog.userAgent.isDocumentModeOrHigher(9), HAS_W3C_EVENT_SUPPORT:!goog.userAgent.IE || goog.userAgent.isDocumentModeOrHigher(9), SET_KEY_CODE_TO_PREVENT_DEFAULT:goog.userAgent.IE && !goog.userAgent.isVersionOrHigher("9"), HAS_NAVIGATOR_ONLINE_PROPERTY:!goog.userAgent.WEBKIT || goog.userAgent.isVersionOrHigher("528"), HAS_HTML5_NETWORK_EVENT_SUPPORT:goog.userAgent.GECKO && goog.userAgent.isVersionOrHigher("1.9b") || goog.userAgent.IE &&
3030 goog.userAgent.isVersionOrHigher("8") || goog.userAgent.OPERA && goog.userAgent.isVersionOrHigher("9.5") || goog.userAgent.WEBKIT && goog.userAgent.isVersionOrHigher("528"), HTML5_NETWORK_EVENTS_FIRE_ON_BODY:goog.userAgent.GECKO && !goog.userAgent.isVersionOrHigher("8") || goog.userAgent.IE && !goog.userAgent.isVersionOrHigher("9"), TOUCH_ENABLED:"ontouchstart" in goog.global || !!(goog.global.document && document.documentElement && "ontouchstart" in document.documentElement) || !(!goog.global.navigator ||
3031 !goog.global.navigator.msMaxTouchPoints)};
3032 goog.events.getVendorPrefixedName_ = function(eventName) {
3033 return goog.userAgent.WEBKIT ? "webkit" + eventName : goog.userAgent.OPERA ? "o" + eventName.toLowerCase() : eventName.toLowerCase();
3035 goog.events.EventType = {CLICK:"click", RIGHTCLICK:"rightclick", DBLCLICK:"dblclick", MOUSEDOWN:"mousedown", MOUSEUP:"mouseup", MOUSEOVER:"mouseover", MOUSEOUT:"mouseout", MOUSEMOVE:"mousemove", MOUSEENTER:"mouseenter", MOUSELEAVE:"mouseleave", SELECTSTART:"selectstart", WHEEL:"wheel", KEYPRESS:"keypress", KEYDOWN:"keydown", KEYUP:"keyup", BLUR:"blur", FOCUS:"focus", DEACTIVATE:"deactivate", FOCUSIN:goog.userAgent.IE ? "focusin" : "DOMFocusIn", FOCUSOUT:goog.userAgent.IE ? "focusout" : "DOMFocusOut",
3036 CHANGE:"change", SELECT:"select", SUBMIT:"submit", INPUT:"input", PROPERTYCHANGE:"propertychange", DRAGSTART:"dragstart", DRAG:"drag", DRAGENTER:"dragenter", DRAGOVER:"dragover", DRAGLEAVE:"dragleave", DROP:"drop", DRAGEND:"dragend", TOUCHSTART:"touchstart", TOUCHMOVE:"touchmove", TOUCHEND:"touchend", TOUCHCANCEL:"touchcancel", BEFOREUNLOAD:"beforeunload", CONSOLEMESSAGE:"consolemessage", CONTEXTMENU:"contextmenu", DOMCONTENTLOADED:"DOMContentLoaded", ERROR:"error", HELP:"help", LOAD:"load", LOSECAPTURE:"losecapture",
3037 ORIENTATIONCHANGE:"orientationchange", READYSTATECHANGE:"readystatechange", RESIZE:"resize", SCROLL:"scroll", UNLOAD:"unload", HASHCHANGE:"hashchange", PAGEHIDE:"pagehide", PAGESHOW:"pageshow", POPSTATE:"popstate", COPY:"copy", PASTE:"paste", CUT:"cut", BEFORECOPY:"beforecopy", BEFORECUT:"beforecut", BEFOREPASTE:"beforepaste", ONLINE:"online", OFFLINE:"offline", MESSAGE:"message", CONNECT:"connect", ANIMATIONSTART:goog.events.getVendorPrefixedName_("AnimationStart"), ANIMATIONEND:goog.events.getVendorPrefixedName_("AnimationEnd"),
3038 ANIMATIONITERATION:goog.events.getVendorPrefixedName_("AnimationIteration"), TRANSITIONEND:goog.events.getVendorPrefixedName_("TransitionEnd"), POINTERDOWN:"pointerdown", POINTERUP:"pointerup", POINTERCANCEL:"pointercancel", POINTERMOVE:"pointermove", POINTEROVER:"pointerover", POINTEROUT:"pointerout", POINTERENTER:"pointerenter", POINTERLEAVE:"pointerleave", GOTPOINTERCAPTURE:"gotpointercapture", LOSTPOINTERCAPTURE:"lostpointercapture", MSGESTURECHANGE:"MSGestureChange", MSGESTUREEND:"MSGestureEnd",
3039 MSGESTUREHOLD:"MSGestureHold", MSGESTURESTART:"MSGestureStart", MSGESTURETAP:"MSGestureTap", MSGOTPOINTERCAPTURE:"MSGotPointerCapture", MSINERTIASTART:"MSInertiaStart", MSLOSTPOINTERCAPTURE:"MSLostPointerCapture", MSPOINTERCANCEL:"MSPointerCancel", MSPOINTERDOWN:"MSPointerDown", MSPOINTERENTER:"MSPointerEnter", MSPOINTERHOVER:"MSPointerHover", MSPOINTERLEAVE:"MSPointerLeave", MSPOINTERMOVE:"MSPointerMove", MSPOINTEROUT:"MSPointerOut", MSPOINTEROVER:"MSPointerOver", MSPOINTERUP:"MSPointerUp", TEXT:"text",
3040 TEXTINPUT:"textInput", COMPOSITIONSTART:"compositionstart", COMPOSITIONUPDATE:"compositionupdate", COMPOSITIONEND:"compositionend", EXIT:"exit", LOADABORT:"loadabort", LOADCOMMIT:"loadcommit", LOADREDIRECT:"loadredirect", LOADSTART:"loadstart", LOADSTOP:"loadstop", RESPONSIVE:"responsive", SIZECHANGED:"sizechanged", UNRESPONSIVE:"unresponsive", VISIBILITYCHANGE:"visibilitychange", STORAGE:"storage", DOMSUBTREEMODIFIED:"DOMSubtreeModified", DOMNODEINSERTED:"DOMNodeInserted", DOMNODEREMOVED:"DOMNodeRemoved",
3041 DOMNODEREMOVEDFROMDOCUMENT:"DOMNodeRemovedFromDocument", DOMNODEINSERTEDINTODOCUMENT:"DOMNodeInsertedIntoDocument", DOMATTRMODIFIED:"DOMAttrModified", DOMCHARACTERDATAMODIFIED:"DOMCharacterDataModified"};
3042 goog.events.BrowserEvent = function(opt_e, opt_currentTarget) {
3043 goog.events.Event.call(this, opt_e ? opt_e.type : "");
3044 this.relatedTarget = this.currentTarget = this.target = null;
3045 this.charCode = this.keyCode = this.button = this.screenY = this.screenX = this.clientY = this.clientX = this.offsetY = this.offsetX = 0;
3046 this.metaKey = this.shiftKey = this.altKey = this.ctrlKey = !1;
3047 this.event_ = this.state = null;
3048 opt_e && this.init(opt_e, opt_currentTarget);
3050 goog.inherits(goog.events.BrowserEvent, goog.events.Event);
3051 goog.events.BrowserEvent.MouseButton = {LEFT:0, MIDDLE:1, RIGHT:2};
3052 goog.events.BrowserEvent.IEButtonMap = [1, 4, 2];
3053 goog.events.BrowserEvent.prototype.init = function(e, opt_currentTarget) {
3054 var type = this.type = e.type;
3055 this.target = e.target || e.srcElement;
3056 this.currentTarget = opt_currentTarget;
3057 var relatedTarget = e.relatedTarget;
3058 relatedTarget ? goog.userAgent.GECKO && (goog.reflect.canAccessProperty(relatedTarget, "nodeName") || (relatedTarget = null)) : type == goog.events.EventType.MOUSEOVER ? relatedTarget = e.fromElement : type == goog.events.EventType.MOUSEOUT && (relatedTarget = e.toElement);
3059 this.relatedTarget = relatedTarget;
3060 this.offsetX = goog.userAgent.WEBKIT || void 0 !== e.offsetX ? e.offsetX : e.layerX;
3061 this.offsetY = goog.userAgent.WEBKIT || void 0 !== e.offsetY ? e.offsetY : e.layerY;
3062 this.clientX = void 0 !== e.clientX ? e.clientX : e.pageX;
3063 this.clientY = void 0 !== e.clientY ? e.clientY : e.pageY;
3064 this.screenX = e.screenX || 0;
3065 this.screenY = e.screenY || 0;
3066 this.button = e.button;
3067 this.keyCode = e.keyCode || 0;
3068 this.charCode = e.charCode || ("keypress" == type ? e.keyCode : 0);
3069 this.ctrlKey = e.ctrlKey;
3070 this.altKey = e.altKey;
3071 this.shiftKey = e.shiftKey;
3072 this.metaKey = e.metaKey;
3073 this.state = e.state;
3075 e.defaultPrevented && this.preventDefault();
3077 goog.events.BrowserEvent.prototype.stopPropagation = function() {
3078 goog.events.BrowserEvent.superClass_.stopPropagation.call(this);
3079 this.event_.stopPropagation ? this.event_.stopPropagation() : this.event_.cancelBubble = !0;
3081 goog.events.BrowserEvent.prototype.preventDefault = function() {
3082 goog.events.BrowserEvent.superClass_.preventDefault.call(this);
3083 var be = this.event_;
3084 if (be.preventDefault) {
3085 be.preventDefault();
3087 if (be.returnValue = !1, goog.events.BrowserFeature.SET_KEY_CODE_TO_PREVENT_DEFAULT) {
3089 if (be.ctrlKey || 112 <= be.keyCode && 123 >= be.keyCode) {
3097 goog.events.BrowserEvent.prototype.disposeInternal = function() {
3099 goog.events.Listenable = function() {
3101 goog.events.Listenable.IMPLEMENTED_BY_PROP = "closure_listenable_" + (1E6 * Math.random() | 0);
3102 goog.events.Listenable.addImplementation = function(cls) {
3103 cls.prototype[goog.events.Listenable.IMPLEMENTED_BY_PROP] = !0;
3105 goog.events.Listenable.isImplementedBy = function(obj) {
3106 return!(!obj || !obj[goog.events.Listenable.IMPLEMENTED_BY_PROP]);
3108 goog.events.ListenableKey = function() {
3110 goog.events.ListenableKey.counter_ = 0;
3111 goog.events.ListenableKey.reserveKey = function() {
3112 return++goog.events.ListenableKey.counter_;
3114 goog.events.Listener = function(listener, proxy, src, type, capture, opt_handler) {
3115 this.listener = listener;
3119 this.capture = !!capture;
3120 this.handler = opt_handler;
3121 this.key = goog.events.ListenableKey.reserveKey();
3122 this.removed = this.callOnce = !1;
3124 goog.events.Listener.ENABLE_MONITORING = !1;
3125 goog.events.Listener.prototype.markAsRemoved = function() {
3127 this.handler = this.src = this.proxy = this.listener = null;
3129 goog.events.ListenerMap = function(src) {
3131 this.listeners = {};
3132 this.typeCount_ = 0;
3134 goog.events.ListenerMap.prototype.getTypeCount = function() {
3135 return this.typeCount_;
3137 goog.events.ListenerMap.prototype.add = function(type, listener, callOnce, opt_useCapture, opt_listenerScope) {
3138 var typeStr = type.toString(), listenerArray = this.listeners[typeStr];
3139 listenerArray || (listenerArray = this.listeners[typeStr] = [], this.typeCount_++);
3140 var listenerObj, index = goog.events.ListenerMap.findListenerIndex_(listenerArray, listener, opt_useCapture, opt_listenerScope);
3141 -1 < index ? (listenerObj = listenerArray[index], callOnce || (listenerObj.callOnce = !1)) : (listenerObj = new goog.events.Listener(listener, null, this.src, typeStr, !!opt_useCapture, opt_listenerScope), listenerObj.callOnce = callOnce, listenerArray.push(listenerObj));
3144 goog.events.ListenerMap.prototype.remove = function(type, listener, opt_useCapture, opt_listenerScope) {
3145 var typeStr = type.toString();
3146 if (!(typeStr in this.listeners)) {
3149 var listenerArray = this.listeners[typeStr], index = goog.events.ListenerMap.findListenerIndex_(listenerArray, listener, opt_useCapture, opt_listenerScope);
3151 var listenerObj = listenerArray[index];
3152 listenerObj.markAsRemoved();
3153 goog.array.removeAt(listenerArray, index);
3154 0 == listenerArray.length && (delete this.listeners[typeStr], this.typeCount_--);
3159 goog.events.ListenerMap.prototype.removeByKey = function(listener) {
3160 var type = listener.type;
3161 if (!(type in this.listeners)) {
3164 var removed = goog.array.remove(this.listeners[type], listener);
3165 removed && (listener.markAsRemoved(), 0 == this.listeners[type].length && (delete this.listeners[type], this.typeCount_--));
3168 goog.events.ListenerMap.prototype.removeAll = function(opt_type) {
3169 var typeStr = opt_type && opt_type.toString(), count = 0, type;
3170 for (type in this.listeners) {
3171 if (!typeStr || type == typeStr) {
3172 for (var listenerArray = this.listeners[type], i = 0;i < listenerArray.length;i++) {
3173 ++count, listenerArray[i].markAsRemoved();
3175 delete this.listeners[type];
3181 goog.events.ListenerMap.prototype.getListeners = function(type, capture) {
3182 var listenerArray = this.listeners[type.toString()], rv = [];
3183 if (listenerArray) {
3184 for (var i = 0;i < listenerArray.length;++i) {
3185 var listenerObj = listenerArray[i];
3186 listenerObj.capture == capture && rv.push(listenerObj);
3191 goog.events.ListenerMap.prototype.getListener = function(type, listener, capture, opt_listenerScope) {
3192 var listenerArray = this.listeners[type.toString()], i = -1;
3193 listenerArray && (i = goog.events.ListenerMap.findListenerIndex_(listenerArray, listener, capture, opt_listenerScope));
3194 return-1 < i ? listenerArray[i] : null;
3196 goog.events.ListenerMap.prototype.hasListener = function(opt_type, opt_capture) {
3197 var hasType = goog.isDef(opt_type), typeStr = hasType ? opt_type.toString() : "", hasCapture = goog.isDef(opt_capture);
3198 return goog.object.some(this.listeners, function(listenerArray) {
3199 for (var i = 0;i < listenerArray.length;++i) {
3200 if (!(hasType && listenerArray[i].type != typeStr || hasCapture && listenerArray[i].capture != opt_capture)) {
3207 goog.events.ListenerMap.findListenerIndex_ = function(listenerArray, listener, opt_useCapture, opt_listenerScope) {
3208 for (var i = 0;i < listenerArray.length;++i) {
3209 var listenerObj = listenerArray[i];
3210 if (!listenerObj.removed && listenerObj.listener == listener && listenerObj.capture == !!opt_useCapture && listenerObj.handler == opt_listenerScope) {
3216 goog.events.LISTENER_MAP_PROP_ = "closure_lm_" + (1E6 * Math.random() | 0);
3217 goog.events.onString_ = "on";
3218 goog.events.onStringMap_ = {};
3219 goog.events.CaptureSimulationMode = {OFF_AND_FAIL:0, OFF_AND_SILENT:1, ON:2};
3220 goog.events.CAPTURE_SIMULATION_MODE = 2;
3221 goog.events.listenerCountEstimate_ = 0;
3222 goog.events.listen = function(src, type, listener, opt_capt, opt_handler) {
3223 if (goog.isArray(type)) {
3224 for (var i = 0;i < type.length;i++) {
3225 goog.events.listen(src, type[i], listener, opt_capt, opt_handler);
3229 listener = goog.events.wrapListener(listener);
3230 return goog.events.Listenable.isImplementedBy(src) ? src.listen(type, listener, opt_capt, opt_handler) : goog.events.listen_(src, type, listener, !1, opt_capt, opt_handler);
3232 goog.events.listen_ = function(src, type, listener, callOnce, opt_capt, opt_handler) {
3234 throw Error("Invalid event type");
3236 var capture = !!opt_capt;
3237 if (capture && !goog.events.BrowserFeature.HAS_W3C_EVENT_SUPPORT) {
3238 if (goog.events.CAPTURE_SIMULATION_MODE == goog.events.CaptureSimulationMode.OFF_AND_FAIL) {
3239 return goog.asserts.fail("Can not register capture listener in IE8-."), null;
3241 if (goog.events.CAPTURE_SIMULATION_MODE == goog.events.CaptureSimulationMode.OFF_AND_SILENT) {
3245 var listenerMap = goog.events.getListenerMap_(src);
3246 listenerMap || (src[goog.events.LISTENER_MAP_PROP_] = listenerMap = new goog.events.ListenerMap(src));
3247 var listenerObj = listenerMap.add(type, listener, callOnce, opt_capt, opt_handler);
3248 if (listenerObj.proxy) {
3251 var proxy = goog.events.getProxy();
3252 listenerObj.proxy = proxy;
3254 proxy.listener = listenerObj;
3255 src.addEventListener ? src.addEventListener(type.toString(), proxy, capture) : src.attachEvent(goog.events.getOnString_(type.toString()), proxy);
3256 goog.events.listenerCountEstimate_++;
3259 goog.events.getProxy = function() {
3260 var proxyCallbackFunction = goog.events.handleBrowserEvent_, f = goog.events.BrowserFeature.HAS_W3C_EVENT_SUPPORT ? function(eventObject) {
3261 return proxyCallbackFunction.call(f.src, f.listener, eventObject);
3262 } : function(eventObject) {
3263 var v = proxyCallbackFunction.call(f.src, f.listener, eventObject);
3270 goog.events.listenOnce = function(src, type, listener, opt_capt, opt_handler) {
3271 if (goog.isArray(type)) {
3272 for (var i = 0;i < type.length;i++) {
3273 goog.events.listenOnce(src, type[i], listener, opt_capt, opt_handler);
3277 listener = goog.events.wrapListener(listener);
3278 return goog.events.Listenable.isImplementedBy(src) ? src.listenOnce(type, listener, opt_capt, opt_handler) : goog.events.listen_(src, type, listener, !0, opt_capt, opt_handler);
3280 goog.events.listenWithWrapper = function(src, wrapper, listener, opt_capt, opt_handler) {
3281 wrapper.listen(src, listener, opt_capt, opt_handler);
3283 goog.events.unlisten = function(src, type, listener, opt_capt, opt_handler) {
3284 if (goog.isArray(type)) {
3285 for (var i = 0;i < type.length;i++) {
3286 goog.events.unlisten(src, type[i], listener, opt_capt, opt_handler);
3290 listener = goog.events.wrapListener(listener);
3291 if (goog.events.Listenable.isImplementedBy(src)) {
3292 return src.unlisten(type, listener, opt_capt, opt_handler);
3297 var capture = !!opt_capt, listenerMap = goog.events.getListenerMap_(src);
3299 var listenerObj = listenerMap.getListener(type, listener, capture, opt_handler);
3301 return goog.events.unlistenByKey(listenerObj);
3306 goog.events.unlistenByKey = function(key) {
3307 if (goog.isNumber(key)) {
3311 if (!listener || listener.removed) {
3314 var src = listener.src;
3315 if (goog.events.Listenable.isImplementedBy(src)) {
3316 return src.unlistenByKey(listener);
3318 var type = listener.type, proxy = listener.proxy;
3319 src.removeEventListener ? src.removeEventListener(type, proxy, listener.capture) : src.detachEvent && src.detachEvent(goog.events.getOnString_(type), proxy);
3320 goog.events.listenerCountEstimate_--;
3321 var listenerMap = goog.events.getListenerMap_(src);
3322 listenerMap ? (listenerMap.removeByKey(listener), 0 == listenerMap.getTypeCount() && (listenerMap.src = null, src[goog.events.LISTENER_MAP_PROP_] = null)) : listener.markAsRemoved();
3325 goog.events.unlistenWithWrapper = function(src, wrapper, listener, opt_capt, opt_handler) {
3326 wrapper.unlisten(src, listener, opt_capt, opt_handler);
3328 goog.events.removeAll = function(obj, opt_type) {
3332 if (goog.events.Listenable.isImplementedBy(obj)) {
3333 return obj.removeAllListeners(opt_type);
3335 var listenerMap = goog.events.getListenerMap_(obj);
3339 var count = 0, typeStr = opt_type && opt_type.toString(), type;
3340 for (type in listenerMap.listeners) {
3341 if (!typeStr || type == typeStr) {
3342 for (var listeners = listenerMap.listeners[type].concat(), i = 0;i < listeners.length;++i) {
3343 goog.events.unlistenByKey(listeners[i]) && ++count;
3349 goog.events.removeAllNativeListeners = function() {
3350 return goog.events.listenerCountEstimate_ = 0;
3352 goog.events.getListeners = function(obj, type, capture) {
3353 if (goog.events.Listenable.isImplementedBy(obj)) {
3354 return obj.getListeners(type, capture);
3359 var listenerMap = goog.events.getListenerMap_(obj);
3360 return listenerMap ? listenerMap.getListeners(type, capture) : [];
3362 goog.events.getListener = function(src, type, listener, opt_capt, opt_handler) {
3363 listener = goog.events.wrapListener(listener);
3364 var capture = !!opt_capt;
3365 if (goog.events.Listenable.isImplementedBy(src)) {
3366 return src.getListener(type, listener, capture, opt_handler);
3371 var listenerMap = goog.events.getListenerMap_(src);
3372 return listenerMap ? listenerMap.getListener(type, listener, capture, opt_handler) : null;
3374 goog.events.hasListener = function(obj, opt_type, opt_capture) {
3375 if (goog.events.Listenable.isImplementedBy(obj)) {
3376 return obj.hasListener(opt_type, opt_capture);
3378 var listenerMap = goog.events.getListenerMap_(obj);
3379 return!!listenerMap && listenerMap.hasListener(opt_type, opt_capture);
3381 goog.events.expose = function(e) {
3384 e[key] && e[key].id ? str.push(key + " = " + e[key] + " (" + e[key].id + ")") : str.push(key + " = " + e[key]);
3386 return str.join("\n");
3388 goog.events.getOnString_ = function(type) {
3389 return type in goog.events.onStringMap_ ? goog.events.onStringMap_[type] : goog.events.onStringMap_[type] = goog.events.onString_ + type;
3391 goog.events.fireListeners = function(obj, type, capture, eventObject) {
3392 return goog.events.Listenable.isImplementedBy(obj) ? obj.fireListeners(type, capture, eventObject) : goog.events.fireListeners_(obj, type, capture, eventObject);
3394 goog.events.fireListeners_ = function(obj, type, capture, eventObject) {
3395 var retval = 1, listenerMap = goog.events.getListenerMap_(obj);
3397 var listenerArray = listenerMap.listeners[type.toString()];
3398 if (listenerArray) {
3399 for (var listenerArray = listenerArray.concat(), i = 0;i < listenerArray.length;i++) {
3400 var listener = listenerArray[i];
3401 listener && listener.capture == capture && !listener.removed && (retval &= !1 !== goog.events.fireListener(listener, eventObject));
3405 return Boolean(retval);
3407 goog.events.fireListener = function(listener, eventObject) {
3408 var listenerFn = listener.listener, listenerHandler = listener.handler || listener.src;
3409 listener.callOnce && goog.events.unlistenByKey(listener);
3410 return listenerFn.call(listenerHandler, eventObject);
3412 goog.events.getTotalListenerCount = function() {
3413 return goog.events.listenerCountEstimate_;
3415 goog.events.dispatchEvent = function(src, e) {
3416 goog.asserts.assert(goog.events.Listenable.isImplementedBy(src), "Can not use goog.events.dispatchEvent with non-goog.events.Listenable instance.");
3417 return src.dispatchEvent(e);
3419 goog.events.protectBrowserEventEntryPoint = function(errorHandler) {
3420 goog.events.handleBrowserEvent_ = errorHandler.protectEntryPoint(goog.events.handleBrowserEvent_);
3422 goog.events.handleBrowserEvent_ = function(listener, opt_evt) {
3423 if (listener.removed) {
3426 if (!goog.events.BrowserFeature.HAS_W3C_EVENT_SUPPORT) {
3427 var ieEvent = opt_evt || goog.getObjectByName("window.event"), evt = new goog.events.BrowserEvent(ieEvent, this), retval = !0;
3428 if (goog.events.CAPTURE_SIMULATION_MODE == goog.events.CaptureSimulationMode.ON) {
3429 if (!goog.events.isMarkedIeEvent_(ieEvent)) {
3430 goog.events.markIeEvent_(ieEvent);
3431 for (var ancestors = [], parent = evt.currentTarget;parent;parent = parent.parentNode) {
3432 ancestors.push(parent);
3434 for (var type = listener.type, i = ancestors.length - 1;!evt.propagationStopped_ && 0 <= i;i--) {
3435 evt.currentTarget = ancestors[i], retval &= goog.events.fireListeners_(ancestors[i], type, !0, evt);
3437 for (i = 0;!evt.propagationStopped_ && i < ancestors.length;i++) {
3438 evt.currentTarget = ancestors[i], retval &= goog.events.fireListeners_(ancestors[i], type, !1, evt);
3442 retval = goog.events.fireListener(listener, evt);
3446 return goog.events.fireListener(listener, new goog.events.BrowserEvent(opt_evt, this));
3448 goog.events.markIeEvent_ = function(e) {
3449 var useReturnValue = !1;
3450 if (0 == e.keyCode) {
3455 useReturnValue = !0;
3458 if (useReturnValue || void 0 == e.returnValue) {
3462 goog.events.isMarkedIeEvent_ = function(e) {
3463 return 0 > e.keyCode || void 0 != e.returnValue;
3465 goog.events.uniqueIdCounter_ = 0;
3466 goog.events.getUniqueId = function(identifier) {
3467 return identifier + "_" + goog.events.uniqueIdCounter_++;
3469 goog.events.getListenerMap_ = function(src) {
3470 var listenerMap = src[goog.events.LISTENER_MAP_PROP_];
3471 return listenerMap instanceof goog.events.ListenerMap ? listenerMap : null;
3473 goog.events.LISTENER_WRAPPER_PROP_ = "__closure_events_fn_" + (1E9 * Math.random() >>> 0);
3474 goog.events.wrapListener = function(listener) {
3475 goog.asserts.assert(listener, "Listener can not be null.");
3476 if (goog.isFunction(listener)) {
3479 goog.asserts.assert(listener.handleEvent, "An object listener must have handleEvent method.");
3480 listener[goog.events.LISTENER_WRAPPER_PROP_] || (listener[goog.events.LISTENER_WRAPPER_PROP_] = function(e) {
3481 return listener.handleEvent(e);
3483 return listener[goog.events.LISTENER_WRAPPER_PROP_];
3485 goog.debug.entryPointRegistry.register(function(transformer) {
3486 goog.events.handleBrowserEvent_ = transformer(goog.events.handleBrowserEvent_);
3488 goog.events.EventTarget = function() {
3489 goog.Disposable.call(this);
3490 this.eventTargetListeners_ = new goog.events.ListenerMap(this);
3491 this.actualEventTarget_ = this;
3492 this.parentEventTarget_ = null;
3494 goog.inherits(goog.events.EventTarget, goog.Disposable);
3495 goog.events.Listenable.addImplementation(goog.events.EventTarget);
3496 goog.events.EventTarget.MAX_ANCESTORS_ = 1E3;
3497 goog.events.EventTarget.prototype.getParentEventTarget = function() {
3498 return this.parentEventTarget_;
3500 goog.events.EventTarget.prototype.addEventListener = function(type, handler, opt_capture, opt_handlerScope) {
3501 goog.events.listen(this, type, handler, opt_capture, opt_handlerScope);
3503 goog.events.EventTarget.prototype.removeEventListener = function(type, handler, opt_capture, opt_handlerScope) {
3504 goog.events.unlisten(this, type, handler, opt_capture, opt_handlerScope);
3506 goog.events.EventTarget.prototype.dispatchEvent = function(e) {
3507 this.assertInitialized_();
3508 var ancestorsTree, ancestor = this.getParentEventTarget();
3511 for (var ancestorCount = 1;ancestor;ancestor = ancestor.getParentEventTarget()) {
3512 ancestorsTree.push(ancestor), goog.asserts.assert(++ancestorCount < goog.events.EventTarget.MAX_ANCESTORS_, "infinite loop");
3515 return goog.events.EventTarget.dispatchEventInternal_(this.actualEventTarget_, e, ancestorsTree);
3517 goog.events.EventTarget.prototype.disposeInternal = function() {
3518 goog.events.EventTarget.superClass_.disposeInternal.call(this);
3519 this.removeAllListeners();
3520 this.parentEventTarget_ = null;
3522 goog.events.EventTarget.prototype.listen = function(type, listener, opt_useCapture, opt_listenerScope) {
3523 this.assertInitialized_();
3524 return this.eventTargetListeners_.add(String(type), listener, !1, opt_useCapture, opt_listenerScope);
3526 goog.events.EventTarget.prototype.listenOnce = function(type, listener, opt_useCapture, opt_listenerScope) {
3527 return this.eventTargetListeners_.add(String(type), listener, !0, opt_useCapture, opt_listenerScope);
3529 goog.events.EventTarget.prototype.unlisten = function(type, listener, opt_useCapture, opt_listenerScope) {
3530 return this.eventTargetListeners_.remove(String(type), listener, opt_useCapture, opt_listenerScope);
3532 goog.events.EventTarget.prototype.unlistenByKey = function(key) {
3533 return this.eventTargetListeners_.removeByKey(key);
3535 goog.events.EventTarget.prototype.removeAllListeners = function(opt_type) {
3536 return this.eventTargetListeners_ ? this.eventTargetListeners_.removeAll(opt_type) : 0;
3538 goog.events.EventTarget.prototype.fireListeners = function(type, capture, eventObject) {
3539 var listenerArray = this.eventTargetListeners_.listeners[String(type)];
3540 if (!listenerArray) {
3543 for (var listenerArray = listenerArray.concat(), rv = !0, i = 0;i < listenerArray.length;++i) {
3544 var listener = listenerArray[i];
3545 if (listener && !listener.removed && listener.capture == capture) {
3546 var listenerFn = listener.listener, listenerHandler = listener.handler || listener.src;
3547 listener.callOnce && this.unlistenByKey(listener);
3548 rv = !1 !== listenerFn.call(listenerHandler, eventObject) && rv;
3551 return rv && 0 != eventObject.returnValue_;
3553 goog.events.EventTarget.prototype.getListeners = function(type, capture) {
3554 return this.eventTargetListeners_.getListeners(String(type), capture);
3556 goog.events.EventTarget.prototype.getListener = function(type, listener, capture, opt_listenerScope) {
3557 return this.eventTargetListeners_.getListener(String(type), listener, capture, opt_listenerScope);
3559 goog.events.EventTarget.prototype.hasListener = function(opt_type, opt_capture) {
3560 var id = goog.isDef(opt_type) ? String(opt_type) : void 0;
3561 return this.eventTargetListeners_.hasListener(id, opt_capture);
3563 goog.events.EventTarget.prototype.assertInitialized_ = function() {
3564 goog.asserts.assert(this.eventTargetListeners_, "Event target is not initialized. Did you call the superclass (goog.events.EventTarget) constructor?");
3566 goog.events.EventTarget.dispatchEventInternal_ = function(target, e, opt_ancestorsTree) {
3567 var type = e.type || e;
3568 if (goog.isString(e)) {
3569 e = new goog.events.Event(e, target);
3571 if (e instanceof goog.events.Event) {
3572 e.target = e.target || target;
3575 e = new goog.events.Event(type, target);
3576 goog.object.extend(e, oldEvent);
3579 var rv = !0, currentTarget;
3580 if (opt_ancestorsTree) {
3581 for (var i = opt_ancestorsTree.length - 1;!e.propagationStopped_ && 0 <= i;i--) {
3582 currentTarget = e.currentTarget = opt_ancestorsTree[i], rv = currentTarget.fireListeners(type, !0, e) && rv;
3585 e.propagationStopped_ || (currentTarget = e.currentTarget = target, rv = currentTarget.fireListeners(type, !0, e) && rv, e.propagationStopped_ || (rv = currentTarget.fireListeners(type, !1, e) && rv));
3586 if (opt_ancestorsTree) {
3587 for (i = 0;!e.propagationStopped_ && i < opt_ancestorsTree.length;i++) {
3588 currentTarget = e.currentTarget = opt_ancestorsTree[i], rv = currentTarget.fireListeners(type, !1, e) && rv;
3594 goog.json.USE_NATIVE_JSON = !1;
3595 goog.json.isValid = function(s) {
3596 if (/^\s*$/.test(s)) {
3599 var backslashesRe = /\\["\\\/bfnrtu]/g, simpleValuesRe = /"[^"\\\n\r\u2028\u2029\x00-\x08\x0a-\x1f]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, openBracketsRe = /(?:^|:|,)(?:[\s\u2028\u2029]*\[)+/g, remainderRe = /^[\],:{}\s\u2028\u2029]*$/;
3600 return remainderRe.test(s.replace(backslashesRe, "@").replace(simpleValuesRe, "]").replace(openBracketsRe, ""));
3602 goog.json.parse = goog.json.USE_NATIVE_JSON ? goog.global.JSON.parse : function(s) {
3604 if (goog.json.isValid(o)) {
3606 return eval("(" + o + ")");
3610 throw Error("Invalid JSON string: " + o);
3612 goog.json.unsafeParse = goog.json.USE_NATIVE_JSON ? goog.global.JSON.parse : function(s) {
3613 return eval("(" + s + ")");
3615 goog.json.serialize = goog.json.USE_NATIVE_JSON ? goog.global.JSON.stringify : function(object, opt_replacer) {
3616 return(new goog.json.Serializer(opt_replacer)).serialize(object);
3618 goog.json.Serializer = function(opt_replacer) {
3619 this.replacer_ = opt_replacer;
3621 goog.json.Serializer.prototype.serialize = function(object) {
3623 this.serializeInternal(object, sb);
3626 goog.json.Serializer.prototype.serializeInternal = function(object, sb) {
3627 switch(typeof object) {
3629 this.serializeString_(object, sb);
3632 this.serializeNumber_(object, sb);
3641 if (null == object) {
3645 if (goog.isArray(object)) {
3646 this.serializeArray(object, sb);
3649 this.serializeObject_(object, sb);
3654 throw Error("Unknown type: " + typeof object);;
3657 goog.json.Serializer.charToJsonCharCache_ = {'"':'\\"', "\\":"\\\\", "/":"\\/", "\b":"\\b", "\f":"\\f", "\n":"\\n", "\r":"\\r", "\t":"\\t", "\x0B":"\\u000b"};
3658 goog.json.Serializer.charsToReplace_ = /\uffff/.test("\uffff") ? /[\\\"\x00-\x1f\x7f-\uffff]/g : /[\\\"\x00-\x1f\x7f-\xff]/g;
3659 goog.json.Serializer.prototype.serializeString_ = function(s, sb) {
3660 sb.push('"', s.replace(goog.json.Serializer.charsToReplace_, function(c) {
3661 if (c in goog.json.Serializer.charToJsonCharCache_) {
3662 return goog.json.Serializer.charToJsonCharCache_[c];
3664 var cc = c.charCodeAt(0), rv = "\\u";
3665 16 > cc ? rv += "000" : 256 > cc ? rv += "00" : 4096 > cc && (rv += "0");
3666 return goog.json.Serializer.charToJsonCharCache_[c] = rv + cc.toString(16);
3669 goog.json.Serializer.prototype.serializeNumber_ = function(n, sb) {
3670 sb.push(isFinite(n) && !isNaN(n) ? n : "null");
3672 goog.json.Serializer.prototype.serializeArray = function(arr, sb) {
3675 for (var sep = "", i = 0;i < l;i++) {
3678 this.serializeInternal(this.replacer_ ? this.replacer_.call(arr, String(i), value) : value, sb);
3683 goog.json.Serializer.prototype.serializeObject_ = function(obj, sb) {
3687 if (Object.prototype.hasOwnProperty.call(obj, key)) {
3688 var value = obj[key];
3689 "function" != typeof value && (sb.push(sep), this.serializeString_(key, sb), sb.push(":"), this.serializeInternal(this.replacer_ ? this.replacer_.call(obj, key, value) : value, sb), sep = ",");
3695 goog.structs.Collection = function() {
3697 goog.functions = {};
3698 goog.functions.constant = function(retValue) {
3703 goog.functions.FALSE = goog.functions.constant(!1);
3704 goog.functions.TRUE = goog.functions.constant(!0);
3705 goog.functions.NULL = goog.functions.constant(null);
3706 goog.functions.identity = function(opt_returnValue) {
3707 return opt_returnValue;
3709 goog.functions.error = function(message) {
3711 throw Error(message);
3714 goog.functions.fail = function(err) {
3719 goog.functions.lock = function(f, opt_numArgs) {
3720 opt_numArgs = opt_numArgs || 0;
3722 return f.apply(this, Array.prototype.slice.call(arguments, 0, opt_numArgs));
3725 goog.functions.nth = function(n) {
3727 return arguments[n];
3730 goog.functions.withReturnValue = function(f, retValue) {
3731 return goog.functions.sequence(f, goog.functions.constant(retValue));
3733 goog.functions.compose = function(fn, var_args) {
3734 var functions = arguments, length = functions.length;
3737 length && (result = functions[length - 1].apply(this, arguments));
3738 for (var i = length - 2;0 <= i;i--) {
3739 result = functions[i].call(this, result);
3744 goog.functions.sequence = function(var_args) {
3745 var functions = arguments, length = functions.length;
3747 for (var result, i = 0;i < length;i++) {
3748 result = functions[i].apply(this, arguments);
3753 goog.functions.and = function(var_args) {
3754 var functions = arguments, length = functions.length;
3756 for (var i = 0;i < length;i++) {
3757 if (!functions[i].apply(this, arguments)) {
3764 goog.functions.or = function(var_args) {
3765 var functions = arguments, length = functions.length;
3767 for (var i = 0;i < length;i++) {
3768 if (functions[i].apply(this, arguments)) {
3775 goog.functions.not = function(f) {
3777 return!f.apply(this, arguments);
3780 goog.functions.create = function(constructor, var_args) {
3781 var temp = function() {
3783 temp.prototype = constructor.prototype;
3785 constructor.apply(obj, Array.prototype.slice.call(arguments, 1));
3788 goog.functions.CACHE_RETURN_VALUE = !0;
3789 goog.functions.cacheReturnValue = function(fn) {
3790 var called = !1, value;
3792 if (!goog.functions.CACHE_RETURN_VALUE) {
3795 called || (value = fn(), called = !0);
3800 goog.iter.StopIteration = "StopIteration" in goog.global ? goog.global.StopIteration : Error("StopIteration");
3801 goog.iter.Iterator = function() {
3803 goog.iter.Iterator.prototype.next = function() {
3804 throw goog.iter.StopIteration;
3806 goog.iter.Iterator.prototype.__iterator__ = function() {
3809 goog.iter.toIterator = function(iterable) {
3810 if (iterable instanceof goog.iter.Iterator) {
3813 if ("function" == typeof iterable.__iterator__) {
3814 return iterable.__iterator__(!1);
3816 if (goog.isArrayLike(iterable)) {
3817 var i = 0, newIter = new goog.iter.Iterator;
3818 newIter.next = function() {
3820 if (i >= iterable.length) {
3821 throw goog.iter.StopIteration;
3823 if (i in iterable) {
3824 return iterable[i++];
3831 throw Error("Not implemented");
3833 goog.iter.forEach = function(iterable, f, opt_obj) {
3834 if (goog.isArrayLike(iterable)) {
3836 goog.array.forEach(iterable, f, opt_obj);
3838 if (ex !== goog.iter.StopIteration) {
3843 iterable = goog.iter.toIterator(iterable);
3846 f.call(opt_obj, iterable.next(), void 0, iterable);
3849 if (ex$$0 !== goog.iter.StopIteration) {
3855 goog.iter.filter = function(iterable, f, opt_obj) {
3856 var iterator = goog.iter.toIterator(iterable), newIter = new goog.iter.Iterator;
3857 newIter.next = function() {
3859 var val = iterator.next();
3860 if (f.call(opt_obj, val, void 0, iterator)) {
3867 goog.iter.filterFalse = function(iterable, f, opt_obj) {
3868 return goog.iter.filter(iterable, goog.functions.not(f), opt_obj);
3870 goog.iter.range = function(startOrStop, opt_stop, opt_step) {
3871 var start = 0, stop = startOrStop, step = opt_step || 1;
3872 1 < arguments.length && (start = startOrStop, stop = opt_stop);
3874 throw Error("Range step argument must not be zero");
3876 var newIter = new goog.iter.Iterator;
3877 newIter.next = function() {
3878 if (0 < step && start >= stop || 0 > step && start <= stop) {
3879 throw goog.iter.StopIteration;
3887 goog.iter.join = function(iterable, deliminator) {
3888 return goog.iter.toArray(iterable).join(deliminator);
3890 goog.iter.map = function(iterable, f, opt_obj) {
3891 var iterator = goog.iter.toIterator(iterable), newIter = new goog.iter.Iterator;
3892 newIter.next = function() {
3893 var val = iterator.next();
3894 return f.call(opt_obj, val, void 0, iterator);
3898 goog.iter.reduce = function(iterable, f, val$$0, opt_obj) {
3900 goog.iter.forEach(iterable, function(val) {
3901 rval = f.call(opt_obj, rval, val);
3905 goog.iter.some = function(iterable, f, opt_obj) {
3906 iterable = goog.iter.toIterator(iterable);
3909 if (f.call(opt_obj, iterable.next(), void 0, iterable)) {
3914 if (ex !== goog.iter.StopIteration) {
3920 goog.iter.every = function(iterable, f, opt_obj) {
3921 iterable = goog.iter.toIterator(iterable);
3924 if (!f.call(opt_obj, iterable.next(), void 0, iterable)) {
3929 if (ex !== goog.iter.StopIteration) {
3935 goog.iter.chain = function(var_args) {
3936 return goog.iter.chainFromIterable(arguments);
3938 goog.iter.chainFromIterable = function(iterable) {
3939 var iterator = goog.iter.toIterator(iterable), iter = new goog.iter.Iterator, current = null;
3940 iter.next = function() {
3942 if (null == current) {
3943 var it = iterator.next();
3944 current = goog.iter.toIterator(it);
3947 return current.next();
3949 if (ex !== goog.iter.StopIteration) {
3958 goog.iter.dropWhile = function(iterable, f, opt_obj) {
3959 var iterator = goog.iter.toIterator(iterable), newIter = new goog.iter.Iterator, dropping = !0;
3960 newIter.next = function() {
3962 var val = iterator.next();
3963 if (!dropping || !f.call(opt_obj, val, void 0, iterator)) {
3964 return dropping = !1, val;
3970 goog.iter.takeWhile = function(iterable, f, opt_obj) {
3971 var iterator = goog.iter.toIterator(iterable), iter = new goog.iter.Iterator;
3972 iter.next = function() {
3973 var val = iterator.next();
3974 if (f.call(opt_obj, val, void 0, iterator)) {
3977 throw goog.iter.StopIteration;
3981 goog.iter.toArray = function(iterable) {
3982 if (goog.isArrayLike(iterable)) {
3983 return goog.array.toArray(iterable);
3985 iterable = goog.iter.toIterator(iterable);
3987 goog.iter.forEach(iterable, function(val) {
3992 goog.iter.equals = function(iterable1, iterable2, opt_equalsFn) {
3993 var fillValue = {}, pairs = goog.iter.zipLongest(fillValue, iterable1, iterable2), equalsFn = opt_equalsFn || goog.array.defaultCompareEquality;
3994 return goog.iter.every(pairs, function(pair) {
3995 return equalsFn(pair[0], pair[1]);
3998 goog.iter.nextOrValue = function(iterable, defaultValue) {
4000 return goog.iter.toIterator(iterable).next();
4002 if (e != goog.iter.StopIteration) {
4005 return defaultValue;
4008 goog.iter.product = function(var_args) {
4009 var someArrayEmpty = goog.array.some(arguments, function(arr) {
4012 if (someArrayEmpty || !arguments.length) {
4013 return new goog.iter.Iterator;
4015 var iter = new goog.iter.Iterator, arrays = arguments, indicies = goog.array.repeat(0, arrays.length);
4016 iter.next = function() {
4018 for (var retVal = goog.array.map(indicies, function(valueIndex, arrayIndex) {
4019 return arrays[arrayIndex][valueIndex];
4020 }), i = indicies.length - 1;0 <= i;i--) {
4021 goog.asserts.assert(indicies);
4022 if (indicies[i] < arrays[i].length - 1) {
4034 throw goog.iter.StopIteration;
4038 goog.iter.cycle = function(iterable) {
4039 var baseIterator = goog.iter.toIterator(iterable), cache = [], cacheIndex = 0, iter = new goog.iter.Iterator, useCache = !1;
4040 iter.next = function() {
4041 var returnElement = null;
4044 return returnElement = baseIterator.next(), cache.push(returnElement), returnElement;
4046 if (e != goog.iter.StopIteration || goog.array.isEmpty(cache)) {
4052 returnElement = cache[cacheIndex];
4053 cacheIndex = (cacheIndex + 1) % cache.length;
4054 return returnElement;
4058 goog.iter.count = function(opt_start, opt_step) {
4059 var counter = opt_start || 0, step = goog.isDef(opt_step) ? opt_step : 1, iter = new goog.iter.Iterator;
4060 iter.next = function() {
4061 var returnValue = counter;
4067 goog.iter.repeat = function(value) {
4068 var iter = new goog.iter.Iterator;
4069 iter.next = goog.functions.constant(value);
4072 goog.iter.accumulate = function(iterable) {
4073 var iterator = goog.iter.toIterator(iterable), total = 0, iter = new goog.iter.Iterator;
4074 iter.next = function() {
4075 return total += iterator.next();
4079 goog.iter.zip = function(var_args) {
4080 var args = arguments, iter = new goog.iter.Iterator;
4081 if (0 < args.length) {
4082 var iterators = goog.array.map(args, goog.iter.toIterator);
4083 iter.next = function() {
4084 var arr = goog.array.map(iterators, function(it) {
4092 goog.iter.zipLongest = function(fillValue, var_args) {
4093 var args = goog.array.slice(arguments, 1), iter = new goog.iter.Iterator;
4094 if (0 < args.length) {
4095 var iterators = goog.array.map(args, goog.iter.toIterator);
4096 iter.next = function() {
4097 var iteratorsHaveValues = !1, arr = goog.array.map(iterators, function(it) {
4100 returnValue = it.next(), iteratorsHaveValues = !0;
4102 if (ex !== goog.iter.StopIteration) {
4105 returnValue = fillValue;
4109 if (!iteratorsHaveValues) {
4110 throw goog.iter.StopIteration;
4117 goog.iter.compress = function(iterable, selectors) {
4118 var selectorIterator = goog.iter.toIterator(selectors);
4119 return goog.iter.filter(iterable, function() {
4120 return!!selectorIterator.next();
4123 goog.iter.GroupByIterator_ = function(iterable, opt_keyFunc) {
4124 this.iterator = goog.iter.toIterator(iterable);
4125 this.keyFunc = opt_keyFunc || goog.functions.identity;
4127 goog.inherits(goog.iter.GroupByIterator_, goog.iter.Iterator);
4128 goog.iter.GroupByIterator_.prototype.next = function() {
4129 for (;this.currentKey == this.targetKey;) {
4130 this.currentValue = this.iterator.next(), this.currentKey = this.keyFunc(this.currentValue);
4132 this.targetKey = this.currentKey;
4133 return[this.currentKey, this.groupItems_(this.targetKey)];
4135 goog.iter.GroupByIterator_.prototype.groupItems_ = function(targetKey) {
4136 for (var arr = [];this.currentKey == targetKey;) {
4137 arr.push(this.currentValue);
4139 this.currentValue = this.iterator.next();
4141 if (ex !== goog.iter.StopIteration) {
4146 this.currentKey = this.keyFunc(this.currentValue);
4150 goog.iter.groupBy = function(iterable, opt_keyFunc) {
4151 return new goog.iter.GroupByIterator_(iterable, opt_keyFunc);
4153 goog.iter.starMap = function(iterable, f, opt_obj) {
4154 var iterator = goog.iter.toIterator(iterable), iter = new goog.iter.Iterator;
4155 iter.next = function() {
4156 var args = goog.iter.toArray(iterator.next());
4157 return f.apply(opt_obj, goog.array.concat(args, void 0, iterator));
4161 goog.iter.tee = function(iterable, opt_num) {
4162 var iterator = goog.iter.toIterator(iterable), num = goog.isNumber(opt_num) ? opt_num : 2, buffers = goog.array.map(goog.array.range(num), function() {
4164 }), addNextIteratorValueToBuffers = function() {
4165 var val = iterator.next();
4166 goog.array.forEach(buffers, function(buffer) {
4169 }, createIterator = function(buffer) {
4170 var iter = new goog.iter.Iterator;
4171 iter.next = function() {
4172 goog.array.isEmpty(buffer) && addNextIteratorValueToBuffers();
4173 goog.asserts.assert(!goog.array.isEmpty(buffer));
4174 return buffer.shift();
4178 return goog.array.map(buffers, createIterator);
4180 goog.iter.enumerate = function(iterable, opt_start) {
4181 return goog.iter.zip(goog.iter.count(opt_start), iterable);
4183 goog.iter.limit = function(iterable, limitSize) {
4184 goog.asserts.assert(goog.math.isInt(limitSize) && 0 <= limitSize);
4185 var iterator = goog.iter.toIterator(iterable), iter = new goog.iter.Iterator, remaining = limitSize;
4186 iter.next = function() {
4187 if (0 < remaining--) {
4188 return iterator.next();
4190 throw goog.iter.StopIteration;
4194 goog.iter.consume = function(iterable, count) {
4195 goog.asserts.assert(goog.math.isInt(count) && 0 <= count);
4196 for (var iterator = goog.iter.toIterator(iterable);0 < count--;) {
4197 goog.iter.nextOrValue(iterator, null);
4201 goog.iter.slice = function(iterable, start, opt_end) {
4202 goog.asserts.assert(goog.math.isInt(start) && 0 <= start);
4203 var iterator = goog.iter.consume(iterable, start);
4204 goog.isNumber(opt_end) && (goog.asserts.assert(goog.math.isInt(opt_end) && opt_end >= start), iterator = goog.iter.limit(iterator, opt_end - start));
4207 goog.iter.hasDuplicates_ = function(arr) {
4209 goog.array.removeDuplicates(arr, deduped);
4210 return arr.length != deduped.length;
4212 goog.iter.permutations = function(iterable, opt_length) {
4213 var elements = goog.iter.toArray(iterable), length = goog.isNumber(opt_length) ? opt_length : elements.length, sets = goog.array.repeat(elements, length), product = goog.iter.product.apply(void 0, sets);
4214 return goog.iter.filter(product, function(arr) {
4215 return!goog.iter.hasDuplicates_(arr);
4218 goog.iter.combinations = function(iterable, length) {
4219 function getIndexFromElements(index) {
4220 return elements[index];
4222 var elements = goog.iter.toArray(iterable), indexes = goog.iter.range(elements.length), indexIterator = goog.iter.permutations(indexes, length), sortedIndexIterator = goog.iter.filter(indexIterator, function(arr) {
4223 return goog.array.isSorted(arr);
4224 }), iter = new goog.iter.Iterator;
4225 iter.next = function() {
4226 return goog.array.map(sortedIndexIterator.next(), getIndexFromElements);
4230 goog.iter.combinationsWithReplacement = function(iterable, length) {
4231 function getIndexFromElements(index) {
4232 return elements[index];
4234 var elements = goog.iter.toArray(iterable), indexes = goog.array.range(elements.length), sets = goog.array.repeat(indexes, length), indexIterator = goog.iter.product.apply(void 0, sets), sortedIndexIterator = goog.iter.filter(indexIterator, function(arr) {
4235 return goog.array.isSorted(arr);
4236 }), iter = new goog.iter.Iterator;
4237 iter.next = function() {
4238 return goog.array.map(sortedIndexIterator.next(), getIndexFromElements);
4242 goog.structs.Map = function(opt_map, var_args) {
4245 this.version_ = this.count_ = 0;
4246 var argLength = arguments.length;
4247 if (1 < argLength) {
4248 if (argLength % 2) {
4249 throw Error("Uneven number of arguments");
4251 for (var i = 0;i < argLength;i += 2) {
4252 this.set(arguments[i], arguments[i + 1]);
4255 opt_map && this.addAll(opt_map);
4258 goog.structs.Map.prototype.getCount = function() {
4261 goog.structs.Map.prototype.getValues = function() {
4262 this.cleanupKeysArray_();
4263 for (var rv = [], i = 0;i < this.keys_.length;i++) {
4264 var key = this.keys_[i];
4265 rv.push(this.map_[key]);
4269 goog.structs.Map.prototype.getKeys = function() {
4270 this.cleanupKeysArray_();
4271 return this.keys_.concat();
4273 goog.structs.Map.prototype.containsKey = function(key) {
4274 return goog.structs.Map.hasKey_(this.map_, key);
4276 goog.structs.Map.prototype.containsValue = function(val) {
4277 for (var i = 0;i < this.keys_.length;i++) {
4278 var key = this.keys_[i];
4279 if (goog.structs.Map.hasKey_(this.map_, key) && this.map_[key] == val) {
4285 goog.structs.Map.prototype.equals = function(otherMap, opt_equalityFn) {
4286 if (this === otherMap) {
4289 if (this.count_ != otherMap.getCount()) {
4292 var equalityFn = opt_equalityFn || goog.structs.Map.defaultEquals;
4293 this.cleanupKeysArray_();
4294 for (var key, i = 0;key = this.keys_[i];i++) {
4295 if (!equalityFn(this.get(key), otherMap.get(key))) {
4301 goog.structs.Map.defaultEquals = function(a, b) {
4304 goog.structs.Map.prototype.isEmpty = function() {
4305 return 0 == this.count_;
4307 goog.structs.Map.prototype.clear = function() {
4309 this.version_ = this.count_ = this.keys_.length = 0;
4311 goog.structs.Map.prototype.remove = function(key) {
4312 return goog.structs.Map.hasKey_(this.map_, key) ? (delete this.map_[key], this.count_--, this.version_++, this.keys_.length > 2 * this.count_ && this.cleanupKeysArray_(), !0) : !1;
4314 goog.structs.Map.prototype.cleanupKeysArray_ = function() {
4315 if (this.count_ != this.keys_.length) {
4316 for (var srcIndex = 0, destIndex = 0;srcIndex < this.keys_.length;) {
4317 var key = this.keys_[srcIndex];
4318 goog.structs.Map.hasKey_(this.map_, key) && (this.keys_[destIndex++] = key);
4321 this.keys_.length = destIndex;
4323 if (this.count_ != this.keys_.length) {
4324 for (var seen = {}, destIndex = srcIndex = 0;srcIndex < this.keys_.length;) {
4325 key = this.keys_[srcIndex], goog.structs.Map.hasKey_(seen, key) || (this.keys_[destIndex++] = key, seen[key] = 1), srcIndex++;
4327 this.keys_.length = destIndex;
4330 goog.structs.Map.prototype.get = function(key, opt_val) {
4331 return goog.structs.Map.hasKey_(this.map_, key) ? this.map_[key] : opt_val;
4333 goog.structs.Map.prototype.set = function(key, value) {
4334 goog.structs.Map.hasKey_(this.map_, key) || (this.count_++, this.keys_.push(key), this.version_++);
4335 this.map_[key] = value;
4337 goog.structs.Map.prototype.addAll = function(map) {
4339 map instanceof goog.structs.Map ? (keys = map.getKeys(), values = map.getValues()) : (keys = goog.object.getKeys(map), values = goog.object.getValues(map));
4340 for (var i = 0;i < keys.length;i++) {
4341 this.set(keys[i], values[i]);
4344 goog.structs.Map.prototype.forEach = function(f, opt_obj) {
4345 for (var keys = this.getKeys(), i = 0;i < keys.length;i++) {
4346 var key = keys[i], value = this.get(key);
4347 f.call(opt_obj, value, key, this);
4350 goog.structs.Map.prototype.clone = function() {
4351 return new goog.structs.Map(this);
4353 goog.structs.Map.prototype.transpose = function() {
4354 for (var transposed = new goog.structs.Map, i = 0;i < this.keys_.length;i++) {
4355 var key = this.keys_[i], value = this.map_[key];
4356 transposed.set(value, key);
4360 goog.structs.Map.prototype.toObject = function() {
4361 this.cleanupKeysArray_();
4362 for (var obj = {}, i = 0;i < this.keys_.length;i++) {
4363 var key = this.keys_[i];
4364 obj[key] = this.map_[key];
4368 goog.structs.Map.prototype.__iterator__ = function(opt_keys) {
4369 this.cleanupKeysArray_();
4370 var i = 0, keys = this.keys_, map = this.map_, version = this.version_, selfObj = this, newIter = new goog.iter.Iterator;
4371 newIter.next = function() {
4373 if (version != selfObj.version_) {
4374 throw Error("The map has changed since the iterator was created");
4376 if (i >= keys.length) {
4377 throw goog.iter.StopIteration;
4379 var key = keys[i++];
4380 return opt_keys ? key : map[key];
4385 goog.structs.Map.hasKey_ = function(obj, key) {
4386 return Object.prototype.hasOwnProperty.call(obj, key);
4388 goog.structs.getCount = function(col) {
4389 return "function" == typeof col.getCount ? col.getCount() : goog.isArrayLike(col) || goog.isString(col) ? col.length : goog.object.getCount(col);
4391 goog.structs.getValues = function(col) {
4392 if ("function" == typeof col.getValues) {
4393 return col.getValues();
4395 if (goog.isString(col)) {
4396 return col.split("");
4398 if (goog.isArrayLike(col)) {
4399 for (var rv = [], l = col.length, i = 0;i < l;i++) {
4404 return goog.object.getValues(col);
4406 goog.structs.getKeys = function(col) {
4407 if ("function" == typeof col.getKeys) {
4408 return col.getKeys();
4410 if ("function" != typeof col.getValues) {
4411 if (goog.isArrayLike(col) || goog.isString(col)) {
4412 for (var rv = [], l = col.length, i = 0;i < l;i++) {
4417 return goog.object.getKeys(col);
4420 goog.structs.contains = function(col, val) {
4421 return "function" == typeof col.contains ? col.contains(val) : "function" == typeof col.containsValue ? col.containsValue(val) : goog.isArrayLike(col) || goog.isString(col) ? goog.array.contains(col, val) : goog.object.containsValue(col, val);
4423 goog.structs.isEmpty = function(col) {
4424 return "function" == typeof col.isEmpty ? col.isEmpty() : goog.isArrayLike(col) || goog.isString(col) ? goog.array.isEmpty(col) : goog.object.isEmpty(col);
4426 goog.structs.clear = function(col) {
4427 "function" == typeof col.clear ? col.clear() : goog.isArrayLike(col) ? goog.array.clear(col) : goog.object.clear(col);
4429 goog.structs.forEach = function(col, f, opt_obj) {
4430 if ("function" == typeof col.forEach) {
4431 col.forEach(f, opt_obj);
4433 if (goog.isArrayLike(col) || goog.isString(col)) {
4434 goog.array.forEach(col, f, opt_obj);
4436 for (var keys = goog.structs.getKeys(col), values = goog.structs.getValues(col), l = values.length, i = 0;i < l;i++) {
4437 f.call(opt_obj, values[i], keys && keys[i], col);
4442 goog.structs.filter = function(col, f, opt_obj) {
4443 if ("function" == typeof col.filter) {
4444 return col.filter(f, opt_obj);
4446 if (goog.isArrayLike(col) || goog.isString(col)) {
4447 return goog.array.filter(col, f, opt_obj);
4449 var rv, keys = goog.structs.getKeys(col), values = goog.structs.getValues(col), l = values.length;
4452 for (var i = 0;i < l;i++) {
4453 f.call(opt_obj, values[i], keys[i], col) && (rv[keys[i]] = values[i]);
4456 for (rv = [], i = 0;i < l;i++) {
4457 f.call(opt_obj, values[i], void 0, col) && rv.push(values[i]);
4462 goog.structs.map = function(col, f, opt_obj) {
4463 if ("function" == typeof col.map) {
4464 return col.map(f, opt_obj);
4466 if (goog.isArrayLike(col) || goog.isString(col)) {
4467 return goog.array.map(col, f, opt_obj);
4469 var rv, keys = goog.structs.getKeys(col), values = goog.structs.getValues(col), l = values.length;
4472 for (var i = 0;i < l;i++) {
4473 rv[keys[i]] = f.call(opt_obj, values[i], keys[i], col);
4476 for (rv = [], i = 0;i < l;i++) {
4477 rv[i] = f.call(opt_obj, values[i], void 0, col);
4482 goog.structs.some = function(col, f, opt_obj) {
4483 if ("function" == typeof col.some) {
4484 return col.some(f, opt_obj);
4486 if (goog.isArrayLike(col) || goog.isString(col)) {
4487 return goog.array.some(col, f, opt_obj);
4489 for (var keys = goog.structs.getKeys(col), values = goog.structs.getValues(col), l = values.length, i = 0;i < l;i++) {
4490 if (f.call(opt_obj, values[i], keys && keys[i], col)) {
4496 goog.structs.every = function(col, f, opt_obj) {
4497 if ("function" == typeof col.every) {
4498 return col.every(f, opt_obj);
4500 if (goog.isArrayLike(col) || goog.isString(col)) {
4501 return goog.array.every(col, f, opt_obj);
4503 for (var keys = goog.structs.getKeys(col), values = goog.structs.getValues(col), l = values.length, i = 0;i < l;i++) {
4504 if (!f.call(opt_obj, values[i], keys && keys[i], col)) {
4510 goog.structs.Set = function(opt_values) {
4511 this.map_ = new goog.structs.Map;
4512 opt_values && this.addAll(opt_values);
4514 goog.structs.Set.getKey_ = function(val) {
4515 var type = typeof val;
4516 return "object" == type && val || "function" == type ? "o" + goog.getUid(val) : type.substr(0, 1) + val;
4518 goog.structs.Set.prototype.getCount = function() {
4519 return this.map_.getCount();
4521 goog.structs.Set.prototype.add = function(element) {
4522 this.map_.set(goog.structs.Set.getKey_(element), element);
4524 goog.structs.Set.prototype.addAll = function(col) {
4525 for (var values = goog.structs.getValues(col), l = values.length, i = 0;i < l;i++) {
4526 this.add(values[i]);
4529 goog.structs.Set.prototype.removeAll = function(col) {
4530 for (var values = goog.structs.getValues(col), l = values.length, i = 0;i < l;i++) {
4531 this.remove(values[i]);
4534 goog.structs.Set.prototype.remove = function(element) {
4535 return this.map_.remove(goog.structs.Set.getKey_(element));
4537 goog.structs.Set.prototype.clear = function() {
4540 goog.structs.Set.prototype.isEmpty = function() {
4541 return this.map_.isEmpty();
4543 goog.structs.Set.prototype.contains = function(element) {
4544 return this.map_.containsKey(goog.structs.Set.getKey_(element));
4546 goog.structs.Set.prototype.difference = function(col) {
4547 var result = this.clone();
4548 result.removeAll(col);
4551 goog.structs.Set.prototype.getValues = function() {
4552 return this.map_.getValues();
4554 goog.structs.Set.prototype.clone = function() {
4555 return new goog.structs.Set(this);
4557 goog.structs.Set.prototype.equals = function(col) {
4558 return this.getCount() == goog.structs.getCount(col) && this.isSubsetOf(col);
4560 goog.structs.Set.prototype.isSubsetOf = function(col) {
4561 var colCount = goog.structs.getCount(col);
4562 if (this.getCount() > colCount) {
4565 !(col instanceof goog.structs.Set) && 5 < colCount && (col = new goog.structs.Set(col));
4566 return goog.structs.every(this, function(value) {
4567 return goog.structs.contains(col, value);
4570 goog.structs.Set.prototype.__iterator__ = function() {
4571 return this.map_.__iterator__(!1);
4573 goog.debug.LOGGING_ENABLED = goog.DEBUG;
4574 goog.debug.catchErrors = function(logFunc, opt_cancel, opt_target) {
4575 var target = opt_target || goog.global, oldErrorHandler = target.onerror, retVal = !!opt_cancel;
4576 goog.userAgent.WEBKIT && !goog.userAgent.isVersionOrHigher("535.3") && (retVal = !retVal);
4577 target.onerror = function(message, url, line, opt_col, opt_error) {
4578 oldErrorHandler && oldErrorHandler(message, url, line, opt_col, opt_error);
4579 logFunc({message:message, fileName:url, line:line, col:opt_col, error:opt_error});
4583 goog.debug.expose = function(obj, opt_showFn) {
4584 if ("undefined" == typeof obj) {
4592 if (opt_showFn || !goog.isFunction(obj[x])) {
4597 s += "*** " + e + " ***";
4602 return str.join("\n");
4604 goog.debug.deepExpose = function(obj$$0, opt_showFn) {
4605 var str = [], helper = function(obj, space, parentSeen) {
4606 var nestspace = space + " ", seen = new goog.structs.Set(parentSeen);
4608 if (goog.isDef(obj)) {
4609 if (goog.isNull(obj)) {
4612 if (goog.isString(obj)) {
4613 str.push('"' + obj.replace(/\n/g, "\n" + space) + '"');
4615 if (goog.isFunction(obj)) {
4616 str.push(String(obj).replace(/\n/g, "\n" + space));
4618 if (goog.isObject(obj)) {
4619 if (seen.contains(obj)) {
4620 str.push("*** reference loop detected ***");
4624 for (var x in obj) {
4625 if (opt_showFn || !goog.isFunction(obj[x])) {
4626 str.push("\n"), str.push(nestspace), str.push(x + " = "), helper(obj[x], nestspace, seen);
4629 str.push("\n" + space + "}");
4638 str.push("undefined");
4641 str.push("*** " + e + " ***");
4644 helper(obj$$0, "", new goog.structs.Set);
4645 return str.join("");
4647 goog.debug.exposeArray = function(arr) {
4648 for (var str = [], i = 0;i < arr.length;i++) {
4649 goog.isArray(arr[i]) ? str.push(goog.debug.exposeArray(arr[i])) : str.push(arr[i]);
4651 return "[ " + str.join(", ") + " ]";
4653 goog.debug.exposeException = function(err, opt_fn) {
4655 var e = goog.debug.normalizeErrorObject(err), error = "Message: " + goog.string.htmlEscape(e.message) + '\nUrl: <a href="view-source:' + e.fileName + '" target="_new">' + e.fileName + "</a>\nLine: " + e.lineNumber + "\n\nBrowser stack:\n" + goog.string.htmlEscape(e.stack + "-> ") + "[end]\n\nJS stack traversal:\n" + goog.string.htmlEscape(goog.debug.getStacktrace(opt_fn) + "-> ");
4658 return "Exception trying to expose exception! You win, we lose. " + e2;
4661 goog.debug.normalizeErrorObject = function(err) {
4662 var href = goog.getObjectByName("window.location.href");
4663 if (goog.isString(err)) {
4664 return{message:err, name:"Unknown error", lineNumber:"Not available", fileName:href, stack:"Not available"};
4666 var lineNumber, fileName, threwError = !1;
4668 lineNumber = err.lineNumber || err.line || "Not available";
4670 lineNumber = "Not available", threwError = !0;
4673 fileName = err.fileName || err.filename || err.sourceURL || goog.global.$googDebugFname || href;
4675 fileName = "Not available", threwError = !0;
4677 return!threwError && err.lineNumber && err.fileName && err.stack && err.message && err.name ? err : {message:err.message || "Not available", name:err.name || "UnknownError", lineNumber:lineNumber, fileName:fileName, stack:err.stack || "Not available"};
4679 goog.debug.enhanceError = function(err, opt_message) {
4681 "string" == typeof err ? (error = Error(err), Error.captureStackTrace && Error.captureStackTrace(error, goog.debug.enhanceError)) : error = err;
4682 error.stack || (error.stack = goog.debug.getStacktrace(goog.debug.enhanceError));
4684 for (var x = 0;error["message" + x];) {
4687 error["message" + x] = String(opt_message);
4691 goog.debug.getStacktraceSimple = function(opt_depth) {
4692 if (goog.STRICT_MODE_COMPATIBLE) {
4693 var stack = goog.debug.getNativeStackTrace_(goog.debug.getStacktraceSimple);
4698 for (var sb = [], fn = arguments.callee.caller, depth = 0;fn && (!opt_depth || depth < opt_depth);) {
4699 sb.push(goog.debug.getFunctionName(fn));
4704 sb.push("[exception trying to get caller]\n");
4708 if (depth >= goog.debug.MAX_STACK_DEPTH) {
4709 sb.push("[...long stack...]");
4713 opt_depth && depth >= opt_depth ? sb.push("[...reached max depth limit...]") : sb.push("[end]");
4716 goog.debug.MAX_STACK_DEPTH = 50;
4717 goog.debug.getNativeStackTrace_ = function(fn) {
4718 var tempErr = Error();
4719 if (Error.captureStackTrace) {
4720 return Error.captureStackTrace(tempErr, fn), String(tempErr.stack);
4727 var stack = tempErr.stack;
4728 return stack ? String(stack) : null;
4730 goog.debug.getStacktrace = function(opt_fn) {
4732 if (goog.STRICT_MODE_COMPATIBLE) {
4733 var contextFn = opt_fn || goog.debug.getStacktrace;
4734 stack = goog.debug.getNativeStackTrace_(contextFn);
4736 stack || (stack = goog.debug.getStacktraceHelper_(opt_fn || arguments.callee.caller, []));
4739 goog.debug.getStacktraceHelper_ = function(fn, visited) {
4741 if (goog.array.contains(visited, fn)) {
4742 sb.push("[...circular reference...]");
4744 if (fn && visited.length < goog.debug.MAX_STACK_DEPTH) {
4745 sb.push(goog.debug.getFunctionName(fn) + "(");
4746 for (var args = fn.arguments, i = 0;args && i < args.length;i++) {
4747 0 < i && sb.push(", ");
4748 var argDesc, arg = args[i];
4749 switch(typeof arg) {
4751 argDesc = arg ? "object" : "null";
4757 argDesc = String(arg);
4760 argDesc = arg ? "true" : "false";
4763 argDesc = (argDesc = goog.debug.getFunctionName(arg)) ? argDesc : "[fn]";
4766 argDesc = typeof arg;
4768 40 < argDesc.length && (argDesc = argDesc.substr(0, 40) + "...");
4774 sb.push(goog.debug.getStacktraceHelper_(fn.caller, visited));
4776 sb.push("[exception trying to get caller]\n");
4779 fn ? sb.push("[...long stack...]") : sb.push("[end]");
4784 goog.debug.setFunctionResolver = function(resolver) {
4785 goog.debug.fnNameResolver_ = resolver;
4787 goog.debug.getFunctionName = function(fn) {
4788 if (goog.debug.fnNameCache_[fn]) {
4789 return goog.debug.fnNameCache_[fn];
4791 if (goog.debug.fnNameResolver_) {
4792 var name = goog.debug.fnNameResolver_(fn);
4794 return goog.debug.fnNameCache_[fn] = name;
4797 var functionSource = String(fn);
4798 if (!goog.debug.fnNameCache_[functionSource]) {
4799 var matches = /function ([^\(]+)/.exec(functionSource);
4801 var method = matches[1];
4802 goog.debug.fnNameCache_[functionSource] = method;
4804 goog.debug.fnNameCache_[functionSource] = "[Anonymous]";
4807 return goog.debug.fnNameCache_[functionSource];
4809 goog.debug.makeWhitespaceVisible = function(string) {
4810 return string.replace(/ /g, "[_]").replace(/\f/g, "[f]").replace(/\n/g, "[n]\n").replace(/\r/g, "[r]").replace(/\t/g, "[t]");
4812 goog.debug.fnNameCache_ = {};
4813 goog.debug.LogRecord = function(level, msg, loggerName, opt_time, opt_sequenceNumber) {
4814 this.reset(level, msg, loggerName, opt_time, opt_sequenceNumber);
4816 goog.debug.LogRecord.prototype.exception_ = null;
4817 goog.debug.LogRecord.prototype.exceptionText_ = null;
4818 goog.debug.LogRecord.ENABLE_SEQUENCE_NUMBERS = !0;
4819 goog.debug.LogRecord.nextSequenceNumber_ = 0;
4820 goog.debug.LogRecord.prototype.reset = function(level, msg, loggerName, opt_time, opt_sequenceNumber) {
4821 goog.debug.LogRecord.ENABLE_SEQUENCE_NUMBERS && ("number" == typeof opt_sequenceNumber || goog.debug.LogRecord.nextSequenceNumber_++);
4822 opt_time || goog.now();
4823 this.level_ = level;
4825 delete this.exception_;
4826 delete this.exceptionText_;
4828 goog.debug.LogRecord.prototype.setException = function(exception) {
4829 this.exception_ = exception;
4831 goog.debug.LogRecord.prototype.setExceptionText = function(text) {
4832 this.exceptionText_ = text;
4834 goog.debug.LogRecord.prototype.setLevel = function(level) {
4835 this.level_ = level;
4837 goog.debug.LogRecord.prototype.getMessage = function() {
4840 goog.debug.LogBuffer = function() {
4841 goog.asserts.assert(goog.debug.LogBuffer.isBufferingEnabled(), "Cannot use goog.debug.LogBuffer without defining goog.debug.LogBuffer.CAPACITY.");
4844 goog.debug.LogBuffer.getInstance = function() {
4845 goog.debug.LogBuffer.instance_ || (goog.debug.LogBuffer.instance_ = new goog.debug.LogBuffer);
4846 return goog.debug.LogBuffer.instance_;
4848 goog.debug.LogBuffer.CAPACITY = 0;
4849 goog.debug.LogBuffer.prototype.addRecord = function(level, msg, loggerName) {
4850 var curIndex = (this.curIndex_ + 1) % goog.debug.LogBuffer.CAPACITY;
4851 this.curIndex_ = curIndex;
4853 var ret = this.buffer_[curIndex];
4854 ret.reset(level, msg, loggerName);
4857 this.isFull_ = curIndex == goog.debug.LogBuffer.CAPACITY - 1;
4858 return this.buffer_[curIndex] = new goog.debug.LogRecord(level, msg, loggerName);
4860 goog.debug.LogBuffer.isBufferingEnabled = function() {
4861 return 0 < goog.debug.LogBuffer.CAPACITY;
4863 goog.debug.LogBuffer.prototype.clear = function() {
4864 this.buffer_ = Array(goog.debug.LogBuffer.CAPACITY);
4865 this.curIndex_ = -1;
4868 goog.debug.Logger = function(name) {
4870 this.handlers_ = this.children_ = this.level_ = this.parent_ = null;
4872 goog.debug.Logger.ROOT_LOGGER_NAME = "";
4873 goog.debug.Logger.ENABLE_HIERARCHY = !0;
4874 goog.debug.Logger.ENABLE_HIERARCHY || (goog.debug.Logger.rootHandlers_ = []);
4875 goog.debug.Logger.Level = function(name, value) {
4879 goog.debug.Logger.Level.prototype.toString = function() {
4882 goog.debug.Logger.Level.OFF = new goog.debug.Logger.Level("OFF", Infinity);
4883 goog.debug.Logger.Level.SHOUT = new goog.debug.Logger.Level("SHOUT", 1200);
4884 goog.debug.Logger.Level.SEVERE = new goog.debug.Logger.Level("SEVERE", 1E3);
4885 goog.debug.Logger.Level.WARNING = new goog.debug.Logger.Level("WARNING", 900);
4886 goog.debug.Logger.Level.INFO = new goog.debug.Logger.Level("INFO", 800);
4887 goog.debug.Logger.Level.CONFIG = new goog.debug.Logger.Level("CONFIG", 700);
4888 goog.debug.Logger.Level.FINE = new goog.debug.Logger.Level("FINE", 500);
4889 goog.debug.Logger.Level.FINER = new goog.debug.Logger.Level("FINER", 400);
4890 goog.debug.Logger.Level.FINEST = new goog.debug.Logger.Level("FINEST", 300);
4891 goog.debug.Logger.Level.ALL = new goog.debug.Logger.Level("ALL", 0);
4892 goog.debug.Logger.Level.PREDEFINED_LEVELS = [goog.debug.Logger.Level.OFF, goog.debug.Logger.Level.SHOUT, goog.debug.Logger.Level.SEVERE, goog.debug.Logger.Level.WARNING, goog.debug.Logger.Level.INFO, goog.debug.Logger.Level.CONFIG, goog.debug.Logger.Level.FINE, goog.debug.Logger.Level.FINER, goog.debug.Logger.Level.FINEST, goog.debug.Logger.Level.ALL];
4893 goog.debug.Logger.Level.predefinedLevelsCache_ = null;
4894 goog.debug.Logger.Level.createPredefinedLevelsCache_ = function() {
4895 goog.debug.Logger.Level.predefinedLevelsCache_ = {};
4896 for (var i = 0, level;level = goog.debug.Logger.Level.PREDEFINED_LEVELS[i];i++) {
4897 goog.debug.Logger.Level.predefinedLevelsCache_[level.value] = level, goog.debug.Logger.Level.predefinedLevelsCache_[level.name] = level;
4900 goog.debug.Logger.Level.getPredefinedLevel = function(name) {
4901 goog.debug.Logger.Level.predefinedLevelsCache_ || goog.debug.Logger.Level.createPredefinedLevelsCache_();
4902 return goog.debug.Logger.Level.predefinedLevelsCache_[name] || null;
4904 goog.debug.Logger.Level.getPredefinedLevelByValue = function(value) {
4905 goog.debug.Logger.Level.predefinedLevelsCache_ || goog.debug.Logger.Level.createPredefinedLevelsCache_();
4906 if (value in goog.debug.Logger.Level.predefinedLevelsCache_) {
4907 return goog.debug.Logger.Level.predefinedLevelsCache_[value];
4909 for (var i = 0;i < goog.debug.Logger.Level.PREDEFINED_LEVELS.length;++i) {
4910 var level = goog.debug.Logger.Level.PREDEFINED_LEVELS[i];
4911 if (level.value <= value) {
4917 goog.debug.Logger.getLogger = function(name) {
4918 return goog.debug.LogManager.getLogger(name);
4920 goog.debug.Logger.logToProfilers = function(msg) {
4921 goog.global.console && (goog.global.console.timeStamp ? goog.global.console.timeStamp(msg) : goog.global.console.markTimeline && goog.global.console.markTimeline(msg));
4922 goog.global.msWriteProfilerMark && goog.global.msWriteProfilerMark(msg);
4924 goog.debug.Logger.prototype.getName = function() {
4927 goog.debug.Logger.prototype.addHandler = function(handler) {
4928 goog.debug.LOGGING_ENABLED && (goog.debug.Logger.ENABLE_HIERARCHY ? (this.handlers_ || (this.handlers_ = []), this.handlers_.push(handler)) : (goog.asserts.assert(!this.name_, "Cannot call addHandler on a non-root logger when goog.debug.Logger.ENABLE_HIERARCHY is false."), goog.debug.Logger.rootHandlers_.push(handler)));
4930 goog.debug.Logger.prototype.removeHandler = function(handler) {
4931 if (goog.debug.LOGGING_ENABLED) {
4932 var handlers = goog.debug.Logger.ENABLE_HIERARCHY ? this.handlers_ : goog.debug.Logger.rootHandlers_;
4933 return!!handlers && goog.array.remove(handlers, handler);
4937 goog.debug.Logger.prototype.getParent = function() {
4938 return this.parent_;
4940 goog.debug.Logger.prototype.getChildren = function() {
4941 this.children_ || (this.children_ = {});
4942 return this.children_;
4944 goog.debug.Logger.prototype.setLevel = function(level) {
4945 goog.debug.LOGGING_ENABLED && (goog.debug.Logger.ENABLE_HIERARCHY ? this.level_ = level : (goog.asserts.assert(!this.name_, "Cannot call setLevel() on a non-root logger when goog.debug.Logger.ENABLE_HIERARCHY is false."), goog.debug.Logger.rootLevel_ = level));
4947 goog.debug.Logger.prototype.getEffectiveLevel = function() {
4948 if (!goog.debug.LOGGING_ENABLED) {
4949 return goog.debug.Logger.Level.OFF;
4951 if (!goog.debug.Logger.ENABLE_HIERARCHY) {
4952 return goog.debug.Logger.rootLevel_;
4958 return this.parent_.getEffectiveLevel();
4960 goog.asserts.fail("Root logger has no level set.");
4963 goog.debug.Logger.prototype.isLoggable = function(level) {
4964 return goog.debug.LOGGING_ENABLED && level.value >= this.getEffectiveLevel().value;
4966 goog.debug.Logger.prototype.log = function(level, msg, opt_exception) {
4967 goog.debug.LOGGING_ENABLED && this.isLoggable(level) && (goog.isFunction(msg) && (msg = msg()), this.doLogRecord_(this.getLogRecord(level, msg, opt_exception, goog.debug.Logger.prototype.log)));
4969 goog.debug.Logger.prototype.getLogRecord = function(level, msg, opt_exception, opt_fnStackContext) {
4970 var logRecord = goog.debug.LogBuffer.isBufferingEnabled() ? goog.debug.LogBuffer.getInstance().addRecord(level, msg, this.name_) : new goog.debug.LogRecord(level, String(msg), this.name_);
4971 opt_exception && (logRecord.setException(opt_exception), logRecord.setExceptionText(goog.debug.exposeException(opt_exception, opt_fnStackContext || goog.debug.Logger.prototype.getLogRecord)));
4974 goog.debug.Logger.prototype.severe = function(msg, opt_exception) {
4975 goog.debug.LOGGING_ENABLED && this.log(goog.debug.Logger.Level.SEVERE, msg, opt_exception);
4977 goog.debug.Logger.prototype.warning = function(msg, opt_exception) {
4978 goog.debug.LOGGING_ENABLED && this.log(goog.debug.Logger.Level.WARNING, msg, opt_exception);
4980 goog.debug.Logger.prototype.info = function(msg, opt_exception) {
4981 goog.debug.LOGGING_ENABLED && this.log(goog.debug.Logger.Level.INFO, msg, opt_exception);
4983 goog.debug.Logger.prototype.fine = function(msg, opt_exception) {
4984 goog.debug.LOGGING_ENABLED && this.log(goog.debug.Logger.Level.FINE, msg, opt_exception);
4986 goog.debug.Logger.prototype.doLogRecord_ = function(logRecord) {
4987 goog.debug.Logger.logToProfilers("log:" + logRecord.getMessage());
4988 if (goog.debug.Logger.ENABLE_HIERARCHY) {
4989 for (var target = this;target;) {
4990 target.callPublish_(logRecord), target = target.getParent();
4993 for (var i = 0, handler;handler = goog.debug.Logger.rootHandlers_[i++];) {
4998 goog.debug.Logger.prototype.callPublish_ = function(logRecord) {
4999 if (this.handlers_) {
5000 for (var i = 0, handler;handler = this.handlers_[i];i++) {
5005 goog.debug.Logger.prototype.setParent_ = function(parent) {
5006 this.parent_ = parent;
5008 goog.debug.Logger.prototype.addChild_ = function(name, logger) {
5009 this.getChildren()[name] = logger;
5011 goog.debug.LogManager = {};
5012 goog.debug.LogManager.loggers_ = {};
5013 goog.debug.LogManager.rootLogger_ = null;
5014 goog.debug.LogManager.initialize = function() {
5015 goog.debug.LogManager.rootLogger_ || (goog.debug.LogManager.rootLogger_ = new goog.debug.Logger(goog.debug.Logger.ROOT_LOGGER_NAME), goog.debug.LogManager.loggers_[goog.debug.Logger.ROOT_LOGGER_NAME] = goog.debug.LogManager.rootLogger_, goog.debug.LogManager.rootLogger_.setLevel(goog.debug.Logger.Level.CONFIG));
5017 goog.debug.LogManager.getLoggers = function() {
5018 return goog.debug.LogManager.loggers_;
5020 goog.debug.LogManager.getRoot = function() {
5021 goog.debug.LogManager.initialize();
5022 return goog.debug.LogManager.rootLogger_;
5024 goog.debug.LogManager.getLogger = function(name) {
5025 goog.debug.LogManager.initialize();
5026 var ret = goog.debug.LogManager.loggers_[name];
5027 return ret || goog.debug.LogManager.createLogger_(name);
5029 goog.debug.LogManager.createFunctionForCatchErrors = function(opt_logger) {
5030 return function(info) {
5031 var logger = opt_logger || goog.debug.LogManager.getRoot();
5032 logger.severe("Error: " + info.message + " (" + info.fileName + " @ Line: " + info.line + ")");
5035 goog.debug.LogManager.createLogger_ = function(name) {
5036 var logger = new goog.debug.Logger(name);
5037 if (goog.debug.Logger.ENABLE_HIERARCHY) {
5038 var lastDotIndex = name.lastIndexOf("."), parentName = name.substr(0, lastDotIndex), leafName = name.substr(lastDotIndex + 1), parentLogger = goog.debug.LogManager.getLogger(parentName);
5039 parentLogger.addChild_(leafName, logger);
5040 logger.setParent_(parentLogger);
5042 return goog.debug.LogManager.loggers_[name] = logger;
5045 goog.log.ENABLED = goog.debug.LOGGING_ENABLED;
5046 goog.log.ROOT_LOGGER_NAME = goog.debug.Logger.ROOT_LOGGER_NAME;
5047 goog.log.Logger = goog.debug.Logger;
5048 goog.log.Level = goog.debug.Logger.Level;
5049 goog.log.LogRecord = goog.debug.LogRecord;
5050 goog.log.getLogger = function(name, opt_level) {
5051 if (goog.log.ENABLED) {
5052 var logger = goog.debug.LogManager.getLogger(name);
5053 opt_level && logger && logger.setLevel(opt_level);
5058 goog.log.addHandler = function(logger, handler) {
5059 goog.log.ENABLED && logger && logger.addHandler(handler);
5061 goog.log.removeHandler = function(logger, handler) {
5062 return goog.log.ENABLED && logger ? logger.removeHandler(handler) : !1;
5064 goog.log.log = function(logger, level, msg, opt_exception) {
5065 goog.log.ENABLED && logger && logger.log(level, msg, opt_exception);
5067 goog.log.error = function(logger, msg, opt_exception) {
5068 goog.log.ENABLED && logger && logger.severe(msg, opt_exception);
5070 goog.log.warning = function(logger, msg, opt_exception) {
5071 goog.log.ENABLED && logger && logger.warning(msg, opt_exception);
5073 goog.log.info = function(logger, msg, opt_exception) {
5074 goog.log.ENABLED && logger && logger.info(msg, opt_exception);
5076 goog.log.fine = function(logger, msg, opt_exception) {
5077 goog.log.ENABLED && logger && logger.fine(msg, opt_exception);
5080 goog.async.throwException = function(exception) {
5081 goog.global.setTimeout(function() {
5085 goog.async.nextTick = function(callback, opt_context) {
5087 opt_context && (cb = goog.bind(callback, opt_context));
5088 cb = goog.async.nextTick.wrapCallback_(cb);
5089 !goog.isFunction(goog.global.setImmediate) || goog.global.Window && goog.global.Window.prototype.setImmediate == goog.global.setImmediate ? (goog.async.nextTick.setImmediate_ || (goog.async.nextTick.setImmediate_ = goog.async.nextTick.getSetImmediateEmulator_()), goog.async.nextTick.setImmediate_(cb)) : goog.global.setImmediate(cb);
5091 goog.async.nextTick.getSetImmediateEmulator_ = function() {
5092 var Channel = goog.global.MessageChannel;
5093 "undefined" === typeof Channel && "undefined" !== typeof window && window.postMessage && window.addEventListener && (Channel = function() {
5094 var iframe = document.createElement("iframe");
5095 iframe.style.display = "none";
5097 document.documentElement.appendChild(iframe);
5098 var win = iframe.contentWindow, doc = win.document;
5102 var message = "callImmediate" + Math.random(), origin = "file:" == win.location.protocol ? "*" : win.location.protocol + "//" + win.location.host, onmessage = goog.bind(function(e) {
5103 if (("*" == origin || e.origin == origin) && e.data == message) {
5104 this.port1.onmessage();
5107 win.addEventListener("message", onmessage, !1);
5109 this.port2 = {postMessage:function() {
5110 win.postMessage(message, origin);
5113 if ("undefined" !== typeof Channel && !goog.labs.userAgent.browser.isIE()) {
5114 var channel = new Channel, head = {}, tail = head;
5115 channel.port1.onmessage = function() {
5116 if (goog.isDef(head.next)) {
5123 return function(cb) {
5124 tail.next = {cb:cb};
5126 channel.port2.postMessage(0);
5129 return "undefined" !== typeof document && "onreadystatechange" in document.createElement("script") ? function(cb) {
5130 var script = document.createElement("script");
5131 script.onreadystatechange = function() {
5132 script.onreadystatechange = null;
5133 script.parentNode.removeChild(script);
5138 document.documentElement.appendChild(script);
5140 goog.global.setTimeout(cb, 0);
5143 goog.async.nextTick.wrapCallback_ = goog.functions.identity;
5144 goog.debug.entryPointRegistry.register(function(transformer) {
5145 goog.async.nextTick.wrapCallback_ = transformer;
5148 goog.testing.watchers = {};
5149 goog.testing.watchers.resetWatchers_ = [];
5150 goog.testing.watchers.signalClockReset = function() {
5151 for (var watchers = goog.testing.watchers.resetWatchers_, i = 0;i < watchers.length;i++) {
5152 goog.testing.watchers.resetWatchers_[i]();
5155 goog.testing.watchers.watchClockReset = function(fn) {
5156 goog.testing.watchers.resetWatchers_.push(fn);
5158 goog.async.run = function(callback, opt_context) {
5159 goog.async.run.schedule_ || goog.async.run.initializeRunner_();
5160 goog.async.run.workQueueScheduled_ || (goog.async.run.schedule_(), goog.async.run.workQueueScheduled_ = !0);
5161 goog.async.run.workQueue_.push(new goog.async.run.WorkItem_(callback, opt_context));
5163 goog.async.run.initializeRunner_ = function() {
5164 if (goog.global.Promise && goog.global.Promise.resolve) {
5165 var promise = goog.global.Promise.resolve();
5166 goog.async.run.schedule_ = function() {
5167 promise.then(goog.async.run.processWorkQueue);
5170 goog.async.run.schedule_ = function() {
5171 goog.async.nextTick(goog.async.run.processWorkQueue);
5175 goog.async.run.forceNextTick = function() {
5176 goog.async.run.schedule_ = function() {
5177 goog.async.nextTick(goog.async.run.processWorkQueue);
5180 goog.async.run.workQueueScheduled_ = !1;
5181 goog.async.run.workQueue_ = [];
5182 goog.DEBUG && (goog.async.run.resetQueue_ = function() {
5183 goog.async.run.workQueueScheduled_ = !1;
5184 goog.async.run.workQueue_ = [];
5185 }, goog.testing.watchers.watchClockReset(goog.async.run.resetQueue_));
5186 goog.async.run.processWorkQueue = function() {
5187 for (;goog.async.run.workQueue_.length;) {
5188 var workItems = goog.async.run.workQueue_;
5189 goog.async.run.workQueue_ = [];
5190 for (var i = 0;i < workItems.length;i++) {
5191 var workItem = workItems[i];
5193 workItem.fn.call(workItem.scope);
5195 goog.async.throwException(e);
5199 goog.async.run.workQueueScheduled_ = !1;
5201 goog.async.run.WorkItem_ = function(fn, scope) {
5206 goog.promise.Resolver = function() {
5208 goog.Thenable = function() {
5210 goog.Thenable.prototype.then = function() {
5212 goog.Thenable.IMPLEMENTED_BY_PROP = "$goog_Thenable";
5213 goog.Thenable.addImplementation = function(ctor) {
5214 goog.exportProperty(ctor.prototype, "then", ctor.prototype.then);
5215 ctor.prototype[goog.Thenable.IMPLEMENTED_BY_PROP] = !0;
5217 goog.Thenable.isImplementedBy = function(object) {
5222 return!!object[goog.Thenable.IMPLEMENTED_BY_PROP];
5227 goog.Promise = function(resolver, opt_context) {
5228 this.state_ = goog.Promise.State_.PENDING;
5229 this.result_ = void 0;
5230 this.callbackEntries_ = this.parent_ = null;
5231 this.executing_ = !1;
5232 0 < goog.Promise.UNHANDLED_REJECTION_DELAY ? this.unhandledRejectionId_ = 0 : 0 == goog.Promise.UNHANDLED_REJECTION_DELAY && (this.hadUnhandledRejection_ = !1);
5233 goog.Promise.LONG_STACK_TRACES && (this.stack_ = [], this.addStackTrace_(Error("created")), this.currentStep_ = 0);
5236 resolver.call(opt_context, function(value) {
5237 self.resolve_(goog.Promise.State_.FULFILLED, value);
5238 }, function(reason) {
5239 if (goog.DEBUG && !(reason instanceof goog.Promise.CancellationError)) {
5241 if (reason instanceof Error) {
5244 throw Error("Promise rejected.");
5248 self.resolve_(goog.Promise.State_.REJECTED, reason);
5251 this.resolve_(goog.Promise.State_.REJECTED, e$$0);
5254 goog.Promise.LONG_STACK_TRACES = !1;
5255 goog.Promise.UNHANDLED_REJECTION_DELAY = 0;
5256 goog.Promise.State_ = {PENDING:0, BLOCKED:1, FULFILLED:2, REJECTED:3};
5257 goog.Promise.resolve = function(opt_value) {
5258 return new goog.Promise(function(resolve) {
5262 goog.Promise.reject = function(opt_reason) {
5263 return new goog.Promise(function(resolve, reject) {
5267 goog.Promise.race = function(promises) {
5268 return new goog.Promise(function(resolve, reject) {
5269 promises.length || resolve(void 0);
5270 for (var i = 0, promise;promise = promises[i];i++) {
5271 promise.then(resolve, reject);
5275 goog.Promise.all = function(promises) {
5276 return new goog.Promise(function(resolve, reject) {
5277 var toFulfill = promises.length, values = [];
5279 for (var onFulfill = function(index, value) {
5281 values[index] = value;
5282 0 == toFulfill && resolve(values);
5283 }, onReject = function(reason) {
5285 }, i = 0, promise;promise = promises[i];i++) {
5286 promise.then(goog.partial(onFulfill, i), onReject);
5293 goog.Promise.firstFulfilled = function(promises) {
5294 return new goog.Promise(function(resolve, reject) {
5295 var toReject = promises.length, reasons = [];
5297 for (var onFulfill = function(value) {
5299 }, onReject = function(index, reason) {
5301 reasons[index] = reason;
5302 0 == toReject && reject(reasons);
5303 }, i = 0, promise;promise = promises[i];i++) {
5304 promise.then(onFulfill, goog.partial(onReject, i));
5311 goog.Promise.withResolver = function() {
5312 var resolve, reject, promise = new goog.Promise(function(rs, rj) {
5316 return new goog.Promise.Resolver_(promise, resolve, reject);
5318 goog.Promise.prototype.then = function(opt_onFulfilled, opt_onRejected, opt_context) {
5319 null != opt_onFulfilled && goog.asserts.assertFunction(opt_onFulfilled, "opt_onFulfilled should be a function.");
5320 null != opt_onRejected && goog.asserts.assertFunction(opt_onRejected, "opt_onRejected should be a function. Did you pass opt_context as the second argument instead of the third?");
5321 goog.Promise.LONG_STACK_TRACES && this.addStackTrace_(Error("then"));
5322 return this.addChildPromise_(goog.isFunction(opt_onFulfilled) ? opt_onFulfilled : null, goog.isFunction(opt_onRejected) ? opt_onRejected : null, opt_context);
5324 goog.Thenable.addImplementation(goog.Promise);
5325 goog.Promise.prototype.thenCatch = function(onRejected, opt_context) {
5326 goog.Promise.LONG_STACK_TRACES && this.addStackTrace_(Error("thenCatch"));
5327 return this.addChildPromise_(null, onRejected, opt_context);
5329 goog.Promise.prototype.cancel = function(opt_message) {
5330 this.state_ == goog.Promise.State_.PENDING && goog.async.run(function() {
5331 var err = new goog.Promise.CancellationError(opt_message);
5332 this.cancelInternal_(err);
5335 goog.Promise.prototype.cancelInternal_ = function(err) {
5336 this.state_ == goog.Promise.State_.PENDING && (this.parent_ ? this.parent_.cancelChild_(this, err) : this.resolve_(goog.Promise.State_.REJECTED, err));
5338 goog.Promise.prototype.cancelChild_ = function(childPromise, err) {
5339 if (this.callbackEntries_) {
5340 for (var childCount = 0, childIndex = -1, i = 0, entry;entry = this.callbackEntries_[i];i++) {
5341 var child = entry.child;
5342 if (child && (childCount++, child == childPromise && (childIndex = i), 0 <= childIndex && 1 < childCount)) {
5346 if (0 <= childIndex) {
5347 if (this.state_ == goog.Promise.State_.PENDING && 1 == childCount) {
5348 this.cancelInternal_(err);
5350 var callbackEntry = this.callbackEntries_.splice(childIndex, 1)[0];
5351 this.executeCallback_(callbackEntry, goog.Promise.State_.REJECTED, err);
5356 goog.Promise.prototype.addCallbackEntry_ = function(callbackEntry) {
5357 this.callbackEntries_ && this.callbackEntries_.length || this.state_ != goog.Promise.State_.FULFILLED && this.state_ != goog.Promise.State_.REJECTED || this.scheduleCallbacks_();
5358 this.callbackEntries_ || (this.callbackEntries_ = []);
5359 this.callbackEntries_.push(callbackEntry);
5361 goog.Promise.prototype.addChildPromise_ = function(onFulfilled, onRejected, opt_context) {
5362 var callbackEntry = {child:null, onFulfilled:null, onRejected:null};
5363 callbackEntry.child = new goog.Promise(function(resolve, reject) {
5364 callbackEntry.onFulfilled = onFulfilled ? function(value) {
5366 var result = onFulfilled.call(opt_context, value);
5372 callbackEntry.onRejected = onRejected ? function(reason) {
5374 var result = onRejected.call(opt_context, reason);
5375 !goog.isDef(result) && reason instanceof goog.Promise.CancellationError ? reject(reason) : resolve(result);
5381 callbackEntry.child.parent_ = this;
5382 this.addCallbackEntry_(callbackEntry);
5383 return callbackEntry.child;
5385 goog.Promise.prototype.unblockAndFulfill_ = function(value) {
5386 goog.asserts.assert(this.state_ == goog.Promise.State_.BLOCKED);
5387 this.state_ = goog.Promise.State_.PENDING;
5388 this.resolve_(goog.Promise.State_.FULFILLED, value);
5390 goog.Promise.prototype.unblockAndReject_ = function(reason) {
5391 goog.asserts.assert(this.state_ == goog.Promise.State_.BLOCKED);
5392 this.state_ = goog.Promise.State_.PENDING;
5393 this.resolve_(goog.Promise.State_.REJECTED, reason);
5395 goog.Promise.prototype.resolve_ = function(state, x) {
5396 if (this.state_ == goog.Promise.State_.PENDING) {
5398 state = goog.Promise.State_.REJECTED, x = new TypeError("Promise cannot resolve to itself");
5400 if (goog.Thenable.isImplementedBy(x)) {
5401 this.state_ = goog.Promise.State_.BLOCKED;
5402 x.then(this.unblockAndFulfill_, this.unblockAndReject_, this);
5405 if (goog.isObject(x)) {
5408 if (goog.isFunction(then)) {
5409 this.tryThen_(x, then);
5413 state = goog.Promise.State_.REJECTED, x = e;
5418 this.state_ = state;
5419 this.scheduleCallbacks_();
5420 state != goog.Promise.State_.REJECTED || x instanceof goog.Promise.CancellationError || goog.Promise.addUnhandledRejection_(this, x);
5423 goog.Promise.prototype.tryThen_ = function(thenable, then) {
5424 this.state_ = goog.Promise.State_.BLOCKED;
5425 var promise = this, called = !1, resolve = function(value) {
5426 called || (called = !0, promise.unblockAndFulfill_(value));
5427 }, reject = function(reason) {
5428 called || (called = !0, promise.unblockAndReject_(reason));
5431 then.call(thenable, resolve, reject);
5436 goog.Promise.prototype.scheduleCallbacks_ = function() {
5437 this.executing_ || (this.executing_ = !0, goog.async.run(this.executeCallbacks_, this));
5439 goog.Promise.prototype.executeCallbacks_ = function() {
5440 for (;this.callbackEntries_ && this.callbackEntries_.length;) {
5441 var entries = this.callbackEntries_;
5442 this.callbackEntries_ = [];
5443 for (var i = 0;i < entries.length;i++) {
5444 goog.Promise.LONG_STACK_TRACES && this.currentStep_++, this.executeCallback_(entries[i], this.state_, this.result_);
5447 this.executing_ = !1;
5449 goog.Promise.prototype.executeCallback_ = function(callbackEntry, state, result) {
5450 if (state == goog.Promise.State_.FULFILLED) {
5451 callbackEntry.onFulfilled(result);
5453 this.removeUnhandledRejection_(), callbackEntry.onRejected(result);
5456 goog.Promise.prototype.addStackTrace_ = function(err) {
5457 if (goog.Promise.LONG_STACK_TRACES && goog.isString(err.stack)) {
5458 var trace = err.stack.split("\n", 4)[3], message = err.message, message = message + Array(11 - message.length).join(" ");
5459 this.stack_.push(message + trace);
5462 goog.Promise.prototype.appendLongStack_ = function(err) {
5463 if (goog.Promise.LONG_STACK_TRACES && err && goog.isString(err.stack) && this.stack_.length) {
5464 for (var longTrace = ["Promise trace:"], promise = this;promise;promise = promise.parent_) {
5465 for (var i = this.currentStep_;0 <= i;i--) {
5466 longTrace.push(promise.stack_[i]);
5468 longTrace.push("Value: [" + (promise.state_ == goog.Promise.State_.REJECTED ? "REJECTED" : "FULFILLED") + "] <" + String(promise.result_) + ">");
5470 err.stack += "\n\n" + longTrace.join("\n");
5473 goog.Promise.prototype.removeUnhandledRejection_ = function() {
5474 if (0 < goog.Promise.UNHANDLED_REJECTION_DELAY) {
5475 for (var p = this;p && p.unhandledRejectionId_;p = p.parent_) {
5476 goog.global.clearTimeout(p.unhandledRejectionId_), p.unhandledRejectionId_ = 0;
5479 if (0 == goog.Promise.UNHANDLED_REJECTION_DELAY) {
5480 for (p = this;p && p.hadUnhandledRejection_;p = p.parent_) {
5481 p.hadUnhandledRejection_ = !1;
5486 goog.Promise.addUnhandledRejection_ = function(promise, reason) {
5487 0 < goog.Promise.UNHANDLED_REJECTION_DELAY ? promise.unhandledRejectionId_ = goog.global.setTimeout(function() {
5488 promise.appendLongStack_(reason);
5489 goog.Promise.handleRejection_.call(null, reason);
5490 }, goog.Promise.UNHANDLED_REJECTION_DELAY) : 0 == goog.Promise.UNHANDLED_REJECTION_DELAY && (promise.hadUnhandledRejection_ = !0, goog.async.run(function() {
5491 promise.hadUnhandledRejection_ && (promise.appendLongStack_(reason), goog.Promise.handleRejection_.call(null, reason));
5494 goog.Promise.handleRejection_ = goog.async.throwException;
5495 goog.Promise.setUnhandledRejectionHandler = function(handler) {
5496 goog.Promise.handleRejection_ = handler;
5498 goog.Promise.CancellationError = function(opt_message) {
5499 goog.debug.Error.call(this, opt_message);
5501 goog.inherits(goog.Promise.CancellationError, goog.debug.Error);
5502 goog.Promise.CancellationError.prototype.name = "cancel";
5503 goog.Promise.Resolver_ = function(promise, resolve, reject) {
5504 this.promise = promise;
5505 this.resolve = resolve;
5506 this.reject = reject;
5508 goog.Timer = function(opt_interval, opt_timerObject) {
5509 goog.events.EventTarget.call(this);
5510 this.interval_ = opt_interval || 1;
5511 this.timerObject_ = opt_timerObject || goog.Timer.defaultTimerObject;
5512 this.boundTick_ = goog.bind(this.tick_, this);
5513 this.last_ = goog.now();
5515 goog.inherits(goog.Timer, goog.events.EventTarget);
5516 goog.Timer.MAX_TIMEOUT_ = 2147483647;
5517 goog.Timer.INVALID_TIMEOUT_ID_ = -1;
5518 goog.Timer.prototype.enabled = !1;
5519 goog.Timer.defaultTimerObject = goog.global;
5520 goog.Timer.intervalScale = .8;
5521 goog.Timer.prototype.timer_ = null;
5522 goog.Timer.prototype.setInterval = function(interval) {
5523 this.interval_ = interval;
5524 this.timer_ && this.enabled ? (this.stop(), this.start()) : this.timer_ && this.stop();
5526 goog.Timer.prototype.tick_ = function() {
5528 var elapsed = goog.now() - this.last_;
5529 0 < elapsed && elapsed < this.interval_ * goog.Timer.intervalScale ? this.timer_ = this.timerObject_.setTimeout(this.boundTick_, this.interval_ - elapsed) : (this.timer_ && (this.timerObject_.clearTimeout(this.timer_), this.timer_ = null), this.dispatchTick(), this.enabled && (this.timer_ = this.timerObject_.setTimeout(this.boundTick_, this.interval_), this.last_ = goog.now()));
5532 goog.Timer.prototype.dispatchTick = function() {
5533 this.dispatchEvent(goog.Timer.TICK);
5535 goog.Timer.prototype.start = function() {
5537 this.timer_ || (this.timer_ = this.timerObject_.setTimeout(this.boundTick_, this.interval_), this.last_ = goog.now());
5539 goog.Timer.prototype.stop = function() {
5541 this.timer_ && (this.timerObject_.clearTimeout(this.timer_), this.timer_ = null);
5543 goog.Timer.prototype.disposeInternal = function() {
5544 goog.Timer.superClass_.disposeInternal.call(this);
5546 delete this.timerObject_;
5548 goog.Timer.TICK = "tick";
5549 goog.Timer.callOnce = function(listener, opt_delay, opt_handler) {
5550 if (goog.isFunction(listener)) {
5551 opt_handler && (listener = goog.bind(listener, opt_handler));
5553 if (listener && "function" == typeof listener.handleEvent) {
5554 listener = goog.bind(listener.handleEvent, listener);
5556 throw Error("Invalid listener argument");
5559 return opt_delay > goog.Timer.MAX_TIMEOUT_ ? goog.Timer.INVALID_TIMEOUT_ID_ : goog.Timer.defaultTimerObject.setTimeout(listener, opt_delay || 0);
5561 goog.Timer.clear = function(timerId) {
5562 goog.Timer.defaultTimerObject.clearTimeout(timerId);
5564 goog.Timer.promise = function(delay, opt_result) {
5565 var timerKey = null;
5566 return(new goog.Promise(function(resolve, reject) {
5567 timerKey = goog.Timer.callOnce(function() {
5568 resolve(opt_result);
5570 timerKey == goog.Timer.INVALID_TIMEOUT_ID_ && reject(Error("Failed to schedule timer."));
5571 })).thenCatch(function(error) {
5572 goog.Timer.clear(timerKey);
5577 goog.uri.utils = {};
5578 goog.uri.utils.CharCode_ = {AMPERSAND:38, EQUAL:61, HASH:35, QUESTION:63};
5579 goog.uri.utils.buildFromEncodedParts = function(opt_scheme, opt_userInfo, opt_domain, opt_port, opt_path, opt_queryData, opt_fragment) {
5581 opt_scheme && (out += opt_scheme + ":");
5582 opt_domain && (out += "//", opt_userInfo && (out += opt_userInfo + "@"), out += opt_domain, opt_port && (out += ":" + opt_port));
5583 opt_path && (out += opt_path);
5584 opt_queryData && (out += "?" + opt_queryData);
5585 opt_fragment && (out += "#" + opt_fragment);
5588 goog.uri.utils.splitRe_ = /^(?:([^:/?#.]+):)?(?:\/\/(?:([^/?#]*)@)?([^/#?]*?)(?::([0-9]+))?(?=[/#?]|$))?([^?#]+)?(?:\?([^#]*))?(?:#(.*))?$/;
5589 goog.uri.utils.ComponentIndex = {SCHEME:1, USER_INFO:2, DOMAIN:3, PORT:4, PATH:5, QUERY_DATA:6, FRAGMENT:7};
5590 goog.uri.utils.split = function(uri) {
5591 goog.uri.utils.phishingProtection_();
5592 return uri.match(goog.uri.utils.splitRe_);
5594 goog.uri.utils.needsPhishingProtection_ = goog.userAgent.WEBKIT;
5595 goog.uri.utils.phishingProtection_ = function() {
5596 if (goog.uri.utils.needsPhishingProtection_) {
5597 goog.uri.utils.needsPhishingProtection_ = !1;
5598 var location = goog.global.location;
5600 var href = location.href;
5602 var domain = goog.uri.utils.getDomain(href);
5603 if (domain && domain != location.hostname) {
5604 throw goog.uri.utils.needsPhishingProtection_ = !0, Error();
5610 goog.uri.utils.decodeIfPossible_ = function(uri, opt_preserveReserved) {
5611 return uri ? opt_preserveReserved ? decodeURI(uri) : decodeURIComponent(uri) : uri;
5613 goog.uri.utils.getComponentByIndex_ = function(componentIndex, uri) {
5614 return goog.uri.utils.split(uri)[componentIndex] || null;
5616 goog.uri.utils.getScheme = function(uri) {
5617 return goog.uri.utils.getComponentByIndex_(goog.uri.utils.ComponentIndex.SCHEME, uri);
5619 goog.uri.utils.getEffectiveScheme = function(uri) {
5620 var scheme = goog.uri.utils.getScheme(uri);
5621 if (!scheme && self.location) {
5622 var protocol = self.location.protocol, scheme = protocol.substr(0, protocol.length - 1)
5624 return scheme ? scheme.toLowerCase() : "";
5626 goog.uri.utils.getUserInfoEncoded = function(uri) {
5627 return goog.uri.utils.getComponentByIndex_(goog.uri.utils.ComponentIndex.USER_INFO, uri);
5629 goog.uri.utils.getUserInfo = function(uri) {
5630 return goog.uri.utils.decodeIfPossible_(goog.uri.utils.getUserInfoEncoded(uri));
5632 goog.uri.utils.getDomainEncoded = function(uri) {
5633 return goog.uri.utils.getComponentByIndex_(goog.uri.utils.ComponentIndex.DOMAIN, uri);
5635 goog.uri.utils.getDomain = function(uri) {
5636 return goog.uri.utils.decodeIfPossible_(goog.uri.utils.getDomainEncoded(uri), !0);
5638 goog.uri.utils.getPort = function(uri) {
5639 return Number(goog.uri.utils.getComponentByIndex_(goog.uri.utils.ComponentIndex.PORT, uri)) || null;
5641 goog.uri.utils.getPathEncoded = function(uri) {
5642 return goog.uri.utils.getComponentByIndex_(goog.uri.utils.ComponentIndex.PATH, uri);
5644 goog.uri.utils.getPath = function(uri) {
5645 return goog.uri.utils.decodeIfPossible_(goog.uri.utils.getPathEncoded(uri), !0);
5647 goog.uri.utils.getQueryData = function(uri) {
5648 return goog.uri.utils.getComponentByIndex_(goog.uri.utils.ComponentIndex.QUERY_DATA, uri);
5650 goog.uri.utils.getFragmentEncoded = function(uri) {
5651 var hashIndex = uri.indexOf("#");
5652 return 0 > hashIndex ? null : uri.substr(hashIndex + 1);
5654 goog.uri.utils.setFragmentEncoded = function(uri, fragment) {
5655 return goog.uri.utils.removeFragment(uri) + (fragment ? "#" + fragment : "");
5657 goog.uri.utils.getFragment = function(uri) {
5658 return goog.uri.utils.decodeIfPossible_(goog.uri.utils.getFragmentEncoded(uri));
5660 goog.uri.utils.getHost = function(uri) {
5661 var pieces = goog.uri.utils.split(uri);
5662 return goog.uri.utils.buildFromEncodedParts(pieces[goog.uri.utils.ComponentIndex.SCHEME], pieces[goog.uri.utils.ComponentIndex.USER_INFO], pieces[goog.uri.utils.ComponentIndex.DOMAIN], pieces[goog.uri.utils.ComponentIndex.PORT]);
5664 goog.uri.utils.getPathAndAfter = function(uri) {
5665 var pieces = goog.uri.utils.split(uri);
5666 return goog.uri.utils.buildFromEncodedParts(null, null, null, null, pieces[goog.uri.utils.ComponentIndex.PATH], pieces[goog.uri.utils.ComponentIndex.QUERY_DATA], pieces[goog.uri.utils.ComponentIndex.FRAGMENT]);
5668 goog.uri.utils.removeFragment = function(uri) {
5669 var hashIndex = uri.indexOf("#");
5670 return 0 > hashIndex ? uri : uri.substr(0, hashIndex);
5672 goog.uri.utils.haveSameDomain = function(uri1, uri2) {
5673 var pieces1 = goog.uri.utils.split(uri1), pieces2 = goog.uri.utils.split(uri2);
5674 return pieces1[goog.uri.utils.ComponentIndex.DOMAIN] == pieces2[goog.uri.utils.ComponentIndex.DOMAIN] && pieces1[goog.uri.utils.ComponentIndex.SCHEME] == pieces2[goog.uri.utils.ComponentIndex.SCHEME] && pieces1[goog.uri.utils.ComponentIndex.PORT] == pieces2[goog.uri.utils.ComponentIndex.PORT];
5676 goog.uri.utils.assertNoFragmentsOrQueries_ = function(uri) {
5677 if (goog.DEBUG && (0 <= uri.indexOf("#") || 0 <= uri.indexOf("?"))) {
5678 throw Error("goog.uri.utils: Fragment or query identifiers are not supported: [" + uri + "]");
5681 goog.uri.utils.appendQueryData_ = function(buffer) {
5683 var baseUri = buffer[0], hashIndex = baseUri.indexOf("#");
5684 0 <= hashIndex && (buffer.push(baseUri.substr(hashIndex)), buffer[0] = baseUri = baseUri.substr(0, hashIndex));
5685 var questionIndex = baseUri.indexOf("?");
5686 0 > questionIndex ? buffer[1] = "?" : questionIndex == baseUri.length - 1 && (buffer[1] = void 0);
5688 return buffer.join("");
5690 goog.uri.utils.appendKeyValuePairs_ = function(key, value, pairs) {
5691 if (goog.isArray(value)) {
5692 goog.asserts.assertArray(value);
5693 for (var j = 0;j < value.length;j++) {
5694 goog.uri.utils.appendKeyValuePairs_(key, String(value[j]), pairs);
5697 null != value && pairs.push("&", key, "" === value ? "" : "=", goog.string.urlEncode(value));
5700 goog.uri.utils.buildQueryDataBuffer_ = function(buffer, keysAndValues, opt_startIndex) {
5701 goog.asserts.assert(0 == Math.max(keysAndValues.length - (opt_startIndex || 0), 0) % 2, "goog.uri.utils: Key/value lists must be even in length.");
5702 for (var i = opt_startIndex || 0;i < keysAndValues.length;i += 2) {
5703 goog.uri.utils.appendKeyValuePairs_(keysAndValues[i], keysAndValues[i + 1], buffer);
5707 goog.uri.utils.buildQueryData = function(keysAndValues, opt_startIndex) {
5708 var buffer = goog.uri.utils.buildQueryDataBuffer_([], keysAndValues, opt_startIndex);
5710 return buffer.join("");
5712 goog.uri.utils.buildQueryDataBufferFromMap_ = function(buffer, map) {
5713 for (var key in map) {
5714 goog.uri.utils.appendKeyValuePairs_(key, map[key], buffer);
5718 goog.uri.utils.buildQueryDataFromMap = function(map) {
5719 var buffer = goog.uri.utils.buildQueryDataBufferFromMap_([], map);
5721 return buffer.join("");
5723 goog.uri.utils.appendParams = function(uri, var_args) {
5724 return goog.uri.utils.appendQueryData_(2 == arguments.length ? goog.uri.utils.buildQueryDataBuffer_([uri], arguments[1], 0) : goog.uri.utils.buildQueryDataBuffer_([uri], arguments, 1));
5726 goog.uri.utils.appendParamsFromMap = function(uri, map) {
5727 return goog.uri.utils.appendQueryData_(goog.uri.utils.buildQueryDataBufferFromMap_([uri], map));
5729 goog.uri.utils.appendParam = function(uri, key, opt_value) {
5730 var paramArr = [uri, "&", key];
5731 goog.isDefAndNotNull(opt_value) && paramArr.push("=", goog.string.urlEncode(opt_value));
5732 return goog.uri.utils.appendQueryData_(paramArr);
5734 goog.uri.utils.findParam_ = function(uri, startIndex, keyEncoded, hashOrEndIndex) {
5735 for (var index = startIndex, keyLength = keyEncoded.length;0 <= (index = uri.indexOf(keyEncoded, index)) && index < hashOrEndIndex;) {
5736 var precedingChar = uri.charCodeAt(index - 1);
5737 if (precedingChar == goog.uri.utils.CharCode_.AMPERSAND || precedingChar == goog.uri.utils.CharCode_.QUESTION) {
5738 var followingChar = uri.charCodeAt(index + keyLength);
5739 if (!followingChar || followingChar == goog.uri.utils.CharCode_.EQUAL || followingChar == goog.uri.utils.CharCode_.AMPERSAND || followingChar == goog.uri.utils.CharCode_.HASH) {
5743 index += keyLength + 1;
5747 goog.uri.utils.hashOrEndRe_ = /#|$/;
5748 goog.uri.utils.hasParam = function(uri, keyEncoded) {
5749 return 0 <= goog.uri.utils.findParam_(uri, 0, keyEncoded, uri.search(goog.uri.utils.hashOrEndRe_));
5751 goog.uri.utils.getParamValue = function(uri, keyEncoded) {
5752 var hashOrEndIndex = uri.search(goog.uri.utils.hashOrEndRe_), foundIndex = goog.uri.utils.findParam_(uri, 0, keyEncoded, hashOrEndIndex);
5753 if (0 > foundIndex) {
5756 var endPosition = uri.indexOf("&", foundIndex);
5757 if (0 > endPosition || endPosition > hashOrEndIndex) {
5758 endPosition = hashOrEndIndex;
5760 foundIndex += keyEncoded.length + 1;
5761 return goog.string.urlDecode(uri.substr(foundIndex, endPosition - foundIndex));
5763 goog.uri.utils.getParamValues = function(uri, keyEncoded) {
5764 for (var hashOrEndIndex = uri.search(goog.uri.utils.hashOrEndRe_), position = 0, foundIndex, result = [];0 <= (foundIndex = goog.uri.utils.findParam_(uri, position, keyEncoded, hashOrEndIndex));) {
5765 position = uri.indexOf("&", foundIndex);
5766 if (0 > position || position > hashOrEndIndex) {
5767 position = hashOrEndIndex;
5769 foundIndex += keyEncoded.length + 1;
5770 result.push(goog.string.urlDecode(uri.substr(foundIndex, position - foundIndex)));
5774 goog.uri.utils.trailingQueryPunctuationRe_ = /[?&]($|#)/;
5775 goog.uri.utils.removeParam = function(uri, keyEncoded) {
5776 for (var hashOrEndIndex = uri.search(goog.uri.utils.hashOrEndRe_), position = 0, foundIndex, buffer = [];0 <= (foundIndex = goog.uri.utils.findParam_(uri, position, keyEncoded, hashOrEndIndex));) {
5777 buffer.push(uri.substring(position, foundIndex)), position = Math.min(uri.indexOf("&", foundIndex) + 1 || hashOrEndIndex, hashOrEndIndex);
5779 buffer.push(uri.substr(position));
5780 return buffer.join("").replace(goog.uri.utils.trailingQueryPunctuationRe_, "$1");
5782 goog.uri.utils.setParam = function(uri, keyEncoded, value) {
5783 return goog.uri.utils.appendParam(goog.uri.utils.removeParam(uri, keyEncoded), keyEncoded, value);
5785 goog.uri.utils.appendPath = function(baseUri, path) {
5786 goog.uri.utils.assertNoFragmentsOrQueries_(baseUri);
5787 goog.string.endsWith(baseUri, "/") && (baseUri = baseUri.substr(0, baseUri.length - 1));
5788 goog.string.startsWith(path, "/") && (path = path.substr(1));
5789 return goog.string.buildString(baseUri, "/", path);
5791 goog.uri.utils.setPath = function(uri, path) {
5792 goog.string.startsWith(path, "/") || (path = "/" + path);
5793 var parts = goog.uri.utils.split(uri);
5794 return goog.uri.utils.buildFromEncodedParts(parts[goog.uri.utils.ComponentIndex.SCHEME], parts[goog.uri.utils.ComponentIndex.USER_INFO], parts[goog.uri.utils.ComponentIndex.DOMAIN], parts[goog.uri.utils.ComponentIndex.PORT], path, parts[goog.uri.utils.ComponentIndex.QUERY_DATA], parts[goog.uri.utils.ComponentIndex.FRAGMENT]);
5796 goog.uri.utils.StandardQueryParam = {RANDOM:"zx"};
5797 goog.uri.utils.makeUnique = function(uri) {
5798 return goog.uri.utils.setParam(uri, goog.uri.utils.StandardQueryParam.RANDOM, goog.string.getRandomString());
5801 goog.net.ErrorCode = {NO_ERROR:0, ACCESS_DENIED:1, FILE_NOT_FOUND:2, FF_SILENT_ERROR:3, CUSTOM_ERROR:4, EXCEPTION:5, HTTP_ERROR:6, ABORT:7, TIMEOUT:8, OFFLINE:9};
5802 goog.net.ErrorCode.getDebugMessage = function(errorCode) {
5804 case goog.net.ErrorCode.NO_ERROR:
5806 case goog.net.ErrorCode.ACCESS_DENIED:
5807 return "Access denied to content document";
5808 case goog.net.ErrorCode.FILE_NOT_FOUND:
5809 return "File not found";
5810 case goog.net.ErrorCode.FF_SILENT_ERROR:
5811 return "Firefox silently errored";
5812 case goog.net.ErrorCode.CUSTOM_ERROR:
5813 return "Application custom error";
5814 case goog.net.ErrorCode.EXCEPTION:
5815 return "An exception occurred";
5816 case goog.net.ErrorCode.HTTP_ERROR:
5817 return "Http response at 400 or 500 level";
5818 case goog.net.ErrorCode.ABORT:
5819 return "Request was aborted";
5820 case goog.net.ErrorCode.TIMEOUT:
5821 return "Request timed out";
5822 case goog.net.ErrorCode.OFFLINE:
5823 return "The resource is not available offline";
5825 return "Unrecognized error code";
5828 goog.net.EventType = {COMPLETE:"complete", SUCCESS:"success", ERROR:"error", ABORT:"abort", READY:"ready", READY_STATE_CHANGE:"readystatechange", TIMEOUT:"timeout", INCREMENTAL_DATA:"incrementaldata", PROGRESS:"progress"};
5829 goog.net.HttpStatus = {CONTINUE:100, SWITCHING_PROTOCOLS:101, OK:200, CREATED:201, ACCEPTED:202, NON_AUTHORITATIVE_INFORMATION:203, NO_CONTENT:204, RESET_CONTENT:205, PARTIAL_CONTENT:206, MULTIPLE_CHOICES:300, MOVED_PERMANENTLY:301, FOUND:302, SEE_OTHER:303, NOT_MODIFIED:304, USE_PROXY:305, TEMPORARY_REDIRECT:307, BAD_REQUEST:400, UNAUTHORIZED:401, PAYMENT_REQUIRED:402, FORBIDDEN:403, NOT_FOUND:404, METHOD_NOT_ALLOWED:405, NOT_ACCEPTABLE:406, PROXY_AUTHENTICATION_REQUIRED:407, REQUEST_TIMEOUT:408,
5830 CONFLICT:409, GONE:410, LENGTH_REQUIRED:411, PRECONDITION_FAILED:412, REQUEST_ENTITY_TOO_LARGE:413, REQUEST_URI_TOO_LONG:414, UNSUPPORTED_MEDIA_TYPE:415, REQUEST_RANGE_NOT_SATISFIABLE:416, EXPECTATION_FAILED:417, PRECONDITION_REQUIRED:428, TOO_MANY_REQUESTS:429, REQUEST_HEADER_FIELDS_TOO_LARGE:431, INTERNAL_SERVER_ERROR:500, NOT_IMPLEMENTED:501, BAD_GATEWAY:502, SERVICE_UNAVAILABLE:503, GATEWAY_TIMEOUT:504, HTTP_VERSION_NOT_SUPPORTED:505, NETWORK_AUTHENTICATION_REQUIRED:511, QUIRK_IE_NO_CONTENT:1223};
5831 goog.net.HttpStatus.isSuccess = function(status) {
5833 case goog.net.HttpStatus.OK:
5835 case goog.net.HttpStatus.CREATED:
5837 case goog.net.HttpStatus.ACCEPTED:
5839 case goog.net.HttpStatus.NO_CONTENT:
5841 case goog.net.HttpStatus.PARTIAL_CONTENT:
5843 case goog.net.HttpStatus.NOT_MODIFIED:
5845 case goog.net.HttpStatus.QUIRK_IE_NO_CONTENT:
5851 goog.net.XhrLike = function() {
5853 goog.net.XhrLike.prototype.open = function() {
5855 goog.net.XhrLike.prototype.send = function() {
5857 goog.net.XhrLike.prototype.abort = function() {
5859 goog.net.XhrLike.prototype.setRequestHeader = function() {
5861 goog.net.XhrLike.prototype.getResponseHeader = function() {
5863 goog.net.XhrLike.prototype.getAllResponseHeaders = function() {
5865 goog.net.XmlHttpFactory = function() {
5867 goog.net.XmlHttpFactory.prototype.cachedOptions_ = null;
5868 goog.net.XmlHttpFactory.prototype.getOptions = function() {
5869 return this.cachedOptions_ || (this.cachedOptions_ = this.internalGetOptions());
5871 goog.net.WrapperXmlHttpFactory = function(xhrFactory, optionsFactory) {
5872 this.xhrFactory_ = xhrFactory;
5873 this.optionsFactory_ = optionsFactory;
5875 goog.inherits(goog.net.WrapperXmlHttpFactory, goog.net.XmlHttpFactory);
5876 goog.net.WrapperXmlHttpFactory.prototype.createInstance = function() {
5877 return this.xhrFactory_();
5879 goog.net.WrapperXmlHttpFactory.prototype.getOptions = function() {
5880 return this.optionsFactory_();
5882 goog.net.XmlHttp = function() {
5883 return goog.net.XmlHttp.factory_.createInstance();
5885 goog.net.XmlHttp.ASSUME_NATIVE_XHR = !1;
5886 goog.net.XmlHttpDefines = {};
5887 goog.net.XmlHttpDefines.ASSUME_NATIVE_XHR = !1;
5888 goog.net.XmlHttp.getOptions = function() {
5889 return goog.net.XmlHttp.factory_.getOptions();
5891 goog.net.XmlHttp.OptionType = {USE_NULL_FUNCTION:0, LOCAL_REQUEST_ERROR:1};
5892 goog.net.XmlHttp.ReadyState = {UNINITIALIZED:0, LOADING:1, LOADED:2, INTERACTIVE:3, COMPLETE:4};
5893 goog.net.XmlHttp.setFactory = function(factory, optionsFactory) {
5894 goog.net.XmlHttp.setGlobalFactory(new goog.net.WrapperXmlHttpFactory(goog.asserts.assert(factory), goog.asserts.assert(optionsFactory)));
5896 goog.net.XmlHttp.setGlobalFactory = function(factory) {
5897 goog.net.XmlHttp.factory_ = factory;
5899 goog.net.DefaultXmlHttpFactory = function() {
5901 goog.inherits(goog.net.DefaultXmlHttpFactory, goog.net.XmlHttpFactory);
5902 goog.net.DefaultXmlHttpFactory.prototype.createInstance = function() {
5903 var progId = this.getProgId_();
5904 return progId ? new ActiveXObject(progId) : new XMLHttpRequest;
5906 goog.net.DefaultXmlHttpFactory.prototype.internalGetOptions = function() {
5907 var progId = this.getProgId_(), options = {};
5908 progId && (options[goog.net.XmlHttp.OptionType.USE_NULL_FUNCTION] = !0, options[goog.net.XmlHttp.OptionType.LOCAL_REQUEST_ERROR] = !0);
5911 goog.net.DefaultXmlHttpFactory.prototype.getProgId_ = function() {
5912 if (goog.net.XmlHttp.ASSUME_NATIVE_XHR || goog.net.XmlHttpDefines.ASSUME_NATIVE_XHR) {
5915 if (!this.ieProgId_ && "undefined" == typeof XMLHttpRequest && "undefined" != typeof ActiveXObject) {
5916 for (var ACTIVE_X_IDENTS = ["MSXML2.XMLHTTP.6.0", "MSXML2.XMLHTTP.3.0", "MSXML2.XMLHTTP", "Microsoft.XMLHTTP"], i = 0;i < ACTIVE_X_IDENTS.length;i++) {
5917 var candidate = ACTIVE_X_IDENTS[i];
5919 return new ActiveXObject(candidate), this.ieProgId_ = candidate;
5923 throw Error("Could not create ActiveXObject. ActiveX might be disabled, or MSXML might not be installed");
5925 return this.ieProgId_;
5927 goog.net.XmlHttp.setGlobalFactory(new goog.net.DefaultXmlHttpFactory);
5928 goog.net.XhrIo = function(opt_xmlHttpFactory) {
5929 goog.events.EventTarget.call(this);
5930 this.headers = new goog.structs.Map;
5931 this.xmlHttpFactory_ = opt_xmlHttpFactory || null;
5933 this.xhrOptions_ = this.xhr_ = null;
5934 this.lastError_ = this.lastMethod_ = this.lastUri_ = "";
5935 this.inAbort_ = this.inOpen_ = this.inSend_ = this.errorDispatched_ = !1;
5936 this.timeoutInterval_ = 0;
5937 this.timeoutId_ = null;
5938 this.responseType_ = goog.net.XhrIo.ResponseType.DEFAULT;
5939 this.useXhr2Timeout_ = this.withCredentials_ = !1;
5941 goog.inherits(goog.net.XhrIo, goog.events.EventTarget);
5942 goog.net.XhrIo.ResponseType = {DEFAULT:"", TEXT:"text", DOCUMENT:"document", BLOB:"blob", ARRAY_BUFFER:"arraybuffer"};
5943 goog.net.XhrIo.prototype.logger_ = goog.log.getLogger("goog.net.XhrIo");
5944 goog.net.XhrIo.CONTENT_TYPE_HEADER = "Content-Type";
5945 goog.net.XhrIo.HTTP_SCHEME_PATTERN = /^https?$/i;
5946 goog.net.XhrIo.METHODS_WITH_FORM_DATA = ["POST", "PUT"];
5947 goog.net.XhrIo.FORM_CONTENT_TYPE = "application/x-www-form-urlencoded;charset=utf-8";
5948 goog.net.XhrIo.XHR2_TIMEOUT_ = "timeout";
5949 goog.net.XhrIo.XHR2_ON_TIMEOUT_ = "ontimeout";
5950 goog.net.XhrIo.sendInstances_ = [];
5951 goog.net.XhrIo.send = function(url, opt_callback, opt_method, opt_content, opt_headers, opt_timeoutInterval, opt_withCredentials) {
5952 var x = new goog.net.XhrIo;
5953 goog.net.XhrIo.sendInstances_.push(x);
5954 opt_callback && x.listen(goog.net.EventType.COMPLETE, opt_callback);
5955 x.listenOnce(goog.net.EventType.READY, x.cleanupSend_);
5956 opt_timeoutInterval && x.setTimeoutInterval(opt_timeoutInterval);
5957 opt_withCredentials && x.setWithCredentials(opt_withCredentials);
5958 x.send(url, opt_method, opt_content, opt_headers);
5961 goog.net.XhrIo.cleanup = function() {
5962 for (var instances = goog.net.XhrIo.sendInstances_;instances.length;) {
5963 instances.pop().dispose();
5966 goog.net.XhrIo.protectEntryPoints = function(errorHandler) {
5967 goog.net.XhrIo.prototype.onReadyStateChangeEntryPoint_ = errorHandler.protectEntryPoint(goog.net.XhrIo.prototype.onReadyStateChangeEntryPoint_);
5969 goog.net.XhrIo.prototype.cleanupSend_ = function() {
5971 goog.array.remove(goog.net.XhrIo.sendInstances_, this);
5973 goog.net.XhrIo.prototype.setTimeoutInterval = function(ms) {
5974 this.timeoutInterval_ = Math.max(0, ms);
5976 goog.net.XhrIo.prototype.setWithCredentials = function(withCredentials) {
5977 this.withCredentials_ = withCredentials;
5979 goog.net.XhrIo.prototype.send = function(url, opt_method, opt_content, opt_headers) {
5981 throw Error("[goog.net.XhrIo] Object is active with another request=" + this.lastUri_ + "; newUri=" + url);
5983 var method = opt_method ? opt_method.toUpperCase() : "GET";
5984 this.lastUri_ = url;
5985 this.lastError_ = "";
5986 this.lastMethod_ = method;
5987 this.errorDispatched_ = !1;
5989 this.xhr_ = this.createXhr();
5990 this.xhrOptions_ = this.xmlHttpFactory_ ? this.xmlHttpFactory_.getOptions() : goog.net.XmlHttp.getOptions();
5991 this.xhr_.onreadystatechange = goog.bind(this.onReadyStateChange_, this);
5993 goog.log.fine(this.logger_, this.formatMsg_("Opening Xhr")), this.inOpen_ = !0, this.xhr_.open(method, String(url), !0), this.inOpen_ = !1;
5995 goog.log.fine(this.logger_, this.formatMsg_("Error opening Xhr: " + err.message));
5996 this.error_(goog.net.ErrorCode.EXCEPTION, err);
5999 var content = opt_content || "", headers = this.headers.clone();
6000 opt_headers && goog.structs.forEach(opt_headers, function(value, key) {
6001 headers.set(key, value);
6003 var contentTypeKey = goog.array.find(headers.getKeys(), goog.net.XhrIo.isContentTypeHeader_), contentIsFormData = goog.global.FormData && content instanceof goog.global.FormData;
6004 !goog.array.contains(goog.net.XhrIo.METHODS_WITH_FORM_DATA, method) || contentTypeKey || contentIsFormData || headers.set(goog.net.XhrIo.CONTENT_TYPE_HEADER, goog.net.XhrIo.FORM_CONTENT_TYPE);
6005 headers.forEach(function(value, key) {
6006 this.xhr_.setRequestHeader(key, value);
6008 this.responseType_ && (this.xhr_.responseType = this.responseType_);
6009 goog.object.containsKey(this.xhr_, "withCredentials") && (this.xhr_.withCredentials = this.withCredentials_);
6011 this.cleanUpTimeoutTimer_(), 0 < this.timeoutInterval_ && (this.useXhr2Timeout_ = goog.net.XhrIo.shouldUseXhr2Timeout_(this.xhr_), goog.log.fine(this.logger_, this.formatMsg_("Will abort after " + this.timeoutInterval_ + "ms if incomplete, xhr2 " + this.useXhr2Timeout_)), this.useXhr2Timeout_ ? (this.xhr_[goog.net.XhrIo.XHR2_TIMEOUT_] = this.timeoutInterval_, this.xhr_[goog.net.XhrIo.XHR2_ON_TIMEOUT_] = goog.bind(this.timeout_, this)) : this.timeoutId_ = goog.Timer.callOnce(this.timeout_, this.timeoutInterval_,
6012 this)), goog.log.fine(this.logger_, this.formatMsg_("Sending request")), this.inSend_ = !0, this.xhr_.send(content), this.inSend_ = !1;
6014 goog.log.fine(this.logger_, this.formatMsg_("Send error: " + err$$0.message)), this.error_(goog.net.ErrorCode.EXCEPTION, err$$0);
6017 goog.net.XhrIo.shouldUseXhr2Timeout_ = function(xhr) {
6018 return goog.userAgent.IE && goog.userAgent.isVersionOrHigher(9) && goog.isNumber(xhr[goog.net.XhrIo.XHR2_TIMEOUT_]) && goog.isDef(xhr[goog.net.XhrIo.XHR2_ON_TIMEOUT_]);
6020 goog.net.XhrIo.isContentTypeHeader_ = function(header) {
6021 return goog.string.caseInsensitiveEquals(goog.net.XhrIo.CONTENT_TYPE_HEADER, header);
6023 goog.net.XhrIo.prototype.createXhr = function() {
6024 return this.xmlHttpFactory_ ? this.xmlHttpFactory_.createInstance() : goog.net.XmlHttp();
6026 goog.net.XhrIo.prototype.timeout_ = function() {
6027 "undefined" != typeof goog && this.xhr_ && (this.lastError_ = "Timed out after " + this.timeoutInterval_ + "ms, aborting", goog.log.fine(this.logger_, this.formatMsg_(this.lastError_)), this.dispatchEvent(goog.net.EventType.TIMEOUT), this.abort(goog.net.ErrorCode.TIMEOUT));
6029 goog.net.XhrIo.prototype.error_ = function(errorCode, err) {
6031 this.xhr_ && (this.inAbort_ = !0, this.xhr_.abort(), this.inAbort_ = !1);
6032 this.lastError_ = err;
6033 this.dispatchErrors_();
6036 goog.net.XhrIo.prototype.dispatchErrors_ = function() {
6037 this.errorDispatched_ || (this.errorDispatched_ = !0, this.dispatchEvent(goog.net.EventType.COMPLETE), this.dispatchEvent(goog.net.EventType.ERROR));
6039 goog.net.XhrIo.prototype.abort = function() {
6040 this.xhr_ && this.active_ && (goog.log.fine(this.logger_, this.formatMsg_("Aborting")), this.active_ = !1, this.inAbort_ = !0, this.xhr_.abort(), this.inAbort_ = !1, this.dispatchEvent(goog.net.EventType.COMPLETE), this.dispatchEvent(goog.net.EventType.ABORT), this.cleanUpXhr_());
6042 goog.net.XhrIo.prototype.disposeInternal = function() {
6043 this.xhr_ && (this.active_ && (this.active_ = !1, this.inAbort_ = !0, this.xhr_.abort(), this.inAbort_ = !1), this.cleanUpXhr_(!0));
6044 goog.net.XhrIo.superClass_.disposeInternal.call(this);
6046 goog.net.XhrIo.prototype.onReadyStateChange_ = function() {
6047 if (!this.isDisposed()) {
6048 if (this.inOpen_ || this.inSend_ || this.inAbort_) {
6049 this.onReadyStateChangeHelper_();
6051 this.onReadyStateChangeEntryPoint_();
6055 goog.net.XhrIo.prototype.onReadyStateChangeEntryPoint_ = function() {
6056 this.onReadyStateChangeHelper_();
6058 goog.net.XhrIo.prototype.onReadyStateChangeHelper_ = function() {
6059 if (this.active_ && "undefined" != typeof goog) {
6060 if (this.xhrOptions_[goog.net.XmlHttp.OptionType.LOCAL_REQUEST_ERROR] && this.getReadyState() == goog.net.XmlHttp.ReadyState.COMPLETE && 2 == this.getStatus()) {
6061 goog.log.fine(this.logger_, this.formatMsg_("Local request error detected and ignored"));
6063 if (this.inSend_ && this.getReadyState() == goog.net.XmlHttp.ReadyState.COMPLETE) {
6064 goog.Timer.callOnce(this.onReadyStateChange_, 0, this);
6066 if (this.dispatchEvent(goog.net.EventType.READY_STATE_CHANGE), this.isComplete()) {
6067 goog.log.fine(this.logger_, this.formatMsg_("Request complete"));
6070 this.isSuccess() ? (this.dispatchEvent(goog.net.EventType.COMPLETE), this.dispatchEvent(goog.net.EventType.SUCCESS)) : (this.lastError_ = this.getStatusText() + " [" + this.getStatus() + "]", this.dispatchErrors_());
6079 goog.net.XhrIo.prototype.cleanUpXhr_ = function(opt_fromDispose) {
6081 this.cleanUpTimeoutTimer_();
6082 var xhr = this.xhr_, clearedOnReadyStateChange = this.xhrOptions_[goog.net.XmlHttp.OptionType.USE_NULL_FUNCTION] ? goog.nullFunction : null;
6083 this.xhrOptions_ = this.xhr_ = null;
6084 opt_fromDispose || this.dispatchEvent(goog.net.EventType.READY);
6086 xhr.onreadystatechange = clearedOnReadyStateChange;
6088 goog.log.error(this.logger_, "Problem encountered resetting onreadystatechange: " + e.message);
6092 goog.net.XhrIo.prototype.cleanUpTimeoutTimer_ = function() {
6093 this.xhr_ && this.useXhr2Timeout_ && (this.xhr_[goog.net.XhrIo.XHR2_ON_TIMEOUT_] = null);
6094 goog.isNumber(this.timeoutId_) && (goog.Timer.clear(this.timeoutId_), this.timeoutId_ = null);
6096 goog.net.XhrIo.prototype.isComplete = function() {
6097 return this.getReadyState() == goog.net.XmlHttp.ReadyState.COMPLETE;
6099 goog.net.XhrIo.prototype.isSuccess = function() {
6100 var status = this.getStatus();
6101 return goog.net.HttpStatus.isSuccess(status) || 0 === status && !this.isLastUriEffectiveSchemeHttp_();
6103 goog.net.XhrIo.prototype.isLastUriEffectiveSchemeHttp_ = function() {
6104 var scheme = goog.uri.utils.getEffectiveScheme(String(this.lastUri_));
6105 return goog.net.XhrIo.HTTP_SCHEME_PATTERN.test(scheme);
6107 goog.net.XhrIo.prototype.getReadyState = function() {
6108 return this.xhr_ ? this.xhr_.readyState : goog.net.XmlHttp.ReadyState.UNINITIALIZED;
6110 goog.net.XhrIo.prototype.getStatus = function() {
6112 return this.getReadyState() > goog.net.XmlHttp.ReadyState.LOADED ? this.xhr_.status : -1;
6117 goog.net.XhrIo.prototype.getStatusText = function() {
6119 return this.getReadyState() > goog.net.XmlHttp.ReadyState.LOADED ? this.xhr_.statusText : "";
6121 return goog.log.fine(this.logger_, "Can not get status: " + e.message), "";
6124 goog.net.XhrIo.prototype.getResponseText = function() {
6126 return this.xhr_ ? this.xhr_.responseText : "";
6128 return goog.log.fine(this.logger_, "Can not get responseText: " + e.message), "";
6131 goog.net.XhrIo.prototype.getResponseHeader = function(key) {
6132 return this.xhr_ && this.isComplete() ? this.xhr_.getResponseHeader(key) : void 0;
6134 goog.net.XhrIo.prototype.getAllResponseHeaders = function() {
6135 return this.xhr_ && this.isComplete() ? this.xhr_.getAllResponseHeaders() : "";
6137 goog.net.XhrIo.prototype.formatMsg_ = function(msg) {
6138 return msg + " [" + this.lastMethod_ + " " + this.lastUri_ + " " + this.getStatus() + "]";
6140 goog.debug.entryPointRegistry.register(function(transformer) {
6141 goog.net.XhrIo.prototype.onReadyStateChangeEntryPoint_ = transformer(goog.net.XhrIo.prototype.onReadyStateChangeEntryPoint_);
6143 goog.Uri = function(opt_uri, opt_ignoreCase) {
6145 opt_uri instanceof goog.Uri ? (this.ignoreCase_ = goog.isDef(opt_ignoreCase) ? opt_ignoreCase : opt_uri.getIgnoreCase(), this.setScheme(opt_uri.getScheme()), this.setUserInfo(opt_uri.getUserInfo()), this.setDomain(opt_uri.getDomain()), this.setPort(opt_uri.getPort()), this.setPath(opt_uri.getPath()), this.setQueryData(opt_uri.getQueryData().clone()), this.setFragment(opt_uri.getFragment())) : opt_uri && (m = goog.uri.utils.split(String(opt_uri))) ? (this.ignoreCase_ = !!opt_ignoreCase, this.setScheme(m[goog.uri.utils.ComponentIndex.SCHEME] ||
6146 "", !0), this.setUserInfo(m[goog.uri.utils.ComponentIndex.USER_INFO] || "", !0), this.setDomain(m[goog.uri.utils.ComponentIndex.DOMAIN] || "", !0), this.setPort(m[goog.uri.utils.ComponentIndex.PORT]), this.setPath(m[goog.uri.utils.ComponentIndex.PATH] || "", !0), this.setQueryData(m[goog.uri.utils.ComponentIndex.QUERY_DATA] || "", !0), this.setFragment(m[goog.uri.utils.ComponentIndex.FRAGMENT] || "", !0)) : (this.ignoreCase_ = !!opt_ignoreCase, this.queryData_ = new goog.Uri.QueryData(null, null,
6149 goog.Uri.preserveParameterTypesCompatibilityFlag = !1;
6150 goog.Uri.RANDOM_PARAM = goog.uri.utils.StandardQueryParam.RANDOM;
6151 goog.Uri.prototype.scheme_ = "";
6152 goog.Uri.prototype.userInfo_ = "";
6153 goog.Uri.prototype.domain_ = "";
6154 goog.Uri.prototype.port_ = null;
6155 goog.Uri.prototype.path_ = "";
6156 goog.Uri.prototype.fragment_ = "";
6157 goog.Uri.prototype.isReadOnly_ = !1;
6158 goog.Uri.prototype.ignoreCase_ = !1;
6159 goog.Uri.prototype.toString = function() {
6160 var out = [], scheme = this.getScheme();
6161 scheme && out.push(goog.Uri.encodeSpecialChars_(scheme, goog.Uri.reDisallowedInSchemeOrUserInfo_, !0), ":");
6162 var domain = this.getDomain();
6165 var userInfo = this.getUserInfo();
6166 userInfo && out.push(goog.Uri.encodeSpecialChars_(userInfo, goog.Uri.reDisallowedInSchemeOrUserInfo_, !0), "@");
6167 out.push(goog.Uri.removeDoubleEncoding_(goog.string.urlEncode(domain)));
6168 var port = this.getPort();
6169 null != port && out.push(":", String(port));
6171 var path = this.getPath();
6172 path && (this.hasDomain() && "/" != path.charAt(0) && out.push("/"), out.push(goog.Uri.encodeSpecialChars_(path, "/" == path.charAt(0) ? goog.Uri.reDisallowedInAbsolutePath_ : goog.Uri.reDisallowedInRelativePath_, !0)));
6173 var query = this.getEncodedQuery();
6174 query && out.push("?", query);
6175 var fragment = this.getFragment();
6176 fragment && out.push("#", goog.Uri.encodeSpecialChars_(fragment, goog.Uri.reDisallowedInFragment_));
6177 return out.join("");
6179 goog.Uri.prototype.resolve = function(relativeUri) {
6180 var absoluteUri = this.clone(), overridden = relativeUri.hasScheme();
6181 overridden ? absoluteUri.setScheme(relativeUri.getScheme()) : overridden = relativeUri.hasUserInfo();
6182 overridden ? absoluteUri.setUserInfo(relativeUri.getUserInfo()) : overridden = relativeUri.hasDomain();
6183 overridden ? absoluteUri.setDomain(relativeUri.getDomain()) : overridden = relativeUri.hasPort();
6184 var path = relativeUri.getPath();
6186 absoluteUri.setPort(relativeUri.getPort());
6188 if (overridden = relativeUri.hasPath()) {
6189 if ("/" != path.charAt(0)) {
6190 if (this.hasDomain() && !this.hasPath()) {
6193 var lastSlashIndex = absoluteUri.getPath().lastIndexOf("/");
6194 -1 != lastSlashIndex && (path = absoluteUri.getPath().substr(0, lastSlashIndex + 1) + path);
6197 path = goog.Uri.removeDotSegments(path);
6200 overridden ? absoluteUri.setPath(path) : overridden = relativeUri.hasQuery();
6201 overridden ? absoluteUri.setQueryData(relativeUri.getDecodedQuery()) : overridden = relativeUri.hasFragment();
6202 overridden && absoluteUri.setFragment(relativeUri.getFragment());
6205 goog.Uri.prototype.clone = function() {
6206 return new goog.Uri(this);
6208 goog.Uri.prototype.getScheme = function() {
6209 return this.scheme_;
6211 goog.Uri.prototype.setScheme = function(newScheme, opt_decode) {
6212 this.enforceReadOnly();
6213 if (this.scheme_ = opt_decode ? goog.Uri.decodeOrEmpty_(newScheme, !0) : newScheme) {
6214 this.scheme_ = this.scheme_.replace(/:$/, "");
6218 goog.Uri.prototype.hasScheme = function() {
6219 return!!this.scheme_;
6221 goog.Uri.prototype.getUserInfo = function() {
6222 return this.userInfo_;
6224 goog.Uri.prototype.setUserInfo = function(newUserInfo, opt_decode) {
6225 this.enforceReadOnly();
6226 this.userInfo_ = opt_decode ? goog.Uri.decodeOrEmpty_(newUserInfo) : newUserInfo;
6229 goog.Uri.prototype.hasUserInfo = function() {
6230 return!!this.userInfo_;
6232 goog.Uri.prototype.getDomain = function() {
6233 return this.domain_;
6235 goog.Uri.prototype.setDomain = function(newDomain, opt_decode) {
6236 this.enforceReadOnly();
6237 this.domain_ = opt_decode ? goog.Uri.decodeOrEmpty_(newDomain, !0) : newDomain;
6240 goog.Uri.prototype.hasDomain = function() {
6241 return!!this.domain_;
6243 goog.Uri.prototype.getPort = function() {
6246 goog.Uri.prototype.setPort = function(newPort) {
6247 this.enforceReadOnly();
6249 newPort = Number(newPort);
6250 if (isNaN(newPort) || 0 > newPort) {
6251 throw Error("Bad port number " + newPort);
6253 this.port_ = newPort;
6259 goog.Uri.prototype.hasPort = function() {
6260 return null != this.port_;
6262 goog.Uri.prototype.getPath = function() {
6265 goog.Uri.prototype.setPath = function(newPath, opt_decode) {
6266 this.enforceReadOnly();
6267 this.path_ = opt_decode ? goog.Uri.decodeOrEmpty_(newPath, !0) : newPath;
6270 goog.Uri.prototype.hasPath = function() {
6273 goog.Uri.prototype.hasQuery = function() {
6274 return "" !== this.queryData_.toString();
6276 goog.Uri.prototype.setQueryData = function(queryData, opt_decode) {
6277 this.enforceReadOnly();
6278 queryData instanceof goog.Uri.QueryData ? (this.queryData_ = queryData, this.queryData_.setIgnoreCase(this.ignoreCase_)) : (opt_decode || (queryData = goog.Uri.encodeSpecialChars_(queryData, goog.Uri.reDisallowedInQuery_)), this.queryData_ = new goog.Uri.QueryData(queryData, null, this.ignoreCase_));
6281 goog.Uri.prototype.getEncodedQuery = function() {
6282 return this.queryData_.toString();
6284 goog.Uri.prototype.getDecodedQuery = function() {
6285 return this.queryData_.toDecodedString();
6287 goog.Uri.prototype.getQueryData = function() {
6288 return this.queryData_;
6290 goog.Uri.prototype.setParameterValue = function(key, value) {
6291 this.enforceReadOnly();
6292 this.queryData_.set(key, value);
6295 goog.Uri.prototype.getFragment = function() {
6296 return this.fragment_;
6298 goog.Uri.prototype.setFragment = function(newFragment, opt_decode) {
6299 this.enforceReadOnly();
6300 this.fragment_ = opt_decode ? goog.Uri.decodeOrEmpty_(newFragment) : newFragment;
6303 goog.Uri.prototype.hasFragment = function() {
6304 return!!this.fragment_;
6306 goog.Uri.prototype.makeUnique = function() {
6307 this.enforceReadOnly();
6308 this.setParameterValue(goog.Uri.RANDOM_PARAM, goog.string.getRandomString());
6311 goog.Uri.prototype.enforceReadOnly = function() {
6312 if (this.isReadOnly_) {
6313 throw Error("Tried to modify a read-only Uri");
6316 goog.Uri.prototype.setIgnoreCase = function(ignoreCase) {
6317 this.ignoreCase_ = ignoreCase;
6318 this.queryData_ && this.queryData_.setIgnoreCase(ignoreCase);
6321 goog.Uri.prototype.getIgnoreCase = function() {
6322 return this.ignoreCase_;
6324 goog.Uri.parse = function(uri, opt_ignoreCase) {
6325 return uri instanceof goog.Uri ? uri.clone() : new goog.Uri(uri, opt_ignoreCase);
6327 goog.Uri.create = function(opt_scheme, opt_userInfo, opt_domain, opt_port, opt_path, opt_query, opt_fragment, opt_ignoreCase) {
6328 var uri = new goog.Uri(null, opt_ignoreCase);
6329 opt_scheme && uri.setScheme(opt_scheme);
6330 opt_userInfo && uri.setUserInfo(opt_userInfo);
6331 opt_domain && uri.setDomain(opt_domain);
6332 opt_port && uri.setPort(opt_port);
6333 opt_path && uri.setPath(opt_path);
6334 opt_query && uri.setQueryData(opt_query);
6335 opt_fragment && uri.setFragment(opt_fragment);
6338 goog.Uri.resolve = function(base, rel) {
6339 base instanceof goog.Uri || (base = goog.Uri.parse(base));
6340 rel instanceof goog.Uri || (rel = goog.Uri.parse(rel));
6341 return base.resolve(rel);
6343 goog.Uri.removeDotSegments = function(path) {
6344 if (".." == path || "." == path) {
6347 if (goog.string.contains(path, "./") || goog.string.contains(path, "/.")) {
6348 for (var leadingSlash = goog.string.startsWith(path, "/"), segments = path.split("/"), out = [], pos = 0;pos < segments.length;) {
6349 var segment = segments[pos++];
6350 "." == segment ? leadingSlash && pos == segments.length && out.push("") : ".." == segment ? ((1 < out.length || 1 == out.length && "" != out[0]) && out.pop(), leadingSlash && pos == segments.length && out.push("")) : (out.push(segment), leadingSlash = !0);
6352 return out.join("/");
6356 goog.Uri.decodeOrEmpty_ = function(val, opt_preserveReserved) {
6357 return val ? opt_preserveReserved ? decodeURI(val) : decodeURIComponent(val) : "";
6359 goog.Uri.encodeSpecialChars_ = function(unescapedPart, extra, opt_removeDoubleEncoding) {
6360 if (goog.isString(unescapedPart)) {
6361 var encoded = encodeURI(unescapedPart).replace(extra, goog.Uri.encodeChar_);
6362 opt_removeDoubleEncoding && (encoded = goog.Uri.removeDoubleEncoding_(encoded));
6367 goog.Uri.encodeChar_ = function(ch) {
6368 var n = ch.charCodeAt(0);
6369 return "%" + (n >> 4 & 15).toString(16) + (n & 15).toString(16);
6371 goog.Uri.removeDoubleEncoding_ = function(doubleEncodedString) {
6372 return doubleEncodedString.replace(/%25([0-9a-fA-F]{2})/g, "%$1");
6374 goog.Uri.reDisallowedInSchemeOrUserInfo_ = /[#\/\?@]/g;
6375 goog.Uri.reDisallowedInRelativePath_ = /[\#\?:]/g;
6376 goog.Uri.reDisallowedInAbsolutePath_ = /[\#\?]/g;
6377 goog.Uri.reDisallowedInQuery_ = /[\#\?@]/g;
6378 goog.Uri.reDisallowedInFragment_ = /#/g;
6379 goog.Uri.haveSameDomain = function(uri1String, uri2String) {
6380 var pieces1 = goog.uri.utils.split(uri1String), pieces2 = goog.uri.utils.split(uri2String);
6381 return pieces1[goog.uri.utils.ComponentIndex.DOMAIN] == pieces2[goog.uri.utils.ComponentIndex.DOMAIN] && pieces1[goog.uri.utils.ComponentIndex.PORT] == pieces2[goog.uri.utils.ComponentIndex.PORT];
6383 goog.Uri.QueryData = function(opt_query, opt_uri, opt_ignoreCase) {
6384 this.encodedQuery_ = opt_query || null;
6385 this.ignoreCase_ = !!opt_ignoreCase;
6387 goog.Uri.QueryData.prototype.ensureKeyMapInitialized_ = function() {
6388 if (!this.keyMap_ && (this.keyMap_ = new goog.structs.Map, this.count_ = 0, this.encodedQuery_)) {
6389 for (var pairs = this.encodedQuery_.split("&"), i = 0;i < pairs.length;i++) {
6390 var indexOfEquals = pairs[i].indexOf("="), name = null, value = null;
6391 0 <= indexOfEquals ? (name = pairs[i].substring(0, indexOfEquals), value = pairs[i].substring(indexOfEquals + 1)) : name = pairs[i];
6392 name = goog.string.urlDecode(name);
6393 name = this.getKeyName_(name);
6394 this.add(name, value ? goog.string.urlDecode(value) : "");
6398 goog.Uri.QueryData.createFromMap = function(map, opt_uri, opt_ignoreCase) {
6399 var keys = goog.structs.getKeys(map);
6400 if ("undefined" == typeof keys) {
6401 throw Error("Keys are undefined");
6403 for (var queryData = new goog.Uri.QueryData(null, null, opt_ignoreCase), values = goog.structs.getValues(map), i = 0;i < keys.length;i++) {
6404 var key = keys[i], value = values[i];
6405 goog.isArray(value) ? queryData.setValues(key, value) : queryData.add(key, value);
6409 goog.Uri.QueryData.createFromKeysValues = function(keys, values, opt_uri, opt_ignoreCase) {
6410 if (keys.length != values.length) {
6411 throw Error("Mismatched lengths for keys/values");
6413 for (var queryData = new goog.Uri.QueryData(null, null, opt_ignoreCase), i = 0;i < keys.length;i++) {
6414 queryData.add(keys[i], values[i]);
6418 goog.Uri.QueryData.prototype.keyMap_ = null;
6419 goog.Uri.QueryData.prototype.count_ = null;
6420 goog.Uri.QueryData.prototype.getCount = function() {
6421 this.ensureKeyMapInitialized_();
6424 goog.Uri.QueryData.prototype.add = function(key, value) {
6425 this.ensureKeyMapInitialized_();
6426 this.invalidateCache_();
6427 key = this.getKeyName_(key);
6428 var values = this.keyMap_.get(key);
6429 values || this.keyMap_.set(key, values = []);
6434 goog.Uri.QueryData.prototype.remove = function(key) {
6435 this.ensureKeyMapInitialized_();
6436 key = this.getKeyName_(key);
6437 return this.keyMap_.containsKey(key) ? (this.invalidateCache_(), this.count_ -= this.keyMap_.get(key).length, this.keyMap_.remove(key)) : !1;
6439 goog.Uri.QueryData.prototype.clear = function() {
6440 this.invalidateCache_();
6441 this.keyMap_ = null;
6444 goog.Uri.QueryData.prototype.isEmpty = function() {
6445 this.ensureKeyMapInitialized_();
6446 return 0 == this.count_;
6448 goog.Uri.QueryData.prototype.containsKey = function(key) {
6449 this.ensureKeyMapInitialized_();
6450 key = this.getKeyName_(key);
6451 return this.keyMap_.containsKey(key);
6453 goog.Uri.QueryData.prototype.containsValue = function(value) {
6454 var vals = this.getValues();
6455 return goog.array.contains(vals, value);
6457 goog.Uri.QueryData.prototype.getKeys = function() {
6458 this.ensureKeyMapInitialized_();
6459 for (var vals = this.keyMap_.getValues(), keys = this.keyMap_.getKeys(), rv = [], i = 0;i < keys.length;i++) {
6460 for (var val = vals[i], j = 0;j < val.length;j++) {
6466 goog.Uri.QueryData.prototype.getValues = function(opt_key) {
6467 this.ensureKeyMapInitialized_();
6469 if (goog.isString(opt_key)) {
6470 this.containsKey(opt_key) && (rv = goog.array.concat(rv, this.keyMap_.get(this.getKeyName_(opt_key))));
6472 for (var values = this.keyMap_.getValues(), i = 0;i < values.length;i++) {
6473 rv = goog.array.concat(rv, values[i]);
6478 goog.Uri.QueryData.prototype.set = function(key, value) {
6479 this.ensureKeyMapInitialized_();
6480 this.invalidateCache_();
6481 key = this.getKeyName_(key);
6482 this.containsKey(key) && (this.count_ -= this.keyMap_.get(key).length);
6483 this.keyMap_.set(key, [value]);
6487 goog.Uri.QueryData.prototype.get = function(key, opt_default) {
6488 var values = key ? this.getValues(key) : [];
6489 return goog.Uri.preserveParameterTypesCompatibilityFlag ? 0 < values.length ? values[0] : opt_default : 0 < values.length ? String(values[0]) : opt_default;
6491 goog.Uri.QueryData.prototype.setValues = function(key, values) {
6493 0 < values.length && (this.invalidateCache_(), this.keyMap_.set(this.getKeyName_(key), goog.array.clone(values)), this.count_ += values.length);
6495 goog.Uri.QueryData.prototype.toString = function() {
6496 if (this.encodedQuery_) {
6497 return this.encodedQuery_;
6499 if (!this.keyMap_) {
6502 for (var sb = [], keys = this.keyMap_.getKeys(), i = 0;i < keys.length;i++) {
6503 for (var key = keys[i], encodedKey = goog.string.urlEncode(key), val = this.getValues(key), j = 0;j < val.length;j++) {
6504 var param = encodedKey;
6505 "" !== val[j] && (param += "=" + goog.string.urlEncode(val[j]));
6509 return this.encodedQuery_ = sb.join("&");
6511 goog.Uri.QueryData.prototype.toDecodedString = function() {
6512 return goog.Uri.decodeOrEmpty_(this.toString());
6514 goog.Uri.QueryData.prototype.invalidateCache_ = function() {
6515 this.encodedQuery_ = null;
6517 goog.Uri.QueryData.prototype.clone = function() {
6518 var rv = new goog.Uri.QueryData;
6519 rv.encodedQuery_ = this.encodedQuery_;
6520 this.keyMap_ && (rv.keyMap_ = this.keyMap_.clone(), rv.count_ = this.count_);
6523 goog.Uri.QueryData.prototype.getKeyName_ = function(arg) {
6524 var keyName = String(arg);
6525 this.ignoreCase_ && (keyName = keyName.toLowerCase());
6528 goog.Uri.QueryData.prototype.setIgnoreCase = function(ignoreCase) {
6529 var resetKeys = ignoreCase && !this.ignoreCase_;
6530 resetKeys && (this.ensureKeyMapInitialized_(), this.invalidateCache_(), this.keyMap_.forEach(function(value, key) {
6531 var lowerCase = key.toLowerCase();
6532 key != lowerCase && (this.remove(key), this.setValues(lowerCase, value));
6534 this.ignoreCase_ = ignoreCase;
6536 goog.Uri.QueryData.prototype.extend = function(var_args) {
6537 for (var i = 0;i < arguments.length;i++) {
6538 var data = arguments[i];
6539 goog.structs.forEach(data, function(value, key) {
6540 this.add(key, value);
6544 goog.appengine = {};
6545 goog.appengine.DevChannel = function(token) {
6546 this.token_ = token;
6548 goog.appengine.DevChannel.prototype.open = function(opt_handler) {
6549 opt_handler = opt_handler || new goog.appengine.DevSocket.Handler;
6550 return new goog.appengine.DevSocket(this.token_, opt_handler);
6552 goog.appengine.DevSocket = function(token, handler) {
6553 this.readyState = goog.appengine.DevSocket.ReadyState.CONNECTING;
6554 this.token_ = token;
6555 this.applicationKey_ = token.substring(token.lastIndexOf("-") + 1);
6556 this.clientId_ = null;
6557 this.onopen = handler.onopen;
6558 this.onmessage = handler.onmessage;
6559 this.onerror = handler.onerror;
6560 this.onclose = handler.onclose;
6561 this.win_ = goog.dom.getWindow();
6562 this.pollingTimer_ = null;
6563 goog.net.XhrIo.send(this.getUrl_("connect"), goog.bind(this.connect_, this));
6564 goog.events.listen(this.win_, "beforeunload", goog.bind(this.beforeunload_, this));
6565 if (!document.body) {
6566 throw "document.body is not defined -- do not create socket from script in <head>.";
6569 goog.appengine.DevSocket.POLLING_TIMEOUT_MS = 500;
6570 goog.appengine.DevSocket.BASE_URL = "/_ah/channel/";
6571 goog.appengine.DevSocket.ReadyState = {CONNECTING:0, OPEN:1, CLOSING:2, CLOSED:3};
6572 goog.appengine.DevSocket.prototype.getUrl_ = function(command) {
6573 var url = goog.appengine.DevSocket.BASE_URL + "dev?command=" + command + "&channel=" + this.token_;
6574 this.clientId_ && (url += "&client=" + this.clientId_);
6577 goog.appengine.DevSocket.prototype.connect_ = function(e) {
6579 if (xhr.isSuccess()) {
6580 this.clientId_ = xhr.getResponseText(), this.readyState = goog.appengine.DevSocket.ReadyState.OPEN, this.onopen(), this.pollingTimer_ = this.win_.setTimeout(goog.bind(this.poll_, this), goog.appengine.DevSocket.POLLING_TIMEOUT_MS);
6582 this.readyState = goog.appengine.DevSocket.ReadyState.CLOSING;
6584 evt.description = xhr.getStatusText();
6585 evt.code = xhr.getStatus();
6587 this.readyState = goog.appengine.DevSocket.ReadyState.CLOSED;
6591 goog.appengine.DevSocket.prototype.disconnect_ = function() {
6592 this.readyState = goog.appengine.DevSocket.ReadyState.CLOSED;
6595 goog.appengine.DevSocket.prototype.forwardMessage_ = function(e) {
6597 if (xhr.isSuccess()) {
6599 evt.data = xhr.getResponseText();
6600 if (evt.data.length) {
6601 this.onmessage(evt);
6603 this.readyState == goog.appengine.DevSocket.ReadyState.OPEN && (this.pollingTimer_ = this.win_.setTimeout(goog.bind(this.poll_, this), goog.appengine.DevSocket.POLLING_TIMEOUT_MS));
6605 evt = {}, evt.description = xhr.getStatusText(), evt.code = xhr.getStatus(), this.onerror(evt), this.readyState = goog.appengine.DevSocket.ReadyState.CLOSED, this.onclose();
6608 goog.appengine.DevSocket.prototype.poll_ = function() {
6609 goog.net.XhrIo.send(this.getUrl_("poll"), goog.bind(this.forwardMessage_, this));
6611 goog.appengine.DevSocket.prototype.beforeunload_ = function() {
6612 var xhr = goog.net.XmlHttp();
6613 xhr.open("GET", this.getUrl_("disconnect"), !1);
6616 goog.appengine.DevSocket.prototype.forwardSendComplete_ = function(e) {
6618 if (!xhr.isSuccess()) {
6620 evt.description = xhr.getStatusText();
6621 evt.code = xhr.getStatus();
6625 goog.appengine.DevSocket.prototype.send = function(data) {
6626 if (this.readyState != goog.appengine.DevSocket.ReadyState.OPEN) {
6629 var url = goog.appengine.DevSocket.BASE_URL + "receive", sendData = new goog.Uri.QueryData;
6630 sendData.set("key", this.applicationKey_);
6631 sendData.set("msg", data);
6632 goog.net.XhrIo.send(url, goog.bind(this.forwardSendComplete_, this), "POST", sendData.toString());
6635 goog.appengine.DevSocket.prototype.close = function() {
6636 this.readyState = goog.appengine.DevSocket.ReadyState.CLOSING;
6637 this.pollingTimer_ && this.win_.clearTimeout(this.pollingTimer_);
6638 goog.net.XhrIo.send(this.getUrl_("disconnect"), goog.bind(this.disconnect_, this));
6640 goog.appengine.DevSocket.Handler = function() {
6642 goog.appengine.DevSocket.Handler.prototype.onopen = function() {
6644 goog.appengine.DevSocket.Handler.prototype.onmessage = function() {
6646 goog.appengine.DevSocket.Handler.prototype.onerror = function() {
6648 goog.appengine.DevSocket.Handler.prototype.onclose = function() {
6650 goog.exportSymbol("goog.appengine.Channel", goog.appengine.DevChannel);
6651 goog.exportSymbol("goog.appengine.Channel.prototype.open", goog.appengine.DevChannel.prototype.open);
6652 goog.exportSymbol("goog.appengine.Socket.Handler", goog.appengine.DevSocket.Handler);
6653 goog.exportSymbol("goog.appengine.Socket.Handler.prototype.onopen", goog.appengine.DevChannel.prototype.onopen);
6654 goog.exportSymbol("goog.appengine.Socket.Handler.prototype.onmessage", goog.appengine.DevSocket.Handler.prototype.onmessage);
6655 goog.exportSymbol("goog.appengine.Socket.Handler.prototype.onerror", goog.appengine.DevSocket.Handler.prototype.onerror);
6656 goog.exportSymbol("goog.appengine.Socket.Handler.prototype.onclose", goog.appengine.DevSocket.Handler.prototype.onclose);
6657 goog.exportSymbol("goog.appengine.Socket", goog.appengine.DevSocket);
6658 goog.exportSymbol("goog.appengine.Socket.ReadyState", goog.appengine.DevSocket.ReadyState);
6659 goog.exportSymbol("goog.appengine.Socket.prototype.send", goog.appengine.DevSocket.prototype.send);
6660 goog.exportSymbol("goog.appengine.Socket.prototype.close", goog.appengine.DevSocket.prototype.close);