chrome-devtools-frontend 1.0.1616061 → 1.0.1621064

package/front_end/third_party/web-vitals/package/README.md

@@ -324,7 +324,7 @@ While `web-vitals` can be called directly from Google Tag Manager, using a pre-d
 
 ### Send attribution data
 
-When using the [attribution build](#attribution-build), you can send additional data to help you debug _why_ the metric values are they way they are.
+When using the [attribution build](#attribution-build), you can send additional data to help you debug _why_ the metric values are the way they are.
 
 This example sends an additional `debug_target` param to Google Analytics, corresponding to the element most associated with each metric.
 
@@ -349,7 +349,7 @@ function sendToGoogleAnalytics({name, delta, value, id, attribution}) {
       eventParams.debug_target = attribution.interactionTarget;
       break;
     case 'LCP':
-      eventParams.debug_target = attribution.element;
+      eventParams.debug_target = attribution.target;
       break;
   }
 
@@ -481,7 +481,7 @@ The following table lists all the builds distributed with the `web-vitals` packa
 
 Most developers will generally want to use "standard" build (via either the ES module or UMD version, depending on your bundler/build system), as it's the easiest to use out of the box and integrate into existing tools.
 
-However, if you'd lke to collect additional debug information to help you diagnose performance bottlenecks based on real-user issues, use the ["attribution" build](#attribution-build).
+However, if you'd like to collect additional debug information to help you diagnose performance bottlenecks based on real-user issues, use the ["attribution" build](#attribution-build).
 
 For guidance on how to collect and use real-user data to debug performance issues, see [Debug performance in the field](https://web.dev/debug-performance-in-the-field/).
 
@@ -659,6 +659,7 @@ Metric-specific subclasses:
 ```ts
 interface INPAttributionReportOpts extends AttributionReportOpts {
   durationThreshold?: number;
+  includeProcessedEventEntries?: boolean;
 }
 ```
 
@@ -800,7 +801,7 @@ In the [attribution build](#attribution-build) each of the metric functions has
    }
    ```
 
-   For example, if a web page has unique `data-name` attibute on many elements, you may prefer to use those over the built-in selector-style strings that are generated by default.
+   For example, if a web page has unique `data-name` attribute on many elements, you may prefer to use those over the built-in selector-style strings that are generated by default.
 
    ```js
    function customGenerateTarget(el) {
@@ -814,6 +815,15 @@ In the [attribution build](#attribution-build) each of the metric functions has
    onLCP(sendToAnalytics, {generateTarget: customGenerateTarget});
    ```
 
+3. The `onINP` `AttributionReportOpts` supports an additional, optional, `includeProcessedEventEntries` configuration option. When set to `false`, the `event` performance entries will not be included in the `attribution` object to conserve memory if these entries are not needed. The default value is `true`.
+
+```ts
+interface INPAttributionReportOpts extends AttributionReportOpts {
+  durationThreshold?: number;
+  includeProcessedEventEntries?: boolean;
+}
+```
+
 The next sections document the shape of the `attribution` object for each of the metrics:
 
 #### `CLSAttribution`
@@ -930,6 +940,9 @@ interface INPAttribution {
   /**
    * An array of Event Timing entries that were processed within the same
    * animation frame as the INP candidate interaction.
+   * This array can be quite large so it will be empty if the
+   * `includeProcessedEventEntries` configuration option is set to `false` to
+   * conserve memory if these entries are not required.
    */
   processedEventEntries: PerformanceEventTiming[];
   /**
@@ -1129,14 +1142,12 @@ interface TTFBAttribution {
 
 The `web-vitals` code is tested in Chrome, Firefox, and Safari. In addition, all JavaScript features used in the code are part of ([Baseline Widely Available](https://web.dev/baseline)), and thus should run without error in all versions of these browsers released within the last 30 months.
 
-However, some of the APIs required to capture these metrics are currently only available in Chromium-based browsers (e.g. Chrome, Edge, Opera, Samsung Internet), which means in some browsers those metrics will not be reported.
-
-Browser support for each function is as follows:
+However, some of the APIs required to capture these metrics (notable CLS) are currently only available in some browsers. The latest browser support for each function is as follows:
 
 - `onCLS()`: Chromium
 - `onFCP()`: Chromium, Firefox, Safari
-- `onINP()`: Chromium
-- `onLCP()`: Chromium, Firefox
+- `onINP()`: Chromium, Firefox, Safari
+- `onLCP()`: Chromium, Firefox, Safari
 - `onTTFB()`: Chromium, Firefox, Safari
 
 ## Limitations
@@ -1186,7 +1197,7 @@ You'll likely want to combine this with `npm run watch` to ensure any changes yo
 
 ## Integrations
 
-- [**Web Vitals Connector**](https://goo.gle/web-vitals-connector): Data Studio connector to create dashboards from [Web Vitals data captured in BiqQuery](https://web.dev/articles/vitals-ga4).
+- [**Web Vitals Connector**](https://goo.gle/web-vitals-connector): Data Studio connector to create dashboards from [Web Vitals data captured in BigQuery](https://web.dev/articles/vitals-ga4).
 - [**Core Web Vitals Custom Tag template**](https://www.simoahava.com/custom-templates/core-web-vitals/): Custom GTM template tag to [add measurement handlers](https://www.simoahava.com/analytics/track-core-web-vitals-in-ga4-with-google-tag-manager/) for all Core Web Vitals metrics.
 - [**`web-vitals-reporter`**](https://github.com/treosh/web-vitals-reporter): JavaScript library to batch `callback` functions and send data with a single request.
 

package/front_end/third_party/web-vitals/package/dist/modules/attribution/onCLS.js

@@ -83,11 +83,9 @@ export const onCLS = (onReport, opts = {}) => {
             }
         }
         // Use `Object.assign()` to ensure the original metric object is returned.
-        const metricWithAttribution = Object.assign(metric, { attribution });
-        return metricWithAttribution;
+        return Object.assign(metric, { attribution });
     };
     unattributedOnCLS((metric) => {
-        const metricWithAttribution = attributeCLS(metric);
-        onReport(metricWithAttribution);
+        onReport(attributeCLS(metric));
     }, opts);
 };

package/front_end/third_party/web-vitals/package/dist/modules/attribution/onFCP.js

@@ -51,7 +51,6 @@ const attributeFCP = (metric) => {
  */
 export const onFCP = (onReport, opts = {}) => {
     unattributedOnFCP((metric) => {
-        const metricWithAttribution = attributeFCP(metric);
-        onReport(metricWithAttribution);
+        onReport(attributeFCP(metric));
     }, opts);
 };

package/front_end/third_party/web-vitals/package/dist/modules/attribution/onINP.d.ts

@@ -14,6 +14,10 @@ import { INPAttributionReportOpts, INPMetricWithAttribution } from '../types.js'
  * less than 40 (well below the recommended
  * [good](https://web.dev/articles/inp#what_is_a_good_inp_score) threshold).
  *
+ * A custom `includeProcessedEventEntries` configuration option can optionally
+ * be passed to control whether the `processedEventEntries` array in the
+ * attribution object is populated. The default value is `true`.
+ *
  * If the `reportAllChanges` configuration option is set to `true`, the
  * `callback` function will be called as soon as the value is initially
  * determined as well as any time the value changes throughout the page

package/front_end/third_party/web-vitals/package/dist/modules/attribution/onINP.js

@@ -26,8 +26,8 @@ import { onINP as unattributedOnINP } from '../onINP.js';
 // frame data is needed to determine various bits of INP attribution once all
 // the frame-related data has come in.
 // In most cases this out-of-order data is only off by a frame or two, so
-// keeping the most recent 50 should be more than sufficient.
-const MAX_PREVIOUS_FRAMES = 50;
+// keeping the most recent 10 should be more than sufficient.
+const MAX_PENDING_FRAMES = 10;
 /**
  * Calculates the [INP](https://web.dev/articles/inp) value for the current
  * page and calls the `callback` function once the value is ready, along with
@@ -43,6 +43,10 @@ const MAX_PREVIOUS_FRAMES = 50;
  * less than 40 (well below the recommended
  * [good](https://web.dev/articles/inp#what_is_a_good_inp_score) threshold).
  *
+ * A custom `includeProcessedEventEntries` configuration option can optionally
+ * be passed to control whether the `processedEventEntries` array in the
+ * attribution object is populated. The default value is `true`.
+ *
  * If the `reportAllChanges` configuration option is set to `true`, the
  * `callback` function will be called as soon as the value is initially
  * determined as well as any time the value changes throughout the page
@@ -109,6 +113,8 @@ export const onINP = (onReport, opts = {}) => {
     const groupEntriesByRenderTime = (entry) => {
         const renderTime = entry.startTime + entry.duration;
         let group;
+        // Update `latestProcessingEnd` to correspond to the `processingEnd`
+        // value of the most recently dispatched `event` entry.
         latestProcessingEnd = Math.max(latestProcessingEnd, entry.processingEnd);
         // Iterate over all previous render times in reverse order to find a match.
         // Go in reverse since the most likely match will be at the end.
@@ -121,11 +127,11 @@ export const onINP = (onReport, opts = {}) => {
                 group.startTime = Math.min(entry.startTime, group.startTime);
                 group.processingStart = Math.min(entry.processingStart, group.processingStart);
                 group.processingEnd = Math.max(entry.processingEnd, group.processingEnd);
-                // Entries are not needed in DevTools since we're only displaying the
-                // summary information, and also emitting events as they come in. Stop
-                // holding a reference to avoid memory issues.
-                // See https://crbug.com/484342204
-                // group.entries.push(entry);
+                // processedEventEntries can be quite large, so only include them if
+                // the user explicitly requests them (default is to include).
+                if (opts.includeProcessedEventEntries !== false) {
+                    group.entries.push(entry);
+                }
                 break;
             }
         }
@@ -136,12 +142,9 @@ export const onINP = (onReport, opts = {}) => {
                 processingStart: entry.processingStart,
                 processingEnd: entry.processingEnd,
                 renderTime,
-                // Entries are not needed in DevTools since we're only displaying the
-                // summary information, and also emiting events as they come in. Stop
-                // holding a reference to avoid memory issues.
-                // See https://crbug.com/484342204
-                // entries: [entry],
-                entries: [],
+                // processedEventEntries can be quite large, so only include them if
+                // the user explicitly requests them (default is to include).
+                entries: opts.includeProcessedEventEntries !== false ? [entry] : [],
             };
             pendingEntriesGroups.push(group);
         }
@@ -159,35 +162,39 @@ export const onINP = (onReport, opts = {}) => {
         }
     };
     const cleanupEntries = () => {
-        // Keep all render times that are part of a pending INP candidate or
-        // that occurred within the 50 most recently-dispatched groups of events.
-        const longestInteractionGroups = interactionManager._longestInteractionList.map((i) => {
+        // Create a set of entries groups that are part of the longest
+        // interactions (for faster lookup below).
+        const longestInteractionGroups = new Set(interactionManager._longestInteractionList.map((i) => {
             return entryToEntriesGroupMap.get(i.entries[0]);
+        }));
+        // Clean up the `pendingEntriesGroups` list so it doesn't grow endlessly.
+        // Keep any groups that:
+        // 1) Correspond to one of the current longest interactions, OR
+        // 2) Are part of one of the most recent set of frames (which is
+        //    determined by checking if the index in the group is within
+        //    `MAX_PENDING_FRAMES` of the group's length).
+        const minIndexToKeep = pendingEntriesGroups.length - MAX_PENDING_FRAMES;
+        pendingEntriesGroups = pendingEntriesGroups.filter((group, i) => {
+            // Check index first because it's faster.
+            return i >= minIndexToKeep || longestInteractionGroups.has(group);
         });
-        const minIndex = pendingEntriesGroups.length - MAX_PREVIOUS_FRAMES;
-        pendingEntriesGroups = pendingEntriesGroups.filter((group, index) => {
-            if (index >= minIndex)
-                return true;
-            return longestInteractionGroups.includes(group);
-        });
-        // Keep all pending LoAF entries that either:
-        // 1) intersect with entries in the newly cleaned up `pendingEntriesGroups`
-        // 2) occur after the most recently-processed event entry (for up to MAX_PREVIOUS_FRAMES)
-        const loafsToKeep = new Set();
+        // Create a set of LoAF entries that intersect with entries in the newly
+        // cleaned up `pendingEntriesGroups` (for faster lookup below).
+        const intersectingLoAFs = new Set();
         for (const group of pendingEntriesGroups) {
             const loafs = getIntersectingLoAFs(group.startTime, group.processingEnd);
             for (const loaf of loafs) {
-                loafsToKeep.add(loaf);
+                intersectingLoAFs.add(loaf);
             }
         }
-        const prevFrameIndexCutoff = pendingLoAFs.length - 1 - MAX_PREVIOUS_FRAMES;
-        // Filter `pendingLoAFs` to preserve LoAF order.
-        pendingLoAFs = pendingLoAFs.filter((loaf, index) => {
-            if (loaf.startTime > latestProcessingEnd &&
-                index > prevFrameIndexCutoff) {
-                return true;
-            }
-            return loafsToKeep.has(loaf);
+        // Clean up the `pendingLoAFs` list so it doesn't grow endlessly.
+        // Keep all LoAFs that either:
+        // 1) Intersect with one of the above pending entries groups, OR
+        // 2) Occurred more recently than the most recently process event entry.
+        pendingLoAFs = pendingLoAFs.filter((loaf) => {
+            return (
+            // Compare times first because it's faster.
+            loaf.startTime > latestProcessingEnd || intersectingLoAFs.has(loaf));
         });
         cleanupPending = false;
     };
@@ -358,13 +365,11 @@ export const onINP = (onReport, opts = {}) => {
         };
         attributeLoAFDetails(attribution);
         // Use `Object.assign()` to ensure the original metric object is returned.
-        const metricWithAttribution = Object.assign(metric, { attribution });
-        return metricWithAttribution;
+        return Object.assign(metric, { attribution });
     };
     // Start observing LoAF entries for attribution.
     observe('long-animation-frame', handleLoAFEntries);
     unattributedOnINP((metric) => {
-        const metricWithAttribution = attributeINP(metric);
-        onReport(metricWithAttribution);
+        onReport(attributeINP(metric));
     }, opts);
 };

package/front_end/third_party/web-vitals/package/dist/modules/attribution/onLCP.js

@@ -43,6 +43,11 @@ export const onLCP = (onReport, opts = {}) => {
             const customTarget = opts.generateTarget?.(node) ?? getSelector(node);
             lcpTargetMap.set(entry, customTarget);
         }
+        else if (entry.id) {
+            // Use the LargestContentfulPaint.id property when the element has been
+            // removed from the DOM (and so node is null), but still has an ID.
+            lcpTargetMap.set(entry, `#${entry.id}`);
+        }
     };
     const attributeLCP = (metric) => {
         // Use a default object if no other attribution has been set.
@@ -53,15 +58,26 @@ export const onLCP = (onReport, opts = {}) => {
             elementRenderDelay: metric.value,
         };
         if (metric.entries.length) {
+            // The `metric.entries.length` check ensures there will be an entry.
+            const lcpEntry = metric.entries.at(-1);
+            const lcpResourceEntry = lcpEntry.url &&
+                performance
+                    .getEntriesByType('resource')
+                    .find((e) => e.name === lcpEntry.url);
+            attribution.target = lcpTargetMap.get(lcpEntry);
+            attribution.lcpEntry = lcpEntry;
+            // Only attribute the URL and resource entry if they exist.
+            if (lcpEntry.url) {
+                attribution.url = lcpEntry.url;
+            }
+            if (lcpResourceEntry) {
+                attribution.lcpResourceEntry = lcpResourceEntry;
+            }
+            // Get subparts from navigation entry. Do this last as occasionally
+            // Safari seems to fail to find a navigation entry.
             const navigationEntry = getNavigationEntry();
             if (navigationEntry) {
                 const activationStart = navigationEntry.activationStart || 0;
-                // The `metric.entries.length` check ensures there will be an entry.
-                const lcpEntry = metric.entries.at(-1);
-                const lcpResourceEntry = lcpEntry.url &&
-                    performance
-                        .getEntriesByType('resource')
-                        .filter((e) => e.name === lcpEntry.url)[0];
                 const ttfb = Math.max(0, navigationEntry.responseStart - activationStart);
                 const lcpRequestStart = Math.max(ttfb, 
                 // Prefer `requestStart` (if TOA is set), otherwise use `startTime`.
@@ -75,29 +91,19 @@ export const onLCP = (onReport, opts = {}) => {
                     ? lcpResourceEntry.responseEnd - activationStart
                     : 0));
                 attribution = {
-                    target: lcpTargetMap.get(lcpEntry),
+                    ...attribution,
                     timeToFirstByte: ttfb,
                     resourceLoadDelay: lcpRequestStart - ttfb,
                     resourceLoadDuration: lcpResponseEnd - lcpRequestStart,
                     elementRenderDelay: metric.value - lcpResponseEnd,
                     navigationEntry,
-                    lcpEntry,
                 };
-                // Only attribute the URL and resource entry if they exist.
-                if (lcpEntry.url) {
-                    attribution.url = lcpEntry.url;
-                }
-                if (lcpResourceEntry) {
-                    attribution.lcpResourceEntry = lcpResourceEntry;
-                }
             }
         }
         // Use `Object.assign()` to ensure the original metric object is returned.
-        const metricWithAttribution = Object.assign(metric, { attribution });
-        return metricWithAttribution;
+        return Object.assign(metric, { attribution });
     };
     unattributedOnLCP((metric) => {
-        const metricWithAttribution = attributeLCP(metric);
-        onReport(metricWithAttribution);
+        onReport(attributeLCP(metric));
     }, opts);
 };

package/front_end/third_party/web-vitals/package/dist/modules/attribution/onTTFB.js

@@ -70,7 +70,6 @@ const attributeTTFB = (metric) => {
  */
 export const onTTFB = (onReport, opts = {}) => {
     unattributedOnTTFB((metric) => {
-        const metricWithAttribution = attributeTTFB(metric);
-        onReport(metricWithAttribution);
+        onReport(attributeTTFB(metric));
     }, opts);
 };

package/front_end/third_party/web-vitals/package/dist/modules/lib/doubleRAF.js

@@ -14,5 +14,5 @@
  * limitations under the License.
  */
 export const doubleRAF = (cb) => {
-    requestAnimationFrame(() => requestAnimationFrame(() => cb()));
+    requestAnimationFrame(() => requestAnimationFrame(cb));
 };

package/front_end/third_party/web-vitals/package/dist/modules/lib/getActivationStart.js

@@ -15,6 +15,5 @@
  */
 import { getNavigationEntry } from './getNavigationEntry.js';
 export const getActivationStart = () => {
-    const navEntry = getNavigationEntry();
-    return navEntry?.activationStart ?? 0;
+    return getNavigationEntry()?.activationStart ?? 0;
 };

package/front_end/third_party/web-vitals/package/dist/modules/lib/getLoadState.js

@@ -20,24 +20,22 @@ export const getLoadState = (timestamp) => {
         // since the timestamp has to be the current time or earlier.
         return 'loading';
     }
-    else {
-        const navigationEntry = getNavigationEntry();
-        if (navigationEntry) {
-            if (timestamp < navigationEntry.domInteractive) {
-                return 'loading';
-            }
-            else if (navigationEntry.domContentLoadedEventStart === 0 ||
-                timestamp < navigationEntry.domContentLoadedEventStart) {
-                // If the `domContentLoadedEventStart` timestamp has not yet been
-                // set, or if the given timestamp is less than that value.
-                return 'dom-interactive';
-            }
-            else if (navigationEntry.domComplete === 0 ||
-                timestamp < navigationEntry.domComplete) {
-                // If the `domComplete` timestamp has not yet been
-                // set, or if the given timestamp is less than that value.
-                return 'dom-content-loaded';
-            }
+    const navigationEntry = getNavigationEntry();
+    if (navigationEntry) {
+        if (timestamp < navigationEntry.domInteractive) {
+            return 'loading';
+        }
+        if (navigationEntry.domContentLoadedEventStart === 0 ||
+            timestamp < navigationEntry.domContentLoadedEventStart) {
+            // If the `domContentLoadedEventStart` timestamp has not yet been
+            // set, or if the given timestamp is less than that value.
+            return 'dom-interactive';
+        }
+        if (navigationEntry.domComplete === 0 ||
+            timestamp < navigationEntry.domComplete) {
+            // If the `domComplete` timestamp has not yet been
+            // set, or if the given timestamp is less than that value.
+            return 'dom-content-loaded';
         }
     }
     // If any of the above fail, default to loaded. This could really only

package/front_end/third_party/web-vitals/package/dist/modules/lib/getVisibilityWatcher.js

@@ -61,7 +61,8 @@ export const getVisibilityWatcher = () => {
         const firstVisibilityStateHiddenTime = !document.prerendering
             ? globalThis.performance
                 .getEntriesByType('visibility-state')
-                .filter((e) => e.name === 'hidden' && e.startTime > activationStart)[0]?.startTime
+                .find((e) => e.name === 'hidden' && e.startTime >= activationStart)
+                ?.startTime
             : undefined;
         /* eslint-enable indent */
         // Prefer that, but if it's not available and the document is hidden when

package/front_end/third_party/web-vitals/package/dist/modules/lib/initMetric.d.ts

@@ -16,5 +16,5 @@ export declare const initMetric: <MetricName extends MetricType["name"]>(name: M
         name: MetricName;
     }>)["entries"];
     id: string;
-    navigationType: "reload" | "navigate" | "prerender" | "back-forward" | "back-forward-cache" | "restore";
+    navigationType: "reload" | "navigate" | "back-forward" | "back-forward-cache" | "prerender" | "restore";
 };

package/front_end/third_party/web-vitals/package/dist/modules/lib/observe.js

@@ -28,7 +28,7 @@ export const observe = (type, callback, opts = {}) => {
                 // Delay by a microtask to workaround a bug in Safari where the
                 // callback is invoked immediately, rather than in a separate task.
                 // See: https://github.com/GoogleChrome/web-vitals/issues/277
-                Promise.resolve().then(() => {
+                queueMicrotask(() => {
                     callback(list.getEntries());
                 });
             });

package/front_end/third_party/web-vitals/package/dist/modules/lib/polyfills/interactionCountPolyfill.d.ts

@@ -1,6 +1,6 @@
 declare global {
     interface Performance {
-        interactionCount: number;
+        readonly interactionCount: number;
     }
 }
 /**

package/front_end/third_party/web-vitals/package/dist/modules/lib/polyfills/interactionCountPolyfill.js

@@ -34,7 +34,7 @@ let po;
  * or the polyfill estimate in this module.
  */
 export const getInteractionCount = () => {
-    return po ? interactionCountEstimate : performance.interactionCount ?? 0;
+    return po ? interactionCountEstimate : (performance.interactionCount ?? 0);
 };
 /**
  * Feature detects native support or initializes the polyfill if needed.
@@ -43,8 +43,6 @@ export const initInteractionCountPolyfill = () => {
     if ('interactionCount' in performance || po)
         return;
     po = observe('event', updateEstimate, {
-        type: 'event',
-        buffered: true,
         durationThreshold: 0,
     });
 };

package/front_end/third_party/web-vitals/package/dist/modules/lib/whenActivated.js

@@ -15,7 +15,7 @@
  */
 export const whenActivated = (callback) => {
     if (document.prerendering) {
-        addEventListener('prerenderingchange', () => callback(), true);
+        addEventListener('prerenderingchange', callback, true);
     }
     else {
         callback();

package/front_end/third_party/web-vitals/package/dist/modules/lib/whenIdleOrHidden.js

@@ -20,19 +20,23 @@ import { runOnce } from './runOnce.js';
  */
 export const whenIdleOrHidden = (cb) => {
     const rIC = globalThis.requestIdleCallback || setTimeout;
+    const cIC = globalThis.cancelIdleCallback || clearTimeout;
     // If the document is hidden, run the callback immediately, otherwise
     // race an idle callback with the next `visibilitychange` event.
     if (document.visibilityState === 'hidden') {
         cb();
     }
     else {
-        cb = runOnce(cb);
-        addEventListener('visibilitychange', cb, { once: true, capture: true });
-        rIC(() => {
-            cb();
-            // Remove the above event listener since no longer required.
-            // See: https://github.com/GoogleChrome/web-vitals/issues/622
-            removeEventListener('visibilitychange', cb, { capture: true });
+        const wrappedCb = runOnce(cb);
+        let idleHandle = -1;
+        const onHidden = () => {
+            cIC(idleHandle);
+            wrappedCb();
+        };
+        addEventListener('visibilitychange', onHidden, { once: true, capture: true });
+        idleHandle = rIC(() => {
+            removeEventListener('visibilitychange', onHidden, { capture: true });
+            wrappedCb();
         });
     }
 };

package/front_end/third_party/web-vitals/package/dist/modules/onCLS.js

@@ -79,7 +79,7 @@ export const onCLS = (onReport, opts = {}) => {
                 layoutShiftManager._sessionValue = 0;
                 metric = initMetric('CLS', 0);
                 report = bindReporter(onReport, metric, CLSThresholds, opts.reportAllChanges);
-                doubleRAF(() => report());
+                doubleRAF(report);
             });
             // Queue a task to report (if nothing else triggers a report first).
             // This allows CLS to be reported as soon as FCP fires when

package/front_end/third_party/web-vitals/package/dist/modules/types/inp.d.ts

@@ -4,6 +4,7 @@ export interface INPReportOpts extends ReportOpts {
 }
 export interface INPAttributionReportOpts extends AttributionReportOpts {
     durationThreshold?: number;
+    includeProcessedEventEntries?: boolean;
     onEachInteraction?: (interaction: INPMetricWithAttribution) => void;
 }
 /**
@@ -69,6 +70,9 @@ export interface INPAttribution {
     /**
      * An array of Event Timing entries that were processed within the same
      * animation frame as the INP candidate interaction.
+     * This array can be quite large so it will be empty if the
+     * `includeProcessedEventEntries` configuration option is set to `false` to
+     * conserve memory if these entries are not required.
      */
     processedEventEntries: PerformanceEventTiming[];
     /**

package/front_end/third_party/web-vitals/package/dist/modules/types.d.ts

@@ -1,5 +1,4 @@
 export * from './types/base.js';
-export * from './types/polyfills.js';
 export * from './types/cls.js';
 export * from './types/fcp.js';
 export * from './types/inp.js';
@@ -26,7 +25,7 @@ declare global {
     }
     interface PerformanceEventTiming extends PerformanceEntry {
         duration: DOMHighResTimeStamp;
-        interactionId: number;
+        readonly interactionId: number;
     }
     interface LayoutShiftAttribution {
         node: Node | null;

package/front_end/third_party/web-vitals/package/dist/modules/types.js

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 export * from './types/base.js';
-export * from './types/polyfills.js';
 export * from './types/cls.js';
 export * from './types/fcp.js';
 export * from './types/inp.js';