@sentry/browser 6.15.0 → 6.17.0

package/build/bundle.es6.js

@@ -1,43 +1,8 @@
-/*! @sentry/browser 6.15.0 (aa30ab6) | https://github.com/getsentry/sentry-javascript */
+/*! @sentry/browser 6.17.0 (ad2f4ad) | https://github.com/getsentry/sentry-javascript */
 var Sentry = (function (exports) {
-  /** Console logging verbosity for the SDK. */
-  var LogLevel;
-  (function (LogLevel) {
-      /** No logs will be generated. */
-      LogLevel[LogLevel["None"] = 0] = "None";
-      /** Only SDK internal errors will be logged. */
-      LogLevel[LogLevel["Error"] = 1] = "Error";
-      /** Information useful for debugging the SDK will be logged. */
-      LogLevel[LogLevel["Debug"] = 2] = "Debug";
-      /** All SDK actions will be logged. */
-      LogLevel[LogLevel["Verbose"] = 3] = "Verbose";
-  })(LogLevel || (LogLevel = {}));
-
   /**
-   * Session Status
+   * TODO(v7): Remove this enum and replace with SeverityLevel
    */
-  var SessionStatus;
-  (function (SessionStatus) {
-      /** JSDoc */
-      SessionStatus["Ok"] = "ok";
-      /** JSDoc */
-      SessionStatus["Exited"] = "exited";
-      /** JSDoc */
-      SessionStatus["Crashed"] = "crashed";
-      /** JSDoc */
-      SessionStatus["Abnormal"] = "abnormal";
-  })(SessionStatus || (SessionStatus = {}));
-  var RequestSessionStatus;
-  (function (RequestSessionStatus) {
-      /** JSDoc */
-      RequestSessionStatus["Ok"] = "ok";
-      /** JSDoc */
-      RequestSessionStatus["Errored"] = "errored";
-      /** JSDoc */
-      RequestSessionStatus["Crashed"] = "crashed";
-  })(RequestSessionStatus || (RequestSessionStatus = {}));
-
-  /** JSDoc */
   (function (Severity) {
       /** JSDoc */
       Severity["Fatal"] = "fatal";
@@ -54,95 +19,7 @@ var Sentry = (function (exports) {
       /** JSDoc */
       Severity["Critical"] = "critical";
   })(exports.Severity || (exports.Severity = {}));
-  // eslint-disable-next-line @typescript-eslint/no-namespace, import/export
-  (function (Severity) {
-      /**
-       * Converts a string-based level into a {@link Severity}.
-       *
-       * @param level string representation of Severity
-       * @returns Severity
-       */
-      function fromString(level) {
-          switch (level) {
-              case 'debug':
-                  return Severity.Debug;
-              case 'info':
-                  return Severity.Info;
-              case 'warn':
-              case 'warning':
-                  return Severity.Warning;
-              case 'error':
-                  return Severity.Error;
-              case 'fatal':
-                  return Severity.Fatal;
-              case 'critical':
-                  return Severity.Critical;
-              case 'log':
-              default:
-                  return Severity.Log;
-          }
-      }
-      Severity.fromString = fromString;
-  })(exports.Severity || (exports.Severity = {}));
-
-  /** The status of an event. */
-  (function (Status) {
-      /** The status could not be determined. */
-      Status["Unknown"] = "unknown";
-      /** The event was skipped due to configuration or callbacks. */
-      Status["Skipped"] = "skipped";
-      /** The event was sent to Sentry successfully. */
-      Status["Success"] = "success";
-      /** The client is currently rate limited and will try again later. */
-      Status["RateLimit"] = "rate_limit";
-      /** The event could not be processed. */
-      Status["Invalid"] = "invalid";
-      /** A server-side error occurred during submission. */
-      Status["Failed"] = "failed";
-  })(exports.Status || (exports.Status = {}));
-  // eslint-disable-next-line @typescript-eslint/no-namespace, import/export
-  (function (Status) {
-      /**
-       * Converts a HTTP status code into a {@link Status}.
-       *
-       * @param code The HTTP response status code.
-       * @returns The send status or {@link Status.Unknown}.
-       */
-      function fromHttpCode(code) {
-          if (code >= 200 && code < 300) {
-              return Status.Success;
-          }
-          if (code === 429) {
-              return Status.RateLimit;
-          }
-          if (code >= 400 && code < 500) {
-              return Status.Invalid;
-          }
-          if (code >= 500) {
-              return Status.Failed;
-          }
-          return Status.Unknown;
-      }
-      Status.fromHttpCode = fromHttpCode;
-  })(exports.Status || (exports.Status = {}));
-
-  var TransactionSamplingMethod;
-  (function (TransactionSamplingMethod) {
-      TransactionSamplingMethod["Explicit"] = "explicitly_set";
-      TransactionSamplingMethod["Sampler"] = "client_sampler";
-      TransactionSamplingMethod["Rate"] = "client_rate";
-      TransactionSamplingMethod["Inheritance"] = "inheritance";
-  })(TransactionSamplingMethod || (TransactionSamplingMethod = {}));
-
-  var Outcome;
-  (function (Outcome) {
-      Outcome["BeforeSend"] = "before_send";
-      Outcome["EventProcessor"] = "event_processor";
-      Outcome["NetworkError"] = "network_error";
-      Outcome["QueueOverflow"] = "queue_overflow";
-      Outcome["RateLimitBackoff"] = "ratelimit_backoff";
-      Outcome["SampleRate"] = "sample_rate";
-  })(Outcome || (Outcome = {}));
+  const SeverityLevels = ['fatal', 'error', 'warning', 'log', 'info', 'debug', 'critical'];
 
   /**
    * Consumes the promise and logs the error when it rejects.
@@ -157,6 +34,33 @@ var Sentry = (function (exports) {
       });
   }
 
+  /**
+   * This module mostly exists for optimizations in the build process
+   * through rollup and terser.  We define some global constants which
+   * are normally undefined.  However terser overrides these with global
+   * definitions which can be evaluated by the static analyzer when
+   * creating a bundle.
+   *
+   * In turn the `isDebugBuild` and `isBrowserBundle` functions are pure
+   * and can help us remove unused code from the bundles.
+   */
+  /**
+   * Figures out if we're building with debug functionality.
+   *
+   * @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.
@@ -167,7 +71,10 @@ var Sentry = (function (exports) {
    * @returns Answer to given question
    */
   function isNodeEnv() {
-      return Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';
+      // 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.
@@ -202,6 +109,8 @@ var Sentry = (function (exports) {
 
   /* eslint-disable @typescript-eslint/no-explicit-any */
   /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+  // eslint-disable-next-line @typescript-eslint/unbound-method
+  const objectToString = Object.prototype.toString;
   /**
    * Checks whether given value's type is one of a few Error or Error-like
    * {@link isError}.
@@ -210,17 +119,18 @@ var Sentry = (function (exports) {
    * @returns A boolean representing the result.
    */
   function isError(wat) {
-      switch (Object.prototype.toString.call(wat)) {
+      switch (objectToString.call(wat)) {
           case '[object Error]':
-              return true;
           case '[object Exception]':
-              return true;
           case '[object DOMException]':
               return true;
           default:
               return isInstanceOf(wat, Error);
       }
   }
+  function isBuiltin(wat, ty) {
+      return objectToString.call(wat) === `[object ${ty}]`;
+  }
   /**
    * Checks whether given value's type is ErrorEvent
    * {@link isErrorEvent}.
@@ -229,7 +139,7 @@ var Sentry = (function (exports) {
    * @returns A boolean representing the result.
    */
   function isErrorEvent(wat) {
-      return Object.prototype.toString.call(wat) === '[object ErrorEvent]';
+      return isBuiltin(wat, 'ErrorEvent');
   }
   /**
    * Checks whether given value's type is DOMError
@@ -239,7 +149,7 @@ var Sentry = (function (exports) {
    * @returns A boolean representing the result.
    */
   function isDOMError(wat) {
-      return Object.prototype.toString.call(wat) === '[object DOMError]';
+      return isBuiltin(wat, 'DOMError');
   }
   /**
    * Checks whether given value's type is DOMException
@@ -249,7 +159,7 @@ var Sentry = (function (exports) {
    * @returns A boolean representing the result.
    */
   function isDOMException(wat) {
-      return Object.prototype.toString.call(wat) === '[object DOMException]';
+      return isBuiltin(wat, 'DOMException');
   }
   /**
    * Checks whether given value's type is a string
@@ -259,10 +169,10 @@ var Sentry = (function (exports) {
    * @returns A boolean representing the result.
    */
   function isString(wat) {
-      return Object.prototype.toString.call(wat) === '[object String]';
+      return isBuiltin(wat, 'String');
   }
   /**
-   * Checks whether given value's is a primitive (undefined, null, number, boolean, string, bigint, symbol)
+   * Checks whether given value is a primitive (undefined, null, number, boolean, string, bigint, symbol)
    * {@link isPrimitive}.
    *
    * @param wat A value to be checked.
@@ -279,7 +189,7 @@ var Sentry = (function (exports) {
    * @returns A boolean representing the result.
    */
   function isPlainObject(wat) {
-      return Object.prototype.toString.call(wat) === '[object Object]';
+      return isBuiltin(wat, 'Object');
   }
   /**
    * Checks whether given value's type is an Event instance
@@ -309,7 +219,7 @@ var Sentry = (function (exports) {
    * @returns A boolean representing the result.
    */
   function isRegExp(wat) {
-      return Object.prototype.toString.call(wat) === '[object RegExp]';
+      return isBuiltin(wat, 'RegExp');
   }
   /**
    * Checks whether given value has a then function.
@@ -393,7 +303,6 @@ var Sentry = (function (exports) {
    * @returns generated DOM path
    */
   function _htmlElementAsString(el, keyAttrs) {
-      var _a, _b;
       const elem = el;
       const out = [];
       let className;
@@ -406,9 +315,10 @@ var Sentry = (function (exports) {
       }
       out.push(elem.tagName.toLowerCase());
       // 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)])
+      const keyAttrPairs = keyAttrs && keyAttrs.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) {
+      if (keyAttrPairs && keyAttrPairs.length) {
           keyAttrPairs.forEach(keyAttrPair => {
               out.push(`[${keyAttrPair[0]}="${keyAttrPair[1]}"]`);
           });
@@ -485,88 +395,87 @@ var Sentry = (function (exports) {
 
   /** Regular expression used to parse a Dsn. */
   const DSN_REGEX = /^(?:(\w+):)\/\/(?:(\w+)(?::(\w+))?@)([\w.-]+)(?::(\d+))?\/(.+)/;
-  /** Error message */
-  const ERROR_MESSAGE = 'Invalid Dsn';
-  /** The Sentry Dsn, identifying a Sentry instance and project. */
-  class Dsn {
-      /** Creates a new Dsn component */
-      constructor(from) {
-          if (typeof from === 'string') {
-              this._fromString(from);
-          }
-          else {
-              this._fromComponents(from);
-          }
-          this._validate();
+  function isValidProtocol(protocol) {
+      return protocol === 'http' || protocol === 'https';
+  }
+  /**
+   * Renders the string representation of this Dsn.
+   *
+   * By default, this will render the public representation without the password
+   * component. To get the deprecated private representation, set `withPassword`
+   * to true.
+   *
+   * @param withPassword When set to true, the password will be included.
+   */
+  function dsnToString(dsn, withPassword = false) {
+      const { host, path, pass, port, projectId, protocol, publicKey } = dsn;
+      return (`${protocol}://${publicKey}${withPassword && pass ? `:${pass}` : ''}` +
+          `@${host}${port ? `:${port}` : ''}/${path ? `${path}/` : path}${projectId}`);
+  }
+  function dsnFromString(str) {
+      const match = DSN_REGEX.exec(str);
+      if (!match) {
+          throw new SentryError(`Invalid Sentry Dsn: ${str}`);
       }
-      /**
-       * Renders the string representation of this Dsn.
-       *
-       * By default, this will render the public representation without the password
-       * component. To get the deprecated private representation, set `withPassword`
-       * to true.
-       *
-       * @param withPassword When set to true, the password will be included.
-       */
-      toString(withPassword = false) {
-          const { host, path, pass, port, projectId, protocol, publicKey } = this;
-          return (`${protocol}://${publicKey}${withPassword && pass ? `:${pass}` : ''}` +
-              `@${host}${port ? `:${port}` : ''}/${path ? `${path}/` : path}${projectId}`);
-      }
-      /** Parses a string into this Dsn. */
-      _fromString(str) {
-          const match = DSN_REGEX.exec(str);
-          if (!match) {
-              throw new SentryError(ERROR_MESSAGE);
-          }
-          const [protocol, publicKey, pass = '', host, port = '', lastPath] = match.slice(1);
-          let path = '';
-          let projectId = lastPath;
-          const split = projectId.split('/');
-          if (split.length > 1) {
-              path = split.slice(0, -1).join('/');
-              projectId = split.pop();
-          }
-          if (projectId) {
-              const projectMatch = projectId.match(/^\d+/);
-              if (projectMatch) {
-                  projectId = projectMatch[0];
-              }
-          }
-          this._fromComponents({ host, pass, path, projectId, port, protocol: protocol, publicKey });
-      }
-      /** Maps Dsn components into this instance. */
-      _fromComponents(components) {
-          // TODO this is for backwards compatibility, and can be removed in a future version
-          if ('user' in components && !('publicKey' in components)) {
-              components.publicKey = components.user;
-          }
-          this.user = components.publicKey || '';
-          this.protocol = components.protocol;
-          this.publicKey = components.publicKey || '';
-          this.pass = components.pass || '';
-          this.host = components.host;
-          this.port = components.port || '';
-          this.path = components.path || '';
-          this.projectId = components.projectId;
-      }
-      /** Validates this Dsn and throws on error. */
-      _validate() {
-          ['protocol', 'publicKey', 'host', 'projectId'].forEach(component => {
-              if (!this[component]) {
-                  throw new SentryError(`${ERROR_MESSAGE}: ${component} missing`);
-              }
-          });
-          if (!this.projectId.match(/^\d+$/)) {
-              throw new SentryError(`${ERROR_MESSAGE}: Invalid projectId ${this.projectId}`);
-          }
-          if (this.protocol !== 'http' && this.protocol !== 'https') {
-              throw new SentryError(`${ERROR_MESSAGE}: Invalid protocol ${this.protocol}`);
+      const [protocol, publicKey, pass = '', host, port = '', lastPath] = match.slice(1);
+      let path = '';
+      let projectId = lastPath;
+      const split = projectId.split('/');
+      if (split.length > 1) {
+          path = split.slice(0, -1).join('/');
+          projectId = split.pop();
+      }
+      if (projectId) {
+          const projectMatch = projectId.match(/^\d+/);
+          if (projectMatch) {
+              projectId = projectMatch[0];
           }
-          if (this.port && isNaN(parseInt(this.port, 10))) {
-              throw new SentryError(`${ERROR_MESSAGE}: Invalid port ${this.port}`);
+      }
+      return dsnFromComponents({ host, pass, path, projectId, port, protocol: protocol, publicKey });
+  }
+  function dsnFromComponents(components) {
+      // TODO this is for backwards compatibility, and can be removed in a future version
+      if ('user' in components && !('publicKey' in components)) {
+          components.publicKey = components.user;
+      }
+      return {
+          user: components.publicKey || '',
+          protocol: components.protocol,
+          publicKey: components.publicKey || '',
+          pass: components.pass || '',
+          host: components.host,
+          port: components.port || '',
+          path: components.path || '',
+          projectId: components.projectId,
+      };
+  }
+  function validateDsn(dsn) {
+      if (!isDebugBuild()) {
+          return;
+      }
+      const { port, projectId, protocol } = dsn;
+      const requiredComponents = ['protocol', 'publicKey', 'host', 'projectId'];
+      requiredComponents.forEach(component => {
+          if (!dsn[component]) {
+              throw new SentryError(`Invalid Sentry Dsn: ${component} missing`);
           }
+      });
+      if (!projectId.match(/^\d+$/)) {
+          throw new SentryError(`Invalid Sentry Dsn: Invalid projectId ${projectId}`);
+      }
+      if (!isValidProtocol(protocol)) {
+          throw new SentryError(`Invalid Sentry Dsn: Invalid protocol ${protocol}`);
+      }
+      if (port && isNaN(parseInt(port, 10))) {
+          throw new SentryError(`Invalid Sentry Dsn: Invalid port ${port}`);
       }
+      return true;
+  }
+  /** The Sentry Dsn, identifying a Sentry instance and project. */
+  function makeDsn(from) {
+      const components = typeof from === 'string' ? dsnFromString(from) : dsnFromComponents(from);
+      validateDsn(components);
+      return components;
   }
 
   // TODO: Implement different loggers for different environments
@@ -653,54 +562,44 @@ var Sentry = (function (exports) {
 
   /* eslint-disable @typescript-eslint/no-unsafe-member-access */
   /* eslint-disable @typescript-eslint/no-explicit-any */
-  /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
   /**
-   * Memo class used for decycle json objects. Uses WeakSet if available otherwise array.
+   * Helper to decycle json objects
    */
-  class Memo {
-      constructor() {
-          this._hasWeakSet = typeof WeakSet === 'function';
-          this._inner = this._hasWeakSet ? new WeakSet() : [];
-      }
-      /**
-       * Sets obj to remember.
-       * @param obj Object to remember
-       */
-      memoize(obj) {
-          if (this._hasWeakSet) {
-              if (this._inner.has(obj)) {
+  function memoBuilder() {
+      const hasWeakSet = typeof WeakSet === 'function';
+      const inner = hasWeakSet ? new WeakSet() : [];
+      function memoize(obj) {
+          if (hasWeakSet) {
+              if (inner.has(obj)) {
                   return true;
               }
-              this._inner.add(obj);
+              inner.add(obj);
               return false;
           }
           // eslint-disable-next-line @typescript-eslint/prefer-for-of
-          for (let i = 0; i < this._inner.length; i++) {
-              const value = this._inner[i];
+          for (let i = 0; i < inner.length; i++) {
+              const value = inner[i];
               if (value === obj) {
                   return true;
               }
           }
-          this._inner.push(obj);
+          inner.push(obj);
           return false;
       }
-      /**
-       * Removes object from internal storage.
-       * @param obj Object to forget
-       */
-      unmemoize(obj) {
-          if (this._hasWeakSet) {
-              this._inner.delete(obj);
+      function unmemoize(obj) {
+          if (hasWeakSet) {
+              inner.delete(obj);
           }
           else {
-              for (let i = 0; i < this._inner.length; i++) {
-                  if (this._inner[i] === obj) {
-                      this._inner.splice(i, 1);
+              for (let i = 0; i < inner.length; i++) {
+                  if (inner[i] === obj) {
+                      inner.splice(i, 1);
                       break;
                   }
               }
           }
       }
+      return [memoize, unmemoize];
   }
 
   const defaultFunctionName = '<anonymous>';
@@ -797,13 +696,7 @@ var Sentry = (function (exports) {
       // otherwise it'll throw "TypeError: Object.defineProperties called on non-object"
       if (typeof wrapped === 'function') {
           try {
-              wrapped.prototype = wrapped.prototype || {};
-              Object.defineProperties(wrapped, {
-                  __sentry_original__: {
-                      enumerable: false,
-                      value: original,
-                  },
-              });
+              markFunctionWrapped(wrapped, original);
           }
           catch (_Oo) {
               // This can throw if multiple fill happens on a global object like XMLHttpRequest
@@ -812,6 +705,41 @@ var Sentry = (function (exports) {
       }
       source[name] = wrapped;
   }
+  /**
+   * Defines a non enumerable property.  This creates a non enumerable property on an 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
+   */
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  function addNonEnumerableProperty(func, name, value) {
+      Object.defineProperty(func, name, {
+          value: value,
+      });
+  }
+  /**
+   * Remembers the original function on the wrapped function and
+   * patches up the prototype.
+   *
+   * @param wrapped the wrapper function
+   * @param original the original function that gets wrapped
+   */
+  function markFunctionWrapped(wrapped, original) {
+      const proto = original.prototype || {};
+      wrapped.prototype = original.prototype = proto;
+      addNonEnumerableProperty(wrapped, '__sentry_original__', original);
+  }
+  /**
+   * This extracts the original function if available.  See
+   * `markFunctionWrapped` for more information.
+   *
+   * @param func the function to unwrap
+   * @returns the unwrapped version of the function if available.
+   */
+  function getOriginalFunction(func) {
+      return func.__sentry_original__;
+  }
   /**
    * Encodes given object into url-friendly format
    *
@@ -910,11 +838,11 @@ var Sentry = (function (exports) {
    *  unchanged.
    */
   function serializeValue(value) {
-      const type = Object.prototype.toString.call(value);
       // Node.js REPL notation
       if (typeof value === 'string') {
           return value;
       }
+      const type = Object.prototype.toString.call(value);
       if (type === '[object Object]') {
           return '[Object]';
       }
@@ -984,8 +912,8 @@ var Sentry = (function (exports) {
    * @param memo Optional Memo class handling decycling
    */
   // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-  function walk(key, value, depth = +Infinity, memo = new Memo()) {
-      // If we reach the maximum depth, serialize whatever has left
+  function walk(key, value, depth = +Infinity, memo = memoBuilder()) {
+      // If we reach the maximum depth, serialize whatever is left
       if (depth === 0) {
           return serializeValue(value);
       }
@@ -995,17 +923,18 @@ var Sentry = (function (exports) {
           return value.toJSON();
       }
       /* eslint-enable @typescript-eslint/no-unsafe-member-access */
-      // If normalized value is a primitive, there are no branches left to walk, so we can just bail out, as theres no point in going down that branch any further
+      // If normalized value is a primitive, there are no branches left to walk, so bail out
       const normalized = normalizeValue(value, key);
       if (isPrimitive(normalized)) {
           return normalized;
       }
-      // Create source that we will use for next itterations, either objectified error object (Error type with extracted keys:value pairs) or the input itself
+      // Create source that we will use for the next iteration. It will either be an objectified error object (`Error` type
+      // with extracted key:value pairs) or the input itself.
       const source = getWalkSource(value);
       // Create an accumulator that will act as a parent for all future itterations of that branch
       const acc = Array.isArray(value) ? [] : {};
       // If we already walked that branch, bail out, as it's circular reference
-      if (memo.memoize(value)) {
+      if (memo[0](value)) {
           return '[Circular ~]';
       }
       // Walk all keys of the source
@@ -1018,7 +947,7 @@ var Sentry = (function (exports) {
           acc[innerKey] = walk(innerKey, source[innerKey], depth - 1, memo);
       }
       // Once walked through all the branches, remove the parent from memo storage
-      memo.unmemoize(value);
+      memo[1](value);
       // Return accumulated values
       return acc;
   }
@@ -1151,7 +1080,9 @@ var Sentry = (function (exports) {
               doc.head.removeChild(sandbox);
           }
           catch (err) {
-              logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);
+              if (isDebugBuild()) {
+                  logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);
+              }
           }
       }
       return result;
@@ -1163,9 +1094,9 @@ var Sentry = (function (exports) {
    * @returns Answer to the given question.
    */
   function supportsReferrerPolicy() {
-      // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default
-      // https://caniuse.com/#feat=referrer-policy
-      // It doesn't. And it throw exception instead of ignoring this parameter...
+      // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default'
+      // (see https://caniuse.com/#feat=referrer-policy),
+      // it doesn't. And it throws an exception instead of ignoring this parameter...
       // REF: https://github.com/getsentry/raven-js/issues/1233
       if (!supportsFetch()) {
           return false;
@@ -1250,13 +1181,10 @@ var Sentry = (function (exports) {
    * Use at your own risk, this might break without changelog notice, only used internally.
    * @hidden
    */
-  function addInstrumentationHandler(handler) {
-      if (!handler || typeof handler.type !== 'string' || typeof handler.callback !== 'function') {
-          return;
-      }
-      handlers[handler.type] = handlers[handler.type] || [];
-      handlers[handler.type].push(handler.callback);
-      instrument(handler.type);
+  function addInstrumentationHandler(type, callback) {
+      handlers[type] = handlers[type] || [];
+      handlers[type].push(callback);
+      instrument(type);
   }
   /** JSDoc */
   function triggerHandlers(type, data) {
@@ -1268,7 +1196,9 @@ var Sentry = (function (exports) {
               handler(data);
           }
           catch (e) {
-              logger.error(`Error while triggering instrumentation handler.\nType: ${type}\nName: ${getFunctionName(handler)}\nError: ${e}`);
+              if (isDebugBuild()) {
+                  logger.error(`Error while triggering instrumentation handler.\nType: ${type}\nName: ${getFunctionName(handler)}\nError: ${e}`);
+              }
           }
       }
   }
@@ -1349,23 +1279,20 @@ var Sentry = (function (exports) {
       if (!('XMLHttpRequest' in global$2)) {
           return;
       }
-      // Poor man's implementation of ES6 `Map`, tracking and keeping in sync key and value separately.
-      const requestKeys = [];
-      const requestValues = [];
       const xhrproto = XMLHttpRequest.prototype;
       fill(xhrproto, 'open', function (originalOpen) {
           return function (...args) {
               // eslint-disable-next-line @typescript-eslint/no-this-alias
               const xhr = this;
               const url = args[1];
-              xhr.__sentry_xhr__ = {
+              const xhrInfo = (xhr.__sentry_xhr__ = {
                   // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
                   method: isString(args[0]) ? args[0].toUpperCase() : args[0],
                   url: args[1],
-              };
+              });
               // if Sentry key appears in URL, don't capture it as a request
               // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-              if (isString(url) && xhr.__sentry_xhr__.method === 'POST' && url.match(/sentry_key/)) {
+              if (isString(url) && xhrInfo.method === 'POST' && url.match(/sentry_key/)) {
                   xhr.__sentry_own_request__ = true;
               }
               const onreadystatechangeHandler = function () {
@@ -1373,23 +1300,7 @@ var Sentry = (function (exports) {
                       try {
                           // touching statusCode in some platforms throws
                           // an exception
-                          if (xhr.__sentry_xhr__) {
-                              xhr.__sentry_xhr__.status_code = xhr.status;
-                          }
-                      }
-                      catch (e) {
-                          /* do nothing */
-                      }
-                      try {
-                          const requestPos = requestKeys.indexOf(xhr);
-                          if (requestPos !== -1) {
-                              // Make sure to pop both key and value to keep it in sync.
-                              requestKeys.splice(requestPos);
-                              const args = requestValues.splice(requestPos)[0];
-                              if (xhr.__sentry_xhr__ && args[0] !== undefined) {
-                                  xhr.__sentry_xhr__.body = args[0];
-                              }
-                          }
+                          xhrInfo.status_code = xhr.status;
                       }
                       catch (e) {
                           /* do nothing */
@@ -1418,8 +1329,9 @@ var Sentry = (function (exports) {
       });
       fill(xhrproto, 'send', function (originalSend) {
           return function (...args) {
-              requestKeys.push(this);
-              requestValues.push(args);
+              if (this.__sentry_xhr__ && args[0] !== undefined) {
+                  this.__sentry_xhr__.body = args[0];
+              }
               triggerHandlers('xhr', {
                   args,
                   startTimestamp: Date.now(),
@@ -1754,22 +1666,26 @@ var Sentry = (function (exports) {
           relative: match[5] + query + fragment,
       };
   }
+  function getFirstException(event) {
+      return event.exception && event.exception.values ? event.exception.values[0] : undefined;
+  }
   /**
    * Extracts either message or type+value from an event that can be used for user-facing logs
    * @returns event's description
    */
   function getEventDescription(event) {
-      if (event.message) {
-          return event.message;
+      const { message, event_id: eventId } = event;
+      if (message) {
+          return message;
       }
-      if (event.exception && event.exception.values && event.exception.values[0]) {
-          const exception = event.exception.values[0];
-          if (exception.type && exception.value) {
-              return `${exception.type}: ${exception.value}`;
+      const firstException = getFirstException(event);
+      if (firstException) {
+          if (firstException.type && firstException.value) {
+              return `${firstException.type}: ${firstException.value}`;
           }
-          return exception.type || exception.value || event.event_id || '<unknown>';
+          return firstException.type || firstException.value || eventId || '<unknown>';
       }
-      return event.event_id || '<unknown>';
+      return eventId || '<unknown>';
   }
   /**
    * Adds exception values, type and value to an synthetic Exception.
@@ -1779,11 +1695,15 @@ var Sentry = (function (exports) {
    * @hidden
    */
   function addExceptionTypeValue(event, value, type) {
-      event.exception = event.exception || {};
-      event.exception.values = event.exception.values || [];
-      event.exception.values[0] = event.exception.values[0] || {};
-      event.exception.values[0].value = event.exception.values[0].value || value || '';
-      event.exception.values[0].type = event.exception.values[0].type || type || 'Error';
+      const exception = (event.exception = event.exception || {});
+      const values = (exception.values = exception.values || []);
+      const firstException = (values[0] = values[0] || {});
+      if (!firstException.value) {
+          firstException.value = value || '';
+      }
+      if (!firstException.type) {
+          firstException.type = type || 'Error';
+      }
   }
   /**
    * Adds exception mechanism data to a given event. Uses defaults if the second parameter is not passed.
@@ -1793,17 +1713,16 @@ var Sentry = (function (exports) {
    * @hidden
    */
   function addExceptionMechanism(event, newMechanism) {
-      var _a;
-      if (!event.exception || !event.exception.values) {
+      const firstException = getFirstException(event);
+      if (!firstException) {
           return;
       }
-      const exceptionValue0 = event.exception.values[0];
       const defaultMechanism = { type: 'generic', handled: true };
-      const currentMechanism = exceptionValue0.mechanism;
-      exceptionValue0.mechanism = Object.assign(Object.assign(Object.assign({}, defaultMechanism), currentMechanism), newMechanism);
+      const currentMechanism = firstException.mechanism;
+      firstException.mechanism = Object.assign(Object.assign(Object.assign({}, defaultMechanism), currentMechanism), newMechanism);
       if (newMechanism && 'data' in newMechanism) {
-          const mergedData = Object.assign(Object.assign({}, (_a = currentMechanism) === null || _a === void 0 ? void 0 : _a.data), newMechanism.data);
-          exceptionValue0.mechanism.data = mergedData;
+          const mergedData = Object.assign(Object.assign({}, (currentMechanism && currentMechanism.data)), newMechanism.data);
+          firstException.mechanism.data = mergedData;
       }
   }
   const defaultRetryAfter = 60 * 1000; // 60 seconds
@@ -1848,17 +1767,14 @@ var Sentry = (function (exports) {
    * @returns `true` if the exception has already been captured, `false` if not (with the side effect of marking it seen)
    */
   function checkOrSetAlreadyCaught(exception) {
-      var _a;
       // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-      if ((_a = exception) === null || _a === void 0 ? void 0 : _a.__sentry_captured__) {
+      if (exception && exception.__sentry_captured__) {
           return true;
       }
       try {
           // set it this way rather than by assignment so that it's not ennumerable and therefore isn't recorded by the
           // `ExtraErrorData` integration
-          Object.defineProperty(exception, '__sentry_captured__', {
-              value: true,
-          });
+          addNonEnumerableProperty(exception, '__sentry_captured__', true);
       }
       catch (err) {
           // `exception` is a primitive, so we can't mark it seen
@@ -1867,35 +1783,47 @@ 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 = {}));
+  /**
+   * Creates a resolved sync promise.
+   *
+   * @param value the value to resolve the promise with
+   * @returns the resolved sync promise
+   */
+  function resolvedSyncPromise(value) {
+      return new SyncPromise(resolve => {
+          resolve(value);
+      });
+  }
+  /**
+   * Creates a rejected sync promise.
+   *
+   * @param value the value to reject the promise with
+   * @returns the rejected sync promise
+   */
+  function rejectedSyncPromise(reason) {
+      return new SyncPromise((_, reject) => {
+          reject(reason);
+      });
+  }
   /**
    * 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 = 0 /* PENDING */;
           this._handlers = [];
           /** JSDoc */
           this._resolve = (value) => {
-              this._setResult(States.RESOLVED, value);
+              this._setResult(1 /* RESOLVED */, value);
           };
           /** JSDoc */
           this._reject = (reason) => {
-              this._setResult(States.REJECTED, reason);
+              this._setResult(2 /* REJECTED */, reason);
           };
           /** JSDoc */
           this._setResult = (state, value) => {
-              if (this._state !== States.PENDING) {
+              if (this._state !== 0 /* PENDING */) {
                   return;
               }
               if (isThenable(value)) {
@@ -1906,35 +1834,25 @@ var Sentry = (function (exports) {
               this._value = value;
               this._executeHandlers();
           };
-          // TODO: FIXME
-          /** JSDoc */
-          this._attachHandler = (handler) => {
-              this._handlers = this._handlers.concat(handler);
-              this._executeHandlers();
-          };
           /** JSDoc */
           this._executeHandlers = () => {
-              if (this._state === States.PENDING) {
+              if (this._state === 0 /* PENDING */) {
                   return;
               }
               const cachedHandlers = this._handlers.slice();
               this._handlers = [];
               cachedHandlers.forEach(handler => {
-                  if (handler.done) {
+                  if (handler[0]) {
                       return;
                   }
-                  if (this._state === States.RESOLVED) {
-                      if (handler.onfulfilled) {
-                          // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                          handler.onfulfilled(this._value);
-                      }
+                  if (this._state === 1 /* RESOLVED */) {
+                      // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                      handler[1](this._value);
                   }
-                  if (this._state === States.REJECTED) {
-                      if (handler.onrejected) {
-                          handler.onrejected(this._value);
-                      }
+                  if (this._state === 2 /* REJECTED */) {
+                      handler[2](this._value);
                   }
-                  handler.done = true;
+                  handler[0] = true;
               });
           };
           try {
@@ -1945,80 +1863,40 @@ var Sentry = (function (exports) {
           }
       }
       /** JSDoc */
-      static resolve(value) {
-          return new SyncPromise(resolve => {
-              resolve(value);
-          });
-      }
-      /** JSDoc */
-      static reject(reason) {
-          return new SyncPromise((_, reject) => {
-              reject(reason);
-          });
-      }
-      /** JSDoc */
-      static all(collection) {
-          return new SyncPromise((resolve, reject) => {
-              if (!Array.isArray(collection)) {
-                  reject(new TypeError(`Promise.all requires an array as input.`));
-                  return;
-              }
-              if (collection.length === 0) {
-                  resolve([]);
-                  return;
-              }
-              let counter = collection.length;
-              const resolvedCollection = [];
-              collection.forEach((item, index) => {
-                  void SyncPromise.resolve(item)
-                      .then(value => {
-                      resolvedCollection[index] = value;
-                      counter -= 1;
-                      if (counter !== 0) {
-                          return;
-                      }
-                      resolve(resolvedCollection);
-                  })
-                      .then(null, reject);
-              });
-          });
-      }
-      /** JSDoc */
       then(onfulfilled, onrejected) {
           return new SyncPromise((resolve, reject) => {
-              this._attachHandler({
-                  done: false,
-                  onfulfilled: result => {
+              this._handlers.push([
+                  false,
+                  result => {
                       if (!onfulfilled) {
                           // TODO: ¯\_(ツ)_/¯
                           // TODO: FIXME
                           resolve(result);
-                          return;
-                      }
-                      try {
-                          resolve(onfulfilled(result));
-                          return;
                       }
-                      catch (e) {
-                          reject(e);
-                          return;
+                      else {
+                          try {
+                              resolve(onfulfilled(result));
+                          }
+                          catch (e) {
+                              reject(e);
+                          }
                       }
                   },
-                  onrejected: reason => {
+                  reason => {
                       if (!onrejected) {
                           reject(reason);
-                          return;
                       }
-                      try {
-                          resolve(onrejected(reason));
-                          return;
-                      }
-                      catch (e) {
-                          reject(e);
-                          return;
+                      else {
+                          try {
+                              resolve(onrejected(reason));
+                          }
+                          catch (e) {
+                              reject(e);
+                          }
                       }
                   },
-              });
+              ]);
+              this._executeHandlers();
           });
       }
       /** JSDoc */
@@ -2051,24 +1929,25 @@ var Sentry = (function (exports) {
               });
           });
       }
-      /** JSDoc */
-      toString() {
-          return '[object SyncPromise]';
-      }
   }
 
-  /** A simple queue that holds promises. */
-  class PromiseBuffer {
-      constructor(_limit) {
-          this._limit = _limit;
-          /** Internal set of queued Promises */
-          this._buffer = [];
+  /**
+   * Creates an new PromiseBuffer object with the specified limit
+   * @param limit max number of promises that can be stored in the buffer
+   */
+  function makePromiseBuffer(limit) {
+      const buffer = [];
+      function isReady() {
+          return limit === undefined || buffer.length < limit;
       }
       /**
-       * Says if the buffer is ready to take more requests
+       * Remove a promise from the queue.
+       *
+       * @param task Can be any PromiseLike<T>
+       * @returns Removed promise.
        */
-      isReady() {
-          return this._limit === undefined || this.length() < this._limit;
+      function remove(task) {
+          return buffer.splice(buffer.indexOf(task), 1)[0];
       }
       /**
        * Add a promise (representing an in-flight action) to the queue, and set it to remove itself on fulfillment.
@@ -2080,41 +1959,25 @@ var Sentry = (function (exports) {
        *        limit check.
        * @returns The original promise.
        */
-      add(taskProducer) {
-          if (!this.isReady()) {
-              return SyncPromise.reject(new SentryError('Not adding Promise due to buffer limit reached.'));
+      function add(taskProducer) {
+          if (!isReady()) {
+              return rejectedSyncPromise(new SentryError('Not adding Promise due to buffer limit reached.'));
           }
           // start the task and add its promise to the queue
           const task = taskProducer();
-          if (this._buffer.indexOf(task) === -1) {
-              this._buffer.push(task);
+          if (buffer.indexOf(task) === -1) {
+              buffer.push(task);
           }
           void task
-              .then(() => this.remove(task))
+              .then(() => remove(task))
               // Use `then(null, rejectionHandler)` rather than `catch(rejectionHandler)` so that we can use `PromiseLike`
               // rather than `Promise`. `PromiseLike` doesn't have a `.catch` method, making its polyfill smaller. (ES5 didn't
               // have promises, so TS has to polyfill when down-compiling.)
-              .then(null, () => this.remove(task).then(null, () => {
-              // We have to add another catch here because `this.remove()` starts a new promise chain.
+              .then(null, () => remove(task).then(null, () => {
+              // We have to add another catch here because `remove()` starts a new promise chain.
           }));
           return task;
       }
-      /**
-       * Remove a promise from the queue.
-       *
-       * @param task Can be any PromiseLike<T>
-       * @returns Removed promise.
-       */
-      remove(task) {
-          const removedTask = this._buffer.splice(this._buffer.indexOf(task), 1)[0];
-          return removedTask;
-      }
-      /**
-       * This function returns the number of unresolved promises in the queue.
-       */
-      length() {
-          return this._buffer.length;
-      }
       /**
        * Wait for all promises in the queue to resolve or for timeout to expire, whichever comes first.
        *
@@ -2124,8 +1987,12 @@ var Sentry = (function (exports) {
        * @returns A promise which will resolve to `true` if the queue is already empty or drains before the timeout, and
        * `false` otherwise
        */
-      drain(timeout) {
-          return new SyncPromise(resolve => {
+      function drain(timeout) {
+          return new SyncPromise((resolve, reject) => {
+              let counter = buffer.length;
+              if (!counter) {
+                  return resolve(true);
+              }
               // wait for `timeout` ms and then resolve to `false` (if not cancelled first)
               const capturedSetTimeout = setTimeout(() => {
                   if (timeout && timeout > 0) {
@@ -2133,16 +2000,62 @@ var Sentry = (function (exports) {
                   }
               }, timeout);
               // if all promises resolve in time, cancel the timer and resolve to `true`
-              void SyncPromise.all(this._buffer)
-                  .then(() => {
-                  clearTimeout(capturedSetTimeout);
-                  resolve(true);
-              })
-                  .then(null, () => {
-                  resolve(true);
+              buffer.forEach(item => {
+                  void resolvedSyncPromise(item).then(() => {
+                      // eslint-disable-next-line no-plusplus
+                      if (!--counter) {
+                          clearTimeout(capturedSetTimeout);
+                          resolve(true);
+                      }
+                  }, reject);
               });
           });
       }
+      return {
+          $: buffer,
+          add,
+          drain,
+      };
+  }
+
+  function isSupportedSeverity(level) {
+      return SeverityLevels.indexOf(level) !== -1;
+  }
+  /**
+   * Converts a string-based level into a {@link Severity}.
+   *
+   * @param level string representation of Severity
+   * @returns Severity
+   */
+  function severityFromString(level) {
+      if (level === 'warn')
+          return exports.Severity.Warning;
+      if (isSupportedSeverity(level)) {
+          return level;
+      }
+      return exports.Severity.Log;
+  }
+
+  /**
+   * Converts an HTTP status code to sentry status {@link EventStatus}.
+   *
+   * @param code number HTTP status code
+   * @returns EventStatus
+   */
+  function eventStatusFromHttpCode(code) {
+      if (code >= 200 && code < 300) {
+          return 'success';
+      }
+      if (code === 429) {
+          return 'rate_limit';
+      }
+      if (code >= 400 && code < 500) {
+          return 'invalid';
+      }
+      if (code >= 500) {
+          return 'failed';
+      }
+      return 'unknown';
   }
 
   /**
@@ -2301,6 +2214,11 @@ var Sentry = (function (exports) {
           this._extra = {};
           /** Contexts */
           this._contexts = {};
+          /**
+           * A place to stash data which is needed at some point in the SDK's event processing pipeline but which shouldn't get
+           * sent to Sentry
+           */
+          this._sdkProcessingMetadata = {};
       }
       /**
        * Inherit values from the parent scope.
@@ -2463,19 +2381,10 @@ var Sentry = (function (exports) {
        * @inheritDoc
        */
       getTransaction() {
-          var _a, _b, _c, _d;
-          // often, this span will be a transaction, but it's not guaranteed to be
+          // Often, this span (if it exists at all) will be a transaction, but it's not guaranteed to be. Regardless, it will
+          // have a pointer to the currently-active transaction.
           const span = this.getSpan();
-          // try it the new way first
-          if ((_a = span) === null || _a === void 0 ? void 0 : _a.transaction) {
-              return (_b = span) === null || _b === void 0 ? void 0 : _b.transaction;
-          }
-          // fallback to the old way (known bug: this only finds transactions with sampled = true)
-          if ((_d = (_c = span) === null || _c === void 0 ? void 0 : _c.spanRecorder) === null || _d === void 0 ? void 0 : _d.spans[0]) {
-              return span.spanRecorder.spans[0];
-          }
-          // neither way found a transaction
-          return undefined;
+          return span && span.transaction;
       }
       /**
        * @inheritDoc
@@ -2594,7 +2503,6 @@ var Sentry = (function (exports) {
        * @hidden
        */
       applyToEvent(event, hint) {
-          var _a;
           if (this._extra && Object.keys(this._extra).length) {
               event.extra = Object.assign(Object.assign({}, this._extra), event.extra);
           }
@@ -2618,7 +2526,7 @@ var Sentry = (function (exports) {
           // errors with transaction and it relies on that.
           if (this._span) {
               event.contexts = Object.assign({ trace: this._span.getTraceContext() }, event.contexts);
-              const transactionName = (_a = this._span.transaction) === null || _a === void 0 ? void 0 : _a.name;
+              const transactionName = this._span.transaction && this._span.transaction.name;
               if (transactionName) {
                   event.tags = Object.assign({ transaction: transactionName }, event.tags);
               }
@@ -2626,8 +2534,16 @@ var Sentry = (function (exports) {
           this._applyFingerprint(event);
           event.breadcrumbs = [...(event.breadcrumbs || []), ...this._breadcrumbs];
           event.breadcrumbs = event.breadcrumbs.length > 0 ? event.breadcrumbs : undefined;
+          event.sdkProcessingMetadata = this._sdkProcessingMetadata;
           return this._notifyEventProcessors([...getGlobalEventProcessors(), ...this._eventProcessors], event, hint);
       }
+      /**
+       * Add data which will be accessible during event processing but won't get sent to Sentry
+       */
+      setSDKProcessingMetadata(newData) {
+          this._sdkProcessingMetadata = Object.assign(Object.assign({}, this._sdkProcessingMetadata), newData);
+          return this;
+      }
       /**
        * This will be called after {@link applyToEvent} is finished.
        */
@@ -2715,7 +2631,7 @@ var Sentry = (function (exports) {
           this.errors = 0;
           this.sid = uuid4();
           this.duration = 0;
-          this.status = SessionStatus.Ok;
+          this.status = 'ok';
           this.init = true;
           this.ignoreDuration = false;
           // Both timestamp and started are in seconds since the UNIX epoch.
@@ -2788,8 +2704,8 @@ var Sentry = (function (exports) {
           if (status) {
               this.update({ status });
           }
-          else if (this.status === SessionStatus.Ok) {
-              this.update({ status: SessionStatus.Exited });
+          else if (this.status === 'ok') {
+              this.update({ status: 'exited' });
           }
           else {
               this.update();
@@ -2807,17 +2723,16 @@ var Sentry = (function (exports) {
               errors: this.errors,
               did: typeof this.did === 'number' || typeof this.did === 'string' ? `${this.did}` : undefined,
               duration: this.duration,
-              attrs: dropUndefinedKeys({
+              attrs: {
                   release: this.release,
                   environment: this.environment,
                   ip_address: this.ipAddress,
                   user_agent: this.userAgent,
-              }),
+              },
           });
       }
   }
 
-  /* eslint-disable max-lines */
   /**
    * API compatibility version of this hub.
    *
@@ -3127,11 +3042,17 @@ var Sentry = (function (exports) {
        * @inheritDoc
        */
       endSession() {
-          var _a, _b, _c, _d, _e;
-          (_c = (_b = (_a = this.getStackTop()) === null || _a === void 0 ? void 0 : _a.scope) === null || _b === void 0 ? void 0 : _b.getSession()) === null || _c === void 0 ? void 0 : _c.close();
+          const layer = this.getStackTop();
+          const scope = layer && layer.scope;
+          const session = scope && scope.getSession();
+          if (session) {
+              session.close();
+          }
           this._sendSessionUpdate();
           // the session is over; take it off of the scope
-          (_e = (_d = this.getStackTop()) === null || _d === void 0 ? void 0 : _d.scope) === null || _e === void 0 ? void 0 : _e.setSession();
+          if (scope) {
+              scope.setSession();
+          }
       }
       /**
        * @inheritDoc
@@ -3147,8 +3068,8 @@ var Sentry = (function (exports) {
           if (scope) {
               // End existing session if there's one
               const currentSession = scope.getSession && scope.getSession();
-              if (currentSession && currentSession.status === SessionStatus.Ok) {
-                  currentSession.update({ status: SessionStatus.Exited });
+              if (currentSession && currentSession.status === 'ok') {
+                  currentSession.update({ status: 'exited' });
               }
               this.endSession();
               // Afterwards we set the new session on the scope
@@ -3250,9 +3171,9 @@ var Sentry = (function (exports) {
    * @returns discovered hub
    */
   function getHubFromActiveDomain(registry) {
-      var _a, _b, _c;
       try {
-          const activeDomain = (_c = (_b = (_a = getMainCarrier().__SENTRY__) === null || _a === void 0 ? void 0 : _a.extensions) === null || _b === void 0 ? void 0 : _b.domain) === null || _c === void 0 ? void 0 : _c.active;
+          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);
@@ -3343,7 +3264,7 @@ var Sentry = (function (exports) {
    * Captures a message event and sends it to Sentry.
    *
    * @param message The message to send to Sentry.
-   * @param level Define the level of the message.
+   * @param Severity Define the level of the message.
    * @returns The generated eventId.
    */
   function captureMessage(message, captureContext) {
@@ -3475,134 +3396,83 @@ var Sentry = (function (exports) {
   }
 
   const SENTRY_API_VERSION = '7';
+  /** Initializes API Details */
+  function initAPIDetails(dsn, metadata, tunnel) {
+      return {
+          initDsn: dsn,
+          metadata: metadata || {},
+          dsn: makeDsn(dsn),
+          tunnel,
+      };
+  }
+  /** Returns the prefix to construct Sentry ingestion API endpoints. */
+  function getBaseApiEndpoint(dsn) {
+      const protocol = dsn.protocol ? `${dsn.protocol}:` : '';
+      const port = dsn.port ? `:${dsn.port}` : '';
+      return `${protocol}//${dsn.host}${port}${dsn.path ? `/${dsn.path}` : ''}/api/`;
+  }
+  /** Returns the ingest API endpoint for target. */
+  function _getIngestEndpoint(dsn, target) {
+      return `${getBaseApiEndpoint(dsn)}${dsn.projectId}/${target}/`;
+  }
+  /** Returns a URL-encoded string with auth config suitable for a query string. */
+  function _encodedAuth(dsn) {
+      return urlEncode({
+          // We send only the minimum set of required information. See
+          // https://github.com/getsentry/sentry-javascript/issues/2572.
+          sentry_key: dsn.publicKey,
+          sentry_version: SENTRY_API_VERSION,
+      });
+  }
+  /** Returns the store endpoint URL. */
+  function getStoreEndpoint(dsn) {
+      return _getIngestEndpoint(dsn, 'store');
+  }
   /**
-   * Helper class to provide urls, headers and metadata that can be used to form
-   * different types of requests to Sentry endpoints.
-   * Supports both envelopes and regular event requests.
-   **/
-  class API {
-      /** Create a new instance of API */
-      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.getDsn();
-          const protocol = dsn.protocol ? `${dsn.protocol}:` : '';
-          const port = dsn.port ? `:${dsn.port}` : '';
-          return `${protocol}//${dsn.host}${port}${dsn.path ? `/${dsn.path}` : ''}/api/`;
-      }
-      /** Returns the store endpoint URL. */
-      getStoreEndpoint() {
-          return this._getIngestEndpoint('store');
-      }
-      /**
-       * Returns the store endpoint URL with auth in the query string.
-       *
-       * Sending auth as part of the query string and not as custom HTTP headers avoids CORS preflight requests.
-       */
-      getStoreEndpointWithUrlEncodedAuth() {
-          return `${this.getStoreEndpoint()}?${this._encodedAuth()}`;
-      }
-      /**
-       * Returns the envelope endpoint URL with auth in the query string.
-       *
-       * 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.getDsn();
-          return `${dsn.path ? `/${dsn.path}` : ''}/api/${dsn.projectId}/store/`;
-      }
-      /**
-       * Returns an object that can be used in request headers.
-       * This is needed for node and the old /store endpoint in sentry
-       */
-      getRequestHeaders(clientName, clientVersion) {
-          // CHANGE THIS to use metadata but keep clientName and clientVersion compatible
-          const dsn = this.getDsn();
-          const header = [`Sentry sentry_version=${SENTRY_API_VERSION}`];
-          header.push(`sentry_client=${clientName}/${clientVersion}`);
-          header.push(`sentry_key=${dsn.publicKey}`);
-          if (dsn.pass) {
-              header.push(`sentry_secret=${dsn.pass}`);
+   * Returns the store endpoint URL with auth in the query string.
+   *
+   * Sending auth as part of the query string and not as custom HTTP headers avoids CORS preflight requests.
+   */
+  function getStoreEndpointWithUrlEncodedAuth(dsn) {
+      return `${getStoreEndpoint(dsn)}?${_encodedAuth(dsn)}`;
+  }
+  /** Returns the envelope endpoint URL. */
+  function _getEnvelopeEndpoint(dsn) {
+      return _getIngestEndpoint(dsn, 'envelope');
+  }
+  /**
+   * Returns the envelope endpoint URL with auth in the query string.
+   *
+   * Sending auth as part of the query string and not as custom HTTP headers avoids CORS preflight requests.
+   */
+  function getEnvelopeEndpointWithUrlEncodedAuth(dsn, tunnel) {
+      return tunnel ? tunnel : `${_getEnvelopeEndpoint(dsn)}?${_encodedAuth(dsn)}`;
+  }
+  /** Returns the url to the report dialog endpoint. */
+  function getReportDialogEndpoint(dsnLike, dialogOptions) {
+      const dsn = makeDsn(dsnLike);
+      const endpoint = `${getBaseApiEndpoint(dsn)}embed/error-page/`;
+      let encodedOptions = `dsn=${dsnToString(dsn)}`;
+      for (const key in dialogOptions) {
+          if (key === 'dsn') {
+              continue;
           }
-          return {
-              'Content-Type': 'application/json',
-              'X-Sentry-Auth': header.join(', '),
-          };
-      }
-      /** Returns the url to the report dialog endpoint. */
-      getReportDialogEndpoint(dialogOptions = {}) {
-          const dsn = this.getDsn();
-          const endpoint = `${this.getBaseApiEndpoint()}embed/error-page/`;
-          const encodedOptions = [];
-          encodedOptions.push(`dsn=${dsn.toString()}`);
-          for (const key in dialogOptions) {
-              if (key === 'dsn') {
+          if (key === 'user') {
+              if (!dialogOptions.user) {
                   continue;
               }
-              if (key === 'user') {
-                  if (!dialogOptions.user) {
-                      continue;
-                  }
-                  if (dialogOptions.user.name) {
-                      encodedOptions.push(`name=${encodeURIComponent(dialogOptions.user.name)}`);
-                  }
-                  if (dialogOptions.user.email) {
-                      encodedOptions.push(`email=${encodeURIComponent(dialogOptions.user.email)}`);
-                  }
+              if (dialogOptions.user.name) {
+                  encodedOptions += `&name=${encodeURIComponent(dialogOptions.user.name)}`;
               }
-              else {
-                  encodedOptions.push(`${encodeURIComponent(key)}=${encodeURIComponent(dialogOptions[key])}`);
+              if (dialogOptions.user.email) {
+                  encodedOptions += `&email=${encodeURIComponent(dialogOptions.user.email)}`;
               }
           }
-          if (encodedOptions.length) {
-              return `${endpoint}?${encodedOptions.join('&')}`;
-          }
-          return endpoint;
-      }
-      /** Returns the envelope endpoint URL. */
-      _getEnvelopeEndpoint() {
-          return this._getIngestEndpoint('envelope');
-      }
-      /** Returns the ingest API endpoint for target. */
-      _getIngestEndpoint(target) {
-          if (this._tunnel) {
-              return this._tunnel;
+          else {
+              encodedOptions += `&${encodeURIComponent(key)}=${encodeURIComponent(dialogOptions[key])}`;
           }
-          const base = this.getBaseApiEndpoint();
-          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.getDsn();
-          const auth = {
-              // We send only the minimum set of required information. See
-              // https://github.com/getsentry/sentry-javascript/issues/2572.
-              sentry_key: dsn.publicKey,
-              sentry_version: SENTRY_API_VERSION,
-          };
-          return urlEncode(auth);
       }
+      return `${endpoint}?${encodedOptions}`;
   }
 
   const installedIntegrations = [];
@@ -3666,7 +3536,7 @@ var Sentry = (function (exports) {
       // set the `initialized` flag so we don't run through the process again unecessarily; use `Object.defineProperty`
       // because by default it creates a property which is nonenumerable, which we want since `initialized` shouldn't be
       // considered a member of the index the way the actual integrations are
-      Object.defineProperty(integrations, 'initialized', { value: true });
+      addNonEnumerableProperty(integrations, 'initialized', true);
       return integrations;
   }
 
@@ -3719,7 +3589,7 @@ var Sentry = (function (exports) {
           this._backend = new backendClass(options);
           this._options = options;
           if (options.dsn) {
-              this._dsn = new Dsn(options.dsn);
+              this._dsn = makeDsn(options.dsn);
           }
       }
       /**
@@ -3760,9 +3630,8 @@ var Sentry = (function (exports) {
        * @inheritDoc
        */
       captureEvent(event, hint, scope) {
-          var _a;
           // ensure we haven't captured this very object before
-          if (((_a = hint) === null || _a === void 0 ? void 0 : _a.originalException) && checkOrSetAlreadyCaught(hint.originalException)) {
+          if (hint && hint.originalException && checkOrSetAlreadyCaught(hint.originalException)) {
               logger.log(ALREADY_SEEN_ERROR);
               return;
           }
@@ -3777,11 +3646,15 @@ var Sentry = (function (exports) {
        */
       captureSession(session) {
           if (!this._isEnabled()) {
-              logger.warn('SDK not enabled, will not capture session.');
+              if (isDebugBuild()) {
+                  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');
+              if (isDebugBuild()) {
+                  logger.warn('Discarded session because of missing or non-string release');
+              }
           }
           else {
               this._sendSession(session);
@@ -3864,10 +3737,10 @@ var Sentry = (function (exports) {
           // 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 sessionNonTerminal = session.status === '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) }));
+              session.update(Object.assign(Object.assign({}, (crashed && { status: 'crashed' })), { errors: session.errors || Number(errored || crashed) }));
               this.captureSession(session);
           }
       }
@@ -3938,7 +3811,7 @@ var Sentry = (function (exports) {
               finalScope = Scope.clone(finalScope).update(hint.captureContext);
           }
           // We prepare the result here with a resolved Event.
-          let result = SyncPromise.resolve(prepared);
+          let result = resolvedSyncPromise(prepared);
           // This should be the last thing called, since we want that
           // {@link Hub.addEventProcessor} gets the finished prepared event.
           if (finalScope) {
@@ -4070,26 +3943,29 @@ var Sentry = (function (exports) {
        * @returns A SyncPromise that resolves with the event or rejects in case event was/will not be send.
        */
       _processEvent(event, hint, scope) {
-          var _a, _b;
           // eslint-disable-next-line @typescript-eslint/unbound-method
           const { beforeSend, sampleRate } = this.getOptions();
           const transport = this.getTransport();
+          function recordLostEvent(outcome, category) {
+              if (transport.recordLostEvent) {
+                  transport.recordLostEvent(outcome, category);
+              }
+          }
           if (!this._isEnabled()) {
-              return SyncPromise.reject(new SentryError('SDK not enabled, will not capture event.'));
+              return rejectedSyncPromise(new SentryError('SDK not enabled, will not capture event.'));
           }
           const isTransaction = event.type === 'transaction';
           // 1.0 === 100% events are sent
           // 0.0 === 0% events are sent
           // Sampling for transaction happens somewhere else
           if (!isTransaction && typeof sampleRate === 'number' && Math.random() > sampleRate) {
-              (_b = (_a = transport).recordLostEvent) === null || _b === void 0 ? void 0 : _b.call(_a, Outcome.SampleRate, 'event');
-              return SyncPromise.reject(new SentryError(`Discarding event because it's not included in the random sample (sampling rate = ${sampleRate})`));
+              recordLostEvent('sample_rate', 'event');
+              return rejectedSyncPromise(new SentryError(`Discarding event because it's not included in the random sample (sampling rate = ${sampleRate})`));
           }
           return this._prepareEvent(event, scope, hint)
               .then(prepared => {
-              var _a, _b;
               if (prepared === null) {
-                  (_b = (_a = transport).recordLostEvent) === null || _b === void 0 ? void 0 : _b.call(_a, Outcome.EventProcessor, event.type || 'event');
+                  recordLostEvent('event_processor', event.type || 'event');
                   throw new SentryError('An event processor returned null, will not send event.');
               }
               const isInternalException = hint && hint.data && hint.data.__sentry__ === true;
@@ -4097,12 +3973,11 @@ var Sentry = (function (exports) {
                   return prepared;
               }
               const beforeSendResult = beforeSend(prepared, hint);
-              return this._ensureBeforeSendRv(beforeSendResult);
+              return _ensureBeforeSendRv(beforeSendResult);
           })
               .then(processedEvent => {
-              var _a, _b;
               if (processedEvent === null) {
-                  (_b = (_a = transport).recordLostEvent) === null || _b === void 0 ? void 0 : _b.call(_a, Outcome.BeforeSend, event.type || 'event');
+                  recordLostEvent('before_send', event.type || 'event');
                   throw new SentryError('`beforeSend` returned `null`, will not send event.');
               }
               const session = scope && scope.getSession && scope.getSession();
@@ -4138,26 +4013,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;
+  }
+  /**
+   * Verifies that return value of configured `beforeSend` is of expected type.
+   */
+  function _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 */
@@ -4166,16 +4041,16 @@ var Sentry = (function (exports) {
        * @inheritDoc
        */
       sendEvent(_) {
-          return SyncPromise.resolve({
+          return resolvedSyncPromise({
               reason: `NoopTransport: Event has been skipped because no Dsn is configured.`,
-              status: exports.Status.Skipped,
+              status: 'skipped',
           });
       }
       /**
        * @inheritDoc
        */
       close(_) {
-          return SyncPromise.resolve(true);
+          return resolvedSyncPromise(true);
       }
   }
 
@@ -4210,7 +4085,9 @@ var Sentry = (function (exports) {
        */
       sendEvent(event) {
           void this._transport.sendEvent(event).then(null, reason => {
-              logger.error(`Error while sending event: ${reason}`);
+              if (isDebugBuild()) {
+                  logger.error(`Error while sending event: ${reason}`);
+              }
           });
       }
       /**
@@ -4218,11 +4095,15 @@ var Sentry = (function (exports) {
        */
       sendSession(session) {
           if (!this._transport.sendSession) {
-              logger.warn("Dropping session because custom transport doesn't implement sendSession");
+              if (isDebugBuild()) {
+                  logger.warn("Dropping session because custom transport doesn't implement sendSession");
+              }
               return;
           }
           void this._transport.sendSession(session).then(null, reason => {
-              logger.error(`Error while sending session: ${reason}`);
+              if (isDebugBuild()) {
+                  logger.error(`Error while sending session: ${reason}`);
+              }
           });
       }
       /**
@@ -4239,31 +4120,6 @@ var Sentry = (function (exports) {
       }
   }
 
-  /*! *****************************************************************************
-  Copyright (c) Microsoft Corporation. All rights reserved.
-  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-  this file except in compliance with the License. You may obtain a copy of the
-  License at http://www.apache.org/licenses/LICENSE-2.0
-
-  THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-  WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-  MERCHANTABLITY OR NON-INFRINGEMENT.
-
-  See the Apache Version 2.0 License for specific language governing permissions
-  and limitations under the License.
-  ***************************************************************************** */
-
-  function __rest(s, e) {
-      var t = {};
-      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-          t[p] = s[p];
-      if (s != null && typeof Object.getOwnPropertySymbols === "function")
-          for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)
-              t[p[i]] = s[p[i]];
-      return t;
-  }
-
   /** Extract sdk info from from the API metadata */
   function getSdkMetadataForEnvelopeHeader(api) {
       if (!api.metadata || !api.metadata.sdk) {
@@ -4290,7 +4146,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(Object.assign({ sent_at: new Date().toISOString() }, (sdkInfo && { sdk: sdkInfo })), (api.forceEnvelope() && { dsn: api.getDsn().toString() })));
+      const envelopeHeaders = JSON.stringify(Object.assign(Object.assign({ sent_at: new Date().toISOString() }, (sdkInfo && { sdk: sdkInfo })), (!!api.tunnel && { dsn: dsnToString(api.dsn) })));
       // 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({
@@ -4299,26 +4155,24 @@ var Sentry = (function (exports) {
       return {
           body: `${envelopeHeaders}\n${itemHeaders}\n${JSON.stringify(session)}`,
           type,
-          url: api.getEnvelopeEndpointWithUrlEncodedAuth(),
+          url: getEnvelopeEndpointWithUrlEncodedAuth(api.dsn, api.tunnel),
       };
   }
   /** Creates a SentryRequest from an event. */
   function eventToSentryRequest(event, api) {
       const sdkInfo = getSdkMetadataForEnvelopeHeader(api);
       const eventType = event.type || 'event';
-      const useEnvelope = eventType === 'transaction' || api.forceEnvelope();
-      const _a = event.debug_meta || {}, { transactionSampling } = _a, metadata = __rest(_a, ["transactionSampling"]);
+      const useEnvelope = eventType === 'transaction' || !!api.tunnel;
+      const { transactionSampling } = event.sdkProcessingMetadata || {};
       const { method: samplingMethod, rate: sampleRate } = transactionSampling || {};
-      if (Object.keys(metadata).length === 0) {
-          delete event.debug_meta;
-      }
-      else {
-          event.debug_meta = metadata;
-      }
+      // prevent this data from being sent to sentry
+      delete event.sdkProcessingMetadata;
       const req = {
           body: JSON.stringify(sdkInfo ? enhanceEventWithSdkInfo(event, api.metadata.sdk) : event),
           type: eventType,
-          url: useEnvelope ? api.getEnvelopeEndpointWithUrlEncodedAuth() : api.getStoreEndpointWithUrlEncodedAuth(),
+          url: useEnvelope
+              ? getEnvelopeEndpointWithUrlEncodedAuth(api.dsn, api.tunnel)
+              : getStoreEndpointWithUrlEncodedAuth(api.dsn),
       };
       // https://develop.sentry.dev/sdk/envelopes/
       // Since we don't need to manipulate envelopes nor store them, there is no
@@ -4326,7 +4180,7 @@ 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(Object.assign({ event_id: event.event_id, sent_at: new Date().toISOString() }, (sdkInfo && { sdk: sdkInfo })), (api.forceEnvelope() && { dsn: api.getDsn().toString() })));
+          const envelopeHeaders = JSON.stringify(Object.assign(Object.assign({ event_id: event.event_id, sent_at: new Date().toISOString() }, (sdkInfo && { sdk: sdkInfo })), (!!api.tunnel && { dsn: dsnToString(api.dsn) })));
           const itemHeaders = JSON.stringify({
               type: eventType,
               // TODO: Right now, sampleRate may or may not be defined (it won't be in the cases of inheritance and
@@ -4351,17 +4205,19 @@ var Sentry = (function (exports) {
    * @param options Options to pass to the client.
    */
   function initAndBind(clientClass, options) {
-      var _a;
       if (options.debug === true) {
           logger.enable();
       }
       const hub = getCurrentHub();
-      (_a = hub.getScope()) === null || _a === void 0 ? void 0 : _a.update(options.initialScope);
+      const scope = hub.getScope();
+      if (scope) {
+          scope.update(options.initialScope);
+      }
       const client = new clientClass(options);
       hub.bindClient(client);
   }
 
-  const SDK_VERSION = '6.15.0';
+  const SDK_VERSION = '6.17.0';
 
   let originalFunctionToString;
   /** Patch toString calls to return proper name for wrapped functions */
@@ -4380,7 +4236,7 @@ var Sentry = (function (exports) {
           originalFunctionToString = Function.prototype.toString;
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
           Function.prototype.toString = function (...args) {
-              const context = this.__sentry_original__ || this;
+              const context = getOriginalFunction(this) || this;
               return originalFunctionToString.apply(context, args);
           };
       }
@@ -4432,19 +4288,27 @@ var Sentry = (function (exports) {
       /** JSDoc */
       _shouldDropEvent(event, options) {
           if (this._isSentryError(event, options)) {
-              logger.warn(`Event dropped due to being internal Sentry Error.\nEvent: ${getEventDescription(event)}`);
+              if (isDebugBuild()) {
+                  logger.warn(`Event dropped due to being internal Sentry Error.\nEvent: ${getEventDescription(event)}`);
+              }
               return true;
           }
           if (this._isIgnoredError(event, options)) {
-              logger.warn(`Event dropped due to being matched by \`ignoreErrors\` option.\nEvent: ${getEventDescription(event)}`);
+              if (isDebugBuild()) {
+                  logger.warn(`Event dropped due to being matched by \`ignoreErrors\` option.\nEvent: ${getEventDescription(event)}`);
+              }
               return true;
           }
           if (this._isDeniedUrl(event, options)) {
-              logger.warn(`Event dropped due to being matched by \`denyUrls\` option.\nEvent: ${getEventDescription(event)}.\nUrl: ${this._getEventFilterUrl(event)}`);
+              if (isDebugBuild()) {
+                  logger.warn(`Event dropped due to being matched by \`denyUrls\` option.\nEvent: ${getEventDescription(event)}.\nUrl: ${this._getEventFilterUrl(event)}`);
+              }
               return true;
           }
           if (!this._isAllowedUrl(event, options)) {
-              logger.warn(`Event dropped due to not being matched by \`allowUrls\` option.\nEvent: ${getEventDescription(event)}.\nUrl: ${this._getEventFilterUrl(event)}`);
+              if (isDebugBuild()) {
+                  logger.warn(`Event dropped due to not being matched by \`allowUrls\` option.\nEvent: ${getEventDescription(event)}.\nUrl: ${this._getEventFilterUrl(event)}`);
+              }
               return true;
           }
           return false;
@@ -4455,16 +4319,14 @@ var Sentry = (function (exports) {
               return false;
           }
           try {
-              return ((event &&
-                  event.exception &&
-                  event.exception.values &&
-                  event.exception.values[0] &&
-                  event.exception.values[0].type === 'SentryError') ||
-                  false);
+              // @ts-ignore can't be a sentry error if undefined
+              // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+              return event.exception.values[0].type === 'SentryError';
           }
-          catch (_oO) {
-              return false;
+          catch (e) {
+              // ignore
           }
+          return false;
       }
       /** JSDoc */
       _isIgnoredError(event, options) {
@@ -4531,7 +4393,9 @@ var Sentry = (function (exports) {
                   return [`${value}`, `${type}: ${value}`];
               }
               catch (oO) {
-                  logger.error(`Cannot extract message for event ${getEventDescription(event)}`);
+                  if (isDebugBuild()) {
+                      logger.error(`Cannot extract message for event ${getEventDescription(event)}`);
+                  }
                   return [];
               }
           }
@@ -4539,10 +4403,9 @@ var Sentry = (function (exports) {
       }
       /** JSDoc */
       _getLastValidUrl(frames = []) {
-          var _a, _b;
           for (let i = frames.length - 1; i >= 0; i--) {
               const frame = frames[i];
-              if (((_a = frame) === null || _a === void 0 ? void 0 : _a.filename) !== '<anonymous>' && ((_b = frame) === null || _b === void 0 ? void 0 : _b.filename) !== '[native code]') {
+              if (frame && frame.filename !== '<anonymous>' && frame.filename !== '[native code]') {
                   return frame.filename || null;
               }
           }
@@ -4552,17 +4415,22 @@ var Sentry = (function (exports) {
       _getEventFilterUrl(event) {
           try {
               if (event.stacktrace) {
-                  const frames = event.stacktrace.frames;
-                  return this._getLastValidUrl(frames);
+                  return this._getLastValidUrl(event.stacktrace.frames);
               }
-              if (event.exception) {
-                  const frames = event.exception.values && event.exception.values[0].stacktrace && event.exception.values[0].stacktrace.frames;
-                  return this._getLastValidUrl(frames);
+              let frames;
+              try {
+                  // @ts-ignore we only care about frames if the whole thing here is defined
+                  frames = event.exception.values[0].stacktrace.frames;
               }
-              return null;
+              catch (e) {
+                  // ignore
+              }
+              return frames ? this._getLastValidUrl(frames) : null;
           }
           catch (oO) {
-              logger.error(`Cannot extract url for event ${getEventDescription(event)}`);
+              if (isDebugBuild()) {
+                  logger.error(`Cannot extract url for event ${getEventDescription(event)}`);
+              }
               return null;
           }
       }
@@ -4924,7 +4792,7 @@ var Sentry = (function (exports) {
   }
 
   /**
-   * Builds and Event from a Exception
+   * Creates an {@link Event} from all inputs to `captureException` and non-primitive inputs to `captureMessage`.
    * @hidden
    */
   function eventFromException(options, exception, hint) {
@@ -4937,7 +4805,7 @@ var Sentry = (function (exports) {
       if (hint && hint.event_id) {
           event.event_id = hint.event_id;
       }
-      return SyncPromise.resolve(event);
+      return resolvedSyncPromise(event);
   }
   /**
    * Builds and Event from a Message
@@ -4952,7 +4820,7 @@ var Sentry = (function (exports) {
       if (hint && hint.event_id) {
           event.event_id = hint.event_id;
       }
-      return SyncPromise.resolve(event);
+      return resolvedSyncPromise(event);
   }
   /**
    * @hidden
@@ -4996,11 +4864,11 @@ var Sentry = (function (exports) {
           return event;
       }
       if (isPlainObject(exception) || isEvent(exception)) {
-          // If it is plain Object or Event, serialize it manually and extract options
-          // This will allow us to group events based on top-level keys
-          // which is much better than creating new group when any key/value change
+          // If it's a plain object or an instance of `Event` (the built-in JS kind, not this SDK's `Event` type), serialize
+          // it manually. This will allow us to group events based on top-level keys which is much better than creating a new
+          // group on any key/value change.
           const objectException = exception;
-          event = eventFromPlainObject(objectException, syntheticException, options.rejection);
+          event = eventFromPlainObject(objectException, syntheticException, options.isRejection);
           addExceptionMechanism(event, {
               synthetic: true,
           });
@@ -5080,7 +4948,6 @@ var Sentry = (function (exports) {
    * Safari:  resource blocked by content blocker
    */
   function getNativeFetchImplementation() {
-      var _a, _b;
       if (cachedFetchImpl) {
           return cachedFetchImpl;
       }
@@ -5092,18 +4959,21 @@ var Sentry = (function (exports) {
       const document = global$3.document;
       let fetchImpl = global$3.fetch;
       // eslint-disable-next-line deprecation/deprecation
-      if (typeof ((_a = document) === null || _a === void 0 ? void 0 : _a.createElement) === `function`) {
+      if (document && typeof document.createElement === `function`) {
           try {
               const sandbox = document.createElement('iframe');
               sandbox.hidden = true;
               document.head.appendChild(sandbox);
-              if ((_b = sandbox.contentWindow) === null || _b === void 0 ? void 0 : _b.fetch) {
-                  fetchImpl = sandbox.contentWindow.fetch;
+              const contentWindow = sandbox.contentWindow;
+              if (contentWindow && contentWindow.fetch) {
+                  fetchImpl = contentWindow.fetch;
               }
               document.head.removeChild(sandbox);
           }
           catch (e) {
-              logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', e);
+              if (isDebugBuild()) {
+                  logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', e);
+              }
           }
       }
       return (cachedFetchImpl = fetchImpl.bind(global$3));
@@ -5134,25 +5004,23 @@ var Sentry = (function (exports) {
       }
   }
 
-  const CATEGORY_MAPPING = {
-      event: 'error',
-      transaction: 'transaction',
-      session: 'session',
-      attachment: 'attachment',
-  };
+  function requestTypeToCategory(ty) {
+      const tyStr = ty;
+      return tyStr === 'event' ? 'error' : tyStr;
+  }
   const global$4 = getGlobalObject();
   /** Base Transport class implementation */
   class BaseTransport {
       constructor(options) {
           this.options = options;
           /** A simple buffer holding all requests. */
-          this._buffer = new PromiseBuffer(30);
+          this._buffer = makePromiseBuffer(30);
           /** Locks transport after receiving rate limits in a response */
           this._rateLimits = {};
           this._outcomes = {};
-          this._api = new API(options.dsn, options._metadata, options.tunnel);
+          this._api = initAPIDetails(options.dsn, options._metadata, options.tunnel);
           // eslint-disable-next-line deprecation/deprecation
-          this.url = this._api.getStoreEndpointWithUrlEncodedAuth();
+          this.url = getStoreEndpointWithUrlEncodedAuth(this._api.dsn);
           if (this.options.sendClientReports && global$4.document) {
               global$4.document.addEventListener('visibilitychange', () => {
                   if (global$4.document.visibilityState === 'hidden') {
@@ -5164,8 +5032,14 @@ var Sentry = (function (exports) {
       /**
        * @inheritDoc
        */
-      sendEvent(_) {
-          throw new SentryError('Transport Class has to implement `sendEvent` method');
+      sendEvent(event) {
+          return this._sendRequest(eventToSentryRequest(event, this._api), event);
+      }
+      /**
+       * @inheritDoc
+       */
+      sendSession(session) {
+          return this._sendRequest(sessionToSentryRequest(session, this._api), session);
       }
       /**
        * @inheritDoc
@@ -5186,7 +5060,7 @@ var Sentry = (function (exports) {
           // We could use nested maps, but it's much easier to read and type this way.
           // A correct type for map-based implementation if we want to go that route
           // would be `Partial<Record<SentryRequestType, Partial<Record<Outcome, number>>>>`
-          const key = `${CATEGORY_MAPPING[category]}:${reason}`;
+          const key = `${requestTypeToCategory(category)}:${reason}`;
           logger.log(`Adding outcome: ${key}`);
           this._outcomes[key] = (_a = this._outcomes[key], (_a !== null && _a !== void 0 ? _a : 0)) + 1;
       }
@@ -5205,9 +5079,9 @@ var Sentry = (function (exports) {
               return;
           }
           logger.log(`Flushing outcomes:\n${JSON.stringify(outcomes, null, 2)}`);
-          const url = this._api.getEnvelopeEndpointWithUrlEncodedAuth();
+          const url = getEnvelopeEndpointWithUrlEncodedAuth(this._api.dsn, this._api.tunnel);
           // Envelope header is required to be at least an empty object
-          const envelopeHeader = JSON.stringify(Object.assign({}, (this.options.tunnel && { dsn: this._api.getDsn().toString() })));
+          const envelopeHeader = JSON.stringify(Object.assign({}, (this._api.tunnel && { dsn: dsnToString(this._api.dsn) })));
           const itemHeaders = JSON.stringify({
               type: 'client_report',
           });
@@ -5234,15 +5108,16 @@ var Sentry = (function (exports) {
        * Handle Sentry repsonse for promise-based transports.
        */
       _handleResponse({ requestType, response, headers, resolve, reject, }) {
-          const status = exports.Status.fromHttpCode(response.status);
+          const status = eventStatusFromHttpCode(response.status);
           /**
            * "The name is case-insensitive."
            * https://developer.mozilla.org/en-US/docs/Web/API/Headers/get
            */
           const limited = this._handleRateLimit(headers);
-          if (limited)
+          if (limited && isDebugBuild()) {
               logger.warn(`Too many ${requestType} requests, backing off until: ${this._disabledUntil(requestType)}`);
-          if (status === exports.Status.Success) {
+          }
+          if (status === 'success') {
               resolve({ status });
               return;
           }
@@ -5252,7 +5127,7 @@ var Sentry = (function (exports) {
        * Gets the time that given category is disabled until for rate limiting
        */
       _disabledUntil(requestType) {
-          const category = CATEGORY_MAPPING[requestType];
+          const category = requestTypeToCategory(requestType);
           return this._rateLimits[category] || this._rateLimits.all;
       }
       /**
@@ -5303,25 +5178,13 @@ var Sentry = (function (exports) {
           super(options);
           this._fetch = fetchImpl;
       }
-      /**
-       * @inheritDoc
-       */
-      sendEvent(event) {
-          return this._sendRequest(eventToSentryRequest(event, this._api), event);
-      }
-      /**
-       * @inheritDoc
-       */
-      sendSession(session) {
-          return this._sendRequest(sessionToSentryRequest(session, this._api), session);
-      }
       /**
        * @param sentryRequest Prepared SentryRequest to be delivered
        * @param originalPayload Original payload used to create SentryRequest
        */
       _sendRequest(sentryRequest, originalPayload) {
           if (this._isRateLimited(sentryRequest.type)) {
-              this.recordLostEvent(Outcome.RateLimitBackoff, sentryRequest.type);
+              this.recordLostEvent('ratelimit_backoff', sentryRequest.type);
               return Promise.reject({
                   event: originalPayload,
                   type: sentryRequest.type,
@@ -5332,9 +5195,9 @@ var Sentry = (function (exports) {
           const options = {
               body: sentryRequest.body,
               method: 'POST',
-              // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default
-              // https://caniuse.com/#feat=referrer-policy
-              // It doesn't. And it throw exception instead of ignoring this parameter...
+              // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default'
+              // (see https://caniuse.com/#feat=referrer-policy),
+              // it doesn't. And it throws an exception instead of ignoring this parameter...
               // REF: https://github.com/getsentry/raven-js/issues/1233
               referrerPolicy: (supportsReferrerPolicy() ? 'origin' : ''),
           };
@@ -5365,10 +5228,10 @@ var Sentry = (function (exports) {
               .then(undefined, reason => {
               // It's either buffer rejection or any other xhr/fetch error, which are treated as NetworkError.
               if (reason instanceof SentryError) {
-                  this.recordLostEvent(Outcome.QueueOverflow, sentryRequest.type);
+                  this.recordLostEvent('queue_overflow', sentryRequest.type);
               }
               else {
-                  this.recordLostEvent(Outcome.NetworkError, sentryRequest.type);
+                  this.recordLostEvent('network_error', sentryRequest.type);
               }
               throw reason;
           });
@@ -5377,25 +5240,13 @@ var Sentry = (function (exports) {
 
   /** `XHR` based transport */
   class XHRTransport extends BaseTransport {
-      /**
-       * @inheritDoc
-       */
-      sendEvent(event) {
-          return this._sendRequest(eventToSentryRequest(event, this._api), event);
-      }
-      /**
-       * @inheritDoc
-       */
-      sendSession(session) {
-          return this._sendRequest(sessionToSentryRequest(session, this._api), session);
-      }
       /**
        * @param sentryRequest Prepared SentryRequest to be delivered
        * @param originalPayload Original payload used to create SentryRequest
        */
       _sendRequest(sentryRequest, originalPayload) {
           if (this._isRateLimited(sentryRequest.type)) {
-              this.recordLostEvent(Outcome.RateLimitBackoff, sentryRequest.type);
+              this.recordLostEvent('ratelimit_backoff', sentryRequest.type);
               return Promise.reject({
                   event: originalPayload,
                   type: sentryRequest.type,
@@ -5426,10 +5277,10 @@ var Sentry = (function (exports) {
               .then(undefined, reason => {
               // It's either buffer rejection or any other xhr/fetch error, which are treated as NetworkError.
               if (reason instanceof SentryError) {
-                  this.recordLostEvent(Outcome.QueueOverflow, sentryRequest.type);
+                  this.recordLostEvent('queue_overflow', sentryRequest.type);
               }
               else {
-                  this.recordLostEvent(Outcome.NetworkError, sentryRequest.type);
+                  this.recordLostEvent('network_error', sentryRequest.type);
               }
               throw reason;
           });
@@ -5508,18 +5359,26 @@ var Sentry = (function (exports) {
    * @hidden
    */
   function wrap(fn, options = {}, before) {
+      // for future readers what this does is wrap a function and then create
+      // a bi-directional wrapping between them.
+      //
+      // example: wrapped = wrap(original);
+      //  original.__sentry_wrapped__ -> wrapped
+      //  wrapped.__sentry_original__ -> original
       if (typeof fn !== 'function') {
           return fn;
       }
       try {
+          // if we're dealing with a function that was previously wrapped, return
+          // the original wrapper.
+          const wrapper = fn.__sentry_wrapped__;
+          if (wrapper) {
+              return wrapper;
+          }
           // We don't wanna wrap it twice
-          if (fn.__sentry__) {
+          if (getOriginalFunction(fn)) {
               return fn;
           }
-          // If this has already been wrapped in the past, return that wrapped function
-          if (fn.__sentry_wrapped__) {
-              return fn.__sentry_wrapped__;
-          }
       }
       catch (e) {
           // Just accessing custom props in some Selenium environments
@@ -5537,14 +5396,6 @@ var Sentry = (function (exports) {
               }
               // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
               const wrappedArguments = args.map((arg) => wrap(arg, options));
-              if (fn.handleEvent) {
-                  // 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
-                  //       is expected behavior and NOT indicative of a bug with sentry.javascript.
-                  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-                  return fn.handleEvent.apply(this, wrappedArguments);
-              }
               // 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
@@ -5555,13 +5406,12 @@ var Sentry = (function (exports) {
               ignoreNextOnError();
               withScope((scope) => {
                   scope.addEventProcessor((event) => {
-                      const processedEvent = Object.assign({}, event);
                       if (options.mechanism) {
-                          addExceptionTypeValue(processedEvent, undefined, undefined);
-                          addExceptionMechanism(processedEvent, options.mechanism);
+                          addExceptionTypeValue(event, undefined, undefined);
+                          addExceptionMechanism(event, options.mechanism);
                       }
-                      processedEvent.extra = Object.assign(Object.assign({}, processedEvent.extra), { arguments: args });
-                      return processedEvent;
+                      event.extra = Object.assign(Object.assign({}, event.extra), { arguments: args });
+                      return event;
                   });
                   captureException(ex);
               });
@@ -5579,24 +5429,10 @@ var Sentry = (function (exports) {
           }
       }
       catch (_oO) { } // eslint-disable-line no-empty
-      fn.prototype = fn.prototype || {};
-      sentryWrapped.prototype = fn.prototype;
-      Object.defineProperty(fn, '__sentry_wrapped__', {
-          enumerable: false,
-          value: sentryWrapped,
-      });
       // Signal that this function has been wrapped/filled already
       // for both debugging and to prevent it to being wrapped/filled twice
-      Object.defineProperties(sentryWrapped, {
-          __sentry__: {
-              enumerable: false,
-              value: true,
-          },
-          __sentry_original__: {
-              enumerable: false,
-              value: fn,
-          },
-      });
+      markFunctionWrapped(sentryWrapped, fn);
+      addNonEnumerableProperty(fn, '__sentry_wrapped__', sentryWrapped);
       // Restore original function name (not all browsers allow that)
       try {
           const descriptor = Object.getOwnPropertyDescriptor(sentryWrapped, 'name');
@@ -5621,16 +5457,20 @@ var Sentry = (function (exports) {
           return;
       }
       if (!options.eventId) {
-          logger.error(`Missing eventId option in showReportDialog call`);
+          if (isDebugBuild()) {
+              logger.error(`Missing eventId option in showReportDialog call`);
+          }
           return;
       }
       if (!options.dsn) {
-          logger.error(`Missing dsn option in showReportDialog call`);
+          if (isDebugBuild()) {
+              logger.error(`Missing dsn option in showReportDialog call`);
+          }
           return;
       }
       const script = global$5.document.createElement('script');
       script.async = true;
-      script.src = new API(options.dsn).getReportDialogEndpoint(options);
+      script.src = getReportDialogEndpoint(options.dsn, options);
       if (options.onLoad) {
           // eslint-disable-next-line @typescript-eslint/unbound-method
           script.onload = options.onLoad;
@@ -5650,10 +5490,14 @@ var Sentry = (function (exports) {
            * @inheritDoc
            */
           this.name = GlobalHandlers.id;
-          /** JSDoc */
-          this._onErrorHandlerInstalled = false;
-          /** JSDoc */
-          this._onUnhandledRejectionHandlerInstalled = false;
+          /**
+           * Stores references functions to installing handlers. Will set to undefined
+           * after they have been run so that they are not used twice.
+           */
+          this._installFunc = {
+              onerror: _installGlobalOnErrorHandler,
+              onunhandledrejection: _installGlobalOnUnhandledRejectionHandler,
+          };
           this._options = Object.assign({ onerror: true, onunhandledrejection: true }, options);
       }
       /**
@@ -5661,176 +5505,182 @@ var Sentry = (function (exports) {
        */
       setupOnce() {
           Error.stackTraceLimit = 50;
-          if (this._options.onerror) {
-              logger.log('Global Handler attached: onerror');
-              this._installGlobalOnErrorHandler();
-          }
-          if (this._options.onunhandledrejection) {
-              logger.log('Global Handler attached: onunhandledrejection');
-              this._installGlobalOnUnhandledRejectionHandler();
+          const options = this._options;
+          // We can disable guard-for-in as we construct the options object above + do checks against
+          // `this._installFunc` for the property.
+          // eslint-disable-next-line guard-for-in
+          for (const key in options) {
+              const installFunc = this._installFunc[key];
+              if (installFunc && options[key]) {
+                  globalHandlerLog(key);
+                  installFunc();
+                  this._installFunc[key] = undefined;
+              }
           }
       }
-      /** JSDoc */
-      _installGlobalOnErrorHandler() {
-          if (this._onErrorHandlerInstalled) {
+  }
+  /**
+   * @inheritDoc
+   */
+  GlobalHandlers.id = 'GlobalHandlers';
+  /** JSDoc */
+  function _installGlobalOnErrorHandler() {
+      addInstrumentationHandler('error', 
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (data) => {
+          const [hub, attachStacktrace] = getHubAndAttachStacktrace();
+          if (!hub.getIntegration(GlobalHandlers)) {
               return;
           }
-          addInstrumentationHandler({
-              // eslint-disable-next-line @typescript-eslint/no-explicit-any
-              callback: (data) => {
-                  const error = data.error;
-                  const currentHub = getCurrentHub();
-                  const hasIntegration = currentHub.getIntegration(GlobalHandlers);
-                  const isFailedOwnDelivery = error && error.__sentry_own_request__ === true;
-                  if (!hasIntegration || shouldIgnoreOnError() || isFailedOwnDelivery) {
-                      return;
-                  }
-                  const client = currentHub.getClient();
-                  const event = error === undefined && isString(data.msg)
-                      ? this._eventFromIncompleteOnError(data.msg, data.url, data.line, data.column)
-                      : this._enhanceEventWithInitialFrame(eventFromUnknownInput(error || data.msg, undefined, {
-                          attachStacktrace: client && client.getOptions().attachStacktrace,
-                          rejection: false,
-                      }), data.url, data.line, data.column);
-                  addExceptionMechanism(event, {
-                      handled: false,
-                      type: 'onerror',
-                  });
-                  currentHub.captureEvent(event, {
-                      originalException: error,
-                  });
-              },
-              type: 'error',
-          });
-          this._onErrorHandlerInstalled = true;
-      }
-      /** JSDoc */
-      _installGlobalOnUnhandledRejectionHandler() {
-          if (this._onUnhandledRejectionHandlerInstalled) {
+          const { msg, url, line, column, error } = data;
+          if (shouldIgnoreOnError() || (error && error.__sentry_own_request__)) {
               return;
           }
-          addInstrumentationHandler({
-              // eslint-disable-next-line @typescript-eslint/no-explicit-any
-              callback: (e) => {
-                  let error = e;
-                  // dig the object of the rejection out of known event types
-                  try {
-                      // PromiseRejectionEvents store the object of the rejection under 'reason'
-                      // see https://developer.mozilla.org/en-US/docs/Web/API/PromiseRejectionEvent
-                      if ('reason' in e) {
-                          error = e.reason;
-                      }
-                      // something, somewhere, (likely a browser extension) effectively casts PromiseRejectionEvents
-                      // to CustomEvents, moving the `promise` and `reason` attributes of the PRE into
-                      // the CustomEvent's `detail` attribute, since they're not part of CustomEvent's spec
-                      // see https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent and
-                      // https://github.com/getsentry/sentry-javascript/issues/2380
-                      else if ('detail' in e && 'reason' in e.detail) {
-                          error = e.detail.reason;
-                      }
-                  }
-                  catch (_oO) {
-                      // no-empty
-                  }
-                  const currentHub = getCurrentHub();
-                  const hasIntegration = currentHub.getIntegration(GlobalHandlers);
-                  const isFailedOwnDelivery = error && error.__sentry_own_request__ === true;
-                  if (!hasIntegration || shouldIgnoreOnError() || isFailedOwnDelivery) {
-                      return true;
-                  }
-                  const client = currentHub.getClient();
-                  const event = isPrimitive(error)
-                      ? this._eventFromRejectionWithPrimitive(error)
-                      : eventFromUnknownInput(error, undefined, {
-                          attachStacktrace: client && client.getOptions().attachStacktrace,
-                          rejection: true,
-                      });
-                  event.level = exports.Severity.Error;
-                  addExceptionMechanism(event, {
-                      handled: false,
-                      type: 'onunhandledrejection',
-                  });
-                  currentHub.captureEvent(event, {
-                      originalException: error,
-                  });
-                  return;
-              },
-              type: 'unhandledrejection',
-          });
-          this._onUnhandledRejectionHandlerInstalled = true;
-      }
-      /**
-       * This function creates a stack from an old, error-less onerror handler.
-       */
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      _eventFromIncompleteOnError(msg, url, line, column) {
-          const ERROR_TYPES_RE = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/i;
-          // If 'message' is ErrorEvent, get real message from inside
-          let message = isErrorEvent(msg) ? msg.message : msg;
-          let name;
-          const groups = message.match(ERROR_TYPES_RE);
-          if (groups) {
-              name = groups[1];
-              message = groups[2];
-          }
-          const event = {
-              exception: {
-                  values: [
-                      {
-                          type: name || 'Error',
-                          value: message,
-                      },
-                  ],
-              },
-          };
-          return this._enhanceEventWithInitialFrame(event, url, line, column);
-      }
-      /**
-       * Create an event from a promise rejection where the `reason` is a primitive.
-       *
-       * @param reason: The `reason` property of the promise rejection
-       * @returns An Event object with an appropriate `exception` value
-       */
-      _eventFromRejectionWithPrimitive(reason) {
-          return {
-              exception: {
-                  values: [
-                      {
-                          type: 'UnhandledRejection',
-                          // String() is needed because the Primitive type includes symbols (which can't be automatically stringified)
-                          value: `Non-Error promise rejection captured with value: ${String(reason)}`,
-                      },
-                  ],
-              },
-          };
-      }
-      /** JSDoc */
+          const event = error === undefined && isString(msg)
+              ? _eventFromIncompleteOnError(msg, url, line, column)
+              : _enhanceEventWithInitialFrame(eventFromUnknownInput(error || msg, undefined, {
+                  attachStacktrace,
+                  isRejection: false,
+              }), url, line, column);
+          addMechanismAndCapture(hub, error, event, 'onerror');
+      });
+  }
+  /** JSDoc */
+  function _installGlobalOnUnhandledRejectionHandler() {
+      addInstrumentationHandler('unhandledrejection', 
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      _enhanceEventWithInitialFrame(event, url, line, column) {
-          event.exception = event.exception || {};
-          event.exception.values = event.exception.values || [];
-          event.exception.values[0] = event.exception.values[0] || {};
-          event.exception.values[0].stacktrace = event.exception.values[0].stacktrace || {};
-          event.exception.values[0].stacktrace.frames = event.exception.values[0].stacktrace.frames || [];
-          const colno = isNaN(parseInt(column, 10)) ? undefined : column;
-          const lineno = isNaN(parseInt(line, 10)) ? undefined : line;
-          const filename = isString(url) && url.length > 0 ? url : getLocationHref();
-          if (event.exception.values[0].stacktrace.frames.length === 0) {
-              event.exception.values[0].stacktrace.frames.push({
-                  colno,
-                  filename,
-                  function: '?',
-                  in_app: true,
-                  lineno,
-              });
+      (e) => {
+          const [hub, attachStacktrace] = getHubAndAttachStacktrace();
+          if (!hub.getIntegration(GlobalHandlers)) {
+              return;
           }
-          return event;
-      }
+          let error = e;
+          // dig the object of the rejection out of known event types
+          try {
+              // PromiseRejectionEvents store the object of the rejection under 'reason'
+              // see https://developer.mozilla.org/en-US/docs/Web/API/PromiseRejectionEvent
+              if ('reason' in e) {
+                  error = e.reason;
+              }
+              // something, somewhere, (likely a browser extension) effectively casts PromiseRejectionEvents
+              // to CustomEvents, moving the `promise` and `reason` attributes of the PRE into
+              // the CustomEvent's `detail` attribute, since they're not part of CustomEvent's spec
+              // see https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent and
+              // https://github.com/getsentry/sentry-javascript/issues/2380
+              else if ('detail' in e && 'reason' in e.detail) {
+                  error = e.detail.reason;
+              }
+          }
+          catch (_oO) {
+              // no-empty
+          }
+          if (shouldIgnoreOnError() || (error && error.__sentry_own_request__)) {
+              return true;
+          }
+          const event = isPrimitive(error)
+              ? _eventFromRejectionWithPrimitive(error)
+              : eventFromUnknownInput(error, undefined, {
+                  attachStacktrace,
+                  isRejection: true,
+              });
+          event.level = exports.Severity.Error;
+          addMechanismAndCapture(hub, error, event, 'onunhandledrejection');
+          return;
+      });
   }
   /**
-   * @inheritDoc
+   * Create an event from a promise rejection where the `reason` is a primitive.
+   *
+   * @param reason: The `reason` property of the promise rejection
+   * @returns An Event object with an appropriate `exception` value
+   */
+  function _eventFromRejectionWithPrimitive(reason) {
+      return {
+          exception: {
+              values: [
+                  {
+                      type: 'UnhandledRejection',
+                      // String() is needed because the Primitive type includes symbols (which can't be automatically stringified)
+                      value: `Non-Error promise rejection captured with value: ${String(reason)}`,
+                  },
+              ],
+          },
+      };
+  }
+  /**
+   * This function creates a stack from an old, error-less onerror handler.
    */
-  GlobalHandlers.id = 'GlobalHandlers';
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function _eventFromIncompleteOnError(msg, url, line, column) {
+      const ERROR_TYPES_RE = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/i;
+      // If 'message' is ErrorEvent, get real message from inside
+      let message = isErrorEvent(msg) ? msg.message : msg;
+      let name = 'Error';
+      const groups = message.match(ERROR_TYPES_RE);
+      if (groups) {
+          name = groups[1];
+          message = groups[2];
+      }
+      const event = {
+          exception: {
+              values: [
+                  {
+                      type: name,
+                      value: message,
+                  },
+              ],
+          },
+      };
+      return _enhanceEventWithInitialFrame(event, url, line, column);
+  }
+  /** JSDoc */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function _enhanceEventWithInitialFrame(event, url, line, column) {
+      // event.exception
+      const e = (event.exception = event.exception || {});
+      // event.exception.values
+      const ev = (e.values = e.values || []);
+      // event.exception.values[0]
+      const ev0 = (ev[0] = ev[0] || {});
+      // event.exception.values[0].stacktrace
+      const ev0s = (ev0.stacktrace = ev0.stacktrace || {});
+      // event.exception.values[0].stacktrace.frames
+      const ev0sf = (ev0s.frames = ev0s.frames || []);
+      const colno = isNaN(parseInt(column, 10)) ? undefined : column;
+      const lineno = isNaN(parseInt(line, 10)) ? undefined : line;
+      const filename = isString(url) && url.length > 0 ? url : getLocationHref();
+      // event.exception.values[0].stacktrace.frames
+      if (ev0sf.length === 0) {
+          ev0sf.push({
+              colno,
+              filename,
+              function: '?',
+              in_app: true,
+              lineno,
+          });
+      }
+      return event;
+  }
+  function globalHandlerLog(type) {
+      if (isDebugBuild()) {
+          logger.log(`Global Handler attached: ${type}`);
+      }
+  }
+  function addMechanismAndCapture(hub, error, event, type) {
+      addExceptionMechanism(event, {
+          handled: false,
+          type,
+      });
+      hub.captureEvent(event, {
+          originalException: error,
+      });
+  }
+  function getHubAndAttachStacktrace() {
+      const hub = getCurrentHub();
+      const client = hub.getClient();
+      const attachStacktrace = client && client.getOptions().attachStacktrace;
+      return [hub, attachStacktrace];
+  }
 
   const DEFAULT_EVENT_TARGET = [
       'EventTarget',
@@ -5882,172 +5732,173 @@ var Sentry = (function (exports) {
       setupOnce() {
           const global = getGlobalObject();
           if (this._options.setTimeout) {
-              fill(global, 'setTimeout', this._wrapTimeFunction.bind(this));
+              fill(global, 'setTimeout', _wrapTimeFunction);
           }
           if (this._options.setInterval) {
-              fill(global, 'setInterval', this._wrapTimeFunction.bind(this));
+              fill(global, 'setInterval', _wrapTimeFunction);
           }
           if (this._options.requestAnimationFrame) {
-              fill(global, 'requestAnimationFrame', this._wrapRAF.bind(this));
+              fill(global, 'requestAnimationFrame', _wrapRAF);
           }
           if (this._options.XMLHttpRequest && 'XMLHttpRequest' in global) {
-              fill(XMLHttpRequest.prototype, 'send', this._wrapXHR.bind(this));
+              fill(XMLHttpRequest.prototype, 'send', _wrapXHR);
           }
-          if (this._options.eventTarget) {
-              const eventTarget = Array.isArray(this._options.eventTarget) ? this._options.eventTarget : DEFAULT_EVENT_TARGET;
-              eventTarget.forEach(this._wrapEventTarget.bind(this));
+          const eventTargetOption = this._options.eventTarget;
+          if (eventTargetOption) {
+              const eventTarget = Array.isArray(eventTargetOption) ? eventTargetOption : DEFAULT_EVENT_TARGET;
+              eventTarget.forEach(_wrapEventTarget);
           }
       }
-      /** JSDoc */
-      _wrapTimeFunction(original) {
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          return function (...args) {
-              const originalCallback = args[0];
-              args[0] = wrap(originalCallback, {
-                  mechanism: {
-                      data: { function: getFunctionName(original) },
-                      handled: true,
-                      type: 'instrument',
-                  },
-              });
-              return original.apply(this, args);
-          };
-      }
-      /** JSDoc */
+  }
+  /**
+   * @inheritDoc
+   */
+  TryCatch.id = 'TryCatch';
+  /** JSDoc */
+  function _wrapTimeFunction(original) {
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      _wrapRAF(original) {
-          // 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, {
-                  mechanism: {
-                      data: {
-                          function: 'requestAnimationFrame',
-                          handler: getFunctionName(original),
-                      },
-                      handled: true,
-                      type: 'instrument',
-                  },
-              }));
-          };
-      }
-      /** JSDoc */
-      _wrapEventTarget(target) {
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          const global = getGlobalObject();
+      return function (...args) {
+          const originalCallback = args[0];
+          args[0] = wrap(originalCallback, {
+              mechanism: {
+                  data: { function: getFunctionName(original) },
+                  handled: true,
+                  type: 'instrument',
+              },
+          });
+          return original.apply(this, args);
+      };
+  }
+  /** JSDoc */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function _wrapRAF(original) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      return function (callback) {
           // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-          const proto = global[target] && global[target].prototype;
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-prototype-builtins
-          if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {
-              return;
-          }
-          fill(proto, 'addEventListener', function (original) {
-              return function (eventName, fn, options) {
-                  try {
-                      if (typeof fn.handleEvent === 'function') {
-                          fn.handleEvent = wrap(fn.handleEvent.bind(fn), {
-                              mechanism: {
-                                  data: {
-                                      function: 'handleEvent',
-                                      handler: getFunctionName(fn),
-                                      target,
-                                  },
-                                  handled: true,
-                                  type: 'instrument',
-                              },
-                          });
-                      }
-                  }
-                  catch (err) {
-                      // can sometimes get 'Permission denied to access property "handle Event'
-                  }
-                  return original.call(this, eventName, 
+          return original.call(this, wrap(callback, {
+              mechanism: {
+                  data: {
+                      function: 'requestAnimationFrame',
+                      handler: getFunctionName(original),
+                  },
+                  handled: true,
+                  type: 'instrument',
+              },
+          }));
+      };
+  }
+  /** JSDoc */
+  function _wrapXHR(originalSend) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      return function (...args) {
+          // eslint-disable-next-line @typescript-eslint/no-this-alias
+          const xhr = this;
+          const xmlHttpRequestProps = ['onload', 'onerror', 'onprogress', 'onreadystatechange'];
+          xmlHttpRequestProps.forEach(prop => {
+              if (prop in xhr && typeof xhr[prop] === 'function') {
                   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                  wrap(fn, {
-                      mechanism: {
-                          data: {
-                              function: 'addEventListener',
-                              handler: getFunctionName(fn),
-                              target,
+                  fill(xhr, prop, function (original) {
+                      const wrapOptions = {
+                          mechanism: {
+                              data: {
+                                  function: prop,
+                                  handler: getFunctionName(original),
+                              },
+                              handled: true,
+                              type: 'instrument',
                           },
-                          handled: true,
-                          type: 'instrument',
-                      },
-                  }), options);
-              };
-          });
-          fill(proto, 'removeEventListener', function (originalRemoveEventListener) {
-              return function (eventName, fn, options) {
-                  var _a;
-                  /**
-                   * There are 2 possible scenarios here:
-                   *
-                   * 1. Someone passes a callback, which was attached prior to Sentry initialization, or by using unmodified
-                   * method, eg. `document.addEventListener.call(el, name, handler). In this case, we treat this function
-                   * as a pass-through, and call original `removeEventListener` with it.
-                   *
-                   * 2. Someone passes a callback, which was attached after Sentry was initialized, which means that it was using
-                   * our wrapped version of `addEventListener`, which internally calls `wrap` helper.
-                   * This helper "wraps" whole callback inside a try/catch statement, and attached appropriate metadata to it,
-                   * in order for us to make a distinction between wrapped/non-wrapped functions possible.
-                   * If a function was wrapped, it has additional property of `__sentry_wrapped__`, holding the handler.
-                   *
-                   * When someone adds a handler prior to initialization, and then do it again, but after,
-                   * then we have to detach both of them. Otherwise, if we'd detach only wrapped one, it'd be impossible
-                   * to get rid of the initial handler and it'd stick there forever.
-                   */
-                  const wrappedEventHandler = fn;
-                  try {
-                      const originalEventHandler = (_a = wrappedEventHandler) === null || _a === void 0 ? void 0 : _a.__sentry_wrapped__;
-                      if (originalEventHandler) {
-                          originalRemoveEventListener.call(this, eventName, originalEventHandler, options);
+                      };
+                      // If Instrument integration has been called before TryCatch, get the name of original function
+                      const originalFunction = getOriginalFunction(original);
+                      if (originalFunction) {
+                          wrapOptions.mechanism.data.handler = getFunctionName(originalFunction);
                       }
-                  }
-                  catch (e) {
-                      // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments
-                  }
-                  return originalRemoveEventListener.call(this, eventName, wrappedEventHandler, options);
-              };
+                      // Otherwise wrap directly
+                      return wrap(original, wrapOptions);
+                  });
+              }
           });
+          return originalSend.apply(this, args);
+      };
+  }
+  /** JSDoc */
+  function _wrapEventTarget(target) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const global = getGlobalObject();
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      const proto = global[target] && global[target].prototype;
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-prototype-builtins
+      if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {
+          return;
       }
-      /** JSDoc */
-      _wrapXHR(originalSend) {
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          return function (...args) {
-              // eslint-disable-next-line @typescript-eslint/no-this-alias
-              const xhr = this;
-              const xmlHttpRequestProps = ['onload', 'onerror', 'onprogress', 'onreadystatechange'];
-              xmlHttpRequestProps.forEach(prop => {
-                  if (prop in xhr && typeof xhr[prop] === 'function') {
-                      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                      fill(xhr, prop, function (original) {
-                          const wrapOptions = {
-                              mechanism: {
-                                  data: {
-                                      function: prop,
-                                      handler: getFunctionName(original),
-                                  },
-                                  handled: true,
-                                  type: 'instrument',
+      fill(proto, 'addEventListener', function (original) {
+          return function (eventName, fn, options) {
+              try {
+                  if (typeof fn.handleEvent === 'function') {
+                      fn.handleEvent = wrap(fn.handleEvent.bind(fn), {
+                          mechanism: {
+                              data: {
+                                  function: 'handleEvent',
+                                  handler: getFunctionName(fn),
+                                  target,
                               },
-                          };
-                          // If Instrument integration has been called before TryCatch, get the name of original function
-                          if (original.__sentry_original__) {
-                              wrapOptions.mechanism.data.handler = getFunctionName(original.__sentry_original__);
-                          }
-                          // Otherwise wrap directly
-                          return wrap(original, wrapOptions);
+                              handled: true,
+                              type: 'instrument',
+                          },
                       });
                   }
-              });
-              return originalSend.apply(this, args);
+              }
+              catch (err) {
+                  // can sometimes get 'Permission denied to access property "handle Event'
+              }
+              return original.call(this, eventName, 
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              wrap(fn, {
+                  mechanism: {
+                      data: {
+                          function: 'addEventListener',
+                          handler: getFunctionName(fn),
+                          target,
+                      },
+                      handled: true,
+                      type: 'instrument',
+                  },
+              }), options);
           };
-      }
-  }
-  /**
-   * @inheritDoc
-   */
-  TryCatch.id = 'TryCatch';
+      });
+      fill(proto, 'removeEventListener', function (originalRemoveEventListener) {
+          return function (eventName, fn, options) {
+              /**
+               * There are 2 possible scenarios here:
+               *
+               * 1. Someone passes a callback, which was attached prior to Sentry initialization, or by using unmodified
+               * method, eg. `document.addEventListener.call(el, name, handler). In this case, we treat this function
+               * as a pass-through, and call original `removeEventListener` with it.
+               *
+               * 2. Someone passes a callback, which was attached after Sentry was initialized, which means that it was using
+               * our wrapped version of `addEventListener`, which internally calls `wrap` helper.
+               * This helper "wraps" whole callback inside a try/catch statement, and attached appropriate metadata to it,
+               * in order for us to make a distinction between wrapped/non-wrapped functions possible.
+               * If a function was wrapped, it has additional property of `__sentry_wrapped__`, holding the handler.
+               *
+               * When someone adds a handler prior to initialization, and then do it again, but after,
+               * then we have to detach both of them. Otherwise, if we'd detach only wrapped one, it'd be impossible
+               * to get rid of the initial handler and it'd stick there forever.
+               */
+              const wrappedEventHandler = fn;
+              try {
+                  const originalEventHandler = wrappedEventHandler && wrappedEventHandler.__sentry_wrapped__;
+                  if (originalEventHandler) {
+                      originalRemoveEventListener.call(this, eventName, originalEventHandler, options);
+                  }
+              }
+              catch (e) {
+                  // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments
+              }
+              return originalRemoveEventListener.call(this, eventName, wrappedEventHandler, options);
+          };
+      });
+  }
 
   /* eslint-disable @typescript-eslint/no-unsafe-member-access */
   /**
@@ -6091,82 +5942,36 @@ var Sentry = (function (exports) {
        */
       setupOnce() {
           if (this._options.console) {
-              addInstrumentationHandler({
-                  callback: (...args) => {
-                      this._consoleBreadcrumb(...args);
-                  },
-                  type: 'console',
-              });
+              addInstrumentationHandler('console', _consoleBreadcrumb);
           }
           if (this._options.dom) {
-              addInstrumentationHandler({
-                  callback: (...args) => {
-                      this._domBreadcrumb(...args);
-                  },
-                  type: 'dom',
-              });
+              addInstrumentationHandler('dom', _domBreadcrumb(this._options.dom));
           }
           if (this._options.xhr) {
-              addInstrumentationHandler({
-                  callback: (...args) => {
-                      this._xhrBreadcrumb(...args);
-                  },
-                  type: 'xhr',
-              });
+              addInstrumentationHandler('xhr', _xhrBreadcrumb);
           }
           if (this._options.fetch) {
-              addInstrumentationHandler({
-                  callback: (...args) => {
-                      this._fetchBreadcrumb(...args);
-                  },
-                  type: 'fetch',
-              });
+              addInstrumentationHandler('fetch', _fetchBreadcrumb);
           }
           if (this._options.history) {
-              addInstrumentationHandler({
-                  callback: (...args) => {
-                      this._historyBreadcrumb(...args);
-                  },
-                  type: 'history',
-              });
-          }
-      }
-      /**
-       * Creates breadcrumbs from console API calls
-       */
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      _consoleBreadcrumb(handlerData) {
-          const breadcrumb = {
-              category: 'console',
-              data: {
-                  arguments: handlerData.args,
-                  logger: 'console',
-              },
-              level: exports.Severity.fromString(handlerData.level),
-              message: safeJoin(handlerData.args, ' '),
-          };
-          if (handlerData.level === 'assert') {
-              if (handlerData.args[0] === false) {
-                  breadcrumb.message = `Assertion failed: ${safeJoin(handlerData.args.slice(1), ' ') || 'console.assert'}`;
-                  breadcrumb.data.arguments = handlerData.args.slice(1);
-              }
-              else {
-                  // Don't capture a breadcrumb for passed assertions
-                  return;
-              }
+              addInstrumentationHandler('history', _historyBreadcrumb);
           }
-          getCurrentHub().addBreadcrumb(breadcrumb, {
-              input: handlerData.args,
-              level: handlerData.level,
-          });
       }
-      /**
-       * Creates breadcrumbs from DOM API calls
-       */
+  }
+  /**
+   * @inheritDoc
+   */
+  Breadcrumbs.id = 'Breadcrumbs';
+  /**
+   * A HOC that creaes a function that creates breadcrumbs from DOM API calls.
+   * This is a HOC so that we get access to dom options in the closure.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function _domBreadcrumb(dom) {
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      _domBreadcrumb(handlerData) {
+      function _innerDomBreadcrumb(handlerData) {
           let target;
-          let keyAttrs = typeof this._options.dom === 'object' ? this._options.dom.serializeAttribute : undefined;
+          let keyAttrs = typeof dom === 'object' ? dom.serializeAttribute : undefined;
           if (typeof keyAttrs === 'string') {
               keyAttrs = [keyAttrs];
           }
@@ -6191,103 +5996,129 @@ var Sentry = (function (exports) {
               global: handlerData.global,
           });
       }
-      /**
-       * Creates breadcrumbs from XHR API calls
-       */
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      _xhrBreadcrumb(handlerData) {
-          if (handlerData.endTimestamp) {
-              // We only capture complete, non-sentry requests
-              if (handlerData.xhr.__sentry_own_request__) {
-                  return;
-              }
-              const { method, url, status_code, body } = handlerData.xhr.__sentry_xhr__ || {};
-              getCurrentHub().addBreadcrumb({
-                  category: 'xhr',
-                  data: {
-                      method,
-                      url,
-                      status_code,
-                  },
-                  type: 'http',
-              }, {
-                  xhr: handlerData.xhr,
-                  input: body,
-              });
-              return;
-          }
-      }
-      /**
-       * Creates breadcrumbs from fetch API calls
-       */
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      _fetchBreadcrumb(handlerData) {
-          // We only capture complete fetch requests
-          if (!handlerData.endTimestamp) {
-              return;
-          }
-          if (handlerData.fetchData.url.match(/sentry_key/) && handlerData.fetchData.method === 'POST') {
-              // We will not create breadcrumbs for fetch requests that contain `sentry_key` (internal sentry requests)
-              return;
-          }
-          if (handlerData.error) {
-              getCurrentHub().addBreadcrumb({
-                  category: 'fetch',
-                  data: handlerData.fetchData,
-                  level: exports.Severity.Error,
-                  type: 'http',
-              }, {
-                  data: handlerData.error,
-                  input: handlerData.args,
-              });
+      return _innerDomBreadcrumb;
+  }
+  /**
+   * Creates breadcrumbs from console API calls
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function _consoleBreadcrumb(handlerData) {
+      const breadcrumb = {
+          category: 'console',
+          data: {
+              arguments: handlerData.args,
+              logger: 'console',
+          },
+          level: severityFromString(handlerData.level),
+          message: safeJoin(handlerData.args, ' '),
+      };
+      if (handlerData.level === 'assert') {
+          if (handlerData.args[0] === false) {
+              breadcrumb.message = `Assertion failed: ${safeJoin(handlerData.args.slice(1), ' ') || 'console.assert'}`;
+              breadcrumb.data.arguments = handlerData.args.slice(1);
           }
           else {
-              getCurrentHub().addBreadcrumb({
-                  category: 'fetch',
-                  data: Object.assign(Object.assign({}, handlerData.fetchData), { status_code: handlerData.response.status }),
-                  type: 'http',
-              }, {
-                  input: handlerData.args,
-                  response: handlerData.response,
-              });
+              // Don't capture a breadcrumb for passed assertions
+              return;
           }
       }
-      /**
-       * Creates breadcrumbs from history API calls
-       */
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      _historyBreadcrumb(handlerData) {
-          const global = getGlobalObject();
-          let from = handlerData.from;
-          let to = handlerData.to;
-          const parsedLoc = parseUrl(global.location.href);
-          let parsedFrom = parseUrl(from);
-          const parsedTo = parseUrl(to);
-          // Initial pushState doesn't provide `from` information
-          if (!parsedFrom.path) {
-              parsedFrom = parsedLoc;
-          }
-          // Use only the path component of the URL if the URL matches the current
-          // document (almost all the time when using pushState)
-          if (parsedLoc.protocol === parsedTo.protocol && parsedLoc.host === parsedTo.host) {
-              to = parsedTo.relative;
-          }
-          if (parsedLoc.protocol === parsedFrom.protocol && parsedLoc.host === parsedFrom.host) {
-              from = parsedFrom.relative;
+      getCurrentHub().addBreadcrumb(breadcrumb, {
+          input: handlerData.args,
+          level: handlerData.level,
+      });
+  }
+  /**
+   * Creates breadcrumbs from XHR API calls
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function _xhrBreadcrumb(handlerData) {
+      if (handlerData.endTimestamp) {
+          // We only capture complete, non-sentry requests
+          if (handlerData.xhr.__sentry_own_request__) {
+              return;
           }
+          const { method, url, status_code, body } = handlerData.xhr.__sentry_xhr__ || {};
           getCurrentHub().addBreadcrumb({
-              category: 'navigation',
+              category: 'xhr',
               data: {
-                  from,
-                  to,
+                  method,
+                  url,
+                  status_code,
               },
+              type: 'http',
+          }, {
+              xhr: handlerData.xhr,
+              input: body,
           });
+          return;
       }
   }
   /**
-   * @inheritDoc
+   * Creates breadcrumbs from fetch API calls
    */
-  Breadcrumbs.id = 'Breadcrumbs';
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function _fetchBreadcrumb(handlerData) {
+      // We only capture complete fetch requests
+      if (!handlerData.endTimestamp) {
+          return;
+      }
+      if (handlerData.fetchData.url.match(/sentry_key/) && handlerData.fetchData.method === 'POST') {
+          // We will not create breadcrumbs for fetch requests that contain `sentry_key` (internal sentry requests)
+          return;
+      }
+      if (handlerData.error) {
+          getCurrentHub().addBreadcrumb({
+              category: 'fetch',
+              data: handlerData.fetchData,
+              level: exports.Severity.Error,
+              type: 'http',
+          }, {
+              data: handlerData.error,
+              input: handlerData.args,
+          });
+      }
+      else {
+          getCurrentHub().addBreadcrumb({
+              category: 'fetch',
+              data: Object.assign(Object.assign({}, handlerData.fetchData), { status_code: handlerData.response.status }),
+              type: 'http',
+          }, {
+              input: handlerData.args,
+              response: handlerData.response,
+          });
+      }
+  }
+  /**
+   * Creates breadcrumbs from history API calls
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function _historyBreadcrumb(handlerData) {
+      const global = getGlobalObject();
+      let from = handlerData.from;
+      let to = handlerData.to;
+      const parsedLoc = parseUrl(global.location.href);
+      let parsedFrom = parseUrl(from);
+      const parsedTo = parseUrl(to);
+      // Initial pushState doesn't provide `from` information
+      if (!parsedFrom.path) {
+          parsedFrom = parsedLoc;
+      }
+      // Use only the path component of the URL if the URL matches the current
+      // document (almost all the time when using pushState)
+      if (parsedLoc.protocol === parsedTo.protocol && parsedLoc.host === parsedTo.host) {
+          to = parsedTo.relative;
+      }
+      if (parsedLoc.protocol === parsedFrom.protocol && parsedLoc.host === parsedFrom.host) {
+          from = parsedFrom.relative;
+      }
+      getCurrentHub().addBreadcrumb({
+          category: 'navigation',
+          data: {
+              from,
+              to,
+          },
+      });
+  }
 
   const DEFAULT_KEY = 'cause';
   const DEFAULT_LIMIT = 5;
@@ -6310,40 +6141,36 @@ var Sentry = (function (exports) {
       setupOnce() {
           addGlobalEventProcessor((event, hint) => {
               const self = getCurrentHub().getIntegration(LinkedErrors);
-              if (self) {
-                  const handler = self._handler && self._handler.bind(self);
-                  return typeof handler === 'function' ? handler(event, hint) : event;
-              }
-              return event;
+              return self ? _handler(self._key, self._limit, event, hint) : event;
           });
       }
-      /**
-       * @inheritDoc
-       */
-      _handler(event, hint) {
-          if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {
-              return event;
-          }
-          const linkedErrors = this._walkErrorTree(hint.originalException, this._key);
-          event.exception.values = [...linkedErrors, ...event.exception.values];
+  }
+  /**
+   * @inheritDoc
+   */
+  LinkedErrors.id = 'LinkedErrors';
+  /**
+   * @inheritDoc
+   */
+  function _handler(key, limit, event, hint) {
+      if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {
           return event;
       }
-      /**
-       * @inheritDoc
-       */
-      _walkErrorTree(error, key, stack = []) {
-          if (!isInstanceOf(error[key], Error) || stack.length + 1 >= this._limit) {
-              return stack;
-          }
-          const stacktrace = computeStackTrace(error[key]);
-          const exception = exceptionFromStacktrace(stacktrace);
-          return this._walkErrorTree(error[key], key, [exception, ...stack]);
-      }
+      const linkedErrors = _walkErrorTree(limit, hint.originalException, key);
+      event.exception.values = [...linkedErrors, ...event.exception.values];
+      return event;
   }
   /**
-   * @inheritDoc
+   * JSDOC
    */
-  LinkedErrors.id = 'LinkedErrors';
+  function _walkErrorTree(limit, error, key, stack = []) {
+      if (!isInstanceOf(error[key], Error) || stack.length + 1 >= limit) {
+          return stack;
+      }
+      const stacktrace = computeStackTrace(error[key]);
+      const exception = exceptionFromStacktrace(stacktrace);
+      return _walkErrorTree(limit, error[key], key, [exception, ...stack]);
+  }
 
   const global$6 = getGlobalObject();
   /** UserAgent */
@@ -6359,17 +6186,16 @@ var Sentry = (function (exports) {
        */
       setupOnce() {
           addGlobalEventProcessor((event) => {
-              var _a, _b, _c;
               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) {
                       return event;
                   }
                   // grab as much info as exists and add it to the event
-                  const url = ((_a = event.request) === null || _a === void 0 ? void 0 : _a.url) || ((_b = global$6.location) === null || _b === void 0 ? void 0 : _b.href);
+                  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 headers = Object.assign(Object.assign(Object.assign({}, (_c = event.request) === null || _c === void 0 ? void 0 : _c.headers), (referrer && { Referer: referrer })), (userAgent && { 'User-Agent': userAgent }));
+                  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 });
               }
@@ -6399,7 +6225,7 @@ var Sentry = (function (exports) {
               if (self) {
                   // Juuust in case something goes wrong
                   try {
-                      if (self._shouldDropEvent(currentEvent, self._previousEvent)) {
+                      if (_shouldDropEvent(currentEvent, self._previousEvent)) {
                           logger.warn(`Event dropped due to being a duplicate of previously captured event.`);
                           return null;
                       }
@@ -6412,139 +6238,139 @@ var Sentry = (function (exports) {
               return currentEvent;
           });
       }
-      /** JSDoc */
-      _shouldDropEvent(currentEvent, previousEvent) {
-          if (!previousEvent) {
-              return false;
-          }
-          if (this._isSameMessageEvent(currentEvent, previousEvent)) {
-              return true;
-          }
-          if (this._isSameExceptionEvent(currentEvent, previousEvent)) {
-              return true;
-          }
+  }
+  /**
+   * @inheritDoc
+   */
+  Dedupe.id = 'Dedupe';
+  /** JSDoc */
+  function _shouldDropEvent(currentEvent, previousEvent) {
+      if (!previousEvent) {
           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;
-          }
+      if (_isSameMessageEvent(currentEvent, previousEvent)) {
           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;
+      if (_isSameExceptionEvent(currentEvent, previousEvent)) {
+          return true;
       }
-      /** 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 false;
+  }
+  /** JSDoc */
+  function _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 (!_isSameFingerprint(currentEvent, previousEvent)) {
+          return false;
+      }
+      if (!_isSameStacktrace(currentEvent, previousEvent)) {
+          return false;
+      }
+      return true;
+  }
+  /** JSDoc */
+  function _isSameExceptionEvent(currentEvent, previousEvent) {
+      const previousException = _getExceptionFromEvent(previousEvent);
+      const currentException = _getExceptionFromEvent(currentEvent);
+      if (!previousException || !currentException) {
+          return false;
+      }
+      if (previousException.type !== currentException.type || previousException.value !== currentException.value) {
+          return false;
+      }
+      if (!_isSameFingerprint(currentEvent, previousEvent)) {
+          return false;
+      }
+      if (!_isSameStacktrace(currentEvent, previousEvent)) {
+          return false;
+      }
+      return true;
+  }
+  /** JSDoc */
+  function _isSameStacktrace(currentEvent, previousEvent) {
+      let currentFrames = _getFramesFromEvent(currentEvent);
+      let previousFrames = _getFramesFromEvent(previousEvent);
+      // If neither event has a stacktrace, they are assumed to be the same
+      if (!currentFrames && !previousFrames) {
           return true;
       }
-      /** JSDoc */
-      _getExceptionFromEvent(event) {
-          return event.exception && event.exception.values && event.exception.values[0];
+      // If only one event has a stacktrace, but not the other one, they are not the same
+      if ((currentFrames && !previousFrames) || (!currentFrames && previousFrames)) {
+          return false;
       }
-      /** 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)) {
+      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 */
+  function _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;
       }
-      /** 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
+      // 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;
+      }
+  }
+  /** JSDoc */
+  function _getExceptionFromEvent(event) {
+      return event.exception && event.exception.values && event.exception.values[0];
+  }
+  /** JSDoc */
+  function _getFramesFromEvent(event) {
+      const exception = event.exception;
+      if (exception) {
           try {
-              return !!(currentFingerprint.join('') === previousFingerprint.join(''));
+              // @ts-ignore Object could be undefined
+              return exception.values[0].stacktrace.frames;
           }
           catch (_oO) {
-              return false;
+              return undefined;
           }
       }
-  }
-  /**
-   * @inheritDoc
-   */
-  Dedupe.id = 'Dedupe';
+      else if (event.stacktrace) {
+          return event.stacktrace.frames;
+      }
+      return undefined;
+  }
 
 
 
@@ -6763,8 +6589,10 @@ var Sentry = (function (exports) {
       if (client) {
           return client.flush(timeout);
       }
-      logger.warn('Cannot flush events. No client defined.');
-      return SyncPromise.resolve(false);
+      if (isDebugBuild()) {
+          logger.warn('Cannot flush events. No client defined.');
+      }
+      return resolvedSyncPromise(false);
   }
   /**
    * Call `close()` on the current client, if there is one. See {@link Client.close}.
@@ -6779,8 +6607,10 @@ var Sentry = (function (exports) {
       if (client) {
           return client.close(timeout);
       }
-      logger.warn('Cannot flush events and disable SDK. No client defined.');
-      return SyncPromise.resolve(false);
+      if (isDebugBuild()) {
+          logger.warn('Cannot flush events and disable SDK. No client defined.');
+      }
+      return resolvedSyncPromise(false);
   }
   /**
    * Wrap code within a try/catch block so the SDK is able to capture errors.
@@ -6793,6 +6623,10 @@ var Sentry = (function (exports) {
   function wrap$1(fn) {
       return wrap(fn)();
   }
+  function startSessionOnHub(hub) {
+      hub.startSession({ ignoreDuration: true });
+      hub.captureSession();
+  }
   /**
    * Enable automatic Session Tracking for the initial page load.
    */
@@ -6800,7 +6634,9 @@ var Sentry = (function (exports) {
       const window = getGlobalObject();
       const document = window.document;
       if (typeof document === 'undefined') {
-          logger.warn('Session tracking in non-browser environment with @sentry/browser is not supported.');
+          if (isDebugBuild()) {
+              logger.warn('Session tracking in non-browser environment with @sentry/browser is not supported.');
+          }
           return;
       }
       const hub = getCurrentHub();
@@ -6810,26 +6646,20 @@ var Sentry = (function (exports) {
       // https://github.com/getsentry/sentry-javascript/issues/3207 and
       // https://github.com/getsentry/sentry-javascript/issues/3234 and
       // https://github.com/getsentry/sentry-javascript/issues/3278.
-      if (typeof hub.startSession !== 'function' || typeof hub.captureSession !== 'function') {
+      if (!hub.captureSession) {
           return;
       }
       // The session duration for browser sessions does not track a meaningful
       // concept that can be used as a metric.
       // Automatically captured sessions are akin to page views, and thus we
       // discard their duration.
-      hub.startSession({ ignoreDuration: true });
-      hub.captureSession();
+      startSessionOnHub(hub);
       // We want to create a session for every navigation as well
-      addInstrumentationHandler({
-          callback: ({ from, to }) => {
-              // Don't create an additional session for the initial route or if the location did not change
-              if (from === undefined || from === to) {
-                  return;
-              }
-              hub.startSession({ ignoreDuration: true });
-              hub.captureSession();
-          },
-          type: 'history',
+      addInstrumentationHandler('history', ({ from, to }) => {
+          // Don't create an additional session for the initial route or if the location did not change
+          if (!(from === undefined || from === to)) {
+              startSessionOnHub(getCurrentHub());
+          }
       });
   }