{"version":3,"file":"js/chunk-vendors-bf6e8d65.f5b40ab1.js","mappings":"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","sources":["webpack://dicom-frontend/./node_modules/@sentry/utils/esm/aggregate-errors.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/baggage.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/browser.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/buildPolyfills/_nullishCoalesce.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/buildPolyfills/_optionalChain.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/clientreport.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/debug-build.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/dsn.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/env.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/envelope.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/error.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/eventbuilder.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/instrument/_handlers.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/instrument/console.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/instrument/dom.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/instrument/fetch.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/instrument/globalError.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/instrument/globalUnhandledRejection.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/vendor/supportsHistory.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/instrument/history.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/instrument/xhr.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/is.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/isBrowser.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/logger.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/misc.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/node.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/memo.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/normalize.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/object.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/path.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/promisebuffer.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/ratelimit.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/severity.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/stacktrace.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/string.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/supports.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/syncpromise.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/time.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/tracing.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/url.js","webpack://dicom-frontend/./node_modules/@sentry/utils/esm/worldwide.js","webpack://dicom-frontend/./node_modules/@sentry/vue/esm/constants.js","webpack://dicom-frontend/./node_modules/@sentry/vue/esm/errorhandler.js","webpack://dicom-frontend/./node_modules/@sentry/vue/esm/router.js","webpack://dicom-frontend/./node_modules/@sentry/vue/esm/browserTracingIntegration.js","webpack://dicom-frontend/./node_modules/@sentry/vue/esm/integration.js","webpack://dicom-frontend/./node_modules/@sentry/vue/esm/sdk.js","webpack://dicom-frontend/./node_modules/@sentry/vue/esm/debug-build.js","webpack://dicom-frontend/./node_modules/@sentry/vue/esm/tracing.js","webpack://dicom-frontend/./node_modules/@sentry/vue/esm/vendor/components.js","webpack://dicom-frontend/./node_modules/set-function-length/index.js","webpack://dicom-frontend/./node_modules/shallow-equal/arrays/index.js"],"sourcesContent":["import { isInstanceOf } from './is.js';\nimport { truncate } from './string.js';\n\n/**\n * Creates exceptions inside `event.exception.values` for errors that are nested on properties based on the `key` parameter.\n */\nfunction applyAggregateErrorsToEvent(\n  exceptionFromErrorImplementation,\n  parser,\n  maxValueLimit = 250,\n  key,\n  limit,\n  event,\n  hint,\n) {\n  if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {\n    return;\n  }\n\n  // Generally speaking the last item in `event.exception.values` is the exception originating from the original Error\n  const originalException =\n    event.exception.values.length > 0 ? event.exception.values[event.exception.values.length - 1] : undefined;\n\n  // We only create exception grouping if there is an exception in the event.\n  if (originalException) {\n    event.exception.values = truncateAggregateExceptions(\n      aggregateExceptionsFromError(\n        exceptionFromErrorImplementation,\n        parser,\n        limit,\n        hint.originalException ,\n        key,\n        event.exception.values,\n        originalException,\n        0,\n      ),\n      maxValueLimit,\n    );\n  }\n}\n\nfunction aggregateExceptionsFromError(\n  exceptionFromErrorImplementation,\n  parser,\n  limit,\n  error,\n  key,\n  prevExceptions,\n  exception,\n  exceptionId,\n) {\n  if (prevExceptions.length >= limit + 1) {\n    return prevExceptions;\n  }\n\n  let newExceptions = [...prevExceptions];\n\n  // Recursively call this function in order to walk down a chain of errors\n  if (isInstanceOf(error[key], Error)) {\n    applyExceptionGroupFieldsForParentException(exception, exceptionId);\n    const newException = exceptionFromErrorImplementation(parser, error[key]);\n    const newExceptionId = newExceptions.length;\n    applyExceptionGroupFieldsForChildException(newException, key, newExceptionId, exceptionId);\n    newExceptions = aggregateExceptionsFromError(\n      exceptionFromErrorImplementation,\n      parser,\n      limit,\n      error[key],\n      key,\n      [newException, ...newExceptions],\n      newException,\n      newExceptionId,\n    );\n  }\n\n  // This will create exception grouping for AggregateErrors\n  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AggregateError\n  if (Array.isArray(error.errors)) {\n    error.errors.forEach((childError, i) => {\n      if (isInstanceOf(childError, Error)) {\n        applyExceptionGroupFieldsForParentException(exception, exceptionId);\n        const newException = exceptionFromErrorImplementation(parser, childError);\n        const newExceptionId = newExceptions.length;\n        applyExceptionGroupFieldsForChildException(newException, `errors[${i}]`, newExceptionId, exceptionId);\n        newExceptions = aggregateExceptionsFromError(\n          exceptionFromErrorImplementation,\n          parser,\n          limit,\n          childError,\n          key,\n          [newException, ...newExceptions],\n          newException,\n          newExceptionId,\n        );\n      }\n    });\n  }\n\n  return newExceptions;\n}\n\nfunction applyExceptionGroupFieldsForParentException(exception, exceptionId) {\n  // Don't know if this default makes sense. The protocol requires us to set these values so we pick *some* default.\n  exception.mechanism = exception.mechanism || { type: 'generic', handled: true };\n\n  exception.mechanism = {\n    ...exception.mechanism,\n    ...(exception.type === 'AggregateError' && { is_exception_group: true }),\n    exception_id: exceptionId,\n  };\n}\n\nfunction applyExceptionGroupFieldsForChildException(\n  exception,\n  source,\n  exceptionId,\n  parentId,\n) {\n  // Don't know if this default makes sense. The protocol requires us to set these values so we pick *some* default.\n  exception.mechanism = exception.mechanism || { type: 'generic', handled: true };\n\n  exception.mechanism = {\n    ...exception.mechanism,\n    type: 'chained',\n    source,\n    exception_id: exceptionId,\n    parent_id: parentId,\n  };\n}\n\n/**\n * Truncate the message (exception.value) of all exceptions in the event.\n * Because this event processor is ran after `applyClientOptions`,\n * we need to truncate the message of the added exceptions here.\n */\nfunction truncateAggregateExceptions(exceptions, maxValueLength) {\n  return exceptions.map(exception => {\n    if (exception.value) {\n      exception.value = truncate(exception.value, maxValueLength);\n    }\n    return exception;\n  });\n}\n\nexport { applyAggregateErrorsToEvent };\n//# sourceMappingURL=aggregate-errors.js.map\n","import { DEBUG_BUILD } from './debug-build.js';\nimport { isString } from './is.js';\nimport { logger } from './logger.js';\n\nconst BAGGAGE_HEADER_NAME = 'baggage';\n\nconst SENTRY_BAGGAGE_KEY_PREFIX = 'sentry-';\n\nconst SENTRY_BAGGAGE_KEY_PREFIX_REGEX = /^sentry-/;\n\n/**\n * Max length of a serialized baggage string\n *\n * https://www.w3.org/TR/baggage/#limits\n */\nconst MAX_BAGGAGE_STRING_LENGTH = 8192;\n\n/**\n * Takes a baggage header and turns it into Dynamic Sampling Context, by extracting all the \"sentry-\" prefixed values\n * from it.\n *\n * @param baggageHeader A very bread definition of a baggage header as it might appear in various frameworks.\n * @returns The Dynamic Sampling Context that was found on `baggageHeader`, if there was any, `undefined` otherwise.\n */\nfunction baggageHeaderToDynamicSamplingContext(\n  // Very liberal definition of what any incoming header might look like\n  baggageHeader,\n) {\n  if (!isString(baggageHeader) && !Array.isArray(baggageHeader)) {\n    return undefined;\n  }\n\n  // Intermediary object to store baggage key value pairs of incoming baggage headers on.\n  // It is later used to read Sentry-DSC-values from.\n  let baggageObject = {};\n\n  if (Array.isArray(baggageHeader)) {\n    // Combine all baggage headers into one object containing the baggage values so we can later read the Sentry-DSC-values from it\n    baggageObject = baggageHeader.reduce((acc, curr) => {\n      const currBaggageObject = baggageHeaderToObject(curr);\n      for (const key of Object.keys(currBaggageObject)) {\n        acc[key] = currBaggageObject[key];\n      }\n      return acc;\n    }, {});\n  } else {\n    // Return undefined if baggage header is an empty string (technically an empty baggage header is not spec conform but\n    // this is how we choose to handle it)\n    if (!baggageHeader) {\n      return undefined;\n    }\n\n    baggageObject = baggageHeaderToObject(baggageHeader);\n  }\n\n  // Read all \"sentry-\" prefixed values out of the baggage object and put it onto a dynamic sampling context object.\n  const dynamicSamplingContext = Object.entries(baggageObject).reduce((acc, [key, value]) => {\n    if (key.match(SENTRY_BAGGAGE_KEY_PREFIX_REGEX)) {\n      const nonPrefixedKey = key.slice(SENTRY_BAGGAGE_KEY_PREFIX.length);\n      acc[nonPrefixedKey] = value;\n    }\n    return acc;\n  }, {});\n\n  // Only return a dynamic sampling context object if there are keys in it.\n  // A keyless object means there were no sentry values on the header, which means that there is no DSC.\n  if (Object.keys(dynamicSamplingContext).length > 0) {\n    return dynamicSamplingContext ;\n  } else {\n    return undefined;\n  }\n}\n\n/**\n * Turns a Dynamic Sampling Object into a baggage header by prefixing all the keys on the object with \"sentry-\".\n *\n * @param dynamicSamplingContext The Dynamic Sampling Context to turn into a header. For convenience and compatibility\n * with the `getDynamicSamplingContext` method on the Transaction class ,this argument can also be `undefined`. If it is\n * `undefined` the function will return `undefined`.\n * @returns a baggage header, created from `dynamicSamplingContext`, or `undefined` either if `dynamicSamplingContext`\n * was `undefined`, or if `dynamicSamplingContext` didn't contain any values.\n */\nfunction dynamicSamplingContextToSentryBaggageHeader(\n  // this also takes undefined for convenience and bundle size in other places\n  dynamicSamplingContext,\n) {\n  if (!dynamicSamplingContext) {\n    return undefined;\n  }\n\n  // Prefix all DSC keys with \"sentry-\" and put them into a new object\n  const sentryPrefixedDSC = Object.entries(dynamicSamplingContext).reduce(\n    (acc, [dscKey, dscValue]) => {\n      if (dscValue) {\n        acc[`${SENTRY_BAGGAGE_KEY_PREFIX}${dscKey}`] = dscValue;\n      }\n      return acc;\n    },\n    {},\n  );\n\n  return objectToBaggageHeader(sentryPrefixedDSC);\n}\n\n/**\n * Will parse a baggage header, which is a simple key-value map, into a flat object.\n *\n * @param baggageHeader The baggage header to parse.\n * @returns a flat object containing all the key-value pairs from `baggageHeader`.\n */\nfunction baggageHeaderToObject(baggageHeader) {\n  return baggageHeader\n    .split(',')\n    .map(baggageEntry => baggageEntry.split('=').map(keyOrValue => decodeURIComponent(keyOrValue.trim())))\n    .reduce((acc, [key, value]) => {\n      acc[key] = value;\n      return acc;\n    }, {});\n}\n\n/**\n * Turns a flat object (key-value pairs) into a baggage header, which is also just key-value pairs.\n *\n * @param object The object to turn into a baggage header.\n * @returns a baggage header string, or `undefined` if the object didn't have any values, since an empty baggage header\n * is not spec compliant.\n */\nfunction objectToBaggageHeader(object) {\n  if (Object.keys(object).length === 0) {\n    // An empty baggage header is not spec compliant: We return undefined.\n    return undefined;\n  }\n\n  return Object.entries(object).reduce((baggageHeader, [objectKey, objectValue], currentIndex) => {\n    const baggageEntry = `${encodeURIComponent(objectKey)}=${encodeURIComponent(objectValue)}`;\n    const newBaggageHeader = currentIndex === 0 ? baggageEntry : `${baggageHeader},${baggageEntry}`;\n    if (newBaggageHeader.length > MAX_BAGGAGE_STRING_LENGTH) {\n      DEBUG_BUILD &&\n        logger.warn(\n          `Not adding key: ${objectKey} with val: ${objectValue} to baggage header due to exceeding baggage size limits.`,\n        );\n      return baggageHeader;\n    } else {\n      return newBaggageHeader;\n    }\n  }, '');\n}\n\nexport { BAGGAGE_HEADER_NAME, MAX_BAGGAGE_STRING_LENGTH, SENTRY_BAGGAGE_KEY_PREFIX, SENTRY_BAGGAGE_KEY_PREFIX_REGEX, baggageHeaderToDynamicSamplingContext, dynamicSamplingContextToSentryBaggageHeader };\n//# sourceMappingURL=baggage.js.map\n","import { isString } from './is.js';\nimport { getGlobalObject } from './worldwide.js';\n\n// eslint-disable-next-line deprecation/deprecation\nconst WINDOW = getGlobalObject();\n\nconst DEFAULT_MAX_STRING_LENGTH = 80;\n\n/**\n * Given a child DOM element, returns a query-selector statement describing that\n * and its ancestors\n * e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nfunction htmlTreeAsString(\n  elem,\n  options = {},\n) {\n  if (!elem) {\n    return '<unknown>';\n  }\n\n  // try/catch both:\n  // - accessing event.target (see getsentry/raven-js#838, #768)\n  // - `htmlTreeAsString` because it's complex, and just accessing the DOM incorrectly\n  // - can throw an exception in some circumstances.\n  try {\n    let currentElem = elem ;\n    const MAX_TRAVERSE_HEIGHT = 5;\n    const out = [];\n    let height = 0;\n    let len = 0;\n    const separator = ' > ';\n    const sepLength = separator.length;\n    let nextStr;\n    const keyAttrs = Array.isArray(options) ? options : options.keyAttrs;\n    const maxStringLength = (!Array.isArray(options) && options.maxStringLength) || DEFAULT_MAX_STRING_LENGTH;\n\n    while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {\n      nextStr = _htmlElementAsString(currentElem, keyAttrs);\n      // bail out if\n      // - nextStr is the 'html' element\n      // - the length of the string that would be created exceeds maxStringLength\n      //   (ignore this limit if we are on the first iteration)\n      if (nextStr === 'html' || (height > 1 && len + out.length * sepLength + nextStr.length >= maxStringLength)) {\n        break;\n      }\n\n      out.push(nextStr);\n\n      len += nextStr.length;\n      currentElem = currentElem.parentNode;\n    }\n\n    return out.reverse().join(separator);\n  } catch (_oO) {\n    return '<unknown>';\n  }\n}\n\n/**\n * Returns a simple, query-selector representation of a DOM element\n * e.g. [HTMLElement] => input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nfunction _htmlElementAsString(el, keyAttrs) {\n  const elem = el\n\n;\n\n  const out = [];\n  let className;\n  let classes;\n  let key;\n  let attr;\n  let i;\n\n  if (!elem || !elem.tagName) {\n    return '';\n  }\n\n  // @ts-expect-error WINDOW has HTMLElement\n  if (WINDOW.HTMLElement) {\n    // If using the component name annotation plugin, this value may be available on the DOM node\n    if (elem instanceof HTMLElement && elem.dataset && elem.dataset['sentryComponent']) {\n      return elem.dataset['sentryComponent'];\n    }\n  }\n\n  out.push(elem.tagName.toLowerCase());\n\n  // Pairs of attribute keys defined in `serializeAttribute` and their values on element.\n  const keyAttrPairs =\n    keyAttrs && keyAttrs.length\n      ? keyAttrs.filter(keyAttr => elem.getAttribute(keyAttr)).map(keyAttr => [keyAttr, elem.getAttribute(keyAttr)])\n      : null;\n\n  if (keyAttrPairs && keyAttrPairs.length) {\n    keyAttrPairs.forEach(keyAttrPair => {\n      out.push(`[${keyAttrPair[0]}=\"${keyAttrPair[1]}\"]`);\n    });\n  } else {\n    if (elem.id) {\n      out.push(`#${elem.id}`);\n    }\n\n    // eslint-disable-next-line prefer-const\n    className = elem.className;\n    if (className && isString(className)) {\n      classes = className.split(/\\s+/);\n      for (i = 0; i < classes.length; i++) {\n        out.push(`.${classes[i]}`);\n      }\n    }\n  }\n  const allowedAttrs = ['aria-label', 'type', 'name', 'title', 'alt'];\n  for (i = 0; i < allowedAttrs.length; i++) {\n    key = allowedAttrs[i];\n    attr = elem.getAttribute(key);\n    if (attr) {\n      out.push(`[${key}=\"${attr}\"]`);\n    }\n  }\n  return out.join('');\n}\n\n/**\n * A safe form of location.href\n */\nfunction getLocationHref() {\n  try {\n    return WINDOW.document.location.href;\n  } catch (oO) {\n    return '';\n  }\n}\n\n/**\n * Gets a DOM element by using document.querySelector.\n *\n * This wrapper will first check for the existance of the function before\n * actually calling it so that we don't have to take care of this check,\n * every time we want to access the DOM.\n *\n * Reason: DOM/querySelector is not available in all environments.\n *\n * We have to cast to any because utils can be consumed by a variety of environments,\n * and we don't want to break TS users. If you know what element will be selected by\n * `document.querySelector`, specify it as part of the generic call. For example,\n * `const element = getDomElement<Element>('selector');`\n *\n * @param selector the selector string passed on to document.querySelector\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction getDomElement(selector) {\n  if (WINDOW.document && WINDOW.document.querySelector) {\n    return WINDOW.document.querySelector(selector) ;\n  }\n  return null;\n}\n\n/**\n * Given a DOM element, traverses up the tree until it finds the first ancestor node\n * that has the `data-sentry-component` attribute. This attribute is added at build-time\n * by projects that have the component name annotation plugin installed.\n *\n * @returns a string representation of the component for the provided DOM element, or `null` if not found\n */\nfunction getComponentName(elem) {\n  // @ts-expect-error WINDOW has HTMLElement\n  if (!WINDOW.HTMLElement) {\n    return null;\n  }\n\n  let currentElem = elem ;\n  const MAX_TRAVERSE_HEIGHT = 5;\n  for (let i = 0; i < MAX_TRAVERSE_HEIGHT; i++) {\n    if (!currentElem) {\n      return null;\n    }\n\n    if (currentElem instanceof HTMLElement && currentElem.dataset['sentryComponent']) {\n      return currentElem.dataset['sentryComponent'];\n    }\n\n    currentElem = currentElem.parentNode;\n  }\n\n  return null;\n}\n\nexport { getComponentName, getDomElement, getLocationHref, htmlTreeAsString };\n//# sourceMappingURL=browser.js.map\n","// https://github.com/alangpierce/sucrase/tree/265887868966917f3b924ce38dfad01fbab1329f\n//\n// The MIT License (MIT)\n//\n// Copyright (c) 2012-2018 various contributors (see AUTHORS)\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n// SOFTWARE.\n\n/**\n * Polyfill for the nullish coalescing operator (`??`).\n *\n * Note that the RHS is wrapped in a function so that if it's a computed value, that evaluation won't happen unless the\n * LHS evaluates to a nullish value, to mimic the operator's short-circuiting behavior.\n *\n * Adapted from Sucrase (https://github.com/alangpierce/sucrase)\n *\n * @param lhs The value of the expression to the left of the `??`\n * @param rhsFn A function returning the value of the expression to the right of the `??`\n * @returns The LHS value, unless it's `null` or `undefined`, in which case, the RHS value\n */\nfunction _nullishCoalesce(lhs, rhsFn) {\n  // by checking for loose equality to `null`, we catch both `null` and `undefined`\n  return lhs != null ? lhs : rhsFn();\n}\n\n// Sucrase version:\n// function _nullishCoalesce(lhs, rhsFn) {\n//   if (lhs != null) {\n//     return lhs;\n//   } else {\n//     return rhsFn();\n//   }\n// }\n\nexport { _nullishCoalesce };\n//# sourceMappingURL=_nullishCoalesce.js.map\n","/**\n * Polyfill for the optional chain operator, `?.`, given previous conversion of the expression into an array of values,\n * descriptors, and functions.\n *\n * Adapted from Sucrase (https://github.com/alangpierce/sucrase)\n * See https://github.com/alangpierce/sucrase/blob/265887868966917f3b924ce38dfad01fbab1329f/src/transformers/OptionalChainingNullishTransformer.ts#L15\n *\n * @param ops Array result of expression conversion\n * @returns The value of the expression\n */\nfunction _optionalChain(ops) {\n  let lastAccessLHS = undefined;\n  let value = ops[0];\n  let i = 1;\n  while (i < ops.length) {\n    const op = ops[i] ;\n    const fn = ops[i + 1] ;\n    i += 2;\n    // by checking for loose equality to `null`, we catch both `null` and `undefined`\n    if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) {\n      // really we're meaning to return `undefined` as an actual value here, but it saves bytes not to write it\n      return;\n    }\n    if (op === 'access' || op === 'optionalAccess') {\n      lastAccessLHS = value;\n      value = fn(value);\n    } else if (op === 'call' || op === 'optionalCall') {\n      value = fn((...args) => (value ).call(lastAccessLHS, ...args));\n      lastAccessLHS = undefined;\n    }\n  }\n  return value;\n}\n\n// Sucrase version\n// function _optionalChain(ops) {\n//   let lastAccessLHS = undefined;\n//   let value = ops[0];\n//   let i = 1;\n//   while (i < ops.length) {\n//     const op = ops[i];\n//     const fn = ops[i + 1];\n//     i += 2;\n//     if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) {\n//       return undefined;\n//     }\n//     if (op === 'access' || op === 'optionalAccess') {\n//       lastAccessLHS = value;\n//       value = fn(value);\n//     } else if (op === 'call' || op === 'optionalCall') {\n//       value = fn((...args) => value.call(lastAccessLHS, ...args));\n//       lastAccessLHS = undefined;\n//     }\n//   }\n//   return value;\n// }\n\nexport { _optionalChain };\n//# sourceMappingURL=_optionalChain.js.map\n","import { createEnvelope } from './envelope.js';\nimport { dateTimestampInSeconds } from './time.js';\n\n/**\n * Creates client report envelope\n * @param discarded_events An array of discard events\n * @param dsn A DSN that can be set on the header. Optional.\n */\nfunction createClientReportEnvelope(\n  discarded_events,\n  dsn,\n  timestamp,\n) {\n  const clientReportItem = [\n    { type: 'client_report' },\n    {\n      timestamp: timestamp || dateTimestampInSeconds(),\n      discarded_events,\n    },\n  ];\n  return createEnvelope(dsn ? { dsn } : {}, [clientReportItem]);\n}\n\nexport { createClientReportEnvelope };\n//# sourceMappingURL=clientreport.js.map\n","/**\n * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.\n *\n * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.\n */\nconst DEBUG_BUILD = (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__);\n\nexport { DEBUG_BUILD };\n//# sourceMappingURL=debug-build.js.map\n","import { DEBUG_BUILD } from './debug-build.js';\nimport { consoleSandbox, logger } from './logger.js';\n\n/** Regular expression used to parse a Dsn. */\nconst DSN_REGEX = /^(?:(\\w+):)\\/\\/(?:(\\w+)(?::(\\w+)?)?@)([\\w.-]+)(?::(\\d+))?\\/(.+)/;\n\nfunction isValidProtocol(protocol) {\n  return protocol === 'http' || protocol === 'https';\n}\n\n/**\n * Renders the string representation of this Dsn.\n *\n * By default, this will render the public representation without the password\n * component. To get the deprecated private representation, set `withPassword`\n * to true.\n *\n * @param withPassword When set to true, the password will be included.\n */\nfunction dsnToString(dsn, withPassword = false) {\n  const { host, path, pass, port, projectId, protocol, publicKey } = dsn;\n  return (\n    `${protocol}://${publicKey}${withPassword && pass ? `:${pass}` : ''}` +\n    `@${host}${port ? `:${port}` : ''}/${path ? `${path}/` : path}${projectId}`\n  );\n}\n\n/**\n * Parses a Dsn from a given string.\n *\n * @param str A Dsn as string\n * @returns Dsn as DsnComponents or undefined if @param str is not a valid DSN string\n */\nfunction dsnFromString(str) {\n  const match = DSN_REGEX.exec(str);\n\n  if (!match) {\n    // This should be logged to the console\n    consoleSandbox(() => {\n      // eslint-disable-next-line no-console\n      console.error(`Invalid Sentry Dsn: ${str}`);\n    });\n    return undefined;\n  }\n\n  const [protocol, publicKey, pass = '', host, port = '', lastPath] = match.slice(1);\n  let path = '';\n  let projectId = lastPath;\n\n  const split = projectId.split('/');\n  if (split.length > 1) {\n    path = split.slice(0, -1).join('/');\n    projectId = split.pop() ;\n  }\n\n  if (projectId) {\n    const projectMatch = projectId.match(/^\\d+/);\n    if (projectMatch) {\n      projectId = projectMatch[0];\n    }\n  }\n\n  return dsnFromComponents({ host, pass, path, projectId, port, protocol: protocol , publicKey });\n}\n\nfunction dsnFromComponents(components) {\n  return {\n    protocol: components.protocol,\n    publicKey: components.publicKey || '',\n    pass: components.pass || '',\n    host: components.host,\n    port: components.port || '',\n    path: components.path || '',\n    projectId: components.projectId,\n  };\n}\n\nfunction validateDsn(dsn) {\n  if (!DEBUG_BUILD) {\n    return true;\n  }\n\n  const { port, projectId, protocol } = dsn;\n\n  const requiredComponents = ['protocol', 'publicKey', 'host', 'projectId'];\n  const hasMissingRequiredComponent = requiredComponents.find(component => {\n    if (!dsn[component]) {\n      logger.error(`Invalid Sentry Dsn: ${component} missing`);\n      return true;\n    }\n    return false;\n  });\n\n  if (hasMissingRequiredComponent) {\n    return false;\n  }\n\n  if (!projectId.match(/^\\d+$/)) {\n    logger.error(`Invalid Sentry Dsn: Invalid projectId ${projectId}`);\n    return false;\n  }\n\n  if (!isValidProtocol(protocol)) {\n    logger.error(`Invalid Sentry Dsn: Invalid protocol ${protocol}`);\n    return false;\n  }\n\n  if (port && isNaN(parseInt(port, 10))) {\n    logger.error(`Invalid Sentry Dsn: Invalid port ${port}`);\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Creates a valid Sentry Dsn object, identifying a Sentry instance and project.\n * @returns a valid DsnComponents object or `undefined` if @param from is an invalid DSN source\n */\nfunction makeDsn(from) {\n  const components = typeof from === 'string' ? dsnFromString(from) : dsnFromComponents(from);\n  if (!components || !validateDsn(components)) {\n    return undefined;\n  }\n  return components;\n}\n\nexport { dsnFromString, dsnToString, makeDsn };\n//# sourceMappingURL=dsn.js.map\n","/*\n * This module exists for optimizations in the build process through rollup and terser.  We define some global\n * constants, which can be overridden during build. By guarding certain pieces of code with functions that return these\n * constants, we can control whether or not they appear in the final bundle. (Any code guarded by a false condition will\n * never run, and will hence be dropped during treeshaking.) The two primary uses for this are stripping out calls to\n * `logger` and preventing node-related code from appearing in browser bundles.\n *\n * Attention:\n * This file should not be used to define constants/flags that are intended to be used for tree-shaking conducted by\n * users. These flags should live in their respective packages, as we identified user tooling (specifically webpack)\n * having issues tree-shaking these constants across package boundaries.\n * An example for this is the __SENTRY_DEBUG__ constant. It is declared in each package individually because we want\n * users to be able to shake away expressions that it guards.\n */\n\n/**\n * Figures out if we're building a browser bundle.\n *\n * @returns true if this is a browser bundle build.\n */\nfunction isBrowserBundle() {\n  return typeof __SENTRY_BROWSER_BUNDLE__ !== 'undefined' && !!__SENTRY_BROWSER_BUNDLE__;\n}\n\n/**\n * Get source of SDK.\n */\nfunction getSDKSource() {\n  // @ts-expect-error \"npm\" is injected by rollup during build process\n  return \"npm\";\n}\n\nexport { getSDKSource, isBrowserBundle };\n//# sourceMappingURL=env.js.map\n","import { dsnToString } from './dsn.js';\nimport { normalize } from './normalize.js';\nimport { dropUndefinedKeys } from './object.js';\n\n/**\n * Creates an envelope.\n * Make sure to always explicitly provide the generic to this function\n * so that the envelope types resolve correctly.\n */\nfunction createEnvelope(headers, items = []) {\n  return [headers, items] ;\n}\n\n/**\n * Add an item to an envelope.\n * Make sure to always explicitly provide the generic to this function\n * so that the envelope types resolve correctly.\n */\nfunction addItemToEnvelope(envelope, newItem) {\n  const [headers, items] = envelope;\n  return [headers, [...items, newItem]] ;\n}\n\n/**\n * Convenience function to loop through the items and item types of an envelope.\n * (This function was mostly created because working with envelope types is painful at the moment)\n *\n * If the callback returns true, the rest of the items will be skipped.\n */\nfunction forEachEnvelopeItem(\n  envelope,\n  callback,\n) {\n  const envelopeItems = envelope[1];\n\n  for (const envelopeItem of envelopeItems) {\n    const envelopeItemType = envelopeItem[0].type;\n    const result = callback(envelopeItem, envelopeItemType);\n\n    if (result) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/**\n * Returns true if the envelope contains any of the given envelope item types\n */\nfunction envelopeContainsItemType(envelope, types) {\n  return forEachEnvelopeItem(envelope, (_, type) => types.includes(type));\n}\n\n/**\n * Encode a string to UTF8.\n */\nfunction encodeUTF8(input, textEncoder) {\n  const utf8 = textEncoder || new TextEncoder();\n  return utf8.encode(input);\n}\n\n/**\n * Serializes an envelope.\n */\nfunction serializeEnvelope(envelope, textEncoder) {\n  const [envHeaders, items] = envelope;\n\n  // Initially we construct our envelope as a string and only convert to binary chunks if we encounter binary data\n  let parts = JSON.stringify(envHeaders);\n\n  function append(next) {\n    if (typeof parts === 'string') {\n      parts = typeof next === 'string' ? parts + next : [encodeUTF8(parts, textEncoder), next];\n    } else {\n      parts.push(typeof next === 'string' ? encodeUTF8(next, textEncoder) : next);\n    }\n  }\n\n  for (const item of items) {\n    const [itemHeaders, payload] = item;\n\n    append(`\\n${JSON.stringify(itemHeaders)}\\n`);\n\n    if (typeof payload === 'string' || payload instanceof Uint8Array) {\n      append(payload);\n    } else {\n      let stringifiedPayload;\n      try {\n        stringifiedPayload = JSON.stringify(payload);\n      } catch (e) {\n        // In case, despite all our efforts to keep `payload` circular-dependency-free, `JSON.strinify()` still\n        // fails, we try again after normalizing it again with infinite normalization depth. This of course has a\n        // performance impact but in this case a performance hit is better than throwing.\n        stringifiedPayload = JSON.stringify(normalize(payload));\n      }\n      append(stringifiedPayload);\n    }\n  }\n\n  return typeof parts === 'string' ? parts : concatBuffers(parts);\n}\n\nfunction concatBuffers(buffers) {\n  const totalLength = buffers.reduce((acc, buf) => acc + buf.length, 0);\n\n  const merged = new Uint8Array(totalLength);\n  let offset = 0;\n  for (const buffer of buffers) {\n    merged.set(buffer, offset);\n    offset += buffer.length;\n  }\n\n  return merged;\n}\n\n/**\n * Parses an envelope\n */\nfunction parseEnvelope(\n  env,\n  textEncoder,\n  textDecoder,\n) {\n  let buffer = typeof env === 'string' ? textEncoder.encode(env) : env;\n\n  function readBinary(length) {\n    const bin = buffer.subarray(0, length);\n    // Replace the buffer with the remaining data excluding trailing newline\n    buffer = buffer.subarray(length + 1);\n    return bin;\n  }\n\n  function readJson() {\n    let i = buffer.indexOf(0xa);\n    // If we couldn't find a newline, we must have found the end of the buffer\n    if (i < 0) {\n      i = buffer.length;\n    }\n\n    return JSON.parse(textDecoder.decode(readBinary(i))) ;\n  }\n\n  const envelopeHeader = readJson();\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const items = [];\n\n  while (buffer.length) {\n    const itemHeader = readJson();\n    const binaryLength = typeof itemHeader.length === 'number' ? itemHeader.length : undefined;\n\n    items.push([itemHeader, binaryLength ? readBinary(binaryLength) : readJson()]);\n  }\n\n  return [envelopeHeader, items];\n}\n\n/**\n * Creates attachment envelope items\n */\nfunction createAttachmentEnvelopeItem(\n  attachment,\n  textEncoder,\n) {\n  const buffer = typeof attachment.data === 'string' ? encodeUTF8(attachment.data, textEncoder) : attachment.data;\n\n  return [\n    dropUndefinedKeys({\n      type: 'attachment',\n      length: buffer.length,\n      filename: attachment.filename,\n      content_type: attachment.contentType,\n      attachment_type: attachment.attachmentType,\n    }),\n    buffer,\n  ];\n}\n\nconst ITEM_TYPE_TO_DATA_CATEGORY_MAP = {\n  session: 'session',\n  sessions: 'session',\n  attachment: 'attachment',\n  transaction: 'transaction',\n  event: 'error',\n  client_report: 'internal',\n  user_report: 'default',\n  profile: 'profile',\n  replay_event: 'replay',\n  replay_recording: 'replay',\n  check_in: 'monitor',\n  feedback: 'feedback',\n  span: 'span',\n  statsd: 'metric_bucket',\n};\n\n/**\n * Maps the type of an envelope item to a data category.\n */\nfunction envelopeItemTypeToDataCategory(type) {\n  return ITEM_TYPE_TO_DATA_CATEGORY_MAP[type];\n}\n\n/** Extracts the minimal SDK info from the metadata or an events */\nfunction getSdkMetadataForEnvelopeHeader(metadataOrEvent) {\n  if (!metadataOrEvent || !metadataOrEvent.sdk) {\n    return;\n  }\n  const { name, version } = metadataOrEvent.sdk;\n  return { name, version };\n}\n\n/**\n * Creates event envelope headers, based on event, sdk info and tunnel\n * Note: This function was extracted from the core package to make it available in Replay\n */\nfunction createEventEnvelopeHeaders(\n  event,\n  sdkInfo,\n  tunnel,\n  dsn,\n) {\n  const dynamicSamplingContext = event.sdkProcessingMetadata && event.sdkProcessingMetadata.dynamicSamplingContext;\n  return {\n    event_id: event.event_id ,\n    sent_at: new Date().toISOString(),\n    ...(sdkInfo && { sdk: sdkInfo }),\n    ...(!!tunnel && dsn && { dsn: dsnToString(dsn) }),\n    ...(dynamicSamplingContext && {\n      trace: dropUndefinedKeys({ ...dynamicSamplingContext }),\n    }),\n  };\n}\n\nexport { addItemToEnvelope, createAttachmentEnvelopeItem, createEnvelope, createEventEnvelopeHeaders, envelopeContainsItemType, envelopeItemTypeToDataCategory, forEachEnvelopeItem, getSdkMetadataForEnvelopeHeader, parseEnvelope, serializeEnvelope };\n//# sourceMappingURL=envelope.js.map\n","/** An error emitted by Sentry SDKs and related utilities. */\nclass SentryError extends Error {\n  /** Display name of this error instance. */\n\n   constructor( message, logLevel = 'warn') {\n    super(message);this.message = message;\n    this.name = new.target.prototype.constructor.name;\n    // This sets the prototype to be `Error`, not `SentryError`. It's unclear why we do this, but commenting this line\n    // out causes various (seemingly totally unrelated) playwright tests consistently time out. FYI, this makes\n    // instances of `SentryError` fail `obj instanceof SentryError` checks.\n    Object.setPrototypeOf(this, new.target.prototype);\n    this.logLevel = logLevel;\n  }\n}\n\nexport { SentryError };\n//# sourceMappingURL=error.js.map\n","import { isError, isPlainObject, isParameterizedString } from './is.js';\nimport { addExceptionTypeValue, addExceptionMechanism } from './misc.js';\nimport { normalizeToSize } from './normalize.js';\nimport { extractExceptionKeysForMessage } from './object.js';\n\n/**\n * Extracts stack frames from the error.stack string\n */\nfunction parseStackFrames(stackParser, error) {\n  return stackParser(error.stack || '', 1);\n}\n\n/**\n * Extracts stack frames from the error and builds a Sentry Exception\n */\nfunction exceptionFromError(stackParser, error) {\n  const exception = {\n    type: error.name || error.constructor.name,\n    value: error.message,\n  };\n\n  const frames = parseStackFrames(stackParser, error);\n  if (frames.length) {\n    exception.stacktrace = { frames };\n  }\n\n  return exception;\n}\n\nfunction getMessageForObject(exception) {\n  if ('name' in exception && typeof exception.name === 'string') {\n    let message = `'${exception.name}' captured as exception`;\n\n    if ('message' in exception && typeof exception.message === 'string') {\n      message += ` with message '${exception.message}'`;\n    }\n\n    return message;\n  } else if ('message' in exception && typeof exception.message === 'string') {\n    return exception.message;\n  } else {\n    // This will allow us to group events based on top-level keys\n    // which is much better than creating new group when any key/value change\n    return `Object captured as exception with keys: ${extractExceptionKeysForMessage(\n      exception ,\n    )}`;\n  }\n}\n\n/**\n * Builds and Event from a Exception\n *\n * TODO(v8): Remove getHub fallback\n * @hidden\n */\nfunction eventFromUnknownInput(\n  // eslint-disable-next-line deprecation/deprecation\n  getHubOrClient,\n  stackParser,\n  exception,\n  hint,\n) {\n  const client =\n    typeof getHubOrClient === 'function'\n      ? // eslint-disable-next-line deprecation/deprecation\n        getHubOrClient().getClient()\n      : getHubOrClient;\n\n  let ex = exception;\n  const providedMechanism =\n    hint && hint.data && (hint.data ).mechanism;\n  const mechanism = providedMechanism || {\n    handled: true,\n    type: 'generic',\n  };\n\n  let extras;\n\n  if (!isError(exception)) {\n    if (isPlainObject(exception)) {\n      const normalizeDepth = client && client.getOptions().normalizeDepth;\n      extras = { ['__serialized__']: normalizeToSize(exception , normalizeDepth) };\n\n      const message = getMessageForObject(exception);\n      ex = (hint && hint.syntheticException) || new Error(message);\n      (ex ).message = message;\n    } else {\n      // This handles when someone does: `throw \"something awesome\";`\n      // We use synthesized Error here so we can extract a (rough) stack trace.\n      ex = (hint && hint.syntheticException) || new Error(exception );\n      (ex ).message = exception ;\n    }\n    mechanism.synthetic = true;\n  }\n\n  const event = {\n    exception: {\n      values: [exceptionFromError(stackParser, ex )],\n    },\n  };\n\n  if (extras) {\n    event.extra = extras;\n  }\n\n  addExceptionTypeValue(event, undefined, undefined);\n  addExceptionMechanism(event, mechanism);\n\n  return {\n    ...event,\n    event_id: hint && hint.event_id,\n  };\n}\n\n/**\n * Builds and Event from a Message\n * @hidden\n */\nfunction eventFromMessage(\n  stackParser,\n  message,\n  // eslint-disable-next-line deprecation/deprecation\n  level = 'info',\n  hint,\n  attachStacktrace,\n) {\n  const event = {\n    event_id: hint && hint.event_id,\n    level,\n  };\n\n  if (attachStacktrace && hint && hint.syntheticException) {\n    const frames = parseStackFrames(stackParser, hint.syntheticException);\n    if (frames.length) {\n      event.exception = {\n        values: [\n          {\n            value: message,\n            stacktrace: { frames },\n          },\n        ],\n      };\n    }\n  }\n\n  if (isParameterizedString(message)) {\n    const { __sentry_template_string__, __sentry_template_values__ } = message;\n\n    event.logentry = {\n      message: __sentry_template_string__,\n      params: __sentry_template_values__,\n    };\n    return event;\n  }\n\n  event.message = message;\n  return event;\n}\n\nexport { eventFromMessage, eventFromUnknownInput, exceptionFromError, parseStackFrames };\n//# sourceMappingURL=eventbuilder.js.map\n","import { DEBUG_BUILD } from '../debug-build.js';\nimport { logger } from '../logger.js';\nimport { getFunctionName } from '../stacktrace.js';\n\n// We keep the handlers globally\nconst handlers = {};\nconst instrumented = {};\n\n/** Add a handler function. */\nfunction addHandler(type, handler) {\n  handlers[type] = handlers[type] || [];\n  (handlers[type] ).push(handler);\n}\n\n/**\n * Reset all instrumentation handlers.\n * This can be used by tests to ensure we have a clean slate of instrumentation handlers.\n */\nfunction resetInstrumentationHandlers() {\n  Object.keys(handlers).forEach(key => {\n    handlers[key ] = undefined;\n  });\n}\n\n/** Maybe run an instrumentation function, unless it was already called. */\nfunction maybeInstrument(type, instrumentFn) {\n  if (!instrumented[type]) {\n    instrumentFn();\n    instrumented[type] = true;\n  }\n}\n\n/** Trigger handlers for a given instrumentation type. */\nfunction triggerHandlers(type, data) {\n  const typeHandlers = type && handlers[type];\n  if (!typeHandlers) {\n    return;\n  }\n\n  for (const handler of typeHandlers) {\n    try {\n      handler(data);\n    } catch (e) {\n      DEBUG_BUILD &&\n        logger.error(\n          `Error while triggering instrumentation handler.\\nType: ${type}\\nName: ${getFunctionName(handler)}\\nError:`,\n          e,\n        );\n    }\n  }\n}\n\nexport { addHandler, maybeInstrument, resetInstrumentationHandlers, triggerHandlers };\n//# sourceMappingURL=_handlers.js.map\n","import { CONSOLE_LEVELS, originalConsoleMethods } from '../logger.js';\nimport { fill } from '../object.js';\nimport { GLOBAL_OBJ } from '../worldwide.js';\nimport { addHandler, maybeInstrument, triggerHandlers } from './_handlers.js';\n\n/**\n * Add an instrumentation handler for when a console.xxx method is called.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addConsoleInstrumentationHandler(handler) {\n  const type = 'console';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentConsole);\n}\n\nfunction instrumentConsole() {\n  if (!('console' in GLOBAL_OBJ)) {\n    return;\n  }\n\n  CONSOLE_LEVELS.forEach(function (level) {\n    if (!(level in GLOBAL_OBJ.console)) {\n      return;\n    }\n\n    fill(GLOBAL_OBJ.console, level, function (originalConsoleMethod) {\n      originalConsoleMethods[level] = originalConsoleMethod;\n\n      return function (...args) {\n        const handlerData = { args, level };\n        triggerHandlers('console', handlerData);\n\n        const log = originalConsoleMethods[level];\n        log && log.apply(GLOBAL_OBJ.console, args);\n      };\n    });\n  });\n}\n\nexport { addConsoleInstrumentationHandler };\n//# sourceMappingURL=console.js.map\n","import { uuid4 } from '../misc.js';\nimport { fill, addNonEnumerableProperty } from '../object.js';\nimport { GLOBAL_OBJ } from '../worldwide.js';\nimport { addHandler, maybeInstrument, triggerHandlers } from './_handlers.js';\n\nconst WINDOW = GLOBAL_OBJ ;\nconst DEBOUNCE_DURATION = 1000;\n\nlet debounceTimerID;\nlet lastCapturedEventType;\nlet lastCapturedEventTargetId;\n\n/**\n * Add an instrumentation handler for when a click or a keypress happens.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addClickKeypressInstrumentationHandler(handler) {\n  const type = 'dom';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentDOM);\n}\n\n/** Exported for tests only. */\nfunction instrumentDOM() {\n  if (!WINDOW.document) {\n    return;\n  }\n\n  // Make it so that any click or keypress that is unhandled / bubbled up all the way to the document triggers our dom\n  // handlers. (Normally we have only one, which captures a breadcrumb for each click or keypress.) Do this before\n  // we instrument `addEventListener` so that we don't end up attaching this handler twice.\n  const triggerDOMHandler = triggerHandlers.bind(null, 'dom');\n  const globalDOMEventHandler = makeDOMEventHandler(triggerDOMHandler, true);\n  WINDOW.document.addEventListener('click', globalDOMEventHandler, false);\n  WINDOW.document.addEventListener('keypress', globalDOMEventHandler, false);\n\n  // After hooking into click and keypress events bubbled up to `document`, we also hook into user-handled\n  // clicks & keypresses, by adding an event listener of our own to any element to which they add a listener. That\n  // way, whenever one of their handlers is triggered, ours will be, too. (This is needed because their handler\n  // could potentially prevent the event from bubbling up to our global listeners. This way, our handler are still\n  // guaranteed to fire at least once.)\n  ['EventTarget', 'Node'].forEach((target) => {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    const proto = (WINDOW )[target] && (WINDOW )[target].prototype;\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-prototype-builtins\n    if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n      return;\n    }\n\n    fill(proto, 'addEventListener', function (originalAddEventListener) {\n      return function (\n\n        type,\n        listener,\n        options,\n      ) {\n        if (type === 'click' || type == 'keypress') {\n          try {\n            const el = this ;\n            const handlers = (el.__sentry_instrumentation_handlers__ = el.__sentry_instrumentation_handlers__ || {});\n            const handlerForType = (handlers[type] = handlers[type] || { refCount: 0 });\n\n            if (!handlerForType.handler) {\n              const handler = makeDOMEventHandler(triggerDOMHandler);\n              handlerForType.handler = handler;\n              originalAddEventListener.call(this, type, handler, options);\n            }\n\n            handlerForType.refCount++;\n          } catch (e) {\n            // Accessing dom properties is always fragile.\n            // Also allows us to skip `addEventListenrs` calls with no proper `this` context.\n          }\n        }\n\n        return originalAddEventListener.call(this, type, listener, options);\n      };\n    });\n\n    fill(\n      proto,\n      'removeEventListener',\n      function (originalRemoveEventListener) {\n        return function (\n\n          type,\n          listener,\n          options,\n        ) {\n          if (type === 'click' || type == 'keypress') {\n            try {\n              const el = this ;\n              const handlers = el.__sentry_instrumentation_handlers__ || {};\n              const handlerForType = handlers[type];\n\n              if (handlerForType) {\n                handlerForType.refCount--;\n                // If there are no longer any custom handlers of the current type on this element, we can remove ours, too.\n                if (handlerForType.refCount <= 0) {\n                  originalRemoveEventListener.call(this, type, handlerForType.handler, options);\n                  handlerForType.handler = undefined;\n                  delete handlers[type]; // eslint-disable-line @typescript-eslint/no-dynamic-delete\n                }\n\n                // If there are no longer any custom handlers of any type on this element, cleanup everything.\n                if (Object.keys(handlers).length === 0) {\n                  delete el.__sentry_instrumentation_handlers__;\n                }\n              }\n            } catch (e) {\n              // Accessing dom properties is always fragile.\n              // Also allows us to skip `addEventListenrs` calls with no proper `this` context.\n            }\n          }\n\n          return originalRemoveEventListener.call(this, type, listener, options);\n        };\n      },\n    );\n  });\n}\n\n/**\n * Check whether the event is similar to the last captured one. For example, two click events on the same button.\n */\nfunction isSimilarToLastCapturedEvent(event) {\n  // If both events have different type, then user definitely performed two separate actions. e.g. click + keypress.\n  if (event.type !== lastCapturedEventType) {\n    return false;\n  }\n\n  try {\n    // If both events have the same type, it's still possible that actions were performed on different targets.\n    // e.g. 2 clicks on different buttons.\n    if (!event.target || (event.target )._sentryId !== lastCapturedEventTargetId) {\n      return false;\n    }\n  } catch (e) {\n    // just accessing `target` property can throw an exception in some rare circumstances\n    // see: https://github.com/getsentry/sentry-javascript/issues/838\n  }\n\n  // If both events have the same type _and_ same `target` (an element which triggered an event, _not necessarily_\n  // to which an event listener was attached), we treat them as the same action, as we want to capture\n  // only one breadcrumb. e.g. multiple clicks on the same button, or typing inside a user input box.\n  return true;\n}\n\n/**\n * Decide whether an event should be captured.\n * @param event event to be captured\n */\nfunction shouldSkipDOMEvent(eventType, target) {\n  // We are only interested in filtering `keypress` events for now.\n  if (eventType !== 'keypress') {\n    return false;\n  }\n\n  if (!target || !target.tagName) {\n    return true;\n  }\n\n  // Only consider keypress events on actual input elements. This will disregard keypresses targeting body\n  // e.g.tabbing through elements, hotkeys, etc.\n  if (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable) {\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Wraps addEventListener to capture UI breadcrumbs\n */\nfunction makeDOMEventHandler(\n  handler,\n  globalListener = false,\n) {\n  return (event) => {\n    // It's possible this handler might trigger multiple times for the same\n    // event (e.g. event propagation through node ancestors).\n    // Ignore if we've already captured that event.\n    if (!event || event['_sentryCaptured']) {\n      return;\n    }\n\n    const target = getEventTarget(event);\n\n    // We always want to skip _some_ events.\n    if (shouldSkipDOMEvent(event.type, target)) {\n      return;\n    }\n\n    // Mark event as \"seen\"\n    addNonEnumerableProperty(event, '_sentryCaptured', true);\n\n    if (target && !target._sentryId) {\n      // Add UUID to event target so we can identify if\n      addNonEnumerableProperty(target, '_sentryId', uuid4());\n    }\n\n    const name = event.type === 'keypress' ? 'input' : event.type;\n\n    // If there is no last captured event, it means that we can safely capture the new event and store it for future comparisons.\n    // If there is a last captured event, see if the new event is different enough to treat it as a unique one.\n    // If that's the case, emit the previous event and store locally the newly-captured DOM event.\n    if (!isSimilarToLastCapturedEvent(event)) {\n      const handlerData = { event, name, global: globalListener };\n      handler(handlerData);\n      lastCapturedEventType = event.type;\n      lastCapturedEventTargetId = target ? target._sentryId : undefined;\n    }\n\n    // Start a new debounce timer that will prevent us from capturing multiple events that should be grouped together.\n    clearTimeout(debounceTimerID);\n    debounceTimerID = WINDOW.setTimeout(() => {\n      lastCapturedEventTargetId = undefined;\n      lastCapturedEventType = undefined;\n    }, DEBOUNCE_DURATION);\n  };\n}\n\nfunction getEventTarget(event) {\n  try {\n    return event.target ;\n  } catch (e) {\n    // just accessing `target` property can throw an exception in some rare circumstances\n    // see: https://github.com/getsentry/sentry-javascript/issues/838\n    return null;\n  }\n}\n\nexport { addClickKeypressInstrumentationHandler, instrumentDOM };\n//# sourceMappingURL=dom.js.map\n","import { fill } from '../object.js';\nimport { supportsNativeFetch } from '../supports.js';\nimport { GLOBAL_OBJ } from '../worldwide.js';\nimport { addHandler, maybeInstrument, triggerHandlers } from './_handlers.js';\n\n/**\n * Add an instrumentation handler for when a fetch request happens.\n * The handler function is called once when the request starts and once when it ends,\n * which can be identified by checking if it has an `endTimestamp`.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addFetchInstrumentationHandler(handler) {\n  const type = 'fetch';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentFetch);\n}\n\nfunction instrumentFetch() {\n  if (!supportsNativeFetch()) {\n    return;\n  }\n\n  fill(GLOBAL_OBJ, 'fetch', function (originalFetch) {\n    return function (...args) {\n      const { method, url } = parseFetchArgs(args);\n\n      const handlerData = {\n        args,\n        fetchData: {\n          method,\n          url,\n        },\n        startTimestamp: Date.now(),\n      };\n\n      triggerHandlers('fetch', {\n        ...handlerData,\n      });\n\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n      return originalFetch.apply(GLOBAL_OBJ, args).then(\n        (response) => {\n          const finishedHandlerData = {\n            ...handlerData,\n            endTimestamp: Date.now(),\n            response,\n          };\n\n          triggerHandlers('fetch', finishedHandlerData);\n          return response;\n        },\n        (error) => {\n          const erroredHandlerData = {\n            ...handlerData,\n            endTimestamp: Date.now(),\n            error,\n          };\n\n          triggerHandlers('fetch', erroredHandlerData);\n          // NOTE: If you are a Sentry user, and you are seeing this stack frame,\n          //       it means the sentry.javascript SDK caught an error invoking your application code.\n          //       This is expected behavior and NOT indicative of a bug with sentry.javascript.\n          throw error;\n        },\n      );\n    };\n  });\n}\n\nfunction hasProp(obj, prop) {\n  return !!obj && typeof obj === 'object' && !!(obj )[prop];\n}\n\nfunction getUrlFromResource(resource) {\n  if (typeof resource === 'string') {\n    return resource;\n  }\n\n  if (!resource) {\n    return '';\n  }\n\n  if (hasProp(resource, 'url')) {\n    return resource.url;\n  }\n\n  if (resource.toString) {\n    return resource.toString();\n  }\n\n  return '';\n}\n\n/**\n * Parses the fetch arguments to find the used Http method and the url of the request.\n * Exported for tests only.\n */\nfunction parseFetchArgs(fetchArgs) {\n  if (fetchArgs.length === 0) {\n    return { method: 'GET', url: '' };\n  }\n\n  if (fetchArgs.length === 2) {\n    const [url, options] = fetchArgs ;\n\n    return {\n      url: getUrlFromResource(url),\n      method: hasProp(options, 'method') ? String(options.method).toUpperCase() : 'GET',\n    };\n  }\n\n  const arg = fetchArgs[0];\n  return {\n    url: getUrlFromResource(arg ),\n    method: hasProp(arg, 'method') ? String(arg.method).toUpperCase() : 'GET',\n  };\n}\n\nexport { addFetchInstrumentationHandler, parseFetchArgs };\n//# sourceMappingURL=fetch.js.map\n","import { GLOBAL_OBJ } from '../worldwide.js';\nimport { addHandler, maybeInstrument, triggerHandlers } from './_handlers.js';\n\nlet _oldOnErrorHandler = null;\n\n/**\n * Add an instrumentation handler for when an error is captured by the global error handler.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addGlobalErrorInstrumentationHandler(handler) {\n  const type = 'error';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentError);\n}\n\nfunction instrumentError() {\n  _oldOnErrorHandler = GLOBAL_OBJ.onerror;\n\n  GLOBAL_OBJ.onerror = function (\n    msg,\n    url,\n    line,\n    column,\n    error,\n  ) {\n    const handlerData = {\n      column,\n      error,\n      line,\n      msg,\n      url,\n    };\n    triggerHandlers('error', handlerData);\n\n    if (_oldOnErrorHandler && !_oldOnErrorHandler.__SENTRY_LOADER__) {\n      // eslint-disable-next-line prefer-rest-params\n      return _oldOnErrorHandler.apply(this, arguments);\n    }\n\n    return false;\n  };\n\n  GLOBAL_OBJ.onerror.__SENTRY_INSTRUMENTED__ = true;\n}\n\nexport { addGlobalErrorInstrumentationHandler };\n//# sourceMappingURL=globalError.js.map\n","import { GLOBAL_OBJ } from '../worldwide.js';\nimport { addHandler, maybeInstrument, triggerHandlers } from './_handlers.js';\n\nlet _oldOnUnhandledRejectionHandler = null;\n\n/**\n * Add an instrumentation handler for when an unhandled promise rejection is captured.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addGlobalUnhandledRejectionInstrumentationHandler(\n  handler,\n) {\n  const type = 'unhandledrejection';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentUnhandledRejection);\n}\n\nfunction instrumentUnhandledRejection() {\n  _oldOnUnhandledRejectionHandler = GLOBAL_OBJ.onunhandledrejection;\n\n  GLOBAL_OBJ.onunhandledrejection = function (e) {\n    const handlerData = e;\n    triggerHandlers('unhandledrejection', handlerData);\n\n    if (_oldOnUnhandledRejectionHandler && !_oldOnUnhandledRejectionHandler.__SENTRY_LOADER__) {\n      // eslint-disable-next-line prefer-rest-params\n      return _oldOnUnhandledRejectionHandler.apply(this, arguments);\n    }\n\n    return true;\n  };\n\n  GLOBAL_OBJ.onunhandledrejection.__SENTRY_INSTRUMENTED__ = true;\n}\n\nexport { addGlobalUnhandledRejectionInstrumentationHandler };\n//# sourceMappingURL=globalUnhandledRejection.js.map\n","import { getGlobalObject } from '../worldwide.js';\n\n// Based on https://github.com/angular/angular.js/pull/13945/files\n\n// eslint-disable-next-line deprecation/deprecation\nconst WINDOW = getGlobalObject();\n\n/**\n * Tells whether current environment supports History API\n * {@link supportsHistory}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsHistory() {\n  // NOTE: in Chrome App environment, touching history.pushState, *even inside\n  //       a try/catch block*, will cause Chrome to output an error to console.error\n  // borrowed from: https://github.com/angular/angular.js/pull/13945/files\n  /* eslint-disable @typescript-eslint/no-unsafe-member-access */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const chromeVar = (WINDOW ).chrome;\n  const isChromePackagedApp = chromeVar && chromeVar.app && chromeVar.app.runtime;\n  /* eslint-enable @typescript-eslint/no-unsafe-member-access */\n  const hasHistoryApi = 'history' in WINDOW && !!WINDOW.history.pushState && !!WINDOW.history.replaceState;\n\n  return !isChromePackagedApp && hasHistoryApi;\n}\n\nexport { supportsHistory };\n//# sourceMappingURL=supportsHistory.js.map\n","import { fill } from '../object.js';\nimport '../debug-build.js';\nimport '../logger.js';\nimport { GLOBAL_OBJ } from '../worldwide.js';\nimport { supportsHistory } from '../vendor/supportsHistory.js';\nimport { addHandler, maybeInstrument, triggerHandlers } from './_handlers.js';\n\nconst WINDOW = GLOBAL_OBJ ;\n\nlet lastHref;\n\n/**\n * Add an instrumentation handler for when a fetch request happens.\n * The handler function is called once when the request starts and once when it ends,\n * which can be identified by checking if it has an `endTimestamp`.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addHistoryInstrumentationHandler(handler) {\n  const type = 'history';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentHistory);\n}\n\nfunction instrumentHistory() {\n  if (!supportsHistory()) {\n    return;\n  }\n\n  const oldOnPopState = WINDOW.onpopstate;\n  WINDOW.onpopstate = function ( ...args) {\n    const to = WINDOW.location.href;\n    // keep track of the current URL state, as we always receive only the updated state\n    const from = lastHref;\n    lastHref = to;\n    const handlerData = { from, to };\n    triggerHandlers('history', handlerData);\n    if (oldOnPopState) {\n      // Apparently this can throw in Firefox when incorrectly implemented plugin is installed.\n      // https://github.com/getsentry/sentry-javascript/issues/3344\n      // https://github.com/bugsnag/bugsnag-js/issues/469\n      try {\n        return oldOnPopState.apply(this, args);\n      } catch (_oO) {\n        // no-empty\n      }\n    }\n  };\n\n  function historyReplacementFunction(originalHistoryFunction) {\n    return function ( ...args) {\n      const url = args.length > 2 ? args[2] : undefined;\n      if (url) {\n        // coerce to string (this is what pushState does)\n        const from = lastHref;\n        const to = String(url);\n        // keep track of the current URL state, as we always receive only the updated state\n        lastHref = to;\n        const handlerData = { from, to };\n        triggerHandlers('history', handlerData);\n      }\n      return originalHistoryFunction.apply(this, args);\n    };\n  }\n\n  fill(WINDOW.history, 'pushState', historyReplacementFunction);\n  fill(WINDOW.history, 'replaceState', historyReplacementFunction);\n}\n\nexport { addHistoryInstrumentationHandler };\n//# sourceMappingURL=history.js.map\n","import { isString } from '../is.js';\nimport { fill } from '../object.js';\nimport { GLOBAL_OBJ } from '../worldwide.js';\nimport { addHandler, maybeInstrument, triggerHandlers } from './_handlers.js';\n\nconst WINDOW = GLOBAL_OBJ ;\n\nconst SENTRY_XHR_DATA_KEY = '__sentry_xhr_v3__';\n\n/**\n * Add an instrumentation handler for when an XHR request happens.\n * The handler function is called once when the request starts and once when it ends,\n * which can be identified by checking if it has an `endTimestamp`.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addXhrInstrumentationHandler(handler) {\n  const type = 'xhr';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentXHR);\n}\n\n/** Exported only for tests. */\nfunction instrumentXHR() {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  if (!(WINDOW ).XMLHttpRequest) {\n    return;\n  }\n\n  const xhrproto = XMLHttpRequest.prototype;\n\n  fill(xhrproto, 'open', function (originalOpen) {\n    return function ( ...args) {\n      const startTimestamp = Date.now();\n\n      // open() should always be called with two or more arguments\n      // But to be on the safe side, we actually validate this and bail out if we don't have a method & url\n      const method = isString(args[0]) ? args[0].toUpperCase() : undefined;\n      const url = parseUrl(args[1]);\n\n      if (!method || !url) {\n        return originalOpen.apply(this, args);\n      }\n\n      this[SENTRY_XHR_DATA_KEY] = {\n        method,\n        url,\n        request_headers: {},\n      };\n\n      // if Sentry key appears in URL, don't capture it as a request\n      if (method === 'POST' && url.match(/sentry_key/)) {\n        this.__sentry_own_request__ = true;\n      }\n\n      const onreadystatechangeHandler = () => {\n        // For whatever reason, this is not the same instance here as from the outer method\n        const xhrInfo = this[SENTRY_XHR_DATA_KEY];\n\n        if (!xhrInfo) {\n          return;\n        }\n\n        if (this.readyState === 4) {\n          try {\n            // touching statusCode in some platforms throws\n            // an exception\n            xhrInfo.status_code = this.status;\n          } catch (e) {\n            /* do nothing */\n          }\n\n          const handlerData = {\n            args: [method, url],\n            endTimestamp: Date.now(),\n            startTimestamp,\n            xhr: this,\n          };\n          triggerHandlers('xhr', handlerData);\n        }\n      };\n\n      if ('onreadystatechange' in this && typeof this.onreadystatechange === 'function') {\n        fill(this, 'onreadystatechange', function (original) {\n          return function ( ...readyStateArgs) {\n            onreadystatechangeHandler();\n            return original.apply(this, readyStateArgs);\n          };\n        });\n      } else {\n        this.addEventListener('readystatechange', onreadystatechangeHandler);\n      }\n\n      // Intercepting `setRequestHeader` to access the request headers of XHR instance.\n      // This will only work for user/library defined headers, not for the default/browser-assigned headers.\n      // Request cookies are also unavailable for XHR, as `Cookie` header can't be defined by `setRequestHeader`.\n      fill(this, 'setRequestHeader', function (original) {\n        return function ( ...setRequestHeaderArgs) {\n          const [header, value] = setRequestHeaderArgs;\n\n          const xhrInfo = this[SENTRY_XHR_DATA_KEY];\n\n          if (xhrInfo && isString(header) && isString(value)) {\n            xhrInfo.request_headers[header.toLowerCase()] = value;\n          }\n\n          return original.apply(this, setRequestHeaderArgs);\n        };\n      });\n\n      return originalOpen.apply(this, args);\n    };\n  });\n\n  fill(xhrproto, 'send', function (originalSend) {\n    return function ( ...args) {\n      const sentryXhrData = this[SENTRY_XHR_DATA_KEY];\n\n      if (!sentryXhrData) {\n        return originalSend.apply(this, args);\n      }\n\n      if (args[0] !== undefined) {\n        sentryXhrData.body = args[0];\n      }\n\n      const handlerData = {\n        args: [sentryXhrData.method, sentryXhrData.url],\n        startTimestamp: Date.now(),\n        xhr: this,\n      };\n      triggerHandlers('xhr', handlerData);\n\n      return originalSend.apply(this, args);\n    };\n  });\n}\n\nfunction parseUrl(url) {\n  if (isString(url)) {\n    return url;\n  }\n\n  try {\n    // url can be a string or URL\n    // but since URL is not available in IE11, we do not check for it,\n    // but simply assume it is an URL and return `toString()` from it (which returns the full URL)\n    // If that fails, we just return undefined\n    return (url ).toString();\n  } catch (e2) {} // eslint-disable-line no-empty\n\n  return undefined;\n}\n\nexport { SENTRY_XHR_DATA_KEY, addXhrInstrumentationHandler, instrumentXHR };\n//# sourceMappingURL=xhr.js.map\n","// eslint-disable-next-line @typescript-eslint/unbound-method\nconst objectToString = Object.prototype.toString;\n\n/**\n * Checks whether given value's type is one of a few Error or Error-like\n * {@link isError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isError(wat) {\n  switch (objectToString.call(wat)) {\n    case '[object Error]':\n    case '[object Exception]':\n    case '[object DOMException]':\n      return true;\n    default:\n      return isInstanceOf(wat, Error);\n  }\n}\n/**\n * Checks whether given value is an instance of the given built-in class.\n *\n * @param wat The value to be checked\n * @param className\n * @returns A boolean representing the result.\n */\nfunction isBuiltin(wat, className) {\n  return objectToString.call(wat) === `[object ${className}]`;\n}\n\n/**\n * Checks whether given value's type is ErrorEvent\n * {@link isErrorEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isErrorEvent(wat) {\n  return isBuiltin(wat, 'ErrorEvent');\n}\n\n/**\n * Checks whether given value's type is DOMError\n * {@link isDOMError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isDOMError(wat) {\n  return isBuiltin(wat, 'DOMError');\n}\n\n/**\n * Checks whether given value's type is DOMException\n * {@link isDOMException}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isDOMException(wat) {\n  return isBuiltin(wat, 'DOMException');\n}\n\n/**\n * Checks whether given value's type is a string\n * {@link isString}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isString(wat) {\n  return isBuiltin(wat, 'String');\n}\n\n/**\n * Checks whether given string is parameterized\n * {@link isParameterizedString}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isParameterizedString(wat) {\n  return (\n    typeof wat === 'object' &&\n    wat !== null &&\n    '__sentry_template_string__' in wat &&\n    '__sentry_template_values__' in wat\n  );\n}\n\n/**\n * Checks whether given value is a primitive (undefined, null, number, boolean, string, bigint, symbol)\n * {@link isPrimitive}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isPrimitive(wat) {\n  return wat === null || isParameterizedString(wat) || (typeof wat !== 'object' && typeof wat !== 'function');\n}\n\n/**\n * Checks whether given value's type is an object literal, or a class instance.\n * {@link isPlainObject}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isPlainObject(wat) {\n  return isBuiltin(wat, 'Object');\n}\n\n/**\n * Checks whether given value's type is an Event instance\n * {@link isEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isEvent(wat) {\n  return typeof Event !== 'undefined' && isInstanceOf(wat, Event);\n}\n\n/**\n * Checks whether given value's type is an Element instance\n * {@link isElement}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isElement(wat) {\n  return typeof Element !== 'undefined' && isInstanceOf(wat, Element);\n}\n\n/**\n * Checks whether given value's type is an regexp\n * {@link isRegExp}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isRegExp(wat) {\n  return isBuiltin(wat, 'RegExp');\n}\n\n/**\n * Checks whether given value has a then function.\n * @param wat A value to be checked.\n */\nfunction isThenable(wat) {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  return Boolean(wat && wat.then && typeof wat.then === 'function');\n}\n\n/**\n * Checks whether given value's type is a SyntheticEvent\n * {@link isSyntheticEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isSyntheticEvent(wat) {\n  return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;\n}\n\n/**\n * Checks whether given value is NaN\n * {@link isNaN}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isNaN(wat) {\n  return typeof wat === 'number' && wat !== wat;\n}\n\n/**\n * Checks whether given value's type is an instance of provided constructor.\n * {@link isInstanceOf}.\n *\n * @param wat A value to be checked.\n * @param base A constructor to be used in a check.\n * @returns A boolean representing the result.\n */\nfunction isInstanceOf(wat, base) {\n  try {\n    return wat instanceof base;\n  } catch (_e) {\n    return false;\n  }\n}\n\n/**\n * Checks whether given value's type is a Vue ViewModel.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isVueViewModel(wat) {\n  // Not using Object.prototype.toString because in Vue 3 it would read the instance's Symbol(Symbol.toStringTag) property.\n  return !!(typeof wat === 'object' && wat !== null && ((wat ).__isVue || (wat )._isVue));\n}\n\nexport { isDOMError, isDOMException, isElement, isError, isErrorEvent, isEvent, isInstanceOf, isNaN, isParameterizedString, isPlainObject, isPrimitive, isRegExp, isString, isSyntheticEvent, isThenable, isVueViewModel };\n//# sourceMappingURL=is.js.map\n","import { isNodeEnv } from './node.js';\nimport { GLOBAL_OBJ } from './worldwide.js';\n\n/**\n * Returns true if we are in the browser.\n */\nfunction isBrowser() {\n  // eslint-disable-next-line no-restricted-globals\n  return typeof window !== 'undefined' && (!isNodeEnv() || isElectronNodeRenderer());\n}\n\n// Electron renderers with nodeIntegration enabled are detected as Node.js so we specifically test for them\nfunction isElectronNodeRenderer() {\n  return (\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any\n    (GLOBAL_OBJ ).process !== undefined && ((GLOBAL_OBJ ).process ).type === 'renderer'\n  );\n}\n\nexport { isBrowser };\n//# sourceMappingURL=isBrowser.js.map\n","import { DEBUG_BUILD } from './debug-build.js';\nimport { GLOBAL_OBJ } from './worldwide.js';\n\n/** Prefix for logging strings */\nconst PREFIX = 'Sentry Logger ';\n\nconst CONSOLE_LEVELS = [\n  'debug',\n  'info',\n  'warn',\n  'error',\n  'log',\n  'assert',\n  'trace',\n] ;\n\n/** This may be mutated by the console instrumentation. */\nconst originalConsoleMethods\n\n = {};\n\n/** JSDoc */\n\n/**\n * Temporarily disable sentry console instrumentations.\n *\n * @param callback The function to run against the original `console` messages\n * @returns The results of the callback\n */\nfunction consoleSandbox(callback) {\n  if (!('console' in GLOBAL_OBJ)) {\n    return callback();\n  }\n\n  const console = GLOBAL_OBJ.console ;\n  const wrappedFuncs = {};\n\n  const wrappedLevels = Object.keys(originalConsoleMethods) ;\n\n  // Restore all wrapped console methods\n  wrappedLevels.forEach(level => {\n    const originalConsoleMethod = originalConsoleMethods[level] ;\n    wrappedFuncs[level] = console[level] ;\n    console[level] = originalConsoleMethod;\n  });\n\n  try {\n    return callback();\n  } finally {\n    // Revert restoration to wrapped state\n    wrappedLevels.forEach(level => {\n      console[level] = wrappedFuncs[level] ;\n    });\n  }\n}\n\nfunction makeLogger() {\n  let enabled = false;\n  const logger = {\n    enable: () => {\n      enabled = true;\n    },\n    disable: () => {\n      enabled = false;\n    },\n    isEnabled: () => enabled,\n  };\n\n  if (DEBUG_BUILD) {\n    CONSOLE_LEVELS.forEach(name => {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      logger[name] = (...args) => {\n        if (enabled) {\n          consoleSandbox(() => {\n            GLOBAL_OBJ.console[name](`${PREFIX}[${name}]:`, ...args);\n          });\n        }\n      };\n    });\n  } else {\n    CONSOLE_LEVELS.forEach(name => {\n      logger[name] = () => undefined;\n    });\n  }\n\n  return logger ;\n}\n\nconst logger = makeLogger();\n\nexport { CONSOLE_LEVELS, consoleSandbox, logger, originalConsoleMethods };\n//# sourceMappingURL=logger.js.map\n","import { addNonEnumerableProperty } from './object.js';\nimport { snipLine } from './string.js';\nimport { GLOBAL_OBJ } from './worldwide.js';\n\n/**\n * UUID4 generator\n *\n * @returns string Generated UUID4.\n */\nfunction uuid4() {\n  const gbl = GLOBAL_OBJ ;\n  const crypto = gbl.crypto || gbl.msCrypto;\n\n  let getRandomByte = () => Math.random() * 16;\n  try {\n    if (crypto && crypto.randomUUID) {\n      return crypto.randomUUID().replace(/-/g, '');\n    }\n    if (crypto && crypto.getRandomValues) {\n      getRandomByte = () => {\n        // crypto.getRandomValues might return undefined instead of the typed array\n        // in old Chromium versions (e.g. 23.0.1235.0 (151422))\n        // However, `typedArray` is still filled in-place.\n        // @see https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues#typedarray\n        const typedArray = new Uint8Array(1);\n        crypto.getRandomValues(typedArray);\n        return typedArray[0];\n      };\n    }\n  } catch (_) {\n    // some runtimes can crash invoking crypto\n    // https://github.com/getsentry/sentry-javascript/issues/8935\n  }\n\n  // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523\n  // Concatenating the following numbers as strings results in '10000000100040008000100000000000'\n  return (([1e7] ) + 1e3 + 4e3 + 8e3 + 1e11).replace(/[018]/g, c =>\n    // eslint-disable-next-line no-bitwise\n    ((c ) ^ ((getRandomByte() & 15) >> ((c ) / 4))).toString(16),\n  );\n}\n\nfunction getFirstException(event) {\n  return event.exception && event.exception.values ? event.exception.values[0] : undefined;\n}\n\n/**\n * Extracts either message or type+value from an event that can be used for user-facing logs\n * @returns event's description\n */\nfunction getEventDescription(event) {\n  const { message, event_id: eventId } = event;\n  if (message) {\n    return message;\n  }\n\n  const firstException = getFirstException(event);\n  if (firstException) {\n    if (firstException.type && firstException.value) {\n      return `${firstException.type}: ${firstException.value}`;\n    }\n    return firstException.type || firstException.value || eventId || '<unknown>';\n  }\n  return eventId || '<unknown>';\n}\n\n/**\n * Adds exception values, type and value to an synthetic Exception.\n * @param event The event to modify.\n * @param value Value of the exception.\n * @param type Type of the exception.\n * @hidden\n */\nfunction addExceptionTypeValue(event, value, type) {\n  const exception = (event.exception = event.exception || {});\n  const values = (exception.values = exception.values || []);\n  const firstException = (values[0] = values[0] || {});\n  if (!firstException.value) {\n    firstException.value = value || '';\n  }\n  if (!firstException.type) {\n    firstException.type = type || 'Error';\n  }\n}\n\n/**\n * Adds exception mechanism data to a given event. Uses defaults if the second parameter is not passed.\n *\n * @param event The event to modify.\n * @param newMechanism Mechanism data to add to the event.\n * @hidden\n */\nfunction addExceptionMechanism(event, newMechanism) {\n  const firstException = getFirstException(event);\n  if (!firstException) {\n    return;\n  }\n\n  const defaultMechanism = { type: 'generic', handled: true };\n  const currentMechanism = firstException.mechanism;\n  firstException.mechanism = { ...defaultMechanism, ...currentMechanism, ...newMechanism };\n\n  if (newMechanism && 'data' in newMechanism) {\n    const mergedData = { ...(currentMechanism && currentMechanism.data), ...newMechanism.data };\n    firstException.mechanism.data = mergedData;\n  }\n}\n\n// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nconst SEMVER_REGEXP =\n  /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/;\n\n/**\n * Represents Semantic Versioning object\n */\n\n/**\n * Parses input into a SemVer interface\n * @param input string representation of a semver version\n */\nfunction parseSemver(input) {\n  const match = input.match(SEMVER_REGEXP) || [];\n  const major = parseInt(match[1], 10);\n  const minor = parseInt(match[2], 10);\n  const patch = parseInt(match[3], 10);\n  return {\n    buildmetadata: match[5],\n    major: isNaN(major) ? undefined : major,\n    minor: isNaN(minor) ? undefined : minor,\n    patch: isNaN(patch) ? undefined : patch,\n    prerelease: match[4],\n  };\n}\n\n/**\n * This function adds context (pre/post/line) lines to the provided frame\n *\n * @param lines string[] containing all lines\n * @param frame StackFrame that will be mutated\n * @param linesOfContext number of context lines we want to add pre/post\n */\nfunction addContextToFrame(lines, frame, linesOfContext = 5) {\n  // When there is no line number in the frame, attaching context is nonsensical and will even break grouping\n  if (frame.lineno === undefined) {\n    return;\n  }\n\n  const maxLines = lines.length;\n  const sourceLine = Math.max(Math.min(maxLines - 1, frame.lineno - 1), 0);\n\n  frame.pre_context = lines\n    .slice(Math.max(0, sourceLine - linesOfContext), sourceLine)\n    .map((line) => snipLine(line, 0));\n\n  frame.context_line = snipLine(lines[Math.min(maxLines - 1, sourceLine)], frame.colno || 0);\n\n  frame.post_context = lines\n    .slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext)\n    .map((line) => snipLine(line, 0));\n}\n\n/**\n * Checks whether or not we've already captured the given exception (note: not an identical exception - the very object\n * in question), and marks it captured if not.\n *\n * This is useful because it's possible for an error to get captured by more than one mechanism. After we intercept and\n * record an error, we rethrow it (assuming we've intercepted it before it's reached the top-level global handlers), so\n * that we don't interfere with whatever effects the error might have had were the SDK not there. At that point, because\n * the error has been rethrown, it's possible for it to bubble up to some other code we've instrumented. If it's not\n * caught after that, it will bubble all the way up to the global handlers (which of course we also instrument). This\n * function helps us ensure that even if we encounter the same error more than once, we only record it the first time we\n * see it.\n *\n * Note: It will ignore primitives (always return `false` and not mark them as seen), as properties can't be set on\n * them. {@link: Object.objectify} can be used on exceptions to convert any that are primitives into their equivalent\n * object wrapper forms so that this check will always work. However, because we need to flag the exact object which\n * will get rethrown, and because that rethrowing happens outside of the event processing pipeline, the objectification\n * must be done before the exception captured.\n *\n * @param A thrown exception to check or flag as having been seen\n * @returns `true` if the exception has already been captured, `false` if not (with the side effect of marking it seen)\n */\nfunction checkOrSetAlreadyCaught(exception) {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  if (exception && (exception ).__sentry_captured__) {\n    return true;\n  }\n\n  try {\n    // set it this way rather than by assignment so that it's not ennumerable and therefore isn't recorded by the\n    // `ExtraErrorData` integration\n    addNonEnumerableProperty(exception , '__sentry_captured__', true);\n  } catch (err) {\n    // `exception` is a primitive, so we can't mark it seen\n  }\n\n  return false;\n}\n\n/**\n * Checks whether the given input is already an array, and if it isn't, wraps it in one.\n *\n * @param maybeArray Input to turn into an array, if necessary\n * @returns The input, if already an array, or an array with the input as the only element, if not\n */\nfunction arrayify(maybeArray) {\n  return Array.isArray(maybeArray) ? maybeArray : [maybeArray];\n}\n\nexport { addContextToFrame, addExceptionMechanism, addExceptionTypeValue, arrayify, checkOrSetAlreadyCaught, getEventDescription, parseSemver, uuid4 };\n//# sourceMappingURL=misc.js.map\n","import { isBrowserBundle } from './env.js';\n\n/**\n * NOTE: In order to avoid circular dependencies, if you add a function to this module and it needs to print something,\n * you must either a) use `console.log` rather than the logger, or b) put your function elsewhere.\n */\n\n/**\n * Checks whether we're in the Node.js or Browser environment\n *\n * @returns Answer to given question\n */\nfunction isNodeEnv() {\n  // explicitly check for browser bundles as those can be optimized statically\n  // by terser/rollup.\n  return (\n    !isBrowserBundle() &&\n    Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]'\n  );\n}\n\n/**\n * Requires a module which is protected against bundler minification.\n *\n * @param request The module path to resolve\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any\nfunction dynamicRequire(mod, request) {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  return mod.require(request);\n}\n\n/**\n * Helper for dynamically loading module that should work with linked dependencies.\n * The problem is that we _should_ be using `require(require.resolve(moduleName, { paths: [cwd()] }))`\n * However it's _not possible_ to do that with Webpack, as it has to know all the dependencies during\n * build time. `require.resolve` is also not available in any other way, so we cannot create,\n * a fake helper like we do with `dynamicRequire`.\n *\n * We always prefer to use local package, thus the value is not returned early from each `try/catch` block.\n * That is to mimic the behavior of `require.resolve` exactly.\n *\n * @param moduleName module name to require\n * @returns possibly required module\n */\nfunction loadModule(moduleName) {\n  let mod;\n\n  try {\n    mod = dynamicRequire(module, moduleName);\n  } catch (e) {\n    // no-empty\n  }\n\n  try {\n    const { cwd } = dynamicRequire(module, 'process');\n    mod = dynamicRequire(module, `${cwd()}/node_modules/${moduleName}`) ;\n  } catch (e) {\n    // no-empty\n  }\n\n  return mod;\n}\n\nexport { dynamicRequire, isNodeEnv, loadModule };\n//# sourceMappingURL=node.js.map\n","/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\n/**\n * Helper to decycle json objects\n */\nfunction memoBuilder() {\n  const hasWeakSet = typeof WeakSet === 'function';\n  const inner = hasWeakSet ? new WeakSet() : [];\n  function memoize(obj) {\n    if (hasWeakSet) {\n      if (inner.has(obj)) {\n        return true;\n      }\n      inner.add(obj);\n      return false;\n    }\n    // eslint-disable-next-line @typescript-eslint/prefer-for-of\n    for (let i = 0; i < inner.length; i++) {\n      const value = inner[i];\n      if (value === obj) {\n        return true;\n      }\n    }\n    inner.push(obj);\n    return false;\n  }\n\n  function unmemoize(obj) {\n    if (hasWeakSet) {\n      inner.delete(obj);\n    } else {\n      for (let i = 0; i < inner.length; i++) {\n        if (inner[i] === obj) {\n          inner.splice(i, 1);\n          break;\n        }\n      }\n    }\n  }\n  return [memoize, unmemoize];\n}\n\nexport { memoBuilder };\n//# sourceMappingURL=memo.js.map\n","import { isNaN, isVueViewModel, isSyntheticEvent } from './is.js';\nimport { memoBuilder } from './memo.js';\nimport { convertToPlainObject } from './object.js';\nimport { getFunctionName } from './stacktrace.js';\n\n/**\n * Recursively normalizes the given object.\n *\n * - Creates a copy to prevent original input mutation\n * - Skips non-enumerable properties\n * - When stringifying, calls `toJSON` if implemented\n * - Removes circular references\n * - Translates non-serializable values (`undefined`/`NaN`/functions) to serializable format\n * - Translates known global objects/classes to a string representations\n * - Takes care of `Error` object serialization\n * - Optionally limits depth of final output\n * - Optionally limits number of properties/elements included in any single object/array\n *\n * @param input The object to be normalized.\n * @param depth The max depth to which to normalize the object. (Anything deeper stringified whole.)\n * @param maxProperties The max number of elements or properties to be included in any single array or\n * object in the normallized output.\n * @returns A normalized version of the object, or `\"**non-serializable**\"` if any errors are thrown during normalization.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction normalize(input, depth = 100, maxProperties = +Infinity) {\n  try {\n    // since we're at the outermost level, we don't provide a key\n    return visit('', input, depth, maxProperties);\n  } catch (err) {\n    return { ERROR: `**non-serializable** (${err})` };\n  }\n}\n\n/** JSDoc */\nfunction normalizeToSize(\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  object,\n  // Default Node.js REPL depth\n  depth = 3,\n  // 100kB, as 200kB is max payload size, so half sounds reasonable\n  maxSize = 100 * 1024,\n) {\n  const normalized = normalize(object, depth);\n\n  if (jsonSize(normalized) > maxSize) {\n    return normalizeToSize(object, depth - 1, maxSize);\n  }\n\n  return normalized ;\n}\n\n/**\n * Visits a node to perform normalization on it\n *\n * @param key The key corresponding to the given node\n * @param value The node to be visited\n * @param depth Optional number indicating the maximum recursion depth\n * @param maxProperties Optional maximum number of properties/elements included in any single object/array\n * @param memo Optional Memo class handling decycling\n */\nfunction visit(\n  key,\n  value,\n  depth = +Infinity,\n  maxProperties = +Infinity,\n  memo = memoBuilder(),\n) {\n  const [memoize, unmemoize] = memo;\n\n  // Get the simple cases out of the way first\n  if (\n    value == null || // this matches null and undefined -> eqeq not eqeqeq\n    (['number', 'boolean', 'string'].includes(typeof value) && !isNaN(value))\n  ) {\n    return value ;\n  }\n\n  const stringified = stringifyValue(key, value);\n\n  // Anything we could potentially dig into more (objects or arrays) will have come back as `\"[object XXXX]\"`.\n  // Everything else will have already been serialized, so if we don't see that pattern, we're done.\n  if (!stringified.startsWith('[object ')) {\n    return stringified;\n  }\n\n  // From here on, we can assert that `value` is either an object or an array.\n\n  // Do not normalize objects that we know have already been normalized. As a general rule, the\n  // \"__sentry_skip_normalization__\" property should only be used sparingly and only should only be set on objects that\n  // have already been normalized.\n  if ((value )['__sentry_skip_normalization__']) {\n    return value ;\n  }\n\n  // We can set `__sentry_override_normalization_depth__` on an object to ensure that from there\n  // We keep a certain amount of depth.\n  // This should be used sparingly, e.g. we use it for the redux integration to ensure we get a certain amount of state.\n  const remainingDepth =\n    typeof (value )['__sentry_override_normalization_depth__'] === 'number'\n      ? ((value )['__sentry_override_normalization_depth__'] )\n      : depth;\n\n  // We're also done if we've reached the max depth\n  if (remainingDepth === 0) {\n    // At this point we know `serialized` is a string of the form `\"[object XXXX]\"`. Clean it up so it's just `\"[XXXX]\"`.\n    return stringified.replace('object ', '');\n  }\n\n  // If we've already visited this branch, bail out, as it's circular reference. If not, note that we're seeing it now.\n  if (memoize(value)) {\n    return '[Circular ~]';\n  }\n\n  // If the value has a `toJSON` method, we call it to extract more information\n  const valueWithToJSON = value ;\n  if (valueWithToJSON && typeof valueWithToJSON.toJSON === 'function') {\n    try {\n      const jsonValue = valueWithToJSON.toJSON();\n      // We need to normalize the return value of `.toJSON()` in case it has circular references\n      return visit('', jsonValue, remainingDepth - 1, maxProperties, memo);\n    } catch (err) {\n      // pass (The built-in `toJSON` failed, but we can still try to do it ourselves)\n    }\n  }\n\n  // At this point we know we either have an object or an array, we haven't seen it before, and we're going to recurse\n  // because we haven't yet reached the max depth. Create an accumulator to hold the results of visiting each\n  // property/entry, and keep track of the number of items we add to it.\n  const normalized = (Array.isArray(value) ? [] : {}) ;\n  let numAdded = 0;\n\n  // Before we begin, convert`Error` and`Event` instances into plain objects, since some of each of their relevant\n  // properties are non-enumerable and otherwise would get missed.\n  const visitable = convertToPlainObject(value );\n\n  for (const visitKey in visitable) {\n    // Avoid iterating over fields in the prototype if they've somehow been exposed to enumeration.\n    if (!Object.prototype.hasOwnProperty.call(visitable, visitKey)) {\n      continue;\n    }\n\n    if (numAdded >= maxProperties) {\n      normalized[visitKey] = '[MaxProperties ~]';\n      break;\n    }\n\n    // Recursively visit all the child nodes\n    const visitValue = visitable[visitKey];\n    normalized[visitKey] = visit(visitKey, visitValue, remainingDepth - 1, maxProperties, memo);\n\n    numAdded++;\n  }\n\n  // Once we've visited all the branches, remove the parent from memo storage\n  unmemoize(value);\n\n  // Return accumulated values\n  return normalized;\n}\n\n/* eslint-disable complexity */\n/**\n * Stringify the given value. Handles various known special values and types.\n *\n * Not meant to be used on simple primitives which already have a string representation, as it will, for example, turn\n * the number 1231 into \"[Object Number]\", nor on `null`, as it will throw.\n *\n * @param value The value to stringify\n * @returns A stringified representation of the given value\n */\nfunction stringifyValue(\n  key,\n  // this type is a tiny bit of a cheat, since this function does handle NaN (which is technically a number), but for\n  // our internal use, it'll do\n  value,\n) {\n  try {\n    if (key === 'domain' && value && typeof value === 'object' && (value )._events) {\n      return '[Domain]';\n    }\n\n    if (key === 'domainEmitter') {\n      return '[DomainEmitter]';\n    }\n\n    // It's safe to use `global`, `window`, and `document` here in this manner, as we are asserting using `typeof` first\n    // which won't throw if they are not present.\n\n    if (typeof global !== 'undefined' && value === global) {\n      return '[Global]';\n    }\n\n    // eslint-disable-next-line no-restricted-globals\n    if (typeof window !== 'undefined' && value === window) {\n      return '[Window]';\n    }\n\n    // eslint-disable-next-line no-restricted-globals\n    if (typeof document !== 'undefined' && value === document) {\n      return '[Document]';\n    }\n\n    if (isVueViewModel(value)) {\n      return '[VueViewModel]';\n    }\n\n    // React's SyntheticEvent thingy\n    if (isSyntheticEvent(value)) {\n      return '[SyntheticEvent]';\n    }\n\n    if (typeof value === 'number' && value !== value) {\n      return '[NaN]';\n    }\n\n    if (typeof value === 'function') {\n      return `[Function: ${getFunctionName(value)}]`;\n    }\n\n    if (typeof value === 'symbol') {\n      return `[${String(value)}]`;\n    }\n\n    // stringified BigInts are indistinguishable from regular numbers, so we need to label them to avoid confusion\n    if (typeof value === 'bigint') {\n      return `[BigInt: ${String(value)}]`;\n    }\n\n    // Now that we've knocked out all the special cases and the primitives, all we have left are objects. Simply casting\n    // them to strings means that instances of classes which haven't defined their `toStringTag` will just come out as\n    // `\"[object Object]\"`. If we instead look at the constructor's name (which is the same as the name of the class),\n    // we can make sure that only plain objects come out that way.\n    const objName = getConstructorName(value);\n\n    // Handle HTML Elements\n    if (/^HTML(\\w*)Element$/.test(objName)) {\n      return `[HTMLElement: ${objName}]`;\n    }\n\n    return `[object ${objName}]`;\n  } catch (err) {\n    return `**non-serializable** (${err})`;\n  }\n}\n/* eslint-enable complexity */\n\nfunction getConstructorName(value) {\n  const prototype = Object.getPrototypeOf(value);\n\n  return prototype ? prototype.constructor.name : 'null prototype';\n}\n\n/** Calculates bytes size of input string */\nfunction utf8Length(value) {\n  // eslint-disable-next-line no-bitwise\n  return ~-encodeURI(value).split(/%..|./).length;\n}\n\n/** Calculates bytes size of input object */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction jsonSize(value) {\n  return utf8Length(JSON.stringify(value));\n}\n\n/**\n * Normalizes URLs in exceptions and stacktraces to a base path so Sentry can fingerprint\n * across platforms and working directory.\n *\n * @param url The URL to be normalized.\n * @param basePath The application base path.\n * @returns The normalized URL.\n */\nfunction normalizeUrlToBase(url, basePath) {\n  const escapedBase = basePath\n    // Backslash to forward\n    .replace(/\\\\/g, '/')\n    // Escape RegExp special characters\n    .replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&');\n\n  let newUrl = url;\n  try {\n    newUrl = decodeURI(url);\n  } catch (_Oo) {\n    // Sometime this breaks\n  }\n  return (\n    newUrl\n      .replace(/\\\\/g, '/')\n      .replace(/webpack:\\/?/g, '') // Remove intermediate base path\n      // eslint-disable-next-line @sentry-internal/sdk/no-regexp-constructor\n      .replace(new RegExp(`(file://)?/*${escapedBase}/*`, 'ig'), 'app:///')\n  );\n}\n\nexport { normalize, normalizeToSize, normalizeUrlToBase, visit as walk };\n//# sourceMappingURL=normalize.js.map\n","import { htmlTreeAsString } from './browser.js';\nimport { DEBUG_BUILD } from './debug-build.js';\nimport { isError, isEvent, isInstanceOf, isElement, isPlainObject, isPrimitive } from './is.js';\nimport { logger } from './logger.js';\nimport { truncate } from './string.js';\n\n/**\n * Replace a method in an object with a wrapped version of itself.\n *\n * @param source An object that contains a method to be wrapped.\n * @param name The name of the method to be wrapped.\n * @param replacementFactory A higher-order function that takes the original version of the given method and returns a\n * wrapped version. Note: The function returned by `replacementFactory` needs to be a non-arrow function, in order to\n * preserve the correct value of `this`, and the original method must be called using `origMethod.call(this, <other\n * args>)` or `origMethod.apply(this, [<other args>])` (rather than being called directly), again to preserve `this`.\n * @returns void\n */\nfunction fill(source, name, replacementFactory) {\n  if (!(name in source)) {\n    return;\n  }\n\n  const original = source[name] ;\n  const wrapped = replacementFactory(original) ;\n\n  // Make sure it's a function first, as we need to attach an empty prototype for `defineProperties` to work\n  // otherwise it'll throw \"TypeError: Object.defineProperties called on non-object\"\n  if (typeof wrapped === 'function') {\n    markFunctionWrapped(wrapped, original);\n  }\n\n  source[name] = wrapped;\n}\n\n/**\n * Defines a non-enumerable property on the given object.\n *\n * @param obj The object on which to set the property\n * @param name The name of the property to be set\n * @param value The value to which to set the property\n */\nfunction addNonEnumerableProperty(obj, name, value) {\n  try {\n    Object.defineProperty(obj, name, {\n      // enumerable: false, // the default, so we can save on bundle size by not explicitly setting it\n      value: value,\n      writable: true,\n      configurable: true,\n    });\n  } catch (o_O) {\n    DEBUG_BUILD && logger.log(`Failed to add non-enumerable property \"${name}\" to object`, obj);\n  }\n}\n\n/**\n * Remembers the original function on the wrapped function and\n * patches up the prototype.\n *\n * @param wrapped the wrapper function\n * @param original the original function that gets wrapped\n */\nfunction markFunctionWrapped(wrapped, original) {\n  try {\n    const proto = original.prototype || {};\n    wrapped.prototype = original.prototype = proto;\n    addNonEnumerableProperty(wrapped, '__sentry_original__', original);\n  } catch (o_O) {} // eslint-disable-line no-empty\n}\n\n/**\n * This extracts the original function if available.  See\n * `markFunctionWrapped` for more information.\n *\n * @param func the function to unwrap\n * @returns the unwrapped version of the function if available.\n */\nfunction getOriginalFunction(func) {\n  return func.__sentry_original__;\n}\n\n/**\n * Encodes given object into url-friendly format\n *\n * @param object An object that contains serializable values\n * @returns string Encoded\n */\nfunction urlEncode(object) {\n  return Object.keys(object)\n    .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(object[key])}`)\n    .join('&');\n}\n\n/**\n * Transforms any `Error` or `Event` into a plain object with all of their enumerable properties, and some of their\n * non-enumerable properties attached.\n *\n * @param value Initial source that we have to transform in order for it to be usable by the serializer\n * @returns An Event or Error turned into an object - or the value argurment itself, when value is neither an Event nor\n *  an Error.\n */\nfunction convertToPlainObject(\n  value,\n)\n\n {\n  if (isError(value)) {\n    return {\n      message: value.message,\n      name: value.name,\n      stack: value.stack,\n      ...getOwnProperties(value),\n    };\n  } else if (isEvent(value)) {\n    const newObj\n\n = {\n      type: value.type,\n      target: serializeEventTarget(value.target),\n      currentTarget: serializeEventTarget(value.currentTarget),\n      ...getOwnProperties(value),\n    };\n\n    if (typeof CustomEvent !== 'undefined' && isInstanceOf(value, CustomEvent)) {\n      newObj.detail = value.detail;\n    }\n\n    return newObj;\n  } else {\n    return value;\n  }\n}\n\n/** Creates a string representation of the target of an `Event` object */\nfunction serializeEventTarget(target) {\n  try {\n    return isElement(target) ? htmlTreeAsString(target) : Object.prototype.toString.call(target);\n  } catch (_oO) {\n    return '<unknown>';\n  }\n}\n\n/** Filters out all but an object's own properties */\nfunction getOwnProperties(obj) {\n  if (typeof obj === 'object' && obj !== null) {\n    const extractedProps = {};\n    for (const property in obj) {\n      if (Object.prototype.hasOwnProperty.call(obj, property)) {\n        extractedProps[property] = (obj )[property];\n      }\n    }\n    return extractedProps;\n  } else {\n    return {};\n  }\n}\n\n/**\n * Given any captured exception, extract its keys and create a sorted\n * and truncated list that will be used inside the event message.\n * eg. `Non-error exception captured with keys: foo, bar, baz`\n */\nfunction extractExceptionKeysForMessage(exception, maxLength = 40) {\n  const keys = Object.keys(convertToPlainObject(exception));\n  keys.sort();\n\n  if (!keys.length) {\n    return '[object has no keys]';\n  }\n\n  if (keys[0].length >= maxLength) {\n    return truncate(keys[0], maxLength);\n  }\n\n  for (let includedKeys = keys.length; includedKeys > 0; includedKeys--) {\n    const serialized = keys.slice(0, includedKeys).join(', ');\n    if (serialized.length > maxLength) {\n      continue;\n    }\n    if (includedKeys === keys.length) {\n      return serialized;\n    }\n    return truncate(serialized, maxLength);\n  }\n\n  return '';\n}\n\n/**\n * Given any object, return a new object having removed all fields whose value was `undefined`.\n * Works recursively on objects and arrays.\n *\n * Attention: This function keeps circular references in the returned object.\n */\nfunction dropUndefinedKeys(inputValue) {\n  // This map keeps track of what already visited nodes map to.\n  // Our Set - based memoBuilder doesn't work here because we want to the output object to have the same circular\n  // references as the input object.\n  const memoizationMap = new Map();\n\n  // This function just proxies `_dropUndefinedKeys` to keep the `memoBuilder` out of this function's API\n  return _dropUndefinedKeys(inputValue, memoizationMap);\n}\n\nfunction _dropUndefinedKeys(inputValue, memoizationMap) {\n  if (isPojo(inputValue)) {\n    // If this node has already been visited due to a circular reference, return the object it was mapped to in the new object\n    const memoVal = memoizationMap.get(inputValue);\n    if (memoVal !== undefined) {\n      return memoVal ;\n    }\n\n    const returnValue = {};\n    // Store the mapping of this value in case we visit it again, in case of circular data\n    memoizationMap.set(inputValue, returnValue);\n\n    for (const key of Object.keys(inputValue)) {\n      if (typeof inputValue[key] !== 'undefined') {\n        returnValue[key] = _dropUndefinedKeys(inputValue[key], memoizationMap);\n      }\n    }\n\n    return returnValue ;\n  }\n\n  if (Array.isArray(inputValue)) {\n    // If this node has already been visited due to a circular reference, return the array it was mapped to in the new object\n    const memoVal = memoizationMap.get(inputValue);\n    if (memoVal !== undefined) {\n      return memoVal ;\n    }\n\n    const returnValue = [];\n    // Store the mapping of this value in case we visit it again, in case of circular data\n    memoizationMap.set(inputValue, returnValue);\n\n    inputValue.forEach((item) => {\n      returnValue.push(_dropUndefinedKeys(item, memoizationMap));\n    });\n\n    return returnValue ;\n  }\n\n  return inputValue;\n}\n\nfunction isPojo(input) {\n  if (!isPlainObject(input)) {\n    return false;\n  }\n\n  try {\n    const name = (Object.getPrototypeOf(input) ).constructor.name;\n    return !name || name === 'Object';\n  } catch (e) {\n    return true;\n  }\n}\n\n/**\n * Ensure that something is an object.\n *\n * Turns `undefined` and `null` into `String`s and all other primitives into instances of their respective wrapper\n * classes (String, Boolean, Number, etc.). Acts as the identity function on non-primitives.\n *\n * @param wat The subject of the objectification\n * @returns A version of `wat` which can safely be used with `Object` class methods\n */\nfunction objectify(wat) {\n  let objectified;\n  switch (true) {\n    case wat === undefined || wat === null:\n      objectified = new String(wat);\n      break;\n\n    // Though symbols and bigints do have wrapper classes (`Symbol` and `BigInt`, respectively), for whatever reason\n    // those classes don't have constructors which can be used with the `new` keyword. We therefore need to cast each as\n    // an object in order to wrap it.\n    case typeof wat === 'symbol' || typeof wat === 'bigint':\n      objectified = Object(wat);\n      break;\n\n    // this will catch the remaining primitives: `String`, `Number`, and `Boolean`\n    case isPrimitive(wat):\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n      objectified = new (wat ).constructor(wat);\n      break;\n\n    // by process of elimination, at this point we know that `wat` must already be an object\n    default:\n      objectified = wat;\n      break;\n  }\n  return objectified;\n}\n\nexport { addNonEnumerableProperty, convertToPlainObject, dropUndefinedKeys, extractExceptionKeysForMessage, fill, getOriginalFunction, markFunctionWrapped, objectify, urlEncode };\n//# sourceMappingURL=object.js.map\n","// Slightly modified (no IE8 support, ES6) and transcribed to TypeScript\n// https://github.com/calvinmetcalf/rollup-plugin-node-builtins/blob/63ab8aacd013767445ca299e468d9a60a95328d7/src/es6/path.js\n//\n// Copyright Joyent, Inc.and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n/** JSDoc */\nfunction normalizeArray(parts, allowAboveRoot) {\n  // if the path tries to go above the root, `up` ends up > 0\n  let up = 0;\n  for (let i = parts.length - 1; i >= 0; i--) {\n    const last = parts[i];\n    if (last === '.') {\n      parts.splice(i, 1);\n    } else if (last === '..') {\n      parts.splice(i, 1);\n      up++;\n    } else if (up) {\n      parts.splice(i, 1);\n      up--;\n    }\n  }\n\n  // if the path is allowed to go above the root, restore leading ..s\n  if (allowAboveRoot) {\n    for (; up--; up) {\n      parts.unshift('..');\n    }\n  }\n\n  return parts;\n}\n\n// Split a filename into [root, dir, basename, ext], unix version\n// 'root' is just a slash, or nothing.\nconst splitPathRe = /^(\\S+:\\\\|\\/?)([\\s\\S]*?)((?:\\.{1,2}|[^/\\\\]+?|)(\\.[^./\\\\]*|))(?:[/\\\\]*)$/;\n/** JSDoc */\nfunction splitPath(filename) {\n  // Truncate files names greater than 1024 characters to avoid regex dos\n  // https://github.com/getsentry/sentry-javascript/pull/8737#discussion_r1285719172\n  const truncated = filename.length > 1024 ? `<truncated>${filename.slice(-1024)}` : filename;\n  const parts = splitPathRe.exec(truncated);\n  return parts ? parts.slice(1) : [];\n}\n\n// path.resolve([from ...], to)\n// posix version\n/** JSDoc */\nfunction resolve(...args) {\n  let resolvedPath = '';\n  let resolvedAbsolute = false;\n\n  for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n    const path = i >= 0 ? args[i] : '/';\n\n    // Skip empty entries\n    if (!path) {\n      continue;\n    }\n\n    resolvedPath = `${path}/${resolvedPath}`;\n    resolvedAbsolute = path.charAt(0) === '/';\n  }\n\n  // At this point the path should be resolved to a full absolute path, but\n  // handle relative paths to be safe (might happen when process.cwd() fails)\n\n  // Normalize the path\n  resolvedPath = normalizeArray(\n    resolvedPath.split('/').filter(p => !!p),\n    !resolvedAbsolute,\n  ).join('/');\n\n  return (resolvedAbsolute ? '/' : '') + resolvedPath || '.';\n}\n\n/** JSDoc */\nfunction trim(arr) {\n  let start = 0;\n  for (; start < arr.length; start++) {\n    if (arr[start] !== '') {\n      break;\n    }\n  }\n\n  let end = arr.length - 1;\n  for (; end >= 0; end--) {\n    if (arr[end] !== '') {\n      break;\n    }\n  }\n\n  if (start > end) {\n    return [];\n  }\n  return arr.slice(start, end - start + 1);\n}\n\n// path.relative(from, to)\n// posix version\n/** JSDoc */\nfunction relative(from, to) {\n  /* eslint-disable no-param-reassign */\n  from = resolve(from).slice(1);\n  to = resolve(to).slice(1);\n  /* eslint-enable no-param-reassign */\n\n  const fromParts = trim(from.split('/'));\n  const toParts = trim(to.split('/'));\n\n  const length = Math.min(fromParts.length, toParts.length);\n  let samePartsLength = length;\n  for (let i = 0; i < length; i++) {\n    if (fromParts[i] !== toParts[i]) {\n      samePartsLength = i;\n      break;\n    }\n  }\n\n  let outputParts = [];\n  for (let i = samePartsLength; i < fromParts.length; i++) {\n    outputParts.push('..');\n  }\n\n  outputParts = outputParts.concat(toParts.slice(samePartsLength));\n\n  return outputParts.join('/');\n}\n\n// path.normalize(path)\n// posix version\n/** JSDoc */\nfunction normalizePath(path) {\n  const isPathAbsolute = isAbsolute(path);\n  const trailingSlash = path.slice(-1) === '/';\n\n  // Normalize the path\n  let normalizedPath = normalizeArray(\n    path.split('/').filter(p => !!p),\n    !isPathAbsolute,\n  ).join('/');\n\n  if (!normalizedPath && !isPathAbsolute) {\n    normalizedPath = '.';\n  }\n  if (normalizedPath && trailingSlash) {\n    normalizedPath += '/';\n  }\n\n  return (isPathAbsolute ? '/' : '') + normalizedPath;\n}\n\n// posix version\n/** JSDoc */\nfunction isAbsolute(path) {\n  return path.charAt(0) === '/';\n}\n\n// posix version\n/** JSDoc */\nfunction join(...args) {\n  return normalizePath(args.join('/'));\n}\n\n/** JSDoc */\nfunction dirname(path) {\n  const result = splitPath(path);\n  const root = result[0];\n  let dir = result[1];\n\n  if (!root && !dir) {\n    // No dirname whatsoever\n    return '.';\n  }\n\n  if (dir) {\n    // It has a dirname, strip trailing slash\n    dir = dir.slice(0, dir.length - 1);\n  }\n\n  return root + dir;\n}\n\n/** JSDoc */\nfunction basename(path, ext) {\n  let f = splitPath(path)[2];\n  if (ext && f.slice(ext.length * -1) === ext) {\n    f = f.slice(0, f.length - ext.length);\n  }\n  return f;\n}\n\nexport { basename, dirname, isAbsolute, join, normalizePath, relative, resolve };\n//# sourceMappingURL=path.js.map\n","import { SentryError } from './error.js';\nimport { rejectedSyncPromise, SyncPromise, resolvedSyncPromise } from './syncpromise.js';\n\n/**\n * Creates an new PromiseBuffer object with the specified limit\n * @param limit max number of promises that can be stored in the buffer\n */\nfunction makePromiseBuffer(limit) {\n  const buffer = [];\n\n  function isReady() {\n    return limit === undefined || buffer.length < limit;\n  }\n\n  /**\n   * Remove a promise from the queue.\n   *\n   * @param task Can be any PromiseLike<T>\n   * @returns Removed promise.\n   */\n  function remove(task) {\n    return buffer.splice(buffer.indexOf(task), 1)[0];\n  }\n\n  /**\n   * Add a promise (representing an in-flight action) to the queue, and set it to remove itself on fulfillment.\n   *\n   * @param taskProducer A function producing any PromiseLike<T>; In previous versions this used to be `task:\n   *        PromiseLike<T>`, but under that model, Promises were instantly created on the call-site and their executor\n   *        functions therefore ran immediately. Thus, even if the buffer was full, the action still happened. By\n   *        requiring the promise to be wrapped in a function, we can defer promise creation until after the buffer\n   *        limit check.\n   * @returns The original promise.\n   */\n  function add(taskProducer) {\n    if (!isReady()) {\n      return rejectedSyncPromise(new SentryError('Not adding Promise because buffer limit was reached.'));\n    }\n\n    // start the task and add its promise to the queue\n    const task = taskProducer();\n    if (buffer.indexOf(task) === -1) {\n      buffer.push(task);\n    }\n    void task\n      .then(() => remove(task))\n      // Use `then(null, rejectionHandler)` rather than `catch(rejectionHandler)` so that we can use `PromiseLike`\n      // rather than `Promise`. `PromiseLike` doesn't have a `.catch` method, making its polyfill smaller. (ES5 didn't\n      // have promises, so TS has to polyfill when down-compiling.)\n      .then(null, () =>\n        remove(task).then(null, () => {\n          // We have to add another catch here because `remove()` starts a new promise chain.\n        }),\n      );\n    return task;\n  }\n\n  /**\n   * Wait for all promises in the queue to resolve or for timeout to expire, whichever comes first.\n   *\n   * @param timeout The time, in ms, after which to resolve to `false` if the queue is still non-empty. Passing `0` (or\n   * not passing anything) will make the promise wait as long as it takes for the queue to drain before resolving to\n   * `true`.\n   * @returns A promise which will resolve to `true` if the queue is already empty or drains before the timeout, and\n   * `false` otherwise\n   */\n  function drain(timeout) {\n    return new SyncPromise((resolve, reject) => {\n      let counter = buffer.length;\n\n      if (!counter) {\n        return resolve(true);\n      }\n\n      // wait for `timeout` ms and then resolve to `false` (if not cancelled first)\n      const capturedSetTimeout = setTimeout(() => {\n        if (timeout && timeout > 0) {\n          resolve(false);\n        }\n      }, timeout);\n\n      // if all promises resolve in time, cancel the timer and resolve to `true`\n      buffer.forEach(item => {\n        void resolvedSyncPromise(item).then(() => {\n          if (!--counter) {\n            clearTimeout(capturedSetTimeout);\n            resolve(true);\n          }\n        }, reject);\n      });\n    });\n  }\n\n  return {\n    $: buffer,\n    add,\n    drain,\n  };\n}\n\nexport { makePromiseBuffer };\n//# sourceMappingURL=promisebuffer.js.map\n","// Intentionally keeping the key broad, as we don't know for sure what rate limit headers get returned from backend\n\nconst DEFAULT_RETRY_AFTER = 60 * 1000; // 60 seconds\n\n/**\n * Extracts Retry-After value from the request header or returns default value\n * @param header string representation of 'Retry-After' header\n * @param now current unix timestamp\n *\n */\nfunction parseRetryAfterHeader(header, now = Date.now()) {\n  const headerDelay = parseInt(`${header}`, 10);\n  if (!isNaN(headerDelay)) {\n    return headerDelay * 1000;\n  }\n\n  const headerDate = Date.parse(`${header}`);\n  if (!isNaN(headerDate)) {\n    return headerDate - now;\n  }\n\n  return DEFAULT_RETRY_AFTER;\n}\n\n/**\n * Gets the time that the given category is disabled until for rate limiting.\n * In case no category-specific limit is set but a general rate limit across all categories is active,\n * that time is returned.\n *\n * @return the time in ms that the category is disabled until or 0 if there's no active rate limit.\n */\nfunction disabledUntil(limits, dataCategory) {\n  return limits[dataCategory] || limits.all || 0;\n}\n\n/**\n * Checks if a category is rate limited\n */\nfunction isRateLimited(limits, dataCategory, now = Date.now()) {\n  return disabledUntil(limits, dataCategory) > now;\n}\n\n/**\n * Update ratelimits from incoming headers.\n *\n * @return the updated RateLimits object.\n */\nfunction updateRateLimits(\n  limits,\n  { statusCode, headers },\n  now = Date.now(),\n) {\n  const updatedRateLimits = {\n    ...limits,\n  };\n\n  // \"The name is case-insensitive.\"\n  // https://developer.mozilla.org/en-US/docs/Web/API/Headers/get\n  const rateLimitHeader = headers && headers['x-sentry-rate-limits'];\n  const retryAfterHeader = headers && headers['retry-after'];\n\n  if (rateLimitHeader) {\n    /**\n     * rate limit headers are of the form\n     *     <header>,<header>,..\n     * where each <header> is of the form\n     *     <retry_after>: <categories>: <scope>: <reason_code>: <namespaces>\n     * where\n     *     <retry_after> is a delay in seconds\n     *     <categories> is the event type(s) (error, transaction, etc) being rate limited and is of the form\n     *         <category>;<category>;...\n     *     <scope> is what's being limited (org, project, or key) - ignored by SDK\n     *     <reason_code> is an arbitrary string like \"org_quota\" - ignored by SDK\n     *     <namespaces> Semicolon-separated list of metric namespace identifiers. Defines which namespace(s) will be affected.\n     *         Only present if rate limit applies to the metric_bucket data category.\n     */\n    for (const limit of rateLimitHeader.trim().split(',')) {\n      const [retryAfter, categories, , , namespaces] = limit.split(':', 5);\n      const headerDelay = parseInt(retryAfter, 10);\n      const delay = (!isNaN(headerDelay) ? headerDelay : 60) * 1000; // 60sec default\n      if (!categories) {\n        updatedRateLimits.all = now + delay;\n      } else {\n        for (const category of categories.split(';')) {\n          if (category === 'metric_bucket') {\n            // namespaces will be present when category === 'metric_bucket'\n            if (!namespaces || namespaces.split(';').includes('custom')) {\n              updatedRateLimits[category] = now + delay;\n            }\n          } else {\n            updatedRateLimits[category] = now + delay;\n          }\n        }\n      }\n    }\n  } else if (retryAfterHeader) {\n    updatedRateLimits.all = now + parseRetryAfterHeader(retryAfterHeader, now);\n  } else if (statusCode === 429) {\n    updatedRateLimits.all = now + 60 * 1000;\n  }\n\n  return updatedRateLimits;\n}\n\nexport { DEFAULT_RETRY_AFTER, disabledUntil, isRateLimited, parseRetryAfterHeader, updateRateLimits };\n//# sourceMappingURL=ratelimit.js.map\n","// Note: Ideally the `SeverityLevel` type would be derived from `validSeverityLevels`, but that would mean either\n//\n// a) moving `validSeverityLevels` to `@sentry/types`,\n// b) moving the`SeverityLevel` type here, or\n// c) importing `validSeverityLevels` from here into `@sentry/types`.\n//\n// Option A would make `@sentry/types` a runtime dependency of `@sentry/utils` (not good), and options B and C would\n// create a circular dependency between `@sentry/types` and `@sentry/utils` (also not good). So a TODO accompanying the\n// type, reminding anyone who changes it to change this list also, will have to do.\n\nconst validSeverityLevels = ['fatal', 'error', 'warning', 'log', 'info', 'debug'];\n\n/**\n * Converts a string-based level into a member of the deprecated {@link Severity} enum.\n *\n * @deprecated `severityFromString` is deprecated. Please use `severityLevelFromString` instead.\n *\n * @param level String representation of Severity\n * @returns Severity\n */\nfunction severityFromString(level) {\n  return severityLevelFromString(level) ;\n}\n\n/**\n * Converts a string-based level into a `SeverityLevel`, normalizing it along the way.\n *\n * @param level String representation of desired `SeverityLevel`.\n * @returns The `SeverityLevel` corresponding to the given string, or 'log' if the string isn't a valid level.\n */\nfunction severityLevelFromString(level) {\n  return (level === 'warn' ? 'warning' : validSeverityLevels.includes(level) ? level : 'log') ;\n}\n\nexport { severityFromString, severityLevelFromString, validSeverityLevels };\n//# sourceMappingURL=severity.js.map\n","import { node } from './node-stack-trace.js';\nexport { filenameIsInApp } from './node-stack-trace.js';\n\nconst STACKTRACE_FRAME_LIMIT = 50;\n// Used to sanitize webpack (error: *) wrapped stack errors\nconst WEBPACK_ERROR_REGEXP = /\\(error: (.*)\\)/;\nconst STRIP_FRAME_REGEXP = /captureMessage|captureException/;\n\n/**\n * Creates a stack parser with the supplied line parsers\n *\n * StackFrames are returned in the correct order for Sentry Exception\n * frames and with Sentry SDK internal frames removed from the top and bottom\n *\n */\nfunction createStackParser(...parsers) {\n  const sortedParsers = parsers.sort((a, b) => a[0] - b[0]).map(p => p[1]);\n\n  return (stack, skipFirst = 0) => {\n    const frames = [];\n    const lines = stack.split('\\n');\n\n    for (let i = skipFirst; i < lines.length; i++) {\n      const line = lines[i];\n      // Ignore lines over 1kb as they are unlikely to be stack frames.\n      // Many of the regular expressions use backtracking which results in run time that increases exponentially with\n      // input size. Huge strings can result in hangs/Denial of Service:\n      // https://github.com/getsentry/sentry-javascript/issues/2286\n      if (line.length > 1024) {\n        continue;\n      }\n\n      // https://github.com/getsentry/sentry-javascript/issues/5459\n      // Remove webpack (error: *) wrappers\n      const cleanedLine = WEBPACK_ERROR_REGEXP.test(line) ? line.replace(WEBPACK_ERROR_REGEXP, '$1') : line;\n\n      // https://github.com/getsentry/sentry-javascript/issues/7813\n      // Skip Error: lines\n      if (cleanedLine.match(/\\S*Error: /)) {\n        continue;\n      }\n\n      for (const parser of sortedParsers) {\n        const frame = parser(cleanedLine);\n\n        if (frame) {\n          frames.push(frame);\n          break;\n        }\n      }\n\n      if (frames.length >= STACKTRACE_FRAME_LIMIT) {\n        break;\n      }\n    }\n\n    return stripSentryFramesAndReverse(frames);\n  };\n}\n\n/**\n * Gets a stack parser implementation from Options.stackParser\n * @see Options\n *\n * If options contains an array of line parsers, it is converted into a parser\n */\nfunction stackParserFromStackParserOptions(stackParser) {\n  if (Array.isArray(stackParser)) {\n    return createStackParser(...stackParser);\n  }\n  return stackParser;\n}\n\n/**\n * Removes Sentry frames from the top and bottom of the stack if present and enforces a limit of max number of frames.\n * Assumes stack input is ordered from top to bottom and returns the reverse representation so call site of the\n * function that caused the crash is the last frame in the array.\n * @hidden\n */\nfunction stripSentryFramesAndReverse(stack) {\n  if (!stack.length) {\n    return [];\n  }\n\n  const localStack = Array.from(stack);\n\n  // If stack starts with one of our API calls, remove it (starts, meaning it's the top of the stack - aka last call)\n  if (/sentryWrapped/.test(localStack[localStack.length - 1].function || '')) {\n    localStack.pop();\n  }\n\n  // Reversing in the middle of the procedure allows us to just pop the values off the stack\n  localStack.reverse();\n\n  // If stack ends with one of our internal API calls, remove it (ends, meaning it's the bottom of the stack - aka top-most call)\n  if (STRIP_FRAME_REGEXP.test(localStack[localStack.length - 1].function || '')) {\n    localStack.pop();\n\n    // When using synthetic events, we will have a 2 levels deep stack, as `new Error('Sentry syntheticException')`\n    // is produced within the hub itself, making it:\n    //\n    //   Sentry.captureException()\n    //   getCurrentHub().captureException()\n    //\n    // instead of just the top `Sentry` call itself.\n    // This forces us to possibly strip an additional frame in the exact same was as above.\n    if (STRIP_FRAME_REGEXP.test(localStack[localStack.length - 1].function || '')) {\n      localStack.pop();\n    }\n  }\n\n  return localStack.slice(0, STACKTRACE_FRAME_LIMIT).map(frame => ({\n    ...frame,\n    filename: frame.filename || localStack[localStack.length - 1].filename,\n    function: frame.function || '?',\n  }));\n}\n\nconst defaultFunctionName = '<anonymous>';\n\n/**\n * Safely extract function name from itself\n */\nfunction getFunctionName(fn) {\n  try {\n    if (!fn || typeof fn !== 'function') {\n      return defaultFunctionName;\n    }\n    return fn.name || defaultFunctionName;\n  } catch (e) {\n    // Just accessing custom props in some Selenium environments\n    // can cause a \"Permission denied\" exception (see raven-js#495).\n    return defaultFunctionName;\n  }\n}\n\n/**\n * Node.js stack line parser\n *\n * This is in @sentry/utils so it can be used from the Electron SDK in the browser for when `nodeIntegration == true`.\n * This allows it to be used without referencing or importing any node specific code which causes bundlers to complain\n */\nfunction nodeStackLineParser(getModule) {\n  return [90, node(getModule)];\n}\n\nexport { createStackParser, getFunctionName, nodeStackLineParser, stackParserFromStackParserOptions, stripSentryFramesAndReverse };\n//# sourceMappingURL=stacktrace.js.map\n","import { isVueViewModel, isString, isRegExp } from './is.js';\n\n/**\n * Truncates given string to the maximum characters count\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string (0 = unlimited)\n * @returns string Encoded\n */\nfunction truncate(str, max = 0) {\n  if (typeof str !== 'string' || max === 0) {\n    return str;\n  }\n  return str.length <= max ? str : `${str.slice(0, max)}...`;\n}\n\n/**\n * This is basically just `trim_line` from\n * https://github.com/getsentry/sentry/blob/master/src/sentry/lang/javascript/processor.py#L67\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string\n * @returns string Encoded\n */\nfunction snipLine(line, colno) {\n  let newLine = line;\n  const lineLength = newLine.length;\n  if (lineLength <= 150) {\n    return newLine;\n  }\n  if (colno > lineLength) {\n    // eslint-disable-next-line no-param-reassign\n    colno = lineLength;\n  }\n\n  let start = Math.max(colno - 60, 0);\n  if (start < 5) {\n    start = 0;\n  }\n\n  let end = Math.min(start + 140, lineLength);\n  if (end > lineLength - 5) {\n    end = lineLength;\n  }\n  if (end === lineLength) {\n    start = Math.max(end - 140, 0);\n  }\n\n  newLine = newLine.slice(start, end);\n  if (start > 0) {\n    newLine = `'{snip} ${newLine}`;\n  }\n  if (end < lineLength) {\n    newLine += ' {snip}';\n  }\n\n  return newLine;\n}\n\n/**\n * Join values in array\n * @param input array of values to be joined together\n * @param delimiter string to be placed in-between values\n * @returns Joined values\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction safeJoin(input, delimiter) {\n  if (!Array.isArray(input)) {\n    return '';\n  }\n\n  const output = [];\n  // eslint-disable-next-line @typescript-eslint/prefer-for-of\n  for (let i = 0; i < input.length; i++) {\n    const value = input[i];\n    try {\n      // This is a hack to fix a Vue3-specific bug that causes an infinite loop of\n      // console warnings. This happens when a Vue template is rendered with\n      // an undeclared variable, which we try to stringify, ultimately causing\n      // Vue to issue another warning which repeats indefinitely.\n      // see: https://github.com/getsentry/sentry-javascript/pull/8981\n      if (isVueViewModel(value)) {\n        output.push('[VueViewModel]');\n      } else {\n        output.push(String(value));\n      }\n    } catch (e) {\n      output.push('[value cannot be serialized]');\n    }\n  }\n\n  return output.join(delimiter);\n}\n\n/**\n * Checks if the given value matches a regex or string\n *\n * @param value The string to test\n * @param pattern Either a regex or a string against which `value` will be matched\n * @param requireExactStringMatch If true, `value` must match `pattern` exactly. If false, `value` will match\n * `pattern` if it contains `pattern`. Only applies to string-type patterns.\n */\nfunction isMatchingPattern(\n  value,\n  pattern,\n  requireExactStringMatch = false,\n) {\n  if (!isString(value)) {\n    return false;\n  }\n\n  if (isRegExp(pattern)) {\n    return pattern.test(value);\n  }\n  if (isString(pattern)) {\n    return requireExactStringMatch ? value === pattern : value.includes(pattern);\n  }\n\n  return false;\n}\n\n/**\n * Test the given string against an array of strings and regexes. By default, string matching is done on a\n * substring-inclusion basis rather than a strict equality basis\n *\n * @param testString The string to test\n * @param patterns The patterns against which to test the string\n * @param requireExactStringMatch If true, `testString` must match one of the given string patterns exactly in order to\n * count. If false, `testString` will match a string pattern if it contains that pattern.\n * @returns\n */\nfunction stringMatchesSomePattern(\n  testString,\n  patterns = [],\n  requireExactStringMatch = false,\n) {\n  return patterns.some(pattern => isMatchingPattern(testString, pattern, requireExactStringMatch));\n}\n\nexport { isMatchingPattern, safeJoin, snipLine, stringMatchesSomePattern, truncate };\n//# sourceMappingURL=string.js.map\n","import { DEBUG_BUILD } from './debug-build.js';\nimport { logger } from './logger.js';\nimport { getGlobalObject } from './worldwide.js';\n\n// eslint-disable-next-line deprecation/deprecation\nconst WINDOW = getGlobalObject();\n\n/**\n * Tells whether current environment supports ErrorEvent objects\n * {@link supportsErrorEvent}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsErrorEvent() {\n  try {\n    new ErrorEvent('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports DOMError objects\n * {@link supportsDOMError}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsDOMError() {\n  try {\n    // Chrome: VM89:1 Uncaught TypeError: Failed to construct 'DOMError':\n    // 1 argument required, but only 0 present.\n    // @ts-expect-error It really needs 1 argument, not 0.\n    new DOMError('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports DOMException objects\n * {@link supportsDOMException}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsDOMException() {\n  try {\n    new DOMException('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports Fetch API\n * {@link supportsFetch}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsFetch() {\n  if (!('fetch' in WINDOW)) {\n    return false;\n  }\n\n  try {\n    new Headers();\n    new Request('http://www.example.com');\n    new Response();\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n/**\n * isNativeFetch checks if the given function is a native implementation of fetch()\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nfunction isNativeFetch(func) {\n  return func && /^function fetch\\(\\)\\s+\\{\\s+\\[native code\\]\\s+\\}$/.test(func.toString());\n}\n\n/**\n * Tells whether current environment supports Fetch API natively\n * {@link supportsNativeFetch}.\n *\n * @returns true if `window.fetch` is natively implemented, false otherwise\n */\nfunction supportsNativeFetch() {\n  if (typeof EdgeRuntime === 'string') {\n    return true;\n  }\n\n  if (!supportsFetch()) {\n    return false;\n  }\n\n  // Fast path to avoid DOM I/O\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  if (isNativeFetch(WINDOW.fetch)) {\n    return true;\n  }\n\n  // window.fetch is implemented, but is polyfilled or already wrapped (e.g: by a chrome extension)\n  // so create a \"pure\" iframe to see if that has native fetch\n  let result = false;\n  const doc = WINDOW.document;\n  // eslint-disable-next-line deprecation/deprecation\n  if (doc && typeof (doc.createElement ) === 'function') {\n    try {\n      const sandbox = doc.createElement('iframe');\n      sandbox.hidden = true;\n      doc.head.appendChild(sandbox);\n      if (sandbox.contentWindow && sandbox.contentWindow.fetch) {\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        result = isNativeFetch(sandbox.contentWindow.fetch);\n      }\n      doc.head.removeChild(sandbox);\n    } catch (err) {\n      DEBUG_BUILD &&\n        logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);\n    }\n  }\n\n  return result;\n}\n\n/**\n * Tells whether current environment supports ReportingObserver API\n * {@link supportsReportingObserver}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsReportingObserver() {\n  return 'ReportingObserver' in WINDOW;\n}\n\n/**\n * Tells whether current environment supports Referrer Policy API\n * {@link supportsReferrerPolicy}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsReferrerPolicy() {\n  // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default'\n  // (see https://caniuse.com/#feat=referrer-policy),\n  // it doesn't. And it throws an exception instead of ignoring this parameter...\n  // REF: https://github.com/getsentry/raven-js/issues/1233\n\n  if (!supportsFetch()) {\n    return false;\n  }\n\n  try {\n    new Request('_', {\n      referrerPolicy: 'origin' ,\n    });\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\nexport { isNativeFetch, supportsDOMError, supportsDOMException, supportsErrorEvent, supportsFetch, supportsNativeFetch, supportsReferrerPolicy, supportsReportingObserver };\n//# sourceMappingURL=supports.js.map\n","import { isThenable } from './is.js';\n\n/* eslint-disable @typescript-eslint/explicit-function-return-type */\n\n/** SyncPromise internal states */\nvar States; (function (States) {\n  /** Pending */\n  const PENDING = 0; States[States[\"PENDING\"] = PENDING] = \"PENDING\";\n  /** Resolved / OK */\n  const RESOLVED = 1; States[States[\"RESOLVED\"] = RESOLVED] = \"RESOLVED\";\n  /** Rejected / Error */\n  const REJECTED = 2; States[States[\"REJECTED\"] = REJECTED] = \"REJECTED\";\n})(States || (States = {}));\n\n// Overloads so we can call resolvedSyncPromise without arguments and generic argument\n\n/**\n * Creates a resolved sync promise.\n *\n * @param value the value to resolve the promise with\n * @returns the resolved sync promise\n */\nfunction resolvedSyncPromise(value) {\n  return new SyncPromise(resolve => {\n    resolve(value);\n  });\n}\n\n/**\n * Creates a rejected sync promise.\n *\n * @param value the value to reject the promise with\n * @returns the rejected sync promise\n */\nfunction rejectedSyncPromise(reason) {\n  return new SyncPromise((_, reject) => {\n    reject(reason);\n  });\n}\n\n/**\n * Thenable class that behaves like a Promise and follows it's interface\n * but is not async internally\n */\nclass SyncPromise {\n\n   constructor(\n    executor,\n  ) {SyncPromise.prototype.__init.call(this);SyncPromise.prototype.__init2.call(this);SyncPromise.prototype.__init3.call(this);SyncPromise.prototype.__init4.call(this);\n    this._state = States.PENDING;\n    this._handlers = [];\n\n    try {\n      executor(this._resolve, this._reject);\n    } catch (e) {\n      this._reject(e);\n    }\n  }\n\n  /** JSDoc */\n   then(\n    onfulfilled,\n    onrejected,\n  ) {\n    return new SyncPromise((resolve, reject) => {\n      this._handlers.push([\n        false,\n        result => {\n          if (!onfulfilled) {\n            // TODO: ¯\\_(ツ)_/¯\n            // TODO: FIXME\n            resolve(result );\n          } else {\n            try {\n              resolve(onfulfilled(result));\n            } catch (e) {\n              reject(e);\n            }\n          }\n        },\n        reason => {\n          if (!onrejected) {\n            reject(reason);\n          } else {\n            try {\n              resolve(onrejected(reason));\n            } catch (e) {\n              reject(e);\n            }\n          }\n        },\n      ]);\n      this._executeHandlers();\n    });\n  }\n\n  /** JSDoc */\n   catch(\n    onrejected,\n  ) {\n    return this.then(val => val, onrejected);\n  }\n\n  /** JSDoc */\n   finally(onfinally) {\n    return new SyncPromise((resolve, reject) => {\n      let val;\n      let isRejected;\n\n      return this.then(\n        value => {\n          isRejected = false;\n          val = value;\n          if (onfinally) {\n            onfinally();\n          }\n        },\n        reason => {\n          isRejected = true;\n          val = reason;\n          if (onfinally) {\n            onfinally();\n          }\n        },\n      ).then(() => {\n        if (isRejected) {\n          reject(val);\n          return;\n        }\n\n        resolve(val );\n      });\n    });\n  }\n\n  /** JSDoc */\n    __init() {this._resolve = (value) => {\n    this._setResult(States.RESOLVED, value);\n  };}\n\n  /** JSDoc */\n    __init2() {this._reject = (reason) => {\n    this._setResult(States.REJECTED, reason);\n  };}\n\n  /** JSDoc */\n    __init3() {this._setResult = (state, value) => {\n    if (this._state !== States.PENDING) {\n      return;\n    }\n\n    if (isThenable(value)) {\n      void (value ).then(this._resolve, this._reject);\n      return;\n    }\n\n    this._state = state;\n    this._value = value;\n\n    this._executeHandlers();\n  };}\n\n  /** JSDoc */\n    __init4() {this._executeHandlers = () => {\n    if (this._state === States.PENDING) {\n      return;\n    }\n\n    const cachedHandlers = this._handlers.slice();\n    this._handlers = [];\n\n    cachedHandlers.forEach(handler => {\n      if (handler[0]) {\n        return;\n      }\n\n      if (this._state === States.RESOLVED) {\n        // eslint-disable-next-line @typescript-eslint/no-floating-promises\n        handler[1](this._value );\n      }\n\n      if (this._state === States.REJECTED) {\n        handler[2](this._value);\n      }\n\n      handler[0] = true;\n    });\n  };}\n}\n\nexport { SyncPromise, rejectedSyncPromise, resolvedSyncPromise };\n//# sourceMappingURL=syncpromise.js.map\n","import { GLOBAL_OBJ } from './worldwide.js';\n\nconst ONE_SECOND_IN_MS = 1000;\n\n/**\n * A partial definition of the [Performance Web API]{@link https://developer.mozilla.org/en-US/docs/Web/API/Performance}\n * for accessing a high-resolution monotonic clock.\n */\n\n/**\n * Returns a timestamp in seconds since the UNIX epoch using the Date API.\n *\n * TODO(v8): Return type should be rounded.\n */\nfunction dateTimestampInSeconds() {\n  return Date.now() / ONE_SECOND_IN_MS;\n}\n\n/**\n * Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not\n * support the API.\n *\n * Wrapping the native API works around differences in behavior from different browsers.\n */\nfunction createUnixTimestampInSecondsFunc() {\n  const { performance } = GLOBAL_OBJ ;\n  if (!performance || !performance.now) {\n    return dateTimestampInSeconds;\n  }\n\n  // Some browser and environments don't have a timeOrigin, so we fallback to\n  // using Date.now() to compute the starting time.\n  const approxStartingTimeOrigin = Date.now() - performance.now();\n  const timeOrigin = performance.timeOrigin == undefined ? approxStartingTimeOrigin : performance.timeOrigin;\n\n  // performance.now() is a monotonic clock, which means it starts at 0 when the process begins. To get the current\n  // wall clock time (actual UNIX timestamp), we need to add the starting time origin and the current time elapsed.\n  //\n  // TODO: This does not account for the case where the monotonic clock that powers performance.now() drifts from the\n  // wall clock time, which causes the returned timestamp to be inaccurate. We should investigate how to detect and\n  // correct for this.\n  // See: https://github.com/getsentry/sentry-javascript/issues/2590\n  // See: https://github.com/mdn/content/issues/4713\n  // See: https://dev.to/noamr/when-a-millisecond-is-not-a-millisecond-3h6\n  return () => {\n    return (timeOrigin + performance.now()) / ONE_SECOND_IN_MS;\n  };\n}\n\n/**\n * Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the\n * availability of the Performance API.\n *\n * BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is\n * asleep. This creates a skew between `dateTimestampInSeconds` and `timestampInSeconds`. The\n * skew can grow to arbitrary amounts like days, weeks or months.\n * See https://github.com/getsentry/sentry-javascript/issues/2590.\n */\nconst timestampInSeconds = createUnixTimestampInSecondsFunc();\n\n/**\n * Re-exported with an old name for backwards-compatibility.\n * TODO (v8): Remove this\n *\n * @deprecated Use `timestampInSeconds` instead.\n */\nconst timestampWithMs = timestampInSeconds;\n\n/**\n * Internal helper to store what is the source of browserPerformanceTimeOrigin below. For debugging only.\n */\nlet _browserPerformanceTimeOriginMode;\n\n/**\n * The number of milliseconds since the UNIX epoch. This value is only usable in a browser, and only when the\n * performance API is available.\n */\nconst browserPerformanceTimeOrigin = (() => {\n  // Unfortunately browsers may report an inaccurate time origin data, through either performance.timeOrigin or\n  // performance.timing.navigationStart, which results in poor results in performance data. We only treat time origin\n  // data as reliable if they are within a reasonable threshold of the current time.\n\n  const { performance } = GLOBAL_OBJ ;\n  if (!performance || !performance.now) {\n    _browserPerformanceTimeOriginMode = 'none';\n    return undefined;\n  }\n\n  const threshold = 3600 * 1000;\n  const performanceNow = performance.now();\n  const dateNow = Date.now();\n\n  // if timeOrigin isn't available set delta to threshold so it isn't used\n  const timeOriginDelta = performance.timeOrigin\n    ? Math.abs(performance.timeOrigin + performanceNow - dateNow)\n    : threshold;\n  const timeOriginIsReliable = timeOriginDelta < threshold;\n\n  // While performance.timing.navigationStart is deprecated in favor of performance.timeOrigin, performance.timeOrigin\n  // is not as widely supported. Namely, performance.timeOrigin is undefined in Safari as of writing.\n  // Also as of writing, performance.timing is not available in Web Workers in mainstream browsers, so it is not always\n  // a valid fallback. In the absence of an initial time provided by the browser, fallback to the current time from the\n  // Date API.\n  // eslint-disable-next-line deprecation/deprecation\n  const navigationStart = performance.timing && performance.timing.navigationStart;\n  const hasNavigationStart = typeof navigationStart === 'number';\n  // if navigationStart isn't available set delta to threshold so it isn't used\n  const navigationStartDelta = hasNavigationStart ? Math.abs(navigationStart + performanceNow - dateNow) : threshold;\n  const navigationStartIsReliable = navigationStartDelta < threshold;\n\n  if (timeOriginIsReliable || navigationStartIsReliable) {\n    // Use the more reliable time origin\n    if (timeOriginDelta <= navigationStartDelta) {\n      _browserPerformanceTimeOriginMode = 'timeOrigin';\n      return performance.timeOrigin;\n    } else {\n      _browserPerformanceTimeOriginMode = 'navigationStart';\n      return navigationStart;\n    }\n  }\n\n  // Either both timeOrigin and navigationStart are skewed or neither is available, fallback to Date.\n  _browserPerformanceTimeOriginMode = 'dateNow';\n  return dateNow;\n})();\n\nexport { _browserPerformanceTimeOriginMode, browserPerformanceTimeOrigin, dateTimestampInSeconds, timestampInSeconds, timestampWithMs };\n//# sourceMappingURL=time.js.map\n","import { baggageHeaderToDynamicSamplingContext } from './baggage.js';\nimport { uuid4 } from './misc.js';\n\n// eslint-disable-next-line @sentry-internal/sdk/no-regexp-constructor -- RegExp is used for readability here\nconst TRACEPARENT_REGEXP = new RegExp(\n  '^[ \\\\t]*' + // whitespace\n    '([0-9a-f]{32})?' + // trace_id\n    '-?([0-9a-f]{16})?' + // span_id\n    '-?([01])?' + // sampled\n    '[ \\\\t]*$', // whitespace\n);\n\n/**\n * Extract transaction context data from a `sentry-trace` header.\n *\n * @param traceparent Traceparent string\n *\n * @returns Object containing data from the header, or undefined if traceparent string is malformed\n */\nfunction extractTraceparentData(traceparent) {\n  if (!traceparent) {\n    return undefined;\n  }\n\n  const matches = traceparent.match(TRACEPARENT_REGEXP);\n  if (!matches) {\n    return undefined;\n  }\n\n  let parentSampled;\n  if (matches[3] === '1') {\n    parentSampled = true;\n  } else if (matches[3] === '0') {\n    parentSampled = false;\n  }\n\n  return {\n    traceId: matches[1],\n    parentSampled,\n    parentSpanId: matches[2],\n  };\n}\n\n/**\n * Create tracing context from incoming headers.\n *\n * @deprecated Use `propagationContextFromHeaders` instead.\n */\n// TODO(v8): Remove this function\nfunction tracingContextFromHeaders(\n  sentryTrace,\n  baggage,\n)\n\n {\n  const traceparentData = extractTraceparentData(sentryTrace);\n  const dynamicSamplingContext = baggageHeaderToDynamicSamplingContext(baggage);\n\n  const { traceId, parentSpanId, parentSampled } = traceparentData || {};\n\n  if (!traceparentData) {\n    return {\n      traceparentData,\n      dynamicSamplingContext: undefined,\n      propagationContext: {\n        traceId: traceId || uuid4(),\n        spanId: uuid4().substring(16),\n      },\n    };\n  } else {\n    return {\n      traceparentData,\n      dynamicSamplingContext: dynamicSamplingContext || {}, // If we have traceparent data but no DSC it means we are not head of trace and we must freeze it\n      propagationContext: {\n        traceId: traceId || uuid4(),\n        parentSpanId: parentSpanId || uuid4().substring(16),\n        spanId: uuid4().substring(16),\n        sampled: parentSampled,\n        dsc: dynamicSamplingContext || {}, // If we have traceparent data but no DSC it means we are not head of trace and we must freeze it\n      },\n    };\n  }\n}\n\n/**\n * Create a propagation context from incoming headers.\n */\nfunction propagationContextFromHeaders(\n  sentryTrace,\n  baggage,\n) {\n  const traceparentData = extractTraceparentData(sentryTrace);\n  const dynamicSamplingContext = baggageHeaderToDynamicSamplingContext(baggage);\n\n  const { traceId, parentSpanId, parentSampled } = traceparentData || {};\n\n  if (!traceparentData) {\n    return {\n      traceId: traceId || uuid4(),\n      spanId: uuid4().substring(16),\n    };\n  } else {\n    return {\n      traceId: traceId || uuid4(),\n      parentSpanId: parentSpanId || uuid4().substring(16),\n      spanId: uuid4().substring(16),\n      sampled: parentSampled,\n      dsc: dynamicSamplingContext || {}, // If we have traceparent data but no DSC it means we are not head of trace and we must freeze it\n    };\n  }\n}\n\n/**\n * Create sentry-trace header from span context values.\n */\nfunction generateSentryTraceHeader(\n  traceId = uuid4(),\n  spanId = uuid4().substring(16),\n  sampled,\n) {\n  let sampledString = '';\n  if (sampled !== undefined) {\n    sampledString = sampled ? '-1' : '-0';\n  }\n  return `${traceId}-${spanId}${sampledString}`;\n}\n\nexport { TRACEPARENT_REGEXP, extractTraceparentData, generateSentryTraceHeader, propagationContextFromHeaders, tracingContextFromHeaders };\n//# sourceMappingURL=tracing.js.map\n","/**\n * Parses string form of URL into an object\n * // borrowed from https://tools.ietf.org/html/rfc3986#appendix-B\n * // intentionally using regex and not <a/> href parsing trick because React Native and other\n * // environments where DOM might not be available\n * @returns parsed URL object\n */\nfunction parseUrl(url) {\n  if (!url) {\n    return {};\n  }\n\n  const match = url.match(/^(([^:/?#]+):)?(\\/\\/([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$/);\n\n  if (!match) {\n    return {};\n  }\n\n  // coerce to undefined values to empty string so we don't get 'undefined'\n  const query = match[6] || '';\n  const fragment = match[8] || '';\n  return {\n    host: match[4],\n    path: match[5],\n    protocol: match[2],\n    search: query,\n    hash: fragment,\n    relative: match[5] + query + fragment, // everything minus origin\n  };\n}\n\n/**\n * Strip the query string and fragment off of a given URL or path (if present)\n *\n * @param urlPath Full URL or path, including possible query string and/or fragment\n * @returns URL or path without query string or fragment\n */\nfunction stripUrlQueryAndFragment(urlPath) {\n  // eslint-disable-next-line no-useless-escape\n  return urlPath.split(/[\\?#]/, 1)[0];\n}\n\n/**\n * Returns number of URL segments of a passed string URL.\n */\nfunction getNumberOfUrlSegments(url) {\n  // split at '/' or at '\\/' to split regex urls correctly\n  return url.split(/\\\\?\\//).filter(s => s.length > 0 && s !== ',').length;\n}\n\n/**\n * Takes a URL object and returns a sanitized string which is safe to use as span description\n * see: https://develop.sentry.dev/sdk/data-handling/#structuring-data\n */\nfunction getSanitizedUrlString(url) {\n  const { protocol, host, path } = url;\n\n  const filteredHost =\n    (host &&\n      host\n        // Always filter out authority\n        .replace(/^.*@/, '[filtered]:[filtered]@')\n        // Don't show standard :80 (http) and :443 (https) ports to reduce the noise\n        // TODO: Use new URL global if it exists\n        .replace(/(:80)$/, '')\n        .replace(/(:443)$/, '')) ||\n    '';\n\n  return `${protocol ? `${protocol}://` : ''}${filteredHost}${path}`;\n}\n\nexport { getNumberOfUrlSegments, getSanitizedUrlString, parseUrl, stripUrlQueryAndFragment };\n//# sourceMappingURL=url.js.map\n","/** Internal global with common properties and Sentry extensions  */\n\n// The code below for 'isGlobalObj' and 'GLOBAL_OBJ' was copied from core-js before modification\n// https://github.com/zloirock/core-js/blob/1b944df55282cdc99c90db5f49eb0b6eda2cc0a3/packages/core-js/internals/global.js\n// core-js has the following licence:\n//\n// Copyright (c) 2014-2022 Denis Pushkarev\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n/** Returns 'obj' if it's the global object, otherwise returns undefined */\nfunction isGlobalObj(obj) {\n  return obj && obj.Math == Math ? obj : undefined;\n}\n\n/** Get's the global object for the current JavaScript runtime */\nconst GLOBAL_OBJ =\n  (typeof globalThis == 'object' && isGlobalObj(globalThis)) ||\n  // eslint-disable-next-line no-restricted-globals\n  (typeof window == 'object' && isGlobalObj(window)) ||\n  (typeof self == 'object' && isGlobalObj(self)) ||\n  (typeof global == 'object' && isGlobalObj(global)) ||\n  (function () {\n    return this;\n  })() ||\n  {};\n\n/**\n * @deprecated Use GLOBAL_OBJ instead or WINDOW from @sentry/browser. This will be removed in v8\n */\nfunction getGlobalObject() {\n  return GLOBAL_OBJ ;\n}\n\n/**\n * Returns a global singleton contained in the global `__SENTRY__` object.\n *\n * If the singleton doesn't already exist in `__SENTRY__`, it will be created using the given factory\n * function and added to the `__SENTRY__` object.\n *\n * @param name name of the global singleton on __SENTRY__\n * @param creator creator Factory function to create the singleton if it doesn't already exist on `__SENTRY__`\n * @param obj (Optional) The global object on which to look for `__SENTRY__`, if not `GLOBAL_OBJ`'s return value\n * @returns the singleton\n */\nfunction getGlobalSingleton(name, creator, obj) {\n  const gbl = (obj || GLOBAL_OBJ) ;\n  const __SENTRY__ = (gbl.__SENTRY__ = gbl.__SENTRY__ || {});\n  const singleton = __SENTRY__[name] || (__SENTRY__[name] = creator());\n  return singleton;\n}\n\nexport { GLOBAL_OBJ, getGlobalObject, getGlobalSingleton };\n//# sourceMappingURL=worldwide.js.map\n","const DEFAULT_HOOKS = ['activate', 'mount', 'update'];\n\nexport { DEFAULT_HOOKS };\n//# sourceMappingURL=constants.js.map\n","import { captureException } from '@sentry/core';\nimport { consoleSandbox } from '@sentry/utils';\nimport { formatComponentName, generateComponentTrace } from './vendor/components.js';\n\nconst attachErrorHandler = (app, options) => {\n  const { errorHandler, warnHandler, silent } = app.config;\n\n  app.config.errorHandler = (error, vm, lifecycleHook) => {\n    const componentName = formatComponentName(vm, false);\n    const trace = vm ? generateComponentTrace(vm) : '';\n    const metadata = {\n      componentName,\n      lifecycleHook,\n      trace,\n    };\n\n    if (options.attachProps && vm) {\n      // Vue2 - $options.propsData\n      // Vue3 - $props\n      if (vm.$options && vm.$options.propsData) {\n        metadata.propsData = vm.$options.propsData;\n      } else if (vm.$props) {\n        metadata.propsData = vm.$props;\n      }\n    }\n\n    // Capture exception in the next event loop, to make sure that all breadcrumbs are recorded in time.\n    setTimeout(() => {\n      captureException(error, {\n        captureContext: { contexts: { vue: metadata } },\n        mechanism: { handled: false },\n      });\n    });\n\n    if (typeof errorHandler === 'function') {\n      (errorHandler ).call(app, error, vm, lifecycleHook);\n    }\n\n    if (options.logErrors) {\n      const hasConsole = typeof console !== 'undefined';\n      const message = `Error in ${lifecycleHook}: \"${error && error.toString()}\"`;\n\n      if (warnHandler) {\n        (warnHandler ).call(null, message, vm, trace);\n      } else if (hasConsole && !silent) {\n        consoleSandbox(() => {\n          // eslint-disable-next-line no-console\n          console.error(`[Vue warn]: ${message}${trace}`);\n        });\n      }\n    }\n  };\n};\n\nexport { attachErrorHandler };\n//# sourceMappingURL=errorhandler.js.map\n","import { WINDOW, captureException } from '@sentry/browser';\nimport { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, spanToJSON } from '@sentry/core';\nimport { getActiveTransaction } from './tracing.js';\n\n/**\n * Creates routing instrumentation for Vue Router v2, v3 and v4\n *\n * You can optionally pass in an options object with the available option:\n * * `routeLabel`: Set this to `route` to opt-out of using `route.name` for transaction names.\n *\n * @param router The Vue Router instance that is used\n *\n * @deprecated Use `browserTracingIntegration()` from `@sentry/vue` instead - this includes the vue router instrumentation.\n */\nfunction vueRouterInstrumentation(\n  router,\n  options = {},\n) {\n  return (\n    startTransaction,\n    startTransactionOnPageLoad = true,\n    startTransactionOnLocationChange = true,\n  ) => {\n    // We have to start the pageload transaction as early as possible (before the router's `beforeEach` hook\n    // is called) to not miss child spans of the pageload.\n    // We check that window & window.location exists in order to not run this code in SSR environments.\n    if (startTransactionOnPageLoad && WINDOW && WINDOW.location) {\n      startTransaction({\n        name: WINDOW.location.pathname,\n        op: 'pageload',\n        attributes: {\n          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.pageload.vue',\n          [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'url',\n        },\n      });\n    }\n\n    instrumentVueRouter(\n      router,\n      {\n        routeLabel: options.routeLabel || 'name',\n        instrumentNavigation: startTransactionOnLocationChange,\n        instrumentPageLoad: startTransactionOnPageLoad,\n      },\n      startTransaction,\n    );\n  };\n}\n\n/**\n * Instrument the Vue router to create navigation spans.\n */\nfunction instrumentVueRouter(\n  router,\n  options\n\n,\n  startNavigationSpanFn,\n) {\n  router.onError(error => captureException(error, { mechanism: { handled: false } }));\n\n  router.beforeEach((to, from, next) => {\n    // According to docs we could use `from === VueRouter.START_LOCATION` but I couldnt get it working for Vue 2\n    // https://router.vuejs.org/api/#router-start-location\n    // https://next.router.vuejs.org/api/#start-location\n\n    // from.name:\n    // - Vue 2: null\n    // - Vue 3: undefined\n    // hence only '==' instead of '===', because `undefined == null` evaluates to `true`\n    const isPageLoadNavigation = from.name == null && from.matched.length === 0;\n\n    const attributes = {\n      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.navigation.vue',\n    };\n\n    for (const key of Object.keys(to.params)) {\n      attributes[`params.${key}`] = to.params[key];\n    }\n    for (const key of Object.keys(to.query)) {\n      const value = to.query[key];\n      if (value) {\n        attributes[`query.${key}`] = value;\n      }\n    }\n\n    // Determine a name for the routing transaction and where that name came from\n    let transactionName = to.path;\n    let transactionSource = 'url';\n    if (to.name && options.routeLabel !== 'path') {\n      transactionName = to.name.toString();\n      transactionSource = 'custom';\n    } else if (to.matched[0] && to.matched[0].path) {\n      transactionName = to.matched[0].path;\n      transactionSource = 'route';\n    }\n\n    if (options.instrumentPageLoad && isPageLoadNavigation) {\n      // eslint-disable-next-line deprecation/deprecation\n      const pageloadTransaction = getActiveTransaction();\n      if (pageloadTransaction) {\n        const existingAttributes = spanToJSON(pageloadTransaction).data || {};\n        if (existingAttributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE] !== 'custom') {\n          pageloadTransaction.updateName(transactionName);\n          pageloadTransaction.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, transactionSource);\n        }\n        // Set router attributes on the existing pageload transaction\n        // This will  the origin, and add params & query attributes\n        pageloadTransaction.setAttributes({\n          ...attributes,\n          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.pageload.vue',\n        });\n      }\n    }\n\n    if (options.instrumentNavigation && !isPageLoadNavigation) {\n      attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE] = transactionSource;\n      startNavigationSpanFn({\n        name: transactionName,\n        op: 'navigation',\n        attributes,\n      });\n    }\n\n    // Vue Router 4 no longer exposes the `next` function, so we need to\n    // check if it's available before calling it.\n    // `next` needs to be called in Vue Router 3 so that the hook is resolved.\n    if (next) {\n      next();\n    }\n  });\n}\n\nexport { instrumentVueRouter, vueRouterInstrumentation };\n//# sourceMappingURL=router.js.map\n","import { browserTracingIntegration as browserTracingIntegration$1, startBrowserTracingNavigationSpan } from '@sentry/browser';\nimport { instrumentVueRouter } from './router.js';\n\n// The following type is an intersection of the Route type from VueRouter v2, v3, and v4.\n// This is not great, but kinda necessary to make it work with all versions at the same time.\n\n/**\n * A custom BrowserTracing integration for Vue.\n */\nfunction browserTracingIntegration(options = {}) {\n  // If router is not passed, we just use the normal implementation\n  if (!options.router) {\n    return browserTracingIntegration$1(options);\n  }\n\n  const integration = browserTracingIntegration$1({\n    ...options,\n    instrumentNavigation: false,\n  });\n\n  const { router, instrumentNavigation = true, instrumentPageLoad = true, routeLabel = 'name' } = options;\n\n  return {\n    ...integration,\n    afterAllSetup(client) {\n      integration.afterAllSetup(client);\n\n      const startNavigationSpan = (options) => {\n        startBrowserTracingNavigationSpan(client, options);\n      };\n\n      instrumentVueRouter(router, { routeLabel, instrumentNavigation, instrumentPageLoad }, startNavigationSpan);\n    },\n  };\n}\n\nexport { browserTracingIntegration };\n//# sourceMappingURL=browserTracingIntegration.js.map\n","import { defineIntegration, convertIntegrationFnToClass, hasTracingEnabled } from '@sentry/core';\nimport { GLOBAL_OBJ, consoleSandbox, arrayify } from '@sentry/utils';\nimport { DEFAULT_HOOKS } from './constants.js';\nimport { attachErrorHandler } from './errorhandler.js';\nimport { createTracingMixins } from './tracing.js';\n\nconst globalWithVue = GLOBAL_OBJ ;\n\nconst DEFAULT_CONFIG = {\n  Vue: globalWithVue.Vue,\n  attachProps: true,\n  logErrors: true,\n  hooks: DEFAULT_HOOKS,\n  timeout: 2000,\n  trackComponents: false,\n};\n\nconst INTEGRATION_NAME = 'Vue';\n\nconst _vueIntegration = ((integrationOptions = {}) => {\n  return {\n    name: INTEGRATION_NAME,\n    // TODO v8: Remove this\n    setupOnce() {}, // eslint-disable-line @typescript-eslint/no-empty-function\n    setup(client) {\n      _setupIntegration(client, integrationOptions);\n    },\n  };\n}) ;\n\nconst vueIntegration = defineIntegration(_vueIntegration);\n\n/**\n * Initialize Vue error & performance tracking.\n *\n * @deprecated Use `vueIntegration()` instead.\n */\n// eslint-disable-next-line deprecation/deprecation\nconst VueIntegration = convertIntegrationFnToClass(\n  INTEGRATION_NAME,\n  vueIntegration,\n) ;\n\nfunction _setupIntegration(client, integrationOptions) {\n  const options = { ...DEFAULT_CONFIG, ...client.getOptions(), ...integrationOptions };\n  if (!options.Vue && !options.app) {\n    consoleSandbox(() => {\n      // eslint-disable-next-line no-console\n      console.warn(\n        `[@sentry/vue]: Misconfigured SDK. Vue specific errors will not be captured.\nUpdate your \\`Sentry.init\\` call with an appropriate config option:\n\\`app\\` (Application Instance - Vue 3) or \\`Vue\\` (Vue Constructor - Vue 2).`,\n      );\n    });\n    return;\n  }\n\n  if (options.app) {\n    const apps = arrayify(options.app);\n    apps.forEach(app => vueInit(app, options));\n  } else if (options.Vue) {\n    vueInit(options.Vue, options);\n  }\n}\n\nconst vueInit = (app, options) => {\n  // Check app is not mounted yet - should be mounted _after_ init()!\n  // This is _somewhat_ private, but in the case that this doesn't exist we simply ignore it\n  // See: https://github.com/vuejs/core/blob/eb2a83283caa9de0a45881d860a3cbd9d0bdd279/packages/runtime-core/src/component.ts#L394\n  const appWithInstance = app\n\n;\n\n  const isMounted = appWithInstance._instance && appWithInstance._instance.isMounted;\n  if (isMounted === true) {\n    consoleSandbox(() => {\n      // eslint-disable-next-line no-console\n      console.warn(\n        '[@sentry/vue]: Misconfigured SDK. Vue app is already mounted. Make sure to call `app.mount()` after `Sentry.init()`.',\n      );\n    });\n  }\n\n  attachErrorHandler(app, options);\n\n  if (hasTracingEnabled(options)) {\n    app.mixin(\n      createTracingMixins({\n        ...options,\n        ...options.tracingOptions,\n      }),\n    );\n  }\n};\n\nexport { VueIntegration, vueIntegration };\n//# sourceMappingURL=integration.js.map\n","import { SDK_VERSION, getDefaultIntegrations, init as init$1 } from '@sentry/browser';\nimport { vueIntegration } from './integration.js';\n\n/**\n * Inits the Vue SDK\n */\nfunction init(\n  config = {},\n) {\n  const options = {\n    _metadata: {\n      sdk: {\n        name: 'sentry.javascript.vue',\n        packages: [\n          {\n            name: 'npm:@sentry/vue',\n            version: SDK_VERSION,\n          },\n        ],\n        version: SDK_VERSION,\n      },\n    },\n    defaultIntegrations: [...getDefaultIntegrations(config), vueIntegration()],\n    ...config,\n  };\n\n  init$1(options);\n}\n\nexport { init };\n//# sourceMappingURL=sdk.js.map\n","/**\n * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.\n *\n * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.\n */\nconst DEBUG_BUILD = (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__);\n\nexport { DEBUG_BUILD };\n//# sourceMappingURL=debug-build.js.map\n","import { getActiveSpan, startInactiveSpan, getCurrentScope } from '@sentry/browser';\nimport { logger, timestampInSeconds } from '@sentry/utils';\nimport { DEFAULT_HOOKS } from './constants.js';\nimport { DEBUG_BUILD } from './debug-build.js';\nimport { formatComponentName } from './vendor/components.js';\n\nconst VUE_OP = 'ui.vue';\n\n// Mappings from operation to corresponding lifecycle hook.\nconst HOOKS = {\n  activate: ['activated', 'deactivated'],\n  create: ['beforeCreate', 'created'],\n  // Vue 3\n  unmount: ['beforeUnmount', 'unmounted'],\n  // Vue 2\n  destroy: ['beforeDestroy', 'destroyed'],\n  mount: ['beforeMount', 'mounted'],\n  update: ['beforeUpdate', 'updated'],\n};\n\n/**\n * Grabs active transaction off scope.\n *\n * @deprecated You should not rely on the transaction, but just use `startSpan()` APIs instead.\n */\nfunction getActiveTransaction() {\n  // eslint-disable-next-line deprecation/deprecation\n  return getCurrentScope().getTransaction();\n}\n\n/** Finish top-level span and activity with a debounce configured using `timeout` option */\nfunction finishRootSpan(vm, timestamp, timeout) {\n  if (vm.$_sentryRootSpanTimer) {\n    clearTimeout(vm.$_sentryRootSpanTimer);\n  }\n\n  vm.$_sentryRootSpanTimer = setTimeout(() => {\n    if (vm.$root && vm.$root.$_sentryRootSpan) {\n      vm.$root.$_sentryRootSpan.end(timestamp);\n      vm.$root.$_sentryRootSpan = undefined;\n    }\n  }, timeout);\n}\n\nconst createTracingMixins = (options) => {\n  const hooks = (options.hooks || [])\n    .concat(DEFAULT_HOOKS)\n    // Removing potential duplicates\n    .filter((value, index, self) => self.indexOf(value) === index);\n\n  const mixins = {};\n\n  for (const operation of hooks) {\n    // Retrieve corresponding hooks from Vue lifecycle.\n    // eg. mount => ['beforeMount', 'mounted']\n    const internalHooks = HOOKS[operation];\n    if (!internalHooks) {\n      DEBUG_BUILD && logger.warn(`Unknown hook: ${operation}`);\n      continue;\n    }\n\n    for (const internalHook of internalHooks) {\n      mixins[internalHook] = function () {\n        const isRoot = this.$root === this;\n\n        if (isRoot) {\n          const activeSpan = getActiveSpan();\n          if (activeSpan) {\n            this.$_sentryRootSpan =\n              this.$_sentryRootSpan ||\n              startInactiveSpan({\n                name: 'Application Render',\n                op: `${VUE_OP}.render`,\n                origin: 'auto.ui.vue',\n              });\n          }\n        }\n\n        // Skip components that we don't want to track to minimize the noise and give a more granular control to the user\n        const name = formatComponentName(this, false);\n        const shouldTrack = Array.isArray(options.trackComponents)\n          ? options.trackComponents.indexOf(name) > -1\n          : options.trackComponents;\n\n        // We always want to track root component\n        if (!isRoot && !shouldTrack) {\n          return;\n        }\n\n        this.$_sentrySpans = this.$_sentrySpans || {};\n\n        // Start a new span if current hook is a 'before' hook.\n        // Otherwise, retrieve the current span and finish it.\n        if (internalHook == internalHooks[0]) {\n          const activeSpan = (this.$root && this.$root.$_sentryRootSpan) || getActiveSpan();\n          if (activeSpan) {\n            // Cancel old span for this hook operation in case it didn't get cleaned up. We're not actually sure if it\n            // will ever be the case that cleanup hooks re not called, but we had users report that spans didn't get\n            // finished so we finish the span before starting a new one, just to be sure.\n            const oldSpan = this.$_sentrySpans[operation];\n            if (oldSpan) {\n              oldSpan.end();\n            }\n\n            this.$_sentrySpans[operation] = startInactiveSpan({\n              name: `Vue <${name}>`,\n              op: `${VUE_OP}.${operation}`,\n              origin: 'auto.ui.vue',\n            });\n          }\n        } else {\n          // The span should already be added via the first handler call (in the 'before' hook)\n          const span = this.$_sentrySpans[operation];\n          // The before hook did not start the tracking span, so the span was not added.\n          // This is probably because it happened before there is an active transaction\n          if (!span) return;\n          span.end();\n\n          finishRootSpan(this, timestampInSeconds(), options.timeout);\n        }\n      };\n    }\n  }\n\n  return mixins;\n};\n\nexport { createTracingMixins, getActiveTransaction };\n//# sourceMappingURL=tracing.js.map\n","// Vendored from https://github.com/vuejs/vue/blob/612fb89547711cacb030a3893a0065b785802860/src/core/util/debug.js\n// with types only changes.\n\n// The MIT License (MIT)\n\n// Copyright (c) 2013-present, Yuxi (Evan) You\n\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nconst classifyRE = /(?:^|[-_])(\\w)/g;\nconst classify = (str) => str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '');\n\nconst ROOT_COMPONENT_NAME = '<Root>';\nconst ANONYMOUS_COMPONENT_NAME = '<Anonymous>';\n\nconst repeat = (str, n) => {\n  // string.repeat() is not supported by IE11, we fall back to just using the string in that case\n  // eslint-disable-next-line @sentry-internal/sdk/no-unsupported-es6-methods\n  return str.repeat ? str.repeat(n) : str;\n};\n\nconst formatComponentName = (vm, includeFile) => {\n  if (!vm) {\n    return ANONYMOUS_COMPONENT_NAME;\n  }\n\n  if (vm.$root === vm) {\n    return ROOT_COMPONENT_NAME;\n  }\n\n  // https://github.com/getsentry/sentry-javascript/issues/5204 $options can be undefined\n  if (!vm.$options) {\n    return ANONYMOUS_COMPONENT_NAME;\n  }\n\n  const options = vm.$options;\n\n  let name = options.name || options._componentTag;\n  const file = options.__file;\n  if (!name && file) {\n    const match = file.match(/([^/\\\\]+)\\.vue$/);\n    if (match) {\n      name = match[1];\n    }\n  }\n\n  return (\n    (name ? `<${classify(name)}>` : ANONYMOUS_COMPONENT_NAME) + (file && includeFile !== false ? ` at ${file}` : '')\n  );\n};\n\nconst generateComponentTrace = (vm) => {\n  if (vm && (vm._isVue || vm.__isVue) && vm.$parent) {\n    const tree = [];\n    let currentRecursiveSequence = 0;\n    while (vm) {\n      if (tree.length > 0) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        const last = tree[tree.length - 1] ;\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        if (last.constructor === vm.constructor) {\n          currentRecursiveSequence++;\n          vm = vm.$parent; // eslint-disable-line no-param-reassign\n          continue;\n        } else if (currentRecursiveSequence > 0) {\n          tree[tree.length - 1] = [last, currentRecursiveSequence];\n          currentRecursiveSequence = 0;\n        }\n      }\n      tree.push(vm);\n      vm = vm.$parent; // eslint-disable-line no-param-reassign\n    }\n\n    const formattedTree = tree\n      .map(\n        (vm, i) =>\n          `${\n            (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) +\n            (Array.isArray(vm)\n              ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`\n              : formatComponentName(vm))\n          }`,\n      )\n      .join('\\n');\n\n    return `\\n\\nfound in\\n\\n${formattedTree}`;\n  }\n\n  return `\\n\\n(found in ${formatComponentName(vm)})`;\n};\n\nexport { formatComponentName, generateComponentTrace };\n//# sourceMappingURL=components.js.map\n","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\nvar define = require('define-data-property');\nvar hasDescriptors = require('has-property-descriptors')();\nvar gOPD = require('gopd');\n\nvar $TypeError = require('es-errors/type');\nvar $floor = GetIntrinsic('%Math.floor%');\n\n/** @type {import('.')} */\nmodule.exports = function setFunctionLength(fn, length) {\n\tif (typeof fn !== 'function') {\n\t\tthrow new $TypeError('`fn` is not a function');\n\t}\n\tif (typeof length !== 'number' || length < 0 || length > 0xFFFFFFFF || $floor(length) !== length) {\n\t\tthrow new $TypeError('`length` must be a positive 32-bit integer');\n\t}\n\n\tvar loose = arguments.length > 2 && !!arguments[2];\n\n\tvar functionLengthIsConfigurable = true;\n\tvar functionLengthIsWritable = true;\n\tif ('length' in fn && gOPD) {\n\t\tvar desc = gOPD(fn, 'length');\n\t\tif (desc && !desc.configurable) {\n\t\t\tfunctionLengthIsConfigurable = false;\n\t\t}\n\t\tif (desc && !desc.writable) {\n\t\t\tfunctionLengthIsWritable = false;\n\t\t}\n\t}\n\n\tif (functionLengthIsConfigurable || functionLengthIsWritable || !loose) {\n\t\tif (hasDescriptors) {\n\t\t\tdefine(/** @type {Parameters<define>[0]} */ (fn), 'length', length, true, true);\n\t\t} else {\n\t\t\tdefine(/** @type {Parameters<define>[0]} */ (fn), 'length', length);\n\t\t}\n\t}\n\treturn fn;\n};\n","'use strict';\n\nfunction shallowEqualArrays(arrA, arrB) {\n  if (arrA === arrB) {\n    return true;\n  }\n\n  if (!arrA || !arrB) {\n    return false;\n  }\n\n  var len = arrA.length;\n\n  if (arrB.length !== len) {\n    return false;\n  }\n\n  for (var i = 0; i < len; i++) {\n    if (arrA[i] !== arrB[i]) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nmodule.exports = shallowEqualArrays;\n"],"names":["applyAggregateErrorsToEvent","exceptionFromErrorImplementation","parser","maxValueLimit","key","limit","event","hint","exception","values","originalException","Error","length","undefined","truncateAggregateExceptions","aggregateExceptionsFromError","error","prevExceptions","exceptionId","newExceptions","applyExceptionGroupFieldsForParentException","newException","newExceptionId","applyExceptionGroupFieldsForChildException","Array","isArray","errors","forEach","childError","i","mechanism","type","handled","is_exception_group","exception_id","source","parentId","parent_id","exceptions","maxValueLength","map","value","BAGGAGE_HEADER_NAME","SENTRY_BAGGAGE_KEY_PREFIX","SENTRY_BAGGAGE_KEY_PREFIX_REGEX","MAX_BAGGAGE_STRING_LENGTH","baggageHeaderToDynamicSamplingContext","baggageHeader","baggageObject","reduce","acc","curr","currBaggageObject","baggageHeaderToObject","Object","keys","dynamicSamplingContext","entries","match","nonPrefixedKey","slice","dynamicSamplingContextToSentryBaggageHeader","sentryPrefixedDSC","dscKey","dscValue","objectToBaggageHeader","split","baggageEntry","keyOrValue","decodeURIComponent","trim","object","objectKey","objectValue","currentIndex","encodeURIComponent","newBaggageHeader","warn","WINDOW","DEFAULT_MAX_STRING_LENGTH","htmlTreeAsString","elem","options","currentElem","MAX_TRAVERSE_HEIGHT","out","height","len","separator","sepLength","nextStr","keyAttrs","maxStringLength","_htmlElementAsString","push","parentNode","reverse","join","_oO","el","className","classes","attr","tagName","HTMLElement","dataset","toLowerCase","keyAttrPairs","filter","keyAttr","getAttribute","keyAttrPair","id","allowedAttrs","getLocationHref","document","location","href","oO","getDomElement","selector","querySelector","getComponentName","_nullishCoalesce","lhs","rhsFn","_optionalChain","ops","lastAccessLHS","op","fn","args","call","createClientReportEnvelope","discarded_events","dsn","timestamp","clientReportItem","DEBUG_BUILD","__SENTRY_DEBUG__","DSN_REGEX","isValidProtocol","protocol","dsnToString","withPassword","host","path","pass","port","projectId","publicKey","dsnFromString","str","exec","console","lastPath","pop","projectMatch","dsnFromComponents","components","validateDsn","requiredComponents","hasMissingRequiredComponent","find","component","isNaN","parseInt","makeDsn","from","isBrowserBundle","__SENTRY_BROWSER_BUNDLE__","getSDKSource","createEnvelope","headers","items","addItemToEnvelope","envelope","newItem","forEachEnvelopeItem","callback","envelopeItems","envelopeItem","envelopeItemType","result","envelopeContainsItemType","types","_","includes","encodeUTF8","input","textEncoder","utf8","TextEncoder","encode","serializeEnvelope","envHeaders","parts","JSON","stringify","append","next","item","itemHeaders","payload","Uint8Array","stringifiedPayload","e","concatBuffers","buffers","totalLength","buf","merged","offset","buffer","set","parseEnvelope","env","textDecoder","readBinary","bin","subarray","readJson","indexOf","parse","decode","envelopeHeader","itemHeader","binaryLength","createAttachmentEnvelopeItem","attachment","data","filename","content_type","contentType","attachment_type","attachmentType","ITEM_TYPE_TO_DATA_CATEGORY_MAP","session","sessions","transaction","client_report","user_report","profile","replay_event","replay_recording","check_in","feedback","span","statsd","envelopeItemTypeToDataCategory","getSdkMetadataForEnvelopeHeader","metadataOrEvent","sdk","name","version","createEventEnvelopeHeaders","sdkInfo","tunnel","sdkProcessingMetadata","event_id","sent_at","Date","toISOString","trace","SentryError","constructor","message","logLevel","super","this","prototype","setPrototypeOf","parseStackFrames","stackParser","stack","exceptionFromError","frames","stacktrace","handlers","instrumented","addHandler","handler","maybeInstrument","instrumentFn","triggerHandlers","typeHandlers","addConsoleInstrumentationHandler","instrumentConsole","level","originalConsoleMethod","handlerData","log","apply","DEBOUNCE_DURATION","debounceTimerID","lastCapturedEventType","lastCapturedEventTargetId","addClickKeypressInstrumentationHandler","instrumentDOM","triggerDOMHandler","bind","globalDOMEventHandler","makeDOMEventHandler","addEventListener","target","proto","hasOwnProperty","originalAddEventListener","listener","__sentry_instrumentation_handlers__","handlerForType","refCount","originalRemoveEventListener","isSimilarToLastCapturedEvent","_sentryId","shouldSkipDOMEvent","eventType","isContentEditable","globalListener","getEventTarget","global","clearTimeout","setTimeout","addFetchInstrumentationHandler","instrumentFetch","originalFetch","method","url","parseFetchArgs","fetchData","startTimestamp","now","then","response","finishedHandlerData","endTimestamp","erroredHandlerData","hasProp","obj","prop","getUrlFromResource","resource","toString","fetchArgs","String","toUpperCase","arg","_oldOnErrorHandler","addGlobalErrorInstrumentationHandler","instrumentError","onerror","msg","line","column","__SENTRY_LOADER__","arguments","__SENTRY_INSTRUMENTED__","_oldOnUnhandledRejectionHandler","addGlobalUnhandledRejectionInstrumentationHandler","instrumentUnhandledRejection","onunhandledrejection","supportsHistory","chromeVar","chrome","isChromePackagedApp","app","runtime","hasHistoryApi","history","pushState","replaceState","lastHref","addHistoryInstrumentationHandler","instrumentHistory","oldOnPopState","onpopstate","historyReplacementFunction","originalHistoryFunction","to","SENTRY_XHR_DATA_KEY","addXhrInstrumentationHandler","instrumentXHR","XMLHttpRequest","xhrproto","originalOpen","parseUrl","request_headers","__sentry_own_request__","onreadystatechangeHandler","xhrInfo","readyState","status_code","status","xhr","onreadystatechange","original","readyStateArgs","setRequestHeaderArgs","header","originalSend","sentryXhrData","body","e2","objectToString","isError","wat","isInstanceOf","isBuiltin","isErrorEvent","isDOMError","isDOMException","isString","isParameterizedString","isPrimitive","isPlainObject","isEvent","Event","isElement","Element","isRegExp","isThenable","Boolean","isSyntheticEvent","base","_e","isVueViewModel","__isVue","_isVue","isBrowser","window","isElectronNodeRenderer","process","PREFIX","CONSOLE_LEVELS","originalConsoleMethods","consoleSandbox","wrappedFuncs","wrappedLevels","makeLogger","enabled","logger","enable","disable","isEnabled","uuid4","gbl","crypto","msCrypto","getRandomByte","Math","random","randomUUID","replace","getRandomValues","typedArray","c","getFirstException","getEventDescription","eventId","firstException","addExceptionTypeValue","addExceptionMechanism","newMechanism","defaultMechanism","currentMechanism","mergedData","addContextToFrame","lines","frame","linesOfContext","lineno","maxLines","sourceLine","max","min","pre_context","context_line","colno","post_context","checkOrSetAlreadyCaught","__sentry_captured__","err","arrayify","maybeArray","isNodeEnv","memoBuilder","hasWeakSet","WeakSet","inner","memoize","has","add","unmemoize","delete","splice","normalize","depth","maxProperties","Infinity","visit","ERROR","normalizeToSize","maxSize","normalized","jsonSize","memo","is","stringified","stringifyValue","startsWith","remainingDepth","valueWithToJSON","toJSON","jsonValue","numAdded","visitable","visitKey","visitValue","_events","g","objName","getConstructorName","test","getPrototypeOf","utf8Length","encodeURI","fill","replacementFactory","wrapped","markFunctionWrapped","addNonEnumerableProperty","defineProperty","writable","configurable","o_O","getOriginalFunction","func","__sentry_original__","urlEncode","convertToPlainObject","getOwnProperties","newObj","serializeEventTarget","currentTarget","CustomEvent","detail","extractedProps","property","extractExceptionKeysForMessage","maxLength","sort","includedKeys","serialized","dropUndefinedKeys","inputValue","memoizationMap","Map","_dropUndefinedKeys","isPojo","memoVal","get","returnValue","normalizeArray","allowAboveRoot","up","last","unshift","splitPathRe","splitPath","truncated","resolve","resolvedPath","resolvedAbsolute","charAt","p","arr","start","end","relative","fromParts","toParts","samePartsLength","outputParts","concat","basename","ext","f","makePromiseBuffer","isReady","remove","task","taskProducer","drain","timeout","reject","counter","capturedSetTimeout","$","DEFAULT_RETRY_AFTER","parseRetryAfterHeader","headerDelay","headerDate","disabledUntil","limits","dataCategory","all","isRateLimited","updateRateLimits","statusCode","updatedRateLimits","rateLimitHeader","retryAfterHeader","retryAfter","categories","namespaces","delay","category","validSeverityLevels","severityLevelFromString","STACKTRACE_FRAME_LIMIT","WEBPACK_ERROR_REGEXP","STRIP_FRAME_REGEXP","createStackParser","parsers","sortedParsers","a","b","skipFirst","cleanedLine","stripSentryFramesAndReverse","stackParserFromStackParserOptions","localStack","function","defaultFunctionName","getFunctionName","truncate","snipLine","newLine","lineLength","safeJoin","delimiter","output","isMatchingPattern","pattern","requireExactStringMatch","stringMatchesSomePattern","testString","patterns","some","supportsFetch","Headers","Request","Response","isNativeFetch","supportsNativeFetch","EdgeRuntime","fetch","doc","sandbox","createElement","hidden","head","appendChild","contentWindow","removeChild","supportsReportingObserver","States","resolvedSyncPromise","SyncPromise","rejectedSyncPromise","reason","PENDING","RESOLVED","REJECTED","executor","__init","__init2","__init3","__init4","_state","_handlers","_resolve","_reject","onfulfilled","onrejected","_executeHandlers","val","onfinally","isRejected","_setResult","state","_value","cachedHandlers","ONE_SECOND_IN_MS","dateTimestampInSeconds","createUnixTimestampInSecondsFunc","performance","approxStartingTimeOrigin","timeOrigin","timestampInSeconds","_browserPerformanceTimeOriginMode","browserPerformanceTimeOrigin","threshold","performanceNow","dateNow","timeOriginDelta","abs","timeOriginIsReliable","navigationStart","timing","hasNavigationStart","navigationStartDelta","navigationStartIsReliable","TRACEPARENT_REGEXP","RegExp","extractTraceparentData","traceparent","matches","parentSampled","traceId","parentSpanId","tracingContextFromHeaders","sentryTrace","baggage","traceparentData","propagationContext","substring","spanId","sampled","dsc","propagationContextFromHeaders","generateSentryTraceHeader","sampledString","query","fragment","search","hash","stripUrlQueryAndFragment","urlPath","isGlobalObj","GLOBAL_OBJ","globalThis","self","getGlobalObject","getGlobalSingleton","creator","__SENTRY__","singleton","DEFAULT_HOOKS","attachErrorHandler","errorHandler","warnHandler","silent","config","vm","lifecycleHook","componentName","metadata","attachProps","$options","propsData","$props","captureContext","contexts","vue","logErrors","hasConsole","vueRouterInstrumentation","router","startTransaction","startTransactionOnPageLoad","startTransactionOnLocationChange","pathname","attributes","instrumentVueRouter","routeLabel","instrumentNavigation","instrumentPageLoad","startNavigationSpanFn","onError","beforeEach","isPageLoadNavigation","matched","params","transactionName","transactionSource","pageloadTransaction","existingAttributes","updateName","setAttribute","setAttributes","browserTracingIntegration","integration","afterAllSetup","client","startNavigationSpan","globalWithVue","DEFAULT_CONFIG","Vue","hooks","trackComponents","INTEGRATION_NAME","_vueIntegration","integrationOptions","setupOnce","setup","_setupIntegration","vueIntegration","VueIntegration","getOptions","apps","vueInit","appWithInstance","isMounted","_instance","mixin","tracingOptions","init","_metadata","packages","defaultIntegrations","v","VUE_OP","HOOKS","activate","create","unmount","destroy","mount","update","getActiveTransaction","getTransaction","finishRootSpan","$_sentryRootSpanTimer","$root","$_sentryRootSpan","createTracingMixins","index","mixins","operation","internalHooks","internalHook","isRoot","activeSpan","origin","shouldTrack","$_sentrySpans","oldSpan","time","classifyRE","classify","ROOT_COMPONENT_NAME","ANONYMOUS_COMPONENT_NAME","repeat","n","formatComponentName","includeFile","_componentTag","file","__file","generateComponentTrace","$parent","tree","currentRecursiveSequence","formattedTree","GetIntrinsic","define","hasDescriptors","gOPD","$TypeError","$floor","module","exports","loose","functionLengthIsConfigurable","functionLengthIsWritable","desc","shallowEqualArrays","arrA","arrB"],"sourceRoot":""}