browser-debugger-cli 0.11.0 → 0.13.0

package/dist/ipc/client.d.ts

@@ -178,8 +178,10 @@ export declare function getNetworkHeaders(options?: {
  *
  * @param method - CDP method name (e.g., 'Network.getCookies')
  * @param params - Optional method parameters
+ * @param options - `isolated`: a bdg page script, run in bdg's isolated world
+ *   (`Runtime.evaluate`, `DOM.resolveNode`)
  * @returns Response with CDP method result
- * @throws Error if connection fails; CommandError (102) when the page was busy and its scripts were terminated
+ * @throws Error if connection fails; CommandError (102) when the page was busy and its scripts were terminated, (107) when the page crashed
  *
  * @example
  * ```typescript
@@ -189,7 +191,21 @@ export declare function getNetworkHeaders(options?: {
  * }
  * ```
  */
-export declare function callCDP(method: string, params?: Record<string, unknown>): Promise<ClientResponse<'cdp_call'>>;
+export declare function callCDP(method: string, params?: Record<string, unknown>, options?: {
+    isolated?: boolean;
+}): Promise<ClientResponse<'cdp_call'>>;
+/**
+ * Send a CDP call for one of bdg's own page scripts: `Runtime.evaluate` and
+ * `DOM.resolveNode` run in bdg's isolated world, so a page that replaced
+ * built-ins (`querySelectorAll`, `JSON.stringify`) cannot change what they
+ * find or return.
+ *
+ * @param method - CDP method name
+ * @param params - Method parameters
+ * @returns Response with the CDP method result
+ * @throws Like {@link callCDP}
+ */
+export declare function callBdgScript(method: string, params?: Record<string, unknown>): Promise<ClientResponse<'cdp_call'>>;
 /**
  * Evaluate a JavaScript expression in the active page (or one of its iframes) via the daemon.
  */
@@ -231,6 +247,10 @@ export declare function domFormDiscover(): Promise<ClientResponse<'dom_form_disc
 export declare function domListeners(params: NoType<(typeof COMMANDS)['dom_listeners']['requestSchema']>): Promise<ClientResponse<'dom_listeners'>>;
 /** Positions, sizes and visibility of elements. */
 export declare function domLayout(params: NoType<(typeof COMMANDS)['dom_layout']['requestSchema']>): Promise<ClientResponse<'dom_layout'>>;
+/** Page-wide checks: contrast, overflow, layers, animations. */
+export declare function domAudit(params: NoType<(typeof COMMANDS)['dom_audit']['requestSchema']>): Promise<ClientResponse<'dom_audit'>>;
+/** Find text in the page's stylesheets. */
+export declare function cssSearch(params: NoType<(typeof COMMANDS)['css_search']['requestSchema']>): Promise<ClientResponse<'css_search'>>;
 /** What one element looks like: styles, box, layout and child tree. */
 export declare function domInspect(params: NoType<(typeof COMMANDS)['dom_inspect']['requestSchema']>): Promise<ClientResponse<'dom_inspect'>>;
 /**

package/dist/ipc/client.js

@@ -251,8 +251,10 @@ export async function getNetworkHeaders(options) {
  *
  * @param method - CDP method name (e.g., 'Network.getCookies')
  * @param params - Optional method parameters
+ * @param options - `isolated`: a bdg page script, run in bdg's isolated world
+ *   (`Runtime.evaluate`, `DOM.resolveNode`)
  * @returns Response with CDP method result
- * @throws Error if connection fails; CommandError (102) when the page was busy and its scripts were terminated
+ * @throws Error if connection fails; CommandError (102) when the page was busy and its scripts were terminated, (107) when the page crashed
  *
  * @example
  * ```typescript
@@ -262,13 +264,32 @@ export async function getNetworkHeaders(options) {
  * }
  * ```
  */
-export async function callCDP(method, params) {
-    const response = await sendCommand('cdp_call', { method, ...(params && { params }) });
-    if (response.status === 'error' && response.exitCode === EXIT_CODES.CDP_TIMEOUT) {
-        throw new CommandError(response.error ?? `${method} timed out`, response.suggestion ? { suggestion: response.suggestion } : {}, EXIT_CODES.CDP_TIMEOUT);
+export async function callCDP(method, params, options = {}) {
+    const response = await sendCommand('cdp_call', {
+        method,
+        ...(params && { params }),
+        ...(options.isolated && { isolated: true }),
+    });
+    const fatal = [EXIT_CODES.CDP_TIMEOUT, EXIT_CODES.PAGE_CRASHED];
+    if (response.status === 'error' && response.exitCode && fatal.includes(response.exitCode)) {
+        throw new CommandError(response.error ?? `${method} failed`, response.suggestion ? { suggestion: response.suggestion } : {}, response.exitCode);
     }
     return response;
 }
+/**
+ * Send a CDP call for one of bdg's own page scripts: `Runtime.evaluate` and
+ * `DOM.resolveNode` run in bdg's isolated world, so a page that replaced
+ * built-ins (`querySelectorAll`, `JSON.stringify`) cannot change what they
+ * find or return.
+ *
+ * @param method - CDP method name
+ * @param params - Method parameters
+ * @returns Response with the CDP method result
+ * @throws Like {@link callCDP}
+ */
+export function callBdgScript(method, params) {
+    return callCDP(method, params, { isolated: true });
+}
 /**
  * Evaluate a JavaScript expression in the active page (or one of its iframes) via the daemon.
  */
@@ -334,6 +355,14 @@ export async function domListeners(params) {
 export async function domLayout(params) {
     return sendCommand('dom_layout', params);
 }
+/** Page-wide checks: contrast, overflow, layers, animations. */
+export async function domAudit(params) {
+    return sendCommand('dom_audit', params);
+}
+/** Find text in the page's stylesheets. */
+export async function cssSearch(params) {
+    return sendCommand('css_search', params);
+}
 /** What one element looks like: styles, box, layout and child tree. */
 export async function domInspect(params) {
     return sendCommand('dom_inspect', params);

package/dist/ipc/protocol/auditTypes.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Types of `bdg dom audit` (page-wide checks) and `bdg css search`.
+ */
+/** A check `dom audit` can run */
+export type AuditCheck = 'contrast' | 'overflow' | 'layers' | 'animations';
+/** Every check, in the order they are shown */
+export declare const AUDIT_CHECKS: readonly AuditCheck[];
+/** Text below the contrast level */
+export interface AuditContrastItem {
+    /** `tag#id` or `tag.firstClass` */
+    element: string;
+    text: string;
+    /** WCAG ratio, rounded down to 2 decimals */
+    ratio: number;
+    color: string;
+    /** Background behind the text, composited */
+    background: string;
+    /** Font size (px) and weight: large text needs less contrast */
+    size: number;
+    weight: number;
+    inView: boolean;
+    /** Opacity of the text and its ancestors, when below 1 (the colors are faded by it) */
+    opacity?: number;
+    /** Why the ratio is approximate (blend modes, filters, an element behind or on top, out of view) */
+    approximate?: string[];
+}
+/** An image drawn larger than its pixels, or with another aspect ratio */
+export interface AuditImage {
+    element: string;
+    natural: {
+        w: number;
+        h: number;
+    };
+    rendered: {
+        w: number;
+        h: number;
+    };
+    /** Pixels needed (rendered size × pixel ratio) over the image's pixels, the larger of width and height */
+    scale: number;
+    /** Identical findings this one stands for (2 or more) */
+    count?: number;
+    upscaled?: true;
+    distorted?: true;
+}
+/** What `dom audit` found */
+export interface AuditResult {
+    checks: AuditCheck[];
+    /** Elements walked */
+    walked: number;
+    /** The walk stopped at its cap: the page has more elements */
+    capped?: true;
+    contrast?: {
+        level: 'AA' | 'AAA';
+        /** Text holders checked */
+        checked: number;
+        /** How many are below the level (measured exactly) */
+        failing: number;
+        /** How many more look below the level but cannot be measured exactly (text over images, blend modes, layers): not listed, `dom inspect` them */
+        uncertain?: number;
+        /** The weakest ones, at most `--limit` */
+        items: AuditContrastItem[];
+    };
+    overflow?: {
+        pageWidth: number;
+        viewportWidth: number;
+        /** The page is wider than its viewport (it scrolls sideways) */
+        scrollsSideways: boolean;
+        /** Elements reaching past the viewport's right edge (not inside a scroller), farthest first */
+        wide: Array<{
+            element: string;
+            right: number;
+            width: number;
+        }>;
+        /** Text cut off: `ellipsis`, `clamp` or `clip` */
+        truncated: Array<{
+            element: string;
+            text: string;
+            kind: string;
+            count?: number;
+        }>;
+        images: AuditImage[];
+        /** Device pixel ratio the image scale counts in (an image needs that many pixels per CSS px) */
+        pixelRatio: number;
+        /** Elements whose content scrolls sideways inside them (carousels, tab strips): fine, but cut off at first sight */
+        scrollers: Array<{
+            element: string;
+            scrollWidth: number;
+            width: number;
+        }>;
+    };
+    layers?: Array<{
+        element: string;
+        position: string;
+        zIndex: string;
+        /** Viewport position and size */
+        rect: {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+        };
+        inView: boolean;
+    }>;
+    animations?: Array<{
+        element: string;
+        name: string;
+        type: string;
+        /** Duration (ms) */
+        duration: number | string;
+        iterations: number | string;
+        /** Driven by scrolling, not time */
+        scrollDriven?: true;
+        /** Identical animations this one stands for (2 or more) */
+        count?: number;
+    }>;
+    /** Visible `<canvas>` elements: scripts may animate them, which `animations` cannot see */
+    canvases?: number;
+}
+/** A stylesheet line where `css search` found the text */
+export interface CssSearchMatch {
+    /** `app.css:12`, `bootstrap.min.css:5:52628`, `<style> in index.html:40` */
+    source: string;
+    /** The rule (or line) around the match, cut to a few hundred characters */
+    text: string;
+}
+/** What `css search` found */
+export interface CssSearchResult {
+    query: string;
+    /** Stylesheets searched */
+    sheets: number;
+    /** Matches found (the list may be shorter: `--limit`) */
+    total: number;
+    matches: CssSearchMatch[];
+}
+//# sourceMappingURL=auditTypes.d.ts.map

package/dist/ipc/protocol/auditTypes.js

@@ -0,0 +1,6 @@
+/**
+ * Types of `bdg dom audit` (page-wide checks) and `bdg css search`.
+ */
+/** Every check, in the order they are shown */
+export const AUDIT_CHECKS = ['contrast', 'overflow', 'layers', 'animations'];
+//# sourceMappingURL=auditTypes.js.map

package/dist/ipc/protocol/commands.d.ts

@@ -5,6 +5,7 @@
  * Each command has a request schema (input) and response data schema (output).
  */
 import type { HintDetails } from '../../errors/notices.js';
+import type { AuditCheck, AuditResult, CssSearchResult } from './auditTypes.js';
 import type { ClickResult, FillResult, LayoutResult, ListenersResult, PressKeyResult, RawFormData, ScrollResult, SubmitResult } from './domTypes.js';
 import type { InspectResult } from './inspectTypes.js';
 import type { PageState, SessionActivity } from '../session/types.js';
@@ -65,10 +66,14 @@ export interface SessionPeekData {
     }>;
     /** Navigation id of the page currently loaded. */
     currentNavigationId: number;
+    /** When the page's renderer crashed (epoch ms), while it is not loaded again */
+    pageCrashedAt?: number;
     /** Total number of network requests (for pagination). */
     totalNetwork: number;
     /** Total number of console messages (for pagination). */
     totalConsole: number;
+    /** Console messages dropped at the limit (the oldest; indices start after them) */
+    droppedConsole?: number;
     /** Whether there are more network items available. */
     hasMoreNetwork?: boolean;
     /** Whether there are more console items available. */
@@ -98,6 +103,12 @@ export interface CdpCallCommand {
     method: string;
     /** Optional parameters for the CDP method. */
     params?: Record<string, unknown>;
+    /**
+     * A bdg page script: `Runtime.evaluate` and `DOM.resolveNode` run in bdg's
+     * isolated world, out of reach of built-ins the page replaced (not for
+     * `bdg cdp`, whose calls stay in the page's world)
+     */
+    isolated?: boolean;
 }
 /**
  * CDP call command response data.
@@ -182,6 +193,8 @@ export interface DomEvalData {
     subtype?: string;
     /** URL of the iframe the script ran in (with `frame`; empty when it has none) */
     frame?: string;
+    /** Set when the page replaced built-ins bdg's copy of the result uses */
+    warning?: string;
 }
 /** An iframe of the page, as listed by `bdg dom frames` */
 export interface DomFrame {
@@ -312,6 +325,26 @@ export interface DomLayoutCommand {
     backendNodeId?: number;
 }
 export type DomLayoutData = LayoutResult;
+/**
+ * dom_audit: page-wide checks (contrast, overflow, layers, animations).
+ */
+export interface DomAuditCommand {
+    checks: AuditCheck[];
+    /** WCAG level text must reach (default AA) */
+    level?: 'AA' | 'AAA';
+    /** Findings listed per check */
+    limit?: number;
+}
+export type DomAuditData = AuditResult;
+/**
+ * css_search: find text in the page's stylesheets.
+ */
+export interface CssSearchCommand {
+    query: string;
+    /** Matches listed at most */
+    limit?: number;
+}
+export type CssSearchData = CssSearchResult;
 /**
  * dom_inspect: what one element looks like (styles, box, layout, child tree).
  */
@@ -369,6 +402,8 @@ export type RegistryShape = {
     dom_form_discover: CommandDef<DomFormDiscoverCommand, DomFormDiscoverData>;
     dom_listeners: CommandDef<DomListenersCommand, DomListenersData>;
     dom_layout: CommandDef<DomLayoutCommand, DomLayoutData>;
+    dom_audit: CommandDef<DomAuditCommand, DomAuditData>;
+    css_search: CommandDef<CssSearchCommand, CssSearchData>;
     dom_inspect: CommandDef<DomInspectCommand, DomInspectData>;
     dom_wait: CommandDef<DomWaitCommand, DomWaitData>;
     page_navigate: CommandDef<PageNavigateCommand, PageNavigationResult>;

package/dist/ipc/protocol/commands.js

@@ -35,6 +35,8 @@ export const COMMANDS = {
     dom_form_discover: defineCommand(),
     dom_listeners: defineCommand(),
     dom_layout: defineCommand(),
+    dom_audit: defineCommand(),
+    css_search: defineCommand(),
     dom_inspect: defineCommand(),
     dom_wait: defineCommand(),
 };

package/dist/ipc/protocol/domTypes.d.ts

@@ -86,6 +86,8 @@ export interface ActionEffects {
     navigation?: PageNavigation;
     /** Messages that appeared or changed (at most 3; absent when none did) */
     messages?: NewMessage[];
+    /** How many more new messages there were than `messages` lists */
+    moreMessages?: number;
     /** Elements a hover or key press showed (at most 3, outermost first; absent when none) */
     shown?: ShownElement[];
     /** "none" when the action had no visible effect: no DOM change, request or navigation */
@@ -94,6 +96,8 @@ export interface ActionEffects {
     settled?: false;
     /** What the page was still working on (with `settled: false`) */
     pending?: PendingChanges;
+    /** All built-ins the page replaced that bdg's action scripts use (when the warning mentions them) */
+    replacedBuiltins?: string[];
 }
 /** A filled field's value differing from the one given */
 export interface FillValueMismatch {
@@ -163,6 +167,11 @@ export interface ClickResult extends ActionEffects {
     method?: 'mouse' | 'dom';
     /** What was done: click, double (click), right (click) or hover */
     action?: 'click' | 'double' | 'right' | 'hover';
+    /** How far the page scrolled to bring the element into view (CSS px; absent when it did not move) */
+    scrolledBy?: {
+        x: number;
+        y: number;
+    };
     /** Exit code for a failure */
     exitCode?: number;
     /** Why the DOM fallback was used (element covered or without size) */
@@ -405,6 +414,8 @@ export interface ElementLayout {
     scrollBy?: LayoutPoint;
     /** Ancestor or iframe cutting it off (scroll that container instead of the page) */
     clippedBy?: string;
+    /** It or a container is `position: fixed`: page scroll does not move it */
+    fixed?: true;
     /** Why page scroll cannot bring it fully into view: it is fixed, or beyond the page's scroll range */
     offScreenReason?: string;
     /** Topmost element at the center of its visible part, when that is another element */
@@ -421,6 +432,11 @@ export interface ElementLayout {
      * `opacity: 0 on div#menu` (`inViewport` still says where it is)
      */
     invisible?: string;
+    /**
+     * A `mask-image` on it or an ancestor, e.g. `mask-image on div.hero`: part
+     * or all of it may not show (how much is not evaluated)
+     */
+    masked?: string;
     /** Inside an `inert` element: shown, but a user cannot interact with it */
     inert?: true;
     computed: LayoutComputedStyle;

package/dist/ipc/protocol/inspectTypes.d.ts

@@ -14,6 +14,13 @@ export interface InspectRect {
     y: number;
     w: number;
     h: number;
+    /** `viewport`: x and y are in the viewport (a fixed element stays there however the page scrolls) */
+    in?: 'viewport';
+    /** Size of the box it covers on screen when a transform (rotation, skew) makes that differ; x and y are its corner */
+    screen?: {
+        w: number;
+        h: number;
+    };
 }
 /** Sides top, right, bottom, left */
 export type Sides = [CssLength, CssLength, CssLength, CssLength];
@@ -104,17 +111,29 @@ export interface InspectContrast {
     /** A background image or gradient is behind the text: the ratio uses the colors only */
     overImage?: boolean;
     /**
-     * Opacity of the element and its ancestors (below 1): the text color is
-     * faded by it before the ratio is taken (backgrounds inside the faded
-     * subtree are not, so the ratio is approximate)
+     * Opacity of the element and its ancestors (below 1): each translucent
+     * element fades its background and the text over it before the ratio is
+     * taken
      */
     opacity?: number;
+    /**
+     * Why the ratio is approximate: `mix-blend-mode hard-light on h1`,
+     * `filter on div.skin-invert`, `canvas behind`, `div.overlay on top`
+     */
+    approximate?: string[];
 }
 /** Typography (for containers without text of their own: only what differs from the parent) */
 export interface InspectText {
+    /**
+     * Label of the descendant that draws most of the text when it is not the
+     * element (`abbr`, `slot.button__label`): the fields describe its text
+     */
+    holder?: string;
     family?: string;
-    /** Font Chrome rendered the text with, when it is not the first family */
+    /** Font Chrome rendered the text with, when it is a fallback for the first family */
     rendered?: string;
+    /** Font a generic first family (`sans-serif`, `system-ui`) resolved to */
+    resolved?: string;
     /** The rendered font is a web font */
     webfont?: boolean;
     weight?: number;
@@ -132,19 +151,30 @@ export interface InspectText {
     clamp?: string;
     shadow?: string;
     features?: string;
+    /** The text is cut off (clipped by overflow, with or without an ellipsis, or by a line clamp) */
+    truncated?: true;
+    /** The text is painted with its background (`background-clip: text`, transparent fill): no single color, so no contrast */
+    gradientFill?: true;
 }
 /** A background layer */
 export type InspectFill = {
     type: 'solid';
     color: string;
 } | {
-    type: 'gradient';
-    value: string;
-} | {
-    type: 'image';
+    type: 'gradient' | 'image';
     value: string;
     size?: string;
+    position?: string;
 };
+/** How an SVG element is painted */
+export interface InspectSvgPaint {
+    /** Fill color (hex), `none` or a paint server (`url(#grad)`) */
+    fill: string;
+    /** Stroke color, `none` or a paint server */
+    stroke: string;
+    /** Stroke width (px), when there is a stroke */
+    strokeWidth?: CssLength;
+}
 /** A border side (or all four) */
 export interface InspectStroke {
     side: 'all' | 'top' | 'right' | 'bottom' | 'left';
@@ -184,6 +214,8 @@ export interface InspectPseudo {
     content?: string;
     display?: string;
     position?: string;
+    /** Offsets of a positioned one (top right bottom left) */
+    inset?: string;
     size?: {
         w: number;
         h: number;
@@ -212,6 +244,12 @@ export interface InspectTreeNode {
     /** `flex` or `grid` container */
     layout?: 'flex' | 'grid';
     text?: string;
+    /** `display: contents` (a text-only slot): no box of its own */
+    contents?: true;
+    /** Reached through a slot or a `display: contents` wrapper (`slot.label`, `div.row (contents)`) */
+    via?: string;
+    /** In the shadow root of its parent */
+    shadow?: true;
     /** Identical siblings this row stands for (2 or more) */
     count?: number;
     children?: InspectTreeNode[];
@@ -232,6 +270,8 @@ export interface InspectVisibility {
     coveredBy?: string;
     /** The cover paints nothing there: the element shows, but clicks land on the cover */
     coverTransparent?: true;
+    /** A `mask-image` on it or an ancestor, e.g. `mask-image on div.hero` (how much it hides is not evaluated) */
+    masked?: string;
 }
 /** A property asked for with `--props` */
 export interface InspectProp {
@@ -251,6 +291,10 @@ export interface InspectHint {
     reason: string;
     /** e.g. `use display: flex or grid on this element` */
     fix: string;
+    /** The longhands of a shorthand that have no effect, when the others do (`margin-top`, `margin-bottom`) */
+    only?: string[];
+    /** The custom properties that are not set (`unset-variable`) */
+    variables?: string[];
     /** e.g. `.hero (app.css:12)` */
     source: string;
 }
@@ -264,6 +308,8 @@ export interface InspectRule {
     computed?: string;
     /** e.g. `.btn-primary (bootstrap.min.css:5:52628)`, `style attribute` */
     source: string;
+    /** The rule as written (selector and declarations); a rule over 300 characters is cut to its selector and this declaration */
+    rule?: string;
     /** Selectors of the declarations it beats */
     overrides?: string[];
     /** Set on an ancestor this many levels up (inherited) */
@@ -286,8 +332,15 @@ export interface InspectWhyEntry {
     source: string;
     /** Specificity of the rule's selector (ids, classes, types) */
     specificity?: [number, number, number];
+    /** The rule as written (selector and declarations); a rule over 300 characters is cut to its selector and this declaration */
+    rule?: string;
     /** `applied` (wins), `overridden`, or `inherited` (from an ancestor: the winner, or one it beat there) */
     status: 'applied' | 'overridden' | 'inherited';
+    /**
+     * Why the winner changes nothing: `no effect: position is static`, or for
+     * an invalid `var()`, what applies instead (`falls back to the initial value`)
+     */
+    note?: string;
     important?: true;
     layer?: string;
     condition?: string;
@@ -300,6 +353,12 @@ export interface InspectWhy {
     chain: InspectWhyEntry[];
     /** Where the custom properties of the winning value are set */
     variables?: InspectVariable[];
+    /** Rules for the element that set it under a `@media`/`@supports` condition that does not apply now */
+    inactive?: Array<{
+        value: string;
+        selector: string;
+        condition: string;
+    }>;
 }
 /** A custom property a winning value uses, and where it is set */
 export interface InspectVariable {
@@ -324,6 +383,8 @@ export interface InspectResult {
      * rendered) or the first
      */
     picked?: 'first-visible' | 'first';
+    /** The selector named a pseudo-element (`a::after`): its element was inspected, the pseudo-element is under `pseudo` */
+    pseudoOf?: '::before' | '::after';
     /** `tag#id.c1.c2(+N)` */
     element: string;
     /** Its text (innerText) or form value, at most 30 characters; not for containers */
@@ -341,6 +402,8 @@ export interface InspectResult {
      * theme's
      */
     theme?: 'dark';
+    /** The dark preference behind `theme` comes from `page emulate`, not the system */
+    themeFrom?: 'emulation';
     /**
      * Running CSS transitions (their property) and animations (their name):
      * the values read are mid-way and will still change
@@ -352,6 +415,8 @@ export interface InspectResult {
     layout?: InspectLayout;
     text?: InspectText;
     fills?: InspectFill[];
+    /** SVG paint: `fill` and `stroke` (with its width) of an SVG element */
+    paint?: InspectSvgPaint;
     opacity?: number;
     blend?: string;
     strokes?: InspectStroke[];

package/dist/ipc/session/types.d.ts

@@ -29,5 +29,7 @@ export interface PageState {
     viewport?: ViewportSize;
     /** `prefers-color-scheme` the page sees (left out when the page did not answer in time). */
     colorScheme?: ColorScheme;
+    /** When the page's renderer crashed (epoch ms); `bdg page reload` brings it back */
+    crashedAt?: number;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/runtime/css/search.d.ts

@@ -0,0 +1,39 @@
+/**
+ * `bdg css search <text>`: find text in the page's stylesheets, cross-origin
+ * ones included (CDP reads every stylesheet's text), and show the rule
+ * around each match with its `file:line`.
+ */
+import type { CDPConnection } from '../../connection/cdp.js';
+import type { CssSearchResult } from '../../ipc/protocol/auditTypes.js';
+import type { CssSearchCommand } from '../../ipc/protocol/commands.js';
+/** Matches listed without `--limit` */
+export declare const DEFAULT_CSS_SEARCH_LIMIT = 20;
+/**
+ * Search the stylesheets for a text (case-insensitive).
+ *
+ * @param cdp - CDP connection
+ * @param params - Text and limit
+ * @returns Matches with their place
+ */
+export declare function searchStyleSheets(cdp: CDPConnection, params: CssSearchCommand): Promise<CssSearchResult>;
+/**
+ * Where a text occurs in a stylesheet (case-insensitive): how many times,
+ * and for the first `limit` matches the 0-based line and column and the
+ * rule around it (from the end of the previous rule to the end of this one,
+ * whitespace collapsed, at most {@link RULE_CONTEXT} characters each side).
+ * Lines are counted as the search moves on, so a big sheet is read once.
+ *
+ * @param text - Stylesheet text
+ * @param query - Text to find
+ * @param limit - Matches described at most
+ * @returns Match count and the described matches
+ */
+export declare function findInSheet(text: string, query: string, limit?: number): {
+    total: number;
+    matches: Array<{
+        line: number;
+        column: number;
+        rule: string;
+    }>;
+};
+//# sourceMappingURL=search.d.ts.map