lighthouse 9.6.7 → 10.0.0

package/lighthouse-core/computed/metrics/largest-contentful-paint-all-frames.js

@@ -1,45 +0,0 @@
-/**
- * @license Copyright 2020 The Lighthouse Authors. All Rights Reserved.
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
- */
-'use strict';
-
-/**
- * @fileoverview Computed Largest Contentful Paint (LCP) for all frames.
- */
-
-const makeComputedArtifact = require('../computed-artifact.js');
-const NavigationMetric = require('./navigation-metric.js');
-const LHError = require('../../lib/lh-error.js');
-
-class LargestContentfulPaintAllFrames extends NavigationMetric {
-  /**
-   * TODO: Simulate LCP all frames in lantern.
-   * @return {Promise<LH.Artifacts.LanternMetric>}
-   */
-  static async computeSimulatedMetric() {
-    throw new Error('LCP All Frames not implemented in lantern');
-  }
-
-  /**
-   * @param {LH.Artifacts.NavigationMetricComputationData} data
-   * @return {Promise<LH.Artifacts.Metric>}
-   */
-  static async computeObservedMetric(data) {
-    const {processedNavigation} = data;
-    if (processedNavigation.timings.largestContentfulPaintAllFrames === undefined) {
-      throw new LHError(LHError.errors.NO_LCP_ALL_FRAMES);
-    }
-
-    return {
-      timing: processedNavigation.timings.largestContentfulPaintAllFrames,
-      timestamp: processedNavigation.timestamps.largestContentfulPaintAllFrames,
-    };
-  }
-}
-
-module.exports = makeComputedArtifact(
-  LargestContentfulPaintAllFrames,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
-);

package/lighthouse-core/computed/metrics/largest-contentful-paint.js

@@ -1,52 +0,0 @@
-/**
- * @license Copyright 2019 The Lighthouse Authors. All Rights Reserved.
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
- */
-'use strict';
-
-/**
- * @fileoverview Computed Largest Contentful Paint (LCP), the paint time of the largest in-viewport contentful element
- * COMPAT: LCP's trace event was first introduced in m78. We can't surface an LCP for older Chrome versions
- * @see https://github.com/WICG/largest-contentful-paint
- * @see https://wicg.github.io/largest-contentful-paint/
- * @see https://web.dev/largest-contentful-paint
- */
-
-const makeComputedArtifact = require('../computed-artifact.js');
-const NavigationMetric = require('./navigation-metric.js');
-const LHError = require('../../lib/lh-error.js');
-const LanternLargestContentfulPaint = require('./lantern-largest-contentful-paint.js');
-
-class LargestContentfulPaint extends NavigationMetric {
-  /**
-   * @param {LH.Artifacts.NavigationMetricComputationData} data
-   * @param {LH.Artifacts.ComputedContext} context
-   * @return {Promise<LH.Artifacts.LanternMetric>}
-   */
-  static computeSimulatedMetric(data, context) {
-    const metricData = NavigationMetric.getMetricComputationInput(data);
-    return LanternLargestContentfulPaint.request(metricData, context);
-  }
-
-  /**
-   * @param {LH.Artifacts.NavigationMetricComputationData} data
-   * @return {Promise<LH.Artifacts.Metric>}
-   */
-  static async computeObservedMetric(data) {
-    const {processedNavigation} = data;
-    if (processedNavigation.timings.largestContentfulPaint === undefined) {
-      throw new LHError(LHError.errors.NO_LCP);
-    }
-
-    return {
-      timing: processedNavigation.timings.largestContentfulPaint,
-      timestamp: processedNavigation.timestamps.largestContentfulPaint,
-    };
-  }
-}
-
-module.exports = makeComputedArtifact(
-  LargestContentfulPaint,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
-);

package/lighthouse-core/computed/metrics/max-potential-fid.js

@@ -1,45 +0,0 @@
-/**
- * @license Copyright 2018 The Lighthouse Authors. All Rights Reserved.
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
- */
-'use strict';
-
-const makeComputedArtifact = require('../computed-artifact.js');
-const NavigationMetric = require('./navigation-metric.js');
-const LanternMaxPotentialFID = require('./lantern-max-potential-fid.js');
-const TracingProcessor = require('../../lib/tracehouse/trace-processor.js');
-
-class MaxPotentialFID extends NavigationMetric {
-  /**
-   * @param {LH.Artifacts.NavigationMetricComputationData} data
-   * @param {LH.Artifacts.ComputedContext} context
-   * @return {Promise<LH.Artifacts.LanternMetric>}
-   */
-  static computeSimulatedMetric(data, context) {
-    const metricData = NavigationMetric.getMetricComputationInput(data);
-    return LanternMaxPotentialFID.request(metricData, context);
-  }
-
-  /**
-   * @param {LH.Artifacts.NavigationMetricComputationData} data
-   * @return {Promise<LH.Artifacts.Metric>}
-   */
-  static computeObservedMetric(data) {
-    const {firstContentfulPaint} = data.processedNavigation.timings;
-
-    const events = TracingProcessor.getMainThreadTopLevelEvents(
-      data.processedTrace,
-      firstContentfulPaint
-    ).filter(evt => evt.duration >= 1);
-
-    return Promise.resolve({
-      timing: Math.max(...events.map(evt => evt.duration), 16),
-    });
-  }
-}
-
-module.exports = makeComputedArtifact(
-  MaxPotentialFID,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
-);

package/lighthouse-core/computed/metrics/metric.js

@@ -1,100 +0,0 @@
-/**
- * @license Copyright 2018 The Lighthouse Authors. All Rights Reserved.
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
- */
-'use strict';
-
-const TracingProcessor = require('../../lib/tracehouse/trace-processor.js');
-const ProcessedTrace = require('../processed-trace.js');
-const ProcessedNavigation = require('../processed-navigation.js');
-const NetworkRecords = require('../network-records.js');
-
-/**
- * @fileOverview Encapsulates logic for choosing the correct metric computation method based on the
- * specified throttling settings, supporting simulated and observed metric types.
- *
- * To implement a fully supported metric:
- *     - Override the computeObservedMetric method with the observed-mode implementation.
- *     - Override the computeSimulatedMetric method with the simulated-mode implementation (which
- *       may call another computed artifact with the name LanternMyMetricName).
- */
-class Metric {
-  constructor() {}
-
-  /**
-   * Narrows the metric computation data to the input so child metric requests can be cached.
-   *
-   * @param {LH.Artifacts.MetricComputationData} data
-   * @return {LH.Artifacts.MetricComputationDataInput}
-   */
-  static getMetricComputationInput(data) {
-    return {
-      trace: data.trace,
-      devtoolsLog: data.devtoolsLog,
-      gatherContext: data.gatherContext,
-      settings: data.settings,
-    };
-  }
-
-  /**
-   * @param {LH.Artifacts.MetricComputationData} data
-   * @param {LH.Artifacts.ComputedContext} context
-   * @return {Promise<LH.Artifacts.LanternMetric>}
-   */
-  static computeSimulatedMetric(data, context) { // eslint-disable-line no-unused-vars
-    throw new Error('Unimplemented');
-  }
-
-  /**
-   * @param {LH.Artifacts.MetricComputationData} data
-   * @param {LH.Artifacts.ComputedContext} context
-   * @return {Promise<LH.Artifacts.Metric>}
-   */
-  static computeObservedMetric(data, context) { // eslint-disable-line no-unused-vars
-    throw new Error('Unimplemented');
-  }
-
-  /**
-   * @param {LH.Artifacts.MetricComputationDataInput} data
-   * @param {LH.Artifacts.ComputedContext} context
-   * @return {Promise<LH.Artifacts.LanternMetric|LH.Artifacts.Metric>}
-   */
-  static async compute_(data, context) {
-    // TODO: remove this fallback when lighthouse-pub-ads plugin can update.
-    const gatherContext = data.gatherContext || {gatherMode: 'navigation'};
-    const {trace, devtoolsLog, settings} = data;
-    if (!trace || !devtoolsLog || !settings) {
-      throw new Error('Did not provide necessary metric computation data');
-    }
-
-    const processedTrace = await ProcessedTrace.request(trace, context);
-    const processedNavigation = gatherContext.gatherMode === 'timespan' ?
-      undefined : await ProcessedNavigation.request(processedTrace, context);
-
-    const augmentedData = Object.assign({
-      networkRecords: await NetworkRecords.request(devtoolsLog, context),
-      gatherContext,
-      processedTrace,
-      processedNavigation,
-    }, data);
-
-    TracingProcessor.assertHasToplevelEvents(augmentedData.processedTrace.mainThreadEvents);
-
-    switch (settings.throttlingMethod) {
-      case 'simulate':
-        if (gatherContext.gatherMode !== 'navigation') {
-          throw new Error(`${gatherContext.gatherMode} does not support throttlingMethod simulate`);
-        }
-
-        return this.computeSimulatedMetric(augmentedData, context);
-      case 'provided':
-      case 'devtools':
-        return this.computeObservedMetric(augmentedData, context);
-      default:
-        throw new TypeError(`Unrecognized throttling method: ${settings.throttlingMethod}`);
-    }
-  }
-}
-
-module.exports = Metric;

package/lighthouse-core/computed/metrics/navigation-metric.js

@@ -1,46 +0,0 @@
-/**
- * @license Copyright 2021 The Lighthouse Authors. All Rights Reserved.
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
- */
-'use strict';
-
-const Metric = require('./metric.js');
-
-/**
- * @fileOverview Enforces that a metric can only be computed on navigations.
- */
-class NavigationMetric extends Metric {
-  /**
-   * @param {LH.Artifacts.NavigationMetricComputationData} data
-   * @param {LH.Artifacts.ComputedContext} context
-   * @return {Promise<LH.Artifacts.LanternMetric>}
-   */
-  static computeSimulatedMetric(data, context) { // eslint-disable-line no-unused-vars
-    throw new Error('Unimplemented');
-  }
-
-  /**
-   * @param {LH.Artifacts.NavigationMetricComputationData} data
-   * @param {LH.Artifacts.ComputedContext} context
-   * @return {Promise<LH.Artifacts.Metric>}
-   */
-  static computeObservedMetric(data, context) { // eslint-disable-line no-unused-vars
-    throw new Error('Unimplemented');
-  }
-
-  /**
-   * @param {LH.Artifacts.MetricComputationDataInput} data
-   * @param {LH.Artifacts.ComputedContext} context
-   * @return {Promise<LH.Artifacts.LanternMetric|LH.Artifacts.Metric>}
-   */
-  static async compute_(data, context) {
-    if (data.gatherContext.gatherMode !== 'navigation') {
-      throw new Error(`${this.name} can only be computed on navigations`);
-    }
-
-    return super.compute_(data, context);
-  }
-}
-
-module.exports = NavigationMetric;

package/lighthouse-core/computed/metrics/responsiveness.js

@@ -1,157 +0,0 @@
-/**
- * @license Copyright 2022 The Lighthouse Authors. All Rights Reserved.
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
- */
-'use strict';
-
-/**
- * @fileoverview Returns a high-percentle (usually 98th) measure of how long it
- * takes the page to visibly respond to user input (or null, if there was no
- * user input in the provided trace).
- */
-
-/** @typedef {LH.Trace.CompleteEvent & {name: 'Responsiveness.Renderer.UserInteraction', args: {frame: string, data: {interactionType: 'drag'|'keyboard'|'tapOrClick', maxDuration: number}}}} ResponsivenessEvent */
-/** @typedef {'keydown'|'keypress'|'keyup'|'mousedown'|'mouseup'|'pointerdown'|'pointerup'|'click'} EventTimingType */
-/**
- * @typedef EventTimingData
- * @property {string} frame
- * @property {number} timeStamp The time of user interaction (in ms from navStart).
- * @property {number} processingStart The start of interaction handling (in ms from navStart).
- * @property {number} processingEnd The end of interaction handling (in ms from navStart).
- * @property {number} duration The time from user interaction to browser paint (in ms).
- * @property {EventTimingType} type
- * @property {number} nodeId
- * @property {number} interactionId
- */
-/** @typedef {LH.Trace.AsyncEvent & {name: 'EventTiming', args: {data: EventTimingData}}} EventTimingEvent */
-/**
- * A fallback EventTiming placeholder, used if updated EventTiming events are not available.
- * TODO: Remove once 103.0.5052.0 is sufficiently released.
- * @typedef {{name: 'FallbackTiming', duration: number}} FallbackTimingEvent
- */
-
-const makeComputedArtifact = require('../computed-artifact.js');
-const ProcessedTrace = require('../processed-trace.js');
-
-const KEYBOARD_EVENTS = new Set(['keydown', 'keypress', 'keyup']);
-const CLICK_TAP_DRAG_EVENTS = new Set([
-  'mousedown', 'mouseup', 'pointerdown', 'pointerup', 'click']);
-/** A map of Responsiveness `interactionType` to matching EventTiming `type`s. */
-const interactionTypeToType = {
-  keyboard: KEYBOARD_EVENTS,
-  tapOrClick: CLICK_TAP_DRAG_EVENTS,
-  drag: CLICK_TAP_DRAG_EVENTS,
-};
-
-class Responsiveness {
-  /**
-   * @param {LH.Artifacts.ProcessedTrace} processedTrace
-   * @return {ResponsivenessEvent|null}
-   */
-  static getHighPercentileResponsiveness(processedTrace) {
-    const responsivenessEvents = processedTrace.frameTreeEvents
-      // https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/core/timing/responsiveness_metrics.cc;l=146-150;drc=a1a2302f30b0a58f7669a41c80acdf1fa11958dd
-      .filter(/** @return {e is ResponsivenessEvent} */ e => {
-        return e.name === 'Responsiveness.Renderer.UserInteraction';
-      }).sort((a, b) => b.args.data.maxDuration - a.args.data.maxDuration);
-
-    // If there were no interactions with the page, the metric is N/A.
-    if (responsivenessEvents.length === 0) {
-      return null;
-    }
-
-    // INP is the "nearest-rank"/inverted_cdf 98th percentile, except Chrome only
-    // keeps the 10 worst events around, so it can never be more than the 10th from
-    // last array element. To keep things simpler, sort desc and pick from front.
-    // See https://source.chromium.org/chromium/chromium/src/+/main:components/page_load_metrics/browser/responsiveness_metrics_normalization.cc;l=45-59;drc=cb0f9c8b559d9c7c3cb4ca94fc1118cc015d38ad
-    const index = Math.min(9, Math.floor(responsivenessEvents.length / 50));
-
-    return responsivenessEvents[index];
-  }
-
-  /**
-   * Finds the interaction event that was probably the responsivenessEvent.maxDuration
-   * source.
-   * Note that (presumably due to rounding to ms), the interaction duration may not
-   * be the same value as `maxDuration`, just the closest value. Function will throw
-   * if the closest match is off by more than 4ms.
-   * TODO: this doesn't try to match inputs to interactions and break ties if more than
-   * one interaction had this duration by returning the first found.
-   * @param {ResponsivenessEvent} responsivenessEvent
-   * @param {LH.Trace} trace
-   * @return {EventTimingEvent|FallbackTimingEvent}
-   */
-  static findInteractionEvent(responsivenessEvent, {traceEvents}) {
-    const candidates = traceEvents.filter(/** @return {evt is EventTimingEvent} */ evt => {
-      // Examine only beginning/instant EventTiming events.
-      return evt.name === 'EventTiming' && evt.ph !== 'e';
-    });
-
-    if (candidates.length && !candidates.some(candidate => candidate.args.data?.frame)) {
-      // Full EventTiming data added in https://crrev.com/c/3632661
-      return {
-        name: 'FallbackTiming',
-        duration: responsivenessEvent.args.data.maxDuration,
-      };
-    }
-
-    const {maxDuration, interactionType} = responsivenessEvent.args.data;
-    let bestMatchEvent;
-    let minDurationDiff = Number.POSITIVE_INFINITY;
-    for (const candidate of candidates) {
-      // Must be from same frame.
-      if (candidate.args.data.frame !== responsivenessEvent.args.frame) continue;
-
-      // TODO(bckenny): must be in same navigation as well.
-
-      const {type, duration} = candidate.args.data;
-      // Discard if type is incompatible with responsiveness interactionType.
-      const matchingTypes = interactionTypeToType[interactionType];
-      if (!matchingTypes) {
-        throw new Error(`unexpected responsiveness interactionType '${interactionType}'`);
-      }
-      if (!matchingTypes.has(type)) continue;
-
-      const durationDiff = Math.abs(duration - maxDuration);
-      if (durationDiff < minDurationDiff) {
-        bestMatchEvent = candidate;
-        minDurationDiff = durationDiff;
-      }
-    }
-
-    if (!bestMatchEvent) {
-      throw new Error(`no interaction event found for responsiveness type '${interactionType}'`);
-    }
-    // TODO: seems to regularly happen up to 3ms and as high as 4. Allow for up to 5ms to be sure.
-    if (minDurationDiff > 5) {
-      throw new Error(`no interaction event found within 5ms of responsiveness maxDuration (max: ${maxDuration}, closest ${bestMatchEvent.args.data.duration})`); // eslint-disable-line max-len
-    }
-
-    return bestMatchEvent;
-  }
-
-  /**
-   * @param {{trace: LH.Trace, settings: Immutable<LH.Config.Settings>}} data
-   * @param {LH.Artifacts.ComputedContext} context
-   * @return {Promise<EventTimingEvent|FallbackTimingEvent|null>}
-   */
-  static async compute_(data, context) {
-    const {settings, trace} = data;
-    if (settings.throttlingMethod === 'simulate') {
-      throw new Error('Responsiveness currently unsupported by simulated throttling');
-    }
-
-    const processedTrace = await ProcessedTrace.request(trace, context);
-    const responsivenessEvent = Responsiveness.getHighPercentileResponsiveness(processedTrace);
-    if (!responsivenessEvent) return null;
-
-    const interactionEvent = Responsiveness.findInteractionEvent(responsivenessEvent, trace);
-    return JSON.parse(JSON.stringify(interactionEvent));
-  }
-}
-
-module.exports = makeComputedArtifact(Responsiveness, [
-  'trace',
-  'settings',
-]);

package/lighthouse-core/computed/metrics/speed-index.js

@@ -1,40 +0,0 @@
-/**
- * @license Copyright 2018 The Lighthouse Authors. All Rights Reserved.
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
- */
-'use strict';
-
-const makeComputedArtifact = require('../computed-artifact.js');
-const NavigationMetric = require('./navigation-metric.js');
-const LanternSpeedIndex = require('./lantern-speed-index.js');
-const Speedline = require('../speedline.js');
-
-class SpeedIndex extends NavigationMetric {
-  /**
-   * @param {LH.Artifacts.NavigationMetricComputationData} data
-   * @param {LH.Artifacts.ComputedContext} context
-   * @return {Promise<LH.Artifacts.LanternMetric>}
-   */
-  static computeSimulatedMetric(data, context) {
-    const metricData = NavigationMetric.getMetricComputationInput(data);
-    return LanternSpeedIndex.request(metricData, context);
-  }
-
-  /**
-   * @param {LH.Artifacts.NavigationMetricComputationData} data
-   * @param {LH.Artifacts.ComputedContext} context
-   * @return {Promise<LH.Artifacts.Metric>}
-   */
-  static async computeObservedMetric(data, context) {
-    const speedline = await Speedline.request(data.trace, context);
-    const timing = Math.round(speedline.speedIndex);
-    const timestamp = (timing + speedline.beginning) * 1000;
-    return Promise.resolve({timing, timestamp});
-  }
-}
-
-module.exports = makeComputedArtifact(
-  SpeedIndex,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
-);

package/lighthouse-core/computed/metrics/tbt-utils.js

@@ -1,57 +0,0 @@
-/**
- * @license Copyright 2021 The Lighthouse Authors. All Rights Reserved.
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
- */
-'use strict';
-
-const BLOCKING_TIME_THRESHOLD = 50;
-
-/**
- * @param {Array<{start: number, end: number, duration: number}>} topLevelEvents
- * @param {number} startTimeMs
- * @param {number} endTimeMs
- * @return {number}
- */
-function calculateSumOfBlockingTime(topLevelEvents, startTimeMs, endTimeMs) {
-  if (endTimeMs <= startTimeMs) return 0;
-
-  const threshold = BLOCKING_TIME_THRESHOLD;
-  let sumBlockingTime = 0;
-  for (const event of topLevelEvents) {
-    // Early exit for small tasks, which should far outnumber long tasks.
-    if (event.duration < threshold) continue;
-
-    // We only want to consider tasks that fall in our time range (FCP and TTI for navigations).
-    // FCP is picked as the lower bound because there is little risk of user input happening
-    // before FCP so Long Queuing Qelay regions do not harm user experience. Developers should be
-    // optimizing to reach FCP as fast as possible without having to worry about task lengths.
-    if (event.end < startTimeMs) continue;
-
-    // TTI is picked as the upper bound because we want a well defined end point for page load.
-    if (event.start > endTimeMs) continue;
-
-    // We first perform the clipping, and then calculate Blocking Region. So if we have a 150ms
-    // task [0, 150] and FCP happens midway at 50ms, we first clip the task to [50, 150], and then
-    // calculate the Blocking Region to be [100, 150]. The rational here is that tasks before FCP
-    // are unimportant, so we care whether the main thread is busy more than 50ms at a time only
-    // after FCP.
-    const clippedStart = Math.max(event.start, startTimeMs);
-    const clippedEnd = Math.min(event.end, endTimeMs);
-    const clippedDuration = clippedEnd - clippedStart;
-    if (clippedDuration < threshold) continue;
-
-    // The duration of the task beyond 50ms at the beginning is considered the Blocking Region.
-    // Example:
-    //   [              250ms Task                   ]
-    //   | First 50ms |   Blocking Region (200ms)    |
-    sumBlockingTime += clippedDuration - threshold;
-  }
-
-  return sumBlockingTime;
-}
-
-module.exports = {
-  BLOCKING_TIME_THRESHOLD,
-  calculateSumOfBlockingTime,
-};