{"version":3,"file":"js/chunk-vendors-15b5c380-legacy.727c9f3c.js","mappings":"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","sources":["webpack://upmed-agendamento/./node_modules/@sentry/browser/esm/eventbuilder.js","webpack://upmed-agendamento/./node_modules/@sentry/browser/esm/helpers.js","webpack://upmed-agendamento/./node_modules/@sentry/browser/esm/integrations/breadcrumbs.js","webpack://upmed-agendamento/./node_modules/@sentry/browser/esm/client.js","webpack://upmed-agendamento/./node_modules/@sentry/browser/esm/integrations/globalhandlers.js","webpack://upmed-agendamento/./node_modules/@sentry/browser/esm/integrations/trycatch.js","webpack://upmed-agendamento/./node_modules/@sentry/browser/esm/integrations/linkederrors.js","webpack://upmed-agendamento/./node_modules/@sentry/browser/esm/integrations/httpcontext.js","webpack://upmed-agendamento/./node_modules/@sentry/browser/esm/integrations/dedupe.js","webpack://upmed-agendamento/./node_modules/@sentry/browser/esm/stack-parsers.js","webpack://upmed-agendamento/./node_modules/@sentry/browser/esm/transports/utils.js","webpack://upmed-agendamento/./node_modules/@sentry/browser/esm/transports/fetch.js","webpack://upmed-agendamento/./node_modules/@sentry/browser/esm/transports/xhr.js","webpack://upmed-agendamento/./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","eventFromPlainObject","syntheticException","isUnhandledRejection","hub","client","getClient","normalizeDepth","getOptions","event","values","is","constructor","extra","__serialized__","normalize","eventFromError","stack","popSize","getPopSize","e","reactMinifiedRegexp","framesToPop","test","message","error","eventFromException","hint","attachStacktrace","eventFromUnknownInput","level","event_id","eventFromMessage","eventFromString","errorEvent","domException","tags","code","objectException","synthetic","input","ignoreOnError","shouldIgnoreOnError","ignoreNextOnError","setTimeout","wrap","fn","options","before","wrapper","__sentry_wrapped__","sentryWrapped","args","Array","prototype","slice","call","arguments","apply","this","wrappedArguments","map","arg","scope","addEventProcessor","mechanism","property","Object","hasOwnProperty","_oO","descriptor","getOwnPropertyDescriptor","configurable","defineProperty","get","MAX_ALLOWED_STRING_LENGTH","BREADCRUMB_INTEGRATION_ID","Breadcrumbs","static","id","__init","console","dom","fetch","history","sentry","xhr","setupOnce","_consoleBreadcrumb","_domBreadcrumb","_xhrBreadcrumb","_fetchBreadcrumb","_historyBreadcrumb","addSentryBreadcrumb","addBreadcrumb","category","_innerDomBreadcrumb","handlerData","target","keyAttrs","serializeAttribute","maxStringLength","__SENTRY_DEBUG__","global","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","_options","sendEvent","breadcrumbIntegration","getIntegrationById","_prepareEvent","platform","outcomes","_clearOutcomes","log","_dsn","envelope","tunnel","dsn","isRealNavigator","toString","hasSendBeacon","transportOptions","sendBeacon","_sendEnvelope","GlobalHandlers","__init2","_installFunc","onerror","_installGlobalOnErrorHandler","onunhandledrejection","_installGlobalOnUnhandledRejectionHandler","Error","stackTraceLimit","key","installFunc","globalHandlerLog","getHubAndOptions","getIntegration","msg","line","column","_eventFromIncompleteOnError","_enhanceEventWithInitialFrame","addMechanismAndCapture","reason","detail","_eventFromRejectionWithPrimitive","String","ERROR_TYPES_RE","groups","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","xmlHttpRequestProps","prop","wrapOptions","originalFunction","globalObject","proto","eventName","handleEvent","err","originalRemoveEventListener","wrappedEventHandler","originalEventHandler","DEFAULT_KEY","DEFAULT_LIMIT","LinkedErrors","_key","_limit","limit","self","_handler","parser","linkedErrors","_walkErrorTree","HttpContext","request","referrer","userAgent","headers","Referer","Dedupe","addGlobalEventProcessor","getCurrentHub","eventProcessor","currentEvent","_shouldDropEvent","_previousEvent","previousEvent","_isSameMessageEvent","_isSameExceptionEvent","currentMessage","previousMessage","_isSameFingerprint","_isSameStacktrace","previousException","_getExceptionFromEvent","currentException","currentFrames","_getFramesFromEvent","previousFrames","frameA","frameB","currentFingerprint","fingerprint","previousFingerprint","join","UNKNOWN_FUNCTION","CHROME_PRIORITY","WINJS_PRIORITY","GECKO_PRIORITY","createFrame","func","frame","abs_path","chromeRegex","chromeEvalRegex","chrome","parts","exec","isEval","indexOf","subMatch","extractSafariExtensionDetails","chromeStackLineParser","geckoREgex","geckoEvalRegex","gecko","geckoStackLineParser","winjsRegex","winjs","winjsStackLineParser","defaultStackLineParsers","defaultStackParser","isSafariExtension","isSafariWebExtension","split","cachedFetchImpl","getNativeFetchImplementation","document","fetchImpl","createElement","sandbox","hidden","head","appendChild","contentWindow","removeChild","bind","clearCachedFetchImplementation","makeFetchTransport","nativeFetch","makeRequest","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","startSessionTracking","startSessionOnHub","startSession","ignoreDuration","captureSession"],"sourceRoot":""}