|undefined}
+ */
+goog.GetMsgOptions.prototype.example;
+
+/**
+ * A hook for providing a custom message retrieval function to
+ * augment `goog.getMsg`.
+ *
+ * If an object is assigned to `CLOSURE_P16N_GET_MSG` in the global scope
+ * *before* base.js is loaded, `goog.getMsg` will use the function provided
+ * under the key 'goog.getMsg' on this object instead of its default
+ * implementation. This allows a "p16n library" to take over the message
+ * localization process.
+ *
+ * The provided object is expected to have the following structure:
+ *
+ * {
+ * 'goog.getMsg': function(string, !Object=,
+ * !goog.GetMsgOptions=): string, 'declareIcuTemplate': function(string, string,
+ * !Object=, !goog.GetMsgOptions=): string
+ * }
+ *
+ *
+ * Example:
+ *
+ * // In a script loaded *before* base.js:
+ * window.CLOSURE_P16N_GET_MSG = {
+ * 'goog.getMsg': function(str, opt_values, opt_options) {
+ * // Custom logic to fetch and format the message from a p16n system.
+ * // 'str' is the original message string.
+ * // 'opt_values' is the placeholder map.
+ * // 'opt_options' are options like html/unescapeHtmlEntities.
+ * return p16nLibrary.getLocalizedMessage(str, opt_values, opt_options);
+ * },
+ * 'declareIcuTemplate': function(templateString, name, opt_values,
+ * opt_options) {
+ * // Custom logic to declare an ICU template.
+ * return p16nLibrary.declareIcuTemplate(templateString, name, opt_values,
+ * opt_options);
+ * }
+ * };
+ *
+ *
+ *
+ * @type {({
+ * 'goog.getMsg': (function(string, !Object=,
+ * !goog.GetMsgOptions=): string), 'declareIcuTemplate': (function(string,
+ * string, !Object=, !goog.GetMsgOptions=): string)
+ * }|undefined)}
+ */
+goog.global.CLOSURE_P16N_GET_MSG;
+
+/**
+ * @define {boolean} Whether to use the global CLOSURE_P16N_GET_MSG override for
+ * goog.getMsg.
+ */
+goog.USE_GET_MSG_OVERRIDE = goog.define('goog.USE_GET_MSG_OVERRIDE', false);
+
+/**
+ * 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:
+ *
+ * var MSG_NAME = goog.getMsg('Hello {$placeholder}', {'placeholder': 'world'});
+ *
+ *
+ * This function produces a string which should be treated as plain text. Use
+ * {@link goog.html.SafeHtmlFormatter} in conjunction with goog.getMsg to
+ * produce SafeHtml.
+ *
+ * @param {string} str Translatable string, places holders in the form {$foo}.
+ * @param {!Object=} opt_values Maps place holder name to value.
+ * @param {!goog.GetMsgOptions=} opt_options see `goog.GetMsgOptions`
+ * @return {string} message with placeholders filled.
+ */
+goog.getMsg = function(str, opt_values, opt_options) {
+ if (goog.USE_GET_MSG_OVERRIDE && !COMPILED) {
+ if (goog.global.CLOSURE_P16N_GET_MSG &&
+ goog.global.CLOSURE_P16N_GET_MSG['goog.getMsg'] != undefined) {
+ str = goog.global.CLOSURE_P16N_GET_MSG['goog.getMsg'](
+ str, opt_values, opt_options);
+ } else {
+ throw new Error('Closure p16n getMsg override is not available.');
+ }
+ }
+ if (opt_options && opt_options.html) {
+ // Note that '&' is not replaced because the translation can contain HTML
+ // entities.
+ str = str.replace(/')
+ .replace(/'/g, '\'')
+ .replace(/"/g, '"')
+ .replace(/&/g, '&');
+ }
+ if (opt_values) {
+ str = str.replace(/\{\$([^}]+)}/g, function(match, key) {
+ return (opt_values != null && key in opt_values) ? opt_values[key] :
+ match;
+ });
+ }
+ return str;
+};
+
+
+/**
+ * Gets a localized message. If the message does not have a translation, gives a
+ * fallback message.
+ *
+ * This is useful when introducing a new message that has not yet been
+ * translated into all languages.
+ *
+ * This function is a compiler primitive. Must be used in the form:
+ * var x = goog.getMsgWithFallback(MSG_A, MSG_B);
+ * where MSG_A and MSG_B were initialized with goog.getMsg.
+ *
+ * @param {string} a The preferred message.
+ * @param {string} b The fallback message.
+ * @return {string} The best translated message.
+ */
+goog.getMsgWithFallback = function(a, b) {
+ return a;
+};
+
+
+/**
+ * Exposes an unobfuscated global namespace path for the given object.
+ * Note that fields of the exported object *will* be obfuscated, unless they are
+ * exported in turn via this function or goog.exportProperty.
+ *
+ * Also handy for making public items that are defined in anonymous closures.
+ *
+ * ex. goog.exportSymbol('public.path.Foo', Foo);
+ *
+ * ex. goog.exportSymbol('public.path.Foo.staticFunction', Foo.staticFunction);
+ * public.path.Foo.staticFunction();
+ *
+ * ex. goog.exportSymbol('public.path.Foo.prototype.myMethod',
+ * Foo.prototype.myMethod);
+ * new public.path.Foo().myMethod();
+ *
+ * @param {string} publicPath Unobfuscated name to export.
+ * @param {*} object Object the name should point to.
+ * @param {?Object=} objectToExportTo The object to add the path to; default
+ * is goog.global.
+ */
+goog.exportSymbol = function(publicPath, object, objectToExportTo) {
+ goog.exportPath_(
+ publicPath, object, /* overwriteImplicit= */ true, objectToExportTo);
+};
+
+
+/**
+ * Exports a property unobfuscated into the object's namespace.
+ * ex. goog.exportProperty(Foo, 'staticFunction', Foo.staticFunction);
+ * ex. goog.exportProperty(Foo.prototype, 'myMethod', Foo.prototype.myMethod);
+ * @param {Object} object Object whose static property is being exported.
+ * @param {string} publicName Unobfuscated name to export.
+ * @param {*} symbol Object the name should point to.
+ */
+goog.exportProperty = function(object, publicName, symbol) {
+ object[publicName] = symbol;
+};
+
+
+/**
+ * Returns the value of a given name, or undefined if there are no other
+ * references to the name.
+ *
+ * This function is evaluated statically, at compile time, as long as the
+ * appropriate compiler passes are enabled. If these compiler passes are not
+ * enabled, the function is a no-op, and will just return its argument
+ * unmodified.
+ *
+ * Usage:
+ *
+ * // If there are other references to `x`, `xOrUndefined` will be `x`.
+ * // Otherwise, `xOrUndefined` will be `undefined`.
+ * var xOrUndefined = goog.weakUsage(x);
+ *
+ *
+ * It is an error to call `goog.weakUsage` with an argument that is not a name.
+ *
+ * @param {T} name A symbol name to reference weakly.
+ * @return {T|undefined} The object or undefined.
+ * @template T
+ * @noinline
+ */
+goog.weakUsage = function(name) {
+ return name;
+};
+
+
+/**
+ * Inherit the prototype methods from one constructor into another.
+ *
+ * Usage:
+ *
+ * function ParentClass(a, b) { }
+ * ParentClass.prototype.foo = function(a) { };
+ *
+ * function ChildClass(a, b, c) {
+ * ChildClass.base(this, 'constructor', a, b);
+ * }
+ * goog.inherits(ChildClass, ParentClass);
+ *
+ * var child = new ChildClass('a', 'b', 'see');
+ * child.foo(); // This works.
+ *
+ *
+ * @param {!Function} childCtor Child class.
+ * @param {!Function} parentCtor Parent class.
+ * @suppress {strictMissingProperties} superClass_ and base is not defined on
+ * Function.
+ * @deprecated Use ECMAScript class syntax instead.
+ */
+goog.inherits = function(childCtor, parentCtor) {
+ /** @constructor */
+ function tempCtor() {}
+ tempCtor.prototype = parentCtor.prototype;
+ childCtor.superClass_ = parentCtor.prototype;
+ childCtor.prototype = new tempCtor();
+ /** @override */
+ childCtor.prototype.constructor = childCtor;
+
+ /**
+ * Calls superclass constructor/method.
+ *
+ * This function is only available if you use goog.inherits to
+ * express inheritance relationships between classes.
+ *
+ * NOTE: This is a replacement for goog.base and for superClass_
+ * property defined in childCtor.
+ *
+ * @param {!Object} me Should always be "this".
+ * @param {string} methodName The method name to call. Calling
+ * superclass constructor can be done with the special string
+ * 'constructor'.
+ * @param {...*} var_args The arguments to pass to superclass
+ * method/constructor.
+ * @return {*} The return value of the superclass method/constructor.
+ */
+ childCtor.base = function(me, methodName, var_args) {
+ // Copying using loop to avoid deop due to passing arguments object to
+ // function. This is faster in many JS engines as of late 2014.
+ var args = new Array(arguments.length - 2);
+ for (var i = 2; i < arguments.length; i++) {
+ args[i - 2] = arguments[i];
}
- function findToken(str, token) {
- let ind = 0;
- for (let i = 0; i < str.length; i++) {
- if (str[i] === token) ind++;
- }
- return ind;
- }
- function removeDotSegments(path4) {
- let input = path4;
- const output = [];
- let nextSlash = -1;
- let len = 0;
- while (len = input.length) {
- if (len === 1) {
- if (input === ".") {
- break;
- } else if (input === "/") {
- output.push("/");
- break;
- } else {
- output.push(input);
- break;
- }
- } else if (len === 2) {
- if (input[0] === ".") {
- if (input[1] === ".") {
- break;
- } else if (input[1] === "/") {
- input = input.slice(2);
- continue;
- }
- } else if (input[0] === "/") {
- if (input[1] === "." || input[1] === "/") {
- output.push("/");
- break;
- }
- }
- } else if (len === 3) {
- if (input === "/..") {
- if (output.length !== 0) {
- output.pop();
- }
- output.push("/");
- break;
- }
- }
- if (input[0] === ".") {
- if (input[1] === ".") {
- if (input[2] === "/") {
- input = input.slice(3);
- continue;
- }
- } else if (input[1] === "/") {
- input = input.slice(2);
- continue;
- }
- } else if (input[0] === "/") {
- if (input[1] === ".") {
- if (input[2] === "/") {
- input = input.slice(2);
- continue;
- } else if (input[2] === ".") {
- if (input[3] === "/") {
- input = input.slice(3);
- if (output.length !== 0) {
- output.pop();
- }
- continue;
- }
- }
- }
- }
- if ((nextSlash = input.indexOf("/", 1)) === -1) {
- output.push(input);
- break;
- } else {
- output.push(input.slice(0, nextSlash));
- input = input.slice(nextSlash);
- }
- }
- return output.join("");
- }
- var HOST_DELIMS = { "@": "%40", "/": "%2F", "?": "%3F", "#": "%23", ":": "%3A" };
- var HOST_DELIM_RE = /[@/?#:]/g;
- var HOST_DELIM_NO_COLON_RE = /[@/?#]/g;
- function reescapeHostDelimiters(host, isIP) {
- const re = isIP ? HOST_DELIM_NO_COLON_RE : HOST_DELIM_RE;
- re.lastIndex = 0;
- return host.replace(re, (ch) => HOST_DELIMS[ch]);
- }
- function normalizePercentEncoding(input, decodeUnreserved = false) {
- if (input.indexOf("%") === -1) {
- return input;
- }
- let output = "";
- for (let i = 0; i < input.length; i++) {
- if (input[i] === "%" && i + 2 < input.length) {
- const hex3 = input.slice(i + 1, i + 3);
- if (isHexPair(hex3)) {
- const normalizedHex = hex3.toUpperCase();
- const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
- if (decodeUnreserved && isUnreserved(decoded)) {
- output += decoded;
- } else {
- output += "%" + normalizedHex;
- }
- i += 2;
- continue;
- }
- }
- output += input[i];
- }
- return output;
- }
- function normalizePathEncoding(input) {
- let output = "";
- for (let i = 0; i < input.length; i++) {
- if (input[i] === "%" && i + 2 < input.length) {
- const hex3 = input.slice(i + 1, i + 3);
- if (isHexPair(hex3)) {
- const normalizedHex = hex3.toUpperCase();
- const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
- if (decoded !== "." && isUnreserved(decoded)) {
- output += decoded;
- } else {
- output += "%" + normalizedHex;
- }
- i += 2;
- continue;
- }
- }
- if (isPathCharacter(input[i])) {
- output += input[i];
+ return parentCtor.prototype[methodName].apply(me, args);
+ };
+};
+
+
+/**
+ * Allow for aliasing within scope functions. This function exists for
+ * uncompiled code - in compiled code the calls will be inlined and the aliases
+ * applied. In uncompiled code the function is simply run since the aliases as
+ * written are valid JavaScript.
+ *
+ * MOE:begin_intracomment_strip
+ * See the goog.scope document at http://go/goog.scope
+ *
+ * For more on goog.scope deprecation, see the style guide entry:
+ * http://go/jsstyle#appendices-legacy-exceptions-goog-scope
+ * MOE:end_intracomment_strip
+ *
+ * @param {function()} fn Function to call. This function can contain aliases
+ * to namespaces (e.g. "var dom = goog.dom") or classes
+ * (e.g. "var Timer = goog.Timer").
+ * @deprecated Use goog.module instead.
+ */
+goog.scope = function(fn) {
+ if (goog.isInModuleLoader_()) {
+ throw new Error('goog.scope is not supported within a module.');
+ }
+ fn.call(goog.global);
+};
+
+
+/*
+ * To support uncompiled, strict mode bundles that use eval to divide source
+ * like so:
+ * eval('someSource;//# sourceUrl sourcefile.js');
+ * We need to export the globally defined symbols "goog" and "COMPILED".
+ * Exporting "goog" breaks the compiler optimizations, so we required that
+ * be defined externally.
+ * NOTE: We don't use goog.exportSymbol here because we don't want to trigger
+ * extern generation when that compiler option is enabled.
+ */
+if (!COMPILED) {
+ goog.LEGACY_NAMESPACE_OBJECT_['COMPILED'] = COMPILED;
+}
+
+/**
+ * Returns the parameter.
+ * @param {string} s
+ * @return {string}
+ * @private
+ */
+goog.identity_ = function(s) {
+ return s;
+};
+
+
+/**
+ * Creates Trusted Types policy if Trusted Types are supported by the browser.
+ * The policy just blesses any string as a Trusted Type. It is not visibility
+ * restricted because anyone can also call trustedTypes.createPolicy directly.
+ * However, the allowed names should be restricted by a HTTP header and the
+ * reference to the created policy should be visibility restricted.
+ * @param {string} name
+ * @return {?TrustedTypePolicy}
+ */
+goog.createTrustedTypesPolicy = function(name) {
+ var policy = null;
+ var policyFactory = goog.global.trustedTypes;
+ if (!policyFactory || !policyFactory.createPolicy) {
+ return policy;
+ }
+ // trustedTypes.createPolicy throws if called with a name that is already
+ // registered, even in report-only mode. Until the API changes, catch the
+ // error not to break the applications functionally. In such case, the code
+ // will fall back to using regular Safe Types.
+ // TODO: Remove catching once createPolicy API stops throwing.
+ try {
+ policy = policyFactory.createPolicy(name, {
+ createHTML: goog.identity_,
+ createScript: goog.identity_,
+ createScriptURL: goog.identity_
+ });
+ } catch (e) {
+ goog.logToConsole_(e.message);
+ }
+ return policy;
+};
+
+// There's a bug in the compiler where without collapse properties the
+// Closure namespace defines do not guard code correctly. To help reduce code
+// size also check for !COMPILED even though it redundant until this is fixed.
+if (!COMPILED && goog.DEPENDENCIES_ENABLED) {
+ // MOE:begin_strip
+ // TODO This object is obsolete but some people are relying on
+ // it internally. Keep it around until we migrate them.
+ /**
+ * @private
+ * @type {{
+ * loadFlags: !Object>,
+ * nameToPath: !Object,
+ * requires: !Object>,
+ * visited: !Object,
+ * written: !Object,
+ * deferred: !Object
+ * }}
+ */
+ goog.dependencies_ = {
+ loadFlags: {}, // 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
+ };
+
+ /**
+ * @return {!Object}
+ * @private
+ */
+ goog.getLoader_ = function() {
+ return {
+ dependencies_: goog.dependencies_,
+ writeScriptTag_: goog.writeScriptTag_
+ };
+ };
+
+
+ /**
+ * @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_()) {
+ /** @type {!HTMLDocument} */
+ var doc = goog.global.document;
+
+ // If the user tries to require a new symbol after document load,
+ // something has gone terribly wrong. Doing a document.write would
+ // wipe out the page. This does not apply to the CSP-compliant method
+ // of writing script tags.
+ if (!goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING &&
+ 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 {
- output += escape(input[i]);
- }
- }
- return output;
- }
- function escapePreservingEscapes(input) {
- let output = "";
- for (let i = 0; i < input.length; i++) {
- if (input[i] === "%" && i + 2 < input.length) {
- const hex3 = input.slice(i + 1, i + 3);
- if (isHexPair(hex3)) {
- output += "%" + hex3.toUpperCase();
- i += 2;
- continue;
- }
- }
- output += escape(input[i]);
- }
- return output;
- }
- function recomposeAuthority(component) {
- const uriTokens = [];
- if (component.userinfo !== void 0) {
- uriTokens.push(component.userinfo);
- uriTokens.push("@");
- }
- if (component.host !== void 0) {
- let host = unescape(component.host);
- if (!isIPv4(host)) {
- const ipV6res = normalizeIPv6(host);
- if (ipV6res.isIPV6 === true) {
- host = `[${ipV6res.escapedHost}]`;
- } else {
- host = reescapeHostDelimiters(host, false);
- }
+ throw Error('Cannot write "' + src + '" after document load');
}
- uriTokens.push(host);
}
- if (typeof component.port === "number" || typeof component.port === "string") {
- uriTokens.push(":");
- uriTokens.push(String(component.port));
+
+ var nonceAttr = '';
+ var nonce = goog.getScriptNonce_();
+ if (nonce) {
+ nonceAttr = ' nonce="' + nonce + '"';
}
- return uriTokens.length ? uriTokens.join("") : void 0;
- }
- module.exports = {
- nonSimpleDomain,
- recomposeAuthority,
- reescapeHostDelimiters,
- normalizePercentEncoding,
- normalizePathEncoding,
- escapePreservingEscapes,
- removeDotSegments,
- isIPv4,
- isUUID,
- normalizeIPv6,
- stringArrayToHexStripped
- };
- }
-});
-// node_modules/fast-uri/lib/schemes.js
-var require_schemes = __commonJS({
- "node_modules/fast-uri/lib/schemes.js"(exports, module) {
- "use strict";
- var { isUUID } = require_utils();
- var URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
- var supportedSchemeNames = (
- /** @type {const} */
- [
- "http",
- "https",
- "ws",
- "wss",
- "urn",
- "urn:uuid"
- ]
- );
- function isValidSchemeName(name) {
- return supportedSchemeNames.indexOf(
- /** @type {*} */
- name
- ) !== -1;
- }
- function wsIsSecure(wsComponent) {
- if (wsComponent.secure === true) {
- return true;
- } else if (wsComponent.secure === false) {
- return false;
- } else if (wsComponent.scheme) {
- return wsComponent.scheme.length === 3 && (wsComponent.scheme[0] === "w" || wsComponent.scheme[0] === "W") && (wsComponent.scheme[1] === "s" || wsComponent.scheme[1] === "S") && (wsComponent.scheme[2] === "s" || wsComponent.scheme[2] === "S");
+ if (opt_sourceText === undefined) {
+ var script = '