@sentry/browser 6.19.2 → 6.19.5

package/{bundles → build}/bundle.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) {
 
     /*! *****************************************************************************
@@ -113,22 +113,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.
@@ -145,6 +129,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) {
+        var global = (obj || getGlobalObject());
+        var __SENTRY__ = (global.__SENTRY__ = global.__SENTRY__ || {});
+        var singleton = __SENTRY__[name] || (__SENTRY__[name] = creator());
+        return singleton;
     }
 
     /* eslint-disable @typescript-eslint/no-explicit-any */
@@ -279,6 +280,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}.
@@ -437,6 +448,22 @@ var Sentry = (function (exports) {
         return SentryError;
     }(Error));
 
+    /*
+     * 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. */
+    var IS_DEBUG_BUILD$3 = true;
+
     /** Regular expression used to parse a Dsn. */
     var DSN_REGEX = /^(?:(\w+):)\/\/(?:(\w+)(?::(\w+))?@)([\w.-]+)(?::(\d+))?\/(.+)/;
     function isValidProtocol(protocol) {
@@ -528,8 +555,7 @@ var Sentry = (function (exports) {
     var PREFIX = 'Sentry Logger ';
     var 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
@@ -539,89 +565,68 @@ var Sentry = (function (exports) {
         if (!('console' in global)) {
             return callback();
         }
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         var originalConsole = global.console;
         var wrappedLevels = {};
         // Restore all wrapped console methods
         CONSOLE_LEVELS.forEach(function (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
+            var 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
-        var result = callback();
-        // Revert restoration to wrapped state
-        Object.keys(wrappedLevels).forEach(function (level) {
-            originalConsole[level] = wrappedLevels[level];
-        });
-        return result;
-    }
-    /** JSDoc */
-    var Logger = /** @class */ (function () {
-        /** JSDoc */
-        function Logger() {
-            this._enabled = false;
+        try {
+            return callback();
         }
-        /** JSDoc */
-        Logger.prototype.disable = function () {
-            this._enabled = false;
-        };
-        /** JSDoc */
-        Logger.prototype.enable = function () {
-            this._enabled = true;
-        };
-        /** JSDoc */
-        Logger.prototype.log = function () {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            if (!this._enabled) {
-                return;
-            }
-            consoleSandbox(function () {
-                var _a;
-                (_a = global$6.console).log.apply(_a, __spread([PREFIX + "[Log]:"], args));
+        finally {
+            // Revert restoration to wrapped state
+            Object.keys(wrappedLevels).forEach(function (level) {
+                originalConsole[level] = wrappedLevels[level];
             });
+        }
+    }
+    function makeLogger() {
+        var enabled = false;
+        var logger = {
+            enable: function () {
+                enabled = true;
+            },
+            disable: function () {
+                enabled = false;
+            },
         };
-        /** JSDoc */
-        Logger.prototype.warn = function () {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            if (!this._enabled) {
-                return;
-            }
-            consoleSandbox(function () {
-                var _a;
-                (_a = global$6.console).warn.apply(_a, __spread([PREFIX + "[Warn]:"], args));
+        if (IS_DEBUG_BUILD$3) {
+            CONSOLE_LEVELS.forEach(function (name) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                logger[name] = function () {
+                    var args = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        args[_i] = arguments[_i];
+                    }
+                    if (enabled) {
+                        consoleSandbox(function () {
+                            var _a;
+                            (_a = global$6.console)[name].apply(_a, __spread([PREFIX + "[" + name + "]:"], args));
+                        });
+                    }
+                };
             });
-        };
-        /** JSDoc */
-        Logger.prototype.error = function () {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            if (!this._enabled) {
-                return;
-            }
-            consoleSandbox(function () {
-                var _a;
-                (_a = global$6.console).error.apply(_a, __spread([PREFIX + "[Error]:"], args));
+        }
+        else {
+            CONSOLE_LEVELS.forEach(function (name) {
+                logger[name] = function () { return undefined; };
             });
-        };
-        return Logger;
-    }());
-    var sentryGlobal = global$6.__SENTRY__ || {};
-    var 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;
+        }
+        return logger;
+    }
+    // Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used
+    var logger;
+    if (IS_DEBUG_BUILD$3) {
+        logger = getGlobalSingleton('logger', makeLogger);
+    }
+    else {
+        logger = makeLogger();
     }
 
     /**
@@ -764,55 +769,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) {
+        var newObj = value;
         if (isError(value)) {
-            var error = value;
-            var err = {
-                message: error.message,
-                name: error.name,
-                stack: error.stack,
-            };
-            for (var i in error) {
-                if (Object.prototype.hasOwnProperty.call(error, i)) {
-                    err[i] = error[i];
-                }
-            }
-            return err;
+            newObj = __assign({ message: value.message, name: value.name, stack: value.stack }, getOwnProperties(value));
         }
-        if (isEvent(value)) {
+        else if (isEvent(value)) {
             var event_1 = value;
-            var 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_1.type;
-            try {
-                source.target = isElement(event_1.target)
-                    ? htmlTreeAsString(event_1.target)
-                    : Object.prototype.toString.call(event_1.target);
-            }
-            catch (_oO) {
-                source.target = '<unknown>';
-            }
-            try {
-                source.currentTarget = isElement(event_1.currentTarget)
-                    ? htmlTreeAsString(event_1.currentTarget)
-                    : Object.prototype.toString.call(event_1.currentTarget);
-            }
-            catch (_oO) {
-                source.currentTarget = '<unknown>';
-            }
+            newObj = __assign({ type: event_1.type, target: serializeEventTarget(event_1.target), currentTarget: serializeEventTarget(event_1.currentTarget) }, getOwnProperties(event_1));
             if (typeof CustomEvent !== 'undefined' && isInstanceOf(value, CustomEvent)) {
-                source.detail = event_1.detail;
+                newObj.detail = event_1.detail;
             }
-            for (var attr in event_1) {
-                if (Object.prototype.hasOwnProperty.call(event_1, attr)) {
-                    source[attr] = event_1[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) {
+        var extractedProps = {};
+        for (var 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
@@ -822,7 +810,7 @@ var Sentry = (function (exports) {
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
     function extractExceptionKeysForMessage(exception, maxLength) {
         if (maxLength === void 0) { maxLength = 40; }
-        var keys = Object.keys(getWalkSource(exception));
+        var keys = Object.keys(convertToPlainObject(exception));
         keys.sort();
         if (!keys.length) {
             return '[object has no keys]';
@@ -849,13 +837,12 @@ var Sentry = (function (exports) {
     function dropUndefinedKeys(val) {
         var e_1, _a;
         if (isPlainObject(val)) {
-            var obj = val;
             var rv = {};
             try {
-                for (var _b = __values(Object.keys(obj)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                for (var _b = __values(Object.keys(val)), _c = _b.next(); !_c.done; _c = _b.next()) {
                     var key = _c.value;
-                    if (typeof obj[key] !== 'undefined') {
-                        rv[key] = dropUndefinedKeys(obj[key]);
+                    if (typeof val[key] !== 'undefined') {
+                        rv[key] = dropUndefinedKeys(val[key]);
                     }
                 }
             }
@@ -1813,10 +1800,10 @@ var Sentry = (function (exports) {
         if (maxProperties === void 0) { 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 */
@@ -1827,145 +1814,145 @@ var Sentry = (function (exports) {
     maxSize) {
         if (depth === void 0) { depth = 3; }
         if (maxSize === void 0) { maxSize = 100 * 1024; }
-        var serialized = normalize(object, depth);
-        if (jsonSize(serialized) > maxSize) {
+        var 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, maxProperties, memo) {
+    function visit(key, value, depth, maxProperties, memo) {
         if (depth === void 0) { depth = +Infinity; }
         if (maxProperties === void 0) { maxProperties = +Infinity; }
         if (memo === void 0) { memo = memoBuilder(); }
         var _a = __read(memo, 2), memoize = _a[0], unmemoize = _a[1];
-        // 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
+        var 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;
+        }
+        var 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.
-        var 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.
-        var source = getWalkSource(value);
-        // Create an accumulator that will act as a parent for all future itterations of that branch
-        var 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 ~]';
         }
-        var propertyCount = 0;
-        // Walk all keys of the source
-        for (var 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.
+        var normalized = (Array.isArray(value) ? [] : {});
+        var 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.
+        var visitable = (isError(value) || isEvent(value) ? convertToPlainObject(value) : value);
+        for (var 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
-            var innerValue = source[innerKey];
-            acc[innerKey] = walk(innerKey, innerValue, depth - 1, maxProperties, memo);
+            // Recursively visit all the child nodes
+            var 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;
-        }
-        var 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.
-        var 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) {
@@ -2384,6 +2371,13 @@ var Sentry = (function (exports) {
         if (items === void 0) { items = []; }
         return [headers, items];
     }
+    /**
+     * Get the type of the envelope. Grabs the type from the first envelope item.
+     */
+    function getEnvelopeType(envelope) {
+        var _a = __read(envelope, 2), _b = __read(_a[1], 1), _c = __read(_b[0], 1), firstItemHeader = _c[0];
+        return firstItemHeader.type;
+    }
     /**
      * Serializes an envelope into a string.
      */
@@ -2944,12 +2938,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  */
-        var 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', function () { return []; });
     }
     /**
      * Add a EventProcessor to be kept globally.
@@ -3071,6 +3060,22 @@ var Sentry = (function (exports) {
         return Session;
     }());
 
+    /*
+     * 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. */
+    var IS_DEBUG_BUILD$2 = true;
+
     /**
      * API compatibility version of this hub.
      *
@@ -3345,7 +3350,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;
             }
         };
@@ -3466,7 +3471,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.");
         };
         return Hub;
     }());
@@ -3527,11 +3532,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', function () { return new Hub(); }, carrier);
     }
     /**
      * This will set passed {@link Hub} on the passed object's __SENTRY__.hub attribute
@@ -3542,8 +3543,8 @@ var Sentry = (function (exports) {
     function setHubOnCarrier(carrier, hub) {
         if (!carrier)
             return false;
-        carrier.__SENTRY__ = carrier.__SENTRY__ || {};
-        carrier.__SENTRY__.hub = hub;
+        var __SENTRY__ = (carrier.__SENTRY__ = carrier.__SENTRY__ || {});
+        __SENTRY__.hub = hub;
         return true;
     }
 
@@ -3789,6 +3790,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. */
+    var IS_DEBUG_BUILD$1 = true;
+
     var installedIntegrations = [];
     /**
      * @private
@@ -4146,7 +4163,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 = __assign(__assign({}, evt.sdkProcessingMetadata), { normalizeDepth: normalize(normalizeDepth) });
+                    evt.sdkProcessingMetadata = __assign(__assign({}, evt.sdkProcessingMetadata), { normalizeDepth: normalize(normalizeDepth) + " (" + typeof normalizeDepth + ")" });
                 }
                 if (typeof normalizeDepth === 'number' && normalizeDepth > 0) {
                     return _this._normalizeEvent(evt, normalizeDepth, normalizeMaxBreadth);
@@ -4190,7 +4207,7 @@ var Sentry = (function (exports) {
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
                 normalized.contexts.trace = event.contexts.trace;
             }
-            event.sdkProcessingMetadata = __assign(__assign({}, event.sdkProcessingMetadata), { baseClientNormalized: true });
+            normalized.sdkProcessingMetadata = __assign(__assign({}, normalized.sdkProcessingMetadata), { baseClientNormalized: true });
             return normalized;
         };
         /**
@@ -4416,6 +4433,32 @@ var Sentry = (function (exports) {
         var eventType = event.type || 'event';
         var transactionSampling = (event.sdkProcessingMetadata || {}).transactionSampling;
         var _a = transactionSampling || {}, samplingMethod = _a.method, sampleRate = _a.rate;
+        // 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;
         var envelopeHeaders = __assign(__assign({ event_id: event.event_id, sent_at: new Date().toISOString() }, (sdkInfo && { sdk: sdkInfo })), (!!api.tunnel && { dsn: dsnToString(api.dsn) }));
         var eventItem = [
             {
@@ -4631,9 +4674,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.');
+            }
         }
         var hub = getCurrentHub();
         var scope = hub.getScope();
@@ -4644,7 +4692,61 @@ var Sentry = (function (exports) {
         hub.bindClient(client);
     }
 
-    var SDK_VERSION = '6.19.2';
+    var DEFAULT_TRANSPORT_BUFFER_SIZE = 30;
+    /**
+     * Creates a `NewTransport`
+     *
+     * @param options
+     * @param makeRequest
+     */
+    function createTransport(options, makeRequest, buffer) {
+        if (buffer === void 0) { buffer = makePromiseBuffer(options.bufferSize || DEFAULT_TRANSPORT_BUFFER_SIZE); }
+        var rateLimits = {};
+        var flush = function (timeout) { return buffer.drain(timeout); };
+        function send(envelope) {
+            var envCategory = getEnvelopeType(envelope);
+            var category = envCategory === 'event' ? 'error' : envCategory;
+            var request = {
+                category: 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),
+                });
+            }
+            var requestTask = function () {
+                return makeRequest(request).then(function (_a) {
+                    var body = _a.body, headers = _a.headers, reason = _a.reason, statusCode = _a.statusCode;
+                    var status = eventStatusFromHttpCode(statusCode);
+                    if (headers) {
+                        rateLimits = updateRateLimits(rateLimits, headers);
+                    }
+                    if (status === 'success') {
+                        return resolvedSyncPromise({ status: status, reason: reason });
+                    }
+                    return rejectedSyncPromise({
+                        status: status,
+                        reason: reason ||
+                            body ||
+                            (status === 'rate_limit' ? getRateLimitReason(rateLimits, category) : 'Unknown transport error'),
+                    });
+                });
+            };
+            return buffer.add(requestTask);
+        }
+        return {
+            send: send,
+            flush: flush,
+        };
+    }
+    function getRateLimitReason(rateLimits, category) {
+        return "Too many " + category + " requests, backing off until: " + new Date(disabledUntil(rateLimits, category)).toISOString();
+    }
+
+    var SDK_VERSION = '6.19.5';
 
     var originalFunctionToString;
     /** Patch toString calls to return proper name for wrapped functions */
@@ -4729,19 +4831,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;
@@ -4780,7 +4886,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 [];
             }
         }
@@ -4823,7 +4929,7 @@ var Sentry = (function (exports) {
             return frames_1 ? _getLastValidUrl(frames_1) : 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;
         }
     }
@@ -5165,6 +5271,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. */
+    var IS_DEBUG_BUILD = true;
+
     var global$4 = getGlobalObject();
     var cachedFetchImpl;
     /**
@@ -5318,7 +5440,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>>>>`
             var 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;
         };
         /**
@@ -5332,10 +5454,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));
             var url = getEnvelopeEndpointWithUrlEncodedAuth(this._api.dsn, this._api.tunnel);
             var discardedEvents = Object.keys(outcomes).map(function (key) {
                 var _a = __read(key.split(':'), 2), category = _a[0], reason = _a[1];
@@ -5351,7 +5473,7 @@ var Sentry = (function (exports) {
                 sendReport(url, serializeEnvelope(envelope));
             }
             catch (e) {
-                logger.error(e);
+                IS_DEBUG_BUILD && logger.error(e);
             }
         };
         /**
@@ -5362,8 +5484,9 @@ var Sentry = (function (exports) {
             var 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') {
@@ -5527,11 +5650,77 @@ var Sentry = (function (exports) {
         return XHRTransport;
     }(BaseTransport));
 
+    /**
+     * Creates a Transport that uses the Fetch API to send events to Sentry.
+     */
+    function makeNewFetchTransport(options, nativeFetch) {
+        if (nativeFetch === void 0) { nativeFetch = getNativeFetchImplementation(); }
+        function makeRequest(request) {
+            var requestOptions = __assign({ body: request.body, method: 'POST', referrerPolicy: 'origin' }, options.requestOptions);
+            return nativeFetch(options.url, requestOptions).then(function (response) {
+                return response.text().then(function (body) { return ({
+                    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}
+     */
+    var 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(function (resolve, _reject) {
+                var xhr = new XMLHttpRequest();
+                xhr.onreadystatechange = function () {
+                    if (xhr.readyState === XHR_READYSTATE_DONE) {
+                        var 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 (var 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
     });
 
     /**
@@ -5565,12 +5754,20 @@ var Sentry = (function (exports) {
                 return _super.prototype._setupTransport.call(this);
             }
             var transportOptions = __assign(__assign({}, this._options.transportOptions), { dsn: this._options.dsn, tunnel: this._options.tunnel, sendClientReports: this._options.sendClientReports, _metadata: this._options._metadata });
+            var api = initAPIDetails(transportOptions.dsn, transportOptions._metadata, transportOptions.tunnel);
+            var url = getEnvelopeEndpointWithUrlEncodedAuth(api.dsn, api.tunnel);
             if (this._options.transport) {
                 return new this._options.transport(transportOptions);
             }
             if (supportsFetch()) {
+                var requestOptions = __assign({}, transportOptions.fetchParameters);
+                this._newTransport = makeNewFetchTransport({ requestOptions: requestOptions, url: url });
                 return new FetchTransport(transportOptions);
             }
+            this._newTransport = makeNewXHRTransport({
+                url: url,
+                headers: transportOptions.headers,
+            });
             return new XHRTransport(transportOptions);
         };
         return BrowserBackend;
@@ -5703,11 +5900,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;
         }
         var script = global$2.document.createElement('script');
@@ -5899,7 +6096,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, {
@@ -6478,7 +6675,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;
                         }
                     }
@@ -6678,7 +6875,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(__assign(__assign({}, options), { dsn: options.dsn || this.getDsn() }));
@@ -6848,7 +7045,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);
     }
     /**
@@ -6864,7 +7061,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);
     }
     /**
@@ -6889,7 +7086,7 @@ var Sentry = (function (exports) {
         var window = getGlobalObject();
         var 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;
         }
         var hub = getCurrentHub();