|undefined}\n */\ngoog.GetMsgOptions.prototype.example;\n\n/**\n * A hook for providing a custom message retrieval function to\n * augment `goog.getMsg`.\n *\n * If an object is assigned to `CLOSURE_P16N_GET_MSG` in the global scope\n * *before* base.js is loaded, `goog.getMsg` will use the function provided\n * under the key 'goog.getMsg' on this object instead of its default\n * implementation. This allows a \"p16n library\" to take over the message\n * localization process.\n *\n * The provided object is expected to have the following structure:\n * \n * {\n * 'goog.getMsg': function(string, !Object=,\n * !goog.GetMsgOptions=): string, 'declareIcuTemplate': function(string, string,\n * !Object=, !goog.GetMsgOptions=): string\n * }\n * \n *\n * Example:\n * \n * // In a script loaded *before* base.js:\n * window.CLOSURE_P16N_GET_MSG = {\n * 'goog.getMsg': function(str, opt_values, opt_options) {\n * // Custom logic to fetch and format the message from a p16n system.\n * // 'str' is the original message string.\n * // 'opt_values' is the placeholder map.\n * // 'opt_options' are options like html/unescapeHtmlEntities.\n * return p16nLibrary.getLocalizedMessage(str, opt_values, opt_options);\n * },\n * 'declareIcuTemplate': function(templateString, name, opt_values,\n * opt_options) {\n * // Custom logic to declare an ICU template.\n * return p16nLibrary.declareIcuTemplate(templateString, name, opt_values,\n * opt_options);\n * }\n * };\n * \n *\n *\n * @type {({\n * 'goog.getMsg': (function(string, !Object=,\n * !goog.GetMsgOptions=): string), 'declareIcuTemplate': (function(string,\n * string, !Object=, !goog.GetMsgOptions=): string)\n * }|undefined)}\n */\ngoog.global.CLOSURE_P16N_GET_MSG;\n\n/**\n * @define {boolean} Whether to use the global CLOSURE_P16N_GET_MSG override for\n * goog.getMsg.\n */\ngoog.USE_GET_MSG_OVERRIDE = goog.define('goog.USE_GET_MSG_OVERRIDE', false);\n\n/**\n * Gets a localized message.\n *\n * This function is a compiler primitive. If you give the compiler a localized\n * message bundle, it will replace the string at compile-time with a localized\n * version, and expand goog.getMsg call to a concatenated string.\n *\n * Messages must be initialized in the form:\n * \n * var MSG_NAME = goog.getMsg('Hello {$placeholder}', {'placeholder': 'world'});\n * \n *\n * This function produces a string which should be treated as plain text. Use\n * {@link goog.html.SafeHtmlFormatter} in conjunction with goog.getMsg to\n * produce SafeHtml.\n *\n * @param {string} str Translatable string, places holders in the form {$foo}.\n * @param {!Object=} opt_values Maps place holder name to value.\n * @param {!goog.GetMsgOptions=} opt_options see `goog.GetMsgOptions`\n * @return {string} message with placeholders filled.\n */\ngoog.getMsg = function(str, opt_values, opt_options) {\n if (goog.USE_GET_MSG_OVERRIDE && !COMPILED) {\n if (goog.global.CLOSURE_P16N_GET_MSG &&\n goog.global.CLOSURE_P16N_GET_MSG['goog.getMsg'] != undefined) {\n str = goog.global.CLOSURE_P16N_GET_MSG['goog.getMsg'](\n str, opt_values, opt_options);\n } else {\n throw new Error('Closure p16n getMsg override is not available.');\n }\n }\n if (opt_options && opt_options.html) {\n // Note that '&' is not replaced because the translation can contain HTML\n // entities.\n str = str.replace(/')\n .replace(/'/g, '\\'')\n .replace(/"/g, '\"')\n .replace(/&/g, '&');\n }\n if (opt_values) {\n str = str.replace(/\\{\\$([^}]+)}/g, function(match, key) {\n return (opt_values != null && key in opt_values) ? opt_values[key] :\n match;\n });\n }\n return str;\n};\n\n\n/**\n * Gets a localized message. If the message does not have a translation, gives a\n * fallback message.\n *\n * This is useful when introducing a new message that has not yet been\n * translated into all languages.\n *\n * This function is a compiler primitive. Must be used in the form:\n * var x = goog.getMsgWithFallback(MSG_A, MSG_B);\n * where MSG_A and MSG_B were initialized with goog.getMsg.\n *\n * @param {string} a The preferred message.\n * @param {string} b The fallback message.\n * @return {string} The best translated message.\n */\ngoog.getMsgWithFallback = function(a, b) {\n return a;\n};\n\n\n/**\n * Exposes an unobfuscated global namespace path for the given object.\n * Note that fields of the exported object *will* be obfuscated, unless they are\n * exported in turn via this function or goog.exportProperty.\n *\n * Also handy for making public items that are defined in anonymous closures.\n *\n * ex. goog.exportSymbol('public.path.Foo', Foo);\n *\n * ex. goog.exportSymbol('public.path.Foo.staticFunction', Foo.staticFunction);\n * public.path.Foo.staticFunction();\n *\n * ex. goog.exportSymbol('public.path.Foo.prototype.myMethod',\n * Foo.prototype.myMethod);\n * new public.path.Foo().myMethod();\n *\n * @param {string} publicPath Unobfuscated name to export.\n * @param {*} object Object the name should point to.\n * @param {?Object=} objectToExportTo The object to add the path to; default\n * is goog.global.\n */\ngoog.exportSymbol = function(publicPath, object, objectToExportTo) {\n goog.exportPath_(\n publicPath, object, /* overwriteImplicit= */ true, objectToExportTo);\n};\n\n\n/**\n * Exports a property unobfuscated into the object's namespace.\n * ex. goog.exportProperty(Foo, 'staticFunction', Foo.staticFunction);\n * ex. goog.exportProperty(Foo.prototype, 'myMethod', Foo.prototype.myMethod);\n * @param {Object} object Object whose static property is being exported.\n * @param {string} publicName Unobfuscated name to export.\n * @param {*} symbol Object the name should point to.\n */\ngoog.exportProperty = function(object, publicName, symbol) {\n object[publicName] = symbol;\n};\n\n\n/**\n * Returns the value of a given name, or undefined if there are no other\n * references to the name.\n *\n * This function is evaluated statically, at compile time, as long as the\n * appropriate compiler passes are enabled. If these compiler passes are not\n * enabled, the function is a no-op, and will just return its argument\n * unmodified.\n *\n * Usage:\n * \n * // If there are other references to `x`, `xOrUndefined` will be `x`.\n * // Otherwise, `xOrUndefined` will be `undefined`.\n * var xOrUndefined = goog.weakUsage(x);\n *
\n *\n * It is an error to call `goog.weakUsage` with an argument that is not a name.\n *\n * @param {T} name A symbol name to reference weakly.\n * @return {T|undefined} The object or undefined.\n * @template T\n * @noinline\n */\ngoog.weakUsage = function(name) {\n return name;\n};\n\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * Usage:\n * \n * function ParentClass(a, b) { }\n * ParentClass.prototype.foo = function(a) { };\n *\n * function ChildClass(a, b, c) {\n * ChildClass.base(this, 'constructor', a, b);\n * }\n * goog.inherits(ChildClass, ParentClass);\n *\n * var child = new ChildClass('a', 'b', 'see');\n * child.foo(); // This works.\n * \n *\n * @param {!Function} childCtor Child class.\n * @param {!Function} parentCtor Parent class.\n * @suppress {strictMissingProperties} superClass_ and base is not defined on\n * Function.\n * @deprecated Use ECMAScript class syntax instead.\n */\ngoog.inherits = function(childCtor, parentCtor) {\n /** @constructor */\n function tempCtor() {}\n tempCtor.prototype = parentCtor.prototype;\n childCtor.superClass_ = parentCtor.prototype;\n childCtor.prototype = new tempCtor();\n /** @override */\n childCtor.prototype.constructor = childCtor;\n\n /**\n * Calls superclass constructor/method.\n *\n * This function is only available if you use goog.inherits to\n * express inheritance relationships between classes.\n *\n * NOTE: This is a replacement for goog.base and for superClass_\n * property defined in childCtor.\n *\n * @param {!Object} me Should always be \"this\".\n * @param {string} methodName The method name to call. Calling\n * superclass constructor can be done with the special string\n * 'constructor'.\n * @param {...*} var_args The arguments to pass to superclass\n * method/constructor.\n * @return {*} The return value of the superclass method/constructor.\n */\n childCtor.base = function(me, methodName, var_args) {\n // Copying using loop to avoid deop due to passing arguments object to\n // function. This is faster in many JS engines as of late 2014.\n var args = new Array(arguments.length - 2);\n for (var i = 2; i < arguments.length; i++) {\n args[i - 2] = arguments[i];\n }\n return parentCtor.prototype[methodName].apply(me, args);\n };\n};\n\n\n/**\n * Allow for aliasing within scope functions. This function exists for\n * uncompiled code - in compiled code the calls will be inlined and the aliases\n * applied. In uncompiled code the function is simply run since the aliases as\n * written are valid JavaScript.\n *\n * MOE:begin_intracomment_strip\n * See the goog.scope document at http://go/goog.scope\n *\n * For more on goog.scope deprecation, see the style guide entry:\n * http://go/jsstyle#appendices-legacy-exceptions-goog-scope\n * MOE:end_intracomment_strip\n *\n * @param {function()} fn Function to call. This function can contain aliases\n * to namespaces (e.g. \"var dom = goog.dom\") or classes\n * (e.g. \"var Timer = goog.Timer\").\n * @deprecated Use goog.module instead.\n */\ngoog.scope = function(fn) {\n if (goog.isInModuleLoader_()) {\n throw new Error('goog.scope is not supported within a module.');\n }\n fn.call(goog.global);\n};\n\n\n/*\n * To support uncompiled, strict mode bundles that use eval to divide source\n * like so:\n * eval('someSource;//# sourceUrl sourcefile.js');\n * We need to export the globally defined symbols \"goog\" and \"COMPILED\".\n * Exporting \"goog\" breaks the compiler optimizations, so we required that\n * be defined externally.\n * NOTE: We don't use goog.exportSymbol here because we don't want to trigger\n * extern generation when that compiler option is enabled.\n */\nif (!COMPILED) {\n goog.LEGACY_NAMESPACE_OBJECT_['COMPILED'] = COMPILED;\n}\n\n/**\n * Returns the parameter.\n * @param {string} s\n * @return {string}\n * @private\n */\ngoog.identity_ = function(s) {\n return s;\n};\n\n\n/**\n * Creates Trusted Types policy if Trusted Types are supported by the browser.\n * The policy just blesses any string as a Trusted Type. It is not visibility\n * restricted because anyone can also call trustedTypes.createPolicy directly.\n * However, the allowed names should be restricted by a HTTP header and the\n * reference to the created policy should be visibility restricted.\n * @param {string} name\n * @return {?TrustedTypePolicy}\n */\ngoog.createTrustedTypesPolicy = function(name) {\n var policy = null;\n var policyFactory = goog.global.trustedTypes;\n if (!policyFactory || !policyFactory.createPolicy) {\n return policy;\n }\n // trustedTypes.createPolicy throws if called with a name that is already\n // registered, even in report-only mode. Until the API changes, catch the\n // error not to break the applications functionally. In such case, the code\n // will fall back to using regular Safe Types.\n // TODO(koto): Remove catching once createPolicy API stops throwing.\n try {\n policy = policyFactory.createPolicy(name, {\n createHTML: goog.identity_,\n createScript: goog.identity_,\n createScriptURL: goog.identity_\n });\n } catch (e) {\n goog.logToConsole_(e.message);\n }\n return policy;\n};\n\n// There's a bug in the compiler where without collapse properties the\n// Closure namespace defines do not guard code correctly. To help reduce code\n// size also check for !COMPILED even though it redundant until this is fixed.\nif (!COMPILED && goog.DEPENDENCIES_ENABLED) {\n // MOE:begin_strip\n // TODO(b/67050526) This object is obsolete but some people are relying on\n // it internally. Keep it around until we migrate them.\n /**\n * @private\n * @type {{\n * loadFlags: !Object>,\n * nameToPath: !Object,\n * requires: !Object>,\n * visited: !Object,\n * written: !Object,\n * deferred: !Object\n * }}\n */\n goog.dependencies_ = {\n loadFlags: {}, // 1 to 1\n\n nameToPath: {}, // 1 to 1\n\n requires: {}, // 1 to many\n\n // Used when resolving dependencies to prevent us from visiting file\n // twice.\n visited: {},\n\n written: {}, // Used to keep track of script files we have written.\n\n deferred: {} // Used to track deferred module evaluations in old IEs\n };\n\n /**\n * @return {!Object}\n * @private\n */\n goog.getLoader_ = function() {\n return {\n dependencies_: goog.dependencies_,\n writeScriptTag_: goog.writeScriptTag_\n };\n };\n\n\n /**\n * @param {string} src The script url.\n * @param {string=} opt_sourceText The optionally source text to evaluate\n * @return {boolean} True if the script was imported, false otherwise.\n * @private\n */\n goog.writeScriptTag_ = function(src, opt_sourceText) {\n if (goog.inHtmlDocument_()) {\n /** @type {!HTMLDocument} */\n var doc = goog.global.document;\n\n // If the user tries to require a new symbol after document load,\n // something has gone terribly wrong. Doing a document.write would\n // wipe out the page. This does not apply to the CSP-compliant method\n // of writing script tags.\n if (!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING &&\n doc.readyState == 'complete') {\n // Certain test frameworks load base.js multiple times, which tries\n // to write deps.js each time. If that happens, just fail silently.\n // These frameworks wipe the page between each load of base.js, so this\n // is OK.\n var isDeps = /\\bdeps.js$/.test(src);\n if (isDeps) {\n return false;\n } else {\n throw Error('Cannot write \"' + src + '\" after document load');\n }\n }\n\n var nonceAttr = '';\n var nonce = goog.getScriptNonce_();\n if (nonce) {\n nonceAttr = ' nonce=\"' + nonce + '\"';\n }\n\n if (opt_sourceText === undefined) {\n var script = '