{"version":3,"file":"js/954-6e7bece70011d76e5c22.js","mappings":"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","sources":["webpack:///../../node_modules/@sentry/utils/esm/logger.js","webpack:///../../node_modules/@sentry/utils/esm/is.js","webpack:///../../node_modules/@sentry/utils/esm/browser.js","webpack:///../../node_modules/@sentry/utils/esm/string.js","webpack:///../../node_modules/@sentry/utils/esm/object.js","webpack:///../../node_modules/@sentry/utils/esm/misc.js","webpack:///../../node_modules/@sentry/core/esm/integrations/inboundfilters.js","webpack:///../../node_modules/@sentry/core/esm/integrations/functiontostring.js","webpack:///../../node_modules/@sentry/utils/esm/syncpromise.js","webpack:///../../node_modules/@sentry/hub/esm/session.js","webpack:///../../node_modules/@sentry/hub/esm/scope.js","webpack:///../../node_modules/@sentry/hub/esm/hub.js","webpack:///../../node_modules/@sentry/core/esm/integration.js","webpack:///../../node_modules/@sentry/utils/esm/stacktrace.js","webpack:///../../node_modules/@sentry/utils/esm/supports.js","webpack:///../../node_modules/@sentry/utils/esm/instrument.js","webpack:///../../node_modules/@sentry/utils/esm/error.js","webpack:///../../node_modules/@sentry/utils/esm/dsn.js","webpack:///../../node_modules/@sentry/utils/esm/envelope.js","webpack:///../../node_modules/@sentry/utils/esm/normalize.js","webpack:///../../node_modules/@sentry/utils/esm/memo.js","webpack:///../../node_modules/@sentry/core/esm/api.js","webpack:///../../node_modules/@sentry/core/esm/envelope.js","webpack:///../../node_modules/@sentry/core/esm/baseclient.js","webpack:///../../node_modules/@sentry/utils/esm/baggage.js","webpack:///../../node_modules/@sentry/core/esm/version.js","webpack:///../../node_modules/@sentry/browser/esm/eventbuilder.js","webpack:///../../node_modules/@sentry/utils/esm/severity.js","webpack:///../../node_modules/@sentry/utils/esm/url.js","webpack:///../../node_modules/@sentry/browser/esm/integrations/breadcrumbs.js","webpack:///../../node_modules/@sentry/browser/esm/transports/utils.js","webpack:///../../node_modules/@sentry/browser/esm/client.js","webpack:///../../node_modules/@sentry/utils/esm/clientreport.js","webpack:///../../node_modules/@sentry/browser/esm/stack-parsers.js","webpack:///../../node_modules/@sentry/hub/esm/exports.js","webpack:///../../node_modules/@sentry/browser/esm/helpers.js","webpack:///../../node_modules/@sentry/browser/esm/integrations/trycatch.js","webpack:///../../node_modules/@sentry/browser/esm/integrations/globalhandlers.js","webpack:///../../node_modules/@sentry/browser/esm/integrations/linkederrors.js","webpack:///../../node_modules/@sentry/browser/esm/integrations/dedupe.js","webpack:///../../node_modules/@sentry/browser/esm/integrations/httpcontext.js","webpack:///../../node_modules/@sentry/core/esm/transports/base.js","webpack:///../../node_modules/@sentry/utils/esm/promisebuffer.js","webpack:///../../node_modules/@sentry/utils/esm/ratelimit.js","webpack:///../../node_modules/@sentry/browser/esm/transports/fetch.js","webpack:///../../node_modules/@sentry/browser/esm/transports/xhr.js","webpack:///../../node_modules/@sentry/browser/esm/sdk.js","webpack:///../../node_modules/@sentry/core/esm/sdk.js","webpack:///../../node_modules/@sentry/utils/esm/global.js","webpack:///../../node_modules/@sentry/utils/esm/node.js","webpack:///../../node_modules/@sentry/utils/esm/env.js","webpack:///../../node_modules/@sentry/utils/esm/time.js","webpack:///../../node_modules/connected-react-router/esm/middleware.js","webpack:///../../node_modules/detect-passive-events/lib/index.js","webpack:///../../node_modules/react-input-mask/index.js","webpack:///../../node_modules/react-input-mask/lib/react-input-mask.production.min.js","webpack:///../../node_modules/react-redux/es/hooks/useStore.js","webpack:///../../node_modules/react-redux/es/hooks/useDispatch.js","webpack:///../../node_modules/reselect/lib/index.js"],"sourcesContent":["import { getGlobalObject, getGlobalSingleton } from './global.js';\n\n// TODO: Implement different loggers for different environments\nvar global = getGlobalObject();\n\n/** Prefix for logging strings */\nvar PREFIX = 'Sentry Logger ';\n\nvar CONSOLE_LEVELS = ['debug', 'info', 'warn', 'error', 'log', 'assert', 'trace'] ;\n\n/**\n * Temporarily disable sentry console instrumentations.\n *\n * @param callback The function to run against the original `console` messages\n * @returns The results of the callback\n */\nfunction consoleSandbox(callback) {\n  var global = getGlobalObject();\n\n  if (!('console' in global)) {\n    return callback();\n  }\n\n  var originalConsole = global.console ;\n  var wrappedLevels = {};\n\n  // Restore all wrapped console methods\n  CONSOLE_LEVELS.forEach(level => {\n    // TODO(v7): Remove this check as it's only needed for Node 6\n    var originalWrappedFunc =\n      originalConsole[level] && (originalConsole[level] ).__sentry_original__;\n    if (level in global.console && originalWrappedFunc) {\n      wrappedLevels[level] = originalConsole[level] ;\n      originalConsole[level] = originalWrappedFunc ;\n    }\n  });\n\n  try {\n    return callback();\n  } finally {\n    // Revert restoration to wrapped state\n    Object.keys(wrappedLevels).forEach(level => {\n      originalConsole[level] = wrappedLevels[level ];\n    });\n  }\n}\n\nfunction makeLogger() {\n  let enabled = false;\n  var logger = {\n    enable: () => {\n      enabled = true;\n    },\n    disable: () => {\n      enabled = false;\n    },\n  };\n\n  if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {\n    CONSOLE_LEVELS.forEach(name => {\n            logger[name] = (...args) => {\n        if (enabled) {\n          consoleSandbox(() => {\n            global.console[name](`${PREFIX}[${name}]:`, ...args);\n          });\n        }\n      };\n    });\n  } else {\n    CONSOLE_LEVELS.forEach(name => {\n      logger[name] = () => undefined;\n    });\n  }\n\n  return logger ;\n}\n\n// Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used\nlet logger;\nif ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {\n  logger = getGlobalSingleton('logger', makeLogger);\n} else {\n  logger = makeLogger();\n}\n\nexport { CONSOLE_LEVELS, consoleSandbox, logger };\n//# sourceMappingURL=logger.js.map\n","var objectToString = Object.prototype.toString;\n\n/**\n * Checks whether given value's type is one of a few Error or Error-like\n * {@link isError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isError(wat) {\n  switch (objectToString.call(wat)) {\n    case '[object Error]':\n    case '[object Exception]':\n    case '[object DOMException]':\n      return true;\n    default:\n      return isInstanceOf(wat, Error);\n  }\n}\n\nfunction isBuiltin(wat, ty) {\n  return objectToString.call(wat) === `[object ${ty}]`;\n}\n\n/**\n * Checks whether given value's type is ErrorEvent\n * {@link isErrorEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isErrorEvent(wat) {\n  return isBuiltin(wat, 'ErrorEvent');\n}\n\n/**\n * Checks whether given value's type is DOMError\n * {@link isDOMError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isDOMError(wat) {\n  return isBuiltin(wat, 'DOMError');\n}\n\n/**\n * Checks whether given value's type is DOMException\n * {@link isDOMException}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isDOMException(wat) {\n  return isBuiltin(wat, 'DOMException');\n}\n\n/**\n * Checks whether given value's type is a string\n * {@link isString}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isString(wat) {\n  return isBuiltin(wat, 'String');\n}\n\n/**\n * Checks whether given value is a primitive (undefined, null, number, boolean, string, bigint, symbol)\n * {@link isPrimitive}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isPrimitive(wat) {\n  return wat === null || (typeof wat !== 'object' && typeof wat !== 'function');\n}\n\n/**\n * Checks whether given value's type is an object literal\n * {@link isPlainObject}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isPlainObject(wat) {\n  return isBuiltin(wat, 'Object');\n}\n\n/**\n * Checks whether given value's type is an Event instance\n * {@link isEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isEvent(wat) {\n  return typeof Event !== 'undefined' && isInstanceOf(wat, Event);\n}\n\n/**\n * Checks whether given value's type is an Element instance\n * {@link isElement}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isElement(wat) {\n  return typeof Element !== 'undefined' && isInstanceOf(wat, Element);\n}\n\n/**\n * Checks whether given value's type is an regexp\n * {@link isRegExp}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isRegExp(wat) {\n  return isBuiltin(wat, 'RegExp');\n}\n\n/**\n * Checks whether given value has a then function.\n * @param wat A value to be checked.\n */\nfunction isThenable(wat) {\n    return Boolean(wat && wat.then && typeof wat.then === 'function');\n}\n\n/**\n * Checks whether given value's type is a SyntheticEvent\n * {@link isSyntheticEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isSyntheticEvent(wat) {\n  return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;\n}\n\n/**\n * Checks whether given value is NaN\n * {@link isNaN}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isNaN(wat) {\n  return typeof wat === 'number' && wat !== wat;\n}\n\n/**\n * Checks whether given value's type is an instance of provided constructor.\n * {@link isInstanceOf}.\n *\n * @param wat A value to be checked.\n * @param base A constructor to be used in a check.\n * @returns A boolean representing the result.\n */\nfunction isInstanceOf(wat, base) {\n  try {\n    return wat instanceof base;\n  } catch (_e) {\n    return false;\n  }\n}\n\nexport { isDOMError, isDOMException, isElement, isError, isErrorEvent, isEvent, isInstanceOf, isNaN, isPlainObject, isPrimitive, isRegExp, isString, isSyntheticEvent, isThenable };\n//# sourceMappingURL=is.js.map\n","import { getGlobalObject } from './global.js';\nimport { isString } from './is.js';\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(elem, keyAttrs) {\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    var MAX_TRAVERSE_HEIGHT = 5;\n    var MAX_OUTPUT_LEN = 80;\n    var out = [];\n    let height = 0;\n    let len = 0;\n    var separator = ' > ';\n    var sepLength = separator.length;\n    let nextStr;\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 MAX_OUTPUT_LEN\n      //   (ignore this limit if we are on the first iteration)\n      if (nextStr === 'html' || (height > 1 && len + out.length * sepLength + nextStr.length >= MAX_OUTPUT_LEN)) {\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  var elem = el \n\n;\n\n  var out = [];\n  let className;\n  let classes;\n  let key;\n  let attr;\n  let i;\n\n  if (!elem || !elem.tagName) {\n    return '';\n  }\n\n  out.push(elem.tagName.toLowerCase());\n\n  // Pairs of attribute keys defined in `serializeAttribute` and their values on element.\n  var keyAttrPairs =\n    keyAttrs && keyAttrs.length\n      ? keyAttrs.filter(keyAttr => elem.getAttribute(keyAttr)).map(keyAttr => [keyAttr, elem.getAttribute(keyAttr)])\n      : null;\n\n  if (keyAttrPairs && keyAttrPairs.length) {\n    keyAttrPairs.forEach(keyAttrPair => {\n      out.push(`[${keyAttrPair[0]}=\"${keyAttrPair[1]}\"]`);\n    });\n  } else {\n    if (elem.id) {\n      out.push(`#${elem.id}`);\n    }\n\n        className = elem.className;\n    if (className && isString(className)) {\n      classes = className.split(/\\s+/);\n      for (i = 0; i < classes.length; i++) {\n        out.push(`.${classes[i]}`);\n      }\n    }\n  }\n  var allowedAttrs = ['type', 'name', 'title', 'alt'];\n  for (i = 0; i < allowedAttrs.length; i++) {\n    key = allowedAttrs[i];\n    attr = elem.getAttribute(key);\n    if (attr) {\n      out.push(`[${key}=\"${attr}\"]`);\n    }\n  }\n  return out.join('');\n}\n\n/**\n * A safe form of location.href\n */\nfunction getLocationHref() {\n  var global = getGlobalObject();\n  try {\n    return global.document.location.href;\n  } catch (oO) {\n    return '';\n  }\n}\n\nexport { getLocationHref, htmlTreeAsString };\n//# sourceMappingURL=browser.js.map\n","import { isString, isRegExp } from './is.js';\n\n/**\n * Truncates given string to the maximum characters count\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string (0 = unlimited)\n * @returns string Encoded\n */\nfunction truncate(str, max = 0) {\n  if (typeof str !== 'string' || max === 0) {\n    return str;\n  }\n  return str.length <= max ? str : `${str.substr(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  var lineLength = newLine.length;\n  if (lineLength <= 150) {\n    return newLine;\n  }\n  if (colno > lineLength) {\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  var output = [];\n    for (let i = 0; i < input.length; i++) {\n    var value = input[i];\n    try {\n      output.push(String(value));\n    } catch (e) {\n      output.push('[value cannot be serialized]');\n    }\n  }\n\n  return output.join(delimiter);\n}\n\n/**\n * Checks if the value matches a regex or includes the string\n * @param value The string value to be checked against\n * @param pattern Either a regex or a string that must be contained in value\n */\nfunction isMatchingPattern(value, pattern) {\n  if (!isString(value)) {\n    return false;\n  }\n\n  if (isRegExp(pattern)) {\n    return pattern.test(value);\n  }\n  if (typeof pattern === 'string') {\n    return value.indexOf(pattern) !== -1;\n  }\n  return false;\n}\n\n/**\n * Given a string, escape characters which have meaning in the regex grammar, such that the result is safe to feed to\n * `new RegExp()`.\n *\n * Based on https://github.com/sindresorhus/escape-string-regexp. Vendored to a) reduce the size by skipping the runtime\n * type-checking, and b) ensure it gets down-compiled for old versions of Node (the published package only supports Node\n * 12+).\n *\n * @param regexString The string to escape\n * @returns An version of the string with all special regex characters escaped\n */\nfunction escapeStringForRegex(regexString) {\n  // escape the hyphen separately so we can also replace it with a unicode literal hyphen, to avoid the problems\n  // discussed in https://github.com/sindresorhus/escape-string-regexp/issues/20.\n  return regexString.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&').replace(/-/g, '\\\\x2d');\n}\n\nexport { escapeStringForRegex, isMatchingPattern, safeJoin, snipLine, truncate };\n//# sourceMappingURL=string.js.map\n","import { htmlTreeAsString } from './browser.js';\nimport { isError, isEvent, isInstanceOf, isElement, isPlainObject, isPrimitive } from './is.js';\nimport { truncate } from './string.js';\n\n/**\n * Replace a method in an object with a wrapped version of itself.\n *\n * @param source An object that contains a method to be wrapped.\n * @param name The name of the method to be wrapped.\n * @param replacementFactory A higher-order function that takes the original version of the given method and returns a\n * wrapped version. Note: The function returned by `replacementFactory` needs to be a non-arrow function, in order to\n * preserve the correct value of `this`, and the original method must be called using `origMethod.call(this, <other\n * args>)` or `origMethod.apply(this, [<other args>])` (rather than being called directly), again to preserve `this`.\n * @returns void\n */\nfunction fill(source, name, replacementFactory) {\n  if (!(name in source)) {\n    return;\n  }\n\n  var original = source[name] ;\n  var wrapped = replacementFactory(original) ;\n\n  // Make sure it's a function first, as we need to attach an empty prototype for `defineProperties` to work\n  // otherwise it'll throw \"TypeError: Object.defineProperties called on non-object\"\n  if (typeof wrapped === 'function') {\n    try {\n      markFunctionWrapped(wrapped, original);\n    } catch (_Oo) {\n      // This can throw if multiple fill happens on a global object like XMLHttpRequest\n      // Fixes https://github.com/getsentry/sentry-javascript/issues/2043\n    }\n  }\n\n  source[name] = wrapped;\n}\n\n/**\n * Defines a non-enumerable property on the given object.\n *\n * @param obj The object on which to set the property\n * @param name The name of the property to be set\n * @param value The value to which to set the property\n */\nfunction addNonEnumerableProperty(obj, name, value) {\n  Object.defineProperty(obj, name, {\n    // enumerable: false, // the default, so we can save on bundle size by not explicitly setting it\n    value: value,\n    writable: true,\n    configurable: true,\n  });\n}\n\n/**\n * Remembers the original function on the wrapped function and\n * patches up the prototype.\n *\n * @param wrapped the wrapper function\n * @param original the original function that gets wrapped\n */\nfunction markFunctionWrapped(wrapped, original) {\n  var proto = original.prototype || {};\n  wrapped.prototype = original.prototype = proto;\n  addNonEnumerableProperty(wrapped, '__sentry_original__', original);\n}\n\n/**\n * This extracts the original function if available.  See\n * `markFunctionWrapped` for more information.\n *\n * @param func the function to unwrap\n * @returns the unwrapped version of the function if available.\n */\nfunction getOriginalFunction(func) {\n  return func.__sentry_original__;\n}\n\n/**\n * Encodes given object into url-friendly format\n *\n * @param object An object that contains serializable values\n * @returns string Encoded\n */\nfunction urlEncode(object) {\n  return Object.keys(object)\n    .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(object[key])}`)\n    .join('&');\n}\n\n/**\n * Transforms any `Error` or `Event` into a plain object with all of their enumerable properties, and some of their\n * non-enumerable properties attached.\n *\n * @param value Initial source that we have to transform in order for it to be usable by the serializer\n * @returns An Event or Error turned into an object - or the value argurment itself, when value is neither an Event nor\n *  an Error.\n */\nfunction convertToPlainObject(\n  value,\n)\n\n {\n  if (isError(value)) {\n    return {\n      message: value.message,\n      name: value.name,\n      stack: value.stack,\n      ...getOwnProperties(value),\n    };\n  } else if (isEvent(value)) {\n    var 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    var extractedProps = {};\n    for (var 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  var keys = Object.keys(convertToPlainObject(exception));\n  keys.sort();\n\n  if (!keys.length) {\n    return '[object has no keys]';\n  }\n\n  if (keys[0].length >= maxLength) {\n    return truncate(keys[0], maxLength);\n  }\n\n  for (let includedKeys = keys.length; includedKeys > 0; includedKeys--) {\n    var 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  var memoizationMap = new Map();\n\n  // This function just proxies `_dropUndefinedKeys` to keep the `memoBuilder` out of this function's API\n  return _dropUndefinedKeys(inputValue, memoizationMap);\n}\n\nfunction _dropUndefinedKeys(inputValue, memoizationMap) {\n  if (isPlainObject(inputValue)) {\n    // If this node has already been visited due to a circular reference, return the object it was mapped to in the new object\n    var memoVal = memoizationMap.get(inputValue);\n    if (memoVal !== undefined) {\n      return memoVal ;\n    }\n\n    var returnValue = {};\n    // Store the mapping of this value in case we visit it again, in case of circular data\n    memoizationMap.set(inputValue, returnValue);\n\n    for (var key of Object.keys(inputValue)) {\n      if (typeof inputValue[key] !== 'undefined') {\n        returnValue[key] = _dropUndefinedKeys(inputValue[key], memoizationMap);\n      }\n    }\n\n    return returnValue ;\n  }\n\n  if (Array.isArray(inputValue)) {\n    // If this node has already been visited due to a circular reference, return the array it was mapped to in the new object\n    var memoVal = memoizationMap.get(inputValue);\n    if (memoVal !== undefined) {\n      return memoVal ;\n    }\n\n    var returnValue = [];\n    // Store the mapping of this value in case we visit it again, in case of circular data\n    memoizationMap.set(inputValue, returnValue);\n\n    inputValue.forEach((item) => {\n      returnValue.push(_dropUndefinedKeys(item, memoizationMap));\n    });\n\n    return returnValue ;\n  }\n\n  return inputValue;\n}\n\n/**\n * Ensure that something is an object.\n *\n * Turns `undefined` and `null` into `String`s and all other primitives into instances of their respective wrapper\n * classes (String, Boolean, Number, etc.). Acts as the identity function on non-primitives.\n *\n * @param wat The subject of the objectification\n * @returns A version of `wat` which can safely be used with `Object` class methods\n */\nfunction objectify(wat) {\n  let objectified;\n  switch (true) {\n    case wat === undefined || wat === null:\n      objectified = new String(wat);\n      break;\n\n    // Though symbols and bigints do have wrapper classes (`Symbol` and `BigInt`, respectively), for whatever reason\n    // those classes don't have constructors which can be used with the `new` keyword. We therefore need to cast each as\n    // an object in order to wrap it.\n    case typeof wat === 'symbol' || typeof wat === 'bigint':\n      objectified = Object(wat);\n      break;\n\n    // this will catch the remaining primitives: `String`, `Number`, and `Boolean`\n    case isPrimitive(wat):\n            objectified = new (wat ).constructor(wat);\n      break;\n\n    // by process of elimination, at this point we know that `wat` must already be an object\n    default:\n      objectified = wat;\n      break;\n  }\n  return objectified;\n}\n\nexport { addNonEnumerableProperty, convertToPlainObject, dropUndefinedKeys, extractExceptionKeysForMessage, fill, getOriginalFunction, markFunctionWrapped, objectify, urlEncode };\n//# sourceMappingURL=object.js.map\n","import { getGlobalObject } from './global.js';\nimport { addNonEnumerableProperty } from './object.js';\nimport { snipLine } from './string.js';\n\n/**\n * Extended Window interface that allows for Crypto API usage in IE browsers\n */\n\n/**\n * UUID4 generator\n *\n * @returns string Generated UUID4.\n */\nfunction uuid4() {\n  var global = getGlobalObject() ;\n  var crypto = (global.crypto || global.msCrypto) ;\n\n  if (crypto && crypto.randomUUID) {\n    return crypto.randomUUID().replace(/-/g, '');\n  }\n\n  var getRandomByte =\n    crypto && crypto.getRandomValues ? () => crypto.getRandomValues(new Uint8Array(1))[0] : () => Math.random() * 16;\n\n  // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523\n  // Concatenating the following numbers as strings results in '10000000100040008000100000000000'\n  return (([1e7] ) + 1e3 + 4e3 + 8e3 + 1e11).replace(/[018]/g, c =>\n        ((c ) ^ ((getRandomByte() & 15) >> ((c ) / 4))).toString(16),\n  );\n}\n\nfunction getFirstException(event) {\n  return event.exception && event.exception.values ? event.exception.values[0] : undefined;\n}\n\n/**\n * Extracts either message or type+value from an event that can be used for user-facing logs\n * @returns event's description\n */\nfunction getEventDescription(event) {\n  const { message, event_id: eventId } = event;\n  if (message) {\n    return message;\n  }\n\n  var 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  var exception = (event.exception = event.exception || {});\n  var values = (exception.values = exception.values || []);\n  var 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  var firstException = getFirstException(event);\n  if (!firstException) {\n    return;\n  }\n\n  var defaultMechanism = { type: 'generic', handled: true };\n  var currentMechanism = firstException.mechanism;\n  firstException.mechanism = { ...defaultMechanism, ...currentMechanism, ...newMechanism };\n\n  if (newMechanism && 'data' in newMechanism) {\n    var mergedData = { ...(currentMechanism && currentMechanism.data), ...newMechanism.data };\n    firstException.mechanism.data = mergedData;\n  }\n}\n\n// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nvar SEMVER_REGEXP =\n  /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/;\n\n/**\n * Represents Semantic Versioning object\n */\n\n/**\n * Parses input into a SemVer interface\n * @param input string representation of a semver version\n */\nfunction parseSemver(input) {\n  var match = input.match(SEMVER_REGEXP) || [];\n  var major = parseInt(match[1], 10);\n  var minor = parseInt(match[2], 10);\n  var patch = parseInt(match[3], 10);\n  return {\n    buildmetadata: match[5],\n    major: isNaN(major) ? undefined : major,\n    minor: isNaN(minor) ? undefined : minor,\n    patch: isNaN(patch) ? undefined : patch,\n    prerelease: match[4],\n  };\n}\n\n/**\n * This function adds context (pre/post/line) lines to the provided frame\n *\n * @param lines string[] containing all lines\n * @param frame StackFrame that will be mutated\n * @param linesOfContext number of context lines we want to add pre/post\n */\nfunction addContextToFrame(lines, frame, linesOfContext = 5) {\n  var lineno = frame.lineno || 0;\n  var maxLines = lines.length;\n  var sourceLine = Math.max(Math.min(maxLines, lineno - 1), 0);\n\n  frame.pre_context = lines\n    .slice(Math.max(0, sourceLine - linesOfContext), sourceLine)\n    .map((line) => snipLine(line, 0));\n\n  frame.context_line = snipLine(lines[Math.min(maxLines - 1, sourceLine)], frame.colno || 0);\n\n  frame.post_context = lines\n    .slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext)\n    .map((line) => snipLine(line, 0));\n}\n\n/**\n * Checks whether or not we've already captured the given exception (note: not an identical exception - the very object\n * in question), and marks it captured if not.\n *\n * This is useful because it's possible for an error to get captured by more than one mechanism. After we intercept and\n * record an error, we rethrow it (assuming we've intercepted it before it's reached the top-level global handlers), so\n * that we don't interfere with whatever effects the error might have had were the SDK not there. At that point, because\n * the error has been rethrown, it's possible for it to bubble up to some other code we've instrumented. If it's not\n * caught after that, it will bubble all the way up to the global handlers (which of course we also instrument). This\n * function helps us ensure that even if we encounter the same error more than once, we only record it the first time we\n * see it.\n *\n * Note: It will ignore primitives (always return `false` and not mark them as seen), as properties can't be set on\n * them. {@link: Object.objectify} can be used on exceptions to convert any that are primitives into their equivalent\n * object wrapper forms so that this check will always work. However, because we need to flag the exact object which\n * will get rethrown, and because that rethrowing happens outside of the event processing pipeline, the objectification\n * must be done before the exception captured.\n *\n * @param A thrown exception to check or flag as having been seen\n * @returns `true` if the exception has already been captured, `false` if not (with the side effect of marking it seen)\n */\nfunction checkOrSetAlreadyCaught(exception) {\n    if (exception && (exception ).__sentry_captured__) {\n    return true;\n  }\n\n  try {\n    // set it this way rather than by assignment so that it's not ennumerable and therefore isn't recorded by the\n    // `ExtraErrorData` integration\n    addNonEnumerableProperty(exception , '__sentry_captured__', true);\n  } catch (err) {\n    // `exception` is a primitive, so we can't mark it seen\n  }\n\n  return false;\n}\n\nexport { addContextToFrame, addExceptionMechanism, addExceptionTypeValue, checkOrSetAlreadyCaught, getEventDescription, parseSemver, uuid4 };\n//# sourceMappingURL=misc.js.map\n","import { logger, getEventDescription, isMatchingPattern } from '@sentry/utils';\n\n// \"Script error.\" is hard coded into browsers for errors that it can't read.\n// this is the result of a script being pulled in from an external domain and CORS.\nvar DEFAULT_IGNORE_ERRORS = [/^Script error\\.?$/, /^Javascript error: Script error\\.? on line 0$/];\n\n/** Options for the InboundFilters integration */\n\n/** Inbound filters configurable by the user */\nclass InboundFilters  {\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = 'InboundFilters';}\n\n  /**\n   * @inheritDoc\n   */\n   __init() {this.name = InboundFilters.id;}\n\n   constructor(  _options = {}) {;this._options = _options;InboundFilters.prototype.__init.call(this);}\n\n  /**\n   * @inheritDoc\n   */\n   setupOnce(addGlobalEventProcessor, getCurrentHub) {\n    var eventProcess = (event) => {\n      var hub = getCurrentHub();\n      if (hub) {\n        var self = hub.getIntegration(InboundFilters);\n        if (self) {\n          var client = hub.getClient();\n          var clientOptions = client ? client.getOptions() : {};\n          var options = _mergeOptions(self._options, clientOptions);\n          return _shouldDropEvent(event, options) ? null : event;\n        }\n      }\n      return event;\n    };\n\n    eventProcess.id = this.name;\n    addGlobalEventProcessor(eventProcess);\n  }\n} InboundFilters.__initStatic();\n\n/** JSDoc */\nfunction _mergeOptions(\n  internalOptions = {},\n  clientOptions = {},\n) {\n  return {\n    allowUrls: [...(internalOptions.allowUrls || []), ...(clientOptions.allowUrls || [])],\n    denyUrls: [...(internalOptions.denyUrls || []), ...(clientOptions.denyUrls || [])],\n    ignoreErrors: [\n      ...(internalOptions.ignoreErrors || []),\n      ...(clientOptions.ignoreErrors || []),\n      ...DEFAULT_IGNORE_ERRORS,\n    ],\n    ignoreInternal: internalOptions.ignoreInternal !== undefined ? internalOptions.ignoreInternal : true,\n  };\n}\n\n/** JSDoc */\nfunction _shouldDropEvent(event, options) {\n  if (options.ignoreInternal && _isSentryError(event)) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.warn(`Event dropped due to being internal Sentry Error.\\nEvent: ${getEventDescription(event)}`);\n    return true;\n  }\n  if (_isIgnoredError(event, options.ignoreErrors)) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.warn(\n        `Event dropped due to being matched by \\`ignoreErrors\\` option.\\nEvent: ${getEventDescription(event)}`,\n      );\n    return true;\n  }\n  if (_isDeniedUrl(event, options.denyUrls)) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.warn(\n        `Event dropped due to being matched by \\`denyUrls\\` option.\\nEvent: ${getEventDescription(\n          event,\n        )}.\\nUrl: ${_getEventFilterUrl(event)}`,\n      );\n    return true;\n  }\n  if (!_isAllowedUrl(event, options.allowUrls)) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.warn(\n        `Event dropped due to not being matched by \\`allowUrls\\` option.\\nEvent: ${getEventDescription(\n          event,\n        )}.\\nUrl: ${_getEventFilterUrl(event)}`,\n      );\n    return true;\n  }\n  return false;\n}\n\nfunction _isIgnoredError(event, ignoreErrors) {\n  if (!ignoreErrors || !ignoreErrors.length) {\n    return false;\n  }\n\n  return _getPossibleEventMessages(event).some(message =>\n    ignoreErrors.some(pattern => isMatchingPattern(message, pattern)),\n  );\n}\n\nfunction _isDeniedUrl(event, denyUrls) {\n  // TODO: Use Glob instead?\n  if (!denyUrls || !denyUrls.length) {\n    return false;\n  }\n  var url = _getEventFilterUrl(event);\n  return !url ? false : denyUrls.some(pattern => isMatchingPattern(url, pattern));\n}\n\nfunction _isAllowedUrl(event, allowUrls) {\n  // TODO: Use Glob instead?\n  if (!allowUrls || !allowUrls.length) {\n    return true;\n  }\n  var url = _getEventFilterUrl(event);\n  return !url ? true : allowUrls.some(pattern => isMatchingPattern(url, pattern));\n}\n\nfunction _getPossibleEventMessages(event) {\n  if (event.message) {\n    return [event.message];\n  }\n  if (event.exception) {\n    try {\n      const { type = '', value = '' } = (event.exception.values && event.exception.values[0]) || {};\n      return [`${value}`, `${type}: ${value}`];\n    } catch (oO) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error(`Cannot extract message for event ${getEventDescription(event)}`);\n      return [];\n    }\n  }\n  return [];\n}\n\nfunction _isSentryError(event) {\n  try {\n    // @ts-ignore can't be a sentry error if undefined\n        return event.exception.values[0].type === 'SentryError';\n  } catch (e) {\n    // ignore\n  }\n  return false;\n}\n\nfunction _getLastValidUrl(frames = []) {\n  for (let i = frames.length - 1; i >= 0; i--) {\n    var frame = frames[i];\n\n    if (frame && frame.filename !== '<anonymous>' && frame.filename !== '[native code]') {\n      return frame.filename || null;\n    }\n  }\n\n  return null;\n}\n\nfunction _getEventFilterUrl(event) {\n  try {\n    let frames;\n    try {\n      // @ts-ignore we only care about frames if the whole thing here is defined\n      frames = event.exception.values[0].stacktrace.frames;\n    } catch (e) {\n      // ignore\n    }\n    return frames ? _getLastValidUrl(frames) : null;\n  } catch (oO) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error(`Cannot extract url for event ${getEventDescription(event)}`);\n    return null;\n  }\n}\n\nexport { InboundFilters, _mergeOptions, _shouldDropEvent };\n//# sourceMappingURL=inboundfilters.js.map\n","import { getOriginalFunction } from '@sentry/utils';\n\nlet originalFunctionToString;\n\n/** Patch toString calls to return proper name for wrapped functions */\nclass FunctionToString  {constructor() { FunctionToString.prototype.__init.call(this); }\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = 'FunctionToString';}\n\n  /**\n   * @inheritDoc\n   */\n   __init() {this.name = FunctionToString.id;}\n\n  /**\n   * @inheritDoc\n   */\n   setupOnce() {\n        originalFunctionToString = Function.prototype.toString;\n\n        Function.prototype.toString = function ( ...args) {\n      var context = getOriginalFunction(this) || this;\n      return originalFunctionToString.apply(context, args);\n    };\n  }\n} FunctionToString.__initStatic();\n\nexport { FunctionToString };\n//# sourceMappingURL=functiontostring.js.map\n","import { isThenable } from './is.js';\n\n/** SyncPromise internal states */\nvar States; (function (States) {\n  /** Pending */\n  var PENDING = 0; States[States[\"PENDING\"] = PENDING] = \"PENDING\";\n  /** Resolved / OK */\n  var RESOLVED = 1; States[States[\"RESOLVED\"] = RESOLVED] = \"RESOLVED\";\n  /** Rejected / Error */\n  var REJECTED = 2; States[States[\"REJECTED\"] = REJECTED] = \"REJECTED\";\n})(States || (States = {}));\n\n// Overloads so we can call resolvedSyncPromise without arguments and generic argument\n\n/**\n * Creates a resolved sync promise.\n *\n * @param value the value to resolve the promise with\n * @returns the resolved sync promise\n */\nfunction resolvedSyncPromise(value) {\n  return new SyncPromise(resolve => {\n    resolve(value);\n  });\n}\n\n/**\n * Creates a rejected sync promise.\n *\n * @param value the value to reject the promise with\n * @returns the rejected sync promise\n */\nfunction rejectedSyncPromise(reason) {\n  return new SyncPromise((_, reject) => {\n    reject(reason);\n  });\n}\n\n/**\n * Thenable class that behaves like a Promise and follows it's interface\n * but is not async internally\n */\nclass SyncPromise {\n   __init() {this._state = States.PENDING;}\n   __init2() {this._handlers = [];}\n  \n\n   constructor(\n    executor,\n  ) {;SyncPromise.prototype.__init.call(this);SyncPromise.prototype.__init2.call(this);SyncPromise.prototype.__init3.call(this);SyncPromise.prototype.__init4.call(this);SyncPromise.prototype.__init5.call(this);SyncPromise.prototype.__init6.call(this);\n    try {\n      executor(this._resolve, this._reject);\n    } catch (e) {\n      this._reject(e);\n    }\n  }\n\n  /** JSDoc */\n   then(\n    onfulfilled,\n    onrejected,\n  ) {\n    return new SyncPromise((resolve, reject) => {\n      this._handlers.push([\n        false,\n        result => {\n          if (!onfulfilled) {\n            // TODO: ¯\\_(ツ)_/¯\n            // TODO: FIXME\n            resolve(result );\n          } else {\n            try {\n              resolve(onfulfilled(result));\n            } catch (e) {\n              reject(e);\n            }\n          }\n        },\n        reason => {\n          if (!onrejected) {\n            reject(reason);\n          } else {\n            try {\n              resolve(onrejected(reason));\n            } catch (e) {\n              reject(e);\n            }\n          }\n        },\n      ]);\n      this._executeHandlers();\n    });\n  }\n\n  /** JSDoc */\n   catch(\n    onrejected,\n  ) {\n    return this.then(val => val, onrejected);\n  }\n\n  /** JSDoc */\n   finally(onfinally) {\n    return new SyncPromise((resolve, reject) => {\n      let val;\n      let isRejected;\n\n      return this.then(\n        value => {\n          isRejected = false;\n          val = value;\n          if (onfinally) {\n            onfinally();\n          }\n        },\n        reason => {\n          isRejected = true;\n          val = reason;\n          if (onfinally) {\n            onfinally();\n          }\n        },\n      ).then(() => {\n        if (isRejected) {\n          reject(val);\n          return;\n        }\n\n        resolve(val );\n      });\n    });\n  }\n\n  /** JSDoc */\n    __init3() {this._resolve = (value) => {\n    this._setResult(States.RESOLVED, value);\n  };}\n\n  /** JSDoc */\n    __init4() {this._reject = (reason) => {\n    this._setResult(States.REJECTED, reason);\n  };}\n\n  /** JSDoc */\n    __init5() {this._setResult = (state, value) => {\n    if (this._state !== States.PENDING) {\n      return;\n    }\n\n    if (isThenable(value)) {\n      void (value ).then(this._resolve, this._reject);\n      return;\n    }\n\n    this._state = state;\n    this._value = value;\n\n    this._executeHandlers();\n  };}\n\n  /** JSDoc */\n    __init6() {this._executeHandlers = () => {\n    if (this._state === States.PENDING) {\n      return;\n    }\n\n    var 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\nexport { SyncPromise, rejectedSyncPromise, resolvedSyncPromise };\n//# sourceMappingURL=syncpromise.js.map\n","import { timestampInSeconds, uuid4, dropUndefinedKeys } from '@sentry/utils';\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  var startingTime = timestampInSeconds();\n\n  var 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 BaseClient.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 */\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.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    var 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 dropUndefinedKeys({\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    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","import { isPlainObject, dateTimestampInSeconds, getGlobalSingleton, SyncPromise, logger, isThenable } from '@sentry/utils';\nimport { updateSession } from './session.js';\n\n/**\n * Absolute maximum number of breadcrumbs added to an event.\n * The `maxBreadcrumbs` option cannot be higher than this value.\n */\nvar MAX_BREADCRUMBS = 100;\n\n/**\n * Holds additional event information. {@link Scope.applyToEvent} will be\n * called by the client before an event will be sent.\n */\nclass Scope  {\n  /** Flag if notifying is happening. */\n  \n\n  /** Callback for client to receive scope changes. */\n  \n\n  /** Callback list that will be called after {@link applyToEvent}. */\n  \n\n  /** Array of breadcrumbs. */\n  \n\n  /** User */\n  \n\n  /** Tags */\n  \n\n  /** Extra */\n  \n\n  /** Contexts */\n  \n\n  /** Attachments */\n  \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\n  /** Fingerprint */\n  \n\n  /** Severity */\n    \n\n  /** Transaction Name */\n  \n\n  /** Span */\n  \n\n  /** Session */\n  \n\n  /** Request Mode Session Status */\n  \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  }\n\n  /**\n   * Inherit values from the parent scope.\n   * @param scope to clone.\n   */\n   static clone(scope) {\n    var newScope = new Scope();\n    if (scope) {\n      newScope._breadcrumbs = [...scope._breadcrumbs];\n      newScope._tags = { ...scope._tags };\n      newScope._extra = { ...scope._extra };\n      newScope._contexts = { ...scope._contexts };\n      newScope._user = scope._user;\n      newScope._level = scope._level;\n      newScope._span = scope._span;\n      newScope._session = scope._session;\n      newScope._transactionName = scope._transactionName;\n      newScope._fingerprint = scope._fingerprint;\n      newScope._eventProcessors = [...scope._eventProcessors];\n      newScope._requestSession = scope._requestSession;\n      newScope._attachments = [...scope._attachments];\n    }\n    return newScope;\n  }\n\n  /**\n   * Add internal on change listener. Used for sub SDKs that need to store the scope.\n   * @hidden\n   */\n   addScopeListener(callback) {\n    this._scopeListeners.push(callback);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   addEventProcessor(callback) {\n    this._eventProcessors.push(callback);\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setUser(user) {\n    this._user = user || {};\n    if (this._session) {\n      updateSession(this._session, { user });\n    }\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getUser() {\n    return this._user;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getRequestSession() {\n    return this._requestSession;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setRequestSession(requestSession) {\n    this._requestSession = requestSession;\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setTags(tags) {\n    this._tags = {\n      ...this._tags,\n      ...tags,\n    };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setTag(key, value) {\n    this._tags = { ...this._tags, [key]: value };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setExtras(extras) {\n    this._extra = {\n      ...this._extra,\n      ...extras,\n    };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setExtra(key, extra) {\n    this._extra = { ...this._extra, [key]: extra };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setFingerprint(fingerprint) {\n    this._fingerprint = fingerprint;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setLevel(\n        level,\n  ) {\n    this._level = level;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setTransactionName(name) {\n    this._transactionName = name;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setContext(key, context) {\n    if (context === null) {\n            delete this._contexts[key];\n    } else {\n      this._contexts = { ...this._contexts, [key]: context };\n    }\n\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setSpan(span) {\n    this._span = span;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getSpan() {\n    return this._span;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getTransaction() {\n    // Often, this span (if it exists at all) will be a transaction, but it's not guaranteed to be. Regardless, it will\n    // have a pointer to the currently-active transaction.\n    var span = this.getSpan();\n    return span && span.transaction;\n  }\n\n  /**\n   * @inheritDoc\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   * @inheritDoc\n   */\n   getSession() {\n    return this._session;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   update(captureContext) {\n    if (!captureContext) {\n      return this;\n    }\n\n    if (typeof captureContext === 'function') {\n      var updatedScope = (captureContext )(this);\n      return updatedScope instanceof Scope ? updatedScope : this;\n    }\n\n    if (captureContext instanceof Scope) {\n      this._tags = { ...this._tags, ...captureContext._tags };\n      this._extra = { ...this._extra, ...captureContext._extra };\n      this._contexts = { ...this._contexts, ...captureContext._contexts };\n      if (captureContext._user && Object.keys(captureContext._user).length) {\n        this._user = captureContext._user;\n      }\n      if (captureContext._level) {\n        this._level = captureContext._level;\n      }\n      if (captureContext._fingerprint) {\n        this._fingerprint = captureContext._fingerprint;\n      }\n      if (captureContext._requestSession) {\n        this._requestSession = captureContext._requestSession;\n      }\n    } else if (isPlainObject(captureContext)) {\n            captureContext = captureContext ;\n      this._tags = { ...this._tags, ...captureContext.tags };\n      this._extra = { ...this._extra, ...captureContext.extra };\n      this._contexts = { ...this._contexts, ...captureContext.contexts };\n      if (captureContext.user) {\n        this._user = captureContext.user;\n      }\n      if (captureContext.level) {\n        this._level = captureContext.level;\n      }\n      if (captureContext.fingerprint) {\n        this._fingerprint = captureContext.fingerprint;\n      }\n      if (captureContext.requestSession) {\n        this._requestSession = captureContext.requestSession;\n      }\n    }\n\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   clear() {\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._requestSession = undefined;\n    this._span = undefined;\n    this._session = undefined;\n    this._notifyScopeListeners();\n    this._attachments = [];\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   addBreadcrumb(breadcrumb, maxBreadcrumbs) {\n    var maxCrumbs = typeof maxBreadcrumbs === 'number' ? Math.min(maxBreadcrumbs, MAX_BREADCRUMBS) : 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    var mergedBreadcrumb = {\n      timestamp: dateTimestampInSeconds(),\n      ...breadcrumb,\n    };\n    this._breadcrumbs = [...this._breadcrumbs, mergedBreadcrumb].slice(-maxCrumbs);\n    this._notifyScopeListeners();\n\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   clearBreadcrumbs() {\n    this._breadcrumbs = [];\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   addAttachment(attachment) {\n    this._attachments.push(attachment);\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getAttachments() {\n    return this._attachments;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   clearAttachments() {\n    this._attachments = [];\n    return this;\n  }\n\n  /**\n   * Applies the current context and fingerprint to the event.\n   * Note that breadcrumbs will be added by the client.\n   * Also if the event has already breadcrumbs on it, we do not merge them.\n   * @param event Event\n   * @param hint May contain additional information about the original exception.\n   * @hidden\n   */\n   applyToEvent(event, hint = {}) {\n    if (this._extra && Object.keys(this._extra).length) {\n      event.extra = { ...this._extra, ...event.extra };\n    }\n    if (this._tags && Object.keys(this._tags).length) {\n      event.tags = { ...this._tags, ...event.tags };\n    }\n    if (this._user && Object.keys(this._user).length) {\n      event.user = { ...this._user, ...event.user };\n    }\n    if (this._contexts && Object.keys(this._contexts).length) {\n      event.contexts = { ...this._contexts, ...event.contexts };\n    }\n    if (this._level) {\n      event.level = this._level;\n    }\n    if (this._transactionName) {\n      event.transaction = this._transactionName;\n    }\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 (this._span) {\n      event.contexts = { trace: this._span.getTraceContext(), ...event.contexts };\n      var transactionName = this._span.transaction && this._span.transaction.name;\n      if (transactionName) {\n        event.tags = { transaction: transactionName, ...event.tags };\n      }\n    }\n\n    this._applyFingerprint(event);\n\n    event.breadcrumbs = [...(event.breadcrumbs || []), ...this._breadcrumbs];\n    event.breadcrumbs = event.breadcrumbs.length > 0 ? event.breadcrumbs : undefined;\n\n    event.sdkProcessingMetadata = { ...event.sdkProcessingMetadata, ...this._sdkProcessingMetadata };\n\n    return this._notifyEventProcessors([...getGlobalEventProcessors(), ...this._eventProcessors], event, hint);\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 = { ...this._sdkProcessingMetadata, ...newData };\n\n    return this;\n  }\n\n  /**\n   * This will be called after {@link applyToEvent} is finished.\n   */\n   _notifyEventProcessors(\n    processors,\n    event,\n    hint,\n    index = 0,\n  ) {\n    return new SyncPromise((resolve, reject) => {\n      var processor = processors[index];\n      if (event === null || typeof processor !== 'function') {\n        resolve(event);\n      } else {\n        var result = processor({ ...event }, hint) ;\n\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n          processor.id &&\n          result === null &&\n          logger.log(`Event processor \"${processor.id}\" dropped event`);\n\n        if (isThenable(result)) {\n          void result\n            .then(final => this._notifyEventProcessors(processors, final, hint, index + 1).then(resolve))\n            .then(null, reject);\n        } else {\n          void this._notifyEventProcessors(processors, result, hint, index + 1)\n            .then(resolve)\n            .then(null, reject);\n        }\n      }\n    });\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  /**\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   */\n   _applyFingerprint(event) {\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 (this._fingerprint) {\n      event.fingerprint = event.fingerprint.concat(this._fingerprint);\n    }\n\n    // If we have no data at all, remove empty array default\n    if (event.fingerprint && !event.fingerprint.length) {\n      delete event.fingerprint;\n    }\n  }\n}\n\n/**\n * Returns the global event processors.\n */\nfunction getGlobalEventProcessors() {\n  return getGlobalSingleton('globalEventProcessors', () => []);\n}\n\n/**\n * Add a EventProcessor to be kept globally.\n * @param callback EventProcessor to add\n */\nfunction addGlobalEventProcessor(callback) {\n  getGlobalEventProcessors().push(callback);\n}\n\nexport { Scope, addGlobalEventProcessor };\n//# sourceMappingURL=scope.js.map\n","import { uuid4, dateTimestampInSeconds, consoleSandbox, logger, getGlobalObject, getGlobalSingleton, isNodeEnv } from '@sentry/utils';\nimport { Scope } from './scope.js';\nimport { closeSession, makeSession, updateSession } from './session.js';\n\n/**\n * API compatibility version of this hub.\n *\n * WARNING: This number should only be increased when the global interface\n * changes and new methods are introduced.\n *\n * @hidden\n */\nvar API_VERSION = 4;\n\n/**\n * Default maximum number of breadcrumbs added to an event. Can be overwritten\n * with {@link Options.maxBreadcrumbs}.\n */\nvar DEFAULT_BREADCRUMBS = 100;\n\n/**\n * A layer in the process stack.\n * @hidden\n */\n\n/**\n * @inheritDoc\n */\nclass Hub  {\n  /** Is a {@link Layer}[] containing the client and scope */\n    __init() {this._stack = [{}];}\n\n  /** Contains the last event id of a captured event.  */\n  \n\n  /**\n   * Creates a new instance of the hub, will push one {@link Layer} into the\n   * internal stack on creation.\n   *\n   * @param client bound to the hub.\n   * @param scope bound to the hub.\n   * @param version number, higher number means higher priority.\n   */\n   constructor(client, scope = new Scope(),   _version = API_VERSION) {;this._version = _version;Hub.prototype.__init.call(this);\n    this.getStackTop().scope = scope;\n    if (client) {\n      this.bindClient(client);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   isOlderThan(version) {\n    return this._version < version;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   bindClient(client) {\n    var top = this.getStackTop();\n    top.client = client;\n    if (client && client.setupIntegrations) {\n      client.setupIntegrations();\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   pushScope() {\n    // We want to clone the content of prev scope\n    var scope = Scope.clone(this.getScope());\n    this.getStack().push({\n      client: this.getClient(),\n      scope,\n    });\n    return scope;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   popScope() {\n    if (this.getStack().length <= 1) return false;\n    return !!this.getStack().pop();\n  }\n\n  /**\n   * @inheritDoc\n   */\n   withScope(callback) {\n    var scope = this.pushScope();\n    try {\n      callback(scope);\n    } finally {\n      this.popScope();\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getClient() {\n    return this.getStackTop().client ;\n  }\n\n  /** Returns the scope of the top stack. */\n   getScope() {\n    return this.getStackTop().scope;\n  }\n\n  /** Returns the scope stack for domains or the process. */\n   getStack() {\n    return this._stack;\n  }\n\n  /** Returns the topmost scope layer in the order domain > local > process. */\n   getStackTop() {\n    return this._stack[this._stack.length - 1];\n  }\n\n  /**\n   * @inheritDoc\n   */\n     captureException(exception, hint) {\n    var eventId = (this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4());\n    var syntheticException = new Error('Sentry syntheticException');\n    this._withClient((client, scope) => {\n      client.captureException(\n        exception,\n        {\n          originalException: exception,\n          syntheticException,\n          ...hint,\n          event_id: eventId,\n        },\n        scope,\n      );\n    });\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureMessage(\n    message,\n        level,\n    hint,\n  ) {\n    var eventId = (this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4());\n    var syntheticException = new Error(message);\n    this._withClient((client, scope) => {\n      client.captureMessage(\n        message,\n        level,\n        {\n          originalException: message,\n          syntheticException,\n          ...hint,\n          event_id: eventId,\n        },\n        scope,\n      );\n    });\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureEvent(event, hint) {\n    var eventId = hint && hint.event_id ? hint.event_id : uuid4();\n    if (event.type !== 'transaction') {\n      this._lastEventId = eventId;\n    }\n\n    this._withClient((client, scope) => {\n      client.captureEvent(event, { ...hint, event_id: eventId }, scope);\n    });\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   lastEventId() {\n    return this._lastEventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   addBreadcrumb(breadcrumb, hint) {\n    const { scope, client } = this.getStackTop();\n\n    if (!scope || !client) return;\n\n        const { beforeBreadcrumb = null, maxBreadcrumbs = DEFAULT_BREADCRUMBS } =\n      (client.getOptions && client.getOptions()) || {};\n\n    if (maxBreadcrumbs <= 0) return;\n\n    var timestamp = dateTimestampInSeconds();\n    var mergedBreadcrumb = { timestamp, ...breadcrumb };\n    var finalBreadcrumb = beforeBreadcrumb\n      ? (consoleSandbox(() => beforeBreadcrumb(mergedBreadcrumb, hint)) )\n      : mergedBreadcrumb;\n\n    if (finalBreadcrumb === null) return;\n\n    scope.addBreadcrumb(finalBreadcrumb, maxBreadcrumbs);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setUser(user) {\n    var scope = this.getScope();\n    if (scope) scope.setUser(user);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setTags(tags) {\n    var scope = this.getScope();\n    if (scope) scope.setTags(tags);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setExtras(extras) {\n    var scope = this.getScope();\n    if (scope) scope.setExtras(extras);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setTag(key, value) {\n    var scope = this.getScope();\n    if (scope) scope.setTag(key, value);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setExtra(key, extra) {\n    var scope = this.getScope();\n    if (scope) scope.setExtra(key, extra);\n  }\n\n  /**\n   * @inheritDoc\n   */\n     setContext(name, context) {\n    var scope = this.getScope();\n    if (scope) scope.setContext(name, context);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   configureScope(callback) {\n    const { scope, client } = this.getStackTop();\n    if (scope && client) {\n      callback(scope);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   run(callback) {\n    var oldHub = makeMain(this);\n    try {\n      callback(this);\n    } finally {\n      makeMain(oldHub);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getIntegration(integration) {\n    var client = this.getClient();\n    if (!client) return null;\n    try {\n      return client.getIntegration(integration);\n    } catch (_oO) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(`Cannot retrieve integration ${integration.id} from the current Hub`);\n      return null;\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   startTransaction(context, customSamplingContext) {\n    return this._callExtensionMethod('startTransaction', context, customSamplingContext);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   traceHeaders() {\n    return this._callExtensionMethod('traceHeaders');\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureSession(endSession = false) {\n    // both send the update and pull the session from the scope\n    if (endSession) {\n      return this.endSession();\n    }\n\n    // only send the update\n    this._sendSessionUpdate();\n  }\n\n  /**\n   * @inheritDoc\n   */\n   endSession() {\n    var layer = this.getStackTop();\n    var scope = layer && layer.scope;\n    var session = scope && scope.getSession();\n    if (session) {\n      closeSession(session);\n    }\n    this._sendSessionUpdate();\n\n    // the session is over; take it off of the scope\n    if (scope) {\n      scope.setSession();\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   startSession(context) {\n    const { scope, client } = this.getStackTop();\n    const { release, environment } = (client && client.getOptions()) || {};\n\n    // Will fetch userAgent if called from browser sdk\n    var global = getGlobalObject();\n    const { userAgent } = global.navigator || {};\n\n    var session = makeSession({\n      release,\n      environment,\n      ...(scope && { user: scope.getUser() }),\n      ...(userAgent && { userAgent }),\n      ...context,\n    });\n\n    if (scope) {\n      // End existing session if there's one\n      var currentSession = scope.getSession && scope.getSession();\n      if (currentSession && currentSession.status === 'ok') {\n        updateSession(currentSession, { status: 'exited' });\n      }\n      this.endSession();\n\n      // Afterwards we set the new session on the scope\n      scope.setSession(session);\n    }\n\n    return session;\n  }\n\n  /**\n   * Returns if default PII should be sent to Sentry and propagated in ourgoing requests\n   * when Tracing is used.\n   */\n   shouldSendDefaultPii() {\n    var client = this.getClient();\n    var options = client && client.getOptions();\n    return Boolean(options && options.sendDefaultPii);\n  }\n\n  /**\n   * Sends the current Session on the scope\n   */\n   _sendSessionUpdate() {\n    const { scope, client } = this.getStackTop();\n    if (!scope) return;\n\n    var session = scope.getSession();\n    if (session) {\n      if (client && client.captureSession) {\n        client.captureSession(session);\n      }\n    }\n  }\n\n  /**\n   * Internal helper function to call a method on the top client if it exists.\n   *\n   * @param method The method to call on the client.\n   * @param args Arguments to pass to the client function.\n   */\n   _withClient(callback) {\n    const { scope, client } = this.getStackTop();\n    if (client) {\n      callback(client, scope);\n    }\n  }\n\n  /**\n   * Calls global extension method and binding current instance to the function call\n   */\n  // @ts-ignore Function lacks ending return statement and return type does not include 'undefined'. ts(2366)\n     _callExtensionMethod(method, ...args) {\n    var carrier = getMainCarrier();\n    var sentry = carrier.__SENTRY__;\n    if (sentry && sentry.extensions && typeof sentry.extensions[method] === 'function') {\n      return sentry.extensions[method].apply(this, args);\n    }\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(`Extension method ${method} couldn't be found, doing nothing.`);\n  }\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  var carrier = getGlobalObject();\n  carrier.__SENTRY__ = carrier.__SENTRY__ || {\n    extensions: {},\n    hub: undefined,\n  };\n  return carrier;\n}\n\n/**\n * Replaces the current main hub with the passed one on the global object\n *\n * @returns The old replaced hub\n */\nfunction makeMain(hub) {\n  var registry = getMainCarrier();\n  var oldHub = getHubFromCarrier(registry);\n  setHubOnCarrier(registry, hub);\n  return oldHub;\n}\n\n/**\n * Returns the default hub instance.\n *\n * If a hub is already registered in the global carrier but this module\n * contains a more recent version, it replaces the registered version.\n * Otherwise, the currently registered hub will be returned.\n */\nfunction getCurrentHub() {\n  // Get main carrier (global for every environment)\n  var registry = getMainCarrier();\n\n  // If there's no hub, or its an old API, assign a new one\n  if (!hasHubOnCarrier(registry) || getHubFromCarrier(registry).isOlderThan(API_VERSION)) {\n    setHubOnCarrier(registry, new Hub());\n  }\n\n  // Prefer domains over global if they are there (applicable only to Node environment)\n  if (isNodeEnv()) {\n    return getHubFromActiveDomain(registry);\n  }\n  // Return hub that lives on a global object\n  return getHubFromCarrier(registry);\n}\n\n/**\n * Try to read the hub from an active domain, and fallback to the registry if one doesn't exist\n * @returns discovered hub\n */\nfunction getHubFromActiveDomain(registry) {\n  try {\n    var sentry = getMainCarrier().__SENTRY__;\n    var activeDomain = sentry && sentry.extensions && sentry.extensions.domain && sentry.extensions.domain.active;\n\n    // If there's no active domain, just return global hub\n    if (!activeDomain) {\n      return getHubFromCarrier(registry);\n    }\n\n    // If there's no hub on current domain, or it's an old API, assign a new one\n    if (!hasHubOnCarrier(activeDomain) || getHubFromCarrier(activeDomain).isOlderThan(API_VERSION)) {\n      var registryHubTopStack = getHubFromCarrier(registry).getStackTop();\n      setHubOnCarrier(activeDomain, new Hub(registryHubTopStack.client, Scope.clone(registryHubTopStack.scope)));\n    }\n\n    // Return hub that lives on a domain\n    return getHubFromCarrier(activeDomain);\n  } catch (_Oo) {\n    // Return hub that lives on a global object\n    return getHubFromCarrier(registry);\n  }\n}\n\n/**\n * This will tell whether a carrier has a hub on it or not\n * @param carrier object\n */\nfunction hasHubOnCarrier(carrier) {\n  return !!(carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub);\n}\n\n/**\n * This will create a new {@link Hub} and add to the passed object on\n * __SENTRY__.hub.\n * @param carrier object\n * @hidden\n */\nfunction getHubFromCarrier(carrier) {\n  return getGlobalSingleton('hub', () => new Hub(), carrier);\n}\n\n/**\n * This will set passed {@link Hub} on the passed object's __SENTRY__.hub attribute\n * @param carrier object\n * @param hub Hub\n * @returns A boolean indicating success or failure\n */\nfunction setHubOnCarrier(carrier, hub) {\n  if (!carrier) return false;\n  var __SENTRY__ = (carrier.__SENTRY__ = carrier.__SENTRY__ || {});\n  __SENTRY__.hub = hub;\n  return true;\n}\n\nexport { API_VERSION, Hub, getCurrentHub, getHubFromCarrier, getMainCarrier, makeMain, setHubOnCarrier };\n//# sourceMappingURL=hub.js.map\n","import { addGlobalEventProcessor, getCurrentHub } from '@sentry/hub';\nimport { logger } from '@sentry/utils';\n\nvar installedIntegrations = [];\n\n/** Map of integrations assigned to a client */\n\n/**\n * @private\n */\nfunction filterDuplicates(integrations) {\n  return integrations.reduce((acc, integrations) => {\n    if (acc.every(accIntegration => integrations.name !== accIntegration.name)) {\n      acc.push(integrations);\n    }\n    return acc;\n  }, [] );\n}\n\n/** Gets integration to install */\nfunction getIntegrationsToSetup(options) {\n  var defaultIntegrations = (options.defaultIntegrations && [...options.defaultIntegrations]) || [];\n  var userIntegrations = options.integrations;\n\n  let integrations = [...filterDuplicates(defaultIntegrations)];\n\n  if (Array.isArray(userIntegrations)) {\n    // Filter out integrations that are also included in user options\n    integrations = [\n      ...integrations.filter(integrations =>\n        userIntegrations.every(userIntegration => userIntegration.name !== integrations.name),\n      ),\n      // And filter out duplicated user options integrations\n      ...filterDuplicates(userIntegrations),\n    ];\n  } else if (typeof userIntegrations === 'function') {\n    integrations = userIntegrations(integrations);\n    integrations = Array.isArray(integrations) ? integrations : [integrations];\n  }\n\n  // Make sure that if present, `Debug` integration will always run last\n  var integrationsNames = integrations.map(i => i.name);\n  var alwaysLastToRun = 'Debug';\n  if (integrationsNames.indexOf(alwaysLastToRun) !== -1) {\n    integrations.push(...integrations.splice(integrationsNames.indexOf(alwaysLastToRun), 1));\n  }\n\n  return integrations;\n}\n\n/**\n * Given a list of integration instances this installs them all. When `withDefaults` is set to `true` then all default\n * integrations are added unless they were already provided before.\n * @param integrations array of integration instances\n * @param withDefault should enable default integrations\n */\nfunction setupIntegrations(integrations) {\n  var integrationIndex = {};\n\n  integrations.forEach(integration => {\n    integrationIndex[integration.name] = integration;\n\n    if (installedIntegrations.indexOf(integration.name) === -1) {\n      integration.setupOnce(addGlobalEventProcessor, getCurrentHub);\n      installedIntegrations.push(integration.name);\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`Integration installed: ${integration.name}`);\n    }\n  });\n\n  return integrationIndex;\n}\n\nexport { getIntegrationsToSetup, installedIntegrations, setupIntegrations };\n//# sourceMappingURL=integration.js.map\n","import { _optionalChain } from './buildPolyfills';\n\nvar STACKTRACE_LIMIT = 50;\n\n/**\n * Creates a stack parser with the supplied line parsers\n *\n * StackFrames are returned in the correct order for Sentry Exception\n * frames and with Sentry SDK internal frames removed from the top and bottom\n *\n */\nfunction createStackParser(...parsers) {\n  var sortedParsers = parsers.sort((a, b) => a[0] - b[0]).map(p => p[1]);\n\n  return (stack, skipFirst = 0) => {\n    var frames = [];\n\n    for (var line of stack.split('\\n').slice(skipFirst)) {\n      // https://github.com/getsentry/sentry-javascript/issues/5459\n      // Remove webpack (error: *) wrappers\n      var cleanedLine = line.replace(/\\(error: (.*)\\)/, '$1');\n\n      for (var parser of sortedParsers) {\n        var frame = parser(cleanedLine);\n\n        if (frame) {\n          frames.push(frame);\n          break;\n        }\n      }\n    }\n\n    return stripSentryFramesAndReverse(frames);\n  };\n}\n\n/**\n * Gets a stack parser implementation from Options.stackParser\n * @see Options\n *\n * If options contains an array of line parsers, it is converted into a parser\n */\nfunction stackParserFromStackParserOptions(stackParser) {\n  if (Array.isArray(stackParser)) {\n    return createStackParser(...stackParser);\n  }\n  return stackParser;\n}\n\n/**\n * @hidden\n */\nfunction stripSentryFramesAndReverse(stack) {\n  if (!stack.length) {\n    return [];\n  }\n\n  let localStack = stack;\n\n  var firstFrameFunction = localStack[0].function || '';\n  var lastFrameFunction = localStack[localStack.length - 1].function || '';\n\n  // If stack starts with one of our API calls, remove it (starts, meaning it's the top of the stack - aka last call)\n  if (firstFrameFunction.indexOf('captureMessage') !== -1 || firstFrameFunction.indexOf('captureException') !== -1) {\n    localStack = localStack.slice(1);\n  }\n\n  // If stack ends with one of our internal API calls, remove it (ends, meaning it's the bottom of the stack - aka top-most call)\n  if (lastFrameFunction.indexOf('sentryWrapped') !== -1) {\n    localStack = localStack.slice(0, -1);\n  }\n\n  // The frame where the crash happened, should be the last entry in the array\n  return localStack\n    .slice(0, STACKTRACE_LIMIT)\n    .map(frame => ({\n      ...frame,\n      filename: frame.filename || localStack[0].filename,\n      function: frame.function || '?',\n    }))\n    .reverse();\n}\n\nvar 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\nfunction node(getModule) {\n  var FILENAME_MATCH = /^\\s*[-]{4,}$/;\n  var FULL_MATCH = /at (?:async )?(?:(.+?)\\s+\\()?(?:(.+):(\\d+):(\\d+)?|([^)]+))\\)?/;\n\n    return (line) => {\n    if (line.match(FILENAME_MATCH)) {\n      return {\n        filename: line,\n      };\n    }\n\n    var lineMatch = line.match(FULL_MATCH);\n    if (!lineMatch) {\n      return undefined;\n    }\n\n    let object;\n    let method;\n    let functionName;\n    let typeName;\n    let methodName;\n\n    if (lineMatch[1]) {\n      functionName = lineMatch[1];\n\n      let methodStart = functionName.lastIndexOf('.');\n      if (functionName[methodStart - 1] === '.') {\n                methodStart--;\n      }\n\n      if (methodStart > 0) {\n        object = functionName.substr(0, methodStart);\n        method = functionName.substr(methodStart + 1);\n        var objectEnd = object.indexOf('.Module');\n        if (objectEnd > 0) {\n          functionName = functionName.substr(objectEnd + 1);\n          object = object.substr(0, objectEnd);\n        }\n      }\n      typeName = undefined;\n    }\n\n    if (method) {\n      typeName = object;\n      methodName = method;\n    }\n\n    if (method === '<anonymous>') {\n      methodName = undefined;\n      functionName = undefined;\n    }\n\n    if (functionName === undefined) {\n      methodName = methodName || '<anonymous>';\n      functionName = typeName ? `${typeName}.${methodName}` : methodName;\n    }\n\n    var filename = _optionalChain([lineMatch, 'access', _ => _[2], 'optionalAccess', _2 => _2.startsWith, 'call', _3 => _3('file://')]) ? lineMatch[2].substr(7) : lineMatch[2];\n    var isNative = lineMatch[5] === 'native';\n    var isInternal =\n      isNative || (filename && !filename.startsWith('/') && !filename.startsWith('.') && filename.indexOf(':\\\\') !== 1);\n\n    // in_app is all that's not an internal Node function or a module within node_modules\n    // note that isNative appears to return true even for node core libraries\n    // see https://github.com/getsentry/raven-node/issues/176\n    var in_app = !isInternal && filename !== undefined && !filename.includes('node_modules/');\n\n    return {\n      filename,\n      module: _optionalChain([getModule, 'optionalCall', _4 => _4(filename)]),\n      function: functionName,\n      lineno: parseInt(lineMatch[3], 10) || undefined,\n      colno: parseInt(lineMatch[4], 10) || undefined,\n      in_app,\n    };\n  };\n}\n\n/**\n * Node.js stack line parser\n *\n * This is in @sentry/utils so it can be used from the Electron SDK in the browser for when `nodeIntegration == true`.\n * This allows it to be used without referencing or importing any node specific code which causes bundlers to complain\n */\nfunction nodeStackLineParser(getModule) {\n  return [90, node(getModule)];\n}\n\nexport { createStackParser, getFunctionName, nodeStackLineParser, stackParserFromStackParserOptions, stripSentryFramesAndReverse };\n//# sourceMappingURL=stacktrace.js.map\n","import { getGlobalObject } from './global.js';\nimport { logger } from './logger.js';\n\n/**\n * Tells whether current environment supports ErrorEvent objects\n * {@link supportsErrorEvent}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsErrorEvent() {\n  try {\n    new ErrorEvent('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports DOMError objects\n * {@link supportsDOMError}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsDOMError() {\n  try {\n    // Chrome: VM89:1 Uncaught TypeError: Failed to construct 'DOMError':\n    // 1 argument required, but only 0 present.\n    // @ts-ignore It really needs 1 argument, not 0.\n    new DOMError('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports DOMException objects\n * {@link supportsDOMException}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsDOMException() {\n  try {\n    new DOMException('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports Fetch API\n * {@link supportsFetch}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsFetch() {\n  if (!('fetch' in getGlobalObject())) {\n    return false;\n  }\n\n  try {\n    new Headers();\n    new Request('');\n    new Response();\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n/**\n * isNativeFetch checks if the given function is a native implementation of fetch()\n */\nfunction isNativeFetch(func) {\n  return func && /^function fetch\\(\\)\\s+\\{\\s+\\[native code\\]\\s+\\}$/.test(func.toString());\n}\n\n/**\n * Tells whether current environment supports Fetch API natively\n * {@link supportsNativeFetch}.\n *\n * @returns true if `window.fetch` is natively implemented, false otherwise\n */\nfunction supportsNativeFetch() {\n  if (!supportsFetch()) {\n    return false;\n  }\n\n  var global = getGlobalObject();\n\n  // Fast path to avoid DOM I/O\n    if (isNativeFetch(global.fetch)) {\n    return true;\n  }\n\n  // window.fetch is implemented, but is polyfilled or already wrapped (e.g: by a chrome extension)\n  // so create a \"pure\" iframe to see if that has native fetch\n  let result = false;\n  var doc = global.document;\n    if (doc && typeof (doc.createElement ) === 'function') {\n    try {\n      var sandbox = doc.createElement('iframe');\n      sandbox.hidden = true;\n      doc.head.appendChild(sandbox);\n      if (sandbox.contentWindow && sandbox.contentWindow.fetch) {\n                result = isNativeFetch(sandbox.contentWindow.fetch);\n      }\n      doc.head.removeChild(sandbox);\n    } catch (err) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);\n    }\n  }\n\n  return result;\n}\n\n/**\n * Tells whether current environment supports ReportingObserver API\n * {@link supportsReportingObserver}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsReportingObserver() {\n  return 'ReportingObserver' in getGlobalObject();\n}\n\n/**\n * Tells whether current environment supports Referrer Policy API\n * {@link supportsReferrerPolicy}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsReferrerPolicy() {\n  // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default'\n  // (see https://caniuse.com/#feat=referrer-policy),\n  // it doesn't. And it throws an exception instead of ignoring this parameter...\n  // REF: https://github.com/getsentry/raven-js/issues/1233\n\n  if (!supportsFetch()) {\n    return false;\n  }\n\n  try {\n    new Request('_', {\n      referrerPolicy: 'origin' ,\n    });\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports History API\n * {@link supportsHistory}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsHistory() {\n  // NOTE: in Chrome App environment, touching history.pushState, *even inside\n  //       a try/catch block*, will cause Chrome to output an error to console.error\n  // borrowed from: https://github.com/angular/angular.js/pull/13945/files\n  var global = getGlobalObject();\n      var chrome = (global ).chrome;\n  var isChromePackagedApp = chrome && chrome.app && chrome.app.runtime;\n    var hasHistoryApi = 'history' in global && !!global.history.pushState && !!global.history.replaceState;\n\n  return !isChromePackagedApp && hasHistoryApi;\n}\n\nexport { isNativeFetch, supportsDOMError, supportsDOMException, supportsErrorEvent, supportsFetch, supportsHistory, supportsNativeFetch, supportsReferrerPolicy, supportsReportingObserver };\n//# sourceMappingURL=supports.js.map\n","import { getGlobalObject } from './global.js';\nimport { isInstanceOf, isString } from './is.js';\nimport { logger, CONSOLE_LEVELS } from './logger.js';\nimport { fill } from './object.js';\nimport { getFunctionName } from './stacktrace.js';\nimport { supportsNativeFetch, supportsHistory } from './supports.js';\n\nvar global = getGlobalObject();\n\n/**\n * Instrument native APIs to call handlers that can be used to create breadcrumbs, APM spans etc.\n *  - Console API\n *  - Fetch API\n *  - XHR API\n *  - History API\n *  - DOM API (click/typing)\n *  - Error API\n *  - UnhandledRejection API\n */\n\nvar handlers = {};\nvar instrumented = {};\n\n/** Instruments given API */\nfunction instrument(type) {\n  if (instrumented[type]) {\n    return;\n  }\n\n  instrumented[type] = true;\n\n  switch (type) {\n    case 'console':\n      instrumentConsole();\n      break;\n    case 'dom':\n      instrumentDOM();\n      break;\n    case 'xhr':\n      instrumentXHR();\n      break;\n    case 'fetch':\n      instrumentFetch();\n      break;\n    case 'history':\n      instrumentHistory();\n      break;\n    case 'error':\n      instrumentError();\n      break;\n    case 'unhandledrejection':\n      instrumentUnhandledRejection();\n      break;\n    default:\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('unknown instrumentation type:', type);\n      return;\n  }\n}\n\n/**\n * Add handler that will be called when given type of instrumentation triggers.\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addInstrumentationHandler(type, callback) {\n  handlers[type] = handlers[type] || [];\n  (handlers[type] ).push(callback);\n  instrument(type);\n}\n\n/** JSDoc */\nfunction triggerHandlers(type, data) {\n  if (!type || !handlers[type]) {\n    return;\n  }\n\n  for (var handler of handlers[type] || []) {\n    try {\n      handler(data);\n    } catch (e) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.error(\n          `Error while triggering instrumentation handler.\\nType: ${type}\\nName: ${getFunctionName(handler)}\\nError:`,\n          e,\n        );\n    }\n  }\n}\n\n/** JSDoc */\nfunction instrumentConsole() {\n  if (!('console' in global)) {\n    return;\n  }\n\n  CONSOLE_LEVELS.forEach(function (level) {\n    if (!(level in global.console)) {\n      return;\n    }\n\n    fill(global.console, level, function (originalConsoleMethod) {\n      return function (...args) {\n        triggerHandlers('console', { args, level });\n\n        // this fails for some browsers. :(\n        if (originalConsoleMethod) {\n          originalConsoleMethod.apply(global.console, args);\n        }\n      };\n    });\n  });\n}\n\n/** JSDoc */\nfunction instrumentFetch() {\n  if (!supportsNativeFetch()) {\n    return;\n  }\n\n  fill(global, 'fetch', function (originalFetch) {\n    return function (...args) {\n      var handlerData = {\n        args,\n        fetchData: {\n          method: getFetchMethod(args),\n          url: getFetchUrl(args),\n        },\n        startTimestamp: Date.now(),\n      };\n\n      triggerHandlers('fetch', {\n        ...handlerData,\n      });\n\n            return originalFetch.apply(global, args).then(\n        (response) => {\n          triggerHandlers('fetch', {\n            ...handlerData,\n            endTimestamp: Date.now(),\n            response,\n          });\n          return response;\n        },\n        (error) => {\n          triggerHandlers('fetch', {\n            ...handlerData,\n            endTimestamp: Date.now(),\n            error,\n          });\n          // NOTE: If you are a Sentry user, and you are seeing this stack frame,\n          //       it means the sentry.javascript SDK caught an error invoking your application code.\n          //       This is expected behavior and NOT indicative of a bug with sentry.javascript.\n          throw error;\n        },\n      );\n    };\n  });\n}\n\n/** Extract `method` from fetch call arguments */\nfunction getFetchMethod(fetchArgs = []) {\n  if ('Request' in global && isInstanceOf(fetchArgs[0], Request) && fetchArgs[0].method) {\n    return String(fetchArgs[0].method).toUpperCase();\n  }\n  if (fetchArgs[1] && fetchArgs[1].method) {\n    return String(fetchArgs[1].method).toUpperCase();\n  }\n  return 'GET';\n}\n\n/** Extract `url` from fetch call arguments */\nfunction getFetchUrl(fetchArgs = []) {\n  if (typeof fetchArgs[0] === 'string') {\n    return fetchArgs[0];\n  }\n  if ('Request' in global && isInstanceOf(fetchArgs[0], Request)) {\n    return fetchArgs[0].url;\n  }\n  return String(fetchArgs[0]);\n}\n\n/** JSDoc */\nfunction instrumentXHR() {\n  if (!('XMLHttpRequest' in global)) {\n    return;\n  }\n\n  var xhrproto = XMLHttpRequest.prototype;\n\n  fill(xhrproto, 'open', function (originalOpen) {\n    return function ( ...args) {\n            var xhr = this;\n      var url = args[1];\n      var xhrInfo = (xhr.__sentry_xhr__ = {\n                method: isString(args[0]) ? args[0].toUpperCase() : args[0],\n        url: args[1],\n      });\n\n      // if Sentry key appears in URL, don't capture it as a request\n            if (isString(url) && xhrInfo.method === 'POST' && url.match(/sentry_key/)) {\n        xhr.__sentry_own_request__ = true;\n      }\n\n      var onreadystatechangeHandler = function () {\n        if (xhr.readyState === 4) {\n          try {\n            // touching statusCode in some platforms throws\n            // an exception\n            xhrInfo.status_code = xhr.status;\n          } catch (e) {\n            /* do nothing */\n          }\n\n          triggerHandlers('xhr', {\n            args,\n            endTimestamp: Date.now(),\n            startTimestamp: Date.now(),\n            xhr,\n          });\n        }\n      };\n\n      if ('onreadystatechange' in xhr && typeof xhr.onreadystatechange === 'function') {\n        fill(xhr, 'onreadystatechange', function (original) {\n          return function (...readyStateArgs) {\n            onreadystatechangeHandler();\n            return original.apply(xhr, readyStateArgs);\n          };\n        });\n      } else {\n        xhr.addEventListener('readystatechange', onreadystatechangeHandler);\n      }\n\n      return originalOpen.apply(xhr, args);\n    };\n  });\n\n  fill(xhrproto, 'send', function (originalSend) {\n    return function ( ...args) {\n      if (this.__sentry_xhr__ && args[0] !== undefined) {\n        this.__sentry_xhr__.body = args[0];\n      }\n\n      triggerHandlers('xhr', {\n        args,\n        startTimestamp: Date.now(),\n        xhr: this,\n      });\n\n      return originalSend.apply(this, args);\n    };\n  });\n}\n\nlet lastHref;\n\n/** JSDoc */\nfunction instrumentHistory() {\n  if (!supportsHistory()) {\n    return;\n  }\n\n  var oldOnPopState = global.onpopstate;\n  global.onpopstate = function ( ...args) {\n    var to = global.location.href;\n    // keep track of the current URL state, as we always receive only the updated state\n    var from = lastHref;\n    lastHref = to;\n    triggerHandlers('history', {\n      from,\n      to,\n    });\n    if (oldOnPopState) {\n      // Apparently this can throw in Firefox when incorrectly implemented plugin is installed.\n      // https://github.com/getsentry/sentry-javascript/issues/3344\n      // https://github.com/bugsnag/bugsnag-js/issues/469\n      try {\n        return oldOnPopState.apply(this, args);\n      } catch (_oO) {\n        // no-empty\n      }\n    }\n  };\n\n  /** @hidden */\n  function historyReplacementFunction(originalHistoryFunction) {\n    return function ( ...args) {\n      var url = args.length > 2 ? args[2] : undefined;\n      if (url) {\n        // coerce to string (this is what pushState does)\n        var from = lastHref;\n        var to = String(url);\n        // keep track of the current URL state, as we always receive only the updated state\n        lastHref = to;\n        triggerHandlers('history', {\n          from,\n          to,\n        });\n      }\n      return originalHistoryFunction.apply(this, args);\n    };\n  }\n\n  fill(global.history, 'pushState', historyReplacementFunction);\n  fill(global.history, 'replaceState', historyReplacementFunction);\n}\n\nvar debounceDuration = 1000;\nlet debounceTimerID;\nlet lastCapturedEvent;\n\n/**\n * Decide whether the current event should finish the debounce of previously captured one.\n * @param previous previously captured event\n * @param current event to be captured\n */\nfunction shouldShortcircuitPreviousDebounce(previous, current) {\n  // If there was no previous event, it should always be swapped for the new one.\n  if (!previous) {\n    return true;\n  }\n\n  // If both events have different type, then user definitely performed two separate actions. e.g. click + keypress.\n  if (previous.type !== current.type) {\n    return true;\n  }\n\n  try {\n    // If both events have the same type, it's still possible that actions were performed on different targets.\n    // e.g. 2 clicks on different buttons.\n    if (previous.target !== current.target) {\n      return true;\n    }\n  } catch (e) {\n    // just accessing `target` property can throw an exception in some rare circumstances\n    // see: https://github.com/getsentry/sentry-javascript/issues/838\n  }\n\n  // If both events have the same type _and_ same `target` (an element which triggered an event, _not necessarily_\n  // to which an event listener was attached), we treat them as the same action, as we want to capture\n  // only one breadcrumb. e.g. multiple clicks on the same button, or typing inside a user input box.\n  return false;\n}\n\n/**\n * Decide whether an event should be captured.\n * @param event event to be captured\n */\nfunction shouldSkipDOMEvent(event) {\n  // We are only interested in filtering `keypress` events for now.\n  if (event.type !== 'keypress') {\n    return false;\n  }\n\n  try {\n    var target = event.target ;\n\n    if (!target || !target.tagName) {\n      return true;\n    }\n\n    // Only consider keypress events on actual input elements. This will disregard keypresses targeting body\n    // e.g.tabbing through elements, hotkeys, etc.\n    if (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable) {\n      return false;\n    }\n  } catch (e) {\n    // just accessing `target` property can throw an exception in some rare circumstances\n    // see: https://github.com/getsentry/sentry-javascript/issues/838\n  }\n\n  return true;\n}\n\n/**\n * Wraps addEventListener to capture UI breadcrumbs\n * @param handler function that will be triggered\n * @param globalListener indicates whether event was captured by the global event listener\n * @returns wrapped breadcrumb events handler\n * @hidden\n */\nfunction makeDOMEventHandler(handler, globalListener = false) {\n  return (event) => {\n    // It's possible this handler might trigger multiple times for the same\n    // event (e.g. event propagation through node ancestors).\n    // Ignore if we've already captured that event.\n    if (!event || lastCapturedEvent === event) {\n      return;\n    }\n\n    // We always want to skip _some_ events.\n    if (shouldSkipDOMEvent(event)) {\n      return;\n    }\n\n    var name = event.type === 'keypress' ? 'input' : event.type;\n\n    // If there is no debounce timer, it means that we can safely capture the new event and store it for future comparisons.\n    if (debounceTimerID === undefined) {\n      handler({\n        event: event,\n        name,\n        global: globalListener,\n      });\n      lastCapturedEvent = event;\n    }\n    // If there is a debounce awaiting, see if the new event is different enough to treat it as a unique one.\n    // If that's the case, emit the previous event and store locally the newly-captured DOM event.\n    else if (shouldShortcircuitPreviousDebounce(lastCapturedEvent, event)) {\n      handler({\n        event: event,\n        name,\n        global: globalListener,\n      });\n      lastCapturedEvent = event;\n    }\n\n    // Start a new debounce timer that will prevent us from capturing multiple events that should be grouped together.\n    clearTimeout(debounceTimerID);\n    debounceTimerID = global.setTimeout(() => {\n      debounceTimerID = undefined;\n    }, debounceDuration);\n  };\n}\n\n/** JSDoc */\nfunction instrumentDOM() {\n  if (!('document' in global)) {\n    return;\n  }\n\n  // Make it so that any click or keypress that is unhandled / bubbled up all the way to the document triggers our dom\n  // handlers. (Normally we have only one, which captures a breadcrumb for each click or keypress.) Do this before\n  // we instrument `addEventListener` so that we don't end up attaching this handler twice.\n  var triggerDOMHandler = triggerHandlers.bind(null, 'dom');\n  var globalDOMEventHandler = makeDOMEventHandler(triggerDOMHandler, true);\n  global.document.addEventListener('click', globalDOMEventHandler, false);\n  global.document.addEventListener('keypress', globalDOMEventHandler, false);\n\n  // After hooking into click and keypress events bubbled up to `document`, we also hook into user-handled\n  // clicks & keypresses, by adding an event listener of our own to any element to which they add a listener. That\n  // way, whenever one of their handlers is triggered, ours will be, too. (This is needed because their handler\n  // could potentially prevent the event from bubbling up to our global listeners. This way, our handler are still\n  // guaranteed to fire at least once.)\n  ['EventTarget', 'Node'].forEach((target) => {\n        var proto = (global )[target] && (global )[target].prototype;\n        if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n      return;\n    }\n\n    fill(proto, 'addEventListener', function (originalAddEventListener) {\n      return function (\n        \n        type,\n        listener,\n        options,\n      ) {\n        if (type === 'click' || type == 'keypress') {\n          try {\n            var el = this ;\n            var handlers = (el.__sentry_instrumentation_handlers__ = el.__sentry_instrumentation_handlers__ || {});\n            var handlerForType = (handlers[type] = handlers[type] || { refCount: 0 });\n\n            if (!handlerForType.handler) {\n              var handler = makeDOMEventHandler(triggerDOMHandler);\n              handlerForType.handler = handler;\n              originalAddEventListener.call(this, type, handler, options);\n            }\n\n            handlerForType.refCount += 1;\n          } catch (e) {\n            // Accessing dom properties is always fragile.\n            // Also allows us to skip `addEventListenrs` calls with no proper `this` context.\n          }\n        }\n\n        return originalAddEventListener.call(this, type, listener, options);\n      };\n    });\n\n    fill(\n      proto,\n      'removeEventListener',\n      function (originalRemoveEventListener) {\n        return function (\n          \n          type,\n          listener,\n          options,\n        ) {\n          if (type === 'click' || type == 'keypress') {\n            try {\n              var el = this ;\n              var handlers = el.__sentry_instrumentation_handlers__ || {};\n              var handlerForType = handlers[type];\n\n              if (handlerForType) {\n                handlerForType.refCount -= 1;\n                // If there are no longer any custom handlers of the current type on this element, we can remove ours, too.\n                if (handlerForType.refCount <= 0) {\n                  originalRemoveEventListener.call(this, type, handlerForType.handler, options);\n                  handlerForType.handler = undefined;\n                  delete handlers[type];                 }\n\n                // If there are no longer any custom handlers of any type on this element, cleanup everything.\n                if (Object.keys(handlers).length === 0) {\n                  delete el.__sentry_instrumentation_handlers__;\n                }\n              }\n            } catch (e) {\n              // Accessing dom properties is always fragile.\n              // Also allows us to skip `addEventListenrs` calls with no proper `this` context.\n            }\n          }\n\n          return originalRemoveEventListener.call(this, type, listener, options);\n        };\n      },\n    );\n  });\n}\n\nlet _oldOnErrorHandler = null;\n/** JSDoc */\nfunction instrumentError() {\n  _oldOnErrorHandler = global.onerror;\n\n  global.onerror = function (msg, url, line, column, error) {\n    triggerHandlers('error', {\n      column,\n      error,\n      line,\n      msg,\n      url,\n    });\n\n    if (_oldOnErrorHandler) {\n            return _oldOnErrorHandler.apply(this, arguments);\n    }\n\n    return false;\n  };\n}\n\nlet _oldOnUnhandledRejectionHandler = null;\n/** JSDoc */\nfunction instrumentUnhandledRejection() {\n  _oldOnUnhandledRejectionHandler = global.onunhandledrejection;\n\n  global.onunhandledrejection = function (e) {\n    triggerHandlers('unhandledrejection', e);\n\n    if (_oldOnUnhandledRejectionHandler) {\n            return _oldOnUnhandledRejectionHandler.apply(this, arguments);\n    }\n\n    return true;\n  };\n}\n\nexport { addInstrumentationHandler };\n//# sourceMappingURL=instrument.js.map\n","/** An error emitted by Sentry SDKs and related utilities. */\nclass SentryError extends Error {\n  /** Display name of this error instance. */\n  \n\n   constructor( message) {\n    super(message);this.message = message;;\n\n    this.name = new.target.prototype.constructor.name;\n    Object.setPrototypeOf(this, new.target.prototype);\n  }\n}\n\nexport { SentryError };\n//# sourceMappingURL=error.js.map\n","import { SentryError } from './error.js';\n\n/** Regular expression used to parse a Dsn. */\nvar DSN_REGEX = /^(?:(\\w+):)\\/\\/(?:(\\w+)(?::(\\w+))?@)([\\w.-]+)(?::(\\d+))?\\/(.+)/;\n\nfunction isValidProtocol(protocol) {\n  return protocol === 'http' || protocol === 'https';\n}\n\n/**\n * Renders the string representation of this Dsn.\n *\n * By default, this will render the public representation without the password\n * component. To get the deprecated private representation, set `withPassword`\n * to true.\n *\n * @param withPassword When set to true, the password will be included.\n */\nfunction dsnToString(dsn, withPassword = false) {\n  const { host, path, pass, port, projectId, protocol, publicKey } = dsn;\n  return (\n    `${protocol}://${publicKey}${withPassword && pass ? `:${pass}` : ''}` +\n    `@${host}${port ? `:${port}` : ''}/${path ? `${path}/` : path}${projectId}`\n  );\n}\n\n/**\n * Parses a Dsn from a given string.\n *\n * @param str A Dsn as string\n * @returns Dsn as DsnComponents\n */\nfunction dsnFromString(str) {\n  var match = DSN_REGEX.exec(str);\n\n  if (!match) {\n    throw new SentryError(`Invalid Sentry Dsn: ${str}`);\n  }\n\n  const [protocol, publicKey, pass = '', host, port = '', lastPath] = match.slice(1);\n  let path = '';\n  let projectId = lastPath;\n\n  var split = projectId.split('/');\n  if (split.length > 1) {\n    path = split.slice(0, -1).join('/');\n    projectId = split.pop() ;\n  }\n\n  if (projectId) {\n    var projectMatch = projectId.match(/^\\d+/);\n    if (projectMatch) {\n      projectId = projectMatch[0];\n    }\n  }\n\n  return dsnFromComponents({ host, pass, path, projectId, port, protocol: protocol , publicKey });\n}\n\nfunction dsnFromComponents(components) {\n  return {\n    protocol: components.protocol,\n    publicKey: components.publicKey || '',\n    pass: components.pass || '',\n    host: components.host,\n    port: components.port || '',\n    path: components.path || '',\n    projectId: components.projectId,\n  };\n}\n\nfunction validateDsn(dsn) {\n  if (!(typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {\n    return;\n  }\n\n  const { port, projectId, protocol } = dsn;\n\n  var requiredComponents = ['protocol', 'publicKey', 'host', 'projectId'];\n  requiredComponents.forEach(component => {\n    if (!dsn[component]) {\n      throw new SentryError(`Invalid Sentry Dsn: ${component} missing`);\n    }\n  });\n\n  if (!projectId.match(/^\\d+$/)) {\n    throw new SentryError(`Invalid Sentry Dsn: Invalid projectId ${projectId}`);\n  }\n\n  if (!isValidProtocol(protocol)) {\n    throw new SentryError(`Invalid Sentry Dsn: Invalid protocol ${protocol}`);\n  }\n\n  if (port && isNaN(parseInt(port, 10))) {\n    throw new SentryError(`Invalid Sentry Dsn: Invalid port ${port}`);\n  }\n\n  return true;\n}\n\n/** The Sentry Dsn, identifying a Sentry instance and project. */\nfunction makeDsn(from) {\n  var components = typeof from === 'string' ? dsnFromString(from) : dsnFromComponents(from);\n  validateDsn(components);\n  return components;\n}\n\nexport { dsnFromString, dsnToString, makeDsn };\n//# sourceMappingURL=dsn.js.map\n","import { dropUndefinedKeys } from './object.js';\n\n/**\n * Creates an envelope.\n * Make sure to always explicitly provide the generic to this function\n * so that the envelope types resolve correctly.\n */\nfunction createEnvelope(headers, items = []) {\n  return [headers, items] ;\n}\n\n/**\n * Add an item to an envelope.\n * Make sure to always explicitly provide the generic to this function\n * so that the envelope types resolve correctly.\n */\nfunction addItemToEnvelope(envelope, newItem) {\n  const [headers, items] = envelope;\n  return [headers, [...items, newItem]] ;\n}\n\n/**\n * Convenience function to loop through the items and item types of an envelope.\n * (This function was mostly created because working with envelope types is painful at the moment)\n */\nfunction forEachEnvelopeItem(\n  envelope,\n  callback,\n) {\n  var envelopeItems = envelope[1];\n  envelopeItems.forEach((envelopeItem) => {\n    var envelopeItemType = envelopeItem[0].type;\n    callback(envelopeItem, envelopeItemType);\n  });\n}\n\nfunction encodeUTF8(input, textEncoder) {\n  var utf8 = textEncoder || new TextEncoder();\n  return utf8.encode(input);\n}\n\n/**\n * Serializes an envelope.\n */\nfunction serializeEnvelope(envelope, textEncoder) {\n  const [envHeaders, items] = envelope;\n\n  // Initially we construct our envelope as a string and only convert to binary chunks if we encounter binary data\n  let parts = JSON.stringify(envHeaders);\n\n  function append(next) {\n    if (typeof parts === 'string') {\n      parts = typeof next === 'string' ? parts + next : [encodeUTF8(parts, textEncoder), next];\n    } else {\n      parts.push(typeof next === 'string' ? encodeUTF8(next, textEncoder) : next);\n    }\n  }\n\n  for (var item of items) {\n    const [itemHeaders, payload] = item ;\n    append(`\\n${JSON.stringify(itemHeaders)}\\n`);\n    append(typeof payload === 'string' || payload instanceof Uint8Array ? payload : JSON.stringify(payload));\n  }\n\n  return typeof parts === 'string' ? parts : concatBuffers(parts);\n}\n\nfunction concatBuffers(buffers) {\n  var totalLength = buffers.reduce((acc, buf) => acc + buf.length, 0);\n\n  var merged = new Uint8Array(totalLength);\n  let offset = 0;\n  for (var buffer of buffers) {\n    merged.set(buffer, offset);\n    offset += buffer.length;\n  }\n\n  return merged;\n}\n\n/**\n * Creates attachment envelope items\n */\nfunction createAttachmentEnvelopeItem(\n  attachment,\n  textEncoder,\n) {\n  var buffer = typeof attachment.data === 'string' ? encodeUTF8(attachment.data, textEncoder) : attachment.data;\n\n  return [\n    dropUndefinedKeys({\n      type: 'attachment',\n      length: buffer.length,\n      filename: attachment.filename,\n      content_type: attachment.contentType,\n      attachment_type: attachment.attachmentType,\n    }),\n    buffer,\n  ];\n}\n\nvar ITEM_TYPE_TO_DATA_CATEGORY_MAP = {\n  session: 'session',\n  sessions: 'session',\n  attachment: 'attachment',\n  transaction: 'transaction',\n  event: 'error',\n  client_report: 'internal',\n  user_report: 'default',\n};\n\n/**\n * Maps the type of an envelope item to a data category.\n */\nfunction envelopeItemTypeToDataCategory(type) {\n  return ITEM_TYPE_TO_DATA_CATEGORY_MAP[type];\n}\n\nexport { addItemToEnvelope, createAttachmentEnvelopeItem, createEnvelope, envelopeItemTypeToDataCategory, forEachEnvelopeItem, serializeEnvelope };\n//# sourceMappingURL=envelope.js.map\n","import { isNaN, isSyntheticEvent } from './is.js';\nimport { memoBuilder } from './memo.js';\nimport { convertToPlainObject } from './object.js';\nimport { getFunctionName } from './stacktrace.js';\n\n/**\n * Recursively normalizes the given object.\n *\n * - Creates a copy to prevent original input mutation\n * - Skips non-enumerable properties\n * - When stringifying, calls `toJSON` if implemented\n * - Removes circular references\n * - Translates non-serializable values (`undefined`/`NaN`/functions) to serializable format\n * - Translates known global objects/classes to a string representations\n * - Takes care of `Error` object serialization\n * - Optionally limits depth of final output\n * - Optionally limits number of properties/elements included in any single object/array\n *\n * @param input The object to be normalized.\n * @param depth The max depth to which to normalize the object. (Anything deeper stringified whole.)\n * @param maxProperties The max number of elements or properties to be included in any single array or\n * object in the normallized output..\n * @returns A normalized version of the object, or `\"**non-serializable**\"` if any errors are thrown during normalization.\n */\nfunction normalize(input, depth = +Infinity, maxProperties = +Infinity) {\n  try {\n    // since we're at the outermost level, we don't provide a key\n    return visit('', input, depth, maxProperties);\n  } catch (err) {\n    return { ERROR: `**non-serializable** (${err})` };\n  }\n}\n\n/** JSDoc */\nfunction normalizeToSize(\n    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  var normalized = normalize(object, depth);\n\n  if (jsonSize(normalized) > maxSize) {\n    return normalizeToSize(object, depth - 1, maxSize);\n  }\n\n  return normalized ;\n}\n\n/**\n * Visits a node to perform normalization on it\n *\n * @param key The key corresponding to the given node\n * @param value The node to be visited\n * @param depth Optional number indicating the maximum recursion depth\n * @param maxProperties Optional maximum number of properties/elements included in any single object/array\n * @param memo Optional Memo class handling decycling\n */\nfunction visit(\n  key,\n  value,\n  depth = +Infinity,\n  maxProperties = +Infinity,\n  memo = memoBuilder(),\n) {\n  const [memoize, unmemoize] = memo;\n\n  // Get the simple cases out of the way first\n  if (value === null || (['number', 'boolean', 'string'].includes(typeof value) && !isNaN(value))) {\n    return value ;\n  }\n\n  var stringified = stringifyValue(key, value);\n\n  // Anything we could potentially dig into more (objects or arrays) will have come back as `\"[object XXXX]\"`.\n  // Everything else will have already been serialized, so if we don't see that pattern, we're done.\n  if (!stringified.startsWith('[object ')) {\n    return stringified;\n  }\n\n  // From here on, we can assert that `value` is either an object or an array.\n\n  // Do not normalize objects that we know have already been normalized. As a general rule, the\n  // \"__sentry_skip_normalization__\" property should only be used sparingly and only should only be set on objects that\n  // have already been normalized.\n  if ((value )['__sentry_skip_normalization__']) {\n    return value ;\n  }\n\n  // We're also done if we've reached the max depth\n  if (depth === 0) {\n    // At this point we know `serialized` is a string of the form `\"[object XXXX]\"`. Clean it up so it's just `\"[XXXX]\"`.\n    return stringified.replace('object ', '');\n  }\n\n  // If we've already visited this branch, bail out, as it's circular reference. If not, note that we're seeing it now.\n  if (memoize(value)) {\n    return '[Circular ~]';\n  }\n\n  // If the value has a `toJSON` method, we call it to extract more information\n  var valueWithToJSON = value ;\n  if (valueWithToJSON && typeof valueWithToJSON.toJSON === 'function') {\n    try {\n      var jsonValue = valueWithToJSON.toJSON();\n      // We need to normalize the return value of `.toJSON()` in case it has circular references\n      return visit('', jsonValue, depth - 1, maxProperties, memo);\n    } catch (err) {\n      // pass (The built-in `toJSON` failed, but we can still try to do it ourselves)\n    }\n  }\n\n  // At this point we know we either have an object or an array, we haven't seen it before, and we're going to recurse\n  // because we haven't yet reached the max depth. Create an accumulator to hold the results of visiting each\n  // property/entry, and keep track of the number of items we add to it.\n  var 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  var visitable = convertToPlainObject(value );\n\n  for (var 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    var visitValue = visitable[visitKey];\n    normalized[visitKey] = visit(visitKey, visitValue, depth - 1, maxProperties, memo);\n\n    numAdded += 1;\n  }\n\n  // Once we've visited all the branches, remove the parent from memo storage\n  unmemoize(value);\n\n  // Return accumulated values\n  return normalized;\n}\n\n/**\n * Stringify the given value. Handles various known special values and types.\n *\n * Not meant to be used on simple primitives which already have a string representation, as it will, for example, turn\n * the number 1231 into \"[Object Number]\", nor on `null`, as it will throw.\n *\n * @param value The value to stringify\n * @returns A stringified representation of the given value\n */\nfunction stringifyValue(\n  key,\n  // this type is a tiny bit of a cheat, since this function does handle NaN (which is technically a number), but for\n  // our internal use, it'll do\n  value,\n) {\n  try {\n    if (key === 'domain' && value && typeof value === 'object' && (value )._events) {\n      return '[Domain]';\n    }\n\n    if (key === 'domainEmitter') {\n      return '[DomainEmitter]';\n    }\n\n    // It's safe to use `global`, `window`, and `document` here in this manner, as we are asserting using `typeof` first\n    // which won't throw if they are not present.\n\n    if (typeof global !== 'undefined' && value === global) {\n      return '[Global]';\n    }\n\n        if (typeof window !== 'undefined' && value === window) {\n      return '[Window]';\n    }\n\n        if (typeof document !== 'undefined' && value === document) {\n      return '[Document]';\n    }\n\n    // React's SyntheticEvent thingy\n    if (isSyntheticEvent(value)) {\n      return '[SyntheticEvent]';\n    }\n\n    if (typeof value === 'number' && value !== value) {\n      return '[NaN]';\n    }\n\n    // this catches `undefined` (but not `null`, which is a primitive and can be serialized on its own)\n    if (value === void 0) {\n      return '[undefined]';\n    }\n\n    if (typeof value === 'function') {\n      return `[Function: ${getFunctionName(value)}]`;\n    }\n\n    if (typeof value === 'symbol') {\n      return `[${String(value)}]`;\n    }\n\n    // stringified BigInts are indistinguishable from regular numbers, so we need to label them to avoid confusion\n    if (typeof value === 'bigint') {\n      return `[BigInt: ${String(value)}]`;\n    }\n\n    // Now that we've knocked out all the special cases and the primitives, all we have left are objects. Simply casting\n    // them to strings means that instances of classes which haven't defined their `toStringTag` will just come out as\n    // `\"[object Object]\"`. If we instead look at the constructor's name (which is the same as the name of the class),\n    // we can make sure that only plain objects come out that way.\n    return `[object ${(Object.getPrototypeOf(value) ).constructor.name}]`;\n  } catch (err) {\n    return `**non-serializable** (${err})`;\n  }\n}\n\n/** Calculates bytes size of input string */\nfunction utf8Length(value) {\n    return ~-encodeURI(value).split(/%..|./).length;\n}\n\n/** Calculates bytes size of input object */\nfunction jsonSize(value) {\n  return utf8Length(JSON.stringify(value));\n}\n\nexport { normalize, normalizeToSize, visit as walk };\n//# sourceMappingURL=normalize.js.map\n","/**\n * Helper to decycle json objects\n */\nfunction memoBuilder() {\n  var hasWeakSet = typeof WeakSet === 'function';\n  var inner = hasWeakSet ? new WeakSet() : [];\n  function memoize(obj) {\n    if (hasWeakSet) {\n      if (inner.has(obj)) {\n        return true;\n      }\n      inner.add(obj);\n      return false;\n    }\n        for (let i = 0; i < inner.length; i++) {\n      var value = inner[i];\n      if (value === obj) {\n        return true;\n      }\n    }\n    inner.push(obj);\n    return false;\n  }\n\n  function unmemoize(obj) {\n    if (hasWeakSet) {\n      inner.delete(obj);\n    } else {\n      for (let i = 0; i < inner.length; i++) {\n        if (inner[i] === obj) {\n          inner.splice(i, 1);\n          break;\n        }\n      }\n    }\n  }\n  return [memoize, unmemoize];\n}\n\nexport { memoBuilder };\n//# sourceMappingURL=memo.js.map\n","import { urlEncode, makeDsn, dsnToString } from '@sentry/utils';\n\nvar SENTRY_API_VERSION = '7';\n\n/** Returns the prefix to construct Sentry ingestion API endpoints. */\nfunction getBaseApiEndpoint(dsn) {\n  var protocol = dsn.protocol ? `${dsn.protocol}:` : '';\n  var port = dsn.port ? `:${dsn.port}` : '';\n  return `${protocol}//${dsn.host}${port}${dsn.path ? `/${dsn.path}` : ''}/api/`;\n}\n\n/** Returns the ingest API endpoint for target. */\nfunction _getIngestEndpoint(dsn) {\n  return `${getBaseApiEndpoint(dsn)}${dsn.projectId}/envelope/`;\n}\n\n/** Returns a URL-encoded string with auth config suitable for a query string. */\nfunction _encodedAuth(dsn, sdkInfo) {\n  return urlEncode({\n    // We send only the minimum set of required information. See\n    // https://github.com/getsentry/sentry-javascript/issues/2572.\n    sentry_key: dsn.publicKey,\n    sentry_version: SENTRY_API_VERSION,\n    ...(sdkInfo && { sentry_client: `${sdkInfo.name}/${sdkInfo.version}` }),\n  });\n}\n\n/**\n * Returns the envelope endpoint URL with auth in the query string.\n *\n * Sending auth as part of the query string and not as custom HTTP headers avoids CORS preflight requests.\n */\nfunction getEnvelopeEndpointWithUrlEncodedAuth(\n  dsn,\n  // TODO (v8): Remove `tunnelOrOptions` in favor of `options`, and use the substitute code below\n  // options: ClientOptions = {} as ClientOptions,\n  tunnelOrOptions = {} ,\n) {\n  // TODO (v8): Use this code instead\n  // const { tunnel, _metadata = {} } = options;\n  // return tunnel ? tunnel : `${_getIngestEndpoint(dsn)}?${_encodedAuth(dsn, _metadata.sdk)}`;\n\n  var tunnel = typeof tunnelOrOptions === 'string' ? tunnelOrOptions : tunnelOrOptions.tunnel;\n  var sdkInfo =\n    typeof tunnelOrOptions === 'string' || !tunnelOrOptions._metadata ? undefined : tunnelOrOptions._metadata.sdk;\n\n  return tunnel ? tunnel : `${_getIngestEndpoint(dsn)}?${_encodedAuth(dsn, sdkInfo)}`;\n}\n\n/** Returns the url to the report dialog endpoint. */\nfunction getReportDialogEndpoint(\n  dsnLike,\n  dialogOptions\n\n,\n) {\n  var dsn = makeDsn(dsnLike);\n  var endpoint = `${getBaseApiEndpoint(dsn)}embed/error-page/`;\n\n  let encodedOptions = `dsn=${dsnToString(dsn)}`;\n  for (var key in dialogOptions) {\n    if (key === 'dsn') {\n      continue;\n    }\n\n    if (key === 'user') {\n      var user = dialogOptions.user;\n      if (!user) {\n        continue;\n      }\n      if (user.name) {\n        encodedOptions += `&name=${encodeURIComponent(user.name)}`;\n      }\n      if (user.email) {\n        encodedOptions += `&email=${encodeURIComponent(user.email)}`;\n      }\n    } else {\n      encodedOptions += `&${encodeURIComponent(key)}=${encodeURIComponent(dialogOptions[key] )}`;\n    }\n  }\n\n  return `${endpoint}?${encodedOptions}`;\n}\n\nexport { getEnvelopeEndpointWithUrlEncodedAuth, getReportDialogEndpoint };\n//# sourceMappingURL=api.js.map\n","import { dsnToString, createEnvelope, dropUndefinedKeys, getSentryBaggageItems } from '@sentry/utils';\n\n/** Extract sdk info from from the API metadata */\nfunction getSdkMetadataForEnvelopeHeader(metadata) {\n  if (!metadata || !metadata.sdk) {\n    return;\n  }\n  const { name, version } = metadata.sdk;\n  return { name, version };\n}\n\n/**\n * Apply SdkInfo (name, version, packages, integrations) to the corresponding event key.\n * Merge with existing data if any.\n **/\nfunction enhanceEventWithSdkInfo(event, sdkInfo) {\n  if (!sdkInfo) {\n    return event;\n  }\n  event.sdk = event.sdk || {};\n  event.sdk.name = event.sdk.name || sdkInfo.name;\n  event.sdk.version = event.sdk.version || sdkInfo.version;\n  event.sdk.integrations = [...(event.sdk.integrations || []), ...(sdkInfo.integrations || [])];\n  event.sdk.packages = [...(event.sdk.packages || []), ...(sdkInfo.packages || [])];\n  return event;\n}\n\n/** Creates an envelope from a Session */\nfunction createSessionEnvelope(\n  session,\n  dsn,\n  metadata,\n  tunnel,\n) {\n  var sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);\n  var envelopeHeaders = {\n    sent_at: new Date().toISOString(),\n    ...(sdkInfo && { sdk: sdkInfo }),\n    ...(!!tunnel && { dsn: dsnToString(dsn) }),\n  };\n\n  var envelopeItem =\n    'aggregates' in session ? [{ type: 'sessions' }, session] : [{ type: 'session' }, session];\n\n  return createEnvelope(envelopeHeaders, [envelopeItem]);\n}\n\n/**\n * Create an Envelope from an event.\n */\nfunction createEventEnvelope(\n  event,\n  dsn,\n  metadata,\n  tunnel,\n) {\n  var sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);\n  var eventType = event.type || 'event';\n\n  const { transactionSampling } = event.sdkProcessingMetadata || {};\n  const { method: samplingMethod, rate: sampleRate } = transactionSampling || {};\n\n  enhanceEventWithSdkInfo(event, metadata && metadata.sdk);\n\n  var envelopeHeaders = createEventEnvelopeHeaders(event, sdkInfo, tunnel, dsn);\n\n  // Prevent this data (which, if it exists, was used in earlier steps in the processing pipeline) from being sent to\n  // sentry. (Note: Our use of this property comes and goes with whatever we might be debugging, whatever hacks we may\n  // have temporarily added, etc. Even if we don't happen to be using it at some point in the future, let's not get rid\n  // of this `delete`, lest we miss putting it back in the next time the property is in use.)\n  delete event.sdkProcessingMetadata;\n\n  var eventItem = [\n    {\n      type: eventType,\n      sample_rates: [{ id: samplingMethod, rate: sampleRate }],\n    },\n    event,\n  ];\n  return createEnvelope(envelopeHeaders, [eventItem]);\n}\n\nfunction createEventEnvelopeHeaders(\n  event,\n  sdkInfo,\n  tunnel,\n  dsn,\n) {\n  var baggage = event.sdkProcessingMetadata && event.sdkProcessingMetadata.baggage;\n  var dynamicSamplingContext = baggage && getSentryBaggageItems(baggage);\n\n  return {\n    event_id: event.event_id ,\n    sent_at: new Date().toISOString(),\n    ...(sdkInfo && { sdk: sdkInfo }),\n    ...(!!tunnel && { dsn: dsnToString(dsn) }),\n    ...(event.type === 'transaction' &&\n      dynamicSamplingContext && {\n        trace: dropUndefinedKeys({ ...dynamicSamplingContext }) ,\n      }),\n  };\n}\n\nexport { createEventEnvelope, createSessionEnvelope };\n//# sourceMappingURL=envelope.js.map\n","import { updateSession, Scope } from '@sentry/hub';\nimport { makeDsn, logger, checkOrSetAlreadyCaught, isPrimitive, resolvedSyncPromise, addItemToEnvelope, createAttachmentEnvelopeItem, SyncPromise, uuid4, dateTimestampInSeconds, normalize, truncate, rejectedSyncPromise, SentryError, isThenable, isPlainObject } from '@sentry/utils';\nimport { getEnvelopeEndpointWithUrlEncodedAuth } from './api.js';\nimport { createEventEnvelope, createSessionEnvelope } from './envelope.js';\nimport { setupIntegrations } from './integration.js';\n\nvar ALREADY_SEEN_ERROR = \"Not capturing exception because it's already been captured.\";\n\n/**\n * Base implementation for all JavaScript SDK clients.\n *\n * Call the constructor with the corresponding options\n * specific to the client subclass. To access these options later, use\n * {@link Client.getOptions}.\n *\n * If a Dsn is specified in the options, it will be parsed and stored. Use\n * {@link Client.getDsn} to retrieve the Dsn at any moment. In case the Dsn is\n * invalid, the constructor will throw a {@link SentryException}. Note that\n * without a valid Dsn, the SDK will not send any events to Sentry.\n *\n * Before sending an event, it is passed through\n * {@link BaseClient._prepareEvent} to add SDK information and scope data\n * (breadcrumbs and context). To add more custom information, override this\n * method and extend the resulting prepared event.\n *\n * To issue automatically created events (e.g. via instrumentation), use\n * {@link Client.captureEvent}. It will prepare the event and pass it through\n * the callback lifecycle. To issue auto-breadcrumbs, use\n * {@link Client.addBreadcrumb}.\n *\n * @example\n * class NodeClient extends BaseClient<NodeOptions> {\n *   public constructor(options: NodeOptions) {\n *     super(options);\n *   }\n *\n *   // ...\n * }\n */\nclass BaseClient {\n  /** Options passed to the SDK. */\n  \n\n  /** The client Dsn, if specified in options. Without this Dsn, the SDK will be disabled. */\n  \n\n  /** Array of set up integrations. */\n   __init() {this._integrations = {};}\n\n  /** Indicates whether this client's integrations have been set up. */\n   __init2() {this._integrationsInitialized = false;}\n\n  /** Number of calls being processed */\n   __init3() {this._numProcessing = 0;}\n\n  /** Holds flushable  */\n   __init4() {this._outcomes = {};}\n\n  /**\n   * Initializes this client instance.\n   *\n   * @param options Options for the client.\n   */\n   constructor(options) {;BaseClient.prototype.__init.call(this);BaseClient.prototype.__init2.call(this);BaseClient.prototype.__init3.call(this);BaseClient.prototype.__init4.call(this);\n    this._options = options;\n    if (options.dsn) {\n      this._dsn = makeDsn(options.dsn);\n      var url = getEnvelopeEndpointWithUrlEncodedAuth(this._dsn, options);\n      this._transport = options.transport({\n        recordDroppedEvent: this.recordDroppedEvent.bind(this),\n        ...options.transportOptions,\n        url,\n      });\n    } else {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('No DSN provided, client will not do anything.');\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n     captureException(exception, hint, scope) {\n    // ensure we haven't captured this very object before\n    if (checkOrSetAlreadyCaught(exception)) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(ALREADY_SEEN_ERROR);\n      return;\n    }\n\n    let eventId = hint && hint.event_id;\n\n    this._process(\n      this.eventFromException(exception, hint)\n        .then(event => this._captureEvent(event, hint, scope))\n        .then(result => {\n          eventId = result;\n        }),\n    );\n\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureMessage(\n    message,\n        level,\n    hint,\n    scope,\n  ) {\n    let eventId = hint && hint.event_id;\n\n    var promisedEvent = isPrimitive(message)\n      ? this.eventFromMessage(String(message), level, hint)\n      : this.eventFromException(message, hint);\n\n    this._process(\n      promisedEvent\n        .then(event => this._captureEvent(event, hint, scope))\n        .then(result => {\n          eventId = result;\n        }),\n    );\n\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureEvent(event, hint, scope) {\n    // ensure we haven't captured this very object before\n    if (hint && hint.originalException && checkOrSetAlreadyCaught(hint.originalException)) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(ALREADY_SEEN_ERROR);\n      return;\n    }\n\n    let eventId = hint && hint.event_id;\n\n    this._process(\n      this._captureEvent(event, hint, scope).then(result => {\n        eventId = result;\n      }),\n    );\n\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureSession(session) {\n    if (!this._isEnabled()) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('SDK not enabled, will not capture session.');\n      return;\n    }\n\n    if (!(typeof session.release === 'string')) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Discarded session because of missing or non-string release');\n    } else {\n      this.sendSession(session);\n      // After sending, we set init false to indicate it's not the first occurrence\n      updateSession(session, { init: false });\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getDsn() {\n    return this._dsn;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getOptions() {\n    return this._options;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getTransport() {\n    return this._transport;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   flush(timeout) {\n    var transport = this._transport;\n    if (transport) {\n      return this._isClientDoneProcessing(timeout).then(clientFinished => {\n        return transport.flush(timeout).then(transportFlushed => clientFinished && transportFlushed);\n      });\n    } else {\n      return resolvedSyncPromise(true);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   close(timeout) {\n    return this.flush(timeout).then(result => {\n      this.getOptions().enabled = false;\n      return result;\n    });\n  }\n\n  /**\n   * Sets up the integrations\n   */\n   setupIntegrations() {\n    if (this._isEnabled() && !this._integrationsInitialized) {\n      this._integrations = setupIntegrations(this._options.integrations);\n      this._integrationsInitialized = true;\n    }\n  }\n\n  /**\n   * Gets an installed integration by its `id`.\n   *\n   * @returns The installed integration or `undefined` if no integration with that `id` was installed.\n   */\n   getIntegrationById(integrationId) {\n    return this._integrations[integrationId];\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getIntegration(integration) {\n    try {\n      return (this._integrations[integration.id] ) || null;\n    } catch (_oO) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(`Cannot retrieve integration ${integration.id} from the current Client`);\n      return null;\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   sendEvent(event, hint = {}) {\n    if (this._dsn) {\n      let env = createEventEnvelope(event, this._dsn, this._options._metadata, this._options.tunnel);\n\n      for (var attachment of hint.attachments || []) {\n        env = addItemToEnvelope(\n          env,\n          createAttachmentEnvelopeItem(\n            attachment,\n            this._options.transportOptions && this._options.transportOptions.textEncoder,\n          ),\n        );\n      }\n\n      this._sendEnvelope(env);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   sendSession(session) {\n    if (this._dsn) {\n      var env = createSessionEnvelope(session, this._dsn, this._options._metadata, this._options.tunnel);\n      this._sendEnvelope(env);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   recordDroppedEvent(reason, category) {\n    if (this._options.sendClientReports) {\n      // We want to track each category (error, transaction, session) separately\n      // but still keep the distinction between different type of outcomes.\n      // We could use nested maps, but it's much easier to read and type this way.\n      // A correct type for map-based implementation if we want to go that route\n      // would be `Partial<Record<SentryRequestType, Partial<Record<Outcome, number>>>>`\n      // With typescript 4.1 we could even use template literal types\n      var key = `${reason}:${category}`;\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`Adding outcome: \"${key}\"`);\n\n      // The following works because undefined + 1 === NaN and NaN is falsy\n      this._outcomes[key] = this._outcomes[key] + 1 || 1;\n    }\n  }\n\n  /** Updates existing session based on the provided event */\n   _updateSessionFromEvent(session, event) {\n    let crashed = false;\n    let errored = false;\n    var exceptions = event.exception && event.exception.values;\n\n    if (exceptions) {\n      errored = true;\n\n      for (var ex of exceptions) {\n        var mechanism = ex.mechanism;\n        if (mechanism && mechanism.handled === false) {\n          crashed = true;\n          break;\n        }\n      }\n    }\n\n    // A session is updated and that session update is sent in only one of the two following scenarios:\n    // 1. Session with non terminal status and 0 errors + an error occurred -> Will set error count to 1 and send update\n    // 2. Session with non terminal status and 1 error + a crash occurred -> Will set status crashed and send update\n    var sessionNonTerminal = session.status === 'ok';\n    var shouldUpdateAndSend = (sessionNonTerminal && session.errors === 0) || (sessionNonTerminal && crashed);\n\n    if (shouldUpdateAndSend) {\n      updateSession(session, {\n        ...(crashed && { status: 'crashed' }),\n        errors: session.errors || Number(errored || crashed),\n      });\n      this.captureSession(session);\n    }\n  }\n\n  /**\n   * Determine if the client is finished processing. Returns a promise because it will wait `timeout` ms before saying\n   * \"no\" (resolving to `false`) in order to give the client a chance to potentially finish first.\n   *\n   * @param timeout The time, in ms, after which to resolve to `false` if the client is still busy. Passing `0` (or not\n   * passing anything) will make the promise wait as long as it takes for processing to finish before resolving to\n   * `true`.\n   * @returns A promise which will resolve to `true` if processing is already done or finishes before the timeout, and\n   * `false` otherwise\n   */\n   _isClientDoneProcessing(timeout) {\n    return new SyncPromise(resolve => {\n      let ticked = 0;\n      var tick = 1;\n\n      var interval = setInterval(() => {\n        if (this._numProcessing == 0) {\n          clearInterval(interval);\n          resolve(true);\n        } else {\n          ticked += tick;\n          if (timeout && ticked >= timeout) {\n            clearInterval(interval);\n            resolve(false);\n          }\n        }\n      }, tick);\n    });\n  }\n\n  /** Determines whether this SDK is enabled and a valid Dsn is present. */\n   _isEnabled() {\n    return this.getOptions().enabled !== false && this._dsn !== undefined;\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   */\n   _prepareEvent(event, hint, scope) {\n    const { normalizeDepth = 3, normalizeMaxBreadth = 1000 } = this.getOptions();\n    var prepared = {\n      ...event,\n      event_id: event.event_id || hint.event_id || uuid4(),\n      timestamp: event.timestamp || dateTimestampInSeconds(),\n    };\n\n    this._applyClientOptions(prepared);\n    this._applyIntegrationsMetadata(prepared);\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    let finalScope = scope;\n    if (hint.captureContext) {\n      finalScope = Scope.clone(finalScope).update(hint.captureContext);\n    }\n\n    // We prepare the result here with a resolved Event.\n    let result = resolvedSyncPromise(prepared);\n\n    // This should be the last thing called, since we want that\n    // {@link Hub.addEventProcessor} gets the finished prepared event.\n    if (finalScope) {\n      // Collect attachments from the hint and scope\n      var attachments = [...(hint.attachments || []), ...finalScope.getAttachments()];\n\n      if (attachments.length) {\n        hint.attachments = attachments;\n      }\n\n      // In case we have a hub we reassign it.\n      result = finalScope.applyToEvent(prepared, hint);\n    }\n\n    return result.then(evt => {\n      if (typeof normalizeDepth === 'number' && normalizeDepth > 0) {\n        return this._normalizeEvent(evt, normalizeDepth, normalizeMaxBreadth);\n      }\n      return evt;\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   */\n   _normalizeEvent(event, depth, maxBreadth) {\n    if (!event) {\n      return null;\n    }\n\n    var 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 && 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        // We cannot use the spread operator here because `toJSON` on `span` is non-enumerable\n        if (span.data) {\n          span.data = normalize(span.data, depth, maxBreadth);\n        }\n        return span;\n      });\n    }\n\n    return normalized;\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   * @param event event instance to be enhanced\n   */\n   _applyClientOptions(event) {\n    var options = this.getOptions();\n    const { environment, release, dist, maxValueLength = 250 } = options;\n\n    if (!('environment' in event)) {\n      event.environment = 'environment' in options ? environment : 'production';\n    }\n\n    if (event.release === undefined && release !== undefined) {\n      event.release = release;\n    }\n\n    if (event.dist === undefined && dist !== undefined) {\n      event.dist = dist;\n    }\n\n    if (event.message) {\n      event.message = truncate(event.message, maxValueLength);\n    }\n\n    var exception = event.exception && event.exception.values && event.exception.values[0];\n    if (exception && exception.value) {\n      exception.value = truncate(exception.value, maxValueLength);\n    }\n\n    var request = event.request;\n    if (request && request.url) {\n      request.url = truncate(request.url, maxValueLength);\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   */\n   _applyIntegrationsMetadata(event) {\n    var integrationsArray = Object.keys(this._integrations);\n    if (integrationsArray.length > 0) {\n      event.sdk = event.sdk || {};\n      event.sdk.integrations = [...(event.sdk.integrations || []), ...integrationsArray];\n    }\n  }\n\n  /**\n   * Processes the event and logs an error in case of rejection\n   * @param event\n   * @param hint\n   * @param scope\n   */\n   _captureEvent(event, hint = {}, scope) {\n    return this._processEvent(event, hint, scope).then(\n      finalEvent => {\n        return finalEvent.event_id;\n      },\n      reason => {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(reason);\n        return undefined;\n      },\n    );\n  }\n\n  /**\n   * Processes an event (either error or message) and sends it to Sentry.\n   *\n   * This also adds breadcrumbs and context information to the event. However,\n   * platform specific meta data (such as the User's IP address) must be added\n   * by the SDK implementor.\n   *\n   *\n   * @param event The event to send to Sentry.\n   * @param hint May contain additional information about the original exception.\n   * @param scope A scope containing event metadata.\n   * @returns A SyncPromise that resolves with the event or rejects in case event was/will not be send.\n   */\n   _processEvent(event, hint, scope) {\n    const { beforeSend, sampleRate } = this.getOptions();\n\n    if (!this._isEnabled()) {\n      return rejectedSyncPromise(new SentryError('SDK not enabled, will not capture event.'));\n    }\n\n    var isTransaction = event.type === 'transaction';\n    // 1.0 === 100% events are sent\n    // 0.0 === 0% events are sent\n    // Sampling for transaction happens somewhere else\n    if (!isTransaction && typeof sampleRate === 'number' && Math.random() > sampleRate) {\n      this.recordDroppedEvent('sample_rate', 'error');\n      return rejectedSyncPromise(\n        new SentryError(\n          `Discarding event because it's not included in the random sample (sampling rate = ${sampleRate})`,\n        ),\n      );\n    }\n\n    return this._prepareEvent(event, hint, scope)\n      .then(prepared => {\n        if (prepared === null) {\n          this.recordDroppedEvent('event_processor', event.type || 'error');\n          throw new SentryError('An event processor returned null, will not send event.');\n        }\n\n        var isInternalException = hint.data && (hint.data ).__sentry__ === true;\n        if (isInternalException || isTransaction || !beforeSend) {\n          return prepared;\n        }\n\n        var beforeSendResult = beforeSend(prepared, hint);\n        return _ensureBeforeSendRv(beforeSendResult);\n      })\n      .then(processedEvent => {\n        if (processedEvent === null) {\n          this.recordDroppedEvent('before_send', event.type || 'error');\n          throw new SentryError('`beforeSend` returned `null`, will not send event.');\n        }\n\n        var session = scope && scope.getSession();\n        if (!isTransaction && session) {\n          this._updateSessionFromEvent(session, processedEvent);\n        }\n\n        this.sendEvent(processedEvent, hint);\n        return processedEvent;\n      })\n      .then(null, reason => {\n        if (reason instanceof SentryError) {\n          throw reason;\n        }\n\n        this.captureException(reason, {\n          data: {\n            __sentry__: true,\n          },\n          originalException: reason ,\n        });\n        throw new SentryError(\n          `Event processing pipeline threw an error, original event will not be sent. Details have been sent as a new event.\\nReason: ${reason}`,\n        );\n      });\n  }\n\n  /**\n   * Occupies the client with processing and event\n   */\n   _process(promise) {\n    this._numProcessing += 1;\n    void promise.then(\n      value => {\n        this._numProcessing -= 1;\n        return value;\n      },\n      reason => {\n        this._numProcessing -= 1;\n        return reason;\n      },\n    );\n  }\n\n  /**\n   * @inheritdoc\n   */\n   _sendEnvelope(envelope) {\n    if (this._transport && this._dsn) {\n      this._transport.send(envelope).then(null, reason => {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Error while sending event:', reason);\n      });\n    } else {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Transport disabled');\n    }\n  }\n\n  /**\n   * Clears outcomes on this client and returns them.\n   */\n   _clearOutcomes() {\n    var outcomes = this._outcomes;\n    this._outcomes = {};\n    return Object.keys(outcomes).map(key => {\n      const [reason, category] = key.split(':') ;\n      return {\n        reason,\n        category,\n        quantity: outcomes[key],\n      };\n    });\n  }\n\n  /**\n   * @inheritDoc\n   */\n    \n\n}\n\n/**\n * Verifies that return value of configured `beforeSend` is of expected type.\n */\nfunction _ensureBeforeSendRv(rv) {\n  var nullErr = '`beforeSend` method has to return `null` or a valid event.';\n  if (isThenable(rv)) {\n    return rv.then(\n      event => {\n        if (!(isPlainObject(event) || event === null)) {\n          throw new SentryError(nullErr);\n        }\n        return event;\n      },\n      e => {\n        throw new SentryError(`beforeSend rejected with ${e}`);\n      },\n    );\n  } else if (!(isPlainObject(rv) || rv === null)) {\n    throw new SentryError(nullErr);\n  }\n  return rv;\n}\n\nexport { BaseClient };\n//# sourceMappingURL=baseclient.js.map\n","import { isString } from './is.js';\nimport { logger } from './logger.js';\n\nvar BAGGAGE_HEADER_NAME = 'baggage';\n\nvar SENTRY_BAGGAGE_KEY_PREFIX = 'sentry-';\n\nvar 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 */\nvar MAX_BAGGAGE_STRING_LENGTH = 8192;\n\n/** Create an instance of Baggage */\nfunction createBaggage(initItems, baggageString = '', mutable = true) {\n  return [{ ...initItems }, baggageString, mutable];\n}\n\n/** Get a value from baggage */\nfunction getBaggageValue(baggage, key) {\n  return baggage[0][key];\n}\n\n/** Add a value to baggage */\nfunction setBaggageValue(baggage, key, value) {\n  if (isBaggageMutable(baggage)) {\n    baggage[0][key] = value;\n  }\n}\n\n/** Check if the Sentry part of the passed baggage (i.e. the first element in the tuple) is empty */\nfunction isSentryBaggageEmpty(baggage) {\n  return Object.keys(baggage[0]).length === 0;\n}\n\n/** Returns Sentry specific baggage values */\nfunction getSentryBaggageItems(baggage) {\n  return baggage[0];\n}\n\n/**\n * Returns 3rd party baggage string of @param baggage\n * @param baggage\n */\nfunction getThirdPartyBaggage(baggage) {\n  return baggage[1];\n}\n\n/**\n * Checks if baggage is mutable\n * @param baggage\n * @returns true if baggage is mutable, else false\n */\nfunction isBaggageMutable(baggage) {\n  return baggage[2];\n}\n\n/**\n * Sets the passed baggage immutable\n * @param baggage\n */\nfunction setBaggageImmutable(baggage) {\n  baggage[2] = false;\n}\n\n/** Serialize a baggage object */\nfunction serializeBaggage(baggage) {\n  return Object.keys(baggage[0]).reduce((prev, key) => {\n    var val = baggage[0][key] ;\n    var baggageEntry = `${SENTRY_BAGGAGE_KEY_PREFIX}${encodeURIComponent(key)}=${encodeURIComponent(val)}`;\n    var newVal = prev === '' ? baggageEntry : `${prev},${baggageEntry}`;\n    if (newVal.length > MAX_BAGGAGE_STRING_LENGTH) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.warn(`Not adding key: ${key} with val: ${val} to baggage due to exceeding baggage size limits.`);\n      return prev;\n    } else {\n      return newVal;\n    }\n  }, baggage[1]);\n}\n\n/**\n * Parse a baggage header from a string or a string array and return a Baggage object\n *\n * If @param includeThirdPartyEntries is set to true, third party baggage entries are added to the Baggage object\n * (This is necessary for merging potentially pre-existing baggage headers in outgoing requests with\n * our `sentry-` values)\n */\nfunction parseBaggageHeader(\n  inputBaggageValue,\n  includeThirdPartyEntries = false,\n) {\n  // Adding this check here because we got reports of this function failing due to the input value\n  // not being a string. This debug log might help us determine what's going on here.\n  if ((!Array.isArray(inputBaggageValue) && !isString(inputBaggageValue)) || typeof inputBaggageValue === 'number') {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.warn(\n        '[parseBaggageHeader] Received input value of incompatible type: ',\n        typeof inputBaggageValue,\n        inputBaggageValue,\n      );\n\n    // Gonna early-return an empty baggage object so that we don't fail later on\n    return createBaggage({}, '');\n  }\n\n  var baggageEntries = (isString(inputBaggageValue) ? inputBaggageValue : inputBaggageValue.join(','))\n    .split(',')\n    .map(entry => entry.trim())\n    .filter(entry => entry !== '' && (includeThirdPartyEntries || SENTRY_BAGGAGE_KEY_PREFIX_REGEX.test(entry)));\n\n  return baggageEntries.reduce(\n    ([baggageObj, baggageString], curr) => {\n      const [key, val] = curr.split('=');\n      if (SENTRY_BAGGAGE_KEY_PREFIX_REGEX.test(key)) {\n        var baggageKey = decodeURIComponent(key.split('-')[1]);\n        return [\n          {\n            ...baggageObj,\n            [baggageKey]: decodeURIComponent(val),\n          },\n          baggageString,\n          true,\n        ];\n      } else {\n        return [baggageObj, baggageString === '' ? curr : `${baggageString},${curr}`, true];\n      }\n    },\n    [{}, '', true],\n  );\n}\n\n/**\n * Merges the baggage header we saved from the incoming request (or meta tag) with\n * a possibly created or modified baggage header by a third party that's been added\n * to the outgoing request header.\n *\n * In case @param headerBaggageString exists, we can safely add the the 3rd party part of @param headerBaggage\n * with our @param incomingBaggage. This is possible because if we modified anything beforehand,\n * it would only affect parts of the sentry baggage (@see Baggage interface).\n *\n * @param incomingBaggage the baggage header of the incoming request that might contain sentry entries\n * @param thirdPartyBaggageHeader possibly existing baggage header string or string[] added from a third\n *        party to the request headers\n *\n * @return a merged and serialized baggage string to be propagated with the outgoing request\n */\nfunction mergeAndSerializeBaggage(incomingBaggage, thirdPartyBaggageHeader) {\n  if (!incomingBaggage && !thirdPartyBaggageHeader) {\n    return '';\n  }\n\n  var headerBaggage = (thirdPartyBaggageHeader && parseBaggageHeader(thirdPartyBaggageHeader, true)) || undefined;\n  var thirdPartyHeaderBaggage = headerBaggage && getThirdPartyBaggage(headerBaggage);\n\n  var finalBaggage = createBaggage((incomingBaggage && incomingBaggage[0]) || {}, thirdPartyHeaderBaggage || '');\n  return serializeBaggage(finalBaggage);\n}\n\n/**\n * Helper function that takes a raw baggage string (if available) and the processed sentry-trace header\n * data (if available), parses the baggage string and creates a Baggage object\n * If there is no baggage string, it will create an empty Baggage object.\n * In a second step, this functions determines if the created Baggage object should be set immutable\n * to prevent mutation of the Sentry data.\n *\n * Extracted this logic to a function because it's duplicated in a lot of places.\n *\n * @param rawBaggageValue\n * @param sentryTraceHeader\n */\nfunction parseBaggageSetMutability(\n  rawBaggageValue,\n  sentryTraceHeader,\n) {\n  var baggage = parseBaggageHeader(rawBaggageValue || '');\n\n  // Because we are always creating a Baggage object by calling `parseBaggageHeader` above\n  // (either a filled one or an empty one, even if we didn't get a `baggage` header),\n  // we only need to check if we have a sentry-trace header or not. As soon as we have it,\n  // we set baggage immutable. In case we don't get a sentry-trace header, we can assume that\n  // this SDK is the head of the trace and thus we still permit mutation at this time.\n  // There is one exception though, which is that we get a baggage-header with `sentry-`\n  // items but NO sentry-trace header. In this case we also set the baggage immutable for now\n  // but if smoething like this would ever happen, we should revisit this and determine\n  // what this would actually mean for the trace (i.e. is this SDK the head?, what happened\n  // before that we don't have a sentry-trace header?, etc)\n  (sentryTraceHeader || !isSentryBaggageEmpty(baggage)) && setBaggageImmutable(baggage);\n\n  return baggage;\n}\n\nexport { BAGGAGE_HEADER_NAME, MAX_BAGGAGE_STRING_LENGTH, SENTRY_BAGGAGE_KEY_PREFIX, SENTRY_BAGGAGE_KEY_PREFIX_REGEX, createBaggage, getBaggageValue, getSentryBaggageItems, getThirdPartyBaggage, isBaggageMutable, isSentryBaggageEmpty, mergeAndSerializeBaggage, parseBaggageHeader, parseBaggageSetMutability, serializeBaggage, setBaggageImmutable, setBaggageValue };\n//# sourceMappingURL=baggage.js.map\n","var SDK_VERSION = '7.10.0';\n\nexport { SDK_VERSION };\n//# sourceMappingURL=version.js.map\n","import { isEvent, extractExceptionKeysForMessage, normalizeToSize, addExceptionMechanism, resolvedSyncPromise, isErrorEvent, isDOMError, isDOMException, addExceptionTypeValue, isError, isPlainObject } from '@sentry/utils';\n\n/**\n * This function creates an exception from a JavaScript Error\n */\nfunction exceptionFromError(stackParser, ex) {\n  // Get the frames first since Opera can lose the stack if we touch anything else first\n  var frames = parseStackFrames(stackParser, ex);\n\n  var exception = {\n    type: ex && ex.name,\n    value: extractMessage(ex),\n  };\n\n  if (frames.length) {\n    exception.stacktrace = { frames };\n  }\n\n  if (exception.type === undefined && exception.value === '') {\n    exception.value = 'Unrecoverable error caught';\n  }\n\n  return exception;\n}\n\n/**\n * @hidden\n */\nfunction eventFromPlainObject(\n  stackParser,\n  exception,\n  syntheticException,\n  isUnhandledRejection,\n) {\n  var event = {\n    exception: {\n      values: [\n        {\n          type: isEvent(exception) ? exception.constructor.name : isUnhandledRejection ? 'UnhandledRejection' : 'Error',\n          value: `Non-Error ${\n            isUnhandledRejection ? 'promise rejection' : 'exception'\n          } captured with keys: ${extractExceptionKeysForMessage(exception)}`,\n        },\n      ],\n    },\n    extra: {\n      __serialized__: normalizeToSize(exception),\n    },\n  };\n\n  if (syntheticException) {\n    var frames = parseStackFrames(stackParser, syntheticException);\n    if (frames.length) {\n      // event.exception.values[0] has been set above\n      (event.exception ).values[0].stacktrace = { frames };\n    }\n  }\n\n  return event;\n}\n\n/**\n * @hidden\n */\nfunction eventFromError(stackParser, ex) {\n  return {\n    exception: {\n      values: [exceptionFromError(stackParser, ex)],\n    },\n  };\n}\n\n/** Parses stack frames from an error */\nfunction parseStackFrames(\n  stackParser,\n  ex,\n) {\n  // Access and store the stacktrace property before doing ANYTHING\n  // else to it because Opera is not very good at providing it\n  // reliably in other circumstances.\n  var stacktrace = ex.stacktrace || ex.stack || '';\n\n  var popSize = getPopSize(ex);\n\n  try {\n    return stackParser(stacktrace, popSize);\n  } catch (e) {\n    // no-empty\n  }\n\n  return [];\n}\n\n// Based on our own mapping pattern - https://github.com/getsentry/sentry/blob/9f08305e09866c8bd6d0c24f5b0aabdd7dd6c59c/src/sentry/lang/javascript/errormapping.py#L83-L108\nvar reactMinifiedRegexp = /Minified React error #\\d+;/i;\n\nfunction getPopSize(ex) {\n  if (ex) {\n    if (typeof ex.framesToPop === 'number') {\n      return ex.framesToPop;\n    }\n\n    if (reactMinifiedRegexp.test(ex.message)) {\n      return 1;\n    }\n  }\n\n  return 0;\n}\n\n/**\n * There are cases where stacktrace.message is an Event object\n * https://github.com/getsentry/sentry-javascript/issues/1949\n * In this specific case we try to extract stacktrace.message.error.message\n */\nfunction extractMessage(ex) {\n  var message = ex && ex.message;\n  if (!message) {\n    return 'No error message';\n  }\n  if (message.error && typeof message.error.message === 'string') {\n    return message.error.message;\n  }\n  return message;\n}\n\n/**\n * Creates an {@link Event} from all inputs to `captureException` and non-primitive inputs to `captureMessage`.\n * @hidden\n */\nfunction eventFromException(\n  stackParser,\n  exception,\n  hint,\n  attachStacktrace,\n) {\n  var syntheticException = (hint && hint.syntheticException) || undefined;\n  var event = eventFromUnknownInput(stackParser, exception, syntheticException, attachStacktrace);\n  addExceptionMechanism(event); // defaults to { type: 'generic', handled: true }\n  event.level = 'error';\n  if (hint && hint.event_id) {\n    event.event_id = hint.event_id;\n  }\n  return resolvedSyncPromise(event);\n}\n\n/**\n * Builds and Event from a Message\n * @hidden\n */\nfunction eventFromMessage(\n  stackParser,\n  message,\n    level = 'info',\n  hint,\n  attachStacktrace,\n) {\n  var syntheticException = (hint && hint.syntheticException) || undefined;\n  var event = eventFromString(stackParser, message, syntheticException, attachStacktrace);\n  event.level = level;\n  if (hint && hint.event_id) {\n    event.event_id = hint.event_id;\n  }\n  return resolvedSyncPromise(event);\n}\n\n/**\n * @hidden\n */\nfunction eventFromUnknownInput(\n  stackParser,\n  exception,\n  syntheticException,\n  attachStacktrace,\n  isUnhandledRejection,\n) {\n  let event;\n\n  if (isErrorEvent(exception ) && (exception ).error) {\n    // If it is an ErrorEvent with `error` property, extract it to get actual Error\n    var errorEvent = exception ;\n    return eventFromError(stackParser, errorEvent.error );\n  }\n\n  // If it is a `DOMError` (which is a legacy API, but still supported in some browsers) then we just extract the name\n  // and message, as it doesn't provide anything else. According to the spec, all `DOMExceptions` should also be\n  // `Error`s, but that's not the case in IE11, so in that case we treat it the same as we do a `DOMError`.\n  //\n  // https://developer.mozilla.org/en-US/docs/Web/API/DOMError\n  // https://developer.mozilla.org/en-US/docs/Web/API/DOMException\n  // https://webidl.spec.whatwg.org/#es-DOMException-specialness\n  if (isDOMError(exception ) || isDOMException(exception )) {\n    var domException = exception ;\n\n    if ('stack' in (exception )) {\n      event = eventFromError(stackParser, exception );\n    } else {\n      var name = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException');\n      var message = domException.message ? `${name}: ${domException.message}` : name;\n      event = eventFromString(stackParser, message, syntheticException, attachStacktrace);\n      addExceptionTypeValue(event, message);\n    }\n    if ('code' in domException) {\n      event.tags = { ...event.tags, 'DOMException.code': `${domException.code}` };\n    }\n\n    return event;\n  }\n  if (isError(exception)) {\n    // we have a real Error object, do nothing\n    return eventFromError(stackParser, exception);\n  }\n  if (isPlainObject(exception) || isEvent(exception)) {\n    // If it's a plain object or an instance of `Event` (the built-in JS kind, not this SDK's `Event` type), serialize\n    // it manually. This will allow us to group events based on top-level keys which is much better than creating a new\n    // group on any key/value change.\n    var objectException = exception ;\n    event = eventFromPlainObject(stackParser, objectException, syntheticException, isUnhandledRejection);\n    addExceptionMechanism(event, {\n      synthetic: true,\n    });\n    return event;\n  }\n\n  // If none of previous checks were valid, then it means that it's not:\n  // - an instance of DOMError\n  // - an instance of DOMException\n  // - an instance of Event\n  // - an instance of Error\n  // - a valid ErrorEvent (one with an error property)\n  // - a plain Object\n  //\n  // So bail out and capture it as a simple message:\n  event = eventFromString(stackParser, exception , syntheticException, attachStacktrace);\n  addExceptionTypeValue(event, `${exception}`, undefined);\n  addExceptionMechanism(event, {\n    synthetic: true,\n  });\n\n  return event;\n}\n\n/**\n * @hidden\n */\nfunction eventFromString(\n  stackParser,\n  input,\n  syntheticException,\n  attachStacktrace,\n) {\n  var event = {\n    message: input,\n  };\n\n  if (attachStacktrace && syntheticException) {\n    var frames = parseStackFrames(stackParser, syntheticException);\n    if (frames.length) {\n      event.exception = {\n        values: [{ value: input, stacktrace: { frames } }],\n      };\n    }\n  }\n\n  return event;\n}\n\nexport { eventFromError, eventFromException, eventFromMessage, eventFromPlainObject, eventFromString, eventFromUnknownInput, exceptionFromError, parseStackFrames };\n//# sourceMappingURL=eventbuilder.js.map\n","// Note: Ideally the `SeverityLevel` type would be derived from `validSeverityLevels`, but that would mean either\n//\n// a) moving `validSeverityLevels` to `@sentry/types`,\n// b) moving the`SeverityLevel` type here, or\n// c) importing `validSeverityLevels` from here into `@sentry/types`.\n//\n// Option A would make `@sentry/types` a runtime dependency of `@sentry/utils` (not good), and options B and C would\n// create a circular dependency between `@sentry/types` and `@sentry/utils` (also not good). So a TODO accompanying the\n// type, reminding anyone who changes it to change this list also, will have to do.\n\nvar validSeverityLevels = ['fatal', 'error', 'warning', 'log', 'info', 'debug'];\n\n/**\n * Converts a string-based level into a member of the deprecated {@link Severity} enum.\n *\n * @deprecated `severityFromString` is deprecated. Please use `severityLevelFromString` instead.\n *\n * @param level String representation of Severity\n * @returns Severity\n */\nfunction severityFromString(level) {\n  return severityLevelFromString(level) ;\n}\n\n/**\n * Converts a string-based level into a `SeverityLevel`, normalizing it along the way.\n *\n * @param level String representation of desired `SeverityLevel`.\n * @returns The `SeverityLevel` corresponding to the given string, or 'log' if the string isn't a valid level.\n */\nfunction severityLevelFromString(level) {\n  return (level === 'warn' ? 'warning' : validSeverityLevels.includes(level) ? level : 'log') ;\n}\n\nexport { severityFromString, severityLevelFromString, validSeverityLevels };\n//# sourceMappingURL=severity.js.map\n","/**\n * Parses string form of URL into an object\n * // borrowed from https://tools.ietf.org/html/rfc3986#appendix-B\n * // intentionally using regex and not <a/> href parsing trick because React Native and other\n * // environments where DOM might not be available\n * @returns parsed URL object\n */\nfunction parseUrl(url)\n\n {\n  if (!url) {\n    return {};\n  }\n\n  var match = url.match(/^(([^:/?#]+):)?(\\/\\/([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$/);\n\n  if (!match) {\n    return {};\n  }\n\n  // coerce to undefined values to empty string so we don't get 'undefined'\n  var query = match[6] || '';\n  var fragment = match[8] || '';\n  return {\n    host: match[4],\n    path: match[5],\n    protocol: match[2],\n    relative: match[5] + query + fragment, // everything minus origin\n  };\n}\n\n/**\n * Strip the query string and fragment off of a given URL or path (if present)\n *\n * @param urlPath Full URL or path, including possible query string and/or fragment\n * @returns URL or path without query string or fragment\n */\nfunction stripUrlQueryAndFragment(urlPath) {\n    return urlPath.split(/[\\?#]/, 1)[0];\n}\n\n/**\n * Returns number of URL segments of a passed string URL.\n */\nfunction getNumberOfUrlSegments(url) {\n  // split at '/' or at '\\/' to split regex urls correctly\n  return url.split(/\\\\?\\//).filter(s => s.length > 0 && s !== ',').length;\n}\n\nexport { getNumberOfUrlSegments, parseUrl, stripUrlQueryAndFragment };\n//# sourceMappingURL=url.js.map\n","import { getCurrentHub } from '@sentry/core';\nimport { addInstrumentationHandler, htmlTreeAsString, severityLevelFromString, safeJoin, getGlobalObject, parseUrl } from '@sentry/utils';\n\n/** JSDoc */\n\nvar BREADCRUMB_INTEGRATION_ID = 'Breadcrumbs';\n\n/**\n * Default Breadcrumbs instrumentations\n * TODO: Deprecated - with v6, this will be renamed to `Instrument`\n */\nclass Breadcrumbs  {\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = BREADCRUMB_INTEGRATION_ID;}\n\n  /**\n   * @inheritDoc\n   */\n   __init() {this.name = Breadcrumbs.id;}\n\n  /**\n   * Options of the breadcrumbs integration.\n   */\n  // This field is public, because we use it in the browser client to check if the `sentry` option is enabled.\n  \n\n  /**\n   * @inheritDoc\n   */\n   constructor(options) {;Breadcrumbs.prototype.__init.call(this);\n    this.options = {\n      console: true,\n      dom: true,\n      fetch: true,\n      history: true,\n      sentry: true,\n      xhr: true,\n      ...options,\n    };\n  }\n\n  /**\n   * Instrument browser built-ins w/ breadcrumb capturing\n   *  - Console API\n   *  - DOM API (click/typing)\n   *  - XMLHttpRequest API\n   *  - Fetch API\n   *  - History API\n   */\n   setupOnce() {\n    if (this.options.console) {\n      addInstrumentationHandler('console', _consoleBreadcrumb);\n    }\n    if (this.options.dom) {\n      addInstrumentationHandler('dom', _domBreadcrumb(this.options.dom));\n    }\n    if (this.options.xhr) {\n      addInstrumentationHandler('xhr', _xhrBreadcrumb);\n    }\n    if (this.options.fetch) {\n      addInstrumentationHandler('fetch', _fetchBreadcrumb);\n    }\n    if (this.options.history) {\n      addInstrumentationHandler('history', _historyBreadcrumb);\n    }\n  }\n} Breadcrumbs.__initStatic();\n\n/**\n * A HOC that creaes a function that creates breadcrumbs from DOM API calls.\n * This is a HOC so that we get access to dom options in the closure.\n */\nfunction _domBreadcrumb(dom) {\n    function _innerDomBreadcrumb(handlerData) {\n    let target;\n    let keyAttrs = typeof dom === 'object' ? dom.serializeAttribute : undefined;\n\n    if (typeof keyAttrs === 'string') {\n      keyAttrs = [keyAttrs];\n    }\n\n    // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n    try {\n      target = handlerData.event.target\n        ? htmlTreeAsString(handlerData.event.target , keyAttrs)\n        : htmlTreeAsString(handlerData.event , keyAttrs);\n    } catch (e) {\n      target = '<unknown>';\n    }\n\n    if (target.length === 0) {\n      return;\n    }\n\n    getCurrentHub().addBreadcrumb(\n      {\n        category: `ui.${handlerData.name}`,\n        message: target,\n      },\n      {\n        event: handlerData.event,\n        name: handlerData.name,\n        global: handlerData.global,\n      },\n    );\n  }\n\n  return _innerDomBreadcrumb;\n}\n\n/**\n * Creates breadcrumbs from console API calls\n */\nfunction _consoleBreadcrumb(handlerData) {\n  var breadcrumb = {\n    category: 'console',\n    data: {\n      arguments: handlerData.args,\n      logger: 'console',\n    },\n    level: severityLevelFromString(handlerData.level),\n    message: safeJoin(handlerData.args, ' '),\n  };\n\n  if (handlerData.level === 'assert') {\n    if (handlerData.args[0] === false) {\n      breadcrumb.message = `Assertion failed: ${safeJoin(handlerData.args.slice(1), ' ') || 'console.assert'}`;\n      breadcrumb.data.arguments = handlerData.args.slice(1);\n    } else {\n      // Don't capture a breadcrumb for passed assertions\n      return;\n    }\n  }\n\n  getCurrentHub().addBreadcrumb(breadcrumb, {\n    input: handlerData.args,\n    level: handlerData.level,\n  });\n}\n\n/**\n * Creates breadcrumbs from XHR API calls\n */\nfunction _xhrBreadcrumb(handlerData) {\n  if (handlerData.endTimestamp) {\n    // We only capture complete, non-sentry requests\n    if (handlerData.xhr.__sentry_own_request__) {\n      return;\n    }\n\n    const { method, url, status_code, body } = handlerData.xhr.__sentry_xhr__ || {};\n\n    getCurrentHub().addBreadcrumb(\n      {\n        category: 'xhr',\n        data: {\n          method,\n          url,\n          status_code,\n        },\n        type: 'http',\n      },\n      {\n        xhr: handlerData.xhr,\n        input: body,\n      },\n    );\n\n    return;\n  }\n}\n\n/**\n * Creates breadcrumbs from fetch API calls\n */\nfunction _fetchBreadcrumb(handlerData) {\n  // We only capture complete fetch requests\n  if (!handlerData.endTimestamp) {\n    return;\n  }\n\n  if (handlerData.fetchData.url.match(/sentry_key/) && handlerData.fetchData.method === 'POST') {\n    // We will not create breadcrumbs for fetch requests that contain `sentry_key` (internal sentry requests)\n    return;\n  }\n\n  if (handlerData.error) {\n    getCurrentHub().addBreadcrumb(\n      {\n        category: 'fetch',\n        data: handlerData.fetchData,\n        level: 'error',\n        type: 'http',\n      },\n      {\n        data: handlerData.error,\n        input: handlerData.args,\n      },\n    );\n  } else {\n    getCurrentHub().addBreadcrumb(\n      {\n        category: 'fetch',\n        data: {\n          ...handlerData.fetchData,\n          status_code: handlerData.response.status,\n        },\n        type: 'http',\n      },\n      {\n        input: handlerData.args,\n        response: handlerData.response,\n      },\n    );\n  }\n}\n\n/**\n * Creates breadcrumbs from history API calls\n */\nfunction _historyBreadcrumb(handlerData) {\n  var global = getGlobalObject();\n  let from = handlerData.from;\n  let to = handlerData.to;\n  var parsedLoc = parseUrl(global.location.href);\n  let parsedFrom = parseUrl(from);\n  var parsedTo = parseUrl(to);\n\n  // Initial pushState doesn't provide `from` information\n  if (!parsedFrom.path) {\n    parsedFrom = parsedLoc;\n  }\n\n  // Use only the path component of the URL if the URL matches the current\n  // document (almost all the time when using pushState)\n  if (parsedLoc.protocol === parsedTo.protocol && parsedLoc.host === parsedTo.host) {\n    to = parsedTo.relative;\n  }\n  if (parsedLoc.protocol === parsedFrom.protocol && parsedLoc.host === parsedFrom.host) {\n    from = parsedFrom.relative;\n  }\n\n  getCurrentHub().addBreadcrumb({\n    category: 'navigation',\n    data: {\n      from,\n      to,\n    },\n  });\n}\n\nexport { BREADCRUMB_INTEGRATION_ID, Breadcrumbs };\n//# sourceMappingURL=breadcrumbs.js.map\n","import { getGlobalObject, isNativeFetch, logger, supportsFetch } from '@sentry/utils';\n\nvar global = getGlobalObject();\nlet cachedFetchImpl;\n\n/**\n * A special usecase for incorrectly wrapped Fetch APIs in conjunction with ad-blockers.\n * Whenever someone wraps the Fetch API and returns the wrong promise chain,\n * this chain becomes orphaned and there is no possible way to capture it's rejections\n * other than allowing it bubble up to this very handler. eg.\n *\n * var f = window.fetch;\n * window.fetch = function () {\n *   var p = f.apply(this, arguments);\n *\n *   p.then(function() {\n *     console.log('hi.');\n *   });\n *\n *   return p;\n * }\n *\n * `p.then(function () { ... })` is producing a completely separate promise chain,\n * however, what's returned is `p` - the result of original `fetch` call.\n *\n * This mean, that whenever we use the Fetch API to send our own requests, _and_\n * some ad-blocker blocks it, this orphaned chain will _always_ reject,\n * effectively causing another event to be captured.\n * This makes a whole process become an infinite loop, which we need to somehow\n * deal with, and break it in one way or another.\n *\n * To deal with this issue, we are making sure that we _always_ use the real\n * browser Fetch API, instead of relying on what `window.fetch` exposes.\n * The only downside to this would be missing our own requests as breadcrumbs,\n * but because we are already not doing this, it should be just fine.\n *\n * Possible failed fetch error messages per-browser:\n *\n * Chrome:  Failed to fetch\n * Edge:    Failed to Fetch\n * Firefox: NetworkError when attempting to fetch resource\n * Safari:  resource blocked by content blocker\n */\nfunction getNativeFetchImplementation() {\n  if (cachedFetchImpl) {\n    return cachedFetchImpl;\n  }\n\n  // Fast path to avoid DOM I/O\n  if (isNativeFetch(global.fetch)) {\n    return (cachedFetchImpl = global.fetch.bind(global));\n  }\n\n  var document = global.document;\n  let fetchImpl = global.fetch;\n    if (document && typeof document.createElement === 'function') {\n    try {\n      var sandbox = document.createElement('iframe');\n      sandbox.hidden = true;\n      document.head.appendChild(sandbox);\n      var contentWindow = sandbox.contentWindow;\n      if (contentWindow && contentWindow.fetch) {\n        fetchImpl = contentWindow.fetch;\n      }\n      document.head.removeChild(sandbox);\n    } catch (e) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', e);\n    }\n  }\n\n  return (cachedFetchImpl = fetchImpl.bind(global));\n  }\n\n/**\n * Sends sdk client report using sendBeacon or fetch as a fallback if available\n *\n * @param url report endpoint\n * @param body report payload\n */\nfunction sendReport(url, body) {\n  var isRealNavigator = Object.prototype.toString.call(global && global.navigator) === '[object Navigator]';\n  var hasSendBeacon = isRealNavigator && typeof global.navigator.sendBeacon === 'function';\n\n  if (hasSendBeacon) {\n    // Prevent illegal invocations - https://xgwang.me/posts/you-may-not-know-beacon/#it-may-throw-error%2C-be-sure-to-catch\n    var sendBeacon = global.navigator.sendBeacon.bind(global.navigator);\n    sendBeacon(url, body);\n  } else if (supportsFetch()) {\n    var fetch = getNativeFetchImplementation();\n    fetch(url, {\n      body,\n      method: 'POST',\n      credentials: 'omit',\n      keepalive: true,\n    }).then(null, error => {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error(error);\n    });\n  }\n}\n\nexport { getNativeFetchImplementation, sendReport };\n//# sourceMappingURL=utils.js.map\n","import { BaseClient, SDK_VERSION, getCurrentHub, getEnvelopeEndpointWithUrlEncodedAuth } from '@sentry/core';\nimport { getGlobalObject, getEventDescription, logger, createClientReportEnvelope, dsnToString, serializeEnvelope } from '@sentry/utils';\nimport { eventFromException, eventFromMessage } from './eventbuilder.js';\nimport { BREADCRUMB_INTEGRATION_ID } from './integrations/breadcrumbs.js';\nimport { sendReport } from './transports/utils.js';\n\nvar globalObject = getGlobalObject();\n\n/**\n * The Sentry Browser SDK Client.\n *\n * @see BrowserOptions for documentation on configuration options.\n * @see SentryClient for usage documentation.\n */\nclass BrowserClient extends BaseClient {\n  /**\n   * Creates a new Browser SDK instance.\n   *\n   * @param options Configuration options for this SDK.\n   */\n   constructor(options) {\n    options._metadata = options._metadata || {};\n    options._metadata.sdk = options._metadata.sdk || {\n      name: 'sentry.javascript.browser',\n      packages: [\n        {\n          name: 'npm:@sentry/browser',\n          version: SDK_VERSION,\n        },\n      ],\n      version: SDK_VERSION,\n    };\n\n    super(options);\n\n    if (options.sendClientReports && globalObject.document) {\n      globalObject.document.addEventListener('visibilitychange', () => {\n        if (globalObject.document.visibilityState === 'hidden') {\n          this._flushOutcomes();\n        }\n      });\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   eventFromException(exception, hint) {\n    return eventFromException(this._options.stackParser, exception, hint, this._options.attachStacktrace);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   eventFromMessage(\n    message,\n        level = 'info',\n    hint,\n  ) {\n    return eventFromMessage(this._options.stackParser, message, level, hint, this._options.attachStacktrace);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   sendEvent(event, hint) {\n    // We only want to add the sentry event breadcrumb when the user has the breadcrumb integration installed and\n    // activated its `sentry` option.\n    // We also do not want to use the `Breadcrumbs` class here directly, because we do not want it to be included in\n    // bundles, if it is not used by the SDK.\n    // This all sadly is a bit ugly, but we currently don't have a \"pre-send\" hook on the integrations so we do it this\n    // way for now.\n    var breadcrumbIntegration = this.getIntegrationById(BREADCRUMB_INTEGRATION_ID) ;\n    if (\n      breadcrumbIntegration &&\n      // We check for definedness of `options`, even though it is not strictly necessary, because that access to\n      // `.sentry` below does not throw, in case users provided their own integration with id \"Breadcrumbs\" that does\n      // not have an`options` field\n      breadcrumbIntegration.options &&\n      breadcrumbIntegration.options.sentry\n    ) {\n      getCurrentHub().addBreadcrumb(\n        {\n          category: `sentry.${event.type === 'transaction' ? 'transaction' : 'event'}`,\n          event_id: event.event_id,\n          level: event.level,\n          message: getEventDescription(event),\n        },\n        {\n          event,\n        },\n      );\n    }\n\n    super.sendEvent(event, hint);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   _prepareEvent(event, hint, scope) {\n    event.platform = event.platform || 'javascript';\n    return super._prepareEvent(event, hint, scope);\n  }\n\n  /**\n   * Sends client reports as an envelope.\n   */\n   _flushOutcomes() {\n    var outcomes = this._clearOutcomes();\n\n    if (outcomes.length === 0) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('No outcomes to send');\n      return;\n    }\n\n    if (!this._dsn) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('No dsn provided, will not send outcomes');\n      return;\n    }\n\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('Sending outcomes:', outcomes);\n\n    var url = getEnvelopeEndpointWithUrlEncodedAuth(this._dsn, this._options);\n    var envelope = createClientReportEnvelope(outcomes, this._options.tunnel && dsnToString(this._dsn));\n\n    try {\n      sendReport(url, serializeEnvelope(envelope));\n    } catch (e) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error(e);\n    }\n  }\n}\n\nexport { BrowserClient };\n//# sourceMappingURL=client.js.map\n","import { createEnvelope } from './envelope.js';\nimport { dateTimestampInSeconds } from './time.js';\n\n/**\n * Creates client report envelope\n * @param discarded_events An array of discard events\n * @param dsn A DSN that can be set on the header. Optional.\n */\nfunction createClientReportEnvelope(\n  discarded_events,\n  dsn,\n  timestamp,\n) {\n  var clientReportItem = [\n    { type: 'client_report' },\n    {\n      timestamp: timestamp || dateTimestampInSeconds(),\n      discarded_events,\n    },\n  ];\n  return createEnvelope(dsn ? { dsn } : {}, [clientReportItem]);\n}\n\nexport { createClientReportEnvelope };\n//# sourceMappingURL=clientreport.js.map\n","import { createStackParser } from '@sentry/utils';\n\n// global reference to slice\nvar UNKNOWN_FUNCTION = '?';\n\nvar OPERA10_PRIORITY = 10;\nvar OPERA11_PRIORITY = 20;\nvar CHROME_PRIORITY = 30;\nvar WINJS_PRIORITY = 40;\nvar GECKO_PRIORITY = 50;\n\nfunction createFrame(filename, func, lineno, colno) {\n  var frame = {\n    filename,\n    function: func,\n    // All browser frames are considered in_app\n    in_app: true,\n  };\n\n  if (lineno !== undefined) {\n    frame.lineno = lineno;\n  }\n\n  if (colno !== undefined) {\n    frame.colno = colno;\n  }\n\n  return frame;\n}\n\n// Chromium based browsers: Chrome, Brave, new Opera, new Edge\nvar chromeRegex =\n  /^\\s*at (?:(.*\\).*?|.*?) ?\\((?:address at )?)?((?:file|https?|blob|chrome-extension|address|native|eval|webpack|<anonymous>|[-a-z]+:|.*bundle|\\/)?.*?)(?::(\\d+))?(?::(\\d+))?\\)?\\s*$/i;\nvar chromeEvalRegex = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/;\n\nvar chrome = line => {\n  var parts = chromeRegex.exec(line);\n\n  if (parts) {\n    var isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n\n    if (isEval) {\n      var subMatch = chromeEvalRegex.exec(parts[2]);\n\n      if (subMatch) {\n        // throw out eval line/column and use top-most line/column number\n        parts[2] = subMatch[1]; // url\n        parts[3] = subMatch[2]; // line\n        parts[4] = subMatch[3]; // column\n      }\n    }\n\n    // Kamil: One more hack won't hurt us right? Understanding and adding more rules on top of these regexps right now\n    // would be way too time consuming. (TODO: Rewrite whole RegExp to be more readable)\n    const [func, filename] = extractSafariExtensionDetails(parts[1] || UNKNOWN_FUNCTION, parts[2]);\n\n    return createFrame(filename, func, parts[3] ? +parts[3] : undefined, parts[4] ? +parts[4] : undefined);\n  }\n\n  return;\n};\n\nvar chromeStackLineParser = [CHROME_PRIORITY, chrome];\n\n// gecko regex: `(?:bundle|\\d+\\.js)`: `bundle` is for react native, `\\d+\\.js` also but specifically for ram bundles because it\n// generates filenames without a prefix like `file://` the filenames in the stacktrace are just 42.js\n// We need this specific case for now because we want no other regex to match.\nvar geckoREgex =\n  /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)?((?:file|https?|blob|chrome|webpack|resource|moz-extension|safari-extension|safari-web-extension|capacitor)?:\\/.*?|\\[native code\\]|[^@]*(?:bundle|\\d+\\.js)|\\/[\\w\\-. /=]+)(?::(\\d+))?(?::(\\d+))?\\s*$/i;\nvar geckoEvalRegex = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\n\nvar gecko = line => {\n  var parts = geckoREgex.exec(line);\n\n  if (parts) {\n    var isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n    if (isEval) {\n      var subMatch = geckoEvalRegex.exec(parts[3]);\n\n      if (subMatch) {\n        // throw out eval line/column and use top-most line number\n        parts[1] = parts[1] || 'eval';\n        parts[3] = subMatch[1];\n        parts[4] = subMatch[2];\n        parts[5] = ''; // no column when eval\n      }\n    }\n\n    let filename = parts[3];\n    let func = parts[1] || UNKNOWN_FUNCTION;\n    [func, filename] = extractSafariExtensionDetails(func, filename);\n\n    return createFrame(filename, func, parts[4] ? +parts[4] : undefined, parts[5] ? +parts[5] : undefined);\n  }\n\n  return;\n};\n\nvar geckoStackLineParser = [GECKO_PRIORITY, gecko];\n\nvar winjsRegex =\n  /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i;\n\nvar winjs = line => {\n  var parts = winjsRegex.exec(line);\n\n  return parts\n    ? createFrame(parts[2], parts[1] || UNKNOWN_FUNCTION, +parts[3], parts[4] ? +parts[4] : undefined)\n    : undefined;\n};\n\nvar winjsStackLineParser = [WINJS_PRIORITY, winjs];\n\nvar opera10Regex = / line (\\d+).*script (?:in )?(\\S+)(?:: in function (\\S+))?$/i;\n\nvar opera10 = line => {\n  var parts = opera10Regex.exec(line);\n  return parts ? createFrame(parts[2], parts[3] || UNKNOWN_FUNCTION, +parts[1]) : undefined;\n};\n\nvar opera10StackLineParser = [OPERA10_PRIORITY, opera10];\n\nvar opera11Regex =\n  / line (\\d+), column (\\d+)\\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\\(.*\\))? in (.*):\\s*$/i;\n\nvar opera11 = line => {\n  var parts = opera11Regex.exec(line);\n  return parts ? createFrame(parts[5], parts[3] || parts[4] || UNKNOWN_FUNCTION, +parts[1], +parts[2]) : undefined;\n};\n\nvar opera11StackLineParser = [OPERA11_PRIORITY, opera11];\n\nvar defaultStackLineParsers = [chromeStackLineParser, geckoStackLineParser, winjsStackLineParser];\n\nvar defaultStackParser = createStackParser(...defaultStackLineParsers);\n\n/**\n * Safari web extensions, starting version unknown, can produce \"frames-only\" stacktraces.\n * What it means, is that instead of format like:\n *\n * Error: wat\n *   at function@url:row:col\n *   at function@url:row:col\n *   at function@url:row:col\n *\n * it produces something like:\n *\n *   function@url:row:col\n *   function@url:row:col\n *   function@url:row:col\n *\n * Because of that, it won't be captured by `chrome` RegExp and will fall into `Gecko` branch.\n * This function is extracted so that we can use it in both places without duplicating the logic.\n * Unfortunately \"just\" changing RegExp is too complicated now and making it pass all tests\n * and fix this case seems like an impossible, or at least way too time-consuming task.\n */\nvar extractSafariExtensionDetails = (func, filename) => {\n  var isSafariExtension = func.indexOf('safari-extension') !== -1;\n  var isSafariWebExtension = func.indexOf('safari-web-extension') !== -1;\n\n  return isSafariExtension || isSafariWebExtension\n    ? [\n        func.indexOf('@') !== -1 ? func.split('@')[0] : UNKNOWN_FUNCTION,\n        isSafariExtension ? `safari-extension:${filename}` : `safari-web-extension:${filename}`,\n      ]\n    : [func, filename];\n};\n\nexport { chromeStackLineParser, defaultStackLineParsers, defaultStackParser, geckoStackLineParser, opera10StackLineParser, opera11StackLineParser, winjsStackLineParser };\n//# sourceMappingURL=stack-parsers.js.map\n","import { getCurrentHub } from './hub.js';\n\n// Note: All functions in this file are typed with a return value of `ReturnType<Hub[HUB_FUNCTION]>`,\n// where HUB_FUNCTION is some method on the Hub class.\n//\n// This is done to make sure the top level SDK methods stay in sync with the hub methods.\n// Although every method here has an explicit return type, some of them (that map to void returns) do not\n// contain `return` keywords. This is done to save on bundle size, as `return` is not minifiable.\n\n/**\n * Captures an exception event and sends it to Sentry.\n *\n * @param exception An exception-like object.\n * @param captureContext Additional scope data to apply to exception event.\n * @returns The generated eventId.\n */\nfunction captureException(exception, captureContext) {\n  return getCurrentHub().captureException(exception, { captureContext });\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 Severity Define the level of the message.\n * @returns The generated eventId.\n */\nfunction captureMessage(\n  message,\n    captureContext,\n) {\n  // This is necessary to provide explicit scopes upgrade, without changing the original\n  // arity of the `captureMessage(message, level)` method.\n  var level = typeof captureContext === 'string' ? captureContext : undefined;\n  var context = typeof captureContext !== 'string' ? { captureContext } : undefined;\n  return getCurrentHub().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 * @returns The generated eventId.\n */\nfunction captureEvent(event, hint) {\n  return getCurrentHub().captureEvent(event, hint);\n}\n\n/**\n * Callback to set context information onto the scope.\n * @param callback Callback function that receives Scope.\n */\nfunction configureScope(callback) {\n  getCurrentHub().configureScope(callback);\n}\n\n/**\n * Records a new breadcrumb which will be attached to future events.\n *\n * Breadcrumbs will be added to subsequent events to provide more context on\n * user's actions prior to an error or crash.\n *\n * @param breadcrumb The breadcrumb to record.\n */\nfunction addBreadcrumb(breadcrumb) {\n  getCurrentHub().addBreadcrumb(breadcrumb);\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  getCurrentHub().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  getCurrentHub().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  getCurrentHub().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  getCurrentHub().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  getCurrentHub().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  getCurrentHub().setUser(user);\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 * This is essentially a convenience function for:\n *\n *     pushScope();\n *     callback();\n *     popScope();\n *\n * @param callback that will be enclosed into push/popScope.\n */\nfunction withScope(callback) {\n  getCurrentHub().withScope(callback);\n}\n\n/**\n * Starts a new `Transaction` and returns it. This is the entry point to manual tracing instrumentation.\n *\n * A tree structure can be built by adding child spans to the transaction, and child spans to other spans. To start a\n * new child span within the transaction or any span, call the respective `.startChild()` method.\n *\n * Every child span must be finished before the transaction is finished, otherwise the unfinished spans are discarded.\n *\n * The transaction must be finished with a call to its `.finish()` method, at which point the transaction with all its\n * finished child spans will be sent to Sentry.\n *\n * NOTE: This function should only be used for *manual* instrumentation. Auto-instrumentation should call\n * `startTransaction` directly on the hub.\n *\n * @param context Properties of the new `Transaction`.\n * @param customSamplingContext Information given to the transaction sampling function (along with context-dependent\n * default values). See {@link Options.tracesSampler}.\n *\n * @returns The transaction which was just started\n */\nfunction startTransaction(\n  context,\n  customSamplingContext,\n) {\n  return getCurrentHub().startTransaction(\n    {\n      metadata: { source: 'custom' },\n      ...context,\n    },\n    customSamplingContext,\n  );\n}\n\nexport { addBreadcrumb, captureEvent, captureException, captureMessage, configureScope, setContext, setExtra, setExtras, setTag, setTags, setUser, startTransaction, withScope };\n//# sourceMappingURL=exports.js.map\n","import { withScope, captureException } from '@sentry/core';\nimport { getOriginalFunction, addExceptionTypeValue, addExceptionMechanism, markFunctionWrapped, addNonEnumerableProperty } from '@sentry/utils';\n\nlet ignoreOnError = 0;\n\n/**\n * @hidden\n */\nfunction shouldIgnoreOnError() {\n  return ignoreOnError > 0;\n}\n\n/**\n * @hidden\n */\nfunction ignoreNextOnError() {\n  // onerror should trigger before setTimeout\n  ignoreOnError += 1;\n  setTimeout(() => {\n    ignoreOnError -= 1;\n  });\n}\n\n/**\n * Instruments the given function and sends an event to Sentry every time the\n * function throws an exception.\n *\n * @param fn A function to wrap. It is generally safe to pass an unbound function, because the returned wrapper always\n * has a correct `this` context.\n * @returns The wrapped function.\n * @hidden\n */\nfunction wrap(\n  fn,\n  options\n\n = {},\n  before,\n  ) {\n  // for future readers what this does is wrap a function and then create\n  // a bi-directional wrapping between them.\n  //\n  // example: wrapped = wrap(original);\n  //  original.__sentry_wrapped__ -> wrapped\n  //  wrapped.__sentry_original__ -> original\n\n  if (typeof fn !== 'function') {\n    return fn;\n  }\n\n  try {\n    // if we're dealing with a function that was previously wrapped, return\n    // the original wrapper.\n    var wrapper = fn.__sentry_wrapped__;\n    if (wrapper) {\n      return wrapper;\n    }\n\n    // We don't wanna wrap it twice\n    if (getOriginalFunction(fn)) {\n      return fn;\n    }\n  } catch (e) {\n    // Just accessing custom props in some Selenium environments\n    // can cause a \"Permission denied\" exception (see raven-js#495).\n    // Bail on wrapping and return the function as-is (defers to window.onerror).\n    return fn;\n  }\n\n    // It is important that `sentryWrapped` is not an arrow function to preserve the context of `this`\n  var sentryWrapped = function () {\n    var args = Array.prototype.slice.call(arguments);\n\n    try {\n      if (before && typeof before === 'function') {\n        before.apply(this, arguments);\n      }\n\n            var wrappedArguments = args.map((arg) => wrap(arg, options));\n\n      // Attempt to invoke user-land function\n      // NOTE: If you are a Sentry user, and you are seeing this stack frame, it\n      //       means the sentry.javascript SDK caught an error invoking your application code. This\n      //       is expected behavior and NOT indicative of a bug with sentry.javascript.\n      return fn.apply(this, wrappedArguments);\n    } catch (ex) {\n      ignoreNextOnError();\n\n      withScope((scope) => {\n        scope.addEventProcessor((event) => {\n          if (options.mechanism) {\n            addExceptionTypeValue(event, undefined, undefined);\n            addExceptionMechanism(event, options.mechanism);\n          }\n\n          event.extra = {\n            ...event.extra,\n            arguments: args,\n          };\n\n          return event;\n        });\n\n        captureException(ex);\n      });\n\n      throw ex;\n    }\n  };\n  \n  // Accessing some objects may throw\n  // ref: https://github.com/getsentry/sentry-javascript/issues/1168\n  try {\n    for (var property in fn) {\n      if (Object.prototype.hasOwnProperty.call(fn, property)) {\n        sentryWrapped[property] = fn[property];\n      }\n    }\n  } catch (_oO) {} \n  // Signal that this function has been wrapped/filled already\n  // for both debugging and to prevent it to being wrapped/filled twice\n  markFunctionWrapped(sentryWrapped, fn);\n\n  addNonEnumerableProperty(fn, '__sentry_wrapped__', sentryWrapped);\n\n  // Restore original function name (not all browsers allow that)\n  try {\n    var descriptor = Object.getOwnPropertyDescriptor(sentryWrapped, 'name') ;\n    if (descriptor.configurable) {\n      Object.defineProperty(sentryWrapped, 'name', {\n        get() {\n          return fn.name;\n        },\n      });\n    }\n      } catch (_oO) {}\n\n  return sentryWrapped;\n}\n\n/**\n * All properties the report dialog supports\n */\n\nexport { ignoreNextOnError, shouldIgnoreOnError, wrap };\n//# sourceMappingURL=helpers.js.map\n","import { getGlobalObject, fill, getFunctionName, getOriginalFunction } from '@sentry/utils';\nimport { wrap } from '../helpers.js';\n\nvar DEFAULT_EVENT_TARGET = [\n  'EventTarget',\n  'Window',\n  'Node',\n  'ApplicationCache',\n  'AudioTrackList',\n  'ChannelMergerNode',\n  'CryptoOperation',\n  'EventSource',\n  'FileReader',\n  'HTMLUnknownElement',\n  'IDBDatabase',\n  'IDBRequest',\n  'IDBTransaction',\n  'KeyOperation',\n  'MediaController',\n  'MessagePort',\n  'ModalWindow',\n  'Notification',\n  'SVGElementInstance',\n  'Screen',\n  'TextTrack',\n  'TextTrackCue',\n  'TextTrackList',\n  'WebSocket',\n  'WebSocketWorker',\n  'Worker',\n  'XMLHttpRequest',\n  'XMLHttpRequestEventTarget',\n  'XMLHttpRequestUpload',\n];\n\n/** Wrap timer functions and event targets to catch errors and provide better meta data */\nclass TryCatch  {\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = 'TryCatch';}\n\n  /**\n   * @inheritDoc\n   */\n   __init() {this.name = TryCatch.id;}\n\n  /** JSDoc */\n  \n\n  /**\n   * @inheritDoc\n   */\n   constructor(options) {;TryCatch.prototype.__init.call(this);\n    this._options = {\n      XMLHttpRequest: true,\n      eventTarget: true,\n      requestAnimationFrame: true,\n      setInterval: true,\n      setTimeout: true,\n      ...options,\n    };\n  }\n\n  /**\n   * Wrap timer functions and event targets to catch errors\n   * and provide better metadata.\n   */\n   setupOnce() {\n    var global = getGlobalObject();\n\n    if (this._options.setTimeout) {\n      fill(global, 'setTimeout', _wrapTimeFunction);\n    }\n\n    if (this._options.setInterval) {\n      fill(global, 'setInterval', _wrapTimeFunction);\n    }\n\n    if (this._options.requestAnimationFrame) {\n      fill(global, 'requestAnimationFrame', _wrapRAF);\n    }\n\n    if (this._options.XMLHttpRequest && 'XMLHttpRequest' in global) {\n      fill(XMLHttpRequest.prototype, 'send', _wrapXHR);\n    }\n\n    var eventTargetOption = this._options.eventTarget;\n    if (eventTargetOption) {\n      var eventTarget = Array.isArray(eventTargetOption) ? eventTargetOption : DEFAULT_EVENT_TARGET;\n      eventTarget.forEach(_wrapEventTarget);\n    }\n  }\n} TryCatch.__initStatic();\n\n/** JSDoc */\nfunction _wrapTimeFunction(original) {\n    return function ( ...args) {\n    var originalCallback = args[0];\n    args[0] = wrap(originalCallback, {\n      mechanism: {\n        data: { function: getFunctionName(original) },\n        handled: true,\n        type: 'instrument',\n      },\n    });\n    return original.apply(this, args);\n  };\n}\n\n/** JSDoc */\nfunction _wrapRAF(original) {\n    return function ( callback) {\n        return original.apply(this, [\n      wrap(callback, {\n        mechanism: {\n          data: {\n            function: 'requestAnimationFrame',\n            handler: getFunctionName(original),\n          },\n          handled: true,\n          type: 'instrument',\n        },\n      }),\n    ]);\n  };\n}\n\n/** JSDoc */\nfunction _wrapXHR(originalSend) {\n    return function ( ...args) {\n        var xhr = this;\n    var xmlHttpRequestProps = ['onload', 'onerror', 'onprogress', 'onreadystatechange'];\n\n    xmlHttpRequestProps.forEach(prop => {\n      if (prop in xhr && typeof xhr[prop] === 'function') {\n                fill(xhr, prop, function (original) {\n          var wrapOptions = {\n            mechanism: {\n              data: {\n                function: prop,\n                handler: getFunctionName(original),\n              },\n              handled: true,\n              type: 'instrument',\n            },\n          };\n\n          // If Instrument integration has been called before TryCatch, get the name of original function\n          var originalFunction = getOriginalFunction(original);\n          if (originalFunction) {\n            wrapOptions.mechanism.data.handler = getFunctionName(originalFunction);\n          }\n\n          // Otherwise wrap directly\n          return wrap(original, wrapOptions);\n        });\n      }\n    });\n\n    return originalSend.apply(this, args);\n  };\n}\n\n/** JSDoc */\nfunction _wrapEventTarget(target) {\n    var global = getGlobalObject() ;\n    var proto = global[target] && global[target].prototype;\n\n    if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n    return;\n  }\n\n  fill(proto, 'addEventListener', function (original)\n\n {\n    return function (\n            \n      eventName,\n      fn,\n      options,\n    ) {\n      try {\n        if (typeof fn.handleEvent === 'function') {\n          // ESlint disable explanation:\n          //  First, it is generally safe to call `wrap` with an unbound function. Furthermore, using `.bind()` would\n          //  introduce a bug here, because bind returns a new function that doesn't have our\n          //  flags(like __sentry_original__) attached. `wrap` checks for those flags to avoid unnecessary wrapping.\n          //  Without those flags, every call to addEventListener wraps the function again, causing a memory leak.\n                    fn.handleEvent = wrap(fn.handleEvent, {\n            mechanism: {\n              data: {\n                function: 'handleEvent',\n                handler: getFunctionName(fn),\n                target,\n              },\n              handled: true,\n              type: 'instrument',\n            },\n          });\n        }\n      } catch (err) {\n        // can sometimes get 'Permission denied to access property \"handle Event'\n      }\n\n      return original.apply(this, [\n        eventName,\n                wrap(fn , {\n          mechanism: {\n            data: {\n              function: 'addEventListener',\n              handler: getFunctionName(fn),\n              target,\n            },\n            handled: true,\n            type: 'instrument',\n          },\n        }),\n        options,\n      ]);\n    };\n  });\n\n  fill(\n    proto,\n    'removeEventListener',\n    function (\n      originalRemoveEventListener,\n          ) {\n      return function (\n                \n        eventName,\n        fn,\n        options,\n      ) {\n        /**\n         * There are 2 possible scenarios here:\n         *\n         * 1. Someone passes a callback, which was attached prior to Sentry initialization, or by using unmodified\n         * method, eg. `document.addEventListener.call(el, name, handler). In this case, we treat this function\n         * as a pass-through, and call original `removeEventListener` with it.\n         *\n         * 2. Someone passes a callback, which was attached after Sentry was initialized, which means that it was using\n         * our wrapped version of `addEventListener`, which internally calls `wrap` helper.\n         * This helper \"wraps\" whole callback inside a try/catch statement, and attached appropriate metadata to it,\n         * in order for us to make a distinction between wrapped/non-wrapped functions possible.\n         * If a function was wrapped, it has additional property of `__sentry_wrapped__`, holding the handler.\n         *\n         * When someone adds a handler prior to initialization, and then do it again, but after,\n         * then we have to detach both of them. Otherwise, if we'd detach only wrapped one, it'd be impossible\n         * to get rid of the initial handler and it'd stick there forever.\n         */\n        var wrappedEventHandler = fn ;\n        try {\n          var originalEventHandler = wrappedEventHandler && wrappedEventHandler.__sentry_wrapped__;\n          if (originalEventHandler) {\n            originalRemoveEventListener.call(this, eventName, originalEventHandler, options);\n          }\n        } catch (e) {\n          // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments\n        }\n        return originalRemoveEventListener.call(this, eventName, wrappedEventHandler, options);\n      };\n    },\n  );\n}\n\nexport { TryCatch };\n//# sourceMappingURL=trycatch.js.map\n","import { getCurrentHub } from '@sentry/core';\nimport { addInstrumentationHandler, isString, isPrimitive, isErrorEvent, getLocationHref, logger, addExceptionMechanism } from '@sentry/utils';\nimport { eventFromUnknownInput } from '../eventbuilder.js';\nimport { shouldIgnoreOnError } from '../helpers.js';\n\n/** Global handlers */\nclass GlobalHandlers  {\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = 'GlobalHandlers';}\n\n  /**\n   * @inheritDoc\n   */\n   __init() {this.name = GlobalHandlers.id;}\n\n  /** JSDoc */\n  \n\n  /**\n   * Stores references functions to installing handlers. Will set to undefined\n   * after they have been run so that they are not used twice.\n   */\n   __init2() {this._installFunc = {\n    onerror: _installGlobalOnErrorHandler,\n    onunhandledrejection: _installGlobalOnUnhandledRejectionHandler,\n  };}\n\n  /** JSDoc */\n   constructor(options) {;GlobalHandlers.prototype.__init.call(this);GlobalHandlers.prototype.__init2.call(this);\n    this._options = {\n      onerror: true,\n      onunhandledrejection: true,\n      ...options,\n    };\n  }\n  /**\n   * @inheritDoc\n   */\n   setupOnce() {\n    Error.stackTraceLimit = 50;\n    var options = this._options;\n\n    // We can disable guard-for-in as we construct the options object above + do checks against\n    // `this._installFunc` for the property.\n        for (var key in options) {\n      var installFunc = this._installFunc[key ];\n      if (installFunc && options[key ]) {\n        globalHandlerLog(key);\n        installFunc();\n        this._installFunc[key ] = undefined;\n      }\n    }\n  }\n} GlobalHandlers.__initStatic();\n\n/** JSDoc */\nfunction _installGlobalOnErrorHandler() {\n  addInstrumentationHandler(\n    'error',\n        (data) => {\n      const [hub, stackParser, attachStacktrace] = getHubAndOptions();\n      if (!hub.getIntegration(GlobalHandlers)) {\n        return;\n      }\n      const { msg, url, line, column, error } = data;\n      if (shouldIgnoreOnError() || (error && error.__sentry_own_request__)) {\n        return;\n      }\n\n      var event =\n        error === undefined && isString(msg)\n          ? _eventFromIncompleteOnError(msg, url, line, column)\n          : _enhanceEventWithInitialFrame(\n              eventFromUnknownInput(stackParser, error || msg, undefined, attachStacktrace, false),\n              url,\n              line,\n              column,\n            );\n\n      event.level = 'error';\n\n      addMechanismAndCapture(hub, error, event, 'onerror');\n    },\n  );\n}\n\n/** JSDoc */\nfunction _installGlobalOnUnhandledRejectionHandler() {\n  addInstrumentationHandler(\n    'unhandledrejection',\n        (e) => {\n      const [hub, stackParser, attachStacktrace] = getHubAndOptions();\n      if (!hub.getIntegration(GlobalHandlers)) {\n        return;\n      }\n      let error = e;\n\n      // dig the object of the rejection out of known event types\n      try {\n        // PromiseRejectionEvents store the object of the rejection under 'reason'\n        // see https://developer.mozilla.org/en-US/docs/Web/API/PromiseRejectionEvent\n        if ('reason' in e) {\n          error = e.reason;\n        }\n        // something, somewhere, (likely a browser extension) effectively casts PromiseRejectionEvents\n        // to CustomEvents, moving the `promise` and `reason` attributes of the PRE into\n        // the CustomEvent's `detail` attribute, since they're not part of CustomEvent's spec\n        // see https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent and\n        // https://github.com/getsentry/sentry-javascript/issues/2380\n        else if ('detail' in e && 'reason' in e.detail) {\n          error = e.detail.reason;\n        }\n      } catch (_oO) {\n        // no-empty\n      }\n\n      if (shouldIgnoreOnError() || (error && error.__sentry_own_request__)) {\n        return true;\n      }\n\n      var event = isPrimitive(error)\n        ? _eventFromRejectionWithPrimitive(error)\n        : eventFromUnknownInput(stackParser, error, undefined, attachStacktrace, true);\n\n      event.level = 'error';\n\n      addMechanismAndCapture(hub, error, event, 'onunhandledrejection');\n      return;\n    },\n  );\n}\n\n/**\n * Create an event from a promise rejection where the `reason` is a primitive.\n *\n * @param reason: The `reason` property of the promise rejection\n * @returns An Event object with an appropriate `exception` value\n */\nfunction _eventFromRejectionWithPrimitive(reason) {\n  return {\n    exception: {\n      values: [\n        {\n          type: 'UnhandledRejection',\n          // String() is needed because the Primitive type includes symbols (which can't be automatically stringified)\n          value: `Non-Error promise rejection captured with value: ${String(reason)}`,\n        },\n      ],\n    },\n  };\n}\n\n/**\n * This function creates a stack from an old, error-less onerror handler.\n */\nfunction _eventFromIncompleteOnError(msg, url, line, column) {\n  var ERROR_TYPES_RE =\n    /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/i;\n\n  // If 'message' is ErrorEvent, get real message from inside\n  let message = isErrorEvent(msg) ? msg.message : msg;\n  let name = 'Error';\n\n  var groups = message.match(ERROR_TYPES_RE);\n  if (groups) {\n    name = groups[1];\n    message = groups[2];\n  }\n\n  var event = {\n    exception: {\n      values: [\n        {\n          type: name,\n          value: message,\n        },\n      ],\n    },\n  };\n\n  return _enhanceEventWithInitialFrame(event, url, line, column);\n}\n\n/** JSDoc */\nfunction _enhanceEventWithInitialFrame(event, url, line, column) {\n  // event.exception\n  var e = (event.exception = event.exception || {});\n  // event.exception.values\n  var ev = (e.values = e.values || []);\n  // event.exception.values[0]\n  var ev0 = (ev[0] = ev[0] || {});\n  // event.exception.values[0].stacktrace\n  var ev0s = (ev0.stacktrace = ev0.stacktrace || {});\n  // event.exception.values[0].stacktrace.frames\n  var ev0sf = (ev0s.frames = ev0s.frames || []);\n\n  var colno = isNaN(parseInt(column, 10)) ? undefined : column;\n  var lineno = isNaN(parseInt(line, 10)) ? undefined : line;\n  var filename = isString(url) && url.length > 0 ? url : getLocationHref();\n\n  // event.exception.values[0].stacktrace.frames\n  if (ev0sf.length === 0) {\n    ev0sf.push({\n      colno,\n      filename,\n      function: '?',\n      in_app: true,\n      lineno,\n    });\n  }\n\n  return event;\n}\n\nfunction globalHandlerLog(type) {\n  (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`Global Handler attached: ${type}`);\n}\n\nfunction addMechanismAndCapture(hub, error, event, type) {\n  addExceptionMechanism(event, {\n    handled: false,\n    type,\n  });\n  hub.captureEvent(event, {\n    originalException: error,\n  });\n}\n\nfunction getHubAndOptions() {\n  var hub = getCurrentHub();\n  var client = hub.getClient();\n  var options = (client && client.getOptions()) || {\n    stackParser: () => [],\n    attachStacktrace: false,\n  };\n  return [hub, options.stackParser, options.attachStacktrace];\n}\n\nexport { GlobalHandlers };\n//# sourceMappingURL=globalhandlers.js.map\n","import { getCurrentHub, addGlobalEventProcessor } from '@sentry/core';\nimport { isInstanceOf } from '@sentry/utils';\nimport { exceptionFromError } from '../eventbuilder.js';\n\nvar DEFAULT_KEY = 'cause';\nvar DEFAULT_LIMIT = 5;\n\n/** Adds SDK info to an event. */\nclass LinkedErrors  {\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = 'LinkedErrors';}\n\n  /**\n   * @inheritDoc\n   */\n    __init() {this.name = LinkedErrors.id;}\n\n  /**\n   * @inheritDoc\n   */\n  \n\n  /**\n   * @inheritDoc\n   */\n  \n\n  /**\n   * @inheritDoc\n   */\n   constructor(options = {}) {;LinkedErrors.prototype.__init.call(this);\n    this._key = options.key || DEFAULT_KEY;\n    this._limit = options.limit || DEFAULT_LIMIT;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setupOnce() {\n    var client = getCurrentHub().getClient();\n    if (!client) {\n      return;\n    }\n    addGlobalEventProcessor((event, hint) => {\n      var self = getCurrentHub().getIntegration(LinkedErrors);\n      return self ? _handler(client.getOptions().stackParser, self._key, self._limit, event, hint) : event;\n    });\n  }\n} LinkedErrors.__initStatic();\n\n/**\n * @inheritDoc\n */\nfunction _handler(\n  parser,\n  key,\n  limit,\n  event,\n  hint,\n) {\n  if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {\n    return event;\n  }\n  var linkedErrors = _walkErrorTree(parser, limit, hint.originalException , key);\n  event.exception.values = [...linkedErrors, ...event.exception.values];\n  return event;\n}\n\n/**\n * JSDOC\n */\nfunction _walkErrorTree(\n  parser,\n  limit,\n  error,\n  key,\n  stack = [],\n) {\n  if (!isInstanceOf(error[key], Error) || stack.length + 1 >= limit) {\n    return stack;\n  }\n  var exception = exceptionFromError(parser, error[key]);\n  return _walkErrorTree(parser, limit, error[key], key, [exception, ...stack]);\n}\n\nexport { LinkedErrors, _handler, _walkErrorTree };\n//# sourceMappingURL=linkederrors.js.map\n","import { logger } from '@sentry/utils';\n\n/** Deduplication filter */\nclass Dedupe  {constructor() { Dedupe.prototype.__init.call(this); }\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = 'Dedupe';}\n\n  /**\n   * @inheritDoc\n   */\n   __init() {this.name = Dedupe.id;}\n\n  /**\n   * @inheritDoc\n   */\n  \n\n  /**\n   * @inheritDoc\n   */\n   setupOnce(addGlobalEventProcessor, getCurrentHub) {\n    var eventProcessor = currentEvent => {\n      var self = getCurrentHub().getIntegration(Dedupe);\n      if (self) {\n        // Juuust in case something goes wrong\n        try {\n          if (_shouldDropEvent(currentEvent, self._previousEvent)) {\n            (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Event dropped due to being a duplicate of previously captured event.');\n            return null;\n          }\n        } catch (_oO) {\n          return (self._previousEvent = currentEvent);\n        }\n\n        return (self._previousEvent = currentEvent);\n      }\n      return currentEvent;\n    };\n\n    eventProcessor.id = this.name;\n    addGlobalEventProcessor(eventProcessor);\n  }\n} Dedupe.__initStatic();\n\n/** JSDoc */\nfunction _shouldDropEvent(currentEvent, previousEvent) {\n  if (!previousEvent) {\n    return false;\n  }\n\n  if (_isSameMessageEvent(currentEvent, previousEvent)) {\n    return true;\n  }\n\n  if (_isSameExceptionEvent(currentEvent, previousEvent)) {\n    return true;\n  }\n\n  return false;\n}\n\n/** JSDoc */\nfunction _isSameMessageEvent(currentEvent, previousEvent) {\n  var currentMessage = currentEvent.message;\n  var previousMessage = previousEvent.message;\n\n  // If neither event has a message property, they were both exceptions, so bail out\n  if (!currentMessage && !previousMessage) {\n    return false;\n  }\n\n  // If only one event has a stacktrace, but not the other one, they are not the same\n  if ((currentMessage && !previousMessage) || (!currentMessage && previousMessage)) {\n    return false;\n  }\n\n  if (currentMessage !== previousMessage) {\n    return false;\n  }\n\n  if (!_isSameFingerprint(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  if (!_isSameStacktrace(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  return true;\n}\n\n/** JSDoc */\nfunction _isSameExceptionEvent(currentEvent, previousEvent) {\n  var previousException = _getExceptionFromEvent(previousEvent);\n  var currentException = _getExceptionFromEvent(currentEvent);\n\n  if (!previousException || !currentException) {\n    return false;\n  }\n\n  if (previousException.type !== currentException.type || previousException.value !== currentException.value) {\n    return false;\n  }\n\n  if (!_isSameFingerprint(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  if (!_isSameStacktrace(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  return true;\n}\n\n/** JSDoc */\nfunction _isSameStacktrace(currentEvent, previousEvent) {\n  let currentFrames = _getFramesFromEvent(currentEvent);\n  let previousFrames = _getFramesFromEvent(previousEvent);\n\n  // If neither event has a stacktrace, they are assumed to be the same\n  if (!currentFrames && !previousFrames) {\n    return true;\n  }\n\n  // If only one event has a stacktrace, but not the other one, they are not the same\n  if ((currentFrames && !previousFrames) || (!currentFrames && previousFrames)) {\n    return false;\n  }\n\n  currentFrames = currentFrames ;\n  previousFrames = previousFrames ;\n\n  // If number of frames differ, they are not the same\n  if (previousFrames.length !== currentFrames.length) {\n    return false;\n  }\n\n  // Otherwise, compare the two\n  for (let i = 0; i < previousFrames.length; i++) {\n    var frameA = previousFrames[i];\n    var frameB = currentFrames[i];\n\n    if (\n      frameA.filename !== frameB.filename ||\n      frameA.lineno !== frameB.lineno ||\n      frameA.colno !== frameB.colno ||\n      frameA.function !== frameB.function\n    ) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/** JSDoc */\nfunction _isSameFingerprint(currentEvent, previousEvent) {\n  let currentFingerprint = currentEvent.fingerprint;\n  let previousFingerprint = previousEvent.fingerprint;\n\n  // If neither event has a fingerprint, they are assumed to be the same\n  if (!currentFingerprint && !previousFingerprint) {\n    return true;\n  }\n\n  // If only one event has a fingerprint, but not the other one, they are not the same\n  if ((currentFingerprint && !previousFingerprint) || (!currentFingerprint && previousFingerprint)) {\n    return false;\n  }\n\n  currentFingerprint = currentFingerprint ;\n  previousFingerprint = previousFingerprint ;\n\n  // Otherwise, compare the two\n  try {\n    return !!(currentFingerprint.join('') === previousFingerprint.join(''));\n  } catch (_oO) {\n    return false;\n  }\n}\n\n/** JSDoc */\nfunction _getExceptionFromEvent(event) {\n  return event.exception && event.exception.values && event.exception.values[0];\n}\n\n/** JSDoc */\nfunction _getFramesFromEvent(event) {\n  var exception = event.exception;\n\n  if (exception) {\n    try {\n      // @ts-ignore Object could be undefined\n      return exception.values[0].stacktrace.frames;\n    } catch (_oO) {\n      return undefined;\n    }\n  }\n  return undefined;\n}\n\nexport { Dedupe };\n//# sourceMappingURL=dedupe.js.map\n","import { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { getGlobalObject } from '@sentry/utils';\n\nvar global = getGlobalObject();\n\n/** HttpContext integration collects information about HTTP request headers */\nclass HttpContext  {constructor() { HttpContext.prototype.__init.call(this); }\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = 'HttpContext';}\n\n  /**\n   * @inheritDoc\n   */\n   __init() {this.name = HttpContext.id;}\n\n  /**\n   * @inheritDoc\n   */\n   setupOnce() {\n    addGlobalEventProcessor((event) => {\n      if (getCurrentHub().getIntegration(HttpContext)) {\n        // if none of the information we want exists, don't bother\n        if (!global.navigator && !global.location && !global.document) {\n          return event;\n        }\n\n        // grab as much info as exists and add it to the event\n        var url = (event.request && event.request.url) || (global.location && global.location.href);\n        const { referrer } = global.document || {};\n        const { userAgent } = global.navigator || {};\n\n        var headers = {\n          ...(event.request && event.request.headers),\n          ...(referrer && { Referer: referrer }),\n          ...(userAgent && { 'User-Agent': userAgent }),\n        };\n        var request = { ...(url && { url }), headers };\n\n        return { ...event, request };\n      }\n      return event;\n    });\n  }\n} HttpContext.__initStatic();\n\nexport { HttpContext };\n//# sourceMappingURL=httpcontext.js.map\n","import { makePromiseBuffer, forEachEnvelopeItem, envelopeItemTypeToDataCategory, isRateLimited, resolvedSyncPromise, createEnvelope, serializeEnvelope, logger, updateRateLimits, SentryError } from '@sentry/utils';\n\nvar DEFAULT_TRANSPORT_BUFFER_SIZE = 30;\n\n/**\n * Creates an instance of a Sentry `Transport`\n *\n * @param options\n * @param makeRequest\n */\nfunction createTransport(\n  options,\n  makeRequest,\n  buffer = makePromiseBuffer(options.bufferSize || DEFAULT_TRANSPORT_BUFFER_SIZE),\n) {\n  let rateLimits = {};\n\n  var flush = (timeout) => buffer.drain(timeout);\n\n  function send(envelope) {\n    var filteredEnvelopeItems = [];\n\n    // Drop rate limited items from envelope\n    forEachEnvelopeItem(envelope, (item, type) => {\n      var envelopeItemDataCategory = envelopeItemTypeToDataCategory(type);\n      if (isRateLimited(rateLimits, envelopeItemDataCategory)) {\n        options.recordDroppedEvent('ratelimit_backoff', envelopeItemDataCategory);\n      } else {\n        filteredEnvelopeItems.push(item);\n      }\n    });\n\n    // Skip sending if envelope is empty after filtering out rate limited events\n    if (filteredEnvelopeItems.length === 0) {\n      return resolvedSyncPromise();\n    }\n\n        var filteredEnvelope = createEnvelope(envelope[0], filteredEnvelopeItems );\n\n    // Creates client report for each item in an envelope\n    var recordEnvelopeLoss = (reason) => {\n      forEachEnvelopeItem(filteredEnvelope, (_, type) => {\n        options.recordDroppedEvent(reason, envelopeItemTypeToDataCategory(type));\n      });\n    };\n\n    var requestTask = () =>\n      makeRequest({ body: serializeEnvelope(filteredEnvelope, options.textEncoder) }).then(\n        response => {\n          // We don't want to throw on NOK responses, but we want to at least log them\n          if (response.statusCode !== undefined && (response.statusCode < 200 || response.statusCode >= 300)) {\n            (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(`Sentry responded with status code ${response.statusCode} to sent event.`);\n          }\n\n          rateLimits = updateRateLimits(rateLimits, response);\n        },\n        error => {\n          (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Failed while sending event:', error);\n          recordEnvelopeLoss('network_error');\n        },\n      );\n\n    return buffer.add(requestTask).then(\n      result => result,\n      error => {\n        if (error instanceof SentryError) {\n          (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Skipped sending event due to full buffer');\n          recordEnvelopeLoss('queue_overflow');\n          return resolvedSyncPromise();\n        } else {\n          throw error;\n        }\n      },\n    );\n  }\n\n  return {\n    send,\n    flush,\n  };\n}\n\nexport { DEFAULT_TRANSPORT_BUFFER_SIZE, createTransport };\n//# sourceMappingURL=base.js.map\n","import { SentryError } from './error.js';\nimport { rejectedSyncPromise, SyncPromise, resolvedSyncPromise } from './syncpromise.js';\n\n/**\n * Creates an new PromiseBuffer object with the specified limit\n * @param limit max number of promises that can be stored in the buffer\n */\nfunction makePromiseBuffer(limit) {\n  var buffer = [];\n\n  function isReady() {\n    return limit === undefined || buffer.length < limit;\n  }\n\n  /**\n   * Remove a promise from the queue.\n   *\n   * @param task Can be any PromiseLike<T>\n   * @returns Removed promise.\n   */\n  function remove(task) {\n    return buffer.splice(buffer.indexOf(task), 1)[0];\n  }\n\n  /**\n   * Add a promise (representing an in-flight action) to the queue, and set it to remove itself on fulfillment.\n   *\n   * @param taskProducer A function producing any PromiseLike<T>; In previous versions this used to be `task:\n   *        PromiseLike<T>`, but under that model, Promises were instantly created on the call-site and their executor\n   *        functions therefore ran immediately. Thus, even if the buffer was full, the action still happened. By\n   *        requiring the promise to be wrapped in a function, we can defer promise creation until after the buffer\n   *        limit check.\n   * @returns The original promise.\n   */\n  function add(taskProducer) {\n    if (!isReady()) {\n      return rejectedSyncPromise(new SentryError('Not adding Promise due to buffer limit reached.'));\n    }\n\n    // start the task and add its promise to the queue\n    var task = taskProducer();\n    if (buffer.indexOf(task) === -1) {\n      buffer.push(task);\n    }\n    void task\n      .then(() => remove(task))\n      // Use `then(null, rejectionHandler)` rather than `catch(rejectionHandler)` so that we can use `PromiseLike`\n      // rather than `Promise`. `PromiseLike` doesn't have a `.catch` method, making its polyfill smaller. (ES5 didn't\n      // have promises, so TS has to polyfill when down-compiling.)\n      .then(null, () =>\n        remove(task).then(null, () => {\n          // We have to add another catch here because `remove()` starts a new promise chain.\n        }),\n      );\n    return task;\n  }\n\n  /**\n   * Wait for all promises in the queue to resolve or for timeout to expire, whichever comes first.\n   *\n   * @param timeout The time, in ms, after which to resolve to `false` if the queue is still non-empty. Passing `0` (or\n   * not passing anything) will make the promise wait as long as it takes for the queue to drain before resolving to\n   * `true`.\n   * @returns A promise which will resolve to `true` if the queue is already empty or drains before the timeout, and\n   * `false` otherwise\n   */\n  function drain(timeout) {\n    return new SyncPromise((resolve, reject) => {\n      let counter = buffer.length;\n\n      if (!counter) {\n        return resolve(true);\n      }\n\n      // wait for `timeout` ms and then resolve to `false` (if not cancelled first)\n      var capturedSetTimeout = setTimeout(() => {\n        if (timeout && timeout > 0) {\n          resolve(false);\n        }\n      }, timeout);\n\n      // if all promises resolve in time, cancel the timer and resolve to `true`\n      buffer.forEach(item => {\n        void resolvedSyncPromise(item).then(() => {\n                    if (!--counter) {\n            clearTimeout(capturedSetTimeout);\n            resolve(true);\n          }\n        }, reject);\n      });\n    });\n  }\n\n  return {\n    $: buffer,\n    add,\n    drain,\n  };\n}\n\nexport { makePromiseBuffer };\n//# sourceMappingURL=promisebuffer.js.map\n","// Intentionally keeping the key broad, as we don't know for sure what rate limit headers get returned from backend\n\nvar DEFAULT_RETRY_AFTER = 60 * 1000; // 60 seconds\n\n/**\n * Extracts Retry-After value from the request header or returns default value\n * @param header string representation of 'Retry-After' header\n * @param now current unix timestamp\n *\n */\nfunction parseRetryAfterHeader(header, now = Date.now()) {\n  var headerDelay = parseInt(`${header}`, 10);\n  if (!isNaN(headerDelay)) {\n    return headerDelay * 1000;\n  }\n\n  var headerDate = Date.parse(`${header}`);\n  if (!isNaN(headerDate)) {\n    return headerDate - now;\n  }\n\n  return DEFAULT_RETRY_AFTER;\n}\n\n/**\n * Gets the time that given category is disabled until for rate limiting\n */\nfunction disabledUntil(limits, category) {\n  return limits[category] || limits.all || 0;\n}\n\n/**\n * Checks if a category is rate limited\n */\nfunction isRateLimited(limits, category, now = Date.now()) {\n  return disabledUntil(limits, category) > now;\n}\n\n/**\n * Update ratelimits from incoming headers.\n * Returns true if headers contains a non-empty rate limiting header.\n */\nfunction updateRateLimits(\n  limits,\n  { statusCode, headers },\n  now = Date.now(),\n) {\n  var updatedRateLimits = {\n    ...limits,\n  };\n\n  // \"The name is case-insensitive.\"\n  // https://developer.mozilla.org/en-US/docs/Web/API/Headers/get\n  var rateLimitHeader = headers && headers['x-sentry-rate-limits'];\n  var retryAfterHeader = headers && headers['retry-after'];\n\n  if (rateLimitHeader) {\n    /**\n     * rate limit headers are of the form\n     *     <header>,<header>,..\n     * where each <header> is of the form\n     *     <retry_after>: <categories>: <scope>: <reason_code>\n     * where\n     *     <retry_after> is a delay in seconds\n     *     <categories> is the event type(s) (error, transaction, etc) being rate limited and is of the form\n     *         <category>;<category>;...\n     *     <scope> is what's being limited (org, project, or key) - ignored by SDK\n     *     <reason_code> is an arbitrary string like \"org_quota\" - ignored by SDK\n     */\n    for (var limit of rateLimitHeader.trim().split(',')) {\n      const [retryAfter, categories] = limit.split(':', 2);\n      var headerDelay = parseInt(retryAfter, 10);\n      var delay = (!isNaN(headerDelay) ? headerDelay : 60) * 1000; // 60sec default\n      if (!categories) {\n        updatedRateLimits.all = now + delay;\n      } else {\n        for (var category of categories.split(';')) {\n          updatedRateLimits[category] = now + delay;\n        }\n      }\n    }\n  } else if (retryAfterHeader) {\n    updatedRateLimits.all = now + parseRetryAfterHeader(retryAfterHeader, now);\n  } else if (statusCode === 429) {\n    updatedRateLimits.all = now + 60 * 1000;\n  }\n\n  return updatedRateLimits;\n}\n\nexport { DEFAULT_RETRY_AFTER, disabledUntil, isRateLimited, parseRetryAfterHeader, updateRateLimits };\n//# sourceMappingURL=ratelimit.js.map\n","import { createTransport } from '@sentry/core';\nimport { getNativeFetchImplementation } from './utils.js';\n\n/**\n * Creates a Transport that uses the Fetch API to send events to Sentry.\n */\nfunction makeFetchTransport(\n  options,\n  nativeFetch = getNativeFetchImplementation(),\n) {\n  function makeRequest(request) {\n    var requestOptions = {\n      body: request.body,\n      method: 'POST',\n      referrerPolicy: 'origin',\n      headers: options.headers,\n      ...options.fetchOptions,\n    };\n\n    return nativeFetch(options.url, requestOptions).then(response => ({\n      statusCode: response.status,\n      headers: {\n        'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),\n        'retry-after': response.headers.get('Retry-After'),\n      },\n    }));\n  }\n\n  return createTransport(options, makeRequest);\n}\n\nexport { makeFetchTransport };\n//# sourceMappingURL=fetch.js.map\n","import { createTransport } from '@sentry/core';\nimport { SyncPromise } from '@sentry/utils';\n\n/**\n * The DONE ready state for XmlHttpRequest\n *\n * Defining it here as a constant b/c XMLHttpRequest.DONE is not always defined\n * (e.g. during testing, it is `undefined`)\n *\n * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/readyState}\n */\nvar XHR_READYSTATE_DONE = 4;\n\n/**\n * Creates a Transport that uses the XMLHttpRequest API to send events to Sentry.\n */\nfunction makeXHRTransport(options) {\n  function makeRequest(request) {\n    return new SyncPromise((resolve, reject) => {\n      var xhr = new XMLHttpRequest();\n\n      xhr.onerror = reject;\n\n      xhr.onreadystatechange = () => {\n        if (xhr.readyState === XHR_READYSTATE_DONE) {\n          resolve({\n            statusCode: xhr.status,\n            headers: {\n              'x-sentry-rate-limits': xhr.getResponseHeader('X-Sentry-Rate-Limits'),\n              'retry-after': xhr.getResponseHeader('Retry-After'),\n            },\n          });\n        }\n      };\n\n      xhr.open('POST', options.url);\n\n      for (var header in options.headers) {\n        if (Object.prototype.hasOwnProperty.call(options.headers, header)) {\n          xhr.setRequestHeader(header, options.headers[header]);\n        }\n      }\n\n      xhr.send(request.body);\n    });\n  }\n\n  return createTransport(options, makeRequest);\n}\n\nexport { makeXHRTransport };\n//# sourceMappingURL=xhr.js.map\n","import { Integrations, getIntegrationsToSetup, initAndBind, getCurrentHub, getReportDialogEndpoint } from '@sentry/core';\nimport { getGlobalObject, stackParserFromStackParserOptions, supportsFetch, logger, resolvedSyncPromise, addInstrumentationHandler } from '@sentry/utils';\nimport { BrowserClient } from './client.js';\nimport { wrap as wrap$1 } from './helpers.js';\nimport './integrations/index.js';\nimport { defaultStackParser } from './stack-parsers.js';\nimport './transports/index.js';\nimport { TryCatch } from './integrations/trycatch.js';\nimport { Breadcrumbs } from './integrations/breadcrumbs.js';\nimport { GlobalHandlers } from './integrations/globalhandlers.js';\nimport { LinkedErrors } from './integrations/linkederrors.js';\nimport { Dedupe } from './integrations/dedupe.js';\nimport { HttpContext } from './integrations/httpcontext.js';\nimport { makeFetchTransport } from './transports/fetch.js';\nimport { makeXHRTransport } from './transports/xhr.js';\n\nvar defaultIntegrations = [\n  new Integrations.InboundFilters(),\n  new Integrations.FunctionToString(),\n  new TryCatch(),\n  new Breadcrumbs(),\n  new GlobalHandlers(),\n  new LinkedErrors(),\n  new Dedupe(),\n  new HttpContext(),\n];\n\n/**\n * The Sentry Browser SDK Client.\n *\n * To use this SDK, call the {@link init} function as early as possible when\n * loading the web page. To set context information or send manual events, use\n * the provided methods.\n *\n * @example\n *\n * ```\n *\n * import { init } from '@sentry/browser';\n *\n * init({\n *   dsn: '__DSN__',\n *   // ...\n * });\n * ```\n *\n * @example\n * ```\n *\n * import { configureScope } from '@sentry/browser';\n * configureScope((scope: Scope) => {\n *   scope.setExtra({ battery: 0.7 });\n *   scope.setTag({ user_mode: 'admin' });\n *   scope.setUser({ id: '4711' });\n * });\n * ```\n *\n * @example\n * ```\n *\n * import { addBreadcrumb } from '@sentry/browser';\n * addBreadcrumb({\n *   message: 'My Breadcrumb',\n *   // ...\n * });\n * ```\n *\n * @example\n *\n * ```\n *\n * import * as Sentry from '@sentry/browser';\n * Sentry.captureMessage('Hello, world!');\n * Sentry.captureException(new Error('Good bye'));\n * Sentry.captureEvent({\n *   message: 'Manual',\n *   stacktrace: [\n *     // ...\n *   ],\n * });\n * ```\n *\n * @see {@link BrowserOptions} for documentation on configuration options.\n */\nfunction init(options = {}) {\n  if (options.defaultIntegrations === undefined) {\n    options.defaultIntegrations = defaultIntegrations;\n  }\n  if (options.release === undefined) {\n    var window = getGlobalObject();\n    // This supports the variable that sentry-webpack-plugin injects\n    if (window.SENTRY_RELEASE && window.SENTRY_RELEASE.id) {\n      options.release = window.SENTRY_RELEASE.id;\n    }\n  }\n  if (options.autoSessionTracking === undefined) {\n    options.autoSessionTracking = true;\n  }\n  if (options.sendClientReports === undefined) {\n    options.sendClientReports = true;\n  }\n\n  var clientOptions = {\n    ...options,\n    stackParser: stackParserFromStackParserOptions(options.stackParser || defaultStackParser),\n    integrations: getIntegrationsToSetup(options),\n    transport: options.transport || (supportsFetch() ? makeFetchTransport : makeXHRTransport),\n  };\n\n  initAndBind(BrowserClient, clientOptions);\n\n  if (options.autoSessionTracking) {\n    startSessionTracking();\n  }\n}\n\n/**\n * Present the user with a report dialog.\n *\n * @param options Everything is optional, we try to fetch all info need from the global scope.\n */\nfunction showReportDialog(options = {}, hub = getCurrentHub()) {\n  // doesn't work without a document (React Native)\n  var global = getGlobalObject();\n  if (!global.document) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Global document not defined in showReportDialog call');\n    return;\n  }\n\n  const { client, scope } = hub.getStackTop();\n  var dsn = options.dsn || (client && client.getDsn());\n  if (!dsn) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('DSN not configured for showReportDialog call');\n    return;\n  }\n\n  if (scope) {\n    options.user = {\n      ...scope.getUser(),\n      ...options.user,\n    };\n  }\n\n  if (!options.eventId) {\n    options.eventId = hub.lastEventId();\n  }\n\n  var script = global.document.createElement('script');\n  script.async = true;\n  script.src = getReportDialogEndpoint(dsn, options);\n\n  if (options.onLoad) {\n        script.onload = options.onLoad;\n  }\n\n  var injectionPoint = global.document.head || global.document.body;\n  if (injectionPoint) {\n    injectionPoint.appendChild(script);\n  } else {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Not injecting report dialog. No injection point found in HTML');\n  }\n}\n\n/**\n * This is the getter for lastEventId.\n *\n * @returns The last event id of a captured event.\n */\nfunction lastEventId() {\n  return getCurrentHub().lastEventId();\n}\n\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nfunction forceLoad() {\n  // Noop\n}\n\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nfunction onLoad(callback) {\n  callback();\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 */\nfunction flush(timeout) {\n  var client = getCurrentHub().getClient();\n  if (client) {\n    return client.flush(timeout);\n  }\n  (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Cannot flush events. No client defined.');\n  return resolvedSyncPromise(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 */\nfunction close(timeout) {\n  var client = getCurrentHub().getClient();\n  if (client) {\n    return client.close(timeout);\n  }\n  (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Cannot flush events and disable SDK. No client defined.');\n  return resolvedSyncPromise(false);\n}\n\n/**\n * Wrap code within a try/catch block so the SDK is able to capture errors.\n *\n * @param fn A function to wrap.\n *\n * @returns The result of wrapped function call.\n */\nfunction wrap(fn) {\n  return wrap$1(fn)();\n}\n\nfunction startSessionOnHub(hub) {\n  hub.startSession({ ignoreDuration: true });\n  hub.captureSession();\n}\n\n/**\n * Enable automatic Session Tracking for the initial page load.\n */\nfunction startSessionTracking() {\n  var window = getGlobalObject();\n  var document = window.document;\n\n  if (typeof document === 'undefined') {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.warn('Session tracking in non-browser environment with @sentry/browser is not supported.');\n    return;\n  }\n\n  var hub = getCurrentHub();\n\n  // The only way for this to be false is for there to be a version mismatch between @sentry/browser (>= 6.0.0) and\n  // @sentry/hub (< 5.27.0). In the simple case, there won't ever be such a mismatch, because the two packages are\n  // pinned at the same version in package.json, but there are edge cases where it's possible. See\n  // https://github.com/getsentry/sentry-javascript/issues/3207 and\n  // https://github.com/getsentry/sentry-javascript/issues/3234 and\n  // https://github.com/getsentry/sentry-javascript/issues/3278.\n  if (!hub.captureSession) {\n    return;\n  }\n\n  // The session duration for browser sessions does not track a meaningful\n  // concept that can be used as a metric.\n  // Automatically captured sessions are akin to page views, and thus we\n  // discard their duration.\n  startSessionOnHub(hub);\n\n  // We want to create a session for every navigation as well\n  addInstrumentationHandler('history', ({ from, to }) => {\n    // Don't create an additional session for the initial route or if the location did not change\n    if (!(from === undefined || from === to)) {\n      startSessionOnHub(getCurrentHub());\n    }\n  });\n}\n\nexport { close, defaultIntegrations, flush, forceLoad, init, lastEventId, onLoad, showReportDialog, wrap };\n//# sourceMappingURL=sdk.js.map\n","import { getCurrentHub } from '@sentry/hub';\nimport { logger } from '@sentry/utils';\n\n/** A class object that can instantiate Client objects. */\n\n/**\n * Internal function to create a new SDK client instance. The client is\n * installed and then bound to the current scope.\n *\n * @param clientClass The client class to instantiate.\n * @param options Options to pass to the client.\n */\nfunction initAndBind(\n  clientClass,\n  options,\n) {\n  if (options.debug === true) {\n    if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {\n      logger.enable();\n    } else {\n      // use `console.warn` rather than `logger.warn` since by non-debug bundles have all `logger.x` statements stripped\n            console.warn('[Sentry] Cannot initialize SDK with `debug` option using a non-debug bundle.');\n    }\n  }\n  var hub = getCurrentHub();\n  var scope = hub.getScope();\n  if (scope) {\n    scope.update(options.initialScope);\n  }\n\n  var client = new clientClass(options);\n  hub.bindClient(client);\n}\n\nexport { initAndBind };\n//# sourceMappingURL=sdk.js.map\n","import { isNodeEnv } from './node.js';\n\n/** Internal */\n\nvar fallbackGlobalObject = {};\n\n/**\n * Safely get global scope object\n *\n * @returns Global scope object\n */\nfunction getGlobalObject() {\n  return (\n    isNodeEnv()\n      ? global\n      : typeof window !== 'undefined'       ? window       : typeof self !== 'undefined'\n      ? self\n      : fallbackGlobalObject\n  ) ;\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 `getGlobalObject`'s return value\n * @returns the singleton\n */\nfunction getGlobalSingleton(name, creator, obj) {\n  var global = (obj || getGlobalObject()) ;\n  var __SENTRY__ = (global.__SENTRY__ = global.__SENTRY__ || {});\n  var singleton = __SENTRY__[name] || (__SENTRY__[name] = creator());\n  return singleton;\n}\n\nexport { getGlobalObject, getGlobalSingleton };\n//# sourceMappingURL=global.js.map\n","import { isBrowserBundle } from './env.js';\n\n/**\n * NOTE: In order to avoid circular dependencies, if you add a function to this module and it needs to print something,\n * you must either a) use `console.log` rather than the logger, or b) put your function elsewhere.\n */\n\n/**\n * Checks whether we're in the Node.js or Browser environment\n *\n * @returns Answer to given question\n */\nfunction isNodeEnv() {\n  // explicitly check for browser bundles as those can be optimized statically\n  // by terser/rollup.\n  return (\n    !isBrowserBundle() &&\n    Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]'\n  );\n}\n\n/**\n * Requires a module which is protected against bundler minification.\n *\n * @param request The module path to resolve\n */\nfunction dynamicRequire(mod, request) {\n    return mod.require(request);\n}\n\n/**\n * Helper for dynamically loading module that should work with linked dependencies.\n * The problem is that we _should_ be using `require(require.resolve(moduleName, { paths: [cwd()] }))`\n * However it's _not possible_ to do that with Webpack, as it has to know all the dependencies during\n * build time. `require.resolve` is also not available in any other way, so we cannot create,\n * a fake helper like we do with `dynamicRequire`.\n *\n * We always prefer to use local package, thus the value is not returned early from each `try/catch` block.\n * That is to mimic the behavior of `require.resolve` exactly.\n *\n * @param moduleName module name to require\n * @returns possibly required module\n */\nfunction loadModule(moduleName) {\n  let mod;\n\n  try {\n    mod = dynamicRequire(module, moduleName);\n  } catch (e) {\n    // no-empty\n  }\n\n  try {\n    const { cwd } = dynamicRequire(module, 'process');\n    mod = dynamicRequire(module, `${cwd()}/node_modules/${moduleName}`) ;\n  } catch (e) {\n    // no-empty\n  }\n\n  return mod;\n}\n\nexport { dynamicRequire, isNodeEnv, loadModule };\n//# sourceMappingURL=node.js.map\n","/*\n * This module exists for optimizations in the build process through rollup and terser.  We define some global\n * constants, which can be overridden during build. By guarding certain pieces of code with functions that return these\n * constants, we can control whether or not they appear in the final bundle. (Any code guarded by a false condition will\n * never run, and will hence be dropped during treeshaking.) The two primary uses for this are stripping out calls to\n * `logger` and preventing node-related code from appearing in browser bundles.\n *\n * Attention:\n * This file should not be used to define constants/flags that are intended to be used for tree-shaking conducted by\n * users. These fags should live in their respective packages, as we identified user tooling (specifically webpack)\n * having issues tree-shaking these constants across package boundaries.\n * An example for this is the __SENTRY_DEBUG__ constant. It is declared in each package individually because we want\n * users to be able to shake away expressions that it guards.\n */\n\n/**\n * Figures out if we're building a browser bundle.\n *\n * @returns true if this is a browser bundle build.\n */\nfunction isBrowserBundle() {\n  return typeof __SENTRY_BROWSER_BUNDLE__ !== 'undefined' && !!__SENTRY_BROWSER_BUNDLE__;\n}\n\nexport { isBrowserBundle };\n//# sourceMappingURL=env.js.map\n","import { getGlobalObject } from './global.js';\nimport { dynamicRequire, isNodeEnv } from './node.js';\n\n/**\n * An object that can return the current timestamp in seconds since the UNIX epoch.\n */\n\n/**\n * A TimestampSource implementation for environments that do not support the Performance Web API natively.\n *\n * Note that this TimestampSource does not use a monotonic clock. A call to `nowSeconds` may return a timestamp earlier\n * than a previously returned value. We do not try to emulate a monotonic behavior in order to facilitate debugging. It\n * is more obvious to explain \"why does my span have negative duration\" than \"why my spans have zero duration\".\n */\nvar dateTimestampSource = {\n  nowSeconds: () => Date.now() / 1000,\n};\n\n/**\n * A partial definition of the [Performance Web API]{@link https://developer.mozilla.org/en-US/docs/Web/API/Performance}\n * for accessing a high-resolution monotonic clock.\n */\n\n/**\n * Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not\n * support the API.\n *\n * Wrapping the native API works around differences in behavior from different browsers.\n */\nfunction getBrowserPerformance() {\n  const { performance } = getGlobalObject();\n  if (!performance || !performance.now) {\n    return undefined;\n  }\n\n  // Replace performance.timeOrigin with our own timeOrigin based on Date.now().\n  //\n  // This is a partial workaround for browsers reporting performance.timeOrigin such that performance.timeOrigin +\n  // performance.now() gives a date arbitrarily in the past.\n  //\n  // Additionally, computing timeOrigin in this way fills the gap for browsers where performance.timeOrigin is\n  // undefined.\n  //\n  // The assumption that performance.timeOrigin + performance.now() ~= Date.now() is flawed, but we depend on it to\n  // interact with data coming out of performance entries.\n  //\n  // Note that despite recommendations against it in the spec, browsers implement the Performance API with a clock that\n  // might stop when the computer is asleep (and perhaps under other circumstances). Such behavior causes\n  // performance.timeOrigin + performance.now() to have an arbitrary skew over Date.now(). In laptop computers, we have\n  // observed skews that can be as long as days, weeks or months.\n  //\n  // See https://github.com/getsentry/sentry-javascript/issues/2590.\n  //\n  // BUG: despite our best intentions, this workaround has its limitations. It mostly addresses timings of pageload\n  // transactions, but ignores the skew built up over time that can aversely affect timestamps of navigation\n  // transactions of long-lived web pages.\n  var timeOrigin = Date.now() - performance.now();\n\n  return {\n    now: () => performance.now(),\n    timeOrigin,\n  };\n}\n\n/**\n * Returns the native Performance API implementation from Node.js. Returns undefined in old Node.js versions that don't\n * implement the API.\n */\nfunction getNodePerformance() {\n  try {\n    var perfHooks = dynamicRequire(module, 'perf_hooks') ;\n    return perfHooks.performance;\n  } catch (_) {\n    return undefined;\n  }\n}\n\n/**\n * The Performance API implementation for the current platform, if available.\n */\nvar platformPerformance = isNodeEnv() ? getNodePerformance() : getBrowserPerformance();\n\nvar timestampSource =\n  platformPerformance === undefined\n    ? dateTimestampSource\n    : {\n        nowSeconds: () => (platformPerformance.timeOrigin + platformPerformance.now()) / 1000,\n      };\n\n/**\n * Returns a timestamp in seconds since the UNIX epoch using the Date API.\n */\nvar dateTimestampInSeconds = dateTimestampSource.nowSeconds.bind(dateTimestampSource);\n\n/**\n * Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the\n * availability of the Performance API.\n *\n * See `usingPerformanceAPI` to test whether the Performance API is used.\n *\n * BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is\n * asleep. This creates a skew between `dateTimestampInSeconds` and `timestampInSeconds`. The\n * skew can grow to arbitrary amounts like days, weeks or months.\n * See https://github.com/getsentry/sentry-javascript/issues/2590.\n */\nvar timestampInSeconds = timestampSource.nowSeconds.bind(timestampSource);\n\n// Re-exported with an old name for backwards-compatibility.\nvar timestampWithMs = timestampInSeconds;\n\n/**\n * A boolean that is true when timestampInSeconds uses the Performance API to produce monotonic timestamps.\n */\nvar usingPerformanceAPI = platformPerformance !== undefined;\n\n/**\n * Internal helper to store what is the source of browserPerformanceTimeOrigin below. For debugging only.\n */\nlet _browserPerformanceTimeOriginMode;\n\n/**\n * The number of milliseconds since the UNIX epoch. This value is only usable in a browser, and only when the\n * performance API is available.\n */\nvar browserPerformanceTimeOrigin = (() => {\n  // Unfortunately browsers may report an inaccurate time origin data, through either performance.timeOrigin or\n  // performance.timing.navigationStart, which results in poor results in performance data. We only treat time origin\n  // data as reliable if they are within a reasonable threshold of the current time.\n\n  const { performance } = getGlobalObject();\n  if (!performance || !performance.now) {\n    _browserPerformanceTimeOriginMode = 'none';\n    return undefined;\n  }\n\n  var threshold = 3600 * 1000;\n  var performanceNow = performance.now();\n  var dateNow = Date.now();\n\n  // if timeOrigin isn't available set delta to threshold so it isn't used\n  var timeOriginDelta = performance.timeOrigin\n    ? Math.abs(performance.timeOrigin + performanceNow - dateNow)\n    : threshold;\n  var 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    var navigationStart = performance.timing && performance.timing.navigationStart;\n  var hasNavigationStart = typeof navigationStart === 'number';\n  // if navigationStart isn't available set delta to threshold so it isn't used\n  var navigationStartDelta = hasNavigationStart ? Math.abs(navigationStart + performanceNow - dateNow) : threshold;\n  var navigationStartIsReliable = navigationStartDelta < threshold;\n\n  if (timeOriginIsReliable || navigationStartIsReliable) {\n    // Use the more reliable time origin\n    if (timeOriginDelta <= navigationStartDelta) {\n      _browserPerformanceTimeOriginMode = 'timeOrigin';\n      return performance.timeOrigin;\n    } else {\n      _browserPerformanceTimeOriginMode = 'navigationStart';\n      return navigationStart;\n    }\n  }\n\n  // Either both timeOrigin and navigationStart are skewed or neither is available, fallback to Date.\n  _browserPerformanceTimeOriginMode = 'dateNow';\n  return dateNow;\n})();\n\nexport { _browserPerformanceTimeOriginMode, browserPerformanceTimeOrigin, dateTimestampInSeconds, timestampInSeconds, timestampWithMs, usingPerformanceAPI };\n//# sourceMappingURL=time.js.map\n","function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }\n\nfunction _nonIterableSpread() { throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(n); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _iterableToArray(iter) { if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter); }\n\nfunction _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nimport { CALL_HISTORY_METHOD } from './actions';\n/**\n * This middleware captures CALL_HISTORY_METHOD actions to redirect to the\n * provided history object. This will prevent these actions from reaching your\n * reducer or any middleware that comes after this one.\n */\n\nvar routerMiddleware = function routerMiddleware(history) {\n  return function (store) {\n    return function (next) {\n      return function (action) {\n        // eslint-disable-line no-unused-vars\n        if (action.type !== CALL_HISTORY_METHOD) {\n          return next(action);\n        }\n\n        var _action$payload = action.payload,\n            method = _action$payload.method,\n            args = _action$payload.args;\n        history[method].apply(history, _toConsumableArray(args));\n      };\n    };\n  };\n};\n\nexport default routerMiddleware;","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n// adapted from https://github.com/WICG/EventListenerOptions/blob/gh-pages/explainer.md\nvar detectPassiveEvents = {\n  update: function update() {\n    if (typeof window !== 'undefined' && typeof window.addEventListener === 'function') {\n      var passive = false;\n      var options = Object.defineProperty({}, 'passive', {\n        get: function get() {\n          passive = true;\n        }\n      });\n      // note: have to set and remove a no-op listener instead of null\n      // (which was used previously), becasue Edge v15 throws an error\n      // when providing a null callback.\n      // https://github.com/rafrex/detect-passive-events/pull/3\n      var noop = function noop() {};\n      window.addEventListener('testPassiveEventSupport', noop, options);\n      window.removeEventListener('testPassiveEventSupport', noop, options);\n      detectPassiveEvents.hasSupport = passive;\n    }\n  }\n};\n\ndetectPassiveEvents.update();\nexports.default = detectPassiveEvents;","if (process.env.NODE_ENV === 'production') {\n  module.exports = require('./lib/react-input-mask.production.min.js');\n} else {\n  module.exports = require('./lib/react-input-mask.development.js');\n}\n","\"use strict\";function _interopDefault(e){return e&&\"object\"==typeof e&&\"default\"in e?e[\"default\"]:e}var React=_interopDefault(require(\"react\")),reactDom=require(\"react-dom\");function _defaults2(e,t){for(var n=Object.getOwnPropertyNames(t),a=0;a<n.length;a++){var r=n[a],i=Object.getOwnPropertyDescriptor(t,r);i&&i.configurable&&e[r]===undefined&&Object.defineProperty(e,r,i)}return e}function _extends(){return(_extends=Object.assign||function(e){for(var t=1;t<arguments.length;t++){var n=arguments[t];for(var a in n)Object.prototype.hasOwnProperty.call(n,a)&&(e[a]=n[a])}return e}).apply(this,arguments)}function _inheritsLoose(e,t){_defaults2(e.prototype,t&&t.prototype),_defaults2(e,t)}function _objectWithoutProperties(e,t){if(null==e)return{};var n,a,r={},i=Object.keys(e);for(a=0;a<i.length;a++)n=i[a],0<=t.indexOf(n)||(r[n]=e[n]);if(Object.getOwnPropertySymbols){var o=Object.getOwnPropertySymbols(e);for(a=0;a<o.length;a++)n=o[a],0<=t.indexOf(n)||Object.prototype.propertyIsEnumerable.call(e,n)&&(r[n]=e[n])}return r}function _assertThisInitialized(e){if(void 0===e)throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");return e}var invariant=function(e,t,n,a,r,i,o,s){if(!e){var l;if(t===undefined)l=new Error(\"Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings.\");else{var u=[n,a,r,i,o,s],c=0;(l=new Error(t.replace(/%s/g,function(){return u[c++]}))).name=\"Invariant Violation\"}throw l.framesToPop=1,l}},invariant_1=invariant;function setInputSelection(e,t,n){if(\"selectionStart\"in e&&\"selectionEnd\"in e)e.selectionStart=t,e.selectionEnd=n;else{var a=e.createTextRange();a.collapse(!0),a.moveStart(\"character\",t),a.moveEnd(\"character\",n-t),a.select()}}function getInputSelection(e){var t=0,n=0;if(\"selectionStart\"in e&&\"selectionEnd\"in e)t=e.selectionStart,n=e.selectionEnd;else{var a=document.selection.createRange();a.parentElement()===e&&(t=-a.moveStart(\"character\",-e.value.length),n=-a.moveEnd(\"character\",-e.value.length))}return{start:t,end:n,length:n-t}}var defaultFormatChars={9:\"[0-9]\",a:\"[A-Za-z]\",\"*\":\"[A-Za-z0-9]\"},defaultMaskChar=\"_\";function parseMask(e,t,n){var a=\"\",r=\"\",i=null,o=[];if(t===undefined&&(t=defaultMaskChar),null==n&&(n=defaultFormatChars),!e||\"string\"!=typeof e)return{maskChar:t,formatChars:n,mask:null,prefix:null,lastEditablePosition:null,permanents:[]};var s=!1;return e.split(\"\").forEach(function(e){s||\"\\\\\"!==e?(s||!n[e]?(o.push(a.length),a.length===o.length-1&&(r+=e)):i=a.length+1,a+=e,s=!1):s=!0}),{maskChar:t,formatChars:n,prefix:r,mask:a,lastEditablePosition:i,permanents:o}}function isPermanentCharacter(e,t){return-1!==e.permanents.indexOf(t)}function isAllowedCharacter(e,t,n){var a=e.mask,r=e.formatChars;if(!n)return!1;if(isPermanentCharacter(e,t))return a[t]===n;var i=r[a[t]];return new RegExp(i).test(n)}function isEmpty(n,e){return e.split(\"\").every(function(e,t){return isPermanentCharacter(n,t)||!isAllowedCharacter(n,t,e)})}function getFilledLength(e,t){var n=e.maskChar,a=e.prefix;if(!n){for(;t.length>a.length&&isPermanentCharacter(e,t.length-1);)t=t.slice(0,t.length-1);return t.length}for(var r=a.length,i=t.length;i>=a.length;i--){var o=t[i];if(!isPermanentCharacter(e,i)&&isAllowedCharacter(e,i,o)){r=i+1;break}}return r}function isFilled(e,t){return getFilledLength(e,t)===e.mask.length}function formatValue(e,t){var n=e.maskChar,a=e.mask,r=e.prefix;if(!n){for((t=insertString(e,\"\",t,0)).length<r.length&&(t=r);t.length<a.length&&isPermanentCharacter(e,t.length);)t+=a[t.length];return t}if(t)return insertString(e,formatValue(e,\"\"),t,0);for(var i=0;i<a.length;i++)isPermanentCharacter(e,i)?t+=a[i]:t+=n;return t}function clearRange(n,e,a,t){var r=a+t,i=n.maskChar,o=n.mask,s=n.prefix,l=e.split(\"\");if(!i){for(var u=r;u<l.length;u++)isPermanentCharacter(n,u)&&(l[u]=\"\");return a=Math.max(s.length,a),l.splice(a,r-a),e=l.join(\"\"),formatValue(n,e)}return l.map(function(e,t){return t<a||r<=t?e:isPermanentCharacter(n,t)?o[t]:i}).join(\"\")}function insertString(i,o,e,s){var l=i.mask,u=i.maskChar,c=i.prefix,t=e.split(\"\"),h=isFilled(i,o);return!u&&s>o.length&&(o+=l.slice(o.length,s)),t.every(function(e){for(;r=e,isPermanentCharacter(i,a=s)&&r!==l[a];){if(s>=o.length&&(o+=l[s]),t=e,n=s,u&&isPermanentCharacter(i,n)&&t===u)return!0;if(++s>=l.length)return!1}var t,n,a,r;return!isAllowedCharacter(i,s,e)&&e!==u||(s<o.length?u||h||s<c.length?o=o.slice(0,s)+e+o.slice(s+1):(o=o.slice(0,s)+e+o.slice(s),o=formatValue(i,o)):u||(o+=e),++s<l.length)}),o}function getInsertStringLength(a,e,t,r){var i=a.mask,o=a.maskChar,n=t.split(\"\"),s=r;return n.every(function(e){for(;n=e,isPermanentCharacter(a,t=r)&&n!==i[t];)if(++r>=i.length)return!1;var t,n;return(isAllowedCharacter(a,r,e)||e===o)&&r++,r<i.length}),r-s}function getLeftEditablePosition(e,t){for(var n=t;0<=n;--n)if(!isPermanentCharacter(e,n))return n;return null}function getRightEditablePosition(e,t){for(var n=e.mask,a=t;a<n.length;++a)if(!isPermanentCharacter(e,a))return a;return null}function getStringValue(e){return e||0===e?e+\"\":\"\"}function processChange(e,t,n,a,r){var i=e.mask,o=e.prefix,s=e.lastEditablePosition,l=t,u=\"\",c=0,h=0,f=Math.min(r.start,n.start);if(n.end>r.start?h=(c=getInsertStringLength(e,a,u=l.slice(r.start,n.end),f))?r.length:0:l.length<a.length&&(h=a.length-l.length),l=a,h){if(1===h&&!r.length)f=r.start===n.start?getRightEditablePosition(e,n.start):getLeftEditablePosition(e,n.start);l=clearRange(e,l,f,h)}return l=insertString(e,l,u,f),(f+=c)>=i.length?f=i.length:f<o.length&&!c?f=o.length:f>=o.length&&f<s&&c&&(f=getRightEditablePosition(e,f)),u||(u=null),{value:l=formatValue(e,l),enteredString:u,selection:{start:f,end:f}}}function isWindowsPhoneBrowser(){var e=new RegExp(\"windows\",\"i\"),t=new RegExp(\"phone\",\"i\"),n=navigator.userAgent;return e.test(n)&&t.test(n)}function isFunction(e){return\"function\"==typeof e}function getRequestAnimationFrame(){return window.requestAnimationFrame||window.webkitRequestAnimationFrame||window.mozRequestAnimationFrame}function getCancelAnimationFrame(){return window.cancelAnimationFrame||window.webkitCancelRequestAnimationFrame||window.webkitCancelAnimationFrame||window.mozCancelAnimationFrame}function defer(e){return(!!getCancelAnimationFrame()?getRequestAnimationFrame():function(){return setTimeout(e,1e3/60)})(e)}function cancelDefer(e){(getCancelAnimationFrame()||clearTimeout)(e)}var InputElement=function(c){function e(e){var f=c.call(this,e)||this;f.focused=!1,f.mounted=!1,f.previousSelection=null,f.selectionDeferId=null,f.saveSelectionLoopDeferId=null,f.saveSelectionLoop=function(){f.previousSelection=f.getSelection(),f.saveSelectionLoopDeferId=defer(f.saveSelectionLoop)},f.runSaveSelectionLoop=function(){null===f.saveSelectionLoopDeferId&&f.saveSelectionLoop()},f.stopSaveSelectionLoop=function(){null!==f.saveSelectionLoopDeferId&&(cancelDefer(f.saveSelectionLoopDeferId),f.saveSelectionLoopDeferId=null,f.previousSelection=null)},f.getInputDOMNode=function(){if(!f.mounted)return null;if(f.input)return f.input;var e=reactDom.findDOMNode(_assertThisInitialized(_assertThisInitialized(f)));if(\"INPUT\"!==e.nodeName&&(e=e.querySelector(\"input\")),!e)throw new Error(\"react-input-mask: inputComponent doesn't contain input node\");return e},f.getInputValue=function(){var e=f.getInputDOMNode();return e?e.value:null},f.setInputValue=function(e){var t=f.getInputDOMNode();t&&(f.value=e,t.value=e)},f.setCursorToEnd=function(){var e=getFilledLength(f.maskOptions,f.value),t=getRightEditablePosition(f.maskOptions,e);null!==t&&f.setCursorPosition(t)},f.setSelection=function(e,t,n){void 0===n&&(n={});var a=f.getInputDOMNode();a&&(n.deferred||setInputSelection(a,e,t),null!==f.selectionDeferId&&cancelDefer(f.selectionDeferId),f.selectionDeferId=defer(function(){f.selectionDeferId=null,setInputSelection(a,e,t)}),f.previousSelection={start:e,end:t,length:Math.abs(t-e)})},f.getSelection=function(){return getInputSelection(f.getInputDOMNode())},f.getCursorPosition=function(){return f.getSelection().start},f.setCursorPosition=function(e){f.setSelection(e,e)},f.isFocused=function(){return f.focused},f.getBeforeMaskedValueChangeConfig=function(){var e=f.maskOptions,t=e.mask,n=e.maskChar,a=e.permanents,r=e.formatChars;return{mask:t,maskChar:n,permanents:a,alwaysShowMask:!!f.props.alwaysShowMask,formatChars:r}},f.isInputAutofilled=function(e,t,n,a){var r=f.getInputDOMNode();try{if(r.matches(\":-webkit-autofill\"))return!0}catch(i){}return!f.focused||a.end<n.length&&t.end===e.length},f.onChange=function(e){var t=_assertThisInitialized(_assertThisInitialized(f)).beforePasteState,n=_assertThisInitialized(_assertThisInitialized(f)).previousSelection,a=f.props.beforeMaskedValueChange,r=f.getInputValue(),i=f.value,o=f.getSelection();f.isInputAutofilled(r,o,i,n)&&(i=formatValue(f.maskOptions,\"\"),n={start:0,end:0,length:0}),t&&(n=t.selection,i=t.value,o={start:n.start+r.length,end:n.start+r.length,length:0},r=i.slice(0,n.start)+r+i.slice(n.end),f.beforePasteState=null);var s=processChange(f.maskOptions,r,o,i,n),l=s.enteredString,u=s.selection,c=s.value;if(isFunction(a)){var h=a({value:c,selection:u},{value:i,selection:n},l,f.getBeforeMaskedValueChangeConfig());c=h.value,u=h.selection}f.setInputValue(c),isFunction(f.props.onChange)&&f.props.onChange(e),f.isWindowsPhoneBrowser?f.setSelection(u.start,u.end,{deferred:!0}):f.setSelection(u.start,u.end)},f.onFocus=function(e){var t=f.props.beforeMaskedValueChange,n=f.maskOptions,a=n.mask,r=n.prefix;if(f.focused=!0,f.input=e.target,f.mounted=!0,a){if(f.value)getFilledLength(f.maskOptions,f.value)<f.maskOptions.mask.length&&f.setCursorToEnd();else{var i=formatValue(f.maskOptions,r),o=formatValue(f.maskOptions,i),s=getFilledLength(f.maskOptions,o),l=getRightEditablePosition(f.maskOptions,s),u={start:l,end:l};if(isFunction(t)){var c=t({value:o,selection:u},{value:f.value,selection:null},null,f.getBeforeMaskedValueChangeConfig());o=c.value,u=c.selection}var h=o!==e.target.value;h&&(e.target.value=o),f.value=o,h&&isFunction(f.props.onChange)&&f.props.onChange(e),f.setSelection(u.start,u.end)}f.runSaveSelectionLoop()}isFunction(f.props.onFocus)&&f.props.onFocus(e)},f.onBlur=function(e){var t=f.props.beforeMaskedValueChange,n=f.maskOptions.mask;if(f.stopSaveSelectionLoop(),f.focused=!1,n&&!f.props.alwaysShowMask&&isEmpty(f.maskOptions,f.value)){var a=\"\";if(isFunction(t))a=t({value:a,selection:null},{value:f.value,selection:f.previousSelection},null,f.getBeforeMaskedValueChangeConfig()).value;var r=a!==f.getInputValue();r&&f.setInputValue(a),r&&isFunction(f.props.onChange)&&f.props.onChange(e)}isFunction(f.props.onBlur)&&f.props.onBlur(e)},f.onMouseDown=function(t){if(!f.focused&&document.addEventListener){f.mouseDownX=t.clientX,f.mouseDownY=t.clientY,f.mouseDownTime=(new Date).getTime();document.addEventListener(\"mouseup\",function e(t){if(document.removeEventListener(\"mouseup\",e),f.focused){var n=Math.abs(t.clientX-f.mouseDownX),a=Math.abs(t.clientY-f.mouseDownY),r=Math.max(n,a),i=(new Date).getTime()-f.mouseDownTime;(r<=10&&i<=200||r<=5&&i<=300)&&f.setCursorToEnd()}})}isFunction(f.props.onMouseDown)&&f.props.onMouseDown(t)},f.onPaste=function(e){isFunction(f.props.onPaste)&&f.props.onPaste(e),e.defaultPrevented||(f.beforePasteState={value:f.getInputValue(),selection:f.getSelection()},f.setInputValue(\"\"))},f.handleRef=function(e){f.input=f.getInputDOMNode(),null==f.props.children&&isFunction(f.props.inputRef)&&f.props.inputRef(e)};var t=e.mask,n=e.maskChar,a=e.formatChars,r=e.alwaysShowMask,i=e.beforeMaskedValueChange,o=e.defaultValue,s=e.value;f.maskOptions=parseMask(t,n,a),null==o&&(o=\"\"),null==s&&(s=o);var l=getStringValue(s);if(f.maskOptions.mask&&(r||l)&&(l=formatValue(f.maskOptions,l),isFunction(i))){var u=e.value;null==e.value&&(u=o),l=i({value:l,selection:null},{value:u=getStringValue(u),selection:null},null,f.getBeforeMaskedValueChangeConfig()).value}return f.value=l,f}var t=e.prototype;return t.componentDidMount=function(){this.mounted=!0,this.isWindowsPhoneBrowser=isWindowsPhoneBrowser(),this.maskOptions.mask&&this.getInputValue()!==this.value&&this.setInputValue(this.value)},t.componentDidUpdate=function(){var e=this.previousSelection,t=this.props,n=t.beforeMaskedValueChange,a=t.alwaysShowMask,r=t.mask,i=t.maskChar,o=t.formatChars,s=this.maskOptions,l=a||this.isFocused(),u=null!=this.props.value,c=u?getStringValue(this.props.value):this.value,h=e?e.start:null;if(this.maskOptions=parseMask(r,i,o),this.maskOptions.mask){!s.mask&&this.isFocused()&&this.runSaveSelectionLoop();var f=this.maskOptions.mask&&this.maskOptions.mask!==s.mask;if(s.mask||u||(c=this.getInputValue()),(f||this.maskOptions.mask&&(c||l))&&(c=formatValue(this.maskOptions,c)),f){var p=getFilledLength(this.maskOptions,c);(null===h||p<h)&&(h=isFilled(this.maskOptions,c)?p:getRightEditablePosition(this.maskOptions,p))}!this.maskOptions.mask||!isEmpty(this.maskOptions,c)||l||u&&this.props.value||(c=\"\");var m={start:h,end:h};if(isFunction(n)){var d=n({value:c,selection:m},{value:this.value,selection:this.previousSelection},null,this.getBeforeMaskedValueChangeConfig());c=d.value,m=d.selection}this.value=c,this.getInputValue()!==this.value?(this.setInputValue(this.value),this.forceUpdate()):f&&this.forceUpdate();var g=!1;null!=m.start&&null!=m.end&&(g=!e||e.start!==m.start||e.end!==m.end),g&&this.setSelection(m.start,m.end)}else s.mask&&(this.stopSaveSelectionLoop(),this.forceUpdate())},t.componentWillUnmount=function(){this.mounted=!1,null!==this.selectionDeferId&&cancelDefer(this.selectionDeferId),this.stopSaveSelectionLoop()},t.render=function(){var t,e=this.props,n=(e.mask,e.alwaysShowMask,e.maskChar,e.formatChars,e.inputRef,e.beforeMaskedValueChange,e.children),a=_objectWithoutProperties(e,[\"mask\",\"alwaysShowMask\",\"maskChar\",\"formatChars\",\"inputRef\",\"beforeMaskedValueChange\",\"children\"]);if(n){isFunction(n)||invariant_1(!1);var r=[\"onChange\",\"onPaste\",\"onMouseDown\",\"onFocus\",\"onBlur\",\"value\",\"disabled\",\"readOnly\"],i=_extends({},a);r.forEach(function(e){return delete i[e]}),t=n(i),r.filter(function(e){return null!=t.props[e]&&t.props[e]!==a[e]}).length&&invariant_1(!1)}else t=React.createElement(\"input\",_extends({ref:this.handleRef},a));var o={onFocus:this.onFocus,onBlur:this.onBlur};return this.maskOptions.mask&&(a.disabled||a.readOnly||(o.onChange=this.onChange,o.onPaste=this.onPaste,o.onMouseDown=this.onMouseDown),null!=a.value&&(o.value=this.value)),t=React.cloneElement(t,o)},_inheritsLoose(e,c),e}(React.Component);module.exports=InputElement;\n","import { useContext } from 'react';\nimport { ReactReduxContext } from '../components/Context';\nimport { useReduxContext as useDefaultReduxContext } from './useReduxContext';\n/**\r\n * Hook factory, which creates a `useStore` hook bound to a given context.\r\n *\r\n * @param {Function} [context=ReactReduxContext] Context passed to your `<Provider>`.\r\n * @returns {Function} A `useStore` hook bound to the specified context.\r\n */\n\nexport function createStoreHook(context) {\n  if (context === void 0) {\n    context = ReactReduxContext;\n  }\n\n  var useReduxContext = context === ReactReduxContext ? useDefaultReduxContext : function () {\n    return useContext(context);\n  };\n  return function useStore() {\n    var _useReduxContext = useReduxContext(),\n        store = _useReduxContext.store;\n\n    return store;\n  };\n}\n/**\r\n * A hook to access the redux store.\r\n *\r\n * @returns {any} the redux store\r\n *\r\n * @example\r\n *\r\n * import React from 'react'\r\n * import { useStore } from 'react-redux'\r\n *\r\n * export const ExampleComponent = () => {\r\n *   const store = useStore()\r\n *   return <div>{store.getState()}</div>\r\n * }\r\n */\n\nexport var useStore = createStoreHook();","import { ReactReduxContext } from '../components/Context';\nimport { useStore as useDefaultStore, createStoreHook } from './useStore';\n/**\r\n * Hook factory, which creates a `useDispatch` hook bound to a given context.\r\n *\r\n * @param {Function} [context=ReactReduxContext] Context passed to your `<Provider>`.\r\n * @returns {Function} A `useDispatch` hook bound to the specified context.\r\n */\n\nexport function createDispatchHook(context) {\n  if (context === void 0) {\n    context = ReactReduxContext;\n  }\n\n  var useStore = context === ReactReduxContext ? useDefaultStore : createStoreHook(context);\n  return function useDispatch() {\n    var store = useStore();\n    return store.dispatch;\n  };\n}\n/**\r\n * A hook to access the redux `dispatch` function.\r\n *\r\n * @returns {any|function} redux store's `dispatch` function\r\n *\r\n * @example\r\n *\r\n * import React, { useCallback } from 'react'\r\n * import { useDispatch } from 'react-redux'\r\n *\r\n * export const CounterComponent = ({ value }) => {\r\n *   const dispatch = useDispatch()\r\n *   const increaseCounter = useCallback(() => dispatch({ type: 'increase-counter' }), [])\r\n *   return (\r\n *     <div>\r\n *       <span>{value}</span>\r\n *       <button onClick={increaseCounter}>Increase counter</button>\r\n *     </div>\r\n *   )\r\n * }\r\n */\n\nexport var useDispatch = createDispatchHook();","'use strict';\n\nexports.__esModule = true;\nexports.defaultMemoize = defaultMemoize;\nexports.createSelectorCreator = createSelectorCreator;\nexports.createStructuredSelector = createStructuredSelector;\nfunction defaultEqualityCheck(a, b) {\n  return a === b;\n}\n\nfunction areArgumentsShallowlyEqual(equalityCheck, prev, next) {\n  if (prev === null || next === null || prev.length !== next.length) {\n    return false;\n  }\n\n  // Do this in a for loop (and not a `forEach` or an `every`) so we can determine equality as fast as possible.\n  var length = prev.length;\n  for (var i = 0; i < length; i++) {\n    if (!equalityCheck(prev[i], next[i])) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction defaultMemoize(func) {\n  var equalityCheck = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultEqualityCheck;\n\n  var lastArgs = null;\n  var lastResult = null;\n  // we reference arguments instead of spreading them for performance reasons\n  return function () {\n    if (!areArgumentsShallowlyEqual(equalityCheck, lastArgs, arguments)) {\n      // apply arguments instead of spreading for performance.\n      lastResult = func.apply(null, arguments);\n    }\n\n    lastArgs = arguments;\n    return lastResult;\n  };\n}\n\nfunction getDependencies(funcs) {\n  var dependencies = Array.isArray(funcs[0]) ? funcs[0] : funcs;\n\n  if (!dependencies.every(function (dep) {\n    return typeof dep === 'function';\n  })) {\n    var dependencyTypes = dependencies.map(function (dep) {\n      return typeof dep;\n    }).join(', ');\n    throw new Error('Selector creators expect all input-selectors to be functions, ' + ('instead received the following types: [' + dependencyTypes + ']'));\n  }\n\n  return dependencies;\n}\n\nfunction createSelectorCreator(memoize) {\n  for (var _len = arguments.length, memoizeOptions = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    memoizeOptions[_key - 1] = arguments[_key];\n  }\n\n  return function () {\n    for (var _len2 = arguments.length, funcs = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n      funcs[_key2] = arguments[_key2];\n    }\n\n    var recomputations = 0;\n    var resultFunc = funcs.pop();\n    var dependencies = getDependencies(funcs);\n\n    var memoizedResultFunc = memoize.apply(undefined, [function () {\n      recomputations++;\n      // apply arguments instead of spreading for performance.\n      return resultFunc.apply(null, arguments);\n    }].concat(memoizeOptions));\n\n    // If a selector is called with the exact same arguments we don't need to traverse our dependencies again.\n    var selector = defaultMemoize(function () {\n      var params = [];\n      var length = dependencies.length;\n\n      for (var i = 0; i < length; i++) {\n        // apply arguments instead of spreading and mutate a local list of params for performance.\n        params.push(dependencies[i].apply(null, arguments));\n      }\n\n      // apply arguments instead of spreading for performance.\n      return memoizedResultFunc.apply(null, params);\n    });\n\n    selector.resultFunc = resultFunc;\n    selector.recomputations = function () {\n      return recomputations;\n    };\n    selector.resetRecomputations = function () {\n      return recomputations = 0;\n    };\n    return selector;\n  };\n}\n\nvar createSelector = exports.createSelector = createSelectorCreator(defaultMemoize);\n\nfunction createStructuredSelector(selectors) {\n  var selectorCreator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : createSelector;\n\n  if (typeof selectors !== 'object') {\n    throw new Error('createStructuredSelector expects first argument to be an object ' + ('where each property is a selector, instead received a ' + typeof selectors));\n  }\n  var objectKeys = Object.keys(selectors);\n  return selectorCreator(objectKeys.map(function (key) {\n    return selectors[key];\n  }), function () {\n    for (var _len3 = arguments.length, values = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {\n      values[_key3] = arguments[_key3];\n    }\n\n    return values.reduce(function (composition, value, index) {\n      composition[objectKeys[index]] = value;\n      return composition;\n    }, {});\n  });\n}"],"names":["global","CONSOLE_LEVELS","consoleSandbox","callback","originalConsole","console","wrappedLevels","forEach","level","originalWrappedFunc","__sentry_original__","Object","keys","makeLogger","enabled","logger","enable","disable","__SENTRY_DEBUG__","name","args","objectToString","prototype","toString","isError","wat","call","isInstanceOf","Error","isBuiltin","ty","isErrorEvent","isDOMError","isPlainObject","isEvent","Event","isThenable","Boolean","then","base","_e","htmlTreeAsString","elem","keyAttrs","currentElem","out","height","len","sepLength","length","nextStr","_htmlElementAsString","push","parentNode","reverse","join","_oO","el","className","classes","key","attr","i","tagName","toLowerCase","keyAttrPairs","filter","keyAttr","getAttribute","map","keyAttrPair","id","split","allowedAttrs","truncate","str","max","substr","safeJoin","input","delimiter","Array","isArray","output","value","String","e","isMatchingPattern","pattern","test","indexOf","fill","source","replacementFactory","original","wrapped","markFunctionWrapped","_Oo","addNonEnumerableProperty","obj","defineProperty","writable","configurable","proto","getOriginalFunction","func","convertToPlainObject","message","stack","getOwnProperties","newObj","type","target","serializeEventTarget","currentTarget","CustomEvent","detail","Element","extractedProps","property","hasOwnProperty","extractExceptionKeysForMessage","exception","maxLength","sort","includedKeys","serialized","slice","dropUndefinedKeys","inputValue","_dropUndefinedKeys","Map","memoizationMap","undefined","memoVal","get","returnValue","set","item","uuid4","crypto","msCrypto","randomUUID","replace","getRandomByte","getRandomValues","Uint8Array","Math","random","c","getFirstException","event","values","getEventDescription","event_id","eventId","firstException","addExceptionTypeValue","addExceptionMechanism","newMechanism","currentMechanism","mechanism","handled","mergedData","data","checkOrSetAlreadyCaught","__sentry_captured__","err","DEFAULT_IGNORE_ERRORS","InboundFilters","static","this","__init","constructor","_options","setupOnce","addGlobalEventProcessor","getCurrentHub","eventProcess","hub","self","getIntegration","client","getClient","clientOptions","getOptions","options","internalOptions","allowUrls","denyUrls","ignoreErrors","ignoreInternal","_mergeOptions","_isSentryError","oO","_getPossibleEventMessages","some","_isIgnoredError","url","_getEventFilterUrl","_isDeniedUrl","_isAllowedUrl","_shouldDropEvent","frames","stacktrace","frame","filename","_getLastValidUrl","originalFunctionToString","__initStatic","FunctionToString","Function","context","apply","States","SyncPromise","resolve","rejectedSyncPromise","reason","_","reject","_state","PENDING","__init2","_handlers","executor","__init3","__init4","__init5","__init6","_resolve","_reject","onfulfilled","onrejected","result","_executeHandlers","catch","val","finally","onfinally","isRejected","_setResult","RESOLVED","REJECTED","state","_value","cachedHandlers","handler","updateSession","session","user","ipAddress","ip_address","did","email","username","timestamp","time","ignoreDuration","sid","init","started","duration","release","environment","userAgent","errors","status","Scope","_notifyingListeners","_scopeListeners","_eventProcessors","_breadcrumbs","_attachments","_user","_tags","_extra","_contexts","_sdkProcessingMetadata","scope","newScope","_level","_span","_session","_transactionName","_fingerprint","_requestSession","addScopeListener","addEventProcessor","setUser","_notifyScopeListeners","getUser","getRequestSession","setRequestSession","requestSession","setTags","tags","setTag","setExtras","extras","setExtra","extra","setFingerprint","fingerprint","setLevel","setTransactionName","setContext","setSpan","span","getSpan","getTransaction","transaction","setSession","getSession","update","captureContext","updatedScope","contexts","clear","addBreadcrumb","breadcrumb","maxBreadcrumbs","maxCrumbs","min","mergedBreadcrumb","clearBreadcrumbs","addAttachment","attachment","getAttachments","clearAttachments","applyToEvent","hint","trace","getTraceContext","transactionName","_applyFingerprint","breadcrumbs","sdkProcessingMetadata","_notifyEventProcessors","getGlobalEventProcessors","setSDKProcessingMetadata","newData","processors","index","processor","log","final","concat","DEFAULT_BREADCRUMBS","Hub","_stack","_version","getStackTop","bindClient","isOlderThan","version","setupIntegrations","pushScope","clone","getScope","getStack","popScope","pop","withScope","captureException","_lastEventId","syntheticException","_withClient","originalException","captureMessage","captureEvent","lastEventId","beforeBreadcrumb","finalBreadcrumb","configureScope","run","oldHub","makeMain","integration","startTransaction","customSamplingContext","_callExtensionMethod","traceHeaders","captureSession","endSession","_sendSessionUpdate","layer","closeSession","startSession","navigator","startingTime","toJSON","Date","toISOString","attrs","user_agent","sessionToJSON","makeSession","currentSession","shouldSendDefaultPii","sendDefaultPii","method","sentry","getMainCarrier","__SENTRY__","extensions","carrier","registry","getHubFromCarrier","setHubOnCarrier","hasHubOnCarrier","activeDomain","domain","active","registryHubTopStack","getHubFromActiveDomain","installedIntegrations","filterDuplicates","integrations","reduce","acc","every","accIntegration","getIntegrationsToSetup","defaultIntegrations","userIntegrations","userIntegration","integrationsNames","alwaysLastToRun","splice","createStackParser","parsers","sortedParsers","a","b","p","skipFirst","line","cleanedLine","parser","localStack","firstFrameFunction","function","lastFrameFunction","stripSentryFramesAndReverse","defaultFunctionName","getFunctionName","fn","supportsFetch","Headers","Request","Response","isNativeFetch","handlers","instrumented","addInstrumentationHandler","originalConsoleMethod","triggerHandlers","triggerDOMHandler","bind","globalDOMEventHandler","makeDOMEventHandler","document","addEventListener","originalAddEventListener","listener","__sentry_instrumentation_handlers__","handlerForType","refCount","originalRemoveEventListener","instrumentDOM","xhrproto","XMLHttpRequest","originalOpen","xhr","xhrInfo","__sentry_xhr__","toUpperCase","match","__sentry_own_request__","onreadystatechangeHandler","readyState","status_code","endTimestamp","now","startTimestamp","onreadystatechange","readyStateArgs","originalSend","body","instrumentXHR","fetch","doc","sandbox","createElement","hidden","head","appendChild","contentWindow","removeChild","supportsNativeFetch","originalFetch","handlerData","fetchData","getFetchMethod","getFetchUrl","response","error","chrome","isChromePackagedApp","app","runtime","hasHistoryApi","history","pushState","replaceState","supportsHistory","oldOnPopState","onpopstate","to","location","href","from","lastHref","historyReplacementFunction","originalHistoryFunction","instrumentHistory","_oldOnErrorHandler","onerror","msg","column","arguments","_oldOnUnhandledRejectionHandler","onunhandledrejection","instrument","fetchArgs","debounceTimerID","lastCapturedEvent","globalListener","isContentEditable","shouldSkipDOMEvent","previous","current","shouldShortcircuitPreviousDebounce","clearTimeout","setTimeout","SentryError","super","setPrototypeOf","DSN_REGEX","dsn","withPassword","host","path","pass","port","projectId","protocol","publicKey","dsnFromComponents","components","createEnvelope","headers","items","addItemToEnvelope","envelope","newItem","forEachEnvelopeItem","envelopeItem","envelopeItemType","encodeUTF8","textEncoder","TextEncoder","encode","serializeEnvelope","envHeaders","parts","JSON","stringify","append","next","itemHeaders","payload","buffers","totalLength","buf","merged","offset","buffer","concatBuffers","createAttachmentEnvelopeItem","content_type","contentType","attachment_type","attachmentType","ITEM_TYPE_TO_DATA_CATEGORY_MAP","sessions","client_report","user_report","envelopeItemTypeToDataCategory","normalize","depth","maxProperties","visit","ERROR","normalizeToSize","object","maxSize","normalized","encodeURI","utf8Length","memo","hasWeakSet","WeakSet","inner","has","add","delete","memoBuilder","memoize","unmemoize","includes","stringified","_events","g","window","isSyntheticEvent","getPrototypeOf","stringifyValue","startsWith","valueWithToJSON","numAdded","visitable","visitKey","visitValue","getEnvelopeEndpointWithUrlEncodedAuth","tunnelOrOptions","tunnel","sdkInfo","_metadata","sdk","getBaseApiEndpoint","_getIngestEndpoint","sentry_key","sentry_version","sentry_client","encodeURIComponent","_encodedAuth","getSdkMetadataForEnvelopeHeader","metadata","ALREADY_SEEN_ERROR","BaseClient","_integrations","_integrationsInitialized","_numProcessing","_outcomes","_dsn","component","isValidProtocol","isNaN","parseInt","validateDsn","exec","lastPath","projectMatch","dsnFromString","_transport","transport","recordDroppedEvent","transportOptions","_process","eventFromException","_captureEvent","promisedEvent","eventFromMessage","_isEnabled","sendSession","getDsn","getTransport","flush","timeout","_isClientDoneProcessing","clientFinished","transportFlushed","close","integrationIndex","getIntegrationById","integrationId","sendEvent","env","eventType","transactionSampling","samplingMethod","rate","sampleRate","packages","enhanceEventWithSdkInfo","envelopeHeaders","baggage","dynamicSamplingContext","getSentryBaggageItems","sent_at","createEventEnvelopeHeaders","sample_rates","createEventEnvelope","attachments","_sendEnvelope","createSessionEnvelope","category","sendClientReports","_updateSessionFromEvent","crashed","errored","exceptions","ex","sessionNonTerminal","Number","ticked","interval","setInterval","clearInterval","_prepareEvent","normalizeDepth","normalizeMaxBreadth","prepared","_applyClientOptions","_applyIntegrationsMetadata","finalScope","evt","_normalizeEvent","maxBreadth","spans","dist","maxValueLength","request","integrationsArray","_processEvent","finalEvent","beforeSend","isTransaction","__sentry__","rv","nullErr","_ensureBeforeSendRv","processedEvent","promise","send","_clearOutcomes","outcomes","quantity","SDK_VERSION","exceptionFromError","stackParser","parseStackFrames","extractMessage","eventFromError","popSize","framesToPop","reactMinifiedRegexp","getPopSize","eventFromUnknownInput","attachStacktrace","isUnhandledRejection","domException","eventFromString","code","__serialized__","eventFromPlainObject","synthetic","validSeverityLevels","parseUrl","query","fragment","relative","BREADCRUMB_INTEGRATION_ID","Breadcrumbs","dom","_consoleBreadcrumb","serializeAttribute","_xhrBreadcrumb","_fetchBreadcrumb","_historyBreadcrumb","parsedLoc","parsedFrom","parsedTo","cachedFetchImpl","getNativeFetchImplementation","fetchImpl","globalObject","BrowserClient","visibilityState","_flushOutcomes","breadcrumbIntegration","platform","discarded_events","sendBeacon","credentials","keepalive","sendReport","UNKNOWN_FUNCTION","createFrame","lineno","colno","in_app","chromeRegex","chromeEvalRegex","geckoREgex","geckoEvalRegex","winjsRegex","defaultStackParser","subMatch","extractSafariExtensionDetails","isSafariExtension","isSafariWebExtension","ignoreOnError","shouldIgnoreOnError","ignoreNextOnError","wrap","before","wrapper","__sentry_wrapped__","sentryWrapped","wrappedArguments","arg","getOwnPropertyDescriptor","DEFAULT_EVENT_TARGET","TryCatch","eventTarget","requestAnimationFrame","_wrapTimeFunction","_wrapRAF","_wrapXHR","eventTargetOption","_wrapEventTarget","originalCallback","prop","wrapOptions","originalFunction","eventName","handleEvent","wrappedEventHandler","originalEventHandler","GlobalHandlers","_installFunc","_installGlobalOnErrorHandler","_installGlobalOnUnhandledRejectionHandler","stackTraceLimit","installFunc","getHubAndOptions","groups","_enhanceEventWithInitialFrame","_eventFromIncompleteOnError","addMechanismAndCapture","ev","ev0","ev0s","ev0sf","getLocationHref","LinkedErrors","_key","_limit","limit","linkedErrors","_walkErrorTree","_handler","Dedupe","eventProcessor","currentEvent","previousEvent","currentMessage","previousMessage","_isSameFingerprint","_isSameStacktrace","_isSameMessageEvent","previousException","_getExceptionFromEvent","currentException","_isSameExceptionEvent","_previousEvent","currentFrames","_getFramesFromEvent","previousFrames","frameA","frameB","currentFingerprint","previousFingerprint","HttpContext","referrer","Referer","createTransport","makeRequest","remove","task","$","taskProducer","drain","counter","capturedSetTimeout","makePromiseBuffer","bufferSize","rateLimits","filteredEnvelopeItems","envelopeItemDataCategory","limits","all","disabledUntil","isRateLimited","filteredEnvelope","recordEnvelopeLoss","statusCode","updatedRateLimits","rateLimitHeader","retryAfterHeader","trim","retryAfter","categories","headerDelay","delay","header","headerDate","parse","parseRetryAfterHeader","updateRateLimits","makeFetchTransport","nativeFetch","requestOptions","referrerPolicy","fetchOptions","makeXHRTransport","getResponseHeader","open","setRequestHeader","SENTRY_RELEASE","autoSessionTracking","clientClass","debug","warn","initialScope","initAndBind","startSessionOnHub","startSessionTracking","fallbackGlobalObject","getGlobalObject","getGlobalSingleton","creator","isNodeEnv","__SENTRY_BROWSER_BUNDLE__","process","dynamicRequire","mod","require","dateTimestampSource","nowSeconds","platformPerformance","module","performance","getNodePerformance","timeOrigin","getBrowserPerformance","timestampSource","dateTimestampInSeconds","timestampInSeconds","_browserPerformanceTimeOriginMode","threshold","performanceNow","dateNow","timeOriginDelta","abs","timeOriginIsReliable","navigationStart","timing","navigationStartDelta","_arrayLikeToArray","arr","arr2","store","action","_action$payload","_arrayWithoutHoles","iter","Symbol","iterator","_iterableToArray","o","minLen","n","_unsupportedIterableToArray","TypeError","_nonIterableSpread","exports","detectPassiveEvents","passive","noop","removeEventListener","hasSupport","React","reactDom","_defaults2","t","getOwnPropertyNames","r","_extends","assign","_assertThisInitialized","ReferenceError","invariant_1","s","l","u","setInputSelection","selectionStart","selectionEnd","createTextRange","collapse","moveStart","moveEnd","select","defaultFormatChars","parseMask","maskChar","formatChars","mask","prefix","lastEditablePosition","permanents","isPermanentCharacter","isAllowedCharacter","RegExp","isEmpty","getFilledLength","isFilled","formatValue","insertString","h","getRightEditablePosition","getStringValue","isFunction","getCancelAnimationFrame","cancelAnimationFrame","webkitCancelRequestAnimationFrame","webkitCancelAnimationFrame","mozCancelAnimationFrame","defer","webkitRequestAnimationFrame","mozRequestAnimationFrame","cancelDefer","InputElement","f","focused","mounted","previousSelection","selectionDeferId","saveSelectionLoopDeferId","saveSelectionLoop","getSelection","runSaveSelectionLoop","stopSaveSelectionLoop","getInputDOMNode","findDOMNode","nodeName","querySelector","getInputValue","setInputValue","setCursorToEnd","maskOptions","setCursorPosition","setSelection","deferred","start","end","selection","createRange","parentElement","getInputSelection","getCursorPosition","isFocused","getBeforeMaskedValueChangeConfig","alwaysShowMask","props","isInputAutofilled","matches","onChange","beforePasteState","beforeMaskedValueChange","getInsertStringLength","getLeftEditablePosition","clearRange","enteredString","processChange","isWindowsPhoneBrowser","onFocus","onBlur","onMouseDown","mouseDownX","clientX","mouseDownY","clientY","mouseDownTime","getTime","onPaste","defaultPrevented","handleRef","children","inputRef","defaultValue","componentDidMount","componentDidUpdate","m","d","forceUpdate","componentWillUnmount","render","getOwnPropertySymbols","propertyIsEnumerable","_objectWithoutProperties","ref","disabled","readOnly","cloneElement","_inheritsLoose","Component","createStoreHook","useReduxContext","useContext","useDispatch","useStore","dispatch","createDispatchHook","defaultEqualityCheck","areArgumentsShallowlyEqual","equalityCheck","prev","defaultMemoize","lastArgs","lastResult","getDependencies","funcs","dependencies","dep","dependencyTypes","_len","memoizeOptions","_len2","_key2","recomputations","resultFunc","memoizedResultFunc","selector","params","resetRecomputations","createSelectorCreator"],"sourceRoot":""}