closure-builder
Version:
Simple Closure, Soy and JavaScript Build system
1,253 lines • 300 kB
JavaScript
var $jscomp = $jscomp || {};
$jscomp.scope = {};
$jscomp.arrayIteratorImpl = function(array) {
var index = 0;
return function() {
return index < array.length ? {done:!1, value:array[index++]} : {done:!0};
};
};
$jscomp.arrayIterator = function(array) {
return {next:$jscomp.arrayIteratorImpl(array)};
};
$jscomp.makeIterator = function(iterable) {
var iteratorFunction = "undefined" != typeof Symbol && Symbol.iterator && iterable[Symbol.iterator];
return iteratorFunction ? iteratorFunction.call(iterable) : $jscomp.arrayIterator(iterable);
};
$jscomp.findInternal = function(array, callback, thisArg) {
array instanceof String && (array = String(array));
for (var len = array.length, i = 0; i < len; i++) {
var value = array[i];
if (callback.call(thisArg, value, i, array)) {
return {i:i, v:value};
}
}
return {i:-1, v:void 0};
};
$jscomp.ASSUME_ES5 = !1;
$jscomp.ASSUME_NO_NATIVE_MAP = !1;
$jscomp.ASSUME_NO_NATIVE_SET = !1;
$jscomp.SIMPLE_FROUND_POLYFILL = !1;
$jscomp.defineProperty = $jscomp.ASSUME_ES5 || "function" == typeof Object.defineProperties ? Object.defineProperty : function(target, property, descriptor) {
target != Array.prototype && target != Object.prototype && (target[property] = descriptor.value);
};
$jscomp.getGlobal = function(maybeGlobal) {
return "undefined" != typeof window && window === maybeGlobal ? maybeGlobal : "undefined" != typeof global && null != global ? global : maybeGlobal;
};
$jscomp.global = $jscomp.getGlobal(this);
$jscomp.polyfill = function(target, polyfill) {
if (polyfill) {
for (var obj = $jscomp.global, split = target.split("."), i = 0; i < split.length - 1; i++) {
var key = split[i];
key in obj || (obj[key] = {});
obj = obj[key];
}
var property = split[split.length - 1], orig = obj[property], impl = polyfill(orig);
impl != orig && null != impl && $jscomp.defineProperty(obj, property, {configurable:!0, writable:!0, value:impl});
}
};
$jscomp.checkStringArgs = function(thisArg, arg, func) {
if (null == thisArg) {
throw new TypeError("The 'this' value for String.prototype." + func + " must not be null or undefined");
}
if (arg instanceof RegExp) {
throw new TypeError("First argument to String.prototype." + func + " must not be a regular expression");
}
return thisArg + "";
};
$jscomp.SYMBOL_PREFIX = "jscomp_symbol_";
$jscomp.initSymbol = function() {
$jscomp.initSymbol = function() {
};
$jscomp.global.Symbol || ($jscomp.global.Symbol = $jscomp.Symbol);
};
$jscomp.SymbolClass = function(id, opt_description) {
this.$jscomp$symbol$id_ = id;
$jscomp.defineProperty(this, "description", {configurable:!0, writable:!0, value:opt_description});
};
$jscomp.SymbolClass.prototype.toString = function() {
return this.$jscomp$symbol$id_;
};
$jscomp.Symbol = function() {
function Symbol(opt_description) {
if (this instanceof Symbol) {
throw new TypeError("Symbol is not a constructor");
}
return new $jscomp.SymbolClass($jscomp.SYMBOL_PREFIX + (opt_description || "") + "_" + counter++, opt_description);
}
var counter = 0;
return Symbol;
}();
$jscomp.initSymbolIterator = function() {
$jscomp.initSymbol();
var symbolIterator = $jscomp.global.Symbol.iterator;
symbolIterator || (symbolIterator = $jscomp.global.Symbol.iterator = $jscomp.global.Symbol("Symbol.iterator"));
"function" != typeof Array.prototype[symbolIterator] && $jscomp.defineProperty(Array.prototype, symbolIterator, {configurable:!0, writable:!0, value:function() {
return $jscomp.iteratorPrototype($jscomp.arrayIteratorImpl(this));
}});
$jscomp.initSymbolIterator = function() {
};
};
$jscomp.initSymbolAsyncIterator = function() {
$jscomp.initSymbol();
var symbolAsyncIterator = $jscomp.global.Symbol.asyncIterator;
symbolAsyncIterator || (symbolAsyncIterator = $jscomp.global.Symbol.asyncIterator = $jscomp.global.Symbol("Symbol.asyncIterator"));
$jscomp.initSymbolAsyncIterator = function() {
};
};
$jscomp.iteratorPrototype = function(next) {
$jscomp.initSymbolIterator();
var iterator = {next:next};
iterator[$jscomp.global.Symbol.iterator] = function() {
return this;
};
return iterator;
};
$jscomp.iteratorFromArray = function(array, transform) {
$jscomp.initSymbolIterator();
array instanceof String && (array += "");
var i = 0, iter = {next:function() {
if (i < array.length) {
var index = i++;
return {value:transform(index, array[index]), done:!1};
}
iter.next = function() {
return {done:!0, value:void 0};
};
return iter.next();
}};
iter[Symbol.iterator] = function() {
return iter;
};
return iter;
};
$jscomp.polyfill("Array.from", function(orig) {
return orig ? orig : function(arrayLike, opt_mapFn, opt_thisArg) {
opt_mapFn = null != opt_mapFn ? opt_mapFn : function(x) {
return x;
};
var result = [], iteratorFunction = "undefined" != typeof Symbol && Symbol.iterator && arrayLike[Symbol.iterator];
if ("function" == typeof iteratorFunction) {
arrayLike = iteratorFunction.call(arrayLike);
for (var next, k = 0; !(next = arrayLike.next()).done;) {
result.push(opt_mapFn.call(opt_thisArg, next.value, k++));
}
} else {
for (var len = arrayLike.length, i = 0; i < len; i++) {
result.push(opt_mapFn.call(opt_thisArg, arrayLike[i], i));
}
}
return result;
};
}, "es6", "es3");
$jscomp.checkEs6ConformanceViaProxy = function() {
try {
var proxied = {}, proxy = Object.create(new $jscomp.global.Proxy(proxied, {get:function(target, key, receiver) {
return target == proxied && "q" == key && receiver == proxy;
}}));
return !0 === proxy.q;
} catch (err) {
return !1;
}
};
$jscomp.USE_PROXY_FOR_ES6_CONFORMANCE_CHECKS = !1;
$jscomp.ES6_CONFORMANCE = $jscomp.USE_PROXY_FOR_ES6_CONFORMANCE_CHECKS && $jscomp.checkEs6ConformanceViaProxy();
$jscomp.owns = function(obj, prop) {
return Object.prototype.hasOwnProperty.call(obj, prop);
};
$jscomp.polyfill("WeakMap", function(NativeWeakMap) {
function isConformant() {
if (!NativeWeakMap || !Object.seal) {
return !1;
}
try {
var x = Object.seal({}), y = Object.seal({}), map = new NativeWeakMap([[x, 2], [y, 3]]);
if (2 != map.get(x) || 3 != map.get(y)) {
return !1;
}
map.delete(x);
map.set(y, 4);
return !map.has(x) && 4 == map.get(y);
} catch (err) {
return !1;
}
}
function WeakMapMembership() {
}
function insert(target) {
$jscomp.owns(target, prop) || $jscomp.defineProperty(target, prop, {value:new WeakMapMembership});
}
function patch(name) {
var prev = Object[name];
prev && (Object[name] = function(target) {
if (target instanceof WeakMapMembership) {
return target;
}
insert(target);
return prev(target);
});
}
if ($jscomp.USE_PROXY_FOR_ES6_CONFORMANCE_CHECKS) {
if (NativeWeakMap && $jscomp.ES6_CONFORMANCE) {
return NativeWeakMap;
}
} else {
if (isConformant()) {
return NativeWeakMap;
}
}
var prop = "$jscomp_hidden_" + Math.random();
patch("freeze");
patch("preventExtensions");
patch("seal");
var index = 0, PolyfillWeakMap = function(opt_iterable) {
this.id_ = (index += Math.random() + 1).toString();
if (opt_iterable) {
for (var iter = $jscomp.makeIterator(opt_iterable), entry; !(entry = iter.next()).done;) {
var item = entry.value;
this.set(item[0], item[1]);
}
}
};
PolyfillWeakMap.prototype.set = function(key, value) {
insert(key);
if (!$jscomp.owns(key, prop)) {
throw Error("WeakMap key fail: " + key);
}
key[prop][this.id_] = value;
return this;
};
PolyfillWeakMap.prototype.get = function(key) {
return $jscomp.owns(key, prop) ? key[prop][this.id_] : void 0;
};
PolyfillWeakMap.prototype.has = function(key) {
return $jscomp.owns(key, prop) && $jscomp.owns(key[prop], this.id_);
};
PolyfillWeakMap.prototype.delete = function(key) {
return $jscomp.owns(key, prop) && $jscomp.owns(key[prop], this.id_) ? delete key[prop][this.id_] : !1;
};
return PolyfillWeakMap;
}, "es6", "es3");
$jscomp.MapEntry = function() {
};
$jscomp.polyfill("Map", function(NativeMap) {
function isConformant() {
if ($jscomp.ASSUME_NO_NATIVE_MAP || !NativeMap || "function" != typeof NativeMap || !NativeMap.prototype.entries || "function" != typeof Object.seal) {
return !1;
}
try {
var key = Object.seal({x:4}), map = new NativeMap($jscomp.makeIterator([[key, "s"]]));
if ("s" != map.get(key) || 1 != map.size || map.get({x:4}) || map.set({x:4}, "t") != map || 2 != map.size) {
return !1;
}
var iter = map.entries(), item = iter.next();
if (item.done || item.value[0] != key || "s" != item.value[1]) {
return !1;
}
item = iter.next();
return item.done || 4 != item.value[0].x || "t" != item.value[1] || !iter.next().done ? !1 : !0;
} catch (err) {
return !1;
}
}
if ($jscomp.USE_PROXY_FOR_ES6_CONFORMANCE_CHECKS) {
if (NativeMap && $jscomp.ES6_CONFORMANCE) {
return NativeMap;
}
} else {
if (isConformant()) {
return NativeMap;
}
}
$jscomp.initSymbolIterator();
var idMap = new WeakMap, PolyfillMap = function(opt_iterable) {
this.data_ = {};
this.head_ = createHead();
this.size = 0;
if (opt_iterable) {
for (var iter = $jscomp.makeIterator(opt_iterable), entry; !(entry = iter.next()).done;) {
var item = entry.value;
this.set(item[0], item[1]);
}
}
};
PolyfillMap.prototype.set = function(key, value) {
key = 0 === key ? 0 : key;
var r = maybeGetEntry(this, key);
r.list || (r.list = this.data_[r.id] = []);
r.entry ? r.entry.value = value : (r.entry = {next:this.head_, previous:this.head_.previous, head:this.head_, key:key, value:value}, r.list.push(r.entry), this.head_.previous.next = r.entry, this.head_.previous = r.entry, this.size++);
return this;
};
PolyfillMap.prototype.delete = function(key) {
var r = maybeGetEntry(this, key);
return r.entry && r.list ? (r.list.splice(r.index, 1), r.list.length || delete this.data_[r.id], r.entry.previous.next = r.entry.next, r.entry.next.previous = r.entry.previous, r.entry.head = null, this.size--, !0) : !1;
};
PolyfillMap.prototype.clear = function() {
this.data_ = {};
this.head_ = this.head_.previous = createHead();
this.size = 0;
};
PolyfillMap.prototype.has = function(key) {
return !!maybeGetEntry(this, key).entry;
};
PolyfillMap.prototype.get = function(key) {
var entry = maybeGetEntry(this, key).entry;
return entry && entry.value;
};
PolyfillMap.prototype.entries = function() {
return makeIterator(this, function(entry) {
return [entry.key, entry.value];
});
};
PolyfillMap.prototype.keys = function() {
return makeIterator(this, function(entry) {
return entry.key;
});
};
PolyfillMap.prototype.values = function() {
return makeIterator(this, function(entry) {
return entry.value;
});
};
PolyfillMap.prototype.forEach = function(callback, opt_thisArg) {
for (var iter = this.entries(), item; !(item = iter.next()).done;) {
var entry = item.value;
callback.call(opt_thisArg, entry[1], entry[0], this);
}
};
PolyfillMap.prototype[Symbol.iterator] = PolyfillMap.prototype.entries;
var maybeGetEntry = function(map, key) {
var type = key && typeof key;
if ("object" == type || "function" == type) {
if (idMap.has(key)) {
var id = idMap.get(key);
} else {
var id$jscomp$0 = "" + ++mapIndex;
idMap.set(key, id$jscomp$0);
id = id$jscomp$0;
}
} else {
id = "p_" + key;
}
var list = map.data_[id];
if (list && $jscomp.owns(map.data_, id)) {
for (var index = 0; index < list.length; index++) {
var entry = list[index];
if (key !== key && entry.key !== entry.key || key === entry.key) {
return {id:id, list:list, index:index, entry:entry};
}
}
}
return {id:id, list:list, index:-1, entry:void 0};
}, makeIterator = function(map, func) {
var entry = map.head_;
return $jscomp.iteratorPrototype(function() {
if (entry) {
for (; entry.head != map.head_;) {
entry = entry.previous;
}
for (; entry.next != entry.head;) {
return entry = entry.next, {done:!1, value:func(entry)};
}
entry = null;
}
return {done:!0, value:void 0};
});
}, createHead = function() {
var head = {};
return head.previous = head.next = head.head = head;
}, mapIndex = 0;
return PolyfillMap;
}, "es6", "es3");
var goog = goog || {};
goog.global = this;
goog.isDef = function(val) {
return void 0 !== val;
};
goog.isString = function(val) {
return "string" == typeof val;
};
goog.isBoolean = function(val) {
return "boolean" == typeof val;
};
goog.isNumber = function(val) {
return "number" == typeof val;
};
goog.exportPath_ = function(name, opt_object, opt_objectToExportTo) {
var parts = name.split("."), cur = opt_objectToExportTo || goog.global;
parts[0] in cur || "undefined" == typeof cur.execScript || cur.execScript("var " + parts[0]);
for (var part; parts.length && (part = parts.shift());) {
!parts.length && goog.isDef(opt_object) ? cur[part] = opt_object : cur = cur[part] && cur[part] !== Object.prototype[part] ? cur[part] : cur[part] = {};
}
};
goog.define = function(name, defaultValue) {
goog.exportPath_(name, defaultValue);
return defaultValue;
};
goog.DEBUG = !1;
goog.LOCALE = "en";
goog.TRUSTED_SITE = !0;
goog.STRICT_MODE_COMPATIBLE = !1;
goog.DISALLOW_TEST_ONLY_CODE = !goog.DEBUG;
goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING = !1;
goog.provide = function(name) {
if (goog.isInModuleLoader_()) {
throw Error("goog.provide cannot be used within a module.");
}
goog.constructNamespace_(name);
};
goog.constructNamespace_ = function(name, opt_obj) {
goog.exportPath_(name, opt_obj);
};
goog.getScriptNonce = function(opt_window) {
if (opt_window && opt_window != goog.global) {
return goog.getScriptNonce_(opt_window.document);
}
null === goog.cspNonce_ && (goog.cspNonce_ = goog.getScriptNonce_(goog.global.document));
return goog.cspNonce_;
};
goog.NONCE_PATTERN_ = /^[\w+/_-]+[=]{0,2}$/;
goog.cspNonce_ = null;
goog.getScriptNonce_ = function(doc) {
var script = doc.querySelector && doc.querySelector("script[nonce]");
if (script) {
var nonce = script.nonce || script.getAttribute("nonce");
if (nonce && goog.NONCE_PATTERN_.test(nonce)) {
return nonce;
}
}
return "";
};
goog.VALID_MODULE_RE_ = /^[a-zA-Z_$][a-zA-Z0-9._$]*$/;
goog.module = function(name) {
if (!goog.isString(name) || !name || -1 == name.search(goog.VALID_MODULE_RE_)) {
throw Error("Invalid module identifier");
}
if (!goog.isInGoogModuleLoader_()) {
throw Error("Module " + name + " has been loaded incorrectly. Note, modules cannot be loaded as normal scripts. They require some kind of pre-processing step. You're likely trying to load a module via a script tag or as a part of a concatenated bundle without rewriting the module. For more info see: https://github.com/google/closure-library/wiki/goog.module:-an-ES6-module-like-alternative-to-goog.provide.");
}
if (goog.moduleLoaderState_.moduleName) {
throw Error("goog.module may only be called once per module.");
}
goog.moduleLoaderState_.moduleName = name;
};
goog.module.get = function() {
return null;
};
goog.module.getInternal_ = function() {
return null;
};
goog.ModuleType = {ES6:"es6", GOOG:"goog"};
goog.moduleLoaderState_ = null;
goog.isInModuleLoader_ = function() {
return goog.isInGoogModuleLoader_() || goog.isInEs6ModuleLoader_();
};
goog.isInGoogModuleLoader_ = function() {
return !!goog.moduleLoaderState_ && goog.moduleLoaderState_.type == goog.ModuleType.GOOG;
};
goog.isInEs6ModuleLoader_ = function() {
if (goog.moduleLoaderState_ && goog.moduleLoaderState_.type == goog.ModuleType.ES6) {
return !0;
}
var jscomp = goog.global.$jscomp;
return jscomp ? "function" != typeof jscomp.getCurrentModulePath ? !1 : !!jscomp.getCurrentModulePath() : !1;
};
goog.module.declareLegacyNamespace = function() {
goog.moduleLoaderState_.declareLegacyNamespace = !0;
};
goog.declareModuleId = function(namespace) {
if (goog.moduleLoaderState_) {
goog.moduleLoaderState_.moduleName = namespace;
} else {
var jscomp = goog.global.$jscomp;
if (!jscomp || "function" != typeof jscomp.getCurrentModulePath) {
throw Error('Module with namespace "' + namespace + '" has been loaded incorrectly.');
}
var exports = jscomp.require(jscomp.getCurrentModulePath());
goog.loadedModules_[namespace] = {exports:exports, type:goog.ModuleType.ES6, moduleId:namespace};
}
};
goog.module.declareNamespace = goog.declareModuleId;
goog.setTestOnly = function(opt_message) {
if (goog.DISALLOW_TEST_ONLY_CODE) {
throw opt_message = opt_message || "", Error("Importing test-only code into non-debug environment" + (opt_message ? ": " + opt_message : "."));
}
};
goog.forwardDeclare = function() {
};
goog.getObjectByName = function(name, opt_obj) {
for (var parts = name.split("."), cur = opt_obj || goog.global, i = 0; i < parts.length; i++) {
if (cur = cur[parts[i]], !goog.isDefAndNotNull(cur)) {
return null;
}
}
return cur;
};
goog.globalize = function(obj, opt_global) {
var global = opt_global || goog.global, x;
for (x in obj) {
global[x] = obj[x];
}
};
goog.addDependency = function() {
};
goog.useStrictRequires = !1;
goog.ENABLE_DEBUG_LOADER = !0;
goog.logToConsole_ = function(msg) {
goog.global.console && goog.global.console.error(msg);
};
goog.require = function() {
};
goog.requireType = function() {
return {};
};
goog.basePath = "";
goog.nullFunction = function() {
};
goog.abstractMethod = function() {
throw Error("unimplemented abstract method");
};
goog.addSingletonGetter = function(ctor) {
ctor.instance_ = void 0;
ctor.getInstance = function() {
if (ctor.instance_) {
return ctor.instance_;
}
goog.DEBUG && (goog.instantiatedSingletons_[goog.instantiatedSingletons_.length] = ctor);
return ctor.instance_ = new ctor;
};
};
goog.instantiatedSingletons_ = [];
goog.LOAD_MODULE_USING_EVAL = !0;
goog.SEAL_MODULE_EXPORTS = goog.DEBUG;
goog.loadedModules_ = {};
goog.DEPENDENCIES_ENABLED = !1;
goog.TRANSPILE = "detect";
goog.ASSUME_ES_MODULES_TRANSPILED = !1;
goog.TRANSPILE_TO_LANGUAGE = "";
goog.TRANSPILER = "transpile.js";
goog.hasBadLetScoping = null;
goog.useSafari10Workaround = function() {
if (null == goog.hasBadLetScoping) {
try {
var hasBadLetScoping = !eval('"use strict";let x = 1; function f() { return typeof x; };f() == "number";');
} catch (e) {
hasBadLetScoping = !1;
}
goog.hasBadLetScoping = hasBadLetScoping;
}
return goog.hasBadLetScoping;
};
goog.workaroundSafari10EvalBug = function(moduleDef) {
return "(function(){" + moduleDef + "\n;})();\n";
};
goog.loadModule = function(moduleDef) {
var previousState = goog.moduleLoaderState_;
try {
goog.moduleLoaderState_ = {moduleName:"", declareLegacyNamespace:!1, type:goog.ModuleType.GOOG};
if (goog.isFunction(moduleDef)) {
var exports = moduleDef.call(void 0, {});
} else {
if (goog.isString(moduleDef)) {
goog.useSafari10Workaround() && (moduleDef = goog.workaroundSafari10EvalBug(moduleDef)), exports = goog.loadModuleFromSource_.call(void 0, moduleDef);
} else {
throw Error("Invalid module definition");
}
}
var moduleName = goog.moduleLoaderState_.moduleName;
if (goog.isString(moduleName) && moduleName) {
goog.moduleLoaderState_.declareLegacyNamespace ? goog.constructNamespace_(moduleName, exports) : goog.SEAL_MODULE_EXPORTS && Object.seal && "object" == typeof exports && null != exports && Object.seal(exports), goog.loadedModules_[moduleName] = {exports:exports, type:goog.ModuleType.GOOG, moduleId:goog.moduleLoaderState_.moduleName};
} else {
throw Error('Invalid module name "' + moduleName + '"');
}
} finally {
goog.moduleLoaderState_ = previousState;
}
};
goog.loadModuleFromSource_ = function(JSCompiler_OptimizeArgumentsArray_p0) {
eval(JSCompiler_OptimizeArgumentsArray_p0);
return {};
};
goog.normalizePath_ = function(path) {
for (var components = path.split("/"), i = 0; i < components.length;) {
"." == components[i] ? components.splice(i, 1) : i && ".." == components[i] && components[i - 1] && ".." != components[i - 1] ? components.splice(--i, 2) : i++;
}
return components.join("/");
};
goog.loadFileSync_ = function(src) {
if (goog.global.CLOSURE_LOAD_FILE_SYNC) {
return goog.global.CLOSURE_LOAD_FILE_SYNC(src);
}
try {
var xhr = new goog.global.XMLHttpRequest;
xhr.open("get", src, !1);
xhr.send();
return 0 == xhr.status || 200 == xhr.status ? xhr.responseText : null;
} catch (err) {
return null;
}
};
goog.transpile_ = function(code$jscomp$0, path$jscomp$0, target) {
var jscomp = goog.global.$jscomp;
jscomp || (goog.global.$jscomp = jscomp = {});
var transpile = jscomp.transpile;
if (!transpile) {
var transpilerPath = goog.basePath + goog.TRANSPILER, transpilerCode = goog.loadFileSync_(transpilerPath);
if (transpilerCode) {
(function() {
eval(transpilerCode + "\n//# sourceURL=" + transpilerPath);
}).call(goog.global);
if (goog.global.$gwtExport && goog.global.$gwtExport.$jscomp && !goog.global.$gwtExport.$jscomp.transpile) {
throw Error('The transpiler did not properly export the "transpile" method. $gwtExport: ' + JSON.stringify(goog.global.$gwtExport));
}
goog.global.$jscomp.transpile = goog.global.$gwtExport.$jscomp.transpile;
jscomp = goog.global.$jscomp;
transpile = jscomp.transpile;
}
}
if (!transpile) {
var suffix = " requires transpilation but no transpiler was found.";
suffix += ' Please add "//javascript/closure:transpiler" as a data dependency to ensure it is included.';
transpile = jscomp.transpile = function(code, path) {
goog.logToConsole_(path + suffix);
return code;
};
}
return transpile(code$jscomp$0, path$jscomp$0, target);
};
goog.typeOf = function(value) {
var s = typeof value;
if ("object" == s) {
if (value) {
if (value instanceof Array) {
return "array";
}
if (value instanceof Object) {
return s;
}
var className = Object.prototype.toString.call(value);
if ("[object Window]" == className) {
return "object";
}
if ("[object Array]" == className || "number" == typeof value.length && "undefined" != typeof value.splice && "undefined" != typeof value.propertyIsEnumerable && !value.propertyIsEnumerable("splice")) {
return "array";
}
if ("[object Function]" == className || "undefined" != typeof value.call && "undefined" != typeof value.propertyIsEnumerable && !value.propertyIsEnumerable("call")) {
return "function";
}
} else {
return "null";
}
} else {
if ("function" == s && "undefined" == typeof value.call) {
return "object";
}
}
return s;
};
goog.isNull = function(val) {
return null === val;
};
goog.isDefAndNotNull = function(val) {
return null != val;
};
goog.isArray = function(val) {
return "array" == goog.typeOf(val);
};
goog.isArrayLike = function(val) {
var type = goog.typeOf(val);
return "array" == type || "object" == type && "number" == typeof val.length;
};
goog.isDateLike = function(val) {
return goog.isObject(val) && "function" == typeof val.getFullYear;
};
goog.isFunction = function(val) {
return "function" == goog.typeOf(val);
};
goog.isObject = function(val) {
var type = typeof val;
return "object" == type && null != val || "function" == type;
};
goog.getUid = function(obj) {
return obj[goog.UID_PROPERTY_] || (obj[goog.UID_PROPERTY_] = ++goog.uidCounter_);
};
goog.hasUid = function(obj) {
return !!obj[goog.UID_PROPERTY_];
};
goog.removeUid = function(obj) {
null !== obj && "removeAttribute" in obj && obj.removeAttribute(goog.UID_PROPERTY_);
try {
delete obj[goog.UID_PROPERTY_];
} catch (ex) {
}
};
goog.UID_PROPERTY_ = "closure_uid_" + (1e9 * Math.random() >>> 0);
goog.uidCounter_ = 0;
goog.getHashCode = goog.getUid;
goog.removeHashCode = goog.removeUid;
goog.cloneObject = function(obj) {
var type = goog.typeOf(obj);
if ("object" == type || "array" == type) {
if ("function" === typeof obj.clone) {
return obj.clone();
}
var clone = "array" == type ? [] : {}, key;
for (key in obj) {
clone[key] = goog.cloneObject(obj[key]);
}
return clone;
}
return obj;
};
goog.bindNative_ = function(fn, selfObj, var_args) {
return fn.call.apply(fn.bind, arguments);
};
goog.bindJs_ = function(fn, selfObj, var_args) {
if (!fn) {
throw Error();
}
if (2 < arguments.length) {
var boundArgs = Array.prototype.slice.call(arguments, 2);
return function() {
var newArgs = Array.prototype.slice.call(arguments);
Array.prototype.unshift.apply(newArgs, boundArgs);
return fn.apply(selfObj, newArgs);
};
}
return function() {
return fn.apply(selfObj, arguments);
};
};
goog.bind = function(fn, selfObj, var_args) {
Function.prototype.bind && -1 != Function.prototype.bind.toString().indexOf("native code") ? goog.bind = goog.bindNative_ : goog.bind = goog.bindJs_;
return goog.bind.apply(null, arguments);
};
goog.partial = function(fn, var_args) {
var args = Array.prototype.slice.call(arguments, 1);
return function() {
var newArgs = args.slice();
newArgs.push.apply(newArgs, arguments);
return fn.apply(this, newArgs);
};
};
goog.mixin = function(target, source) {
for (var x in source) {
target[x] = source[x];
}
};
goog.now = goog.TRUSTED_SITE && Date.now || function() {
return +new Date;
};
goog.globalEval = function(script) {
if (goog.global.execScript) {
goog.global.execScript(script, "JavaScript");
} else {
if (goog.global.eval) {
if (null == goog.evalWorksForGlobals_) {
try {
goog.global.eval("var _evalTest_ = 1;");
} catch (ignore) {
}
if ("undefined" != typeof goog.global._evalTest_) {
try {
delete goog.global._evalTest_;
} catch (ignore$3) {
}
goog.evalWorksForGlobals_ = !0;
} else {
goog.evalWorksForGlobals_ = !1;
}
}
if (goog.evalWorksForGlobals_) {
goog.global.eval(script);
} else {
var doc = goog.global.document, scriptElt = doc.createElement("SCRIPT");
scriptElt.type = "text/javascript";
scriptElt.defer = !1;
scriptElt.appendChild(doc.createTextNode(script));
doc.head.appendChild(scriptElt);
doc.head.removeChild(scriptElt);
}
} else {
throw Error("goog.globalEval not available");
}
}
};
goog.evalWorksForGlobals_ = null;
goog.getCssName = function(className, opt_modifier) {
if ("." == String(className).charAt(0)) {
throw Error('className passed in goog.getCssName must not start with ".". You passed: ' + className);
}
var getMapping = function(cssName) {
return goog.cssNameMapping_[cssName] || cssName;
}, renameByParts = function(cssName) {
for (var parts = cssName.split("-"), mapped = [], i = 0; i < parts.length; i++) {
mapped.push(getMapping(parts[i]));
}
return mapped.join("-");
};
var rename = goog.cssNameMapping_ ? "BY_WHOLE" == goog.cssNameMappingStyle_ ? getMapping : renameByParts : function(a) {
return a;
};
var result = opt_modifier ? className + "-" + rename(opt_modifier) : rename(className);
return goog.global.CLOSURE_CSS_NAME_MAP_FN ? goog.global.CLOSURE_CSS_NAME_MAP_FN(result) : result;
};
goog.setCssNameMapping = function(mapping, opt_style) {
goog.cssNameMapping_ = mapping;
goog.cssNameMappingStyle_ = opt_style;
};
goog.getMsg = function(str, opt_values) {
opt_values && (str = str.replace(/\{\$([^}]+)}/g, function(match, key) {
return null != opt_values && key in opt_values ? opt_values[key] : match;
}));
return str;
};
goog.getMsgWithFallback = function(a) {
return a;
};
goog.exportSymbol = function(publicPath, object, opt_objectToExportTo) {
goog.exportPath_(publicPath, object, opt_objectToExportTo);
};
goog.exportProperty = function(object, publicName, symbol) {
object[publicName] = symbol;
};
goog.inherits = function(childCtor, parentCtor) {
function tempCtor() {
}
tempCtor.prototype = parentCtor.prototype;
childCtor.superClass_ = parentCtor.prototype;
childCtor.prototype = new tempCtor;
childCtor.prototype.constructor = childCtor;
childCtor.base = function(me, methodName, var_args) {
for (var args = Array(arguments.length - 2), i = 2; i < arguments.length; i++) {
args[i - 2] = arguments[i];
}
return parentCtor.prototype[methodName].apply(me, args);
};
};
goog.base = function(me, opt_methodName, var_args) {
var caller = arguments.callee.caller;
if (goog.STRICT_MODE_COMPATIBLE || goog.DEBUG && !caller) {
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");
}
if ("undefined" !== typeof caller.superClass_) {
for (var ctorArgs = Array(arguments.length - 1), i = 1; i < arguments.length; i++) {
ctorArgs[i - 1] = arguments[i];
}
return caller.superClass_.constructor.apply(me, ctorArgs);
}
if ("string" != typeof opt_methodName && "symbol" != typeof opt_methodName) {
throw Error("method names provided to goog.base must be a string or a symbol");
}
var args = Array(arguments.length - 2);
for (i = 2; i < arguments.length; i++) {
args[i - 2] = arguments[i];
}
for (var foundCaller = !1, ctor = me.constructor; ctor; ctor = ctor.superClass_ && ctor.superClass_.constructor) {
if (ctor.prototype[opt_methodName] === caller) {
foundCaller = !0;
} else {
if (foundCaller) {
return ctor.prototype[opt_methodName].apply(me, args);
}
}
}
if (me[opt_methodName] === caller) {
return me.constructor.prototype[opt_methodName].apply(me, args);
}
throw Error("goog.base called from a method of one name to a method of a different name");
};
goog.scope = function(fn) {
if (goog.isInModuleLoader_()) {
throw Error("goog.scope is not supported within a module.");
}
fn.call(goog.global);
};
goog.defineClass = function(superClass, def) {
var constructor = def.constructor, statics = def.statics;
constructor && constructor != Object.prototype.constructor || (constructor = function() {
throw Error("cannot instantiate an interface (no constructor defined).");
});
var cls = goog.defineClass.createSealingConstructor_(constructor, superClass);
superClass && goog.inherits(cls, superClass);
delete def.constructor;
delete def.statics;
goog.defineClass.applyProperties_(cls.prototype, def);
null != statics && (statics instanceof Function ? statics(cls) : goog.defineClass.applyProperties_(cls, statics));
return cls;
};
goog.defineClass.SEAL_CLASS_INSTANCES = goog.DEBUG;
goog.defineClass.createSealingConstructor_ = function(ctr, superClass) {
if (!goog.defineClass.SEAL_CLASS_INSTANCES) {
return ctr;
}
var superclassSealable = !goog.defineClass.isUnsealable_(superClass), wrappedCtr = function() {
var instance = ctr.apply(this, arguments) || this;
instance[goog.UID_PROPERTY_] = instance[goog.UID_PROPERTY_];
this.constructor === wrappedCtr && superclassSealable && Object.seal instanceof Function && Object.seal(instance);
return instance;
};
return wrappedCtr;
};
goog.defineClass.isUnsealable_ = function(ctr) {
return ctr && ctr.prototype && ctr.prototype[goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_];
};
goog.defineClass.OBJECT_PROTOTYPE_FIELDS_ = "constructor hasOwnProperty isPrototypeOf propertyIsEnumerable toLocaleString toString valueOf".split(" ");
goog.defineClass.applyProperties_ = function(target, source) {
for (var key in source) {
Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
}
for (var i = 0; i < goog.defineClass.OBJECT_PROTOTYPE_FIELDS_.length; i++) {
key = goog.defineClass.OBJECT_PROTOTYPE_FIELDS_[i], Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
}
};
goog.tagUnsealableClass = function() {
};
goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_ = "goog_defineClass_legacy_unsealable";
goog.TRUSTED_TYPES_POLICY_NAME = "";
goog.identity_ = function(s) {
return s;
};
goog.createTrustedTypesPolicy = function(name) {
return "undefined" !== typeof TrustedTypes && TrustedTypes.createPolicy ? TrustedTypes.createPolicy(name, {createHTML:goog.identity_, createScript:goog.identity_, createScriptURL:goog.identity_, createURL:goog.identity_}) : null;
};
goog.TRUSTED_TYPES_POLICY_ = goog.TRUSTED_TYPES_POLICY_NAME ? goog.createTrustedTypesPolicy(goog.TRUSTED_TYPES_POLICY_NAME + "#base") : null;
goog.debug = {};
goog.debug.Error = function(opt_msg) {
if (Error.captureStackTrace) {
Error.captureStackTrace(this, goog.debug.Error);
} else {
var stack = Error().stack;
stack && (this.stack = stack);
}
opt_msg && (this.message = String(opt_msg));
};
goog.inherits(goog.debug.Error, Error);
goog.debug.Error.prototype.name = "CustomError";
goog.dom = {};
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};
goog.asserts = {};
goog.asserts.ENABLE_ASSERTS = goog.DEBUG;
goog.asserts.AssertionError = function(messagePattern, messageArgs) {
goog.debug.Error.call(this, goog.asserts.subs_(messagePattern, messageArgs));
};
goog.inherits(goog.asserts.AssertionError, goog.debug.Error);
goog.asserts.AssertionError.prototype.name = "AssertionError";
goog.asserts.DEFAULT_ERROR_HANDLER = function(e) {
throw e;
};
goog.asserts.errorHandler_ = goog.asserts.DEFAULT_ERROR_HANDLER;
goog.asserts.subs_ = function(pattern, subs) {
for (var splitParts = pattern.split("%s"), returnString = "", subLast = splitParts.length - 1, i = 0; i < subLast; i++) {
returnString += splitParts[i] + (i < subs.length ? subs[i] : "%s");
}
return returnString + splitParts[subLast];
};
goog.asserts.doAssertFailure_ = function(defaultMessage, defaultArgs, givenMessage, givenArgs) {
var message = "Assertion failed";
if (givenMessage) {
message += ": " + givenMessage;
var args = givenArgs;
} else {
defaultMessage && (message += ": " + defaultMessage, args = defaultArgs);
}
var e = new goog.asserts.AssertionError("" + message, args || []);
goog.asserts.errorHandler_(e);
};
goog.asserts.setErrorHandler = function(errorHandler) {
goog.asserts.ENABLE_ASSERTS && (goog.asserts.errorHandler_ = errorHandler);
};
goog.asserts.assert = function(condition, opt_message, var_args) {
goog.asserts.ENABLE_ASSERTS && !condition && goog.asserts.doAssertFailure_("", null, opt_message, Array.prototype.slice.call(arguments, 2));
return condition;
};
goog.asserts.fail = function(opt_message, var_args) {
goog.asserts.ENABLE_ASSERTS && goog.asserts.errorHandler_(new goog.asserts.AssertionError("Failure" + (opt_message ? ": " + opt_message : ""), Array.prototype.slice.call(arguments, 1)));
};
goog.asserts.assertNumber = function(value, opt_message, var_args) {
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));
return value;
};
goog.asserts.assertString = function(value, opt_message, var_args) {
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));
return value;
};
goog.asserts.assertFunction = function(value, opt_message, var_args) {
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));
return value;
};
goog.asserts.assertObject = function(value, opt_message, var_args) {
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));
return value;
};
goog.asserts.assertArray = function(value, opt_message, var_args) {
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));
return value;
};
goog.asserts.assertBoolean = function(value, opt_message, var_args) {
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));
return value;
};
goog.asserts.assertElement = function(value, opt_message, var_args) {
!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));
return value;
};
goog.asserts.assertInstanceof = function(value, type, opt_message, var_args) {
!goog.asserts.ENABLE_ASSERTS || value instanceof type || goog.asserts.doAssertFailure_("Expected instanceof %s but got %s.", [goog.asserts.getType_(type), goog.asserts.getType_(value)], opt_message, Array.prototype.slice.call(arguments, 3));
return value;
};
goog.asserts.assertFinite = function(value, opt_message, var_args) {
!goog.asserts.ENABLE_ASSERTS || "number" == typeof value && isFinite(value) || goog.asserts.doAssertFailure_("Expected %s to be a finite number but it is not.", [value], opt_message, Array.prototype.slice.call(arguments, 2));
return value;
};
goog.asserts.assertObjectPrototypeIsIntact = function() {
for (var key in Object.prototype) {
goog.asserts.fail(key + " should not be enumerable in Object.prototype.");
}
};
goog.asserts.getType_ = function(value) {
return value instanceof Function ? value.displayName || value.name || "unknown type name" : value instanceof Object ? value.constructor.displayName || value.constructor.name || Object.prototype.toString.call(value) : null === value ? "null" : typeof value;
};
goog.array = {};
goog.NATIVE_ARRAY_PROTOTYPES = goog.TRUSTED_SITE;
goog.array.ASSUME_NATIVE_FUNCTIONS = !1;
goog.array.peek = function(array) {
return array[array.length - 1];
};
goog.array.last = goog.array.peek;
goog.array.indexOf = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.indexOf) ? function(arr, obj, opt_fromIndex) {
goog.asserts.assert(null != arr.length);
return Array.prototype.indexOf.call(arr, obj, opt_fromIndex);
} : function(arr, obj, opt_fromIndex) {
var fromIndex = null == opt_fromIndex ? 0 : 0 > opt_fromIndex ? Math.max(0, arr.length + opt_fromIndex) : opt_fromIndex;
if (goog.isString(arr)) {
return goog.isString(obj) && 1 == obj.length ? arr.indexOf(obj, fromIndex) : -1;
}
for (var i = fromIndex; i < arr.length; i++) {
if (i in arr && arr[i] === obj) {
return i;
}
}
return -1;
};
goog.array.lastIndexOf = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.lastIndexOf) ? function(arr, obj, opt_fromIndex) {
goog.asserts.assert(null != arr.length);
return Array.prototype.lastIndexOf.call(arr, obj, null == opt_fromIndex ? arr.length - 1 : opt_fromIndex);
} : function(arr, obj, opt_fromIndex) {
var fromIndex = null == opt_fromIndex ? arr.length - 1 : opt_fromIndex;
0 > fromIndex && (fromIndex = Math.max(0, arr.length + fromIndex));
if (goog.isString(arr)) {
return goog.isString(obj) && 1 == obj.length ? arr.lastIndexOf(obj, fromIndex) : -1;
}
for (var i = fromIndex; 0 <= i; i--) {
if (i in arr && arr[i] === obj) {
return i;
}
}
return -1;
};
goog.array.forEach = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.forEach) ? function(arr, f, opt_obj) {
goog.asserts.assert(null != arr.length);
Array.prototype.forEach.call(arr, f, opt_obj);
} : function(arr, f, opt_obj) {
for (var l = arr.length, arr2 = goog.isString(arr) ? arr.split("") : arr, i = 0; i < l; i++) {
i in arr2 && f.call(opt_obj, arr2[i], i, arr);
}
};
goog.array.forEachRight = function(arr, f, opt_obj) {
for (var l = arr.length, arr2 = goog.isString(arr) ? arr.split("") : arr, i = l - 1; 0 <= i; --i) {
i in arr2 && f.call(opt_obj, arr2[i], i, arr);
}
};
goog.array.filter = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.filter) ? function(arr, f, opt_obj) {
goog.asserts.assert(null != arr.length);
return Array.prototype.filter.call(arr, f, opt_obj);
} : function(arr, f, opt_obj) {
for (var l = arr.length, res = [], resLength = 0, arr2 = goog.isString(arr) ? arr.split("") : arr, i = 0; i < l; i++) {
if (i in arr2) {
var val = arr2[i];
f.call(opt_obj, val, i, arr) && (res[resLength++] = val);
}
}
return res;
};
goog.array.map = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.map) ? function(arr, f, opt_obj) {
goog.asserts.assert(null != arr.length);
return Array.prototype.map.call(arr, f, opt_obj);
} : function(arr, f, opt_obj) {
for (var l = arr.length, res = Array(l), arr2 = goog.isString(arr) ? arr.split("") : arr, i = 0; i < l; i++) {
i in arr2 && (res[i] = f.call(opt_obj, arr2[i], i, arr));
}
return res;
};
goog.array.reduce = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.reduce) ? function(arr, f, val, opt_obj) {
goog.asserts.assert(null != arr.length);
opt_obj && (f = goog.bind(f, opt_obj));
return Array.prototype.reduce.call(arr, f, val);
} : function(arr, f, val$jscomp$0, opt_obj) {
var rval = val$jscomp$0;
goog.array.forEach(arr, function(val, index) {
rval = f.call(opt_obj, rval, val, index, arr);
});
return rval;
};
goog.array.reduceRight = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.reduceRight) ? function(arr, f, val, opt_obj) {
goog.asserts.assert(null != arr.length);
goog.asserts.assert(null != f);
opt_obj && (f = goog.bind(f, opt_obj));
return Array.prototype.reduceRight.call(arr, f, val);
} : function(arr, f, val$jscomp$0, opt_obj) {
var rval = val$jscomp$0;
goog.array.forEachRight(arr, function(val, index) {
rval = f.call(opt_obj, rval, val, index, arr);
});
return rval;
};
goog.array.some = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.some) ? function(arr, f, opt_obj) {
goog.asserts.assert(null != arr.length);
return Array.prototype.some.call(arr, f, opt_obj);
} : function(arr, f, opt_obj) {
for (var l = arr.length, arr2 = goog.isString(arr) ? arr.split("") : arr, i = 0; i < l; i++) {
if (i in arr2 && f.call(opt_obj, arr2[i], i, arr)) {
return !0;
}
}
return !1;
};
goog.array.every = goog.NATIVE_ARRAY_PROTOTYPES && (goog.array.ASSUME_NATIVE_FUNCTIONS || Array.prototype.every) ? function(arr, f, opt_obj) {
goog.asserts.assert(null != arr.length);
return Array.prototype.every.call(arr, f, opt_obj);
} : function(arr, f, opt_obj) {
for (var l = arr.length, arr2 = goog.isString(arr) ? arr.split("") : arr, i = 0; i < l; i++) {
if (i in arr2 && !f.call(opt_obj, arr2[i], i, arr)) {
return !1;
}
}
return !0;
};
goog.array.count = function(arr$jscomp$0, f, opt_obj) {
var count = 0;
goog.array.forEach(arr$jscomp$0, function(element, index, arr) {
f.call(opt_obj, element, index, arr) && ++count;
}, opt_obj);
return count;
};
goog.array.find = function(arr, f, opt_obj) {
var i = goog.array.findIndex(arr, f, opt_obj);
return 0 > i ? null : goog.isString(arr) ? arr.charAt(i) : arr[i];
};
goog.array.findIndex = function(arr, f, opt_obj) {
for (var l = arr.length, arr2 = goog.isString(arr) ? arr.split("") : arr, i = 0; i < l; i++) {
if (i in arr2 && f.call(opt_obj, arr2[i], i, arr)) {
return i;
}
}
return -1;
};
goog.array.findRight = function(arr, f, opt_obj) {
var i = goog.array.findIndexRight(arr, f, opt_obj);
return 0 > i ? null : goog.isString(arr) ? arr.charAt(i) : arr[i];
};
goog.array.findIndexRight = function(arr, f, opt_obj) {
for (var l = arr.length, arr2 = goog.isString(arr) ? arr.split("") : arr, i = l - 1; 0 <= i; i--) {
if (i in arr2 && f.call(opt_obj, arr2[i], i, arr)) {
return i;
}
}
return -1;
};
goog.array.contains = function(arr, obj) {
return 0 <= goog.array.indexOf(arr, obj);
};
goog.array.isEmpty = function(arr) {
return 0 == arr.length;
};
goog.array.clear = function(arr) {
if (!goog.isArray(arr)) {
for (var i = arr.length - 1; 0 <= i; i--) {
delete arr[i];
}
}
arr.length = 0;
};
goog.array.insert = function(arr, obj) {
goog.array.contains(arr, obj) || arr.push(obj);
};
goog.array.insertAt = function(arr, obj, opt_i) {
goog.array.splice(arr, opt_i, 0, obj);
};
goog.array.insertArrayAt = function(arr, elementsToAdd, opt_i) {
goog.partial(goog.array.splice, arr, opt_i, 0).apply(null, elementsToAdd);
};
goog.array.insertBefore = function(arr, obj, opt_obj2) {
var i;
2 == arguments.length || 0 > (i = goog.array.indexOf(arr, opt_obj2)) ? arr.push(obj) : goog.array.insertAt(arr, obj, i);
};
goog.array.remove = function(arr, obj) {
var i = goog.array.indexOf(arr, obj), rv;
(rv = 0 <= i) && goog.array.removeAt(arr, i);
return rv;
};
goog.array.removeLast = function(arr, obj) {
var i = goog.array.lastIndexOf(arr, obj);
return 0 <= i ? (goog.array.removeAt(arr, i), !0) : !1;
};
goog.array.removeAt = function(arr, i) {
goog.asserts.assert(null != arr.length);
return 1 == Array.prototype.splice.call(arr, i, 1).length;
};
goog.array.removeIf = function(arr, f, opt_obj) {
var i = goog.array.findIndex(arr, f, opt_obj);
return 0 <= i ? (goog.array.removeAt(arr, i), !0) : !1;
};
goog.array.removeAllIf = function(arr, f, opt_obj) {
var removedCount = 0;
goog.array.forEachRight(arr, function(val, index) {
f.call(opt_obj, val, index, arr) && goog.array.removeAt(arr, index) && removedCount++;
});
return removedCount;
};
goog.array.concat = function(var_args) {
return Array.prototype.concat.apply([], arguments);
};
goog.array.join = function(var_args) {
return Array.prototype.concat.apply([], arguments);
};
goog.array.toArray = function(object) {
var length = object.length;
if (0 < length) {
for (var rv = Array(length), i = 0; i < length; i++) {
rv[i] = object[i];
}
return rv;
}
return [];
};
goog.array.clone = goog.array.toArray;
goog.array.extend = function(arr1, var_args) {
for (var i = 1; i < arguments.length; i++) {
var arr2 = arguments[i];
if (goog.isArrayLike(arr2)) {
var len1 = arr1.length || 0, len2 = arr2.length || 0;
arr1.length = len1 + len2;
for (var j = 0; j < len2; j++) {
arr1[len1 + j] = arr2[j];
}
} else {
arr1.push(arr2);
}
}
};
goog.array.splice = function(arr, index, howMany, var_args) {
goog.asserts.assert(null != arr.length);
return Array.prototype.splice.apply(arr, goog.array.slice(arguments, 1));
};
goog.array.slice = function(arr, start, opt_end) {
goog.asserts.assert(null != arr.length);
return 2 >= arguments.length ? Array.prototype.slice.call(arr, start) : Array.prototype.slice.call(arr, start, opt_end);
};
goog.array.removeDuplicates = function(arr, opt_rv, opt_hashFn) {
for (var returnArray = opt_rv || arr, defaultHashFn = function(item) {
return goog.isObject(item) ? "o" + goog.getUid(item) : (typeof item).charAt(0) + item;
}, hashFn = opt_hashFn || defaultHashFn, seen = {}, cursorInsert = 0, cursorRead = 0; cursorRead < arr.length;) {
var current = arr[cursorRead++], key = hashFn(current);
Object.prototype.hasOwnProperty.call(seen, key) || (seen[key] = !0, returnArray[cursorIn