=} opt_values Maps place holder name to value.
- * @param {{html: boolean}=} opt_options Options:
- * html: Escape '<' in str to '<'. Used by Closure Templates where the
- * generated code size and performance is critical which is why {@link
- * goog.html.SafeHtmlFormatter} is not used. The value must be literal true
- * or false.
- * @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(/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=} opt_objectToExportTo The object to add the path to; default
- * is goog.global.
- */
-goog.exportSymbol = function(publicPath, object, opt_objectToExportTo) {
- goog.exportPath_(publicPath, object, opt_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.
- */
-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);
- };
-};
-
-
-/**
- * Call up to the superclass.
- *
- * If this is called from a constructor, then this calls the superclass
- * constructor with arguments 1-N.
- *
- * If this is called from a prototype method, then you must pass the name of the
- * method as the second argument to this function. If you do not, you will get a
- * runtime error. This calls the superclass' method with arguments 2-N.
- *
- * This function only works if you use goog.inherits to express inheritance
- * relationships between your classes.
- *
- * This function is a compiler primitive. At compile-time, the compiler will do
- * macro expansion to remove a lot of the extra overhead that this function
- * introduces. The compiler will also enforce a lot of the assumptions that this
- * function makes, and treat it as a compiler error if you break them.
- *
- * @param {!Object} me Should always be "this".
- * @param {*=} opt_methodName The method name if calling a super method.
- * @param {...*} var_args The rest of the arguments.
- * @return {*} The return value of the superclass method.
- * @suppress {es5Strict} This method can not be used in strict mode, but
- * all Closure Library consumers must depend on this file.
- * @deprecated goog.base is not strict mode compatible. Prefer the static
- * "base" method added to the constructor by goog.inherits
- * or ES6 classes and the "super" keyword.
- */
-goog.base = function(me, opt_methodName, var_args) {
- var caller = arguments.callee.caller;
-
- if (goog.STRICT_MODE_COMPATIBLE || (goog.DEBUG && !caller)) {
- throw new Error(
- 'arguments.caller not defined. goog.base() cannot be used ' +
- 'with strict mode code. See ' +
- 'http://www.ecma-international.org/ecma-262/5.1/#sec-C');
- }
-
- if (typeof caller.superClass_ !== 'undefined') {
- // 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 ctorArgs = new Array(arguments.length - 1);
- for (var i = 1; i < arguments.length; i++) {
- ctorArgs[i - 1] = arguments[i];
- }
- // This is a constructor. Call the superclass constructor.
- return /** @type {!Function} */ (caller.superClass_)
- .constructor.apply(me, ctorArgs);
- }
-
- if (typeof opt_methodName != 'string' && typeof opt_methodName != 'symbol') {
- throw new Error(
- 'method names provided to goog.base must be a string or a symbol');
- }
-
- // 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];
- }
- var foundCaller = false;
- for (var proto = me.constructor.prototype; proto;
- proto = Object.getPrototypeOf(proto)) {
- if (proto[opt_methodName] === caller) {
- foundCaller = true;
- } else if (foundCaller) {
- return proto[opt_methodName].apply(me, args);
- }
- }
-
- // If we did not find the caller in the prototype chain, then one of two
- // things happened:
- // 1) The caller is an instance method.
- // 2) This method was not called by the right caller.
- if (me[opt_methodName] === caller) {
- return me.constructor.prototype[opt_methodName].apply(me, args);
- } else {
- throw new Error(
- 'goog.base called from a method of one name ' +
- 'to a method of a different name');
- }
-};
-
-
-/**
- * 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").
- */
-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 ES6 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;
- }
-
- // Compute whether the constructor is sealable at definition time, rather
- // than when the instance is being constructed.
- var superclassSealable = !goog.defineClass.isUnsealable_(superClass);
-
- /**
- * @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_];
-
- if (this.constructor === wrappedCtr && superclassSealable &&
- Object.seal instanceof Function) {
- Object.seal(instance);
- }
- return instance;
- };
-
- return wrappedCtr;
-};
-
-
-/**
- * @param {Function} ctr The constructor to test.
- * @return {boolean} Whether the constructor has been tagged as unsealable
- * using goog.tagUnsealableClass.
- * @private
- */
-goog.defineClass.isUnsealable_ = function(ctr) {
- return ctr && ctr.prototype &&
- ctr.prototype[goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_];
-};
-
-
-// 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];
- }
- }
-};
-
-
-/**
- * Sealing classes breaks the older idiom of assigning properties on the
- * prototype rather than in the constructor. As such, goog.defineClass
- * must not seal subclasses of these old-style classes until they are fixed.
- * Until then, this marks a class as "broken", instructing defineClass
- * not to seal subclasses.
- * @param {!Function} ctr The legacy constructor to tag as unsealable.
- */
-goog.tagUnsealableClass = function(ctr) {
- if (!COMPILED && goog.defineClass.SEAL_CLASS_INSTANCES) {
- ctr.prototype[goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_] = true;
- }
-};
-
-
-/**
- * Name for unsealable tag property.
- * @const @private {string}
- */
-goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_ = 'goog_defineClass_legacy_unsealable';
-
-
// 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 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.isDef(goog.global.CLOSURE_BASE_PATH) &&
- // Anti DOM-clobbering runtime check (b/37736576).
- goog.isString(goog.global.CLOSURE_BASE_PATH)) {
- 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.substr(l - 7, 7) == 'base.js') {
- goog.basePath = src.substr(0, l - 7);
- return;
- }
- }
- };
-
- goog.findBasePath_();
-
- /** @struct @constructor @final */
- goog.Transpiler = function() {
- /** @private {?Object} */
- this.requiresTranspilation_ = null;
- /** @private {string} */
- this.transpilationTarget_ = goog.TRANSPILE_TO_LANGUAGE;
- };
-
-
- /**
- * Returns a newly created map from language mode string to a boolean
- * indicating whether transpilation should be done for that mode as well as
- * the highest level language that this environment supports.
- *
- * Guaranteed invariant:
- * For any two modes, l1 and l2 where l2 is a newer mode than l1,
- * `map[l1] == true` implies that `map[l2] == true`.
- *
- * Note this method is extracted and used elsewhere, so it cannot rely on
- * anything external (it should easily be able to be transformed into a
- * standalone, top level function).
- *
- * @private
- * @return {{
- * target: string,
- * map: !Object
- * }}
- */
- goog.Transpiler.prototype.createRequiresTranspilation_ = function() {
- var transpilationTarget = 'es3';
- var /** !Object */ requiresTranspilation = {'es3': false};
- var transpilationRequiredForAllLaterModes = false;
-
- /**
- * Adds an entry to requiresTranspliation for the given language mode.
- *
- * IMPORTANT: Calls must be made in order from oldest to newest language
- * mode.
- * @param {string} modeName
- * @param {function(): boolean} isSupported Returns true if the JS engine
- * supports the given mode.
- */
- function addNewerLanguageTranspilationCheck(modeName, isSupported) {
- if (transpilationRequiredForAllLaterModes) {
- requiresTranspilation[modeName] = true;
- } else if (isSupported()) {
- transpilationTarget = modeName;
- requiresTranspilation[modeName] = false;
- } else {
- requiresTranspilation[modeName] = true;
- transpilationRequiredForAllLaterModes = true;
- }
- }
-
- /**
- * Does the given code evaluate without syntax errors and return a truthy
- * result?
- */
- function /** boolean */ evalCheck(/** string */ code) {
- try {
- return !!eval(code);
- } catch (ignored) {
- return false;
- }
- }
-
- var userAgent = goog.global.navigator && goog.global.navigator.userAgent ?
- goog.global.navigator.userAgent :
- '';
-
- // Identify ES3-only browsers by their incorrect treatment of commas.
- addNewerLanguageTranspilationCheck('es5', function() {
- return evalCheck('[1,].length==1');
- });
- addNewerLanguageTranspilationCheck('es6', function() {
- // Edge has a non-deterministic (i.e., not reproducible) bug with ES6:
- // https://github.com/Microsoft/ChakraCore/issues/1496.
- var re = /Edge\/(\d+)(\.\d)*/i;
- var edgeUserAgent = userAgent.match(re);
- if (edgeUserAgent) {
- // The Reflect.construct test below is flaky on Edge. It can sometimes
- // pass or fail on 40 15.15063, so just exit early for Edge and treat
- // it as ES5. Until we're on a more up to date version just always use
- // ES5. See https://github.com/Microsoft/ChakraCore/issues/3217.
- return false;
- }
- // Test es6: [FF50 (?), Edge 14 (?), Chrome 50]
- // (a) default params (specifically shadowing locals),
- // (b) destructuring, (c) block-scoped functions,
- // (d) for-of (const), (e) new.target/Reflect.construct
- var es6fullTest =
- 'class X{constructor(){if(new.target!=String)throw 1;this.x=42}}' +
- 'let q=Reflect.construct(X,[],String);if(q.x!=42||!(q instanceof ' +
- 'String))throw 1;for(const a of[2,3]){if(a==2)continue;function ' +
- 'f(z={a}){let a=0;return z.a}{function f(){return 0;}}return f()' +
- '==3}';
-
- return evalCheck('(()=>{"use strict";' + es6fullTest + '})()');
- });
- // ** and **= are the only new features in 'es7'
- addNewerLanguageTranspilationCheck('es7', function() {
- return evalCheck('2 ** 2 == 4');
- });
- // async functions are the only new features in 'es8'
- addNewerLanguageTranspilationCheck('es8', function() {
- return evalCheck('async () => 1, true');
- });
- addNewerLanguageTranspilationCheck('es9', function() {
- return evalCheck('({...rest} = {}), true');
- });
- addNewerLanguageTranspilationCheck('es_next', function() {
- return false; // assume it always need to transpile
- });
- return {target: transpilationTarget, map: requiresTranspilation};
- };
-
-
- /**
- * Determines whether the given language needs to be transpiled.
- * @param {string} lang
- * @param {string|undefined} module
- * @return {boolean}
- */
- goog.Transpiler.prototype.needsTranspile = function(lang, module) {
- if (goog.TRANSPILE == 'always') {
- return true;
- } else if (goog.TRANSPILE == 'never') {
- return false;
- } else if (!this.requiresTranspilation_) {
- var obj = this.createRequiresTranspilation_();
- this.requiresTranspilation_ = obj.map;
- this.transpilationTarget_ = this.transpilationTarget_ || obj.target;
- }
- if (lang in this.requiresTranspilation_) {
- if (this.requiresTranspilation_[lang]) {
- return true;
- } else if (
- goog.inHtmlDocument_() && module == 'es6' &&
- !('noModule' in goog.global.document.createElement('script'))) {
- return true;
- } else {
- return false;
- }
- } else {
- throw new Error('Unknown language mode: ' + lang);
- }
- };
-
-
- /**
- * Lazily retrieves the transpiler and applies it to the source.
- * @param {string} code JS code.
- * @param {string} path Path to the code.
- * @return {string} The transpiled code.
- */
- goog.Transpiler.prototype.transpile = function(code, path) {
- // TODO(johnplaisted): We should delete goog.transpile_ and just have this
- // function. But there's some compile error atm where goog.global is being
- // stripped incorrectly without this.
- return goog.transpile_(code, path, this.transpilationTarget_);
- };
-
-
- /** @private @final {!goog.Transpiler} */
- goog.transpiler_ = new goog.Transpiler();
-
- /**
- * 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(goog.transpiler_);
- /** @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, [], [], {},
- false));
- 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);
- throw Error(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 transpiled non-goog.module files {@see goog.TranspiledDependency}.
- * 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');
- }
- }
-
- if (!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING &&
- goog.isDocumentLoading_()) {
- var key = goog.Dependency.registerCallback_(function(script) {
- if (!goog.DebugLoader_.IS_OLD_IE_ || script.readyState == 'complete') {
- goog.Dependency.unregisterCallback_(key);
- controller.loaded();
- }
- });
- var nonceAttr = !goog.DebugLoader_.IS_OLD_IE_ && goog.getScriptNonce() ?
- ' nonce="' + goog.getScriptNonce() + '"' :
- '';
- var event =
- goog.DebugLoader_.IS_OLD_IE_ ? 'onreadystatechange' : 'onload';
- var defer = goog.Dependency.defer_ ? 'defer' : '';
- var script = '