{"version":3,"file":"1ff028afc8f2bf0671d7.bundle.js","mappings":"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","sources":["webpack://spartner/./node_modules/@sentry/browser/build/npm/esm/debug-build.js","webpack://spartner/./node_modules/@sentry/browser/build/npm/esm/eventbuilder.js","webpack://spartner/./node_modules/@sentry/browser/build/npm/esm/helpers.js","webpack://spartner/./node_modules/@sentry/browser/build/npm/esm/integrations/breadcrumbs.js","webpack://spartner/./node_modules/@sentry/browser/build/npm/esm/integrations/browserapierrors.js","webpack://spartner/./node_modules/@sentry/browser/build/npm/esm/integrations/globalhandlers.js","webpack://spartner/./node_modules/@sentry/browser/build/npm/esm/integrations/httpcontext.js","webpack://spartner/./node_modules/@sentry/browser/build/npm/esm/integrations/linkederrors.js","webpack://spartner/./node_modules/@sentry/browser/build/npm/esm/userfeedback.js","webpack://spartner/./node_modules/@sentry/browser/build/npm/esm/client.js","webpack://spartner/./node_modules/@sentry/browser/build/npm/esm/integrations/browsersession.js","webpack://spartner/./node_modules/@sentry/browser/build/npm/esm/sdk.js","webpack://spartner/./node_modules/@sentry/browser/build/npm/esm/stack-parsers.js","webpack://spartner/./node_modules/@sentry/browser/build/npm/esm/tracing/request.js","webpack://spartner/./node_modules/@sentry/browser/build/npm/esm/tracing/browserTracingIntegration.js","webpack://spartner/./node_modules/@sentry/browser/build/npm/esm/tracing/backgroundtab.js","webpack://spartner/./node_modules/@sentry/browser/build/npm/esm/transports/fetch.js"],"sourcesContent":["/**\n * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.\n *\n * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.\n */\nconst DEBUG_BUILD = (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__);\n\nexport { DEBUG_BUILD };\n//# sourceMappingURL=debug-build.js.map\n","import { addExceptionMechanism, resolvedSyncPromise, isErrorEvent, isDOMError, isDOMException, addExceptionTypeValue, isError, isPlainObject, isEvent, isParameterizedString, getClient, normalizeToSize, extractExceptionKeysForMessage } from '@sentry/core';\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: extractType(ex),\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\nfunction eventFromPlainObject(\n  stackParser,\n  exception,\n  syntheticException,\n  isUnhandledRejection,\n) {\n  const client = getClient();\n  const normalizeDepth = client && client.getOptions().normalizeDepth;\n\n  // If we can, we extract an exception from the object properties\n  const errorFromProp = getErrorPropertyFromObject(exception);\n\n  const extra = {\n    __serialized__: normalizeToSize(exception, normalizeDepth),\n  };\n\n  if (errorFromProp) {\n    return {\n      exception: {\n        values: [exceptionFromError(stackParser, errorFromProp)],\n      },\n      extra,\n    };\n  }\n\n  const event = {\n    exception: {\n      values: [\n        {\n          type: isEvent(exception) ? exception.constructor.name : isUnhandledRejection ? 'UnhandledRejection' : 'Error',\n          value: getNonErrorObjectExceptionValue(exception, { isUnhandledRejection }),\n        } ,\n      ],\n    },\n    extra,\n  } ;\n\n  if (syntheticException) {\n    const frames = parseStackFrames(stackParser, syntheticException);\n    if (frames.length) {\n      // event.exception.values[0] has been set above\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      event.exception.values[0].stacktrace = { frames };\n    }\n  }\n\n  return event;\n}\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 skipLines = getSkipFirstStackStringLines(ex);\n  const framesToPop = getPopFirstTopFrames(ex);\n\n  try {\n    return stackParser(stacktrace, skipLines, framesToPop);\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\n/**\n * Certain known React errors contain links that would be falsely\n * parsed as frames. This function check for these errors and\n * returns number of the stack string lines to skip.\n */\nfunction getSkipFirstStackStringLines(ex) {\n  if (ex && reactMinifiedRegexp.test(ex.message)) {\n    return 1;\n  }\n\n  return 0;\n}\n\n/**\n * If error has `framesToPop` property, it means that the\n * creator tells us the first x frames will be useless\n * and should be discarded. Typically error from wrapper function\n * which don't point to the actual location in the developer's code.\n *\n * Example: https://github.com/zertosh/invariant/blob/master/invariant.js#L46\n */\nfunction getPopFirstTopFrames(ex) {\n  if (typeof ex.framesToPop === 'number') {\n    return ex.framesToPop;\n  }\n\n  return 0;\n}\n\n// https://developer.mozilla.org/en-US/docs/WebAssembly/JavaScript_interface/Exception\n// @ts-expect-error - WebAssembly.Exception is a valid class\nfunction isWebAssemblyException(exception) {\n  // Check for support\n  // @ts-expect-error - WebAssembly.Exception is a valid class\n  if (typeof WebAssembly !== 'undefined' && typeof WebAssembly.Exception !== 'undefined') {\n    // @ts-expect-error - WebAssembly.Exception is a valid class\n    return exception instanceof WebAssembly.Exception;\n  } else {\n    return false;\n  }\n}\n\n/**\n * Extracts from errors what we use as the exception `type` in error events.\n *\n * Usually, this is the `name` property on Error objects but WASM errors need to be treated differently.\n */\nfunction extractType(ex) {\n  const name = ex && ex.name;\n\n  // The name for WebAssembly.Exception Errors needs to be extracted differently.\n  // Context: https://github.com/getsentry/sentry-javascript/issues/13787\n  if (!name && isWebAssemblyException(ex)) {\n    // Emscripten sets array[type, message] to the \"message\" property on the WebAssembly.Exception object\n    const hasTypeInMessage = ex.message && Array.isArray(ex.message) && ex.message.length == 2;\n    return hasTypeInMessage ? ex.message[0] : 'WebAssembly.Exception';\n  }\n\n  return name;\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\n  if (!message) {\n    return 'No error message';\n  }\n\n  if (message.error && typeof message.error.message === 'string') {\n    return message.error.message;\n  }\n\n  // Emscripten sets array[type, message] to the \"message\" property on the WebAssembly.Exception object\n  if (isWebAssemblyException(ex) && Array.isArray(ex.message) && ex.message.length == 2) {\n    return ex.message[1];\n  }\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  level = 'info',\n  hint,\n  attachStacktrace,\n) {\n  const syntheticException = (hint && hint.syntheticException) || undefined;\n  const event = eventFromString(stackParser, message, syntheticException, attachStacktrace);\n  event.level = level;\n  if (hint && hint.event_id) {\n    event.event_id = hint.event_id;\n  }\n  return resolvedSyncPromise(event);\n}\n\n/**\n * @hidden\n */\nfunction eventFromUnknownInput(\n  stackParser,\n  exception,\n  syntheticException,\n  attachStacktrace,\n  isUnhandledRejection,\n) {\n  let event;\n\n  if (isErrorEvent(exception ) && (exception ).error) {\n    // If it is an ErrorEvent with `error` property, extract it to get actual Error\n    const errorEvent = exception ;\n    return eventFromError(stackParser, errorEvent.error );\n  }\n\n  // If it is a `DOMError` (which is a legacy API, but still supported in some browsers) then we just extract the name\n  // and message, as it doesn't provide anything else. According to the spec, all `DOMExceptions` should also be\n  // `Error`s, but that's not the case in IE11, so in that case we treat it the same as we do a `DOMError`.\n  //\n  // https://developer.mozilla.org/en-US/docs/Web/API/DOMError\n  // https://developer.mozilla.org/en-US/docs/Web/API/DOMException\n  // https://webidl.spec.whatwg.org/#es-DOMException-specialness\n  if (isDOMError(exception) || isDOMException(exception )) {\n    const domException = exception ;\n\n    if ('stack' in (exception )) {\n      event = eventFromError(stackParser, exception );\n    } else {\n      const name = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException');\n      const message = domException.message ? `${name}: ${domException.message}` : name;\n      event = eventFromString(stackParser, message, syntheticException, attachStacktrace);\n      addExceptionTypeValue(event, message);\n    }\n    if ('code' in domException) {\n      // eslint-disable-next-line deprecation/deprecation\n      event.tags = { ...event.tags, 'DOMException.code': `${domException.code}` };\n    }\n\n    return event;\n  }\n  if (isError(exception)) {\n    // we have a real Error object, do nothing\n    return eventFromError(stackParser, exception);\n  }\n  if (isPlainObject(exception) || isEvent(exception)) {\n    // If it's a plain object or an instance of `Event` (the built-in JS kind, not this SDK's `Event` type), serialize\n    // it manually. This will allow us to group events based on top-level keys which is much better than creating a new\n    // group on any key/value change.\n    const objectException = exception ;\n    event = eventFromPlainObject(stackParser, objectException, syntheticException, isUnhandledRejection);\n    addExceptionMechanism(event, {\n      synthetic: true,\n    });\n    return event;\n  }\n\n  // If none of previous checks were valid, then it means that it's not:\n  // - an instance of DOMError\n  // - an instance of DOMException\n  // - an instance of Event\n  // - an instance of Error\n  // - a valid ErrorEvent (one with an error property)\n  // - a plain Object\n  //\n  // So bail out and capture it as a simple message:\n  event = eventFromString(stackParser, exception , syntheticException, attachStacktrace);\n  addExceptionTypeValue(event, `${exception}`, undefined);\n  addExceptionMechanism(event, {\n    synthetic: true,\n  });\n\n  return event;\n}\n\nfunction eventFromString(\n  stackParser,\n  message,\n  syntheticException,\n  attachStacktrace,\n) {\n  const event = {};\n\n  if (attachStacktrace && syntheticException) {\n    const frames = parseStackFrames(stackParser, syntheticException);\n    if (frames.length) {\n      event.exception = {\n        values: [{ value: message, stacktrace: { frames } }],\n      };\n    }\n    addExceptionMechanism(event, { synthetic: true });\n  }\n\n  if (isParameterizedString(message)) {\n    const { __sentry_template_string__, __sentry_template_values__ } = message;\n\n    event.logentry = {\n      message: __sentry_template_string__,\n      params: __sentry_template_values__,\n    };\n    return event;\n  }\n\n  event.message = message;\n  return event;\n}\n\nfunction getNonErrorObjectExceptionValue(\n  exception,\n  { isUnhandledRejection },\n) {\n  const keys = extractExceptionKeysForMessage(exception);\n  const captureType = isUnhandledRejection ? 'promise rejection' : 'exception';\n\n  // Some ErrorEvent instances do not have an `error` property, which is why they are not handled before\n  // We still want to try to get a decent message for these cases\n  if (isErrorEvent(exception)) {\n    return `Event \\`ErrorEvent\\` captured as ${captureType} with message \\`${exception.message}\\``;\n  }\n\n  if (isEvent(exception)) {\n    const className = getObjectClassName(exception);\n    return `Event \\`${className}\\` (type=${exception.type}) captured as ${captureType}`;\n  }\n\n  return `Object captured as ${captureType} with keys: ${keys}`;\n}\n\nfunction getObjectClassName(obj) {\n  try {\n    const prototype = Object.getPrototypeOf(obj);\n    return prototype ? prototype.constructor.name : undefined;\n  } catch (e) {\n    // ignore errors here\n  }\n}\n\n/** If a plain object has a property that is an `Error`, return this error. */\nfunction getErrorPropertyFromObject(obj) {\n  for (const prop in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, prop)) {\n      const value = obj[prop];\n      if (value instanceof Error) {\n        return value;\n      }\n    }\n  }\n\n  return undefined;\n}\n\nexport { eventFromException, eventFromMessage, eventFromUnknownInput, exceptionFromError, extractMessage, extractType };\n//# sourceMappingURL=eventbuilder.js.map\n","import { GLOBAL_OBJ, getOriginalFunction, markFunctionWrapped, addNonEnumerableProperty, withScope, addExceptionTypeValue, addExceptionMechanism, captureException } from '@sentry/core';\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// eslint-disable-next-line @typescript-eslint/ban-types\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) {\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  function isFunction(fn) {\n    return typeof fn === 'function';\n  }\n\n  if (!isFunction(fn)) {\n    return fn;\n  }\n\n  try {\n    // if we're dealing with a function that was previously wrapped, return\n    // the original wrapper.\n    const wrapper = (fn ).__sentry_wrapped__;\n    if (wrapper) {\n      if (typeof wrapper === 'function') {\n        return wrapper;\n      } else {\n        // If we find that the `__sentry_wrapped__` function is not a function at the time of accessing it, it means\n        // that something messed with it. In that case we want to return the originally passed function.\n        return fn;\n      }\n    }\n\n    // We don't wanna wrap it twice\n    if (getOriginalFunction(fn)) {\n      return fn;\n    }\n  } catch (e) {\n    // Just accessing custom props in some Selenium environments\n    // can cause a \"Permission denied\" exception (see raven-js#495).\n    // Bail on wrapping and return the function as-is (defers to window.onerror).\n    return fn;\n  }\n\n  // Wrap the function itself\n  // It is important that `sentryWrapped` is not an arrow function to preserve the context of `this`\n  const sentryWrapped = function ( ...args) {\n    try {\n      // Also wrap arguments that are themselves functions\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\n  // Wrap the wrapped function in a proxy, to ensure any other properties of the original function remain available\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 (e2) {\n    // Accessing some objects may throw\n    // ref: https://github.com/getsentry/sentry-javascript/issues/1168\n  }\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    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\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  } catch (e3) {\n    // This may throw if e.g. the descriptor does not exist, or a browser does not allow redefining `name`.\n    // to save some bytes we simply try-catch this\n  }\n\n  return sentryWrapped;\n}\n\nexport { WINDOW, ignoreNextOnError, shouldIgnoreOnError, wrap };\n//# sourceMappingURL=helpers.js.map\n","import { addClickKeypressInstrumentationHandler, addXhrInstrumentationHandler, addHistoryInstrumentationHandler, SENTRY_XHR_DATA_KEY } from '@sentry-internal/browser-utils';\nimport { defineIntegration, addConsoleInstrumentationHandler, addFetchInstrumentationHandler, getClient, addBreadcrumb, getEventDescription, logger, htmlTreeAsString, getComponentName, severityLevelFromString, safeJoin, getBreadcrumbLogLevelFromHttpStatusCode, parseUrl } from '@sentry/core';\nimport { DEBUG_BUILD } from '../debug-build.js';\nimport { WINDOW } from '../helpers.js';\n\n/* eslint-disable max-lines */\n\n\n/** maxStringLength gets capped to prevent 100 breadcrumbs exceeding 1MB event payload size */\nconst MAX_ALLOWED_STRING_LENGTH = 1024;\n\nconst INTEGRATION_NAME = 'Breadcrumbs';\n\nconst _breadcrumbsIntegration = ((options = {}) => {\n  const _options = {\n    console: true,\n    dom: true,\n    fetch: true,\n    history: true,\n    sentry: true,\n    xhr: true,\n    ...options,\n  };\n\n  return {\n    name: INTEGRATION_NAME,\n    setup(client) {\n      if (_options.console) {\n        addConsoleInstrumentationHandler(_getConsoleBreadcrumbHandler(client));\n      }\n      if (_options.dom) {\n        addClickKeypressInstrumentationHandler(_getDomBreadcrumbHandler(client, _options.dom));\n      }\n      if (_options.xhr) {\n        addXhrInstrumentationHandler(_getXhrBreadcrumbHandler(client));\n      }\n      if (_options.fetch) {\n        addFetchInstrumentationHandler(_getFetchBreadcrumbHandler(client));\n      }\n      if (_options.history) {\n        addHistoryInstrumentationHandler(_getHistoryBreadcrumbHandler(client));\n      }\n      if (_options.sentry) {\n        client.on('beforeSendEvent', _getSentryBreadcrumbHandler(client));\n      }\n    },\n  };\n}) ;\n\nconst breadcrumbsIntegration = defineIntegration(_breadcrumbsIntegration);\n\n/**\n * Adds a breadcrumb for Sentry events or transactions if this option is enabled.\n */\nfunction _getSentryBreadcrumbHandler(client) {\n  return function addSentryBreadcrumb(event) {\n    if (getClient() !== client) {\n      return;\n    }\n\n    addBreadcrumb(\n      {\n        category: `sentry.${event.type === 'transaction' ? 'transaction' : 'event'}`,\n        event_id: event.event_id,\n        level: event.level,\n        message: getEventDescription(event),\n      },\n      {\n        event,\n      },\n    );\n  };\n}\n\n/**\n * A HOC that creates a function that creates breadcrumbs from DOM API calls.\n * This is a HOC so that we get access to dom options in the closure.\n */\nfunction _getDomBreadcrumbHandler(\n  client,\n  dom,\n) {\n  return function _innerDomBreadcrumb(handlerData) {\n    if (getClient() !== client) {\n      return;\n    }\n\n    let target;\n    let componentName;\n    let keyAttrs = typeof dom === 'object' ? dom.serializeAttribute : undefined;\n\n    let maxStringLength =\n      typeof dom === 'object' && typeof dom.maxStringLength === 'number' ? dom.maxStringLength : undefined;\n    if (maxStringLength && maxStringLength > MAX_ALLOWED_STRING_LENGTH) {\n      DEBUG_BUILD &&\n        logger.warn(\n          `\\`dom.maxStringLength\\` cannot exceed ${MAX_ALLOWED_STRING_LENGTH}, but a value of ${maxStringLength} was configured. Sentry will use ${MAX_ALLOWED_STRING_LENGTH} instead.`,\n        );\n      maxStringLength = MAX_ALLOWED_STRING_LENGTH;\n    }\n\n    if (typeof keyAttrs === 'string') {\n      keyAttrs = [keyAttrs];\n    }\n\n    // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n    try {\n      const event = handlerData.event ;\n      const element = _isEvent(event) ? event.target : event;\n\n      target = htmlTreeAsString(element, { keyAttrs, maxStringLength });\n      componentName = getComponentName(element);\n    } catch (e) {\n      target = '<unknown>';\n    }\n\n    if (target.length === 0) {\n      return;\n    }\n\n    const breadcrumb = {\n      category: `ui.${handlerData.name}`,\n      message: target,\n    };\n\n    if (componentName) {\n      breadcrumb.data = { 'ui.component_name': componentName };\n    }\n\n    addBreadcrumb(breadcrumb, {\n      event: handlerData.event,\n      name: handlerData.name,\n      global: handlerData.global,\n    });\n  };\n}\n\n/**\n * Creates breadcrumbs from console API calls\n */\nfunction _getConsoleBreadcrumbHandler(client) {\n  return function _consoleBreadcrumb(handlerData) {\n    if (getClient() !== client) {\n      return;\n    }\n\n    const breadcrumb = {\n      category: 'console',\n      data: {\n        arguments: handlerData.args,\n        logger: 'console',\n      },\n      level: severityLevelFromString(handlerData.level),\n      message: safeJoin(handlerData.args, ' '),\n    };\n\n    if (handlerData.level === 'assert') {\n      if (handlerData.args[0] === false) {\n        breadcrumb.message = `Assertion failed: ${safeJoin(handlerData.args.slice(1), ' ') || 'console.assert'}`;\n        breadcrumb.data.arguments = handlerData.args.slice(1);\n      } else {\n        // Don't capture a breadcrumb for passed assertions\n        return;\n      }\n    }\n\n    addBreadcrumb(breadcrumb, {\n      input: handlerData.args,\n      level: handlerData.level,\n    });\n  };\n}\n\n/**\n * Creates breadcrumbs from XHR API calls\n */\nfunction _getXhrBreadcrumbHandler(client) {\n  return function _xhrBreadcrumb(handlerData) {\n    if (getClient() !== client) {\n      return;\n    }\n\n    const { startTimestamp, endTimestamp } = handlerData;\n\n    const sentryXhrData = handlerData.xhr[SENTRY_XHR_DATA_KEY];\n\n    // We only capture complete, non-sentry requests\n    if (!startTimestamp || !endTimestamp || !sentryXhrData) {\n      return;\n    }\n\n    const { method, url, status_code, body } = sentryXhrData;\n\n    const data = {\n      method,\n      url,\n      status_code,\n    };\n\n    const hint = {\n      xhr: handlerData.xhr,\n      input: body,\n      startTimestamp,\n      endTimestamp,\n    };\n\n    const level = getBreadcrumbLogLevelFromHttpStatusCode(status_code);\n\n    addBreadcrumb(\n      {\n        category: 'xhr',\n        data,\n        type: 'http',\n        level,\n      },\n      hint,\n    );\n  };\n}\n\n/**\n * Creates breadcrumbs from fetch API calls\n */\nfunction _getFetchBreadcrumbHandler(client) {\n  return function _fetchBreadcrumb(handlerData) {\n    if (getClient() !== client) {\n      return;\n    }\n\n    const { startTimestamp, endTimestamp } = handlerData;\n\n    // We only capture complete fetch requests\n    if (!endTimestamp) {\n      return;\n    }\n\n    if (handlerData.fetchData.url.match(/sentry_key/) && handlerData.fetchData.method === 'POST') {\n      // We will not create breadcrumbs for fetch requests that contain `sentry_key` (internal sentry requests)\n      return;\n    }\n\n    if (handlerData.error) {\n      const data = handlerData.fetchData;\n      const hint = {\n        data: handlerData.error,\n        input: handlerData.args,\n        startTimestamp,\n        endTimestamp,\n      };\n\n      addBreadcrumb(\n        {\n          category: 'fetch',\n          data,\n          level: 'error',\n          type: 'http',\n        },\n        hint,\n      );\n    } else {\n      const response = handlerData.response ;\n      const data = {\n        ...handlerData.fetchData,\n        status_code: response && response.status,\n      };\n      const hint = {\n        input: handlerData.args,\n        response,\n        startTimestamp,\n        endTimestamp,\n      };\n      const level = getBreadcrumbLogLevelFromHttpStatusCode(data.status_code);\n\n      addBreadcrumb(\n        {\n          category: 'fetch',\n          data,\n          type: 'http',\n          level,\n        },\n        hint,\n      );\n    }\n  };\n}\n\n/**\n * Creates breadcrumbs from history API calls\n */\nfunction _getHistoryBreadcrumbHandler(client) {\n  return function _historyBreadcrumb(handlerData) {\n    if (getClient() !== client) {\n      return;\n    }\n\n    let from = handlerData.from;\n    let to = handlerData.to;\n    const parsedLoc = parseUrl(WINDOW.location.href);\n    let parsedFrom = from ? parseUrl(from) : undefined;\n    const parsedTo = parseUrl(to);\n\n    // Initial pushState doesn't provide `from` information\n    if (!parsedFrom || !parsedFrom.path) {\n      parsedFrom = parsedLoc;\n    }\n\n    // Use only the path component of the URL if the URL matches the current\n    // document (almost all the time when using pushState)\n    if (parsedLoc.protocol === parsedTo.protocol && parsedLoc.host === parsedTo.host) {\n      to = parsedTo.relative;\n    }\n    if (parsedLoc.protocol === parsedFrom.protocol && parsedLoc.host === parsedFrom.host) {\n      from = parsedFrom.relative;\n    }\n\n    addBreadcrumb({\n      category: 'navigation',\n      data: {\n        from,\n        to,\n      },\n    });\n  };\n}\n\nfunction _isEvent(event) {\n  return !!event && !!(event ).target;\n}\n\nexport { breadcrumbsIntegration };\n//# sourceMappingURL=breadcrumbs.js.map\n","import { defineIntegration, fill, getFunctionName, getOriginalFunction } from '@sentry/core';\nimport { WINDOW, wrap } from '../helpers.js';\n\nconst DEFAULT_EVENT_TARGET = [\n  'EventTarget',\n  'Window',\n  'Node',\n  'ApplicationCache',\n  'AudioTrackList',\n  'BroadcastChannel',\n  'ChannelMergerNode',\n  'CryptoOperation',\n  'EventSource',\n  'FileReader',\n  'HTMLUnknownElement',\n  'IDBDatabase',\n  'IDBRequest',\n  'IDBTransaction',\n  'KeyOperation',\n  'MediaController',\n  'MessagePort',\n  'ModalWindow',\n  'Notification',\n  'SVGElementInstance',\n  'Screen',\n  'SharedWorker',\n  'TextTrack',\n  'TextTrackCue',\n  'TextTrackList',\n  'WebSocket',\n  'WebSocketWorker',\n  'Worker',\n  'XMLHttpRequest',\n  'XMLHttpRequestEventTarget',\n  'XMLHttpRequestUpload',\n];\n\nconst INTEGRATION_NAME = 'BrowserApiErrors';\n\nconst _browserApiErrorsIntegration = ((options = {}) => {\n  const _options = {\n    XMLHttpRequest: true,\n    eventTarget: true,\n    requestAnimationFrame: true,\n    setInterval: true,\n    setTimeout: true,\n    ...options,\n  };\n\n  return {\n    name: INTEGRATION_NAME,\n    // TODO: This currently only works for the first client this is setup\n    // We may want to adjust this to check for client etc.\n    setupOnce() {\n      if (_options.setTimeout) {\n        fill(WINDOW, 'setTimeout', _wrapTimeFunction);\n      }\n\n      if (_options.setInterval) {\n        fill(WINDOW, 'setInterval', _wrapTimeFunction);\n      }\n\n      if (_options.requestAnimationFrame) {\n        fill(WINDOW, 'requestAnimationFrame', _wrapRAF);\n      }\n\n      if (_options.XMLHttpRequest && 'XMLHttpRequest' in WINDOW) {\n        fill(XMLHttpRequest.prototype, 'send', _wrapXHR);\n      }\n\n      const eventTargetOption = _options.eventTarget;\n      if (eventTargetOption) {\n        const eventTarget = Array.isArray(eventTargetOption) ? eventTargetOption : DEFAULT_EVENT_TARGET;\n        eventTarget.forEach(_wrapEventTarget);\n      }\n    },\n  };\n}) ;\n\n/**\n * Wrap timer functions and event targets to catch errors and provide better meta data.\n */\nconst browserApiErrorsIntegration = defineIntegration(_browserApiErrorsIntegration);\n\nfunction _wrapTimeFunction(original) {\n  return function ( ...args) {\n    const originalCallback = args[0];\n    args[0] = wrap(originalCallback, {\n      mechanism: {\n        data: { function: getFunctionName(original) },\n        handled: false,\n        type: 'instrument',\n      },\n    });\n    return original.apply(this, args);\n  };\n}\n\nfunction _wrapRAF(original) {\n  return function ( callback) {\n    return original.apply(this, [\n      wrap(callback, {\n        mechanism: {\n          data: {\n            function: 'requestAnimationFrame',\n            handler: getFunctionName(original),\n          },\n          handled: false,\n          type: 'instrument',\n        },\n      }),\n    ]);\n  };\n}\n\nfunction _wrapXHR(originalSend) {\n  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        fill(xhr, prop, function (original) {\n          const wrapOptions = {\n            mechanism: {\n              data: {\n                function: prop,\n                handler: getFunctionName(original),\n              },\n              handled: false,\n              type: 'instrument',\n            },\n          };\n\n          // If Instrument integration has been called before BrowserApiErrors, get the name of original function\n          const originalFunction = getOriginalFunction(original);\n          if (originalFunction) {\n            wrapOptions.mechanism.data.handler = getFunctionName(originalFunction);\n          }\n\n          // Otherwise wrap directly\n          return wrap(original, wrapOptions);\n        });\n      }\n    });\n\n    return originalSend.apply(this, args);\n  };\n}\n\nfunction _wrapEventTarget(target) {\n  const globalObject = WINDOW ;\n  const targetObj = globalObject[target];\n  const proto = targetObj && targetObj.prototype;\n\n  // eslint-disable-next-line 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 ( eventName, fn, options) {\n      try {\n        if (isEventListenerObject(fn)) {\n          // ESlint disable explanation:\n          //  First, it is generally safe to call `wrap` with an unbound function. Furthermore, using `.bind()` would\n          //  introduce a bug here, because bind returns a new function that doesn't have our\n          //  flags(like __sentry_original__) attached. `wrap` checks for those flags to avoid unnecessary wrapping.\n          //  Without those flags, every call to addEventListener wraps the function again, causing a memory leak.\n          // eslint-disable-next-line @typescript-eslint/unbound-method\n          fn.handleEvent = wrap(fn.handleEvent, {\n            mechanism: {\n              data: {\n                function: 'handleEvent',\n                handler: getFunctionName(fn),\n                target,\n              },\n              handled: false,\n              type: 'instrument',\n            },\n          });\n        }\n      } catch (e2) {\n        // can sometimes get 'Permission denied to access property \"handle Event'\n      }\n\n      return original.apply(this, [\n        eventName,\n        wrap(fn, {\n          mechanism: {\n            data: {\n              function: 'addEventListener',\n              handler: getFunctionName(fn),\n              target,\n            },\n            handled: false,\n            type: 'instrument',\n          },\n        }),\n        options,\n      ]);\n    };\n  });\n\n  fill(proto, 'removeEventListener', function (originalRemoveEventListener)\n\n {\n    return function ( eventName, fn, options) {\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      try {\n        const originalEventHandler = (fn ).__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, fn, options);\n    };\n  });\n}\n\nfunction isEventListenerObject(obj) {\n  return typeof (obj ).handleEvent === 'function';\n}\n\nexport { browserApiErrorsIntegration };\n//# sourceMappingURL=browserapierrors.js.map\n","import { defineIntegration, addGlobalErrorInstrumentationHandler, getClient, captureEvent, addGlobalUnhandledRejectionInstrumentationHandler, isPrimitive, isString, getLocationHref, UNKNOWN_FUNCTION, logger } from '@sentry/core';\nimport { DEBUG_BUILD } from '../debug-build.js';\nimport { eventFromUnknownInput } from '../eventbuilder.js';\nimport { shouldIgnoreOnError } from '../helpers.js';\n\nconst INTEGRATION_NAME = 'GlobalHandlers';\n\nconst _globalHandlersIntegration = ((options = {}) => {\n  const _options = {\n    onerror: true,\n    onunhandledrejection: true,\n    ...options,\n  };\n\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      Error.stackTraceLimit = 50;\n    },\n    setup(client) {\n      if (_options.onerror) {\n        _installGlobalOnErrorHandler(client);\n        globalHandlerLog('onerror');\n      }\n      if (_options.onunhandledrejection) {\n        _installGlobalOnUnhandledRejectionHandler(client);\n        globalHandlerLog('onunhandledrejection');\n      }\n    },\n  };\n}) ;\n\nconst globalHandlersIntegration = defineIntegration(_globalHandlersIntegration);\n\nfunction _installGlobalOnErrorHandler(client) {\n  addGlobalErrorInstrumentationHandler(data => {\n    const { stackParser, attachStacktrace } = getOptions();\n\n    if (getClient() !== client || shouldIgnoreOnError()) {\n      return;\n    }\n\n    const { msg, url, line, column, error } = data;\n\n    const event = _enhanceEventWithInitialFrame(\n      eventFromUnknownInput(stackParser, error || msg, undefined, attachStacktrace, false),\n      url,\n      line,\n      column,\n    );\n\n    event.level = 'error';\n\n    captureEvent(event, {\n      originalException: error,\n      mechanism: {\n        handled: false,\n        type: 'onerror',\n      },\n    });\n  });\n}\n\nfunction _installGlobalOnUnhandledRejectionHandler(client) {\n  addGlobalUnhandledRejectionInstrumentationHandler(e => {\n    const { stackParser, attachStacktrace } = getOptions();\n\n    if (getClient() !== client || shouldIgnoreOnError()) {\n      return;\n    }\n\n    const error = _getUnhandledRejectionError(e );\n\n    const event = isPrimitive(error)\n      ? _eventFromRejectionWithPrimitive(error)\n      : eventFromUnknownInput(stackParser, error, undefined, attachStacktrace, true);\n\n    event.level = 'error';\n\n    captureEvent(event, {\n      originalException: error,\n      mechanism: {\n        handled: false,\n        type: 'onunhandledrejection',\n      },\n    });\n  });\n}\n\nfunction _getUnhandledRejectionError(error) {\n  if (isPrimitive(error)) {\n    return error;\n  }\n\n  // dig the object of the rejection out of known event types\n  try {\n\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 (error )) {\n      return (error ).reason;\n    }\n\n    // something, somewhere, (likely a browser extension) effectively casts PromiseRejectionEvents\n    // to CustomEvents, moving the `promise` and `reason` attributes of the PRE into\n    // the CustomEvent's `detail` attribute, since they're not part of CustomEvent's spec\n    // see https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent and\n    // https://github.com/getsentry/sentry-javascript/issues/2380\n    if ('detail' in (error ) && 'reason' in (error ).detail) {\n      return (error ).detail.reason;\n    }\n  } catch (e2) {} // eslint-disable-line no-empty\n\n  return error;\n}\n\n/**\n * Create an event from a promise rejection where the `reason` is a primitive.\n *\n * @param reason: The `reason` property of the promise rejection\n * @returns An Event object with an appropriate `exception` value\n */\nfunction _eventFromRejectionWithPrimitive(reason) {\n  return {\n    exception: {\n      values: [\n        {\n          type: 'UnhandledRejection',\n          // String() is needed because the Primitive type includes symbols (which can't be automatically stringified)\n          value: `Non-Error promise rejection captured with value: ${String(reason)}`,\n        },\n      ],\n    },\n  };\n}\n\nfunction _enhanceEventWithInitialFrame(\n  event,\n  url,\n  line,\n  column,\n) {\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 = column;\n  const lineno = 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: UNKNOWN_FUNCTION,\n      in_app: true,\n      lineno,\n    });\n  }\n\n  return event;\n}\n\nfunction globalHandlerLog(type) {\n  DEBUG_BUILD && logger.log(`Global Handler attached: ${type}`);\n}\n\nfunction getOptions() {\n  const client = getClient();\n  const options = (client && client.getOptions()) || {\n    stackParser: () => [],\n    attachStacktrace: false,\n  };\n  return options;\n}\n\nexport { globalHandlersIntegration };\n//# sourceMappingURL=globalhandlers.js.map\n","import { defineIntegration } from '@sentry/core';\nimport { WINDOW } from '../helpers.js';\n\n/**\n * Collects information about HTTP request headers and\n * attaches them to the event.\n */\nconst httpContextIntegration = defineIntegration(() => {\n  return {\n    name: 'HttpContext',\n    preprocessEvent(event) {\n      // if none of the information we want exists, don't bother\n      if (!WINDOW.navigator && !WINDOW.location && !WINDOW.document) {\n        return;\n      }\n\n      // grab as much info as exists and add it to the event\n      const url = (event.request && event.request.url) || (WINDOW.location && WINDOW.location.href);\n      const { referrer } = WINDOW.document || {};\n      const { userAgent } = WINDOW.navigator || {};\n\n      const headers = {\n        ...(event.request && event.request.headers),\n        ...(referrer && { Referer: referrer }),\n        ...(userAgent && { 'User-Agent': userAgent }),\n      };\n      const request = { ...event.request, ...(url && { url }), headers };\n\n      event.request = request;\n    },\n  };\n});\n\nexport { httpContextIntegration };\n//# sourceMappingURL=httpcontext.js.map\n","import { defineIntegration, applyAggregateErrorsToEvent } from '@sentry/core';\nimport { exceptionFromError } from '../eventbuilder.js';\n\nconst DEFAULT_KEY = 'cause';\nconst DEFAULT_LIMIT = 5;\n\nconst INTEGRATION_NAME = 'LinkedErrors';\n\nconst _linkedErrorsIntegration = ((options = {}) => {\n  const limit = options.limit || DEFAULT_LIMIT;\n  const key = options.key || DEFAULT_KEY;\n\n  return {\n    name: INTEGRATION_NAME,\n    preprocessEvent(event, hint, client) {\n      const options = client.getOptions();\n\n      applyAggregateErrorsToEvent(\n        // This differs from the LinkedErrors integration in core by using a different exceptionFromError function\n        exceptionFromError,\n        options.stackParser,\n        options.maxValueLength,\n        key,\n        limit,\n        event,\n        hint,\n      );\n    },\n  };\n}) ;\n\n/**\n * Aggregrate linked errors in an event.\n */\nconst linkedErrorsIntegration = defineIntegration(_linkedErrorsIntegration);\n\nexport { linkedErrorsIntegration };\n//# sourceMappingURL=linkederrors.js.map\n","import { dsnToString, createEnvelope } from '@sentry/core';\n\n/**\n * Creates an envelope from a user feedback.\n */\nfunction createUserFeedbackEnvelope(\n  feedback,\n  {\n    metadata,\n    tunnel,\n    dsn,\n  }\n\n,\n) {\n  const headers = {\n    event_id: feedback.event_id,\n    sent_at: new Date().toISOString(),\n    ...(metadata &&\n      metadata.sdk && {\n        sdk: {\n          name: metadata.sdk.name,\n          version: metadata.sdk.version,\n        },\n      }),\n    ...(!!tunnel && !!dsn && { dsn: dsnToString(dsn) }),\n  };\n  const item = createUserFeedbackEnvelopeItem(feedback);\n\n  return createEnvelope(headers, [item]);\n}\n\nfunction createUserFeedbackEnvelopeItem(feedback) {\n  const feedbackHeaders = {\n    type: 'user_report',\n  };\n  return [feedbackHeaders, feedback];\n}\n\nexport { createUserFeedbackEnvelope };\n//# sourceMappingURL=userfeedback.js.map\n","import { BaseClient, getSDKSource, applySdkMetadata, logger } from '@sentry/core';\nimport { DEBUG_BUILD } from './debug-build.js';\nimport { eventFromException, eventFromMessage } from './eventbuilder.js';\nimport { WINDOW } from './helpers.js';\nimport { createUserFeedbackEnvelope } from './userfeedback.js';\n\n/**\n * Configuration options for the Sentry Browser SDK.\n * @see @sentry/core 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 opts = {\n      // We default this to true, as it is the safer scenario\n      parentSpanIsAlwaysRootSpan: true,\n      ...options,\n    };\n    const sdkSource = WINDOW.SENTRY_SDK_SOURCE || getSDKSource();\n    applySdkMetadata(opts, 'browser', ['browser'], sdkSource);\n\n    super(opts);\n\n    if (opts.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    level = 'info',\n    hint,\n  ) {\n    return eventFromMessage(this._options.stackParser, message, level, hint, this._options.attachStacktrace);\n  }\n\n  /**\n   * Sends user feedback to Sentry.\n   *\n   * @deprecated Use `captureFeedback` instead.\n   */\n   captureUserFeedback(feedback) {\n    if (!this._isEnabled()) {\n      DEBUG_BUILD && logger.warn('SDK not enabled, will not capture user feedback.');\n      return;\n    }\n\n    const envelope = createUserFeedbackEnvelope(feedback, {\n      metadata: this.getSdkMetadata(),\n      dsn: this.getDsn(),\n      tunnel: this.getOptions().tunnel,\n    });\n\n    // sendEnvelope should not throw\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    this.sendEnvelope(envelope);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   _prepareEvent(event, hint, scope) {\n    event.platform = event.platform || 'javascript';\n    return super._prepareEvent(event, hint, scope);\n  }\n}\n\nexport { BrowserClient };\n//# sourceMappingURL=client.js.map\n","import { addHistoryInstrumentationHandler } from '@sentry-internal/browser-utils';\nimport { defineIntegration, logger, startSession, captureSession } from '@sentry/core';\nimport { DEBUG_BUILD } from '../debug-build.js';\nimport { WINDOW } from '../helpers.js';\n\n/**\n * When added, automatically creates sessions which allow you to track adoption and crashes (crash free rate) in your Releases in Sentry.\n * More information: https://docs.sentry.io/product/releases/health/\n *\n * Note: In order for session tracking to work, you need to set up Releases: https://docs.sentry.io/product/releases/\n */\nconst browserSessionIntegration = defineIntegration(() => {\n  return {\n    name: 'BrowserSession',\n    setupOnce() {\n      if (typeof WINDOW.document === 'undefined') {\n        DEBUG_BUILD &&\n          logger.warn('Using the `browserSessionIntegration` in non-browser environments is not supported.');\n        return;\n      }\n\n      // The session duration for browser sessions does not track a meaningful\n      // concept that can be used as a metric.\n      // Automatically captured sessions are akin to page views, and thus we\n      // discard their duration.\n      startSession({ ignoreDuration: true });\n      captureSession();\n\n      // We want to create a session for every navigation as well\n      addHistoryInstrumentationHandler(({ from, to }) => {\n        // Don't create an additional session for the initial route or if the location did not change\n        if (from !== undefined && from !== to) {\n          startSession({ ignoreDuration: true });\n          captureSession();\n        }\n      });\n    },\n  };\n});\n\nexport { browserSessionIntegration };\n//# sourceMappingURL=browsersession.js.map\n","import { inboundFiltersIntegration, functionToStringIntegration, dedupeIntegration, consoleSandbox, supportsFetch, logger, stackParserFromStackParserOptions, getIntegrationsToSetup, initAndBind, getCurrentScope, lastEventId, getReportDialogEndpoint, getClient } from '@sentry/core';\nimport { BrowserClient } from './client.js';\nimport { DEBUG_BUILD } from './debug-build.js';\nimport { WINDOW } from './helpers.js';\nimport { breadcrumbsIntegration } from './integrations/breadcrumbs.js';\nimport { browserApiErrorsIntegration } from './integrations/browserapierrors.js';\nimport { browserSessionIntegration } from './integrations/browsersession.js';\nimport { globalHandlersIntegration } from './integrations/globalhandlers.js';\nimport { httpContextIntegration } from './integrations/httpcontext.js';\nimport { linkedErrorsIntegration } from './integrations/linkederrors.js';\nimport { defaultStackParser } from './stack-parsers.js';\nimport { makeFetchTransport } from './transports/fetch.js';\n\n/** Get the default integrations for the browser SDK. */\nfunction getDefaultIntegrations(options) {\n  /**\n   * Note: Please make sure this stays in sync with Angular SDK, which re-exports\n   * `getDefaultIntegrations` but with an adjusted set of integrations.\n   */\n  const integrations = [\n    inboundFiltersIntegration(),\n    functionToStringIntegration(),\n    browserApiErrorsIntegration(),\n    breadcrumbsIntegration(),\n    globalHandlersIntegration(),\n    linkedErrorsIntegration(),\n    dedupeIntegration(),\n    httpContextIntegration(),\n  ];\n\n  // eslint-disable-next-line deprecation/deprecation\n  if (options.autoSessionTracking !== false) {\n    integrations.push(browserSessionIntegration());\n  }\n\n  return integrations;\n}\n\nfunction applyDefaultOptions(optionsArg = {}) {\n  const defaultOptions = {\n    defaultIntegrations: getDefaultIntegrations(optionsArg),\n    release:\n      typeof __SENTRY_RELEASE__ === 'string' // This allows build tooling to find-and-replace __SENTRY_RELEASE__ to inject a release value\n        ? __SENTRY_RELEASE__\n        : WINDOW.SENTRY_RELEASE && WINDOW.SENTRY_RELEASE.id // This supports the variable that sentry-webpack-plugin injects\n          ? WINDOW.SENTRY_RELEASE.id\n          : undefined,\n    autoSessionTracking: true,\n    sendClientReports: true,\n  };\n\n  // TODO: Instead of dropping just `defaultIntegrations`, we should simply\n  // call `dropUndefinedKeys` on the entire `optionsArg`.\n  // However, for this to work we need to adjust the `hasTracingEnabled()` logic\n  // first as it differentiates between `undefined` and the key not being in the object.\n  if (optionsArg.defaultIntegrations == null) {\n    delete optionsArg.defaultIntegrations;\n  }\n\n  return { ...defaultOptions, ...optionsArg };\n}\n\nfunction shouldShowBrowserExtensionError() {\n  const windowWithMaybeExtension =\n    typeof WINDOW.window !== 'undefined' && (WINDOW );\n  if (!windowWithMaybeExtension) {\n    // No need to show the error if we're not in a browser window environment (e.g. service workers)\n    return false;\n  }\n\n  const extensionKey = windowWithMaybeExtension.chrome ? 'chrome' : 'browser';\n  const extensionObject = windowWithMaybeExtension[extensionKey];\n\n  const runtimeId = extensionObject && extensionObject.runtime && extensionObject.runtime.id;\n  const href = (WINDOW.location && WINDOW.location.href) || '';\n\n  const extensionProtocols = ['chrome-extension:', 'moz-extension:', 'ms-browser-extension:', 'safari-web-extension:'];\n\n  // Running the SDK in a dedicated extension page and calling Sentry.init is fine; no risk of data leakage\n  const isDedicatedExtensionPage =\n    !!runtimeId && WINDOW === WINDOW.top && extensionProtocols.some(protocol => href.startsWith(`${protocol}//`));\n\n  // Running the SDK in NW.js, which appears like a browser extension but isn't, is also fine\n  // see: https://github.com/getsentry/sentry-javascript/issues/12668\n  const isNWjs = typeof windowWithMaybeExtension.nw !== 'undefined';\n\n  return !!runtimeId && !isDedicatedExtensionPage && !isNWjs;\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 { 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(browserOptions = {}) {\n  const options = applyDefaultOptions(browserOptions);\n\n  if (!options.skipBrowserExtensionCheck && shouldShowBrowserExtensionError()) {\n    consoleSandbox(() => {\n      // eslint-disable-next-line no-console\n      console.error(\n        '[Sentry] You cannot run Sentry this way in a browser extension, check: https://docs.sentry.io/platforms/javascript/best-practices/browser-extensions/',\n      );\n    });\n    return;\n  }\n\n  if (DEBUG_BUILD) {\n    if (!supportsFetch()) {\n      logger.warn(\n        'No Fetch API detected. The Sentry SDK requires a Fetch API compatible environment to send events. Please add a Fetch API polyfill.',\n      );\n    }\n  }\n  const clientOptions = {\n    ...options,\n    stackParser: stackParserFromStackParserOptions(options.stackParser || defaultStackParser),\n    integrations: getIntegrationsToSetup(options),\n    transport: options.transport || makeFetchTransport,\n  };\n\n  return initAndBind(BrowserClient, clientOptions);\n}\n\n/**\n * All properties the report dialog supports\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 = {}) {\n  // doesn't work without a document (React Native)\n  if (!WINDOW.document) {\n    DEBUG_BUILD && logger.error('Global document not defined in showReportDialog call');\n    return;\n  }\n\n  const scope = getCurrentScope();\n  const client = scope.getClient();\n  const dsn = client && client.getDsn();\n\n  if (!dsn) {\n    DEBUG_BUILD && logger.error('DSN not configured for showReportDialog call');\n    return;\n  }\n\n  if (scope) {\n    options.user = {\n      ...scope.getUser(),\n      ...options.user,\n    };\n  }\n\n  if (!options.eventId) {\n    const eventId = lastEventId();\n    if (eventId) {\n      options.eventId = eventId;\n    }\n  }\n\n  const script = WINDOW.document.createElement('script');\n  script.async = true;\n  script.crossOrigin = 'anonymous';\n  script.src = getReportDialogEndpoint(dsn, options);\n\n  if (options.onLoad) {\n    script.onload = options.onLoad;\n  }\n\n  const { onClose } = options;\n  if (onClose) {\n    const reportDialogClosedMessageHandler = (event) => {\n      if (event.data === '__sentry_reportdialog_closed__') {\n        try {\n          onClose();\n        } finally {\n          WINDOW.removeEventListener('message', reportDialogClosedMessageHandler);\n        }\n      }\n    };\n    WINDOW.addEventListener('message', reportDialogClosedMessageHandler);\n  }\n\n  const injectionPoint = WINDOW.document.head || WINDOW.document.body;\n  if (injectionPoint) {\n    injectionPoint.appendChild(script);\n  } else {\n    DEBUG_BUILD && logger.error('Not injecting report dialog. No injection point found in HTML');\n  }\n}\n\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nfunction forceLoad() {\n  // Noop\n}\n\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nfunction onLoad(callback) {\n  callback();\n}\n\n/**\n * Captures user feedback and sends it to Sentry.\n *\n * @deprecated Use `captureFeedback` instead.\n */\nfunction captureUserFeedback(feedback) {\n  const client = getClient();\n  if (client) {\n    // eslint-disable-next-line deprecation/deprecation\n    client.captureUserFeedback(feedback);\n  }\n}\n\nexport { captureUserFeedback, forceLoad, getDefaultIntegrations, init, onLoad, showReportDialog };\n//# sourceMappingURL=sdk.js.map\n","import { createStackParser, UNKNOWN_FUNCTION } from '@sentry/core';\n\n// This was originally forked from https://github.com/csnover/TraceKit, and was largely\n// re - written as part of raven - js.\n//\n// This code was later copied to the JavaScript mono - repo and further modified and\n// refactored over the years.\n\n\nconst OPERA10_PRIORITY = 10;\nconst OPERA11_PRIORITY = 20;\nconst CHROME_PRIORITY = 30;\nconst WINJS_PRIORITY = 40;\nconst GECKO_PRIORITY = 50;\n\nfunction createFrame(filename, func, lineno, colno) {\n  const frame = {\n    filename,\n    function: func === '<anonymous>' ? UNKNOWN_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// This regex matches frames that have no function name (ie. are at the top level of a module).\n// For example \"at http://localhost:5000//script.js:1:126\"\n// Frames _with_ function names usually look as follows: \"at commitLayoutEffects (react-dom.development.js:23426:1)\"\nconst chromeRegexNoFnName = /^\\s*at (\\S+?)(?::(\\d+))(?::(\\d+))\\s*$/i;\n\n// This regex matches all the frames that have a function name.\nconst chromeRegex =\n  /^\\s*at (?:(.+?\\)(?: \\[.+\\])?|.*?) ?\\((?:address at )?)?(?:async )?((?:<anonymous>|[-a-z]+:|.*bundle|\\/)?.*?)(?::(\\d+))?(?::(\\d+))?\\)?\\s*$/i;\n\nconst chromeEvalRegex = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/;\n\n// Chromium based browsers: Chrome, Brave, new Opera, new Edge\n// We cannot call this variable `chrome` because it can conflict with global `chrome` variable in certain environments\n// See: https://github.com/getsentry/sentry-javascript/issues/6880\nconst chromeStackParserFn = line => {\n  // If the stack line has no function name, we need to parse it differently\n  const noFnParts = chromeRegexNoFnName.exec(line) ;\n\n  if (noFnParts) {\n    const [, filename, line, col] = noFnParts;\n    return createFrame(filename, UNKNOWN_FUNCTION, +line, +col);\n  }\n\n  const parts = chromeRegex.exec(line) ;\n\n  if (parts) {\n    const isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n\n    if (isEval) {\n      const subMatch = chromeEvalRegex.exec(parts[2]) ;\n\n      if (subMatch) {\n        // throw out eval line/column and use top-most line/column number\n        parts[2] = subMatch[1]; // url\n        parts[3] = subMatch[2]; // line\n        parts[4] = subMatch[3]; // column\n      }\n    }\n\n    // Kamil: One more hack won't hurt us right? Understanding and adding more rules on top of these regexps right now\n    // would be way too time consuming. (TODO: Rewrite whole RegExp to be more readable)\n    const [func, filename] = extractSafariExtensionDetails(parts[1] || UNKNOWN_FUNCTION, parts[2]);\n\n    return createFrame(filename, func, parts[3] ? +parts[3] : undefined, parts[4] ? +parts[4] : undefined);\n  }\n\n  return;\n};\n\nconst chromeStackLineParser = [CHROME_PRIORITY, chromeStackParserFn];\n\n// gecko regex: `(?:bundle|\\d+\\.js)`: `bundle` is for react native, `\\d+\\.js` also but specifically for ram bundles because it\n// generates filenames without a prefix like `file://` the filenames in the stacktrace are just 42.js\n// We need this specific case for now because we want no other regex to match.\nconst geckoREgex =\n  /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)?((?:[-a-z]+)?:\\/.*?|\\[native code\\]|[^@]*(?:bundle|\\d+\\.js)|\\/[\\w\\-. /=]+)(?::(\\d+))?(?::(\\d+))?\\s*$/i;\nconst geckoEvalRegex = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\n\nconst gecko = line => {\n  const parts = geckoREgex.exec(line) ;\n\n  if (parts) {\n    const isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n    if (isEval) {\n      const subMatch = geckoEvalRegex.exec(parts[3]) ;\n\n      if (subMatch) {\n        // throw out eval line/column and use top-most line number\n        parts[1] = parts[1] || 'eval';\n        parts[3] = subMatch[1];\n        parts[4] = subMatch[2];\n        parts[5] = ''; // no column when eval\n      }\n    }\n\n    let filename = parts[3];\n    let func = parts[1] || UNKNOWN_FUNCTION;\n    [func, filename] = extractSafariExtensionDetails(func, filename);\n\n    return createFrame(filename, func, parts[4] ? +parts[4] : undefined, parts[5] ? +parts[5] : undefined);\n  }\n\n  return;\n};\n\nconst geckoStackLineParser = [GECKO_PRIORITY, gecko];\n\nconst winjsRegex = /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:[-a-z]+):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i;\n\nconst winjs = line => {\n  const parts = winjsRegex.exec(line) ;\n\n  return parts\n    ? createFrame(parts[2], parts[1] || UNKNOWN_FUNCTION, +parts[3], parts[4] ? +parts[4] : undefined)\n    : undefined;\n};\n\nconst winjsStackLineParser = [WINJS_PRIORITY, winjs];\n\nconst opera10Regex = / line (\\d+).*script (?:in )?(\\S+)(?:: in function (\\S+))?$/i;\n\nconst opera10 = line => {\n  const parts = opera10Regex.exec(line) ;\n  return parts ? createFrame(parts[2], parts[3] || UNKNOWN_FUNCTION, +parts[1]) : undefined;\n};\n\nconst opera10StackLineParser = [OPERA10_PRIORITY, opera10];\n\nconst opera11Regex =\n  / line (\\d+), column (\\d+)\\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\\(.*\\))? in (.*):\\s*$/i;\n\nconst opera11 = line => {\n  const parts = opera11Regex.exec(line) ;\n  return parts ? createFrame(parts[5], parts[3] || parts[4] || UNKNOWN_FUNCTION, +parts[1], +parts[2]) : undefined;\n};\n\nconst opera11StackLineParser = [OPERA11_PRIORITY, opera11];\n\nconst defaultStackLineParsers = [chromeStackLineParser, geckoStackLineParser];\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 { addXhrInstrumentationHandler, addPerformanceInstrumentationHandler, SENTRY_XHR_DATA_KEY } from '@sentry-internal/browser-utils';\nimport { addFetchEndInstrumentationHandler, addFetchInstrumentationHandler, instrumentFetchRequest, parseUrl, spanToJSON, browserPerformanceTimeOrigin, hasTracingEnabled, setHttpStatus, getActiveSpan, startInactiveSpan, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_OP, SentryNonRecordingSpan, getTraceData, stringMatchesSomePattern } from '@sentry/core';\nimport { WINDOW } from '../helpers.js';\n\n/** Options for Request Instrumentation */\n\nconst responseToSpanId = new WeakMap();\nconst spanIdToEndTimestamp = new Map();\n\nconst defaultRequestInstrumentationOptions = {\n  traceFetch: true,\n  traceXHR: true,\n  enableHTTPTimings: true,\n  trackFetchStreamPerformance: false,\n};\n\n/** Registers span creators for xhr and fetch requests  */\nfunction instrumentOutgoingRequests(client, _options) {\n  const {\n    traceFetch,\n    traceXHR,\n    trackFetchStreamPerformance,\n    shouldCreateSpanForRequest,\n    enableHTTPTimings,\n    tracePropagationTargets,\n  } = {\n    traceFetch: defaultRequestInstrumentationOptions.traceFetch,\n    traceXHR: defaultRequestInstrumentationOptions.traceXHR,\n    trackFetchStreamPerformance: defaultRequestInstrumentationOptions.trackFetchStreamPerformance,\n    ..._options,\n  };\n\n  const shouldCreateSpan =\n    typeof shouldCreateSpanForRequest === 'function' ? shouldCreateSpanForRequest : (_) => true;\n\n  const shouldAttachHeadersWithTargets = (url) => shouldAttachHeaders(url, tracePropagationTargets);\n\n  const spans = {};\n\n  if (traceFetch) {\n    // Keeping track of http requests, whose body payloads resolved later than the initial resolved request\n    // e.g. streaming using server sent events (SSE)\n    client.addEventProcessor(event => {\n      if (event.type === 'transaction' && event.spans) {\n        event.spans.forEach(span => {\n          if (span.op === 'http.client') {\n            const updatedTimestamp = spanIdToEndTimestamp.get(span.span_id);\n            if (updatedTimestamp) {\n              span.timestamp = updatedTimestamp / 1000;\n              spanIdToEndTimestamp.delete(span.span_id);\n            }\n          }\n        });\n      }\n      return event;\n    });\n\n    if (trackFetchStreamPerformance) {\n      addFetchEndInstrumentationHandler(handlerData => {\n        if (handlerData.response) {\n          const span = responseToSpanId.get(handlerData.response);\n          if (span && handlerData.endTimestamp) {\n            spanIdToEndTimestamp.set(span, handlerData.endTimestamp);\n          }\n        }\n      });\n    }\n\n    addFetchInstrumentationHandler(handlerData => {\n      const createdSpan = instrumentFetchRequest(handlerData, shouldCreateSpan, shouldAttachHeadersWithTargets, spans);\n\n      if (handlerData.response && handlerData.fetchData.__span) {\n        responseToSpanId.set(handlerData.response, handlerData.fetchData.__span);\n      }\n\n      // We cannot use `window.location` in the generic fetch instrumentation,\n      // but we need it for reliable `server.address` attribute.\n      // so we extend this in here\n      if (createdSpan) {\n        const fullUrl = getFullURL(handlerData.fetchData.url);\n        const host = fullUrl ? parseUrl(fullUrl).host : undefined;\n        createdSpan.setAttributes({\n          'http.url': fullUrl,\n          'server.address': host,\n        });\n      }\n\n      if (enableHTTPTimings && createdSpan) {\n        addHTTPTimings(createdSpan);\n      }\n    });\n  }\n\n  if (traceXHR) {\n    addXhrInstrumentationHandler(handlerData => {\n      const createdSpan = xhrCallback(handlerData, shouldCreateSpan, shouldAttachHeadersWithTargets, spans);\n      if (enableHTTPTimings && createdSpan) {\n        addHTTPTimings(createdSpan);\n      }\n    });\n  }\n}\n\nfunction isPerformanceResourceTiming(entry) {\n  return (\n    entry.entryType === 'resource' &&\n    'initiatorType' in entry &&\n    typeof (entry ).nextHopProtocol === 'string' &&\n    (entry.initiatorType === 'fetch' || entry.initiatorType === 'xmlhttprequest')\n  );\n}\n\n/**\n * Creates a temporary observer to listen to the next fetch/xhr resourcing timings,\n * so that when timings hit their per-browser limit they don't need to be removed.\n *\n * @param span A span that has yet to be finished, must contain `url` on data.\n */\nfunction addHTTPTimings(span) {\n  const { url } = spanToJSON(span).data || {};\n\n  if (!url || typeof url !== 'string') {\n    return;\n  }\n\n  const cleanup = addPerformanceInstrumentationHandler('resource', ({ entries }) => {\n    entries.forEach(entry => {\n      if (isPerformanceResourceTiming(entry) && entry.name.endsWith(url)) {\n        const spanData = resourceTimingEntryToSpanData(entry);\n        spanData.forEach(data => span.setAttribute(...data));\n        // In the next tick, clean this handler up\n        // We have to wait here because otherwise this cleans itself up before it is fully done\n        setTimeout(cleanup);\n      }\n    });\n  });\n}\n\n/**\n * Converts ALPN protocol ids to name and version.\n *\n * (https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids)\n * @param nextHopProtocol PerformanceResourceTiming.nextHopProtocol\n */\nfunction extractNetworkProtocol(nextHopProtocol) {\n  let name = 'unknown';\n  let version = 'unknown';\n  let _name = '';\n  for (const char of nextHopProtocol) {\n    // http/1.1 etc.\n    if (char === '/') {\n      [name, version] = nextHopProtocol.split('/') ;\n      break;\n    }\n    // h2, h3 etc.\n    if (!isNaN(Number(char))) {\n      name = _name === 'h' ? 'http' : _name;\n      version = nextHopProtocol.split(_name)[1] ;\n      break;\n    }\n    _name += char;\n  }\n  if (_name === nextHopProtocol) {\n    // webrtc, ftp, etc.\n    name = _name;\n  }\n  return { name, version };\n}\n\nfunction getAbsoluteTime(time = 0) {\n  return ((browserPerformanceTimeOrigin || performance.timeOrigin) + time) / 1000;\n}\n\nfunction resourceTimingEntryToSpanData(resourceTiming) {\n  const { name, version } = extractNetworkProtocol(resourceTiming.nextHopProtocol);\n\n  const timingSpanData = [];\n\n  timingSpanData.push(['network.protocol.version', version], ['network.protocol.name', name]);\n\n  if (!browserPerformanceTimeOrigin) {\n    return timingSpanData;\n  }\n  return [\n    ...timingSpanData,\n    ['http.request.redirect_start', getAbsoluteTime(resourceTiming.redirectStart)],\n    ['http.request.fetch_start', getAbsoluteTime(resourceTiming.fetchStart)],\n    ['http.request.domain_lookup_start', getAbsoluteTime(resourceTiming.domainLookupStart)],\n    ['http.request.domain_lookup_end', getAbsoluteTime(resourceTiming.domainLookupEnd)],\n    ['http.request.connect_start', getAbsoluteTime(resourceTiming.connectStart)],\n    ['http.request.secure_connection_start', getAbsoluteTime(resourceTiming.secureConnectionStart)],\n    ['http.request.connection_end', getAbsoluteTime(resourceTiming.connectEnd)],\n    ['http.request.request_start', getAbsoluteTime(resourceTiming.requestStart)],\n    ['http.request.response_start', getAbsoluteTime(resourceTiming.responseStart)],\n    ['http.request.response_end', getAbsoluteTime(resourceTiming.responseEnd)],\n  ];\n}\n\n/**\n * A function that determines whether to attach tracing headers to a request.\n * We only export this function for testing purposes.\n */\nfunction shouldAttachHeaders(\n  targetUrl,\n  tracePropagationTargets,\n) {\n  // window.location.href not being defined is an edge case in the browser but we need to handle it.\n  // Potentially dangerous situations where it may not be defined: Browser Extensions, Web Workers, patching of the location obj\n  const href = WINDOW.location && WINDOW.location.href;\n\n  if (!href) {\n    // If there is no window.location.origin, we default to only attaching tracing headers to relative requests, i.e. ones that start with `/`\n    // BIG DISCLAIMER: Users can call URLs with a double slash (fetch(\"//example.com/api\")), this is a shorthand for \"send to the same protocol\",\n    // so we need a to exclude those requests, because they might be cross origin.\n    const isRelativeSameOriginRequest = !!targetUrl.match(/^\\/(?!\\/)/);\n    if (!tracePropagationTargets) {\n      return isRelativeSameOriginRequest;\n    } else {\n      return stringMatchesSomePattern(targetUrl, tracePropagationTargets);\n    }\n  } else {\n    let resolvedUrl;\n    let currentOrigin;\n\n    // URL parsing may fail, we default to not attaching trace headers in that case.\n    try {\n      resolvedUrl = new URL(targetUrl, href);\n      currentOrigin = new URL(href).origin;\n    } catch (e) {\n      return false;\n    }\n\n    const isSameOriginRequest = resolvedUrl.origin === currentOrigin;\n    if (!tracePropagationTargets) {\n      return isSameOriginRequest;\n    } else {\n      return (\n        stringMatchesSomePattern(resolvedUrl.toString(), tracePropagationTargets) ||\n        (isSameOriginRequest && stringMatchesSomePattern(resolvedUrl.pathname, tracePropagationTargets))\n      );\n    }\n  }\n}\n\n/**\n * Create and track xhr request spans\n *\n * @returns Span if a span was created, otherwise void.\n */\nfunction xhrCallback(\n  handlerData,\n  shouldCreateSpan,\n  shouldAttachHeaders,\n  spans,\n) {\n  const xhr = handlerData.xhr;\n  const sentryXhrData = xhr && xhr[SENTRY_XHR_DATA_KEY];\n\n  if (!xhr || xhr.__sentry_own_request__ || !sentryXhrData) {\n    return undefined;\n  }\n\n  const shouldCreateSpanResult = hasTracingEnabled() && shouldCreateSpan(sentryXhrData.url);\n\n  // check first if the request has finished and is tracked by an existing span which should now end\n  if (handlerData.endTimestamp && shouldCreateSpanResult) {\n    const spanId = xhr.__sentry_xhr_span_id__;\n    if (!spanId) return;\n\n    const span = spans[spanId];\n    if (span && sentryXhrData.status_code !== undefined) {\n      setHttpStatus(span, sentryXhrData.status_code);\n      span.end();\n\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete spans[spanId];\n    }\n    return undefined;\n  }\n\n  const fullUrl = getFullURL(sentryXhrData.url);\n  const host = fullUrl ? parseUrl(fullUrl).host : undefined;\n\n  const hasParent = !!getActiveSpan();\n\n  const span =\n    shouldCreateSpanResult && hasParent\n      ? startInactiveSpan({\n          name: `${sentryXhrData.method} ${sentryXhrData.url}`,\n          attributes: {\n            type: 'xhr',\n            'http.method': sentryXhrData.method,\n            'http.url': fullUrl,\n            url: sentryXhrData.url,\n            'server.address': host,\n            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.browser',\n            [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'http.client',\n          },\n        })\n      : new SentryNonRecordingSpan();\n\n  xhr.__sentry_xhr_span_id__ = span.spanContext().spanId;\n  spans[xhr.__sentry_xhr_span_id__] = span;\n\n  if (shouldAttachHeaders(sentryXhrData.url)) {\n    addTracingHeadersToXhrRequest(\n      xhr,\n      // If performance is disabled (TWP) or there's no active root span (pageload/navigation/interaction),\n      // we do not want to use the span as base for the trace headers,\n      // which means that the headers will be generated from the scope and the sampling decision is deferred\n      hasTracingEnabled() && hasParent ? span : undefined,\n    );\n  }\n\n  return span;\n}\n\nfunction addTracingHeadersToXhrRequest(xhr, span) {\n  const { 'sentry-trace': sentryTrace, baggage } = getTraceData({ span });\n\n  if (sentryTrace) {\n    setHeaderOnXhr(xhr, sentryTrace, baggage);\n  }\n}\n\nfunction setHeaderOnXhr(\n  xhr,\n  sentryTraceHeader,\n  sentryBaggageHeader,\n) {\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    xhr.setRequestHeader('sentry-trace', sentryTraceHeader);\n    if (sentryBaggageHeader) {\n      // From MDN: \"If this method is called several times with the same header, the values are merged into one single request header.\"\n      // We can therefore simply set a baggage header without checking what was there before\n      // https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/setRequestHeader\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      xhr.setRequestHeader('baggage', sentryBaggageHeader);\n    }\n  } catch (_) {\n    // Error: InvalidStateError: Failed to execute 'setRequestHeader' on 'XMLHttpRequest': The object's state must be OPENED.\n  }\n}\n\nfunction getFullURL(url) {\n  try {\n    // By adding a base URL to new URL(), this will also work for relative urls\n    // If `url` is a full URL, the base URL is ignored anyhow\n    const parsed = new URL(url, WINDOW.location.origin);\n    return parsed.href;\n  } catch (e2) {\n    return undefined;\n  }\n}\n\nexport { defaultRequestInstrumentationOptions, extractNetworkProtocol, instrumentOutgoingRequests, shouldAttachHeaders, xhrCallback };\n//# sourceMappingURL=request.js.map\n","import { startTrackingWebVitals, startTrackingINP, startTrackingLongAnimationFrames, startTrackingLongTasks, startTrackingInteractions, addHistoryInstrumentationHandler, registerInpInteractionListener, addPerformanceEntries } from '@sentry-internal/browser-utils';\nimport { TRACING_DEFAULTS, registerSpanErrorInstrumentation, GLOBAL_OBJ, getClient, propagationContextFromHeaders, getCurrentScope, spanToJSON, getRootSpan, spanIsSampled, getDynamicSamplingContextFromSpan, browserPerformanceTimeOrigin, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, getActiveSpan, getIsolationScope, generateTraceId, getDomElement, startIdleSpan, logger, SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON } from '@sentry/core';\nimport { DEBUG_BUILD } from '../debug-build.js';\nimport { WINDOW } from '../helpers.js';\nimport { registerBackgroundTabDetection } from './backgroundtab.js';\nimport { defaultRequestInstrumentationOptions, instrumentOutgoingRequests } from './request.js';\n\n/* eslint-disable max-lines */\n\nconst BROWSER_TRACING_INTEGRATION_ID = 'BrowserTracing';\n\nconst DEFAULT_BROWSER_TRACING_OPTIONS = {\n  ...TRACING_DEFAULTS,\n  instrumentNavigation: true,\n  instrumentPageLoad: true,\n  markBackgroundSpan: true,\n  enableLongTask: true,\n  enableLongAnimationFrame: true,\n  enableInp: true,\n  _experiments: {},\n  ...defaultRequestInstrumentationOptions,\n};\n\n/**\n * The Browser Tracing integration automatically instruments browser pageload/navigation\n * actions as transactions, and captures requests, metrics and errors as spans.\n *\n * The integration can be configured with a variety of options, and can be extended to use\n * any routing library.\n *\n * We explicitly export the proper type here, as this has to be extended in some cases.\n */\nconst browserTracingIntegration = ((_options = {}) => {\n  registerSpanErrorInstrumentation();\n\n  const {\n    enableInp,\n    enableLongTask,\n    enableLongAnimationFrame,\n    _experiments: { enableInteractions, enableStandaloneClsSpans },\n    beforeStartSpan,\n    idleTimeout,\n    finalTimeout,\n    childSpanTimeout,\n    markBackgroundSpan,\n    traceFetch,\n    traceXHR,\n    trackFetchStreamPerformance,\n    shouldCreateSpanForRequest,\n    enableHTTPTimings,\n    instrumentPageLoad,\n    instrumentNavigation,\n  } = {\n    ...DEFAULT_BROWSER_TRACING_OPTIONS,\n    ..._options,\n  };\n\n  const _collectWebVitals = startTrackingWebVitals({ recordClsStandaloneSpans: enableStandaloneClsSpans || false });\n\n  if (enableInp) {\n    startTrackingINP();\n  }\n\n  if (\n    enableLongAnimationFrame &&\n    GLOBAL_OBJ.PerformanceObserver &&\n    PerformanceObserver.supportedEntryTypes &&\n    PerformanceObserver.supportedEntryTypes.includes('long-animation-frame')\n  ) {\n    startTrackingLongAnimationFrames();\n  } else if (enableLongTask) {\n    startTrackingLongTasks();\n  }\n\n  if (enableInteractions) {\n    startTrackingInteractions();\n  }\n\n  const latestRoute = {\n    name: undefined,\n    source: undefined,\n  };\n\n  /** Create routing idle transaction. */\n  function _createRouteSpan(client, startSpanOptions) {\n    const isPageloadTransaction = startSpanOptions.op === 'pageload';\n\n    const finalStartSpanOptions = beforeStartSpan\n      ? beforeStartSpan(startSpanOptions)\n      : startSpanOptions;\n\n    const attributes = finalStartSpanOptions.attributes || {};\n\n    // If `finalStartSpanOptions.name` is different than `startSpanOptions.name`\n    // it is because `beforeStartSpan` set a custom name. Therefore we set the source to 'custom'.\n    if (startSpanOptions.name !== finalStartSpanOptions.name) {\n      attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE] = 'custom';\n      finalStartSpanOptions.attributes = attributes;\n    }\n\n    latestRoute.name = finalStartSpanOptions.name;\n    latestRoute.source = attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE];\n\n    const idleSpan = startIdleSpan(finalStartSpanOptions, {\n      idleTimeout,\n      finalTimeout,\n      childSpanTimeout,\n      // should wait for finish signal if it's a pageload transaction\n      disableAutoFinish: isPageloadTransaction,\n      beforeSpanEnd: span => {\n        _collectWebVitals();\n        addPerformanceEntries(span, { recordClsOnPageloadSpan: !enableStandaloneClsSpans });\n      },\n    });\n\n    function emitFinish() {\n      if (['interactive', 'complete'].includes(WINDOW.document.readyState)) {\n        client.emit('idleSpanEnableAutoFinish', idleSpan);\n      }\n    }\n\n    if (isPageloadTransaction && WINDOW.document) {\n      WINDOW.document.addEventListener('readystatechange', () => {\n        emitFinish();\n      });\n\n      emitFinish();\n    }\n\n    return idleSpan;\n  }\n\n  return {\n    name: BROWSER_TRACING_INTEGRATION_ID,\n    afterAllSetup(client) {\n      let activeSpan;\n      let startingUrl = WINDOW.location && WINDOW.location.href;\n\n      function maybeEndActiveSpan() {\n        if (activeSpan && !spanToJSON(activeSpan).timestamp) {\n          DEBUG_BUILD && logger.log(`[Tracing] Finishing current active span with op: ${spanToJSON(activeSpan).op}`);\n          // If there's an open active span, we need to finish it before creating an new one.\n          activeSpan.end();\n        }\n      }\n\n      client.on('startNavigationSpan', startSpanOptions => {\n        if (getClient() !== client) {\n          return;\n        }\n\n        maybeEndActiveSpan();\n\n        activeSpan = _createRouteSpan(client, {\n          op: 'navigation',\n          ...startSpanOptions,\n        });\n      });\n\n      client.on('startPageLoadSpan', (startSpanOptions, traceOptions = {}) => {\n        if (getClient() !== client) {\n          return;\n        }\n        maybeEndActiveSpan();\n\n        const sentryTrace = traceOptions.sentryTrace || getMetaContent('sentry-trace');\n        const baggage = traceOptions.baggage || getMetaContent('baggage');\n\n        const propagationContext = propagationContextFromHeaders(sentryTrace, baggage);\n        getCurrentScope().setPropagationContext(propagationContext);\n\n        activeSpan = _createRouteSpan(client, {\n          op: 'pageload',\n          ...startSpanOptions,\n        });\n      });\n\n      // A trace should to stay the consistent over the entire time span of one route.\n      // Therefore, when the initial pageload or navigation root span ends, we update the\n      // scope's propagation context to keep span-specific attributes like the `sampled` decision and\n      // the dynamic sampling context valid, even after the root span has ended.\n      // This ensures that the trace data is consistent for the entire duration of the route.\n      client.on('spanEnd', span => {\n        const op = spanToJSON(span).op;\n        if (span !== getRootSpan(span) || (op !== 'navigation' && op !== 'pageload')) {\n          return;\n        }\n\n        const scope = getCurrentScope();\n        const oldPropagationContext = scope.getPropagationContext();\n\n        scope.setPropagationContext({\n          ...oldPropagationContext,\n          sampled: oldPropagationContext.sampled !== undefined ? oldPropagationContext.sampled : spanIsSampled(span),\n          dsc: oldPropagationContext.dsc || getDynamicSamplingContextFromSpan(span),\n        });\n      });\n\n      if (WINDOW.location) {\n        if (instrumentPageLoad) {\n          startBrowserTracingPageLoadSpan(client, {\n            name: WINDOW.location.pathname,\n            // pageload should always start at timeOrigin (and needs to be in s, not ms)\n            startTime: browserPerformanceTimeOrigin ? browserPerformanceTimeOrigin / 1000 : undefined,\n            attributes: {\n              [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'url',\n              [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.pageload.browser',\n            },\n          });\n        }\n\n        if (instrumentNavigation) {\n          addHistoryInstrumentationHandler(({ to, from }) => {\n            /**\n             * This early return is there to account for some cases where a navigation transaction starts right after\n             * long-running pageload. We make sure that if `from` is undefined and a valid `startingURL` exists, we don't\n             * create an uneccessary navigation transaction.\n             *\n             * This was hard to duplicate, but this behavior stopped as soon as this fix was applied. This issue might also\n             * only be caused in certain development environments where the usage of a hot module reloader is causing\n             * errors.\n             */\n            if (from === undefined && startingUrl && startingUrl.indexOf(to) !== -1) {\n              startingUrl = undefined;\n              return;\n            }\n\n            if (from !== to) {\n              startingUrl = undefined;\n              startBrowserTracingNavigationSpan(client, {\n                name: WINDOW.location.pathname,\n                attributes: {\n                  [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'url',\n                  [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.navigation.browser',\n                },\n              });\n            }\n          });\n        }\n      }\n\n      if (markBackgroundSpan) {\n        registerBackgroundTabDetection();\n      }\n\n      if (enableInteractions) {\n        registerInteractionListener(idleTimeout, finalTimeout, childSpanTimeout, latestRoute);\n      }\n\n      if (enableInp) {\n        registerInpInteractionListener();\n      }\n\n      instrumentOutgoingRequests(client, {\n        traceFetch,\n        traceXHR,\n        trackFetchStreamPerformance,\n        tracePropagationTargets: client.getOptions().tracePropagationTargets,\n        shouldCreateSpanForRequest,\n        enableHTTPTimings,\n      });\n    },\n  };\n}) ;\n\n/**\n * Manually start a page load span.\n * This will only do something if a browser tracing integration integration has been setup.\n *\n * If you provide a custom `traceOptions` object, it will be used to continue the trace\n * instead of the default behavior, which is to look it up on the <meta> tags.\n */\nfunction startBrowserTracingPageLoadSpan(\n  client,\n  spanOptions,\n  traceOptions,\n) {\n  client.emit('startPageLoadSpan', spanOptions, traceOptions);\n\n  getCurrentScope().setTransactionName(spanOptions.name);\n\n  const span = getActiveSpan();\n  const op = span && spanToJSON(span).op;\n  return op === 'pageload' ? span : undefined;\n}\n\n/**\n * Manually start a navigation span.\n * This will only do something if a browser tracing integration has been setup.\n */\nfunction startBrowserTracingNavigationSpan(client, spanOptions) {\n  getIsolationScope().setPropagationContext({ traceId: generateTraceId() });\n  getCurrentScope().setPropagationContext({ traceId: generateTraceId() });\n\n  client.emit('startNavigationSpan', spanOptions);\n\n  getCurrentScope().setTransactionName(spanOptions.name);\n\n  const span = getActiveSpan();\n  const op = span && spanToJSON(span).op;\n  return op === 'navigation' ? span : undefined;\n}\n\n/** Returns the value of a meta tag */\nfunction getMetaContent(metaName) {\n  // Can't specify generic to `getDomElement` because tracing can be used\n  // in a variety of environments, have to disable `no-unsafe-member-access`\n  // as a result.\n  // eslint-disable-next-line deprecation/deprecation\n  const metaTag = getDomElement(`meta[name=${metaName}]`);\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  return metaTag ? metaTag.getAttribute('content') : undefined;\n}\n\n/** Start listener for interaction transactions */\nfunction registerInteractionListener(\n  idleTimeout,\n  finalTimeout,\n  childSpanTimeout,\n  latestRoute,\n) {\n  let inflightInteractionSpan;\n  const registerInteractionTransaction = () => {\n    const op = 'ui.action.click';\n\n    const activeSpan = getActiveSpan();\n    const rootSpan = activeSpan && getRootSpan(activeSpan);\n    if (rootSpan) {\n      const currentRootSpanOp = spanToJSON(rootSpan).op;\n      if (['navigation', 'pageload'].includes(currentRootSpanOp )) {\n        DEBUG_BUILD &&\n          logger.warn(`[Tracing] Did not create ${op} span because a pageload or navigation span is in progress.`);\n        return undefined;\n      }\n    }\n\n    if (inflightInteractionSpan) {\n      inflightInteractionSpan.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON, 'interactionInterrupted');\n      inflightInteractionSpan.end();\n      inflightInteractionSpan = undefined;\n    }\n\n    if (!latestRoute.name) {\n      DEBUG_BUILD && logger.warn(`[Tracing] Did not create ${op} transaction because _latestRouteName is missing.`);\n      return undefined;\n    }\n\n    inflightInteractionSpan = startIdleSpan(\n      {\n        name: latestRoute.name,\n        op,\n        attributes: {\n          [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: latestRoute.source || 'url',\n        },\n      },\n      {\n        idleTimeout,\n        finalTimeout,\n        childSpanTimeout,\n      },\n    );\n  };\n\n  if (WINDOW.document) {\n    addEventListener('click', registerInteractionTransaction, { once: false, capture: true });\n  }\n}\n\nexport { BROWSER_TRACING_INTEGRATION_ID, browserTracingIntegration, getMetaContent, startBrowserTracingNavigationSpan, startBrowserTracingPageLoadSpan };\n//# sourceMappingURL=browserTracingIntegration.js.map\n","import { getActiveSpan, getRootSpan, spanToJSON, logger, SPAN_STATUS_ERROR } from '@sentry/core';\nimport { DEBUG_BUILD } from '../debug-build.js';\nimport { WINDOW } from '../helpers.js';\n\n/**\n * Add a listener that cancels and finishes a transaction when the global\n * document is hidden.\n */\nfunction registerBackgroundTabDetection() {\n  if (WINDOW && WINDOW.document) {\n    WINDOW.document.addEventListener('visibilitychange', () => {\n      const activeSpan = getActiveSpan();\n      if (!activeSpan) {\n        return;\n      }\n\n      const rootSpan = getRootSpan(activeSpan);\n\n      if (WINDOW.document.hidden && rootSpan) {\n        const cancelledStatus = 'cancelled';\n\n        const { op, status } = spanToJSON(rootSpan);\n\n        if (DEBUG_BUILD) {\n          logger.log(`[Tracing] Transaction: ${cancelledStatus} -> since tab moved to the background, op: ${op}`);\n        }\n\n        // We should not set status if it is already set, this prevent important statuses like\n        // error or data loss from being overwritten on transaction.\n        if (!status) {\n          rootSpan.setStatus({ code: SPAN_STATUS_ERROR, message: cancelledStatus });\n        }\n\n        rootSpan.setAttribute('sentry.cancellation_reason', 'document.hidden');\n        rootSpan.end();\n      }\n    });\n  } else {\n    DEBUG_BUILD && logger.warn('[Tracing] Could not set up background tab detection due to lack of global document');\n  }\n}\n\nexport { registerBackgroundTabDetection };\n//# sourceMappingURL=backgroundtab.js.map\n","import { getNativeImplementation, clearCachedImplementation } from '@sentry-internal/browser-utils';\nimport { createTransport, rejectedSyncPromise } from '@sentry/core';\n\n/**\n * Creates a Transport that uses the Fetch API to send events to Sentry.\n */\nfunction makeFetchTransport(\n  options,\n  nativeFetch = getNativeImplementation('fetch'),\n) {\n  let pendingBodySize = 0;\n  let pendingCount = 0;\n\n  function makeRequest(request) {\n    const requestSize = request.body.length;\n    pendingBodySize += requestSize;\n    pendingCount++;\n\n    const requestOptions = {\n      body: request.body,\n      method: 'POST',\n      referrerPolicy: 'origin',\n      headers: options.headers,\n      // Outgoing requests are usually cancelled when navigating to a different page, causing a \"TypeError: Failed to\n      // fetch\" error and sending a \"network_error\" client-outcome - in Chrome, the request status shows \"(cancelled)\".\n      // The `keepalive` flag keeps outgoing requests alive, even when switching pages. We want this since we're\n      // frequently sending events right before the user is switching pages (eg. when finishing navigation transactions).\n      // Gotchas:\n      // - `keepalive` isn't supported by Firefox\n      // - As per spec (https://fetch.spec.whatwg.org/#http-network-or-cache-fetch):\n      //   If the sum of contentLength and inflightKeepaliveBytes is greater than 64 kibibytes, then return a network error.\n      //   We will therefore only activate the flag when we're below that limit.\n      // There is also a limit of requests that can be open at the same time, so we also limit this to 15\n      // See https://github.com/getsentry/sentry-javascript/pull/7553 for details\n      keepalive: pendingBodySize <= 60000 && pendingCount < 15,\n      ...options.fetchOptions,\n    };\n\n    if (!nativeFetch) {\n      clearCachedImplementation('fetch');\n      return rejectedSyncPromise('No fetch implementation available');\n    }\n\n    try {\n      // TODO: This may need a `suppressTracing` call in the future when we switch the browser SDK to OTEL\n      return nativeFetch(options.url, requestOptions).then(response => {\n        pendingBodySize -= requestSize;\n        pendingCount--;\n        return {\n          statusCode: response.status,\n          headers: {\n            'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),\n            'retry-after': response.headers.get('Retry-After'),\n          },\n        };\n      });\n    } catch (e) {\n      clearCachedImplementation('fetch');\n      pendingBodySize -= requestSize;\n      pendingCount--;\n      return rejectedSyncPromise(e);\n    }\n  }\n\n  return createTransport(options, makeRequest);\n}\n\nexport { makeFetchTransport };\n//# sourceMappingURL=fetch.js.map\n"],"names":["DEBUG_BUILD","__SENTRY_DEBUG__","exceptionFromError","stackParser","ex","frames","parseStackFrames","exception","type","extractType","value","extractMessage","length","stacktrace","undefined","eventFromError","values","stack","skipLines","reactMinifiedRegexp","test","message","getSkipFirstStackStringLines","framesToPop","getPopFirstTopFrames","e","isWebAssemblyException","WebAssembly","Exception","name","Array","isArray","error","eventFromException","hint","attachStacktrace","event","eventFromUnknownInput","syntheticException","level","event_id","eventFromMessage","eventFromString","isUnhandledRejection","domException","tags","code","client","normalizeDepth","getOptions","errorFromProp","obj","prop","Object","prototype","hasOwnProperty","call","Error","getErrorPropertyFromObject","extra","__serialized__","constructor","getNonErrorObjectExceptionValue","eventFromPlainObject","synthetic","__sentry_template_string__","__sentry_template_values__","logentry","params","keys","captureType","getPrototypeOf","getObjectClassName","WINDOW","ignoreOnError","shouldIgnoreOnError","wrap","fn","options","isFunction","wrapper","__sentry_wrapped__","sentryWrapped","args","wrappedArguments","map","arg","apply","this","setTimeout","scope","addEventProcessor","mechanism","arguments","property","e2","getOwnPropertyDescriptor","configurable","defineProperty","get","e3","breadcrumbsIntegration","_options","console","dom","fetch","history","sentry","xhr","setup","handlerData","breadcrumb","category","data","logger","slice","input","_getConsoleBreadcrumbHandler","target","componentName","keyAttrs","serializeAttribute","maxStringLength","warn","element","_isEvent","global","_getDomBreadcrumbHandler","startTimestamp","endTimestamp","sentryXhrData","method","url","status_code","body","_getXhrBreadcrumbHandler","fetchData","match","response","status","_getFetchBreadcrumbHandler","from","to","parsedLoc","location","href","parsedFrom","parsedTo","path","protocol","host","relative","_getHistoryBreadcrumbHandler","on","_getSentryBreadcrumbHandler","DEFAULT_EVENT_TARGET","browserApiErrorsIntegration","XMLHttpRequest","eventTarget","requestAnimationFrame","setInterval","setupOnce","_wrapTimeFunction","_wrapRAF","_wrapXHR","eventTargetOption","forEach","_wrapEventTarget","original","originalCallback","function","handled","callback","handler","originalSend","wrapOptions","originalFunction","targetObj","proto","eventName","handleEvent","originalRemoveEventListener","originalEventHandler","globalHandlersIntegration","onerror","onunhandledrejection","stackTraceLimit","msg","line","column","ev","ev0","ev0s","ev0sf","colno","lineno","filename","push","in_app","_enhanceEventWithInitialFrame","originalException","_installGlobalOnErrorHandler","globalHandlerLog","reason","detail","_getUnhandledRejectionError","String","_installGlobalOnUnhandledRejectionHandler","log","httpContextIntegration","preprocessEvent","navigator","document","request","referrer","userAgent","headers","Referer","linkedErrorsIntegration","limit","key","maxValueLength","createUserFeedbackEnvelope","feedback","metadata","tunnel","dsn","sent_at","Date","toISOString","sdk","version","item","createUserFeedbackEnvelopeItem","BrowserClient","opts","parentSpanIsAlwaysRootSpan","sdkSource","SENTRY_SDK_SOURCE","super","sendClientReports","addEventListener","visibilityState","_flushOutcomes","captureUserFeedback","_isEnabled","envelope","getSdkMetadata","getDsn","sendEnvelope","_prepareEvent","platform","browserSessionIntegration","ignoreDuration","getDefaultIntegrations","integrations","breadcrumbs","dedupe","autoSessionTracking","init","browserOptions","optionsArg","defaultOptions","defaultIntegrations","release","__SENTRY_RELEASE__","SENTRY_RELEASE","id","applyDefaultOptions","skipBrowserExtensionCheck","windowWithMaybeExtension","window","extensionObject","chrome","runtimeId","runtime","isDedicatedExtensionPage","top","some","startsWith","isNWjs","nw","shouldShowBrowserExtensionError","supports","clientOptions","transport","showReportDialog","getClient","user","getUser","eventId","script","createElement","async","crossOrigin","src","onLoad","onload","onClose","reportDialogClosedMessageHandler","removeEventListener","injectionPoint","head","appendChild","createFrame","func","frame","chromeRegexNoFnName","chromeRegex","chromeEvalRegex","geckoREgex","geckoEvalRegex","defaultStackLineParsers","noFnParts","exec","col","parts","indexOf","subMatch","extractSafariExtensionDetails","defaultStackParser","isSafariExtension","isSafariWebExtension","split","responseToSpanId","WeakMap","spanIdToEndTimestamp","Map","defaultRequestInstrumentationOptions","traceFetch","traceXHR","enableHTTPTimings","trackFetchStreamPerformance","addHTTPTimings","span","cleanup","entries","entry","entryType","nextHopProtocol","initiatorType","isPerformanceResourceTiming","endsWith","resourceTiming","_name","char","isNaN","Number","extractNetworkProtocol","timingSpanData","getAbsoluteTime","redirectStart","fetchStart","domainLookupStart","domainLookupEnd","connectStart","secureConnectionStart","connectEnd","requestStart","responseStart","responseEnd","resourceTimingEntryToSpanData","setAttribute","time","performance","timeOrigin","getFullURL","URL","origin","DEFAULT_BROWSER_TRACING_OPTIONS","instrumentNavigation","instrumentPageLoad","markBackgroundSpan","enableLongTask","enableLongAnimationFrame","enableInp","_experiments","browserTracingIntegration","enableInteractions","enableStandaloneClsSpans","beforeStartSpan","idleTimeout","finalTimeout","childSpanTimeout","shouldCreateSpanForRequest","_collectWebVitals","recordClsStandaloneSpans","PerformanceObserver","supportedEntryTypes","includes","latestRoute","source","_createRouteSpan","startSpanOptions","isPageloadTransaction","op","finalStartSpanOptions","attributes","idleSpan","disableAutoFinish","beforeSpanEnd","recordClsOnPageloadSpan","emitFinish","readyState","emit","afterAllSetup","activeSpan","startingUrl","maybeEndActiveSpan","timestamp","end","traceOptions","sentryTrace","getMetaContent","baggage","propagationContext","setPropagationContext","oldPropagationContext","getPropagationContext","sampled","dsc","startBrowserTracingPageLoadSpan","pathname","startTime","startBrowserTracingNavigationSpan","rootSpan","hidden","cancelledStatus","setStatus","inflightInteractionSpan","currentRootSpanOp","once","capture","registerInteractionListener","tracePropagationTargets","shouldCreateSpan","_","shouldAttachHeadersWithTargets","targetUrl","resolvedUrl","currentOrigin","isSameOriginRequest","string","toString","isRelativeSameOriginRequest","shouldAttachHeaders","spans","updatedTimestamp","span_id","delete","set","createdSpan","__span","fullUrl","setAttributes","__sentry_own_request__","shouldCreateSpanResult","hasTracingEnabled","spanId","__sentry_xhr_span_id__","hasParent","spanContext","sentryTraceHeader","sentryBaggageHeader","setRequestHeader","setHeaderOnXhr","addTracingHeadersToXhrRequest","xhrCallback","instrumentOutgoingRequests","spanOptions","setTransactionName","traceId","metaName","metaTag","getAttribute","makeFetchTransport","nativeFetch","pendingBodySize","pendingCount","requestSize","requestOptions","referrerPolicy","keepalive","fetchOptions","then","statusCode"],"sourceRoot":""}