@newrelic/browser-agent 0.1.229 → 0.1.231

package/dist/cjs/common/window/session-storage.js

@@ -3,9 +3,11 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.getAllStorageItemsOfGroup = getAllStorageItemsOfGroup;
 exports.getCurrentSessionIdOrMakeNew = getCurrentSessionIdOrMakeNew;
+exports.putInBrowserStorage = putInBrowserStorage;
+exports.removeFromBrowserStorage = removeFromBrowserStorage;
 var _uniqueId = require("../ids/unique-id");
-var _globalScope = require("../util/global-scope");
 /**
  * Interface for Agents' usage of the Window.sessionStorage as a replacement to third-party cookies.
  *  (All agents on a tab|window will share the same sessionStorage.)
@@ -14,29 +16,72 @@ var _globalScope = require("../util/global-scope");
  * @environment Browser script
  */
 
-const SESS_ID = 'NRBA_SESSION_ID'; // prevents potential key collisions in session storage
+const AGENT_PREFIX = 'NRBA/';
+
+/**
+ * @param {string} key
+ * @param {string} value
+ * @returns true, if item was set successfully. false, if storage is full or setItem threw an exception.
+ */
+function putInBrowserStorage(key, value) {
+  let subgroup = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+  try {
+    window.sessionStorage.setItem(AGENT_PREFIX + subgroup + key, value);
+    return true;
+  } catch (ex) {
+    // Session storage may be full.
+    return false;
+  }
+}
+/**
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Storage/getItem}
+ * @param {string} key
+ */
+function getFromBrowserStorage(key) {
+  let subgroup = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  return window.sessionStorage.getItem(AGENT_PREFIX + subgroup + key);
+}
+function removeFromBrowserStorage(key) {
+  let subgroup = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  try {
+    window.sessionStorage.removeItem(AGENT_PREFIX + subgroup + key);
+  } catch (e) {}
+}
 
 /**
  * @returns {string} This tab|window's session identifier, or a new ID if not found in storage
  */
 function getCurrentSessionIdOrMakeNew() {
-  if (!_globalScope.isBrowserScope) {
-    return null;
-  }
   try {
     let sessionId;
-    if ((sessionId = window.sessionStorage.getItem(SESS_ID)) === null) {
+    if ((sessionId = getFromBrowserStorage('SESSION_ID')) === null) {
       // Generate a new one if storage is empty (no previous ID was created or currently exists)
       sessionId = (0, _uniqueId.generateRandomHexString)(16);
-      window.sessionStorage.setItem(SESS_ID, sessionId);
+      putInBrowserStorage('SESSION_ID', sessionId);
     }
     return sessionId;
   } catch (ex) {
-    // Session storage quota most likely 0mb and cannot be written to
-    // OR the agent is running in a security context that does not allow
-    // access to the browser sessionStorage
+    // The agent is running in a security context that does not allow access to the sessionStorage or is not in browser window context.
     return null;
   }
 }
 
-// In the future, we may expand sessionStorage to, say, auto-save some other agent data between page refreshes.
+/**
+ * Look through the page's sessionStorage items and gather the ones that was set under some grouping label, if applicable.
+ * @param {string} [subgroup] - empty string by default, which will return all items set by browser agent
+ * @returns An object of the key-value items from putInBrowserStorage calls from agents with access to the same storage space.
+ */
+function getAllStorageItemsOfGroup() {
+  let subgroup = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  const prefixFilter = AGENT_PREFIX + subgroup;
+  const groupItems = {};
+  try {
+    for (let i = 0; i < window.sessionStorage.length; i++) {
+      let key = window.sessionStorage.key(i);
+      if (!key.startsWith(prefixFilter)) continue;else key = key.slice(prefixFilter.length); // this removes the "NRBA/<subgroup>" prefix so we get back the original key putInBrowserStorage
+
+      groupItems[key] = getFromBrowserStorage(key, subgroup);
+    }
+  } catch (ex) {}
+  return groupItems;
+}

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

@@ -57,12 +57,12 @@ Object.defineProperty(exports, "wrapXhr", {
     return _wrapXhr.wrapXhr;
   }
 });
+var _wrapEvents = require("./wrap-events");
 var _wrapFetch = require("./wrap-fetch");
-var _wrapTimer = require("./wrap-timer");
-var _wrapRaf = require("./wrap-raf");
 var _wrapHistory = require("./wrap-history");
 var _wrapJsonp = require("./wrap-jsonp");
 var _wrapMutation = require("./wrap-mutation");
 var _wrapPromise = require("./wrap-promise");
-var _wrapXhr = require("./wrap-xhr");
-var _wrapEvents = require("./wrap-events");
+var _wrapRaf = require("./wrap-raf");
+var _wrapTimer = require("./wrap-timer");
+var _wrapXhr = require("./wrap-xhr");

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

@@ -33,19 +33,16 @@ const REMOVE_EVENT_LISTENER = 'removeEventListener';
  */
 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 = (0, _wrapFunction.createWrapperWithEmitter)(ee, true);
 
   // Guard against instrumenting environments w/o necessary features
   if ('getPrototypeOf' in Object) {
-    if (_globalScope.isBrowserScope) {
-      findEventListenerProtoAndCb(document, wrapNode);
-    }
+    if (_globalScope.isBrowserScope) findEventListenerProtoAndCb(document, wrapNode);
     findEventListenerProtoAndCb(_globalScope.globalScope, wrapNode);
     findEventListenerProtoAndCb(XHR.prototype, wrapNode);
   }
@@ -85,11 +82,14 @@ function wrapEvents(sharedEE) {
  * @param {Function} cb - the function to run on the ancestral object once found, accepts an object as a arg
  * @param {Array} rest - [optional] any additional arguments to pass to the cb
  */
-function findEventListenerProtoAndCb(object, cb, ...rest) {
+function findEventListenerProtoAndCb(object, cb) {
   let step = object;
   while (typeof step === 'object' && !Object.prototype.hasOwnProperty.call(step, ADD_EVENT_LISTENER)) {
     step = Object.getPrototypeOf(step);
   }
+  for (var _len = arguments.length, rest = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+    rest[_key - 2] = arguments[_key];
+  }
   if (step) cb(step, ...rest);
 }
 

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

@@ -41,12 +41,12 @@ function wrapFetch(sharedEE) {
   if (!(Req && Res && _globalScope.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);
@@ -95,10 +95,8 @@ function wrapFetch(sharedEE) {
           throw err;
         });
       };
-      target[name][_wrapFunction.flag] = fn; // track original similar to in wrap-function.js, so that they can be unwrapped with ease
     }
   }
-
   return ee;
 }
 

package/dist/cjs/common/wrap/wrap-function.js

@@ -5,7 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createWrapperWithEmitter = createWrapperWithEmitter;
 exports.flag = exports.default = void 0;
-exports.unwrapFunction = unwrapFunction;
 exports.wrapFunction = wrapFunction;
 exports.wrapInPlace = wrapInPlace;
 var _contextualEe = require("../event-emitter/contextual-ee");
@@ -115,7 +114,8 @@ function createWrapperWithEmitter(emitter, always) {
    * Creates wrapper functions around each of an array of methods on a specified object.
    * @param {Object} obj - The object to which the specified methods belong.
    * @param {string[]} methods - An array of method names to be wrapped.
-   * @param {string} [prefix=''] - A prefix to add to the names of emitted events.
+   * @param {string} [prefix=''] - A prefix to add to the names of emitted events. If `-` is the first character, also
+   *     adds the method name before the prefix.
    * @param {function|object} [getContext] - The function or object that will serve as the 'this' context for handlers
    *     of events emitted by this wrapper.
    * @param {boolean} [bubble=false] - If `true`, emitted events should also bubble up to the old emitter upon which
@@ -123,8 +123,7 @@ function createWrapperWithEmitter(emitter, always) {
    */
   function inPlace(obj, methods, prefix, getContext, bubble) {
     if (!prefix) prefix = '';
-    // If prefix starts with '-' set this boolean to add the method name to
-    // the prefix before passing each one to wrap.
+    // If prefix starts with '-' set this boolean to add the method name to the prefix before passing each one to wrap.
     var prependMethodPrefix = prefix.charAt(0) === '-';
     var fn;
     var method;
@@ -133,8 +132,7 @@ function createWrapperWithEmitter(emitter, always) {
       method = methods[i];
       fn = obj[method];
 
-      // Unless fn is both wrappable and unwrapped bail,
-      // so we don't add extra properties with undefined values.
+      // Unless fn is both wrappable and unwrapped, bail so we don't add extra properties with undefined values.
       if (notWrappable(fn)) continue;
       obj[method] = wrapFn(fn, prependMethodPrefix ? method + prefix : prefix, getContext, method, bubble);
     }
@@ -254,16 +252,4 @@ function wrapFunction(fn, wrapper) {
 function wrapInPlace(obj, fnName, wrapper) {
   var fn = obj[fnName];
   obj[fnName] = wrapFunction(fn, wrapper);
-}
-
-/**
- * If a function property on an object (e.g. window) was previously wrapped (by this module), removes the wrapper.
- * @param {Object} obj - The object on which the named function is a property.
- * @param {string} fnName - The name of the function to be unwrapped.
- */
-function unwrapFunction(obj, fnName) {
-  if (obj?.[fnName]?.[flag]) {
-    // previous state of the function property is stored under our wrapper's "flag"; we don't wrap properties that *were* undefined to begin with
-    obj[fnName] = obj[fnName][flag];
-  }
 }

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

@@ -28,12 +28,13 @@ const HISTORY_FNS = ['pushState', 'replaceState'];
  */
 function wrapHistory(sharedEE) {
   const ee = scopedEE(sharedEE);
-  if (!_globalScope.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 (!_globalScope.isBrowserScope || wrapped[ee.debugId]++) return ee;
+  wrapped[ee.debugId] = 1; // otherwise, first feature to wrap history
+
   var wrapFn = (0, _wrapFunction.createWrapperWithEmitter)(ee);
   /*
    * For objects that will be instantiated more than once, we wrap the object's prototype methods. The history object

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

@@ -29,12 +29,13 @@ const domInsertMethods = ['appendChild', 'insertBefore', 'replaceChild'];
  */
 function wrapJsonP(sharedEE) {
   const ee = scopedEE(sharedEE);
-  if (!_globalScope.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 (!_globalScope.isBrowserScope || wrapped[ee.debugId]) return ee;
+  wrapped[ee.debugId] = true; // otherwise, first feature to wrap JSONP
+
   var wrapFn = (0, _wrapFunction.createWrapperWithEmitter)(ee);
   var CALLBACK_REGEX = /[?&](?:callback|cb)=([^&#]+)/;
   var PARENT_REGEX = /(.*)\.([^.]+)/;

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

@@ -28,12 +28,13 @@ const wrapped = {};
  */
 function wrapMutation(sharedEE) {
   const ee = scopedEE(sharedEE);
-  if (!_globalScope.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 (!_globalScope.isBrowserScope || wrapped[ee.debugId]) return ee;
+  wrapped[ee.debugId] = true; // otherwise, first feature to wrap mutations
+
   var wrapFn = (0, _wrapFunction.createWrapperWithEmitter)(ee);
   var OriginalObserver = _config.originals.MO;
   if (OriginalObserver) {

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

@@ -29,10 +29,12 @@ const wrapped = {};
  */
 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 = _contextualEe.getOrSetContext;
   var promiseWrapper = (0, _wrapFunction.createWrapperWithEmitter)(promiseEE);
   var prevPromiseObj = _config.originals.PR;
@@ -74,8 +76,7 @@ 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);
@@ -111,10 +112,13 @@ function wrapPromise(sharedEE) {
 
     // Note that this wrapping affects the same originals.PR (prototype) object.
     const prevPromiseOrigThen = prevPromiseObj.prototype.then;
-    prevPromiseObj.prototype.then = function wrappedThen(...args) {
+    prevPromiseObj.prototype.then = function wrappedThen() {
       var originalThis = this;
       var ctx = getContext(originalThis);
       ctx.promise = originalThis;
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
       args[0] = promiseWrapper(args[0], 'cb-', ctx, null, false);
       args[1] = promiseWrapper(args[1], 'cb-', ctx, null, false);
       const origFnCallWithThis = prevPromiseOrigThen.apply(this, args);

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

@@ -0,0 +1,119 @@
+"use strict";
+
+var _faker = require("@faker-js/faker");
+var _globalScope = require("../util/global-scope");
+var _config = require("../config/config");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+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
+  _config.originals.PR = new Proxy(class extends Promise {}, {
+    construct(target, args) {
+      promiseConstructorCalls.push(args);
+      return Reflect.construct(target, args);
+    }
+  });
+  (await Promise.resolve().then(() => _interopRequireWildcard(require('./wrap-promise')))).wrapPromise();
+});
+afterEach(() => {
+  jest.resetModules();
+});
+test('should wrap promise constructor', async () => {
+  const promiseInstance = new _globalScope.globalScope.Promise(jest.fn());
+  expect(promiseInstance).toBeInstanceOf(Promise);
+  expect(promiseConstructorCalls.length).toEqual(1);
+  expect(_globalScope.globalScope.Promise.toString()).toMatch(/\[native code\]/);
+  expect(_globalScope.globalScope.Promise.name).toEqual('Promise');
+});
+describe('all', () => {
+  test('should work with acceptable iterables', async () => {
+    const resolveValue = _faker.faker.datatype.uuid();
+    const customIterable = new CustomIterable([new _globalScope.globalScope.Promise(resolve => resolve(resolveValue))]);
+    const arrayIterable = [new _globalScope.globalScope.Promise(resolve => resolve(resolveValue))];
+    const setIterable = new Set();
+    setIterable.add(new _globalScope.globalScope.Promise(resolve => resolve(resolveValue)));
+    await expect(_globalScope.globalScope.Promise.all(customIterable)).resolves.toEqual([resolveValue]);
+    await expect(_globalScope.globalScope.Promise.all(arrayIterable)).resolves.toEqual([resolveValue]);
+    await expect(_globalScope.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.globalScope.Promise, 'resolve');
+    await expect(_globalScope.globalScope.Promise.all(input)).rejects.toThrow();
+    expect(_globalScope.globalScope.Promise.resolve).not.toHaveBeenCalled();
+  });
+});
+describe('race', () => {
+  test('should work with acceptable iterables', async () => {
+    jest.spyOn(_globalScope.globalScope.Promise, 'resolve');
+    const resolveValue = _faker.faker.datatype.uuid();
+    const customIterable = new CustomIterable([new _globalScope.globalScope.Promise(resolve => resolve(resolveValue))]);
+    const arrayIterable = [new _globalScope.globalScope.Promise(resolve => resolve(resolveValue))];
+    const setIterable = new Set();
+    setIterable.add(new _globalScope.globalScope.Promise(resolve => resolve(resolveValue)));
+    await expect(_globalScope.globalScope.Promise.race(customIterable)).resolves.toEqual(resolveValue);
+    await expect(_globalScope.globalScope.Promise.race(arrayIterable)).resolves.toEqual(resolveValue);
+    await expect(_globalScope.globalScope.Promise.race(setIterable)).resolves.toEqual(resolveValue);
+    expect(_globalScope.globalScope.Promise.resolve).toHaveBeenCalled();
+  });
+  test.each([null, undefined])('should not try to iterate a non-iterable %s', async input => {
+    jest.spyOn(_globalScope.globalScope.Promise, 'resolve');
+    await expect(_globalScope.globalScope.Promise.race(input)).rejects.toThrow();
+    expect(_globalScope.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/cjs/common/wrap/wrap-raf.js

@@ -28,12 +28,12 @@ const RAF_NAME = 'requestAnimationFrame';
  */
 function wrapRaf(sharedEE) {
   const ee = scopedEE(sharedEE);
-  if (!_globalScope.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 (!_globalScope.isBrowserScope || wrapped[ee.debugId]++) return ee;
+  wrapped[ee.debugId] = 1; // otherwise, first feature to wrap RAF
+
   var wrapFn = (0, _wrapFunction.createWrapperWithEmitter)(ee);
   wrapFn.inPlace(window, [RAF_NAME], 'raf-');
   ee.on('raf-start', function (args) {

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

@@ -35,12 +35,12 @@ const TIMER_FNS = [SET_TIMEOUT, 'setImmediate', SET_INTERVAL, CLEAR_TIMEOUT, 'cl
 //eslint-disable-next-line
 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 = (0, _wrapFunction.createWrapperWithEmitter)(ee);
   wrapFn.inPlace(_globalScope.globalScope, TIMER_FNS.slice(0, 2), SET_TIMEOUT + DASH);
   wrapFn.inPlace(_globalScope.globalScope, TIMER_FNS.slice(2, 3), SET_INTERVAL + DASH);

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

@@ -34,12 +34,11 @@ const XHR_PROPS = ['open', 'send']; // these are the specific funcs being wrappe
 function wrapXhr(sharedEE) {
   var baseEE = sharedEE || _contextualEe.ee;
   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
 
   (0, _wrapEvents.wrapEvents)(baseEE); // wrap-events patches XMLHttpRequest.prototype.addEventListener for us
   var wrapFn = (0, _wrapFunction.createWrapperWithEmitter)(ee);

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

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

package/dist/cjs/features/ajax/instrument/index.js

@@ -30,7 +30,8 @@ var origRequest = _config.originals.REQ;
 var origXHR = _globalScope.globalScope.XMLHttpRequest;
 class Instrument extends _instrumentBase.InstrumentBase {
   static featureName = _constants.FEATURE_NAME;
-  constructor(agentIdentifier, aggregator, auto = true) {
+  constructor(agentIdentifier, aggregator) {
+    let auto = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
     super(agentIdentifier, aggregator, _constants.FEATURE_NAME, auto);
 
     // Very unlikely, but in case the existing XMLHttpRequest.prototype object on the page couldn't be wrapped.

package/dist/cjs/features/jserrors/aggregate/canonical-function-name.test.js

@@ -21,10 +21,11 @@ test.each([{
   input: '<anonymous>',
   expected: undefined,
   title: 'Return undefined ending is non-alphanumeric'
-}])('$title', ({
-  input,
-  expected
-}) => {
+}])('$title', _ref => {
+  let {
+    input,
+    expected
+  } = _ref;
   const result = (0, _canonicalFunctionName.canonicalFunctionName)(input);
   expect(result).toEqual(expected);
 });

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

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.computeStackTrace = computeStackTrace;
-var _reduce = require("../../../common/util/reduce");
 var _formatStackTrace = require("./format-stack-trace");
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
@@ -120,7 +119,7 @@ function computeStackTraceFromStackProp(ex) {
   if (!ex.stack) {
     return null;
   }
-  var errorInfo = (0, _reduce.reduce)(ex.stack.split('\n'), parseStackProp, {
+  var errorInfo = ex.stack.split('\n').reduce(parseStackProp, {
     frames: [],
     stackLines: [],
     wrapperSeen: false

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

@@ -146,7 +146,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({
@@ -172,7 +172,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({
@@ -193,7 +193,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({
@@ -232,7 +232,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: []
     }));
   });
@@ -248,7 +248,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: []
     }));
   });