@sentry/browser 6.13.2 → 6.14.2

package/build/bundle.js

@@ -1,4 +1,4 @@
-/*! @sentry/browser 6.13.2 (1de7a04) | https://github.com/getsentry/sentry-javascript */
+/*! @sentry/browser 6.14.2 (9a623dd) | https://github.com/getsentry/sentry-javascript */
 var Sentry = (function (exports) {
     /*! *****************************************************************************
     Copyright (c) Microsoft Corporation. All rights reserved.
@@ -228,6 +228,62 @@ var Sentry = (function (exports) {
         Outcome["SampleRate"] = "sample_rate";
     })(Outcome || (Outcome = {}));
 
+    /**
+     * Consumes the promise and logs the error when it rejects.
+     * @param promise A promise to forget.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    function forget(promise) {
+        void promise.then(null, function (e) {
+            // TODO: Use a better logging mechanism
+            // eslint-disable-next-line no-console
+            console.error(e);
+        });
+    }
+
+    /**
+     * 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.
+     */
+    /**
+     * Checks whether we're in the Node.js or Browser environment
+     *
+     * @returns Answer to given question
+     */
+    function isNodeEnv() {
+        return Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';
+    }
+    /**
+     * Requires a module which is protected against bundler minification.
+     *
+     * @param request The module path to resolve
+     */
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+    function dynamicRequire(mod, request) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        return mod.require(request);
+    }
+
+    /**
+     * 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.
+     */
+    var fallbackGlobalObject = {};
+    /**
+     * Safely get global scope object
+     *
+     * @returns Global scope object
+     */
+    function getGlobalObject() {
+        return (isNodeEnv()
+            ? global
+            : typeof window !== 'undefined' // eslint-disable-line no-restricted-globals
+                ? window // eslint-disable-line no-restricted-globals
+                : typeof self !== 'undefined'
+                    ? self
+                    : fallbackGlobalObject);
+    }
+
     /* eslint-disable @typescript-eslint/no-explicit-any */
     /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
     /**
@@ -280,7 +336,7 @@ var Sentry = (function (exports) {
         return Object.prototype.toString.call(wat) === '[object DOMException]';
     }
     /**
-     * Checks whether given value's type is a string
+     * Checks whether the given value's type is string
      * {@link isString}.
      *
      * @param wat A value to be checked.
@@ -463,6 +519,18 @@ var Sentry = (function (exports) {
             }
         }
         return out.join('');
+    }
+    /**
+     * A safe form of location.href
+     */
+    function getLocationHref() {
+        var global = getGlobalObject();
+        try {
+            return global.document.location.href;
+        }
+        catch (oO) {
+            return '';
+        }
     }
 
     var setPrototypeOf = Object.setPrototypeOf || ({ __proto__: [] } instanceof Array ? setProtoOf : mixinProperties);
@@ -481,8 +549,7 @@ var Sentry = (function (exports) {
     // eslint-disable-next-line @typescript-eslint/ban-types
     function mixinProperties(obj, proto) {
         for (var prop in proto) {
-            // eslint-disable-next-line no-prototype-builtins
-            if (!obj.hasOwnProperty(prop)) {
+            if (!Object.prototype.hasOwnProperty.call(obj, prop)) {
                 // @ts-ignore typescript complains about indexing so we remove
                 obj[prop] = proto[prop];
             }
@@ -593,175 +660,17 @@ var Sentry = (function (exports) {
         return Dsn;
     }());
 
+    // TODO: Implement different loggers for different environments
+    var global$1 = getGlobalObject();
+    /** Prefix for logging strings */
+    var PREFIX = 'Sentry Logger ';
     /**
-     * Checks whether we're in the Node.js or Browser environment
-     *
-     * @returns Answer to given question
-     */
-    function isNodeEnv() {
-        return Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';
-    }
-    /**
-     * Requires a module which is protected against bundler minification.
-     *
-     * @param request The module path to resolve
-     */
-    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
-    function dynamicRequire(mod, request) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        return mod.require(request);
-    }
-
-    /**
-     * Truncates given string to the maximum characters count
-     *
-     * @param str An object that contains serializable values
-     * @param max Maximum number of characters in truncated string (0 = unlimited)
-     * @returns string Encoded
-     */
-    function truncate(str, max) {
-        if (max === void 0) { max = 0; }
-        if (typeof str !== 'string' || max === 0) {
-            return str;
-        }
-        return str.length <= max ? str : str.substr(0, max) + "...";
-    }
-    /**
-     * Join values in array
-     * @param input array of values to be joined together
-     * @param delimiter string to be placed in-between values
-     * @returns Joined values
-     */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    function safeJoin(input, delimiter) {
-        if (!Array.isArray(input)) {
-            return '';
-        }
-        var output = [];
-        // eslint-disable-next-line @typescript-eslint/prefer-for-of
-        for (var i = 0; i < input.length; i++) {
-            var value = input[i];
-            try {
-                output.push(String(value));
-            }
-            catch (e) {
-                output.push('[value cannot be serialized]');
-            }
-        }
-        return output.join(delimiter);
-    }
-    /**
-     * Checks if the value matches a regex or includes the string
-     * @param value The string value to be checked against
-     * @param pattern Either a regex or a string that must be contained in value
-     */
-    function isMatchingPattern(value, pattern) {
-        if (!isString(value)) {
-            return false;
-        }
-        if (isRegExp(pattern)) {
-            return pattern.test(value);
-        }
-        if (typeof pattern === 'string') {
-            return value.indexOf(pattern) !== -1;
-        }
-        return false;
-    }
-
-    var fallbackGlobalObject = {};
-    /**
-     * Safely get global scope object
-     *
-     * @returns Global scope object
-     */
-    function getGlobalObject() {
-        return (isNodeEnv()
-            ? global
-            : typeof window !== 'undefined' // eslint-disable-line no-restricted-globals
-                ? window // eslint-disable-line no-restricted-globals
-                : typeof self !== 'undefined'
-                    ? self
-                    : fallbackGlobalObject);
-    }
-    /**
-     * UUID4 generator
+     * Temporarily unwrap `console.log` and friends in order to perform the given callback using the original methods.
+     * Restores wrapping after the callback completes.
      *
-     * @returns string Generated UUID4.
-     */
-    function uuid4() {
-        var global = getGlobalObject();
-        var crypto = global.crypto || global.msCrypto;
-        if (!(crypto === void 0) && crypto.getRandomValues) {
-            // Use window.crypto API if available
-            var arr = new Uint16Array(8);
-            crypto.getRandomValues(arr);
-            // set 4 in byte 7
-            // eslint-disable-next-line no-bitwise
-            arr[3] = (arr[3] & 0xfff) | 0x4000;
-            // set 2 most significant bits of byte 9 to '10'
-            // eslint-disable-next-line no-bitwise
-            arr[4] = (arr[4] & 0x3fff) | 0x8000;
-            var pad = function (num) {
-                var v = num.toString(16);
-                while (v.length < 4) {
-                    v = "0" + v;
-                }
-                return v;
-            };
-            return (pad(arr[0]) + pad(arr[1]) + pad(arr[2]) + pad(arr[3]) + pad(arr[4]) + pad(arr[5]) + pad(arr[6]) + pad(arr[7]));
-        }
-        // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523
-        return 'xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
-            // eslint-disable-next-line no-bitwise
-            var r = (Math.random() * 16) | 0;
-            // eslint-disable-next-line no-bitwise
-            var v = c === 'x' ? r : (r & 0x3) | 0x8;
-            return v.toString(16);
-        });
-    }
-    /**
-     * Parses string form of URL into an object
-     * // borrowed from https://tools.ietf.org/html/rfc3986#appendix-B
-     * // intentionally using regex and not <a/> href parsing trick because React Native and other
-     * // environments where DOM might not be available
-     * @returns parsed URL object
-     */
-    function parseUrl(url) {
-        if (!url) {
-            return {};
-        }
-        var match = url.match(/^(([^:/?#]+):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?$/);
-        if (!match) {
-            return {};
-        }
-        // coerce to undefined values to empty string so we don't get 'undefined'
-        var query = match[6] || '';
-        var fragment = match[8] || '';
-        return {
-            host: match[4],
-            path: match[5],
-            protocol: match[2],
-            relative: match[5] + query + fragment,
-        };
-    }
-    /**
-     * Extracts either message or type+value from an event that can be used for user-facing logs
-     * @returns event's description
+     * @param callback The function to run against the original `console` messages
+     * @returns The results of the callback
      */
-    function getEventDescription(event) {
-        if (event.message) {
-            return event.message;
-        }
-        if (event.exception && event.exception.values && event.exception.values[0]) {
-            var exception = event.exception.values[0];
-            if (exception.type && exception.value) {
-                return exception.type + ": " + exception.value;
-            }
-            return exception.type || exception.value || event.event_id || '<unknown>';
-        }
-        return event.event_id || '<unknown>';
-    }
-    /** JSDoc */
     function consoleSandbox(callback) {
         var global = getGlobalObject();
         var levels = ['debug', 'info', 'warn', 'error', 'log', 'assert'];
@@ -787,81 +696,6 @@ var Sentry = (function (exports) {
         });
         return result;
     }
-    /**
-     * Adds exception values, type and value to an synthetic Exception.
-     * @param event The event to modify.
-     * @param value Value of the exception.
-     * @param type Type of the exception.
-     * @hidden
-     */
-    function addExceptionTypeValue(event, value, type) {
-        event.exception = event.exception || {};
-        event.exception.values = event.exception.values || [];
-        event.exception.values[0] = event.exception.values[0] || {};
-        event.exception.values[0].value = event.exception.values[0].value || value || '';
-        event.exception.values[0].type = event.exception.values[0].type || type || 'Error';
-    }
-    /**
-     * Adds exception mechanism to a given event.
-     * @param event The event to modify.
-     * @param mechanism Mechanism of the mechanism.
-     * @hidden
-     */
-    function addExceptionMechanism(event, mechanism) {
-        if (mechanism === void 0) { mechanism = {}; }
-        // TODO: Use real type with `keyof Mechanism` thingy and maybe make it better?
-        try {
-            // @ts-ignore Type 'Mechanism | {}' is not assignable to type 'Mechanism | undefined'
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            event.exception.values[0].mechanism = event.exception.values[0].mechanism || {};
-            Object.keys(mechanism).forEach(function (key) {
-                // @ts-ignore Mechanism has no index signature
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                event.exception.values[0].mechanism[key] = mechanism[key];
-            });
-        }
-        catch (_oO) {
-            // no-empty
-        }
-    }
-    /**
-     * A safe form of location.href
-     */
-    function getLocationHref() {
-        var global = getGlobalObject();
-        try {
-            return global.document.location.href;
-        }
-        catch (oO) {
-            return '';
-        }
-    }
-    var defaultRetryAfter = 60 * 1000; // 60 seconds
-    /**
-     * Extracts Retry-After value from the request header or returns default value
-     * @param now current unix timestamp
-     * @param header string representation of 'Retry-After' header
-     */
-    function parseRetryAfterHeader(now, header) {
-        if (!header) {
-            return defaultRetryAfter;
-        }
-        var headerDelay = parseInt("" + header, 10);
-        if (!isNaN(headerDelay)) {
-            return headerDelay * 1000;
-        }
-        var headerDate = Date.parse("" + header);
-        if (!isNaN(headerDate)) {
-            return headerDate - now;
-        }
-        return defaultRetryAfter;
-    }
-
-    /* eslint-disable @typescript-eslint/no-explicit-any */
-    // TODO: Implement different loggers for different environments
-    var global$1 = getGlobalObject();
-    /** Prefix for logging strings */
-    var PREFIX = 'Sentry Logger ';
     /** JSDoc */
     var Logger = /** @class */ (function () {
         /** JSDoc */
@@ -992,6 +826,62 @@ var Sentry = (function (exports) {
         }
     }
 
+    /**
+     * Truncates given string to the maximum characters count
+     *
+     * @param str An object that contains serializable values
+     * @param max Maximum number of characters in truncated string (0 = unlimited)
+     * @returns string Encoded
+     */
+    function truncate(str, max) {
+        if (max === void 0) { max = 0; }
+        if (typeof str !== 'string' || max === 0) {
+            return str;
+        }
+        return str.length <= max ? str : str.substr(0, max) + "...";
+    }
+    /**
+     * Join values in array
+     * @param input array of values to be joined together
+     * @param delimiter string to be placed in-between values
+     * @returns Joined values
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    function safeJoin(input, delimiter) {
+        if (!Array.isArray(input)) {
+            return '';
+        }
+        var output = [];
+        // eslint-disable-next-line @typescript-eslint/prefer-for-of
+        for (var i = 0; i < input.length; i++) {
+            var value = input[i];
+            try {
+                output.push(String(value));
+            }
+            catch (e) {
+                output.push('[value cannot be serialized]');
+            }
+        }
+        return output.join(delimiter);
+    }
+    /**
+     * Checks if the value matches a regex or includes the string
+     * @param value The string value to be checked against
+     * @param pattern Either a regex or a string that must be contained in value
+     */
+    function isMatchingPattern(value, pattern) {
+        if (!isString(value)) {
+            return false;
+        }
+        if (isRegExp(pattern)) {
+            return pattern.test(value);
+        }
+        if (typeof pattern === 'string') {
+            return value.indexOf(pattern) !== -1;
+        }
+        return false;
+    }
+
     /**
      * Replace a method in an object with a wrapped version of itself.
      *
@@ -1295,10 +1185,9 @@ var Sentry = (function (exports) {
      * Given any object, return the new object with removed keys that value was `undefined`.
      * Works recursively on objects and arrays.
      */
-    function dropUndefinedKeys(val) {
+    function dropUndefinedKeys(obj) {
         var e_1, _a;
-        if (isPlainObject(val)) {
-            var obj = val;
+        if (isPlainObject(obj)) {
             var rv = {};
             try {
                 for (var _b = __values(Object.keys(obj)), _c = _b.next(); !_c.done; _c = _b.next()) {
@@ -1317,10 +1206,10 @@ var Sentry = (function (exports) {
             }
             return rv;
         }
-        if (Array.isArray(val)) {
-            return val.map(dropUndefinedKeys);
+        if (Array.isArray(obj)) {
+            return obj.map(dropUndefinedKeys);
         }
-        return val;
+        return obj;
     }
 
     /**
@@ -1953,18 +1842,191 @@ var Sentry = (function (exports) {
             return false;
         };
     }
-    var _oldOnUnhandledRejectionHandler = null;
-    /** JSDoc */
-    function instrumentUnhandledRejection() {
-        _oldOnUnhandledRejectionHandler = global$2.onunhandledrejection;
-        global$2.onunhandledrejection = function (e) {
-            triggerHandlers('unhandledrejection', e);
-            if (_oldOnUnhandledRejectionHandler) {
-                // eslint-disable-next-line prefer-rest-params
-                return _oldOnUnhandledRejectionHandler.apply(this, arguments);
+    var _oldOnUnhandledRejectionHandler = null;
+    /** JSDoc */
+    function instrumentUnhandledRejection() {
+        _oldOnUnhandledRejectionHandler = global$2.onunhandledrejection;
+        global$2.onunhandledrejection = function (e) {
+            triggerHandlers('unhandledrejection', e);
+            if (_oldOnUnhandledRejectionHandler) {
+                // eslint-disable-next-line prefer-rest-params
+                return _oldOnUnhandledRejectionHandler.apply(this, arguments);
+            }
+            return true;
+        };
+    }
+
+    /**
+     * UUID4 generator
+     *
+     * @returns string Generated UUID4.
+     */
+    function uuid4() {
+        var global = getGlobalObject();
+        var crypto = global.crypto || global.msCrypto;
+        if (!(crypto === void 0) && crypto.getRandomValues) {
+            // Use window.crypto API if available
+            var arr = new Uint16Array(8);
+            crypto.getRandomValues(arr);
+            // set 4 in byte 7
+            // eslint-disable-next-line no-bitwise
+            arr[3] = (arr[3] & 0xfff) | 0x4000;
+            // set 2 most significant bits of byte 9 to '10'
+            // eslint-disable-next-line no-bitwise
+            arr[4] = (arr[4] & 0x3fff) | 0x8000;
+            var pad = function (num) {
+                var v = num.toString(16);
+                while (v.length < 4) {
+                    v = "0" + v;
+                }
+                return v;
+            };
+            return (pad(arr[0]) + pad(arr[1]) + pad(arr[2]) + pad(arr[3]) + pad(arr[4]) + pad(arr[5]) + pad(arr[6]) + pad(arr[7]));
+        }
+        // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523
+        return 'xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+            // eslint-disable-next-line no-bitwise
+            var r = (Math.random() * 16) | 0;
+            // eslint-disable-next-line no-bitwise
+            var v = c === 'x' ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    }
+    /**
+     * Parses string form of URL into an object
+     * // borrowed from https://tools.ietf.org/html/rfc3986#appendix-B
+     * // intentionally using regex and not <a/> href parsing trick because React Native and other
+     * // environments where DOM might not be available
+     * @returns parsed URL object
+     */
+    function parseUrl(url) {
+        if (!url) {
+            return {};
+        }
+        var match = url.match(/^(([^:/?#]+):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?$/);
+        if (!match) {
+            return {};
+        }
+        // coerce to undefined values to empty string so we don't get 'undefined'
+        var query = match[6] || '';
+        var fragment = match[8] || '';
+        return {
+            host: match[4],
+            path: match[5],
+            protocol: match[2],
+            relative: match[5] + query + fragment,
+        };
+    }
+    /**
+     * Extracts either message or type+value from an event that can be used for user-facing logs
+     * @returns event's description
+     */
+    function getEventDescription(event) {
+        if (event.message) {
+            return event.message;
+        }
+        if (event.exception && event.exception.values && event.exception.values[0]) {
+            var exception = event.exception.values[0];
+            if (exception.type && exception.value) {
+                return exception.type + ": " + exception.value;
             }
+            return exception.type || exception.value || event.event_id || '<unknown>';
+        }
+        return event.event_id || '<unknown>';
+    }
+    /**
+     * Adds exception values, type and value to an synthetic Exception.
+     * @param event The event to modify.
+     * @param value Value of the exception.
+     * @param type Type of the exception.
+     * @hidden
+     */
+    function addExceptionTypeValue(event, value, type) {
+        event.exception = event.exception || {};
+        event.exception.values = event.exception.values || [];
+        event.exception.values[0] = event.exception.values[0] || {};
+        event.exception.values[0].value = event.exception.values[0].value || value || '';
+        event.exception.values[0].type = event.exception.values[0].type || type || 'Error';
+    }
+    /**
+     * Adds exception mechanism data to a given event. Uses defaults if the second parameter is not passed.
+     *
+     * @param event The event to modify.
+     * @param newMechanism Mechanism data to add to the event.
+     * @hidden
+     */
+    function addExceptionMechanism(event, newMechanism) {
+        var _a;
+        if (!event.exception || !event.exception.values) {
+            return;
+        }
+        var exceptionValue0 = event.exception.values[0];
+        var defaultMechanism = { type: 'generic', handled: true };
+        var currentMechanism = exceptionValue0.mechanism;
+        exceptionValue0.mechanism = __assign(__assign(__assign({}, defaultMechanism), currentMechanism), newMechanism);
+        if (newMechanism && 'data' in newMechanism) {
+            var mergedData = __assign(__assign({}, (_a = currentMechanism) === null || _a === void 0 ? void 0 : _a.data), newMechanism.data);
+            exceptionValue0.mechanism.data = mergedData;
+        }
+    }
+    var defaultRetryAfter = 60 * 1000; // 60 seconds
+    /**
+     * Extracts Retry-After value from the request header or returns default value
+     * @param now current unix timestamp
+     * @param header string representation of 'Retry-After' header
+     */
+    function parseRetryAfterHeader(now, header) {
+        if (!header) {
+            return defaultRetryAfter;
+        }
+        var headerDelay = parseInt("" + header, 10);
+        if (!isNaN(headerDelay)) {
+            return headerDelay * 1000;
+        }
+        var headerDate = Date.parse("" + header);
+        if (!isNaN(headerDate)) {
+            return headerDate - now;
+        }
+        return defaultRetryAfter;
+    }
+    /**
+     * Checks whether or not we've already captured the given exception (note: not an identical exception - the very object
+     * in question), and marks it captured if not.
+     *
+     * This is useful because it's possible for an error to get captured by more than one mechanism. After we intercept and
+     * record an error, we rethrow it (assuming we've intercepted it before it's reached the top-level global handlers), so
+     * that we don't interfere with whatever effects the error might have had were the SDK not there. At that point, because
+     * the error has been rethrown, it's possible for it to bubble up to some other code we've instrumented. If it's not
+     * caught after that, it will bubble all the way up to the global handlers (which of course we also instrument). This
+     * function helps us ensure that even if we encounter the same error more than once, we only record it the first time we
+     * see it.
+     *
+     * Note: It will ignore primitives (always return `false` and not mark them as seen), as properties can't be set on
+     * them. {@link: Object.objectify} can be used on exceptions to convert any that are primitives into their equivalent
+     * object wrapper forms so that this check will always work. However, because we need to flag the exact object which
+     * will get rethrown, and because that rethrowing happens outside of the event processing pipeline, the objectification
+     * must be done before the exception captured.
+     *
+     * @param A thrown exception to check or flag as having been seen
+     * @returns `true` if the exception has already been captured, `false` if not (with the side effect of marking it seen)
+     */
+    function checkOrSetAlreadyCaught(exception) {
+        var _a;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        if ((_a = exception) === null || _a === void 0 ? void 0 : _a.__sentry_captured__) {
             return true;
-        };
+        }
+        try {
+            // set it this way rather than by assignment so that it's not ennumerable and therefore isn't recorded by the
+            // `ExtraErrorData` integration
+            Object.defineProperty(exception, '__sentry_captured__', {
+                value: true,
+            });
+        }
+        catch (err) {
+            // `exception` is a primitive, so we can't mark it seen
+        }
+        return false;
     }
 
     /* eslint-disable @typescript-eslint/explicit-function-return-type */
@@ -3806,6 +3868,7 @@ var Sentry = (function (exports) {
         return integrations;
     }
 
+    var ALREADY_SEEN_ERROR = "Not capturing exception because it's already been captured.";
     /**
      * Base implementation for all JavaScript SDK clients.
      *
@@ -3862,6 +3925,11 @@ var Sentry = (function (exports) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
         BaseClient.prototype.captureException = function (exception, hint, scope) {
             var _this = this;
+            // ensure we haven't captured this very object before
+            if (checkOrSetAlreadyCaught(exception)) {
+                logger.log(ALREADY_SEEN_ERROR);
+                return;
+            }
             var eventId = hint && hint.event_id;
             this._process(this._getBackend()
                 .eventFromException(exception, hint)
@@ -3891,6 +3959,12 @@ var Sentry = (function (exports) {
          * @inheritDoc
          */
         BaseClient.prototype.captureEvent = function (event, hint, scope) {
+            var _a;
+            // ensure we haven't captured this very object before
+            if (((_a = hint) === null || _a === void 0 ? void 0 : _a.originalException) && checkOrSetAlreadyCaught(hint.originalException)) {
+                logger.log(ALREADY_SEEN_ERROR);
+                return;
+            }
             var eventId = hint && hint.event_id;
             this._process(this._captureEvent(event, hint, scope).then(function (result) {
                 eventId = result;
@@ -4483,7 +4557,7 @@ var Sentry = (function (exports) {
         hub.bindClient(client);
     }
 
-    var SDK_VERSION = '6.13.2';
+    var SDK_VERSION = '6.14.2';
 
     var originalFunctionToString;
     /** Patch toString calls to return proper name for wrapped functions */
@@ -5047,10 +5121,7 @@ var Sentry = (function (exports) {
         var event = eventFromUnknownInput(exception, syntheticException, {
             attachStacktrace: options.attachStacktrace,
         });
-        addExceptionMechanism(event, {
-            handled: true,
-            type: 'generic',
-        });
+        addExceptionMechanism(event); // defaults to { type: 'generic', handled: true }
         event.level = exports.Severity.Error;
         if (hint && hint.event_id) {
             event.event_id = hint.event_id;
@@ -5079,11 +5150,10 @@ var Sentry = (function (exports) {
     function eventFromUnknownInput(exception, syntheticException, options) {
         if (options === void 0) { options = {}; }
         var event;
-        if (isErrorEvent(exception) && exception.error) {
+        if (isErrorEvent(exception)) {
             // If it is an ErrorEvent with `error` property, extract it to get actual Error
-            var errorEvent = exception;
             // eslint-disable-next-line no-param-reassign
-            exception = errorEvent.error;
+            exception = exception.error;
             event = eventFromStacktrace(computeStackTrace(exception));
             return event;
         }
@@ -5152,13 +5222,108 @@ var Sentry = (function (exports) {
         return event;
     }
 
+    var global$3 = getGlobalObject();
+    var cachedFetchImpl;
+    /**
+     * A special usecase for incorrectly wrapped Fetch APIs in conjunction with ad-blockers.
+     * Whenever someone wraps the Fetch API and returns the wrong promise chain,
+     * this chain becomes orphaned and there is no possible way to capture it's rejections
+     * other than allowing it bubble up to this very handler. eg.
+     *
+     * const f = window.fetch;
+     * window.fetch = function () {
+     *   const p = f.apply(this, arguments);
+     *
+     *   p.then(function() {
+     *     console.log('hi.');
+     *   });
+     *
+     *   return p;
+     * }
+     *
+     * `p.then(function () { ... })` is producing a completely separate promise chain,
+     * however, what's returned is `p` - the result of original `fetch` call.
+     *
+     * This mean, that whenever we use the Fetch API to send our own requests, _and_
+     * some ad-blocker blocks it, this orphaned chain will _always_ reject,
+     * effectively causing another event to be captured.
+     * This makes a whole process become an infinite loop, which we need to somehow
+     * deal with, and break it in one way or another.
+     *
+     * To deal with this issue, we are making sure that we _always_ use the real
+     * browser Fetch API, instead of relying on what `window.fetch` exposes.
+     * The only downside to this would be missing our own requests as breadcrumbs,
+     * but because we are already not doing this, it should be just fine.
+     *
+     * Possible failed fetch error messages per-browser:
+     *
+     * Chrome:  Failed to fetch
+     * Edge:    Failed to Fetch
+     * Firefox: NetworkError when attempting to fetch resource
+     * Safari:  resource blocked by content blocker
+     */
+    function getNativeFetchImplementation() {
+        var _a, _b;
+        if (cachedFetchImpl) {
+            return cachedFetchImpl;
+        }
+        /* eslint-disable @typescript-eslint/unbound-method */
+        // Fast path to avoid DOM I/O
+        if (isNativeFetch(global$3.fetch)) {
+            return (cachedFetchImpl = global$3.fetch.bind(global$3));
+        }
+        var document = global$3.document;
+        var fetchImpl = global$3.fetch;
+        // eslint-disable-next-line deprecation/deprecation
+        if (typeof ((_a = document) === null || _a === void 0 ? void 0 : _a.createElement) === "function") {
+            try {
+                var sandbox = document.createElement('iframe');
+                sandbox.hidden = true;
+                document.head.appendChild(sandbox);
+                if ((_b = sandbox.contentWindow) === null || _b === void 0 ? void 0 : _b.fetch) {
+                    fetchImpl = sandbox.contentWindow.fetch;
+                }
+                document.head.removeChild(sandbox);
+            }
+            catch (e) {
+                logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', e);
+            }
+        }
+        return (cachedFetchImpl = fetchImpl.bind(global$3));
+        /* eslint-enable @typescript-eslint/unbound-method */
+    }
+    /**
+     * Sends sdk client report using sendBeacon or fetch as a fallback if available
+     *
+     * @param url report endpoint
+     * @param body report payload
+     */
+    function sendReport(url, body) {
+        var isRealNavigator = Object.prototype.toString.call(global$3 && global$3.navigator) === '[object Navigator]';
+        var hasSendBeacon = isRealNavigator && typeof global$3.navigator.sendBeacon === 'function';
+        if (hasSendBeacon) {
+            // Prevent illegal invocations - https://xgwang.me/posts/you-may-not-know-beacon/#it-may-throw-error%2C-be-sure-to-catch
+            var sendBeacon = global$3.navigator.sendBeacon.bind(global$3.navigator);
+            return sendBeacon(url, body);
+        }
+        if (supportsFetch()) {
+            var fetch_1 = getNativeFetchImplementation();
+            return forget(fetch_1(url, {
+                body: body,
+                method: 'POST',
+                credentials: 'omit',
+                keepalive: true,
+            }));
+        }
+    }
+
     var CATEGORY_MAPPING = {
         event: 'error',
         transaction: 'transaction',
         session: 'session',
         attachment: 'attachment',
     };
-    var global$3 = getGlobalObject();
+    var global$4 = getGlobalObject();
     /** Base Transport class implementation */
     var BaseTransport = /** @class */ (function () {
         function BaseTransport(options) {
@@ -5172,9 +5337,9 @@ var Sentry = (function (exports) {
             this._api = new API(options.dsn, options._metadata, options.tunnel);
             // eslint-disable-next-line deprecation/deprecation
             this.url = this._api.getStoreEndpointWithUrlEncodedAuth();
-            if (this.options.sendClientReports && global$3.document) {
-                global$3.document.addEventListener('visibilitychange', function () {
-                    if (global$3.document.visibilityState === 'hidden') {
+            if (this.options.sendClientReports && global$4.document) {
+                global$4.document.addEventListener('visibilitychange', function () {
+                    if (global$4.document.visibilityState === 'hidden') {
                         _this._flushOutcomes();
                     }
                 });
@@ -5216,10 +5381,6 @@ var Sentry = (function (exports) {
             if (!this.options.sendClientReports) {
                 return;
             }
-            if (!global$3.navigator || typeof global$3.navigator.sendBeacon !== 'function') {
-                logger.warn('Beacon API not available, skipping sending outcomes.');
-                return;
-            }
             var outcomes = this._outcomes;
             this._outcomes = {};
             // Nothing to send
@@ -5230,7 +5391,7 @@ var Sentry = (function (exports) {
             logger.log("Flushing outcomes:\n" + JSON.stringify(outcomes, null, 2));
             var url = this._api.getEnvelopeEndpointWithUrlEncodedAuth();
             // Envelope header is required to be at least an empty object
-            var envelopeHeader = JSON.stringify({});
+            var envelopeHeader = JSON.stringify(__assign({}, (this.options.tunnel && { dsn: this._api.getDsn().toString() })));
             var itemHeaders = JSON.stringify({
                 type: 'client_report',
             });
@@ -5246,7 +5407,12 @@ var Sentry = (function (exports) {
                 }),
             });
             var envelope = envelopeHeader + "\n" + itemHeaders + "\n" + item;
-            global$3.navigator.sendBeacon(url, envelope);
+            try {
+                sendReport(url, envelope);
+            }
+            catch (e) {
+                logger.error(e);
+            }
         };
         /**
          * Handle Sentry repsonse for promise-based transports.
@@ -5338,72 +5504,6 @@ var Sentry = (function (exports) {
         return BaseTransport;
     }());
 
-    /**
-     * A special usecase for incorrectly wrapped Fetch APIs in conjunction with ad-blockers.
-     * Whenever someone wraps the Fetch API and returns the wrong promise chain,
-     * this chain becomes orphaned and there is no possible way to capture it's rejections
-     * other than allowing it bubble up to this very handler. eg.
-     *
-     * const f = window.fetch;
-     * window.fetch = function () {
-     *   const p = f.apply(this, arguments);
-     *
-     *   p.then(function() {
-     *     console.log('hi.');
-     *   });
-     *
-     *   return p;
-     * }
-     *
-     * `p.then(function () { ... })` is producing a completely separate promise chain,
-     * however, what's returned is `p` - the result of original `fetch` call.
-     *
-     * This mean, that whenever we use the Fetch API to send our own requests, _and_
-     * some ad-blocker blocks it, this orphaned chain will _always_ reject,
-     * effectively causing another event to be captured.
-     * This makes a whole process become an infinite loop, which we need to somehow
-     * deal with, and break it in one way or another.
-     *
-     * To deal with this issue, we are making sure that we _always_ use the real
-     * browser Fetch API, instead of relying on what `window.fetch` exposes.
-     * The only downside to this would be missing our own requests as breadcrumbs,
-     * but because we are already not doing this, it should be just fine.
-     *
-     * Possible failed fetch error messages per-browser:
-     *
-     * Chrome:  Failed to fetch
-     * Edge:    Failed to Fetch
-     * Firefox: NetworkError when attempting to fetch resource
-     * Safari:  resource blocked by content blocker
-     */
-    function getNativeFetchImplementation() {
-        /* eslint-disable @typescript-eslint/unbound-method */
-        var _a, _b;
-        // Fast path to avoid DOM I/O
-        var global = getGlobalObject();
-        if (isNativeFetch(global.fetch)) {
-            return global.fetch.bind(global);
-        }
-        var document = global.document;
-        var fetchImpl = global.fetch;
-        // eslint-disable-next-line deprecation/deprecation
-        if (typeof ((_a = document) === null || _a === void 0 ? void 0 : _a.createElement) === "function") {
-            try {
-                var sandbox = document.createElement('iframe');
-                sandbox.hidden = true;
-                document.head.appendChild(sandbox);
-                if ((_b = sandbox.contentWindow) === null || _b === void 0 ? void 0 : _b.fetch) {
-                    fetchImpl = sandbox.contentWindow.fetch;
-                }
-                document.head.removeChild(sandbox);
-            }
-            catch (e) {
-                logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', e);
-            }
-        }
-        return fetchImpl.bind(global);
-        /* eslint-enable @typescript-eslint/unbound-method */
-    }
     /** `fetch` based transport */
     var FetchTransport = /** @class */ (function (_super) {
         __extends(FetchTransport, _super);
@@ -5537,7 +5637,7 @@ var Sentry = (function (exports) {
                     };
                     request.open('POST', sentryRequest.url);
                     for (var header in _this.options.headers) {
-                        if (_this.options.headers.hasOwnProperty(header)) {
+                        if (Object.prototype.hasOwnProperty.call(_this.options.headers, header)) {
                             request.setRequestHeader(header, _this.options.headers[header]);
                         }
                     }
@@ -5609,7 +5709,7 @@ var Sentry = (function (exports) {
         return BrowserBackend;
     }(BaseBackend));
 
-    var global$4 = getGlobalObject();
+    var global$5 = getGlobalObject();
     var ignoreOnError = 0;
     /**
      * @hidden
@@ -5747,7 +5847,7 @@ var Sentry = (function (exports) {
      */
     function injectReportDialog(options) {
         if (options === void 0) { options = {}; }
-        if (!global$4.document) {
+        if (!global$5.document) {
             return;
         }
         if (!options.eventId) {
@@ -5758,14 +5858,14 @@ var Sentry = (function (exports) {
             logger.error("Missing dsn option in showReportDialog call");
             return;
         }
-        var script = global$4.document.createElement('script');
+        var script = global$5.document.createElement('script');
         script.async = true;
         script.src = new API(options.dsn).getReportDialogEndpoint(options);
         if (options.onLoad) {
             // eslint-disable-next-line @typescript-eslint/unbound-method
             script.onload = options.onLoad;
         }
-        var injectionPoint = global$4.document.head || global$4.document.body;
+        var injectionPoint = global$5.document.head || global$5.document.body;
         if (injectionPoint) {
             injectionPoint.appendChild(script);
         }
@@ -6073,7 +6173,7 @@ var Sentry = (function (exports) {
             var global = getGlobalObject();
             // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
             var proto = global[target] && global[target].prototype;
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-prototype-builtins
             if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {
                 return;
             }
@@ -6510,7 +6610,7 @@ var Sentry = (function (exports) {
         return LinkedErrors;
     }());
 
-    var global$5 = getGlobalObject();
+    var global$6 = getGlobalObject();
     /** UserAgent */
     var UserAgent = /** @class */ (function () {
         function UserAgent() {
@@ -6527,13 +6627,13 @@ var Sentry = (function (exports) {
                 var _a, _b, _c;
                 if (getCurrentHub().getIntegration(UserAgent)) {
                     // if none of the information we want exists, don't bother
-                    if (!global$5.navigator && !global$5.location && !global$5.document) {
+                    if (!global$6.navigator && !global$6.location && !global$6.document) {
                         return event;
                     }
                     // grab as much info as exists and add it to the event
-                    var url = ((_a = event.request) === null || _a === void 0 ? void 0 : _a.url) || ((_b = global$5.location) === null || _b === void 0 ? void 0 : _b.href);
-                    var referrer = (global$5.document || {}).referrer;
-                    var userAgent = (global$5.navigator || {}).userAgent;
+                    var url = ((_a = event.request) === null || _a === void 0 ? void 0 : _a.url) || ((_b = global$6.location) === null || _b === void 0 ? void 0 : _b.href);
+                    var referrer = (global$6.document || {}).referrer;
+                    var userAgent = (global$6.navigator || {}).userAgent;
                     var headers = __assign(__assign(__assign({}, (_c = event.request) === null || _c === void 0 ? void 0 : _c.headers), (referrer && { Referer: referrer })), (userAgent && { 'User-Agent': userAgent }));
                     var request = __assign(__assign({}, (url && { url: url })), { headers: headers });
                     return __assign(__assign({}, event), { request: request });