462 lines
15 KiB
JavaScript
462 lines
15 KiB
JavaScript
/*TRANSPILED*//*
|
||
|
||
Copyright The Closure Library Authors.
|
||
SPDX-License-Identifier: Apache-2.0
|
||
*/
|
||
'use strict';
|
||
goog.provide("goog.string");
|
||
goog.provide("goog.string.Unicode");
|
||
goog.require("goog.dom.safe");
|
||
goog.require("goog.html.uncheckedconversions");
|
||
goog.require("goog.string.Const");
|
||
goog.require("goog.string.internal");
|
||
goog.string.DETECT_DOUBLE_ESCAPING = goog.define("goog.string.DETECT_DOUBLE_ESCAPING", false);
|
||
goog.string.FORCE_NON_DOM_HTML_UNESCAPING = goog.define("goog.string.FORCE_NON_DOM_HTML_UNESCAPING", false);
|
||
goog.string.Unicode = {NBSP:" ", ZERO_WIDTH_SPACE:""};
|
||
goog.string.startsWith = goog.string.internal.startsWith;
|
||
goog.string.endsWith = goog.string.internal.endsWith;
|
||
goog.string.caseInsensitiveStartsWith = goog.string.internal.caseInsensitiveStartsWith;
|
||
goog.string.caseInsensitiveEndsWith = goog.string.internal.caseInsensitiveEndsWith;
|
||
goog.string.caseInsensitiveEquals = goog.string.internal.caseInsensitiveEquals;
|
||
goog.string.subs = function(str, var_args) {
|
||
const splitParts = str.split("%s");
|
||
let returnString = "";
|
||
const subsArguments = Array.prototype.slice.call(arguments, 1);
|
||
while (subsArguments.length && splitParts.length > 1) {
|
||
returnString += splitParts.shift() + subsArguments.shift();
|
||
}
|
||
return returnString + splitParts.join("%s");
|
||
};
|
||
goog.string.collapseWhitespace = function(str) {
|
||
return str.replace(/[\s\xa0]+/g, " ").replace(/^\s+|\s+$/g, "");
|
||
};
|
||
goog.string.isEmptyOrWhitespace = goog.string.internal.isEmptyOrWhitespace;
|
||
goog.string.isEmptyString = function(str) {
|
||
return str.length == 0;
|
||
};
|
||
goog.string.isEmpty = goog.string.isEmptyOrWhitespace;
|
||
goog.string.isEmptyOrWhitespaceSafe = function(str) {
|
||
return goog.string.isEmptyOrWhitespace(goog.string.makeSafe(str));
|
||
};
|
||
goog.string.isEmptySafe = goog.string.isEmptyOrWhitespaceSafe;
|
||
goog.string.isBreakingWhitespace = function(str) {
|
||
return !/[^\t\n\r ]/.test(str);
|
||
};
|
||
goog.string.isAlpha = function(str) {
|
||
return !/[^a-zA-Z]/.test(str);
|
||
};
|
||
goog.string.isNumeric = function(str) {
|
||
return !/[^0-9]/.test(str);
|
||
};
|
||
goog.string.isAlphaNumeric = function(str) {
|
||
return !/[^a-zA-Z0-9]/.test(str);
|
||
};
|
||
goog.string.isSpace = function(ch) {
|
||
return ch == " ";
|
||
};
|
||
goog.string.isUnicodeChar = function(ch) {
|
||
return ch.length == 1 && ch >= " " && ch <= "~" || ch >= "" && ch <= "<22>";
|
||
};
|
||
goog.string.stripNewlines = function(str) {
|
||
return str.replace(/(\r\n|\r|\n)+/g, " ");
|
||
};
|
||
goog.string.canonicalizeNewlines = function(str) {
|
||
return str.replace(/(\r\n|\r|\n)/g, "\n");
|
||
};
|
||
goog.string.normalizeWhitespace = function(str) {
|
||
return str.replace(/\xa0|\s/g, " ");
|
||
};
|
||
goog.string.normalizeSpaces = function(str) {
|
||
return str.replace(/\xa0|[ \t]+/g, " ");
|
||
};
|
||
goog.string.collapseBreakingSpaces = function(str) {
|
||
return str.replace(/[\t\r\n ]+/g, " ").replace(/^[\t\r\n ]+|[\t\r\n ]+$/g, "");
|
||
};
|
||
goog.string.trim = goog.string.internal.trim;
|
||
goog.string.trimLeft = function(str) {
|
||
return str.replace(/^[\s\xa0]+/, "");
|
||
};
|
||
goog.string.trimRight = function(str) {
|
||
return str.replace(/[\s\xa0]+$/, "");
|
||
};
|
||
goog.string.caseInsensitiveCompare = goog.string.internal.caseInsensitiveCompare;
|
||
goog.string.numberAwareCompare_ = function(str1, str2, tokenizerRegExp) {
|
||
if (str1 == str2) {
|
||
return 0;
|
||
}
|
||
if (!str1) {
|
||
return -1;
|
||
}
|
||
if (!str2) {
|
||
return 1;
|
||
}
|
||
const tokens1 = str1.toLowerCase().match(tokenizerRegExp);
|
||
const tokens2 = str2.toLowerCase().match(tokenizerRegExp);
|
||
const count = Math.min(tokens1.length, tokens2.length);
|
||
for (let i = 0; i < count; i++) {
|
||
const a = tokens1[i];
|
||
const b = tokens2[i];
|
||
if (a != b) {
|
||
const num1 = parseInt(a, 10);
|
||
if (!isNaN(num1)) {
|
||
const num2 = parseInt(b, 10);
|
||
if (!isNaN(num2) && num1 - num2) {
|
||
return num1 - num2;
|
||
}
|
||
}
|
||
return a < b ? -1 : 1;
|
||
}
|
||
}
|
||
if (tokens1.length != tokens2.length) {
|
||
return tokens1.length - tokens2.length;
|
||
}
|
||
return str1 < str2 ? -1 : 1;
|
||
};
|
||
goog.string.intAwareCompare = function(str1, str2) {
|
||
return goog.string.numberAwareCompare_(str1, str2, /\d+|\D+/g);
|
||
};
|
||
goog.string.floatAwareCompare = function(str1, str2) {
|
||
return goog.string.numberAwareCompare_(str1, str2, /\d+|\.\d+|\D+/g);
|
||
};
|
||
goog.string.numerateCompare = goog.string.floatAwareCompare;
|
||
goog.string.urlEncode = function(str) {
|
||
return encodeURIComponent(String(str));
|
||
};
|
||
goog.string.urlDecode = function(str) {
|
||
return decodeURIComponent(str.replace(/\+/g, " "));
|
||
};
|
||
goog.string.newLineToBr = goog.string.internal.newLineToBr;
|
||
goog.string.htmlEscape = function(str, opt_isLikelyToContainHtmlChars) {
|
||
str = goog.string.internal.htmlEscape(str, opt_isLikelyToContainHtmlChars);
|
||
if (goog.string.DETECT_DOUBLE_ESCAPING) {
|
||
str = str.replace(goog.string.E_RE_, "\x26#101;");
|
||
}
|
||
return str;
|
||
};
|
||
goog.string.E_RE_ = /e/g;
|
||
goog.string.unescapeEntities = function(str) {
|
||
if (goog.string.contains(str, "\x26")) {
|
||
if (!goog.string.FORCE_NON_DOM_HTML_UNESCAPING && "document" in goog.global) {
|
||
return goog.string.unescapeEntitiesUsingDom_(str);
|
||
} else {
|
||
return goog.string.unescapePureXmlEntities_(str);
|
||
}
|
||
}
|
||
return str;
|
||
};
|
||
goog.string.unescapeEntitiesWithDocument = function(str, document) {
|
||
if (goog.string.contains(str, "\x26")) {
|
||
return goog.string.unescapeEntitiesUsingDom_(str, document);
|
||
}
|
||
return str;
|
||
};
|
||
goog.string.unescapeEntitiesUsingDom_ = function(str, opt_document) {
|
||
const seen = {"\x26amp;":"\x26", "\x26lt;":"\x3c", "\x26gt;":"\x3e", "\x26quot;":'"'};
|
||
let div;
|
||
if (opt_document) {
|
||
div = opt_document.createElement("div");
|
||
} else {
|
||
div = goog.global.document.createElement("div");
|
||
}
|
||
return str.replace(goog.string.HTML_ENTITY_PATTERN_, function(s, entity) {
|
||
let value = seen[s];
|
||
if (value) {
|
||
return value;
|
||
}
|
||
if (entity.charAt(0) == "#") {
|
||
const n = Number("0" + entity.slice(1));
|
||
if (!isNaN(n)) {
|
||
value = String.fromCharCode(n);
|
||
}
|
||
}
|
||
if (!value) {
|
||
goog.dom.safe.setInnerHtml(div, goog.html.uncheckedconversions.safeHtmlFromStringKnownToSatisfyTypeContract(goog.string.Const.from("Single HTML entity."), s + " "));
|
||
value = div.firstChild.nodeValue.slice(0, -1);
|
||
}
|
||
return seen[s] = value;
|
||
});
|
||
};
|
||
goog.string.unescapePureXmlEntities_ = function(str) {
|
||
return str.replace(/&([^;]+);/g, function(s, entity) {
|
||
switch(entity) {
|
||
case "amp":
|
||
return "\x26";
|
||
case "lt":
|
||
return "\x3c";
|
||
case "gt":
|
||
return "\x3e";
|
||
case "quot":
|
||
return '"';
|
||
default:
|
||
if (entity.charAt(0) == "#") {
|
||
const n = Number("0" + entity.slice(1));
|
||
if (!isNaN(n)) {
|
||
return String.fromCharCode(n);
|
||
}
|
||
}
|
||
return s;
|
||
}
|
||
});
|
||
};
|
||
goog.string.HTML_ENTITY_PATTERN_ = /&([^;\s<&]+);?/g;
|
||
goog.string.whitespaceEscape = function(str, opt_xml) {
|
||
return goog.string.newLineToBr(str.replace(/ /g, " \x26#160;"), opt_xml);
|
||
};
|
||
goog.string.preserveSpaces = function(str) {
|
||
return str.replace(/(^|[\n ]) /g, "$1" + goog.string.Unicode.NBSP);
|
||
};
|
||
goog.string.stripQuotes = function(str, quoteChars) {
|
||
const length = quoteChars.length;
|
||
for (let i = 0; i < length; i++) {
|
||
const quoteChar = length == 1 ? quoteChars : quoteChars.charAt(i);
|
||
if (str.charAt(0) == quoteChar && str.charAt(str.length - 1) == quoteChar) {
|
||
return str.substring(1, str.length - 1);
|
||
}
|
||
}
|
||
return str;
|
||
};
|
||
goog.string.truncate = function(str, chars, opt_protectEscapedCharacters) {
|
||
if (opt_protectEscapedCharacters) {
|
||
str = goog.string.unescapeEntities(str);
|
||
}
|
||
if (str.length > chars) {
|
||
str = str.substring(0, chars - 3) + "...";
|
||
}
|
||
if (opt_protectEscapedCharacters) {
|
||
str = goog.string.htmlEscape(str);
|
||
}
|
||
return str;
|
||
};
|
||
goog.string.truncateMiddle = function(str, chars, opt_protectEscapedCharacters, opt_trailingChars) {
|
||
if (opt_protectEscapedCharacters) {
|
||
str = goog.string.unescapeEntities(str);
|
||
}
|
||
if (opt_trailingChars && str.length > chars) {
|
||
if (opt_trailingChars > chars) {
|
||
opt_trailingChars = chars;
|
||
}
|
||
const endPoint = str.length - opt_trailingChars;
|
||
const startPoint = chars - opt_trailingChars;
|
||
str = str.substring(0, startPoint) + "..." + str.substring(endPoint);
|
||
} else if (str.length > chars) {
|
||
let half = Math.floor(chars / 2);
|
||
const endPos = str.length - half;
|
||
half += chars % 2;
|
||
str = str.substring(0, half) + "..." + str.substring(endPos);
|
||
}
|
||
if (opt_protectEscapedCharacters) {
|
||
str = goog.string.htmlEscape(str);
|
||
}
|
||
return str;
|
||
};
|
||
goog.string.specialEscapeChars_ = {"\x00":"\\0", "\b":"\\b", "\f":"\\f", "\n":"\\n", "\r":"\\r", "\t":"\\t", "\v":"\\x0B", '"':'\\"', "\\":"\\\\", "\x3c":"\\u003C"};
|
||
goog.string.jsEscapeCache_ = {"'":"\\'"};
|
||
goog.string.quote = function(s) {
|
||
s = String(s);
|
||
const sb = ['"'];
|
||
for (let i = 0; i < s.length; i++) {
|
||
const ch = s.charAt(i);
|
||
const cc = ch.charCodeAt(0);
|
||
sb[i + 1] = goog.string.specialEscapeChars_[ch] || (cc > 31 && cc < 127 ? ch : goog.string.escapeChar(ch));
|
||
}
|
||
sb.push('"');
|
||
return sb.join("");
|
||
};
|
||
goog.string.escapeString = function(str) {
|
||
const sb = [];
|
||
for (let i = 0; i < str.length; i++) {
|
||
sb[i] = goog.string.escapeChar(str.charAt(i));
|
||
}
|
||
return sb.join("");
|
||
};
|
||
goog.string.escapeChar = function(c) {
|
||
if (c in goog.string.jsEscapeCache_) {
|
||
return goog.string.jsEscapeCache_[c];
|
||
}
|
||
if (c in goog.string.specialEscapeChars_) {
|
||
return goog.string.jsEscapeCache_[c] = goog.string.specialEscapeChars_[c];
|
||
}
|
||
let rv = c;
|
||
const cc = c.charCodeAt(0);
|
||
if (cc > 31 && cc < 127) {
|
||
rv = c;
|
||
} else {
|
||
if (cc < 256) {
|
||
rv = "\\x";
|
||
if (cc < 16 || cc > 256) {
|
||
rv += "0";
|
||
}
|
||
} else {
|
||
rv = "\\u";
|
||
if (cc < 4096) {
|
||
rv += "0";
|
||
}
|
||
}
|
||
rv += cc.toString(16).toUpperCase();
|
||
}
|
||
return goog.string.jsEscapeCache_[c] = rv;
|
||
};
|
||
goog.string.contains = goog.string.internal.contains;
|
||
goog.string.caseInsensitiveContains = goog.string.internal.caseInsensitiveContains;
|
||
goog.string.countOf = function(s, ss) {
|
||
return s && ss ? s.split(ss).length - 1 : 0;
|
||
};
|
||
goog.string.removeAt = function(s, index, stringLength) {
|
||
let resultStr = s;
|
||
if (index >= 0 && index < s.length && stringLength > 0) {
|
||
resultStr = s.slice(0, index) + s.slice(index + stringLength);
|
||
}
|
||
return resultStr;
|
||
};
|
||
goog.string.remove = function(str, substr) {
|
||
return str.replace(substr, "");
|
||
};
|
||
goog.string.removeAll = function(s, ss) {
|
||
const re = new RegExp(goog.string.regExpEscape(ss), "g");
|
||
return s.replace(re, "");
|
||
};
|
||
goog.string.replaceAll = function(s, ss, replacement) {
|
||
const re = new RegExp(goog.string.regExpEscape(ss), "g");
|
||
return s.replace(re, replacement.replace(/\$/g, "$$$$"));
|
||
};
|
||
goog.string.regExpEscape = function(s) {
|
||
return String(s).replace(/([-()\[\]{}+?*.$\^|,:#<!\\])/g, "\\$1").replace(/\x08/g, "\\x08");
|
||
};
|
||
goog.string.repeat = String.prototype.repeat ? function(string, length) {
|
||
return string.repeat(length);
|
||
} : function(string, length) {
|
||
return (new Array(length + 1)).join(string);
|
||
};
|
||
goog.string.padNumber = function(num, length, opt_precision) {
|
||
if (!Number.isFinite(num)) {
|
||
return String(num);
|
||
}
|
||
let s = opt_precision !== undefined ? num.toFixed(opt_precision) : String(num);
|
||
let index = s.indexOf(".");
|
||
if (index === -1) {
|
||
index = s.length;
|
||
}
|
||
const sign = s[0] === "-" ? "-" : "";
|
||
if (sign) {
|
||
s = s.substring(1);
|
||
}
|
||
return sign + goog.string.repeat("0", Math.max(0, length - index)) + s;
|
||
};
|
||
goog.string.makeSafe = function(obj) {
|
||
return obj == null ? "" : String(obj);
|
||
};
|
||
goog.string.getRandomString = function() {
|
||
const x = 2147483648;
|
||
return Math.floor(Math.random() * x).toString(36) + Math.abs(Math.floor(Math.random() * x) ^ goog.now()).toString(36);
|
||
};
|
||
goog.string.compareVersions = goog.string.internal.compareVersions;
|
||
goog.string.hashCode = function(str) {
|
||
let result = 0;
|
||
for (let i = 0; i < str.length; ++i) {
|
||
result = 31 * result + str.charCodeAt(i) >>> 0;
|
||
}
|
||
return result;
|
||
};
|
||
goog.string.uniqueStringCounter_ = Math.random() * 2147483648 | 0;
|
||
goog.string.createUniqueString = function() {
|
||
return "goog_" + goog.string.uniqueStringCounter_++;
|
||
};
|
||
goog.string.toNumber = function(str) {
|
||
const num = Number(str);
|
||
if (num == 0 && goog.string.isEmptyOrWhitespace(str)) {
|
||
return NaN;
|
||
}
|
||
return num;
|
||
};
|
||
goog.string.isLowerCamelCase = function(str) {
|
||
return /^[a-z]+([A-Z][a-z]*)*$/.test(str);
|
||
};
|
||
goog.string.isUpperCamelCase = function(str) {
|
||
return /^([A-Z][a-z]*)+$/.test(str);
|
||
};
|
||
goog.string.toCamelCase = function(str) {
|
||
return String(str).replace(/\-([a-z])/g, function(all, match) {
|
||
return match.toUpperCase();
|
||
});
|
||
};
|
||
goog.string.toSelectorCase = function(str) {
|
||
return String(str).replace(/([A-Z])/g, "-$1").toLowerCase();
|
||
};
|
||
goog.string.toTitleCase = function(str, opt_delimiters) {
|
||
let delimiters = typeof opt_delimiters === "string" ? goog.string.regExpEscape(opt_delimiters) : "\\s";
|
||
delimiters = delimiters ? "|[" + delimiters + "]+" : "";
|
||
const regexp = new RegExp("(^" + delimiters + ")([a-z])", "g");
|
||
return str.replace(regexp, function(all, p1, p2) {
|
||
return p1 + p2.toUpperCase();
|
||
});
|
||
};
|
||
goog.string.capitalize = function(str) {
|
||
return String(str.charAt(0)).toUpperCase() + String(str.slice(1)).toLowerCase();
|
||
};
|
||
goog.string.parseInt = function(value) {
|
||
if (isFinite(value)) {
|
||
value = String(value);
|
||
}
|
||
if (typeof value === "string") {
|
||
return /^\s*-?0x/i.test(value) ? parseInt(value, 16) : parseInt(value, 10);
|
||
}
|
||
return NaN;
|
||
};
|
||
goog.string.splitLimit = function(str, separator, limit) {
|
||
const parts = str.split(separator);
|
||
const returnVal = [];
|
||
while (limit > 0 && parts.length) {
|
||
returnVal.push(parts.shift());
|
||
limit--;
|
||
}
|
||
if (parts.length) {
|
||
returnVal.push(parts.join(separator));
|
||
}
|
||
return returnVal;
|
||
};
|
||
goog.string.lastComponent = function(str, separators) {
|
||
if (!separators) {
|
||
return str;
|
||
} else if (typeof separators == "string") {
|
||
separators = [separators];
|
||
}
|
||
let lastSeparatorIndex = -1;
|
||
for (let i = 0; i < separators.length; i++) {
|
||
if (separators[i] == "") {
|
||
continue;
|
||
}
|
||
const currentSeparatorIndex = str.lastIndexOf(separators[i]);
|
||
if (currentSeparatorIndex > lastSeparatorIndex) {
|
||
lastSeparatorIndex = currentSeparatorIndex;
|
||
}
|
||
}
|
||
if (lastSeparatorIndex == -1) {
|
||
return str;
|
||
}
|
||
return str.slice(lastSeparatorIndex + 1);
|
||
};
|
||
goog.string.editDistance = function(a, b) {
|
||
const v0 = [];
|
||
const v1 = [];
|
||
if (a == b) {
|
||
return 0;
|
||
}
|
||
if (!a.length || !b.length) {
|
||
return Math.max(a.length, b.length);
|
||
}
|
||
for (let i = 0; i < b.length + 1; i++) {
|
||
v0[i] = i;
|
||
}
|
||
for (let i = 0; i < a.length; i++) {
|
||
v1[0] = i + 1;
|
||
for (let j = 0; j < b.length; j++) {
|
||
const cost = Number(a[i] != b[j]);
|
||
v1[j + 1] = Math.min(v1[j] + 1, v0[j + 1] + 1, v0[j] + cost);
|
||
}
|
||
for (let j = 0; j < v0.length; j++) {
|
||
v0[j] = v1[j];
|
||
}
|
||
}
|
||
return v1[b.length];
|
||
};
|