devtools-tracing 1.2.1 → 1.3.0

package/dist/lib/front_end/core/common/App.d.ts

@@ -0,0 +1,3 @@
+export interface App {
+    presentUI(document: Document): void;
+}

package/dist/lib/front_end/core/common/AppProvider.d.ts

@@ -0,0 +1,12 @@
+import * as Root from '../root/root.js';
+import type { App } from './App.js';
+export interface AppProvider {
+    createApp(): App;
+}
+export declare function registerAppProvider(registration: AppProviderRegistration): void;
+export declare function getRegisteredAppProviders(): AppProviderRegistration[];
+export interface AppProviderRegistration {
+    loadAppProvider: () => Promise<AppProvider>;
+    condition?: Root.Runtime.Condition;
+    order: number;
+}

package/dist/lib/front_end/core/common/Base64.d.ts

@@ -0,0 +1,11 @@
+export declare const BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+export declare const BASE64_CODES: Uint8Array<ArrayBuffer>;
+/**
+ * Decodes Base64-encoded data from a string without performing any kind of checking.
+ */
+export declare function decode(input: string): Uint8Array<ArrayBuffer>;
+/**
+ * Note: if input can be very large (larger than the max string size), callers should
+ * expect this to throw an error.
+ */
+export declare function encode(input: BlobPart): Promise<string>;

package/dist/lib/front_end/core/common/CharacterIdMap.d.ts

@@ -0,0 +1,5 @@
+export declare class CharacterIdMap<T> {
+    #private;
+    toChar(object: T): string;
+    fromChar(character: string): T | null;
+}

package/dist/lib/front_end/core/common/Color.d.ts

@@ -0,0 +1,383 @@
+import { type Color3D, type Color4D, type Color4DOr3D } from './ColorUtils.js';
+/** Returns the `Format` equivalent from the format text **/
+export declare function getFormat(formatText: string): Format | null;
+type ColorSpace = Format.SRGB | Format.SRGB_LINEAR | Format.DISPLAY_P3 | Format.A98_RGB | Format.PROPHOTO_RGB | Format.REC_2020 | Format.XYZ | Format.XYZ_D50 | Format.XYZ_D65;
+export declare const enum ColorChannel {
+    A = "a",
+    ALPHA = "alpha",
+    B = "b",
+    C = "c",
+    G = "g",
+    H = "h",
+    L = "l",
+    R = "r",
+    S = "s",
+    W = "w",
+    X = "x",
+    Y = "y",
+    Z = "z"
+}
+export declare function parse(text: string): Color | null;
+export declare function parseHueNumeric(value: string): number | null;
+export declare function hsl2rgb(hsl: Color4D): Color4D;
+export declare function hsva2rgba(hsva: Color4D): Color4D;
+export declare function rgb2hsv(rgba: Color3D): Color3D;
+/**
+ * Compute a desired luminance given a given luminance and a desired contrast
+ * ratio.
+ */
+export declare function desiredLuminance(luminance: number, contrast: number, lighter: boolean): number;
+/**
+ * Approach a value of the given component of `candidateHSVA` such that the
+ * calculated luminance of `candidateHSVA` approximates `desiredLuminance`.
+ */
+export declare function approachColorValue(candidateHSVA: Color4D, index: number, desiredLuminance: number, candidateLuminance: (arg0: Color4D) => number): number | null;
+export declare function findFgColorForContrast(fgColor: Legacy, bgColor: Legacy, requiredContrast: number): Legacy | null;
+export declare function findFgColorForContrastAPCA(fgColor: Legacy, bgColor: Legacy, requiredContrast: number): Legacy | null;
+type ColorParameterSpec = [string, string, string, string | undefined];
+interface ColorConversions<T = void> {
+    [Format.HEX](self: T): Legacy;
+    [Format.HEXA](self: T): Legacy;
+    [Format.RGB](self: T): Legacy;
+    [Format.RGBA](self: T): Legacy;
+    [Format.HSL](self: T): HSL;
+    [Format.HSLA](self: T): HSL;
+    [Format.HWB](self: T): HWB;
+    [Format.HWBA](self: T): HWB;
+    [Format.LCH](self: T): LCH;
+    [Format.OKLCH](self: T): Oklch;
+    [Format.LAB](self: T): Lab;
+    [Format.OKLAB](self: T): Oklab;
+    [Format.SRGB](self: T): ColorFunction;
+    [Format.SRGB_LINEAR](self: T): ColorFunction;
+    [Format.DISPLAY_P3](self: T): ColorFunction;
+    [Format.A98_RGB](self: T): ColorFunction;
+    [Format.PROPHOTO_RGB](self: T): ColorFunction;
+    [Format.REC_2020](self: T): ColorFunction;
+    [Format.XYZ](self: T): ColorFunction;
+    [Format.XYZ_D50](self: T): ColorFunction;
+    [Format.XYZ_D65](self: T): ColorFunction;
+}
+export interface Color {
+    readonly alpha: number | null;
+    readonly channels: [ColorChannel, ColorChannel, ColorChannel, ColorChannel];
+    equal(color: Color): boolean;
+    asString(format?: Format): string;
+    setAlpha(alpha: number): Color;
+    format(): Format;
+    as<T extends Format>(format: T): ReturnType<ColorConversions[T]>;
+    is<T extends Format>(format: T): this is ReturnType<ColorConversions[T]>;
+    asLegacyColor(): Legacy;
+    getAuthoredText(): string | null;
+    getRawParameters(): Color3D;
+    getAsRawString(format?: Format): string;
+    isGamutClipped(): boolean;
+}
+export declare const enum Format {
+    HEX = "hex",
+    HEXA = "hexa",
+    RGB = "rgb",
+    RGBA = "rgba",
+    HSL = "hsl",
+    HSLA = "hsla",
+    HWB = "hwb",
+    HWBA = "hwba",
+    LCH = "lch",
+    OKLCH = "oklch",
+    LAB = "lab",
+    OKLAB = "oklab",
+    SRGB = "srgb",
+    SRGB_LINEAR = "srgb-linear",
+    DISPLAY_P3 = "display-p3",
+    A98_RGB = "a98-rgb",
+    PROPHOTO_RGB = "prophoto-rgb",
+    REC_2020 = "rec2020",
+    XYZ = "xyz",
+    XYZ_D50 = "xyz-d50",
+    XYZ_D65 = "xyz-d65"
+}
+export declare class Lab implements Color {
+    #private;
+    readonly l: number;
+    readonly a: number;
+    readonly b: number;
+    readonly alpha: number | null;
+    readonly channels: [ColorChannel, ColorChannel, ColorChannel, ColorChannel];
+    constructor(l: number, a: number, b: number, alpha: number | null, authoredText?: string);
+    is<T extends Format>(format: T): this is ReturnType<ColorConversions[T]>;
+    as<T extends Format>(format: T): ReturnType<ColorConversions[T]>;
+    asLegacyColor(): Legacy;
+    equal(color: Color): boolean;
+    format(): Format;
+    setAlpha(alpha: number): Lab;
+    asString(format?: Format): string;
+    getAuthoredText(): string | null;
+    getRawParameters(): Color3D;
+    getAsRawString(format?: Format): string;
+    isGamutClipped(): boolean;
+    static fromSpec(spec: ColorParameterSpec, text: string): Lab | null;
+}
+export declare class LCH implements Color {
+    #private;
+    readonly l: number;
+    readonly c: number;
+    readonly h: number;
+    readonly alpha: number | null;
+    readonly channels: [ColorChannel, ColorChannel, ColorChannel, ColorChannel];
+    constructor(l: number, c: number, h: number, alpha: number | null, authoredText?: string);
+    asLegacyColor(): Legacy;
+    is<T extends Format>(format: T): this is ReturnType<ColorConversions[T]>;
+    as<T extends Format>(format: T): ReturnType<ColorConversions[T]>;
+    equal(color: Color): boolean;
+    format(): Format;
+    setAlpha(alpha: number): Color;
+    asString(format?: Format): string;
+    getAuthoredText(): string | null;
+    getRawParameters(): Color3D;
+    getAsRawString(format?: Format): string;
+    isGamutClipped(): boolean;
+    isHuePowerless(): boolean;
+    static fromSpec(spec: ColorParameterSpec, text: string): LCH | null;
+}
+export declare class Oklab implements Color {
+    #private;
+    readonly l: number;
+    readonly a: number;
+    readonly b: number;
+    readonly alpha: number | null;
+    readonly channels: [ColorChannel, ColorChannel, ColorChannel, ColorChannel];
+    constructor(l: number, a: number, b: number, alpha: number | null, authoredText?: string);
+    asLegacyColor(): Legacy;
+    is<T extends Format>(format: T): this is ReturnType<ColorConversions[T]>;
+    as<T extends Format>(format: T): ReturnType<ColorConversions[T]>;
+    equal(color: Color): boolean;
+    format(): Format;
+    setAlpha(alpha: number): Color;
+    asString(format?: Format): string;
+    getAuthoredText(): string | null;
+    getRawParameters(): Color3D;
+    getAsRawString(format?: Format): string;
+    isGamutClipped(): boolean;
+    static fromSpec(spec: ColorParameterSpec, text: string): Oklab | null;
+}
+export declare class Oklch implements Color {
+    #private;
+    readonly l: number;
+    readonly c: number;
+    readonly h: number;
+    readonly alpha: number | null;
+    readonly channels: [ColorChannel, ColorChannel, ColorChannel, ColorChannel];
+    constructor(l: number, c: number, h: number, alpha: number | null, authoredText?: string);
+    asLegacyColor(): Legacy;
+    is<T extends Format>(format: T): this is ReturnType<ColorConversions[T]>;
+    as<T extends Format>(format: T): ReturnType<ColorConversions[T]>;
+    equal(color: Color): boolean;
+    format(): Format;
+    setAlpha(alpha: number): Color;
+    asString(format?: Format): string;
+    getAuthoredText(): string | null;
+    getRawParameters(): Color3D;
+    getAsRawString(format?: Format): string;
+    isGamutClipped(): boolean;
+    static fromSpec(spec: ColorParameterSpec, text: string): Oklch | null;
+}
+export declare class ColorFunction implements Color {
+    #private;
+    readonly p0: number;
+    readonly p1: number;
+    readonly p2: number;
+    readonly alpha: number | null;
+    readonly colorSpace: ColorSpace;
+    get channels(): [ColorChannel, ColorChannel, ColorChannel, ColorChannel];
+    constructor(colorSpace: ColorSpace, p0: number, p1: number, p2: number, alpha: number | null, authoredText?: string);
+    asLegacyColor(): Legacy;
+    is<T extends Format>(format: T): this is ReturnType<ColorConversions[T]>;
+    as<T extends Format>(format: T): ReturnType<ColorConversions[T]>;
+    equal(color: Color): boolean;
+    format(): Format;
+    setAlpha(alpha: number): Color;
+    asString(format?: Format): string;
+    getAuthoredText(): string | null;
+    getRawParameters(): Color3D;
+    getAsRawString(format?: Format): string;
+    isGamutClipped(): boolean;
+    isXYZ(): boolean;
+    /**
+     * Parses given `color()` function definition and returns the `Color` object.
+     * We want to special case its parsing here because it's a bit different
+     * than other color functions: rgb, lch etc. accepts 3 arguments with
+     * optional alpha. This accepts 4 arguments with optional alpha.
+     *
+     * Instead of making `splitColorFunctionParameters` work for this case too
+     * I've decided to implement it specifically.
+     * @param authoredText Original definition of the color with `color`
+     * @param parametersText Inside of the `color()` function. ex, `display-p3 0.1 0.2 0.3 / 0%`
+     * @returns `Color` object
+     */
+    static fromSpec(authoredText: string, parametersWithAlphaText: string): ColorFunction | null;
+}
+export declare class HSL implements Color {
+    #private;
+    readonly h: number;
+    readonly s: number;
+    readonly l: number;
+    readonly alpha: number | null;
+    readonly channels: [ColorChannel, ColorChannel, ColorChannel, ColorChannel];
+    constructor(h: number, s: number, l: number, alpha?: number | null, authoredText?: string);
+    equal(color: Color): boolean;
+    asString(format?: Format): string;
+    setAlpha(alpha: number): HSL;
+    format(): Format;
+    is<T extends Format>(format: T): this is ReturnType<ColorConversions[T]>;
+    as<T extends Format>(format: T): ReturnType<ColorConversions[T]>;
+    asLegacyColor(): Legacy;
+    getAuthoredText(): string | null;
+    getRawParameters(): Color3D;
+    getAsRawString(format?: Format): string;
+    isGamutClipped(): boolean;
+    static fromSpec(spec: ColorParameterSpec, text: string): HSL | null;
+    hsva(): Color4D;
+    canonicalHSLA(): number[];
+}
+export declare class HWB implements Color {
+    #private;
+    readonly h: number;
+    readonly w: number;
+    readonly b: number;
+    readonly alpha: number | null;
+    readonly channels: [ColorChannel, ColorChannel, ColorChannel, ColorChannel];
+    constructor(h: number, w: number, b: number, alpha: number | null, authoredText?: string);
+    equal(color: Color): boolean;
+    asString(format?: Format): string;
+    setAlpha(alpha: number): HWB;
+    format(): Format;
+    is<T extends Format>(format: T): this is ReturnType<ColorConversions[T]>;
+    as<T extends Format>(format: T): ReturnType<ColorConversions[T]>;
+    asLegacyColor(): Legacy;
+    getAuthoredText(): string | null;
+    canonicalHWBA(): number[];
+    getRawParameters(): Color3D;
+    getAsRawString(format?: Format): string;
+    isGamutClipped(): boolean;
+    static fromSpec(spec: ColorParameterSpec, text: string): HWB | null;
+}
+type LegacyColor = Format.HEX | Format.HEXA | Format.RGB | Format.RGBA;
+declare abstract class ShortFormatColorBase implements Color {
+    protected readonly color: Legacy;
+    readonly channels: [ColorChannel, ColorChannel, ColorChannel, ColorChannel];
+    constructor(color: Legacy);
+    get alpha(): number | null;
+    rgba(): Color4D;
+    equal(color: Color): boolean;
+    setAlpha(alpha: number): Color;
+    format(): Format;
+    as<T extends Format>(format: T): ReturnType<ColorConversions<void>[T]>;
+    is<T extends Format>(format: T): this is ReturnType<ColorConversions<void>[T]>;
+    asLegacyColor(): Legacy;
+    getAuthoredText(): string | null;
+    getRawParameters(): Color3D;
+    isGamutClipped(): boolean;
+    asString(format?: Format): string;
+    getAsRawString(format?: Format): string;
+    protected abstract stringify(r: number, g: number, b: number): string;
+}
+export declare class ShortHex extends ShortFormatColorBase {
+    setAlpha(alpha: number): Color;
+    asString(format?: Format): string;
+    protected stringify(r: number, g: number, b: number): string;
+}
+export declare class Nickname extends ShortFormatColorBase {
+    readonly nickname: string;
+    constructor(nickname: string, color: Legacy);
+    static fromName(name: string, text: string): Nickname | null;
+    protected stringify(): string;
+    getAsRawString(format?: Format): string;
+}
+export declare class Legacy implements Color {
+    #private;
+    readonly channels: [ColorChannel, ColorChannel, ColorChannel, ColorChannel];
+    get alpha(): number | null;
+    asLegacyColor(): Legacy;
+    nickname(): Nickname | null;
+    shortHex(): ShortHex | null;
+    constructor(rgba: Color3D | Color4DOr3D, format: LegacyColor, authoredText?: string);
+    static fromHex(hex: string, text: string): Legacy | ShortHex;
+    static fromRGBAFunction(r: string, g: string, b: string, alpha: string, text: string): Legacy | null;
+    static fromRGBA(rgba: number[], authoredText?: string): Legacy;
+    static fromHSVA(hsva: Color4D): Legacy;
+    is<T extends Format>(format: T): this is ReturnType<ColorConversions[T]>;
+    as<T extends Format>(format: T): ReturnType<ColorConversions[T]>;
+    format(): LegacyColor;
+    hasAlpha(): boolean;
+    detectHEXFormat(): Format;
+    asString(format?: Format): string;
+    getAuthoredText(): string | null;
+    getRawParameters(): Color3D;
+    getAsRawString(format?: Format): string;
+    isGamutClipped(): boolean;
+    rgba(): Color4D;
+    canonicalRGBA(): Color4D;
+    toProtocolRGBA(): {
+        r: number;
+        g: number;
+        b: number;
+        a?: number;
+    };
+    invert(): Legacy;
+    /**
+     * Returns a new color using the NTSC formula for making a RGB color grayscale.
+     * Note: We override with an alpha of 50% to enhance the dimming effect.
+     */
+    grayscale(): Legacy;
+    setAlpha(alpha: number): Legacy;
+    blendWith(fgColor: Legacy): Legacy;
+    blendWithAlpha(alpha: number): Legacy;
+    setFormat(format: LegacyColor): void;
+    equal(other: Color): boolean;
+}
+export declare const Regex: RegExp;
+export declare const ColorMixRegex: RegExp;
+export declare const Nicknames: Map<string, number[]>;
+export declare const PageHighlight: {
+    Content: Legacy;
+    ContentLight: Legacy;
+    ContentOutline: Legacy;
+    Padding: Legacy;
+    PaddingLight: Legacy;
+    Border: Legacy;
+    BorderLight: Legacy;
+    Margin: Legacy;
+    MarginLight: Legacy;
+    EventTarget: Legacy;
+    Shape: Legacy;
+    ShapeMargin: Legacy;
+    CssGrid: Legacy;
+    LayoutLine: Legacy;
+    GridBorder: Legacy;
+    GapBackground: Legacy;
+    GapHatch: Legacy;
+    GridAreaBorder: Legacy;
+};
+export declare const SourceOrderHighlight: {
+    ParentOutline: Legacy;
+    ChildOutline: Legacy;
+};
+export declare const IsolationModeHighlight: {
+    Resizer: Legacy;
+    ResizerHandle: Legacy;
+    Mask: Legacy;
+};
+type Space = number | {
+    min: number;
+    max: number;
+    count?: number;
+};
+export declare class Generator {
+    #private;
+    constructor(hueSpace?: Space, satSpace?: Space, lightnessSpace?: Space, alphaSpace?: Space);
+    setColorForID(id: string, color: string): void;
+    colorForID(id: string): string;
+    private generateColorForID;
+    private indexToValueInSpace;
+}
+export {};

package/dist/lib/front_end/core/common/ColorConverter.d.ts

@@ -0,0 +1,24 @@
+export declare class ColorConverter {
+    static labToXyzd50(l: number, a: number, b: number): [number, number, number];
+    static xyzd50ToLab(x: number, y: number, z: number): [number, number, number];
+    static oklabToXyzd65(l: number, a: number, b: number): [number, number, number];
+    static xyzd65ToOklab(x: number, y: number, z: number): [number, number, number];
+    static lchToLab(l: number, c: number, h: number | undefined): [number, number, number];
+    static labToLch(l: number, a: number, b: number): [number, number, number];
+    static displayP3ToXyzd50(r: number, g: number, b: number): [number, number, number];
+    static xyzd50ToDisplayP3(x: number, y: number, z: number): [number, number, number];
+    static proPhotoToXyzd50(r: number, g: number, b: number): [number, number, number];
+    static xyzd50ToProPhoto(x: number, y: number, z: number): [number, number, number];
+    static adobeRGBToXyzd50(r: number, g: number, b: number): [number, number, number];
+    static xyzd50ToAdobeRGB(x: number, y: number, z: number): [number, number, number];
+    static rec2020ToXyzd50(r: number, g: number, b: number): [number, number, number];
+    static xyzd50ToRec2020(x: number, y: number, z: number): [number, number, number];
+    static xyzd50ToD65(x: number, y: number, z: number): [number, number, number];
+    static xyzd65ToD50(x: number, y: number, z: number): [number, number, number];
+    static xyzd50TosRGBLinear(x: number, y: number, z: number): [number, number, number];
+    static srgbLinearToXyzd50(r: number, g: number, b: number): [number, number, number];
+    static srgbToXyzd50(r: number, g: number, b: number): [number, number, number];
+    static xyzd50ToSrgb(x: number, y: number, z: number): [number, number, number];
+    static oklchToXyzd50(lInput: number, c: number, h: number): [number, number, number];
+    static xyzd50ToOklch(x: number, y: number, z: number): [number, number, number];
+}

package/dist/lib/front_end/core/common/ColorUtils.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Combine the two given colors according to alpha blending.
+ */
+export type Color4D = [number, number, number, number];
+export type Color3D = [number, number, number];
+export type Color4DOr3D = [number, number, number, number | undefined];
+export declare function blendColors(fgRGBA: Color4D, bgRGBA: Color4D): Color4D;
+export declare function rgbToHsl(rgb: Color3D): Color3D;
+export declare function rgbaToHsla([r, g, b, a]: Color4DOr3D): Color4DOr3D;
+export declare function rgbToHwb(rgb: Color3D): Color3D;
+export declare function rgbaToHwba([r, g, b, a]: Color4DOr3D): Color4DOr3D;
+/**
+ * Calculate the luminance of this color using the WCAG algorithm.
+ * See https://www.w3.org/TR/WCAG21/#dfn-relative-luminance.
+ */
+export declare function luminance([rSRGB, gSRGB, bSRGB]: number[]): number;
+/**
+ * Calculate the contrast ratio between a foreground and a background color.
+ * Returns the ratio to 1, for example for two two colors with a contrast ratio of 21:1, this function will return 21.
+ * See http://www.w3.org/TR/2008/REC-WCAG20-20081211/#contrast-ratiodef
+ */
+export declare function contrastRatio(fgRGBA: Color4D, bgRGBA: Color4D): number;
+/**
+ * Calculate relative luminance of a color.
+ * See https://github.com/Myndex/SAPC-APCA
+ */
+export declare function luminanceAPCA([rSRGB, gSRGB, bSRGB]: number[]): number;
+/**
+ * Calculate the contrast ratio between a foreground and a background color.
+ * Returns the percentage of the predicted visual contrast.
+ * See https://github.com/Myndex/SAPC-APCA
+ */
+export declare function contrastRatioAPCA(fgRGBA: Color4D, bgRGBA: Color4D): number;
+export declare function contrastRatioByLuminanceAPCA(fgLuminance: number, bgLuminance: number): number;
+/**
+ * Compute a desired luminance given a given luminance and a desired contrast
+ * percentage according to APCA.
+ */
+export declare function desiredLuminanceAPCA(luminance: number, contrast: number, lighter: boolean): number;
+export declare function getAPCAThreshold(fontSize: string, fontWeight: string): number | null;
+export declare function isLargeFont(fontSize: string, fontWeight: string): boolean;
+export declare function getContrastThreshold(fontSize: string, fontWeight: string): {
+    aa: number;
+    aaa: number;
+};

package/dist/lib/front_end/core/common/Console.d.ts

@@ -0,0 +1,54 @@
+import { ObjectWrapper } from './Object.js';
+export declare class Console extends ObjectWrapper<EventTypes> {
+    #private;
+    static instance(opts?: {
+        forceNew: boolean;
+    }): Console;
+    static removeInstance(): void;
+    /**
+     * Add a message to the Console panel.
+     *
+     * @param text the message text.
+     * @param level the message level.
+     * @param show whether to show the Console panel (if it's not already shown).
+     * @param source the message source.
+     */
+    addMessage(text: string, level?: MessageLevel, show?: boolean, source?: FrontendMessageSource): void;
+    log(text: string): void;
+    warn(text: string, source?: FrontendMessageSource): void;
+    /**
+     * Adds an error message to the Console panel.
+     *
+     * @param text the message text.
+     * @param show whether to show the Console panel (if it's not already shown).
+     */
+    error(text: string, show?: boolean): void;
+    messages(): Message[];
+    show(): void;
+    showPromise(): Promise<void>;
+}
+export declare const enum Events {
+    MESSAGE_ADDED = "messageAdded"
+}
+export interface EventTypes {
+    [Events.MESSAGE_ADDED]: Message;
+}
+export declare const enum MessageLevel {
+    INFO = "info",
+    WARNING = "warning",
+    ERROR = "error"
+}
+export declare enum FrontendMessageSource {
+    CSS = "css",
+    ConsoleAPI = "console-api",
+    ISSUE_PANEL = "issue-panel",
+    SELF_XSS = "self-xss"
+}
+export declare class Message {
+    text: string;
+    level: MessageLevel;
+    timestamp: number;
+    show: boolean;
+    source?: FrontendMessageSource;
+    constructor(text: string, level: MessageLevel, timestamp: number, show: boolean, source?: FrontendMessageSource);
+}

package/dist/lib/front_end/core/common/Debouncer.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Debounce utility function, ensures that the function passed in is only called once the function stops being called and the delay has expired.
+ */
+export declare const debounce: (func: (...args: any[]) => void, delay: number) => (...args: any[]) => void;
+export declare function enableTestOverride(): void;
+export declare function disableTestOverride(): void;

package/dist/lib/front_end/core/common/EventTarget.d.ts

@@ -0,0 +1,23 @@
+import type * as Platform from '../platform/platform.js';
+export interface EventDescriptor<Events = any, T extends keyof Events = any> {
+    eventTarget: EventTarget<Events>;
+    eventType: T;
+    thisObject?: Object;
+    listener: EventListener<Events, T>;
+}
+export declare function removeEventListeners(eventList: EventDescriptor[]): void;
+export type GenericEvents = Record<string, any>;
+export type EventPayloadToRestParameters<Events, T extends keyof Events> = Events[T] extends void ? [] : [Events[T]];
+export type EventListener<Events, T extends keyof Events> = (arg0: EventTargetEvent<Events[T], Events>) => void;
+export interface EventTarget<Events> {
+    addEventListener<T extends keyof Events>(eventType: T, listener: EventListener<Events, T>, thisObject?: Object): EventDescriptor<Events, T>;
+    once<T extends keyof Events>(eventType: T): Promise<Events[T]>;
+    removeEventListener<T extends keyof Events>(eventType: T, listener: EventListener<Events, T>, thisObject?: Object): void;
+    hasEventListeners(eventType: keyof Events): boolean;
+    dispatchEventToListeners<T extends keyof Events>(eventType: Platform.TypeScriptUtilities.NoUnion<T>, ...[eventData]: EventPayloadToRestParameters<Events, T>): void;
+}
+export declare function fireEvent(name: string, detail?: unknown, target?: HTMLElement | Window): void;
+export interface EventTargetEvent<T, Events = any> {
+    data: T;
+    source?: EventTarget<Events>;
+}

package/dist/lib/front_end/core/common/Gzip.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Quickly determine if gzipped, by seeing if the first 3 bytes of the file header match the gzip signature
+ */
+export declare function isGzip(ab: ArrayBufferLike): boolean;
+/** Decode a gzipped _or_ plain text ArrayBuffer to a decoded string */
+export declare function arrayBufferToString(ab: ArrayBufferLike): Promise<string>;
+export declare function fileToString(file: File): Promise<string>;
+/**
+ * Decompress a gzipped ArrayBuffer to a string.
+ * Consider using `arrayBufferToString` instead, which can handle both gzipped and plain text buffers.
+ */
+export declare function decompress(gzippedBuffer: ArrayBufferLike, charset?: string): Promise<string>;
+/**
+ * Decompress a deflate-encoded ArrayBuffer to a string.
+ * Tries 'deflate' (zlib wrapper) first, then falls back to 'deflate-raw'.
+ */
+export declare function decompressDeflate(buffer: ArrayBufferLike, charset?: string): Promise<string>;
+export declare function compress(str: string): Promise<ArrayBuffer>;
+export declare function decompressStream(stream: ReadableStream): ReadableStream;
+export declare function compressStream(stream: ReadableStream): ReadableStream;
+export declare function createMonitoredStream(stream: ReadableStream, onProgress: (bytesRead: number) => void): ReadableStream;

package/dist/lib/front_end/core/common/JavaScriptMetaData.d.ts

@@ -0,0 +1,20 @@
+export interface DOMPinnedWebIDLProp {
+    global?: boolean;
+    specs?: number;
+    rules?: DOMPinnedWebIDLRule[];
+}
+export interface DOMPinnedWebIDLType {
+    inheritance?: string;
+    includes?: string[];
+    props?: Record<string, DOMPinnedWebIDLProp>;
+    rules?: DOMPinnedWebIDLRule[];
+}
+export interface DOMPinnedWebIDLRule {
+    when: string;
+    is: string;
+}
+export interface JavaScriptMetaData {
+    signaturesForNativeFunction(name: string): string[][] | null;
+    signaturesForInstanceMethod(name: string, receiverClassName: string): string[][] | null;
+    signaturesForStaticMethod(name: string, receiverConstructorName: string): string[][] | null;
+}

package/dist/lib/front_end/core/common/Lazy.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Very basic memoizer. Will only invoke its callback the first time, returning the cached value all subsequent calls.
+ */
+export declare function lazy<T>(producer: () => T): () => symbol | T;

package/dist/lib/front_end/core/common/MapWithDefault.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Polyfill of https://github.com/tc39/proposal-upsert with a subclass.
+ *
+ * TODO: Once the proposal is merged, just replace `MapWithDefault` with `Map` and remove it.
+ **/
+export declare class MapWithDefault<K, V> extends Map<K, V> {
+    getOrInsert(key: K, defaultValue: V): V;
+    getOrInsertComputed(key: K, callbackFunction: (key: K) => V): V;
+}

package/dist/lib/front_end/core/common/Mutex.d.ts

@@ -0,0 +1,13 @@
+type ReleaseFunction = () => void;
+/**
+ * Use Mutex class to coordinate local concurrent operations.
+ * Once `acquire` promise resolves, you hold the lock and must
+ * call `release` function returned by `acquire` to release the
+ * lock. Failing to `release` the lock may lead to deadlocks.
+ */
+export declare class Mutex {
+    #private;
+    acquire(): Promise<ReleaseFunction>;
+    run<T>(action: () => Promise<T>): Promise<T>;
+}
+export {};