lighthouse 12.8.2 → 13.0.0-dev.20251010

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

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

@@ -1,293 +0,0 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import parseCacheControl from 'parse-cache-control';
-
-import {Audit} from '../audit.js';
-import {NetworkRequest} from '../../lib/network-request.js';
-import UrlUtils from '../../lib/url-utils.js';
-import {linearInterpolation} from '../../../shared/statistics.js';
-import * as i18n from '../../lib/i18n/i18n.js';
-import {NetworkRecords} from '../../computed/network-records.js';
-
-const UIStrings = {
-  /** Title of a diagnostic audit that provides detail on the cache policy applies to the page's static assets. Cache refers to browser disk cache, which keeps old versions of network resources around for future use. This is displayed in a list of audit titles that Lighthouse generates. */
-  title: 'Uses efficient cache policy on static assets',
-  /** Title of a diagnostic audit that provides details on the any page resources that could have been served with more efficient cache policies. Cache refers to browser disk cache, which keeps old versions of network resources around for future use. This imperative title is shown to users when there is a significant amount of assets served with poor cache policies. */
-  failureTitle: 'Serve static assets with an efficient cache policy',
-  /** Description of a Lighthouse audit that tells the user *why* they need to adopt a long cache lifetime policy. 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:
-    'A long cache lifetime can speed up repeat visits to your page. ' +
-    '[Learn more about efficient cache policies](https://developer.chrome.com/docs/lighthouse/performance/uses-long-cache-ttl/).',
-  /** [ICU Syntax] Label for the audit identifying network resources with inefficient cache values. Clicking this will expand the audit to show the resources. */
-  displayValue: `{itemCount, plural,
-    =1 {1 resource found}
-    other {# resources found}
-    }`,
-};
-
-const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
-
-// Ignore assets that have very high likelihood of cache hit
-const IGNORE_THRESHOLD_IN_PERCENT = 0.925;
-
-class CacheHeaders extends Audit {
-  /**
-   * @return {LH.Audit.Meta}
-   */
-  static get meta() {
-    return {
-      id: 'uses-long-cache-ttl',
-      title: str_(UIStrings.title),
-      failureTitle: str_(UIStrings.failureTitle),
-      description: str_(UIStrings.description),
-      scoreDisplayMode: Audit.SCORING_MODES.METRIC_SAVINGS,
-      guidanceLevel: 3,
-      requiredArtifacts: ['DevtoolsLog', 'SourceMaps'],
-    };
-  }
-
-  /**
-   * @return {LH.Audit.ScoreOptions}
-   */
-  static get defaultOptions() {
-    return {
-      // 50th and 25th percentiles HTTPArchive -> 50 and 75, with p10 derived from them.
-      // https://bigquery.cloud.google.com/table/httparchive:lighthouse.2018_04_01_mobile?pli=1
-      // see https://www.desmos.com/calculator/uzsyl2hbcb
-      p10: 28 * 1024,
-      median: 128 * 1024,
-    };
-  }
-
-  /**
-   * 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) {
-    // This array contains the hand wavy distribution of the age of a resource in hours at the time of
-    // cache hit at 0th, 10th, 20th, 30th, etc percentiles. This is used to compute `wastedMs` since there
-    // are clearly diminishing returns to cache duration i.e. 6 months is not 2x better than 3 months.
-    // Based on UMA stats for HttpCache.StaleEntry.Validated.Age, see https://www.desmos.com/calculator/7v0qh1nzvh
-    // Example: a max-age of 12 hours already covers ~50% of cases, doubling to 24 hours covers ~10% more.
-    const RESOURCE_AGE_IN_HOURS_DECILES = [0, 0.2, 1, 3, 8, 12, 24, 48, 72, 168, 8760, Infinity];
-    if (RESOURCE_AGE_IN_HOURS_DECILES.length !== 12) {
-      throw new Error('deciles 0-10 and 1 for overflow');
-    }
-
-    const maxAgeInHours = maxAgeInSeconds / 3600;
-    const upperDecileIndex = RESOURCE_AGE_IN_HOURS_DECILES.findIndex(
-      decile => decile >= maxAgeInHours
-    );
-
-    // Clip the likelihood between 0 and 1
-    if (upperDecileIndex === RESOURCE_AGE_IN_HOURS_DECILES.length - 1) return 1;
-    if (upperDecileIndex === 0) return 0;
-
-    // Use the two closest decile points as control points
-    const upperDecileValue = RESOURCE_AGE_IN_HOURS_DECILES[upperDecileIndex];
-    const lowerDecileValue = RESOURCE_AGE_IN_HOURS_DECILES[upperDecileIndex - 1];
-    const upperDecile = upperDecileIndex / 10;
-    const lowerDecile = (upperDecileIndex - 1) / 10;
-
-    // Approximate the real likelihood with linear interpolation
-    return linearInterpolation(
-      lowerDecileValue,
-      lowerDecile,
-      upperDecileValue,
-      upperDecile,
-      maxAgeInHours
-    );
-  }
-
-  /**
-   * 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, cacheControl) {
-    if (cacheControl && cacheControl['max-age'] !== undefined) {
-      return cacheControl['max-age'];
-    }
-
-    const expiresHeaders = headers.get('expires');
-    if (expiresHeaders) {
-      const expires = new Date(expiresHeaders).getTime();
-      // Invalid expires values MUST be treated as already expired
-      if (!expires) return 0;
-      return Math.ceil((expires - Date.now()) / 1000);
-    }
-
-    return 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) {
-    const CACHEABLE_STATUS_CODES = new Set([200, 203, 206]);
-
-    /** @type {Set<LH.Crdp.Network.ResourceType>} */
-    const STATIC_RESOURCE_TYPES = new Set([
-      NetworkRequest.TYPES.Font,
-      NetworkRequest.TYPES.Image,
-      NetworkRequest.TYPES.Media,
-      NetworkRequest.TYPES.Script,
-      NetworkRequest.TYPES.Stylesheet,
-    ]);
-
-    // It's not a request loaded over the network, caching makes no sense
-    if (NetworkRequest.isNonNetworkRequest(record)) return false;
-
-
-    return (
-      CACHEABLE_STATUS_CODES.has(record.statusCode) &&
-      STATIC_RESOURCE_TYPES.has(record.resourceType || 'Other')
-    );
-  }
-
-  /**
-   * 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, cacheControl) {
-    // The HTTP/1.0 Pragma header can disable caching if cache-control is not set, see https://tools.ietf.org/html/rfc7234#section-5.4
-    if (!cacheControl && (headers.get('pragma') || '').includes('no-cache')) {
-      return true;
-    }
-
-    // Ignore assets where policy implies they should not be cached long periods
-    if (cacheControl &&
-      (
-        cacheControl['must-revalidate'] ||
-        cacheControl['no-cache'] ||
-        cacheControl['no-store'] ||
-        cacheControl['stale-while-revalidate'] ||
-        cacheControl['private'])) {
-      return true;
-    }
-
-    return false;
-  }
-
-  /**
-   * @param {LH.Artifacts} artifacts
-   * @param {LH.Audit.Context} context
-   * @return {Promise<LH.Audit.Product>}
-   */
-  static async audit(artifacts, context) {
-    const devtoolsLogs = artifacts.DevtoolsLog;
-    const records = await NetworkRecords.request(devtoolsLogs, context);
-    const results = [];
-    let totalWastedBytes = 0;
-
-    for (const record of records) {
-      if (!CacheHeaders.isCacheableAsset(record)) continue;
-
-      /** @type {Map<string, string>} */
-      const headers = new Map();
-      for (const header of record.responseHeaders || []) {
-        if (headers.has(header.name.toLowerCase())) {
-          const previousHeaderValue = headers.get(header.name.toLowerCase());
-          headers.set(header.name.toLowerCase(),
-            `${previousHeaderValue}, ${header.value}`);
-        } else {
-          headers.set(header.name.toLowerCase(), header.value);
-        }
-      }
-
-      const cacheControl = parseCacheControl(headers.get('cache-control'));
-      if (this.shouldSkipRecord(headers, cacheControl)) {
-        continue;
-      }
-
-      // Ignore if cacheLifetimeInSeconds is a nonpositive number.
-      let cacheLifetimeInSeconds = CacheHeaders.computeCacheLifetimeInSeconds(
-        headers, cacheControl);
-      if (cacheLifetimeInSeconds !== null &&
-        (!Number.isFinite(cacheLifetimeInSeconds) || cacheLifetimeInSeconds <= 0)) {
-        continue;
-      }
-      cacheLifetimeInSeconds = cacheLifetimeInSeconds || 0;
-
-      // Ignore assets whose cache lifetime is already high enough
-      const cacheHitProbability = CacheHeaders.getCacheHitProbability(cacheLifetimeInSeconds);
-      if (cacheHitProbability > IGNORE_THRESHOLD_IN_PERCENT) continue;
-
-      const url = UrlUtils.elideDataURI(record.url);
-      const totalBytes = record.transferSize || 0;
-      const wastedBytes = (1 - cacheHitProbability) * totalBytes;
-
-      totalWastedBytes += wastedBytes;
-
-      // Include cacheControl info (if it exists) per url as a diagnostic.
-      /** @type {LH.Audit.Details.DebugData|undefined} */
-      let debugData;
-      if (cacheControl) {
-        debugData = {
-          type: 'debugdata',
-          ...cacheControl,
-        };
-      }
-
-      results.push({
-        url,
-        debugData,
-        cacheLifetimeMs: cacheLifetimeInSeconds * 1000,
-        cacheHitProbability,
-        totalBytes,
-        wastedBytes,
-      });
-    }
-
-    results.sort((a, b) => {
-      return a.cacheLifetimeMs - b.cacheLifetimeMs ||
-        b.totalBytes - a.totalBytes ||
-        a.url.localeCompare(b.url);
-    });
-
-    /** @type {LH.Audit.Details.Table['headings']} */
-    const headings = [
-      {key: 'url', valueType: 'url', label: str_(i18n.UIStrings.columnURL)},
-      // TODO(i18n): pre-compute localized duration
-      {key: 'cacheLifetimeMs', valueType: 'ms', label: str_(i18n.UIStrings.columnCacheTTL),
-        displayUnit: 'duration'},
-      {key: 'totalBytes', valueType: 'bytes', label: str_(i18n.UIStrings.columnTransferSize),
-        displayUnit: 'kb', granularity: 1},
-    ];
-
-    const details = Audit.makeTableDetails(headings, results,
-      {wastedBytes: totalWastedBytes, sortedBy: ['totalBytes'], skipSumming: ['cacheLifetimeMs']});
-
-    return {
-      score: results.length ? 0 : 1,
-      numericValue: totalWastedBytes,
-      numericUnit: 'byte',
-      displayValue: str_(UIStrings.displayValue, {itemCount: results.length}),
-      details,
-    };
-  }
-}
-
-export default CacheHeaders;
-export {UIStrings};