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

package/core/audits/byte-efficiency/modern-image-formats.js

@@ -1,187 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-/*
- * @fileoverview This audit determines if the images could be smaller when compressed with WebP.
- */
-
-
-import {ByteEfficiencyAudit} from './byte-efficiency-audit.js';
-import UrlUtils from '../../lib/url-utils.js';
-import * as i18n from '../../lib/i18n/i18n.js';
-
-const UIStrings = {
-  /** Imperative title of a Lighthouse audit that tells the user to serve images in newer and more efficient image formats in order to enhance the performance of a page. A non-modern image format was designed 20+ years ago. This is displayed in a list of audit titles that Lighthouse generates. */
-  title: 'Serve images in next-gen formats',
-  /** Description of a Lighthouse audit that tells the user *why* they should use newer and more efficient image formats. 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: 'Image formats like WebP and AVIF often provide better ' +
-    'compression than PNG or JPEG, which means faster downloads and less data consumption. ' +
-    '[Learn more about modern image formats](https://developer.chrome.com/docs/lighthouse/performance/uses-webp-images/).',
-};
-
-const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
-
-const IGNORE_THRESHOLD_IN_BYTES = 8192;
-
-class ModernImageFormats extends ByteEfficiencyAudit {
-  /**
-   * @return {LH.Audit.Meta}
-   */
-  static get meta() {
-    return {
-      id: 'modern-image-formats',
-      title: str_(UIStrings.title),
-      description: str_(UIStrings.description),
-      scoreDisplayMode: ByteEfficiencyAudit.SCORING_MODES.METRIC_SAVINGS,
-      guidanceLevel: 3,
-      requiredArtifacts: ['OptimizedImages', 'DevtoolsLog', 'Trace', 'URL', 'GatherContext',
-        'ImageElements', 'SourceMaps'],
-    };
-  }
-
-  /**
-   * @param {{naturalWidth: number, naturalHeight: number}} imageElement
-   * @return {number}
-   */
-  static estimateWebPSizeFromDimensions(imageElement) {
-    const totalPixels = imageElement.naturalWidth * imageElement.naturalHeight;
-    // See uses-optimized-images for the rationale behind our 2 byte-per-pixel baseline and
-    // JPEG compression ratio of 8:1.
-    // WebP usually gives ~20% additional savings on top of that, so we will use 10:1.
-    // This is quite pessimistic as their study shows a photographic compression ratio of ~29:1.
-    // https://developers.google.com/speed/webp/docs/webp_lossless_alpha_study#results
-    const expectedBytesPerPixel = 2 * 1 / 10;
-    return Math.round(totalPixels * expectedBytesPerPixel);
-  }
-
-  /**
-   * @param {{naturalWidth: number, naturalHeight: number}} imageElement
-   * @return {number}
-   */
-  static estimateAvifSizeFromDimensions(imageElement) {
-    const totalPixels = imageElement.naturalWidth * imageElement.naturalHeight;
-    // See above for the rationale behind our 2 byte-per-pixel baseline and WebP ratio of 10:1.
-    // AVIF usually gives ~20% additional savings on top of that, so we will use 12:1.
-    // This is quite pessimistic as Netflix study shows a photographic compression ratio of ~40:1
-    // (0.4 *bits* per pixel at SSIM 0.97).
-    // https://netflixtechblog.com/avif-for-next-generation-image-coding-b1d75675fe4
-    const expectedBytesPerPixel = 2 * 1 / 12;
-    return Math.round(totalPixels * expectedBytesPerPixel);
-  }
-
-  /**
-   * @param {{jpegSize: number | undefined, webpSize: number | undefined}} otherFormatSizes
-   * @return {number|undefined}
-   */
-  static estimateAvifSizeFromWebPAndJpegEstimates(otherFormatSizes) {
-    if (!otherFormatSizes.jpegSize || !otherFormatSizes.webpSize) return undefined;
-
-    // AVIF saves at least ~50% on JPEG, ~20% on WebP at low quality.
-    // http://downloads.aomedia.org/assets/pdf/symposium-2019/slides/CyrilConcolato_Netflix-AVIF-AOM-Research-Symposium-2019.pdf
-    // https://jakearchibald.com/2020/avif-has-landed/
-    // https://www.finally.agency/blog/what-is-avif-image-format
-    // See https://github.com/GoogleChrome/lighthouse/issues/12295#issue-840261460 for more.
-    const estimateFromJpeg = otherFormatSizes.jpegSize * 5 / 10;
-    const estimateFromWebp = otherFormatSizes.webpSize * 8 / 10;
-    return estimateFromJpeg / 2 + estimateFromWebp / 2;
-  }
-
-  /**
-   * @param {LH.Artifacts} artifacts
-   * @return {import('./byte-efficiency-audit.js').ByteEfficiencyProduct}
-   */
-  static audit_(artifacts) {
-    const pageURL = artifacts.URL.finalDisplayedUrl;
-    const images = artifacts.OptimizedImages;
-    const imageElements = artifacts.ImageElements;
-    /** @type {Map<string, LH.Artifacts.ImageElement>} */
-    const imageElementsByURL = new Map();
-    imageElements.forEach(img => imageElementsByURL.set(img.src, img));
-
-    /** @type {Array<LH.Audit.ByteEfficiencyItem>} */
-    const items = [];
-    const warnings = [];
-    for (const image of images) {
-      const imageElement = imageElementsByURL.get(image.url);
-
-      if (image.failed) {
-        warnings.push(`Unable to decode ${UrlUtils.getURLDisplayName(image.url)}`);
-        continue;
-      }
-
-      // Skip if the image was already using a modern format.
-      if (image.mimeType === 'image/webp' || image.mimeType === 'image/avif') continue;
-
-      const jpegSize = image.jpegSize;
-      let webpSize = image.webpSize;
-      let avifSize = ModernImageFormats.estimateAvifSizeFromWebPAndJpegEstimates({
-        jpegSize,
-        webpSize,
-      });
-      let fromProtocol = true;
-
-      if (typeof webpSize === 'undefined') {
-        if (!imageElement) {
-          warnings.push(`Unable to locate resource ${UrlUtils.getURLDisplayName(image.url)}`);
-          continue;
-        }
-
-        // Skip if we couldn't collect natural image size information.
-        if (!imageElement.naturalDimensions) continue;
-        const naturalHeight = imageElement.naturalDimensions.height;
-        const naturalWidth = imageElement.naturalDimensions.width;
-        // If naturalHeight or naturalWidth are falsy, information is not valid, skip.
-        if (!naturalWidth || !naturalHeight) continue;
-
-        webpSize = ModernImageFormats.estimateWebPSizeFromDimensions({
-          naturalHeight,
-          naturalWidth,
-        });
-        avifSize = ModernImageFormats.estimateAvifSizeFromDimensions({
-          naturalHeight,
-          naturalWidth,
-        });
-        fromProtocol = false;
-      }
-
-      if (webpSize === undefined || avifSize === undefined) continue;
-
-      // Visible wasted bytes uses AVIF, but we still include the WebP savings in the LHR.
-      const wastedWebpBytes = image.originalSize - webpSize;
-      const wastedBytes = image.originalSize - avifSize;
-      if (wastedBytes < IGNORE_THRESHOLD_IN_BYTES) continue;
-
-      const url = UrlUtils.elideDataURI(image.url);
-      const isCrossOrigin = !UrlUtils.originsMatch(pageURL, image.url);
-
-      items.push({
-        node: imageElement ? ByteEfficiencyAudit.makeNodeItem(imageElement.node) : undefined,
-        url,
-        fromProtocol,
-        isCrossOrigin,
-        totalBytes: image.originalSize,
-        wastedBytes,
-        wastedWebpBytes,
-      });
-    }
-
-    /** @type {LH.Audit.Details.Opportunity['headings']} */
-    const headings = [
-      {key: 'node', valueType: 'node', label: ''},
-      {key: 'url', valueType: 'url', label: str_(i18n.UIStrings.columnURL)},
-      {key: 'totalBytes', valueType: 'bytes', label: str_(i18n.UIStrings.columnResourceSize)},
-      {key: 'wastedBytes', valueType: 'bytes', label: str_(i18n.UIStrings.columnWastedBytes)},
-    ];
-
-    return {
-      warnings,
-      items,
-      headings,
-    };
-  }
-}
-
-export default ModernImageFormats;
-export {UIStrings};

package/core/audits/byte-efficiency/render-blocking-resources.d.ts

@@ -1,53 +0,0 @@
-export default RenderBlockingResources;
-declare class RenderBlockingResources extends Audit {
-    /**
-     * @param {LH.Artifacts} artifacts
-     * @param {LH.Audit.Context} context
-     * @return {Promise<{fcpWastedMs: number, lcpWastedMs: number, results: Array<{url: string, totalBytes: number, wastedMs: number}>}>}
-     */
-    static computeResults(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<{
-        fcpWastedMs: number;
-        lcpWastedMs: number;
-        results: Array<{
-            url: string;
-            totalBytes: number;
-            wastedMs: number;
-        }>;
-    }>;
-    /**
-     * Estimates how much faster this page would reach FCP if we inlined all the used CSS from the
-     * render blocking stylesheets and deferred all the scripts. This is more conservative than
-     * removing all the assets and more aggressive than inlining everything.
-     *
-     * *Most* of the time, scripts in the head are there accidentally/due to lack of awareness
-     * rather than necessity, so we're comfortable with this balance. In the worst case, we're telling
-     * devs that they should be able to get to a reasonable first paint without JS, which is not a bad
-     * thing.
-     *
-     * @param {LH.Gatherer.Simulation.Simulator} simulator
-     * @param {LH.Gatherer.Simulation.GraphNode} fcpGraph
-     * @param {Set<string>} deferredIds
-     * @param {Map<string, number>} wastedCssBytesByUrl
-     * @param {LH.Artifacts.DetectedStack[]} Stacks
-     * @return {number}
-     */
-    static estimateSavingsWithGraphs(simulator: LH.Gatherer.Simulation.Simulator, fcpGraph: LH.Gatherer.Simulation.GraphNode, deferredIds: Set<string>, wastedCssBytesByUrl: Map<string, number>, Stacks: LH.Artifacts.DetectedStack[]): number;
-    /**
-     * @param {LH.Artifacts} artifacts
-     * @param {LH.Audit.Context} context
-     * @return {Promise<Map<string, number>>}
-     */
-    static computeWastedCSSBytes(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<Map<string, 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';
-//# sourceMappingURL=render-blocking-resources.d.ts.map

package/core/audits/byte-efficiency/render-blocking-resources.js

@@ -1,312 +0,0 @@
-/**
- * @license
- * Copyright 2018 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @fileoverview Audit a page to see if it does have resources that are blocking first paint
- */
-
-import {Audit} from '../audit.js';
-import * as i18n from '../../lib/i18n/i18n.js';
-import * as Lantern from '../../lib/lantern/lantern.js';
-import {UnusedCSS} from '../../computed/unused-css.js';
-import {NetworkRequest} from '../../lib/network-request.js';
-import {LoadSimulator} from '../../computed/load-simulator.js';
-import {FirstContentfulPaint} from '../../computed/metrics/first-contentful-paint.js';
-import {LCPImageRecord} from '../../computed/lcp-image-record.js';
-import {NavigationInsights} from '../../computed/navigation-insights.js';
-
-// Because of the way we detect blocking stylesheets, asynchronously loaded
-// CSS with link[rel=preload] and an onload handler (see https://github.com/filamentgroup/loadCSS)
-// can be falsely flagged as blocking. Therefore, ignore stylesheets that loaded fast enough
-// to possibly be non-blocking (and they have minimal impact anyway).
-const MINIMUM_WASTED_MS = 50;
-
-const UIStrings = {
-  /** Imperative title of a Lighthouse audit that tells the user to reduce or remove network resources that block the initial render of the page. This is displayed in a list of audit titles that Lighthouse generates. */
-  title: 'Eliminate render-blocking resources',
-  /** Description of a Lighthouse audit that tells the user *why* they should reduce or remove network resources that block the initial render of the page. 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: 'Resources are blocking the first paint of your page. Consider ' +
-    'delivering critical JS/CSS inline and deferring all non-critical ' +
-    'JS/styles. [Learn how to eliminate render-blocking resources](https://developer.chrome.com/docs/lighthouse/performance/render-blocking-resources/).',
-};
-
-const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
-
-/**
- * Given a simulation's nodeTimings, return an object with the nodes/timing keyed by network URL
- * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
- * @return {Map<string, {node: LH.Gatherer.Simulation.GraphNetworkNode, nodeTiming: LH.Gatherer.Simulation.NodeTiming}>}
- */
-function getNodesAndTimingByRequestId(nodeTimings) {
-  /** @type {Map<string, {node: LH.Gatherer.Simulation.GraphNetworkNode, nodeTiming: LH.Gatherer.Simulation.NodeTiming}>} */
-  const requestIdToNode = new Map();
-
-  for (const [node, nodeTiming] of nodeTimings) {
-    if (node.type !== 'network') continue;
-
-    requestIdToNode.set(node.request.requestId, {node, nodeTiming});
-  }
-
-  return requestIdToNode;
-}
-
-/**
- * Adjust the timing of a node and its dependencies to account for stack specific overrides.
- * @param {Map<LH.Gatherer.Simulation.GraphNode, LH.Gatherer.Simulation.NodeTiming>} adjustedNodeTimings
- * @param {LH.Gatherer.Simulation.GraphNode} node
- * @param {LH.Artifacts.DetectedStack[]} Stacks
- */
-function adjustNodeTimings(adjustedNodeTimings, node, Stacks) {
-  const nodeTiming = adjustedNodeTimings.get(node);
-  if (!nodeTiming) return;
-  const stackSpecificTiming = computeStackSpecificTiming(node, nodeTiming, Stacks);
-  const difference = nodeTiming.duration - stackSpecificTiming.duration;
-  if (!difference) return;
-
-  // AMP's method of removal of stylesheets effectively removes all dependent nodes from the FCP graph
-  node.traverse(childNode => {
-    adjustedNodeTimings.delete(childNode);
-  });
-  adjustedNodeTimings.set(node, stackSpecificTiming);
-}
-
-/**
- * Any stack specific timing overrides should go in this function.
- * @see https://github.com/GoogleChrome/lighthouse/issues/2832#issuecomment-591066081
- *
- * @param {LH.Gatherer.Simulation.GraphNode} node
- * @param {LH.Gatherer.Simulation.NodeTiming} nodeTiming
- * @param {LH.Artifacts.DetectedStack[]} Stacks
- */
-function computeStackSpecificTiming(node, nodeTiming, Stacks) {
-  const stackSpecificTiming = {...nodeTiming};
-  if (Stacks.some(stack => stack.id === 'amp')) {
-    // AMP will load a linked stylesheet asynchronously if it has not been loaded after 2.1 seconds:
-    // https://github.com/ampproject/amphtml/blob/8e03ac2f315774070651584a7e046ff24212c9b1/src/font-stylesheet-timeout.js#L54-L59
-    // Any potential savings must only include time spent on AMP stylesheet nodes before 2.1 seconds.
-    if (node.type === Lantern.Graph.BaseNode.types.NETWORK &&
-        node.request.resourceType === NetworkRequest.TYPES.Stylesheet &&
-        nodeTiming.endTime > 2100) {
-      stackSpecificTiming.endTime = Math.max(nodeTiming.startTime, 2100);
-      stackSpecificTiming.duration = stackSpecificTiming.endTime - stackSpecificTiming.startTime;
-    }
-  }
-  return stackSpecificTiming;
-}
-
-class RenderBlockingResources extends Audit {
-  /**
-   * @return {LH.Audit.Meta}
-   */
-  static get meta() {
-    return {
-      id: 'render-blocking-resources',
-      title: str_(UIStrings.title),
-      supportedModes: ['navigation'],
-      scoreDisplayMode: Audit.SCORING_MODES.METRIC_SAVINGS,
-      description: str_(UIStrings.description),
-      guidanceLevel: 2,
-      // TODO: look into adding an `optionalArtifacts` property that captures the non-required nature
-      // of CSSUsage
-      requiredArtifacts:
-        // eslint-disable-next-line max-len
-        ['URL', 'Trace', 'DevtoolsLog', 'Stylesheets', 'CSSUsage', 'GatherContext', 'Stacks', 'SourceMaps'],
-    };
-  }
-
-  /**
-   * @param {LH.Artifacts} artifacts
-   * @param {LH.Audit.Context} context
-   * @return {Promise<{fcpWastedMs: number, lcpWastedMs: number, results: Array<{url: string, totalBytes: number, wastedMs: number}>}>}
-   */
-  static async computeResults(artifacts, context) {
-    const settings = context.settings;
-    const gatherContext = artifacts.GatherContext;
-    const trace = artifacts.Trace;
-    const devtoolsLog = artifacts.DevtoolsLog;
-    const SourceMaps = artifacts.SourceMaps;
-    const simulatorData = {devtoolsLog, settings: context.settings};
-    const simulator = await LoadSimulator.request(simulatorData, context);
-    const wastedCssBytes = await RenderBlockingResources.computeWastedCSSBytes(artifacts, context);
-    const navInsights = await NavigationInsights.request({trace, settings, SourceMaps}, context);
-
-    const renderBlocking = navInsights.model.RenderBlocking;
-    if (renderBlocking instanceof Error) throw renderBlocking;
-
-    /** @type {LH.Audit.Context['settings']} */
-    const metricSettings = {
-      ...context.settings,
-      throttlingMethod: 'simulate',
-    };
-
-    const metricComputationData = {trace, devtoolsLog, gatherContext, simulator,
-      settings: metricSettings, URL: artifacts.URL, SourceMaps: artifacts.SourceMaps};
-
-    // Cast to just `LanternMetric` since we explicitly set `throttlingMethod: 'simulate'`.
-    const fcpSimulation = /** @type {LH.Artifacts.LanternMetric} */
-      (await FirstContentfulPaint.request(metricComputationData, context));
-
-    const nodesAndTimingsByRequestId =
-      getNodesAndTimingByRequestId(fcpSimulation.optimisticEstimate.nodeTimings);
-
-    const results = [];
-    const deferredNodeIds = new Set();
-    for (const resource of renderBlocking.renderBlockingRequests) {
-      const nodeAndTiming = nodesAndTimingsByRequestId.get(resource.args.data.requestId);
-      // TODO: beacon to Sentry, https://github.com/GoogleChrome/lighthouse/issues/7041
-      if (!nodeAndTiming) continue;
-
-      const {node, nodeTiming} = nodeAndTiming;
-
-      const stackSpecificTiming = computeStackSpecificTiming(node, nodeTiming, artifacts.Stacks);
-
-      // Mark this node and all its dependents as deferrable
-      node.traverse(node => deferredNodeIds.add(node.id));
-
-      // "wastedMs" is the download time of the network request, responseReceived - requestSent
-      const wastedMs = Math.round(stackSpecificTiming.duration);
-      if (wastedMs < MINIMUM_WASTED_MS) continue;
-
-      results.push({
-        url: resource.args.data.url,
-        totalBytes: node.request.transferSize,
-        wastedMs,
-      });
-    }
-
-    if (!results.length) {
-      return {results, fcpWastedMs: 0, lcpWastedMs: 0};
-    }
-
-    const fcpWastedMs = RenderBlockingResources.estimateSavingsWithGraphs(
-      simulator,
-      fcpSimulation.optimisticGraph,
-      deferredNodeIds,
-      wastedCssBytes,
-      artifacts.Stacks
-    );
-
-    const lcpRecord = await LCPImageRecord.request(metricComputationData, context);
-
-    // In most cases if the LCP is an image, render blocking resources don't affect LCP. For these cases we should reduce its impact.
-    return {results, fcpWastedMs, lcpWastedMs: lcpRecord ? 0 : fcpWastedMs};
-  }
-
-  /**
-   * Estimates how much faster this page would reach FCP if we inlined all the used CSS from the
-   * render blocking stylesheets and deferred all the scripts. This is more conservative than
-   * removing all the assets and more aggressive than inlining everything.
-   *
-   * *Most* of the time, scripts in the head are there accidentally/due to lack of awareness
-   * rather than necessity, so we're comfortable with this balance. In the worst case, we're telling
-   * devs that they should be able to get to a reasonable first paint without JS, which is not a bad
-   * thing.
-   *
-   * @param {LH.Gatherer.Simulation.Simulator} simulator
-   * @param {LH.Gatherer.Simulation.GraphNode} fcpGraph
-   * @param {Set<string>} deferredIds
-   * @param {Map<string, number>} wastedCssBytesByUrl
-   * @param {LH.Artifacts.DetectedStack[]} Stacks
-   * @return {number}
-   */
-  static estimateSavingsWithGraphs(simulator, fcpGraph, deferredIds, wastedCssBytesByUrl, Stacks) {
-    const {nodeTimings} = simulator.simulate(fcpGraph);
-    const adjustedNodeTimings = new Map(nodeTimings);
-
-    let totalChildNetworkBytes = 0;
-    const minimalFCPGraph = fcpGraph.cloneWithRelationships(node => {
-      adjustNodeTimings(adjustedNodeTimings, node, Stacks);
-
-      // If a node can be deferred, exclude it from the new FCP graph
-      const canDeferRequest = deferredIds.has(node.id);
-      if (node.type !== Lantern.Graph.BaseNode.types.NETWORK) return !canDeferRequest;
-
-      const isStylesheet =
-        node.request.resourceType === NetworkRequest.TYPES.Stylesheet;
-      if (canDeferRequest && isStylesheet) {
-        // We'll inline the used bytes of the stylesheet and assume the rest can be deferred
-        const wastedBytes = wastedCssBytesByUrl.get(node.request.url) || 0;
-        totalChildNetworkBytes += (node.request.transferSize || 0) - wastedBytes;
-      }
-      return !canDeferRequest;
-    });
-
-    if (minimalFCPGraph.type !== 'network') {
-      throw new Error('minimalFCPGraph not a NetworkNode');
-    }
-
-    // Recalculate the "before" time based on our adjusted node timings.
-    const estimateBeforeInline = Math.max(...Array.from(
-      Array.from(adjustedNodeTimings).map(timing => timing[1].endTime)
-    ));
-
-    // Add the inlined bytes to the HTML response
-    const originalTransferSize = minimalFCPGraph.request.transferSize;
-    const safeTransferSize = originalTransferSize || 0;
-    minimalFCPGraph.request.transferSize = safeTransferSize + totalChildNetworkBytes;
-    const estimateAfterInline = simulator.simulate(minimalFCPGraph).timeInMs;
-    minimalFCPGraph.request.transferSize = originalTransferSize;
-    return Math.round(Math.max(estimateBeforeInline - estimateAfterInline, 0));
-  }
-
-  /**
-   * @param {LH.Artifacts} artifacts
-   * @param {LH.Audit.Context} context
-   * @return {Promise<Map<string, number>>}
-   */
-  static async computeWastedCSSBytes(artifacts, context) {
-    const wastedBytesByUrl = new Map();
-    try {
-      const unusedCssItems = await UnusedCSS.request({
-        Stylesheets: artifacts.Stylesheets,
-        CSSUsage: artifacts.CSSUsage,
-        devtoolsLog: artifacts.DevtoolsLog,
-      }, context);
-      for (const item of unusedCssItems) {
-        wastedBytesByUrl.set(item.url, item.wastedBytes);
-      }
-    } catch {}
-
-    return wastedBytesByUrl;
-  }
-
-  /**
-   * @param {LH.Artifacts} artifacts
-   * @param {LH.Audit.Context} context
-   * @return {Promise<LH.Audit.Product>}
-   */
-  static async audit(artifacts, context) {
-    const {results, fcpWastedMs, lcpWastedMs} =
-      await RenderBlockingResources.computeResults(artifacts, context);
-
-    let displayValue;
-    if (results.length > 0) {
-      displayValue = str_(i18n.UIStrings.displayValueMsSavings, {wastedMs: fcpWastedMs});
-    }
-
-    /** @type {LH.Audit.Details.Opportunity['headings']} */
-    const headings = [
-      {key: 'url', valueType: 'url', label: str_(i18n.UIStrings.columnURL)},
-      {key: 'totalBytes', valueType: 'bytes', label: str_(i18n.UIStrings.columnTransferSize)},
-      {key: 'wastedMs', valueType: 'timespanMs', label: str_(i18n.UIStrings.columnDuration)},
-    ];
-
-    const details = Audit.makeOpportunityDetails(headings, results,
-      {overallSavingsMs: fcpWastedMs});
-
-    return {
-      displayValue,
-      score: results.length ? 0 : 1,
-      numericValue: fcpWastedMs,
-      numericUnit: 'millisecond',
-      details,
-      metricSavings: {FCP: fcpWastedMs, LCP: lcpWastedMs},
-    };
-  }
-}
-
-export default RenderBlockingResources;
-export {UIStrings};

package/core/audits/byte-efficiency/uses-long-cache-ttl.d.ts

@@ -1,59 +0,0 @@
-export default CacheHeaders;
-declare class CacheHeaders extends Audit {
-    /**
-     * @return {LH.Audit.ScoreOptions}
-     */
-    static get defaultOptions(): LH.Audit.ScoreOptions;
-    /**
-     * Computes the percent likelihood that a return visit will be within the cache lifetime, based on
-     * Chrome UMA stats see the note below.
-     * @param {number} maxAgeInSeconds
-     * @return {number}
-     */
-    static getCacheHitProbability(maxAgeInSeconds: number): number;
-    /**
-     * Return max-age if defined, otherwise expires header if defined, and null if not.
-     * @param {Map<string, string>} headers
-     * @param {ReturnType<typeof parseCacheControl>} cacheControl
-     * @return {?number}
-     */
-    static computeCacheLifetimeInSeconds(headers: Map<string, string>, cacheControl: ReturnType<typeof parseCacheControl>): number | null;
-    /**
-     * Given a network record, returns whether we believe the asset is cacheable, i.e. it was a network
-     * request that satisifed the conditions:
-     *
-     *  1. Has a cacheable status code
-     *  2. Has a resource type that corresponds to static assets (image, script, stylesheet, etc).
-     *
-     * Allowing assets with a query string is debatable, PSI considered them non-cacheable with a similar
-     * caveat.
-     *
-     * TODO: Investigate impact in HTTPArchive, experiment with this policy to see what changes.
-     *
-     * @param {LH.Artifacts.NetworkRequest} record
-     * @return {boolean}
-     */
-    static isCacheableAsset(record: LH.Artifacts.NetworkRequest): boolean;
-    /**
-     * Returns true if headers suggest a record should not be cached for a long time.
-     * @param {Map<string, string>} headers
-     * @param {ReturnType<typeof parseCacheControl>} cacheControl
-     * @return {boolean}
-     */
-    static shouldSkipRecord(headers: Map<string, string>, cacheControl: ReturnType<typeof parseCacheControl>): 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;
-    let displayValue: string;
-}
-import { Audit } from '../audit.js';
-import parseCacheControl from 'parse-cache-control';
-//# sourceMappingURL=uses-long-cache-ttl.d.ts.map