{"version":3,"sources":["webpack:///./node_modules/@sentry/browser/esm/tracekit.js","webpack:///./node_modules/@sentry/browser/esm/parsers.js","webpack:///./node_modules/@sentry/browser/esm/eventbuilder.js","webpack:///./node_modules/@sentry/browser/esm/transports/utils.js","webpack:///./node_modules/@sentry/browser/esm/transports/base.js","webpack:///./node_modules/@sentry/browser/esm/transports/fetch.js","webpack:///./node_modules/@sentry/browser/esm/transports/xhr.js","webpack:///./node_modules/@sentry/browser/esm/backend.js","webpack:///./node_modules/@sentry/browser/esm/helpers.js","webpack:///./node_modules/@sentry/browser/esm/integrations/breadcrumbs.js","webpack:///./node_modules/@sentry/browser/esm/client.js","webpack:///./node_modules/@sentry/browser/esm/integrations/trycatch.js","webpack:///./node_modules/@sentry/browser/esm/integrations/globalhandlers.js","webpack:///./node_modules/@sentry/browser/esm/integrations/linkederrors.js","webpack:///./node_modules/@sentry/browser/esm/integrations/dedupe.js","webpack:///./node_modules/@sentry/browser/esm/integrations/useragent.js","webpack:///./node_modules/@sentry/browser/esm/sdk.js"],"names":["chrome","gecko","winjs","geckoEval","chromeEval","reactMinifiedRegexp","computeStackTrace","ex","stack","popSize","framesToPop","test","message","stacktrace","parts","opera10Regex","opera11Regex","lines","split","line","length","element","exec","url","func","args","column","push","extractMessage","name","computeStackTraceFromStacktraceProp","popFrames","e","_a","_b","submatch","i","isNative","indexOf","substr","extractSafariExtensionDetails","columnNumber","computeStackTraceFromStackProp","failed","isSafariExtension","isSafariWebExtension","slice","error","exceptionFromStacktrace","frames","prepareFramesForEvent","exception","type","value","undefined","eventFromStacktrace","values","localStack","firstFrameFunction","lastFrameFunction","map","frame","colno","filename","function","in_app","lineno","reverse","eventFromUnknownInput","syntheticException","options","event","is","domException","name_1","eventFromString","tags","code","rejection","constructor","extra","__serialized__","frames_1","eventFromPlainObject","synthetic","input","attachStacktrace","cachedFetchImpl","getNativeFetchImplementation","fetch","bind","document","fetchImpl","createElement","sandbox","hidden","head","appendChild","contentWindow","removeChild","logger","warn","CATEGORY_MAPPING","transaction","session","attachment","BaseTransport","_this","this","_buffer","_rateLimits","_outcomes","_api","dsn","_metadata","tunnel","getStoreEndpointWithUrlEncodedAuth","sendClientReports","addEventListener","visibilityState","_flushOutcomes","prototype","sendEvent","_","close","timeout","drain","recordLostEvent","reason","category","key","log","outcomes","Object","keys","JSON","stringify","getEnvelopeEndpointWithUrlEncodedAuth","envelope","getDsn","toString","timestamp","discarded_events","quantity","body","call","navigator","sendBeacon","supports","fetch_1","method","credentials","keepalive","sendReport","_handleResponse","requestType","response","headers","resolve","reject","status","fromHttpCode","_handleRateLimit","_disabledUntil","Success","all","_isRateLimited","Date","now","e_1","e_2","rlHeader","raHeader","_c","trim","_d","next","done","parameters","headerDelay","parseInt","delay","isNaN","_e","_f","e_2_1","return","e_1_1","_super","FetchTransport","_fetch","_sendRequest","sendSession","sentryRequest","originalPayload","RateLimitBackoff","Promise","referrerPolicy","fetchParameters","assign","add","then","get","catch","QueueOverflow","NetworkError","XHRTransport","apply","arguments","request","XMLHttpRequest","header","onreadystatechange","readyState","getResponseHeader","open","hasOwnProperty","setRequestHeader","send","BrowserBackend","eventFromException","hint","level","Error","event_id","_options","eventFromMessage","Info","_setupTransport","transportOptions","transport","ignoreOnError","shouldIgnoreOnError","ignoreNextOnError","setTimeout","wrap","fn","before","__sentry__","__sentry_wrapped__","sentryWrapped","Array","wrappedArguments","arg","handleEvent","scope","addEventProcessor","processedEvent","mechanism","property","_oO","defineProperty","enumerable","defineProperties","__sentry_original__","getOwnPropertyDescriptor","configurable","Breadcrumbs","id","console","dom","history","sentry","xhr","addSentryBreadcrumb","addBreadcrumb","setupOnce","callback","_i","_consoleBreadcrumb","_domBreadcrumb","_xhrBreadcrumb","_fetchBreadcrumb","_historyBreadcrumb","handlerData","breadcrumb","data","fromString","target","keyAttrs","serializeAttribute","global","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","getReportDialogEndpoint","onLoad","onload","injectionPoint","injectReportDialog","_prepareEvent","platform","_sendEvent","integration","getIntegration","DEFAULT_EVENT_TARGET","TryCatch","eventTarget","requestAnimationFrame","setInterval","_wrapTimeFunction","_wrapRAF","_wrapXHR","isArray","forEach","_wrapEventTarget","original","originalCallback","handled","handler","proto","eventName","err","originalRemoveEventListener","wrappedEventHandler","originalEventHandler","originalSend","xmlHttpRequestProps","prop","wrapOptions","GlobalHandlers","_onErrorHandlerInstalled","_onUnhandledRejectionHandlerInstalled","onerror","onunhandledrejection","stackTraceLimit","_installGlobalOnErrorHandler","_installGlobalOnUnhandledRejectionHandler","currentHub","hasIntegration","isFailedOwnDelivery","client","getClient","msg","_eventFromIncompleteOnError","_enhanceEventWithInitialFrame","getOptions","captureEvent","originalException","detail","_eventFromRejectionWithPrimitive","groups","String","LinkedErrors","_key","_limit","limit","self","_handler","linkedErrors","_walkErrorTree","Dedupe","addGlobalEventProcessor","getCurrentHub","currentEvent","_shouldDropEvent","_previousEvent","previousEvent","_isSameMessageEvent","_isSameExceptionEvent","currentMessage","previousMessage","_isSameFingerprint","_isSameStacktrace","_getFramesFromEvent","currentFrames","previousFrames","frameA","frameB","_getExceptionFromEvent","previousException","currentException","currentFingerprint","fingerprint","previousFingerprint","join","UserAgent","referrer","userAgent","Referer","defaultIntegrations","InboundFilters","FunctionToString","init","release","window_1","SENTRY_RELEASE","autoSessionTracking","hub","startSession","captureSession","ignoreDuration","startSessionTracking"],"mappings":"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","file":"vendors~c30cbe04.d1b0b30d71cdec7a9fa6.chunk.js","sourcesContent":["/**\n * This was originally forked from https://github.com/occ/TraceKit, but has since been\n * largely modified and is now maintained as part of Sentry JS SDK.\n */\nimport { __assign, __read } from \"tslib\";\n// global reference to slice\nvar UNKNOWN_FUNCTION = '?';\n// Chromium based browsers: Chrome, Brave, new Opera, new Edge\nvar chrome = /^\\s*at (?:(.*?) ?\\()?((?:file|https?|blob|chrome-extension|address|native|eval|webpack|<anonymous>|[-a-z]+:|.*bundle|\\/).*?)(?::(\\d+))?(?::(\\d+))?\\)?\\s*$/i;\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 gecko = /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)?((?:file|https?|blob|chrome|webpack|resource|moz-extension|capacitor).*?:\\/.*?|\\[native code\\]|[^@]*(?:bundle|\\d+\\.js)|\\/[\\w\\-. /=]+)(?::(\\d+))?(?::(\\d+))?\\s*$/i;\nvar winjs = /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i;\nvar geckoEval = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\nvar chromeEval = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/;\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;\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\nexport function computeStackTrace(ex) {\n    var stack = null;\n    var popSize = 0;\n    if (ex) {\n        if (typeof ex.framesToPop === 'number') {\n            popSize = ex.framesToPop;\n        }\n        else if (reactMinifiedRegexp.test(ex.message)) {\n            popSize = 1;\n        }\n    }\n    try {\n        // This must be tried first because Opera 10 *destroys*\n        // its stacktrace property if you try to access the stack\n        // property first!!\n        stack = computeStackTraceFromStacktraceProp(ex);\n        if (stack) {\n            return popFrames(stack, popSize);\n        }\n    }\n    catch (e) {\n        // no-empty\n    }\n    try {\n        stack = computeStackTraceFromStackProp(ex);\n        if (stack) {\n            return popFrames(stack, popSize);\n        }\n    }\n    catch (e) {\n        // no-empty\n    }\n    return {\n        message: extractMessage(ex),\n        name: ex && ex.name,\n        stack: [],\n        failed: true,\n    };\n}\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any, complexity\nfunction computeStackTraceFromStackProp(ex) {\n    var _a, _b;\n    if (!ex || !ex.stack) {\n        return null;\n    }\n    var stack = [];\n    var lines = ex.stack.split('\\n');\n    var isEval;\n    var submatch;\n    var parts;\n    var element;\n    for (var i = 0; i < lines.length; ++i) {\n        if ((parts = chrome.exec(lines[i]))) {\n            var isNative = parts[2] && parts[2].indexOf('native') === 0; // start of line\n            isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n            if (isEval && (submatch = chromeEval.exec(parts[2]))) {\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            // Arpad: Working with the regexp above is super painful. it is quite a hack, but just stripping the `address at `\n            // prefix here seems like the quickest solution for now.\n            var url = parts[2] && parts[2].indexOf('address at ') === 0 ? parts[2].substr('address at '.length) : parts[2];\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 func = parts[1] || UNKNOWN_FUNCTION;\n            _a = __read(extractSafariExtensionDetails(func, url), 2), func = _a[0], url = _a[1];\n            element = {\n                url: url,\n                func: func,\n                args: isNative ? [parts[2]] : [],\n                line: parts[3] ? +parts[3] : null,\n                column: parts[4] ? +parts[4] : null,\n            };\n        }\n        else if ((parts = winjs.exec(lines[i]))) {\n            element = {\n                url: parts[2],\n                func: parts[1] || UNKNOWN_FUNCTION,\n                args: [],\n                line: +parts[3],\n                column: parts[4] ? +parts[4] : null,\n            };\n        }\n        else if ((parts = gecko.exec(lines[i]))) {\n            isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n            if (isEval && (submatch = geckoEval.exec(parts[3]))) {\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            else if (i === 0 && !parts[5] && ex.columnNumber !== void 0) {\n                // FireFox uses this awesome columnNumber property for its top frame\n                // Also note, Firefox's column number is 0-based and everything else expects 1-based,\n                // so adding 1\n                // NOTE: this hack doesn't work if top-most frame is eval\n                stack[0].column = ex.columnNumber + 1;\n            }\n            var url = parts[3];\n            var func = parts[1] || UNKNOWN_FUNCTION;\n            _b = __read(extractSafariExtensionDetails(func, url), 2), func = _b[0], url = _b[1];\n            element = {\n                url: url,\n                func: func,\n                args: parts[2] ? parts[2].split(',') : [],\n                line: parts[4] ? +parts[4] : null,\n                column: parts[5] ? +parts[5] : null,\n            };\n        }\n        else {\n            continue;\n        }\n        if (!element.func && element.line) {\n            element.func = UNKNOWN_FUNCTION;\n        }\n        stack.push(element);\n    }\n    if (!stack.length) {\n        return null;\n    }\n    return {\n        message: extractMessage(ex),\n        name: ex.name,\n        stack: stack,\n    };\n}\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction computeStackTraceFromStacktraceProp(ex) {\n    if (!ex || !ex.stacktrace) {\n        return null;\n    }\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;\n    var opera10Regex = / line (\\d+).*script (?:in )?(\\S+)(?:: in function (\\S+))?$/i;\n    var opera11Regex = / line (\\d+), column (\\d+)\\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\\((.*)\\))? in (.*):\\s*$/i;\n    var lines = stacktrace.split('\\n');\n    var stack = [];\n    var parts;\n    for (var line = 0; line < lines.length; line += 2) {\n        var element = null;\n        if ((parts = opera10Regex.exec(lines[line]))) {\n            element = {\n                url: parts[2],\n                func: parts[3],\n                args: [],\n                line: +parts[1],\n                column: null,\n            };\n        }\n        else if ((parts = opera11Regex.exec(lines[line]))) {\n            element = {\n                url: parts[6],\n                func: parts[3] || parts[4],\n                args: parts[5] ? parts[5].split(',') : [],\n                line: +parts[1],\n                column: +parts[2],\n            };\n        }\n        if (element) {\n            if (!element.func && element.line) {\n                element.func = UNKNOWN_FUNCTION;\n            }\n            stack.push(element);\n        }\n    }\n    if (!stack.length) {\n        return null;\n    }\n    return {\n        message: extractMessage(ex),\n        name: ex.name,\n        stack: stack,\n    };\n}\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 * Unfortunatelly \"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, url) {\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:\" + url : \"safari-web-extension:\" + url,\n        ]\n        : [func, url];\n};\n/** Remove N number of frames from the stack */\nfunction popFrames(stacktrace, popSize) {\n    try {\n        return __assign(__assign({}, stacktrace), { stack: stacktrace.stack.slice(popSize) });\n    }\n    catch (e) {\n        return stacktrace;\n    }\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 */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\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//# sourceMappingURL=tracekit.js.map","import { extractExceptionKeysForMessage, isEvent, normalizeToSize } from '@sentry/utils';\nimport { computeStackTrace } from './tracekit';\nvar STACKTRACE_LIMIT = 50;\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 exceptionFromStacktrace(stacktrace) {\n    var frames = prepareFramesForEvent(stacktrace.stack);\n    var exception = {\n        type: stacktrace.name,\n        value: stacktrace.message,\n    };\n    if (frames && 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, rejection) {\n    var event = {\n        exception: {\n            values: [\n                {\n                    type: isEvent(exception) ? exception.constructor.name : rejection ? 'UnhandledRejection' : 'Error',\n                    value: \"Non-Error \" + (rejection ? 'promise rejection' : 'exception') + \" captured with keys: \" + extractExceptionKeysForMessage(exception),\n                },\n            ],\n        },\n        extra: {\n            __serialized__: normalizeToSize(exception),\n        },\n    };\n    if (syntheticException) {\n        var stacktrace = computeStackTrace(syntheticException);\n        var frames_1 = prepareFramesForEvent(stacktrace.stack);\n        event.stacktrace = {\n            frames: frames_1,\n        };\n    }\n    return event;\n}\n/**\n * @hidden\n */\nexport function eventFromStacktrace(stacktrace) {\n    var exception = exceptionFromStacktrace(stacktrace);\n    return {\n        exception: {\n            values: [exception],\n        },\n    };\n}\n/**\n * @hidden\n */\nexport function prepareFramesForEvent(stack) {\n    if (!stack || !stack.length) {\n        return [];\n    }\n    var localStack = stack;\n    var firstFrameFunction = localStack[0].func || '';\n    var lastFrameFunction = localStack[localStack.length - 1].func || '';\n    // If stack starts with one of our API calls, remove it (starts, meaning it's the top of the stack - aka last call)\n    if (firstFrameFunction.indexOf('captureMessage') !== -1 || firstFrameFunction.indexOf('captureException') !== -1) {\n        localStack = localStack.slice(1);\n    }\n    // If stack ends with one of our internal API calls, remove it (ends, meaning it's the bottom of the stack - aka top-most call)\n    if (lastFrameFunction.indexOf('sentryWrapped') !== -1) {\n        localStack = localStack.slice(0, -1);\n    }\n    // The frame where the crash happened, should be the last entry in the array\n    return localStack\n        .slice(0, STACKTRACE_LIMIT)\n        .map(function (frame) { return ({\n        colno: frame.column === null ? undefined : frame.column,\n        filename: frame.url || localStack[0].url,\n        function: frame.func || '?',\n        in_app: true,\n        lineno: frame.line === null ? undefined : frame.line,\n    }); })\n        .reverse();\n}\n//# sourceMappingURL=parsers.js.map","import { __assign } from \"tslib\";\nimport { Severity } from '@sentry/types';\nimport { addExceptionMechanism, addExceptionTypeValue, isDOMError, isDOMException, isError, isErrorEvent, isEvent, isPlainObject, SyncPromise, } from '@sentry/utils';\nimport { eventFromPlainObject, eventFromStacktrace, prepareFramesForEvent } from './parsers';\nimport { computeStackTrace } from './tracekit';\n/**\n * Builds and Event from a Exception\n * @hidden\n */\nexport function eventFromException(options, exception, hint) {\n    var syntheticException = (hint && hint.syntheticException) || undefined;\n    var event = eventFromUnknownInput(exception, syntheticException, {\n        attachStacktrace: options.attachStacktrace,\n    });\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 SyncPromise.resolve(event);\n}\n/**\n * Builds and Event from a Message\n * @hidden\n */\nexport function eventFromMessage(options, message, level, hint) {\n    if (level === void 0) { level = Severity.Info; }\n    var syntheticException = (hint && hint.syntheticException) || undefined;\n    var event = eventFromString(message, syntheticException, {\n        attachStacktrace: options.attachStacktrace,\n    });\n    event.level = level;\n    if (hint && hint.event_id) {\n        event.event_id = hint.event_id;\n    }\n    return SyncPromise.resolve(event);\n}\n/**\n * @hidden\n */\nexport function eventFromUnknownInput(exception, syntheticException, options) {\n    if (options === void 0) { options = {}; }\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        // eslint-disable-next-line no-param-reassign\n        exception = errorEvent.error;\n        event = eventFromStacktrace(computeStackTrace(exception));\n        return event;\n    }\n    if (isDOMError(exception) || isDOMException(exception)) {\n        // If it is a DOMError or DOMException (which are legacy APIs, but still supported in some browsers)\n        // then we just extract the name, code, and message, as they don't provide anything else\n        // https://developer.mozilla.org/en-US/docs/Web/API/DOMError\n        // https://developer.mozilla.org/en-US/docs/Web/API/DOMException\n        var domException = exception;\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, options);\n        addExceptionTypeValue(event, message);\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        event = eventFromStacktrace(computeStackTrace(exception));\n        return event;\n    }\n    if (isPlainObject(exception) || isEvent(exception)) {\n        // If it is plain Object or Event, serialize it manually and extract options\n        // This will allow us to group events based on top-level keys\n        // which is much better than creating new group when any key/value change\n        var objectException = exception;\n        event = eventFromPlainObject(objectException, syntheticException, options.rejection);\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, options);\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, options) {\n    if (options === void 0) { options = {}; }\n    var event = {\n        message: input,\n    };\n    if (options.attachStacktrace && syntheticException) {\n        var stacktrace = computeStackTrace(syntheticException);\n        var frames_1 = prepareFramesForEvent(stacktrace.stack);\n        event.stacktrace = {\n            frames: frames_1,\n        };\n    }\n    return event;\n}\n//# sourceMappingURL=eventbuilder.js.map","import { forget, getGlobalObject, isNativeFetch, logger, supportsFetch } from '@sentry/utils';\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    var _a, _b;\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 (typeof ((_a = document) === null || _a === void 0 ? void 0 : _a.createElement) === \"function\") {\n        try {\n            var sandbox = document.createElement('iframe');\n            sandbox.hidden = true;\n            document.head.appendChild(sandbox);\n            if ((_b = sandbox.contentWindow) === null || _b === void 0 ? void 0 : _b.fetch) {\n                fetchImpl = sandbox.contentWindow.fetch;\n            }\n            document.head.removeChild(sandbox);\n        }\n        catch (e) {\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","import { __assign, __read, __values } from \"tslib\";\nimport { API } from '@sentry/core';\nimport { Status, } from '@sentry/types';\nimport { dateTimestampInSeconds, getGlobalObject, logger, parseRetryAfterHeader, PromiseBuffer, SentryError, } from '@sentry/utils';\nimport { sendReport } from './utils';\nvar CATEGORY_MAPPING = {\n    event: 'error',\n    transaction: 'transaction',\n    session: 'session',\n    attachment: 'attachment',\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 = new PromiseBuffer(30);\n        /** Locks transport after receiving rate limits in a response */\n        this._rateLimits = {};\n        this._outcomes = {};\n        this._api = new API(options.dsn, options._metadata, options.tunnel);\n        // eslint-disable-next-line deprecation/deprecation\n        this.url = this._api.getStoreEndpointWithUrlEncodedAuth();\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 (_) {\n        throw new SentryError('Transport Class has to implement `sendEvent` method');\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 = CATEGORY_MAPPING[category] + \":\" + reason;\n        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            logger.log('No outcomes to flush');\n            return;\n        }\n        logger.log(\"Flushing outcomes:\\n\" + JSON.stringify(outcomes, null, 2));\n        var url = this._api.getEnvelopeEndpointWithUrlEncodedAuth();\n        // Envelope header is required to be at least an empty object\n        var envelopeHeader = JSON.stringify(__assign({}, (this.options.tunnel && { dsn: this._api.getDsn().toString() })));\n        var itemHeaders = JSON.stringify({\n            type: 'client_report',\n        });\n        var item = JSON.stringify({\n            timestamp: dateTimestampInSeconds(),\n            discarded_events: 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            }),\n        });\n        var envelope = envelopeHeader + \"\\n\" + itemHeaders + \"\\n\" + item;\n        try {\n            sendReport(url, envelope);\n        }\n        catch (e) {\n            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 = Status.fromHttpCode(response.status);\n        /**\n         * \"The name is case-insensitive.\"\n         * https://developer.mozilla.org/en-US/docs/Web/API/Headers/get\n         */\n        var limited = this._handleRateLimit(headers);\n        if (limited)\n            logger.warn(\"Too many \" + requestType + \" requests, backing off until: \" + this._disabledUntil(requestType));\n        if (status === 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    BaseTransport.prototype._disabledUntil = function (requestType) {\n        var category = CATEGORY_MAPPING[requestType];\n        return this._rateLimits[category] || this._rateLimits.all;\n    };\n    /**\n     * Checks if a category is rate limited\n     */\n    BaseTransport.prototype._isRateLimited = function (requestType) {\n        return this._disabledUntil(requestType) > new Date(Date.now());\n    };\n    /**\n     * Sets internal _rateLimits from incoming headers. Returns true if headers contains a non-empty rate limiting header.\n     */\n    BaseTransport.prototype._handleRateLimit = function (headers) {\n        var e_1, _a, e_2, _b;\n        var now = Date.now();\n        var rlHeader = headers['x-sentry-rate-limits'];\n        var raHeader = headers['retry-after'];\n        if (rlHeader) {\n            try {\n                // rate limit headers are of the form\n                //     <header>,<header>,..\n                // where each <header> is of the form\n                //     <retry_after>: <categories>: <scope>: <reason_code>\n                // where\n                //     <retry_after> is a delay in ms\n                //     <categories> is the event type(s) (error, transaction, etc) being rate limited and is of the form\n                //         <category>;<category>;...\n                //     <scope> is what's being limited (org, project, or key) - ignored by SDK\n                //     <reason_code> is an arbitrary string like \"org_quota\" - ignored by SDK\n                for (var _c = __values(rlHeader.trim().split(',')), _d = _c.next(); !_d.done; _d = _c.next()) {\n                    var limit = _d.value;\n                    var parameters = limit.split(':', 2);\n                    var headerDelay = parseInt(parameters[0], 10);\n                    var delay = (!isNaN(headerDelay) ? headerDelay : 60) * 1000; // 60sec default\n                    try {\n                        for (var _e = (e_2 = void 0, __values(parameters[1].split(';'))), _f = _e.next(); !_f.done; _f = _e.next()) {\n                            var category = _f.value;\n                            this._rateLimits[category || 'all'] = new Date(now + delay);\n                        }\n                    }\n                    catch (e_2_1) { e_2 = { error: e_2_1 }; }\n                    finally {\n                        try {\n                            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);\n                        }\n                        finally { if (e_2) throw e_2.error; }\n                    }\n                }\n            }\n            catch (e_1_1) { e_1 = { error: e_1_1 }; }\n            finally {\n                try {\n                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);\n                }\n                finally { if (e_1) throw e_1.error; }\n            }\n            return true;\n        }\n        else if (raHeader) {\n            this._rateLimits.all = new Date(now + parseRetryAfterHeader(now, raHeader));\n            return true;\n        }\n        return false;\n    };\n    return BaseTransport;\n}());\nexport { BaseTransport };\n//# sourceMappingURL=base.js.map","import { __extends } from \"tslib\";\nimport { eventToSentryRequest, sessionToSentryRequest } from '@sentry/core';\nimport { Outcome } from '@sentry/types';\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     * @inheritDoc\n     */\n    FetchTransport.prototype.sendEvent = function (event) {\n        return this._sendRequest(eventToSentryRequest(event, this._api), event);\n    };\n    /**\n     * @inheritDoc\n     */\n    FetchTransport.prototype.sendSession = function (session) {\n        return this._sendRequest(sessionToSentryRequest(session, this._api), session);\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        if (this._isRateLimited(sentryRequest.type)) {\n            this.recordLostEvent(Outcome.RateLimitBackoff, sentryRequest.type);\n            return Promise.reject({\n                event: originalPayload,\n                type: sentryRequest.type,\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            // https://caniuse.com/#feat=referrer-policy\n            // It doesn't. And it throw 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(Outcome.QueueOverflow, sentryRequest.type);\n            }\n            else {\n                _this.recordLostEvent(Outcome.NetworkError, 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 { eventToSentryRequest, sessionToSentryRequest } from '@sentry/core';\nimport { Outcome } from '@sentry/types';\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     * @inheritDoc\n     */\n    XHRTransport.prototype.sendEvent = function (event) {\n        return this._sendRequest(eventToSentryRequest(event, this._api), event);\n    };\n    /**\n     * @inheritDoc\n     */\n    XHRTransport.prototype.sendSession = function (session) {\n        return this._sendRequest(sessionToSentryRequest(session, this._api), session);\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        if (this._isRateLimited(sentryRequest.type)) {\n            this.recordLostEvent(Outcome.RateLimitBackoff, sentryRequest.type);\n            return Promise.reject({\n                event: originalPayload,\n                type: sentryRequest.type,\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(Outcome.QueueOverflow, sentryRequest.type);\n            }\n            else {\n                _this.recordLostEvent(Outcome.NetworkError, 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 } from '@sentry/core';\nimport { Severity } from '@sentry/types';\nimport { supportsFetch } from '@sentry/utils';\nimport { eventFromException, eventFromMessage } from './eventbuilder';\nimport { FetchTransport, 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(this._options, exception, hint);\n    };\n    /**\n     * @inheritDoc\n     */\n    BrowserBackend.prototype.eventFromMessage = function (message, level, hint) {\n        if (level === void 0) { level = Severity.Info; }\n        return eventFromMessage(this._options, message, level, hint);\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        if (this._options.transport) {\n            return new this._options.transport(transportOptions);\n        }\n        if (supportsFetch()) {\n            return new FetchTransport(transportOptions);\n        }\n        return new XHRTransport(transportOptions);\n    };\n    return BrowserBackend;\n}(BaseBackend));\nexport { BrowserBackend };\n//# sourceMappingURL=backend.js.map","import { __assign } from \"tslib\";\nimport { API, captureException, withScope } from '@sentry/core';\nimport { addExceptionMechanism, addExceptionTypeValue, getGlobalObject, logger } from '@sentry/utils';\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    if (options === void 0) { options = {}; }\n    if (typeof fn !== 'function') {\n        return fn;\n    }\n    try {\n        // We don't wanna wrap it twice\n        if (fn.__sentry__) {\n            return fn;\n        }\n        // If this has already been wrapped in the past, return that wrapped function\n        if (fn.__sentry_wrapped__) {\n            return fn.__sentry_wrapped__;\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            if (fn.handleEvent) {\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                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n                return fn.handleEvent.apply(this, wrappedArguments);\n            }\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                    var processedEvent = __assign({}, event);\n                    if (options.mechanism) {\n                        addExceptionTypeValue(processedEvent, undefined, undefined);\n                        addExceptionMechanism(processedEvent, options.mechanism);\n                    }\n                    processedEvent.extra = __assign(__assign({}, processedEvent.extra), { arguments: args });\n                    return processedEvent;\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    fn.prototype = fn.prototype || {};\n    sentryWrapped.prototype = fn.prototype;\n    Object.defineProperty(fn, '__sentry_wrapped__', {\n        enumerable: false,\n        value: sentryWrapped,\n    });\n    // Signal that this function has been wrapped/filled already\n    // for both debugging and to prevent it to being wrapped/filled twice\n    Object.defineProperties(sentryWrapped, {\n        __sentry__: {\n            enumerable: false,\n            value: true,\n        },\n        __sentry_original__: {\n            enumerable: false,\n            value: fn,\n        },\n    });\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        logger.error(\"Missing eventId option in showReportDialog call\");\n        return;\n    }\n    if (!options.dsn) {\n        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 = new API(options.dsn).getReportDialogEndpoint(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, __read, __spread } 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, } 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        var _this = this;\n        if (this._options.console) {\n            addInstrumentationHandler({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._consoleBreadcrumb.apply(_this, __spread(args));\n                },\n                type: 'console',\n            });\n        }\n        if (this._options.dom) {\n            addInstrumentationHandler({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._domBreadcrumb.apply(_this, __spread(args));\n                },\n                type: 'dom',\n            });\n        }\n        if (this._options.xhr) {\n            addInstrumentationHandler({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._xhrBreadcrumb.apply(_this, __spread(args));\n                },\n                type: 'xhr',\n            });\n        }\n        if (this._options.fetch) {\n            addInstrumentationHandler({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._fetchBreadcrumb.apply(_this, __spread(args));\n                },\n                type: 'fetch',\n            });\n        }\n        if (this._options.history) {\n            addInstrumentationHandler({\n                callback: function () {\n                    var args = [];\n                    for (var _i = 0; _i < arguments.length; _i++) {\n                        args[_i] = arguments[_i];\n                    }\n                    _this._historyBreadcrumb.apply(_this, __spread(args));\n                },\n                type: 'history',\n            });\n        }\n    };\n    /**\n     * Creates breadcrumbs from console API calls\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Breadcrumbs.prototype._consoleBreadcrumb = function (handlerData) {\n        var breadcrumb = {\n            category: 'console',\n            data: {\n                arguments: handlerData.args,\n                logger: 'console',\n            },\n            level: Severity.fromString(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 DOM API calls\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Breadcrumbs.prototype._domBreadcrumb = function (handlerData) {\n        var target;\n        var keyAttrs = typeof this._options.dom === 'object' ? this._options.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    /**\n     * Creates breadcrumbs from XHR API calls\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Breadcrumbs.prototype._xhrBreadcrumb = function (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\n    Breadcrumbs.prototype._fetchBreadcrumb = function (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\n    Breadcrumbs.prototype._historyBreadcrumb = function (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    /**\n     * @inheritDoc\n     */\n    Breadcrumbs.id = 'Breadcrumbs';\n    return Breadcrumbs;\n}());\nexport { Breadcrumbs };\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 { 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            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 } 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', this._wrapTimeFunction.bind(this));\n        }\n        if (this._options.setInterval) {\n            fill(global, 'setInterval', this._wrapTimeFunction.bind(this));\n        }\n        if (this._options.requestAnimationFrame) {\n            fill(global, 'requestAnimationFrame', this._wrapRAF.bind(this));\n        }\n        if (this._options.XMLHttpRequest && 'XMLHttpRequest' in global) {\n            fill(XMLHttpRequest.prototype, 'send', this._wrapXHR.bind(this));\n        }\n        if (this._options.eventTarget) {\n            var eventTarget = Array.isArray(this._options.eventTarget) ? this._options.eventTarget : DEFAULT_EVENT_TARGET;\n            eventTarget.forEach(this._wrapEventTarget.bind(this));\n        }\n    };\n    /** JSDoc */\n    TryCatch.prototype._wrapTimeFunction = function (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\n    TryCatch.prototype._wrapRAF = function (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.call(this, 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    /** JSDoc */\n    TryCatch.prototype._wrapEventTarget = function (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.call(this, 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                }), options);\n            };\n        });\n        fill(proto, 'removeEventListener', function (originalRemoveEventListener) {\n            return function (eventName, fn, options) {\n                var _a;\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 = (_a = wrappedEventHandler) === null || _a === void 0 ? void 0 : _a.__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    /** JSDoc */\n    TryCatch.prototype._wrapXHR = function (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                        if (original.__sentry_original__) {\n                            wrapOptions.mechanism.data.handler = getFunctionName(original.__sentry_original__);\n                        }\n                        // Otherwise wrap directly\n                        return wrap(original, wrapOptions);\n                    });\n                }\n            });\n            return originalSend.apply(this, args);\n        };\n    };\n    /**\n     * @inheritDoc\n     */\n    TryCatch.id = 'TryCatch';\n    return TryCatch;\n}());\nexport { TryCatch };\n//# sourceMappingURL=trycatch.js.map","import { __assign } 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 { 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        /** JSDoc */\n        this._onErrorHandlerInstalled = false;\n        /** JSDoc */\n        this._onUnhandledRejectionHandlerInstalled = false;\n        this._options = __assign({ onerror: true, onunhandledrejection: true }, options);\n    }\n    /**\n     * @inheritDoc\n     */\n    GlobalHandlers.prototype.setupOnce = function () {\n        Error.stackTraceLimit = 50;\n        if (this._options.onerror) {\n            logger.log('Global Handler attached: onerror');\n            this._installGlobalOnErrorHandler();\n        }\n        if (this._options.onunhandledrejection) {\n            logger.log('Global Handler attached: onunhandledrejection');\n            this._installGlobalOnUnhandledRejectionHandler();\n        }\n    };\n    /** JSDoc */\n    GlobalHandlers.prototype._installGlobalOnErrorHandler = function () {\n        var _this = this;\n        if (this._onErrorHandlerInstalled) {\n            return;\n        }\n        addInstrumentationHandler({\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            callback: function (data) {\n                var error = data.error;\n                var currentHub = getCurrentHub();\n                var hasIntegration = currentHub.getIntegration(GlobalHandlers);\n                var isFailedOwnDelivery = error && error.__sentry_own_request__ === true;\n                if (!hasIntegration || shouldIgnoreOnError() || isFailedOwnDelivery) {\n                    return;\n                }\n                var client = currentHub.getClient();\n                var event = error === undefined && isString(data.msg)\n                    ? _this._eventFromIncompleteOnError(data.msg, data.url, data.line, data.column)\n                    : _this._enhanceEventWithInitialFrame(eventFromUnknownInput(error || data.msg, undefined, {\n                        attachStacktrace: client && client.getOptions().attachStacktrace,\n                        rejection: false,\n                    }), data.url, data.line, data.column);\n                addExceptionMechanism(event, {\n                    handled: false,\n                    type: 'onerror',\n                });\n                currentHub.captureEvent(event, {\n                    originalException: error,\n                });\n            },\n            type: 'error',\n        });\n        this._onErrorHandlerInstalled = true;\n    };\n    /** JSDoc */\n    GlobalHandlers.prototype._installGlobalOnUnhandledRejectionHandler = function () {\n        var _this = this;\n        if (this._onUnhandledRejectionHandlerInstalled) {\n            return;\n        }\n        addInstrumentationHandler({\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            callback: function (e) {\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                var currentHub = getCurrentHub();\n                var hasIntegration = currentHub.getIntegration(GlobalHandlers);\n                var isFailedOwnDelivery = error && error.__sentry_own_request__ === true;\n                if (!hasIntegration || shouldIgnoreOnError() || isFailedOwnDelivery) {\n                    return true;\n                }\n                var client = currentHub.getClient();\n                var event = isPrimitive(error)\n                    ? _this._eventFromRejectionWithPrimitive(error)\n                    : eventFromUnknownInput(error, undefined, {\n                        attachStacktrace: client && client.getOptions().attachStacktrace,\n                        rejection: true,\n                    });\n                event.level = Severity.Error;\n                addExceptionMechanism(event, {\n                    handled: false,\n                    type: 'onunhandledrejection',\n                });\n                currentHub.captureEvent(event, {\n                    originalException: error,\n                });\n                return;\n            },\n            type: 'unhandledrejection',\n        });\n        this._onUnhandledRejectionHandlerInstalled = true;\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\n    GlobalHandlers.prototype._eventFromIncompleteOnError = function (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;\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 || 'Error',\n                        value: message,\n                    },\n                ],\n            },\n        };\n        return this._enhanceEventWithInitialFrame(event, url, line, column);\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     */\n    GlobalHandlers.prototype._eventFromRejectionWithPrimitive = function (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    /** JSDoc */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    GlobalHandlers.prototype._enhanceEventWithInitialFrame = function (event, url, line, column) {\n        event.exception = event.exception || {};\n        event.exception.values = event.exception.values || [];\n        event.exception.values[0] = event.exception.values[0] || {};\n        event.exception.values[0].stacktrace = event.exception.values[0].stacktrace || {};\n        event.exception.values[0].stacktrace.frames = event.exception.values[0].stacktrace.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        if (event.exception.values[0].stacktrace.frames.length === 0) {\n            event.exception.values[0].stacktrace.frames.push({\n                colno: colno,\n                filename: filename,\n                function: '?',\n                in_app: true,\n                lineno: lineno,\n            });\n        }\n        return event;\n    };\n    /**\n     * @inheritDoc\n     */\n    GlobalHandlers.id = 'GlobalHandlers';\n    return GlobalHandlers;\n}());\nexport { GlobalHandlers };\n//# sourceMappingURL=globalhandlers.js.map","import { __read, __spread } from \"tslib\";\nimport { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { isInstanceOf } from '@sentry/utils';\nimport { exceptionFromStacktrace } from '../parsers';\nimport { computeStackTrace } from '../tracekit';\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            if (self) {\n                var handler = self._handler && self._handler.bind(self);\n                return typeof handler === 'function' ? handler(event, hint) : event;\n            }\n            return event;\n        });\n    };\n    /**\n     * @inheritDoc\n     */\n    LinkedErrors.prototype._handler = function (event, hint) {\n        if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {\n            return event;\n        }\n        var linkedErrors = this._walkErrorTree(hint.originalException, this._key);\n        event.exception.values = __spread(linkedErrors, event.exception.values);\n        return event;\n    };\n    /**\n     * @inheritDoc\n     */\n    LinkedErrors.prototype._walkErrorTree = function (error, key, stack) {\n        if (stack === void 0) { stack = []; }\n        if (!isInstanceOf(error[key], Error) || stack.length + 1 >= this._limit) {\n            return stack;\n        }\n        var stacktrace = computeStackTrace(error[key]);\n        var exception = exceptionFromStacktrace(stacktrace);\n        return this._walkErrorTree(error[key], key, __spread([exception], stack));\n    };\n    /**\n     * @inheritDoc\n     */\n    LinkedErrors.id = 'LinkedErrors';\n    return LinkedErrors;\n}());\nexport { LinkedErrors };\n//# sourceMappingURL=linkederrors.js.map","import { logger } from '@sentry/utils';\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 (self._shouldDropEvent(currentEvent, self._previousEvent)) {\n                        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    /** JSDoc */\n    Dedupe.prototype._shouldDropEvent = function (currentEvent, previousEvent) {\n        if (!previousEvent) {\n            return false;\n        }\n        if (this._isSameMessageEvent(currentEvent, previousEvent)) {\n            return true;\n        }\n        if (this._isSameExceptionEvent(currentEvent, previousEvent)) {\n            return true;\n        }\n        return false;\n    };\n    /** JSDoc */\n    Dedupe.prototype._isSameMessageEvent = function (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 (!this._isSameFingerprint(currentEvent, previousEvent)) {\n            return false;\n        }\n        if (!this._isSameStacktrace(currentEvent, previousEvent)) {\n            return false;\n        }\n        return true;\n    };\n    /** JSDoc */\n    Dedupe.prototype._getFramesFromEvent = function (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    /** JSDoc */\n    Dedupe.prototype._isSameStacktrace = function (currentEvent, previousEvent) {\n        var currentFrames = this._getFramesFromEvent(currentEvent);\n        var previousFrames = this._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 */\n    Dedupe.prototype._getExceptionFromEvent = function (event) {\n        return event.exception && event.exception.values && event.exception.values[0];\n    };\n    /** JSDoc */\n    Dedupe.prototype._isSameExceptionEvent = function (currentEvent, previousEvent) {\n        var previousException = this._getExceptionFromEvent(previousEvent);\n        var currentException = this._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 (!this._isSameFingerprint(currentEvent, previousEvent)) {\n            return false;\n        }\n        if (!this._isSameStacktrace(currentEvent, previousEvent)) {\n            return false;\n        }\n        return true;\n    };\n    /** JSDoc */\n    Dedupe.prototype._isSameFingerprint = function (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    /**\n     * @inheritDoc\n     */\n    Dedupe.id = 'Dedupe';\n    return Dedupe;\n}());\nexport { Dedupe };\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            var _a, _b, _c;\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 = ((_a = event.request) === null || _a === void 0 ? void 0 : _a.url) || ((_b = global.location) === null || _b === void 0 ? void 0 : _b.href);\n                var referrer = (global.document || {}).referrer;\n                var userAgent = (global.navigator || {}).userAgent;\n                var headers = __assign(__assign(__assign({}, (_c = event.request) === null || _c === void 0 ? void 0 : _c.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, SyncPromise } from '@sentry/utils';\nimport { BrowserClient } from './client';\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    logger.warn('Cannot flush events. No client defined.');\n    return SyncPromise.resolve(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    logger.warn('Cannot flush events and disable SDK. No client defined.');\n    return SyncPromise.resolve(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}\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        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 (typeof hub.startSession !== 'function' || typeof hub.captureSession !== 'function') {\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    hub.startSession({ ignoreDuration: true });\n    hub.captureSession();\n    // We want to create a session for every navigation as well\n    addInstrumentationHandler({\n        callback: 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                return;\n            }\n            hub.startSession({ ignoreDuration: true });\n            hub.captureSession();\n        },\n        type: 'history',\n    });\n}\n//# sourceMappingURL=sdk.js.map"],"sourceRoot":""}