{"version":3,"file":"9586.js","mappings":"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","sources":["webpack://suicidegirls/./node_modules/@sentry/browser/esm/stack-parsers.js","webpack://suicidegirls/./node_modules/@sentry/browser/esm/eventbuilder.js","webpack://suicidegirls/./node_modules/@sentry/browser/esm/transports/utils.js","webpack://suicidegirls/./node_modules/@sentry/browser/esm/flags.js","webpack://suicidegirls/./node_modules/@sentry/browser/esm/transports/base.js","webpack://suicidegirls/./node_modules/@sentry/browser/esm/transports/fetch.js","webpack://suicidegirls/./node_modules/@sentry/browser/esm/transports/xhr.js","webpack://suicidegirls/./node_modules/@sentry/browser/esm/backend.js","webpack://suicidegirls/./node_modules/@sentry/browser/esm/transports/new-fetch.js","webpack://suicidegirls/./node_modules/@sentry/browser/esm/transports/new-xhr.js","webpack://suicidegirls/./node_modules/@sentry/browser/esm/helpers.js","webpack://suicidegirls/./node_modules/@sentry/browser/esm/integrations/breadcrumbs.js","webpack://suicidegirls/./node_modules/@sentry/browser/esm/client.js","webpack://suicidegirls/./node_modules/@sentry/browser/esm/integrations/trycatch.js","webpack://suicidegirls/./node_modules/@sentry/browser/esm/integrations/globalhandlers.js","webpack://suicidegirls/./node_modules/@sentry/browser/esm/integrations/linkederrors.js","webpack://suicidegirls/./node_modules/@sentry/browser/esm/integrations/dedupe.js","webpack://suicidegirls/./node_modules/@sentry/browser/esm/integrations/useragent.js","webpack://suicidegirls/./node_modules/@sentry/browser/esm/sdk.js"],"sourcesContent":["import { __read } from \"tslib\";\n// global reference to slice\nvar UNKNOWN_FUNCTION = '?';\nvar OPERA10_PRIORITY = 10;\nvar OPERA11_PRIORITY = 20;\nvar CHROME_PRIORITY = 30;\nvar WINJS_PRIORITY = 40;\nvar GECKO_PRIORITY = 50;\nfunction createFrame(filename, func, lineno, colno) {\n    var frame = {\n        filename: filename,\n        function: func,\n        // All browser frames are considered in_app\n        in_app: true,\n    };\n    if (lineno !== undefined) {\n        frame.lineno = lineno;\n    }\n    if (colno !== undefined) {\n        frame.colno = colno;\n    }\n    return frame;\n}\n// Chromium based browsers: Chrome, Brave, new Opera, new Edge\nvar chromeRegex = /^\\s*at (?:(.*?) ?\\((?:address at )?)?((?:file|https?|blob|chrome-extension|address|native|eval|webpack|<anonymous>|[-a-z]+:|.*bundle|\\/).*?)(?::(\\d+))?(?::(\\d+))?\\)?\\s*$/i;\nvar chromeEvalRegex = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/;\nvar chrome = function (line) {\n    var parts = chromeRegex.exec(line);\n    if (parts) {\n        var isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n        if (isEval) {\n            var subMatch = chromeEvalRegex.exec(parts[2]);\n            if (subMatch) {\n                // throw out eval line/column and use top-most line/column number\n                parts[2] = subMatch[1]; // url\n                parts[3] = subMatch[2]; // line\n                parts[4] = subMatch[3]; // column\n            }\n        }\n        // Kamil: One more hack won't hurt us right? Understanding and adding more rules on top of these regexps right now\n        // would be way too time consuming. (TODO: Rewrite whole RegExp to be more readable)\n        var _a = __read(extractSafariExtensionDetails(parts[1] || UNKNOWN_FUNCTION, parts[2]), 2), func = _a[0], filename = _a[1];\n        return createFrame(filename, func, parts[3] ? +parts[3] : undefined, parts[4] ? +parts[4] : undefined);\n    }\n    return;\n};\nexport var chromeStackParser = [CHROME_PRIORITY, chrome];\n// gecko regex: `(?:bundle|\\d+\\.js)`: `bundle` is for react native, `\\d+\\.js` also but specifically for ram bundles because it\n// generates filenames without a prefix like `file://` the filenames in the stacktrace are just 42.js\n// We need this specific case for now because we want no other regex to match.\nvar geckoREgex = /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)?((?:file|https?|blob|chrome|webpack|resource|moz-extension|capacitor).*?:\\/.*?|\\[native code\\]|[^@]*(?:bundle|\\d+\\.js)|\\/[\\w\\-. /=]+)(?::(\\d+))?(?::(\\d+))?\\s*$/i;\nvar geckoEvalRegex = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\nvar gecko = function (line) {\n    var _a;\n    var parts = geckoREgex.exec(line);\n    if (parts) {\n        var isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n        if (isEval) {\n            var subMatch = geckoEvalRegex.exec(parts[3]);\n            if (subMatch) {\n                // throw out eval line/column and use top-most line number\n                parts[1] = parts[1] || 'eval';\n                parts[3] = subMatch[1];\n                parts[4] = subMatch[2];\n                parts[5] = ''; // no column when eval\n            }\n        }\n        var filename = parts[3];\n        var func = parts[1] || UNKNOWN_FUNCTION;\n        _a = __read(extractSafariExtensionDetails(func, filename), 2), func = _a[0], filename = _a[1];\n        return createFrame(filename, func, parts[4] ? +parts[4] : undefined, parts[5] ? +parts[5] : undefined);\n    }\n    return;\n};\nexport var geckoStackParser = [GECKO_PRIORITY, gecko];\nvar winjsRegex = /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i;\nvar winjs = function (line) {\n    var parts = winjsRegex.exec(line);\n    return parts\n        ? createFrame(parts[2], parts[1] || UNKNOWN_FUNCTION, +parts[3], parts[4] ? +parts[4] : undefined)\n        : undefined;\n};\nexport var winjsStackParser = [WINJS_PRIORITY, winjs];\nvar opera10Regex = / line (\\d+).*script (?:in )?(\\S+)(?:: in function (\\S+))?$/i;\nvar opera10 = function (line) {\n    var parts = opera10Regex.exec(line);\n    return parts ? createFrame(parts[2], parts[3] || UNKNOWN_FUNCTION, +parts[1]) : undefined;\n};\nexport var opera10StackParser = [OPERA10_PRIORITY, opera10];\nvar opera11Regex = / line (\\d+), column (\\d+)\\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\\(.*\\))? in (.*):\\s*$/i;\nvar opera11 = function (line) {\n    var parts = opera11Regex.exec(line);\n    return parts ? createFrame(parts[5], parts[3] || parts[4] || UNKNOWN_FUNCTION, +parts[1], +parts[2]) : undefined;\n};\nexport var opera11StackParser = [OPERA11_PRIORITY, opera11];\n/**\n * Safari web extensions, starting version unknown, can produce \"frames-only\" stacktraces.\n * What it means, is that instead of format like:\n *\n * Error: wat\n *   at function@url:row:col\n *   at function@url:row:col\n *   at function@url:row:col\n *\n * it produces something like:\n *\n *   function@url:row:col\n *   function@url:row:col\n *   function@url:row:col\n *\n * Because of that, it won't be captured by `chrome` RegExp and will fall into `Gecko` branch.\n * This function is extracted so that we can use it in both places without duplicating the logic.\n * Unfortunately \"just\" changing RegExp is too complicated now and making it pass all tests\n * and fix this case seems like an impossible, or at least way too time-consuming task.\n */\nvar extractSafariExtensionDetails = function (func, filename) {\n    var isSafariExtension = func.indexOf('safari-extension') !== -1;\n    var isSafariWebExtension = func.indexOf('safari-web-extension') !== -1;\n    return isSafariExtension || isSafariWebExtension\n        ? [\n            func.indexOf('@') !== -1 ? func.split('@')[0] : UNKNOWN_FUNCTION,\n            isSafariExtension ? \"safari-extension:\" + filename : \"safari-web-extension:\" + filename,\n        ]\n        : [func, filename];\n};\n//# sourceMappingURL=stack-parsers.js.map","import { __assign } from \"tslib\";\nimport { Severity } from '@sentry/types';\nimport { addExceptionMechanism, addExceptionTypeValue, createStackParser, extractExceptionKeysForMessage, isDOMError, isDOMException, isError, isErrorEvent, isEvent, isPlainObject, normalizeToSize, resolvedSyncPromise, } from '@sentry/utils';\nimport { chromeStackParser, geckoStackParser, opera10StackParser, opera11StackParser, winjsStackParser, } from './stack-parsers';\n/**\n * This function creates an exception from an TraceKitStackTrace\n * @param stacktrace TraceKitStackTrace that will be converted to an exception\n * @hidden\n */\nexport function exceptionFromError(ex) {\n    // Get the frames first since Opera can lose the stack if we touch anything else first\n    var frames = parseStackFrames(ex);\n    var exception = {\n        type: ex && ex.name,\n        value: extractMessage(ex),\n    };\n    if (frames.length) {\n        exception.stacktrace = { frames: frames };\n    }\n    if (exception.type === undefined && exception.value === '') {\n        exception.value = 'Unrecoverable error caught';\n    }\n    return exception;\n}\n/**\n * @hidden\n */\nexport function eventFromPlainObject(exception, syntheticException, isUnhandledRejection) {\n    var event = {\n        exception: {\n            values: [\n                {\n                    type: isEvent(exception) ? exception.constructor.name : isUnhandledRejection ? 'UnhandledRejection' : 'Error',\n                    value: \"Non-Error \" + (isUnhandledRejection ? 'promise rejection' : 'exception') + \" captured with keys: \" + extractExceptionKeysForMessage(exception),\n                },\n            ],\n        },\n        extra: {\n            __serialized__: normalizeToSize(exception),\n        },\n    };\n    if (syntheticException) {\n        var frames_1 = parseStackFrames(syntheticException);\n        if (frames_1.length) {\n            event.stacktrace = { frames: frames_1 };\n        }\n    }\n    return event;\n}\n/**\n * @hidden\n */\nexport function eventFromError(ex) {\n    return {\n        exception: {\n            values: [exceptionFromError(ex)],\n        },\n    };\n}\n/** Parses stack frames from an error */\nexport function parseStackFrames(ex) {\n    // Access and store the stacktrace property before doing ANYTHING\n    // else to it because Opera is not very good at providing it\n    // reliably in other circumstances.\n    var stacktrace = ex.stacktrace || ex.stack || '';\n    var popSize = getPopSize(ex);\n    try {\n        return createStackParser(opera10StackParser, opera11StackParser, chromeStackParser, winjsStackParser, geckoStackParser)(stacktrace, popSize);\n    }\n    catch (e) {\n        // no-empty\n    }\n    return [];\n}\n// Based on our own mapping pattern - https://github.com/getsentry/sentry/blob/9f08305e09866c8bd6d0c24f5b0aabdd7dd6c59c/src/sentry/lang/javascript/errormapping.py#L83-L108\nvar reactMinifiedRegexp = /Minified React error #\\d+;/i;\nfunction getPopSize(ex) {\n    if (ex) {\n        if (typeof ex.framesToPop === 'number') {\n            return ex.framesToPop;\n        }\n        if (reactMinifiedRegexp.test(ex.message)) {\n            return 1;\n        }\n    }\n    return 0;\n}\n/**\n * There are cases where stacktrace.message is an Event object\n * https://github.com/getsentry/sentry-javascript/issues/1949\n * In this specific case we try to extract stacktrace.message.error.message\n */\nfunction extractMessage(ex) {\n    var message = ex && ex.message;\n    if (!message) {\n        return 'No error message';\n    }\n    if (message.error && typeof message.error.message === 'string') {\n        return message.error.message;\n    }\n    return message;\n}\n/**\n * Creates an {@link Event} from all inputs to `captureException` and non-primitive inputs to `captureMessage`.\n * @hidden\n */\nexport function eventFromException(exception, hint, attachStacktrace) {\n    var syntheticException = (hint && hint.syntheticException) || undefined;\n    var event = eventFromUnknownInput(exception, syntheticException, attachStacktrace);\n    addExceptionMechanism(event); // defaults to { type: 'generic', handled: true }\n    event.level = Severity.Error;\n    if (hint && hint.event_id) {\n        event.event_id = hint.event_id;\n    }\n    return resolvedSyncPromise(event);\n}\n/**\n * Builds and Event from a Message\n * @hidden\n */\nexport function eventFromMessage(message, level, hint, attachStacktrace) {\n    if (level === void 0) { level = Severity.Info; }\n    var syntheticException = (hint && hint.syntheticException) || undefined;\n    var event = eventFromString(message, syntheticException, attachStacktrace);\n    event.level = level;\n    if (hint && hint.event_id) {\n        event.event_id = hint.event_id;\n    }\n    return resolvedSyncPromise(event);\n}\n/**\n * @hidden\n */\nexport function eventFromUnknownInput(exception, syntheticException, attachStacktrace, isUnhandledRejection) {\n    var event;\n    if (isErrorEvent(exception) && exception.error) {\n        // If it is an ErrorEvent with `error` property, extract it to get actual Error\n        var errorEvent = exception;\n        return eventFromError(errorEvent.error);\n    }\n    // If it is a `DOMError` (which is a legacy API, but still supported in some browsers) then we just extract the name\n    // and message, as it doesn't provide anything else. According to the spec, all `DOMExceptions` should also be\n    // `Error`s, but that's not the case in IE11, so in that case we treat it the same as we do a `DOMError`.\n    //\n    // https://developer.mozilla.org/en-US/docs/Web/API/DOMError\n    // https://developer.mozilla.org/en-US/docs/Web/API/DOMException\n    // https://webidl.spec.whatwg.org/#es-DOMException-specialness\n    if (isDOMError(exception) || isDOMException(exception)) {\n        var domException = exception;\n        if ('stack' in exception) {\n            event = eventFromError(exception);\n        }\n        else {\n            var name_1 = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException');\n            var message = domException.message ? name_1 + \": \" + domException.message : name_1;\n            event = eventFromString(message, syntheticException, attachStacktrace);\n            addExceptionTypeValue(event, message);\n        }\n        if ('code' in domException) {\n            event.tags = __assign(__assign({}, event.tags), { 'DOMException.code': \"\" + domException.code });\n        }\n        return event;\n    }\n    if (isError(exception)) {\n        // we have a real Error object, do nothing\n        return eventFromError(exception);\n    }\n    if (isPlainObject(exception) || isEvent(exception)) {\n        // If it's a plain object or an instance of `Event` (the built-in JS kind, not this SDK's `Event` type), serialize\n        // it manually. This will allow us to group events based on top-level keys which is much better than creating a new\n        // group on any key/value change.\n        var objectException = exception;\n        event = eventFromPlainObject(objectException, syntheticException, isUnhandledRejection);\n        addExceptionMechanism(event, {\n            synthetic: true,\n        });\n        return event;\n    }\n    // If none of previous checks were valid, then it means that it's not:\n    // - an instance of DOMError\n    // - an instance of DOMException\n    // - an instance of Event\n    // - an instance of Error\n    // - a valid ErrorEvent (one with an error property)\n    // - a plain Object\n    //\n    // So bail out and capture it as a simple message:\n    event = eventFromString(exception, syntheticException, attachStacktrace);\n    addExceptionTypeValue(event, \"\" + exception, undefined);\n    addExceptionMechanism(event, {\n        synthetic: true,\n    });\n    return event;\n}\n/**\n * @hidden\n */\nexport function eventFromString(input, syntheticException, attachStacktrace) {\n    var event = {\n        message: input,\n    };\n    if (attachStacktrace && syntheticException) {\n        var frames_2 = parseStackFrames(syntheticException);\n        if (frames_2.length) {\n            event.stacktrace = { frames: frames_2 };\n        }\n    }\n    return event;\n}\n//# sourceMappingURL=eventbuilder.js.map","import { forget, getGlobalObject, isNativeFetch, logger, supportsFetch } from '@sentry/utils';\nimport { IS_DEBUG_BUILD } from '../flags';\nvar global = getGlobalObject();\nvar cachedFetchImpl;\n/**\n * A special usecase for incorrectly wrapped Fetch APIs in conjunction with ad-blockers.\n * Whenever someone wraps the Fetch API and returns the wrong promise chain,\n * this chain becomes orphaned and there is no possible way to capture it's rejections\n * other than allowing it bubble up to this very handler. eg.\n *\n * const f = window.fetch;\n * window.fetch = function () {\n *   const p = f.apply(this, arguments);\n *\n *   p.then(function() {\n *     console.log('hi.');\n *   });\n *\n *   return p;\n * }\n *\n * `p.then(function () { ... })` is producing a completely separate promise chain,\n * however, what's returned is `p` - the result of original `fetch` call.\n *\n * This mean, that whenever we use the Fetch API to send our own requests, _and_\n * some ad-blocker blocks it, this orphaned chain will _always_ reject,\n * effectively causing another event to be captured.\n * This makes a whole process become an infinite loop, which we need to somehow\n * deal with, and break it in one way or another.\n *\n * To deal with this issue, we are making sure that we _always_ use the real\n * browser Fetch API, instead of relying on what `window.fetch` exposes.\n * The only downside to this would be missing our own requests as breadcrumbs,\n * but because we are already not doing this, it should be just fine.\n *\n * Possible failed fetch error messages per-browser:\n *\n * Chrome:  Failed to fetch\n * Edge:    Failed to Fetch\n * Firefox: NetworkError when attempting to fetch resource\n * Safari:  resource blocked by content blocker\n */\nexport function getNativeFetchImplementation() {\n    if (cachedFetchImpl) {\n        return cachedFetchImpl;\n    }\n    /* eslint-disable @typescript-eslint/unbound-method */\n    // Fast path to avoid DOM I/O\n    if (isNativeFetch(global.fetch)) {\n        return (cachedFetchImpl = global.fetch.bind(global));\n    }\n    var document = global.document;\n    var fetchImpl = global.fetch;\n    // eslint-disable-next-line deprecation/deprecation\n    if (document && typeof document.createElement === 'function') {\n        try {\n            var sandbox = document.createElement('iframe');\n            sandbox.hidden = true;\n            document.head.appendChild(sandbox);\n            var contentWindow = sandbox.contentWindow;\n            if (contentWindow && contentWindow.fetch) {\n                fetchImpl = contentWindow.fetch;\n            }\n            document.head.removeChild(sandbox);\n        }\n        catch (e) {\n            IS_DEBUG_BUILD &&\n                logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', e);\n        }\n    }\n    return (cachedFetchImpl = fetchImpl.bind(global));\n    /* eslint-enable @typescript-eslint/unbound-method */\n}\n/**\n * Sends sdk client report using sendBeacon or fetch as a fallback if available\n *\n * @param url report endpoint\n * @param body report payload\n */\nexport function sendReport(url, body) {\n    var isRealNavigator = Object.prototype.toString.call(global && global.navigator) === '[object Navigator]';\n    var hasSendBeacon = isRealNavigator && typeof global.navigator.sendBeacon === 'function';\n    if (hasSendBeacon) {\n        // Prevent illegal invocations - https://xgwang.me/posts/you-may-not-know-beacon/#it-may-throw-error%2C-be-sure-to-catch\n        var sendBeacon = global.navigator.sendBeacon.bind(global.navigator);\n        return sendBeacon(url, body);\n    }\n    if (supportsFetch()) {\n        var fetch_1 = getNativeFetchImplementation();\n        return forget(fetch_1(url, {\n            body: body,\n            method: 'POST',\n            credentials: 'omit',\n            keepalive: true,\n        }));\n    }\n}\n//# sourceMappingURL=utils.js.map","/*\n * This file defines flags and constants that can be modified during compile time in order to facilitate tree shaking\n * for users.\n *\n * Debug flags need to be declared in each package individually and must not be imported across package boundaries,\n * because some build tools have trouble tree-shaking imported guards.\n *\n * As a convention, we define debug flags in a `flags.ts` file in the root of a package's `src` folder.\n *\n * Debug flag files will contain \"magic strings\" like `__SENTRY_DEBUG__` that may get replaced with actual values during\n * our, or the user's build process. Take care when introducing new flags - they must not throw if they are not\n * replaced.\n */\n/** Flag that is true for debug builds, false otherwise. */\nexport var IS_DEBUG_BUILD = typeof __SENTRY_DEBUG__ === 'undefined' ? true : __SENTRY_DEBUG__;\n//# sourceMappingURL=flags.js.map","import { __read } from \"tslib\";\nimport { eventToSentryRequest, getEnvelopeEndpointWithUrlEncodedAuth, getStoreEndpointWithUrlEncodedAuth, initAPIDetails, sessionToSentryRequest, } from '@sentry/core';\nimport { createClientReportEnvelope, disabledUntil, dsnToString, eventStatusFromHttpCode, getGlobalObject, isRateLimited, logger, makePromiseBuffer, serializeEnvelope, updateRateLimits, } from '@sentry/utils';\nimport { IS_DEBUG_BUILD } from '../flags';\nimport { sendReport } from './utils';\nfunction requestTypeToCategory(ty) {\n    var tyStr = ty;\n    return tyStr === 'event' ? 'error' : tyStr;\n}\nvar global = getGlobalObject();\n/** Base Transport class implementation */\nvar BaseTransport = /** @class */ (function () {\n    function BaseTransport(options) {\n        var _this = this;\n        this.options = options;\n        /** A simple buffer holding all requests. */\n        this._buffer = makePromiseBuffer(30);\n        /** Locks transport after receiving rate limits in a response */\n        this._rateLimits = {};\n        this._outcomes = {};\n        this._api = initAPIDetails(options.dsn, options._metadata, options.tunnel);\n        // eslint-disable-next-line deprecation/deprecation\n        this.url = getStoreEndpointWithUrlEncodedAuth(this._api.dsn);\n        if (this.options.sendClientReports && global.document) {\n            global.document.addEventListener('visibilitychange', function () {\n                if (global.document.visibilityState === 'hidden') {\n                    _this._flushOutcomes();\n                }\n            });\n        }\n    }\n    /**\n     * @inheritDoc\n     */\n    BaseTransport.prototype.sendEvent = function (event) {\n        return this._sendRequest(eventToSentryRequest(event, this._api), event);\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseTransport.prototype.sendSession = function (session) {\n        return this._sendRequest(sessionToSentryRequest(session, this._api), session);\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseTransport.prototype.close = function (timeout) {\n        return this._buffer.drain(timeout);\n    };\n    /**\n     * @inheritDoc\n     */\n    BaseTransport.prototype.recordLostEvent = function (reason, category) {\n        var _a;\n        if (!this.options.sendClientReports) {\n            return;\n        }\n        // We want to track each category (event, transaction, session) separately\n        // but still keep the distinction between different type of outcomes.\n        // We could use nested maps, but it's much easier to read and type this way.\n        // A correct type for map-based implementation if we want to go that route\n        // would be `Partial<Record<SentryRequestType, Partial<Record<Outcome, number>>>>`\n        var key = requestTypeToCategory(category) + \":\" + reason;\n        IS_DEBUG_BUILD && logger.log(\"Adding outcome: \" + key);\n        this._outcomes[key] = (_a = this._outcomes[key], (_a !== null && _a !== void 0 ? _a : 0)) + 1;\n    };\n    /**\n     * Send outcomes as an envelope\n     */\n    BaseTransport.prototype._flushOutcomes = function () {\n        if (!this.options.sendClientReports) {\n            return;\n        }\n        var outcomes = this._outcomes;\n        this._outcomes = {};\n        // Nothing to send\n        if (!Object.keys(outcomes).length) {\n            IS_DEBUG_BUILD && logger.log('No outcomes to flush');\n            return;\n        }\n        IS_DEBUG_BUILD && logger.log(\"Flushing outcomes:\\n\" + JSON.stringify(outcomes, null, 2));\n        var url = getEnvelopeEndpointWithUrlEncodedAuth(this._api.dsn, this._api.tunnel);\n        var discardedEvents = Object.keys(outcomes).map(function (key) {\n            var _a = __read(key.split(':'), 2), category = _a[0], reason = _a[1];\n            return {\n                reason: reason,\n                category: category,\n                quantity: outcomes[key],\n            };\n            // TODO: Improve types on discarded_events to get rid of cast\n        });\n        var envelope = createClientReportEnvelope(discardedEvents, this._api.tunnel && dsnToString(this._api.dsn));\n        try {\n            sendReport(url, serializeEnvelope(envelope));\n        }\n        catch (e) {\n            IS_DEBUG_BUILD && logger.error(e);\n        }\n    };\n    /**\n     * Handle Sentry repsonse for promise-based transports.\n     */\n    BaseTransport.prototype._handleResponse = function (_a) {\n        var requestType = _a.requestType, response = _a.response, headers = _a.headers, resolve = _a.resolve, reject = _a.reject;\n        var status = eventStatusFromHttpCode(response.status);\n        this._rateLimits = updateRateLimits(this._rateLimits, headers);\n        // eslint-disable-next-line deprecation/deprecation\n        if (this._isRateLimited(requestType)) {\n            IS_DEBUG_BUILD &&\n                // eslint-disable-next-line deprecation/deprecation\n                logger.warn(\"Too many \" + requestType + \" requests, backing off until: \" + this._disabledUntil(requestType));\n        }\n        if (status === 'success') {\n            resolve({ status: status });\n            return;\n        }\n        reject(response);\n    };\n    /**\n     * Gets the time that given category is disabled until for rate limiting\n     *\n     * @deprecated Please use `disabledUntil` from @sentry/utils\n     */\n    BaseTransport.prototype._disabledUntil = function (requestType) {\n        var category = requestTypeToCategory(requestType);\n        return new Date(disabledUntil(this._rateLimits, category));\n    };\n    /**\n     * Checks if a category is rate limited\n     *\n     * @deprecated Please use `isRateLimited` from @sentry/utils\n     */\n    BaseTransport.prototype._isRateLimited = function (requestType) {\n        var category = requestTypeToCategory(requestType);\n        return isRateLimited(this._rateLimits, category);\n    };\n    return BaseTransport;\n}());\nexport { BaseTransport };\n//# sourceMappingURL=base.js.map","import { __extends } from \"tslib\";\nimport { SentryError, supportsReferrerPolicy, SyncPromise } from '@sentry/utils';\nimport { BaseTransport } from './base';\nimport { getNativeFetchImplementation } from './utils';\n/** `fetch` based transport */\nvar FetchTransport = /** @class */ (function (_super) {\n    __extends(FetchTransport, _super);\n    function FetchTransport(options, fetchImpl) {\n        if (fetchImpl === void 0) { fetchImpl = getNativeFetchImplementation(); }\n        var _this = _super.call(this, options) || this;\n        _this._fetch = fetchImpl;\n        return _this;\n    }\n    /**\n     * @param sentryRequest Prepared SentryRequest to be delivered\n     * @param originalPayload Original payload used to create SentryRequest\n     */\n    FetchTransport.prototype._sendRequest = function (sentryRequest, originalPayload) {\n        var _this = this;\n        // eslint-disable-next-line deprecation/deprecation\n        if (this._isRateLimited(sentryRequest.type)) {\n            this.recordLostEvent('ratelimit_backoff', sentryRequest.type);\n            return Promise.reject({\n                event: originalPayload,\n                type: sentryRequest.type,\n                // eslint-disable-next-line deprecation/deprecation\n                reason: \"Transport for \" + sentryRequest.type + \" requests locked till \" + this._disabledUntil(sentryRequest.type) + \" due to too many requests.\",\n                status: 429,\n            });\n        }\n        var options = {\n            body: sentryRequest.body,\n            method: 'POST',\n            // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default'\n            // (see https://caniuse.com/#feat=referrer-policy),\n            // it doesn't. And it throws an exception instead of ignoring this parameter...\n            // REF: https://github.com/getsentry/raven-js/issues/1233\n            referrerPolicy: (supportsReferrerPolicy() ? 'origin' : ''),\n        };\n        if (this.options.fetchParameters !== undefined) {\n            Object.assign(options, this.options.fetchParameters);\n        }\n        if (this.options.headers !== undefined) {\n            options.headers = this.options.headers;\n        }\n        return this._buffer\n            .add(function () {\n            return new SyncPromise(function (resolve, reject) {\n                void _this._fetch(sentryRequest.url, options)\n                    .then(function (response) {\n                    var headers = {\n                        'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),\n                        'retry-after': response.headers.get('Retry-After'),\n                    };\n                    _this._handleResponse({\n                        requestType: sentryRequest.type,\n                        response: response,\n                        headers: headers,\n                        resolve: resolve,\n                        reject: reject,\n                    });\n                })\n                    .catch(reject);\n            });\n        })\n            .then(undefined, function (reason) {\n            // It's either buffer rejection or any other xhr/fetch error, which are treated as NetworkError.\n            if (reason instanceof SentryError) {\n                _this.recordLostEvent('queue_overflow', sentryRequest.type);\n            }\n            else {\n                _this.recordLostEvent('network_error', sentryRequest.type);\n            }\n            throw reason;\n        });\n    };\n    return FetchTransport;\n}(BaseTransport));\nexport { FetchTransport };\n//# sourceMappingURL=fetch.js.map","import { __extends } from \"tslib\";\nimport { SentryError, SyncPromise } from '@sentry/utils';\nimport { BaseTransport } from './base';\n/** `XHR` based transport */\nvar XHRTransport = /** @class */ (function (_super) {\n    __extends(XHRTransport, _super);\n    function XHRTransport() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * @param sentryRequest Prepared SentryRequest to be delivered\n     * @param originalPayload Original payload used to create SentryRequest\n     */\n    XHRTransport.prototype._sendRequest = function (sentryRequest, originalPayload) {\n        var _this = this;\n        // eslint-disable-next-line deprecation/deprecation\n        if (this._isRateLimited(sentryRequest.type)) {\n            this.recordLostEvent('ratelimit_backoff', sentryRequest.type);\n            return Promise.reject({\n                event: originalPayload,\n                type: sentryRequest.type,\n                // eslint-disable-next-line deprecation/deprecation\n                reason: \"Transport for \" + sentryRequest.type + \" requests locked till \" + this._disabledUntil(sentryRequest.type) + \" due to too many requests.\",\n                status: 429,\n            });\n        }\n        return this._buffer\n            .add(function () {\n            return new SyncPromise(function (resolve, reject) {\n                var request = new XMLHttpRequest();\n                request.onreadystatechange = function () {\n                    if (request.readyState === 4) {\n                        var headers = {\n                            'x-sentry-rate-limits': request.getResponseHeader('X-Sentry-Rate-Limits'),\n                            'retry-after': request.getResponseHeader('Retry-After'),\n                        };\n                        _this._handleResponse({ requestType: sentryRequest.type, response: request, headers: headers, resolve: resolve, reject: reject });\n                    }\n                };\n                request.open('POST', sentryRequest.url);\n                for (var header in _this.options.headers) {\n                    if (Object.prototype.hasOwnProperty.call(_this.options.headers, header)) {\n                        request.setRequestHeader(header, _this.options.headers[header]);\n                    }\n                }\n                request.send(sentryRequest.body);\n            });\n        })\n            .then(undefined, function (reason) {\n            // It's either buffer rejection or any other xhr/fetch error, which are treated as NetworkError.\n            if (reason instanceof SentryError) {\n                _this.recordLostEvent('queue_overflow', sentryRequest.type);\n            }\n            else {\n                _this.recordLostEvent('network_error', sentryRequest.type);\n            }\n            throw reason;\n        });\n    };\n    return XHRTransport;\n}(BaseTransport));\nexport { XHRTransport };\n//# sourceMappingURL=xhr.js.map","import { __assign, __extends } from \"tslib\";\nimport { BaseBackend, getEnvelopeEndpointWithUrlEncodedAuth, initAPIDetails } from '@sentry/core';\nimport { Severity } from '@sentry/types';\nimport { supportsFetch } from '@sentry/utils';\nimport { eventFromException, eventFromMessage } from './eventbuilder';\nimport { FetchTransport, makeNewFetchTransport, makeNewXHRTransport, XHRTransport } from './transports';\n/**\n * The Sentry Browser SDK Backend.\n * @hidden\n */\nvar BrowserBackend = /** @class */ (function (_super) {\n    __extends(BrowserBackend, _super);\n    function BrowserBackend() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * @inheritDoc\n     */\n    BrowserBackend.prototype.eventFromException = function (exception, hint) {\n        return eventFromException(exception, hint, this._options.attachStacktrace);\n    };\n    /**\n     * @inheritDoc\n     */\n    BrowserBackend.prototype.eventFromMessage = function (message, level, hint) {\n        if (level === void 0) { level = Severity.Info; }\n        return eventFromMessage(message, level, hint, this._options.attachStacktrace);\n    };\n    /**\n     * @inheritDoc\n     */\n    BrowserBackend.prototype._setupTransport = function () {\n        if (!this._options.dsn) {\n            // We return the noop transport here in case there is no Dsn.\n            return _super.prototype._setupTransport.call(this);\n        }\n        var transportOptions = __assign(__assign({}, this._options.transportOptions), { dsn: this._options.dsn, tunnel: this._options.tunnel, sendClientReports: this._options.sendClientReports, _metadata: this._options._metadata });\n        var api = initAPIDetails(transportOptions.dsn, transportOptions._metadata, transportOptions.tunnel);\n        var url = getEnvelopeEndpointWithUrlEncodedAuth(api.dsn, api.tunnel);\n        if (this._options.transport) {\n            return new this._options.transport(transportOptions);\n        }\n        if (supportsFetch()) {\n            var requestOptions = __assign({}, transportOptions.fetchParameters);\n            this._newTransport = makeNewFetchTransport({ requestOptions: requestOptions, url: url });\n            return new FetchTransport(transportOptions);\n        }\n        this._newTransport = makeNewXHRTransport({\n            url: url,\n            headers: transportOptions.headers,\n        });\n        return new XHRTransport(transportOptions);\n    };\n    return BrowserBackend;\n}(BaseBackend));\nexport { BrowserBackend };\n//# sourceMappingURL=backend.js.map","import { __assign } from \"tslib\";\nimport { createTransport, } from '@sentry/core';\nimport { getNativeFetchImplementation } from './utils';\n/**\n * Creates a Transport that uses the Fetch API to send events to Sentry.\n */\nexport function makeNewFetchTransport(options, nativeFetch) {\n    if (nativeFetch === void 0) { nativeFetch = getNativeFetchImplementation(); }\n    function makeRequest(request) {\n        var requestOptions = __assign({ body: request.body, method: 'POST', referrerPolicy: 'origin' }, options.requestOptions);\n        return nativeFetch(options.url, requestOptions).then(function (response) {\n            return response.text().then(function (body) { return ({\n                body: body,\n                headers: {\n                    'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),\n                    'retry-after': response.headers.get('Retry-After'),\n                },\n                reason: response.statusText,\n                statusCode: response.status,\n            }); });\n        });\n    }\n    return createTransport({ bufferSize: options.bufferSize }, makeRequest);\n}\n//# sourceMappingURL=new-fetch.js.map","import { createTransport, } from '@sentry/core';\nimport { SyncPromise } from '@sentry/utils';\n/**\n * The DONE ready state for XmlHttpRequest\n *\n * Defining it here as a constant b/c XMLHttpRequest.DONE is not always defined\n * (e.g. during testing, it is `undefined`)\n *\n * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/readyState}\n */\nvar XHR_READYSTATE_DONE = 4;\n/**\n * Creates a Transport that uses the XMLHttpRequest API to send events to Sentry.\n */\nexport function makeNewXHRTransport(options) {\n    function makeRequest(request) {\n        return new SyncPromise(function (resolve, _reject) {\n            var xhr = new XMLHttpRequest();\n            xhr.onreadystatechange = function () {\n                if (xhr.readyState === XHR_READYSTATE_DONE) {\n                    var response = {\n                        body: xhr.response,\n                        headers: {\n                            'x-sentry-rate-limits': xhr.getResponseHeader('X-Sentry-Rate-Limits'),\n                            'retry-after': xhr.getResponseHeader('Retry-After'),\n                        },\n                        reason: xhr.statusText,\n                        statusCode: xhr.status,\n                    };\n                    resolve(response);\n                }\n            };\n            xhr.open('POST', options.url);\n            for (var header in options.headers) {\n                if (Object.prototype.hasOwnProperty.call(options.headers, header)) {\n                    xhr.setRequestHeader(header, options.headers[header]);\n                }\n            }\n            xhr.send(request.body);\n        });\n    }\n    return createTransport({ bufferSize: options.bufferSize }, makeRequest);\n}\n//# sourceMappingURL=new-xhr.js.map","import { __assign } from \"tslib\";\nimport { captureException, getReportDialogEndpoint, withScope } from '@sentry/core';\nimport { addExceptionMechanism, addExceptionTypeValue, addNonEnumerableProperty, getGlobalObject, getOriginalFunction, logger, markFunctionWrapped, } from '@sentry/utils';\nimport { IS_DEBUG_BUILD } from './flags';\nvar global = getGlobalObject();\nvar ignoreOnError = 0;\n/**\n * @hidden\n */\nexport function shouldIgnoreOnError() {\n    return ignoreOnError > 0;\n}\n/**\n * @hidden\n */\nexport function ignoreNextOnError() {\n    // onerror should trigger before setTimeout\n    ignoreOnError += 1;\n    setTimeout(function () {\n        ignoreOnError -= 1;\n    });\n}\n/**\n * Instruments the given function and sends an event to Sentry every time the\n * function throws an exception.\n *\n * @param fn A function to wrap.\n * @returns The wrapped function.\n * @hidden\n */\nexport function wrap(fn, options, before) {\n    // for future readers what this does is wrap a function and then create\n    // a bi-directional wrapping between them.\n    //\n    // example: wrapped = wrap(original);\n    //  original.__sentry_wrapped__ -> wrapped\n    //  wrapped.__sentry_original__ -> original\n    if (options === void 0) { options = {}; }\n    if (typeof fn !== 'function') {\n        return fn;\n    }\n    try {\n        // if we're dealing with a function that was previously wrapped, return\n        // the original wrapper.\n        var wrapper = fn.__sentry_wrapped__;\n        if (wrapper) {\n            return wrapper;\n        }\n        // We don't wanna wrap it twice\n        if (getOriginalFunction(fn)) {\n            return fn;\n        }\n    }\n    catch (e) {\n        // Just accessing custom props in some Selenium environments\n        // can cause a \"Permission denied\" exception (see raven-js#495).\n        // Bail on wrapping and return the function as-is (defers to window.onerror).\n        return fn;\n    }\n    /* eslint-disable prefer-rest-params */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    var sentryWrapped = function () {\n        var args = Array.prototype.slice.call(arguments);\n        try {\n            if (before && typeof before === 'function') {\n                before.apply(this, arguments);\n            }\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access\n            var wrappedArguments = args.map(function (arg) { return wrap(arg, options); });\n            // Attempt to invoke user-land function\n            // NOTE: If you are a Sentry user, and you are seeing this stack frame, it\n            //       means the sentry.javascript SDK caught an error invoking your application code. This\n            //       is expected behavior and NOT indicative of a bug with sentry.javascript.\n            return fn.apply(this, wrappedArguments);\n        }\n        catch (ex) {\n            ignoreNextOnError();\n            withScope(function (scope) {\n                scope.addEventProcessor(function (event) {\n                    if (options.mechanism) {\n                        addExceptionTypeValue(event, undefined, undefined);\n                        addExceptionMechanism(event, options.mechanism);\n                    }\n                    event.extra = __assign(__assign({}, event.extra), { arguments: args });\n                    return event;\n                });\n                captureException(ex);\n            });\n            throw ex;\n        }\n    };\n    /* eslint-enable prefer-rest-params */\n    // Accessing some objects may throw\n    // ref: https://github.com/getsentry/sentry-javascript/issues/1168\n    try {\n        for (var property in fn) {\n            if (Object.prototype.hasOwnProperty.call(fn, property)) {\n                sentryWrapped[property] = fn[property];\n            }\n        }\n    }\n    catch (_oO) { } // eslint-disable-line no-empty\n    // Signal that this function has been wrapped/filled already\n    // for both debugging and to prevent it to being wrapped/filled twice\n    markFunctionWrapped(sentryWrapped, fn);\n    addNonEnumerableProperty(fn, '__sentry_wrapped__', sentryWrapped);\n    // Restore original function name (not all browsers allow that)\n    try {\n        var descriptor = Object.getOwnPropertyDescriptor(sentryWrapped, 'name');\n        if (descriptor.configurable) {\n            Object.defineProperty(sentryWrapped, 'name', {\n                get: function () {\n                    return fn.name;\n                },\n            });\n        }\n        // eslint-disable-next-line no-empty\n    }\n    catch (_oO) { }\n    return sentryWrapped;\n}\n/**\n * Injects the Report Dialog script\n * @hidden\n */\nexport function injectReportDialog(options) {\n    if (options === void 0) { options = {}; }\n    if (!global.document) {\n        return;\n    }\n    if (!options.eventId) {\n        IS_DEBUG_BUILD && logger.error('Missing eventId option in showReportDialog call');\n        return;\n    }\n    if (!options.dsn) {\n        IS_DEBUG_BUILD && logger.error('Missing dsn option in showReportDialog call');\n        return;\n    }\n    var script = global.document.createElement('script');\n    script.async = true;\n    script.src = getReportDialogEndpoint(options.dsn, options);\n    if (options.onLoad) {\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        script.onload = options.onLoad;\n    }\n    var injectionPoint = global.document.head || global.document.body;\n    if (injectionPoint) {\n        injectionPoint.appendChild(script);\n    }\n}\n//# sourceMappingURL=helpers.js.map","import { __assign } from \"tslib\";\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/* eslint-disable max-lines */\nimport { getCurrentHub } from '@sentry/core';\nimport { Severity } from '@sentry/types';\nimport { addInstrumentationHandler, getEventDescription, getGlobalObject, htmlTreeAsString, parseUrl, safeJoin, severityFromString, } from '@sentry/utils';\n/**\n * Default Breadcrumbs instrumentations\n * TODO: Deprecated - with v6, this will be renamed to `Instrument`\n */\nvar Breadcrumbs = /** @class */ (function () {\n    /**\n     * @inheritDoc\n     */\n    function Breadcrumbs(options) {\n        /**\n         * @inheritDoc\n         */\n        this.name = Breadcrumbs.id;\n        this._options = __assign({ console: true, dom: true, fetch: true, history: true, sentry: true, xhr: true }, options);\n    }\n    /**\n     * Create a breadcrumb of `sentry` from the events themselves\n     */\n    Breadcrumbs.prototype.addSentryBreadcrumb = function (event) {\n        if (!this._options.sentry) {\n            return;\n        }\n        getCurrentHub().addBreadcrumb({\n            category: \"sentry.\" + (event.type === 'transaction' ? 'transaction' : 'event'),\n            event_id: event.event_id,\n            level: event.level,\n            message: getEventDescription(event),\n        }, {\n            event: event,\n        });\n    };\n    /**\n     * Instrument browser built-ins w/ breadcrumb capturing\n     *  - Console API\n     *  - DOM API (click/typing)\n     *  - XMLHttpRequest API\n     *  - Fetch API\n     *  - History API\n     */\n    Breadcrumbs.prototype.setupOnce = function () {\n        if (this._options.console) {\n            addInstrumentationHandler('console', _consoleBreadcrumb);\n        }\n        if (this._options.dom) {\n            addInstrumentationHandler('dom', _domBreadcrumb(this._options.dom));\n        }\n        if (this._options.xhr) {\n            addInstrumentationHandler('xhr', _xhrBreadcrumb);\n        }\n        if (this._options.fetch) {\n            addInstrumentationHandler('fetch', _fetchBreadcrumb);\n        }\n        if (this._options.history) {\n            addInstrumentationHandler('history', _historyBreadcrumb);\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    Breadcrumbs.id = 'Breadcrumbs';\n    return Breadcrumbs;\n}());\nexport { Breadcrumbs };\n/**\n * A HOC that creaes a function that creates breadcrumbs from DOM API calls.\n * This is a HOC so that we get access to dom options in the closure.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _domBreadcrumb(dom) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    function _innerDomBreadcrumb(handlerData) {\n        var target;\n        var keyAttrs = typeof dom === 'object' ? dom.serializeAttribute : undefined;\n        if (typeof keyAttrs === 'string') {\n            keyAttrs = [keyAttrs];\n        }\n        // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n        try {\n            target = handlerData.event.target\n                ? htmlTreeAsString(handlerData.event.target, keyAttrs)\n                : htmlTreeAsString(handlerData.event, keyAttrs);\n        }\n        catch (e) {\n            target = '<unknown>';\n        }\n        if (target.length === 0) {\n            return;\n        }\n        getCurrentHub().addBreadcrumb({\n            category: \"ui.\" + handlerData.name,\n            message: target,\n        }, {\n            event: handlerData.event,\n            name: handlerData.name,\n            global: handlerData.global,\n        });\n    }\n    return _innerDomBreadcrumb;\n}\n/**\n * Creates breadcrumbs from console API calls\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _consoleBreadcrumb(handlerData) {\n    var breadcrumb = {\n        category: 'console',\n        data: {\n            arguments: handlerData.args,\n            logger: 'console',\n        },\n        level: severityFromString(handlerData.level),\n        message: safeJoin(handlerData.args, ' '),\n    };\n    if (handlerData.level === 'assert') {\n        if (handlerData.args[0] === false) {\n            breadcrumb.message = \"Assertion failed: \" + (safeJoin(handlerData.args.slice(1), ' ') || 'console.assert');\n            breadcrumb.data.arguments = handlerData.args.slice(1);\n        }\n        else {\n            // Don't capture a breadcrumb for passed assertions\n            return;\n        }\n    }\n    getCurrentHub().addBreadcrumb(breadcrumb, {\n        input: handlerData.args,\n        level: handlerData.level,\n    });\n}\n/**\n * Creates breadcrumbs from XHR API calls\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _xhrBreadcrumb(handlerData) {\n    if (handlerData.endTimestamp) {\n        // We only capture complete, non-sentry requests\n        if (handlerData.xhr.__sentry_own_request__) {\n            return;\n        }\n        var _a = handlerData.xhr.__sentry_xhr__ || {}, method = _a.method, url = _a.url, status_code = _a.status_code, body = _a.body;\n        getCurrentHub().addBreadcrumb({\n            category: 'xhr',\n            data: {\n                method: method,\n                url: url,\n                status_code: status_code,\n            },\n            type: 'http',\n        }, {\n            xhr: handlerData.xhr,\n            input: body,\n        });\n        return;\n    }\n}\n/**\n * Creates breadcrumbs from fetch API calls\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _fetchBreadcrumb(handlerData) {\n    // We only capture complete fetch requests\n    if (!handlerData.endTimestamp) {\n        return;\n    }\n    if (handlerData.fetchData.url.match(/sentry_key/) && handlerData.fetchData.method === 'POST') {\n        // We will not create breadcrumbs for fetch requests that contain `sentry_key` (internal sentry requests)\n        return;\n    }\n    if (handlerData.error) {\n        getCurrentHub().addBreadcrumb({\n            category: 'fetch',\n            data: handlerData.fetchData,\n            level: Severity.Error,\n            type: 'http',\n        }, {\n            data: handlerData.error,\n            input: handlerData.args,\n        });\n    }\n    else {\n        getCurrentHub().addBreadcrumb({\n            category: 'fetch',\n            data: __assign(__assign({}, handlerData.fetchData), { status_code: handlerData.response.status }),\n            type: 'http',\n        }, {\n            input: handlerData.args,\n            response: handlerData.response,\n        });\n    }\n}\n/**\n * Creates breadcrumbs from history API calls\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _historyBreadcrumb(handlerData) {\n    var global = getGlobalObject();\n    var from = handlerData.from;\n    var to = handlerData.to;\n    var parsedLoc = parseUrl(global.location.href);\n    var parsedFrom = parseUrl(from);\n    var parsedTo = parseUrl(to);\n    // Initial pushState doesn't provide `from` information\n    if (!parsedFrom.path) {\n        parsedFrom = parsedLoc;\n    }\n    // Use only the path component of the URL if the URL matches the current\n    // document (almost all the time when using pushState)\n    if (parsedLoc.protocol === parsedTo.protocol && parsedLoc.host === parsedTo.host) {\n        to = parsedTo.relative;\n    }\n    if (parsedLoc.protocol === parsedFrom.protocol && parsedLoc.host === parsedFrom.host) {\n        from = parsedFrom.relative;\n    }\n    getCurrentHub().addBreadcrumb({\n        category: 'navigation',\n        data: {\n            from: from,\n            to: to,\n        },\n    });\n}\n//# sourceMappingURL=breadcrumbs.js.map","import { __assign, __extends } from \"tslib\";\nimport { BaseClient, SDK_VERSION } from '@sentry/core';\nimport { getGlobalObject, logger } from '@sentry/utils';\nimport { BrowserBackend } from './backend';\nimport { IS_DEBUG_BUILD } from './flags';\nimport { injectReportDialog } from './helpers';\nimport { Breadcrumbs } from './integrations';\n/**\n * The Sentry Browser SDK Client.\n *\n * @see BrowserOptions for documentation on configuration options.\n * @see SentryClient for usage documentation.\n */\nvar BrowserClient = /** @class */ (function (_super) {\n    __extends(BrowserClient, _super);\n    /**\n     * Creates a new Browser SDK instance.\n     *\n     * @param options Configuration options for this SDK.\n     */\n    function BrowserClient(options) {\n        if (options === void 0) { options = {}; }\n        var _this = this;\n        options._metadata = options._metadata || {};\n        options._metadata.sdk = options._metadata.sdk || {\n            name: 'sentry.javascript.browser',\n            packages: [\n                {\n                    name: 'npm:@sentry/browser',\n                    version: SDK_VERSION,\n                },\n            ],\n            version: SDK_VERSION,\n        };\n        _this = _super.call(this, BrowserBackend, options) || this;\n        return _this;\n    }\n    /**\n     * Show a report dialog to the user to send feedback to a specific event.\n     *\n     * @param options Set individual options for the dialog\n     */\n    BrowserClient.prototype.showReportDialog = function (options) {\n        if (options === void 0) { options = {}; }\n        // doesn't work without a document (React Native)\n        var document = getGlobalObject().document;\n        if (!document) {\n            return;\n        }\n        if (!this._isEnabled()) {\n            IS_DEBUG_BUILD && logger.error('Trying to call showReportDialog with Sentry Client disabled');\n            return;\n        }\n        injectReportDialog(__assign(__assign({}, options), { dsn: options.dsn || this.getDsn() }));\n    };\n    /**\n     * @inheritDoc\n     */\n    BrowserClient.prototype._prepareEvent = function (event, scope, hint) {\n        event.platform = event.platform || 'javascript';\n        return _super.prototype._prepareEvent.call(this, event, scope, hint);\n    };\n    /**\n     * @inheritDoc\n     */\n    BrowserClient.prototype._sendEvent = function (event) {\n        var integration = this.getIntegration(Breadcrumbs);\n        if (integration) {\n            integration.addSentryBreadcrumb(event);\n        }\n        _super.prototype._sendEvent.call(this, event);\n    };\n    return BrowserClient;\n}(BaseClient));\nexport { BrowserClient };\n//# sourceMappingURL=client.js.map","import { __assign } from \"tslib\";\nimport { fill, getFunctionName, getGlobalObject, getOriginalFunction } from '@sentry/utils';\nimport { wrap } from '../helpers';\nvar DEFAULT_EVENT_TARGET = [\n    'EventTarget',\n    'Window',\n    'Node',\n    'ApplicationCache',\n    'AudioTrackList',\n    'ChannelMergerNode',\n    'CryptoOperation',\n    'EventSource',\n    'FileReader',\n    'HTMLUnknownElement',\n    'IDBDatabase',\n    'IDBRequest',\n    'IDBTransaction',\n    'KeyOperation',\n    'MediaController',\n    'MessagePort',\n    'ModalWindow',\n    'Notification',\n    'SVGElementInstance',\n    'Screen',\n    'TextTrack',\n    'TextTrackCue',\n    'TextTrackList',\n    'WebSocket',\n    'WebSocketWorker',\n    'Worker',\n    'XMLHttpRequest',\n    'XMLHttpRequestEventTarget',\n    'XMLHttpRequestUpload',\n];\n/** Wrap timer functions and event targets to catch errors and provide better meta data */\nvar TryCatch = /** @class */ (function () {\n    /**\n     * @inheritDoc\n     */\n    function TryCatch(options) {\n        /**\n         * @inheritDoc\n         */\n        this.name = TryCatch.id;\n        this._options = __assign({ XMLHttpRequest: true, eventTarget: true, requestAnimationFrame: true, setInterval: true, setTimeout: true }, options);\n    }\n    /**\n     * Wrap timer functions and event targets to catch errors\n     * and provide better metadata.\n     */\n    TryCatch.prototype.setupOnce = function () {\n        var global = getGlobalObject();\n        if (this._options.setTimeout) {\n            fill(global, 'setTimeout', _wrapTimeFunction);\n        }\n        if (this._options.setInterval) {\n            fill(global, 'setInterval', _wrapTimeFunction);\n        }\n        if (this._options.requestAnimationFrame) {\n            fill(global, 'requestAnimationFrame', _wrapRAF);\n        }\n        if (this._options.XMLHttpRequest && 'XMLHttpRequest' in global) {\n            fill(XMLHttpRequest.prototype, 'send', _wrapXHR);\n        }\n        var eventTargetOption = this._options.eventTarget;\n        if (eventTargetOption) {\n            var eventTarget = Array.isArray(eventTargetOption) ? eventTargetOption : DEFAULT_EVENT_TARGET;\n            eventTarget.forEach(_wrapEventTarget);\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    TryCatch.id = 'TryCatch';\n    return TryCatch;\n}());\nexport { TryCatch };\n/** JSDoc */\nfunction _wrapTimeFunction(original) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    return function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        var originalCallback = args[0];\n        args[0] = wrap(originalCallback, {\n            mechanism: {\n                data: { function: getFunctionName(original) },\n                handled: true,\n                type: 'instrument',\n            },\n        });\n        return original.apply(this, args);\n    };\n}\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _wrapRAF(original) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    return function (callback) {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        return original.apply(this, [\n            wrap(callback, {\n                mechanism: {\n                    data: {\n                        function: 'requestAnimationFrame',\n                        handler: getFunctionName(original),\n                    },\n                    handled: true,\n                    type: 'instrument',\n                },\n            }),\n        ]);\n    };\n}\n/** JSDoc */\nfunction _wrapXHR(originalSend) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    return function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        // eslint-disable-next-line @typescript-eslint/no-this-alias\n        var xhr = this;\n        var xmlHttpRequestProps = ['onload', 'onerror', 'onprogress', 'onreadystatechange'];\n        xmlHttpRequestProps.forEach(function (prop) {\n            if (prop in xhr && typeof xhr[prop] === 'function') {\n                // eslint-disable-next-line @typescript-eslint/no-explicit-any\n                fill(xhr, prop, function (original) {\n                    var wrapOptions = {\n                        mechanism: {\n                            data: {\n                                function: prop,\n                                handler: getFunctionName(original),\n                            },\n                            handled: true,\n                            type: 'instrument',\n                        },\n                    };\n                    // If Instrument integration has been called before TryCatch, get the name of original function\n                    var originalFunction = getOriginalFunction(original);\n                    if (originalFunction) {\n                        wrapOptions.mechanism.data.handler = getFunctionName(originalFunction);\n                    }\n                    // Otherwise wrap directly\n                    return wrap(original, wrapOptions);\n                });\n            }\n        });\n        return originalSend.apply(this, args);\n    };\n}\n/** JSDoc */\nfunction _wrapEventTarget(target) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    var global = getGlobalObject();\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    var proto = global[target] && global[target].prototype;\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-prototype-builtins\n    if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n        return;\n    }\n    fill(proto, 'addEventListener', function (original) {\n        return function (eventName, fn, options) {\n            try {\n                if (typeof fn.handleEvent === 'function') {\n                    fn.handleEvent = wrap(fn.handleEvent.bind(fn), {\n                        mechanism: {\n                            data: {\n                                function: 'handleEvent',\n                                handler: getFunctionName(fn),\n                                target: target,\n                            },\n                            handled: true,\n                            type: 'instrument',\n                        },\n                    });\n                }\n            }\n            catch (err) {\n                // can sometimes get 'Permission denied to access property \"handle Event'\n            }\n            return original.apply(this, [\n                eventName,\n                // eslint-disable-next-line @typescript-eslint/no-explicit-any\n                wrap(fn, {\n                    mechanism: {\n                        data: {\n                            function: 'addEventListener',\n                            handler: getFunctionName(fn),\n                            target: target,\n                        },\n                        handled: true,\n                        type: 'instrument',\n                    },\n                }),\n                options,\n            ]);\n        };\n    });\n    fill(proto, 'removeEventListener', function (originalRemoveEventListener) {\n        return function (eventName, fn, options) {\n            /**\n             * There are 2 possible scenarios here:\n             *\n             * 1. Someone passes a callback, which was attached prior to Sentry initialization, or by using unmodified\n             * method, eg. `document.addEventListener.call(el, name, handler). In this case, we treat this function\n             * as a pass-through, and call original `removeEventListener` with it.\n             *\n             * 2. Someone passes a callback, which was attached after Sentry was initialized, which means that it was using\n             * our wrapped version of `addEventListener`, which internally calls `wrap` helper.\n             * This helper \"wraps\" whole callback inside a try/catch statement, and attached appropriate metadata to it,\n             * in order for us to make a distinction between wrapped/non-wrapped functions possible.\n             * If a function was wrapped, it has additional property of `__sentry_wrapped__`, holding the handler.\n             *\n             * When someone adds a handler prior to initialization, and then do it again, but after,\n             * then we have to detach both of them. Otherwise, if we'd detach only wrapped one, it'd be impossible\n             * to get rid of the initial handler and it'd stick there forever.\n             */\n            var wrappedEventHandler = fn;\n            try {\n                var originalEventHandler = wrappedEventHandler && wrappedEventHandler.__sentry_wrapped__;\n                if (originalEventHandler) {\n                    originalRemoveEventListener.call(this, eventName, originalEventHandler, options);\n                }\n            }\n            catch (e) {\n                // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments\n            }\n            return originalRemoveEventListener.call(this, eventName, wrappedEventHandler, options);\n        };\n    });\n}\n//# sourceMappingURL=trycatch.js.map","import { __assign, __read } from \"tslib\";\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\nimport { getCurrentHub } from '@sentry/core';\nimport { Severity } from '@sentry/types';\nimport { addExceptionMechanism, addInstrumentationHandler, getLocationHref, isErrorEvent, isPrimitive, isString, logger, } from '@sentry/utils';\nimport { eventFromUnknownInput } from '../eventbuilder';\nimport { IS_DEBUG_BUILD } from '../flags';\nimport { shouldIgnoreOnError } from '../helpers';\n/** Global handlers */\nvar GlobalHandlers = /** @class */ (function () {\n    /** JSDoc */\n    function GlobalHandlers(options) {\n        /**\n         * @inheritDoc\n         */\n        this.name = GlobalHandlers.id;\n        /**\n         * Stores references functions to installing handlers. Will set to undefined\n         * after they have been run so that they are not used twice.\n         */\n        this._installFunc = {\n            onerror: _installGlobalOnErrorHandler,\n            onunhandledrejection: _installGlobalOnUnhandledRejectionHandler,\n        };\n        this._options = __assign({ onerror: true, onunhandledrejection: true }, options);\n    }\n    /**\n     * @inheritDoc\n     */\n    GlobalHandlers.prototype.setupOnce = function () {\n        Error.stackTraceLimit = 50;\n        var options = this._options;\n        // We can disable guard-for-in as we construct the options object above + do checks against\n        // `this._installFunc` for the property.\n        // eslint-disable-next-line guard-for-in\n        for (var key in options) {\n            var installFunc = this._installFunc[key];\n            if (installFunc && options[key]) {\n                globalHandlerLog(key);\n                installFunc();\n                this._installFunc[key] = undefined;\n            }\n        }\n    };\n    /**\n     * @inheritDoc\n     */\n    GlobalHandlers.id = 'GlobalHandlers';\n    return GlobalHandlers;\n}());\nexport { GlobalHandlers };\n/** JSDoc */\nfunction _installGlobalOnErrorHandler() {\n    addInstrumentationHandler('error', \n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    function (data) {\n        var _a = __read(getHubAndAttachStacktrace(), 2), hub = _a[0], attachStacktrace = _a[1];\n        if (!hub.getIntegration(GlobalHandlers)) {\n            return;\n        }\n        var msg = data.msg, url = data.url, line = data.line, column = data.column, error = data.error;\n        if (shouldIgnoreOnError() || (error && error.__sentry_own_request__)) {\n            return;\n        }\n        var event = error === undefined && isString(msg)\n            ? _eventFromIncompleteOnError(msg, url, line, column)\n            : _enhanceEventWithInitialFrame(eventFromUnknownInput(error || msg, undefined, attachStacktrace, false), url, line, column);\n        event.level = Severity.Error;\n        addMechanismAndCapture(hub, error, event, 'onerror');\n    });\n}\n/** JSDoc */\nfunction _installGlobalOnUnhandledRejectionHandler() {\n    addInstrumentationHandler('unhandledrejection', \n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    function (e) {\n        var _a = __read(getHubAndAttachStacktrace(), 2), hub = _a[0], attachStacktrace = _a[1];\n        if (!hub.getIntegration(GlobalHandlers)) {\n            return;\n        }\n        var error = e;\n        // dig the object of the rejection out of known event types\n        try {\n            // PromiseRejectionEvents store the object of the rejection under 'reason'\n            // see https://developer.mozilla.org/en-US/docs/Web/API/PromiseRejectionEvent\n            if ('reason' in e) {\n                error = e.reason;\n            }\n            // something, somewhere, (likely a browser extension) effectively casts PromiseRejectionEvents\n            // to CustomEvents, moving the `promise` and `reason` attributes of the PRE into\n            // the CustomEvent's `detail` attribute, since they're not part of CustomEvent's spec\n            // see https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent and\n            // https://github.com/getsentry/sentry-javascript/issues/2380\n            else if ('detail' in e && 'reason' in e.detail) {\n                error = e.detail.reason;\n            }\n        }\n        catch (_oO) {\n            // no-empty\n        }\n        if (shouldIgnoreOnError() || (error && error.__sentry_own_request__)) {\n            return true;\n        }\n        var event = isPrimitive(error)\n            ? _eventFromRejectionWithPrimitive(error)\n            : eventFromUnknownInput(error, undefined, attachStacktrace, true);\n        event.level = Severity.Error;\n        addMechanismAndCapture(hub, error, event, 'onunhandledrejection');\n        return;\n    });\n}\n/**\n * Create an event from a promise rejection where the `reason` is a primitive.\n *\n * @param reason: The `reason` property of the promise rejection\n * @returns An Event object with an appropriate `exception` value\n */\nfunction _eventFromRejectionWithPrimitive(reason) {\n    return {\n        exception: {\n            values: [\n                {\n                    type: 'UnhandledRejection',\n                    // String() is needed because the Primitive type includes symbols (which can't be automatically stringified)\n                    value: \"Non-Error promise rejection captured with value: \" + String(reason),\n                },\n            ],\n        },\n    };\n}\n/**\n * This function creates a stack from an old, error-less onerror handler.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _eventFromIncompleteOnError(msg, url, line, column) {\n    var ERROR_TYPES_RE = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/i;\n    // If 'message' is ErrorEvent, get real message from inside\n    var message = isErrorEvent(msg) ? msg.message : msg;\n    var name = 'Error';\n    var groups = message.match(ERROR_TYPES_RE);\n    if (groups) {\n        name = groups[1];\n        message = groups[2];\n    }\n    var event = {\n        exception: {\n            values: [\n                {\n                    type: name,\n                    value: message,\n                },\n            ],\n        },\n    };\n    return _enhanceEventWithInitialFrame(event, url, line, column);\n}\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _enhanceEventWithInitialFrame(event, url, line, column) {\n    // event.exception\n    var e = (event.exception = event.exception || {});\n    // event.exception.values\n    var ev = (e.values = e.values || []);\n    // event.exception.values[0]\n    var ev0 = (ev[0] = ev[0] || {});\n    // event.exception.values[0].stacktrace\n    var ev0s = (ev0.stacktrace = ev0.stacktrace || {});\n    // event.exception.values[0].stacktrace.frames\n    var ev0sf = (ev0s.frames = ev0s.frames || []);\n    var colno = isNaN(parseInt(column, 10)) ? undefined : column;\n    var lineno = isNaN(parseInt(line, 10)) ? undefined : line;\n    var filename = isString(url) && url.length > 0 ? url : getLocationHref();\n    // event.exception.values[0].stacktrace.frames\n    if (ev0sf.length === 0) {\n        ev0sf.push({\n            colno: colno,\n            filename: filename,\n            function: '?',\n            in_app: true,\n            lineno: lineno,\n        });\n    }\n    return event;\n}\nfunction globalHandlerLog(type) {\n    IS_DEBUG_BUILD && logger.log(\"Global Handler attached: \" + type);\n}\nfunction addMechanismAndCapture(hub, error, event, type) {\n    addExceptionMechanism(event, {\n        handled: false,\n        type: type,\n    });\n    hub.captureEvent(event, {\n        originalException: error,\n    });\n}\nfunction getHubAndAttachStacktrace() {\n    var hub = getCurrentHub();\n    var client = hub.getClient();\n    var attachStacktrace = client && client.getOptions().attachStacktrace;\n    return [hub, attachStacktrace];\n}\n//# sourceMappingURL=globalhandlers.js.map","import { __read, __spread } from \"tslib\";\nimport { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { isInstanceOf } from '@sentry/utils';\nimport { exceptionFromError } from '../eventbuilder';\nvar DEFAULT_KEY = 'cause';\nvar DEFAULT_LIMIT = 5;\n/** Adds SDK info to an event. */\nvar LinkedErrors = /** @class */ (function () {\n    /**\n     * @inheritDoc\n     */\n    function LinkedErrors(options) {\n        if (options === void 0) { options = {}; }\n        /**\n         * @inheritDoc\n         */\n        this.name = LinkedErrors.id;\n        this._key = options.key || DEFAULT_KEY;\n        this._limit = options.limit || DEFAULT_LIMIT;\n    }\n    /**\n     * @inheritDoc\n     */\n    LinkedErrors.prototype.setupOnce = function () {\n        addGlobalEventProcessor(function (event, hint) {\n            var self = getCurrentHub().getIntegration(LinkedErrors);\n            return self ? _handler(self._key, self._limit, event, hint) : event;\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    LinkedErrors.id = 'LinkedErrors';\n    return LinkedErrors;\n}());\nexport { LinkedErrors };\n/**\n * @inheritDoc\n */\nexport function _handler(key, limit, event, hint) {\n    if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {\n        return event;\n    }\n    var linkedErrors = _walkErrorTree(limit, hint.originalException, key);\n    event.exception.values = __spread(linkedErrors, event.exception.values);\n    return event;\n}\n/**\n * JSDOC\n */\nexport function _walkErrorTree(limit, error, key, stack) {\n    if (stack === void 0) { stack = []; }\n    if (!isInstanceOf(error[key], Error) || stack.length + 1 >= limit) {\n        return stack;\n    }\n    var exception = exceptionFromError(error[key]);\n    return _walkErrorTree(limit, error[key], key, __spread([exception], stack));\n}\n//# sourceMappingURL=linkederrors.js.map","import { logger } from '@sentry/utils';\nimport { IS_DEBUG_BUILD } from '../flags';\n/** Deduplication filter */\nvar Dedupe = /** @class */ (function () {\n    function Dedupe() {\n        /**\n         * @inheritDoc\n         */\n        this.name = Dedupe.id;\n    }\n    /**\n     * @inheritDoc\n     */\n    Dedupe.prototype.setupOnce = function (addGlobalEventProcessor, getCurrentHub) {\n        addGlobalEventProcessor(function (currentEvent) {\n            var self = getCurrentHub().getIntegration(Dedupe);\n            if (self) {\n                // Juuust in case something goes wrong\n                try {\n                    if (_shouldDropEvent(currentEvent, self._previousEvent)) {\n                        IS_DEBUG_BUILD && logger.warn('Event dropped due to being a duplicate of previously captured event.');\n                        return null;\n                    }\n                }\n                catch (_oO) {\n                    return (self._previousEvent = currentEvent);\n                }\n                return (self._previousEvent = currentEvent);\n            }\n            return currentEvent;\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    Dedupe.id = 'Dedupe';\n    return Dedupe;\n}());\nexport { Dedupe };\n/** JSDoc */\nfunction _shouldDropEvent(currentEvent, previousEvent) {\n    if (!previousEvent) {\n        return false;\n    }\n    if (_isSameMessageEvent(currentEvent, previousEvent)) {\n        return true;\n    }\n    if (_isSameExceptionEvent(currentEvent, previousEvent)) {\n        return true;\n    }\n    return false;\n}\n/** JSDoc */\nfunction _isSameMessageEvent(currentEvent, previousEvent) {\n    var currentMessage = currentEvent.message;\n    var previousMessage = previousEvent.message;\n    // If neither event has a message property, they were both exceptions, so bail out\n    if (!currentMessage && !previousMessage) {\n        return false;\n    }\n    // If only one event has a stacktrace, but not the other one, they are not the same\n    if ((currentMessage && !previousMessage) || (!currentMessage && previousMessage)) {\n        return false;\n    }\n    if (currentMessage !== previousMessage) {\n        return false;\n    }\n    if (!_isSameFingerprint(currentEvent, previousEvent)) {\n        return false;\n    }\n    if (!_isSameStacktrace(currentEvent, previousEvent)) {\n        return false;\n    }\n    return true;\n}\n/** JSDoc */\nfunction _isSameExceptionEvent(currentEvent, previousEvent) {\n    var previousException = _getExceptionFromEvent(previousEvent);\n    var currentException = _getExceptionFromEvent(currentEvent);\n    if (!previousException || !currentException) {\n        return false;\n    }\n    if (previousException.type !== currentException.type || previousException.value !== currentException.value) {\n        return false;\n    }\n    if (!_isSameFingerprint(currentEvent, previousEvent)) {\n        return false;\n    }\n    if (!_isSameStacktrace(currentEvent, previousEvent)) {\n        return false;\n    }\n    return true;\n}\n/** JSDoc */\nfunction _isSameStacktrace(currentEvent, previousEvent) {\n    var currentFrames = _getFramesFromEvent(currentEvent);\n    var previousFrames = _getFramesFromEvent(previousEvent);\n    // If neither event has a stacktrace, they are assumed to be the same\n    if (!currentFrames && !previousFrames) {\n        return true;\n    }\n    // If only one event has a stacktrace, but not the other one, they are not the same\n    if ((currentFrames && !previousFrames) || (!currentFrames && previousFrames)) {\n        return false;\n    }\n    currentFrames = currentFrames;\n    previousFrames = previousFrames;\n    // If number of frames differ, they are not the same\n    if (previousFrames.length !== currentFrames.length) {\n        return false;\n    }\n    // Otherwise, compare the two\n    for (var i = 0; i < previousFrames.length; i++) {\n        var frameA = previousFrames[i];\n        var frameB = currentFrames[i];\n        if (frameA.filename !== frameB.filename ||\n            frameA.lineno !== frameB.lineno ||\n            frameA.colno !== frameB.colno ||\n            frameA.function !== frameB.function) {\n            return false;\n        }\n    }\n    return true;\n}\n/** JSDoc */\nfunction _isSameFingerprint(currentEvent, previousEvent) {\n    var currentFingerprint = currentEvent.fingerprint;\n    var previousFingerprint = previousEvent.fingerprint;\n    // If neither event has a fingerprint, they are assumed to be the same\n    if (!currentFingerprint && !previousFingerprint) {\n        return true;\n    }\n    // If only one event has a fingerprint, but not the other one, they are not the same\n    if ((currentFingerprint && !previousFingerprint) || (!currentFingerprint && previousFingerprint)) {\n        return false;\n    }\n    currentFingerprint = currentFingerprint;\n    previousFingerprint = previousFingerprint;\n    // Otherwise, compare the two\n    try {\n        return !!(currentFingerprint.join('') === previousFingerprint.join(''));\n    }\n    catch (_oO) {\n        return false;\n    }\n}\n/** JSDoc */\nfunction _getExceptionFromEvent(event) {\n    return event.exception && event.exception.values && event.exception.values[0];\n}\n/** JSDoc */\nfunction _getFramesFromEvent(event) {\n    var exception = event.exception;\n    if (exception) {\n        try {\n            // @ts-ignore Object could be undefined\n            return exception.values[0].stacktrace.frames;\n        }\n        catch (_oO) {\n            return undefined;\n        }\n    }\n    else if (event.stacktrace) {\n        return event.stacktrace.frames;\n    }\n    return undefined;\n}\n//# sourceMappingURL=dedupe.js.map","import { __assign } from \"tslib\";\nimport { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { getGlobalObject } from '@sentry/utils';\nvar global = getGlobalObject();\n/** UserAgent */\nvar UserAgent = /** @class */ (function () {\n    function UserAgent() {\n        /**\n         * @inheritDoc\n         */\n        this.name = UserAgent.id;\n    }\n    /**\n     * @inheritDoc\n     */\n    UserAgent.prototype.setupOnce = function () {\n        addGlobalEventProcessor(function (event) {\n            if (getCurrentHub().getIntegration(UserAgent)) {\n                // if none of the information we want exists, don't bother\n                if (!global.navigator && !global.location && !global.document) {\n                    return event;\n                }\n                // grab as much info as exists and add it to the event\n                var url = (event.request && event.request.url) || (global.location && global.location.href);\n                var referrer = (global.document || {}).referrer;\n                var userAgent = (global.navigator || {}).userAgent;\n                var headers = __assign(__assign(__assign({}, (event.request && event.request.headers)), (referrer && { Referer: referrer })), (userAgent && { 'User-Agent': userAgent }));\n                var request = __assign(__assign({}, (url && { url: url })), { headers: headers });\n                return __assign(__assign({}, event), { request: request });\n            }\n            return event;\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    UserAgent.id = 'UserAgent';\n    return UserAgent;\n}());\nexport { UserAgent };\n//# sourceMappingURL=useragent.js.map","import { __assign } from \"tslib\";\nimport { getCurrentHub, initAndBind, Integrations as CoreIntegrations } from '@sentry/core';\nimport { addInstrumentationHandler, getGlobalObject, logger, resolvedSyncPromise } from '@sentry/utils';\nimport { BrowserClient } from './client';\nimport { IS_DEBUG_BUILD } from './flags';\nimport { wrap as internalWrap } from './helpers';\nimport { Breadcrumbs, Dedupe, GlobalHandlers, LinkedErrors, TryCatch, UserAgent } from './integrations';\nexport var defaultIntegrations = [\n    new CoreIntegrations.InboundFilters(),\n    new CoreIntegrations.FunctionToString(),\n    new TryCatch(),\n    new Breadcrumbs(),\n    new GlobalHandlers(),\n    new LinkedErrors(),\n    new Dedupe(),\n    new UserAgent(),\n];\n/**\n * The Sentry Browser SDK Client.\n *\n * To use this SDK, call the {@link init} function as early as possible when\n * loading the web page. To set context information or send manual events, use\n * the provided methods.\n *\n * @example\n *\n * ```\n *\n * import { init } from '@sentry/browser';\n *\n * init({\n *   dsn: '__DSN__',\n *   // ...\n * });\n * ```\n *\n * @example\n * ```\n *\n * import { configureScope } from '@sentry/browser';\n * configureScope((scope: Scope) => {\n *   scope.setExtra({ battery: 0.7 });\n *   scope.setTag({ user_mode: 'admin' });\n *   scope.setUser({ id: '4711' });\n * });\n * ```\n *\n * @example\n * ```\n *\n * import { addBreadcrumb } from '@sentry/browser';\n * addBreadcrumb({\n *   message: 'My Breadcrumb',\n *   // ...\n * });\n * ```\n *\n * @example\n *\n * ```\n *\n * import * as Sentry from '@sentry/browser';\n * Sentry.captureMessage('Hello, world!');\n * Sentry.captureException(new Error('Good bye'));\n * Sentry.captureEvent({\n *   message: 'Manual',\n *   stacktrace: [\n *     // ...\n *   ],\n * });\n * ```\n *\n * @see {@link BrowserOptions} for documentation on configuration options.\n */\nexport function init(options) {\n    if (options === void 0) { options = {}; }\n    if (options.defaultIntegrations === undefined) {\n        options.defaultIntegrations = defaultIntegrations;\n    }\n    if (options.release === undefined) {\n        var window_1 = getGlobalObject();\n        // This supports the variable that sentry-webpack-plugin injects\n        if (window_1.SENTRY_RELEASE && window_1.SENTRY_RELEASE.id) {\n            options.release = window_1.SENTRY_RELEASE.id;\n        }\n    }\n    if (options.autoSessionTracking === undefined) {\n        options.autoSessionTracking = true;\n    }\n    if (options.sendClientReports === undefined) {\n        options.sendClientReports = true;\n    }\n    initAndBind(BrowserClient, options);\n    if (options.autoSessionTracking) {\n        startSessionTracking();\n    }\n}\n/**\n * Present the user with a report dialog.\n *\n * @param options Everything is optional, we try to fetch all info need from the global scope.\n */\nexport function showReportDialog(options) {\n    if (options === void 0) { options = {}; }\n    var hub = getCurrentHub();\n    var scope = hub.getScope();\n    if (scope) {\n        options.user = __assign(__assign({}, scope.getUser()), options.user);\n    }\n    if (!options.eventId) {\n        options.eventId = hub.lastEventId();\n    }\n    var client = hub.getClient();\n    if (client) {\n        client.showReportDialog(options);\n    }\n}\n/**\n * This is the getter for lastEventId.\n *\n * @returns The last event id of a captured event.\n */\nexport function lastEventId() {\n    return getCurrentHub().lastEventId();\n}\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nexport function forceLoad() {\n    // Noop\n}\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nexport function onLoad(callback) {\n    callback();\n}\n/**\n * Call `flush()` on the current client, if there is one. See {@link Client.flush}.\n *\n * @param timeout Maximum time in ms the client should wait to flush its event queue. Omitting this parameter will cause\n * the client to wait until all events are sent before resolving the promise.\n * @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it\n * doesn't (or if there's no client defined).\n */\nexport function flush(timeout) {\n    var client = getCurrentHub().getClient();\n    if (client) {\n        return client.flush(timeout);\n    }\n    IS_DEBUG_BUILD && logger.warn('Cannot flush events. No client defined.');\n    return resolvedSyncPromise(false);\n}\n/**\n * Call `close()` on the current client, if there is one. See {@link Client.close}.\n *\n * @param timeout Maximum time in ms the client should wait to flush its event queue before shutting down. Omitting this\n * parameter will cause the client to wait until all events are sent before disabling itself.\n * @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it\n * doesn't (or if there's no client defined).\n */\nexport function close(timeout) {\n    var client = getCurrentHub().getClient();\n    if (client) {\n        return client.close(timeout);\n    }\n    IS_DEBUG_BUILD && logger.warn('Cannot flush events and disable SDK. No client defined.');\n    return resolvedSyncPromise(false);\n}\n/**\n * Wrap code within a try/catch block so the SDK is able to capture errors.\n *\n * @param fn A function to wrap.\n *\n * @returns The result of wrapped function call.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function wrap(fn) {\n    return internalWrap(fn)();\n}\nfunction startSessionOnHub(hub) {\n    hub.startSession({ ignoreDuration: true });\n    hub.captureSession();\n}\n/**\n * Enable automatic Session Tracking for the initial page load.\n */\nfunction startSessionTracking() {\n    var window = getGlobalObject();\n    var document = window.document;\n    if (typeof document === 'undefined') {\n        IS_DEBUG_BUILD && logger.warn('Session tracking in non-browser environment with @sentry/browser is not supported.');\n        return;\n    }\n    var hub = getCurrentHub();\n    // The only way for this to be false is for there to be a version mismatch between @sentry/browser (>= 6.0.0) and\n    // @sentry/hub (< 5.27.0). In the simple case, there won't ever be such a mismatch, because the two packages are\n    // pinned at the same version in package.json, but there are edge cases where it's possible. See\n    // https://github.com/getsentry/sentry-javascript/issues/3207 and\n    // https://github.com/getsentry/sentry-javascript/issues/3234 and\n    // https://github.com/getsentry/sentry-javascript/issues/3278.\n    if (!hub.captureSession) {\n        return;\n    }\n    // The session duration for browser sessions does not track a meaningful\n    // concept that can be used as a metric.\n    // Automatically captured sessions are akin to page views, and thus we\n    // discard their duration.\n    startSessionOnHub(hub);\n    // We want to create a session for every navigation as well\n    addInstrumentationHandler('history', function (_a) {\n        var from = _a.from, to = _a.to;\n        // Don't create an additional session for the initial route or if the location did not change\n        if (!(from === undefined || from === to)) {\n            startSessionOnHub(getCurrentHub());\n        }\n    });\n}\n//# sourceMappingURL=sdk.js.map"],"names":["UNKNOWN_FUNCTION","createFrame","filename","func","lineno","colno","frame","function","in_app","undefined","chromeRegex","chromeEvalRegex","chromeStackParser","line","parts","exec","indexOf","subMatch","_a","extractSafariExtensionDetails","geckoREgex","geckoEvalRegex","geckoStackParser","winjsRegex","winjsStackParser","opera10Regex","opera10StackParser","opera11Regex","opera11StackParser","isSafariExtension","isSafariWebExtension","split","exceptionFromError","ex","frames","parseStackFrames","exception","type","name","value","extractMessage","length","stacktrace","eventFromError","values","stack","popSize","framesToPop","reactMinifiedRegexp","test","message","getPopSize","e","error","eventFromUnknownInput","syntheticException","attachStacktrace","isUnhandledRejection","event","is","domException","name_1","eventFromString","tags","code","constructor","extra","__serialized__","normalize","frames_1","eventFromPlainObject","synthetic","input","frames_2","cachedFetchImpl","__SENTRY_DEBUG__","global","getNativeFetchImplementation","fetch","bind","document","fetchImpl","createElement","sandbox","hidden","head","appendChild","contentWindow","removeChild","requestTypeToCategory","ty","BaseTransport","options","_this","this","_buffer","_rateLimits","_outcomes","_api","dsn","_metadata","tunnel","url","sendClientReports","addEventListener","visibilityState","_flushOutcomes","prototype","sendEvent","_sendRequest","sendSession","session","close","timeout","drain","recordLostEvent","reason","category","key","log","outcomes","Object","keys","JSON","stringify","discardedEvents","map","quantity","envelope","body","toString","call","navigator","sendBeacon","supports","fetch_1","method","credentials","keepalive","sendReport","_handleResponse","requestType","response","headers","resolve","reject","status","_isRateLimited","_disabledUntil","Date","FetchTransport","_super","_fetch","sentryRequest","originalPayload","Promise","referrerPolicy","fetchParameters","assign","add","then","get","catch","XHRTransport","apply","arguments","request","XMLHttpRequest","header","onreadystatechange","readyState","getResponseHeader","open","hasOwnProperty","setRequestHeader","send","BrowserBackend","eventFromException","hint","level","event_id","_options","eventFromMessage","_setupTransport","nativeFetch","transportOptions","api","transport","requestOptions","_newTransport","bufferSize","text","statusText","statusCode","_reject","xhr","makeNewXHRTransport","ignoreOnError","shouldIgnoreOnError","wrap","fn","before","wrapper","__sentry_wrapped__","sentryWrapped","args","Array","slice","wrappedArguments","arg","setTimeout","scope","addEventProcessor","mechanism","property","_oO","getOwnPropertyDescriptor","configurable","defineProperty","Breadcrumbs","id","console","dom","history","sentry","addSentryBreadcrumb","addBreadcrumb","setupOnce","_consoleBreadcrumb","_innerDomBreadcrumb","handlerData","target","keyAttrs","serializeAttribute","_domBreadcrumb","_xhrBreadcrumb","_fetchBreadcrumb","_historyBreadcrumb","breadcrumb","data","logger","endTimestamp","__sentry_own_request__","__sentry_xhr__","status_code","fetchData","match","from","to","parsedLoc","location","href","parsedFrom","parsedTo","path","protocol","host","relative","BrowserClient","sdk","packages","version","showReportDialog","_isEnabled","eventId","script","async","src","onLoad","onload","injectionPoint","injectReportDialog","getDsn","_prepareEvent","platform","_sendEvent","integration","getIntegration","DEFAULT_EVENT_TARGET","TryCatch","eventTarget","requestAnimationFrame","setInterval","_wrapTimeFunction","_wrapRAF","_wrapXHR","eventTargetOption","isArray","forEach","_wrapEventTarget","original","_i","originalCallback","handled","callback","handler","originalSend","prop","wrapOptions","originalFunction","proto","eventName","handleEvent","err","originalRemoveEventListener","wrappedEventHandler","originalEventHandler","GlobalHandlers","_installFunc","onerror","_installGlobalOnErrorHandler","onunhandledrejection","_installGlobalOnUnhandledRejectionHandler","Error","stackTraceLimit","installFunc","getHubAndAttachStacktrace","hub","msg","column","ERROR_TYPES_RE","groups","_enhanceEventWithInitialFrame","_eventFromIncompleteOnError","addMechanismAndCapture","detail","String","ev","ev0","ev0s","ev0sf","isNaN","parseInt","push","captureEvent","originalException","client","getClient","getOptions","LinkedErrors","_key","_limit","limit","self","linkedErrors","_walkErrorTree","_handler","Dedupe","addGlobalEventProcessor","getCurrentHub","currentEvent","previousEvent","currentMessage","previousMessage","_isSameFingerprint","_isSameStacktrace","_isSameMessageEvent","previousException","_getExceptionFromEvent","currentException","_isSameExceptionEvent","_shouldDropEvent","_previousEvent","currentFrames","_getFramesFromEvent","previousFrames","i","frameA","frameB","currentFingerprint","fingerprint","previousFingerprint","join","UserAgent","referrer","userAgent","Referer","defaultIntegrations","init","release","window_1","SENTRY_RELEASE","autoSessionTracking","captureSession","startSessionOnHub","startSessionTracking","startSession","ignoreDuration"],"sourceRoot":""}