{"version":3,"file":"js/chunk-vendors-611a1183.1cbe5e84.js","mappings":"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","sources":["webpack://ouvidoria/./node_modules/@sentry/hub/esm/session.js","webpack://ouvidoria/./node_modules/@sentry/hub/esm/hub.js","webpack://ouvidoria/./node_modules/@sentry/hub/esm/scope.js","webpack://ouvidoria/./node_modules/@sentry/hub/node_modules/tslib/tslib.es6.js"],"sourcesContent":["import { SessionStatus } from '@sentry/types';\nimport { dropUndefinedKeys, uuid4 } from '@sentry/utils';\n/**\n * @inheritdoc\n */\nvar Session = /** @class */ (function () {\n    function Session(context) {\n        this.errors = 0;\n        this.sid = uuid4();\n        this.timestamp = Date.now();\n        this.started = Date.now();\n        this.duration = 0;\n        this.status = SessionStatus.Ok;\n        if (context) {\n            this.update(context);\n        }\n    }\n    /** JSDoc */\n    // eslint-disable-next-line complexity\n    Session.prototype.update = function (context) {\n        if (context === void 0) { context = {}; }\n        if (context.user) {\n            if (context.user.ip_address) {\n                this.ipAddress = context.user.ip_address;\n            }\n            if (!context.did) {\n                this.did = context.user.id || context.user.email || context.user.username;\n            }\n        }\n        this.timestamp = context.timestamp || Date.now();\n        if (context.sid) {\n            // Good enough uuid validation. — Kamil\n            this.sid = context.sid.length === 32 ? context.sid : uuid4();\n        }\n        if (context.did) {\n            this.did = \"\" + context.did;\n        }\n        if (typeof context.started === 'number') {\n            this.started = context.started;\n        }\n        if (typeof context.duration === 'number') {\n            this.duration = context.duration;\n        }\n        else {\n            this.duration = this.timestamp - this.started;\n        }\n        if (context.release) {\n            this.release = context.release;\n        }\n        if (context.environment) {\n            this.environment = context.environment;\n        }\n        if (context.ipAddress) {\n            this.ipAddress = context.ipAddress;\n        }\n        if (context.userAgent) {\n            this.userAgent = context.userAgent;\n        }\n        if (typeof context.errors === 'number') {\n            this.errors = context.errors;\n        }\n        if (context.status) {\n            this.status = context.status;\n        }\n    };\n    /** JSDoc */\n    Session.prototype.close = function (status) {\n        if (status) {\n            this.update({ status: status });\n        }\n        else if (this.status === SessionStatus.Ok) {\n            this.update({ status: SessionStatus.Exited });\n        }\n        else {\n            this.update();\n        }\n    };\n    /** JSDoc */\n    Session.prototype.toJSON = function () {\n        return dropUndefinedKeys({\n            sid: \"\" + this.sid,\n            init: true,\n            started: new Date(this.started).toISOString(),\n            timestamp: new Date(this.timestamp).toISOString(),\n            status: this.status,\n            errors: this.errors,\n            did: typeof this.did === 'number' || typeof this.did === 'string' ? \"\" + this.did : undefined,\n            duration: this.duration,\n            attrs: dropUndefinedKeys({\n                release: this.release,\n                environment: this.environment,\n                ip_address: this.ipAddress,\n                user_agent: this.userAgent,\n            }),\n        });\n    };\n    return Session;\n}());\nexport { Session };\n//# sourceMappingURL=session.js.map","import { __assign, __read, __spread } from \"tslib\";\nimport { consoleSandbox, dateTimestampInSeconds, getGlobalObject, isNodeEnv, logger, uuid4 } from '@sentry/utils';\nimport { Scope } from './scope';\nimport { Session } from './session';\n/**\n * API compatibility version of this hub.\n *\n * WARNING: This number should only be increased when the global interface\n * changes and new methods are introduced.\n *\n * @hidden\n */\nexport var API_VERSION = 3;\n/**\n * Default maximum number of breadcrumbs added to an event. Can be overwritten\n * with {@link Options.maxBreadcrumbs}.\n */\nvar DEFAULT_BREADCRUMBS = 100;\n/**\n * Absolute maximum number of breadcrumbs added to an event. The\n * `maxBreadcrumbs` option cannot be higher than this value.\n */\nvar MAX_BREADCRUMBS = 100;\n/**\n * @inheritDoc\n */\nvar Hub = /** @class */ (function () {\n    /**\n     * Creates a new instance of the hub, will push one {@link Layer} into the\n     * internal stack on creation.\n     *\n     * @param client bound to the hub.\n     * @param scope bound to the hub.\n     * @param version number, higher number means higher priority.\n     */\n    function Hub(client, scope, _version) {\n        if (scope === void 0) { scope = new Scope(); }\n        if (_version === void 0) { _version = API_VERSION; }\n        this._version = _version;\n        /** Is a {@link Layer}[] containing the client and scope */\n        this._stack = [{}];\n        this.getStackTop().scope = scope;\n        this.bindClient(client);\n    }\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.isOlderThan = function (version) {\n        return this._version < version;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.bindClient = function (client) {\n        var top = this.getStackTop();\n        top.client = client;\n        if (client && client.setupIntegrations) {\n            client.setupIntegrations();\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.pushScope = function () {\n        // We want to clone the content of prev scope\n        var scope = Scope.clone(this.getScope());\n        this.getStack().push({\n            client: this.getClient(),\n            scope: scope,\n        });\n        return scope;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.popScope = function () {\n        if (this.getStack().length <= 1)\n            return false;\n        return !!this.getStack().pop();\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.withScope = function (callback) {\n        var scope = this.pushScope();\n        try {\n            callback(scope);\n        }\n        finally {\n            this.popScope();\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.getClient = function () {\n        return this.getStackTop().client;\n    };\n    /** Returns the scope of the top stack. */\n    Hub.prototype.getScope = function () {\n        return this.getStackTop().scope;\n    };\n    /** Returns the scope stack for domains or the process. */\n    Hub.prototype.getStack = function () {\n        return this._stack;\n    };\n    /** Returns the topmost scope layer in the order domain > local > process. */\n    Hub.prototype.getStackTop = function () {\n        return this._stack[this._stack.length - 1];\n    };\n    /**\n     * @inheritDoc\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n    Hub.prototype.captureException = function (exception, hint) {\n        var eventId = (this._lastEventId = uuid4());\n        var finalHint = hint;\n        // If there's no explicit hint provided, mimick the same thing that would happen\n        // in the minimal itself to create a consistent behavior.\n        // We don't do this in the client, as it's the lowest level API, and doing this,\n        // would prevent user from having full control over direct calls.\n        if (!hint) {\n            var syntheticException = void 0;\n            try {\n                throw new Error('Sentry syntheticException');\n            }\n            catch (exception) {\n                syntheticException = exception;\n            }\n            finalHint = {\n                originalException: exception,\n                syntheticException: syntheticException,\n            };\n        }\n        this._invokeClient('captureException', exception, __assign(__assign({}, finalHint), { event_id: eventId }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.captureMessage = function (message, level, hint) {\n        var eventId = (this._lastEventId = uuid4());\n        var finalHint = hint;\n        // If there's no explicit hint provided, mimick the same thing that would happen\n        // in the minimal itself to create a consistent behavior.\n        // We don't do this in the client, as it's the lowest level API, and doing this,\n        // would prevent user from having full control over direct calls.\n        if (!hint) {\n            var syntheticException = void 0;\n            try {\n                throw new Error(message);\n            }\n            catch (exception) {\n                syntheticException = exception;\n            }\n            finalHint = {\n                originalException: message,\n                syntheticException: syntheticException,\n            };\n        }\n        this._invokeClient('captureMessage', message, level, __assign(__assign({}, finalHint), { event_id: eventId }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.captureEvent = function (event, hint) {\n        var eventId = (this._lastEventId = uuid4());\n        this._invokeClient('captureEvent', event, __assign(__assign({}, hint), { event_id: eventId }));\n        return eventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.lastEventId = function () {\n        return this._lastEventId;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.addBreadcrumb = function (breadcrumb, hint) {\n        var _a = this.getStackTop(), scope = _a.scope, client = _a.client;\n        if (!scope || !client)\n            return;\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        var _b = (client.getOptions && client.getOptions()) || {}, _c = _b.beforeBreadcrumb, beforeBreadcrumb = _c === void 0 ? null : _c, _d = _b.maxBreadcrumbs, maxBreadcrumbs = _d === void 0 ? DEFAULT_BREADCRUMBS : _d;\n        if (maxBreadcrumbs <= 0)\n            return;\n        var timestamp = dateTimestampInSeconds();\n        var mergedBreadcrumb = __assign({ timestamp: timestamp }, breadcrumb);\n        var finalBreadcrumb = beforeBreadcrumb\n            ? consoleSandbox(function () { return beforeBreadcrumb(mergedBreadcrumb, hint); })\n            : mergedBreadcrumb;\n        if (finalBreadcrumb === null)\n            return;\n        scope.addBreadcrumb(finalBreadcrumb, Math.min(maxBreadcrumbs, MAX_BREADCRUMBS));\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setUser = function (user) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setUser(user);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setTags = function (tags) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setTags(tags);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setExtras = function (extras) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setExtras(extras);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setTag = function (key, value) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setTag(key, value);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.setExtra = function (key, extra) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setExtra(key, extra);\n    };\n    /**\n     * @inheritDoc\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Hub.prototype.setContext = function (name, context) {\n        var scope = this.getScope();\n        if (scope)\n            scope.setContext(name, context);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.configureScope = function (callback) {\n        var _a = this.getStackTop(), scope = _a.scope, client = _a.client;\n        if (scope && client) {\n            callback(scope);\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.run = function (callback) {\n        var oldHub = makeMain(this);\n        try {\n            callback(this);\n        }\n        finally {\n            makeMain(oldHub);\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.getIntegration = function (integration) {\n        var client = this.getClient();\n        if (!client)\n            return null;\n        try {\n            return client.getIntegration(integration);\n        }\n        catch (_oO) {\n            logger.warn(\"Cannot retrieve integration \" + integration.id + \" from the current Hub\");\n            return null;\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.startSpan = function (context) {\n        return this._callExtensionMethod('startSpan', context);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.startTransaction = function (context, customSamplingContext) {\n        return this._callExtensionMethod('startTransaction', context, customSamplingContext);\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.traceHeaders = function () {\n        return this._callExtensionMethod('traceHeaders');\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.startSession = function (context) {\n        // End existing session if there's one\n        this.endSession();\n        var _a = this.getStackTop(), scope = _a.scope, client = _a.client;\n        var _b = (client && client.getOptions()) || {}, release = _b.release, environment = _b.environment;\n        var session = new Session(__assign(__assign({ release: release,\n            environment: environment }, (scope && { user: scope.getUser() })), context));\n        if (scope) {\n            scope.setSession(session);\n        }\n        return session;\n    };\n    /**\n     * @inheritDoc\n     */\n    Hub.prototype.endSession = function () {\n        var _a = this.getStackTop(), scope = _a.scope, client = _a.client;\n        if (!scope)\n            return;\n        var session = scope.getSession && scope.getSession();\n        if (session) {\n            session.close();\n            if (client && client.captureSession) {\n                client.captureSession(session);\n            }\n            scope.setSession();\n        }\n    };\n    /**\n     * Internal helper function to call a method on the top client if it exists.\n     *\n     * @param method The method to call on the client.\n     * @param args Arguments to pass to the client function.\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Hub.prototype._invokeClient = function (method) {\n        var _a;\n        var args = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            args[_i - 1] = arguments[_i];\n        }\n        var _b = this.getStackTop(), scope = _b.scope, client = _b.client;\n        if (client && client[method]) {\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any\n            (_a = client)[method].apply(_a, __spread(args, [scope]));\n        }\n    };\n    /**\n     * Calls global extension method and binding current instance to the function call\n     */\n    // @ts-ignore Function lacks ending return statement and return type does not include 'undefined'. ts(2366)\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Hub.prototype._callExtensionMethod = function (method) {\n        var args = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            args[_i - 1] = arguments[_i];\n        }\n        var carrier = getMainCarrier();\n        var sentry = carrier.__SENTRY__;\n        if (sentry && sentry.extensions && typeof sentry.extensions[method] === 'function') {\n            return sentry.extensions[method].apply(this, args);\n        }\n        logger.warn(\"Extension method \" + method + \" couldn't be found, doing nothing.\");\n    };\n    return Hub;\n}());\nexport { Hub };\n/** Returns the global shim registry. */\nexport function getMainCarrier() {\n    var carrier = getGlobalObject();\n    carrier.__SENTRY__ = carrier.__SENTRY__ || {\n        extensions: {},\n        hub: undefined,\n    };\n    return carrier;\n}\n/**\n * Replaces the current main hub with the passed one on the global object\n *\n * @returns The old replaced hub\n */\nexport function makeMain(hub) {\n    var registry = getMainCarrier();\n    var oldHub = getHubFromCarrier(registry);\n    setHubOnCarrier(registry, hub);\n    return oldHub;\n}\n/**\n * Returns the default hub instance.\n *\n * If a hub is already registered in the global carrier but this module\n * contains a more recent version, it replaces the registered version.\n * Otherwise, the currently registered hub will be returned.\n */\nexport function getCurrentHub() {\n    // Get main carrier (global for every environment)\n    var registry = getMainCarrier();\n    // If there's no hub, or its an old API, assign a new one\n    if (!hasHubOnCarrier(registry) || getHubFromCarrier(registry).isOlderThan(API_VERSION)) {\n        setHubOnCarrier(registry, new Hub());\n    }\n    // Prefer domains over global if they are there (applicable only to Node environment)\n    if (isNodeEnv()) {\n        return getHubFromActiveDomain(registry);\n    }\n    // Return hub that lives on a global object\n    return getHubFromCarrier(registry);\n}\n/**\n * Returns the active domain, if one exists\n *\n * @returns The domain, or undefined if there is no active domain\n */\nexport function getActiveDomain() {\n    var sentry = getMainCarrier().__SENTRY__;\n    return sentry && sentry.extensions && sentry.extensions.domain && sentry.extensions.domain.active;\n}\n/**\n * Try to read the hub from an active domain, and fallback to the registry if one doesn't exist\n * @returns discovered hub\n */\nfunction getHubFromActiveDomain(registry) {\n    try {\n        var activeDomain = getActiveDomain();\n        // If there's no active domain, just return global hub\n        if (!activeDomain) {\n            return getHubFromCarrier(registry);\n        }\n        // If there's no hub on current domain, or it's an old API, assign a new one\n        if (!hasHubOnCarrier(activeDomain) || getHubFromCarrier(activeDomain).isOlderThan(API_VERSION)) {\n            var registryHubTopStack = getHubFromCarrier(registry).getStackTop();\n            setHubOnCarrier(activeDomain, new Hub(registryHubTopStack.client, Scope.clone(registryHubTopStack.scope)));\n        }\n        // Return hub that lives on a domain\n        return getHubFromCarrier(activeDomain);\n    }\n    catch (_Oo) {\n        // Return hub that lives on a global object\n        return getHubFromCarrier(registry);\n    }\n}\n/**\n * This will tell whether a carrier has a hub on it or not\n * @param carrier object\n */\nfunction hasHubOnCarrier(carrier) {\n    return !!(carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub);\n}\n/**\n * This will create a new {@link Hub} and add to the passed object on\n * __SENTRY__.hub.\n * @param carrier object\n * @hidden\n */\nexport function getHubFromCarrier(carrier) {\n    if (carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub)\n        return carrier.__SENTRY__.hub;\n    carrier.__SENTRY__ = carrier.__SENTRY__ || {};\n    carrier.__SENTRY__.hub = new Hub();\n    return carrier.__SENTRY__.hub;\n}\n/**\n * This will set passed {@link Hub} on the passed object's __SENTRY__.hub attribute\n * @param carrier object\n * @param hub Hub\n */\nexport function setHubOnCarrier(carrier, hub) {\n    if (!carrier)\n        return false;\n    carrier.__SENTRY__ = carrier.__SENTRY__ || {};\n    carrier.__SENTRY__.hub = hub;\n    return true;\n}\n//# sourceMappingURL=hub.js.map","import { __assign, __read, __spread } from \"tslib\";\nimport { dateTimestampInSeconds, getGlobalObject, isPlainObject, isThenable, SyncPromise } from '@sentry/utils';\n/**\n * Holds additional event information. {@link Scope.applyToEvent} will be\n * called by the client before an event will be sent.\n */\nvar Scope = /** @class */ (function () {\n    function Scope() {\n        /** Flag if notifiying is happening. */\n        this._notifyingListeners = false;\n        /** Callback for client to receive scope changes. */\n        this._scopeListeners = [];\n        /** Callback list that will be called after {@link applyToEvent}. */\n        this._eventProcessors = [];\n        /** Array of breadcrumbs. */\n        this._breadcrumbs = [];\n        /** User */\n        this._user = {};\n        /** Tags */\n        this._tags = {};\n        /** Extra */\n        this._extra = {};\n        /** Contexts */\n        this._contexts = {};\n    }\n    /**\n     * Inherit values from the parent scope.\n     * @param scope to clone.\n     */\n    Scope.clone = function (scope) {\n        var newScope = new Scope();\n        if (scope) {\n            newScope._breadcrumbs = __spread(scope._breadcrumbs);\n            newScope._tags = __assign({}, scope._tags);\n            newScope._extra = __assign({}, scope._extra);\n            newScope._contexts = __assign({}, scope._contexts);\n            newScope._user = scope._user;\n            newScope._level = scope._level;\n            newScope._span = scope._span;\n            newScope._session = scope._session;\n            newScope._transactionName = scope._transactionName;\n            newScope._fingerprint = scope._fingerprint;\n            newScope._eventProcessors = __spread(scope._eventProcessors);\n        }\n        return newScope;\n    };\n    /**\n     * Add internal on change listener. Used for sub SDKs that need to store the scope.\n     * @hidden\n     */\n    Scope.prototype.addScopeListener = function (callback) {\n        this._scopeListeners.push(callback);\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.addEventProcessor = function (callback) {\n        this._eventProcessors.push(callback);\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setUser = function (user) {\n        this._user = user || {};\n        if (this._session) {\n            this._session.update({ user: user });\n        }\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.getUser = function () {\n        return this._user;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setTags = function (tags) {\n        this._tags = __assign(__assign({}, this._tags), tags);\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setTag = function (key, value) {\n        var _a;\n        this._tags = __assign(__assign({}, this._tags), (_a = {}, _a[key] = value, _a));\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setExtras = function (extras) {\n        this._extra = __assign(__assign({}, this._extra), extras);\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setExtra = function (key, extra) {\n        var _a;\n        this._extra = __assign(__assign({}, this._extra), (_a = {}, _a[key] = extra, _a));\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setFingerprint = function (fingerprint) {\n        this._fingerprint = fingerprint;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setLevel = function (level) {\n        this._level = level;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setTransactionName = function (name) {\n        this._transactionName = name;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * Can be removed in major version.\n     * @deprecated in favor of {@link this.setTransactionName}\n     */\n    Scope.prototype.setTransaction = function (name) {\n        return this.setTransactionName(name);\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setContext = function (key, context) {\n        var _a;\n        if (context === null) {\n            // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n            delete this._contexts[key];\n        }\n        else {\n            this._contexts = __assign(__assign({}, this._contexts), (_a = {}, _a[key] = context, _a));\n        }\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setSpan = function (span) {\n        this._span = span;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.getSpan = function () {\n        return this._span;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.getTransaction = function () {\n        var _a, _b, _c, _d;\n        // often, this span will be a transaction, but it's not guaranteed to be\n        var span = this.getSpan();\n        // try it the new way first\n        if ((_a = span) === null || _a === void 0 ? void 0 : _a.transaction) {\n            return (_b = span) === null || _b === void 0 ? void 0 : _b.transaction;\n        }\n        // fallback to the old way (known bug: this only finds transactions with sampled = true)\n        if ((_d = (_c = span) === null || _c === void 0 ? void 0 : _c.spanRecorder) === null || _d === void 0 ? void 0 : _d.spans[0]) {\n            return span.spanRecorder.spans[0];\n        }\n        // neither way found a transaction\n        return undefined;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.setSession = function (session) {\n        if (!session) {\n            delete this._session;\n        }\n        else {\n            this._session = session;\n        }\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.getSession = function () {\n        return this._session;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.update = function (captureContext) {\n        if (!captureContext) {\n            return this;\n        }\n        if (typeof captureContext === 'function') {\n            var updatedScope = captureContext(this);\n            return updatedScope instanceof Scope ? updatedScope : this;\n        }\n        if (captureContext instanceof Scope) {\n            this._tags = __assign(__assign({}, this._tags), captureContext._tags);\n            this._extra = __assign(__assign({}, this._extra), captureContext._extra);\n            this._contexts = __assign(__assign({}, this._contexts), captureContext._contexts);\n            if (captureContext._user && Object.keys(captureContext._user).length) {\n                this._user = captureContext._user;\n            }\n            if (captureContext._level) {\n                this._level = captureContext._level;\n            }\n            if (captureContext._fingerprint) {\n                this._fingerprint = captureContext._fingerprint;\n            }\n        }\n        else if (isPlainObject(captureContext)) {\n            // eslint-disable-next-line no-param-reassign\n            captureContext = captureContext;\n            this._tags = __assign(__assign({}, this._tags), captureContext.tags);\n            this._extra = __assign(__assign({}, this._extra), captureContext.extra);\n            this._contexts = __assign(__assign({}, this._contexts), captureContext.contexts);\n            if (captureContext.user) {\n                this._user = captureContext.user;\n            }\n            if (captureContext.level) {\n                this._level = captureContext.level;\n            }\n            if (captureContext.fingerprint) {\n                this._fingerprint = captureContext.fingerprint;\n            }\n        }\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.clear = function () {\n        this._breadcrumbs = [];\n        this._tags = {};\n        this._extra = {};\n        this._user = {};\n        this._contexts = {};\n        this._level = undefined;\n        this._transactionName = undefined;\n        this._fingerprint = undefined;\n        this._span = undefined;\n        this._session = undefined;\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.addBreadcrumb = function (breadcrumb, maxBreadcrumbs) {\n        var mergedBreadcrumb = __assign({ timestamp: dateTimestampInSeconds() }, breadcrumb);\n        this._breadcrumbs =\n            maxBreadcrumbs !== undefined && maxBreadcrumbs >= 0\n                ? __spread(this._breadcrumbs, [mergedBreadcrumb]).slice(-maxBreadcrumbs)\n                : __spread(this._breadcrumbs, [mergedBreadcrumb]);\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * @inheritDoc\n     */\n    Scope.prototype.clearBreadcrumbs = function () {\n        this._breadcrumbs = [];\n        this._notifyScopeListeners();\n        return this;\n    };\n    /**\n     * Applies the current context and fingerprint to the event.\n     * Note that breadcrumbs will be added by the client.\n     * Also if the event has already breadcrumbs on it, we do not merge them.\n     * @param event Event\n     * @param hint May contain additional informartion about the original exception.\n     * @hidden\n     */\n    Scope.prototype.applyToEvent = function (event, hint) {\n        var _a;\n        if (this._extra && Object.keys(this._extra).length) {\n            event.extra = __assign(__assign({}, this._extra), event.extra);\n        }\n        if (this._tags && Object.keys(this._tags).length) {\n            event.tags = __assign(__assign({}, this._tags), event.tags);\n        }\n        if (this._user && Object.keys(this._user).length) {\n            event.user = __assign(__assign({}, this._user), event.user);\n        }\n        if (this._contexts && Object.keys(this._contexts).length) {\n            event.contexts = __assign(__assign({}, this._contexts), event.contexts);\n        }\n        if (this._level) {\n            event.level = this._level;\n        }\n        if (this._transactionName) {\n            event.transaction = this._transactionName;\n        }\n        // We want to set the trace context for normal events only if there isn't already\n        // a trace context on the event. There is a product feature in place where we link\n        // errors with transaction and it relys on that.\n        if (this._span) {\n            event.contexts = __assign({ trace: this._span.getTraceContext() }, event.contexts);\n            var transactionName = (_a = this._span.transaction) === null || _a === void 0 ? void 0 : _a.name;\n            if (transactionName) {\n                event.tags = __assign({ transaction: transactionName }, event.tags);\n            }\n        }\n        this._applyFingerprint(event);\n        event.breadcrumbs = __spread((event.breadcrumbs || []), this._breadcrumbs);\n        event.breadcrumbs = event.breadcrumbs.length > 0 ? event.breadcrumbs : undefined;\n        return this._notifyEventProcessors(__spread(getGlobalEventProcessors(), this._eventProcessors), event, hint);\n    };\n    /**\n     * This will be called after {@link applyToEvent} is finished.\n     */\n    Scope.prototype._notifyEventProcessors = function (processors, event, hint, index) {\n        var _this = this;\n        if (index === void 0) { index = 0; }\n        return new SyncPromise(function (resolve, reject) {\n            var processor = processors[index];\n            if (event === null || typeof processor !== 'function') {\n                resolve(event);\n            }\n            else {\n                var result = processor(__assign({}, event), hint);\n                if (isThenable(result)) {\n                    result\n                        .then(function (final) { return _this._notifyEventProcessors(processors, final, hint, index + 1).then(resolve); })\n                        .then(null, reject);\n                }\n                else {\n                    _this._notifyEventProcessors(processors, result, hint, index + 1)\n                        .then(resolve)\n                        .then(null, reject);\n                }\n            }\n        });\n    };\n    /**\n     * This will be called on every set call.\n     */\n    Scope.prototype._notifyScopeListeners = function () {\n        var _this = this;\n        // We need this check for this._notifyingListeners to be able to work on scope during updates\n        // If this check is not here we'll produce endless recursion when something is done with the scope\n        // during the callback.\n        if (!this._notifyingListeners) {\n            this._notifyingListeners = true;\n            this._scopeListeners.forEach(function (callback) {\n                callback(_this);\n            });\n            this._notifyingListeners = false;\n        }\n    };\n    /**\n     * Applies fingerprint from the scope to the event if there's one,\n     * uses message if there's one instead or get rid of empty fingerprint\n     */\n    Scope.prototype._applyFingerprint = function (event) {\n        // Make sure it's an array first and we actually have something in place\n        event.fingerprint = event.fingerprint\n            ? Array.isArray(event.fingerprint)\n                ? event.fingerprint\n                : [event.fingerprint]\n            : [];\n        // If we have something on the scope, then merge it with event\n        if (this._fingerprint) {\n            event.fingerprint = event.fingerprint.concat(this._fingerprint);\n        }\n        // If we have no data at all, remove empty array default\n        if (event.fingerprint && !event.fingerprint.length) {\n            delete event.fingerprint;\n        }\n    };\n    return Scope;\n}());\nexport { Scope };\n/**\n * Retruns the global event processors.\n */\nfunction getGlobalEventProcessors() {\n    /* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access  */\n    var global = getGlobalObject();\n    global.__SENTRY__ = global.__SENTRY__ || {};\n    global.__SENTRY__.globalEventProcessors = global.__SENTRY__.globalEventProcessors || [];\n    return global.__SENTRY__.globalEventProcessors;\n    /* eslint-enable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access */\n}\n/**\n * Add a EventProcessor to be kept globally.\n * @param callback EventProcessor to add\n */\nexport function addGlobalEventProcessor(callback) {\n    getGlobalEventProcessors().push(callback);\n}\n//# sourceMappingURL=scope.js.map","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n"],"names":["Session","context","this","errors","sid","timestamp","Date","now","started","duration","status","Ok","update","prototype","user","ip_address","ipAddress","did","id","email","username","length","release","environment","userAgent","close","Exited","toJSON","init","toISOString","undefined","attrs","user_agent","API_VERSION","DEFAULT_BREADCRUMBS","MAX_BREADCRUMBS","Hub","client","scope","_version","_stack","getStackTop","bindClient","isOlderThan","version","top","setupIntegrations","pushScope","clone","getScope","getStack","push","getClient","popScope","pop","withScope","callback","captureException","exception","hint","eventId","_lastEventId","finalHint","syntheticException","Error","originalException","_invokeClient","event_id","captureMessage","message","level","captureEvent","event","lastEventId","addBreadcrumb","breadcrumb","_a","_b","getOptions","_c","beforeBreadcrumb","_d","maxBreadcrumbs","mergedBreadcrumb","finalBreadcrumb","Math","min","setUser","setTags","tags","setExtras","extras","setTag","key","value","setExtra","extra","setContext","name","configureScope","run","oldHub","makeMain","getIntegration","integration","_oO","logger","warn","startSpan","_callExtensionMethod","startTransaction","customSamplingContext","traceHeaders","startSession","endSession","session","getUser","setSession","getSession","captureSession","method","args","_i","arguments","apply","carrier","getMainCarrier","sentry","__SENTRY__","extensions","hub","registry","getHubFromCarrier","setHubOnCarrier","getCurrentHub","hasHubOnCarrier","getHubFromActiveDomain","getActiveDomain","domain","active","activeDomain","registryHubTopStack","_Oo","Scope","_notifyingListeners","_scopeListeners","_eventProcessors","_breadcrumbs","_user","_tags","_extra","_contexts","newScope","_level","_span","_session","_transactionName","_fingerprint","addScopeListener","addEventProcessor","_notifyScopeListeners","setFingerprint","fingerprint","setLevel","setTransactionName","setTransaction","setSpan","span","getSpan","getTransaction","transaction","spanRecorder","spans","captureContext","updatedScope","Object","keys","contexts","clear","slice","clearBreadcrumbs","applyToEvent","trace","getTraceContext","transactionName","_applyFingerprint","breadcrumbs","_notifyEventProcessors","getGlobalEventProcessors","processors","index","_this","resolve","reject","processor","result","then","final","forEach","Array","isArray","concat","global","globalEventProcessors","addGlobalEventProcessor","__assign","assign","t","s","i","n","p","hasOwnProperty","call","__read","o","m","Symbol","iterator","r","e","ar","next","done","error","__spread"],"sourceRoot":""}