@sentry/browser 6.13.0 → 6.14.0

package/build/bundle.es6.js

@@ -1,4 +1,4 @@
-/*! @sentry/browser 6.13.0 (a241a0c) | https://github.com/getsentry/sentry-javascript */
+/*! @sentry/browser 6.14.0 (574741b) | https://github.com/getsentry/sentry-javascript */
 var Sentry = (function (exports) {
   /** Console logging verbosity for the SDK. */
   var LogLevel;
@@ -144,6 +144,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, 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.
+   */
+  const 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 */
   /**
@@ -379,6 +435,18 @@ var Sentry = (function (exports) {
           }
       }
       return out.join('');
+  }
+  /**
+   * A safe form of location.href
+   */
+  function getLocationHref() {
+      const global = getGlobalObject();
+      try {
+          return global.document.location.href;
+      }
+      catch (oO) {
+          return '';
+      }
   }
 
   const setPrototypeOf = Object.setPrototypeOf || ({ __proto__: [] } instanceof Array ? setProtoOf : mixinProperties);
@@ -502,174 +570,17 @@ var Sentry = (function (exports) {
       }
   }
 
+  // TODO: Implement different loggers for different environments
+  const global$1 = getGlobalObject();
+  /** Prefix for logging strings */
+  const 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 = 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 '';
-      }
-      const output = [];
-      // eslint-disable-next-line @typescript-eslint/prefer-for-of
-      for (let i = 0; i < input.length; i++) {
-          const 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;
-  }
-
-  const fallbackGlobalObject = {};
-  /**
-   * Safely get global scope object
+   * Temporarily unwrap `console.log` and friends in order to perform the given callback using the original methods.
+   * Restores wrapping after the callback completes.
    *
-   * @returns Global scope object
+   * @param callback The function to run against the original `console` messages
+   * @returns The results of the callback
    */
-  function getGlobalObject() {
-      return (isNodeEnv()
-          ? global
-          : typeof window !== 'undefined'
-              ? window
-              : typeof self !== 'undefined'
-                  ? self
-                  : fallbackGlobalObject);
-  }
-  /**
-   * UUID4 generator
-   *
-   * @returns string Generated UUID4.
-   */
-  function uuid4() {
-      const global = getGlobalObject();
-      const crypto = global.crypto || global.msCrypto;
-      if (!(crypto === void 0) && crypto.getRandomValues) {
-          // Use window.crypto API if available
-          const 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;
-          const pad = (num) => {
-              let 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, c => {
-          // eslint-disable-next-line no-bitwise
-          const r = (Math.random() * 16) | 0;
-          // eslint-disable-next-line no-bitwise
-          const 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 {};
-      }
-      const match = url.match(/^(([^:/?#]+):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?$/);
-      if (!match) {
-          return {};
-      }
-      // coerce to undefined values to empty string so we don't get 'undefined'
-      const query = match[6] || '';
-      const 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]) {
-          const 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) {
       const global = getGlobalObject();
       const levels = ['debug', 'info', 'warn', 'error', 'log', 'assert'];
@@ -695,79 +606,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 = {}) {
-      // 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(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 '';
-      }
-  }
-  const 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;
-      }
-      const headerDelay = parseInt(`${header}`, 10);
-      if (!isNaN(headerDelay)) {
-          return headerDelay * 1000;
-      }
-      const 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
-  const global$1 = getGlobalObject();
-  /** Prefix for logging strings */
-  const PREFIX = 'Sentry Logger ';
   /** JSDoc */
   class Logger {
       /** JSDoc */
@@ -884,6 +722,61 @@ 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 = 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 '';
+      }
+      const output = [];
+      // eslint-disable-next-line @typescript-eslint/prefer-for-of
+      for (let i = 0; i < input.length; i++) {
+          const 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.
    *
@@ -1051,9 +944,13 @@ var Sentry = (function (exports) {
       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]';
       }
@@ -1783,18 +1680,191 @@ var Sentry = (function (exports) {
           return false;
       };
   }
-  let _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);
+  let _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() {
+      const global = getGlobalObject();
+      const crypto = global.crypto || global.msCrypto;
+      if (!(crypto === void 0) && crypto.getRandomValues) {
+          // Use window.crypto API if available
+          const 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;
+          const pad = (num) => {
+              let 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, c => {
+          // eslint-disable-next-line no-bitwise
+          const r = (Math.random() * 16) | 0;
+          // eslint-disable-next-line no-bitwise
+          const 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 {};
+      }
+      const match = url.match(/^(([^:/?#]+):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?$/);
+      if (!match) {
+          return {};
+      }
+      // coerce to undefined values to empty string so we don't get 'undefined'
+      const query = match[6] || '';
+      const 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]) {
+          const 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;
+      }
+      const exceptionValue0 = event.exception.values[0];
+      const defaultMechanism = { type: 'generic', handled: true };
+      const currentMechanism = exceptionValue0.mechanism;
+      exceptionValue0.mechanism = Object.assign(Object.assign(Object.assign({}, defaultMechanism), currentMechanism), newMechanism);
+      if (newMechanism && 'data' in newMechanism) {
+          const mergedData = Object.assign(Object.assign({}, (_a = currentMechanism) === null || _a === void 0 ? void 0 : _a.data), newMechanism.data);
+          exceptionValue0.mechanism.data = mergedData;
+      }
+  }
+  const 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;
+      }
+      const headerDelay = parseInt(`${header}`, 10);
+      if (!isNaN(headerDelay)) {
+          return headerDelay * 1000;
+      }
+      const 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 */
@@ -3602,6 +3672,7 @@ var Sentry = (function (exports) {
   }
 
   /* eslint-disable max-lines */
+  const ALREADY_SEEN_ERROR = "Not capturing exception because it's already been captured.";
   /**
    * Base implementation for all JavaScript SDK clients.
    *
@@ -3657,6 +3728,11 @@ var Sentry = (function (exports) {
        */
       // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
       captureException(exception, hint, scope) {
+          // ensure we haven't captured this very object before
+          if (checkOrSetAlreadyCaught(exception)) {
+              logger.log(ALREADY_SEEN_ERROR);
+              return;
+          }
           let eventId = hint && hint.event_id;
           this._process(this._getBackend()
               .eventFromException(exception, hint)
@@ -3685,6 +3761,12 @@ var Sentry = (function (exports) {
        * @inheritDoc
        */
       captureEvent(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;
+          }
           let eventId = hint && hint.event_id;
           this._process(this._captureEvent(event, hint, scope).then(result => {
               eventId = result;
@@ -4280,7 +4362,7 @@ var Sentry = (function (exports) {
       hub.bindClient(client);
   }
 
-  const SDK_VERSION = '6.13.0';
+  const SDK_VERSION = '6.14.0';
 
   let originalFunctionToString;
   /** Patch toString calls to return proper name for wrapped functions */
@@ -4851,10 +4933,7 @@ var Sentry = (function (exports) {
       const 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;
@@ -4953,12 +5032,108 @@ var Sentry = (function (exports) {
       return event;
   }
 
+  const global$3 = getGlobalObject();
+  let 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));
+      }
+      const document = global$3.document;
+      let fetchImpl = global$3.fetch;
+      // eslint-disable-next-line deprecation/deprecation
+      if (typeof ((_a = document) === null || _a === void 0 ? void 0 : _a.createElement) === `function`) {
+          try {
+              const 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) {
+      const isRealNavigator = Object.prototype.toString.call(global$3 && global$3.navigator) === '[object Navigator]';
+      const 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
+          const sendBeacon = global$3.navigator.sendBeacon.bind(global$3.navigator);
+          return sendBeacon(url, body);
+      }
+      if (supportsFetch()) {
+          const fetch = getNativeFetchImplementation();
+          return forget(fetch(url, {
+              body,
+              method: 'POST',
+              credentials: 'omit',
+              keepalive: true,
+          }));
+      }
+  }
+
   const CATEGORY_MAPPING = {
       event: 'error',
       transaction: 'transaction',
       session: 'session',
       attachment: 'attachment',
   };
+  const global$4 = getGlobalObject();
   /** Base Transport class implementation */
   class BaseTransport {
       constructor(options) {
@@ -4971,9 +5146,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) {
-              document.addEventListener('visibilitychange', () => {
-                  if (document.visibilityState === 'hidden') {
+          if (this.options.sendClientReports && global$4.document) {
+              global$4.document.addEventListener('visibilitychange', () => {
+                  if (global$4.document.visibilityState === 'hidden') {
                       this._flushOutcomes();
                   }
               });
@@ -5015,10 +5190,6 @@ var Sentry = (function (exports) {
           if (!this.options.sendClientReports) {
               return;
           }
-          if (!navigator || typeof navigator.sendBeacon !== 'function') {
-              logger.warn('Beacon API not available, skipping sending outcomes.');
-              return;
-          }
           const outcomes = this._outcomes;
           this._outcomes = {};
           // Nothing to send
@@ -5029,7 +5200,7 @@ var Sentry = (function (exports) {
           logger.log(`Flushing outcomes:\n${JSON.stringify(outcomes, null, 2)}`);
           const url = this._api.getEnvelopeEndpointWithUrlEncodedAuth();
           // Envelope header is required to be at least an empty object
-          const envelopeHeader = JSON.stringify({});
+          const envelopeHeader = JSON.stringify(Object.assign({}, (this.options.tunnel && { dsn: this._api.getDsn().toString() })));
           const itemHeaders = JSON.stringify({
               type: 'client_report',
           });
@@ -5045,7 +5216,12 @@ var Sentry = (function (exports) {
               }),
           });
           const envelope = `${envelopeHeader}\n${itemHeaders}\n${item}`;
-          navigator.sendBeacon(url, envelope);
+          try {
+              sendReport(url, envelope);
+          }
+          catch (e) {
+              logger.error(e);
+          }
       }
       /**
        * Handle Sentry repsonse for promise-based transports.
@@ -5114,72 +5290,6 @@ var Sentry = (function (exports) {
       }
   }
 
-  /**
-   * 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
-      const global = getGlobalObject();
-      if (isNativeFetch(global.fetch)) {
-          return global.fetch.bind(global);
-      }
-      const document = global.document;
-      let fetchImpl = global.fetch;
-      // eslint-disable-next-line deprecation/deprecation
-      if (typeof ((_a = document) === null || _a === void 0 ? void 0 : _a.createElement) === `function`) {
-          try {
-              const 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 */
   class FetchTransport extends BaseTransport {
       constructor(options, fetchImpl = getNativeFetchImplementation()) {
@@ -5364,6 +5474,7 @@ var Sentry = (function (exports) {
       }
   }
 
+  const global$5 = getGlobalObject();
   let ignoreOnError = 0;
   /**
    * @hidden
@@ -5499,6 +5610,9 @@ var Sentry = (function (exports) {
    * @hidden
    */
   function injectReportDialog(options = {}) {
+      if (!global$5.document) {
+          return;
+      }
       if (!options.eventId) {
           logger.error(`Missing eventId option in showReportDialog call`);
           return;
@@ -5507,14 +5621,14 @@ var Sentry = (function (exports) {
           logger.error(`Missing dsn option in showReportDialog call`);
           return;
       }
-      const script = document.createElement('script');
+      const 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;
       }
-      const injectionPoint = document.head || document.body;
+      const injectionPoint = global$5.document.head || global$5.document.body;
       if (injectionPoint) {
           injectionPoint.appendChild(script);
       }
@@ -6224,7 +6338,7 @@ var Sentry = (function (exports) {
    */
   LinkedErrors.id = 'LinkedErrors';
 
-  const global$3 = getGlobalObject();
+  const global$6 = getGlobalObject();
   /** UserAgent */
   class UserAgent {
       constructor() {
@@ -6241,13 +6355,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$3.navigator && !global$3.location && !global$3.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
-                  const url = ((_a = event.request) === null || _a === void 0 ? void 0 : _a.url) || ((_b = global$3.location) === null || _b === void 0 ? void 0 : _b.href);
-                  const { referrer } = global$3.document || {};
-                  const { userAgent } = global$3.navigator || {};
+                  const url = ((_a = event.request) === null || _a === void 0 ? void 0 : _a.url) || ((_b = global$6.location) === null || _b === void 0 ? void 0 : _b.href);
+                  const { referrer } = global$6.document || {};
+                  const { userAgent } = global$6.navigator || {};
                   const headers = Object.assign(Object.assign(Object.assign({}, (_c = event.request) === null || _c === void 0 ? void 0 : _c.headers), (referrer && { Referer: referrer })), (userAgent && { 'User-Agent': userAgent }));
                   const request = Object.assign(Object.assign({}, (url && { url })), { headers });
                   return Object.assign(Object.assign({}, event), { request });