devtools-tracing 1.2.1 → 1.2.2

package/dist/lib/front_end/core/sdk/CPUThrottlingManager.d.ts

@@ -0,0 +1,57 @@
+import * as Common from '../../core/common/common.js';
+import { EmulationModel } from './EmulationModel.js';
+import { type SDKModelObserver } from './TargetManager.js';
+export declare class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> implements SDKModelObserver<EmulationModel> {
+    #private;
+    private constructor();
+    static instance(opts?: {
+        forceNew: boolean | null;
+    }): CPUThrottlingManager;
+    static removeInstance(): void;
+    cpuThrottlingRate(): number;
+    cpuThrottlingOption(): CPUThrottlingOption;
+    setCPUThrottlingOption(option: CPUThrottlingOption): void;
+    setHardwareConcurrency(concurrency: number): void;
+    hasPrimaryPageTargetSet(): boolean;
+    getHardwareConcurrency(): Promise<number>;
+    modelAdded(emulationModel: EmulationModel): void;
+    modelRemoved(_emulationModel: EmulationModel): void;
+}
+export declare const enum Events {
+    RATE_CHANGED = "RateChanged",
+    HARDWARE_CONCURRENCY_CHANGED = "HardwareConcurrencyChanged"
+}
+export interface EventTypes {
+    [Events.RATE_CHANGED]: number;
+    [Events.HARDWARE_CONCURRENCY_CHANGED]: number;
+}
+export declare enum CPUThrottlingRates {
+    NO_THROTTLING = 1,
+    MID_TIER_MOBILE = 4,
+    LOW_TIER_MOBILE = 6,
+    EXTRA_SLOW = 20,
+    MidTierMobile = 4,
+    LowEndMobile = 6
+}
+export type CalibratedDeviceType = 'low-tier-mobile' | 'mid-tier-mobile';
+export interface CPUThrottlingOption {
+    title: () => string;
+    rate: () => number;
+    calibratedDeviceType?: CalibratedDeviceType;
+    jslogContext: string;
+}
+export declare const NoThrottlingOption: CPUThrottlingOption;
+export declare const MidTierThrottlingOption: CPUThrottlingOption;
+export declare const LowTierThrottlingOption: CPUThrottlingOption;
+export declare const ExtraSlowThrottlingOption: CPUThrottlingOption;
+export declare const CalibratedLowTierMobileThrottlingOption: CPUThrottlingOption;
+export declare const CalibratedMidTierMobileThrottlingOption: CPUThrottlingOption;
+export interface CalibratedCPUThrottling {
+    /** Either the CPU multiplier, or an error code for why it could not be determined. */
+    low?: number | CalibrationError;
+    mid?: number | CalibrationError;
+}
+export declare enum CalibrationError {
+    DEVICE_TOO_WEAK = "DEVICE_TOO_WEAK"
+}
+export declare function calibrationErrorToString(error: CalibrationError): string;

package/dist/lib/front_end/core/sdk/CSSContainerQuery.d.ts

@@ -0,0 +1,41 @@
+import type * as Protocol from '../../generated/protocol.js';
+import type { CSSModel } from './CSSModel.js';
+import { CSSQuery } from './CSSQuery.js';
+import type { DOMNode } from './DOMModel.js';
+export declare class CSSContainerQuery extends CSSQuery {
+    name?: string;
+    physicalAxes?: Protocol.DOM.PhysicalAxes;
+    logicalAxes?: Protocol.DOM.LogicalAxes;
+    queriesScrollState?: boolean;
+    queriesAnchored?: boolean;
+    static parseContainerQueriesPayload(cssModel: CSSModel, payload: Protocol.CSS.CSSContainerQuery[]): CSSContainerQuery[];
+    constructor(cssModel: CSSModel, payload: Protocol.CSS.CSSContainerQuery);
+    reinitialize(payload: Protocol.CSS.CSSContainerQuery): void;
+    active(): boolean;
+    getContainerForNode(nodeId: Protocol.DOM.NodeId): Promise<CSSContainerQueryContainer | undefined>;
+}
+export declare class CSSContainerQueryContainer {
+    readonly containerNode: DOMNode;
+    constructor(containerNode: DOMNode);
+    getContainerSizeDetails(): Promise<ContainerQueriedSizeDetails | undefined>;
+}
+export declare const getQueryAxisFromContainerType: (propertyValue: string) => QueryAxis;
+export declare const getPhysicalAxisFromQueryAxis: (queryAxis: QueryAxis, writingMode: string) => PhysicalAxis;
+export interface ContainerQueriedSizeDetails {
+    queryAxis: QueryAxis;
+    physicalAxis: PhysicalAxis;
+    width?: string;
+    height?: string;
+}
+export declare const enum QueryAxis {
+    NONE = "",
+    INLINE = "inline-size",
+    BLOCK = "block-size",
+    BOTH = "size"
+}
+export declare const enum PhysicalAxis {
+    NONE = "",
+    HORIZONTAL = "Horizontal",
+    VERTICAL = "Vertical",
+    BOTH = "Both"
+}

package/dist/lib/front_end/core/sdk/CSSFontFace.d.ts

@@ -0,0 +1,10 @@
+import type * as Protocol from '../../generated/protocol.js';
+import type * as Platform from '../platform/platform.js';
+export declare class CSSFontFace {
+    #private;
+    constructor(payload: Protocol.CSS.FontFace);
+    getFontFamily(): string;
+    getSrc(): Platform.DevToolsPath.UrlString;
+    getFontDisplay(): string;
+    getVariationAxisByTag(tag: string): Protocol.CSS.FontVariationAxis | undefined;
+}

package/dist/lib/front_end/core/sdk/CSSLayer.d.ts

@@ -0,0 +1,9 @@
+import type * as Protocol from '../../generated/protocol.js';
+import type { CSSModel } from './CSSModel.js';
+import { CSSQuery } from './CSSQuery.js';
+export declare class CSSLayer extends CSSQuery {
+    static parseLayerPayload(cssModel: CSSModel, payload: Protocol.CSS.CSSLayer[]): CSSLayer[];
+    constructor(cssModel: CSSModel, payload: Protocol.CSS.CSSLayer);
+    reinitialize(payload: Protocol.CSS.CSSLayer): void;
+    active(): boolean;
+}

package/dist/lib/front_end/core/sdk/CSSMatchedStyles.d.ts

@@ -0,0 +1,116 @@
+import * as Protocol from '../../generated/protocol.js';
+import { CSSWideKeyword } from './CSSMetadata.js';
+import type { CSSModel } from './CSSModel.js';
+import { CSSProperty } from './CSSProperty.js';
+import * as PropertyParser from './CSSPropertyParser.js';
+import type { Match, Matcher } from './CSSPropertyParser.js';
+import { CSSAtRule, CSSFunctionRule, CSSKeyframesRule, CSSPositionTryRule, CSSPropertyRule, CSSStyleRule } from './CSSRule.js';
+import { CSSStyleDeclaration } from './CSSStyleDeclaration.js';
+import type { DOMNode } from './DOMModel.js';
+export interface CSSMatchedStylesPayload {
+    cssModel: CSSModel;
+    node: DOMNode;
+    activePositionFallbackIndex: number;
+    inlinePayload: Protocol.CSS.CSSStyle | null;
+    attributesPayload: Protocol.CSS.CSSStyle | null;
+    matchedPayload: Protocol.CSS.RuleMatch[];
+    pseudoPayload: Protocol.CSS.PseudoElementMatches[];
+    inheritedPayload: Protocol.CSS.InheritedStyleEntry[];
+    inheritedPseudoPayload: Protocol.CSS.InheritedPseudoElementMatches[];
+    animationsPayload: Protocol.CSS.CSSKeyframesRule[];
+    parentLayoutNodeId: Protocol.DOM.NodeId | undefined;
+    positionTryRules: Protocol.CSS.CSSPositionTryRule[];
+    propertyRules: Protocol.CSS.CSSPropertyRule[];
+    cssPropertyRegistrations: Protocol.CSS.CSSPropertyRegistration[];
+    atRules: Protocol.CSS.CSSAtRule[];
+    animationStylesPayload: Protocol.CSS.CSSAnimationStyle[];
+    transitionsStylePayload: Protocol.CSS.CSSStyle | null;
+    inheritedAnimatedPayload: Protocol.CSS.InheritedAnimatedStyleEntry[];
+    functionRules: Protocol.CSS.CSSFunctionRule[];
+}
+export interface CSSType {
+    type: string;
+    isCSSTokens: boolean;
+}
+export declare class CSSRegisteredProperty {
+    #private;
+    constructor(cssModel: CSSModel, registration: CSSPropertyRule | Protocol.CSS.CSSPropertyRegistration);
+    propertyName(): string;
+    initialValue(): string | null;
+    inherits(): boolean;
+    syntax(): string;
+    parseValue(matchedStyles: CSSMatchedStyles, computedStyles: Map<string, string> | null): PropertyParser.BottomUpTreeMatching | null;
+    style(): CSSStyleDeclaration;
+}
+export declare class CSSMatchedStyles {
+    #private;
+    static create(payload: CSSMatchedStylesPayload): Promise<CSSMatchedStyles>;
+    private constructor();
+    private init;
+    private buildMainCascade;
+    /**
+     * Pseudo rule matches received via the inspector protocol are grouped by pseudo type.
+     * For custom highlight pseudos, we need to instead group the rule matches by highlight
+     * name in order to produce separate cascades for each highlight name. This is necessary
+     * so that styles of ::highlight(foo) are not shown as overriding styles of ::highlight(bar).
+     *
+     * This helper function takes a list of rule matches and generates separate NodeCascades
+     * for each custom highlight name that was matched.
+     */
+    private buildSplitCustomHighlightCascades;
+    private buildPseudoCascades;
+    private addMatchingSelectors;
+    node(): DOMNode;
+    cssModel(): CSSModel;
+    hasMatchingSelectors(rule: CSSStyleRule): boolean;
+    getParentLayoutNodeId(): Protocol.DOM.NodeId | undefined;
+    getMatchingSelectors(rule: CSSStyleRule): number[];
+    recomputeMatchingSelectors(rule: CSSStyleRule): Promise<void>;
+    addNewRule(rule: CSSStyleRule, node: DOMNode): Promise<void>;
+    private setSelectorMatches;
+    nodeStyles(): CSSStyleDeclaration[];
+    inheritedStyles(): CSSStyleDeclaration[];
+    animationStyles(): CSSStyleDeclaration[];
+    transitionsStyle(): CSSStyleDeclaration | null;
+    registeredProperties(): CSSRegisteredProperty[];
+    getRegisteredProperty(name: string): CSSRegisteredProperty | undefined;
+    getRegisteredFunction(name: string): string | undefined;
+    functionRules(): CSSFunctionRule[];
+    atRules(): CSSAtRule[];
+    keyframes(): CSSKeyframesRule[];
+    positionTryRules(): CSSPositionTryRule[];
+    activePositionFallbackIndex(): number;
+    pseudoStyles(pseudoType: Protocol.DOM.PseudoType): CSSStyleDeclaration[];
+    pseudoTypes(): Set<Protocol.DOM.PseudoType>;
+    customHighlightPseudoStyles(highlightName: string): CSSStyleDeclaration[];
+    customHighlightPseudoNames(): Set<string>;
+    nodeForStyle(style: CSSStyleDeclaration): DOMNode | null;
+    availableCSSVariables(style: CSSStyleDeclaration): string[];
+    computeCSSVariable(style: CSSStyleDeclaration, variableName: string): CSSVariableValue | null;
+    computeAttribute(style: CSSStyleDeclaration, attributeName: string, type: CSSType): string | null;
+    originatingNodeForStyle(style: CSSStyleDeclaration): DOMNode | null;
+    rawAttributeValueFromStyle(style: CSSStyleDeclaration, attributeName: string): string | null;
+    resolveProperty(name: string, ownerStyle: CSSStyleDeclaration): CSSProperty | null;
+    resolveGlobalKeyword(property: CSSProperty, keyword: CSSWideKeyword): CSSValueSource | null;
+    isInherited(style: CSSStyleDeclaration): boolean;
+    propertyState(property: CSSProperty): PropertyState | null;
+    isPropertyOverriddenByAnimation(property: CSSProperty): boolean;
+    resetActiveProperties(): void;
+    propertyMatchers(style: CSSStyleDeclaration, computedStyles: Map<string, string> | null): Array<Matcher<Match>>;
+    environmentVariable(name: string): string | undefined;
+}
+export declare class CSSValueSource {
+    readonly declaration: CSSProperty | CSSRegisteredProperty;
+    constructor(declaration: CSSProperty | CSSRegisteredProperty);
+    get value(): string | null;
+    get style(): CSSStyleDeclaration;
+    get name(): string;
+}
+export interface CSSVariableValue {
+    value: string;
+    declaration: CSSValueSource;
+}
+export declare const enum PropertyState {
+    ACTIVE = "Active",
+    OVERLOADED = "Overloaded"
+}

package/dist/lib/front_end/core/sdk/CSSMedia.d.ts

@@ -0,0 +1,36 @@
+import type * as Protocol from '../../generated/protocol.js';
+import * as TextUtils from '../../models/text_utils/text_utils.js';
+import type { CSSModel } from './CSSModel.js';
+import { CSSQuery } from './CSSQuery.js';
+export declare class CSSMediaQuery {
+    #private;
+    constructor(payload: Protocol.CSS.MediaQuery);
+    static parsePayload(payload: Protocol.CSS.MediaQuery): CSSMediaQuery;
+    active(): boolean;
+    expressions(): CSSMediaQueryExpression[] | null;
+}
+export declare class CSSMediaQueryExpression {
+    #private;
+    constructor(payload: Protocol.CSS.MediaQueryExpression);
+    static parsePayload(payload: Protocol.CSS.MediaQueryExpression): CSSMediaQueryExpression;
+    value(): number;
+    unit(): string;
+    feature(): string;
+    valueRange(): TextUtils.TextRange.TextRange | null;
+    computedLength(): number | null;
+}
+export declare class CSSMedia extends CSSQuery {
+    source?: Protocol.CSS.CSSMediaSource;
+    sourceURL?: string;
+    mediaList?: CSSMediaQuery[] | null;
+    static parseMediaArrayPayload(cssModel: CSSModel, payload: Protocol.CSS.CSSMedia[]): CSSMedia[];
+    constructor(cssModel: CSSModel, payload: Protocol.CSS.CSSMedia);
+    reinitialize(payload: Protocol.CSS.CSSMedia): void;
+    active(): boolean;
+}
+export declare const Source: {
+    LINKED_SHEET: string;
+    INLINE_SHEET: string;
+    MEDIA_RULE: string;
+    IMPORT_RULE: string;
+};

package/dist/lib/front_end/core/sdk/CSSMetadata.d.ts

@@ -0,0 +1,85 @@
+import * as Protocol from '../../generated/protocol.js';
+export declare class CSSMetadata {
+    #private;
+    constructor(properties: CSSPropertyDefinition[], aliasesFor: Map<string, string>);
+    static isCSSWideKeyword(a: string): a is CSSWideKeyword;
+    static isPositionTryOrderKeyword(a: string): a is PositionTryOrderKeyword;
+    private static sortPrefixesAndCSSWideKeywordsToEnd;
+    allProperties(): string[];
+    aliasesFor(): Map<string, string>;
+    nameValuePresets(includeSVG?: boolean): string[];
+    isSVGProperty(name: string): boolean;
+    getLonghands(shorthand: string): string[] | null;
+    getShorthands(longhand: string): string[] | null;
+    isColorAwareProperty(propertyName: string): boolean;
+    isFontFamilyProperty(propertyName: string): boolean;
+    isAngleAwareProperty(propertyName: string): boolean;
+    isGridAreaDefiningProperty(propertyName: string): boolean;
+    isGridColumnNameAwareProperty(propertyName: string): boolean;
+    isGridRowNameAwareProperty(propertyName: string): boolean;
+    isGridAreaNameAwareProperty(propertyName: string): boolean;
+    isGridNameAwareProperty(propertyName: string): boolean;
+    isLengthProperty(propertyName: string): boolean;
+    isBezierAwareProperty(propertyName: string): boolean;
+    isFontAwareProperty(propertyName: string): boolean;
+    isCustomProperty(propertyName: string): boolean;
+    isShadowProperty(propertyName: string): boolean;
+    isStringProperty(propertyName: string): boolean;
+    canonicalPropertyName(name: string): string;
+    isCSSPropertyName(propertyName: string): boolean;
+    isPropertyInherited(propertyName: string): boolean;
+    private specificPropertyValues;
+    getPropertyValues(propertyName: string): string[];
+    propertyUsageWeight(property: string): number;
+    getValuePreset(key: string, value: string): {
+        text: string;
+        startColumn: number;
+        endColumn: number;
+    } | null;
+    isHighlightPseudoType(pseudoType: Protocol.DOM.PseudoType): boolean;
+}
+export declare const CubicBezierKeywordValues: Map<string, string>;
+/** CSS-wide keywords. **/
+export declare const enum CSSWideKeyword {
+    INHERIT = "inherit",
+    INITIAL = "initial",
+    REVERT = "revert",
+    REVERT_LAYER = "revert-layer",
+    REVERT_RULE = "revert-rule",
+    UNSET = "unset"
+}
+/**
+ * Spec: https://drafts.csswg.org/css-cascade/#defaulting-keywords
+ * https://drafts.csswg.org/css-cascade-5/#revert-layer
+ * https://drafts.csswg.org/css-cascade-6/#revert-rule
+ **/
+export declare const CSSWideKeywords: CSSWideKeyword[];
+/** https://www.w3.org/TR/css-anchor-position-1/#typedef-try-size **/
+export declare const enum PositionTryOrderKeyword {
+    NORMAL = "normal",
+    MOST_HEIGHT = "most-height",
+    MOST_WIDTH = "most-width",
+    MOST_BLOCK_SIZE = "most-block-size",
+    MOST_INLINE_SIZE = "most-inline-size"
+}
+export declare const PositionTryOrderKeywords: PositionTryOrderKeyword[];
+export declare const VariableNameRegex: RegExp;
+export declare const VariableRegex: RegExp;
+export declare const CustomVariableRegex: RegExp;
+export declare const URLRegex: RegExp;
+/**
+ * Matches an instance of a grid area 'row' definition.
+ * 'grid-template-areas', e.g.
+ *    "a a ."
+ *
+ * 'grid', 'grid-template', e.g.
+ *    [track-#name] "a a ." minmax(50px, auto) [track-#name]
+ */
+export declare const GridAreaRowRegex: RegExp;
+export declare function cssMetadata(): CSSMetadata;
+export interface CSSPropertyDefinition {
+    name: string;
+    longhands: string[] | null;
+    inherited: boolean | null;
+    svg: boolean | null;
+}

package/dist/lib/front_end/core/sdk/CSSModel.d.ts

@@ -0,0 +1,186 @@
+import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
+import type * as Protocol from '../../generated/protocol.js';
+import * as TextUtils from '../../models/text_utils/text_utils.js';
+import * as Common from '../common/common.js';
+import * as Platform from '../platform/platform.js';
+import { CSSFontFace } from './CSSFontFace.js';
+import { CSSMatchedStyles } from './CSSMatchedStyles.js';
+import { CSSMedia } from './CSSMedia.js';
+import { CSSStyleRule } from './CSSRule.js';
+import { CSSStyleDeclaration } from './CSSStyleDeclaration.js';
+import { CSSStyleSheetHeader } from './CSSStyleSheetHeader.js';
+import { DOMModel, type DOMNode } from './DOMModel.js';
+import { SDKModel } from './SDKModel.js';
+import { SourceMapManager } from './SourceMapManager.js';
+import { type Target } from './Target.js';
+export declare const enum ColorScheme {
+    LIGHT = "light",
+    DARK = "dark"
+}
+export interface LayoutProperties {
+    isFlex: boolean;
+    isGrid: boolean;
+    isSubgrid: boolean;
+    isGridLanes: boolean;
+    containerType?: string;
+    hasScroll: boolean;
+}
+export declare class CSSModel extends SDKModel<EventTypes> {
+    #private;
+    readonly agent: ProtocolProxyApi.CSSApi;
+    constructor(target: Target);
+    colorScheme(): Promise<ColorScheme | undefined>;
+    resolveValues(propertyName: string | undefined, nodeId: Protocol.DOM.NodeId, ...values: string[]): Promise<string[] | null>;
+    headersForSourceURL(sourceURL: Platform.DevToolsPath.UrlString): CSSStyleSheetHeader[];
+    createRawLocationsByURL(sourceURL: Platform.DevToolsPath.UrlString, lineNumber: number, columnNumber?: number | undefined): CSSLocation[];
+    sourceMapManager(): SourceMapManager<CSSStyleSheetHeader>;
+    static readableLayerName(text: string): string;
+    static trimSourceURL(text: string): string;
+    domModel(): DOMModel;
+    trackComputedStyleUpdatesForNode(nodeId: Protocol.DOM.NodeId | undefined): Promise<void>;
+    setStyleText(styleSheetId: Protocol.DOM.StyleSheetId, range: TextUtils.TextRange.TextRange, text: string, majorChange: boolean): Promise<boolean>;
+    setSelectorText(styleSheetId: Protocol.DOM.StyleSheetId, range: TextUtils.TextRange.TextRange, text: string): Promise<boolean>;
+    setPropertyRulePropertyName(styleSheetId: Protocol.DOM.StyleSheetId, range: TextUtils.TextRange.TextRange, text: string): Promise<boolean>;
+    setKeyframeKey(styleSheetId: Protocol.DOM.StyleSheetId, range: TextUtils.TextRange.TextRange, text: string): Promise<boolean>;
+    startCoverage(): Promise<Protocol.ProtocolResponseWithError>;
+    takeCoverageDelta(): Promise<{
+        timestamp: number;
+        coverage: Protocol.CSS.RuleUsage[];
+    }>;
+    setLocalFontsEnabled(enabled: boolean): Promise<Protocol.ProtocolResponseWithError>;
+    stopCoverage(): Promise<void>;
+    getMediaQueries(): Promise<CSSMedia[]>;
+    getRootLayer(nodeId: Protocol.DOM.NodeId): Promise<Protocol.CSS.CSSLayerData>;
+    isEnabled(): boolean;
+    private enable;
+    getAnimatedStylesForNode(nodeId: Protocol.DOM.NodeId): Promise<Protocol.CSS.GetAnimatedStylesForNodeResponse | null>;
+    getMatchedStyles(nodeId: Protocol.DOM.NodeId): Promise<CSSMatchedStyles | null>;
+    getClassNames(styleSheetId: Protocol.DOM.StyleSheetId): Promise<string[]>;
+    getComputedStyle(nodeId: Protocol.DOM.NodeId): Promise<Map<string, string> | null>;
+    getComputedStyleExtraFields(nodeId: Protocol.DOM.NodeId): Promise<Protocol.CSS.ComputedStyleExtraFields>;
+    getLayoutPropertiesFromComputedStyle(nodeId: Protocol.DOM.NodeId): Promise<LayoutProperties | null>;
+    getEnvironmentVariables(): Promise<Record<string, string>>;
+    getBackgroundColors(nodeId: Protocol.DOM.NodeId): Promise<ContrastInfo | null>;
+    getPlatformFonts(nodeId: Protocol.DOM.NodeId): Promise<Protocol.CSS.PlatformFontUsage[] | null>;
+    allStyleSheets(): CSSStyleSheetHeader[];
+    getInlineStyles(nodeId: Protocol.DOM.NodeId): Promise<InlineStyleResult | null>;
+    forceStartingStyle(node: DOMNode, forced: boolean): boolean;
+    forcePseudoState(node: DOMNode, pseudoClass: string, enable: boolean): boolean;
+    pseudoState(node: DOMNode): string[] | null;
+    setMediaText(styleSheetId: Protocol.DOM.StyleSheetId, range: TextUtils.TextRange.TextRange, newMediaText: string): Promise<boolean>;
+    setContainerQueryText(styleSheetId: Protocol.DOM.StyleSheetId, range: TextUtils.TextRange.TextRange, newContainerQueryText: string): Promise<boolean>;
+    setSupportsText(styleSheetId: Protocol.DOM.StyleSheetId, range: TextUtils.TextRange.TextRange, newSupportsText: string): Promise<boolean>;
+    setNavigationText(styleSheetId: Protocol.DOM.StyleSheetId, range: TextUtils.TextRange.TextRange, newNavigationText: string): Promise<boolean>;
+    setScopeText(styleSheetId: Protocol.DOM.StyleSheetId, range: TextUtils.TextRange.TextRange, newScopeText: string): Promise<boolean>;
+    addRule(styleSheetId: Protocol.DOM.StyleSheetId, ruleText: string, ruleLocation: TextUtils.TextRange.TextRange): Promise<CSSStyleRule | null>;
+    requestViaInspectorStylesheet(maybeFrameId?: Protocol.Page.FrameId | null): Promise<CSSStyleSheetHeader | null>;
+    createInspectorStylesheet(frameId: Protocol.Page.FrameId, force?: boolean): Promise<CSSStyleSheetHeader | null>;
+    mediaQueryResultChanged(): void;
+    fontsUpdated(fontFace?: Protocol.CSS.FontFace | null): void;
+    fontFaces(): CSSFontFace[];
+    fontFaceForSource(src: string): CSSFontFace | undefined;
+    styleSheetHeaderForId(id: Protocol.DOM.StyleSheetId): CSSStyleSheetHeader | null;
+    styleSheetHeaders(): CSSStyleSheetHeader[];
+    fireStyleSheetChanged(styleSheetId: Protocol.DOM.StyleSheetId, edit?: Edit): void;
+    private ensureOriginalStyleSheetText;
+    private originalContentRequestedForTest;
+    originalStyleSheetText(header: CSSStyleSheetHeader): Promise<string | null>;
+    getAllStyleSheetHeaders(): Iterable<CSSStyleSheetHeader>;
+    computedStyleUpdated(nodeId: Protocol.DOM.NodeId): void;
+    styleSheetAdded(header: Protocol.CSS.CSSStyleSheetHeader): void;
+    styleSheetRemoved(id: Protocol.DOM.StyleSheetId): void;
+    getStyleSheetIdsForURL(url: Platform.DevToolsPath.UrlString): Protocol.DOM.StyleSheetId[];
+    setStyleSheetText(styleSheetId: Protocol.DOM.StyleSheetId, newText: string, majorChange: boolean): Promise<string | null>;
+    getStyleSheetText(styleSheetId: Protocol.DOM.StyleSheetId): Promise<string | null>;
+    private onPrimaryPageChanged;
+    private resetStyleSheets;
+    private resetFontFaces;
+    suspendModel(): Promise<void>;
+    resumeModel(): Promise<void>;
+    setEffectivePropertyValueForNode(nodeId: Protocol.DOM.NodeId, propertyName: string, value: string): void;
+    cachedMatchedCascadeForNode(node: DOMNode): Promise<CSSMatchedStyles | null>;
+    discardCachedMatchedCascade(): void;
+    createCSSPropertyTracker(propertiesToTrack: Protocol.CSS.CSSComputedStyleProperty[]): CSSPropertyTracker;
+    enableCSSPropertyTracker(cssPropertyTracker: CSSPropertyTracker): void;
+    disableCSSPropertyTracker(): void;
+    private pollComputedStyleUpdates;
+    dispose(): void;
+    getAgent(): ProtocolProxyApi.CSSApi;
+}
+export declare enum Events {
+    FontsUpdated = "FontsUpdated",
+    MediaQueryResultChanged = "MediaQueryResultChanged",
+    ModelWasEnabled = "ModelWasEnabled",
+    ModelDisposed = "ModelDisposed",
+    PseudoStateForced = "PseudoStateForced",
+    StartingStylesStateForced = "StartingStylesStateForced",
+    StyleSheetAdded = "StyleSheetAdded",
+    StyleSheetChanged = "StyleSheetChanged",
+    StyleSheetRemoved = "StyleSheetRemoved",
+    ComputedStyleUpdated = "ComputedStyleUpdated"
+}
+export interface StyleSheetChangedEvent {
+    styleSheetId: Protocol.DOM.StyleSheetId;
+    edit?: Edit;
+}
+export interface PseudoStateForcedEvent {
+    node: DOMNode;
+    pseudoClass: string;
+    enable: boolean;
+}
+export interface ComputedStyleUpdatedEvent {
+    nodeId: Protocol.DOM.NodeId;
+}
+export interface EventTypes {
+    [Events.FontsUpdated]: void;
+    [Events.MediaQueryResultChanged]: void;
+    [Events.ModelWasEnabled]: void;
+    [Events.ModelDisposed]: CSSModel;
+    [Events.PseudoStateForced]: PseudoStateForcedEvent;
+    [Events.StartingStylesStateForced]: DOMNode;
+    [Events.StyleSheetAdded]: CSSStyleSheetHeader;
+    [Events.StyleSheetChanged]: StyleSheetChangedEvent;
+    [Events.StyleSheetRemoved]: CSSStyleSheetHeader;
+    [Events.ComputedStyleUpdated]: ComputedStyleUpdatedEvent;
+}
+export declare class Edit {
+    styleSheetId: string;
+    oldRange: TextUtils.TextRange.TextRange;
+    newRange: TextUtils.TextRange.TextRange;
+    newText: string;
+    payload: Object | null;
+    constructor(styleSheetId: string, oldRange: TextUtils.TextRange.TextRange, newText: string, payload: Object | null);
+}
+export declare class CSSLocation {
+    #private;
+    styleSheetId: Protocol.DOM.StyleSheetId;
+    url: Platform.DevToolsPath.UrlString;
+    lineNumber: number;
+    columnNumber: number;
+    constructor(header: CSSStyleSheetHeader, lineNumber: number, columnNumber?: number);
+    cssModel(): CSSModel;
+    header(): CSSStyleSheetHeader | null;
+}
+export declare class InlineStyleResult {
+    inlineStyle: CSSStyleDeclaration | null;
+    attributesStyle: CSSStyleDeclaration | null;
+    constructor(inlineStyle: CSSStyleDeclaration | null, attributesStyle: CSSStyleDeclaration | null);
+}
+export declare class CSSPropertyTracker extends Common.ObjectWrapper.ObjectWrapper<CSSPropertyTrackerEventTypes> {
+    #private;
+    constructor(cssModel: CSSModel, propertiesToTrack: Protocol.CSS.CSSComputedStyleProperty[]);
+    start(): void;
+    stop(): void;
+    getTrackedProperties(): Protocol.CSS.CSSComputedStyleProperty[];
+}
+export declare const enum CSSPropertyTrackerEvents {
+    TRACKED_CSS_PROPERTIES_UPDATED = "TrackedCSSPropertiesUpdated"
+}
+export interface CSSPropertyTrackerEventTypes {
+    [CSSPropertyTrackerEvents.TRACKED_CSS_PROPERTIES_UPDATED]: Array<DOMNode | null>;
+}
+export interface ContrastInfo {
+    backgroundColors: string[] | null;
+    computedFontSize: string;
+    computedFontWeight: string;
+}

package/dist/lib/front_end/core/sdk/CSSNavigation.d.ts

@@ -0,0 +1,10 @@
+import type * as Protocol from '../../generated/protocol.js';
+import type { CSSModel } from './CSSModel.js';
+import { CSSQuery } from './CSSQuery.js';
+export declare class CSSNavigation extends CSSQuery {
+    #private;
+    static parseNavigationPayload(cssModel: CSSModel, payload: Protocol.CSS.CSSNavigation[]): CSSNavigation[];
+    constructor(cssModel: CSSModel, payload: Protocol.CSS.CSSNavigation);
+    reinitialize(payload: Protocol.CSS.CSSNavigation): void;
+    active(): boolean;
+}

package/dist/lib/front_end/core/sdk/CSSProperty.d.ts

@@ -0,0 +1,53 @@
+import type * as Protocol from '../../generated/protocol.js';
+import * as TextUtils from '../../models/text_utils/text_utils.js';
+import * as Common from '../common/common.js';
+import type { CSSMatchedStyles } from './CSSMatchedStyles.js';
+import type { Edit } from './CSSModel.js';
+import { type BottomUpTreeMatching } from './CSSPropertyParser.js';
+import type { CSSStyleDeclaration } from './CSSStyleDeclaration.js';
+export declare const enum Events {
+    LOCAL_VALUE_UPDATED = "localValueUpdated"
+}
+export interface EventTypes {
+    [Events.LOCAL_VALUE_UPDATED]: void;
+}
+export declare class CSSProperty extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
+    #private;
+    ownerStyle: CSSStyleDeclaration;
+    index: number;
+    name: string;
+    value: string;
+    important: boolean;
+    disabled: boolean;
+    parsedOk: boolean;
+    implicit: boolean;
+    text: string | null | undefined;
+    range: TextUtils.TextRange.TextRange | null;
+    constructor(ownerStyle: CSSStyleDeclaration, index: number, name: string, value: string, important: boolean, disabled: boolean, parsedOk: boolean, implicit: boolean, text?: string | null, range?: Protocol.CSS.SourceRange, longhandProperties?: Protocol.CSS.CSSProperty[]);
+    static parsePayload(ownerStyle: CSSStyleDeclaration, index: number, payload: Protocol.CSS.CSSProperty): CSSProperty;
+    parseExpression(expression: string, matchedStyles: CSSMatchedStyles, computedStyles: Map<string, string> | null): BottomUpTreeMatching | null;
+    parseValue(matchedStyles: CSSMatchedStyles, computedStyles: Map<string, string> | null): BottomUpTreeMatching | null;
+    private ensureRanges;
+    nameRange(): TextUtils.TextRange.TextRange | null;
+    valueRange(): TextUtils.TextRange.TextRange | null;
+    rebase(edit: Edit): void;
+    setActive(active: boolean): void;
+    get propertyText(): string | null;
+    activeInStyle(): boolean;
+    setText(propertyText: string, majorChange: boolean, overwrite?: boolean): Promise<boolean>;
+    static formatStyle(styleText: string, indentation: string, endIndentation: string): Promise<string>;
+    private detectIndentation;
+    setValue(newValue: string, majorChange: boolean, overwrite: boolean, userCallback?: ((arg0: boolean) => void)): void;
+    setLocalValue(value: string): void;
+    setDisabled(disabled: boolean): Promise<boolean>;
+    /**
+     * This stores the warning string when a CSS Property is improperly parsed.
+     */
+    setDisplayedStringForInvalidProperty(invalidString: Common.UIString.LocalizedString): void;
+    /**
+     * Retrieve the warning string for a screen reader to announce when editing the property.
+     */
+    getInvalidStringForInvalidProperty(): Common.UIString.LocalizedString | undefined;
+    getLonghandProperties(): CSSProperty[];
+    ignoreErrors(): boolean;
+}