{"version":3,"file":"js/chunk-vendors-5d9221fc-legacy.60d10f55.js","mappings":"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","sources":["webpack://upmed-agendamento/./node_modules/@sentry/utils/esm/browser.js","webpack://upmed-agendamento/./node_modules/@sentry/utils/esm/clientreport.js","webpack://upmed-agendamento/./node_modules/@sentry/utils/esm/dsn.js","webpack://upmed-agendamento/./node_modules/@sentry/utils/esm/env.js","webpack://upmed-agendamento/./node_modules/@sentry/utils/esm/envelope.js","webpack://upmed-agendamento/./node_modules/@sentry/utils/esm/error.js","webpack://upmed-agendamento/./node_modules/@sentry/utils/esm/instrument.js","webpack://upmed-agendamento/./node_modules/@sentry/utils/esm/is.js","webpack://upmed-agendamento/./node_modules/@sentry/utils/esm/logger.js","webpack://upmed-agendamento/./node_modules/@sentry/utils/esm/misc.js","webpack://upmed-agendamento/./node_modules/@sentry/utils/esm/node.js","webpack://upmed-agendamento/./node_modules/@sentry/utils/esm/memo.js","webpack://upmed-agendamento/./node_modules/@sentry/utils/esm/normalize.js","webpack://upmed-agendamento/./node_modules/@sentry/utils/esm/object.js","webpack://upmed-agendamento/./node_modules/@sentry/utils/esm/promisebuffer.js","webpack://upmed-agendamento/./node_modules/@sentry/utils/esm/ratelimit.js","webpack://upmed-agendamento/./node_modules/@sentry/utils/esm/severity.js","webpack://upmed-agendamento/./node_modules/@sentry/utils/esm/stacktrace.js","webpack://upmed-agendamento/./node_modules/@sentry/utils/esm/string.js","webpack://upmed-agendamento/./node_modules/@sentry/utils/esm/supports.js","webpack://upmed-agendamento/./node_modules/@sentry/utils/esm/syncpromise.js","webpack://upmed-agendamento/./node_modules/@sentry/utils/esm/time.js","webpack://upmed-agendamento/./node_modules/@sentry/utils/esm/url.js","webpack://upmed-agendamento/./node_modules/@sentry/utils/esm/worldwide.js","webpack://upmed-agendamento/./node_modules/@sentry/vue/esm/constants.js","webpack://upmed-agendamento/./node_modules/@sentry/vue/esm/components.js","webpack://upmed-agendamento/./node_modules/@sentry/vue/esm/errorhandler.js","webpack://upmed-agendamento/./node_modules/@sentry/vue/esm/tracing.js","webpack://upmed-agendamento/./node_modules/@sentry/vue/esm/sdk.js"],"sourcesContent":["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\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  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\nexport { getDomElement, getLocationHref, htmlTreeAsString };\n//# sourceMappingURL=browser.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","import { SentryError } from './error.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\n */\nfunction dsnFromString(str) {\n  const match = DSN_REGEX.exec(str);\n\n  if (!match) {\n    throw new SentryError(`Invalid Sentry Dsn: ${str}`);\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 (!(typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {\n    return;\n  }\n\n  const { port, projectId, protocol } = dsn;\n\n  const requiredComponents = ['protocol', 'publicKey', 'host', 'projectId'];\n  requiredComponents.forEach(component => {\n    if (!dsn[component]) {\n      throw new SentryError(`Invalid Sentry Dsn: ${component} missing`);\n    }\n  });\n\n  if (!projectId.match(/^\\d+$/)) {\n    throw new SentryError(`Invalid Sentry Dsn: Invalid projectId ${projectId}`);\n  }\n\n  if (!isValidProtocol(protocol)) {\n    throw new SentryError(`Invalid Sentry Dsn: Invalid protocol ${protocol}`);\n  }\n\n  if (port && isNaN(parseInt(port, 10))) {\n    throw new SentryError(`Invalid Sentry Dsn: Invalid port ${port}`);\n  }\n\n  return true;\n}\n\n/** The Sentry Dsn, identifying a Sentry instance and project. */\nfunction makeDsn(from) {\n  const components = typeof from === 'string' ? dsnFromString(from) : dsnFromComponents(from);\n  validateDsn(components);\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-ignore \"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};\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 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\n  return {\n    event_id: event.event_id ,\n    sent_at: new Date().toISOString(),\n    ...(sdkInfo && { sdk: sdkInfo }),\n    ...(!!tunnel && { dsn: dsnToString(dsn) }),\n    ...(event.type === 'transaction' &&\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 { isInstanceOf, isString } from './is.js';\nimport { logger, CONSOLE_LEVELS } from './logger.js';\nimport { fill } from './object.js';\nimport { getFunctionName } from './stacktrace.js';\nimport { supportsNativeFetch, supportsHistory } from './supports.js';\nimport { getGlobalObject } from './worldwide.js';\n\n// eslint-disable-next-line deprecation/deprecation\nconst WINDOW = getGlobalObject();\n\n/**\n * Instrument native APIs to call handlers that can be used to create breadcrumbs, APM spans etc.\n *  - Console API\n *  - Fetch API\n *  - XHR API\n *  - History API\n *  - DOM API (click/typing)\n *  - Error API\n *  - UnhandledRejection API\n */\n\nconst handlers = {};\nconst instrumented = {};\n\n/** Instruments given API */\nfunction instrument(type) {\n  if (instrumented[type]) {\n    return;\n  }\n\n  instrumented[type] = true;\n\n  switch (type) {\n    case 'console':\n      instrumentConsole();\n      break;\n    case 'dom':\n      instrumentDOM();\n      break;\n    case 'xhr':\n      instrumentXHR();\n      break;\n    case 'fetch':\n      instrumentFetch();\n      break;\n    case 'history':\n      instrumentHistory();\n      break;\n    case 'error':\n      instrumentError();\n      break;\n    case 'unhandledrejection':\n      instrumentUnhandledRejection();\n      break;\n    default:\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('unknown instrumentation type:', type);\n      return;\n  }\n}\n\n/**\n * Add handler that will be called when given type of instrumentation triggers.\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addInstrumentationHandler(type, callback) {\n  handlers[type] = handlers[type] || [];\n  (handlers[type] ).push(callback);\n  instrument(type);\n}\n\n/** JSDoc */\nfunction triggerHandlers(type, data) {\n  if (!type || !handlers[type]) {\n    return;\n  }\n\n  for (const handler of handlers[type] || []) {\n    try {\n      handler(data);\n    } catch (e) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.error(\n          `Error while triggering instrumentation handler.\\nType: ${type}\\nName: ${getFunctionName(handler)}\\nError:`,\n          e,\n        );\n    }\n  }\n}\n\n/** JSDoc */\nfunction instrumentConsole() {\n  if (!('console' in WINDOW)) {\n    return;\n  }\n\n  CONSOLE_LEVELS.forEach(function (level) {\n    if (!(level in WINDOW.console)) {\n      return;\n    }\n\n    fill(WINDOW.console, level, function (originalConsoleMethod) {\n      return function (...args) {\n        triggerHandlers('console', { args, level });\n\n        // this fails for some browsers. :(\n        if (originalConsoleMethod) {\n          originalConsoleMethod.apply(WINDOW.console, args);\n        }\n      };\n    });\n  });\n}\n\n/** JSDoc */\nfunction instrumentFetch() {\n  if (!supportsNativeFetch()) {\n    return;\n  }\n\n  fill(WINDOW, 'fetch', function (originalFetch) {\n    return function (...args) {\n      const handlerData = {\n        args,\n        fetchData: {\n          method: getFetchMethod(args),\n          url: getFetchUrl(args),\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(WINDOW, args).then(\n        (response) => {\n          triggerHandlers('fetch', {\n            ...handlerData,\n            endTimestamp: Date.now(),\n            response,\n          });\n          return response;\n        },\n        (error) => {\n          triggerHandlers('fetch', {\n            ...handlerData,\n            endTimestamp: Date.now(),\n            error,\n          });\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\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/** Extract `method` from fetch call arguments */\nfunction getFetchMethod(fetchArgs = []) {\n  if ('Request' in WINDOW && isInstanceOf(fetchArgs[0], Request) && fetchArgs[0].method) {\n    return String(fetchArgs[0].method).toUpperCase();\n  }\n  if (fetchArgs[1] && fetchArgs[1].method) {\n    return String(fetchArgs[1].method).toUpperCase();\n  }\n  return 'GET';\n}\n\n/** Extract `url` from fetch call arguments */\nfunction getFetchUrl(fetchArgs = []) {\n  if (typeof fetchArgs[0] === 'string') {\n    return fetchArgs[0];\n  }\n  if ('Request' in WINDOW && isInstanceOf(fetchArgs[0], Request)) {\n    return fetchArgs[0].url;\n  }\n  return String(fetchArgs[0]);\n}\n/* eslint-enable @typescript-eslint/no-unsafe-member-access */\n\n/** JSDoc */\nfunction instrumentXHR() {\n  if (!('XMLHttpRequest' in WINDOW)) {\n    return;\n  }\n\n  const xhrproto = XMLHttpRequest.prototype;\n\n  fill(xhrproto, 'open', function (originalOpen) {\n    return function ( ...args) {\n      // eslint-disable-next-line @typescript-eslint/no-this-alias\n      const xhr = this;\n      const url = args[1];\n      const xhrInfo = (xhr.__sentry_xhr__ = {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        method: isString(args[0]) ? args[0].toUpperCase() : args[0],\n        url: args[1],\n      });\n\n      // if Sentry key appears in URL, don't capture it as a request\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n      if (isString(url) && xhrInfo.method === 'POST' && url.match(/sentry_key/)) {\n        xhr.__sentry_own_request__ = true;\n      }\n\n      const onreadystatechangeHandler = function () {\n        if (xhr.readyState === 4) {\n          try {\n            // touching statusCode in some platforms throws\n            // an exception\n            xhrInfo.status_code = xhr.status;\n          } catch (e) {\n            /* do nothing */\n          }\n\n          triggerHandlers('xhr', {\n            args,\n            endTimestamp: Date.now(),\n            startTimestamp: Date.now(),\n            xhr,\n          });\n        }\n      };\n\n      if ('onreadystatechange' in xhr && typeof xhr.onreadystatechange === 'function') {\n        fill(xhr, 'onreadystatechange', function (original) {\n          return function (...readyStateArgs) {\n            onreadystatechangeHandler();\n            return original.apply(xhr, readyStateArgs);\n          };\n        });\n      } else {\n        xhr.addEventListener('readystatechange', onreadystatechangeHandler);\n      }\n\n      return originalOpen.apply(xhr, args);\n    };\n  });\n\n  fill(xhrproto, 'send', function (originalSend) {\n    return function ( ...args) {\n      if (this.__sentry_xhr__ && args[0] !== undefined) {\n        this.__sentry_xhr__.body = args[0];\n      }\n\n      triggerHandlers('xhr', {\n        args,\n        startTimestamp: Date.now(),\n        xhr: this,\n      });\n\n      return originalSend.apply(this, args);\n    };\n  });\n}\n\nlet lastHref;\n\n/** JSDoc */\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    triggerHandlers('history', {\n      from,\n      to,\n    });\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  /** @hidden */\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        triggerHandlers('history', {\n          from,\n          to,\n        });\n      }\n      return originalHistoryFunction.apply(this, args);\n    };\n  }\n\n  fill(WINDOW.history, 'pushState', historyReplacementFunction);\n  fill(WINDOW.history, 'replaceState', historyReplacementFunction);\n}\n\nconst debounceDuration = 1000;\nlet debounceTimerID;\nlet lastCapturedEvent;\n\n/**\n * Decide whether the current event should finish the debounce of previously captured one.\n * @param previous previously captured event\n * @param current event to be captured\n */\nfunction shouldShortcircuitPreviousDebounce(previous, current) {\n  // If there was no previous event, it should always be swapped for the new one.\n  if (!previous) {\n    return true;\n  }\n\n  // If both events have different type, then user definitely performed two separate actions. e.g. click + keypress.\n  if (previous.type !== current.type) {\n    return true;\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 (previous.target !== current.target) {\n      return true;\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 false;\n}\n\n/**\n * Decide whether an event should be captured.\n * @param event event to be captured\n */\nfunction shouldSkipDOMEvent(event) {\n  // We are only interested in filtering `keypress` events for now.\n  if (event.type !== 'keypress') {\n    return false;\n  }\n\n  try {\n    const target = event.target ;\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  } 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  return true;\n}\n\n/**\n * Wraps addEventListener to capture UI breadcrumbs\n * @param handler function that will be triggered\n * @param globalListener indicates whether event was captured by the global event listener\n * @returns wrapped breadcrumb events handler\n * @hidden\n */\nfunction makeDOMEventHandler(handler, globalListener = false) {\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 || lastCapturedEvent === event) {\n      return;\n    }\n\n    // We always want to skip _some_ events.\n    if (shouldSkipDOMEvent(event)) {\n      return;\n    }\n\n    const name = event.type === 'keypress' ? 'input' : event.type;\n\n    // If there is no debounce timer, it means that we can safely capture the new event and store it for future comparisons.\n    if (debounceTimerID === undefined) {\n      handler({\n        event: event,\n        name,\n        global: globalListener,\n      });\n      lastCapturedEvent = event;\n    }\n    // If there is a debounce awaiting, 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    else if (shouldShortcircuitPreviousDebounce(lastCapturedEvent, event)) {\n      handler({\n        event: event,\n        name,\n        global: globalListener,\n      });\n      lastCapturedEvent = event;\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      debounceTimerID = undefined;\n    }, debounceDuration);\n  };\n}\n\n/** JSDoc */\nfunction instrumentDOM() {\n  if (!('document' in WINDOW)) {\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\nlet _oldOnErrorHandler = null;\n/** JSDoc */\nfunction instrumentError() {\n  _oldOnErrorHandler = WINDOW.onerror;\n\n  WINDOW.onerror = function (msg, url, line, column, error) {\n    triggerHandlers('error', {\n      column,\n      error,\n      line,\n      msg,\n      url,\n    });\n\n    if (_oldOnErrorHandler) {\n      // eslint-disable-next-line prefer-rest-params\n      return _oldOnErrorHandler.apply(this, arguments);\n    }\n\n    return false;\n  };\n}\n\nlet _oldOnUnhandledRejectionHandler = null;\n/** JSDoc */\nfunction instrumentUnhandledRejection() {\n  _oldOnUnhandledRejectionHandler = WINDOW.onunhandledrejection;\n\n  WINDOW.onunhandledrejection = function (e) {\n    triggerHandlers('unhandledrejection', e);\n\n    if (_oldOnUnhandledRejectionHandler) {\n      // eslint-disable-next-line prefer-rest-params\n      return _oldOnUnhandledRejectionHandler.apply(this, arguments);\n    }\n\n    return true;\n  };\n}\n\nexport { addInstrumentationHandler };\n//# sourceMappingURL=instrument.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 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 || (typeof wat !== 'object' && typeof wat !== 'function');\n}\n\n/**\n * Checks whether given value's type is an object literal\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\nexport { isDOMError, isDOMException, isElement, isError, isErrorEvent, isEvent, isInstanceOf, isNaN, isPlainObject, isPrimitive, isRegExp, isString, isSyntheticEvent, isThenable };\n//# sourceMappingURL=is.js.map\n","import { getGlobalSingleton, GLOBAL_OBJ } from './worldwide.js';\n\n/** Prefix for logging strings */\nconst PREFIX = 'Sentry Logger ';\n\nconst CONSOLE_LEVELS = ['debug', 'info', 'warn', 'error', 'log', 'assert', 'trace'] ;\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 originalConsole = GLOBAL_OBJ.console ;\n  const wrappedLevels = {};\n\n  // Restore all wrapped console methods\n  CONSOLE_LEVELS.forEach(level => {\n    // TODO(v7): Remove this check as it's only needed for Node 6\n    const originalWrappedFunc =\n      originalConsole[level] && (originalConsole[level] ).__sentry_original__;\n    if (level in originalConsole && originalWrappedFunc) {\n      wrappedLevels[level] = originalConsole[level] ;\n      originalConsole[level] = originalWrappedFunc ;\n    }\n  });\n\n  try {\n    return callback();\n  } finally {\n    // Revert restoration to wrapped state\n    Object.keys(wrappedLevels).forEach(level => {\n      originalConsole[level] = wrappedLevels[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  };\n\n  if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {\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\n// Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used\nlet logger;\nif ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {\n  logger = getGlobalSingleton('logger', makeLogger);\n} else {\n  logger = makeLogger();\n}\n\nexport { CONSOLE_LEVELS, consoleSandbox, logger };\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  if (crypto && crypto.randomUUID) {\n    return crypto.randomUUID().replace(/-/g, '');\n  }\n\n  const getRandomByte =\n    crypto && crypto.getRandomValues ? () => crypto.getRandomValues(new Uint8Array(1))[0] : () => Math.random() * 16;\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, frame.lineno - 1), 0);\n\n  frame.pre_context = lines\n    .slice(Math.max(0, sourceLine - linesOfContext), sourceLine)\n    .map((line) => snipLine(line, 0));\n\n  frame.context_line = snipLine(lines[Math.min(maxLines - 1, sourceLine)], frame.colno || 0);\n\n  frame.post_context = lines\n    .slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext)\n    .map((line) => snipLine(line, 0));\n}\n\n/**\n * Checks whether or not we've already captured the given exception (note: not an identical exception - the very object\n * in question), and marks it captured if not.\n *\n * This is useful because it's possible for an error to get captured by more than one mechanism. After we intercept and\n * record an error, we rethrow it (assuming we've intercepted it before it's reached the top-level global handlers), so\n * that we don't interfere with whatever effects the error might have had were the SDK not there. At that point, because\n * the error has been rethrown, it's possible for it to bubble up to some other code we've instrumented. If it's not\n * caught after that, it will bubble all the way up to the global handlers (which of course we also instrument). This\n * function helps us ensure that even if we encounter the same error more than once, we only record it the first time we\n * see it.\n *\n * Note: It will ignore primitives (always return `false` and not mark them as seen), as properties can't be set on\n * them. {@link: Object.objectify} can be used on exceptions to convert any that are primitives into their equivalent\n * object wrapper forms so that this check will always work. However, because we need to flag the exact object which\n * will get rethrown, and because that rethrowing happens outside of the event processing pipeline, the objectification\n * must be done before the exception captured.\n *\n * @param A thrown exception to check or flag as having been seen\n * @returns `true` if the exception has already been captured, `false` if not (with the side effect of marking it seen)\n */\nfunction checkOrSetAlreadyCaught(exception) {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  if (exception && (exception ).__sentry_captured__) {\n    return true;\n  }\n\n  try {\n    // set it this way rather than by assignment so that it's not ennumerable and therefore isn't recorded by the\n    // `ExtraErrorData` integration\n    addNonEnumerableProperty(exception , '__sentry_captured__', true);\n  } catch (err) {\n    // `exception` is a primitive, so we can't mark it seen\n  }\n\n  return false;\n}\n\n/**\n * Checks whether the given input is already an array, and if it isn't, wraps it in one.\n *\n * @param maybeArray Input to turn into an array, if necessary\n * @returns The input, if already an array, or an array with the input as the only element, if not\n */\nfunction arrayify(maybeArray) {\n  return Array.isArray(maybeArray) ? maybeArray : [maybeArray];\n}\n\nexport { addContextToFrame, addExceptionMechanism, addExceptionTypeValue, arrayify, checkOrSetAlreadyCaught, getEventDescription, parseSemver, uuid4 };\n//# sourceMappingURL=misc.js.map\n","import { isBrowserBundle } from './env.js';\n\n/**\n * NOTE: In order to avoid circular dependencies, if you add a function to this module and it needs to print something,\n * you must either a) use `console.log` rather than the logger, or b) put your function elsewhere.\n */\n\n/**\n * Checks whether we're in the Node.js or Browser environment\n *\n * @returns Answer to given question\n */\nfunction isNodeEnv() {\n  // explicitly check for browser bundles as those can be optimized statically\n  // by terser/rollup.\n  return (\n    !isBrowserBundle() &&\n    Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]'\n  );\n}\n\n/**\n * Requires a module which is protected against bundler minification.\n *\n * @param request The module path to resolve\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any\nfunction dynamicRequire(mod, request) {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  return mod.require(request);\n}\n\n/**\n * Helper for dynamically loading module that should work with linked dependencies.\n * The problem is that we _should_ be using `require(require.resolve(moduleName, { paths: [cwd()] }))`\n * However it's _not possible_ to do that with Webpack, as it has to know all the dependencies during\n * build time. `require.resolve` is also not available in any other way, so we cannot create,\n * a fake helper like we do with `dynamicRequire`.\n *\n * We always prefer to use local package, thus the value is not returned early from each `try/catch` block.\n * That is to mimic the behavior of `require.resolve` exactly.\n *\n * @param moduleName module name to require\n * @returns possibly required module\n */\nfunction loadModule(moduleName) {\n  let mod;\n\n  try {\n    mod = dynamicRequire(module, moduleName);\n  } catch (e) {\n    // no-empty\n  }\n\n  try {\n    const { cwd } = dynamicRequire(module, 'process');\n    mod = dynamicRequire(module, `${cwd()}/node_modules/${moduleName}`) ;\n  } catch (e) {\n    // no-empty\n  }\n\n  return mod;\n}\n\nexport { dynamicRequire, isNodeEnv, loadModule };\n//# sourceMappingURL=node.js.map\n","/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\n/**\n * Helper to decycle json objects\n */\nfunction memoBuilder() {\n  const hasWeakSet = typeof WeakSet === 'function';\n  const inner = hasWeakSet ? new WeakSet() : [];\n  function memoize(obj) {\n    if (hasWeakSet) {\n      if (inner.has(obj)) {\n        return true;\n      }\n      inner.add(obj);\n      return false;\n    }\n    // eslint-disable-next-line @typescript-eslint/prefer-for-of\n    for (let i = 0; i < inner.length; i++) {\n      const value = inner[i];\n      if (value === obj) {\n        return true;\n      }\n    }\n    inner.push(obj);\n    return false;\n  }\n\n  function unmemoize(obj) {\n    if (hasWeakSet) {\n      inner.delete(obj);\n    } else {\n      for (let i = 0; i < inner.length; i++) {\n        if (inner[i] === obj) {\n          inner.splice(i, 1);\n          break;\n        }\n      }\n    }\n  }\n  return [memoize, unmemoize];\n}\n\nexport { memoBuilder };\n//# sourceMappingURL=memo.js.map\n","import { isNaN, 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 = +Infinity, 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 (value === null || (['number', 'boolean', 'string'].includes(typeof value) && !isNaN(value))) {\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're also done if we've reached the max depth\n  if (depth === 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, depth - 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, depth - 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/**\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    // 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    // this catches `undefined` (but not `null`, which is a primitive and can be serialized on its own)\n    if (value === void 0) {\n      return '[undefined]';\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    return `[object ${getConstructorName(value)}]`;\n  } catch (err) {\n    return `**non-serializable** (${err})`;\n  }\n}\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\nexport { normalize, normalizeToSize, visit as walk };\n//# sourceMappingURL=normalize.js.map\n","import { htmlTreeAsString } from './browser.js';\nimport { isError, isEvent, isInstanceOf, isElement, isPlainObject, isPrimitive } from './is.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    try {\n      markFunctionWrapped(wrapped, original);\n    } catch (_Oo) {\n      // This can throw if multiple fill happens on a global object like XMLHttpRequest\n      // Fixes https://github.com/getsentry/sentry-javascript/issues/2043\n    }\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  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}\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  const proto = original.prototype || {};\n  wrapped.prototype = original.prototype = proto;\n  addNonEnumerableProperty(wrapped, '__sentry_original__', original);\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(value)\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 (isPlainObject(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\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, category) {\n  return limits[category] || limits.all || 0;\n}\n\n/**\n * Checks if a category is rate limited\n */\nfunction isRateLimited(limits, category, now = Date.now()) {\n  return disabledUntil(limits, category) > 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>\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     */\n    for (const limit of rateLimitHeader.trim().split(',')) {\n      const [retryAfter, categories] = limit.split(':', 2);\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          updatedRateLimits[category] = now + delay;\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","const STACKTRACE_LIMIT = 50;\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    for (const line of stack.split('\\n').slice(skipFirst)) {\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 = line.replace(/\\(error: (.*)\\)/, '$1');\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\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 * @hidden\n */\nfunction stripSentryFramesAndReverse(stack) {\n  if (!stack.length) {\n    return [];\n  }\n\n  let localStack = stack;\n\n  const firstFrameFunction = localStack[0].function || '';\n  const lastFrameFunction = localStack[localStack.length - 1].function || '';\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 (firstFrameFunction.indexOf('captureMessage') !== -1 || firstFrameFunction.indexOf('captureException') !== -1) {\n    localStack = localStack.slice(1);\n  }\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 (lastFrameFunction.indexOf('sentryWrapped') !== -1) {\n    localStack = localStack.slice(0, -1);\n  }\n\n  // The frame where the crash happened, should be the last entry in the array\n  return localStack\n    .slice(0, STACKTRACE_LIMIT)\n    .map(frame => ({\n      ...frame,\n      filename: frame.filename || localStack[0].filename,\n      function: frame.function || '?',\n    }))\n    .reverse();\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// eslint-disable-next-line complexity\nfunction node(getModule) {\n  const FILENAME_MATCH = /^\\s*[-]{4,}$/;\n  const FULL_MATCH = /at (?:async )?(?:(.+?)\\s+\\()?(?:(.+):(\\d+):(\\d+)?|([^)]+))\\)?/;\n\n  // eslint-disable-next-line complexity\n  return (line) => {\n    if (line.match(FILENAME_MATCH)) {\n      return {\n        filename: line,\n      };\n    }\n\n    const lineMatch = line.match(FULL_MATCH);\n    if (!lineMatch) {\n      return undefined;\n    }\n\n    let object;\n    let method;\n    let functionName;\n    let typeName;\n    let methodName;\n\n    if (lineMatch[1]) {\n      functionName = lineMatch[1];\n\n      let methodStart = functionName.lastIndexOf('.');\n      if (functionName[methodStart - 1] === '.') {\n        methodStart--;\n      }\n\n      if (methodStart > 0) {\n        object = functionName.slice(0, methodStart);\n        method = functionName.slice(methodStart + 1);\n        const objectEnd = object.indexOf('.Module');\n        if (objectEnd > 0) {\n          functionName = functionName.slice(objectEnd + 1);\n          object = object.slice(0, objectEnd);\n        }\n      }\n      typeName = undefined;\n    }\n\n    if (method) {\n      typeName = object;\n      methodName = method;\n    }\n\n    if (method === '<anonymous>') {\n      methodName = undefined;\n      functionName = undefined;\n    }\n\n    if (functionName === undefined) {\n      methodName = methodName || '<anonymous>';\n      functionName = typeName ? `${typeName}.${methodName}` : methodName;\n    }\n\n    const filename = lineMatch[2] && lineMatch[2].startsWith('file://') ? lineMatch[2].slice(7) : lineMatch[2];\n    const isNative = lineMatch[5] === 'native';\n    const isInternal =\n      isNative || (filename && !filename.startsWith('/') && !filename.startsWith('.') && filename.indexOf(':\\\\') !== 1);\n\n    // in_app is all that's not an internal Node function or a module within node_modules\n    // note that isNative appears to return true even for node core libraries\n    // see https://github.com/getsentry/raven-node/issues/176\n    const in_app = !isInternal && filename !== undefined && !filename.includes('node_modules/');\n\n    return {\n      filename,\n      module: getModule ? getModule(filename) : undefined,\n      function: functionName,\n      lineno: parseInt(lineMatch[3], 10) || undefined,\n      colno: parseInt(lineMatch[4], 10) || undefined,\n      in_app,\n    };\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 { 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      output.push(String(value));\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\n/**\n * Given a string, escape characters which have meaning in the regex grammar, such that the result is safe to feed to\n * `new RegExp()`.\n *\n * Based on https://github.com/sindresorhus/escape-string-regexp. Vendored to a) reduce the size by skipping the runtime\n * type-checking, and b) ensure it gets down-compiled for old versions of Node (the published package only supports Node\n * 12+).\n *\n * @param regexString The string to escape\n * @returns An version of the string with all special regex characters escaped\n */\nfunction escapeStringForRegex(regexString) {\n  // escape the hyphen separately so we can also replace it with a unicode literal hyphen, to avoid the problems\n  // discussed in https://github.com/sindresorhus/escape-string-regexp/issues/20.\n  return regexString.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&').replace(/-/g, '\\\\x2d');\n}\n\nexport { escapeStringForRegex, isMatchingPattern, safeJoin, snipLine, stringMatchesSomePattern, truncate };\n//# sourceMappingURL=string.js.map\n","import { 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-ignore 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 (!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      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\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\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 chrome = (WINDOW ).chrome;\n  const isChromePackagedApp = chrome && chrome.app && chrome.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 { isNativeFetch, supportsDOMError, supportsDOMException, supportsErrorEvent, supportsFetch, supportsHistory, 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   __init() {this._state = States.PENDING;}\n   __init2() {this._handlers = [];}\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);SyncPromise.prototype.__init5.call(this);SyncPromise.prototype.__init6.call(this);\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    __init3() {this._resolve = (value) => {\n    this._setResult(States.RESOLVED, value);\n  };}\n\n  /** JSDoc */\n    __init4() {this._reject = (reason) => {\n    this._setResult(States.REJECTED, reason);\n  };}\n\n  /** JSDoc */\n    __init5() {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    __init6() {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 { isNodeEnv, dynamicRequire } from './node.js';\nimport { getGlobalObject } from './worldwide.js';\n\n// eslint-disable-next-line deprecation/deprecation\nconst WINDOW = getGlobalObject();\n\n/**\n * An object that can return the current timestamp in seconds since the UNIX epoch.\n */\n\n/**\n * A TimestampSource implementation for environments that do not support the Performance Web API natively.\n *\n * Note that this TimestampSource does not use a monotonic clock. A call to `nowSeconds` may return a timestamp earlier\n * than a previously returned value. We do not try to emulate a monotonic behavior in order to facilitate debugging. It\n * is more obvious to explain \"why does my span have negative duration\" than \"why my spans have zero duration\".\n */\nconst dateTimestampSource = {\n  nowSeconds: () => Date.now() / 1000,\n};\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 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 getBrowserPerformance() {\n  const { performance } = WINDOW;\n  if (!performance || !performance.now) {\n    return undefined;\n  }\n\n  // Replace performance.timeOrigin with our own timeOrigin based on Date.now().\n  //\n  // This is a partial workaround for browsers reporting performance.timeOrigin such that performance.timeOrigin +\n  // performance.now() gives a date arbitrarily in the past.\n  //\n  // Additionally, computing timeOrigin in this way fills the gap for browsers where performance.timeOrigin is\n  // undefined.\n  //\n  // The assumption that performance.timeOrigin + performance.now() ~= Date.now() is flawed, but we depend on it to\n  // interact with data coming out of performance entries.\n  //\n  // Note that despite recommendations against it in the spec, browsers implement the Performance API with a clock that\n  // might stop when the computer is asleep (and perhaps under other circumstances). Such behavior causes\n  // performance.timeOrigin + performance.now() to have an arbitrary skew over Date.now(). In laptop computers, we have\n  // observed skews that can be as long as days, weeks or months.\n  //\n  // See https://github.com/getsentry/sentry-javascript/issues/2590.\n  //\n  // BUG: despite our best intentions, this workaround has its limitations. It mostly addresses timings of pageload\n  // transactions, but ignores the skew built up over time that can aversely affect timestamps of navigation\n  // transactions of long-lived web pages.\n  const timeOrigin = Date.now() - performance.now();\n\n  return {\n    now: () => performance.now(),\n    timeOrigin,\n  };\n}\n\n/**\n * Returns the native Performance API implementation from Node.js. Returns undefined in old Node.js versions that don't\n * implement the API.\n */\nfunction getNodePerformance() {\n  try {\n    const perfHooks = dynamicRequire(module, 'perf_hooks') ;\n    return perfHooks.performance;\n  } catch (_) {\n    return undefined;\n  }\n}\n\n/**\n * The Performance API implementation for the current platform, if available.\n */\nconst platformPerformance = isNodeEnv() ? getNodePerformance() : getBrowserPerformance();\n\nconst timestampSource =\n  platformPerformance === undefined\n    ? dateTimestampSource\n    : {\n        nowSeconds: () => (platformPerformance.timeOrigin + platformPerformance.now()) / 1000,\n      };\n\n/**\n * Returns a timestamp in seconds since the UNIX epoch using the Date API.\n */\nconst dateTimestampInSeconds = dateTimestampSource.nowSeconds.bind(dateTimestampSource);\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 * See `usingPerformanceAPI` to test whether the Performance API is used.\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 = timestampSource.nowSeconds.bind(timestampSource);\n\n// Re-exported with an old name for backwards-compatibility.\nconst timestampWithMs = timestampInSeconds;\n\n/**\n * A boolean that is true when timestampInSeconds uses the Performance API to produce monotonic timestamps.\n */\nconst usingPerformanceAPI = platformPerformance !== undefined;\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 } = WINDOW;\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, usingPerformanceAPI };\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\n {\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    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\nexport { getNumberOfUrlSegments, parseUrl, stripUrlQueryAndFragment };\n//# sourceMappingURL=url.js.map\n","/** Internal global with common properties and Sentry extensions  */\n\n// The code below for 'isGlobalObj' and 'GLOBAL_OBJ' was copied from core-js before modification\n// https://github.com/zloirock/core-js/blob/1b944df55282cdc99c90db5f49eb0b6eda2cc0a3/packages/core-js/internals/global.js\n// core-js has the following licence:\n//\n// Copyright (c) 2014-2022 Denis Pushkarev\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n/** Returns 'obj' if it's the global object, otherwise returns undefined */\nfunction isGlobalObj(obj) {\n  return obj && obj.Math == Math ? obj : undefined;\n}\n\n/** Get's the global object for the current JavaScript runtime */\nconst GLOBAL_OBJ =\n  (typeof globalThis == 'object' && isGlobalObj(globalThis)) ||\n  // eslint-disable-next-line no-restricted-globals\n  (typeof window == 'object' && isGlobalObj(window)) ||\n  (typeof self == 'object' && isGlobalObj(self)) ||\n  (typeof global == 'object' && isGlobalObj(global)) ||\n  (function () {\n    return this;\n  })() ||\n  {};\n\n/**\n * @deprecated Use GLOBAL_OBJ instead or WINDOW from @sentry/browser. This will be removed in v8\n */\nfunction getGlobalObject() {\n  return GLOBAL_OBJ ;\n}\n\n/**\n * Returns a global singleton contained in the global `__SENTRY__` object.\n *\n * If the singleton doesn't already exist in `__SENTRY__`, it will be created using the given factory\n * function and added to the `__SENTRY__` object.\n *\n * @param name name of the global singleton on __SENTRY__\n * @param creator creator Factory function to create the singleton if it doesn't already exist on `__SENTRY__`\n * @param obj (Optional) The global object on which to look for `__SENTRY__`, if not `GLOBAL_OBJ`'s return value\n * @returns the singleton\n */\nfunction getGlobalSingleton(name, creator, obj) {\n  const gbl = (obj || GLOBAL_OBJ) ;\n  const __SENTRY__ = (gbl.__SENTRY__ = gbl.__SENTRY__ || {});\n  const singleton = __SENTRY__[name] || (__SENTRY__[name] = creator());\n  return singleton;\n}\n\nexport { GLOBAL_OBJ, getGlobalObject, getGlobalSingleton };\n//# sourceMappingURL=worldwide.js.map\n","const DEFAULT_HOOKS = ['activate', 'mount', 'update'];\n\nexport { DEFAULT_HOOKS };\n//# sourceMappingURL=constants.js.map\n","// Vendored directly from https://github.com/vuejs/vue/blob/master/src/core/util/debug.js with types only changes.\nconst classifyRE = /(?:^|[-_])(\\w)/g;\nconst classify = (str) => str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '');\n\nconst ROOT_COMPONENT_NAME = '<Root>';\nconst ANONYMOUS_COMPONENT_NAME = '<Anonymous>';\n\nconst repeat = (str, n) => {\n  // string.repeat() is not supported by IE11, we fall back to just using the string in that case\n  return str.repeat ? str.repeat(n) : str;\n};\n\nconst formatComponentName = (vm, includeFile) => {\n  if (!vm) {\n    return ANONYMOUS_COMPONENT_NAME;\n  }\n\n  if (vm.$root === vm) {\n    return ROOT_COMPONENT_NAME;\n  }\n\n  // https://github.com/getsentry/sentry-javascript/issues/5204 $options can be undefined\n  if (!vm.$options) {\n    return ANONYMOUS_COMPONENT_NAME;\n  }\n\n  const options = vm.$options;\n\n  let name = options.name || options._componentTag;\n  const file = options.__file;\n  if (!name && file) {\n    const match = file.match(/([^/\\\\]+)\\.vue$/);\n    if (match) {\n      name = match[1];\n    }\n  }\n\n  return (\n    (name ? `<${classify(name)}>` : ANONYMOUS_COMPONENT_NAME) + (file && includeFile !== false ? ` at ${file}` : '')\n  );\n};\n\nconst generateComponentTrace = (vm) => {\n  if (vm && (vm._isVue || vm.__isVue) && vm.$parent) {\n    const tree = [];\n    let currentRecursiveSequence = 0;\n    while (vm) {\n      if (tree.length > 0) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        const last = tree[tree.length - 1] ;\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        if (last.constructor === vm.constructor) {\n          currentRecursiveSequence++;\n          vm = vm.$parent; // eslint-disable-line no-param-reassign\n          continue;\n        } else if (currentRecursiveSequence > 0) {\n          tree[tree.length - 1] = [last, currentRecursiveSequence];\n          currentRecursiveSequence = 0;\n        }\n      }\n      tree.push(vm);\n      vm = vm.$parent; // eslint-disable-line no-param-reassign\n    }\n\n    const formattedTree = tree\n      .map(\n        (vm, i) =>\n          `${\n            (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) +\n            (Array.isArray(vm)\n              ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`\n              : formatComponentName(vm))\n          }`,\n      )\n      .join('\\n');\n\n    return `\\n\\nfound in\\n\\n${formattedTree}`;\n  }\n\n  return `\\n\\n(found in ${formatComponentName(vm)})`;\n};\n\nexport { formatComponentName, generateComponentTrace };\n//# sourceMappingURL=components.js.map\n","import { getCurrentHub } from '@sentry/browser';\nimport { formatComponentName, generateComponentTrace } from './components.js';\n\nconst attachErrorHandler = (app, options) => {\n  const { errorHandler, warnHandler, silent } = app.config;\n\n  app.config.errorHandler = (error, vm, lifecycleHook) => {\n    const componentName = formatComponentName(vm, false);\n    const trace = vm ? generateComponentTrace(vm) : '';\n    const metadata = {\n      componentName,\n      lifecycleHook,\n      trace,\n    };\n\n    if (options.attachProps && vm) {\n      // Vue2 - $options.propsData\n      // Vue3 - $props\n      if (vm.$options && vm.$options.propsData) {\n        metadata.propsData = vm.$options.propsData;\n      } else if (vm.$props) {\n        metadata.propsData = vm.$props;\n      }\n    }\n\n    // Capture exception in the next event loop, to make sure that all breadcrumbs are recorded in time.\n    setTimeout(() => {\n      getCurrentHub().withScope(scope => {\n        scope.setContext('vue', metadata);\n        getCurrentHub().captureException(error);\n      });\n    });\n\n    if (typeof errorHandler === 'function') {\n      (errorHandler ).call(app, error, vm, lifecycleHook);\n    }\n\n    if (options.logErrors) {\n      const hasConsole = typeof console !== 'undefined';\n      const message = `Error in ${lifecycleHook}: \"${error && error.toString()}\"`;\n\n      if (warnHandler) {\n        (warnHandler ).call(null, message, vm, trace);\n      } else if (hasConsole && !silent) {\n        // eslint-disable-next-line no-console\n        console.error(`[Vue warn]: ${message}${trace}`);\n      }\n    }\n  };\n};\n\nexport { attachErrorHandler };\n//# sourceMappingURL=errorhandler.js.map\n","import { getCurrentHub } from '@sentry/browser';\nimport { logger, timestampInSeconds } from '@sentry/utils';\nimport { formatComponentName } from './components.js';\nimport { DEFAULT_HOOKS } from './constants.js';\n\nconst VUE_OP = 'ui.vue';\n\n// Mappings from operation to corresponding lifecycle hook.\nconst HOOKS = {\n  activate: ['activated', 'deactivated'],\n  create: ['beforeCreate', 'created'],\n  destroy: ['beforeDestroy', 'destroyed'],\n  mount: ['beforeMount', 'mounted'],\n  update: ['beforeUpdate', 'updated'],\n};\n\n/** Grabs active transaction off scope, if any */\nfunction getActiveTransaction() {\n  const scope = getCurrentHub().getScope();\n  return scope && scope.getTransaction();\n}\n\n/** Finish top-level span and activity with a debounce configured using `timeout` option */\nfunction finishRootSpan(vm, timestamp, timeout) {\n  if (vm.$_sentryRootSpanTimer) {\n    clearTimeout(vm.$_sentryRootSpanTimer);\n  }\n\n  vm.$_sentryRootSpanTimer = setTimeout(() => {\n    if (vm.$root && vm.$root.$_sentryRootSpan) {\n      vm.$root.$_sentryRootSpan.finish(timestamp);\n      vm.$root.$_sentryRootSpan = undefined;\n    }\n  }, timeout);\n}\n\nconst createTracingMixins = (options) => {\n  const hooks = (options.hooks || [])\n    .concat(DEFAULT_HOOKS)\n    // Removing potential duplicates\n    .filter((value, index, self) => self.indexOf(value) === index);\n\n  const mixins = {};\n\n  for (const operation of hooks) {\n    // Retrieve corresponding hooks from Vue lifecycle.\n    // eg. mount => ['beforeMount', 'mounted']\n    const internalHooks = HOOKS[operation];\n    if (!internalHooks) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(`Unknown hook: ${operation}`);\n      continue;\n    }\n\n    for (const internalHook of internalHooks) {\n      mixins[internalHook] = function () {\n        const isRoot = this.$root === this;\n\n        if (isRoot) {\n          const activeTransaction = getActiveTransaction();\n          if (activeTransaction) {\n            this.$_sentryRootSpan =\n              this.$_sentryRootSpan ||\n              activeTransaction.startChild({\n                description: 'Application Render',\n                op: `${VUE_OP}.render`,\n              });\n          }\n        }\n\n        // Skip components that we don't want to track to minimize the noise and give a more granular control to the user\n        const name = formatComponentName(this, false);\n        const shouldTrack = Array.isArray(options.trackComponents)\n          ? options.trackComponents.indexOf(name) > -1\n          : options.trackComponents;\n\n        // We always want to track root component\n        if (!isRoot && !shouldTrack) {\n          return;\n        }\n\n        this.$_sentrySpans = this.$_sentrySpans || {};\n\n        // Start a new span if current hook is a 'before' hook.\n        // Otherwise, retrieve the current span and finish it.\n        if (internalHook == internalHooks[0]) {\n          const activeTransaction = (this.$root && this.$root.$_sentryRootSpan) || getActiveTransaction();\n          if (activeTransaction) {\n            // Cancel old span for this hook operation in case it didn't get cleaned up. We're not actually sure if it\n            // will ever be the case that cleanup hooks re not called, but we had users report that spans didn't get\n            // finished so we finish the span before starting a new one, just to be sure.\n            const oldSpan = this.$_sentrySpans[operation];\n            if (oldSpan && !oldSpan.endTimestamp) {\n              oldSpan.finish();\n            }\n\n            this.$_sentrySpans[operation] = activeTransaction.startChild({\n              description: `Vue <${name}>`,\n              op: `${VUE_OP}.${operation}`,\n            });\n          }\n        } else {\n          // The span should already be added via the first handler call (in the 'before' hook)\n          const span = this.$_sentrySpans[operation];\n          // The before hook did not start the tracking span, so the span was not added.\n          // This is probably because it happened before there is an active transaction\n          if (!span) return;\n          span.finish();\n\n          finishRootSpan(this, timestampInSeconds(), options.timeout);\n        }\n      };\n    }\n  }\n\n  return mixins;\n};\n\nexport { createTracingMixins, getActiveTransaction };\n//# sourceMappingURL=tracing.js.map\n","import { SDK_VERSION, init as init$1 } from '@sentry/browser';\nimport { hasTracingEnabled } from '@sentry/core';\nimport { GLOBAL_OBJ, arrayify } from '@sentry/utils';\nimport { DEFAULT_HOOKS } from './constants.js';\nimport { attachErrorHandler } from './errorhandler.js';\nimport { createTracingMixins } from './tracing.js';\n\nconst globalWithVue = GLOBAL_OBJ ;\n\nconst DEFAULT_CONFIG = {\n  Vue: globalWithVue.Vue,\n  attachProps: true,\n  logErrors: false,\n  hooks: DEFAULT_HOOKS,\n  timeout: 2000,\n  trackComponents: false,\n  _metadata: {\n    sdk: {\n      name: 'sentry.javascript.vue',\n      packages: [\n        {\n          name: 'npm:@sentry/vue',\n          version: SDK_VERSION,\n        },\n      ],\n      version: SDK_VERSION,\n    },\n  },\n};\n\n/**\n * Inits the Vue SDK\n */\nfunction init(\n  config = {},\n) {\n  const options = {\n    ...DEFAULT_CONFIG,\n    ...config,\n  };\n\n  init$1(options);\n\n  if (!options.Vue && !options.app) {\n    // eslint-disable-next-line no-console\n    console.warn(\n      `[@sentry/vue]: Misconfigured SDK. Vue specific errors will not be captured.\nUpdate your \\`Sentry.init\\` call with an appropriate config option:\n\\`app\\` (Application Instance - Vue 3) or \\`Vue\\` (Vue Constructor - Vue 2).`,\n    );\n    return;\n  }\n\n  if (options.app) {\n    const apps = arrayify(options.app);\n    apps.forEach(app => vueInit(app, options));\n  } else if (options.Vue) {\n    vueInit(options.Vue, options);\n  }\n}\n\nconst vueInit = (app, options) => {\n  // Check app is not mounted yet - should be mounted _after_ init()!\n  // This is _somewhat_ private, but in the case that this doesn't exist we simply ignore it\n  // See: https://github.com/vuejs/core/blob/eb2a83283caa9de0a45881d860a3cbd9d0bdd279/packages/runtime-core/src/component.ts#L394\n  const appWithInstance = app\n\n;\n\n  const isMounted = appWithInstance._instance && appWithInstance._instance.isMounted;\n  if (isMounted === true) {\n    // eslint-disable-next-line no-console\n    console.warn(\n      '[@sentry/vue]: Misconfigured SDK. Vue app is already mounted. Make sure to call `app.mount()` after `Sentry.init()`.',\n    );\n  }\n\n  attachErrorHandler(app, options);\n\n  if (hasTracingEnabled(options)) {\n    app.mixin(\n      createTracingMixins({\n        ...options,\n        ...options.tracingOptions,\n      }),\n    );\n  }\n};\n\nexport { init };\n//# sourceMappingURL=sdk.js.map\n"],"names":["WINDOW","DEFAULT_MAX_STRING_LENGTH","htmlTreeAsString","elem","options","currentElem","MAX_TRAVERSE_HEIGHT","out","height","len","separator","sepLength","length","nextStr","keyAttrs","Array","isArray","maxStringLength","_htmlElementAsString","push","parentNode","reverse","join","_oO","el","className","classes","key","attr","i","tagName","toLowerCase","keyAttrPairs","filter","keyAttr","getAttribute","map","forEach","keyAttrPair","id","split","allowedAttrs","getLocationHref","document","location","href","oO","createClientReportEnvelope","discarded_events","dsn","timestamp","clientReportItem","type","DSN_REGEX","isValidProtocol","protocol","dsnToString","withPassword","host","path","pass","port","projectId","publicKey","dsnFromString","str","match","exec","lastPath","slice","pop","projectMatch","dsnFromComponents","components","validateDsn","__SENTRY_DEBUG__","requiredComponents","component","isNaN","parseInt","makeDsn","from","isBrowserBundle","__SENTRY_BROWSER_BUNDLE__","getSDKSource","createEnvelope","headers","items","addItemToEnvelope","envelope","newItem","forEachEnvelopeItem","callback","envelopeItems","envelopeItem","envelopeItemType","result","encodeUTF8","input","textEncoder","utf8","TextEncoder","encode","serializeEnvelope","envHeaders","parts","JSON","stringify","append","next","item","itemHeaders","payload","Uint8Array","stringifiedPayload","e","concatBuffers","buffers","totalLength","reduce","acc","buf","merged","offset","buffer","set","createAttachmentEnvelopeItem","attachment","data","filename","content_type","contentType","attachment_type","attachmentType","ITEM_TYPE_TO_DATA_CATEGORY_MAP","session","sessions","transaction","event","client_report","user_report","profile","replay_event","replay_recording","envelopeItemTypeToDataCategory","getSdkMetadataForEnvelopeHeader","metadataOrEvent","sdk","name","version","createEventEnvelopeHeaders","sdkInfo","tunnel","dynamicSamplingContext","sdkProcessingMetadata","event_id","sent_at","Date","toISOString","trace","SentryError","Error","constructor","message","logLevel","super","this","prototype","Object","setPrototypeOf","handlers","instrumented","instrument","instrumentConsole","instrumentDOM","instrumentXHR","instrumentFetch","instrumentHistory","instrumentError","instrumentUnhandledRejection","addInstrumentationHandler","triggerHandlers","handler","level","console","originalConsoleMethod","args","apply","originalFetch","handlerData","fetchData","method","getFetchMethod","url","getFetchUrl","startTimestamp","now","then","response","endTimestamp","error","fetchArgs","Request","String","toUpperCase","xhrproto","XMLHttpRequest","originalOpen","xhr","xhrInfo","__sentry_xhr__","__sentry_own_request__","onreadystatechangeHandler","readyState","status_code","status","onreadystatechange","original","readyStateArgs","addEventListener","originalSend","undefined","body","lastHref","oldOnPopState","onpopstate","historyReplacementFunction","originalHistoryFunction","to","history","debounceDuration","debounceTimerID","lastCapturedEvent","shouldShortcircuitPreviousDebounce","previous","current","target","shouldSkipDOMEvent","isContentEditable","makeDOMEventHandler","globalListener","global","clearTimeout","setTimeout","triggerDOMHandler","bind","globalDOMEventHandler","proto","hasOwnProperty","originalAddEventListener","listener","__sentry_instrumentation_handlers__","handlerForType","refCount","call","originalRemoveEventListener","keys","_oldOnErrorHandler","onerror","msg","line","column","arguments","_oldOnUnhandledRejectionHandler","onunhandledrejection","objectToString","toString","isError","wat","isInstanceOf","isBuiltin","isErrorEvent","isDOMError","isDOMException","isString","isPrimitive","isPlainObject","isEvent","Event","isElement","Element","isRegExp","isThenable","Boolean","isSyntheticEvent","base","_e","PREFIX","CONSOLE_LEVELS","consoleSandbox","originalConsole","wrappedLevels","originalWrappedFunc","__sentry_original__","makeLogger","enabled","logger","enable","disable","uuid4","gbl","crypto","msCrypto","randomUUID","replace","getRandomByte","getRandomValues","Math","random","c","getFirstException","exception","values","getEventDescription","eventId","firstException","value","addExceptionTypeValue","addExceptionMechanism","newMechanism","defaultMechanism","handled","currentMechanism","mechanism","mergedData","checkOrSetAlreadyCaught","__sentry_captured__","err","arrayify","maybeArray","isNodeEnv","process","dynamicRequire","mod","request","require","memoBuilder","hasWeakSet","WeakSet","inner","memoize","obj","has","add","unmemoize","delete","splice","normalize","depth","Infinity","maxProperties","visit","ERROR","normalizeToSize","object","maxSize","normalized","jsonSize","memo","includes","is","stringified","stringifyValue","startsWith","valueWithToJSON","toJSON","jsonValue","numAdded","visitable","visitKey","visitValue","_events","g","window","getConstructorName","getPrototypeOf","utf8Length","encodeURI","fill","source","replacementFactory","wrapped","markFunctionWrapped","_Oo","addNonEnumerableProperty","defineProperty","writable","configurable","getOriginalFunction","func","urlEncode","encodeURIComponent","convertToPlainObject","stack","getOwnProperties","newObj","serializeEventTarget","currentTarget","CustomEvent","detail","extractedProps","property","extractExceptionKeysForMessage","maxLength","sort","includedKeys","serialized","dropUndefinedKeys","inputValue","memoizationMap","Map","_dropUndefinedKeys","memoVal","get","returnValue","makePromiseBuffer","limit","isReady","remove","task","indexOf","taskProducer","drain","timeout","resolve","reject","counter","capturedSetTimeout","$","DEFAULT_RETRY_AFTER","parseRetryAfterHeader","header","headerDelay","headerDate","parse","disabledUntil","limits","category","all","isRateLimited","updateRateLimits","statusCode","updatedRateLimits","rateLimitHeader","retryAfterHeader","trim","retryAfter","categories","delay","validSeverityLevels","severityLevelFromString","STACKTRACE_LIMIT","createStackParser","parsers","sortedParsers","a","b","p","skipFirst","frames","cleanedLine","parser","frame","stripSentryFramesAndReverse","stackParserFromStackParserOptions","stackParser","localStack","firstFrameFunction","function","lastFrameFunction","defaultFunctionName","getFunctionName","fn","truncate","max","safeJoin","delimiter","output","isMatchingPattern","pattern","requireExactStringMatch","test","stringMatchesSomePattern","testString","patterns","some","supportsFetch","Headers","Response","isNativeFetch","supportsNativeFetch","fetch","doc","sandbox","createElement","hidden","head","appendChild","contentWindow","removeChild","supportsHistory","chrome","isChromePackagedApp","app","runtime","hasHistoryApi","pushState","replaceState","States","resolvedSyncPromise","SyncPromise","rejectedSyncPromise","reason","_","PENDING","RESOLVED","REJECTED","__init","_state","__init2","_handlers","executor","__init3","__init4","__init5","__init6","_resolve","_reject","onfulfilled","onrejected","_executeHandlers","catch","val","finally","onfinally","isRejected","_setResult","state","_value","cachedHandlers","dateTimestampSource","nowSeconds","getBrowserPerformance","performance","timeOrigin","getNodePerformance","perfHooks","module","platformPerformance","timestampSource","dateTimestampInSeconds","timestampInSeconds","_browserPerformanceTimeOriginMode","threshold","performanceNow","dateNow","timeOriginDelta","abs","timeOriginIsReliable","navigationStart","timing","hasNavigationStart","navigationStartDelta","navigationStartIsReliable","parseUrl","query","fragment","relative","isGlobalObj","GLOBAL_OBJ","globalThis","self","getGlobalObject","getGlobalSingleton","creator","__SENTRY__","singleton","DEFAULT_HOOKS","classifyRE","classify","ROOT_COMPONENT_NAME","ANONYMOUS_COMPONENT_NAME","repeat","n","formatComponentName","vm","includeFile","$root","$options","_componentTag","file","__file","generateComponentTrace","_isVue","__isVue","$parent","tree","currentRecursiveSequence","last","formattedTree","attachErrorHandler","errorHandler","warnHandler","silent","config","lifecycleHook","componentName","metadata","attachProps","propsData","$props","withScope","scope","setContext","captureException","logErrors","hasConsole","VUE_OP","HOOKS","activate","create","destroy","mount","update","getActiveTransaction","getScope","getTransaction","finishRootSpan","$_sentryRootSpanTimer","$_sentryRootSpan","finish","createTracingMixins","hooks","concat","index","mixins","operation","internalHooks","internalHook","isRoot","activeTransaction","startChild","description","op","shouldTrack","trackComponents","$_sentrySpans","oldSpan","span","time","globalWithVue","DEFAULT_CONFIG","Vue","_metadata","packages","init","apps","vueInit","warn","appWithInstance","isMounted","_instance","hasTracingEnabled","mixin","tracingOptions"],"sourceRoot":""}