@newrelic/browser-agent 0.1.230 → 1.232.0

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

@@ -0,0 +1,70 @@
+import * as encode from './encode';
+describe('query string encoding', () => {
+  test('escapes string components except safe characters', () => {
+    const input = 'Asdf:, :, /@$;';
+    const expected = 'Asdf:,%20:,%20/@$;';
+    expect(encode.qs(input)).toEqual(expected);
+  });
+  test('null and undefined value returns \'null\'', () => {
+    expect(encode.qs(null)).toEqual('null');
+    expect(encode.qs(undefined)).toEqual('null');
+  });
+});
+describe('fromArray encoding', () => {
+  test('cuts cleanly at end of byte', () => {
+    const input = ['a', 'b', 'c'];
+    const expected = 'ab';
+    expect(encode.fromArray(input, 2)).toEqual(expected);
+  });
+  test('fall back to largest whole chunk', () => {
+    const input = ['aa', 'bb', 'cc'];
+    const expected = 'aabb';
+    expect(encode.fromArray(input, 5)).toEqual(expected);
+  });
+});
+describe('object encoding', () => {
+  test('cuts cleanly at end of byte', () => {
+    const input = {
+      foo: [1, 2, 3]
+    };
+    const expected = '&foo=%5B1,2%5D';
+    expect(encode.obj(input, 12)).toEqual(expected);
+  });
+  test('fall back to largest whole chunk', () => {
+    const input = {
+      bar: ['a', 'b', 'c']
+    };
+    const expected = '&bar=%5B%22a%22,%22b%22%5D';
+    expect(encode.obj(input, 30)).toEqual(expected);
+  });
+  test('handles circular objects', () => {
+    const circular = {};
+    circular.circular = circular;
+    const input = {
+      bar: ['a', circular, 'c']
+    };
+    const expected = '&bar=%5B%22a%22,%7B%7D,%22c%22%5D';
+    expect(encode.obj(input, 1000)).toEqual(expected);
+  });
+  test('handles circular arrays', () => {
+    const circular = [];
+    circular.push(circular);
+    const input = {
+      bar: ['a', circular, 'c']
+    };
+    const expected = '&bar=%5B%22a%22,%5Bnull%5D,%22c%22%5D';
+    expect(encode.obj(input, 1000)).toEqual(expected);
+  });
+});
+describe('encode key value pairs as query params', () => {
+  test('ignores input when value is null or undefined', () => {
+    expect(encode.param('foo', null)).toEqual('');
+    expect(encode.param('foo', undefined)).toEqual('');
+  });
+  test('encodes key value pair correctly', () => {
+    expect(encode.param('foo', 'bar')).toEqual('&foo=bar');
+  });
+  test('ignores input when value is not a string', () => {
+    expect(encode.param('foo', {})).toEqual('');
+  });
+});

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

@@ -3,6 +3,10 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+/**
+ * This method only exists to support testing in JIL and can be removed once tests are migrated to WDIO.
+ * @returns global scope location
+ */
 export function getLocation() {
   return '' + location;
 }

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

@@ -0,0 +1,11 @@
+import { faker } from '@faker-js/faker';
+import { getLocation } from './location';
+test('should always return a string', () => {
+  jest.spyOn(window, 'location', 'get').mockReturnValue({});
+  expect(typeof getLocation()).toEqual('string');
+});
+test('should return window location', () => {
+  const expected = faker.internet.url();
+  jest.spyOn(window, 'location', 'get').mockReturnValue(expected);
+  expect(getLocation()).toEqual(expected);
+});

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/data-size.js

@@ -4,6 +4,13 @@
  */
 
 import { stringify } from './stringify';
+
+/**
+ * Returns the size of the provided data. Designed for measuring XHR responses.
+ *
+ * @param {*} data - The data to be measured.
+ * @returns {(number|undefined)} - The size of the data or undefined if size cannot be determined.
+ */
 export function dataSize(data) {
   if (typeof data === 'string' && data.length) return data.length;
   if (typeof data !== 'object') return undefined;

package/dist/esm/common/util/data-size.test.js

@@ -0,0 +1,45 @@
+import { dataSize } from './data-size';
+describe('dataSize', () => {
+  test('returns length of string', () => {
+    const str = 'Hello, world!';
+    expect(dataSize(str)).toBe(str.length);
+  });
+  test('returns undefined for non-object, number, or empty string', () => {
+    expect(dataSize(Infinity)).toBeUndefined();
+    expect(dataSize(12345)).toBeUndefined(); // might not actually be by design, but this is how it works today
+    expect(dataSize('')).toBeUndefined();
+  });
+  test('returns byte length of ArrayBuffer object', () => {
+    const buffer = new ArrayBuffer(8);
+    expect(dataSize(buffer)).toBe(8);
+  });
+  test('returns size of Blob object', () => {
+    const blob = new Blob(['Hello, world!'], {
+      type: 'text/plain'
+    });
+    expect(dataSize(blob)).toBe(blob.size);
+  });
+  test('returns undefined for FormData object', () => {
+    const formData = new FormData();
+    expect(dataSize(formData)).toBeUndefined();
+  });
+  test('returns length of JSON string representation of object', () => {
+    const obj = {
+      str: 'Hello, world!',
+      num: 12345,
+      nestedObj: {
+        arr: [1, 2, 3]
+      }
+    };
+    const expectedSize = JSON.stringify(obj).length;
+    expect(dataSize(obj)).toBe(expectedSize);
+  });
+  test('returns undefined for object with toJSON method that throws an error', () => {
+    const obj = {
+      toJSON: () => {
+        throw new Error('Error in toJSON');
+      }
+    };
+    expect(dataSize(obj)).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,66 @@
+/**
+ * Reduce the invocation of the supplied function so that it is only invoked
+ * once within a given timeout.
+ *
+ * If `wait` is `0`, the function will be invoked during the next tick.
+ * If `options.leading` is false or not provided, the function will be invoked
+ * N milliseconds after the last invocation of the returned function where
+ * N is the `timeout` value.
+ * If `options.leading` is true, the function will be invoked immediately upon
+ * the first invocation of the returned function and not again for N milliseconds
+ * where N is the `timeout` value.
+ * @param {function} func Function whose invocation should be limited so it is only invoked
+ * once within a given timeout period.
+ * @param {number} timeout Time in milliseconds that the function should only be invoked
+ * once within.
+ * @param {object} options Debounce options
+ * @param {boolean} options.leading Forces the function to be invoked on the first
+ * invocation of the returned function instead of N milliseconds after the last
+ * invocation.
+ * @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] : {};
+  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];
+    }
+    if (leading && timer === undefined) {
+      func.apply(_this, args);
+      timer = setTimeout(() => timer = clearTimeout(timer), timeout);
+    }
+    if (!leading) {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        func.apply(_this, args);
+      }, timeout);
+    }
+  };
+}
+
+/**
+ * Reduce the invocation of the supplied function so that it is only invoked
+ * once.
+ * @param {function} func Function whose invocation should be limited so it is only invoked
+ * once.
+ * @returns {function} A wrapping function that will ensure the provided function
+ * is invoked only once.
+ */
+export function single(func) {
+  var _this2 = this;
+  let called = false;
+  return function () {
+    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);
+    }
+  };
+}

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

@@ -0,0 +1,47 @@
+import { debounce, single } from './invoke';
+jest.useFakeTimers();
+describe('debounce', () => {
+  test('should run the supplied function after 100ms', () => {
+    let mockCallback = jest.fn();
+    let debouncedMethod = debounce(mockCallback, 100);
+    execFnTimes(debouncedMethod, 100);
+    expect(mockCallback).not.toHaveBeenCalled();
+    jest.advanceTimersByTime(1000);
+    expect(mockCallback).toHaveBeenCalledTimes(1);
+  });
+  test('should rerun the supplied function when called again after 100ms', () => {
+    let mockCallback = jest.fn();
+    let debouncedMethod = debounce(mockCallback, 100);
+    execFnTimes(debouncedMethod, 100);
+    jest.advanceTimersByTime(200);
+    execFnTimes(debouncedMethod, 100);
+    jest.advanceTimersByTime(2000);
+    expect(mockCallback).toHaveBeenCalledTimes(2);
+  });
+  test('should run the supplied function on the first event and debounce subsequent events', () => {
+    let mockCallback = jest.fn();
+    let debouncedMethod = debounce(mockCallback, 100, {
+      leading: true
+    });
+    execFnTimes(debouncedMethod, 100);
+    expect(mockCallback).toHaveBeenCalledTimes(1);
+    jest.advanceTimersByTime(200);
+    expect(mockCallback).toHaveBeenCalledTimes(1);
+    execFnTimes(debouncedMethod, 100);
+    jest.advanceTimersByTime(200);
+    expect(mockCallback).toHaveBeenCalledTimes(2);
+  });
+});
+describe('single', () => {
+  test('should run the supplied function only once', () => {
+    let mockCallback = jest.fn();
+    let singleMethod = single(mockCallback, 100);
+    execFnTimes(singleMethod, 100);
+    expect(mockCallback).toHaveBeenCalledTimes(1);
+  });
+});
+function execFnTimes(fn, count) {
+  for (let i = 0; i < count; i++) {
+    fn();
+  }
+}

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,16 +1,12 @@
 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:\/\/(.*)/,
   replacement: 'file://OBFUSCATED'
 };
 export class Obfuscator extends SharedContext {
-  constructor(parent) {
-    super(parent); // gets any allowed properties from the parent and stores them in `sharedContext`
-  }
-
   shouldObfuscate() {
     return getRules(this.sharedContext.agentIdentifier).length > 0;
   }
@@ -37,7 +33,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

@@ -12,12 +12,15 @@ import { documentAddEventListener } from '../event-listener/event-listener-opts'
  */
 export function subscribeToVisibilityChange(cb) {
   let toHiddenOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-  documentAddEventListener('visibilitychange', handleVisibilityChange);
+  let capture = arguments.length > 2 ? arguments[2] : undefined;
+  let abortSignal = arguments.length > 3 ? arguments[3] : undefined;
+  documentAddEventListener('visibilitychange', handleVisibilityChange, capture, abortSignal);
   return;
   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);