=} opt_values Maps place holder name to
value.\n * @param {{html: boolean}=} opt_options Options:\n * html:
Escape '<' in str to '<'. Used by Closure Templates where the\n *
generated code size and performance is critical which is why
{@link\n * goog.html.SafeHtmlFormatter} is not used. The value must
be literal true\n * or false.\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(/var x =
goog.getMsgWithFallback(MSG_A, MSG_B);\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 * \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 * \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}\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// 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 * Returns the most
recently added script element in the DOM.\n * @return {?Element}\n *
@private\n */\n goog.getLastScript_ = function() {\n var elem =
document.documentElement;\n while (elem.nodeName != 'SCRIPT'
&& elem.lastChild) {\n elem = elem.lastChild;\n }\n
return /** @type {?Element} */ (elem);\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.substr(l - 7, 7) ==
'base.js') {\n goog.basePath = src.substr(0, l - 7);\n
return;\n }\n }\n };\n\n goog.findBasePath_();\n\n /**
@struct @constructor @final */\n goog.Transpiler = function() {\n
/** @private {?Object} */\n
this.requiresTranspilation_ = null;\n /** @private {string} */\n
this.transpilationTarget_ = goog.TRANSPILE_TO_LANGUAGE;\n };\n /**\n
* Returns a newly created map from language mode string to a boolean\n
* indicating whether transpilation should be done for that mode as
well as\n * the highest level language that this environment
supports.\n *\n * Guaranteed invariant:\n * For any two modes, l1
and l2 where l2 is a newer mode than l1,\n * `map[l1] == true` implies
that `map[l2] == true`.\n *\n * Note this method is extracted and
used elsewhere, so it cannot rely on\n * anything external (it should
easily be able to be transformed into a\n * standalone, top level
function).\n *\n * @private\n * @return {{\n * target:
string,\n * map: !Object\n * }}\n */\n
goog.Transpiler.prototype.createRequiresTranspilation_ = function() {\n
var transpilationTarget = 'es3';\n var /** !Object
*/ requiresTranspilation = {'es3': false};\n var
transpilationRequiredForAllLaterModes = false;\n\n /**\n * Adds
an entry to requiresTranspliation for the given language mode.\n *\n
* IMPORTANT: Calls must be made in order from oldest to newest
language\n * mode.\n * @param {string} modeName\n * @param
{function(): boolean} isSupported Returns true if the JS engine\n *
supports the given mode.\n */\n function
addNewerLanguageTranspilationCheck(modeName, isSupported) {\n if
(transpilationRequiredForAllLaterModes) {\n
requiresTranspilation[modeName] = true;\n } else if (isSupported())
{\n transpilationTarget = modeName;\n
requiresTranspilation[modeName] = false;\n } else {\n
requiresTranspilation[modeName] = true;\n
transpilationRequiredForAllLaterModes = true;\n }\n }\n\n
/**\n * Does the given code evaluate without syntax errors and
return a truthy\n * result?\n */\n function /** boolean */
evalCheck(/** string */ code) {\n try {\n return
!!eval(code);\n } catch (ignored) {\n return false;\n
}\n }\n\n var userAgent = goog.global.navigator &&
goog.global.navigator.userAgent ?\n
goog.global.navigator.userAgent :\n '';\n\n // Identify
ES3-only browsers by their incorrect treatment of commas.\n
addNewerLanguageTranspilationCheck('es5', function() {\n return
evalCheck('[1,].length==1');\n });\n
addNewerLanguageTranspilationCheck('es6', function() {\n // Edge
has a non-deterministic (i.e., not reproducible) bug with ES6:\n //
https://github.com/Microsoft/ChakraCore/issues/1496.\n var re =
/Edge\\/(\\d+)(\\.\\d)*/i;\n var edgeUserAgent =
userAgent.match(re);\n if (edgeUserAgent) {\n // The
Reflect.construct test below is flaky on Edge. It can sometimes\n
// pass or fail on 40 15.15063, so just exit early for Edge and treat\n
// it as ES5. Until we're on a more up to date version just
always use\n // ES5. See
https://github.com/Microsoft/ChakraCore/issues/3217.\n return
false;\n }\n // Test es6: [FF50 (?), Edge 14 (?), Chrome 50]\n
// (a) default params (specifically shadowing locals),\n //
(b) destructuring, (c) block-scoped functions,\n // (d) for-of
(const), (e) new.target/Reflect.construct\n var es6fullTest =\n
'class X{constructor(){if(new.target!=String)throw 1;this.x=42}}'
+\n 'let q=Reflect.construct(X,[],String);if(q.x!=42||!(q
instanceof ' +\n 'String))throw 1;for(const a
of[2,3]){if(a==2)continue;function ' +\n 'f(z={a}){let
a=0;return z.a}{function f(){return 0;}}return f()' +\n
'==3}';\n\n return evalCheck('(()=>{\"use strict\";' +
es6fullTest + '})()');\n });\n // ** and **= are the only new
features in 'es7'\n addNewerLanguageTranspilationCheck('es7',
function() {\n return evalCheck('2 ** 2 == 4');\n });\n //
async functions are the only new features in 'es8'\n
addNewerLanguageTranspilationCheck('es8', function() {\n return
evalCheck('async () => 1, true');\n });\n
addNewerLanguageTranspilationCheck('es9', function() {\n return
evalCheck('({...rest} = {}), true');\n });\n
addNewerLanguageTranspilationCheck('es_next', function() {\n return
false; // assume it always need to transpile\n });\n return
{target: transpilationTarget, map: requiresTranspilation};\n };\n\n\n
/**\n * Determines whether the given language needs to be
transpiled.\n * @param {string} lang\n * @param {string|undefined}
module\n * @return {boolean}\n */\n
goog.Transpiler.prototype.needsTranspile = function(lang, module) {\n
if (goog.TRANSPILE == 'always') {\n return true;\n } else if
(goog.TRANSPILE == 'never') {\n return false;\n } else if
(!this.requiresTranspilation_) {\n var obj =
this.createRequiresTranspilation_();\n this.requiresTranspilation_ =
obj.map;\n this.transpilationTarget_ = this.transpilationTarget_
|| obj.target;\n }\n if (lang in this.requiresTranspilation_) {\n
if (this.requiresTranspilation_[lang]) {\n return true;\n
} else if (\n goog.inHtmlDocument_() && module ==
'es6' &&\n !('noModule' in
goog.global.document.createElement('script'))) {\n return true;\n
} else {\n return false;\n }\n } else {\n
throw new Error('Unknown language mode: ' + lang);\n }\n };\n\n\n
/**\n * Lazily retrieves the transpiler and applies it to the
source.\n * @param {string} code JS code.\n * @param {string} path
Path to the code.\n * @return {string} The transpiled code.\n */\n
goog.Transpiler.prototype.transpile = function(code, path) {\n //
TODO(johnplaisted): We should delete goog.transpile_ and just have
this\n // function. But there's some compile error atm where
goog.global is being\n // stripped incorrectly without this.\n
return goog.transpile_(code, path, this.transpilationTarget_);\n
};\n\n\n /** @private @final {!goog.Transpiler} */\n goog.transpiler_ =
new goog.Transpiler();\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} */\n this.dependencies_ = {};\n /** @private @const {!Object} */\n this.idToPath_ = {};\n /** @private @const {!Object} */\n this.written_ = {};\n /** @private @const {!Array} */\n this.loadingDeps_ = [];\n /** @private {!Array}
*/\n this.depsToLoad_ = [];\n /** @private {boolean} */\n
this.paused_ = false;\n /** @private {!goog.DependencyFactory} */\n
this.factory_ = new goog.DependencyFactory(goog.transpiler_);\n /**
@private @const {!Object} */\n this.deferredCallbacks_ = {};\n /** @private @const {!Array} */\n this.deferredQueue_ = [];\n };\n\n /**\n * @param {!Array}
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
false));\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\n
goog.logToConsole_(errorMessage);\n throw Error(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}
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}\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
transpiled non-goog.module files {@see goog.TranspiledDependency}.\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} provides goog.provided or goog.module symbols\n * in this file.\n * @param {!Array} requires goog symbols or relative paths to Closure\n * this depends on.\n * @param {!Object}
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}
*/\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}\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 allowInlineEventHandlers =
!nonce;\n var key =
goog.Dependency.registerCallback_(function(script) {\n if
(!goog.DebugLoader_.IS_OLD_IE_ || script.readyState == 'complete') {\n
goog.Dependency.unregisterCallback_(key);\n
controller.loaded();\n }\n });\n var eventName =\n
goog.DebugLoader_.IS_OLD_IE_ ? 'onreadystatechange' : 'onload';\n
var event = '';\n if (allowInlineEventHandlers) {\n
event = ' ' + eventName + '=\"goog.Dependency.callback_(\\'' + key +\n
'\\', this)\"';\n }\n\n var defer =
goog.Dependency.defer_ ? ' defer' : '';\n var nonceAttr = nonce ? '
nonce=\"' + nonce + '\"' : '';\n var script = '