lighthouse 12.8.2 → 13.0.0-dev.20251009

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/metrics/first-meaningful-paint.d.ts

@@ -1,12 +0,0 @@
-export default FirstMeaningfulPaint;
-declare class FirstMeaningfulPaint extends Audit {
-    /**
-     * @return {Promise<LH.Audit.Product>}
-     */
-    static audit(): Promise<LH.Audit.Product>;
-}
-export namespace UIStrings {
-    let description: string;
-}
-import { Audit } from '../audit.js';
-//# sourceMappingURL=first-meaningful-paint.d.ts.map

package/core/audits/metrics/first-meaningful-paint.js

@@ -1,47 +0,0 @@
-/**
- * @license
- * Copyright 2016 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-// TODO(COMPAT): This is just a shell. Remove in future breaking release.
-
-import {Audit} from '../audit.js';
-import * as i18n from '../../lib/i18n/i18n.js';
-
-const UIStrings = {
-  /** Description of the First Meaningful Paint (FMP) metric, which marks the time at which a majority of the content has been painted by the browser. This is displayed within a tooltip when the user hovers on the metric name to see more. No character length limits. The last sentence starting with 'Learn' becomes link text to additional documentation. */
-  description: 'First Meaningful Paint measures when the primary content of a page is ' +
-      'visible. [Learn more about the First Meaningful Paint metric](https://developer.chrome.com/docs/lighthouse/performance/first-meaningful-paint/).',
-};
-
-const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
-
-class FirstMeaningfulPaint extends Audit {
-  /**
-   * @return {LH.Audit.Meta}
-   */
-  static get meta() {
-    return {
-      id: 'first-meaningful-paint',
-      title: str_(i18n.UIStrings.firstMeaningfulPaintMetric),
-      description: str_(UIStrings.description),
-      scoreDisplayMode: Audit.SCORING_MODES.NUMERIC,
-      supportedModes: ['navigation'],
-      requiredArtifacts: ['Trace', 'DevtoolsLog', 'GatherContext', 'URL'],
-    };
-  }
-
-  /**
-   * @return {Promise<LH.Audit.Product>}
-   */
-  static async audit() {
-    return {
-      score: null,
-      notApplicable: true,
-    };
-  }
-}
-
-export default FirstMeaningfulPaint;
-export {UIStrings};

package/core/audits/preload-fonts.d.ts

@@ -1,25 +0,0 @@
-export default PreloadFontsAudit;
-declare class PreloadFontsAudit extends Audit {
-    /**
-     * Finds which font URLs were attempted to be preloaded,
-     * ignoring those that failed to be reused and were requested again.
-     * Note: document.fonts.load() is a valid way to preload fonts,
-     * but we are not currently checking for that.
-     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
-     * @return {Set<string>}
-     */
-    static getURLsAttemptedToPreload(networkRecords: Array<LH.Artifacts.NetworkRequest>): Set<string>;
-    /**
-     * @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=preload-fonts.d.ts.map

package/core/audits/preload-fonts.js

@@ -1,97 +0,0 @@
-/**
- * @license
- * Copyright 2020 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @fileoverview
- * Audit that checks whether fonts that use `font-display: optional` were preloaded.
- */
-
-import {Audit} from './audit.js';
-import * as i18n from './../lib/i18n/i18n.js';
-import FontDisplay from './../audits/font-display.js';
-const PASSING_FONT_DISPLAY_REGEX = /^(optional)$/;
-import {NetworkRecords} from '../computed/network-records.js';
-
-const UIStrings = {
-  /** Title of a Lighthouse audit that provides detail on whether fonts that used `font-display: optional` were preloaded. This descriptive title is shown to users when all fonts that used `font-display: optional` were preloaded. */
-  title: 'Fonts with `font-display: optional` are preloaded',
-  /** Title of a Lighthouse audit that provides detail on whether fonts that used `font-display: optional` were preloaded. This descriptive title is shown to users when one or more fonts used `font-display: optional` and were not preloaded. */
-  failureTitle: 'Fonts with `font-display: optional` are not preloaded',
-  /** Description of a Lighthouse audit that tells the user why they should preload fonts if they are using `font-display: optional`. 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: 'Preload `optional` fonts so first-time visitors may use them. [Learn more about preloading fonts](https://web.dev/articles/preload-optional-fonts)',
-};
-
-const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
-
-class PreloadFontsAudit extends Audit {
-  /**
-   * @return {LH.Audit.Meta}
-   */
-  static get meta() {
-    return {
-      id: 'preload-fonts',
-      title: str_(UIStrings.title),
-      failureTitle: str_(UIStrings.failureTitle),
-      description: str_(UIStrings.description),
-      requiredArtifacts: ['DevtoolsLog', 'URL', 'CSSUsage', 'Stylesheets'],
-    };
-  }
-
-  /**
-   * Finds which font URLs were attempted to be preloaded,
-   * ignoring those that failed to be reused and were requested again.
-   * Note: document.fonts.load() is a valid way to preload fonts,
-   * but we are not currently checking for that.
-   * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
-   * @return {Set<string>}
-   */
-  static getURLsAttemptedToPreload(networkRecords) {
-    const attemptedURLs = networkRecords
-      .filter(req => req.resourceType === 'Font')
-      .filter(req => req.isLinkPreload)
-      .map(req => req.url);
-
-    return new Set(attemptedURLs);
-  }
-
-  /**
-   * @param {LH.Artifacts} artifacts
-   * @param {LH.Audit.Context} context
-   * @return {Promise<LH.Audit.Product>}
-   */
-  static async audit(artifacts, context) {
-    const devtoolsLog = artifacts.DevtoolsLog;
-    const networkRecords = await NetworkRecords.request(devtoolsLog, context);
-
-    // Gets the URLs of fonts where font-display: optional.
-    const optionalFontURLs =
-      FontDisplay.findFontDisplayDeclarations(artifacts, PASSING_FONT_DISPLAY_REGEX).passingURLs;
-
-    // Gets the URLs of fonts attempted to be preloaded.
-    const preloadedFontURLs =
-      PreloadFontsAudit.getURLsAttemptedToPreload(networkRecords);
-
-    const results = Array.from(optionalFontURLs)
-      .filter(url => !preloadedFontURLs.has(url))
-      .map(url => {
-        return {url};
-      });
-
-    /** @type {LH.Audit.Details.Table['headings']} */
-    const headings = [
-      {key: 'url', valueType: 'url', label: str_(i18n.UIStrings.columnURL)},
-    ];
-
-    return {
-      score: results.length > 0 ? 0 : 1,
-      details: Audit.makeTableDetails(headings, results),
-      notApplicable: optionalFontURLs.size === 0,
-    };
-  }
-}
-
-export default PreloadFontsAudit;
-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