@newrelic/browser-agent 1.264.0 → 1.265.0

package/dist/esm/common/harvest/harvest.js

@@ -7,11 +7,11 @@ import { obj as encodeObj, param as encodeParam } from '../url/encode';
 import { stringify } from '../util/stringify';
 import * as submitData from '../util/submit-data';
 import { getLocation } from '../url/location';
-import { getInfo, getConfigurationValue, getRuntime, getConfiguration } from '../config/config';
+import { getInfo } from '../config/info';
+import { getConfigurationValue, getConfiguration } from '../config/init';
+import { getRuntime } from '../config/runtime';
 import { cleanURL } from '../url/clean-url';
 import { eventListenerOpts } from '../event-listener/event-listener-opts';
-import { Obfuscator } from '../util/obfuscate';
-import { applyFnToProps } from '../util/traverse';
 import { SharedContext } from '../context/shared-context';
 import { VERSION } from "../constants/env.npm";
 import { isWorkerScope } from '../constants/runtime';
@@ -31,7 +31,7 @@ export class Harvest extends SharedContext {
     super(parent); // gets any allowed properties from the parent and stores them in `sharedContext`
 
     this.tooManyRequestsDelay = getConfigurationValue(this.sharedContext.agentIdentifier, 'harvest.tooManyRequestsDelay') || 60;
-    this.obfuscator = new Obfuscator(this.sharedContext);
+    this.obfuscator = getRuntime(this.sharedContext.agentIdentifier).obfuscator;
     this._events = {};
   }
 
@@ -41,8 +41,7 @@ export class Harvest extends SharedContext {
    * Note: Used by page_action
    * @param {NetworkSendSpec} spec Specification for sending data
    */
-  sendX() {
-    let spec = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  sendX(spec = {}) {
     const submitMethod = submitData.getSubmitMethod({
       isFinalHarvest: spec.opts?.unload
     });
@@ -51,7 +50,7 @@ export class Harvest extends SharedContext {
       isFinalHarvest: spec.opts?.unload === true
     };
     const payload = this.createPayload(spec.endpoint, options);
-    const caller = this.obfuscator.shouldObfuscate() ? this.obfuscateAndSend.bind(this) : this._send.bind(this);
+    const caller = this._send.bind(this);
     return caller({
       ...spec,
       payload,
@@ -63,31 +62,11 @@ export class Harvest extends SharedContext {
    * Initiate a harvest call.
    * @param {NetworkSendSpec} spec Specification for sending data
    */
-  send() {
-    let spec = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    const caller = this.obfuscator.shouldObfuscate() ? this.obfuscateAndSend.bind(this) : this._send.bind(this);
+  send(spec = {}) {
+    const caller = this._send.bind(this);
     return caller(spec);
   }
 
-  /**
-   * Apply obfuscation rules to the payload and then initial the harvest network call.
-   * @param {NetworkSendSpec} spec Specification for sending data
-   */
-  obfuscateAndSend() {
-    var _this = this;
-    let spec = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    const {
-      payload = {}
-    } = spec;
-    applyFnToProps(payload, function () {
-      return _this.obfuscator.obfuscateString(...arguments);
-    }, 'string', ['e']);
-    return this._send({
-      ...spec,
-      payload
-    });
-  }
-
   /**
    * Initiate a harvest call. Typically used by `sendX` and `send` methods or called directly
    * for raw network calls.
@@ -95,17 +74,16 @@ export class Harvest extends SharedContext {
    * @returns {boolean} True if the network call succeeded. For final harvest calls, the return
    * value should not be relied upon because network calls will be made asynchronously.
    */
-  _send(_ref) {
-    let {
-      endpoint,
-      payload = {},
-      opts = {},
-      submitMethod,
-      cbFinished,
-      customUrl,
-      raw,
-      includeBaseParams = true
-    } = _ref;
+  _send({
+    endpoint,
+    payload = {},
+    opts = {},
+    submitMethod,
+    cbFinished,
+    customUrl,
+    raw,
+    includeBaseParams = true
+  }) {
     const info = getInfo(this.sharedContext.agentIdentifier);
     if (!info.errorBeacon) return false;
     const agentRuntime = getRuntime(this.sharedContext.agentIdentifier);
@@ -193,8 +171,6 @@ export class Harvest extends SharedContext {
         cbFinished(cbResult);
       }, eventListenerOpts(false));
     }
-    const runtime = getRuntime(this.sharedContext.agentIdentifier);
-    runtime.harvestCount++;
     return result;
   }
 
@@ -202,8 +178,7 @@ export class Harvest extends SharedContext {
   baseQueryString(qs, endpoint) {
     const runtime = getRuntime(this.sharedContext.agentIdentifier);
     const info = getInfo(this.sharedContext.agentIdentifier);
-    const location = cleanURL(getLocation());
-    const ref = this.obfuscator.shouldObfuscate() ? this.obfuscator.obfuscateString(location) : location;
+    const ref = this.obfuscator.obfuscateString(cleanURL(getLocation()));
     const hr = runtime?.session?.state.sessionReplayMode === 1 && endpoint !== 'jserrors';
     const qps = ['a=' + info.applicationID, encodeParam('sa', info.sa ? '' + info.sa : ''), encodeParam('v', VERSION), transactionNameParam(info), encodeParam('ct', runtime.customTransaction), '&rst=' + now(), '&ck=0',
     // ck param DEPRECATED - still expected by backend
@@ -254,13 +229,11 @@ export class Harvest extends SharedContext {
    * @param {HarvestPayload} payload Payload to be sent to the endpoint.
    * @returns {HarvestPayload} Cleaned payload payload to be sent to the endpoint.
    */
-  cleanPayload() {
-    let payload = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  cleanPayload(payload = {}) {
     const clean = input => {
       if (typeof Uint8Array !== 'undefined' && input instanceof Uint8Array || Array.isArray(input)) return input;
       if (typeof input === 'string') return input.length > 0 ? input : null;
-      return Object.entries(input || {}).reduce((accumulator, _ref2) => {
-        let [key, value] = _ref2;
+      return Object.entries(input || {}).reduce((accumulator, [key, value]) => {
         if (typeof value === 'number' || typeof value === 'string' && value.length > 0 || typeof value === 'object' && Object.keys(value || {}).length > 0) {
           accumulator[key] = value;
         }

package/dist/esm/common/serialize/bel-serializer.js

@@ -4,7 +4,7 @@
  */
 
 import { stringify } from '../util/stringify';
-import { Obfuscator } from '../util/obfuscate';
+import { getRuntime } from '../config/runtime';
 var hasOwnProp = Object.prototype.hasOwnProperty;
 var MAX_ATTRIBUTES = 64;
 export function nullable(val, fn, comma) {
@@ -17,17 +17,13 @@ export function numeric(n, noDefault) {
   return n === undefined || n === 0 ? '' : Math.floor(n).toString(36);
 }
 export function getAddStringContext(agentIdentifier) {
-  // eslint-disable-next-line
-  var stringTable = Object.hasOwnProperty('create') ? Object.create(null) : {};
-  var stringTableIdx = 0;
+  let stringTableIdx = 0;
+  const stringTable = Object.prototype.hasOwnProperty.call(Object, 'create') ? Object.create(null) : {};
+  const obfuscator = getRuntime(agentIdentifier).obfuscator;
   return addString;
   function addString(str) {
     if (typeof str === 'undefined' || str === '') return '';
-    var obfuscator = new Obfuscator({
-      agentIdentifier
-    });
-    str = String(str);
-    if (obfuscator.shouldObfuscate()) str = obfuscator.obfuscateString(str);
+    str = obfuscator.obfuscateString(String(str));
     if (hasOwnProp.call(stringTable, str)) {
       return numeric(stringTable[str], true);
     } else {
@@ -38,8 +34,7 @@ export function getAddStringContext(agentIdentifier) {
 }
 export function addCustomAttributes(attrs, addString) {
   var attrParts = [];
-  Object.entries(attrs || {}).forEach(_ref => {
-    let [key, val] = _ref;
+  Object.entries(attrs || {}).forEach(([key, val]) => {
     if (attrParts.length >= MAX_ATTRIBUTES) return;
     var type = 5;
     var serializedValue;

package/dist/esm/common/session/session-entity.js

@@ -6,8 +6,8 @@ import { Timer } from '../timer/timer';
 import { isBrowserScope } from '../constants/runtime';
 import { DEFAULT_EXPIRES_MS, DEFAULT_INACTIVE_MS, MODE, PREFIX, SESSION_EVENTS, SESSION_EVENT_TYPES } from './constants';
 import { InteractionTimer } from '../timer/interaction-timer';
-import { wrapEvents } from '../wrap';
-import { getModeledObject } from '../config/state/configurable';
+import { wrapEvents } from '../wrap/wrap-events';
+import { getModeledObject } from '../config/configurable';
 import { handle } from '../event-emitter/handle';
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../features/metrics/constants';
 import { FEATURE_NAMES } from '../../loaders/features/features';
@@ -69,12 +69,11 @@ export class SessionEntity {
       });
     }
   }
-  setup(_ref) {
-    let {
-      value = generateRandomHexString(16),
-      expiresMs = DEFAULT_EXPIRES_MS,
-      inactiveMs = DEFAULT_INACTIVE_MS
-    } = _ref;
+  setup({
+    value = generateRandomHexString(16),
+    expiresMs = DEFAULT_EXPIRES_MS,
+    inactiveMs = DEFAULT_INACTIVE_MS
+  }) {
     /** Ensure that certain properties are preserved across a reset if already set */
     const persistentAttributes = {
       serverTimeDiff: this.state.serverTimeDiff || model.serverTimeDiff
@@ -282,9 +281,7 @@ export class SessionEntity {
     if (type === 'inactive') tag = 'Session/Inactive/Seen';
     if (tag) handle(SUPPORTABILITY_METRIC_CHANNEL, [tag, value], undefined, FEATURE_NAMES.metrics, this.ee);
   }
-  getDuration() {
-    let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.state;
-    let useUpdatedAt = arguments.length > 1 ? arguments[1] : undefined;
+  getDuration(data = this.state, useUpdatedAt) {
     const startingTimestamp = data.expiresAt - this.expiresMs;
     const endingTimestamp = !useUpdatedAt ? data.updatedAt : Date.now();
     return endingTimestamp - startingTimestamp;

package/dist/esm/common/timing/nav-timing.js

@@ -35,9 +35,7 @@ function getPntType(type) {
   };
   return types[type];
 }
-export function addPT(offset, pt) {
-  let v = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  let isL1Api = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+export function addPT(offset, pt, v = {}, isL1Api = false) {
   if (!pt) return;
   v.of = offset;
   handleValue(v.of, v, 'n', true);

package/dist/esm/common/timing/time-keeper.js

@@ -1,5 +1,5 @@
 import { originTime } from '../constants/runtime';
-import { getRuntime } from '../config/config';
+import { getRuntime } from '../config/runtime';
 const rfc2616Regex = /^(Mon|Tue|Wed|Thu|Fri|Sat|Sun), ([0-3][0-9]) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ([0-9]{4}) ([01][0-9]|2[0-3])(:[0-5][0-9]){2} GMT$/;
 
 /**
@@ -81,21 +81,31 @@ export class TimeKeeper {
 
   /**
    * Converts a page origin relative time to an absolute timestamp
-   * corrected to NR server time.
+   * using the user's local clock.
    * @param relativeTime {number} The relative time of the event in milliseconds
    * @returns {number} Corrected unix/epoch timestamp
    */
   convertRelativeTimestamp(relativeTime) {
-    return Math.floor(this.#correctedOriginTime + relativeTime);
+    return originTime + relativeTime;
   }
 
   /**
-   * Corrects an event timestamp to NR server time.
+   * Converts an absolute timestamp to a relative timestamp using the
+   * user's local clock.
+   * @param timestamp
+   * @returns {number}
+   */
+  convertAbsoluteTimestamp(timestamp) {
+    return timestamp - originTime;
+  }
+
+  /**
+   * Corrects an absolute timestamp to NR server time.
    * @param timestamp {number} The unix/epoch timestamp of the event with milliseconds
    * @return {number} Corrected unix/epoch timestamp
    */
   correctAbsoluteTimestamp(timestamp) {
-    return Math.floor(timestamp - this.#localTimeDiff);
+    return timestamp - this.#localTimeDiff;
   }
 
   /** Process the session entity and use the info to set the main time calculations if present */

package/dist/esm/common/url/encode.js

@@ -37,8 +37,7 @@ export function fromArray(qs, maxBytes) {
 export function obj(payload, maxBytes) {
   var total = 0;
   var result = '';
-  Object.entries(payload || {}).forEach(_ref => {
-    let [feature, dataArray] = _ref;
+  Object.entries(payload || {}).forEach(([feature, dataArray]) => {
     var intermediate = [];
     var next;
     var i;
@@ -61,8 +60,7 @@ export function obj(payload, maxBytes) {
 }
 
 // Constructs an HTTP parameter to add to the BAM router URL
-export function param(name, value) {
-  let base = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+export function param(name, value, base = {}) {
   if (Object.keys(base).includes(name)) return ''; // we assume if feature supplied a matching qp to the base, we should honor what the feature sent over the default
   if (value && typeof value === 'string') {
     return '&' + name + '=' + qs(value);

package/dist/esm/common/util/console.js

@@ -1,3 +1,5 @@
+/* eslint no-console: ["error", { allow: ["debug"] }] */
+
 /**
  * A helper method to warn to the console with New Relic: decoration
  * @param {string} message The primary message to warn

package/dist/esm/common/util/invoke.js

@@ -20,18 +20,12 @@
  * @returns {function} A wrapping function that will ensure the provided function
  * is invoked only once within the given timeout.
  */
-export function debounce(func) {
-  var _this = this;
-  let timeout = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 500;
-  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+export function debounce(func, timeout = 500, options = {}) {
   const leading = options?.leading || false;
   let timer;
-  return function () {
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
+  return (...args) => {
     if (leading && timer === undefined) {
-      func.apply(_this, args);
+      func.apply(this, args);
       timer = setTimeout(() => {
         timer = clearTimeout(timer);
       }, timeout);
@@ -39,7 +33,7 @@ export function debounce(func) {
     if (!leading) {
       clearTimeout(timer);
       timer = setTimeout(() => {
-        func.apply(_this, args);
+        func.apply(this, args);
       }, timeout);
     }
   };
@@ -54,15 +48,11 @@ export function debounce(func) {
  * is invoked only once.
  */
 export function single(func) {
-  var _this2 = this;
   let called = false;
-  return function () {
+  return (...args) => {
     if (!called) {
       called = true;
-      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-        args[_key2] = arguments[_key2];
-      }
-      func.apply(_this2, args);
+      func.apply(this, args);
     }
   };
 }

package/dist/esm/common/util/obfuscate.js

@@ -1,61 +1,108 @@
-import { getConfigurationValue } from '../config/config';
-import { SharedContext } from '../context/shared-context';
+import { getConfigurationValue } from '../config/init';
 import { isFileProtocol } from '../url/protocol';
 import { warn } from './console';
-var fileProtocolRule = {
-  regex: /^file:\/\/(.*)/,
-  replacement: atob('ZmlsZTovL09CRlVTQ0FURUQ=')
-};
-export class Obfuscator extends SharedContext {
-  shouldObfuscate() {
-    return getRules(this.sharedContext.agentIdentifier).length > 0;
+
+/**
+ * Represents an obfuscation rule that can be applied to harvested payloads
+ * @typedef {object} ObfuscationRule
+ * @property {string|RegExp} regex The regular expression to match against in the payload
+ * @property {string} [replacement] The string to replace the matched regex with
+ */
+
+/**
+ * Represents an obfuscation rule validation state
+ * @typedef {object} ObfuscationRuleValidation
+ * @property {ObfuscationRule} rule The original rule validated
+ * @property {boolean} isValid Whether the rule is valid
+ * @property {object} errors Validation errors
+ * @property {boolean} errors.regexMissingDetected Whether the regex is missing
+ * @property {boolean} errors.invalidRegexDetected Whether the regex is invalid
+ * @property {boolean} errors.invalidReplacementDetected Whether the replacement is invalid
+ */
+
+export class Obfuscator {
+  /**
+   * @type {ObfuscationRuleValidation[]}
+   */
+  #ruleValidationCache;
+  constructor(agentIdentifier) {
+    this.#ruleValidationCache = Obfuscator.getRuleValidationCache(agentIdentifier);
+    Obfuscator.logObfuscationRuleErrors(this.#ruleValidationCache);
+  }
+  get ruleValidationCache() {
+    return this.#ruleValidationCache;
   }
 
-  // applies all regex obfuscation rules to provided URL string and returns the result
-  obfuscateString(string) {
-    // if string is empty string, null or not a string, return unmodified
-    if (!string || typeof string !== 'string') return string;
-    var rules = getRules(this.sharedContext.agentIdentifier);
-    var obfuscated = string;
+  /**
+   * Applies all valid obfuscation rules to the provided input string
+   * @param {string} input String to obfuscate
+   * @returns {string}
+   */
+  obfuscateString(input) {
+    // if input is not of type string or is an empty string, short-circuit
+    if (typeof input !== 'string' || input.trim().length === 0) return input;
+    return this.#ruleValidationCache.filter(ruleValidation => ruleValidation.isValid).reduce((input, ruleValidation) => {
+      const {
+        rule
+      } = ruleValidation;
+      return input.replace(rule.regex, rule.replacement || '*');
+    }, input);
+  }
 
-    // apply every rule to URL string
-    for (var i = 0; i < rules.length; i++) {
-      var regex = rules[i].regex;
-      var replacement = rules[i].replacement || '*';
-      obfuscated = obfuscated.replace(regex, replacement);
+  /**
+   * Returns an array of obfuscation rules to be applied to harvested payloads
+   * @param {string} agentIdentifier The agent identifier to get rules for
+   * @returns {ObfuscationRuleValidation[]} The array of rules or validation states
+   */
+  static getRuleValidationCache(agentIdentifier) {
+    /**
+     * @type {ObfuscationRule[]}
+     */
+    let rules = getConfigurationValue(agentIdentifier, 'obfuscate') || [];
+    if (isFileProtocol()) {
+      rules.push({
+        regex: /^file:\/\/(.*)/,
+        replacement: atob('ZmlsZTovL09CRlVTQ0FURUQ=')
+      });
     }
-    return obfuscated;
+    return rules.map(rule => Obfuscator.validateObfuscationRule(rule));
   }
-}
-
-// TO DO: this function should be inside the Obfuscator class since its context relates to agentID
-export function getRules(agentIdentifier) {
-  var rules = [];
-  var configRules = getConfigurationValue(agentIdentifier, 'obfuscate') || [];
-  rules = rules.concat(configRules);
-  if (isFileProtocol()) rules.push(fileProtocolRule);
-  // could add additional runtime/environment-specific rules here
 
-  return rules;
-}
+  /**
+   * Validates an obfuscation rule and provides errors if any are found.
+   * @param {ObfuscationRule} rule The rule to validate
+   * @returns {ObfuscationRuleValidation} The validation state of the rule
+   */
+  static validateObfuscationRule(rule) {
+    const regexMissingDetected = Boolean(rule.regex === undefined);
+    const invalidRegexDetected = Boolean(rule.regex !== undefined && typeof rule.regex !== 'string' && !(rule.regex instanceof RegExp));
+    const invalidReplacementDetected = Boolean(rule.replacement && typeof rule.replacement !== 'string');
+    return {
+      rule,
+      isValid: !regexMissingDetected && !invalidRegexDetected && !invalidReplacementDetected,
+      errors: {
+        regexMissingDetected,
+        invalidRegexDetected,
+        invalidReplacementDetected
+      }
+    };
+  }
 
-// takes array of rule objects, logs warning and returns false if any portion of rule is invalid
-export function validateRules(rules) {
-  var invalidReplacementDetected = false;
-  var invalidRegexDetected = false;
-  for (var i = 0; i < rules.length; i++) {
-    if (!('regex' in rules[i])) {
-      warn(12);
-      invalidRegexDetected = true;
-    } else if (typeof rules[i].regex !== 'string' && !(rules[i].regex instanceof RegExp)) {
-      warn(13);
-      invalidRegexDetected = true;
-    }
-    var replacement = rules[i].replacement;
-    if (replacement && typeof replacement !== 'string') {
-      warn(14);
-      invalidReplacementDetected = true;
+  /**
+   * Logs any obfuscation rule errors to the console. This is called when an obfuscator
+   * instance is created.
+   * @param {ObfuscationRuleValidation[]} ruleValidationCache The cache of rule validation states
+   */
+  static logObfuscationRuleErrors(ruleValidationCache) {
+    for (const ruleValidation of ruleValidationCache) {
+      const {
+        rule,
+        isValid,
+        errors
+      } = ruleValidation;
+      if (isValid) continue;
+      if (errors.regexMissingDetected) warn(12, rule);else if (errors.invalidRegexDetected) warn(13, rule);
+      if (errors.invalidReplacementDetected) warn(14, rule);
     }
   }
-  return !invalidReplacementDetected && !invalidRegexDetected;
 }

package/dist/esm/common/util/submit-data.js

@@ -16,10 +16,9 @@ import { isBrowserScope, supportsSendBeacon } from '../constants/runtime';
  * @param {boolean} opts.isFinalHarvest Indicates if the data submission is due to
  * a final harvest within the agent.
  */
-export function getSubmitMethod() {
-  let {
-    isFinalHarvest = false
-  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+export function getSubmitMethod({
+  isFinalHarvest = false
+} = {}) {
   return isFinalHarvest && isBrowserScope && supportsSendBeacon
   // Use sendBeacon for final harvest
   ? beacon
@@ -37,17 +36,16 @@ export function getSubmitMethod() {
  * @param {{key: string, value: string}[]} [args.headers] - The headers to attach.
  * @returns {XMLHttpRequest}
  */
-export function xhr(_ref) {
-  let {
-    url,
-    body = null,
-    sync,
-    method = 'POST',
-    headers = [{
-      key: 'content-type',
-      value: 'text/plain'
-    }]
-  } = _ref;
+export function xhr({
+  url,
+  body = null,
+  sync,
+  method = 'POST',
+  headers = [{
+    key: 'content-type',
+    value: 'text/plain'
+  }]
+}) {
   const request = new XMLHttpRequest();
   request.open(method, url, !sync);
   try {
@@ -70,11 +68,10 @@ export function xhr(_ref) {
  * @param {string=} args.body - The Stringified body
  * @returns {boolean}
  */
-export function beacon(_ref2) {
-  let {
-    url,
-    body
-  } = _ref2;
+export function beacon({
+  url,
+  body
+}) {
   try {
     // Navigator has to be bound to ensure it does not error in some browsers
     // https://xgwang.me/posts/you-may-not-know-beacon/#it-may-throw-error%2C-be-sure-to-catch

package/dist/esm/common/util/text.js

@@ -0,0 +1,3 @@
+export function toTitleCase(str, regex = /\w*/g) {
+  return str.replace(regex, text => text.charAt(0).toUpperCase() + text.substring(1).toLowerCase());
+}

package/dist/esm/common/util/traverse.js

@@ -12,9 +12,7 @@
  * @param {Array<string>} [ignoreKeys=[]] - The keys of properties to ignore and not modify.
  * @returns {Object} - The object with function recursively applied.
  */
-export function applyFnToProps(obj, fn) {
-  let type = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'string';
-  let ignoreKeys = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+export function applyFnToProps(obj, fn, type = 'string', ignoreKeys = []) {
   if (!obj || typeof obj !== 'object') return obj;
   Object.keys(obj).forEach(property => {
     if (typeof obj[property] === 'object') {

package/dist/esm/common/vitals/cumulative-layout-shift.js

@@ -4,12 +4,11 @@ import { VitalMetric } from './vital-metric';
 import { isBrowserScope } from '../constants/runtime';
 export const cumulativeLayoutShift = new VitalMetric(VITAL_NAMES.CUMULATIVE_LAYOUT_SHIFT, x => x);
 if (isBrowserScope) {
-  onCLS(_ref => {
-    let {
-      value,
-      attribution,
-      id
-    } = _ref;
+  onCLS(({
+    value,
+    attribution,
+    id
+  }) => {
     const attrs = {
       metricId: id,
       largestShiftTarget: attribution.largestShiftTarget,

package/dist/esm/common/vitals/first-contentful-paint.js

@@ -25,11 +25,10 @@ if (isBrowserScope) {
       // ignore
     }
   } else {
-    onFCP(_ref => {
-      let {
-        value,
-        attribution
-      } = _ref;
+    onFCP(({
+      value,
+      attribution
+    }) => {
       if (initiallyHidden || firstContentfulPaint.isValid) return;
       const attrs = {
         timeToFirstByte: attribution.timeToFirstByte,

package/dist/esm/common/vitals/first-input-delay.js

@@ -4,11 +4,10 @@ import { VITAL_NAMES } from './constants';
 import { initiallyHidden, isBrowserScope } from '../constants/runtime';
 export const firstInputDelay = new VitalMetric(VITAL_NAMES.FIRST_INPUT_DELAY);
 if (isBrowserScope) {
-  onFID(_ref => {
-    let {
-      value,
-      attribution
-    } = _ref;
+  onFID(({
+    value,
+    attribution
+  }) => {
     if (initiallyHidden || firstInputDelay.isValid) return;
     const attrs = {
       type: attribution.eventType,

package/dist/esm/common/vitals/interaction-to-next-paint.js

@@ -5,12 +5,11 @@ import { isBrowserScope } from '../constants/runtime';
 export const interactionToNextPaint = new VitalMetric(VITAL_NAMES.INTERACTION_TO_NEXT_PAINT);
 if (isBrowserScope) {
   /* Interaction-to-Next-Paint */
-  onINP(_ref => {
-    let {
-      value,
-      attribution,
-      id
-    } = _ref;
+  onINP(({
+    value,
+    attribution,
+    id
+  }) => {
     const attrs = {
       metricId: id,
       eventTarget: attribution.eventTarget,