@sentry/browser 6.14.2 → 6.16.1

package/build/bundle.es6.js

@@ -1,4 +1,4 @@
-/*! @sentry/browser 6.14.2 (9a623dd) | https://github.com/getsentry/sentry-javascript */
+/*! @sentry/browser 6.16.1 (6919d17) | https://github.com/getsentry/sentry-javascript */
 var Sentry = (function (exports) {
   /** Console logging verbosity for the SDK. */
   var LogLevel;
@@ -252,7 +252,7 @@ var Sentry = (function (exports) {
       return Object.prototype.toString.call(wat) === '[object DOMException]';
   }
   /**
-   * Checks whether the given value's type is string
+   * Checks whether given value's type is a string
    * {@link isString}.
    *
    * @param wat A value to be checked.
@@ -1074,8 +1074,9 @@ var Sentry = (function (exports) {
    * Given any object, return the new object with removed keys that value was `undefined`.
    * Works recursively on objects and arrays.
    */
-  function dropUndefinedKeys(obj) {
-      if (isPlainObject(obj)) {
+  function dropUndefinedKeys(val) {
+      if (isPlainObject(val)) {
+          const obj = val;
           const rv = {};
           for (const key of Object.keys(obj)) {
               if (typeof obj[key] !== 'undefined') {
@@ -1084,10 +1085,10 @@ var Sentry = (function (exports) {
           }
           return rv;
       }
-      if (Array.isArray(obj)) {
-          return obj.map(dropUndefinedKeys);
+      if (Array.isArray(val)) {
+          return val.map(dropUndefinedKeys);
       }
-      return obj;
+      return val;
   }
 
   /**
@@ -1866,35 +1867,25 @@ var Sentry = (function (exports) {
   }
 
   /* eslint-disable @typescript-eslint/explicit-function-return-type */
-  /** SyncPromise internal states */
-  var States;
-  (function (States) {
-      /** Pending */
-      States["PENDING"] = "PENDING";
-      /** Resolved / OK */
-      States["RESOLVED"] = "RESOLVED";
-      /** Rejected / Error */
-      States["REJECTED"] = "REJECTED";
-  })(States || (States = {}));
   /**
    * Thenable class that behaves like a Promise and follows it's interface
    * but is not async internally
    */
   class SyncPromise {
       constructor(executor) {
-          this._state = States.PENDING;
+          this._state = "PENDING" /* PENDING */;
           this._handlers = [];
           /** JSDoc */
           this._resolve = (value) => {
-              this._setResult(States.RESOLVED, value);
+              this._setResult("RESOLVED" /* RESOLVED */, value);
           };
           /** JSDoc */
           this._reject = (reason) => {
-              this._setResult(States.REJECTED, reason);
+              this._setResult("REJECTED" /* REJECTED */, reason);
           };
           /** JSDoc */
           this._setResult = (state, value) => {
-              if (this._state !== States.PENDING) {
+              if (this._state !== "PENDING" /* PENDING */) {
                   return;
               }
               if (isThenable(value)) {
@@ -1913,7 +1904,7 @@ var Sentry = (function (exports) {
           };
           /** JSDoc */
           this._executeHandlers = () => {
-              if (this._state === States.PENDING) {
+              if (this._state === "PENDING" /* PENDING */) {
                   return;
               }
               const cachedHandlers = this._handlers.slice();
@@ -1922,13 +1913,13 @@ var Sentry = (function (exports) {
                   if (handler.done) {
                       return;
                   }
-                  if (this._state === States.RESOLVED) {
+                  if (this._state === "RESOLVED" /* RESOLVED */) {
                       if (handler.onfulfilled) {
                           // eslint-disable-next-line @typescript-eslint/no-floating-promises
                           handler.onfulfilled(this._value);
                       }
                   }
-                  if (this._state === States.REJECTED) {
+                  if (this._state === "REJECTED" /* REJECTED */) {
                       if (handler.onrejected) {
                           handler.onrejected(this._value);
                       }
@@ -4360,7 +4351,7 @@ var Sentry = (function (exports) {
       hub.bindClient(client);
   }
 
-  const SDK_VERSION = '6.14.2';
+  const SDK_VERSION = '6.16.1';
 
   let originalFunctionToString;
   /** Patch toString calls to return proper name for wrapped functions */
@@ -4958,23 +4949,32 @@ var Sentry = (function (exports) {
    */
   function eventFromUnknownInput(exception, syntheticException, options = {}) {
       let event;
-      if (isErrorEvent(exception)) {
+      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 = exception.error;
+          exception = errorEvent.error;
           event = eventFromStacktrace(computeStackTrace(exception));
           return event;
       }
+      // 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
+      // `Error`s, but that's not the case in IE11, so in that case we treat it the same as we do a `DOMError`.
+      //
+      // https://developer.mozilla.org/en-US/docs/Web/API/DOMError
+      // https://developer.mozilla.org/en-US/docs/Web/API/DOMException
+      // https://webidl.spec.whatwg.org/#es-DOMException-specialness
       if (isDOMError(exception) || isDOMException(exception)) {
-          // If it is a DOMError or DOMException (which are legacy APIs, but still supported in some browsers)
-          // then we just extract the name, code, and message, as they don't provide anything else
-          // https://developer.mozilla.org/en-US/docs/Web/API/DOMError
-          // https://developer.mozilla.org/en-US/docs/Web/API/DOMException
           const domException = exception;
-          const name = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException');
-          const message = domException.message ? `${name}: ${domException.message}` : name;
-          event = eventFromString(message, syntheticException, options);
-          addExceptionTypeValue(event, message);
+          if ('stack' in exception) {
+              event = eventFromStacktrace(computeStackTrace(exception));
+          }
+          else {
+              const name = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException');
+              const message = domException.message ? `${name}: ${domException.message}` : name;
+              event = eventFromString(message, syntheticException, options);
+              addExceptionTypeValue(event, message);
+          }
           if ('code' in domException) {
               event.tags = Object.assign(Object.assign({}, event.tags), { 'DOMException.code': `${domException.code}` });
           }