@sentry/browser 5.25.0-beta.2 → 5.25.0

package/build/bundle.es6.js

@@ -1,4 +1,4 @@
-/*! @sentry/browser 5.25.0-beta.2 (84e835c) | https://github.com/getsentry/sentry-javascript */
+/*! @sentry/browser 5.25.0 (bca2c59) | https://github.com/getsentry/sentry-javascript */
 var Sentry = (function (exports) {
   /** Console logging verbosity for the SDK. */
   var LogLevel;
@@ -13,21 +13,6 @@ var Sentry = (function (exports) {
       LogLevel[LogLevel["Verbose"] = 3] = "Verbose";
   })(LogLevel || (LogLevel = {}));
 
-  /**
-   * Session Status
-   */
-  var SessionStatus;
-  (function (SessionStatus) {
-      /** JSDoc */
-      SessionStatus["Ok"] = "ok";
-      /** JSDoc */
-      SessionStatus["Exited"] = "exited";
-      /** JSDoc */
-      SessionStatus["Crashed"] = "crashed";
-      /** JSDoc */
-      SessionStatus["Abnormal"] = "abnormal";
-  })(SessionStatus || (SessionStatus = {}));
-
   /** JSDoc */
   (function (Severity) {
       /** JSDoc */
@@ -853,26 +838,6 @@ var Sentry = (function (exports) {
           return truncate(serialized, maxLength);
       }
       return '';
-  }
-  /**
-   * Given any object, return the new object with removed keys that value was `undefined`.
-   * Works recursively on objects and arrays.
-   */
-  function dropUndefinedKeys(val) {
-      if (isPlainObject(val)) {
-          const obj = val;
-          const rv = {};
-          for (const key of Object.keys(obj)) {
-              if (typeof obj[key] !== 'undefined') {
-                  rv[key] = dropUndefinedKeys(obj[key]);
-              }
-          }
-          return rv;
-      }
-      if (Array.isArray(val)) {
-          return val.map(dropUndefinedKeys);
-      }
-      return val;
   }
 
   /**
@@ -909,13 +874,6 @@ var Sentry = (function (exports) {
                   ? self
                   : fallbackGlobalObject);
   }
-  /**
-   * Determines if running in react native
-   */
-  function isReactNative() {
-      var _a;
-      return ((_a = getGlobalObject().navigator) === null || _a === void 0 ? void 0 : _a.product) === 'ReactNative';
-  }
   /**
    * UUID4 generator
    *
@@ -1067,73 +1025,6 @@ var Sentry = (function (exports) {
           return '';
       }
   }
-  const INITIAL_TIME = Date.now();
-  let prevNow = 0;
-  const performanceFallback = {
-      now() {
-          let now = Date.now() - INITIAL_TIME;
-          if (now < prevNow) {
-              now = prevNow;
-          }
-          prevNow = now;
-          return now;
-      },
-      timeOrigin: INITIAL_TIME,
-  };
-  /**
-   * Performance wrapper for react native as performance.now() has been found to start off with an unusual offset.
-   */
-  function getReactNativePerformanceWrapper() {
-      // Performance only available >= RN 0.63
-      const { performance } = getGlobalObject();
-      if (performance && typeof performance.now === 'function') {
-          const INITIAL_OFFSET = performance.now();
-          return {
-              now() {
-                  return performance.now() - INITIAL_OFFSET;
-              },
-              timeOrigin: INITIAL_TIME,
-          };
-      }
-      return performanceFallback;
-  }
-  const crossPlatformPerformance = (() => {
-      // React Native's performance.now() starts with a gigantic offset, so we need to wrap it.
-      if (isReactNative()) {
-          return getReactNativePerformanceWrapper();
-      }
-      if (isNodeEnv()) {
-          try {
-              const perfHooks = dynamicRequire(module, 'perf_hooks');
-              return perfHooks.performance;
-          }
-          catch (_) {
-              return performanceFallback;
-          }
-      }
-      const { performance } = getGlobalObject();
-      if (!performance || !performance.now) {
-          return performanceFallback;
-      }
-      // Polyfill for performance.timeOrigin.
-      //
-      // While performance.timing.navigationStart is deprecated in favor of performance.timeOrigin, performance.timeOrigin
-      // is not as widely supported. Namely, performance.timeOrigin is undefined in Safari as of writing.
-      if (performance.timeOrigin === undefined) {
-          // As of writing, performance.timing is not available in Web Workers in mainstream browsers, so it is not always a
-          // valid fallback. In the absence of a initial time provided by the browser, fallback to INITIAL_TIME.
-          // @ts-ignore ignored because timeOrigin is a readonly property but we want to override
-          // eslint-disable-next-line deprecation/deprecation
-          performance.timeOrigin = (performance.timing && performance.timing.navigationStart) || INITIAL_TIME;
-      }
-      return performance;
-  })();
-  /**
-   * Returns a timestamp in seconds with milliseconds precision since the UNIX epoch calculated with the monotonic clock.
-   */
-  function timestampWithMs() {
-      return (crossPlatformPerformance.timeOrigin + crossPlatformPerformance.now()) / 1000;
-  }
   const defaultRetryAfter = 60 * 1000; // 60 seconds
   /**
    * Extracts Retry-After value from the request header or returns default value
@@ -1206,359 +1097,93 @@ var Sentry = (function (exports) {
   global$1.__SENTRY__ = global$1.__SENTRY__ || {};
   const logger = global$1.__SENTRY__.logger || (global$1.__SENTRY__.logger = new Logger());
 
-  /* eslint-disable @typescript-eslint/explicit-function-return-type */
-  /** SyncPromise internal states */
-  var States;
-  (function (States) {
-      /** Pending */
-      States["PENDING"] = "PENDING";
-      /** Resolved / OK */
-      States["RESOLVED"] = "RESOLVED";
-      /** Rejected / Error */
-      States["REJECTED"] = "REJECTED";
-  })(States || (States = {}));
   /**
-   * Thenable class that behaves like a Promise and follows it's interface
-   * but is not async internally
+   * Tells whether current environment supports Fetch API
+   * {@link supportsFetch}.
+   *
+   * @returns Answer to the given question.
    */
-  class SyncPromise {
-      constructor(executor) {
-          this._state = States.PENDING;
-          this._handlers = [];
-          /** JSDoc */
-          this._resolve = (value) => {
-              this._setResult(States.RESOLVED, value);
-          };
-          /** JSDoc */
-          this._reject = (reason) => {
-              this._setResult(States.REJECTED, reason);
-          };
-          /** JSDoc */
-          this._setResult = (state, value) => {
-              if (this._state !== States.PENDING) {
-                  return;
-              }
-              if (isThenable(value)) {
-                  value.then(this._resolve, this._reject);
-                  return;
-              }
-              this._state = state;
-              this._value = value;
-              this._executeHandlers();
-          };
-          // TODO: FIXME
-          /** JSDoc */
-          this._attachHandler = (handler) => {
-              this._handlers = this._handlers.concat(handler);
-              this._executeHandlers();
-          };
-          /** JSDoc */
-          this._executeHandlers = () => {
-              if (this._state === States.PENDING) {
-                  return;
-              }
-              const cachedHandlers = this._handlers.slice();
-              this._handlers = [];
-              cachedHandlers.forEach(handler => {
-                  if (handler.done) {
-                      return;
-                  }
-                  if (this._state === States.RESOLVED) {
-                      if (handler.onfulfilled) {
-                          // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                          handler.onfulfilled(this._value);
-                      }
-                  }
-                  if (this._state === States.REJECTED) {
-                      if (handler.onrejected) {
-                          handler.onrejected(this._value);
-                      }
-                  }
-                  handler.done = true;
-              });
-          };
+  function supportsFetch() {
+      if (!('fetch' in getGlobalObject())) {
+          return false;
+      }
+      try {
+          new Headers();
+          new Request('');
+          new Response();
+          return true;
+      }
+      catch (e) {
+          return false;
+      }
+  }
+  /**
+   * isNativeFetch checks if the given function is a native implementation of fetch()
+   */
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  function isNativeFetch(func) {
+      return func && /^function fetch\(\)\s+\{\s+\[native code\]\s+\}$/.test(func.toString());
+  }
+  /**
+   * Tells whether current environment supports Fetch API natively
+   * {@link supportsNativeFetch}.
+   *
+   * @returns true if `window.fetch` is natively implemented, false otherwise
+   */
+  function supportsNativeFetch() {
+      if (!supportsFetch()) {
+          return false;
+      }
+      const global = getGlobalObject();
+      // Fast path to avoid DOM I/O
+      // eslint-disable-next-line @typescript-eslint/unbound-method
+      if (isNativeFetch(global.fetch)) {
+          return true;
+      }
+      // window.fetch is implemented, but is polyfilled or already wrapped (e.g: by a chrome extension)
+      // so create a "pure" iframe to see if that has native fetch
+      let result = false;
+      const doc = global.document;
+      // eslint-disable-next-line deprecation/deprecation
+      if (doc && typeof doc.createElement === `function`) {
           try {
-              executor(this._resolve, this._reject);
+              const sandbox = doc.createElement('iframe');
+              sandbox.hidden = true;
+              doc.head.appendChild(sandbox);
+              if (sandbox.contentWindow && sandbox.contentWindow.fetch) {
+                  // eslint-disable-next-line @typescript-eslint/unbound-method
+                  result = isNativeFetch(sandbox.contentWindow.fetch);
+              }
+              doc.head.removeChild(sandbox);
           }
-          catch (e) {
-              this._reject(e);
+          catch (err) {
+              logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);
           }
       }
-      /** JSDoc */
-      static resolve(value) {
-          return new SyncPromise(resolve => {
-              resolve(value);
-          });
+      return result;
+  }
+  /**
+   * Tells whether current environment supports Referrer Policy API
+   * {@link supportsReferrerPolicy}.
+   *
+   * @returns Answer to the given question.
+   */
+  function supportsReferrerPolicy() {
+      // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default
+      // https://caniuse.com/#feat=referrer-policy
+      // It doesn't. And it throw exception instead of ignoring this parameter...
+      // REF: https://github.com/getsentry/raven-js/issues/1233
+      if (!supportsFetch()) {
+          return false;
       }
-      /** JSDoc */
-      static reject(reason) {
-          return new SyncPromise((_, reject) => {
-              reject(reason);
+      try {
+          new Request('_', {
+              referrerPolicy: 'origin',
           });
+          return true;
       }
-      /** JSDoc */
-      static all(collection) {
-          return new SyncPromise((resolve, reject) => {
-              if (!Array.isArray(collection)) {
-                  reject(new TypeError(`Promise.all requires an array as input.`));
-                  return;
-              }
-              if (collection.length === 0) {
-                  resolve([]);
-                  return;
-              }
-              let counter = collection.length;
-              const resolvedCollection = [];
-              collection.forEach((item, index) => {
-                  SyncPromise.resolve(item)
-                      .then(value => {
-                      resolvedCollection[index] = value;
-                      counter -= 1;
-                      if (counter !== 0) {
-                          return;
-                      }
-                      resolve(resolvedCollection);
-                  })
-                      .then(null, reject);
-              });
-          });
-      }
-      /** JSDoc */
-      then(onfulfilled, onrejected) {
-          return new SyncPromise((resolve, reject) => {
-              this._attachHandler({
-                  done: false,
-                  onfulfilled: result => {
-                      if (!onfulfilled) {
-                          // TODO: ¯\_(ツ)_/¯
-                          // TODO: FIXME
-                          resolve(result);
-                          return;
-                      }
-                      try {
-                          resolve(onfulfilled(result));
-                          return;
-                      }
-                      catch (e) {
-                          reject(e);
-                          return;
-                      }
-                  },
-                  onrejected: reason => {
-                      if (!onrejected) {
-                          reject(reason);
-                          return;
-                      }
-                      try {
-                          resolve(onrejected(reason));
-                          return;
-                      }
-                      catch (e) {
-                          reject(e);
-                          return;
-                      }
-                  },
-              });
-          });
-      }
-      /** JSDoc */
-      catch(onrejected) {
-          return this.then(val => val, onrejected);
-      }
-      /** JSDoc */
-      finally(onfinally) {
-          return new SyncPromise((resolve, reject) => {
-              let val;
-              let isRejected;
-              return this.then(value => {
-                  isRejected = false;
-                  val = value;
-                  if (onfinally) {
-                      onfinally();
-                  }
-              }, reason => {
-                  isRejected = true;
-                  val = reason;
-                  if (onfinally) {
-                      onfinally();
-                  }
-              }).then(() => {
-                  if (isRejected) {
-                      reject(val);
-                      return;
-                  }
-                  resolve(val);
-              });
-          });
-      }
-      /** JSDoc */
-      toString() {
-          return '[object SyncPromise]';
-      }
-  }
-
-  /** A simple queue that holds promises. */
-  class PromiseBuffer {
-      constructor(_limit) {
-          this._limit = _limit;
-          /** Internal set of queued Promises */
-          this._buffer = [];
-      }
-      /**
-       * Says if the buffer is ready to take more requests
-       */
-      isReady() {
-          return this._limit === undefined || this.length() < this._limit;
-      }
-      /**
-       * Add a promise to the queue.
-       *
-       * @param task Can be any PromiseLike<T>
-       * @returns The original promise.
-       */
-      add(task) {
-          if (!this.isReady()) {
-              return SyncPromise.reject(new SentryError('Not adding Promise due to buffer limit reached.'));
-          }
-          if (this._buffer.indexOf(task) === -1) {
-              this._buffer.push(task);
-          }
-          task
-              .then(() => this.remove(task))
-              .then(null, () => this.remove(task).then(null, () => {
-              // We have to add this catch here otherwise we have an unhandledPromiseRejection
-              // because it's a new Promise chain.
-          }));
-          return task;
-      }
-      /**
-       * Remove a promise to the queue.
-       *
-       * @param task Can be any PromiseLike<T>
-       * @returns Removed promise.
-       */
-      remove(task) {
-          const removedTask = this._buffer.splice(this._buffer.indexOf(task), 1)[0];
-          return removedTask;
-      }
-      /**
-       * This function returns the number of unresolved promises in the queue.
-       */
-      length() {
-          return this._buffer.length;
-      }
-      /**
-       * This will drain the whole queue, returns true if queue is empty or drained.
-       * If timeout is provided and the queue takes longer to drain, the promise still resolves but with false.
-       *
-       * @param timeout Number in ms to wait until it resolves with false.
-       */
-      drain(timeout) {
-          return new SyncPromise(resolve => {
-              const capturedSetTimeout = setTimeout(() => {
-                  if (timeout && timeout > 0) {
-                      resolve(false);
-                  }
-              }, timeout);
-              SyncPromise.all(this._buffer)
-                  .then(() => {
-                  clearTimeout(capturedSetTimeout);
-                  resolve(true);
-              })
-                  .then(null, () => {
-                  resolve(true);
-              });
-          });
-      }
-  }
-
-  /**
-   * Tells whether current environment supports Fetch API
-   * {@link supportsFetch}.
-   *
-   * @returns Answer to the given question.
-   */
-  function supportsFetch() {
-      if (!('fetch' in getGlobalObject())) {
-          return false;
-      }
-      try {
-          new Headers();
-          new Request('');
-          new Response();
-          return true;
-      }
-      catch (e) {
-          return false;
-      }
-  }
-  /**
-   * isNativeFetch checks if the given function is a native implementation of fetch()
-   */
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  function isNativeFetch(func) {
-      return func && /^function fetch\(\)\s+\{\s+\[native code\]\s+\}$/.test(func.toString());
-  }
-  /**
-   * Tells whether current environment supports Fetch API natively
-   * {@link supportsNativeFetch}.
-   *
-   * @returns true if `window.fetch` is natively implemented, false otherwise
-   */
-  function supportsNativeFetch() {
-      if (!supportsFetch()) {
-          return false;
-      }
-      const global = getGlobalObject();
-      // Fast path to avoid DOM I/O
-      // eslint-disable-next-line @typescript-eslint/unbound-method
-      if (isNativeFetch(global.fetch)) {
-          return true;
-      }
-      // window.fetch is implemented, but is polyfilled or already wrapped (e.g: by a chrome extension)
-      // so create a "pure" iframe to see if that has native fetch
-      let result = false;
-      const doc = global.document;
-      // eslint-disable-next-line deprecation/deprecation
-      if (doc && typeof doc.createElement === `function`) {
-          try {
-              const sandbox = doc.createElement('iframe');
-              sandbox.hidden = true;
-              doc.head.appendChild(sandbox);
-              if (sandbox.contentWindow && sandbox.contentWindow.fetch) {
-                  // eslint-disable-next-line @typescript-eslint/unbound-method
-                  result = isNativeFetch(sandbox.contentWindow.fetch);
-              }
-              doc.head.removeChild(sandbox);
-          }
-          catch (err) {
-              logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);
-          }
-      }
-      return result;
-  }
-  /**
-   * Tells whether current environment supports Referrer Policy API
-   * {@link supportsReferrerPolicy}.
-   *
-   * @returns Answer to the given question.
-   */
-  function supportsReferrerPolicy() {
-      // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default
-      // https://caniuse.com/#feat=referrer-policy
-      // It doesn't. And it throw exception instead of ignoring this parameter...
-      // REF: https://github.com/getsentry/raven-js/issues/1233
-      if (!supportsFetch()) {
-          return false;
-      }
-      try {
-          new Request('_', {
-              referrerPolicy: 'origin',
-          });
-          return true;
-      }
-      catch (e) {
-          return false;
+      catch (e) {
+          return false;
       }
   }
   /**
@@ -1680,7 +1305,7 @@ var Sentry = (function (exports) {
       }
       fill(global$2, 'fetch', function (originalFetch) {
           return function (...args) {
-              const commonHandlerData = {
+              const handlerData = {
                   args,
                   fetchData: {
                       method: getFetchMethod(args),
@@ -1688,13 +1313,13 @@ var Sentry = (function (exports) {
                   },
                   startTimestamp: Date.now(),
               };
-              triggerHandlers('fetch', Object.assign({}, commonHandlerData));
+              triggerHandlers('fetch', Object.assign({}, handlerData));
               // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
               return originalFetch.apply(global$2, args).then((response) => {
-                  triggerHandlers('fetch', Object.assign(Object.assign({}, commonHandlerData), { endTimestamp: Date.now(), response }));
+                  triggerHandlers('fetch', Object.assign(Object.assign({}, handlerData), { endTimestamp: Date.now(), response }));
                   return response;
               }, (error) => {
-                  triggerHandlers('fetch', Object.assign(Object.assign({}, commonHandlerData), { endTimestamp: Date.now(), error }));
+                  triggerHandlers('fetch', Object.assign(Object.assign({}, handlerData), { endTimestamp: Date.now(), error }));
                   // NOTE: If you are a Sentry user, and you are seeing this stack frame,
                   //       it means the sentry.javascript SDK caught an error invoking your application code.
                   //       This is expected behavior and NOT indicative of a bug with sentry.javascript.
@@ -1730,7 +1355,7 @@ var Sentry = (function (exports) {
       if (!('XMLHttpRequest' in global$2)) {
           return;
       }
-      // Poor man implementation of ES6 `Map` by tracking and keeping in sync key and value separately.
+      // Poor man's implementation of ES6 `Map`, tracking and keeping in sync key and value separately.
       const requestKeys = [];
       const requestValues = [];
       const xhrproto = XMLHttpRequest.prototype;
@@ -1764,7 +1389,7 @@ var Sentry = (function (exports) {
                       try {
                           const requestPos = requestKeys.indexOf(xhr);
                           if (requestPos !== -1) {
-                              // Make sure to pop both, key and value to keep it in sync.
+                              // Make sure to pop both key and value to keep it in sync.
                               requestKeys.splice(requestPos);
                               const args = requestValues.splice(requestPos)[0];
                               if (xhr.__sentry_xhr__ && args[0] !== undefined) {
@@ -1952,75 +1577,448 @@ var Sentry = (function (exports) {
       };
   }
   /**
-   * Wraps addEventListener to capture keypress UI events
-   * @param handler function that will be triggered
-   * @returns wrapped keypress events handler
-   * @hidden
+   * Wraps addEventListener to capture keypress UI events
+   * @param handler function that will be triggered
+   * @returns wrapped keypress events handler
+   * @hidden
+   */
+  function keypressEventHandler(handler) {
+      // TODO: if somehow user switches keypress target before
+      //       debounce timeout is triggered, we will only capture
+      //       a single breadcrumb from the FIRST target (acceptable?)
+      return (event) => {
+          let target;
+          try {
+              target = event.target;
+          }
+          catch (e) {
+              // just accessing event properties can throw an exception in some rare circumstances
+              // see: https://github.com/getsentry/raven-js/issues/838
+              return;
+          }
+          const tagName = target && target.tagName;
+          // only consider keypress events on actual input elements
+          // this will disregard keypresses targeting body (e.g. tabbing
+          // through elements, hotkeys, etc)
+          if (!tagName || (tagName !== 'INPUT' && tagName !== 'TEXTAREA' && !target.isContentEditable)) {
+              return;
+          }
+          // record first keypress in a series, but ignore subsequent
+          // keypresses until debounce clears
+          if (!keypressTimeout) {
+              domEventHandler('input', handler)(event);
+          }
+          clearTimeout(keypressTimeout);
+          keypressTimeout = setTimeout(() => {
+              keypressTimeout = undefined;
+          }, debounceDuration);
+      };
+  }
+  let _oldOnErrorHandler = null;
+  /** JSDoc */
+  function instrumentError() {
+      _oldOnErrorHandler = global$2.onerror;
+      global$2.onerror = function (msg, url, line, column, error) {
+          triggerHandlers('error', {
+              column,
+              error,
+              line,
+              msg,
+              url,
+          });
+          if (_oldOnErrorHandler) {
+              // eslint-disable-next-line prefer-rest-params
+              return _oldOnErrorHandler.apply(this, arguments);
+          }
+          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);
+          }
+          return true;
+      };
+  }
+
+  /* eslint-disable @typescript-eslint/explicit-function-return-type */
+  /** SyncPromise internal states */
+  var States;
+  (function (States) {
+      /** Pending */
+      States["PENDING"] = "PENDING";
+      /** Resolved / OK */
+      States["RESOLVED"] = "RESOLVED";
+      /** Rejected / Error */
+      States["REJECTED"] = "REJECTED";
+  })(States || (States = {}));
+  /**
+   * Thenable class that behaves like a Promise and follows it's interface
+   * but is not async internally
+   */
+  class SyncPromise {
+      constructor(executor) {
+          this._state = States.PENDING;
+          this._handlers = [];
+          /** JSDoc */
+          this._resolve = (value) => {
+              this._setResult(States.RESOLVED, value);
+          };
+          /** JSDoc */
+          this._reject = (reason) => {
+              this._setResult(States.REJECTED, reason);
+          };
+          /** JSDoc */
+          this._setResult = (state, value) => {
+              if (this._state !== States.PENDING) {
+                  return;
+              }
+              if (isThenable(value)) {
+                  value.then(this._resolve, this._reject);
+                  return;
+              }
+              this._state = state;
+              this._value = value;
+              this._executeHandlers();
+          };
+          // TODO: FIXME
+          /** JSDoc */
+          this._attachHandler = (handler) => {
+              this._handlers = this._handlers.concat(handler);
+              this._executeHandlers();
+          };
+          /** JSDoc */
+          this._executeHandlers = () => {
+              if (this._state === States.PENDING) {
+                  return;
+              }
+              const cachedHandlers = this._handlers.slice();
+              this._handlers = [];
+              cachedHandlers.forEach(handler => {
+                  if (handler.done) {
+                      return;
+                  }
+                  if (this._state === States.RESOLVED) {
+                      if (handler.onfulfilled) {
+                          // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                          handler.onfulfilled(this._value);
+                      }
+                  }
+                  if (this._state === States.REJECTED) {
+                      if (handler.onrejected) {
+                          handler.onrejected(this._value);
+                      }
+                  }
+                  handler.done = true;
+              });
+          };
+          try {
+              executor(this._resolve, this._reject);
+          }
+          catch (e) {
+              this._reject(e);
+          }
+      }
+      /** JSDoc */
+      static resolve(value) {
+          return new SyncPromise(resolve => {
+              resolve(value);
+          });
+      }
+      /** JSDoc */
+      static reject(reason) {
+          return new SyncPromise((_, reject) => {
+              reject(reason);
+          });
+      }
+      /** JSDoc */
+      static all(collection) {
+          return new SyncPromise((resolve, reject) => {
+              if (!Array.isArray(collection)) {
+                  reject(new TypeError(`Promise.all requires an array as input.`));
+                  return;
+              }
+              if (collection.length === 0) {
+                  resolve([]);
+                  return;
+              }
+              let counter = collection.length;
+              const resolvedCollection = [];
+              collection.forEach((item, index) => {
+                  SyncPromise.resolve(item)
+                      .then(value => {
+                      resolvedCollection[index] = value;
+                      counter -= 1;
+                      if (counter !== 0) {
+                          return;
+                      }
+                      resolve(resolvedCollection);
+                  })
+                      .then(null, reject);
+              });
+          });
+      }
+      /** JSDoc */
+      then(onfulfilled, onrejected) {
+          return new SyncPromise((resolve, reject) => {
+              this._attachHandler({
+                  done: false,
+                  onfulfilled: result => {
+                      if (!onfulfilled) {
+                          // TODO: ¯\_(ツ)_/¯
+                          // TODO: FIXME
+                          resolve(result);
+                          return;
+                      }
+                      try {
+                          resolve(onfulfilled(result));
+                          return;
+                      }
+                      catch (e) {
+                          reject(e);
+                          return;
+                      }
+                  },
+                  onrejected: reason => {
+                      if (!onrejected) {
+                          reject(reason);
+                          return;
+                      }
+                      try {
+                          resolve(onrejected(reason));
+                          return;
+                      }
+                      catch (e) {
+                          reject(e);
+                          return;
+                      }
+                  },
+              });
+          });
+      }
+      /** JSDoc */
+      catch(onrejected) {
+          return this.then(val => val, onrejected);
+      }
+      /** JSDoc */
+      finally(onfinally) {
+          return new SyncPromise((resolve, reject) => {
+              let val;
+              let isRejected;
+              return this.then(value => {
+                  isRejected = false;
+                  val = value;
+                  if (onfinally) {
+                      onfinally();
+                  }
+              }, reason => {
+                  isRejected = true;
+                  val = reason;
+                  if (onfinally) {
+                      onfinally();
+                  }
+              }).then(() => {
+                  if (isRejected) {
+                      reject(val);
+                      return;
+                  }
+                  resolve(val);
+              });
+          });
+      }
+      /** JSDoc */
+      toString() {
+          return '[object SyncPromise]';
+      }
+  }
+
+  /** A simple queue that holds promises. */
+  class PromiseBuffer {
+      constructor(_limit) {
+          this._limit = _limit;
+          /** Internal set of queued Promises */
+          this._buffer = [];
+      }
+      /**
+       * Says if the buffer is ready to take more requests
+       */
+      isReady() {
+          return this._limit === undefined || this.length() < this._limit;
+      }
+      /**
+       * Add a promise to the queue.
+       *
+       * @param task Can be any PromiseLike<T>
+       * @returns The original promise.
+       */
+      add(task) {
+          if (!this.isReady()) {
+              return SyncPromise.reject(new SentryError('Not adding Promise due to buffer limit reached.'));
+          }
+          if (this._buffer.indexOf(task) === -1) {
+              this._buffer.push(task);
+          }
+          task
+              .then(() => this.remove(task))
+              .then(null, () => this.remove(task).then(null, () => {
+              // We have to add this catch here otherwise we have an unhandledPromiseRejection
+              // because it's a new Promise chain.
+          }));
+          return task;
+      }
+      /**
+       * Remove a promise to the queue.
+       *
+       * @param task Can be any PromiseLike<T>
+       * @returns Removed promise.
+       */
+      remove(task) {
+          const removedTask = this._buffer.splice(this._buffer.indexOf(task), 1)[0];
+          return removedTask;
+      }
+      /**
+       * This function returns the number of unresolved promises in the queue.
+       */
+      length() {
+          return this._buffer.length;
+      }
+      /**
+       * This will drain the whole queue, returns true if queue is empty or drained.
+       * If timeout is provided and the queue takes longer to drain, the promise still resolves but with false.
+       *
+       * @param timeout Number in ms to wait until it resolves with false.
+       */
+      drain(timeout) {
+          return new SyncPromise(resolve => {
+              const capturedSetTimeout = setTimeout(() => {
+                  if (timeout && timeout > 0) {
+                      resolve(false);
+                  }
+              }, timeout);
+              SyncPromise.all(this._buffer)
+                  .then(() => {
+                  clearTimeout(capturedSetTimeout);
+                  resolve(true);
+              })
+                  .then(null, () => {
+                  resolve(true);
+              });
+          });
+      }
+  }
+
+  /**
+   * A TimestampSource implementation for environments that do not support the Performance Web API natively.
+   *
+   * Note that this TimestampSource does not use a monotonic clock. A call to `nowSeconds` may return a timestamp earlier
+   * than a previously returned value. We do not try to emulate a monotonic behavior in order to facilitate debugging. It
+   * is more obvious to explain "why does my span have negative duration" than "why my spans have zero duration".
+   */
+  const dateTimestampSource = {
+      nowSeconds: () => Date.now() / 1000,
+  };
+  /**
+   * Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not
+   * support the API.
+   *
+   * Wrapping the native API works around differences in behavior from different browsers.
+   */
+  function getBrowserPerformance() {
+      const { performance } = getGlobalObject();
+      if (!performance || !performance.now) {
+          return undefined;
+      }
+      // Replace performance.timeOrigin with our own timeOrigin based on Date.now().
+      //
+      // This is a partial workaround for browsers reporting performance.timeOrigin such that performance.timeOrigin +
+      // performance.now() gives a date arbitrarily in the past.
+      //
+      // Additionally, computing timeOrigin in this way fills the gap for browsers where performance.timeOrigin is
+      // undefined.
+      //
+      // The assumption that performance.timeOrigin + performance.now() ~= Date.now() is flawed, but we depend on it to
+      // interact with data coming out of performance entries.
+      //
+      // Note that despite recommendations against it in the spec, browsers implement the Performance API with a clock that
+      // might stop when the computer is asleep (and perhaps under other circumstances). Such behavior causes
+      // performance.timeOrigin + performance.now() to have an arbitrary skew over Date.now(). In laptop computers, we have
+      // observed skews that can be as long as days, weeks or months.
+      //
+      // See https://github.com/getsentry/sentry-javascript/issues/2590.
+      //
+      // BUG: despite our best intentions, this workaround has its limitations. It mostly addresses timings of pageload
+      // transactions, but ignores the skew built up over time that can aversely affect timestamps of navigation
+      // transactions of long-lived web pages.
+      const timeOrigin = Date.now() - performance.now();
+      return {
+          now: () => performance.now(),
+          timeOrigin,
+      };
+  }
+  /**
+   * Returns the native Performance API implementation from Node.js. Returns undefined in old Node.js versions that don't
+   * implement the API.
    */
-  function keypressEventHandler(handler) {
-      // TODO: if somehow user switches keypress target before
-      //       debounce timeout is triggered, we will only capture
-      //       a single breadcrumb from the FIRST target (acceptable?)
-      return (event) => {
-          let target;
-          try {
-              target = event.target;
-          }
-          catch (e) {
-              // just accessing event properties can throw an exception in some rare circumstances
-              // see: https://github.com/getsentry/raven-js/issues/838
-              return;
-          }
-          const tagName = target && target.tagName;
-          // only consider keypress events on actual input elements
-          // this will disregard keypresses targeting body (e.g. tabbing
-          // through elements, hotkeys, etc)
-          if (!tagName || (tagName !== 'INPUT' && tagName !== 'TEXTAREA' && !target.isContentEditable)) {
-              return;
-          }
-          // record first keypress in a series, but ignore subsequent
-          // keypresses until debounce clears
-          if (!keypressTimeout) {
-              domEventHandler('input', handler)(event);
-          }
-          clearTimeout(keypressTimeout);
-          keypressTimeout = setTimeout(() => {
-              keypressTimeout = undefined;
-          }, debounceDuration);
-      };
-  }
-  let _oldOnErrorHandler = null;
-  /** JSDoc */
-  function instrumentError() {
-      _oldOnErrorHandler = global$2.onerror;
-      global$2.onerror = function (msg, url, line, column, error) {
-          triggerHandlers('error', {
-              column,
-              error,
-              line,
-              msg,
-              url,
-          });
-          if (_oldOnErrorHandler) {
-              // eslint-disable-next-line prefer-rest-params
-              return _oldOnErrorHandler.apply(this, arguments);
-          }
-          return false;
-      };
+  function getNodePerformance() {
+      try {
+          const perfHooks = dynamicRequire(module, 'perf_hooks');
+          return perfHooks.performance;
+      }
+      catch (_) {
+          return undefined;
+      }
   }
-  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;
+  /**
+   * The Performance API implementation for the current platform, if available.
+   */
+  const platformPerformance = isNodeEnv() ? getNodePerformance() : getBrowserPerformance();
+  const timestampSource = platformPerformance === undefined
+      ? dateTimestampSource
+      : {
+          nowSeconds: () => (platformPerformance.timeOrigin + platformPerformance.now()) / 1000,
       };
-  }
+  /**
+   * Returns a timestamp in seconds since the UNIX epoch using the Date API.
+   */
+  const dateTimestampInSeconds = dateTimestampSource.nowSeconds.bind(dateTimestampSource);
+  /**
+   * Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the
+   * availability of the Performance API.
+   *
+   * See `usingPerformanceAPI` to test whether the Performance API is used.
+   *
+   * BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is
+   * asleep. This creates a skew between `dateTimestampInSeconds` and `timestampInSeconds`. The
+   * skew can grow to arbitrary amounts like days, weeks or months.
+   * See https://github.com/getsentry/sentry-javascript/issues/2590.
+   */
+  const timestampInSeconds = timestampSource.nowSeconds.bind(timestampSource);
+  /**
+   * The number of milliseconds since the UNIX epoch. This value is only usable in a browser, and only when the
+   * performance API is available.
+   */
+  const browserPerformanceTimeOrigin = (() => {
+      const { performance } = getGlobalObject();
+      if (!performance) {
+          return undefined;
+      }
+      if (performance.timeOrigin) {
+          return performance.timeOrigin;
+      }
+      // While performance.timing.navigationStart is deprecated in favor of performance.timeOrigin, performance.timeOrigin
+      // is not as widely supported. Namely, performance.timeOrigin is undefined in Safari as of writing.
+      // Also as of writing, performance.timing is not available in Web Workers in mainstream browsers, so it is not always
+      // a valid fallback. In the absence of an initial time provided by the browser, fallback to the current time from the
+      // Date API.
+      // eslint-disable-next-line deprecation/deprecation
+      return (performance.timing && performance.timing.navigationStart) || Date.now();
+  })();
 
   /**
    * Holds additional event information. {@link Scope.applyToEvent} will be
@@ -2041,10 +2039,8 @@ var Sentry = (function (exports) {
           /** Tags */
           this._tags = {};
           /** Extra */
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
           this._extra = {};
           /** Contexts */
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
           this._contexts = {};
       }
       /**
@@ -2061,7 +2057,6 @@ var Sentry = (function (exports) {
               newScope._user = scope._user;
               newScope._level = scope._level;
               newScope._span = scope._span;
-              newScope._session = scope._session;
               newScope._transactionName = scope._transactionName;
               newScope._fingerprint = scope._fingerprint;
               newScope._eventProcessors = [...scope._eventProcessors];
@@ -2087,18 +2082,9 @@ var Sentry = (function (exports) {
        */
       setUser(user) {
           this._user = user || {};
-          if (this._session) {
-              this._session.update({ user });
-          }
           this._notifyScopeListeners();
           return this;
       }
-      /**
-       * @inheritDoc
-       */
-      getUser() {
-          return this._user;
-      }
       /**
        * @inheritDoc
        */
@@ -2165,9 +2151,14 @@ var Sentry = (function (exports) {
       /**
        * @inheritDoc
        */
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       setContext(key, context) {
-          this._contexts = Object.assign(Object.assign({}, this._contexts), { [key]: context });
+          if (context === null) {
+              // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+              delete this._contexts[key];
+          }
+          else {
+              this._contexts = Object.assign(Object.assign({}, this._contexts), { [key]: context });
+          }
           this._notifyScopeListeners();
           return this;
       }
@@ -2189,31 +2180,20 @@ var Sentry = (function (exports) {
        * @inheritDoc
        */
       getTransaction() {
+          var _a, _b, _c, _d;
+          // often, this span will be a transaction, but it's not guaranteed to be
           const span = this.getSpan();
-          if (span && span.spanRecorder && span.spanRecorder.spans[0]) {
+          // try it the new way first
+          if ((_a = span) === null || _a === void 0 ? void 0 : _a.transaction) {
+              return (_b = span) === null || _b === void 0 ? void 0 : _b.transaction;
+          }
+          // fallback to the old way (known bug: this only finds transactions with sampled = true)
+          if ((_d = (_c = span) === null || _c === void 0 ? void 0 : _c.spanRecorder) === null || _d === void 0 ? void 0 : _d.spans[0]) {
               return span.spanRecorder.spans[0];
           }
+          // neither way found a transaction
           return undefined;
       }
-      /**
-       * @inheritDoc
-       */
-      setSession(session) {
-          if (!session) {
-              delete this._session;
-          }
-          else {
-              this._session = session;
-          }
-          this._notifyScopeListeners();
-          return this;
-      }
-      /**
-       * @inheritDoc
-       */
-      getSession() {
-          return this._session;
-      }
       /**
        * @inheritDoc
        */
@@ -2270,7 +2250,6 @@ var Sentry = (function (exports) {
           this._transactionName = undefined;
           this._fingerprint = undefined;
           this._span = undefined;
-          this._session = undefined;
           this._notifyScopeListeners();
           return this;
       }
@@ -2278,7 +2257,7 @@ var Sentry = (function (exports) {
        * @inheritDoc
        */
       addBreadcrumb(breadcrumb, maxBreadcrumbs) {
-          const mergedBreadcrumb = Object.assign({ timestamp: timestampWithMs() }, breadcrumb);
+          const mergedBreadcrumb = Object.assign({ timestamp: dateTimestampInSeconds() }, breadcrumb);
           this._breadcrumbs =
               maxBreadcrumbs !== undefined && maxBreadcrumbs >= 0
                   ? [...this._breadcrumbs, mergedBreadcrumb].slice(-maxBreadcrumbs)
@@ -2408,95 +2387,6 @@ var Sentry = (function (exports) {
       getGlobalEventProcessors().push(callback);
   }
 
-  /**
-   * @inheritdoc
-   */
-  class Session {
-      constructor(context) {
-          this.errors = 0;
-          this.sid = uuid4();
-          this.timestamp = Date.now();
-          this.started = Date.now();
-          this.status = SessionStatus.Ok;
-          console.log('new session constructed'); // eslint-disable-line no-console
-          if (context) {
-              this.update(context);
-          }
-      }
-      /** JSDoc */
-      // eslint-disable-next-line complexity
-      update(context) {
-          if (context.user) {
-              if (context.user.ip_address) {
-                  this.ip_address = context.user.ip_address;
-              }
-              if (!context.did) {
-                  this.did = context.user.id || context.user.email || context.user.username;
-              }
-          }
-          this.timestamp = context.timestamp || Date.now();
-          if (context.sid) {
-              // Good enough uuid validation for now
-              this.sid = context.sid.length === 32 ? context.sid : uuid4();
-          }
-          if (context.did) {
-              this.did = `${context.did}`;
-          }
-          if (typeof context.started === 'number') {
-              this.started = context.started;
-          }
-          if (typeof context.duration === 'number') {
-              this.duration = context.duration;
-          }
-          if (context.release) {
-              this.release = context.release;
-          }
-          if (context.environment) {
-              this.environment = context.environment;
-          }
-          if (context.ip_address) {
-              this.ip_address = context.ip_address;
-          }
-          if (context.user_agent) {
-              this.user_agent = context.user_agent;
-          }
-          if (typeof context.errors === 'number') {
-              this.errors = context.errors;
-          }
-          if (context.status) {
-              this.status = context.status;
-          }
-      }
-      /** JSDoc */
-      close(status) {
-          if (status) {
-              this.update({ status });
-          }
-          else if (this.status === SessionStatus.Ok) {
-              this.update({ status: SessionStatus.Exited });
-          }
-      }
-      /** JSDoc */
-      toJSON() {
-          return dropUndefinedKeys({
-              sid: `${this.sid}`,
-              init: true,
-              started: new Date(this.started).toISOString(),
-              timestamp: new Date(this.timestamp).toISOString(),
-              status: this.status,
-              errors: this.errors,
-              did: typeof this.did === 'number' || typeof this.did === 'string' ? `${this.did}` : undefined,
-              duration: this.duration,
-              attrs: dropUndefinedKeys({
-                  release: this.release,
-                  environment: this.environment,
-                  ip_address: this.ip_address,
-                  user_agent: this.user_agent,
-              }),
-          });
-      }
-  }
-
   /**
    * API compatibility version of this hub.
    *
@@ -2681,7 +2571,7 @@ var Sentry = (function (exports) {
           if (maxBreadcrumbs <= 0) {
               return;
           }
-          const timestamp = timestampWithMs();
+          const timestamp = dateTimestampInSeconds();
           const mergedBreadcrumb = Object.assign({ timestamp }, breadcrumb);
           const finalBreadcrumb = beforeBreadcrumb
               ? consoleSandbox(() => beforeBreadcrumb(mergedBreadcrumb, hint))
@@ -2807,41 +2697,6 @@ var Sentry = (function (exports) {
       traceHeaders() {
           return this._callExtensionMethod('traceHeaders');
       }
-      /**
-       * @inheritDoc
-       */
-      startSession() {
-          const top = this.getStackTop();
-          if (!top.scope) {
-              return;
-          }
-          const client = top.client;
-          const { release, environment } = (client && client.getOptions()) || {};
-          // End existing session if there's one
-          this.endSession();
-          top.scope.setSession(new Session({
-              release,
-              environment,
-              user: top.scope.getUser(),
-          }));
-      }
-      /**
-       * @inheritDoc
-       */
-      endSession() {
-          const top = this.getStackTop();
-          if (!top.scope) {
-              return;
-          }
-          const session = top.scope.getSession();
-          if (session) {
-              session.close();
-              if (top.client) {
-                  top.client.captureSession(session);
-              }
-          }
-          top.scope.setSession(undefined);
-      }
       /**
        * Internal helper function to call a method on the top client if it exists.
        *
@@ -3423,17 +3278,6 @@ var Sentry = (function (exports) {
           });
           return eventId;
       }
-      /**
-       * @inheritDoc
-       */
-      captureSession(session) {
-          if (!session.release) {
-              logger.warn('Discarded session update because of missing release');
-          }
-          else {
-              this._sendSession(session);
-          }
-      }
       /**
        * @inheritDoc
        */
@@ -3487,38 +3331,6 @@ var Sentry = (function (exports) {
               return null;
           }
       }
-      /** Updates existing session based on the provided event */
-      _updateSessionFromEvent(session, event) {
-          let crashed = false;
-          let errored = false;
-          let user_agent;
-          const exceptions = event.exception && event.exception.values;
-          if (exceptions) {
-              errored = true;
-              for (const ex of exceptions) {
-                  const mechanism = ex.mechanism;
-                  if (mechanism && mechanism.handled === false) {
-                      crashed = true;
-                      break;
-                  }
-              }
-          }
-          const user = event.user;
-          if (!session.user_agent) {
-              const headers = event.request ? event.request.headers : {};
-              for (const key in headers) {
-                  if (key.toLowerCase() === 'user-agent') {
-                      user_agent = headers[key];
-                      break;
-                  }
-              }
-          }
-          session.update(Object.assign(Object.assign({}, (crashed && { status: SessionStatus.Crashed })), { user, user_agent: user_agent, errors: session.errors + Number(errored || crashed) }));
-      }
-      /** Deliver captured session to Sentry */
-      _sendSession(session) {
-          this._getBackend().sendSession(session);
-      }
       /** Waits for the client to be done with processing. */
       _isClientProcessing(timeout) {
           return new SyncPromise(resolve => {
@@ -3569,7 +3381,7 @@ var Sentry = (function (exports) {
        */
       _prepareEvent(event, scope, hint) {
           const { normalizeDepth = 3 } = this.getOptions();
-          const prepared = Object.assign(Object.assign({}, event), { event_id: event.event_id || (hint && hint.event_id ? hint.event_id : uuid4()), timestamp: event.timestamp || timestampWithMs() });
+          const prepared = Object.assign(Object.assign({}, event), { event_id: event.event_id || (hint && hint.event_id ? hint.event_id : uuid4()), timestamp: event.timestamp || dateTimestampInSeconds() });
           this._applyClientOptions(prepared);
           this._applyIntegrationsMetadata(prepared);
           // If we have scope given to us, use it as the base for further modifications.
@@ -3715,12 +3527,6 @@ var Sentry = (function (exports) {
                   const isInternalException = hint && hint.data && hint.data.__sentry__ === true;
                   // We skip beforeSend in case of transactions
                   if (isInternalException || !beforeSend || isTransaction) {
-                      if (!isTransaction) {
-                          const session = scope && scope.getSession();
-                          if (session) {
-                              this._updateSessionFromEvent(session, finalEvent);
-                          }
-                      }
                       this._sendEvent(finalEvent);
                       resolve(finalEvent);
                       return;
@@ -3739,10 +3545,6 @@ var Sentry = (function (exports) {
                           resolve(null);
                           return;
                       }
-                      const session = scope && scope.getSession();
-                      if (session) {
-                          this._updateSessionFromEvent(session, finalEvent);
-                      }
                       // From here on we are really async
                       this._sendEvent(finalEvent);
                       resolve(finalEvent);
@@ -3832,18 +3634,6 @@ var Sentry = (function (exports) {
               logger.error(`Error while sending event: ${reason}`);
           });
       }
-      /**
-       * @inheritDoc
-       */
-      sendSession(session) {
-          if (!this._transport.sendSession) {
-              logger.warn('sendSession not implemented for a transport used');
-              return;
-          }
-          this._transport.sendSession(session).then(null, reason => {
-              logger.error(`Error while sending session: ${reason}`);
-          });
-      }
       /**
        * @inheritDoc
        */
@@ -3858,19 +3648,6 @@ var Sentry = (function (exports) {
       }
   }
 
-  /** Creates a SentryRequest from an event. */
-  function sessionToSentryRequest(session, api) {
-      const envelopeHeaders = JSON.stringify({
-          sent_at: new Date(timestampWithMs() * 1000).toISOString(),
-      });
-      const itemHeaders = JSON.stringify({
-          type: 'session',
-      });
-      return {
-          body: `${envelopeHeaders}\n${itemHeaders}\n${JSON.stringify(session)}`,
-          url: api.getEnvelopeEndpointWithUrlEncodedAuth(),
-      };
-  }
   /** Creates a SentryRequest from an event. */
   function eventToSentryRequest(event, api) {
       const useEnvelope = event.type === 'transaction';
@@ -3888,7 +3665,7 @@ var Sentry = (function (exports) {
               event_id: event.event_id,
               // We need to add * 1000 since we divide it by 1000 by default but JS works with ms precision
               // The reason we use timestampWithMs here is that all clocks across the SDK use the same clock
-              sent_at: new Date(timestampWithMs() * 1000).toISOString(),
+              sent_at: new Date().toISOString(),
           });
           const itemHeaders = JSON.stringify({
               type: event.type,
@@ -4615,40 +4392,6 @@ var Sentry = (function (exports) {
                   .catch(reject);
           }));
       }
-      /**
-       * @inheritDoc
-       */
-      sendSession(session) {
-          const sentryReq = sessionToSentryRequest(session, this._api);
-          const options = {
-              body: sentryReq.body,
-              method: 'POST',
-              // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default
-              // https://caniuse.com/#feat=referrer-policy
-              // It doesn't. And it throw exception instead of ignoring this parameter...
-              // REF: https://github.com/getsentry/raven-js/issues/1233
-              referrerPolicy: (supportsReferrerPolicy() ? 'origin' : ''),
-          };
-          if (this.options.fetchParameters !== undefined) {
-              Object.assign(options, this.options.fetchParameters);
-          }
-          if (this.options.headers !== undefined) {
-              options.headers = this.options.headers;
-          }
-          return new SyncPromise((resolve, reject) => {
-              global$3
-                  .fetch(sentryReq.url, options)
-                  .then(response => {
-                  const status = exports.Status.fromHttpCode(response.status);
-                  if (status === exports.Status.Success) {
-                      resolve({ status });
-                      return;
-                  }
-                  reject(response);
-              })
-                  .catch(reject);
-          });
-      }
   }
 
   /** `XHR` based transport */
@@ -4702,33 +4445,6 @@ var Sentry = (function (exports) {
               request.send(sentryReq.body);
           }));
       }
-      /**
-       * @inheritDoc
-       */
-      sendSession(session) {
-          const sentryReq = sessionToSentryRequest(session, this._api);
-          return new SyncPromise((resolve, reject) => {
-              const request = new XMLHttpRequest();
-              request.onreadystatechange = () => {
-                  if (request.readyState !== 4) {
-                      return;
-                  }
-                  const status = exports.Status.fromHttpCode(request.status);
-                  if (status === exports.Status.Success) {
-                      resolve({ status });
-                      return;
-                  }
-                  reject(request);
-              };
-              request.open('POST', sentryReq.url);
-              for (const header in this.options.headers) {
-                  if (this.options.headers.hasOwnProperty(header)) {
-                      request.setRequestHeader(header, this.options.headers[header]);
-                  }
-              }
-              request.send(sentryReq.body);
-          });
-      }
   }
 
 
@@ -5670,7 +5386,7 @@ var Sentry = (function (exports) {
   });
 
   const SDK_NAME = 'sentry.javascript.browser';
-  const SDK_VERSION = '5.25.0-beta.2';
+  const SDK_VERSION = '5.25.0';
 
   /**
    * The Sentry Browser SDK Client.