lighthouse 9.5.0-dev.20220509 → 9.6.1

package/lighthouse-core/gather/gatherers/link-elements.js

@@ -8,9 +8,10 @@
 const LinkHeader = require('http-link-header');
 const FRGatherer = require('../../fraggle-rock/gather/base-gatherer.js');
 const {URL} = require('../../lib/url-shim.js');
+const NetworkRecords = require('../../computed/network-records.js');
+const NetworkAnalyzer = require('../../lib/dependency-graph/simulator/network-analyzer.js');
 const pageFunctions = require('../../lib/page-functions.js');
 const DevtoolsLog = require('./devtools-log.js');
-const MainResource = require('../../computed/main-resource.js');
 
 /* globals HTMLLinkElement getNodeDetails */
 
@@ -113,12 +114,12 @@ class LinkElements extends FRGatherer {
 
   /**
    * @param {LH.Gatherer.FRTransitionalContext} context
-   * @param {LH.Artifacts['DevtoolsLog']} devtoolsLog
-   * @return {Promise<LH.Artifacts['LinkElements']>}
+   * @param {LH.Artifacts.NetworkRequest[]} networkRecords
+   * @return {LH.Artifacts['LinkElements']}
    */
-  static async getLinkElementsInHeaders(context, devtoolsLog) {
-    const mainDocument =
-      await MainResource.request({devtoolsLog, URL: context.baseArtifacts.URL}, context);
+  static getLinkElementsInHeaders(context, networkRecords) {
+    const finalUrl = context.url;
+    const mainDocument = NetworkAnalyzer.findMainDocument(networkRecords, finalUrl);
 
     /** @type {LH.Artifacts['LinkElements']} */
     const linkElements = [];
@@ -129,7 +130,7 @@ class LinkElements extends FRGatherer {
       for (const link of LinkHeader.parse(header.value).refs) {
         linkElements.push({
           rel: link.rel || '',
-          href: normalizeUrlOrNull(link.uri, context.baseArtifacts.URL.finalUrl),
+          href: normalizeUrlOrNull(link.uri, finalUrl),
           hrefRaw: link.uri || '',
           hreflang: link.hreflang || '',
           as: link.as || '',
@@ -145,12 +146,12 @@ class LinkElements extends FRGatherer {
 
   /**
    * @param {LH.Gatherer.FRTransitionalContext} context
-   * @param {LH.Artifacts['DevtoolsLog']} devtoolsLog
+   * @param {LH.Artifacts.NetworkRequest[]} networkRecords
    * @return {Promise<LH.Artifacts['LinkElements']>}
    */
-  async _getArtifact(context, devtoolsLog) {
+  async _getArtifact(context, networkRecords) {
     const fromDOM = await LinkElements.getLinkElementsInDOM(context);
-    const fromHeaders = await LinkElements.getLinkElementsInHeaders(context, devtoolsLog);
+    const fromHeaders = LinkElements.getLinkElementsInHeaders(context, networkRecords);
     const linkElements = fromDOM.concat(fromHeaders);
 
     for (const link of linkElements) {
@@ -167,7 +168,7 @@ class LinkElements extends FRGatherer {
    * @return {Promise<LH.Artifacts['LinkElements']>}
    */
   async afterPass(context, loadData) {
-    return this._getArtifact({...context, dependencies: {}}, loadData.devtoolsLog);
+    return this._getArtifact({...context, dependencies: {}}, loadData.networkRecords);
   }
 
   /**
@@ -175,7 +176,8 @@ class LinkElements extends FRGatherer {
    * @return {Promise<LH.Artifacts['LinkElements']>}
    */
   async getArtifact(context) {
-    return this._getArtifact(context, context.dependencies.DevtoolsLog);
+    const records = await NetworkRecords.request(context.dependencies.DevtoolsLog, context);
+    return this._getArtifact(context, records);
   }
 }
 

package/lighthouse-core/gather/gatherers/main-document-content.js

@@ -6,9 +6,10 @@
 'use strict';
 
 const FRGatherer = require('../../fraggle-rock/gather/base-gatherer.js');
+const NetworkAnalyzer = require('../../lib/dependency-graph/simulator/network-analyzer.js');
+const NetworkRecords = require('../../computed/network-records.js');
 const DevtoolsLog = require('./devtools-log.js');
 const {fetchResponseBodyFromCache} = require('../driver/network.js');
-const MainResource = require('../../computed/main-resource.js');
 
 /**
  * Collects the content of the main html document.
@@ -23,16 +24,14 @@ class MainDocumentContent extends FRGatherer {
   /**
    *
    * @param {LH.Gatherer.FRTransitionalContext} context
-   * @param {LH.Artifacts['DevtoolsLog']} devtoolsLog
+   * @param {LH.Artifacts.NetworkRequest[]} networkRecords
    * @return {Promise<LH.Artifacts['MainDocumentContent']>}
    */
-  async _getArtifact(context, devtoolsLog) {
-    const mainResource =
-      await MainResource.request({devtoolsLog, URL: context.baseArtifacts.URL}, context);
+  async _getArtifact(context, networkRecords) {
+    const mainResource = NetworkAnalyzer.findMainDocument(networkRecords, context.url);
     const session = context.driver.defaultSession;
     return fetchResponseBodyFromCache(session, mainResource.requestId);
   }
-
   /**
    *
    * @param {LH.Gatherer.FRTransitionalContext<'DevtoolsLog'>} context
@@ -40,7 +39,8 @@ class MainDocumentContent extends FRGatherer {
    */
   async getArtifact(context) {
     const devtoolsLog = context.dependencies.DevtoolsLog;
-    return this._getArtifact(context, devtoolsLog);
+    const networkRecords = await NetworkRecords.request(devtoolsLog, context);
+    return this._getArtifact(context, networkRecords);
   }
 
   /**
@@ -49,7 +49,7 @@ class MainDocumentContent extends FRGatherer {
    * @return {Promise<LH.Artifacts['MainDocumentContent']>}
    */
   async afterPass(passContext, loadData) {
-    return this._getArtifact({...passContext, dependencies: {}}, loadData.devtoolsLog);
+    return this._getArtifact({...passContext, dependencies: {}}, loadData.networkRecords);
   }
 }
 

package/lighthouse-core/gather/gatherers/script-elements.js

@@ -7,8 +7,10 @@
 
 const FRGatherer = require('../../fraggle-rock/gather/base-gatherer.js');
 const NetworkRecords = require('../../computed/network-records.js');
+const NetworkAnalyzer = require('../../lib/dependency-graph/simulator/network-analyzer.js');
 const NetworkRequest = require('../../lib/network-request.js');
 const pageFunctions = require('../../lib/page-functions.js');
+const {fetchResponseBodyFromCache} = require('../driver/network.js');
 const DevtoolsLog = require('./devtools-log.js');
 
 /* global getNodeDetails */
@@ -30,6 +32,8 @@ function collectAllScriptElements() {
       async: script.async,
       defer: script.defer,
       source: script.closest('head') ? 'head' : 'body',
+      content: script.src ? null : script.text,
+      requestId: null,
       // @ts-expect-error - getNodeDetails put into scope via stringification
       node: getNodeDetails(script),
     };
@@ -37,6 +41,27 @@ function collectAllScriptElements() {
 }
 /* c8 ignore stop */
 
+/**
+ * @template T, U
+ * @param {Array<T>} values
+ * @param {(value: T) => Promise<U>} promiseMapper
+ * @param {boolean} runInSeries
+ * @return {Promise<Array<U>>}
+ */
+async function runInSeriesOrParallel(values, promiseMapper, runInSeries) {
+  if (runInSeries) {
+    const results = [];
+    for (const value of values) {
+      const result = await promiseMapper(value);
+      results.push(result);
+    }
+    return results;
+  } else {
+    const promises = values.map(promiseMapper);
+    return await Promise.all(promises);
+  }
+}
+
 /**
  * @fileoverview Gets JavaScript file contents.
  */
@@ -50,10 +75,13 @@ class ScriptElements extends FRGatherer {
   /**
    * @param {LH.Gatherer.FRTransitionalContext} context
    * @param {LH.Artifacts.NetworkRequest[]} networkRecords
+   * @param {LH.Artifacts['HostFormFactor']} formFactor
    * @return {Promise<LH.Artifacts['ScriptElements']>}
    */
-  async _getArtifact(context, networkRecords) {
+  async _getArtifact(context, networkRecords, formFactor) {
+    const session = context.driver.defaultSession;
     const executionContext = context.driver.executionContext;
+    const mainResource = NetworkAnalyzer.findOptionalMainDocument(networkRecords, context.url);
 
     const scripts = await executionContext.evaluate(collectAllScriptElements, {
       args: [],
@@ -64,16 +92,34 @@ class ScriptElements extends FRGatherer {
       ],
     });
 
+    for (const script of scripts) {
+      if (mainResource && script.content) script.requestId = mainResource.requestId;
+    }
+
     const scriptRecords = networkRecords
-      .filter(record => record.resourceType === NetworkRequest.TYPES.Script)
       // Ignore records from OOPIFs
-      .filter(record => !record.sessionId);
+      .filter(record => !record.sessionId)
+      // Only get the content of script requests
+      .filter(record => record.resourceType === NetworkRequest.TYPES.Script);
+
+    // If run on a mobile device, be sensitive to memory limitations and only request one
+    // record at a time.
+    const scriptRecordContents = await runInSeriesOrParallel(
+      scriptRecords,
+      record => fetchResponseBodyFromCache(session, record.requestId).catch(() => ''),
+      formFactor === 'mobile' /* runInSeries */
+    );
 
     for (let i = 0; i < scriptRecords.length; i++) {
       const record = scriptRecords[i];
+      const content = scriptRecordContents[i];
+      if (!content) continue;
 
       const matchedScriptElement = scripts.find(script => script.src === record.url);
-      if (!matchedScriptElement) {
+      if (matchedScriptElement) {
+        matchedScriptElement.requestId = record.requestId;
+        matchedScriptElement.content = content;
+      } else {
         scripts.push({
           type: null,
           src: record.url,
@@ -81,11 +127,12 @@ class ScriptElements extends FRGatherer {
           async: false,
           defer: false,
           source: 'network',
+          requestId: record.requestId,
+          content,
           node: null,
         });
       }
     }
-
     return scripts;
   }
 
@@ -94,8 +141,9 @@ class ScriptElements extends FRGatherer {
    */
   async getArtifact(context) {
     const devtoolsLog = context.dependencies.DevtoolsLog;
+    const formFactor = context.baseArtifacts.HostFormFactor;
     const networkRecords = await NetworkRecords.request(devtoolsLog, context);
-    return this._getArtifact(context, networkRecords);
+    return this._getArtifact(context, networkRecords, formFactor);
   }
 
   /**
@@ -104,7 +152,8 @@ class ScriptElements extends FRGatherer {
    */
   async afterPass(passContext, loadData) {
     const networkRecords = loadData.networkRecords;
-    return this._getArtifact({...passContext, dependencies: {}}, networkRecords);
+    const formFactor = passContext.baseArtifacts.HostFormFactor;
+    return this._getArtifact({...passContext, dependencies: {}}, networkRecords, formFactor);
   }
 }
 

package/lighthouse-core/gather/gatherers/seo/robots-txt.js

@@ -7,6 +7,25 @@
 
 const FRGatherer = require('../../../fraggle-rock/gather/base-gatherer.js');
 
+/* global fetch, location */
+
+/** @return {Promise<LH.Artifacts['RobotsTxt']>} */
+/* c8 ignore start */
+async function getRobotsTxtContent() {
+  try {
+    const response = await fetch(new URL('/robots.txt', location.href).href);
+    if (!response.ok) {
+      return {status: response.status, content: null};
+    }
+
+    const content = await response.text();
+    return {status: response.status, content};
+  } catch (err) {
+    return {status: null, content: null, errorMessage: err.message};
+  }
+}
+/* c8 ignore stop */
+
 class RobotsTxt extends FRGatherer {
   /** @type {LH.Gatherer.GathererMeta} */
   meta = {
@@ -18,8 +37,17 @@ class RobotsTxt extends FRGatherer {
    * @return {Promise<LH.Artifacts['RobotsTxt']>}
    */
   async getArtifact(passContext) {
-    const {finalUrl} = passContext.baseArtifacts.URL;
-    const robotsUrl = new URL('/robots.txt', finalUrl).href;
+    // Iframe fetcher still has issues with CSPs.
+    // Only use the fetcher if we are fetching over the protocol.
+    if (await passContext.driver.fetcher.shouldUseLegacyFetcher()) {
+      return passContext.driver.executionContext.evaluate(getRobotsTxtContent, {
+        args: [],
+        useIsolation: true,
+      });
+    }
+
+    const robotsUrl = new URL('/robots.txt', passContext.url).href;
+    await passContext.driver.fetcher.enable();
     return passContext.driver.fetcher.fetchResource(robotsUrl)
       .catch(err => ({status: null, content: null, errorMessage: err.message}));
   }

package/lighthouse-core/gather/gatherers/source-maps.js

@@ -88,7 +88,6 @@ class SourceMaps extends FRGatherer {
 
     if (!rawSourceMapUrl) {
       return {
-        scriptId: event.scriptId,
         scriptUrl,
         errorMessage: `Could not resolve map url: ${event.sourceMapURL}`,
       };
@@ -105,14 +104,12 @@ class SourceMaps extends FRGatherer {
         map.sections = map.sections.filter(section => section.map);
       }
       return {
-        scriptId: event.scriptId,
         scriptUrl,
         sourceMapUrl,
         map,
       };
     } catch (err) {
       return {
-        scriptId: event.scriptId,
         scriptUrl,
         sourceMapUrl,
         errorMessage: err.toString(),
@@ -143,6 +140,7 @@ class SourceMaps extends FRGatherer {
    * @return {Promise<LH.Artifacts['SourceMaps']>}
    */
   async getArtifact(context) {
+    await context.driver.fetcher.enable();
     const eventProcessPromises = this._scriptParsedEvents
       .map((event) => this._retrieveMapFromScriptParsedEvent(context.driver, event));
     return Promise.all(eventProcessPromises);

package/lighthouse-core/gather/gatherers/trace-elements.js

@@ -22,6 +22,7 @@ const Trace = require('./trace.js');
 const ProcessedTrace = require('../../computed/processed-trace.js');
 const ProcessedNavigation = require('../../computed/processed-navigation.js');
 const LighthouseError = require('../../lib/lh-error.js');
+const ComputedResponsivenes = require('../../computed/metrics/responsiveness.js');
 
 /** @typedef {{nodeId: number, score?: number, animations?: {name?: string, failureReasonsMask?: number, unsupportedProperties?: string[]}[]}} TraceElementData */
 
@@ -142,6 +143,23 @@ class TraceElements extends FRGatherer {
     return topFive;
   }
 
+  /**
+   * @param {LH.Trace} trace
+   * @param {LH.Gatherer.FRTransitionalContext} context
+   * @return {Promise<TraceElementData|undefined>}
+   */
+  static async getResponsivenessElement(trace, context) {
+    const {settings} = context;
+    try {
+      const responsivenessEvent = await ComputedResponsivenes.request({trace, settings}, context);
+      if (!responsivenessEvent || responsivenessEvent.name === 'FallbackTiming') return;
+      return {nodeId: responsivenessEvent.args.data.nodeId};
+    } catch {
+      // Don't let responsiveness errors sink the rest of the gatherer.
+      return;
+    }
+  }
+
   /**
    * Find the node ids of elements which are animated using the Animation trace events.
    * @param {Array<LH.TraceEvent>} mainThreadEvents
@@ -237,14 +255,15 @@ class TraceElements extends FRGatherer {
 
     const lcpNodeId = largestContentfulPaintEvt?.args?.data?.nodeId;
     const clsNodeData = TraceElements.getTopLayoutShiftElements(mainThreadEvents);
-    const animatedElementData =
-      await this.getAnimatedElements(mainThreadEvents);
+    const animatedElementData = await this.getAnimatedElements(mainThreadEvents);
+    const responsivenessElementData = await TraceElements.getResponsivenessElement(trace, context);
 
     /** @type {Map<string, TraceElementData[]>} */
     const backendNodeDataMap = new Map([
       ['largest-contentful-paint', lcpNodeId ? [{nodeId: lcpNodeId}] : []],
       ['layout-shift', clsNodeData],
       ['animation', animatedElementData],
+      ['responsiveness', responsivenessElementData ? [responsivenessElementData] : []],
     ]);
 
     const traceElements = [];

package/lighthouse-core/gather/gatherers/web-app-manifest.js

@@ -94,8 +94,8 @@ class WebAppManifest extends FRGatherer {
    */
   getArtifact(context) {
     const driver = context.driver;
-    const {finalUrl} = context.baseArtifacts.URL;
-    return WebAppManifest.getWebAppManifest(driver.defaultSession, finalUrl);
+
+    return WebAppManifest.getWebAppManifest(driver.defaultSession, context.url);
   }
 }
 

package/lighthouse-core/index.js

@@ -10,7 +10,6 @@ const log = require('lighthouse-logger');
 const ChromeProtocol = require('./gather/connections/cri.js');
 const Config = require('./config/config.js');
 const URL = require('./lib/url-shim.js');
-const fraggleRock = require('./fraggle-rock/api.js');
 
 /** @typedef {import('./gather/connections/connection.js')} Connection */
 
@@ -34,32 +33,10 @@ const fraggleRock = require('./fraggle-rock/api.js');
  *   they will override any settings in the config.
  * @param {LH.Config.Json=} configJSON Configuration for the Lighthouse run. If
  *   not present, the default config is used.
- * @param {LH.Puppeteer.Page=} page
- * @return {Promise<LH.RunnerResult|undefined>}
- */
-async function lighthouse(url, flags = {}, configJSON, page) {
-  const configContext = {
-    configPath: flags.configPath,
-    settingsOverrides: flags,
-    logLevel: flags.logLevel,
-    hostname: flags.hostname,
-    port: flags.port,
-  };
-  return fraggleRock.navigation(url, {page, config: configJSON, configContext});
-}
-
-/**
- * Run Lighthouse using the legacy navigation runner.
- * This is left in place for any clients that don't support FR navigations yet (e.g. Lightrider)
- * @param {string=} url The URL to test. Optional if running in auditMode.
- * @param {LH.Flags=} flags Optional settings for the Lighthouse run. If present,
- *   they will override any settings in the config.
- * @param {LH.Config.Json=} configJSON Configuration for the Lighthouse run. If
- *   not present, the default config is used.
  * @param {Connection=} userConnection
  * @return {Promise<LH.RunnerResult|undefined>}
  */
-async function legacyNavigation(url, flags = {}, configJSON, userConnection) {
+async function lighthouse(url, flags = {}, configJSON, userConnection) {
   // set logging preferences, assume quiet
   flags.logLevel = flags.logLevel || 'error';
   log.setLevel(flags.logLevel);
@@ -89,12 +66,11 @@ function generateConfig(configJson, flags) {
   return new Config(configJson, flags);
 }
 
-lighthouse.legacyNavigation = legacyNavigation;
 lighthouse.generateConfig = generateConfig;
 lighthouse.getAuditList = Runner.getAuditList;
 lighthouse.traceCategories = require('./gather/driver.js').traceCategories;
 lighthouse.Audit = require('./audits/audit.js');
-lighthouse.Gatherer = require('./fraggle-rock/gather/base-gatherer.js');
+lighthouse.Gatherer = require('./gather/gatherers/gatherer.js');
 
 // Explicit type reference (hidden by makeComputedArtifact) for d.ts export.
 // TODO(esmodules): should be a workaround for module.export and can be removed when in esm.

package/lighthouse-core/lib/cdt/generated/SourceMap.js

@@ -149,7 +149,7 @@ class TextSourceMap {
         }
         return mappings.slice(startIndex, endIndex);
     }
-    /** @return {Array<{lineNumber: number, columnNumber: number, sourceURL?: string, sourceLineNumber: number, sourceColumnNumber: number, name?: string, lastColumnNumber?: number}>} */
+    /** @return {Array<{lineNumber: number, columnNumber: number, sourceURL?: string, sourceLineNumber, sourceColumnNumber: number, name?: string, lastColumnNumber?: number}>} */
 mappings() {
         if (this.mappingsInternal === null) {
             this.mappingsInternal = [];

package/lighthouse-core/lib/dependency-graph/simulator/network-analyzer.js

@@ -6,6 +6,7 @@
 'use strict';
 
 const INITIAL_CWD = 14 * 1024;
+const NetworkRequest = require('../../network-request.js');
 const URL = require('../../url-shim.js');
 
 // Assume that 40% of TTFB was server response time by default for static assets
@@ -433,20 +434,40 @@ class NetworkAnalyzer {
 
   /**
    * @param {Array<LH.Artifacts.NetworkRequest>} records
-   * @param {string} resourceUrl
+   * @param {string} [finalURL]
+   * @return {LH.Artifacts.NetworkRequest}
+   */
+  static findMainDocument(records, finalURL) {
+    const mainDocument = NetworkAnalyzer.findOptionalMainDocument(records, finalURL);
+    if (!mainDocument) throw new Error('Unable to identify the main resource');
+    return mainDocument;
+  }
+
+  /**
+   * @param {Array<LH.Artifacts.NetworkRequest>} records
+   * @param {string} [finalURL]
    * @return {LH.Artifacts.NetworkRequest|undefined}
    */
-  static findResourceForUrl(records, resourceUrl) {
-    // equalWithExcludedFragments is expensive, so check that the resourceUrl starts with the request url first
-    return records.find(request =>
-      resourceUrl.startsWith(request.url) &&
-      URL.equalWithExcludedFragments(request.url, resourceUrl)
-    );
+  static findOptionalMainDocument(records, finalURL) {
+    // Try to find an exact match with the final URL first if we have one
+    if (finalURL) {
+      // equalWithExcludedFragments is expensive, so check that the finalUrl starts with the request first
+      const mainResource = records.find(request => finalURL.startsWith(request.url) &&
+        URL.equalWithExcludedFragments(request.url, finalURL));
+      if (mainResource) return mainResource;
+      // TODO: beacon !mainResource to Sentry, https://github.com/GoogleChrome/lighthouse/issues/7041
+    }
+
+    const documentRequests = records.filter(record => record.resourceType ===
+        NetworkRequest.TYPES.Document);
+    if (!documentRequests.length) return undefined;
+    // The main document is the earliest document request, using position in networkRecords array to break ties.
+    return documentRequests.reduce((min, r) => (r.startTime < min.startTime ? r : min));
   }
 
   /**
    * Resolves redirect chain given a main document.
-   * See: {@link NetworkAnalyzer.findResourceForUrl}) for how to retrieve main document.
+   * See: {@link NetworkAnalyzer.findMainDocument}) for how to retrieve main document.
    *
    * @param {LH.Artifacts.NetworkRequest} request
    * @return {LH.Artifacts.NetworkRequest}

package/lighthouse-core/lib/navigation-error.js

@@ -7,7 +7,6 @@
 
 const LHError = require('./lh-error.js');
 const NetworkAnalyzer = require('./dependency-graph/simulator/network-analyzer.js');
-const NetworkRequest = require('./network-request.js');
 
 /**
  * Returns an error if the original network request failed or wasn't found.
@@ -101,18 +100,10 @@ function getNonHtmlError(finalRecord) {
 function getPageLoadError(navigationError, context) {
   const {url, loadFailureMode, networkRecords} = context;
   /** @type {LH.Artifacts.NetworkRequest|undefined} */
-  let mainRecord = NetworkAnalyzer.findResourceForUrl(networkRecords, url);
-
-  // If the url doesn't give us a network request, it's possible we landed on a chrome-error:// page
-  // In this case, just get the first document request.
-  if (!mainRecord) {
-    const documentRequests = networkRecords.filter(record =>
-      record.resourceType === NetworkRequest.TYPES.Document
-    );
-    if (documentRequests.length) {
-      mainRecord = documentRequests.reduce((min, r) => (r.startTime < min.startTime ? r : min));
-    }
-  }
+  let mainRecord;
+  try {
+    mainRecord = NetworkAnalyzer.findMainDocument(networkRecords, url);
+  } catch (_) {}
 
   // MIME Type is only set on the final redirected document request. Use this for the HTML check instead of root.
   let finalRecord;

package/lighthouse-core/lib/script-helpers.js

@@ -5,25 +5,20 @@
  */
 'use strict';
 
-/**
- * @param {LH.Artifacts.Script} script
- * @return {boolean}
- */
-function isInline(script) {
-  return Boolean(script.startLine || script.startColumn);
-}
-
 /**
  * @param {LH.Artifacts.NetworkRequest[]} networkRecords
- * @param {LH.Artifacts.Script} script
+ * @param {LH.Artifacts.ScriptElement|undefined} script
  * @return {LH.Artifacts.NetworkRequest|undefined}
  */
 function getRequestForScript(networkRecords, script) {
-  let networkRequest = networkRecords.find(request => request.url === script.url);
+  if (!script) return;
+  let networkRequest = script.requestId &&
+    networkRecords.find(request => request.requestId === script.requestId);
+  if (!networkRequest) networkRequest = networkRecords.find(request => request.url === script.src);
   while (networkRequest?.redirectDestination) {
     networkRequest = networkRequest.redirectDestination;
   }
   return networkRequest;
 }
 
-module.exports = {getRequestForScript, isInline};
+module.exports = {getRequestForScript};

package/lighthouse-core/lib/url-shim.js

@@ -236,9 +236,9 @@ class URLShim extends URL {
     }
 
     if (url.protocol === 'data:') {
-      const match = url.pathname.match(/^(image\/(png|jpeg|svg\+xml|webp|gif|avif))[;,]/);
+      const match = url.pathname.match(/image\/(png|jpeg|svg\+xml|webp|gif|avif)(?=;)/);
       if (!match) return undefined;
-      return match[1];
+      return match[0];
     }
 
     const match = url.pathname.toLowerCase().match(/\.(png|jpeg|jpg|svg|webp|gif|avif)$/);

package/lighthouse-core/runner.js

@@ -158,6 +158,11 @@ class Runner {
         // No browser required, just load the artifacts from disk.
         const path = this._getDataSavePath(settings);
         artifacts = assetSaver.loadArtifacts(path);
+        const requestedUrl = artifacts.URL.requestedUrl;
+
+        if (!requestedUrl) {
+          throw new Error('Cannot run audit mode on empty URL');
+        }
       } else {
         const runnerStatus = {msg: 'Gather phase', id: 'lh:runner:gather'};
         log.time(runnerStatus, 'verbose');

package/lighthouse-core/scripts/manual-chrome-launcher.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 
+'use strict';
 
 /**
  * @fileoverview Script to launch a clean Chrome instance on-demand.