{"version":3,"file":"vendors-4b17d0e8.xxxxxxxx.bundle.js","mappings":"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","sources":["webpack://iadviser/./node_modules/@sentry/browser/esm/eventbuilder.js","webpack://iadviser/./node_modules/@sentry/browser/esm/helpers.js","webpack://iadviser/./node_modules/@sentry/browser/esm/integrations/breadcrumbs.js","webpack://iadviser/./node_modules/@sentry/browser/esm/client.js","webpack://iadviser/./node_modules/@sentry/browser/esm/integrations/globalhandlers.js","webpack://iadviser/./node_modules/@sentry/browser/esm/integrations/trycatch.js","webpack://iadviser/./node_modules/@sentry/browser/esm/integrations/linkederrors.js","webpack://iadviser/./node_modules/@sentry/browser/esm/integrations/httpcontext.js","webpack://iadviser/./node_modules/@sentry/browser/esm/integrations/dedupe.js","webpack://iadviser/./node_modules/@sentry/browser/esm/stack-parsers.js","webpack://iadviser/./node_modules/@sentry/browser/esm/transports/utils.js","webpack://iadviser/./node_modules/@sentry/browser/esm/transports/fetch.js","webpack://iadviser/./node_modules/@sentry/browser/esm/transports/xhr.js","webpack://iadviser/./node_modules/@sentry/browser/esm/sdk.js"],"sourcesContent":["import { getCurrentHub } from '@sentry/core';\nimport { addExceptionMechanism, resolvedSyncPromise, isErrorEvent, isDOMError, isDOMException, addExceptionTypeValue, isError, isPlainObject, isEvent, extractExceptionKeysForMessage, normalizeToSize } from '@sentry/utils';\n\n/**\n * This function creates an exception from a JavaScript Error\n */\nfunction exceptionFromError(stackParser, ex) {\n // Get the frames first since Opera can lose the stack if we touch anything else first\n const frames = parseStackFrames(stackParser, ex);\n\n const exception = {\n type: ex && ex.name,\n value: extractMessage(ex),\n };\n\n if (frames.length) {\n exception.stacktrace = { frames };\n }\n\n if (exception.type === undefined && exception.value === '') {\n exception.value = 'Unrecoverable error caught';\n }\n\n return exception;\n}\n\n/**\n * @hidden\n */\nfunction eventFromPlainObject(\n stackParser,\n exception,\n syntheticException,\n isUnhandledRejection,\n) {\n const hub = getCurrentHub();\n const client = hub.getClient();\n const normalizeDepth = client && client.getOptions().normalizeDepth;\n\n const event = {\n exception: {\n values: [\n {\n type: isEvent(exception) ? exception.constructor.name : isUnhandledRejection ? 'UnhandledRejection' : 'Error',\n value: `Non-Error ${\n isUnhandledRejection ? 'promise rejection' : 'exception'\n } captured with keys: ${extractExceptionKeysForMessage(exception)}`,\n },\n ],\n },\n extra: {\n __serialized__: normalizeToSize(exception, normalizeDepth),\n },\n };\n\n if (syntheticException) {\n const frames = parseStackFrames(stackParser, syntheticException);\n if (frames.length) {\n // event.exception.values[0] has been set above\n (event.exception ).values[0].stacktrace = { frames };\n }\n }\n\n return event;\n}\n\n/**\n * @hidden\n */\nfunction eventFromError(stackParser, ex) {\n return {\n exception: {\n values: [exceptionFromError(stackParser, ex)],\n },\n };\n}\n\n/** Parses stack frames from an error */\nfunction parseStackFrames(\n stackParser,\n ex,\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 const stacktrace = ex.stacktrace || ex.stack || '';\n\n const popSize = getPopSize(ex);\n\n try {\n return stackParser(stacktrace, popSize);\n } catch (e) {\n // no-empty\n }\n\n return [];\n}\n\n// Based on our own mapping pattern - https://github.com/getsentry/sentry/blob/9f08305e09866c8bd6d0c24f5b0aabdd7dd6c59c/src/sentry/lang/javascript/errormapping.py#L83-L108\nconst reactMinifiedRegexp = /Minified React error #\\d+;/i;\n\nfunction getPopSize(ex) {\n if (ex) {\n if (typeof ex.framesToPop === 'number') {\n return ex.framesToPop;\n }\n\n if (reactMinifiedRegexp.test(ex.message)) {\n return 1;\n }\n }\n\n return 0;\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 */\nfunction extractMessage(ex) {\n const message = ex && ex.message;\n if (!message) {\n return 'No error message';\n }\n if (message.error && typeof message.error.message === 'string') {\n return message.error.message;\n }\n return message;\n}\n\n/**\n * Creates an {@link Event} from all inputs to `captureException` and non-primitive inputs to `captureMessage`.\n * @hidden\n */\nfunction eventFromException(\n stackParser,\n exception,\n hint,\n attachStacktrace,\n) {\n const syntheticException = (hint && hint.syntheticException) || undefined;\n const event = eventFromUnknownInput(stackParser, exception, syntheticException, attachStacktrace);\n addExceptionMechanism(event); // defaults to { type: 'generic', handled: true }\n event.level = 'error';\n if (hint && hint.event_id) {\n event.event_id = hint.event_id;\n }\n return resolvedSyncPromise(event);\n}\n\n/**\n * Builds and Event from a Message\n * @hidden\n */\nfunction eventFromMessage(\n stackParser,\n message,\n // eslint-disable-next-line deprecation/deprecation\n level = 'info',\n hint,\n attachStacktrace,\n) {\n const syntheticException = (hint && hint.syntheticException) || undefined;\n const event = eventFromString(stackParser, message, syntheticException, attachStacktrace);\n event.level = level;\n if (hint && hint.event_id) {\n event.event_id = hint.event_id;\n }\n return resolvedSyncPromise(event);\n}\n\n/**\n * @hidden\n */\nfunction eventFromUnknownInput(\n stackParser,\n exception,\n syntheticException,\n attachStacktrace,\n isUnhandledRejection,\n) {\n let event;\n\n if (isErrorEvent(exception ) && (exception ).error) {\n // If it is an ErrorEvent with `error` property, extract it to get actual Error\n const errorEvent = exception ;\n return eventFromError(stackParser, errorEvent.error );\n }\n\n // If it is a `DOMError` (which is a legacy API, but still supported in some browsers) then we just extract the name\n // and message, as it doesn't provide anything else. According to the spec, all `DOMExceptions` should also be\n // `Error`s, but that's not the case in IE11, so in that case we treat it the same as we do a `DOMError`.\n //\n // https://developer.mozilla.org/en-US/docs/Web/API/DOMError\n // https://developer.mozilla.org/en-US/docs/Web/API/DOMException\n // https://webidl.spec.whatwg.org/#es-DOMException-specialness\n if (isDOMError(exception ) || isDOMException(exception )) {\n const domException = exception ;\n\n if ('stack' in (exception )) {\n event = eventFromError(stackParser, exception );\n } else {\n const name = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException');\n const message = domException.message ? `${name}: ${domException.message}` : name;\n event = eventFromString(stackParser, message, syntheticException, attachStacktrace);\n addExceptionTypeValue(event, message);\n }\n if ('code' in domException) {\n event.tags = { ...event.tags, 'DOMException.code': `${domException.code}` };\n }\n\n return event;\n }\n if (isError(exception)) {\n // we have a real Error object, do nothing\n return eventFromError(stackParser, exception);\n }\n if (isPlainObject(exception) || isEvent(exception)) {\n // If it's a plain object or an instance of `Event` (the built-in JS kind, not this SDK's `Event` type), serialize\n // it manually. This will allow us to group events based on top-level keys which is much better than creating a new\n // group on any key/value change.\n const objectException = exception ;\n event = eventFromPlainObject(stackParser, objectException, syntheticException, isUnhandledRejection);\n addExceptionMechanism(event, {\n synthetic: true,\n });\n return event;\n }\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(stackParser, exception , syntheticException, attachStacktrace);\n addExceptionTypeValue(event, `${exception}`, undefined);\n addExceptionMechanism(event, {\n synthetic: true,\n });\n\n return event;\n}\n\n/**\n * @hidden\n */\nfunction eventFromString(\n stackParser,\n input,\n syntheticException,\n attachStacktrace,\n) {\n const event = {\n message: input,\n };\n\n if (attachStacktrace && syntheticException) {\n const frames = parseStackFrames(stackParser, syntheticException);\n if (frames.length) {\n event.exception = {\n values: [{ value: input, stacktrace: { frames } }],\n };\n }\n }\n\n return event;\n}\n\nexport { eventFromError, eventFromException, eventFromMessage, eventFromPlainObject, eventFromString, eventFromUnknownInput, exceptionFromError, parseStackFrames };\n//# sourceMappingURL=eventbuilder.js.map\n","import { withScope, captureException } from '@sentry/core';\nimport { GLOBAL_OBJ, getOriginalFunction, markFunctionWrapped, addNonEnumerableProperty, addExceptionTypeValue, addExceptionMechanism } from '@sentry/utils';\n\nconst WINDOW = GLOBAL_OBJ ;\n\nlet ignoreOnError = 0;\n\n/**\n * @hidden\n */\nfunction shouldIgnoreOnError() {\n return ignoreOnError > 0;\n}\n\n/**\n * @hidden\n */\nfunction ignoreNextOnError() {\n // onerror should trigger before setTimeout\n ignoreOnError++;\n setTimeout(() => {\n ignoreOnError--;\n });\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. It is generally safe to pass an unbound function, because the returned wrapper always\n * has a correct `this` context.\n * @returns The wrapped function.\n * @hidden\n */\nfunction wrap(\n fn,\n options\n\n = {},\n before,\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n) {\n // for future readers what this does is wrap a function and then create\n // a bi-directional wrapping between them.\n //\n // example: wrapped = wrap(original);\n // original.__sentry_wrapped__ -> wrapped\n // wrapped.__sentry_original__ -> original\n\n if (typeof fn !== 'function') {\n return fn;\n }\n\n try {\n // if we're dealing with a function that was previously wrapped, return\n // the original wrapper.\n const wrapper = fn.__sentry_wrapped__;\n if (wrapper) {\n return wrapper;\n }\n\n // We don't wanna wrap it twice\n if (getOriginalFunction(fn)) {\n return fn;\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\n /* eslint-disable prefer-rest-params */\n // It is important that `sentryWrapped` is not an arrow function to preserve the context of `this`\n const sentryWrapped = function () {\n const args = Array.prototype.slice.call(arguments);\n\n try {\n if (before && typeof before === 'function') {\n before.apply(this, arguments);\n }\n\n // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access\n const wrappedArguments = args.map((arg) => wrap(arg, options));\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 } catch (ex) {\n ignoreNextOnError();\n\n withScope((scope) => {\n scope.addEventProcessor((event) => {\n if (options.mechanism) {\n addExceptionTypeValue(event, undefined, undefined);\n addExceptionMechanism(event, options.mechanism);\n }\n\n event.extra = {\n ...event.extra,\n arguments: args,\n };\n\n return event;\n });\n\n captureException(ex);\n });\n\n throw ex;\n }\n };\n /* eslint-enable prefer-rest-params */\n\n // Accessing some objects may throw\n // ref: https://github.com/getsentry/sentry-javascript/issues/1168\n try {\n for (const property in fn) {\n if (Object.prototype.hasOwnProperty.call(fn, property)) {\n sentryWrapped[property] = fn[property];\n }\n }\n } catch (_oO) {} // eslint-disable-line no-empty\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 markFunctionWrapped(sentryWrapped, fn);\n\n addNonEnumerableProperty(fn, '__sentry_wrapped__', sentryWrapped);\n\n // Restore original function name (not all browsers allow that)\n try {\n const descriptor = Object.getOwnPropertyDescriptor(sentryWrapped, 'name') ;\n if (descriptor.configurable) {\n Object.defineProperty(sentryWrapped, 'name', {\n get() {\n return fn.name;\n },\n });\n }\n // eslint-disable-next-line no-empty\n } catch (_oO) {}\n\n return sentryWrapped;\n}\n\n/**\n * All properties the report dialog supports\n */\n\nexport { WINDOW, ignoreNextOnError, shouldIgnoreOnError, wrap };\n//# sourceMappingURL=helpers.js.map\n","import { getCurrentHub } from '@sentry/core';\nimport { addInstrumentationHandler, getEventDescription, severityLevelFromString, safeJoin, parseUrl, logger, htmlTreeAsString } from '@sentry/utils';\nimport { WINDOW } from '../helpers.js';\n\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n\n/** JSDoc */\n\n/** maxStringLength gets capped to prevent 100 breadcrumbs exceeding 1MB event payload size */\nconst MAX_ALLOWED_STRING_LENGTH = 1024;\n\nconst BREADCRUMB_INTEGRATION_ID = 'Breadcrumbs';\n\n/**\n * Default Breadcrumbs instrumentations\n * TODO: Deprecated - with v6, this will be renamed to `Instrument`\n */\nclass Breadcrumbs {\n /**\n * @inheritDoc\n */\n static __initStatic() {this.id = BREADCRUMB_INTEGRATION_ID;}\n\n /**\n * @inheritDoc\n */\n __init() {this.name = Breadcrumbs.id;}\n\n /**\n * Options of the breadcrumbs integration.\n */\n // This field is public, because we use it in the browser client to check if the `sentry` option is enabled.\n\n /**\n * @inheritDoc\n */\n constructor(options) {Breadcrumbs.prototype.__init.call(this);\n this.options = {\n console: true,\n dom: true,\n fetch: true,\n history: true,\n sentry: true,\n xhr: true,\n ...options,\n };\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 setupOnce() {\n if (this.options.console) {\n addInstrumentationHandler('console', _consoleBreadcrumb);\n }\n if (this.options.dom) {\n addInstrumentationHandler('dom', _domBreadcrumb(this.options.dom));\n }\n if (this.options.xhr) {\n addInstrumentationHandler('xhr', _xhrBreadcrumb);\n }\n if (this.options.fetch) {\n addInstrumentationHandler('fetch', _fetchBreadcrumb);\n }\n if (this.options.history) {\n addInstrumentationHandler('history', _historyBreadcrumb);\n }\n }\n\n /**\n * Adds a breadcrumb for Sentry events or transactions if this option is enabled.\n */\n addSentryBreadcrumb(event) {\n if (this.options.sentry) {\n getCurrentHub().addBreadcrumb(\n {\n category: `sentry.${event.type === 'transaction' ? 'transaction' : 'event'}`,\n event_id: event.event_id,\n level: event.level,\n message: getEventDescription(event),\n },\n {\n event,\n },\n );\n }\n }\n} Breadcrumbs.__initStatic();\n\n/**\n * A HOC that creaes a function that creates breadcrumbs from DOM API calls.\n * This is a HOC so that we get access to dom options in the closure.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _domBreadcrumb(dom) {\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n function _innerDomBreadcrumb(handlerData) {\n let target;\n let keyAttrs = typeof dom === 'object' ? dom.serializeAttribute : undefined;\n\n let maxStringLength =\n typeof dom === 'object' && typeof dom.maxStringLength === 'number' ? dom.maxStringLength : undefined;\n if (maxStringLength && maxStringLength > MAX_ALLOWED_STRING_LENGTH) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n logger.warn(\n `\\`dom.maxStringLength\\` cannot exceed ${MAX_ALLOWED_STRING_LENGTH}, but a value of ${maxStringLength} was configured. Sentry will use ${MAX_ALLOWED_STRING_LENGTH} instead.`,\n );\n maxStringLength = MAX_ALLOWED_STRING_LENGTH;\n }\n\n if (typeof keyAttrs === 'string') {\n keyAttrs = [keyAttrs];\n }\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, maxStringLength })\n : htmlTreeAsString(handlerData.event , { keyAttrs, maxStringLength });\n } catch (e) {\n target = '';\n }\n\n if (target.length === 0) {\n return;\n }\n\n getCurrentHub().addBreadcrumb(\n {\n category: `ui.${handlerData.name}`,\n message: target,\n },\n {\n event: handlerData.event,\n name: handlerData.name,\n global: handlerData.global,\n },\n );\n }\n\n return _innerDomBreadcrumb;\n}\n\n/**\n * Creates breadcrumbs from console API calls\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _consoleBreadcrumb(handlerData) {\n // This is a hack to fix a Vue3-specific bug that causes an infinite loop of\n // console warnings. This happens when a Vue template is rendered with\n // an undeclared variable, which we try to stringify, ultimately causing\n // Vue to issue another warning which repeats indefinitely.\n // see: https://github.com/getsentry/sentry-javascript/pull/6010\n // see: https://github.com/getsentry/sentry-javascript/issues/5916\n for (let i = 0; i < handlerData.args.length; i++) {\n if (handlerData.args[i] === 'ref=Ref<') {\n handlerData.args[i + 1] = 'viewRef';\n break;\n }\n }\n const breadcrumb = {\n category: 'console',\n data: {\n arguments: handlerData.args,\n logger: 'console',\n },\n level: severityLevelFromString(handlerData.level),\n message: safeJoin(handlerData.args, ' '),\n };\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 } else {\n // Don't capture a breadcrumb for passed assertions\n return;\n }\n }\n\n getCurrentHub().addBreadcrumb(breadcrumb, {\n input: handlerData.args,\n level: handlerData.level,\n });\n}\n\n/**\n * Creates breadcrumbs from XHR API calls\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _xhrBreadcrumb(handlerData) {\n if (handlerData.endTimestamp) {\n // We only capture complete, non-sentry requests\n if (handlerData.xhr.__sentry_own_request__) {\n return;\n }\n\n const { method, url, status_code, body } = handlerData.xhr.__sentry_xhr__ || {};\n\n getCurrentHub().addBreadcrumb(\n {\n category: 'xhr',\n data: {\n method,\n url,\n status_code,\n },\n type: 'http',\n },\n {\n xhr: handlerData.xhr,\n input: body,\n },\n );\n\n return;\n }\n}\n\n/**\n * Creates breadcrumbs from fetch API calls\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _fetchBreadcrumb(handlerData) {\n // We only capture complete fetch requests\n if (!handlerData.endTimestamp) {\n return;\n }\n\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\n if (handlerData.error) {\n getCurrentHub().addBreadcrumb(\n {\n category: 'fetch',\n data: handlerData.fetchData,\n level: 'error',\n type: 'http',\n },\n {\n data: handlerData.error,\n input: handlerData.args,\n },\n );\n } else {\n getCurrentHub().addBreadcrumb(\n {\n category: 'fetch',\n data: {\n ...handlerData.fetchData,\n status_code: handlerData.response.status,\n },\n type: 'http',\n },\n {\n input: handlerData.args,\n response: handlerData.response,\n },\n );\n }\n}\n\n/**\n * Creates breadcrumbs from history API calls\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _historyBreadcrumb(handlerData) {\n let from = handlerData.from;\n let to = handlerData.to;\n const parsedLoc = parseUrl(WINDOW.location.href);\n let parsedFrom = parseUrl(from);\n const parsedTo = parseUrl(to);\n\n // Initial pushState doesn't provide `from` information\n if (!parsedFrom.path) {\n parsedFrom = parsedLoc;\n }\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\n getCurrentHub().addBreadcrumb({\n category: 'navigation',\n data: {\n from,\n to,\n },\n });\n}\n\nexport { BREADCRUMB_INTEGRATION_ID, Breadcrumbs };\n//# sourceMappingURL=breadcrumbs.js.map\n","import { BaseClient, SDK_VERSION, getEnvelopeEndpointWithUrlEncodedAuth } from '@sentry/core';\nimport { getSDKSource, logger, createClientReportEnvelope, dsnToString, serializeEnvelope } from '@sentry/utils';\nimport { eventFromException, eventFromMessage } from './eventbuilder.js';\nimport { WINDOW } from './helpers.js';\nimport { BREADCRUMB_INTEGRATION_ID } from './integrations/breadcrumbs.js';\n\n/**\n * Configuration options for the Sentry Browser SDK.\n * @see @sentry/types Options for more information.\n */\n\n/**\n * The Sentry Browser SDK Client.\n *\n * @see BrowserOptions for documentation on configuration options.\n * @see SentryClient for usage documentation.\n */\nclass BrowserClient extends BaseClient {\n /**\n * Creates a new Browser SDK instance.\n *\n * @param options Configuration options for this SDK.\n */\n constructor(options) {\n const sdkSource = WINDOW.SENTRY_SDK_SOURCE || getSDKSource();\n\n options._metadata = options._metadata || {};\n options._metadata.sdk = options._metadata.sdk || {\n name: 'sentry.javascript.browser',\n packages: [\n {\n name: `${sdkSource}:@sentry/browser`,\n version: SDK_VERSION,\n },\n ],\n version: SDK_VERSION,\n };\n\n super(options);\n\n if (options.sendClientReports && WINDOW.document) {\n WINDOW.document.addEventListener('visibilitychange', () => {\n if (WINDOW.document.visibilityState === 'hidden') {\n this._flushOutcomes();\n }\n });\n }\n }\n\n /**\n * @inheritDoc\n */\n eventFromException(exception, hint) {\n return eventFromException(this._options.stackParser, exception, hint, this._options.attachStacktrace);\n }\n\n /**\n * @inheritDoc\n */\n eventFromMessage(\n message,\n // eslint-disable-next-line deprecation/deprecation\n level = 'info',\n hint,\n ) {\n return eventFromMessage(this._options.stackParser, message, level, hint, this._options.attachStacktrace);\n }\n\n /**\n * @inheritDoc\n */\n sendEvent(event, hint) {\n // We only want to add the sentry event breadcrumb when the user has the breadcrumb integration installed and\n // activated its `sentry` option.\n // We also do not want to use the `Breadcrumbs` class here directly, because we do not want it to be included in\n // bundles, if it is not used by the SDK.\n // This all sadly is a bit ugly, but we currently don't have a \"pre-send\" hook on the integrations so we do it this\n // way for now.\n const breadcrumbIntegration = this.getIntegrationById(BREADCRUMB_INTEGRATION_ID) ;\n // We check for definedness of `addSentryBreadcrumb` in case users provided their own integration with id\n // \"Breadcrumbs\" that does not have this function.\n if (breadcrumbIntegration && breadcrumbIntegration.addSentryBreadcrumb) {\n breadcrumbIntegration.addSentryBreadcrumb(event);\n }\n\n super.sendEvent(event, hint);\n }\n\n /**\n * @inheritDoc\n */\n _prepareEvent(event, hint, scope) {\n event.platform = event.platform || 'javascript';\n return super._prepareEvent(event, hint, scope);\n }\n\n /**\n * Sends client reports as an envelope.\n */\n _flushOutcomes() {\n const outcomes = this._clearOutcomes();\n\n if (outcomes.length === 0) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('No outcomes to send');\n return;\n }\n\n if (!this._dsn) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('No dsn provided, will not send outcomes');\n return;\n }\n\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('Sending outcomes:', outcomes);\n\n const url = getEnvelopeEndpointWithUrlEncodedAuth(this._dsn, this._options);\n const envelope = createClientReportEnvelope(outcomes, this._options.tunnel && dsnToString(this._dsn));\n\n try {\n const isRealNavigator = Object.prototype.toString.call(WINDOW && WINDOW.navigator) === '[object Navigator]';\n const hasSendBeacon = isRealNavigator && typeof WINDOW.navigator.sendBeacon === 'function';\n // Make sure beacon is not used if user configures custom transport options\n if (hasSendBeacon && !this._options.transportOptions) {\n // Prevent illegal invocations - https://xgwang.me/posts/you-may-not-know-beacon/#it-may-throw-error%2C-be-sure-to-catch\n const sendBeacon = WINDOW.navigator.sendBeacon.bind(WINDOW.navigator);\n sendBeacon(url, serializeEnvelope(envelope));\n } else {\n // If beacon is not supported or if they are using the tunnel option\n // use our regular transport to send client reports to Sentry.\n this._sendEnvelope(envelope);\n }\n } catch (e) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error(e);\n }\n }\n}\n\nexport { BrowserClient };\n//# sourceMappingURL=client.js.map\n","import { getCurrentHub } from '@sentry/core';\nimport { addInstrumentationHandler, isString, isPrimitive, isErrorEvent, getLocationHref, logger, addExceptionMechanism } from '@sentry/utils';\nimport { eventFromUnknownInput } from '../eventbuilder.js';\nimport { shouldIgnoreOnError } from '../helpers.js';\n\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n\n/** Global handlers */\nclass GlobalHandlers {\n /**\n * @inheritDoc\n */\n static __initStatic() {this.id = 'GlobalHandlers';}\n\n /**\n * @inheritDoc\n */\n __init() {this.name = GlobalHandlers.id;}\n\n /** JSDoc */\n\n /**\n * Stores references functions to installing handlers. Will set to undefined\n * after they have been run so that they are not used twice.\n */\n __init2() {this._installFunc = {\n onerror: _installGlobalOnErrorHandler,\n onunhandledrejection: _installGlobalOnUnhandledRejectionHandler,\n };}\n\n /** JSDoc */\n constructor(options) {GlobalHandlers.prototype.__init.call(this);GlobalHandlers.prototype.__init2.call(this);\n this._options = {\n onerror: true,\n onunhandledrejection: true,\n ...options,\n };\n }\n /**\n * @inheritDoc\n */\n setupOnce() {\n Error.stackTraceLimit = 50;\n const options = this._options;\n\n // We can disable guard-for-in as we construct the options object above + do checks against\n // `this._installFunc` for the property.\n // eslint-disable-next-line guard-for-in\n for (const key in options) {\n const installFunc = this._installFunc[key ];\n if (installFunc && options[key ]) {\n globalHandlerLog(key);\n installFunc();\n this._installFunc[key ] = undefined;\n }\n }\n }\n} GlobalHandlers.__initStatic();\n\n/** JSDoc */\nfunction _installGlobalOnErrorHandler() {\n addInstrumentationHandler(\n 'error',\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n (data) => {\n const [hub, stackParser, attachStacktrace] = getHubAndOptions();\n if (!hub.getIntegration(GlobalHandlers)) {\n return;\n }\n const { msg, url, line, column, error } = data;\n if (shouldIgnoreOnError() || (error && error.__sentry_own_request__)) {\n return;\n }\n\n const event =\n error === undefined && isString(msg)\n ? _eventFromIncompleteOnError(msg, url, line, column)\n : _enhanceEventWithInitialFrame(\n eventFromUnknownInput(stackParser, error || msg, undefined, attachStacktrace, false),\n url,\n line,\n column,\n );\n\n event.level = 'error';\n\n addMechanismAndCapture(hub, error, event, 'onerror');\n },\n );\n}\n\n/** JSDoc */\nfunction _installGlobalOnUnhandledRejectionHandler() {\n addInstrumentationHandler(\n 'unhandledrejection',\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n (e) => {\n const [hub, stackParser, attachStacktrace] = getHubAndOptions();\n if (!hub.getIntegration(GlobalHandlers)) {\n return;\n }\n let error = e;\n\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 } catch (_oO) {\n // no-empty\n }\n\n if (shouldIgnoreOnError() || (error && error.__sentry_own_request__)) {\n return true;\n }\n\n const event = isPrimitive(error)\n ? _eventFromRejectionWithPrimitive(error)\n : eventFromUnknownInput(stackParser, error, undefined, attachStacktrace, true);\n\n event.level = 'error';\n\n addMechanismAndCapture(hub, error, event, 'onunhandledrejection');\n return;\n },\n );\n}\n\n/**\n * Create an event from a promise rejection where the `reason` is a primitive.\n *\n * @param reason: The `reason` property of the promise rejection\n * @returns An Event object with an appropriate `exception` value\n */\nfunction _eventFromRejectionWithPrimitive(reason) {\n return {\n exception: {\n values: [\n {\n type: 'UnhandledRejection',\n // String() is needed because the Primitive type includes symbols (which can't be automatically stringified)\n value: `Non-Error promise rejection captured with value: ${String(reason)}`,\n },\n ],\n },\n };\n}\n\n/**\n * This function creates a stack from an old, error-less onerror handler.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _eventFromIncompleteOnError(msg, url, line, column) {\n const ERROR_TYPES_RE =\n /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/i;\n\n // If 'message' is ErrorEvent, get real message from inside\n let message = isErrorEvent(msg) ? msg.message : msg;\n let name = 'Error';\n\n const groups = message.match(ERROR_TYPES_RE);\n if (groups) {\n name = groups[1];\n message = groups[2];\n }\n\n const event = {\n exception: {\n values: [\n {\n type: name,\n value: message,\n },\n ],\n },\n };\n\n return _enhanceEventWithInitialFrame(event, url, line, column);\n}\n\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _enhanceEventWithInitialFrame(event, url, line, column) {\n // event.exception\n const e = (event.exception = event.exception || {});\n // event.exception.values\n const ev = (e.values = e.values || []);\n // event.exception.values[0]\n const ev0 = (ev[0] = ev[0] || {});\n // event.exception.values[0].stacktrace\n const ev0s = (ev0.stacktrace = ev0.stacktrace || {});\n // event.exception.values[0].stacktrace.frames\n const ev0sf = (ev0s.frames = ev0s.frames || []);\n\n const colno = isNaN(parseInt(column, 10)) ? undefined : column;\n const lineno = isNaN(parseInt(line, 10)) ? undefined : line;\n const filename = isString(url) && url.length > 0 ? url : getLocationHref();\n\n // event.exception.values[0].stacktrace.frames\n if (ev0sf.length === 0) {\n ev0sf.push({\n colno,\n filename,\n function: '?',\n in_app: true,\n lineno,\n });\n }\n\n return event;\n}\n\nfunction globalHandlerLog(type) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`Global Handler attached: ${type}`);\n}\n\nfunction addMechanismAndCapture(hub, error, event, type) {\n addExceptionMechanism(event, {\n handled: false,\n type,\n });\n hub.captureEvent(event, {\n originalException: error,\n });\n}\n\nfunction getHubAndOptions() {\n const hub = getCurrentHub();\n const client = hub.getClient();\n const options = (client && client.getOptions()) || {\n stackParser: () => [],\n attachStacktrace: false,\n };\n return [hub, options.stackParser, options.attachStacktrace];\n}\n\nexport { GlobalHandlers };\n//# sourceMappingURL=globalhandlers.js.map\n","import { fill, getFunctionName, getOriginalFunction } from '@sentry/utils';\nimport { WINDOW, wrap } from '../helpers.js';\n\nconst 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\n/** Wrap timer functions and event targets to catch errors and provide better meta data */\nclass TryCatch {\n /**\n * @inheritDoc\n */\n static __initStatic() {this.id = 'TryCatch';}\n\n /**\n * @inheritDoc\n */\n __init() {this.name = TryCatch.id;}\n\n /** JSDoc */\n\n /**\n * @inheritDoc\n */\n constructor(options) {TryCatch.prototype.__init.call(this);\n this._options = {\n XMLHttpRequest: true,\n eventTarget: true,\n requestAnimationFrame: true,\n setInterval: true,\n setTimeout: true,\n ...options,\n };\n }\n\n /**\n * Wrap timer functions and event targets to catch errors\n * and provide better metadata.\n */\n setupOnce() {\n if (this._options.setTimeout) {\n fill(WINDOW, 'setTimeout', _wrapTimeFunction);\n }\n\n if (this._options.setInterval) {\n fill(WINDOW, 'setInterval', _wrapTimeFunction);\n }\n\n if (this._options.requestAnimationFrame) {\n fill(WINDOW, 'requestAnimationFrame', _wrapRAF);\n }\n\n if (this._options.XMLHttpRequest && 'XMLHttpRequest' in WINDOW) {\n fill(XMLHttpRequest.prototype, 'send', _wrapXHR);\n }\n\n const eventTargetOption = this._options.eventTarget;\n if (eventTargetOption) {\n const eventTarget = Array.isArray(eventTargetOption) ? eventTargetOption : DEFAULT_EVENT_TARGET;\n eventTarget.forEach(_wrapEventTarget);\n }\n }\n} TryCatch.__initStatic();\n\n/** JSDoc */\nfunction _wrapTimeFunction(original) {\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n return function ( ...args) {\n const 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\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _wrapRAF(original) {\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n return function ( callback) {\n // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n return original.apply(this, [\n wrap(callback, {\n mechanism: {\n data: {\n function: 'requestAnimationFrame',\n handler: getFunctionName(original),\n },\n handled: true,\n type: 'instrument',\n },\n }),\n ]);\n };\n}\n\n/** JSDoc */\nfunction _wrapXHR(originalSend) {\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n return function ( ...args) {\n // eslint-disable-next-line @typescript-eslint/no-this-alias\n const xhr = this;\n const xmlHttpRequestProps = ['onload', 'onerror', 'onprogress', 'onreadystatechange'];\n\n xmlHttpRequestProps.forEach(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 const wrapOptions = {\n mechanism: {\n data: {\n function: prop,\n handler: getFunctionName(original),\n },\n handled: true,\n type: 'instrument',\n },\n };\n\n // If Instrument integration has been called before TryCatch, get the name of original function\n const originalFunction = getOriginalFunction(original);\n if (originalFunction) {\n wrapOptions.mechanism.data.handler = getFunctionName(originalFunction);\n }\n\n // Otherwise wrap directly\n return wrap(original, wrapOptions);\n });\n }\n });\n\n return originalSend.apply(this, args);\n };\n}\n\n/** JSDoc */\nfunction _wrapEventTarget(target) {\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n const globalObject = WINDOW ;\n // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n const proto = globalObject[target] && globalObject[target].prototype;\n\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\n fill(proto, 'addEventListener', function (original)\n\n {\n return function (\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n eventName,\n fn,\n options,\n ) {\n try {\n if (typeof fn.handleEvent === 'function') {\n // ESlint disable explanation:\n // First, it is generally safe to call `wrap` with an unbound function. Furthermore, using `.bind()` would\n // introduce a bug here, because bind returns a new function that doesn't have our\n // flags(like __sentry_original__) attached. `wrap` checks for those flags to avoid unnecessary wrapping.\n // Without those flags, every call to addEventListener wraps the function again, causing a memory leak.\n // eslint-disable-next-line @typescript-eslint/unbound-method\n fn.handleEvent = wrap(fn.handleEvent, {\n mechanism: {\n data: {\n function: 'handleEvent',\n handler: getFunctionName(fn),\n target,\n },\n handled: true,\n type: 'instrument',\n },\n });\n }\n } catch (err) {\n // can sometimes get 'Permission denied to access property \"handle Event'\n }\n\n return original.apply(this, [\n eventName,\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n wrap(fn , {\n mechanism: {\n data: {\n function: 'addEventListener',\n handler: getFunctionName(fn),\n target,\n },\n handled: true,\n type: 'instrument',\n },\n }),\n options,\n ]);\n };\n });\n\n fill(\n proto,\n 'removeEventListener',\n function (\n originalRemoveEventListener,\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n ) {\n return function (\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n eventName,\n fn,\n options,\n ) {\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 const wrappedEventHandler = fn ;\n try {\n const originalEventHandler = wrappedEventHandler && wrappedEventHandler.__sentry_wrapped__;\n if (originalEventHandler) {\n originalRemoveEventListener.call(this, eventName, originalEventHandler, options);\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}\n\nexport { TryCatch };\n//# sourceMappingURL=trycatch.js.map\n","import { getCurrentHub, addGlobalEventProcessor } from '@sentry/core';\nimport { isInstanceOf } from '@sentry/utils';\nimport { exceptionFromError } from '../eventbuilder.js';\n\nconst DEFAULT_KEY = 'cause';\nconst DEFAULT_LIMIT = 5;\n\n/** Adds SDK info to an event. */\nclass LinkedErrors {\n /**\n * @inheritDoc\n */\n static __initStatic() {this.id = 'LinkedErrors';}\n\n /**\n * @inheritDoc\n */\n __init() {this.name = LinkedErrors.id;}\n\n /**\n * @inheritDoc\n */\n\n /**\n * @inheritDoc\n */\n\n /**\n * @inheritDoc\n */\n constructor(options = {}) {LinkedErrors.prototype.__init.call(this);\n this._key = options.key || DEFAULT_KEY;\n this._limit = options.limit || DEFAULT_LIMIT;\n }\n\n /**\n * @inheritDoc\n */\n setupOnce() {\n const client = getCurrentHub().getClient();\n if (!client) {\n return;\n }\n addGlobalEventProcessor((event, hint) => {\n const self = getCurrentHub().getIntegration(LinkedErrors);\n return self ? _handler(client.getOptions().stackParser, self._key, self._limit, event, hint) : event;\n });\n }\n} LinkedErrors.__initStatic();\n\n/**\n * @inheritDoc\n */\nfunction _handler(\n parser,\n key,\n limit,\n event,\n hint,\n) {\n if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {\n return event;\n }\n const linkedErrors = _walkErrorTree(parser, limit, hint.originalException , key);\n event.exception.values = [...linkedErrors, ...event.exception.values];\n return event;\n}\n\n/**\n * JSDOC\n */\nfunction _walkErrorTree(\n parser,\n limit,\n error,\n key,\n stack = [],\n) {\n if (!isInstanceOf(error[key], Error) || stack.length + 1 >= limit) {\n return stack;\n }\n const exception = exceptionFromError(parser, error[key]);\n return _walkErrorTree(parser, limit, error[key], key, [exception, ...stack]);\n}\n\nexport { LinkedErrors, _handler, _walkErrorTree };\n//# sourceMappingURL=linkederrors.js.map\n","import { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { WINDOW } from '../helpers.js';\n\n/** HttpContext integration collects information about HTTP request headers */\nclass HttpContext {constructor() { HttpContext.prototype.__init.call(this); }\n /**\n * @inheritDoc\n */\n static __initStatic() {this.id = 'HttpContext';}\n\n /**\n * @inheritDoc\n */\n __init() {this.name = HttpContext.id;}\n\n /**\n * @inheritDoc\n */\n setupOnce() {\n addGlobalEventProcessor((event) => {\n if (getCurrentHub().getIntegration(HttpContext)) {\n // if none of the information we want exists, don't bother\n if (!WINDOW.navigator && !WINDOW.location && !WINDOW.document) {\n return event;\n }\n\n // grab as much info as exists and add it to the event\n const url = (event.request && event.request.url) || (WINDOW.location && WINDOW.location.href);\n const { referrer } = WINDOW.document || {};\n const { userAgent } = WINDOW.navigator || {};\n\n const headers = {\n ...(event.request && event.request.headers),\n ...(referrer && { Referer: referrer }),\n ...(userAgent && { 'User-Agent': userAgent }),\n };\n const request = { ...event.request, ...(url && { url }), headers };\n\n return { ...event, request };\n }\n return event;\n });\n }\n} HttpContext.__initStatic();\n\nexport { HttpContext };\n//# sourceMappingURL=httpcontext.js.map\n","import { logger } from '@sentry/utils';\n\n/** Deduplication filter */\nclass Dedupe {constructor() { Dedupe.prototype.__init.call(this); }\n /**\n * @inheritDoc\n */\n static __initStatic() {this.id = 'Dedupe';}\n\n /**\n * @inheritDoc\n */\n __init() {this.name = Dedupe.id;}\n\n /**\n * @inheritDoc\n */\n\n /**\n * @inheritDoc\n */\n setupOnce(addGlobalEventProcessor, getCurrentHub) {\n const eventProcessor = currentEvent => {\n // We want to ignore any non-error type events, e.g. transactions or replays\n // These should never be deduped, and also not be compared against as _previousEvent.\n if (currentEvent.type) {\n return currentEvent;\n }\n\n const self = getCurrentHub().getIntegration(Dedupe);\n if (self) {\n // Juuust in case something goes wrong\n try {\n if (_shouldDropEvent(currentEvent, self._previousEvent)) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Event dropped due to being a duplicate of previously captured event.');\n return null;\n }\n } catch (_oO) {\n return (self._previousEvent = currentEvent);\n }\n\n return (self._previousEvent = currentEvent);\n }\n return currentEvent;\n };\n\n eventProcessor.id = this.name;\n addGlobalEventProcessor(eventProcessor);\n }\n} Dedupe.__initStatic();\n\n/** JSDoc */\nfunction _shouldDropEvent(currentEvent, previousEvent) {\n if (!previousEvent) {\n return false;\n }\n\n if (_isSameMessageEvent(currentEvent, previousEvent)) {\n return true;\n }\n\n if (_isSameExceptionEvent(currentEvent, previousEvent)) {\n return true;\n }\n\n return false;\n}\n\n/** JSDoc */\nfunction _isSameMessageEvent(currentEvent, previousEvent) {\n const currentMessage = currentEvent.message;\n const previousMessage = previousEvent.message;\n\n // If neither event has a message property, they were both exceptions, so bail out\n if (!currentMessage && !previousMessage) {\n return false;\n }\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\n if (currentMessage !== previousMessage) {\n return false;\n }\n\n if (!_isSameFingerprint(currentEvent, previousEvent)) {\n return false;\n }\n\n if (!_isSameStacktrace(currentEvent, previousEvent)) {\n return false;\n }\n\n return true;\n}\n\n/** JSDoc */\nfunction _isSameExceptionEvent(currentEvent, previousEvent) {\n const previousException = _getExceptionFromEvent(previousEvent);\n const currentException = _getExceptionFromEvent(currentEvent);\n\n if (!previousException || !currentException) {\n return false;\n }\n\n if (previousException.type !== currentException.type || previousException.value !== currentException.value) {\n return false;\n }\n\n if (!_isSameFingerprint(currentEvent, previousEvent)) {\n return false;\n }\n\n if (!_isSameStacktrace(currentEvent, previousEvent)) {\n return false;\n }\n\n return true;\n}\n\n/** JSDoc */\nfunction _isSameStacktrace(currentEvent, previousEvent) {\n let currentFrames = _getFramesFromEvent(currentEvent);\n let previousFrames = _getFramesFromEvent(previousEvent);\n\n // If neither event has a stacktrace, they are assumed to be the same\n if (!currentFrames && !previousFrames) {\n return true;\n }\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\n currentFrames = currentFrames ;\n previousFrames = previousFrames ;\n\n // If number of frames differ, they are not the same\n if (previousFrames.length !== currentFrames.length) {\n return false;\n }\n\n // Otherwise, compare the two\n for (let i = 0; i < previousFrames.length; i++) {\n const frameA = previousFrames[i];\n const frameB = currentFrames[i];\n\n if (\n frameA.filename !== frameB.filename ||\n frameA.lineno !== frameB.lineno ||\n frameA.colno !== frameB.colno ||\n frameA.function !== frameB.function\n ) {\n return false;\n }\n }\n\n return true;\n}\n\n/** JSDoc */\nfunction _isSameFingerprint(currentEvent, previousEvent) {\n let currentFingerprint = currentEvent.fingerprint;\n let previousFingerprint = previousEvent.fingerprint;\n\n // If neither event has a fingerprint, they are assumed to be the same\n if (!currentFingerprint && !previousFingerprint) {\n return true;\n }\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\n currentFingerprint = currentFingerprint ;\n previousFingerprint = previousFingerprint ;\n\n // Otherwise, compare the two\n try {\n return !!(currentFingerprint.join('') === previousFingerprint.join(''));\n } catch (_oO) {\n return false;\n }\n}\n\n/** JSDoc */\nfunction _getExceptionFromEvent(event) {\n return event.exception && event.exception.values && event.exception.values[0];\n}\n\n/** JSDoc */\nfunction _getFramesFromEvent(event) {\n const exception = event.exception;\n\n if (exception) {\n try {\n // @ts-ignore Object could be undefined\n return exception.values[0].stacktrace.frames;\n } catch (_oO) {\n return undefined;\n }\n }\n return undefined;\n}\n\nexport { Dedupe };\n//# sourceMappingURL=dedupe.js.map\n","import { createStackParser } from '@sentry/utils';\n\n// global reference to slice\nconst UNKNOWN_FUNCTION = '?';\n\nconst OPERA10_PRIORITY = 10;\nconst OPERA11_PRIORITY = 20;\nconst CHROME_PRIORITY = 30;\nconst WINJS_PRIORITY = 40;\nconst GECKO_PRIORITY = 50;\n\nfunction createFrame(filename, func, lineno, colno) {\n const frame = {\n filename,\n abs_path: filename, // As opposed to filename, abs_path is immutable (I can't control your actions but don't touch it!)\n function: func,\n in_app: true, // All browser frames are considered in_app\n };\n\n if (lineno !== undefined) {\n frame.lineno = lineno;\n }\n\n if (colno !== undefined) {\n frame.colno = colno;\n }\n\n return frame;\n}\n\n// Chromium based browsers: Chrome, Brave, new Opera, new Edge\nconst chromeRegex =\n /^\\s*at (?:(.*\\).*?|.*?) ?\\((?:address at )?)?(?:async )?((?:file|https?|blob|chrome-extension|address|native|eval|webpack||[-a-z]+:|.*bundle|\\/)?.*?)(?::(\\d+))?(?::(\\d+))?\\)?\\s*$/i;\nconst chromeEvalRegex = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/;\n\nconst chrome = line => {\n const parts = chromeRegex.exec(line);\n\n if (parts) {\n const isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n\n if (isEval) {\n const subMatch = chromeEvalRegex.exec(parts[2]);\n\n if (subMatch) {\n // throw out eval line/column and use top-most line/column number\n parts[2] = subMatch[1]; // url\n parts[3] = subMatch[2]; // line\n parts[4] = subMatch[3]; // column\n }\n }\n\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 const [func, filename] = extractSafariExtensionDetails(parts[1] || UNKNOWN_FUNCTION, parts[2]);\n\n return createFrame(filename, func, parts[3] ? +parts[3] : undefined, parts[4] ? +parts[4] : undefined);\n }\n\n return;\n};\n\nconst chromeStackLineParser = [CHROME_PRIORITY, chrome];\n\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.\nconst geckoREgex =\n /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)?((?:file|https?|blob|chrome|webpack|resource|moz-extension|safari-extension|safari-web-extension|capacitor)?:\\/.*?|\\[native code\\]|[^@]*(?:bundle|\\d+\\.js)|\\/[\\w\\-. /=]+)(?::(\\d+))?(?::(\\d+))?\\s*$/i;\nconst geckoEvalRegex = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\n\nconst gecko = line => {\n const parts = geckoREgex.exec(line);\n\n if (parts) {\n const isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n if (isEval) {\n const subMatch = geckoEvalRegex.exec(parts[3]);\n\n if (subMatch) {\n // throw out eval line/column and use top-most line number\n parts[1] = parts[1] || 'eval';\n parts[3] = subMatch[1];\n parts[4] = subMatch[2];\n parts[5] = ''; // no column when eval\n }\n }\n\n let filename = parts[3];\n let func = parts[1] || UNKNOWN_FUNCTION;\n [func, filename] = extractSafariExtensionDetails(func, filename);\n\n return createFrame(filename, func, parts[4] ? +parts[4] : undefined, parts[5] ? +parts[5] : undefined);\n }\n\n return;\n};\n\nconst geckoStackLineParser = [GECKO_PRIORITY, gecko];\n\nconst winjsRegex =\n /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i;\n\nconst winjs = line => {\n const parts = winjsRegex.exec(line);\n\n return parts\n ? createFrame(parts[2], parts[1] || UNKNOWN_FUNCTION, +parts[3], parts[4] ? +parts[4] : undefined)\n : undefined;\n};\n\nconst winjsStackLineParser = [WINJS_PRIORITY, winjs];\n\nconst opera10Regex = / line (\\d+).*script (?:in )?(\\S+)(?:: in function (\\S+))?$/i;\n\nconst opera10 = line => {\n const parts = opera10Regex.exec(line);\n return parts ? createFrame(parts[2], parts[3] || UNKNOWN_FUNCTION, +parts[1]) : undefined;\n};\n\nconst opera10StackLineParser = [OPERA10_PRIORITY, opera10];\n\nconst opera11Regex =\n / line (\\d+), column (\\d+)\\s*(?:in (?:]+)>|([^)]+))\\(.*\\))? in (.*):\\s*$/i;\n\nconst opera11 = line => {\n const parts = opera11Regex.exec(line);\n return parts ? createFrame(parts[5], parts[3] || parts[4] || UNKNOWN_FUNCTION, +parts[1], +parts[2]) : undefined;\n};\n\nconst opera11StackLineParser = [OPERA11_PRIORITY, opera11];\n\nconst defaultStackLineParsers = [chromeStackLineParser, geckoStackLineParser, winjsStackLineParser];\n\nconst defaultStackParser = createStackParser(...defaultStackLineParsers);\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 * Unfortunately \"just\" changing RegExp is too complicated now and making it pass all tests\n * and fix this case seems like an impossible, or at least way too time-consuming task.\n */\nconst extractSafariExtensionDetails = (func, filename) => {\n const isSafariExtension = func.indexOf('safari-extension') !== -1;\n const isSafariWebExtension = func.indexOf('safari-web-extension') !== -1;\n\n return isSafariExtension || isSafariWebExtension\n ? [\n func.indexOf('@') !== -1 ? func.split('@')[0] : UNKNOWN_FUNCTION,\n isSafariExtension ? `safari-extension:${filename}` : `safari-web-extension:${filename}`,\n ]\n : [func, filename];\n};\n\nexport { chromeStackLineParser, defaultStackLineParsers, defaultStackParser, geckoStackLineParser, opera10StackLineParser, opera11StackLineParser, winjsStackLineParser };\n//# sourceMappingURL=stack-parsers.js.map\n","import { isNativeFetch, logger } from '@sentry/utils';\nimport { WINDOW } from '../helpers.js';\n\nlet cachedFetchImpl = undefined;\n\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 */\nfunction getNativeFetchImplementation() {\n if (cachedFetchImpl) {\n return cachedFetchImpl;\n }\n\n /* eslint-disable @typescript-eslint/unbound-method */\n\n // Fast path to avoid DOM I/O\n if (isNativeFetch(WINDOW.fetch)) {\n return (cachedFetchImpl = WINDOW.fetch.bind(WINDOW));\n }\n\n const document = WINDOW.document;\n let fetchImpl = WINDOW.fetch;\n // eslint-disable-next-line deprecation/deprecation\n if (document && typeof document.createElement === 'function') {\n try {\n const sandbox = document.createElement('iframe');\n sandbox.hidden = true;\n document.head.appendChild(sandbox);\n const contentWindow = sandbox.contentWindow;\n if (contentWindow && contentWindow.fetch) {\n fetchImpl = contentWindow.fetch;\n }\n document.head.removeChild(sandbox);\n } catch (e) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', e);\n }\n }\n\n return (cachedFetchImpl = fetchImpl.bind(WINDOW));\n /* eslint-enable @typescript-eslint/unbound-method */\n}\n\n/** Clears cached fetch impl */\nfunction clearCachedFetchImplementation() {\n cachedFetchImpl = undefined;\n}\n\nexport { clearCachedFetchImplementation, getNativeFetchImplementation };\n//# sourceMappingURL=utils.js.map\n","import { createTransport } from '@sentry/core';\nimport { rejectedSyncPromise } from '@sentry/utils';\nimport { getNativeFetchImplementation, clearCachedFetchImplementation } from './utils.js';\n\n/**\n * Creates a Transport that uses the Fetch API to send events to Sentry.\n */\nfunction makeFetchTransport(\n options,\n nativeFetch = getNativeFetchImplementation(),\n) {\n function makeRequest(request) {\n const requestOptions = {\n body: request.body,\n method: 'POST',\n referrerPolicy: 'origin',\n headers: options.headers,\n // Outgoing requests are usually cancelled when navigating to a different page, causing a \"TypeError: Failed to\n // fetch\" error and sending a \"network_error\" client-outcome - in Chrome, the request status shows \"(cancelled)\".\n // The `keepalive` flag keeps outgoing requests alive, even when switching pages. We want this since we're\n // frequently sending events right before the user is switching pages (eg. whenfinishing navigation transactions).\n // Gotchas:\n // - `keepalive` isn't supported by Firefox\n // - As per spec (https://fetch.spec.whatwg.org/#http-network-or-cache-fetch), a request with `keepalive: true`\n // and a content length of > 64 kibibytes returns a network error. We will therefore only activate the flag when\n // we're below that limit.\n keepalive: request.body.length <= 65536,\n ...options.fetchOptions,\n };\n\n try {\n return nativeFetch(options.url, requestOptions).then(response => ({\n statusCode: response.status,\n headers: {\n 'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),\n 'retry-after': response.headers.get('Retry-After'),\n },\n }));\n } catch (e) {\n clearCachedFetchImplementation();\n return rejectedSyncPromise(e);\n }\n }\n\n return createTransport(options, makeRequest);\n}\n\nexport { makeFetchTransport };\n//# sourceMappingURL=fetch.js.map\n","import { createTransport } from '@sentry/core';\nimport { SyncPromise } from '@sentry/utils';\n\n/**\n * The DONE ready state for XmlHttpRequest\n *\n * Defining it here as a constant b/c XMLHttpRequest.DONE is not always defined\n * (e.g. during testing, it is `undefined`)\n *\n * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/readyState}\n */\nconst XHR_READYSTATE_DONE = 4;\n\n/**\n * Creates a Transport that uses the XMLHttpRequest API to send events to Sentry.\n */\nfunction makeXHRTransport(options) {\n function makeRequest(request) {\n return new SyncPromise((resolve, reject) => {\n const xhr = new XMLHttpRequest();\n\n xhr.onerror = reject;\n\n xhr.onreadystatechange = () => {\n if (xhr.readyState === XHR_READYSTATE_DONE) {\n resolve({\n statusCode: xhr.status,\n headers: {\n 'x-sentry-rate-limits': xhr.getResponseHeader('X-Sentry-Rate-Limits'),\n 'retry-after': xhr.getResponseHeader('Retry-After'),\n },\n });\n }\n };\n\n xhr.open('POST', options.url);\n\n for (const header in options.headers) {\n if (Object.prototype.hasOwnProperty.call(options.headers, header)) {\n xhr.setRequestHeader(header, options.headers[header]);\n }\n }\n\n xhr.send(request.body);\n });\n }\n\n return createTransport(options, makeRequest);\n}\n\nexport { makeXHRTransport };\n//# sourceMappingURL=xhr.js.map\n","import { Integrations, getIntegrationsToSetup, initAndBind, getReportDialogEndpoint, getCurrentHub } from '@sentry/core';\nimport { stackParserFromStackParserOptions, supportsFetch, logger, resolvedSyncPromise, addInstrumentationHandler } from '@sentry/utils';\nimport { BrowserClient } from './client.js';\nimport { WINDOW, wrap as wrap$1 } from './helpers.js';\nimport { GlobalHandlers } from './integrations/globalhandlers.js';\nimport { TryCatch } from './integrations/trycatch.js';\nimport { Breadcrumbs } from './integrations/breadcrumbs.js';\nimport { LinkedErrors } from './integrations/linkederrors.js';\nimport { HttpContext } from './integrations/httpcontext.js';\nimport { Dedupe } from './integrations/dedupe.js';\nimport { defaultStackParser } from './stack-parsers.js';\nimport { makeFetchTransport } from './transports/fetch.js';\nimport { makeXHRTransport } from './transports/xhr.js';\n\nconst defaultIntegrations = [\n new Integrations.InboundFilters(),\n new Integrations.FunctionToString(),\n new TryCatch(),\n new Breadcrumbs(),\n new GlobalHandlers(),\n new LinkedErrors(),\n new Dedupe(),\n new HttpContext(),\n];\n\n/**\n * A magic string that build tooling can leverage in order to inject a release value into the SDK.\n */\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 */\nfunction init(options = {}) {\n if (options.defaultIntegrations === undefined) {\n options.defaultIntegrations = defaultIntegrations;\n }\n if (options.release === undefined) {\n // This allows build tooling to find-and-replace __SENTRY_RELEASE__ to inject a release value\n if (typeof __SENTRY_RELEASE__ === 'string') {\n options.release = __SENTRY_RELEASE__;\n }\n\n // This supports the variable that sentry-webpack-plugin injects\n if (WINDOW.SENTRY_RELEASE && WINDOW.SENTRY_RELEASE.id) {\n options.release = WINDOW.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\n const clientOptions = {\n ...options,\n stackParser: stackParserFromStackParserOptions(options.stackParser || defaultStackParser),\n integrations: getIntegrationsToSetup(options),\n transport: options.transport || (supportsFetch() ? makeFetchTransport : makeXHRTransport),\n };\n\n initAndBind(BrowserClient, clientOptions);\n\n if (options.autoSessionTracking) {\n startSessionTracking();\n }\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 */\nfunction showReportDialog(options = {}, hub = getCurrentHub()) {\n // doesn't work without a document (React Native)\n if (!WINDOW.document) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Global document not defined in showReportDialog call');\n return;\n }\n\n const { client, scope } = hub.getStackTop();\n const dsn = options.dsn || (client && client.getDsn());\n if (!dsn) {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('DSN not configured for showReportDialog call');\n return;\n }\n\n if (scope) {\n options.user = {\n ...scope.getUser(),\n ...options.user,\n };\n }\n\n if (!options.eventId) {\n options.eventId = hub.lastEventId();\n }\n\n const script = WINDOW.document.createElement('script');\n script.async = true;\n script.src = getReportDialogEndpoint(dsn, options);\n\n if (options.onLoad) {\n script.onload = options.onLoad;\n }\n\n const injectionPoint = WINDOW.document.head || WINDOW.document.body;\n if (injectionPoint) {\n injectionPoint.appendChild(script);\n } else {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Not injecting report dialog. No injection point found in HTML');\n }\n}\n\n/**\n * This is the getter for lastEventId.\n *\n * @returns The last event id of a captured event.\n */\nfunction lastEventId() {\n return getCurrentHub().lastEventId();\n}\n\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nfunction forceLoad() {\n // Noop\n}\n\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nfunction onLoad(callback) {\n callback();\n}\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 */\nfunction flush(timeout) {\n const client = getCurrentHub().getClient();\n if (client) {\n return client.flush(timeout);\n }\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Cannot flush events. No client defined.');\n return resolvedSyncPromise(false);\n}\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 */\nfunction close(timeout) {\n const client = getCurrentHub().getClient();\n if (client) {\n return client.close(timeout);\n }\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Cannot flush events and disable SDK. No client defined.');\n return resolvedSyncPromise(false);\n}\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\nfunction wrap(fn) {\n return wrap$1(fn)();\n}\n\nfunction startSessionOnHub(hub) {\n hub.startSession({ ignoreDuration: true });\n hub.captureSession();\n}\n\n/**\n * Enable automatic Session Tracking for the initial page load.\n */\nfunction startSessionTracking() {\n if (typeof WINDOW.document === 'undefined') {\n (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n logger.warn('Session tracking in non-browser environment with @sentry/browser is not supported.');\n return;\n }\n\n const hub = getCurrentHub();\n\n // The only way for this to be false is for there to be a version mismatch between @sentry/browser (>= 6.0.0) and\n // @sentry/hub (< 5.27.0). In the simple case, there won't ever be such a mismatch, because the two packages are\n // pinned at the same version in package.json, but there are edge cases where it's possible. See\n // https://github.com/getsentry/sentry-javascript/issues/3207 and\n // https://github.com/getsentry/sentry-javascript/issues/3234 and\n // https://github.com/getsentry/sentry-javascript/issues/3278.\n if (!hub.captureSession) {\n return;\n }\n\n // The session duration for browser sessions does not track a meaningful\n // concept that can be used as a metric.\n // Automatically captured sessions are akin to page views, and thus we\n // discard their duration.\n startSessionOnHub(hub);\n\n // We want to create a session for every navigation as well\n addInstrumentationHandler('history', ({ from, to }) => {\n // Don't create an additional session for the initial route or if the location did not change\n if (!(from === undefined || from === to)) {\n startSessionOnHub(getCurrentHub());\n }\n });\n}\n\nexport { close, defaultIntegrations, flush, forceLoad, init, lastEventId, onLoad, showReportDialog, wrap };\n//# sourceMappingURL=sdk.js.map\n"],"names":["exceptionFromError","stackParser","ex","frames","parseStackFrames","exception","type","name","value","extractMessage","length","stacktrace","undefined","eventFromError","values","stack","popSize","framesToPop","reactMinifiedRegexp","test","message","getPopSize","e","error","eventFromUnknownInput","syntheticException","attachStacktrace","isUnhandledRejection","event","is","domException","eventFromString","tags","code","client","getClient","normalizeDepth","getOptions","constructor","extra","__serialized__","normalize","eventFromPlainObject","synthetic","input","ignoreOnError","shouldIgnoreOnError","wrap","fn","options","before","wrapper","__sentry_wrapped__","sentryWrapped","args","Array","prototype","slice","call","arguments","apply","this","wrappedArguments","map","arg","setTimeout","scope","addEventProcessor","mechanism","property","Object","hasOwnProperty","_oO","getOwnPropertyDescriptor","configurable","defineProperty","get","MAX_ALLOWED_STRING_LENGTH","BREADCRUMB_INTEGRATION_ID","Breadcrumbs","static","id","__init","console","dom","fetch","history","sentry","xhr","setupOnce","_consoleBreadcrumb","handlerData","target","keyAttrs","serializeAttribute","maxStringLength","__SENTRY_DEBUG__","addBreadcrumb","category","global","_xhrBreadcrumb","_fetchBreadcrumb","_historyBreadcrumb","addSentryBreadcrumb","event_id","level","i","breadcrumb","data","logger","severity","endTimestamp","__sentry_own_request__","method","url","status_code","body","__sentry_xhr__","fetchData","match","response","status","from","to","parsedLoc","parsedFrom","parsedTo","path","protocol","host","relative","__initStatic","BrowserClient","sdkSource","_metadata","sdk","packages","version","super","sendClientReports","_flushOutcomes","eventFromException","hint","_options","eventFromMessage","sendEvent","breadcrumbIntegration","getIntegrationById","_prepareEvent","platform","outcomes","_clearOutcomes","log","_dsn","envelope","tunnel","dsn","toString","transportOptions","sendBeacon","_sendEnvelope","GlobalHandlers","__init2","_installFunc","onerror","_installGlobalOnErrorHandler","onunhandledrejection","_installGlobalOnUnhandledRejectionHandler","Error","stackTraceLimit","key","installFunc","hub","getHubAndOptions","getIntegration","msg","line","column","groups","_enhanceEventWithInitialFrame","_eventFromIncompleteOnError","addMechanismAndCapture","reason","detail","String","ev","ev0","ev0s","ev0sf","colno","isNaN","parseInt","lineno","filename","push","function","in_app","handled","captureEvent","originalException","DEFAULT_EVENT_TARGET","TryCatch","XMLHttpRequest","eventTarget","requestAnimationFrame","setInterval","_wrapTimeFunction","_wrapRAF","_wrapXHR","eventTargetOption","isArray","forEach","_wrapEventTarget","original","originalCallback","callback","handler","originalSend","prop","wrapOptions","originalFunction","globalObject","proto","eventName","handleEvent","err","originalRemoveEventListener","wrappedEventHandler","originalEventHandler","LinkedErrors","_key","_limit","limit","self","parser","linkedErrors","_walkErrorTree","_handler","HttpContext","request","referrer","userAgent","headers","Referer","Dedupe","addGlobalEventProcessor","getCurrentHub","eventProcessor","currentEvent","previousEvent","currentMessage","previousMessage","_isSameFingerprint","_isSameStacktrace","_isSameMessageEvent","previousException","_getExceptionFromEvent","currentException","_isSameExceptionEvent","_shouldDropEvent","_previousEvent","currentFrames","_getFramesFromEvent","previousFrames","frameA","frameB","currentFingerprint","fingerprint","previousFingerprint","join","UNKNOWN_FUNCTION","createFrame","func","frame","abs_path","chromeRegex","chromeEvalRegex","geckoREgex","geckoEvalRegex","winjsRegex","defaultStackLineParsers","parts","exec","indexOf","subMatch","extractSafariExtensionDetails","defaultStackParser","isSafariExtension","isSafariWebExtension","split","cachedFetchImpl","makeFetchTransport","nativeFetch","document","fetchImpl","createElement","sandbox","hidden","head","appendChild","contentWindow","removeChild","bind","getNativeFetchImplementation","requestOptions","referrerPolicy","keepalive","fetchOptions","then","statusCode","XHR_READYSTATE_DONE","makeXHRTransport","resolve","reject","onreadystatechange","readyState","getResponseHeader","open","header","setRequestHeader","send","defaultIntegrations","init","release","__SENTRY_RELEASE__","autoSessionTracking","clientOptions","integrations","transport","supports","captureSession","startSessionOnHub","startSessionTracking","startSession","ignoreDuration"],"sourceRoot":""}