@sentry/browser 6.17.8-beta.0 → 6.17.8

package/build/bundle.es6.js

@@ -1,4 +1,4 @@
-/*! @sentry/browser 6.17.8-beta.0 (07f9257) | https://github.com/getsentry/sentry-javascript */
+/*! @sentry/browser 6.17.8 (db493a0) | https://github.com/getsentry/sentry-javascript */
 var Sentry = (function (exports) {
   /**
    * TODO(v7): Remove this enum and replace with SeverityLevel
@@ -49,41 +49,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 +63,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
@@ -603,6 +567,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
@@ -1219,7 +1230,7 @@ var Sentry = (function (exports) {
                   triggerHandlers('console', { args, level });
                   // this fails for some browsers. :(
                   if (originalConsoleMethod) {
-                      originalConsoleMethod.call(global$2.console, args);
+                      originalConsoleMethod.apply(global$2.console, args);
                   }
               };
           });
@@ -2109,23 +2120,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
       : {
@@ -3162,38 +3160,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
@@ -3822,6 +3791,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);
               }
@@ -4166,22 +4140,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
@@ -4263,7 +4242,7 @@ var Sentry = (function (exports) {
       hub.bindClient(client);
   }
 
-  const SDK_VERSION = '6.17.8-beta.0';
+  const SDK_VERSION = '6.17.8';
 
   let originalFunctionToString;
   /** Patch toString calls to return proper name for wrapped functions */
@@ -4496,127 +4475,87 @@ var Sentry = (function (exports) {
 
   // global reference to slice
   const UNKNOWN_FUNCTION = '?';
-  // Chromium based browsers: Chrome, Brave, new Opera, new Edge
-  const chrome = /^\s*at (?:(.*?) ?\((?:address 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;
-  const opera10Regex = / line (\d+).*script (?:in )?(\S+)(?:: in function (\S+))?$/i;
-  const opera11Regex = / line (\d+), column (\d+)\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\(.*\))? in (.*):\s*$/i;
-  /** JSDoc */
-  function computeStackTrace(ex) {
-      let frames = [];
-      let popSize = 0;
-      if (ex) {
-          if (typeof ex.framesToPop === 'number') {
-              popSize = ex.framesToPop;
-          }
-          else if (reactMinifiedRegexp.test(ex.message)) {
-              popSize = 1;
-          }
-      }
-      try {
-          // 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 || '';
-          frames = parseFrames(stacktrace);
-      }
-      catch (e) {
-          // no-empty
+  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;
       }
-      if (frames.length && popSize > 0) {
-          frames = frames.slice(popSize);
+      if (colno !== undefined) {
+          frame.colno = colno;
       }
-      return {
-          message: extractMessage(ex),
-          name: ex && ex.name,
-          stack: frames,
-      };
+      return frame;
   }
-  /** JSDoc */
-  // eslint-disable-next-line complexity
-  function parseFrames(stackString) {
-      const frames = [];
-      const lines = stackString.split('\n');
-      let isEval;
-      let submatch;
-      let parts;
-      let element;
-      for (const line of lines) {
-          if ((parts = opera10Regex.exec(line))) {
-              element = {
-                  filename: parts[2],
-                  function: parts[3] || UNKNOWN_FUNCTION,
-                  lineno: +parts[1],
-              };
-          }
-          else if ((parts = opera11Regex.exec(line))) {
-              element = {
-                  filename: parts[5],
-                  function: parts[3] || parts[4] || UNKNOWN_FUNCTION,
-                  lineno: +parts[1],
-                  colno: +parts[2],
-              };
-          }
-          else if ((parts = chrome.exec(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
               }
-              // 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]);
-              element = {
-                  filename,
-                  function: func,
-                  lineno: parts[3] ? +parts[3] : undefined,
-                  colno: parts[4] ? +parts[4] : undefined,
-              };
-          }
-          else if ((parts = winjs.exec(line))) {
-              element = {
-                  filename: parts[2],
-                  function: parts[1] || UNKNOWN_FUNCTION,
-                  lineno: +parts[3],
-                  colno: parts[4] ? +parts[4] : undefined,
-              };
           }
-          else if ((parts = gecko.exec(line))) {
-              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
               }
-              let filename = parts[3];
-              let func = parts[1] || UNKNOWN_FUNCTION;
-              [func, filename] = extractSafariExtensionDetails(func, filename);
-              element = {
-                  filename,
-                  function: func,
-                  lineno: parts[4] ? +parts[4] : undefined,
-                  colno: parts[5] ? +parts[5] : undefined,
-              };
           }
-          else {
-              continue;
-          }
-          frames.push(element);
+          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 frames;
-  }
+      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:
@@ -4634,7 +4573,7 @@ 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, filename) => {
@@ -4646,35 +4585,19 @@ var Sentry = (function (exports) {
               isSafariExtension ? `safari-extension:${filename}` : `safari-web-extension:${filename}`,
           ]
           : [func, filename];
-  };
-  /**
-   * 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;
-  }
+  };
 
-  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 };
@@ -4702,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;
@@ -4713,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.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);
+  // 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 => ({
-          filename: frame.filename || localStack[0].filename,
-          function: frame.function || '?',
-          lineno: frame.lineno,
-          colno: frame.colno,
-          in_app: true,
-      }))
-          .reverse();
+      return message;
   }
 
   /**
@@ -4791,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
@@ -4806,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');
@@ -4821,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
@@ -4859,10 +4790,8 @@ 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;
@@ -6129,8 +6058,7 @@ 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]);
   }