@sentry/browser 5.24.2 → 5.25.0

package/build/bundle.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) {
     /*! *****************************************************************************
     Copyright (c) Microsoft Corporation. All rights reserved.
@@ -962,13 +962,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
      *
@@ -1121,73 +1114,6 @@ var Sentry = (function (exports) {
             return '';
         }
     }
-    var INITIAL_TIME = Date.now();
-    var prevNow = 0;
-    var performanceFallback = {
-        now: function () {
-            var 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
-        var performance = getGlobalObject().performance;
-        if (performance && typeof performance.now === 'function') {
-            var INITIAL_OFFSET_1 = performance.now();
-            return {
-                now: function () {
-                    return performance.now() - INITIAL_OFFSET_1;
-                },
-                timeOrigin: INITIAL_TIME,
-            };
-        }
-        return performanceFallback;
-    }
-    var crossPlatformPerformance = (function () {
-        // React Native's performance.now() starts with a gigantic offset, so we need to wrap it.
-        if (isReactNative()) {
-            return getReactNativePerformanceWrapper();
-        }
-        if (isNodeEnv()) {
-            try {
-                var perfHooks = dynamicRequire(module, 'perf_hooks');
-                return perfHooks.performance;
-            }
-            catch (_) {
-                return performanceFallback;
-            }
-        }
-        var performance = getGlobalObject().performance;
-        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;
-    }
     var defaultRetryAfter = 60 * 1000; // 60 seconds
     /**
      * Extracts Retry-After value from the request header or returns default value
@@ -1273,363 +1199,88 @@ var Sentry = (function (exports) {
     global$1.__SENTRY__ = global$1.__SENTRY__ || {};
     var 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.
      */
-    var SyncPromise = /** @class */ (function () {
-        function SyncPromise(executor) {
-            var _this = this;
-            this._state = States.PENDING;
-            this._handlers = [];
-            /** JSDoc */
-            this._resolve = function (value) {
-                _this._setResult(States.RESOLVED, value);
-            };
-            /** JSDoc */
-            this._reject = function (reason) {
-                _this._setResult(States.REJECTED, reason);
-            };
-            /** JSDoc */
-            this._setResult = function (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 = function (handler) {
-                _this._handlers = _this._handlers.concat(handler);
-                _this._executeHandlers();
-            };
-            /** JSDoc */
-            this._executeHandlers = function () {
-                if (_this._state === States.PENDING) {
-                    return;
-                }
-                var cachedHandlers = _this._handlers.slice();
-                _this._handlers = [];
-                cachedHandlers.forEach(function (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;
+        }
+        var 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
+        var result = false;
+        var doc = global.document;
+        // eslint-disable-next-line deprecation/deprecation
+        if (doc && typeof doc.createElement === "function") {
             try {
-                executor(this._resolve, this._reject);
+                var 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 */
-        SyncPromise.resolve = function (value) {
-            return new SyncPromise(function (resolve) {
-                resolve(value);
-            });
-        };
-        /** JSDoc */
-        SyncPromise.reject = function (reason) {
-            return new SyncPromise(function (_, reject) {
-                reject(reason);
-            });
-        };
-        /** JSDoc */
-        SyncPromise.all = function (collection) {
-            return new SyncPromise(function (resolve, reject) {
-                if (!Array.isArray(collection)) {
-                    reject(new TypeError("Promise.all requires an array as input."));
-                    return;
-                }
-                if (collection.length === 0) {
-                    resolve([]);
-                    return;
-                }
-                var counter = collection.length;
-                var resolvedCollection = [];
-                collection.forEach(function (item, index) {
-                    SyncPromise.resolve(item)
-                        .then(function (value) {
-                        resolvedCollection[index] = value;
-                        counter -= 1;
-                        if (counter !== 0) {
-                            return;
-                        }
-                        resolve(resolvedCollection);
-                    })
-                        .then(null, reject);
-                });
-            });
-        };
-        /** JSDoc */
-        SyncPromise.prototype.then = function (onfulfilled, onrejected) {
-            var _this = this;
-            return new SyncPromise(function (resolve, reject) {
-                _this._attachHandler({
-                    done: false,
-                    onfulfilled: function (result) {
-                        if (!onfulfilled) {
-                            // TODO: ¯\_(ツ)_/¯
-                            // TODO: FIXME
-                            resolve(result);
-                            return;
-                        }
-                        try {
-                            resolve(onfulfilled(result));
-                            return;
-                        }
-                        catch (e) {
-                            reject(e);
-                            return;
-                        }
-                    },
-                    onrejected: function (reason) {
-                        if (!onrejected) {
-                            reject(reason);
-                            return;
-                        }
-                        try {
-                            resolve(onrejected(reason));
-                            return;
-                        }
-                        catch (e) {
-                            reject(e);
-                            return;
-                        }
-                    },
-                });
-            });
-        };
-        /** JSDoc */
-        SyncPromise.prototype.catch = function (onrejected) {
-            return this.then(function (val) { return val; }, onrejected);
-        };
-        /** JSDoc */
-        SyncPromise.prototype.finally = function (onfinally) {
-            var _this = this;
-            return new SyncPromise(function (resolve, reject) {
-                var val;
-                var isRejected;
-                return _this.then(function (value) {
-                    isRejected = false;
-                    val = value;
-                    if (onfinally) {
-                        onfinally();
-                    }
-                }, function (reason) {
-                    isRejected = true;
-                    val = reason;
-                    if (onfinally) {
-                        onfinally();
-                    }
-                }).then(function () {
-                    if (isRejected) {
-                        reject(val);
-                        return;
-                    }
-                    resolve(val);
-                });
-            });
-        };
-        /** JSDoc */
-        SyncPromise.prototype.toString = function () {
-            return '[object SyncPromise]';
-        };
-        return SyncPromise;
-    }());
-
-    /** A simple queue that holds promises. */
-    var PromiseBuffer = /** @class */ (function () {
-        function PromiseBuffer(_limit) {
-            this._limit = _limit;
-            /** Internal set of queued Promises */
-            this._buffer = [];
-        }
-        /**
-         * Says if the buffer is ready to take more requests
-         */
-        PromiseBuffer.prototype.isReady = function () {
-            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.
-         */
-        PromiseBuffer.prototype.add = function (task) {
-            var _this = this;
-            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(function () { return _this.remove(task); })
-                .then(null, function () {
-                return _this.remove(task).then(null, function () {
-                    // 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.
-         */
-        PromiseBuffer.prototype.remove = function (task) {
-            var removedTask = this._buffer.splice(this._buffer.indexOf(task), 1)[0];
-            return removedTask;
-        };
-        /**
-         * This function returns the number of unresolved promises in the queue.
-         */
-        PromiseBuffer.prototype.length = function () {
-            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.
-         */
-        PromiseBuffer.prototype.drain = function (timeout) {
-            var _this = this;
-            return new SyncPromise(function (resolve) {
-                var capturedSetTimeout = setTimeout(function () {
-                    if (timeout && timeout > 0) {
-                        resolve(false);
-                    }
-                }, timeout);
-                SyncPromise.all(_this._buffer)
-                    .then(function () {
-                    clearTimeout(capturedSetTimeout);
-                    resolve(true);
-                })
-                    .then(null, function () {
-                    resolve(true);
-                });
-            });
-        };
-        return PromiseBuffer;
-    }());
-
-    /**
-     * 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;
-        }
-        var 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
-        var result = false;
-        var doc = global.document;
-        // eslint-disable-next-line deprecation/deprecation
-        if (doc && typeof doc.createElement === "function") {
-            try {
-                var 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 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;
         }
@@ -1775,7 +1426,7 @@ var Sentry = (function (exports) {
                 for (var _i = 0; _i < arguments.length; _i++) {
                     args[_i] = arguments[_i];
                 }
-                var commonHandlerData = {
+                var handlerData = {
                     args: args,
                     fetchData: {
                         method: getFetchMethod(args),
@@ -1783,13 +1434,13 @@ var Sentry = (function (exports) {
                     },
                     startTimestamp: Date.now(),
                 };
-                triggerHandlers('fetch', __assign({}, commonHandlerData));
+                triggerHandlers('fetch', __assign({}, handlerData));
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
                 return originalFetch.apply(global$2, args).then(function (response) {
-                    triggerHandlers('fetch', __assign(__assign({}, commonHandlerData), { endTimestamp: Date.now(), response: response }));
+                    triggerHandlers('fetch', __assign(__assign({}, handlerData), { endTimestamp: Date.now(), response: response }));
                     return response;
                 }, function (error) {
-                    triggerHandlers('fetch', __assign(__assign({}, commonHandlerData), { endTimestamp: Date.now(), error: error }));
+                    triggerHandlers('fetch', __assign(__assign({}, handlerData), { endTimestamp: Date.now(), error: 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.
@@ -1827,7 +1478,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.
         var requestKeys = [];
         var requestValues = [];
         var xhrproto = XMLHttpRequest.prototype;
@@ -1865,7 +1516,7 @@ var Sentry = (function (exports) {
                         try {
                             var 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);
                                 var args_1 = requestValues.splice(requestPos)[0];
                                 if (xhr.__sentry_xhr__ && args_1[0] !== undefined) {
@@ -2140,51 +1791,431 @@ 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
      */
-    var Scope = /** @class */ (function () {
-        function Scope() {
-            /** 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.
-         */
-        Scope.clone = function (scope) {
-            var newScope = new Scope();
-            if (scope) {
-                newScope._breadcrumbs = __spread(scope._breadcrumbs);
-                newScope._tags = __assign({}, scope._tags);
-                newScope._extra = __assign({}, scope._extra);
-                newScope._contexts = __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 = __spread(scope._eventProcessors);
-            }
-            return newScope;
-        };
+    var SyncPromise = /** @class */ (function () {
+        function SyncPromise(executor) {
+            var _this = this;
+            this._state = States.PENDING;
+            this._handlers = [];
+            /** JSDoc */
+            this._resolve = function (value) {
+                _this._setResult(States.RESOLVED, value);
+            };
+            /** JSDoc */
+            this._reject = function (reason) {
+                _this._setResult(States.REJECTED, reason);
+            };
+            /** JSDoc */
+            this._setResult = function (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 = function (handler) {
+                _this._handlers = _this._handlers.concat(handler);
+                _this._executeHandlers();
+            };
+            /** JSDoc */
+            this._executeHandlers = function () {
+                if (_this._state === States.PENDING) {
+                    return;
+                }
+                var cachedHandlers = _this._handlers.slice();
+                _this._handlers = [];
+                cachedHandlers.forEach(function (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 */
+        SyncPromise.resolve = function (value) {
+            return new SyncPromise(function (resolve) {
+                resolve(value);
+            });
+        };
+        /** JSDoc */
+        SyncPromise.reject = function (reason) {
+            return new SyncPromise(function (_, reject) {
+                reject(reason);
+            });
+        };
+        /** JSDoc */
+        SyncPromise.all = function (collection) {
+            return new SyncPromise(function (resolve, reject) {
+                if (!Array.isArray(collection)) {
+                    reject(new TypeError("Promise.all requires an array as input."));
+                    return;
+                }
+                if (collection.length === 0) {
+                    resolve([]);
+                    return;
+                }
+                var counter = collection.length;
+                var resolvedCollection = [];
+                collection.forEach(function (item, index) {
+                    SyncPromise.resolve(item)
+                        .then(function (value) {
+                        resolvedCollection[index] = value;
+                        counter -= 1;
+                        if (counter !== 0) {
+                            return;
+                        }
+                        resolve(resolvedCollection);
+                    })
+                        .then(null, reject);
+                });
+            });
+        };
+        /** JSDoc */
+        SyncPromise.prototype.then = function (onfulfilled, onrejected) {
+            var _this = this;
+            return new SyncPromise(function (resolve, reject) {
+                _this._attachHandler({
+                    done: false,
+                    onfulfilled: function (result) {
+                        if (!onfulfilled) {
+                            // TODO: ¯\_(ツ)_/¯
+                            // TODO: FIXME
+                            resolve(result);
+                            return;
+                        }
+                        try {
+                            resolve(onfulfilled(result));
+                            return;
+                        }
+                        catch (e) {
+                            reject(e);
+                            return;
+                        }
+                    },
+                    onrejected: function (reason) {
+                        if (!onrejected) {
+                            reject(reason);
+                            return;
+                        }
+                        try {
+                            resolve(onrejected(reason));
+                            return;
+                        }
+                        catch (e) {
+                            reject(e);
+                            return;
+                        }
+                    },
+                });
+            });
+        };
+        /** JSDoc */
+        SyncPromise.prototype.catch = function (onrejected) {
+            return this.then(function (val) { return val; }, onrejected);
+        };
+        /** JSDoc */
+        SyncPromise.prototype.finally = function (onfinally) {
+            var _this = this;
+            return new SyncPromise(function (resolve, reject) {
+                var val;
+                var isRejected;
+                return _this.then(function (value) {
+                    isRejected = false;
+                    val = value;
+                    if (onfinally) {
+                        onfinally();
+                    }
+                }, function (reason) {
+                    isRejected = true;
+                    val = reason;
+                    if (onfinally) {
+                        onfinally();
+                    }
+                }).then(function () {
+                    if (isRejected) {
+                        reject(val);
+                        return;
+                    }
+                    resolve(val);
+                });
+            });
+        };
+        /** JSDoc */
+        SyncPromise.prototype.toString = function () {
+            return '[object SyncPromise]';
+        };
+        return SyncPromise;
+    }());
+
+    /** A simple queue that holds promises. */
+    var PromiseBuffer = /** @class */ (function () {
+        function PromiseBuffer(_limit) {
+            this._limit = _limit;
+            /** Internal set of queued Promises */
+            this._buffer = [];
+        }
+        /**
+         * Says if the buffer is ready to take more requests
+         */
+        PromiseBuffer.prototype.isReady = function () {
+            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.
+         */
+        PromiseBuffer.prototype.add = function (task) {
+            var _this = this;
+            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(function () { return _this.remove(task); })
+                .then(null, function () {
+                return _this.remove(task).then(null, function () {
+                    // 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.
+         */
+        PromiseBuffer.prototype.remove = function (task) {
+            var removedTask = this._buffer.splice(this._buffer.indexOf(task), 1)[0];
+            return removedTask;
+        };
+        /**
+         * This function returns the number of unresolved promises in the queue.
+         */
+        PromiseBuffer.prototype.length = function () {
+            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.
+         */
+        PromiseBuffer.prototype.drain = function (timeout) {
+            var _this = this;
+            return new SyncPromise(function (resolve) {
+                var capturedSetTimeout = setTimeout(function () {
+                    if (timeout && timeout > 0) {
+                        resolve(false);
+                    }
+                }, timeout);
+                SyncPromise.all(_this._buffer)
+                    .then(function () {
+                    clearTimeout(capturedSetTimeout);
+                    resolve(true);
+                })
+                    .then(null, function () {
+                    resolve(true);
+                });
+            });
+        };
+        return PromiseBuffer;
+    }());
+
+    /**
+     * 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".
+     */
+    var dateTimestampSource = {
+        nowSeconds: function () { return 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() {
+        var performance = getGlobalObject().performance;
+        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.
+        var timeOrigin = Date.now() - performance.now();
+        return {
+            now: function () { return performance.now(); },
+            timeOrigin: 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 {
+            var perfHooks = dynamicRequire(module, 'perf_hooks');
+            return perfHooks.performance;
+        }
+        catch (_) {
+            return undefined;
+        }
+    }
+    /**
+     * The Performance API implementation for the current platform, if available.
+     */
+    var platformPerformance = isNodeEnv() ? getNodePerformance() : getBrowserPerformance();
+    var timestampSource = platformPerformance === undefined
+        ? dateTimestampSource
+        : {
+            nowSeconds: function () { return (platformPerformance.timeOrigin + platformPerformance.now()) / 1000; },
+        };
+    /**
+     * Returns a timestamp in seconds since the UNIX epoch using the Date API.
+     */
+    var 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.
+     */
+    var 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.
+     */
+    var browserPerformanceTimeOrigin = (function () {
+        var performance = getGlobalObject().performance;
+        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.
+     */
+    var Scope = /** @class */ (function () {
+        function Scope() {
+            /** 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.
+         */
+        Scope.clone = function (scope) {
+            var newScope = new Scope();
+            if (scope) {
+                newScope._breadcrumbs = __spread(scope._breadcrumbs);
+                newScope._tags = __assign({}, scope._tags);
+                newScope._extra = __assign({}, scope._extra);
+                newScope._contexts = __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 = __spread(scope._eventProcessors);
+            }
+            return newScope;
+        };
         /**
          * Add internal on change listener. Used for sub SDKs that need to store the scope.
          * @hidden
@@ -2275,10 +2306,15 @@ var Sentry = (function (exports) {
         /**
          * @inheritDoc
          */
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         Scope.prototype.setContext = function (key, context) {
             var _a;
-            this._contexts = __assign(__assign({}, this._contexts), (_a = {}, _a[key] = context, _a));
+            if (context === null) {
+                // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+                delete this._contexts[key];
+            }
+            else {
+                this._contexts = __assign(__assign({}, this._contexts), (_a = {}, _a[key] = context, _a));
+            }
             this._notifyScopeListeners();
             return this;
         };
@@ -2300,10 +2336,18 @@ var Sentry = (function (exports) {
          * @inheritDoc
          */
         Scope.prototype.getTransaction = function () {
+            var _a, _b, _c, _d;
+            // often, this span will be a transaction, but it's not guaranteed to be
             var 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;
         };
         /**
@@ -2369,7 +2413,7 @@ var Sentry = (function (exports) {
          * @inheritDoc
          */
         Scope.prototype.addBreadcrumb = function (breadcrumb, maxBreadcrumbs) {
-            var mergedBreadcrumb = __assign({ timestamp: timestampWithMs() }, breadcrumb);
+            var mergedBreadcrumb = __assign({ timestamp: dateTimestampInSeconds() }, breadcrumb);
             this._breadcrumbs =
                 maxBreadcrumbs !== undefined && maxBreadcrumbs >= 0
                     ? __spread(this._breadcrumbs, [mergedBreadcrumb]).slice(-maxBreadcrumbs)
@@ -2689,7 +2733,7 @@ var Sentry = (function (exports) {
             if (maxBreadcrumbs <= 0) {
                 return;
             }
-            var timestamp = timestampWithMs();
+            var timestamp = dateTimestampInSeconds();
             var mergedBreadcrumb = __assign({ timestamp: timestamp }, breadcrumb);
             var finalBreadcrumb = beforeBreadcrumb
                 ? consoleSandbox(function () { return beforeBreadcrumb(mergedBreadcrumb, hint); })
@@ -3521,7 +3565,7 @@ var Sentry = (function (exports) {
         BaseClient.prototype._prepareEvent = function (event, scope, hint) {
             var _this = this;
             var _a = this.getOptions().normalizeDepth, normalizeDepth = _a === void 0 ? 3 : _a;
-            var prepared = __assign(__assign({}, event), { event_id: event.event_id || (hint && hint.event_id ? hint.event_id : uuid4()), timestamp: event.timestamp || timestampWithMs() });
+            var prepared = __assign(__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.
@@ -3812,7 +3856,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(),
             });
             var itemHeaders = JSON.stringify({
                 type: event.type,
@@ -5580,7 +5624,7 @@ var Sentry = (function (exports) {
     });
 
     var SDK_NAME = 'sentry.javascript.browser';
-    var SDK_VERSION = '5.24.2';
+    var SDK_VERSION = '5.25.0';
 
     /**
      * The Sentry Browser SDK Client.