@newrelic/browser-agent 1.232.0 → 1.232.1

package/dist/esm/features/session_trace/aggregate/index.js

@@ -8,7 +8,6 @@ import { mapOwn } from '../../../common/util/map-own';
 import { stringify } from '../../../common/util/stringify';
 import { parseUrl } from '../../../common/url/parse-url';
 import { supportsPerformanceObserver } from '../../../common/window/supports-performance-observer';
-import slice from 'lodash._slice';
 import { getConfigurationValue, getInfo, getRuntime } from '../../../common/config/config';
 import { now } from '../../../common/timing/now';
 import { FEATURE_NAME } from '../constants';
@@ -252,7 +251,7 @@ export class Aggregate extends FeatureBase {
     } else if (t && typeof t.tagName === 'string') {
       origin = t.tagName.toLowerCase();
       if (t.id) origin += '#' + t.id;
-      if (t.className) origin += '.' + slice(t.classList).join('.');
+      if (t.className) origin += '.' + Array.from(t.classList).join('.');
     }
     if (origin === 'unknown') {
       if (typeof target === 'string') origin = target;else if (target === document) origin = 'document';else if (target === window) origin = 'window';else if (target instanceof FileReader) origin = 'FileReader';

package/dist/types/common/url/canonicalize-url.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Converts a URL to its basic form without a query string or fragment. If the resulting URL is the same as the
+ * loader's origin URL, returns '<inline>'.
+ * @param {string} url - The URL to be canonicalized.
+ * @param {string} loaderOriginUrl - The origin URL of the agent loader, used for inline detection.
+ * @returns {string} The canonicalized URL, or '<inline>' if the URL matches the loader origin URL.
+ */
+export function canonicalizeUrl(url: string): string;
+//# sourceMappingURL=canonicalize-url.d.ts.map

package/dist/types/common/url/canonicalize-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonicalize-url.d.ts","sourceRoot":"","sources":["../../../../src/common/url/canonicalize-url.js"],"names":[],"mappings":"AAQA;;;;;;GAMG;AACH,qCAJW,MAAM,GAEJ,MAAM,CAclB"}

package/dist/types/common/url/clean-url.d.ts

@@ -1,2 +1,8 @@
-export function cleanURL(url: any, keepHash: any): any;
+/**
+ * Cleans a URL by removing the query string and fragment (hash portion).
+ * @param {string} url - The original URL to be cleaned.
+ * @param {boolean} [keepHash=false] - Whether to preserve the hash portion of the URL.
+ * @returns {string} The cleaned URL.
+ */
+export function cleanURL(url: string, keepHash?: boolean | undefined): string;
 //# sourceMappingURL=clean-url.d.ts.map

package/dist/types/common/url/clean-url.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clean-url.d.ts","sourceRoot":"","sources":["../../../../src/common/url/clean-url.js"],"names":[],"mappings":"AAOA,uDAEC"}
+{"version":3,"file":"clean-url.d.ts","sourceRoot":"","sources":["../../../../src/common/url/clean-url.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,8BAJW,MAAM,mCAEJ,MAAM,CAIlB"}

package/dist/types/common/util/global-scope.d.ts

@@ -10,4 +10,5 @@ export function getGlobalScope(): typeof globalThis;
 export const isBrowserScope: boolean;
 export const isWorkerScope: boolean;
 export let globalScope: typeof globalThis;
+export const initialLocation: string;
 //# sourceMappingURL=global-scope.d.ts.map

package/dist/types/common/util/global-scope.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"global-scope.d.ts","sourceRoot":"","sources":["../../../../src/common/util/global-scope.js"],"names":[],"mappings":"AAsBA;;;;;GAKG;AACH,yCAEC;AACD,mCAYC;AACD,oDAEC;AA5CD,qCAC2D;AAE3D,oCACgG;AAEhG,0CAYI"}
+{"version":3,"file":"global-scope.d.ts","sourceRoot":"","sources":["../../../../src/common/util/global-scope.js"],"names":[],"mappings":"AAwBA;;;;;GAKG;AACH,yCAEC;AACD,mCAYC;AACD,oDAEC;AA9CD,qCAC2D;AAE3D,oCACgG;AAEhG,0CAYI;AAEJ,qCAAwD"}

package/dist/types/common/wrap/wrap-fetch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wrap-fetch.d.ts","sourceRoot":"","sources":["../../../../src/common/wrap/wrap-fetch.js"],"names":[],"mappings":"AAuBA;;;;;;;GAOG;AACH,oCAJW,MAAM,GAEJ,MAAM,CAqElB;AAED;;;;;;GAMG;AACH,mCAJW,MAAM,GAEJ,MAAM,CAIlB"}
+{"version":3,"file":"wrap-fetch.d.ts","sourceRoot":"","sources":["../../../../src/common/wrap/wrap-fetch.js"],"names":[],"mappings":"AAsBA;;;;;;;GAOG;AACH,oCAJW,MAAM,GAEJ,MAAM,CAqElB;AAED;;;;;;GAMG;AACH,mCAJW,MAAM,GAEJ,MAAM,CAIlB"}

package/dist/types/common/wrap/wrap-function.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wrap-function.d.ts","sourceRoot":"","sources":["../../../../src/common/wrap/wrap-function.js"],"names":[],"mappings":"AA2BA;;;;;GAKG;AACH,+EAHW,OAAO,YAkIjB;AA6DD;;;;;;;GAOG;AACH,wEAKC;AAED;;;;;;;GAOG;AACH,iCALW,MAAM,UACN,MAAM,2BAOhB;AA7OD,iCAAiC"}
+{"version":3,"file":"wrap-function.d.ts","sourceRoot":"","sources":["../../../../src/common/wrap/wrap-function.js"],"names":[],"mappings":"AA0BA;;;;;GAKG;AACH,+EAHW,OAAO,YAkIjB;AA6DD;;;;;;;GAOG;AACH,wEAKC;AAED;;;;;;;GAOG;AACH,iCALW,MAAM,UACN,MAAM,2BAOhB;AA7OD,iCAAiC"}

package/dist/types/features/jserrors/aggregate/canonical-function-name.d.ts

@@ -1,2 +1,9 @@
-export function canonicalFunctionName(orig: any): any;
+/**
+ * Given a function name string, extracts only an alphanumeric segment at the end of the string (if one exists).
+ * This is useful for stack traces, where functions might not be named (e.g., anonymous, computed).
+ *
+ * @param {string} functionNameString - The original function name string.
+ * @returns {string|undefined} The canonical function name, or undefined if the input is falsy or no alphanumeric segments are found.
+ */
+export function canonicalFunctionName(functionNameString: string): string | undefined;
 //# sourceMappingURL=canonical-function-name.d.ts.map

package/dist/types/features/jserrors/aggregate/canonical-function-name.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"canonical-function-name.d.ts","sourceRoot":"","sources":["../../../../../src/features/jserrors/aggregate/canonical-function-name.js"],"names":[],"mappings":"AAMA,sDAOC"}
+{"version":3,"file":"canonical-function-name.d.ts","sourceRoot":"","sources":["../../../../../src/features/jserrors/aggregate/canonical-function-name.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,0DAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAS5B"}

package/dist/types/features/jserrors/aggregate/compute-stack-trace.d.ts

@@ -1,22 +1,51 @@
-export function computeStackTrace(ex: any): {
-    [x: string]: any;
-} | {
-    mode: string;
-    name: any;
-    message: any;
+/**
+ * Represents an error with a stack trace.
+ * @typedef {Object} StackInfo
+ * @property {string} name - The name of the error (e.g. 'TypeError').
+ * @property {string} message - The error message.
+ * @property {string} stackString - The stack trace as a string.
+ * @property {Array<Object>} frames - An array of frames in the stack trace.
+ * @property {string} frames.url - The URL of the file containing the code for the frame.
+ * @property {string} frames.func - The name of the function associated with the frame.
+ * @property {number} frames.line - The line number of the code in the frame.
+ */
+/**
+ * Attempts to compute a stack trace for the given exception.
+ * @param {Error} ex - The exception for which to compute the stack trace.
+ * @returns {StackInfo} A stack trace object containing information about the frames on the stack.
+ */
+export function computeStackTrace(ex: Error): StackInfo;
+/**
+ * Represents an error with a stack trace.
+ */
+export type StackInfo = {
+    /**
+     * - The name of the error (e.g. 'TypeError').
+     */
+    name: string;
+    /**
+     * - The error message.
+     */
+    message: string;
+    /**
+     * - The stack trace as a string.
+     */
     stackString: string;
-    frames: {
-        func: string;
-    }[];
-} | {
-    mode: string;
-    name: any;
-    message: any;
-    stackString: string;
-    frames: {
-        url: any;
-        line: any;
-        column: any;
-    }[];
+    /**
+     * - An array of frames in the stack trace.
+     */
+    frames: Array<Object>;
+    /**
+     * - The URL of the file containing the code for the frame.
+     */
+    url: string;
+    /**
+     * - The name of the function associated with the frame.
+     */
+    func: string;
+    /**
+     * - The line number of the code in the frame.
+     */
+    line: number;
 };
 //# sourceMappingURL=compute-stack-trace.d.ts.map

package/dist/types/features/jserrors/aggregate/compute-stack-trace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compute-stack-trace.d.ts","sourceRoot":"","sources":["../../../../../src/features/jserrors/aggregate/compute-stack-trace.js"],"names":[],"mappings":"AAoEA;;;;;;;;;;;;;;;;;;;;EAyCC"}
+{"version":3,"file":"compute-stack-trace.d.ts","sourceRoot":"","sources":["../../../../../src/features/jserrors/aggregate/compute-stack-trace.js"],"names":[],"mappings":"AAqEA;;;;;;;;;;GAUG;AAEH;;;;GAIG;AACH,sCAHW,KAAK,GACH,SAAS,CA2CrB;;;;;;;;UAvDa,MAAM;;;;aACN,MAAM;;;;iBACN,MAAM;;;;YACN,MAAM,MAAM,CAAC;;;;SACb,MAAM;;;;UACN,MAAM;;;;UACN,MAAM"}

package/dist/types/features/jserrors/aggregate/index.d.ts

@@ -1,3 +1,6 @@
+/**
+ * @typedef {import('./compute-stack-trace.js').StackInfo} StackInfo
+ */
 export class Aggregate extends FeatureBase {
     static featureName: string;
     constructor(agentIdentifier: any, aggregator: any);
@@ -13,12 +16,18 @@ export class Aggregate extends FeatureBase {
     onHarvestFinished(result: any): void;
     nameHash(params: any): number;
     getBucketName(params: any, customParams: any): string;
-    canonicalizeURL(url: any, cleanedOrigin: any): any;
-    buildCanonicalStackString(stackInfo: any, cleanedOrigin: any): string;
-    canonicalizeStackURLs(stackInfo: any): any;
+    /**
+     * Builds a standardized stack trace string from the frames in the given `stackInfo` object, with each frame separated
+     * by a newline character. Lines take the form `<functionName>@<url>:<lineNumber>`.
+     *
+     * @param {StackInfo} stackInfo - An object specifying a stack string and individual frames.
+     * @returns {string} A canonical stack string built from the URLs and function names in the given `stackInfo` object.
+     */
+    buildCanonicalStackString(stackInfo: StackInfo): string;
     storeError(err: any, time: any, internal: any, customAttributes: any): void;
     onInteractionSaved(interaction: any): void;
     onInteractionDiscarded(interaction: any): void;
 }
+export type StackInfo = import('./compute-stack-trace.js').StackInfo;
 import { FeatureBase } from '../../utils/feature-base';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/features/jserrors/aggregate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/jserrors/aggregate/index.js"],"names":[],"mappings":"AAyBA;IACE,2BAAiC;IACjC,mDAmCC;IAhCC,kBAAuB;IACvB,qBAA0B;IAC1B,eAAoB;IAEpB,qBAAwB;IA8B1B;;;MAoBC;IAfG,iBAAuB;IAiB3B,qCAWC;IAED,8BAEC;IAED,sDAEC;IAED,mDASC;IAED,sEAcC;IASD,2CAgBC;IAED,4EAsFC;IAED,2CAgCC;IAED,+CA2BC;CACF;4BA9R2B,0BAA0B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/jserrors/aggregate/index.js"],"names":[],"mappings":"AAwBA;;GAEG;AAEH;IACE,2BAAiC;IACjC,mDAmCC;IAhCC,kBAAuB;IACvB,qBAA0B;IAC1B,eAAoB;IAEpB,qBAAwB;IA8B1B;;;MAoBC;IAfG,iBAAuB;IAiB3B,qCAWC;IAED,8BAEC;IAED,sDAEC;IAED;;;;;;OAMG;IACH,qCAHW,SAAS,GACP,MAAM,CAgBlB;IAED,4EAsFC;IAED,2CAgCC;IAED,+CA2BC;CACF;wBAlQY,OAAO,0BAA0B,EAAE,SAAS;4BAH7B,0BAA0B"}

package/dist/types/features/jserrors/instrument/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/jserrors/instrument/index.js"],"names":[],"mappings":"AAmBA;IACE,2BAAiC;IACjC,mEAgDC;IA5CC,iBAAiB;IAGf,2CAA0C;IAyB5C,iCAAsC;IActC,yBAA+B;IAUjC;;;;;;;;;OASG;IACH,wBAPW,MAAM,YACN,MAAM,UACN,MAAM,UACN,MAAM,YACN,KAAK,MAAI,2BAiBnB;;CACF;+BA3F8B,6BAA6B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/jserrors/instrument/index.js"],"names":[],"mappings":"AAkBA;IACE,2BAAiC;IACjC,mEAgDC;IA5CC,iBAAiB;IAGf,2CAA0C;IAyB5C,iCAAsC;IActC,yBAA+B;IAUjC;;;;;;;;;OASG;IACH,wBAPW,MAAM,YACN,MAAM,UACN,MAAM,UACN,MAAM,YACN,KAAK,MAAI,2BAiBnB;;CACF;+BA3F8B,6BAA6B"}

package/dist/types/features/page_action/aggregate/index.d.ts

@@ -6,7 +6,7 @@ export class Aggregate extends FeatureBase {
     eventsPerHarvest: number;
     events: any[];
     att: any;
-    referrerUrl: any;
+    referrerUrl: string | undefined;
     onHarvestStarted(options: any): {
         qs: {
             ua: any;

package/dist/types/features/page_action/aggregate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/page_action/aggregate/index.js"],"names":[],"mappings":"AAgBA;IACE,2BAAiC;IACjC,mDA2BC;IAzBC,wBAA0B;IAC1B,wBAAsL;IACtL,yBAA2E;IAI3E,cAAgB;IAEhB,SAAqD;IAEZ,iBAA8C;IAiBzF;;;;;;;;MAkBC;IALG,wCAAgC;IAOpC,qCAKC;IAGD,wDAoCC;CACF;4BAlG2B,0BAA0B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/page_action/aggregate/index.js"],"names":[],"mappings":"AAgBA;IACE,2BAAiC;IACjC,mDA2BC;IAzBC,wBAA0B;IAC1B,wBAAsL;IACtL,yBAA2E;IAI3E,cAAgB;IAEhB,SAAqD;IAEZ,gCAA8C;IAiBzF;;;;;;;;MAkBC;IALG,wCAAgC;IAOpC,qCAKC;IAGD,wDAoCC;CACF;4BAlG2B,0BAA0B"}

package/dist/types/features/session_trace/aggregate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_trace/aggregate/index.js"],"names":[],"mappings":"AAkBA;IACE,2BAAiC;IACjC,mDAoHC;IA7GC,yBAAc;IACd;;;;;;;;;;;;kBAOC;IACD;;;;;kBAKC;IACD;;;;;;;;;;;;;;;;;;;;;;;;kBAwBC;IAED,sBAAe;IACf,8BAAkB;IAClB,iCAAqB;IACrB,wBAA0G;IAC1G,wBAA4G;IAE5G,8BAAkB;IAgEpB,oDAKC;IAED,2BAuBC;IAED,+DAaC;IAED,oFAmBC;IAED,wBAQC;IAED,uCAqBC;IAED,gDAUC;IAED,qCAoBC;IAED,qEAUC;IAED,mEAUC;IAED,yBASC;IAED,sCASC;IAED,yBAmCC;IAED,gCAEC;IAED,+DAyBC;IAED,+BAEC;IAED,6BAEC;IAED,uCAEC;IAED,4BAIC;IAED,oDAMC;CACF;4BA5Y2B,0BAA0B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/features/session_trace/aggregate/index.js"],"names":[],"mappings":"AAiBA;IACE,2BAAiC;IACjC,mDAoHC;IA7GC,yBAAc;IACd;;;;;;;;;;;;kBAOC;IACD;;;;;kBAKC;IACD;;;;;;;;;;;;;;;;;;;;;;;;kBAwBC;IAED,sBAAe;IACf,8BAAkB;IAClB,iCAAqB;IACrB,wBAA0G;IAC1G,wBAA4G;IAE5G,8BAAkB;IAgEpB,oDAKC;IAED,2BAuBC;IAED,+DAaC;IAED,oFAmBC;IAED,wBAQC;IAED,uCAqBC;IAED,gDAUC;IAED,qCAoBC;IAED,qEAUC;IAED,mEAUC;IAED,yBASC;IAED,sCASC;IAED,yBAmCC;IAED,gCAEC;IAED,+DAyBC;IAED,+BAEC;IAED,6BAEC;IAED,uCAEC;IAED,4BAIC;IAED,oDAMC;CACF;4BA5Y2B,0BAA0B"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newrelic/browser-agent",
-  "version": "1.232.0",
+  "version": "1.232.1",
   "private": false,
   "author": "New Relic Browser Agent Team <browser-agent@newrelic.com>",
   "description": "Tests for the New Relic JavaScript agent",
@@ -116,8 +116,8 @@
     "cdn:watch:extension": "jung -r ./src -F '.*\\.test\\.js' --run -- npm run cdn:build:extension",
     "cdn:webpack": "npx webpack --progress --config ./webpack.config.js",
     "packages:bundle": "webpack -c tools/jil/webpack.modular.js",
-    "test-server": "node ./tools/jil/bin/server",
-    "sauce:connect": "node ./tools/wdio/bin/sauce",
+    "test-server": "node ./tools/wdio/bin/server",
+    "sauce:connect": "node ./tools/saucelabs/bin.mjs",
     "sauce:get-browsers": "node ./tools/browsers-lists/sauce-browsers.mjs",
     "tools:test-builds": "npm --prefix ./tools/test-builds run build-all",
     "third-party-updates": "oss third-party manifest --includeOptDeps && oss third-party notices --includeOptDeps",
@@ -136,7 +136,6 @@
   },
   "dependencies": {
     "core-js": "^3.26.0",
-    "lodash._slice": "^2.4.1",
     "web-vitals": "^3.1.0"
   },
   "devDependencies": {
@@ -146,6 +145,7 @@
     "@babel/eslint-parser": "^7.19.1",
     "@babel/plugin-syntax-import-assertions": "^7.20.0",
     "@babel/preset-env": "^7.20.2",
+    "@babel/register": "^7.21.0",
     "@faker-js/faker": "^7.6.0",
     "@fastify/cors": "^8.2.0",
     "@fastify/multipart": "^7.3.0",

package/src/common/url/canonicalize-url.js

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2020 New Relic Corporation. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { initialLocation } from '../util/global-scope'
+import { cleanURL } from './clean-url'
+
+/**
+ * Converts a URL to its basic form without a query string or fragment. If the resulting URL is the same as the
+ * loader's origin URL, returns '<inline>'.
+ * @param {string} url - The URL to be canonicalized.
+ * @param {string} loaderOriginUrl - The origin URL of the agent loader, used for inline detection.
+ * @returns {string} The canonicalized URL, or '<inline>' if the URL matches the loader origin URL.
+ */
+export function canonicalizeUrl (url) {
+  if (typeof url !== 'string') return ''
+
+  const cleanedUrl = cleanURL(url)
+  const cleanedGlobalScopeUrl = cleanURL(initialLocation)
+
+  // If the URL matches the origin URL of the loader, we assume it originated within an inline script.
+  if (cleanedUrl === cleanedGlobalScopeUrl) {
+    return '<inline>'
+  } else {
+    return cleanedUrl
+  }
+}

package/src/common/url/canonicalize-url.test.js

@@ -0,0 +1,34 @@
+afterEach(() => {
+  jest.resetModules()
+})
+
+test.each([null, undefined, 34])('returns empty string when url argument is %s', async (url) => {
+  const { canonicalizeUrl } = await import('./canonicalize-url')
+  expect(canonicalizeUrl(url)).toEqual('')
+})
+
+test('strips URLs of query strings and fragments', async () => {
+  jest.doMock('../util/global-scope', () => ({
+    initialLocation: 'http://different-domain.com/'
+  }))
+  const { canonicalizeUrl } = await import('./canonicalize-url')
+  expect(canonicalizeUrl('http://example.com/path?query=string#fragment')).toBe('http://example.com/path')
+  expect(canonicalizeUrl('https://www.example.com/path/to/file.html?param=value')).toBe('https://www.example.com/path/to/file.html')
+  expect(canonicalizeUrl('https://www.example.com/?param=value#fragment')).toBe('https://www.example.com/')
+})
+
+test('returns <inline> when matching the page URL of the loader', async () => {
+  jest.doMock('../util/global-scope', () => ({
+    initialLocation: 'http://example.com/'
+  }))
+  const { canonicalizeUrl } = await import('./canonicalize-url')
+  expect(canonicalizeUrl('http://example.com/')).toEqual('<inline>')
+})
+
+test('does not identify sub-paths of the loader origin as <inline>', async () => {
+  jest.doMock('../util/global-scope', () => ({
+    initialLocation: 'http://example.com/'
+  }))
+  const { canonicalizeUrl } = await import('./canonicalize-url')
+  expect(canonicalizeUrl('http://example.com/path/to/script.js')).not.toEqual('<inline>')
+})

package/src/common/url/clean-url.js

@@ -3,8 +3,15 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-var withHash = /([^?#]*)[^#]*(#[^?]*|$).*/
-var withoutHash = /([^?#]*)().*/
+var patternWithHash = /([^?#]*)[^#]*(#[^?]*|$).*/
+var patternWithoutHash = /([^?#]*)().*/
+
+/**
+ * Cleans a URL by removing the query string and fragment (hash portion).
+ * @param {string} url - The original URL to be cleaned.
+ * @param {boolean} [keepHash=false] - Whether to preserve the hash portion of the URL.
+ * @returns {string} The cleaned URL.
+ */
 export function cleanURL (url, keepHash) {
-  return url.replace(keepHash ? withHash : withoutHash, '$1$2')
+  return url.replace(keepHash ? patternWithHash : patternWithoutHash, '$1$2')
 }

package/src/common/util/global-scope.js

@@ -20,6 +20,8 @@ export let globalScope = (() => {
   throw new Error('New Relic browser agent shutting down due to error: Unable to locate global scope. This is possibly due to code redefining browser global variables like "self" and "window".')
 })()
 
+export const initialLocation = '' + globalScope.location
+
 /**
  * The below methods are only used for testing and should be removed once the
  * reliant tests are moved to Jest.

package/src/common/wrap/wrap-fetch.js

@@ -7,7 +7,6 @@
  * This module is used by: ajax, spa.
  */
 import { ee as baseEE } from '../event-emitter/contextual-ee'
-import slice from 'lodash._slice'
 import { globalScope } from '../util/global-scope'
 import { flag } from './wrap-function'
 
@@ -71,7 +70,7 @@ export function wrapFetch (sharedEE) {
     var fn = target[name]
     if (typeof fn === 'function') {
       target[name] = function () {
-        var args = slice(arguments)
+        var args = Array.from(arguments)
 
         var ctx = {}
         // we are wrapping args in an array so we can preserve the reference

package/src/common/wrap/wrap-function.js

@@ -7,7 +7,6 @@
  */
 
 import { ee } from '../event-emitter/contextual-ee'
-import slice from 'lodash._slice'
 export const flag = 'nr@original'
 
 /**
@@ -77,7 +76,7 @@ export function createWrapperWithEmitter (emitter, always) {
 
       try {
         originalThis = this
-        args = slice(arguments)
+        args = Array.from(arguments)
 
         if (typeof getContext === 'function') {
           ctx = getContext(args, originalThis)

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

@@ -99,7 +99,7 @@ function subscribeToEvents (agentIdentifier, ee, handler, dt) {
 
   function onOpenXhrEnd (args, xhr) {
     var loader_config = getLoaderConfig(agentIdentifier)
-    if ('xpid' in loader_config && this.sameOrigin) {
+    if (loader_config.xpid && this.sameOrigin) {
       xhr.setRequestHeader('X-NewRelic-ID', loader_config.xpid)
     }
 

package/src/features/jserrors/aggregate/canonical-function-name.js

@@ -3,11 +3,19 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-var canonicalFunctionNameRe = /([a-z0-9]+)$/i
-export function canonicalFunctionName (orig) {
-  if (!orig) return
+const canonicalFunctionNameRe = /([a-z0-9]+)$/i
 
-  var match = orig.match(canonicalFunctionNameRe)
+/**
+ * Given a function name string, extracts only an alphanumeric segment at the end of the string (if one exists).
+ * This is useful for stack traces, where functions might not be named (e.g., anonymous, computed).
+ *
+ * @param {string} functionNameString - The original function name string.
+ * @returns {string|undefined} The canonical function name, or undefined if the input is falsy or no alphanumeric segments are found.
+ */
+export function canonicalFunctionName (functionNameString) {
+  if (!functionNameString) return
+
+  const match = functionNameString.match(canonicalFunctionNameRe)
   if (match) return match[1]
 
   return

package/src/features/jserrors/aggregate/compute-stack-trace.js

@@ -57,6 +57,7 @@
 // ex.message = ...
 // ex.name = ReferenceError
 import { formatStackTrace } from './format-stack-trace'
+import { canonicalizeUrl } from '../../../common/url/canonicalize-url'
 
 var debug = false
 
@@ -66,6 +67,23 @@ var gecko = /^\s*(?:(\S*|global code)(?:\(.*?\))?@)?((?:file|http|https|chrome|s
 var chrome_eval = /^\s*at .+ \(eval at \S+ \((?:(?:file|http|https):[^)]+)?\)(?:, [^:]*:\d+:\d+)?\)$/i
 var ie_eval = /^\s*at Function code \(Function code:\d+:\d+\)\s*/i
 
+/**
+ * Represents an error with a stack trace.
+ * @typedef {Object} StackInfo
+ * @property {string} name - The name of the error (e.g. 'TypeError').
+ * @property {string} message - The error message.
+ * @property {string} stackString - The stack trace as a string.
+ * @property {Array<Object>} frames - An array of frames in the stack trace.
+ * @property {string} frames.url - The URL of the file containing the code for the frame.
+ * @property {string} frames.func - The name of the function associated with the frame.
+ * @property {number} frames.line - The line number of the code in the frame.
+ */
+
+/**
+ * Attempts to compute a stack trace for the given exception.
+ * @param {Error} ex - The exception for which to compute the stack trace.
+ * @returns {StackInfo} A stack trace object containing information about the frames on the stack.
+ */
 export function computeStackTrace (ex) {
   var stack = null
 
@@ -110,9 +128,9 @@ export function computeStackTrace (ex) {
 }
 
 /**
- * Computes stack trace information from the stack property.
- * Chrome and Gecko use this property.
- * @param {Error} ex
+ * Computes stack trace information from the stack property. Chrome and Gecko use this property.
+ *
+ * @param {Error} ex - The error object to compute the stack trace for.
  * @return {?Object.<string, *>} Stack trace information.
  */
 function computeStackTraceFromStackProp (ex) {
@@ -136,22 +154,49 @@ function computeStackTraceFromStackProp (ex) {
   }
 }
 
+/**
+ * Parses a line from a JavaScript error stack trace and adds it to the given `info` object.
+ * Ignores all stack entries thrown from one of our wrapper functions.
+ *
+ * @param {object} info - The `info` object to add the parsed line to.
+ * @param {string} line - The line to parse.
+ * @returns {object} The `info` object with the parsed line added.
+ */
 function parseStackProp (info, line) {
-  var element = getElement(line)
+  let element = getStackElement(line)
 
+  // This catches lines that aren't frames (like the first line stating the error).
   if (!element) {
     info.stackLines.push(line)
     return info
   }
 
-  if (isWrapper(element.func)) info.wrapperSeen = true
-  else info.stackLines.push(line)
+  // Once we've seen a wrapper, ignore all subsequent stack entries.
+  if (isNrWrapper(element.func)) info.wrapperSeen = true
+  if (!info.wrapperSeen) {
+    // Query strings and fragments should be removed, and URLs matching the loader's origin should be "<inline>".
+    let canonicalUrl = canonicalizeUrl(element.url)
+    if (canonicalUrl !== element.url) {
+      line = line.replace(element.url, canonicalUrl)
+      element.url = canonicalUrl
+    }
+
+    info.stackLines.push(line)
+    info.frames.push(element)
+  }
 
-  if (!info.wrapperSeen) info.frames.push(element)
   return info
 }
 
-function getElement (line) {
+/**
+ * Parses a line from a JavaScript error stack trace to extract information about a stack trace element, such as the
+ * URL, function name, line number, and column number.
+ *
+ * @param {string} line - A single line from a JavaScript error stack trace.
+ * @returns {object} An object containing information about the stack trace element, including the URL, function
+ *     name, line number, and column number (if available).
+ */
+function getStackElement (line) {
   var parts = line.match(gecko)
   if (!parts) parts = line.match(chrome)
 
@@ -169,6 +214,14 @@ function getElement (line) {
   }
 }
 
+/**
+ * Computes a stack trace object from an error object, by extracting the source and line number from the error object,
+ * and using them to create a single stack frame.
+ *
+ * @param {Error} ex - The error object to compute the stack trace for.
+ * @returns {Object|null} - An object representing the computed stack trace, or null if the
+ * input error object does not contain a line number.
+ */
 function computeStackTraceBySourceAndLine (ex) {
   if (!('line' in ex)) return null
 
@@ -187,7 +240,10 @@ function computeStackTraceBySourceAndLine (ex) {
     })
   }
 
-  var stackString = className + ': ' + ex.message + '\n    at ' + ex.sourceURL
+  // Remove any query string and fragment
+  var canonicalUrl = canonicalizeUrl(ex.sourceURL)
+
+  var stackString = className + ': ' + ex.message + '\n    at ' + canonicalUrl
   if (ex.line) {
     stackString += ':' + ex.line
     if (ex.column) {
@@ -201,13 +257,19 @@ function computeStackTraceBySourceAndLine (ex) {
     message: ex.message,
     stackString: stackString,
     frames: [{
-      url: ex.sourceURL,
+      url: canonicalUrl,
       line: ex.line,
       column: ex.column
     }]
   })
 }
 
+/**
+ * For exceptions with no stack and only a message, derives a stack trace by extracting the class name and message.
+ *
+ * @param {Error} ex - The exception for which to compute the stack trace.
+ * @returns {StackTrace} A stack trace object containing the name and message of the exception.
+ */
 function computeStackTraceWithMessageOnly (ex) {
   var className = ex.name || getClassName(ex)
   if (!className) return null
@@ -221,11 +283,23 @@ function computeStackTraceWithMessageOnly (ex) {
   })
 }
 
+/**
+ * Attempts to extract the name of the constructor function (the class) of the given object.
+ *
+ * @param {Object} obj - The object for which to extract the constructor function name.
+ * @returns {string} The name of the constructor function, or 'unknown' if the name cannot be determined.
+ */
 function getClassName (obj) {
   var results = classNameRegex.exec(String(obj.constructor))
   return (results && results.length > 1) ? results[1] : 'unknown'
 }
 
-function isWrapper (functionName) {
+/**
+ * Checks whether the given function name is a New Relic wrapper function.
+ *
+ * @param {string} functionName - The name of the function to check.
+ * @returns {boolean} True if the function name includes the string 'nrWrapper', false otherwise.
+ */
+function isNrWrapper (functionName) {
   return (functionName && functionName.indexOf('nrWrapper') >= 0)
 }