@sentry/browser 5.24.2 → 5.25.0

package/build/bundle.es6.js

@@ -1,4 +1,4 @@
-/*! @sentry/browser 5.24.2 (8096d02) | 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;
@@ -874,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
    *
@@ -1032,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
@@ -1171,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;
-              });
-          };
-          try {
-              executor(this._resolve, this._reject);
-          }
-          catch (e) {
-              this._reject(e);
-          }
+  function supportsFetch() {
+      if (!('fetch' in getGlobalObject())) {
+          return false;
       }
-      /** JSDoc */
-      static resolve(value) {
-          return new SyncPromise(resolve => {
-              resolve(value);
-          });
+      try {
+          new Headers();
+          new Request('');
+          new Response();
+          return true;
       }
-      /** JSDoc */
-      static reject(reason) {
-          return new SyncPromise((_, reject) => {
-              reject(reason);
-          });
+      catch (e) {
+          return false;
       }
-      /** 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;
+  }
+  /**
+   * 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);
               }
-              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);
-              });
-          });
+              doc.head.removeChild(sandbox);
+          }
+          catch (err) {
+              logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);
+          }
       }
-      /** 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;
-                      }
-                  },
-              });
+      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;
       }
-      /** 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;
       }
   }
   /**
@@ -1645,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),
@@ -1653,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.
@@ -1695,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;
@@ -1729,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) {
@@ -1987,56 +1647,427 @@ var Sentry = (function (exports) {
       };
   }
 
+  /* 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 = {}));
   /**
-   * Holds additional event information. {@link Scope.applyToEvent} will be
-   * called by the client before an event will be sent.
+   * Thenable class that behaves like a Promise and follows it's interface
+   * but is not async internally
    */
-  class Scope {
-      constructor() {
-          /** Flag if notifiying is happening. */
-          this._notifyingListeners = false;
-          /** Callback for client to receive scope changes. */
-          this._scopeListeners = [];
-          /** Callback list that will be called after {@link applyToEvent}. */
-          this._eventProcessors = [];
-          /** Array of breadcrumbs. */
-          this._breadcrumbs = [];
-          /** User */
-          this._user = {};
-          /** 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 = {};
-      }
-      /**
-       * Inherit values from the parent scope.
-       * @param scope to clone.
-       */
-      static clone(scope) {
-          const newScope = new Scope();
-          if (scope) {
-              newScope._breadcrumbs = [...scope._breadcrumbs];
-              newScope._tags = Object.assign({}, scope._tags);
-              newScope._extra = Object.assign({}, scope._extra);
-              newScope._contexts = Object.assign({}, scope._contexts);
-              newScope._user = scope._user;
-              newScope._level = scope._level;
-              newScope._span = scope._span;
-              newScope._transactionName = scope._transactionName;
-              newScope._fingerprint = scope._fingerprint;
-              newScope._eventProcessors = [...scope._eventProcessors];
-          }
-          return newScope;
-      }
-      /**
-       * Add internal on change listener. Used for sub SDKs that need to store the scope.
-       * @hidden
-       */
-      addScopeListener(callback) {
+  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 getNodePerformance() {
+      try {
+          const perfHooks = dynamicRequire(module, 'perf_hooks');
+          return perfHooks.performance;
+      }
+      catch (_) {
+          return undefined;
+      }
+  }
+  /**
+   * 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
+   * called by the client before an event will be sent.
+   */
+  class Scope {
+      constructor() {
+          /** Flag if notifiying is happening. */
+          this._notifyingListeners = false;
+          /** Callback for client to receive scope changes. */
+          this._scopeListeners = [];
+          /** Callback list that will be called after {@link applyToEvent}. */
+          this._eventProcessors = [];
+          /** Array of breadcrumbs. */
+          this._breadcrumbs = [];
+          /** User */
+          this._user = {};
+          /** Tags */
+          this._tags = {};
+          /** Extra */
+          this._extra = {};
+          /** Contexts */
+          this._contexts = {};
+      }
+      /**
+       * Inherit values from the parent scope.
+       * @param scope to clone.
+       */
+      static clone(scope) {
+          const newScope = new Scope();
+          if (scope) {
+              newScope._breadcrumbs = [...scope._breadcrumbs];
+              newScope._tags = Object.assign({}, scope._tags);
+              newScope._extra = Object.assign({}, scope._extra);
+              newScope._contexts = Object.assign({}, scope._contexts);
+              newScope._user = scope._user;
+              newScope._level = scope._level;
+              newScope._span = scope._span;
+              newScope._transactionName = scope._transactionName;
+              newScope._fingerprint = scope._fingerprint;
+              newScope._eventProcessors = [...scope._eventProcessors];
+          }
+          return newScope;
+      }
+      /**
+       * Add internal on change listener. Used for sub SDKs that need to store the scope.
+       * @hidden
+       */
+      addScopeListener(callback) {
           this._scopeListeners.push(callback);
       }
       /**
@@ -2120,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;
       }
@@ -2144,10 +2180,18 @@ 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;
       }
       /**
@@ -2213,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)
@@ -2527,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))
@@ -3337,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.
@@ -3621,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,
@@ -5342,7 +5386,7 @@ var Sentry = (function (exports) {
   });
 
   const SDK_NAME = 'sentry.javascript.browser';
-  const SDK_VERSION = '5.24.2';
+  const SDK_VERSION = '5.25.0';
 
   /**
    * The Sentry Browser SDK Client.