@newrelic/browser-agent 1.232.0 → 1.233.0

package/src/features/session_trace/instrument/index.js

@@ -4,8 +4,6 @@
  */
 import { handle } from '../../../common/event-emitter/handle'
 import { wrapHistory, wrapEvents, wrapTimer, wrapRaf } from '../../../common/wrap'
-import { supportsPerformanceObserver } from '../../../common/window/supports-performance-observer'
-import { eventListenerOpts } from '../../../common/event-listener/event-listener-opts'
 import { now } from '../../../common/timing/now'
 import { InstrumentBase } from '../../utils/instrument-base'
 import * as CONSTANTS from '../constants'
@@ -13,10 +11,8 @@ import { FEATURE_NAMES } from '../../../loaders/features/features'
 import { isBrowserScope } from '../../../common/util/global-scope'
 
 const {
-  BST_RESOURCE, BST_TIMER, END, FEATURE_NAME, FN_END, FN_START, ADD_EVENT_LISTENER,
-  PUSH_STATE, RESOURCE, RESOURCE_TIMING_BUFFER_FULL, START, ORIG_EVENT: origEvent
+  BST_RESOURCE, RESOURCE, BST_TIMER, START, END, FEATURE_NAME, FN_END, FN_START, PUSH_STATE
 } = CONSTANTS
-const CRT = 'clearResourceTimings'
 
 export class Instrument extends InstrumentBase {
   static featureName = FEATURE_NAME
@@ -28,29 +24,21 @@ export class Instrument extends InstrumentBase {
     this.timerEE = wrapTimer(thisInstrumentEE)
     this.rafEE = wrapRaf(thisInstrumentEE)
     wrapHistory(thisInstrumentEE)
-    wrapEvents(thisInstrumentEE)
+    this.eventsEE = wrapEvents(thisInstrumentEE)
 
-    thisInstrumentEE.on(FN_START, function (args, target) {
-      var evt = args[0]
-      if (evt instanceof origEvent) {
-        this.bstStart = now()
-      }
+    this.eventsEE.on(FN_START, function (args, target) {
+      this.bstStart = now()
     })
-
-    thisInstrumentEE.on(FN_END, function (args, target) {
-      var evt = args[0]
-      if (evt instanceof origEvent) {
-        // ISSUE: when target is XMLHttpRequest, nr@context should have params so we can calculate event origin
-        // When ajax is disabled, this may fail without making ajax a dependency of session_trace
-        handle('bst', [evt, target, this.bstStart, now()], undefined, FEATURE_NAMES.sessionTrace, thisInstrumentEE)
-      }
+    this.eventsEE.on(FN_END, function (args, target) {
+      // ISSUE: when target is XMLHttpRequest, nr@context should have params so we can calculate event origin
+      // When ajax is disabled, this may fail without making ajax a dependency of session_trace
+      handle('bst', [args[0], target, this.bstStart, now()], undefined, FEATURE_NAMES.sessionTrace, thisInstrumentEE)
     })
 
     this.timerEE.on(FN_START, function (args, obj, type) {
       this.bstStart = now()
       this.bstType = type
     })
-
     this.timerEE.on(FN_END, function (args, target) {
       handle(BST_TIMER, [target, this.bstStart, now(), this.bstType], undefined, FEATURE_NAMES.sessionTrace, thisInstrumentEE)
     })
@@ -58,7 +46,6 @@ export class Instrument extends InstrumentBase {
     this.rafEE.on(FN_START, function () {
       this.bstStart = now()
     })
-
     this.rafEE.on(FN_END, function (args, target) {
       handle(BST_TIMER, [target, this.bstStart, now(), 'requestAnimationFrame'], undefined, FEATURE_NAMES.sessionTrace, thisInstrumentEE)
     })
@@ -71,57 +58,18 @@ export class Instrument extends InstrumentBase {
       handle('bstHist', [location.pathname + location.hash, this.startPath, this.time], undefined, FEATURE_NAMES.sessionTrace, thisInstrumentEE)
     })
 
-    if (supportsPerformanceObserver()) {
-      // capture initial resources, in case our observer missed anything
-      handle(BST_RESOURCE, [window.performance.getEntriesByType('resource')], undefined, FEATURE_NAMES.sessionTrace, thisInstrumentEE)
-
-      observeResourceTimings()
-    } else {
-      // collect resource timings once when buffer is full
-      if (window.performance[CRT] && window.performance[ADD_EVENT_LISTENER]) {
-        window.performance.addEventListener(RESOURCE_TIMING_BUFFER_FULL, this.onResourceTimingBufferFull, eventListenerOpts(false))
-      }
-    }
-
-    function observeResourceTimings () {
-      var observer = new PerformanceObserver((list, observer) => { // eslint-disable-line no-undef
-        var entries = list.getEntries()
-
+    let observer
+    try {
+      // Capture initial resources and watch for future ones. Don't defer this given there's a default cap on the number of buffered entries.
+      observer = new PerformanceObserver((list) => { // eslint-disable-line no-undef
+        const entries = list.getEntries()
         handle(BST_RESOURCE, [entries], undefined, FEATURE_NAMES.sessionTrace, thisInstrumentEE)
       })
-
-      try {
-        observer.observe({ entryTypes: ['resource'] })
-      } catch (e) {
-        // do nothing
-      }
+      observer.observe({ type: RESOURCE, buffered: true })
+    } catch (e) {
+      // Per NEWRELIC-8525, we don't have a fallback for capturing resources for older versions that don't support PO at this time.
     }
 
-    document.addEventListener('scroll', this.noOp, eventListenerOpts(false))
-    document.addEventListener('keypress', this.noOp, eventListenerOpts(false))
-    document.addEventListener('click', this.noOp, eventListenerOpts(false))
-
-    this.abortHandler = this.#abort
-    this.importAggregator()
-  }
-
-  /** Restoration and resource release tasks to be done if Session trace loader is being aborted. Unwind changes to globals. */
-  #abort () {
-    window.performance.removeEventListener(RESOURCE_TIMING_BUFFER_FULL, this.onResourceTimingBufferFull, false)
-    // The doc interaction noOp listeners are harmless--cannot buffer data into EE.
-    this.abortHandler = undefined // weakly allow this abort op to run only once
-  }
-
-  noOp (e) { /* no-op */ }
-
-  onResourceTimingBufferFull (evt) {
-    handle(BST_RESOURCE, [window.performance.getEntriesByType(RESOURCE)], undefined, FEATURE_NAMES.sessionTrace, this.ee)
-
-    // stop recording once buffer is full
-    if (window.performance[CRT]) {
-      try {
-        window.performance.removeEventListener(RESOURCE_TIMING_BUFFER_FULL, this.onResourceTimingBufferFull, false)
-      } catch (e) {}
-    }
+    this.importAggregator({ resourceObserver: observer })
   }
 }

package/src/features/spa/aggregate/index.js

@@ -19,13 +19,13 @@ import { ee } from '../../../common/event-emitter/contextual-ee'
 import * as CONSTANTS from '../constants'
 import { drain } from '../../../common/drain/drain'
 import { FEATURE_NAMES } from '../../../loaders/features/features'
-import { FeatureBase } from '../../utils/feature-base'
+import { AggregateBase } from '../../utils/aggregate-base'
 
 const {
   FEATURE_NAME, INTERACTION_EVENTS, MAX_TIMER_BUDGET, FN_START, FN_END, CB_START, INTERACTION_API, REMAINING,
   INTERACTION, SPA_NODE, JSONP_NODE, FETCH_START, FETCH_DONE, FETCH_BODY, JSONP_END, originalSetTimeout
 } = CONSTANTS
-export class Aggregate extends FeatureBase {
+export class Aggregate extends AggregateBase {
   static featureName = FEATURE_NAME
   constructor (agentIdentifier, aggregator) {
     super(agentIdentifier, aggregator, FEATURE_NAME)

package/src/features/utils/agent-session.js

@@ -6,7 +6,6 @@ import { isBrowserScope } from '../../common/util/global-scope'
 import { SessionEntity } from '../../common/session/session-entity'
 import { LocalStorage } from '../../common/storage/local-storage.js'
 import { FirstPartyCookies } from '../../common/storage/first-party-cookies'
-import { LocalMemory } from '../../common/storage/local-memory'
 
 let ranOnce = 0
 export function setupAgentSession (agentIdentifier) {
@@ -41,7 +40,7 @@ export function setupAgentSession (agentIdentifier) {
   // that's currently stored in the storage API into the local info.jsAttributes object
   if (isBrowserScope) {
     // retrieve & re-add all of the persisted setCustomAttribute|setUserId k-v from previous page load(s)
-    const customSessionData = agentRuntime.session?.read?.()?.custom
+    const customSessionData = agentRuntime.session.state.custom
     const agentInfo = getInfo(agentIdentifier)
     if (customSessionData) {
       setInfo(agentIdentifier, { ...agentInfo, jsAttributes: { ...agentInfo.jsAttributes, ...customSessionData } })

package/src/features/utils/aggregate-base.js

@@ -0,0 +1,51 @@
+import { registerHandler } from '../../common/event-emitter/register-handler'
+import { FeatureBase } from './feature-base'
+import { getInfo, isConfigured, getRuntime } from '../../common/config/config'
+import { configure } from '../../loaders/configure/configure'
+import { gosCDN } from '../../common/window/nreum'
+
+export class AggregateBase extends FeatureBase {
+  constructor (...args) {
+    super(...args)
+    this.checkConfiguration()
+  }
+
+  waitForFlags (flagNames = []) {
+    return Promise.all(flagNames.map(fName => new Promise((resolve) => {
+      registerHandler(`feat-${fName}`, () => {
+        resolve({ name: fName, value: true })
+      }, this.featureName, this.ee)
+      registerHandler(`block-${fName}`, () => {
+        resolve({ name: fName, value: false })
+      }, this.feature, this.ee)
+    })
+    ))
+  }
+
+  /**
+   * Checks for additional `jsAttributes` items to support backward compatibility with implementations of the agent where
+   * loader configurations may appear after the loader code is executed.
+   */
+  checkConfiguration () {
+    // NOTE: This check has to happen at aggregator load time
+    if (!isConfigured(this.agentIdentifier)) {
+      let jsAttributes = { ...gosCDN().info?.jsAttributes }
+      try {
+        jsAttributes = {
+          ...jsAttributes,
+          ...getInfo(this.agentIdentifier)?.jsAttributes
+        }
+      } catch (err) {
+        // do nothing
+      }
+      configure(this.agentIdentifier, {
+        ...gosCDN(),
+        info: {
+          ...gosCDN().info,
+          jsAttributes
+        },
+        runtime: getRuntime(this.agentIdentifier)
+      })
+    }
+  }
+}

package/src/features/utils/feature-base.js

@@ -1,7 +1,5 @@
-import { getInfo, isConfigured, getRuntime } from '../../common/config/config'
+import { getRuntime } from '../../common/config/config'
 import { ee } from '../../common/event-emitter/contextual-ee'
-import { configure } from '../../loaders/configure/configure'
-import { gosCDN } from '../../common/window/nreum'
 
 export class FeatureBase {
   constructor (agentIdentifier, aggregator, featureName) {
@@ -19,33 +17,5 @@ export class FeatureBase {
      * @type {boolean}
      */
     this.blocked = false
-
-    this.checkConfiguration()
-  }
-
-  /**
-   * Checks for additional `jsAttributes` items to support backward compatibility with implementations of the agent where
-   * loader configurations may appear after the loader code is executed.
-   */
-  checkConfiguration () {
-    // NOTE: This check has to happen at aggregator load time
-    if (!isConfigured(this.agentIdentifier)) {
-      let jsAttributes = { ...gosCDN().info?.jsAttributes }
-      try {
-        jsAttributes = {
-          ...jsAttributes,
-          ...getInfo(this.agentIdentifier)?.jsAttributes
-        }
-      } catch (err) {
-        // do nothing
-      }
-      configure(this.agentIdentifier, {
-        ...gosCDN(),
-        info: {
-          ...gosCDN().info,
-          jsAttributes
-        }
-      })
-    }
   }
 }

package/src/features/utils/handler-cache.js

@@ -5,8 +5,6 @@
 export class HandlerCache {
   /** @private @type {boolean | undefined} */
   #decision = undefined
-  /** @private @type {boolean} */
-  #shouldsettle = true
   /** @private @type {Function[]} */
   #cache = []
   /** @private @type {Timeout} */
@@ -29,7 +27,7 @@ export class HandlerCache {
      * @private
      */
   #close () {
-    this.#shouldsettle = false
+    this.#decision = false // settle() & decide() cannot be used after close
     this.#cache = []
   }
 
@@ -39,7 +37,7 @@ export class HandlerCache {
      * @returns {void}
      */
   settle (handler) {
-    if (this.#decision === false || this.#shouldsettle === false) return
+    if (this.#decision === false) return
     else if (this.#decision === undefined) this.#cache.push(handler)
     else handler()
   }
@@ -53,6 +51,7 @@ export class HandlerCache {
      * @param {boolean} decision
      */
   decide (decision) {
+    if (this.#decision !== undefined) return // a decision can only be made once
     this.#decision = decision
     if (decision === false) this.#close()
     if (decision === true) this.#drain()

package/src/features/utils/instrument-base.js

@@ -4,11 +4,13 @@
  * exposes the `blocked` property.
  */
 
-import { registerDrain } from '../../common/drain/drain'
+import { drain, registerDrain } from '../../common/drain/drain'
 import { FeatureBase } from './feature-base'
 import { onWindowLoad } from '../../common/window/load'
 import { isWorkerScope } from '../../common/util/global-scope'
 import { warn } from '../../common/util/console'
+import { FEATURE_NAMES } from '../../loaders/features/features'
+import { getConfigurationValue } from '../../common/config/config'
 
 /**
  * Base class for instrumenting a feature.
@@ -38,11 +40,19 @@ export class InstrumentBase extends FeatureBase {
   /**
    * Lazy-load the latter part of the feature: its aggregator. This method is called by the first part of the feature
    * (the instrumentation) when instrumentation is complete.
+   * @param {Object} [argsObjFromInstrument] - any values or references to pass down to aggregate
+   * @returns void
    */
-  importAggregator () {
+  importAggregator (argsObjFromInstrument) {
     if (this.hasAggregator || !this.auto) return
     this.hasAggregator = true
-
+    let session, agentSessionImport
+    if (getConfigurationValue(this.agentIdentifier, 'privacy.cookies_enabled') === true && !isWorkerScope) {
+      agentSessionImport = import(/* webpackChunkName: "session-manager" */ './agent-session')
+        .catch(err => {
+          warn('failed to import the session manager', err)
+        })
+    }
     const importLater = async () => {
       /**
        * Note this try-catch differs from the one in Agent.start() in that it's placed later in a page's lifecycle and
@@ -50,12 +60,19 @@ export class InstrumentBase extends FeatureBase {
        */
       try {
         // The session entity needs to be attached to the config internals before the aggregator chunk runs
-        const { setupAgentSession } = await import(/* webpackChunkName: "session-manager" */ './agent-session')
-        setupAgentSession(this.agentIdentifier)
+        if (agentSessionImport && !session) {
+          const { setupAgentSession } = await agentSessionImport
+          session = setupAgentSession(this.agentIdentifier)
+        }
+        if (!shouldImportAgg(this.featureName, session)) {
+          drain(this.agentIdentifier, this.featureName)
+          return
+        }
+
         // import and instantiate the aggregator chunk
-        const { lazyLoader } = await import(/* webpackChunkName: "lazy-loader" */ './lazy-loader')
-        const { Aggregate } = await lazyLoader(this.featureName, 'aggregate')
-        new Aggregate(this.agentIdentifier, this.aggregator)
+        const { lazyFeatureLoader } = await import(/* webpackChunkName: "lazy-feature-loader" */ './lazy-feature-loader')
+        const { Aggregate } = await lazyFeatureLoader(this.featureName, 'aggregate')
+        new Aggregate(this.agentIdentifier, this.aggregator, argsObjFromInstrument)
       } catch (e) {
         warn(`Downloading ${this.featureName} failed...`, e)
         this.abortHandler?.() // undo any important alterations made to the page
@@ -69,3 +86,18 @@ export class InstrumentBase extends FeatureBase {
     else onWindowLoad(() => importLater(), true)
   }
 }
+/**
+ * Make a determination if an aggregate class should even be imported
+ * @param {string} featureName
+ * @param {SessionEntity} session
+ * @returns
+ */
+function shouldImportAgg (featureName, session) {
+  // if this isnt the FIRST load of a session AND
+  // we are not actively recording SR... DO NOT run the aggregator
+  // session replay samples can only be decided on the first load of a session
+  // session replays can continue if in progress
+  if (featureName === FEATURE_NAMES.sessionReplay) return !!session?.isNew || !!session?.state.sessionReplayActive
+  // todo -- add case like above for session trace
+  return true
+}

package/src/features/utils/{lazy-loader.js → lazy-feature-loader.js}

@@ -11,7 +11,7 @@ import { FEATURE_NAMES } from '../../loaders/features/features'
  * @param featurePart Name of the feature part to load; should be either instrument or aggregate
  * @returns {Promise<InstrumentBase|FeatureBase|null>}
  */
-export function lazyLoader (featureName, featurePart) {
+export function lazyFeatureLoader (featureName, featurePart) {
   if (featurePart === 'aggregate') {
     switch (featureName) {
       case FEATURE_NAMES.ajax:
@@ -26,6 +26,8 @@ export function lazyLoader (featureName, featurePart) {
         return import(/* webpackChunkName: "page_view_event-aggregate" */ '../page_view_event/aggregate')
       case FEATURE_NAMES.pageViewTiming:
         return import(/* webpackChunkName: "page_view_timing-aggregate" */ '../page_view_timing/aggregate')
+      case FEATURE_NAMES.sessionReplay:
+        return import(/* webpackChunkName: "session_replay-aggregate" */ '../session_replay/aggregate')
       case FEATURE_NAMES.sessionTrace:
         return import(/* webpackChunkName: "session_trace-aggregate" */ '../session_trace/aggregate')
       case FEATURE_NAMES.spa:

package/src/loaders/agent.js

@@ -49,7 +49,7 @@ export class Agent {
     // Attempt to initialize all the requested features (sequentially in prio order & synchronously), with any failure aborting the whole process.
     try {
       const enabledFeatures = getEnabledFeatures(this.agentIdentifier)
-      const featuresToStart = Array.from(this.desiredFeatures)
+      const featuresToStart = [...this.desiredFeatures]
       featuresToStart.sort((a, b) => featurePriority[a.featureName] - featurePriority[b.featureName])
       featuresToStart.forEach(f => {
         // pageViewEvent must be enabled because RUM calls are not optional. See comment in constructor and PR 428.

package/src/loaders/api/apiAsync.js

@@ -78,7 +78,7 @@ export function setAPI (agentIdentifier) {
     url += 'fe=' + ~~fe_time + '&'
     url += 'c=' + cycle
 
-    submitData.img(url)
+    submitData.img({ url })
   }
 
   function setErrorHandler (t, handler) {

package/src/loaders/configure/configure.js

@@ -13,15 +13,16 @@ export function configure (agentIdentifier, opts = {}, loaderType, forceDrain) {
     loader_config = nr.loader_config
   }
 
+  setConfiguration(agentIdentifier, init || {})
+  setLoaderConfig(agentIdentifier, loader_config || {})
+  setRuntime(agentIdentifier, runtime)
+
   info.jsAttributes ??= {}
   if (isWorkerScope) { // add a default attr to all worker payloads
     info.jsAttributes.isWorker = true
   }
 
   setInfo(agentIdentifier, info)
-  setConfiguration(agentIdentifier, init || {})
-  setLoaderConfig(agentIdentifier, loader_config || {})
-  setRuntime(agentIdentifier, runtime)
 
   setTopLevelCallers()
   const api = setAPI(agentIdentifier, forceDrain)

package/src/loaders/features/featureDependencies.js

@@ -12,15 +12,3 @@ export function getFeatureDependencyNames (feature) {
       return []
   }
 }
-
-export function getFrozenAttributes (feature) {
-  switch (feature) {
-    // right now, jserrors is the only feature that can have "on" or "off" page-level auto-instrumentation...
-    // page_action is always "off" (no instr)
-    // as new API/manual implementation methods are added, this list can likely be pruned
-    case FEATURE_NAMES.jserrors:
-      return []
-    default:
-      return ['auto']
-  }
-}

package/src/loaders/features/features.js

@@ -5,6 +5,7 @@ export const FEATURE_NAMES = {
   pageAction: 'page_action',
   pageViewEvent: 'page_view_event',
   pageViewTiming: 'page_view_timing',
+  sessionReplay: 'session_replay',
   sessionTrace: 'session_trace',
   spa: 'spa'
 }
@@ -21,5 +22,6 @@ export const featurePriority = {
   [FEATURE_NAMES.ajax]: 5,
   [FEATURE_NAMES.sessionTrace]: 6,
   [FEATURE_NAMES.pageAction]: 7,
-  [FEATURE_NAMES.spa]: 8
+  [FEATURE_NAMES.spa]: 8,
+  [FEATURE_NAMES.sessionReplay]: 9
 }

package/src/loaders/micro-agent.js

@@ -54,8 +54,8 @@ export class MicroAgent {
       autoFeatures.forEach(f => {
         if (enabledFeatures[f]) {
           // TODO - THIS does not work, the instrument switch in lazy loader increases the size of the worker build.  Needs to be revisited
-          import(/* webpackChunkName: "lazy-loader" */ '../features/utils/lazy-loader').then(({ lazyLoader }) => {
-            return lazyLoader(f, 'instrument')
+          import(/* webpackChunkName: "lazy-feature-loader" */ '../features/utils/lazy-feature-loader').then(({ lazyFeatureLoader }) => {
+            return lazyFeatureLoader(f, 'instrument')
           }).then(({ Instrument }) => {
             this.features[f] = new Instrument(this.agentIdentifier, this.sharedAggregator)
           }).catch(err =>
@@ -66,8 +66,8 @@ export class MicroAgent {
         if (enabledFeatures[f]) {
           // TODO - THIS does not work, the instrument switch in lazy loader increases the size of the worker build.  Needs to be revisited
           // Parts of the lazy-loader were removed because webpack was transpiling them into the worker build, errantly inflating the build size.
-          import(/* webpackChunkName: "lazy-loader" */ '../features/utils/lazy-loader').then(({ lazyLoader }) => {
-            return lazyLoader(f, 'aggregate')
+          import(/* webpackChunkName: "lazy-feature-loader" */ '../features/utils/lazy-feature-loader').then(({ lazyFeatureLoader }) => {
+            return lazyFeatureLoader(f, 'aggregate')
           }).then(({ Aggregate }) => {
             this.features[f] = new Aggregate(this.agentIdentifier, this.sharedAggregator)
           }).catch(err =>

package/dist/cjs/common/metrics/framework-detection.js

@@ -1,72 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getFrameworks = getFrameworks;
-var _globalScope = require("../util/global-scope");
-var FRAMEWORKS = {
-  REACT: 'React',
-  ANGULAR: 'Angular',
-  ANGULARJS: 'AngularJS',
-  BACKBONE: 'Backbone',
-  EMBER: 'Ember',
-  VUE: 'Vue',
-  METEOR: 'Meteor',
-  ZEPTO: 'Zepto',
-  JQUERY: 'Jquery'
-};
-function getFrameworks() {
-  if (!_globalScope.isBrowserScope) return []; // don't bother detecting frameworks if not in the main window context
-
-  var frameworks = [];
-  try {
-    if (detectReact()) frameworks.push(FRAMEWORKS.REACT);
-    if (detectAngularJs()) frameworks.push(FRAMEWORKS.ANGULARJS);
-    if (detectAngular()) frameworks.push(FRAMEWORKS.ANGULAR);
-    if (window.Backbone) frameworks.push(FRAMEWORKS.BACKBONE);
-    if (window.Ember) frameworks.push(FRAMEWORKS.EMBER);
-    if (window.Vue) frameworks.push(FRAMEWORKS.VUE);
-    if (window.Meteor) frameworks.push(FRAMEWORKS.METEOR);
-    if (window.Zepto) frameworks.push(FRAMEWORKS.ZEPTO);
-    if (window.jQuery) frameworks.push(FRAMEWORKS.JQUERY);
-  } catch (err) {
-    // not supported?
-  }
-  return frameworks;
-}
-function detectReact() {
-  try {
-    if (!!window.React || !!window.ReactDOM || !!window.ReactRedux) return true;
-    if (document.querySelector('[data-reactroot], [data-reactid]')) return true;
-    var divs = document.querySelectorAll('body > div');
-    for (var i = 0; i < divs.length; i++) {
-      if (Object.keys(divs[i]).indexOf('_reactRootContainer') >= 0) return true;
-    }
-    return false;
-  } catch (err) {
-    // not supported?
-    return false;
-  }
-}
-function detectAngularJs() {
-  try {
-    if (window.angular) return true;
-    if (document.querySelector('.ng-binding, [ng-app], [data-ng-app], [ng-controller], [data-ng-controller], [ng-repeat], [data-ng-repeat]')) return true;
-    if (document.querySelector('script[src*="angular.js"], script[src*="angular.min.js"]')) return true;
-    return false;
-  } catch (err) {
-    // not supported?
-    return false;
-  }
-}
-function detectAngular() {
-  try {
-    // eslint-disable-next-line
-    if (window.hasOwnProperty('ng') && window.ng.hasOwnProperty('coreTokens') && window.ng.coreTokens.hasOwnProperty('NgZone')) return true;
-    return !!document.querySelectorAll('[ng-version]').length;
-  } catch (err) {
-    // not supported?
-    return false;
-  }
-}

package/dist/cjs/common/util/user-agent.js

@@ -1,57 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.agent = void 0;
-exports.match = match;
-exports.version = void 0;
-/*
- * Copyright 2020 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-// Feature-detection is much preferred over using User Agent to detect browser.
-// However, there are cases where feature detection is not possible, for example
-// when a specific version of a browser has a bug that requires a workaround in just
-// that version.
-// https://developer.mozilla.org/en-US/docs/Web/HTTP/Browser_detection_using_the_user_agent#Browser_Name
-var agentName = null;
-exports.agent = agentName;
-var agentVersion = null;
-exports.version = agentVersion;
-const safari = /Version\/(\S+)\s+Safari/;
-if (navigator.userAgent) {
-  var userAgent = navigator.userAgent;
-  var parts = userAgent.match(safari);
-  if (parts && userAgent.indexOf('Chrome') === -1 && userAgent.indexOf('Chromium') === -1) {
-    exports.agent = agentName = 'Safari';
-    exports.version = agentVersion = parts[1];
-  }
-}
-function match(name, version) {
-  if (!agentName) {
-    return false;
-  }
-  if (name !== agentName) {
-    return false;
-  }
-
-  // version not provided, only match by name
-  if (!version) {
-    return true;
-  }
-
-  // version provided, but not detected - not reliable match
-  if (!agentVersion) {
-    return false;
-  }
-  var detectedParts = agentVersion.split('.');
-  var requestedParts = version.split('.');
-  for (var i = 0; i < requestedParts.length; i++) {
-    if (requestedParts[i] !== detectedParts[i]) {
-      return false;
-    }
-  }
-  return true;
-}

package/dist/cjs/common/window/supports-performance-observer.js

@@ -1,15 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.supportsPerformanceObserver = supportsPerformanceObserver;
-var _globalScope = require("../util/global-scope");
-/*
- * Copyright 2020 New Relic Corporation. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-function supportsPerformanceObserver() {
-  return typeof _globalScope.globalScope?.PerformanceObserver === 'function';
-}