gis-api
Version:
GIS API for DHIS 2 based on Leaflet
1,184 lines • 585 kB
JavaScript
var goog = goog || {};
goog.global = this;
goog.isDef = function(val) {
return void 0 !== val;
};
goog.exportPath_ = function(name, opt_object, opt_objectToExportTo) {
var parts = name.split("."), cur = opt_objectToExportTo || goog.global;
parts[0] in cur || !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] : cur[part] = {};
}
};
goog.define = function(name, defaultValue) {
goog.exportPath_(name, defaultValue);
};
goog.DEBUG = !0;
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 can not be used within a goog.module.");
}
goog.constructNamespace_(name);
};
goog.constructNamespace_ = function(name, opt_obj) {
var namespace;
goog.exportPath_(name, opt_obj);
};
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.isInModuleLoader_()) {
throw Error("Module " + name + " has been loaded incorrectly.");
}
if (goog.moduleLoaderState_.moduleName) {
throw Error("goog.module may only be called once per module.");
}
goog.moduleLoaderState_.moduleName = name;
};
goog.module.get = function(name) {
return goog.module.getInternal_(name);
};
goog.module.getInternal_ = function(name) {
};
goog.moduleLoaderState_ = null;
goog.isInModuleLoader_ = function() {
return null != goog.moduleLoaderState_;
};
goog.module.declareLegacyNamespace = function() {
goog.moduleLoaderState_.declareLegacyNamespace = !0;
};
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(name) {
};
goog.getObjectByName = function(name, opt_obj) {
for (var parts = name.split("."), cur = opt_obj || goog.global, part;part = parts.shift();) {
if (goog.isDefAndNotNull(cur[part])) {
cur = cur[part];
} else {
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(relPath, provides, requires, opt_loadFlags) {
if (goog.DEPENDENCIES_ENABLED) {
var provide, require, path = relPath.replace(/\\/g, "/"), deps = goog.dependencies_;
opt_loadFlags && "boolean" !== typeof opt_loadFlags || (opt_loadFlags = opt_loadFlags ? {module:"goog"} : {});
for (var i = 0;provide = provides[i];i++) {
deps.nameToPath[provide] = path, deps.loadFlags[path] = opt_loadFlags;
}
for (var j = 0;require = requires[j];j++) {
path in deps.requires || (deps.requires[path] = {}), deps.requires[path][require] = !0;
}
}
};
goog.useStrictRequires = !1;
goog.ENABLE_DEBUG_LOADER = !0;
goog.logToConsole_ = function(msg) {
goog.global.console && goog.global.console.error(msg);
};
goog.require = function(name) {
var errorMessage, path;
};
goog.basePath = "";
goog.nullFunction = function() {
};
goog.abstractMethod = function() {
throw Error("unimplemented abstract method");
};
goog.addSingletonGetter = function(ctor) {
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.TRANSPILER = "transpile.js";
goog.DEPENDENCIES_ENABLED && (goog.dependencies_ = {loadFlags:{}, nameToPath:{}, requires:{}, visited:{}, written:{}, deferred:{}}, goog.inHtmlDocument_ = function() {
var doc = goog.global.document;
return null != doc && "write" in doc;
}, goog.findBasePath_ = function() {
if (goog.isDef(goog.global.CLOSURE_BASE_PATH)) {
goog.basePath = goog.global.CLOSURE_BASE_PATH;
} else {
if (goog.inHtmlDocument_()) {
for (var scripts = goog.global.document.getElementsByTagName("SCRIPT"), i = scripts.length - 1;0 <= i;--i) {
var src = scripts[i].src, qmark = src.lastIndexOf("?"), l = -1 == qmark ? src.length : qmark;
if ("base.js" == src.substr(l - 7, 7)) {
goog.basePath = src.substr(0, l - 7);
break;
}
}
}
}
}, goog.importScript_ = function(src, opt_sourceText) {
(goog.global.CLOSURE_IMPORT_SCRIPT || goog.writeScriptTag_)(src, opt_sourceText) && (goog.dependencies_.written[src] = !0);
}, goog.IS_OLD_IE_ = !(goog.global.atob || !goog.global.document || !goog.global.document.all), goog.importProcessedScript_ = function(src, isModule, needsTranspile) {
goog.importScript_("", 'goog.retrieveAndExec_("' + src + '", ' + isModule + ", " + needsTranspile + ");");
}, goog.queuedModules_ = [], goog.wrapModule_ = function(srcUrl, scriptText) {
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";
}, goog.loadQueuedModules_ = function() {
var count = goog.queuedModules_.length;
if (0 < count) {
var queue = goog.queuedModules_;
goog.queuedModules_ = [];
for (var i = 0;i < count;i++) {
goog.maybeProcessDeferredPath_(queue[i]);
}
}
}, goog.maybeProcessDeferredDep_ = function(name) {
goog.isDeferredModule_(name) && goog.allDepsAreAvailable_(name) && goog.maybeProcessDeferredPath_(goog.basePath + goog.getPathFromDeps_(name));
}, goog.isDeferredModule_ = function(name) {
var path = goog.getPathFromDeps_(name), loadFlags = path && goog.dependencies_.loadFlags[path] || {};
return path && ("goog" == loadFlags.module || goog.needsTranspile_(loadFlags.lang)) ? goog.basePath + path in goog.dependencies_.deferred : !1;
}, goog.allDepsAreAvailable_ = function(name) {
var path = goog.getPathFromDeps_(name);
if (path && path in goog.dependencies_.requires) {
for (var requireName in goog.dependencies_.requires[path]) {
if (!goog.isProvided_(requireName) && !goog.isDeferredModule_(requireName)) {
return !1;
}
}
}
return !0;
}, goog.maybeProcessDeferredPath_ = function(abspath) {
if (abspath in goog.dependencies_.deferred) {
var src = goog.dependencies_.deferred[abspath];
delete goog.dependencies_.deferred[abspath];
goog.globalEval(src);
}
}, goog.loadModuleFromUrl = function(url) {
}, goog.writeScriptSrcNode_ = function(src) {
goog.global.document.write('<script type="text/javascript" src="' + src + '">\x3c/script>');
}, goog.appendScriptSrcNode_ = function(src) {
var doc = goog.global.document, scriptEl = doc.createElement("script");
scriptEl.type = "text/javascript";
scriptEl.src = src;
scriptEl.defer = !1;
scriptEl.async = !1;
doc.head.appendChild(scriptEl);
}, goog.writeScriptTag_ = function(src, opt_sourceText) {
if (goog.inHtmlDocument_()) {
var doc = goog.global.document;
if (!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING && "complete" == doc.readyState) {
if (/\bdeps.js$/.test(src)) {
return !1;
}
throw Error('Cannot write "' + src + '" after document load');
}
if (void 0 === opt_sourceText) {
if (goog.IS_OLD_IE_) {
var state = " onreadystatechange='goog.onScriptLoad_(this, " + ++goog.lastNonModuleScriptIndex_ + ")' ";
doc.write('<script type="text/javascript" src="' + src + '"' + state + ">\x3c/script>");
} else {
goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING ? goog.appendScriptSrcNode_(src) : goog.writeScriptSrcNode_(src);
}
} else {
doc.write('<script type="text/javascript">' + opt_sourceText + "\x3c/script>");
}
return !0;
}
return !1;
}, goog.needsTranspile_ = function(lang) {
if ("always" == goog.TRANSPILE) {
return !0;
}
if ("never" == goog.TRANSPILE) {
return !1;
}
if (!goog.transpiledLanguages_) {
goog.transpiledLanguages_ = {es5:!0, es6:!0, "es6-impl":!0};
try {
goog.transpiledLanguages_.es5 = eval("[1,].length!=1"), eval('(()=>{"use strict";let a={};const X=class{constructor(){}x(z){return new Map([...arguments]).get(z[0])==3}};return new X().x([a,3])})()') && (goog.transpiledLanguages_["es6-impl"] = !1), eval('(()=>{"use strict";class X{constructor(){if(new.target!=String)throw 1;this.x=42}}let q=Reflect.construct(X,[],String);if(q.x!=42||!(q instanceof String))throw 1;for(const a of[2,3]){if(a==2)continue;function f(z={a}){let a=0;return z.a}{function f(){return 0;}}return f()==3}})()') &&
(goog.transpiledLanguages_.es6 = !1);
} catch (err) {
}
}
return !!goog.transpiledLanguages_[lang];
}, goog.transpiledLanguages_ = null, goog.lastNonModuleScriptIndex_ = 0, goog.onScriptLoad_ = function(script, scriptIndex) {
"complete" == script.readyState && goog.lastNonModuleScriptIndex_ == scriptIndex && goog.loadQueuedModules_();
return !0;
}, goog.writeScripts_ = function(pathToLoad) {
function visitNode(path) {
if (!(path in deps.written || path in deps.visited)) {
deps.visited[path] = !0;
if (path in deps.requires) {
for (var requireName in deps.requires[path]) {
if (!goog.isProvided_(requireName)) {
if (requireName in deps.nameToPath) {
visitNode(deps.nameToPath[requireName]);
} else {
throw Error("Undefined nameToPath for " + requireName);
}
}
}
}
path in seenScript || (seenScript[path] = !0, scripts.push(path));
}
}
var scripts = [], seenScript = {}, deps = goog.dependencies_;
visitNode(pathToLoad);
for (var i = 0;i < scripts.length;i++) {
var path$$0 = scripts[i];
goog.dependencies_.written[path$$0] = !0;
}
var moduleState = goog.moduleLoaderState_;
goog.moduleLoaderState_ = null;
for (i = 0;i < scripts.length;i++) {
if (path$$0 = scripts[i]) {
var loadFlags = deps.loadFlags[path$$0] || {}, needsTranspile = goog.needsTranspile_(loadFlags.lang);
"goog" == loadFlags.module || needsTranspile ? goog.importProcessedScript_(goog.basePath + path$$0, "goog" == loadFlags.module, needsTranspile) : goog.importScript_(goog.basePath + path$$0);
} else {
throw goog.moduleLoaderState_ = moduleState, Error("Undefined script input");
}
}
goog.moduleLoaderState_ = moduleState;
}, goog.getPathFromDeps_ = function(rule) {
return rule in goog.dependencies_.nameToPath ? goog.dependencies_.nameToPath[rule] : null;
}, goog.findBasePath_(), goog.global.CLOSURE_NO_DEPS || goog.importScript_(goog.basePath + "deps.js"));
goog.loadModule = function(moduleDef) {
var previousState = goog.moduleLoaderState_;
try {
goog.moduleLoaderState_ = {moduleName:void 0, declareLegacyNamespace:!1};
var exports;
if (goog.isFunction(moduleDef)) {
exports = moduleDef.call(void 0, {});
} else {
if (goog.isString(moduleDef)) {
exports = goog.loadModuleFromSource_.call(void 0, moduleDef);
} else {
throw Error("Invalid module definition");
}
}
var moduleName = goog.moduleLoaderState_.moduleName;
if (!goog.isString(moduleName) || !moduleName) {
throw Error('Invalid module name "' + moduleName + '"');
}
goog.moduleLoaderState_.declareLegacyNamespace ? goog.constructNamespace_(moduleName, exports) : goog.SEAL_MODULE_EXPORTS && Object.seal && goog.isObject(exports) && Object.seal(exports);
goog.loadedModules_[moduleName] = exports;
} 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.retrieveAndExec_ = function(src, isModule, needsTranspile) {
var scriptText, importScript, originalPath;
};
goog.transpile_ = function(code$$0, path$$0) {
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);
transpilerCode && (eval(transpilerCode + "\n//# sourceURL=" + transpilerPath), jscomp = goog.global.$jscomp, transpile = jscomp.transpile);
}
if (!transpile) {
var suffix = " requires transpilation but no transpiler was found.", suffix = 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$$0, path$$0);
};
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.isString = function(val) {
return "string" == typeof val;
};
goog.isBoolean = function(val) {
return "boolean" == typeof val;
};
goog.isNumber = function(val) {
return "number" == typeof val;
};
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 (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_) {
if (goog.global.eval("var _evalTest_ = 1;"), "undefined" != typeof goog.global._evalTest_) {
try {
delete goog.global._evalTest_;
} catch (ignore) {
}
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.body.appendChild(scriptElt);
doc.body.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("-");
}, rename;
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, b) {
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 (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);
}
for (var args = Array(arguments.length - 2), 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 goog.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(ctr) {
};
goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_ = "goog_defineClass_legacy_unsealable";
goog.disposable = {};
goog.disposable.IDisposable = function() {
};
goog.Disposable = function() {
goog.Disposable.MONITORING_MODE != goog.Disposable.MonitoringMode.OFF && (goog.Disposable.INCLUDE_STACK_ON_CREATION && (this.creationStack = Error().stack), goog.Disposable.instances_[goog.getUid(this)] = this);
this.disposed_ = this.disposed_;
this.onDisposeCallbacks_ = this.onDisposeCallbacks_;
};
goog.Disposable.MonitoringMode = {OFF:0, PERMANENT:1, INTERACTIVE:2};
goog.Disposable.MONITORING_MODE = 0;
goog.Disposable.INCLUDE_STACK_ON_CREATION = !0;
goog.Disposable.instances_ = {};
goog.Disposable.getUndisposedObjects = function() {
var ret = [], id;
for (id in goog.Disposable.instances_) {
goog.Disposable.instances_.hasOwnProperty(id) && ret.push(goog.Disposable.instances_[Number(id)]);
}
return ret;
};
goog.Disposable.clearUndisposedObjects = function() {
goog.Disposable.instances_ = {};
};
goog.Disposable.prototype.disposed_ = !1;
goog.Disposable.prototype.isDisposed = function() {
return this.disposed_;
};
goog.Disposable.prototype.getDisposed = goog.Disposable.prototype.isDisposed;
goog.Disposable.prototype.dispose = function() {
if (!this.disposed_ && (this.disposed_ = !0, this.disposeInternal(), goog.Disposable.MONITORING_MODE != goog.Disposable.MonitoringMode.OFF)) {
var uid = goog.getUid(this);
if (goog.Disposable.MONITORING_MODE == goog.Disposable.MonitoringMode.PERMANENT && !goog.Disposable.instances_.hasOwnProperty(uid)) {
throw Error(this + " did not call the goog.Disposable base constructor or was disposed of after a clearUndisposedObjects call");
}
delete goog.Disposable.instances_[uid];
}
};
goog.Disposable.prototype.registerDisposable = function(disposable) {
this.addOnDisposeCallback(goog.partial(goog.dispose, disposable));
};
goog.Disposable.prototype.addOnDisposeCallback = function(callback, opt_scope) {
this.disposed_ ? goog.isDef(opt_scope) ? callback.call(opt_scope) : callback() : (this.onDisposeCallbacks_ || (this.onDisposeCallbacks_ = []), this.onDisposeCallbacks_.push(goog.isDef(opt_scope) ? goog.bind(callback, opt_scope) : callback));
};
goog.Disposable.prototype.disposeInternal = function() {
if (this.onDisposeCallbacks_) {
for (;this.onDisposeCallbacks_.length;) {
this.onDisposeCallbacks_.shift()();
}
}
};
goog.Disposable.isDisposed = function(obj) {
return obj && "function" == typeof obj.isDisposed ? obj.isDisposed() : !1;
};
goog.dispose = function(obj) {
obj && "function" == typeof obj.dispose && obj.dispose();
};
goog.disposeAll = function(var_args) {
for (var i = 0, len = arguments.length;i < len;++i) {
var disposable = arguments[i];
goog.isArrayLike(disposable) ? goog.disposeAll.apply(null, disposable) : goog.dispose(disposable);
}
};
goog.events = {};
goog.events.EventId = function(eventId) {
this.id = eventId;
};
goog.events.EventId.prototype.toString = function() {
return this.id;
};
goog.events.Event = function(type, opt_target) {
this.type = type instanceof goog.events.EventId ? String(type) : type;
this.currentTarget = this.target = opt_target;
this.defaultPrevented = this.propagationStopped_ = !1;
this.returnValue_ = !0;
};
goog.events.Event.prototype.stopPropagation = function() {
this.propagationStopped_ = !0;
};
goog.events.Event.prototype.preventDefault = function() {
this.defaultPrevented = !0;
this.returnValue_ = !1;
};
goog.events.Event.stopPropagation = function(e) {
e.stopPropagation();
};
goog.events.Event.preventDefault = function(e) {
e.preventDefault();
};
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));
this.reportErrorToServer = !0;
};
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.string = {};
goog.string.DETECT_DOUBLE_ESCAPING = !1;
goog.string.FORCE_NON_DOM_HTML_UNESCAPING = !1;
goog.string.Unicode = {NBSP:"\u00a0"};
goog.string.startsWith = function(str, prefix) {
return 0 == str.lastIndexOf(prefix, 0);
};
goog.string.endsWith = function(str, suffix) {
var l = str.length - suffix.length;
return 0 <= l && str.indexOf(suffix, l) == l;
};
goog.string.caseInsensitiveStartsWith = function(str, prefix) {
return 0 == goog.string.caseInsensitiveCompare(prefix, str.substr(0, prefix.length));
};
goog.string.caseInsensitiveEndsWith = function(str, suffix) {
return 0 == goog.string.caseInsensitiveCompare(suffix, str.substr(str.length - suffix.length, suffix.length));
};
goog.string.caseInsensitiveEquals = function(str1, str2) {
return str1.toLowerCase() == str2.toLowerCase();
};
goog.string.subs = function(str, var_args) {
for (var splitParts = str.split("%s"), returnString = "", subsArguments = Array.prototype.slice.call(arguments, 1);subsArguments.length && 1 < splitParts.length;) {
returnString += splitParts.shift() + subsArguments.shift();
}
return returnString + splitParts.join("%s");
};
goog.string.collapseWhitespace = function(str) {
return str.replace(/[\s\xa0]+/g, " ").replace(/^\s+|\s+$/g, "");
};
goog.string.isEmptyOrWhitespace = function(str) {
return /^[\s\xa0]*$/.test(str);
};
goog.string.isEmptyString = function(str) {
return 0 == str.length;
};
goog.string.isEmpty = goog.string.isEmptyOrWhitespace;
goog.string.isEmptyOrWhitespaceSafe = function(str) {
return goog.string.isEmptyOrWhitespace(goog.string.makeSafe(str));
};
goog.string.isEmptySafe = goog.string.isEmptyOrWhitespaceSafe;
goog.string.isBreakingWhitespace = function(str) {
return !/[^\t\n\r ]/.test(str);
};
goog.string.isAlpha = function(str) {
return !/[^a-zA-Z]/.test(str);
};
goog.string.isNumeric = function(str) {
return !/[^0-9]/.test(str);
};
goog.string.isAlphaNumeric = function(str) {
return !/[^a-zA-Z0-9]/.test(str);
};
goog.string.isSpace = function(ch) {
return " " == ch;
};
goog.string.isUnicodeChar = function(ch) {
return 1 == ch.length && " " <= ch && "~" >= ch || "\u0080" <= ch && "\ufffd" >= ch;
};
goog.string.stripNewlines = function(str) {
return str.replace(/(\r\n|\r|\n)+/g, " ");
};
goog.string.canonicalizeNewlines = function(str) {
return str.replace(/(\r\n|\r|\n)/g, "\n");
};
goog.string.normalizeWhitespace = function(str) {
return str.replace(/\xa0|\s/g, " ");
};
goog.string.normalizeSpaces = function(str) {
return str.replace(/\xa0|[ \t]+/g, " ");
};
goog.string.collapseBreakingSpaces = function(str) {
return str.replace(/[\t\r\n ]+/g, " ").replace(/^[\t\r\n ]+|[\t\r\n ]+$/g, "");
};
goog.string.trim = goog.TRUSTED_SITE && String.prototype.trim ? function(str) {
return str.trim();
} : function(str) {
return str.replace(/^[\s\xa0]+|[\s\xa0]+$/g, "");
};
goog.string.trimLeft = function(str) {
return str.replace(/^[\s\xa0]+/, "");
};
goog.string.trimRight = function(str) {
return str.replace(/[\s\xa0]+$/, "");
};
goog.string.caseInsensitiveCompare = function(str1, str2) {
var test1 = String(str1).toLowerCase(), test2 = String(str2).toLowerCase();
return test1 < test2 ? -1 : test1 == test2 ? 0 : 1;
};
goog.string.numberAwareCompare_ = function(str1, str2, tokenizerRegExp) {
if (str1 == str2) {
return 0;
}
if (!str1) {
return -1;
}
if (!str2) {
return 1;
}
for (var tokens1 = str1.toLowerCase().match(tokenizerRegExp), tokens2 = str2.toLowerCase().match(tokenizerRegExp), count = Math.min(tokens1.length, tokens2.length), i = 0;i < count;i++) {
var a = tokens1[i], b = tokens2[i];
if (a != b) {
var num1 = parseInt(a, 10);
if (!isNaN(num1)) {
var num2 = parseInt(b, 10);
if (!isNaN(num2) && num1 - num2) {
return num1 - num2;
}
}
return a < b ? -1 : 1;
}
}
return tokens1.length != tokens2.length ? tokens1.length - tokens2.length : str1 < str2 ? -1 : 1;
};
goog.string.intAwareCompare = function(str1, str2) {
return goog.string.numberAwareCompare_(str1, str2, /\d+|\D+/g);
};
goog.string.floatAwareCompare = function(str1, str2) {
return goog.string.numberAwareCompare_(str1, str2, /\d+|\.\d+|\D+/g);
};
goog.string.numerateCompare = goog.string.floatAwareCompare;
goog.string.urlEncode = function(str) {
return encodeURIComponent(String(str));
};
goog.string.urlDecode = function(str) {
return decodeURIComponent(str.replace(/\+/g, " "));
};
goog.string.newLineToBr = function(str, opt_xml) {
return str.replace(/(\r\n|\r|\n)/g, opt_xml ? "<br />" : "<br>");
};
goog.string.htmlEscape = function(str, opt_isLikelyToContainHtmlChars) {
if (opt_isLikelyToContainHtmlChars) {
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"));
} else {
if (!goog.string.ALL_RE_.test(str)) {
return str;
}
-1 != str.indexOf("&") && (str = str.replace(goog.string.AMP_RE_, "&"));
-1 != str.indexOf("<") && (str = str.replace(goog.string.LT_RE_, "<"));
-1 != str.indexOf(">") && (str = str.replace(goog.string.GT_RE_, ">"));
-1 != str.indexOf('"') && (str = str.replace(goog.string.QUOT_RE_, """));
-1 != str.indexOf("'") && (str = str.replace(goog.string.SINGLE_QUOTE_RE_, "'"));
-1 != str.indexOf("\x00") && (str = str.replace(goog.string.NULL_RE_, "�"));
goog.string.DETECT_DOUBLE_ESCAPING && -1 != str.indexOf("e") && (str = str.replace(goog.string.E_RE_, "e"));
}
return str;
};
goog.string.AMP_RE_ = /&/g;
goog.string.LT_RE_ = /</g;
goog.string.GT_RE_ = />/g;
goog.string.QUOT_RE_ = /"/g;
goog.string.SINGLE_QUOTE_RE_ = /'/g;
goog.string.NULL_RE_ = /\x00/g;
goog.string.E_RE_ = /e/g;
goog.string.ALL_RE_ = goog.string.DETECT_DOUBLE_ESCAPING ? /[\x00&<>"'e]/ : /[\x00&<>"']/;
goog.string.unescapeEntities = function(str) {
return goog.string.contains(str, "&") ? !goog.string.FORCE_NON_DOM_HTML_UNESCAPING && "document" in goog.global ? goog.string.unescapeEntitiesUsingDom_(str) : goog.string.unescapePureXmlEntities_(str) : str;
};
goog.string.unescapeEntitiesWithDocument = function(str, document) {
return goog.string.contains(str, "&") ? goog.string.unescapeEntitiesUsingDom_(str, document) : str;
};
goog.string.unescapeEntitiesUsingDom_ = function(str, opt_document) {
var seen = {"&":"&", "<":"<", ">":">", """:'"'}, div;
div = opt_document ? opt_document.createElement("div") : goog.global.document.createElement("div");
return str.replace(goog.string.HTML_ENTITY_PATTERN_, function(s, entity) {
var value = seen[s];
if (value) {
return value;
}
if ("#" == entity.charAt(0)) {
var n = Number("0" + entity.substr(1));
isNaN(n) || (value = String.fromCharCode(n));
}
value || (div.innerHTML = s + " ", value = div.firstChild.nodeValue.slice(0, -1));
return seen[s] = value;
});
};
goog.string.unescapePureXmlEntities_ = function(str) {
return str.replace(/&([^;]+);/g, function(s, entity) {
switch(entity) {
case "amp":
return "&";
case "lt":
return "<";
case "gt":
return ">";
case "quot":
return '"';
default:
if ("#" == entity.charAt(0)) {
var n = Number("0" + entity.substr(1));
if (!isNaN(n)) {
return String.fromCharCode(n);
}
}
return s;
}
});
};
goog.string.HTML_ENTITY_PATTERN_ = /&([^;\s<&]+);?/g;
goog.string.whitespaceEscape = function(str, opt_xml) {
return goog.string.newLineToBr(str.replace(/ /g, "  "), opt_xml);
};
goog.string.preserveSpaces = function(str) {
return str.replace(/(^|[\n ]) /g, "$1" + goog.string.Unicode.NBSP);
};
goog.string.stripQuotes = function(str, quoteChars) {
for (var length = quoteChars.length, i = 0;i < length;i++) {
var quoteChar = 1 == length ? quoteChars : quoteChars.charAt(i);
if (str.charAt(0) == quoteChar && str.charAt(str.length - 1) == quoteChar) {
return str.substring(1, str.length - 1);
}
}
return str;
};
goog.string.truncate = function(str, chars, opt_protectEscapedCharacters) {
opt_protectEscapedCharacters && (str = goog.string.unescapeEntities(str));
str.length > chars && (str = str.substring(0, chars - 3) + "...");
opt_protectEscapedCharacters && (str = goog.string.htmlEscape(str));
return str;
};
goog.string.truncateMiddle = function(str, chars, opt_protectEscapedCharacters, opt_trailingChars) {
opt_protectEscapedCharacters && (str = goog.string.unescapeEntities(str));
if (opt_trailingChars && str.length > chars) {
opt_trailingChars > chars && (opt_trailingChars = chars), str = str.substring(0, chars - opt_trailingChars) + "..." + str.substring(str.length - opt_trailingChars);
} else {
if (str.length > chars) {
var half = Math.floor(chars / 2);
str = str.substring(0, half + chars % 2) + "..." + str.substring(str.length - half);
}
}
opt_protectEscapedCharacters && (str = goog.string.htmlEscape(str));
return str;
};
goog.string.specialEscapeChars_ = {"\x00":"\\0", "\b":"\\b", "\f":"\\f", "\n":"\\n", "\r":"\\r", "\t":"\\t", "\x0B":"\\x0B", '"':'\\"', "\\":"\\\\", "<":"<"};
goog.string.jsEscapeCache_ = {"'":"\\'"};
goog.string.quote = function(s) {
s = String(s);
for (var sb = ['"'], i = 0;i < s.length;i++) {
var ch = s.charAt(i), cc = ch.charCodeAt(0);
sb[i + 1] = goog.string.specialEscapeChars_[ch] || (31 < cc && 127 > cc ? ch : goog.string.escapeChar(ch));
}
sb.push('"');
return sb.join("");
};
goog.string.escapeString = function(str) {
for (var sb = [], i = 0;i < str.length;i++) {
sb[i] = goog.string.escapeChar(str.charAt(i));
}
return sb.join("");
};
goog.string.escapeChar = function(c) {
if (c in goog.string.jsEscapeCache_) {
return goog.string.jsEscapeCache_[c];
}
if (c in goog.string.specialEscapeChars_) {
return goog.string.jsEscapeCache_[c] = goog.string.specialEscapeChars_[c];
}
var rv = c, cc = c.charCodeAt(0);
if (31 < cc && 127 > cc) {
rv = c;
} else {
if (256 > cc) {
if (rv = "\\x", 16 > cc || 256 < cc) {
rv += "0";
}
} else {
rv = "\\u", 4096 > cc && (rv += "0");
}
rv += cc.toString(16).toUpperCase();
}
return goog.string.jsEscapeCache_[c] = rv;
};
goog.string.contains = function(str, subString) {
return -1 != str.indexOf(subString);
};
goog.string.caseInsensitiveContains = function(str, subString) {
return goog.string.contains(str.toLowerCase(), subString.toLowerCase());
};
goog.string.countOf = function(s, ss) {
return s && ss ? s.split(ss).length - 1 : 0;
};
goog.string.removeAt = function(s, index, stringLength) {
var resultStr = s;
0 <= index && index < s.length && 0 < stringLength && (resultStr = s.substr(0, index) + s.substr(index + stringLength, s.length - index - stringLength));
return resultStr;
};
goog.string.remove = function(s, ss) {
var re = new RegExp(goog.string.regExpEscape(ss), "");
return s.replace(re, "");
};
goog.string.removeAll = function(s, ss) {
var re = new RegExp(goog.string.regExpEscape(ss), "g");
return s.replace(re, "");
};
goog.string.regExpEscape = function(s) {
return String(s).replace(/([-()\[\]{}+?*.$\^|,:#<!\\])/g, "\\$1").replace(/\x08/g, "\\x08");
};
goog.string.repeat = String.prototype.repeat ? function(string, length) {
return string.repeat(length);
} : function(string, length) {
return Array(length + 1).join(string);
};
goog.string.padNumber = function(num, length, opt_precision) {
var s = goog.isDef(opt_precision) ? num.toFixed(opt_precision) : String(num), index = s.indexOf(".");
-1 == index && (index = s.length);
return goog.string.repeat("0", Math.max(0, length - index)) + s;
};
goog.string.makeSafe = function(obj) {
return null == obj ? "" : String(obj);
};
goog.string.buildString = function(var_args) {
return Array.prototype.join.call(arguments, "");
};
goog.string.getRandomString = function() {
return Math.floor(2147483648 * Math.random()).toString(36) + Math.abs(Math.floor(2147483648 * Math.random()) ^ goog.now()).toString(36);
};
goog.string.compareVersions = function(version1, version2) {
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++) {
var v1Sub = v1Subs[subIdx] || "", v2Sub = v2Subs[subIdx] || "";
do {
var v1Comp = /(\d*)(\D*)(.*)/.exec(v1Sub) || ["", "", "", ""], v2Comp = /(\d*)(\D*)(.*)/.exec(v2Sub) || ["", "", "", ""];
if (0 == v1Comp[0].length && 0 == v2Comp[0].length) {
break;
}
order = goog.string.compareElements_(0 == v1Comp[1].length ? 0 : parseInt(v1Comp[1], 10), 0 == v2Comp[1].length ? 0 : parseInt(v2Comp[1], 10)) || goog.string.compareElements_(0 == v1Comp[2].length, 0 == v2Comp[2].length) || goog.string.compareElements_(v1Comp[2], v2Comp[2]);
v1Sub = v1Comp[3];
v2Sub = v2Comp[3];
} while (0 == order);
}
return order;
};
goog.string.compareElements_ = function(left, right) {
return left < right ? -1 : left > right ? 1 : 0;
};
goog.string.hashCode = function(str) {
for (var result = 0, i = 0;i < str.length;++i) {
result = 31 * result + str.charCodeAt(i) >>> 0;
}
return result;
};
goog.string.uniqueStringCounter_ = 2147483648 * Math.random() | 0;
goog.string.createUniqueString = function() {
return "goog_" + goog.string.uniqueStringCounter_++;
};
goog.string.toNumber = function(str) {
var num = Number(str);
return 0 == num && goog.string.isEmptyOrWhitespace(str) ? NaN : num;
};
goog.string.isLowerCamelCase = function(str) {
return /^[a-z]+([A-Z][a-z]*)*$/.test(str);
};
goog.string.isUpperCamelCase = function(str) {
return /^([A-Z][a-z]*)+$/.test(str);
};
goog.string.toCamelCase = function(str) {
return String(str).replace(/\-([a-z])/g, function(all, match) {
return match.toUpperCase();
});
};
goog.string.toSelectorCase = function(str) {
return String(str).replace(/([A-Z])/g, "-$1").toLowerCase();
};
goog.string.toTitleCase = function(str, opt_delimiters) {
var delimiters = goog.isString(opt_delimiters) ? goog.string.regExpEscape(opt_delimiters) : "\\s";
return str.replace(new RegExp("(^" + (delimiters ? "|[" + delimiters + "]+" : "") + ")([a-z])", "g"), function(all, p1, p2) {
return p1 + p2.toUpperCase();
});
};
goog.string.capitalize = function(str) {
return String(str.charAt(0)).toUpperCase() + String(str.substr(1)).toLowerCase();
};
goog.string.parseInt = function(value) {
isFinite(value) && (value = String(value));
return goog.isString(value) ? /^\s*-?0x/i.test(value) ? parseInt(value, 16) : parseInt(value, 10) : NaN;
};
goog.string.splitLimit = function(str, separator, limit) {
for (var parts = str.split(separator), returnVal = [];0 < limit && parts.length;) {
returnVal.push(parts.shift()), limit--;
}
parts.length && returnVal.push(parts.join(separator));
return returnVal;
};
goog.string.lastComponent = function(str, separators) {
if (separators) {
"string" == typeof separators && (separators = [separators]);
} else {
return str;
}
for (var lastSeparatorIndex = -1, i = 0;i < separators.length;i++) {
if ("" != separators[i]) {
var currentSeparatorIndex = str.lastIndexOf(separators[i]);
currentSeparatorIndex > lastSeparatorIndex && (lastSeparatorIndex = currentSeparatorIndex);
}
}
return -1 == lastSeparatorIndex ? str : str.slice(lastSeparatorIndex + 1);
};
goog.string.editDistance = function(a, b) {
var v0 = [], v1 = [];
if (a == b) {
return 0;
}
if (!a.length || !b.length) {
return Math.max(a.length, b.length);
}
for (var i = 0;i < b.length + 1;i++) {
v0[i] = i;
}
for (i = 0;i < a.length;i++) {
v1[0] = i + 1;
for (var j = 0;j < b.length;j++) {
v1[j + 1] = Math.min(v1[j] + 1, v0[j + 1] + 1, v0[j] + Number(a[i] != b[j]));
}
for (j = 0;j < v0.length;j++) {
v0[j] = v1[j];
}
}
return v1[b.length];
};
goog.asserts = {};
goog.asserts.ENABLE_ASSERTS = goog.DEBUG;
goog.asserts.AssertionError = function(messagePattern, messageArgs) {
messageArgs.unshift(messagePattern);
goog.debug.Error.call(this, goog.string.subs.apply(null, messageArgs));
messageArgs.shift();
this.messagePattern = messagePattern;
};
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.doAssertFailure_ = function(defaultMessage, defaultArgs, givenMessage, givenArgs) {
var message = "Assertion failed";
if (givenMessage) {
var message = message + (": " + givenMessage), 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 va