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