{"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 = '<unknown>';\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 )?((?:<anonymous>|[-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 (?:<anonymous function: ([^>]+)>|([^)]+))\\(.*\\))? 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","OW","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","vF","error","stacktrace","qQ","push","index","indexOf","splice","exceptionFromError","stackParser","ex","frames","parseStackFrames","exception","extractMessage","eventFromError","values","stack","popSize","framesToPop","reactMinifiedRegexp","test","message","getPopSize","eventFromUnknownInput","syntheticException","attachStacktrace","isUnhandledRejection","is","T2","BD","W6","domException","eventFromString","misc","gO","tags","code","bJ","Qd","xH","client","esm_exports","KU","normalizeDepth","getOptions","constructor","getNonErrorObjectExceptionValue","extra","__serialized__","normalize","cd","eventFromPlainObject","M6","synthetic","NF","__sentry_template_string__","__sentry_template_values__","logentry","params","keys","object","HF","captureType","obj","prototype","Object","getPrototypeOf","getObjectClassName","ignoreOnError","shouldIgnoreOnError","wrap","fn","before","wrapper","__sentry_wrapped__","sp","sentryWrapped","args","Array","slice","call","arguments","apply","this","wrappedArguments","map","arg","setTimeout","v4","scope","addEventProcessor","mechanism","Cp","property","hasOwnProperty","_oO","pO","my","getOwnPropertyDescriptor","configurable","defineProperty","get","createUserFeedbackEnvelope","feedback","metadata","tunnel","dsn","headers","event_id","sent_at","toISOString","sdk","version","esm_dsn","SB","item","createUserFeedbackEnvelopeItem","envelope","h4","BrowserClient","baseclient","V","sdkSource","SENTRY_SDK_SOURCE","env","sdkMetadata","K","super","sendClientReports","_flushOutcomes","eventFromException","hint","level","syncpromise","XW","_options","eventFromMessage","captureUserFeedback","_isEnabled","warn","getSdkMetadata","getDsn","_sendEnvelope","_prepareEvent","platform","outcomes","_clearOutcomes","log","_dsn","clientreport","m","INTEGRATION_NAME","breadcrumbsIntegration","integration","_C","console","dom","fetch","history","sentry","xhr","setupOnce","setup","P","handlerData","breadcrumb","category","severity","te","string","gt","ZQ","input","_getConsoleBreadcrumbHandler","i","target","componentName","keyAttrs","serializeAttribute","maxStringLength","element","_isEvent","browser","Hd","xE","global","_getDomBreadcrumbHandler","Mn","startTimestamp","endTimestamp","sentryXhrData","Er","method","url","status_code","body","_getXhrBreadcrumbHandler","u","fetchData","match","response","status","_getFetchBreadcrumbHandler","instrument_history","_","from","to","parsedLoc","Dl","location","href","parsedFrom","parsedTo","path","protocol","host","relative","_getHistoryBreadcrumbHandler","on","$X","_getSentryBreadcrumbHandler","F","dedupe_INTEGRATION_NAME","dedupeIntegration","previousEvent","processEvent","currentEvent","currentMessage","previousMessage","_isSameFingerprint","_isSameStacktrace","_isSameMessageEvent","previousException","_getExceptionFromEvent","currentException","_isSameExceptionEvent","_shouldDropEvent","currentFrames","_getFramesFromEvent","previousFrames","frameA","frameB","filename","lineno","colno","function","currentFingerprint","fingerprint","previousFingerprint","join","globalhandlers_INTEGRATION_NAME","globalHandlersIntegration","onerror","onunhandledrejection","Error","stackTraceLimit","globalError","L","msg","line","column","Kg","groups","_enhanceEventWithInitialFrame","_eventFromIncompleteOnError","r","originalException","handled","_installGlobalOnErrorHandler","globalHandlerLog","globalUnhandledRejection","sO","reason","detail","e2","_getUnhandledRejectionError","String","_installGlobalOnUnhandledRejectionHandler","ev","ev0","ev0s","ev0sf","isNaN","parseInt","$N","in_app","httpcontext_INTEGRATION_NAME","httpContextIntegration","preprocessEvent","navigator","request","referrer","userAgent","Referer","linkederrors_INTEGRATION_NAME","linkedErrorsIntegration","limit","aggregate_errors","Q","maxValueLength","DEFAULT_EVENT_TARGET","trycatch_INTEGRATION_NAME","browserApiErrorsIntegration","XMLHttpRequest","eventTarget","requestAnimationFrame","setInterval","GS","_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","gd","isSafariExtension","isSafariWebExtension","split","cachedFetchImpl","makeFetchTransport","nativeFetch","supports","ap","bind","fetchImpl","createElement","sandbox","hidden","head","appendChild","contentWindow","removeChild","getNativeFetchImplementation","pendingBodySize","pendingCount","base","o","requestSize","requestOptions","referrerPolicy","keepalive","fetchOptions","then","statusCode","xg","XHR_READYSTATE_DONE","makeXHRTransport","resolve","reject","onreadystatechange","readyState","getResponseHeader","open","header","setRequestHeader","send","defaultIntegrations","inboundfilters","D","functiontostring","Z","init","release","__SENTRY_RELEASE__","SENTRY_RELEASE","autoSessionTracking","clientOptions","vk","integrations","mH","transport","vm","J","J0","ignoreDuration","J5"],"sourceRoot":""}