lighthouse 9.6.8 → 10.0.0-dev.20230209

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

@@ -0,0 +1,297 @@
+/**
+ * @license Copyright 2017 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+
+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 '../../lib/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.NUMERIC,
+      requiredArtifacts: ['devtoolsLogs'],
+    };
+  }
+
+  /**
+   * @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.devtoolsLogs[Audit.DEFAULT_PASS];
+    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);
+    });
+
+    const score = Audit.computeLogNormalScore(
+      {p10: context.options.p10, median: context.options.median},
+      totalWastedBytes
+    );
+
+    /** @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 summary = {wastedBytes: totalWastedBytes};
+    const details = Audit.makeTableDetails(headings, results, summary);
+
+    return {
+      score,
+      numericValue: totalWastedBytes,
+      numericUnit: 'byte',
+      displayValue: str_(UIStrings.displayValue, {itemCount: results.length}),
+      details,
+    };
+  }
+}
+
+export default CacheHeaders;
+export {UIStrings};

package/core/audits/byte-efficiency/uses-optimized-images.d.ts

@@ -0,0 +1,33 @@
+export default UsesOptimizedImages;
+declare class UsesOptimizedImages extends ByteEfficiencyAudit {
+    /**
+     * @param {{originalSize: number, jpegSize: number}} image
+     * @return {{bytes: number, percent: number}}
+     */
+    static computeSavings(image: {
+        originalSize: number;
+        jpegSize: number;
+    }): {
+        bytes: number;
+        percent: number;
+    };
+    /**
+     * @param {{naturalWidth: number, naturalHeight: number}} imageElement
+     * @return {number}
+     */
+    static estimateJPEGSizeFromDimensions(imageElement: {
+        naturalWidth: number;
+        naturalHeight: number;
+    }): number;
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @return {import('./byte-efficiency-audit.js').ByteEfficiencyProduct}
+     */
+    static audit_(artifacts: LH.Artifacts): import('./byte-efficiency-audit.js').ByteEfficiencyProduct;
+}
+export namespace UIStrings {
+    const title: string;
+    const description: string;
+}
+import { ByteEfficiencyAudit } from "./byte-efficiency-audit.js";
+//# sourceMappingURL=uses-optimized-images.d.ts.map

package/core/audits/byte-efficiency/uses-optimized-images.js

@@ -0,0 +1,145 @@
+/**
+ * @license Copyright 2017 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+/*
+ * @fileoverview This audit determines if the images used are sufficiently larger
+ * than JPEG compressed images without metadata at quality 85.
+ */
+
+
+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 encode images with optimization (better compression). This is displayed in a list of audit titles that Lighthouse generates. */
+  title: 'Efficiently encode images',
+  /** Description of a Lighthouse audit that tells the user *why* they need to efficiently encode images. 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: 'Optimized images load faster and consume less cellular data. ' +
+  '[Learn how to efficiently encode images](https://developer.chrome.com/docs/lighthouse/performance/uses-optimized-images/).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+const IGNORE_THRESHOLD_IN_BYTES = 4096;
+
+class UsesOptimizedImages extends ByteEfficiencyAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'uses-optimized-images',
+      title: str_(UIStrings.title),
+      description: str_(UIStrings.description),
+      scoreDisplayMode: ByteEfficiencyAudit.SCORING_MODES.NUMERIC,
+      requiredArtifacts: ['OptimizedImages', 'ImageElements', 'GatherContext', 'devtoolsLogs',
+        'traces', 'URL'],
+    };
+  }
+
+  /**
+   * @param {{originalSize: number, jpegSize: number}} image
+   * @return {{bytes: number, percent: number}}
+   */
+  static computeSavings(image) {
+    const bytes = image.originalSize - image.jpegSize;
+    const percent = 100 * bytes / image.originalSize;
+    return {bytes, percent};
+  }
+
+  /**
+   * @param {{naturalWidth: number, naturalHeight: number}} imageElement
+   * @return {number}
+   */
+  static estimateJPEGSizeFromDimensions(imageElement) {
+    const totalPixels = imageElement.naturalWidth * imageElement.naturalHeight;
+    // Even JPEGs with lots of detail can usually be compressed down to <1 byte per pixel
+    // Using 4:2:2 subsampling already gets an uncompressed bitmap to 2 bytes per pixel.
+    // The compression ratio for JPEG is usually somewhere around 10:1 depending on content, so
+    // 8:1 is a reasonable expectation for web content which is 1.5MB for a 6MP image.
+    const expectedBytesPerPixel = 2 * 1 / 8;
+    return Math.round(totalPixels * expectedBytesPerPixel);
+  }
+
+  /**
+   * @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<{node?: LH.Audit.Details.NodeValue, url: string, fromProtocol: boolean, isCrossOrigin: boolean, totalBytes: number, wastedBytes: number}>} */
+    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;
+      } else if (/(jpeg|bmp)/.test(image.mimeType) === false) {
+        continue;
+      }
+
+      let jpegSize = image.jpegSize;
+      let fromProtocol = true;
+
+      if (typeof jpegSize === '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 (!naturalHeight || !naturalWidth) continue;
+        jpegSize =
+          UsesOptimizedImages.estimateJPEGSizeFromDimensions({naturalHeight, naturalWidth});
+        fromProtocol = false;
+      }
+
+      if (image.originalSize < jpegSize + IGNORE_THRESHOLD_IN_BYTES) continue;
+
+      const url = UrlUtils.elideDataURI(image.url);
+      const isCrossOrigin = !UrlUtils.originsMatch(pageURL, image.url);
+      const jpegSavings = UsesOptimizedImages.computeSavings({...image, jpegSize});
+
+      items.push({
+        node: imageElement ? ByteEfficiencyAudit.makeNodeItem(imageElement.node) : undefined,
+        url,
+        fromProtocol,
+        isCrossOrigin,
+        totalBytes: image.originalSize,
+        wastedBytes: jpegSavings.bytes,
+      });
+    }
+
+    /** @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 UsesOptimizedImages;
+export {UIStrings};

package/core/audits/byte-efficiency/uses-responsive-images-snapshot.d.ts

@@ -0,0 +1,16 @@
+export default UsesResponsiveImagesSnapshot;
+declare class UsesResponsiveImagesSnapshot extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts): Promise<LH.Audit.Product>;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const columnDisplayedDimensions: string;
+    const columnActualDimensions: string;
+}
+import { Audit } from "../audit.js";
+//# sourceMappingURL=uses-responsive-images-snapshot.d.ts.map

package/core/audits/byte-efficiency/uses-responsive-images-snapshot.js

@@ -0,0 +1,100 @@
+/**
+ * @license Copyright 2021 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+/**
+ * @fileoverview Checks to see if the images used on the page are larger than
+ *   their display sizes. The audit will list all images that are larger than
+ *   their display size with DPR (a 1000px wide image displayed as a
+ *   500px high-res image on a Retina display is 100% used);
+ */
+
+
+import {Audit} from '../audit.js';
+import * as UsesResponsiveImages from './uses-responsive-images.js';
+import UrlUtils from '../../lib/url-utils.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Descriptive title of a Lighthouse audit that checks if images match their displayed dimensions. This is displayed when the audit is passing. */
+  title: 'Images were appropriate for their displayed size',
+  /** Descriptive title of a Lighthouse audit that checks if images match their displayed dimensions. This is displayed when the audit is failing. */
+  failureTitle: 'Images were larger than their displayed size',
+  /** Label for a column in a data table; entries will be the dimensions of an image as it appears on the page. */
+  columnDisplayedDimensions: 'Displayed dimensions',
+  /** Label for a column in a data table; entries will be the dimensions of an image from it's source file. */
+  columnActualDimensions: 'Actual dimensions',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+// Based on byte threshold of 4096, with 3 bytes per pixel.
+const IGNORE_THRESHOLD_IN_PIXELS = 1365;
+
+class UsesResponsiveImagesSnapshot extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'uses-responsive-images-snapshot',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: UsesResponsiveImages.str_(UsesResponsiveImages.UIStrings.description),
+      supportedModes: ['snapshot'],
+      requiredArtifacts: ['ImageElements', 'ViewportDimensions'],
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts) {
+    let score = 1;
+    /** @type {LH.Audit.Details.TableItem[]} */
+    const items = [];
+    for (const image of artifacts.ImageElements) {
+      if (!image.naturalDimensions) continue;
+      const actual = image.naturalDimensions;
+      const displayed = UsesResponsiveImages.default.getDisplayedDimensions(
+        {...image, naturalWidth: actual.width, naturalHeight: actual.height},
+        artifacts.ViewportDimensions
+      );
+
+      const actualPixels = actual.width * actual.height;
+      const usedPixels = displayed.width * displayed.height;
+
+      if (actualPixels <= usedPixels) continue;
+      if (actualPixels - usedPixels > IGNORE_THRESHOLD_IN_PIXELS) score = 0;
+
+      items.push({
+        node: Audit.makeNodeItem(image.node),
+        url: UrlUtils.elideDataURI(image.src),
+        displayedDimensions: `${displayed.width}x${displayed.height}`,
+        actualDimensions: `${actual.width}x${actual.height}`,
+      });
+    }
+
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      /* eslint-disable max-len */
+      {key: 'node', valueType: 'node', label: ''},
+      {key: 'url', valueType: 'url', label: str_(i18n.UIStrings.columnURL)},
+      {key: 'displayedDimensions', valueType: 'text', label: str_(UIStrings.columnDisplayedDimensions)},
+      {key: 'actualDimensions', valueType: 'text', label: str_(UIStrings.columnActualDimensions)},
+      /* eslint-enable max-len */
+    ];
+
+    const details = Audit.makeTableDetails(headings, items);
+
+    return {
+      score,
+      details,
+    };
+  }
+}
+
+export default UsesResponsiveImagesSnapshot;
+export {UIStrings};

package/core/audits/byte-efficiency/uses-responsive-images.d.ts

@@ -0,0 +1,45 @@
+export default UsesResponsiveImages;
+declare class UsesResponsiveImages extends ByteEfficiencyAudit {
+    /**
+     * @param {LH.Artifacts.ImageElement & {naturalWidth: number, naturalHeight: number}} image
+     * @param {LH.Artifacts.ViewportDimensions} ViewportDimensions
+     * @return {{width: number, height: number}};
+     */
+    static getDisplayedDimensions(image: LH.Artifacts.ImageElement & {
+        naturalWidth: number;
+        naturalHeight: number;
+    }, ViewportDimensions: LH.Artifacts.ViewportDimensions): {
+        width: number;
+        height: number;
+    };
+    /**
+     * @param {LH.Artifacts.ImageElement & {naturalWidth: number, naturalHeight: number}} image
+     * @param {LH.Artifacts.ViewportDimensions} ViewportDimensions
+     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+     * @return {null|LH.Audit.ByteEfficiencyItem};
+     */
+    static computeWaste(image: LH.Artifacts.ImageElement & {
+        naturalWidth: number;
+        naturalHeight: number;
+    }, ViewportDimensions: LH.Artifacts.ViewportDimensions, networkRecords: Array<LH.Artifacts.NetworkRequest>): null | LH.Audit.ByteEfficiencyItem;
+    /**
+     * @param {LH.Artifacts.ImageElement} image
+     * @return {number};
+     */
+    static determineAllowableWaste(image: LH.Artifacts.ImageElement): number;
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+     * @param {LH.Audit.Context} context
+     * @return {Promise<import('./byte-efficiency-audit.js').ByteEfficiencyProduct>}
+     */
+    static audit_(artifacts: LH.Artifacts, networkRecords: Array<LH.Artifacts.NetworkRequest>, context: LH.Audit.Context): Promise<import('./byte-efficiency-audit.js').ByteEfficiencyProduct>;
+}
+export namespace UIStrings {
+    const title: string;
+    const description: string;
+}
+export const str_: (message: string, values?: Record<string, string | number> | undefined) => import("../../index.js").IcuMessage;
+import { ByteEfficiencyAudit } from "./byte-efficiency-audit.js";
+import { NetworkRequest } from "../../lib/network-request.js";
+//# sourceMappingURL=uses-responsive-images.d.ts.map