lighthouse 12.8.2-dev.20251004 → 12.8.2-dev.20251006

package/core/audits/font-display.js

@@ -1,195 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import {Audit} from './audit.js';
-import UrlUtils from '../lib/url-utils.js';
-import * as i18n from '../lib/i18n/i18n.js';
-import {Sentry} from '../lib/sentry.js';
-import {NetworkRecords} from '../computed/network-records.js';
-
-const PASSING_FONT_DISPLAY_REGEX = /^(block|fallback|optional|swap)$/;
-const CSS_URL_REGEX = /url\((.*?)\)/;
-const CSS_URL_GLOBAL_REGEX = new RegExp(CSS_URL_REGEX, 'g');
-
-const UIStrings = {
-  /** Title of a diagnostic audit that provides detail on if all the text on a webpage was visible while the page was loading its webfonts. This descriptive title is shown to users when the amount is acceptable and no user action is required. */
-  title: 'All text remains visible during webfont loads',
-  /** Title of a diagnostic audit that provides detail on the load of the page's webfonts. Often the text is invisible for seconds before the webfont resource is loaded. This imperative title is shown to users when there is a significant amount of execution time that could be reduced. */
-  failureTitle: 'Ensure text remains visible during webfont load',
-  /** Description of a Lighthouse audit that tells the user *why* they should use the font-display CSS feature. This is displayed after a user expands the section to see more. No character length limits. The last sentence starting with 'Learn' becomes link text to additional documentation. */
-  description:
-    'Leverage the `font-display` CSS feature to ensure text is user-visible while ' +
-    'webfonts are loading. ' +
-    '[Learn more about `font-display`](https://developer.chrome.com/docs/lighthouse/performance/font-display/).',
-  /**
-   * @description [ICU Syntax] A warning message that is shown when Lighthouse couldn't automatically check some of the page's fonts, telling the user that they will need to manually check the fonts coming from a certain URL origin.
-   * @example {https://font.cdn.com/} fontOrigin
-   */
-  undeclaredFontOriginWarning:
-    '{fontCountForOrigin, plural, ' +
-    // eslint-disable-next-line max-len
-    '=1 {Lighthouse was unable to automatically check the `font-display` value for the origin {fontOrigin}.} ' +
-    // eslint-disable-next-line max-len
-    'other {Lighthouse was unable to automatically check the `font-display` values for the origin {fontOrigin}.}}',
-};
-
-const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
-
-class FontDisplay extends Audit {
-  /**
-   * @return {LH.Audit.Meta}
-   */
-  static get meta() {
-    return {
-      id: 'font-display',
-      title: str_(UIStrings.title),
-      failureTitle: str_(UIStrings.failureTitle),
-      description: str_(UIStrings.description),
-      supportedModes: ['navigation'],
-      guidanceLevel: 3,
-      requiredArtifacts: ['DevtoolsLog', 'Stylesheets', 'URL'],
-      scoreDisplayMode: Audit.SCORING_MODES.METRIC_SAVINGS,
-    };
-  }
-
-  /**
-   * @param {LH.Artifacts} artifacts
-   * @param {RegExp} passingFontDisplayRegex
-   * @return {{passingURLs: Set<string>, failingURLs: Set<string>}}
-   */
-  static findFontDisplayDeclarations(artifacts, passingFontDisplayRegex) {
-    /** @type {Set<string>} */
-    const passingURLs = new Set();
-    /** @type {Set<string>} */
-    const failingURLs = new Set();
-
-    // Go through all the stylesheets to find all @font-face declarations
-    for (const stylesheet of artifacts.Stylesheets) {
-      // Eliminate newlines so we can more easily scan through with a regex
-      const newlinesStripped = stylesheet.content.replace(/(\r|\n)+/g, ' ');
-      // Find the @font-faces
-      const fontFaceDeclarations = newlinesStripped.match(/@font-face\s*{(.*?)}/g) || [];
-      // Go through all the @font-face declarations to find a declared `font-display: ` property
-      for (const declaration of fontFaceDeclarations) {
-        // We'll try to find the URL it's referencing.
-        const rawFontURLs = declaration.match(CSS_URL_GLOBAL_REGEX);
-        // If no URLs, we can't really do anything; bail
-        if (!rawFontURLs) continue;
-        // Find the font-display value by matching a single token, optionally surrounded by whitespace,
-        // followed either by a semicolon or the end of a block.
-        const fontDisplayMatch = declaration.match(/font-display\s*:\s*(\w+)\s*(;|\})/);
-        const rawFontDisplay = fontDisplayMatch?.[1] || '';
-        const hasPassingFontDisplay = passingFontDisplayRegex.test(rawFontDisplay);
-        const targetURLSet = hasPassingFontDisplay ? passingURLs : failingURLs;
-
-        // Finally convert the raw font URLs to the absolute URLs and add them to the set.
-        const relativeURLs = rawFontURLs
-          // @ts-expect-error - guaranteed to match from previous regex, pull URL group out
-          .map(s => s.match(CSS_URL_REGEX)[1].trim())
-          .map(s => {
-            // remove any quotes surrounding the URL
-            if (/^('|").*\1$/.test(s)) {
-              return s.substr(1, s.length - 2);
-            }
-
-            return s;
-          });
-
-        // Convert the relative CSS URL to an absolute URL and add it to the target set.
-        for (const relativeURL of relativeURLs) {
-          try {
-            const relativeRoot = UrlUtils.isValid(stylesheet.header.sourceURL) ?
-              stylesheet.header.sourceURL : artifacts.URL.finalDisplayedUrl;
-            const absoluteURL = new URL(relativeURL, relativeRoot);
-            targetURLSet.add(absoluteURL.href);
-          } catch (err) {
-            Sentry.captureException(err, {tags: {audit: this.meta.id}});
-          }
-        }
-      }
-    }
-
-    return {passingURLs, failingURLs};
-  }
-
-  /**
-   * Some pages load many fonts we can't check, so dedupe on origin.
-   * @param {Array<string>} warningUrls
-   * @return {Array<LH.IcuMessage>}
-   */
-  static getWarningsForFontUrls(warningUrls) {
-    /** @type {Map<string, number>} */
-    const warningCountByOrigin = new Map();
-    for (const warningUrl of warningUrls) {
-      const origin = UrlUtils.getOrigin(warningUrl);
-      if (!origin) continue;
-
-      const count = warningCountByOrigin.get(origin) || 0;
-      warningCountByOrigin.set(origin, count + 1);
-    }
-
-    const warnings = [...warningCountByOrigin].map(([fontOrigin, fontCountForOrigin]) => {
-      return str_(UIStrings.undeclaredFontOriginWarning, {fontCountForOrigin, fontOrigin});
-    });
-    return warnings;
-  }
-
-  /**
-   * @param {LH.Artifacts} artifacts
-   * @param {LH.Audit.Context} context
-   * @return {Promise<LH.Audit.Product>}
-   */
-  static async audit(artifacts, context) {
-    const devtoolsLogs = artifacts.DevtoolsLog;
-    const networkRecords = await NetworkRecords.request(devtoolsLogs, context);
-    const {passingURLs, failingURLs} =
-      FontDisplay.findFontDisplayDeclarations(artifacts, PASSING_FONT_DISPLAY_REGEX);
-    /** @type {Array<string>} */
-    const warningURLs = [];
-
-    const results = networkRecords
-      // Find all fonts...
-      .filter(record => record.resourceType === 'Font')
-      // ...and that aren't data URLs, the blocking concern doesn't really apply
-      .filter(record => !/^data:/.test(record.url))
-      .filter(record => !/^blob:/.test(record.url))
-      // ...that have a failing font-display value
-      .filter(record => {
-        // Failing URLs should be considered.
-        if (failingURLs.has(record.url)) return true;
-        // Everything else shouldn't be, but we should warn if we don't recognize the URL at all.
-        if (!passingURLs.has(record.url)) warningURLs.push(record.url);
-        return false;
-      })
-      .map(record => {
-        // In reality the end time should be calculated with paint time included
-        // all browsers wait 3000ms to block text so we make sure 3000 is our max wasted time
-        const wastedMs = Math.min(record.networkEndTime - record.networkRequestTime, 3000);
-
-        return {
-          url: record.url,
-          wastedMs,
-        };
-      });
-
-    /** @type {LH.Audit.Details.Table['headings']} */
-    const headings = [
-      {key: 'url', valueType: 'url', label: str_(i18n.UIStrings.columnURL)},
-      {key: 'wastedMs', valueType: 'ms', label: str_(i18n.UIStrings.columnWastedMs)},
-    ];
-
-    const details = Audit.makeTableDetails(headings, results);
-
-    return {
-      score: Number(results.length === 0),
-      details,
-      warnings: FontDisplay.getWarningsForFontUrls(warningURLs),
-    };
-  }
-}
-
-export default FontDisplay;
-export {UIStrings};

package/core/audits/largest-contentful-paint-element.d.ts

@@ -1,34 +0,0 @@
-export default LargestContentfulPaintElement;
-declare class LargestContentfulPaintElement extends Audit {
-    /**
-     * @param {LH.Artifacts} artifacts
-     * @return {LH.Audit.Details.Table|undefined}
-     */
-    static makeElementTable(artifacts: LH.Artifacts): LH.Audit.Details.Table | undefined;
-    /**
-     * @param {number} metricLcp
-     * @param {LH.Artifacts.MetricComputationDataInput} metricComputationData
-     * @param {LH.Audit.Context} context
-     * @return {Promise<LH.Audit.Details.Table>}
-     */
-    static makePhaseTable(metricLcp: number, metricComputationData: LH.Artifacts.MetricComputationDataInput, context: LH.Audit.Context): Promise<LH.Audit.Details.Table>;
-    /**
-     * @param {LH.Artifacts} artifacts
-     * @param {LH.Audit.Context} context
-     * @return {Promise<LH.Audit.Product>}
-     */
-    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
-}
-export namespace UIStrings {
-    let title: string;
-    let description: string;
-    let columnPhase: string;
-    let columnPercentOfLCP: string;
-    let columnTiming: string;
-    let itemTTFB: string;
-    let itemLoadDelay: string;
-    let itemLoadTime: string;
-    let itemRenderDelay: string;
-}
-import { Audit } from './audit.js';
-//# sourceMappingURL=largest-contentful-paint-element.d.ts.map

package/core/audits/largest-contentful-paint-element.js

@@ -1,181 +0,0 @@
-/**
- * @license
- * Copyright 2020 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import log from 'lighthouse-logger';
-
-import {Audit} from './audit.js';
-import * as i18n from '../lib/i18n/i18n.js';
-import {LargestContentfulPaint as LargestContentfulPaintComputed} from '../computed/metrics/largest-contentful-paint.js';
-import LargestContentfulPaint from './metrics/largest-contentful-paint.js';
-import {LCPBreakdown} from '../computed/metrics/lcp-breakdown.js';
-import {Sentry} from '../lib/sentry.js';
-
-const UIStrings = {
-  /** Descriptive title of a diagnostic audit that provides the element that was determined to be the Largest Contentful Paint. */
-  title: 'Largest Contentful Paint element',
-  /** Description of a Lighthouse audit that tells the user that the element shown was determined to be the Largest Contentful Paint. */
-  description: 'This is the largest contentful element painted within the viewport. ' +
-    '[Learn more about the Largest Contentful Paint element](https://developer.chrome.com/docs/lighthouse/performance/lighthouse-largest-contentful-paint/)',
-  /** Label for a column in a data table; entries will be the name of a phase in the Largest Contentful Paint (LCP) metric. */
-  columnPhase: 'Phase',
-  /** Label for a column in a data table; entries will be the percent of Largest Contentful Paint (LCP) that a phase covers. */
-  columnPercentOfLCP: '% of LCP',
-  /** Label for a column in a data table; entries will be the amount of time spent in a phase in the Largest Contentful Paint (LCP) metric. */
-  columnTiming: 'Timing',
-  /** Table item value for the Time To First Byte (TTFB) phase of the Largest Contentful Paint (LCP) metric. */
-  itemTTFB: 'TTFB',
-  /** Table item value for the load delay phase of the Largest Contentful Paint (LCP) metric. */
-  itemLoadDelay: 'Load Delay',
-  /** Table item value for the load time phase of the Largest Contentful Paint (LCP) metric. */
-  itemLoadTime: 'Load Time',
-  /** Table item value for the render delay phase of the Largest Contentful Paint (LCP) metric. */
-  itemRenderDelay: 'Render Delay',
-};
-
-const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
-
-class LargestContentfulPaintElement extends Audit {
-  /**
-   * @return {LH.Audit.Meta}
-   */
-  static get meta() {
-    return {
-      id: 'largest-contentful-paint-element',
-      title: str_(UIStrings.title),
-      description: str_(UIStrings.description),
-      scoreDisplayMode: Audit.SCORING_MODES.METRIC_SAVINGS,
-      guidanceLevel: 1,
-      supportedModes: ['navigation'],
-      requiredArtifacts:
-        ['Trace', 'TraceElements', 'DevtoolsLog', 'GatherContext', 'settings', 'URL',
-          'SourceMaps'],
-    };
-  }
-
-  /**
-   * @param {LH.Artifacts} artifacts
-   * @return {LH.Audit.Details.Table|undefined}
-   */
-  static makeElementTable(artifacts) {
-    const lcpElement = artifacts.TraceElements
-      .find(element => element.traceEventType === 'largest-contentful-paint');
-    if (!lcpElement) return;
-
-    /** @type {LH.Audit.Details.Table['headings']} */
-    const headings = [
-      {key: 'node', valueType: 'node', label: str_(i18n.UIStrings.columnElement)},
-    ];
-
-    const lcpElementDetails = [{node: Audit.makeNodeItem(lcpElement.node)}];
-
-    return Audit.makeTableDetails(headings, lcpElementDetails);
-  }
-
-  /**
-   * @param {number} metricLcp
-   * @param {LH.Artifacts.MetricComputationDataInput} metricComputationData
-   * @param {LH.Audit.Context} context
-   * @return {Promise<LH.Audit.Details.Table>}
-   */
-  static async makePhaseTable(metricLcp, metricComputationData, context) {
-    const {ttfb, loadStart, loadEnd} = await LCPBreakdown.request(metricComputationData, context);
-
-    let loadDelay = 0;
-    let loadTime = 0;
-    let renderDelay = metricLcp - ttfb;
-
-    if (loadStart && loadEnd) {
-      loadDelay = loadStart - ttfb;
-      loadTime = loadEnd - loadStart;
-      renderDelay = metricLcp - loadEnd;
-    }
-
-    const results = [
-      {phase: str_(UIStrings.itemTTFB), timing: ttfb},
-      {phase: str_(UIStrings.itemLoadDelay), timing: loadDelay},
-      {phase: str_(UIStrings.itemLoadTime), timing: loadTime},
-      {phase: str_(UIStrings.itemRenderDelay), timing: renderDelay},
-    ].map(result => {
-      const percent = 100 * result.timing / metricLcp;
-      const percentStr = `${percent.toFixed(0)}%`;
-      return {...result, percent: percentStr};
-    });
-
-    /** @type {LH.Audit.Details.Table['headings']} */
-    const headings = [
-      {key: 'phase', valueType: 'text', label: str_(UIStrings.columnPhase)},
-      {key: 'percent', valueType: 'text', label: str_(UIStrings.columnPercentOfLCP)},
-      {key: 'timing', valueType: 'ms', label: str_(UIStrings.columnTiming)},
-    ];
-
-    return Audit.makeTableDetails(headings, results);
-  }
-
-  /**
-   * @param {LH.Artifacts} artifacts
-   * @param {LH.Audit.Context} context
-   * @return {Promise<LH.Audit.Product>}
-   */
-  static async audit(artifacts, context) {
-    const trace = artifacts.Trace;
-    const devtoolsLog = artifacts.DevtoolsLog;
-    const gatherContext = artifacts.GatherContext;
-    const metricComputationData = {
-      trace, devtoolsLog, gatherContext,
-      settings: context.settings, URL: artifacts.URL,
-      SourceMaps: artifacts.SourceMaps, simulator: null,
-    };
-
-    const elementTable = this.makeElementTable(artifacts);
-    if (!elementTable) {
-      return {
-        score: null,
-        notApplicable: true,
-        metricSavings: {LCP: 0},
-      };
-    }
-
-    const items = [elementTable];
-    let displayValue;
-    let metricLcp = 0;
-
-    try {
-      const lcpResult =
-        await LargestContentfulPaintComputed.request(metricComputationData, context);
-      metricLcp = lcpResult.timing;
-      displayValue = str_(i18n.UIStrings.ms, {timeInMs: metricLcp});
-
-      const phaseTable = await this.makePhaseTable(metricLcp, metricComputationData, context);
-      items.push(phaseTable);
-    } catch (err) {
-      Sentry.captureException(err, {
-        tags: {audit: this.meta.id},
-        level: 'error',
-      });
-      log.error(this.meta.id, err.message);
-    }
-
-    const details = Audit.makeListDetails(items);
-
-    // Conceptually, this doesn't make much sense as "savings" for this audit since there isn't anything to "fix".
-    // However, this audit will always be useful when improving LCP and that should be reflected in our impact calculations.
-    const idealLcp = LargestContentfulPaint.defaultOptions[context.settings.formFactor].scoring.p10;
-    const lcpSavings = Math.max(0, metricLcp - idealLcp);
-
-    return {
-      score: lcpSavings ? 0 : 1,
-      scoreDisplayMode: lcpSavings ? undefined : Audit.SCORING_MODES.INFORMATIVE,
-      displayValue,
-      details,
-      metricSavings: {
-        LCP: lcpSavings,
-      },
-    };
-  }
-}
-
-export default LargestContentfulPaintElement;
-export {UIStrings};

package/core/audits/lcp-lazy-loaded.d.ts

@@ -1,22 +0,0 @@
-export default LargestContentfulPaintLazyLoaded;
-declare class LargestContentfulPaintLazyLoaded extends Audit {
-    /**
-     * @param {LH.Artifacts.ImageElement} image
-     * @param {LH.Artifacts.ViewportDimensions} viewportDimensions
-     * @return {boolean}
-     */
-    static isImageInViewport(image: LH.Artifacts.ImageElement, viewportDimensions: LH.Artifacts.ViewportDimensions): boolean;
-    /**
-     * @param {LH.Artifacts} artifacts
-     * @param {LH.Audit.Context} context
-     * @return {Promise<LH.Audit.Product>}
-     */
-    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
-}
-export namespace UIStrings {
-    let title: string;
-    let failureTitle: string;
-    let description: string;
-}
-import { Audit } from './audit.js';
-//# sourceMappingURL=lcp-lazy-loaded.d.ts.map

package/core/audits/lcp-lazy-loaded.js

@@ -1,115 +0,0 @@
-/**
- * @license
- * Copyright 2021 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import {Audit} from './audit.js';
-import * as i18n from '../lib/i18n/i18n.js';
-import {LCPBreakdown} from '../computed/metrics/lcp-breakdown.js';
-import {LargestContentfulPaint} from '../computed/metrics/largest-contentful-paint.js';
-
-const UIStrings = {
-  /** Title of a Lighthouse audit that provides detail on whether the largest above-the-fold image was loaded with sufficient priority. This descriptive title is shown to users when the image was loaded properly. */
-  title: 'Largest Contentful Paint image was not lazily loaded',
-  /** Title of a Lighthouse audit that provides detail on whether the largest above-the-fold image was loaded with sufficient priority. This descriptive title is shown to users when the image was loaded inefficiently using the `loading=lazy` attribute. */
-  failureTitle: 'Largest Contentful Paint image was lazily loaded',
-  /** Description of a Lighthouse audit that tells the user why the advice is important. This is displayed after a user expands the section to see more. No character length limits. */
-  description: 'Above-the-fold images that are lazily loaded render later in the page lifecycle, which can delay the largest contentful paint. [Learn more about optimal lazy loading](https://web.dev/articles/lcp-lazy-loading).',
-};
-
-const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
-
-const ESTIMATED_PERCENT_SAVINGS = 0.15;
-
-class LargestContentfulPaintLazyLoaded extends Audit {
-  /**
-   * @return {LH.Audit.Meta}
-   */
-  static get meta() {
-    return {
-      id: 'lcp-lazy-loaded',
-      title: str_(UIStrings.title),
-      failureTitle: str_(UIStrings.failureTitle),
-      description: str_(UIStrings.description),
-      supportedModes: ['navigation'],
-      scoreDisplayMode: Audit.SCORING_MODES.METRIC_SAVINGS,
-      guidanceLevel: 3,
-      requiredArtifacts: ['TraceElements', 'ViewportDimensions', 'ImageElements',
-        'Trace', 'DevtoolsLog', 'GatherContext', 'URL', 'SourceMaps'],
-    };
-  }
-
-  /**
-   * @param {LH.Artifacts.ImageElement} image
-   * @param {LH.Artifacts.ViewportDimensions} viewportDimensions
-   * @return {boolean}
-   */
-  static isImageInViewport(image, viewportDimensions) {
-    const imageTop = image.clientRect.top;
-    const viewportHeight = viewportDimensions.innerHeight;
-    return imageTop < viewportHeight;
-  }
-
-  /**
-   * @param {LH.Artifacts} artifacts
-   * @param {LH.Audit.Context} context
-   * @return {Promise<LH.Audit.Product>}
-   */
-  static async audit(artifacts, context) {
-    const lcpElement = artifacts.TraceElements.find(element => {
-      return element.traceEventType === 'largest-contentful-paint' && element.type === 'image';
-    });
-    const lcpElementImage = lcpElement ? artifacts.ImageElements.find(elem => {
-      return elem.node.devtoolsNodePath === lcpElement.node.devtoolsNodePath;
-    }) : undefined;
-
-
-    if (!lcpElementImage ||
-      !this.isImageInViewport(lcpElementImage, artifacts.ViewportDimensions)) {
-      return {
-        score: null,
-        notApplicable: true,
-        metricSavings: {LCP: 0},
-      };
-    }
-
-    /** @type {LH.Audit.Details.Table['headings']} */
-    const headings = [
-      {key: 'node', valueType: 'node', label: str_(i18n.UIStrings.columnElement)},
-    ];
-
-    const details = Audit.makeTableDetails(headings, [
-      {
-        node: Audit.makeNodeItem(lcpElementImage.node),
-      },
-    ]);
-
-    const wasLazyLoaded = lcpElementImage.loading === 'lazy';
-
-    const metricComputationData = Audit.makeMetricComputationDataInput(artifacts, context);
-    const {timing: metricLcp} =
-      await LargestContentfulPaint.request(metricComputationData, context);
-    const lcpBreakdown = await LCPBreakdown.request(metricComputationData, context);
-    let lcpSavings = 0;
-    if (wasLazyLoaded && lcpBreakdown.loadStart !== undefined) {
-      // Estimate the LCP savings using a statistical percentage.
-      // https://web.dev/articles/lcp-lazy-loading#causal_performance
-      //
-      // LCP savings will be at most the LCP load delay.
-      const lcpLoadDelay = lcpBreakdown.loadStart - lcpBreakdown.ttfb;
-      lcpSavings = Math.min(metricLcp * ESTIMATED_PERCENT_SAVINGS, lcpLoadDelay);
-    }
-
-    return {
-      score: wasLazyLoaded ? 0 : 1,
-      metricSavings: {
-        LCP: lcpSavings,
-      },
-      details,
-    };
-  }
-}
-
-export default LargestContentfulPaintLazyLoaded;
-export {UIStrings};

package/core/audits/prioritize-lcp-image.d.ts

@@ -1,74 +0,0 @@
-export default PrioritizeLcpImage;
-export type InitiatorType = LH.Crdp.Network.Initiator["type"] | "redirect" | "fallbackToMain";
-export type InitiatorPath = Array<{
-    url: string;
-    initiatorType: InitiatorType;
-}>;
-/**
- * @typedef {LH.Crdp.Network.Initiator['type']|'redirect'|'fallbackToMain'} InitiatorType
- * @typedef {Array<{url: string, initiatorType: InitiatorType}>} InitiatorPath
- */
-declare class PrioritizeLcpImage extends Audit {
-    /**
-     *
-     * @param {LH.Artifacts.NetworkRequest} request
-     * @param {LH.Artifacts.NetworkRequest} mainResource
-     * @param {InitiatorPath} initiatorPath
-     * @return {boolean}
-     */
-    static shouldPreloadRequest(request: LH.Artifacts.NetworkRequest, mainResource: LH.Artifacts.NetworkRequest, initiatorPath: InitiatorPath): boolean;
-    /**
-     * @param {LH.Gatherer.Simulation.GraphNode} graph
-     * @param {NetworkRequest} lcpRecord
-     * @return {LH.Gatherer.Simulation.GraphNetworkNode|undefined}
-     */
-    static findLCPNode(graph: LH.Gatherer.Simulation.GraphNode, lcpRecord: NetworkRequest): LH.Gatherer.Simulation.GraphNetworkNode | undefined;
-    /**
-     * Get the initiator path starting with lcpRecord back to mainResource, inclusive.
-     * Navigation redirects *to* the mainResource are not included.
-     * Path returned will always be at least [lcpRecord, mainResource].
-     * @param {NetworkRequest} lcpRecord
-     * @param {NetworkRequest} mainResource
-     * @return {InitiatorPath}
-     */
-    static getLcpInitiatorPath(lcpRecord: NetworkRequest, mainResource: NetworkRequest): InitiatorPath;
-    /**
-     * @param {LH.Artifacts.NetworkRequest} mainResource
-     * @param {LH.Gatherer.Simulation.GraphNode} graph
-     * @param {NetworkRequest|undefined} lcpRecord
-     * @return {{lcpNodeToPreload?: LH.Gatherer.Simulation.GraphNetworkNode, initiatorPath?: InitiatorPath}}
-     */
-    static getLCPNodeToPreload(mainResource: LH.Artifacts.NetworkRequest, graph: LH.Gatherer.Simulation.GraphNode, lcpRecord: NetworkRequest | undefined): {
-        lcpNodeToPreload?: LH.Gatherer.Simulation.GraphNetworkNode;
-        initiatorPath?: InitiatorPath;
-    };
-    /**
-     * Computes the estimated effect of preloading the LCP image.
-     * @param {LH.Artifacts.TraceElement} lcpElement
-     * @param {LH.Gatherer.Simulation.GraphNetworkNode|undefined} lcpNode
-     * @param {LH.Gatherer.Simulation.GraphNode} graph
-     * @param {LH.Gatherer.Simulation.Simulator} simulator
-     * @return {{wastedMs: number, results: Array<{node: LH.Audit.Details.NodeValue, url: string, wastedMs: number}>}}
-     */
-    static computeWasteWithGraph(lcpElement: LH.Artifacts.TraceElement, lcpNode: LH.Gatherer.Simulation.GraphNetworkNode | undefined, graph: LH.Gatherer.Simulation.GraphNode, simulator: LH.Gatherer.Simulation.Simulator): {
-        wastedMs: number;
-        results: Array<{
-            node: LH.Audit.Details.NodeValue;
-            url: string;
-            wastedMs: number;
-        }>;
-    };
-    /**
-     * @param {LH.Artifacts} artifacts
-     * @param {LH.Audit.Context} context
-     * @return {Promise<LH.Audit.Product>}
-     */
-    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
-}
-export namespace UIStrings {
-    let title: string;
-    let description: string;
-}
-import { Audit } from './audit.js';
-import { NetworkRequest } from '../lib/network-request.js';
-//# sourceMappingURL=prioritize-lcp-image.d.ts.map