lighthouse 11.7.1 → 12.0.0

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

@@ -14,10 +14,10 @@ import * as i18n from '../../lib/i18n/i18n.js';
 import {BaseNode} from '../../lib/lantern/base-node.js';
 import {UnusedCSS} from '../../computed/unused-css.js';
 import {NetworkRequest} from '../../lib/network-request.js';
-import {ProcessedNavigation} from '../../computed/processed-navigation.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';
 
 
 /** @typedef {import('../../lib/lantern/simulator/simulator.js').Simulator} Simulator */
@@ -44,21 +44,19 @@ 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 {Object<string, {node: Node, nodeTiming: LH.Gatherer.Simulation.NodeTiming}>}
+ * @return {Map<string, {node: Node, nodeTiming: LH.Gatherer.Simulation.NodeTiming}>}
  */
-function getNodesAndTimingByUrl(nodeTimings) {
-  /** @type {Object<string, {node: Node, nodeTiming: LH.Gatherer.Simulation.NodeTiming}>} */
-  const urlMap = {};
-  const nodes = Array.from(nodeTimings.keys());
-  nodes.forEach(node => {
-    if (node.type !== 'network') return;
-    const nodeTiming = nodeTimings.get(node);
-    if (!nodeTiming) return;
-
-    urlMap[node.record.url] = {node, nodeTiming};
-  });
+function getNodesAndTimingByRequestId(nodeTimings) {
+  /** @type {Map<string, {node: Node, nodeTiming: LH.Gatherer.Simulation.NodeTiming}>} */
+  const requestIdToNode = new Map();
+
+  for (const [node, nodeTiming] of nodeTimings) {
+    if (node.type !== 'network') continue;
 
-  return urlMap;
+    requestIdToNode.set(node.record.requestId, {node, nodeTiming});
+  }
+
+  return requestIdToNode;
 }
 
 /**
@@ -119,8 +117,8 @@ class RenderBlockingResources extends Audit {
       guidanceLevel: 2,
       // TODO: look into adding an `optionalArtifacts` property that captures the non-required nature
       // of CSSUsage
-      requiredArtifacts: ['URL', 'TagsBlockingFirstPaint', 'traces', 'devtoolsLogs', 'CSSUsage',
-        'GatherContext', 'Stacks'],
+      requiredArtifacts:
+        ['URL', 'traces', 'devtoolsLogs', 'Stylesheets', 'CSSUsage', 'GatherContext', 'Stacks'],
     };
   }
 
@@ -134,9 +132,12 @@ class RenderBlockingResources extends Audit {
     const trace = artifacts.traces[Audit.DEFAULT_PASS];
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
     const simulatorData = {devtoolsLog, settings: context.settings};
-    const processedNavigation = await ProcessedNavigation.request(trace, context);
     const simulator = await LoadSimulator.request(simulatorData, context);
     const wastedCssBytes = await RenderBlockingResources.computeWastedCSSBytes(artifacts, context);
+    const navInsights = await NavigationInsights.request(trace, context);
+
+    const renderBlocking = navInsights.RenderBlocking;
+    if (renderBlocking instanceof Error) throw renderBlocking;
 
     /** @type {LH.Audit.Context['settings']} */
     const metricSettings = {
@@ -150,19 +151,18 @@ class RenderBlockingResources extends Audit {
     // Cast to just `LanternMetric` since we explicitly set `throttlingMethod: 'simulate'`.
     const fcpSimulation = /** @type {LH.Artifacts.LanternMetric} */
       (await FirstContentfulPaint.request(metricComputationData, context));
-    const fcpTsInMs = processedNavigation.timestamps.firstContentfulPaint / 1000;
 
-    const nodesByUrl = getNodesAndTimingByUrl(fcpSimulation.optimisticEstimate.nodeTimings);
+    const nodesAndTimingsByRequestId =
+      getNodesAndTimingByRequestId(fcpSimulation.optimisticEstimate.nodeTimings);
 
     const results = [];
     const deferredNodeIds = new Set();
-    for (const resource of artifacts.TagsBlockingFirstPaint) {
-      // Ignore any resources that finished after observed FCP (they're clearly not render-blocking)
-      if (resource.endTime > fcpTsInMs) continue;
+    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 (!nodesByUrl[resource.tag.url]) continue;
+      if (!nodeAndTiming) continue;
 
-      const {node, nodeTiming} = nodesByUrl[resource.tag.url];
+      const {node, nodeTiming} = nodeAndTiming;
 
       const stackSpecificTiming = computeStackSpecificTiming(node, nodeTiming, artifacts.Stacks);
 
@@ -174,8 +174,8 @@ class RenderBlockingResources extends Audit {
       if (wastedMs < MINIMUM_WASTED_MS) continue;
 
       results.push({
-        url: resource.tag.url,
-        totalBytes: resource.transferSize,
+        url: resource.args.data.url,
+        totalBytes: resource.args.data.encodedDataLength,
         wastedMs,
       });
     }
@@ -264,6 +264,7 @@ class RenderBlockingResources extends Audit {
     const wastedBytesByUrl = new Map();
     try {
       const unusedCssItems = await UnusedCSS.request({
+        Stylesheets: artifacts.Stylesheets,
         CSSUsage: artifacts.CSSUsage,
         devtoolsLog: artifacts.devtoolsLogs[Audit.DEFAULT_PASS],
       }, context);

package/core/audits/byte-efficiency/unminified-css.js

@@ -37,7 +37,7 @@ class UnminifiedCSS extends ByteEfficiencyAudit {
       description: str_(UIStrings.description),
       scoreDisplayMode: ByteEfficiencyAudit.SCORING_MODES.METRIC_SAVINGS,
       guidanceLevel: 3,
-      requiredArtifacts: ['CSSUsage', 'devtoolsLogs', 'traces', 'URL', 'GatherContext'],
+      requiredArtifacts: ['Stylesheets', 'devtoolsLogs', 'traces', 'URL', 'GatherContext'],
     };
   }
 
@@ -85,7 +85,7 @@ class UnminifiedCSS extends ByteEfficiencyAudit {
    */
   static audit_(artifacts, networkRecords) {
     const items = [];
-    for (const stylesheet of artifacts.CSSUsage.stylesheets) {
+    for (const stylesheet of artifacts.Stylesheets) {
       const networkRecord = networkRecords
         .find(record => record.url === stylesheet.header.sourceURL);
       if (!stylesheet.content) continue;

package/core/audits/byte-efficiency/unused-css-rules.js

@@ -34,7 +34,8 @@ class UnusedCSSRules extends ByteEfficiencyAudit {
       description: str_(UIStrings.description),
       scoreDisplayMode: ByteEfficiencyAudit.SCORING_MODES.METRIC_SAVINGS,
       guidanceLevel: 1,
-      requiredArtifacts: ['CSSUsage', 'URL', 'devtoolsLogs', 'traces', 'GatherContext'],
+      requiredArtifacts:
+        ['Stylesheets', 'CSSUsage', 'URL', 'devtoolsLogs', 'traces', 'GatherContext'],
     };
   }
 
@@ -46,6 +47,7 @@ class UnusedCSSRules extends ByteEfficiencyAudit {
    */
   static async audit_(artifacts, _, context) {
     const unusedCssItems = await UnusedCSS.request({
+      Stylesheets: artifacts.Stylesheets,
       CSSUsage: artifacts.CSSUsage,
       devtoolsLog: artifacts.devtoolsLogs[ByteEfficiencyAudit.DEFAULT_PASS],
     }, context);

package/core/audits/dobetterweb/uses-http2.d.ts

@@ -20,19 +20,6 @@ declare class UsesHTTP2Audit extends Audit {
         simulationBefore: LH.Gatherer.Simulation.Result;
         simulationAfter: LH.Gatherer.Simulation.Result;
     };
-    /**
-     * Computes the estimated effect all results being converted to use http/2, the max of:
-     *
-     * - end time of the last long task in the provided graph
-     * - end time of the last node in the graph
-     * @param {Array<{url: string}>} results
-     * @param {Node} graph
-     * @param {Simulator} simulator
-     * @return {number}
-     */
-    static computeWasteWithTTIGraph(results: Array<{
-        url: string;
-    }>, graph: Node, simulator: Simulator): number;
     /**
      * Determines whether a network request is a "static resource" that would benefit from H2 multiplexing.
      * XHRs, tracking pixels, etc generally don't benefit as much because they aren't requested en-masse

package/core/audits/dobetterweb/uses-http2.js

@@ -15,11 +15,9 @@
 import {Audit} from '../audit.js';
 import {EntityClassification} from '../../computed/entity-classification.js';
 import UrlUtils from '../../lib/url-utils.js';
-import {LanternInteractive} from '../../computed/metrics/lantern-interactive.js';
 import {NetworkRequest} from '../../lib/network-request.js';
 import {NetworkRecords} from '../../computed/network-records.js';
 import {LoadSimulator} from '../../computed/load-simulator.js';
-import {PageDependencyGraph} from '../../computed/page-dependency-graph.js';
 import {LanternLargestContentfulPaint} from '../../computed/metrics/lantern-largest-contentful-paint.js';
 import {LanternFirstContentfulPaint} from '../../computed/metrics/lantern-first-contentful-paint.js';
 import * as i18n from '../../lib/i18n/i18n.js';
@@ -80,11 +78,9 @@ class UsesHTTP2Audit extends Audit {
     options = Object.assign({label: ''}, options);
     const beforeLabel = `${this.meta.id}-${options.label}-before`;
     const afterLabel = `${this.meta.id}-${options.label}-after`;
-    const flexibleOrdering = true;
 
     const urlsToChange = new Set(results.map(result => result.url));
-    const simulationBefore =
-      simulator.simulate(graph, {label: beforeLabel, flexibleOrdering});
+    const simulationBefore = simulator.simulate(graph, {label: beforeLabel});
 
     // Update all the protocols to reflect implementing our recommendations
     /** @type {Map<string, string>} */
@@ -97,7 +93,7 @@ class UsesHTTP2Audit extends Audit {
       node.request.protocol = 'h2';
     });
 
-    const simulationAfter = simulator.simulate(graph, {label: afterLabel, flexibleOrdering});
+    const simulationAfter = simulator.simulate(graph, {label: afterLabel});
 
     // Restore the original protocol after we've done our simulation
     graph.traverse(node => {
@@ -117,32 +113,6 @@ class UsesHTTP2Audit extends Audit {
     };
   }
 
-  /**
-   * Computes the estimated effect all results being converted to use http/2, the max of:
-   *
-   * - end time of the last long task in the provided graph
-   * - end time of the last node in the graph
-   * @param {Array<{url: string}>} results
-   * @param {Node} graph
-   * @param {Simulator} simulator
-   * @return {number}
-   */
-  static computeWasteWithTTIGraph(results, graph, simulator) {
-    const {savings: savingsOnOverallLoad, simulationBefore, simulationAfter} =
-      this.computeWasteWithGraph(results, graph, simulator, {
-        label: 'tti',
-      });
-
-    const savingsOnTTI =
-      LanternInteractive.getLastLongTaskEndTime(simulationBefore.nodeTimings) -
-      LanternInteractive.getLastLongTaskEndTime(simulationAfter.nodeTimings);
-
-    const savings = Math.max(savingsOnTTI, savingsOnOverallLoad);
-
-    // Round waste to nearest 10ms
-    return Math.round(Math.max(savings, 0) / 10) * 10;
-  }
-
   /**
    * Determines whether a network request is a "static resource" that would benefit from H2 multiplexing.
    * XHRs, tracking pixels, etc generally don't benefit as much because they aren't requested en-masse
@@ -235,7 +205,6 @@ class UsesHTTP2Audit extends Audit {
    * @return {Promise<LH.Audit.Product>}
    */
   static async audit(artifacts, context) {
-    const trace = artifacts.traces[Audit.DEFAULT_PASS];
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
     const URL = artifacts.URL;
     const networkRecords = await NetworkRecords.request(devtoolsLog, context);
@@ -269,7 +238,6 @@ class UsesHTTP2Audit extends Audit {
       devtoolsLog,
       settings,
     };
-    const pageGraph = await PageDependencyGraph.request({trace, devtoolsLog, URL}, context);
     const simulator = await LoadSimulator.request(simulatorOptions, context);
     const metricComputationInput = Audit.makeMetricComputationDataInput(artifacts, context);
 
@@ -280,8 +248,6 @@ class UsesHTTP2Audit extends Audit {
       pessimisticGraph: lcpGraph,
     } = await LanternLargestContentfulPaint.request(metricComputationInput, context);
 
-    const wastedMsTti = UsesHTTP2Audit.computeWasteWithTTIGraph(
-      resources, pageGraph, simulator);
     const wasteFcp =
       UsesHTTP2Audit.computeWasteWithGraph(resources,
         fcpGraph, simulator, {label: 'fcp'});
@@ -296,11 +262,11 @@ class UsesHTTP2Audit extends Audit {
     ];
 
     const details = Audit.makeOpportunityDetails(headings, resources,
-      {overallSavingsMs: wastedMsTti});
+      {overallSavingsMs: wasteLcp.savings});
 
     return {
       displayValue,
-      numericValue: wastedMsTti,
+      numericValue: wasteLcp.savings,
       numericUnit: 'millisecond',
       score: resources.length ? 0 : 1,
       details,

package/core/audits/font-display.js

@@ -50,7 +50,7 @@ class FontDisplay extends Audit {
       description: str_(UIStrings.description),
       supportedModes: ['navigation'],
       guidanceLevel: 3,
-      requiredArtifacts: ['devtoolsLogs', 'CSSUsage', 'URL'],
+      requiredArtifacts: ['devtoolsLogs', 'Stylesheets', 'URL'],
       scoreDisplayMode: Audit.SCORING_MODES.METRIC_SAVINGS,
     };
   }
@@ -67,7 +67,7 @@ class FontDisplay extends Audit {
     const failingURLs = new Set();
 
     // Go through all the stylesheets to find all @font-face declarations
-    for (const stylesheet of artifacts.CSSUsage.stylesheets) {
+    for (const stylesheet of artifacts.Stylesheets) {
       // Eliminate newlines so we can more easily scan through with a regex
       const newlinesStripped = stylesheet.content.replace(/(\r|\n)+/g, ' ');
       // Find the @font-faces

package/core/audits/layout-shifts.js

@@ -61,7 +61,7 @@ class LayoutShifts extends Audit {
   static async audit(artifacts, context) {
     const trace = artifacts.traces[Audit.DEFAULT_PASS];
     const traceEngineResult = await TraceEngineResult.request({trace}, context);
-    const clusters = traceEngineResult.LayoutShifts.clusters ?? [];
+    const clusters = traceEngineResult.data.LayoutShifts.clusters ?? [];
     const {cumulativeLayoutShift: clsSavings, impactByNodeId} =
       await CumulativeLayoutShiftComputed.request(trace, context);
     const traceElements = artifacts.TraceElements

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

@@ -14,11 +14,7 @@ declare class PreloadFontsAudit extends Audit {
      * @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>;
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
 }
 export namespace UIStrings {
     const title: string;

package/core/audits/preload-fonts.js

@@ -62,7 +62,7 @@ class PreloadFontsAudit extends Audit {
    * @param {LH.Audit.Context} context
    * @return {Promise<LH.Audit.Product>}
    */
-  static async audit_(artifacts, context) {
+  static async audit(artifacts, context) {
     const devtoolsLog = artifacts.devtoolsLogs[this.DEFAULT_PASS];
     const networkRecords = await NetworkRecords.request(devtoolsLog, context);
 
@@ -91,15 +91,6 @@ class PreloadFontsAudit extends Audit {
       notApplicable: optionalFontURLs.size === 0,
     };
   }
-
-  /**
-   * @return {Promise<LH.Audit.Product>}
-   */
-  static async audit() {
-    // Preload advice is on hold until https://github.com/GoogleChrome/lighthouse/issues/11960
-    // is resolved.
-    return {score: 1, notApplicable: true};
-  }
 }
 
 export default PreloadFontsAudit;

package/core/audits/prioritize-lcp-image.js

@@ -194,8 +194,8 @@ class PrioritizeLcpImage extends Audit {
     modifiedLCPNode.removeAllDependencies();
     modifiedLCPNode.addDependency(mainDocumentNode);
 
-    const simulationBeforeChanges = simulator.simulate(graph, {flexibleOrdering: true});
-    const simulationAfterChanges = simulator.simulate(modifiedGraph, {flexibleOrdering: true});
+    const simulationBeforeChanges = simulator.simulate(graph);
+    const simulationAfterChanges = simulator.simulate(modifiedGraph);
     const lcpTimingsBefore = simulationBeforeChanges.nodeTimings.get(lcpNode);
     if (!lcpTimingsBefore) throw new Error('Impossible - node timings should never be undefined');
     const lcpTimingsAfter = simulationAfterChanges.nodeTimings.get(modifiedLCPNode);

package/core/audits/redirects-http.d.ts

@@ -0,0 +1,19 @@
+export default RedirectsHTTP;
+/**
+ * An audit for checking if a site starting on http redirects to https. The audit
+ * is marked not applicable if the requestedUrl is already https.
+ */
+declare class RedirectsHTTP extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @return {LH.Audit.Product}
+     */
+    static audit(artifacts: LH.Artifacts): LH.Audit.Product;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import { Audit } from './audit.js';
+//# sourceMappingURL=redirects-http.d.ts.map

package/core/audits/redirects-http.js

@@ -0,0 +1,75 @@
+/**
+ * @license Copyright 2024 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 UrlUtils from '../lib/url-utils.js';
+
+const UIStrings = {
+  /** Title of a Lighthouse audit that provides detail on HTTP to HTTPS redirects. This descriptive title is shown to users when HTTP traffic is redirected to HTTPS. */
+  title: 'Redirects HTTP traffic to HTTPS',
+  /** Title of a Lighthouse audit that provides detail on HTTP to HTTPS redirects. This descriptive title is shown to users when HTTP traffic is not redirected to HTTPS. */
+  failureTitle: 'Does not redirect HTTP traffic to HTTPS',
+  /** Description of a Lighthouse audit that tells the user why they should direct HTTP traffic to HTTPS. This is displayed after a user expands the section to see more. No character length limits. 'Learn More' becomes link text to additional documentation. */
+  description: 'Make sure that you redirect all HTTP ' +
+    'traffic to HTTPS in order to enable secure web features for all your users. [Learn more](https://developer.chrome.com/docs/lighthouse/pwa/redirects-http/).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+/**
+ * An audit for checking if a site starting on http redirects to https. The audit
+ * is marked not applicable if the requestedUrl is already https.
+ */
+class RedirectsHTTP extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'redirects-http',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['URL'],
+      supportedModes: ['navigation'],
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @return {LH.Audit.Product}
+   */
+  static audit(artifacts) {
+    if (!artifacts.URL.requestedUrl) {
+      throw new Error('Missing requestedUrl');
+    }
+
+    const requestedUrl = new URL(artifacts.URL.requestedUrl);
+    const finalDisplayedUrl = new URL(artifacts.URL.finalDisplayedUrl);
+
+    // Not applicable unless starting on http.
+    const startedInsecure = requestedUrl.protocol === 'http:';
+
+    // Relax requirements on localhost.
+    const isLocalhost = UrlUtils.isLikeLocalhost(finalDisplayedUrl.hostname);
+
+    if (!startedInsecure || isLocalhost) {
+      return {
+        score: null,
+        notApplicable: true,
+      };
+    }
+
+    const endedSecure = finalDisplayedUrl.protocol === 'https:';
+    return {
+      score: Number(endedSecure),
+    };
+  }
+}
+
+export default RedirectsHTTP;
+export {UIStrings};

package/core/audits/resource-summary.d.ts

@@ -1,4 +1,6 @@
 export default ResourceSummary;
+export type ResourceType = import('../computed/resource-summary.js').ResourceType;
+/** @typedef {import('../computed/resource-summary.js').ResourceType} ResourceType */
 declare class ResourceSummary extends Audit {
     /**
      * @param {LH.Artifacts} artifacts

package/core/audits/resource-summary.js

@@ -10,6 +10,8 @@ import * as i18n from '../lib/i18n/i18n.js';
 
 const str_ = i18n.createIcuMessageFn(import.meta.url);
 
+/** @typedef {import('../computed/resource-summary.js').ResourceType} ResourceType */
+
 class ResourceSummary extends Audit {
   /**
    * @return {LH.Audit.Meta}
@@ -32,7 +34,7 @@ class ResourceSummary extends Audit {
   static async audit(artifacts, context) {
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
     const summary = await ComputedResourceSummary
-      .request({devtoolsLog, URL: artifacts.URL, budgets: context.settings.budgets}, context);
+      .request({devtoolsLog, URL: artifacts.URL}, context);
 
     /** @type {LH.Audit.Details.Table['headings']} */
     const headings = [
@@ -41,8 +43,7 @@ class ResourceSummary extends Audit {
       {key: 'transferSize', valueType: 'bytes', label: str_(i18n.UIStrings.columnTransferSize)},
     ];
 
-
-    /** @type {Record<LH.Budget.ResourceType, LH.IcuMessage>} */
+    /** @type {Record<ResourceType, LH.IcuMessage>} */
     const strMappings = {
       'total': str_(i18n.UIStrings.totalResourceType),
       'document': str_(i18n.UIStrings.documentResourceType),
@@ -55,7 +56,7 @@ class ResourceSummary extends Audit {
       'third-party': str_(i18n.UIStrings.thirdPartyResourceType),
     };
 
-    const types = /** @type {Array<LH.Budget.ResourceType>} */ (Object.keys(summary));
+    const types = /** @type {Array<ResourceType>} */ (Object.keys(summary));
     const rows = types.map(type => {
       return {
         // ResourceType is included as an "id" for ease of use.

package/core/audits/seo/is-crawlable.d.ts

@@ -6,11 +6,12 @@ declare class IsCrawlable extends Audit {
     static handleMetaElement(metaElement: LH.Artifacts.MetaElement): {
         source: {
             snippet: string;
+            /** @type {Array<string|undefined>} */
             type: "node";
             lhId?: string | undefined;
             path?: string | undefined;
             selector?: string | undefined;
-            boundingRect?: import("../../../types/lhr/audit-details.js").default.Rect | undefined;
+            boundingRect?: import("../../../types/lhr/audit-details.js").default.Rect | undefined; /** @type {Array<string|undefined>} */
             nodeLabel?: string | undefined;
         };
     } | undefined;

package/core/audits/seo/link-text.js

@@ -84,6 +84,18 @@ const BLOCKLIST = new Set([
   'மேலும் தரவுகளுக்கு',
   'தயவுசெய்து இங்கே அழுத்தவும்',
   'இங்கே கிளிக் செய்யவும்',
+  // Persian
+  'اطلاعات بیشتر',
+  'اطلاعات',
+  'این',
+  'اینجا بزنید',
+  'اینجا کلیک کنید',
+  'اینجا',
+  'برو',
+  'بیشتر بخوانید',
+  'بیشتر بدانید',
+  'بیشتر',
+  'شروع',
 ]);
 
 const UIStrings = {

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

@@ -45,11 +45,7 @@ declare class UsesRelPreloadAudit extends Audit {
      * @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>;
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
 }
 export namespace UIStrings {
     const title: string;

package/core/audits/uses-rel-preload.js

@@ -143,9 +143,9 @@ class UsesRelPreloadAudit extends Audit {
       return {wastedMs: 0, results: []};
     }
 
-    // Preload changes the ordering of requests, simulate the original graph with flexible ordering
+    // Preload changes the ordering of requests, simulate the original graph
     // to have a reasonable baseline for comparison.
-    const simulationBeforeChanges = simulator.simulate(graph, {flexibleOrdering: true});
+    const simulationBeforeChanges = simulator.simulate(graph);
     const modifiedGraph = graph.cloneWithRelationships();
 
     /** @type {Array<LH.Gatherer.Simulation.GraphNetworkNode>} */
@@ -174,8 +174,8 @@ class UsesRelPreloadAudit extends Audit {
       node.addDependency(mainDocumentNode);
     }
 
-    // Once we've modified the dependencies, simulate the new graph with flexible ordering.
-    const simulationAfterChanges = simulator.simulate(modifiedGraph, {flexibleOrdering: true});
+    // Once we've modified the dependencies, simulate the new graph.
+    const simulationAfterChanges = simulator.simulate(modifiedGraph);
     const originalNodesByRecord = Array.from(simulationBeforeChanges.nodeTimings.keys())
         // @ts-expect-error we don't care if all nodes without a record collect on `undefined`
         .reduce((map, node) => map.set(node.record, node), new Map());
@@ -209,7 +209,7 @@ class UsesRelPreloadAudit extends Audit {
    * @param {LH.Audit.Context} context
    * @return {Promise<LH.Audit.Product>}
    */
-  static async audit_(artifacts, context) {
+  static async audit(artifacts, context) {
     const trace = artifacts.traces[UsesRelPreloadAudit.DEFAULT_PASS];
     const devtoolsLog = artifacts.devtoolsLogs[UsesRelPreloadAudit.DEFAULT_PASS];
     const URL = artifacts.URL;
@@ -253,16 +253,6 @@ class UsesRelPreloadAudit extends Audit {
       warnings,
     };
   }
-
-  /**
-   * @return {Promise<LH.Audit.Product>}
-   */
-  static async audit() {
-    // Preload advice is on hold until https://github.com/GoogleChrome/lighthouse/issues/11960
-    // is resolved.
-    return {score: 1, notApplicable: true,
-      details: Audit.makeOpportunityDetails([], [], {overallSavingsMs: 0})};
-  }
 }
 
 export default UsesRelPreloadAudit;

package/core/audits/work-during-interaction.d.ts

@@ -32,7 +32,7 @@ declare class WorkDuringInteraction extends Audit {
             startTs: number;
             endTs: number;
         };
-        processingTime: {
+        processingDuration: {
             startTs: number;
             endTs: number;
         };
@@ -72,7 +72,7 @@ export namespace UIStrings {
     const failureTitle: string;
     const description: string;
     const inputDelay: string;
-    const processingTime: string;
+    const processingDuration: string;
     const presentationDelay: string;
     const displayValue: string;
     const eventTarget: string;

package/core/audits/work-during-interaction.js

@@ -30,7 +30,7 @@ const UIStrings = {
   /** Label for a column in a data table; entries will be information on the time that the browser is delayed before responding to user input. Ideally fits within a ~40 character limit. */
   inputDelay: 'Input delay',
   /** Label for a column in a data table; entries will be information on the time taken by code processing user input that delays a response to the user. Ideally fits within a ~40 character limit. */
-  processingTime: 'Processing time',
+  processingDuration: 'Processing duration',
   /** Label for a column in a data table; entries will be information on the time that the browser is delayed before presenting a response to user input on screen. Ideally fits within a ~40 character limit. */
   presentationDelay: 'Presentation delay',
   /**
@@ -115,7 +115,7 @@ class WorkDuringInteraction extends Audit {
     const endTs = startTs + interactionData.duration * 1000;
     return {
       inputDelay: {startTs, endTs: processingStartTs},
-      processingTime: {startTs: processingStartTs, endTs: processingEndTs},
+      processingDuration: {startTs: processingStartTs, endTs: processingEndTs},
       presentationDelay: {startTs: processingEndTs, endTs},
     };
   }

package/core/computed/js-bundles.d.ts

@@ -1,6 +1,6 @@
 export { JSBundlesComputed as JSBundles };
 declare const JSBundlesComputed: typeof JSBundles & {
-    request: (dependencies: Pick<import("../index.js").Artifacts, "Scripts" | "SourceMaps">, context: import("../../types/utility-types.js").default.ImmutableObject<{
+    request: (dependencies: Pick<import("../index.js").Artifacts, "SourceMaps" | "Scripts">, context: import("../../types/utility-types.js").default.ImmutableObject<{
         computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
     }>) => Promise<import("../index.js").Artifacts.Bundle[]>;
 };