@newrelic/browser-agent 0.1.230 → 0.1.231

package/dist/esm/common/url/parse-url.test.js

@@ -0,0 +1,107 @@
+afterEach(() => {
+  jest.resetModules();
+  jest.clearAllMocks();
+});
+const urlTests = [{
+  input: 'http://example.com/path/name?qs=5&a=b',
+  expected: {
+    hostname: 'example.com',
+    pathname: '/path/name',
+    protocol: 'http',
+    port: '80',
+    sameOrigin: false
+  }
+}, {
+  input: 'http://foo:bar@example.com:8080/path/@name?qs=5&a=b',
+  expected: {
+    hostname: 'example.com',
+    pathname: '/path/@name',
+    protocol: 'http',
+    port: '8080',
+    sameOrigin: false
+  }
+}, {
+  input: 'https://foo:bar@example.com/path/name?qs=5&a=b',
+  expected: {
+    hostname: 'example.com',
+    pathname: '/path/name',
+    protocol: 'https',
+    port: '443',
+    sameOrigin: false
+  }
+}, {
+  input: '/path/name?qs=5&a=b',
+  expected: {
+    hostname: location.hostname,
+    pathname: '/path/name',
+    protocol: location.protocol.split(':')[0],
+    port: '80',
+    sameOrigin: true
+  }
+}, {
+  input: location.protocol + '//' + location.hostname + ':' + location.port + '/path/name?qs=5&a=b',
+  expected: {
+    hostname: location.hostname,
+    pathname: '/path/name',
+    protocol: location.protocol.split(':')[0],
+    port: '80',
+    sameOrigin: true
+  }
+}, {
+  input: 'data:text/plain;base64,SGVsbG8sIFdvcmxkIQ==',
+  expected: {
+    protocol: 'data'
+  }
+}];
+test.each(urlTests)('verify url parsing inside browser scope', async _ref => {
+  let {
+    input,
+    expected
+  } = _ref;
+  jest.doMock('../util/global-scope', () => ({
+    __esModule: true,
+    isBrowserScope: true,
+    globalScope: global
+  }));
+  const {
+    parseUrl
+  } = await import('./parse-url');
+  expect(parseUrl(input)).toEqual(expected);
+});
+test.each(urlTests)('verify url parsing outside browser scope', async _ref2 => {
+  let {
+    input,
+    expected
+  } = _ref2;
+  jest.doMock('../util/global-scope', () => ({
+    __esModule: true,
+    isBrowserScope: false,
+    globalScope: global
+  }));
+  const {
+    parseUrl
+  } = await import('./parse-url');
+  expect(parseUrl(input)).toEqual(expected);
+});
+test('should cache parsed urls', async () => {
+  jest.doMock('../util/global-scope', () => ({
+    __esModule: true,
+    isBrowserScope: true,
+    globalScope: global
+  }));
+  const input = 'http://example.com/';
+  const expected = {
+    hostname: 'example.com',
+    pathname: '/',
+    protocol: 'http',
+    port: '80',
+    sameOrigin: false
+  };
+  jest.spyOn(document, 'createElement');
+  const {
+    parseUrl
+  } = await import('./parse-url');
+  parseUrl(input);
+  expect(parseUrl(input)).toEqual(expected);
+  expect(document.createElement).toHaveBeenCalledTimes(1);
+});

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

@@ -2,16 +2,7 @@
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { getGlobalScope } from '../util/global-scope';
-export const protocol = {
-  isFileProtocol: isFileProtocol,
-  supportabilityMetricSent: false
-};
-function isFileProtocol() {
-  let isFile = Boolean(getGlobalScope()?.location?.protocol === 'file:');
-  if (isFile) {
-    //metrics.recordSupportability('Generic/FileProtocol/Detected') -- may be implemented later? Probably make sure it's once per window
-    protocol.supportabilityMetricSent = true;
-  }
-  return isFile;
+import { globalScope } from '../util/global-scope';
+export function isFileProtocol() {
+  return Boolean(globalScope?.location?.protocol === 'file:');
 }

package/dist/esm/common/url/protocol.test.js

@@ -0,0 +1,14 @@
+import { faker } from '@faker-js/faker';
+import { isFileProtocol } from './protocol';
+test('should return true when location url contains file protocol', () => {
+  jest.spyOn(window, 'location', 'get').mockReturnValue({
+    protocol: 'file:'
+  });
+  expect(isFileProtocol()).toEqual(true);
+});
+test('should return false when location url does not contains file protocol', () => {
+  jest.spyOn(window, 'location', 'get').mockReturnValue({
+    protocol: 'http:'
+  });
+  expect(isFileProtocol()).toEqual(false);
+});

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

@@ -6,6 +6,6 @@
  */
 export function warn(message, secondary) {
   if (typeof console.warn !== 'function') return;
-  console.warn(`New Relic: ${message}`);
+  console.warn("New Relic: ".concat(message));
   if (secondary) console.warn(secondary);
 }

package/dist/esm/common/util/map-own.test.js

@@ -8,7 +8,7 @@ test('enumerates the object properties', () => {
   expect(callback).toHaveBeenCalledWith('foo', 'bar');
 });
 test('return array of results from callback invocation', () => {
-  const callback = jest.fn((key, value) => `${key}:${value}`);
+  const callback = jest.fn((key, value) => "".concat(key, ":").concat(value));
   const input = {
     foo: 'bar',
     biz: 'baz'
@@ -19,7 +19,7 @@ test('return array of results from callback invocation', () => {
   expect(result).toContain('biz:baz');
 });
 test('does not iterate symbol properties', () => {
-  const callback = jest.fn((key, value) => `${key}:${value}`);
+  const callback = jest.fn((key, value) => "".concat(key, ":").concat(value));
   const input = {
     foo: 'bar',
     [Symbol.for('biz')]: 'baz'
@@ -32,7 +32,7 @@ test('does not iterate inherited properties', () => {
   F.prototype = {
     biz: 'baz'
   };
-  const callback = jest.fn((key, value) => `${key}:${value}`);
+  const callback = jest.fn((key, value) => "".concat(key, ":").concat(value));
   const input = new F();
   input.foo = 'bar';
   const result = mapOwn(input, callback);

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

@@ -1,6 +1,6 @@
 import { getConfigurationValue } from '../config/config';
 import { SharedContext } from '../context/shared-context';
-import { protocol } from '../url/protocol';
+import { isFileProtocol } from '../url/protocol';
 import { warn } from './console';
 var fileProtocolRule = {
   regex: /^file:\/\/(.*)/,
@@ -37,7 +37,7 @@ export function getRules(agentIdentifier) {
   var rules = [];
   var configRules = getConfigurationValue(agentIdentifier, 'obfuscate') || [];
   rules = rules.concat(configRules);
-  if (protocol.isFileProtocol()) rules.push(fileProtocolRule);
+  if (isFileProtocol()) rules.push(fileProtocolRule);
   // could add additional runtime/environment-specific rules here
 
   return rules;

package/dist/esm/common/window/page-visibility.js

@@ -17,7 +17,8 @@ export function subscribeToVisibilityChange(cb) {
   function handleVisibilityChange() {
     if (toHiddenOnly) {
       // trigger cb on change to hidden state only
-      if (document.visibilityState == 'hidden') cb();else return;
+      if (document.visibilityState == 'hidden') cb();
+      return;
     }
     cb(document.visibilityState);
   }

package/dist/esm/common/wrap/index.js

@@ -2,7 +2,6 @@
  * @file Wraps assorted native objects and functions for instrumentation.
  */
 
-import { wrapConsole } from './wrap-console';
 import { wrapEvents } from './wrap-events';
 import { wrapFetch } from './wrap-fetch';
 import { wrapHistory } from './wrap-history';
@@ -12,4 +11,4 @@ import { wrapPromise } from './wrap-promise';
 import { wrapRaf } from './wrap-raf';
 import { wrapTimer } from './wrap-timer';
 import { wrapXhr } from './wrap-xhr';
-export { wrapConsole, wrapEvents, wrapFetch, wrapHistory, wrapJsonP, wrapMutation, wrapPromise, wrapRaf, wrapTimer, wrapXhr };
+export { wrapEvents, wrapFetch, wrapHistory, wrapJsonP, wrapMutation, wrapPromise, wrapRaf, wrapTimer, wrapXhr };

package/dist/esm/common/wrap/wrap-events.js

@@ -25,19 +25,16 @@ const REMOVE_EVENT_LISTENER = 'removeEventListener';
  */
 export function wrapEvents(sharedEE) {
   var ee = scopedEE(sharedEE);
-  if (wrapped[ee.debugId]++)
-    // Notice if our wrapping never ran yet, the falsey NaN will not early return; but if it has,
-    {
-      return ee;
-    } // then we increment the count to track # of feats using this at runtime.
-  wrapped[ee.debugId] = 1;
+
+  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,
+  // then we increment the count to track # of feats using this at runtime.
+  if (wrapped[ee.debugId]++) return ee;
+  wrapped[ee.debugId] = 1; // otherwise, first feature to wrap events
   var wrapFn = wfn(ee, true);
 
   // Guard against instrumenting environments w/o necessary features
   if ('getPrototypeOf' in Object) {
-    if (isBrowserScope) {
-      findEventListenerProtoAndCb(document, wrapNode);
-    }
+    if (isBrowserScope) findEventListenerProtoAndCb(document, wrapNode);
     findEventListenerProtoAndCb(globalScope, wrapNode);
     findEventListenerProtoAndCb(XHR.prototype, wrapNode);
   }

package/dist/esm/common/wrap/wrap-fetch.js

@@ -32,12 +32,12 @@ export function wrapFetch(sharedEE) {
   if (!(Req && Res && globalScope.fetch)) {
     return ee;
   }
-  if (wrapped[ee.debugId]++)
-    // Notice if our wrapping never ran yet, the falsey NaN will not early return; but if it has,
-    {
-      return ee;
-    } // then we increment the count to track # of feats using this at runtime.
-  wrapped[ee.debugId] = 1;
+
+  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,
+  // then we increment the count to track # of feats using this at runtime.
+  if (wrapped[ee.debugId]++) return ee;
+  wrapped[ee.debugId] = 1; // otherwise, first feature to wrap fetch
+
   bodyMethods.forEach(method => {
     wrapPromiseMethod(Req[proto], method, bodyPrefix);
     wrapPromiseMethod(Res[proto], method, bodyPrefix);

package/dist/esm/common/wrap/wrap-history.js

@@ -20,12 +20,13 @@ const HISTORY_FNS = ['pushState', 'replaceState'];
  */
 export function wrapHistory(sharedEE) {
   const ee = scopedEE(sharedEE);
-  if (!isBrowserScope || wrapped[ee.debugId]++)
-    // Notice if our wrapping never ran yet, the falsey NaN will not early return; but if it has,
-    {
-      return ee;
-    } // then we increment the count to track # of feats using this at runtime. (History API is only avail in browser DOM context.)
-  wrapped[ee.debugId] = 1;
+
+  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,
+  // then we increment the count to track # of feats using this at runtime. History API is only
+  // available in browser DOM context.
+  if (!isBrowserScope || wrapped[ee.debugId]++) return ee;
+  wrapped[ee.debugId] = 1; // otherwise, first feature to wrap history
+
   var wrapFn = wfn(ee);
   /*
    * For objects that will be instantiated more than once, we wrap the object's prototype methods. The history object

package/dist/esm/common/wrap/wrap-jsonp.js

@@ -22,12 +22,13 @@ const domInsertMethods = ['appendChild', 'insertBefore', 'replaceChild'];
  */
 export function wrapJsonP(sharedEE) {
   const ee = scopedEE(sharedEE);
-  if (!isBrowserScope || wrapped[ee.debugId])
-    // JSONP deals with DOM tags so browser window env is req'd
-    {
-      return ee;
-    }
-  wrapped[ee.debugId] = true;
+
+  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,
+  // then we increment the count to track # of feats using this at runtime.  JSONP deals with DOM
+  // tags so browser window env is required.
+  if (!isBrowserScope || wrapped[ee.debugId]) return ee;
+  wrapped[ee.debugId] = true; // otherwise, first feature to wrap JSONP
+
   var wrapFn = wfn(ee);
   var CALLBACK_REGEX = /[?&](?:callback|cb)=([^&#]+)/;
   var PARENT_REGEX = /(.*)\.([^.]+)/;

package/dist/esm/common/wrap/wrap-mutation.js

@@ -21,12 +21,13 @@ const wrapped = {};
  */
 export function wrapMutation(sharedEE) {
   const ee = scopedEE(sharedEE);
-  if (!isBrowserScope || wrapped[ee.debugId])
-    // relates to the DOM tree (web env only)
-    {
-      return ee;
-    }
-  wrapped[ee.debugId] = true;
+
+  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,
+  // then we increment the count to track # of feats using this at runtime. Mutations API is only
+  // available in browser DOM context.
+  if (!isBrowserScope || wrapped[ee.debugId]) return ee;
+  wrapped[ee.debugId] = true; // otherwise, first feature to wrap mutations
+
   var wrapFn = wfn(ee);
   var OriginalObserver = originals.MO;
   if (OriginalObserver) {

package/dist/esm/common/wrap/wrap-promise.js

@@ -22,10 +22,12 @@ const wrapped = {};
  */
 export function wrapPromise(sharedEE) {
   const promiseEE = scopedEE(sharedEE);
-  if (wrapped[promiseEE.debugId]) {
-    return promiseEE;
-  }
-  wrapped[promiseEE.debugId] = true;
+
+  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,
+  // then we increment the count to track # of feats using this at runtime.
+  if (wrapped[promiseEE.debugId]) return promiseEE;
+  wrapped[promiseEE.debugId] = true; // otherwise, first feature to wrap promise
+
   var getContext = getOrSetContext;
   var promiseWrapper = wrapFn(promiseEE);
   var prevPromiseObj = originals.PR;
@@ -67,8 +69,7 @@ export function wrapPromise(sharedEE) {
       WrappedPromise[method] = function (subPromises) {
         // use our own wrapped version of "Promise.all" and ".race" static fns
         let finalized = false;
-        subPromises?.forEach(sub => {
-          // eslint-disable-next-line
+        Array.from(subPromises || []).forEach(sub => {
           this.resolve(sub).then(setNrId(method === 'all'), setNrId(false));
         });
         const origFnCallWithThis = prevStaticFn.apply(this, arguments);

package/dist/esm/common/wrap/wrap-promise.test.js

@@ -0,0 +1,115 @@
+import { faker } from '@faker-js/faker';
+import { globalScope } from '../util/global-scope';
+import { originals } from '../config/config';
+jest.mock('./wrap-function', () => ({
+  __esModule: true,
+  createWrapperWithEmitter: jest.fn(() => fn => function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return fn.apply(null, args);
+  })
+}));
+jest.mock('../event-emitter/contextual-ee', () => ({
+  __esModule: true,
+  getOrSetContext: jest.fn(() => ({})),
+  ee: {
+    get: jest.fn(name => ({
+      debugId: name,
+      on: jest.fn(),
+      context: jest.fn(() => ({})),
+      emit: jest.fn()
+    }))
+  }
+}));
+jest.mock('../config/config', () => ({
+  __esModule: true,
+  originals: {}
+}));
+jest.mock('../util/global-scope', () => ({
+  __esModule: true,
+  globalScope: {
+    NREUM: {}
+  }
+}));
+let promiseConstructorCalls;
+beforeEach(async () => {
+  promiseConstructorCalls = [];
+
+  // Proxy the global Promise to prevent the wrapping from
+  // messing with Jest internal promises
+  originals.PR = new Proxy(class extends Promise {}, {
+    construct(target, args) {
+      promiseConstructorCalls.push(args);
+      return Reflect.construct(target, args);
+    }
+  });
+  (await import('./wrap-promise')).wrapPromise();
+});
+afterEach(() => {
+  jest.resetModules();
+});
+test('should wrap promise constructor', async () => {
+  const promiseInstance = new globalScope.Promise(jest.fn());
+  expect(promiseInstance).toBeInstanceOf(Promise);
+  expect(promiseConstructorCalls.length).toEqual(1);
+  expect(globalScope.Promise.toString()).toMatch(/\[native code\]/);
+  expect(globalScope.Promise.name).toEqual('Promise');
+});
+describe('all', () => {
+  test('should work with acceptable iterables', async () => {
+    const resolveValue = faker.datatype.uuid();
+    const customIterable = new CustomIterable([new globalScope.Promise(resolve => resolve(resolveValue))]);
+    const arrayIterable = [new globalScope.Promise(resolve => resolve(resolveValue))];
+    const setIterable = new Set();
+    setIterable.add(new globalScope.Promise(resolve => resolve(resolveValue)));
+    await expect(globalScope.Promise.all(customIterable)).resolves.toEqual([resolveValue]);
+    await expect(globalScope.Promise.all(arrayIterable)).resolves.toEqual([resolveValue]);
+    await expect(globalScope.Promise.all(setIterable)).resolves.toEqual([resolveValue]);
+  });
+  test.each([null, undefined])('should not try to iterate a non-iterable %s', async input => {
+    jest.spyOn(globalScope.Promise, 'resolve');
+    await expect(globalScope.Promise.all(input)).rejects.toThrow();
+    expect(globalScope.Promise.resolve).not.toHaveBeenCalled();
+  });
+});
+describe('race', () => {
+  test('should work with acceptable iterables', async () => {
+    jest.spyOn(globalScope.Promise, 'resolve');
+    const resolveValue = faker.datatype.uuid();
+    const customIterable = new CustomIterable([new globalScope.Promise(resolve => resolve(resolveValue))]);
+    const arrayIterable = [new globalScope.Promise(resolve => resolve(resolveValue))];
+    const setIterable = new Set();
+    setIterable.add(new globalScope.Promise(resolve => resolve(resolveValue)));
+    await expect(globalScope.Promise.race(customIterable)).resolves.toEqual(resolveValue);
+    await expect(globalScope.Promise.race(arrayIterable)).resolves.toEqual(resolveValue);
+    await expect(globalScope.Promise.race(setIterable)).resolves.toEqual(resolveValue);
+    expect(globalScope.Promise.resolve).toHaveBeenCalled();
+  });
+  test.each([null, undefined])('should not try to iterate a non-iterable %s', async input => {
+    jest.spyOn(globalScope.Promise, 'resolve');
+    await expect(globalScope.Promise.race(input)).rejects.toThrow();
+    expect(globalScope.Promise.resolve).not.toHaveBeenCalled();
+  });
+});
+class CustomIterable {
+  #iterables = [];
+  constructor(iterables) {
+    this.#iterables = iterables;
+  }
+  [Symbol.iterator]() {
+    return {
+      index: 0,
+      iterables: this.#iterables,
+      next() {
+        return {
+          done: this.index >= this.iterables.length,
+          value: this.iterables[this.index++] || undefined
+        };
+      },
+      [Symbol.iterator]() {
+        return this;
+      }
+    };
+  }
+}

package/dist/esm/common/wrap/wrap-raf.js

@@ -21,12 +21,12 @@ const RAF_NAME = 'requestAnimationFrame';
  */
 export function wrapRaf(sharedEE) {
   const ee = scopedEE(sharedEE);
-  if (!isBrowserScope || wrapped[ee.debugId]++)
-    // Notice if our wrapping never ran yet, the falsey NaN will not early return; but if it has,
-    {
-      return ee;
-    } // then we increment the count to track # of feats using this at runtime. (RAF is only avail in browser DOM context.)
-  wrapped[ee.debugId] = 1;
+
+  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,
+  // then we increment the count to track # of feats using this at runtime.
+  if (!isBrowserScope || wrapped[ee.debugId]++) return ee;
+  wrapped[ee.debugId] = 1; // otherwise, first feature to wrap RAF
+
   var wrapFn = wfn(ee);
   wrapFn.inPlace(window, [RAF_NAME], 'raf-');
   ee.on('raf-start', function (args) {

package/dist/esm/common/wrap/wrap-timer.js

@@ -28,12 +28,12 @@ const TIMER_FNS = [SET_TIMEOUT, 'setImmediate', SET_INTERVAL, CLEAR_TIMEOUT, 'cl
 //eslint-disable-next-line
 export function wrapTimer(sharedEE) {
   const ee = scopedEE(sharedEE);
-  if (wrapped[ee.debugId]++)
-    // Notice if our wrapping never ran yet, the falsey NaN will not early return; but if it has,
-    {
-      return ee;
-    } // then we increment the count to track # of feats using this at runtime.
-  wrapped[ee.debugId] = 1;
+
+  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,
+  // then we increment the count to track # of feats using this at runtime.
+  if (wrapped[ee.debugId]++) return ee;
+  wrapped[ee.debugId] = 1; // otherwise, first feature to wrap timer
+
   var wrapFn = wfn(ee);
   wrapFn.inPlace(globalScope, TIMER_FNS.slice(0, 2), SET_TIMEOUT + DASH);
   wrapFn.inPlace(globalScope, TIMER_FNS.slice(2, 3), SET_INTERVAL + DASH);

package/dist/esm/common/wrap/wrap-xhr.js

@@ -27,12 +27,11 @@ const XHR_PROPS = ['open', 'send']; // these are the specific funcs being wrappe
 export function wrapXhr(sharedEE) {
   var baseEE = sharedEE || contextualEE;
   const ee = scopedEE(baseEE);
-  if (wrapped[ee.debugId]++)
-    // Notice if our wrapping never ran yet, the falsey NaN will not early return; but if it has,
-    {
-      return ee;
-    } // then we increment the count to track # of feats using this at runtime.
-  wrapped[ee.debugId] = 1; // <- otherwise, first feature to wrap XHR
+
+  // Notice if our wrapping never ran yet, the falsy NaN will not early return; but if it has,
+  // then we increment the count to track # of feats using this at runtime.
+  if (wrapped[ee.debugId]++) return ee;
+  wrapped[ee.debugId] = 1; // otherwise, first feature to wrap XHR
 
   wrapEvents(baseEE); // wrap-events patches XMLHttpRequest.prototype.addEventListener for us
   var wrapFn = wfn(ee);

package/dist/esm/features/ajax/aggregate/index.js

@@ -55,7 +55,7 @@ export class Aggregate extends AggregateBase {
         onFinished: onEventsHarvestFinished,
         getPayload: prepareHarvest
       }, this);
-      ee.on(`drain-${this.featureName}`, () => {
+      ee.on("drain-".concat(this.featureName), () => {
         scheduler.startTimer(harvestTimeSeconds);
       });
     }

package/dist/esm/features/jserrors/aggregate/compute-stack-trace.test.js

@@ -144,7 +144,7 @@ describe('errors without stack property and with line property', () => {
       mode: 'sourceline',
       name: mockError.name,
       message: mockError.message,
-      stackString: `${mockError.name}: ${mockError.message}\n    at ${sourceURL}:${mockError.line}`
+      stackString: "".concat(mockError.name, ": ").concat(mockError.message, "\n    at ").concat(sourceURL, ":").concat(mockError.line)
     }));
     expect(result.frames.length).toEqual(1);
     expect(result.frames).toContainEqual(expect.objectContaining({
@@ -170,7 +170,7 @@ describe('errors without stack property and with line property', () => {
       mode: 'sourceline',
       name: mockError.name,
       message: mockError.message,
-      stackString: `${mockError.name}: ${mockError.message}\n    at ${sourceURL}:${mockError.line}:${mockError.column}`
+      stackString: "".concat(mockError.name, ": ").concat(mockError.message, "\n    at ").concat(sourceURL, ":").concat(mockError.line, ":").concat(mockError.column)
     }));
     expect(result.frames.length).toEqual(1);
     expect(result.frames).toContainEqual(expect.objectContaining({
@@ -191,7 +191,7 @@ describe('errors without stack property and with line property', () => {
       mode: 'sourceline',
       name: mockError.name,
       message: mockError.message,
-      stackString: `RangeError: ${mockError.message}\n    in evaluated code`
+      stackString: "RangeError: ".concat(mockError.message, "\n    in evaluated code")
     }));
     expect(result.frames.length).toEqual(1);
     expect(result.frames).toContainEqual(expect.objectContaining({
@@ -230,7 +230,7 @@ describe('errors that are messages only or primitives', () => {
     expect(result).toEqual(expect.objectContaining({
       mode: 'nameonly',
       name: mockError.name,
-      stackString: `${mockError.name}: undefined`,
+      stackString: "".concat(mockError.name, ": undefined"),
       frames: []
     }));
   });
@@ -246,7 +246,7 @@ describe('errors that are messages only or primitives', () => {
       mode: 'nameonly',
       name: mockError.name,
       message: mockError.message,
-      stackString: `${mockError.name}: ${mockError.message}`,
+      stackString: "".concat(mockError.name, ": ").concat(mockError.message),
       frames: []
     }));
   });

package/dist/esm/features/jserrors/aggregate/format-stack-trace.test.js

@@ -23,7 +23,7 @@ describe('formatStackTrace', () => {
   });
   test('truncates the middle of the stack lines when more than 100', () => {
     const input = Array.apply(null, Array(200)).map(() => faker.datatype.uuid());
-    const expected = input.slice(0, 50).join('\n') + `\n< ...truncated ${input.length - 100} lines... >\n` + input.slice(-50).join('\n');
+    const expected = input.slice(0, 50).join('\n') + "\n< ...truncated ".concat(input.length - 100, " lines... >\n") + input.slice(-50).join('\n');
     const result = formatStackTrace(input);
     expect(result).toEqual(expected);
   });

package/dist/esm/features/jserrors/aggregate/index.js

@@ -54,7 +54,7 @@ export class Aggregate extends AggregateBase {
     });
 
     // Don't start harvesting until "drain" for this feat has been called (which currently requires RUM response).
-    this.ee.on(`drain-${this.featureName}`, () => {
+    this.ee.on("drain-".concat(this.featureName), () => {
       if (!this.blocked) scheduler.startTimer(harvestTimeSeconds); // and only if ingest will accept jserror payloads
     });
 
@@ -98,7 +98,7 @@ export class Aggregate extends AggregateBase {
     }
   }
   nameHash(params) {
-    return stringHashCode(`${params.exceptionClass}_${params.message}_${params.stack_trace || params.browser_stack_hash}`);
+    return stringHashCode("".concat(params.exceptionClass, "_").concat(params.message, "_").concat(params.stack_trace || params.browser_stack_hash));
   }
   getBucketName(params, customParams) {
     return this.nameHash(params) + ':' + stringHashCode(stringify(customParams));
@@ -180,7 +180,7 @@ export class Aggregate extends AggregateBase {
      * the canonical stack trace excludes items like the column number increasing the hit-rate of different errors potentially
      * bucketing and ultimately resulting in the loss of data in NR1.
      */
-    var bucketHash = stringHashCode(`${stackInfo.name}_${stackInfo.message}_${stackInfo.stackString}`);
+    var bucketHash = stringHashCode("".concat(stackInfo.name, "_").concat(stackInfo.message, "_").concat(stackInfo.stackString));
     if (!this.stackReported[bucketHash]) {
       this.stackReported[bucketHash] = true;
       params.stack_trace = truncateSize(stackInfo.stackString);

package/dist/esm/features/jserrors/instrument/index.js

@@ -25,9 +25,9 @@ export class Instrument extends InstrumentBase {
     // errors that will be the same as caught errors.
     this.skipNext = 0;
     try {
+      // this try-catch can be removed when IE11 is completely unsupported & gone
       this.removeOnAbort = new AbortController();
-    } // this try-catch can be removed when IE11 is completely unsupported & gone
-    catch (e) {}
+    } catch (e) {}
     const thisInstrument = this;
     thisInstrument.ee.on('fn-start', function (args, obj, methodName) {
       if (thisInstrument.abortHandler) thisInstrument.skipNext += 1;