=} opt_values Maps place holder name to value.
+ * @param {!goog.GetMsgOptions=} opt_options see `goog.GetMsgOptions`
+ * @return {string} message with placeholders filled.
+ */
+goog.getMsg = function(str, opt_values, opt_options) {
+ if (opt_options && opt_options.html) {
+ // Note that '&' is not replaced because the translation can contain HTML
+ // entities.
+ str = str.replace(/')
+ .replace(/'/g, '\'')
+ .replace(/"/g, '"')
+ .replace(/&/g, '&');
+ }
+ if (opt_values) {
+ str = str.replace(/\{\$([^}]+)}/g, function(match, key) {
+ return (opt_values != null && key in opt_values) ? opt_values[key] :
+ match;
+ });
+ }
+ return str;
+};
+
+
+/**
+ * Gets a localized message. If the message does not have a translation, gives a
+ * fallback message.
+ *
+ * This is useful when introducing a new message that has not yet been
+ * translated into all languages.
+ *
+ * This function is a compiler primitive. Must be used in the form:
+ * var x = goog.getMsgWithFallback(MSG_A, MSG_B);
+ * where MSG_A and MSG_B were initialized with goog.getMsg.
+ *
+ * @param {string} a The preferred message.
+ * @param {string} b The fallback message.
+ * @return {string} The best translated message.
+ */
+goog.getMsgWithFallback = function(a, b) {
+ return a;
+};
+
+
+/**
+ * Exposes an unobfuscated global namespace path for the given object.
+ * Note that fields of the exported object *will* be obfuscated, unless they are
+ * exported in turn via this function or goog.exportProperty.
+ *
+ * Also handy for making public items that are defined in anonymous closures.
+ *
+ * ex. goog.exportSymbol('public.path.Foo', Foo);
+ *
+ * ex. goog.exportSymbol('public.path.Foo.staticFunction', Foo.staticFunction);
+ * public.path.Foo.staticFunction();
+ *
+ * ex. goog.exportSymbol('public.path.Foo.prototype.myMethod',
+ * Foo.prototype.myMethod);
+ * new public.path.Foo().myMethod();
+ *
+ * @param {string} publicPath Unobfuscated name to export.
+ * @param {*} object Object the name should point to.
+ * @param {?Object=} objectToExportTo The object to add the path to; default
+ * is goog.global.
+ */
+goog.exportSymbol = function(publicPath, object, objectToExportTo) {
+ goog.exportPath_(
+ publicPath, object, /* overwriteImplicit= */ true, objectToExportTo);
+};
+
+
+/**
+ * Exports a property unobfuscated into the object's namespace.
+ * ex. goog.exportProperty(Foo, 'staticFunction', Foo.staticFunction);
+ * ex. goog.exportProperty(Foo.prototype, 'myMethod', Foo.prototype.myMethod);
+ * @param {Object} object Object whose static property is being exported.
+ * @param {string} publicName Unobfuscated name to export.
+ * @param {*} symbol Object the name should point to.
+ */
+goog.exportProperty = function(object, publicName, symbol) {
+ object[publicName] = symbol;
+};
+
+
+/**
+ * Inherit the prototype methods from one constructor into another.
+ *
+ * Usage:
+ *
+ * function ParentClass(a, b) { }
+ * ParentClass.prototype.foo = function(a) { };
+ *
+ * function ChildClass(a, b, c) {
+ * ChildClass.base(this, 'constructor', a, b);
+ * }
+ * goog.inherits(ChildClass, ParentClass);
+ *
+ * var child = new ChildClass('a', 'b', 'see');
+ * child.foo(); // This works.
+ *
+ *
+ * @param {!Function} childCtor Child class.
+ * @param {!Function} parentCtor Parent class.
+ * @suppress {strictMissingProperties} superClass_ and base is not defined on
+ * Function.
+ * @deprecated Use ECMAScript class syntax instead.
+ */
+goog.inherits = function(childCtor, parentCtor) {
+ /** @constructor */
+ function tempCtor() {}
+ tempCtor.prototype = parentCtor.prototype;
+ childCtor.superClass_ = parentCtor.prototype;
+ childCtor.prototype = new tempCtor();
+ /** @override */
+ childCtor.prototype.constructor = childCtor;
+
+ /**
+ * Calls superclass constructor/method.
+ *
+ * This function is only available if you use goog.inherits to
+ * express inheritance relationships between classes.
+ *
+ * NOTE: This is a replacement for goog.base and for superClass_
+ * property defined in childCtor.
+ *
+ * @param {!Object} me Should always be "this".
+ * @param {string} methodName The method name to call. Calling
+ * superclass constructor can be done with the special string
+ * 'constructor'.
+ * @param {...*} var_args The arguments to pass to superclass
+ * method/constructor.
+ * @return {*} The return value of the superclass method/constructor.
+ */
+ childCtor.base = function(me, methodName, var_args) {
+ // Copying using loop to avoid deop due to passing arguments object to
+ // function. This is faster in many JS engines as of late 2014.
+ var args = new Array(arguments.length - 2);
+ for (var i = 2; i < arguments.length; i++) {
+ args[i - 2] = arguments[i];
+ }
+ return parentCtor.prototype[methodName].apply(me, args);
+ };
+};
+
+
+/**
+ * Allow for aliasing within scope functions. This function exists for
+ * uncompiled code - in compiled code the calls will be inlined and the aliases
+ * applied. In uncompiled code the function is simply run since the aliases as
+ * written are valid JavaScript.
+ *
+ *
+ * @param {function()} fn Function to call. This function can contain aliases
+ * to namespaces (e.g. "var dom = goog.dom") or classes
+ * (e.g. "var Timer = goog.Timer").
+ * @deprecated Use goog.module instead.
+ */
+goog.scope = function(fn) {
+ if (goog.isInModuleLoader_()) {
+ throw new Error('goog.scope is not supported within a module.');
+ }
+ fn.call(goog.global);
+};
+
+
+/*
+ * To support uncompiled, strict mode bundles that use eval to divide source
+ * like so:
+ * eval('someSource;//# sourceUrl sourcefile.js');
+ * We need to export the globally defined symbols "goog" and "COMPILED".
+ * Exporting "goog" breaks the compiler optimizations, so we required that
+ * be defined externally.
+ * NOTE: We don't use goog.exportSymbol here because we don't want to trigger
+ * extern generation when that compiler option is enabled.
+ */
+if (!COMPILED) {
+ goog.global['COMPILED'] = COMPILED;
+}
+
+
+//==============================================================================
+// goog.defineClass implementation
+//==============================================================================
+
+
+/**
+ * Creates a restricted form of a Closure "class":
+ * - from the compiler's perspective, the instance returned from the
+ * constructor is sealed (no new properties may be added). This enables
+ * better checks.
+ * - the compiler will rewrite this definition to a form that is optimal
+ * for type checking and optimization (initially this will be a more
+ * traditional form).
+ *
+ * @param {Function} superClass The superclass, Object or null.
+ * @param {goog.defineClass.ClassDescriptor} def
+ * An object literal describing
+ * the class. It may have the following properties:
+ * "constructor": the constructor function
+ * "statics": an object literal containing methods to add to the constructor
+ * as "static" methods or a function that will receive the constructor
+ * function as its only parameter to which static properties can
+ * be added.
+ * all other properties are added to the prototype.
+ * @return {!Function} The class constructor.
+ * @deprecated Use ECMAScript class syntax instead.
+ */
+goog.defineClass = function(superClass, def) {
+ // TODO(johnlenz): consider making the superClass an optional parameter.
+ var constructor = def.constructor;
+ var statics = def.statics;
+ // Wrap the constructor prior to setting up the prototype and static methods.
+ if (!constructor || constructor == Object.prototype.constructor) {
+ constructor = function() {
+ throw new Error(
+ 'cannot instantiate an interface (no constructor defined).');
+ };
+ }
+
+ var cls = goog.defineClass.createSealingConstructor_(constructor, superClass);
+ if (superClass) {
+ goog.inherits(cls, superClass);
+ }
+
+ // Remove all the properties that should not be copied to the prototype.
+ delete def.constructor;
+ delete def.statics;
+
+ goog.defineClass.applyProperties_(cls.prototype, def);
+ if (statics != null) {
+ if (statics instanceof Function) {
+ statics(cls);
+ } else {
+ goog.defineClass.applyProperties_(cls, statics);
+ }
+ }
+
+ return cls;
+};
+
+
+/**
+ * @typedef {{
+ * constructor: (!Function|undefined),
+ * statics: (Object|undefined|function(Function):void)
+ * }}
+ */
+goog.defineClass.ClassDescriptor;
+
+
+/**
+ * @define {boolean} Whether the instances returned by goog.defineClass should
+ * be sealed when possible.
+ *
+ * When sealing is disabled the constructor function will not be wrapped by
+ * goog.defineClass, making it incompatible with ES6 class methods.
+ */
+goog.defineClass.SEAL_CLASS_INSTANCES =
+ goog.define('goog.defineClass.SEAL_CLASS_INSTANCES', goog.DEBUG);
+
+
+/**
+ * If goog.defineClass.SEAL_CLASS_INSTANCES is enabled and Object.seal is
+ * defined, this function will wrap the constructor in a function that seals the
+ * results of the provided constructor function.
+ *
+ * @param {!Function} ctr The constructor whose results maybe be sealed.
+ * @param {Function} superClass The superclass constructor.
+ * @return {!Function} The replacement constructor.
+ * @private
+ */
+goog.defineClass.createSealingConstructor_ = function(ctr, superClass) {
+ if (!goog.defineClass.SEAL_CLASS_INSTANCES) {
+ // Do now wrap the constructor when sealing is disabled. Angular code
+ // depends on this for injection to work properly.
+ return ctr;
+ }
+
+ // NOTE: The sealing behavior has been removed
+
+ /**
+ * @this {Object}
+ * @return {?}
+ */
+ var wrappedCtr = function() {
+ // Don't seal an instance of a subclass when it calls the constructor of
+ // its super class as there is most likely still setup to do.
+ var instance = ctr.apply(this, arguments) || this;
+ instance[goog.UID_PROPERTY_] = instance[goog.UID_PROPERTY_];
+
+ return instance;
+ };
+
+ return wrappedCtr;
+};
+
+
+
+// TODO(johnlenz): share these values with the goog.object
+/**
+ * The names of the fields that are defined on Object.prototype.
+ * @type {!Array}
+ * @private
+ * @const
+ */
+goog.defineClass.OBJECT_PROTOTYPE_FIELDS_ = [
+ 'constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable',
+ 'toLocaleString', 'toString', 'valueOf'
+];
+
+
+// TODO(johnlenz): share this function with the goog.object
+/**
+ * @param {!Object} target The object to add properties to.
+ * @param {!Object} source The object to copy properties from.
+ * @private
+ */
+goog.defineClass.applyProperties_ = function(target, source) {
+ // TODO(johnlenz): update this to support ES5 getters/setters
+
+ var key;
+ for (key in source) {
+ if (Object.prototype.hasOwnProperty.call(source, key)) {
+ target[key] = source[key];
+ }
+ }
+
+ // For IE the for-in-loop does not contain any properties that are not
+ // enumerable on the prototype object (for example isPrototypeOf from
+ // Object.prototype) and it will also not include 'replace' on objects that
+ // extend String and change 'replace' (not that it is common for anyone to
+ // extend anything except Object).
+ for (var i = 0; i < goog.defineClass.OBJECT_PROTOTYPE_FIELDS_.length; i++) {
+ key = goog.defineClass.OBJECT_PROTOTYPE_FIELDS_[i];
+ if (Object.prototype.hasOwnProperty.call(source, key)) {
+ target[key] = source[key];
+ }
+ }
+};
+
+/**
+ * Returns the parameter.
+ * @param {string} s
+ * @return {string}
+ * @private
+ */
+goog.identity_ = function(s) {
+ return s;
+};
+
+
+/**
+ * Creates Trusted Types policy if Trusted Types are supported by the browser.
+ * The policy just blesses any string as a Trusted Type. It is not visibility
+ * restricted because anyone can also call trustedTypes.createPolicy directly.
+ * However, the allowed names should be restricted by a HTTP header and the
+ * reference to the created policy should be visibility restricted.
+ * @param {string} name
+ * @return {?TrustedTypePolicy}
+ */
+goog.createTrustedTypesPolicy = function(name) {
+ var policy = null;
+ var policyFactory = goog.global.trustedTypes;
+ if (!policyFactory || !policyFactory.createPolicy) {
+ return policy;
+ }
+ // trustedTypes.createPolicy throws if called with a name that is already
+ // registered, even in report-only mode. Until the API changes, catch the
+ // error not to break the applications functionally. In such case, the code
+ // will fall back to using regular Safe Types.
+ // TODO(koto): Remove catching once createPolicy API stops throwing.
+ try {
+ policy = policyFactory.createPolicy(name, {
+ createHTML: goog.identity_,
+ createScript: goog.identity_,
+ createScriptURL: goog.identity_
+ });
+ } catch (e) {
+ goog.logToConsole_(e.message);
+ }
+ return policy;
+};
+
+// There's a bug in the compiler where without collapse properties the
+// Closure namespace defines do not guard code correctly. To help reduce code
+// size also check for !COMPILED even though it redundant until this is fixed.
+if (!COMPILED && goog.DEPENDENCIES_ENABLED) {
+
+
+ /**
+ * Tries to detect whether the current browser is Edge, based on the user
+ * agent. This matches only pre-Chromium Edge.
+ * @see https://docs.microsoft.com/en-us/microsoft-edge/web-platform/user-agent-string
+ * @return {boolean} True if the current browser is Edge.
+ * @private
+ */
+ goog.isEdge_ = function() {
+ var userAgent = goog.global.navigator && goog.global.navigator.userAgent ?
+ goog.global.navigator.userAgent :
+ '';
+ var edgeRe = /Edge\/(\d+)(\.\d)*/i;
+ return !!userAgent.match(edgeRe);
+ };
+
+
+ /**
+ * Tries to detect whether is in the context of an HTML document.
+ * @return {boolean} True if it looks like HTML document.
+ * @private
+ */
+ goog.inHtmlDocument_ = function() {
+ /** @type {!Document} */
+ var doc = goog.global.document;
+ return doc != null && 'write' in doc; // XULDocument misses write.
+ };
+
+
+ /**
+ * We'd like to check for if the document readyState is 'loading'; however
+ * there are bugs on IE 10 and below where the readyState being anything other
+ * than 'complete' is not reliable.
+ * @return {boolean}
+ * @private
+ */
+ goog.isDocumentLoading_ = function() {
+ // attachEvent is available on IE 6 thru 10 only, and thus can be used to
+ // detect those browsers.
+ /** @type {!HTMLDocument} */
+ var doc = goog.global.document;
+ return doc.attachEvent ? doc.readyState != 'complete' :
+ doc.readyState == 'loading';
+ };
+
+
+ /**
+ * Tries to detect the base path of base.js script that bootstraps Closure.
+ * @private
+ */
+ goog.findBasePath_ = function() {
+ if (goog.global.CLOSURE_BASE_PATH != undefined &&
+ // Anti DOM-clobbering runtime check (b/37736576).
+ typeof goog.global.CLOSURE_BASE_PATH === 'string') {
+ goog.basePath = goog.global.CLOSURE_BASE_PATH;
+ return;
+ } else if (!goog.inHtmlDocument_()) {
+ return;
+ }
+ /** @type {!Document} */
+ var doc = goog.global.document;
+ // If we have a currentScript available, use it exclusively.
+ var currentScript = doc.currentScript;
+ if (currentScript) {
+ var scripts = [currentScript];
+ } else {
+ var scripts = doc.getElementsByTagName('SCRIPT');
+ }
+ // Search backwards since the current script is in almost all cases the one
+ // that has base.js.
+ for (var i = scripts.length - 1; i >= 0; --i) {
+ var script = /** @type {!HTMLScriptElement} */ (scripts[i]);
+ var src = script.src;
+ var qmark = src.lastIndexOf('?');
+ var l = qmark == -1 ? src.length : qmark;
+ if (src.slice(l - 7, l) == 'base.js') {
+ goog.basePath = src.slice(0, l - 7);
+ return;
+ }
+ }
+ };
+
+ goog.findBasePath_();
+
+ /**
+ * Rewrites closing script tags in input to avoid ending an enclosing script
+ * tag.
+ *
+ * @param {string} str
+ * @return {string}
+ * @private
+ */
+ goog.protectScriptTag_ = function(str) {
+ return str.replace(/<\/(SCRIPT)/ig, '\\x3c/$1');
+ };
+
+
+ /**
+ * A debug loader is responsible for downloading and executing javascript
+ * files in an unbundled, uncompiled environment.
+ *
+ * This can be custimized via the setDependencyFactory method, or by
+ * CLOSURE_IMPORT_SCRIPT/CLOSURE_LOAD_FILE_SYNC.
+ *
+ * @struct @constructor @final @private
+ */
+ goog.DebugLoader_ = function() {
+ /** @private @const {!Object} */
+ this.dependencies_ = {};
+ /** @private @const {!Object} */
+ this.idToPath_ = {};
+ /** @private @const {!Object} */
+ this.written_ = {};
+ /** @private @const {!Array} */
+ this.loadingDeps_ = [];
+ /** @private {!Array} */
+ this.depsToLoad_ = [];
+ /** @private {boolean} */
+ this.paused_ = false;
+ /** @private {!goog.DependencyFactory} */
+ this.factory_ = new goog.DependencyFactory();
+ /** @private @const {!Object} */
+ this.deferredCallbacks_ = {};
+ /** @private @const {!Array} */
+ this.deferredQueue_ = [];
+ };
+
+ /**
+ * @param {!Array} namespaces
+ * @param {function(): undefined} callback Function to call once all the
+ * namespaces have loaded.
+ */
+ goog.DebugLoader_.prototype.bootstrap = function(namespaces, callback) {
+ var cb = callback;
+ function resolve() {
+ if (cb) {
+ goog.global.setTimeout(cb, 0);
+ cb = null;
+ }
+ }
+
+ if (!namespaces.length) {
+ resolve();
+ return;
+ }
+
+ var deps = [];
+ for (var i = 0; i < namespaces.length; i++) {
+ var path = this.getPathFromDeps_(namespaces[i]);
+ if (!path) {
+ throw new Error('Unregonized namespace: ' + namespaces[i]);
+ }
+ deps.push(this.dependencies_[path]);
+ }
+
+ var require = goog.require;
+ var loaded = 0;
+ for (var i = 0; i < namespaces.length; i++) {
+ require(namespaces[i]);
+ deps[i].onLoad(function() {
+ if (++loaded == namespaces.length) {
+ resolve();
+ }
+ });
+ }
+ };
+
+
+ /**
+ * Loads the Closure Dependency file.
+ *
+ * Exposed a public function so CLOSURE_NO_DEPS can be set to false, base
+ * loaded, setDependencyFactory called, and then this called. i.e. allows
+ * custom loading of the deps file.
+ */
+ goog.DebugLoader_.prototype.loadClosureDeps = function() {
+ // Circumvent addDependency, which would try to transpile deps.js if
+ // transpile is set to always.
+ var relPath = 'deps.js';
+ this.depsToLoad_.push(this.factory_.createDependency(
+ goog.normalizePath_(goog.basePath + relPath), relPath, [], [], {}));
+ this.loadDeps_();
+ };
+
+
+ /**
+ * Notifies the debug loader when a dependency has been requested.
+ *
+ * @param {string} absPathOrId Path of the dependency or goog id.
+ * @param {boolean=} opt_force
+ */
+ goog.DebugLoader_.prototype.requested = function(absPathOrId, opt_force) {
+ var path = this.getPathFromDeps_(absPathOrId);
+ if (path &&
+ (opt_force || this.areDepsLoaded_(this.dependencies_[path].requires))) {
+ var callback = this.deferredCallbacks_[path];
+ if (callback) {
+ delete this.deferredCallbacks_[path];
+ callback();
+ }
+ }
+ };
+
+
+ /**
+ * Sets the dependency factory, which can be used to create custom
+ * goog.Dependency implementations to control how dependencies are loaded.
+ *
+ * @param {!goog.DependencyFactory} factory
+ */
+ goog.DebugLoader_.prototype.setDependencyFactory = function(factory) {
+ this.factory_ = factory;
+ };
+
+
+ /**
+ * Travserses the dependency graph and queues the given dependency, and all of
+ * its transitive dependencies, for loading and then starts loading if not
+ * paused.
+ *
+ * @param {string} namespace
+ * @private
+ */
+ goog.DebugLoader_.prototype.load_ = function(namespace) {
+ if (!this.getPathFromDeps_(namespace)) {
+ var errorMessage = 'goog.require could not find: ' + namespace;
+ goog.logToConsole_(errorMessage);
+ } else {
+ var loader = this;
+
+ var deps = [];
+
+ /** @param {string} namespace */
+ var visit = function(namespace) {
+ var path = loader.getPathFromDeps_(namespace);
+
+ if (!path) {
+ throw new Error('Bad dependency path or symbol: ' + namespace);
+ }
+
+ if (loader.written_[path]) {
+ return;
+ }
+
+ loader.written_[path] = true;
+
+ var dep = loader.dependencies_[path];
+ for (var i = 0; i < dep.requires.length; i++) {
+ if (!goog.isProvided_(dep.requires[i])) {
+ visit(dep.requires[i]);
+ }
+ }
+
+ deps.push(dep);
+ };
+
+ visit(namespace);
+
+ var wasLoading = !!this.depsToLoad_.length;
+ this.depsToLoad_ = this.depsToLoad_.concat(deps);
+
+ if (!this.paused_ && !wasLoading) {
+ this.loadDeps_();
+ }
+ }
+ };
+
+
+ /**
+ * Loads any queued dependencies until they are all loaded or paused.
+ *
+ * @private
+ */
+ goog.DebugLoader_.prototype.loadDeps_ = function() {
+ var loader = this;
+ var paused = this.paused_;
+
+ while (this.depsToLoad_.length && !paused) {
+ (function() {
+ var loadCallDone = false;
+ var dep = loader.depsToLoad_.shift();
+
+ var loaded = false;
+ loader.loading_(dep);
+
+ var controller = {
+ pause: function() {
+ if (loadCallDone) {
+ throw new Error('Cannot call pause after the call to load.');
+ } else {
+ paused = true;
+ }
+ },
+ resume: function() {
+ if (loadCallDone) {
+ loader.resume_();
+ } else {
+ // Some dep called pause and then resume in the same load call.
+ // Just keep running this same loop.
+ paused = false;
+ }
+ },
+ loaded: function() {
+ if (loaded) {
+ throw new Error('Double call to loaded.');
+ }
+
+ loaded = true;
+ loader.loaded_(dep);
+ },
+ pending: function() {
+ // Defensive copy.
+ var pending = [];
+ for (var i = 0; i < loader.loadingDeps_.length; i++) {
+ pending.push(loader.loadingDeps_[i]);
+ }
+ return pending;
+ },
+ /**
+ * @param {goog.ModuleType} type
+ */
+ setModuleState: function(type) {
+ goog.moduleLoaderState_ = {
+ type: type,
+ moduleName: '',
+ declareLegacyNamespace: false
+ };
+ },
+ /** @type {function(string, string, string=)} */
+ registerEs6ModuleExports: function(
+ path, exports, opt_closureNamespace) {
+ if (opt_closureNamespace) {
+ goog.loadedModules_[opt_closureNamespace] = {
+ exports: exports,
+ type: goog.ModuleType.ES6,
+ moduleId: opt_closureNamespace || ''
+ };
+ }
+ },
+ /** @type {function(string, ?)} */
+ registerGoogModuleExports: function(moduleId, exports) {
+ goog.loadedModules_[moduleId] = {
+ exports: exports,
+ type: goog.ModuleType.GOOG,
+ moduleId: moduleId
+ };
+ },
+ clearModuleState: function() {
+ goog.moduleLoaderState_ = null;
+ },
+ defer: function(callback) {
+ if (loadCallDone) {
+ throw new Error(
+ 'Cannot register with defer after the call to load.');
+ }
+ loader.defer_(dep, callback);
+ },
+ areDepsLoaded: function() {
+ return loader.areDepsLoaded_(dep.requires);
+ }
+ };
+
+ try {
+ dep.load(controller);
+ } finally {
+ loadCallDone = true;
+ }
+ })();
+ }
+
+ if (paused) {
+ this.pause_();
+ }
+ };
+
+
+ /** @private */
+ goog.DebugLoader_.prototype.pause_ = function() {
+ this.paused_ = true;
+ };
+
+
+ /** @private */
+ goog.DebugLoader_.prototype.resume_ = function() {
+ if (this.paused_) {
+ this.paused_ = false;
+ this.loadDeps_();
+ }
+ };
+
+
+ /**
+ * Marks the given dependency as loading (load has been called but it has not
+ * yet marked itself as finished). Useful for dependencies that want to know
+ * what else is loading. Example: goog.modules cannot eval if there are
+ * loading dependencies.
+ *
+ * @param {!goog.Dependency} dep
+ * @private
+ */
+ goog.DebugLoader_.prototype.loading_ = function(dep) {
+ this.loadingDeps_.push(dep);
+ };
+
+
+ /**
+ * Marks the given dependency as having finished loading and being available
+ * for require.
+ *
+ * @param {!goog.Dependency} dep
+ * @private
+ */
+ goog.DebugLoader_.prototype.loaded_ = function(dep) {
+ for (var i = 0; i < this.loadingDeps_.length; i++) {
+ if (this.loadingDeps_[i] == dep) {
+ this.loadingDeps_.splice(i, 1);
+ break;
+ }
+ }
+
+ for (var i = 0; i < this.deferredQueue_.length; i++) {
+ if (this.deferredQueue_[i] == dep.path) {
+ this.deferredQueue_.splice(i, 1);
+ break;
+ }
+ }
+
+ if (this.loadingDeps_.length == this.deferredQueue_.length &&
+ !this.depsToLoad_.length) {
+ // Something has asked to load these, but they may not be directly
+ // required again later, so load them now that we know we're done loading
+ // everything else. e.g. a goog module entry point.
+ while (this.deferredQueue_.length) {
+ this.requested(this.deferredQueue_.shift(), true);
+ }
+ }
+
+ dep.loaded();
+ };
+
+
+ /**
+ * @param {!Array} pathsOrIds
+ * @return {boolean}
+ * @private
+ */
+ goog.DebugLoader_.prototype.areDepsLoaded_ = function(pathsOrIds) {
+ for (var i = 0; i < pathsOrIds.length; i++) {
+ var path = this.getPathFromDeps_(pathsOrIds[i]);
+ if (!path ||
+ (!(path in this.deferredCallbacks_) &&
+ !goog.isProvided_(pathsOrIds[i]))) {
+ return false;
+ }
+ }
+
+ return true;
+ };
+
+
+ /**
+ * @param {string} absPathOrId
+ * @return {?string}
+ * @private
+ */
+ goog.DebugLoader_.prototype.getPathFromDeps_ = function(absPathOrId) {
+ if (absPathOrId in this.idToPath_) {
+ return this.idToPath_[absPathOrId];
+ } else if (absPathOrId in this.dependencies_) {
+ return absPathOrId;
+ } else {
+ return null;
+ }
+ };
+
+
+ /**
+ * @param {!goog.Dependency} dependency
+ * @param {!Function} callback
+ * @private
+ */
+ goog.DebugLoader_.prototype.defer_ = function(dependency, callback) {
+ this.deferredCallbacks_[dependency.path] = callback;
+ this.deferredQueue_.push(dependency.path);
+ };
+
+
+ /**
+ * Interface for goog.Dependency implementations to have some control over
+ * loading of dependencies.
+ *
+ * @record
+ */
+ goog.LoadController = function() {};
+
+
+ /**
+ * Tells the controller to halt loading of more dependencies.
+ */
+ goog.LoadController.prototype.pause = function() {};
+
+
+ /**
+ * Tells the controller to resume loading of more dependencies if paused.
+ */
+ goog.LoadController.prototype.resume = function() {};
+
+
+ /**
+ * Tells the controller that this dependency has finished loading.
+ *
+ * This causes this to be removed from pending() and any load callbacks to
+ * fire.
+ */
+ goog.LoadController.prototype.loaded = function() {};
+
+
+ /**
+ * List of dependencies on which load has been called but which have not
+ * called loaded on their controller. This includes the current dependency.
+ *
+ * @return {!Array}
+ */
+ goog.LoadController.prototype.pending = function() {};
+
+
+ /**
+ * Registers an object as an ES6 module's exports so that goog.modules may
+ * require it by path.
+ *
+ * @param {string} path Full path of the module.
+ * @param {?} exports
+ * @param {string=} opt_closureNamespace Closure namespace to associate with
+ * this module.
+ */
+ goog.LoadController.prototype.registerEs6ModuleExports = function(
+ path, exports, opt_closureNamespace) {};
+
+
+ /**
+ * Sets the current module state.
+ *
+ * @param {goog.ModuleType} type Type of module.
+ */
+ goog.LoadController.prototype.setModuleState = function(type) {};
+
+
+ /**
+ * Clears the current module state.
+ */
+ goog.LoadController.prototype.clearModuleState = function() {};
+
+
+ /**
+ * Registers a callback to call once the dependency is actually requested
+ * via goog.require + all of the immediate dependencies have been loaded or
+ * all other files have been loaded. Allows for lazy loading until
+ * require'd without pausing dependency loading, which is needed on old IE.
+ *
+ * @param {!Function} callback
+ */
+ goog.LoadController.prototype.defer = function(callback) {};
+
+
+ /**
+ * @return {boolean}
+ */
+ goog.LoadController.prototype.areDepsLoaded = function() {};
+
+
+ /**
+ * Basic super class for all dependencies Closure Library can load.
+ *
+ * This default implementation is designed to load untranspiled, non-module
+ * scripts in a web broswer.
+ *
+ * For goog.modules see {@see goog.GoogModuleDependency}.
+ * For untranspiled ES6 modules {@see goog.Es6ModuleDependency}.
+ *
+ * @param {string} path Absolute path of this script.
+ * @param {string} relativePath Path of this script relative to goog.basePath.
+ * @param {!Array} provides goog.provided or goog.module symbols
+ * in this file.
+ * @param {!Array} requires goog symbols or relative paths to Closure
+ * this depends on.
+ * @param {!Object} loadFlags
+ * @struct @constructor
+ */
+ goog.Dependency = function(
+ path, relativePath, provides, requires, loadFlags) {
+ /** @const */
+ this.path = path;
+ /** @const */
+ this.relativePath = relativePath;
+ /** @const */
+ this.provides = provides;
+ /** @const */
+ this.requires = requires;
+ /** @const */
+ this.loadFlags = loadFlags;
+ /** @private {boolean} */
+ this.loaded_ = false;
+ /** @private {!Array} */
+ this.loadCallbacks_ = [];
+ };
+
+
+ /**
+ * @return {string} The pathname part of this dependency's path if it is a
+ * URI.
+ */
+ goog.Dependency.prototype.getPathName = function() {
+ var pathName = this.path;
+ var protocolIndex = pathName.indexOf('://');
+ if (protocolIndex >= 0) {
+ pathName = pathName.substring(protocolIndex + 3);
+ var slashIndex = pathName.indexOf('/');
+ if (slashIndex >= 0) {
+ pathName = pathName.substring(slashIndex + 1);
+ }
+ }
+ return pathName;
+ };
+
+
+ /**
+ * @param {function()} callback Callback to fire as soon as this has loaded.
+ * @final
+ */
+ goog.Dependency.prototype.onLoad = function(callback) {
+ if (this.loaded_) {
+ callback();
+ } else {
+ this.loadCallbacks_.push(callback);
+ }
+ };
+
+
+ /**
+ * Marks this dependency as loaded and fires any callbacks registered with
+ * onLoad.
+ * @final
+ */
+ goog.Dependency.prototype.loaded = function() {
+ this.loaded_ = true;
+ var callbacks = this.loadCallbacks_;
+ this.loadCallbacks_ = [];
+ for (var i = 0; i < callbacks.length; i++) {
+ callbacks[i]();
+ }
+ };
+
+
+ /**
+ * Whether or not document.written / appended script tags should be deferred.
+ *
+ * @private {boolean}
+ */
+ goog.Dependency.defer_ = false;
+
+
+ /**
+ * Map of script ready / state change callbacks. Old IE cannot handle putting
+ * these properties on goog.global.
+ *
+ * @private @const {!Object}
+ */
+ goog.Dependency.callbackMap_ = {};
+
+
+ /**
+ * @param {function(...?):?} callback
+ * @return {string}
+ * @private
+ */
+ goog.Dependency.registerCallback_ = function(callback) {
+ var key = Math.random().toString(32);
+ goog.Dependency.callbackMap_[key] = callback;
+ return key;
+ };
+
+
+ /**
+ * @param {string} key
+ * @private
+ */
+ goog.Dependency.unregisterCallback_ = function(key) {
+ delete goog.Dependency.callbackMap_[key];
+ };
+
+
+ /**
+ * @param {string} key
+ * @param {...?} var_args
+ * @private
+ * @suppress {unusedPrivateMembers}
+ */
+ goog.Dependency.callback_ = function(key, var_args) {
+ if (key in goog.Dependency.callbackMap_) {
+ var callback = goog.Dependency.callbackMap_[key];
+ var args = [];
+ for (var i = 1; i < arguments.length; i++) {
+ args.push(arguments[i]);
+ }
+ callback.apply(undefined, args);
+ } else {
+ var errorMessage = 'Callback key ' + key +
+ ' does not exist (was base.js loaded more than once?).';
+ throw Error(errorMessage);
+ }
+ };
+
+
+ /**
+ * Starts loading this dependency. This dependency can pause loading if it
+ * needs to and resume it later via the controller interface.
+ *
+ * When this is loaded it should call controller.loaded(). Note that this will
+ * end up calling the loaded method of this dependency; there is no need to
+ * call it explicitly.
+ *
+ * @param {!goog.LoadController} controller
+ */
+ goog.Dependency.prototype.load = function(controller) {
+ if (goog.global.CLOSURE_IMPORT_SCRIPT) {
+ if (goog.global.CLOSURE_IMPORT_SCRIPT(this.path)) {
+ controller.loaded();
+ } else {
+ controller.pause();
+ }
+ return;
+ }
+
+ if (!goog.inHtmlDocument_()) {
+ goog.logToConsole_(
+ 'Cannot use default debug loader outside of HTML documents.');
+ if (this.relativePath == 'deps.js') {
+ // Some old code is relying on base.js auto loading deps.js failing with
+ // no error before later setting CLOSURE_IMPORT_SCRIPT.
+ // CLOSURE_IMPORT_SCRIPT should be set *before* base.js is loaded, or
+ // CLOSURE_NO_DEPS set to true.
+ goog.logToConsole_(
+ 'Consider setting CLOSURE_IMPORT_SCRIPT before loading base.js, ' +
+ 'or setting CLOSURE_NO_DEPS to true.');
+ controller.loaded();
+ } else {
+ controller.pause();
+ }
+ return;
+ }
+
+ /** @type {!HTMLDocument} */
+ var doc = goog.global.document;
+
+ // If the user tries to require a new symbol after document load,
+ // something has gone terribly wrong. Doing a document.write would
+ // wipe out the page. This does not apply to the CSP-compliant method
+ // of writing script tags.
+ if (doc.readyState == 'complete' &&
+ !goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING) {
+ // Certain test frameworks load base.js multiple times, which tries
+ // to write deps.js each time. If that happens, just fail silently.
+ // These frameworks wipe the page between each load of base.js, so this
+ // is OK.
+ var isDeps = /\bdeps.js$/.test(this.path);
+ if (isDeps) {
+ controller.loaded();
+ return;
+ } else {
+ throw Error('Cannot write "' + this.path + '" after document load');
+ }
+ }
+
+ var nonce = goog.getScriptNonce_();
+ if (!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING &&
+ goog.isDocumentLoading_()) {
+ var key;
+ var callback = function(script) {
+ if (script.readyState && script.readyState != 'complete') {
+ script.onload = callback;
+ return;
+ }
+ goog.Dependency.unregisterCallback_(key);
+ controller.loaded();
+ };
+ key = goog.Dependency.registerCallback_(callback);
+
+ var defer = goog.Dependency.defer_ ? ' defer' : '';
+ var nonceAttr = nonce ? ' nonce="' + nonce + '"' : '';
+ var script = '