lighthouse 9.6.7 → 10.0.0

package/core/audits/non-composited-animations.js

@@ -0,0 +1,205 @@
+/**
+ * @license Copyright 2020 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 Audit which reports all animations that failed to composite along
+ * with the failure reasons. Failure reasons are only reported if they are actionable.
+ * https://docs.google.com/document/d/1XKcJP2CKmNKfOcDsVvliAQ-e1H9C1nf2H-pzTdyafAA/edit?usp=sharing
+ */
+
+import {Audit} from './audit.js';
+import * as i18n from '../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of a diagnostic LH audit that provides details on animations that are not composited. */
+  title: 'Avoid non-composited animations',
+  /** Description of a diagnostic LH audit that shows the user animations that are not composited. Janky means frames may be skipped and the animation will look bad. Acceptable alternatives here might be 'poor', or 'slow'. */
+  description: 'Animations which are not composited can be janky and increase CLS. ' +
+    '[Learn how to avoid non-composited animations](https://developer.chrome.com/docs/lighthouse/performance/non-composited-animations/)',
+  /** [ICU Syntax] Label identifying the number of animated elements that are not composited. */
+  displayValue: `{itemCount, plural,
+  =1 {# animated element found}
+  other {# animated elements found}
+  }`,
+  /**
+   * @description [ICU Syntax] Descriptive reason for why a user-provided animation failed to be optimized by the browser due to the animated CSS property not being supported on the compositor. Shown in a table with a list of other potential failure reasons.
+   * @example {height, width} properties
+   */
+  unsupportedCSSProperty: `{propertyCount, plural,
+    =1 {Unsupported CSS Property: {properties}}
+    other {Unsupported CSS Properties: {properties}}
+  }`,
+  /** Descriptive reason for why a user-provided animation failed to be optimized by the browser due to a `transform` property being dependent on the size of the element itself. Shown in a table with a list of other potential failure reasons.  */
+  transformDependsBoxSize: 'Transform-related property depends on box size',
+  /** Descriptive reason for why a user-provided animation failed to be optimized by the browser due to a `filter` property possibly moving pixels. Shown in a table with a list of other potential failure reasons.  */
+  filterMayMovePixels: 'Filter-related property may move pixels',
+  /** Descriptive reason for why a user-provided animation failed to be optimized by the browser due to an effect having a composite mode which is not `replace`. Shown in a table with a list of other potential failure reasons.  */
+  nonReplaceCompositeMode: 'Effect has composite mode other than "replace"',
+  /** Descriptive reason for why a user-provided animation failed to be optimized by the browser due to another animation on the same target being incompatible. Shown in a table with a list of other potential failure reasons.  */
+  incompatibleAnimations: 'Target has another animation which is incompatible',
+  /** Descriptive reason for why a user-provided animation failed to be optimized by the browser due to an effect having unsupported timing parameters. Shown in a table with a list of other potential failure reasons.  */
+  unsupportedTimingParameters: 'Effect has unsupported timing parameters',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+/**
+ * Each failure reason is represented by a bit flag. The bit shift operator '<<' is used to define which bit corresponds to each failure reason.
+ * https://source.chromium.org/search?q=f:compositor_animations.h%20%22enum%20FailureReason%22
+ * @type {{flag: number, text: string}[]}
+ */
+const ACTIONABLE_FAILURE_REASONS = [
+  {
+    flag: 1 << 13,
+    text: UIStrings.unsupportedCSSProperty,
+  },
+  {
+    flag: 1 << 11,
+    text: UIStrings.transformDependsBoxSize,
+  },
+  {
+    flag: 1 << 12,
+    text: UIStrings.filterMayMovePixels,
+  },
+  {
+    flag: 1 << 4,
+    text: UIStrings.nonReplaceCompositeMode,
+  },
+  {
+    flag: 1 << 6,
+    text: UIStrings.incompatibleAnimations,
+  },
+  {
+    flag: 1 << 3,
+    text: UIStrings.unsupportedTimingParameters,
+  },
+];
+
+/**
+ * Return list of actionable failure reasons and a boolean if some reasons are not actionable.
+ * Each flag is a number with a single bit set to 1 in the position corresponding to a failure reason.
+ * We can check if a specific bit is true in the failure coding using bitwise and '&' with the flag.
+ * @param {number} failureCode
+ * @param {string[]} unsupportedProperties
+ * @return {LH.IcuMessage[]}
+ */
+function getActionableFailureReasons(failureCode, unsupportedProperties) {
+  return ACTIONABLE_FAILURE_REASONS
+    .filter(reason => failureCode & reason.flag)
+    .map(reason => {
+      if (reason.text === UIStrings.unsupportedCSSProperty) {
+        return str_(reason.text, {
+          propertyCount: unsupportedProperties.length,
+          properties: unsupportedProperties.join(', '),
+        });
+      }
+      return str_(reason.text);
+    });
+}
+
+class NonCompositedAnimations extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'non-composited-animations',
+      scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,
+      title: str_(UIStrings.title),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['TraceElements', 'HostUserAgent'],
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts) {
+    // COMPAT: This audit requires m86
+    const match = artifacts.HostUserAgent.match(/Chrome\/(\d+)/);
+    if (!match || Number(match[1]) < 86) {
+      return {
+        score: 1,
+        notApplicable: true,
+      };
+    }
+
+    /** @type {LH.Audit.Details.TableItem[]} */
+    const results = [];
+    let shouldAddAnimationNameColumn = false;
+    artifacts.TraceElements.forEach(element => {
+      if (element.traceEventType !== 'animation') return;
+
+      const animations = element.animations || [];
+      const animationReasons = new Map();
+      for (const {name, failureReasonsMask, unsupportedProperties} of animations) {
+        if (!failureReasonsMask) continue;
+        const failureReasons =
+          getActionableFailureReasons(failureReasonsMask, unsupportedProperties || []);
+        for (const failureReason of failureReasons) {
+          if (name) {
+            shouldAddAnimationNameColumn = true;
+          }
+          const reasons = animationReasons.get(name) || new Set();
+          reasons.add(failureReason);
+          animationReasons.set(name, reasons);
+        }
+      }
+      if (!animationReasons.size) return;
+
+      const allFailureReasons = [];
+      for (const [name, reasons] of animationReasons) {
+        for (const failureReason of reasons) {
+          allFailureReasons.push({
+            failureReason,
+            animation: name,
+          });
+        }
+      }
+
+      results.push({
+        node: Audit.makeNodeItem(element.node),
+        subItems: {
+          type: 'subitems',
+          items: allFailureReasons,
+        },
+      });
+    });
+
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      /* eslint-disable max-len */
+      {key: 'node', valueType: 'node', subItemsHeading: {key: 'failureReason', valueType: 'text'}, label: str_(i18n.UIStrings.columnElement)},
+      /* eslint-enable max-len */
+    ];
+
+    if (shouldAddAnimationNameColumn) {
+      headings.push(
+        /* eslint-disable max-len */
+        {key: null, valueType: 'text', subItemsHeading: {key: 'animation', valueType: 'text'}, label: str_(i18n.UIStrings.columnName)}
+        /* eslint-enable max-len */
+      );
+    }
+
+    const details = Audit.makeTableDetails(headings, results);
+
+    let displayValue;
+    if (results.length > 0) {
+      displayValue = str_(UIStrings.displayValue, {itemCount: results.length});
+    }
+
+    return {
+      score: results.length === 0 ? 1 : 0,
+      notApplicable: results.length === 0,
+      details,
+      displayValue,
+    };
+  }
+}
+
+export default NonCompositedAnimations;
+export {UIStrings};

package/core/audits/oopif-iframe-test-audit.d.ts

@@ -0,0 +1,14 @@
+declare namespace _default {
+    namespace meta {
+        const id: string;
+        const title: string;
+        const failureTitle: string;
+        const description: string;
+        const requiredArtifacts: string[];
+    }
+    function audit(): {
+        score: number;
+    };
+}
+export default _default;
+//# sourceMappingURL=oopif-iframe-test-audit.d.ts.map

package/core/audits/oopif-iframe-test-audit.js

@@ -0,0 +1,29 @@
+/**
+ * @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 This is a fake audit used exclusively in smoke tests to force inclusion of IFrameElements artifact.
+ * It is included here for complex reasons in the way the bundled smoketests work.
+ *
+ * The smokehouse configs are evaluated first in the node CLI side (which requires an absolute path using LH_ROOT).
+ * The smokehouse configs are then *re-evaluated* in the bundled context for execution by Lighthouse (which *cannot* use an absolute path using LH_ROOT).
+ *
+ * This mismatch in environment demands that the audit path in the config must be context-aware,
+ * yet the require-graph for the config is included before even the CLI knows that it will be using
+ * a bundled runner. Rather than force a massive smoketest architecture change, we include a harmless,
+ * test-only audit in our core list instead.
+ */
+
+export default {
+  meta: {
+    id: 'oopif-iframe-test-audit',
+    title: 'IFrame Elements',
+    failureTitle: 'IFrame Elements',
+    description: 'Audit to force the inclusion of IFrameElements artifact',
+    requiredArtifacts: ['IFrameElements'],
+  },
+  audit: () => ({score: 1}),
+};

package/core/audits/performance-budget.d.ts

@@ -0,0 +1,39 @@
+export default ResourceBudget;
+export type ResourceEntry = import('../computed/resource-summary.js').ResourceEntry;
+export type BudgetItem = {
+    resourceType: LH.Budget.ResourceType;
+    label: LH.IcuMessage;
+    requestCount: number;
+    transferSize: number;
+    sizeOverBudget: number | undefined;
+    countOverBudget: LH.IcuMessage | undefined;
+};
+/** @typedef {import('../computed/resource-summary.js').ResourceEntry} ResourceEntry */
+/** @typedef {{resourceType: LH.Budget.ResourceType, label: LH.IcuMessage, requestCount: number, transferSize: number, sizeOverBudget: number | undefined, countOverBudget: LH.IcuMessage | undefined}} BudgetItem */
+declare class ResourceBudget extends Audit {
+    /**
+     * @param {LH.Budget.ResourceType} resourceType
+     * @return {string}
+     */
+    static getRowLabel(resourceType: LH.Budget.ResourceType): string;
+    /**
+     * @param {LH.Util.Immutable<LH.Budget>} budget
+     * @param {Record<LH.Budget.ResourceType, ResourceEntry>} summary
+     * @return {Array<BudgetItem>}
+     */
+    static tableItems(budget: LH.Util.Immutable<LH.Budget>, summary: Record<LH.Budget.ResourceType, ResourceEntry>): Array<BudgetItem>;
+    /**
+     * @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 {
+    const title: string;
+    const description: string;
+    const requestCountOverBudget: string;
+}
+import { Budget } from "../config/budget.js";
+import { Audit } from "./audit.js";
+//# sourceMappingURL=performance-budget.d.ts.map

package/core/audits/performance-budget.js

@@ -0,0 +1,154 @@
+/**
+ * @license Copyright 2019 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 {Audit} from './audit.js';
+import {ResourceSummary} from '../computed/resource-summary.js';
+import {MainResource} from '../computed/main-resource.js';
+import {Budget} from '../config/budget.js';
+import * as i18n from '../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of a Lighthouse audit that compares the size and quantity of page resources against targets set by the user. These targets are thought of as "performance budgets" because these metrics impact page performance (i.e. how quickly a page loads). */
+  title: 'Performance budget',
+  /** Description of a Lighthouse audit where a user sets budgets for the quantity and size of page resources. No character length limits. The last sentence starting with 'Learn' becomes link text to additional documentation. */
+  description: 'Keep the quantity and size of network requests under the targets ' +
+    'set by the provided performance budget. ' +
+    '[Learn more about performance budgets](https://developers.google.com/web/tools/lighthouse/audits/budgets).',
+  /** [ICU Syntax] Entry in a data table identifying the number of network requests of a particular type. Count will be a whole number. String should be as short as possible to be able to fit well into the table. */
+  requestCountOverBudget: `{count, plural,
+    =1 {1 request}
+    other {# requests}
+   }`,
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+/** @typedef {import('../computed/resource-summary.js').ResourceEntry} ResourceEntry */
+/** @typedef {{resourceType: LH.Budget.ResourceType, label: LH.IcuMessage, requestCount: number, transferSize: number, sizeOverBudget: number | undefined, countOverBudget: LH.IcuMessage | undefined}} BudgetItem */
+
+class ResourceBudget extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'performance-budget',
+      title: str_(UIStrings.title),
+      description: str_(UIStrings.description),
+      scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,
+      supportedModes: ['navigation'],
+      requiredArtifacts: ['devtoolsLogs', 'URL'],
+    };
+  }
+
+  /**
+   * @param {LH.Budget.ResourceType} resourceType
+   * @return {string}
+   */
+  static getRowLabel(resourceType) {
+    /** @type {Record<LH.Budget.ResourceType,string>} */
+    const strMappings = {
+      'total': i18n.UIStrings.totalResourceType,
+      'document': i18n.UIStrings.documentResourceType,
+      'script': i18n.UIStrings.scriptResourceType,
+      'stylesheet': i18n.UIStrings.stylesheetResourceType,
+      'image': i18n.UIStrings.imageResourceType,
+      'media': i18n.UIStrings.mediaResourceType,
+      'font': i18n.UIStrings.fontResourceType,
+      'other': i18n.UIStrings.otherResourceType,
+      'third-party': i18n.UIStrings.thirdPartyResourceType,
+    };
+    return strMappings[resourceType];
+  }
+
+  /**
+   * @param {LH.Util.Immutable<LH.Budget>} budget
+   * @param {Record<LH.Budget.ResourceType, ResourceEntry>} summary
+   * @return {Array<BudgetItem>}
+   */
+  static tableItems(budget, summary) {
+    const resourceTypes = /** @type {Array<LH.Budget.ResourceType>} */ (Object.keys(summary));
+    return resourceTypes.map((resourceType) => {
+      const label = str_(this.getRowLabel(resourceType));
+      const requestCount = summary[resourceType].count;
+      const transferSize = summary[resourceType].transferSize;
+
+      let sizeOverBudget;
+      let countOverBudget;
+
+      if (budget.resourceSizes) {
+        const sizeBudget = budget.resourceSizes.find(b => b.resourceType === resourceType);
+        if (sizeBudget && (transferSize > (sizeBudget.budget * 1024))) {
+          sizeOverBudget = transferSize - (sizeBudget.budget * 1024);
+        }
+      }
+      if (budget.resourceCounts) {
+        const countBudget = budget.resourceCounts.find(b => b.resourceType === resourceType);
+        if (countBudget && (requestCount > countBudget.budget)) {
+          const requestDifference = requestCount - countBudget.budget;
+          countOverBudget = str_(UIStrings.requestCountOverBudget, {count: requestDifference});
+        }
+      }
+      return {
+        resourceType,
+        label,
+        requestCount,
+        transferSize,
+        countOverBudget,
+        sizeOverBudget,
+      };
+    }).filter((row) => {
+      // Only resources with budgets should be included in the table
+      if (budget.resourceSizes) {
+        if (budget.resourceSizes.some(b => b.resourceType === row.resourceType)) return true;
+      }
+      if (budget.resourceCounts) {
+        if (budget.resourceCounts.some(b => b.resourceType === row.resourceType)) return true;
+      }
+      return false;
+    }).sort((a, b) => {
+      return (b.sizeOverBudget || 0) - (a.sizeOverBudget || 0);
+    });
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts, context) {
+    const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
+    const data = {devtoolsLog, URL: artifacts.URL, budgets: context.settings.budgets};
+    const summary = await ResourceSummary.request(data, context);
+    const mainResource = await MainResource.request({URL: artifacts.URL, devtoolsLog}, context);
+    const budget = Budget.getMatchingBudget(context.settings.budgets, mainResource.url);
+
+    if (!budget) {
+      return {
+        score: 0,
+        notApplicable: true,
+      };
+    }
+
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headers = [
+      {key: 'label', valueType: 'text', label: str_(i18n.UIStrings.columnResourceType)},
+      {key: 'requestCount', valueType: 'numeric', label: str_(i18n.UIStrings.columnRequests)},
+      {key: 'transferSize', valueType: 'bytes', label: str_(i18n.UIStrings.columnTransferSize)},
+      {key: 'countOverBudget', valueType: 'text', label: ''},
+      {key: 'sizeOverBudget', valueType: 'bytes', label: str_(i18n.UIStrings.columnOverBudget)},
+    ];
+
+    return {
+      details: Audit.makeTableDetails(headers,
+        this.tableItems(budget, summary)),
+      score: 1,
+    };
+  }
+}
+
+export default ResourceBudget;
+export {UIStrings};

package/core/audits/predictive-perf.d.ts

@@ -0,0 +1,11 @@
+export default PredictivePerf;
+declare class PredictivePerf extends Audit {
+    /**
+     * @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>;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=predictive-perf.d.ts.map

package/core/audits/predictive-perf.js

@@ -0,0 +1,100 @@
+/**
+ * @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 {Audit} from './audit.js';
+import * as i18n from '../lib/i18n/i18n.js';
+import {LanternFirstContentfulPaint} from '../computed/metrics/lantern-first-contentful-paint.js';
+import {LanternFirstMeaningfulPaint} from '../computed/metrics/lantern-first-meaningful-paint.js';
+import {LanternInteractive} from '../computed/metrics/lantern-interactive.js';
+import {LanternSpeedIndex} from '../computed/metrics/lantern-speed-index.js';
+import {LanternLargestContentfulPaint} from '../computed/metrics/lantern-largest-contentful-paint.js';
+
+// Parameters (in ms) for log-normal CDF scoring. To see the curve:
+//   https://www.desmos.com/calculator/bksgkihhj8
+const SCORING_P10 = 3651;
+const SCORING_MEDIAN = 10000;
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, {});
+
+class PredictivePerf extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'predictive-perf',
+      title: 'Predicted Performance (beta)',
+      description:
+        'Predicted performance evaluates how your site will perform under ' +
+        'a cellular connection on a mobile device.',
+      scoreDisplayMode: Audit.SCORING_MODES.NUMERIC,
+      supportedModes: ['navigation'],
+      requiredArtifacts: ['traces', 'devtoolsLogs', 'GatherContext'],
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts, context) {
+    const gatherContext = artifacts.GatherContext;
+    const trace = artifacts.traces[Audit.DEFAULT_PASS];
+    const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
+    const URL = artifacts.URL;
+    /** @type {LH.Config.Settings} */
+    // @ts-expect-error - TODO(bckenny): allow optional `throttling` settings
+    const settings = {}; // Use default settings.
+    const computationData = {trace, devtoolsLog, gatherContext, settings, URL};
+    const fcp = await LanternFirstContentfulPaint.request(computationData, context);
+    const fmp = await LanternFirstMeaningfulPaint.request(computationData, context);
+    const tti = await LanternInteractive.request(computationData, context);
+    const si = await LanternSpeedIndex.request(computationData, context);
+    const lcp = await LanternLargestContentfulPaint.request(computationData, context);
+
+    const values = {
+      roughEstimateOfFCP: fcp.timing,
+      optimisticFCP: fcp.optimisticEstimate.timeInMs,
+      pessimisticFCP: fcp.pessimisticEstimate.timeInMs,
+
+      roughEstimateOfFMP: fmp.timing,
+      optimisticFMP: fmp.optimisticEstimate.timeInMs,
+      pessimisticFMP: fmp.pessimisticEstimate.timeInMs,
+
+      roughEstimateOfTTI: tti.timing,
+      optimisticTTI: tti.optimisticEstimate.timeInMs,
+      pessimisticTTI: tti.pessimisticEstimate.timeInMs,
+
+      roughEstimateOfSI: si.timing,
+      optimisticSI: si.optimisticEstimate.timeInMs,
+      pessimisticSI: si.pessimisticEstimate.timeInMs,
+
+      roughEstimateOfLCP: lcp.timing,
+      optimisticLCP: lcp.optimisticEstimate.timeInMs,
+      pessimisticLCP: lcp.pessimisticEstimate.timeInMs,
+    };
+
+    const score = Audit.computeLogNormalScore(
+      {p10: SCORING_P10, median: SCORING_MEDIAN},
+      values.roughEstimateOfTTI
+    );
+
+    return {
+      score,
+      numericValue: values.roughEstimateOfTTI,
+      numericUnit: 'millisecond',
+      displayValue: str_(i18n.UIStrings.ms, {timeInMs: values.roughEstimateOfTTI}),
+      details: {
+        type: 'debugdata',
+        // TODO: Consider not nesting values under `items`.
+        items: [values],
+      },
+    };
+  }
+}
+
+export default PredictivePerf;

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

@@ -0,0 +1,29 @@
+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>;
+    /**
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(): Promise<LH.Audit.Product>;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=preload-fonts.d.ts.map