{"version":3,"file":"vendors-b403787e.xxxxxxxx.bundle.js","mappings":"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","sources":["webpack://iadviser/./node_modules/@sentry/utils/esm/browser.js","webpack://iadviser/./node_modules/@sentry/utils/esm/clientreport.js","webpack://iadviser/./node_modules/@sentry/utils/esm/dsn.js","webpack://iadviser/./node_modules/@sentry/utils/esm/env.js","webpack://iadviser/./node_modules/@sentry/utils/esm/envelope.js","webpack://iadviser/./node_modules/@sentry/utils/esm/error.js","webpack://iadviser/./node_modules/@sentry/utils/esm/instrument.js","webpack://iadviser/./node_modules/@sentry/utils/esm/is.js","webpack://iadviser/./node_modules/@sentry/utils/esm/logger.js","webpack://iadviser/./node_modules/@sentry/utils/esm/misc.js","webpack://iadviser/./node_modules/@sentry/utils/esm/node.js","webpack://iadviser/./node_modules/@sentry/utils/esm/normalize.js","webpack://iadviser/./node_modules/@sentry/utils/esm/memo.js","webpack://iadviser/./node_modules/@sentry/utils/esm/object.js","webpack://iadviser/./node_modules/@sentry/utils/esm/promisebuffer.js","webpack://iadviser/./node_modules/@sentry/utils/esm/ratelimit.js","webpack://iadviser/./node_modules/@sentry/utils/esm/severity.js","webpack://iadviser/./node_modules/@sentry/utils/esm/stacktrace.js","webpack://iadviser/./node_modules/@sentry/utils/esm/string.js","webpack://iadviser/./node_modules/@sentry/utils/esm/supports.js","webpack://iadviser/./node_modules/@sentry/utils/esm/syncpromise.js","webpack://iadviser/./node_modules/@sentry/utils/esm/time.js","webpack://iadviser/./node_modules/@sentry/utils/esm/url.js","webpack://iadviser/./node_modules/@sentry/utils/esm/worldwide.js","webpack://iadviser/./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js","webpack://iadviser/./node_modules/style-loader/dist/runtime/insertBySelector.js","webpack://iadviser/./node_modules/style-loader/dist/runtime/insertStyleElement.js","webpack://iadviser/./node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js","webpack://iadviser/./node_modules/style-loader/dist/runtime/styleDomAPI.js","webpack://iadviser/./node_modules/style-loader/dist/runtime/styleTagTransform.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","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","/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\n/**\n * Helper to decycle json objects\n */\nfunction memoBuilder() {\n  const hasWeakSet = typeof WeakSet === 'function';\n  const inner = hasWeakSet ? new WeakSet() : [];\n  function memoize(obj) {\n    if (hasWeakSet) {\n      if (inner.has(obj)) {\n        return true;\n      }\n      inner.add(obj);\n      return false;\n    }\n    // eslint-disable-next-line @typescript-eslint/prefer-for-of\n    for (let i = 0; i < inner.length; i++) {\n      const value = inner[i];\n      if (value === obj) {\n        return true;\n      }\n    }\n    inner.push(obj);\n    return false;\n  }\n\n  function unmemoize(obj) {\n    if (hasWeakSet) {\n      inner.delete(obj);\n    } else {\n      for (let i = 0; i < inner.length; i++) {\n        if (inner[i] === obj) {\n          inner.splice(i, 1);\n          break;\n        }\n      }\n    }\n  }\n  return [memoize, unmemoize];\n}\n\nexport { memoBuilder };\n//# sourceMappingURL=memo.js.map\n","import { htmlTreeAsString } from './browser.js';\nimport { 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","\"use strict\";\n\nvar stylesInDOM = [];\n\nfunction getIndexByIdentifier(identifier) {\n  var result = -1;\n\n  for (var i = 0; i < stylesInDOM.length; i++) {\n    if (stylesInDOM[i].identifier === identifier) {\n      result = i;\n      break;\n    }\n  }\n\n  return result;\n}\n\nfunction modulesToDom(list, options) {\n  var idCountMap = {};\n  var identifiers = [];\n\n  for (var i = 0; i < list.length; i++) {\n    var item = list[i];\n    var id = options.base ? item[0] + options.base : item[0];\n    var count = idCountMap[id] || 0;\n    var identifier = \"\".concat(id, \" \").concat(count);\n    idCountMap[id] = count + 1;\n    var indexByIdentifier = getIndexByIdentifier(identifier);\n    var obj = {\n      css: item[1],\n      media: item[2],\n      sourceMap: item[3],\n      supports: item[4],\n      layer: item[5]\n    };\n\n    if (indexByIdentifier !== -1) {\n      stylesInDOM[indexByIdentifier].references++;\n      stylesInDOM[indexByIdentifier].updater(obj);\n    } else {\n      var updater = addElementStyle(obj, options);\n      options.byIndex = i;\n      stylesInDOM.splice(i, 0, {\n        identifier: identifier,\n        updater: updater,\n        references: 1\n      });\n    }\n\n    identifiers.push(identifier);\n  }\n\n  return identifiers;\n}\n\nfunction addElementStyle(obj, options) {\n  var api = options.domAPI(options);\n  api.update(obj);\n\n  var updater = function updater(newObj) {\n    if (newObj) {\n      if (newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap && newObj.supports === obj.supports && newObj.layer === obj.layer) {\n        return;\n      }\n\n      api.update(obj = newObj);\n    } else {\n      api.remove();\n    }\n  };\n\n  return updater;\n}\n\nmodule.exports = function (list, options) {\n  options = options || {};\n  list = list || [];\n  var lastIdentifiers = modulesToDom(list, options);\n  return function update(newList) {\n    newList = newList || [];\n\n    for (var i = 0; i < lastIdentifiers.length; i++) {\n      var identifier = lastIdentifiers[i];\n      var index = getIndexByIdentifier(identifier);\n      stylesInDOM[index].references--;\n    }\n\n    var newLastIdentifiers = modulesToDom(newList, options);\n\n    for (var _i = 0; _i < lastIdentifiers.length; _i++) {\n      var _identifier = lastIdentifiers[_i];\n\n      var _index = getIndexByIdentifier(_identifier);\n\n      if (stylesInDOM[_index].references === 0) {\n        stylesInDOM[_index].updater();\n\n        stylesInDOM.splice(_index, 1);\n      }\n    }\n\n    lastIdentifiers = newLastIdentifiers;\n  };\n};","\"use strict\";\n\nvar memo = {};\n/* istanbul ignore next  */\n\nfunction getTarget(target) {\n  if (typeof memo[target] === \"undefined\") {\n    var styleTarget = document.querySelector(target); // Special case to return head of iframe instead of iframe itself\n\n    if (window.HTMLIFrameElement && styleTarget instanceof window.HTMLIFrameElement) {\n      try {\n        // This will throw an exception if access to iframe is blocked\n        // due to cross-origin restrictions\n        styleTarget = styleTarget.contentDocument.head;\n      } catch (e) {\n        // istanbul ignore next\n        styleTarget = null;\n      }\n    }\n\n    memo[target] = styleTarget;\n  }\n\n  return memo[target];\n}\n/* istanbul ignore next  */\n\n\nfunction insertBySelector(insert, style) {\n  var target = getTarget(insert);\n\n  if (!target) {\n    throw new Error(\"Couldn't find a style target. This probably means that the value for the 'insert' parameter is invalid.\");\n  }\n\n  target.appendChild(style);\n}\n\nmodule.exports = insertBySelector;","\"use strict\";\n\n/* istanbul ignore next  */\nfunction insertStyleElement(options) {\n  var element = document.createElement(\"style\");\n  options.setAttributes(element, options.attributes);\n  options.insert(element, options.options);\n  return element;\n}\n\nmodule.exports = insertStyleElement;","\"use strict\";\n\n/* istanbul ignore next  */\nfunction setAttributesWithoutAttributes(styleElement) {\n  var nonce = typeof __webpack_nonce__ !== \"undefined\" ? __webpack_nonce__ : null;\n\n  if (nonce) {\n    styleElement.setAttribute(\"nonce\", nonce);\n  }\n}\n\nmodule.exports = setAttributesWithoutAttributes;","\"use strict\";\n\n/* istanbul ignore next  */\nfunction apply(styleElement, options, obj) {\n  var css = \"\";\n\n  if (obj.supports) {\n    css += \"@supports (\".concat(obj.supports, \") {\");\n  }\n\n  if (obj.media) {\n    css += \"@media \".concat(obj.media, \" {\");\n  }\n\n  var needLayer = typeof obj.layer !== \"undefined\";\n\n  if (needLayer) {\n    css += \"@layer\".concat(obj.layer.length > 0 ? \" \".concat(obj.layer) : \"\", \" {\");\n  }\n\n  css += obj.css;\n\n  if (needLayer) {\n    css += \"}\";\n  }\n\n  if (obj.media) {\n    css += \"}\";\n  }\n\n  if (obj.supports) {\n    css += \"}\";\n  }\n\n  var sourceMap = obj.sourceMap;\n\n  if (sourceMap && typeof btoa !== \"undefined\") {\n    css += \"\\n/*# sourceMappingURL=data:application/json;base64,\".concat(btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))), \" */\");\n  } // For old IE\n\n  /* istanbul ignore if  */\n\n\n  options.styleTagTransform(css, styleElement, options.options);\n}\n\nfunction removeStyleElement(styleElement) {\n  // istanbul ignore if\n  if (styleElement.parentNode === null) {\n    return false;\n  }\n\n  styleElement.parentNode.removeChild(styleElement);\n}\n/* istanbul ignore next  */\n\n\nfunction domAPI(options) {\n  var styleElement = options.insertStyleElement(options);\n  return {\n    update: function update(obj) {\n      apply(styleElement, options, obj);\n    },\n    remove: function remove() {\n      removeStyleElement(styleElement);\n    }\n  };\n}\n\nmodule.exports = domAPI;","\"use strict\";\n\n/* istanbul ignore next  */\nfunction styleTagTransform(css, styleElement) {\n  if (styleElement.styleSheet) {\n    styleElement.styleSheet.cssText = css;\n  } else {\n    while (styleElement.firstChild) {\n      styleElement.removeChild(styleElement.firstChild);\n    }\n\n    styleElement.appendChild(document.createTextNode(css));\n  }\n}\n\nmodule.exports = styleTagTransform;"],"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","dsnToString","withPassword","host","path","pass","port","projectId","protocol","publicKey","dsnFromComponents","components","makeDsn","from","str","match","exec","lastPath","slice","pop","projectMatch","dsnFromString","__SENTRY_DEBUG__","component","isValidProtocol","isNaN","parseInt","validateDsn","isBrowserBundle","__SENTRY_BROWSER_BUNDLE__","getSDKSource","createEnvelope","headers","items","addItemToEnvelope","envelope","newItem","forEachEnvelopeItem","callback","envelopeItems","envelopeItem","encodeUTF8","input","textEncoder","TextEncoder","encode","serializeEnvelope","envHeaders","parts","JSON","stringify","append","next","item","itemHeaders","payload","Uint8Array","stringifiedPayload","e","buffers","totalLength","reduce","acc","buf","merged","offset","buffer","set","concatBuffers","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","addInstrumentationHandler","level","console","originalConsoleMethod","args","triggerHandlers","apply","triggerDOMHandler","bind","globalDOMEventHandler","makeDOMEventHandler","addEventListener","target","proto","hasOwnProperty","originalAddEventListener","listener","__sentry_instrumentation_handlers__","handlerForType","refCount","handler","call","originalRemoveEventListener","undefined","keys","instrumentDOM","xhrproto","XMLHttpRequest","originalOpen","xhr","url","xhrInfo","__sentry_xhr__","method","toUpperCase","__sentry_own_request__","onreadystatechangeHandler","readyState","status_code","status","endTimestamp","now","startTimestamp","onreadystatechange","original","readyStateArgs","originalSend","body","instrumentXHR","originalFetch","handlerData","fetchData","getFetchMethod","getFetchUrl","then","response","error","oldOnPopState","onpopstate","historyReplacementFunction","originalHistoryFunction","lastHref","to","String","history","instrumentHistory","_oldOnErrorHandler","onerror","msg","line","column","arguments","_oldOnUnhandledRejectionHandler","onunhandledrejection","instrument","fetchArgs","Request","debounceDuration","debounceTimerID","lastCapturedEvent","globalListener","isContentEditable","shouldSkipDOMEvent","previous","current","shouldShortcircuitPreviousDebounce","global","clearTimeout","setTimeout","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","currentMechanism","mechanism","handled","mergedData","checkOrSetAlreadyCaught","__sentry_captured__","err","arrayify","maybeArray","isNodeEnv","process","dynamicRequire","mod","request","require","normalize","depth","maxProperties","visit","ERROR","normalizeToSize","object","maxSize","normalized","encodeURI","utf8Length","memo","hasWeakSet","WeakSet","inner","obj","has","add","delete","splice","memoBuilder","memoize","unmemoize","includes","is","stringified","_events","g","window","getPrototypeOf","getConstructorName","stringifyValue","startsWith","valueWithToJSON","toJSON","numAdded","visitable","visitKey","visitValue","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","_dropUndefinedKeys","Map","memoizationMap","memoVal","get","returnValue","makePromiseBuffer","limit","remove","task","indexOf","$","taskProducer","drain","timeout","resolve","reject","counter","capturedSetTimeout","DEFAULT_RETRY_AFTER","isRateLimited","limits","category","all","disabledUntil","updateRateLimits","statusCode","updatedRateLimits","rateLimitHeader","retryAfterHeader","trim","retryAfter","categories","headerDelay","delay","header","headerDate","parse","parseRetryAfterHeader","validSeverityLevels","severityLevelFromString","STACKTRACE_LIMIT","createStackParser","parsers","sortedParsers","a","b","p","skipFirst","frames","cleanedLine","parser","frame","localStack","firstFrameFunction","function","lastFrameFunction","stripSentryFramesAndReverse","stackParserFromStackParserOptions","stackParser","defaultFunctionName","getFunctionName","fn","truncate","max","safeJoin","delimiter","output","stringMatchesSomePattern","testString","patterns","requireExactStringMatch","some","pattern","test","isMatchingPattern","supportsFetch","Headers","Response","isNativeFetch","supportsNativeFetch","fetch","result","doc","sandbox","createElement","hidden","head","appendChild","contentWindow","removeChild","supportsHistory","chrome","isChromePackagedApp","app","runtime","hasHistoryApi","pushState","replaceState","States","resolvedSyncPromise","SyncPromise","rejectedSyncPromise","reason","_","__init","_state","PENDING","__init2","_handlers","executor","__init3","__init4","__init5","__init6","_resolve","_reject","onfulfilled","onrejected","_executeHandlers","catch","val","finally","onfinally","isRejected","_setResult","RESOLVED","REJECTED","state","_value","cachedHandlers","dateTimestampSource","nowSeconds","platformPerformance","module","performance","getNodePerformance","timeOrigin","getBrowserPerformance","timestampSource","dateTimestampInSeconds","timestampInSeconds","_browserPerformanceTimeOriginMode","browserPerformanceTimeOrigin","threshold","performanceNow","dateNow","timeOriginDelta","abs","timeOriginIsReliable","navigationStart","timing","navigationStartDelta","parseUrl","query","fragment","relative","isGlobalObj","GLOBAL_OBJ","globalThis","self","getGlobalObject","getGlobalSingleton","creator","__SENTRY__","stylesInDOM","getIndexByIdentifier","identifier","modulesToDom","list","idCountMap","identifiers","count","concat","indexByIdentifier","css","media","sourceMap","supports","layer","references","updater","addElementStyle","byIndex","api","domAPI","update","exports","lastIdentifiers","newList","index","newLastIdentifiers","_i","_index","insert","style","styleTarget","querySelector","HTMLIFrameElement","contentDocument","getTarget","element","setAttributes","attributes","styleElement","nonce","setAttribute","insertStyleElement","needLayer","btoa","unescape","styleTagTransform","removeStyleElement","styleSheet","cssText","firstChild","createTextNode"],"sourceRoot":""}