{"version":3,"file":"components/change-location.dd6a3beacef2e79abc86.js","mappings":"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","sources":["webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/utils-hoist/propagationContext.js","webpack://stdcheck-exposed-wp-theme/./themes/stdcheck-exposed/src/js/components/change-location.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/utils/spanOnScope.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/utils-hoist/time.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/utils-hoist/stacktrace.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/utils-hoist/syncpromise.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/utils-hoist/is.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/utils-hoist/object.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/utils-hoist/debug-build.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/utils-hoist/normalize.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/tracing/spanstatus.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/tracing/dynamicSamplingContext.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/utils-hoist/version.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/utils/parseSampleRate.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/utils-hoist/string.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/asyncContext/stackStrategy.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/defaultScopes.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/asyncContext/index.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/utils-hoist/worldwide.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/exports.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/semanticAttributes.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/utils/hasSpansEnabled.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/utils-hoist/misc.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/scope.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/carrier.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/eventProcessors.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/utils-hoist/debug-ids.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/utils/applyScopeDataToEvent.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/utils/prepareEvent.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/utils-hoist/logger.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/utils/merge.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/utils/spanUtils.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/debug-build.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/constants.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/utils-hoist/browser.js","webpack://stdcheck-exposed-wp-theme/./themes/stdcheck-exposed/src/js/services/storage.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/currentScopes.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/utils-hoist/tracing.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/tracing/utils.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/utils-hoist/baggage.js","webpack://stdcheck-exposed-wp-theme/./node_modules/@sentry/core/build/esm/session.js"],"sourcesContent":["import { uuid4 } from './misc.js';\n\n/**\n * Generate a random, valid trace ID.\n */\nfunction generateTraceId() {\n  return uuid4();\n}\n\n/**\n * Generate a random, valid span ID.\n */\nfunction generateSpanId() {\n  return uuid4().substring(16);\n}\n\nexport { generateSpanId, generateTraceId };\n//# sourceMappingURL=propagationContext.js.map\n","import { StorageService } from '../services/storage';\nimport * as Sentry from '@sentry/browser';\n\nexport function ChangeLocationComponent() {\n  const storageService = new StorageService();\n  const changeLocationComponentElement = document.querySelector('#change-location-component');\n  const changeLocationWordingContainer = document.querySelector('#change-location-wording-container');\n  const changeLocationContentContainer = document.querySelector('#change-location-content-container');\n  let center;\n  let bookingResult;\n\n  /**\n   * Initialize the component\n   */\n  window.addEventListener('load', () => {\n    handleCenterData();\n    handleInHomeCollectionData();\n  });\n\n  /**\n   * Handles the center data.\n   */\n  function handleCenterData() {\n    center = storageService.lab;\n\n    if (!hasCenter()) {\n      return;\n    }\n\n    displayCenter();\n  }\n\n  /**\n   * Display/render the center data.\n   */\n  function displayCenter() {\n    changeLocationWordingContainer.innerHTML = 'You have chosen this location:';\n    changeLocationContentContainer.innerHTML = `${getCenterTitle()} <br />`;\n\n    if (centerSubtitle()) {\n      changeLocationContentContainer.innerHTML += `<span> ${centerSubtitle()}<br /> </span>`;\n    }\n\n    changeLocationContentContainer.innerHTML += `${center.address} <br />`;\n    changeLocationContentContainer.innerHTML += `${center.city}, ${center.state} ${center.zip || center.zip_code}`;\n    changeLocationComponentElement.classList.remove('is-hidden');\n  }\n\n  /**\n   * Display/render the in-home collection data.\n   */\n  function handleInHomeCollectionData() {\n    bookingResult = storageService.inHomeResult;\n\n    if (!hasInHomeCollection()) {\n      return;\n    }\n\n    displayInHomeCollection();\n  }\n\n  /**\n   * Displays the in-home collection data.\n   */\n  function displayInHomeCollection() {\n    changeLocationWordingContainer.innerHTML = 'You selected in-home collection at:';\n    changeLocationContentContainer.innerHTML = `${bookingResult.address.street} <br />`;\n    changeLocationContentContainer.innerHTML += `${bookingResult.address.city}, ${bookingResult.address.state} ${bookingResult.address.zipCode} <br />`;\n    changeLocationContentContainer.innerHTML += bookingDateAndTime();\n    changeLocationComponentElement.classList.remove('is-hidden');\n  }\n\n  /**\n   * Determines if the center or the booking result are defined.\n   */\n  function hasCenterOrBooking() {\n    return hasCenter() || hasInHomeCollection();\n  }\n\n  /**\n   * Determines if the center is defined.\n   */\n  function hasCenter() {\n    return Object.keys(center).length > 0 && !!center.id;\n  }\n\n  /**\n   * Determines if the booking result is defined.\n   */\n  function hasInHomeCollection() {\n    return !!bookingResult;\n  }\n\n  /**\n   * Gets the center subtitle, which could be the center title if the network name is included in it.\n   */\n  function centerSubtitle() {\n    if (!centerNetworkName()) {\n      return null;\n    }\n\n    if (center.title && !isNetworkNameIncludedInCenterTitle()) {\n      return center.title;\n    }\n\n    return null;\n  }\n\n  /**\n   * Gets the center network name, which could be the network attribute if it is a string,\n   * or the network name attribute if not. In case center is undefined, or center.network\n   * is undefined, it could return undefined.\n   */\n  function centerNetworkName() {\n    return typeof center?.network === 'string' ? center?.network : center?.network?.name;\n  }\n\n  /**\n   * Determines if the network name includes the center title.\n   */\n  function isNetworkNameIncludedInCenterTitle() {\n    return !!center?.title?.toLowerCase().includes(centerNetworkName()?.toLowerCase());\n  }\n\n  /**\n   * Gets the center title, which could be the network name if it is included in the center title,\n   */\n  function getCenterTitle() {\n    if (!hasCenterOrBooking()) {\n      return null;\n    }\n\n    let centerTitle = centerNetworkName();\n\n    if (!centerTitle || isNetworkNameIncludedInCenterTitle()) {\n      centerTitle = center.title;\n    }\n\n    /**\n     * At this point, centerTitle could be undefined or an empty string if that's the value\n     * that comes in this.center.title. We add a log in Sentry that tells us that something\n     * might be wrong.\n     */\n    if (!centerTitle) {\n      Sentry.withScope((scope) => {\n        scope.setExtra('lab', JSON.stringify(this.center));\n        Sentry.captureMessage('center has no network name or title');\n      });\n    }\n\n    return centerTitle;\n  }\n\n  /**\n   * Gets the booking date and time.\n   */\n  function bookingDateAndTime() {\n    const dateSegments = bookingResult.date.split('-');\n    return dateSegments[1] + '/' + dateSegments[2] + '/' + dateSegments[0] + ' at ' + bookingResult.bookingSlot.period;\n  }\n}\n\nwindow.changeLocation = new ChangeLocationComponent();\n","import { addNonEnumerableProperty } from '../utils-hoist/object.js';\n\nconst SCOPE_SPAN_FIELD = '_sentrySpan';\n\n/**\n * Set the active span for a given scope.\n * NOTE: This should NOT be used directly, but is only used internally by the trace methods.\n */\nfunction _setSpanForScope(scope, span) {\n  if (span) {\n    addNonEnumerableProperty(scope , SCOPE_SPAN_FIELD, span);\n  } else {\n    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n    delete (scope )[SCOPE_SPAN_FIELD];\n  }\n}\n\n/**\n * Get the active span for a given scope.\n * NOTE: This should NOT be used directly, but is only used internally by the trace methods.\n */\nfunction _getSpanForScope(scope) {\n  return scope[SCOPE_SPAN_FIELD];\n}\n\nexport { _getSpanForScope, _setSpanForScope };\n//# sourceMappingURL=spanOnScope.js.map\n","import { GLOBAL_OBJ } from './worldwide.js';\n\nconst ONE_SECOND_IN_MS = 1000;\n\n/**\n * A partial definition of the [Performance Web API]{@link https://developer.mozilla.org/en-US/docs/Web/API/Performance}\n * for accessing a high-resolution monotonic clock.\n */\n\n/**\n * Returns a timestamp in seconds since the UNIX epoch using the Date API.\n */\nfunction dateTimestampInSeconds() {\n  return Date.now() / ONE_SECOND_IN_MS;\n}\n\n/**\n * Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not\n * support the API.\n *\n * Wrapping the native API works around differences in behavior from different browsers.\n */\nfunction createUnixTimestampInSecondsFunc() {\n  const { performance } = GLOBAL_OBJ ;\n  if (!performance?.now) {\n    return dateTimestampInSeconds;\n  }\n\n  // Some browser and environments don't have a timeOrigin, so we fallback to\n  // using Date.now() to compute the starting time.\n  const approxStartingTimeOrigin = Date.now() - performance.now();\n  const timeOrigin = performance.timeOrigin == undefined ? approxStartingTimeOrigin : performance.timeOrigin;\n\n  // performance.now() is a monotonic clock, which means it starts at 0 when the process begins. To get the current\n  // wall clock time (actual UNIX timestamp), we need to add the starting time origin and the current time elapsed.\n  //\n  // TODO: This does not account for the case where the monotonic clock that powers performance.now() drifts from the\n  // wall clock time, which causes the returned timestamp to be inaccurate. We should investigate how to detect and\n  // correct for this.\n  // See: https://github.com/getsentry/sentry-javascript/issues/2590\n  // See: https://github.com/mdn/content/issues/4713\n  // See: https://dev.to/noamr/when-a-millisecond-is-not-a-millisecond-3h6\n  return () => {\n    return (timeOrigin + performance.now()) / ONE_SECOND_IN_MS;\n  };\n}\n\n/**\n * Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the\n * availability of the Performance API.\n *\n * BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is\n * asleep. This creates a skew between `dateTimestampInSeconds` and `timestampInSeconds`. The\n * skew can grow to arbitrary amounts like days, weeks or months.\n * See https://github.com/getsentry/sentry-javascript/issues/2590.\n */\nconst timestampInSeconds = createUnixTimestampInSecondsFunc();\n\n/**\n * Cached result of getBrowserTimeOrigin.\n */\nlet cachedTimeOrigin;\n\n/**\n * Gets the time origin and the mode used to determine it.\n */\nfunction getBrowserTimeOrigin() {\n  // Unfortunately browsers may report an inaccurate time origin data, through either performance.timeOrigin or\n  // performance.timing.navigationStart, which results in poor results in performance data. We only treat time origin\n  // data as reliable if they are within a reasonable threshold of the current time.\n\n  const { performance } = GLOBAL_OBJ ;\n  if (!performance?.now) {\n    return [undefined, 'none'];\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?.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      return [performance.timeOrigin, 'timeOrigin'];\n    } else {\n      return [navigationStart, 'navigationStart'];\n    }\n  }\n\n  // Either both timeOrigin and navigationStart are skewed or neither is available, fallback to Date.\n  return [dateNow, 'dateNow'];\n}\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 */\nfunction browserPerformanceTimeOrigin() {\n  if (!cachedTimeOrigin) {\n    cachedTimeOrigin = getBrowserTimeOrigin();\n  }\n\n  return cachedTimeOrigin[0];\n}\n\nexport { browserPerformanceTimeOrigin, dateTimestampInSeconds, timestampInSeconds };\n//# sourceMappingURL=time.js.map\n","const STACKTRACE_FRAME_LIMIT = 50;\nconst UNKNOWN_FUNCTION = '?';\n// Used to sanitize webpack (error: *) wrapped stack errors\nconst WEBPACK_ERROR_REGEXP = /\\(error: (.*)\\)/;\nconst STRIP_FRAME_REGEXP = /captureMessage|captureException/;\n\n/**\n * Creates a stack parser with the supplied line parsers\n *\n * StackFrames are returned in the correct order for Sentry Exception\n * frames and with Sentry SDK internal frames removed from the top and bottom\n *\n */\nfunction createStackParser(...parsers) {\n  const sortedParsers = parsers.sort((a, b) => a[0] - b[0]).map(p => p[1]);\n\n  return (stack, skipFirstLines = 0, framesToPop = 0) => {\n    const frames = [];\n    const lines = stack.split('\\n');\n\n    for (let i = skipFirstLines; i < lines.length; i++) {\n      const line = lines[i] ;\n      // Ignore lines over 1kb as they are unlikely to be stack frames.\n      // Many of the regular expressions use backtracking which results in run time that increases exponentially with\n      // input size. Huge strings can result in hangs/Denial of Service:\n      // https://github.com/getsentry/sentry-javascript/issues/2286\n      if (line.length > 1024) {\n        continue;\n      }\n\n      // https://github.com/getsentry/sentry-javascript/issues/5459\n      // Remove webpack (error: *) wrappers\n      const cleanedLine = WEBPACK_ERROR_REGEXP.test(line) ? line.replace(WEBPACK_ERROR_REGEXP, '$1') : line;\n\n      // https://github.com/getsentry/sentry-javascript/issues/7813\n      // Skip Error: lines\n      if (cleanedLine.match(/\\S*Error: /)) {\n        continue;\n      }\n\n      for (const parser of sortedParsers) {\n        const frame = parser(cleanedLine);\n\n        if (frame) {\n          frames.push(frame);\n          break;\n        }\n      }\n\n      if (frames.length >= STACKTRACE_FRAME_LIMIT + framesToPop) {\n        break;\n      }\n    }\n\n    return stripSentryFramesAndReverse(frames.slice(framesToPop));\n  };\n}\n\n/**\n * Gets a stack parser implementation from Options.stackParser\n * @see Options\n *\n * If options contains an array of line parsers, it is converted into a parser\n */\nfunction stackParserFromStackParserOptions(stackParser) {\n  if (Array.isArray(stackParser)) {\n    return createStackParser(...stackParser);\n  }\n  return stackParser;\n}\n\n/**\n * Removes Sentry frames from the top and bottom of the stack if present and enforces a limit of max number of frames.\n * Assumes stack input is ordered from top to bottom and returns the reverse representation so call site of the\n * function that caused the crash is the last frame in the array.\n * @hidden\n */\nfunction stripSentryFramesAndReverse(stack) {\n  if (!stack.length) {\n    return [];\n  }\n\n  const localStack = Array.from(stack);\n\n  // If stack starts with one of our API calls, remove it (starts, meaning it's the top of the stack - aka last call)\n  if (/sentryWrapped/.test(getLastStackFrame(localStack).function || '')) {\n    localStack.pop();\n  }\n\n  // Reversing in the middle of the procedure allows us to just pop the values off the stack\n  localStack.reverse();\n\n  // If stack ends with one of our internal API calls, remove it (ends, meaning it's the bottom of the stack - aka top-most call)\n  if (STRIP_FRAME_REGEXP.test(getLastStackFrame(localStack).function || '')) {\n    localStack.pop();\n\n    // When using synthetic events, we will have a 2 levels deep stack, as `new Error('Sentry syntheticException')`\n    // is produced within the scope itself, making it:\n    //\n    //   Sentry.captureException()\n    //   scope.captureException()\n    //\n    // instead of just the top `Sentry` call itself.\n    // This forces us to possibly strip an additional frame in the exact same was as above.\n    if (STRIP_FRAME_REGEXP.test(getLastStackFrame(localStack).function || '')) {\n      localStack.pop();\n    }\n  }\n\n  return localStack.slice(0, STACKTRACE_FRAME_LIMIT).map(frame => ({\n    ...frame,\n    filename: frame.filename || getLastStackFrame(localStack).filename,\n    function: frame.function || UNKNOWN_FUNCTION,\n  }));\n}\n\nfunction getLastStackFrame(arr) {\n  return arr[arr.length - 1] || {};\n}\n\nconst defaultFunctionName = '<anonymous>';\n\n/**\n * Safely extract function name from itself\n */\nfunction getFunctionName(fn) {\n  try {\n    if (!fn || typeof fn !== 'function') {\n      return defaultFunctionName;\n    }\n    return fn.name || defaultFunctionName;\n  } catch (e) {\n    // Just accessing custom props in some Selenium environments\n    // can cause a \"Permission denied\" exception (see raven-js#495).\n    return defaultFunctionName;\n  }\n}\n\n/**\n * Get's stack frames from an event without needing to check for undefined properties.\n */\nfunction getFramesFromEvent(event) {\n  const exception = event.exception;\n\n  if (exception) {\n    const frames = [];\n    try {\n      // @ts-expect-error Object could be undefined\n      exception.values.forEach(value => {\n        // @ts-expect-error Value could be undefined\n        if (value.stacktrace.frames) {\n          // @ts-expect-error Value could be undefined\n          frames.push(...value.stacktrace.frames);\n        }\n      });\n      return frames;\n    } catch (_oO) {\n      return undefined;\n    }\n  }\n  return undefined;\n}\n\nexport { UNKNOWN_FUNCTION, createStackParser, getFramesFromEvent, getFunctionName, stackParserFromStackParserOptions, stripSentryFramesAndReverse };\n//# sourceMappingURL=stacktrace.js.map\n","import { isThenable } from './is.js';\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\n/** SyncPromise internal states */\nvar States; (function (States) {\n  /** Pending */\n  const PENDING = 0; States[States[\"PENDING\"] = PENDING] = \"PENDING\";\n  /** Resolved / OK */\n  const RESOLVED = 1; States[States[\"RESOLVED\"] = RESOLVED] = \"RESOLVED\";\n  /** Rejected / Error */\n  const REJECTED = 2; States[States[\"REJECTED\"] = REJECTED] = \"REJECTED\";\n})(States || (States = {}));\n\n// Overloads so we can call resolvedSyncPromise without arguments and generic argument\n\n/**\n * Creates a resolved sync promise.\n *\n * @param value the value to resolve the promise with\n * @returns the resolved sync promise\n */\nfunction resolvedSyncPromise(value) {\n  return new SyncPromise(resolve => {\n    resolve(value);\n  });\n}\n\n/**\n * Creates a rejected sync promise.\n *\n * @param value the value to reject the promise with\n * @returns the rejected sync promise\n */\nfunction rejectedSyncPromise(reason) {\n  return new SyncPromise((_, reject) => {\n    reject(reason);\n  });\n}\n\n/**\n * Thenable class that behaves like a Promise and follows it's interface\n * but is not async internally\n */\nclass SyncPromise {\n\n   constructor(executor) {\n    this._state = States.PENDING;\n    this._handlers = [];\n\n    this._runExecutor(executor);\n  }\n\n  /** @inheritdoc */\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  /** @inheritdoc */\n   catch(\n    onrejected,\n  ) {\n    return this.then(val => val, onrejected);\n  }\n\n  /** @inheritdoc */\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  /** Excute the resolve/reject handlers. */\n   _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        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  /** Run the executor for the SyncPromise. */\n   _runExecutor(executor) {\n    const setResult = (state, value) => {\n      if (this._state !== States.PENDING) {\n        return;\n      }\n\n      if (isThenable(value)) {\n        void (value ).then(resolve, reject);\n        return;\n      }\n\n      this._state = state;\n      this._value = value;\n\n      this._executeHandlers();\n    };\n\n    const resolve = (value) => {\n      setResult(States.RESOLVED, value);\n    };\n\n    const reject = (reason) => {\n      setResult(States.REJECTED, reason);\n    };\n\n    try {\n      executor(resolve, reject);\n    } catch (e) {\n      reject(e);\n    }\n  }\n}\n\nexport { SyncPromise, rejectedSyncPromise, resolvedSyncPromise };\n//# sourceMappingURL=syncpromise.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    case '[object WebAssembly.Exception]':\n      return true;\n    default:\n      return isInstanceOf(wat, Error);\n  }\n}\n/**\n * Checks whether given value is an instance of the given built-in class.\n *\n * @param wat The value to be checked\n * @param className\n * @returns A boolean representing the result.\n */\nfunction isBuiltin(wat, className) {\n  return objectToString.call(wat) === `[object ${className}]`;\n}\n\n/**\n * Checks whether given value's type is ErrorEvent\n * {@link isErrorEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isErrorEvent(wat) {\n  return isBuiltin(wat, 'ErrorEvent');\n}\n\n/**\n * Checks whether given value's type is DOMError\n * {@link isDOMError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isDOMError(wat) {\n  return isBuiltin(wat, 'DOMError');\n}\n\n/**\n * Checks whether given value's type is DOMException\n * {@link isDOMException}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isDOMException(wat) {\n  return isBuiltin(wat, 'DOMException');\n}\n\n/**\n * Checks whether given value's type is a string\n * {@link isString}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isString(wat) {\n  return isBuiltin(wat, 'String');\n}\n\n/**\n * Checks whether given string is parameterized\n * {@link isParameterizedString}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isParameterizedString(wat) {\n  return (\n    typeof wat === 'object' &&\n    wat !== null &&\n    '__sentry_template_string__' in wat &&\n    '__sentry_template_values__' in wat\n  );\n}\n\n/**\n * Checks whether given value is a primitive (undefined, null, number, boolean, string, bigint, symbol)\n * {@link isPrimitive}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isPrimitive(wat) {\n  return wat === null || isParameterizedString(wat) || (typeof wat !== 'object' && typeof wat !== 'function');\n}\n\n/**\n * Checks whether given value's type is an object literal, or a class instance.\n * {@link isPlainObject}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isPlainObject(wat) {\n  return isBuiltin(wat, 'Object');\n}\n\n/**\n * Checks whether given value's type is an Event instance\n * {@link isEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isEvent(wat) {\n  return typeof Event !== 'undefined' && isInstanceOf(wat, Event);\n}\n\n/**\n * Checks whether given value's type is an Element instance\n * {@link isElement}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isElement(wat) {\n  return typeof Element !== 'undefined' && isInstanceOf(wat, Element);\n}\n\n/**\n * Checks whether given value's type is an regexp\n * {@link isRegExp}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isRegExp(wat) {\n  return isBuiltin(wat, 'RegExp');\n}\n\n/**\n * Checks whether given value has a then function.\n * @param wat A value to be checked.\n */\nfunction isThenable(wat) {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  return Boolean(wat?.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's type is an instance of provided constructor.\n * {@link isInstanceOf}.\n *\n * @param wat A value to be checked.\n * @param base A constructor to be used in a check.\n * @returns A boolean representing the result.\n */\nfunction isInstanceOf(wat, base) {\n  try {\n    return wat instanceof base;\n  } catch (_e) {\n    return false;\n  }\n}\n\n/**\n * Checks whether given value's type is a Vue ViewModel.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isVueViewModel(wat) {\n  // Not using Object.prototype.toString because in Vue 3 it would read the instance's Symbol(Symbol.toStringTag) property.\n  return !!(typeof wat === 'object' && wat !== null && ((wat ).__isVue || (wat )._isVue));\n}\n\nexport { isDOMError, isDOMException, isElement, isError, isErrorEvent, isEvent, isInstanceOf, isParameterizedString, isPlainObject, isPrimitive, isRegExp, isString, isSyntheticEvent, isThenable, isVueViewModel };\n//# sourceMappingURL=is.js.map\n","import { htmlTreeAsString } from './browser.js';\nimport { DEBUG_BUILD } from './debug-build.js';\nimport { isError, isEvent, isInstanceOf, isPrimitive, isElement } from './is.js';\nimport { logger } from './logger.js';\nimport { truncate } from './string.js';\n\n/**\n * Replace a method in an object with a wrapped version of itself.\n *\n * If the method on the passed object is not a function, the wrapper will not be applied.\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  // explicitly casting to unknown because we don't know the type of the method initially at all\n  const original = source[name] ;\n\n  if (typeof original !== 'function') {\n    return;\n  }\n\n  const wrapped = replacementFactory(original) ;\n\n  // Make sure it's a function first, as we need to attach an empty prototype for `defineProperties` to work\n  // otherwise it'll throw \"TypeError: Object.defineProperties called on non-object\"\n  if (typeof wrapped === 'function') {\n    markFunctionWrapped(wrapped, original);\n  }\n\n  try {\n    source[name] = wrapped;\n  } catch {\n    DEBUG_BUILD && logger.log(`Failed to replace method \"${name}\" in object`, source);\n  }\n}\n\n/**\n * Defines a non-enumerable property on the given object.\n *\n * @param obj The object on which to set the property\n * @param name The name of the property to be set\n * @param value The value to which to set the property\n */\nfunction addNonEnumerableProperty(obj, name, value) {\n  try {\n    Object.defineProperty(obj, name, {\n      // enumerable: false, // the default, so we can save on bundle size by not explicitly setting it\n      value: value,\n      writable: true,\n      configurable: true,\n    });\n  } catch (o_O) {\n    DEBUG_BUILD && logger.log(`Failed to add non-enumerable property \"${name}\" to object`, obj);\n  }\n}\n\n/**\n * Remembers the original function on the wrapped function and\n * patches up the prototype.\n *\n * @param wrapped the wrapper function\n * @param original the original function that gets wrapped\n */\nfunction markFunctionWrapped(wrapped, original) {\n  try {\n    const proto = original.prototype || {};\n    wrapped.prototype = original.prototype = proto;\n    addNonEnumerableProperty(wrapped, '__sentry_original__', original);\n  } catch (o_O) {} // eslint-disable-line no-empty\n}\n\n/**\n * This extracts the original function if available.  See\n * `markFunctionWrapped` for more information.\n *\n * @param func the function to unwrap\n * @returns the unwrapped version of the function if available.\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nfunction getOriginalFunction(func) {\n  return func.__sentry_original__;\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 argument 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  const firstKey = keys[0];\n\n  if (!firstKey) {\n    return '[object has no keys]';\n  }\n\n  if (firstKey.length >= maxLength) {\n    return truncate(firstKey, 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  // Early return for primitive values\n  if (inputValue === null || typeof inputValue !== 'object') {\n    return inputValue;\n  }\n\n  // Check memo map first for all object types\n  const memoVal = memoizationMap.get(inputValue);\n  if (memoVal !== undefined) {\n    return memoVal ;\n  }\n\n  // handle arrays\n  if (Array.isArray(inputValue)) {\n    const returnValue = [];\n    // Store mapping to handle circular references\n    memoizationMap.set(inputValue, returnValue);\n\n    inputValue.forEach(value => {\n      returnValue.push(_dropUndefinedKeys(value, memoizationMap));\n    });\n\n    return returnValue ;\n  }\n\n  if (isPojo(inputValue)) {\n    const returnValue = {};\n    // Store mapping to handle circular references\n    memoizationMap.set(inputValue, returnValue);\n\n    const keys = Object.keys(inputValue);\n\n    keys.forEach(key => {\n      const val = inputValue[key];\n      if (val !== undefined) {\n        returnValue[key] = _dropUndefinedKeys(val, memoizationMap);\n      }\n    });\n\n    return returnValue ;\n  }\n\n  // For other object types, return as is\n  return inputValue;\n}\n\nfunction isPojo(input) {\n  // Plain objects have Object as constructor or no constructor\n  const constructor = (input ).constructor;\n  return constructor === Object || constructor === undefined;\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    // this will catch both undefined and null\n    case wat == undefined:\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 };\n//# sourceMappingURL=object.js.map\n","/**\n * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.\n *\n * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.\n */\nconst DEBUG_BUILD = (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__);\n\nexport { DEBUG_BUILD };\n//# sourceMappingURL=debug-build.js.map\n","import { isVueViewModel, isSyntheticEvent } from './is.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 normalized output.\n * @returns A normalized version of the object, or `\"**non-serializable**\"` if any errors are thrown during normalization.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction normalize(input, depth = 100, maxProperties = +Infinity) {\n  try {\n    // since we're at the outermost level, we don't provide a key\n    return visit('', input, depth, maxProperties);\n  } catch (err) {\n    return { ERROR: `**non-serializable** (${err})` };\n  }\n}\n\n/** JSDoc */\nfunction normalizeToSize(\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  object,\n  // Default Node.js REPL depth\n  depth = 3,\n  // 100kB, as 200kB is max payload size, so half sounds reasonable\n  maxSize = 100 * 1024,\n) {\n  const normalized = normalize(object, depth);\n\n  if (jsonSize(normalized) > maxSize) {\n    return normalizeToSize(object, depth - 1, maxSize);\n  }\n\n  return normalized ;\n}\n\n/**\n * Visits a node to perform normalization on it\n *\n * @param key The key corresponding to the given node\n * @param value The node to be visited\n * @param depth Optional number indicating the maximum recursion depth\n * @param maxProperties Optional maximum number of properties/elements included in any single object/array\n * @param memo Optional Memo class handling decycling\n */\nfunction visit(\n  key,\n  value,\n  depth = +Infinity,\n  maxProperties = +Infinity,\n  memo = memoBuilder(),\n) {\n  const [memoize, unmemoize] = memo;\n\n  // Get the simple cases out of the way first\n  if (\n    value == null || // this matches null and undefined -> eqeq not eqeqeq\n    ['boolean', 'string'].includes(typeof value) ||\n    (typeof value === 'number' && Number.isFinite(value))\n  ) {\n    return value ;\n  }\n\n  const stringified = stringifyValue(key, value);\n\n  // Anything we could potentially dig into more (objects or arrays) will have come back as `\"[object XXXX]\"`.\n  // Everything else will have already been serialized, so if we don't see that pattern, we're done.\n  if (!stringified.startsWith('[object ')) {\n    return stringified;\n  }\n\n  // From here on, we can assert that `value` is either an object or an array.\n\n  // Do not normalize objects that we know have already been normalized. As a general rule, the\n  // \"__sentry_skip_normalization__\" property should only be used sparingly and only should only be set on objects that\n  // have already been normalized.\n  if ((value )['__sentry_skip_normalization__']) {\n    return value ;\n  }\n\n  // We can set `__sentry_override_normalization_depth__` on an object to ensure that from there\n  // We keep a certain amount of depth.\n  // This should be used sparingly, e.g. we use it for the redux integration to ensure we get a certain amount of state.\n  const remainingDepth =\n    typeof (value )['__sentry_override_normalization_depth__'] === 'number'\n      ? ((value )['__sentry_override_normalization_depth__'] )\n      : depth;\n\n  // We're also done if we've reached the max depth\n  if (remainingDepth === 0) {\n    // At this point we know `serialized` is a string of the form `\"[object XXXX]\"`. Clean it up so it's just `\"[XXXX]\"`.\n    return stringified.replace('object ', '');\n  }\n\n  // If we've already visited this branch, bail out, as it's circular reference. If not, note that we're seeing it now.\n  if (memoize(value)) {\n    return '[Circular ~]';\n  }\n\n  // If the value has a `toJSON` method, we call it to extract more information\n  const valueWithToJSON = value ;\n  if (valueWithToJSON && typeof valueWithToJSON.toJSON === 'function') {\n    try {\n      const jsonValue = valueWithToJSON.toJSON();\n      // We need to normalize the return value of `.toJSON()` in case it has circular references\n      return visit('', jsonValue, remainingDepth - 1, maxProperties, memo);\n    } catch (err) {\n      // pass (The built-in `toJSON` failed, but we can still try to do it ourselves)\n    }\n  }\n\n  // At this point we know we either have an object or an array, we haven't seen it before, and we're going to recurse\n  // because we haven't yet reached the max depth. Create an accumulator to hold the results of visiting each\n  // property/entry, and keep track of the number of items we add to it.\n  const normalized = (Array.isArray(value) ? [] : {}) ;\n  let numAdded = 0;\n\n  // Before we begin, convert`Error` and`Event` instances into plain objects, since some of each of their relevant\n  // properties are non-enumerable and otherwise would get missed.\n  const visitable = convertToPlainObject(value );\n\n  for (const visitKey in visitable) {\n    // Avoid iterating over fields in the prototype if they've somehow been exposed to enumeration.\n    if (!Object.prototype.hasOwnProperty.call(visitable, visitKey)) {\n      continue;\n    }\n\n    if (numAdded >= maxProperties) {\n      normalized[visitKey] = '[MaxProperties ~]';\n      break;\n    }\n\n    // Recursively visit all the child nodes\n    const visitValue = visitable[visitKey];\n    normalized[visitKey] = visit(visitKey, visitValue, remainingDepth - 1, maxProperties, memo);\n\n    numAdded++;\n  }\n\n  // Once we've visited all the branches, remove the parent from memo storage\n  unmemoize(value);\n\n  // Return accumulated values\n  return normalized;\n}\n\n/* eslint-disable complexity */\n/**\n * Stringify the given value. Handles various known special values and types.\n *\n * Not meant to be used on simple primitives which already have a string representation, as it will, for example, turn\n * the number 1231 into \"[Object Number]\", nor on `null`, as it will throw.\n *\n * @param value The value to stringify\n * @returns A stringified representation of the given value\n */\nfunction stringifyValue(\n  key,\n  // this type is a tiny bit of a cheat, since this function does handle NaN (which is technically a number), but for\n  // our internal use, it'll do\n  value,\n) {\n  try {\n    if (key === 'domain' && value && typeof value === 'object' && (value )._events) {\n      return '[Domain]';\n    }\n\n    if (key === 'domainEmitter') {\n      return '[DomainEmitter]';\n    }\n\n    // It's safe to use `global`, `window`, and `document` here in this manner, as we are asserting using `typeof` first\n    // which won't throw if they are not present.\n\n    if (typeof global !== 'undefined' && value === global) {\n      return '[Global]';\n    }\n\n    // eslint-disable-next-line no-restricted-globals\n    if (typeof window !== 'undefined' && value === window) {\n      return '[Window]';\n    }\n\n    // eslint-disable-next-line no-restricted-globals\n    if (typeof document !== 'undefined' && value === document) {\n      return '[Document]';\n    }\n\n    if (isVueViewModel(value)) {\n      return '[VueViewModel]';\n    }\n\n    // React's SyntheticEvent thingy\n    if (isSyntheticEvent(value)) {\n      return '[SyntheticEvent]';\n    }\n\n    if (typeof value === 'number' && !Number.isFinite(value)) {\n      return `[${value}]`;\n    }\n\n    if (typeof value === 'function') {\n      return `[Function: ${getFunctionName(value)}]`;\n    }\n\n    if (typeof value === 'symbol') {\n      return `[${String(value)}]`;\n    }\n\n    // stringified BigInts are indistinguishable from regular numbers, so we need to label them to avoid confusion\n    if (typeof value === 'bigint') {\n      return `[BigInt: ${String(value)}]`;\n    }\n\n    // Now that we've knocked out all the special cases and the primitives, all we have left are objects. Simply casting\n    // them to strings means that instances of classes which haven't defined their `toStringTag` will just come out as\n    // `\"[object Object]\"`. If we instead look at the constructor's name (which is the same as the name of the class),\n    // we can make sure that only plain objects come out that way.\n    const objName = getConstructorName(value);\n\n    // Handle HTML Elements\n    if (/^HTML(\\w*)Element$/.test(objName)) {\n      return `[HTMLElement: ${objName}]`;\n    }\n\n    return `[object ${objName}]`;\n  } catch (err) {\n    return `**non-serializable** (${err})`;\n  }\n}\n/* eslint-enable complexity */\n\nfunction getConstructorName(value) {\n  const prototype = Object.getPrototypeOf(value);\n\n  return prototype?.constructor ? prototype.constructor.name : 'null prototype';\n}\n\n/** Calculates bytes size of input string */\nfunction utf8Length(value) {\n  // eslint-disable-next-line no-bitwise\n  return ~-encodeURI(value).split(/%..|./).length;\n}\n\n/** Calculates bytes size of input object */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction jsonSize(value) {\n  return utf8Length(JSON.stringify(value));\n}\n\n/**\n * Normalizes URLs in exceptions and stacktraces to a base path so Sentry can fingerprint\n * across platforms and working directory.\n *\n * @param url The URL to be normalized.\n * @param basePath The application base path.\n * @returns The normalized URL.\n */\nfunction normalizeUrlToBase(url, basePath) {\n  const escapedBase = basePath\n    // Backslash to forward\n    .replace(/\\\\/g, '/')\n    // Escape RegExp special characters\n    .replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&');\n\n  let newUrl = url;\n  try {\n    newUrl = decodeURI(url);\n  } catch (_Oo) {\n    // Sometime this breaks\n  }\n  return (\n    newUrl\n      .replace(/\\\\/g, '/')\n      .replace(/webpack:\\/?/g, '') // Remove intermediate base path\n      // eslint-disable-next-line @sentry-internal/sdk/no-regexp-constructor\n      .replace(new RegExp(`(file://)?/*${escapedBase}/*`, 'ig'), 'app:///')\n  );\n}\n\n/**\n * Helper to decycle json objects\n */\nfunction memoBuilder() {\n  const inner = new WeakSet();\n  function memoize(obj) {\n    if (inner.has(obj)) {\n      return true;\n    }\n    inner.add(obj);\n    return false;\n  }\n\n  function unmemoize(obj) {\n    inner.delete(obj);\n  }\n  return [memoize, unmemoize];\n}\n\nexport { normalize, normalizeToSize, normalizeUrlToBase };\n//# sourceMappingURL=normalize.js.map\n","const SPAN_STATUS_UNSET = 0;\nconst SPAN_STATUS_OK = 1;\nconst SPAN_STATUS_ERROR = 2;\n\n/**\n * Converts a HTTP status code into a sentry status with a message.\n *\n * @param httpStatus The HTTP response status code.\n * @returns The span status or unknown_error.\n */\n// https://develop.sentry.dev/sdk/event-payloads/span/\nfunction getSpanStatusFromHttpCode(httpStatus) {\n  if (httpStatus < 400 && httpStatus >= 100) {\n    return { code: SPAN_STATUS_OK };\n  }\n\n  if (httpStatus >= 400 && httpStatus < 500) {\n    switch (httpStatus) {\n      case 401:\n        return { code: SPAN_STATUS_ERROR, message: 'unauthenticated' };\n      case 403:\n        return { code: SPAN_STATUS_ERROR, message: 'permission_denied' };\n      case 404:\n        return { code: SPAN_STATUS_ERROR, message: 'not_found' };\n      case 409:\n        return { code: SPAN_STATUS_ERROR, message: 'already_exists' };\n      case 413:\n        return { code: SPAN_STATUS_ERROR, message: 'failed_precondition' };\n      case 429:\n        return { code: SPAN_STATUS_ERROR, message: 'resource_exhausted' };\n      case 499:\n        return { code: SPAN_STATUS_ERROR, message: 'cancelled' };\n      default:\n        return { code: SPAN_STATUS_ERROR, message: 'invalid_argument' };\n    }\n  }\n\n  if (httpStatus >= 500 && httpStatus < 600) {\n    switch (httpStatus) {\n      case 501:\n        return { code: SPAN_STATUS_ERROR, message: 'unimplemented' };\n      case 503:\n        return { code: SPAN_STATUS_ERROR, message: 'unavailable' };\n      case 504:\n        return { code: SPAN_STATUS_ERROR, message: 'deadline_exceeded' };\n      default:\n        return { code: SPAN_STATUS_ERROR, message: 'internal_error' };\n    }\n  }\n\n  return { code: SPAN_STATUS_ERROR, message: 'unknown_error' };\n}\n\n/**\n * Sets the Http status attributes on the current span based on the http code.\n * Additionally, the span's status is updated, depending on the http code.\n */\nfunction setHttpStatus(span, httpStatus) {\n  span.setAttribute('http.response.status_code', httpStatus);\n\n  const spanStatus = getSpanStatusFromHttpCode(httpStatus);\n  if (spanStatus.message !== 'unknown_error') {\n    span.setStatus(spanStatus);\n  }\n}\n\nexport { SPAN_STATUS_ERROR, SPAN_STATUS_OK, SPAN_STATUS_UNSET, getSpanStatusFromHttpCode, setHttpStatus };\n//# sourceMappingURL=spanstatus.js.map\n","import { DEFAULT_ENVIRONMENT } from '../constants.js';\nimport { getClient } from '../currentScopes.js';\nimport { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from '../semanticAttributes.js';\nimport { baggageHeaderToDynamicSamplingContext, dynamicSamplingContextToSentryBaggageHeader } from '../utils-hoist/baggage.js';\nimport { dropUndefinedKeys, addNonEnumerableProperty } from '../utils-hoist/object.js';\nimport { hasSpansEnabled } from '../utils/hasSpansEnabled.js';\nimport { getRootSpan, spanToJSON, spanIsSampled } from '../utils/spanUtils.js';\nimport { getCapturedScopesOnSpan } from './utils.js';\n\n/**\n * If you change this value, also update the terser plugin config to\n * avoid minification of the object property!\n */\nconst FROZEN_DSC_FIELD = '_frozenDsc';\n\n/**\n * Freeze the given DSC on the given span.\n */\nfunction freezeDscOnSpan(span, dsc) {\n  const spanWithMaybeDsc = span ;\n  addNonEnumerableProperty(spanWithMaybeDsc, FROZEN_DSC_FIELD, dsc);\n}\n\n/**\n * Creates a dynamic sampling context from a client.\n *\n * Dispatches the `createDsc` lifecycle hook as a side effect.\n */\nfunction getDynamicSamplingContextFromClient(trace_id, client) {\n  const options = client.getOptions();\n\n  const { publicKey: public_key } = client.getDsn() || {};\n\n  const dsc = dropUndefinedKeys({\n    environment: options.environment || DEFAULT_ENVIRONMENT,\n    release: options.release,\n    public_key,\n    trace_id,\n  }) ;\n\n  client.emit('createDsc', dsc);\n\n  return dsc;\n}\n\n/**\n * Get the dynamic sampling context for the currently active scopes.\n */\nfunction getDynamicSamplingContextFromScope(client, scope) {\n  const propagationContext = scope.getPropagationContext();\n  return propagationContext.dsc || getDynamicSamplingContextFromClient(propagationContext.traceId, client);\n}\n\n/**\n * Creates a dynamic sampling context from a span (and client and scope)\n *\n * @param span the span from which a few values like the root span name and sample rate are extracted.\n *\n * @returns a dynamic sampling context\n */\nfunction getDynamicSamplingContextFromSpan(span) {\n  const client = getClient();\n  if (!client) {\n    return {};\n  }\n\n  const rootSpan = getRootSpan(span);\n  const rootSpanJson = spanToJSON(rootSpan);\n  const rootSpanAttributes = rootSpanJson.data;\n  const traceState = rootSpan.spanContext().traceState;\n\n  // The span sample rate that was locally applied to the root span should also always be applied to the DSC, even if the DSC is frozen.\n  // This is so that the downstream traces/services can use parentSampleRate in their `tracesSampler` to make consistent sampling decisions across the entire trace.\n  const rootSpanSampleRate =\n    traceState?.get('sentry.sample_rate') ?? rootSpanAttributes[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE];\n  function applyLocalSampleRateToDsc(dsc) {\n    if (typeof rootSpanSampleRate === 'number' || typeof rootSpanSampleRate === 'string') {\n      dsc.sample_rate = `${rootSpanSampleRate}`;\n    }\n    return dsc;\n  }\n\n  // For core implementation, we freeze the DSC onto the span as a non-enumerable property\n  const frozenDsc = (rootSpan )[FROZEN_DSC_FIELD];\n  if (frozenDsc) {\n    return applyLocalSampleRateToDsc(frozenDsc);\n  }\n\n  // For OpenTelemetry, we freeze the DSC on the trace state\n  const traceStateDsc = traceState?.get('sentry.dsc');\n\n  // If the span has a DSC, we want it to take precedence\n  const dscOnTraceState = traceStateDsc && baggageHeaderToDynamicSamplingContext(traceStateDsc);\n\n  if (dscOnTraceState) {\n    return applyLocalSampleRateToDsc(dscOnTraceState);\n  }\n\n  // Else, we generate it from the span\n  const dsc = getDynamicSamplingContextFromClient(span.spanContext().traceId, client);\n\n  // We don't want to have a transaction name in the DSC if the source is \"url\" because URLs might contain PII\n  const source = rootSpanAttributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE];\n\n  // after JSON conversion, txn.name becomes jsonSpan.description\n  const name = rootSpanJson.description;\n  if (source !== 'url' && name) {\n    dsc.transaction = name;\n  }\n\n  // How can we even land here with hasSpansEnabled() returning false?\n  // Otel creates a Non-recording span in Tracing Without Performance mode when handling incoming requests\n  // So we end up with an active span that is not sampled (neither positively nor negatively)\n  if (hasSpansEnabled()) {\n    dsc.sampled = String(spanIsSampled(rootSpan));\n    dsc.sample_rand =\n      // In OTEL we store the sample rand on the trace state because we cannot access scopes for NonRecordingSpans\n      // The Sentry OTEL SpanSampler takes care of writing the sample rand on the root span\n      traceState?.get('sentry.sample_rand') ??\n      // On all other platforms we can actually get the scopes from a root span (we use this as a fallback)\n      getCapturedScopesOnSpan(rootSpan).scope?.getPropagationContext().sampleRand.toString();\n  }\n\n  applyLocalSampleRateToDsc(dsc);\n\n  client.emit('createDsc', dsc, rootSpan);\n\n  return dsc;\n}\n\n/**\n * Convert a Span to a baggage header.\n */\nfunction spanToBaggageHeader(span) {\n  const dsc = getDynamicSamplingContextFromSpan(span);\n  return dynamicSamplingContextToSentryBaggageHeader(dsc);\n}\n\nexport { freezeDscOnSpan, getDynamicSamplingContextFromClient, getDynamicSamplingContextFromScope, getDynamicSamplingContextFromSpan, spanToBaggageHeader };\n//# sourceMappingURL=dynamicSamplingContext.js.map\n","// This is a magic string replaced by rollup\n\nconst SDK_VERSION = \"9.9.0\" ;\n\nexport { SDK_VERSION };\n//# sourceMappingURL=version.js.map\n","/**\n * Parse a sample rate from a given value.\n * This will either return a boolean or number sample rate, if the sample rate is valid (between 0 and 1).\n * If a string is passed, we try to convert it to a number.\n *\n * Any invalid sample rate will return `undefined`.\n */\nfunction parseSampleRate(sampleRate) {\n  if (typeof sampleRate === 'boolean') {\n    return Number(sampleRate);\n  }\n\n  const rate = typeof sampleRate === 'string' ? parseFloat(sampleRate) : sampleRate;\n  if (typeof rate !== 'number' || isNaN(rate) || rate < 0 || rate > 1) {\n    return undefined;\n  }\n\n  return rate;\n}\n\nexport { parseSampleRate };\n//# sourceMappingURL=parseSampleRate.js.map\n","import { isString, isRegExp, isVueViewModel } 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 */\nfunction safeJoin(input, delimiter) {\n  if (!Array.isArray(input)) {\n    return '';\n  }\n\n  const output = [];\n  // eslint-disable-next-line @typescript-eslint/prefer-for-of\n  for (let i = 0; i < input.length; i++) {\n    const value = input[i];\n    try {\n      // This is a hack to fix a Vue3-specific bug that causes an infinite loop of\n      // console warnings. This happens when a Vue template is rendered with\n      // an undeclared variable, which we try to stringify, ultimately causing\n      // Vue to issue another warning which repeats indefinitely.\n      // see: https://github.com/getsentry/sentry-javascript/pull/8981\n      if (isVueViewModel(value)) {\n        output.push('[VueViewModel]');\n      } else {\n        output.push(String(value));\n      }\n    } catch (e) {\n      output.push('[value cannot be serialized]');\n    }\n  }\n\n  return output.join(delimiter);\n}\n\n/**\n * Checks if the given value matches a regex or string\n *\n * @param value The string to test\n * @param pattern Either a regex or a string against which `value` will be matched\n * @param requireExactStringMatch If true, `value` must match `pattern` exactly. If false, `value` will match\n * `pattern` if it contains `pattern`. Only applies to string-type patterns.\n */\nfunction isMatchingPattern(\n  value,\n  pattern,\n  requireExactStringMatch = false,\n) {\n  if (!isString(value)) {\n    return false;\n  }\n\n  if (isRegExp(pattern)) {\n    return pattern.test(value);\n  }\n  if (isString(pattern)) {\n    return requireExactStringMatch ? value === pattern : value.includes(pattern);\n  }\n\n  return false;\n}\n\n/**\n * Test the given string against an array of strings and regexes. By default, string matching is done on a\n * substring-inclusion basis rather than a strict equality basis\n *\n * @param testString The string to test\n * @param patterns The patterns against which to test the string\n * @param requireExactStringMatch If true, `testString` must match one of the given string patterns exactly in order to\n * count. If false, `testString` will match a string pattern if it contains that pattern.\n * @returns\n */\nfunction stringMatchesSomePattern(\n  testString,\n  patterns = [],\n  requireExactStringMatch = false,\n) {\n  return patterns.some(pattern => isMatchingPattern(testString, pattern, requireExactStringMatch));\n}\n\nexport { isMatchingPattern, safeJoin, snipLine, stringMatchesSomePattern, truncate };\n//# sourceMappingURL=string.js.map\n","import { getDefaultCurrentScope, getDefaultIsolationScope } from '../defaultScopes.js';\nimport { Scope } from '../scope.js';\nimport { isThenable } from '../utils-hoist/is.js';\nimport { getMainCarrier, getSentryCarrier } from '../carrier.js';\n\n/**\n * This is an object that holds a stack of scopes.\n */\nclass AsyncContextStack {\n\n   constructor(scope, isolationScope) {\n    let assignedScope;\n    if (!scope) {\n      assignedScope = new Scope();\n    } else {\n      assignedScope = scope;\n    }\n\n    let assignedIsolationScope;\n    if (!isolationScope) {\n      assignedIsolationScope = new Scope();\n    } else {\n      assignedIsolationScope = isolationScope;\n    }\n\n    // scope stack for domains or the process\n    this._stack = [{ scope: assignedScope }];\n    this._isolationScope = assignedIsolationScope;\n  }\n\n  /**\n   * Fork a scope for the stack.\n   */\n   withScope(callback) {\n    const scope = this._pushScope();\n\n    let maybePromiseResult;\n    try {\n      maybePromiseResult = callback(scope);\n    } catch (e) {\n      this._popScope();\n      throw e;\n    }\n\n    if (isThenable(maybePromiseResult)) {\n      // @ts-expect-error - isThenable returns the wrong type\n      return maybePromiseResult.then(\n        res => {\n          this._popScope();\n          return res;\n        },\n        e => {\n          this._popScope();\n          throw e;\n        },\n      );\n    }\n\n    this._popScope();\n    return maybePromiseResult;\n  }\n\n  /**\n   * Get the client of the stack.\n   */\n   getClient() {\n    return this.getStackTop().client ;\n  }\n\n  /**\n   * Returns the scope of the top stack.\n   */\n   getScope() {\n    return this.getStackTop().scope;\n  }\n\n  /**\n   * Get the isolation scope for the stack.\n   */\n   getIsolationScope() {\n    return this._isolationScope;\n  }\n\n  /**\n   * Returns the topmost scope layer in the order domain > local > process.\n   */\n   getStackTop() {\n    return this._stack[this._stack.length - 1] ;\n  }\n\n  /**\n   * Push a scope to the stack.\n   */\n   _pushScope() {\n    // We want to clone the content of prev scope\n    const scope = this.getScope().clone();\n    this._stack.push({\n      client: this.getClient(),\n      scope,\n    });\n    return scope;\n  }\n\n  /**\n   * Pop a scope from the stack.\n   */\n   _popScope() {\n    if (this._stack.length <= 1) return false;\n    return !!this._stack.pop();\n  }\n}\n\n/**\n * Get the global async context stack.\n * This will be removed during the v8 cycle and is only here to make migration easier.\n */\nfunction getAsyncContextStack() {\n  const registry = getMainCarrier();\n  const sentry = getSentryCarrier(registry);\n\n  return (sentry.stack = sentry.stack || new AsyncContextStack(getDefaultCurrentScope(), getDefaultIsolationScope()));\n}\n\nfunction withScope(callback) {\n  return getAsyncContextStack().withScope(callback);\n}\n\nfunction withSetScope(scope, callback) {\n  const stack = getAsyncContextStack() ;\n  return stack.withScope(() => {\n    stack.getStackTop().scope = scope;\n    return callback(scope);\n  });\n}\n\nfunction withIsolationScope(callback) {\n  return getAsyncContextStack().withScope(() => {\n    return callback(getAsyncContextStack().getIsolationScope());\n  });\n}\n\n/**\n * Get the stack-based async context strategy.\n */\nfunction getStackAsyncContextStrategy() {\n  return {\n    withIsolationScope,\n    withScope,\n    withSetScope,\n    withSetIsolationScope: (_isolationScope, callback) => {\n      return withIsolationScope(callback);\n    },\n    getCurrentScope: () => getAsyncContextStack().getScope(),\n    getIsolationScope: () => getAsyncContextStack().getIsolationScope(),\n  };\n}\n\nexport { AsyncContextStack, getStackAsyncContextStrategy };\n//# sourceMappingURL=stackStrategy.js.map\n","import { getGlobalSingleton } from './carrier.js';\nimport { Scope } from './scope.js';\n\n/** Get the default current scope. */\nfunction getDefaultCurrentScope() {\n  return getGlobalSingleton('defaultCurrentScope', () => new Scope());\n}\n\n/** Get the default isolation scope. */\nfunction getDefaultIsolationScope() {\n  return getGlobalSingleton('defaultIsolationScope', () => new Scope());\n}\n\nexport { getDefaultCurrentScope, getDefaultIsolationScope };\n//# sourceMappingURL=defaultScopes.js.map\n","import { getMainCarrier, getSentryCarrier } from '../carrier.js';\nimport { getStackAsyncContextStrategy } from './stackStrategy.js';\n\n/**\n * @private Private API with no semver guarantees!\n *\n * Sets the global async context strategy\n */\nfunction setAsyncContextStrategy(strategy) {\n  // Get main carrier (global for every environment)\n  const registry = getMainCarrier();\n  const sentry = getSentryCarrier(registry);\n  sentry.acs = strategy;\n}\n\n/**\n * Get the current async context strategy.\n * If none has been setup, the default will be used.\n */\nfunction getAsyncContextStrategy(carrier) {\n  const sentry = getSentryCarrier(carrier);\n\n  if (sentry.acs) {\n    return sentry.acs;\n  }\n\n  // Otherwise, use the default one (stack)\n  return getStackAsyncContextStrategy();\n}\n\nexport { getAsyncContextStrategy, setAsyncContextStrategy };\n//# sourceMappingURL=index.js.map\n","/** Internal global with common properties and Sentry extensions  */\n\n/** Get's the global object for the current JavaScript runtime */\nconst GLOBAL_OBJ = globalThis ;\n\nexport { GLOBAL_OBJ };\n//# sourceMappingURL=worldwide.js.map\n","import { getCurrentScope, getClient, withIsolationScope, getIsolationScope } from './currentScopes.js';\nimport { DEBUG_BUILD } from './debug-build.js';\nimport { makeSession, updateSession, closeSession } from './session.js';\nimport { isThenable } from './utils-hoist/is.js';\nimport { logger } from './utils-hoist/logger.js';\nimport { uuid4 } from './utils-hoist/misc.js';\nimport { timestampInSeconds } from './utils-hoist/time.js';\nimport { GLOBAL_OBJ } from './utils-hoist/worldwide.js';\nimport { parseEventHintOrCaptureContext } from './utils/prepareEvent.js';\n\n/**\n * Captures an exception event and sends it to Sentry.\n *\n * @param exception The exception to capture.\n * @param hint Optional additional data to attach to the Sentry event.\n * @returns the id of the captured Sentry event.\n */\nfunction captureException(exception, hint) {\n  return getCurrentScope().captureException(exception, parseEventHintOrCaptureContext(hint));\n}\n\n/**\n * Captures a message event and sends it to Sentry.\n *\n * @param message The message to send to Sentry.\n * @param captureContext Define the level of the message or pass in additional data to attach to the message.\n * @returns the id of the captured message.\n */\nfunction captureMessage(message, captureContext) {\n  // This is necessary to provide explicit scopes upgrade, without changing the original\n  // arity of the `captureMessage(message, level)` method.\n  const level = typeof captureContext === 'string' ? captureContext : undefined;\n  const context = typeof captureContext !== 'string' ? { captureContext } : undefined;\n  return getCurrentScope().captureMessage(message, level, context);\n}\n\n/**\n * Captures a manually created event and sends it to Sentry.\n *\n * @param event The event to send to Sentry.\n * @param hint Optional additional data to attach to the Sentry event.\n * @returns the id of the captured event.\n */\nfunction captureEvent(event, hint) {\n  return getCurrentScope().captureEvent(event, hint);\n}\n\n/**\n * Sets context data with the given name.\n * @param name of the context\n * @param context Any kind of data. This data will be normalized.\n */\nfunction setContext(name, context) {\n  getIsolationScope().setContext(name, context);\n}\n\n/**\n * Set an object that will be merged sent as extra data with the event.\n * @param extras Extras object to merge into current context.\n */\nfunction setExtras(extras) {\n  getIsolationScope().setExtras(extras);\n}\n\n/**\n * Set key:value that will be sent as extra data with the event.\n * @param key String of extra\n * @param extra Any kind of data. This data will be normalized.\n */\nfunction setExtra(key, extra) {\n  getIsolationScope().setExtra(key, extra);\n}\n\n/**\n * Set an object that will be merged sent as tags data with the event.\n * @param tags Tags context object to merge into current context.\n */\nfunction setTags(tags) {\n  getIsolationScope().setTags(tags);\n}\n\n/**\n * Set key:value that will be sent as tags data with the event.\n *\n * Can also be used to unset a tag, by passing `undefined`.\n *\n * @param key String key of tag\n * @param value Value of tag\n */\nfunction setTag(key, value) {\n  getIsolationScope().setTag(key, value);\n}\n\n/**\n * Updates user context information for future events.\n *\n * @param user User context object to be set in the current context. Pass `null` to unset the user.\n */\nfunction setUser(user) {\n  getIsolationScope().setUser(user);\n}\n\n/**\n * The last error event id of the isolation scope.\n *\n * Warning: This function really returns the last recorded error event id on the current\n * isolation scope. If you call this function after handling a certain error and another error\n * is captured in between, the last one is returned instead of the one you might expect.\n * Also, ids of events that were never sent to Sentry (for example because\n * they were dropped in `beforeSend`) could be returned.\n *\n * @returns The last event id of the isolation scope.\n */\nfunction lastEventId() {\n  return getIsolationScope().lastEventId();\n}\n\n/**\n * Create a cron monitor check in and send it to Sentry.\n *\n * @param checkIn An object that describes a check in.\n * @param upsertMonitorConfig An optional object that describes a monitor config. Use this if you want\n * to create a monitor automatically when sending a check in.\n */\nfunction captureCheckIn(checkIn, upsertMonitorConfig) {\n  const scope = getCurrentScope();\n  const client = getClient();\n  if (!client) {\n    DEBUG_BUILD && logger.warn('Cannot capture check-in. No client defined.');\n  } else if (!client.captureCheckIn) {\n    DEBUG_BUILD && logger.warn('Cannot capture check-in. Client does not support sending check-ins.');\n  } else {\n    return client.captureCheckIn(checkIn, upsertMonitorConfig, scope);\n  }\n\n  return uuid4();\n}\n\n/**\n * Wraps a callback with a cron monitor check in. The check in will be sent to Sentry when the callback finishes.\n *\n * @param monitorSlug The distinct slug of the monitor.\n * @param upsertMonitorConfig An optional object that describes a monitor config. Use this if you want\n * to create a monitor automatically when sending a check in.\n */\nfunction withMonitor(\n  monitorSlug,\n  callback,\n  upsertMonitorConfig,\n) {\n  const checkInId = captureCheckIn({ monitorSlug, status: 'in_progress' }, upsertMonitorConfig);\n  const now = timestampInSeconds();\n\n  function finishCheckIn(status) {\n    captureCheckIn({ monitorSlug, status, checkInId, duration: timestampInSeconds() - now });\n  }\n\n  return withIsolationScope(() => {\n    let maybePromiseResult;\n    try {\n      maybePromiseResult = callback();\n    } catch (e) {\n      finishCheckIn('error');\n      throw e;\n    }\n\n    if (isThenable(maybePromiseResult)) {\n      Promise.resolve(maybePromiseResult).then(\n        () => {\n          finishCheckIn('ok');\n        },\n        e => {\n          finishCheckIn('error');\n          throw e;\n        },\n      );\n    } else {\n      finishCheckIn('ok');\n    }\n\n    return maybePromiseResult;\n  });\n}\n\n/**\n * Call `flush()` on the current client, if there is one. See {@link Client.flush}.\n *\n * @param timeout Maximum time in ms the client should wait to flush its event queue. Omitting this parameter will cause\n * the client to wait until all events are sent before resolving the promise.\n * @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it\n * doesn't (or if there's no client defined).\n */\nasync function flush(timeout) {\n  const client = getClient();\n  if (client) {\n    return client.flush(timeout);\n  }\n  DEBUG_BUILD && logger.warn('Cannot flush events. No client defined.');\n  return Promise.resolve(false);\n}\n\n/**\n * Call `close()` on the current client, if there is one. See {@link Client.close}.\n *\n * @param timeout Maximum time in ms the client should wait to flush its event queue before shutting down. Omitting this\n * parameter will cause the client to wait until all events are sent before disabling itself.\n * @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it\n * doesn't (or if there's no client defined).\n */\nasync function close(timeout) {\n  const client = getClient();\n  if (client) {\n    return client.close(timeout);\n  }\n  DEBUG_BUILD && logger.warn('Cannot flush events and disable SDK. No client defined.');\n  return Promise.resolve(false);\n}\n\n/**\n * Returns true if Sentry has been properly initialized.\n */\nfunction isInitialized() {\n  return !!getClient();\n}\n\n/** If the SDK is initialized & enabled. */\nfunction isEnabled() {\n  const client = getClient();\n  return client?.getOptions().enabled !== false && !!client?.getTransport();\n}\n\n/**\n * Add an event processor.\n * This will be added to the current isolation scope, ensuring any event that is processed in the current execution\n * context will have the processor applied.\n */\nfunction addEventProcessor(callback) {\n  getIsolationScope().addEventProcessor(callback);\n}\n\n/**\n * Start a session on the current isolation scope.\n *\n * @param context (optional) additional properties to be applied to the returned session object\n *\n * @returns the new active session\n */\nfunction startSession(context) {\n  const isolationScope = getIsolationScope();\n  const currentScope = getCurrentScope();\n\n  // Will fetch userAgent if called from browser sdk\n  const { userAgent } = GLOBAL_OBJ.navigator || {};\n\n  const session = makeSession({\n    user: currentScope.getUser() || isolationScope.getUser(),\n    ...(userAgent && { userAgent }),\n    ...context,\n  });\n\n  // End existing session if there's one\n  const currentSession = isolationScope.getSession();\n  if (currentSession?.status === 'ok') {\n    updateSession(currentSession, { status: 'exited' });\n  }\n\n  endSession();\n\n  // Afterwards we set the new session on the scope\n  isolationScope.setSession(session);\n\n  return session;\n}\n\n/**\n * End the session on the current isolation scope.\n */\nfunction endSession() {\n  const isolationScope = getIsolationScope();\n  const currentScope = getCurrentScope();\n\n  const session = currentScope.getSession() || isolationScope.getSession();\n  if (session) {\n    closeSession(session);\n  }\n  _sendSessionUpdate();\n\n  // the session is over; take it off of the scope\n  isolationScope.setSession();\n}\n\n/**\n * Sends the current Session on the scope\n */\nfunction _sendSessionUpdate() {\n  const isolationScope = getIsolationScope();\n  const client = getClient();\n  const session = isolationScope.getSession();\n  if (session && client) {\n    client.captureSession(session);\n  }\n}\n\n/**\n * Sends the current session on the scope to Sentry\n *\n * @param end If set the session will be marked as exited and removed from the scope.\n *            Defaults to `false`.\n */\nfunction captureSession(end = false) {\n  // both send the update and pull the session from the scope\n  if (end) {\n    endSession();\n    return;\n  }\n\n  // only send the update\n  _sendSessionUpdate();\n}\n\nexport { addEventProcessor, captureCheckIn, captureEvent, captureException, captureMessage, captureSession, close, endSession, flush, isEnabled, isInitialized, lastEventId, setContext, setExtra, setExtras, setTag, setTags, setUser, startSession, withMonitor };\n//# sourceMappingURL=exports.js.map\n","/**\n * Use this attribute to represent the source of a span.\n * Should be one of: custom, url, route, view, component, task, unknown\n *\n */\nconst SEMANTIC_ATTRIBUTE_SENTRY_SOURCE = 'sentry.source';\n\n/**\n * Attributes that holds the sample rate that was locally applied to a span.\n * If this attribute is not defined, it means that the span inherited a sampling decision.\n *\n * NOTE: Is only defined on root spans.\n */\nconst SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE = 'sentry.sample_rate';\n\n/**\n * Use this attribute to represent the operation of a span.\n */\nconst SEMANTIC_ATTRIBUTE_SENTRY_OP = 'sentry.op';\n\n/**\n * Use this attribute to represent the origin of a span.\n */\nconst SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN = 'sentry.origin';\n\n/** The reason why an idle span finished. */\nconst SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON = 'sentry.idle_span_finish_reason';\n\n/** The unit of a measurement, which may be stored as a TimedEvent. */\nconst SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT = 'sentry.measurement_unit';\n\n/** The value of a measurement, which may be stored as a TimedEvent. */\nconst SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE = 'sentry.measurement_value';\n\n/**\n * A custom span name set by users guaranteed to be taken over any automatically\n * inferred name. This attribute is removed before the span is sent.\n *\n * @internal only meant for internal SDK usage\n * @hidden\n */\nconst SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME = 'sentry.custom_span_name';\n\n/**\n * The id of the profile that this span occurred in.\n */\nconst SEMANTIC_ATTRIBUTE_PROFILE_ID = 'sentry.profile_id';\n\nconst SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME = 'sentry.exclusive_time';\n\nconst SEMANTIC_ATTRIBUTE_CACHE_HIT = 'cache.hit';\n\nconst SEMANTIC_ATTRIBUTE_CACHE_KEY = 'cache.key';\n\nconst SEMANTIC_ATTRIBUTE_CACHE_ITEM_SIZE = 'cache.item_size';\n\n/** TODO: Remove these once we update to latest semantic conventions */\nconst SEMANTIC_ATTRIBUTE_HTTP_REQUEST_METHOD = 'http.request.method';\nconst SEMANTIC_ATTRIBUTE_URL_FULL = 'url.full';\n\n/**\n * A span link attribute to mark the link as a special span link.\n *\n * Known values:\n * - `previous_trace`: The span links to the frontend root span of the previous trace.\n * - `next_trace`: The span links to the frontend root span of the next trace. (Not set by the SDK)\n *\n * Other values may be set as appropriate.\n * @see https://develop.sentry.dev/sdk/telemetry/traces/span-links/#link-types\n */\nconst SEMANTIC_LINK_ATTRIBUTE_LINK_TYPE = 'sentry.link.type';\n\nexport { SEMANTIC_ATTRIBUTE_CACHE_HIT, SEMANTIC_ATTRIBUTE_CACHE_ITEM_SIZE, SEMANTIC_ATTRIBUTE_CACHE_KEY, SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME, SEMANTIC_ATTRIBUTE_HTTP_REQUEST_METHOD, SEMANTIC_ATTRIBUTE_PROFILE_ID, SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME, SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON, SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT, SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, SEMANTIC_ATTRIBUTE_URL_FULL, SEMANTIC_LINK_ATTRIBUTE_LINK_TYPE };\n//# sourceMappingURL=semanticAttributes.js.map\n","import { getClient } from '../currentScopes.js';\n\n// Treeshakable guard to remove all code related to tracing\n\n/**\n * Determines if span recording is currently enabled.\n *\n * Spans are recorded when at least one of `tracesSampleRate` and `tracesSampler`\n * is defined in the SDK config. This function does not make any assumption about\n * sampling decisions, it only checks if the SDK is configured to record spans.\n *\n * Important: This function only determines if span recording is enabled. Trace\n * continuation and propagation is separately controlled and not covered by this function.\n * If this function returns `false`, traces can still be propagated (which is what\n * we refer to by \"Tracing without Performance\")\n * @see https://develop.sentry.dev/sdk/telemetry/traces/tracing-without-performance/\n *\n * @param maybeOptions An SDK options object to be passed to this function.\n * If this option is not provided, the function will use the current client's options.\n */\nfunction hasSpansEnabled(\n  maybeOptions,\n) {\n  if (typeof __SENTRY_TRACING__ === 'boolean' && !__SENTRY_TRACING__) {\n    return false;\n  }\n\n  const options = maybeOptions || getClient()?.getOptions();\n  return (\n    !!options &&\n    // Note: This check is `!= null`, meaning \"nullish\". `0` is not \"nullish\", `undefined` and `null` are. (This comment was brought to you by 15 minutes of questioning life)\n    (options.tracesSampleRate != null || !!options.tracesSampler)\n  );\n}\n\n/**\n * @see JSDoc of `hasSpansEnabled`\n * @deprecated Use `hasSpansEnabled` instead, which is a more accurately named version of this function.\n * This function will be removed in the next major version of the SDK.\n */\n// TODO(v10): Remove this export\nconst hasTracingEnabled = hasSpansEnabled;\n\nexport { hasSpansEnabled, hasTracingEnabled };\n//# sourceMappingURL=hasSpansEnabled.js.map\n","import { addNonEnumerableProperty } from './object.js';\nimport { snipLine } from './string.js';\nimport { GLOBAL_OBJ } from './worldwide.js';\n\nfunction getCrypto() {\n  const gbl = GLOBAL_OBJ ;\n  return gbl.crypto || gbl.msCrypto;\n}\n\n/**\n * UUID4 generator\n * @param crypto Object that provides the crypto API.\n * @returns string Generated UUID4.\n */\nfunction uuid4(crypto = getCrypto()) {\n  let getRandomByte = () => Math.random() * 16;\n  try {\n    if (crypto?.randomUUID) {\n      return crypto.randomUUID().replace(/-/g, '');\n    }\n    if (crypto?.getRandomValues) {\n      getRandomByte = () => {\n        // crypto.getRandomValues might return undefined instead of the typed array\n        // in old Chromium versions (e.g. 23.0.1235.0 (151422))\n        // However, `typedArray` is still filled in-place.\n        // @see https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues#typedarray\n        const typedArray = new Uint8Array(1);\n        crypto.getRandomValues(typedArray);\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        return typedArray[0];\n      };\n    }\n  } catch (_) {\n    // some runtimes can crash invoking crypto\n    // https://github.com/getsentry/sentry-javascript/issues/8935\n  }\n\n  // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523\n  // Concatenating the following numbers as strings results in '10000000100040008000100000000000'\n  return (([1e7] ) + 1e3 + 4e3 + 8e3 + 1e11).replace(/[018]/g, c =>\n    // eslint-disable-next-line no-bitwise\n    ((c ) ^ ((getRandomByte() & 15) >> ((c ) / 4))).toString(16),\n  );\n}\n\nfunction getFirstException(event) {\n  return event.exception?.values?.[0];\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?.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\nfunction _parseInt(input) {\n  return parseInt(input || '', 10);\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]);\n  const minor = _parseInt(match[2]);\n  const patch = _parseInt(match[3]);\n  return {\n    buildmetadata: match[5],\n    major: isNaN(major) ? undefined : major,\n    minor: isNaN(minor) ? undefined : minor,\n    patch: isNaN(patch) ? undefined : patch,\n    prerelease: match[4],\n  };\n}\n\n/**\n * This function adds context (pre/post/line) lines to the provided frame\n *\n * @param lines string[] containing all lines\n * @param frame StackFrame that will be mutated\n * @param linesOfContext number of context lines we want to add pre/post\n */\nfunction addContextToFrame(lines, frame, linesOfContext = 5) {\n  // When there is no line number in the frame, attaching context is nonsensical and will even break grouping\n  if (frame.lineno === undefined) {\n    return;\n  }\n\n  const maxLines = lines.length;\n  const sourceLine = Math.max(Math.min(maxLines - 1, frame.lineno - 1), 0);\n\n  frame.pre_context = lines\n    .slice(Math.max(0, sourceLine - linesOfContext), sourceLine)\n    .map((line) => snipLine(line, 0));\n\n  // We guard here to ensure this is not larger than the existing number of lines\n  const lineIndex = Math.min(maxLines - 1, sourceLine);\n\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n  frame.context_line = snipLine(lines[lineIndex], 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  if (isAlreadyCaptured(exception)) {\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\nfunction isAlreadyCaptured(exception) {\n  try {\n    return (exception ).__sentry_captured__;\n  } catch {} // eslint-disable-line no-empty\n}\n\nexport { addContextToFrame, addExceptionMechanism, addExceptionTypeValue, checkOrSetAlreadyCaught, getEventDescription, parseSemver, uuid4 };\n//# sourceMappingURL=misc.js.map\n","import { updateSession } from './session.js';\nimport { isPlainObject } from './utils-hoist/is.js';\nimport { logger } from './utils-hoist/logger.js';\nimport { uuid4 } from './utils-hoist/misc.js';\nimport { generateTraceId } from './utils-hoist/propagationContext.js';\nimport { dateTimestampInSeconds } from './utils-hoist/time.js';\nimport { merge } from './utils/merge.js';\nimport { _setSpanForScope, _getSpanForScope } from './utils/spanOnScope.js';\n\n/**\n * Default value for maximum number of breadcrumbs added to an event.\n */\nconst DEFAULT_MAX_BREADCRUMBS = 100;\n\n/**\n * A context to be used for capturing an event.\n * This can either be a Scope, or a partial ScopeContext,\n * or a callback that receives the current scope and returns a new scope to use.\n */\n\n/**\n * Holds additional event information.\n */\nclass Scope {\n  /** Flag if notifying is happening. */\n\n  /** Callback for client to receive scope changes. */\n\n  /** Callback list that will be called during event processing. */\n\n  /** Array of breadcrumbs. */\n\n  /** User */\n\n  /** Tags */\n\n  /** Extra */\n\n  /** Contexts */\n\n  /** Attachments */\n\n  /** Propagation Context for distributed tracing */\n\n  /**\n   * A place to stash data which is needed at some point in the SDK's event processing pipeline but which shouldn't get\n   * sent to Sentry\n   */\n\n  /** Fingerprint */\n\n  /** Severity */\n\n  /**\n   * Transaction Name\n   *\n   * IMPORTANT: The transaction name on the scope has nothing to do with root spans/transaction objects.\n   * It's purpose is to assign a transaction to the scope that's added to non-transaction events.\n   */\n\n  /** Session */\n\n  /** The client on this scope */\n\n  /** Contains the last event id of a captured event.  */\n\n  // NOTE: Any field which gets added here should get added not only to the constructor but also to the `clone` method.\n\n   constructor() {\n    this._notifyingListeners = false;\n    this._scopeListeners = [];\n    this._eventProcessors = [];\n    this._breadcrumbs = [];\n    this._attachments = [];\n    this._user = {};\n    this._tags = {};\n    this._extra = {};\n    this._contexts = {};\n    this._sdkProcessingMetadata = {};\n    this._propagationContext = {\n      traceId: generateTraceId(),\n      sampleRand: Math.random(),\n    };\n  }\n\n  /**\n   * Clone all data from this scope into a new scope.\n   */\n   clone() {\n    const newScope = new Scope();\n    newScope._breadcrumbs = [...this._breadcrumbs];\n    newScope._tags = { ...this._tags };\n    newScope._extra = { ...this._extra };\n    newScope._contexts = { ...this._contexts };\n    if (this._contexts.flags) {\n      // We need to copy the `values` array so insertions on a cloned scope\n      // won't affect the original array.\n      newScope._contexts.flags = {\n        values: [...this._contexts.flags.values],\n      };\n    }\n\n    newScope._user = this._user;\n    newScope._level = this._level;\n    newScope._session = this._session;\n    newScope._transactionName = this._transactionName;\n    newScope._fingerprint = this._fingerprint;\n    newScope._eventProcessors = [...this._eventProcessors];\n    newScope._attachments = [...this._attachments];\n    newScope._sdkProcessingMetadata = { ...this._sdkProcessingMetadata };\n    newScope._propagationContext = { ...this._propagationContext };\n    newScope._client = this._client;\n    newScope._lastEventId = this._lastEventId;\n\n    _setSpanForScope(newScope, _getSpanForScope(this));\n\n    return newScope;\n  }\n\n  /**\n   * Update the client assigned to this scope.\n   * Note that not every scope will have a client assigned - isolation scopes & the global scope will generally not have a client,\n   * as well as manually created scopes.\n   */\n   setClient(client) {\n    this._client = client;\n  }\n\n  /**\n   * Set the ID of the last captured error event.\n   * This is generally only captured on the isolation scope.\n   */\n   setLastEventId(lastEventId) {\n    this._lastEventId = lastEventId;\n  }\n\n  /**\n   * Get the client assigned to this scope.\n   */\n   getClient() {\n    return this._client ;\n  }\n\n  /**\n   * Get the ID of the last captured error event.\n   * This is generally only available on the isolation scope.\n   */\n   lastEventId() {\n    return this._lastEventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   addScopeListener(callback) {\n    this._scopeListeners.push(callback);\n  }\n\n  /**\n   * Add an event processor that will be called before an event is sent.\n   */\n   addEventProcessor(callback) {\n    this._eventProcessors.push(callback);\n    return this;\n  }\n\n  /**\n   * Set the user for this scope.\n   * Set to `null` to unset the user.\n   */\n   setUser(user) {\n    // If null is passed we want to unset everything, but still define keys,\n    // so that later down in the pipeline any existing values are cleared.\n    this._user = user || {\n      email: undefined,\n      id: undefined,\n      ip_address: undefined,\n      username: undefined,\n    };\n\n    if (this._session) {\n      updateSession(this._session, { user });\n    }\n\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * Get the user from this scope.\n   */\n   getUser() {\n    return this._user;\n  }\n\n  /**\n   * Set an object that will be merged into existing tags on the scope,\n   * and will be sent as tags data with the event.\n   */\n   setTags(tags) {\n    this._tags = {\n      ...this._tags,\n      ...tags,\n    };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * Set a single tag that will be sent as tags data with the event.\n   */\n   setTag(key, value) {\n    this._tags = { ...this._tags, [key]: value };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * Set an object that will be merged into existing extra on the scope,\n   * and will be sent as extra data with the event.\n   */\n   setExtras(extras) {\n    this._extra = {\n      ...this._extra,\n      ...extras,\n    };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * Set a single key:value extra entry that will be sent as extra data with the event.\n   */\n   setExtra(key, extra) {\n    this._extra = { ...this._extra, [key]: extra };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * Sets the fingerprint on the scope to send with the events.\n   * @param {string[]} fingerprint Fingerprint to group events in Sentry.\n   */\n   setFingerprint(fingerprint) {\n    this._fingerprint = fingerprint;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * Sets the level on the scope for future events.\n   */\n   setLevel(level) {\n    this._level = level;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * Sets the transaction name on the scope so that the name of e.g. taken server route or\n   * the page location is attached to future events.\n   *\n   * IMPORTANT: Calling this function does NOT change the name of the currently active\n   * root span. If you want to change the name of the active root span, use\n   * `Sentry.updateSpanName(rootSpan, 'new name')` instead.\n   *\n   * By default, the SDK updates the scope's transaction name automatically on sensible\n   * occasions, such as a page navigation or when handling a new request on the server.\n   */\n   setTransactionName(name) {\n    this._transactionName = name;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * Sets context data with the given name.\n   * Data passed as context will be normalized. You can also pass `null` to unset the context.\n   * Note that context data will not be merged - calling `setContext` will overwrite an existing context with the same key.\n   */\n   setContext(key, context) {\n    if (context === null) {\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete this._contexts[key];\n    } else {\n      this._contexts[key] = context;\n    }\n\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * Set the session for the scope.\n   */\n   setSession(session) {\n    if (!session) {\n      delete this._session;\n    } else {\n      this._session = session;\n    }\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * Get the session from the scope.\n   */\n   getSession() {\n    return this._session;\n  }\n\n  /**\n   * Updates the scope with provided data. Can work in three variations:\n   * - plain object containing updatable attributes\n   * - Scope instance that'll extract the attributes from\n   * - callback function that'll receive the current scope as an argument and allow for modifications\n   */\n   update(captureContext) {\n    if (!captureContext) {\n      return this;\n    }\n\n    const scopeToMerge = typeof captureContext === 'function' ? captureContext(this) : captureContext;\n\n    const scopeInstance =\n      scopeToMerge instanceof Scope\n        ? scopeToMerge.getScopeData()\n        : isPlainObject(scopeToMerge)\n          ? (captureContext )\n          : undefined;\n\n    const { tags, extra, user, contexts, level, fingerprint = [], propagationContext } = scopeInstance || {};\n\n    this._tags = { ...this._tags, ...tags };\n    this._extra = { ...this._extra, ...extra };\n    this._contexts = { ...this._contexts, ...contexts };\n\n    if (user && Object.keys(user).length) {\n      this._user = user;\n    }\n\n    if (level) {\n      this._level = level;\n    }\n\n    if (fingerprint.length) {\n      this._fingerprint = fingerprint;\n    }\n\n    if (propagationContext) {\n      this._propagationContext = propagationContext;\n    }\n\n    return this;\n  }\n\n  /**\n   * Clears the current scope and resets its properties.\n   * Note: The client will not be cleared.\n   */\n   clear() {\n    // client is not cleared here on purpose!\n    this._breadcrumbs = [];\n    this._tags = {};\n    this._extra = {};\n    this._user = {};\n    this._contexts = {};\n    this._level = undefined;\n    this._transactionName = undefined;\n    this._fingerprint = undefined;\n    this._session = undefined;\n    _setSpanForScope(this, undefined);\n    this._attachments = [];\n    this.setPropagationContext({ traceId: generateTraceId(), sampleRand: Math.random() });\n\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * Adds a breadcrumb to the scope.\n   * By default, the last 100 breadcrumbs are kept.\n   */\n   addBreadcrumb(breadcrumb, maxBreadcrumbs) {\n    const maxCrumbs = typeof maxBreadcrumbs === 'number' ? maxBreadcrumbs : DEFAULT_MAX_BREADCRUMBS;\n\n    // No data has been changed, so don't notify scope listeners\n    if (maxCrumbs <= 0) {\n      return this;\n    }\n\n    const mergedBreadcrumb = {\n      timestamp: dateTimestampInSeconds(),\n      ...breadcrumb,\n    };\n\n    this._breadcrumbs.push(mergedBreadcrumb);\n    if (this._breadcrumbs.length > maxCrumbs) {\n      this._breadcrumbs = this._breadcrumbs.slice(-maxCrumbs);\n      this._client?.recordDroppedEvent('buffer_overflow', 'log_item');\n    }\n\n    this._notifyScopeListeners();\n\n    return this;\n  }\n\n  /**\n   * Get the last breadcrumb of the scope.\n   */\n   getLastBreadcrumb() {\n    return this._breadcrumbs[this._breadcrumbs.length - 1];\n  }\n\n  /**\n   * Clear all breadcrumbs from the scope.\n   */\n   clearBreadcrumbs() {\n    this._breadcrumbs = [];\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * Add an attachment to the scope.\n   */\n   addAttachment(attachment) {\n    this._attachments.push(attachment);\n    return this;\n  }\n\n  /**\n   * Clear all attachments from the scope.\n   */\n   clearAttachments() {\n    this._attachments = [];\n    return this;\n  }\n\n  /**\n   * Get the data of this scope, which should be applied to an event during processing.\n   */\n   getScopeData() {\n    return {\n      breadcrumbs: this._breadcrumbs,\n      attachments: this._attachments,\n      contexts: this._contexts,\n      tags: this._tags,\n      extra: this._extra,\n      user: this._user,\n      level: this._level,\n      fingerprint: this._fingerprint || [],\n      eventProcessors: this._eventProcessors,\n      propagationContext: this._propagationContext,\n      sdkProcessingMetadata: this._sdkProcessingMetadata,\n      transactionName: this._transactionName,\n      span: _getSpanForScope(this),\n    };\n  }\n\n  /**\n   * Add data which will be accessible during event processing but won't get sent to Sentry.\n   */\n   setSDKProcessingMetadata(newData) {\n    this._sdkProcessingMetadata = merge(this._sdkProcessingMetadata, newData, 2);\n    return this;\n  }\n\n  /**\n   * Add propagation context to the scope, used for distributed tracing\n   */\n   setPropagationContext(context) {\n    this._propagationContext = context;\n    return this;\n  }\n\n  /**\n   * Get propagation context from the scope, used for distributed tracing\n   */\n   getPropagationContext() {\n    return this._propagationContext;\n  }\n\n  /**\n   * Capture an exception for this scope.\n   *\n   * @returns {string} The id of the captured Sentry event.\n   */\n   captureException(exception, hint) {\n    const eventId = hint?.event_id || uuid4();\n\n    if (!this._client) {\n      logger.warn('No client configured on scope - will not capture exception!');\n      return eventId;\n    }\n\n    const syntheticException = new Error('Sentry syntheticException');\n\n    this._client.captureException(\n      exception,\n      {\n        originalException: exception,\n        syntheticException,\n        ...hint,\n        event_id: eventId,\n      },\n      this,\n    );\n\n    return eventId;\n  }\n\n  /**\n   * Capture a message for this scope.\n   *\n   * @returns {string} The id of the captured message.\n   */\n   captureMessage(message, level, hint) {\n    const eventId = hint?.event_id || uuid4();\n\n    if (!this._client) {\n      logger.warn('No client configured on scope - will not capture message!');\n      return eventId;\n    }\n\n    const syntheticException = new Error(message);\n\n    this._client.captureMessage(\n      message,\n      level,\n      {\n        originalException: message,\n        syntheticException,\n        ...hint,\n        event_id: eventId,\n      },\n      this,\n    );\n\n    return eventId;\n  }\n\n  /**\n   * Capture a Sentry event for this scope.\n   *\n   * @returns {string} The id of the captured event.\n   */\n   captureEvent(event, hint) {\n    const eventId = hint?.event_id || uuid4();\n\n    if (!this._client) {\n      logger.warn('No client configured on scope - will not capture event!');\n      return eventId;\n    }\n\n    this._client.captureEvent(event, { ...hint, event_id: eventId }, this);\n\n    return eventId;\n  }\n\n  /**\n   * This will be called on every set call.\n   */\n   _notifyScopeListeners() {\n    // We need this check for this._notifyingListeners to be able to work on scope during updates\n    // If this check is not here we'll produce endless recursion when something is done with the scope\n    // during the callback.\n    if (!this._notifyingListeners) {\n      this._notifyingListeners = true;\n      this._scopeListeners.forEach(callback => {\n        callback(this);\n      });\n      this._notifyingListeners = false;\n    }\n  }\n}\n\nexport { Scope };\n//# sourceMappingURL=scope.js.map\n","import { SDK_VERSION } from './utils-hoist/version.js';\nimport { GLOBAL_OBJ } from './utils-hoist/worldwide.js';\n\n/**\n * An object that contains globally accessible properties and maintains a scope stack.\n * @hidden\n */\n\n/**\n * Returns the global shim registry.\n *\n * FIXME: This function is problematic, because despite always returning a valid Carrier,\n * it has an optional `__SENTRY__` property, which then in turn requires us to always perform an unnecessary check\n * at the call-site. We always access the carrier through this function, so we can guarantee that `__SENTRY__` is there.\n **/\nfunction getMainCarrier() {\n  // This ensures a Sentry carrier exists\n  getSentryCarrier(GLOBAL_OBJ);\n  return GLOBAL_OBJ;\n}\n\n/** Will either get the existing sentry carrier, or create a new one. */\nfunction getSentryCarrier(carrier) {\n  const __SENTRY__ = (carrier.__SENTRY__ = carrier.__SENTRY__ || {});\n\n  // For now: First SDK that sets the .version property wins\n  __SENTRY__.version = __SENTRY__.version || SDK_VERSION;\n\n  // Intentionally populating and returning the version of \"this\" SDK instance\n  // rather than what's set in .version so that \"this\" SDK always gets its carrier\n  return (__SENTRY__[SDK_VERSION] = __SENTRY__[SDK_VERSION] || {});\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(\n  name,\n  creator,\n  obj = GLOBAL_OBJ,\n) {\n  const __SENTRY__ = (obj.__SENTRY__ = obj.__SENTRY__ || {});\n  const carrier = (__SENTRY__[SDK_VERSION] = __SENTRY__[SDK_VERSION] || {});\n  // Note: We do not want to set `carrier.version` here, as this may be called before any `init` is called, e.g. for the default scopes\n  return carrier[name] || (carrier[name] = creator());\n}\n\nexport { getGlobalSingleton, getMainCarrier, getSentryCarrier };\n//# sourceMappingURL=carrier.js.map\n","import { DEBUG_BUILD } from './debug-build.js';\nimport { isThenable } from './utils-hoist/is.js';\nimport { logger } from './utils-hoist/logger.js';\nimport { SyncPromise } from './utils-hoist/syncpromise.js';\n\n/**\n * Process an array of event processors, returning the processed event (or `null` if the event was dropped).\n */\nfunction notifyEventProcessors(\n  processors,\n  event,\n  hint,\n  index = 0,\n) {\n  return new SyncPromise((resolve, reject) => {\n    const processor = processors[index];\n    if (event === null || typeof processor !== 'function') {\n      resolve(event);\n    } else {\n      const result = processor({ ...event }, hint) ;\n\n      DEBUG_BUILD && processor.id && result === null && logger.log(`Event processor \"${processor.id}\" dropped event`);\n\n      if (isThenable(result)) {\n        void result\n          .then(final => notifyEventProcessors(processors, final, hint, index + 1).then(resolve))\n          .then(null, reject);\n      } else {\n        void notifyEventProcessors(processors, result, hint, index + 1)\n          .then(resolve)\n          .then(null, reject);\n      }\n    }\n  });\n}\n\nexport { notifyEventProcessors };\n//# sourceMappingURL=eventProcessors.js.map\n","import { GLOBAL_OBJ } from './worldwide.js';\n\nlet parsedStackResults;\nlet lastKeysCount;\nlet cachedFilenameDebugIds;\n\n/**\n * Returns a map of filenames to debug identifiers.\n */\nfunction getFilenameToDebugIdMap(stackParser) {\n  const debugIdMap = GLOBAL_OBJ._sentryDebugIds;\n  if (!debugIdMap) {\n    return {};\n  }\n\n  const debugIdKeys = Object.keys(debugIdMap);\n\n  // If the count of registered globals hasn't changed since the last call, we\n  // can just return the cached result.\n  if (cachedFilenameDebugIds && debugIdKeys.length === lastKeysCount) {\n    return cachedFilenameDebugIds;\n  }\n\n  lastKeysCount = debugIdKeys.length;\n\n  // Build a map of filename -> debug_id.\n  cachedFilenameDebugIds = debugIdKeys.reduce((acc, stackKey) => {\n    if (!parsedStackResults) {\n      parsedStackResults = {};\n    }\n\n    const result = parsedStackResults[stackKey];\n\n    if (result) {\n      acc[result[0]] = result[1];\n    } else {\n      const parsedStack = stackParser(stackKey);\n\n      for (let i = parsedStack.length - 1; i >= 0; i--) {\n        const stackFrame = parsedStack[i];\n        const filename = stackFrame?.filename;\n        const debugId = debugIdMap[stackKey];\n\n        if (filename && debugId) {\n          acc[filename] = debugId;\n          parsedStackResults[stackKey] = [filename, debugId];\n          break;\n        }\n      }\n    }\n\n    return acc;\n  }, {});\n\n  return cachedFilenameDebugIds;\n}\n\n/**\n * Returns a list of debug images for the given resources.\n */\nfunction getDebugImagesForResources(\n  stackParser,\n  resource_paths,\n) {\n  const filenameDebugIdMap = getFilenameToDebugIdMap(stackParser);\n\n  if (!filenameDebugIdMap) {\n    return [];\n  }\n\n  const images = [];\n  for (const path of resource_paths) {\n    if (path && filenameDebugIdMap[path]) {\n      images.push({\n        type: 'sourcemap',\n        code_file: path,\n        debug_id: filenameDebugIdMap[path] ,\n      });\n    }\n  }\n\n  return images;\n}\n\nexport { getDebugImagesForResources, getFilenameToDebugIdMap };\n//# sourceMappingURL=debug-ids.js.map\n","import { getDynamicSamplingContextFromSpan } from '../tracing/dynamicSamplingContext.js';\nimport { merge } from './merge.js';\nimport { spanToTraceContext, getRootSpan, spanToJSON } from './spanUtils.js';\n\n/**\n * Applies data from the scope to the event and runs all event processors on it.\n */\nfunction applyScopeDataToEvent(event, data) {\n  const { fingerprint, span, breadcrumbs, sdkProcessingMetadata } = data;\n\n  // Apply general data\n  applyDataToEvent(event, data);\n\n  // We want to set the trace context for normal events only if there isn't already\n  // a trace context on the event. There is a product feature in place where we link\n  // errors with transaction and it relies on that.\n  if (span) {\n    applySpanToEvent(event, span);\n  }\n\n  applyFingerprintToEvent(event, fingerprint);\n  applyBreadcrumbsToEvent(event, breadcrumbs);\n  applySdkMetadataToEvent(event, sdkProcessingMetadata);\n}\n\n/** Merge data of two scopes together. */\nfunction mergeScopeData(data, mergeData) {\n  const {\n    extra,\n    tags,\n    user,\n    contexts,\n    level,\n    sdkProcessingMetadata,\n    breadcrumbs,\n    fingerprint,\n    eventProcessors,\n    attachments,\n    propagationContext,\n    transactionName,\n    span,\n  } = mergeData;\n\n  mergeAndOverwriteScopeData(data, 'extra', extra);\n  mergeAndOverwriteScopeData(data, 'tags', tags);\n  mergeAndOverwriteScopeData(data, 'user', user);\n  mergeAndOverwriteScopeData(data, 'contexts', contexts);\n\n  data.sdkProcessingMetadata = merge(data.sdkProcessingMetadata, sdkProcessingMetadata, 2);\n\n  if (level) {\n    data.level = level;\n  }\n\n  if (transactionName) {\n    data.transactionName = transactionName;\n  }\n\n  if (span) {\n    data.span = span;\n  }\n\n  if (breadcrumbs.length) {\n    data.breadcrumbs = [...data.breadcrumbs, ...breadcrumbs];\n  }\n\n  if (fingerprint.length) {\n    data.fingerprint = [...data.fingerprint, ...fingerprint];\n  }\n\n  if (eventProcessors.length) {\n    data.eventProcessors = [...data.eventProcessors, ...eventProcessors];\n  }\n\n  if (attachments.length) {\n    data.attachments = [...data.attachments, ...attachments];\n  }\n\n  data.propagationContext = { ...data.propagationContext, ...propagationContext };\n}\n\n/**\n * Merges certain scope data. Undefined values will overwrite any existing values.\n * Exported only for tests.\n */\nfunction mergeAndOverwriteScopeData\n\n(data, prop, mergeVal) {\n  data[prop] = merge(data[prop], mergeVal, 1);\n}\n\nfunction applyDataToEvent(event, data) {\n  const { extra, tags, user, contexts, level, transactionName } = data;\n\n  if (Object.keys(extra).length) {\n    event.extra = { ...extra, ...event.extra };\n  }\n\n  if (Object.keys(tags).length) {\n    event.tags = { ...tags, ...event.tags };\n  }\n\n  if (Object.keys(user).length) {\n    event.user = { ...user, ...event.user };\n  }\n\n  if (Object.keys(contexts).length) {\n    event.contexts = { ...contexts, ...event.contexts };\n  }\n\n  if (level) {\n    event.level = level;\n  }\n\n  // transaction events get their `transaction` from the root span name\n  if (transactionName && event.type !== 'transaction') {\n    event.transaction = transactionName;\n  }\n}\n\nfunction applyBreadcrumbsToEvent(event, breadcrumbs) {\n  const mergedBreadcrumbs = [...(event.breadcrumbs || []), ...breadcrumbs];\n  event.breadcrumbs = mergedBreadcrumbs.length ? mergedBreadcrumbs : undefined;\n}\n\nfunction applySdkMetadataToEvent(event, sdkProcessingMetadata) {\n  event.sdkProcessingMetadata = {\n    ...event.sdkProcessingMetadata,\n    ...sdkProcessingMetadata,\n  };\n}\n\nfunction applySpanToEvent(event, span) {\n  event.contexts = {\n    trace: spanToTraceContext(span),\n    ...event.contexts,\n  };\n\n  event.sdkProcessingMetadata = {\n    dynamicSamplingContext: getDynamicSamplingContextFromSpan(span),\n    ...event.sdkProcessingMetadata,\n  };\n\n  const rootSpan = getRootSpan(span);\n  const transactionName = spanToJSON(rootSpan).description;\n  if (transactionName && !event.transaction && event.type === 'transaction') {\n    event.transaction = transactionName;\n  }\n}\n\n/**\n * Applies fingerprint from the scope to the event if there's one,\n * uses message if there's one instead or get rid of empty fingerprint\n */\nfunction applyFingerprintToEvent(event, fingerprint) {\n  // Make sure it's an array first and we actually have something in place\n  event.fingerprint = event.fingerprint\n    ? Array.isArray(event.fingerprint)\n      ? event.fingerprint\n      : [event.fingerprint]\n    : [];\n\n  // If we have something on the scope, then merge it with event\n  if (fingerprint) {\n    event.fingerprint = event.fingerprint.concat(fingerprint);\n  }\n\n  // If we have no data at all, remove empty array default\n  if (!event.fingerprint.length) {\n    delete event.fingerprint;\n  }\n}\n\nexport { applyScopeDataToEvent, mergeAndOverwriteScopeData, mergeScopeData };\n//# sourceMappingURL=applyScopeDataToEvent.js.map\n","import { DEFAULT_ENVIRONMENT } from '../constants.js';\nimport { getGlobalScope } from '../currentScopes.js';\nimport { notifyEventProcessors } from '../eventProcessors.js';\nimport { Scope } from '../scope.js';\nimport { getFilenameToDebugIdMap } from '../utils-hoist/debug-ids.js';\nimport { uuid4, addExceptionMechanism } from '../utils-hoist/misc.js';\nimport { normalize } from '../utils-hoist/normalize.js';\nimport { truncate } from '../utils-hoist/string.js';\nimport { dateTimestampInSeconds } from '../utils-hoist/time.js';\nimport { mergeScopeData, applyScopeDataToEvent } from './applyScopeDataToEvent.js';\n\n/**\n * This type makes sure that we get either a CaptureContext, OR an EventHint.\n * It does not allow mixing them, which could lead to unexpected outcomes, e.g. this is disallowed:\n * { user: { id: '123' }, mechanism: { handled: false } }\n */\n\n/**\n * Adds common information to events.\n *\n * The information includes release and environment from `options`,\n * breadcrumbs and context (extra, tags and user) from the scope.\n *\n * Information that is already present in the event is never overwritten. For\n * nested objects, such as the context, keys are merged.\n *\n * @param event The original event.\n * @param hint May contain additional information about the original exception.\n * @param scope A scope containing event metadata.\n * @returns A new event with more information.\n * @hidden\n */\nfunction prepareEvent(\n  options,\n  event,\n  hint,\n  scope,\n  client,\n  isolationScope,\n) {\n  const { normalizeDepth = 3, normalizeMaxBreadth = 1000 } = options;\n  const prepared = {\n    ...event,\n    event_id: event.event_id || hint.event_id || uuid4(),\n    timestamp: event.timestamp || dateTimestampInSeconds(),\n  };\n  const integrations = hint.integrations || options.integrations.map(i => i.name);\n\n  applyClientOptions(prepared, options);\n  applyIntegrationsMetadata(prepared, integrations);\n\n  if (client) {\n    client.emit('applyFrameMetadata', event);\n  }\n\n  // Only put debug IDs onto frames for error events.\n  if (event.type === undefined) {\n    applyDebugIds(prepared, options.stackParser);\n  }\n\n  // If we have scope given to us, use it as the base for further modifications.\n  // This allows us to prevent unnecessary copying of data if `captureContext` is not provided.\n  const finalScope = getFinalScope(scope, hint.captureContext);\n\n  if (hint.mechanism) {\n    addExceptionMechanism(prepared, hint.mechanism);\n  }\n\n  const clientEventProcessors = client ? client.getEventProcessors() : [];\n\n  // This should be the last thing called, since we want that\n  // {@link Scope.addEventProcessor} gets the finished prepared event.\n  // Merge scope data together\n  const data = getGlobalScope().getScopeData();\n\n  if (isolationScope) {\n    const isolationData = isolationScope.getScopeData();\n    mergeScopeData(data, isolationData);\n  }\n\n  if (finalScope) {\n    const finalScopeData = finalScope.getScopeData();\n    mergeScopeData(data, finalScopeData);\n  }\n\n  const attachments = [...(hint.attachments || []), ...data.attachments];\n  if (attachments.length) {\n    hint.attachments = attachments;\n  }\n\n  applyScopeDataToEvent(prepared, data);\n\n  const eventProcessors = [\n    ...clientEventProcessors,\n    // Run scope event processors _after_ all other processors\n    ...data.eventProcessors,\n  ];\n\n  const result = notifyEventProcessors(eventProcessors, prepared, hint);\n\n  return result.then(evt => {\n    if (evt) {\n      // We apply the debug_meta field only after all event processors have ran, so that if any event processors modified\n      // file names (e.g.the RewriteFrames integration) the filename -> debug ID relationship isn't destroyed.\n      // This should not cause any PII issues, since we're only moving data that is already on the event and not adding\n      // any new data\n      applyDebugMeta(evt);\n    }\n\n    if (typeof normalizeDepth === 'number' && normalizeDepth > 0) {\n      return normalizeEvent(evt, normalizeDepth, normalizeMaxBreadth);\n    }\n    return evt;\n  });\n}\n\n/**\n * Enhances event using the client configuration.\n * It takes care of all \"static\" values like environment, release and `dist`,\n * as well as truncating overly long values.\n *\n * Only exported for tests.\n *\n * @param event event instance to be enhanced\n */\nfunction applyClientOptions(event, options) {\n  const { environment, release, dist, maxValueLength = 250 } = options;\n\n  // empty strings do not make sense for environment, release, and dist\n  // so we handle them the same as if they were not provided\n  event.environment = event.environment || environment || DEFAULT_ENVIRONMENT;\n\n  if (!event.release && release) {\n    event.release = release;\n  }\n\n  if (!event.dist && dist) {\n    event.dist = dist;\n  }\n\n  if (event.message) {\n    event.message = truncate(event.message, maxValueLength);\n  }\n\n  const exception = event.exception?.values?.[0];\n  if (exception?.value) {\n    exception.value = truncate(exception.value, maxValueLength);\n  }\n\n  const request = event.request;\n  if (request?.url) {\n    request.url = truncate(request.url, maxValueLength);\n  }\n}\n\n/**\n * Puts debug IDs into the stack frames of an error event.\n */\nfunction applyDebugIds(event, stackParser) {\n  // Build a map of filename -> debug_id\n  const filenameDebugIdMap = getFilenameToDebugIdMap(stackParser);\n\n  event.exception?.values?.forEach(exception => {\n    exception.stacktrace?.frames?.forEach(frame => {\n      if (frame.filename) {\n        frame.debug_id = filenameDebugIdMap[frame.filename];\n      }\n    });\n  });\n}\n\n/**\n * Moves debug IDs from the stack frames of an error event into the debug_meta field.\n */\nfunction applyDebugMeta(event) {\n  // Extract debug IDs and filenames from the stack frames on the event.\n  const filenameDebugIdMap = {};\n  event.exception?.values?.forEach(exception => {\n    exception.stacktrace?.frames?.forEach(frame => {\n      if (frame.debug_id) {\n        if (frame.abs_path) {\n          filenameDebugIdMap[frame.abs_path] = frame.debug_id;\n        } else if (frame.filename) {\n          filenameDebugIdMap[frame.filename] = frame.debug_id;\n        }\n        delete frame.debug_id;\n      }\n    });\n  });\n\n  if (Object.keys(filenameDebugIdMap).length === 0) {\n    return;\n  }\n\n  // Fill debug_meta information\n  event.debug_meta = event.debug_meta || {};\n  event.debug_meta.images = event.debug_meta.images || [];\n  const images = event.debug_meta.images;\n  Object.entries(filenameDebugIdMap).forEach(([filename, debug_id]) => {\n    images.push({\n      type: 'sourcemap',\n      code_file: filename,\n      debug_id,\n    });\n  });\n}\n\n/**\n * This function adds all used integrations to the SDK info in the event.\n * @param event The event that will be filled with all integrations.\n */\nfunction applyIntegrationsMetadata(event, integrationNames) {\n  if (integrationNames.length > 0) {\n    event.sdk = event.sdk || {};\n    event.sdk.integrations = [...(event.sdk.integrations || []), ...integrationNames];\n  }\n}\n\n/**\n * Applies `normalize` function on necessary `Event` attributes to make them safe for serialization.\n * Normalized keys:\n * - `breadcrumbs.data`\n * - `user`\n * - `contexts`\n * - `extra`\n * @param event Event\n * @returns Normalized event\n */\nfunction normalizeEvent(event, depth, maxBreadth) {\n  if (!event) {\n    return null;\n  }\n\n  const normalized = {\n    ...event,\n    ...(event.breadcrumbs && {\n      breadcrumbs: event.breadcrumbs.map(b => ({\n        ...b,\n        ...(b.data && {\n          data: normalize(b.data, depth, maxBreadth),\n        }),\n      })),\n    }),\n    ...(event.user && {\n      user: normalize(event.user, depth, maxBreadth),\n    }),\n    ...(event.contexts && {\n      contexts: normalize(event.contexts, depth, maxBreadth),\n    }),\n    ...(event.extra && {\n      extra: normalize(event.extra, depth, maxBreadth),\n    }),\n  };\n\n  // event.contexts.trace stores information about a Transaction. Similarly,\n  // event.spans[] stores information about child Spans. Given that a\n  // Transaction is conceptually a Span, normalization should apply to both\n  // Transactions and Spans consistently.\n  // For now the decision is to skip normalization of Transactions and Spans,\n  // so this block overwrites the normalized event to add back the original\n  // Transaction information prior to normalization.\n  if (event.contexts?.trace && normalized.contexts) {\n    normalized.contexts.trace = event.contexts.trace;\n\n    // event.contexts.trace.data may contain circular/dangerous data so we need to normalize it\n    if (event.contexts.trace.data) {\n      normalized.contexts.trace.data = normalize(event.contexts.trace.data, depth, maxBreadth);\n    }\n  }\n\n  // event.spans[].data may contain circular/dangerous data so we need to normalize it\n  if (event.spans) {\n    normalized.spans = event.spans.map(span => {\n      return {\n        ...span,\n        ...(span.data && {\n          data: normalize(span.data, depth, maxBreadth),\n        }),\n      };\n    });\n  }\n\n  // event.contexts.flags (FeatureFlagContext) stores context for our feature\n  // flag integrations. It has a greater nesting depth than our other typed\n  // Contexts, so we re-normalize with a fixed depth of 3 here. We do not want\n  // to skip this in case of conflicting, user-provided context.\n  if (event.contexts?.flags && normalized.contexts) {\n    normalized.contexts.flags = normalize(event.contexts.flags, 3, maxBreadth);\n  }\n\n  return normalized;\n}\n\nfunction getFinalScope(scope, captureContext) {\n  if (!captureContext) {\n    return scope;\n  }\n\n  const finalScope = scope ? scope.clone() : new Scope();\n  finalScope.update(captureContext);\n  return finalScope;\n}\n\n/**\n * Parse either an `EventHint` directly, or convert a `CaptureContext` to an `EventHint`.\n * This is used to allow to update method signatures that used to accept a `CaptureContext` but should now accept an `EventHint`.\n */\nfunction parseEventHintOrCaptureContext(\n  hint,\n) {\n  if (!hint) {\n    return undefined;\n  }\n\n  // If you pass a Scope or `() => Scope` as CaptureContext, we just return this as captureContext\n  if (hintIsScopeOrFunction(hint)) {\n    return { captureContext: hint };\n  }\n\n  if (hintIsScopeContext(hint)) {\n    return {\n      captureContext: hint,\n    };\n  }\n\n  return hint;\n}\n\nfunction hintIsScopeOrFunction(hint) {\n  return hint instanceof Scope || typeof hint === 'function';\n}\n\nconst captureContextKeys = [\n  'user',\n  'level',\n  'extra',\n  'contexts',\n  'tags',\n  'fingerprint',\n  'propagationContext',\n] ;\n\nfunction hintIsScopeContext(hint) {\n  return Object.keys(hint).some(key => captureContextKeys.includes(key ));\n}\n\nexport { applyClientOptions, applyDebugIds, applyDebugMeta, parseEventHintOrCaptureContext, prepareEvent };\n//# sourceMappingURL=prepareEvent.js.map\n","import { getGlobalSingleton } from '../carrier.js';\nimport { DEBUG_BUILD } from './debug-build.js';\nimport { GLOBAL_OBJ } from './worldwide.js';\n\n/** Prefix for logging strings */\nconst PREFIX = 'Sentry Logger ';\n\nconst CONSOLE_LEVELS = [\n  'debug',\n  'info',\n  'warn',\n  'error',\n  'log',\n  'assert',\n  'trace',\n] ;\n\n/** This may be mutated by the console instrumentation. */\nconst originalConsoleMethods\n\n = {};\n\n/** A Sentry Logger instance. */\n\n/**\n * Temporarily disable sentry console instrumentations.\n *\n * @param callback The function to run against the original `console` messages\n * @returns The results of the callback\n */\nfunction consoleSandbox(callback) {\n  if (!('console' in GLOBAL_OBJ)) {\n    return callback();\n  }\n\n  const console = GLOBAL_OBJ.console ;\n  const wrappedFuncs = {};\n\n  const wrappedLevels = Object.keys(originalConsoleMethods) ;\n\n  // Restore all wrapped console methods\n  wrappedLevels.forEach(level => {\n    const originalConsoleMethod = originalConsoleMethods[level] ;\n    wrappedFuncs[level] = console[level] ;\n    console[level] = originalConsoleMethod;\n  });\n\n  try {\n    return callback();\n  } finally {\n    // Revert restoration to wrapped state\n    wrappedLevels.forEach(level => {\n      console[level] = wrappedFuncs[level] ;\n    });\n  }\n}\n\nfunction makeLogger() {\n  let enabled = false;\n  const logger = {\n    enable: () => {\n      enabled = true;\n    },\n    disable: () => {\n      enabled = false;\n    },\n    isEnabled: () => enabled,\n  };\n\n  if (DEBUG_BUILD) {\n    CONSOLE_LEVELS.forEach(name => {\n      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/**\n * This is a logger singleton which either logs things or no-ops if logging is not enabled.\n * The logger is a singleton on the carrier, to ensure that a consistent logger is used throughout the SDK.\n */\nconst logger = getGlobalSingleton('logger', makeLogger);\n\nexport { CONSOLE_LEVELS, consoleSandbox, logger, originalConsoleMethods };\n//# sourceMappingURL=logger.js.map\n","/**\n * Shallow merge two objects.\n * Does not mutate the passed in objects.\n * Undefined/empty values in the merge object will overwrite existing values.\n *\n * By default, this merges 2 levels deep.\n */\nfunction merge(initialObj, mergeObj, levels = 2) {\n  // If the merge value is not an object, or we have no merge levels left,\n  // we just set the value to the merge value\n  if (!mergeObj || typeof mergeObj !== 'object' || levels <= 0) {\n    return mergeObj;\n  }\n\n  // If the merge object is an empty object, and the initial object is not undefined, we return the initial object\n  if (initialObj && Object.keys(mergeObj).length === 0) {\n    return initialObj;\n  }\n\n  // Clone object\n  const output = { ...initialObj };\n\n  // Merge values into output, resursively\n  for (const key in mergeObj) {\n    if (Object.prototype.hasOwnProperty.call(mergeObj, key)) {\n      output[key] = merge(output[key], mergeObj[key], levels - 1);\n    }\n  }\n\n  return output;\n}\n\nexport { merge };\n//# sourceMappingURL=merge.js.map\n","import { getAsyncContextStrategy } from '../asyncContext/index.js';\nimport { getMainCarrier } from '../carrier.js';\nimport { getCurrentScope } from '../currentScopes.js';\nimport { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from '../semanticAttributes.js';\nimport { SPAN_STATUS_UNSET, SPAN_STATUS_OK } from '../tracing/spanstatus.js';\nimport { getCapturedScopesOnSpan } from '../tracing/utils.js';\nimport { consoleSandbox } from '../utils-hoist/logger.js';\nimport { dropUndefinedKeys, addNonEnumerableProperty } from '../utils-hoist/object.js';\nimport { generateSpanId } from '../utils-hoist/propagationContext.js';\nimport { timestampInSeconds } from '../utils-hoist/time.js';\nimport { generateSentryTraceHeader } from '../utils-hoist/tracing.js';\nimport { _getSpanForScope } from './spanOnScope.js';\n\n// These are aligned with OpenTelemetry trace flags\nconst TRACE_FLAG_NONE = 0x0;\nconst TRACE_FLAG_SAMPLED = 0x1;\n\nlet hasShownSpanDropWarning = false;\n\n/**\n * Convert a span to a trace context, which can be sent as the `trace` context in an event.\n * By default, this will only include trace_id, span_id & parent_span_id.\n * If `includeAllData` is true, it will also include data, op, status & origin.\n */\nfunction spanToTransactionTraceContext(span) {\n  const { spanId: span_id, traceId: trace_id } = span.spanContext();\n  const { data, op, parent_span_id, status, origin, links } = spanToJSON(span);\n\n  return dropUndefinedKeys({\n    parent_span_id,\n    span_id,\n    trace_id,\n    data,\n    op,\n    status,\n    origin,\n    links,\n  });\n}\n\n/**\n * Convert a span to a trace context, which can be sent as the `trace` context in a non-transaction event.\n */\nfunction spanToTraceContext(span) {\n  const { spanId, traceId: trace_id, isRemote } = span.spanContext();\n\n  // If the span is remote, we use a random/virtual span as span_id to the trace context,\n  // and the remote span as parent_span_id\n  const parent_span_id = isRemote ? spanId : spanToJSON(span).parent_span_id;\n  const scope = getCapturedScopesOnSpan(span).scope;\n\n  const span_id = isRemote ? scope?.getPropagationContext().propagationSpanId || generateSpanId() : spanId;\n\n  return dropUndefinedKeys({\n    parent_span_id,\n    span_id,\n    trace_id,\n  });\n}\n\n/**\n * Convert a Span to a Sentry trace header.\n */\nfunction spanToTraceHeader(span) {\n  const { traceId, spanId } = span.spanContext();\n  const sampled = spanIsSampled(span);\n  return generateSentryTraceHeader(traceId, spanId, sampled);\n}\n\n/**\n *  Converts the span links array to a flattened version to be sent within an envelope.\n *\n *  If the links array is empty, it returns `undefined` so the empty value can be dropped before it's sent.\n */\nfunction convertSpanLinksForEnvelope(links) {\n  if (links && links.length > 0) {\n    return links.map(({ context: { spanId, traceId, traceFlags, ...restContext }, attributes }) => ({\n      span_id: spanId,\n      trace_id: traceId,\n      sampled: traceFlags === TRACE_FLAG_SAMPLED,\n      attributes,\n      ...restContext,\n    }));\n  } else {\n    return undefined;\n  }\n}\n\n/**\n * Convert a span time input into a timestamp in seconds.\n */\nfunction spanTimeInputToSeconds(input) {\n  if (typeof input === 'number') {\n    return ensureTimestampInSeconds(input);\n  }\n\n  if (Array.isArray(input)) {\n    // See {@link HrTime} for the array-based time format\n    return input[0] + input[1] / 1e9;\n  }\n\n  if (input instanceof Date) {\n    return ensureTimestampInSeconds(input.getTime());\n  }\n\n  return timestampInSeconds();\n}\n\n/**\n * Converts a timestamp to second, if it was in milliseconds, or keeps it as second.\n */\nfunction ensureTimestampInSeconds(timestamp) {\n  const isMs = timestamp > 9999999999;\n  return isMs ? timestamp / 1000 : timestamp;\n}\n\n/**\n * Convert a span to a JSON representation.\n */\n// Note: Because of this, we currently have a circular type dependency (which we opted out of in package.json).\n// This is not avoidable as we need `spanToJSON` in `spanUtils.ts`, which in turn is needed by `span.ts` for backwards compatibility.\n// And `spanToJSON` needs the Span class from `span.ts` to check here.\nfunction spanToJSON(span) {\n  if (spanIsSentrySpan(span)) {\n    return span.getSpanJSON();\n  }\n\n  const { spanId: span_id, traceId: trace_id } = span.spanContext();\n\n  // Handle a span from @opentelemetry/sdk-base-trace's `Span` class\n  if (spanIsOpenTelemetrySdkTraceBaseSpan(span)) {\n    const { attributes, startTime, name, endTime, parentSpanId, status, links } = span;\n\n    return dropUndefinedKeys({\n      span_id,\n      trace_id,\n      data: attributes,\n      description: name,\n      parent_span_id: parentSpanId,\n      start_timestamp: spanTimeInputToSeconds(startTime),\n      // This is [0,0] by default in OTEL, in which case we want to interpret this as no end time\n      timestamp: spanTimeInputToSeconds(endTime) || undefined,\n      status: getStatusMessage(status),\n      op: attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP],\n      origin: attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] ,\n      links: convertSpanLinksForEnvelope(links),\n    });\n  }\n\n  // Finally, at least we have `spanContext()`....\n  // This should not actually happen in reality, but we need to handle it for type safety.\n  return {\n    span_id,\n    trace_id,\n    start_timestamp: 0,\n    data: {},\n  };\n}\n\nfunction spanIsOpenTelemetrySdkTraceBaseSpan(span) {\n  const castSpan = span ;\n  return !!castSpan.attributes && !!castSpan.startTime && !!castSpan.name && !!castSpan.endTime && !!castSpan.status;\n}\n\n/** Exported only for tests. */\n\n/**\n * Sadly, due to circular dependency checks we cannot actually import the Span class here and check for instanceof.\n * :( So instead we approximate this by checking if it has the `getSpanJSON` method.\n */\nfunction spanIsSentrySpan(span) {\n  return typeof (span ).getSpanJSON === 'function';\n}\n\n/**\n * Returns true if a span is sampled.\n * In most cases, you should just use `span.isRecording()` instead.\n * However, this has a slightly different semantic, as it also returns false if the span is finished.\n * So in the case where this distinction is important, use this method.\n */\nfunction spanIsSampled(span) {\n  // We align our trace flags with the ones OpenTelemetry use\n  // So we also check for sampled the same way they do.\n  const { traceFlags } = span.spanContext();\n  return traceFlags === TRACE_FLAG_SAMPLED;\n}\n\n/** Get the status message to use for a JSON representation of a span. */\nfunction getStatusMessage(status) {\n  if (!status || status.code === SPAN_STATUS_UNSET) {\n    return undefined;\n  }\n\n  if (status.code === SPAN_STATUS_OK) {\n    return 'ok';\n  }\n\n  return status.message || 'unknown_error';\n}\n\nconst CHILD_SPANS_FIELD = '_sentryChildSpans';\nconst ROOT_SPAN_FIELD = '_sentryRootSpan';\n\n/**\n * Adds an opaque child span reference to a span.\n */\nfunction addChildSpanToSpan(span, childSpan) {\n  // We store the root span reference on the child span\n  // We need this for `getRootSpan()` to work\n  const rootSpan = span[ROOT_SPAN_FIELD] || span;\n  addNonEnumerableProperty(childSpan , ROOT_SPAN_FIELD, rootSpan);\n\n  // We store a list of child spans on the parent span\n  // We need this for `getSpanDescendants()` to work\n  if (span[CHILD_SPANS_FIELD]) {\n    span[CHILD_SPANS_FIELD].add(childSpan);\n  } else {\n    addNonEnumerableProperty(span, CHILD_SPANS_FIELD, new Set([childSpan]));\n  }\n}\n\n/** This is only used internally by Idle Spans. */\nfunction removeChildSpanFromSpan(span, childSpan) {\n  if (span[CHILD_SPANS_FIELD]) {\n    span[CHILD_SPANS_FIELD].delete(childSpan);\n  }\n}\n\n/**\n * Returns an array of the given span and all of its descendants.\n */\nfunction getSpanDescendants(span) {\n  const resultSet = new Set();\n\n  function addSpanChildren(span) {\n    // This exit condition is required to not infinitely loop in case of a circular dependency.\n    if (resultSet.has(span)) {\n      return;\n      // We want to ignore unsampled spans (e.g. non recording spans)\n    } else if (spanIsSampled(span)) {\n      resultSet.add(span);\n      const childSpans = span[CHILD_SPANS_FIELD] ? Array.from(span[CHILD_SPANS_FIELD]) : [];\n      for (const childSpan of childSpans) {\n        addSpanChildren(childSpan);\n      }\n    }\n  }\n\n  addSpanChildren(span);\n\n  return Array.from(resultSet);\n}\n\n/**\n * Returns the root span of a given span.\n */\nfunction getRootSpan(span) {\n  return span[ROOT_SPAN_FIELD] || span;\n}\n\n/**\n * Returns the currently active span.\n */\nfunction getActiveSpan() {\n  const carrier = getMainCarrier();\n  const acs = getAsyncContextStrategy(carrier);\n  if (acs.getActiveSpan) {\n    return acs.getActiveSpan();\n  }\n\n  return _getSpanForScope(getCurrentScope());\n}\n\n/**\n * Logs a warning once if `beforeSendSpan` is used to drop spans.\n */\nfunction showSpanDropWarning() {\n  if (!hasShownSpanDropWarning) {\n    consoleSandbox(() => {\n      // eslint-disable-next-line no-console\n      console.warn(\n        '[Sentry] Returning null from `beforeSendSpan` is disallowed. To drop certain spans, configure the respective integrations directly.',\n      );\n    });\n    hasShownSpanDropWarning = true;\n  }\n}\n\n/**\n * Updates the name of the given span and ensures that the span name is not\n * overwritten by the Sentry SDK.\n *\n * Use this function instead of `span.updateName()` if you want to make sure that\n * your name is kept. For some spans, for example root `http.server` spans the\n * Sentry SDK would otherwise overwrite the span name with a high-quality name\n * it infers when the span ends.\n *\n * Use this function in server code or when your span is started on the server\n * and on the client (browser). If you only update a span name on the client,\n * you can also use `span.updateName()` the SDK does not overwrite the name.\n *\n * @param span - The span to update the name of.\n * @param name - The name to set on the span.\n */\nfunction updateSpanName(span, name) {\n  span.updateName(name);\n  span.setAttributes({\n    [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'custom',\n    [SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME]: name,\n  });\n}\n\nexport { TRACE_FLAG_NONE, TRACE_FLAG_SAMPLED, addChildSpanToSpan, convertSpanLinksForEnvelope, getActiveSpan, getRootSpan, getSpanDescendants, getStatusMessage, removeChildSpanFromSpan, showSpanDropWarning, spanIsSampled, spanTimeInputToSeconds, spanToJSON, spanToTraceContext, spanToTraceHeader, spanToTransactionTraceContext, updateSpanName };\n//# sourceMappingURL=spanUtils.js.map\n","/**\n * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.\n *\n * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.\n */\nconst DEBUG_BUILD = (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__);\n\nexport { DEBUG_BUILD };\n//# sourceMappingURL=debug-build.js.map\n","const DEFAULT_ENVIRONMENT = 'production';\n\nexport { DEFAULT_ENVIRONMENT };\n//# sourceMappingURL=constants.js.map\n","import { isString } from './is.js';\nimport { GLOBAL_OBJ } from './worldwide.js';\n\nconst WINDOW = GLOBAL_OBJ ;\n\nconst DEFAULT_MAX_STRING_LENGTH = 80;\n\n/**\n * Given a child DOM element, returns a query-selector statement describing that\n * and its ancestors\n * e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nfunction htmlTreeAsString(\n  elem,\n  options = {},\n) {\n  if (!elem) {\n    return '<unknown>';\n  }\n\n  // try/catch both:\n  // - accessing event.target (see getsentry/raven-js#838, #768)\n  // - `htmlTreeAsString` because it's complex, and just accessing the DOM incorrectly\n  // - can throw an exception in some circumstances.\n  try {\n    let currentElem = elem ;\n    const MAX_TRAVERSE_HEIGHT = 5;\n    const out = [];\n    let height = 0;\n    let len = 0;\n    const separator = ' > ';\n    const sepLength = separator.length;\n    let nextStr;\n    const keyAttrs = Array.isArray(options) ? options : options.keyAttrs;\n    const maxStringLength = (!Array.isArray(options) && options.maxStringLength) || DEFAULT_MAX_STRING_LENGTH;\n\n    while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {\n      nextStr = _htmlElementAsString(currentElem, keyAttrs);\n      // bail out if\n      // - nextStr is the 'html' element\n      // - the length of the string that would be created exceeds maxStringLength\n      //   (ignore this limit if we are on the first iteration)\n      if (nextStr === 'html' || (height > 1 && len + out.length * sepLength + nextStr.length >= maxStringLength)) {\n        break;\n      }\n\n      out.push(nextStr);\n\n      len += nextStr.length;\n      currentElem = currentElem.parentNode;\n    }\n\n    return out.reverse().join(separator);\n  } catch (_oO) {\n    return '<unknown>';\n  }\n}\n\n/**\n * Returns a simple, query-selector representation of a DOM element\n * e.g. [HTMLElement] => input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nfunction _htmlElementAsString(el, keyAttrs) {\n  const elem = el\n\n;\n\n  const out = [];\n\n  if (!elem?.tagName) {\n    return '';\n  }\n\n  // @ts-expect-error WINDOW has HTMLElement\n  if (WINDOW.HTMLElement) {\n    // If using the component name annotation plugin, this value may be available on the DOM node\n    if (elem instanceof HTMLElement && elem.dataset) {\n      if (elem.dataset['sentryComponent']) {\n        return elem.dataset['sentryComponent'];\n      }\n      if (elem.dataset['sentryElement']) {\n        return elem.dataset['sentryElement'];\n      }\n    }\n  }\n\n  out.push(elem.tagName.toLowerCase());\n\n  // Pairs of attribute keys defined in `serializeAttribute` and their values on element.\n  const keyAttrPairs = keyAttrs?.length\n    ? keyAttrs.filter(keyAttr => elem.getAttribute(keyAttr)).map(keyAttr => [keyAttr, elem.getAttribute(keyAttr)])\n    : null;\n\n  if (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    const className = elem.className;\n    if (className && isString(className)) {\n      const classes = className.split(/\\s+/);\n      for (const c of classes) {\n        out.push(`.${c}`);\n      }\n    }\n  }\n  const allowedAttrs = ['aria-label', 'type', 'name', 'title', 'alt'];\n  for (const k of allowedAttrs) {\n    const attr = elem.getAttribute(k);\n    if (attr) {\n      out.push(`[${k}=\"${attr}\"]`);\n    }\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 * Given a DOM element, traverses up the tree until it finds the first ancestor node\n * that has the `data-sentry-component` or `data-sentry-element` attribute with `data-sentry-component` taking\n * precedence. This attribute is added at build-time by projects that have the component name annotation plugin installed.\n *\n * @returns a string representation of the component for the provided DOM element, or `null` if not found\n */\nfunction getComponentName(elem) {\n  // @ts-expect-error WINDOW has HTMLElement\n  if (!WINDOW.HTMLElement) {\n    return null;\n  }\n\n  let currentElem = elem ;\n  const MAX_TRAVERSE_HEIGHT = 5;\n  for (let i = 0; i < MAX_TRAVERSE_HEIGHT; i++) {\n    if (!currentElem) {\n      return null;\n    }\n\n    if (currentElem instanceof HTMLElement) {\n      if (currentElem.dataset['sentryComponent']) {\n        return currentElem.dataset['sentryComponent'];\n      }\n      if (currentElem.dataset['sentryElement']) {\n        return currentElem.dataset['sentryElement'];\n      }\n    }\n\n    currentElem = currentElem.parentNode;\n  }\n\n  return null;\n}\n\nexport { getComponentName, getLocationHref, htmlTreeAsString };\n//# sourceMappingURL=browser.js.map\n","/**\n * Service class for accessing localStorage.\n */\nexport function StorageService() {\n  /**\n   * Keys used to reference data in localStorage\n   */\n  const CJ_EVENT_KEY = 'ngStorage-cjevent';\n  const COUPON_KEY = 'ngStorage-coupon';\n  const FEE_KEY = 'ngStorage-fee';\n  const LAB_KEY = 'ngStorage-center';\n  const REORDER_KEY = 'ngStorage-reorder';\n  const TESTS_KEY = 'ngStorage-tests';\n  const TOKEN_KEY = 'ngStorage-token';\n  const ZIPCODE_KEY = 'ngStorage-zip_code';\n  const IN_HOME_KEY = 'ngStorage-in-home-booking-result';\n  const EMAIL_KEY = 'ngStorage-email';\n  const FREE_KEY = 'ngStorage-free';\n  const TRANSACTION_ID_KEY = 'transaction_id';\n  const BETTER_LAB = 'ngStorage-betterlab';\n  const IHC_PROVIDERS_KEY = 'ngStorage-ihc-providers';\n\n  /**\n   * Retrieves a value stored as JSON in localStorage\n   *\n   * @param {string} key the key to retrieve from storage\n   *\n   * @return {any}  The value stored in localStorage\n   */\n  function getLocalStorage(key) {\n    return JSON.parse(window.localStorage?.getItem(key) || null);\n  }\n\n  /**\n   * Saves a value in localStorage as a JSON string\n   *\n   * @param {string} key The key to store the value in\n   * @param {any} value  The value to be stored\n   *\n   * @return {void}\n   */\n  function setLocalStorage(key, value) {\n    window.localStorage?.setItem(key, JSON.stringify(value || null));\n  }\n\n  /**\n   * Deletes a value from the storage.\n   *\n   * @param key {string} The value's key.\n   *\n   * @return void\n   */\n  function removeLocalStorage(key) {\n    window.localStorage?.removeItem(key);\n  }\n\n  // Initialize tests in localStorage\n  if (!getLocalStorage(TESTS_KEY)) {\n    setLocalStorage(TESTS_KEY, []);\n  }\n\n  return {\n    /**\n     * Local Storage get, set and remove\n     */\n    localStorage: {\n      get: getLocalStorage,\n      set: setLocalStorage,\n      remove: removeLocalStorage,\n    },\n\n    /**\n     * Removes any reorder information from local storage\n     */\n    removeReorderInformation: function () {\n      window.localStorage?.removeItem(REORDER_KEY);\n    },\n\n    /**\n     * Removes previous order information from local storage\n     */\n    removePreviousOrderInformation: function () {\n      window.localStorage?.removeItem(TRANSACTION_ID_KEY);\n      window.localStorage?.removeItem(BETTER_LAB);\n    },\n\n    /**\n     * Retrieve coupon data from local storage\n     */\n    get coupon() {\n      return this.localStorage.get(COUPON_KEY) ?? {};\n    },\n\n    /**\n     * Store coupon data in local storage\n     */\n    set coupon(coupon) {\n      this.localStorage.set(COUPON_KEY, coupon);\n    },\n\n    /**\n     * Retrieve fee data from localStorage\n     */\n    get fee() {\n      return this.localStorage.get(FEE_KEY);\n    },\n\n    /**\n     * Store fee data in localStorage\n     */\n    set fee(fee) {\n      this.localStorage.set(FEE_KEY, fee);\n    },\n\n    /**\n     * Retrieve lab data from local storage\n     */\n    get lab() {\n      return this.localStorage.get(LAB_KEY) ?? {};\n    },\n\n    /**\n     * Store lab data in local storage\n     */\n    set lab(lab) {\n      this.localStorage.set(LAB_KEY, lab);\n    },\n\n    /**\n     * Retrieve psc data from local storage\n     */\n    get psc() {\n      return this.lab;\n    },\n\n    /**\n     * Store psc data in local storage\n     */\n    set psc(psc) {\n      this.lab = psc;\n    },\n\n    /**\n     * Retrieve selected tests data from local storage\n     */\n    get tests() {\n      return this.localStorage.get(TESTS_KEY) ?? [];\n    },\n\n    /**\n     * Store selected tests data in local storage\n     */\n    set tests(tests) {\n      this.localStorage.set(TESTS_KEY, tests);\n    },\n\n    /**\n     * Retrieve token data from localStorage\n     */\n    get token() {\n      return this.localStorage.get(TOKEN_KEY);\n    },\n\n    /**\n     * Store token data in localStorage\n     */\n    set token(token) {\n      this.localStorage.set(TOKEN_KEY, token);\n    },\n\n    /**\n     * Retrieve CJ Affiliate data from localStorage\n     */\n    get cjevent() {\n      return this.localStorage.get(CJ_EVENT_KEY);\n    },\n\n    /**\n     * Store CJ Affiliate data in localStorage\n     */\n    set cjevent(cjevent) {\n      this.localStorage.set(CJ_EVENT_KEY, cjevent);\n    },\n\n    /**\n     * Retrieve zip code data from localStorage\n     */\n    get zipCode() {\n      return this.localStorage.get(ZIPCODE_KEY);\n    },\n\n    /**\n     * Store zip code data in localStorage\n     */\n    set zipCode(zipCode) {\n      this.localStorage.set(ZIPCODE_KEY, zipCode);\n    },\n\n    get inHomeResult() {\n      return this.localStorage.get(IN_HOME_KEY);\n    },\n\n    /**\n     * Retrieve email data from local storage\n     */\n    get email() {\n      return this.localStorage.get(EMAIL_KEY) ?? {};\n    },\n\n    /**\n     * Store email data in local storage\n     */\n    set email(email) {\n      this.localStorage.set(EMAIL_KEY, email);\n    },\n\n    /**\n     * Retrieve free order data from local storage\n     */\n    get free() {\n      return this.localStorage.get(FREE_KEY) ?? {};\n    },\n\n    /**\n     * Store free order data in local storage\n     */\n    set free(free) {\n      this.localStorage.set(FREE_KEY, free);\n    },\n\n    /**\n     * Retrieve In-Home Collection provider IDs from local storage\n     */\n    get ihcProviders() {\n      return this.localStorage.get(IHC_PROVIDERS_KEY);\n    },\n\n    /**\n     * Store In-Home Collection provider IDs in local storage\n     */\n    set ihcProviders(ihcProviders) {\n      this.localStorage.set(IHC_PROVIDERS_KEY, ihcProviders);\n    },\n  };\n}\n","import { getAsyncContextStrategy } from './asyncContext/index.js';\nimport { getMainCarrier, getGlobalSingleton } from './carrier.js';\nimport { Scope } from './scope.js';\nimport './utils-hoist/debug-build.js';\nimport './utils-hoist/logger.js';\nimport './utils-hoist/time.js';\nimport './utils-hoist/syncpromise.js';\nimport { generateSpanId } from './utils-hoist/propagationContext.js';\n\n/**\n * Get the currently active scope.\n */\nfunction getCurrentScope() {\n  const carrier = getMainCarrier();\n  const acs = getAsyncContextStrategy(carrier);\n  return acs.getCurrentScope();\n}\n\n/**\n * Get the currently active isolation scope.\n * The isolation scope is active for the current execution context.\n */\nfunction getIsolationScope() {\n  const carrier = getMainCarrier();\n  const acs = getAsyncContextStrategy(carrier);\n  return acs.getIsolationScope();\n}\n\n/**\n * Get the global scope.\n * This scope is applied to _all_ events.\n */\nfunction getGlobalScope() {\n  return getGlobalSingleton('globalScope', () => new Scope());\n}\n\n/**\n * Creates a new scope with and executes the given operation within.\n * The scope is automatically removed once the operation\n * finishes or throws.\n */\n\n/**\n * Either creates a new active scope, or sets the given scope as active scope in the given callback.\n */\nfunction withScope(\n  ...rest\n) {\n  const carrier = getMainCarrier();\n  const acs = getAsyncContextStrategy(carrier);\n\n  // If a scope is defined, we want to make this the active scope instead of the default one\n  if (rest.length === 2) {\n    const [scope, callback] = rest;\n\n    if (!scope) {\n      return acs.withScope(callback);\n    }\n\n    return acs.withSetScope(scope, callback);\n  }\n\n  return acs.withScope(rest[0]);\n}\n\n/**\n * Attempts to fork the current isolation scope and the current scope based on the current async context strategy. If no\n * async context strategy is set, the isolation scope and the current scope will not be forked (this is currently the\n * case, for example, in the browser).\n *\n * Usage of this function in environments without async context strategy is discouraged and may lead to unexpected behaviour.\n *\n * This function is intended for Sentry SDK and SDK integration development. It is not recommended to be used in \"normal\"\n * applications directly because it comes with pitfalls. Use at your own risk!\n */\n\n/**\n * Either creates a new active isolation scope, or sets the given isolation scope as active scope in the given callback.\n */\nfunction withIsolationScope(\n  ...rest\n\n) {\n  const carrier = getMainCarrier();\n  const acs = getAsyncContextStrategy(carrier);\n\n  // If a scope is defined, we want to make this the active scope instead of the default one\n  if (rest.length === 2) {\n    const [isolationScope, callback] = rest;\n\n    if (!isolationScope) {\n      return acs.withIsolationScope(callback);\n    }\n\n    return acs.withSetIsolationScope(isolationScope, callback);\n  }\n\n  return acs.withIsolationScope(rest[0]);\n}\n\n/**\n * Get the currently active client.\n */\nfunction getClient() {\n  return getCurrentScope().getClient();\n}\n\n/**\n * Get a trace context for the given scope.\n */\nfunction getTraceContextFromScope(scope) {\n  const propagationContext = scope.getPropagationContext();\n\n  const { traceId, parentSpanId, propagationSpanId } = propagationContext;\n\n  const traceContext = {\n    trace_id: traceId,\n    span_id: propagationSpanId || generateSpanId(),\n  };\n\n  if (parentSpanId) {\n    traceContext.parent_span_id = parentSpanId;\n  }\n\n  return traceContext;\n}\n\nexport { getClient, getCurrentScope, getGlobalScope, getIsolationScope, getTraceContextFromScope, withIsolationScope, withScope };\n//# sourceMappingURL=currentScopes.js.map\n","import { parseSampleRate } from '../utils/parseSampleRate.js';\nimport { baggageHeaderToDynamicSamplingContext } from './baggage.js';\nimport { generateTraceId, generateSpanId } from './propagationContext.js';\n\n// eslint-disable-next-line @sentry-internal/sdk/no-regexp-constructor -- RegExp is used for readability here\nconst TRACEPARENT_REGEXP = new RegExp(\n  '^[ \\\\t]*' + // whitespace\n    '([0-9a-f]{32})?' + // trace_id\n    '-?([0-9a-f]{16})?' + // span_id\n    '-?([01])?' + // sampled\n    '[ \\\\t]*$', // whitespace\n);\n\n/**\n * Extract transaction context data from a `sentry-trace` header.\n *\n * @param traceparent Traceparent string\n *\n * @returns Object containing data from the header, or undefined if traceparent string is malformed\n */\nfunction extractTraceparentData(traceparent) {\n  if (!traceparent) {\n    return undefined;\n  }\n\n  const matches = traceparent.match(TRACEPARENT_REGEXP);\n  if (!matches) {\n    return undefined;\n  }\n\n  let parentSampled;\n  if (matches[3] === '1') {\n    parentSampled = true;\n  } else if (matches[3] === '0') {\n    parentSampled = false;\n  }\n\n  return {\n    traceId: matches[1],\n    parentSampled,\n    parentSpanId: matches[2],\n  };\n}\n\n/**\n * Create a propagation context from incoming headers or\n * creates a minimal new one if the headers are undefined.\n */\nfunction propagationContextFromHeaders(\n  sentryTrace,\n  baggage,\n) {\n  const traceparentData = extractTraceparentData(sentryTrace);\n  const dynamicSamplingContext = baggageHeaderToDynamicSamplingContext(baggage);\n\n  if (!traceparentData?.traceId) {\n    return {\n      traceId: generateTraceId(),\n      sampleRand: Math.random(),\n    };\n  }\n\n  const sampleRand = getSampleRandFromTraceparentAndDsc(traceparentData, dynamicSamplingContext);\n\n  // The sample_rand on the DSC needs to be generated based on traceparent + baggage.\n  if (dynamicSamplingContext) {\n    dynamicSamplingContext.sample_rand = sampleRand.toString();\n  }\n\n  const { traceId, parentSpanId, parentSampled } = traceparentData;\n\n  return {\n    traceId,\n    parentSpanId,\n    sampled: parentSampled,\n    dsc: dynamicSamplingContext || {}, // If we have traceparent data but no DSC it means we are not head of trace and we must freeze it\n    sampleRand,\n  };\n}\n\n/**\n * Create sentry-trace header from span context values.\n */\nfunction generateSentryTraceHeader(\n  traceId = generateTraceId(),\n  spanId = generateSpanId(),\n  sampled,\n) {\n  let sampledString = '';\n  if (sampled !== undefined) {\n    sampledString = sampled ? '-1' : '-0';\n  }\n  return `${traceId}-${spanId}${sampledString}`;\n}\n\n/**\n * Given any combination of an incoming trace, generate a sample rand based on its defined semantics.\n *\n * Read more: https://develop.sentry.dev/sdk/telemetry/traces/#propagated-random-value\n */\nfunction getSampleRandFromTraceparentAndDsc(\n  traceparentData,\n  dsc,\n) {\n  // When there is an incoming sample rand use it.\n  const parsedSampleRand = parseSampleRate(dsc?.sample_rand);\n  if (parsedSampleRand !== undefined) {\n    return parsedSampleRand;\n  }\n\n  // Otherwise, if there is an incoming sampling decision + sample rate, generate a sample rand that would lead to the same sampling decision.\n  const parsedSampleRate = parseSampleRate(dsc?.sample_rate);\n  if (parsedSampleRate && traceparentData?.parentSampled !== undefined) {\n    return traceparentData.parentSampled\n      ? // Returns a sample rand with positive sampling decision [0, sampleRate)\n        Math.random() * parsedSampleRate\n      : // Returns a sample rand with negative sampling decision [sampleRate, 1)\n        parsedSampleRate + Math.random() * (1 - parsedSampleRate);\n  } else {\n    // If nothing applies, return a random sample rand.\n    return Math.random();\n  }\n}\n\nexport { TRACEPARENT_REGEXP, extractTraceparentData, generateSentryTraceHeader, propagationContextFromHeaders };\n//# sourceMappingURL=tracing.js.map\n","import { addNonEnumerableProperty } from '../utils-hoist/object.js';\n\nconst SCOPE_ON_START_SPAN_FIELD = '_sentryScope';\nconst ISOLATION_SCOPE_ON_START_SPAN_FIELD = '_sentryIsolationScope';\n\n/** Store the scope & isolation scope for a span, which can the be used when it is finished. */\nfunction setCapturedScopesOnSpan(span, scope, isolationScope) {\n  if (span) {\n    addNonEnumerableProperty(span, ISOLATION_SCOPE_ON_START_SPAN_FIELD, isolationScope);\n    addNonEnumerableProperty(span, SCOPE_ON_START_SPAN_FIELD, scope);\n  }\n}\n\n/**\n * Grabs the scope and isolation scope off a span that were active when the span was started.\n */\nfunction getCapturedScopesOnSpan(span) {\n  return {\n    scope: (span )[SCOPE_ON_START_SPAN_FIELD],\n    isolationScope: (span )[ISOLATION_SCOPE_ON_START_SPAN_FIELD],\n  };\n}\n\nexport { getCapturedScopesOnSpan, setCapturedScopesOnSpan };\n//# sourceMappingURL=utils.js.map\n","import { DEBUG_BUILD } from './debug-build.js';\nimport { isString } from './is.js';\nimport { logger } from './logger.js';\n\nconst SENTRY_BAGGAGE_KEY_PREFIX = 'sentry-';\n\nconst SENTRY_BAGGAGE_KEY_PREFIX_REGEX = /^sentry-/;\n\n/**\n * Max length of a serialized baggage string\n *\n * https://www.w3.org/TR/baggage/#limits\n */\nconst MAX_BAGGAGE_STRING_LENGTH = 8192;\n\n/**\n * Takes a baggage header and turns it into Dynamic Sampling Context, by extracting all the \"sentry-\" prefixed values\n * from it.\n *\n * @param baggageHeader A very bread definition of a baggage header as it might appear in various frameworks.\n * @returns The Dynamic Sampling Context that was found on `baggageHeader`, if there was any, `undefined` otherwise.\n */\nfunction baggageHeaderToDynamicSamplingContext(\n  // Very liberal definition of what any incoming header might look like\n  baggageHeader,\n) {\n  const baggageObject = parseBaggageHeader(baggageHeader);\n\n  if (!baggageObject) {\n    return undefined;\n  }\n\n  // Read all \"sentry-\" prefixed values out of the baggage object and put it onto a dynamic sampling context object.\n  const dynamicSamplingContext = Object.entries(baggageObject).reduce((acc, [key, value]) => {\n    if (key.match(SENTRY_BAGGAGE_KEY_PREFIX_REGEX)) {\n      const nonPrefixedKey = key.slice(SENTRY_BAGGAGE_KEY_PREFIX.length);\n      acc[nonPrefixedKey] = value;\n    }\n    return acc;\n  }, {});\n\n  // Only return a dynamic sampling context object if there are keys in it.\n  // A keyless object means there were no sentry values on the header, which means that there is no DSC.\n  if (Object.keys(dynamicSamplingContext).length > 0) {\n    return dynamicSamplingContext ;\n  } else {\n    return undefined;\n  }\n}\n\n/**\n * Turns a Dynamic Sampling Object into a baggage header by prefixing all the keys on the object with \"sentry-\".\n *\n * @param dynamicSamplingContext The Dynamic Sampling Context to turn into a header. For convenience and compatibility\n * with the `getDynamicSamplingContext` method on the Transaction class ,this argument can also be `undefined`. If it is\n * `undefined` the function will return `undefined`.\n * @returns a baggage header, created from `dynamicSamplingContext`, or `undefined` either if `dynamicSamplingContext`\n * was `undefined`, or if `dynamicSamplingContext` didn't contain any values.\n */\nfunction dynamicSamplingContextToSentryBaggageHeader(\n  // this also takes undefined for convenience and bundle size in other places\n  dynamicSamplingContext,\n) {\n  if (!dynamicSamplingContext) {\n    return undefined;\n  }\n\n  // Prefix all DSC keys with \"sentry-\" and put them into a new object\n  const sentryPrefixedDSC = Object.entries(dynamicSamplingContext).reduce(\n    (acc, [dscKey, dscValue]) => {\n      if (dscValue) {\n        acc[`${SENTRY_BAGGAGE_KEY_PREFIX}${dscKey}`] = dscValue;\n      }\n      return acc;\n    },\n    {},\n  );\n\n  return objectToBaggageHeader(sentryPrefixedDSC);\n}\n\n/**\n * Take a baggage header and parse it into an object.\n */\nfunction parseBaggageHeader(\n  baggageHeader,\n) {\n  if (!baggageHeader || (!isString(baggageHeader) && !Array.isArray(baggageHeader))) {\n    return undefined;\n  }\n\n  if (Array.isArray(baggageHeader)) {\n    // Combine all baggage headers into one object containing the baggage values so we can later read the Sentry-DSC-values from it\n    return baggageHeader.reduce((acc, curr) => {\n      const currBaggageObject = baggageHeaderToObject(curr);\n      Object.entries(currBaggageObject).forEach(([key, value]) => {\n        acc[key] = value;\n      });\n      return acc;\n    }, {});\n  }\n\n  return baggageHeaderToObject(baggageHeader);\n}\n\n/**\n * Will parse a baggage header, which is a simple key-value map, into a flat object.\n *\n * @param baggageHeader The baggage header to parse.\n * @returns a flat object containing all the key-value pairs from `baggageHeader`.\n */\nfunction baggageHeaderToObject(baggageHeader) {\n  return baggageHeader\n    .split(',')\n    .map(baggageEntry => baggageEntry.split('=').map(keyOrValue => decodeURIComponent(keyOrValue.trim())))\n    .reduce((acc, [key, value]) => {\n      if (key && value) {\n        acc[key] = value;\n      }\n      return acc;\n    }, {});\n}\n\n/**\n * Turns a flat object (key-value pairs) into a baggage header, which is also just key-value pairs.\n *\n * @param object The object to turn into a baggage header.\n * @returns a baggage header string, or `undefined` if the object didn't have any values, since an empty baggage header\n * is not spec compliant.\n */\nfunction objectToBaggageHeader(object) {\n  if (Object.keys(object).length === 0) {\n    // An empty baggage header is not spec compliant: We return undefined.\n    return undefined;\n  }\n\n  return Object.entries(object).reduce((baggageHeader, [objectKey, objectValue], currentIndex) => {\n    const baggageEntry = `${encodeURIComponent(objectKey)}=${encodeURIComponent(objectValue)}`;\n    const newBaggageHeader = currentIndex === 0 ? baggageEntry : `${baggageHeader},${baggageEntry}`;\n    if (newBaggageHeader.length > MAX_BAGGAGE_STRING_LENGTH) {\n      DEBUG_BUILD &&\n        logger.warn(\n          `Not adding key: ${objectKey} with val: ${objectValue} to baggage header due to exceeding baggage size limits.`,\n        );\n      return baggageHeader;\n    } else {\n      return newBaggageHeader;\n    }\n  }, '');\n}\n\nexport { MAX_BAGGAGE_STRING_LENGTH, SENTRY_BAGGAGE_KEY_PREFIX, SENTRY_BAGGAGE_KEY_PREFIX_REGEX, baggageHeaderToDynamicSamplingContext, dynamicSamplingContextToSentryBaggageHeader, objectToBaggageHeader, parseBaggageHeader };\n//# sourceMappingURL=baggage.js.map\n","import './utils-hoist/debug-build.js';\nimport './utils-hoist/logger.js';\nimport { timestampInSeconds } from './utils-hoist/time.js';\nimport { uuid4 } from './utils-hoist/misc.js';\nimport './utils-hoist/syncpromise.js';\n\n/**\n * Creates a new `Session` object by setting certain default parameters. If optional @param context\n * is passed, the passed properties are applied to the session object.\n *\n * @param context (optional) additional properties to be applied to the returned session object\n *\n * @returns a new `Session` object\n */\nfunction makeSession(context) {\n  // Both timestamp and started are in seconds since the UNIX epoch.\n  const startingTime = timestampInSeconds();\n\n  const session = {\n    sid: uuid4(),\n    init: true,\n    timestamp: startingTime,\n    started: startingTime,\n    duration: 0,\n    status: 'ok',\n    errors: 0,\n    ignoreDuration: false,\n    toJSON: () => sessionToJSON(session),\n  };\n\n  if (context) {\n    updateSession(session, context);\n  }\n\n  return session;\n}\n\n/**\n * Updates a session object with the properties passed in the context.\n *\n * Note that this function mutates the passed object and returns void.\n * (Had to do this instead of returning a new and updated session because closing and sending a session\n * makes an update to the session after it was passed to the sending logic.\n * @see Client.captureSession )\n *\n * @param session the `Session` to update\n * @param context the `SessionContext` holding the properties that should be updated in @param session\n */\n// eslint-disable-next-line complexity\nfunction updateSession(session, context = {}) {\n  if (context.user) {\n    if (!session.ipAddress && context.user.ip_address) {\n      session.ipAddress = context.user.ip_address;\n    }\n\n    if (!session.did && !context.did) {\n      session.did = context.user.id || context.user.email || context.user.username;\n    }\n  }\n\n  session.timestamp = context.timestamp || timestampInSeconds();\n\n  if (context.abnormal_mechanism) {\n    session.abnormal_mechanism = context.abnormal_mechanism;\n  }\n\n  if (context.ignoreDuration) {\n    session.ignoreDuration = context.ignoreDuration;\n  }\n  if (context.sid) {\n    // Good enough uuid validation. — Kamil\n    session.sid = context.sid.length === 32 ? context.sid : uuid4();\n  }\n  if (context.init !== undefined) {\n    session.init = context.init;\n  }\n  if (!session.did && context.did) {\n    session.did = `${context.did}`;\n  }\n  if (typeof context.started === 'number') {\n    session.started = context.started;\n  }\n  if (session.ignoreDuration) {\n    session.duration = undefined;\n  } else if (typeof context.duration === 'number') {\n    session.duration = context.duration;\n  } else {\n    const duration = session.timestamp - session.started;\n    session.duration = duration >= 0 ? duration : 0;\n  }\n  if (context.release) {\n    session.release = context.release;\n  }\n  if (context.environment) {\n    session.environment = context.environment;\n  }\n  if (!session.ipAddress && context.ipAddress) {\n    session.ipAddress = context.ipAddress;\n  }\n  if (!session.userAgent && context.userAgent) {\n    session.userAgent = context.userAgent;\n  }\n  if (typeof context.errors === 'number') {\n    session.errors = context.errors;\n  }\n  if (context.status) {\n    session.status = context.status;\n  }\n}\n\n/**\n * Closes a session by setting its status and updating the session object with it.\n * Internally calls `updateSession` to update the passed session object.\n *\n * Note that this function mutates the passed session (@see updateSession for explanation).\n *\n * @param session the `Session` object to be closed\n * @param status the `SessionStatus` with which the session was closed. If you don't pass a status,\n *               this function will keep the previously set status, unless it was `'ok'` in which case\n *               it is changed to `'exited'`.\n */\nfunction closeSession(session, status) {\n  let context = {};\n  if (status) {\n    context = { status };\n  } else if (session.status === 'ok') {\n    context = { status: 'exited' };\n  }\n\n  updateSession(session, context);\n}\n\n/**\n * Serializes a passed session object to a JSON object with a slightly different structure.\n * This is necessary because the Sentry backend requires a slightly different schema of a session\n * than the one the JS SDKs use internally.\n *\n * @param session the session to be converted\n *\n * @returns a JSON object of the passed session\n */\nfunction sessionToJSON(session) {\n  return {\n    sid: `${session.sid}`,\n    init: session.init,\n    // Make sure that sec is converted to ms for date constructor\n    started: new Date(session.started * 1000).toISOString(),\n    timestamp: new Date(session.timestamp * 1000).toISOString(),\n    status: session.status,\n    errors: session.errors,\n    did: typeof session.did === 'number' || typeof session.did === 'string' ? `${session.did}` : undefined,\n    duration: session.duration,\n    abnormal_mechanism: session.abnormal_mechanism,\n    attrs: {\n      release: session.release,\n      environment: session.environment,\n      ip_address: session.ipAddress,\n      user_agent: session.userAgent,\n    },\n  };\n}\n\nexport { closeSession, makeSession, updateSession };\n//# sourceMappingURL=session.js.map\n"],"names":["generateTraceId","generateSpanId","substring","window","changeLocation","storageService","changeLocationComponentElement","document","querySelector","changeLocationWordingContainer","changeLocationContentContainer","center","bookingResult","hasCenter","Object","keys","length","id","hasInHomeCollection","centerSubtitle","centerNetworkName","title","isNetworkNameIncludedInCenterTitle","network","name","toLowerCase","includes","addEventListener","lab","innerHTML","centerTitle","scope","setExtra","JSON","stringify","this","getCenterTitle","address","city","state","zip","zip_code","classList","remove","inHomeResult","street","zipCode","dateSegments","date","split","bookingSlot","period","bookingDateAndTime","SCOPE_SPAN_FIELD","_setSpanForScope","span","_getSpanForScope","ONE_SECOND_IN_MS","dateTimestampInSeconds","Date","now","timestampInSeconds","performance","approxStartingTimeOrigin","timeOrigin","undefined","createUnixTimestampInSecondsFunc","cachedTimeOrigin","browserPerformanceTimeOrigin","threshold","performanceNow","dateNow","timeOriginDelta","Math","abs","timeOriginIsReliable","navigationStart","timing","navigationStartDelta","getBrowserTimeOrigin","STACKTRACE_FRAME_LIMIT","UNKNOWN_FUNCTION","WEBPACK_ERROR_REGEXP","STRIP_FRAME_REGEXP","createStackParser","parsers","sortedParsers","sort","a","b","map","p","stack","skipFirstLines","framesToPop","frames","lines","i","line","cleanedLine","test","replace","match","parser","frame","push","localStack","Array","from","getLastStackFrame","function","pop","reverse","slice","filename","stripSentryFramesAndReverse","stackParserFromStackParserOptions","stackParser","isArray","arr","defaultFunctionName","getFunctionName","fn","e","getFramesFromEvent","event","exception","values","forEach","value","stacktrace","_oO","States","resolvedSyncPromise","SyncPromise","resolve","rejectedSyncPromise","reason","_","reject","constructor","executor","_state","PENDING","_handlers","_runExecutor","then","onfulfilled","onrejected","result","_executeHandlers","val","onfinally","isRejected","cachedHandlers","handler","RESOLVED","_value","REJECTED","setResult","objectToString","prototype","toString","isError","wat","call","isInstanceOf","Error","isBuiltin","className","isErrorEvent","isDOMError","isDOMException","isString","isParameterizedString","isPrimitive","isPlainObject","isEvent","Event","isElement","Element","isRegExp","isThenable","Boolean","isSyntheticEvent","base","_e","isVueViewModel","__isVue","_isVue","fill","source","replacementFactory","original","wrapped","markFunctionWrapped","log","addNonEnumerableProperty","obj","defineProperty","writable","configurable","o_O","proto","getOriginalFunction","func","__sentry_original__","convertToPlainObject","message","getOwnProperties","newObj","type","target","serializeEventTarget","currentTarget","CustomEvent","detail","extractedProps","property","hasOwnProperty","extractExceptionKeysForMessage","maxLength","firstKey","includedKeys","serialized","join","dropUndefinedKeys","inputValue","_dropUndefinedKeys","Map","memoizationMap","memoVal","get","returnValue","set","input","isPojo","key","DEBUG_BUILD","__SENTRY_DEBUG__","normalize","depth","maxProperties","visit","err","ERROR","normalizeToSize","object","maxSize","normalized","encodeURI","utf8Length","memo","inner","WeakSet","has","add","delete","memoBuilder","memoize","unmemoize","Number","isFinite","stringified","_events","global","String","objName","getPrototypeOf","getConstructorName","stringifyValue","startsWith","remainingDepth","valueWithToJSON","toJSON","numAdded","visitable","visitKey","visitValue","SPAN_STATUS_UNSET","SPAN_STATUS_OK","SPAN_STATUS_ERROR","setHttpStatus","httpStatus","setAttribute","spanStatus","code","getSpanStatusFromHttpCode","setStatus","FROZEN_DSC_FIELD","freezeDscOnSpan","dsc","spanWithMaybeDsc","getDynamicSamplingContextFromClient","trace_id","client","options","getOptions","publicKey","public_key","getDsn","environment","release","emit","getDynamicSamplingContextFromScope","propagationContext","getPropagationContext","traceId","getDynamicSamplingContextFromSpan","rootSpan","rootSpanJson","rootSpanAttributes","data","traceState","spanContext","rootSpanSampleRate","applyLocalSampleRateToDsc","sample_rate","frozenDsc","traceStateDsc","dscOnTraceState","description","transaction","sampled","sample_rand","sampleRand","SDK_VERSION","parseSampleRate","sampleRate","rate","parseFloat","isNaN","truncate","str","max","safeJoin","delimiter","output","stringMatchesSomePattern","testString","patterns","requireExactStringMatch","some","pattern","isMatchingPattern","AsyncContextStack","isolationScope","assignedScope","assignedIsolationScope","_stack","_isolationScope","withScope","callback","_pushScope","maybePromiseResult","_popScope","is","res","getClient","getStackTop","getScope","getIsolationScope","clone","getAsyncContextStack","registry","sentry","withSetScope","withIsolationScope","getAsyncContextStrategy","carrier","acs","withSetIsolationScope","getCurrentScope","GLOBAL_OBJ","globalThis","captureException","hint","captureMessage","captureContext","level","context","captureEvent","isEnabled","enabled","getTransport","startSession","currentScope","userAgent","navigator","session","user","getUser","currentSession","getSession","status","endSession","setSession","_sendSessionUpdate","captureSession","end","SEMANTIC_ATTRIBUTE_SENTRY_SOURCE","SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE","SEMANTIC_ATTRIBUTE_SENTRY_OP","SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN","SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON","SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT","SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE","SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME","SEMANTIC_ATTRIBUTE_PROFILE_ID","SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME","SEMANTIC_LINK_ATTRIBUTE_LINK_TYPE","hasSpansEnabled","maybeOptions","__SENTRY_TRACING__","tracesSampleRate","tracesSampler","uuid4","crypto","gbl","msCrypto","getCrypto","getRandomByte","random","randomUUID","getRandomValues","typedArray","Uint8Array","c","getFirstException","getEventDescription","event_id","eventId","firstException","addExceptionTypeValue","addExceptionMechanism","newMechanism","currentMechanism","mechanism","handled","mergedData","checkOrSetAlreadyCaught","__sentry_captured__","isAlreadyCaptured","Scope","_notifyingListeners","_scopeListeners","_eventProcessors","_breadcrumbs","_attachments","_user","_tags","_extra","_contexts","_sdkProcessingMetadata","_propagationContext","newScope","flags","_level","_session","_transactionName","_fingerprint","_client","_lastEventId","setClient","setLastEventId","lastEventId","addScopeListener","addEventProcessor","setUser","email","ip_address","username","_notifyScopeListeners","setTags","tags","setTag","setExtras","extras","extra","setFingerprint","fingerprint","setLevel","setTransactionName","setContext","update","scopeToMerge","scopeInstance","getScopeData","contexts","clear","setPropagationContext","addBreadcrumb","breadcrumb","maxBreadcrumbs","maxCrumbs","mergedBreadcrumb","timestamp","recordDroppedEvent","getLastBreadcrumb","clearBreadcrumbs","addAttachment","attachment","clearAttachments","breadcrumbs","attachments","eventProcessors","sdkProcessingMetadata","transactionName","setSDKProcessingMetadata","newData","warn","syntheticException","originalException","getMainCarrier","getSentryCarrier","__SENTRY__","version","getGlobalSingleton","creator","notifyEventProcessors","processors","index","processor","logger","final","parsedStackResults","lastKeysCount","cachedFilenameDebugIds","mergeScopeData","mergeData","mergeAndOverwriteScopeData","merge","prop","mergeVal","prepareEvent","normalizeDepth","normalizeMaxBreadth","prepared","integrations","dist","maxValueLength","request","url","applyClientOptions","integrationNames","sdk","applyIntegrationsMetadata","filenameDebugIdMap","debugIdMap","_sentryDebugIds","debugIdKeys","reduce","acc","stackKey","parsedStack","stackFrame","debugId","getFilenameToDebugIdMap","debug_id","applyDebugIds","finalScope","getFinalScope","clientEventProcessors","getEventProcessors","applyDataToEvent","trace","dynamicSamplingContext","applySpanToEvent","concat","applyFingerprintToEvent","mergedBreadcrumbs","applyBreadcrumbsToEvent","applySdkMetadataToEvent","applyScopeDataToEvent","evt","abs_path","debug_meta","images","entries","code_file","applyDebugMeta","maxBreadth","spans","normalizeEvent","parseEventHintOrCaptureContext","hintIsScopeOrFunction","captureContextKeys","hintIsScopeContext","CONSOLE_LEVELS","originalConsoleMethods","consoleSandbox","console","wrappedFuncs","wrappedLevels","originalConsoleMethod","enable","disable","args","initialObj","mergeObj","levels","TRACE_FLAG_NONE","TRACE_FLAG_SAMPLED","hasShownSpanDropWarning","spanToTransactionTraceContext","spanId","span_id","op","parent_span_id","origin","links","spanToJSON","spanToTraceContext","isRemote","propagationSpanId","spanToTraceHeader","spanIsSampled","convertSpanLinksForEnvelope","traceFlags","restContext","attributes","spanTimeInputToSeconds","ensureTimestampInSeconds","getTime","getSpanJSON","spanIsSentrySpan","castSpan","startTime","endTime","spanIsOpenTelemetrySdkTraceBaseSpan","parentSpanId","start_timestamp","getStatusMessage","CHILD_SPANS_FIELD","ROOT_SPAN_FIELD","addChildSpanToSpan","childSpan","Set","removeChildSpanFromSpan","getSpanDescendants","resultSet","addSpanChildren","childSpans","getRootSpan","getActiveSpan","showSpanDropWarning","DEFAULT_ENVIRONMENT","WINDOW","DEFAULT_MAX_STRING_LENGTH","htmlTreeAsString","elem","currentElem","MAX_TRAVERSE_HEIGHT","out","height","len","separator","sepLength","nextStr","keyAttrs","maxStringLength","_htmlElementAsString","parentNode","el","tagName","HTMLElement","dataset","keyAttrPairs","filter","keyAttr","getAttribute","keyAttrPair","classes","allowedAttrs","k","attr","getLocationHref","location","href","oO","getComponentName","StorageService","CJ_EVENT_KEY","COUPON_KEY","FEE_KEY","LAB_KEY","TESTS_KEY","TOKEN_KEY","ZIPCODE_KEY","EMAIL_KEY","FREE_KEY","IHC_PROVIDERS_KEY","getLocalStorage","parse","localStorage","getItem","setLocalStorage","setItem","removeItem","removeReorderInformation","removePreviousOrderInformation","coupon","fee","psc","tests","token","cjevent","free","ihcProviders","getGlobalScope","rest","getTraceContextFromScope","traceContext","TRACEPARENT_REGEXP","RegExp","propagationContextFromHeaders","sentryTrace","baggage","traceparentData","traceparent","matches","parentSampled","extractTraceparentData","parsedSampleRand","parsedSampleRate","getSampleRandFromTraceparentAndDsc","generateSentryTraceHeader","sampledString","SCOPE_ON_START_SPAN_FIELD","ISOLATION_SCOPE_ON_START_SPAN_FIELD","setCapturedScopesOnSpan","getCapturedScopesOnSpan","SENTRY_BAGGAGE_KEY_PREFIX","SENTRY_BAGGAGE_KEY_PREFIX_REGEX","MAX_BAGGAGE_STRING_LENGTH","baggageHeaderToDynamicSamplingContext","baggageHeader","baggageObject","curr","currBaggageObject","baggageHeaderToObject","parseBaggageHeader","dynamicSamplingContextToSentryBaggageHeader","objectKey","objectValue","currentIndex","baggageEntry","encodeURIComponent","newBaggageHeader","objectToBaggageHeader","dscKey","dscValue","keyOrValue","decodeURIComponent","trim","makeSession","startingTime","sid","init","started","duration","errors","ignoreDuration","toISOString","did","abnormal_mechanism","attrs","ipAddress","user_agent","sessionToJSON","updateSession","closeSession"],"sourceRoot":""}