lighthouse 13.5.0 → 13.6.0-dev.20261028

package/core/lib/deprecations-strings.js

@@ -72,6 +72,10 @@ export const UIStrings = {
    * @description Translation is not needed, this will never be exposed in production code.
    */
   ExampleBrowserProcessDeprecation: "This is an example for showing the code required for a browser process reported deprecation.",
+  /**
+   * @description Warning displayed to developers that they are using the Fenced Frame API which has been deprecated and is scheduled to be removed.
+   */
+  FencedFrame: "Fenced Frame API is deprecated and scheduled for removal.",
   /**
    * @description A deprecation warning shown in the DevTools Issues tab. It's shown when one of the Protected Audience APIs like `navigator.joinAdInterestGroup`, `navigator.getInterestGroupAdAuctionData` or `navigator.runAdAuction` are called.
    */
@@ -240,6 +244,10 @@ export const UIStrings = {
    * @description A deprecation warning shown in the DevTools Issues tab. It's shown when a video conferencing website uses a non-standard API for controlling the crypto method used, but is not having an effect because the desired behavior is already enabled-by-default.
    */
   RTCConstraintEnableDtlsSrtpTrue: "The constraint `DtlsSrtpKeyAgreement` is removed. You have specified a `true` value for this constraint, which had no effect, but you can remove this constraint for tidiness.",
+  /**
+   * @description Warning displayed to developers when the non-standard RTCPeerConnection.createDTMFSender() method is used. Developers should use the standard RTCRtpSender.dtmf attribute instead.
+   */
+  RTCPeerConnectionCreateDTMFSender: "RTCPeerConnection.createDTMFSender() is deprecated and will be removed. Please use RTCRtpSender.dtmf instead.",
   /**
    * @description WebRTC is set of JavaScript APIs for sending and receiving data, audio and video. getStats() is a method used to obtain network and quality metrics. There are two versions of this method, one is being deprecated because it is non-standard.
    */
@@ -252,14 +260,6 @@ export const UIStrings = {
    * @description A deprecation warning shown in the DevTools Issues tab. The placeholder is always the noun 'SharedArrayBuffer' which refers to a JavaScript construct.
    */
   SharedArrayBufferConstructedWithoutIsolation: "`SharedArrayBuffer` will require cross-origin isolation. See https://developer.chrome.com/blog/enabling-shared-array-buffer/ for more details.",
-  /**
-   * @description A deprecation warning shown in the DevTools Issues tab. It's shown when one of the Shared Storage APIs like `sharedStorage.set()`, `sharedStorage.worklet.addModule()`, `sharedStorage.selectURL()`, etc., along with `<img sharedstoragewritable>`, `<iframe sharedstoragewritable>`, or `fetch(url, {sharedStorageWritable: true})` are used.
-   */
-  SharedStorage: "The Shared Storage API is deprecated and will be removed in a future release.",
-  /**
-   * @description A deprecation warning shown in the DevTools Issues tab. It's shown when the `document.requestStorageAccessFor` API is called. The placeholder will always be the string `document.requestStorageAccessFor`.
-   */
-  StorageAccessAPI_requestStorageAccessFor_Method: "`document.requestStorageAccessFor` is deprecated and will be removed. See https://privacysandbox.com/news/update-on-plans-for-privacy-sandbox-technologies/ for more details.",
   /**
    * @description A deprecation warning shown in the DevTools Issues tab. It's shown when the speech synthesis API is called before the page receives a user activation.
    */
@@ -276,6 +276,10 @@ export const UIStrings = {
    * @description A deprecation warning shown in the DevTools Issues tab. The placeholder is always the noun 'SharedArrayBuffer' which refers to a JavaScript construct. 'Extensions' refers to Chrome extensions. The warning is shown when Chrome Extensions attempt to use 'SharedArrayBuffer's under insecure circumstances.
    */
   V8SharedArrayBufferConstructedInExtensionWithoutIsolation: "Extensions should opt into cross-origin isolation to continue using `SharedArrayBuffer`. See https://developer.chrome.com/docs/extensions/mv3/cross-origin-isolation/.",
+  /**
+   * @description Warning displayed to developers when an SVG filter is applied to view transition content, which is disallowed because the content may contain cross-origin iframes or plugins. `::view-transition-old()` and `::view-transition-new()` are CSS pseudo-element names and should not be translated.
+   */
+  ViewTransitionPreventSvgFilterPaint: "SVG filters cannot be applied to view transition content, such as `::view-transition-old()` and `::view-transition-new()`, as it may contain cross-origin iframes or plugins.",
   /**
    * @description This warning occurs when the deprecated `BluetoothRemoteGATTCharacteristic.writeValue()` method is used. Developers should use `writeValueWithResponse()` or `writeValueWithoutResponse()` instead.
    */
@@ -350,6 +354,10 @@ export const DEPRECATIONS_METADATA = {
     "chromeStatusFeature": 5095987863486464,
     "milestone": 151
   },
+  "FencedFrame": {
+    "chromeStatusFeature": 6366274495053824,
+    "milestone": 156
+  },
   "IdentityInCanMakePaymentEvent": {
     "chromeStatusFeature": 5190978431352832
   },
@@ -420,6 +428,10 @@ export const DEPRECATIONS_METADATA = {
   "RTCConstraintEnableDtlsSrtpTrue": {
     "milestone": 97
   },
+  "RTCPeerConnectionCreateDTMFSender": {
+    "chromeStatusFeature": 5160724576993280,
+    "milestone": 160
+  },
   "RTCPeerConnectionGetStatsLegacyNonCompliant": {
     "chromeStatusFeature": 4631626228695040,
     "milestone": 117
@@ -437,12 +449,6 @@ export const DEPRECATIONS_METADATA = {
   "SharedArrayBufferConstructedWithoutIsolation": {
     "milestone": 106
   },
-  "SharedStorage": {
-    "chromeStatusFeature": 5076349064708096
-  },
-  "StorageAccessAPI_requestStorageAccessFor_Method": {
-    "chromeStatusFeature": 5162221567082496
-  },
   "TextToSpeech_DisallowedByAutoplay": {
     "chromeStatusFeature": 5687444770914304,
     "milestone": 71

package/core/lib/i18n/i18n.d.ts

@@ -1,4 +1,3 @@
-export type LhlMessages = import("../../../shared/localization/locales").LhlMessages;
 export namespace UIStrings {
     let ms: string;
     let seconds: string;
@@ -78,4 +77,6 @@ export function createIcuMessageFn(filename: string, fileStrings?: Record<string
  * @return {value is string|LH.IcuMessage}
  */
 export function isStringOrIcuMessage(value: unknown): value is string | LH.IcuMessage;
+import { registerLocaleData } from '../../../shared/localization/format.js';
+export { registerLocaleData };
 //# sourceMappingURL=i18n.d.ts.map

package/core/lib/i18n/i18n.js

@@ -4,18 +4,19 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-/** @typedef {import('../../../shared/localization/locales').LhlMessages} LhlMessages */
-
 import path from 'path';
 import url from 'url';
 
-import lookupClosestLocale from 'lookup-closest-locale';
 import log from 'lighthouse-logger';
 
-import {getAvailableLocales} from '../../../shared/localization/format.js';
+import {
+  getAvailableLocales,
+  isIcuMessage,
+  formatMessage,
+  registerLocaleData,
+  DEFAULT_LOCALE,
+} from '../../../shared/localization/format.js';
 import {LH_ROOT} from '../../../shared/root.js';
-import {isIcuMessage, formatMessage, DEFAULT_LOCALE} from '../../../shared/localization/format.js';
-import {getModulePath} from '../../../shared/esm-utils.js';
 
 const UIStrings = {
   /** Used to show the duration in milliseconds that something lasted. The `{timeInMs}` placeholder will be replaced with the time duration, shown in milliseconds (e.g. 63 ms) */
@@ -145,12 +146,22 @@ function lookupLocale(locales, possibleLocales) {
   // Filter by what's available in this runtime.
   const availableLocales = Intl.NumberFormat.supportedLocalesOf(canonicalLocales);
 
-  // Get available locales and transform into object to match `lookupClosestLocale`'s API.
-  const localesWithMessages = possibleLocales || getAvailableLocales();
-  const localesWithmessagesObj = /** @type {Record<LH.Locale, LhlMessages>} */ (
-    Object.fromEntries(localesWithMessages.map(l => [l, {}])));
-
-  const closestLocale = lookupClosestLocale(availableLocales, localesWithmessagesObj);
+  const localesWithMessages = new Set(possibleLocales || getAvailableLocales());
+
+  /** @type {LH.Locale|undefined} */
+  let closestLocale;
+  for (const locale of availableLocales) {
+    const parts = locale.split('-');
+    while (parts.length) {
+      const candidate = /** @type {LH.Locale} */ (parts.join('-'));
+      if (localesWithMessages.has(candidate)) {
+        closestLocale = candidate;
+        break;
+      }
+      parts.pop();
+    }
+    if (closestLocale) break;
+  }
 
   if (!closestLocale) {
     // Log extra info if we're pretty sure this version of Node was built with `--with-intl=small-icu`.
@@ -198,7 +209,7 @@ function createIcuMessageFn(filename, fileStrings = {}) {
     // one of the common strings found in `i18n.UIStrings`.
     const filenameToLookup = keyname in fileStrings ?
       filename :
-      path.relative(LH_ROOT, getModulePath(import.meta));
+      path.relative(LH_ROOT, import.meta.filename);
     const unixStyleFilename = filenameToLookup.replace(/\\/g, '/');
     const i18nId = `${unixStyleFilename} | ${keyname}`;
 
@@ -226,4 +237,5 @@ export {
   lookupLocale,
   createIcuMessageFn,
   isStringOrIcuMessage,
+  registerLocaleData,
 };

package/core/lib/legacy-javascript/legacy-javascript.d.ts

@@ -2,6 +2,7 @@ export type Pattern = {
     name: string;
     expression: string;
     estimateBytes?: (content: string) => number;
+    resolveName?: (match: string) => string;
 };
 export type PatternMatchResult = {
     name: string;
@@ -14,10 +15,10 @@ export type Result = {
 };
 /**
  * @param {string} content
- * @param {import('../cdt/generated/SourceMap.js')|null} map
+ * @param {import('../cdt/generated/SourceMap.js').default|null} map
  * @return {Result}
  */
-export function detectLegacyJavaScript(content: string, map: import("../cdt/generated/SourceMap.js") | null): Result;
+export function detectLegacyJavaScript(content: string, map: import("../cdt/generated/SourceMap.js").default | null): Result;
 /**
  * @return {Pattern[]}
  */

package/core/lib/legacy-javascript/legacy-javascript.js

@@ -11,7 +11,7 @@
  * ./core/scripts/legacy-javascript - verification tool.
  */
 
-/** @typedef {{name: string, expression: string, estimateBytes?: (content: string) => number}} Pattern */
+/** @typedef {{name: string, expression: string, estimateBytes?: (content: string) => number, resolveName?: (match: string) => string}} Pattern */
 /** @typedef {{name: string, line: number, column: number}} PatternMatchResult */
 /** @typedef {{matches: PatternMatchResult[], estimatedByteSavings: number}} Result */
 
@@ -27,7 +27,7 @@ const graph = graph_;
 /**
  * Takes a list of patterns (consisting of a name identifier and a RegExp expression string)
  * and via `match` returns match results with line / column information for a given code input.
- * Only returns the first match per pattern given.
+ * Only returns the first match per pattern name.
  */
 class CodePatternMatcher {
   /**
@@ -45,12 +45,13 @@ class CodePatternMatcher {
     if (!this.re) {
       const patternsExpression =
         this.patterns.map(pattern => `(${pattern.expression})`).join('|');
-      this.re = new RegExp(`(^\r\n|\r|\n)|${patternsExpression}`, 'g');
+      this.re = new RegExp(patternsExpression, 'g');
     }
 
     // Reset RegExp state.
     this.re.lastIndex = 0;
 
+    /** @type {Set<string>} */
     const seen = new Set();
     /** @type {PatternMatchResult[]} */
     const matches = [];
@@ -58,29 +59,41 @@ class CodePatternMatcher {
     let result;
     let line = 0;
     let lineBeginsAtIndex = 0;
+    let scannedToIndex = 0;
     // Each pattern maps to one subgroup in the generated regex. For each iteration of RegExp.exec,
     // only one subgroup will be defined. Exec until no more matches.
     while ((result = this.re.exec(code)) !== null) {
-      // Discard first value in `result` - it's just the entire match.
-      const captureGroups = result.slice(1);
-      // isNewline - truthy if matching a newline, used to track the line number.
-      // `patternExpressionMatches` maps to each possible pattern in `this.patterns`.
-      // Only one of [isNewline, ...patternExpressionMatches] is ever truthy.
-      const [isNewline, ...patternExpressionMatches] = captureGroups;
-      if (isNewline) {
-        line++;
-        lineBeginsAtIndex = result.index + 1;
-        continue;
+      let patternIndex = -1;
+      for (let i = 1; i < result.length; i++) {
+        if (result[i] !== undefined) {
+          patternIndex = i - 1;
+          break;
+        }
       }
-      const pattern = this.patterns[patternExpressionMatches.findIndex(Boolean)];
+      if (patternIndex === -1) continue;
 
-      if (seen.has(pattern)) {
+      const pattern = this.patterns[patternIndex];
+      const name = pattern.resolveName ? pattern.resolveName(result[0]) : pattern.name;
+      if (seen.has(name)) {
         continue;
       }
-      seen.add(pattern);
+      seen.add(name);
+
+      // Lazily advance line and column tracking up to `result.index`.
+      // Because `[scannedToIndex, result.index)` includes the text of any previous matches,
+      // this also accounts for newlines inside multi-line matches.
+      // Scanning for `\n` handles both LF (`\n`) and CRLF (`\r\n`) line endings since
+      // the next line always begins at `nlIdx + 1`.
+      let nlIdx = code.indexOf('\n', scannedToIndex);
+      while (nlIdx !== -1 && nlIdx < result.index) {
+        line++;
+        lineBeginsAtIndex = nlIdx + 1;
+        nlIdx = code.indexOf('\n', lineBeginsAtIndex);
+      }
+      scannedToIndex = result.index;
 
       matches.push({
-        name: pattern.name,
+        name,
         line,
         column: result.index - lineBeginsAtIndex,
       });
@@ -90,70 +103,6 @@ class CodePatternMatcher {
   }
 }
 
-/**
- * @param {string?} object
- * @param {string} property
- * @param {string} coreJs3Module
- */
-function buildPolyfillExpression(object, property, coreJs3Module) {
-  const qt = (/** @type {string} */ token) =>
-    `['"]${token}['"]`; // don't worry about matching string delims
-
-  let expression = '';
-
-  if (object) {
-    // String.prototype.startsWith =
-    expression += `${object}\\.${property}\\s?=[^=]`;
-  } else {
-    // Promise =
-    // window.Promise =// Promise =Z
-    // but not: SomePromise =
-    expression += `(?:window\\.|[\\s;]+)${property}\\s?=[^=]`;
-  }
-
-  // String.prototype['startsWith'] =
-  if (object) {
-    expression += `|${object}\\[${qt(property)}\\]\\s?=[^=]`;
-  }
-
-  // Object.defineProperty(String.prototype, 'startsWith'
-  expression += `|defineProperty\\(${object || 'window'},\\s?${qt(property)}`;
-
-  // es-shims
-  // no(Object,{entries:r},{entries:function
-  if (object) {
-    expression += `|\\(${object},\\s*{${property}:.*},\\s*{${property}`;
-  }
-
-  // core-js
-  if (object) {
-    const objectWithoutPrototype = object.replace('.prototype', '');
-    // e(e.S,"Object",{values
-    // Minified + mangled pattern found in CDN babel-polyfill.
-    // see https://cdnjs.cloudflare.com/ajax/libs/babel-polyfill/7.2.5/polyfill.min.js
-    // TODO: perhaps this is the wrong place to check for a CDN polyfill. Remove?
-    // expression += `|;e\\([^,]+,${qt(objectWithoutPrototype)},{${property}:`;
-
-    // core-js@3 minified pattern.
-    // {target:"Array",proto:true},{fill:fill
-    // {target:"Array",proto:true,forced:!HAS_SPECIES_SUPPORT||!USES_TO_LENGTH},{filter:
-    expression += `|{target:${qt(objectWithoutPrototype)}[^;]*},{${property}:`;
-  } else {
-    // Detect polyfills for new classes: Map, Set, WeakSet, etc.
-    // TODO: so far, no class polyfills are enabled for detection.
-    // See `modulesToSkip` in create-polyfill-module-data.js
-
-    // collection("Map",
-    // expression += `|collection\\(${qt(property)},`;
-  }
-
-  // Un-minified code may have module names.
-  // core-js/modules/es.object.is-frozen
-  expression += `|${coreJs3Module.replaceAll('.', '\\.')}(?:\\.js)?"`;
-
-  return expression;
-}
-
 function getCoreJsPolyfillData() {
   return polyfillModuleData.filter(d => d.corejs).map(d => {
     return {
@@ -164,34 +113,171 @@ function getCoreJsPolyfillData() {
 }
 
 /**
+ * Builds factored polyfill patterns grouped by receiver object, core-js target, and
+ * core-js module prefix so the regex engine evaluates a few shared branches instead
+ * of repeating common prefixes (like `defineProperty(`, `{target:`, `Array.prototype.`)
+ * once per polyfill.
+ *
  * @return {Pattern[]}
  */
 function getPolyfillPatterns() {
-  /** @type {Pattern[]} */
-  const patterns = [];
+  /** @param {string} str */
+  const escapeRegExp = str => str.replaceAll('.', '\\.');
+
+  /** @type {Map<string, string[]>} */
+  const byObject = new Map();
+  /** @type {Map<string, string[]>} */
+  const byTarget = new Map();
+  /** @type {Map<string, string>} */
+  const targetPropToName = new Map();
+  /** @type {Map<string, string>} */
+  const coreJsModuleToName = new Map();
+  /** @type {Map<string, string[]>} */
+  const byModulePrefix = new Map();
 
   for (const {name, coreJs3Module} of getCoreJsPolyfillData()) {
     const parts = name.split('.');
-    const object = parts.length > 1 ? parts.slice(0, parts.length - 1).join('.') : null;
+    const object = parts.slice(0, parts.length - 1).join('.');
     const property = parts[parts.length - 1];
-    patterns.push({
-      name,
-      expression: buildPolyfillExpression(object, property, coreJs3Module),
-    });
+
+    let objProps = byObject.get(object);
+    if (!objProps) {
+      objProps = [];
+      byObject.set(object, objProps);
+    }
+    objProps.push(property);
+
+    const target = object.replace('.prototype', '');
+    let targetProps = byTarget.get(target);
+    if (!targetProps) {
+      targetProps = [];
+      byTarget.set(target, targetProps);
+    }
+    targetProps.push(property);
+    targetPropToName.set(`${target}.${property}`, name);
+
+    coreJsModuleToName.set(coreJs3Module, name);
+    const modParts = coreJs3Module.split('.');
+    const modPrefix = modParts.slice(0, 2).join('.');
+    const modRest = modParts.slice(2).join('.');
+    let modRests = byModulePrefix.get(modPrefix);
+    if (!modRests) {
+      modRests = [];
+      byModulePrefix.set(modPrefix, modRests);
+    }
+    modRests.push(modRest);
+  }
+
+  // 1. Direct property assignment: `String.prototype.startsWith =`
+  const directBranches = [];
+  for (const [object, props] of byObject) {
+    directBranches.push(`${escapeRegExp(object)}\\.(?:${props.join('|')})\\s?=[^=]`);
+  }
+
+  // 2. Bracket property assignment: `String.prototype['startsWith'] =`
+  const bracketBranches = [];
+  for (const [object, props] of byObject) {
+    bracketBranches.push(`${escapeRegExp(object)}\\[['"](?:${props.join('|')})['"]\\]\\s?=[^=]`);
+  }
+
+  // 3. Object.defineProperty: `Object.defineProperty(String.prototype, 'startsWith'`
+  const definePropBranches = [];
+  for (const [object, props] of byObject) {
+    definePropBranches.push(`${escapeRegExp(object)},\\s?['"](?:${props.join('|')})['"]`);
+  }
+
+  // 4. es-shims: `no(Object,{entries:r},{entries:function`
+  const esShimsBranches = [];
+  for (const [object, props] of byObject) {
+    const propBranches = props.map(p => `${p}:[^};]*},\\s*{${p}\\b`).join('|');
+    esShimsBranches.push(`${escapeRegExp(object)},\\s*{(?:${propBranches})`);
+  }
+
+  // 5. core-js@3 minified pattern:
+  // `{target:"Array",proto:true},{fill:fill`
+  // `{target:"Array",proto:true,forced:!HAS_SPECIES_SUPPORT||!USES_TO_LENGTH},{filter:`
+  const targetBranches = [];
+  for (const [target, props] of byTarget) {
+    targetBranches.push(`['"]${escapeRegExp(target)}['"][^;]*?},{(?:${props.join('|')}):`);
+  }
+
+  // 6. Un-minified core-js module names: `core-js/modules/es.object.is-frozen`
+  const moduleBranches = [];
+  for (const [prefix, rests] of byModulePrefix) {
+    moduleBranches.push(
+      `${escapeRegExp(prefix)}\\.(?:${rests.map(escapeRegExp).join('|')})`
+    );
   }
 
-  return patterns;
+  return [
+    {
+      name: 'direct-assignment',
+      expression: directBranches.join('|'),
+      resolveName: match => match.slice(0, match.indexOf('=')).trimEnd(),
+    },
+    {
+      name: 'bracket-assignment',
+      expression: bracketBranches.join('|'),
+      resolveName: match => {
+        const bracketIdx = match.indexOf('[');
+        const closeIdx = match.indexOf(']', bracketIdx);
+        return `${match.slice(0, bracketIdx)}.${match.slice(bracketIdx + 2, closeIdx - 1)}`;
+      },
+    },
+    {
+      name: 'defineProperty',
+      expression: `defineProperty\\((?:${definePropBranches.join('|')})`,
+      resolveName: match => {
+        const openIdx = match.indexOf('(');
+        const commaIdx = match.indexOf(',', openIdx);
+        const obj = match.slice(openIdx + 1, commaIdx);
+        const prop = match.slice(commaIdx + 1).trimStart().slice(1, -1);
+        return `${obj}.${prop}`;
+      },
+    },
+    {
+      name: 'es-shims',
+      expression: `\\((?:${esShimsBranches.join('|')})`,
+      resolveName: match => {
+        const commaIdx = match.indexOf(',');
+        const obj = match.slice(1, commaIdx);
+        const braceIdx = match.indexOf('{', commaIdx);
+        const colonIdx = match.indexOf(':', braceIdx);
+        const prop = match.slice(braceIdx + 1, colonIdx);
+        return `${obj}.${prop}`;
+      },
+    },
+    {
+      name: 'core-js-target',
+      expression: `{target:(?:${targetBranches.join('|')})`,
+      resolveName: match => {
+        const targetEnd = match.indexOf(match[8], 9);
+        const target = match.slice(9, targetEnd);
+        const lastBrace = match.lastIndexOf('{');
+        const prop = match.slice(lastBrace + 1, -1);
+        return /** @type {string} */ (targetPropToName.get(`${target}.${prop}`));
+      },
+    },
+    {
+      name: 'core-js-module',
+      expression: `(?:${moduleBranches.join('|')})(?:\\.js)?"`,
+      resolveName: match => {
+        const mod = match.endsWith('.js"') ? match.slice(0, -4) : match.slice(0, -1);
+        return /** @type {string} */ (coreJsModuleToName.get(mod));
+      },
+    },
+  ];
 }
 
 /**
  * @return {Pattern[]}
  */
 function getTransformPatterns() {
-/**
- * @param {string} content
- * @param {RegExp|string} pattern
- * @return {number}
- */
+  /**
+   * @param {string} content
+   * @param {RegExp|string} pattern
+   * @return {number}
+   */
   const count = (content, pattern) => {
     // Split is slightly faster than match.
     if (typeof pattern === 'string') {
@@ -259,6 +345,17 @@ function getTransformPatterns() {
   ];
 }
 
+const transformPatterns = getTransformPatterns();
+const transformPatternsByName = new Map(transformPatterns.map(p => [p.name, p]));
+
+/** @type {Map<string, string>} */
+const moduleToPolyfillName = new Map();
+for (const {name, modules} of polyfillModuleData) {
+  for (const mod of modules) {
+    moduleToPolyfillName.set(mod, name);
+  }
+}
+
 /**
  * @param {string} content
  * @param {PatternMatchResult[]} matches
@@ -287,7 +384,7 @@ function estimateWastedBytes(content, matches) {
   let estimatedWastedBytesFromTransforms = 0;
 
   for (const result of transformResults) {
-    const pattern = getTransformPatterns().find(p => p.name === result.name);
+    const pattern = transformPatternsByName.get(result.name);
     if (!pattern || !pattern.estimateBytes || !content) continue;
     estimatedWastedBytesFromTransforms += pattern.estimateBytes(content);
   }
@@ -299,12 +396,12 @@ function estimateWastedBytes(content, matches) {
 
 const matcher = new CodePatternMatcher([
   ...getPolyfillPatterns(),
-  ...getTransformPatterns(),
+  ...transformPatterns,
 ]);
 
 /**
  * @param {string} content
- * @param {import('../cdt/generated/SourceMap.js')|null} map
+ * @param {import('../cdt/generated/SourceMap.js').default|null} map
  * @return {Result}
  */
 function detectLegacyJavaScript(content, map) {
@@ -315,20 +412,47 @@ function detectLegacyJavaScript(content, map) {
 
   // If it's a bundle with source maps, add in the polyfill modules by name too.
   if (map) {
-    for (const {name, modules} of polyfillModuleData) {
-      // Skip if the pattern matching found a match for this polyfill.
-      if (matches.some(m => m.name === name)) continue;
-
-      const source = map.sourceURLs().find(source => modules.some(module => {
-        return source.endsWith(`/${module}.js`) || source.includes(`node_modules/${module}/`);
-      }));
-      if (!source) continue;
-
-      const mapping = map.mappings().find(m => m.sourceURL === source);
-      if (mapping) {
-        matches.push({name, line: mapping.lineNumber, column: mapping.columnNumber});
-      } else {
-        matches.push({name, line: 0, column: 0});
+    const matchedNames = new Set(matches.map(m => m.name));
+    /** @type {Array<{name: string, source: string}>} */
+    const foundInMap = [];
+
+    for (const source of map.sourceURLs()) {
+      if (source.endsWith('.js')) {
+        const slashIdx = source.lastIndexOf('/');
+        if (slashIdx !== -1) {
+          const polyfillName = moduleToPolyfillName.get(source.slice(slashIdx + 1, -3));
+          if (polyfillName && !matchedNames.has(polyfillName)) {
+            matchedNames.add(polyfillName);
+            foundInMap.push({name: polyfillName, source});
+          }
+        }
+      }
+      if (source.includes('node_modules/')) {
+        let nmIdx = source.indexOf('node_modules/');
+        while (nmIdx !== -1) {
+          const modStart = nmIdx + 13; // 'node_modules/'.length
+          const nextSlash = source.indexOf('/', modStart);
+          if (nextSlash !== -1) {
+            const polyfillName = moduleToPolyfillName.get(source.slice(modStart, nextSlash));
+            if (polyfillName && !matchedNames.has(polyfillName)) {
+              matchedNames.add(polyfillName);
+              foundInMap.push({name: polyfillName, source});
+            }
+          }
+          nmIdx = source.indexOf('node_modules/', modStart);
+        }
+      }
+    }
+
+    if (foundInMap.length > 0) {
+      const mappings = map.mappings();
+      for (const {name, source} of foundInMap) {
+        const mapping = mappings.find(m => m.sourceURL === source);
+        if (mapping) {
+          matches.push({name, line: mapping.lineNumber, column: mapping.columnNumber});
+        } else {
+          matches.push({name, line: 0, column: 0});
+        }
       }
     }
   }