tor-browser

base.js (81069B)

---

// Copyright 2006 The Closure Library Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS-IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

/**
* @fileoverview Bootstrap for the Google JS Library (Closure).
*
* In uncompiled mode base.js will write out Closure's deps file, unless the
* global <code>CLOSURE_NO_DEPS</code> is set to true.  This allows projects to
* include their own deps file(s) from different locations.
*
* @author arv@google.com (Erik Arvidsson)
*
* @provideGoog
*/


/**
* @define {boolean} Overridden to true by the compiler when --closure_pass
*     or --mark_as_compiled is specified.
*/
var COMPILED = false;


/**
* Base namespace for the Closure library.  Checks to see goog is already
* defined in the current scope before assigning to prevent clobbering if
* base.js is loaded more than once.
*
* @const
*/
var goog = goog || {};


/**
* Reference to the global context.  In most cases this will be 'window'.
*/
goog.global = this;


/**
* A hook for overriding the define values in uncompiled mode.
*
* In uncompiled mode, {@code CLOSURE_UNCOMPILED_DEFINES} may be defined before
* loading base.js.  If a key is defined in {@code CLOSURE_UNCOMPILED_DEFINES},
* {@code goog.define} will use the value instead of the default value.  This
* allows flags to be overwritten without compilation (this is normally
* accomplished with the compiler's "define" flag).
*
* Example:
* <pre>
*   var CLOSURE_UNCOMPILED_DEFINES = {'goog.DEBUG': false};
* </pre>
*
* @type {Object<string, (string|number|boolean)>|undefined}
*/
goog.global.CLOSURE_UNCOMPILED_DEFINES;


/**
* A hook for overriding the define values in uncompiled or compiled mode,
* like CLOSURE_UNCOMPILED_DEFINES but effective in compiled code.  In
* uncompiled code CLOSURE_UNCOMPILED_DEFINES takes precedence.
*
* Also unlike CLOSURE_UNCOMPILED_DEFINES the values must be number, boolean or
* string literals or the compiler will emit an error.
*
* While any @define value may be set, only those set with goog.define will be
* effective for uncompiled code.
*
* Example:
* <pre>
*   var CLOSURE_DEFINES = {'goog.DEBUG': false} ;
* </pre>
*
* @type {Object<string, (string|number|boolean)>|undefined}
*/
goog.global.CLOSURE_DEFINES;


/**
* Returns true if the specified value is not undefined.
* WARNING: Do not use this to test if an object has a property. Use the in
* operator instead.
*
* @param {?} val Variable to test.
* @return {boolean} Whether variable is defined.
*/
goog.isDef = function(val) {
 // void 0 always evaluates to undefined and hence we do not need to depend on
 // the definition of the global variable named 'undefined'.
 return val !== void 0;
};


/**
* Builds an object structure for the provided namespace path, ensuring that
* names that already exist are not overwritten. For example:
* "a.b.c" -> a = {};a.b={};a.b.c={};
* Used by goog.provide and goog.exportSymbol.
* @param {string} name name of the object that this file defines.
* @param {*=} opt_object the object to expose at the end of the path.
* @param {Object=} opt_objectToExportTo The object to add the path to; default
*     is |goog.global|.
* @private
*/
goog.exportPath_ = function(name, opt_object, opt_objectToExportTo) {
 var parts = name.split('.');
 var cur = opt_objectToExportTo || goog.global;

 // Internet Explorer exhibits strange behavior when throwing errors from
 // methods externed in this manner.  See the testExportSymbolExceptions in
 // base_test.html for an example.
 if (!(parts[0] in cur) && cur.execScript) {
   cur.execScript('var ' + parts[0]);
 }

 // Certain browsers cannot parse code in the form for((a in b); c;);
 // This pattern is produced by the JSCompiler when it collapses the
 // statement above into the conditional loop below. To prevent this from
 // happening, use a for-loop and reserve the init logic as below.

 // Parentheses added to eliminate strict JS warning in Firefox.
 for (var part; parts.length && (part = parts.shift());) {
   if (!parts.length && goog.isDef(opt_object)) {
     // last part and we have an object; use it
     cur[part] = opt_object;
   } else if (cur[part]) {
     cur = cur[part];
   } else {
     cur = cur[part] = {};
   }
 }
};


/**
* Defines a named value. In uncompiled mode, the value is retrieved from
* CLOSURE_DEFINES or CLOSURE_UNCOMPILED_DEFINES if the object is defined and
* has the property specified, and otherwise used the defined defaultValue.
* When compiled the default can be overridden using the compiler
* options or the value set in the CLOSURE_DEFINES object.
*
* @param {string} name The distinguished name to provide.
* @param {string|number|boolean} defaultValue
*/
goog.define = function(name, defaultValue) {
 var value = defaultValue;
 if (!COMPILED) {
   if (goog.global.CLOSURE_UNCOMPILED_DEFINES &&
       Object.prototype.hasOwnProperty.call(
           goog.global.CLOSURE_UNCOMPILED_DEFINES, name)) {
     value = goog.global.CLOSURE_UNCOMPILED_DEFINES[name];
   } else if (goog.global.CLOSURE_DEFINES &&
       Object.prototype.hasOwnProperty.call(
           goog.global.CLOSURE_DEFINES, name)) {
     value = goog.global.CLOSURE_DEFINES[name];
   }
 }
 goog.exportPath_(name, value);
};


/**
* @define {boolean} DEBUG is provided as a convenience so that debugging code
* that should not be included in a production js_binary can be easily stripped
* by specifying --define goog.DEBUG=false to the JSCompiler. For example, most
* toString() methods should be declared inside an "if (goog.DEBUG)" conditional
* because they are generally used for debugging purposes and it is difficult
* for the JSCompiler to statically determine whether they are used.
*/
goog.define('goog.DEBUG', true);


/**
* @define {string} LOCALE defines the locale being used for compilation. It is
* used to select locale specific data to be compiled in js binary. BUILD rule
* can specify this value by "--define goog.LOCALE=<locale_name>" as JSCompiler
* option.
*
* Take into account that the locale code format is important. You should use
* the canonical Unicode format with hyphen as a delimiter. Language must be
* lowercase, Language Script - Capitalized, Region - UPPERCASE.
* There are few examples: pt-BR, en, en-US, sr-Latin-BO, zh-Hans-CN.
*
* See more info about locale codes here:
* http://www.unicode.org/reports/tr35/#Unicode_Language_and_Locale_Identifiers
*
* For language codes you should use values defined by ISO 693-1. See it here
* http://www.w3.org/WAI/ER/IG/ert/iso639.htm. There is only one exception from
* this rule: the Hebrew language. For legacy reasons the old code (iw) should
* be used instead of the new code (he), see http://wiki/Main/IIISynonyms.
*/
goog.define('goog.LOCALE', 'en');  // default to en


/**
* @define {boolean} Whether this code is running on trusted sites.
*
* On untrusted sites, several native functions can be defined or overridden by
* external libraries like Prototype, Datejs, and JQuery and setting this flag
* to false forces closure to use its own implementations when possible.
*
* If your JavaScript can be loaded by a third party site and you are wary about
* relying on non-standard implementations, specify
* "--define goog.TRUSTED_SITE=false" to the JSCompiler.
*/
goog.define('goog.TRUSTED_SITE', true);


/**
* @define {boolean} Whether a project is expected to be running in strict mode.
*
* This define can be used to trigger alternate implementations compatible with
* running in EcmaScript Strict mode or warn about unavailable functionality.
* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/Strict_mode
*
*/
goog.define('goog.STRICT_MODE_COMPATIBLE', false);


/**
* @define {boolean} Whether code that calls {@link goog.setTestOnly} should
*     be disallowed in the compilation unit.
*/
goog.define('goog.DISALLOW_TEST_ONLY_CODE', COMPILED && !goog.DEBUG);


/**
* Defines a namespace in Closure.
*
* A namespace may only be defined once in a codebase. It may be defined using
* goog.provide() or goog.module().
*
* The presence of one or more goog.provide() calls in a file indicates
* that the file defines the given objects/namespaces.
* Provided symbols must not be null or undefined.
*
* In addition, goog.provide() creates the object stubs for a namespace
* (for example, goog.provide("goog.foo.bar") will create the object
* goog.foo.bar if it does not already exist).
*
* Build tools also scan for provide/require/module statements
* to discern dependencies, build dependency files (see deps.js), etc.
*
* @see goog.require
* @see goog.module
* @param {string} name Namespace provided by this file in the form
*     "goog.package.part".
*/
goog.provide = function(name) {
 if (!COMPILED) {
   // Ensure that the same namespace isn't provided twice.
   // A goog.module/goog.provide maps a goog.require to a specific file
   if (goog.isProvided_(name)) {
     throw Error('Namespace "' + name + '" already declared.');
   }
 }

 goog.constructNamespace_(name);
};


/**
* @param {string} name Namespace provided by this file in the form
*     "goog.package.part".
* @param {Object=} opt_obj The object to embed in the namespace.
* @private
*/
goog.constructNamespace_ = function(name, opt_obj) {
 if (!COMPILED) {
   delete goog.implicitNamespaces_[name];

   var namespace = name;
   while ((namespace = namespace.substring(0, namespace.lastIndexOf('.')))) {
     if (goog.getObjectByName(namespace)) {
       break;
     }
     goog.implicitNamespaces_[namespace] = true;
   }
 }

 goog.exportPath_(name, opt_obj);
};


/**
* Module identifier validation regexp.
* Note: This is a conservative check, it is very possible to be more lenient,
*   the primary exclusion here is "/" and "\" and a leading ".", these
*   restrictions are intended to leave the door open for using goog.require
*   with relative file paths rather than module identifiers.
* @private
*/
goog.VALID_MODULE_RE_ = /^[a-zA-Z_$][a-zA-Z0-9._$]*$/;


/**
* Defines a module in Closure.
*
* Marks that this file must be loaded as a module and claims the namespace.
*
* A namespace may only be defined once in a codebase. It may be defined using
* goog.provide() or goog.module().
*
* goog.module() has three requirements:
* - goog.module may not be used in the same file as goog.provide.
* - goog.module must be the first statement in the file.
* - only one goog.module is allowed per file.
*
* When a goog.module annotated file is loaded, it is enclosed in
* a strict function closure. This means that:
* - any variables declared in a goog.module file are private to the file
* (not global), though the compiler is expected to inline the module.
* - The code must obey all the rules of "strict" JavaScript.
* - the file will be marked as "use strict"
*
* NOTE: unlike goog.provide, goog.module does not declare any symbols by
* itself. If declared symbols are desired, use
* goog.module.declareLegacyNamespace().
*
*
* See the public goog.module proposal: http://goo.gl/Va1hin
*
* @param {string} name Namespace provided by this file in the form
*     "goog.package.part", is expected but not required.
*/
goog.module = function(name) {
 if (!goog.isString(name) ||
     !name ||
     name.search(goog.VALID_MODULE_RE_) == -1) {
   throw Error('Invalid module identifier');
 }
 if (!goog.isInModuleLoader_()) {
   throw Error('Module ' + name + ' has been loaded incorrectly.');
 }
 if (goog.moduleLoaderState_.moduleName) {
   throw Error('goog.module may only be called once per module.');
 }

 // Store the module name for the loader.
 goog.moduleLoaderState_.moduleName = name;
 if (!COMPILED) {
   // Ensure that the same namespace isn't provided twice.
   // A goog.module/goog.provide maps a goog.require to a specific file
   if (goog.isProvided_(name)) {
     throw Error('Namespace "' + name + '" already declared.');
   }
   delete goog.implicitNamespaces_[name];
 }
};


/**
* @param {string} name The module identifier.
* @return {?} The module exports for an already loaded module or null.
*
* Note: This is not an alternative to goog.require, it does not
* indicate a hard dependency, instead it is used to indicate
* an optional dependency or to access the exports of a module
* that has already been loaded.
* @suppress {missingProvide}
*/
goog.module.get = function(name) {
 return goog.module.getInternal_(name);
};


/**
* @param {string} name The module identifier.
* @return {?} The module exports for an already loaded module or null.
* @private
*/
goog.module.getInternal_ = function(name) {
 if (!COMPILED) {
   if (goog.isProvided_(name)) {
     // goog.require only return a value with-in goog.module files.
     return name in goog.loadedModules_ ?
         goog.loadedModules_[name] :
         goog.getObjectByName(name);
   } else {
     return null;
   }
 }
};


/**
* @private {?{
*   moduleName: (string|undefined),
*   declareTestMethods: boolean
* }}
*/
goog.moduleLoaderState_ = null;


/**
* @private
* @return {boolean} Whether a goog.module is currently being initialized.
*/
goog.isInModuleLoader_ = function() {
 return goog.moduleLoaderState_ != null;
};


/**
* Indicate that a module's exports that are known test methods should
* be copied to the global object.  This makes the test methods visible to
* test runners that inspect the global object.
*
* TODO(johnlenz): Make the test framework aware of goog.module so
* that this isn't necessary. Alternately combine this with goog.setTestOnly
* to minimize boiler plate.
* @suppress {missingProvide}
*/
goog.module.declareTestMethods = function() {
 if (!goog.isInModuleLoader_()) {
   throw new Error('goog.module.declareTestMethods must be called from ' +
       'within a goog.module');
 }
 goog.moduleLoaderState_.declareTestMethods = true;
};


/**
* Provide the module's exports as a globally accessible object under the
* module's declared name.  This is intended to ease migration to goog.module
* for files that have existing usages.
* @suppress {missingProvide}
*/
goog.module.declareLegacyNamespace = function() {
 if (!COMPILED && !goog.isInModuleLoader_()) {
   throw new Error('goog.module.declareLegacyNamespace must be called from ' +
       'within a goog.module');
 }
 if (!COMPILED && !goog.moduleLoaderState_.moduleName) {
   throw Error('goog.module must be called prior to ' +
       'goog.module.declareLegacyNamespace.');
 }
 goog.moduleLoaderState_.declareLegacyNamespace = true;
};


/**
* Marks that the current file should only be used for testing, and never for
* live code in production.
*
* In the case of unit tests, the message may optionally be an exact namespace
* for the test (e.g. 'goog.stringTest'). The linter will then ignore the extra
* provide (if not explicitly defined in the code).
*
* @param {string=} opt_message Optional message to add to the error that's
*     raised when used in production code.
*/
goog.setTestOnly = function(opt_message) {
 if (goog.DISALLOW_TEST_ONLY_CODE) {
   opt_message = opt_message || '';
   throw Error('Importing test-only code into non-debug environment' +
               (opt_message ? ': ' + opt_message : '.'));
 }
};


/**
* Forward declares a symbol. This is an indication to the compiler that the
* symbol may be used in the source yet is not required and may not be provided
* in compilation.
*
* The most common usage of forward declaration is code that takes a type as a
* function parameter but does not need to require it. By forward declaring
* instead of requiring, no hard dependency is made, and (if not required
* elsewhere) the namespace may never be required and thus, not be pulled
* into the JavaScript binary. If it is required elsewhere, it will be type
* checked as normal.
*
*
* @param {string} name The namespace to forward declare in the form of
*     "goog.package.part".
*/
goog.forwardDeclare = function(name) {};


if (!COMPILED) {

 /**
  * Check if the given name has been goog.provided. This will return false for
  * names that are available only as implicit namespaces.
  * @param {string} name name of the object to look for.
  * @return {boolean} Whether the name has been provided.
  * @private
  */
 goog.isProvided_ = function(name) {
   return (name in goog.loadedModules_) ||
       (!goog.implicitNamespaces_[name] &&
           goog.isDefAndNotNull(goog.getObjectByName(name)));
 };

 /**
  * Namespaces implicitly defined by goog.provide. For example,
  * goog.provide('goog.events.Event') implicitly declares that 'goog' and
  * 'goog.events' must be namespaces.
  *
  * @type {!Object<string, (boolean|undefined)>}
  * @private
  */
 goog.implicitNamespaces_ = {'goog.module': true};

 // NOTE: We add goog.module as an implicit namespace as goog.module is defined
 // here and because the existing module package has not been moved yet out of
 // the goog.module namespace. This satisifies both the debug loader and
 // ahead-of-time dependency management.
}


/**
* Returns an object based on its fully qualified external name.  The object
* is not found if null or undefined.  If you are using a compilation pass that
* renames property names beware that using this function will not find renamed
* properties.
*
* @param {string} name The fully qualified name.
* @param {Object=} opt_obj The object within which to look; default is
*     |goog.global|.
* @return {?} The value (object or primitive) or, if not found, null.
*/
goog.getObjectByName = function(name, opt_obj) {
 var parts = name.split('.');
 var cur = opt_obj || goog.global;
 for (var part; part = parts.shift(); ) {
   if (goog.isDefAndNotNull(cur[part])) {
     cur = cur[part];
   } else {
     return null;
   }
 }
 return cur;
};


/**
* Globalizes a whole namespace, such as goog or goog.lang.
*
* @param {!Object} obj The namespace to globalize.
* @param {Object=} opt_global The object to add the properties to.
* @deprecated Properties may be explicitly exported to the global scope, but
*     this should no longer be done in bulk.
*/
goog.globalize = function(obj, opt_global) {
 var global = opt_global || goog.global;
 for (var x in obj) {
   global[x] = obj[x];
 }
};


/**
* Adds a dependency from a file to the files it requires.
* @param {string} relPath The path to the js file.
* @param {!Array<string>} provides An array of strings with
*     the names of the objects this file provides.
* @param {!Array<string>} requires An array of strings with
*     the names of the objects this file requires.
* @param {boolean=} opt_isModule Whether this dependency must be loaded as
*     a module as declared by goog.module.
*/
goog.addDependency = function(relPath, provides, requires, opt_isModule) {
 if (goog.DEPENDENCIES_ENABLED) {
   var provide, require;
   var path = relPath.replace(/\\/g, '/');
   var deps = goog.dependencies_;
   for (var i = 0; provide = provides[i]; i++) {
     deps.nameToPath[provide] = path;
     deps.pathIsModule[path] = !!opt_isModule;
   }
   for (var j = 0; require = requires[j]; j++) {
     if (!(path in deps.requires)) {
       deps.requires[path] = {};
     }
     deps.requires[path][require] = true;
   }
 }
};




// NOTE(nnaze): The debug DOM loader was included in base.js as an original way
// to do "debug-mode" development.  The dependency system can sometimes be
// confusing, as can the debug DOM loader's asynchronous nature.
//
// With the DOM loader, a call to goog.require() is not blocking -- the script
// will not load until some point after the current script.  If a namespace is
// needed at runtime, it needs to be defined in a previous script, or loaded via
// require() with its registered dependencies.
// User-defined namespaces may need their own deps file.  See http://go/js_deps,
// http://go/genjsdeps, or, externally, DepsWriter.
// https://developers.google.com/closure/library/docs/depswriter
//
// Because of legacy clients, the DOM loader can't be easily removed from
// base.js.  Work is being done to make it disableable or replaceable for
// different environments (DOM-less JavaScript interpreters like Rhino or V8,
// for example). See bootstrap/ for more information.


/**
* @define {boolean} Whether to enable the debug loader.
*
* If enabled, a call to goog.require() will attempt to load the namespace by
* appending a script tag to the DOM (if the namespace has been registered).
*
* If disabled, goog.require() will simply assert that the namespace has been
* provided (and depend on the fact that some outside tool correctly ordered
* the script).
*/
goog.define('goog.ENABLE_DEBUG_LOADER', true);


/**
* @param {string} msg
* @private
*/
goog.logToConsole_ = function(msg) {
 if (goog.global.console) {
   goog.global.console['error'](msg);
 }
};


/**
* Implements a system for the dynamic resolution of dependencies that works in
* parallel with the BUILD system. Note that all calls to goog.require will be
* stripped by the JSCompiler when the --closure_pass option is used.
* @see goog.provide
* @param {string} name Namespace to include (as was given in goog.provide()) in
*     the form "goog.package.part".
* @return {?} If called within a goog.module file, the associated namespace or
*     module otherwise null.
*/
goog.require = function(name) {

 // If the object already exists we do not need do do anything.
 if (!COMPILED) {
   if (goog.ENABLE_DEBUG_LOADER && goog.IS_OLD_IE_) {
     goog.maybeProcessDeferredDep_(name);
   }

   if (goog.isProvided_(name)) {
     if (goog.isInModuleLoader_()) {
       return goog.module.getInternal_(name);
     } else {
       return null;
     }
   }

   if (goog.ENABLE_DEBUG_LOADER) {
     var path = goog.getPathFromDeps_(name);
     if (path) {
       goog.included_[path] = true;
       goog.writeScripts_();
       return null;
     }
   }

   var errorMessage = 'goog.require could not find: ' + name;
   goog.logToConsole_(errorMessage);

   throw Error(errorMessage);
 }
};


/**
* Path for included scripts.
* @type {string}
*/
goog.basePath = '';


/**
* A hook for overriding the base path.
* @type {string|undefined}
*/
goog.global.CLOSURE_BASE_PATH;


/**
* Whether to write out Closure's deps file. By default, the deps are written.
* @type {boolean|undefined}
*/
goog.global.CLOSURE_NO_DEPS;


/**
* A function to import a single script. This is meant to be overridden when
* Closure is being run in non-HTML contexts, such as web workers. It's defined
* in the global scope so that it can be set before base.js is loaded, which
* allows deps.js to be imported properly.
*
* The function is passed the script source, which is a relative URI. It should
* return true if the script was imported, false otherwise.
* @type {(function(string): boolean)|undefined}
*/
goog.global.CLOSURE_IMPORT_SCRIPT;


/**
* Null function used for default values of callbacks, etc.
* @return {void} Nothing.
*/
goog.nullFunction = function() {};


/**
* The identity function. Returns its first argument.
*
* @param {*=} opt_returnValue The single value that will be returned.
* @param {...*} var_args Optional trailing arguments. These are ignored.
* @return {?} The first argument. We can't know the type -- just pass it along
*      without type.
* @deprecated Use goog.functions.identity instead.
*/
goog.identityFunction = function(opt_returnValue, var_args) {
 return opt_returnValue;
};


/**
* When defining a class Foo with an abstract method bar(), you can do:
* Foo.prototype.bar = goog.abstractMethod
*
* Now if a subclass of Foo fails to override bar(), an error will be thrown
* when bar() is invoked.
*
* Note: This does not take the name of the function to override as an argument
* because that would make it more difficult to obfuscate our JavaScript code.
*
* @type {!Function}
* @throws {Error} when invoked to indicate the method should be overridden.
*/
goog.abstractMethod = function() {
 throw Error('unimplemented abstract method');
};


/**
* Adds a {@code getInstance} static method that always returns the same
* instance object.
* @param {!Function} ctor The constructor for the class to add the static
*     method to.
*/
goog.addSingletonGetter = function(ctor) {
 ctor.getInstance = function() {
   if (ctor.instance_) {
     return ctor.instance_;
   }
   if (goog.DEBUG) {
     // NOTE: JSCompiler can't optimize away Array#push.
     goog.instantiatedSingletons_[goog.instantiatedSingletons_.length] = ctor;
   }
   return ctor.instance_ = new ctor;
 };
};


/**
* All singleton classes that have been instantiated, for testing. Don't read
* it directly, use the {@code goog.testing.singleton} module. The compiler
* removes this variable if unused.
* @type {!Array<!Function>}
* @private
*/
goog.instantiatedSingletons_ = [];


/**
* @define {boolean} Whether to load goog.modules using {@code eval} when using
* the debug loader.  This provides a better debugging experience as the
* source is unmodified and can be edited using Chrome Workspaces or similar.
* However in some environments the use of {@code eval} is banned
* so we provide an alternative.
*/
goog.define('goog.LOAD_MODULE_USING_EVAL', true);


/**
* @define {boolean} Whether the exports of goog.modules should be sealed when
* possible.
*/
goog.define('goog.SEAL_MODULE_EXPORTS', goog.DEBUG);


/**
* The registry of initialized modules:
* the module identifier to module exports map.
* @private @const {!Object<string, ?>}
*/
goog.loadedModules_ = {};


/**
* True if goog.dependencies_ is available.
* @const {boolean}
*/
goog.DEPENDENCIES_ENABLED = !COMPILED && goog.ENABLE_DEBUG_LOADER;


if (goog.DEPENDENCIES_ENABLED) {
 /**
  * Object used to keep track of urls that have already been added. This record
  * allows the prevention of circular dependencies.
  * @private {!Object<string, boolean>}
  */
 goog.included_ = {};


 /**
  * This object is used to keep track of dependencies and other data that is
  * used for loading scripts.
  * @private
  * @type {{
  *   pathIsModule: !Object<string, boolean>,
  *   nameToPath: !Object<string, string>,
  *   requires: !Object<string, !Object<string, boolean>>,
  *   visited: !Object<string, boolean>,
  *   written: !Object<string, boolean>,
  *   deferred: !Object<string, string>
  * }}
  */
 goog.dependencies_ = {
   pathIsModule: {}, // 1 to 1

   nameToPath: {}, // 1 to 1

   requires: {}, // 1 to many

   // Used when resolving dependencies to prevent us from visiting file twice.
   visited: {},

   written: {}, // Used to keep track of script files we have written.

   deferred: {} // Used to track deferred module evaluations in old IEs
 };


 /**
  * 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() {
   var doc = goog.global.document;
   return typeof doc != 'undefined' &&
          'write' in doc;  // XULDocument misses write.
 };


 /**
  * 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)) {
     goog.basePath = goog.global.CLOSURE_BASE_PATH;
     return;
   } else if (!goog.inHtmlDocument_()) {
     return;
   }
   var doc = goog.global.document;
   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;
     }
   }
 };


 /**
  * Imports a script if, and only if, that script hasn't already been imported.
  * (Must be called at execution time)
  * @param {string} src Script source.
  * @param {string=} opt_sourceText The optionally source text to evaluate
  * @private
  */
 goog.importScript_ = function(src, opt_sourceText) {
   var importScript = goog.global.CLOSURE_IMPORT_SCRIPT ||
       goog.writeScriptTag_;
   if (importScript(src, opt_sourceText)) {
     goog.dependencies_.written[src] = true;
   }
 };


 /** @const @private {boolean} */
 goog.IS_OLD_IE_ = !!(!goog.global.atob && goog.global.document &&
     goog.global.document.all);


 /**
  * Given a URL initiate retrieval and execution of the module.
  * @param {string} src Script source URL.
  * @private
  */
 goog.importModule_ = function(src) {
   // In an attempt to keep browsers from timing out loading scripts using
   // synchronous XHRs, put each load in its own script block.
   var bootstrap = 'goog.retrieveAndExecModule_("' + src + '");';

   if (goog.importScript_('', bootstrap)) {
     goog.dependencies_.written[src] = true;
   }
 };


 /** @private {!Array<string>} */
 goog.queuedModules_ = [];


 /**
  * Return an appropriate module text. Suitable to insert into
  * a script tag (that is unescaped).
  * @param {string} srcUrl
  * @param {string} scriptText
  * @return {string}
  * @private
  */
 goog.wrapModule_ = function(srcUrl, scriptText) {
   if (!goog.LOAD_MODULE_USING_EVAL || !goog.isDef(goog.global.JSON)) {
     return '' +
         'goog.loadModule(function(exports) {' +
         '"use strict";' +
         scriptText +
         '\n' + // terminate any trailing single line comment.
         ';return exports' +
         '});' +
         '\n//# sourceURL=' + srcUrl + '\n';
   } else {
     return '' +
         'goog.loadModule(' +
         goog.global.JSON.stringify(
             scriptText + '\n//# sourceURL=' + srcUrl + '\n') +
         ');';
   }
 };

 // On IE9 and earlier, it is necessary to handle
 // deferred module loads. In later browsers, the
 // code to be evaluated is simply inserted as a script
 // block in the correct order. To eval deferred
 // code at the right time, we piggy back on goog.require to call
 // goog.maybeProcessDeferredDep_.
 //
 // The goog.requires are used both to bootstrap
 // the loading process (when no deps are available) and
 // declare that they should be available.
 //
 // Here we eval the sources, if all the deps are available
 // either already eval'd or goog.require'd.  This will
 // be the case when all the dependencies have already
 // been loaded, and the dependent module is loaded.
 //
 // But this alone isn't sufficient because it is also
 // necessary to handle the case where there is no root
 // that is not deferred.  For that there we register for an event
 // and trigger goog.loadQueuedModules_ handle any remaining deferred
 // evaluations.

 /**
  * Handle any remaining deferred goog.module evals.
  * @private
  */
 goog.loadQueuedModules_ = function() {
   var count = goog.queuedModules_.length;
   if (count > 0) {
     var queue = goog.queuedModules_;
     goog.queuedModules_ = [];
     for (var i = 0; i < count; i++) {
       var path = queue[i];
       goog.maybeProcessDeferredPath_(path);
     }
   }
 };


 /**
  * Eval the named module if its dependencies are
  * available.
  * @param {string} name The module to load.
  * @private
  */
 goog.maybeProcessDeferredDep_ = function(name) {
   if (goog.isDeferredModule_(name) &&
       goog.allDepsAreAvailable_(name)) {
     var path = goog.getPathFromDeps_(name);
     goog.maybeProcessDeferredPath_(goog.basePath + path);
   }
 };

 /**
  * @param {string} name The module to check.
  * @return {boolean} Whether the name represents a
  *     module whose evaluation has been deferred.
  * @private
  */
 goog.isDeferredModule_ = function(name) {
   var path = goog.getPathFromDeps_(name);
   if (path && goog.dependencies_.pathIsModule[path]) {
     var abspath = goog.basePath + path;
     return (abspath) in goog.dependencies_.deferred;
   }
   return false;
 };

 /**
  * @param {string} name The module to check.
  * @return {boolean} Whether the name represents a
  *     module whose declared dependencies have all been loaded
  *     (eval'd or a deferred module load)
  * @private
  */
 goog.allDepsAreAvailable_ = function(name) {
   var path = goog.getPathFromDeps_(name);
   if (path && (path in goog.dependencies_.requires)) {
     for (var requireName in goog.dependencies_.requires[path]) {
       if (!goog.isProvided_(requireName) &&
           !goog.isDeferredModule_(requireName)) {
         return false;
       }
     }
   }
   return true;
 };


 /**
  * @param {string} abspath
  * @private
  */
 goog.maybeProcessDeferredPath_ = function(abspath) {
   if (abspath in goog.dependencies_.deferred) {
     var src = goog.dependencies_.deferred[abspath];
     delete goog.dependencies_.deferred[abspath];
     goog.globalEval(src);
   }
 };


 /**
  * @param {function(?):?|string} moduleDef The module definition.
  */
 goog.loadModule = function(moduleDef) {
   // NOTE: we allow function definitions to be either in the from
   // of a string to eval (which keeps the original source intact) or
   // in a eval forbidden environment (CSP) we allow a function definition
   // which in its body must call {@code goog.module}, and return the exports
   // of the module.
   var previousState = goog.moduleLoaderState_;
   try {
     goog.moduleLoaderState_ = {
       moduleName: undefined, declareTestMethods: false};
     var exports;
     if (goog.isFunction(moduleDef)) {
       exports = moduleDef.call(goog.global, {});
     } else if (goog.isString(moduleDef)) {
       exports = goog.loadModuleFromSource_.call(goog.global, moduleDef);
     } else {
       throw Error('Invalid module definition');
     }

     var moduleName = goog.moduleLoaderState_.moduleName;
     if (!goog.isString(moduleName) || !moduleName) {
       throw Error('Invalid module name \"' + moduleName + '\"');
     }

     // Don't seal legacy namespaces as they may be uses as a parent of
     // another namespace
     if (goog.moduleLoaderState_.declareLegacyNamespace) {
       goog.constructNamespace_(moduleName, exports);
     } else if (goog.SEAL_MODULE_EXPORTS && Object.seal) {
       Object.seal(exports);
     }

     goog.loadedModules_[moduleName] = exports;
     if (goog.moduleLoaderState_.declareTestMethods) {
       for (var entry in exports) {
         if (entry.indexOf('test', 0) === 0 ||
             entry == 'tearDown' ||
             entry == 'setUp' ||
             entry == 'setUpPage' ||
             entry == 'tearDownPage') {
           goog.global[entry] = exports[entry];
         }
       }
     }
   } finally {
     goog.moduleLoaderState_ = previousState;
   }
 };


 /**
  * @param {string} source
  * @return {!Object}
  * @private
  */
 goog.loadModuleFromSource_ = function(source) {
   // NOTE: we avoid declaring parameters or local variables here to avoid
   // masking globals or leaking values into the module definition.
   'use strict';
   var exports = {};
   eval(arguments[0]);
   return exports;
 };


 /**
  * The default implementation of the import function. Writes a script tag to
  * import the script.
  *
  * @param {string} src The script url.
  * @param {string=} opt_sourceText The optionally source text to evaluate
  * @return {boolean} True if the script was imported, false otherwise.
  * @private
  */
 goog.writeScriptTag_ = function(src, opt_sourceText) {
   if (goog.inHtmlDocument_()) {
     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.
     if (doc.readyState == 'complete') {
       // 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(src);
       if (isDeps) {
         return false;
       } else {
         throw Error('Cannot write "' + src + '" after document load');
       }
     }

     var isOldIE = goog.IS_OLD_IE_;

     if (opt_sourceText === undefined) {
       if (!isOldIE) {
         doc.write(
             '<script type="application/javascript" src="' +
                 src + '"></' + 'script>');
       } else {
         var state = " onreadystatechange='goog.onScriptLoad_(this, " +
             ++goog.lastNonModuleScriptIndex_ + ")' ";
         doc.write(
             '<script type="application/javascript" src="' +
                 src + '"' + state + '></' + 'script>');
       }
     } else {
       doc.write(
           '<script type="application/javascript">' +
           opt_sourceText +
           '</' + 'script>');
     }
     return true;
   } else {
     return false;
   }
 };


 /** @private {number} */
 goog.lastNonModuleScriptIndex_ = 0;


 /**
  * A readystatechange handler for legacy IE
  * @param {!HTMLScriptElement} script
  * @param {number} scriptIndex
  * @return {boolean}
  * @private
  */
 goog.onScriptLoad_ = function(script, scriptIndex) {
   // for now load the modules when we reach the last script,
   // later allow more inter-mingling.
   if (script.readyState == 'complete' &&
       goog.lastNonModuleScriptIndex_ == scriptIndex) {
     goog.loadQueuedModules_();
   }
   return true;
 };

 /**
  * Resolves dependencies based on the dependencies added using addDependency
  * and calls importScript_ in the correct order.
  * @private
  */
 goog.writeScripts_ = function() {
   /** @type {!Array<string>} The scripts we need to write this time. */
   var scripts = [];
   var seenScript = {};
   var deps = goog.dependencies_;

   /** @param {string} path */
   function visitNode(path) {
     if (path in deps.written) {
       return;
     }

     // We have already visited this one. We can get here if we have cyclic
     // dependencies.
     if (path in deps.visited) {
       if (!(path in seenScript)) {
         seenScript[path] = true;
         scripts.push(path);
       }
       return;
     }

     deps.visited[path] = true;

     if (path in deps.requires) {
       for (var requireName in deps.requires[path]) {
         // If the required name is defined, we assume that it was already
         // bootstrapped by other means.
         if (!goog.isProvided_(requireName)) {
           if (requireName in deps.nameToPath) {
             visitNode(deps.nameToPath[requireName]);
           } else {
             throw Error('Undefined nameToPath for ' + requireName);
           }
         }
       }
     }

     if (!(path in seenScript)) {
       seenScript[path] = true;
       scripts.push(path);
     }
   }

   for (var path in goog.included_) {
     if (!deps.written[path]) {
       visitNode(path);
     }
   }

   // record that we are going to load all these scripts.
   for (var i = 0; i < scripts.length; i++) {
     var path = scripts[i];
     goog.dependencies_.written[path] = true;
   }

   // If a module is loaded synchronously then we need to
   // clear the current inModuleLoader value, and restore it when we are
   // done loading the current "requires".
   var moduleState = goog.moduleLoaderState_;
   goog.moduleLoaderState_ = null;

   var loadingModule = false;
   for (var i = 0; i < scripts.length; i++) {
     var path = scripts[i];
     if (path) {
       if (!deps.pathIsModule[path]) {
         goog.importScript_(goog.basePath + path);
       } else {
         loadingModule = true;
         goog.importModule_(goog.basePath + path);
       }
     } else {
       goog.moduleLoaderState_ = moduleState;
       throw Error('Undefined script input');
     }
   }

   // restore the current "module loading state"
   goog.moduleLoaderState_ = moduleState;
 };


 /**
  * Looks at the dependency rules and tries to determine the script file that
  * fulfills a particular rule.
  * @param {string} rule In the form goog.namespace.Class or project.script.
  * @return {?string} Url corresponding to the rule, or null.
  * @private
  */
 goog.getPathFromDeps_ = function(rule) {
   if (rule in goog.dependencies_.nameToPath) {
     return goog.dependencies_.nameToPath[rule];
   } else {
     return null;
   }
 };

 goog.findBasePath_();

 // Allow projects to manage the deps files themselves.
 if (!goog.global.CLOSURE_NO_DEPS) {
   goog.importScript_(goog.basePath + 'deps.js');
 }
}


/**
* Normalize a file path by removing redundant ".." and extraneous "." file
* path components.
* @param {string} path
* @return {string}
* @private
*/
goog.normalizePath_ = function(path) {
 var components = path.split('/');
 var i = 0;
 while (i < components.length) {
   if (components[i] == '.') {
     components.splice(i, 1);
   } else if (i && components[i] == '..' &&
       components[i - 1] && components[i - 1] != '..') {
     components.splice(--i, 2);
   } else {
     i++;
   }
 }
 return components.join('/');
};


/**
* Retrieve and execute a module.
* @param {string} src Script source URL.
* @private
*/
goog.retrieveAndExecModule_ = function(src) {
 if (!COMPILED) {
   // The full but non-canonicalized URL for later use.
   var originalPath = src;
   // Canonicalize the path, removing any /./ or /../ since Chrome's debugging
   // console doesn't auto-canonicalize XHR loads as it does <script> srcs.
   src = goog.normalizePath_(src);

   var importScript = goog.global.CLOSURE_IMPORT_SCRIPT ||
       goog.writeScriptTag_;

   var scriptText = null;

   var xhr = new goog.global['XMLHttpRequest']();

   /** @this {Object} */
   xhr.onload = function() {
     scriptText = this.responseText;
   };
   xhr.open('get', src, false);
   xhr.send();

   scriptText = xhr.responseText;

   if (scriptText != null) {
     var execModuleScript = goog.wrapModule_(src, scriptText);
     var isOldIE = goog.IS_OLD_IE_;
     if (isOldIE) {
       goog.dependencies_.deferred[originalPath] = execModuleScript;
       goog.queuedModules_.push(originalPath);
     } else {
       importScript(src, execModuleScript);
     }
   } else {
     throw new Error('load of ' + src + 'failed');
   }
 }
};


//==============================================================================
// Language Enhancements
//==============================================================================


/**
* This is a "fixed" version of the typeof operator.  It differs from the typeof
* operator in such a way that null returns 'null' and arrays return 'array'.
* @param {*} value The value to get the type of.
* @return {string} The name of the type.
*/
goog.typeOf = function(value) {
 var s = typeof value;
 if (s == 'object') {
   if (value) {
     // Check these first, so we can avoid calling Object.prototype.toString if
     // possible.
     //
     // IE improperly marshals tyepof across execution contexts, but a
     // cross-context object will still return false for "instanceof Object".
     if (value instanceof Array) {
       return 'array';
     } else if (value instanceof Object) {
       return s;
     }

     // HACK: In order to use an Object prototype method on the arbitrary
     //   value, the compiler requires the value be cast to type Object,
     //   even though the ECMA spec explicitly allows it.
     var className = Object.prototype.toString.call(
         /** @type {Object} */ (value));
     // In Firefox 3.6, attempting to access iframe window objects' length
     // property throws an NS_ERROR_FAILURE, so we need to special-case it
     // here.
     if (className == '[object Window]') {
       return 'object';
     }

     // We cannot always use constructor == Array or instanceof Array because
     // different frames have different Array objects. In IE6, if the iframe
     // where the array was created is destroyed, the array loses its
     // prototype. Then dereferencing val.splice here throws an exception, so
     // we can't use goog.isFunction. Calling typeof directly returns 'unknown'
     // so that will work. In this case, this function will return false and
     // most array functions will still work because the array is still
     // array-like (supports length and []) even though it has lost its
     // prototype.
     // Mark Miller noticed that Object.prototype.toString
     // allows access to the unforgeable [[Class]] property.
     //  15.2.4.2 Object.prototype.toString ( )
     //  When the toString method is called, the following steps are taken:
     //      1. Get the [[Class]] property of this object.
     //      2. Compute a string value by concatenating the three strings
     //         "[object ", Result(1), and "]".
     //      3. Return Result(2).
     // and this behavior survives the destruction of the execution context.
     if ((className == '[object Array]' ||
          // In IE all non value types are wrapped as objects across window
          // boundaries (not iframe though) so we have to do object detection
          // for this edge case.
          typeof value.length == 'number' &&
          typeof value.splice != 'undefined' &&
          typeof value.propertyIsEnumerable != 'undefined' &&
          !value.propertyIsEnumerable('splice')

         )) {
       return 'array';
     }
     // HACK: There is still an array case that fails.
     //     function ArrayImpostor() {}
     //     ArrayImpostor.prototype = [];
     //     var impostor = new ArrayImpostor;
     // this can be fixed by getting rid of the fast path
     // (value instanceof Array) and solely relying on
     // (value && Object.prototype.toString.vall(value) === '[object Array]')
     // but that would require many more function calls and is not warranted
     // unless closure code is receiving objects from untrusted sources.

     // IE in cross-window calls does not correctly marshal the function type
     // (it appears just as an object) so we cannot use just typeof val ==
     // 'function'. However, if the object has a call property, it is a
     // function.
     if ((className == '[object Function]' ||
         typeof value.call != 'undefined' &&
         typeof value.propertyIsEnumerable != 'undefined' &&
         !value.propertyIsEnumerable('call'))) {
       return 'function';
     }

   } else {
     return 'null';
   }

 } else if (s == 'function' && typeof value.call == 'undefined') {
   // In Safari typeof nodeList returns 'function', and on Firefox typeof
   // behaves similarly for HTML{Applet,Embed,Object}, Elements and RegExps. We
   // would like to return object for those and we can detect an invalid
   // function by making sure that the function object has a call method.
   return 'object';
 }
 return s;
};


/**
* Returns true if the specified value is null.
* @param {?} val Variable to test.
* @return {boolean} Whether variable is null.
*/
goog.isNull = function(val) {
 return val === null;
};


/**
* Returns true if the specified value is defined and not null.
* @param {?} val Variable to test.
* @return {boolean} Whether variable is defined and not null.
*/
goog.isDefAndNotNull = function(val) {
 // Note that undefined == null.
 return val != null;
};


/**
* Returns true if the specified value is an array.
* @param {?} val Variable to test.
* @return {boolean} Whether variable is an array.
*/
goog.isArray = function(val) {
 return goog.typeOf(val) == 'array';
};


/**
* Returns true if the object looks like an array. To qualify as array like
* the value needs to be either a NodeList or an object with a Number length
* property. As a special case, a function value is not array like, because its
* length property is fixed to correspond to the number of expected arguments.
* @param {?} val Variable to test.
* @return {boolean} Whether variable is an array.
*/
goog.isArrayLike = function(val) {
 var type = goog.typeOf(val);
 // We do not use goog.isObject here in order to exclude function values.
 return type == 'array' || type == 'object' && typeof val.length == 'number';
};


/**
* Returns true if the object looks like a Date. To qualify as Date-like the
* value needs to be an object and have a getFullYear() function.
* @param {?} val Variable to test.
* @return {boolean} Whether variable is a like a Date.
*/
goog.isDateLike = function(val) {
 return goog.isObject(val) && typeof val.getFullYear == 'function';
};


/**
* Returns true if the specified value is a string.
* @param {?} val Variable to test.
* @return {boolean} Whether variable is a string.
*/
goog.isString = function(val) {
 return typeof val == 'string';
};


/**
* Returns true if the specified value is a boolean.
* @param {?} val Variable to test.
* @return {boolean} Whether variable is boolean.
*/
goog.isBoolean = function(val) {
 return typeof val == 'boolean';
};


/**
* Returns true if the specified value is a number.
* @param {?} val Variable to test.
* @return {boolean} Whether variable is a number.
*/
goog.isNumber = function(val) {
 return typeof val == 'number';
};


/**
* Returns true if the specified value is a function.
* @param {?} val Variable to test.
* @return {boolean} Whether variable is a function.
*/
goog.isFunction = function(val) {
 return goog.typeOf(val) == 'function';
};


/**
* Returns true if the specified value is an object.  This includes arrays and
* functions.
* @param {?} val Variable to test.
* @return {boolean} Whether variable is an object.
*/
goog.isObject = function(val) {
 var type = typeof val;
 return type == 'object' && val != null || type == 'function';
 // return Object(val) === val also works, but is slower, especially if val is
 // not an object.
};


/**
* Gets a unique ID for an object. This mutates the object so that further calls
* with the same object as a parameter returns the same value. The unique ID is
* guaranteed to be unique across the current session amongst objects that are
* passed into {@code getUid}. There is no guarantee that the ID is unique or
* consistent across sessions. It is unsafe to generate unique ID for function
* prototypes.
*
* @param {Object} obj The object to get the unique ID for.
* @return {number} The unique ID for the object.
*/
goog.getUid = function(obj) {
 // TODO(arv): Make the type stricter, do not accept null.

 // In Opera window.hasOwnProperty exists but always returns false so we avoid
 // using it. As a consequence the unique ID generated for BaseClass.prototype
 // and SubClass.prototype will be the same.
 return obj[goog.UID_PROPERTY_] ||
     (obj[goog.UID_PROPERTY_] = ++goog.uidCounter_);
};


/**
* Whether the given object is already assigned a unique ID.
*
* This does not modify the object.
*
* @param {!Object} obj The object to check.
* @return {boolean} Whether there is an assigned unique id for the object.
*/
goog.hasUid = function(obj) {
 return !!obj[goog.UID_PROPERTY_];
};


/**
* Removes the unique ID from an object. This is useful if the object was
* previously mutated using {@code goog.getUid} in which case the mutation is
* undone.
* @param {Object} obj The object to remove the unique ID field from.
*/
goog.removeUid = function(obj) {
 // TODO(arv): Make the type stricter, do not accept null.

 // In IE, DOM nodes are not instances of Object and throw an exception if we
 // try to delete.  Instead we try to use removeAttribute.
 if ('removeAttribute' in obj) {
   obj.removeAttribute(goog.UID_PROPERTY_);
 }
 /** @preserveTry */
 try {
   delete obj[goog.UID_PROPERTY_];
 } catch (ex) {
 }
};


/**
* Name for unique ID property. Initialized in a way to help avoid collisions
* with other closure JavaScript on the same page.
* @type {string}
* @private
*/
goog.UID_PROPERTY_ = 'closure_uid_' + ((Math.random() * 1e9) >>> 0);


/**
* Counter for UID.
* @type {number}
* @private
*/
goog.uidCounter_ = 0;


/**
* Adds a hash code field to an object. The hash code is unique for the
* given object.
* @param {Object} obj The object to get the hash code for.
* @return {number} The hash code for the object.
* @deprecated Use goog.getUid instead.
*/
goog.getHashCode = goog.getUid;


/**
* Removes the hash code field from an object.
* @param {Object} obj The object to remove the field from.
* @deprecated Use goog.removeUid instead.
*/
goog.removeHashCode = goog.removeUid;


/**
* Clones a value. The input may be an Object, Array, or basic type. Objects and
* arrays will be cloned recursively.
*
* WARNINGS:
* <code>goog.cloneObject</code> does not detect reference loops. Objects that
* refer to themselves will cause infinite recursion.
*
* <code>goog.cloneObject</code> is unaware of unique identifiers, and copies
* UIDs created by <code>getUid</code> into cloned results.
*
* @param {*} obj The value to clone.
* @return {*} A clone of the input value.
* @deprecated goog.cloneObject is unsafe. Prefer the goog.object methods.
*/
goog.cloneObject = function(obj) {
 var type = goog.typeOf(obj);
 if (type == 'object' || type == 'array') {
   if (obj.clone) {
     return obj.clone();
   }
   var clone = type == 'array' ? [] : {};
   for (var key in obj) {
     clone[key] = goog.cloneObject(obj[key]);
   }
   return clone;
 }

 return obj;
};


/**
* A native implementation of goog.bind.
* @param {Function} fn A function to partially apply.
* @param {Object|undefined} selfObj Specifies the object which this should
*     point to when the function is run.
* @param {...*} var_args Additional arguments that are partially applied to the
*     function.
* @return {!Function} A partially-applied form of the function bind() was
*     invoked as a method of.
* @private
* @suppress {deprecated} The compiler thinks that Function.prototype.bind is
*     deprecated because some people have declared a pure-JS version.
*     Only the pure-JS version is truly deprecated.
*/
goog.bindNative_ = function(fn, selfObj, var_args) {
 return /** @type {!Function} */ (fn.call.apply(fn.bind, arguments));
};


/**
* A pure-JS implementation of goog.bind.
* @param {Function} fn A function to partially apply.
* @param {Object|undefined} selfObj Specifies the object which this should
*     point to when the function is run.
* @param {...*} var_args Additional arguments that are partially applied to the
*     function.
* @return {!Function} A partially-applied form of the function bind() was
*     invoked as a method of.
* @private
*/
goog.bindJs_ = function(fn, selfObj, var_args) {
 if (!fn) {
   throw new Error();
 }

 if (arguments.length > 2) {
   var boundArgs = Array.prototype.slice.call(arguments, 2);
   return function() {
     // Prepend the bound arguments to the current arguments.
     var newArgs = Array.prototype.slice.call(arguments);
     Array.prototype.unshift.apply(newArgs, boundArgs);
     return fn.apply(selfObj, newArgs);
   };

 } else {
   return function() {
     return fn.apply(selfObj, arguments);
   };
 }
};


/**
* Partially applies this function to a particular 'this object' and zero or
* more arguments. The result is a new function with some arguments of the first
* function pre-filled and the value of this 'pre-specified'.
*
* Remaining arguments specified at call-time are appended to the pre-specified
* ones.
*
* Also see: {@link #partial}.
*
* Usage:
* <pre>var barMethBound = bind(myFunction, myObj, 'arg1', 'arg2');
* barMethBound('arg3', 'arg4');</pre>
*
* @param {?function(this:T, ...)} fn A function to partially apply.
* @param {T} selfObj Specifies the object which this should point to when the
*     function is run.
* @param {...*} var_args Additional arguments that are partially applied to the
*     function.
* @return {!Function} A partially-applied form of the function bind() was
*     invoked as a method of.
* @template T
* @suppress {deprecated} See above.
*/
goog.bind = function(fn, selfObj, var_args) {
 // TODO(nicksantos): narrow the type signature.
 if (Function.prototype.bind &&
     // NOTE(nicksantos): Somebody pulled base.js into the default Chrome
     // extension environment. This means that for Chrome extensions, they get
     // the implementation of Function.prototype.bind that calls goog.bind
     // instead of the native one. Even worse, we don't want to introduce a
     // circular dependency between goog.bind and Function.prototype.bind, so
     // we have to hack this to make sure it works correctly.
     Function.prototype.bind.toString().indexOf('native code') != -1) {
   goog.bind = goog.bindNative_;
 } else {
   goog.bind = goog.bindJs_;
 }
 return goog.bind.apply(null, arguments);
};


/**
* Like bind(), except that a 'this object' is not required. Useful when the
* target function is already bound.
*
* Usage:
* var g = partial(f, arg1, arg2);
* g(arg3, arg4);
*
* @param {Function} fn A function to partially apply.
* @param {...*} var_args Additional arguments that are partially applied to fn.
* @return {!Function} A partially-applied form of the function bind() was
*     invoked as a method of.
*/
goog.partial = function(fn, var_args) {
 var args = Array.prototype.slice.call(arguments, 1);
 return function() {
   // Clone the array (with slice()) and append additional arguments
   // to the existing arguments.
   var newArgs = args.slice();
   newArgs.push.apply(newArgs, arguments);
   return fn.apply(this, newArgs);
 };
};


/**
* Copies all the members of a source object to a target object. This method
* does not work on all browsers for all objects that contain keys such as
* toString or hasOwnProperty. Use goog.object.extend for this purpose.
* @param {Object} target Target.
* @param {Object} source Source.
*/
goog.mixin = function(target, source) {
 for (var x in source) {
   target[x] = source[x];
 }

 // For IE7 or lower, the for-in-loop does not contain any properties that are
 // not enumerable on the prototype object (for example, isPrototypeOf from
 // Object.prototype) but also it will not include 'replace' on objects that
 // extend String and change 'replace' (not that it is common for anyone to
 // extend anything except Object).
};


/**
* @return {number} An integer value representing the number of milliseconds
*     between midnight, January 1, 1970 and the current time.
*/
goog.now = (goog.TRUSTED_SITE && Date.now) || (function() {
 // Unary plus operator converts its operand to a number which in the case of
 // a date is done by calling getTime().
 return +new Date();
});


/**
* Evals JavaScript in the global scope.  In IE this uses execScript, other
* browsers use goog.global.eval. If goog.global.eval does not evaluate in the
* global scope (for example, in Safari), appends a script tag instead.
* Throws an exception if neither execScript or eval is defined.
* @param {string} script JavaScript string.
*/
goog.globalEval = function(script) {
 if (goog.global.execScript) {
   goog.global.execScript(script, 'JavaScript');
 } else if (goog.global.eval) {
   // Test to see if eval works
   if (goog.evalWorksForGlobals_ == null) {
     goog.global.eval('var _et_ = 1;');
     if (typeof goog.global['_et_'] != 'undefined') {
       delete goog.global['_et_'];
       goog.evalWorksForGlobals_ = true;
     } else {
       goog.evalWorksForGlobals_ = false;
     }
   }

   if (goog.evalWorksForGlobals_) {
     goog.global.eval(script);
   } else {
     var doc = goog.global.document;
     var scriptElt = doc.createElement('SCRIPT');
     scriptElt.type = 'application/javascript';
     scriptElt.defer = false;
     // Note(user): can't use .innerHTML since "t('<test>')" will fail and
     // .text doesn't work in Safari 2.  Therefore we append a text node.
     scriptElt.appendChild(doc.createTextNode(script));
     doc.body.appendChild(scriptElt);
     doc.body.removeChild(scriptElt);
   }
 } else {
   throw Error('goog.globalEval not available');
 }
};


/**
* Indicates whether or not we can call 'eval' directly to eval code in the
* global scope. Set to a Boolean by the first call to goog.globalEval (which
* empirically tests whether eval works for globals). @see goog.globalEval
* @type {?boolean}
* @private
*/
goog.evalWorksForGlobals_ = null;


/**
* Optional map of CSS class names to obfuscated names used with
* goog.getCssName().
* @private {!Object<string, string>|undefined}
* @see goog.setCssNameMapping
*/
goog.cssNameMapping_;


/**
* Optional obfuscation style for CSS class names. Should be set to either
* 'BY_WHOLE' or 'BY_PART' if defined.
* @type {string|undefined}
* @private
* @see goog.setCssNameMapping
*/
goog.cssNameMappingStyle_;


/**
* Handles strings that are intended to be used as CSS class names.
*
* This function works in tandem with @see goog.setCssNameMapping.
*
* Without any mapping set, the arguments are simple joined with a hyphen and
* passed through unaltered.
*
* When there is a mapping, there are two possible styles in which these
* mappings are used. In the BY_PART style, each part (i.e. in between hyphens)
* of the passed in css name is rewritten according to the map. In the BY_WHOLE
* style, the full css name is looked up in the map directly. If a rewrite is
* not specified by the map, the compiler will output a warning.
*
* When the mapping is passed to the compiler, it will replace calls to
* goog.getCssName with the strings from the mapping, e.g.
*     var x = goog.getCssName('foo');
*     var y = goog.getCssName(this.baseClass, 'active');
*  becomes:
*     var x= 'foo';
*     var y = this.baseClass + '-active';
*
* If one argument is passed it will be processed, if two are passed only the
* modifier will be processed, as it is assumed the first argument was generated
* as a result of calling goog.getCssName.
*
* @param {string} className The class name.
* @param {string=} opt_modifier A modifier to be appended to the class name.
* @return {string} The class name or the concatenation of the class name and
*     the modifier.
*/
goog.getCssName = function(className, opt_modifier) {
 var getMapping = function(cssName) {
   return goog.cssNameMapping_[cssName] || cssName;
 };

 var renameByParts = function(cssName) {
   // Remap all the parts individually.
   var parts = cssName.split('-');
   var mapped = [];
   for (var i = 0; i < parts.length; i++) {
     mapped.push(getMapping(parts[i]));
   }
   return mapped.join('-');
 };

 var rename;
 if (goog.cssNameMapping_) {
   rename = goog.cssNameMappingStyle_ == 'BY_WHOLE' ?
       getMapping : renameByParts;
 } else {
   rename = function(a) {
     return a;
   };
 }

 if (opt_modifier) {
   return className + '-' + rename(opt_modifier);
 } else {
   return rename(className);
 }
};


/**
* Sets the map to check when returning a value from goog.getCssName(). Example:
* <pre>
* goog.setCssNameMapping({
*   "goog": "a",
*   "disabled": "b",
* });
*
* var x = goog.getCssName('goog');
* // The following evaluates to: "a a-b".
* goog.getCssName('goog') + ' ' + goog.getCssName(x, 'disabled')
* </pre>
* When declared as a map of string literals to string literals, the JSCompiler
* will replace all calls to goog.getCssName() using the supplied map if the
* --closure_pass flag is set.
*
* @param {!Object} mapping A map of strings to strings where keys are possible
*     arguments to goog.getCssName() and values are the corresponding values
*     that should be returned.
* @param {string=} opt_style The style of css name mapping. There are two valid
*     options: 'BY_PART', and 'BY_WHOLE'.
* @see goog.getCssName for a description.
*/
goog.setCssNameMapping = function(mapping, opt_style) {
 goog.cssNameMapping_ = mapping;
 goog.cssNameMappingStyle_ = opt_style;
};


/**
* To use CSS renaming in compiled mode, one of the input files should have a
* call to goog.setCssNameMapping() with an object literal that the JSCompiler
* can extract and use to replace all calls to goog.getCssName(). In uncompiled
* mode, JavaScript code should be loaded before this base.js file that declares
* a global variable, CLOSURE_CSS_NAME_MAPPING, which is used below. This is
* to ensure that the mapping is loaded before any calls to goog.getCssName()
* are made in uncompiled mode.
*
* A hook for overriding the CSS name mapping.
* @type {!Object<string, string>|undefined}
*/
goog.global.CLOSURE_CSS_NAME_MAPPING;


if (!COMPILED && goog.global.CLOSURE_CSS_NAME_MAPPING) {
 // This does not call goog.setCssNameMapping() because the JSCompiler
 // requires that goog.setCssNameMapping() be called with an object literal.
 goog.cssNameMapping_ = goog.global.CLOSURE_CSS_NAME_MAPPING;
}


/**
* Gets a localized message.
*
* This function is a compiler primitive. If you give the compiler a localized
* message bundle, it will replace the string at compile-time with a localized
* version, and expand goog.getMsg call to a concatenated string.
*
* Messages must be initialized in the form:
* <code>
* var MSG_NAME = goog.getMsg('Hello {$placeholder}', {'placeholder': 'world'});
* </code>
*
* @param {string} str Translatable string, places holders in the form {$foo}.
* @param {Object<string, string>=} opt_values Maps place holder name to value.
* @return {string} message with placeholders filled.
*/
goog.getMsg = function(str, opt_values) {
 if (opt_values) {
   str = str.replace(/\{\$([^}]+)}/g, function(match, key) {
     return 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:
* <code>var x = goog.getMsgWithFallback(MSG_A, MSG_B);</code>
* 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:
* <pre>
* 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.
* </pre>
*
* @param {Function} childCtor Child class.
* @param {Function} parentCtor Parent class.
*/
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.
*/
goog.base = function(me, opt_methodName, var_args) {
 var caller = arguments.callee.caller;

 if (goog.STRICT_MODE_COMPATIBLE || (goog.DEBUG && !caller)) {
   throw Error('arguments.caller not defined.  goog.base() cannot be used ' +
               'with strict mode code. See ' +
               'http://www.ecma-international.org/ecma-262/5.1/#sec-C');
 }

 if (caller.superClass_) {
   // 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 caller.superClass_.constructor.apply(me, ctorArgs);
 }

 // 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 ctor = me.constructor;
      ctor; ctor = ctor.superClass_ && ctor.superClass_.constructor) {
   if (ctor.prototype[opt_methodName] === caller) {
     foundCaller = true;
   } else if (foundCaller) {
     return ctor.prototype[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 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) {
 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.
*/
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 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 {
*     !Object|
*     {constructor:!Function}|
*     {constructor:!Function, statics:(Object|function(Function):void)}}
* @suppress {missingProvide}
*/
goog.defineClass.ClassDescriptor;


/**
* @define {boolean} Whether the instances returned by
* goog.defineClass should be sealed when possible.
*/
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 &&
     Object.seal instanceof Function) {
   // Don't seal subclasses of unsealable-tagged legacy classes.
   if (superClass && superClass.prototype &&
       superClass.prototype[goog.UNSEALABLE_CONSTRUCTOR_PROPERTY_]) {
     return ctr;
   }
   /**
    * @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) {
       Object.seal(instance);
     }
     return instance;
   };
   return wrappedCtr;
 }
 return ctr;
};


// TODO(johnlenz): share these values with the goog.object
/**
* The names of the fields that are defined on Object.prototype.
* @type {!Array<string>}
* @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';