@sentry/browser 6.19.2 → 6.19.5

package/{bundles → build}/bundle.es6.js

@@ -1,4 +1,4 @@
-/*! @sentry/browser 6.19.2 (f49c509) | https://github.com/getsentry/sentry-javascript */
+/*! @sentry/browser 6.19.5 (755d2cd) | https://github.com/getsentry/sentry-javascript */
 var Sentry = (function (exports) {
 
   /**
@@ -35,22 +35,6 @@ var Sentry = (function (exports) {
       });
   }
 
-  /**
-   * This module exists for optimizations in the build process through rollup and terser.  We define some global
-   * constants, which can be overridden during build. By guarding certain pieces of code with functions that return these
-   * constants, we can control whether or not they appear in the final bundle. (Any code guarded by a false condition will
-   * never run, and will hence be dropped during treeshaking.) The two primary uses for this are stripping out calls to
-   * `logger` and preventing node-related code from appearing in browser bundles.
-   */
-  /**
-   * Figures out if we're building with debug functionality.
-   *
-   * @returns true if this is a debug build
-   */
-  function isDebugBuild() {
-      return true;
-  }
-
   /**
    * 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.
@@ -67,6 +51,23 @@ var Sentry = (function (exports) {
               : typeof self !== 'undefined'
                   ? self
                   : fallbackGlobalObject);
+  }
+  /**
+   * Returns a global singleton contained in the global `__SENTRY__` object.
+   *
+   * If the singleton doesn't already exist in `__SENTRY__`, it will be created using the given factory
+   * function and added to the `__SENTRY__` object.
+   *
+   * @param name name of the global singleton on __SENTRY__
+   * @param creator creator Factory function to create the singleton if it doesn't already exist on `__SENTRY__`
+   * @param obj (Optional) The global object on which to look for `__SENTRY__`, if not `getGlobalObject`'s return value
+   * @returns the singleton
+   */
+  function getGlobalSingleton(name, creator, obj) {
+      const global = (obj || getGlobalObject());
+      const __SENTRY__ = (global.__SENTRY__ = global.__SENTRY__ || {});
+      const singleton = __SENTRY__[name] || (__SENTRY__[name] = creator());
+      return singleton;
   }
 
   /* eslint-disable @typescript-eslint/no-explicit-any */
@@ -201,6 +202,16 @@ var Sentry = (function (exports) {
   function isSyntheticEvent(wat) {
       return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;
   }
+  /**
+   * Checks whether given value is NaN
+   * {@link isNaN}.
+   *
+   * @param wat A value to be checked.
+   * @returns A boolean representing the result.
+   */
+  function isNaN$1(wat) {
+      return typeof wat === 'number' && wat !== wat;
+  }
   /**
    * Checks whether given value's type is an instance of provided constructor.
    * {@link isInstanceOf}.
@@ -355,6 +366,22 @@ var Sentry = (function (exports) {
       }
   }
 
+  /*
+   * This file defines flags and constants that can be modified during compile time in order to facilitate tree shaking
+   * for users.
+   *
+   * Debug flags need to be declared in each package individually and must not be imported across package boundaries,
+   * because some build tools have trouble tree-shaking imported guards.
+   *
+   * As a convention, we define debug flags in a `flags.ts` file in the root of a package's `src` folder.
+   *
+   * Debug flag files will contain "magic strings" like `true` that may get replaced with actual values during
+   * our, or the user's build process. Take care when introducing new flags - they must not throw if they are not
+   * replaced.
+   */
+  /** Flag that is true for debug builds, false otherwise. */
+  const IS_DEBUG_BUILD$3 = true;
+
   /** Regular expression used to parse a Dsn. */
   const DSN_REGEX = /^(?:(\w+):)\/\/(?:(\w+)(?::(\w+))?@)([\w.-]+)(?::(\d+))?\/(.+)/;
   function isValidProtocol(protocol) {
@@ -412,6 +439,9 @@ var Sentry = (function (exports) {
       };
   }
   function validateDsn(dsn) {
+      if (!IS_DEBUG_BUILD$3) {
+          return;
+      }
       const { port, projectId, protocol } = dsn;
       const requiredComponents = ['protocol', 'publicKey', 'host', 'projectId'];
       requiredComponents.forEach(component => {
@@ -445,8 +475,7 @@ var Sentry = (function (exports) {
   const PREFIX = 'Sentry Logger ';
   const CONSOLE_LEVELS = ['debug', 'info', 'warn', 'error', 'log', 'assert'];
   /**
-   * Temporarily unwrap `console.log` and friends in order to perform the given callback using the original methods.
-   * Restores wrapping after the callback completes.
+   * Temporarily disable sentry console instrumentations.
    *
    * @param callback The function to run against the original `console` messages
    * @returns The results of the callback
@@ -456,73 +485,63 @@ var Sentry = (function (exports) {
       if (!('console' in global)) {
           return callback();
       }
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
       const originalConsole = global.console;
       const wrappedLevels = {};
       // Restore all wrapped console methods
       CONSOLE_LEVELS.forEach(level => {
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-          if (level in global.console && originalConsole[level].__sentry_original__) {
+          // TODO(v7): Remove this check as it's only needed for Node 6
+          const originalWrappedFunc = originalConsole[level] && originalConsole[level].__sentry_original__;
+          if (level in global.console && originalWrappedFunc) {
               wrappedLevels[level] = originalConsole[level];
-              originalConsole[level] = originalConsole[level].__sentry_original__;
+              originalConsole[level] = originalWrappedFunc;
           }
       });
-      // Perform callback manipulations
-      const result = callback();
-      // Revert restoration to wrapped state
-      Object.keys(wrappedLevels).forEach(level => {
-          originalConsole[level] = wrappedLevels[level];
-      });
-      return result;
-  }
-  /** JSDoc */
-  class Logger {
-      /** JSDoc */
-      constructor() {
-          this._enabled = false;
-      }
-      /** JSDoc */
-      disable() {
-          this._enabled = false;
-      }
-      /** JSDoc */
-      enable() {
-          this._enabled = true;
+      try {
+          return callback();
       }
-      /** JSDoc */
-      log(...args) {
-          if (!this._enabled) {
-              return;
-          }
-          consoleSandbox(() => {
-              global$6.console.log(`${PREFIX}[Log]:`, ...args);
+      finally {
+          // Revert restoration to wrapped state
+          Object.keys(wrappedLevels).forEach(level => {
+              originalConsole[level] = wrappedLevels[level];
           });
       }
-      /** JSDoc */
-      warn(...args) {
-          if (!this._enabled) {
-              return;
-          }
-          consoleSandbox(() => {
-              global$6.console.warn(`${PREFIX}[Warn]:`, ...args);
+  }
+  function makeLogger() {
+      let enabled = false;
+      const logger = {
+          enable: () => {
+              enabled = true;
+          },
+          disable: () => {
+              enabled = false;
+          },
+      };
+      if (IS_DEBUG_BUILD$3) {
+          CONSOLE_LEVELS.forEach(name => {
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              logger[name] = (...args) => {
+                  if (enabled) {
+                      consoleSandbox(() => {
+                          global$6.console[name](`${PREFIX}[${name}]:`, ...args);
+                      });
+                  }
+              };
           });
       }
-      /** JSDoc */
-      error(...args) {
-          if (!this._enabled) {
-              return;
-          }
-          consoleSandbox(() => {
-              global$6.console.error(`${PREFIX}[Error]:`, ...args);
+      else {
+          CONSOLE_LEVELS.forEach(name => {
+              logger[name] = () => undefined;
           });
       }
+      return logger;
+  }
+  // Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used
+  let logger;
+  if (IS_DEBUG_BUILD$3) {
+      logger = getGlobalSingleton('logger', makeLogger);
   }
-  const sentryGlobal = global$6.__SENTRY__ || {};
-  const logger = sentryGlobal.logger || new Logger();
-  {
-      // Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used
-      sentryGlobal.logger = logger;
-      global$6.__SENTRY__ = sentryGlobal;
+  else {
+      logger = makeLogger();
   }
 
   /**
@@ -664,55 +683,38 @@ var Sentry = (function (exports) {
    *
    * @param value Initial source that we have to transform in order for it to be usable by the serializer
    */
-  function getWalkSource(value) {
+  function convertToPlainObject(value) {
+      let newObj = value;
       if (isError(value)) {
-          const error = value;
-          const err = {
-              message: error.message,
-              name: error.name,
-              stack: error.stack,
-          };
-          for (const i in error) {
-              if (Object.prototype.hasOwnProperty.call(error, i)) {
-                  err[i] = error[i];
-              }
-          }
-          return err;
+          newObj = Object.assign({ message: value.message, name: value.name, stack: value.stack }, getOwnProperties(value));
       }
-      if (isEvent(value)) {
+      else if (isEvent(value)) {
           const event = value;
-          const source = {};
-          // Accessing event attributes can throw (see https://github.com/getsentry/sentry-javascript/issues/768 and
-          // https://github.com/getsentry/sentry-javascript/issues/838), but accessing `type` hasn't been wrapped in a
-          // try-catch in at least two years and no one's complained, so that's likely not an issue anymore
-          source.type = event.type;
-          try {
-              source.target = isElement(event.target)
-                  ? htmlTreeAsString(event.target)
-                  : Object.prototype.toString.call(event.target);
-          }
-          catch (_oO) {
-              source.target = '<unknown>';
-          }
-          try {
-              source.currentTarget = isElement(event.currentTarget)
-                  ? htmlTreeAsString(event.currentTarget)
-                  : Object.prototype.toString.call(event.currentTarget);
-          }
-          catch (_oO) {
-              source.currentTarget = '<unknown>';
-          }
+          newObj = Object.assign({ type: event.type, target: serializeEventTarget(event.target), currentTarget: serializeEventTarget(event.currentTarget) }, getOwnProperties(event));
           if (typeof CustomEvent !== 'undefined' && isInstanceOf(value, CustomEvent)) {
-              source.detail = event.detail;
+              newObj.detail = event.detail;
           }
-          for (const attr in event) {
-              if (Object.prototype.hasOwnProperty.call(event, attr)) {
-                  source[attr] = event[attr];
-              }
+      }
+      return newObj;
+  }
+  /** Creates a string representation of the target of an `Event` object */
+  function serializeEventTarget(target) {
+      try {
+          return isElement(target) ? htmlTreeAsString(target) : Object.prototype.toString.call(target);
+      }
+      catch (_oO) {
+          return '<unknown>';
+      }
+  }
+  /** Filters out all but an object's own properties */
+  function getOwnProperties(obj) {
+      const extractedProps = {};
+      for (const property in obj) {
+          if (Object.prototype.hasOwnProperty.call(obj, property)) {
+              extractedProps[property] = obj[property];
           }
-          return source;
       }
-      return value;
+      return extractedProps;
   }
   /**
    * Given any captured exception, extract its keys and create a sorted
@@ -721,7 +723,7 @@ var Sentry = (function (exports) {
    */
   // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
   function extractExceptionKeysForMessage(exception, maxLength = 40) {
-      const keys = Object.keys(getWalkSource(exception));
+      const keys = Object.keys(convertToPlainObject(exception));
       keys.sort();
       if (!keys.length) {
           return '[object has no keys]';
@@ -747,11 +749,10 @@ var Sentry = (function (exports) {
    */
   function dropUndefinedKeys(val) {
       if (isPlainObject(val)) {
-          const obj = val;
           const rv = {};
-          for (const key of Object.keys(obj)) {
-              if (typeof obj[key] !== 'undefined') {
-                  rv[key] = dropUndefinedKeys(obj[key]);
+          for (const key of Object.keys(val)) {
+              if (typeof val[key] !== 'undefined') {
+                  rv[key] = dropUndefinedKeys(val[key]);
               }
           }
           return rv;
@@ -1631,10 +1632,10 @@ var Sentry = (function (exports) {
   function normalize(input, depth = +Infinity, maxProperties = +Infinity) {
       try {
           // since we're at the outermost level, there is no key
-          return walk('', input, depth, maxProperties);
+          return visit('', input, depth, maxProperties);
       }
-      catch (_oO) {
-          return '**non-serializable**';
+      catch (err) {
+          return { ERROR: `**non-serializable** (${err})` };
       }
   }
   /** JSDoc */
@@ -1643,142 +1644,142 @@ var Sentry = (function (exports) {
   depth = 3, 
   // 100kB, as 200kB is max payload size, so half sounds reasonable
   maxSize = 100 * 1024) {
-      const serialized = normalize(object, depth);
-      if (jsonSize(serialized) > maxSize) {
+      const normalized = normalize(object, depth);
+      if (jsonSize(normalized) > maxSize) {
           return normalizeToSize(object, depth - 1, maxSize);
       }
-      return serialized;
+      return normalized;
   }
   /**
-   * Walks an object to perform a normalization on it
+   * Visits a node to perform normalization on it
    *
-   * @param key of object that's walked in current iteration
-   * @param value object to be walked
-   * @param depth Optional number indicating how deep should walking be performed
-   * @param maxProperties Optional maximum  number of properties/elements included in any single object/array
+   * @param key The key corresponding to the given node
+   * @param value The node to be visited
+   * @param depth Optional number indicating the maximum recursion depth
+   * @param maxProperties Optional maximum number of properties/elements included in any single object/array
    * @param memo Optional Memo class handling decycling
    */
-  function walk(key, value, depth = +Infinity, maxProperties = +Infinity, memo = memoBuilder()) {
+  function visit(key, value, depth = +Infinity, maxProperties = +Infinity, memo = memoBuilder()) {
       const [memoize, unmemoize] = memo;
-      // If we reach the maximum depth, serialize whatever is left
+      // If the value has a `toJSON` method, see if we can bail and let it do the work
+      const valueWithToJSON = value;
+      if (valueWithToJSON && typeof valueWithToJSON.toJSON === 'function') {
+          try {
+              return valueWithToJSON.toJSON();
+          }
+          catch (err) {
+              // pass (The built-in `toJSON` failed, but we can still try to do it ourselves)
+          }
+      }
+      // Get the simple cases out of the way first
+      if (value === null || (['number', 'boolean', 'string'].includes(typeof value) && !isNaN$1(value))) {
+          return value;
+      }
+      const stringified = stringifyValue(key, value);
+      // Anything we could potentially dig into more (objects or arrays) will have come back as `"[object XXXX]"`.
+      // Everything else will have already been serialized, so if we don't see that pattern, we're done.
+      if (!stringified.startsWith('[object ')) {
+          return stringified;
+      }
+      // We're also done if we've reached the max depth
       if (depth === 0) {
-          return serializeValue(value);
-      }
-      // If value implements `toJSON` method, call it and return early
-      if (value !== null && value !== undefined && typeof value.toJSON === 'function') {
-          return value.toJSON();
-      }
-      // `makeSerializable` provides a string representation of certain non-serializable values. For all others, it's a
-      // pass-through. If what comes back is a primitive (either because it's been stringified or because it was primitive
-      // all along), we're done.
-      const serializable = makeSerializable(value, key);
-      if (isPrimitive(serializable)) {
-          return serializable;
-      }
-      // 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
+          // At this point we know `serialized` is a string of the form `"[object XXXX]"`. Clean it up so it's just `"[XXXX]"`.
+          return stringified.replace('object ', '');
+      }
+      // If we've already visited this branch, bail out, as it's circular reference. If not, note that we're seeing it now.
       if (memoize(value)) {
           return '[Circular ~]';
       }
-      let propertyCount = 0;
-      // Walk all keys of the source
-      for (const innerKey in source) {
+      // At this point we know we either have an object or an array, we haven't seen it before, and we're going to recurse
+      // because we haven't yet reached the max depth. Create an accumulator to hold the results of visiting each
+      // property/entry, and keep track of the number of items we add to it.
+      const normalized = (Array.isArray(value) ? [] : {});
+      let numAdded = 0;
+      // Before we begin, convert`Error` and`Event` instances into plain objects, since some of each of their relevant
+      // properties are non-enumerable and otherwise would get missed.
+      const visitable = (isError(value) || isEvent(value) ? convertToPlainObject(value) : value);
+      for (const visitKey in visitable) {
           // Avoid iterating over fields in the prototype if they've somehow been exposed to enumeration.
-          if (!Object.prototype.hasOwnProperty.call(source, innerKey)) {
+          if (!Object.prototype.hasOwnProperty.call(visitable, visitKey)) {
               continue;
           }
-          if (propertyCount >= maxProperties) {
-              acc[innerKey] = '[MaxProperties ~]';
+          if (numAdded >= maxProperties) {
+              normalized[visitKey] = '[MaxProperties ~]';
               break;
           }
-          propertyCount += 1;
-          // Recursively walk through all the child nodes
-          const innerValue = source[innerKey];
-          acc[innerKey] = walk(innerKey, innerValue, depth - 1, maxProperties, memo);
+          // Recursively visit all the child nodes
+          const visitValue = visitable[visitKey];
+          normalized[visitKey] = visit(visitKey, visitValue, depth - 1, maxProperties, memo);
+          numAdded += 1;
       }
-      // Once walked through all the branches, remove the parent from memo storage
+      // Once we've visited all the branches, remove the parent from memo storage
       unmemoize(value);
       // Return accumulated values
-      return acc;
-  }
-  /**
-   * Transform any non-primitive, BigInt, or Symbol-type value into a string. Acts as a no-op on strings, numbers,
-   * booleans, null, and undefined.
-   *
-   * @param value The value to stringify
-   * @returns For non-primitive, BigInt, and Symbol-type values, a string denoting the value's type, type and value, or
-   *  type and `description` property, respectively. For non-BigInt, non-Symbol primitives, returns the original value,
-   *  unchanged.
-   */
-  function serializeValue(value) {
-      // Node.js REPL notation
-      if (typeof value === 'string') {
-          return value;
-      }
-      const type = Object.prototype.toString.call(value);
-      if (type === '[object Object]') {
-          return '[Object]';
-      }
-      if (type === '[object Array]') {
-          return '[Array]';
-      }
-      // `makeSerializable` provides a string representation of certain non-serializable values. For all others, it's a
-      // pass-through.
-      const serializable = makeSerializable(value);
-      return isPrimitive(serializable) ? serializable : type;
+      return normalized;
   }
   /**
-   * makeSerializable()
+   * Stringify the given value. Handles various known special values and types.
    *
-   * Takes unserializable input and make it serializer-friendly.
+   * Not meant to be used on simple primitives which already have a string representation, as it will, for example, turn
+   * the number 1231 into "[Object Number]", nor on `null`, as it will throw.
    *
-   * Handles globals, functions, `undefined`, `NaN`, and other non-serializable values.
+   * @param value The value to stringify
+   * @returns A stringified representation of the given value
    */
-  function makeSerializable(value, key) {
-      if (key === 'domain' && value && typeof value === 'object' && value._events) {
-          return '[Domain]';
-      }
-      if (key === 'domainEmitter') {
-          return '[DomainEmitter]';
-      }
-      if (typeof global !== 'undefined' && value === global) {
-          return '[Global]';
-      }
-      // It's safe to use `window` and `document` here in this manner, as we are asserting using `typeof` first
-      // which won't throw if they are not present.
-      // eslint-disable-next-line no-restricted-globals
-      if (typeof window !== 'undefined' && value === window) {
-          return '[Window]';
-      }
-      // eslint-disable-next-line no-restricted-globals
-      if (typeof document !== 'undefined' && value === document) {
-          return '[Document]';
-      }
-      // React's SyntheticEvent thingy
-      if (isSyntheticEvent(value)) {
-          return '[SyntheticEvent]';
-      }
-      if (typeof value === 'number' && value !== value) {
-          return '[NaN]';
-      }
-      if (value === void 0) {
-          return '[undefined]';
-      }
-      if (typeof value === 'function') {
-          return `[Function: ${getFunctionName(value)}]`;
-      }
-      // symbols and bigints are considered primitives by TS, but aren't natively JSON-serilaizable
-      if (typeof value === 'symbol') {
-          return `[${String(value)}]`;
+  function stringifyValue(key, 
+  // this type is a tiny bit of a cheat, since this function does handle NaN (which is technically a number), but for
+  // our internal use, it'll do
+  value) {
+      try {
+          if (key === 'domain' && value && typeof value === 'object' && value._events) {
+              return '[Domain]';
+          }
+          if (key === 'domainEmitter') {
+              return '[DomainEmitter]';
+          }
+          // It's safe to use `global`, `window`, and `document` here in this manner, as we are asserting using `typeof` first
+          // which won't throw if they are not present.
+          if (typeof global !== 'undefined' && value === global) {
+              return '[Global]';
+          }
+          // eslint-disable-next-line no-restricted-globals
+          if (typeof window !== 'undefined' && value === window) {
+              return '[Window]';
+          }
+          // eslint-disable-next-line no-restricted-globals
+          if (typeof document !== 'undefined' && value === document) {
+              return '[Document]';
+          }
+          // React's SyntheticEvent thingy
+          if (isSyntheticEvent(value)) {
+              return '[SyntheticEvent]';
+          }
+          if (typeof value === 'number' && value !== value) {
+              return '[NaN]';
+          }
+          // this catches `undefined` (but not `null`, which is a primitive and can be serialized on its own)
+          if (value === void 0) {
+              return '[undefined]';
+          }
+          if (typeof value === 'function') {
+              return `[Function: ${getFunctionName(value)}]`;
+          }
+          if (typeof value === 'symbol') {
+              return `[${String(value)}]`;
+          }
+          // stringified BigInts are indistinguishable from regular numbers, so we need to label them to avoid confusion
+          if (typeof value === 'bigint') {
+              return `[BigInt: ${String(value)}]`;
+          }
+          // Now that we've knocked out all the special cases and the primitives, all we have left are objects. Simply casting
+          // them to strings means that instances of classes which haven't defined their `toStringTag` will just come out as
+          // `"[object Object]"`. If we instead look at the constructor's name (which is the same as the name of the class),
+          // we can make sure that only plain objects come out that way.
+          return `[object ${Object.getPrototypeOf(value).constructor.name}]`;
       }
-      if (typeof value === 'bigint') {
-          return `[BigInt: ${String(value)}]`;
+      catch (err) {
+          return `**non-serializable** (${err})`;
       }
-      return value;
   }
   /** Calculates bytes size of input string */
   function utf8Length(value) {
@@ -2190,6 +2191,13 @@ var Sentry = (function (exports) {
   function createEnvelope(headers, items = []) {
       return [headers, items];
   }
+  /**
+   * Get the type of the envelope. Grabs the type from the first envelope item.
+   */
+  function getEnvelopeType(envelope) {
+      const [, [[firstItemHeader]]] = envelope;
+      return firstItemHeader.type;
+  }
   /**
    * Serializes an envelope into a string.
    */
@@ -2719,12 +2727,7 @@ var Sentry = (function (exports) {
    * Returns the global event processors.
    */
   function getGlobalEventProcessors() {
-      /* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access  */
-      const global = getGlobalObject();
-      global.__SENTRY__ = global.__SENTRY__ || {};
-      global.__SENTRY__.globalEventProcessors = global.__SENTRY__.globalEventProcessors || [];
-      return global.__SENTRY__.globalEventProcessors;
-      /* eslint-enable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access */
+      return getGlobalSingleton('globalEventProcessors', () => []);
   }
   /**
    * Add a EventProcessor to be kept globally.
@@ -2844,6 +2847,22 @@ var Sentry = (function (exports) {
       }
   }
 
+  /*
+   * This file defines flags and constants that can be modified during compile time in order to facilitate tree shaking
+   * for users.
+   *
+   * Debug flags need to be declared in each package individually and must not be imported across package boundaries,
+   * because some build tools have trouble tree-shaking imported guards.
+   *
+   * As a convention, we define debug flags in a `flags.ts` file in the root of a package's `src` folder.
+   *
+   * Debug flag files will contain "magic strings" like `true` that may get replaced with actual values during
+   * our, or the user's build process. Take care when introducing new flags - they must not throw if they are not
+   * replaced.
+   */
+  /** Flag that is true for debug builds, false otherwise. */
+  const IS_DEBUG_BUILD$2 = true;
+
   /**
    * API compatibility version of this hub.
    *
@@ -3116,7 +3135,7 @@ var Sentry = (function (exports) {
               return client.getIntegration(integration);
           }
           catch (_oO) {
-              logger.warn(`Cannot retrieve integration ${integration.id} from the current Hub`);
+              IS_DEBUG_BUILD$2 && logger.warn(`Cannot retrieve integration ${integration.id} from the current Hub`);
               return null;
           }
       }
@@ -3227,7 +3246,7 @@ var Sentry = (function (exports) {
           if (sentry && sentry.extensions && typeof sentry.extensions[method] === 'function') {
               return sentry.extensions[method].apply(this, args);
           }
-          logger.warn(`Extension method ${method} couldn't be found, doing nothing.`);
+          IS_DEBUG_BUILD$2 && logger.warn(`Extension method ${method} couldn't be found, doing nothing.`);
       }
   }
   /**
@@ -3287,11 +3306,7 @@ var Sentry = (function (exports) {
    * @hidden
    */
   function getHubFromCarrier(carrier) {
-      if (carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub)
-          return carrier.__SENTRY__.hub;
-      carrier.__SENTRY__ = carrier.__SENTRY__ || {};
-      carrier.__SENTRY__.hub = new Hub();
-      return carrier.__SENTRY__.hub;
+      return getGlobalSingleton('hub', () => new Hub(), carrier);
   }
   /**
    * This will set passed {@link Hub} on the passed object's __SENTRY__.hub attribute
@@ -3302,8 +3317,8 @@ var Sentry = (function (exports) {
   function setHubOnCarrier(carrier, hub) {
       if (!carrier)
           return false;
-      carrier.__SENTRY__ = carrier.__SENTRY__ || {};
-      carrier.__SENTRY__.hub = hub;
+      const __SENTRY__ = (carrier.__SENTRY__ = carrier.__SENTRY__ || {});
+      __SENTRY__.hub = hub;
       return true;
   }
 
@@ -3545,6 +3560,22 @@ var Sentry = (function (exports) {
       return `${endpoint}?${encodedOptions}`;
   }
 
+  /*
+   * This file defines flags and constants that can be modified during compile time in order to facilitate tree shaking
+   * for users.
+   *
+   * Debug flags need to be declared in each package individually and must not be imported across package boundaries,
+   * because some build tools have trouble tree-shaking imported guards.
+   *
+   * As a convention, we define debug flags in a `flags.ts` file in the root of a package's `src` folder.
+   *
+   * Debug flag files will contain "magic strings" like `true` that may get replaced with actual values during
+   * our, or the user's build process. Take care when introducing new flags - they must not throw if they are not
+   * replaced.
+   */
+  /** Flag that is true for debug builds, false otherwise. */
+  const IS_DEBUG_BUILD$1 = true;
+
   const installedIntegrations = [];
   /**
    * @private
@@ -3888,7 +3919,7 @@ var Sentry = (function (exports) {
               if (evt) {
                   // TODO this is more of the hack trying to solve https://github.com/getsentry/sentry-javascript/issues/2809
                   // it is only attached as extra data to the event if the event somehow skips being normalized
-                  evt.sdkProcessingMetadata = Object.assign(Object.assign({}, evt.sdkProcessingMetadata), { normalizeDepth: normalize(normalizeDepth) });
+                  evt.sdkProcessingMetadata = Object.assign(Object.assign({}, evt.sdkProcessingMetadata), { normalizeDepth: `${normalize(normalizeDepth)} (${typeof normalizeDepth})` });
               }
               if (typeof normalizeDepth === 'number' && normalizeDepth > 0) {
                   return this._normalizeEvent(evt, normalizeDepth, normalizeMaxBreadth);
@@ -3932,7 +3963,7 @@ var Sentry = (function (exports) {
               // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
               normalized.contexts.trace = event.contexts.trace;
           }
-          event.sdkProcessingMetadata = Object.assign(Object.assign({}, event.sdkProcessingMetadata), { baseClientNormalized: true });
+          normalized.sdkProcessingMetadata = Object.assign(Object.assign({}, normalized.sdkProcessingMetadata), { baseClientNormalized: true });
           return normalized;
       }
       /**
@@ -4155,6 +4186,32 @@ var Sentry = (function (exports) {
       const eventType = event.type || 'event';
       const { transactionSampling } = event.sdkProcessingMetadata || {};
       const { method: samplingMethod, rate: sampleRate } = transactionSampling || {};
+      // TODO: Below is a temporary hack in order to debug a serialization error - see
+      // https://github.com/getsentry/sentry-javascript/issues/2809,
+      // https://github.com/getsentry/sentry-javascript/pull/4425, and
+      // https://github.com/getsentry/sentry-javascript/pull/4574.
+      //
+      // TL; DR: even though we normalize all events (which should prevent this), something is causing `JSON.stringify` to
+      // throw a circular reference error.
+      //
+      // When it's time to remove it:
+      // 1. Delete everything between here and where the request object `req` is created, EXCEPT the line deleting
+      //    `sdkProcessingMetadata`
+      // 2. Restore the original version of the request body, which is commented out
+      // 3. Search for either of the PR URLs above and pull out the companion hacks in the browser playwright tests and the
+      //    baseClient tests in this package
+      enhanceEventWithSdkInfo(event, api.metadata.sdk);
+      event.tags = event.tags || {};
+      event.extra = event.extra || {};
+      // In theory, all events should be marked as having gone through normalization and so
+      // we should never set this tag/extra data
+      if (!(event.sdkProcessingMetadata && event.sdkProcessingMetadata.baseClientNormalized)) {
+          event.tags.skippedNormalization = true;
+          event.extra.normalizeDepth = event.sdkProcessingMetadata ? event.sdkProcessingMetadata.normalizeDepth : 'unset';
+      }
+      // prevent this data from being sent to sentry
+      // TODO: This is NOT part of the hack - DO NOT DELETE
+      delete event.sdkProcessingMetadata;
       const envelopeHeaders = Object.assign(Object.assign({ event_id: event.event_id, sent_at: new Date().toISOString() }, (sdkInfo && { sdk: sdkInfo })), (!!api.tunnel && { dsn: dsnToString(api.dsn) }));
       const eventItem = [
           {
@@ -4366,9 +4423,14 @@ var Sentry = (function (exports) {
    */
   function initAndBind(clientClass, options) {
       if (options.debug === true) {
-          {
+          if (IS_DEBUG_BUILD$1) {
               logger.enable();
           }
+          else {
+              // use `console.warn` rather than `logger.warn` since by non-debug bundles have all `logger.x` statements stripped
+              // eslint-disable-next-line no-console
+              console.warn('[Sentry] Cannot initialize SDK with `debug` option using a non-debug bundle.');
+          }
       }
       const hub = getCurrentHub();
       const scope = hub.getScope();
@@ -4379,7 +4441,57 @@ var Sentry = (function (exports) {
       hub.bindClient(client);
   }
 
-  const SDK_VERSION = '6.19.2';
+  const DEFAULT_TRANSPORT_BUFFER_SIZE = 30;
+  /**
+   * Creates a `NewTransport`
+   *
+   * @param options
+   * @param makeRequest
+   */
+  function createTransport(options, makeRequest, buffer = makePromiseBuffer(options.bufferSize || DEFAULT_TRANSPORT_BUFFER_SIZE)) {
+      let rateLimits = {};
+      const flush = (timeout) => buffer.drain(timeout);
+      function send(envelope) {
+          const envCategory = getEnvelopeType(envelope);
+          const category = envCategory === 'event' ? 'error' : envCategory;
+          const request = {
+              category,
+              body: serializeEnvelope(envelope),
+          };
+          // Don't add to buffer if transport is already rate-limited
+          if (isRateLimited(rateLimits, category)) {
+              return rejectedSyncPromise({
+                  status: 'rate_limit',
+                  reason: getRateLimitReason(rateLimits, category),
+              });
+          }
+          const requestTask = () => makeRequest(request).then(({ body, headers, reason, statusCode }) => {
+              const status = eventStatusFromHttpCode(statusCode);
+              if (headers) {
+                  rateLimits = updateRateLimits(rateLimits, headers);
+              }
+              if (status === 'success') {
+                  return resolvedSyncPromise({ status, reason });
+              }
+              return rejectedSyncPromise({
+                  status,
+                  reason: reason ||
+                      body ||
+                      (status === 'rate_limit' ? getRateLimitReason(rateLimits, category) : 'Unknown transport error'),
+              });
+          });
+          return buffer.add(requestTask);
+      }
+      return {
+          send,
+          flush,
+      };
+  }
+  function getRateLimitReason(rateLimits, category) {
+      return `Too many ${category} requests, backing off until: ${new Date(disabledUntil(rateLimits, category)).toISOString()}`;
+  }
+
+  const SDK_VERSION = '6.19.5';
 
   let originalFunctionToString;
   /** Patch toString calls to return proper name for wrapped functions */
@@ -4473,19 +4585,23 @@ var Sentry = (function (exports) {
   /** JSDoc */
   function _shouldDropEvent$1(event, options) {
       if (options.ignoreInternal && _isSentryError(event)) {
-          logger.warn(`Event dropped due to being internal Sentry Error.\nEvent: ${getEventDescription(event)}`);
+          IS_DEBUG_BUILD$1 &&
+              logger.warn(`Event dropped due to being internal Sentry Error.\nEvent: ${getEventDescription(event)}`);
           return true;
       }
       if (_isIgnoredError(event, options.ignoreErrors)) {
-          logger.warn(`Event dropped due to being matched by \`ignoreErrors\` option.\nEvent: ${getEventDescription(event)}`);
+          IS_DEBUG_BUILD$1 &&
+              logger.warn(`Event dropped due to being matched by \`ignoreErrors\` option.\nEvent: ${getEventDescription(event)}`);
           return true;
       }
       if (_isDeniedUrl(event, options.denyUrls)) {
-          logger.warn(`Event dropped due to being matched by \`denyUrls\` option.\nEvent: ${getEventDescription(event)}.\nUrl: ${_getEventFilterUrl(event)}`);
+          IS_DEBUG_BUILD$1 &&
+              logger.warn(`Event dropped due to being matched by \`denyUrls\` option.\nEvent: ${getEventDescription(event)}.\nUrl: ${_getEventFilterUrl(event)}`);
           return true;
       }
       if (!_isAllowedUrl(event, options.allowUrls)) {
-          logger.warn(`Event dropped due to not being matched by \`allowUrls\` option.\nEvent: ${getEventDescription(event)}.\nUrl: ${_getEventFilterUrl(event)}`);
+          IS_DEBUG_BUILD$1 &&
+              logger.warn(`Event dropped due to not being matched by \`allowUrls\` option.\nEvent: ${getEventDescription(event)}.\nUrl: ${_getEventFilterUrl(event)}`);
           return true;
       }
       return false;
@@ -4522,7 +4638,7 @@ var Sentry = (function (exports) {
               return [`${value}`, `${type}: ${value}`];
           }
           catch (oO) {
-              logger.error(`Cannot extract message for event ${getEventDescription(event)}`);
+              IS_DEBUG_BUILD$1 && logger.error(`Cannot extract message for event ${getEventDescription(event)}`);
               return [];
           }
       }
@@ -4564,7 +4680,7 @@ var Sentry = (function (exports) {
           return frames ? _getLastValidUrl(frames) : null;
       }
       catch (oO) {
-          logger.error(`Cannot extract url for event ${getEventDescription(event)}`);
+          IS_DEBUG_BUILD$1 && logger.error(`Cannot extract url for event ${getEventDescription(event)}`);
           return null;
       }
   }
@@ -4904,6 +5020,22 @@ var Sentry = (function (exports) {
       return event;
   }
 
+  /*
+   * This file defines flags and constants that can be modified during compile time in order to facilitate tree shaking
+   * for users.
+   *
+   * Debug flags need to be declared in each package individually and must not be imported across package boundaries,
+   * because some build tools have trouble tree-shaking imported guards.
+   *
+   * As a convention, we define debug flags in a `flags.ts` file in the root of a package's `src` folder.
+   *
+   * Debug flag files will contain "magic strings" like `true` that may get replaced with actual values during
+   * our, or the user's build process. Take care when introducing new flags - they must not throw if they are not
+   * replaced.
+   */
+  /** Flag that is true for debug builds, false otherwise. */
+  const IS_DEBUG_BUILD = true;
+
   const global$4 = getGlobalObject();
   let cachedFetchImpl;
   /**
@@ -5056,7 +5188,7 @@ var Sentry = (function (exports) {
           // 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 = `${requestTypeToCategory(category)}:${reason}`;
-          logger.log(`Adding outcome: ${key}`);
+          IS_DEBUG_BUILD && logger.log(`Adding outcome: ${key}`);
           this._outcomes[key] = (_a = this._outcomes[key], (_a !== null && _a !== void 0 ? _a : 0)) + 1;
       }
       /**
@@ -5070,10 +5202,10 @@ var Sentry = (function (exports) {
           this._outcomes = {};
           // Nothing to send
           if (!Object.keys(outcomes).length) {
-              logger.log('No outcomes to flush');
+              IS_DEBUG_BUILD && logger.log('No outcomes to flush');
               return;
           }
-          logger.log(`Flushing outcomes:\n${JSON.stringify(outcomes, null, 2)}`);
+          IS_DEBUG_BUILD && logger.log(`Flushing outcomes:\n${JSON.stringify(outcomes, null, 2)}`);
           const url = getEnvelopeEndpointWithUrlEncodedAuth(this._api.dsn, this._api.tunnel);
           const discardedEvents = Object.keys(outcomes).map(key => {
               const [category, reason] = key.split(':');
@@ -5089,7 +5221,7 @@ var Sentry = (function (exports) {
               sendReport(url, serializeEnvelope(envelope));
           }
           catch (e) {
-              logger.error(e);
+              IS_DEBUG_BUILD && logger.error(e);
           }
       }
       /**
@@ -5099,8 +5231,9 @@ var Sentry = (function (exports) {
           const status = eventStatusFromHttpCode(response.status);
           this._rateLimits = updateRateLimits(this._rateLimits, headers);
           // eslint-disable-next-line deprecation/deprecation
-          if (this._isRateLimited(requestType) && isDebugBuild()) {
-              // eslint-disable-next-line deprecation/deprecation
+          if (this._isRateLimited(requestType)) {
+              IS_DEBUG_BUILD &&
+                  // eslint-disable-next-line deprecation/deprecation
                   logger.warn(`Too many ${requestType} requests, backing off until: ${this._disabledUntil(requestType)}`);
           }
           if (status === 'success') {
@@ -5248,11 +5381,76 @@ var Sentry = (function (exports) {
       }
   }
 
+  /**
+   * Creates a Transport that uses the Fetch API to send events to Sentry.
+   */
+  function makeNewFetchTransport(options, nativeFetch = getNativeFetchImplementation()) {
+      function makeRequest(request) {
+          const requestOptions = Object.assign({ body: request.body, method: 'POST', referrerPolicy: 'origin' }, options.requestOptions);
+          return nativeFetch(options.url, requestOptions).then(response => {
+              return response.text().then(body => ({
+                  body,
+                  headers: {
+                      'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),
+                      'retry-after': response.headers.get('Retry-After'),
+                  },
+                  reason: response.statusText,
+                  statusCode: response.status,
+              }));
+          });
+      }
+      return createTransport({ bufferSize: options.bufferSize }, makeRequest);
+  }
+
+  /**
+   * The DONE ready state for XmlHttpRequest
+   *
+   * Defining it here as a constant b/c XMLHttpRequest.DONE is not always defined
+   * (e.g. during testing, it is `undefined`)
+   *
+   * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/readyState}
+   */
+  const XHR_READYSTATE_DONE = 4;
+  /**
+   * Creates a Transport that uses the XMLHttpRequest API to send events to Sentry.
+   */
+  function makeNewXHRTransport(options) {
+      function makeRequest(request) {
+          return new SyncPromise((resolve, _reject) => {
+              const xhr = new XMLHttpRequest();
+              xhr.onreadystatechange = () => {
+                  if (xhr.readyState === XHR_READYSTATE_DONE) {
+                      const response = {
+                          body: xhr.response,
+                          headers: {
+                              'x-sentry-rate-limits': xhr.getResponseHeader('X-Sentry-Rate-Limits'),
+                              'retry-after': xhr.getResponseHeader('Retry-After'),
+                          },
+                          reason: xhr.statusText,
+                          statusCode: xhr.status,
+                      };
+                      resolve(response);
+                  }
+              };
+              xhr.open('POST', options.url);
+              for (const header in options.headers) {
+                  if (Object.prototype.hasOwnProperty.call(options.headers, header)) {
+                      xhr.setRequestHeader(header, options.headers[header]);
+                  }
+              }
+              xhr.send(request.body);
+          });
+      }
+      return createTransport({ bufferSize: options.bufferSize }, makeRequest);
+  }
+
   var index = /*#__PURE__*/Object.freeze({
     __proto__: null,
     BaseTransport: BaseTransport,
     FetchTransport: FetchTransport,
-    XHRTransport: XHRTransport
+    XHRTransport: XHRTransport,
+    makeNewFetchTransport: makeNewFetchTransport,
+    makeNewXHRTransport: makeNewXHRTransport
   });
 
   /**
@@ -5281,12 +5479,20 @@ var Sentry = (function (exports) {
               return super._setupTransport();
           }
           const transportOptions = Object.assign(Object.assign({}, this._options.transportOptions), { dsn: this._options.dsn, tunnel: this._options.tunnel, sendClientReports: this._options.sendClientReports, _metadata: this._options._metadata });
+          const api = initAPIDetails(transportOptions.dsn, transportOptions._metadata, transportOptions.tunnel);
+          const url = getEnvelopeEndpointWithUrlEncodedAuth(api.dsn, api.tunnel);
           if (this._options.transport) {
               return new this._options.transport(transportOptions);
           }
           if (supportsFetch()) {
+              const requestOptions = Object.assign({}, transportOptions.fetchParameters);
+              this._newTransport = makeNewFetchTransport({ requestOptions, url });
               return new FetchTransport(transportOptions);
           }
+          this._newTransport = makeNewXHRTransport({
+              url,
+              headers: transportOptions.headers,
+          });
           return new XHRTransport(transportOptions);
       }
   }
@@ -5416,11 +5622,11 @@ var Sentry = (function (exports) {
           return;
       }
       if (!options.eventId) {
-          logger.error('Missing eventId option in showReportDialog call');
+          IS_DEBUG_BUILD && logger.error('Missing eventId option in showReportDialog call');
           return;
       }
       if (!options.dsn) {
-          logger.error('Missing dsn option in showReportDialog call');
+          IS_DEBUG_BUILD && logger.error('Missing dsn option in showReportDialog call');
           return;
       }
       const script = global$2.document.createElement('script');
@@ -5612,7 +5818,7 @@ var Sentry = (function (exports) {
       return event;
   }
   function globalHandlerLog(type) {
-      logger.log(`Global Handler attached: ${type}`);
+      IS_DEBUG_BUILD && logger.log(`Global Handler attached: ${type}`);
   }
   function addMechanismAndCapture(hub, error, event, type) {
       addExceptionMechanism(event, {
@@ -6178,7 +6384,7 @@ var Sentry = (function (exports) {
                   // Juuust in case something goes wrong
                   try {
                       if (_shouldDropEvent(currentEvent, self._previousEvent)) {
-                          logger.warn('Event dropped due to being a duplicate of previously captured event.');
+                          IS_DEBUG_BUILD && logger.warn('Event dropped due to being a duplicate of previously captured event.');
                           return null;
                       }
                   }
@@ -6372,7 +6578,7 @@ var Sentry = (function (exports) {
               return;
           }
           if (!this._isEnabled()) {
-              logger.error('Trying to call showReportDialog with Sentry Client disabled');
+              IS_DEBUG_BUILD && logger.error('Trying to call showReportDialog with Sentry Client disabled');
               return;
           }
           injectReportDialog(Object.assign(Object.assign({}, options), { dsn: options.dsn || this.getDsn() }));
@@ -6539,7 +6745,7 @@ var Sentry = (function (exports) {
       if (client) {
           return client.flush(timeout);
       }
-      logger.warn('Cannot flush events. No client defined.');
+      IS_DEBUG_BUILD && logger.warn('Cannot flush events. No client defined.');
       return resolvedSyncPromise(false);
   }
   /**
@@ -6555,7 +6761,7 @@ var Sentry = (function (exports) {
       if (client) {
           return client.close(timeout);
       }
-      logger.warn('Cannot flush events and disable SDK. No client defined.');
+      IS_DEBUG_BUILD && logger.warn('Cannot flush events and disable SDK. No client defined.');
       return resolvedSyncPromise(false);
   }
   /**
@@ -6580,7 +6786,7 @@ 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.');
+          IS_DEBUG_BUILD && logger.warn('Session tracking in non-browser environment with @sentry/browser is not supported.');
           return;
       }
       const hub = getCurrentHub();