@newrelic/browser-agent 1.312.1 → 1.313.0-rc.1

package/src/loaders/api/register.js

@@ -4,7 +4,7 @@
  */
 import { handle } from '../../common/event-emitter/handle'
 import { warn } from '../../common/util/console'
-import { V2_TYPES } from '../../common/util/v2'
+import { V2_TYPES } from '../../common/v2/utils'
 import { FEATURE_NAMES } from '../features/features'
 import { now } from '../../common/timing/now'
 import { SUPPORTABILITY_METRIC_CHANNEL } from '../../features/metrics/constants'
@@ -17,7 +17,7 @@ import { single } from '../../common/util/invoke'
 import { measure } from './measure'
 import { recordCustomEvent } from './recordCustomEvent'
 import { subscribeToPageUnload } from '../../common/window/page-visibility'
-import { findScriptTimings } from '../../common/util/script-tracker'
+import { findScriptTimings } from '../../common/v2/script-tracker'
 import { generateRandomHexString } from '../../common/ids/unique-id'
 
 /**
@@ -26,6 +26,29 @@ import { generateRandomHexString } from '../../common/ids/unique-id'
 
 const PROTECTED_KEYS = ['name', 'id', 'type']
 
+/**
+ * Map of API methods to their names (prevents minification from breaking method name references)
+ * @private
+ */
+const METHOD_NAMES = new Map([
+  [addPageAction, 'addPageAction'],
+  [log, 'log'],
+  [measure, 'measure'],
+  [noticeError, 'noticeError'],
+  [recordCustomEvent, 'recordCustomEvent']
+])
+
+/**
+ * Warning functions that only fire once - can be reset in tests
+ * @private
+ */
+export const warnings = {
+  experimental: single(() => warn(54, 'newrelic.register')),
+  disabled: single(() => warn(55)),
+  invalidTarget: single((target) => warn(48, target)),
+  deregistered: single(() => warn(68))
+}
+
 /**
  * @experimental
  * IMPORTANT: This feature is being developed for use internally and is not in a public-facing production-ready state.
@@ -42,11 +65,10 @@ export function setupRegisterAPI (agent) {
  * Also conducts certain side-effects, such as harvesting a PageView event when triggered and gathering metadata for the registered entity.
  * @param {Object} agentRef the reference to the base agent instance
  * @param {import('./register-api-types').RegisterAPIConstructor} target
- * @param {import('./register-api-types').RegisterAPIConstructor} [parent]
  * @returns {RegisterAPI} the api object to be returned from the register api method
  */
-function register (agentRef, target, parent) {
-  warn(54, 'newrelic.register')
+function register (agentRef, target) {
+  warnings.experimental()
 
   target ||= {}
   target.instance = generateRandomHexString(8)
@@ -54,7 +76,7 @@ function register (agentRef, target, parent) {
   target.licenseKey ||= agentRef.info.licenseKey // will inherit the license key from the container agent if not provided for brevity. A future state may dictate that we need different license keys to do different things.
   target.blocked = false
   if (typeof target.tags !== 'object' || target.tags === null || Array.isArray(target.tags)) target.tags = {}
-  target.parent = parent || {
+  target.parent ??= {
     get id () { return agentRef.runtime.appMetadata.agents[0].entityGuid }, // getter because this is asyncronously set
     type: V2_TYPES.BA
   }
@@ -62,18 +84,22 @@ function register (agentRef, target, parent) {
   const timings = findScriptTimings()
 
   const attrs = {}
-  Object.defineProperty(target, 'attributes', {
-    get () {
-      return {
-        ...attrs,
-        'source.id': target.id,
-        'source.name': target.name,
-        'source.type': target.type,
-        'parent.type': target.parent?.type || V2_TYPES.BA,
-        'parent.id': target.parent?.id
+
+  // Only define attributes getter if it doesn't already exist
+  if (!Object.prototype.hasOwnProperty.call(target, 'attributes')) {
+    Object.defineProperty(target, 'attributes', {
+      get () {
+        return {
+          ...attrs,
+          'source.id': target.id,
+          'source.name': target.name,
+          'source.type': target.type,
+          'parent.type': target.parent?.type || V2_TYPES.BA,
+          'parent.id': target.parent?.id
+        }
       }
-    }
-  })
+    })
+  }
 
   // Process tags object and add to attrs, excluding protected keys
   Object.entries(target.tags).forEach(([key, value]) => {
@@ -82,19 +108,11 @@ function register (agentRef, target, parent) {
     }
   })
 
-  target.isolated ??= true
-
   /** @type {Function} a function that is set and reports when APIs are triggered -- warns the customer of the invalid state  */
   let invalidApiResponse = () => {}
   /** @type {Array} the array of registered target APIs */
   const registeredEntities = agentRef.runtime.registeredEntities
 
-  if (!target.isolated) {
-  /** if we have already registered this non-isolated target, go ahead and re-use it */
-    const sharedEntity = registeredEntities.find(({ metadata: { target: { id } } }) => id === target.id && !target.isolated)
-    if (sharedEntity) return sharedEntity
-  }
-
   /**
    * Block the API, and supply a warning function to display a message to end users
    * @param {Function} warning
@@ -109,8 +127,8 @@ function register (agentRef, target, parent) {
   }
 
   /** primary cases that can block the register API from working at init time */
-  if (!agentRef.init.api.allow_registered_children) block(single(() => warn(55)))
-  if (!hasValidValue(target.id) || !hasValidValue(target.name)) block(single(() => warn(48, target)))
+  if (!agentRef.init.api.register.enabled) block(warnings.disabled)
+  if (!hasValidValue(target.id) || !hasValidValue(target.name)) block(() => warnings.invalidTarget(target))
 
   /** @type {RegisterAPI} */
   const api = {
@@ -118,12 +136,11 @@ function register (agentRef, target, parent) {
     deregister: () => {
       /** note: blocking this instance will disable access for all entities sharing the instance, and will invalidate it from the v2 checks */
       reportTimings()
-      block(single(() => warn(68)))
+      block(warnings.deregistered)
     },
     log: (message, options = {}) => report(log, [message, { ...options, customAttributes: { ...attrs, ...(options.customAttributes || {}) } }, agentRef], target),
     measure: (name, options = {}) => report(measure, [name, { ...options, customAttributes: { ...attrs, ...(options.customAttributes || {}) } }, agentRef], target),
     noticeError: (error, attributes = {}) => report(noticeError, [error, { ...attrs, ...attributes }, agentRef], target),
-    register: (target = {}) => report(register, [agentRef, target], api.metadata.target),
     recordCustomEvent: (eventType, attributes = {}) => report(recordCustomEvent, [eventType, { ...attrs, ...attributes }, agentRef], target),
     setApplicationVersion: (value) => setLocalValue('application.version', value),
     setCustomAttribute: (key, value) => setLocalValue(key, value),
@@ -160,14 +177,17 @@ function register (agentRef, target, parent) {
     // only ever report the timings the first time this is called
     if (timings.reportedAt) return
     timings.reportedAt = now()
+    const timeToFetch = timings.fetchEnd - timings.fetchStart // fetchStart to fetchEnd
+    const timeToExecute = timings.scriptEnd - timings.scriptStart // scriptStart to scriptEnd
     api.recordCustomEvent('MicroFrontEndTiming', {
       assetUrl: timings.asset, // the url of the script that was registered, or undefined if it could not be determined (inline or no match)
       assetType: timings.type, // the type of asset that was associated with the timings, one of 'script', 'link' (if preloaded and found in the resource timing buffer), 'preload' (if preloaded but not found in the resource timing buffer), or "unknown" if it could not be determined
-      timeToLoad: timings.registeredAt - timings.fetchStart, // fetchStart to registeredAt
+      timeAlive: timings.reportedAt - timings.registeredAt, // registeredAt to reportedAt
       timeToBeRequested: timings.fetchStart, // origin to fetchStart
-      timeToFetch: timings.fetchEnd - timings.fetchStart, // fetchStart to fetchEnd
-      timeToRegister: timings.registeredAt - timings.fetchEnd, // fetchEnd to registeredAt
-      timeAlive: timings.reportedAt - timings.registeredAt // registeredAt to reportedAt
+      timeToExecute, // scriptStart to scriptEnd
+      timeToFetch, // fetchStart to fetchEnd
+      timeToLoad: timeToFetch + timeToExecute, // fetch time and script time together
+      timeToRegister: timings.registeredAt // timestamp when register() was called
     })
   }
 
@@ -184,7 +204,7 @@ function register (agentRef, target, parent) {
 
   /**
      * The reporter method that will be used to report the data to the container agent's API method. If invalid, will log a warning and not execute.
-     * If the api.duplicate_registered_data configuration value is set to true, the data will be reported to BOTH the container and the external target
+     * If the api.register.duplicate_data_to_container configuration value is set to true, the data will be reported to BOTH the container and the external target
      * @param {*} methodToCall the container agent's API method to call
      * @param {*} args the arguments to supply to the container agent's API method
      * @param {string} target the target to report the data to. If undefined, will report to the container agent's target.
@@ -195,7 +215,8 @@ function register (agentRef, target, parent) {
     if (isBlocked() && methodToCall !== register) return
     /** set the timestamp before the async part of waiting for the rum response for better accuracy */
     const timestamp = now()
-    handle(SUPPORTABILITY_METRIC_CHANNEL, [`API/register/${methodToCall.name}/called`], undefined, FEATURE_NAMES.metrics, agentRef.ee)
+    const methodName = METHOD_NAMES.get(methodToCall) || 'unknown'
+    handle(SUPPORTABILITY_METRIC_CHANNEL, [`API/register/${methodName}/called`], undefined, FEATURE_NAMES.metrics, agentRef.ee)
     try {
       return methodToCall(...args, target, timestamp) // always report to target
     } catch (err) {

package/dist/cjs/common/util/script-tracker.js

@@ -1,204 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.extractUrlsFromStack = extractUrlsFromStack;
-exports.findScriptTimings = findScriptTimings;
-exports.getDeepStackTrace = getDeepStackTrace;
-exports.thisFile = void 0;
-var _runtime = require("../constants/runtime");
-var _now = require("../timing/now");
-var _cleanUrl = require("../url/clean-url");
-var _browserStackMatchers = require("./browser-stack-matchers");
-/**
- * Copyright 2020-2026 New Relic, Inc. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @typedef {import('./register-api-types').RegisterAPITimings} RegisterAPITimings
- */
-
-/** export for testing purposes */
-let thisFile = exports.thisFile = void 0;
-try {
-  exports.thisFile = thisFile = extractUrlsFromStack(getDeepStackTrace())[0];
-} catch (err) {
-  exports.thisFile = thisFile = extractUrlsFromStack(err)[0];
-}
-
-/** @type {(entry: PerformanceEntry) => boolean} - A shared function to determine if a performance entry is a valid script or link resource for evaluation */
-const validEntryCriteria = entry => entry.initiatorType === 'script' || ['link', 'fetch'].includes(entry.initiatorType) && entry.name.endsWith('.js');
-
-/** @type {Set<PerformanceResourceTiming>} - A set of resource timing objects that are "valid" -- see "validEntryCriteria" */
-const scripts = new Set();
-/** @type {Array<{ test: (entry: PerformanceEntry) => boolean, addedAt: number }>} an array of PerformanceObserver subscribers to check for late emissions */
-let poSubscribers = [];
-if (_runtime.globalScope.PerformanceObserver?.supportedEntryTypes.includes('resource')) {
-  /** We must track the script assets this way, because the performance buffer can fill up and when it does that
-   * it stops accepting new entries (instead of dropping old entries), which means if the register API is called
-   * after the buffer fills up we won't be able to get the script timing information from the resource timing API
-  */
-  const scriptObserver = new PerformanceObserver(list => {
-    list.getEntries().forEach(entry => {
-      if (validEntryCriteria(entry)) {
-        if (scripts.size > 250) scripts.delete(scripts.values().next().value); // keep the set from growing indefinitely, we only need to check recent entries against the stack of the register API caller, so we can drop old entries as new ones come in
-        scripts.add(entry);
-        const canClear = [];
-        poSubscribers.forEach(({
-          test,
-          addedAt
-        }, idx) => {
-          if (test(entry) || (0, _now.now)() - addedAt > 10000) canClear.push(idx); // Clear subscribers that have resolved or have been pending for more than 10 seconds
-        });
-        poSubscribers = poSubscribers.filter((_, idx) => !canClear.includes(idx));
-      }
-    });
-  });
-  scriptObserver.observe({
-    type: 'resource',
-    buffered: true
-  });
-}
-
-/**
- * Extracts URLs from stack traces using the same logic as compute-stack-trace.js
- * @param {string} stack The error stack trace
- * @returns {string[]} Array of cleaned URLs found in the stack trace
- */
-function extractUrlsFromStack(stack) {
-  if (!stack || typeof stack !== 'string') return [];
-  const urls = new Set();
-  const lines = stack.split('\n');
-  for (const line of lines) {
-    // Try gecko format first, then chrome
-    const parts = line.match(_browserStackMatchers.gecko) || line.match(_browserStackMatchers.chrome) || line.match(_browserStackMatchers.chromeEval);
-    if (parts && parts[2]) {
-      urls.add((0, _cleanUrl.cleanURL)(parts[2]));
-    } else {
-      // Fallback: match URLs using a generic .js pattern (non-greedy to handle ports and query params)
-      const fallbackMatch = line.match(/\(([^)]+\.js):\d+:\d+\)/) || line.match(/^\s+at\s+([^\s(]+\.js):\d+:\d+/);
-      if (fallbackMatch && fallbackMatch[1]) {
-        urls.add((0, _cleanUrl.cleanURL)(fallbackMatch[1]));
-      }
-    }
-  }
-  return [...urls];
-}
-
-/**
- * Returns a deep stack trace by temporarily increasing the stack trace limit.
- * @returns {Error.stack | undefined}
- */
-function getDeepStackTrace() {
-  let stack;
-  try {
-    const originalStackLimit = Error.stackTraceLimit;
-    Error.stackTraceLimit = 50;
-    stack = new Error().stack;
-    Error.stackTraceLimit = originalStackLimit;
-  } catch (e) {
-    stack = new Error().stack;
-  }
-  return stack;
-}
-
-/**
- * Indicates whether the provided URL matches any script preload link tags in the document.
- * @param {string} targetUrl The URL to match against preload tags
- * @returns {boolean} True if a matching preload link is found, false otherwise
- */
-function wasPreloaded(targetUrl) {
-  if (!targetUrl || !_runtime.globalScope.document) return false;
-  try {
-    const linkTags = _runtime.globalScope.document.querySelectorAll('link[rel="preload"][as="script"]');
-    for (const link of linkTags) {
-      // link.href is resolved to an absolute URL by the browser (even if supplied as relative), so we can match exactly against the cleaned target URL
-      if ((0, _cleanUrl.cleanURL)(link.href) === targetUrl) return true;
-    }
-  } catch (error) {
-    // Don't let DOM parsing errors break anything
-  }
-  return false;
-}
-
-/**
- * Uses the stack of the initiator function, returns script timing information if a script can be found with the resource timing API matching the URL found in the stack.
- * @returns {RegisterAPITimings} Object containing script fetch start and end times, and the asset URL if found
- */
-function findScriptTimings() {
-  const timings = {
-    registeredAt: (0, _now.now)(),
-    reportedAt: undefined,
-    fetchStart: 0,
-    fetchEnd: 0,
-    asset: undefined,
-    type: 'unknown'
-  };
-  const stack = getDeepStackTrace();
-  if (!stack) return timings;
-  const navUrl = _runtime.globalScope.performance?.getEntriesByType('navigation')?.[0]?.name || '';
-  try {
-    const urls = extractUrlsFromStack(stack);
-    /** if there is exactly one url, this means the MFE script is running in the same file as the agent.  Otherwise, lets strip away the known agent file from any other file lines */
-    const mfeScriptUrl = (urls.length > 1 ? urls.filter(line => !thisFile.endsWith(line) && !line.endsWith(thisFile)) : urls)[0];
-    if (!mfeScriptUrl) return timings;
-    if (navUrl.includes(mfeScriptUrl)) {
-      // this means the stack is indicating that the registration came from an inline script or eval, so we won't find a matching script resource - return early with just the URL
-      timings.asset = (0, _cleanUrl.cleanURL)(navUrl);
-      timings.type = 'inline';
-      return timings;
-    }
-
-    // try to find it in the static list, which updates faster than the PO.  This cant be solely trusted, since the buffer can fill up and stop accepting entries,
-    // but it can still help in cases where the check is made before the asset is emitted by the performance observer and the buffer is not full. Fallback to checking the PO
-    // entries that have been buffered as seen in the PO callback if its not found in the static list.
-    const match = performance.getEntriesByType('resource').find(entryMatchesMfe) || [...scripts].find(entryMatchesMfe);
-    if (match) {
-      setMatchedAttributes(match);
-    } else {
-      // We didnt find a match with the PO, nor a static lookup... check if its preloaded and if so, set basic fallbacks and try to associate with a later script entry if possible, this can happen if the preload is reported late in the PO observer callback
-      if (wasPreloaded(mfeScriptUrl)) {
-        timings.asset = mfeScriptUrl;
-        timings.type = 'preload';
-
-        // wait for a late PO callback...  The timings object can be mutated after the fact since we return a pointer and not a cloned object
-        poSubscribers.push({
-          addedAt: (0, _now.now)(),
-          test: entry => {
-            if (entryMatchesMfe(entry)) {
-              setMatchedAttributes(entry);
-              return true; // return true so that we know to clear this callback from the pending list since we found our match, otherwise it will stay in the list and be called for future entries which is unnecessary after we found our match and can cause performance issues if there are a lot of future entries and pending callbacks
-            }
-            return false;
-          }
-        });
-      }
-    }
-
-    /**
-     * A matcher function to determine if a performance entry corresponds to the MFE script based on URL matching. It checks if either the entry URL ends with the MFE script URL or vice versa, to account for potential differences in how URLs are represented in the stack trace versus the resource timing entries.
-     * @param {PerformanceResourceTiming} entry - The resource timing entry to compare to the MFE script
-     * @returns {boolean} True if we think the entry matches the MFE script, false otherwise
-     */
-    function entryMatchesMfe(entry) {
-      const entryUrl = (0, _cleanUrl.cleanURL)(entry.name);
-      return entryUrl.endsWith(mfeScriptUrl) || mfeScriptUrl.endsWith(entryUrl);
-    }
-
-    /**
-     * A helper function to set the matched timing attributes on the timings object based on a performance entry. This is called when we have identified a resource timing entry that we believe corresponds to the MFE script, and we want to extract the fetch start and end times, as well as the asset URL and type.
-     * @param {PerformanceResourceTiming} entry - The resource timing entry to base values off of
-     */
-    function setMatchedAttributes(entry) {
-      timings.fetchStart = Math.floor(entry.startTime);
-      timings.fetchEnd = Math.floor(entry.responseEnd);
-      timings.asset = entry.name;
-      timings.type = entry.initiatorType;
-    }
-  } catch (error) {
-    // Don't let stack parsing errors break anything
-  }
-  return timings;
-}

package/dist/esm/common/util/script-tracker.js

@@ -1,196 +0,0 @@
-/**
- * Copyright 2020-2026 New Relic, Inc. All rights reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { globalScope } from '../constants/runtime';
-import { now } from '../timing/now';
-import { cleanURL } from '../url/clean-url';
-import { chrome, chromeEval, gecko } from './browser-stack-matchers';
-
-/**
- * @typedef {import('./register-api-types').RegisterAPITimings} RegisterAPITimings
- */
-
-/** export for testing purposes */
-export let thisFile;
-try {
-  thisFile = extractUrlsFromStack(getDeepStackTrace())[0];
-} catch (err) {
-  thisFile = extractUrlsFromStack(err)[0];
-}
-
-/** @type {(entry: PerformanceEntry) => boolean} - A shared function to determine if a performance entry is a valid script or link resource for evaluation */
-const validEntryCriteria = entry => entry.initiatorType === 'script' || ['link', 'fetch'].includes(entry.initiatorType) && entry.name.endsWith('.js');
-
-/** @type {Set<PerformanceResourceTiming>} - A set of resource timing objects that are "valid" -- see "validEntryCriteria" */
-const scripts = new Set();
-/** @type {Array<{ test: (entry: PerformanceEntry) => boolean, addedAt: number }>} an array of PerformanceObserver subscribers to check for late emissions */
-let poSubscribers = [];
-if (globalScope.PerformanceObserver?.supportedEntryTypes.includes('resource')) {
-  /** We must track the script assets this way, because the performance buffer can fill up and when it does that
-   * it stops accepting new entries (instead of dropping old entries), which means if the register API is called
-   * after the buffer fills up we won't be able to get the script timing information from the resource timing API
-  */
-  const scriptObserver = new PerformanceObserver(list => {
-    list.getEntries().forEach(entry => {
-      if (validEntryCriteria(entry)) {
-        if (scripts.size > 250) scripts.delete(scripts.values().next().value); // keep the set from growing indefinitely, we only need to check recent entries against the stack of the register API caller, so we can drop old entries as new ones come in
-        scripts.add(entry);
-        const canClear = [];
-        poSubscribers.forEach(({
-          test,
-          addedAt
-        }, idx) => {
-          if (test(entry) || now() - addedAt > 10000) canClear.push(idx); // Clear subscribers that have resolved or have been pending for more than 10 seconds
-        });
-        poSubscribers = poSubscribers.filter((_, idx) => !canClear.includes(idx));
-      }
-    });
-  });
-  scriptObserver.observe({
-    type: 'resource',
-    buffered: true
-  });
-}
-
-/**
- * Extracts URLs from stack traces using the same logic as compute-stack-trace.js
- * @param {string} stack The error stack trace
- * @returns {string[]} Array of cleaned URLs found in the stack trace
- */
-export function extractUrlsFromStack(stack) {
-  if (!stack || typeof stack !== 'string') return [];
-  const urls = new Set();
-  const lines = stack.split('\n');
-  for (const line of lines) {
-    // Try gecko format first, then chrome
-    const parts = line.match(gecko) || line.match(chrome) || line.match(chromeEval);
-    if (parts && parts[2]) {
-      urls.add(cleanURL(parts[2]));
-    } else {
-      // Fallback: match URLs using a generic .js pattern (non-greedy to handle ports and query params)
-      const fallbackMatch = line.match(/\(([^)]+\.js):\d+:\d+\)/) || line.match(/^\s+at\s+([^\s(]+\.js):\d+:\d+/);
-      if (fallbackMatch && fallbackMatch[1]) {
-        urls.add(cleanURL(fallbackMatch[1]));
-      }
-    }
-  }
-  return [...urls];
-}
-
-/**
- * Returns a deep stack trace by temporarily increasing the stack trace limit.
- * @returns {Error.stack | undefined}
- */
-export function getDeepStackTrace() {
-  let stack;
-  try {
-    const originalStackLimit = Error.stackTraceLimit;
-    Error.stackTraceLimit = 50;
-    stack = new Error().stack;
-    Error.stackTraceLimit = originalStackLimit;
-  } catch (e) {
-    stack = new Error().stack;
-  }
-  return stack;
-}
-
-/**
- * Indicates whether the provided URL matches any script preload link tags in the document.
- * @param {string} targetUrl The URL to match against preload tags
- * @returns {boolean} True if a matching preload link is found, false otherwise
- */
-function wasPreloaded(targetUrl) {
-  if (!targetUrl || !globalScope.document) return false;
-  try {
-    const linkTags = globalScope.document.querySelectorAll('link[rel="preload"][as="script"]');
-    for (const link of linkTags) {
-      // link.href is resolved to an absolute URL by the browser (even if supplied as relative), so we can match exactly against the cleaned target URL
-      if (cleanURL(link.href) === targetUrl) return true;
-    }
-  } catch (error) {
-    // Don't let DOM parsing errors break anything
-  }
-  return false;
-}
-
-/**
- * Uses the stack of the initiator function, returns script timing information if a script can be found with the resource timing API matching the URL found in the stack.
- * @returns {RegisterAPITimings} Object containing script fetch start and end times, and the asset URL if found
- */
-export function findScriptTimings() {
-  const timings = {
-    registeredAt: now(),
-    reportedAt: undefined,
-    fetchStart: 0,
-    fetchEnd: 0,
-    asset: undefined,
-    type: 'unknown'
-  };
-  const stack = getDeepStackTrace();
-  if (!stack) return timings;
-  const navUrl = globalScope.performance?.getEntriesByType('navigation')?.[0]?.name || '';
-  try {
-    const urls = extractUrlsFromStack(stack);
-    /** if there is exactly one url, this means the MFE script is running in the same file as the agent.  Otherwise, lets strip away the known agent file from any other file lines */
-    const mfeScriptUrl = (urls.length > 1 ? urls.filter(line => !thisFile.endsWith(line) && !line.endsWith(thisFile)) : urls)[0];
-    if (!mfeScriptUrl) return timings;
-    if (navUrl.includes(mfeScriptUrl)) {
-      // this means the stack is indicating that the registration came from an inline script or eval, so we won't find a matching script resource - return early with just the URL
-      timings.asset = cleanURL(navUrl);
-      timings.type = 'inline';
-      return timings;
-    }
-
-    // try to find it in the static list, which updates faster than the PO.  This cant be solely trusted, since the buffer can fill up and stop accepting entries,
-    // but it can still help in cases where the check is made before the asset is emitted by the performance observer and the buffer is not full. Fallback to checking the PO
-    // entries that have been buffered as seen in the PO callback if its not found in the static list.
-    const match = performance.getEntriesByType('resource').find(entryMatchesMfe) || [...scripts].find(entryMatchesMfe);
-    if (match) {
-      setMatchedAttributes(match);
-    } else {
-      // We didnt find a match with the PO, nor a static lookup... check if its preloaded and if so, set basic fallbacks and try to associate with a later script entry if possible, this can happen if the preload is reported late in the PO observer callback
-      if (wasPreloaded(mfeScriptUrl)) {
-        timings.asset = mfeScriptUrl;
-        timings.type = 'preload';
-
-        // wait for a late PO callback...  The timings object can be mutated after the fact since we return a pointer and not a cloned object
-        poSubscribers.push({
-          addedAt: now(),
-          test: entry => {
-            if (entryMatchesMfe(entry)) {
-              setMatchedAttributes(entry);
-              return true; // return true so that we know to clear this callback from the pending list since we found our match, otherwise it will stay in the list and be called for future entries which is unnecessary after we found our match and can cause performance issues if there are a lot of future entries and pending callbacks
-            }
-            return false;
-          }
-        });
-      }
-    }
-
-    /**
-     * A matcher function to determine if a performance entry corresponds to the MFE script based on URL matching. It checks if either the entry URL ends with the MFE script URL or vice versa, to account for potential differences in how URLs are represented in the stack trace versus the resource timing entries.
-     * @param {PerformanceResourceTiming} entry - The resource timing entry to compare to the MFE script
-     * @returns {boolean} True if we think the entry matches the MFE script, false otherwise
-     */
-    function entryMatchesMfe(entry) {
-      const entryUrl = cleanURL(entry.name);
-      return entryUrl.endsWith(mfeScriptUrl) || mfeScriptUrl.endsWith(entryUrl);
-    }
-
-    /**
-     * A helper function to set the matched timing attributes on the timings object based on a performance entry. This is called when we have identified a resource timing entry that we believe corresponds to the MFE script, and we want to extract the fetch start and end times, as well as the asset URL and type.
-     * @param {PerformanceResourceTiming} entry - The resource timing entry to base values off of
-     */
-    function setMatchedAttributes(entry) {
-      timings.fetchStart = Math.floor(entry.startTime);
-      timings.fetchEnd = Math.floor(entry.responseEnd);
-      timings.asset = entry.name;
-      timings.type = entry.initiatorType;
-    }
-  } catch (error) {
-    // Don't let stack parsing errors break anything
-  }
-  return timings;
-}

package/dist/types/common/util/script-tracker.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"script-tracker.d.ts","sourceRoot":"","sources":["../../../../src/common/util/script-tracker.js"],"names":[],"mappings":"AAmDA;;;;GAIG;AACH,4CAHW,MAAM,GACJ,MAAM,EAAE,CAsBpB;AAED;;;GAGG;AACH,qCAFa,KAAK,CAAC,KAAK,GAAG,SAAS,CAanC;AAsBD;;;GAGG;AACH,qCAFa,kBAAkB,CAuE9B;AAlLD;;GAEG;AAEH,kCAAkC;AAClC,yBAAmB"}

package/dist/types/common/util/v2.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"v2.d.ts","sourceRoot":"","sources":["../../../../src/common/util/v2.js"],"names":[],"mappings":"AAkBA;;;;;GAKG;AACH,+CAJW,MAAM,GAAC,MAAM,YACb,GAAC,GACC,OAAO,oCAAoC,EAAE,yBAAyB,EAAE,CAMpF;AAED;;;;;GAKG;AACH,2DAJW,MAAM,YACN,GAAC,GACC,OAAO,oCAAoC,EAAE,yBAAyB,EAAE,CAMpF;AAED;;;;;;;GAOG;AACH,+CAJW,MAAM,sBACN,iBAAiB,GACf,MAAM,CAclB;AAED;;;;;;;GAOG;AACH,yDAJW,OAAO,oCAAoC,EAAE,yBAAyB,qBACtE,GAAC,GACC,MAAM,CAKlB;AAED;;;;;;GAMG;AACH,wCAJW,OAAO,oCAAoC,EAAE,yBAAyB,qBACtE,GAAC,GACC,OAAO,CAInB;AAED;;;;GAIG;AACH,oDAHW,GAAC,SAkBX;;;;uBApGS,MAAM"}