lighthouse 9.6.8 → 10.0.0-dev.20230210

package/core/audits/timing-budget.js

@@ -0,0 +1,174 @@
+/**
+ * @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 {TimingSummary} from '../computed/metrics/timing-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 how quickly the page loads against targets set by the user. Timing budgets are a type of performance budget. */
+  title: 'Timing budget',
+  /** Description of a Lighthouse audit where a user sets budgets for how quickly the page loads. No character length limits. The last sentence starting with 'Learn' becomes link text to additional documentation. */
+  description: 'Set a timing budget to help you keep an eye on the performance of your site. Performant sites load fast and respond to user input events quickly. [Learn more about performance budgets](https://developers.google.com/web/tools/lighthouse/audits/budgets).',
+  /** Label for a column in a data table; entries will be the names of different timing metrics, e.g. "Time to Interactive", "First Contentful Paint", etc. */
+  columnTimingMetric: 'Metric',
+  /** Label for a column in a data table; entries will be the measured value of a particular timing metric. Most entries will have a unit of milliseconds, but units could be other things as well. */
+  columnMeasurement: 'Measurement',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+/** @typedef {{metric: LH.Budget.TimingMetric, label: LH.IcuMessage, measurement?: LH.Audit.Details.NumericValue|number, overBudget?: LH.Audit.Details.NumericValue|number}} BudgetItem */
+
+class TimingBudget extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'timing-budget',
+      title: str_(UIStrings.title),
+      description: str_(UIStrings.description),
+      scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,
+      supportedModes: ['navigation'],
+      requiredArtifacts: ['devtoolsLogs', 'traces', 'URL', 'GatherContext'],
+    };
+  }
+
+  /**
+   * @param {LH.Budget.TimingMetric} timingMetric
+   * @return {LH.IcuMessage}
+   */
+  static getRowLabel(timingMetric) {
+    /** @type {Record<LH.Budget.TimingMetric, string>} */
+    const strMappings = {
+      'first-contentful-paint': i18n.UIStrings.firstContentfulPaintMetric,
+      'interactive': i18n.UIStrings.interactiveMetric,
+      'first-meaningful-paint': i18n.UIStrings.firstMeaningfulPaintMetric,
+      'max-potential-fid': i18n.UIStrings.maxPotentialFIDMetric,
+      'total-blocking-time': i18n.UIStrings.totalBlockingTimeMetric,
+      'speed-index': i18n.UIStrings.speedIndexMetric,
+      'largest-contentful-paint': i18n.UIStrings.largestContentfulPaintMetric,
+      'cumulative-layout-shift': i18n.UIStrings.cumulativeLayoutShiftMetric,
+    };
+    return str_(strMappings[timingMetric]);
+  }
+
+  /**
+   * @param {LH.Budget.TimingMetric} timingMetric
+   * @param {LH.Artifacts.TimingSummary} summary
+   * @return {number|undefined}
+   */
+  static getMeasurement(timingMetric, summary) {
+    /** @type {Record<LH.Budget.TimingMetric, number|undefined>} */
+    const measurements = {
+      'first-contentful-paint': summary.firstContentfulPaint,
+      'interactive': summary.interactive,
+      'first-meaningful-paint': summary.firstMeaningfulPaint,
+      'max-potential-fid': summary.maxPotentialFID,
+      'total-blocking-time': summary.totalBlockingTime,
+      'speed-index': summary.speedIndex,
+      'largest-contentful-paint': summary.largestContentfulPaint,
+      'cumulative-layout-shift': summary.cumulativeLayoutShift,
+    };
+    return measurements[timingMetric];
+  }
+
+  /**
+   * @param {LH.Util.Immutable<LH.Budget>} budget
+   * @param {LH.Artifacts.TimingSummary} summary
+   * @return {Array<BudgetItem>}
+   */
+  static tableItems(budget, summary) {
+    /** @type {Array<BudgetItem>} */
+    let items = [];
+    if (!budget.timings) {
+      return items;
+    }
+
+    items = budget.timings.map((timingBudget) => {
+      const metricName = timingBudget.metric;
+      const label = this.getRowLabel(metricName);
+      const measurement = this.getMeasurement(metricName, summary);
+      const overBudget = measurement && (measurement > timingBudget.budget)
+        ? (measurement - timingBudget.budget) : undefined;
+      return {
+        metric: metricName,
+        label,
+        measurement,
+        overBudget,
+      };
+    }).sort((a, b) => {
+      return (b.overBudget || 0) - (a.overBudget || 0);
+    });
+
+    // CLS requires a different granularity and should be a numeric type.
+    // Defining type here overrides the column setting so that it doesn't receive ms units.
+    const clsItem = items.find(item => item.metric === 'cumulative-layout-shift');
+    if (clsItem) {
+      if (typeof clsItem.measurement === 'number') {
+        clsItem.measurement = {
+          type: 'numeric',
+          value: Number(clsItem.measurement),
+          granularity: 0.01,
+        };
+      }
+      if (typeof clsItem.overBudget === 'number') {
+        clsItem.overBudget = {
+          type: 'numeric',
+          value: Number(clsItem.overBudget),
+          granularity: 0.01,
+        };
+      }
+    }
+
+    return items;
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts, context) {
+    const gatherContext = artifacts.GatherContext;
+    const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
+    const trace = artifacts.traces[Audit.DEFAULT_PASS];
+    const URL = artifacts.URL;
+    const mainResource = await MainResource.request({URL, devtoolsLog}, context);
+    const data = {trace, devtoolsLog, gatherContext, settings: context.settings, URL};
+    const summary = (await TimingSummary.request(data, context)).metrics;
+    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_(UIStrings.columnTimingMetric)},
+      /**
+       * Note: SpeedIndex, unlike other timing metrics, is not measured in milliseconds.
+       * The renderer applies the correct units to the 'measurement' and 'overBudget' columns for SpeedIndex.
+       */
+      {key: 'measurement', valueType: 'ms', label: str_(UIStrings.columnMeasurement)},
+      {key: 'overBudget', valueType: 'ms', label: str_(i18n.UIStrings.columnOverBudget)},
+    ];
+
+    return {
+      details: Audit.makeTableDetails(headers, this.tableItems(budget, summary)),
+      score: 1,
+    };
+  }
+}
+
+export default TimingBudget;
+export {UIStrings};

package/core/audits/unsized-images.d.ts

@@ -0,0 +1,39 @@
+export default UnsizedImages;
+declare class UnsizedImages extends Audit {
+    /**
+     * An img size attribute prevents layout shifts if it is a non-negative integer (incl zero!).
+     * @url https://html.spec.whatwg.org/multipage/embedded-content-other.html#dimension-attributes
+     * @param {string | null} attrValue
+     * @return {boolean}
+     */
+    static doesHtmlAttrProvideExplicitSize(attrValue: string | null): boolean;
+    /**
+     * An img css size property prevents layout shifts if it is defined, not empty, and not equal to 'auto'.
+     * @param {string | null} property
+     * @return {boolean}
+     */
+    static isCssPropExplicitlySet(property: string | null): boolean;
+    /**
+     * Images are considered sized if they have defined & valid values.
+     * @param {LH.Artifacts.ImageElement} image
+     * @return {boolean}
+     */
+    static isSizedImage(image: LH.Artifacts.ImageElement): boolean;
+    /**
+     * @param {LH.Artifacts.ImageElement} image
+     * @return {boolean}
+     */
+    static isNonNetworkSvg(image: LH.Artifacts.ImageElement): boolean;
+    /**
+     * @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 description: string;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=unsized-images.d.ts.map

package/core/audits/unsized-images.js

@@ -0,0 +1,162 @@
+/**
+ * @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 that checks whether all images have explicit width and height.
+ */
+
+
+import {Audit} from './audit.js';
+import * as i18n from './../lib/i18n/i18n.js';
+import UrlUtils from '../lib/url-utils.js';
+
+const UIStrings = {
+  /** Title of a Lighthouse audit that provides detail on whether all images have explicit width and height. This descriptive title is shown to users when every image has explicit width and height */
+  title: 'Image elements have explicit `width` and `height`',
+  /** Title of a Lighthouse audit that provides detail on whether all images have explicit width and height. This descriptive title is shown to users when one or more images does not have explicit width and height */
+  failureTitle: 'Image elements do not have explicit `width` and `height`',
+  /** Description of a Lighthouse audit that tells the user why they should include explicit width and height for all 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: 'Set an explicit width and height on image elements to reduce layout shifts and improve CLS. [Learn how to set image dimensions](https://web.dev/optimize-cls/#images-without-dimensions)',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class UnsizedImages extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'unsized-images',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['ImageElements'],
+    };
+  }
+
+  /**
+   * An img size attribute prevents layout shifts if it is a non-negative integer (incl zero!).
+   * @url https://html.spec.whatwg.org/multipage/embedded-content-other.html#dimension-attributes
+   * @param {string | null} attrValue
+   * @return {boolean}
+   */
+  static doesHtmlAttrProvideExplicitSize(attrValue) {
+    if (!attrValue) return false;
+
+    // First, superweird edge case of using the positive-sign. The spec _sorta_ says it's valid...
+    // https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#rules-for-parsing-integers
+    //   > Otherwise, if the character is … (+): Advance position to the next character.
+    //   > (The "+" is ignored, but it is not conforming.)
+    // lol.  Irrelevant though b/c Chrome (at least) doesn't ignore. It rejects this as a non-conforming value.
+    if (attrValue.startsWith('+')) return false;
+
+    // parseInt isn't exactly the same as the html's spec for parsing integers, but it's close enough
+    // https://tc39.es/ecma262/#sec-parseint-string-radix
+    const int = parseInt(attrValue, 10);
+    return int >= 0;
+  }
+
+  /**
+   * An img css size property prevents layout shifts if it is defined, not empty, and not equal to 'auto'.
+   * @param {string | null} property
+   * @return {boolean}
+   */
+  static isCssPropExplicitlySet(property) {
+    if (!property) return false;
+    return !['auto', 'initial', 'unset', 'inherit'].includes(property);
+  }
+
+  /**
+   * Images are considered sized if they have defined & valid values.
+   * @param {LH.Artifacts.ImageElement} image
+   * @return {boolean}
+   */
+  static isSizedImage(image) {
+    // Perhaps we hit reachedGatheringBudget before collecting this image's cssWidth/Height
+    // in fetchSourceRules. In this case, we don't have enough information to determine if it's sized.
+    // We don't want to show the user a false positive, so we'll call it sized to give it as pass.
+    // While this situation should only befall small-impact images, it means our analysis is incomplete. :(
+    // Handwavey TODO: explore ways to avoid this.
+    if (image.cssEffectiveRules === undefined) return true;
+
+    const attrWidth = image.attributeWidth;
+    const attrHeight = image.attributeHeight;
+    const cssWidth = image.cssEffectiveRules.width;
+    const cssHeight = image.cssEffectiveRules.height;
+    const cssAspectRatio = image.cssEffectiveRules.aspectRatio;
+    const htmlWidthIsExplicit = UnsizedImages.doesHtmlAttrProvideExplicitSize(attrWidth);
+    const cssWidthIsExplicit = UnsizedImages.isCssPropExplicitlySet(cssWidth);
+    const htmlHeightIsExplicit = UnsizedImages.doesHtmlAttrProvideExplicitSize(attrHeight);
+    const cssHeightIsExplicit = UnsizedImages.isCssPropExplicitlySet(cssHeight);
+    const explicitAspectRatio = UnsizedImages.isCssPropExplicitlySet(cssAspectRatio);
+    const explicitWidth = htmlWidthIsExplicit || cssWidthIsExplicit;
+    const explicitHeight = htmlHeightIsExplicit || cssHeightIsExplicit;
+    return (explicitWidth && explicitHeight) ||
+      (explicitWidth && explicitAspectRatio) ||
+      (explicitHeight && explicitAspectRatio);
+  }
+
+  /**
+   * @param {LH.Artifacts.ImageElement} image
+   * @return {boolean}
+   */
+  static isNonNetworkSvg(image) {
+    const isSvg = UrlUtils.guessMimeType(image.src) === 'image/svg+xml';
+    const urlScheme = image.src.slice(0, image.src.indexOf(':'));
+    const isNonNetwork = UrlUtils.isNonNetworkProtocol(urlScheme);
+    return isSvg && isNonNetwork;
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts) {
+    // CSS background-images & ShadowRoot images are ignored for this audit.
+    const images = artifacts.ImageElements.filter(el => !el.isCss && !el.isInShadowDOM);
+    const unsizedImages = [];
+
+    for (const image of images) {
+      // Fixed images are out of document flow and won't cause layout shifts
+      const isFixedImage =
+        image.computedStyles.position === 'fixed' || image.computedStyles.position === 'absolute';
+      if (isFixedImage) continue;
+
+      // Non-network SVGs with dimensions don't cause layout shifts in practice, skip them.
+      // See https://github.com/GoogleChrome/lighthouse/issues/11631
+      if (UnsizedImages.isNonNetworkSvg(image)) continue;
+
+      // The image was sized with HTML or CSS. Good job.
+      if (UnsizedImages.isSizedImage(image)) continue;
+
+      // Images with a 0-size bounding rect (due to hidden parent) aren't part of layout. Cool.
+      const boundingRect = image.node.boundingRect;
+      const isNotDisplayed = boundingRect.width === 0 && boundingRect.height === 0;
+      if (isNotDisplayed) continue;
+
+      unsizedImages.push({
+        url: UrlUtils.elideDataURI(image.src),
+        node: Audit.makeNodeItem(image.node),
+      });
+    }
+
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      {key: 'node', valueType: 'node', label: ''},
+      {key: 'url', valueType: 'url', label: str_(i18n.UIStrings.columnURL)},
+    ];
+
+    return {
+      score: unsizedImages.length > 0 ? 0 : 1,
+      notApplicable: images.length === 0,
+      details: Audit.makeTableDetails(headings, unsizedImages),
+    };
+  }
+}
+
+export default UnsizedImages;
+export {UIStrings};

package/core/audits/user-timings.d.ts

@@ -0,0 +1,43 @@
+export default UserTimings;
+export type MarkEvent = {
+    name: string;
+    isMark: true;
+    args: LH.TraceEvent['args'];
+    startTime: number;
+};
+export type MeasureEvent = {
+    name: string;
+    isMark: false;
+    args: LH.TraceEvent['args'];
+    startTime: number;
+    endTime: number;
+    duration: number;
+};
+/** @typedef {{name: string, isMark: true, args: LH.TraceEvent['args'], startTime: number}} MarkEvent */
+/** @typedef {{name: string, isMark: false, args: LH.TraceEvent['args'], startTime: number, endTime: number, duration: number}} MeasureEvent */
+declare class UserTimings extends Audit {
+    /**
+     * @return {Array<string>}
+     */
+    static get excludedPrefixes(): string[];
+    /**
+     * We remove mark/measures entered by third parties not of interest to the user
+     * @param {MarkEvent|MeasureEvent} evt
+     * @return {boolean}
+     */
+    static excludeEvent(evt: MarkEvent | MeasureEvent): 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 {
+    const title: string;
+    const description: string;
+    const displayValue: string;
+    const columnType: string;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=user-timings.d.ts.map

package/core/audits/user-timings.js

@@ -0,0 +1,118 @@
+/**
+ * @license Copyright 2016 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 {UserTimings as ComputedUserTimings} from '../computed/user-timings.js';
+
+const UIStrings = {
+  /** Descriptive title of a diagnostic audit that provides details on any timestamps generated by the page. User Timing refers to the 'User Timing API', which enables a website to record specific times as 'marks', or spans of time as 'measures'. */
+  title: 'User Timing marks and measures',
+  /** Description of a Lighthouse audit that tells the user they may want to use the User Timing API to help measure the performance of aspects of their page load and interaction. 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: 'Consider instrumenting your app with the User Timing API to measure your ' +
+      'app\'s real-world performance during key user experiences. ' +
+      '[Learn more about User Timing marks](https://developer.chrome.com/docs/lighthouse/performance/user-timings/).',
+  /** [ICU Syntax] Label for an audit identifying the number of User Timing timestamps present in the page. */
+  displayValue: `{itemCount, plural,
+    =1 {1 user timing}
+    other {# user timings}
+    }`,
+  /** Label for the Type column in the User Timing event data table. User Timing API entries are added by the developer of the web page. The only possible types are 'Mark' and Measure'. */
+  columnType: 'Type',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+/** @typedef {{name: string, isMark: true, args: LH.TraceEvent['args'], startTime: number}} MarkEvent */
+/** @typedef {{name: string, isMark: false, args: LH.TraceEvent['args'], startTime: number, endTime: number, duration: number}} MeasureEvent */
+
+class UserTimings extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'user-timings',
+      title: str_(UIStrings.title),
+      description: str_(UIStrings.description),
+      scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,
+      requiredArtifacts: ['traces'],
+    };
+  }
+
+  /**
+   * @return {Array<string>}
+   */
+  static get excludedPrefixes() {
+    return ['goog_'];
+  }
+
+  /**
+   * We remove mark/measures entered by third parties not of interest to the user
+   * @param {MarkEvent|MeasureEvent} evt
+   * @return {boolean}
+   */
+  static excludeEvent(evt) {
+    return UserTimings.excludedPrefixes.every(prefix => !evt.name.startsWith(prefix));
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts, context) {
+    const trace = artifacts.traces[Audit.DEFAULT_PASS];
+    const computedUserTimings = await ComputedUserTimings.request(trace, context);
+    const userTimings = computedUserTimings.filter(UserTimings.excludeEvent);
+    const tableRows = userTimings.map(item => {
+      return {
+        name: item.name,
+        startTime: item.startTime,
+        duration: item.isMark ? undefined : item.duration,
+        timingType: item.isMark ? 'Mark' : 'Measure',
+      };
+    }).sort((itemA, itemB) => {
+      if (itemA.timingType === itemB.timingType) {
+        // If both items are the same type, sort in ascending order by time
+        return itemA.startTime - itemB.startTime;
+      } else if (itemA.timingType === 'Measure') {
+        // Put measures before marks
+        return -1;
+      } else {
+        return 1;
+      }
+    });
+
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      {key: 'name', valueType: 'text', label: str_(i18n.UIStrings.columnName)},
+      {key: 'timingType', valueType: 'text', label: str_(UIStrings.columnType)},
+      {key: 'startTime', valueType: 'ms', granularity: 0.01,
+        label: str_(i18n.UIStrings.columnStartTime)},
+      {key: 'duration', valueType: 'ms', granularity: 0.01,
+        label: str_(i18n.UIStrings.columnDuration)},
+    ];
+
+    const details = Audit.makeTableDetails(headings, tableRows);
+
+    let displayValue;
+    if (userTimings.length) {
+      displayValue = str_(UIStrings.displayValue, {itemCount: userTimings.length});
+    }
+
+    return {
+      // mark the audit as notApplicable if there were no user timings
+      score: Number(userTimings.length === 0),
+      notApplicable: userTimings.length === 0,
+      displayValue,
+      details,
+    };
+  }
+}
+
+export default UserTimings;
+export {UIStrings};

package/core/audits/uses-rel-preconnect.d.ts

@@ -0,0 +1,37 @@
+export default UsesRelPreconnectAudit;
+declare class UsesRelPreconnectAudit extends Audit {
+    /**
+     * Check if record has valid timing
+     * @param {LH.Artifacts.NetworkRequest} record
+     * @return {boolean}
+     */
+    static hasValidTiming(record: LH.Artifacts.NetworkRequest): boolean;
+    /**
+     * Check is the connection is already open
+     * @param {LH.Artifacts.NetworkRequest} record
+     * @return {boolean}
+     */
+    static hasAlreadyConnectedToOrigin(record: LH.Artifacts.NetworkRequest): boolean;
+    /**
+     * Check is the connection has started before the socket idle time
+     * @param {LH.Artifacts.NetworkRequest} record
+     * @param {LH.Artifacts.NetworkRequest} mainResource
+     * @return {boolean}
+     */
+    static socketStartTimeIsBelowThreshold(record: LH.Artifacts.NetworkRequest, mainResource: LH.Artifacts.NetworkRequest): 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 {
+    const title: string;
+    const description: string;
+    const unusedWarning: string;
+    const crossoriginWarning: string;
+    const tooManyPreconnectLinksWarning: string;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=uses-rel-preconnect.d.ts.map