devtools-tracing 1.2.1 → 1.2.2

package/dist/lib/front_end/core/host/host.d.ts

@@ -0,0 +1,12 @@
+import * as AidaClient from './AidaClient.js';
+import * as AidaGcaTranslation from './AidaGcaTranslation.js';
+import * as DispatchHttpRequestClient from './DispatchHttpRequestClient.js';
+import * as GcaTypes from './GcaTypes.js';
+import * as GdpClient from './GdpClient.js';
+import * as InspectorFrontendHost from './InspectorFrontendHost.js';
+import * as InspectorFrontendHostAPI from './InspectorFrontendHostAPI.js';
+import * as Platform from './Platform.js';
+import * as ResourceLoader from './ResourceLoader.js';
+import * as UserMetrics from './UserMetrics.js';
+export { AidaClient, AidaGcaTranslation, DispatchHttpRequestClient, GcaTypes, GdpClient, InspectorFrontendHost, InspectorFrontendHostAPI, Platform, ResourceLoader, UserMetrics, };
+export declare const userMetrics: UserMetrics.UserMetrics;

package/dist/lib/front_end/core/i18n/ByteUtilities.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Returns string for bytes with legible units.
+ * If necessary, can convert bytes to Kb or MB.
+ */
+export declare const bytesToString: (bytes: number) => string;
+/**
+ * Returns a string for bytes converted to Kb.
+ * This is currently used on tables/rows to maintain consistency
+ * and avoid varying units.
+ */
+export declare const formatBytesToKb: (bytes: number) => string;

package/dist/lib/front_end/core/i18n/DevToolsLocale.d.ts

@@ -0,0 +1,41 @@
+export interface DevToolsLocaleData {
+    settingLanguage: string;
+    navigatorLanguage: string;
+    lookupClosestDevToolsLocale: (locale: string) => string;
+}
+export type DevToolsLocaleCreationOptions = {
+    create: true;
+    data: DevToolsLocaleData;
+} | {
+    create: false;
+};
+/**
+ * Simple class that determines the DevTools locale based on:
+ *   1) navigator.language, which matches the Chrome UI
+ *   2) the value of the "language" Setting the user choses
+ *   3) available locales in DevTools.
+ *
+ * The DevTools locale is only determined once during startup and
+ * guaranteed to never change. Use this class when using
+ * `Intl` APIs.
+ */
+export declare class DevToolsLocale {
+    readonly locale: string;
+    readonly lookupClosestDevToolsLocale: (locale: string) => string;
+    private constructor();
+    static instance(opts?: DevToolsLocaleCreationOptions): DevToolsLocale;
+    static removeInstance(): void;
+    forceFallbackLocale(): void;
+    /**
+     * Returns true iff DevTools supports the language of the passed locale.
+     * Note that it doesn't have to be a one-to-one match, e.g. if DevTools supports
+     * 'de', then passing 'de-AT' will return true.
+     */
+    languageIsSupportedByDevTools(localeString: string): boolean;
+}
+/**
+ * Returns true iff the two locales have matching languages. This means the
+ * passing 'de-AT' and 'de-DE' will return true, while 'de-DE' and 'en' will
+ * return false.
+ */
+export declare function localeLanguagesMatch(localeString1: string, localeString2: string): boolean;

package/dist/lib/front_end/core/i18n/NumberFormatter.d.ts

@@ -0,0 +1,11 @@
+export interface NumberFormatter {
+    format(value: number, separator?: string): string;
+    formatToParts(value: number): Intl.NumberFormatPart[];
+}
+/**
+ * Creates an instance of NumberFormatter.
+ *
+ * Safe to call in top-level of a module, since the creation of Intl.NumberFormat is deferred
+ * until first usage.
+ */
+export declare function defineFormatter(options: Intl.NumberFormatOptions): NumberFormatter;

package/dist/lib/front_end/core/i18n/i18n.d.ts

@@ -0,0 +1,6 @@
+import * as ByteUtilities from './ByteUtilities.js';
+import * as DevToolsLocale from './DevToolsLocale.js';
+import * as i18n from './i18nImpl.js';
+import * as NumberFormatter from './NumberFormatter.js';
+import * as TimeUtilities from './time-utilities.js';
+export { ByteUtilities, DevToolsLocale, i18n, NumberFormatter, TimeUtilities, };

package/dist/lib/front_end/core/i18n/i18nImpl.d.ts

@@ -0,0 +1,64 @@
+import * as I18n from '../../third_party/i18n/i18n.js';
+import type * as Platform from '../platform/platform.js';
+import { DevToolsLocale } from './DevToolsLocale.js';
+import type * as i18nTypes from './i18nTypes.js';
+/**
+ * Look up the best available locale for the requested language through these fall backs:
+ * - exact match
+ * - progressively shorter prefixes (`de-CH-1996` -> `de-CH` -> `de`)
+ * - the default locale ('en-US') if no match is found
+ *
+ * If `locale` isn't provided, the default is used.
+ */
+export declare function lookupClosestSupportedDevToolsLocale(locale: string): string;
+/**
+ * Returns a list of all supported DevTools locales, including pseudo locales.
+ */
+export declare function getAllSupportedDevToolsLocales(): string[];
+/**
+ * Fetches the locale data of the specified locale.
+ * Callers have to ensure that `locale` is an officially supported locale.
+ * Depending whether a locale is present in `bundledLocales`, the data will be
+ * fetched locally or remotely.
+ */
+export declare function fetchAndRegisterLocaleData(locale: Intl.UnicodeBCP47LocaleIdentifier, location?: string): Promise<void>;
+export declare function hasLocaleDataForTest(locale: Intl.UnicodeBCP47LocaleIdentifier): boolean;
+export declare function resetLocaleDataForTest(): void;
+export declare function registerLocaleDataForTest(locale: Intl.UnicodeBCP47LocaleIdentifier, messages: I18n.I18n.LocalizedMessages): void;
+/**
+ * Returns an anonymous function that wraps a call to retrieve a localized string.
+ * This is introduced so that localized strings can be declared in environments where
+ * the i18n system has not been configured and so, cannot be directly invoked. Instead,
+ * strings are lazily localized when they are used. This is used for instance in the
+ * meta files used to register module extensions.
+ */
+export declare function getLazilyComputedLocalizedString(registeredStrings: I18n.LocalizedStringSet.RegisteredFileStrings, id: string, values?: i18nTypes.Values): () => Platform.UIString.LocalizedString;
+/**
+ * Retrieve the localized string.
+ */
+export declare function getLocalizedString(registeredStrings: I18n.LocalizedStringSet.RegisteredFileStrings, id: string, values?: i18nTypes.Values): Platform.UIString.LocalizedString;
+/**
+ * Register a file's UIStrings with i18n, return function to generate the string ids.
+ */
+export declare function registerUIStrings(path: string, stringStructure: Record<string, string>): I18n.LocalizedStringSet.RegisteredFileStrings;
+export declare function serializeUIString(string: string, values?: Record<string, Object>): string;
+export declare function deserializeUIString(serializedMessage: string): i18nTypes.SerializedMessage;
+/**
+ * Use this function in places where a `LocalizedString` is expected but the
+ * term/phrase you want to use does not require translation.
+ */
+export declare function lockedString(str: string): Platform.UIString.LocalizedString;
+/**
+ * Same as `lockedString` but for places where `i18nLazyString` would be used otherwise.
+ */
+export declare function lockedLazyString(str: string): () => Platform.UIString.LocalizedString;
+/**
+ * Returns a string of the form:
+ *   "German (Austria) - Deutsch (Österreich)"
+ * where the former locale representation is written in the currently enabled DevTools
+ * locale and the latter locale representation is written in the locale of `localeString`.
+ *
+ * Should the two locales match (i.e. have the same language) then the latter locale
+ * representation is written in English.
+ */
+export declare function getLocalizedLanguageRegion(localeString: Intl.UnicodeBCP47LocaleIdentifier, devtoolsLocale: DevToolsLocale): Platform.UIString.LocalizedString;

package/dist/lib/front_end/core/i18n/i18nTypes.d.ts

@@ -0,0 +1,5 @@
+export type Values = Record<string, string | boolean | number>;
+export interface SerializedMessage {
+    string: string;
+    values: Values;
+}

package/dist/lib/front_end/core/i18n/time-utilities.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @file Uses Intl.NumberFormat.
+ * @see go/cpq:i18n-units-design
+ */
+import * as Platform from '../platform/platform.js';
+export declare function formatMicroSecondsTime(time: Platform.Timing.MicroSeconds): string;
+export declare function formatMicroSecondsAsSeconds(time: Platform.Timing.MicroSeconds): string;
+export declare function formatMicroSecondsAsMillisFixed(time: Platform.Timing.MicroSeconds): string;
+export declare function formatMicroSecondsAsMillisFixedExpanded(time: Platform.Timing.MicroSeconds): string;
+/**
+ * @param higherResolution if true, the output may show as microsends or as milliseconds with a fractional component
+ */
+export declare function millisToString(ms: number, higherResolution?: boolean): string;
+export declare function preciseMillisToString(ms: number, precision?: number, separator?: string): string;
+export declare function preciseSecondsToString(ms: number, precision?: number): string;
+export declare function secondsToString(seconds: number, higherResolution?: boolean): string;

package/dist/lib/front_end/core/platform/ArrayUtilities.d.ts

@@ -0,0 +1,69 @@
+export declare const removeElement: <T>(array: T[], element: T, firstOnly?: boolean) => boolean;
+type NumberComparator = (a: number, b: number) => number;
+export declare function swap<T>(array: T[], i1: number, i2: number): void;
+export declare function sortRange(array: number[], comparator: NumberComparator, leftBound: number, rightBound: number, sortWindowLeft: number, sortWindowRight: number): number[];
+export declare const binaryIndexOf: <T, S>(array: T[], value: S, comparator: (a: S, b: T) => number) => number;
+export declare const intersectOrdered: <T>(array1: T[], array2: T[], comparator: (a: T, b: T) => number) => T[];
+export declare const mergeOrdered: <T>(array1: T[], array2: T[], comparator: (a: T, b: T) => number) => T[];
+export declare const DEFAULT_COMPARATOR: (a: string | number, b: string | number) => -1 | 0 | 1;
+/**
+ * Returns the index of the element closest to the needle that is equal to or
+ * greater than it. Assumes that the provided array is sorted.
+ *
+ * If no element is found, the right bound is returned.
+ *
+ * Uses the provided comparator function to determine if two items are equal or
+ * if one is greater than the other. If you are working with strings or
+ * numbers, you can use ArrayUtilities.DEFAULT_COMPARATOR. Otherwise, you
+ * should define one that takes the needle element and an element from the
+ * array and returns a positive or negative number to indicate which is greater
+ * than the other.
+ *
+ * When specified, |left| (inclusive) and |right| (exclusive) indices
+ * define the search window.
+ */
+export declare function lowerBound<T>(array: Uint32Array | Int32Array, needle: T, comparator: (needle: T, b: number) => number, left?: number, right?: number): number;
+export declare function lowerBound<S, T>(array: S[], needle: T, comparator: (needle: T, b: S) => number, left?: number, right?: number): number;
+export declare function lowerBound<S, T>(array: readonly S[], needle: T, comparator: (needle: T, b: S) => number, left?: number, right?: number): number;
+/**
+ * Returns the index of the element closest to the needle that is greater than
+ * it. Assumes that the provided array is sorted.
+ *
+ * If no element is found, the right bound is returned.
+ *
+ * Uses the provided comparator function to determine if two items are equal or
+ * if one is greater than the other. If you are working with strings or
+ * numbers, you can use ArrayUtilities.DEFAULT_COMPARATOR. Otherwise, you
+ * should define one that takes the needle element and an element from the
+ * array and returns a positive or negative number to indicate which is greater
+ * than the other.
+ *
+ * When specified, |left| (inclusive) and |right| (exclusive) indices
+ * define the search window.
+ */
+export declare function upperBound<T>(array: Uint32Array, needle: T, comparator: (needle: T, b: number) => number, left?: number, right?: number): number;
+export declare function upperBound<S, T>(array: S[], needle: T, comparator: (needle: T, b: S) => number, left?: number, right?: number): number;
+/**
+ * Obtains the first item in the array that satisfies the predicate function.
+ * So, for example, if the array was arr = [2, 4, 6, 8, 10], and you are looking for
+ * the first item arr[i] such that arr[i] > 5 you would be returned 2, because
+ * array[2] is 6, the first item in the array that satisfies the
+ * predicate function.
+ *
+ * Please note: this presupposes that the array is already ordered.
+ */
+export declare function nearestIndexFromBeginning<T>(arr: T[], predicate: (arrayItem: T) => boolean): number | null;
+/**
+ * Obtains the last item in the array that satisfies the predicate function.
+ * So, for example, if the array was arr = [2, 4, 6, 8, 10], and you are looking for
+ * the last item arr[i] such that arr[i] < 5 you would be returned 1, because
+ * arr[1] is 4, the last item in the array that satisfies the
+ * predicate function.
+ *
+ * Please note: this presupposes that the array is already ordered.
+ */
+export declare function nearestIndexFromEnd<T>(arr: readonly T[], predicate: (arrayItem: T) => boolean): number | null;
+/** Type guard for ensuring that `arr` does not contain null or undefined **/
+export declare function arrayDoesNotContainNullOrUndefined<T>(arr: Array<T | null | undefined>): arr is T[];
+export declare function assertArrayIsSorted<T>(arr: readonly T[], compareFn?: (a: T, b: T) => number): void;
+export {};

package/dist/lib/front_end/core/platform/Brand.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Helper type to introduce new branded types.
+ *
+ * `Base` is the underlying data type and `Tag` must be unique symbol/string.
+ *
+ * Usage:
+ * ```ts
+ *   type LineNumber = Brand<number, "LineNumber">;
+ *   type RawUrl = Brand<string, "RawUrl">;
+ * ```
+ *
+ * We purposefully use the string index of `_tag` rather then creating a Symbol
+ * wrapper that would hide if in IDEs and fail build. This means that at build
+ * time if one uses `<branded-var>._tag`, it will build without error and have
+ * potentially having a runtime error. This allows us to have multiple places
+ * where we define the brands and they will overlap. Also a use case for reusing
+ * the type in other downstream projects is simplified.
+ */
+export type Brand<Base, Tag> = Base & {
+    _tag: Tag;
+};

package/dist/lib/front_end/core/platform/Constructor.d.ts

@@ -0,0 +1,3 @@
+export type Constructor<T, Args extends any[] = any[]> = new (...args: Args) => T;
+export type AbstractConstructor<T, Args extends any[] = any[]> = (abstract new (...args: Args) => T);
+export type ConstructorOrAbstract<T> = Constructor<T> | AbstractConstructor<T>;

package/dist/lib/front_end/core/platform/DateUtilities.d.ts

@@ -0,0 +1,2 @@
+export declare const isValid: (date: Date) => boolean;
+export declare const toISO8601Compact: (date: Date) => string;

package/dist/lib/front_end/core/platform/DevToolsPath.d.ts

@@ -0,0 +1,44 @@
+import type { Brand } from './Brand.js';
+/**
+ * URLs are in DevTools are repsented as encoded URL strings.
+ *
+ * @example 'file:///Hello%20World/file/js'
+ */
+export type UrlString = Brand<string, 'UrlString'>;
+export declare const EmptyUrlString: UrlString;
+/**
+ * Tagged template helper to construct `UrlString`s in a more readable form,
+ * without having to sprinkle casts throughout the codebase. Primarily useful
+ * for writing unit tests.
+ *
+ * Usage:
+ * ```js
+ * const url1 = urlString`https://www.example.com/404.html`;
+ * const url2 = urlString`http://${host}/path/to/file.js`;
+ * ```
+ *
+ * This is implemented as a wrapper around `String.raw` for convenience. This
+ * function doesn't perform any kind of validation that the returned string is
+ * really a valid `UrlString`.
+ *
+ * @param strings the string parts of the template.
+ * @param values the dynamic values of the template.
+ * @returns the string constructed from `strings` and `values` casted to an
+ *         `UrlString`.
+ */
+export declare const urlString: (strings: ArrayLike<string>, ...values: any[]) => UrlString;
+/**
+ * File paths in DevTools that are represented as unencoded absolute
+ * or relative paths.
+ *
+ * @example '/Hello World/file.js'
+ */
+export type RawPathString = Brand<string, 'RawPathString'>;
+export declare const EmptyRawPathString: RawPathString;
+/**
+ * File paths in DevTools that are represented as encoded paths.
+ *
+ * @example '/Hello%20World/file.js'
+ */
+export type EncodedPathString = Brand<string, 'EncodedPathString'>;
+export declare const EmptyEncodedPathString: EncodedPathString;

package/dist/lib/front_end/core/platform/HostRuntime.d.ts

@@ -0,0 +1,3 @@
+export declare const IS_NODE: boolean;
+export declare const IS_BROWSER: boolean;
+export declare const HOST_RUNTIME: any;

package/dist/lib/front_end/core/platform/KeyboardUtilities.d.ts

@@ -0,0 +1,21 @@
+export declare const enum ArrowKey {
+    UP = "ArrowUp",
+    DOWN = "ArrowDown",
+    LEFT = "ArrowLeft",
+    RIGHT = "ArrowRight"
+}
+export declare const enum PageKey {
+    UP = "PageUp",
+    DOWN = "PageDown"
+}
+export declare const ENTER_KEY = "Enter";
+export declare const ESCAPE_KEY = "Escape";
+export declare const TAB_KEY = "Tab";
+export declare const ARROW_KEYS: Set<ArrowKey>;
+export declare function keyIsArrowKey(key: string): key is ArrowKey;
+export declare function isEscKey(event: {
+    readonly key: string;
+}): boolean;
+export declare function isEnterOrSpaceKey(event: {
+    readonly key: string;
+}): boolean;

package/dist/lib/front_end/core/platform/MapUtilities.d.ts

@@ -0,0 +1,19 @@
+export declare const inverse: <K, V>(map: Map<K, V>) => Multimap<V, K>;
+export declare class Multimap<K, V> {
+    private map;
+    set(key: K, value: V): void;
+    get(key: K): Set<V>;
+    has(key: K): boolean;
+    hasValue(key: K, value: V): boolean;
+    get size(): number;
+    delete(key: K, value: V): boolean;
+    deleteAll(key: K): void;
+    keysArray(): K[];
+    keys(): IterableIterator<K>;
+    valuesArray(): V[];
+    clear(): void;
+}
+/**
+ * Gets value for key, assigning a default if value is falsy.
+ */
+export declare function getWithDefault<K extends {}, V>(map: WeakMap<K, V> | Map<K, V>, key: K, defaultValueFactory: (key?: K) => V): V;

package/dist/lib/front_end/core/platform/MimeType.d.ts

@@ -0,0 +1,28 @@
+export declare const enum MimeType {
+    HTML = "text/html",
+    XML = "text/xml",
+    PLAIN = "text/plain",
+    XHTML = "application/xhtml+xml",
+    SVG = "image/svg+xml",
+    CSS = "text/css",
+    XSL = "text/xsl",
+    VTT = "text/vtt",
+    PDF = "application/pdf",
+    EVENTSTREAM = "text/event-stream"
+}
+/**
+ * @returns true iff `mimeType` has textual content. Concretely we return true if:
+ *   - `mimeType` starts with "text/" or "multipart/"
+ *   - `mimeType` ends with "+xml"
+ *   - `mimeType` contains "json"
+ *   - if `mimeType` is one of a predefined list textual mime types.
+ */
+export declare function isTextType(mimeType: string): boolean;
+/**
+ * Port of net::HttpUtils::ParseContentType to extract mimeType and charset from
+ * the 'Content-Type' header.
+ */
+export declare function parseContentType(contentType: string): {
+    mimeType: string | null;
+    charset: string | null;
+};

package/dist/lib/front_end/core/platform/NumberUtilities.d.ts

@@ -0,0 +1,14 @@
+export declare const clamp: (num: number, min: number, max: number) => number;
+export declare const mod: (m: number, n: number) => number;
+export declare const toFixedIfFloating: (value: string) => string;
+/**
+ * Rounds a number (including float) down.
+ */
+export declare const floor: (value: number, precision?: number) => number;
+/**
+ * Computes the great common divisor for two numbers.
+ * If the numbers are floats, they will be rounded to an integer.
+ */
+export declare const greatestCommonDivisor: (a: number, b: number) => number;
+export declare const aspectRatio: (width: number, height: number) => string;
+export declare const withThousandsSeparator: (num: number) => string;

package/dist/lib/front_end/core/platform/StringUtilities.d.ts

@@ -0,0 +1,77 @@
+import type { Brand } from './Brand.js';
+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;
+/**
+ * Tests if the `inputStr` is following the extended Kebab Case naming convention,
+ * where words are separated with either a dash (`-`) or a dot (`.`), and all
+ * characters must be lower-case alphanumeric.
+ *
+ * For example, it will yield `true` for `'my.amazing-string.literal'`, but `false`
+ * for `'Another.AmazingLiteral'` or '`another_amazing_literal'`.
+ *
+ * @param inputStr the input string to test.
+ * @returns `true` if the `inputStr` follows the extended Kebab Case convention.
+ */
+export declare const isExtendedKebabCase: (inputStr: string) => boolean;
+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, matchWholeWord?: 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;
+/** Returns a string that has no more than maxLength characters. Actual graphemes are used, not bytes. */
+export declare const trimMiddle: (str: string, maxLength: number) => string;
+/** Returns a string that has no more than maxLength characters. Actual graphemes are used, not bytes. */
+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 countUnmatchedLeftParentheses: (str: string) => number;
+export declare const createPlainTextSearchRegex: (query: string, flags?: string) => RegExp;
+export type LowerCaseString = Brand<string, 'lowerCaseStringTag'>;
+export declare const toLowerCaseString: (input: string) => LowerCaseString;
+export declare const toKebabCase: (input: string) => Lowercase<string>;
+export declare function toKebabCaseKeys<T>(settingValue: Record<string, T>): Record<string, T>;
+/**
+ * Converts a given string to snake_case.
+ * This function handles camelCase, PascalCase, and acronyms, including transitions between letters and numbers.
+ * It uses Unicode-aware regular expressions (`\p{L}`, `\p{N}`, `\p{Lu}`, `\p{Ll}` with the `u` flag)
+ * to correctly process letters and numbers from various languages.
+ *
+ * @param text The input string to convert to snake_case.
+ * @returns The snake_case version of the input string.
+ */
+export declare function toSnakeCase(text: string): string;
+/** Replaces the last occurrence of parameter `search` with parameter `replacement` in `input` **/
+export declare const replaceLast: (input: string, search: string, replacement: string) => string;
+export declare const stringifyWithPrecision: (s: number, precision?: number) => string;
+/**
+ * Somewhat efficiently concatenates 2 base64 encoded strings.
+ */
+export declare const concatBase64: (lhs: string, rhs: string) => string;

package/dist/lib/front_end/core/platform/Timing.d.ts

@@ -0,0 +1,6 @@
+import type { Brand } from './Brand.js';
+export type Seconds = Brand<number, 'Seconds'>;
+export type MilliSeconds = Brand<number, 'MilliSeconds'>;
+export type MicroSeconds = Brand<number, 'MicroSeconds'>;
+export declare function milliSecondsToSeconds(x: MilliSeconds): Seconds;
+export declare function microSecondsToMilliSeconds(x: MicroSeconds): MilliSeconds;

package/dist/lib/front_end/core/platform/TypedArrayUtilities.d.ts

@@ -0,0 +1,34 @@
+/**
+ * An object which provides functionality similar to Uint32Array. It may be
+ * implemented as:
+ * 1. A Uint32Array,
+ * 2. An array of Uint32Arrays, to support more data than Uint32Array, or
+ * 3. A plain array, in which case the length may change by setting values.
+ */
+export interface BigUint32Array {
+    get length(): number;
+    getValue(index: number): number;
+    setValue(index: number, value: number): void;
+    asUint32ArrayOrFail(): Uint32Array;
+    asArrayOrFail(): number[];
+}
+/**
+ * @returns A BigUint32Array implementation which is based on Array.
+ * This means that its length automatically expands to include the highest index
+ * used, and asArrayOrFail will succeed.
+ */
+export declare function createExpandableBigUint32Array(): BigUint32Array;
+/**
+ * @returns A BigUint32Array implementation which is based on Uint32Array.
+ * If the length is small enough to fit in a single Uint32Array, then
+ * asUint32ArrayOrFail will succeed. Otherwise, it will throw an exception.
+ */
+export declare function createFixedBigUint32Array(length: number, maxLengthForTesting?: number): BigUint32Array;
+export interface BitVector {
+    getBit(index: number): boolean;
+    setBit(index: number): void;
+    clearBit(index: number): void;
+    previous(index: number): number;
+    get buffer(): ArrayBuffer;
+}
+export declare function createBitVector(lengthOrBuffer: number | ArrayBuffer): BitVector;

package/dist/lib/front_end/core/platform/TypescriptUtilities.d.ts

@@ -0,0 +1,66 @@
+/**
+ * This is useful to keep TypeScript happy in a test - if you have a value
+ * that's potentially `null` you can use this function to assert that it isn't,
+ * and satisfy TypeScript that the value is present.
+ */
+export declare function assertNotNullOrUndefined<T>(val: T, message?: string): asserts val is NonNullable<T>;
+export declare function assertNever(_type: never, message: string): never;
+/**
+ * This is useful to check on the type-level that the unhandled cases of
+ * a switch are exactly `T` (where T is usually a union type of enum values).
+ * @param caseVariable
+ */
+export declare function assertUnhandled<T>(_caseVariable: T): T;
+export type FieldsThatExtend<Type, Selector> = {
+    [Key in keyof Type]: Type[Key] extends Selector ? Key : never;
+}[keyof Type];
+export type PickFieldsThatExtend<Type, Selector> = Pick<Type, FieldsThatExtend<Type, Selector>>;
+/**
+ * Turns a Union type (a | b) into an Intersection type (a & b).
+ * This is a helper type to implement the "NoUnion" guard.
+ *
+ * Adapted from https://stackoverflow.com/a/50375286.
+ *
+ * The tautological `T extends any` is necessary to trigger distributivity for
+ * plain unions, e.g. in IntersectionFromUnion<'a'|'b'> TypeScript expands it
+ * to  ('a' extends any ? (arg: 'a') => void : never)
+ *  |  ('b' extends any ? (arg: 'b') => void : never)
+ *
+ * The second extends clause then asks TypeScript to find a type of the form
+ * `(arg: infer U) => void` that upper-bounds the union, i.e., intuitively,
+ * a type that converts to each of the union members. This forces U to be the
+ * intersection of 'a' and 'b' in the example.
+ *
+ * Please note that some intersection types are simply impossible, e.g.
+ * `string & number`. There is no type that fulfills both at the same time. A
+ * union of this kind is reduced to `never`.
+ */
+type IntersectionFromUnion<T> = (T extends any ? (arg: T) => void : never) extends ((arg: infer U) => void) ? U : never;
+/**
+ * When writing generic code it may be desired to disallow Union types from
+ * being passed. This type can be used in those cases.
+ *
+ *   function foo<T>(argument: NoUnion<T>) {...}
+ *
+ * Would result in a compile error for foo<a|b>(...); invocations as `argument`
+ * would be typed as `never`.
+ *
+ * Adapted from https://stackoverflow.com/a/50641073.
+ *
+ * Conditional types become distributive when receiving a union type. To
+ * prevent this from happening, we use `[T] extends [IntersectionFromUnion<T>]`
+ * instead of `T extends IntersectionFromUnion<T>`.
+ * See: https://www.typescriptlang.org/docs/handbook/2/conditional-types.html
+ */
+export type NoUnion<T> = [T] extends [IntersectionFromUnion<T>] ? T : never;
+export type RecursivePartial<T> = {
+    [P in keyof T]?: RecursivePartial<T[P]>;
+};
+/**
+ * Note this does not recursively
+ * make Array items readonly at the moment
+ */
+export type RecursiveReadonly<T> = {
+    [P in keyof T]: Readonly<RecursiveReadonly<T[P]>>;
+};
+export {};

package/dist/lib/front_end/core/platform/UIString.d.ts

@@ -0,0 +1,3 @@
+import type { Brand } from './Brand.js';
+export type LocalizedString = Brand<string, 'LocalizedString'>;
+export declare const LocalizedEmptyString: LocalizedString;

package/dist/lib/front_end/core/platform/UserVisibleError.d.ts

@@ -0,0 +1,12 @@
+import type { LocalizedString } from './UIString.js';
+/**
+ * Represents an error that might become visible to the user. Where errors
+ * might be surfaced to the user (such as by displaying the message to the
+ * console), this class should be used to enforce that the message is
+ * localized on the way in.
+ */
+export declare class UserVisibleError extends Error {
+    readonly message: LocalizedString;
+    constructor(message: LocalizedString);
+}
+export declare function isUserVisibleError(error: unknown): error is UserVisibleError;