lighthouse 9.5.0-dev.20221115 → 9.5.0-dev.20221117

package/cli/cli-flags.js

@@ -351,7 +351,7 @@ function getFlags(manualArgv, options = {}) {
   // Augmenting yargs type with auto-camelCasing breaks in tsc@4.1.2 and @types/yargs@15.0.11,
   // so for now cast to add yarg's camelCase properties to type.
   const argv = /** @type {Awaited<typeof parser.argv>} */ (parser.argv);
-  const cliFlags = /** @type {typeof argv & CamelCasify<typeof argv>} */ (argv);
+  const cliFlags = /** @type {typeof argv & LH.Util.CamelCasify<typeof argv>} */ (argv);
 
   // yargs will return `undefined` for options that have a `coerce` function but
   // are not actually present in the user input. Instead of passing properties

package/cli/printer.js

@@ -13,7 +13,7 @@ import log from 'lighthouse-logger';
  *   'json': JSON formatted results
  *   'html': An HTML report
  *   'csv': CSV formatted results
- * @type {SelfMap<LH.OutputMode>}
+ * @type {LH.Util.SelfMap<LH.OutputMode>}
  */
 const OutputMode = {
   json: 'json',

package/cli/test/smokehouse/frontends/smokehouse-bin.js

@@ -174,7 +174,7 @@ async function begin() {
   // Augmenting yargs type with auto-camelCasing breaks in tsc@4.1.2 and @types/yargs@15.0.11,
   // so for now cast to add yarg's camelCase properties to type.
   const argv =
-    /** @type {Awaited<typeof rawArgv> & CamelCasify<Awaited<typeof rawArgv>>} */ (rawArgv);
+    /** @type {Awaited<typeof rawArgv> & LH.Util.CamelCasify<Awaited<typeof rawArgv>>} */ (rawArgv);
 
   const jobs = Number.isFinite(argv.jobs) ? argv.jobs : undefined;
   const retries = Number.isFinite(argv.retries) ? argv.retries : undefined;

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

@@ -138,7 +138,7 @@ class RenderBlockingResources extends Audit {
     const simulator = await LoadSimulator.request(simulatorData, context);
     const wastedCssBytes = await RenderBlockingResources.computeWastedCSSBytes(artifacts, context);
 
-    /** @type {Immutable<LH.Config.Settings>} */
+    /** @type {LH.Audit.Context['settings']} */
     const metricSettings = {
       ...context.settings,
       throttlingMethod: 'simulate',

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

@@ -194,103 +194,102 @@ class CacheHeaders extends Audit {
    * @param {LH.Audit.Context} context
    * @return {Promise<LH.Audit.Product>}
    */
-  static audit(artifacts, context) {
+  static async audit(artifacts, context) {
     const devtoolsLogs = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
-    return NetworkRecords.request(devtoolsLogs, context).then(records => {
-      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;
+    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);
         }
+      }
 
-        // 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,
-          };
-        }
+      const cacheControl = parseCacheControl(headers.get('cache-control'));
+      if (this.shouldSkipRecord(headers, cacheControl)) {
+        continue;
+      }
 
-        results.push({
-          url,
-          debugData,
-          cacheLifetimeMs: cacheLifetimeInSeconds * 1000,
-          cacheHitProbability,
-          totalBytes,
-          wastedBytes,
-        });
+      // 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.sort((a, b) => {
-        return a.cacheLifetimeMs - b.cacheLifetimeMs ||
-          b.totalBytes - a.totalBytes ||
-          a.url.localeCompare(b.url);
+      results.push({
+        url,
+        debugData,
+        cacheLifetimeMs: cacheLifetimeInSeconds * 1000,
+        cacheHitProbability,
+        totalBytes,
+        wastedBytes,
       });
+    }
 
-      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,
-      };
+    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,
+    };
   }
 }
 

package/core/audits/critical-request-chains.js

@@ -166,52 +166,51 @@ class CriticalRequestChains extends Audit {
    * @param {LH.Audit.Context} context
    * @return {Promise<LH.Audit.Product>}
    */
-  static audit(artifacts, context) {
+  static async audit(artifacts, context) {
     const trace = artifacts.traces[Audit.DEFAULT_PASS];
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
     const URL = artifacts.URL;
-    return ComputedChains.request({devtoolsLog, trace, URL}, context).then(chains => {
-      let chainCount = 0;
-      /**
-       * @param {LH.Audit.Details.SimpleCriticalRequestNode} node
-       * @param {number} depth
-       */
-      function walk(node, depth) {
-        const childIds = Object.keys(node);
-
-        childIds.forEach(id => {
-          const child = node[id];
-          if (child.children) {
-            walk(child.children, depth + 1);
-          } else {
-            // if the node doesn't have a children field, then it is a leaf, so +1
-            chainCount++;
-          }
-        }, '');
-      }
-      // Convert
-      const flattenedChains = CriticalRequestChains.flattenRequests(chains);
-
-      // Account for initial navigation
-      const initialNavKey = Object.keys(flattenedChains)[0];
-      const initialNavChildren = initialNavKey && flattenedChains[initialNavKey].children;
-      if (initialNavChildren && Object.keys(initialNavChildren).length > 0) {
-        walk(initialNavChildren, 0);
-      }
+    const chains = await ComputedChains.request({devtoolsLog, trace, URL}, context);
+    let chainCount = 0;
+    /**
+     * @param {LH.Audit.Details.SimpleCriticalRequestNode} node
+     * @param {number} depth
+     */
+    function walk(node, depth) {
+      const childIds = Object.keys(node);
 
-      const longestChain = CriticalRequestChains._getLongestChain(flattenedChains);
-
-      return {
-        score: Number(chainCount === 0),
-        notApplicable: chainCount === 0,
-        displayValue: chainCount ? str_(UIStrings.displayValue, {itemCount: chainCount}) : '',
-        details: {
-          type: 'criticalrequestchain',
-          chains: flattenedChains,
-          longestChain,
-        },
-      };
-    });
+      childIds.forEach(id => {
+        const child = node[id];
+        if (child.children) {
+          walk(child.children, depth + 1);
+        } else {
+          // if the node doesn't have a children field, then it is a leaf, so +1
+          chainCount++;
+        }
+      }, '');
+    }
+    // Convert
+    const flattenedChains = CriticalRequestChains.flattenRequests(chains);
+
+    // Account for initial navigation
+    const initialNavKey = Object.keys(flattenedChains)[0];
+    const initialNavChildren = initialNavKey && flattenedChains[initialNavKey].children;
+    if (initialNavChildren && Object.keys(initialNavChildren).length > 0) {
+      walk(initialNavChildren, 0);
+    }
+
+    const longestChain = CriticalRequestChains._getLongestChain(flattenedChains);
+
+    return {
+      score: Number(chainCount === 0),
+      notApplicable: chainCount === 0,
+      displayValue: chainCount ? str_(UIStrings.displayValue, {itemCount: chainCount}) : '',
+      details: {
+        type: 'criticalrequestchain',
+        chains: flattenedChains,
+        longestChain,
+      },
+    };
   }
 }
 

package/core/audits/is-on-https.js

@@ -70,53 +70,52 @@ class HTTPS extends Audit {
    * @param {LH.Audit.Context} context
    * @return {Promise<LH.Audit.Product>}
    */
-  static audit(artifacts, context) {
+  static async audit(artifacts, context) {
     const devtoolsLogs = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
-    return NetworkRecords.request(devtoolsLogs, context).then(networkRecords => {
-      const insecureURLs = networkRecords
-          .filter(record => !NetworkRequest.isSecureRequest(record))
-          .map(record => UrlUtils.elideDataURI(record.url));
+    const networkRecords = await NetworkRecords.request(devtoolsLogs, context);
+    const insecureURLs = networkRecords
+      .filter(record => !NetworkRequest.isSecureRequest(record))
+      .map(record => UrlUtils.elideDataURI(record.url));
 
-      /** @type {Array<{url: string, resolution?: LH.IcuMessage|string}>}  */
-      const items = Array.from(new Set(insecureURLs)).map(url => ({url, resolution: undefined}));
+    /** @type {Array<{url: string, resolution?: LH.IcuMessage|string}>}  */
+    const items = Array.from(new Set(insecureURLs)).map(url => ({url, resolution: undefined}));
 
-      /** @type {LH.Audit.Details.Table['headings']} */
-      const headings = [
-        {key: 'url', valueType: 'url', label: str_(UIStrings.columnInsecureURL)},
-        {key: 'resolution', valueType: 'text', label: str_(UIStrings.columnResolution)},
-      ];
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      {key: 'url', valueType: 'url', label: str_(UIStrings.columnInsecureURL)},
+      {key: 'resolution', valueType: 'text', label: str_(UIStrings.columnResolution)},
+    ];
 
-      for (const details of artifacts.InspectorIssues.mixedContentIssue) {
-        let item = items.find(item => item.url === details.insecureURL);
-        if (!item) {
-          item = {url: details.insecureURL};
-          items.push(item);
-        }
-        item.resolution = resolutionToString[details.resolutionStatus] ?
-          str_(resolutionToString[details.resolutionStatus]) :
-          details.resolutionStatus;
+    for (const details of artifacts.InspectorIssues.mixedContentIssue) {
+      let item = items.find(item => item.url === details.insecureURL);
+      if (!item) {
+        item = {url: details.insecureURL};
+        items.push(item);
       }
+      item.resolution = resolutionToString[details.resolutionStatus] ?
+        str_(resolutionToString[details.resolutionStatus]) :
+        details.resolutionStatus;
+    }
 
-      // If a resolution wasn't assigned from an InspectorIssue, then the item
-      // is not blocked by the browser but we've determined it is insecure anyhow.
-      // For example, if the URL is localhost, all `http` requests are valid
-      // (localhost is a secure context), but we still identify `http` requests
-      // as an "Allowed" insecure URL.
-      for (const item of items) {
-        if (!item.resolution) item.resolution = str_(UIStrings.allowed);
-      }
+    // If a resolution wasn't assigned from an InspectorIssue, then the item
+    // is not blocked by the browser but we've determined it is insecure anyhow.
+    // For example, if the URL is localhost, all `http` requests are valid
+    // (localhost is a secure context), but we still identify `http` requests
+    // as an "Allowed" insecure URL.
+    for (const item of items) {
+      if (!item.resolution) item.resolution = str_(UIStrings.allowed);
+    }
 
-      let displayValue;
-      if (items.length > 0) {
-        displayValue = str_(UIStrings.displayValue, {itemCount: items.length});
-      }
+    let displayValue;
+    if (items.length > 0) {
+      displayValue = str_(UIStrings.displayValue, {itemCount: items.length});
+    }
 
-      return {
-        score: Number(items.length === 0),
-        displayValue,
-        details: Audit.makeTableDetails(headings, items),
-      };
-    });
+    return {
+      score: Number(items.length === 0),
+      displayValue,
+      details: Audit.makeTableDetails(headings, items),
+    };
   }
 }
 

package/core/audits/metrics/first-contentful-paint-3g.js

@@ -49,7 +49,7 @@ class FirstContentfulPaint3G extends Audit {
     const gatherContext = artifacts.GatherContext;
     const trace = artifacts.traces[Audit.DEFAULT_PASS];
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
-    /** @type {Immutable<LH.Config.Settings>} */
+    /** @type {LH.Audit.Context['settings']} */
     const settings = {...context.settings, throttlingMethod: 'simulate', throttling: regular3G};
     const metricComputationData = {trace, devtoolsLog, gatherContext, settings, URL: artifacts.URL};
     const metricResult = await ComputedFcp.request(metricComputationData, context);

package/core/audits/performance-budget.js

@@ -65,7 +65,7 @@ class ResourceBudget extends Audit {
   }
 
   /**
-   * @param {Immutable<LH.Budget>} budget
+   * @param {LH.Util.Immutable<LH.Budget>} budget
    * @param {Record<LH.Budget.ResourceType, ResourceEntry>} summary
    * @return {Array<BudgetItem>}
    */

package/core/audits/seo/is-crawlable.js

@@ -90,63 +90,60 @@ class IsCrawlable extends Audit {
    * @param {LH.Audit.Context} context
    * @return {Promise<LH.Audit.Product>}
    */
-  static audit(artifacts, context) {
+  static async audit(artifacts, context) {
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
     const metaRobots = artifacts.MetaElements.find(meta => meta.name === 'robots');
+    const mainResource = await MainResource.request({devtoolsLog, URL: artifacts.URL}, context);
+    /** @type {LH.Audit.Details.Table['items']} */
+    const blockingDirectives = [];
+
+    if (metaRobots) {
+      const metaRobotsContent = metaRobots.content || '';
+      const isBlocking = hasBlockingDirective(metaRobotsContent);
+
+      if (isBlocking) {
+        blockingDirectives.push({
+          source: {
+            ...Audit.makeNodeItem(metaRobots.node),
+            snippet: `<meta name="robots" content="${metaRobotsContent}" />`,
+          },
+        });
+      }
+    }
+
+    mainResource.responseHeaders && mainResource.responseHeaders
+      .filter(h => h.name.toLowerCase() === ROBOTS_HEADER && !hasUserAgent(h.value) &&
+        hasBlockingDirective(h.value))
+      .forEach(h => blockingDirectives.push({source: `${h.name}: ${h.value}`}));
+
+    if (artifacts.RobotsTxt.content) {
+      const robotsFileUrl = new URL('/robots.txt', mainResource.url);
+      const robotsTxt = robotsParser(robotsFileUrl.href, artifacts.RobotsTxt.content);
+
+      if (!robotsTxt.isAllowed(mainResource.url)) {
+        const line = robotsTxt.getMatchingLineNumber(mainResource.url) || 1;
+        blockingDirectives.push({
+          source: {
+            type: /** @type {const} */ ('source-location'),
+            url: robotsFileUrl.href,
+            urlProvider: /** @type {const} */ ('network'),
+            line: line - 1,
+            column: 0,
+          },
+        });
+      }
+    }
+
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      {key: 'source', valueType: 'code', label: 'Blocking Directive Source'},
+    ];
+    const details = Audit.makeTableDetails(headings, blockingDirectives);
 
-    return MainResource.request({devtoolsLog, URL: artifacts.URL}, context)
-      .then(mainResource => {
-        /** @type {LH.Audit.Details.Table['items']} */
-        const blockingDirectives = [];
-
-        if (metaRobots) {
-          const metaRobotsContent = metaRobots.content || '';
-          const isBlocking = hasBlockingDirective(metaRobotsContent);
-
-          if (isBlocking) {
-            blockingDirectives.push({
-              source: {
-                ...Audit.makeNodeItem(metaRobots.node),
-                snippet: `<meta name="robots" content="${metaRobotsContent}" />`,
-              },
-            });
-          }
-        }
-
-        mainResource.responseHeaders && mainResource.responseHeaders
-          .filter(h => h.name.toLowerCase() === ROBOTS_HEADER && !hasUserAgent(h.value) &&
-            hasBlockingDirective(h.value))
-          .forEach(h => blockingDirectives.push({source: `${h.name}: ${h.value}`}));
-
-        if (artifacts.RobotsTxt.content) {
-          const robotsFileUrl = new URL('/robots.txt', mainResource.url);
-          const robotsTxt = robotsParser(robotsFileUrl.href, artifacts.RobotsTxt.content);
-
-          if (!robotsTxt.isAllowed(mainResource.url)) {
-            const line = robotsTxt.getMatchingLineNumber(mainResource.url) || 1;
-            blockingDirectives.push({
-              source: {
-                type: /** @type {const} */ ('source-location'),
-                url: robotsFileUrl.href,
-                urlProvider: /** @type {const} */ ('network'),
-                line: line - 1,
-                column: 0,
-              },
-            });
-          }
-        }
-
-        /** @type {LH.Audit.Details.Table['headings']} */
-        const headings = [
-          {key: 'source', valueType: 'code', label: 'Blocking Directive Source'},
-        ];
-        const details = Audit.makeTableDetails(headings, blockingDirectives);
-
-        return {
-          score: Number(blockingDirectives.length === 0),
-          details,
-        };
-      });
+    return {
+      score: Number(blockingDirectives.length === 0),
+      details,
+    };
   }
 }
 

package/core/audits/timing-budget.js

@@ -80,7 +80,7 @@ class TimingBudget extends Audit {
   }
 
   /**
-   * @param {Immutable<LH.Budget>} budget
+   * @param {LH.Util.Immutable<LH.Budget>} budget
    * @param {LH.Artifacts.TimingSummary} summary
    * @return {Array<BudgetItem>}
    */

package/core/audits/user-timings.js

@@ -64,54 +64,53 @@ class UserTimings extends Audit {
    * @param {LH.Audit.Context} context
    * @return {Promise<LH.Audit.Product>}
    */
-  static audit(artifacts, context) {
+  static async audit(artifacts, context) {
     const trace = artifacts.traces[Audit.DEFAULT_PASS];
-    return ComputedUserTimings.request(trace, context).then(computedUserTimings => {
-      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;
-        }
-      });
+    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)},
-      ];
+    /** @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);
+    const details = Audit.makeTableDetails(headings, tableRows);
 
-      let displayValue;
-      if (userTimings.length) {
-        displayValue = str_(UIStrings.displayValue, {itemCount: userTimings.length});
-      }
+    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,
-      };
-    });
+    return {
+      // mark the audit as notApplicable if there were no user timings
+      score: Number(userTimings.length === 0),
+      notApplicable: userTimings.length === 0,
+      displayValue,
+      details,
+    };
   }
 }
 

package/core/computed/computed-artifact.js

@@ -12,9 +12,9 @@ import {ArbitraryEqualityMap} from '../lib/arbitrary-equality-map.js';
  * Decorate computableArtifact with a caching `request()` method which will
  * automatically call `computableArtifact.compute_()` under the hood.
  * @template {{name: string, compute_(dependencies: unknown, context: LH.Artifacts.ComputedContext): Promise<unknown>}} C
- * @template {Array<keyof FirstParamType<C['compute_']>>} K
+ * @template {Array<keyof LH.Util.FirstParamType<C['compute_']>>} K
  * @param {C} computableArtifact
- * @param {(K & ([keyof FirstParamType<C['compute_']>] extends [K[number]] ? unknown : never)) | null} keys List of properties of `dependencies` used by `compute_`; other properties are filtered out. Use `null` to allow all properties. Ensures that only required properties are used for caching result.
+ * @param {(K & ([keyof LH.Util.FirstParamType<C['compute_']>] extends [K[number]] ? unknown : never)) | null} keys List of properties of `dependencies` used by `compute_`; other properties are filtered out. Use `null` to allow all properties. Ensures that only required properties are used for caching result.
  */
 function makeComputedArtifact(computableArtifact, keys) {
   // tsc (3.1) has more difficulty with template inter-references in jsdoc, so
@@ -22,7 +22,7 @@ function makeComputedArtifact(computableArtifact, keys) {
   // polymorphic-this behavior for C.
   /**
    * Return an automatically cached result from the computed artifact.
-   * @param {FirstParamType<C['compute_']>} dependencies
+   * @param {LH.Util.FirstParamType<C['compute_']>} dependencies
    * @param {LH.Artifacts.ComputedContext} context
    * @return {ReturnType<C['compute_']>}
    */

package/core/computed/load-simulator.js

@@ -11,7 +11,7 @@ import {NetworkAnalysis} from './network-analysis.js';
 
 class LoadSimulator {
   /**
-   * @param {{devtoolsLog: LH.DevtoolsLog, settings: Immutable<LH.Config.Settings>}} data
+   * @param {{devtoolsLog: LH.DevtoolsLog, settings: LH.Audit.Context['settings']}} data
    * @param {LH.Artifacts.ComputedContext} context
    * @return {Promise<Simulator>}
    */

package/core/computed/metrics/responsiveness.js

@@ -131,7 +131,7 @@ class Responsiveness {
   }
 
   /**
-   * @param {{trace: LH.Trace, settings: Immutable<LH.Config.Settings>}} data
+   * @param {{trace: LH.Trace, settings: LH.Audit.Context['settings']}} data
    * @param {LH.Artifacts.ComputedContext} context
    * @return {Promise<EventTimingEvent|FallbackTimingEvent|null>}
    */

package/core/computed/metrics/timing-summary.js

@@ -24,7 +24,7 @@ class TimingSummary {
      * @param {LH.Trace} trace
      * @param {LH.DevtoolsLog} devtoolsLog
      * @param {LH.Artifacts['GatherContext']} gatherContext
-     * @param {ImmutableObject<LH.Config.Settings>} settings
+     * @param {LH.Util.ImmutableObject<LH.Config.Settings>} settings
      * @param {LH.Artifacts['URL']} URL
      * @param {LH.Artifacts.ComputedContext} context
      * @return {Promise<{metrics: LH.Artifacts.TimingSummary, debugInfo: Record<string,boolean>}>}
@@ -134,7 +134,7 @@ class TimingSummary {
     return {metrics, debugInfo};
   }
   /**
-   * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, gatherContext: LH.Artifacts['GatherContext']; settings: ImmutableObject<LH.Config.Settings>, URL: LH.Artifacts['URL']}} data
+   * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, gatherContext: LH.Artifacts['GatherContext']; settings: LH.Util.ImmutableObject<LH.Config.Settings>, URL: LH.Artifacts['URL']}} data
    * @param {LH.Artifacts.ComputedContext} context
    * @return {Promise<{metrics: LH.Artifacts.TimingSummary, debugInfo: Record<string,boolean>}>}
    */

package/core/computed/network-analysis.js

@@ -11,7 +11,7 @@ import {NetworkRecords} from './network-records.js';
 class NetworkAnalysis {
   /**
    * @param {Array<LH.Artifacts.NetworkRequest>} records
-   * @return {StrictOmit<LH.Artifacts.NetworkAnalysis, 'throughput'>}
+   * @return {LH.Util.StrictOmit<LH.Artifacts.NetworkAnalysis, 'throughput'>}
    */
   static computeRTTAndServerResponseTime(records) {
     // First pass compute the estimated observed RTT to each origin's servers.

package/core/computed/resource-summary.js

@@ -34,7 +34,7 @@ class ResourceSummary {
   /**
    * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
    * @param {LH.Artifacts.URL} URLArtifact
-   * @param {ImmutableObject<LH.Budget[]|null>} budgets
+   * @param {LH.Util.ImmutableObject<LH.Budget[]|null>} budgets
    * @return {Record<LH.Budget.ResourceType, ResourceEntry>}
    */
   static summarize(networkRecords, URLArtifact, budgets) {
@@ -99,7 +99,7 @@ class ResourceSummary {
   }
 
   /**
-   * @param {{URL: LH.Artifacts['URL'], devtoolsLog: LH.DevtoolsLog, budgets: ImmutableObject<LH.Budget[]|null>}} data
+   * @param {{URL: LH.Artifacts['URL'], devtoolsLog: LH.DevtoolsLog, budgets: LH.Util.ImmutableObject<LH.Budget[]|null>}} data
    * @param {LH.Artifacts.ComputedContext} context
    * @return {Promise<Record<LH.Budget.ResourceType,ResourceEntry>>}
    */

package/core/config/budget.js

@@ -135,9 +135,9 @@ class Budget {
    * Returns the budget that applies to a given URL.
    * If multiple budgets match based on thier 'path' property,
    * then the last-listed of those budgets is returned.
-   * @param {Immutable<Array<LH.Budget>>|null} budgets
+   * @param {LH.Util.Immutable<Array<LH.Budget>>|null} budgets
    * @param {string|undefined} url
-   * @return {Immutable<LH.Budget> | undefined} budget
+   * @return {LH.Util.Immutable<LH.Budget> | undefined} budget
    */
   static getMatchingBudget(budgets, url) {
     if (budgets === null || url === undefined) return;

package/core/config/config-helpers.js

@@ -299,10 +299,10 @@ function requireAudit(auditPath, coreAuditList, configDir) {
  * Creates a settings object from potential flags object by dropping all the properties
  * that don't exist on Config.Settings.
  * @param {Partial<LH.Flags>=} flags
- * @return {RecursivePartial<LH.Config.Settings>}
+ * @return {LH.Util.RecursivePartial<LH.Config.Settings>}
 */
 function cleanFlagsForSettings(flags = {}) {
-  /** @type {RecursivePartial<LH.Config.Settings>} */
+  /** @type {LH.Util.RecursivePartial<LH.Config.Settings>} */
   const settings = {};
 
   for (const key of Object.keys(flags)) {

package/core/gather/gatherers/full-page-screenshot.js

@@ -25,7 +25,9 @@ const MAX_WEBP_SIZE = 16383;
  * @param {S} str
  */
 function kebabCaseToCamelCase(str) {
-  return /** @type {KebabToCamelCase<S>} */ (str.replace(/(-\w)/g, m => m[1].toUpperCase()));
+  return /** @type {LH.Util.KebabToCamelCase<S>} */ (
+    str.replace(/(-\w)/g, m => m[1].toUpperCase())
+  );
 }
 
 /* c8 ignore start */

package/core/lib/lantern-trace-saver.js

@@ -130,7 +130,7 @@ function convertNodeTimingsToTrace(nodeTimings) {
     if (startTime === endTime) endTime += 0.3;
 
     const requestData = {requestId: requestId.toString(), frame};
-    /** @type {StrictOmit<LH.TraceEvent, 'name'|'ts'|'args'>} */
+    /** @type {LH.Util.StrictOmit<LH.TraceEvent, 'name'|'ts'|'args'>} */
     const baseRequestEvent = {...baseEvent, ph: 'I', s: 't', dur: 0};
 
     const sendRequestData = {

package/core/lib/network-request.js

@@ -89,7 +89,7 @@ const HEADER_PROTOCOL_IS_H2 = 'X-ProtocolIsH2';
  * @property {number} responseMs
  */
 
-/** @type {SelfMap<LH.Crdp.Network.ResourceType>} */
+/** @type {LH.Util.SelfMap<LH.Crdp.Network.ResourceType>} */
 const RESOURCE_TYPES = {
   XHR: 'XHR',
   Fetch: 'Fetch',

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lighthouse",
   "type": "module",
-  "version": "9.5.0-dev.20221115",
+  "version": "9.5.0-dev.20221117",
   "description": "Automated auditing, performance metrics, and best practices for the web.",
   "main": "./core/index.js",
   "bin": {

package/types/artifacts.d.ts

@@ -18,10 +18,12 @@ import Gatherer from './gatherer';
 import {IcuMessage} from './lhr/i18n';
 import LHResult from './lhr/lhr'
 import Protocol from './protocol';
+import Util from './utility-types.js';
+import Audit from './audit.js';
 
 export interface Artifacts extends BaseArtifacts, GathererArtifacts {}
 
-export type FRArtifacts = StrictOmit<Artifacts,
+export type FRArtifacts = Util.StrictOmit<Artifacts,
   | 'Fonts'
   | 'Manifest'
   | 'MixedContent'
@@ -179,7 +181,7 @@ export interface GathererArtifacts extends PublicGathererArtifacts,LegacyBaseArt
 }
 
 declare module Artifacts {
-  type ComputedContext = Immutable<{
+  type ComputedContext = Util.Immutable<{
     computedCache: Map<string, ArbitraryEqualityMap>;
   }>;
 
@@ -634,7 +636,7 @@ declare module Artifacts {
   interface MetricComputationDataInput {
     devtoolsLog: DevtoolsLog;
     trace: Trace;
-    settings: Immutable<Config.Settings>;
+    settings: Audit.Context['settings'];
     gatherContext: Artifacts['GatherContext'];
     simulator?: InstanceType<typeof Simulator>;
     URL: Artifacts['URL'];

package/types/audit.d.ts

@@ -11,6 +11,7 @@ import Config from './config';
 import Gatherer from './gatherer';
 import {IcuMessage} from './lhr/i18n';
 import * as AuditResult from './lhr/audit-result';
+import Util from './utility-types.js';
 
 declare module Audit {
   export import Details = AuditDetails;
@@ -18,7 +19,7 @@ declare module Audit {
   export type ScoreDisplayMode = AuditResult.ScoreDisplayMode;
   export type ScoreDisplayModes = AuditResult.ScoreDisplayModes;
 
-  type Context = Immutable<{
+  type Context = Util.Immutable<{
     /** audit options */
     options: Record<string, any>;
     settings: Config.Settings;

package/types/externs.d.ts

@@ -8,101 +8,6 @@ import {Artifacts} from './artifacts';
 import LHResult from './lhr/lhr';
 import {SharedFlagsSettings, OutputMode} from './lhr/settings';
 
-declare global {
-  // Augment Intl to include
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/getCanonicalLocales
-  namespace Intl {
-    var getCanonicalLocales: (locales?: string | Array<string>) => Array<string>;
-  }
-
-  interface Window {
-    // Cached native functions/objects for use in case the page overwrites them.
-    // See: `executionContext.cacheNativesOnNewDocument`.
-    __nativePromise: PromiseConstructor;
-    __nativePerformance: Performance;
-    __nativeFetch: typeof fetch,
-    __nativeURL: typeof URL;
-    __ElementMatches: Element['matches'];
-    __HTMLElementBoundingClientRect: HTMLElement['getBoundingClientRect'];
-
-    /** Used for monitoring long tasks in the test page. */
-    ____lastLongTask?: number;
-
-    /** Used by FullPageScreenshot gatherer. */
-    __lighthouseNodesDontTouchOrAllVarianceGoesAway: Map<Element, string>;
-    __lighthouseExecutionContextUniqueIdentifier?: number;
-
-    /** Injected into the page when the `--debug` flag is used. */
-    continueLighthouseRun(): void;
-
-    // Not defined in tsc yet: https://github.com/microsoft/TypeScript/issues/40807
-    requestIdleCallback(callback: (deadline: {didTimeout: boolean, timeRemaining: () => DOMHighResTimeStamp}) => void, options?: {timeout: number}): number;
-  }
-
-  /** Make properties K in T optional. */
-  type MakeOptional<T, K extends keyof T> = {
-    [P in Exclude<keyof T, K>]: T[P]
-  } & {
-    [P in K]+?: T[P]
-  }
-
-  /** An object with the keys in the union K mapped to themselves as values. */
-  type SelfMap<K extends string> = {
-    [P in K]: P;
-  };
-
-  /** Make optional all properties on T and any properties on object properties of T. */
-  type RecursivePartial<T> =
-    // Recurse into arrays and tuples: elements aren't (newly) optional, but any properties they have are.
-    T extends (infer U)[] ? RecursivePartial<U>[] :
-    // Recurse into objects: properties and any of their properties are optional.
-    T extends object ? {[P in keyof T]?: RecursivePartial<T[P]>} :
-    // Strings, numbers, etc. (terminal types) end here.
-    T;
-
-  /** Recursively makes all properties of T read-only. */
-  type Immutable<T> =
-    T extends Function ? T :
-    T extends Array<infer R> ? ImmutableArray<R> :
-    T extends Map<infer K, infer V> ? ImmutableMap<K, V> :
-    T extends Set<infer M> ? ImmutableSet<M> :
-    T extends object ? ImmutableObject<T> :
-    T
-
-  // Intermediate immutable types. Prefer e.g. Immutable<Set<T>> over direct use.
-  type ImmutableArray<T> = ReadonlyArray<Immutable<T>>;
-  type ImmutableMap<K, V> = ReadonlyMap<Immutable<K>, Immutable<V>>;
-  type ImmutableSet<T> = ReadonlySet<Immutable<T>>;
-  type ImmutableObject<T> = {
-    readonly [K in keyof T]: Immutable<T[K]>;
-  };
-
-  /**
-   * Exclude void from T
-   */
-  type NonVoid<T> = T extends void ? never : T;
-
-  /** Remove properties K from T. */
-  type StrictOmit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
-
-  /** Obtain the type of the first parameter of a function. */
-  type FirstParamType<T extends (arg1: any, ...args: any[]) => any> =
-    T extends (arg1: infer P, ...args: any[]) => any ? P : never;
-
-  /**
-   * If `S` is a kebab-style string `S`, convert to camelCase.
-   */
-  type KebabToCamelCase<S> =
-    S extends `${infer T}-${infer U}` ?
-    `${T}${Capitalize<KebabToCamelCase<U>>}` :
-    S
-
-  /** Returns T with any kebab-style property names rewritten as camelCase. */
-  type CamelCasify<T> = {
-    [K in keyof T as KebabToCamelCase<K>]: T[K];
-  }
-}
-
 /**
  * Extends the flags in SharedFlagsSettings with flags used to configure the
  * Lighthouse module but will not end up in the Config settings.

package/types/global-lh.d.ts

@@ -22,6 +22,7 @@ import * as Settings from './lhr/settings';
 import Treemap_ from './lhr/treemap';
 import UserFlow_ from './user-flow';
 import Puppeteer_ from './puppeteer';
+import Util_ from './utility-types.js';
 
 // Construct hierarchy of global types under the LH namespace.
 declare global {
@@ -29,6 +30,8 @@ declare global {
     export type ArbitraryEqualityMap = ArbitraryEqualityMap_;
     export type NavigationRequestor = string | (() => Promise<void> | void);
 
+    export import Util = Util_;
+
     export import Puppeteer = Puppeteer_;
 
     // artifacts.d.ts

package/types/node.d.ts

@@ -7,6 +7,38 @@
 declare global {
   var isDevtools: boolean | undefined;
   var isLightrider: boolean | undefined;
+
+  // Augment Intl to include
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/getCanonicalLocales
+  namespace Intl {
+    var getCanonicalLocales: (locales?: string | Array<string>) => Array<string>;
+  }
+
+  // Some functions defined in node are stringified and run in the browser.
+  // Ensure those functions are working with the correct browser environment.
+  interface Window {
+    // Cached native functions/objects for use in case the page overwrites them.
+    // See: `executionContext.cacheNativesOnNewDocument`.
+    __nativePromise: PromiseConstructor;
+    __nativePerformance: Performance;
+    __nativeFetch: typeof fetch,
+    __nativeURL: typeof URL;
+    __ElementMatches: Element['matches'];
+    __HTMLElementBoundingClientRect: HTMLElement['getBoundingClientRect'];
+
+    /** Used for monitoring long tasks in the test page. */
+    ____lastLongTask?: number;
+
+    /** Used by FullPageScreenshot gatherer. */
+    __lighthouseNodesDontTouchOrAllVarianceGoesAway: Map<Element, string>;
+    __lighthouseExecutionContextUniqueIdentifier?: number;
+
+    /** Injected into the page when the `--debug` flag is used. */
+    continueLighthouseRun(): void;
+
+    // Not defined in tsc yet: https://github.com/microsoft/TypeScript/issues/40807
+    requestIdleCallback(callback: (deadline: {didTimeout: boolean, timeRemaining: () => DOMHighResTimeStamp}) => void, options?: {timeout: number}): number;
+  }
 }
 
 export {};

package/types/utility-types.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @license Copyright 2022 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.
+ */
+
+declare module Util {
+  /** Make properties K in T optional. */
+  type MakeOptional<T, K extends keyof T> = {
+    [P in Exclude<keyof T, K>]: T[P]
+  } & {
+    [P in K]+?: T[P]
+  }
+
+  /** An object with the keys in the union K mapped to themselves as values. */
+  type SelfMap<K extends string> = {
+    [P in K]: P;
+  };
+
+  /** Make optional all properties on T and any properties on object properties of T. */
+  type RecursivePartial<T> =
+    // Recurse into arrays and tuples: elements aren't (newly) optional, but any properties they have are.
+    T extends (infer U)[] ? RecursivePartial<U>[] :
+    // Recurse into objects: properties and any of their properties are optional.
+    T extends object ? {[P in keyof T]?: RecursivePartial<T[P]>} :
+    // Strings, numbers, etc. (terminal types) end here.
+    T;
+
+  /** Recursively makes all properties of T read-only. */
+  type Immutable<T> =
+    T extends Function ? T :
+    T extends Array<infer R> ? ImmutableArray<R> :
+    T extends Map<infer K, infer V> ? ImmutableMap<K, V> :
+    T extends Set<infer M> ? ImmutableSet<M> :
+    T extends object ? ImmutableObject<T> :
+    T
+
+  // Intermediate immutable types. Prefer e.g. Immutable<Set<T>> over direct use.
+  type ImmutableArray<T> = ReadonlyArray<Immutable<T>>;
+  type ImmutableMap<K, V> = ReadonlyMap<Immutable<K>, Immutable<V>>;
+  type ImmutableSet<T> = ReadonlySet<Immutable<T>>;
+  type ImmutableObject<T> = {
+    readonly [K in keyof T]: Immutable<T[K]>;
+  };
+
+  /**
+   * Exclude void from T
+   */
+  type NonVoid<T> = T extends void ? never : T;
+
+  /** Remove properties K from T. */
+  type StrictOmit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+
+  /** Obtain the type of the first parameter of a function. */
+  type FirstParamType<T extends (arg1: any, ...args: any[]) => any> =
+    T extends (arg1: infer P, ...args: any[]) => any ? P : never;
+
+  /**
+   * If `S` is a kebab-style string `S`, convert to camelCase.
+   */
+  type KebabToCamelCase<S> =
+    S extends `${infer T}-${infer U}` ?
+    `${T}${Capitalize<KebabToCamelCase<U>>}` :
+    S
+
+  /** Returns T with any kebab-style property names rewritten as camelCase. */
+  type CamelCasify<T> = {
+    [K in keyof T as KebabToCamelCase<K>]: T[K];
+  }
+}
+
+export default Util;