chrome-devtools-frontend 1.0.1526630 → 1.0.1528866

package/front_end/third_party/web-vitals/package/src/lib/initMetric.ts

@@ -22,7 +22,7 @@ import {MetricType} from '../types.js';
 
 export const initMetric = <MetricName extends MetricType['name']>(
   name: MetricName,
-  value?: number,
+  value: number = -1,
 ) => {
   const navEntry = getNavigationEntry();
   let navigationType: MetricType['navigationType'] = 'navigate';
@@ -47,7 +47,7 @@ export const initMetric = <MetricName extends MetricType['name']>(
 
   return {
     name,
-    value: typeof value === 'undefined' ? -1 : value,
+    value,
     rating: 'good' as const, // If needed, will be updated when reported. `const` to keep the type from widening to `string`.
     delta: 0,
     entries,

package/front_end/third_party/web-vitals/package/src/{deprecated.ts → lib/initUnique.ts}

@@ -1,5 +1,5 @@
 /*
- * Copyright 2022 Google LLC
+ * Copyright 2024 Google LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,10 +14,16 @@
  * limitations under the License.
  */
 
-export {
-  /**
-   * @deprecated Use `onINP()` instead.
-   */
-  onFID,
-  FIDThresholds,
-} from './onFID.js';
+const instanceMap: WeakMap<object, unknown> = new WeakMap();
+
+/**
+ * A function that accepts and identity object and a class object and returns
+ * either a new instance of that class or an existing instance, if the
+ * identity object was previously used.
+ */
+export function initUnique<T>(identityObj: object, ClassObj: new () => T): T {
+  if (!instanceMap.get(identityObj)) {
+    instanceMap.set(identityObj, new ClassObj());
+  }
+  return instanceMap.get(identityObj)! as T;
+}

package/front_end/third_party/web-vitals/package/src/lib/observe.ts

@@ -36,7 +36,7 @@ interface PerformanceEntryMap {
 export const observe = <K extends keyof PerformanceEntryMap>(
   type: K,
   callback: (entries: PerformanceEntryMap[K]) => void,
-  opts?: PerformanceObserverInit,
+  opts: PerformanceObserverInit = {},
 ): PerformanceObserver | undefined => {
   try {
     if (PerformanceObserver.supportedEntryTypes.includes(type)) {
@@ -48,18 +48,10 @@ export const observe = <K extends keyof PerformanceEntryMap>(
           callback(list.getEntries() as PerformanceEntryMap[K]);
         });
       });
-      po.observe(
-        Object.assign(
-          {
-            type,
-            buffered: true,
-          },
-          opts || {},
-        ) as PerformanceObserverInit,
-      );
+      po.observe({type, buffered: true, ...opts});
       return po;
     }
-  } catch (e) {
+  } catch {
     // Do nothing.
   }
   return;

package/front_end/third_party/web-vitals/package/src/lib/polyfills/interactionCountPolyfill.ts

@@ -27,16 +27,22 @@ let minKnownInteractionId = Infinity;
 let maxKnownInteractionId = 0;
 
 const updateEstimate = (entries: PerformanceEventTiming[]) => {
-  entries.forEach((e) => {
-    if (e.interactionId) {
-      minKnownInteractionId = Math.min(minKnownInteractionId, e.interactionId);
-      maxKnownInteractionId = Math.max(maxKnownInteractionId, e.interactionId);
+  for (const entry of entries) {
+    if (entry.interactionId) {
+      minKnownInteractionId = Math.min(
+        minKnownInteractionId,
+        entry.interactionId,
+      );
+      maxKnownInteractionId = Math.max(
+        maxKnownInteractionId,
+        entry.interactionId,
+      );
 
       interactionCountEstimate = maxKnownInteractionId
         ? (maxKnownInteractionId - minKnownInteractionId) / 7 + 1
         : 0;
     }
-  });
+  }
 };
 
 let po: PerformanceObserver | undefined;
@@ -46,7 +52,7 @@ let po: PerformanceObserver | undefined;
  * or the polyfill estimate in this module.
  */
 export const getInteractionCount = () => {
-  return po ? interactionCountEstimate : performance.interactionCount || 0;
+  return po ? interactionCountEstimate : performance.interactionCount ?? 0;
 };
 
 /**

package/front_end/third_party/web-vitals/package/src/lib/{whenIdle.ts → whenIdleOrHidden.ts}

@@ -14,25 +14,27 @@
  * limitations under the License.
  */
 
-import {onHidden} from './onHidden.js';
 import {runOnce} from './runOnce.js';
 
 /**
  * Runs the passed callback during the next idle period, or immediately
  * if the browser's visibility state is (or becomes) hidden.
  */
-export const whenIdle = (cb: () => void): number => {
-  const rIC = self.requestIdleCallback || self.setTimeout;
+export const whenIdleOrHidden = (cb: () => void) => {
+  const rIC = globalThis.requestIdleCallback || setTimeout;
 
-  let handle = -1;
-  cb = runOnce(cb);
   // 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 {
-    handle = rIC(cb);
-    onHidden(cb);
+    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});
+    });
   }
-  return handle;
 };

package/front_end/third_party/web-vitals/package/src/onCLS.ts

@@ -15,13 +15,15 @@
  */
 
 import {onBFCacheRestore} from './lib/bfcache.js';
-import {initMetric} from './lib/initMetric.js';
-import {observe} from './lib/observe.js';
 import {bindReporter} from './lib/bindReporter.js';
 import {doubleRAF} from './lib/doubleRAF.js';
-import {onHidden} from './lib/onHidden.js';
+import {initMetric} from './lib/initMetric.js';
+import {initUnique} from './lib/initUnique.js';
+import {LayoutShiftManager} from './lib/LayoutShiftManager.js';
+import {observe} from './lib/observe.js';
 import {runOnce} from './lib/runOnce.js';
 import {onFCP} from './onFCP.js';
+import {getVisibilityWatcher} from './lib/getVisibilityWatcher.js';
 import {CLSMetric, MetricRatingThresholds, ReportOpts} from './types.js';
 
 /** Thresholds for CLS. See https://web.dev/articles/cls#what_is_a_good_cls_score */
@@ -50,11 +52,9 @@ export const CLSThresholds: MetricRatingThresholds = [0.1, 0.25];
  */
 export const onCLS = (
   onReport: (metric: CLSMetric) => void,
-  opts?: ReportOpts,
+  opts: ReportOpts = {},
 ) => {
-  // Set defaults
-  opts = opts || {};
-
+  const visibilityWatcher = getVisibilityWatcher();
   // Start monitoring FCP so we can only report CLS if FCP is also reported.
   // Note: this is done to match the current behavior of CrUX.
   onFCP(
@@ -62,39 +62,18 @@ export const onCLS = (
       let metric = initMetric('CLS', 0);
       let report: ReturnType<typeof bindReporter>;
 
-      let sessionValue = 0;
-      let sessionEntries: LayoutShift[] = [];
+      const layoutShiftManager = initUnique(opts, LayoutShiftManager);
 
       const handleEntries = (entries: LayoutShift[]) => {
-        entries.forEach((entry) => {
-          // Only count layout shifts without recent user input.
-          if (!entry.hadRecentInput) {
-            const firstSessionEntry = sessionEntries[0];
-            const lastSessionEntry = sessionEntries[sessionEntries.length - 1];
-
-            // If the entry occurred less than 1 second after the previous entry
-            // and less than 5 seconds after the first entry in the session,
-            // include the entry in the current session. Otherwise, start a new
-            // session.
-            if (
-              sessionValue &&
-              entry.startTime - lastSessionEntry.startTime < 1000 &&
-              entry.startTime - firstSessionEntry.startTime < 5000
-            ) {
-              sessionValue += entry.value;
-              sessionEntries.push(entry);
-            } else {
-              sessionValue = entry.value;
-              sessionEntries = [entry];
-            }
-          }
-        });
+        for (const entry of entries) {
+          layoutShiftManager._processEntry(entry);
+        }
 
         // If the current session value is larger than the current CLS value,
         // update CLS and the entries contributing to it.
-        if (sessionValue > metric.value) {
-          metric.value = sessionValue;
-          metric.entries = sessionEntries;
+        if (layoutShiftManager._sessionValue > metric.value) {
+          metric.value = layoutShiftManager._sessionValue;
+          metric.entries = layoutShiftManager._sessionEntries;
           report();
         }
       };
@@ -108,7 +87,7 @@ export const onCLS = (
           opts!.reportAllChanges,
         );
 
-        onHidden(() => {
+        visibilityWatcher.onHidden(() => {
           handleEntries(po.takeRecords() as CLSMetric['entries']);
           report(true);
         });
@@ -116,7 +95,7 @@ export const onCLS = (
         // Only report after a bfcache restore if the `PerformanceObserver`
         // successfully registered.
         onBFCacheRestore(() => {
-          sessionValue = 0;
+          layoutShiftManager._sessionValue = 0;
           metric = initMetric('CLS', 0);
           report = bindReporter(
             onReport,
@@ -131,7 +110,7 @@ export const onCLS = (
         // Queue a task to report (if nothing else triggers a report first).
         // This allows CLS to be reported as soon as FCP fires when
         // `reportAllChanges` is true.
-        setTimeout(report, 0);
+        setTimeout(report);
       }
     }),
   );

package/front_end/third_party/web-vitals/package/src/onFCP.ts

@@ -35,18 +35,15 @@ export const FCPThresholds: MetricRatingThresholds = [1800, 3000];
  */
 export const onFCP = (
   onReport: (metric: FCPMetric) => void,
-  opts?: ReportOpts,
+  opts: ReportOpts = {},
 ) => {
-  // Set defaults
-  opts = opts || {};
-
   whenActivated(() => {
     const visibilityWatcher = getVisibilityWatcher();
     let metric = initMetric('FCP');
     let report: ReturnType<typeof bindReporter>;
 
     const handleEntries = (entries: FCPMetric['entries']) => {
-      entries.forEach((entry) => {
+      for (const entry of entries) {
         if (entry.name === 'first-contentful-paint') {
           po!.disconnect();
 
@@ -61,7 +58,7 @@ export const onFCP = (
             report(true);
           }
         }
-      });
+      }
     };
 
     const po = observe('paint', handleEntries);

package/front_end/third_party/web-vitals/package/src/onINP.ts

@@ -17,34 +17,36 @@
 import {onBFCacheRestore} from './lib/bfcache.js';
 import {bindReporter} from './lib/bindReporter.js';
 import {initMetric} from './lib/initMetric.js';
-import {
-  DEFAULT_DURATION_THRESHOLD,
-  processInteractionEntry,
-  estimateP98LongestInteraction,
-  resetInteractions,
-} from './lib/interactions.js';
+import {initUnique} from './lib/initUnique.js';
+import {InteractionManager} from './lib/InteractionManager.js';
 import {observe} from './lib/observe.js';
-import {onHidden} from './lib/onHidden.js';
 import {initInteractionCountPolyfill} from './lib/polyfills/interactionCountPolyfill.js';
 import {whenActivated} from './lib/whenActivated.js';
-import {whenIdle} from './lib/whenIdle.js';
+import {getVisibilityWatcher} from './lib/getVisibilityWatcher.js';
+import {whenIdleOrHidden} from './lib/whenIdleOrHidden.js';
 
-import {INPMetric, MetricRatingThresholds, ReportOpts} from './types.js';
+import {INPMetric, MetricRatingThresholds, INPReportOpts} from './types.js';
 
 /** Thresholds for INP. See https://web.dev/articles/inp#what_is_a_good_inp_score */
 export const INPThresholds: MetricRatingThresholds = [200, 500];
 
+// The default `durationThreshold` used across this library for observing
+// `event` entries via PerformanceObserver.
+const DEFAULT_DURATION_THRESHOLD = 40;
+
 /**
  * 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
  * the `event` performance entries reported for that interaction. The reported
  * value is a `DOMHighResTimeStamp`.
  *
- * A custom `durationThreshold` configuration option can optionally be passed to
- * control what `event-timing` entries are considered for INP reporting. The
- * default threshold is `40`, which means INP scores of less than 40 are
- * reported as 0. Note that this will not affect your 75th percentile INP value
- * unless that value is also less than 40 (well below the recommended
+ * A custom `durationThreshold` configuration option can optionally be passed
+ * to control what `event-timing` entries are considered for INP reporting. The
+ * default threshold is `40`, which means INP scores of less than 40 will not
+ * be reported. To avoid reporting no interactions in these cases, the library
+ * will fall back to the input delay of the first interaction. Note that this
+ * will not affect your 75th percentile INP value unless that value is also
+ * less than 40 (well below the recommended
  * [good](https://web.dev/articles/inp#what_is_a_good_inp_score) threshold).
  *
  * If the `reportAllChanges` configuration option is set to `true`, the
@@ -63,20 +65,19 @@ export const INPThresholds: MetricRatingThresholds = [200, 500];
  */
 export const onINP = (
   onReport: (metric: INPMetric) => void,
-  opts?: ReportOpts,
+  opts: INPReportOpts = {},
 ) => {
   // Return if the browser doesn't support all APIs needed to measure INP.
   if (
     !(
-      'PerformanceEventTiming' in self &&
+      globalThis.PerformanceEventTiming &&
       'interactionId' in PerformanceEventTiming.prototype
     )
   ) {
     return;
   }
 
-  // Set defaults
-  opts = opts || {};
+  const visibilityWatcher = getVisibilityWatcher();
 
   whenActivated(() => {
     // TODO(philipwalton): remove once the polyfill is no longer needed.
@@ -85,6 +86,8 @@ export const onINP = (
     let metric = initMetric('INP');
     let report: ReturnType<typeof bindReporter>;
 
+    const interactionManager = initUnique(opts, InteractionManager);
+
     const handleEntries = (entries: INPMetric['entries']) => {
       // Queue the `handleEntries()` callback in the next idle task.
       // This is needed to increase the chances that all event entries that
@@ -92,13 +95,15 @@ export const onINP = (
       // have been dispatched. Note: there is currently an experiment
       // running in Chrome (EventTimingKeypressAndCompositionInteractionId)
       // 123+ that if rolled out fully may make this no longer necessary.
-      whenIdle(() => {
-        entries.forEach(processInteractionEntry);
+      whenIdleOrHidden(() => {
+        for (const entry of entries) {
+          interactionManager._processEntry(entry);
+        }
 
-        const inp = estimateP98LongestInteraction();
+        const inp = interactionManager._estimateP98LongestInteraction();
 
-        if (inp && inp.latency !== metric.value) {
-          metric.value = inp.latency;
+        if (inp && inp._latency !== metric.value) {
+          metric.value = inp._latency;
           metric.entries = inp.entries;
           report();
         }
@@ -112,14 +117,14 @@ export const onINP = (
       // and performance. Running this callback for any interaction that spans
       // just one or two frames is likely not worth the insight that could be
       // gained.
-      durationThreshold: opts!.durationThreshold ?? DEFAULT_DURATION_THRESHOLD,
+      durationThreshold: opts.durationThreshold ?? DEFAULT_DURATION_THRESHOLD,
     });
 
     report = bindReporter(
       onReport,
       metric,
       INPThresholds,
-      opts!.reportAllChanges,
+      opts.reportAllChanges,
     );
 
     if (po) {
@@ -127,7 +132,7 @@ export const onINP = (
       // where the first interaction is less than the `durationThreshold`.
       po.observe({type: 'first-input', buffered: true});
 
-      onHidden(() => {
+      visibilityWatcher.onHidden(() => {
         handleEntries(po.takeRecords() as INPMetric['entries']);
         report(true);
       });
@@ -135,14 +140,14 @@ export const onINP = (
       // Only report after a bfcache restore if the `PerformanceObserver`
       // successfully registered.
       onBFCacheRestore(() => {
-        resetInteractions();
+        interactionManager._resetInteractions();
 
         metric = initMetric('INP');
         report = bindReporter(
           onReport,
           metric,
           INPThresholds,
-          opts!.reportAllChanges,
+          opts.reportAllChanges,
         );
       });
     }

package/front_end/third_party/web-vitals/package/src/onLCP.ts

@@ -14,24 +14,23 @@
  * limitations under the License.
  */
 
+import {LCPEntryManager} from './lib/LCPEntryManager.js';
 import {onBFCacheRestore} from './lib/bfcache.js';
 import {bindReporter} from './lib/bindReporter.js';
 import {doubleRAF} from './lib/doubleRAF.js';
 import {getActivationStart} from './lib/getActivationStart.js';
 import {getVisibilityWatcher} from './lib/getVisibilityWatcher.js';
 import {initMetric} from './lib/initMetric.js';
+import {initUnique} from './lib/initUnique.js';
 import {observe} from './lib/observe.js';
-import {onHidden} from './lib/onHidden.js';
 import {runOnce} from './lib/runOnce.js';
 import {whenActivated} from './lib/whenActivated.js';
-import {whenIdle} from './lib/whenIdle.js';
+import {whenIdleOrHidden} from './lib/whenIdleOrHidden.js';
 import {LCPMetric, MetricRatingThresholds, ReportOpts} from './types.js';
 
 /** Thresholds for LCP. See https://web.dev/articles/lcp#what_is_a_good_lcp_score */
 export const LCPThresholds: MetricRatingThresholds = [2500, 4000];
 
-const reportedMetricIDs: Record<string, boolean> = {};
-
 /**
  * Calculates the [LCP](https://web.dev/articles/lcp) value for the current page and
  * calls the `callback` function once the value is ready (along with the
@@ -45,16 +44,15 @@ const reportedMetricIDs: Record<string, boolean> = {};
  */
 export const onLCP = (
   onReport: (metric: LCPMetric) => void,
-  opts?: ReportOpts,
+  opts: ReportOpts = {},
 ) => {
-  // Set defaults
-  opts = opts || {};
-
   whenActivated(() => {
     const visibilityWatcher = getVisibilityWatcher();
     let metric = initMetric('LCP');
     let report: ReturnType<typeof bindReporter>;
 
+    const lcpEntryManager = initUnique(opts, LCPEntryManager);
+
     const handleEntries = (entries: LCPMetric['entries']) => {
       // If reportAllChanges is set then call this function for each entry,
       // otherwise only consider the last one.
@@ -62,7 +60,9 @@ export const onLCP = (
         entries = entries.slice(-1);
       }
 
-      entries.forEach((entry) => {
+      for (const entry of entries) {
+        lcpEntryManager._processEntry(entry);
+
         // Only report if the page wasn't hidden prior to LCP.
         if (entry.startTime < visibilityWatcher.firstHiddenTime) {
           // The startTime attribute returns the value of the renderTime if it is
@@ -75,7 +75,7 @@ export const onLCP = (
           metric.entries = [entry];
           report();
         }
-      });
+      }
     };
 
     const po = observe('largest-contentful-paint', handleEntries);
@@ -88,29 +88,37 @@ export const onLCP = (
         opts!.reportAllChanges,
       );
 
+      // Ensure this logic only runs once, since it can be triggered from
+      // any of three different event listeners below.
       const stopListening = runOnce(() => {
-        if (!reportedMetricIDs[metric.id]) {
-          handleEntries(po!.takeRecords() as LCPMetric['entries']);
-          po!.disconnect();
-          reportedMetricIDs[metric.id] = true;
-          report(true);
-        }
+        handleEntries(po!.takeRecords() as LCPMetric['entries']);
+        po!.disconnect();
+        report(true);
       });
 
-      // Stop listening after input. Note: while scrolling is an input that
-      // stops LCP observation, it's unreliable since it can be programmatically
-      // generated. See: https://github.com/GoogleChrome/web-vitals/issues/75
-      ['keydown', 'click'].forEach((type) => {
-        // Wrap in a setTimeout so the callback is run in a separate task
-        // to avoid extending the keyboard/click handler to reduce INP impact
-        // https://github.com/GoogleChrome/web-vitals/issues/383
-        addEventListener(type, () => whenIdle(stopListening), {
-          once: true,
+      // Need a separate wrapper to ensure the `runOnce` function above is
+      // common for all three functions
+      const stopListeningWrapper = (event: Event) => {
+        if (event.isTrusted) {
+          // Wrap the listener in an idle callback so it's run in a separate
+          // task to reduce potential INP impact.
+          // https://github.com/GoogleChrome/web-vitals/issues/383
+          whenIdleOrHidden(stopListening);
+          removeEventListener(event.type, stopListeningWrapper, {
+            capture: true,
+          });
+        }
+      };
+
+      // Stop listening after input or visibilitychange.
+      // Note: while scrolling is an input that stops LCP observation, it's
+      // unreliable since it can be programmatically generated.
+      // See: https://github.com/GoogleChrome/web-vitals/issues/75
+      for (const type of ['keydown', 'click', 'visibilitychange']) {
+        addEventListener(type, stopListeningWrapper, {
           capture: true,
         });
-      });
-
-      onHidden(stopListening);
+      }
 
       // Only report after a bfcache restore if the `PerformanceObserver`
       // successfully registered.
@@ -125,7 +133,6 @@ export const onLCP = (
 
         doubleRAF(() => {
           metric.value = performance.now() - event.timeStamp;
-          reportedMetricIDs[metric.id] = true;
           report(true);
         });
       });

package/front_end/third_party/web-vitals/package/src/onTTFB.ts

@@ -36,7 +36,7 @@ const whenReady = (callback: () => void) => {
     addEventListener('load', () => whenReady(callback), true);
   } else {
     // Queue a task so the callback runs after `loadEventEnd`.
-    setTimeout(callback, 0);
+    setTimeout(callback);
   }
 };
 
@@ -57,11 +57,8 @@ const whenReady = (callback: () => void) => {
  */
 export const onTTFB = (
   onReport: (metric: TTFBMetric) => void,
-  opts?: ReportOpts,
+  opts: ReportOpts = {},
 ) => {
-  // Set defaults
-  opts = opts || {};
-
   let metric = initMetric('TTFB');
   let report = bindReporter(
     onReport,

package/front_end/third_party/web-vitals/package/src/types/base.ts

@@ -16,7 +16,6 @@
 
 import type {CLSMetric, CLSMetricWithAttribution} from './cls.js';
 import type {FCPMetric, FCPMetricWithAttribution} from './fcp.js';
-import type {FIDMetric, FIDMetricWithAttribution} from './fid.js';
 import type {INPMetric, INPMetricWithAttribution} from './inp.js';
 import type {LCPMetric, LCPMetricWithAttribution} from './lcp.js';
 import type {TTFBMetric, TTFBMetricWithAttribution} from './ttfb.js';
@@ -25,7 +24,7 @@ export interface Metric {
   /**
    * The name of the metric (in acronym form).
    */
-  name: 'CLS' | 'FCP' | 'FID' | 'INP' | 'LCP' | 'TTFB';
+  name: 'CLS' | 'FCP' | 'INP' | 'LCP' | 'TTFB';
 
   /**
    * The current value of the metric.
@@ -87,7 +86,6 @@ export interface Metric {
 export type MetricType =
   | CLSMetric
   | FCPMetric
-  | FIDMetric
   | INPMetric
   | LCPMetric
   | TTFBMetric;
@@ -96,7 +94,6 @@ export type MetricType =
 export type MetricWithAttribution =
   | CLSMetricWithAttribution
   | FCPMetricWithAttribution
-  | FIDMetricWithAttribution
   | INPMetricWithAttribution
   | LCPMetricWithAttribution
   | TTFBMetricWithAttribution;
@@ -127,7 +124,10 @@ export interface ReportCallback {
 
 export interface ReportOpts {
   reportAllChanges?: boolean;
-  durationThreshold?: number;
+}
+
+export interface AttributionReportOpts extends ReportOpts {
+  generateTarget?: (el: Node | null) => string | undefined;
 }
 
 /**

package/front_end/third_party/web-vitals/package/src/types/cls.ts

@@ -31,9 +31,11 @@ export interface CLSMetric extends Metric {
  */
 export interface CLSAttribution {
   /**
-   * A selector identifying the first element (in document order) that
-   * shifted when the single largest layout shift contributing to the page's
-   * CLS score occurred.
+   * By default, a selector identifying the first element (in document order)
+   * that shifted when the single largest layout shift that contributed to the
+   * page's CLS score occurred. If the `generateTarget` configuration option
+   * was passed, then this will instead be the return value of that function,
+   * falling back to the default if that returns null or undefined.
    */
   largestShiftTarget?: string;
   /**