@sentry/browser 6.6.0 → 6.8.0

package/build/bundle.es6.js

@@ -1,4 +1,4 @@
-/*! @sentry/browser 6.6.0 (9a13c8b) | https://github.com/getsentry/sentry-javascript */
+/*! @sentry/browser 6.8.0 (e93d96f) | https://github.com/getsentry/sentry-javascript */
 var Sentry = (function (exports) {
   /** Console logging verbosity for the SDK. */
   var LogLevel;
@@ -286,7 +286,7 @@ var Sentry = (function (exports) {
    * e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]
    * @returns generated DOM path
    */
-  function htmlTreeAsString(elem, keyAttr) {
+  function htmlTreeAsString(elem, keyAttrs) {
       // try/catch both:
       // - accessing event.target (see getsentry/raven-js#838, #768)
       // - `htmlTreeAsString` because it's complex, and just accessing the DOM incorrectly
@@ -303,7 +303,7 @@ var Sentry = (function (exports) {
           let nextStr;
           // eslint-disable-next-line no-plusplus
           while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {
-              nextStr = _htmlElementAsString(currentElem, keyAttr);
+              nextStr = _htmlElementAsString(currentElem, keyAttrs);
               // bail out if
               // - nextStr is the 'html' element
               // - the length of the string that would be created exceeds MAX_OUTPUT_LEN
@@ -326,7 +326,8 @@ var Sentry = (function (exports) {
    * e.g. [HTMLElement] => input#foo.btn[name=baz]
    * @returns generated DOM path
    */
-  function _htmlElementAsString(el, keyAttr) {
+  function _htmlElementAsString(el, keyAttrs) {
+      var _a, _b;
       const elem = el;
       const out = [];
       let className;
@@ -338,9 +339,13 @@ var Sentry = (function (exports) {
           return '';
       }
       out.push(elem.tagName.toLowerCase());
-      const keyAttrValue = keyAttr ? elem.getAttribute(keyAttr) : null;
-      if (keyAttrValue) {
-          out.push(`[${keyAttr}="${keyAttrValue}"]`);
+      // Pairs of attribute keys defined in `serializeAttribute` and their values on element.
+      const keyAttrPairs = ((_a = keyAttrs) === null || _a === void 0 ? void 0 : _a.length) ? keyAttrs.filter(keyAttr => elem.getAttribute(keyAttr)).map(keyAttr => [keyAttr, elem.getAttribute(keyAttr)])
+          : null;
+      if ((_b = keyAttrPairs) === null || _b === void 0 ? void 0 : _b.length) {
+          keyAttrPairs.forEach(keyAttrPair => {
+              out.push(`[${keyAttrPair[0]}="${keyAttrPair[1]}"]`);
+          });
       }
       else {
           if (elem.id) {
@@ -1987,13 +1992,15 @@ var Sentry = (function (exports) {
       /**
        * Add a promise to the queue.
        *
-       * @param task Can be any PromiseLike<T>
+       * @param taskProducer A function producing any PromiseLike<T>; In previous versions this used to be `task: PromiseLike<T>`,
+       *        however, Promises were instantly created on the call-site, making them fall through the buffer limit.
        * @returns The original promise.
        */
-      add(task) {
+      add(taskProducer) {
           if (!this.isReady()) {
               return SyncPromise.reject(new SentryError('Not adding Promise due to buffer limit reached.'));
           }
+          const task = taskProducer();
           if (this._buffer.indexOf(task) === -1) {
               this._buffer.push(task);
           }
@@ -2175,6 +2182,11 @@ var Sentry = (function (exports) {
       return dateNow;
   })();
 
+  /**
+   * Absolute maximum number of breadcrumbs added to an event.
+   * The `maxBreadcrumbs` option cannot be higher than this value.
+   */
+  const MAX_BREADCRUMBS = 100;
   /**
    * Holds additional event information. {@link Scope.applyToEvent} will be
    * called by the client before an event will be sent.
@@ -2463,11 +2475,13 @@ var Sentry = (function (exports) {
        * @inheritDoc
        */
       addBreadcrumb(breadcrumb, maxBreadcrumbs) {
+          const maxCrumbs = typeof maxBreadcrumbs === 'number' ? Math.min(maxBreadcrumbs, MAX_BREADCRUMBS) : MAX_BREADCRUMBS;
+          // No data has been changed, so don't notify scope listeners
+          if (maxCrumbs <= 0) {
+              return this;
+          }
           const mergedBreadcrumb = Object.assign({ timestamp: dateTimestampInSeconds() }, breadcrumb);
-          this._breadcrumbs =
-              maxBreadcrumbs !== undefined && maxBreadcrumbs >= 0
-                  ? [...this._breadcrumbs, mergedBreadcrumb].slice(-maxBreadcrumbs)
-                  : [...this._breadcrumbs, mergedBreadcrumb];
+          this._breadcrumbs = [...this._breadcrumbs, mergedBreadcrumb].slice(-maxCrumbs);
           this._notifyScopeListeners();
           return this;
       }
@@ -2624,10 +2638,10 @@ var Sentry = (function (exports) {
       // eslint-disable-next-line complexity
       update(context = {}) {
           if (context.user) {
-              if (context.user.ip_address) {
+              if (!this.ipAddress && context.user.ip_address) {
                   this.ipAddress = context.user.ip_address;
               }
-              if (!context.did) {
+              if (!this.did && !context.did) {
                   this.did = context.user.id || context.user.email || context.user.username;
               }
           }
@@ -2642,7 +2656,7 @@ var Sentry = (function (exports) {
           if (context.init !== undefined) {
               this.init = context.init;
           }
-          if (context.did) {
+          if (!this.did && context.did) {
               this.did = `${context.did}`;
           }
           if (typeof context.started === 'number') {
@@ -2664,10 +2678,10 @@ var Sentry = (function (exports) {
           if (context.environment) {
               this.environment = context.environment;
           }
-          if (context.ipAddress) {
+          if (!this.ipAddress && context.ipAddress) {
               this.ipAddress = context.ipAddress;
           }
-          if (context.userAgent) {
+          if (!this.userAgent && context.userAgent) {
               this.userAgent = context.userAgent;
           }
           if (typeof context.errors === 'number') {
@@ -2726,11 +2740,6 @@ var Sentry = (function (exports) {
    * with {@link Options.maxBreadcrumbs}.
    */
   const DEFAULT_BREADCRUMBS = 100;
-  /**
-   * Absolute maximum number of breadcrumbs added to an event. The
-   * `maxBreadcrumbs` option cannot be higher than this value.
-   */
-  const MAX_BREADCRUMBS = 100;
   /**
    * @inheritDoc
    */
@@ -2901,7 +2910,7 @@ var Sentry = (function (exports) {
               : mergedBreadcrumb;
           if (finalBreadcrumb === null)
               return;
-          scope.addBreadcrumb(finalBreadcrumb, Math.min(maxBreadcrumbs, MAX_BREADCRUMBS));
+          scope.addBreadcrumb(finalBreadcrumb, maxBreadcrumbs);
       }
       /**
        * @inheritDoc
@@ -3033,8 +3042,11 @@ var Sentry = (function (exports) {
       startSession(context) {
           const { scope, client } = this.getStackTop();
           const { release, environment } = (client && client.getOptions()) || {};
-          const session = new Session(Object.assign(Object.assign({ release,
-              environment }, (scope && { user: scope.getUser() })), context));
+          // Will fetch userAgent if called from browser sdk
+          const global = getGlobalObject();
+          const { userAgent } = global.navigator || {};
+          const session = new Session(Object.assign(Object.assign(Object.assign({ release,
+              environment }, (scope && { user: scope.getUser() })), (userAgent && { userAgent })), context));
           if (scope) {
               // End existing session if there's one
               const currentSession = scope.getSession && scope.getSession();
@@ -3373,18 +3385,23 @@ var Sentry = (function (exports) {
    **/
   class API {
       /** Create a new instance of API */
-      constructor(dsn, metadata = {}) {
+      constructor(dsn, metadata = {}, tunnel) {
           this.dsn = dsn;
           this._dsnObject = new Dsn(dsn);
           this.metadata = metadata;
+          this._tunnel = tunnel;
       }
       /** Returns the Dsn object. */
       getDsn() {
           return this._dsnObject;
       }
+      /** Does this transport force envelopes? */
+      forceEnvelope() {
+          return !!this._tunnel;
+      }
       /** Returns the prefix to construct Sentry ingestion API endpoints. */
       getBaseApiEndpoint() {
-          const dsn = this._dsnObject;
+          const dsn = this.getDsn();
           const protocol = dsn.protocol ? `${dsn.protocol}:` : '';
           const port = dsn.port ? `:${dsn.port}` : '';
           return `${protocol}//${dsn.host}${port}${dsn.path ? `/${dsn.path}` : ''}/api/`;
@@ -3407,11 +3424,14 @@ var Sentry = (function (exports) {
        * Sending auth as part of the query string and not as custom HTTP headers avoids CORS preflight requests.
        */
       getEnvelopeEndpointWithUrlEncodedAuth() {
+          if (this.forceEnvelope()) {
+              return this._tunnel;
+          }
           return `${this._getEnvelopeEndpoint()}?${this._encodedAuth()}`;
       }
       /** Returns only the path component for the store endpoint. */
       getStoreEndpointPath() {
-          const dsn = this._dsnObject;
+          const dsn = this.getDsn();
           return `${dsn.path ? `/${dsn.path}` : ''}/api/${dsn.projectId}/store/`;
       }
       /**
@@ -3420,7 +3440,7 @@ var Sentry = (function (exports) {
        */
       getRequestHeaders(clientName, clientVersion) {
           // CHANGE THIS to use metadata but keep clientName and clientVersion compatible
-          const dsn = this._dsnObject;
+          const dsn = this.getDsn();
           const header = [`Sentry sentry_version=${SENTRY_API_VERSION}`];
           header.push(`sentry_client=${clientName}/${clientVersion}`);
           header.push(`sentry_key=${dsn.publicKey}`);
@@ -3434,7 +3454,7 @@ var Sentry = (function (exports) {
       }
       /** Returns the url to the report dialog endpoint. */
       getReportDialogEndpoint(dialogOptions = {}) {
-          const dsn = this._dsnObject;
+          const dsn = this.getDsn();
           const endpoint = `${this.getBaseApiEndpoint()}embed/error-page/`;
           const encodedOptions = [];
           encodedOptions.push(`dsn=${dsn.toString()}`);
@@ -3468,13 +3488,16 @@ var Sentry = (function (exports) {
       }
       /** Returns the ingest API endpoint for target. */
       _getIngestEndpoint(target) {
+          if (this._tunnel) {
+              return this._tunnel;
+          }
           const base = this.getBaseApiEndpoint();
-          const dsn = this._dsnObject;
+          const dsn = this.getDsn();
           return `${base}${dsn.projectId}/${target}/`;
       }
       /** Returns a URL-encoded string with auth config suitable for a query string. */
       _encodedAuth() {
-          const dsn = this._dsnObject;
+          const dsn = this.getDsn();
           const auth = {
               // We send only the minimum set of required information. See
               // https://github.com/getsentry/sentry-javascript/issues/2572.
@@ -3640,6 +3663,10 @@ var Sentry = (function (exports) {
        * @inheritDoc
        */
       captureSession(session) {
+          if (!this._isEnabled()) {
+              logger.warn('SDK not enabled, will not capture session.');
+              return;
+          }
           if (!(typeof session.release === 'string')) {
               logger.warn('Discarded session because of missing or non-string release');
           }
@@ -3705,7 +3732,6 @@ var Sentry = (function (exports) {
       _updateSessionFromEvent(session, event) {
           let crashed = false;
           let errored = false;
-          let userAgent;
           const exceptions = event.exception && event.exception.values;
           if (exceptions) {
               errored = true;
@@ -3717,19 +3743,15 @@ var Sentry = (function (exports) {
                   }
               }
           }
-          const user = event.user;
-          if (!session.userAgent) {
-              const headers = event.request ? event.request.headers : {};
-              for (const key in headers) {
-                  if (key.toLowerCase() === 'user-agent') {
-                      userAgent = headers[key];
-                      break;
-                  }
-              }
+          // A session is updated and that session update is sent in only one of the two following scenarios:
+          // 1. Session with non terminal status and 0 errors + an error occurred -> Will set error count to 1 and send update
+          // 2. Session with non terminal status and 1 error + a crash occurred -> Will set status crashed and send update
+          const sessionNonTerminal = session.status === SessionStatus.Ok;
+          const shouldUpdateAndSend = (sessionNonTerminal && session.errors === 0) || (sessionNonTerminal && crashed);
+          if (shouldUpdateAndSend) {
+              session.update(Object.assign(Object.assign({}, (crashed && { status: SessionStatus.Crashed })), { errors: session.errors || Number(errored || crashed) }));
+              this.captureSession(session);
           }
-          session.update(Object.assign(Object.assign({}, (crashed && { status: SessionStatus.Crashed })), { user,
-              userAgent, errors: session.errors + Number(errored || crashed) }));
-          this.captureSession(session);
       }
       /** Deliver captured session to Sentry */
       _sendSession(session) {
@@ -3920,7 +3942,7 @@ var Sentry = (function (exports) {
           // eslint-disable-next-line @typescript-eslint/unbound-method
           const { beforeSend, sampleRate } = this.getOptions();
           if (!this._isEnabled()) {
-              return SyncPromise.reject(new SentryError('SDK not enabled, will not send event.'));
+              return SyncPromise.reject(new SentryError('SDK not enabled, will not capture event.'));
           }
           const isTransaction = event.type === 'transaction';
           // 1.0 === 100% events are sent
@@ -3939,15 +3961,7 @@ var Sentry = (function (exports) {
                   return prepared;
               }
               const beforeSendResult = beforeSend(prepared, hint);
-              if (typeof beforeSendResult === 'undefined') {
-                  throw new SentryError('`beforeSend` method has to return `null` or a valid event.');
-              }
-              else if (isThenable(beforeSendResult)) {
-                  return beforeSendResult.then(event => event, e => {
-                      throw new SentryError(`beforeSend rejected with ${e}`);
-                  });
-              }
-              return beforeSendResult;
+              return this._ensureBeforeSendRv(beforeSendResult);
           })
               .then(processedEvent => {
               if (processedEvent === null) {
@@ -3986,6 +4000,26 @@ var Sentry = (function (exports) {
               return reason;
           });
       }
+      /**
+       * Verifies that return value of configured `beforeSend` is of expected type.
+       */
+      _ensureBeforeSendRv(rv) {
+          const nullErr = '`beforeSend` method has to return `null` or a valid event.';
+          if (isThenable(rv)) {
+              return rv.then(event => {
+                  if (!(isPlainObject(event) || event === null)) {
+                      throw new SentryError(nullErr);
+                  }
+                  return event;
+              }, e => {
+                  throw new SentryError(`beforeSend rejected with ${e}`);
+              });
+          }
+          else if (!(isPlainObject(rv) || rv === null)) {
+              throw new SentryError(nullErr);
+          }
+          return rv;
+      }
   }
 
   /** Noop transport */
@@ -4118,7 +4152,7 @@ var Sentry = (function (exports) {
   /** Creates a SentryRequest from a Session. */
   function sessionToSentryRequest(session, api) {
       const sdkInfo = getSdkMetadataForEnvelopeHeader(api);
-      const envelopeHeaders = JSON.stringify(Object.assign({ sent_at: new Date().toISOString() }, (sdkInfo && { sdk: sdkInfo })));
+      const envelopeHeaders = JSON.stringify(Object.assign(Object.assign({ sent_at: new Date().toISOString() }, (sdkInfo && { sdk: sdkInfo })), (api.forceEnvelope() && { dsn: api.getDsn().toString() })));
       // I know this is hacky but we don't want to add `session` to request type since it's never rate limited
       const type = 'aggregates' in session ? 'sessions' : 'session';
       const itemHeaders = JSON.stringify({
@@ -4134,7 +4168,7 @@ var Sentry = (function (exports) {
   function eventToSentryRequest(event, api) {
       const sdkInfo = getSdkMetadataForEnvelopeHeader(api);
       const eventType = event.type || 'event';
-      const useEnvelope = eventType === 'transaction';
+      const useEnvelope = eventType === 'transaction' || api.forceEnvelope();
       const _a = event.debug_meta || {}, { transactionSampling } = _a, metadata = __rest(_a, ["transactionSampling"]);
       const { method: samplingMethod, rate: sampleRate } = transactionSampling || {};
       if (Object.keys(metadata).length === 0) {
@@ -4154,9 +4188,9 @@ var Sentry = (function (exports) {
       // deserialization. Instead, we only implement a minimal subset of the spec to
       // serialize events inline here.
       if (useEnvelope) {
-          const envelopeHeaders = JSON.stringify(Object.assign({ event_id: event.event_id, sent_at: new Date().toISOString() }, (sdkInfo && { sdk: sdkInfo })));
+          const envelopeHeaders = JSON.stringify(Object.assign(Object.assign({ event_id: event.event_id, sent_at: new Date().toISOString() }, (sdkInfo && { sdk: sdkInfo })), (api.forceEnvelope() && { dsn: api.getDsn().toString() })));
           const itemHeaders = JSON.stringify({
-              type: event.type,
+              type: eventType,
               // TODO: Right now, sampleRate may or may not be defined (it won't be in the cases of inheritance and
               // explicitly-set sampling decisions). Are we good with that?
               sample_rates: [{ id: samplingMethod, rate: sampleRate }],
@@ -4189,7 +4223,7 @@ var Sentry = (function (exports) {
       hub.bindClient(client);
   }
 
-  const SDK_VERSION = '6.6.0';
+  const SDK_VERSION = '6.8.0';
 
   let originalFunctionToString;
   /** Patch toString calls to return proper name for wrapped functions */
@@ -4837,7 +4871,7 @@ var Sentry = (function (exports) {
           this._buffer = new PromiseBuffer(30);
           /** Locks transport after receiving rate limits in a response */
           this._rateLimits = {};
-          this._api = new API(options.dsn, options._metadata);
+          this._api = new API(options.dsn, options._metadata, options.tunnel);
           // eslint-disable-next-line deprecation/deprecation
           this.url = this._api.getStoreEndpointWithUrlEncodedAuth();
       }
@@ -4864,7 +4898,7 @@ var Sentry = (function (exports) {
            */
           const limited = this._handleRateLimit(headers);
           if (limited)
-              logger.warn(`Too many requests, backing off until: ${this._disabledUntil(requestType)}`);
+              logger.warn(`Too many ${requestType} requests, backing off until: ${this._disabledUntil(requestType)}`);
           if (status === exports.Status.Success) {
               resolve({ status });
               return;
@@ -5013,7 +5047,7 @@ var Sentry = (function (exports) {
               return Promise.reject({
                   event: originalPayload,
                   type: sentryRequest.type,
-                  reason: `Transport locked till ${this._disabledUntil(sentryRequest.type)} due to too many requests.`,
+                  reason: `Transport for ${sentryRequest.type} requests locked till ${this._disabledUntil(sentryRequest.type)} due to too many requests.`,
                   status: 429,
               });
           }
@@ -5032,7 +5066,7 @@ var Sentry = (function (exports) {
           if (this.options.headers !== undefined) {
               options.headers = this.options.headers;
           }
-          return this._buffer.add(new SyncPromise((resolve, reject) => {
+          return this._buffer.add(() => new SyncPromise((resolve, reject) => {
               void this._fetch(sentryRequest.url, options)
                   .then(response => {
                   const headers = {
@@ -5075,11 +5109,11 @@ var Sentry = (function (exports) {
               return Promise.reject({
                   event: originalPayload,
                   type: sentryRequest.type,
-                  reason: `Transport locked till ${this._disabledUntil(sentryRequest.type)} due to too many requests.`,
+                  reason: `Transport for ${sentryRequest.type} requests locked till ${this._disabledUntil(sentryRequest.type)} due to too many requests.`,
                   status: 429,
               });
           }
-          return this._buffer.add(new SyncPromise((resolve, reject) => {
+          return this._buffer.add(() => new SyncPromise((resolve, reject) => {
               const request = new XMLHttpRequest();
               request.onreadystatechange = () => {
                   if (request.readyState === 4) {
@@ -5135,7 +5169,7 @@ var Sentry = (function (exports) {
               // We return the noop transport here in case there is no Dsn.
               return super._setupTransport();
           }
-          const transportOptions = Object.assign(Object.assign({}, this._options.transportOptions), { dsn: this._options.dsn, _metadata: this._options._metadata });
+          const transportOptions = Object.assign(Object.assign({}, this._options.transportOptions), { dsn: this._options.dsn, tunnel: this._options.tunnel, _metadata: this._options._metadata });
           if (this._options.transport) {
               return new this._options.transport(transportOptions);
           }
@@ -5344,9 +5378,9 @@ var Sentry = (function (exports) {
                       return;
                   }
                   const client = currentHub.getClient();
-                  const event = isPrimitive(error)
+                  const event = error === undefined && isString(data.msg)
                       ? this._eventFromIncompleteOnError(data.msg, data.url, data.line, data.column)
-                      : this._enhanceEventWithInitialFrame(eventFromUnknownInput(error, undefined, {
+                      : this._enhanceEventWithInitialFrame(eventFromUnknownInput(error || data.msg, undefined, {
                           attachStacktrace: client && client.getOptions().attachStacktrace,
                           rejection: false,
                       }), data.url, data.line, data.column);
@@ -5426,12 +5460,10 @@ var Sentry = (function (exports) {
           // If 'message' is ErrorEvent, get real message from inside
           let message = isErrorEvent(msg) ? msg.message : msg;
           let name;
-          if (isString(message)) {
-              const groups = message.match(ERROR_TYPES_RE);
-              if (groups) {
-                  name = groups[1];
-                  message = groups[2];
-              }
+          const groups = message.match(ERROR_TYPES_RE);
+          if (groups) {
+              name = groups[1];
+              message = groups[2];
           }
           const event = {
               exception: {
@@ -5826,12 +5858,15 @@ var Sentry = (function (exports) {
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       _domBreadcrumb(handlerData) {
           let target;
-          const keyAttr = typeof this._options.dom === 'object' ? this._options.dom.serializeAttribute : undefined;
+          let keyAttrs = typeof this._options.dom === 'object' ? this._options.dom.serializeAttribute : undefined;
+          if (typeof keyAttrs === 'string') {
+              keyAttrs = [keyAttrs];
+          }
           // Accessing event.target can throw (see getsentry/raven-js#838, #768)
           try {
               target = handlerData.event.target
-                  ? htmlTreeAsString(handlerData.event.target, keyAttr)
-                  : htmlTreeAsString(handlerData.event, keyAttr);
+                  ? htmlTreeAsString(handlerData.event.target, keyAttrs)
+                  : htmlTreeAsString(handlerData.event, keyAttrs);
           }
           catch (e) {
               target = '<unknown>';
@@ -6038,6 +6073,169 @@ var Sentry = (function (exports) {
    */
   UserAgent.id = 'UserAgent';
 
+  /** Deduplication filter */
+  class Dedupe {
+      constructor() {
+          /**
+           * @inheritDoc
+           */
+          this.name = Dedupe.id;
+      }
+      /**
+       * @inheritDoc
+       */
+      setupOnce(addGlobalEventProcessor, getCurrentHub) {
+          addGlobalEventProcessor((currentEvent) => {
+              const self = getCurrentHub().getIntegration(Dedupe);
+              if (self) {
+                  // Juuust in case something goes wrong
+                  try {
+                      if (self._shouldDropEvent(currentEvent, self._previousEvent)) {
+                          return null;
+                      }
+                  }
+                  catch (_oO) {
+                      return (self._previousEvent = currentEvent);
+                  }
+                  return (self._previousEvent = currentEvent);
+              }
+              return currentEvent;
+          });
+      }
+      /** JSDoc */
+      _shouldDropEvent(currentEvent, previousEvent) {
+          if (!previousEvent) {
+              return false;
+          }
+          if (this._isSameMessageEvent(currentEvent, previousEvent)) {
+              return true;
+          }
+          if (this._isSameExceptionEvent(currentEvent, previousEvent)) {
+              return true;
+          }
+          return false;
+      }
+      /** JSDoc */
+      _isSameMessageEvent(currentEvent, previousEvent) {
+          const currentMessage = currentEvent.message;
+          const previousMessage = previousEvent.message;
+          // If neither event has a message property, they were both exceptions, so bail out
+          if (!currentMessage && !previousMessage) {
+              return false;
+          }
+          // If only one event has a stacktrace, but not the other one, they are not the same
+          if ((currentMessage && !previousMessage) || (!currentMessage && previousMessage)) {
+              return false;
+          }
+          if (currentMessage !== previousMessage) {
+              return false;
+          }
+          if (!this._isSameFingerprint(currentEvent, previousEvent)) {
+              return false;
+          }
+          if (!this._isSameStacktrace(currentEvent, previousEvent)) {
+              return false;
+          }
+          return true;
+      }
+      /** JSDoc */
+      _getFramesFromEvent(event) {
+          const exception = event.exception;
+          if (exception) {
+              try {
+                  // @ts-ignore Object could be undefined
+                  return exception.values[0].stacktrace.frames;
+              }
+              catch (_oO) {
+                  return undefined;
+              }
+          }
+          else if (event.stacktrace) {
+              return event.stacktrace.frames;
+          }
+          return undefined;
+      }
+      /** JSDoc */
+      _isSameStacktrace(currentEvent, previousEvent) {
+          let currentFrames = this._getFramesFromEvent(currentEvent);
+          let previousFrames = this._getFramesFromEvent(previousEvent);
+          // If neither event has a stacktrace, they are assumed to be the same
+          if (!currentFrames && !previousFrames) {
+              return true;
+          }
+          // If only one event has a stacktrace, but not the other one, they are not the same
+          if ((currentFrames && !previousFrames) || (!currentFrames && previousFrames)) {
+              return false;
+          }
+          currentFrames = currentFrames;
+          previousFrames = previousFrames;
+          // If number of frames differ, they are not the same
+          if (previousFrames.length !== currentFrames.length) {
+              return false;
+          }
+          // Otherwise, compare the two
+          for (let i = 0; i < previousFrames.length; i++) {
+              const frameA = previousFrames[i];
+              const frameB = currentFrames[i];
+              if (frameA.filename !== frameB.filename ||
+                  frameA.lineno !== frameB.lineno ||
+                  frameA.colno !== frameB.colno ||
+                  frameA.function !== frameB.function) {
+                  return false;
+              }
+          }
+          return true;
+      }
+      /** JSDoc */
+      _getExceptionFromEvent(event) {
+          return event.exception && event.exception.values && event.exception.values[0];
+      }
+      /** JSDoc */
+      _isSameExceptionEvent(currentEvent, previousEvent) {
+          const previousException = this._getExceptionFromEvent(previousEvent);
+          const currentException = this._getExceptionFromEvent(currentEvent);
+          if (!previousException || !currentException) {
+              return false;
+          }
+          if (previousException.type !== currentException.type || previousException.value !== currentException.value) {
+              return false;
+          }
+          if (!this._isSameFingerprint(currentEvent, previousEvent)) {
+              return false;
+          }
+          if (!this._isSameStacktrace(currentEvent, previousEvent)) {
+              return false;
+          }
+          return true;
+      }
+      /** JSDoc */
+      _isSameFingerprint(currentEvent, previousEvent) {
+          let currentFingerprint = currentEvent.fingerprint;
+          let previousFingerprint = previousEvent.fingerprint;
+          // If neither event has a fingerprint, they are assumed to be the same
+          if (!currentFingerprint && !previousFingerprint) {
+              return true;
+          }
+          // If only one event has a fingerprint, but not the other one, they are not the same
+          if ((currentFingerprint && !previousFingerprint) || (!currentFingerprint && previousFingerprint)) {
+              return false;
+          }
+          currentFingerprint = currentFingerprint;
+          previousFingerprint = previousFingerprint;
+          // Otherwise, compare the two
+          try {
+              return !!(currentFingerprint.join('') === previousFingerprint.join(''));
+          }
+          catch (_oO) {
+              return false;
+          }
+      }
+  }
+  /**
+   * @inheritDoc
+   */
+  Dedupe.id = 'Dedupe';
+
 
 
   var BrowserIntegrations = /*#__PURE__*/Object.freeze({
@@ -6046,7 +6244,8 @@ var Sentry = (function (exports) {
     TryCatch: TryCatch,
     Breadcrumbs: Breadcrumbs,
     LinkedErrors: LinkedErrors,
-    UserAgent: UserAgent
+    UserAgent: UserAgent,
+    Dedupe: Dedupe
   });
 
   /**
@@ -6118,6 +6317,7 @@ var Sentry = (function (exports) {
       new Breadcrumbs(),
       new GlobalHandlers(),
       new LinkedErrors(),
+      new Dedupe(),
       new UserAgent(),
   ];
   /**