@sentry/browser 6.19.1 → 6.19.4

package/bundles/bundle.js

@@ -1,4 +1,4 @@
-/*! @sentry/browser 6.19.1 (9268185) | https://github.com/getsentry/sentry-javascript */
+/*! @sentry/browser 6.19.4 (261f2e4) | 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.
@@ -279,6 +263,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}.
@@ -624,140 +618,6 @@ var Sentry = (function (exports) {
         global$6.__SENTRY__ = sentryGlobal;
     }
 
-    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-    /* eslint-disable @typescript-eslint/no-explicit-any */
-    /**
-     * Helper to decycle json objects
-     */
-    function memoBuilder() {
-        var hasWeakSet = typeof WeakSet === 'function';
-        var inner = hasWeakSet ? new WeakSet() : [];
-        function memoize(obj) {
-            if (hasWeakSet) {
-                if (inner.has(obj)) {
-                    return true;
-                }
-                inner.add(obj);
-                return false;
-            }
-            // eslint-disable-next-line @typescript-eslint/prefer-for-of
-            for (var i = 0; i < inner.length; i++) {
-                var value = inner[i];
-                if (value === obj) {
-                    return true;
-                }
-            }
-            inner.push(obj);
-            return false;
-        }
-        function unmemoize(obj) {
-            if (hasWeakSet) {
-                inner.delete(obj);
-            }
-            else {
-                for (var i = 0; i < inner.length; i++) {
-                    if (inner[i] === obj) {
-                        inner.splice(i, 1);
-                        break;
-                    }
-                }
-            }
-        }
-        return [memoize, unmemoize];
-    }
-
-    var STACKTRACE_LIMIT = 50;
-    /**
-     * Creates a stack parser with the supplied line parsers
-     *
-     * StackFrames are returned in the correct order for Sentry Exception
-     * frames and with Sentry SDK internal frames removed from the top and bottom
-     *
-     */
-    function createStackParser() {
-        var parsers = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            parsers[_i] = arguments[_i];
-        }
-        var sortedParsers = parsers.sort(function (a, b) { return a[0] - b[0]; }).map(function (p) { return p[1]; });
-        return function (stack, skipFirst) {
-            var e_1, _a, e_2, _b;
-            if (skipFirst === void 0) { skipFirst = 0; }
-            var frames = [];
-            try {
-                for (var _c = __values(stack.split('\n').slice(skipFirst)), _d = _c.next(); !_d.done; _d = _c.next()) {
-                    var line = _d.value;
-                    try {
-                        for (var sortedParsers_1 = (e_2 = void 0, __values(sortedParsers)), sortedParsers_1_1 = sortedParsers_1.next(); !sortedParsers_1_1.done; sortedParsers_1_1 = sortedParsers_1.next()) {
-                            var parser = sortedParsers_1_1.value;
-                            var frame = parser(line);
-                            if (frame) {
-                                frames.push(frame);
-                                break;
-                            }
-                        }
-                    }
-                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                    finally {
-                        try {
-                            if (sortedParsers_1_1 && !sortedParsers_1_1.done && (_b = sortedParsers_1.return)) _b.call(sortedParsers_1);
-                        }
-                        finally { if (e_2) throw e_2.error; }
-                    }
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-            return stripSentryFramesAndReverse(frames);
-        };
-    }
-    /**
-     * @hidden
-     */
-    function stripSentryFramesAndReverse(stack) {
-        if (!stack.length) {
-            return [];
-        }
-        var localStack = stack;
-        var firstFrameFunction = localStack[0].function || '';
-        var lastFrameFunction = localStack[localStack.length - 1].function || '';
-        // If stack starts with one of our API calls, remove it (starts, meaning it's the top of the stack - aka last call)
-        if (firstFrameFunction.indexOf('captureMessage') !== -1 || firstFrameFunction.indexOf('captureException') !== -1) {
-            localStack = localStack.slice(1);
-        }
-        // If stack ends with one of our internal API calls, remove it (ends, meaning it's the bottom of the stack - aka top-most call)
-        if (lastFrameFunction.indexOf('sentryWrapped') !== -1) {
-            localStack = localStack.slice(0, -1);
-        }
-        // The frame where the crash happened, should be the last entry in the array
-        return localStack
-            .slice(0, STACKTRACE_LIMIT)
-            .map(function (frame) { return (__assign(__assign({}, frame), { filename: frame.filename || localStack[0].filename, function: frame.function || '?' })); })
-            .reverse();
-    }
-    var defaultFunctionName = '<anonymous>';
-    /**
-     * Safely extract function name from itself
-     */
-    function getFunctionName(fn) {
-        try {
-            if (!fn || typeof fn !== 'function') {
-                return defaultFunctionName;
-            }
-            return fn.name || defaultFunctionName;
-        }
-        catch (e) {
-            // Just accessing custom props in some Selenium environments
-            // can cause a "Permission denied" exception (see raven-js#495).
-            return defaultFunctionName;
-        }
-    }
-
     /**
      * Truncates given string to the maximum characters count
      *
@@ -898,242 +758,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 source;
         }
-        return value;
+        return newObj;
     }
-    /** Calculates bytes size of input string */
-    function utf8Length(value) {
-        // eslint-disable-next-line no-bitwise
-        return ~-encodeURI(value).split(/%..|./).length;
-    }
-    /** Calculates bytes size of input object */
-    function jsonSize(value) {
-        return utf8Length(JSON.stringify(value));
-    }
-    /** JSDoc */
-    function normalizeToSize(object, 
-    // Default Node.js REPL depth
-    depth, 
-    // 100kB, as 200kB is max payload size, so half sounds reasonable
-    maxSize) {
-        if (depth === void 0) { depth = 3; }
-        if (maxSize === void 0) { maxSize = 100 * 1024; }
-        var serialized = normalize(object, depth);
-        if (jsonSize(serialized) > maxSize) {
-            return normalizeToSize(object, depth - 1, maxSize);
-        }
-        return serialized;
-    }
-    /**
-     * 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;
-    }
-    /**
-     * makeSerializable()
-     *
-     * Takes unserializable input and make it serializer-friendly.
-     *
-     * Handles globals, functions, `undefined`, `NaN`, and other non-serializable values.
-     */
-    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) + "]";
+    /** 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);
         }
-        if (typeof value === 'bigint') {
-            return "[BigInt: " + String(value) + "]";
+        catch (_oO) {
+            return '<unknown>';
         }
-        return value;
     }
-    /**
-     * Walks an object to perform a 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 memo Optional Memo class handling decycling
-     */
-    function walk(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 (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
-        if (memoize(value)) {
-            return '[Circular ~]';
-        }
-        var propertyCount = 0;
-        // Walk all keys of the source
-        for (var innerKey in source) {
-            // Avoid iterating over fields in the prototype if they've somehow been exposed to enumeration.
-            if (!Object.prototype.hasOwnProperty.call(source, innerKey)) {
-                continue;
+    /** 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];
             }
-            if (propertyCount >= maxProperties) {
-                acc[innerKey] = '[MaxProperties ~]';
-                break;
-            }
-            propertyCount += 1;
-            // Recursively walk through all the child nodes
-            var innerValue = source[innerKey];
-            acc[innerKey] = walk(innerKey, innerValue, depth - 1, maxProperties, memo);
-        }
-        // Once walked through all the branches, remove the parent from memo storage
-        unmemoize(value);
-        // Return accumulated values
-        return acc;
-    }
-    /**
-     * Recursively normalizes the given object.
-     *
-     * - Creates a copy to prevent original input mutation
-     * - Skips non-enumerable properties
-     * - When stringifying, calls `toJSON` if implemented
-     * - Removes circular references
-     * - Translates non-serializable values (`undefined`/`NaN`/functions) to serializable format
-     * - Translates known global objects/classes to a string representations
-     * - Takes care of `Error` object serialization
-     * - Optionally limits depth of final output
-     * - Optionally limits number of properties/elements included in any single object/array
-     *
-     * @param input The object to be normalized.
-     * @param depth The max depth to which to normalize the object. (Anything deeper stringified whole.)
-     * @param maxProperties The max number of elements or properties to be included in any single array or
-     * object in the normallized output..
-     * @returns A normalized version of the object, or `"**non-serializable**"` if any errors are thrown during normalization.
-     */
-    function normalize(input, depth, maxProperties) {
-        if (depth === void 0) { depth = +Infinity; }
-        if (maxProperties === void 0) { maxProperties = +Infinity; }
-        try {
-            // since we're at the outermost level, there is no key
-            return walk('', input, depth, maxProperties);
-        }
-        catch (_oO) {
-            return '**non-serializable**';
         }
+        return extractedProps;
     }
     /**
      * Given any captured exception, extract its keys and create a sorted
@@ -1143,7 +799,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]';
@@ -1170,13 +826,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]);
                     }
                 }
             }
@@ -1187,12 +842,104 @@ var Sentry = (function (exports) {
                 }
                 finally { if (e_1) throw e_1.error; }
             }
-            return rv;
+            return rv;
+        }
+        if (Array.isArray(val)) {
+            return val.map(dropUndefinedKeys);
+        }
+        return val;
+    }
+
+    var STACKTRACE_LIMIT = 50;
+    /**
+     * Creates a stack parser with the supplied line parsers
+     *
+     * StackFrames are returned in the correct order for Sentry Exception
+     * frames and with Sentry SDK internal frames removed from the top and bottom
+     *
+     */
+    function createStackParser() {
+        var parsers = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            parsers[_i] = arguments[_i];
+        }
+        var sortedParsers = parsers.sort(function (a, b) { return a[0] - b[0]; }).map(function (p) { return p[1]; });
+        return function (stack, skipFirst) {
+            var e_1, _a, e_2, _b;
+            if (skipFirst === void 0) { skipFirst = 0; }
+            var frames = [];
+            try {
+                for (var _c = __values(stack.split('\n').slice(skipFirst)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var line = _d.value;
+                    try {
+                        for (var sortedParsers_1 = (e_2 = void 0, __values(sortedParsers)), sortedParsers_1_1 = sortedParsers_1.next(); !sortedParsers_1_1.done; sortedParsers_1_1 = sortedParsers_1.next()) {
+                            var parser = sortedParsers_1_1.value;
+                            var frame = parser(line);
+                            if (frame) {
+                                frames.push(frame);
+                                break;
+                            }
+                        }
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (sortedParsers_1_1 && !sortedParsers_1_1.done && (_b = sortedParsers_1.return)) _b.call(sortedParsers_1);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return stripSentryFramesAndReverse(frames);
+        };
+    }
+    /**
+     * @hidden
+     */
+    function stripSentryFramesAndReverse(stack) {
+        if (!stack.length) {
+            return [];
+        }
+        var localStack = stack;
+        var firstFrameFunction = localStack[0].function || '';
+        var lastFrameFunction = localStack[localStack.length - 1].function || '';
+        // If stack starts with one of our API calls, remove it (starts, meaning it's the top of the stack - aka last call)
+        if (firstFrameFunction.indexOf('captureMessage') !== -1 || firstFrameFunction.indexOf('captureException') !== -1) {
+            localStack = localStack.slice(1);
+        }
+        // If stack ends with one of our internal API calls, remove it (ends, meaning it's the bottom of the stack - aka top-most call)
+        if (lastFrameFunction.indexOf('sentryWrapped') !== -1) {
+            localStack = localStack.slice(0, -1);
+        }
+        // The frame where the crash happened, should be the last entry in the array
+        return localStack
+            .slice(0, STACKTRACE_LIMIT)
+            .map(function (frame) { return (__assign(__assign({}, frame), { filename: frame.filename || localStack[0].filename, function: frame.function || '?' })); })
+            .reverse();
+    }
+    var defaultFunctionName = '<anonymous>';
+    /**
+     * Safely extract function name from itself
+     */
+    function getFunctionName(fn) {
+        try {
+            if (!fn || typeof fn !== 'function') {
+                return defaultFunctionName;
+            }
+            return fn.name || defaultFunctionName;
         }
-        if (Array.isArray(val)) {
-            return val.map(dropUndefinedKeys);
+        catch (e) {
+            // Just accessing custom props in some Selenium environments
+            // can cause a "Permission denied" exception (see raven-js#495).
+            return defaultFunctionName;
         }
-        return val;
     }
 
     /**
@@ -1819,6 +1566,48 @@ var Sentry = (function (exports) {
         };
     }
 
+    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+    /**
+     * Helper to decycle json objects
+     */
+    function memoBuilder() {
+        var hasWeakSet = typeof WeakSet === 'function';
+        var inner = hasWeakSet ? new WeakSet() : [];
+        function memoize(obj) {
+            if (hasWeakSet) {
+                if (inner.has(obj)) {
+                    return true;
+                }
+                inner.add(obj);
+                return false;
+            }
+            // eslint-disable-next-line @typescript-eslint/prefer-for-of
+            for (var i = 0; i < inner.length; i++) {
+                var value = inner[i];
+                if (value === obj) {
+                    return true;
+                }
+            }
+            inner.push(obj);
+            return false;
+        }
+        function unmemoize(obj) {
+            if (hasWeakSet) {
+                inner.delete(obj);
+            }
+            else {
+                for (var i = 0; i < inner.length; i++) {
+                    if (inner[i] === obj) {
+                        inner.splice(i, 1);
+                        break;
+                    }
+                }
+            }
+        }
+        return [memoize, unmemoize];
+    }
+
     /**
      * UUID4 generator
      *
@@ -1976,6 +1765,194 @@ var Sentry = (function (exports) {
         return false;
     }
 
+    /**
+     * Recursively normalizes the given object.
+     *
+     * - Creates a copy to prevent original input mutation
+     * - Skips non-enumerable properties
+     * - When stringifying, calls `toJSON` if implemented
+     * - Removes circular references
+     * - Translates non-serializable values (`undefined`/`NaN`/functions) to serializable format
+     * - Translates known global objects/classes to a string representations
+     * - Takes care of `Error` object serialization
+     * - Optionally limits depth of final output
+     * - Optionally limits number of properties/elements included in any single object/array
+     *
+     * @param input The object to be normalized.
+     * @param depth The max depth to which to normalize the object. (Anything deeper stringified whole.)
+     * @param maxProperties The max number of elements or properties to be included in any single array or
+     * object in the normallized output..
+     * @returns A normalized version of the object, or `"**non-serializable**"` if any errors are thrown during normalization.
+     */
+    function normalize(input, depth, maxProperties) {
+        if (depth === void 0) { depth = +Infinity; }
+        if (maxProperties === void 0) { maxProperties = +Infinity; }
+        try {
+            // since we're at the outermost level, there is no key
+            return visit('', input, depth, maxProperties);
+        }
+        catch (err) {
+            return { ERROR: "**non-serializable** (" + err + ")" };
+        }
+    }
+    /** JSDoc */
+    function normalizeToSize(object, 
+    // Default Node.js REPL depth
+    depth, 
+    // 100kB, as 200kB is max payload size, so half sounds reasonable
+    maxSize) {
+        if (depth === void 0) { depth = 3; }
+        if (maxSize === void 0) { maxSize = 100 * 1024; }
+        var normalized = normalize(object, depth);
+        if (jsonSize(normalized) > maxSize) {
+            return normalizeToSize(object, depth - 1, maxSize);
+        }
+        return normalized;
+    }
+    /**
+     * Visits a node to perform normalization on it
+     *
+     * @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 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 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) {
+            // 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 ~]';
+        }
+        // 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(visitable, visitKey)) {
+                continue;
+            }
+            if (numAdded >= maxProperties) {
+                normalized[visitKey] = '[MaxProperties ~]';
+                break;
+            }
+            // Recursively visit all the child nodes
+            var visitValue = visitable[visitKey];
+            normalized[visitKey] = visit(visitKey, visitValue, depth - 1, maxProperties, memo);
+            numAdded += 1;
+        }
+        // Once we've visited all the branches, remove the parent from memo storage
+        unmemoize(value);
+        // Return accumulated values
+        return normalized;
+    }
+    /**
+     * Stringify the given value. Handles various known special values and types.
+     *
+     * 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.
+     *
+     * @param value The value to stringify
+     * @returns A stringified representation of the given 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 + "]";
+        }
+        catch (err) {
+            return "**non-serializable** (" + err + ")";
+        }
+    }
+    /** Calculates bytes size of input string */
+    function utf8Length(value) {
+        // eslint-disable-next-line no-bitwise
+        return ~-encodeURI(value).split(/%..|./).length;
+    }
+    /** Calculates bytes size of input object */
+    function jsonSize(value) {
+        return utf8Length(JSON.stringify(value));
+    }
+
     /* eslint-disable @typescript-eslint/explicit-function-return-type */
     /**
      * Creates a resolved sync promise.
@@ -2383,6 +2360,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.
      */
@@ -4189,7 +4173,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;
         };
         /**
@@ -4363,89 +4347,6 @@ var Sentry = (function (exports) {
         return rv;
     }
 
-    /** Noop transport */
-    var NoopTransport = /** @class */ (function () {
-        function NoopTransport() {
-        }
-        /**
-         * @inheritDoc
-         */
-        NoopTransport.prototype.sendEvent = function (_) {
-            return resolvedSyncPromise({
-                reason: 'NoopTransport: Event has been skipped because no Dsn is configured.',
-                status: 'skipped',
-            });
-        };
-        /**
-         * @inheritDoc
-         */
-        NoopTransport.prototype.close = function (_) {
-            return resolvedSyncPromise(true);
-        };
-        return NoopTransport;
-    }());
-
-    /**
-     * This is the base implemention of a Backend.
-     * @hidden
-     */
-    var BaseBackend = /** @class */ (function () {
-        /** Creates a new backend instance. */
-        function BaseBackend(options) {
-            this._options = options;
-            if (!this._options.dsn) {
-                logger.warn('No DSN provided, backend will not do anything.');
-            }
-            this._transport = this._setupTransport();
-        }
-        /**
-         * @inheritDoc
-         */
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
-        BaseBackend.prototype.eventFromException = function (_exception, _hint) {
-            throw new SentryError('Backend has to implement `eventFromException` method');
-        };
-        /**
-         * @inheritDoc
-         */
-        BaseBackend.prototype.eventFromMessage = function (_message, _level, _hint) {
-            throw new SentryError('Backend has to implement `eventFromMessage` method');
-        };
-        /**
-         * @inheritDoc
-         */
-        BaseBackend.prototype.sendEvent = function (event) {
-            void this._transport.sendEvent(event).then(null, function (reason) {
-                logger.error('Error while sending event:', reason);
-            });
-        };
-        /**
-         * @inheritDoc
-         */
-        BaseBackend.prototype.sendSession = function (session) {
-            if (!this._transport.sendSession) {
-                logger.warn("Dropping session because custom transport doesn't implement sendSession");
-                return;
-            }
-            void this._transport.sendSession(session).then(null, function (reason) {
-                logger.error('Error while sending session:', reason);
-            });
-        };
-        /**
-         * @inheritDoc
-         */
-        BaseBackend.prototype.getTransport = function () {
-            return this._transport;
-        };
-        /**
-         * Sets up the transport so it can be used later to send requests.
-         */
-        BaseBackend.prototype._setupTransport = function () {
-            return new NoopTransport();
-        };
-        return BaseBackend;
-    }());
-
     /** Extract sdk info from from the API metadata */
     function getSdkMetadataForEnvelopeHeader(api) {
         if (!api.metadata || !api.metadata.sdk) {
@@ -4469,8 +4370,8 @@ var Sentry = (function (exports) {
         event.sdk.packages = __spread((event.sdk.packages || []), (sdkInfo.packages || []));
         return event;
     }
-    /** Creates a SentryRequest from a Session. */
-    function sessionToSentryRequest(session, api) {
+    /** Creates an envelope from a Session */
+    function createSessionEnvelope(session, api) {
         var sdkInfo = getSdkMetadataForEnvelopeHeader(api);
         var envelopeHeaders = __assign(__assign({ sent_at: new Date().toISOString() }, (sdkInfo && { sdk: sdkInfo })), (!!api.tunnel && { dsn: dsnToString(api.dsn) }));
         // I know this is hacky but we don't want to add `sessions` to request type since it's never rate limited
@@ -4478,12 +4379,62 @@ var Sentry = (function (exports) {
         // TODO (v7) Have to cast type because envelope items do not accept a `SentryRequestType`
         var envelopeItem = [{ type: type }, session];
         var envelope = createEnvelope(envelopeHeaders, [envelopeItem]);
+        return [envelope, type];
+    }
+    /** Creates a SentryRequest from a Session. */
+    function sessionToSentryRequest(session, api) {
+        var _a = __read(createSessionEnvelope(session, api), 2), envelope = _a[0], type = _a[1];
         return {
             body: serializeEnvelope(envelope),
             type: type,
             url: getEnvelopeEndpointWithUrlEncodedAuth(api.dsn, api.tunnel),
         };
     }
+    /**
+     * Create an Envelope from an event. Note that this is duplicated from below,
+     * but on purpose as this will be refactored in v7.
+     */
+    function createEventEnvelope(event, api) {
+        var sdkInfo = getSdkMetadataForEnvelopeHeader(api);
+        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 = [
+            {
+                type: eventType,
+                sample_rates: [{ id: samplingMethod, rate: sampleRate }],
+            },
+            event,
+        ];
+        return createEnvelope(envelopeHeaders, [eventItem]);
+    }
     /** Creates a SentryRequest from an event. */
     function eventToSentryRequest(event, api) {
         var sdkInfo = getSdkMetadataForEnvelopeHeader(api);
@@ -4571,6 +4522,115 @@ var Sentry = (function (exports) {
         return req;
     }
 
+    /** Noop transport */
+    var NoopTransport = /** @class */ (function () {
+        function NoopTransport() {
+        }
+        /**
+         * @inheritDoc
+         */
+        NoopTransport.prototype.sendEvent = function (_) {
+            return resolvedSyncPromise({
+                reason: 'NoopTransport: Event has been skipped because no Dsn is configured.',
+                status: 'skipped',
+            });
+        };
+        /**
+         * @inheritDoc
+         */
+        NoopTransport.prototype.close = function (_) {
+            return resolvedSyncPromise(true);
+        };
+        return NoopTransport;
+    }());
+
+    /**
+     * This is the base implemention of a Backend.
+     * @hidden
+     */
+    var BaseBackend = /** @class */ (function () {
+        /** Creates a new backend instance. */
+        function BaseBackend(options) {
+            this._options = options;
+            if (!this._options.dsn) {
+                logger.warn('No DSN provided, backend will not do anything.');
+            }
+            this._transport = this._setupTransport();
+        }
+        /**
+         * @inheritDoc
+         */
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+        BaseBackend.prototype.eventFromException = function (_exception, _hint) {
+            throw new SentryError('Backend has to implement `eventFromException` method');
+        };
+        /**
+         * @inheritDoc
+         */
+        BaseBackend.prototype.eventFromMessage = function (_message, _level, _hint) {
+            throw new SentryError('Backend has to implement `eventFromMessage` method');
+        };
+        /**
+         * @inheritDoc
+         */
+        BaseBackend.prototype.sendEvent = function (event) {
+            // TODO(v7): Remove the if-else
+            if (this._newTransport &&
+                this._options.dsn &&
+                this._options._experiments &&
+                this._options._experiments.newTransport) {
+                var api = initAPIDetails(this._options.dsn, this._options._metadata, this._options.tunnel);
+                var env = createEventEnvelope(event, api);
+                void this._newTransport.send(env).then(null, function (reason) {
+                    logger.error('Error while sending event:', reason);
+                });
+            }
+            else {
+                void this._transport.sendEvent(event).then(null, function (reason) {
+                    logger.error('Error while sending event:', reason);
+                });
+            }
+        };
+        /**
+         * @inheritDoc
+         */
+        BaseBackend.prototype.sendSession = function (session) {
+            if (!this._transport.sendSession) {
+                logger.warn("Dropping session because custom transport doesn't implement sendSession");
+                return;
+            }
+            // TODO(v7): Remove the if-else
+            if (this._newTransport &&
+                this._options.dsn &&
+                this._options._experiments &&
+                this._options._experiments.newTransport) {
+                var api = initAPIDetails(this._options.dsn, this._options._metadata, this._options.tunnel);
+                var _a = __read(createSessionEnvelope(session, api), 1), env = _a[0];
+                void this._newTransport.send(env).then(null, function (reason) {
+                    logger.error('Error while sending session:', reason);
+                });
+            }
+            else {
+                void this._transport.sendSession(session).then(null, function (reason) {
+                    logger.error('Error while sending session:', reason);
+                });
+            }
+        };
+        /**
+         * @inheritDoc
+         */
+        BaseBackend.prototype.getTransport = function () {
+            return this._transport;
+        };
+        /**
+         * Sets up the transport so it can be used later to send requests.
+         */
+        BaseBackend.prototype._setupTransport = function () {
+            return new NoopTransport();
+        };
+        return BaseBackend;
+    }());
+
     /**
      * Internal function to create a new SDK client instance. The client is
      * installed and then bound to the current scope.
@@ -4593,7 +4653,61 @@ var Sentry = (function (exports) {
         hub.bindClient(client);
     }
 
-    var SDK_VERSION = '6.19.1';
+    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.4';
 
     var originalFunctionToString;
     /** Patch toString calls to return proper name for wrapped functions */
@@ -4643,158 +4757,139 @@ var Sentry = (function (exports) {
         /**
          * @inheritDoc
          */
-        InboundFilters.prototype.setupOnce = function () {
+        InboundFilters.prototype.setupOnce = function (addGlobalEventProcessor, getCurrentHub) {
             addGlobalEventProcessor(function (event) {
                 var hub = getCurrentHub();
-                if (!hub) {
-                    return event;
-                }
-                var self = hub.getIntegration(InboundFilters);
-                if (self) {
-                    var client = hub.getClient();
-                    var clientOptions = client ? client.getOptions() : {};
-                    // This checks prevents most of the occurrences of the bug linked below:
-                    // https://github.com/getsentry/sentry-javascript/issues/2622
-                    // The bug is caused by multiple SDK instances, where one is minified and one is using non-mangled code.
-                    // Unfortunatelly we cannot fix it reliably (thus reserved property in rollup's terser config),
-                    // as we cannot force people using multiple instances in their apps to sync SDK versions.
-                    var options = typeof self._mergeOptions === 'function' ? self._mergeOptions(clientOptions) : {};
-                    if (typeof self._shouldDropEvent !== 'function') {
-                        return event;
+                if (hub) {
+                    var self_1 = hub.getIntegration(InboundFilters);
+                    if (self_1) {
+                        var client = hub.getClient();
+                        var clientOptions = client ? client.getOptions() : {};
+                        var options = _mergeOptions(self_1._options, clientOptions);
+                        return _shouldDropEvent$1(event, options) ? null : event;
                     }
-                    return self._shouldDropEvent(event, options) ? null : event;
                 }
                 return event;
             });
         };
-        /** JSDoc */
-        InboundFilters.prototype._shouldDropEvent = function (event, options) {
-            if (this._isSentryError(event, options)) {
-                logger.warn("Event dropped due to being internal Sentry Error.\nEvent: " + getEventDescription(event));
-                return true;
-            }
-            if (this._isIgnoredError(event, options)) {
-                logger.warn("Event dropped due to being matched by `ignoreErrors` option.\nEvent: " + getEventDescription(event));
-                return true;
+        /**
+         * @inheritDoc
+         */
+        InboundFilters.id = 'InboundFilters';
+        return InboundFilters;
+    }());
+    /** JSDoc */
+    function _mergeOptions(internalOptions, clientOptions) {
+        if (internalOptions === void 0) { internalOptions = {}; }
+        if (clientOptions === void 0) { clientOptions = {}; }
+        return {
+            allowUrls: __spread((internalOptions.whitelistUrls || []), (internalOptions.allowUrls || []), (clientOptions.whitelistUrls || []), (clientOptions.allowUrls || [])),
+            denyUrls: __spread((internalOptions.blacklistUrls || []), (internalOptions.denyUrls || []), (clientOptions.blacklistUrls || []), (clientOptions.denyUrls || [])),
+            ignoreErrors: __spread((internalOptions.ignoreErrors || []), (clientOptions.ignoreErrors || []), DEFAULT_IGNORE_ERRORS),
+            ignoreInternal: internalOptions.ignoreInternal !== undefined ? internalOptions.ignoreInternal : true,
+        };
+    }
+    /** JSDoc */
+    function _shouldDropEvent$1(event, options) {
+        if (options.ignoreInternal && _isSentryError(event)) {
+            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));
+            return true;
+        }
+        if (_isDeniedUrl(event, options.denyUrls)) {
+            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));
+            return true;
+        }
+        return false;
+    }
+    function _isIgnoredError(event, ignoreErrors) {
+        if (!ignoreErrors || !ignoreErrors.length) {
+            return false;
+        }
+        return _getPossibleEventMessages(event).some(function (message) {
+            return ignoreErrors.some(function (pattern) { return isMatchingPattern(message, pattern); });
+        });
+    }
+    function _isDeniedUrl(event, denyUrls) {
+        // TODO: Use Glob instead?
+        if (!denyUrls || !denyUrls.length) {
+            return false;
+        }
+        var url = _getEventFilterUrl(event);
+        return !url ? false : denyUrls.some(function (pattern) { return isMatchingPattern(url, pattern); });
+    }
+    function _isAllowedUrl(event, allowUrls) {
+        // TODO: Use Glob instead?
+        if (!allowUrls || !allowUrls.length) {
+            return true;
+        }
+        var url = _getEventFilterUrl(event);
+        return !url ? true : allowUrls.some(function (pattern) { return isMatchingPattern(url, pattern); });
+    }
+    function _getPossibleEventMessages(event) {
+        if (event.message) {
+            return [event.message];
+        }
+        if (event.exception) {
+            try {
+                var _a = (event.exception.values && event.exception.values[0]) || {}, _b = _a.type, type = _b === void 0 ? '' : _b, _c = _a.value, value = _c === void 0 ? '' : _c;
+                return ["" + value, type + ": " + value];
             }
-            if (this._isDeniedUrl(event, options)) {
-                logger.warn("Event dropped due to being matched by `denyUrls` option.\nEvent: " + getEventDescription(event) + ".\nUrl: " + this._getEventFilterUrl(event));
-                return true;
+            catch (oO) {
+                logger.error("Cannot extract message for event " + getEventDescription(event));
+                return [];
             }
-            if (!this._isAllowedUrl(event, options)) {
-                logger.warn("Event dropped due to not being matched by `allowUrls` option.\nEvent: " + getEventDescription(event) + ".\nUrl: " + this._getEventFilterUrl(event));
-                return true;
+        }
+        return [];
+    }
+    function _isSentryError(event) {
+        try {
+            // @ts-ignore can't be a sentry error if undefined
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            return event.exception.values[0].type === 'SentryError';
+        }
+        catch (e) {
+            // ignore
+        }
+        return false;
+    }
+    function _getLastValidUrl(frames) {
+        if (frames === void 0) { frames = []; }
+        for (var i = frames.length - 1; i >= 0; i--) {
+            var frame = frames[i];
+            if (frame && frame.filename !== '<anonymous>' && frame.filename !== '[native code]') {
+                return frame.filename || null;
             }
-            return false;
-        };
-        /** JSDoc */
-        InboundFilters.prototype._isSentryError = function (event, options) {
-            if (!options.ignoreInternal) {
-                return false;
+        }
+        return null;
+    }
+    function _getEventFilterUrl(event) {
+        try {
+            if (event.stacktrace) {
+                return _getLastValidUrl(event.stacktrace.frames);
             }
+            var frames_1;
             try {
-                // @ts-ignore can't be a sentry error if undefined
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-                return event.exception.values[0].type === 'SentryError';
+                // @ts-ignore we only care about frames if the whole thing here is defined
+                frames_1 = event.exception.values[0].stacktrace.frames;
             }
             catch (e) {
                 // ignore
             }
-            return false;
-        };
-        /** JSDoc */
-        InboundFilters.prototype._isIgnoredError = function (event, options) {
-            if (!options.ignoreErrors || !options.ignoreErrors.length) {
-                return false;
-            }
-            return this._getPossibleEventMessages(event).some(function (message) {
-                // Not sure why TypeScript complains here...
-                return options.ignoreErrors.some(function (pattern) { return isMatchingPattern(message, pattern); });
-            });
-        };
-        /** JSDoc */
-        InboundFilters.prototype._isDeniedUrl = function (event, options) {
-            // TODO: Use Glob instead?
-            if (!options.denyUrls || !options.denyUrls.length) {
-                return false;
-            }
-            var url = this._getEventFilterUrl(event);
-            return !url ? false : options.denyUrls.some(function (pattern) { return isMatchingPattern(url, pattern); });
-        };
-        /** JSDoc */
-        InboundFilters.prototype._isAllowedUrl = function (event, options) {
-            // TODO: Use Glob instead?
-            if (!options.allowUrls || !options.allowUrls.length) {
-                return true;
-            }
-            var url = this._getEventFilterUrl(event);
-            return !url ? true : options.allowUrls.some(function (pattern) { return isMatchingPattern(url, pattern); });
-        };
-        /** JSDoc */
-        InboundFilters.prototype._mergeOptions = function (clientOptions) {
-            if (clientOptions === void 0) { clientOptions = {}; }
-            return {
-                allowUrls: __spread((this._options.whitelistUrls || []), (this._options.allowUrls || []), (clientOptions.whitelistUrls || []), (clientOptions.allowUrls || [])),
-                denyUrls: __spread((this._options.blacklistUrls || []), (this._options.denyUrls || []), (clientOptions.blacklistUrls || []), (clientOptions.denyUrls || [])),
-                ignoreErrors: __spread((this._options.ignoreErrors || []), (clientOptions.ignoreErrors || []), DEFAULT_IGNORE_ERRORS),
-                ignoreInternal: typeof this._options.ignoreInternal !== 'undefined' ? this._options.ignoreInternal : true,
-            };
-        };
-        /** JSDoc */
-        InboundFilters.prototype._getPossibleEventMessages = function (event) {
-            if (event.message) {
-                return [event.message];
-            }
-            if (event.exception) {
-                try {
-                    var _a = (event.exception.values && event.exception.values[0]) || {}, _b = _a.type, type = _b === void 0 ? '' : _b, _c = _a.value, value = _c === void 0 ? '' : _c;
-                    return ["" + value, type + ": " + value];
-                }
-                catch (oO) {
-                    logger.error("Cannot extract message for event " + getEventDescription(event));
-                    return [];
-                }
-            }
-            return [];
-        };
-        /** JSDoc */
-        InboundFilters.prototype._getLastValidUrl = function (frames) {
-            if (frames === void 0) { frames = []; }
-            for (var i = frames.length - 1; i >= 0; i--) {
-                var frame = frames[i];
-                if (frame && frame.filename !== '<anonymous>' && frame.filename !== '[native code]') {
-                    return frame.filename || null;
-                }
-            }
+            return frames_1 ? _getLastValidUrl(frames_1) : null;
+        }
+        catch (oO) {
+            logger.error("Cannot extract url for event " + getEventDescription(event));
             return null;
-        };
-        /** JSDoc */
-        InboundFilters.prototype._getEventFilterUrl = function (event) {
-            try {
-                if (event.stacktrace) {
-                    return this._getLastValidUrl(event.stacktrace.frames);
-                }
-                var frames_1;
-                try {
-                    // @ts-ignore we only care about frames if the whole thing here is defined
-                    frames_1 = event.exception.values[0].stacktrace.frames;
-                }
-                catch (e) {
-                    // ignore
-                }
-                return frames_1 ? this._getLastValidUrl(frames_1) : null;
-            }
-            catch (oO) {
-                logger.error("Cannot extract url for event " + getEventDescription(event));
-                return null;
-            }
-        };
-        /**
-         * @inheritDoc
-         */
-        InboundFilters.id = 'InboundFilters';
-        return InboundFilters;
-    }());
+        }
+    }
 
     var CoreIntegrations = /*#__PURE__*/Object.freeze({
         __proto__: null,
@@ -5330,7 +5425,7 @@ 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()) {
+            if (this._isRateLimited(requestType)) {
                 // eslint-disable-next-line deprecation/deprecation
                     logger.warn("Too many " + requestType + " requests, backing off until: " + this._disabledUntil(requestType));
             }
@@ -5495,11 +5590,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
     });
 
     /**
@@ -5533,12 +5694,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;