1 line
340 KiB
JavaScript
1 line
340 KiB
JavaScript
["^ ","~:resource-id",["~:shadow.build.classpath/resource","goog/base.js"],"~:js","var COMPILED = false;\nvar goog = goog || {};\ngoog.global = this || self;\ngoog.global.CLOSURE_UNCOMPILED_DEFINES;\ngoog.global.CLOSURE_DEFINES;\ngoog.exportPath_ = function(name, object, overwriteImplicit, objectToExportTo) {\n var parts = name.split(\".\");\n var cur = objectToExportTo || goog.global;\n if (!(parts[0] in cur) && typeof cur.execScript != \"undefined\") {\n cur.execScript(\"var \" + parts[0]);\n }\n for (var part; parts.length && (part = parts.shift());) {\n if (!parts.length && object !== undefined) {\n if (!overwriteImplicit && goog.isObject(object) && goog.isObject(cur[part])) {\n for (var prop in object) {\n if (object.hasOwnProperty(prop)) {\n cur[part][prop] = object[prop];\n }\n }\n } else {\n cur[part] = object;\n }\n } else if (cur[part] && cur[part] !== Object.prototype[part]) {\n cur = cur[part];\n } else {\n cur = cur[part] = {};\n }\n }\n};\ngoog.define = function(name, defaultValue) {\n var value = defaultValue;\n if (!COMPILED) {\n var uncompiledDefines = goog.global.CLOSURE_UNCOMPILED_DEFINES;\n var defines = goog.global.CLOSURE_DEFINES;\n if (uncompiledDefines && uncompiledDefines.nodeType === undefined && Object.prototype.hasOwnProperty.call(uncompiledDefines, name)) {\n value = uncompiledDefines[name];\n } else if (defines && defines.nodeType === undefined && Object.prototype.hasOwnProperty.call(defines, name)) {\n value = defines[name];\n }\n }\n return value;\n};\ngoog.FEATURESET_YEAR = goog.define(\"goog.FEATURESET_YEAR\", 2012);\ngoog.DEBUG = goog.define(\"goog.DEBUG\", true);\ngoog.LOCALE = goog.define(\"goog.LOCALE\", \"en\");\ngoog.TRUSTED_SITE = goog.define(\"goog.TRUSTED_SITE\", true);\ngoog.DISALLOW_TEST_ONLY_CODE = goog.define(\"goog.DISALLOW_TEST_ONLY_CODE\", COMPILED && !goog.DEBUG);\ngoog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING = goog.define(\"goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING\", false);\ngoog.provide = function(name) {\n if (goog.isInModuleLoader_()) {\n throw new Error(\"goog.provide cannot be used within a module.\");\n }\n if (!COMPILED) {\n if (goog.isProvided_(name)) {\n throw new Error('Namespace \"' + name + '\" already declared.');\n }\n }\n goog.constructNamespace_(name);\n};\ngoog.constructNamespace_ = function(name, object, overwriteImplicit) {\n if (!COMPILED) {\n delete goog.implicitNamespaces_[name];\n var namespace = name;\n while (namespace = namespace.substring(0, namespace.lastIndexOf(\".\"))) {\n if (goog.getObjectByName(namespace)) {\n break;\n }\n goog.implicitNamespaces_[namespace] = true;\n }\n }\n goog.exportPath_(name, object, overwriteImplicit);\n};\ngoog.NONCE_PATTERN_ = /^[\\w+/_-]+[=]{0,2}$/;\ngoog.getScriptNonce_ = function(opt_window) {\n var doc = (opt_window || goog.global).document;\n var script = doc.querySelector && doc.querySelector(\"script[nonce]\");\n if (script) {\n var nonce = script[\"nonce\"] || script.getAttribute(\"nonce\");\n if (nonce && goog.NONCE_PATTERN_.test(nonce)) {\n return nonce;\n }\n }\n return \"\";\n};\ngoog.VALID_MODULE_RE_ = /^[a-zA-Z_$][a-zA-Z0-9._$]*$/;\ngoog.module = function(name) {\n if (typeof name !== \"string\" || !name || name.search(goog.VALID_MODULE_RE_) == -1) {\n throw new Error(\"Invalid module identifier\");\n }\n if (!goog.isInGoogModuleLoader_()) {\n throw new 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.\");\n }\n if (goog.moduleLoaderState_.moduleName) {\n throw new Error(\"goog.module may only be called once per module.\");\n }\n goog.moduleLoaderState_.moduleName = name;\n if (!COMPILED) {\n if (goog.isProvided_(name)) {\n throw new Error('Namespace \"' + name + '\" already declared.');\n }\n delete goog.implicitNamespaces_[name];\n }\n};\ngoog.module.get = function(name) {\n return goog.module.getInternal_(name);\n};\ngoog.module.getInternal_ = function(name) {\n if (!COMPILED) {\n if (name in goog.loadedModules_) {\n return goog.loadedModules_[name].exports;\n } else if (!goog.implicitNamespaces_[name]) {\n var ns = goog.getObjectByName(name);\n return ns != null ? ns : null;\n }\n }\n return null;\n};\ngoog.ModuleType = {ES6:\"es6\", GOOG:\"goog\"};\ngoog.moduleLoaderState_ = null;\ngoog.isInModuleLoader_ = function() {\n return goog.isInGoogModuleLoader_() || goog.isInEs6ModuleLoader_();\n};\ngoog.isInGoogModuleLoader_ = function() {\n return !!goog.moduleLoaderState_ && goog.moduleLoaderState_.type == goog.ModuleType.GOOG;\n};\ngoog.isInEs6ModuleLoader_ = function() {\n var inLoader = !!goog.moduleLoaderState_ && goog.moduleLoaderState_.type == goog.ModuleType.ES6;\n if (inLoader) {\n return true;\n }\n var jscomp = goog.global[\"$jscomp\"];\n if (jscomp) {\n if (typeof jscomp.getCurrentModulePath != \"function\") {\n return false;\n }\n return !!jscomp.getCurrentModulePath();\n }\n return false;\n};\ngoog.module.declareLegacyNamespace = function() {\n if (!COMPILED && !goog.isInGoogModuleLoader_()) {\n throw new Error(\"goog.module.declareLegacyNamespace must be called from \" + \"within a goog.module\");\n }\n if (!COMPILED && !goog.moduleLoaderState_.moduleName) {\n throw new Error(\"goog.module must be called prior to \" + \"goog.module.declareLegacyNamespace.\");\n }\n goog.moduleLoaderState_.declareLegacyNamespace = true;\n};\ngoog.declareModuleId = function(namespace) {\n if (!COMPILED) {\n if (!goog.isInEs6ModuleLoader_()) {\n throw new Error(\"goog.declareModuleId may only be called from \" + \"within an ES6 module\");\n }\n if (goog.moduleLoaderState_ && goog.moduleLoaderState_.moduleName) {\n throw new Error(\"goog.declareModuleId may only be called once per module.\");\n }\n if (namespace in goog.loadedModules_) {\n throw new Error('Module with namespace \"' + namespace + '\" already exists.');\n }\n }\n if (goog.moduleLoaderState_) {\n goog.moduleLoaderState_.moduleName = namespace;\n } else {\n var jscomp = goog.global[\"$jscomp\"];\n if (!jscomp || typeof jscomp.getCurrentModulePath != \"function\") {\n throw new Error('Module with namespace \"' + namespace + '\" has been loaded incorrectly.');\n }\n var exports = jscomp.require(jscomp.getCurrentModulePath());\n goog.loadedModules_[namespace] = {exports:exports, type:goog.ModuleType.ES6, moduleId:namespace};\n }\n};\ngoog.setTestOnly = function(opt_message) {\n if (goog.DISALLOW_TEST_ONLY_CODE) {\n opt_message = opt_message || \"\";\n throw new Error(\"Importing test-only code into non-debug environment\" + (opt_message ? \": \" + opt_message : \".\"));\n }\n};\ngoog.forwardDeclare = function(name) {\n};\ngoog.forwardDeclare(\"Document\");\ngoog.forwardDeclare(\"HTMLScriptElement\");\ngoog.forwardDeclare(\"XMLHttpRequest\");\nif (!COMPILED) {\n goog.isProvided_ = function(name) {\n return name in goog.loadedModules_ || !goog.implicitNamespaces_[name] && goog.getObjectByName(name) != null;\n };\n goog.implicitNamespaces_ = {\"goog.module\":true};\n}\ngoog.getObjectByName = function(name, opt_obj) {\n var parts = name.split(\".\");\n var cur = opt_obj || goog.global;\n for (var i = 0; i < parts.length; i++) {\n cur = cur[parts[i]];\n if (cur == null) {\n return null;\n }\n }\n return cur;\n};\ngoog.addDependency = function(relPath, provides, requires, opt_loadFlags) {\n if (!COMPILED && goog.DEPENDENCIES_ENABLED) {\n goog.debugLoader_.addDependency(relPath, provides, requires, opt_loadFlags);\n }\n};\ngoog.ENABLE_DEBUG_LOADER = goog.define(\"goog.ENABLE_DEBUG_LOADER\", true);\ngoog.logToConsole_ = function(msg) {\n if (goog.global.console) {\n goog.global.console[\"error\"](msg);\n }\n};\ngoog.require = function(namespace) {\n if (!COMPILED) {\n if (goog.ENABLE_DEBUG_LOADER) {\n goog.debugLoader_.requested(namespace);\n }\n if (goog.isProvided_(namespace)) {\n if (goog.isInModuleLoader_()) {\n return goog.module.getInternal_(namespace);\n }\n } else if (goog.ENABLE_DEBUG_LOADER) {\n var moduleLoaderState = goog.moduleLoaderState_;\n goog.moduleLoaderState_ = null;\n try {\n goog.debugLoader_.load_(namespace);\n } finally {\n goog.moduleLoaderState_ = moduleLoaderState;\n }\n }\n return null;\n }\n};\ngoog.requireType = function(namespace) {\n return {};\n};\ngoog.basePath = \"\";\ngoog.global.CLOSURE_BASE_PATH;\ngoog.global.CLOSURE_NO_DEPS;\ngoog.global.CLOSURE_IMPORT_SCRIPT;\ngoog.abstractMethod = function() {\n throw new Error(\"unimplemented abstract method\");\n};\ngoog.addSingletonGetter = function(ctor) {\n ctor.instance_ = undefined;\n ctor.getInstance = function() {\n if (ctor.instance_) {\n return ctor.instance_;\n }\n if (goog.DEBUG) {\n goog.instantiatedSingletons_[goog.instantiatedSingletons_.length] = ctor;\n }\n return ctor.instance_ = new ctor();\n };\n};\ngoog.instantiatedSingletons_ = [];\ngoog.LOAD_MODULE_USING_EVAL = goog.define(\"goog.LOAD_MODULE_USING_EVAL\", true);\ngoog.SEAL_MODULE_EXPORTS = goog.define(\"goog.SEAL_MODULE_EXPORTS\", goog.DEBUG);\ngoog.loadedModules_ = {};\ngoog.DEPENDENCIES_ENABLED = !COMPILED && goog.ENABLE_DEBUG_LOADER;\ngoog.TRANSPILE = goog.define(\"goog.TRANSPILE\", \"detect\");\ngoog.ASSUME_ES_MODULES_TRANSPILED = goog.define(\"goog.ASSUME_ES_MODULES_TRANSPILED\", false);\ngoog.TRUSTED_TYPES_POLICY_NAME = goog.define(\"goog.TRUSTED_TYPES_POLICY_NAME\", \"goog\");\ngoog.hasBadLetScoping = null;\ngoog.loadModule = function(moduleDef) {\n var previousState = goog.moduleLoaderState_;\n try {\n goog.moduleLoaderState_ = {moduleName:\"\", declareLegacyNamespace:false, type:goog.ModuleType.GOOG};\n var origExports = {};\n var exports = origExports;\n if (typeof moduleDef === \"function\") {\n exports = moduleDef.call(undefined, exports);\n } else if (typeof moduleDef === \"string\") {\n exports = goog.loadModuleFromSource_.call(undefined, exports, moduleDef);\n } else {\n throw new Error(\"Invalid module definition\");\n }\n var moduleName = goog.moduleLoaderState_.moduleName;\n if (typeof moduleName === \"string\" && moduleName) {\n if (goog.moduleLoaderState_.declareLegacyNamespace) {\n var isDefaultExport = origExports !== exports;\n goog.constructNamespace_(moduleName, exports, isDefaultExport);\n } else if (goog.SEAL_MODULE_EXPORTS && Object.seal && typeof exports == \"object\" && exports != null) {\n Object.seal(exports);\n }\n var data = {exports:exports, type:goog.ModuleType.GOOG, moduleId:goog.moduleLoaderState_.moduleName};\n goog.loadedModules_[moduleName] = data;\n } else {\n throw new Error('Invalid module name \"' + moduleName + '\"');\n }\n } finally {\n goog.moduleLoaderState_ = previousState;\n }\n};\ngoog.loadModuleFromSource_ = function(exports) {\n eval(goog.CLOSURE_EVAL_PREFILTER_.createScript(arguments[1]));\n return exports;\n};\ngoog.normalizePath_ = function(path) {\n var components = path.split(\"/\");\n var i = 0;\n while (i < components.length) {\n if (components[i] == \".\") {\n components.splice(i, 1);\n } else if (i && components[i] == \"..\" && components[i - 1] && components[i - 1] != \"..\") {\n components.splice(--i, 2);\n } else {\n i++;\n }\n }\n return components.join(\"/\");\n};\ngoog.global.CLOSURE_LOAD_FILE_SYNC;\ngoog.loadFileSync_ = function(src) {\n if (goog.global.CLOSURE_LOAD_FILE_SYNC) {\n return goog.global.CLOSURE_LOAD_FILE_SYNC(src);\n } else {\n try {\n var xhr = new goog.global[\"XMLHttpRequest\"]();\n xhr.open(\"get\", src, false);\n xhr.send();\n return xhr.status == 0 || xhr.status == 200 ? xhr.responseText : null;\n } catch (err) {\n return null;\n }\n }\n};\ngoog.typeOf = function(value) {\n var s = typeof value;\n if (s != \"object\") {\n return s;\n }\n if (!value) {\n return \"null\";\n }\n if (Array.isArray(value)) {\n return \"array\";\n }\n return s;\n};\ngoog.isArrayLike = function(val) {\n var type = goog.typeOf(val);\n return type == \"array\" || type == \"object\" && typeof val.length == \"number\";\n};\ngoog.isDateLike = function(val) {\n return goog.isObject(val) && typeof val.getFullYear == \"function\";\n};\ngoog.isObject = function(val) {\n var type = typeof val;\n return type == \"object\" && val != null || type == \"function\";\n};\ngoog.getUid = function(obj) {\n return Object.prototype.hasOwnProperty.call(obj, goog.UID_PROPERTY_) && obj[goog.UID_PROPERTY_] || (obj[goog.UID_PROPERTY_] = ++goog.uidCounter_);\n};\ngoog.hasUid = function(obj) {\n return !!obj[goog.UID_PROPERTY_];\n};\ngoog.removeUid = function(obj) {\n if (obj !== null && \"removeAttribute\" in obj) {\n obj.removeAttribute(goog.UID_PROPERTY_);\n }\n try {\n delete obj[goog.UID_PROPERTY_];\n } catch (ex) {\n }\n};\ngoog.UID_PROPERTY_ = \"closure_uid_\" + (Math.random() * 1e9 >>> 0);\ngoog.uidCounter_ = 0;\ngoog.cloneObject = function(obj) {\n var type = goog.typeOf(obj);\n if (type == \"object\" || type == \"array\") {\n if (typeof obj.clone === \"function\") {\n return obj.clone();\n }\n if (typeof Map !== \"undefined\" && obj instanceof Map) {\n return new Map(obj);\n } else if (typeof Set !== \"undefined\" && obj instanceof Set) {\n return new Set(obj);\n }\n var clone = type == \"array\" ? [] : {};\n for (var key in obj) {\n clone[key] = goog.cloneObject(obj[key]);\n }\n return clone;\n }\n return obj;\n};\ngoog.bindNative_ = function(fn, selfObj, var_args) {\n return fn.call.apply(fn.bind, arguments);\n};\ngoog.bindJs_ = function(fn, selfObj, var_args) {\n if (!fn) {\n throw new Error();\n }\n if (arguments.length > 2) {\n var boundArgs = Array.prototype.slice.call(arguments, 2);\n return function() {\n var newArgs = Array.prototype.slice.call(arguments);\n Array.prototype.unshift.apply(newArgs, boundArgs);\n return fn.apply(selfObj, newArgs);\n };\n } else {\n return function() {\n return fn.apply(selfObj, arguments);\n };\n }\n};\ngoog.bind = function(fn, selfObj, var_args) {\n if (Function.prototype.bind && Function.prototype.bind.toString().indexOf(\"native code\") != -1) {\n goog.bind = goog.bindNative_;\n } else {\n goog.bind = goog.bindJs_;\n }\n return goog.bind.apply(null, arguments);\n};\ngoog.partial = function(fn, var_args) {\n var args = Array.prototype.slice.call(arguments, 1);\n return function() {\n var newArgs = args.slice();\n newArgs.push.apply(newArgs, arguments);\n return fn.apply(this, newArgs);\n };\n};\ngoog.now = function() {\n return Date.now();\n};\ngoog.globalEval = function(script) {\n (0,eval)(script);\n};\ngoog.cssNameMapping_;\ngoog.cssNameMappingStyle_;\ngoog.global.CLOSURE_CSS_NAME_MAP_FN;\ngoog.getCssName = function(className, opt_modifier) {\n if (String(className).charAt(0) == \".\") {\n throw new Error('className passed in goog.getCssName must not start with \".\".' + \" You passed: \" + className);\n }\n var getMapping = function(cssName) {\n return goog.cssNameMapping_[cssName] || cssName;\n };\n var renameByParts = function(cssName) {\n var parts = cssName.split(\"-\");\n var mapped = [];\n for (var i = 0; i < parts.length; i++) {\n mapped.push(getMapping(parts[i]));\n }\n return mapped.join(\"-\");\n };\n var rename;\n if (goog.cssNameMapping_) {\n rename = goog.cssNameMappingStyle_ == \"BY_WHOLE\" ? getMapping : renameByParts;\n } else {\n rename = function(a) {\n return a;\n };\n }\n var result = opt_modifier ? className + \"-\" + rename(opt_modifier) : rename(className);\n if (goog.global.CLOSURE_CSS_NAME_MAP_FN) {\n return goog.global.CLOSURE_CSS_NAME_MAP_FN(result);\n }\n return result;\n};\ngoog.setCssNameMapping = function(mapping, opt_style) {\n goog.cssNameMapping_ = mapping;\n goog.cssNameMappingStyle_ = opt_style;\n};\ngoog.global.CLOSURE_CSS_NAME_MAPPING;\nif (!COMPILED && goog.global.CLOSURE_CSS_NAME_MAPPING) {\n goog.cssNameMapping_ = goog.global.CLOSURE_CSS_NAME_MAPPING;\n}\ngoog.GetMsgOptions = function() {\n};\ngoog.GetMsgOptions.prototype.html;\ngoog.GetMsgOptions.prototype.unescapeHtmlEntities;\ngoog.GetMsgOptions.prototype.original_code;\ngoog.GetMsgOptions.prototype.example;\ngoog.getMsg = function(str, opt_values, opt_options) {\n if (opt_options && opt_options.html) {\n str = str.replace(/</g, \"\\x26lt;\");\n }\n if (opt_options && opt_options.unescapeHtmlEntities) {\n str = str.replace(/</g, \"\\x3c\").replace(/>/g, \"\\x3e\").replace(/'/g, \"'\").replace(/"/g, '\"').replace(/&/g, \"\\x26\");\n }\n if (opt_values) {\n str = str.replace(/\\{\\$([^}]+)}/g, function(match, key) {\n return opt_values != null && key in opt_values ? opt_values[key] : match;\n });\n }\n return str;\n};\ngoog.getMsgWithFallback = function(a, b) {\n return a;\n};\ngoog.exportSymbol = function(publicPath, object, objectToExportTo) {\n goog.exportPath_(publicPath, object, true, objectToExportTo);\n};\ngoog.exportProperty = function(object, publicName, symbol) {\n object[publicName] = symbol;\n};\ngoog.inherits = function(childCtor, parentCtor) {\n function tempCtor() {\n }\n tempCtor.prototype = parentCtor.prototype;\n childCtor.superClass_ = parentCtor.prototype;\n childCtor.prototype = new tempCtor();\n childCtor.prototype.constructor = childCtor;\n childCtor.base = function(me, methodName, var_args) {\n var args = new Array(arguments.length - 2);\n for (var i = 2; i < arguments.length; i++) {\n args[i - 2] = arguments[i];\n }\n return parentCtor.prototype[methodName].apply(me, args);\n };\n};\ngoog.scope = function(fn) {\n if (goog.isInModuleLoader_()) {\n throw new Error(\"goog.scope is not supported within a module.\");\n }\n fn.call(goog.global);\n};\nif (!COMPILED) {\n goog.global[\"COMPILED\"] = COMPILED;\n}\ngoog.defineClass = function(superClass, def) {\n var constructor = def.constructor;\n var statics = def.statics;\n if (!constructor || constructor == Object.prototype.constructor) {\n constructor = function() {\n throw new Error(\"cannot instantiate an interface (no constructor defined).\");\n };\n }\n var cls = goog.defineClass.createSealingConstructor_(constructor, superClass);\n if (superClass) {\n goog.inherits(cls, superClass);\n }\n delete def.constructor;\n delete def.statics;\n goog.defineClass.applyProperties_(cls.prototype, def);\n if (statics != null) {\n if (statics instanceof Function) {\n statics(cls);\n } else {\n goog.defineClass.applyProperties_(cls, statics);\n }\n }\n return cls;\n};\ngoog.defineClass.ClassDescriptor;\ngoog.defineClass.SEAL_CLASS_INSTANCES = goog.define(\"goog.defineClass.SEAL_CLASS_INSTANCES\", goog.DEBUG);\ngoog.defineClass.createSealingConstructor_ = function(ctr, superClass) {\n if (!goog.defineClass.SEAL_CLASS_INSTANCES) {\n return ctr;\n }\n var wrappedCtr = function() {\n var instance = ctr.apply(this, arguments) || this;\n instance[goog.UID_PROPERTY_] = instance[goog.UID_PROPERTY_];\n return instance;\n };\n return wrappedCtr;\n};\ngoog.defineClass.OBJECT_PROTOTYPE_FIELDS_ = [\"constructor\", \"hasOwnProperty\", \"isPrototypeOf\", \"propertyIsEnumerable\", \"toLocaleString\", \"toString\", \"valueOf\"];\ngoog.defineClass.applyProperties_ = function(target, source) {\n var key;\n for (key in source) {\n if (Object.prototype.hasOwnProperty.call(source, key)) {\n target[key] = source[key];\n }\n }\n for (var i = 0; i < goog.defineClass.OBJECT_PROTOTYPE_FIELDS_.length; i++) {\n key = goog.defineClass.OBJECT_PROTOTYPE_FIELDS_[i];\n if (Object.prototype.hasOwnProperty.call(source, key)) {\n target[key] = source[key];\n }\n }\n};\ngoog.identity_ = function(s) {\n return s;\n};\ngoog.createTrustedTypesPolicy = function(name) {\n var policy = null;\n var policyFactory = goog.global.trustedTypes;\n if (!policyFactory || !policyFactory.createPolicy) {\n return policy;\n }\n try {\n policy = policyFactory.createPolicy(name, {createHTML:goog.identity_, createScript:goog.identity_, createScriptURL:goog.identity_});\n } catch (e) {\n goog.logToConsole_(e.message);\n }\n return policy;\n};\nif (!COMPILED && goog.DEPENDENCIES_ENABLED) {\n goog.isEdge_ = function() {\n var userAgent = goog.global.navigator && goog.global.navigator.userAgent ? goog.global.navigator.userAgent : \"\";\n var edgeRe = /Edge\\/(\\d+)(\\.\\d)*/i;\n return !!userAgent.match(edgeRe);\n };\n goog.inHtmlDocument_ = function() {\n var doc = goog.global.document;\n return doc != null && \"write\" in doc;\n };\n goog.isDocumentLoading_ = function() {\n var doc = goog.global.document;\n return doc.attachEvent ? doc.readyState != \"complete\" : doc.readyState == \"loading\";\n };\n goog.findBasePath_ = function() {\n if (goog.global.CLOSURE_BASE_PATH != undefined && typeof goog.global.CLOSURE_BASE_PATH === \"string\") {\n goog.basePath = goog.global.CLOSURE_BASE_PATH;\n return;\n } else if (!goog.inHtmlDocument_()) {\n return;\n }\n var doc = goog.global.document;\n var currentScript = doc.currentScript;\n if (currentScript) {\n var scripts = [currentScript];\n } else {\n var scripts = doc.getElementsByTagName(\"SCRIPT\");\n }\n for (var i = scripts.length - 1; i >= 0; --i) {\n var script = scripts[i];\n var src = script.src;\n var qmark = src.lastIndexOf(\"?\");\n var l = qmark == -1 ? src.length : qmark;\n if (src.slice(l - 7, l) == \"base.js\") {\n goog.basePath = src.slice(0, l - 7);\n return;\n }\n }\n };\n goog.findBasePath_();\n goog.protectScriptTag_ = function(str) {\n return str.replace(/<\\/(SCRIPT)/ig, \"\\\\x3c/$1\");\n };\n goog.DebugLoader_ = function() {\n this.dependencies_ = {};\n this.idToPath_ = {};\n this.written_ = {};\n this.loadingDeps_ = [];\n this.depsToLoad_ = [];\n this.paused_ = false;\n this.factory_ = new goog.DependencyFactory();\n this.deferredCallbacks_ = {};\n this.deferredQueue_ = [];\n };\n goog.DebugLoader_.prototype.bootstrap = function(namespaces, callback) {\n var cb = callback;\n function resolve() {\n if (cb) {\n goog.global.setTimeout(cb, 0);\n cb = null;\n }\n }\n if (!namespaces.length) {\n resolve();\n return;\n }\n var deps = [];\n for (var i = 0; i < namespaces.length; i++) {\n var path = this.getPathFromDeps_(namespaces[i]);\n if (!path) {\n throw new Error(\"Unregonized namespace: \" + namespaces[i]);\n }\n deps.push(this.dependencies_[path]);\n }\n var require = goog.require;\n var loaded = 0;\n for (var i = 0; i < namespaces.length; i++) {\n require(namespaces[i]);\n deps[i].onLoad(function() {\n if (++loaded == namespaces.length) {\n resolve();\n }\n });\n }\n };\n goog.DebugLoader_.prototype.loadClosureDeps = function() {\n var relPath = \"deps.js\";\n this.depsToLoad_.push(this.factory_.createDependency(goog.normalizePath_(goog.basePath + relPath), relPath, [], [], {}));\n this.loadDeps_();\n };\n goog.DebugLoader_.prototype.requested = function(absPathOrId, opt_force) {\n var path = this.getPathFromDeps_(absPathOrId);\n if (path && (opt_force || this.areDepsLoaded_(this.dependencies_[path].requires))) {\n var callback = this.deferredCallbacks_[path];\n if (callback) {\n delete this.deferredCallbacks_[path];\n callback();\n }\n }\n };\n goog.DebugLoader_.prototype.setDependencyFactory = function(factory) {\n this.factory_ = factory;\n };\n goog.DebugLoader_.prototype.load_ = function(namespace) {\n if (!this.getPathFromDeps_(namespace)) {\n var errorMessage = \"goog.require could not find: \" + namespace;\n goog.logToConsole_(errorMessage);\n } else {\n var loader = this;\n var deps = [];\n var visit = function(namespace) {\n var path = loader.getPathFromDeps_(namespace);\n if (!path) {\n throw new Error(\"Bad dependency path or symbol: \" + namespace);\n }\n if (loader.written_[path]) {\n return;\n }\n loader.written_[path] = true;\n var dep = loader.dependencies_[path];\n for (var i = 0; i < dep.requires.length; i++) {\n if (!goog.isProvided_(dep.requires[i])) {\n visit(dep.requires[i]);\n }\n }\n deps.push(dep);\n };\n visit(namespace);\n var wasLoading = !!this.depsToLoad_.length;\n this.depsToLoad_ = this.depsToLoad_.concat(deps);\n if (!this.paused_ && !wasLoading) {\n this.loadDeps_();\n }\n }\n };\n goog.DebugLoader_.prototype.loadDeps_ = function() {\n var loader = this;\n var paused = this.paused_;\n while (this.depsToLoad_.length && !paused) {\n (function() {\n var loadCallDone = false;\n var dep = loader.depsToLoad_.shift();\n var loaded = false;\n loader.loading_(dep);\n var controller = {pause:function() {\n if (loadCallDone) {\n throw new Error(\"Cannot call pause after the call to load.\");\n } else {\n paused = true;\n }\n }, resume:function() {\n if (loadCallDone) {\n loader.resume_();\n } else {\n paused = false;\n }\n }, loaded:function() {\n if (loaded) {\n throw new Error(\"Double call to loaded.\");\n }\n loaded = true;\n loader.loaded_(dep);\n }, pending:function() {\n var pending = [];\n for (var i = 0; i < loader.loadingDeps_.length; i++) {\n pending.push(loader.loadingDeps_[i]);\n }\n return pending;\n }, setModuleState:function(type) {\n goog.moduleLoaderState_ = {type:type, moduleName:\"\", declareLegacyNamespace:false};\n }, registerEs6ModuleExports:function(path, exports, opt_closureNamespace) {\n if (opt_closureNamespace) {\n goog.loadedModules_[opt_closureNamespace] = {exports:exports, type:goog.ModuleType.ES6, moduleId:opt_closureNamespace || \"\"};\n }\n }, registerGoogModuleExports:function(moduleId, exports) {\n goog.loadedModules_[moduleId] = {exports:exports, type:goog.ModuleType.GOOG, moduleId:moduleId};\n }, clearModuleState:function() {\n goog.moduleLoaderState_ = null;\n }, defer:function(callback) {\n if (loadCallDone) {\n throw new Error(\"Cannot register with defer after the call to load.\");\n }\n loader.defer_(dep, callback);\n }, areDepsLoaded:function() {\n return loader.areDepsLoaded_(dep.requires);\n }};\n try {\n dep.load(controller);\n } finally {\n loadCallDone = true;\n }\n })();\n }\n if (paused) {\n this.pause_();\n }\n };\n goog.DebugLoader_.prototype.pause_ = function() {\n this.paused_ = true;\n };\n goog.DebugLoader_.prototype.resume_ = function() {\n if (this.paused_) {\n this.paused_ = false;\n this.loadDeps_();\n }\n };\n goog.DebugLoader_.prototype.loading_ = function(dep) {\n this.loadingDeps_.push(dep);\n };\n goog.DebugLoader_.prototype.loaded_ = function(dep) {\n for (var i = 0; i < this.loadingDeps_.length; i++) {\n if (this.loadingDeps_[i] == dep) {\n this.loadingDeps_.splice(i, 1);\n break;\n }\n }\n for (var i = 0; i < this.deferredQueue_.length; i++) {\n if (this.deferredQueue_[i] == dep.path) {\n this.deferredQueue_.splice(i, 1);\n break;\n }\n }\n if (this.loadingDeps_.length == this.deferredQueue_.length && !this.depsToLoad_.length) {\n while (this.deferredQueue_.length) {\n this.requested(this.deferredQueue_.shift(), true);\n }\n }\n dep.loaded();\n };\n goog.DebugLoader_.prototype.areDepsLoaded_ = function(pathsOrIds) {\n for (var i = 0; i < pathsOrIds.length; i++) {\n var path = this.getPathFromDeps_(pathsOrIds[i]);\n if (!path || !(path in this.deferredCallbacks_) && !goog.isProvided_(pathsOrIds[i])) {\n return false;\n }\n }\n return true;\n };\n goog.DebugLoader_.prototype.getPathFromDeps_ = function(absPathOrId) {\n if (absPathOrId in this.idToPath_) {\n return this.idToPath_[absPathOrId];\n } else if (absPathOrId in this.dependencies_) {\n return absPathOrId;\n } else {\n return null;\n }\n };\n goog.DebugLoader_.prototype.defer_ = function(dependency, callback) {\n this.deferredCallbacks_[dependency.path] = callback;\n this.deferredQueue_.push(dependency.path);\n };\n goog.LoadController = function() {\n };\n goog.LoadController.prototype.pause = function() {\n };\n goog.LoadController.prototype.resume = function() {\n };\n goog.LoadController.prototype.loaded = function() {\n };\n goog.LoadController.prototype.pending = function() {\n };\n goog.LoadController.prototype.registerEs6ModuleExports = function(path, exports, opt_closureNamespace) {\n };\n goog.LoadController.prototype.setModuleState = function(type) {\n };\n goog.LoadController.prototype.clearModuleState = function() {\n };\n goog.LoadController.prototype.defer = function(callback) {\n };\n goog.LoadController.prototype.areDepsLoaded = function() {\n };\n goog.Dependency = function(path, relativePath, provides, requires, loadFlags) {\n this.path = path;\n this.relativePath = relativePath;\n this.provides = provides;\n this.requires = requires;\n this.loadFlags = loadFlags;\n this.loaded_ = false;\n this.loadCallbacks_ = [];\n };\n goog.Dependency.prototype.getPathName = function() {\n var pathName = this.path;\n var protocolIndex = pathName.indexOf(\"://\");\n if (protocolIndex >= 0) {\n pathName = pathName.substring(protocolIndex + 3);\n var slashIndex = pathName.indexOf(\"/\");\n if (slashIndex >= 0) {\n pathName = pathName.substring(slashIndex + 1);\n }\n }\n return pathName;\n };\n goog.Dependency.prototype.onLoad = function(callback) {\n if (this.loaded_) {\n callback();\n } else {\n this.loadCallbacks_.push(callback);\n }\n };\n goog.Dependency.prototype.loaded = function() {\n this.loaded_ = true;\n var callbacks = this.loadCallbacks_;\n this.loadCallbacks_ = [];\n for (var i = 0; i < callbacks.length; i++) {\n callbacks[i]();\n }\n };\n goog.Dependency.defer_ = false;\n goog.Dependency.callbackMap_ = {};\n goog.Dependency.registerCallback_ = function(callback) {\n var key = Math.random().toString(32);\n goog.Dependency.callbackMap_[key] = callback;\n return key;\n };\n goog.Dependency.unregisterCallback_ = function(key) {\n delete goog.Dependency.callbackMap_[key];\n };\n goog.Dependency.callback_ = function(key, var_args) {\n if (key in goog.Dependency.callbackMap_) {\n var callback = goog.Dependency.callbackMap_[key];\n var args = [];\n for (var i = 1; i < arguments.length; i++) {\n args.push(arguments[i]);\n }\n callback.apply(undefined, args);\n } else {\n var errorMessage = \"Callback key \" + key + \" does not exist (was base.js loaded more than once?).\";\n throw Error(errorMessage);\n }\n };\n goog.Dependency.prototype.load = function(controller) {\n if (goog.global.CLOSURE_IMPORT_SCRIPT) {\n if (goog.global.CLOSURE_IMPORT_SCRIPT(this.path)) {\n controller.loaded();\n } else {\n controller.pause();\n }\n return;\n }\n if (!goog.inHtmlDocument_()) {\n goog.logToConsole_(\"Cannot use default debug loader outside of HTML documents.\");\n if (this.relativePath == \"deps.js\") {\n goog.logToConsole_(\"Consider setting CLOSURE_IMPORT_SCRIPT before loading base.js, \" + \"or setting CLOSURE_NO_DEPS to true.\");\n controller.loaded();\n } else {\n controller.pause();\n }\n return;\n }\n var doc = goog.global.document;\n if (doc.readyState == \"complete\" && !goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING) {\n var isDeps = /\\bdeps.js$/.test(this.path);\n if (isDeps) {\n controller.loaded();\n return;\n } else {\n throw Error('Cannot write \"' + this.path + '\" after document load');\n }\n }\n var nonce = goog.getScriptNonce_();\n if (!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING && goog.isDocumentLoading_()) {\n var key;\n var callback = function(script) {\n if (script.readyState && script.readyState != \"complete\") {\n script.onload = callback;\n return;\n }\n goog.Dependency.unregisterCallback_(key);\n controller.loaded();\n };\n key = goog.Dependency.registerCallback_(callback);\n var defer = goog.Dependency.defer_ ? \" defer\" : \"\";\n var nonceAttr = nonce ? ' nonce\\x3d\"' + nonce + '\"' : \"\";\n var script = '\\x3cscript src\\x3d\"' + this.path + '\"' + nonceAttr + defer + ' id\\x3d\"script-' + key + '\"\\x3e\\x3c/script\\x3e';\n script += \"\\x3cscript\" + nonceAttr + \"\\x3e\";\n if (goog.Dependency.defer_) {\n script += \"document.getElementById('script-\" + key + \"').onload \\x3d function() {\\n\" + \" goog.Dependency.callback_('\" + key + \"', this);\\n\" + \"};\\n\";\n } else {\n script += \"goog.Dependency.callback_('\" + key + \"', document.getElementById('script-\" + key + \"'));\";\n }\n script += \"\\x3c/script\\x3e\";\n doc.write(goog.TRUSTED_TYPES_POLICY_ ? goog.TRUSTED_TYPES_POLICY_.createHTML(script) : script);\n } else {\n var scriptEl = doc.createElement(\"script\");\n scriptEl.defer = goog.Dependency.defer_;\n scriptEl.async = false;\n if (nonce) {\n scriptEl.nonce = nonce;\n }\n scriptEl.onload = function() {\n scriptEl.onload = null;\n controller.loaded();\n };\n scriptEl.src = goog.TRUSTED_TYPES_POLICY_ ? goog.TRUSTED_TYPES_POLICY_.createScriptURL(this.path) : this.path;\n doc.head.appendChild(scriptEl);\n }\n };\n goog.Es6ModuleDependency = function(path, relativePath, provides, requires, loadFlags) {\n goog.Es6ModuleDependency.base(this, \"constructor\", path, relativePath, provides, requires, loadFlags);\n };\n goog.inherits(goog.Es6ModuleDependency, goog.Dependency);\n goog.Es6ModuleDependency.prototype.load = function(controller) {\n if (goog.global.CLOSURE_IMPORT_SCRIPT) {\n if (goog.global.CLOSURE_IMPORT_SCRIPT(this.path)) {\n controller.loaded();\n } else {\n controller.pause();\n }\n return;\n }\n if (!goog.inHtmlDocument_()) {\n goog.logToConsole_(\"Cannot use default debug loader outside of HTML documents.\");\n controller.pause();\n return;\n }\n var doc = goog.global.document;\n var dep = this;\n function write(src, contents) {\n var nonceAttr = \"\";\n var nonce = goog.getScriptNonce_();\n if (nonce) {\n nonceAttr = ' nonce\\x3d\"' + nonce + '\"';\n }\n if (contents) {\n var script = '\\x3cscript type\\x3d\"module\" crossorigin' + nonceAttr + \"\\x3e\" + contents + \"\\x3c/\" + \"script\\x3e\";\n doc.write(goog.TRUSTED_TYPES_POLICY_ ? goog.TRUSTED_TYPES_POLICY_.createHTML(script) : script);\n } else {\n var script = '\\x3cscript type\\x3d\"module\" crossorigin src\\x3d\"' + src + '\"' + nonceAttr + \"\\x3e\\x3c/\" + \"script\\x3e\";\n doc.write(goog.TRUSTED_TYPES_POLICY_ ? goog.TRUSTED_TYPES_POLICY_.createHTML(script) : script);\n }\n }\n function append(src, contents) {\n var scriptEl = doc.createElement(\"script\");\n scriptEl.defer = true;\n scriptEl.async = false;\n scriptEl.type = \"module\";\n scriptEl.setAttribute(\"crossorigin\", true);\n var nonce = goog.getScriptNonce_();\n if (nonce) {\n scriptEl.nonce = nonce;\n }\n if (contents) {\n scriptEl.text = goog.TRUSTED_TYPES_POLICY_ ? goog.TRUSTED_TYPES_POLICY_.createScript(contents) : contents;\n } else {\n scriptEl.src = goog.TRUSTED_TYPES_POLICY_ ? goog.TRUSTED_TYPES_POLICY_.createScriptURL(src) : src;\n }\n doc.head.appendChild(scriptEl);\n }\n var create;\n if (goog.isDocumentLoading_()) {\n create = write;\n goog.Dependency.defer_ = true;\n } else {\n create = append;\n }\n var beforeKey = goog.Dependency.registerCallback_(function() {\n goog.Dependency.unregisterCallback_(beforeKey);\n controller.setModuleState(goog.ModuleType.ES6);\n });\n create(undefined, 'goog.Dependency.callback_(\"' + beforeKey + '\")');\n create(this.path, undefined);\n var registerKey = goog.Dependency.registerCallback_(function(exports) {\n goog.Dependency.unregisterCallback_(registerKey);\n controller.registerEs6ModuleExports(dep.path, exports, goog.moduleLoaderState_.moduleName);\n });\n create(undefined, 'import * as m from \"' + this.path + '\"; goog.Dependency.callback_(\"' + registerKey + '\", m)');\n var afterKey = goog.Dependency.registerCallback_(function() {\n goog.Dependency.unregisterCallback_(afterKey);\n controller.clearModuleState();\n controller.loaded();\n });\n create(undefined, 'goog.Dependency.callback_(\"' + afterKey + '\")');\n };\n goog.TransformedDependency = function(path, relativePath, provides, requires, loadFlags) {\n goog.TransformedDependency.base(this, \"constructor\", path, relativePath, provides, requires, loadFlags);\n this.contents_ = null;\n this.lazyFetch_ = !goog.inHtmlDocument_() || !(\"noModule\" in goog.global.document.createElement(\"script\"));\n };\n goog.inherits(goog.TransformedDependency, goog.Dependency);\n goog.TransformedDependency.prototype.load = function(controller) {\n var dep = this;\n function fetch() {\n dep.contents_ = goog.loadFileSync_(dep.path);\n if (dep.contents_) {\n dep.contents_ = dep.transform(dep.contents_);\n if (dep.contents_) {\n dep.contents_ += \"\\n//# sourceURL\\x3d\" + dep.path;\n }\n }\n }\n if (goog.global.CLOSURE_IMPORT_SCRIPT) {\n fetch();\n if (this.contents_ && goog.global.CLOSURE_IMPORT_SCRIPT(\"\", this.contents_)) {\n this.contents_ = null;\n controller.loaded();\n } else {\n controller.pause();\n }\n return;\n }\n var isEs6 = this.loadFlags[\"module\"] == goog.ModuleType.ES6;\n if (!this.lazyFetch_) {\n fetch();\n }\n function load() {\n if (dep.lazyFetch_) {\n fetch();\n }\n if (!dep.contents_) {\n return;\n }\n if (isEs6) {\n controller.setModuleState(goog.ModuleType.ES6);\n }\n var namespace;\n try {\n var contents = dep.contents_;\n dep.contents_ = null;\n goog.globalEval(goog.CLOSURE_EVAL_PREFILTER_.createScript(contents));\n if (isEs6) {\n namespace = goog.moduleLoaderState_.moduleName;\n }\n } finally {\n if (isEs6) {\n controller.clearModuleState();\n }\n }\n if (isEs6) {\n goog.global[\"$jscomp\"][\"require\"][\"ensure\"]([dep.getPathName()], function() {\n controller.registerEs6ModuleExports(dep.path, goog.global[\"$jscomp\"][\"require\"](dep.getPathName()), namespace);\n });\n }\n controller.loaded();\n }\n function fetchInOwnScriptThenLoad() {\n var doc = goog.global.document;\n var key = goog.Dependency.registerCallback_(function() {\n goog.Dependency.unregisterCallback_(key);\n load();\n });\n var nonce = goog.getScriptNonce_();\n var nonceAttr = nonce ? ' nonce\\x3d\"' + nonce + '\"' : \"\";\n var script = \"\\x3cscript\" + nonceAttr + \"\\x3e\" + goog.protectScriptTag_('goog.Dependency.callback_(\"' + key + '\");') + \"\\x3c/\" + \"script\\x3e\";\n doc.write(goog.TRUSTED_TYPES_POLICY_ ? goog.TRUSTED_TYPES_POLICY_.createHTML(script) : script);\n }\n var anythingElsePending = controller.pending().length > 1;\n var needsAsyncLoading = goog.Dependency.defer_ && (anythingElsePending || goog.isDocumentLoading_());\n if (needsAsyncLoading) {\n controller.defer(function() {\n load();\n });\n return;\n }\n var doc = goog.global.document;\n var isInternetExplorerOrEdge = goog.inHtmlDocument_() && (\"ActiveXObject\" in goog.global || goog.isEdge_());\n if (isEs6 && goog.inHtmlDocument_() && goog.isDocumentLoading_() && !isInternetExplorerOrEdge) {\n goog.Dependency.defer_ = true;\n controller.pause();\n var oldCallback = doc.onreadystatechange;\n doc.onreadystatechange = function() {\n if (doc.readyState == \"interactive\") {\n doc.onreadystatechange = oldCallback;\n load();\n controller.resume();\n }\n if (typeof oldCallback === \"function\") {\n oldCallback.apply(undefined, arguments);\n }\n };\n } else {\n if (!goog.inHtmlDocument_() || !goog.isDocumentLoading_()) {\n load();\n } else {\n fetchInOwnScriptThenLoad();\n }\n }\n };\n goog.TransformedDependency.prototype.transform = function(contents) {\n };\n goog.PreTranspiledEs6ModuleDependency = function(path, relativePath, provides, requires, loadFlags) {\n goog.PreTranspiledEs6ModuleDependency.base(this, \"constructor\", path, relativePath, provides, requires, loadFlags);\n };\n goog.inherits(goog.PreTranspiledEs6ModuleDependency, goog.TransformedDependency);\n goog.PreTranspiledEs6ModuleDependency.prototype.transform = function(contents) {\n return contents;\n };\n goog.GoogModuleDependency = function(path, relativePath, provides, requires, loadFlags) {\n goog.GoogModuleDependency.base(this, \"constructor\", path, relativePath, provides, requires, loadFlags);\n };\n goog.inherits(goog.GoogModuleDependency, goog.TransformedDependency);\n goog.GoogModuleDependency.prototype.transform = function(contents) {\n if (!goog.LOAD_MODULE_USING_EVAL || goog.global.JSON === undefined) {\n return \"\" + \"goog.loadModule(function(exports) {\" + '\"use strict\";' + contents + \"\\n\" + \";return exports\" + \"});\" + \"\\n//# sourceURL\\x3d\" + this.path + \"\\n\";\n } else {\n return \"\" + \"goog.loadModule(\" + goog.global.JSON.stringify(contents + \"\\n//# sourceURL\\x3d\" + this.path + \"\\n\") + \");\";\n }\n };\n goog.DebugLoader_.prototype.addDependency = function(relPath, provides, requires, opt_loadFlags) {\n provides = provides || [];\n relPath = relPath.replace(/\\\\/g, \"/\");\n var path = goog.normalizePath_(goog.basePath + relPath);\n if (!opt_loadFlags || typeof opt_loadFlags === \"boolean\") {\n opt_loadFlags = opt_loadFlags ? {\"module\":goog.ModuleType.GOOG} : {};\n }\n var dep = this.factory_.createDependency(path, relPath, provides, requires, opt_loadFlags);\n this.dependencies_[path] = dep;\n for (var i = 0; i < provides.length; i++) {\n this.idToPath_[provides[i]] = path;\n }\n this.idToPath_[relPath] = path;\n };\n goog.DependencyFactory = function() {\n };\n goog.DependencyFactory.prototype.createDependency = function(path, relativePath, provides, requires, loadFlags) {\n if (loadFlags[\"module\"] == goog.ModuleType.GOOG) {\n return new goog.GoogModuleDependency(path, relativePath, provides, requires, loadFlags);\n } else {\n if (loadFlags[\"module\"] == goog.ModuleType.ES6) {\n if (goog.ASSUME_ES_MODULES_TRANSPILED) {\n return new goog.PreTranspiledEs6ModuleDependency(path, relativePath, provides, requires, loadFlags);\n } else {\n return new goog.Es6ModuleDependency(path, relativePath, provides, requires, loadFlags);\n }\n } else {\n return new goog.Dependency(path, relativePath, provides, requires, loadFlags);\n }\n }\n };\n goog.debugLoader_ = new goog.DebugLoader_();\n goog.loadClosureDeps = function() {\n goog.debugLoader_.loadClosureDeps();\n };\n goog.setDependencyFactory = function(factory) {\n goog.debugLoader_.setDependencyFactory(factory);\n };\n goog.TRUSTED_TYPES_POLICY_ = goog.TRUSTED_TYPES_POLICY_NAME ? goog.createTrustedTypesPolicy(goog.TRUSTED_TYPES_POLICY_NAME + \"#base\") : null;\n if (!goog.global.CLOSURE_NO_DEPS) {\n goog.debugLoader_.loadClosureDeps();\n }\n goog.bootstrap = function(namespaces, callback) {\n goog.debugLoader_.bootstrap(namespaces, callback);\n };\n}\nif (!COMPILED) {\n var isChrome87 = false;\n try {\n isChrome87 = eval(goog.global.trustedTypes.emptyScript) !== goog.global.trustedTypes.emptyScript;\n } catch (err) {\n }\n goog.CLOSURE_EVAL_PREFILTER_ = goog.global.trustedTypes && isChrome87 && goog.createTrustedTypesPolicy(\"goog#base#devonly#eval\") || {createScript:goog.identity_};\n}\n","~:source","/**\n * @license\n * Copyright The Closure Library Authors.\n * SPDX-License-Identifier: Apache-2.0\n */\n\n/**\n * @fileoverview Bootstrap for the Google JS Library (Closure).\n *\n * In uncompiled mode base.js will attempt to load Closure's deps file, unless\n * the global <code>CLOSURE_NO_DEPS</code> is set to true. This allows projects\n * to include their own deps file(s) from different locations.\n *\n * Avoid including base.js more than once. This is strictly discouraged and not\n * supported. goog.require(...) won't work properly in that case.\n *\n * @suppress {deprecated} Users cannot remove deprecated uses here.\n * @provideGoog\n */\n\n\n/**\n * @define {boolean} Overridden to true by the compiler.\n */\nvar COMPILED = false;\n\n\n/**\n * Base namespace for the Closure library. Checks to see goog is already\n * defined in the current scope before assigning to prevent clobbering if\n * base.js is loaded more than once.\n *\n * @const\n */\nvar goog = goog || {};\n\n/**\n * Reference to the global object.\n * https://www.ecma-international.org/ecma-262/9.0/index.html#sec-global-object\n *\n * More info on this implementation here:\n * https://docs.google.com/document/d/1NAeW4Wk7I7FV0Y2tcUFvQdGMc89k2vdgSXInw8_nvCI/edit\n *\n * @const\n * @suppress {undefinedVars} self won't be referenced unless `this` is falsy.\n * @type {!Global}\n */\ngoog.global =\n // Check `this` first for backwards compatibility.\n // Valid unless running as an ES module or in a function wrapper called\n // without setting `this` properly.\n // Note that base.js can't usefully be imported as an ES module, but it may\n // be compiled into bundles that are loadable as ES modules.\n this ||\n // https://developer.mozilla.org/en-US/docs/Web/API/Window/self\n // For in-page browser environments and workers.\n self;\n\n\n/**\n * A hook for overriding the define values in uncompiled mode.\n *\n * In uncompiled mode, `CLOSURE_UNCOMPILED_DEFINES` may be defined before\n * loading base.js. If a key is defined in `CLOSURE_UNCOMPILED_DEFINES`,\n * `goog.define` will use the value instead of the default value. This\n * allows flags to be overwritten without compilation (this is normally\n * accomplished with the compiler's \"define\" flag).\n *\n * Example:\n * <pre>\n * var CLOSURE_UNCOMPILED_DEFINES = {'goog.DEBUG': false};\n * </pre>\n *\n * @type {Object<string, (string|number|boolean)>|undefined}\n */\ngoog.global.CLOSURE_UNCOMPILED_DEFINES;\n\n\n/**\n * A hook for overriding the define values in uncompiled or compiled mode,\n * like CLOSURE_UNCOMPILED_DEFINES but effective in compiled code. In\n * uncompiled code CLOSURE_UNCOMPILED_DEFINES takes precedence.\n *\n * Also unlike CLOSURE_UNCOMPILED_DEFINES the values must be number, boolean or\n * string literals or the compiler will emit an error.\n *\n * While any @define value may be set, only those set with goog.define will be\n * effective for uncompiled code.\n *\n * Example:\n * <pre>\n * var CLOSURE_DEFINES = {'goog.DEBUG': false} ;\n * </pre>\n *\n * Currently the Closure Compiler will only recognize very simple definitions of\n * this value when looking for values to apply to compiled code and ignore all\n * other references. Specifically, it looks the value defined at the variable\n * declaration, as with the example above.\n *\n * TODO(user): Improve the recognized definitions.\n *\n * @type {!Object<string, (string|number|boolean)>|null|undefined}\n */\ngoog.global.CLOSURE_DEFINES;\n\n\n/**\n * Builds an object structure for the provided namespace path, ensuring that\n * names that already exist are not overwritten. For example:\n * \"a.b.c\" -> a = {};a.b={};a.b.c={};\n * Used by goog.provide and goog.exportSymbol.\n * @param {string} name The name of the object that this file defines.\n * @param {*=} object The object to expose at the end of the path.\n * @param {boolean=} overwriteImplicit If object is set and a previous call\n * implicitly constructed the namespace given by name, this parameter\n * controls whether object should overwrite the implicitly constructed\n * namespace or be merged into it. Defaults to false.\n * @param {?Object=} objectToExportTo The object to add the path to; if this\n * field is not specified, its value defaults to `goog.global`.\n * @private\n */\ngoog.exportPath_ = function(name, object, overwriteImplicit, objectToExportTo) {\n var parts = name.split('.');\n var cur = objectToExportTo || goog.global;\n\n // Internet Explorer exhibits strange behavior when throwing errors from\n // methods externed in this manner. See the testExportSymbolExceptions in\n // base_test.html for an example.\n if (!(parts[0] in cur) && typeof cur.execScript != 'undefined') {\n cur.execScript('var ' + parts[0]);\n }\n\n for (var part; parts.length && (part = parts.shift());) {\n if (!parts.length && object !== undefined) {\n if (!overwriteImplicit && goog.isObject(object) &&\n goog.isObject(cur[part])) {\n // Merge properties on object (the input parameter) with the existing\n // implicitly defined namespace, so as to not clobber previously\n // defined child namespaces.\n for (var prop in object) {\n if (object.hasOwnProperty(prop)) {\n cur[part][prop] = object[prop];\n }\n }\n } else {\n // Either there is no existing implicit namespace, or overwriteImplicit\n // is set to true, so directly assign object (the input parameter) to\n // the namespace.\n cur[part] = object;\n }\n } else if (cur[part] && cur[part] !== Object.prototype[part]) {\n cur = cur[part];\n } else {\n cur = cur[part] = {};\n }\n }\n};\n\n\n/**\n * Defines a named value. In uncompiled mode, the value is retrieved from\n * CLOSURE_DEFINES or CLOSURE_UNCOMPILED_DEFINES if the object is defined and\n * has the property specified, and otherwise used the defined defaultValue.\n * When compiled the default can be overridden using the compiler options or the\n * value set in the CLOSURE_DEFINES object. Returns the defined value so that it\n * can be used safely in modules. Note that the value type MUST be either\n * boolean, number, or string.\n *\n * @param {string} name The distinguished name to provide.\n * @param {T} defaultValue\n * @return {T} The defined value.\n * @template T\n */\ngoog.define = function(name, defaultValue) {\n var value = defaultValue;\n if (!COMPILED) {\n var uncompiledDefines = goog.global.CLOSURE_UNCOMPILED_DEFINES;\n var defines = goog.global.CLOSURE_DEFINES;\n if (uncompiledDefines &&\n // Anti DOM-clobbering runtime check (b/37736576).\n /** @type {?} */ (uncompiledDefines).nodeType === undefined &&\n Object.prototype.hasOwnProperty.call(uncompiledDefines, name)) {\n value = uncompiledDefines[name];\n } else if (\n defines &&\n // Anti DOM-clobbering runtime check (b/37736576).\n /** @type {?} */ (defines).nodeType === undefined &&\n Object.prototype.hasOwnProperty.call(defines, name)) {\n value = defines[name];\n }\n }\n return value;\n};\n\n\n/**\n * @define {number} Integer year indicating the set of browser features that are\n * guaranteed to be present. This is defined to include exactly features that\n * work correctly on all \"modern\" browsers that are stable on January 1 of the\n * specified year. For example,\n * ```js\n * if (goog.FEATURESET_YEAR >= 2019) {\n * // use APIs known to be available on all major stable browsers Jan 1, 2019\n * } else {\n * // polyfill for older browsers\n * }\n * ```\n * This is intended to be the primary define for removing\n * unnecessary browser compatibility code (such as ponyfills and workarounds),\n * and should inform the default value for most other defines:\n * ```js\n * const ASSUME_NATIVE_PROMISE =\n * goog.define('ASSUME_NATIVE_PROMISE', goog.FEATURESET_YEAR >= 2016);\n * ```\n *\n * The default assumption is that IE9 is the lowest supported browser, which was\n * first available Jan 1, 2012.\n *\n * TODO(user): Reference more thorough documentation when it's available.\n */\ngoog.FEATURESET_YEAR = goog.define('goog.FEATURESET_YEAR', 2012);\n\n\n/**\n * @define {boolean} DEBUG is provided as a convenience so that debugging code\n * that should not be included in a production. It can be easily stripped\n * by specifying --define goog.DEBUG=false to the Closure Compiler aka\n * JSCompiler. For example, most toString() methods should be declared inside an\n * \"if (goog.DEBUG)\" conditional because they are generally used for debugging\n * purposes and it is difficult for the JSCompiler to statically determine\n * whether they are used.\n */\ngoog.DEBUG = goog.define('goog.DEBUG', true);\n\n\n/**\n * @define {string} LOCALE defines the locale being used for compilation. It is\n * used to select locale specific data to be compiled in js binary. BUILD rule\n * can specify this value by \"--define goog.LOCALE=<locale_name>\" as a compiler\n * option.\n *\n * Take into account that the locale code format is important. You should use\n * the canonical Unicode format with hyphen as a delimiter. Language must be\n * lowercase, Language Script - Capitalized, Region - UPPERCASE.\n * There are few examples: pt-BR, en, en-US, sr-Latin-BO, zh-Hans-CN.\n *\n * See more info about locale codes here:\n * http://www.unicode.org/reports/tr35/#Unicode_Language_and_Locale_Identifiers\n *\n * For language codes you should use values defined by ISO 693-1. See it here\n * http://www.w3.org/WAI/ER/IG/ert/iso639.htm. There is only one exception from\n * this rule: the Hebrew language. For legacy reasons the old code (iw) should\n * be used instead of the new code (he).\n *\n */\ngoog.LOCALE = goog.define('goog.LOCALE', 'en'); // default to en\n\n\n/**\n * @define {boolean} Whether this code is running on trusted sites.\n *\n * On untrusted sites, several native functions can be defined or overridden by\n * external libraries like Prototype, Datejs, and JQuery and setting this flag\n * to false forces closure to use its own implementations when possible.\n *\n * If your JavaScript can be loaded by a third party site and you are wary about\n * relying on non-standard implementations, specify\n * \"--define goog.TRUSTED_SITE=false\" to the compiler.\n */\ngoog.TRUSTED_SITE = goog.define('goog.TRUSTED_SITE', true);\n\n\n/**\n * @define {boolean} Whether code that calls {@link goog.setTestOnly} should\n * be disallowed in the compilation unit.\n */\ngoog.DISALLOW_TEST_ONLY_CODE =\n goog.define('goog.DISALLOW_TEST_ONLY_CODE', COMPILED && !goog.DEBUG);\n\n\n/**\n * @define {boolean} Whether to use a Chrome app CSP-compliant method for\n * loading scripts via goog.require. @see appendScriptSrcNode_.\n */\ngoog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING =\n goog.define('goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING', false);\n\n\n/**\n * Defines a namespace in Closure.\n *\n * A namespace may only be defined once in a codebase. It may be defined using\n * goog.provide() or goog.module().\n *\n * The presence of one or more goog.provide() calls in a file indicates\n * that the file defines the given objects/namespaces.\n * Provided symbols must not be null or undefined.\n *\n * In addition, goog.provide() creates the object stubs for a namespace\n * (for example, goog.provide(\"goog.foo.bar\") will create the object\n * goog.foo.bar if it does not already exist).\n *\n * Build tools also scan for provide/require/module statements\n * to discern dependencies, build dependency files (see deps.js), etc.\n *\n * @see goog.require\n * @see goog.module\n * @param {string} name Namespace provided by this file in the form\n * \"goog.package.part\".\n * deprecated Use goog.module (see b/159289405)\n */\ngoog.provide = function(name) {\n if (goog.isInModuleLoader_()) {\n throw new Error('goog.provide cannot be used within a module.');\n }\n if (!COMPILED) {\n // Ensure that the same namespace isn't provided twice.\n // A goog.module/goog.provide maps a goog.require to a specific file\n if (goog.isProvided_(name)) {\n throw new Error('Namespace \"' + name + '\" already declared.');\n }\n }\n\n goog.constructNamespace_(name);\n};\n\n\n/**\n * @param {string} name Namespace provided by this file in the form\n * \"goog.package.part\".\n * @param {?Object=} object The object to embed in the namespace.\n * @param {boolean=} overwriteImplicit If object is set and a previous call\n * implicitly constructed the namespace given by name, this parameter\n * controls whether opt_obj should overwrite the implicitly constructed\n * namespace or be merged into it. Defaults to false.\n * @private\n */\ngoog.constructNamespace_ = function(name, object, overwriteImplicit) {\n if (!COMPILED) {\n delete goog.implicitNamespaces_[name];\n\n var namespace = name;\n while ((namespace = namespace.substring(0, namespace.lastIndexOf('.')))) {\n if (goog.getObjectByName(namespace)) {\n break;\n }\n goog.implicitNamespaces_[namespace] = true;\n }\n }\n\n goog.exportPath_(name, object, overwriteImplicit);\n};\n\n\n/**\n * According to the CSP3 spec a nonce must be a valid base64 string.\n * @see https://www.w3.org/TR/CSP3/#grammardef-base64-value\n * @private @const\n */\ngoog.NONCE_PATTERN_ = /^[\\w+/_-]+[=]{0,2}$/;\n\n\n/**\n * Returns CSP nonce, if set for any script tag.\n * @param {?Window=} opt_window The window context used to retrieve the nonce.\n * Defaults to global context.\n * @return {string} CSP nonce or empty string if no nonce is present.\n * @private\n */\ngoog.getScriptNonce_ = function(opt_window) {\n var doc = (opt_window || goog.global).document;\n var script = doc.querySelector && doc.querySelector('script[nonce]');\n if (script) {\n // Try to get the nonce from the IDL property first, because browsers that\n // implement additional nonce protection features (currently only Chrome) to\n // prevent nonce stealing via CSS do not expose the nonce via attributes.\n // See https://github.com/whatwg/html/issues/2369\n var nonce = script['nonce'] || script.getAttribute('nonce');\n if (nonce && goog.NONCE_PATTERN_.test(nonce)) {\n return nonce;\n }\n }\n return '';\n};\n\n\n/**\n * Module identifier validation regexp.\n * Note: This is a conservative check, it is very possible to be more lenient,\n * the primary exclusion here is \"/\" and \"\\\" and a leading \".\", these\n * restrictions are intended to leave the door open for using goog.require\n * with relative file paths rather than module identifiers.\n * @private\n */\ngoog.VALID_MODULE_RE_ = /^[a-zA-Z_$][a-zA-Z0-9._$]*$/;\n\n\n/**\n * Defines a module in Closure.\n *\n * Marks that this file must be loaded as a module and claims the namespace.\n *\n * A namespace may only be defined once in a codebase. It may be defined using\n * goog.provide() or goog.module().\n *\n * goog.module() has three requirements:\n * - goog.module may not be used in the same file as goog.provide.\n * - goog.module must be the first statement in the file.\n * - only one goog.module is allowed per file.\n *\n * When a goog.module annotated file is loaded, it is enclosed in\n * a strict function closure. This means that:\n * - any variables declared in a goog.module file are private to the file\n * (not global), though the compiler is expected to inline the module.\n * - The code must obey all the rules of \"strict\" JavaScript.\n * - the file will be marked as \"use strict\"\n *\n * NOTE: unlike goog.provide, goog.module does not declare any symbols by\n * itself. If declared symbols are desired, use\n * goog.module.declareLegacyNamespace().\n *\n *\n * See the public goog.module proposal: http://goo.gl/Va1hin\n *\n * @param {string} name Namespace provided by this file in the form\n * \"goog.package.part\", is expected but not required.\n * @return {void}\n */\ngoog.module = function(name) {\n if (typeof name !== 'string' || !name ||\n name.search(goog.VALID_MODULE_RE_) == -1) {\n throw new Error('Invalid module identifier');\n }\n if (!goog.isInGoogModuleLoader_()) {\n throw new Error(\n 'Module ' + name + ' has been loaded incorrectly. Note, ' +\n 'modules cannot be loaded as normal scripts. They require some kind of ' +\n 'pre-processing step. You\\'re likely trying to load a module via a ' +\n 'script tag or as a part of a concatenated bundle without rewriting the ' +\n 'module. For more info see: ' +\n 'https://github.com/google/closure-library/wiki/goog.module:-an-ES6-module-like-alternative-to-goog.provide.');\n }\n if (goog.moduleLoaderState_.moduleName) {\n throw new Error('goog.module may only be called once per module.');\n }\n\n // Store the module name for the loader.\n goog.moduleLoaderState_.moduleName = name;\n if (!COMPILED) {\n // Ensure that the same namespace isn't provided twice.\n // A goog.module/goog.provide maps a goog.require to a specific file\n if (goog.isProvided_(name)) {\n throw new Error('Namespace \"' + name + '\" already declared.');\n }\n delete goog.implicitNamespaces_[name];\n }\n};\n\n\n/**\n * @param {string} name The module identifier.\n * @return {?} The module exports for an already loaded module or null.\n *\n * Note: This is not an alternative to goog.require, it does not\n * indicate a hard dependency, instead it is used to indicate\n * an optional dependency or to access the exports of a module\n * that has already been loaded.\n * @suppress {missingProvide}\n */\ngoog.module.get = function(name) {\n return goog.module.getInternal_(name);\n};\n\n\n/**\n * @param {string} name The module identifier.\n * @return {?} The module exports for an already loaded module or null.\n * @private\n */\ngoog.module.getInternal_ = function(name) {\n if (!COMPILED) {\n if (name in goog.loadedModules_) {\n return goog.loadedModules_[name].exports;\n } else if (!goog.implicitNamespaces_[name]) {\n var ns = goog.getObjectByName(name);\n return ns != null ? ns : null;\n }\n }\n return null;\n};\n\n/**\n * Types of modules the debug loader can load.\n * @enum {string}\n */\ngoog.ModuleType = {\n ES6: 'es6',\n GOOG: 'goog'\n};\n\n\n/**\n * @private {?{\n * moduleName: (string|undefined),\n * declareLegacyNamespace:boolean,\n * type: ?goog.ModuleType\n * }}\n */\ngoog.moduleLoaderState_ = null;\n\n\n/**\n * @private\n * @return {boolean} Whether a goog.module or an es6 module is currently being\n * initialized.\n */\ngoog.isInModuleLoader_ = function() {\n return goog.isInGoogModuleLoader_() || goog.isInEs6ModuleLoader_();\n};\n\n\n/**\n * @private\n * @return {boolean} Whether a goog.module is currently being initialized.\n */\ngoog.isInGoogModuleLoader_ = function() {\n return !!goog.moduleLoaderState_ &&\n goog.moduleLoaderState_.type == goog.ModuleType.GOOG;\n};\n\n\n/**\n * @private\n * @return {boolean} Whether an es6 module is currently being initialized.\n */\ngoog.isInEs6ModuleLoader_ = function() {\n var inLoader = !!goog.moduleLoaderState_ &&\n goog.moduleLoaderState_.type == goog.ModuleType.ES6;\n\n if (inLoader) {\n return true;\n }\n\n var jscomp = goog.global['$jscomp'];\n\n if (jscomp) {\n // jscomp may not have getCurrentModulePath if this is a compiled bundle\n // that has some of the runtime, but not all of it. This can happen if\n // optimizations are turned on so the unused runtime is removed but renaming\n // and Closure pass are off (so $jscomp is still named $jscomp and the\n // goog.provide/require calls still exist).\n if (typeof jscomp.getCurrentModulePath != 'function') {\n return false;\n }\n\n // Bundled ES6 module.\n return !!jscomp.getCurrentModulePath();\n }\n\n return false;\n};\n\n\n/**\n * Provide the module's exports as a globally accessible object under the\n * module's declared name. This is intended to ease migration to goog.module\n * for files that have existing usages.\n * @suppress {missingProvide}\n */\ngoog.module.declareLegacyNamespace = function() {\n if (!COMPILED && !goog.isInGoogModuleLoader_()) {\n throw new Error(\n 'goog.module.declareLegacyNamespace must be called from ' +\n 'within a goog.module');\n }\n if (!COMPILED && !goog.moduleLoaderState_.moduleName) {\n throw new Error(\n 'goog.module must be called prior to ' +\n 'goog.module.declareLegacyNamespace.');\n }\n goog.moduleLoaderState_.declareLegacyNamespace = true;\n};\n\n\n/**\n * Associates an ES6 module with a Closure module ID so that is available via\n * goog.require. The associated ID acts like a goog.module ID - it does not\n * create any global names, it is merely available via goog.require /\n * goog.module.get / goog.forwardDeclare / goog.requireType. goog.require and\n * goog.module.get will return the entire module as if it was import *'d. This\n * allows Closure files to reference ES6 modules for the sake of migration.\n *\n * @param {string} namespace\n * @suppress {missingProvide}\n */\ngoog.declareModuleId = function(namespace) {\n if (!COMPILED) {\n if (!goog.isInEs6ModuleLoader_()) {\n throw new Error(\n 'goog.declareModuleId may only be called from ' +\n 'within an ES6 module');\n }\n if (goog.moduleLoaderState_ && goog.moduleLoaderState_.moduleName) {\n throw new Error(\n 'goog.declareModuleId may only be called once per module.');\n }\n if (namespace in goog.loadedModules_) {\n throw new Error(\n 'Module with namespace \"' + namespace + '\" already exists.');\n }\n }\n if (goog.moduleLoaderState_) {\n // Not bundled - debug loading.\n goog.moduleLoaderState_.moduleName = namespace;\n } else {\n // Bundled - not debug loading, no module loader state.\n var jscomp = goog.global['$jscomp'];\n if (!jscomp || typeof jscomp.getCurrentModulePath != 'function') {\n throw new Error(\n 'Module with namespace \"' + namespace +\n '\" has been loaded incorrectly.');\n }\n var exports = jscomp.require(jscomp.getCurrentModulePath());\n goog.loadedModules_[namespace] = {\n exports: exports,\n type: goog.ModuleType.ES6,\n moduleId: namespace\n };\n }\n};\n\n\n/**\n * Marks that the current file should only be used for testing, and never for\n * live code in production.\n *\n * In the case of unit tests, the message may optionally be an exact namespace\n * for the test (e.g. 'goog.stringTest'). The linter will then ignore the extra\n * provide (if not explicitly defined in the code).\n *\n * @param {string=} opt_message Optional message to add to the error that's\n * raised when used in production code.\n */\ngoog.setTestOnly = function(opt_message) {\n if (goog.DISALLOW_TEST_ONLY_CODE) {\n opt_message = opt_message || '';\n throw new Error(\n 'Importing test-only code into non-debug environment' +\n (opt_message ? ': ' + opt_message : '.'));\n }\n};\n\n\n/**\n * Forward declares a symbol. This is an indication to the compiler that the\n * symbol may be used in the source yet is not required and may not be provided\n * in compilation.\n *\n * The most common usage of forward declaration is code that takes a type as a\n * function parameter but does not need to require it. By forward declaring\n * instead of requiring, no hard dependency is made, and (if not required\n * elsewhere) the namespace may never be required and thus, not be pulled\n * into the JavaScript binary. If it is required elsewhere, it will be type\n * checked as normal.\n *\n * Before using goog.forwardDeclare, please read the documentation at\n * https://github.com/google/closure-compiler/wiki/Bad-Type-Annotation to\n * understand the options and tradeoffs when working with forward declarations.\n *\n * @param {string} name The namespace to forward declare in the form of\n * \"goog.package.part\".\n * @deprecated See go/noforwarddeclaration, Use `goog.requireType` instead.\n */\ngoog.forwardDeclare = function(name) {};\n\n\n/**\n * Forward declare type information. Used to assign types to goog.global\n * referenced object that would otherwise result in unknown type references\n * and thus block property disambiguation.\n */\ngoog.forwardDeclare('Document');\ngoog.forwardDeclare('HTMLScriptElement');\ngoog.forwardDeclare('XMLHttpRequest');\n\n\nif (!COMPILED) {\n /**\n * Check if the given name has been goog.provided. This will return false for\n * names that are available only as implicit namespaces.\n * @param {string} name name of the object to look for.\n * @return {boolean} Whether the name has been provided.\n * @private\n */\n goog.isProvided_ = function(name) {\n return (name in goog.loadedModules_) ||\n (!goog.implicitNamespaces_[name] && goog.getObjectByName(name) != null);\n };\n\n /**\n * Namespaces implicitly defined by goog.provide. For example,\n * goog.provide('goog.events.Event') implicitly declares that 'goog' and\n * 'goog.events' must be namespaces.\n *\n * @type {!Object<string, (boolean|undefined)>}\n * @private\n */\n goog.implicitNamespaces_ = {'goog.module': true};\n\n // NOTE: We add goog.module as an implicit namespace as goog.module is defined\n // here and because the existing module package has not been moved yet out of\n // the goog.module namespace. This satisifies both the debug loader and\n // ahead-of-time dependency management.\n}\n\n\n/**\n * Returns an object based on its fully qualified external name. The object\n * is not found if null or undefined. If you are using a compilation pass that\n * renames property names beware that using this function will not find renamed\n * properties.\n *\n * @param {string} name The fully qualified name.\n * @param {Object=} opt_obj The object within which to look; default is\n * |goog.global|.\n * @return {?} The value (object or primitive) or, if not found, null.\n */\ngoog.getObjectByName = function(name, opt_obj) {\n var parts = name.split('.');\n var cur = opt_obj || goog.global;\n for (var i = 0; i < parts.length; i++) {\n cur = cur[parts[i]];\n if (cur == null) {\n return null;\n }\n }\n return cur;\n};\n\n\n/**\n * Adds a dependency from a file to the files it requires.\n * @param {string} relPath The path to the js file.\n * @param {!Array<string>} provides An array of strings with\n * the names of the objects this file provides.\n * @param {!Array<string>} requires An array of strings with\n * the names of the objects this file requires.\n * @param {boolean|!Object<string>=} opt_loadFlags Parameters indicating\n * how the file must be loaded. The boolean 'true' is equivalent\n * to {'module': 'goog'} for backwards-compatibility. Valid properties\n * and values include {'module': 'goog'} and {'lang': 'es6'}.\n */\ngoog.addDependency = function(relPath, provides, requires, opt_loadFlags) {\n if (!COMPILED && goog.DEPENDENCIES_ENABLED) {\n goog.debugLoader_.addDependency(relPath, provides, requires, opt_loadFlags);\n }\n};\n\n\n// NOTE(nnaze): The debug DOM loader was included in base.js as an original way\n// to do \"debug-mode\" development. The dependency system can sometimes be\n// confusing, as can the debug DOM loader's asynchronous nature.\n//\n// With the DOM loader, a call to goog.require() is not blocking -- the script\n// will not load until some point after the current script. If a namespace is\n// needed at runtime, it needs to be defined in a previous script, or loaded via\n// require() with its registered dependencies.\n//\n// User-defined namespaces may need their own deps file. For a reference on\n// creating a deps file, see:\n// Externally: https://developers.google.com/closure/library/docs/depswriter\n//\n// Because of legacy clients, the DOM loader can't be easily removed from\n// base.js. Work was done to make it disableable or replaceable for\n// different environments (DOM-less JavaScript interpreters like Rhino or V8,\n// for example). See bootstrap/ for more information.\n\n\n/**\n * @define {boolean} Whether to enable the debug loader.\n *\n * If enabled, a call to goog.require() will attempt to load the namespace by\n * appending a script tag to the DOM (if the namespace has been registered).\n *\n * If disabled, goog.require() will simply assert that the namespace has been\n * provided (and depend on the fact that some outside tool correctly ordered\n * the script).\n */\ngoog.ENABLE_DEBUG_LOADER = goog.define('goog.ENABLE_DEBUG_LOADER', true);\n\n\n/**\n * @param {string} msg\n * @private\n */\ngoog.logToConsole_ = function(msg) {\n if (goog.global.console) {\n goog.global.console['error'](msg);\n }\n};\n\n\n/**\n * Implements a system for the dynamic resolution of dependencies that works in\n * parallel with the BUILD system.\n *\n * Note that all calls to goog.require will be stripped by the compiler.\n *\n * @see goog.provide\n * @param {string} namespace Namespace (as was given in goog.provide,\n * goog.module, or goog.declareModuleId) in the form\n * \"goog.package.part\".\n * @return {?} If called within a goog.module or ES6 module file, the associated\n * namespace or module otherwise null.\n */\ngoog.require = function(namespace) {\n if (!COMPILED) {\n // Might need to lazy load on old IE.\n if (goog.ENABLE_DEBUG_LOADER) {\n goog.debugLoader_.requested(namespace);\n }\n\n // If the object already exists we do not need to do anything.\n if (goog.isProvided_(namespace)) {\n if (goog.isInModuleLoader_()) {\n return goog.module.getInternal_(namespace);\n }\n } else if (goog.ENABLE_DEBUG_LOADER) {\n var moduleLoaderState = goog.moduleLoaderState_;\n goog.moduleLoaderState_ = null;\n try {\n goog.debugLoader_.load_(namespace);\n } finally {\n goog.moduleLoaderState_ = moduleLoaderState;\n }\n }\n\n return null;\n }\n};\n\n\n/**\n * Requires a symbol for its type information. This is an indication to the\n * compiler that the symbol may appear in type annotations, yet it is not\n * referenced at runtime.\n *\n * When called within a goog.module or ES6 module file, the return value may be\n * assigned to or destructured into a variable, but it may not be otherwise used\n * in code outside of a type annotation.\n *\n * Note that all calls to goog.requireType will be stripped by the compiler.\n *\n * @param {string} namespace Namespace (as was given in goog.provide,\n * goog.module, or goog.declareModuleId) in the form\n * \"goog.package.part\".\n * @return {?}\n */\ngoog.requireType = function(namespace) {\n // Return an empty object so that single-level destructuring of the return\n // value doesn't crash at runtime when using the debug loader. Multi-level\n // destructuring isn't supported.\n return {};\n};\n\n\n/**\n * Path for included scripts.\n * @type {string}\n */\ngoog.basePath = '';\n\n\n/**\n * A hook for overriding the base path.\n * @type {string|undefined}\n */\ngoog.global.CLOSURE_BASE_PATH;\n\n\n/**\n * Whether to attempt to load Closure's deps file. By default, when uncompiled,\n * deps files will attempt to be loaded.\n * @type {boolean|undefined}\n */\ngoog.global.CLOSURE_NO_DEPS;\n\n\n/**\n * A function to import a single script. This is meant to be overridden when\n * Closure is being run in non-HTML contexts, such as web workers. It's defined\n * in the global scope so that it can be set before base.js is loaded, which\n * allows deps.js to be imported properly.\n *\n * The first parameter the script source, which is a relative URI. The second,\n * optional parameter is the script contents, in the event the script needed\n * transformation. It should return true if the script was imported, false\n * otherwise.\n * @type {(function(string, string=): boolean)|undefined}\n */\ngoog.global.CLOSURE_IMPORT_SCRIPT;\n\n\n/**\n * When defining a class Foo with an abstract method bar(), you can do:\n * Foo.prototype.bar = goog.abstractMethod\n *\n * Now if a subclass of Foo fails to override bar(), an error will be thrown\n * when bar() is invoked.\n *\n * @type {!Function}\n * @throws {Error} when invoked to indicate the method should be overridden.\n * @deprecated Use \"@abstract\" annotation instead of goog.abstractMethod in new\n * code. See\n * https://github.com/google/closure-compiler/wiki/@abstract-classes-and-methods\n */\ngoog.abstractMethod = function() {\n throw new Error('unimplemented abstract method');\n};\n\n\n/**\n * Adds a `getInstance` static method that always returns the same\n * instance object.\n * @param {!Function} ctor The constructor for the class to add the static\n * method to.\n * @suppress {missingProperties} 'instance_' isn't a property on 'Function'\n * but we don't have a better type to use here.\n */\ngoog.addSingletonGetter = function(ctor) {\n // instance_ is immediately set to prevent issues with sealed constructors\n // such as are encountered when a constructor is returned as the export object\n // of a goog.module in unoptimized code.\n // Delcare type to avoid conformance violations that ctor.instance_ is unknown\n /** @type {undefined|!Object} @suppress {underscore} */\n ctor.instance_ = undefined;\n ctor.getInstance = function() {\n if (ctor.instance_) {\n return ctor.instance_;\n }\n if (goog.DEBUG) {\n // NOTE: JSCompiler can't optimize away Array#push.\n goog.instantiatedSingletons_[goog.instantiatedSingletons_.length] = ctor;\n }\n // Cast to avoid conformance violations that ctor.instance_ is unknown\n return /** @type {!Object|undefined} */ (ctor.instance_) = new ctor;\n };\n};\n\n\n/**\n * All singleton classes that have been instantiated, for testing. Don't read\n * it directly, use the `goog.testing.singleton` module. The compiler\n * removes this variable if unused.\n * @type {!Array<!Function>}\n * @private\n */\ngoog.instantiatedSingletons_ = [];\n\n\n/**\n * @define {boolean} Whether to load goog.modules using `eval` when using\n * the debug loader. This provides a better debugging experience as the\n * source is unmodified and can be edited using Chrome Workspaces or similar.\n * However in some environments the use of `eval` is banned\n * so we provide an alternative.\n */\ngoog.LOAD_MODULE_USING_EVAL = goog.define('goog.LOAD_MODULE_USING_EVAL', true);\n\n\n/**\n * @define {boolean} Whether the exports of goog.modules should be sealed when\n * possible.\n */\ngoog.SEAL_MODULE_EXPORTS = goog.define('goog.SEAL_MODULE_EXPORTS', goog.DEBUG);\n\n\n/**\n * The registry of initialized modules:\n * The module identifier or path to module exports map.\n * @private @const {!Object<string, {exports:?,type:string,moduleId:string}>}\n */\ngoog.loadedModules_ = {};\n\n\n/**\n * True if the debug loader enabled and used.\n * @const {boolean}\n */\ngoog.DEPENDENCIES_ENABLED = !COMPILED && goog.ENABLE_DEBUG_LOADER;\n\n\n/**\n * @define {string} How to decide whether to transpile. Valid values\n * are 'always', 'never', and 'detect'. The default ('detect') is to\n * use feature detection to determine which language levels need\n * transpilation.\n */\n// NOTE(sdh): we could expand this to accept a language level to bypass\n// detection: e.g. goog.TRANSPILE == 'es5' would transpile ES6 files but\n// would leave ES3 and ES5 files alone.\ngoog.TRANSPILE = goog.define('goog.TRANSPILE', 'detect');\n\n/**\n * @define {boolean} If true assume that ES modules have already been\n * transpiled by the jscompiler (in the same way that transpile.js would\n * transpile them - to jscomp modules). Useful only for servers that wish to use\n * the debug loader and transpile server side. Thus this is only respected if\n * goog.TRANSPILE is \"never\".\n */\ngoog.ASSUME_ES_MODULES_TRANSPILED =\n goog.define('goog.ASSUME_ES_MODULES_TRANSPILED', false);\n\n\n/**\n * @define {string} Trusted Types policy name. If non-empty then Closure will\n * use Trusted Types.\n */\ngoog.TRUSTED_TYPES_POLICY_NAME =\n goog.define('goog.TRUSTED_TYPES_POLICY_NAME', 'goog');\n\n\n/**\n * @package {?boolean}\n * Visible for testing.\n */\ngoog.hasBadLetScoping = null;\n\n\n/**\n * @param {function(?):?|string} moduleDef The module definition.\n */\ngoog.loadModule = function(moduleDef) {\n // NOTE: we allow function definitions to be either in the from\n // of a string to eval (which keeps the original source intact) or\n // in a eval forbidden environment (CSP) we allow a function definition\n // which in its body must call `goog.module`, and return the exports\n // of the module.\n var previousState = goog.moduleLoaderState_;\n try {\n goog.moduleLoaderState_ = {\n moduleName: '',\n declareLegacyNamespace: false,\n type: goog.ModuleType.GOOG\n };\n var origExports = {};\n var exports = origExports;\n if (typeof moduleDef === 'function') {\n exports = moduleDef.call(undefined, exports);\n } else if (typeof moduleDef === 'string') {\n exports = goog.loadModuleFromSource_.call(undefined, exports, moduleDef);\n } else {\n throw new Error('Invalid module definition');\n }\n\n var moduleName = goog.moduleLoaderState_.moduleName;\n if (typeof moduleName === 'string' && moduleName) {\n // Don't seal legacy namespaces as they may be used as a parent of\n // another namespace\n if (goog.moduleLoaderState_.declareLegacyNamespace) {\n // Whether exports was overwritten via default export assignment.\n // This is important for legacy namespaces as it dictates whether\n // previously a previously loaded implicit namespace should be clobbered\n // or not.\n var isDefaultExport = origExports !== exports;\n goog.constructNamespace_(moduleName, exports, isDefaultExport);\n } else if (\n goog.SEAL_MODULE_EXPORTS && Object.seal &&\n typeof exports == 'object' && exports != null) {\n Object.seal(exports);\n }\n\n var data = {\n exports: exports,\n type: goog.ModuleType.GOOG,\n moduleId: goog.moduleLoaderState_.moduleName\n };\n goog.loadedModules_[moduleName] = data;\n } else {\n throw new Error('Invalid module name \\\"' + moduleName + '\\\"');\n }\n } finally {\n goog.moduleLoaderState_ = previousState;\n }\n};\n\n\n/**\n * @private @const\n */\ngoog.loadModuleFromSource_ =\n /** @type {function(!Object, string):?} */ (function(exports) {\n // NOTE: we avoid declaring parameters or local variables here to avoid\n // masking globals or leaking values into the module definition.\n 'use strict';\n eval(goog.CLOSURE_EVAL_PREFILTER_.createScript(arguments[1]));\n return exports;\n });\n\n\n/**\n * Normalize a file path by removing redundant \"..\" and extraneous \".\" file\n * path components.\n * @param {string} path\n * @return {string}\n * @private\n */\ngoog.normalizePath_ = function(path) {\n var components = path.split('/');\n var i = 0;\n while (i < components.length) {\n if (components[i] == '.') {\n components.splice(i, 1);\n } else if (\n i && components[i] == '..' && components[i - 1] &&\n components[i - 1] != '..') {\n components.splice(--i, 2);\n } else {\n i++;\n }\n }\n return components.join('/');\n};\n\n\n/**\n * Provides a hook for loading a file when using Closure's goog.require() API\n * with goog.modules. In particular this hook is provided to support Node.js.\n *\n * @type {(function(string):string)|undefined}\n */\ngoog.global.CLOSURE_LOAD_FILE_SYNC;\n\n\n/**\n * Loads file by synchronous XHR. Should not be used in production environments.\n * @param {string} src Source URL.\n * @return {?string} File contents, or null if load failed.\n * @private\n */\ngoog.loadFileSync_ = function(src) {\n if (goog.global.CLOSURE_LOAD_FILE_SYNC) {\n return goog.global.CLOSURE_LOAD_FILE_SYNC(src);\n } else {\n try {\n /** @type {XMLHttpRequest} */\n var xhr = new goog.global['XMLHttpRequest']();\n xhr.open('get', src, false);\n xhr.send();\n // NOTE: Successful http: requests have a status of 200, but successful\n // file: requests may have a status of zero. Any other status, or a\n // thrown exception (particularly in case of file: requests) indicates\n // some sort of error, which we treat as a missing or unavailable file.\n return xhr.status == 0 || xhr.status == 200 ? xhr.responseText : null;\n } catch (err) {\n // No need to rethrow or log, since errors should show up on their own.\n return null;\n }\n }\n};\n\n//==============================================================================\n// Language Enhancements\n//==============================================================================\n\n\n/**\n * This is a \"fixed\" version of the typeof operator. It differs from the typeof\n * operator in such a way that null returns 'null' and arrays return 'array'.\n * @param {?} value The value to get the type of.\n * @return {string} The name of the type.\n */\ngoog.typeOf = function(value) {\n var s = typeof value;\n\n if (s != 'object') {\n return s;\n }\n\n if (!value) {\n return 'null';\n }\n\n if (Array.isArray(value)) {\n return 'array';\n }\n return s;\n};\n\n\n/**\n * Returns true if the object looks like an array. To qualify as array like\n * the value needs to be either a NodeList or an object with a Number length\n * property. Note that for this function neither strings nor functions are\n * considered \"array-like\".\n *\n * @param {?} val Variable to test.\n * @return {boolean} Whether variable is an array.\n */\ngoog.isArrayLike = function(val) {\n var type = goog.typeOf(val);\n // We do not use goog.isObject here in order to exclude function values.\n return type == 'array' || type == 'object' && typeof val.length == 'number';\n};\n\n\n/**\n * Returns true if the object looks like a Date. To qualify as Date-like the\n * value needs to be an object and have a getFullYear() function.\n * @param {?} val Variable to test.\n * @return {boolean} Whether variable is a like a Date.\n */\ngoog.isDateLike = function(val) {\n return goog.isObject(val) && typeof val.getFullYear == 'function';\n};\n\n\n/**\n * Returns true if the specified value is an object. This includes arrays and\n * functions.\n * @param {?} val Variable to test.\n * @return {boolean} Whether variable is an object.\n */\ngoog.isObject = function(val) {\n var type = typeof val;\n return type == 'object' && val != null || type == 'function';\n // return Object(val) === val also works, but is slower, especially if val is\n // not an object.\n};\n\n\n/**\n * Gets a unique ID for an object. This mutates the object so that further calls\n * with the same object as a parameter returns the same value. The unique ID is\n * guaranteed to be unique across the current session amongst objects that are\n * passed into `getUid`. There is no guarantee that the ID is unique or\n * consistent across sessions. It is unsafe to generate unique ID for function\n * prototypes.\n *\n * @param {Object} obj The object to get the unique ID for.\n * @return {number} The unique ID for the object.\n */\ngoog.getUid = function(obj) {\n // TODO(arv): Make the type stricter, do not accept null.\n return Object.prototype.hasOwnProperty.call(obj, goog.UID_PROPERTY_) &&\n obj[goog.UID_PROPERTY_] ||\n (obj[goog.UID_PROPERTY_] = ++goog.uidCounter_);\n};\n\n\n/**\n * Whether the given object is already assigned a unique ID.\n *\n * This does not modify the object.\n *\n * @param {!Object} obj The object to check.\n * @return {boolean} Whether there is an assigned unique id for the object.\n */\ngoog.hasUid = function(obj) {\n return !!obj[goog.UID_PROPERTY_];\n};\n\n\n/**\n * Removes the unique ID from an object. This is useful if the object was\n * previously mutated using `goog.getUid` in which case the mutation is\n * undone.\n * @param {Object} obj The object to remove the unique ID field from.\n */\ngoog.removeUid = function(obj) {\n // TODO(arv): Make the type stricter, do not accept null.\n\n // In IE, DOM nodes are not instances of Object and throw an exception if we\n // try to delete. Instead we try to use removeAttribute.\n if (obj !== null && 'removeAttribute' in obj) {\n obj.removeAttribute(goog.UID_PROPERTY_);\n }\n\n try {\n delete obj[goog.UID_PROPERTY_];\n } catch (ex) {\n }\n};\n\n\n/**\n * Name for unique ID property. Initialized in a way to help avoid collisions\n * with other closure JavaScript on the same page.\n * @type {string}\n * @private\n */\ngoog.UID_PROPERTY_ = 'closure_uid_' + ((Math.random() * 1e9) >>> 0);\n\n\n/**\n * Counter for UID.\n * @type {number}\n * @private\n */\ngoog.uidCounter_ = 0;\n\n\n/**\n * Clones a value. The input may be an Object, Array, or basic type. Objects and\n * arrays will be cloned recursively.\n *\n * WARNINGS:\n * <code>goog.cloneObject</code> does not detect reference loops. Objects that\n * refer to themselves will cause infinite recursion.\n *\n * <code>goog.cloneObject</code> is unaware of unique identifiers, and copies\n * UIDs created by <code>getUid</code> into cloned results.\n *\n * @param {*} obj The value to clone.\n * @return {*} A clone of the input value.\n * @deprecated goog.cloneObject is unsafe. Prefer the goog.object methods.\n */\ngoog.cloneObject = function(obj) {\n var type = goog.typeOf(obj);\n if (type == 'object' || type == 'array') {\n if (typeof obj.clone === 'function') {\n return obj.clone();\n }\n if (typeof Map !== 'undefined' && obj instanceof Map) {\n return new Map(obj);\n } else if (typeof Set !== 'undefined' && obj instanceof Set) {\n return new Set(obj);\n }\n var clone = type == 'array' ? [] : {};\n for (var key in obj) {\n clone[key] = goog.cloneObject(obj[key]);\n }\n return clone;\n }\n\n return obj;\n};\n\n\n/**\n * A native implementation of goog.bind.\n * @param {?function(this:T, ...)} fn A function to partially apply.\n * @param {T} selfObj Specifies the object which this should point to when the\n * function is run.\n * @param {...*} var_args Additional arguments that are partially applied to the\n * function.\n * @return {!Function} A partially-applied form of the function goog.bind() was\n * invoked as a method of.\n * @template T\n * @private\n */\ngoog.bindNative_ = function(fn, selfObj, var_args) {\n return /** @type {!Function} */ (fn.call.apply(fn.bind, arguments));\n};\n\n\n/**\n * A pure-JS implementation of goog.bind.\n * @param {?function(this:T, ...)} fn A function to partially apply.\n * @param {T} selfObj Specifies the object which this should point to when the\n * function is run.\n * @param {...*} var_args Additional arguments that are partially applied to the\n * function.\n * @return {!Function} A partially-applied form of the function goog.bind() was\n * invoked as a method of.\n * @template T\n * @private\n */\ngoog.bindJs_ = function(fn, selfObj, var_args) {\n if (!fn) {\n throw new Error();\n }\n\n if (arguments.length > 2) {\n var boundArgs = Array.prototype.slice.call(arguments, 2);\n return function() {\n // Prepend the bound arguments to the current arguments.\n var newArgs = Array.prototype.slice.call(arguments);\n Array.prototype.unshift.apply(newArgs, boundArgs);\n return fn.apply(selfObj, newArgs);\n };\n\n } else {\n return function() {\n return fn.apply(selfObj, arguments);\n };\n }\n};\n\n\n/**\n * Partially applies this function to a particular 'this object' and zero or\n * more arguments. The result is a new function with some arguments of the first\n * function pre-filled and the value of this 'pre-specified'.\n *\n * Remaining arguments specified at call-time are appended to the pre-specified\n * ones.\n *\n * Also see: {@link #partial}.\n *\n * Usage:\n * <pre>var barMethBound = goog.bind(myFunction, myObj, 'arg1', 'arg2');\n * barMethBound('arg3', 'arg4');</pre>\n *\n * @param {?function(this:T, ...)} fn A function to partially apply.\n * @param {T} selfObj Specifies the object which this should point to when the\n * function is run.\n * @param {...*} var_args Additional arguments that are partially applied to the\n * function.\n * @return {!Function} A partially-applied form of the function goog.bind() was\n * invoked as a method of.\n * @template T\n * @suppress {deprecated} See above.\n * @deprecated use `=> {}` or Function.prototype.bind instead.\n */\ngoog.bind = function(fn, selfObj, var_args) {\n // TODO(nicksantos): narrow the type signature.\n if (Function.prototype.bind &&\n // NOTE(nicksantos): Somebody pulled base.js into the default Chrome\n // extension environment. This means that for Chrome extensions, they get\n // the implementation of Function.prototype.bind that calls goog.bind\n // instead of the native one. Even worse, we don't want to introduce a\n // circular dependency between goog.bind and Function.prototype.bind, so\n // we have to hack this to make sure it works correctly.\n Function.prototype.bind.toString().indexOf('native code') != -1) {\n goog.bind = goog.bindNative_;\n } else {\n goog.bind = goog.bindJs_;\n }\n return goog.bind.apply(null, arguments);\n};\n\n\n/**\n * Like goog.bind(), except that a 'this object' is not required. Useful when\n * the target function is already bound.\n *\n * Usage:\n * var g = goog.partial(f, arg1, arg2);\n * g(arg3, arg4);\n *\n * @param {Function} fn A function to partially apply.\n * @param {...*} var_args Additional arguments that are partially applied to fn.\n * @return {!Function} A partially-applied form of the function goog.partial()\n * was invoked as a method of.\n */\ngoog.partial = function(fn, var_args) {\n var args = Array.prototype.slice.call(arguments, 1);\n return function() {\n // Clone the array (with slice()) and append additional arguments\n // to the existing arguments.\n var newArgs = args.slice();\n newArgs.push.apply(newArgs, arguments);\n return fn.apply(/** @type {?} */ (this), newArgs);\n };\n};\n\n\n/**\n * @return {number} An integer value representing the number of milliseconds\n * between midnight, January 1, 1970 and the current time.\n * @deprecated Use Date.now\n */\ngoog.now = function() {\n return Date.now();\n};\n\n\n/**\n * Evals JavaScript in the global scope.\n *\n * Throws an exception if neither execScript or eval is defined.\n * @param {string|!TrustedScript} script JavaScript string.\n */\ngoog.globalEval = function(script) {\n (0, eval)(script);\n};\n\n\n/**\n * Optional map of CSS class names to obfuscated names used with\n * goog.getCssName().\n * @private {!Object<string, string>|undefined}\n * @see goog.setCssNameMapping\n */\ngoog.cssNameMapping_;\n\n\n/**\n * Optional obfuscation style for CSS class names. Should be set to either\n * 'BY_WHOLE' or 'BY_PART' if defined.\n * @type {string|undefined}\n * @private\n * @see goog.setCssNameMapping\n */\ngoog.cssNameMappingStyle_;\n\n\n\n/**\n * A hook for modifying the default behavior goog.getCssName. The function\n * if present, will receive the standard output of the goog.getCssName as\n * its input.\n *\n * @type {(function(string):string)|undefined}\n */\ngoog.global.CLOSURE_CSS_NAME_MAP_FN;\n\n\n/**\n * Handles strings that are intended to be used as CSS class names.\n *\n * This function works in tandem with @see goog.setCssNameMapping.\n *\n * Without any mapping set, the arguments are simple joined with a hyphen and\n * passed through unaltered.\n *\n * When there is a mapping, there are two possible styles in which these\n * mappings are used. In the BY_PART style, each part (i.e. in between hyphens)\n * of the passed in css name is rewritten according to the map. In the BY_WHOLE\n * style, the full css name is looked up in the map directly. If a rewrite is\n * not specified by the map, the compiler will output a warning.\n *\n * When the mapping is passed to the compiler, it will replace calls to\n * goog.getCssName with the strings from the mapping, e.g.\n * var x = goog.getCssName('foo');\n * var y = goog.getCssName(this.baseClass, 'active');\n * becomes:\n * var x = 'foo';\n * var y = this.baseClass + '-active';\n *\n * If one argument is passed it will be processed, if two are passed only the\n * modifier will be processed, as it is assumed the first argument was generated\n * as a result of calling goog.getCssName.\n *\n * @param {string} className The class name.\n * @param {string=} opt_modifier A modifier to be appended to the class name.\n * @return {string} The class name or the concatenation of the class name and\n * the modifier.\n */\ngoog.getCssName = function(className, opt_modifier) {\n // String() is used for compatibility with compiled soy where the passed\n // className can be non-string objects.\n if (String(className).charAt(0) == '.') {\n throw new Error(\n 'className passed in goog.getCssName must not start with \".\".' +\n ' You passed: ' + className);\n }\n\n var getMapping = function(cssName) {\n return goog.cssNameMapping_[cssName] || cssName;\n };\n\n var renameByParts = function(cssName) {\n // Remap all the parts individually.\n var parts = cssName.split('-');\n var mapped = [];\n for (var i = 0; i < parts.length; i++) {\n mapped.push(getMapping(parts[i]));\n }\n return mapped.join('-');\n };\n\n var rename;\n if (goog.cssNameMapping_) {\n rename =\n goog.cssNameMappingStyle_ == 'BY_WHOLE' ? getMapping : renameByParts;\n } else {\n rename = function(a) {\n return a;\n };\n }\n\n var result =\n opt_modifier ? className + '-' + rename(opt_modifier) : rename(className);\n\n // The special CLOSURE_CSS_NAME_MAP_FN allows users to specify further\n // processing of the class name.\n if (goog.global.CLOSURE_CSS_NAME_MAP_FN) {\n return goog.global.CLOSURE_CSS_NAME_MAP_FN(result);\n }\n\n return result;\n};\n\n\n/**\n * Sets the map to check when returning a value from goog.getCssName(). Example:\n * <pre>\n * goog.setCssNameMapping({\n * \"goog\": \"a\",\n * \"disabled\": \"b\",\n * });\n *\n * var x = goog.getCssName('goog');\n * // The following evaluates to: \"a a-b\".\n * goog.getCssName('goog') + ' ' + goog.getCssName(x, 'disabled')\n * </pre>\n * When declared as a map of string literals to string literals, the JSCompiler\n * will replace all calls to goog.getCssName() using the supplied map if the\n * --process_closure_primitives flag is set.\n *\n * @param {!Object} mapping A map of strings to strings where keys are possible\n * arguments to goog.getCssName() and values are the corresponding values\n * that should be returned.\n * @param {string=} opt_style The style of css name mapping. There are two valid\n * options: 'BY_PART', and 'BY_WHOLE'.\n * @see goog.getCssName for a description.\n */\ngoog.setCssNameMapping = function(mapping, opt_style) {\n goog.cssNameMapping_ = mapping;\n goog.cssNameMappingStyle_ = opt_style;\n};\n\n\n/**\n * To use CSS renaming in compiled mode, one of the input files should have a\n * call to goog.setCssNameMapping() with an object literal that the JSCompiler\n * can extract and use to replace all calls to goog.getCssName(). In uncompiled\n * mode, JavaScript code should be loaded before this base.js file that declares\n * a global variable, CLOSURE_CSS_NAME_MAPPING, which is used below. This is\n * to ensure that the mapping is loaded before any calls to goog.getCssName()\n * are made in uncompiled mode.\n *\n * A hook for overriding the CSS name mapping.\n * @type {!Object<string, string>|undefined}\n */\ngoog.global.CLOSURE_CSS_NAME_MAPPING;\n\n\nif (!COMPILED && goog.global.CLOSURE_CSS_NAME_MAPPING) {\n // This does not call goog.setCssNameMapping() because the JSCompiler\n // requires that goog.setCssNameMapping() be called with an object literal.\n goog.cssNameMapping_ = goog.global.CLOSURE_CSS_NAME_MAPPING;\n}\n\n/**\n * Options bag type for `goog.getMsg()` third argument.\n *\n * It is important to note that these options need to be known at compile time,\n * so they must always be provided to `goog.getMsg()` as an actual object\n * literal in the function call. Otherwise, closure-compiler will report an\n * error.\n * @record\n */\ngoog.GetMsgOptions = function() {};\n\n/**\n * If `true`, escape '<' in the message string to '<'.\n *\n * Used by Closure Templates where the generated code size and performance is\n * critical which is why {@link goog.html.SafeHtmlFormatter} is not used.\n * The value must be literal `true` or `false`.\n * @type {boolean|undefined}\n */\ngoog.GetMsgOptions.prototype.html;\n\n/**\n * If `true`, unescape common html entities: >, <, ', " and\n * &.\n *\n * Used for messages not in HTML context, such as with the `textContent`\n * property.\n * The value must be literal `true` or `false`.\n * @type {boolean|undefined}\n */\ngoog.GetMsgOptions.prototype.unescapeHtmlEntities;\n\n/**\n * Associates placeholder names with strings showing how their values are\n * obtained.\n *\n * This field is intended for use in automatically generated JS code.\n * Human-written code should use meaningful placeholder names instead.\n *\n * closure-compiler uses this as the contents of the `<ph>` tag in the\n * XMB file it generates or defaults to `-` for historical reasons.\n *\n * Must be an object literal.\n * Ignored at runtime.\n * Keys are placeholder names.\n * Values are string literals indicating how the value is obtained.\n * Typically this is a snippet of source code.\n * @type {!Object<string, string>|undefined}\n */\ngoog.GetMsgOptions.prototype.original_code;\n\n/**\n * Associates placeholder names with example values.\n *\n * closure-compiler uses this as the contents of the `<ex>` tag in the\n * XMB file it generates or defaults to `-` for historical reasons.\n *\n * Must be an object literal.\n * Ignored at runtime.\n * Keys are placeholder names.\n * Values are string literals containing example placeholder values.\n * (e.g. \"George McFly\" for a name placeholder)\n * @type {!Object<string, string>|undefined}\n */\ngoog.GetMsgOptions.prototype.example;\n\n/**\n * Gets a localized message.\n *\n * This function is a compiler primitive. If you give the compiler a localized\n * message bundle, it will replace the string at compile-time with a localized\n * version, and expand goog.getMsg call to a concatenated string.\n *\n * Messages must be initialized in the form:\n * <code>\n * var MSG_NAME = goog.getMsg('Hello {$placeholder}', {'placeholder': 'world'});\n * </code>\n *\n * This function produces a string which should be treated as plain text. Use\n * {@link goog.html.SafeHtmlFormatter} in conjunction with goog.getMsg to\n * produce SafeHtml.\n *\n * @param {string} str Translatable string, places holders in the form {$foo}.\n * @param {!Object<string, string>=} opt_values Maps place holder name to value.\n * @param {!goog.GetMsgOptions=} opt_options see `goog.GetMsgOptions`\n * @return {string} message with placeholders filled.\n */\ngoog.getMsg = function(str, opt_values, opt_options) {\n if (opt_options && opt_options.html) {\n // Note that '&' is not replaced because the translation can contain HTML\n // entities.\n str = str.replace(/</g, '<');\n }\n if (opt_options && opt_options.unescapeHtmlEntities) {\n // Note that \"&\" must be the last to avoid \"creating\" new entities.\n str = str.replace(/</g, '<')\n .replace(/>/g, '>')\n .replace(/'/g, '\\'')\n .replace(/"/g, '\"')\n .replace(/&/g, '&');\n }\n if (opt_values) {\n str = str.replace(/\\{\\$([^}]+)}/g, function(match, key) {\n return (opt_values != null && key in opt_values) ? opt_values[key] :\n match;\n });\n }\n return str;\n};\n\n\n/**\n * Gets a localized message. If the message does not have a translation, gives a\n * fallback message.\n *\n * This is useful when introducing a new message that has not yet been\n * translated into all languages.\n *\n * This function is a compiler primitive. Must be used in the form:\n * <code>var x = goog.getMsgWithFallback(MSG_A, MSG_B);</code>\n * where MSG_A and MSG_B were initialized with goog.getMsg.\n *\n * @param {string} a The preferred message.\n * @param {string} b The fallback message.\n * @return {string} The best translated message.\n */\ngoog.getMsgWithFallback = function(a, b) {\n return a;\n};\n\n\n/**\n * Exposes an unobfuscated global namespace path for the given object.\n * Note that fields of the exported object *will* be obfuscated, unless they are\n * exported in turn via this function or goog.exportProperty.\n *\n * Also handy for making public items that are defined in anonymous closures.\n *\n * ex. goog.exportSymbol('public.path.Foo', Foo);\n *\n * ex. goog.exportSymbol('public.path.Foo.staticFunction', Foo.staticFunction);\n * public.path.Foo.staticFunction();\n *\n * ex. goog.exportSymbol('public.path.Foo.prototype.myMethod',\n * Foo.prototype.myMethod);\n * new public.path.Foo().myMethod();\n *\n * @param {string} publicPath Unobfuscated name to export.\n * @param {*} object Object the name should point to.\n * @param {?Object=} objectToExportTo The object to add the path to; default\n * is goog.global.\n */\ngoog.exportSymbol = function(publicPath, object, objectToExportTo) {\n goog.exportPath_(\n publicPath, object, /* overwriteImplicit= */ true, objectToExportTo);\n};\n\n\n/**\n * Exports a property unobfuscated into the object's namespace.\n * ex. goog.exportProperty(Foo, 'staticFunction', Foo.staticFunction);\n * ex. goog.exportProperty(Foo.prototype, 'myMethod', Foo.prototype.myMethod);\n * @param {Object} object Object whose static property is being exported.\n * @param {string} publicName Unobfuscated name to export.\n * @param {*} symbol Object the name should point to.\n */\ngoog.exportProperty = function(object, publicName, symbol) {\n object[publicName] = symbol;\n};\n\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * Usage:\n * <pre>\n * function ParentClass(a, b) { }\n * ParentClass.prototype.foo = function(a) { };\n *\n * function ChildClass(a, b, c) {\n * ChildClass.base(this, 'constructor', a, b);\n * }\n * goog.inherits(ChildClass, ParentClass);\n *\n * var child = new ChildClass('a', 'b', 'see');\n * child.foo(); // This works.\n * </pre>\n *\n * @param {!Function} childCtor Child class.\n * @param {!Function} parentCtor Parent class.\n * @suppress {strictMissingProperties} superClass_ and base is not defined on\n * Function.\n * @deprecated Use ECMAScript class syntax instead.\n */\ngoog.inherits = function(childCtor, parentCtor) {\n /** @constructor */\n function tempCtor() {}\n tempCtor.prototype = parentCtor.prototype;\n childCtor.superClass_ = parentCtor.prototype;\n childCtor.prototype = new tempCtor();\n /** @override */\n childCtor.prototype.constructor = childCtor;\n\n /**\n * Calls superclass constructor/method.\n *\n * This function is only available if you use goog.inherits to\n * express inheritance relationships between classes.\n *\n * NOTE: This is a replacement for goog.base and for superClass_\n * property defined in childCtor.\n *\n * @param {!Object} me Should always be \"this\".\n * @param {string} methodName The method name to call. Calling\n * superclass constructor can be done with the special string\n * 'constructor'.\n * @param {...*} var_args The arguments to pass to superclass\n * method/constructor.\n * @return {*} The return value of the superclass method/constructor.\n */\n childCtor.base = function(me, methodName, var_args) {\n // Copying using loop to avoid deop due to passing arguments object to\n // function. This is faster in many JS engines as of late 2014.\n var args = new Array(arguments.length - 2);\n for (var i = 2; i < arguments.length; i++) {\n args[i - 2] = arguments[i];\n }\n return parentCtor.prototype[methodName].apply(me, args);\n };\n};\n\n\n/**\n * Allow for aliasing within scope functions. This function exists for\n * uncompiled code - in compiled code the calls will be inlined and the aliases\n * applied. In uncompiled code the function is simply run since the aliases as\n * written are valid JavaScript.\n *\n *\n * @param {function()} fn Function to call. This function can contain aliases\n * to namespaces (e.g. \"var dom = goog.dom\") or classes\n * (e.g. \"var Timer = goog.Timer\").\n * @deprecated Use goog.module instead.\n */\ngoog.scope = function(fn) {\n if (goog.isInModuleLoader_()) {\n throw new Error('goog.scope is not supported within a module.');\n }\n fn.call(goog.global);\n};\n\n\n/*\n * To support uncompiled, strict mode bundles that use eval to divide source\n * like so:\n * eval('someSource;//# sourceUrl sourcefile.js');\n * We need to export the globally defined symbols \"goog\" and \"COMPILED\".\n * Exporting \"goog\" breaks the compiler optimizations, so we required that\n * be defined externally.\n * NOTE: We don't use goog.exportSymbol here because we don't want to trigger\n * extern generation when that compiler option is enabled.\n */\nif (!COMPILED) {\n goog.global['COMPILED'] = COMPILED;\n}\n\n\n//==============================================================================\n// goog.defineClass implementation\n//==============================================================================\n\n\n/**\n * Creates a restricted form of a Closure \"class\":\n * - from the compiler's perspective, the instance returned from the\n * constructor is sealed (no new properties may be added). This enables\n * better checks.\n * - the compiler will rewrite this definition to a form that is optimal\n * for type checking and optimization (initially this will be a more\n * traditional form).\n *\n * @param {Function} superClass The superclass, Object or null.\n * @param {goog.defineClass.ClassDescriptor} def\n * An object literal describing\n * the class. It may have the following properties:\n * \"constructor\": the constructor function\n * \"statics\": an object literal containing methods to add to the constructor\n * as \"static\" methods or a function that will receive the constructor\n * function as its only parameter to which static properties can\n * be added.\n * all other properties are added to the prototype.\n * @return {!Function} The class constructor.\n * @deprecated Use ECMAScript class syntax instead.\n */\ngoog.defineClass = function(superClass, def) {\n // TODO(johnlenz): consider making the superClass an optional parameter.\n var constructor = def.constructor;\n var statics = def.statics;\n // Wrap the constructor prior to setting up the prototype and static methods.\n if (!constructor || constructor == Object.prototype.constructor) {\n constructor = function() {\n throw new Error(\n 'cannot instantiate an interface (no constructor defined).');\n };\n }\n\n var cls = goog.defineClass.createSealingConstructor_(constructor, superClass);\n if (superClass) {\n goog.inherits(cls, superClass);\n }\n\n // Remove all the properties that should not be copied to the prototype.\n delete def.constructor;\n delete def.statics;\n\n goog.defineClass.applyProperties_(cls.prototype, def);\n if (statics != null) {\n if (statics instanceof Function) {\n statics(cls);\n } else {\n goog.defineClass.applyProperties_(cls, statics);\n }\n }\n\n return cls;\n};\n\n\n/**\n * @typedef {{\n * constructor: (!Function|undefined),\n * statics: (Object|undefined|function(Function):void)\n * }}\n */\ngoog.defineClass.ClassDescriptor;\n\n\n/**\n * @define {boolean} Whether the instances returned by goog.defineClass should\n * be sealed when possible.\n *\n * When sealing is disabled the constructor function will not be wrapped by\n * goog.defineClass, making it incompatible with ES6 class methods.\n */\ngoog.defineClass.SEAL_CLASS_INSTANCES =\n goog.define('goog.defineClass.SEAL_CLASS_INSTANCES', goog.DEBUG);\n\n\n/**\n * If goog.defineClass.SEAL_CLASS_INSTANCES is enabled and Object.seal is\n * defined, this function will wrap the constructor in a function that seals the\n * results of the provided constructor function.\n *\n * @param {!Function} ctr The constructor whose results maybe be sealed.\n * @param {Function} superClass The superclass constructor.\n * @return {!Function} The replacement constructor.\n * @private\n */\ngoog.defineClass.createSealingConstructor_ = function(ctr, superClass) {\n if (!goog.defineClass.SEAL_CLASS_INSTANCES) {\n // Do now wrap the constructor when sealing is disabled. Angular code\n // depends on this for injection to work properly.\n return ctr;\n }\n\n // NOTE: The sealing behavior has been removed\n\n /**\n * @this {Object}\n * @return {?}\n */\n var wrappedCtr = function() {\n // Don't seal an instance of a subclass when it calls the constructor of\n // its super class as there is most likely still setup to do.\n var instance = ctr.apply(this, arguments) || this;\n instance[goog.UID_PROPERTY_] = instance[goog.UID_PROPERTY_];\n\n return instance;\n };\n\n return wrappedCtr;\n};\n\n\n\n// TODO(johnlenz): share these values with the goog.object\n/**\n * The names of the fields that are defined on Object.prototype.\n * @type {!Array<string>}\n * @private\n * @const\n */\ngoog.defineClass.OBJECT_PROTOTYPE_FIELDS_ = [\n 'constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable',\n 'toLocaleString', 'toString', 'valueOf'\n];\n\n\n// TODO(johnlenz): share this function with the goog.object\n/**\n * @param {!Object} target The object to add properties to.\n * @param {!Object} source The object to copy properties from.\n * @private\n */\ngoog.defineClass.applyProperties_ = function(target, source) {\n // TODO(johnlenz): update this to support ES5 getters/setters\n\n var key;\n for (key in source) {\n if (Object.prototype.hasOwnProperty.call(source, key)) {\n target[key] = source[key];\n }\n }\n\n // For IE the for-in-loop does not contain any properties that are not\n // enumerable on the prototype object (for example isPrototypeOf from\n // Object.prototype) and it will also not include 'replace' on objects that\n // extend String and change 'replace' (not that it is common for anyone to\n // extend anything except Object).\n for (var i = 0; i < goog.defineClass.OBJECT_PROTOTYPE_FIELDS_.length; i++) {\n key = goog.defineClass.OBJECT_PROTOTYPE_FIELDS_[i];\n if (Object.prototype.hasOwnProperty.call(source, key)) {\n target[key] = source[key];\n }\n }\n};\n\n/**\n * Returns the parameter.\n * @param {string} s\n * @return {string}\n * @private\n */\ngoog.identity_ = function(s) {\n return s;\n};\n\n\n/**\n * Creates Trusted Types policy if Trusted Types are supported by the browser.\n * The policy just blesses any string as a Trusted Type. It is not visibility\n * restricted because anyone can also call trustedTypes.createPolicy directly.\n * However, the allowed names should be restricted by a HTTP header and the\n * reference to the created policy should be visibility restricted.\n * @param {string} name\n * @return {?TrustedTypePolicy}\n */\ngoog.createTrustedTypesPolicy = function(name) {\n var policy = null;\n var policyFactory = goog.global.trustedTypes;\n if (!policyFactory || !policyFactory.createPolicy) {\n return policy;\n }\n // trustedTypes.createPolicy throws if called with a name that is already\n // registered, even in report-only mode. Until the API changes, catch the\n // error not to break the applications functionally. In such case, the code\n // will fall back to using regular Safe Types.\n // TODO(koto): Remove catching once createPolicy API stops throwing.\n try {\n policy = policyFactory.createPolicy(name, {\n createHTML: goog.identity_,\n createScript: goog.identity_,\n createScriptURL: goog.identity_\n });\n } catch (e) {\n goog.logToConsole_(e.message);\n }\n return policy;\n};\n\n// There's a bug in the compiler where without collapse properties the\n// Closure namespace defines do not guard code correctly. To help reduce code\n// size also check for !COMPILED even though it redundant until this is fixed.\nif (!COMPILED && goog.DEPENDENCIES_ENABLED) {\n\n\n /**\n * Tries to detect whether the current browser is Edge, based on the user\n * agent. This matches only pre-Chromium Edge.\n * @see https://docs.microsoft.com/en-us/microsoft-edge/web-platform/user-agent-string\n * @return {boolean} True if the current browser is Edge.\n * @private\n */\n goog.isEdge_ = function() {\n var userAgent = goog.global.navigator && goog.global.navigator.userAgent ?\n goog.global.navigator.userAgent :\n '';\n var edgeRe = /Edge\\/(\\d+)(\\.\\d)*/i;\n return !!userAgent.match(edgeRe);\n };\n\n\n /**\n * Tries to detect whether is in the context of an HTML document.\n * @return {boolean} True if it looks like HTML document.\n * @private\n */\n goog.inHtmlDocument_ = function() {\n /** @type {!Document} */\n var doc = goog.global.document;\n return doc != null && 'write' in doc; // XULDocument misses write.\n };\n\n\n /**\n * We'd like to check for if the document readyState is 'loading'; however\n * there are bugs on IE 10 and below where the readyState being anything other\n * than 'complete' is not reliable.\n * @return {boolean}\n * @private\n */\n goog.isDocumentLoading_ = function() {\n // attachEvent is available on IE 6 thru 10 only, and thus can be used to\n // detect those browsers.\n /** @type {!HTMLDocument} */\n var doc = goog.global.document;\n return doc.attachEvent ? doc.readyState != 'complete' :\n doc.readyState == 'loading';\n };\n\n\n /**\n * Tries to detect the base path of base.js script that bootstraps Closure.\n * @private\n */\n goog.findBasePath_ = function() {\n if (goog.global.CLOSURE_BASE_PATH != undefined &&\n // Anti DOM-clobbering runtime check (b/37736576).\n typeof goog.global.CLOSURE_BASE_PATH === 'string') {\n goog.basePath = goog.global.CLOSURE_BASE_PATH;\n return;\n } else if (!goog.inHtmlDocument_()) {\n return;\n }\n /** @type {!Document} */\n var doc = goog.global.document;\n // If we have a currentScript available, use it exclusively.\n var currentScript = doc.currentScript;\n if (currentScript) {\n var scripts = [currentScript];\n } else {\n var scripts = doc.getElementsByTagName('SCRIPT');\n }\n // Search backwards since the current script is in almost all cases the one\n // that has base.js.\n for (var i = scripts.length - 1; i >= 0; --i) {\n var script = /** @type {!HTMLScriptElement} */ (scripts[i]);\n var src = script.src;\n var qmark = src.lastIndexOf('?');\n var l = qmark == -1 ? src.length : qmark;\n if (src.slice(l - 7, l) == 'base.js') {\n goog.basePath = src.slice(0, l - 7);\n return;\n }\n }\n };\n\n goog.findBasePath_();\n\n /**\n * Rewrites closing script tags in input to avoid ending an enclosing script\n * tag.\n *\n * @param {string} str\n * @return {string}\n * @private\n */\n goog.protectScriptTag_ = function(str) {\n return str.replace(/<\\/(SCRIPT)/ig, '\\\\x3c/$1');\n };\n\n\n /**\n * A debug loader is responsible for downloading and executing javascript\n * files in an unbundled, uncompiled environment.\n *\n * This can be custimized via the setDependencyFactory method, or by\n * CLOSURE_IMPORT_SCRIPT/CLOSURE_LOAD_FILE_SYNC.\n *\n * @struct @constructor @final @private\n */\n goog.DebugLoader_ = function() {\n /** @private @const {!Object<string, !goog.Dependency>} */\n this.dependencies_ = {};\n /** @private @const {!Object<string, string>} */\n this.idToPath_ = {};\n /** @private @const {!Object<string, boolean>} */\n this.written_ = {};\n /** @private @const {!Array<!goog.Dependency>} */\n this.loadingDeps_ = [];\n /** @private {!Array<!goog.Dependency>} */\n this.depsToLoad_ = [];\n /** @private {boolean} */\n this.paused_ = false;\n /** @private {!goog.DependencyFactory} */\n this.factory_ = new goog.DependencyFactory();\n /** @private @const {!Object<string, !Function>} */\n this.deferredCallbacks_ = {};\n /** @private @const {!Array<string>} */\n this.deferredQueue_ = [];\n };\n\n /**\n * @param {!Array<string>} namespaces\n * @param {function(): undefined} callback Function to call once all the\n * namespaces have loaded.\n */\n goog.DebugLoader_.prototype.bootstrap = function(namespaces, callback) {\n var cb = callback;\n function resolve() {\n if (cb) {\n goog.global.setTimeout(cb, 0);\n cb = null;\n }\n }\n\n if (!namespaces.length) {\n resolve();\n return;\n }\n\n var deps = [];\n for (var i = 0; i < namespaces.length; i++) {\n var path = this.getPathFromDeps_(namespaces[i]);\n if (!path) {\n throw new Error('Unregonized namespace: ' + namespaces[i]);\n }\n deps.push(this.dependencies_[path]);\n }\n\n var require = goog.require;\n var loaded = 0;\n for (var i = 0; i < namespaces.length; i++) {\n require(namespaces[i]);\n deps[i].onLoad(function() {\n if (++loaded == namespaces.length) {\n resolve();\n }\n });\n }\n };\n\n\n /**\n * Loads the Closure Dependency file.\n *\n * Exposed a public function so CLOSURE_NO_DEPS can be set to false, base\n * loaded, setDependencyFactory called, and then this called. i.e. allows\n * custom loading of the deps file.\n */\n goog.DebugLoader_.prototype.loadClosureDeps = function() {\n // Circumvent addDependency, which would try to transpile deps.js if\n // transpile is set to always.\n var relPath = 'deps.js';\n this.depsToLoad_.push(this.factory_.createDependency(\n goog.normalizePath_(goog.basePath + relPath), relPath, [], [], {}));\n this.loadDeps_();\n };\n\n\n /**\n * Notifies the debug loader when a dependency has been requested.\n *\n * @param {string} absPathOrId Path of the dependency or goog id.\n * @param {boolean=} opt_force\n */\n goog.DebugLoader_.prototype.requested = function(absPathOrId, opt_force) {\n var path = this.getPathFromDeps_(absPathOrId);\n if (path &&\n (opt_force || this.areDepsLoaded_(this.dependencies_[path].requires))) {\n var callback = this.deferredCallbacks_[path];\n if (callback) {\n delete this.deferredCallbacks_[path];\n callback();\n }\n }\n };\n\n\n /**\n * Sets the dependency factory, which can be used to create custom\n * goog.Dependency implementations to control how dependencies are loaded.\n *\n * @param {!goog.DependencyFactory} factory\n */\n goog.DebugLoader_.prototype.setDependencyFactory = function(factory) {\n this.factory_ = factory;\n };\n\n\n /**\n * Travserses the dependency graph and queues the given dependency, and all of\n * its transitive dependencies, for loading and then starts loading if not\n * paused.\n *\n * @param {string} namespace\n * @private\n */\n goog.DebugLoader_.prototype.load_ = function(namespace) {\n if (!this.getPathFromDeps_(namespace)) {\n var errorMessage = 'goog.require could not find: ' + namespace;\n goog.logToConsole_(errorMessage);\n } else {\n var loader = this;\n\n var deps = [];\n\n /** @param {string} namespace */\n var visit = function(namespace) {\n var path = loader.getPathFromDeps_(namespace);\n\n if (!path) {\n throw new Error('Bad dependency path or symbol: ' + namespace);\n }\n\n if (loader.written_[path]) {\n return;\n }\n\n loader.written_[path] = true;\n\n var dep = loader.dependencies_[path];\n for (var i = 0; i < dep.requires.length; i++) {\n if (!goog.isProvided_(dep.requires[i])) {\n visit(dep.requires[i]);\n }\n }\n\n deps.push(dep);\n };\n\n visit(namespace);\n\n var wasLoading = !!this.depsToLoad_.length;\n this.depsToLoad_ = this.depsToLoad_.concat(deps);\n\n if (!this.paused_ && !wasLoading) {\n this.loadDeps_();\n }\n }\n };\n\n\n /**\n * Loads any queued dependencies until they are all loaded or paused.\n *\n * @private\n */\n goog.DebugLoader_.prototype.loadDeps_ = function() {\n var loader = this;\n var paused = this.paused_;\n\n while (this.depsToLoad_.length && !paused) {\n (function() {\n var loadCallDone = false;\n var dep = loader.depsToLoad_.shift();\n\n var loaded = false;\n loader.loading_(dep);\n\n var controller = {\n pause: function() {\n if (loadCallDone) {\n throw new Error('Cannot call pause after the call to load.');\n } else {\n paused = true;\n }\n },\n resume: function() {\n if (loadCallDone) {\n loader.resume_();\n } else {\n // Some dep called pause and then resume in the same load call.\n // Just keep running this same loop.\n paused = false;\n }\n },\n loaded: function() {\n if (loaded) {\n throw new Error('Double call to loaded.');\n }\n\n loaded = true;\n loader.loaded_(dep);\n },\n pending: function() {\n // Defensive copy.\n var pending = [];\n for (var i = 0; i < loader.loadingDeps_.length; i++) {\n pending.push(loader.loadingDeps_[i]);\n }\n return pending;\n },\n /**\n * @param {goog.ModuleType} type\n */\n setModuleState: function(type) {\n goog.moduleLoaderState_ = {\n type: type,\n moduleName: '',\n declareLegacyNamespace: false\n };\n },\n /** @type {function(string, string, string=)} */\n registerEs6ModuleExports: function(\n path, exports, opt_closureNamespace) {\n if (opt_closureNamespace) {\n goog.loadedModules_[opt_closureNamespace] = {\n exports: exports,\n type: goog.ModuleType.ES6,\n moduleId: opt_closureNamespace || ''\n };\n }\n },\n /** @type {function(string, ?)} */\n registerGoogModuleExports: function(moduleId, exports) {\n goog.loadedModules_[moduleId] = {\n exports: exports,\n type: goog.ModuleType.GOOG,\n moduleId: moduleId\n };\n },\n clearModuleState: function() {\n goog.moduleLoaderState_ = null;\n },\n defer: function(callback) {\n if (loadCallDone) {\n throw new Error(\n 'Cannot register with defer after the call to load.');\n }\n loader.defer_(dep, callback);\n },\n areDepsLoaded: function() {\n return loader.areDepsLoaded_(dep.requires);\n }\n };\n\n try {\n dep.load(controller);\n } finally {\n loadCallDone = true;\n }\n })();\n }\n\n if (paused) {\n this.pause_();\n }\n };\n\n\n /** @private */\n goog.DebugLoader_.prototype.pause_ = function() {\n this.paused_ = true;\n };\n\n\n /** @private */\n goog.DebugLoader_.prototype.resume_ = function() {\n if (this.paused_) {\n this.paused_ = false;\n this.loadDeps_();\n }\n };\n\n\n /**\n * Marks the given dependency as loading (load has been called but it has not\n * yet marked itself as finished). Useful for dependencies that want to know\n * what else is loading. Example: goog.modules cannot eval if there are\n * loading dependencies.\n *\n * @param {!goog.Dependency} dep\n * @private\n */\n goog.DebugLoader_.prototype.loading_ = function(dep) {\n this.loadingDeps_.push(dep);\n };\n\n\n /**\n * Marks the given dependency as having finished loading and being available\n * for require.\n *\n * @param {!goog.Dependency} dep\n * @private\n */\n goog.DebugLoader_.prototype.loaded_ = function(dep) {\n for (var i = 0; i < this.loadingDeps_.length; i++) {\n if (this.loadingDeps_[i] == dep) {\n this.loadingDeps_.splice(i, 1);\n break;\n }\n }\n\n for (var i = 0; i < this.deferredQueue_.length; i++) {\n if (this.deferredQueue_[i] == dep.path) {\n this.deferredQueue_.splice(i, 1);\n break;\n }\n }\n\n if (this.loadingDeps_.length == this.deferredQueue_.length &&\n !this.depsToLoad_.length) {\n // Something has asked to load these, but they may not be directly\n // required again later, so load them now that we know we're done loading\n // everything else. e.g. a goog module entry point.\n while (this.deferredQueue_.length) {\n this.requested(this.deferredQueue_.shift(), true);\n }\n }\n\n dep.loaded();\n };\n\n\n /**\n * @param {!Array<string>} pathsOrIds\n * @return {boolean}\n * @private\n */\n goog.DebugLoader_.prototype.areDepsLoaded_ = function(pathsOrIds) {\n for (var i = 0; i < pathsOrIds.length; i++) {\n var path = this.getPathFromDeps_(pathsOrIds[i]);\n if (!path ||\n (!(path in this.deferredCallbacks_) &&\n !goog.isProvided_(pathsOrIds[i]))) {\n return false;\n }\n }\n\n return true;\n };\n\n\n /**\n * @param {string} absPathOrId\n * @return {?string}\n * @private\n */\n goog.DebugLoader_.prototype.getPathFromDeps_ = function(absPathOrId) {\n if (absPathOrId in this.idToPath_) {\n return this.idToPath_[absPathOrId];\n } else if (absPathOrId in this.dependencies_) {\n return absPathOrId;\n } else {\n return null;\n }\n };\n\n\n /**\n * @param {!goog.Dependency} dependency\n * @param {!Function} callback\n * @private\n */\n goog.DebugLoader_.prototype.defer_ = function(dependency, callback) {\n this.deferredCallbacks_[dependency.path] = callback;\n this.deferredQueue_.push(dependency.path);\n };\n\n\n /**\n * Interface for goog.Dependency implementations to have some control over\n * loading of dependencies.\n *\n * @record\n */\n goog.LoadController = function() {};\n\n\n /**\n * Tells the controller to halt loading of more dependencies.\n */\n goog.LoadController.prototype.pause = function() {};\n\n\n /**\n * Tells the controller to resume loading of more dependencies if paused.\n */\n goog.LoadController.prototype.resume = function() {};\n\n\n /**\n * Tells the controller that this dependency has finished loading.\n *\n * This causes this to be removed from pending() and any load callbacks to\n * fire.\n */\n goog.LoadController.prototype.loaded = function() {};\n\n\n /**\n * List of dependencies on which load has been called but which have not\n * called loaded on their controller. This includes the current dependency.\n *\n * @return {!Array<!goog.Dependency>}\n */\n goog.LoadController.prototype.pending = function() {};\n\n\n /**\n * Registers an object as an ES6 module's exports so that goog.modules may\n * require it by path.\n *\n * @param {string} path Full path of the module.\n * @param {?} exports\n * @param {string=} opt_closureNamespace Closure namespace to associate with\n * this module.\n */\n goog.LoadController.prototype.registerEs6ModuleExports = function(\n path, exports, opt_closureNamespace) {};\n\n\n /**\n * Sets the current module state.\n *\n * @param {goog.ModuleType} type Type of module.\n */\n goog.LoadController.prototype.setModuleState = function(type) {};\n\n\n /**\n * Clears the current module state.\n */\n goog.LoadController.prototype.clearModuleState = function() {};\n\n\n /**\n * Registers a callback to call once the dependency is actually requested\n * via goog.require + all of the immediate dependencies have been loaded or\n * all other files have been loaded. Allows for lazy loading until\n * require'd without pausing dependency loading, which is needed on old IE.\n *\n * @param {!Function} callback\n */\n goog.LoadController.prototype.defer = function(callback) {};\n\n\n /**\n * @return {boolean}\n */\n goog.LoadController.prototype.areDepsLoaded = function() {};\n\n\n /**\n * Basic super class for all dependencies Closure Library can load.\n *\n * This default implementation is designed to load untranspiled, non-module\n * scripts in a web broswer.\n *\n * For goog.modules see {@see goog.GoogModuleDependency}.\n * For untranspiled ES6 modules {@see goog.Es6ModuleDependency}.\n *\n * @param {string} path Absolute path of this script.\n * @param {string} relativePath Path of this script relative to goog.basePath.\n * @param {!Array<string>} provides goog.provided or goog.module symbols\n * in this file.\n * @param {!Array<string>} requires goog symbols or relative paths to Closure\n * this depends on.\n * @param {!Object<string, string>} loadFlags\n * @struct @constructor\n */\n goog.Dependency = function(\n path, relativePath, provides, requires, loadFlags) {\n /** @const */\n this.path = path;\n /** @const */\n this.relativePath = relativePath;\n /** @const */\n this.provides = provides;\n /** @const */\n this.requires = requires;\n /** @const */\n this.loadFlags = loadFlags;\n /** @private {boolean} */\n this.loaded_ = false;\n /** @private {!Array<function()>} */\n this.loadCallbacks_ = [];\n };\n\n\n /**\n * @return {string} The pathname part of this dependency's path if it is a\n * URI.\n */\n goog.Dependency.prototype.getPathName = function() {\n var pathName = this.path;\n var protocolIndex = pathName.indexOf('://');\n if (protocolIndex >= 0) {\n pathName = pathName.substring(protocolIndex + 3);\n var slashIndex = pathName.indexOf('/');\n if (slashIndex >= 0) {\n pathName = pathName.substring(slashIndex + 1);\n }\n }\n return pathName;\n };\n\n\n /**\n * @param {function()} callback Callback to fire as soon as this has loaded.\n * @final\n */\n goog.Dependency.prototype.onLoad = function(callback) {\n if (this.loaded_) {\n callback();\n } else {\n this.loadCallbacks_.push(callback);\n }\n };\n\n\n /**\n * Marks this dependency as loaded and fires any callbacks registered with\n * onLoad.\n * @final\n */\n goog.Dependency.prototype.loaded = function() {\n this.loaded_ = true;\n var callbacks = this.loadCallbacks_;\n this.loadCallbacks_ = [];\n for (var i = 0; i < callbacks.length; i++) {\n callbacks[i]();\n }\n };\n\n\n /**\n * Whether or not document.written / appended script tags should be deferred.\n *\n * @private {boolean}\n */\n goog.Dependency.defer_ = false;\n\n\n /**\n * Map of script ready / state change callbacks. Old IE cannot handle putting\n * these properties on goog.global.\n *\n * @private @const {!Object<string, function(?):undefined>}\n */\n goog.Dependency.callbackMap_ = {};\n\n\n /**\n * @param {function(...?):?} callback\n * @return {string}\n * @private\n */\n goog.Dependency.registerCallback_ = function(callback) {\n var key = Math.random().toString(32);\n goog.Dependency.callbackMap_[key] = callback;\n return key;\n };\n\n\n /**\n * @param {string} key\n * @private\n */\n goog.Dependency.unregisterCallback_ = function(key) {\n delete goog.Dependency.callbackMap_[key];\n };\n\n\n /**\n * @param {string} key\n * @param {...?} var_args\n * @private\n * @suppress {unusedPrivateMembers}\n */\n goog.Dependency.callback_ = function(key, var_args) {\n if (key in goog.Dependency.callbackMap_) {\n var callback = goog.Dependency.callbackMap_[key];\n var args = [];\n for (var i = 1; i < arguments.length; i++) {\n args.push(arguments[i]);\n }\n callback.apply(undefined, args);\n } else {\n var errorMessage = 'Callback key ' + key +\n ' does not exist (was base.js loaded more than once?).';\n throw Error(errorMessage);\n }\n };\n\n\n /**\n * Starts loading this dependency. This dependency can pause loading if it\n * needs to and resume it later via the controller interface.\n *\n * When this is loaded it should call controller.loaded(). Note that this will\n * end up calling the loaded method of this dependency; there is no need to\n * call it explicitly.\n *\n * @param {!goog.LoadController} controller\n */\n goog.Dependency.prototype.load = function(controller) {\n if (goog.global.CLOSURE_IMPORT_SCRIPT) {\n if (goog.global.CLOSURE_IMPORT_SCRIPT(this.path)) {\n controller.loaded();\n } else {\n controller.pause();\n }\n return;\n }\n\n if (!goog.inHtmlDocument_()) {\n goog.logToConsole_(\n 'Cannot use default debug loader outside of HTML documents.');\n if (this.relativePath == 'deps.js') {\n // Some old code is relying on base.js auto loading deps.js failing with\n // no error before later setting CLOSURE_IMPORT_SCRIPT.\n // CLOSURE_IMPORT_SCRIPT should be set *before* base.js is loaded, or\n // CLOSURE_NO_DEPS set to true.\n goog.logToConsole_(\n 'Consider setting CLOSURE_IMPORT_SCRIPT before loading base.js, ' +\n 'or setting CLOSURE_NO_DEPS to true.');\n controller.loaded();\n } else {\n controller.pause();\n }\n return;\n }\n\n /** @type {!HTMLDocument} */\n var doc = goog.global.document;\n\n // If the user tries to require a new symbol after document load,\n // something has gone terribly wrong. Doing a document.write would\n // wipe out the page. This does not apply to the CSP-compliant method\n // of writing script tags.\n if (doc.readyState == 'complete' &&\n !goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING) {\n // Certain test frameworks load base.js multiple times, which tries\n // to write deps.js each time. If that happens, just fail silently.\n // These frameworks wipe the page between each load of base.js, so this\n // is OK.\n var isDeps = /\\bdeps.js$/.test(this.path);\n if (isDeps) {\n controller.loaded();\n return;\n } else {\n throw Error('Cannot write \"' + this.path + '\" after document load');\n }\n }\n\n var nonce = goog.getScriptNonce_();\n if (!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING &&\n goog.isDocumentLoading_()) {\n var key;\n var callback = function(script) {\n if (script.readyState && script.readyState != 'complete') {\n script.onload = callback;\n return;\n }\n goog.Dependency.unregisterCallback_(key);\n controller.loaded();\n };\n key = goog.Dependency.registerCallback_(callback);\n\n var defer = goog.Dependency.defer_ ? ' defer' : '';\n var nonceAttr = nonce ? ' nonce=\"' + nonce + '\"' : '';\n var script = '<script src=\"' + this.path + '\"' + nonceAttr + defer +\n ' id=\"script-' + key + '\"><\\/script>';\n\n script += '<script' + nonceAttr + '>';\n\n if (goog.Dependency.defer_) {\n script += 'document.getElementById(\\'script-' + key +\n '\\').onload = function() {\\n' +\n ' goog.Dependency.callback_(\\'' + key + '\\', this);\\n' +\n '};\\n';\n } else {\n script += 'goog.Dependency.callback_(\\'' + key +\n '\\', document.getElementById(\\'script-' + key + '\\'));';\n }\n\n script += '<\\/script>';\n\n doc.write(\n goog.TRUSTED_TYPES_POLICY_ ?\n goog.TRUSTED_TYPES_POLICY_.createHTML(script) :\n script);\n } else {\n var scriptEl =\n /** @type {!HTMLScriptElement} */ (doc.createElement('script'));\n scriptEl.defer = goog.Dependency.defer_;\n scriptEl.async = false;\n\n // If CSP nonces are used, propagate them to dynamically created scripts.\n // This is necessary to allow nonce-based CSPs without 'strict-dynamic'.\n if (nonce) {\n scriptEl.nonce = nonce;\n }\n\n scriptEl.onload = function() {\n scriptEl.onload = null;\n controller.loaded();\n };\n\n scriptEl.src = goog.TRUSTED_TYPES_POLICY_ ?\n goog.TRUSTED_TYPES_POLICY_.createScriptURL(this.path) :\n this.path;\n doc.head.appendChild(scriptEl);\n }\n };\n\n\n /**\n * @param {string} path Absolute path of this script.\n * @param {string} relativePath Path of this script relative to goog.basePath.\n * @param {!Array<string>} provides Should be an empty array.\n * TODO(johnplaisted) add support for adding closure namespaces to ES6\n * modules for interop purposes.\n * @param {!Array<string>} requires goog symbols or relative paths to Closure\n * this depends on.\n * @param {!Object<string, string>} loadFlags\n * @struct @constructor\n * @extends {goog.Dependency}\n */\n goog.Es6ModuleDependency = function(\n path, relativePath, provides, requires, loadFlags) {\n goog.Es6ModuleDependency.base(\n this, 'constructor', path, relativePath, provides, requires, loadFlags);\n };\n goog.inherits(goog.Es6ModuleDependency, goog.Dependency);\n\n\n /**\n * @override\n * @param {!goog.LoadController} controller\n */\n goog.Es6ModuleDependency.prototype.load = function(controller) {\n if (goog.global.CLOSURE_IMPORT_SCRIPT) {\n if (goog.global.CLOSURE_IMPORT_SCRIPT(this.path)) {\n controller.loaded();\n } else {\n controller.pause();\n }\n return;\n }\n\n if (!goog.inHtmlDocument_()) {\n goog.logToConsole_(\n 'Cannot use default debug loader outside of HTML documents.');\n controller.pause();\n return;\n }\n\n /** @type {!HTMLDocument} */\n var doc = goog.global.document;\n\n var dep = this;\n\n // TODO(johnplaisted): Does document.writing really speed up anything? Any\n // difference between this and just waiting for interactive mode and then\n // appending?\n function write(src, contents) {\n var nonceAttr = '';\n var nonce = goog.getScriptNonce_();\n if (nonce) {\n nonceAttr = ' nonce=\"' + nonce + '\"';\n }\n\n if (contents) {\n var script = '<script type=\"module\" crossorigin' + nonceAttr + '>' +\n contents + '</' +\n 'script>';\n doc.write(\n goog.TRUSTED_TYPES_POLICY_ ?\n goog.TRUSTED_TYPES_POLICY_.createHTML(script) :\n script);\n } else {\n var script = '<script type=\"module\" crossorigin src=\"' + src + '\"' +\n nonceAttr + '></' +\n 'script>';\n doc.write(\n goog.TRUSTED_TYPES_POLICY_ ?\n goog.TRUSTED_TYPES_POLICY_.createHTML(script) :\n script);\n }\n }\n\n function append(src, contents) {\n var scriptEl =\n /** @type {!HTMLScriptElement} */ (doc.createElement('script'));\n scriptEl.defer = true;\n scriptEl.async = false;\n scriptEl.type = 'module';\n scriptEl.setAttribute('crossorigin', true);\n\n // If CSP nonces are used, propagate them to dynamically created scripts.\n // This is necessary to allow nonce-based CSPs without 'strict-dynamic'.\n var nonce = goog.getScriptNonce_();\n if (nonce) {\n scriptEl.nonce = nonce;\n }\n\n if (contents) {\n scriptEl.text = goog.TRUSTED_TYPES_POLICY_ ?\n goog.TRUSTED_TYPES_POLICY_.createScript(contents) :\n contents;\n } else {\n scriptEl.src = goog.TRUSTED_TYPES_POLICY_ ?\n goog.TRUSTED_TYPES_POLICY_.createScriptURL(src) :\n src;\n }\n\n doc.head.appendChild(scriptEl);\n }\n\n var create;\n\n if (goog.isDocumentLoading_()) {\n create = write;\n // We can ONLY call document.write if we are guaranteed that any\n // non-module script tags document.written after this are deferred.\n // Small optimization, in theory document.writing is faster.\n goog.Dependency.defer_ = true;\n } else {\n create = append;\n }\n\n // Write 4 separate tags here:\n // 1) Sets the module state at the correct time (just before execution).\n // 2) A src node for this, which just hopefully lets the browser load it a\n // little early (no need to parse #3).\n // 3) Import the module and register it.\n // 4) Clear the module state at the correct time. Guaranteed to run even\n // if there is an error in the module (#3 will not run if there is an\n // error in the module).\n var beforeKey = goog.Dependency.registerCallback_(function() {\n goog.Dependency.unregisterCallback_(beforeKey);\n controller.setModuleState(goog.ModuleType.ES6);\n });\n create(undefined, 'goog.Dependency.callback_(\"' + beforeKey + '\")');\n\n // TODO(johnplaisted): Does this really speed up anything?\n create(this.path, undefined);\n\n var registerKey = goog.Dependency.registerCallback_(function(exports) {\n goog.Dependency.unregisterCallback_(registerKey);\n controller.registerEs6ModuleExports(\n dep.path, exports, goog.moduleLoaderState_.moduleName);\n });\n create(\n undefined,\n 'import * as m from \"' + this.path + '\"; goog.Dependency.callback_(\"' +\n registerKey + '\", m)');\n\n var afterKey = goog.Dependency.registerCallback_(function() {\n goog.Dependency.unregisterCallback_(afterKey);\n controller.clearModuleState();\n controller.loaded();\n });\n create(undefined, 'goog.Dependency.callback_(\"' + afterKey + '\")');\n };\n\n\n /**\n * Superclass of any dependency that needs to be loaded into memory,\n * transformed, and then eval'd (goog.modules and transpiled files).\n *\n * @param {string} path Absolute path of this script.\n * @param {string} relativePath Path of this script relative to goog.basePath.\n * @param {!Array<string>} provides goog.provided or goog.module symbols\n * in this file.\n * @param {!Array<string>} requires goog symbols or relative paths to Closure\n * this depends on.\n * @param {!Object<string, string>} loadFlags\n * @struct @constructor @abstract\n * @extends {goog.Dependency}\n */\n goog.TransformedDependency = function(\n path, relativePath, provides, requires, loadFlags) {\n goog.TransformedDependency.base(\n this, 'constructor', path, relativePath, provides, requires, loadFlags);\n /** @private {?string} */\n this.contents_ = null;\n\n /**\n * Whether to lazily make the synchronous XHR (when goog.require'd) or make\n * the synchronous XHR when initially loading. On FireFox 61 there is a bug\n * where an ES6 module cannot make a synchronous XHR (rather, it can, but if\n * it does then no other ES6 modules will load after).\n *\n * tl;dr we lazy load due to bugs on older browsers and eager load due to\n * bugs on newer ones.\n *\n * https://bugzilla.mozilla.org/show_bug.cgi?id=1477090\n *\n * @private @const {boolean}\n */\n this.lazyFetch_ = !goog.inHtmlDocument_() ||\n !('noModule' in goog.global.document.createElement('script'));\n };\n goog.inherits(goog.TransformedDependency, goog.Dependency);\n\n\n /**\n * @override\n * @param {!goog.LoadController} controller\n */\n goog.TransformedDependency.prototype.load = function(controller) {\n var dep = this;\n\n function fetch() {\n dep.contents_ = goog.loadFileSync_(dep.path);\n\n if (dep.contents_) {\n dep.contents_ = dep.transform(dep.contents_);\n if (dep.contents_) {\n dep.contents_ += '\\n//# sourceURL=' + dep.path;\n }\n }\n }\n\n if (goog.global.CLOSURE_IMPORT_SCRIPT) {\n fetch();\n if (this.contents_ &&\n goog.global.CLOSURE_IMPORT_SCRIPT('', this.contents_)) {\n this.contents_ = null;\n controller.loaded();\n } else {\n controller.pause();\n }\n return;\n }\n\n\n var isEs6 = this.loadFlags['module'] == goog.ModuleType.ES6;\n\n if (!this.lazyFetch_) {\n fetch();\n }\n\n function load() {\n if (dep.lazyFetch_) {\n fetch();\n }\n\n if (!dep.contents_) {\n // loadFileSync_ or transform are responsible. Assume they logged an\n // error.\n return;\n }\n\n if (isEs6) {\n controller.setModuleState(goog.ModuleType.ES6);\n }\n\n var namespace;\n\n try {\n var contents = dep.contents_;\n dep.contents_ = null;\n goog.globalEval(goog.CLOSURE_EVAL_PREFILTER_.createScript(contents));\n if (isEs6) {\n namespace = goog.moduleLoaderState_.moduleName;\n }\n } finally {\n if (isEs6) {\n controller.clearModuleState();\n }\n }\n\n if (isEs6) {\n // Due to circular dependencies this may not be available for require\n // right now.\n goog.global['$jscomp']['require']['ensure'](\n [dep.getPathName()], function() {\n controller.registerEs6ModuleExports(\n dep.path,\n goog.global['$jscomp']['require'](dep.getPathName()),\n namespace);\n });\n }\n\n controller.loaded();\n }\n\n // Do not fetch now; in FireFox 47 the synchronous XHR doesn't block all\n // events. If we fetched now and then document.write'd the contents the\n // document.write would be an eval and would execute too soon! Instead write\n // a script tag to fetch and eval synchronously at the correct time.\n function fetchInOwnScriptThenLoad() {\n /** @type {!HTMLDocument} */\n var doc = goog.global.document;\n\n var key = goog.Dependency.registerCallback_(function() {\n goog.Dependency.unregisterCallback_(key);\n load();\n });\n\n var nonce = goog.getScriptNonce_();\n var nonceAttr = nonce ? ' nonce=\"' + nonce + '\"' : '';\n var script = '<script' + nonceAttr + '>' +\n goog.protectScriptTag_('goog.Dependency.callback_(\"' + key + '\");') +\n '</' +\n 'script>';\n doc.write(\n goog.TRUSTED_TYPES_POLICY_ ?\n goog.TRUSTED_TYPES_POLICY_.createHTML(script) :\n script);\n }\n\n // If one thing is pending it is this.\n var anythingElsePending = controller.pending().length > 1;\n\n // Additionally if we are meant to defer scripts but the page is still\n // loading (e.g. an ES6 module is loading) then also defer. Or if we are\n // meant to defer and anything else is pending then defer (those may be\n // scripts that did not need transformation and are just script tags with\n // defer set to true, and we need to evaluate after that deferred script).\n var needsAsyncLoading = goog.Dependency.defer_ &&\n (anythingElsePending || goog.isDocumentLoading_());\n\n if (needsAsyncLoading) {\n // Note that we only defer when we have to rather than 100% of the time.\n // Always defering would work, but then in theory the order of\n // goog.require calls would then matter. We want to enforce that most of\n // the time the order of the require calls does not matter.\n controller.defer(function() {\n load();\n });\n return;\n }\n // TODO(johnplaisted): Externs are missing onreadystatechange for\n // HTMLDocument.\n /** @type {?} */\n var doc = goog.global.document;\n\n var isInternetExplorerOrEdge = goog.inHtmlDocument_() &&\n ('ActiveXObject' in goog.global || goog.isEdge_());\n\n // Don't delay in any version of IE or pre-Chromium Edge. There's a bug\n // around this that will cause out of order script execution. This means\n // that on older IE ES6 modules will load too early (while the document is\n // still loading + the dom is not available). The other option is to load\n // too late (when the document is complete and the onload even will never\n // fire). This seems to be the lesser of two evils as scripts already act\n // like the former.\n if (isEs6 && goog.inHtmlDocument_() && goog.isDocumentLoading_() &&\n !isInternetExplorerOrEdge) {\n goog.Dependency.defer_ = true;\n // Transpiled ES6 modules still need to load like regular ES6 modules,\n // aka only after the document is interactive.\n controller.pause();\n var oldCallback = doc.onreadystatechange;\n doc.onreadystatechange = function() {\n if (doc.readyState == 'interactive') {\n doc.onreadystatechange = oldCallback;\n load();\n controller.resume();\n }\n if (typeof oldCallback === 'function') {\n oldCallback.apply(undefined, arguments);\n }\n };\n } else {\n // Always eval on old IE.\n if (!goog.inHtmlDocument_() || !goog.isDocumentLoading_()) {\n load();\n } else {\n fetchInOwnScriptThenLoad();\n }\n }\n };\n\n\n /**\n * @param {string} contents\n * @return {string}\n * @abstract\n */\n goog.TransformedDependency.prototype.transform = function(contents) {};\n\n\n /**\n * An ES6 module dependency that was transpiled to a jscomp module outside\n * of the debug loader, e.g. server side.\n *\n * @param {string} path Absolute path of this script.\n * @param {string} relativePath Path of this script relative to goog.basePath.\n * @param {!Array<string>} provides goog.provided or goog.module symbols\n * in this file.\n * @param {!Array<string>} requires goog symbols or relative paths to Closure\n * this depends on.\n * @param {!Object<string, string>} loadFlags\n * @struct @constructor\n * @extends {goog.TransformedDependency}\n */\n goog.PreTranspiledEs6ModuleDependency = function(\n path, relativePath, provides, requires, loadFlags) {\n goog.PreTranspiledEs6ModuleDependency.base(\n this, 'constructor', path, relativePath, provides, requires, loadFlags);\n };\n goog.inherits(\n goog.PreTranspiledEs6ModuleDependency, goog.TransformedDependency);\n\n\n /**\n * @override\n * @param {string} contents\n * @return {string}\n */\n goog.PreTranspiledEs6ModuleDependency.prototype.transform = function(\n contents) {\n return contents;\n };\n\n\n /**\n * A goog.module, transpiled or not. Will always perform some minimal\n * transformation even when not transpiled to wrap in a goog.loadModule\n * statement.\n *\n * @param {string} path Absolute path of this script.\n * @param {string} relativePath Path of this script relative to goog.basePath.\n * @param {!Array<string>} provides goog.provided or goog.module symbols\n * in this file.\n * @param {!Array<string>} requires goog symbols or relative paths to Closure\n * this depends on.\n * @param {!Object<string, string>} loadFlags\n * @struct @constructor\n * @extends {goog.TransformedDependency}\n */\n goog.GoogModuleDependency = function(\n path, relativePath, provides, requires, loadFlags) {\n goog.GoogModuleDependency.base(\n this, 'constructor', path, relativePath, provides, requires, loadFlags);\n };\n goog.inherits(goog.GoogModuleDependency, goog.TransformedDependency);\n\n\n /**\n * @override\n * @param {string} contents\n * @return {string}\n */\n goog.GoogModuleDependency.prototype.transform = function(contents) {\n if (!goog.LOAD_MODULE_USING_EVAL || goog.global.JSON === undefined) {\n return '' +\n 'goog.loadModule(function(exports) {' +\n '\"use strict\";' + contents +\n '\\n' + // terminate any trailing single line comment.\n ';return exports' +\n '});' +\n '\\n//# sourceURL=' + this.path + '\\n';\n } else {\n return '' +\n 'goog.loadModule(' +\n goog.global.JSON.stringify(\n contents + '\\n//# sourceURL=' + this.path + '\\n') +\n ');';\n }\n };\n\n\n /**\n * @param {string} relPath\n * @param {!Array<string>|undefined} provides\n * @param {!Array<string>} requires\n * @param {boolean|!Object<string>=} opt_loadFlags\n * @see goog.addDependency\n */\n goog.DebugLoader_.prototype.addDependency = function(\n relPath, provides, requires, opt_loadFlags) {\n provides = provides || [];\n relPath = relPath.replace(/\\\\/g, '/');\n var path = goog.normalizePath_(goog.basePath + relPath);\n if (!opt_loadFlags || typeof opt_loadFlags === 'boolean') {\n opt_loadFlags = opt_loadFlags ? {'module': goog.ModuleType.GOOG} : {};\n }\n var dep = this.factory_.createDependency(\n path, relPath, provides, requires, opt_loadFlags);\n this.dependencies_[path] = dep;\n for (var i = 0; i < provides.length; i++) {\n this.idToPath_[provides[i]] = path;\n }\n this.idToPath_[relPath] = path;\n };\n\n\n /**\n * Creates goog.Dependency instances for the debug loader to load.\n *\n * Should be overridden to have the debug loader use custom subclasses of\n * goog.Dependency.\n *\n * @struct @constructor\n */\n goog.DependencyFactory = function() {};\n\n\n /**\n * @param {string} path Absolute path of the file.\n * @param {string} relativePath Path relative to closure’s base.js.\n * @param {!Array<string>} provides Array of provided goog.provide/module ids.\n * @param {!Array<string>} requires Array of required goog.provide/module /\n * relative ES6 module paths.\n * @param {!Object<string, string>} loadFlags\n * @return {!goog.Dependency}\n */\n goog.DependencyFactory.prototype.createDependency = function(\n path, relativePath, provides, requires, loadFlags) {\n\n if (loadFlags['module'] == goog.ModuleType.GOOG) {\n return new goog.GoogModuleDependency(\n path, relativePath, provides, requires, loadFlags);\n } else {\n if (loadFlags['module'] == goog.ModuleType.ES6) {\n if (goog.ASSUME_ES_MODULES_TRANSPILED) {\n return new goog.PreTranspiledEs6ModuleDependency(\n path, relativePath, provides, requires, loadFlags);\n } else {\n return new goog.Es6ModuleDependency(\n path, relativePath, provides, requires, loadFlags);\n }\n } else {\n return new goog.Dependency(\n path, relativePath, provides, requires, loadFlags);\n }\n }\n };\n\n\n /** @private @const */\n goog.debugLoader_ = new goog.DebugLoader_();\n\n\n /**\n * Loads the Closure Dependency file.\n *\n * Exposed a public function so CLOSURE_NO_DEPS can be set to false, base\n * loaded, setDependencyFactory called, and then this called. i.e. allows\n * custom loading of the deps file.\n */\n goog.loadClosureDeps = function() {\n goog.debugLoader_.loadClosureDeps();\n };\n\n\n /**\n * Sets the dependency factory, which can be used to create custom\n * goog.Dependency implementations to control how dependencies are loaded.\n *\n * Note: if you wish to call this function and provide your own implemnetation\n * it is a wise idea to set CLOSURE_NO_DEPS to true, otherwise the dependency\n * file and all of its goog.addDependency calls will use the default factory.\n * You can call goog.loadClosureDeps to load the Closure dependency file\n * later, after your factory is injected.\n *\n * @param {!goog.DependencyFactory} factory\n */\n goog.setDependencyFactory = function(factory) {\n goog.debugLoader_.setDependencyFactory(factory);\n };\n\n\n /**\n * Trusted Types policy for the debug loader.\n * @private @const {?TrustedTypePolicy}\n */\n goog.TRUSTED_TYPES_POLICY_ = goog.TRUSTED_TYPES_POLICY_NAME ?\n goog.createTrustedTypesPolicy(goog.TRUSTED_TYPES_POLICY_NAME + '#base') :\n null;\n\n if (!goog.global.CLOSURE_NO_DEPS) {\n goog.debugLoader_.loadClosureDeps();\n }\n\n\n /**\n * Bootstraps the given namespaces and calls the callback once they are\n * available either via goog.require. This is a replacement for using\n * `goog.require` to bootstrap Closure JavaScript. Previously a `goog.require`\n * in an HTML file would guarantee that the require'd namespace was available\n * in the next immediate script tag. With ES6 modules this no longer a\n * guarantee.\n *\n * @param {!Array<string>} namespaces\n * @param {function(): ?} callback Function to call once all the namespaces\n * have loaded. Always called asynchronously.\n */\n goog.bootstrap = function(namespaces, callback) {\n goog.debugLoader_.bootstrap(namespaces, callback);\n };\n}\n\n\nif (!COMPILED) {\n var isChrome87 = false;\n // Cannot run check for Chrome <87 bug in case of strict CSP environments.\n // TODO(user): Remove once Chrome <87 bug is no longer a problem.\n try {\n isChrome87 = eval(goog.global.trustedTypes.emptyScript) !==\n goog.global.trustedTypes.emptyScript;\n } catch (err) {\n }\n\n /**\n * Trusted Types for running dev servers.\n *\n * @private @const\n */\n goog.CLOSURE_EVAL_PREFILTER_ =\n // Detect Chrome <87 bug with TT and eval.\n goog.global.trustedTypes && isChrome87 &&\n goog.createTrustedTypesPolicy('goog#base#devonly#eval') ||\n {createScript: goog.identity_};\n}\n","~:compiled-at",1684858197804,"~:source-map-json","{\n\"version\":3,\n\"file\":\"goog.base.js\",\n\"lineCount\":1240,\n\"mappings\":\"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\",\n\"sources\":[\"goog/base.js\"],\n\"sourcesContent\":[\"/**\\n * @license\\n * Copyright The Closure Library Authors.\\n * SPDX-License-Identifier: Apache-2.0\\n */\\n\\n/**\\n * @fileoverview Bootstrap for the Google JS Library (Closure).\\n *\\n * In uncompiled mode base.js will attempt to load Closure's deps file, unless\\n * the global <code>CLOSURE_NO_DEPS</code> is set to true. This allows projects\\n * to include their own deps file(s) from different locations.\\n *\\n * Avoid including base.js more than once. This is strictly discouraged and not\\n * supported. goog.require(...) won't work properly in that case.\\n *\\n * @suppress {deprecated} Users cannot remove deprecated uses here.\\n * @provideGoog\\n */\\n\\n\\n/**\\n * @define {boolean} Overridden to true by the compiler.\\n */\\nvar COMPILED = false;\\n\\n\\n/**\\n * Base namespace for the Closure library. Checks to see goog is already\\n * defined in the current scope before assigning to prevent clobbering if\\n * base.js is loaded more than once.\\n *\\n * @const\\n */\\nvar goog = goog || {};\\n\\n/**\\n * Reference to the global object.\\n * https://www.ecma-international.org/ecma-262/9.0/index.html#sec-global-object\\n *\\n * More info on this implementation here:\\n * https://docs.google.com/document/d/1NAeW4Wk7I7FV0Y2tcUFvQdGMc89k2vdgSXInw8_nvCI/edit\\n *\\n * @const\\n * @suppress {undefinedVars} self won't be referenced unless `this` is falsy.\\n * @type {!Global}\\n */\\ngoog.global =\\n // Check `this` first for backwards compatibility.\\n // Valid unless running as an ES module or in a function wrapper called\\n // without setting `this` properly.\\n // Note that base.js can't usefully be imported as an ES module, but it may\\n // be compiled into bundles that are loadable as ES modules.\\n this ||\\n // https://developer.mozilla.org/en-US/docs/Web/API/Window/self\\n // For in-page browser environments and workers.\\n self;\\n\\n\\n/**\\n * A hook for overriding the define values in uncompiled mode.\\n *\\n * In uncompiled mode, `CLOSURE_UNCOMPILED_DEFINES` may be defined before\\n * loading base.js. If a key is defined in `CLOSURE_UNCOMPILED_DEFINES`,\\n * `goog.define` will use the value instead of the default value. This\\n * allows flags to be overwritten without compilation (this is normally\\n * accomplished with the compiler's \\\"define\\\" flag).\\n *\\n * Example:\\n * <pre>\\n * var CLOSURE_UNCOMPILED_DEFINES = {'goog.DEBUG': false};\\n * </pre>\\n *\\n * @type {Object<string, (string|number|boolean)>|undefined}\\n */\\ngoog.global.CLOSURE_UNCOMPILED_DEFINES;\\n\\n\\n/**\\n * A hook for overriding the define values in uncompiled or compiled mode,\\n * like CLOSURE_UNCOMPILED_DEFINES but effective in compiled code. In\\n * uncompiled code CLOSURE_UNCOMPILED_DEFINES takes precedence.\\n *\\n * Also unlike CLOSURE_UNCOMPILED_DEFINES the values must be number, boolean or\\n * string literals or the compiler will emit an error.\\n *\\n * While any @define value may be set, only those set with goog.define will be\\n * effective for uncompiled code.\\n *\\n * Example:\\n * <pre>\\n * var CLOSURE_DEFINES = {'goog.DEBUG': false} ;\\n * </pre>\\n *\\n * Currently the Closure Compiler will only recognize very simple definitions of\\n * this value when looking for values to apply to compiled code and ignore all\\n * other references. Specifically, it looks the value defined at the variable\\n * declaration, as with the example above.\\n *\\n * TODO(user): Improve the recognized definitions.\\n *\\n * @type {!Object<string, (string|number|boolean)>|null|undefined}\\n */\\ngoog.global.CLOSURE_DEFINES;\\n\\n\\n/**\\n * Builds an object structure for the provided namespace path, ensuring that\\n * names that already exist are not overwritten. For example:\\n * \\\"a.b.c\\\" -> a = {};a.b={};a.b.c={};\\n * Used by goog.provide and goog.exportSymbol.\\n * @param {string} name The name of the object that this file defines.\\n * @param {*=} object The object to expose at the end of the path.\\n * @param {boolean=} overwriteImplicit If object is set and a previous call\\n * implicitly constructed the namespace given by name, this parameter\\n * controls whether object should overwrite the implicitly constructed\\n * namespace or be merged into it. Defaults to false.\\n * @param {?Object=} objectToExportTo The object to add the path to; if this\\n * field is not specified, its value defaults to `goog.global`.\\n * @private\\n */\\ngoog.exportPath_ = function(name, object, overwriteImplicit, objectToExportTo) {\\n var parts = name.split('.');\\n var cur = objectToExportTo || goog.global;\\n\\n // Internet Explorer exhibits strange behavior when throwing errors from\\n // methods externed in this manner. See the testExportSymbolExceptions in\\n // base_test.html for an example.\\n if (!(parts[0] in cur) && typeof cur.execScript != 'undefined') {\\n cur.execScript('var ' + parts[0]);\\n }\\n\\n for (var part; parts.length && (part = parts.shift());) {\\n if (!parts.length && object !== undefined) {\\n if (!overwriteImplicit && goog.isObject(object) &&\\n goog.isObject(cur[part])) {\\n // Merge properties on object (the input parameter) with the existing\\n // implicitly defined namespace, so as to not clobber previously\\n // defined child namespaces.\\n for (var prop in object) {\\n if (object.hasOwnProperty(prop)) {\\n cur[part][prop] = object[prop];\\n }\\n }\\n } else {\\n // Either there is no existing implicit namespace, or overwriteImplicit\\n // is set to true, so directly assign object (the input parameter) to\\n // the namespace.\\n cur[part] = object;\\n }\\n } else if (cur[part] && cur[part] !== Object.prototype[part]) {\\n cur = cur[part];\\n } else {\\n cur = cur[part] = {};\\n }\\n }\\n};\\n\\n\\n/**\\n * Defines a named value. In uncompiled mode, the value is retrieved from\\n * CLOSURE_DEFINES or CLOSURE_UNCOMPILED_DEFINES if the object is defined and\\n * has the property specified, and otherwise used the defined defaultValue.\\n * When compiled the default can be overridden using the compiler options or the\\n * value set in the CLOSURE_DEFINES object. Returns the defined value so that it\\n * can be used safely in modules. Note that the value type MUST be either\\n * boolean, number, or string.\\n *\\n * @param {string} name The distinguished name to provide.\\n * @param {T} defaultValue\\n * @return {T} The defined value.\\n * @template T\\n */\\ngoog.define = function(name, defaultValue) {\\n var value = defaultValue;\\n if (!COMPILED) {\\n var uncompiledDefines = goog.global.CLOSURE_UNCOMPILED_DEFINES;\\n var defines = goog.global.CLOSURE_DEFINES;\\n if (uncompiledDefines &&\\n // Anti DOM-clobbering runtime check (b/37736576).\\n /** @type {?} */ (uncompiledDefines).nodeType === undefined &&\\n Object.prototype.hasOwnProperty.call(uncompiledDefines, name)) {\\n value = uncompiledDefines[name];\\n } else if (\\n defines &&\\n // Anti DOM-clobbering runtime check (b/37736576).\\n /** @type {?} */ (defines).nodeType === undefined &&\\n Object.prototype.hasOwnProperty.call(defines, name)) {\\n value = defines[name];\\n }\\n }\\n return value;\\n};\\n\\n\\n/**\\n * @define {number} Integer year indicating the set of browser features that are\\n * guaranteed to be present. This is defined to include exactly features that\\n * work correctly on all \\\"modern\\\" browsers that are stable on January 1 of the\\n * specified year. For example,\\n * ```js\\n * if (goog.FEATURESET_YEAR >= 2019) {\\n * // use APIs known to be available on all major stable browsers Jan 1, 2019\\n * } else {\\n * // polyfill for older browsers\\n * }\\n * ```\\n * This is intended to be the primary define for removing\\n * unnecessary browser compatibility code (such as ponyfills and workarounds),\\n * and should inform the default value for most other defines:\\n * ```js\\n * const ASSUME_NATIVE_PROMISE =\\n * goog.define('ASSUME_NATIVE_PROMISE', goog.FEATURESET_YEAR >= 2016);\\n * ```\\n *\\n * The default assumption is that IE9 is the lowest supported browser, which was\\n * first available Jan 1, 2012.\\n *\\n * TODO(user): Reference more thorough documentation when it's available.\\n */\\ngoog.FEATURESET_YEAR = goog.define('goog.FEATURESET_YEAR', 2012);\\n\\n\\n/**\\n * @define {boolean} DEBUG is provided as a convenience so that debugging code\\n * that should not be included in a production. It can be easily stripped\\n * by specifying --define goog.DEBUG=false to the Closure Compiler aka\\n * JSCompiler. For example, most toString() methods should be declared inside an\\n * \\\"if (goog.DEBUG)\\\" conditional because they are generally used for debugging\\n * purposes and it is difficult for the JSCompiler to statically determine\\n * whether they are used.\\n */\\ngoog.DEBUG = goog.define('goog.DEBUG', true);\\n\\n\\n/**\\n * @define {string} LOCALE defines the locale being used for compilation. It is\\n * used to select locale specific data to be compiled in js binary. BUILD rule\\n * can specify this value by \\\"--define goog.LOCALE=<locale_name>\\\" as a compiler\\n * option.\\n *\\n * Take into account that the locale code format is important. You should use\\n * the canonical Unicode format with hyphen as a delimiter. Language must be\\n * lowercase, Language Script - Capitalized, Region - UPPERCASE.\\n * There are few examples: pt-BR, en, en-US, sr-Latin-BO, zh-Hans-CN.\\n *\\n * See more info about locale codes here:\\n * http://www.unicode.org/reports/tr35/#Unicode_Language_and_Locale_Identifiers\\n *\\n * For language codes you should use values defined by ISO 693-1. See it here\\n * http://www.w3.org/WAI/ER/IG/ert/iso639.htm. There is only one exception from\\n * this rule: the Hebrew language. For legacy reasons the old code (iw) should\\n * be used instead of the new code (he).\\n *\\n */\\ngoog.LOCALE = goog.define('goog.LOCALE', 'en'); // default to en\\n\\n\\n/**\\n * @define {boolean} Whether this code is running on trusted sites.\\n *\\n * On untrusted sites, several native functions can be defined or overridden by\\n * external libraries like Prototype, Datejs, and JQuery and setting this flag\\n * to false forces closure to use its own implementations when possible.\\n *\\n * If your JavaScript can be loaded by a third party site and you are wary about\\n * relying on non-standard implementations, specify\\n * \\\"--define goog.TRUSTED_SITE=false\\\" to the compiler.\\n */\\ngoog.TRUSTED_SITE = goog.define('goog.TRUSTED_SITE', true);\\n\\n\\n/**\\n * @define {boolean} Whether code that calls {@link goog.setTestOnly} should\\n * be disallowed in the compilation unit.\\n */\\ngoog.DISALLOW_TEST_ONLY_CODE =\\n goog.define('goog.DISALLOW_TEST_ONLY_CODE', COMPILED && !goog.DEBUG);\\n\\n\\n/**\\n * @define {boolean} Whether to use a Chrome app CSP-compliant method for\\n * loading scripts via goog.require. @see appendScriptSrcNode_.\\n */\\ngoog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING =\\n goog.define('goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING', false);\\n\\n\\n/**\\n * Defines a namespace in Closure.\\n *\\n * A namespace may only be defined once in a codebase. It may be defined using\\n * goog.provide() or goog.module().\\n *\\n * The presence of one or more goog.provide() calls in a file indicates\\n * that the file defines the given objects/namespaces.\\n * Provided symbols must not be null or undefined.\\n *\\n * In addition, goog.provide() creates the object stubs for a namespace\\n * (for example, goog.provide(\\\"goog.foo.bar\\\") will create the object\\n * goog.foo.bar if it does not already exist).\\n *\\n * Build tools also scan for provide/require/module statements\\n * to discern dependencies, build dependency files (see deps.js), etc.\\n *\\n * @see goog.require\\n * @see goog.module\\n * @param {string} name Namespace provided by this file in the form\\n * \\\"goog.package.part\\\".\\n * deprecated Use goog.module (see b/159289405)\\n */\\ngoog.provide = function(name) {\\n if (goog.isInModuleLoader_()) {\\n throw new Error('goog.provide cannot be used within a module.');\\n }\\n if (!COMPILED) {\\n // Ensure that the same namespace isn't provided twice.\\n // A goog.module/goog.provide maps a goog.require to a specific file\\n if (goog.isProvided_(name)) {\\n throw new Error('Namespace \\\"' + name + '\\\" already declared.');\\n }\\n }\\n\\n goog.constructNamespace_(name);\\n};\\n\\n\\n/**\\n * @param {string} name Namespace provided by this file in the form\\n * \\\"goog.package.part\\\".\\n * @param {?Object=} object The object to embed in the namespace.\\n * @param {boolean=} overwriteImplicit If object is set and a previous call\\n * implicitly constructed the namespace given by name, this parameter\\n * controls whether opt_obj should overwrite the implicitly constructed\\n * namespace or be merged into it. Defaults to false.\\n * @private\\n */\\ngoog.constructNamespace_ = function(name, object, overwriteImplicit) {\\n if (!COMPILED) {\\n delete goog.implicitNamespaces_[name];\\n\\n var namespace = name;\\n while ((namespace = namespace.substring(0, namespace.lastIndexOf('.')))) {\\n if (goog.getObjectByName(namespace)) {\\n break;\\n }\\n goog.implicitNamespaces_[namespace] = true;\\n }\\n }\\n\\n goog.exportPath_(name, object, overwriteImplicit);\\n};\\n\\n\\n/**\\n * According to the CSP3 spec a nonce must be a valid base64 string.\\n * @see https://www.w3.org/TR/CSP3/#grammardef-base64-value\\n * @private @const\\n */\\ngoog.NONCE_PATTERN_ = /^[\\\\w+/_-]+[=]{0,2}$/;\\n\\n\\n/**\\n * Returns CSP nonce, if set for any script tag.\\n * @param {?Window=} opt_window The window context used to retrieve the nonce.\\n * Defaults to global context.\\n * @return {string} CSP nonce or empty string if no nonce is present.\\n * @private\\n */\\ngoog.getScriptNonce_ = function(opt_window) {\\n var doc = (opt_window || goog.global).document;\\n var script = doc.querySelector && doc.querySelector('script[nonce]');\\n if (script) {\\n // Try to get the nonce from the IDL property first, because browsers that\\n // implement additional nonce protection features (currently only Chrome) to\\n // prevent nonce stealing via CSS do not expose the nonce via attributes.\\n // See https://github.com/whatwg/html/issues/2369\\n var nonce = script['nonce'] || script.getAttribute('nonce');\\n if (nonce && goog.NONCE_PATTERN_.test(nonce)) {\\n return nonce;\\n }\\n }\\n return '';\\n};\\n\\n\\n/**\\n * Module identifier validation regexp.\\n * Note: This is a conservative check, it is very possible to be more lenient,\\n * the primary exclusion here is \\\"/\\\" and \\\"\\\\\\\" and a leading \\\".\\\", these\\n * restrictions are intended to leave the door open for using goog.require\\n * with relative file paths rather than module identifiers.\\n * @private\\n */\\ngoog.VALID_MODULE_RE_ = /^[a-zA-Z_$][a-zA-Z0-9._$]*$/;\\n\\n\\n/**\\n * Defines a module in Closure.\\n *\\n * Marks that this file must be loaded as a module and claims the namespace.\\n *\\n * A namespace may only be defined once in a codebase. It may be defined using\\n * goog.provide() or goog.module().\\n *\\n * goog.module() has three requirements:\\n * - goog.module may not be used in the same file as goog.provide.\\n * - goog.module must be the first statement in the file.\\n * - only one goog.module is allowed per file.\\n *\\n * When a goog.module annotated file is loaded, it is enclosed in\\n * a strict function closure. This means that:\\n * - any variables declared in a goog.module file are private to the file\\n * (not global), though the compiler is expected to inline the module.\\n * - The code must obey all the rules of \\\"strict\\\" JavaScript.\\n * - the file will be marked as \\\"use strict\\\"\\n *\\n * NOTE: unlike goog.provide, goog.module does not declare any symbols by\\n * itself. If declared symbols are desired, use\\n * goog.module.declareLegacyNamespace().\\n *\\n *\\n * See the public goog.module proposal: http://goo.gl/Va1hin\\n *\\n * @param {string} name Namespace provided by this file in the form\\n * \\\"goog.package.part\\\", is expected but not required.\\n * @return {void}\\n */\\ngoog.module = function(name) {\\n if (typeof name !== 'string' || !name ||\\n name.search(goog.VALID_MODULE_RE_) == -1) {\\n throw new Error('Invalid module identifier');\\n }\\n if (!goog.isInGoogModuleLoader_()) {\\n throw new Error(\\n 'Module ' + name + ' has been loaded incorrectly. Note, ' +\\n 'modules cannot be loaded as normal scripts. They require some kind of ' +\\n 'pre-processing step. You\\\\'re likely trying to load a module via a ' +\\n 'script tag or as a part of a concatenated bundle without rewriting the ' +\\n 'module. For more info see: ' +\\n 'https://github.com/google/closure-library/wiki/goog.module:-an-ES6-module-like-alternative-to-goog.provide.');\\n }\\n if (goog.moduleLoaderState_.moduleName) {\\n throw new Error('goog.module may only be called once per module.');\\n }\\n\\n // Store the module name for the loader.\\n goog.moduleLoaderState_.moduleName = name;\\n if (!COMPILED) {\\n // Ensure that the same namespace isn't provided twice.\\n // A goog.module/goog.provide maps a goog.require to a specific file\\n if (goog.isProvided_(name)) {\\n throw new Error('Namespace \\\"' + name + '\\\" already declared.');\\n }\\n delete goog.implicitNamespaces_[name];\\n }\\n};\\n\\n\\n/**\\n * @param {string} name The module identifier.\\n * @return {?} The module exports for an already loaded module or null.\\n *\\n * Note: This is not an alternative to goog.require, it does not\\n * indicate a hard dependency, instead it is used to indicate\\n * an optional dependency or to access the exports of a module\\n * that has already been loaded.\\n * @suppress {missingProvide}\\n */\\ngoog.module.get = function(name) {\\n return goog.module.getInternal_(name);\\n};\\n\\n\\n/**\\n * @param {string} name The module identifier.\\n * @return {?} The module exports for an already loaded module or null.\\n * @private\\n */\\ngoog.module.getInternal_ = function(name) {\\n if (!COMPILED) {\\n if (name in goog.loadedModules_) {\\n return goog.loadedModules_[name].exports;\\n } else if (!goog.implicitNamespaces_[name]) {\\n var ns = goog.getObjectByName(name);\\n return ns != null ? ns : null;\\n }\\n }\\n return null;\\n};\\n\\n/**\\n * Types of modules the debug loader can load.\\n * @enum {string}\\n */\\ngoog.ModuleType = {\\n ES6: 'es6',\\n GOOG: 'goog'\\n};\\n\\n\\n/**\\n * @private {?{\\n * moduleName: (string|undefined),\\n * declareLegacyNamespace:boolean,\\n * type: ?goog.ModuleType\\n * }}\\n */\\ngoog.moduleLoaderState_ = null;\\n\\n\\n/**\\n * @private\\n * @return {boolean} Whether a goog.module or an es6 module is currently being\\n * initialized.\\n */\\ngoog.isInModuleLoader_ = function() {\\n return goog.isInGoogModuleLoader_() || goog.isInEs6ModuleLoader_();\\n};\\n\\n\\n/**\\n * @private\\n * @return {boolean} Whether a goog.module is currently being initialized.\\n */\\ngoog.isInGoogModuleLoader_ = function() {\\n return !!goog.moduleLoaderState_ &&\\n goog.moduleLoaderState_.type == goog.ModuleType.GOOG;\\n};\\n\\n\\n/**\\n * @private\\n * @return {boolean} Whether an es6 module is currently being initialized.\\n */\\ngoog.isInEs6ModuleLoader_ = function() {\\n var inLoader = !!goog.moduleLoaderState_ &&\\n goog.moduleLoaderState_.type == goog.ModuleType.ES6;\\n\\n if (inLoader) {\\n return true;\\n }\\n\\n var jscomp = goog.global['$jscomp'];\\n\\n if (jscomp) {\\n // jscomp may not have getCurrentModulePath if this is a compiled bundle\\n // that has some of the runtime, but not all of it. This can happen if\\n // optimizations are turned on so the unused runtime is removed but renaming\\n // and Closure pass are off (so $jscomp is still named $jscomp and the\\n // goog.provide/require calls still exist).\\n if (typeof jscomp.getCurrentModulePath != 'function') {\\n return false;\\n }\\n\\n // Bundled ES6 module.\\n return !!jscomp.getCurrentModulePath();\\n }\\n\\n return false;\\n};\\n\\n\\n/**\\n * Provide the module's exports as a globally accessible object under the\\n * module's declared name. This is intended to ease migration to goog.module\\n * for files that have existing usages.\\n * @suppress {missingProvide}\\n */\\ngoog.module.declareLegacyNamespace = function() {\\n if (!COMPILED && !goog.isInGoogModuleLoader_()) {\\n throw new Error(\\n 'goog.module.declareLegacyNamespace must be called from ' +\\n 'within a goog.module');\\n }\\n if (!COMPILED && !goog.moduleLoaderState_.moduleName) {\\n throw new Error(\\n 'goog.module must be called prior to ' +\\n 'goog.module.declareLegacyNamespace.');\\n }\\n goog.moduleLoaderState_.declareLegacyNamespace = true;\\n};\\n\\n\\n/**\\n * Associates an ES6 module with a Closure module ID so that is available via\\n * goog.require. The associated ID acts like a goog.module ID - it does not\\n * create any global names, it is merely available via goog.require /\\n * goog.module.get / goog.forwardDeclare / goog.requireType. goog.require and\\n * goog.module.get will return the entire module as if it was import *'d. This\\n * allows Closure files to reference ES6 modules for the sake of migration.\\n *\\n * @param {string} namespace\\n * @suppress {missingProvide}\\n */\\ngoog.declareModuleId = function(namespace) {\\n if (!COMPILED) {\\n if (!goog.isInEs6ModuleLoader_()) {\\n throw new Error(\\n 'goog.declareModuleId may only be called from ' +\\n 'within an ES6 module');\\n }\\n if (goog.moduleLoaderState_ && goog.moduleLoaderState_.moduleName) {\\n throw new Error(\\n 'goog.declareModuleId may only be called once per module.');\\n }\\n if (namespace in goog.loadedModules_) {\\n throw new Error(\\n 'Module with namespace \\\"' + namespace + '\\\" already exists.');\\n }\\n }\\n if (goog.moduleLoaderState_) {\\n // Not bundled - debug loading.\\n goog.moduleLoaderState_.moduleName = namespace;\\n } else {\\n // Bundled - not debug loading, no module loader state.\\n var jscomp = goog.global['$jscomp'];\\n if (!jscomp || typeof jscomp.getCurrentModulePath != 'function') {\\n throw new Error(\\n 'Module with namespace \\\"' + namespace +\\n '\\\" has been loaded incorrectly.');\\n }\\n var exports = jscomp.require(jscomp.getCurrentModulePath());\\n goog.loadedModules_[namespace] = {\\n exports: exports,\\n type: goog.ModuleType.ES6,\\n moduleId: namespace\\n };\\n }\\n};\\n\\n\\n/**\\n * Marks that the current file should only be used for testing, and never for\\n * live code in production.\\n *\\n * In the case of unit tests, the message may optionally be an exact namespace\\n * for the test (e.g. 'goog.stringTest'). The linter will then ignore the extra\\n * provide (if not explicitly defined in the code).\\n *\\n * @param {string=} opt_message Optional message to add to the error that's\\n * raised when used in production code.\\n */\\ngoog.setTestOnly = function(opt_message) {\\n if (goog.DISALLOW_TEST_ONLY_CODE) {\\n opt_message = opt_message || '';\\n throw new Error(\\n 'Importing test-only code into non-debug environment' +\\n (opt_message ? ': ' + opt_message : '.'));\\n }\\n};\\n\\n\\n/**\\n * Forward declares a symbol. This is an indication to the compiler that the\\n * symbol may be used in the source yet is not required and may not be provided\\n * in compilation.\\n *\\n * The most common usage of forward declaration is code that takes a type as a\\n * function parameter but does not need to require it. By forward declaring\\n * instead of requiring, no hard dependency is made, and (if not required\\n * elsewhere) the namespace may never be required and thus, not be pulled\\n * into the JavaScript binary. If it is required elsewhere, it will be type\\n * checked as normal.\\n *\\n * Before using goog.forwardDeclare, please read the documentation at\\n * https://github.com/google/closure-compiler/wiki/Bad-Type-Annotation to\\n * understand the options and tradeoffs when working with forward declarations.\\n *\\n * @param {string} name The namespace to forward declare in the form of\\n * \\\"goog.package.part\\\".\\n * @deprecated See go/noforwarddeclaration, Use `goog.requireType` instead.\\n */\\ngoog.forwardDeclare = function(name) {};\\n\\n\\n/**\\n * Forward declare type information. Used to assign types to goog.global\\n * referenced object that would otherwise result in unknown type references\\n * and thus block property disambiguation.\\n */\\ngoog.forwardDeclare('Document');\\ngoog.forwardDeclare('HTMLScriptElement');\\ngoog.forwardDeclare('XMLHttpRequest');\\n\\n\\nif (!COMPILED) {\\n /**\\n * Check if the given name has been goog.provided. This will return false for\\n * names that are available only as implicit namespaces.\\n * @param {string} name name of the object to look for.\\n * @return {boolean} Whether the name has been provided.\\n * @private\\n */\\n goog.isProvided_ = function(name) {\\n return (name in goog.loadedModules_) ||\\n (!goog.implicitNamespaces_[name] && goog.getObjectByName(name) != null);\\n };\\n\\n /**\\n * Namespaces implicitly defined by goog.provide. For example,\\n * goog.provide('goog.events.Event') implicitly declares that 'goog' and\\n * 'goog.events' must be namespaces.\\n *\\n * @type {!Object<string, (boolean|undefined)>}\\n * @private\\n */\\n goog.implicitNamespaces_ = {'goog.module': true};\\n\\n // NOTE: We add goog.module as an implicit namespace as goog.module is defined\\n // here and because the existing module package has not been moved yet out of\\n // the goog.module namespace. This satisifies both the debug loader and\\n // ahead-of-time dependency management.\\n}\\n\\n\\n/**\\n * Returns an object based on its fully qualified external name. The object\\n * is not found if null or undefined. If you are using a compilation pass that\\n * renames property names beware that using this function will not find renamed\\n * properties.\\n *\\n * @param {string} name The fully qualified name.\\n * @param {Object=} opt_obj The object within which to look; default is\\n * |goog.global|.\\n * @return {?} The value (object or primitive) or, if not found, null.\\n */\\ngoog.getObjectByName = function(name, opt_obj) {\\n var parts = name.split('.');\\n var cur = opt_obj || goog.global;\\n for (var i = 0; i < parts.length; i++) {\\n cur = cur[parts[i]];\\n if (cur == null) {\\n return null;\\n }\\n }\\n return cur;\\n};\\n\\n\\n/**\\n * Adds a dependency from a file to the files it requires.\\n * @param {string} relPath The path to the js file.\\n * @param {!Array<string>} provides An array of strings with\\n * the names of the objects this file provides.\\n * @param {!Array<string>} requires An array of strings with\\n * the names of the objects this file requires.\\n * @param {boolean|!Object<string>=} opt_loadFlags Parameters indicating\\n * how the file must be loaded. The boolean 'true' is equivalent\\n * to {'module': 'goog'} for backwards-compatibility. Valid properties\\n * and values include {'module': 'goog'} and {'lang': 'es6'}.\\n */\\ngoog.addDependency = function(relPath, provides, requires, opt_loadFlags) {\\n if (!COMPILED && goog.DEPENDENCIES_ENABLED) {\\n goog.debugLoader_.addDependency(relPath, provides, requires, opt_loadFlags);\\n }\\n};\\n\\n\\n// NOTE(nnaze): The debug DOM loader was included in base.js as an original way\\n// to do \\\"debug-mode\\\" development. The dependency system can sometimes be\\n// confusing, as can the debug DOM loader's asynchronous nature.\\n//\\n// With the DOM loader, a call to goog.require() is not blocking -- the script\\n// will not load until some point after the current script. If a namespace is\\n// needed at runtime, it needs to be defined in a previous script, or loaded via\\n// require() with its registered dependencies.\\n//\\n// User-defined namespaces may need their own deps file. For a reference on\\n// creating a deps file, see:\\n// Externally: https://developers.google.com/closure/library/docs/depswriter\\n//\\n// Because of legacy clients, the DOM loader can't be easily removed from\\n// base.js. Work was done to make it disableable or replaceable for\\n// different environments (DOM-less JavaScript interpreters like Rhino or V8,\\n// for example). See bootstrap/ for more information.\\n\\n\\n/**\\n * @define {boolean} Whether to enable the debug loader.\\n *\\n * If enabled, a call to goog.require() will attempt to load the namespace by\\n * appending a script tag to the DOM (if the namespace has been registered).\\n *\\n * If disabled, goog.require() will simply assert that the namespace has been\\n * provided (and depend on the fact that some outside tool correctly ordered\\n * the script).\\n */\\ngoog.ENABLE_DEBUG_LOADER = goog.define('goog.ENABLE_DEBUG_LOADER', true);\\n\\n\\n/**\\n * @param {string} msg\\n * @private\\n */\\ngoog.logToConsole_ = function(msg) {\\n if (goog.global.console) {\\n goog.global.console['error'](msg);\\n }\\n};\\n\\n\\n/**\\n * Implements a system for the dynamic resolution of dependencies that works in\\n * parallel with the BUILD system.\\n *\\n * Note that all calls to goog.require will be stripped by the compiler.\\n *\\n * @see goog.provide\\n * @param {string} namespace Namespace (as was given in goog.provide,\\n * goog.module, or goog.declareModuleId) in the form\\n * \\\"goog.package.part\\\".\\n * @return {?} If called within a goog.module or ES6 module file, the associated\\n * namespace or module otherwise null.\\n */\\ngoog.require = function(namespace) {\\n if (!COMPILED) {\\n // Might need to lazy load on old IE.\\n if (goog.ENABLE_DEBUG_LOADER) {\\n goog.debugLoader_.requested(namespace);\\n }\\n\\n // If the object already exists we do not need to do anything.\\n if (goog.isProvided_(namespace)) {\\n if (goog.isInModuleLoader_()) {\\n return goog.module.getInternal_(namespace);\\n }\\n } else if (goog.ENABLE_DEBUG_LOADER) {\\n var moduleLoaderState = goog.moduleLoaderState_;\\n goog.moduleLoaderState_ = null;\\n try {\\n goog.debugLoader_.load_(namespace);\\n } finally {\\n goog.moduleLoaderState_ = moduleLoaderState;\\n }\\n }\\n\\n return null;\\n }\\n};\\n\\n\\n/**\\n * Requires a symbol for its type information. This is an indication to the\\n * compiler that the symbol may appear in type annotations, yet it is not\\n * referenced at runtime.\\n *\\n * When called within a goog.module or ES6 module file, the return value may be\\n * assigned to or destructured into a variable, but it may not be otherwise used\\n * in code outside of a type annotation.\\n *\\n * Note that all calls to goog.requireType will be stripped by the compiler.\\n *\\n * @param {string} namespace Namespace (as was given in goog.provide,\\n * goog.module, or goog.declareModuleId) in the form\\n * \\\"goog.package.part\\\".\\n * @return {?}\\n */\\ngoog.requireType = function(namespace) {\\n // Return an empty object so that single-level destructuring of the return\\n // value doesn't crash at runtime when using the debug loader. Multi-level\\n // destructuring isn't supported.\\n return {};\\n};\\n\\n\\n/**\\n * Path for included scripts.\\n * @type {string}\\n */\\ngoog.basePath = '';\\n\\n\\n/**\\n * A hook for overriding the base path.\\n * @type {string|undefined}\\n */\\ngoog.global.CLOSURE_BASE_PATH;\\n\\n\\n/**\\n * Whether to attempt to load Closure's deps file. By default, when uncompiled,\\n * deps files will attempt to be loaded.\\n * @type {boolean|undefined}\\n */\\ngoog.global.CLOSURE_NO_DEPS;\\n\\n\\n/**\\n * A function to import a single script. This is meant to be overridden when\\n * Closure is being run in non-HTML contexts, such as web workers. It's defined\\n * in the global scope so that it can be set before base.js is loaded, which\\n * allows deps.js to be imported properly.\\n *\\n * The first parameter the script source, which is a relative URI. The second,\\n * optional parameter is the script contents, in the event the script needed\\n * transformation. It should return true if the script was imported, false\\n * otherwise.\\n * @type {(function(string, string=): boolean)|undefined}\\n */\\ngoog.global.CLOSURE_IMPORT_SCRIPT;\\n\\n\\n/**\\n * When defining a class Foo with an abstract method bar(), you can do:\\n * Foo.prototype.bar = goog.abstractMethod\\n *\\n * Now if a subclass of Foo fails to override bar(), an error will be thrown\\n * when bar() is invoked.\\n *\\n * @type {!Function}\\n * @throws {Error} when invoked to indicate the method should be overridden.\\n * @deprecated Use \\\"@abstract\\\" annotation instead of goog.abstractMethod in new\\n * code. See\\n * https://github.com/google/closure-compiler/wiki/@abstract-classes-and-methods\\n */\\ngoog.abstractMethod = function() {\\n throw new Error('unimplemented abstract method');\\n};\\n\\n\\n/**\\n * Adds a `getInstance` static method that always returns the same\\n * instance object.\\n * @param {!Function} ctor The constructor for the class to add the static\\n * method to.\\n * @suppress {missingProperties} 'instance_' isn't a property on 'Function'\\n * but we don't have a better type to use here.\\n */\\ngoog.addSingletonGetter = function(ctor) {\\n // instance_ is immediately set to prevent issues with sealed constructors\\n // such as are encountered when a constructor is returned as the export object\\n // of a goog.module in unoptimized code.\\n // Delcare type to avoid conformance violations that ctor.instance_ is unknown\\n /** @type {undefined|!Object} @suppress {underscore} */\\n ctor.instance_ = undefined;\\n ctor.getInstance = function() {\\n if (ctor.instance_) {\\n return ctor.instance_;\\n }\\n if (goog.DEBUG) {\\n // NOTE: JSCompiler can't optimize away Array#push.\\n goog.instantiatedSingletons_[goog.instantiatedSingletons_.length] = ctor;\\n }\\n // Cast to avoid conformance violations that ctor.instance_ is unknown\\n return /** @type {!Object|undefined} */ (ctor.instance_) = new ctor;\\n };\\n};\\n\\n\\n/**\\n * All singleton classes that have been instantiated, for testing. Don't read\\n * it directly, use the `goog.testing.singleton` module. The compiler\\n * removes this variable if unused.\\n * @type {!Array<!Function>}\\n * @private\\n */\\ngoog.instantiatedSingletons_ = [];\\n\\n\\n/**\\n * @define {boolean} Whether to load goog.modules using `eval` when using\\n * the debug loader. This provides a better debugging experience as the\\n * source is unmodified and can be edited using Chrome Workspaces or similar.\\n * However in some environments the use of `eval` is banned\\n * so we provide an alternative.\\n */\\ngoog.LOAD_MODULE_USING_EVAL = goog.define('goog.LOAD_MODULE_USING_EVAL', true);\\n\\n\\n/**\\n * @define {boolean} Whether the exports of goog.modules should be sealed when\\n * possible.\\n */\\ngoog.SEAL_MODULE_EXPORTS = goog.define('goog.SEAL_MODULE_EXPORTS', goog.DEBUG);\\n\\n\\n/**\\n * The registry of initialized modules:\\n * The module identifier or path to module exports map.\\n * @private @const {!Object<string, {exports:?,type:string,moduleId:string}>}\\n */\\ngoog.loadedModules_ = {};\\n\\n\\n/**\\n * True if the debug loader enabled and used.\\n * @const {boolean}\\n */\\ngoog.DEPENDENCIES_ENABLED = !COMPILED && goog.ENABLE_DEBUG_LOADER;\\n\\n\\n/**\\n * @define {string} How to decide whether to transpile. Valid values\\n * are 'always', 'never', and 'detect'. The default ('detect') is to\\n * use feature detection to determine which language levels need\\n * transpilation.\\n */\\n// NOTE(sdh): we could expand this to accept a language level to bypass\\n// detection: e.g. goog.TRANSPILE == 'es5' would transpile ES6 files but\\n// would leave ES3 and ES5 files alone.\\ngoog.TRANSPILE = goog.define('goog.TRANSPILE', 'detect');\\n\\n/**\\n * @define {boolean} If true assume that ES modules have already been\\n * transpiled by the jscompiler (in the same way that transpile.js would\\n * transpile them - to jscomp modules). Useful only for servers that wish to use\\n * the debug loader and transpile server side. Thus this is only respected if\\n * goog.TRANSPILE is \\\"never\\\".\\n */\\ngoog.ASSUME_ES_MODULES_TRANSPILED =\\n goog.define('goog.ASSUME_ES_MODULES_TRANSPILED', false);\\n\\n\\n/**\\n * @define {string} Trusted Types policy name. If non-empty then Closure will\\n * use Trusted Types.\\n */\\ngoog.TRUSTED_TYPES_POLICY_NAME =\\n goog.define('goog.TRUSTED_TYPES_POLICY_NAME', 'goog');\\n\\n\\n/**\\n * @package {?boolean}\\n * Visible for testing.\\n */\\ngoog.hasBadLetScoping = null;\\n\\n\\n/**\\n * @param {function(?):?|string} moduleDef The module definition.\\n */\\ngoog.loadModule = function(moduleDef) {\\n // NOTE: we allow function definitions to be either in the from\\n // of a string to eval (which keeps the original source intact) or\\n // in a eval forbidden environment (CSP) we allow a function definition\\n // which in its body must call `goog.module`, and return the exports\\n // of the module.\\n var previousState = goog.moduleLoaderState_;\\n try {\\n goog.moduleLoaderState_ = {\\n moduleName: '',\\n declareLegacyNamespace: false,\\n type: goog.ModuleType.GOOG\\n };\\n var origExports = {};\\n var exports = origExports;\\n if (typeof moduleDef === 'function') {\\n exports = moduleDef.call(undefined, exports);\\n } else if (typeof moduleDef === 'string') {\\n exports = goog.loadModuleFromSource_.call(undefined, exports, moduleDef);\\n } else {\\n throw new Error('Invalid module definition');\\n }\\n\\n var moduleName = goog.moduleLoaderState_.moduleName;\\n if (typeof moduleName === 'string' && moduleName) {\\n // Don't seal legacy namespaces as they may be used as a parent of\\n // another namespace\\n if (goog.moduleLoaderState_.declareLegacyNamespace) {\\n // Whether exports was overwritten via default export assignment.\\n // This is important for legacy namespaces as it dictates whether\\n // previously a previously loaded implicit namespace should be clobbered\\n // or not.\\n var isDefaultExport = origExports !== exports;\\n goog.constructNamespace_(moduleName, exports, isDefaultExport);\\n } else if (\\n goog.SEAL_MODULE_EXPORTS && Object.seal &&\\n typeof exports == 'object' && exports != null) {\\n Object.seal(exports);\\n }\\n\\n var data = {\\n exports: exports,\\n type: goog.ModuleType.GOOG,\\n moduleId: goog.moduleLoaderState_.moduleName\\n };\\n goog.loadedModules_[moduleName] = data;\\n } else {\\n throw new Error('Invalid module name \\\\\\\"' + moduleName + '\\\\\\\"');\\n }\\n } finally {\\n goog.moduleLoaderState_ = previousState;\\n }\\n};\\n\\n\\n/**\\n * @private @const\\n */\\ngoog.loadModuleFromSource_ =\\n /** @type {function(!Object, string):?} */ (function(exports) {\\n // NOTE: we avoid declaring parameters or local variables here to avoid\\n // masking globals or leaking values into the module definition.\\n 'use strict';\\n eval(goog.CLOSURE_EVAL_PREFILTER_.createScript(arguments[1]));\\n return exports;\\n });\\n\\n\\n/**\\n * Normalize a file path by removing redundant \\\"..\\\" and extraneous \\\".\\\" file\\n * path components.\\n * @param {string} path\\n * @return {string}\\n * @private\\n */\\ngoog.normalizePath_ = function(path) {\\n var components = path.split('/');\\n var i = 0;\\n while (i < components.length) {\\n if (components[i] == '.') {\\n components.splice(i, 1);\\n } else if (\\n i && components[i] == '..' && components[i - 1] &&\\n components[i - 1] != '..') {\\n components.splice(--i, 2);\\n } else {\\n i++;\\n }\\n }\\n return components.join('/');\\n};\\n\\n\\n/**\\n * Provides a hook for loading a file when using Closure's goog.require() API\\n * with goog.modules. In particular this hook is provided to support Node.js.\\n *\\n * @type {(function(string):string)|undefined}\\n */\\ngoog.global.CLOSURE_LOAD_FILE_SYNC;\\n\\n\\n/**\\n * Loads file by synchronous XHR. Should not be used in production environments.\\n * @param {string} src Source URL.\\n * @return {?string} File contents, or null if load failed.\\n * @private\\n */\\ngoog.loadFileSync_ = function(src) {\\n if (goog.global.CLOSURE_LOAD_FILE_SYNC) {\\n return goog.global.CLOSURE_LOAD_FILE_SYNC(src);\\n } else {\\n try {\\n /** @type {XMLHttpRequest} */\\n var xhr = new goog.global['XMLHttpRequest']();\\n xhr.open('get', src, false);\\n xhr.send();\\n // NOTE: Successful http: requests have a status of 200, but successful\\n // file: requests may have a status of zero. Any other status, or a\\n // thrown exception (particularly in case of file: requests) indicates\\n // some sort of error, which we treat as a missing or unavailable file.\\n return xhr.status == 0 || xhr.status == 200 ? xhr.responseText : null;\\n } catch (err) {\\n // No need to rethrow or log, since errors should show up on their own.\\n return null;\\n }\\n }\\n};\\n\\n//==============================================================================\\n// Language Enhancements\\n//==============================================================================\\n\\n\\n/**\\n * This is a \\\"fixed\\\" version of the typeof operator. It differs from the typeof\\n * operator in such a way that null returns 'null' and arrays return 'array'.\\n * @param {?} value The value to get the type of.\\n * @return {string} The name of the type.\\n */\\ngoog.typeOf = function(value) {\\n var s = typeof value;\\n\\n if (s != 'object') {\\n return s;\\n }\\n\\n if (!value) {\\n return 'null';\\n }\\n\\n if (Array.isArray(value)) {\\n return 'array';\\n }\\n return s;\\n};\\n\\n\\n/**\\n * Returns true if the object looks like an array. To qualify as array like\\n * the value needs to be either a NodeList or an object with a Number length\\n * property. Note that for this function neither strings nor functions are\\n * considered \\\"array-like\\\".\\n *\\n * @param {?} val Variable to test.\\n * @return {boolean} Whether variable is an array.\\n */\\ngoog.isArrayLike = function(val) {\\n var type = goog.typeOf(val);\\n // We do not use goog.isObject here in order to exclude function values.\\n return type == 'array' || type == 'object' && typeof val.length == 'number';\\n};\\n\\n\\n/**\\n * Returns true if the object looks like a Date. To qualify as Date-like the\\n * value needs to be an object and have a getFullYear() function.\\n * @param {?} val Variable to test.\\n * @return {boolean} Whether variable is a like a Date.\\n */\\ngoog.isDateLike = function(val) {\\n return goog.isObject(val) && typeof val.getFullYear == 'function';\\n};\\n\\n\\n/**\\n * Returns true if the specified value is an object. This includes arrays and\\n * functions.\\n * @param {?} val Variable to test.\\n * @return {boolean} Whether variable is an object.\\n */\\ngoog.isObject = function(val) {\\n var type = typeof val;\\n return type == 'object' && val != null || type == 'function';\\n // return Object(val) === val also works, but is slower, especially if val is\\n // not an object.\\n};\\n\\n\\n/**\\n * Gets a unique ID for an object. This mutates the object so that further calls\\n * with the same object as a parameter returns the same value. The unique ID is\\n * guaranteed to be unique across the current session amongst objects that are\\n * passed into `getUid`. There is no guarantee that the ID is unique or\\n * consistent across sessions. It is unsafe to generate unique ID for function\\n * prototypes.\\n *\\n * @param {Object} obj The object to get the unique ID for.\\n * @return {number} The unique ID for the object.\\n */\\ngoog.getUid = function(obj) {\\n // TODO(arv): Make the type stricter, do not accept null.\\n return Object.prototype.hasOwnProperty.call(obj, goog.UID_PROPERTY_) &&\\n obj[goog.UID_PROPERTY_] ||\\n (obj[goog.UID_PROPERTY_] = ++goog.uidCounter_);\\n};\\n\\n\\n/**\\n * Whether the given object is already assigned a unique ID.\\n *\\n * This does not modify the object.\\n *\\n * @param {!Object} obj The object to check.\\n * @return {boolean} Whether there is an assigned unique id for the object.\\n */\\ngoog.hasUid = function(obj) {\\n return !!obj[goog.UID_PROPERTY_];\\n};\\n\\n\\n/**\\n * Removes the unique ID from an object. This is useful if the object was\\n * previously mutated using `goog.getUid` in which case the mutation is\\n * undone.\\n * @param {Object} obj The object to remove the unique ID field from.\\n */\\ngoog.removeUid = function(obj) {\\n // TODO(arv): Make the type stricter, do not accept null.\\n\\n // In IE, DOM nodes are not instances of Object and throw an exception if we\\n // try to delete. Instead we try to use removeAttribute.\\n if (obj !== null && 'removeAttribute' in obj) {\\n obj.removeAttribute(goog.UID_PROPERTY_);\\n }\\n\\n try {\\n delete obj[goog.UID_PROPERTY_];\\n } catch (ex) {\\n }\\n};\\n\\n\\n/**\\n * Name for unique ID property. Initialized in a way to help avoid collisions\\n * with other closure JavaScript on the same page.\\n * @type {string}\\n * @private\\n */\\ngoog.UID_PROPERTY_ = 'closure_uid_' + ((Math.random() * 1e9) >>> 0);\\n\\n\\n/**\\n * Counter for UID.\\n * @type {number}\\n * @private\\n */\\ngoog.uidCounter_ = 0;\\n\\n\\n/**\\n * Clones a value. The input may be an Object, Array, or basic type. Objects and\\n * arrays will be cloned recursively.\\n *\\n * WARNINGS:\\n * <code>goog.cloneObject</code> does not detect reference loops. Objects that\\n * refer to themselves will cause infinite recursion.\\n *\\n * <code>goog.cloneObject</code> is unaware of unique identifiers, and copies\\n * UIDs created by <code>getUid</code> into cloned results.\\n *\\n * @param {*} obj The value to clone.\\n * @return {*} A clone of the input value.\\n * @deprecated goog.cloneObject is unsafe. Prefer the goog.object methods.\\n */\\ngoog.cloneObject = function(obj) {\\n var type = goog.typeOf(obj);\\n if (type == 'object' || type == 'array') {\\n if (typeof obj.clone === 'function') {\\n return obj.clone();\\n }\\n if (typeof Map !== 'undefined' && obj instanceof Map) {\\n return new Map(obj);\\n } else if (typeof Set !== 'undefined' && obj instanceof Set) {\\n return new Set(obj);\\n }\\n var clone = type == 'array' ? [] : {};\\n for (var key in obj) {\\n clone[key] = goog.cloneObject(obj[key]);\\n }\\n return clone;\\n }\\n\\n return obj;\\n};\\n\\n\\n/**\\n * A native implementation of goog.bind.\\n * @param {?function(this:T, ...)} fn A function to partially apply.\\n * @param {T} selfObj Specifies the object which this should point to when the\\n * function is run.\\n * @param {...*} var_args Additional arguments that are partially applied to the\\n * function.\\n * @return {!Function} A partially-applied form of the function goog.bind() was\\n * invoked as a method of.\\n * @template T\\n * @private\\n */\\ngoog.bindNative_ = function(fn, selfObj, var_args) {\\n return /** @type {!Function} */ (fn.call.apply(fn.bind, arguments));\\n};\\n\\n\\n/**\\n * A pure-JS implementation of goog.bind.\\n * @param {?function(this:T, ...)} fn A function to partially apply.\\n * @param {T} selfObj Specifies the object which this should point to when the\\n * function is run.\\n * @param {...*} var_args Additional arguments that are partially applied to the\\n * function.\\n * @return {!Function} A partially-applied form of the function goog.bind() was\\n * invoked as a method of.\\n * @template T\\n * @private\\n */\\ngoog.bindJs_ = function(fn, selfObj, var_args) {\\n if (!fn) {\\n throw new Error();\\n }\\n\\n if (arguments.length > 2) {\\n var boundArgs = Array.prototype.slice.call(arguments, 2);\\n return function() {\\n // Prepend the bound arguments to the current arguments.\\n var newArgs = Array.prototype.slice.call(arguments);\\n Array.prototype.unshift.apply(newArgs, boundArgs);\\n return fn.apply(selfObj, newArgs);\\n };\\n\\n } else {\\n return function() {\\n return fn.apply(selfObj, arguments);\\n };\\n }\\n};\\n\\n\\n/**\\n * Partially applies this function to a particular 'this object' and zero or\\n * more arguments. The result is a new function with some arguments of the first\\n * function pre-filled and the value of this 'pre-specified'.\\n *\\n * Remaining arguments specified at call-time are appended to the pre-specified\\n * ones.\\n *\\n * Also see: {@link #partial}.\\n *\\n * Usage:\\n * <pre>var barMethBound = goog.bind(myFunction, myObj, 'arg1', 'arg2');\\n * barMethBound('arg3', 'arg4');</pre>\\n *\\n * @param {?function(this:T, ...)} fn A function to partially apply.\\n * @param {T} selfObj Specifies the object which this should point to when the\\n * function is run.\\n * @param {...*} var_args Additional arguments that are partially applied to the\\n * function.\\n * @return {!Function} A partially-applied form of the function goog.bind() was\\n * invoked as a method of.\\n * @template T\\n * @suppress {deprecated} See above.\\n * @deprecated use `=> {}` or Function.prototype.bind instead.\\n */\\ngoog.bind = function(fn, selfObj, var_args) {\\n // TODO(nicksantos): narrow the type signature.\\n if (Function.prototype.bind &&\\n // NOTE(nicksantos): Somebody pulled base.js into the default Chrome\\n // extension environment. This means that for Chrome extensions, they get\\n // the implementation of Function.prototype.bind that calls goog.bind\\n // instead of the native one. Even worse, we don't want to introduce a\\n // circular dependency between goog.bind and Function.prototype.bind, so\\n // we have to hack this to make sure it works correctly.\\n Function.prototype.bind.toString().indexOf('native code') != -1) {\\n goog.bind = goog.bindNative_;\\n } else {\\n goog.bind = goog.bindJs_;\\n }\\n return goog.bind.apply(null, arguments);\\n};\\n\\n\\n/**\\n * Like goog.bind(), except that a 'this object' is not required. Useful when\\n * the target function is already bound.\\n *\\n * Usage:\\n * var g = goog.partial(f, arg1, arg2);\\n * g(arg3, arg4);\\n *\\n * @param {Function} fn A function to partially apply.\\n * @param {...*} var_args Additional arguments that are partially applied to fn.\\n * @return {!Function} A partially-applied form of the function goog.partial()\\n * was invoked as a method of.\\n */\\ngoog.partial = function(fn, var_args) {\\n var args = Array.prototype.slice.call(arguments, 1);\\n return function() {\\n // Clone the array (with slice()) and append additional arguments\\n // to the existing arguments.\\n var newArgs = args.slice();\\n newArgs.push.apply(newArgs, arguments);\\n return fn.apply(/** @type {?} */ (this), newArgs);\\n };\\n};\\n\\n\\n/**\\n * @return {number} An integer value representing the number of milliseconds\\n * between midnight, January 1, 1970 and the current time.\\n * @deprecated Use Date.now\\n */\\ngoog.now = function() {\\n return Date.now();\\n};\\n\\n\\n/**\\n * Evals JavaScript in the global scope.\\n *\\n * Throws an exception if neither execScript or eval is defined.\\n * @param {string|!TrustedScript} script JavaScript string.\\n */\\ngoog.globalEval = function(script) {\\n (0, eval)(script);\\n};\\n\\n\\n/**\\n * Optional map of CSS class names to obfuscated names used with\\n * goog.getCssName().\\n * @private {!Object<string, string>|undefined}\\n * @see goog.setCssNameMapping\\n */\\ngoog.cssNameMapping_;\\n\\n\\n/**\\n * Optional obfuscation style for CSS class names. Should be set to either\\n * 'BY_WHOLE' or 'BY_PART' if defined.\\n * @type {string|undefined}\\n * @private\\n * @see goog.setCssNameMapping\\n */\\ngoog.cssNameMappingStyle_;\\n\\n\\n\\n/**\\n * A hook for modifying the default behavior goog.getCssName. The function\\n * if present, will receive the standard output of the goog.getCssName as\\n * its input.\\n *\\n * @type {(function(string):string)|undefined}\\n */\\ngoog.global.CLOSURE_CSS_NAME_MAP_FN;\\n\\n\\n/**\\n * Handles strings that are intended to be used as CSS class names.\\n *\\n * This function works in tandem with @see goog.setCssNameMapping.\\n *\\n * Without any mapping set, the arguments are simple joined with a hyphen and\\n * passed through unaltered.\\n *\\n * When there is a mapping, there are two possible styles in which these\\n * mappings are used. In the BY_PART style, each part (i.e. in between hyphens)\\n * of the passed in css name is rewritten according to the map. In the BY_WHOLE\\n * style, the full css name is looked up in the map directly. If a rewrite is\\n * not specified by the map, the compiler will output a warning.\\n *\\n * When the mapping is passed to the compiler, it will replace calls to\\n * goog.getCssName with the strings from the mapping, e.g.\\n * var x = goog.getCssName('foo');\\n * var y = goog.getCssName(this.baseClass, 'active');\\n * becomes:\\n * var x = 'foo';\\n * var y = this.baseClass + '-active';\\n *\\n * If one argument is passed it will be processed, if two are passed only the\\n * modifier will be processed, as it is assumed the first argument was generated\\n * as a result of calling goog.getCssName.\\n *\\n * @param {string} className The class name.\\n * @param {string=} opt_modifier A modifier to be appended to the class name.\\n * @return {string} The class name or the concatenation of the class name and\\n * the modifier.\\n */\\ngoog.getCssName = function(className, opt_modifier) {\\n // String() is used for compatibility with compiled soy where the passed\\n // className can be non-string objects.\\n if (String(className).charAt(0) == '.') {\\n throw new Error(\\n 'className passed in goog.getCssName must not start with \\\".\\\".' +\\n ' You passed: ' + className);\\n }\\n\\n var getMapping = function(cssName) {\\n return goog.cssNameMapping_[cssName] || cssName;\\n };\\n\\n var renameByParts = function(cssName) {\\n // Remap all the parts individually.\\n var parts = cssName.split('-');\\n var mapped = [];\\n for (var i = 0; i < parts.length; i++) {\\n mapped.push(getMapping(parts[i]));\\n }\\n return mapped.join('-');\\n };\\n\\n var rename;\\n if (goog.cssNameMapping_) {\\n rename =\\n goog.cssNameMappingStyle_ == 'BY_WHOLE' ? getMapping : renameByParts;\\n } else {\\n rename = function(a) {\\n return a;\\n };\\n }\\n\\n var result =\\n opt_modifier ? className + '-' + rename(opt_modifier) : rename(className);\\n\\n // The special CLOSURE_CSS_NAME_MAP_FN allows users to specify further\\n // processing of the class name.\\n if (goog.global.CLOSURE_CSS_NAME_MAP_FN) {\\n return goog.global.CLOSURE_CSS_NAME_MAP_FN(result);\\n }\\n\\n return result;\\n};\\n\\n\\n/**\\n * Sets the map to check when returning a value from goog.getCssName(). Example:\\n * <pre>\\n * goog.setCssNameMapping({\\n * \\\"goog\\\": \\\"a\\\",\\n * \\\"disabled\\\": \\\"b\\\",\\n * });\\n *\\n * var x = goog.getCssName('goog');\\n * // The following evaluates to: \\\"a a-b\\\".\\n * goog.getCssName('goog') + ' ' + goog.getCssName(x, 'disabled')\\n * </pre>\\n * When declared as a map of string literals to string literals, the JSCompiler\\n * will replace all calls to goog.getCssName() using the supplied map if the\\n * --process_closure_primitives flag is set.\\n *\\n * @param {!Object} mapping A map of strings to strings where keys are possible\\n * arguments to goog.getCssName() and values are the corresponding values\\n * that should be returned.\\n * @param {string=} opt_style The style of css name mapping. There are two valid\\n * options: 'BY_PART', and 'BY_WHOLE'.\\n * @see goog.getCssName for a description.\\n */\\ngoog.setCssNameMapping = function(mapping, opt_style) {\\n goog.cssNameMapping_ = mapping;\\n goog.cssNameMappingStyle_ = opt_style;\\n};\\n\\n\\n/**\\n * To use CSS renaming in compiled mode, one of the input files should have a\\n * call to goog.setCssNameMapping() with an object literal that the JSCompiler\\n * can extract and use to replace all calls to goog.getCssName(). In uncompiled\\n * mode, JavaScript code should be loaded before this base.js file that declares\\n * a global variable, CLOSURE_CSS_NAME_MAPPING, which is used below. This is\\n * to ensure that the mapping is loaded before any calls to goog.getCssName()\\n * are made in uncompiled mode.\\n *\\n * A hook for overriding the CSS name mapping.\\n * @type {!Object<string, string>|undefined}\\n */\\ngoog.global.CLOSURE_CSS_NAME_MAPPING;\\n\\n\\nif (!COMPILED && goog.global.CLOSURE_CSS_NAME_MAPPING) {\\n // This does not call goog.setCssNameMapping() because the JSCompiler\\n // requires that goog.setCssNameMapping() be called with an object literal.\\n goog.cssNameMapping_ = goog.global.CLOSURE_CSS_NAME_MAPPING;\\n}\\n\\n/**\\n * Options bag type for `goog.getMsg()` third argument.\\n *\\n * It is important to note that these options need to be known at compile time,\\n * so they must always be provided to `goog.getMsg()` as an actual object\\n * literal in the function call. Otherwise, closure-compiler will report an\\n * error.\\n * @record\\n */\\ngoog.GetMsgOptions = function() {};\\n\\n/**\\n * If `true`, escape '<' in the message string to '<'.\\n *\\n * Used by Closure Templates where the generated code size and performance is\\n * critical which is why {@link goog.html.SafeHtmlFormatter} is not used.\\n * The value must be literal `true` or `false`.\\n * @type {boolean|undefined}\\n */\\ngoog.GetMsgOptions.prototype.html;\\n\\n/**\\n * If `true`, unescape common html entities: >, <, ', " and\\n * &.\\n *\\n * Used for messages not in HTML context, such as with the `textContent`\\n * property.\\n * The value must be literal `true` or `false`.\\n * @type {boolean|undefined}\\n */\\ngoog.GetMsgOptions.prototype.unescapeHtmlEntities;\\n\\n/**\\n * Associates placeholder names with strings showing how their values are\\n * obtained.\\n *\\n * This field is intended for use in automatically generated JS code.\\n * Human-written code should use meaningful placeholder names instead.\\n *\\n * closure-compiler uses this as the contents of the `<ph>` tag in the\\n * XMB file it generates or defaults to `-` for historical reasons.\\n *\\n * Must be an object literal.\\n * Ignored at runtime.\\n * Keys are placeholder names.\\n * Values are string literals indicating how the value is obtained.\\n * Typically this is a snippet of source code.\\n * @type {!Object<string, string>|undefined}\\n */\\ngoog.GetMsgOptions.prototype.original_code;\\n\\n/**\\n * Associates placeholder names with example values.\\n *\\n * closure-compiler uses this as the contents of the `<ex>` tag in the\\n * XMB file it generates or defaults to `-` for historical reasons.\\n *\\n * Must be an object literal.\\n * Ignored at runtime.\\n * Keys are placeholder names.\\n * Values are string literals containing example placeholder values.\\n * (e.g. \\\"George McFly\\\" for a name placeholder)\\n * @type {!Object<string, string>|undefined}\\n */\\ngoog.GetMsgOptions.prototype.example;\\n\\n/**\\n * Gets a localized message.\\n *\\n * This function is a compiler primitive. If you give the compiler a localized\\n * message bundle, it will replace the string at compile-time with a localized\\n * version, and expand goog.getMsg call to a concatenated string.\\n *\\n * Messages must be initialized in the form:\\n * <code>\\n * var MSG_NAME = goog.getMsg('Hello {$placeholder}', {'placeholder': 'world'});\\n * </code>\\n *\\n * This function produces a string which should be treated as plain text. Use\\n * {@link goog.html.SafeHtmlFormatter} in conjunction with goog.getMsg to\\n * produce SafeHtml.\\n *\\n * @param {string} str Translatable string, places holders in the form {$foo}.\\n * @param {!Object<string, string>=} opt_values Maps place holder name to value.\\n * @param {!goog.GetMsgOptions=} opt_options see `goog.GetMsgOptions`\\n * @return {string} message with placeholders filled.\\n */\\ngoog.getMsg = function(str, opt_values, opt_options) {\\n if (opt_options && opt_options.html) {\\n // Note that '&' is not replaced because the translation can contain HTML\\n // entities.\\n str = str.replace(/</g, '<');\\n }\\n if (opt_options && opt_options.unescapeHtmlEntities) {\\n // Note that \\\"&\\\" must be the last to avoid \\\"creating\\\" new entities.\\n str = str.replace(/</g, '<')\\n .replace(/>/g, '>')\\n .replace(/'/g, '\\\\'')\\n .replace(/"/g, '\\\"')\\n .replace(/&/g, '&');\\n }\\n if (opt_values) {\\n str = str.replace(/\\\\{\\\\$([^}]+)}/g, function(match, key) {\\n return (opt_values != null && key in opt_values) ? opt_values[key] :\\n match;\\n });\\n }\\n return str;\\n};\\n\\n\\n/**\\n * Gets a localized message. If the message does not have a translation, gives a\\n * fallback message.\\n *\\n * This is useful when introducing a new message that has not yet been\\n * translated into all languages.\\n *\\n * This function is a compiler primitive. Must be used in the form:\\n * <code>var x = goog.getMsgWithFallback(MSG_A, MSG_B);</code>\\n * where MSG_A and MSG_B were initialized with goog.getMsg.\\n *\\n * @param {string} a The preferred message.\\n * @param {string} b The fallback message.\\n * @return {string} The best translated message.\\n */\\ngoog.getMsgWithFallback = function(a, b) {\\n return a;\\n};\\n\\n\\n/**\\n * Exposes an unobfuscated global namespace path for the given object.\\n * Note that fields of the exported object *will* be obfuscated, unless they are\\n * exported in turn via this function or goog.exportProperty.\\n *\\n * Also handy for making public items that are defined in anonymous closures.\\n *\\n * ex. goog.exportSymbol('public.path.Foo', Foo);\\n *\\n * ex. goog.exportSymbol('public.path.Foo.staticFunction', Foo.staticFunction);\\n * public.path.Foo.staticFunction();\\n *\\n * ex. goog.exportSymbol('public.path.Foo.prototype.myMethod',\\n * Foo.prototype.myMethod);\\n * new public.path.Foo().myMethod();\\n *\\n * @param {string} publicPath Unobfuscated name to export.\\n * @param {*} object Object the name should point to.\\n * @param {?Object=} objectToExportTo The object to add the path to; default\\n * is goog.global.\\n */\\ngoog.exportSymbol = function(publicPath, object, objectToExportTo) {\\n goog.exportPath_(\\n publicPath, object, /* overwriteImplicit= */ true, objectToExportTo);\\n};\\n\\n\\n/**\\n * Exports a property unobfuscated into the object's namespace.\\n * ex. goog.exportProperty(Foo, 'staticFunction', Foo.staticFunction);\\n * ex. goog.exportProperty(Foo.prototype, 'myMethod', Foo.prototype.myMethod);\\n * @param {Object} object Object whose static property is being exported.\\n * @param {string} publicName Unobfuscated name to export.\\n * @param {*} symbol Object the name should point to.\\n */\\ngoog.exportProperty = function(object, publicName, symbol) {\\n object[publicName] = symbol;\\n};\\n\\n\\n/**\\n * Inherit the prototype methods from one constructor into another.\\n *\\n * Usage:\\n * <pre>\\n * function ParentClass(a, b) { }\\n * ParentClass.prototype.foo = function(a) { };\\n *\\n * function ChildClass(a, b, c) {\\n * ChildClass.base(this, 'constructor', a, b);\\n * }\\n * goog.inherits(ChildClass, ParentClass);\\n *\\n * var child = new ChildClass('a', 'b', 'see');\\n * child.foo(); // This works.\\n * </pre>\\n *\\n * @param {!Function} childCtor Child class.\\n * @param {!Function} parentCtor Parent class.\\n * @suppress {strictMissingProperties} superClass_ and base is not defined on\\n * Function.\\n * @deprecated Use ECMAScript class syntax instead.\\n */\\ngoog.inherits = function(childCtor, parentCtor) {\\n /** @constructor */\\n function tempCtor() {}\\n tempCtor.prototype = parentCtor.prototype;\\n childCtor.superClass_ = parentCtor.prototype;\\n childCtor.prototype = new tempCtor();\\n /** @override */\\n childCtor.prototype.constructor = childCtor;\\n\\n /**\\n * Calls superclass constructor/method.\\n *\\n * This function is only available if you use goog.inherits to\\n * express inheritance relationships between classes.\\n *\\n * NOTE: This is a replacement for goog.base and for superClass_\\n * property defined in childCtor.\\n *\\n * @param {!Object} me Should always be \\\"this\\\".\\n * @param {string} methodName The method name to call. Calling\\n * superclass constructor can be done with the special string\\n * 'constructor'.\\n * @param {...*} var_args The arguments to pass to superclass\\n * method/constructor.\\n * @return {*} The return value of the superclass method/constructor.\\n */\\n childCtor.base = function(me, methodName, var_args) {\\n // Copying using loop to avoid deop due to passing arguments object to\\n // function. This is faster in many JS engines as of late 2014.\\n var args = new Array(arguments.length - 2);\\n for (var i = 2; i < arguments.length; i++) {\\n args[i - 2] = arguments[i];\\n }\\n return parentCtor.prototype[methodName].apply(me, args);\\n };\\n};\\n\\n\\n/**\\n * Allow for aliasing within scope functions. This function exists for\\n * uncompiled code - in compiled code the calls will be inlined and the aliases\\n * applied. In uncompiled code the function is simply run since the aliases as\\n * written are valid JavaScript.\\n *\\n *\\n * @param {function()} fn Function to call. This function can contain aliases\\n * to namespaces (e.g. \\\"var dom = goog.dom\\\") or classes\\n * (e.g. \\\"var Timer = goog.Timer\\\").\\n * @deprecated Use goog.module instead.\\n */\\ngoog.scope = function(fn) {\\n if (goog.isInModuleLoader_()) {\\n throw new Error('goog.scope is not supported within a module.');\\n }\\n fn.call(goog.global);\\n};\\n\\n\\n/*\\n * To support uncompiled, strict mode bundles that use eval to divide source\\n * like so:\\n * eval('someSource;//# sourceUrl sourcefile.js');\\n * We need to export the globally defined symbols \\\"goog\\\" and \\\"COMPILED\\\".\\n * Exporting \\\"goog\\\" breaks the compiler optimizations, so we required that\\n * be defined externally.\\n * NOTE: We don't use goog.exportSymbol here because we don't want to trigger\\n * extern generation when that compiler option is enabled.\\n */\\nif (!COMPILED) {\\n goog.global['COMPILED'] = COMPILED;\\n}\\n\\n\\n//==============================================================================\\n// goog.defineClass implementation\\n//==============================================================================\\n\\n\\n/**\\n * Creates a restricted form of a Closure \\\"class\\\":\\n * - from the compiler's perspective, the instance returned from the\\n * constructor is sealed (no new properties may be added). This enables\\n * better checks.\\n * - the compiler will rewrite this definition to a form that is optimal\\n * for type checking and optimization (initially this will be a more\\n * traditional form).\\n *\\n * @param {Function} superClass The superclass, Object or null.\\n * @param {goog.defineClass.ClassDescriptor} def\\n * An object literal describing\\n * the class. It may have the following properties:\\n * \\\"constructor\\\": the constructor function\\n * \\\"statics\\\": an object literal containing methods to add to the constructor\\n * as \\\"static\\\" methods or a function that will receive the constructor\\n * function as its only parameter to which static properties can\\n * be added.\\n * all other properties are added to the prototype.\\n * @return {!Function} The class constructor.\\n * @deprecated Use ECMAScript class syntax instead.\\n */\\ngoog.defineClass = function(superClass, def) {\\n // TODO(johnlenz): consider making the superClass an optional parameter.\\n var constructor = def.constructor;\\n var statics = def.statics;\\n // Wrap the constructor prior to setting up the prototype and static methods.\\n if (!constructor || constructor == Object.prototype.constructor) {\\n constructor = function() {\\n throw new Error(\\n 'cannot instantiate an interface (no constructor defined).');\\n };\\n }\\n\\n var cls = goog.defineClass.createSealingConstructor_(constructor, superClass);\\n if (superClass) {\\n goog.inherits(cls, superClass);\\n }\\n\\n // Remove all the properties that should not be copied to the prototype.\\n delete def.constructor;\\n delete def.statics;\\n\\n goog.defineClass.applyProperties_(cls.prototype, def);\\n if (statics != null) {\\n if (statics instanceof Function) {\\n statics(cls);\\n } else {\\n goog.defineClass.applyProperties_(cls, statics);\\n }\\n }\\n\\n return cls;\\n};\\n\\n\\n/**\\n * @typedef {{\\n * constructor: (!Function|undefined),\\n * statics: (Object|undefined|function(Function):void)\\n * }}\\n */\\ngoog.defineClass.ClassDescriptor;\\n\\n\\n/**\\n * @define {boolean} Whether the instances returned by goog.defineClass should\\n * be sealed when possible.\\n *\\n * When sealing is disabled the constructor function will not be wrapped by\\n * goog.defineClass, making it incompatible with ES6 class methods.\\n */\\ngoog.defineClass.SEAL_CLASS_INSTANCES =\\n goog.define('goog.defineClass.SEAL_CLASS_INSTANCES', goog.DEBUG);\\n\\n\\n/**\\n * If goog.defineClass.SEAL_CLASS_INSTANCES is enabled and Object.seal is\\n * defined, this function will wrap the constructor in a function that seals the\\n * results of the provided constructor function.\\n *\\n * @param {!Function} ctr The constructor whose results maybe be sealed.\\n * @param {Function} superClass The superclass constructor.\\n * @return {!Function} The replacement constructor.\\n * @private\\n */\\ngoog.defineClass.createSealingConstructor_ = function(ctr, superClass) {\\n if (!goog.defineClass.SEAL_CLASS_INSTANCES) {\\n // Do now wrap the constructor when sealing is disabled. Angular code\\n // depends on this for injection to work properly.\\n return ctr;\\n }\\n\\n // NOTE: The sealing behavior has been removed\\n\\n /**\\n * @this {Object}\\n * @return {?}\\n */\\n var wrappedCtr = function() {\\n // Don't seal an instance of a subclass when it calls the constructor of\\n // its super class as there is most likely still setup to do.\\n var instance = ctr.apply(this, arguments) || this;\\n instance[goog.UID_PROPERTY_] = instance[goog.UID_PROPERTY_];\\n\\n return instance;\\n };\\n\\n return wrappedCtr;\\n};\\n\\n\\n\\n// TODO(johnlenz): share these values with the goog.object\\n/**\\n * The names of the fields that are defined on Object.prototype.\\n * @type {!Array<string>}\\n * @private\\n * @const\\n */\\ngoog.defineClass.OBJECT_PROTOTYPE_FIELDS_ = [\\n 'constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable',\\n 'toLocaleString', 'toString', 'valueOf'\\n];\\n\\n\\n// TODO(johnlenz): share this function with the goog.object\\n/**\\n * @param {!Object} target The object to add properties to.\\n * @param {!Object} source The object to copy properties from.\\n * @private\\n */\\ngoog.defineClass.applyProperties_ = function(target, source) {\\n // TODO(johnlenz): update this to support ES5 getters/setters\\n\\n var key;\\n for (key in source) {\\n if (Object.prototype.hasOwnProperty.call(source, key)) {\\n target[key] = source[key];\\n }\\n }\\n\\n // For IE the for-in-loop does not contain any properties that are not\\n // enumerable on the prototype object (for example isPrototypeOf from\\n // Object.prototype) and it will also not include 'replace' on objects that\\n // extend String and change 'replace' (not that it is common for anyone to\\n // extend anything except Object).\\n for (var i = 0; i < goog.defineClass.OBJECT_PROTOTYPE_FIELDS_.length; i++) {\\n key = goog.defineClass.OBJECT_PROTOTYPE_FIELDS_[i];\\n if (Object.prototype.hasOwnProperty.call(source, key)) {\\n target[key] = source[key];\\n }\\n }\\n};\\n\\n/**\\n * Returns the parameter.\\n * @param {string} s\\n * @return {string}\\n * @private\\n */\\ngoog.identity_ = function(s) {\\n return s;\\n};\\n\\n\\n/**\\n * Creates Trusted Types policy if Trusted Types are supported by the browser.\\n * The policy just blesses any string as a Trusted Type. It is not visibility\\n * restricted because anyone can also call trustedTypes.createPolicy directly.\\n * However, the allowed names should be restricted by a HTTP header and the\\n * reference to the created policy should be visibility restricted.\\n * @param {string} name\\n * @return {?TrustedTypePolicy}\\n */\\ngoog.createTrustedTypesPolicy = function(name) {\\n var policy = null;\\n var policyFactory = goog.global.trustedTypes;\\n if (!policyFactory || !policyFactory.createPolicy) {\\n return policy;\\n }\\n // trustedTypes.createPolicy throws if called with a name that is already\\n // registered, even in report-only mode. Until the API changes, catch the\\n // error not to break the applications functionally. In such case, the code\\n // will fall back to using regular Safe Types.\\n // TODO(koto): Remove catching once createPolicy API stops throwing.\\n try {\\n policy = policyFactory.createPolicy(name, {\\n createHTML: goog.identity_,\\n createScript: goog.identity_,\\n createScriptURL: goog.identity_\\n });\\n } catch (e) {\\n goog.logToConsole_(e.message);\\n }\\n return policy;\\n};\\n\\n// There's a bug in the compiler where without collapse properties the\\n// Closure namespace defines do not guard code correctly. To help reduce code\\n// size also check for !COMPILED even though it redundant until this is fixed.\\nif (!COMPILED && goog.DEPENDENCIES_ENABLED) {\\n\\n\\n /**\\n * Tries to detect whether the current browser is Edge, based on the user\\n * agent. This matches only pre-Chromium Edge.\\n * @see https://docs.microsoft.com/en-us/microsoft-edge/web-platform/user-agent-string\\n * @return {boolean} True if the current browser is Edge.\\n * @private\\n */\\n goog.isEdge_ = function() {\\n var userAgent = goog.global.navigator && goog.global.navigator.userAgent ?\\n goog.global.navigator.userAgent :\\n '';\\n var edgeRe = /Edge\\\\/(\\\\d+)(\\\\.\\\\d)*/i;\\n return !!userAgent.match(edgeRe);\\n };\\n\\n\\n /**\\n * Tries to detect whether is in the context of an HTML document.\\n * @return {boolean} True if it looks like HTML document.\\n * @private\\n */\\n goog.inHtmlDocument_ = function() {\\n /** @type {!Document} */\\n var doc = goog.global.document;\\n return doc != null && 'write' in doc; // XULDocument misses write.\\n };\\n\\n\\n /**\\n * We'd like to check for if the document readyState is 'loading'; however\\n * there are bugs on IE 10 and below where the readyState being anything other\\n * than 'complete' is not reliable.\\n * @return {boolean}\\n * @private\\n */\\n goog.isDocumentLoading_ = function() {\\n // attachEvent is available on IE 6 thru 10 only, and thus can be used to\\n // detect those browsers.\\n /** @type {!HTMLDocument} */\\n var doc = goog.global.document;\\n return doc.attachEvent ? doc.readyState != 'complete' :\\n doc.readyState == 'loading';\\n };\\n\\n\\n /**\\n * Tries to detect the base path of base.js script that bootstraps Closure.\\n * @private\\n */\\n goog.findBasePath_ = function() {\\n if (goog.global.CLOSURE_BASE_PATH != undefined &&\\n // Anti DOM-clobbering runtime check (b/37736576).\\n typeof goog.global.CLOSURE_BASE_PATH === 'string') {\\n goog.basePath = goog.global.CLOSURE_BASE_PATH;\\n return;\\n } else if (!goog.inHtmlDocument_()) {\\n return;\\n }\\n /** @type {!Document} */\\n var doc = goog.global.document;\\n // If we have a currentScript available, use it exclusively.\\n var currentScript = doc.currentScript;\\n if (currentScript) {\\n var scripts = [currentScript];\\n } else {\\n var scripts = doc.getElementsByTagName('SCRIPT');\\n }\\n // Search backwards since the current script is in almost all cases the one\\n // that has base.js.\\n for (var i = scripts.length - 1; i >= 0; --i) {\\n var script = /** @type {!HTMLScriptElement} */ (scripts[i]);\\n var src = script.src;\\n var qmark = src.lastIndexOf('?');\\n var l = qmark == -1 ? src.length : qmark;\\n if (src.slice(l - 7, l) == 'base.js') {\\n goog.basePath = src.slice(0, l - 7);\\n return;\\n }\\n }\\n };\\n\\n goog.findBasePath_();\\n\\n /**\\n * Rewrites closing script tags in input to avoid ending an enclosing script\\n * tag.\\n *\\n * @param {string} str\\n * @return {string}\\n * @private\\n */\\n goog.protectScriptTag_ = function(str) {\\n return str.replace(/<\\\\/(SCRIPT)/ig, '\\\\\\\\x3c/$1');\\n };\\n\\n\\n /**\\n * A debug loader is responsible for downloading and executing javascript\\n * files in an unbundled, uncompiled environment.\\n *\\n * This can be custimized via the setDependencyFactory method, or by\\n * CLOSURE_IMPORT_SCRIPT/CLOSURE_LOAD_FILE_SYNC.\\n *\\n * @struct @constructor @final @private\\n */\\n goog.DebugLoader_ = function() {\\n /** @private @const {!Object<string, !goog.Dependency>} */\\n this.dependencies_ = {};\\n /** @private @const {!Object<string, string>} */\\n this.idToPath_ = {};\\n /** @private @const {!Object<string, boolean>} */\\n this.written_ = {};\\n /** @private @const {!Array<!goog.Dependency>} */\\n this.loadingDeps_ = [];\\n /** @private {!Array<!goog.Dependency>} */\\n this.depsToLoad_ = [];\\n /** @private {boolean} */\\n this.paused_ = false;\\n /** @private {!goog.DependencyFactory} */\\n this.factory_ = new goog.DependencyFactory();\\n /** @private @const {!Object<string, !Function>} */\\n this.deferredCallbacks_ = {};\\n /** @private @const {!Array<string>} */\\n this.deferredQueue_ = [];\\n };\\n\\n /**\\n * @param {!Array<string>} namespaces\\n * @param {function(): undefined} callback Function to call once all the\\n * namespaces have loaded.\\n */\\n goog.DebugLoader_.prototype.bootstrap = function(namespaces, callback) {\\n var cb = callback;\\n function resolve() {\\n if (cb) {\\n goog.global.setTimeout(cb, 0);\\n cb = null;\\n }\\n }\\n\\n if (!namespaces.length) {\\n resolve();\\n return;\\n }\\n\\n var deps = [];\\n for (var i = 0; i < namespaces.length; i++) {\\n var path = this.getPathFromDeps_(namespaces[i]);\\n if (!path) {\\n throw new Error('Unregonized namespace: ' + namespaces[i]);\\n }\\n deps.push(this.dependencies_[path]);\\n }\\n\\n var require = goog.require;\\n var loaded = 0;\\n for (var i = 0; i < namespaces.length; i++) {\\n require(namespaces[i]);\\n deps[i].onLoad(function() {\\n if (++loaded == namespaces.length) {\\n resolve();\\n }\\n });\\n }\\n };\\n\\n\\n /**\\n * Loads the Closure Dependency file.\\n *\\n * Exposed a public function so CLOSURE_NO_DEPS can be set to false, base\\n * loaded, setDependencyFactory called, and then this called. i.e. allows\\n * custom loading of the deps file.\\n */\\n goog.DebugLoader_.prototype.loadClosureDeps = function() {\\n // Circumvent addDependency, which would try to transpile deps.js if\\n // transpile is set to always.\\n var relPath = 'deps.js';\\n this.depsToLoad_.push(this.factory_.createDependency(\\n goog.normalizePath_(goog.basePath + relPath), relPath, [], [], {}));\\n this.loadDeps_();\\n };\\n\\n\\n /**\\n * Notifies the debug loader when a dependency has been requested.\\n *\\n * @param {string} absPathOrId Path of the dependency or goog id.\\n * @param {boolean=} opt_force\\n */\\n goog.DebugLoader_.prototype.requested = function(absPathOrId, opt_force) {\\n var path = this.getPathFromDeps_(absPathOrId);\\n if (path &&\\n (opt_force || this.areDepsLoaded_(this.dependencies_[path].requires))) {\\n var callback = this.deferredCallbacks_[path];\\n if (callback) {\\n delete this.deferredCallbacks_[path];\\n callback();\\n }\\n }\\n };\\n\\n\\n /**\\n * Sets the dependency factory, which can be used to create custom\\n * goog.Dependency implementations to control how dependencies are loaded.\\n *\\n * @param {!goog.DependencyFactory} factory\\n */\\n goog.DebugLoader_.prototype.setDependencyFactory = function(factory) {\\n this.factory_ = factory;\\n };\\n\\n\\n /**\\n * Travserses the dependency graph and queues the given dependency, and all of\\n * its transitive dependencies, for loading and then starts loading if not\\n * paused.\\n *\\n * @param {string} namespace\\n * @private\\n */\\n goog.DebugLoader_.prototype.load_ = function(namespace) {\\n if (!this.getPathFromDeps_(namespace)) {\\n var errorMessage = 'goog.require could not find: ' + namespace;\\n goog.logToConsole_(errorMessage);\\n } else {\\n var loader = this;\\n\\n var deps = [];\\n\\n /** @param {string} namespace */\\n var visit = function(namespace) {\\n var path = loader.getPathFromDeps_(namespace);\\n\\n if (!path) {\\n throw new Error('Bad dependency path or symbol: ' + namespace);\\n }\\n\\n if (loader.written_[path]) {\\n return;\\n }\\n\\n loader.written_[path] = true;\\n\\n var dep = loader.dependencies_[path];\\n for (var i = 0; i < dep.requires.length; i++) {\\n if (!goog.isProvided_(dep.requires[i])) {\\n visit(dep.requires[i]);\\n }\\n }\\n\\n deps.push(dep);\\n };\\n\\n visit(namespace);\\n\\n var wasLoading = !!this.depsToLoad_.length;\\n this.depsToLoad_ = this.depsToLoad_.concat(deps);\\n\\n if (!this.paused_ && !wasLoading) {\\n this.loadDeps_();\\n }\\n }\\n };\\n\\n\\n /**\\n * Loads any queued dependencies until they are all loaded or paused.\\n *\\n * @private\\n */\\n goog.DebugLoader_.prototype.loadDeps_ = function() {\\n var loader = this;\\n var paused = this.paused_;\\n\\n while (this.depsToLoad_.length && !paused) {\\n (function() {\\n var loadCallDone = false;\\n var dep = loader.depsToLoad_.shift();\\n\\n var loaded = false;\\n loader.loading_(dep);\\n\\n var controller = {\\n pause: function() {\\n if (loadCallDone) {\\n throw new Error('Cannot call pause after the call to load.');\\n } else {\\n paused = true;\\n }\\n },\\n resume: function() {\\n if (loadCallDone) {\\n loader.resume_();\\n } else {\\n // Some dep called pause and then resume in the same load call.\\n // Just keep running this same loop.\\n paused = false;\\n }\\n },\\n loaded: function() {\\n if (loaded) {\\n throw new Error('Double call to loaded.');\\n }\\n\\n loaded = true;\\n loader.loaded_(dep);\\n },\\n pending: function() {\\n // Defensive copy.\\n var pending = [];\\n for (var i = 0; i < loader.loadingDeps_.length; i++) {\\n pending.push(loader.loadingDeps_[i]);\\n }\\n return pending;\\n },\\n /**\\n * @param {goog.ModuleType} type\\n */\\n setModuleState: function(type) {\\n goog.moduleLoaderState_ = {\\n type: type,\\n moduleName: '',\\n declareLegacyNamespace: false\\n };\\n },\\n /** @type {function(string, string, string=)} */\\n registerEs6ModuleExports: function(\\n path, exports, opt_closureNamespace) {\\n if (opt_closureNamespace) {\\n goog.loadedModules_[opt_closureNamespace] = {\\n exports: exports,\\n type: goog.ModuleType.ES6,\\n moduleId: opt_closureNamespace || ''\\n };\\n }\\n },\\n /** @type {function(string, ?)} */\\n registerGoogModuleExports: function(moduleId, exports) {\\n goog.loadedModules_[moduleId] = {\\n exports: exports,\\n type: goog.ModuleType.GOOG,\\n moduleId: moduleId\\n };\\n },\\n clearModuleState: function() {\\n goog.moduleLoaderState_ = null;\\n },\\n defer: function(callback) {\\n if (loadCallDone) {\\n throw new Error(\\n 'Cannot register with defer after the call to load.');\\n }\\n loader.defer_(dep, callback);\\n },\\n areDepsLoaded: function() {\\n return loader.areDepsLoaded_(dep.requires);\\n }\\n };\\n\\n try {\\n dep.load(controller);\\n } finally {\\n loadCallDone = true;\\n }\\n })();\\n }\\n\\n if (paused) {\\n this.pause_();\\n }\\n };\\n\\n\\n /** @private */\\n goog.DebugLoader_.prototype.pause_ = function() {\\n this.paused_ = true;\\n };\\n\\n\\n /** @private */\\n goog.DebugLoader_.prototype.resume_ = function() {\\n if (this.paused_) {\\n this.paused_ = false;\\n this.loadDeps_();\\n }\\n };\\n\\n\\n /**\\n * Marks the given dependency as loading (load has been called but it has not\\n * yet marked itself as finished). Useful for dependencies that want to know\\n * what else is loading. Example: goog.modules cannot eval if there are\\n * loading dependencies.\\n *\\n * @param {!goog.Dependency} dep\\n * @private\\n */\\n goog.DebugLoader_.prototype.loading_ = function(dep) {\\n this.loadingDeps_.push(dep);\\n };\\n\\n\\n /**\\n * Marks the given dependency as having finished loading and being available\\n * for require.\\n *\\n * @param {!goog.Dependency} dep\\n * @private\\n */\\n goog.DebugLoader_.prototype.loaded_ = function(dep) {\\n for (var i = 0; i < this.loadingDeps_.length; i++) {\\n if (this.loadingDeps_[i] == dep) {\\n this.loadingDeps_.splice(i, 1);\\n break;\\n }\\n }\\n\\n for (var i = 0; i < this.deferredQueue_.length; i++) {\\n if (this.deferredQueue_[i] == dep.path) {\\n this.deferredQueue_.splice(i, 1);\\n break;\\n }\\n }\\n\\n if (this.loadingDeps_.length == this.deferredQueue_.length &&\\n !this.depsToLoad_.length) {\\n // Something has asked to load these, but they may not be directly\\n // required again later, so load them now that we know we're done loading\\n // everything else. e.g. a goog module entry point.\\n while (this.deferredQueue_.length) {\\n this.requested(this.deferredQueue_.shift(), true);\\n }\\n }\\n\\n dep.loaded();\\n };\\n\\n\\n /**\\n * @param {!Array<string>} pathsOrIds\\n * @return {boolean}\\n * @private\\n */\\n goog.DebugLoader_.prototype.areDepsLoaded_ = function(pathsOrIds) {\\n for (var i = 0; i < pathsOrIds.length; i++) {\\n var path = this.getPathFromDeps_(pathsOrIds[i]);\\n if (!path ||\\n (!(path in this.deferredCallbacks_) &&\\n !goog.isProvided_(pathsOrIds[i]))) {\\n return false;\\n }\\n }\\n\\n return true;\\n };\\n\\n\\n /**\\n * @param {string} absPathOrId\\n * @return {?string}\\n * @private\\n */\\n goog.DebugLoader_.prototype.getPathFromDeps_ = function(absPathOrId) {\\n if (absPathOrId in this.idToPath_) {\\n return this.idToPath_[absPathOrId];\\n } else if (absPathOrId in this.dependencies_) {\\n return absPathOrId;\\n } else {\\n return null;\\n }\\n };\\n\\n\\n /**\\n * @param {!goog.Dependency} dependency\\n * @param {!Function} callback\\n * @private\\n */\\n goog.DebugLoader_.prototype.defer_ = function(dependency, callback) {\\n this.deferredCallbacks_[dependency.path] = callback;\\n this.deferredQueue_.push(dependency.path);\\n };\\n\\n\\n /**\\n * Interface for goog.Dependency implementations to have some control over\\n * loading of dependencies.\\n *\\n * @record\\n */\\n goog.LoadController = function() {};\\n\\n\\n /**\\n * Tells the controller to halt loading of more dependencies.\\n */\\n goog.LoadController.prototype.pause = function() {};\\n\\n\\n /**\\n * Tells the controller to resume loading of more dependencies if paused.\\n */\\n goog.LoadController.prototype.resume = function() {};\\n\\n\\n /**\\n * Tells the controller that this dependency has finished loading.\\n *\\n * This causes this to be removed from pending() and any load callbacks to\\n * fire.\\n */\\n goog.LoadController.prototype.loaded = function() {};\\n\\n\\n /**\\n * List of dependencies on which load has been called but which have not\\n * called loaded on their controller. This includes the current dependency.\\n *\\n * @return {!Array<!goog.Dependency>}\\n */\\n goog.LoadController.prototype.pending = function() {};\\n\\n\\n /**\\n * Registers an object as an ES6 module's exports so that goog.modules may\\n * require it by path.\\n *\\n * @param {string} path Full path of the module.\\n * @param {?} exports\\n * @param {string=} opt_closureNamespace Closure namespace to associate with\\n * this module.\\n */\\n goog.LoadController.prototype.registerEs6ModuleExports = function(\\n path, exports, opt_closureNamespace) {};\\n\\n\\n /**\\n * Sets the current module state.\\n *\\n * @param {goog.ModuleType} type Type of module.\\n */\\n goog.LoadController.prototype.setModuleState = function(type) {};\\n\\n\\n /**\\n * Clears the current module state.\\n */\\n goog.LoadController.prototype.clearModuleState = function() {};\\n\\n\\n /**\\n * Registers a callback to call once the dependency is actually requested\\n * via goog.require + all of the immediate dependencies have been loaded or\\n * all other files have been loaded. Allows for lazy loading until\\n * require'd without pausing dependency loading, which is needed on old IE.\\n *\\n * @param {!Function} callback\\n */\\n goog.LoadController.prototype.defer = function(callback) {};\\n\\n\\n /**\\n * @return {boolean}\\n */\\n goog.LoadController.prototype.areDepsLoaded = function() {};\\n\\n\\n /**\\n * Basic super class for all dependencies Closure Library can load.\\n *\\n * This default implementation is designed to load untranspiled, non-module\\n * scripts in a web broswer.\\n *\\n * For goog.modules see {@see goog.GoogModuleDependency}.\\n * For untranspiled ES6 modules {@see goog.Es6ModuleDependency}.\\n *\\n * @param {string} path Absolute path of this script.\\n * @param {string} relativePath Path of this script relative to goog.basePath.\\n * @param {!Array<string>} provides goog.provided or goog.module symbols\\n * in this file.\\n * @param {!Array<string>} requires goog symbols or relative paths to Closure\\n * this depends on.\\n * @param {!Object<string, string>} loadFlags\\n * @struct @constructor\\n */\\n goog.Dependency = function(\\n path, relativePath, provides, requires, loadFlags) {\\n /** @const */\\n this.path = path;\\n /** @const */\\n this.relativePath = relativePath;\\n /** @const */\\n this.provides = provides;\\n /** @const */\\n this.requires = requires;\\n /** @const */\\n this.loadFlags = loadFlags;\\n /** @private {boolean} */\\n this.loaded_ = false;\\n /** @private {!Array<function()>} */\\n this.loadCallbacks_ = [];\\n };\\n\\n\\n /**\\n * @return {string} The pathname part of this dependency's path if it is a\\n * URI.\\n */\\n goog.Dependency.prototype.getPathName = function() {\\n var pathName = this.path;\\n var protocolIndex = pathName.indexOf('://');\\n if (protocolIndex >= 0) {\\n pathName = pathName.substring(protocolIndex + 3);\\n var slashIndex = pathName.indexOf('/');\\n if (slashIndex >= 0) {\\n pathName = pathName.substring(slashIndex + 1);\\n }\\n }\\n return pathName;\\n };\\n\\n\\n /**\\n * @param {function()} callback Callback to fire as soon as this has loaded.\\n * @final\\n */\\n goog.Dependency.prototype.onLoad = function(callback) {\\n if (this.loaded_) {\\n callback();\\n } else {\\n this.loadCallbacks_.push(callback);\\n }\\n };\\n\\n\\n /**\\n * Marks this dependency as loaded and fires any callbacks registered with\\n * onLoad.\\n * @final\\n */\\n goog.Dependency.prototype.loaded = function() {\\n this.loaded_ = true;\\n var callbacks = this.loadCallbacks_;\\n this.loadCallbacks_ = [];\\n for (var i = 0; i < callbacks.length; i++) {\\n callbacks[i]();\\n }\\n };\\n\\n\\n /**\\n * Whether or not document.written / appended script tags should be deferred.\\n *\\n * @private {boolean}\\n */\\n goog.Dependency.defer_ = false;\\n\\n\\n /**\\n * Map of script ready / state change callbacks. Old IE cannot handle putting\\n * these properties on goog.global.\\n *\\n * @private @const {!Object<string, function(?):undefined>}\\n */\\n goog.Dependency.callbackMap_ = {};\\n\\n\\n /**\\n * @param {function(...?):?} callback\\n * @return {string}\\n * @private\\n */\\n goog.Dependency.registerCallback_ = function(callback) {\\n var key = Math.random().toString(32);\\n goog.Dependency.callbackMap_[key] = callback;\\n return key;\\n };\\n\\n\\n /**\\n * @param {string} key\\n * @private\\n */\\n goog.Dependency.unregisterCallback_ = function(key) {\\n delete goog.Dependency.callbackMap_[key];\\n };\\n\\n\\n /**\\n * @param {string} key\\n * @param {...?} var_args\\n * @private\\n * @suppress {unusedPrivateMembers}\\n */\\n goog.Dependency.callback_ = function(key, var_args) {\\n if (key in goog.Dependency.callbackMap_) {\\n var callback = goog.Dependency.callbackMap_[key];\\n var args = [];\\n for (var i = 1; i < arguments.length; i++) {\\n args.push(arguments[i]);\\n }\\n callback.apply(undefined, args);\\n } else {\\n var errorMessage = 'Callback key ' + key +\\n ' does not exist (was base.js loaded more than once?).';\\n throw Error(errorMessage);\\n }\\n };\\n\\n\\n /**\\n * Starts loading this dependency. This dependency can pause loading if it\\n * needs to and resume it later via the controller interface.\\n *\\n * When this is loaded it should call controller.loaded(). Note that this will\\n * end up calling the loaded method of this dependency; there is no need to\\n * call it explicitly.\\n *\\n * @param {!goog.LoadController} controller\\n */\\n goog.Dependency.prototype.load = function(controller) {\\n if (goog.global.CLOSURE_IMPORT_SCRIPT) {\\n if (goog.global.CLOSURE_IMPORT_SCRIPT(this.path)) {\\n controller.loaded();\\n } else {\\n controller.pause();\\n }\\n return;\\n }\\n\\n if (!goog.inHtmlDocument_()) {\\n goog.logToConsole_(\\n 'Cannot use default debug loader outside of HTML documents.');\\n if (this.relativePath == 'deps.js') {\\n // Some old code is relying on base.js auto loading deps.js failing with\\n // no error before later setting CLOSURE_IMPORT_SCRIPT.\\n // CLOSURE_IMPORT_SCRIPT should be set *before* base.js is loaded, or\\n // CLOSURE_NO_DEPS set to true.\\n goog.logToConsole_(\\n 'Consider setting CLOSURE_IMPORT_SCRIPT before loading base.js, ' +\\n 'or setting CLOSURE_NO_DEPS to true.');\\n controller.loaded();\\n } else {\\n controller.pause();\\n }\\n return;\\n }\\n\\n /** @type {!HTMLDocument} */\\n var doc = goog.global.document;\\n\\n // If the user tries to require a new symbol after document load,\\n // something has gone terribly wrong. Doing a document.write would\\n // wipe out the page. This does not apply to the CSP-compliant method\\n // of writing script tags.\\n if (doc.readyState == 'complete' &&\\n !goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING) {\\n // Certain test frameworks load base.js multiple times, which tries\\n // to write deps.js each time. If that happens, just fail silently.\\n // These frameworks wipe the page between each load of base.js, so this\\n // is OK.\\n var isDeps = /\\\\bdeps.js$/.test(this.path);\\n if (isDeps) {\\n controller.loaded();\\n return;\\n } else {\\n throw Error('Cannot write \\\"' + this.path + '\\\" after document load');\\n }\\n }\\n\\n var nonce = goog.getScriptNonce_();\\n if (!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING &&\\n goog.isDocumentLoading_()) {\\n var key;\\n var callback = function(script) {\\n if (script.readyState && script.readyState != 'complete') {\\n script.onload = callback;\\n return;\\n }\\n goog.Dependency.unregisterCallback_(key);\\n controller.loaded();\\n };\\n key = goog.Dependency.registerCallback_(callback);\\n\\n var defer = goog.Dependency.defer_ ? ' defer' : '';\\n var nonceAttr = nonce ? ' nonce=\\\"' + nonce + '\\\"' : '';\\n var script = '<script src=\\\"' + this.path + '\\\"' + nonceAttr + defer +\\n ' id=\\\"script-' + key + '\\\"><\\\\/script>';\\n\\n script += '<script' + nonceAttr + '>';\\n\\n if (goog.Dependency.defer_) {\\n script += 'document.getElementById(\\\\'script-' + key +\\n '\\\\').onload = function() {\\\\n' +\\n ' goog.Dependency.callback_(\\\\'' + key + '\\\\', this);\\\\n' +\\n '};\\\\n';\\n } else {\\n script += 'goog.Dependency.callback_(\\\\'' + key +\\n '\\\\', document.getElementById(\\\\'script-' + key + '\\\\'));';\\n }\\n\\n script += '<\\\\/script>';\\n\\n doc.write(\\n goog.TRUSTED_TYPES_POLICY_ ?\\n goog.TRUSTED_TYPES_POLICY_.createHTML(script) :\\n script);\\n } else {\\n var scriptEl =\\n /** @type {!HTMLScriptElement} */ (doc.createElement('script'));\\n scriptEl.defer = goog.Dependency.defer_;\\n scriptEl.async = false;\\n\\n // If CSP nonces are used, propagate them to dynamically created scripts.\\n // This is necessary to allow nonce-based CSPs without 'strict-dynamic'.\\n if (nonce) {\\n scriptEl.nonce = nonce;\\n }\\n\\n scriptEl.onload = function() {\\n scriptEl.onload = null;\\n controller.loaded();\\n };\\n\\n scriptEl.src = goog.TRUSTED_TYPES_POLICY_ ?\\n goog.TRUSTED_TYPES_POLICY_.createScriptURL(this.path) :\\n this.path;\\n doc.head.appendChild(scriptEl);\\n }\\n };\\n\\n\\n /**\\n * @param {string} path Absolute path of this script.\\n * @param {string} relativePath Path of this script relative to goog.basePath.\\n * @param {!Array<string>} provides Should be an empty array.\\n * TODO(johnplaisted) add support for adding closure namespaces to ES6\\n * modules for interop purposes.\\n * @param {!Array<string>} requires goog symbols or relative paths to Closure\\n * this depends on.\\n * @param {!Object<string, string>} loadFlags\\n * @struct @constructor\\n * @extends {goog.Dependency}\\n */\\n goog.Es6ModuleDependency = function(\\n path, relativePath, provides, requires, loadFlags) {\\n goog.Es6ModuleDependency.base(\\n this, 'constructor', path, relativePath, provides, requires, loadFlags);\\n };\\n goog.inherits(goog.Es6ModuleDependency, goog.Dependency);\\n\\n\\n /**\\n * @override\\n * @param {!goog.LoadController} controller\\n */\\n goog.Es6ModuleDependency.prototype.load = function(controller) {\\n if (goog.global.CLOSURE_IMPORT_SCRIPT) {\\n if (goog.global.CLOSURE_IMPORT_SCRIPT(this.path)) {\\n controller.loaded();\\n } else {\\n controller.pause();\\n }\\n return;\\n }\\n\\n if (!goog.inHtmlDocument_()) {\\n goog.logToConsole_(\\n 'Cannot use default debug loader outside of HTML documents.');\\n controller.pause();\\n return;\\n }\\n\\n /** @type {!HTMLDocument} */\\n var doc = goog.global.document;\\n\\n var dep = this;\\n\\n // TODO(johnplaisted): Does document.writing really speed up anything? Any\\n // difference between this and just waiting for interactive mode and then\\n // appending?\\n function write(src, contents) {\\n var nonceAttr = '';\\n var nonce = goog.getScriptNonce_();\\n if (nonce) {\\n nonceAttr = ' nonce=\\\"' + nonce + '\\\"';\\n }\\n\\n if (contents) {\\n var script = '<script type=\\\"module\\\" crossorigin' + nonceAttr + '>' +\\n contents + '</' +\\n 'script>';\\n doc.write(\\n goog.TRUSTED_TYPES_POLICY_ ?\\n goog.TRUSTED_TYPES_POLICY_.createHTML(script) :\\n script);\\n } else {\\n var script = '<script type=\\\"module\\\" crossorigin src=\\\"' + src + '\\\"' +\\n nonceAttr + '></' +\\n 'script>';\\n doc.write(\\n goog.TRUSTED_TYPES_POLICY_ ?\\n goog.TRUSTED_TYPES_POLICY_.createHTML(script) :\\n script);\\n }\\n }\\n\\n function append(src, contents) {\\n var scriptEl =\\n /** @type {!HTMLScriptElement} */ (doc.createElement('script'));\\n scriptEl.defer = true;\\n scriptEl.async = false;\\n scriptEl.type = 'module';\\n scriptEl.setAttribute('crossorigin', true);\\n\\n // If CSP nonces are used, propagate them to dynamically created scripts.\\n // This is necessary to allow nonce-based CSPs without 'strict-dynamic'.\\n var nonce = goog.getScriptNonce_();\\n if (nonce) {\\n scriptEl.nonce = nonce;\\n }\\n\\n if (contents) {\\n scriptEl.text = goog.TRUSTED_TYPES_POLICY_ ?\\n goog.TRUSTED_TYPES_POLICY_.createScript(contents) :\\n contents;\\n } else {\\n scriptEl.src = goog.TRUSTED_TYPES_POLICY_ ?\\n goog.TRUSTED_TYPES_POLICY_.createScriptURL(src) :\\n src;\\n }\\n\\n doc.head.appendChild(scriptEl);\\n }\\n\\n var create;\\n\\n if (goog.isDocumentLoading_()) {\\n create = write;\\n // We can ONLY call document.write if we are guaranteed that any\\n // non-module script tags document.written after this are deferred.\\n // Small optimization, in theory document.writing is faster.\\n goog.Dependency.defer_ = true;\\n } else {\\n create = append;\\n }\\n\\n // Write 4 separate tags here:\\n // 1) Sets the module state at the correct time (just before execution).\\n // 2) A src node for this, which just hopefully lets the browser load it a\\n // little early (no need to parse #3).\\n // 3) Import the module and register it.\\n // 4) Clear the module state at the correct time. Guaranteed to run even\\n // if there is an error in the module (#3 will not run if there is an\\n // error in the module).\\n var beforeKey = goog.Dependency.registerCallback_(function() {\\n goog.Dependency.unregisterCallback_(beforeKey);\\n controller.setModuleState(goog.ModuleType.ES6);\\n });\\n create(undefined, 'goog.Dependency.callback_(\\\"' + beforeKey + '\\\")');\\n\\n // TODO(johnplaisted): Does this really speed up anything?\\n create(this.path, undefined);\\n\\n var registerKey = goog.Dependency.registerCallback_(function(exports) {\\n goog.Dependency.unregisterCallback_(registerKey);\\n controller.registerEs6ModuleExports(\\n dep.path, exports, goog.moduleLoaderState_.moduleName);\\n });\\n create(\\n undefined,\\n 'import * as m from \\\"' + this.path + '\\\"; goog.Dependency.callback_(\\\"' +\\n registerKey + '\\\", m)');\\n\\n var afterKey = goog.Dependency.registerCallback_(function() {\\n goog.Dependency.unregisterCallback_(afterKey);\\n controller.clearModuleState();\\n controller.loaded();\\n });\\n create(undefined, 'goog.Dependency.callback_(\\\"' + afterKey + '\\\")');\\n };\\n\\n\\n /**\\n * Superclass of any dependency that needs to be loaded into memory,\\n * transformed, and then eval'd (goog.modules and transpiled files).\\n *\\n * @param {string} path Absolute path of this script.\\n * @param {string} relativePath Path of this script relative to goog.basePath.\\n * @param {!Array<string>} provides goog.provided or goog.module symbols\\n * in this file.\\n * @param {!Array<string>} requires goog symbols or relative paths to Closure\\n * this depends on.\\n * @param {!Object<string, string>} loadFlags\\n * @struct @constructor @abstract\\n * @extends {goog.Dependency}\\n */\\n goog.TransformedDependency = function(\\n path, relativePath, provides, requires, loadFlags) {\\n goog.TransformedDependency.base(\\n this, 'constructor', path, relativePath, provides, requires, loadFlags);\\n /** @private {?string} */\\n this.contents_ = null;\\n\\n /**\\n * Whether to lazily make the synchronous XHR (when goog.require'd) or make\\n * the synchronous XHR when initially loading. On FireFox 61 there is a bug\\n * where an ES6 module cannot make a synchronous XHR (rather, it can, but if\\n * it does then no other ES6 modules will load after).\\n *\\n * tl;dr we lazy load due to bugs on older browsers and eager load due to\\n * bugs on newer ones.\\n *\\n * https://bugzilla.mozilla.org/show_bug.cgi?id=1477090\\n *\\n * @private @const {boolean}\\n */\\n this.lazyFetch_ = !goog.inHtmlDocument_() ||\\n !('noModule' in goog.global.document.createElement('script'));\\n };\\n goog.inherits(goog.TransformedDependency, goog.Dependency);\\n\\n\\n /**\\n * @override\\n * @param {!goog.LoadController} controller\\n */\\n goog.TransformedDependency.prototype.load = function(controller) {\\n var dep = this;\\n\\n function fetch() {\\n dep.contents_ = goog.loadFileSync_(dep.path);\\n\\n if (dep.contents_) {\\n dep.contents_ = dep.transform(dep.contents_);\\n if (dep.contents_) {\\n dep.contents_ += '\\\\n//# sourceURL=' + dep.path;\\n }\\n }\\n }\\n\\n if (goog.global.CLOSURE_IMPORT_SCRIPT) {\\n fetch();\\n if (this.contents_ &&\\n goog.global.CLOSURE_IMPORT_SCRIPT('', this.contents_)) {\\n this.contents_ = null;\\n controller.loaded();\\n } else {\\n controller.pause();\\n }\\n return;\\n }\\n\\n\\n var isEs6 = this.loadFlags['module'] == goog.ModuleType.ES6;\\n\\n if (!this.lazyFetch_) {\\n fetch();\\n }\\n\\n function load() {\\n if (dep.lazyFetch_) {\\n fetch();\\n }\\n\\n if (!dep.contents_) {\\n // loadFileSync_ or transform are responsible. Assume they logged an\\n // error.\\n return;\\n }\\n\\n if (isEs6) {\\n controller.setModuleState(goog.ModuleType.ES6);\\n }\\n\\n var namespace;\\n\\n try {\\n var contents = dep.contents_;\\n dep.contents_ = null;\\n goog.globalEval(goog.CLOSURE_EVAL_PREFILTER_.createScript(contents));\\n if (isEs6) {\\n namespace = goog.moduleLoaderState_.moduleName;\\n }\\n } finally {\\n if (isEs6) {\\n controller.clearModuleState();\\n }\\n }\\n\\n if (isEs6) {\\n // Due to circular dependencies this may not be available for require\\n // right now.\\n goog.global['$jscomp']['require']['ensure'](\\n [dep.getPathName()], function() {\\n controller.registerEs6ModuleExports(\\n dep.path,\\n goog.global['$jscomp']['require'](dep.getPathName()),\\n namespace);\\n });\\n }\\n\\n controller.loaded();\\n }\\n\\n // Do not fetch now; in FireFox 47 the synchronous XHR doesn't block all\\n // events. If we fetched now and then document.write'd the contents the\\n // document.write would be an eval and would execute too soon! Instead write\\n // a script tag to fetch and eval synchronously at the correct time.\\n function fetchInOwnScriptThenLoad() {\\n /** @type {!HTMLDocument} */\\n var doc = goog.global.document;\\n\\n var key = goog.Dependency.registerCallback_(function() {\\n goog.Dependency.unregisterCallback_(key);\\n load();\\n });\\n\\n var nonce = goog.getScriptNonce_();\\n var nonceAttr = nonce ? ' nonce=\\\"' + nonce + '\\\"' : '';\\n var script = '<script' + nonceAttr + '>' +\\n goog.protectScriptTag_('goog.Dependency.callback_(\\\"' + key + '\\\");') +\\n '</' +\\n 'script>';\\n doc.write(\\n goog.TRUSTED_TYPES_POLICY_ ?\\n goog.TRUSTED_TYPES_POLICY_.createHTML(script) :\\n script);\\n }\\n\\n // If one thing is pending it is this.\\n var anythingElsePending = controller.pending().length > 1;\\n\\n // Additionally if we are meant to defer scripts but the page is still\\n // loading (e.g. an ES6 module is loading) then also defer. Or if we are\\n // meant to defer and anything else is pending then defer (those may be\\n // scripts that did not need transformation and are just script tags with\\n // defer set to true, and we need to evaluate after that deferred script).\\n var needsAsyncLoading = goog.Dependency.defer_ &&\\n (anythingElsePending || goog.isDocumentLoading_());\\n\\n if (needsAsyncLoading) {\\n // Note that we only defer when we have to rather than 100% of the time.\\n // Always defering would work, but then in theory the order of\\n // goog.require calls would then matter. We want to enforce that most of\\n // the time the order of the require calls does not matter.\\n controller.defer(function() {\\n load();\\n });\\n return;\\n }\\n // TODO(johnplaisted): Externs are missing onreadystatechange for\\n // HTMLDocument.\\n /** @type {?} */\\n var doc = goog.global.document;\\n\\n var isInternetExplorerOrEdge = goog.inHtmlDocument_() &&\\n ('ActiveXObject' in goog.global || goog.isEdge_());\\n\\n // Don't delay in any version of IE or pre-Chromium Edge. There's a bug\\n // around this that will cause out of order script execution. This means\\n // that on older IE ES6 modules will load too early (while the document is\\n // still loading + the dom is not available). The other option is to load\\n // too late (when the document is complete and the onload even will never\\n // fire). This seems to be the lesser of two evils as scripts already act\\n // like the former.\\n if (isEs6 && goog.inHtmlDocument_() && goog.isDocumentLoading_() &&\\n !isInternetExplorerOrEdge) {\\n goog.Dependency.defer_ = true;\\n // Transpiled ES6 modules still need to load like regular ES6 modules,\\n // aka only after the document is interactive.\\n controller.pause();\\n var oldCallback = doc.onreadystatechange;\\n doc.onreadystatechange = function() {\\n if (doc.readyState == 'interactive') {\\n doc.onreadystatechange = oldCallback;\\n load();\\n controller.resume();\\n }\\n if (typeof oldCallback === 'function') {\\n oldCallback.apply(undefined, arguments);\\n }\\n };\\n } else {\\n // Always eval on old IE.\\n if (!goog.inHtmlDocument_() || !goog.isDocumentLoading_()) {\\n load();\\n } else {\\n fetchInOwnScriptThenLoad();\\n }\\n }\\n };\\n\\n\\n /**\\n * @param {string} contents\\n * @return {string}\\n * @abstract\\n */\\n goog.TransformedDependency.prototype.transform = function(contents) {};\\n\\n\\n /**\\n * An ES6 module dependency that was transpiled to a jscomp module outside\\n * of the debug loader, e.g. server side.\\n *\\n * @param {string} path Absolute path of this script.\\n * @param {string} relativePath Path of this script relative to goog.basePath.\\n * @param {!Array<string>} provides goog.provided or goog.module symbols\\n * in this file.\\n * @param {!Array<string>} requires goog symbols or relative paths to Closure\\n * this depends on.\\n * @param {!Object<string, string>} loadFlags\\n * @struct @constructor\\n * @extends {goog.TransformedDependency}\\n */\\n goog.PreTranspiledEs6ModuleDependency = function(\\n path, relativePath, provides, requires, loadFlags) {\\n goog.PreTranspiledEs6ModuleDependency.base(\\n this, 'constructor', path, relativePath, provides, requires, loadFlags);\\n };\\n goog.inherits(\\n goog.PreTranspiledEs6ModuleDependency, goog.TransformedDependency);\\n\\n\\n /**\\n * @override\\n * @param {string} contents\\n * @return {string}\\n */\\n goog.PreTranspiledEs6ModuleDependency.prototype.transform = function(\\n contents) {\\n return contents;\\n };\\n\\n\\n /**\\n * A goog.module, transpiled or not. Will always perform some minimal\\n * transformation even when not transpiled to wrap in a goog.loadModule\\n * statement.\\n *\\n * @param {string} path Absolute path of this script.\\n * @param {string} relativePath Path of this script relative to goog.basePath.\\n * @param {!Array<string>} provides goog.provided or goog.module symbols\\n * in this file.\\n * @param {!Array<string>} requires goog symbols or relative paths to Closure\\n * this depends on.\\n * @param {!Object<string, string>} loadFlags\\n * @struct @constructor\\n * @extends {goog.TransformedDependency}\\n */\\n goog.GoogModuleDependency = function(\\n path, relativePath, provides, requires, loadFlags) {\\n goog.GoogModuleDependency.base(\\n this, 'constructor', path, relativePath, provides, requires, loadFlags);\\n };\\n goog.inherits(goog.GoogModuleDependency, goog.TransformedDependency);\\n\\n\\n /**\\n * @override\\n * @param {string} contents\\n * @return {string}\\n */\\n goog.GoogModuleDependency.prototype.transform = function(contents) {\\n if (!goog.LOAD_MODULE_USING_EVAL || goog.global.JSON === undefined) {\\n return '' +\\n 'goog.loadModule(function(exports) {' +\\n '\\\"use strict\\\";' + contents +\\n '\\\\n' + // terminate any trailing single line comment.\\n ';return exports' +\\n '});' +\\n '\\\\n//# sourceURL=' + this.path + '\\\\n';\\n } else {\\n return '' +\\n 'goog.loadModule(' +\\n goog.global.JSON.stringify(\\n contents + '\\\\n//# sourceURL=' + this.path + '\\\\n') +\\n ');';\\n }\\n };\\n\\n\\n /**\\n * @param {string} relPath\\n * @param {!Array<string>|undefined} provides\\n * @param {!Array<string>} requires\\n * @param {boolean|!Object<string>=} opt_loadFlags\\n * @see goog.addDependency\\n */\\n goog.DebugLoader_.prototype.addDependency = function(\\n relPath, provides, requires, opt_loadFlags) {\\n provides = provides || [];\\n relPath = relPath.replace(/\\\\\\\\/g, '/');\\n var path = goog.normalizePath_(goog.basePath + relPath);\\n if (!opt_loadFlags || typeof opt_loadFlags === 'boolean') {\\n opt_loadFlags = opt_loadFlags ? {'module': goog.ModuleType.GOOG} : {};\\n }\\n var dep = this.factory_.createDependency(\\n path, relPath, provides, requires, opt_loadFlags);\\n this.dependencies_[path] = dep;\\n for (var i = 0; i < provides.length; i++) {\\n this.idToPath_[provides[i]] = path;\\n }\\n this.idToPath_[relPath] = path;\\n };\\n\\n\\n /**\\n * Creates goog.Dependency instances for the debug loader to load.\\n *\\n * Should be overridden to have the debug loader use custom subclasses of\\n * goog.Dependency.\\n *\\n * @struct @constructor\\n */\\n goog.DependencyFactory = function() {};\\n\\n\\n /**\\n * @param {string} path Absolute path of the file.\\n * @param {string} relativePath Path relative to closure\\u2019s base.js.\\n * @param {!Array<string>} provides Array of provided goog.provide/module ids.\\n * @param {!Array<string>} requires Array of required goog.provide/module /\\n * relative ES6 module paths.\\n * @param {!Object<string, string>} loadFlags\\n * @return {!goog.Dependency}\\n */\\n goog.DependencyFactory.prototype.createDependency = function(\\n path, relativePath, provides, requires, loadFlags) {\\n\\n if (loadFlags['module'] == goog.ModuleType.GOOG) {\\n return new goog.GoogModuleDependency(\\n path, relativePath, provides, requires, loadFlags);\\n } else {\\n if (loadFlags['module'] == goog.ModuleType.ES6) {\\n if (goog.ASSUME_ES_MODULES_TRANSPILED) {\\n return new goog.PreTranspiledEs6ModuleDependency(\\n path, relativePath, provides, requires, loadFlags);\\n } else {\\n return new goog.Es6ModuleDependency(\\n path, relativePath, provides, requires, loadFlags);\\n }\\n } else {\\n return new goog.Dependency(\\n path, relativePath, provides, requires, loadFlags);\\n }\\n }\\n };\\n\\n\\n /** @private @const */\\n goog.debugLoader_ = new goog.DebugLoader_();\\n\\n\\n /**\\n * Loads the Closure Dependency file.\\n *\\n * Exposed a public function so CLOSURE_NO_DEPS can be set to false, base\\n * loaded, setDependencyFactory called, and then this called. i.e. allows\\n * custom loading of the deps file.\\n */\\n goog.loadClosureDeps = function() {\\n goog.debugLoader_.loadClosureDeps();\\n };\\n\\n\\n /**\\n * Sets the dependency factory, which can be used to create custom\\n * goog.Dependency implementations to control how dependencies are loaded.\\n *\\n * Note: if you wish to call this function and provide your own implemnetation\\n * it is a wise idea to set CLOSURE_NO_DEPS to true, otherwise the dependency\\n * file and all of its goog.addDependency calls will use the default factory.\\n * You can call goog.loadClosureDeps to load the Closure dependency file\\n * later, after your factory is injected.\\n *\\n * @param {!goog.DependencyFactory} factory\\n */\\n goog.setDependencyFactory = function(factory) {\\n goog.debugLoader_.setDependencyFactory(factory);\\n };\\n\\n\\n /**\\n * Trusted Types policy for the debug loader.\\n * @private @const {?TrustedTypePolicy}\\n */\\n goog.TRUSTED_TYPES_POLICY_ = goog.TRUSTED_TYPES_POLICY_NAME ?\\n goog.createTrustedTypesPolicy(goog.TRUSTED_TYPES_POLICY_NAME + '#base') :\\n null;\\n\\n if (!goog.global.CLOSURE_NO_DEPS) {\\n goog.debugLoader_.loadClosureDeps();\\n }\\n\\n\\n /**\\n * Bootstraps the given namespaces and calls the callback once they are\\n * available either via goog.require. This is a replacement for using\\n * `goog.require` to bootstrap Closure JavaScript. Previously a `goog.require`\\n * in an HTML file would guarantee that the require'd namespace was available\\n * in the next immediate script tag. With ES6 modules this no longer a\\n * guarantee.\\n *\\n * @param {!Array<string>} namespaces\\n * @param {function(): ?} callback Function to call once all the namespaces\\n * have loaded. Always called asynchronously.\\n */\\n goog.bootstrap = function(namespaces, callback) {\\n goog.debugLoader_.bootstrap(namespaces, callback);\\n };\\n}\\n\\n\\nif (!COMPILED) {\\n var isChrome87 = false;\\n // Cannot run check for Chrome <87 bug in case of strict CSP environments.\\n // TODO(user): Remove once Chrome <87 bug is no longer a problem.\\n try {\\n isChrome87 = eval(goog.global.trustedTypes.emptyScript) !==\\n goog.global.trustedTypes.emptyScript;\\n } catch (err) {\\n }\\n\\n /**\\n * Trusted Types for running dev servers.\\n *\\n * @private @const\\n */\\n goog.CLOSURE_EVAL_PREFILTER_ =\\n // Detect Chrome <87 bug with TT and eval.\\n goog.global.trustedTypes && isChrome87 &&\\n goog.createTrustedTypesPolicy('goog#base#devonly#eval') ||\\n {createScript: goog.identity_};\\n}\\n\"],\n\"names\":[\"COMPILED\",\"goog\",\"global\",\"self\",\"CLOSURE_UNCOMPILED_DEFINES\",\"CLOSURE_DEFINES\",\"exportPath_\",\"goog.exportPath_\",\"name\",\"object\",\"overwriteImplicit\",\"objectToExportTo\",\"parts\",\"split\",\"cur\",\"execScript\",\"part\",\"length\",\"shift\",\"undefined\",\"isObject\",\"prop\",\"hasOwnProperty\",\"Object\",\"prototype\",\"define\",\"goog.define\",\"defaultValue\",\"value\",\"uncompiledDefines\",\"defines\",\"nodeType\",\"call\",\"FEATURESET_YEAR\",\"DEBUG\",\"LOCALE\",\"TRUSTED_SITE\",\"DISALLOW_TEST_ONLY_CODE\",\"ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING\",\"provide\",\"goog.provide\",\"isInModuleLoader_\",\"Error\",\"isProvided_\",\"constructNamespace_\",\"goog.constructNamespace_\",\"implicitNamespaces_\",\"namespace\",\"substring\",\"lastIndexOf\",\"getObjectByName\",\"NONCE_PATTERN_\",\"getScriptNonce_\",\"goog.getScriptNonce_\",\"opt_window\",\"doc\",\"document\",\"script\",\"querySelector\",\"nonce\",\"getAttribute\",\"test\",\"VALID_MODULE_RE_\",\"module\",\"goog.module\",\"search\",\"isInGoogModuleLoader_\",\"moduleLoaderState_\",\"moduleName\",\"get\",\"goog.module.get\",\"getInternal_\",\"goog.module.getInternal_\",\"loadedModules_\",\"exports\",\"ns\",\"ModuleType\",\"ES6\",\"GOOG\",\"goog.isInModuleLoader_\",\"isInEs6ModuleLoader_\",\"goog.isInGoogModuleLoader_\",\"type\",\"goog.isInEs6ModuleLoader_\",\"inLoader\",\"jscomp\",\"getCurrentModulePath\",\"declareLegacyNamespace\",\"goog.module.declareLegacyNamespace\",\"declareModuleId\",\"goog.declareModuleId\",\"require\",\"moduleId\",\"setTestOnly\",\"goog.setTestOnly\",\"opt_message\",\"forwardDeclare\",\"goog.forwardDeclare\",\"goog.isProvided_\",\"goog.getObjectByName\",\"opt_obj\",\"i\",\"addDependency\",\"goog.addDependency\",\"relPath\",\"provides\",\"requires\",\"opt_loadFlags\",\"DEPENDENCIES_ENABLED\",\"debugLoader_\",\"ENABLE_DEBUG_LOADER\",\"logToConsole_\",\"goog.logToConsole_\",\"msg\",\"console\",\"goog.require\",\"requested\",\"moduleLoaderState\",\"load_\",\"requireType\",\"goog.requireType\",\"basePath\",\"CLOSURE_BASE_PATH\",\"CLOSURE_NO_DEPS\",\"CLOSURE_IMPORT_SCRIPT\",\"abstractMethod\",\"goog.abstractMethod\",\"addSingletonGetter\",\"goog.addSingletonGetter\",\"ctor\",\"instance_\",\"getInstance\",\"ctor.getInstance\",\"instantiatedSingletons_\",\"LOAD_MODULE_USING_EVAL\",\"SEAL_MODULE_EXPORTS\",\"TRANSPILE\",\"ASSUME_ES_MODULES_TRANSPILED\",\"TRUSTED_TYPES_POLICY_NAME\",\"hasBadLetScoping\",\"loadModule\",\"goog.loadModule\",\"moduleDef\",\"previousState\",\"origExports\",\"loadModuleFromSource_\",\"isDefaultExport\",\"seal\",\"data\",\"eval\",\"CLOSURE_EVAL_PREFILTER_\",\"createScript\",\"arguments\",\"normalizePath_\",\"goog.normalizePath_\",\"path\",\"components\",\"splice\",\"join\",\"CLOSURE_LOAD_FILE_SYNC\",\"loadFileSync_\",\"goog.loadFileSync_\",\"src\",\"xhr\",\"open\",\"send\",\"status\",\"responseText\",\"err\",\"typeOf\",\"goog.typeOf\",\"s\",\"Array\",\"isArray\",\"isArrayLike\",\"goog.isArrayLike\",\"val\",\"isDateLike\",\"goog.isDateLike\",\"getFullYear\",\"goog.isObject\",\"getUid\",\"goog.getUid\",\"obj\",\"UID_PROPERTY_\",\"uidCounter_\",\"hasUid\",\"goog.hasUid\",\"removeUid\",\"goog.removeUid\",\"removeAttribute\",\"ex\",\"Math\",\"random\",\"cloneObject\",\"goog.cloneObject\",\"clone\",\"Map\",\"Set\",\"key\",\"bindNative_\",\"goog.bindNative_\",\"fn\",\"selfObj\",\"var_args\",\"apply\",\"bind\",\"bindJs_\",\"goog.bindJs_\",\"boundArgs\",\"slice\",\"newArgs\",\"unshift\",\"goog.bind\",\"Function\",\"toString\",\"indexOf\",\"partial\",\"goog.partial\",\"args\",\"push\",\"now\",\"goog.now\",\"Date\",\"globalEval\",\"goog.globalEval\",\"cssNameMapping_\",\"cssNameMappingStyle_\",\"CLOSURE_CSS_NAME_MAP_FN\",\"getCssName\",\"goog.getCssName\",\"className\",\"opt_modifier\",\"String\",\"charAt\",\"getMapping\",\"cssName\",\"renameByParts\",\"mapped\",\"rename\",\"a\",\"result\",\"setCssNameMapping\",\"goog.setCssNameMapping\",\"mapping\",\"opt_style\",\"CLOSURE_CSS_NAME_MAPPING\",\"GetMsgOptions\",\"goog.GetMsgOptions\",\"html\",\"unescapeHtmlEntities\",\"original_code\",\"example\",\"getMsg\",\"goog.getMsg\",\"str\",\"opt_values\",\"opt_options\",\"replace\",\"match\",\"getMsgWithFallback\",\"goog.getMsgWithFallback\",\"b\",\"exportSymbol\",\"goog.exportSymbol\",\"publicPath\",\"exportProperty\",\"goog.exportProperty\",\"publicName\",\"symbol\",\"inherits\",\"goog.inherits\",\"childCtor\",\"parentCtor\",\"tempCtor\",\"superClass_\",\"constructor\",\"base\",\"childCtor.base\",\"me\",\"methodName\",\"scope\",\"goog.scope\",\"defineClass\",\"goog.defineClass\",\"superClass\",\"def\",\"statics\",\"cls\",\"createSealingConstructor_\",\"applyProperties_\",\"ClassDescriptor\",\"SEAL_CLASS_INSTANCES\",\"goog.defineClass.createSealingConstructor_\",\"ctr\",\"wrappedCtr\",\"instance\",\"OBJECT_PROTOTYPE_FIELDS_\",\"goog.defineClass.applyProperties_\",\"target\",\"source\",\"identity_\",\"goog.identity_\",\"createTrustedTypesPolicy\",\"goog.createTrustedTypesPolicy\",\"policy\",\"policyFactory\",\"trustedTypes\",\"createPolicy\",\"createHTML\",\"createScriptURL\",\"e\",\"message\",\"isEdge_\",\"goog.isEdge_\",\"userAgent\",\"navigator\",\"edgeRe\",\"inHtmlDocument_\",\"goog.inHtmlDocument_\",\"isDocumentLoading_\",\"goog.isDocumentLoading_\",\"attachEvent\",\"readyState\",\"findBasePath_\",\"goog.findBasePath_\",\"currentScript\",\"scripts\",\"getElementsByTagName\",\"qmark\",\"l\",\"protectScriptTag_\",\"goog.protectScriptTag_\",\"DebugLoader_\",\"goog.DebugLoader_\",\"dependencies_\",\"idToPath_\",\"written_\",\"loadingDeps_\",\"depsToLoad_\",\"paused_\",\"factory_\",\"DependencyFactory\",\"deferredCallbacks_\",\"deferredQueue_\",\"bootstrap\",\"goog.DebugLoader_.prototype.bootstrap\",\"namespaces\",\"callback\",\"cb\",\"resolve\",\"setTimeout\",\"deps\",\"getPathFromDeps_\",\"loaded\",\"onLoad\",\"loadClosureDeps\",\"goog.DebugLoader_.prototype.loadClosureDeps\",\"createDependency\",\"loadDeps_\",\"goog.DebugLoader_.prototype.requested\",\"absPathOrId\",\"opt_force\",\"areDepsLoaded_\",\"setDependencyFactory\",\"goog.DebugLoader_.prototype.setDependencyFactory\",\"factory\",\"goog.DebugLoader_.prototype.load_\",\"errorMessage\",\"loader\",\"visit\",\"dep\",\"wasLoading\",\"concat\",\"goog.DebugLoader_.prototype.loadDeps_\",\"paused\",\"loadCallDone\",\"loading_\",\"controller\",\"pause\",\"resume\",\"resume_\",\"loaded_\",\"pending\",\"setModuleState\",\"registerEs6ModuleExports\",\"opt_closureNamespace\",\"registerGoogModuleExports\",\"clearModuleState\",\"defer\",\"defer_\",\"areDepsLoaded\",\"load\",\"pause_\",\"goog.DebugLoader_.prototype.pause_\",\"goog.DebugLoader_.prototype.resume_\",\"goog.DebugLoader_.prototype.loading_\",\"goog.DebugLoader_.prototype.loaded_\",\"goog.DebugLoader_.prototype.areDepsLoaded_\",\"pathsOrIds\",\"goog.DebugLoader_.prototype.getPathFromDeps_\",\"goog.DebugLoader_.prototype.defer_\",\"dependency\",\"LoadController\",\"goog.LoadController\",\"goog.LoadController.prototype.pause\",\"goog.LoadController.prototype.resume\",\"goog.LoadController.prototype.loaded\",\"goog.LoadController.prototype.pending\",\"goog.LoadController.prototype.registerEs6ModuleExports\",\"goog.LoadController.prototype.setModuleState\",\"goog.LoadController.prototype.clearModuleState\",\"goog.LoadController.prototype.defer\",\"goog.LoadController.prototype.areDepsLoaded\",\"Dependency\",\"goog.Dependency\",\"relativePath\",\"loadFlags\",\"loadCallbacks_\",\"getPathName\",\"goog.Dependency.prototype.getPathName\",\"pathName\",\"protocolIndex\",\"slashIndex\",\"goog.Dependency.prototype.onLoad\",\"goog.Dependency.prototype.loaded\",\"callbacks\",\"callbackMap_\",\"registerCallback_\",\"goog.Dependency.registerCallback_\",\"unregisterCallback_\",\"goog.Dependency.unregisterCallback_\",\"callback_\",\"goog.Dependency.callback_\",\"goog.Dependency.prototype.load\",\"isDeps\",\"onload\",\"nonceAttr\",\"write\",\"TRUSTED_TYPES_POLICY_\",\"scriptEl\",\"createElement\",\"async\",\"scriptEl.onload\",\"head\",\"appendChild\",\"Es6ModuleDependency\",\"goog.Es6ModuleDependency\",\"goog.Es6ModuleDependency.prototype.load\",\"contents\",\"append\",\"setAttribute\",\"text\",\"create\",\"beforeKey\",\"registerKey\",\"afterKey\",\"TransformedDependency\",\"goog.TransformedDependency\",\"contents_\",\"lazyFetch_\",\"goog.TransformedDependency.prototype.load\",\"fetch\",\"transform\",\"isEs6\",\"fetchInOwnScriptThenLoad\",\"anythingElsePending\",\"needsAsyncLoading\",\"isInternetExplorerOrEdge\",\"oldCallback\",\"onreadystatechange\",\"doc.onreadystatechange\",\"goog.TransformedDependency.prototype.transform\",\"PreTranspiledEs6ModuleDependency\",\"goog.PreTranspiledEs6ModuleDependency\",\"goog.PreTranspiledEs6ModuleDependency.prototype.transform\",\"GoogModuleDependency\",\"goog.GoogModuleDependency\",\"goog.GoogModuleDependency.prototype.transform\",\"JSON\",\"stringify\",\"goog.DebugLoader_.prototype.addDependency\",\"goog.DependencyFactory\",\"goog.DependencyFactory.prototype.createDependency\",\"goog.loadClosureDeps\",\"goog.setDependencyFactory\",\"goog.bootstrap\",\"isChrome87\",\"emptyScript\"]\n}\n"] |