mini-program-cljs/.shadow-cljs/builds/node-repl/dev/goog-js/goog.string.internal.js

["^ ","~:resource-id",["~:shadow.build.classpath/resource","goog/string/internal.js"],"~:js","goog.provide(\"goog.string.internal\");\n/**\n * @param {string} str\n * @param {string} prefix\n * @return {boolean}\n */\ngoog.string.internal.startsWith = function(str, prefix) {\n  return str.lastIndexOf(prefix, 0) == 0;\n};\n/**\n * @param {string} str\n * @param {string} suffix\n * @return {boolean}\n */\ngoog.string.internal.endsWith = function(str, suffix) {\n  /** @const */ var l = str.length - suffix.length;\n  return l >= 0 && str.indexOf(suffix, l) == l;\n};\n/**\n * @param {string} str\n * @param {string} prefix\n * @return {boolean}\n */\ngoog.string.internal.caseInsensitiveStartsWith = function(str, prefix) {\n  return goog.string.internal.caseInsensitiveCompare(prefix, str.substr(0, prefix.length)) == 0;\n};\n/**\n * @param {string} str\n * @param {string} suffix\n * @return {boolean}\n */\ngoog.string.internal.caseInsensitiveEndsWith = function(str, suffix) {\n  return goog.string.internal.caseInsensitiveCompare(suffix, str.substr(str.length - suffix.length, suffix.length)) == 0;\n};\n/**\n * @param {string} str1\n * @param {string} str2\n * @return {boolean}\n */\ngoog.string.internal.caseInsensitiveEquals = function(str1, str2) {\n  return str1.toLowerCase() == str2.toLowerCase();\n};\n/**\n * @param {string} str\n * @return {boolean}\n */\ngoog.string.internal.isEmptyOrWhitespace = function(str) {\n  return /^[\\s\\xa0]*$/.test(str);\n};\n/**\n * @param {string} str\n * @return {string}\n */\ngoog.string.internal.trim = goog.TRUSTED_SITE && String.prototype.trim ? function(str) {\n  return str.trim();\n} : function(str) {\n  return /^[\\s\\xa0]*([\\s\\S]*?)[\\s\\xa0]*$/.exec(str)[1];\n};\n/**\n * @param {string} str1\n * @param {string} str2\n * @return {number}\n */\ngoog.string.internal.caseInsensitiveCompare = function(str1, str2) {\n  /** @const */ var test1 = String(str1).toLowerCase();\n  /** @const */ var test2 = String(str2).toLowerCase();\n  if (test1 < test2) {\n    return -1;\n  } else {\n    if (test1 == test2) {\n      return 0;\n    } else {\n      return 1;\n    }\n  }\n};\n/**\n * @param {string} str\n * @param {boolean=} opt_xml\n * @return {string}\n */\ngoog.string.internal.newLineToBr = function(str, opt_xml) {\n  return str.replace(/(\\r\\n|\\r|\\n)/g, opt_xml ? \"\\x3cbr /\\x3e\" : \"\\x3cbr\\x3e\");\n};\n/**\n * @param {string} str\n * @param {boolean=} opt_isLikelyToContainHtmlChars\n * @return {string}\n */\ngoog.string.internal.htmlEscape = function(str, opt_isLikelyToContainHtmlChars) {\n  if (opt_isLikelyToContainHtmlChars) {\n    str = str.replace(goog.string.internal.AMP_RE_, \"\\x26amp;\").replace(goog.string.internal.LT_RE_, \"\\x26lt;\").replace(goog.string.internal.GT_RE_, \"\\x26gt;\").replace(goog.string.internal.QUOT_RE_, \"\\x26quot;\").replace(goog.string.internal.SINGLE_QUOTE_RE_, \"\\x26#39;\").replace(goog.string.internal.NULL_RE_, \"\\x26#0;\");\n    return str;\n  } else {\n    if (!goog.string.internal.ALL_RE_.test(str)) {\n      return str;\n    }\n    if (str.indexOf(\"\\x26\") != -1) {\n      str = str.replace(goog.string.internal.AMP_RE_, \"\\x26amp;\");\n    }\n    if (str.indexOf(\"\\x3c\") != -1) {\n      str = str.replace(goog.string.internal.LT_RE_, \"\\x26lt;\");\n    }\n    if (str.indexOf(\"\\x3e\") != -1) {\n      str = str.replace(goog.string.internal.GT_RE_, \"\\x26gt;\");\n    }\n    if (str.indexOf('\"') != -1) {\n      str = str.replace(goog.string.internal.QUOT_RE_, \"\\x26quot;\");\n    }\n    if (str.indexOf(\"'\") != -1) {\n      str = str.replace(goog.string.internal.SINGLE_QUOTE_RE_, \"\\x26#39;\");\n    }\n    if (str.indexOf(\"\\x00\") != -1) {\n      str = str.replace(goog.string.internal.NULL_RE_, \"\\x26#0;\");\n    }\n    return str;\n  }\n};\n/** @private @const @type {!RegExp} */ goog.string.internal.AMP_RE_ = /&/g;\n/** @private @const @type {!RegExp} */ goog.string.internal.LT_RE_ = /</g;\n/** @private @const @type {!RegExp} */ goog.string.internal.GT_RE_ = />/g;\n/** @private @const @type {!RegExp} */ goog.string.internal.QUOT_RE_ = /\"/g;\n/** @private @const @type {!RegExp} */ goog.string.internal.SINGLE_QUOTE_RE_ = /'/g;\n/** @private @const @type {!RegExp} */ goog.string.internal.NULL_RE_ = /\\x00/g;\n/** @private @const @type {!RegExp} */ goog.string.internal.ALL_RE_ = /[\\x00&<>\"']/;\n/**\n * @param {string} str\n * @param {boolean=} opt_xml\n * @return {string}\n */\ngoog.string.internal.whitespaceEscape = function(str, opt_xml) {\n  return goog.string.internal.newLineToBr(str.replace(/  /g, \" \\x26#160;\"), opt_xml);\n};\n/**\n * @param {string} str\n * @param {string} subString\n * @return {boolean}\n */\ngoog.string.internal.contains = function(str, subString) {\n  return str.indexOf(subString) != -1;\n};\n/**\n * @param {string} str\n * @param {string} subString\n * @return {boolean}\n */\ngoog.string.internal.caseInsensitiveContains = function(str, subString) {\n  return goog.string.internal.contains(str.toLowerCase(), subString.toLowerCase());\n};\n/**\n * @param {(string|number)} version1\n * @param {(string|number)} version2\n * @return {number}\n */\ngoog.string.internal.compareVersions = function(version1, version2) {\n  var order = 0;\n  /** @const */ var v1Subs = goog.string.internal.trim(String(version1)).split(\".\");\n  /** @const */ var v2Subs = goog.string.internal.trim(String(version2)).split(\".\");\n  /** @const */ var subCount = Math.max(v1Subs.length, v2Subs.length);\n  for (var subIdx = 0; order == 0 && subIdx < subCount; subIdx++) {\n    var v1Sub = v1Subs[subIdx] || \"\";\n    var v2Sub = v2Subs[subIdx] || \"\";\n    do {\n      /** @const */ var v1Comp = /(\\d*)(\\D*)(.*)/.exec(v1Sub) || [\"\", \"\", \"\", \"\"];\n      /** @const */ var v2Comp = /(\\d*)(\\D*)(.*)/.exec(v2Sub) || [\"\", \"\", \"\", \"\"];\n      if (v1Comp[0].length == 0 && v2Comp[0].length == 0) {\n        break;\n      }\n      /** @const */ var v1CompNum = v1Comp[1].length == 0 ? 0 : parseInt(v1Comp[1], 10);\n      /** @const */ var v2CompNum = v2Comp[1].length == 0 ? 0 : parseInt(v2Comp[1], 10);\n      order = goog.string.internal.compareElements_(v1CompNum, v2CompNum) || goog.string.internal.compareElements_(v1Comp[2].length == 0, v2Comp[2].length == 0) || goog.string.internal.compareElements_(v1Comp[2], v2Comp[2]);\n      v1Sub = v1Comp[3];\n      v2Sub = v2Comp[3];\n    } while (order == 0);\n  }\n  return order;\n};\n/**\n * @private\n * @param {(string|number|boolean)} left\n * @param {(string|number|boolean)} right\n * @return {number}\n */\ngoog.string.internal.compareElements_ = function(left, right) {\n  if (left < right) {\n    return -1;\n  } else {\n    if (left > right) {\n      return 1;\n    }\n  }\n  return 0;\n};\n","~:source","// Copyright 2006 The Closure Library Authors. All Rights Reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n//      http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS-IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n/**\n * @fileoverview String functions called from Closure packages that couldn't\n * depend on each other. Outside Closure, use goog.string function which\n * delegate to these.\n */\n\n\ngoog.provide('goog.string.internal');\n\n\n/**\n * Fast prefix-checker.\n * @param {string} str The string to check.\n * @param {string} prefix A string to look for at the start of `str`.\n * @return {boolean} True if `str` begins with `prefix`.\n * @see goog.string.startsWith\n */\ngoog.string.internal.startsWith = function(str, prefix) {\n  return str.lastIndexOf(prefix, 0) == 0;\n};\n\n\n/**\n * Fast suffix-checker.\n * @param {string} str The string to check.\n * @param {string} suffix A string to look for at the end of `str`.\n * @return {boolean} True if `str` ends with `suffix`.\n * @see goog.string.endsWith\n */\ngoog.string.internal.endsWith = function(str, suffix) {\n  const l = str.length - suffix.length;\n  return l >= 0 && str.indexOf(suffix, l) == l;\n};\n\n\n/**\n * Case-insensitive prefix-checker.\n * @param {string} str The string to check.\n * @param {string} prefix  A string to look for at the end of `str`.\n * @return {boolean} True if `str` begins with `prefix` (ignoring\n *     case).\n * @see goog.string.caseInsensitiveStartsWith\n */\ngoog.string.internal.caseInsensitiveStartsWith = function(str, prefix) {\n  return goog.string.internal.caseInsensitiveCompare(\n             prefix, str.substr(0, prefix.length)) == 0;\n};\n\n\n/**\n * Case-insensitive suffix-checker.\n * @param {string} str The string to check.\n * @param {string} suffix A string to look for at the end of `str`.\n * @return {boolean} True if `str` ends with `suffix` (ignoring\n *     case).\n * @see goog.string.caseInsensitiveEndsWith\n */\ngoog.string.internal.caseInsensitiveEndsWith = function(str, suffix) {\n  return (\n      goog.string.internal.caseInsensitiveCompare(\n          suffix, str.substr(str.length - suffix.length, suffix.length)) == 0);\n};\n\n\n/**\n * Case-insensitive equality checker.\n * @param {string} str1 First string to check.\n * @param {string} str2 Second string to check.\n * @return {boolean} True if `str1` and `str2` are the same string,\n *     ignoring case.\n * @see goog.string.caseInsensitiveEquals\n */\ngoog.string.internal.caseInsensitiveEquals = function(str1, str2) {\n  return str1.toLowerCase() == str2.toLowerCase();\n};\n\n\n/**\n * Checks if a string is empty or contains only whitespaces.\n * @param {string} str The string to check.\n * @return {boolean} Whether `str` is empty or whitespace only.\n * @see goog.string.isEmptyOrWhitespace\n */\ngoog.string.internal.isEmptyOrWhitespace = function(str) {\n  // testing length == 0 first is actually slower in all browsers (about the\n  // same in Opera).\n  // Since IE doesn't include non-breaking-space (0xa0) in their \\s character\n  // class (as required by section 7.2 of the ECMAScript spec), we explicitly\n  // include it in the regexp to enforce consistent cross-browser behavior.\n  return /^[\\s\\xa0]*$/.test(str);\n};\n\n\n/**\n * Trims white spaces to the left and right of a string.\n * @param {string} str The string to trim.\n * @return {string} A trimmed copy of `str`.\n */\ngoog.string.internal.trim =\n    (goog.TRUSTED_SITE && String.prototype.trim) ? function(str) {\n      return str.trim();\n    } : function(str) {\n      // Since IE doesn't include non-breaking-space (0xa0) in their \\s\n      // character class (as required by section 7.2 of the ECMAScript spec),\n      // we explicitly include it in the regexp to enforce consistent\n      // cross-browser behavior.\n      // NOTE: We don't use String#replace because it might have side effects\n      // causing this function to not compile to 0 bytes.\n      return /^[\\s\\xa0]*([\\s\\S]*?)[\\s\\xa0]*$/.exec(str)[1];\n    };\n\n\n/**\n * A string comparator that ignores case.\n * -1 = str1 less than str2\n *  0 = str1 equals str2\n *  1 = str1 greater than str2\n *\n * @param {string} str1 The string to compare.\n * @param {string} str2 The string to compare `str1` to.\n * @return {number} The comparator result, as described above.\n * @see goog.string.caseInsensitiveCompare\n */\ngoog.string.internal.caseInsensitiveCompare = function(str1, str2) {\n  const test1 = String(str1).toLowerCase();\n  const test2 = String(str2).toLowerCase();\n\n  if (test1 < test2) {\n    return -1;\n  } else if (test1 == test2) {\n    return 0;\n  } else {\n    return 1;\n  }\n};\n\n\n/**\n * Converts \\n to <br>s or <br />s.\n * @param {string} str The string in which to convert newlines.\n * @param {boolean=} opt_xml Whether to use XML compatible tags.\n * @return {string} A copy of `str` with converted newlines.\n * @see goog.string.newLineToBr\n */\ngoog.string.internal.newLineToBr = function(str, opt_xml) {\n  return str.replace(/(\\r\\n|\\r|\\n)/g, opt_xml ? '<br />' : '<br>');\n};\n\n\n/**\n * Escapes double quote '\"' and single quote '\\'' characters in addition to\n * '&', '<', and '>' so that a string can be included in an HTML tag attribute\n * value within double or single quotes.\n * @param {string} str string to be escaped.\n * @param {boolean=} opt_isLikelyToContainHtmlChars\n * @return {string} An escaped copy of `str`.\n * @see goog.string.htmlEscape\n */\ngoog.string.internal.htmlEscape = function(\n    str, opt_isLikelyToContainHtmlChars) {\n  if (opt_isLikelyToContainHtmlChars) {\n    str = str.replace(goog.string.internal.AMP_RE_, '&amp;')\n              .replace(goog.string.internal.LT_RE_, '&lt;')\n              .replace(goog.string.internal.GT_RE_, '&gt;')\n              .replace(goog.string.internal.QUOT_RE_, '&quot;')\n              .replace(goog.string.internal.SINGLE_QUOTE_RE_, '&#39;')\n              .replace(goog.string.internal.NULL_RE_, '&#0;');\n    return str;\n\n  } else {\n    // quick test helps in the case when there are no chars to replace, in\n    // worst case this makes barely a difference to the time taken\n    if (!goog.string.internal.ALL_RE_.test(str)) return str;\n\n    // str.indexOf is faster than regex.test in this case\n    if (str.indexOf('&') != -1) {\n      str = str.replace(goog.string.internal.AMP_RE_, '&amp;');\n    }\n    if (str.indexOf('<') != -1) {\n      str = str.replace(goog.string.internal.LT_RE_, '&lt;');\n    }\n    if (str.indexOf('>') != -1) {\n      str = str.replace(goog.string.internal.GT_RE_, '&gt;');\n    }\n    if (str.indexOf('\"') != -1) {\n      str = str.replace(goog.string.internal.QUOT_RE_, '&quot;');\n    }\n    if (str.indexOf('\\'') != -1) {\n      str = str.replace(goog.string.internal.SINGLE_QUOTE_RE_, '&#39;');\n    }\n    if (str.indexOf('\\x00') != -1) {\n      str = str.replace(goog.string.internal.NULL_RE_, '&#0;');\n    }\n    return str;\n  }\n};\n\n\n/**\n * Regular expression that matches an ampersand, for use in escaping.\n * @const {!RegExp}\n * @private\n */\ngoog.string.internal.AMP_RE_ = /&/g;\n\n\n/**\n * Regular expression that matches a less than sign, for use in escaping.\n * @const {!RegExp}\n * @private\n */\ngoog.string.internal.LT_RE_ = /</g;\n\n\n/**\n * Regular expression that matches a greater than sign, for use in escaping.\n * @const {!RegExp}\n * @private\n */\ngoog.string.internal.GT_RE_ = />/g;\n\n\n/**\n * Regular expression that matches a double quote, for use in escaping.\n * @const {!RegExp}\n * @private\n */\ngoog.string.internal.QUOT_RE_ = /\"/g;\n\n\n/**\n * Regular expression that matches a single quote, for use in escaping.\n * @const {!RegExp}\n * @private\n */\ngoog.string.internal.SINGLE_QUOTE_RE_ = /'/g;\n\n\n/**\n * Regular expression that matches null character, for use in escaping.\n * @const {!RegExp}\n * @private\n */\ngoog.string.internal.NULL_RE_ = /\\x00/g;\n\n\n/**\n * Regular expression that matches any character that needs to be escaped.\n * @const {!RegExp}\n * @private\n */\ngoog.string.internal.ALL_RE_ = /[\\x00&<>\"']/;\n\n\n/**\n * Do escaping of whitespace to preserve spatial formatting. We use character\n * entity #160 to make it safer for xml.\n * @param {string} str The string in which to escape whitespace.\n * @param {boolean=} opt_xml Whether to use XML compatible tags.\n * @return {string} An escaped copy of `str`.\n * @see goog.string.whitespaceEscape\n */\ngoog.string.internal.whitespaceEscape = function(str, opt_xml) {\n  // This doesn't use goog.string.preserveSpaces for backwards compatibility.\n  return goog.string.internal.newLineToBr(\n      str.replace(/  /g, ' &#160;'), opt_xml);\n};\n\n\n/**\n * Determines whether a string contains a substring.\n * @param {string} str The string to search.\n * @param {string} subString The substring to search for.\n * @return {boolean} Whether `str` contains `subString`.\n * @see goog.string.contains\n */\ngoog.string.internal.contains = function(str, subString) {\n  return str.indexOf(subString) != -1;\n};\n\n\n/**\n * Determines whether a string contains a substring, ignoring case.\n * @param {string} str The string to search.\n * @param {string} subString The substring to search for.\n * @return {boolean} Whether `str` contains `subString`.\n * @see goog.string.caseInsensitiveContains\n */\ngoog.string.internal.caseInsensitiveContains = function(str, subString) {\n  return goog.string.internal.contains(\n      str.toLowerCase(), subString.toLowerCase());\n};\n\n\n/**\n * Compares two version numbers.\n *\n * @param {string|number} version1 Version of first item.\n * @param {string|number} version2 Version of second item.\n *\n * @return {number}  1 if `version1` is higher.\n *                   0 if arguments are equal.\n *                  -1 if `version2` is higher.\n * @see goog.string.compareVersions\n */\ngoog.string.internal.compareVersions = function(version1, version2) {\n  let order = 0;\n  // Trim leading and trailing whitespace and split the versions into\n  // subversions.\n  const v1Subs = goog.string.internal.trim(String(version1)).split('.');\n  const v2Subs = goog.string.internal.trim(String(version2)).split('.');\n  const subCount = Math.max(v1Subs.length, v2Subs.length);\n\n  // Iterate over the subversions, as long as they appear to be equivalent.\n  for (let subIdx = 0; order == 0 && subIdx < subCount; subIdx++) {\n    let v1Sub = v1Subs[subIdx] || '';\n    let v2Sub = v2Subs[subIdx] || '';\n\n    do {\n      // Split the subversions into pairs of numbers and qualifiers (like 'b').\n      // Two different RegExp objects are use to make it clear the code\n      // is side-effect free\n      const v1Comp = /(\\d*)(\\D*)(.*)/.exec(v1Sub) || ['', '', '', ''];\n      const v2Comp = /(\\d*)(\\D*)(.*)/.exec(v2Sub) || ['', '', '', ''];\n      // Break if there are no more matches.\n      if (v1Comp[0].length == 0 && v2Comp[0].length == 0) {\n        break;\n      }\n\n      // Parse the numeric part of the subversion. A missing number is\n      // equivalent to 0.\n      const v1CompNum = v1Comp[1].length == 0 ? 0 : parseInt(v1Comp[1], 10);\n      const v2CompNum = v2Comp[1].length == 0 ? 0 : parseInt(v2Comp[1], 10);\n\n      // Compare the subversion components. The number has the highest\n      // precedence. Next, if the numbers are equal, a subversion without any\n      // qualifier is always higher than a subversion with any qualifier. Next,\n      // the qualifiers are compared as strings.\n      order = goog.string.internal.compareElements_(v1CompNum, v2CompNum) ||\n          goog.string.internal.compareElements_(\n              v1Comp[2].length == 0, v2Comp[2].length == 0) ||\n          goog.string.internal.compareElements_(v1Comp[2], v2Comp[2]);\n      // Stop as soon as an inequality is discovered.\n\n      v1Sub = v1Comp[3];\n      v2Sub = v2Comp[3];\n    } while (order == 0);\n  }\n\n  return order;\n};\n\n\n/**\n * Compares elements of a version number.\n *\n * @param {string|number|boolean} left An element from a version number.\n * @param {string|number|boolean} right An element from a version number.\n *\n * @return {number}  1 if `left` is higher.\n *                   0 if arguments are equal.\n *                  -1 if `right` is higher.\n * @private\n */\ngoog.string.internal.compareElements_ = function(left, right) {\n  if (left < right) {\n    return -1;\n  } else if (left > right) {\n    return 1;\n  }\n  return 0;\n};\n","~:compiled-at",1584073468409,"~:source-map-json","{\n\"version\":3,\n\"file\":\"goog.string.internal.js\",\n\"lineCount\":194,\n\"mappings\":\"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\",\n\"sources\":[\"goog/string/internal.js\"],\n\"sourcesContent\":[\"// Copyright 2006 The Closure Library Authors. All Rights Reserved.\\n//\\n// Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n// you may not use this file except in compliance with the License.\\n// You may obtain a copy of the License at\\n//\\n//      http://www.apache.org/licenses/LICENSE-2.0\\n//\\n// Unless required by applicable law or agreed to in writing, software\\n// distributed under the License is distributed on an \\\"AS-IS\\\" BASIS,\\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n// See the License for the specific language governing permissions and\\n// limitations under the License.\\n\\n/**\\n * @fileoverview String functions called from Closure packages that couldn't\\n * depend on each other. Outside Closure, use goog.string function which\\n * delegate to these.\\n */\\n\\n\\ngoog.provide('goog.string.internal');\\n\\n\\n/**\\n * Fast prefix-checker.\\n * @param {string} str The string to check.\\n * @param {string} prefix A string to look for at the start of `str`.\\n * @return {boolean} True if `str` begins with `prefix`.\\n * @see goog.string.startsWith\\n */\\ngoog.string.internal.startsWith = function(str, prefix) {\\n  return str.lastIndexOf(prefix, 0) == 0;\\n};\\n\\n\\n/**\\n * Fast suffix-checker.\\n * @param {string} str The string to check.\\n * @param {string} suffix A string to look for at the end of `str`.\\n * @return {boolean} True if `str` ends with `suffix`.\\n * @see goog.string.endsWith\\n */\\ngoog.string.internal.endsWith = function(str, suffix) {\\n  const l = str.length - suffix.length;\\n  return l >= 0 && str.indexOf(suffix, l) == l;\\n};\\n\\n\\n/**\\n * Case-insensitive prefix-checker.\\n * @param {string} str The string to check.\\n * @param {string} prefix  A string to look for at the end of `str`.\\n * @return {boolean} True if `str` begins with `prefix` (ignoring\\n *     case).\\n * @see goog.string.caseInsensitiveStartsWith\\n */\\ngoog.string.internal.caseInsensitiveStartsWith = function(str, prefix) {\\n  return goog.string.internal.caseInsensitiveCompare(\\n             prefix, str.substr(0, prefix.length)) == 0;\\n};\\n\\n\\n/**\\n * Case-insensitive suffix-checker.\\n * @param {string} str The string to check.\\n * @param {string} suffix A string to look for at the end of `str`.\\n * @return {boolean} True if `str` ends with `suffix` (ignoring\\n *     case).\\n * @see goog.string.caseInsensitiveEndsWith\\n */\\ngoog.string.internal.caseInsensitiveEndsWith = function(str, suffix) {\\n  return (\\n      goog.string.internal.caseInsensitiveCompare(\\n          suffix, str.substr(str.length - suffix.length, suffix.length)) == 0);\\n};\\n\\n\\n/**\\n * Case-insensitive equality checker.\\n * @param {string} str1 First string to check.\\n * @param {string} str2 Second string to check.\\n * @return {boolean} True if `str1` and `str2` are the same string,\\n *     ignoring case.\\n * @see goog.string.caseInsensitiveEquals\\n */\\ngoog.string.internal.caseInsensitiveEquals = function(str1, str2) {\\n  return str1.toLowerCase() == str2.toLowerCase();\\n};\\n\\n\\n/**\\n * Checks if a string is empty or contains only whitespaces.\\n * @param {string} str The string to check.\\n * @return {boolean} Whether `str` is empty or whitespace only.\\n * @see goog.string.isEmptyOrWhitespace\\n */\\ngoog.string.internal.isEmptyOrWhitespace = function(str) {\\n  // testing length == 0 first is actually slower in all browsers (about the\\n  // same in Opera).\\n  // Since IE doesn't include non-breaking-space (0xa0) in their \\\\s character\\n  // class (as required by section 7.2 of the ECMAScript spec), we explicitly\\n  // include it in the regexp to enforce consistent cross-browser behavior.\\n  return /^[\\\\s\\\\xa0]*$/.test(str);\\n};\\n\\n\\n/**\\n * Trims white spaces to the left and right of a string.\\n * @param {string} str The string to trim.\\n * @return {string} A trimmed copy of `str`.\\n */\\ngoog.string.internal.trim =\\n    (goog.TRUSTED_SITE && String.prototype.trim) ? function(str) {\\n      return str.trim();\\n    } : function(str) {\\n      // Since IE doesn't include non-breaking-space (0xa0) in their \\\\s\\n      // character class (as required by section 7.2 of the ECMAScript spec),\\n      // we explicitly include it in the regexp to enforce consistent\\n      // cross-browser behavior.\\n      // NOTE: We don't use String#replace because it might have side effects\\n      // causing this function to not compile to 0 bytes.\\n      return /^[\\\\s\\\\xa0]*([\\\\s\\\\S]*?)[\\\\s\\\\xa0]*$/.exec(str)[1];\\n    };\\n\\n\\n/**\\n * A string comparator that ignores case.\\n * -1 = str1 less than str2\\n *  0 = str1 equals str2\\n *  1 = str1 greater than str2\\n *\\n * @param {string} str1 The string to compare.\\n * @param {string} str2 The string to compare `str1` to.\\n * @return {number} The comparator result, as described above.\\n * @see goog.string.caseInsensitiveCompare\\n */\\ngoog.string.internal.caseInsensitiveCompare = function(str1, str2) {\\n  const test1 = String(str1).toLowerCase();\\n  const test2 = String(str2).toLowerCase();\\n\\n  if (test1 < test2) {\\n    return -1;\\n  } else if (test1 == test2) {\\n    return 0;\\n  } else {\\n    return 1;\\n  }\\n};\\n\\n\\n/**\\n * Converts \\\\n to <br>s or <br />s.\\n * @param {string} str The string in which to convert newlines.\\n * @param {boolean=} opt_xml Whether to use XML compatible tags.\\n * @return {string} A copy of `str` with converted newlines.\\n * @see goog.string.newLineToBr\\n */\\ngoog.string.internal.newLineToBr = function(str, opt_xml) {\\n  return str.replace(/(\\\\r\\\\n|\\\\r|\\\\n)/g, opt_xml ? '<br />' : '<br>');\\n};\\n\\n\\n/**\\n * Escapes double quote '\\\"' and single quote '\\\\'' characters in addition to\\n * '&', '<', and '>' so that a string can be included in an HTML tag attribute\\n * value within double or single quotes.\\n * @param {string} str string to be escaped.\\n * @param {boolean=} opt_isLikelyToContainHtmlChars\\n * @return {string} An escaped copy of `str`.\\n * @see goog.string.htmlEscape\\n */\\ngoog.string.internal.htmlEscape = function(\\n    str, opt_isLikelyToContainHtmlChars) {\\n  if (opt_isLikelyToContainHtmlChars) {\\n    str = str.replace(goog.string.internal.AMP_RE_, '&amp;')\\n              .replace(goog.string.internal.LT_RE_, '&lt;')\\n              .replace(goog.string.internal.GT_RE_, '&gt;')\\n              .replace(goog.string.internal.QUOT_RE_, '&quot;')\\n              .replace(goog.string.internal.SINGLE_QUOTE_RE_, '&#39;')\\n              .replace(goog.string.internal.NULL_RE_, '&#0;');\\n    return str;\\n\\n  } else {\\n    // quick test helps in the case when there are no chars to replace, in\\n    // worst case this makes barely a difference to the time taken\\n    if (!goog.string.internal.ALL_RE_.test(str)) return str;\\n\\n    // str.indexOf is faster than regex.test in this case\\n    if (str.indexOf('&') != -1) {\\n      str = str.replace(goog.string.internal.AMP_RE_, '&amp;');\\n    }\\n    if (str.indexOf('<') != -1) {\\n      str = str.replace(goog.string.internal.LT_RE_, '&lt;');\\n    }\\n    if (str.indexOf('>') != -1) {\\n      str = str.replace(goog.string.internal.GT_RE_, '&gt;');\\n    }\\n    if (str.indexOf('\\\"') != -1) {\\n      str = str.replace(goog.string.internal.QUOT_RE_, '&quot;');\\n    }\\n    if (str.indexOf('\\\\'') != -1) {\\n      str = str.replace(goog.string.internal.SINGLE_QUOTE_RE_, '&#39;');\\n    }\\n    if (str.indexOf('\\\\x00') != -1) {\\n      str = str.replace(goog.string.internal.NULL_RE_, '&#0;');\\n    }\\n    return str;\\n  }\\n};\\n\\n\\n/**\\n * Regular expression that matches an ampersand, for use in escaping.\\n * @const {!RegExp}\\n * @private\\n */\\ngoog.string.internal.AMP_RE_ = /&/g;\\n\\n\\n/**\\n * Regular expression that matches a less than sign, for use in escaping.\\n * @const {!RegExp}\\n * @private\\n */\\ngoog.string.internal.LT_RE_ = /</g;\\n\\n\\n/**\\n * Regular expression that matches a greater than sign, for use in escaping.\\n * @const {!RegExp}\\n * @private\\n */\\ngoog.string.internal.GT_RE_ = />/g;\\n\\n\\n/**\\n * Regular expression that matches a double quote, for use in escaping.\\n * @const {!RegExp}\\n * @private\\n */\\ngoog.string.internal.QUOT_RE_ = /\\\"/g;\\n\\n\\n/**\\n * Regular expression that matches a single quote, for use in escaping.\\n * @const {!RegExp}\\n * @private\\n */\\ngoog.string.internal.SINGLE_QUOTE_RE_ = /'/g;\\n\\n\\n/**\\n * Regular expression that matches null character, for use in escaping.\\n * @const {!RegExp}\\n * @private\\n */\\ngoog.string.internal.NULL_RE_ = /\\\\x00/g;\\n\\n\\n/**\\n * Regular expression that matches any character that needs to be escaped.\\n * @const {!RegExp}\\n * @private\\n */\\ngoog.string.internal.ALL_RE_ = /[\\\\x00&<>\\\"']/;\\n\\n\\n/**\\n * Do escaping of whitespace to preserve spatial formatting. We use character\\n * entity #160 to make it safer for xml.\\n * @param {string} str The string in which to escape whitespace.\\n * @param {boolean=} opt_xml Whether to use XML compatible tags.\\n * @return {string} An escaped copy of `str`.\\n * @see goog.string.whitespaceEscape\\n */\\ngoog.string.internal.whitespaceEscape = function(str, opt_xml) {\\n  // This doesn't use goog.string.preserveSpaces for backwards compatibility.\\n  return goog.string.internal.newLineToBr(\\n      str.replace(/  /g, ' &#160;'), opt_xml);\\n};\\n\\n\\n/**\\n * Determines whether a string contains a substring.\\n * @param {string} str The string to search.\\n * @param {string} subString The substring to search for.\\n * @return {boolean} Whether `str` contains `subString`.\\n * @see goog.string.contains\\n */\\ngoog.string.internal.contains = function(str, subString) {\\n  return str.indexOf(subString) != -1;\\n};\\n\\n\\n/**\\n * Determines whether a string contains a substring, ignoring case.\\n * @param {string} str The string to search.\\n * @param {string} subString The substring to search for.\\n * @return {boolean} Whether `str` contains `subString`.\\n * @see goog.string.caseInsensitiveContains\\n */\\ngoog.string.internal.caseInsensitiveContains = function(str, subString) {\\n  return goog.string.internal.contains(\\n      str.toLowerCase(), subString.toLowerCase());\\n};\\n\\n\\n/**\\n * Compares two version numbers.\\n *\\n * @param {string|number} version1 Version of first item.\\n * @param {string|number} version2 Version of second item.\\n *\\n * @return {number}  1 if `version1` is higher.\\n *                   0 if arguments are equal.\\n *                  -1 if `version2` is higher.\\n * @see goog.string.compareVersions\\n */\\ngoog.string.internal.compareVersions = function(version1, version2) {\\n  let order = 0;\\n  // Trim leading and trailing whitespace and split the versions into\\n  // subversions.\\n  const v1Subs = goog.string.internal.trim(String(version1)).split('.');\\n  const v2Subs = goog.string.internal.trim(String(version2)).split('.');\\n  const subCount = Math.max(v1Subs.length, v2Subs.length);\\n\\n  // Iterate over the subversions, as long as they appear to be equivalent.\\n  for (let subIdx = 0; order == 0 && subIdx < subCount; subIdx++) {\\n    let v1Sub = v1Subs[subIdx] || '';\\n    let v2Sub = v2Subs[subIdx] || '';\\n\\n    do {\\n      // Split the subversions into pairs of numbers and qualifiers (like 'b').\\n      // Two different RegExp objects are use to make it clear the code\\n      // is side-effect free\\n      const v1Comp = /(\\\\d*)(\\\\D*)(.*)/.exec(v1Sub) || ['', '', '', ''];\\n      const v2Comp = /(\\\\d*)(\\\\D*)(.*)/.exec(v2Sub) || ['', '', '', ''];\\n      // Break if there are no more matches.\\n      if (v1Comp[0].length == 0 && v2Comp[0].length == 0) {\\n        break;\\n      }\\n\\n      // Parse the numeric part of the subversion. A missing number is\\n      // equivalent to 0.\\n      const v1CompNum = v1Comp[1].length == 0 ? 0 : parseInt(v1Comp[1], 10);\\n      const v2CompNum = v2Comp[1].length == 0 ? 0 : parseInt(v2Comp[1], 10);\\n\\n      // Compare the subversion components. The number has the highest\\n      // precedence. Next, if the numbers are equal, a subversion without any\\n      // qualifier is always higher than a subversion with any qualifier. Next,\\n      // the qualifiers are compared as strings.\\n      order = goog.string.internal.compareElements_(v1CompNum, v2CompNum) ||\\n          goog.string.internal.compareElements_(\\n              v1Comp[2].length == 0, v2Comp[2].length == 0) ||\\n          goog.string.internal.compareElements_(v1Comp[2], v2Comp[2]);\\n      // Stop as soon as an inequality is discovered.\\n\\n      v1Sub = v1Comp[3];\\n      v2Sub = v2Comp[3];\\n    } while (order == 0);\\n  }\\n\\n  return order;\\n};\\n\\n\\n/**\\n * Compares elements of a version number.\\n *\\n * @param {string|number|boolean} left An element from a version number.\\n * @param {string|number|boolean} right An element from a version number.\\n *\\n * @return {number}  1 if `left` is higher.\\n *                   0 if arguments are equal.\\n *                  -1 if `right` is higher.\\n * @private\\n */\\ngoog.string.internal.compareElements_ = function(left, right) {\\n  if (left < right) {\\n    return -1;\\n  } else if (left > right) {\\n    return 1;\\n  }\\n  return 0;\\n};\\n\"],\n\"names\":[\"goog\",\"provide\",\"string\",\"internal\",\"startsWith\",\"goog.string.internal.startsWith\",\"str\",\"prefix\",\"lastIndexOf\",\"endsWith\",\"goog.string.internal.endsWith\",\"suffix\",\"l\",\"length\",\"indexOf\",\"caseInsensitiveStartsWith\",\"goog.string.internal.caseInsensitiveStartsWith\",\"caseInsensitiveCompare\",\"substr\",\"caseInsensitiveEndsWith\",\"goog.string.internal.caseInsensitiveEndsWith\",\"caseInsensitiveEquals\",\"goog.string.internal.caseInsensitiveEquals\",\"str1\",\"str2\",\"toLowerCase\",\"isEmptyOrWhitespace\",\"goog.string.internal.isEmptyOrWhitespace\",\"test\",\"trim\",\"TRUSTED_SITE\",\"String\",\"prototype\",\"exec\",\"goog.string.internal.caseInsensitiveCompare\",\"test1\",\"test2\",\"newLineToBr\",\"goog.string.internal.newLineToBr\",\"opt_xml\",\"replace\",\"htmlEscape\",\"goog.string.internal.htmlEscape\",\"opt_isLikelyToContainHtmlChars\",\"AMP_RE_\",\"LT_RE_\",\"GT_RE_\",\"QUOT_RE_\",\"SINGLE_QUOTE_RE_\",\"NULL_RE_\",\"ALL_RE_\",\"whitespaceEscape\",\"goog.string.internal.whitespaceEscape\",\"contains\",\"goog.string.internal.contains\",\"subString\",\"caseInsensitiveContains\",\"goog.string.internal.caseInsensitiveContains\",\"compareVersions\",\"goog.string.internal.compareVersions\",\"version1\",\"version2\",\"order\",\"v1Subs\",\"split\",\"v2Subs\",\"subCount\",\"Math\",\"max\",\"subIdx\",\"v1Sub\",\"v2Sub\",\"v1Comp\",\"v2Comp\",\"v1CompNum\",\"parseInt\",\"v2CompNum\",\"compareElements_\",\"goog.string.internal.compareElements_\",\"left\",\"right\"]\n}\n"]