@sentry/browser 6.17.6 → 6.17.9

package/build/bundle.es6.js

@@ -1,8 +1,10 @@
-/*! @sentry/browser 6.17.6 (4b4faec) | https://github.com/getsentry/sentry-javascript */
+/*! @sentry/browser 6.17.9 (4ef06bf) | https://github.com/getsentry/sentry-javascript */
 var Sentry = (function (exports) {
+
   /**
    * TODO(v7): Remove this enum and replace with SeverityLevel
    */
+  exports.Severity = void 0;
   (function (Severity) {
       /** JSDoc */
       Severity["Fatal"] = "fatal";
@@ -49,41 +51,7 @@ var Sentry = (function (exports) {
    * @returns true if this is a debug build
    */
   function isDebugBuild() {
-      return typeof __SENTRY_NO_DEBUG__ !== 'undefined' && !__SENTRY_BROWSER_BUNDLE__;
-  }
-  /**
-   * Figures out if we're building a browser bundle.
-   *
-   * @returns true if this is a browser bundle build.
-   */
-  function isBrowserBundle() {
-      return typeof __SENTRY_BROWSER_BUNDLE__ !== 'undefined' && !!__SENTRY_BROWSER_BUNDLE__;
-  }
-
-  /**
-   * NOTE: In order to avoid circular dependencies, if you add a function to this module and it needs to print something,
-   * you must either a) use `console.log` rather than the logger, or b) put your function elsewhere.
-   */
-  /**
-   * Checks whether we're in the Node.js or Browser environment
-   *
-   * @returns Answer to given question
-   */
-  function isNodeEnv() {
-      // explicitly check for browser bundles as those can be optimized statically
-      // by terser/rollup.
-      return (!isBrowserBundle() &&
-          Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]');
-  }
-  /**
-   * Requires a module which is protected against bundler minification.
-   *
-   * @param request The module path to resolve
-   */
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
-  function dynamicRequire(mod, request) {
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-      return mod.require(request);
+      return typeof __SENTRY_NO_DEBUG__ !== 'undefined' && !true;
   }
 
   /**
@@ -97,9 +65,7 @@ var Sentry = (function (exports) {
    * @returns Global scope object
    */
   function getGlobalObject() {
-      return (isNodeEnv()
-          ? global
-          : typeof window !== 'undefined' // eslint-disable-line no-restricted-globals
+      return (typeof window !== 'undefined' // eslint-disable-line no-restricted-globals
               ? window // eslint-disable-line no-restricted-globals
               : typeof self !== 'undefined'
                   ? self
@@ -480,7 +446,7 @@ var Sentry = (function (exports) {
   const SeverityLevels = ['fatal', 'error', 'warning', 'log', 'info', 'debug', 'critical'];
 
   // TODO: Implement different loggers for different environments
-  const global$1 = getGlobalObject();
+  const global$6 = getGlobalObject();
   /** Prefix for logging strings */
   const PREFIX = 'Sentry Logger ';
   /**
@@ -535,7 +501,7 @@ var Sentry = (function (exports) {
               return;
           }
           consoleSandbox(() => {
-              global$1.console.log(`${PREFIX}[Log]: ${args.join(' ')}`);
+              global$6.console.log(`${PREFIX}[Log]: ${args.join(' ')}`);
           });
       }
       /** JSDoc */
@@ -544,7 +510,7 @@ var Sentry = (function (exports) {
               return;
           }
           consoleSandbox(() => {
-              global$1.console.warn(`${PREFIX}[Warn]: ${args.join(' ')}`);
+              global$6.console.warn(`${PREFIX}[Warn]: ${args.join(' ')}`);
           });
       }
       /** JSDoc */
@@ -553,13 +519,13 @@ var Sentry = (function (exports) {
               return;
           }
           consoleSandbox(() => {
-              global$1.console.error(`${PREFIX}[Error]: ${args.join(' ')}`);
+              global$6.console.error(`${PREFIX}[Error]: ${args.join(' ')}`);
           });
       }
   }
   // Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used
-  global$1.__SENTRY__ = global$1.__SENTRY__ || {};
-  const logger = global$1.__SENTRY__.logger || (global$1.__SENTRY__.logger = new Logger());
+  global$6.__SENTRY__ = global$6.__SENTRY__ || {};
+  const logger = global$6.__SENTRY__.logger || (global$6.__SENTRY__.logger = new Logger());
 
   /* eslint-disable @typescript-eslint/no-unsafe-member-access */
   /* eslint-disable @typescript-eslint/no-explicit-any */
@@ -603,6 +569,53 @@ var Sentry = (function (exports) {
       return [memoize, unmemoize];
   }
 
+  const STACKTRACE_LIMIT = 50;
+  /**
+   * Creates a stack parser with the supplied line parsers
+   *
+   * StackFrames are returned in the correct order for Sentry Exception
+   * frames and with Sentry SDK internal frames removed from the top and bottom
+   *
+   * */
+  function createStackParser(...parsers) {
+      return (stack, skipFirst = 0) => {
+          const frames = [];
+          for (const line of stack.split('\n').slice(skipFirst)) {
+              for (const parser of parsers) {
+                  const frame = parser(line);
+                  if (frame) {
+                      frames.push(frame);
+                      break;
+                  }
+              }
+          }
+          return stripSentryFramesAndReverse(frames);
+      };
+  }
+  /**
+   * @hidden
+   */
+  function stripSentryFramesAndReverse(stack) {
+      if (!stack.length) {
+          return [];
+      }
+      let localStack = stack;
+      const firstFrameFunction = localStack[0].function || '';
+      const lastFrameFunction = localStack[localStack.length - 1].function || '';
+      // If stack starts with one of our API calls, remove it (starts, meaning it's the top of the stack - aka last call)
+      if (firstFrameFunction.indexOf('captureMessage') !== -1 || firstFrameFunction.indexOf('captureException') !== -1) {
+          localStack = localStack.slice(1);
+      }
+      // If stack ends with one of our internal API calls, remove it (ends, meaning it's the bottom of the stack - aka top-most call)
+      if (lastFrameFunction.indexOf('sentryWrapped') !== -1) {
+          localStack = localStack.slice(0, -1);
+      }
+      // The frame where the crash happened, should be the last entry in the array
+      return localStack
+          .slice(0, STACKTRACE_LIMIT)
+          .map(frame => (Object.assign(Object.assign({}, frame), { filename: frame.filename || localStack[0].filename, function: frame.function || '?' })))
+          .reverse();
+  }
   const defaultFunctionName = '<anonymous>';
   /**
    * Safely extract function name from itself
@@ -707,16 +720,18 @@ var Sentry = (function (exports) {
       source[name] = wrapped;
   }
   /**
-   * Defines a non enumerable property.  This creates a non enumerable property on an object.
+   * Defines a non-enumerable property on the given object.
    *
-   * @param func The function to set a property to
-   * @param name the name of the special sentry property
-   * @param value the property to define
+   * @param obj The object on which to set the property
+   * @param name The name of the property to be set
+   * @param value The value to which to set the property
    */
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-  function addNonEnumerableProperty(func, name, value) {
-      Object.defineProperty(func, name, {
+  function addNonEnumerableProperty(obj, name, value) {
+      Object.defineProperty(obj, name, {
+          // enumerable: false, // the default, so we can save on bundle size by not explicitly setting it
           value: value,
+          writable: true,
+          configurable: true,
       });
   }
   /**
@@ -1132,7 +1147,7 @@ var Sentry = (function (exports) {
       return !isChromePackagedApp && hasHistoryApi;
   }
 
-  const global$2 = getGlobalObject();
+  const global$5 = getGlobalObject();
   /**
    * Instrument native APIs to call handlers that can be used to create breadcrumbs, APM spans etc.
    *  - Console API
@@ -1205,19 +1220,19 @@ var Sentry = (function (exports) {
   }
   /** JSDoc */
   function instrumentConsole() {
-      if (!('console' in global$2)) {
+      if (!('console' in global$5)) {
           return;
       }
       ['debug', 'info', 'warn', 'error', 'log', 'assert'].forEach(function (level) {
-          if (!(level in global$2.console)) {
+          if (!(level in global$5.console)) {
               return;
           }
-          fill(global$2.console, level, function (originalConsoleLevel) {
+          fill(global$5.console, level, function (originalConsoleMethod) {
               return function (...args) {
                   triggerHandlers('console', { args, level });
                   // this fails for some browsers. :(
-                  if (originalConsoleLevel) {
-                      Function.prototype.apply.call(originalConsoleLevel, global$2.console, args);
+                  if (originalConsoleMethod) {
+                      originalConsoleMethod.apply(global$5.console, args);
                   }
               };
           });
@@ -1228,7 +1243,7 @@ var Sentry = (function (exports) {
       if (!supportsNativeFetch()) {
           return;
       }
-      fill(global$2, 'fetch', function (originalFetch) {
+      fill(global$5, 'fetch', function (originalFetch) {
           return function (...args) {
               const handlerData = {
                   args,
@@ -1240,7 +1255,7 @@ var Sentry = (function (exports) {
               };
               triggerHandlers('fetch', Object.assign({}, handlerData));
               // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-              return originalFetch.apply(global$2, args).then((response) => {
+              return originalFetch.apply(global$5, args).then((response) => {
                   triggerHandlers('fetch', Object.assign(Object.assign({}, handlerData), { endTimestamp: Date.now(), response }));
                   return response;
               }, (error) => {
@@ -1256,7 +1271,7 @@ var Sentry = (function (exports) {
   /* eslint-disable @typescript-eslint/no-unsafe-member-access */
   /** Extract `method` from fetch call arguments */
   function getFetchMethod(fetchArgs = []) {
-      if ('Request' in global$2 && isInstanceOf(fetchArgs[0], Request) && fetchArgs[0].method) {
+      if ('Request' in global$5 && isInstanceOf(fetchArgs[0], Request) && fetchArgs[0].method) {
           return String(fetchArgs[0].method).toUpperCase();
       }
       if (fetchArgs[1] && fetchArgs[1].method) {
@@ -1269,7 +1284,7 @@ var Sentry = (function (exports) {
       if (typeof fetchArgs[0] === 'string') {
           return fetchArgs[0];
       }
-      if ('Request' in global$2 && isInstanceOf(fetchArgs[0], Request)) {
+      if ('Request' in global$5 && isInstanceOf(fetchArgs[0], Request)) {
           return fetchArgs[0].url;
       }
       return String(fetchArgs[0]);
@@ -1277,7 +1292,7 @@ var Sentry = (function (exports) {
   /* eslint-enable @typescript-eslint/no-unsafe-member-access */
   /** JSDoc */
   function instrumentXHR() {
-      if (!('XMLHttpRequest' in global$2)) {
+      if (!('XMLHttpRequest' in global$5)) {
           return;
       }
       const xhrproto = XMLHttpRequest.prototype;
@@ -1348,9 +1363,9 @@ var Sentry = (function (exports) {
       if (!supportsHistory()) {
           return;
       }
-      const oldOnPopState = global$2.onpopstate;
-      global$2.onpopstate = function (...args) {
-          const to = global$2.location.href;
+      const oldOnPopState = global$5.onpopstate;
+      global$5.onpopstate = function (...args) {
+          const to = global$5.location.href;
           // keep track of the current URL state, as we always receive only the updated state
           const from = lastHref;
           lastHref = to;
@@ -1388,8 +1403,8 @@ var Sentry = (function (exports) {
               return originalHistoryFunction.apply(this, args);
           };
       }
-      fill(global$2.history, 'pushState', historyReplacementFunction);
-      fill(global$2.history, 'replaceState', historyReplacementFunction);
+      fill(global$5.history, 'pushState', historyReplacementFunction);
+      fill(global$5.history, 'replaceState', historyReplacementFunction);
   }
   const debounceDuration = 1000;
   let debounceTimerID;
@@ -1491,14 +1506,14 @@ var Sentry = (function (exports) {
           }
           // Start a new debounce timer that will prevent us from capturing multiple events that should be grouped together.
           clearTimeout(debounceTimerID);
-          debounceTimerID = global$2.setTimeout(() => {
+          debounceTimerID = global$5.setTimeout(() => {
               debounceTimerID = undefined;
           }, debounceDuration);
       };
   }
   /** JSDoc */
   function instrumentDOM() {
-      if (!('document' in global$2)) {
+      if (!('document' in global$5)) {
           return;
       }
       // Make it so that any click or keypress that is unhandled / bubbled up all the way to the document triggers our dom
@@ -1506,8 +1521,8 @@ var Sentry = (function (exports) {
       // we instrument `addEventListener` so that we don't end up attaching this handler twice.
       const triggerDOMHandler = triggerHandlers.bind(null, 'dom');
       const globalDOMEventHandler = makeDOMEventHandler(triggerDOMHandler, true);
-      global$2.document.addEventListener('click', globalDOMEventHandler, false);
-      global$2.document.addEventListener('keypress', globalDOMEventHandler, false);
+      global$5.document.addEventListener('click', globalDOMEventHandler, false);
+      global$5.document.addEventListener('keypress', globalDOMEventHandler, false);
       // After hooking into click and keypress events bubbled up to `document`, we also hook into user-handled
       // clicks & keypresses, by adding an event listener of our own to any element to which they add a listener. That
       // way, whenever one of their handlers is triggered, ours will be, too. (This is needed because their handler
@@ -1515,7 +1530,7 @@ var Sentry = (function (exports) {
       // guaranteed to fire at least once.)
       ['EventTarget', 'Node'].forEach((target) => {
           // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-          const proto = global$2[target] && global$2[target].prototype;
+          const proto = global$5[target] && global$5[target].prototype;
           // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-prototype-builtins
           if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {
               return;
@@ -1576,8 +1591,8 @@ var Sentry = (function (exports) {
   let _oldOnErrorHandler = null;
   /** JSDoc */
   function instrumentError() {
-      _oldOnErrorHandler = global$2.onerror;
-      global$2.onerror = function (msg, url, line, column, error) {
+      _oldOnErrorHandler = global$5.onerror;
+      global$5.onerror = function (msg, url, line, column, error) {
           triggerHandlers('error', {
               column,
               error,
@@ -1595,8 +1610,8 @@ var Sentry = (function (exports) {
   let _oldOnUnhandledRejectionHandler = null;
   /** JSDoc */
   function instrumentUnhandledRejection() {
-      _oldOnUnhandledRejectionHandler = global$2.onunhandledrejection;
-      global$2.onunhandledrejection = function (e) {
+      _oldOnUnhandledRejectionHandler = global$5.onunhandledrejection;
+      global$5.onunhandledrejection = function (e) {
           triggerHandlers('unhandledrejection', e);
           if (_oldOnUnhandledRejectionHandler) {
               // eslint-disable-next-line prefer-rest-params
@@ -2107,23 +2122,10 @@ var Sentry = (function (exports) {
           timeOrigin,
       };
   }
-  /**
-   * Returns the native Performance API implementation from Node.js. Returns undefined in old Node.js versions that don't
-   * implement the API.
-   */
-  function getNodePerformance() {
-      try {
-          const perfHooks = dynamicRequire(module, 'perf_hooks');
-          return perfHooks.performance;
-      }
-      catch (_) {
-          return undefined;
-      }
-  }
   /**
    * The Performance API implementation for the current platform, if available.
    */
-  const platformPerformance = isNodeEnv() ? getNodePerformance() : getBrowserPerformance();
+  const platformPerformance = getBrowserPerformance();
   const timestampSource = platformPerformance === undefined
       ? dateTimestampSource
       : {
@@ -2149,7 +2151,7 @@ var Sentry = (function (exports) {
    * The number of milliseconds since the UNIX epoch. This value is only usable in a browser, and only when the
    * performance API is available.
    */
-  const browserPerformanceTimeOrigin = (() => {
+  (() => {
       // Unfortunately browsers may report an inaccurate time origin data, through either performance.timeOrigin or
       // performance.timing.navigationStart, which results in poor results in performance data. We only treat time origin
       // data as reliable if they are within a reasonable threshold of the current time.
@@ -3160,38 +3162,9 @@ var Sentry = (function (exports) {
       if (!hasHubOnCarrier(registry) || getHubFromCarrier(registry).isOlderThan(API_VERSION)) {
           setHubOnCarrier(registry, new Hub());
       }
-      // Prefer domains over global if they are there (applicable only to Node environment)
-      if (isNodeEnv()) {
-          return getHubFromActiveDomain(registry);
-      }
       // Return hub that lives on a global object
       return getHubFromCarrier(registry);
   }
-  /**
-   * Try to read the hub from an active domain, and fallback to the registry if one doesn't exist
-   * @returns discovered hub
-   */
-  function getHubFromActiveDomain(registry) {
-      try {
-          const sentry = getMainCarrier().__SENTRY__;
-          const activeDomain = sentry && sentry.extensions && sentry.extensions.domain && sentry.extensions.domain.active;
-          // If there's no active domain, just return global hub
-          if (!activeDomain) {
-              return getHubFromCarrier(registry);
-          }
-          // If there's no hub on current domain, or it's an old API, assign a new one
-          if (!hasHubOnCarrier(activeDomain) || getHubFromCarrier(activeDomain).isOlderThan(API_VERSION)) {
-              const registryHubTopStack = getHubFromCarrier(registry).getStackTop();
-              setHubOnCarrier(activeDomain, new Hub(registryHubTopStack.client, Scope.clone(registryHubTopStack.scope)));
-          }
-          // Return hub that lives on a domain
-          return getHubFromCarrier(activeDomain);
-      }
-      catch (_Oo) {
-          // Return hub that lives on a global object
-          return getHubFromCarrier(registry);
-      }
-  }
   /**
    * This will tell whether a carrier has a hub on it or not
    * @param carrier object
@@ -3820,6 +3793,11 @@ var Sentry = (function (exports) {
               result = finalScope.applyToEvent(prepared, hint);
           }
           return result.then(evt => {
+              if (evt) {
+                  // TODO this is more of the hack trying to solve https://github.com/getsentry/sentry-javascript/issues/2809
+                  // it is only attached as extra data to the event if the event somehow skips being normalized
+                  evt.sdkProcessingMetadata = Object.assign(Object.assign({}, evt.sdkProcessingMetadata), { normalizeDepth: normalize(normalizeDepth) });
+              }
               if (typeof normalizeDepth === 'number' && normalizeDepth > 0) {
                   return this._normalizeEvent(evt, normalizeDepth);
               }
@@ -4164,22 +4142,27 @@ var Sentry = (function (exports) {
       const { transactionSampling } = event.sdkProcessingMetadata || {};
       const { method: samplingMethod, rate: sampleRate } = transactionSampling || {};
       // TODO: Below is a temporary hack in order to debug a serialization error - see
-      // https://github.com/getsentry/sentry-javascript/issues/2809 and
-      // https://github.com/getsentry/sentry-javascript/pull/4425. TL;DR: even though we normalize all events (which should
-      // prevent this), something is causing `JSON.stringify` to throw a circular reference error.
+      // https://github.com/getsentry/sentry-javascript/issues/2809,
+      // https://github.com/getsentry/sentry-javascript/pull/4425, and
+      // https://github.com/getsentry/sentry-javascript/pull/4574.
+      //
+      // TL; DR: even though we normalize all events (which should prevent this), something is causing `JSON.stringify` to
+      // throw a circular reference error.
       //
       // When it's time to remove it:
       // 1. Delete everything between here and where the request object `req` is created, EXCEPT the line deleting
       //    `sdkProcessingMetadata`
       // 2. Restore the original version of the request body, which is commented out
-      // 3. Search for `skippedNormalization` and pull out the companion hack in the browser playwright tests
+      // 3. Search for either of the PR URLs above and pull out the companion hacks in the browser playwright tests and the
+      //    baseClient tests in this package
       enhanceEventWithSdkInfo(event, api.metadata.sdk);
       event.tags = event.tags || {};
       event.extra = event.extra || {};
       // In theory, all events should be marked as having gone through normalization and so
-      // we should never set this tag
+      // we should never set this tag/extra data
       if (!(event.sdkProcessingMetadata && event.sdkProcessingMetadata.baseClientNormalized)) {
           event.tags.skippedNormalization = true;
+          event.extra.normalizeDepth = event.sdkProcessingMetadata ? event.sdkProcessingMetadata.normalizeDepth : 'unset';
       }
       // prevent this data from being sent to sentry
       // TODO: This is NOT part of the hack - DO NOT DELETE
@@ -4261,7 +4244,7 @@ var Sentry = (function (exports) {
       hub.bindClient(client);
   }
 
-  const SDK_VERSION = '6.17.6';
+  const SDK_VERSION = '6.17.9';
 
   let originalFunctionToString;
   /** Patch toString calls to return proper name for wrapped functions */
@@ -4484,213 +4467,95 @@ var Sentry = (function (exports) {
    */
   InboundFilters.id = 'InboundFilters';
 
-
-
   var CoreIntegrations = /*#__PURE__*/Object.freeze({
     __proto__: null,
     FunctionToString: FunctionToString,
     InboundFilters: InboundFilters
   });
 
-  /**
-   * This was originally forked from https://github.com/occ/TraceKit, but has since been
-   * largely modified and is now maintained as part of Sentry JS SDK.
-   */
   // global reference to slice
   const UNKNOWN_FUNCTION = '?';
-  // Chromium based browsers: Chrome, Brave, new Opera, new Edge
-  const chrome = /^\s*at (?:(.*?) ?\()?((?:file|https?|blob|chrome-extension|address|native|eval|webpack|<anonymous>|[-a-z]+:|.*bundle|\/).*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i;
-  // gecko regex: `(?:bundle|\d+\.js)`: `bundle` is for react native, `\d+\.js` also but specifically for ram bundles because it
-  // generates filenames without a prefix like `file://` the filenames in the stacktrace are just 42.js
-  // We need this specific case for now because we want no other regex to match.
-  const gecko = /^\s*(.*?)(?:\((.*?)\))?(?:^|@)?((?:file|https?|blob|chrome|webpack|resource|moz-extension|capacitor).*?:\/.*?|\[native code\]|[^@]*(?:bundle|\d+\.js)|\/[\w\-. /=]+)(?::(\d+))?(?::(\d+))?\s*$/i;
-  const winjs = /^\s*at (?:((?:\[object object\])?.+) )?\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\d+)(?::(\d+))?\)?\s*$/i;
-  const geckoEval = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i;
-  const chromeEval = /\((\S*)(?::(\d+))(?::(\d+))\)/;
-  // Based on our own mapping pattern - https://github.com/getsentry/sentry/blob/9f08305e09866c8bd6d0c24f5b0aabdd7dd6c59c/src/sentry/lang/javascript/errormapping.py#L83-L108
-  const reactMinifiedRegexp = /Minified React error #\d+;/i;
-  /** JSDoc */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
-  function computeStackTrace(ex) {
-      let stack = null;
-      let popSize = 0;
-      if (ex) {
-          if (typeof ex.framesToPop === 'number') {
-              popSize = ex.framesToPop;
-          }
-          else if (reactMinifiedRegexp.test(ex.message)) {
-              popSize = 1;
-          }
-      }
-      try {
-          // This must be tried first because Opera 10 *destroys*
-          // its stacktrace property if you try to access the stack
-          // property first!!
-          stack = computeStackTraceFromStacktraceProp(ex);
-          if (stack) {
-              return popFrames(stack, popSize);
-          }
-      }
-      catch (e) {
-          // no-empty
-      }
-      try {
-          stack = computeStackTraceFromStackProp(ex);
-          if (stack) {
-              return popFrames(stack, popSize);
-          }
+  function createFrame(filename, func, lineno, colno) {
+      const frame = {
+          filename,
+          function: func,
+          // All browser frames are considered in_app
+          in_app: true,
+      };
+      if (lineno !== undefined) {
+          frame.lineno = lineno;
       }
-      catch (e) {
-          // no-empty
+      if (colno !== undefined) {
+          frame.colno = colno;
       }
-      return {
-          message: extractMessage(ex),
-          name: ex && ex.name,
-          stack: [],
-          failed: true,
-      };
+      return frame;
   }
-  /** JSDoc */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any, complexity
-  function computeStackTraceFromStackProp(ex) {
-      if (!ex || !ex.stack) {
-          return null;
-      }
-      const stack = [];
-      const lines = ex.stack.split('\n');
-      let isEval;
-      let submatch;
-      let parts;
-      let element;
-      for (let i = 0; i < lines.length; ++i) {
-          if ((parts = chrome.exec(lines[i]))) {
-              const isNative = parts[2] && parts[2].indexOf('native') === 0; // start of line
-              isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line
-              if (isEval && (submatch = chromeEval.exec(parts[2]))) {
+  // Chromium based browsers: Chrome, Brave, new Opera, new Edge
+  const chromeRegex = /^\s*at (?:(.*?) ?\((?:address at )?)?((?:file|https?|blob|chrome-extension|address|native|eval|webpack|<anonymous>|[-a-z]+:|.*bundle|\/).*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i;
+  const chromeEvalRegex = /\((\S*)(?::(\d+))(?::(\d+))\)/;
+  const chrome = line => {
+      const parts = chromeRegex.exec(line);
+      if (parts) {
+          const isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line
+          if (isEval) {
+              const subMatch = chromeEvalRegex.exec(parts[2]);
+              if (subMatch) {
                   // throw out eval line/column and use top-most line/column number
-                  parts[2] = submatch[1]; // url
-                  parts[3] = submatch[2]; // line
-                  parts[4] = submatch[3]; // column
+                  parts[2] = subMatch[1]; // url
+                  parts[3] = subMatch[2]; // line
+                  parts[4] = subMatch[3]; // column
               }
-              // Arpad: Working with the regexp above is super painful. it is quite a hack, but just stripping the `address at `
-              // prefix here seems like the quickest solution for now.
-              let url = parts[2] && parts[2].indexOf('address at ') === 0 ? parts[2].substr('address at '.length) : parts[2];
-              // Kamil: One more hack won't hurt us right? Understanding and adding more rules on top of these regexps right now
-              // would be way too time consuming. (TODO: Rewrite whole RegExp to be more readable)
-              let func = parts[1] || UNKNOWN_FUNCTION;
-              [func, url] = extractSafariExtensionDetails(func, url);
-              element = {
-                  url,
-                  func,
-                  args: isNative ? [parts[2]] : [],
-                  line: parts[3] ? +parts[3] : null,
-                  column: parts[4] ? +parts[4] : null,
-              };
-          }
-          else if ((parts = winjs.exec(lines[i]))) {
-              element = {
-                  url: parts[2],
-                  func: parts[1] || UNKNOWN_FUNCTION,
-                  args: [],
-                  line: +parts[3],
-                  column: parts[4] ? +parts[4] : null,
-              };
           }
-          else if ((parts = gecko.exec(lines[i]))) {
-              isEval = parts[3] && parts[3].indexOf(' > eval') > -1;
-              if (isEval && (submatch = geckoEval.exec(parts[3]))) {
+          // Kamil: One more hack won't hurt us right? Understanding and adding more rules on top of these regexps right now
+          // would be way too time consuming. (TODO: Rewrite whole RegExp to be more readable)
+          const [func, filename] = extractSafariExtensionDetails(parts[1] || UNKNOWN_FUNCTION, parts[2]);
+          return createFrame(filename, func, parts[3] ? +parts[3] : undefined, parts[4] ? +parts[4] : undefined);
+      }
+      return;
+  };
+  // gecko regex: `(?:bundle|\d+\.js)`: `bundle` is for react native, `\d+\.js` also but specifically for ram bundles because it
+  // generates filenames without a prefix like `file://` the filenames in the stacktrace are just 42.js
+  // We need this specific case for now because we want no other regex to match.
+  const geckoREgex = /^\s*(.*?)(?:\((.*?)\))?(?:^|@)?((?:file|https?|blob|chrome|webpack|resource|moz-extension|capacitor).*?:\/.*?|\[native code\]|[^@]*(?:bundle|\d+\.js)|\/[\w\-. /=]+)(?::(\d+))?(?::(\d+))?\s*$/i;
+  const geckoEvalRegex = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i;
+  const gecko = line => {
+      const parts = geckoREgex.exec(line);
+      if (parts) {
+          const isEval = parts[3] && parts[3].indexOf(' > eval') > -1;
+          if (isEval) {
+              const subMatch = geckoEvalRegex.exec(parts[3]);
+              if (subMatch) {
                   // throw out eval line/column and use top-most line number
                   parts[1] = parts[1] || `eval`;
-                  parts[3] = submatch[1];
-                  parts[4] = submatch[2];
+                  parts[3] = subMatch[1];
+                  parts[4] = subMatch[2];
                   parts[5] = ''; // no column when eval
               }
-              else if (i === 0 && !parts[5] && ex.columnNumber !== void 0) {
-                  // FireFox uses this awesome columnNumber property for its top frame
-                  // Also note, Firefox's column number is 0-based and everything else expects 1-based,
-                  // so adding 1
-                  // NOTE: this hack doesn't work if top-most frame is eval
-                  stack[0].column = ex.columnNumber + 1;
-              }
-              let url = parts[3];
-              let func = parts[1] || UNKNOWN_FUNCTION;
-              [func, url] = extractSafariExtensionDetails(func, url);
-              element = {
-                  url,
-                  func,
-                  args: parts[2] ? parts[2].split(',') : [],
-                  line: parts[4] ? +parts[4] : null,
-                  column: parts[5] ? +parts[5] : null,
-              };
-          }
-          else {
-              continue;
-          }
-          if (!element.func && element.line) {
-              element.func = UNKNOWN_FUNCTION;
           }
-          stack.push(element);
-      }
-      if (!stack.length) {
-          return null;
-      }
-      return {
-          message: extractMessage(ex),
-          name: ex.name,
-          stack,
-      };
-  }
-  /** JSDoc */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  function computeStackTraceFromStacktraceProp(ex) {
-      if (!ex || !ex.stacktrace) {
-          return null;
-      }
-      // Access and store the stacktrace property before doing ANYTHING
-      // else to it because Opera is not very good at providing it
-      // reliably in other circumstances.
-      const stacktrace = ex.stacktrace;
-      const opera10Regex = / line (\d+).*script (?:in )?(\S+)(?:: in function (\S+))?$/i;
-      const opera11Regex = / line (\d+), column (\d+)\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\((.*)\))? in (.*):\s*$/i;
-      const lines = stacktrace.split('\n');
-      const stack = [];
-      let parts;
-      for (let line = 0; line < lines.length; line += 2) {
-          let element = null;
-          if ((parts = opera10Regex.exec(lines[line]))) {
-              element = {
-                  url: parts[2],
-                  func: parts[3],
-                  args: [],
-                  line: +parts[1],
-                  column: null,
-              };
-          }
-          else if ((parts = opera11Regex.exec(lines[line]))) {
-              element = {
-                  url: parts[6],
-                  func: parts[3] || parts[4],
-                  args: parts[5] ? parts[5].split(',') : [],
-                  line: +parts[1],
-                  column: +parts[2],
-              };
-          }
-          if (element) {
-              if (!element.func && element.line) {
-                  element.func = UNKNOWN_FUNCTION;
-              }
-              stack.push(element);
-          }
-      }
-      if (!stack.length) {
-          return null;
+          let filename = parts[3];
+          let func = parts[1] || UNKNOWN_FUNCTION;
+          [func, filename] = extractSafariExtensionDetails(func, filename);
+          return createFrame(filename, func, parts[4] ? +parts[4] : undefined, parts[5] ? +parts[5] : undefined);
       }
-      return {
-          message: extractMessage(ex),
-          name: ex.name,
-          stack,
-      };
-  }
+      return;
+  };
+  const winjsRegex = /^\s*at (?:((?:\[object object\])?.+) )?\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\d+)(?::(\d+))?\)?\s*$/i;
+  const winjs = line => {
+      const parts = winjsRegex.exec(line);
+      return parts
+          ? createFrame(parts[2], parts[1] || UNKNOWN_FUNCTION, +parts[3], parts[4] ? +parts[4] : undefined)
+          : undefined;
+  };
+  const opera10Regex = / line (\d+).*script (?:in )?(\S+)(?:: in function (\S+))?$/i;
+  const opera10 = line => {
+      const parts = opera10Regex.exec(line);
+      return parts ? createFrame(parts[2], parts[3] || UNKNOWN_FUNCTION, +parts[1]) : undefined;
+  };
+  const opera11Regex = / line (\d+), column (\d+)\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\(.*\))? in (.*):\s*$/i;
+  const opera11 = line => {
+      const parts = opera11Regex.exec(line);
+      return parts ? createFrame(parts[5], parts[3] || parts[4] || UNKNOWN_FUNCTION, +parts[1], +parts[2]) : undefined;
+  };
   /**
    * Safari web extensions, starting version unknown, can produce "frames-only" stacktraces.
    * What it means, is that instead of format like:
@@ -4708,56 +4573,31 @@ var Sentry = (function (exports) {
    *
    * Because of that, it won't be captured by `chrome` RegExp and will fall into `Gecko` branch.
    * This function is extracted so that we can use it in both places without duplicating the logic.
-   * Unfortunatelly "just" changing RegExp is too complicated now and making it pass all tests
+   * Unfortunately "just" changing RegExp is too complicated now and making it pass all tests
    * and fix this case seems like an impossible, or at least way too time-consuming task.
    */
-  const extractSafariExtensionDetails = (func, url) => {
+  const extractSafariExtensionDetails = (func, filename) => {
       const isSafariExtension = func.indexOf('safari-extension') !== -1;
       const isSafariWebExtension = func.indexOf('safari-web-extension') !== -1;
       return isSafariExtension || isSafariWebExtension
           ? [
               func.indexOf('@') !== -1 ? func.split('@')[0] : UNKNOWN_FUNCTION,
-              isSafariExtension ? `safari-extension:${url}` : `safari-web-extension:${url}`,
+              isSafariExtension ? `safari-extension:${filename}` : `safari-web-extension:${filename}`,
           ]
-          : [func, url];
-  };
-  /** Remove N number of frames from the stack */
-  function popFrames(stacktrace, popSize) {
-      try {
-          return Object.assign(Object.assign({}, stacktrace), { stack: stacktrace.stack.slice(popSize) });
-      }
-      catch (e) {
-          return stacktrace;
-      }
-  }
-  /**
-   * There are cases where stacktrace.message is an Event object
-   * https://github.com/getsentry/sentry-javascript/issues/1949
-   * In this specific case we try to extract stacktrace.message.error.message
-   */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  function extractMessage(ex) {
-      const message = ex && ex.message;
-      if (!message) {
-          return 'No error message';
-      }
-      if (message.error && typeof message.error.message === 'string') {
-          return message.error.message;
-      }
-      return message;
-  }
+          : [func, filename];
+  };
 
-  const STACKTRACE_LIMIT = 50;
   /**
    * This function creates an exception from an TraceKitStackTrace
    * @param stacktrace TraceKitStackTrace that will be converted to an exception
    * @hidden
    */
-  function exceptionFromStacktrace(stacktrace) {
-      const frames = prepareFramesForEvent(stacktrace.stack);
+  function exceptionFromError(ex) {
+      // Get the frames first since Opera can lose the stack if we touch anything else first
+      const frames = parseStackFrames(ex);
       const exception = {
-          type: stacktrace.name,
-          value: stacktrace.message,
+          type: ex && ex.name,
+          value: extractMessage(ex),
       };
       if (frames && frames.length) {
           exception.stacktrace = { frames };
@@ -4785,10 +4625,8 @@ var Sentry = (function (exports) {
           },
       };
       if (syntheticException) {
-          const stacktrace = computeStackTrace(syntheticException);
-          const frames = prepareFramesForEvent(stacktrace.stack);
           event.stacktrace = {
-              frames,
+              frames: parseStackFrames(syntheticException),
           };
       }
       return event;
@@ -4796,43 +4634,57 @@ var Sentry = (function (exports) {
   /**
    * @hidden
    */
-  function eventFromStacktrace(stacktrace) {
-      const exception = exceptionFromStacktrace(stacktrace);
+  function eventFromError(ex) {
       return {
           exception: {
-              values: [exception],
+              values: [exceptionFromError(ex)],
           },
       };
   }
+  /** Parses stack frames from an error */
+  function parseStackFrames(ex) {
+      // Access and store the stacktrace property before doing ANYTHING
+      // else to it because Opera is not very good at providing it
+      // reliably in other circumstances.
+      const stacktrace = ex.stacktrace || ex.stack || '';
+      const popSize = getPopSize(ex);
+      try {
+          // The order of the parsers in important
+          return createStackParser(opera10, opera11, chrome, winjs, gecko)(stacktrace, popSize);
+      }
+      catch (e) {
+          // no-empty
+      }
+      return [];
+  }
+  // Based on our own mapping pattern - https://github.com/getsentry/sentry/blob/9f08305e09866c8bd6d0c24f5b0aabdd7dd6c59c/src/sentry/lang/javascript/errormapping.py#L83-L108
+  const reactMinifiedRegexp = /Minified React error #\d+;/i;
+  function getPopSize(ex) {
+      if (ex) {
+          if (typeof ex.framesToPop === 'number') {
+              return ex.framesToPop;
+          }
+          if (reactMinifiedRegexp.test(ex.message)) {
+              return 1;
+          }
+      }
+      return 0;
+  }
   /**
-   * @hidden
+   * There are cases where stacktrace.message is an Event object
+   * https://github.com/getsentry/sentry-javascript/issues/1949
+   * In this specific case we try to extract stacktrace.message.error.message
    */
-  function prepareFramesForEvent(stack) {
-      if (!stack || !stack.length) {
-          return [];
-      }
-      let localStack = stack;
-      const firstFrameFunction = localStack[0].func || '';
-      const lastFrameFunction = localStack[localStack.length - 1].func || '';
-      // If stack starts with one of our API calls, remove it (starts, meaning it's the top of the stack - aka last call)
-      if (firstFrameFunction.indexOf('captureMessage') !== -1 || firstFrameFunction.indexOf('captureException') !== -1) {
-          localStack = localStack.slice(1);
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function extractMessage(ex) {
+      const message = ex && ex.message;
+      if (!message) {
+          return 'No error message';
       }
-      // If stack ends with one of our internal API calls, remove it (ends, meaning it's the bottom of the stack - aka top-most call)
-      if (lastFrameFunction.indexOf('sentryWrapped') !== -1) {
-          localStack = localStack.slice(0, -1);
+      if (message.error && typeof message.error.message === 'string') {
+          return message.error.message;
       }
-      // The frame where the crash happened, should be the last entry in the array
-      return localStack
-          .slice(0, STACKTRACE_LIMIT)
-          .map((frame) => ({
-          colno: frame.column === null ? undefined : frame.column,
-          filename: frame.url || localStack[0].url,
-          function: frame.func || '?',
-          in_app: true,
-          lineno: frame.line === null ? undefined : frame.line,
-      }))
-          .reverse();
+      return message;
   }
 
   /**
@@ -4874,10 +4726,7 @@ var Sentry = (function (exports) {
       if (isErrorEvent(exception) && exception.error) {
           // If it is an ErrorEvent with `error` property, extract it to get actual Error
           const errorEvent = exception;
-          // eslint-disable-next-line no-param-reassign
-          exception = errorEvent.error;
-          event = eventFromStacktrace(computeStackTrace(exception));
-          return event;
+          return eventFromError(errorEvent.error);
       }
       // If it is a `DOMError` (which is a legacy API, but still supported in some browsers) then we just extract the name
       // and message, as it doesn't provide anything else. According to the spec, all `DOMExceptions` should also be
@@ -4889,7 +4738,7 @@ var Sentry = (function (exports) {
       if (isDOMError(exception) || isDOMException(exception)) {
           const domException = exception;
           if ('stack' in exception) {
-              event = eventFromStacktrace(computeStackTrace(exception));
+              event = eventFromError(exception);
           }
           else {
               const name = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException');
@@ -4904,8 +4753,7 @@ var Sentry = (function (exports) {
       }
       if (isError(exception)) {
           // we have a real Error object, do nothing
-          event = eventFromStacktrace(computeStackTrace(exception));
-          return event;
+          return eventFromError(exception);
       }
       if (isPlainObject(exception) || isEvent(exception)) {
           // If it's a plain object or an instance of `Event` (the built-in JS kind, not this SDK's `Event` type), serialize
@@ -4942,16 +4790,14 @@ var Sentry = (function (exports) {
           message: input,
       };
       if (options.attachStacktrace && syntheticException) {
-          const stacktrace = computeStackTrace(syntheticException);
-          const frames = prepareFramesForEvent(stacktrace.stack);
           event.stacktrace = {
-              frames,
+              frames: parseStackFrames(syntheticException),
           };
       }
       return event;
   }
 
-  const global$3 = getGlobalObject();
+  const global$4 = getGlobalObject();
   let cachedFetchImpl;
   /**
    * A special usecase for incorrectly wrapped Fetch APIs in conjunction with ad-blockers.
@@ -4997,11 +4843,11 @@ var Sentry = (function (exports) {
       }
       /* eslint-disable @typescript-eslint/unbound-method */
       // Fast path to avoid DOM I/O
-      if (isNativeFetch(global$3.fetch)) {
-          return (cachedFetchImpl = global$3.fetch.bind(global$3));
+      if (isNativeFetch(global$4.fetch)) {
+          return (cachedFetchImpl = global$4.fetch.bind(global$4));
       }
-      const document = global$3.document;
-      let fetchImpl = global$3.fetch;
+      const document = global$4.document;
+      let fetchImpl = global$4.fetch;
       // eslint-disable-next-line deprecation/deprecation
       if (document && typeof document.createElement === `function`) {
           try {
@@ -5020,7 +4866,7 @@ var Sentry = (function (exports) {
               }
           }
       }
-      return (cachedFetchImpl = fetchImpl.bind(global$3));
+      return (cachedFetchImpl = fetchImpl.bind(global$4));
       /* eslint-enable @typescript-eslint/unbound-method */
   }
   /**
@@ -5030,11 +4876,11 @@ var Sentry = (function (exports) {
    * @param body report payload
    */
   function sendReport(url, body) {
-      const isRealNavigator = Object.prototype.toString.call(global$3 && global$3.navigator) === '[object Navigator]';
-      const hasSendBeacon = isRealNavigator && typeof global$3.navigator.sendBeacon === 'function';
+      const isRealNavigator = Object.prototype.toString.call(global$4 && global$4.navigator) === '[object Navigator]';
+      const hasSendBeacon = isRealNavigator && typeof global$4.navigator.sendBeacon === 'function';
       if (hasSendBeacon) {
           // Prevent illegal invocations - https://xgwang.me/posts/you-may-not-know-beacon/#it-may-throw-error%2C-be-sure-to-catch
-          const sendBeacon = global$3.navigator.sendBeacon.bind(global$3.navigator);
+          const sendBeacon = global$4.navigator.sendBeacon.bind(global$4.navigator);
           return sendBeacon(url, body);
       }
       if (supportsFetch()) {
@@ -5052,7 +4898,7 @@ var Sentry = (function (exports) {
       const tyStr = ty;
       return tyStr === 'event' ? 'error' : tyStr;
   }
-  const global$4 = getGlobalObject();
+  const global$3 = getGlobalObject();
   /** Base Transport class implementation */
   class BaseTransport {
       constructor(options) {
@@ -5065,9 +4911,9 @@ var Sentry = (function (exports) {
           this._api = initAPIDetails(options.dsn, options._metadata, options.tunnel);
           // eslint-disable-next-line deprecation/deprecation
           this.url = getStoreEndpointWithUrlEncodedAuth(this._api.dsn);
-          if (this.options.sendClientReports && global$4.document) {
-              global$4.document.addEventListener('visibilitychange', () => {
-                  if (global$4.document.visibilityState === 'hidden') {
+          if (this.options.sendClientReports && global$3.document) {
+              global$3.document.addEventListener('visibilitychange', () => {
+                  if (global$3.document.visibilityState === 'hidden') {
                       this._flushOutcomes();
                   }
               });
@@ -5331,8 +5177,6 @@ var Sentry = (function (exports) {
       }
   }
 
-
-
   var index = /*#__PURE__*/Object.freeze({
     __proto__: null,
     BaseTransport: BaseTransport,
@@ -5376,7 +5220,7 @@ var Sentry = (function (exports) {
       }
   }
 
-  const global$5 = getGlobalObject();
+  const global$2 = getGlobalObject();
   let ignoreOnError = 0;
   /**
    * @hidden
@@ -5402,7 +5246,7 @@ var Sentry = (function (exports) {
    * @returns The wrapped function.
    * @hidden
    */
-  function wrap(fn, options = {}, before) {
+  function wrap$1(fn, options = {}, before) {
       // for future readers what this does is wrap a function and then create
       // a bi-directional wrapping between them.
       //
@@ -5439,7 +5283,7 @@ var Sentry = (function (exports) {
                   before.apply(this, arguments);
               }
               // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
-              const wrappedArguments = args.map((arg) => wrap(arg, options));
+              const wrappedArguments = args.map((arg) => wrap$1(arg, options));
               // Attempt to invoke user-land function
               // NOTE: If you are a Sentry user, and you are seeing this stack frame, it
               //       means the sentry.javascript SDK caught an error invoking your application code. This
@@ -5497,7 +5341,7 @@ var Sentry = (function (exports) {
    * @hidden
    */
   function injectReportDialog(options = {}) {
-      if (!global$5.document) {
+      if (!global$2.document) {
           return;
       }
       if (!options.eventId) {
@@ -5512,14 +5356,14 @@ var Sentry = (function (exports) {
           }
           return;
       }
-      const script = global$5.document.createElement('script');
+      const script = global$2.document.createElement('script');
       script.async = true;
       script.src = getReportDialogEndpoint(options.dsn, options);
       if (options.onLoad) {
           // eslint-disable-next-line @typescript-eslint/unbound-method
           script.onload = options.onLoad;
       }
-      const injectionPoint = global$5.document.head || global$5.document.body;
+      const injectionPoint = global$2.document.head || global$2.document.body;
       if (injectionPoint) {
           injectionPoint.appendChild(script);
       }
@@ -5804,7 +5648,7 @@ var Sentry = (function (exports) {
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       return function (...args) {
           const originalCallback = args[0];
-          args[0] = wrap(originalCallback, {
+          args[0] = wrap$1(originalCallback, {
               mechanism: {
                   data: { function: getFunctionName(original) },
                   handled: true,
@@ -5820,7 +5664,7 @@ var Sentry = (function (exports) {
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       return function (callback) {
           // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-          return original.call(this, wrap(callback, {
+          return original.call(this, wrap$1(callback, {
               mechanism: {
                   data: {
                       function: 'requestAnimationFrame',
@@ -5859,7 +5703,7 @@ var Sentry = (function (exports) {
                           wrapOptions.mechanism.data.handler = getFunctionName(originalFunction);
                       }
                       // Otherwise wrap directly
-                      return wrap(original, wrapOptions);
+                      return wrap$1(original, wrapOptions);
                   });
               }
           });
@@ -5880,7 +5724,7 @@ var Sentry = (function (exports) {
           return function (eventName, fn, options) {
               try {
                   if (typeof fn.handleEvent === 'function') {
-                      fn.handleEvent = wrap(fn.handleEvent.bind(fn), {
+                      fn.handleEvent = wrap$1(fn.handleEvent.bind(fn), {
                           mechanism: {
                               data: {
                                   function: 'handleEvent',
@@ -5898,7 +5742,7 @@ var Sentry = (function (exports) {
               }
               return original.call(this, eventName, 
               // eslint-disable-next-line @typescript-eslint/no-explicit-any
-              wrap(fn, {
+              wrap$1(fn, {
                   mechanism: {
                       data: {
                           function: 'addEventListener',
@@ -6212,12 +6056,11 @@ var Sentry = (function (exports) {
       if (!isInstanceOf(error[key], Error) || stack.length + 1 >= limit) {
           return stack;
       }
-      const stacktrace = computeStackTrace(error[key]);
-      const exception = exceptionFromStacktrace(stacktrace);
+      const exception = exceptionFromError(error[key]);
       return _walkErrorTree(limit, error[key], key, [exception, ...stack]);
   }
 
-  const global$6 = getGlobalObject();
+  const global$1 = getGlobalObject();
   /** UserAgent */
   class UserAgent {
       constructor() {
@@ -6233,13 +6076,13 @@ var Sentry = (function (exports) {
           addGlobalEventProcessor((event) => {
               if (getCurrentHub().getIntegration(UserAgent)) {
                   // if none of the information we want exists, don't bother
-                  if (!global$6.navigator && !global$6.location && !global$6.document) {
+                  if (!global$1.navigator && !global$1.location && !global$1.document) {
                       return event;
                   }
                   // grab as much info as exists and add it to the event
-                  const url = (event.request && event.request.url) || (global$6.location && global$6.location.href);
-                  const { referrer } = global$6.document || {};
-                  const { userAgent } = global$6.navigator || {};
+                  const url = (event.request && event.request.url) || (global$1.location && global$1.location.href);
+                  const { referrer } = global$1.document || {};
+                  const { userAgent } = global$1.navigator || {};
                   const headers = Object.assign(Object.assign(Object.assign({}, (event.request && event.request.headers)), (referrer && { Referer: referrer })), (userAgent && { 'User-Agent': userAgent }));
                   const request = Object.assign(Object.assign({}, (url && { url })), { headers });
                   return Object.assign(Object.assign({}, event), { request });
@@ -6417,8 +6260,6 @@ var Sentry = (function (exports) {
       return undefined;
   }
 
-
-
   var BrowserIntegrations = /*#__PURE__*/Object.freeze({
     __proto__: null,
     GlobalHandlers: GlobalHandlers,
@@ -6665,8 +6506,8 @@ var Sentry = (function (exports) {
    * @returns The result of wrapped function call.
    */
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  function wrap$1(fn) {
-      return wrap(fn)();
+  function wrap(fn) {
+      return wrap$1(fn)();
   }
   function startSessionOnHub(hub) {
       hub.startSession({ ignoreDuration: true });
@@ -6755,9 +6596,9 @@ var Sentry = (function (exports) {
   exports.showReportDialog = showReportDialog;
   exports.startTransaction = startTransaction;
   exports.withScope = withScope;
-  exports.wrap = wrap$1;
+  exports.wrap = wrap;
 
   return exports;
 
-}({}));
+})({});
 //# sourceMappingURL=bundle.es6.js.map