{"version":3,"file":"vendors-96700d3a.xxxxxxxx.bundle.js","mappings":"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","sources":["webpack://iadviser/./node_modules/@sentry-internal/tracing/esm/common/debug-build.js","webpack://iadviser/./node_modules/@sentry-internal/tracing/esm/browser/types.js","webpack://iadviser/./node_modules/@sentry-internal/tracing/esm/browser/web-vitals/lib/getNavigationEntry.js","webpack://iadviser/./node_modules/@sentry-internal/tracing/esm/browser/web-vitals/lib/getActivationStart.js","webpack://iadviser/./node_modules/@sentry-internal/tracing/esm/browser/web-vitals/lib/onHidden.js","webpack://iadviser/./node_modules/@sentry-internal/tracing/esm/browser/web-vitals/lib/getVisibilityWatcher.js","webpack://iadviser/./node_modules/@sentry-internal/tracing/esm/browser/web-vitals/lib/observe.js","webpack://iadviser/./node_modules/@sentry-internal/tracing/esm/browser/web-vitals/getLCP.js","webpack://iadviser/./node_modules/@sentry-internal/tracing/esm/browser/web-vitals/lib/initMetric.js","webpack://iadviser/./node_modules/@sentry-internal/tracing/esm/browser/web-vitals/lib/generateUniqueID.js","webpack://iadviser/./node_modules/@sentry-internal/tracing/esm/browser/web-vitals/lib/bindReporter.js","webpack://iadviser/./node_modules/@sentry-internal/tracing/esm/browser/instrument.js","webpack://iadviser/./node_modules/@sentry/browser/esm/debug-build.js","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/userfeedback.js","webpack://iadviser/./node_modules/@sentry/browser/esm/client.js","webpack://iadviser/./node_modules/@sentry/browser/esm/integrations/breadcrumbs.js","webpack://iadviser/./node_modules/@sentry/browser/esm/integrations/dedupe.js","webpack://iadviser/./node_modules/@sentry/browser/esm/integrations/globalhandlers.js","webpack://iadviser/./node_modules/@sentry/browser/esm/integrations/httpcontext.js","webpack://iadviser/./node_modules/@sentry/browser/esm/integrations/linkederrors.js","webpack://iadviser/./node_modules/@sentry/browser/esm/integrations/trycatch.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":["/**\n * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.\n *\n * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.\n */\nconst DEBUG_BUILD = (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__);\n\nexport { DEBUG_BUILD };\n//# sourceMappingURL=debug-build.js.map\n","import { GLOBAL_OBJ } from '@sentry/utils';\n\nconst WINDOW = GLOBAL_OBJ\n\n;\n\nexport { WINDOW };\n//# sourceMappingURL=types.js.map\n","import { WINDOW } from '../../types.js';\n\n/*\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nconst getNavigationEntryFromPerformanceTiming = () => {\n // eslint-disable-next-line deprecation/deprecation\n const timing = WINDOW.performance.timing;\n // eslint-disable-next-line deprecation/deprecation\n const type = WINDOW.performance.navigation.type;\n\n const navigationEntry = {\n entryType: 'navigation',\n startTime: 0,\n type: type == 2 ? 'back_forward' : type === 1 ? 'reload' : 'navigate',\n };\n\n for (const key in timing) {\n if (key !== 'navigationStart' && key !== 'toJSON') {\n // eslint-disable-next-line deprecation/deprecation\n navigationEntry[key] = Math.max((timing[key ] ) - timing.navigationStart, 0);\n }\n }\n return navigationEntry ;\n};\n\nconst getNavigationEntry = () => {\n if (WINDOW.__WEB_VITALS_POLYFILL__) {\n return (\n WINDOW.performance &&\n ((performance.getEntriesByType && performance.getEntriesByType('navigation')[0]) ||\n getNavigationEntryFromPerformanceTiming())\n );\n } else {\n return WINDOW.performance && performance.getEntriesByType && performance.getEntriesByType('navigation')[0];\n }\n};\n\nexport { getNavigationEntry };\n//# sourceMappingURL=getNavigationEntry.js.map\n","import { getNavigationEntry } from './getNavigationEntry.js';\n\n/*\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nconst getActivationStart = () => {\n const navEntry = getNavigationEntry();\n return (navEntry && navEntry.activationStart) || 0;\n};\n\nexport { getActivationStart };\n//# sourceMappingURL=getActivationStart.js.map\n","import { WINDOW } from '../../types.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nconst onHidden = (cb, once) => {\n const onHiddenOrPageHide = (event) => {\n if (event.type === 'pagehide' || WINDOW.document.visibilityState === 'hidden') {\n cb(event);\n if (once) {\n removeEventListener('visibilitychange', onHiddenOrPageHide, true);\n removeEventListener('pagehide', onHiddenOrPageHide, true);\n }\n }\n };\n\n if (WINDOW.document) {\n addEventListener('visibilitychange', onHiddenOrPageHide, true);\n // Some browsers have buggy implementations of visibilitychange,\n // so we use pagehide in addition, just to be safe.\n addEventListener('pagehide', onHiddenOrPageHide, true);\n }\n};\n\nexport { onHidden };\n//# sourceMappingURL=onHidden.js.map\n","import { WINDOW } from '../../types.js';\nimport { onHidden } from './onHidden.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nlet firstHiddenTime = -1;\n\nconst initHiddenTime = () => {\n // If the document is hidden and not prerendering, assume it was always\n // hidden and the page was loaded in the background.\n if (WINDOW.document && WINDOW.document.visibilityState) {\n firstHiddenTime = WINDOW.document.visibilityState === 'hidden' && !WINDOW.document.prerendering ? 0 : Infinity;\n }\n};\n\nconst trackChanges = () => {\n // Update the time if/when the document becomes hidden.\n onHidden(({ timeStamp }) => {\n firstHiddenTime = timeStamp;\n }, true);\n};\n\nconst getVisibilityWatcher = (\n\n) => {\n if (firstHiddenTime < 0) {\n // If the document is hidden when this code runs, assume it was hidden\n // since navigation start. This isn't a perfect heuristic, but it's the\n // best we can do until an API is available to support querying past\n // visibilityState.\n initHiddenTime();\n trackChanges();\n }\n return {\n get firstHiddenTime() {\n return firstHiddenTime;\n },\n };\n};\n\nexport { getVisibilityWatcher };\n//# sourceMappingURL=getVisibilityWatcher.js.map\n","/**\n * Takes a performance entry type and a callback function, and creates a\n * `PerformanceObserver` instance that will observe the specified entry type\n * with buffering enabled and call the callback _for each entry_.\n *\n * This function also feature-detects entry support and wraps the logic in a\n * try/catch to avoid errors in unsupporting browsers.\n */\nconst observe = (\n type,\n callback,\n opts,\n) => {\n try {\n if (PerformanceObserver.supportedEntryTypes.includes(type)) {\n const po = new PerformanceObserver(list => {\n callback(list.getEntries() );\n });\n po.observe({\n type,\n buffered: true,\n ...opts,\n } );\n return po;\n }\n } catch (e) {\n // Do nothing.\n }\n return;\n};\n\nexport { observe };\n//# sourceMappingURL=observe.js.map\n","import { WINDOW } from '../types.js';\nimport { bindReporter } from './lib/bindReporter.js';\nimport { getActivationStart } from './lib/getActivationStart.js';\nimport { getVisibilityWatcher } from './lib/getVisibilityWatcher.js';\nimport { initMetric } from './lib/initMetric.js';\nimport { observe } from './lib/observe.js';\nimport { onHidden } from './lib/onHidden.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nconst reportedMetricIDs = {};\n\n/**\n * Calculates the [LCP](https://web.dev/lcp/) value for the current page and\n * calls the `callback` function once the value is ready (along with the\n * relevant `largest-contentful-paint` performance entry used to determine the\n * value). The reported value is a `DOMHighResTimeStamp`.\n */\nconst onLCP = (onReport) => {\n const visibilityWatcher = getVisibilityWatcher();\n const metric = initMetric('LCP');\n let report;\n\n const handleEntries = (entries) => {\n const lastEntry = entries[entries.length - 1] ;\n if (lastEntry) {\n // The startTime attribute returns the value of the renderTime if it is\n // not 0, and the value of the loadTime otherwise. The activationStart\n // reference is used because LCP should be relative to page activation\n // rather than navigation start if the page was prerendered.\n const value = Math.max(lastEntry.startTime - getActivationStart(), 0);\n\n // Only report if the page wasn't hidden prior to LCP.\n if (value < visibilityWatcher.firstHiddenTime) {\n metric.value = value;\n metric.entries = [lastEntry];\n report();\n }\n }\n };\n\n const po = observe('largest-contentful-paint', handleEntries);\n\n if (po) {\n report = bindReporter(onReport, metric);\n\n const stopListening = () => {\n if (!reportedMetricIDs[metric.id]) {\n handleEntries(po.takeRecords() );\n po.disconnect();\n reportedMetricIDs[metric.id] = true;\n report(true);\n }\n };\n\n // Stop listening after input. Note: while scrolling is an input that\n // stop LCP observation, it's unreliable since it can be programmatically\n // generated. See: https://github.com/GoogleChrome/web-vitals/issues/75\n ['keydown', 'click'].forEach(type => {\n if (WINDOW.document) {\n addEventListener(type, stopListening, { once: true, capture: true });\n }\n });\n\n onHidden(stopListening, true);\n\n return stopListening;\n }\n\n return;\n};\n\nexport { onLCP };\n//# sourceMappingURL=getLCP.js.map\n","import { WINDOW } from '../../types.js';\nimport { generateUniqueID } from './generateUniqueID.js';\nimport { getActivationStart } from './getActivationStart.js';\nimport { getNavigationEntry } from './getNavigationEntry.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nconst initMetric = (name, value) => {\n const navEntry = getNavigationEntry();\n let navigationType = 'navigate';\n\n if (navEntry) {\n if ((WINDOW.document && WINDOW.document.prerendering) || getActivationStart() > 0) {\n navigationType = 'prerender';\n } else {\n navigationType = navEntry.type.replace(/_/g, '-') ;\n }\n }\n\n return {\n name,\n value: typeof value === 'undefined' ? -1 : value,\n rating: 'good', // Will be updated if the value changes.\n delta: 0,\n entries: [],\n id: generateUniqueID(),\n navigationType,\n };\n};\n\nexport { initMetric };\n//# sourceMappingURL=initMetric.js.map\n","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Performantly generate a unique, 30-char string by combining a version\n * number, the current timestamp with a 13-digit number integer.\n * @return {string}\n */\nconst generateUniqueID = () => {\n return `v3-${Date.now()}-${Math.floor(Math.random() * (9e12 - 1)) + 1e12}`;\n};\n\nexport { generateUniqueID };\n//# sourceMappingURL=generateUniqueID.js.map\n","const bindReporter = (\n callback,\n metric,\n reportAllChanges,\n) => {\n let prevValue;\n let delta;\n return (forceReport) => {\n if (metric.value >= 0) {\n if (forceReport || reportAllChanges) {\n delta = metric.value - (prevValue || 0);\n\n // Report the metric if there's a non-zero delta or if no previous\n // value exists (which can happen in the case of the document becoming\n // hidden when the metric value is 0).\n // See: https://github.com/GoogleChrome/web-vitals/issues/14\n if (delta || prevValue === undefined) {\n prevValue = metric.value;\n metric.delta = delta;\n callback(metric);\n }\n }\n }\n };\n};\n\nexport { bindReporter };\n//# sourceMappingURL=bindReporter.js.map\n","import { logger, getFunctionName } from '@sentry/utils';\nimport { DEBUG_BUILD } from '../common/debug-build.js';\nimport { onCLS } from './web-vitals/getCLS.js';\nimport { onFID } from './web-vitals/getFID.js';\nimport { onINP } from './web-vitals/getINP.js';\nimport { onLCP } from './web-vitals/getLCP.js';\nimport { observe } from './web-vitals/lib/observe.js';\nimport { onTTFB } from './web-vitals/onTTFB.js';\n\nconst handlers = {};\nconst instrumented = {};\n\nlet _previousCls;\nlet _previousFid;\nlet _previousLcp;\nlet _previousTtfb;\nlet _previousInp;\n\n/**\n * Add a callback that will be triggered when a CLS metric is available.\n * Returns a cleanup callback which can be called to remove the instrumentation handler.\n *\n * Pass `stopOnCallback = true` to stop listening for CLS when the cleanup callback is called.\n * This will lead to the CLS being finalized and frozen.\n */\nfunction addClsInstrumentationHandler(\n callback,\n stopOnCallback = false,\n) {\n return addMetricObserver('cls', callback, instrumentCls, _previousCls, stopOnCallback);\n}\n\n/**\n * Add a callback that will be triggered when a LCP metric is available.\n * Returns a cleanup callback which can be called to remove the instrumentation handler.\n *\n * Pass `stopOnCallback = true` to stop listening for LCP when the cleanup callback is called.\n * This will lead to the LCP being finalized and frozen.\n */\nfunction addLcpInstrumentationHandler(\n callback,\n stopOnCallback = false,\n) {\n return addMetricObserver('lcp', callback, instrumentLcp, _previousLcp, stopOnCallback);\n}\n\n/**\n * Add a callback that will be triggered when a FID metric is available.\n */\nfunction addTtfbInstrumentationHandler(callback) {\n return addMetricObserver('ttfb', callback, instrumentTtfb, _previousTtfb);\n}\n\n/**\n * Add a callback that will be triggered when a FID metric is available.\n * Returns a cleanup callback which can be called to remove the instrumentation handler.\n */\nfunction addFidInstrumentationHandler(callback) {\n return addMetricObserver('fid', callback, instrumentFid, _previousFid);\n}\n\n/**\n * Add a callback that will be triggered when a INP metric is available.\n * Returns a cleanup callback which can be called to remove the instrumentation handler.\n */\nfunction addInpInstrumentationHandler(\n callback,\n) {\n return addMetricObserver('inp', callback, instrumentInp, _previousInp);\n}\n\n/**\n * Add a callback that will be triggered when a performance observer is triggered,\n * and receives the entries of the observer.\n * Returns a cleanup callback which can be called to remove the instrumentation handler.\n */\nfunction addPerformanceInstrumentationHandler(\n type,\n callback,\n) {\n addHandler(type, callback);\n\n if (!instrumented[type]) {\n instrumentPerformanceObserver(type);\n instrumented[type] = true;\n }\n\n return getCleanupCallback(type, callback);\n}\n\n/** Trigger all handlers of a given type. */\nfunction triggerHandlers(type, data) {\n const typeHandlers = handlers[type];\n\n if (!typeHandlers || !typeHandlers.length) {\n return;\n }\n\n for (const handler of typeHandlers) {\n try {\n handler(data);\n } catch (e) {\n DEBUG_BUILD &&\n logger.error(\n `Error while triggering instrumentation handler.\\nType: ${type}\\nName: ${getFunctionName(handler)}\\nError:`,\n e,\n );\n }\n }\n}\n\nfunction instrumentCls() {\n return onCLS(\n metric => {\n triggerHandlers('cls', {\n metric,\n });\n _previousCls = metric;\n },\n { reportAllChanges: true },\n );\n}\n\nfunction instrumentFid() {\n return onFID(metric => {\n triggerHandlers('fid', {\n metric,\n });\n _previousFid = metric;\n });\n}\n\nfunction instrumentLcp() {\n return onLCP(metric => {\n triggerHandlers('lcp', {\n metric,\n });\n _previousLcp = metric;\n });\n}\n\nfunction instrumentTtfb() {\n return onTTFB(metric => {\n triggerHandlers('ttfb', {\n metric,\n });\n _previousTtfb = metric;\n });\n}\n\nfunction instrumentInp() {\n return onINP(metric => {\n triggerHandlers('inp', {\n metric,\n });\n _previousInp = metric;\n });\n}\n\nfunction addMetricObserver(\n type,\n callback,\n instrumentFn,\n previousValue,\n stopOnCallback = false,\n) {\n addHandler(type, callback);\n\n let stopListening;\n\n if (!instrumented[type]) {\n stopListening = instrumentFn();\n instrumented[type] = true;\n }\n\n if (previousValue) {\n callback({ metric: previousValue });\n }\n\n return getCleanupCallback(type, callback, stopOnCallback ? stopListening : undefined);\n}\n\nfunction instrumentPerformanceObserver(type) {\n const options = {};\n\n // Special per-type options we want to use\n if (type === 'event') {\n options.durationThreshold = 0;\n }\n\n observe(\n type,\n entries => {\n triggerHandlers(type, { entries });\n },\n options,\n );\n}\n\nfunction addHandler(type, handler) {\n handlers[type] = handlers[type] || [];\n (handlers[type] ).push(handler);\n}\n\n// Get a callback which can be called to remove the instrumentation handler\nfunction getCleanupCallback(\n type,\n callback,\n stopListening,\n) {\n return () => {\n if (stopListening) {\n stopListening();\n }\n\n const typeHandlers = handlers[type];\n\n if (!typeHandlers) {\n return;\n }\n\n const index = typeHandlers.indexOf(callback);\n if (index !== -1) {\n typeHandlers.splice(index, 1);\n }\n };\n}\n\nexport { addClsInstrumentationHandler, addFidInstrumentationHandler, addInpInstrumentationHandler, addLcpInstrumentationHandler, addPerformanceInstrumentationHandler, addTtfbInstrumentationHandler };\n//# sourceMappingURL=instrument.js.map\n","/**\n * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.\n *\n * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.\n */\nconst DEBUG_BUILD = (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__);\n\nexport { DEBUG_BUILD };\n//# sourceMappingURL=debug-build.js.map\n","import { getClient } from '@sentry/core';\nimport { addExceptionMechanism, resolvedSyncPromise, isErrorEvent, isDOMError, isDOMException, addExceptionTypeValue, isError, isPlainObject, isEvent, isParameterizedString, normalizeToSize, extractExceptionKeysForMessage } 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 client = 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: getNonErrorObjectExceptionValue(exception, { isUnhandledRejection }),\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 // eslint-disable-next-line deprecation/deprecation\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 message,\n syntheticException,\n attachStacktrace,\n) {\n const event = {};\n\n if (attachStacktrace && syntheticException) {\n const frames = parseStackFrames(stackParser, syntheticException);\n if (frames.length) {\n event.exception = {\n values: [{ value: message, stacktrace: { frames } }],\n };\n }\n }\n\n if (isParameterizedString(message)) {\n const { __sentry_template_string__, __sentry_template_values__ } = message;\n\n event.logentry = {\n message: __sentry_template_string__,\n params: __sentry_template_values__,\n };\n return event;\n }\n\n event.message = message;\n return event;\n}\n\nfunction getNonErrorObjectExceptionValue(\n exception,\n { isUnhandledRejection },\n) {\n const keys = extractExceptionKeysForMessage(exception);\n const captureType = isUnhandledRejection ? 'promise rejection' : 'exception';\n\n // Some ErrorEvent instances do not have an `error` property, which is why they are not handled before\n // We still want to try to get a decent message for these cases\n if (isErrorEvent(exception)) {\n return `Event \\`ErrorEvent\\` captured as ${captureType} with message \\`${exception.message}\\``;\n }\n\n if (isEvent(exception)) {\n const className = getObjectClassName(exception);\n return `Event \\`${className}\\` (type=${exception.type}) captured as ${captureType}`;\n }\n\n return `Object captured as ${captureType} with keys: ${keys}`;\n}\n\nfunction getObjectClassName(obj) {\n try {\n const prototype = Object.getPrototypeOf(obj);\n return prototype ? prototype.constructor.name : undefined;\n } catch (e) {\n // ignore errors here\n }\n}\n\nexport { eventFromError, eventFromException, eventFromMessage, eventFromPlainObject, eventFromString, eventFromUnknownInput, exceptionFromError, parseStackFrames };\n//# sourceMappingURL=eventbuilder.js.map\n","import '@sentry-internal/tracing';\nimport { 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 if (typeof wrapper === 'function') {\n return wrapper;\n } else {\n // If we find that the `__sentry_wrapped__` function is not a function at the time of accessing it, it means\n // that something messed with it. In that case we want to return the originally passed function.\n return fn;\n }\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\nexport { WINDOW, ignoreNextOnError, shouldIgnoreOnError, wrap };\n//# sourceMappingURL=helpers.js.map\n","import { dsnToString, createEnvelope } from '@sentry/utils';\n\n/**\n * Creates an envelope from a user feedback.\n */\nfunction createUserFeedbackEnvelope(\n feedback,\n {\n metadata,\n tunnel,\n dsn,\n }\n\n,\n) {\n const headers = {\n event_id: feedback.event_id,\n sent_at: new Date().toISOString(),\n ...(metadata &&\n metadata.sdk && {\n sdk: {\n name: metadata.sdk.name,\n version: metadata.sdk.version,\n },\n }),\n ...(!!tunnel && !!dsn && { dsn: dsnToString(dsn) }),\n };\n const item = createUserFeedbackEnvelopeItem(feedback);\n\n return createEnvelope(headers, [item]);\n}\n\nfunction createUserFeedbackEnvelopeItem(feedback) {\n const feedbackHeaders = {\n type: 'user_report',\n };\n return [feedbackHeaders, feedback];\n}\n\nexport { createUserFeedbackEnvelope };\n//# sourceMappingURL=userfeedback.js.map\n","import { BaseClient, applySdkMetadata } from '@sentry/core';\nimport { getSDKSource, logger, createClientReportEnvelope, dsnToString } from '@sentry/utils';\nimport { DEBUG_BUILD } from './debug-build.js';\nimport { eventFromException, eventFromMessage } from './eventbuilder.js';\nimport { WINDOW } from './helpers.js';\nimport { createUserFeedbackEnvelope } from './userfeedback.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 applySdkMetadata(options, 'browser', ['browser'], sdkSource);\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 * Sends user feedback to Sentry.\n */\n captureUserFeedback(feedback) {\n if (!this._isEnabled()) {\n DEBUG_BUILD && logger.warn('SDK not enabled, will not capture user feedback.');\n return;\n }\n\n const envelope = createUserFeedbackEnvelope(feedback, {\n metadata: this.getSdkMetadata(),\n dsn: this.getDsn(),\n tunnel: this.getOptions().tunnel,\n });\n\n // _sendEnvelope should not throw\n // eslint-disable-next-line @typescript-eslint/no-floating-promises\n this._sendEnvelope(envelope);\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 DEBUG_BUILD && logger.log('No outcomes to send');\n return;\n }\n\n // This is really the only place where we want to check for a DSN and only send outcomes then\n if (!this._dsn) {\n DEBUG_BUILD && logger.log('No dsn provided, will not send outcomes');\n return;\n }\n\n DEBUG_BUILD && logger.log('Sending outcomes:', outcomes);\n\n const envelope = createClientReportEnvelope(outcomes, this._options.tunnel && dsnToString(this._dsn));\n\n // _sendEnvelope should not throw\n // eslint-disable-next-line @typescript-eslint/no-floating-promises\n this._sendEnvelope(envelope);\n }\n}\n\nexport { BrowserClient };\n//# sourceMappingURL=client.js.map\n","import { defineIntegration, convertIntegrationFnToClass, getClient, addBreadcrumb } from '@sentry/core';\nimport { addConsoleInstrumentationHandler, addClickKeypressInstrumentationHandler, addXhrInstrumentationHandler, addFetchInstrumentationHandler, addHistoryInstrumentationHandler, getEventDescription, logger, htmlTreeAsString, getComponentName, severityLevelFromString, safeJoin, SENTRY_XHR_DATA_KEY, parseUrl } from '@sentry/utils';\nimport { DEBUG_BUILD } from '../debug-build.js';\nimport { WINDOW } from '../helpers.js';\n\n/* eslint-disable max-lines */\n\n/** maxStringLength gets capped to prevent 100 breadcrumbs exceeding 1MB event payload size */\nconst MAX_ALLOWED_STRING_LENGTH = 1024;\n\nconst INTEGRATION_NAME = 'Breadcrumbs';\n\nconst _breadcrumbsIntegration = ((options = {}) => {\n const _options = {\n console: true,\n dom: true,\n fetch: true,\n history: true,\n sentry: true,\n xhr: true,\n ...options,\n };\n\n return {\n name: INTEGRATION_NAME,\n // TODO v8: Remove this\n setupOnce() {}, // eslint-disable-line @typescript-eslint/no-empty-function\n setup(client) {\n if (_options.console) {\n addConsoleInstrumentationHandler(_getConsoleBreadcrumbHandler(client));\n }\n if (_options.dom) {\n addClickKeypressInstrumentationHandler(_getDomBreadcrumbHandler(client, _options.dom));\n }\n if (_options.xhr) {\n addXhrInstrumentationHandler(_getXhrBreadcrumbHandler(client));\n }\n if (_options.fetch) {\n addFetchInstrumentationHandler(_getFetchBreadcrumbHandler(client));\n }\n if (_options.history) {\n addHistoryInstrumentationHandler(_getHistoryBreadcrumbHandler(client));\n }\n if (_options.sentry && client.on) {\n client.on('beforeSendEvent', _getSentryBreadcrumbHandler(client));\n }\n },\n };\n}) ;\n\nconst breadcrumbsIntegration = defineIntegration(_breadcrumbsIntegration);\n\n/**\n * Default Breadcrumbs instrumentations\n *\n * @deprecated Use `breadcrumbsIntegration()` instead.\n */\n// eslint-disable-next-line deprecation/deprecation\nconst Breadcrumbs = convertIntegrationFnToClass(INTEGRATION_NAME, breadcrumbsIntegration)\n\n;\n\n/**\n * Adds a breadcrumb for Sentry events or transactions if this option is enabled.\n */\nfunction _getSentryBreadcrumbHandler(client) {\n return function addSentryBreadcrumb(event) {\n if (getClient() !== client) {\n return;\n }\n\n 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\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 */\nfunction _getDomBreadcrumbHandler(\n client,\n dom,\n) {\n return function _innerDomBreadcrumb(handlerData) {\n if (getClient() !== client) {\n return;\n }\n\n let target;\n let componentName;\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 DEBUG_BUILD &&\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 const event = handlerData.event ;\n const element = _isEvent(event) ? event.target : event;\n\n target = htmlTreeAsString(element, { keyAttrs, maxStringLength });\n componentName = getComponentName(element);\n } catch (e) {\n target = '';\n }\n\n if (target.length === 0) {\n return;\n }\n\n const breadcrumb = {\n category: `ui.${handlerData.name}`,\n message: target,\n };\n\n if (componentName) {\n breadcrumb.data = { 'ui.component_name': componentName };\n }\n\n addBreadcrumb(breadcrumb, {\n event: handlerData.event,\n name: handlerData.name,\n global: handlerData.global,\n });\n };\n}\n\n/**\n * Creates breadcrumbs from console API calls\n */\nfunction _getConsoleBreadcrumbHandler(client) {\n return function _consoleBreadcrumb(handlerData) {\n if (getClient() !== client) {\n return;\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 addBreadcrumb(breadcrumb, {\n input: handlerData.args,\n level: handlerData.level,\n });\n };\n}\n\n/**\n * Creates breadcrumbs from XHR API calls\n */\nfunction _getXhrBreadcrumbHandler(client) {\n return function _xhrBreadcrumb(handlerData) {\n if (getClient() !== client) {\n return;\n }\n\n const { startTimestamp, endTimestamp } = handlerData;\n\n const sentryXhrData = handlerData.xhr[SENTRY_XHR_DATA_KEY];\n\n // We only capture complete, non-sentry requests\n if (!startTimestamp || !endTimestamp || !sentryXhrData) {\n return;\n }\n\n const { method, url, status_code, body } = sentryXhrData;\n\n const data = {\n method,\n url,\n status_code,\n };\n\n const hint = {\n xhr: handlerData.xhr,\n input: body,\n startTimestamp,\n endTimestamp,\n };\n\n addBreadcrumb(\n {\n category: 'xhr',\n data,\n type: 'http',\n },\n hint,\n );\n };\n}\n\n/**\n * Creates breadcrumbs from fetch API calls\n */\nfunction _getFetchBreadcrumbHandler(client) {\n return function _fetchBreadcrumb(handlerData) {\n if (getClient() !== client) {\n return;\n }\n\n const { startTimestamp, endTimestamp } = handlerData;\n\n // We only capture complete fetch requests\n if (!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 const data = handlerData.fetchData;\n const hint = {\n data: handlerData.error,\n input: handlerData.args,\n startTimestamp,\n endTimestamp,\n };\n\n addBreadcrumb(\n {\n category: 'fetch',\n data,\n level: 'error',\n type: 'http',\n },\n hint,\n );\n } else {\n const response = handlerData.response ;\n const data = {\n ...handlerData.fetchData,\n status_code: response && response.status,\n };\n const hint = {\n input: handlerData.args,\n response,\n startTimestamp,\n endTimestamp,\n };\n addBreadcrumb(\n {\n category: 'fetch',\n data,\n type: 'http',\n },\n hint,\n );\n }\n };\n}\n\n/**\n * Creates breadcrumbs from history API calls\n */\nfunction _getHistoryBreadcrumbHandler(client) {\n return function _historyBreadcrumb(handlerData) {\n if (getClient() !== client) {\n return;\n }\n\n let from = handlerData.from;\n let to = handlerData.to;\n const parsedLoc = parseUrl(WINDOW.location.href);\n let parsedFrom = from ? parseUrl(from) : undefined;\n const parsedTo = parseUrl(to);\n\n // Initial pushState doesn't provide `from` information\n if (!parsedFrom || !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 addBreadcrumb({\n category: 'navigation',\n data: {\n from,\n to,\n },\n });\n };\n}\n\nfunction _isEvent(event) {\n return !!event && !!(event ).target;\n}\n\nexport { Breadcrumbs, breadcrumbsIntegration };\n//# sourceMappingURL=breadcrumbs.js.map\n","import { defineIntegration, convertIntegrationFnToClass } from '@sentry/core';\nimport { logger } from '@sentry/utils';\nimport { DEBUG_BUILD } from '../debug-build.js';\n\nconst INTEGRATION_NAME = 'Dedupe';\n\nconst _dedupeIntegration = (() => {\n let previousEvent;\n\n return {\n name: INTEGRATION_NAME,\n // TODO v8: Remove this\n setupOnce() {}, // eslint-disable-line @typescript-eslint/no-empty-function\n processEvent(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 // Juuust in case something goes wrong\n try {\n if (_shouldDropEvent(currentEvent, previousEvent)) {\n DEBUG_BUILD && logger.warn('Event dropped due to being a duplicate of previously captured event.');\n return null;\n }\n } catch (_oO) {} // eslint-disable-line no-empty\n\n return (previousEvent = currentEvent);\n },\n };\n}) ;\n\nconst dedupeIntegration = defineIntegration(_dedupeIntegration);\n\n/**\n * Deduplication filter.\n * @deprecated Use `dedupeIntegration()` instead.\n */\n// eslint-disable-next-line deprecation/deprecation\nconst Dedupe = convertIntegrationFnToClass(INTEGRATION_NAME, dedupeIntegration)\n\n;\n\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\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\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\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\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\nfunction _getExceptionFromEvent(event) {\n return event.exception && event.exception.values && event.exception.values[0];\n}\n\nfunction _getFramesFromEvent(event) {\n const exception = event.exception;\n\n if (exception) {\n try {\n // @ts-expect-error 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, dedupeIntegration };\n//# sourceMappingURL=dedupe.js.map\n","import { defineIntegration, convertIntegrationFnToClass, getClient, captureEvent } from '@sentry/core';\nimport { addGlobalErrorInstrumentationHandler, isString, addGlobalUnhandledRejectionInstrumentationHandler, isPrimitive, isErrorEvent, getLocationHref, logger } from '@sentry/utils';\nimport { DEBUG_BUILD } from '../debug-build.js';\nimport { eventFromUnknownInput } from '../eventbuilder.js';\nimport { shouldIgnoreOnError } from '../helpers.js';\n\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n\nconst INTEGRATION_NAME = 'GlobalHandlers';\n\nconst _globalHandlersIntegration = ((options = {}) => {\n const _options = {\n onerror: true,\n onunhandledrejection: true,\n ...options,\n };\n\n return {\n name: INTEGRATION_NAME,\n setupOnce() {\n Error.stackTraceLimit = 50;\n },\n setup(client) {\n if (_options.onerror) {\n _installGlobalOnErrorHandler(client);\n globalHandlerLog('onerror');\n }\n if (_options.onunhandledrejection) {\n _installGlobalOnUnhandledRejectionHandler(client);\n globalHandlerLog('onunhandledrejection');\n }\n },\n };\n}) ;\n\nconst globalHandlersIntegration = defineIntegration(_globalHandlersIntegration);\n\n/**\n * Global handlers.\n * @deprecated Use `globalHandlersIntegration()` instead.\n */\n// eslint-disable-next-line deprecation/deprecation\nconst GlobalHandlers = convertIntegrationFnToClass(\n INTEGRATION_NAME,\n globalHandlersIntegration,\n)\n\n;\n\nfunction _installGlobalOnErrorHandler(client) {\n addGlobalErrorInstrumentationHandler(data => {\n const { stackParser, attachStacktrace } = getOptions();\n\n if (getClient() !== client || shouldIgnoreOnError()) {\n return;\n }\n\n const { msg, url, line, column, error } = data;\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 captureEvent(event, {\n originalException: error,\n mechanism: {\n handled: false,\n type: 'onerror',\n },\n });\n });\n}\n\nfunction _installGlobalOnUnhandledRejectionHandler(client) {\n addGlobalUnhandledRejectionInstrumentationHandler(e => {\n const { stackParser, attachStacktrace } = getOptions();\n\n if (getClient() !== client || shouldIgnoreOnError()) {\n return;\n }\n\n const error = _getUnhandledRejectionError(e );\n\n const event = isPrimitive(error)\n ? _eventFromRejectionWithPrimitive(error)\n : eventFromUnknownInput(stackParser, error, undefined, attachStacktrace, true);\n\n event.level = 'error';\n\n captureEvent(event, {\n originalException: error,\n mechanism: {\n handled: false,\n type: 'onunhandledrejection',\n },\n });\n });\n}\n\nfunction _getUnhandledRejectionError(error) {\n if (isPrimitive(error)) {\n return error;\n }\n\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n const e = error ;\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 return e.reason;\n }\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 return e.detail.reason;\n }\n } catch (e2) {} // eslint-disable-line no-empty\n\n return error;\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// 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 DEBUG_BUILD && logger.log(`Global Handler attached: ${type}`);\n}\n\nfunction getOptions() {\n const client = getClient();\n const options = (client && client.getOptions()) || {\n stackParser: () => [],\n attachStacktrace: false,\n };\n return options;\n}\n\nexport { GlobalHandlers, globalHandlersIntegration };\n//# sourceMappingURL=globalhandlers.js.map\n","import { defineIntegration, convertIntegrationFnToClass } from '@sentry/core';\nimport { WINDOW } from '../helpers.js';\n\nconst INTEGRATION_NAME = 'HttpContext';\n\nconst _httpContextIntegration = (() => {\n return {\n name: INTEGRATION_NAME,\n // TODO v8: Remove this\n setupOnce() {}, // eslint-disable-line @typescript-eslint/no-empty-function\n preprocessEvent(event) {\n // if none of the information we want exists, don't bother\n if (!WINDOW.navigator && !WINDOW.location && !WINDOW.document) {\n return;\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 event.request = request;\n },\n };\n}) ;\n\nconst httpContextIntegration = defineIntegration(_httpContextIntegration);\n\n/**\n * HttpContext integration collects information about HTTP request headers.\n * @deprecated Use `httpContextIntegration()` instead.\n */\n// eslint-disable-next-line deprecation/deprecation\nconst HttpContext = convertIntegrationFnToClass(INTEGRATION_NAME, httpContextIntegration)\n\n;\n\nexport { HttpContext, httpContextIntegration };\n//# sourceMappingURL=httpcontext.js.map\n","import { defineIntegration, convertIntegrationFnToClass } from '@sentry/core';\nimport { applyAggregateErrorsToEvent } from '@sentry/utils';\nimport { exceptionFromError } from '../eventbuilder.js';\n\nconst DEFAULT_KEY = 'cause';\nconst DEFAULT_LIMIT = 5;\n\nconst INTEGRATION_NAME = 'LinkedErrors';\n\nconst _linkedErrorsIntegration = ((options = {}) => {\n const limit = options.limit || DEFAULT_LIMIT;\n const key = options.key || DEFAULT_KEY;\n\n return {\n name: INTEGRATION_NAME,\n // TODO v8: Remove this\n setupOnce() {}, // eslint-disable-line @typescript-eslint/no-empty-function\n preprocessEvent(event, hint, client) {\n const options = client.getOptions();\n\n applyAggregateErrorsToEvent(\n // This differs from the LinkedErrors integration in core by using a different exceptionFromError function\n exceptionFromError,\n options.stackParser,\n options.maxValueLength,\n key,\n limit,\n event,\n hint,\n );\n },\n };\n}) ;\n\nconst linkedErrorsIntegration = defineIntegration(_linkedErrorsIntegration);\n\n/**\n * Aggregrate linked errors in an event.\n * @deprecated Use `linkedErrorsIntegration()` instead.\n */\n// eslint-disable-next-line deprecation/deprecation\nconst LinkedErrors = convertIntegrationFnToClass(INTEGRATION_NAME, linkedErrorsIntegration)\n\n;\n\nexport { LinkedErrors, linkedErrorsIntegration };\n//# sourceMappingURL=linkederrors.js.map\n","import { defineIntegration, convertIntegrationFnToClass } from '@sentry/core';\nimport { 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 'BroadcastChannel',\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 'SharedWorker',\n 'TextTrack',\n 'TextTrackCue',\n 'TextTrackList',\n 'WebSocket',\n 'WebSocketWorker',\n 'Worker',\n 'XMLHttpRequest',\n 'XMLHttpRequestEventTarget',\n 'XMLHttpRequestUpload',\n];\n\nconst INTEGRATION_NAME = 'TryCatch';\n\nconst _browserApiErrorsIntegration = ((options = {}) => {\n const _options = {\n XMLHttpRequest: true,\n eventTarget: true,\n requestAnimationFrame: true,\n setInterval: true,\n setTimeout: true,\n ...options,\n };\n\n return {\n name: INTEGRATION_NAME,\n // TODO: This currently only works for the first client this is setup\n // We may want to adjust this to check for client etc.\n setupOnce() {\n if (_options.setTimeout) {\n fill(WINDOW, 'setTimeout', _wrapTimeFunction);\n }\n\n if (_options.setInterval) {\n fill(WINDOW, 'setInterval', _wrapTimeFunction);\n }\n\n if (_options.requestAnimationFrame) {\n fill(WINDOW, 'requestAnimationFrame', _wrapRAF);\n }\n\n if (_options.XMLHttpRequest && 'XMLHttpRequest' in WINDOW) {\n fill(XMLHttpRequest.prototype, 'send', _wrapXHR);\n }\n\n const eventTargetOption = _options.eventTarget;\n if (eventTargetOption) {\n const eventTarget = Array.isArray(eventTargetOption) ? eventTargetOption : DEFAULT_EVENT_TARGET;\n eventTarget.forEach(_wrapEventTarget);\n }\n },\n };\n}) ;\n\nconst browserApiErrorsIntegration = defineIntegration(_browserApiErrorsIntegration);\n\n/**\n * Wrap timer functions and event targets to catch errors and provide better meta data.\n * @deprecated Use `browserApiErrorsIntegration()` instead.\n */\n// eslint-disable-next-line deprecation/deprecation\nconst TryCatch = convertIntegrationFnToClass(\n INTEGRATION_NAME,\n browserApiErrorsIntegration,\n)\n\n;\n\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: false,\n type: 'instrument',\n },\n });\n return original.apply(this, args);\n };\n}\n\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: false,\n type: 'instrument',\n },\n }),\n ]);\n };\n}\n\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: false,\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\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: false,\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: false,\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, browserApiErrorsIntegration };\n//# sourceMappingURL=trycatch.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 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 )?((?:|[-a-z]+:|.*bundle|\\/)?.*?)(?::(\\d+))?(?::(\\d+))?\\)?\\s*$/i;\nconst chromeEvalRegex = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/;\n\n// We cannot call this variable `chrome` because it can conflict with global `chrome` variable in certain environments\n// See: https://github.com/getsentry/sentry-javascript/issues/6880\nconst chromeStackParserFn = 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, chromeStackParserFn];\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*(.*?)(?:\\((.*?)\\))?(?:^|@)?((?:[-a-z]+)?:\\/.*?|\\[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 = /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:[-a-z]+):.*?):(\\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 { DEBUG_BUILD } from '../debug-build.js';\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 DEBUG_BUILD && 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 let pendingBodySize = 0;\n let pendingCount = 0;\n\n function makeRequest(request) {\n const requestSize = request.body.length;\n pendingBodySize += requestSize;\n pendingCount++;\n\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):\n // If the sum of contentLength and inflightKeepaliveBytes is greater than 64 kibibytes, then return a network error.\n // We will therefore only activate the flag when we're below that limit.\n // There is also a limit of requests that can be open at the same time, so we also limit this to 15\n // See https://github.com/getsentry/sentry-javascript/pull/7553 for details\n keepalive: pendingBodySize <= 60000 && pendingCount < 15,\n ...options.fetchOptions,\n };\n\n try {\n return nativeFetch(options.url, requestOptions).then(response => {\n pendingBodySize -= requestSize;\n pendingCount--;\n return {\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 });\n } catch (e) {\n clearCachedFetchImplementation();\n pendingBodySize -= requestSize;\n pendingCount--;\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 { inboundFiltersIntegration, functionToStringIntegration, getIntegrationsToSetup, initAndBind, getReportDialogEndpoint, getCurrentHub, startSession, captureSession, getClient } from '@sentry/core';\nimport { stackParserFromStackParserOptions, supportsFetch, logger, addHistoryInstrumentationHandler } from '@sentry/utils';\nimport { BrowserClient } from './client.js';\nimport { DEBUG_BUILD } from './debug-build.js';\nimport { WINDOW, wrap as wrap$1 } from './helpers.js';\nimport { breadcrumbsIntegration } from './integrations/breadcrumbs.js';\nimport { dedupeIntegration } from './integrations/dedupe.js';\nimport { globalHandlersIntegration } from './integrations/globalhandlers.js';\nimport { httpContextIntegration } from './integrations/httpcontext.js';\nimport { linkedErrorsIntegration } from './integrations/linkederrors.js';\nimport { browserApiErrorsIntegration } from './integrations/trycatch.js';\nimport { defaultStackParser } from './stack-parsers.js';\nimport { makeFetchTransport } from './transports/fetch.js';\nimport { makeXHRTransport } from './transports/xhr.js';\n\n/** @deprecated Use `getDefaultIntegrations(options)` instead. */\nconst defaultIntegrations = [\n inboundFiltersIntegration(),\n functionToStringIntegration(),\n browserApiErrorsIntegration(),\n breadcrumbsIntegration(),\n globalHandlersIntegration(),\n linkedErrorsIntegration(),\n dedupeIntegration(),\n httpContextIntegration(),\n];\n\n/** Get the default integrations for the browser SDK. */\nfunction getDefaultIntegrations(_options) {\n // We return a copy of the defaultIntegrations here to avoid mutating this\n return [\n // eslint-disable-next-line deprecation/deprecation\n ...defaultIntegrations,\n ];\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 = getDefaultIntegrations();\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\nconst showReportDialog = (\n // eslint-disable-next-line deprecation/deprecation\n options = {},\n // eslint-disable-next-line deprecation/deprecation\n hub = getCurrentHub(),\n) => {\n // doesn't work without a document (React Native)\n if (!WINDOW.document) {\n DEBUG_BUILD && logger.error('Global document not defined in showReportDialog call');\n return;\n }\n\n // eslint-disable-next-line deprecation/deprecation\n const { client, scope } = hub.getStackTop();\n const dsn = options.dsn || (client && client.getDsn());\n if (!dsn) {\n DEBUG_BUILD && 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 // eslint-disable-next-line deprecation/deprecation\n options.eventId = hub.lastEventId();\n }\n\n const script = WINDOW.document.createElement('script');\n script.async = true;\n script.crossOrigin = 'anonymous';\n script.src = getReportDialogEndpoint(dsn, options);\n\n if (options.onLoad) {\n script.onload = options.onLoad;\n }\n\n const { onClose } = options;\n if (onClose) {\n const reportDialogClosedMessageHandler = (event) => {\n if (event.data === '__sentry_reportdialog_closed__') {\n try {\n onClose();\n } finally {\n WINDOW.removeEventListener('message', reportDialogClosedMessageHandler);\n }\n }\n };\n WINDOW.addEventListener('message', reportDialogClosedMessageHandler);\n }\n\n const injectionPoint = WINDOW.document.head || WINDOW.document.body;\n if (injectionPoint) {\n injectionPoint.appendChild(script);\n } else {\n DEBUG_BUILD && logger.error('Not injecting report dialog. No injection point found in HTML');\n }\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 * Wrap code within a try/catch block so the SDK is able to capture errors.\n *\n * @deprecated This function will be removed in v8.\n * It is not part of Sentry's official API and it's easily replaceable by using a try/catch block\n * and calling Sentry.captureException.\n *\n * @param fn A function to wrap.\n *\n * @returns The result of wrapped function call.\n */\n// TODO(v8): Remove this function\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction wrap(fn) {\n return wrap$1(fn)();\n}\n\n/**\n * Enable automatic Session Tracking for the initial page load.\n */\nfunction startSessionTracking() {\n if (typeof WINDOW.document === 'undefined') {\n DEBUG_BUILD && logger.warn('Session tracking in non-browser environment with @sentry/browser is not supported.');\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 startSession({ ignoreDuration: true });\n captureSession();\n\n // We want to create a session for every navigation as well\n addHistoryInstrumentationHandler(({ 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 startSession({ ignoreDuration: true });\n captureSession();\n }\n });\n}\n\n/**\n * Captures user feedback and sends it to Sentry.\n */\nfunction captureUserFeedback(feedback) {\n const client = getClient();\n if (client) {\n client.captureUserFeedback(feedback);\n }\n}\n\nexport { captureUserFeedback, defaultIntegrations, forceLoad, getDefaultIntegrations, init, onLoad, showReportDialog, wrap };\n//# sourceMappingURL=sdk.js.map\n"],"names":["DEBUG_BUILD","__SENTRY_DEBUG__","WINDOW","getNavigationEntry","__WEB_VITALS_POLYFILL__","performance","getEntriesByType","timing","type","navigation","navigationEntry","entryType","startTime","key","Math","max","navigationStart","getNavigationEntryFromPerformanceTiming","getActivationStart","navEntry","activationStart","onHidden","cb","once","onHiddenOrPageHide","event","document","visibilityState","removeEventListener","addEventListener","firstHiddenTime","observe","callback","opts","PerformanceObserver","supportedEntryTypes","includes","po","list","getEntries","buffered","e","reportedMetricIDs","onLCP","onReport","visibilityWatcher","prerendering","Infinity","timeStamp","metric","navigationType","replace","name","value","rating","delta","entries","id","Date","now","floor","random","initMetric","report","handleEntries","lastEntry","length","prevValue","forceReport","undefined","bindReporter","stopListening","takeRecords","disconnect","forEach","capture","handlers","instrumented","_previousLcp","addLcpInstrumentationHandler","stopOnCallback","instrumentFn","previousValue","addHandler","getCleanupCallback","addMetricObserver","instrumentLcp","addPerformanceInstrumentationHandler","options","durationThreshold","triggerHandlers","instrumentPerformanceObserver","data","typeHandlers","handler","logger","error","push","index","indexOf","splice","exceptionFromError","stackParser","ex","frames","parseStackFrames","exception","extractMessage","stacktrace","eventFromError","values","stack","popSize","framesToPop","reactMinifiedRegexp","test","message","getPopSize","eventFromUnknownInput","syntheticException","attachStacktrace","isUnhandledRejection","is","domException","eventFromString","tags","code","client","normalizeDepth","getOptions","constructor","getNonErrorObjectExceptionValue","extra","__serialized__","normalize","eventFromPlainObject","synthetic","__sentry_template_string__","__sentry_template_values__","logentry","params","keys","captureType","obj","prototype","Object","getPrototypeOf","getObjectClassName","ignoreOnError","shouldIgnoreOnError","wrap","fn","before","wrapper","__sentry_wrapped__","sentryWrapped","args","Array","slice","call","arguments","apply","this","wrappedArguments","map","arg","setTimeout","scope","addEventProcessor","mechanism","property","hasOwnProperty","_oO","getOwnPropertyDescriptor","configurable","defineProperty","get","createUserFeedbackEnvelope","feedback","metadata","tunnel","dsn","headers","event_id","sent_at","toISOString","sdk","version","item","createUserFeedbackEnvelopeItem","BrowserClient","sdkSource","SENTRY_SDK_SOURCE","super","sendClientReports","_flushOutcomes","eventFromException","hint","level","_options","eventFromMessage","captureUserFeedback","_isEnabled","warn","envelope","getSdkMetadata","getDsn","_sendEnvelope","_prepareEvent","platform","outcomes","_clearOutcomes","log","_dsn","INTEGRATION_NAME","breadcrumbsIntegration","console","dom","fetch","history","sentry","xhr","setupOnce","setup","handlerData","breadcrumb","category","severity","input","_getConsoleBreadcrumbHandler","target","componentName","keyAttrs","serializeAttribute","maxStringLength","element","_isEvent","global","_getDomBreadcrumbHandler","startTimestamp","endTimestamp","sentryXhrData","method","url","status_code","body","_getXhrBreadcrumbHandler","fetchData","match","response","status","_getFetchBreadcrumbHandler","from","to","parsedLoc","location","href","parsedFrom","parsedTo","path","protocol","host","relative","_getHistoryBreadcrumbHandler","on","_getSentryBreadcrumbHandler","dedupeIntegration","previousEvent","processEvent","currentEvent","currentMessage","previousMessage","_isSameFingerprint","_isSameStacktrace","_isSameMessageEvent","previousException","_getExceptionFromEvent","currentException","_isSameExceptionEvent","_shouldDropEvent","currentFrames","_getFramesFromEvent","previousFrames","i","frameA","frameB","filename","lineno","colno","function","currentFingerprint","fingerprint","previousFingerprint","join","globalHandlersIntegration","onerror","onunhandledrejection","Error","stackTraceLimit","msg","line","column","groups","_enhanceEventWithInitialFrame","_eventFromIncompleteOnError","originalException","handled","_installGlobalOnErrorHandler","globalHandlerLog","reason","detail","e2","_getUnhandledRejectionError","String","_installGlobalOnUnhandledRejectionHandler","ev","ev0","ev0s","ev0sf","isNaN","parseInt","in_app","httpContextIntegration","preprocessEvent","navigator","request","referrer","userAgent","Referer","linkedErrorsIntegration","limit","maxValueLength","DEFAULT_EVENT_TARGET","browserApiErrorsIntegration","XMLHttpRequest","eventTarget","requestAnimationFrame","setInterval","_wrapTimeFunction","_wrapRAF","_wrapXHR","eventTargetOption","isArray","_wrapEventTarget","original","originalCallback","originalSend","prop","wrapOptions","originalFunction","globalObject","proto","eventName","handleEvent","err","originalRemoveEventListener","wrappedEventHandler","originalEventHandler","UNKNOWN_FUNCTION","createFrame","func","frame","chromeRegex","chromeEvalRegex","geckoREgex","geckoEvalRegex","winjsRegex","defaultStackLineParsers","parts","exec","subMatch","extractSafariExtensionDetails","defaultStackParser","isSafariExtension","isSafariWebExtension","split","cachedFetchImpl","makeFetchTransport","nativeFetch","bind","fetchImpl","createElement","sandbox","hidden","head","appendChild","contentWindow","removeChild","getNativeFetchImplementation","pendingBodySize","pendingCount","requestSize","requestOptions","referrerPolicy","keepalive","fetchOptions","then","statusCode","XHR_READYSTATE_DONE","makeXHRTransport","resolve","reject","onreadystatechange","readyState","getResponseHeader","open","header","setRequestHeader","send","defaultIntegrations","init","release","__SENTRY_RELEASE__","SENTRY_RELEASE","autoSessionTracking","clientOptions","integrations","transport","supports","ignoreDuration"],"sourceRoot":""}