@sentry/browser 6.17.7 → 6.17.8-beta.0

package/build/bundle.es6.js

@@ -1,4 +1,4 @@
-/*! @sentry/browser 6.17.7 (635dfc2) | https://github.com/getsentry/sentry-javascript */
+/*! @sentry/browser 6.17.8-beta.0 (07f9257) | https://github.com/getsentry/sentry-javascript */
 var Sentry = (function (exports) {
   /**
    * TODO(v7): Remove this enum and replace with SeverityLevel
@@ -4263,7 +4263,7 @@ var Sentry = (function (exports) {
       hub.bindClient(client);
   }
 
-  const SDK_VERSION = '6.17.7';
+  const SDK_VERSION = '6.17.8-beta.0';
 
   let originalFunctionToString;
   /** Patch toString calls to return proper name for wrapped functions */
@@ -4494,10 +4494,6 @@ var Sentry = (function (exports) {
     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
@@ -4511,10 +4507,11 @@ var Sentry = (function (exports) {
   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 */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
   function computeStackTrace(ex) {
-      let stack = null;
+      let frames = [];
       let popSize = 0;
       if (ex) {
           if (typeof ex.framesToPop === 'number') {
@@ -4525,47 +4522,50 @@ var Sentry = (function (exports) {
           }
       }
       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);
-          }
+          // 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
       }
-      try {
-          stack = computeStackTraceFromStackProp(ex);
-          if (stack) {
-              return popFrames(stack, popSize);
-          }
-      }
-      catch (e) {
-          // no-empty
+      if (frames.length && popSize > 0) {
+          frames = frames.slice(popSize);
       }
       return {
           message: extractMessage(ex),
           name: ex && ex.name,
-          stack: [],
-          failed: true,
+          stack: frames,
       };
   }
   /** 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');
+  // 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 = chrome.exec(line))) {
+          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]))) {
                   // throw out eval line/column and use top-most line/column number
@@ -4575,20 +4575,20 @@ var Sentry = (function (exports) {
               }
               // 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, url] = extractSafariExtensionDetails(parts[1] || UNKNOWN_FUNCTION, parts[2]);
+              const [func, filename] = extractSafariExtensionDetails(parts[1] || UNKNOWN_FUNCTION, parts[2]);
               element = {
-                  url,
-                  func,
-                  line: parts[3] ? +parts[3] : null,
-                  column: parts[4] ? +parts[4] : null,
+                  filename,
+                  function: func,
+                  lineno: parts[3] ? +parts[3] : undefined,
+                  colno: parts[4] ? +parts[4] : undefined,
               };
           }
           else if ((parts = winjs.exec(line))) {
               element = {
-                  url: parts[2],
-                  func: parts[1] || UNKNOWN_FUNCTION,
-                  line: +parts[3],
-                  column: parts[4] ? +parts[4] : null,
+                  filename: parts[2],
+                  function: parts[1] || UNKNOWN_FUNCTION,
+                  lineno: +parts[3],
+                  colno: parts[4] ? +parts[4] : undefined,
               };
           }
           else if ((parts = gecko.exec(line))) {
@@ -4600,78 +4600,22 @@ var Sentry = (function (exports) {
                   parts[4] = submatch[2];
                   parts[5] = ''; // no column when eval
               }
-              let url = parts[3];
+              let filename = parts[3];
               let func = parts[1] || UNKNOWN_FUNCTION;
-              [func, url] = extractSafariExtensionDetails(func, url);
+              [func, filename] = extractSafariExtensionDetails(func, filename);
               element = {
-                  url,
-                  func,
-                  line: parts[4] ? +parts[4] : null,
-                  column: parts[5] ? +parts[5] : null,
+                  filename,
+                  function: func,
+                  lineno: parts[4] ? +parts[4] : undefined,
+                  colno: parts[5] ? +parts[5] : undefined,
               };
           }
           else {
               continue;
           }
-          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],
-                  line: +parts[1],
-                  column: null,
-              };
-          }
-          else if ((parts = opera11Regex.exec(lines[line]))) {
-              element = {
-                  url: parts[5],
-                  func: parts[3] || parts[4],
-                  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;
+          frames.push(element);
       }
-      return {
-          message: extractMessage(ex),
-          name: ex.name,
-          stack,
-      };
+      return frames;
   }
   /**
    * Safari web extensions, starting version unknown, can produce "frames-only" stacktraces.
@@ -4693,25 +4637,16 @@ var Sentry = (function (exports) {
    * Unfortunatelly "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];
+          : [func, filename];
   };
-  /** 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
@@ -4790,12 +4725,12 @@ var Sentry = (function (exports) {
    * @hidden
    */
   function prepareFramesForEvent(stack) {
-      if (!stack || !stack.length) {
+      if (!stack.length) {
           return [];
       }
       let localStack = stack;
-      const firstFrameFunction = localStack[0].func || '';
-      const lastFrameFunction = localStack[localStack.length - 1].func || '';
+      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);
@@ -4807,12 +4742,12 @@ var Sentry = (function (exports) {
       // 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 || '?',
+          .map(frame => ({
+          filename: frame.filename || localStack[0].filename,
+          function: frame.function || '?',
+          lineno: frame.lineno,
+          colno: frame.colno,
           in_app: true,
-          lineno: frame.line === null ? undefined : frame.line,
       }))
           .reverse();
   }