@paulirish/trace_engine 0.0.8 → 0.0.10

package/core/platform/platform.prebundle.ts

@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2019 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+import * as ArrayUtilities from './array-utilities.js';
+import * as DateUtilities from './date-utilities.js';
+import * as DevToolsPath from './DevToolsPath.js';
+import * as DOMUtilities from './dom-utilities.js';
+import * as KeyboardUtilities from './keyboard-utilities.js';
+import * as MapUtilities from './map-utilities.js';
+import * as NumberUtilities from './number-utilities.js';
+import * as SetUtilities from './set-utilities.js';
+import * as StringUtilities from './string-utilities.js';
+import * as TypeScriptUtilities from './typescript-utilities.js';
+import * as UIString from './UIString.js';
+import * as UserVisibleError from './UserVisibleError.js';
+
+export {DCHECK} from './dcheck.js';
+/* `assertNotNull` also need to be exposed, as TypeScript does not
+ * allow `asserts` functions to be used with qualified access
+ * (e.g. `Platform.TypeScriptUtilities.assertNotNull` causes a
+ * compiler error)
+ */
+export {assertNever, assertNotNullOrUndefined, assertUnhandled} from './typescript-utilities.js';
+export {
+  ArrayUtilities,
+  DateUtilities,
+  DevToolsPath,
+  DOMUtilities,
+  KeyboardUtilities,
+  MapUtilities,
+  NumberUtilities,
+  SetUtilities,
+  StringUtilities,
+  TypeScriptUtilities,
+  UIString,
+  UserVisibleError,
+};

package/core/platform/promise-utilities.js

@@ -0,0 +1,10 @@
+export function promiseWithResolvers() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+//# sourceMappingURL=promise-utilities.js.map

package/core/platform/promise-utilities.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../front_end/core/platform/promise-utilities.ts"],
+  "sourcesContent": ["// Copyright 2023 The Chromium Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style license that can be\n// found in the LICENSE file.\n\n/**\n * Returns a new pending promise together with it's resolve and reject functions.\n *\n * Polyfill for https://github.com/tc39/proposal-promise-with-resolvers.\n */\nexport function promiseWithResolvers<T = unknown>(): {\n  promise: Promise<T>,\n  resolve: (value: T|PromiseLike<T>) => void,\n  reject: (error?: Error) => void,\n} {\n  let resolve!: (value: T|PromiseLike<T>) => void;\n  let reject!: (error?: Error) => void;\n  const promise = new Promise<T>((res, rej) => {\n    resolve = res;\n    reject = rej;\n  });\n  return {promise, resolve, reject};\n}\n"],
+  "mappings": "AASO,uCAIL;AACA,MAAI;AACJ,MAAI;AACJ,QAAM,UAAU,IAAI,QAAW,CAAC,KAAK,QAAQ;AAC3C,cAAU;AACV,aAAS;AAAA;AAEX,SAAO,EAAC,SAAS,SAAS;AAAA;",
+  "names": []
+}

package/core/platform/set-utilities.d.ts

@@ -0,0 +1,2 @@
+export declare const addAll: <T>(set: Set<T>, iterable: Iterable<T>) => void;
+export declare const isEqual: <T>(setA: Set<T>, setB: Set<T>) => boolean;

package/core/platform/set-utilities.js

@@ -0,0 +1,20 @@
+export const addAll = function(set, iterable) {
+  for (const item of iterable) {
+    set.add(item);
+  }
+};
+export const isEqual = function(setA, setB) {
+  if (setA === setB) {
+    return true;
+  }
+  if (setA.size !== setB.size) {
+    return false;
+  }
+  for (const item of setA) {
+    if (!setB.has(item)) {
+      return false;
+    }
+  }
+  return true;
+};
+//# sourceMappingURL=set-utilities.js.map

package/core/platform/set-utilities.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../front_end/core/platform/set-utilities.ts"],
+  "sourcesContent": ["// Copyright (c) 2020 The Chromium Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style license that can be\n// found in the LICENSE file.\n\nexport const addAll = function<T>(set: Set<T>, iterable: Iterable<T>): void {\n  for (const item of iterable) {\n    set.add(item);\n  }\n};\n\nexport const isEqual = function<T>(setA: Set<T>, setB: Set<T>): boolean {\n  if (setA === setB) {\n    return true;\n  }\n  if (setA.size !== setB.size) {\n    return false;\n  }\n  for (const item of setA) {\n    if (!setB.has(item)) {\n      return false;\n    }\n  }\n  return true;\n};\n"],
+  "mappings": "AAIO,aAAM,SAAS,SAAY,KAAa,UAA6B;AAC1E,aAAW,QAAQ,UAAU;AAC3B,QAAI,IAAI;AAAA;AAAA;AAIL,aAAM,UAAU,SAAY,MAAc,MAAuB;AACtE,MAAI,SAAS,MAAM;AACjB,WAAO;AAAA;AAET,MAAI,KAAK,SAAS,KAAK,MAAM;AAC3B,WAAO;AAAA;AAET,aAAW,QAAQ,MAAM;AACvB,QAAI,CAAC,KAAK,IAAI,OAAO;AACnB,aAAO;AAAA;AAAA;AAGX,SAAO;AAAA;",
+  "names": []
+}

package/core/platform/string-utilities.d.ts

@@ -0,0 +1,40 @@
+export declare const escapeCharacters: (inputString: string, charsToEscape: string) => string;
+export declare const formatAsJSLiteral: (content: string) => string;
+/**
+ * This implements a subset of the sprintf() function described in the Single UNIX
+ * Specification. It supports the %s, %f, %d, and %% formatting specifiers, and
+ * understands the %m$d notation to select the m-th parameter for this substitution,
+ * as well as the optional precision for %s, %f, and %d.
+ *
+ * @param fmt format string.
+ * @param args parameters to the format string.
+ * @returns the formatted output string.
+ */
+export declare const sprintf: (fmt: string, ...args: unknown[]) => string;
+export declare const toBase64: (inputString: string) => string;
+export declare const findIndexesOfSubString: (inputString: string, searchString: string) => number[];
+export declare const findLineEndingIndexes: (inputString: string) => number[];
+export declare const isWhitespace: (inputString: string) => boolean;
+export declare const trimURL: (url: string, baseURLDomain?: string) => string;
+export declare const collapseWhitespace: (inputString: string) => string;
+export declare const reverse: (inputString: string) => string;
+export declare const replaceControlCharacters: (inputString: string) => string;
+export declare const countWtf8Bytes: (inputString: string) => number;
+export declare const stripLineBreaks: (inputStr: string) => string;
+export declare const toTitleCase: (inputStr: string) => string;
+export declare const removeURLFragment: (inputStr: string) => string;
+export declare const regexSpecialCharacters: () => string;
+export declare const filterRegex: (query: string) => RegExp;
+export declare const createSearchRegex: (query: string, caseSensitive: boolean, isRegex: boolean) => RegExp;
+export declare const caseInsensetiveComparator: (a: string, b: string) => number;
+export declare const hashCode: (string?: string) => number;
+export declare const compare: (a: string, b: string) => number;
+export declare const trimMiddle: (str: string, maxLength: number) => string;
+export declare const trimEndWithMaxLength: (str: string, maxLength: number) => string;
+export declare const escapeForRegExp: (str: string) => string;
+export declare const naturalOrderComparator: (a: string, b: string) => number;
+export declare const base64ToSize: (content: string | null) => number;
+export declare const SINGLE_QUOTE = "'";
+export declare const DOUBLE_QUOTE = "\"";
+export declare const findUnclosedCssQuote: (str: string) => string;
+export declare const createPlainTextSearchRegex: (query: string, flags?: string) => RegExp;

package/core/platform/string-utilities.js

@@ -0,0 +1,439 @@
+export const escapeCharacters = (inputString, charsToEscape) => {
+  let foundChar = false;
+  for (let i = 0; i < charsToEscape.length; ++i) {
+    if (inputString.indexOf(charsToEscape.charAt(i)) !== -1) {
+      foundChar = true;
+      break;
+    }
+  }
+  if (!foundChar) {
+    return String(inputString);
+  }
+  let result = "";
+  for (let i = 0; i < inputString.length; ++i) {
+    if (charsToEscape.indexOf(inputString.charAt(i)) !== -1) {
+      result += "\\";
+    }
+    result += inputString.charAt(i);
+  }
+  return result;
+};
+const toHexadecimal = (charCode, padToLength) => {
+  return charCode.toString(16).toUpperCase().padStart(padToLength, "0");
+};
+const escapedReplacements = /* @__PURE__ */ new Map([
+  ["\b", "\\b"],
+  ["\f", "\\f"],
+  ["\n", "\\n"],
+  ["\r", "\\r"],
+  ["	", "\\t"],
+  ["\v", "\\v"],
+  ["'", "\\'"],
+  ["\\", "\\\\"],
+  ["<!--", "\\x3C!--"],
+  ["<script", "\\x3Cscript"],
+  ["<\/script", "\\x3C/script"]
+]);
+export const formatAsJSLiteral = (content) => {
+  const patternsToEscape = /(\\|<(?:!--|\/?script))|(\p{Control})|(\p{Surrogate})/gu;
+  const patternsToEscapePlusSingleQuote = /(\\|'|<(?:!--|\/?script))|(\p{Control})|(\p{Surrogate})/gu;
+  const escapePattern = (match, pattern, controlChar, loneSurrogate) => {
+    if (controlChar) {
+      if (escapedReplacements.has(controlChar)) {
+        return escapedReplacements.get(controlChar);
+      }
+      const twoDigitHex = toHexadecimal(controlChar.charCodeAt(0), 2);
+      return "\\x" + twoDigitHex;
+    }
+    if (loneSurrogate) {
+      const fourDigitHex = toHexadecimal(loneSurrogate.charCodeAt(0), 4);
+      return "\\u" + fourDigitHex;
+    }
+    if (pattern) {
+      return escapedReplacements.get(pattern) || "";
+    }
+    return match;
+  };
+  let escapedContent = "";
+  let quote = "";
+  if (!content.includes("'")) {
+    quote = "'";
+    escapedContent = content.replaceAll(patternsToEscape, escapePattern);
+  } else if (!content.includes('"')) {
+    quote = '"';
+    escapedContent = content.replaceAll(patternsToEscape, escapePattern);
+  } else if (!content.includes("`") && !content.includes("${")) {
+    quote = "`";
+    escapedContent = content.replaceAll(patternsToEscape, escapePattern);
+  } else {
+    quote = "'";
+    escapedContent = content.replaceAll(patternsToEscapePlusSingleQuote, escapePattern);
+  }
+  return `${quote}${escapedContent}${quote}`;
+};
+export const sprintf = (fmt, ...args) => {
+  let argIndex = 0;
+  const RE = /%(?:(\d+)\$)?(?:\.(\d*))?([%dfs])/g;
+  return fmt.replaceAll(RE, (_, index, precision, specifier) => {
+    if (specifier === "%") {
+      return "%";
+    }
+    if (index !== void 0) {
+      argIndex = parseInt(index, 10) - 1;
+      if (argIndex < 0) {
+        throw new RangeError(`Invalid parameter index ${argIndex + 1}`);
+      }
+    }
+    if (argIndex >= args.length) {
+      throw new RangeError(`Expected at least ${argIndex + 1} format parameters, but only ${args.length} where given.`);
+    }
+    if (specifier === "s") {
+      const argValue2 = String(args[argIndex++]);
+      if (precision !== void 0) {
+        return argValue2.substring(0, Number(precision));
+      }
+      return argValue2;
+    }
+    let argValue = Number(args[argIndex++]);
+    if (isNaN(argValue)) {
+      argValue = 0;
+    }
+    if (specifier === "d") {
+      return String(Math.floor(argValue)).padStart(Number(precision), "0");
+    }
+    if (precision !== void 0) {
+      return argValue.toFixed(Number(precision));
+    }
+    return String(argValue);
+  });
+};
+export const toBase64 = (inputString) => {
+  function encodeBits(b) {
+    return b < 26 ? b + 65 : b < 52 ? b + 71 : b < 62 ? b - 4 : b === 62 ? 43 : b === 63 ? 47 : 65;
+  }
+  const encoder = new TextEncoder();
+  const data = encoder.encode(inputString.toString());
+  const n = data.length;
+  let encoded = "";
+  if (n === 0) {
+    return encoded;
+  }
+  let shift;
+  let v = 0;
+  for (let i = 0; i < n; i++) {
+    shift = i % 3;
+    v |= data[i] << (16 >>> shift & 24);
+    if (shift === 2) {
+      encoded += String.fromCharCode(encodeBits(v >>> 18 & 63), encodeBits(v >>> 12 & 63), encodeBits(v >>> 6 & 63), encodeBits(v & 63));
+      v = 0;
+    }
+  }
+  if (shift === 0) {
+    encoded += String.fromCharCode(encodeBits(v >>> 18 & 63), encodeBits(v >>> 12 & 63), 61, 61);
+  } else if (shift === 1) {
+    encoded += String.fromCharCode(encodeBits(v >>> 18 & 63), encodeBits(v >>> 12 & 63), encodeBits(v >>> 6 & 63), 61);
+  }
+  return encoded;
+};
+export const findIndexesOfSubString = (inputString, searchString) => {
+  const matches = [];
+  let i = inputString.indexOf(searchString);
+  while (i !== -1) {
+    matches.push(i);
+    i = inputString.indexOf(searchString, i + searchString.length);
+  }
+  return matches;
+};
+export const findLineEndingIndexes = (inputString) => {
+  const endings = findIndexesOfSubString(inputString, "\n");
+  endings.push(inputString.length);
+  return endings;
+};
+export const isWhitespace = (inputString) => {
+  return /^\s*$/.test(inputString);
+};
+export const trimURL = (url, baseURLDomain) => {
+  let result = url.replace(/^(https|http|file):\/\//i, "");
+  if (baseURLDomain) {
+    if (result.toLowerCase().startsWith(baseURLDomain.toLowerCase())) {
+      result = result.substr(baseURLDomain.length);
+    }
+  }
+  return result;
+};
+export const collapseWhitespace = (inputString) => {
+  return inputString.replace(/[\s\xA0]+/g, " ");
+};
+export const reverse = (inputString) => {
+  return inputString.split("").reverse().join("");
+};
+export const replaceControlCharacters = (inputString) => {
+  return inputString.replace(/[\0-\x08\x0B\f\x0E-\x1F\x80-\x9F]/g, "\uFFFD");
+};
+export const countWtf8Bytes = (inputString) => {
+  let count = 0;
+  for (let i = 0; i < inputString.length; i++) {
+    const c = inputString.charCodeAt(i);
+    if (c <= 127) {
+      count++;
+    } else if (c <= 2047) {
+      count += 2;
+    } else if (c < 55296 || 57343 < c) {
+      count += 3;
+    } else {
+      if (c <= 56319 && i + 1 < inputString.length) {
+        const next = inputString.charCodeAt(i + 1);
+        if (56320 <= next && next <= 57343) {
+          count += 4;
+          i++;
+          continue;
+        }
+      }
+      count += 3;
+    }
+  }
+  return count;
+};
+export const stripLineBreaks = (inputStr) => {
+  return inputStr.replace(/(\r)?\n/g, "");
+};
+const EXTENDED_KEBAB_CASE_REGEXP = /^([a-z0-9]+(?:-[a-z0-9]+)*\.)*[a-z0-9]+(?:-[a-z0-9]+)*$/;
+export const isExtendedKebabCase = (inputStr) => {
+  return EXTENDED_KEBAB_CASE_REGEXP.test(inputStr);
+};
+export const toTitleCase = (inputStr) => {
+  return inputStr.substring(0, 1).toUpperCase() + inputStr.substring(1);
+};
+export const removeURLFragment = (inputStr) => {
+  const url = new URL(inputStr);
+  url.hash = "";
+  return url.toString();
+};
+const SPECIAL_REGEX_CHARACTERS = "^[]{}()\\.^$*+?|-,";
+export const regexSpecialCharacters = function() {
+  return SPECIAL_REGEX_CHARACTERS;
+};
+export const filterRegex = function(query) {
+  let regexString = "^(?:.*\\0)?";
+  for (let i = 0; i < query.length; ++i) {
+    let c = query.charAt(i);
+    if (SPECIAL_REGEX_CHARACTERS.indexOf(c) !== -1) {
+      c = "\\" + c;
+    }
+    regexString += "[^\\0" + c + "]*" + c;
+  }
+  return new RegExp(regexString, "i");
+};
+export const createSearchRegex = function(query, caseSensitive, isRegex, matchWholeWord = false) {
+  const regexFlags = caseSensitive ? "g" : "gi";
+  let regexObject;
+  if (isRegex) {
+    try {
+      regexObject = new RegExp(query, regexFlags);
+    } catch (e) {
+    }
+  }
+  if (!regexObject) {
+    regexObject = createPlainTextSearchRegex(query, regexFlags);
+  }
+  if (matchWholeWord && regexObject) {
+    regexObject = new RegExp(`\\b${regexObject.source}\\b`, regexFlags);
+  }
+  return regexObject;
+};
+export const caseInsensetiveComparator = function(a, b) {
+  a = a.toUpperCase();
+  b = b.toUpperCase();
+  if (a === b) {
+    return 0;
+  }
+  return a > b ? 1 : -1;
+};
+export const hashCode = function(string) {
+  if (!string) {
+    return 0;
+  }
+  const p = (1 << 30) * 4 - 5;
+  const z = 1345575271;
+  const z2 = 1506996573;
+  let s = 0;
+  let zi = 1;
+  for (let i = 0; i < string.length; i++) {
+    const xi = string.charCodeAt(i) * z2;
+    s = (s + zi * xi) % p;
+    zi = zi * z % p;
+  }
+  s = (s + zi * (p - 1)) % p;
+  return Math.abs(s | 0);
+};
+export const compare = (a, b) => {
+  if (a > b) {
+    return 1;
+  }
+  if (a < b) {
+    return -1;
+  }
+  return 0;
+};
+export const trimMiddle = (str, maxLength) => {
+  if (str.length <= maxLength) {
+    return String(str);
+  }
+  let leftHalf = maxLength >> 1;
+  let rightHalf = maxLength - leftHalf - 1;
+  if (str.codePointAt(str.length - rightHalf - 1) >= 65536) {
+    --rightHalf;
+    ++leftHalf;
+  }
+  if (leftHalf > 0 && str.codePointAt(leftHalf - 1) >= 65536) {
+    --leftHalf;
+  }
+  return str.substr(0, leftHalf) + "\u2026" + str.substr(str.length - rightHalf, rightHalf);
+};
+export const trimEndWithMaxLength = (str, maxLength) => {
+  if (str.length <= maxLength) {
+    return String(str);
+  }
+  return str.substr(0, maxLength - 1) + "\u2026";
+};
+export const escapeForRegExp = (str) => {
+  return escapeCharacters(str, SPECIAL_REGEX_CHARACTERS);
+};
+export const naturalOrderComparator = (a, b) => {
+  const chunk = /^\d+|^\D+/;
+  let chunka, chunkb, anum, bnum;
+  while (true) {
+    if (a) {
+      if (!b) {
+        return 1;
+      }
+    } else {
+      if (b) {
+        return -1;
+      }
+      return 0;
+    }
+    chunka = a.match(chunk)[0];
+    chunkb = b.match(chunk)[0];
+    anum = !Number.isNaN(Number(chunka));
+    bnum = !Number.isNaN(Number(chunkb));
+    if (anum && !bnum) {
+      return -1;
+    }
+    if (bnum && !anum) {
+      return 1;
+    }
+    if (anum && bnum) {
+      const diff = Number(chunka) - Number(chunkb);
+      if (diff) {
+        return diff;
+      }
+      if (chunka.length !== chunkb.length) {
+        if (!Number(chunka) && !Number(chunkb)) {
+          return chunka.length - chunkb.length;
+        }
+        return chunkb.length - chunka.length;
+      }
+    } else if (chunka !== chunkb) {
+      return chunka < chunkb ? -1 : 1;
+    }
+    a = a.substring(chunka.length);
+    b = b.substring(chunkb.length);
+  }
+};
+export const base64ToSize = function(content) {
+  if (!content) {
+    return 0;
+  }
+  let size = content.length * 3 / 4;
+  if (content[content.length - 1] === "=") {
+    size--;
+  }
+  if (content.length > 1 && content[content.length - 2] === "=") {
+    size--;
+  }
+  return size;
+};
+export const SINGLE_QUOTE = "'";
+export const DOUBLE_QUOTE = '"';
+const BACKSLASH = "\\";
+export const findUnclosedCssQuote = function(str) {
+  let unmatchedQuote = "";
+  for (let i = 0; i < str.length; ++i) {
+    const char = str[i];
+    if (char === BACKSLASH) {
+      i++;
+      continue;
+    }
+    if (char === SINGLE_QUOTE || char === DOUBLE_QUOTE) {
+      if (unmatchedQuote === char) {
+        unmatchedQuote = "";
+      } else if (unmatchedQuote === "") {
+        unmatchedQuote = char;
+      }
+    }
+  }
+  return unmatchedQuote;
+};
+export const countUnmatchedLeftParentheses = (str) => {
+  let unmatchedCount = 0;
+  for (const c of str) {
+    if (c === "(") {
+      unmatchedCount++;
+    } else if (c === ")" && unmatchedCount > 0) {
+      unmatchedCount--;
+    }
+  }
+  return unmatchedCount;
+};
+export const createPlainTextSearchRegex = function(query, flags) {
+  let regex = "";
+  for (let i = 0; i < query.length; ++i) {
+    const c = query.charAt(i);
+    if (regexSpecialCharacters().indexOf(c) !== -1) {
+      regex += "\\";
+    }
+    regex += c;
+  }
+  return new RegExp(regex, flags || "");
+};
+class LowerCaseStringTag {
+  lowerCaseStringTag;
+}
+export const toLowerCaseString = function(input) {
+  return input.toLowerCase();
+};
+const WORD = /[A-Z]{2,}(?=[A-Z0-9][a-z0-9]+|\b)|[A-Za-z][0-9]+[a-z]|[A-Z]?[a-z]+|[0-9][A-Za-z]+|[A-Z]|[0-9]+|[.]/g;
+export const toKebabCase = function(input) {
+  return input.match?.(WORD)?.map((w) => w.toLowerCase()).join("-").replaceAll("-.-", ".") || input;
+};
+export function toKebabCaseKeys(settingValue) {
+  const result = {};
+  for (const [key, value] of Object.entries(settingValue)) {
+    result[toKebabCase(key)] = value;
+  }
+  return result;
+}
+export const replaceLast = function(input, search, replacement) {
+  const replacementStartIndex = input.lastIndexOf(search);
+  if (replacementStartIndex === -1) {
+    return input;
+  }
+  return input.slice(0, replacementStartIndex) + input.slice(replacementStartIndex).replace(search, replacement);
+};
+export const stringifyWithPrecision = function stringifyWithPrecision2(s, precision = 2) {
+  if (precision === 0) {
+    return s.toFixed(0);
+  }
+  const string = s.toFixed(precision).replace(/\.?0*$/, "");
+  return string === "-0" ? "0" : string;
+};
+export const concatBase64 = function(lhs, rhs) {
+  if (lhs.length === 0 || !lhs.endsWith("=")) {
+    return lhs + rhs;
+  }
+  const lhsLeaveAsIs = lhs.substring(0, lhs.length - 4);
+  const lhsToDecode = lhs.substring(lhs.length - 4);
+  return lhsLeaveAsIs + window.btoa(window.atob(lhsToDecode) + window.atob(rhs));
+};
+//# sourceMappingURL=string-utilities.js.map

package/core/platform/string-utilities.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../front_end/core/platform/string-utilities.ts"],
+  "sourcesContent": ["// Copyright (c) 2020 The Chromium Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style license that can be\n// found in the LICENSE file.\n\nexport const escapeCharacters = (inputString: string, charsToEscape: string): string => {\n  let foundChar = false;\n  for (let i = 0; i < charsToEscape.length; ++i) {\n    if (inputString.indexOf(charsToEscape.charAt(i)) !== -1) {\n      foundChar = true;\n      break;\n    }\n  }\n\n  if (!foundChar) {\n    return String(inputString);\n  }\n\n  let result = '';\n  for (let i = 0; i < inputString.length; ++i) {\n    if (charsToEscape.indexOf(inputString.charAt(i)) !== -1) {\n      result += '\\\\';\n    }\n    result += inputString.charAt(i);\n  }\n\n  return result;\n};\n\nconst toHexadecimal = (charCode: number, padToLength: number): string => {\n  return charCode.toString(16).toUpperCase().padStart(padToLength, '0');\n};\n\n// Remember to update the third group in the regexps patternsToEscape and\n// patternsToEscapePlusSingleQuote when adding new entries in this map.\nconst escapedReplacements = new Map([\n  ['\\b', '\\\\b'],\n  ['\\f', '\\\\f'],\n  ['\\n', '\\\\n'],\n  ['\\r', '\\\\r'],\n  ['\\t', '\\\\t'],\n  ['\\v', '\\\\v'],\n  ['\\'', '\\\\\\''],\n  ['\\\\', '\\\\\\\\'],\n  ['<!--', '\\\\x3C!--'],\n  ['<script', '\\\\x3Cscript'],\n  ['</script', '\\\\x3C/script'],\n]);\n\nexport const formatAsJSLiteral = (content: string): string => {\n  const patternsToEscape = /(\\\\|<(?:!--|\\/?script))|(\\p{Control})|(\\p{Surrogate})/gu;\n  const patternsToEscapePlusSingleQuote = /(\\\\|'|<(?:!--|\\/?script))|(\\p{Control})|(\\p{Surrogate})/gu;\n  const escapePattern = (match: string, pattern: string, controlChar: string, loneSurrogate: string): string => {\n    if (controlChar) {\n      if (escapedReplacements.has(controlChar)) {\n        // @ts-ignore https://github.com/microsoft/TypeScript/issues/13086\n        return escapedReplacements.get(controlChar);\n      }\n      const twoDigitHex = toHexadecimal(controlChar.charCodeAt(0), 2);\n      return '\\\\x' + twoDigitHex;\n    }\n    if (loneSurrogate) {\n      const fourDigitHex = toHexadecimal(loneSurrogate.charCodeAt(0), 4);\n      return '\\\\u' + fourDigitHex;\n    }\n    if (pattern) {\n      return escapedReplacements.get(pattern) || '';\n    }\n    return match;\n  };\n\n  let escapedContent = '';\n  let quote = '';\n  if (!content.includes('\\'')) {\n    quote = '\\'';\n    escapedContent = content.replaceAll(patternsToEscape, escapePattern);\n  } else if (!content.includes('\"')) {\n    quote = '\"';\n    escapedContent = content.replaceAll(patternsToEscape, escapePattern);\n  } else if (!content.includes('`') && !content.includes('${')) {\n    quote = '`';\n    escapedContent = content.replaceAll(patternsToEscape, escapePattern);\n  } else {\n    quote = '\\'';\n    escapedContent = content.replaceAll(patternsToEscapePlusSingleQuote, escapePattern);\n  }\n  return `${quote}${escapedContent}${quote}`;\n};\n\n/**\n * This implements a subset of the sprintf() function described in the Single UNIX\n * Specification. It supports the %s, %f, %d, and %% formatting specifiers, and\n * understands the %m$d notation to select the m-th parameter for this substitution,\n * as well as the optional precision for %s, %f, and %d.\n *\n * @param fmt format string.\n * @param args parameters to the format string.\n * @returns the formatted output string.\n */\nexport const sprintf = (fmt: string, ...args: unknown[]): string => {\n  let argIndex = 0;\n  const RE = /%(?:(\\d+)\\$)?(?:\\.(\\d*))?([%dfs])/g;\n  return fmt.replaceAll(RE, (_: string, index?: string, precision?: string, specifier?: string) => {\n    if (specifier === '%') {\n      return '%';\n    }\n    if (index !== undefined) {\n      argIndex = parseInt(index, 10) - 1;\n      if (argIndex < 0) {\n        throw new RangeError(`Invalid parameter index ${argIndex + 1}`);\n      }\n    }\n    if (argIndex >= args.length) {\n      throw new RangeError(`Expected at least ${argIndex + 1} format parameters, but only ${args.length} where given.`);\n    }\n    if (specifier === 's') {\n      const argValue = String(args[argIndex++]);\n      if (precision !== undefined) {\n        return argValue.substring(0, Number(precision));\n      }\n      return argValue;\n    }\n    let argValue = Number(args[argIndex++]);\n    if (isNaN(argValue)) {\n      argValue = 0;\n    }\n    if (specifier === 'd') {\n      return String(Math.floor(argValue)).padStart(Number(precision), '0');\n    }\n    if (precision !== undefined) {\n      return argValue.toFixed(Number(precision));\n    }\n    return String(argValue);\n  });\n};\n\nexport const toBase64 = (inputString: string): string => {\n  /* note to the reader: we can't use btoa here because we need to\n   * support Unicode correctly. See the test cases for this function and\n   * also\n   * https://developer.mozilla.org/en-US/docs/Web/API/WindowBase64/Base64_encoding_and_decoding#The_Unicode_Problem\n   */\n\n  function encodeBits(b: number): number {\n    return b < 26 ? b + 65 : b < 52 ? b + 71 : b < 62 ? b - 4 : b === 62 ? 43 : b === 63 ? 47 : 65;\n  }\n  const encoder = new TextEncoder();\n  const data = encoder.encode(inputString.toString());\n  const n = data.length;\n  let encoded = '';\n  if (n === 0) {\n    return encoded;\n  }\n  let shift;\n  let v = 0;\n  for (let i = 0; i < n; i++) {\n    shift = i % 3;\n    v |= data[i] << (16 >>> shift & 24);\n    if (shift === 2) {\n      encoded += String.fromCharCode(\n          encodeBits(v >>> 18 & 63), encodeBits(v >>> 12 & 63), encodeBits(v >>> 6 & 63), encodeBits(v & 63));\n      v = 0;\n    }\n  }\n  if (shift === 0) {\n    encoded += String.fromCharCode(encodeBits(v >>> 18 & 63), encodeBits(v >>> 12 & 63), 61, 61);\n  } else if (shift === 1) {\n    encoded += String.fromCharCode(encodeBits(v >>> 18 & 63), encodeBits(v >>> 12 & 63), encodeBits(v >>> 6 & 63), 61);\n  }\n  return encoded;\n};\n\nexport const findIndexesOfSubString = (inputString: string, searchString: string): number[] => {\n  const matches = [];\n  let i = inputString.indexOf(searchString);\n  while (i !== -1) {\n    matches.push(i);\n    i = inputString.indexOf(searchString, i + searchString.length);\n  }\n  return matches;\n};\n\nexport const findLineEndingIndexes = (inputString: string): number[] => {\n  const endings = findIndexesOfSubString(inputString, '\\n');\n  endings.push(inputString.length);\n  return endings;\n};\n\nexport const isWhitespace = (inputString: string): boolean => {\n  return /^\\s*$/.test(inputString);\n};\n\nexport const trimURL = (url: string, baseURLDomain?: string): string => {\n  let result = url.replace(/^(https|http|file):\\/\\//i, '');\n  if (baseURLDomain) {\n    if (result.toLowerCase().startsWith(baseURLDomain.toLowerCase())) {\n      result = result.substr(baseURLDomain.length);\n    }\n  }\n  return result;\n};\n\nexport const collapseWhitespace = (inputString: string): string => {\n  return inputString.replace(/[\\s\\xA0]+/g, ' ');\n};\n\nexport const reverse = (inputString: string): string => {\n  return inputString.split('').reverse().join('');\n};\n\nexport const replaceControlCharacters = (inputString: string): string => {\n  // Replace C0 and C1 control character sets with replacement character.\n  // Do not replace '\\t', \\n' and '\\r'.\n  return inputString.replace(/[\\0-\\x08\\x0B\\f\\x0E-\\x1F\\x80-\\x9F]/g, '\\uFFFD');\n};\n\nexport const countWtf8Bytes = (inputString: string): number => {\n  let count = 0;\n  for (let i = 0; i < inputString.length; i++) {\n    const c = inputString.charCodeAt(i);\n    if (c <= 0x7F) {\n      count++;\n    } else if (c <= 0x07FF) {\n      count += 2;\n    } else if (c < 0xD800 || 0xDFFF < c) {\n      count += 3;\n    } else {\n      if (c <= 0xDBFF && i + 1 < inputString.length) {\n        // The current character is a leading surrogate, and there is a\n        // next character.\n        const next = inputString.charCodeAt(i + 1);\n        if (0xDC00 <= next && next <= 0xDFFF) {\n          // The next character is a trailing surrogate, meaning this\n          // is a surrogate pair.\n          count += 4;\n          i++;\n          continue;\n        }\n      }\n      count += 3;\n    }\n  }\n  return count;\n};\n\nexport const stripLineBreaks = (inputStr: string): string => {\n  return inputStr.replace(/(\\r)?\\n/g, '');\n};\n\nconst EXTENDED_KEBAB_CASE_REGEXP = /^([a-z0-9]+(?:-[a-z0-9]+)*\\.)*[a-z0-9]+(?:-[a-z0-9]+)*$/;\n\n/**\n * Tests if the `inputStr` is following the extended Kebab Case naming convetion,\n * where words are separated with either a dash (`-`) or a dot (`.`), and all\n * characters must be lower-case alphanumeric.\n *\n * For example, it will yield `true` for `'my.amazing-string.literal'`, but `false`\n * for `'Another.AmazingLiteral'` or '`another_amazing_literal'`.\n *\n * @param inputStr the input string to test.\n * @return `true` if the `inputStr` follows the extended Kebab Case convention.\n */\nexport const isExtendedKebabCase = (inputStr: string): boolean => {\n  return EXTENDED_KEBAB_CASE_REGEXP.test(inputStr);\n};\n\nexport const toTitleCase = (inputStr: string): string => {\n  return inputStr.substring(0, 1).toUpperCase() + inputStr.substring(1);\n};\n\nexport const removeURLFragment = (inputStr: string): string => {\n  const url = new URL(inputStr);\n  url.hash = '';\n  return url.toString();\n};\n\nconst SPECIAL_REGEX_CHARACTERS = '^[]{}()\\\\.^$*+?|-,';\n\nexport const regexSpecialCharacters = function(): string {\n  return SPECIAL_REGEX_CHARACTERS;\n};\n\nexport const filterRegex = function(query: string): RegExp {\n  let regexString = '^(?:.*\\\\0)?';  // Start from beginning or after a \\0\n  for (let i = 0; i < query.length; ++i) {\n    let c = query.charAt(i);\n    if (SPECIAL_REGEX_CHARACTERS.indexOf(c) !== -1) {\n      c = '\\\\' + c;\n    }\n    regexString += '[^\\\\0' + c + ']*' + c;\n  }\n  return new RegExp(regexString, 'i');\n};\n\nexport const createSearchRegex = function(\n    query: string, caseSensitive: boolean, isRegex: boolean, matchWholeWord: boolean = false): RegExp {\n  const regexFlags = caseSensitive ? 'g' : 'gi';\n  let regexObject;\n\n  if (isRegex) {\n    try {\n      regexObject = new RegExp(query, regexFlags);\n    } catch (e) {\n      // Silent catch.\n    }\n  }\n\n  if (!regexObject) {\n    regexObject = createPlainTextSearchRegex(query, regexFlags);\n  }\n\n  if (matchWholeWord && regexObject) {\n    regexObject = new RegExp(`\\\\b${regexObject.source}\\\\b`, regexFlags);\n  }\n\n  return regexObject;\n};\n\nexport const caseInsensetiveComparator = function(a: string, b: string): number {\n  a = a.toUpperCase();\n  b = b.toUpperCase();\n  if (a === b) {\n    return 0;\n  }\n  return a > b ? 1 : -1;\n};\n\nexport const hashCode = function(string?: string): number {\n  if (!string) {\n    return 0;\n  }\n  // Hash algorithm for substrings is described in \"\u00DCber die Komplexit\u00E4t der Multiplikation in\n  // eingeschr\u00E4nkten Branchingprogrammmodellen\" by Woelfe.\n  // http://opendatastructures.org/versions/edition-0.1d/ods-java/node33.html#SECTION00832000000000000000\n  const p = ((1 << 30) * 4 - 5);  // prime: 2^32 - 5\n  const z = 0x5033d967;           // 32 bits from random.org\n  const z2 = 0x59d2f15d;          // random odd 32 bit number\n  let s = 0;\n  let zi = 1;\n  for (let i = 0; i < string.length; i++) {\n    const xi = string.charCodeAt(i) * z2;\n    s = (s + zi * xi) % p;\n    zi = (zi * z) % p;\n  }\n  s = (s + zi * (p - 1)) % p;\n  return Math.abs(s | 0);\n};\n\nexport const compare = (a: string, b: string): number => {\n  if (a > b) {\n    return 1;\n  }\n  if (a < b) {\n    return -1;\n  }\n  return 0;\n};\n\nexport const trimMiddle = (str: string, maxLength: number): string => {\n  if (str.length <= maxLength) {\n    return String(str);\n  }\n  let leftHalf = maxLength >> 1;\n  let rightHalf = maxLength - leftHalf - 1;\n  if ((str.codePointAt(str.length - rightHalf - 1) as number) >= 0x10000) {\n    --rightHalf;\n    ++leftHalf;\n  }\n  if (leftHalf > 0 && (str.codePointAt(leftHalf - 1) as number) >= 0x10000) {\n    --leftHalf;\n  }\n  return str.substr(0, leftHalf) + '\u2026' + str.substr(str.length - rightHalf, rightHalf);\n};\n\nexport const trimEndWithMaxLength = (str: string, maxLength: number): string => {\n  if (str.length <= maxLength) {\n    return String(str);\n  }\n  return str.substr(0, maxLength - 1) + '\u2026';\n};\n\nexport const escapeForRegExp = (str: string): string => {\n  return escapeCharacters(str, SPECIAL_REGEX_CHARACTERS);\n};\n\nexport const naturalOrderComparator = (a: string, b: string): number => {\n  const chunk = /^\\d+|^\\D+/;\n  let chunka, chunkb, anum, bnum;\n  while (true) {\n    if (a) {\n      if (!b) {\n        return 1;\n      }\n    } else {\n      if (b) {\n        return -1;\n      }\n      return 0;\n    }\n    chunka = (a.match(chunk) as string[])[0];\n    chunkb = (b.match(chunk) as string[])[0];\n    anum = !Number.isNaN(Number(chunka));\n    bnum = !Number.isNaN(Number(chunkb));\n    if (anum && !bnum) {\n      return -1;\n    }\n    if (bnum && !anum) {\n      return 1;\n    }\n    if (anum && bnum) {\n      const diff = Number(chunka) - Number(chunkb);\n      if (diff) {\n        return diff;\n      }\n      if (chunka.length !== chunkb.length) {\n        if (!Number(chunka) && !Number(chunkb)) {  // chunks are strings of all 0s (special case)\n          return chunka.length - chunkb.length;\n        }\n        return chunkb.length - chunka.length;\n      }\n    } else if (chunka !== chunkb) {\n      return (chunka < chunkb) ? -1 : 1;\n    }\n    a = a.substring(chunka.length);\n    b = b.substring(chunkb.length);\n  }\n};\n\nexport const base64ToSize = function(content: string|null): number {\n  if (!content) {\n    return 0;\n  }\n  let size = content.length * 3 / 4;\n  if (content[content.length - 1] === '=') {\n    size--;\n  }\n  if (content.length > 1 && content[content.length - 2] === '=') {\n    size--;\n  }\n  return size;\n};\n\nexport const SINGLE_QUOTE = '\\'';\nexport const DOUBLE_QUOTE = '\"';\nconst BACKSLASH = '\\\\';\n\nexport const findUnclosedCssQuote = function(str: string): string {\n  let unmatchedQuote = '';\n  for (let i = 0; i < str.length; ++i) {\n    const char = str[i];\n    if (char === BACKSLASH) {\n      i++;\n      continue;\n    }\n    if (char === SINGLE_QUOTE || char === DOUBLE_QUOTE) {\n      if (unmatchedQuote === char) {\n        unmatchedQuote = '';\n      } else if (unmatchedQuote === '') {\n        unmatchedQuote = char;\n      }\n    }\n  }\n  return unmatchedQuote;\n};\n\nexport const countUnmatchedLeftParentheses = (str: string): number => {\n  let unmatchedCount = 0;\n  for (const c of str) {\n    if (c === '(') {\n      unmatchedCount++;\n    } else if (c === ')' && unmatchedCount > 0) {\n      unmatchedCount--;\n    }\n  }\n  return unmatchedCount;\n};\n\nexport const createPlainTextSearchRegex = function(query: string, flags?: string): RegExp {\n  // This should be kept the same as the one in StringUtil.cpp.\n  let regex = '';\n  for (let i = 0; i < query.length; ++i) {\n    const c = query.charAt(i);\n    if (regexSpecialCharacters().indexOf(c) !== -1) {\n      regex += '\\\\';\n    }\n    regex += c;\n  }\n  return new RegExp(regex, flags || '');\n};\n\nclass LowerCaseStringTag {\n  private lowerCaseStringTag: (string|undefined);\n}\n\nexport type LowerCaseString = string&LowerCaseStringTag;\n\nexport const toLowerCaseString = function(input: string): LowerCaseString {\n  return input.toLowerCase() as LowerCaseString;\n};\n\nconst WORD = /[A-Z]{2,}(?=[A-Z0-9][a-z0-9]+|\\b)|[A-Za-z][0-9]+[a-z]|[A-Z]?[a-z]+|[0-9][A-Za-z]+|[A-Z]|[0-9]+|[.]/g;\n//            <---1---><-----------2----------> <--------3--------> <-----4----> <------5-----> <-----6----> <7>\n// 1: two or more consecutive uppercase letters. This is useful for identifying acronyms\n// 2: lookahead assertion that matches a word boundary\n// 3: numeronym: single letter followed by number and another letter\n// 4: word starting with an optional uppercase letter\n// 5: single digit followed by word to handle '3D' or '2px' (this might be controverial)\n// 6: single uppercase letter or number\n// 7: a dot character. We extract it into a separate word and remove dashes around it later.\n//    This is makes more sense conceptually and allows accounting for all possible word variants.\n//    Making dot a part of a word prevent us from handling acronyms or numeronyms after the word\n//    correctly without making the RegExp prohibitively complicated.\n// https://regex101.com/r/LtFugp/1\nexport const toKebabCase = function(input: string): Lowercase<string> {\n  return (input.match?.(WORD)?.map(w => w.toLowerCase()).join('-').replaceAll('-.-', '.') || input) as\n      Lowercase<string>;\n};\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\nexport function toKebabCaseKeys(settingValue: {\n  [x: string]: any,\n}): {[x: string]: any} {\n  const result: {\n    [x: string]: any,\n  } = {};\n  for (const [key, value] of Object.entries(settingValue)) {\n    result[toKebabCase(key)] = value;\n  }\n  return result;\n}\n/* eslint-enable @typescript-eslint/no-explicit-any */\n\n// Replaces the last ocurrence of parameter `search` with parameter `replacement` in `input`\nexport const replaceLast = function(input: string, search: string, replacement: string): string {\n  const replacementStartIndex = input.lastIndexOf(search);\n  if (replacementStartIndex === -1) {\n    return input;\n  }\n\n  return input.slice(0, replacementStartIndex) + input.slice(replacementStartIndex).replace(search, replacement);\n};\n\nexport const stringifyWithPrecision = function stringifyWithPrecision(s: number, precision = 2): string {\n  if (precision === 0) {\n    return s.toFixed(0);\n  }\n  const string = s.toFixed(precision).replace(/\\.?0*$/, '');\n  return string === '-0' ? '0' : string;\n};\n\n/**\n * Somewhat efficiently concatenates 2 base64 encoded strings.\n */\nexport const concatBase64 = function(lhs: string, rhs: string): string {\n  if (lhs.length === 0 || !lhs.endsWith('=')) {\n    // Empty string or no padding, we can straight-up concatenate.\n    return lhs + rhs;\n  }\n  const lhsLeaveAsIs = lhs.substring(0, lhs.length - 4);\n  const lhsToDecode = lhs.substring(lhs.length - 4);\n  return lhsLeaveAsIs + window.btoa(window.atob(lhsToDecode) + window.atob(rhs));\n};\n"],
+  "mappings": "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",
+  "names": []
+}