@newrelic/browser-agent 0.1.229 → 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

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

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

@@ -3,16 +3,22 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-var has = Object.prototype.hasOwnProperty;
-export 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.
+ */
+export const mapOwn = (obj, fn) => Object.entries(obj || {}).map(_ref => {
+  let [key, value] = _ref;
+  return fn(key, value);
+});

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

@@ -0,0 +1,47 @@
+import { mapOwn } from './map-own';
+test('enumerates the object properties', () => {
+  const callback = jest.fn();
+  const input = {
+    foo: 'bar'
+  };
+  mapOwn(input, callback);
+  expect(callback).toHaveBeenCalledWith('foo', 'bar');
+});
+test('return array of results from callback invocation', () => {
+  const callback = jest.fn((key, value) => "".concat(key, ":").concat(value));
+  const input = {
+    foo: 'bar',
+    biz: 'baz'
+  };
+  const result = 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) => "".concat(key, ":").concat(value));
+  const input = {
+    foo: 'bar',
+    [Symbol.for('biz')]: 'baz'
+  };
+  const result = 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) => "".concat(key, ":").concat(value));
+  const input = new F();
+  input.foo = 'bar';
+  const result = 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 = mapOwn(input, callback);
+  expect(Array.isArray(result)).toEqual(true);
+  expect(result.length).toEqual(0);
+  expect(callback).toHaveBeenCalledTimes(0);
+});

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

@@ -45,7 +45,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 {
@@ -86,6 +87,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/esm/common/window/page-visibility.js

@@ -10,13 +10,15 @@ import { documentAddEventListener } from '../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
  */
-export function subscribeToVisibilityChange(cb, toHiddenOnly = false) {
+export function subscribeToVisibilityChange(cb) {
+  let toHiddenOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
   documentAddEventListener('visibilitychange', handleVisibilityChange);
   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/window/session-storage.js

@@ -6,31 +6,72 @@
  * @environment Browser script
  */
 import { generateRandomHexString } from '../ids/unique-id';
-import { isBrowserScope } from '../util/global-scope';
-export { getCurrentSessionIdOrMakeNew };
-const SESS_ID = 'NRBA_SESSION_ID'; // prevents potential key collisions in session storage
+const AGENT_PREFIX = 'NRBA/';
 
 /**
- * @returns {string} This tab|window's session identifier, or a new ID if not found in storage
+ * @param {string} key
+ * @param {string} value
+ * @returns true, if item was set successfully. false, if storage is full or setItem threw an exception.
  */
-function getCurrentSessionIdOrMakeNew() {
-  if (!isBrowserScope) {
-    return null;
+export 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);
+}
+export 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
+ */
+export function getCurrentSessionIdOrMakeNew() {
   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 = 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.
+ */
+export 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/esm/common/wrap/index.js

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

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

@@ -8,7 +8,7 @@
  * It is also called by -> wrapXhr <-, so see "wrap-xhr.js" for features that use this indirectly.
  */
 import { ee as baseEE } from '../event-emitter/contextual-ee';
-import { createWrapperWithEmitter as wfn, unwrapFunction } from './wrap-function';
+import { createWrapperWithEmitter as wfn } from './wrap-function';
 import { getOrSet } from '../util/get-or-set';
 import { globalScope, isBrowserScope } from '../util/global-scope';
 const wrapped = {};
@@ -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);
   }
@@ -77,11 +74,14 @@ export 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/esm/common/wrap/wrap-fetch.js

@@ -9,7 +9,7 @@
 import { ee as baseEE } from '../event-emitter/contextual-ee';
 import slice from 'lodash._slice';
 import { globalScope } from '../util/global-scope';
-import { flag, unwrapFunction } from './wrap-function';
+import { flag } from './wrap-function';
 var prefix = 'fetch-';
 var bodyPrefix = prefix + 'body-';
 var bodyMethods = ['arrayBuffer', 'blob', 'json', 'text', 'formData'];
@@ -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);
@@ -86,10 +86,8 @@ export function wrapFetch(sharedEE) {
           throw err;
         });
       };
-      target[name][flag] = fn; // track original similar to in wrap-function.js, so that they can be unwrapped with ease
     }
   }
-
   return ee;
 }
 

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

@@ -103,7 +103,8 @@ export 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
@@ -111,8 +112,7 @@ export 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;
@@ -121,8 +121,7 @@ export 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);
     }
@@ -242,16 +241,4 @@ export function wrapFunction(fn, wrapper) {
 export 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.
- */
-export 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/esm/common/wrap/wrap-history.js

@@ -7,7 +7,7 @@
  * This module is used by: session_trace, spa.
  */
 import { ee as globalEE } from '../event-emitter/contextual-ee';
-import { createWrapperWithEmitter as wfn, unwrapFunction } from './wrap-function';
+import { createWrapperWithEmitter as wfn } from './wrap-function';
 import { isBrowserScope } from '../util/global-scope';
 const wrapped = {};
 const HISTORY_FNS = ['pushState', 'replaceState'];
@@ -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

@@ -9,7 +9,7 @@
 
 import { eventListenerOpts } from '../event-listener/event-listener-opts';
 import { ee as baseEE } from '../event-emitter/contextual-ee';
-import { createWrapperWithEmitter as wfn, unwrapFunction } from './wrap-function';
+import { createWrapperWithEmitter as wfn } from './wrap-function';
 import { isBrowserScope } from '../util/global-scope';
 const wrapped = {};
 const domInsertMethods = ['appendChild', 'insertBefore', 'replaceChild'];
@@ -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) {