@newrelic/browser-agent 0.1.229 → 0.1.230

package/README.md

@@ -131,8 +131,47 @@ import { SessionTrace } from '@newrelic/browser-agent/features/session_trace';
 import { Spa } from '@newrelic/browser-agent/features/spa';
 ```
 
+## Supported Browsers
+
+Our supported browser list can be accessed [here](https://docs.newrelic.com/docs/browser/new-relic-browser/getting-started/compatibility-requirements-browser-monitoring/#browser-types).
+
+If you desire more control over how the agent is built, our package also includes the source code. The source code is written to target the latest ECMAScript standards (ES2022). Please note that if you import the browser agent source code instead of the transpiled distribution code, you may need to alter your project's build system to apply transformations to the browser agent source code. Without these transforms, the code produced by your project's build system may not be compatible with your desired target browsers. Below is an example of how to import the source code.
+
+```javascript
+// Note the /src/ in the import paths below
+import { Agent } from '@newrelic/browser-agent/src/loaders/agent'
+import { Metrics } from '@newrelic/browser-agent/src/features/metrics'
+import { PageViewEvent } from '@newrelic/browser-agent/src/features/page_view_event'
+import { PageViewTiming } from '@newrelic/browser-agent/src/features/page_view_timing'
+
+const options = {
+  info: { ... },
+  loader_config: { ... },
+  init: { ... }
+}
+
+new Agent({
+  ...options,
+  features: [
+    Metrics,
+    PageViewEvent,
+    PageViewTiming
+  ]
+})
+```
+
+Neither the browser agent development team nor the New Relic support teams can support the numerous build systems that exist in the JavaScript ecosystem. If you run into issues, you may be asked to revert to importing from the transpiled distribution code.
+
+**DON'T** mix imports between the browser agent source code and transpiled distribution code. The below will break.
+
+```javascript
+// THIS IS BAD - do not do this
+import { Agent } from '@newrelic/browser-agent/loaders/agent'
+import { Metrics } from '@newrelic/browser-agent/src/features/metrics'
+```
+
 ## License
 
 The Browser agent is licensed under the [Apache 2.0](http://apache.org/licenses/LICENSE-2.0.txt) License.
 
-The Browser agent also uses source code from third-party libraries. Full details on which libraries are used and the terms under which they are licensed can be found in the [third-party notices document](THIRD_PARTY_NOTICES.md).
+The Browser agent also uses source code from third-party libraries. Full details on which libraries are used and the terms under which they are licensed can be found in the [third-party notices document](THIRD_PARTY_NOTICES.md).

package/dist/cjs/common/config/state/configurable.js

@@ -12,7 +12,8 @@ class Configurable {
       if (!obj || typeof obj !== 'object') return (0, _console.warn)('New setting a Configurable requires an object as input');
       if (!model || typeof model !== 'object') return (0, _console.warn)('Setting a Configurable requires a model to set its initial properties');
       Object.assign(this, model);
-      Object.entries(obj).forEach(([key, value]) => {
+      Object.entries(obj).forEach(_ref => {
+        let [key, value] = _ref;
         const frozenAttrs = (0, _featureDependencies.getFrozenAttributes)(key);
         if (frozenAttrs.length && value && typeof value === 'object') {
           frozenAttrs.forEach(attr => {

package/dist/cjs/common/config/state/runtime.js

@@ -17,6 +17,7 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj &&
 const model = agentId => {
   return {
     buildEnv: _environmentVariables.BUILD_ENV,
+    bytesSent: {},
     customTransaction: undefined,
     disabled: false,
     distMethod: _environmentVariables.DIST_METHOD,

package/dist/cjs/common/constants/environment-variables.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.VERSION = exports.DIST_METHOD = exports.BUILD_ENV = void 0;
 // Webpack and NPM builds define `process.env.BUILD_VERSION` at build time based on variables supplied at build time.
 // VERSION as defined here ends up decorating: agent runtime configuration, harvest, and supportability metrics.
-const VERSION = typeof "0.1.229" !== 'undefined' && "0.1.229" || '';
+const VERSION = typeof "0.1.230" !== 'undefined' && "0.1.230" || '';
 
 // process.env.BUILD_ENV is replaced during webpack -or- npm build with environment vars supplied at build time
 // LOCAL, PROD, DEV, etc

package/dist/cjs/common/context/shared-context.js

@@ -14,7 +14,8 @@ class SharedContext {
       if (typeof context !== 'object') return (0, _console.warn)('shared context requires an object as input');
       this.sharedContext = {};
       Object.assign(this.sharedContext, model);
-      Object.entries(context).forEach(([key, value]) => {
+      Object.entries(context).forEach(_ref => {
+        let [key, value] = _ref;
         if (Object.keys(model).includes(key)) this.sharedContext[key] = value;
       });
     } catch (err) {

package/dist/cjs/common/drain/drain.js

@@ -51,7 +51,9 @@ function curateRegistry(agentIdentifier) {
  * @param {string} agentIdentifier - A unique 16 character ID corresponding to an instantiated agent.
  * @param {string} featureName - A named group into which the feature's buffered events are bucketed.
  */
-function drain(agentIdentifier = '', featureName = 'feature') {
+function drain() {
+  let agentIdentifier = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  let featureName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'feature';
   curateRegistry(agentIdentifier);
 
   // If the feature for the specified agent is not in the registry, that means the instrument file was bypassed.
@@ -65,9 +67,13 @@ function drain(agentIdentifier = '', featureName = 'feature') {
   // Only when the event-groups for all features are ready to drain (staged) do we execute the drain. This has the effect
   // that the last feature to call drain triggers drain for all features.
   const items = Array.from(registry[agentIdentifier]);
-  if (items.every(([key, values]) => values.staged)) {
+  if (items.every(_ref => {
+    let [key, values] = _ref;
+    return values.staged;
+  })) {
     items.sort((a, b) => a[1].priority - b[1].priority);
-    items.forEach(([group]) => {
+    items.forEach(_ref2 => {
+      let [group] = _ref2;
       drainGroup(group);
     });
   }

package/dist/cjs/common/event-listener/event-listener-opts.js

@@ -37,10 +37,12 @@ function eventListenerOpts(useCapture, abortSignal) {
 }
 
 /** Do not use this within the worker context. */
-function windowAddEventListener(event, listener, capture = false) {
+function windowAddEventListener(event, listener) {
+  let capture = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
   window.addEventListener(event, listener, eventListenerOpts(capture));
 }
 /** Do not use this within the worker context. */
-function documentAddEventListener(event, listener, capture = false) {
+function documentAddEventListener(event, listener) {
+  let capture = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
   document.addEventListener(event, listener, eventListenerOpts(capture));
 }

package/dist/cjs/common/harvest/harvest-scheduler.js

@@ -43,7 +43,8 @@ class HarvestScheduler extends _sharedContext.SharedContext {
     this.started = true;
     this.scheduleHarvest(initialDelay != null ? initialDelay : this.interval);
   }
-  stopTimer(permanently = false) {
+  stopTimer() {
+    let permanently = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
     this.aborted = permanently; // stopping permanently is same as aborting, but this function also cleans up the setTimeout loop
     this.started = false;
     if (this.timeoutHandle) {

package/dist/cjs/common/harvest/harvest.js

@@ -71,6 +71,7 @@ class Harvest extends _sharedContext.SharedContext {
   * @param {bool} opts.unload - Specify whether the call is a final harvest during page unload.
   */
   send(endpoint, singlePayload, opts, submitMethod, cbFinished) {
+    var _this = this;
     var makeBody = createAccumulator();
     var makeQueryString = createAccumulator();
     if (singlePayload.body) (0, _mapOwn.mapOwn)(singlePayload.body, makeBody);
@@ -79,11 +80,18 @@ class Harvest extends _sharedContext.SharedContext {
       body: makeBody(),
       qs: makeQueryString()
     };
-    var caller = this.obfuscator.shouldObfuscate() ? (...args) => this.obfuscateAndSend(...args) : (...args) => this._send(...args);
+    var caller = this.obfuscator.shouldObfuscate() ? function () {
+      return _this.obfuscateAndSend(...arguments);
+    } : function () {
+      return _this._send(...arguments);
+    };
     return caller(endpoint, payload, opts, submitMethod, cbFinished);
   }
   obfuscateAndSend(endpoint, payload, opts, submitMethod, cbFinished) {
-    (0, _traverse.applyFnToProps)(payload, (...args) => this.obfuscator.obfuscateString(...args), 'string', ['e']);
+    var _this2 = this;
+    (0, _traverse.applyFnToProps)(payload, function () {
+      return _this2.obfuscator.obfuscateString(...arguments);
+    }, 'string', ['e']);
     return this._send(endpoint, payload, opts, submitMethod, cbFinished);
   }
   _send(endpoint, payload, opts, submitMethod, cbFinished) {
@@ -117,6 +125,9 @@ class Harvest extends _sharedContext.SharedContext {
       fullUrl = url + (0, _encode.obj)(payload.body, agentRuntime.maxBytes);
     }
 
+    // Get bytes harvested per endpoint as a supportability metric. See metrics aggregator (on unload).
+    agentRuntime.bytesSent[endpoint] = (agentRuntime.bytesSent[endpoint] || 0) + body?.length || 0;
+
     /* Since workers don't support sendBeacon right now, or Image(), they can only use XHR method.
         Because they still do permit synch XHR, the idea is that at final harvest time (worker is closing),
         we just make a BLOCKING request--trivial impact--with the remaining data as a temp fill-in for sendBeacon. */

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

@@ -11,7 +11,7 @@ exports.warn = warn;
  * @returns
  */
 function warn(message, secondary) {
-  if (!console || !console.warn || typeof console.warn !== 'function') return;
+  if (typeof console.warn !== 'function') return;
   console.warn(`New Relic: ${message}`);
   if (secondary) console.warn(secondary);
 }

package/dist/cjs/common/util/map-own.js

@@ -3,22 +3,29 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.mapOwn = mapOwn;
+exports.mapOwn = void 0;
 /*
  * Copyright 2020 New Relic Corporation. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
-var has = Object.prototype.hasOwnProperty;
-function mapOwn(obj, fn) {
-  var results = [];
-  var key = '';
-  var i = 0;
-  for (key in obj) {
-    if (has.call(obj, key)) {
-      results[i] = fn(key, obj[key]);
-      i += 1;
-    }
-  }
-  return results;
-}
+/**
+ * @typedef {function} MapOwnCallback
+ * @param {string} key Object key
+ * @param {any} value Object value
+ * @returns {any}
+ */
+
+/**
+ * Iterates the own enumerable properties of an object passing the key and value pair to a given
+ * callback function.
+ * @param {object} obj Input object to iterate over. If null or undefined, an empty array will be returned.
+ * @param {MapOwnCallback} fn A callback function called for each property. The callback should take the key
+ * and value from the object iteration and return some value.
+ * @returns {any[]} An array of values returned by the callback function.
+ */
+const mapOwn = (obj, fn) => Object.entries(obj || {}).map(_ref => {
+  let [key, value] = _ref;
+  return fn(key, value);
+});
+exports.mapOwn = mapOwn;

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

@@ -0,0 +1,49 @@
+"use strict";
+
+var _mapOwn = require("./map-own");
+test('enumerates the object properties', () => {
+  const callback = jest.fn();
+  const input = {
+    foo: 'bar'
+  };
+  (0, _mapOwn.mapOwn)(input, callback);
+  expect(callback).toHaveBeenCalledWith('foo', 'bar');
+});
+test('return array of results from callback invocation', () => {
+  const callback = jest.fn((key, value) => `${key}:${value}`);
+  const input = {
+    foo: 'bar',
+    biz: 'baz'
+  };
+  const result = (0, _mapOwn.mapOwn)(input, callback);
+  expect(result.length).toEqual(2);
+  expect(result).toContain('foo:bar');
+  expect(result).toContain('biz:baz');
+});
+test('does not iterate symbol properties', () => {
+  const callback = jest.fn((key, value) => `${key}:${value}`);
+  const input = {
+    foo: 'bar',
+    [Symbol.for('biz')]: 'baz'
+  };
+  const result = (0, _mapOwn.mapOwn)(input, callback);
+  expect(result.length).toEqual(1);
+});
+test('does not iterate inherited properties', () => {
+  function F() {}
+  F.prototype = {
+    biz: 'baz'
+  };
+  const callback = jest.fn((key, value) => `${key}:${value}`);
+  const input = new F();
+  input.foo = 'bar';
+  const result = (0, _mapOwn.mapOwn)(input, callback);
+  expect(result.length).toEqual(1);
+});
+test.each([null, undefined])('returns empty array when passed object is null or undefined', input => {
+  const callback = jest.fn();
+  const result = (0, _mapOwn.mapOwn)(input, callback);
+  expect(Array.isArray(result)).toEqual(true);
+  expect(result.length).toEqual(0);
+  expect(callback).toHaveBeenCalledTimes(0);
+});

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

@@ -53,7 +53,8 @@ submitData.xhrGet = function xhrGet(url) {
  * @param {boolean} sync
  * @returns {XMLHttpRequest}
  */
-submitData.xhr = function xhr(url, body, sync, method = 'POST') {
+submitData.xhr = function xhr(url, body, sync) {
+  let method = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'POST';
   var request = new XMLHttpRequest();
   request.open(method, url, !sync);
   try {
@@ -94,6 +95,13 @@ submitData.img = function img(url) {
 submitData.beacon = function (url, body) {
   // 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
-  const send = window.navigator.sendBeacon.bind(navigator);
-  return send(url, body);
+  const send = window.navigator.sendBeacon.bind(window.navigator);
+  try {
+    return send(url, body);
+  } catch (err) {
+    // if sendBeacon still trys to throw an illegal invocation error,
+    // we can catch here and return.  The harvest module will fallback to use
+    // .img to try to send
+    return false;
+  }
 };

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

@@ -15,7 +15,8 @@ var _eventListenerOpts = require("../event-listener/event-listener-opts");
  * @param {boolean} [toHiddenOnly=false] - only execute the 'cb' when the vis is changing to the hidden state; no arg is passed to 'cb' if used
  * @returns void
  */
-function subscribeToVisibilityChange(cb, toHiddenOnly = false) {
+function subscribeToVisibilityChange(cb) {
+  let toHiddenOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
   (0, _eventListenerOpts.documentAddEventListener)('visibilitychange', handleVisibilityChange);
   return;
   function handleVisibilityChange() {

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

@@ -3,6 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+Object.defineProperty(exports, "wrapConsole", {
+  enumerable: true,
+  get: function () {
+    return _wrapConsole.wrapConsole;
+  }
+});
 Object.defineProperty(exports, "wrapEvents", {
   enumerable: true,
   get: function () {
@@ -57,12 +63,13 @@ Object.defineProperty(exports, "wrapXhr", {
     return _wrapXhr.wrapXhr;
   }
 });
+var _wrapConsole = require("./wrap-console");
+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-console.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.scopedEE = scopedEE;
+exports.wrapConsole = wrapConsole;
+var _contextualEe = require("../event-emitter/contextual-ee");
+var _wrapFunction = require("./wrap-function");
+var _globalScope = require("../util/global-scope");
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @file Wraps `debug`, `error`, `info`, `log`, `trace, and `warn` methods of the global `console` object for instrumentation.
+ * This module is used by: metrics.
+ */
+
+const wrapped = {};
+const CONSOLE_METHODS = ['debug', 'error', 'info', 'log', 'trace', 'warn'];
+
+/**
+ * Wraps the `debug`, `error`, `info`, `log`, `trace, and `warn` methods of global `console` object and returns a
+ * corresponding event emitter scoped to the console object.
+ * @param {Object} sharedEE - The shared event emitter on which a new scoped event emitter will be based.
+ * @returns {Object} Scoped event emitter with a debug ID of `console`.
+ */
+function wrapConsole(sharedEE) {
+  const ee = scopedEE(sharedEE);
+
+  // We want to wrap console once and only once for each agent instance (`ee.debugId`).
+  if (wrapped[ee.debugId]) {
+    return ee;
+  }
+  wrapped[ee.debugId] = true;
+  var functionWrapper = (0, _wrapFunction.createWrapperWithEmitter)(ee);
+  // Because the console object exists once on the global scope, we don't need to wrap the prototype's methods.
+  // We use the global scope instead of window to accomodate service workers.
+  // The leading hyphen on '-console-' tells `inPlace` to prefix emitted event names with the method name too.
+  functionWrapper.inPlace(_globalScope.globalScope.console, CONSOLE_METHODS, '-console-');
+  return ee;
+}
+
+/**
+ * Returns an event emitter scoped specifically for the `console` context. This scoping is a remnant from when all the
+ * features shared the same group in the event, to isolate events between features. It will likely be revisited.
+ * @param {Object} sharedEE - Optional event emitter on which to base the scoped emitter.
+ *    Uses `ee` on the global scope if undefined).
+ * @returns {Object} Scoped event emitter with a debug ID of 'console'.
+ */
+function scopedEE(sharedEE) {
+  return (sharedEE || _contextualEe.ee).get('console');
+}

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

@@ -85,11 +85,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

@@ -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-promise.js

@@ -111,10 +111,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/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);
 });