vviinn-widgets 0.9.4 → 0.9.8

package/dist/cjs/{app-globals-f0541d27.js → app-globals-cb302902.js}

@@ -1,5 +1,7 @@
 'use strict';
 
+const index = require('./index-e31c19f6.js');
+
 /*! *****************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -175,7 +177,7 @@ var Status;
     Status["RateLimit"] = "rate_limit";
     /** The event could not be processed. */
     Status["Invalid"] = "invalid";
-    /** A server-side error ocurred during submission. */
+    /** A server-side error occurred during submission. */
     Status["Failed"] = "failed";
 })(Status || (Status = {}));
 // eslint-disable-next-line @typescript-eslint/no-namespace, import/export
@@ -212,6 +214,102 @@ var TransactionSamplingMethod;
     TransactionSamplingMethod["Inheritance"] = "inheritance";
 })(TransactionSamplingMethod || (TransactionSamplingMethod = {}));
 
+var Outcome;
+(function (Outcome) {
+    Outcome["BeforeSend"] = "before_send";
+    Outcome["EventProcessor"] = "event_processor";
+    Outcome["NetworkError"] = "network_error";
+    Outcome["QueueOverflow"] = "queue_overflow";
+    Outcome["RateLimitBackoff"] = "ratelimit_backoff";
+    Outcome["SampleRate"] = "sample_rate";
+})(Outcome || (Outcome = {}));
+
+/**
+ * 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);
+}
+/**
+ * Helper for dynamically loading module that should work with linked dependencies.
+ * The problem is that we _should_ be using `require(require.resolve(moduleName, { paths: [cwd()] }))`
+ * However it's _not possible_ to do that with Webpack, as it has to know all the dependencies during
+ * build time. `require.resolve` is also not available in any other way, so we cannot create,
+ * a fake helper like we do with `dynamicRequire`.
+ *
+ * We always prefer to use local package, thus the value is not returned early from each `try/catch` block.
+ * That is to mimic the behavior of `require.resolve` exactly.
+ *
+ * @param moduleName module name to require
+ * @returns possibly required module
+ */
+function loadModule(moduleName) {
+    var mod;
+    try {
+        mod = dynamicRequire(module, moduleName);
+    }
+    catch (e) {
+        // no-empty
+    }
+    try {
+        var cwd = dynamicRequire(module, 'process').cwd;
+        mod = dynamicRequire(module, cwd() + "/node_modules/" + moduleName);
+    }
+    catch (e) {
+        // no-empty
+    }
+    return mod;
+}
+
+/**
+ * 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 */
 /**
@@ -448,6 +546,18 @@ function _htmlElementAsString(el, keyAttrs) {
     }
     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);
 /**
@@ -465,8 +575,7 @@ function setProtoOf(obj, proto) {
 // 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];
         }
@@ -575,207 +684,19 @@ var Dsn = /** @class */ (function () {
         }
     };
     return Dsn;
-}());
-
-/**
- * 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);
-}
-/**
- * Helper for dynamically loading module that should work with linked dependencies.
- * The problem is that we _should_ be using `require(require.resolve(moduleName, { paths: [cwd()] }))`
- * However it's _not possible_ to do that with Webpack, as it has to know all the dependencies during
- * build time. `require.resolve` is also not available in any other way, so we cannot create,
- * a fake helper like we do with `dynamicRequire`.
- *
- * We always prefer to use local package, thus the value is not returned early from each `try/catch` block.
- * That is to mimic the behavior of `require.resolve` exactly.
- *
- * @param moduleName module name to require
- * @returns possibly required module
- */
-function loadModule(moduleName) {
-    var mod;
-    try {
-        mod = dynamicRequire(module, moduleName);
-    }
-    catch (e) {
-        // no-empty
-    }
-    try {
-        var cwd = dynamicRequire(module, 'process').cwd;
-        mod = dynamicRequire(module, cwd() + "/node_modules/" + moduleName);
-    }
-    catch (e) {
-        // no-empty
-    }
-    return mod;
-}
-
-/**
- * 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'
-            ? window
-            : typeof self !== 'undefined'
-                ? self
-                : fallbackGlobalObject);
-}
-/**
- * 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,
-    };
-}
+}());
+
+// TODO: Implement different loggers for different environments
+var global$9 = getGlobalObject();
+/** Prefix for logging strings */
+var PREFIX = 'Sentry Logger ';
 /**
- * Extracts either message or type+value from an event that can be used for user-facing logs
- * @returns event's description
+ * Temporarily unwrap `console.log` and friends in order to perform the given callback using the original methods.
+ * Restores wrapping after the callback completes.
+ *
+ * @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'];
@@ -801,80 +722,6 @@ function consoleSandbox(callback) {
     });
     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() {
-    try {
-        return 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$6 = getGlobalObject();
-/** Prefix for logging strings */
-var PREFIX = 'Sentry Logger ';
 /** JSDoc */
 var Logger = /** @class */ (function () {
     /** JSDoc */
@@ -899,7 +746,7 @@ var Logger = /** @class */ (function () {
             return;
         }
         consoleSandbox(function () {
-            global$6.console.log(PREFIX + "[Log]: " + args.join(' '));
+            global$9.console.log(PREFIX + "[Log]: " + args.join(' '));
         });
     };
     /** JSDoc */
@@ -912,7 +759,7 @@ var Logger = /** @class */ (function () {
             return;
         }
         consoleSandbox(function () {
-            global$6.console.warn(PREFIX + "[Warn]: " + args.join(' '));
+            global$9.console.warn(PREFIX + "[Warn]: " + args.join(' '));
         });
     };
     /** JSDoc */
@@ -925,14 +772,14 @@ var Logger = /** @class */ (function () {
             return;
         }
         consoleSandbox(function () {
-            global$6.console.error(PREFIX + "[Error]: " + args.join(' '));
+            global$9.console.error(PREFIX + "[Error]: " + args.join(' '));
         });
     };
     return Logger;
 }());
 // Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used
-global$6.__SENTRY__ = global$6.__SENTRY__ || {};
-var logger = global$6.__SENTRY__.logger || (global$6.__SENTRY__.logger = new Logger());
+global$9.__SENTRY__ = global$9.__SENTRY__ || {};
+var logger = global$9.__SENTRY__.logger || (global$9.__SENTRY__.logger = new Logger());
 
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 /* eslint-disable @typescript-eslint/no-explicit-any */
@@ -1005,6 +852,62 @@ function getFunctionName(fn) {
     }
 }
 
+/**
+ * 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.
  *
@@ -1174,9 +1077,13 @@ function normalizeValue(value, key) {
     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]';
     }
@@ -1441,7 +1348,7 @@ function supportsHistory() {
     return !isChromePackagedApp && hasHistoryApi;
 }
 
-var global$5 = getGlobalObject();
+var global$8 = getGlobalObject();
 /**
  * Instrument native APIs to call handlers that can be used to create breadcrumbs, APM spans etc.
  *  - Console API
@@ -1526,14 +1433,14 @@ function triggerHandlers(type, data) {
 }
 /** JSDoc */
 function instrumentConsole() {
-    if (!('console' in global$5)) {
+    if (!('console' in global$8)) {
         return;
     }
     ['debug', 'info', 'warn', 'error', 'log', 'assert'].forEach(function (level) {
-        if (!(level in global$5.console)) {
+        if (!(level in global$8.console)) {
             return;
         }
-        fill(global$5.console, level, function (originalConsoleLevel) {
+        fill(global$8.console, level, function (originalConsoleLevel) {
             return function () {
                 var args = [];
                 for (var _i = 0; _i < arguments.length; _i++) {
@@ -1542,7 +1449,7 @@ function instrumentConsole() {
                 triggerHandlers('console', { args: args, level: level });
                 // this fails for some browsers. :(
                 if (originalConsoleLevel) {
-                    Function.prototype.apply.call(originalConsoleLevel, global$5.console, args);
+                    Function.prototype.apply.call(originalConsoleLevel, global$8.console, args);
                 }
             };
         });
@@ -1553,7 +1460,7 @@ function instrumentFetch() {
     if (!supportsNativeFetch()) {
         return;
     }
-    fill(global$5, 'fetch', function (originalFetch) {
+    fill(global$8, 'fetch', function (originalFetch) {
         return function () {
             var args = [];
             for (var _i = 0; _i < arguments.length; _i++) {
@@ -1569,7 +1476,7 @@ function instrumentFetch() {
             };
             triggerHandlers('fetch', __assign({}, handlerData));
             // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-            return originalFetch.apply(global$5, args).then(function (response) {
+            return originalFetch.apply(global$8, args).then(function (response) {
                 triggerHandlers('fetch', __assign(__assign({}, handlerData), { endTimestamp: Date.now(), response: response }));
                 return response;
             }, function (error) {
@@ -1586,7 +1493,7 @@ function instrumentFetch() {
 /** Extract `method` from fetch call arguments */
 function getFetchMethod(fetchArgs) {
     if (fetchArgs === void 0) { fetchArgs = []; }
-    if ('Request' in global$5 && isInstanceOf(fetchArgs[0], Request) && fetchArgs[0].method) {
+    if ('Request' in global$8 && isInstanceOf(fetchArgs[0], Request) && fetchArgs[0].method) {
         return String(fetchArgs[0].method).toUpperCase();
     }
     if (fetchArgs[1] && fetchArgs[1].method) {
@@ -1600,7 +1507,7 @@ function getFetchUrl(fetchArgs) {
     if (typeof fetchArgs[0] === 'string') {
         return fetchArgs[0];
     }
-    if ('Request' in global$5 && isInstanceOf(fetchArgs[0], Request)) {
+    if ('Request' in global$8 && isInstanceOf(fetchArgs[0], Request)) {
         return fetchArgs[0].url;
     }
     return String(fetchArgs[0]);
@@ -1608,7 +1515,7 @@ function getFetchUrl(fetchArgs) {
 /* eslint-enable @typescript-eslint/no-unsafe-member-access */
 /** JSDoc */
 function instrumentXHR() {
-    if (!('XMLHttpRequest' in global$5)) {
+    if (!('XMLHttpRequest' in global$8)) {
         return;
     }
     // Poor man's implementation of ES6 `Map`, tracking and keeping in sync key and value separately.
@@ -1709,13 +1616,13 @@ function instrumentHistory() {
     if (!supportsHistory()) {
         return;
     }
-    var oldOnPopState = global$5.onpopstate;
-    global$5.onpopstate = function () {
+    var oldOnPopState = global$8.onpopstate;
+    global$8.onpopstate = function () {
         var args = [];
         for (var _i = 0; _i < arguments.length; _i++) {
             args[_i] = arguments[_i];
         }
-        var to = global$5.location.href;
+        var to = global$8.location.href;
         // keep track of the current URL state, as we always receive only the updated state
         var from = lastHref;
         lastHref = to;
@@ -1757,8 +1664,8 @@ function instrumentHistory() {
             return originalHistoryFunction.apply(this, args);
         };
     }
-    fill(global$5.history, 'pushState', historyReplacementFunction);
-    fill(global$5.history, 'replaceState', historyReplacementFunction);
+    fill(global$8.history, 'pushState', historyReplacementFunction);
+    fill(global$8.history, 'replaceState', historyReplacementFunction);
 }
 var debounceDuration = 1000;
 var debounceTimerID;
@@ -1861,14 +1768,14 @@ function makeDOMEventHandler(handler, globalListener) {
         }
         // Start a new debounce timer that will prevent us from capturing multiple events that should be grouped together.
         clearTimeout(debounceTimerID);
-        debounceTimerID = global$5.setTimeout(function () {
+        debounceTimerID = global$8.setTimeout(function () {
             debounceTimerID = undefined;
         }, debounceDuration);
     };
 }
 /** JSDoc */
 function instrumentDOM() {
-    if (!('document' in global$5)) {
+    if (!('document' in global$8)) {
         return;
     }
     // Make it so that any click or keypress that is unhandled / bubbled up all the way to the document triggers our dom
@@ -1876,8 +1783,8 @@ function instrumentDOM() {
     // we instrument `addEventListener` so that we don't end up attaching this handler twice.
     var triggerDOMHandler = triggerHandlers.bind(null, 'dom');
     var globalDOMEventHandler = makeDOMEventHandler(triggerDOMHandler, true);
-    global$5.document.addEventListener('click', globalDOMEventHandler, false);
-    global$5.document.addEventListener('keypress', globalDOMEventHandler, false);
+    global$8.document.addEventListener('click', globalDOMEventHandler, false);
+    global$8.document.addEventListener('keypress', globalDOMEventHandler, false);
     // After hooking into click and keypress events bubbled up to `document`, we also hook into user-handled
     // clicks & keypresses, by adding an event listener of our own to any element to which they add a listener. That
     // way, whenever one of their handlers is triggered, ours will be, too. (This is needed because their handler
@@ -1885,7 +1792,7 @@ function instrumentDOM() {
     // guaranteed to fire at least once.)
     ['EventTarget', 'Node'].forEach(function (target) {
         // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        var proto = global$5[target] && global$5[target].prototype;
+        var proto = global$8[target] && global$8[target].prototype;
         // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-prototype-builtins
         if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {
             return;
@@ -1946,8 +1853,8 @@ function instrumentDOM() {
 var _oldOnErrorHandler = null;
 /** JSDoc */
 function instrumentError() {
-    _oldOnErrorHandler = global$5.onerror;
-    global$5.onerror = function (msg, url, line, column, error) {
+    _oldOnErrorHandler = global$8.onerror;
+    global$8.onerror = function (msg, url, line, column, error) {
         triggerHandlers('error', {
             column: column,
             error: error,
@@ -1962,18 +1869,191 @@ function instrumentError() {
         return false;
     };
 }
-var _oldOnUnhandledRejectionHandler = null;
-/** JSDoc */
-function instrumentUnhandledRejection() {
-    _oldOnUnhandledRejectionHandler = global$5.onunhandledrejection;
-    global$5.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$8.onunhandledrejection;
+    global$8.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 */
@@ -3107,7 +3187,10 @@ var Hub = /** @class */ (function () {
      * @inheritDoc
      */
     Hub.prototype.captureEvent = function (event, hint) {
-        var eventId = (this._lastEventId = uuid4());
+        var eventId = uuid4();
+        if (event.type !== 'transaction') {
+            this._lastEventId = eventId;
+        }
         this._invokeClient('captureEvent', event, __assign(__assign({}, hint), { event_id: eventId }));
         return eventId;
     };
@@ -3696,6 +3779,7 @@ function setupIntegrations(options) {
     return integrations;
 }
 
+var ALREADY_SEEN_ERROR = "Not capturing exception because it's already been captured.";
 /**
  * Base implementation for all JavaScript SDK clients.
  *
@@ -3752,6 +3836,11 @@ var BaseClient = /** @class */ (function () {
     // 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)
@@ -3781,6 +3870,12 @@ var BaseClient = /** @class */ (function () {
      * @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;
@@ -3816,14 +3911,19 @@ var BaseClient = /** @class */ (function () {
     BaseClient.prototype.getOptions = function () {
         return this._options;
     };
+    /**
+     * @inheritDoc
+     */
+    BaseClient.prototype.getTransport = function () {
+        return this._getBackend().getTransport();
+    };
     /**
      * @inheritDoc
      */
     BaseClient.prototype.flush = function (timeout) {
         var _this = this;
         return this._isClientDoneProcessing(timeout).then(function (clientFinished) {
-            return _this._getBackend()
-                .getTransport()
+            return _this.getTransport()
                 .close(timeout)
                 .then(function (transportFlushed) { return clientFinished && transportFlushed; });
         });
@@ -4096,8 +4196,10 @@ var BaseClient = /** @class */ (function () {
      */
     BaseClient.prototype._processEvent = function (event, hint, scope) {
         var _this = this;
+        var _a, _b;
         // eslint-disable-next-line @typescript-eslint/unbound-method
-        var _a = this.getOptions(), beforeSend = _a.beforeSend, sampleRate = _a.sampleRate;
+        var _c = this.getOptions(), beforeSend = _c.beforeSend, sampleRate = _c.sampleRate;
+        var transport = this.getTransport();
         if (!this._isEnabled()) {
             return SyncPromise.reject(new SentryError('SDK not enabled, will not capture event.'));
         }
@@ -4106,11 +4208,14 @@ var BaseClient = /** @class */ (function () {
         // 0.0 === 0% events are sent
         // Sampling for transaction happens somewhere else
         if (!isTransaction && typeof sampleRate === 'number' && Math.random() > sampleRate) {
+            (_b = (_a = transport).recordLostEvent) === null || _b === void 0 ? void 0 : _b.call(_a, Outcome.SampleRate, 'event');
             return SyncPromise.reject(new SentryError("Discarding event because it's not included in the random sample (sampling rate = " + sampleRate + ")"));
         }
         return this._prepareEvent(event, scope, hint)
             .then(function (prepared) {
+            var _a, _b;
             if (prepared === null) {
+                (_b = (_a = transport).recordLostEvent) === null || _b === void 0 ? void 0 : _b.call(_a, Outcome.EventProcessor, event.type || 'event');
                 throw new SentryError('An event processor returned null, will not send event.');
             }
             var isInternalException = hint && hint.data && hint.data.__sentry__ === true;
@@ -4121,7 +4226,9 @@ var BaseClient = /** @class */ (function () {
             return _this._ensureBeforeSendRv(beforeSendResult);
         })
             .then(function (processedEvent) {
+            var _a, _b;
             if (processedEvent === null) {
+                (_b = (_a = transport).recordLostEvent) === null || _b === void 0 ? void 0 : _b.call(_a, Outcome.BeforeSend, event.type || 'event');
                 throw new SentryError('`beforeSend` returned `null`, will not send event.');
             }
             var session = scope && scope.getSession && scope.getSession();
@@ -4361,7 +4468,7 @@ function initAndBind(clientClass, options) {
     hub.bindClient(client);
 }
 
-var SDK_VERSION = '6.11.0';
+var SDK_VERSION = '6.15.0';
 
 var originalFunctionToString;
 /** Patch toString calls to return proper name for wrapped functions */
@@ -4530,10 +4637,10 @@ var InboundFilters = /** @class */ (function () {
     /** JSDoc */
     InboundFilters.prototype._getLastValidUrl = function (frames) {
         if (frames === void 0) { frames = []; }
-        var _a;
+        var _a, _b;
         for (var i = frames.length - 1; i >= 0; i--) {
             var frame = frames[i];
-            if (((_a = frame) === null || _a === void 0 ? void 0 : _a.filename) !== '<anonymous>') {
+            if (((_a = frame) === null || _a === void 0 ? void 0 : _a.filename) !== '<anonymous>' && ((_b = frame) === null || _b === void 0 ? void 0 : _b.filename) !== '[native code]') {
                 return frame.filename || null;
             }
         }
@@ -4625,6 +4732,7 @@ function computeStackTrace(ex) {
 /** JSDoc */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any, complexity
 function computeStackTraceFromStackProp(ex) {
+    var _a, _b;
     if (!ex || !ex.stack) {
         return null;
     }
@@ -4650,12 +4758,7 @@ function computeStackTraceFromStackProp(ex) {
             // Kamil: One more hack won't hurt us right? Understanding and adding more rules on top of these regexps right now
             // would be way too time consuming. (TODO: Rewrite whole RegExp to be more readable)
             var func = parts[1] || UNKNOWN_FUNCTION;
-            var isSafariExtension = func.indexOf('safari-extension') !== -1;
-            var isSafariWebExtension = func.indexOf('safari-web-extension') !== -1;
-            if (isSafariExtension || isSafariWebExtension) {
-                func = func.indexOf('@') !== -1 ? func.split('@')[0] : UNKNOWN_FUNCTION;
-                url = isSafariExtension ? "safari-extension:" + url : "safari-web-extension:" + url;
-            }
+            _a = __read(extractSafariExtensionDetails(func, url), 2), func = _a[0], url = _a[1];
             element = {
                 url: url,
                 func: func,
@@ -4689,9 +4792,12 @@ function computeStackTraceFromStackProp(ex) {
                 // NOTE: this hack doesn't work if top-most frame is eval
                 stack[0].column = ex.columnNumber + 1;
             }
+            var url = parts[3];
+            var func = parts[1] || UNKNOWN_FUNCTION;
+            _b = __read(extractSafariExtensionDetails(func, url), 2), func = _b[0], url = _b[1];
             element = {
-                url: parts[3],
-                func: parts[1] || UNKNOWN_FUNCTION,
+                url: url,
+                func: func,
                 args: parts[2] ? parts[2].split(',') : [],
                 line: parts[4] ? +parts[4] : null,
                 column: parts[5] ? +parts[5] : null,
@@ -4765,6 +4871,36 @@ function computeStackTraceFromStacktraceProp(ex) {
         stack: stack,
     };
 }
+/**
+ * Safari web extensions, starting version unknown, can produce "frames-only" stacktraces.
+ * What it means, is that instead of format like:
+ *
+ * Error: wat
+ *   at function@url:row:col
+ *   at function@url:row:col
+ *   at function@url:row:col
+ *
+ * it produces something like:
+ *
+ *   function@url:row:col
+ *   function@url:row:col
+ *   function@url:row:col
+ *
+ * Because of that, it won't be captured by `chrome` RegExp and will fall into `Gecko` branch.
+ * This function is extracted so that we can use it in both places without duplicating the logic.
+ * Unfortunatelly "just" changing RegExp is too complicated now and making it pass all tests
+ * and fix this case seems like an impossible, or at least way too time-consuming task.
+ */
+var extractSafariExtensionDetails = function (func, url) {
+    var isSafariExtension = func.indexOf('safari-extension') !== -1;
+    var isSafariWebExtension = func.indexOf('safari-web-extension') !== -1;
+    return isSafariExtension || isSafariWebExtension
+        ? [
+            func.indexOf('@') !== -1 ? func.split('@')[0] : UNKNOWN_FUNCTION,
+            isSafariExtension ? "safari-extension:" + url : "safari-web-extension:" + url,
+        ]
+        : [func, url];
+};
 /** Remove N number of frames from the stack */
 function popFrames(stacktrace, popSize) {
     try {
@@ -4888,10 +5024,7 @@ function eventFromException(options, exception, hint) {
     var event = eventFromUnknownInput(exception, syntheticException, {
         attachStacktrace: options.attachStacktrace,
     });
-    addExceptionMechanism(event, {
-        handled: true,
-        type: 'generic',
-    });
+    addExceptionMechanism(event); // defaults to { type: 'generic', handled: true }
     event.level = Severity.Error;
     if (hint && hint.event_id) {
         event.event_id = hint.event_id;
@@ -4928,16 +5061,24 @@ function eventFromUnknownInput(exception, syntheticException, options) {
         event = eventFromStacktrace(computeStackTrace(exception));
         return event;
     }
+    // If it is a `DOMError` (which is a legacy API, but still supported in some browsers) then we just extract the name
+    // and message, as it doesn't provide anything else. According to the spec, all `DOMExceptions` should also be
+    // `Error`s, but that's not the case in IE11, so in that case we treat it the same as we do a `DOMError`.
+    //
+    // https://developer.mozilla.org/en-US/docs/Web/API/DOMError
+    // https://developer.mozilla.org/en-US/docs/Web/API/DOMException
+    // https://webidl.spec.whatwg.org/#es-DOMException-specialness
     if (isDOMError(exception) || isDOMException(exception)) {
-        // If it is a DOMError or DOMException (which are legacy APIs, but still supported in some browsers)
-        // then we just extract the name, code, and message, as they don't provide anything else
-        // https://developer.mozilla.org/en-US/docs/Web/API/DOMError
-        // https://developer.mozilla.org/en-US/docs/Web/API/DOMException
         var domException = exception;
-        var name_1 = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException');
-        var message = domException.message ? name_1 + ": " + domException.message : name_1;
-        event = eventFromString(message, syntheticException, options);
-        addExceptionTypeValue(event, message);
+        if ('stack' in exception) {
+            event = eventFromStacktrace(computeStackTrace(exception));
+        }
+        else {
+            var name_1 = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException');
+            var message = domException.message ? name_1 + ": " + domException.message : name_1;
+            event = eventFromString(message, syntheticException, options);
+            addExceptionTypeValue(event, message);
+        }
         if ('code' in domException) {
             event.tags = __assign(__assign({}, event.tags), { 'DOMException.code': "" + domException.code });
         }
@@ -4993,23 +5134,128 @@ function eventFromString(input, syntheticException, options) {
     return event;
 }
 
+var global$7 = 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$7.fetch)) {
+        return (cachedFetchImpl = global$7.fetch.bind(global$7));
+    }
+    var document = global$7.document;
+    var fetchImpl = global$7.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$7));
+    /* 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$7 && global$7.navigator) === '[object Navigator]';
+    var hasSendBeacon = isRealNavigator && typeof global$7.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$7.navigator.sendBeacon.bind(global$7.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$6 = getGlobalObject();
 /** Base Transport class implementation */
 var BaseTransport = /** @class */ (function () {
     function BaseTransport(options) {
+        var _this = this;
         this.options = options;
         /** A simple buffer holding all requests. */
         this._buffer = new PromiseBuffer(30);
         /** Locks transport after receiving rate limits in a response */
         this._rateLimits = {};
+        this._outcomes = {};
         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$6.document) {
+            global$6.document.addEventListener('visibilitychange', function () {
+                if (global$6.document.visibilityState === 'hidden') {
+                    _this._flushOutcomes();
+                }
+            });
+        }
     }
     /**
      * @inheritDoc
@@ -5023,6 +5269,63 @@ var BaseTransport = /** @class */ (function () {
     BaseTransport.prototype.close = function (timeout) {
         return this._buffer.drain(timeout);
     };
+    /**
+     * @inheritDoc
+     */
+    BaseTransport.prototype.recordLostEvent = function (reason, category) {
+        var _a;
+        if (!this.options.sendClientReports) {
+            return;
+        }
+        // We want to track each category (event, transaction, session) separately
+        // but still keep the distinction between different type of outcomes.
+        // We could use nested maps, but it's much easier to read and type this way.
+        // A correct type for map-based implementation if we want to go that route
+        // would be `Partial<Record<SentryRequestType, Partial<Record<Outcome, number>>>>`
+        var key = CATEGORY_MAPPING[category] + ":" + reason;
+        logger.log("Adding outcome: " + key);
+        this._outcomes[key] = (_a = this._outcomes[key], (_a !== null && _a !== void 0 ? _a : 0)) + 1;
+    };
+    /**
+     * Send outcomes as an envelope
+     */
+    BaseTransport.prototype._flushOutcomes = function () {
+        if (!this.options.sendClientReports) {
+            return;
+        }
+        var outcomes = this._outcomes;
+        this._outcomes = {};
+        // Nothing to send
+        if (!Object.keys(outcomes).length) {
+            logger.log('No outcomes to flush');
+            return;
+        }
+        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(__assign({}, (this.options.tunnel && { dsn: this._api.getDsn().toString() })));
+        var itemHeaders = JSON.stringify({
+            type: 'client_report',
+        });
+        var item = JSON.stringify({
+            timestamp: dateTimestampInSeconds(),
+            discarded_events: Object.keys(outcomes).map(function (key) {
+                var _a = __read(key.split(':'), 2), category = _a[0], reason = _a[1];
+                return {
+                    reason: reason,
+                    category: category,
+                    quantity: outcomes[key],
+                };
+            }),
+        });
+        var envelope = envelopeHeader + "\n" + itemHeaders + "\n" + item;
+        try {
+            sendReport(url, envelope);
+        }
+        catch (e) {
+            logger.error(e);
+        }
+    };
     /**
      * Handle Sentry repsonse for promise-based transports.
      */
@@ -5113,72 +5416,6 @@ var BaseTransport = /** @class */ (function () {
     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);
@@ -5207,6 +5444,7 @@ var FetchTransport = /** @class */ (function (_super) {
     FetchTransport.prototype._sendRequest = function (sentryRequest, originalPayload) {
         var _this = this;
         if (this._isRateLimited(sentryRequest.type)) {
+            this.recordLostEvent(Outcome.RateLimitBackoff, sentryRequest.type);
             return Promise.reject({
                 event: originalPayload,
                 type: sentryRequest.type,
@@ -5229,7 +5467,8 @@ var FetchTransport = /** @class */ (function (_super) {
         if (this.options.headers !== undefined) {
             options.headers = this.options.headers;
         }
-        return this._buffer.add(function () {
+        return this._buffer
+            .add(function () {
             return new SyncPromise(function (resolve, reject) {
                 void _this._fetch(sentryRequest.url, options)
                     .then(function (response) {
@@ -5247,6 +5486,16 @@ var FetchTransport = /** @class */ (function (_super) {
                 })
                     .catch(reject);
             });
+        })
+            .then(undefined, function (reason) {
+            // It's either buffer rejection or any other xhr/fetch error, which are treated as NetworkError.
+            if (reason instanceof SentryError) {
+                _this.recordLostEvent(Outcome.QueueOverflow, sentryRequest.type);
+            }
+            else {
+                _this.recordLostEvent(Outcome.NetworkError, sentryRequest.type);
+            }
+            throw reason;
         });
     };
     return FetchTransport;
@@ -5277,6 +5526,7 @@ var XHRTransport = /** @class */ (function (_super) {
     XHRTransport.prototype._sendRequest = function (sentryRequest, originalPayload) {
         var _this = this;
         if (this._isRateLimited(sentryRequest.type)) {
+            this.recordLostEvent(Outcome.RateLimitBackoff, sentryRequest.type);
             return Promise.reject({
                 event: originalPayload,
                 type: sentryRequest.type,
@@ -5284,7 +5534,8 @@ var XHRTransport = /** @class */ (function (_super) {
                 status: 429,
             });
         }
-        return this._buffer.add(function () {
+        return this._buffer
+            .add(function () {
             return new SyncPromise(function (resolve, reject) {
                 var request = new XMLHttpRequest();
                 request.onreadystatechange = function () {
@@ -5298,12 +5549,22 @@ var XHRTransport = /** @class */ (function (_super) {
                 };
                 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]);
                     }
                 }
                 request.send(sentryRequest.body);
             });
+        })
+            .then(undefined, function (reason) {
+            // It's either buffer rejection or any other xhr/fetch error, which are treated as NetworkError.
+            if (reason instanceof SentryError) {
+                _this.recordLostEvent(Outcome.QueueOverflow, sentryRequest.type);
+            }
+            else {
+                _this.recordLostEvent(Outcome.NetworkError, sentryRequest.type);
+            }
+            throw reason;
         });
     };
     return XHRTransport;
@@ -5339,7 +5600,7 @@ var BrowserBackend = /** @class */ (function (_super) {
             // We return the noop transport here in case there is no Dsn.
             return _super.prototype._setupTransport.call(this);
         }
-        var transportOptions = __assign(__assign({}, this._options.transportOptions), { dsn: this._options.dsn, tunnel: this._options.tunnel, _metadata: this._options._metadata });
+        var transportOptions = __assign(__assign({}, this._options.transportOptions), { dsn: this._options.dsn, tunnel: this._options.tunnel, sendClientReports: this._options.sendClientReports, _metadata: this._options._metadata });
         if (this._options.transport) {
             return new this._options.transport(transportOptions);
         }
@@ -5351,6 +5612,7 @@ var BrowserBackend = /** @class */ (function (_super) {
     return BrowserBackend;
 }(BaseBackend));
 
+var global$5 = getGlobalObject();
 var ignoreOnError = 0;
 /**
  * @hidden
@@ -5488,6 +5750,9 @@ function wrap$1(fn, options, before) {
  */
 function injectReportDialog(options) {
     if (options === void 0) { options = {}; }
+    if (!global$5.document) {
+        return;
+    }
     if (!options.eventId) {
         logger.error("Missing eventId option in showReportDialog call");
         return;
@@ -5496,14 +5761,17 @@ function injectReportDialog(options) {
         logger.error("Missing dsn option in showReportDialog call");
         return;
     }
-    var script = 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;
     }
-    (document.head || document.body).appendChild(script);
+    var injectionPoint = global$5.document.head || global$5.document.body;
+    if (injectionPoint) {
+        injectionPoint.appendChild(script);
+    }
 }
 
 /** Global handlers */
@@ -5808,7 +6076,7 @@ var TryCatch = /** @class */ (function () {
         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;
         }
@@ -6301,6 +6569,7 @@ var Dedupe = /** @class */ (function () {
                 // Juuust in case something goes wrong
                 try {
                     if (self._shouldDropEvent(currentEvent, self._previousEvent)) {
+                        logger.warn("Event dropped due to being a duplicate of previously captured event.");
                         return null;
                     }
                 }
@@ -6597,6 +6866,9 @@ function init(options) {
     if (options.autoSessionTracking === undefined) {
         options.autoSessionTracking = true;
     }
+    if (options.sendClientReports === undefined) {
+        options.sendClientReports = true;
+    }
     initAndBind(BrowserClient, options);
     if (options.autoSessionTracking) {
         startSessionTracking();
@@ -7127,6 +7399,7 @@ var Transaction = /** @class */ (function (_super) {
      */
     Transaction.prototype.finish = function (endTimestamp) {
         var _this = this;
+        var _a, _b, _c, _d, _e;
         // This transaction is already finished, so we should not flush it again.
         if (this.endTimestamp !== undefined) {
             return undefined;
@@ -7140,6 +7413,8 @@ var Transaction = /** @class */ (function (_super) {
         if (this.sampled !== true) {
             // At this point if `sampled !== true` we want to discard the transaction.
             logger.log('[Tracing] Discarding transaction because its trace was not chosen to be sampled.');
+            (_e = (_c = (_a = this._hub
+                .getClient()) === null || _a === void 0 ? void 0 : (_b = _a).getTransport) === null || _c === void 0 ? void 0 : (_d = _c.call(_b)).recordLostEvent) === null || _e === void 0 ? void 0 : _e.call(_d, Outcome.SampleRate, 'transaction');
             return undefined;
         }
         var finishedSpans = this.spanRecorder ? this.spanRecorder.spans.filter(function (s) { return s !== _this && s.endTimestamp; }) : [];
@@ -7192,6 +7467,7 @@ var Transaction = /** @class */ (function (_super) {
 }(Span));
 
 var DEFAULT_IDLE_TIMEOUT = 1000;
+var HEARTBEAT_INTERVAL = 5000;
 /**
  * @inheritDoc
  */
@@ -7235,7 +7511,10 @@ var IdleTransactionSpanRecorder = /** @class */ (function (_super) {
 var IdleTransaction = /** @class */ (function (_super) {
     __extends(IdleTransaction, _super);
     function IdleTransaction(transactionContext, _idleHub, 
-    // The time to wait in ms until the idle transaction will be finished. Default: 1000
+    /**
+     * The time to wait in ms until the idle transaction will be finished.
+     * @default 1000
+     */
     _idleTimeout, 
     // If an idle transaction should be put itself on and off the scope automatically.
     _onScope) {
@@ -7247,8 +7526,6 @@ var IdleTransaction = /** @class */ (function (_super) {
         _this._onScope = _onScope;
         // Activities store a list of active spans
         _this.activities = {};
-        // Stores reference to the timeout that calls _beat().
-        _this._heartbeatTimer = 0;
         // Amount of times heartbeat has counted. Will cause transaction to finish after 3 beats.
         _this._heartbeatCounter = 0;
         // We should not use heartbeat if we finished a transaction
@@ -7396,13 +7673,11 @@ var IdleTransaction = /** @class */ (function (_super) {
      * If this occurs we finish the transaction.
      */
     IdleTransaction.prototype._beat = function () {
-        clearTimeout(this._heartbeatTimer);
         // We should not be running heartbeat if the idle transaction is finished.
         if (this._finished) {
             return;
         }
-        var keys = Object.keys(this.activities);
-        var heartbeatString = keys.length ? keys.reduce(function (prev, current) { return prev + current; }) : '';
+        var heartbeatString = Object.keys(this.activities).join('');
         if (heartbeatString === this._prevHeartbeatString) {
             this._heartbeatCounter += 1;
         }
@@ -7426,9 +7701,9 @@ var IdleTransaction = /** @class */ (function (_super) {
     IdleTransaction.prototype._pingHeartbeat = function () {
         var _this = this;
         logger.log("pinging Heartbeat -> current counter: " + this._heartbeatCounter);
-        this._heartbeatTimer = setTimeout(function () {
+        setTimeout(function () {
             _this._beat();
-        }, 5000);
+        }, HEARTBEAT_INTERVAL);
     };
     return IdleTransaction;
 }(Transaction));
@@ -7474,7 +7749,7 @@ function traceHeaders() {
  */
 function sample(transaction, options, samplingContext) {
     // nothing to do if tracing is not enabled
-    if (!hasTracingEnabled()) {
+    if (!hasTracingEnabled(options)) {
         transaction.sampled = false;
         return transaction;
     }
@@ -7621,19 +7896,19 @@ function _autoloadDatabaseIntegrations() {
     }
     var packageToIntegrationMapping = {
         mongodb: function () {
-            var integration = dynamicRequire(module, './integrations/mongo');
+            var integration = dynamicRequire(module, './integrations/node/mongo');
             return new integration.Mongo();
         },
         mongoose: function () {
-            var integration = dynamicRequire(module, './integrations/mongo');
+            var integration = dynamicRequire(module, './integrations/node/mongo');
             return new integration.Mongo({ mongoose: true });
         },
         mysql: function () {
-            var integration = dynamicRequire(module, './integrations/mysql');
+            var integration = dynamicRequire(module, './integrations/node/mysql');
             return new integration.Mysql();
         },
         pg: function () {
-            var integration = dynamicRequire(module, './integrations/postgres');
+            var integration = dynamicRequire(module, './integrations/node/postgres');
             return new integration.Postgres();
         },
     };
@@ -7833,7 +8108,7 @@ var observe = function (type, callback) {
  */
 var onHidden = function (cb, once) {
     var onHiddenOrPageHide = function (event) {
-        if (event.type === 'pagehide' || document.visibilityState === 'hidden') {
+        if (event.type === 'pagehide' || getGlobalObject().document.visibilityState === 'hidden') {
             cb(event);
             if (once) {
                 removeEventListener('visibilitychange', onHiddenOrPageHide, true);
@@ -7925,7 +8200,7 @@ var getCLS = function (onReport, reportAllChanges) {
  */
 var firstHiddenTime = -1;
 var initHiddenTime = function () {
-    return document.visibilityState === 'hidden' ? 0 : Infinity;
+    return getGlobalObject().document.visibilityState === 'hidden' ? 0 : Infinity;
 };
 var trackChanges = function () {
     // Update the time if/when the document becomes hidden.
@@ -8043,18 +8318,21 @@ var getLCP = function (onReport, reportAllChanges) {
 };
 
 var global$2 = getGlobalObject();
+var DEFAULT_METRICS_INSTR_OPTIONS = {
+    _reportAllChanges: false,
+};
 /** Class tracking metrics  */
 var MetricsInstrumentation = /** @class */ (function () {
-    function MetricsInstrumentation() {
-        var _a;
+    function MetricsInstrumentation(_options) {
+        var _a, _b;
         this._measurements = {};
         this._performanceCursor = 0;
-        if (!isNodeEnv() && ((_a = global$2) === null || _a === void 0 ? void 0 : _a.performance)) {
+        if (!isNodeEnv() && ((_a = global$2) === null || _a === void 0 ? void 0 : _a.performance) && ((_b = global$2) === null || _b === void 0 ? void 0 : _b.document)) {
             if (global$2.performance.mark) {
                 global$2.performance.mark('sentry-tracing-init');
             }
             this._trackCLS();
-            this._trackLCP();
+            this._trackLCP(_options._reportAllChanges);
             this._trackFID();
         }
     }
@@ -8124,7 +8402,7 @@ var MetricsInstrumentation = /** @class */ (function () {
                     break;
                 }
                 case 'resource': {
-                    var resourceName = entry.name.replace(window.location.origin, '');
+                    var resourceName = entry.name.replace(global$2.location.origin, '');
                     var endTimestamp = addResourceSpans(transaction, entry, resourceName, startTime, duration, timeOrigin);
                     // We remember the entry script end time to calculate the difference to the first init mark
                     if (entryScriptStartTimestamp === undefined && (entryScriptSrc || '').indexOf(resourceName) > -1) {
@@ -8266,7 +8544,7 @@ var MetricsInstrumentation = /** @class */ (function () {
         }
     };
     /** Starts tracking the Largest Contentful Paint on the current page. */
-    MetricsInstrumentation.prototype._trackLCP = function () {
+    MetricsInstrumentation.prototype._trackLCP = function (reportAllChanges) {
         var _this = this;
         getLCP(function (metric) {
             var entry = metric.entries.pop();
@@ -8279,7 +8557,7 @@ var MetricsInstrumentation = /** @class */ (function () {
             _this._measurements['lcp'] = { value: metric.value };
             _this._measurements['mark.lcp'] = { value: timeOrigin + startTime };
             _this._lcpEntry = entry;
-        });
+        }, reportAllChanges);
     };
     /** Starts tracking the First Input Delay on the current page. */
     MetricsInstrumentation.prototype._trackFID = function () {
@@ -8626,7 +8904,6 @@ var BrowserTracing = /** @class */ (function () {
          * @inheritDoc
          */
         this.name = BrowserTracing.id;
-        this._metrics = new MetricsInstrumentation();
         this._emitOptionsWarning = false;
         var tracingOrigins = defaultRequestInstrumentationOptions.tracingOrigins;
         // NOTE: Logger doesn't work in constructors, as it's initialized after integrations instances
@@ -8640,6 +8917,7 @@ var BrowserTracing = /** @class */ (function () {
             this._emitOptionsWarning = true;
         }
         this.options = __assign(__assign(__assign({}, DEFAULT_BROWSER_TRACING_OPTIONS), _options), { tracingOrigins: tracingOrigins });
+        this._metrics = new MetricsInstrumentation(__assign(__assign({}, DEFAULT_METRICS_INSTR_OPTIONS), this.options._metricOptions));
     }
     /**
      * @inheritDoc
@@ -8707,7 +8985,7 @@ function getHeaderContext() {
 }
 /** Returns the value of a meta tag */
 function getMetaContent(metaName) {
-    var el = document.querySelector("meta[name=" + metaName + "]");
+    var el = getGlobalObject().document.querySelector("meta[name=" + metaName + "]");
     return el ? el.getAttribute('content') : null;
 }
 /** Adjusts transaction value based on max transaction duration */
@@ -8880,21 +9158,29 @@ function instrumentMiddlewares(router, methods) {
 
 /** Tracing integration for node-postgres package */
 var Postgres = /** @class */ (function () {
-    function Postgres() {
+    function Postgres(options) {
+        if (options === void 0) { options = {}; }
         /**
          * @inheritDoc
          */
         this.name = Postgres.id;
+        this._usePgNative = !!options.usePgNative;
     }
     /**
      * @inheritDoc
      */
     Postgres.prototype.setupOnce = function (_, getCurrentHub) {
+        var _a;
         var pkg = loadModule('pg');
         if (!pkg) {
             logger.error('Postgres Integration was unable to require `pg` package.');
             return;
         }
+        if (this._usePgNative && !((_a = pkg.native) === null || _a === void 0 ? void 0 : _a.Client)) {
+            logger.error("Postgres Integration was unable to access 'pg-native' bindings.");
+            return;
+        }
+        var Client = (this._usePgNative ? pkg.native : pkg).Client;
         /**
          * function (query, callback) => void
          * function (query, params, callback) => void
@@ -8902,7 +9188,7 @@ var Postgres = /** @class */ (function () {
          * function (query, params) => Promise
          * function (pg.Cursor) => pg.Cursor
          */
-        fill(pkg.Client.prototype, 'query', function (orig) {
+        fill(Client.prototype, 'query', function (orig) {
             return function (config, values, callback) {
                 var _a, _b, _c;
                 var scope = getCurrentHub().getScope();
@@ -9206,6 +9492,7 @@ const setupSentry = () => {
   init({
     dsn: "https://70bcf561598b44148bd3cabc7c142a6c@o1015876.ingest.sentry.io/5983034",
     integrations: [new Integrations.BrowserTracing()],
+    release: `${index.Env.packageName}@${index.Env.packageVersion}`,
     tracesSampleRate: 1.0,
     maxBreadcrumbs: 4,
     allowUrls: [/https?:\/\/.+vviinn-widgets.+.js/],