{"version":3,"file":"vendors-fd03fc49.xxxxxxxx.bundle.js","mappings":"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","sources":["webpack://iadviser/./node_modules/@sentry/utils/esm/aggregate-errors.js","webpack://iadviser/./node_modules/@sentry/utils/esm/browser.js","webpack://iadviser/./node_modules/@sentry/utils/esm/buildPolyfills/_nullishCoalesce.js","webpack://iadviser/./node_modules/@sentry/utils/esm/buildPolyfills/_optionalChain.js","webpack://iadviser/./node_modules/@sentry/utils/esm/clientreport.js","webpack://iadviser/./node_modules/@sentry/utils/esm/debug-build.js","webpack://iadviser/./node_modules/@sentry/utils/esm/dsn.js","webpack://iadviser/./node_modules/@sentry/utils/esm/env.js","webpack://iadviser/./node_modules/@sentry/utils/esm/envelope.js","webpack://iadviser/./node_modules/@sentry/utils/esm/error.js","webpack://iadviser/./node_modules/@sentry/utils/esm/instrument/_handlers.js","webpack://iadviser/./node_modules/@sentry/utils/esm/instrument/console.js","webpack://iadviser/./node_modules/@sentry/utils/esm/instrument/dom.js","webpack://iadviser/./node_modules/@sentry/utils/esm/instrument/fetch.js","webpack://iadviser/./node_modules/@sentry/utils/esm/instrument/globalError.js","webpack://iadviser/./node_modules/@sentry/utils/esm/instrument/globalUnhandledRejection.js","webpack://iadviser/./node_modules/@sentry/utils/esm/vendor/supportsHistory.js","webpack://iadviser/./node_modules/@sentry/utils/esm/instrument/history.js","webpack://iadviser/./node_modules/@sentry/utils/esm/instrument/xhr.js","webpack://iadviser/./node_modules/@sentry/utils/esm/is.js","webpack://iadviser/./node_modules/@sentry/utils/esm/isBrowser.js","webpack://iadviser/./node_modules/@sentry/utils/esm/logger.js","webpack://iadviser/./node_modules/@sentry/utils/esm/misc.js","webpack://iadviser/./node_modules/@sentry/utils/esm/node.js","webpack://iadviser/./node_modules/@sentry/utils/esm/normalize.js","webpack://iadviser/./node_modules/@sentry/utils/esm/memo.js","webpack://iadviser/./node_modules/@sentry/utils/esm/object.js","webpack://iadviser/./node_modules/@sentry/utils/esm/promisebuffer.js","webpack://iadviser/./node_modules/@sentry/utils/esm/ratelimit.js","webpack://iadviser/./node_modules/@sentry/utils/esm/severity.js","webpack://iadviser/./node_modules/@sentry/utils/esm/stacktrace.js","webpack://iadviser/./node_modules/@sentry/utils/esm/string.js","webpack://iadviser/./node_modules/@sentry/utils/esm/supports.js","webpack://iadviser/./node_modules/@sentry/utils/esm/syncpromise.js","webpack://iadviser/./node_modules/@sentry/utils/esm/time.js","webpack://iadviser/./node_modules/@sentry/utils/esm/url.js","webpack://iadviser/./node_modules/@sentry/utils/esm/worldwide.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 { 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 { 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","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","/* 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 { 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","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","/**\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"],"names":["applyAggregateErrorsToEvent","exceptionFromErrorImplementation","parser","maxValueLimit","key","limit","event","hint","exception","values","_is_js__WEBPACK_IMPORTED_MODULE_0__","tH","originalException","Error","length","undefined","exceptions","maxValueLength","aggregateExceptionsFromError","map","value","_string_js__WEBPACK_IMPORTED_MODULE_1__","xv","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","WINDOW","VZ","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","Kg","split","allowedAttrs","getLocationHref","document","location","href","oO","getComponentName","_nullishCoalesce","lhs","rhsFn","_optionalChain","ops","lastAccessLHS","op","fn","args","call","createClientReportEnvelope","discarded_events","dsn","timestamp","clientReportItem","_time_js__WEBPACK_IMPORTED_MODULE_1__","lu","_envelope_js__WEBPACK_IMPORTED_MODULE_0__","h4","DEBUG_BUILD","__SENTRY_DEBUG__","DSN_REGEX","dsnToString","withPassword","host","path","pass","port","projectId","protocol","publicKey","dsnFromComponents","components","makeDsn","from","str","match","exec","_logger_js__WEBPACK_IMPORTED_MODULE_1__","pq","console","lastPath","slice","pop","projectMatch","dsnFromString","_debug_build_js__WEBPACK_IMPORTED_MODULE_0__","T","find","component","vF","isValidProtocol","isNaN","parseInt","validateDsn","isBrowserBundle","__SENTRY_BROWSER_BUNDLE__","getSDKSource","createEnvelope","headers","items","addItemToEnvelope","envelope","newItem","forEachEnvelopeItem","callback","envelopeItems","envelopeItem","encodeUTF8","input","textEncoder","TextEncoder","encode","serializeEnvelope","envHeaders","parts","JSON","stringify","append","next","item","itemHeaders","payload","Uint8Array","stringifiedPayload","e","_normalize_js__WEBPACK_IMPORTED_MODULE_1__","S8","buffers","totalLength","reduce","acc","buf","merged","offset","buffer","set","concatBuffers","createAttachmentEnvelopeItem","attachment","data","_object_js__WEBPACK_IMPORTED_MODULE_2__","Ce","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","dynamicSamplingContext","sdkProcessingMetadata","event_id","sent_at","Date","toISOString","_dsn_js__WEBPACK_IMPORTED_MODULE_0__","SB","trace","SentryError","constructor","message","logLevel","super","this","prototype","Object","setPrototypeOf","handlers","instrumented","addHandler","handler","maybeInstrument","instrumentFn","triggerHandlers","typeHandlers","_stacktrace_js__WEBPACK_IMPORTED_MODULE_2__","qQ","addConsoleInstrumentationHandler","_handlers_js__WEBPACK_IMPORTED_MODULE_3__","s5","AS","instrumentConsole","_worldwide_js__WEBPACK_IMPORTED_MODULE_2__","OW","_logger_js__WEBPACK_IMPORTED_MODULE_0__","Ow","level","_object_js__WEBPACK_IMPORTED_MODULE_1__","GS","originalConsoleMethod","Z9","handlerData","aj","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","keys","globalListener","getEventTarget","eventType","isContentEditable","shouldSkipDOMEvent","my","_sentryId","_misc_js__WEBPACK_IMPORTED_MODULE_0__","eJ","isSimilarToLastCapturedEvent","global","clearTimeout","setTimeout","addFetchInstrumentationHandler","instrumentFetch","_supports_js__WEBPACK_IMPORTED_MODULE_1__","m7","_object_js__WEBPACK_IMPORTED_MODULE_0__","originalFetch","method","url","fetchArgs","getUrlFromResource","hasProp","String","toUpperCase","arg","parseFetchArgs","fetchData","startTimestamp","now","then","response","finishedHandlerData","endTimestamp","erroredHandlerData","obj","prop","resource","toString","_oldOnErrorHandler","addGlobalErrorInstrumentationHandler","_handlers_js__WEBPACK_IMPORTED_MODULE_1__","instrumentError","_worldwide_js__WEBPACK_IMPORTED_MODULE_0__","onerror","msg","line","column","__SENTRY_LOADER__","arguments","__SENTRY_INSTRUMENTED__","_oldOnUnhandledRejectionHandler","addGlobalUnhandledRejectionInstrumentationHandler","instrumentUnhandledRejection","onunhandledrejection","worldwide","history_WINDOW","lastHref","addHistoryInstrumentationHandler","_handlers","instrumentHistory","chromeVar","chrome","isChromePackagedApp","app","runtime","hasHistoryApi","history","pushState","replaceState","supportsHistory","oldOnPopState","onpopstate","historyReplacementFunction","originalHistoryFunction","to","object","SENTRY_XHR_DATA_KEY","addXhrInstrumentationHandler","instrumentXHR","XMLHttpRequest","xhrproto","originalOpen","e2","parseUrl","request_headers","__sentry_own_request__","onreadystatechangeHandler","xhrInfo","readyState","status_code","status","xhr","onreadystatechange","original","readyStateArgs","setRequestHeaderArgs","header","originalSend","sentryXhrData","body","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","_node_js__WEBPACK_IMPORTED_MODULE_0__","wD","_worldwide_js__WEBPACK_IMPORTED_MODULE_1__","process","CONSOLE_LEVELS","originalConsoleMethods","consoleSandbox","wrappedFuncs","wrappedLevels","logger","enabled","enable","disable","isEnabled","makeLogger","uuid4","gbl","crypto","msCrypto","getRandomByte","Math","random","randomUUID","replace","getRandomValues","typedArray","_","c","getFirstException","getEventDescription","eventId","firstException","addExceptionTypeValue","addExceptionMechanism","newMechanism","currentMechanism","mergedData","checkOrSetAlreadyCaught","__sentry_captured__","err","arrayify","maybeArray","isNodeEnv","_env_js__WEBPACK_IMPORTED_MODULE_0__","Z","normalize","depth","maxProperties","visit","ERROR","normalizeToSize","maxSize","normalized","encodeURI","utf8Length","memo","hasWeakSet","WeakSet","inner","has","add","delete","splice","memoBuilder","memoize","unmemoize","includes","is","yr","stringified","_events","__webpack_require__","g","L2","mE","stacktrace","objName","getPrototypeOf","getConstructorName","test","stringifyValue","startsWith","remainingDepth","valueWithToJSON","toJSON","numAdded","visitable","W4","visitKey","visitValue","fill","replacementFactory","wrapped","markFunctionWrapped","addNonEnumerableProperty","defineProperty","writable","configurable","o_O","_debug_build_js__WEBPACK_IMPORTED_MODULE_1__","_logger_js__WEBPACK_IMPORTED_MODULE_3__","getOriginalFunction","func","__sentry_original__","urlEncode","encodeURIComponent","convertToPlainObject","_is_js__WEBPACK_IMPORTED_MODULE_2__","bJ","stack","getOwnProperties","xH","newObj","serializeEventTarget","currentTarget","CustomEvent","detail","vq","_browser_js__WEBPACK_IMPORTED_MODULE_0__","Hd","extractedProps","property","extractExceptionKeysForMessage","maxLength","sort","_string_js__WEBPACK_IMPORTED_MODULE_4__","includedKeys","serialized","dropUndefinedKeys","inputValue","_dropUndefinedKeys","Map","memoizationMap","Qd","isPojo","memoVal","get","returnValue","makePromiseBuffer","remove","task","indexOf","$","taskProducer","_syncpromise_js__WEBPACK_IMPORTED_MODULE_1__","xg","_error_js__WEBPACK_IMPORTED_MODULE_0__","U","drain","timeout","T2","resolve","reject","counter","capturedSetTimeout","XW","DEFAULT_RETRY_AFTER","isRateLimited","limits","dataCategory","all","disabledUntil","updateRateLimits","statusCode","updatedRateLimits","rateLimitHeader","retryAfterHeader","trim","retryAfter","categories","namespaces","headerDelay","delay","category","headerDate","parse","parseRetryAfterHeader","validSeverityLevels","severityLevelFromString","STACKTRACE_FRAME_LIMIT","WEBPACK_ERROR_REGEXP","STRIP_FRAME_REGEXP","createStackParser","parsers","sortedParsers","a","b","p","skipFirst","frames","lines","cleanedLine","frame","localStack","function","stripSentryFramesAndReverse","stackParserFromStackParserOptions","stackParser","defaultFunctionName","getFunctionName","truncate","max","safeJoin","delimiter","output","stringMatchesSomePattern","testString","patterns","requireExactStringMatch","some","pattern","gd","isMatchingPattern","supportsFetch","Headers","Request","Response","isNativeFetch","supportsNativeFetch","EdgeRuntime","fetch","result","doc","sandbox","createElement","hidden","head","appendChild","contentWindow","removeChild","warn","States","resolvedSyncPromise","SyncPromise","rejectedSyncPromise","reason","executor","__init","__init2","__init3","__init4","_state","PENDING","_resolve","_reject","onfulfilled","onrejected","_executeHandlers","val","onfinally","isRejected","_setResult","RESOLVED","REJECTED","state","Qg","_value","cachedHandlers","ONE_SECOND_IN_MS","dateTimestampInSeconds","timestampInSeconds","performance","approxStartingTimeOrigin","timeOrigin","createUnixTimestampInSecondsFunc","_browserPerformanceTimeOriginMode","browserPerformanceTimeOrigin","threshold","performanceNow","dateNow","timeOriginDelta","abs","timeOriginIsReliable","navigationStart","timing","navigationStartDelta","query","fragment","search","hash","relative","isGlobalObj","GLOBAL_OBJ","globalThis","self","getGlobalObject","getGlobalSingleton","creator","__SENTRY__"],"sourceRoot":""}