{"version":3,"file":"formik.main.3db93f9a.js","mappings":"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AG,EAAG,EAAG,EAAG,GAAI,GAAIA,GAAa,EAAG,EAAG,GAAI,EAAG,EAAG,EAAG,GAAI,EAAG,EAAG,EAAG,GAAI,GAAIA,GAAa,EAAG,EAAG,GAAI,EAAG,EAAG,EAAG,GAAI,EAAG,EAAG,EAAG,GAAI,GAAIA,GAAa,EAAG,EAAG,GAAI,EAAG,EAAG,EAAG,GAAI,EAAG,EAAG,EAAG,GAAI,GAAIA,GAAa,EAAG,EAAG,GAAI,EAAG,EAAG,EAAG,GAAI,EAAG,EAAG,EAAG,GAAI,GAAIA,GAAa,EAAG,EAAG,GAAI,EAAG,EAAG,GAAI,GAAI,EAAG,EAAG,EAAG,GAAI,GAAIA,GAAa,EAAG,EAAG,GAAI,EAAG,EAAG,GAAI,GAAI,EAAG,EAAG,EAAG,GAAI,GAAIA,GAAa,EAAG,EAAG,GAAI,EAAG,EAAG,GAAI,GAAI,EAAG,EAAG,EAAG,GAAI,GAAIA,GAAa,EAAG,EAAG,GAAI,EAAG,EAAG,GAAI,GAAI,EAAG,EAAG,EAAG,GAAI,GAAIA,GAAa,EAAG,EAAG,GAAI,EAAG,EAAG,GAAI,GAAI,EAAG,EAAG,EAAG,GAAI,GAAIA,GAAa,EAAG,EAAG,GAAI,EAAG,EAAG,GAAI,GAAI,EAAG,EAAG,EAAG,GAAI,GAAIA,GAAa,EAAG,EAAG,IAAK,EAAG,EAAG,GAAI,GAAI,EAAG,EAAG,EAAG,GAAI,GAAIA,GAAa,EAAG,EAAG,IAAK,EAAG,EAAG,GAAI,GAAI,EAAG,EAAG,EAAG,GAAI,GAAIA,GAAa,EAAG,EAAG,IAAK,EAAG,EAAG,GAAI,GAAI,EAAG,EAAG,EAAG,GAAI,GAAIA,GAAa,EAAG,EAAG,IAAK,EAAG,EAAG,GAAI,GAAI,EAAG,EAAG,EAAG,GAAI,GAAIA,GAAa,EAAG,GAAI,IAAK,EAAG,EAAG,GAAI,GAAI,EAAG,EAAG,EAAG,GAAI,GAAIA,GAAa,EAAG,GAAI,IAAK,EAAG,EAAG,GAAI,GAAI,EAAG,EAAG,EAAG,GAAI,GAAIA,GAAa,EAAG,GAAI,IAAK,EAAG,EAAG,GAAI,GAAI,EAAG,EAAG,EAAG,GAAI,GAAIA,GAAa,EAAG,GAAI,IAAK,EAAG,EAAG,GAAI,GAAI,EAAG,EAAG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","sources":["webpack://my-vehicles/./node_modules/@material-ui/core/node_modules/@material-ui/styles/esm/mergeClasses/mergeClasses.js","webpack://my-vehicles/./node_modules/@material-ui/core/node_modules/@material-ui/styles/esm/makeStyles/multiKeyStore.js","webpack://my-vehicles/./node_modules/@material-ui/core/node_modules/@material-ui/styles/esm/useTheme/ThemeContext.js","webpack://my-vehicles/./node_modules/@material-ui/core/node_modules/@material-ui/styles/esm/useTheme/useTheme.js","webpack://my-vehicles/./node_modules/@material-ui/core/node_modules/@material-ui/styles/esm/ThemeProvider/nested.js","webpack://my-vehicles/./node_modules/@material-ui/core/node_modules/@material-ui/styles/esm/createGenerateClassName/createGenerateClassName.js","webpack://my-vehicles/./node_modules/@material-ui/core/node_modules/@material-ui/styles/esm/StylesProvider/StylesProvider.js","webpack://my-vehicles/./node_modules/@material-ui/core/node_modules/@material-ui/styles/esm/jssPreset/jssPreset.js","webpack://my-vehicles/./node_modules/@material-ui/core/node_modules/@material-ui/styles/esm/makeStyles/indexCounter.js","webpack://my-vehicles/./node_modules/@material-ui/utils/esm/deepmerge.js","webpack://my-vehicles/./node_modules/@material-ui/core/node_modules/@material-ui/styles/esm/getStylesCreator/noopTheme.js","webpack://my-vehicles/./node_modules/@material-ui/core/node_modules/@material-ui/styles/esm/makeStyles/makeStyles.js","webpack://my-vehicles/./node_modules/@material-ui/core/node_modules/@material-ui/styles/esm/getStylesCreator/getStylesCreator.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/styles/createBreakpoints.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/styles/createMixins.js","webpack://my-vehicles/./node_modules/@material-ui/utils/esm/formatMuiErrorMessage.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/colors/common.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/colors/grey.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/colors/indigo.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/colors/pink.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/colors/red.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/colors/orange.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/colors/blue.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/colors/green.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/styles/colorManipulator.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/styles/createPalette.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/styles/createTypography.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/styles/shadows.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/styles/shape.js","webpack://my-vehicles/./node_modules/@material-ui/core/node_modules/@material-ui/system/esm/breakpoints.js","webpack://my-vehicles/./node_modules/@material-ui/core/node_modules/@material-ui/system/esm/merge.js","webpack://my-vehicles/./node_modules/@material-ui/core/node_modules/@material-ui/system/esm/spacing.js","webpack://my-vehicles/./node_modules/@material-ui/core/node_modules/@material-ui/system/esm/memoize.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/styles/transitions.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/styles/zIndex.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/styles/defaultTheme.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/styles/createTheme.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/styles/createSpacing.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/styles/withStyles.js","webpack://my-vehicles/./node_modules/@material-ui/core/node_modules/@material-ui/styles/esm/withStyles/withStyles.js","webpack://my-vehicles/./node_modules/@material-ui/core/node_modules/@material-ui/styles/esm/getThemeProps/getThemeProps.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/utils/capitalize.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/FormControl/FormControlContext.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/utils/setRef.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/utils/useForkRef.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/utils/useEventCallback.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/utils/useIsFocusVisible.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/ButtonBase/Ripple.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/ButtonBase/TouchRipple.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/ButtonBase/ButtonBase.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/IconButton/IconButton.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/internal/SwitchBase.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/utils/useControlled.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/FormControl/useFormControl.js","webpack://my-vehicles/./node_modules/@material-ui/core/esm/Switch/Switch.js","webpack://my-vehicles/./node_modules/@sentry/core/esm/integrations/inboundfilters.js","webpack://my-vehicles/./node_modules/@sentry/core/esm/integrations/functiontostring.js","webpack://my-vehicles/./node_modules/@sentry/core/esm/integration.js","webpack://my-vehicles/./node_modules/@sentry/utils/esm/error.js","webpack://my-vehicles/./node_modules/@sentry/utils/esm/dsn.js","webpack://my-vehicles/./node_modules/@sentry/core/esm/api.js","webpack://my-vehicles/./node_modules/@sentry/utils/esm/stacktrace.js","webpack://my-vehicles/./node_modules/@sentry/utils/esm/supports.js","webpack://my-vehicles/./node_modules/@sentry/utils/esm/instrument.js","webpack://my-vehicles/./node_modules/@sentry/utils/esm/normalize.js","webpack://my-vehicles/./node_modules/@sentry/utils/esm/memo.js","webpack://my-vehicles/./node_modules/@sentry/utils/esm/envelope.js","webpack://my-vehicles/./node_modules/@sentry/core/esm/envelope.js","webpack://my-vehicles/./node_modules/@sentry/core/esm/baseclient.js","webpack://my-vehicles/./node_modules/@sentry/browser/esm/eventbuilder.js","webpack://my-vehicles/./node_modules/@sentry/utils/esm/severity.js","webpack://my-vehicles/./node_modules/@sentry/utils/esm/url.js","webpack://my-vehicles/./node_modules/@sentry/browser/esm/integrations/breadcrumbs.js","webpack://my-vehicles/./node_modules/@sentry/browser/esm/client.js","webpack://my-vehicles/./node_modules/@sentry/utils/esm/clientreport.js","webpack://my-vehicles/./node_modules/@sentry/browser/esm/stack-parsers.js","webpack://my-vehicles/./node_modules/@sentry/browser/esm/helpers.js","webpack://my-vehicles/./node_modules/@sentry/browser/esm/integrations/trycatch.js","webpack://my-vehicles/./node_modules/@sentry/browser/esm/integrations/globalhandlers.js","webpack://my-vehicles/./node_modules/@sentry/browser/esm/integrations/linkederrors.js","webpack://my-vehicles/./node_modules/@sentry/browser/esm/integrations/dedupe.js","webpack://my-vehicles/./node_modules/@sentry/browser/esm/integrations/httpcontext.js","webpack://my-vehicles/./node_modules/@sentry/utils/esm/ratelimit.js","webpack://my-vehicles/./node_modules/@sentry/core/esm/transports/base.js","webpack://my-vehicles/./node_modules/@sentry/utils/esm/promisebuffer.js","webpack://my-vehicles/./node_modules/@sentry/browser/esm/transports/utils.js","webpack://my-vehicles/./node_modules/@sentry/browser/esm/transports/fetch.js","webpack://my-vehicles/./node_modules/@sentry/browser/esm/transports/xhr.js","webpack://my-vehicles/./node_modules/@sentry/browser/esm/sdk.js","webpack://my-vehicles/./node_modules/@sentry/core/esm/sdk.js","webpack://my-vehicles/./node_modules/@sentry/core/esm/exports.js","webpack://my-vehicles/./node_modules/@sentry/core/esm/hub.js","webpack://my-vehicles/./node_modules/@sentry/core/esm/scope.js","webpack://my-vehicles/./node_modules/@sentry/core/esm/session.js","webpack://my-vehicles/./node_modules/@sentry/core/esm/version.js","webpack://my-vehicles/./node_modules/@sentry/react/esm/profiler.js","webpack://my-vehicles/./node_modules/@sentry/react/esm/constants.js","webpack://my-vehicles/./node_modules/@sentry/react/esm/reactrouter.js","webpack://my-vehicles/./node_modules/@sentry/react/esm/sdk.js","webpack://my-vehicles/./node_modules/@sentry/tracing/esm/index.js","webpack://my-vehicles/./node_modules/@sentry/utils/esm/browser.js","webpack://my-vehicles/./node_modules/@sentry/utils/esm/global.js","webpack://my-vehicles/./node_modules/@sentry/utils/esm/is.js","webpack://my-vehicles/./node_modules/@sentry/utils/esm/logger.js","webpack://my-vehicles/./node_modules/@sentry/utils/esm/misc.js","webpack://my-vehicles/./node_modules/@sentry/utils/esm/node.js","webpack://my-vehicles/./node_modules/@sentry/utils/esm/env.js","webpack://my-vehicles/./node_modules/@sentry/utils/esm/object.js","webpack://my-vehicles/./node_modules/@sentry/utils/esm/string.js","webpack://my-vehicles/./node_modules/@sentry/utils/esm/syncpromise.js","webpack://my-vehicles/./node_modules/@sentry/utils/esm/time.js","webpack://my-vehicles/./node_modules/formik/dist/formik.esm.js","webpack://my-vehicles/./node_modules/formik/node_modules/react-fast-compare/index.js","webpack://my-vehicles/./node_modules/@floating-ui/core/dist/floating-ui.core.mjs","webpack://my-vehicles/./node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs","webpack://my-vehicles/./node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs","webpack://my-vehicles/./node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs"],"sourcesContent":["import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport { getDisplayName } from '@material-ui/utils';\nexport default function mergeClasses() {\n  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n  var baseClasses = options.baseClasses,\n      newClasses = options.newClasses,\n      Component = options.Component;\n\n  if (!newClasses) {\n    return baseClasses;\n  }\n\n  var nextClasses = _extends({}, baseClasses);\n\n  if (process.env.NODE_ENV !== 'production') {\n    if (typeof newClasses === 'string') {\n      console.error([\"Material-UI: The value `\".concat(newClasses, \"` \") + \"provided to the classes prop of \".concat(getDisplayName(Component), \" is incorrect.\"), 'You might want to use the className prop instead.'].join('\\n'));\n      return baseClasses;\n    }\n  }\n\n  Object.keys(newClasses).forEach(function (key) {\n    if (process.env.NODE_ENV !== 'production') {\n      if (!baseClasses[key] && newClasses[key]) {\n        console.error([\"Material-UI: The key `\".concat(key, \"` \") + \"provided to the classes prop is not implemented in \".concat(getDisplayName(Component), \".\"), \"You can only override one of the following: \".concat(Object.keys(baseClasses).join(','), \".\")].join('\\n'));\n      }\n\n      if (newClasses[key] && typeof newClasses[key] !== 'string') {\n        console.error([\"Material-UI: The key `\".concat(key, \"` \") + \"provided to the classes prop is not valid for \".concat(getDisplayName(Component), \".\"), \"You need to provide a non empty string instead of: \".concat(newClasses[key], \".\")].join('\\n'));\n      }\n    }\n\n    if (newClasses[key]) {\n      nextClasses[key] = \"\".concat(baseClasses[key], \" \").concat(newClasses[key]);\n    }\n  });\n  return nextClasses;\n}","// Used https://github.com/thinkloop/multi-key-cache as inspiration\nvar multiKeyStore = {\n  set: function set(cache, key1, key2, value) {\n    var subCache = cache.get(key1);\n\n    if (!subCache) {\n      subCache = new Map();\n      cache.set(key1, subCache);\n    }\n\n    subCache.set(key2, value);\n  },\n  get: function get(cache, key1, key2) {\n    var subCache = cache.get(key1);\n    return subCache ? subCache.get(key2) : undefined;\n  },\n  delete: function _delete(cache, key1, key2) {\n    var subCache = cache.get(key1);\n    subCache.delete(key2);\n  }\n};\nexport default multiKeyStore;","import React from 'react';\nvar ThemeContext = React.createContext(null);\n\nif (process.env.NODE_ENV !== 'production') {\n  ThemeContext.displayName = 'ThemeContext';\n}\n\nexport default ThemeContext;","import React from 'react';\nimport ThemeContext from './ThemeContext';\nexport default function useTheme() {\n  var theme = React.useContext(ThemeContext);\n\n  if (process.env.NODE_ENV !== 'production') {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useDebugValue(theme);\n  }\n\n  return theme;\n}","var hasSymbol = typeof Symbol === 'function' && Symbol.for;\nexport default hasSymbol ? Symbol.for('mui.nested') : '__THEME_NESTED__';","import nested from '../ThemeProvider/nested';\n/**\n * This is the list of the style rule name we use as drop in replacement for the built-in\n * pseudo classes (:checked, :disabled, :focused, etc.).\n *\n * Why do they exist in the first place?\n * These classes are used at a specificity of 2.\n * It allows them to override previously definied styles as well as\n * being untouched by simple user overrides.\n */\n\nvar pseudoClasses = ['checked', 'disabled', 'error', 'focused', 'focusVisible', 'required', 'expanded', 'selected']; // Returns a function which generates unique class names based on counters.\n// When new generator function is created, rule counter is reset.\n// We need to reset the rule counter for SSR for each request.\n//\n// It's inspired by\n// https://github.com/cssinjs/jss/blob/4e6a05dd3f7b6572fdd3ab216861d9e446c20331/src/utils/createGenerateClassName.js\n\nexport default function createGenerateClassName() {\n  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n  var _options$disableGloba = options.disableGlobal,\n      disableGlobal = _options$disableGloba === void 0 ? false : _options$disableGloba,\n      _options$productionPr = options.productionPrefix,\n      productionPrefix = _options$productionPr === void 0 ? 'jss' : _options$productionPr,\n      _options$seed = options.seed,\n      seed = _options$seed === void 0 ? '' : _options$seed;\n  var seedPrefix = seed === '' ? '' : \"\".concat(seed, \"-\");\n  var ruleCounter = 0;\n\n  var getNextCounterId = function getNextCounterId() {\n    ruleCounter += 1;\n\n    if (process.env.NODE_ENV !== 'production') {\n      if (ruleCounter >= 1e10) {\n        console.warn(['Material-UI: You might have a memory leak.', 'The ruleCounter is not supposed to grow that much.'].join(''));\n      }\n    }\n\n    return ruleCounter;\n  };\n\n  return function (rule, styleSheet) {\n    var name = styleSheet.options.name; // Is a global static MUI style?\n\n    if (name && name.indexOf('Mui') === 0 && !styleSheet.options.link && !disableGlobal) {\n      // We can use a shorthand class name, we never use the keys to style the components.\n      if (pseudoClasses.indexOf(rule.key) !== -1) {\n        return \"Mui-\".concat(rule.key);\n      }\n\n      var prefix = \"\".concat(seedPrefix).concat(name, \"-\").concat(rule.key);\n\n      if (!styleSheet.options.theme[nested] || seed !== '') {\n        return prefix;\n      }\n\n      return \"\".concat(prefix, \"-\").concat(getNextCounterId());\n    }\n\n    if (process.env.NODE_ENV === 'production') {\n      return \"\".concat(seedPrefix).concat(productionPrefix).concat(getNextCounterId());\n    }\n\n    var suffix = \"\".concat(rule.key, \"-\").concat(getNextCounterId()); // Help with debuggability.\n\n    if (styleSheet.options.classNamePrefix) {\n      return \"\".concat(seedPrefix).concat(styleSheet.options.classNamePrefix, \"-\").concat(suffix);\n    }\n\n    return \"\".concat(seedPrefix).concat(suffix);\n  };\n}","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/esm/objectWithoutProperties\";\nimport React from 'react';\nimport PropTypes from 'prop-types';\nimport { exactProp } from '@material-ui/utils';\nimport createGenerateClassName from '../createGenerateClassName';\nimport { create } from 'jss';\nimport jssPreset from '../jssPreset'; // Default JSS instance.\n\nvar jss = create(jssPreset()); // Use a singleton or the provided one by the context.\n//\n// The counter-based approach doesn't tolerate any mistake.\n// It's much safer to use the same counter everywhere.\n\nvar generateClassName = createGenerateClassName(); // Exported for test purposes\n\nexport var sheetsManager = new Map();\nvar defaultOptions = {\n  disableGeneration: false,\n  generateClassName: generateClassName,\n  jss: jss,\n  sheetsCache: null,\n  sheetsManager: sheetsManager,\n  sheetsRegistry: null\n};\nexport var StylesContext = React.createContext(defaultOptions);\n\nif (process.env.NODE_ENV !== 'production') {\n  StylesContext.displayName = 'StylesContext';\n}\n\nvar injectFirstNode;\nexport default function StylesProvider(props) {\n  var children = props.children,\n      _props$injectFirst = props.injectFirst,\n      injectFirst = _props$injectFirst === void 0 ? false : _props$injectFirst,\n      _props$disableGenerat = props.disableGeneration,\n      disableGeneration = _props$disableGenerat === void 0 ? false : _props$disableGenerat,\n      localOptions = _objectWithoutProperties(props, [\"children\", \"injectFirst\", \"disableGeneration\"]);\n\n  var outerOptions = React.useContext(StylesContext);\n\n  var context = _extends({}, outerOptions, {\n    disableGeneration: disableGeneration\n  }, localOptions);\n\n  if (process.env.NODE_ENV !== 'production') {\n    if (typeof window === 'undefined' && !context.sheetsManager) {\n      console.error('Material-UI: You need to use the ServerStyleSheets API when rendering on the server.');\n    }\n  }\n\n  if (process.env.NODE_ENV !== 'production') {\n    if (context.jss.options.insertionPoint && injectFirst) {\n      console.error('Material-UI: You cannot use a custom insertionPoint and <StylesContext injectFirst> at the same time.');\n    }\n  }\n\n  if (process.env.NODE_ENV !== 'production') {\n    if (injectFirst && localOptions.jss) {\n      console.error('Material-UI: You cannot use the jss and injectFirst props at the same time.');\n    }\n  }\n\n  if (!context.jss.options.insertionPoint && injectFirst && typeof window !== 'undefined') {\n    if (!injectFirstNode) {\n      var head = document.head;\n      injectFirstNode = document.createComment('mui-inject-first');\n      head.insertBefore(injectFirstNode, head.firstChild);\n    }\n\n    context.jss = create({\n      plugins: jssPreset().plugins,\n      insertionPoint: injectFirstNode\n    });\n  }\n\n  return /*#__PURE__*/React.createElement(StylesContext.Provider, {\n    value: context\n  }, children);\n}\nprocess.env.NODE_ENV !== \"production\" ? StylesProvider.propTypes = {\n  /**\n   * Your component tree.\n   */\n  children: PropTypes.node.isRequired,\n\n  /**\n   * You can disable the generation of the styles with this option.\n   * It can be useful when traversing the React tree outside of the HTML\n   * rendering step on the server.\n   * Let's say you are using react-apollo to extract all\n   * the queries made by the interface server-side - you can significantly speed up the traversal with this prop.\n   */\n  disableGeneration: PropTypes.bool,\n\n  /**\n   * JSS's class name generator.\n   */\n  generateClassName: PropTypes.func,\n\n  /**\n   * By default, the styles are injected last in the <head> element of the page.\n   * As a result, they gain more specificity than any other style sheet.\n   * If you want to override Material-UI's styles, set this prop.\n   */\n  injectFirst: PropTypes.bool,\n\n  /**\n   * JSS's instance.\n   */\n  jss: PropTypes.object,\n\n  /**\n   * @ignore\n   */\n  serverGenerateClassName: PropTypes.func,\n\n  /**\n   * @ignore\n   *\n   * Beta feature.\n   *\n   * Cache for the sheets.\n   */\n  sheetsCache: PropTypes.object,\n\n  /**\n   * @ignore\n   *\n   * The sheetsManager is used to deduplicate style sheet injection in the page.\n   * It's deduplicating using the (theme, styles) couple.\n   * On the server, you should provide a new instance for each request.\n   */\n  sheetsManager: PropTypes.object,\n\n  /**\n   * @ignore\n   *\n   * Collect the sheets.\n   */\n  sheetsRegistry: PropTypes.object\n} : void 0;\n\nif (process.env.NODE_ENV !== 'production') {\n  process.env.NODE_ENV !== \"production\" ? StylesProvider.propTypes = exactProp(StylesProvider.propTypes) : void 0;\n}","import functions from 'jss-plugin-rule-value-function';\nimport global from 'jss-plugin-global';\nimport nested from 'jss-plugin-nested';\nimport camelCase from 'jss-plugin-camel-case';\nimport defaultUnit from 'jss-plugin-default-unit';\nimport vendorPrefixer from 'jss-plugin-vendor-prefixer';\nimport propsSort from 'jss-plugin-props-sort'; // Subset of jss-preset-default with only the plugins the Material-UI components are using.\n\nexport default function jssPreset() {\n  return {\n    plugins: [functions(), global(), nested(), camelCase(), defaultUnit(), // Disable the vendor prefixer server-side, it does nothing.\n    // This way, we can get a performance boost.\n    // In the documentation, we are using `autoprefixer` to solve this problem.\n    typeof window === 'undefined' ? null : vendorPrefixer(), propsSort()]\n  };\n}","/* eslint-disable import/prefer-default-export */\n// Global index counter to preserve source order.\n// We create the style sheet during the creation of the component,\n// children are handled after the parents, so the order of style elements would be parent->child.\n// It is a problem though when a parent passes a className\n// which needs to override any child's styles.\n// StyleSheet of the child has a higher specificity, because of the source order.\n// So our solution is to render sheets them in the reverse order child->sheet, so\n// that parent has a higher specificity.\nvar indexCounter = -1e9;\nexport function increment() {\n  indexCounter += 1;\n\n  if (process.env.NODE_ENV !== 'production') {\n    if (indexCounter >= 0) {\n      console.warn(['Material-UI: You might have a memory leak.', 'The indexCounter is not supposed to grow that much.'].join('\\n'));\n    }\n  }\n\n  return indexCounter;\n}","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _typeof from \"@babel/runtime/helpers/esm/typeof\";\nexport function isPlainObject(item) {\n  return item && _typeof(item) === 'object' && item.constructor === Object;\n}\nexport default function deepmerge(target, source) {\n  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {\n    clone: true\n  };\n  var output = options.clone ? _extends({}, target) : target;\n\n  if (isPlainObject(target) && isPlainObject(source)) {\n    Object.keys(source).forEach(function (key) {\n      // Avoid prototype pollution\n      if (key === '__proto__') {\n        return;\n      }\n\n      if (isPlainObject(source[key]) && key in target) {\n        output[key] = deepmerge(target[key], source[key], options);\n      } else {\n        output[key] = source[key];\n      }\n    });\n  }\n\n  return output;\n}","// We use the same empty object to ref count the styles that don't need a theme object.\nvar noopTheme = {};\nexport default noopTheme;","import _objectWithoutProperties from \"@babel/runtime/helpers/esm/objectWithoutProperties\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nimport React from 'react';\nimport { getDynamicStyles } from 'jss';\nimport mergeClasses from '../mergeClasses';\nimport multiKeyStore from './multiKeyStore';\nimport useTheme from '../useTheme';\nimport { StylesContext } from '../StylesProvider';\nimport { increment } from './indexCounter';\nimport getStylesCreator from '../getStylesCreator';\nimport noopTheme from '../getStylesCreator/noopTheme';\n\nfunction getClasses(_ref, classes, Component) {\n  var state = _ref.state,\n      stylesOptions = _ref.stylesOptions;\n\n  if (stylesOptions.disableGeneration) {\n    return classes || {};\n  }\n\n  if (!state.cacheClasses) {\n    state.cacheClasses = {\n      // Cache for the finalized classes value.\n      value: null,\n      // Cache for the last used classes prop pointer.\n      lastProp: null,\n      // Cache for the last used rendered classes pointer.\n      lastJSS: {}\n    };\n  } // Tracks if either the rendered classes or classes prop has changed,\n  // requiring the generation of a new finalized classes object.\n\n\n  var generate = false;\n\n  if (state.classes !== state.cacheClasses.lastJSS) {\n    state.cacheClasses.lastJSS = state.classes;\n    generate = true;\n  }\n\n  if (classes !== state.cacheClasses.lastProp) {\n    state.cacheClasses.lastProp = classes;\n    generate = true;\n  }\n\n  if (generate) {\n    state.cacheClasses.value = mergeClasses({\n      baseClasses: state.cacheClasses.lastJSS,\n      newClasses: classes,\n      Component: Component\n    });\n  }\n\n  return state.cacheClasses.value;\n}\n\nfunction attach(_ref2, props) {\n  var state = _ref2.state,\n      theme = _ref2.theme,\n      stylesOptions = _ref2.stylesOptions,\n      stylesCreator = _ref2.stylesCreator,\n      name = _ref2.name;\n\n  if (stylesOptions.disableGeneration) {\n    return;\n  }\n\n  var sheetManager = multiKeyStore.get(stylesOptions.sheetsManager, stylesCreator, theme);\n\n  if (!sheetManager) {\n    sheetManager = {\n      refs: 0,\n      staticSheet: null,\n      dynamicStyles: null\n    };\n    multiKeyStore.set(stylesOptions.sheetsManager, stylesCreator, theme, sheetManager);\n  }\n\n  var options = _extends({}, stylesCreator.options, stylesOptions, {\n    theme: theme,\n    flip: typeof stylesOptions.flip === 'boolean' ? stylesOptions.flip : theme.direction === 'rtl'\n  });\n\n  options.generateId = options.serverGenerateClassName || options.generateClassName;\n  var sheetsRegistry = stylesOptions.sheetsRegistry;\n\n  if (sheetManager.refs === 0) {\n    var staticSheet;\n\n    if (stylesOptions.sheetsCache) {\n      staticSheet = multiKeyStore.get(stylesOptions.sheetsCache, stylesCreator, theme);\n    }\n\n    var styles = stylesCreator.create(theme, name);\n\n    if (!staticSheet) {\n      staticSheet = stylesOptions.jss.createStyleSheet(styles, _extends({\n        link: false\n      }, options));\n      staticSheet.attach();\n\n      if (stylesOptions.sheetsCache) {\n        multiKeyStore.set(stylesOptions.sheetsCache, stylesCreator, theme, staticSheet);\n      }\n    }\n\n    if (sheetsRegistry) {\n      sheetsRegistry.add(staticSheet);\n    }\n\n    sheetManager.staticSheet = staticSheet;\n    sheetManager.dynamicStyles = getDynamicStyles(styles);\n  }\n\n  if (sheetManager.dynamicStyles) {\n    var dynamicSheet = stylesOptions.jss.createStyleSheet(sheetManager.dynamicStyles, _extends({\n      link: true\n    }, options));\n    dynamicSheet.update(props);\n    dynamicSheet.attach();\n    state.dynamicSheet = dynamicSheet;\n    state.classes = mergeClasses({\n      baseClasses: sheetManager.staticSheet.classes,\n      newClasses: dynamicSheet.classes\n    });\n\n    if (sheetsRegistry) {\n      sheetsRegistry.add(dynamicSheet);\n    }\n  } else {\n    state.classes = sheetManager.staticSheet.classes;\n  }\n\n  sheetManager.refs += 1;\n}\n\nfunction update(_ref3, props) {\n  var state = _ref3.state;\n\n  if (state.dynamicSheet) {\n    state.dynamicSheet.update(props);\n  }\n}\n\nfunction detach(_ref4) {\n  var state = _ref4.state,\n      theme = _ref4.theme,\n      stylesOptions = _ref4.stylesOptions,\n      stylesCreator = _ref4.stylesCreator;\n\n  if (stylesOptions.disableGeneration) {\n    return;\n  }\n\n  var sheetManager = multiKeyStore.get(stylesOptions.sheetsManager, stylesCreator, theme);\n  sheetManager.refs -= 1;\n  var sheetsRegistry = stylesOptions.sheetsRegistry;\n\n  if (sheetManager.refs === 0) {\n    multiKeyStore.delete(stylesOptions.sheetsManager, stylesCreator, theme);\n    stylesOptions.jss.removeStyleSheet(sheetManager.staticSheet);\n\n    if (sheetsRegistry) {\n      sheetsRegistry.remove(sheetManager.staticSheet);\n    }\n  }\n\n  if (state.dynamicSheet) {\n    stylesOptions.jss.removeStyleSheet(state.dynamicSheet);\n\n    if (sheetsRegistry) {\n      sheetsRegistry.remove(state.dynamicSheet);\n    }\n  }\n}\n\nfunction useSynchronousEffect(func, values) {\n  var key = React.useRef([]);\n  var output; // Store \"generation\" key. Just returns a new object every time\n\n  var currentKey = React.useMemo(function () {\n    return {};\n  }, values); // eslint-disable-line react-hooks/exhaustive-deps\n  // \"the first render\", or \"memo dropped the value\"\n\n  if (key.current !== currentKey) {\n    key.current = currentKey;\n    output = func();\n  }\n\n  React.useEffect(function () {\n    return function () {\n      if (output) {\n        output();\n      }\n    };\n  }, [currentKey] // eslint-disable-line react-hooks/exhaustive-deps\n  );\n}\n\nexport default function makeStyles(stylesOrCreator) {\n  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n  var name = options.name,\n      classNamePrefixOption = options.classNamePrefix,\n      Component = options.Component,\n      _options$defaultTheme = options.defaultTheme,\n      defaultTheme = _options$defaultTheme === void 0 ? noopTheme : _options$defaultTheme,\n      stylesOptions2 = _objectWithoutProperties(options, [\"name\", \"classNamePrefix\", \"Component\", \"defaultTheme\"]);\n\n  var stylesCreator = getStylesCreator(stylesOrCreator);\n  var classNamePrefix = name || classNamePrefixOption || 'makeStyles';\n  stylesCreator.options = {\n    index: increment(),\n    name: name,\n    meta: classNamePrefix,\n    classNamePrefix: classNamePrefix\n  };\n\n  var useStyles = function useStyles() {\n    var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n    var theme = useTheme() || defaultTheme;\n\n    var stylesOptions = _extends({}, React.useContext(StylesContext), stylesOptions2);\n\n    var instance = React.useRef();\n    var shouldUpdate = React.useRef();\n    useSynchronousEffect(function () {\n      var current = {\n        name: name,\n        state: {},\n        stylesCreator: stylesCreator,\n        stylesOptions: stylesOptions,\n        theme: theme\n      };\n      attach(current, props);\n      shouldUpdate.current = false;\n      instance.current = current;\n      return function () {\n        detach(current);\n      };\n    }, [theme, stylesCreator]);\n    React.useEffect(function () {\n      if (shouldUpdate.current) {\n        update(instance.current, props);\n      }\n\n      shouldUpdate.current = true;\n    });\n    var classes = getClasses(instance.current, props.classes, Component);\n\n    if (process.env.NODE_ENV !== 'production') {\n      // eslint-disable-next-line react-hooks/rules-of-hooks\n      React.useDebugValue(classes);\n    }\n\n    return classes;\n  };\n\n  return useStyles;\n}","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _typeof from \"@babel/runtime/helpers/esm/typeof\";\nimport { deepmerge } from '@material-ui/utils';\nimport noopTheme from './noopTheme';\nexport default function getStylesCreator(stylesOrCreator) {\n  var themingEnabled = typeof stylesOrCreator === 'function';\n\n  if (process.env.NODE_ENV !== 'production') {\n    if (_typeof(stylesOrCreator) !== 'object' && !themingEnabled) {\n      console.error(['Material-UI: The `styles` argument provided is invalid.', 'You need to provide a function generating the styles or a styles object.'].join('\\n'));\n    }\n  }\n\n  return {\n    create: function create(theme, name) {\n      var styles;\n\n      try {\n        styles = themingEnabled ? stylesOrCreator(theme) : stylesOrCreator;\n      } catch (err) {\n        if (process.env.NODE_ENV !== 'production') {\n          if (themingEnabled === true && theme === noopTheme) {\n            // TODO: prepend error message/name instead\n            console.error(['Material-UI: The `styles` argument provided is invalid.', 'You are providing a function without a theme in the context.', 'One of the parent elements needs to use a ThemeProvider.'].join('\\n'));\n          }\n        }\n\n        throw err;\n      }\n\n      if (!name || !theme.overrides || !theme.overrides[name]) {\n        return styles;\n      }\n\n      var overrides = theme.overrides[name];\n\n      var stylesWithOverrides = _extends({}, styles);\n\n      Object.keys(overrides).forEach(function (key) {\n        if (process.env.NODE_ENV !== 'production') {\n          if (!stylesWithOverrides[key]) {\n            console.warn(['Material-UI: You are trying to override a style that does not exist.', \"Fix the `\".concat(key, \"` key of `theme.overrides.\").concat(name, \"`.\")].join('\\n'));\n          }\n        }\n\n        stylesWithOverrides[key] = deepmerge(stylesWithOverrides[key], overrides[key]);\n      });\n      return stylesWithOverrides;\n    },\n    options: {}\n  };\n}","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/esm/objectWithoutProperties\";\n// Sorted ASC by size. That's important.\n// It can't be configured as it's used statically for propTypes.\nexport var keys = ['xs', 'sm', 'md', 'lg', 'xl']; // Keep in mind that @media is inclusive by the CSS specification.\n\nexport default function createBreakpoints(breakpoints) {\n  var _breakpoints$values = breakpoints.values,\n      values = _breakpoints$values === void 0 ? {\n    xs: 0,\n    sm: 600,\n    md: 960,\n    lg: 1280,\n    xl: 1920\n  } : _breakpoints$values,\n      _breakpoints$unit = breakpoints.unit,\n      unit = _breakpoints$unit === void 0 ? 'px' : _breakpoints$unit,\n      _breakpoints$step = breakpoints.step,\n      step = _breakpoints$step === void 0 ? 5 : _breakpoints$step,\n      other = _objectWithoutProperties(breakpoints, [\"values\", \"unit\", \"step\"]);\n\n  function up(key) {\n    var value = typeof values[key] === 'number' ? values[key] : key;\n    return \"@media (min-width:\".concat(value).concat(unit, \")\");\n  }\n\n  function down(key) {\n    var endIndex = keys.indexOf(key) + 1;\n    var upperbound = values[keys[endIndex]];\n\n    if (endIndex === keys.length) {\n      // xl down applies to all sizes\n      return up('xs');\n    }\n\n    var value = typeof upperbound === 'number' && endIndex > 0 ? upperbound : key;\n    return \"@media (max-width:\".concat(value - step / 100).concat(unit, \")\");\n  }\n\n  function between(start, end) {\n    var endIndex = keys.indexOf(end);\n\n    if (endIndex === keys.length - 1) {\n      return up(start);\n    }\n\n    return \"@media (min-width:\".concat(typeof values[start] === 'number' ? values[start] : start).concat(unit, \") and \") + \"(max-width:\".concat((endIndex !== -1 && typeof values[keys[endIndex + 1]] === 'number' ? values[keys[endIndex + 1]] : end) - step / 100).concat(unit, \")\");\n  }\n\n  function only(key) {\n    return between(key, key);\n  }\n\n  var warnedOnce = false;\n\n  function width(key) {\n    if (process.env.NODE_ENV !== 'production') {\n      if (!warnedOnce) {\n        warnedOnce = true;\n        console.warn([\"Material-UI: The `theme.breakpoints.width` utility is deprecated because it's redundant.\", 'Use the `theme.breakpoints.values` instead.'].join('\\n'));\n      }\n    }\n\n    return values[key];\n  }\n\n  return _extends({\n    keys: keys,\n    values: values,\n    up: up,\n    down: down,\n    between: between,\n    only: only,\n    width: width\n  }, other);\n}","import _defineProperty from \"@babel/runtime/helpers/esm/defineProperty\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nexport default function createMixins(breakpoints, spacing, mixins) {\n  var _toolbar;\n\n  return _extends({\n    gutters: function gutters() {\n      var styles = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n      console.warn(['Material-UI: theme.mixins.gutters() is deprecated.', 'You can use the source of the mixin directly:', \"\\n      paddingLeft: theme.spacing(2),\\n      paddingRight: theme.spacing(2),\\n      [theme.breakpoints.up('sm')]: {\\n        paddingLeft: theme.spacing(3),\\n        paddingRight: theme.spacing(3),\\n      },\\n      \"].join('\\n'));\n      return _extends({\n        paddingLeft: spacing(2),\n        paddingRight: spacing(2)\n      }, styles, _defineProperty({}, breakpoints.up('sm'), _extends({\n        paddingLeft: spacing(3),\n        paddingRight: spacing(3)\n      }, styles[breakpoints.up('sm')])));\n    },\n    toolbar: (_toolbar = {\n      minHeight: 56\n    }, _defineProperty(_toolbar, \"\".concat(breakpoints.up('xs'), \" and (orientation: landscape)\"), {\n      minHeight: 48\n    }), _defineProperty(_toolbar, breakpoints.up('sm'), {\n      minHeight: 64\n    }), _toolbar)\n  }, mixins);\n}","/**\n * WARNING: Don't import this directly.\n * Use `MuiError` from `@material-ui/utils/macros/MuiError.macro` instead.\n * @param {number} code\n */\nexport default function formatMuiErrorMessage(code) {\n  // Apply babel-plugin-transform-template-literals in loose mode\n  // loose mode is safe iff we're concatenating primitives\n  // see https://babeljs.io/docs/en/babel-plugin-transform-template-literals#loose\n\n  /* eslint-disable prefer-template */\n  var url = 'https://mui.com/production-error/?code=' + code;\n\n  for (var i = 1; i < arguments.length; i += 1) {\n    // rest params over-transpile for this case\n    // eslint-disable-next-line prefer-rest-params\n    url += '&args[]=' + encodeURIComponent(arguments[i]);\n  }\n\n  return 'Minified Material-UI error #' + code + '; visit ' + url + ' for the full message.';\n  /* eslint-enable prefer-template */\n}","var common = {\n  black: '#000',\n  white: '#fff'\n};\nexport default common;","var grey = {\n  50: '#fafafa',\n  100: '#f5f5f5',\n  200: '#eeeeee',\n  300: '#e0e0e0',\n  400: '#bdbdbd',\n  500: '#9e9e9e',\n  600: '#757575',\n  700: '#616161',\n  800: '#424242',\n  900: '#212121',\n  A100: '#d5d5d5',\n  A200: '#aaaaaa',\n  A400: '#303030',\n  A700: '#616161'\n};\nexport default grey;","var indigo = {\n  50: '#e8eaf6',\n  100: '#c5cae9',\n  200: '#9fa8da',\n  300: '#7986cb',\n  400: '#5c6bc0',\n  500: '#3f51b5',\n  600: '#3949ab',\n  700: '#303f9f',\n  800: '#283593',\n  900: '#1a237e',\n  A100: '#8c9eff',\n  A200: '#536dfe',\n  A400: '#3d5afe',\n  A700: '#304ffe'\n};\nexport default indigo;","var pink = {\n  50: '#fce4ec',\n  100: '#f8bbd0',\n  200: '#f48fb1',\n  300: '#f06292',\n  400: '#ec407a',\n  500: '#e91e63',\n  600: '#d81b60',\n  700: '#c2185b',\n  800: '#ad1457',\n  900: '#880e4f',\n  A100: '#ff80ab',\n  A200: '#ff4081',\n  A400: '#f50057',\n  A700: '#c51162'\n};\nexport default pink;","var red = {\n  50: '#ffebee',\n  100: '#ffcdd2',\n  200: '#ef9a9a',\n  300: '#e57373',\n  400: '#ef5350',\n  500: '#f44336',\n  600: '#e53935',\n  700: '#d32f2f',\n  800: '#c62828',\n  900: '#b71c1c',\n  A100: '#ff8a80',\n  A200: '#ff5252',\n  A400: '#ff1744',\n  A700: '#d50000'\n};\nexport default red;","var orange = {\n  50: '#fff3e0',\n  100: '#ffe0b2',\n  200: '#ffcc80',\n  300: '#ffb74d',\n  400: '#ffa726',\n  500: '#ff9800',\n  600: '#fb8c00',\n  700: '#f57c00',\n  800: '#ef6c00',\n  900: '#e65100',\n  A100: '#ffd180',\n  A200: '#ffab40',\n  A400: '#ff9100',\n  A700: '#ff6d00'\n};\nexport default orange;","var blue = {\n  50: '#e3f2fd',\n  100: '#bbdefb',\n  200: '#90caf9',\n  300: '#64b5f6',\n  400: '#42a5f5',\n  500: '#2196f3',\n  600: '#1e88e5',\n  700: '#1976d2',\n  800: '#1565c0',\n  900: '#0d47a1',\n  A100: '#82b1ff',\n  A200: '#448aff',\n  A400: '#2979ff',\n  A700: '#2962ff'\n};\nexport default blue;","var green = {\n  50: '#e8f5e9',\n  100: '#c8e6c9',\n  200: '#a5d6a7',\n  300: '#81c784',\n  400: '#66bb6a',\n  500: '#4caf50',\n  600: '#43a047',\n  700: '#388e3c',\n  800: '#2e7d32',\n  900: '#1b5e20',\n  A100: '#b9f6ca',\n  A200: '#69f0ae',\n  A400: '#00e676',\n  A700: '#00c853'\n};\nexport default green;","import { formatMuiErrorMessage as _formatMuiErrorMessage } from \"@material-ui/utils\";\n\n/* eslint-disable no-use-before-define */\n\n/**\n * Returns a number whose value is limited to the given range.\n *\n * @param {number} value The value to be clamped\n * @param {number} min The lower boundary of the output range\n * @param {number} max The upper boundary of the output range\n * @returns {number} A number in the range [min, max]\n */\nfunction clamp(value) {\n  var min = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n  var max = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;\n\n  if (process.env.NODE_ENV !== 'production') {\n    if (value < min || value > max) {\n      console.error(\"Material-UI: The value provided \".concat(value, \" is out of range [\").concat(min, \", \").concat(max, \"].\"));\n    }\n  }\n\n  return Math.min(Math.max(min, value), max);\n}\n/**\n * Converts a color from CSS hex format to CSS rgb format.\n *\n * @param {string} color - Hex color, i.e. #nnn or #nnnnnn\n * @returns {string} A CSS rgb color string\n */\n\n\nexport function hexToRgb(color) {\n  color = color.substr(1);\n  var re = new RegExp(\".{1,\".concat(color.length >= 6 ? 2 : 1, \"}\"), 'g');\n  var colors = color.match(re);\n\n  if (colors && colors[0].length === 1) {\n    colors = colors.map(function (n) {\n      return n + n;\n    });\n  }\n\n  return colors ? \"rgb\".concat(colors.length === 4 ? 'a' : '', \"(\").concat(colors.map(function (n, index) {\n    return index < 3 ? parseInt(n, 16) : Math.round(parseInt(n, 16) / 255 * 1000) / 1000;\n  }).join(', '), \")\") : '';\n}\n\nfunction intToHex(int) {\n  var hex = int.toString(16);\n  return hex.length === 1 ? \"0\".concat(hex) : hex;\n}\n/**\n * Converts a color from CSS rgb format to CSS hex format.\n *\n * @param {string} color - RGB color, i.e. rgb(n, n, n)\n * @returns {string} A CSS rgb color string, i.e. #nnnnnn\n */\n\n\nexport function rgbToHex(color) {\n  // Idempotent\n  if (color.indexOf('#') === 0) {\n    return color;\n  }\n\n  var _decomposeColor = decomposeColor(color),\n      values = _decomposeColor.values;\n\n  return \"#\".concat(values.map(function (n) {\n    return intToHex(n);\n  }).join(''));\n}\n/**\n * Converts a color from hsl format to rgb format.\n *\n * @param {string} color - HSL color values\n * @returns {string} rgb color values\n */\n\nexport function hslToRgb(color) {\n  color = decomposeColor(color);\n  var _color = color,\n      values = _color.values;\n  var h = values[0];\n  var s = values[1] / 100;\n  var l = values[2] / 100;\n  var a = s * Math.min(l, 1 - l);\n\n  var f = function f(n) {\n    var k = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : (n + h / 30) % 12;\n    return l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);\n  };\n\n  var type = 'rgb';\n  var rgb = [Math.round(f(0) * 255), Math.round(f(8) * 255), Math.round(f(4) * 255)];\n\n  if (color.type === 'hsla') {\n    type += 'a';\n    rgb.push(values[3]);\n  }\n\n  return recomposeColor({\n    type: type,\n    values: rgb\n  });\n}\n/**\n * Returns an object with the type and values of a color.\n *\n * Note: Does not support rgb % values.\n *\n * @param {string} color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla()\n * @returns {object} - A MUI color object: {type: string, values: number[]}\n */\n\nexport function decomposeColor(color) {\n  // Idempotent\n  if (color.type) {\n    return color;\n  }\n\n  if (color.charAt(0) === '#') {\n    return decomposeColor(hexToRgb(color));\n  }\n\n  var marker = color.indexOf('(');\n  var type = color.substring(0, marker);\n\n  if (['rgb', 'rgba', 'hsl', 'hsla'].indexOf(type) === -1) {\n    throw new Error(process.env.NODE_ENV !== \"production\" ? \"Material-UI: Unsupported `\".concat(color, \"` color.\\nWe support the following formats: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla().\") : _formatMuiErrorMessage(3, color));\n  }\n\n  var values = color.substring(marker + 1, color.length - 1).split(',');\n  values = values.map(function (value) {\n    return parseFloat(value);\n  });\n  return {\n    type: type,\n    values: values\n  };\n}\n/**\n * Converts a color object with type and values to a string.\n *\n * @param {object} color - Decomposed color\n * @param {string} color.type - One of: 'rgb', 'rgba', 'hsl', 'hsla'\n * @param {array} color.values - [n,n,n] or [n,n,n,n]\n * @returns {string} A CSS color string\n */\n\nexport function recomposeColor(color) {\n  var type = color.type;\n  var values = color.values;\n\n  if (type.indexOf('rgb') !== -1) {\n    // Only convert the first 3 values to int (i.e. not alpha)\n    values = values.map(function (n, i) {\n      return i < 3 ? parseInt(n, 10) : n;\n    });\n  } else if (type.indexOf('hsl') !== -1) {\n    values[1] = \"\".concat(values[1], \"%\");\n    values[2] = \"\".concat(values[2], \"%\");\n  }\n\n  return \"\".concat(type, \"(\").concat(values.join(', '), \")\");\n}\n/**\n * Calculates the contrast ratio between two colors.\n *\n * Formula: https://www.w3.org/TR/WCAG20-TECHS/G17.html#G17-tests\n *\n * @param {string} foreground - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla()\n * @param {string} background - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla()\n * @returns {number} A contrast ratio value in the range 0 - 21.\n */\n\nexport function getContrastRatio(foreground, background) {\n  var lumA = getLuminance(foreground);\n  var lumB = getLuminance(background);\n  return (Math.max(lumA, lumB) + 0.05) / (Math.min(lumA, lumB) + 0.05);\n}\n/**\n * The relative brightness of any point in a color space,\n * normalized to 0 for darkest black and 1 for lightest white.\n *\n * Formula: https://www.w3.org/TR/WCAG20-TECHS/G17.html#G17-tests\n *\n * @param {string} color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla()\n * @returns {number} The relative brightness of the color in the range 0 - 1\n */\n\nexport function getLuminance(color) {\n  color = decomposeColor(color);\n  var rgb = color.type === 'hsl' ? decomposeColor(hslToRgb(color)).values : color.values;\n  rgb = rgb.map(function (val) {\n    val /= 255; // normalized\n\n    return val <= 0.03928 ? val / 12.92 : Math.pow((val + 0.055) / 1.055, 2.4);\n  }); // Truncate at 3 digits\n\n  return Number((0.2126 * rgb[0] + 0.7152 * rgb[1] + 0.0722 * rgb[2]).toFixed(3));\n}\n/**\n * Darken or lighten a color, depending on its luminance.\n * Light colors are darkened, dark colors are lightened.\n *\n * @param {string} color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla()\n * @param {number} coefficient=0.15 - multiplier in the range 0 - 1\n * @returns {string} A CSS color string. Hex input values are returned as rgb\n */\n\nexport function emphasize(color) {\n  var coefficient = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0.15;\n  return getLuminance(color) > 0.5 ? darken(color, coefficient) : lighten(color, coefficient);\n}\nvar warnedOnce = false;\n/**\n * Set the absolute transparency of a color.\n * Any existing alpha values are overwritten.\n *\n * @param {string} color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla()\n * @param {number} value - value to set the alpha channel to in the range 0 -1\n * @returns {string} A CSS color string. Hex input values are returned as rgb\n *\n * @deprecated\n * Use `import { alpha } from '@material-ui/core/styles'` instead.\n */\n\nexport function fade(color, value) {\n  if (process.env.NODE_ENV !== 'production') {\n    if (!warnedOnce) {\n      warnedOnce = true;\n      console.error(['Material-UI: The `fade` color utility was renamed to `alpha` to better describe its functionality.', '', \"You should use `import { alpha } from '@material-ui/core/styles'`\"].join('\\n'));\n    }\n  }\n\n  return alpha(color, value);\n}\n/**\n * Set the absolute transparency of a color.\n * Any existing alpha value is overwritten.\n *\n * @param {string} color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla()\n * @param {number} value - value to set the alpha channel to in the range 0-1\n * @returns {string} A CSS color string. Hex input values are returned as rgb\n */\n\nexport function alpha(color, value) {\n  color = decomposeColor(color);\n  value = clamp(value);\n\n  if (color.type === 'rgb' || color.type === 'hsl') {\n    color.type += 'a';\n  }\n\n  color.values[3] = value;\n  return recomposeColor(color);\n}\n/**\n * Darkens a color.\n *\n * @param {string} color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla()\n * @param {number} coefficient - multiplier in the range 0 - 1\n * @returns {string} A CSS color string. Hex input values are returned as rgb\n */\n\nexport function darken(color, coefficient) {\n  color = decomposeColor(color);\n  coefficient = clamp(coefficient);\n\n  if (color.type.indexOf('hsl') !== -1) {\n    color.values[2] *= 1 - coefficient;\n  } else if (color.type.indexOf('rgb') !== -1) {\n    for (var i = 0; i < 3; i += 1) {\n      color.values[i] *= 1 - coefficient;\n    }\n  }\n\n  return recomposeColor(color);\n}\n/**\n * Lightens a color.\n *\n * @param {string} color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(), hsl(), hsla()\n * @param {number} coefficient - multiplier in the range 0 - 1\n * @returns {string} A CSS color string. Hex input values are returned as rgb\n */\n\nexport function lighten(color, coefficient) {\n  color = decomposeColor(color);\n  coefficient = clamp(coefficient);\n\n  if (color.type.indexOf('hsl') !== -1) {\n    color.values[2] += (100 - color.values[2]) * coefficient;\n  } else if (color.type.indexOf('rgb') !== -1) {\n    for (var i = 0; i < 3; i += 1) {\n      color.values[i] += (255 - color.values[i]) * coefficient;\n    }\n  }\n\n  return recomposeColor(color);\n}","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/esm/objectWithoutProperties\";\nimport { formatMuiErrorMessage as _formatMuiErrorMessage } from \"@material-ui/utils\";\nimport { deepmerge } from '@material-ui/utils';\nimport common from '../colors/common';\nimport grey from '../colors/grey';\nimport indigo from '../colors/indigo';\nimport pink from '../colors/pink';\nimport red from '../colors/red';\nimport orange from '../colors/orange';\nimport blue from '../colors/blue';\nimport green from '../colors/green';\nimport { darken, getContrastRatio, lighten } from './colorManipulator';\nexport var light = {\n  // The colors used to style the text.\n  text: {\n    // The most important text.\n    primary: 'rgba(0, 0, 0, 0.87)',\n    // Secondary text.\n    secondary: 'rgba(0, 0, 0, 0.54)',\n    // Disabled text have even lower visual prominence.\n    disabled: 'rgba(0, 0, 0, 0.38)',\n    // Text hints.\n    hint: 'rgba(0, 0, 0, 0.38)'\n  },\n  // The color used to divide different elements.\n  divider: 'rgba(0, 0, 0, 0.12)',\n  // The background colors used to style the surfaces.\n  // Consistency between these values is important.\n  background: {\n    paper: common.white,\n    default: grey[50]\n  },\n  // The colors used to style the action elements.\n  action: {\n    // The color of an active action like an icon button.\n    active: 'rgba(0, 0, 0, 0.54)',\n    // The color of an hovered action.\n    hover: 'rgba(0, 0, 0, 0.04)',\n    hoverOpacity: 0.04,\n    // The color of a selected action.\n    selected: 'rgba(0, 0, 0, 0.08)',\n    selectedOpacity: 0.08,\n    // The color of a disabled action.\n    disabled: 'rgba(0, 0, 0, 0.26)',\n    // The background color of a disabled action.\n    disabledBackground: 'rgba(0, 0, 0, 0.12)',\n    disabledOpacity: 0.38,\n    focus: 'rgba(0, 0, 0, 0.12)',\n    focusOpacity: 0.12,\n    activatedOpacity: 0.12\n  }\n};\nexport var dark = {\n  text: {\n    primary: common.white,\n    secondary: 'rgba(255, 255, 255, 0.7)',\n    disabled: 'rgba(255, 255, 255, 0.5)',\n    hint: 'rgba(255, 255, 255, 0.5)',\n    icon: 'rgba(255, 255, 255, 0.5)'\n  },\n  divider: 'rgba(255, 255, 255, 0.12)',\n  background: {\n    paper: grey[800],\n    default: '#303030'\n  },\n  action: {\n    active: common.white,\n    hover: 'rgba(255, 255, 255, 0.08)',\n    hoverOpacity: 0.08,\n    selected: 'rgba(255, 255, 255, 0.16)',\n    selectedOpacity: 0.16,\n    disabled: 'rgba(255, 255, 255, 0.3)',\n    disabledBackground: 'rgba(255, 255, 255, 0.12)',\n    disabledOpacity: 0.38,\n    focus: 'rgba(255, 255, 255, 0.12)',\n    focusOpacity: 0.12,\n    activatedOpacity: 0.24\n  }\n};\n\nfunction addLightOrDark(intent, direction, shade, tonalOffset) {\n  var tonalOffsetLight = tonalOffset.light || tonalOffset;\n  var tonalOffsetDark = tonalOffset.dark || tonalOffset * 1.5;\n\n  if (!intent[direction]) {\n    if (intent.hasOwnProperty(shade)) {\n      intent[direction] = intent[shade];\n    } else if (direction === 'light') {\n      intent.light = lighten(intent.main, tonalOffsetLight);\n    } else if (direction === 'dark') {\n      intent.dark = darken(intent.main, tonalOffsetDark);\n    }\n  }\n}\n\nexport default function createPalette(palette) {\n  var _palette$primary = palette.primary,\n      primary = _palette$primary === void 0 ? {\n    light: indigo[300],\n    main: indigo[500],\n    dark: indigo[700]\n  } : _palette$primary,\n      _palette$secondary = palette.secondary,\n      secondary = _palette$secondary === void 0 ? {\n    light: pink.A200,\n    main: pink.A400,\n    dark: pink.A700\n  } : _palette$secondary,\n      _palette$error = palette.error,\n      error = _palette$error === void 0 ? {\n    light: red[300],\n    main: red[500],\n    dark: red[700]\n  } : _palette$error,\n      _palette$warning = palette.warning,\n      warning = _palette$warning === void 0 ? {\n    light: orange[300],\n    main: orange[500],\n    dark: orange[700]\n  } : _palette$warning,\n      _palette$info = palette.info,\n      info = _palette$info === void 0 ? {\n    light: blue[300],\n    main: blue[500],\n    dark: blue[700]\n  } : _palette$info,\n      _palette$success = palette.success,\n      success = _palette$success === void 0 ? {\n    light: green[300],\n    main: green[500],\n    dark: green[700]\n  } : _palette$success,\n      _palette$type = palette.type,\n      type = _palette$type === void 0 ? 'light' : _palette$type,\n      _palette$contrastThre = palette.contrastThreshold,\n      contrastThreshold = _palette$contrastThre === void 0 ? 3 : _palette$contrastThre,\n      _palette$tonalOffset = palette.tonalOffset,\n      tonalOffset = _palette$tonalOffset === void 0 ? 0.2 : _palette$tonalOffset,\n      other = _objectWithoutProperties(palette, [\"primary\", \"secondary\", \"error\", \"warning\", \"info\", \"success\", \"type\", \"contrastThreshold\", \"tonalOffset\"]); // Use the same logic as\n  // Bootstrap: https://github.com/twbs/bootstrap/blob/1d6e3710dd447de1a200f29e8fa521f8a0908f70/scss/_functions.scss#L59\n  // and material-components-web https://github.com/material-components/material-components-web/blob/ac46b8863c4dab9fc22c4c662dc6bd1b65dd652f/packages/mdc-theme/_functions.scss#L54\n\n\n  function getContrastText(background) {\n    var contrastText = getContrastRatio(background, dark.text.primary) >= contrastThreshold ? dark.text.primary : light.text.primary;\n\n    if (process.env.NODE_ENV !== 'production') {\n      var contrast = getContrastRatio(background, contrastText);\n\n      if (contrast < 3) {\n        console.error([\"Material-UI: The contrast ratio of \".concat(contrast, \":1 for \").concat(contrastText, \" on \").concat(background), 'falls below the WCAG recommended absolute minimum contrast ratio of 3:1.', 'https://www.w3.org/TR/2008/REC-WCAG20-20081211/#visual-audio-contrast-contrast'].join('\\n'));\n      }\n    }\n\n    return contrastText;\n  }\n\n  var augmentColor = function augmentColor(color) {\n    var mainShade = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 500;\n    var lightShade = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 300;\n    var darkShade = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 700;\n    color = _extends({}, color);\n\n    if (!color.main && color[mainShade]) {\n      color.main = color[mainShade];\n    }\n\n    if (!color.main) {\n      throw new Error(process.env.NODE_ENV !== \"production\" ? \"Material-UI: The color provided to augmentColor(color) is invalid.\\nThe color object needs to have a `main` property or a `\".concat(mainShade, \"` property.\") : _formatMuiErrorMessage(4, mainShade));\n    }\n\n    if (typeof color.main !== 'string') {\n      throw new Error(process.env.NODE_ENV !== \"production\" ? \"Material-UI: The color provided to augmentColor(color) is invalid.\\n`color.main` should be a string, but `\".concat(JSON.stringify(color.main), \"` was provided instead.\\n\\nDid you intend to use one of the following approaches?\\n\\nimport {\\xA0green } from \\\"@material-ui/core/colors\\\";\\n\\nconst theme1 = createTheme({ palette: {\\n  primary: green,\\n} });\\n\\nconst theme2 = createTheme({ palette: {\\n  primary: { main: green[500] },\\n} });\") : _formatMuiErrorMessage(5, JSON.stringify(color.main)));\n    }\n\n    addLightOrDark(color, 'light', lightShade, tonalOffset);\n    addLightOrDark(color, 'dark', darkShade, tonalOffset);\n\n    if (!color.contrastText) {\n      color.contrastText = getContrastText(color.main);\n    }\n\n    return color;\n  };\n\n  var types = {\n    dark: dark,\n    light: light\n  };\n\n  if (process.env.NODE_ENV !== 'production') {\n    if (!types[type]) {\n      console.error(\"Material-UI: The palette type `\".concat(type, \"` is not supported.\"));\n    }\n  }\n\n  var paletteOutput = deepmerge(_extends({\n    // A collection of common colors.\n    common: common,\n    // The palette type, can be light or dark.\n    type: type,\n    // The colors used to represent primary interface elements for a user.\n    primary: augmentColor(primary),\n    // The colors used to represent secondary interface elements for a user.\n    secondary: augmentColor(secondary, 'A400', 'A200', 'A700'),\n    // The colors used to represent interface elements that the user should be made aware of.\n    error: augmentColor(error),\n    // The colors used to represent potentially dangerous actions or important messages.\n    warning: augmentColor(warning),\n    // The colors used to present information to the user that is neutral and not necessarily important.\n    info: augmentColor(info),\n    // The colors used to indicate the successful completion of an action that user triggered.\n    success: augmentColor(success),\n    // The grey colors.\n    grey: grey,\n    // Used by `getContrastText()` to maximize the contrast between\n    // the background and the text.\n    contrastThreshold: contrastThreshold,\n    // Takes a background color and returns the text color that maximizes the contrast.\n    getContrastText: getContrastText,\n    // Generate a rich color object.\n    augmentColor: augmentColor,\n    // Used by the functions below to shift a color's luminance by approximately\n    // two indexes within its tonal palette.\n    // E.g., shift from Red 500 to Red 300 or Red 700.\n    tonalOffset: tonalOffset\n  }, types[type]), other);\n  return paletteOutput;\n}","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/esm/objectWithoutProperties\";\nimport { deepmerge } from '@material-ui/utils';\n\nfunction round(value) {\n  return Math.round(value * 1e5) / 1e5;\n}\n\nvar warnedOnce = false;\n\nfunction roundWithDeprecationWarning(value) {\n  if (process.env.NODE_ENV !== 'production') {\n    if (!warnedOnce) {\n      console.warn(['Material-UI: The `theme.typography.round` helper is deprecated.', 'Head to https://material-ui.com/r/migration-v4/#theme for a migration path.'].join('\\n'));\n      warnedOnce = true;\n    }\n  }\n\n  return round(value);\n}\n\nvar caseAllCaps = {\n  textTransform: 'uppercase'\n};\nvar defaultFontFamily = '\"Roboto\", \"Helvetica\", \"Arial\", sans-serif';\n/**\n * @see @link{https://material.io/design/typography/the-type-system.html}\n * @see @link{https://material.io/design/typography/understanding-typography.html}\n */\n\nexport default function createTypography(palette, typography) {\n  var _ref = typeof typography === 'function' ? typography(palette) : typography,\n      _ref$fontFamily = _ref.fontFamily,\n      fontFamily = _ref$fontFamily === void 0 ? defaultFontFamily : _ref$fontFamily,\n      _ref$fontSize = _ref.fontSize,\n      fontSize = _ref$fontSize === void 0 ? 14 : _ref$fontSize,\n      _ref$fontWeightLight = _ref.fontWeightLight,\n      fontWeightLight = _ref$fontWeightLight === void 0 ? 300 : _ref$fontWeightLight,\n      _ref$fontWeightRegula = _ref.fontWeightRegular,\n      fontWeightRegular = _ref$fontWeightRegula === void 0 ? 400 : _ref$fontWeightRegula,\n      _ref$fontWeightMedium = _ref.fontWeightMedium,\n      fontWeightMedium = _ref$fontWeightMedium === void 0 ? 500 : _ref$fontWeightMedium,\n      _ref$fontWeightBold = _ref.fontWeightBold,\n      fontWeightBold = _ref$fontWeightBold === void 0 ? 700 : _ref$fontWeightBold,\n      _ref$htmlFontSize = _ref.htmlFontSize,\n      htmlFontSize = _ref$htmlFontSize === void 0 ? 16 : _ref$htmlFontSize,\n      allVariants = _ref.allVariants,\n      pxToRem2 = _ref.pxToRem,\n      other = _objectWithoutProperties(_ref, [\"fontFamily\", \"fontSize\", \"fontWeightLight\", \"fontWeightRegular\", \"fontWeightMedium\", \"fontWeightBold\", \"htmlFontSize\", \"allVariants\", \"pxToRem\"]);\n\n  if (process.env.NODE_ENV !== 'production') {\n    if (typeof fontSize !== 'number') {\n      console.error('Material-UI: `fontSize` is required to be a number.');\n    }\n\n    if (typeof htmlFontSize !== 'number') {\n      console.error('Material-UI: `htmlFontSize` is required to be a number.');\n    }\n  }\n\n  var coef = fontSize / 14;\n\n  var pxToRem = pxToRem2 || function (size) {\n    return \"\".concat(size / htmlFontSize * coef, \"rem\");\n  };\n\n  var buildVariant = function buildVariant(fontWeight, size, lineHeight, letterSpacing, casing) {\n    return _extends({\n      fontFamily: fontFamily,\n      fontWeight: fontWeight,\n      fontSize: pxToRem(size),\n      // Unitless following https://meyerweb.com/eric/thoughts/2006/02/08/unitless-line-heights/\n      lineHeight: lineHeight\n    }, fontFamily === defaultFontFamily ? {\n      letterSpacing: \"\".concat(round(letterSpacing / size), \"em\")\n    } : {}, casing, allVariants);\n  };\n\n  var variants = {\n    h1: buildVariant(fontWeightLight, 96, 1.167, -1.5),\n    h2: buildVariant(fontWeightLight, 60, 1.2, -0.5),\n    h3: buildVariant(fontWeightRegular, 48, 1.167, 0),\n    h4: buildVariant(fontWeightRegular, 34, 1.235, 0.25),\n    h5: buildVariant(fontWeightRegular, 24, 1.334, 0),\n    h6: buildVariant(fontWeightMedium, 20, 1.6, 0.15),\n    subtitle1: buildVariant(fontWeightRegular, 16, 1.75, 0.15),\n    subtitle2: buildVariant(fontWeightMedium, 14, 1.57, 0.1),\n    body1: buildVariant(fontWeightRegular, 16, 1.5, 0.15),\n    body2: buildVariant(fontWeightRegular, 14, 1.43, 0.15),\n    button: buildVariant(fontWeightMedium, 14, 1.75, 0.4, caseAllCaps),\n    caption: buildVariant(fontWeightRegular, 12, 1.66, 0.4),\n    overline: buildVariant(fontWeightRegular, 12, 2.66, 1, caseAllCaps)\n  };\n  return deepmerge(_extends({\n    htmlFontSize: htmlFontSize,\n    pxToRem: pxToRem,\n    round: roundWithDeprecationWarning,\n    // TODO v5: remove\n    fontFamily: fontFamily,\n    fontSize: fontSize,\n    fontWeightLight: fontWeightLight,\n    fontWeightRegular: fontWeightRegular,\n    fontWeightMedium: fontWeightMedium,\n    fontWeightBold: fontWeightBold\n  }, variants), other, {\n    clone: false // No need to clone deep\n\n  });\n}","var shadowKeyUmbraOpacity = 0.2;\nvar shadowKeyPenumbraOpacity = 0.14;\nvar shadowAmbientShadowOpacity = 0.12;\n\nfunction createShadow() {\n  return [\"\".concat(arguments.length <= 0 ? undefined : arguments[0], \"px \").concat(arguments.length <= 1 ? undefined : arguments[1], \"px \").concat(arguments.length <= 2 ? undefined : arguments[2], \"px \").concat(arguments.length <= 3 ? undefined : arguments[3], \"px rgba(0,0,0,\").concat(shadowKeyUmbraOpacity, \")\"), \"\".concat(arguments.length <= 4 ? undefined : arguments[4], \"px \").concat(arguments.length <= 5 ? undefined : arguments[5], \"px \").concat(arguments.length <= 6 ? undefined : arguments[6], \"px \").concat(arguments.length <= 7 ? undefined : arguments[7], \"px rgba(0,0,0,\").concat(shadowKeyPenumbraOpacity, \")\"), \"\".concat(arguments.length <= 8 ? undefined : arguments[8], \"px \").concat(arguments.length <= 9 ? undefined : arguments[9], \"px \").concat(arguments.length <= 10 ? undefined : arguments[10], \"px \").concat(arguments.length <= 11 ? undefined : arguments[11], \"px rgba(0,0,0,\").concat(shadowAmbientShadowOpacity, \")\")].join(',');\n} // Values from https://github.com/material-components/material-components-web/blob/be8747f94574669cb5e7add1a7c54fa41a89cec7/packages/mdc-elevation/_variables.scss\n\n\nvar shadows = ['none', createShadow(0, 2, 1, -1, 0, 1, 1, 0, 0, 1, 3, 0), createShadow(0, 3, 1, -2, 0, 2, 2, 0, 0, 1, 5, 0), createShadow(0, 3, 3, -2, 0, 3, 4, 0, 0, 1, 8, 0), createShadow(0, 2, 4, -1, 0, 4, 5, 0, 0, 1, 10, 0), createShadow(0, 3, 5, -1, 0, 5, 8, 0, 0, 1, 14, 0), createShadow(0, 3, 5, -1, 0, 6, 10, 0, 0, 1, 18, 0), createShadow(0, 4, 5, -2, 0, 7, 10, 1, 0, 2, 16, 1), createShadow(0, 5, 5, -3, 0, 8, 10, 1, 0, 3, 14, 2), createShadow(0, 5, 6, -3, 0, 9, 12, 1, 0, 3, 16, 2), createShadow(0, 6, 6, -3, 0, 10, 14, 1, 0, 4, 18, 3), createShadow(0, 6, 7, -4, 0, 11, 15, 1, 0, 4, 20, 3), createShadow(0, 7, 8, -4, 0, 12, 17, 2, 0, 5, 22, 4), createShadow(0, 7, 8, -4, 0, 13, 19, 2, 0, 5, 24, 4), createShadow(0, 7, 9, -4, 0, 14, 21, 2, 0, 5, 26, 4), createShadow(0, 8, 9, -5, 0, 15, 22, 2, 0, 6, 28, 5), createShadow(0, 8, 10, -5, 0, 16, 24, 2, 0, 6, 30, 5), createShadow(0, 8, 11, -5, 0, 17, 26, 2, 0, 6, 32, 5), createShadow(0, 9, 11, -5, 0, 18, 28, 2, 0, 7, 34, 6), createShadow(0, 9, 12, -6, 0, 19, 29, 2, 0, 7, 36, 6), createShadow(0, 10, 13, -6, 0, 20, 31, 3, 0, 8, 38, 7), createShadow(0, 10, 13, -6, 0, 21, 33, 3, 0, 8, 40, 7), createShadow(0, 10, 14, -6, 0, 22, 35, 3, 0, 8, 42, 7), createShadow(0, 11, 14, -7, 0, 23, 36, 3, 0, 9, 44, 8), createShadow(0, 11, 15, -7, 0, 24, 38, 3, 0, 9, 46, 8)];\nexport default shadows;","var shape = {\n  borderRadius: 4\n};\nexport default shape;","import _toConsumableArray from \"@babel/runtime/helpers/esm/toConsumableArray\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _typeof from \"@babel/runtime/helpers/esm/typeof\";\nimport PropTypes from 'prop-types';\nimport merge from './merge'; // The breakpoint **start** at this value.\n// For instance with the first breakpoint xs: [xs, sm[.\n\nvar values = {\n  xs: 0,\n  sm: 600,\n  md: 960,\n  lg: 1280,\n  xl: 1920\n};\nvar defaultBreakpoints = {\n  // Sorted ASC by size. That's important.\n  // It can't be configured as it's used statically for propTypes.\n  keys: ['xs', 'sm', 'md', 'lg', 'xl'],\n  up: function up(key) {\n    return \"@media (min-width:\".concat(values[key], \"px)\");\n  }\n};\nexport function handleBreakpoints(props, propValue, styleFromPropValue) {\n  if (process.env.NODE_ENV !== 'production') {\n    if (!props.theme) {\n      console.error('Material-UI: You are calling a style function without a theme value.');\n    }\n  }\n\n  if (Array.isArray(propValue)) {\n    var themeBreakpoints = props.theme.breakpoints || defaultBreakpoints;\n    return propValue.reduce(function (acc, item, index) {\n      acc[themeBreakpoints.up(themeBreakpoints.keys[index])] = styleFromPropValue(propValue[index]);\n      return acc;\n    }, {});\n  }\n\n  if (_typeof(propValue) === 'object') {\n    var _themeBreakpoints = props.theme.breakpoints || defaultBreakpoints;\n\n    return Object.keys(propValue).reduce(function (acc, breakpoint) {\n      acc[_themeBreakpoints.up(breakpoint)] = styleFromPropValue(propValue[breakpoint]);\n      return acc;\n    }, {});\n  }\n\n  var output = styleFromPropValue(propValue);\n  return output;\n}\n\nfunction breakpoints(styleFunction) {\n  var newStyleFunction = function newStyleFunction(props) {\n    var base = styleFunction(props);\n    var themeBreakpoints = props.theme.breakpoints || defaultBreakpoints;\n    var extended = themeBreakpoints.keys.reduce(function (acc, key) {\n      if (props[key]) {\n        acc = acc || {};\n        acc[themeBreakpoints.up(key)] = styleFunction(_extends({\n          theme: props.theme\n        }, props[key]));\n      }\n\n      return acc;\n    }, null);\n    return merge(base, extended);\n  };\n\n  newStyleFunction.propTypes = process.env.NODE_ENV !== 'production' ? _extends({}, styleFunction.propTypes, {\n    xs: PropTypes.object,\n    sm: PropTypes.object,\n    md: PropTypes.object,\n    lg: PropTypes.object,\n    xl: PropTypes.object\n  }) : {};\n  newStyleFunction.filterProps = ['xs', 'sm', 'md', 'lg', 'xl'].concat(_toConsumableArray(styleFunction.filterProps));\n  return newStyleFunction;\n}\n\nexport default breakpoints;","import { deepmerge } from '@material-ui/utils';\n\nfunction merge(acc, item) {\n  if (!item) {\n    return acc;\n  }\n\n  return deepmerge(acc, item, {\n    clone: false // No need to clone deep, it's way faster.\n\n  });\n}\n\nexport default merge;","import _slicedToArray from \"@babel/runtime/helpers/esm/slicedToArray\";\nimport responsivePropType from './responsivePropType';\nimport { handleBreakpoints } from './breakpoints';\nimport merge from './merge';\nimport memoize from './memoize';\nvar properties = {\n  m: 'margin',\n  p: 'padding'\n};\nvar directions = {\n  t: 'Top',\n  r: 'Right',\n  b: 'Bottom',\n  l: 'Left',\n  x: ['Left', 'Right'],\n  y: ['Top', 'Bottom']\n};\nvar aliases = {\n  marginX: 'mx',\n  marginY: 'my',\n  paddingX: 'px',\n  paddingY: 'py'\n}; // memoize() impact:\n// From 300,000 ops/sec\n// To 350,000 ops/sec\n\nvar getCssProperties = memoize(function (prop) {\n  // It's not a shorthand notation.\n  if (prop.length > 2) {\n    if (aliases[prop]) {\n      prop = aliases[prop];\n    } else {\n      return [prop];\n    }\n  }\n\n  var _prop$split = prop.split(''),\n      _prop$split2 = _slicedToArray(_prop$split, 2),\n      a = _prop$split2[0],\n      b = _prop$split2[1];\n\n  var property = properties[a];\n  var direction = directions[b] || '';\n  return Array.isArray(direction) ? direction.map(function (dir) {\n    return property + dir;\n  }) : [property + direction];\n});\nvar spacingKeys = ['m', 'mt', 'mr', 'mb', 'ml', 'mx', 'my', 'p', 'pt', 'pr', 'pb', 'pl', 'px', 'py', 'margin', 'marginTop', 'marginRight', 'marginBottom', 'marginLeft', 'marginX', 'marginY', 'padding', 'paddingTop', 'paddingRight', 'paddingBottom', 'paddingLeft', 'paddingX', 'paddingY'];\nexport function createUnarySpacing(theme) {\n  var themeSpacing = theme.spacing || 8;\n\n  if (typeof themeSpacing === 'number') {\n    return function (abs) {\n      if (process.env.NODE_ENV !== 'production') {\n        if (typeof abs !== 'number') {\n          console.error(\"Material-UI: Expected spacing argument to be a number, got \".concat(abs, \".\"));\n        }\n      }\n\n      return themeSpacing * abs;\n    };\n  }\n\n  if (Array.isArray(themeSpacing)) {\n    return function (abs) {\n      if (process.env.NODE_ENV !== 'production') {\n        if (abs > themeSpacing.length - 1) {\n          console.error([\"Material-UI: The value provided (\".concat(abs, \") overflows.\"), \"The supported values are: \".concat(JSON.stringify(themeSpacing), \".\"), \"\".concat(abs, \" > \").concat(themeSpacing.length - 1, \", you need to add the missing values.\")].join('\\n'));\n        }\n      }\n\n      return themeSpacing[abs];\n    };\n  }\n\n  if (typeof themeSpacing === 'function') {\n    return themeSpacing;\n  }\n\n  if (process.env.NODE_ENV !== 'production') {\n    console.error([\"Material-UI: The `theme.spacing` value (\".concat(themeSpacing, \") is invalid.\"), 'It should be a number, an array or a function.'].join('\\n'));\n  }\n\n  return function () {\n    return undefined;\n  };\n}\n\nfunction getValue(transformer, propValue) {\n  if (typeof propValue === 'string' || propValue == null) {\n    return propValue;\n  }\n\n  var abs = Math.abs(propValue);\n  var transformed = transformer(abs);\n\n  if (propValue >= 0) {\n    return transformed;\n  }\n\n  if (typeof transformed === 'number') {\n    return -transformed;\n  }\n\n  return \"-\".concat(transformed);\n}\n\nfunction getStyleFromPropValue(cssProperties, transformer) {\n  return function (propValue) {\n    return cssProperties.reduce(function (acc, cssProperty) {\n      acc[cssProperty] = getValue(transformer, propValue);\n      return acc;\n    }, {});\n  };\n}\n\nfunction spacing(props) {\n  var theme = props.theme;\n  var transformer = createUnarySpacing(theme);\n  return Object.keys(props).map(function (prop) {\n    // Using a hash computation over an array iteration could be faster, but with only 28 items,\n    // it's doesn't worth the bundle size.\n    if (spacingKeys.indexOf(prop) === -1) {\n      return null;\n    }\n\n    var cssProperties = getCssProperties(prop);\n    var styleFromPropValue = getStyleFromPropValue(cssProperties, transformer);\n    var propValue = props[prop];\n    return handleBreakpoints(props, propValue, styleFromPropValue);\n  }).reduce(merge, {});\n}\n\nspacing.propTypes = process.env.NODE_ENV !== 'production' ? spacingKeys.reduce(function (obj, key) {\n  obj[key] = responsivePropType;\n  return obj;\n}, {}) : {};\nspacing.filterProps = spacingKeys;\nexport default spacing;","export default function memoize(fn) {\n  var cache = {};\n  return function (arg) {\n    if (cache[arg] === undefined) {\n      cache[arg] = fn(arg);\n    }\n\n    return cache[arg];\n  };\n}","import _objectWithoutProperties from \"@babel/runtime/helpers/esm/objectWithoutProperties\";\n// Follow https://material.google.com/motion/duration-easing.html#duration-easing-natural-easing-curves\n// to learn the context in which each easing should be used.\nexport var easing = {\n  // This is the most common easing curve.\n  easeInOut: 'cubic-bezier(0.4, 0, 0.2, 1)',\n  // Objects enter the screen at full velocity from off-screen and\n  // slowly decelerate to a resting point.\n  easeOut: 'cubic-bezier(0.0, 0, 0.2, 1)',\n  // Objects leave the screen at full velocity. They do not decelerate when off-screen.\n  easeIn: 'cubic-bezier(0.4, 0, 1, 1)',\n  // The sharp curve is used by objects that may return to the screen at any time.\n  sharp: 'cubic-bezier(0.4, 0, 0.6, 1)'\n}; // Follow https://material.io/guidelines/motion/duration-easing.html#duration-easing-common-durations\n// to learn when use what timing\n\nexport var duration = {\n  shortest: 150,\n  shorter: 200,\n  short: 250,\n  // most basic recommended timing\n  standard: 300,\n  // this is to be used in complex animations\n  complex: 375,\n  // recommended when something is entering screen\n  enteringScreen: 225,\n  // recommended when something is leaving screen\n  leavingScreen: 195\n};\n\nfunction formatMs(milliseconds) {\n  return \"\".concat(Math.round(milliseconds), \"ms\");\n}\n/**\n * @param {string|Array} props\n * @param {object} param\n * @param {string} param.prop\n * @param {number} param.duration\n * @param {string} param.easing\n * @param {number} param.delay\n */\n\n\nexport default {\n  easing: easing,\n  duration: duration,\n  create: function create() {\n    var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ['all'];\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    var _options$duration = options.duration,\n        durationOption = _options$duration === void 0 ? duration.standard : _options$duration,\n        _options$easing = options.easing,\n        easingOption = _options$easing === void 0 ? easing.easeInOut : _options$easing,\n        _options$delay = options.delay,\n        delay = _options$delay === void 0 ? 0 : _options$delay,\n        other = _objectWithoutProperties(options, [\"duration\", \"easing\", \"delay\"]);\n\n    if (process.env.NODE_ENV !== 'production') {\n      var isString = function isString(value) {\n        return typeof value === 'string';\n      };\n\n      var isNumber = function isNumber(value) {\n        return !isNaN(parseFloat(value));\n      };\n\n      if (!isString(props) && !Array.isArray(props)) {\n        console.error('Material-UI: Argument \"props\" must be a string or Array.');\n      }\n\n      if (!isNumber(durationOption) && !isString(durationOption)) {\n        console.error(\"Material-UI: Argument \\\"duration\\\" must be a number or a string but found \".concat(durationOption, \".\"));\n      }\n\n      if (!isString(easingOption)) {\n        console.error('Material-UI: Argument \"easing\" must be a string.');\n      }\n\n      if (!isNumber(delay) && !isString(delay)) {\n        console.error('Material-UI: Argument \"delay\" must be a number or a string.');\n      }\n\n      if (Object.keys(other).length !== 0) {\n        console.error(\"Material-UI: Unrecognized argument(s) [\".concat(Object.keys(other).join(','), \"].\"));\n      }\n    }\n\n    return (Array.isArray(props) ? props : [props]).map(function (animatedProp) {\n      return \"\".concat(animatedProp, \" \").concat(typeof durationOption === 'string' ? durationOption : formatMs(durationOption), \" \").concat(easingOption, \" \").concat(typeof delay === 'string' ? delay : formatMs(delay));\n    }).join(',');\n  },\n  getAutoHeightDuration: function getAutoHeightDuration(height) {\n    if (!height) {\n      return 0;\n    }\n\n    var constant = height / 36; // https://www.wolframalpha.com/input/?i=(4+%2B+15+*+(x+%2F+36+)+**+0.25+%2B+(x+%2F+36)+%2F+5)+*+10\n\n    return Math.round((4 + 15 * Math.pow(constant, 0.25) + constant / 5) * 10);\n  }\n};","// We need to centralize the zIndex definitions as they work\n// like global values in the browser.\nvar zIndex = {\n  mobileStepper: 1000,\n  speedDial: 1050,\n  appBar: 1100,\n  drawer: 1200,\n  modal: 1300,\n  snackbar: 1400,\n  tooltip: 1500\n};\nexport default zIndex;","import createTheme from './createTheme';\nvar defaultTheme = createTheme();\nexport default defaultTheme;","import _defineProperty from \"@babel/runtime/helpers/esm/defineProperty\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/esm/objectWithoutProperties\";\nimport { deepmerge } from '@material-ui/utils';\nimport createBreakpoints from './createBreakpoints';\nimport createMixins from './createMixins';\nimport createPalette from './createPalette';\nimport createTypography from './createTypography';\nimport shadows from './shadows';\nimport shape from './shape';\nimport createSpacing from './createSpacing';\nimport transitions from './transitions';\nimport zIndex from './zIndex';\n\nfunction createTheme() {\n  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n  var _options$breakpoints = options.breakpoints,\n      breakpointsInput = _options$breakpoints === void 0 ? {} : _options$breakpoints,\n      _options$mixins = options.mixins,\n      mixinsInput = _options$mixins === void 0 ? {} : _options$mixins,\n      _options$palette = options.palette,\n      paletteInput = _options$palette === void 0 ? {} : _options$palette,\n      spacingInput = options.spacing,\n      _options$typography = options.typography,\n      typographyInput = _options$typography === void 0 ? {} : _options$typography,\n      other = _objectWithoutProperties(options, [\"breakpoints\", \"mixins\", \"palette\", \"spacing\", \"typography\"]);\n\n  var palette = createPalette(paletteInput);\n  var breakpoints = createBreakpoints(breakpointsInput);\n  var spacing = createSpacing(spacingInput);\n  var muiTheme = deepmerge({\n    breakpoints: breakpoints,\n    direction: 'ltr',\n    mixins: createMixins(breakpoints, spacing, mixinsInput),\n    overrides: {},\n    // Inject custom styles\n    palette: palette,\n    props: {},\n    // Provide default props\n    shadows: shadows,\n    typography: createTypography(palette, typographyInput),\n    spacing: spacing,\n    shape: shape,\n    transitions: transitions,\n    zIndex: zIndex\n  }, other);\n\n  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    args[_key - 1] = arguments[_key];\n  }\n\n  muiTheme = args.reduce(function (acc, argument) {\n    return deepmerge(acc, argument);\n  }, muiTheme);\n\n  if (process.env.NODE_ENV !== 'production') {\n    var pseudoClasses = ['checked', 'disabled', 'error', 'focused', 'focusVisible', 'required', 'expanded', 'selected'];\n\n    var traverse = function traverse(node, parentKey) {\n      var depth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;\n      var key; // eslint-disable-next-line guard-for-in, no-restricted-syntax\n\n      for (key in node) {\n        var child = node[key];\n\n        if (depth === 1) {\n          if (key.indexOf('Mui') === 0 && child) {\n            traverse(child, key, depth + 1);\n          }\n        } else if (pseudoClasses.indexOf(key) !== -1 && Object.keys(child).length > 0) {\n          if (process.env.NODE_ENV !== 'production') {\n            console.error([\"Material-UI: The `\".concat(parentKey, \"` component increases \") + \"the CSS specificity of the `\".concat(key, \"` internal state.\"), 'You can not override it like this: ', JSON.stringify(node, null, 2), '', 'Instead, you need to use the $ruleName syntax:', JSON.stringify({\n              root: _defineProperty({}, \"&$\".concat(key), child)\n            }, null, 2), '', 'https://material-ui.com/r/pseudo-classes-guide'].join('\\n'));\n          } // Remove the style to prevent global conflicts.\n\n\n          node[key] = {};\n        }\n      }\n    };\n\n    traverse(muiTheme.overrides);\n  }\n\n  return muiTheme;\n}\n\nvar warnedOnce = false;\nexport function createMuiTheme() {\n  if (process.env.NODE_ENV !== 'production') {\n    if (!warnedOnce) {\n      warnedOnce = true;\n      console.error(['Material-UI: the createMuiTheme function was renamed to createTheme.', '', \"You should use `import { createTheme } from '@material-ui/core/styles'`\"].join('\\n'));\n    }\n  }\n\n  return createTheme.apply(void 0, arguments);\n}\nexport default createTheme;","import { createUnarySpacing } from '@material-ui/system';\nvar warnOnce;\nexport default function createSpacing() {\n  var spacingInput = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 8;\n\n  // Already transformed.\n  if (spacingInput.mui) {\n    return spacingInput;\n  } // Material Design layouts are visually balanced. Most measurements align to an 8dp grid applied, which aligns both spacing and the overall layout.\n  // Smaller components, such as icons and type, can align to a 4dp grid.\n  // https://material.io/design/layout/understanding-layout.html#usage\n\n\n  var transform = createUnarySpacing({\n    spacing: spacingInput\n  });\n\n  var spacing = function spacing() {\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    if (process.env.NODE_ENV !== 'production') {\n      if (!(args.length <= 4)) {\n        console.error(\"Material-UI: Too many arguments provided, expected between 0 and 4, got \".concat(args.length));\n      }\n    }\n\n    if (args.length === 0) {\n      return transform(1);\n    }\n\n    if (args.length === 1) {\n      return transform(args[0]);\n    }\n\n    return args.map(function (argument) {\n      if (typeof argument === 'string') {\n        return argument;\n      }\n\n      var output = transform(argument);\n      return typeof output === 'number' ? \"\".concat(output, \"px\") : output;\n    }).join(' ');\n  }; // Backward compatibility, to remove in v5.\n\n\n  Object.defineProperty(spacing, 'unit', {\n    get: function get() {\n      if (process.env.NODE_ENV !== 'production') {\n        if (!warnOnce || process.env.NODE_ENV === 'test') {\n          console.error(['Material-UI: theme.spacing.unit usage has been deprecated.', 'It will be removed in v5.', 'You can replace `theme.spacing.unit * y` with `theme.spacing(y)`.', '', 'You can use the `https://github.com/mui-org/material-ui/tree/master/packages/material-ui-codemod/README.md#theme-spacing-api` migration helper to make the process smoother.'].join('\\n'));\n        }\n\n        warnOnce = true;\n      }\n\n      return spacingInput;\n    }\n  });\n  spacing.mui = true;\n  return spacing;\n}","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport { withStyles as withStylesWithoutDefault } from '@material-ui/styles';\nimport defaultTheme from './defaultTheme';\n\nfunction withStyles(stylesOrCreator, options) {\n  return withStylesWithoutDefault(stylesOrCreator, _extends({\n    defaultTheme: defaultTheme\n  }, options));\n}\n\nexport default withStyles;","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/esm/objectWithoutProperties\";\nimport React from 'react';\nimport PropTypes from 'prop-types';\nimport hoistNonReactStatics from 'hoist-non-react-statics';\nimport { chainPropTypes, getDisplayName } from '@material-ui/utils';\nimport makeStyles from '../makeStyles';\nimport getThemeProps from '../getThemeProps';\nimport useTheme from '../useTheme'; // Link a style sheet with a component.\n// It does not modify the component passed to it;\n// instead, it returns a new component, with a `classes` property.\n\nvar withStyles = function withStyles(stylesOrCreator) {\n  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  return function (Component) {\n    var defaultTheme = options.defaultTheme,\n        _options$withTheme = options.withTheme,\n        withTheme = _options$withTheme === void 0 ? false : _options$withTheme,\n        name = options.name,\n        stylesOptions = _objectWithoutProperties(options, [\"defaultTheme\", \"withTheme\", \"name\"]);\n\n    if (process.env.NODE_ENV !== 'production') {\n      if (Component === undefined) {\n        throw new Error(['You are calling withStyles(styles)(Component) with an undefined component.', 'You may have forgotten to import it.'].join('\\n'));\n      }\n    }\n\n    var classNamePrefix = name;\n\n    if (process.env.NODE_ENV !== 'production') {\n      if (!name) {\n        // Provide a better DX outside production.\n        var displayName = getDisplayName(Component);\n\n        if (displayName !== undefined) {\n          classNamePrefix = displayName;\n        }\n      }\n    }\n\n    var useStyles = makeStyles(stylesOrCreator, _extends({\n      defaultTheme: defaultTheme,\n      Component: Component,\n      name: name || Component.displayName,\n      classNamePrefix: classNamePrefix\n    }, stylesOptions));\n    var WithStyles = /*#__PURE__*/React.forwardRef(function WithStyles(props, ref) {\n      var classesProp = props.classes,\n          innerRef = props.innerRef,\n          other = _objectWithoutProperties(props, [\"classes\", \"innerRef\"]); // The wrapper receives only user supplied props, which could be a subset of\n      // the actual props Component might receive due to merging with defaultProps.\n      // So copying it here would give us the same result in the wrapper as well.\n\n\n      var classes = useStyles(_extends({}, Component.defaultProps, props));\n      var theme;\n      var more = other;\n\n      if (typeof name === 'string' || withTheme) {\n        // name and withTheme are invariant in the outer scope\n        // eslint-disable-next-line react-hooks/rules-of-hooks\n        theme = useTheme() || defaultTheme;\n\n        if (name) {\n          more = getThemeProps({\n            theme: theme,\n            name: name,\n            props: other\n          });\n        } // Provide the theme to the wrapped component.\n        // So we don't have to use the `withTheme()` Higher-order Component.\n\n\n        if (withTheme && !more.theme) {\n          more.theme = theme;\n        }\n      }\n\n      return /*#__PURE__*/React.createElement(Component, _extends({\n        ref: innerRef || ref,\n        classes: classes\n      }, more));\n    });\n    process.env.NODE_ENV !== \"production\" ? WithStyles.propTypes = {\n      /**\n       * Override or extend the styles applied to the component.\n       */\n      classes: PropTypes.object,\n\n      /**\n       * Use that prop to pass a ref to the decorated component.\n       * @deprecated\n       */\n      innerRef: chainPropTypes(PropTypes.oneOfType([PropTypes.func, PropTypes.object]), function (props) {\n        if (props.innerRef == null) {\n          return null;\n        }\n\n        return null; // return new Error(\n        //   'Material-UI: The `innerRef` prop is deprecated and will be removed in v5. ' +\n        //     'Refs are now automatically forwarded to the inner component.',\n        // );\n      })\n    } : void 0;\n\n    if (process.env.NODE_ENV !== 'production') {\n      WithStyles.displayName = \"WithStyles(\".concat(getDisplayName(Component), \")\");\n    }\n\n    hoistNonReactStatics(WithStyles, Component);\n\n    if (process.env.NODE_ENV !== 'production') {\n      // Exposed for test purposes.\n      WithStyles.Naked = Component;\n      WithStyles.options = options;\n      WithStyles.useStyles = useStyles;\n    }\n\n    return WithStyles;\n  };\n};\n\nexport default withStyles;","/* eslint-disable no-restricted-syntax */\nexport default function getThemeProps(params) {\n  var theme = params.theme,\n      name = params.name,\n      props = params.props;\n\n  if (!theme || !theme.props || !theme.props[name]) {\n    return props;\n  } // Resolve default props, code borrow from React source.\n  // https://github.com/facebook/react/blob/15a8f031838a553e41c0b66eb1bcf1da8448104d/packages/react/src/ReactElement.js#L221\n\n\n  var defaultProps = theme.props[name];\n  var propName;\n\n  for (propName in defaultProps) {\n    if (props[propName] === undefined) {\n      props[propName] = defaultProps[propName];\n    }\n  }\n\n  return props;\n}","import { formatMuiErrorMessage as _formatMuiErrorMessage } from \"@material-ui/utils\";\n// It should to be noted that this function isn't equivalent to `text-transform: capitalize`.\n//\n// A strict capitalization should uppercase the first letter of each word a the sentence.\n// We only handle the first word.\nexport default function capitalize(string) {\n  if (typeof string !== 'string') {\n    throw new Error(process.env.NODE_ENV !== \"production\" ? \"Material-UI: capitalize(string) expects a string argument.\" : _formatMuiErrorMessage(7));\n  }\n\n  return string.charAt(0).toUpperCase() + string.slice(1);\n}","import * as React from 'react';\n/**\n * @ignore - internal component.\n */\n\nvar FormControlContext = React.createContext();\n\nif (process.env.NODE_ENV !== 'production') {\n  FormControlContext.displayName = 'FormControlContext';\n}\n\nexport function useFormControl() {\n  return React.useContext(FormControlContext);\n}\nexport default FormControlContext;","// TODO v5: consider to make it private\nexport default function setRef(ref, value) {\n  if (typeof ref === 'function') {\n    ref(value);\n  } else if (ref) {\n    ref.current = value;\n  }\n}","import * as React from 'react';\nimport setRef from './setRef';\nexport default function useForkRef(refA, refB) {\n  /**\n   * This will create a new function if the ref props change and are defined.\n   * This means react will call the old forkRef with `null` and the new forkRef\n   * with the ref. Cleanup naturally emerges from this behavior\n   */\n  return React.useMemo(function () {\n    if (refA == null && refB == null) {\n      return null;\n    }\n\n    return function (refValue) {\n      setRef(refA, refValue);\n      setRef(refB, refValue);\n    };\n  }, [refA, refB]);\n}","import * as React from 'react';\nvar useEnhancedEffect = typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect;\n/**\n * https://github.com/facebook/react/issues/14099#issuecomment-440013892\n *\n * @param {function} fn\n */\n\nexport default function useEventCallback(fn) {\n  var ref = React.useRef(fn);\n  useEnhancedEffect(function () {\n    ref.current = fn;\n  });\n  return React.useCallback(function () {\n    return (0, ref.current).apply(void 0, arguments);\n  }, []);\n}","// based on https://github.com/WICG/focus-visible/blob/v4.1.5/src/focus-visible.js\nimport * as React from 'react';\nimport * as ReactDOM from 'react-dom';\nvar hadKeyboardEvent = true;\nvar hadFocusVisibleRecently = false;\nvar hadFocusVisibleRecentlyTimeout = null;\nvar inputTypesWhitelist = {\n  text: true,\n  search: true,\n  url: true,\n  tel: true,\n  email: true,\n  password: true,\n  number: true,\n  date: true,\n  month: true,\n  week: true,\n  time: true,\n  datetime: true,\n  'datetime-local': true\n};\n/**\n * Computes whether the given element should automatically trigger the\n * `focus-visible` class being added, i.e. whether it should always match\n * `:focus-visible` when focused.\n * @param {Element} node\n * @return {boolean}\n */\n\nfunction focusTriggersKeyboardModality(node) {\n  var type = node.type,\n      tagName = node.tagName;\n\n  if (tagName === 'INPUT' && inputTypesWhitelist[type] && !node.readOnly) {\n    return true;\n  }\n\n  if (tagName === 'TEXTAREA' && !node.readOnly) {\n    return true;\n  }\n\n  if (node.isContentEditable) {\n    return true;\n  }\n\n  return false;\n}\n/**\n * Keep track of our keyboard modality state with `hadKeyboardEvent`.\n * If the most recent user interaction was via the keyboard;\n * and the key press did not include a meta, alt/option, or control key;\n * then the modality is keyboard. Otherwise, the modality is not keyboard.\n * @param {KeyboardEvent} event\n */\n\n\nfunction handleKeyDown(event) {\n  if (event.metaKey || event.altKey || event.ctrlKey) {\n    return;\n  }\n\n  hadKeyboardEvent = true;\n}\n/**\n * If at any point a user clicks with a pointing device, ensure that we change\n * the modality away from keyboard.\n * This avoids the situation where a user presses a key on an already focused\n * element, and then clicks on a different element, focusing it with a\n * pointing device, while we still think we're in keyboard modality.\n */\n\n\nfunction handlePointerDown() {\n  hadKeyboardEvent = false;\n}\n\nfunction handleVisibilityChange() {\n  if (this.visibilityState === 'hidden') {\n    // If the tab becomes active again, the browser will handle calling focus\n    // on the element (Safari actually calls it twice).\n    // If this tab change caused a blur on an element with focus-visible,\n    // re-apply the class when the user switches back to the tab.\n    if (hadFocusVisibleRecently) {\n      hadKeyboardEvent = true;\n    }\n  }\n}\n\nfunction prepare(doc) {\n  doc.addEventListener('keydown', handleKeyDown, true);\n  doc.addEventListener('mousedown', handlePointerDown, true);\n  doc.addEventListener('pointerdown', handlePointerDown, true);\n  doc.addEventListener('touchstart', handlePointerDown, true);\n  doc.addEventListener('visibilitychange', handleVisibilityChange, true);\n}\n\nexport function teardown(doc) {\n  doc.removeEventListener('keydown', handleKeyDown, true);\n  doc.removeEventListener('mousedown', handlePointerDown, true);\n  doc.removeEventListener('pointerdown', handlePointerDown, true);\n  doc.removeEventListener('touchstart', handlePointerDown, true);\n  doc.removeEventListener('visibilitychange', handleVisibilityChange, true);\n}\n\nfunction isFocusVisible(event) {\n  var target = event.target;\n\n  try {\n    return target.matches(':focus-visible');\n  } catch (error) {} // browsers not implementing :focus-visible will throw a SyntaxError\n  // we use our own heuristic for those browsers\n  // rethrow might be better if it's not the expected error but do we really\n  // want to crash if focus-visible malfunctioned?\n  // no need for validFocusTarget check. the user does that by attaching it to\n  // focusable events only\n\n\n  return hadKeyboardEvent || focusTriggersKeyboardModality(target);\n}\n/**\n * Should be called if a blur event is fired on a focus-visible element\n */\n\n\nfunction handleBlurVisible() {\n  // To detect a tab/window switch, we look for a blur event followed\n  // rapidly by a visibility change.\n  // If we don't see a visibility change within 100ms, it's probably a\n  // regular focus change.\n  hadFocusVisibleRecently = true;\n  window.clearTimeout(hadFocusVisibleRecentlyTimeout);\n  hadFocusVisibleRecentlyTimeout = window.setTimeout(function () {\n    hadFocusVisibleRecently = false;\n  }, 100);\n}\n\nexport default function useIsFocusVisible() {\n  var ref = React.useCallback(function (instance) {\n    var node = ReactDOM.findDOMNode(instance);\n\n    if (node != null) {\n      prepare(node.ownerDocument);\n    }\n  }, []);\n\n  if (process.env.NODE_ENV !== 'production') {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useDebugValue(isFocusVisible);\n  }\n\n  return {\n    isFocusVisible: isFocusVisible,\n    onBlurVisible: handleBlurVisible,\n    ref: ref\n  };\n}","import * as React from 'react';\nimport PropTypes from 'prop-types';\nimport clsx from 'clsx';\nimport useEventCallback from '../utils/useEventCallback';\nvar useEnhancedEffect = typeof window === 'undefined' ? React.useEffect : React.useLayoutEffect;\n/**\n * @ignore - internal component.\n */\n\nfunction Ripple(props) {\n  var classes = props.classes,\n      _props$pulsate = props.pulsate,\n      pulsate = _props$pulsate === void 0 ? false : _props$pulsate,\n      rippleX = props.rippleX,\n      rippleY = props.rippleY,\n      rippleSize = props.rippleSize,\n      inProp = props.in,\n      _props$onExited = props.onExited,\n      onExited = _props$onExited === void 0 ? function () {} : _props$onExited,\n      timeout = props.timeout;\n\n  var _React$useState = React.useState(false),\n      leaving = _React$useState[0],\n      setLeaving = _React$useState[1];\n\n  var rippleClassName = clsx(classes.ripple, classes.rippleVisible, pulsate && classes.ripplePulsate);\n  var rippleStyles = {\n    width: rippleSize,\n    height: rippleSize,\n    top: -(rippleSize / 2) + rippleY,\n    left: -(rippleSize / 2) + rippleX\n  };\n  var childClassName = clsx(classes.child, leaving && classes.childLeaving, pulsate && classes.childPulsate);\n  var handleExited = useEventCallback(onExited); // Ripple is used for user feedback (e.g. click or press) so we want to apply styles with the highest priority\n\n  useEnhancedEffect(function () {\n    if (!inProp) {\n      // react-transition-group#onExit\n      setLeaving(true); // react-transition-group#onExited\n\n      var timeoutId = setTimeout(handleExited, timeout);\n      return function () {\n        clearTimeout(timeoutId);\n      };\n    }\n\n    return undefined;\n  }, [handleExited, inProp, timeout]);\n  return /*#__PURE__*/React.createElement(\"span\", {\n    className: rippleClassName,\n    style: rippleStyles\n  }, /*#__PURE__*/React.createElement(\"span\", {\n    className: childClassName\n  }));\n}\n\nprocess.env.NODE_ENV !== \"production\" ? Ripple.propTypes = {\n  /**\n   * Override or extend the styles applied to the component.\n   * See [CSS API](#css) below for more details.\n   */\n  classes: PropTypes.object.isRequired,\n\n  /**\n   * @ignore - injected from TransitionGroup\n   */\n  in: PropTypes.bool,\n\n  /**\n   * @ignore - injected from TransitionGroup\n   */\n  onExited: PropTypes.func,\n\n  /**\n   * If `true`, the ripple pulsates, typically indicating the keyboard focus state of an element.\n   */\n  pulsate: PropTypes.bool,\n\n  /**\n   * Diameter of the ripple.\n   */\n  rippleSize: PropTypes.number,\n\n  /**\n   * Horizontal position of the ripple center.\n   */\n  rippleX: PropTypes.number,\n\n  /**\n   * Vertical position of the ripple center.\n   */\n  rippleY: PropTypes.number,\n\n  /**\n   * exit delay\n   */\n  timeout: PropTypes.number.isRequired\n} : void 0;\nexport default Ripple;","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _toConsumableArray from \"@babel/runtime/helpers/esm/toConsumableArray\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/esm/objectWithoutProperties\";\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { TransitionGroup } from 'react-transition-group';\nimport clsx from 'clsx';\nimport withStyles from '../styles/withStyles';\nimport Ripple from './Ripple';\nvar DURATION = 550;\nexport var DELAY_RIPPLE = 80;\nexport var styles = function styles(theme) {\n  return {\n    /* Styles applied to the root element. */\n    root: {\n      overflow: 'hidden',\n      pointerEvents: 'none',\n      position: 'absolute',\n      zIndex: 0,\n      top: 0,\n      right: 0,\n      bottom: 0,\n      left: 0,\n      borderRadius: 'inherit'\n    },\n\n    /* Styles applied to the internal `Ripple` components `ripple` class. */\n    ripple: {\n      opacity: 0,\n      position: 'absolute'\n    },\n\n    /* Styles applied to the internal `Ripple` components `rippleVisible` class. */\n    rippleVisible: {\n      opacity: 0.3,\n      transform: 'scale(1)',\n      animation: \"$enter \".concat(DURATION, \"ms \").concat(theme.transitions.easing.easeInOut)\n    },\n\n    /* Styles applied to the internal `Ripple` components `ripplePulsate` class. */\n    ripplePulsate: {\n      animationDuration: \"\".concat(theme.transitions.duration.shorter, \"ms\")\n    },\n\n    /* Styles applied to the internal `Ripple` components `child` class. */\n    child: {\n      opacity: 1,\n      display: 'block',\n      width: '100%',\n      height: '100%',\n      borderRadius: '50%',\n      backgroundColor: 'currentColor'\n    },\n\n    /* Styles applied to the internal `Ripple` components `childLeaving` class. */\n    childLeaving: {\n      opacity: 0,\n      animation: \"$exit \".concat(DURATION, \"ms \").concat(theme.transitions.easing.easeInOut)\n    },\n\n    /* Styles applied to the internal `Ripple` components `childPulsate` class. */\n    childPulsate: {\n      position: 'absolute',\n      left: 0,\n      top: 0,\n      animation: \"$pulsate 2500ms \".concat(theme.transitions.easing.easeInOut, \" 200ms infinite\")\n    },\n    '@keyframes enter': {\n      '0%': {\n        transform: 'scale(0)',\n        opacity: 0.1\n      },\n      '100%': {\n        transform: 'scale(1)',\n        opacity: 0.3\n      }\n    },\n    '@keyframes exit': {\n      '0%': {\n        opacity: 1\n      },\n      '100%': {\n        opacity: 0\n      }\n    },\n    '@keyframes pulsate': {\n      '0%': {\n        transform: 'scale(1)'\n      },\n      '50%': {\n        transform: 'scale(0.92)'\n      },\n      '100%': {\n        transform: 'scale(1)'\n      }\n    }\n  };\n};\n/**\n * @ignore - internal component.\n *\n * TODO v5: Make private\n */\n\nvar TouchRipple = /*#__PURE__*/React.forwardRef(function TouchRipple(props, ref) {\n  var _props$center = props.center,\n      centerProp = _props$center === void 0 ? false : _props$center,\n      classes = props.classes,\n      className = props.className,\n      other = _objectWithoutProperties(props, [\"center\", \"classes\", \"className\"]);\n\n  var _React$useState = React.useState([]),\n      ripples = _React$useState[0],\n      setRipples = _React$useState[1];\n\n  var nextKey = React.useRef(0);\n  var rippleCallback = React.useRef(null);\n  React.useEffect(function () {\n    if (rippleCallback.current) {\n      rippleCallback.current();\n      rippleCallback.current = null;\n    }\n  }, [ripples]); // Used to filter out mouse emulated events on mobile.\n\n  var ignoringMouseDown = React.useRef(false); // We use a timer in order to only show the ripples for touch \"click\" like events.\n  // We don't want to display the ripple for touch scroll events.\n\n  var startTimer = React.useRef(null); // This is the hook called once the previous timeout is ready.\n\n  var startTimerCommit = React.useRef(null);\n  var container = React.useRef(null);\n  React.useEffect(function () {\n    return function () {\n      clearTimeout(startTimer.current);\n    };\n  }, []);\n  var startCommit = React.useCallback(function (params) {\n    var pulsate = params.pulsate,\n        rippleX = params.rippleX,\n        rippleY = params.rippleY,\n        rippleSize = params.rippleSize,\n        cb = params.cb;\n    setRipples(function (oldRipples) {\n      return [].concat(_toConsumableArray(oldRipples), [/*#__PURE__*/React.createElement(Ripple, {\n        key: nextKey.current,\n        classes: classes,\n        timeout: DURATION,\n        pulsate: pulsate,\n        rippleX: rippleX,\n        rippleY: rippleY,\n        rippleSize: rippleSize\n      })]);\n    });\n    nextKey.current += 1;\n    rippleCallback.current = cb;\n  }, [classes]);\n  var start = React.useCallback(function () {\n    var event = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var cb = arguments.length > 2 ? arguments[2] : undefined;\n    var _options$pulsate = options.pulsate,\n        pulsate = _options$pulsate === void 0 ? false : _options$pulsate,\n        _options$center = options.center,\n        center = _options$center === void 0 ? centerProp || options.pulsate : _options$center,\n        _options$fakeElement = options.fakeElement,\n        fakeElement = _options$fakeElement === void 0 ? false : _options$fakeElement;\n\n    if (event.type === 'mousedown' && ignoringMouseDown.current) {\n      ignoringMouseDown.current = false;\n      return;\n    }\n\n    if (event.type === 'touchstart') {\n      ignoringMouseDown.current = true;\n    }\n\n    var element = fakeElement ? null : container.current;\n    var rect = element ? element.getBoundingClientRect() : {\n      width: 0,\n      height: 0,\n      left: 0,\n      top: 0\n    }; // Get the size of the ripple\n\n    var rippleX;\n    var rippleY;\n    var rippleSize;\n\n    if (center || event.clientX === 0 && event.clientY === 0 || !event.clientX && !event.touches) {\n      rippleX = Math.round(rect.width / 2);\n      rippleY = Math.round(rect.height / 2);\n    } else {\n      var _ref = event.touches ? event.touches[0] : event,\n          clientX = _ref.clientX,\n          clientY = _ref.clientY;\n\n      rippleX = Math.round(clientX - rect.left);\n      rippleY = Math.round(clientY - rect.top);\n    }\n\n    if (center) {\n      rippleSize = Math.sqrt((2 * Math.pow(rect.width, 2) + Math.pow(rect.height, 2)) / 3); // For some reason the animation is broken on Mobile Chrome if the size if even.\n\n      if (rippleSize % 2 === 0) {\n        rippleSize += 1;\n      }\n    } else {\n      var sizeX = Math.max(Math.abs((element ? element.clientWidth : 0) - rippleX), rippleX) * 2 + 2;\n      var sizeY = Math.max(Math.abs((element ? element.clientHeight : 0) - rippleY), rippleY) * 2 + 2;\n      rippleSize = Math.sqrt(Math.pow(sizeX, 2) + Math.pow(sizeY, 2));\n    } // Touche devices\n\n\n    if (event.touches) {\n      // check that this isn't another touchstart due to multitouch\n      // otherwise we will only clear a single timer when unmounting while two\n      // are running\n      if (startTimerCommit.current === null) {\n        // Prepare the ripple effect.\n        startTimerCommit.current = function () {\n          startCommit({\n            pulsate: pulsate,\n            rippleX: rippleX,\n            rippleY: rippleY,\n            rippleSize: rippleSize,\n            cb: cb\n          });\n        }; // Delay the execution of the ripple effect.\n\n\n        startTimer.current = setTimeout(function () {\n          if (startTimerCommit.current) {\n            startTimerCommit.current();\n            startTimerCommit.current = null;\n          }\n        }, DELAY_RIPPLE); // We have to make a tradeoff with this value.\n      }\n    } else {\n      startCommit({\n        pulsate: pulsate,\n        rippleX: rippleX,\n        rippleY: rippleY,\n        rippleSize: rippleSize,\n        cb: cb\n      });\n    }\n  }, [centerProp, startCommit]);\n  var pulsate = React.useCallback(function () {\n    start({}, {\n      pulsate: true\n    });\n  }, [start]);\n  var stop = React.useCallback(function (event, cb) {\n    clearTimeout(startTimer.current); // The touch interaction occurs too quickly.\n    // We still want to show ripple effect.\n\n    if (event.type === 'touchend' && startTimerCommit.current) {\n      event.persist();\n      startTimerCommit.current();\n      startTimerCommit.current = null;\n      startTimer.current = setTimeout(function () {\n        stop(event, cb);\n      });\n      return;\n    }\n\n    startTimerCommit.current = null;\n    setRipples(function (oldRipples) {\n      if (oldRipples.length > 0) {\n        return oldRipples.slice(1);\n      }\n\n      return oldRipples;\n    });\n    rippleCallback.current = cb;\n  }, []);\n  React.useImperativeHandle(ref, function () {\n    return {\n      pulsate: pulsate,\n      start: start,\n      stop: stop\n    };\n  }, [pulsate, start, stop]);\n  return /*#__PURE__*/React.createElement(\"span\", _extends({\n    className: clsx(classes.root, className),\n    ref: container\n  }, other), /*#__PURE__*/React.createElement(TransitionGroup, {\n    component: null,\n    exit: true\n  }, ripples));\n});\nprocess.env.NODE_ENV !== \"production\" ? TouchRipple.propTypes = {\n  /**\n   * If `true`, the ripple starts at the center of the component\n   * rather than at the point of interaction.\n   */\n  center: PropTypes.bool,\n\n  /**\n   * Override or extend the styles applied to the component.\n   * See [CSS API](#css) below for more details.\n   */\n  classes: PropTypes.object.isRequired,\n\n  /**\n   * @ignore\n   */\n  className: PropTypes.string\n} : void 0;\nexport default withStyles(styles, {\n  flip: false,\n  name: 'MuiTouchRipple'\n})( /*#__PURE__*/React.memo(TouchRipple));","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/esm/objectWithoutProperties\";\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport * as ReactDOM from 'react-dom';\nimport clsx from 'clsx';\nimport { elementTypeAcceptingRef, refType } from '@material-ui/utils';\nimport useForkRef from '../utils/useForkRef';\nimport useEventCallback from '../utils/useEventCallback';\nimport deprecatedPropType from '../utils/deprecatedPropType';\nimport withStyles from '../styles/withStyles';\nimport useIsFocusVisible from '../utils/useIsFocusVisible';\nimport TouchRipple from './TouchRipple';\nexport var styles = {\n  /* Styles applied to the root element. */\n  root: {\n    display: 'inline-flex',\n    alignItems: 'center',\n    justifyContent: 'center',\n    position: 'relative',\n    WebkitTapHighlightColor: 'transparent',\n    backgroundColor: 'transparent',\n    // Reset default value\n    // We disable the focus ring for mouse, touch and keyboard users.\n    outline: 0,\n    border: 0,\n    margin: 0,\n    // Remove the margin in Safari\n    borderRadius: 0,\n    padding: 0,\n    // Remove the padding in Firefox\n    cursor: 'pointer',\n    userSelect: 'none',\n    verticalAlign: 'middle',\n    '-moz-appearance': 'none',\n    // Reset\n    '-webkit-appearance': 'none',\n    // Reset\n    textDecoration: 'none',\n    // So we take precedent over the style of a native <a /> element.\n    color: 'inherit',\n    '&::-moz-focus-inner': {\n      borderStyle: 'none' // Remove Firefox dotted outline.\n\n    },\n    '&$disabled': {\n      pointerEvents: 'none',\n      // Disable link interactions\n      cursor: 'default'\n    },\n    '@media print': {\n      colorAdjust: 'exact'\n    }\n  },\n\n  /* Pseudo-class applied to the root element if `disabled={true}`. */\n  disabled: {},\n\n  /* Pseudo-class applied to the root element if keyboard focused. */\n  focusVisible: {}\n};\n/**\n * `ButtonBase` contains as few styles as possible.\n * It aims to be a simple building block for creating a button.\n * It contains a load of style reset and some focus/ripple logic.\n */\n\nvar ButtonBase = /*#__PURE__*/React.forwardRef(function ButtonBase(props, ref) {\n  var action = props.action,\n      buttonRefProp = props.buttonRef,\n      _props$centerRipple = props.centerRipple,\n      centerRipple = _props$centerRipple === void 0 ? false : _props$centerRipple,\n      children = props.children,\n      classes = props.classes,\n      className = props.className,\n      _props$component = props.component,\n      component = _props$component === void 0 ? 'button' : _props$component,\n      _props$disabled = props.disabled,\n      disabled = _props$disabled === void 0 ? false : _props$disabled,\n      _props$disableRipple = props.disableRipple,\n      disableRipple = _props$disableRipple === void 0 ? false : _props$disableRipple,\n      _props$disableTouchRi = props.disableTouchRipple,\n      disableTouchRipple = _props$disableTouchRi === void 0 ? false : _props$disableTouchRi,\n      _props$focusRipple = props.focusRipple,\n      focusRipple = _props$focusRipple === void 0 ? false : _props$focusRipple,\n      focusVisibleClassName = props.focusVisibleClassName,\n      onBlur = props.onBlur,\n      onClick = props.onClick,\n      onFocus = props.onFocus,\n      onFocusVisible = props.onFocusVisible,\n      onKeyDown = props.onKeyDown,\n      onKeyUp = props.onKeyUp,\n      onMouseDown = props.onMouseDown,\n      onMouseLeave = props.onMouseLeave,\n      onMouseUp = props.onMouseUp,\n      onTouchEnd = props.onTouchEnd,\n      onTouchMove = props.onTouchMove,\n      onTouchStart = props.onTouchStart,\n      onDragLeave = props.onDragLeave,\n      _props$tabIndex = props.tabIndex,\n      tabIndex = _props$tabIndex === void 0 ? 0 : _props$tabIndex,\n      TouchRippleProps = props.TouchRippleProps,\n      _props$type = props.type,\n      type = _props$type === void 0 ? 'button' : _props$type,\n      other = _objectWithoutProperties(props, [\"action\", \"buttonRef\", \"centerRipple\", \"children\", \"classes\", \"className\", \"component\", \"disabled\", \"disableRipple\", \"disableTouchRipple\", \"focusRipple\", \"focusVisibleClassName\", \"onBlur\", \"onClick\", \"onFocus\", \"onFocusVisible\", \"onKeyDown\", \"onKeyUp\", \"onMouseDown\", \"onMouseLeave\", \"onMouseUp\", \"onTouchEnd\", \"onTouchMove\", \"onTouchStart\", \"onDragLeave\", \"tabIndex\", \"TouchRippleProps\", \"type\"]);\n\n  var buttonRef = React.useRef(null);\n\n  function getButtonNode() {\n    // #StrictMode ready\n    return ReactDOM.findDOMNode(buttonRef.current);\n  }\n\n  var rippleRef = React.useRef(null);\n\n  var _React$useState = React.useState(false),\n      focusVisible = _React$useState[0],\n      setFocusVisible = _React$useState[1];\n\n  if (disabled && focusVisible) {\n    setFocusVisible(false);\n  }\n\n  var _useIsFocusVisible = useIsFocusVisible(),\n      isFocusVisible = _useIsFocusVisible.isFocusVisible,\n      onBlurVisible = _useIsFocusVisible.onBlurVisible,\n      focusVisibleRef = _useIsFocusVisible.ref;\n\n  React.useImperativeHandle(action, function () {\n    return {\n      focusVisible: function focusVisible() {\n        setFocusVisible(true);\n        buttonRef.current.focus();\n      }\n    };\n  }, []);\n  React.useEffect(function () {\n    if (focusVisible && focusRipple && !disableRipple) {\n      rippleRef.current.pulsate();\n    }\n  }, [disableRipple, focusRipple, focusVisible]);\n\n  function useRippleHandler(rippleAction, eventCallback) {\n    var skipRippleAction = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : disableTouchRipple;\n    return useEventCallback(function (event) {\n      if (eventCallback) {\n        eventCallback(event);\n      }\n\n      var ignore = skipRippleAction;\n\n      if (!ignore && rippleRef.current) {\n        rippleRef.current[rippleAction](event);\n      }\n\n      return true;\n    });\n  }\n\n  var handleMouseDown = useRippleHandler('start', onMouseDown);\n  var handleDragLeave = useRippleHandler('stop', onDragLeave);\n  var handleMouseUp = useRippleHandler('stop', onMouseUp);\n  var handleMouseLeave = useRippleHandler('stop', function (event) {\n    if (focusVisible) {\n      event.preventDefault();\n    }\n\n    if (onMouseLeave) {\n      onMouseLeave(event);\n    }\n  });\n  var handleTouchStart = useRippleHandler('start', onTouchStart);\n  var handleTouchEnd = useRippleHandler('stop', onTouchEnd);\n  var handleTouchMove = useRippleHandler('stop', onTouchMove);\n  var handleBlur = useRippleHandler('stop', function (event) {\n    if (focusVisible) {\n      onBlurVisible(event);\n      setFocusVisible(false);\n    }\n\n    if (onBlur) {\n      onBlur(event);\n    }\n  }, false);\n  var handleFocus = useEventCallback(function (event) {\n    // Fix for https://github.com/facebook/react/issues/7769\n    if (!buttonRef.current) {\n      buttonRef.current = event.currentTarget;\n    }\n\n    if (isFocusVisible(event)) {\n      setFocusVisible(true);\n\n      if (onFocusVisible) {\n        onFocusVisible(event);\n      }\n    }\n\n    if (onFocus) {\n      onFocus(event);\n    }\n  });\n\n  var isNonNativeButton = function isNonNativeButton() {\n    var button = getButtonNode();\n    return component && component !== 'button' && !(button.tagName === 'A' && button.href);\n  };\n  /**\n   * IE 11 shim for https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/repeat\n   */\n\n\n  var keydownRef = React.useRef(false);\n  var handleKeyDown = useEventCallback(function (event) {\n    // Check if key is already down to avoid repeats being counted as multiple activations\n    if (focusRipple && !keydownRef.current && focusVisible && rippleRef.current && event.key === ' ') {\n      keydownRef.current = true;\n      event.persist();\n      rippleRef.current.stop(event, function () {\n        rippleRef.current.start(event);\n      });\n    }\n\n    if (event.target === event.currentTarget && isNonNativeButton() && event.key === ' ') {\n      event.preventDefault();\n    }\n\n    if (onKeyDown) {\n      onKeyDown(event);\n    } // Keyboard accessibility for non interactive elements\n\n\n    if (event.target === event.currentTarget && isNonNativeButton() && event.key === 'Enter' && !disabled) {\n      event.preventDefault();\n\n      if (onClick) {\n        onClick(event);\n      }\n    }\n  });\n  var handleKeyUp = useEventCallback(function (event) {\n    // calling preventDefault in keyUp on a <button> will not dispatch a click event if Space is pressed\n    // https://codesandbox.io/s/button-keyup-preventdefault-dn7f0\n    if (focusRipple && event.key === ' ' && rippleRef.current && focusVisible && !event.defaultPrevented) {\n      keydownRef.current = false;\n      event.persist();\n      rippleRef.current.stop(event, function () {\n        rippleRef.current.pulsate(event);\n      });\n    }\n\n    if (onKeyUp) {\n      onKeyUp(event);\n    } // Keyboard accessibility for non interactive elements\n\n\n    if (onClick && event.target === event.currentTarget && isNonNativeButton() && event.key === ' ' && !event.defaultPrevented) {\n      onClick(event);\n    }\n  });\n  var ComponentProp = component;\n\n  if (ComponentProp === 'button' && other.href) {\n    ComponentProp = 'a';\n  }\n\n  var buttonProps = {};\n\n  if (ComponentProp === 'button') {\n    buttonProps.type = type;\n    buttonProps.disabled = disabled;\n  } else {\n    if (ComponentProp !== 'a' || !other.href) {\n      buttonProps.role = 'button';\n    }\n\n    buttonProps['aria-disabled'] = disabled;\n  }\n\n  var handleUserRef = useForkRef(buttonRefProp, ref);\n  var handleOwnRef = useForkRef(focusVisibleRef, buttonRef);\n  var handleRef = useForkRef(handleUserRef, handleOwnRef);\n\n  var _React$useState2 = React.useState(false),\n      mountedState = _React$useState2[0],\n      setMountedState = _React$useState2[1];\n\n  React.useEffect(function () {\n    setMountedState(true);\n  }, []);\n  var enableTouchRipple = mountedState && !disableRipple && !disabled;\n\n  if (process.env.NODE_ENV !== 'production') {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useEffect(function () {\n      if (enableTouchRipple && !rippleRef.current) {\n        console.error(['Material-UI: The `component` prop provided to ButtonBase is invalid.', 'Please make sure the children prop is rendered in this custom component.'].join('\\n'));\n      }\n    }, [enableTouchRipple]);\n  }\n\n  return /*#__PURE__*/React.createElement(ComponentProp, _extends({\n    className: clsx(classes.root, className, focusVisible && [classes.focusVisible, focusVisibleClassName], disabled && classes.disabled),\n    onBlur: handleBlur,\n    onClick: onClick,\n    onFocus: handleFocus,\n    onKeyDown: handleKeyDown,\n    onKeyUp: handleKeyUp,\n    onMouseDown: handleMouseDown,\n    onMouseLeave: handleMouseLeave,\n    onMouseUp: handleMouseUp,\n    onDragLeave: handleDragLeave,\n    onTouchEnd: handleTouchEnd,\n    onTouchMove: handleTouchMove,\n    onTouchStart: handleTouchStart,\n    ref: handleRef,\n    tabIndex: disabled ? -1 : tabIndex\n  }, buttonProps, other), children, enableTouchRipple ?\n  /*#__PURE__*/\n\n  /* TouchRipple is only needed client-side, x2 boost on the server. */\n  React.createElement(TouchRipple, _extends({\n    ref: rippleRef,\n    center: centerRipple\n  }, TouchRippleProps)) : null);\n});\nprocess.env.NODE_ENV !== \"production\" ? ButtonBase.propTypes = {\n  // ----------------------------- Warning --------------------------------\n  // | These PropTypes are generated from the TypeScript type definitions |\n  // |     To update them edit the d.ts file and run \"yarn proptypes\"     |\n  // ----------------------------------------------------------------------\n\n  /**\n   * A ref for imperative actions.\n   * It currently only supports `focusVisible()` action.\n   */\n  action: refType,\n\n  /**\n   * @ignore\n   *\n   * Use that prop to pass a ref to the native button component.\n   * @deprecated Use `ref` instead.\n   */\n  buttonRef: deprecatedPropType(refType, 'Use `ref` instead.'),\n\n  /**\n   * If `true`, the ripples will be centered.\n   * They won't start at the cursor interaction position.\n   */\n  centerRipple: PropTypes.bool,\n\n  /**\n   * The content of the component.\n   */\n  children: PropTypes.node,\n\n  /**\n   * Override or extend the styles applied to the component.\n   * See [CSS API](#css) below for more details.\n   */\n  classes: PropTypes.object,\n\n  /**\n   * @ignore\n   */\n  className: PropTypes.string,\n\n  /**\n   * The component used for the root node.\n   * Either a string to use a HTML element or a component.\n   */\n  component: elementTypeAcceptingRef,\n\n  /**\n   * If `true`, the base button will be disabled.\n   */\n  disabled: PropTypes.bool,\n\n  /**\n   * If `true`, the ripple effect will be disabled.\n   *\n   * ⚠️ Without a ripple there is no styling for :focus-visible by default. Be sure\n   * to highlight the element by applying separate styles with the `focusVisibleClassName`.\n   */\n  disableRipple: PropTypes.bool,\n\n  /**\n   * If `true`, the touch ripple effect will be disabled.\n   */\n  disableTouchRipple: PropTypes.bool,\n\n  /**\n   * If `true`, the base button will have a keyboard focus ripple.\n   */\n  focusRipple: PropTypes.bool,\n\n  /**\n   * This prop can help identify which element has keyboard focus.\n   * The class name will be applied when the element gains the focus through keyboard interaction.\n   * It's a polyfill for the [CSS :focus-visible selector](https://drafts.csswg.org/selectors-4/#the-focus-visible-pseudo).\n   * The rationale for using this feature [is explained here](https://github.com/WICG/focus-visible/blob/master/explainer.md).\n   * A [polyfill can be used](https://github.com/WICG/focus-visible) to apply a `focus-visible` class to other components\n   * if needed.\n   */\n  focusVisibleClassName: PropTypes.string,\n\n  /**\n   * @ignore\n   */\n  href: PropTypes.string,\n\n  /**\n   * @ignore\n   */\n  onBlur: PropTypes.func,\n\n  /**\n   * @ignore\n   */\n  onClick: PropTypes.func,\n\n  /**\n   * @ignore\n   */\n  onDragLeave: PropTypes.func,\n\n  /**\n   * @ignore\n   */\n  onFocus: PropTypes.func,\n\n  /**\n   * Callback fired when the component is focused with a keyboard.\n   * We trigger a `onFocus` callback too.\n   */\n  onFocusVisible: PropTypes.func,\n\n  /**\n   * @ignore\n   */\n  onKeyDown: PropTypes.func,\n\n  /**\n   * @ignore\n   */\n  onKeyUp: PropTypes.func,\n\n  /**\n   * @ignore\n   */\n  onMouseDown: PropTypes.func,\n\n  /**\n   * @ignore\n   */\n  onMouseLeave: PropTypes.func,\n\n  /**\n   * @ignore\n   */\n  onMouseUp: PropTypes.func,\n\n  /**\n   * @ignore\n   */\n  onTouchEnd: PropTypes.func,\n\n  /**\n   * @ignore\n   */\n  onTouchMove: PropTypes.func,\n\n  /**\n   * @ignore\n   */\n  onTouchStart: PropTypes.func,\n\n  /**\n   * @ignore\n   */\n  tabIndex: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),\n\n  /**\n   * Props applied to the `TouchRipple` element.\n   */\n  TouchRippleProps: PropTypes.object,\n\n  /**\n   * @ignore\n   */\n  type: PropTypes.oneOfType([PropTypes.oneOf(['button', 'reset', 'submit']), PropTypes.string])\n} : void 0;\nexport default withStyles(styles, {\n  name: 'MuiButtonBase'\n})(ButtonBase);","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/esm/objectWithoutProperties\";\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport clsx from 'clsx';\nimport { chainPropTypes } from '@material-ui/utils';\nimport withStyles from '../styles/withStyles';\nimport { alpha } from '../styles/colorManipulator';\nimport ButtonBase from '../ButtonBase';\nimport capitalize from '../utils/capitalize';\nexport var styles = function styles(theme) {\n  return {\n    /* Styles applied to the root element. */\n    root: {\n      textAlign: 'center',\n      flex: '0 0 auto',\n      fontSize: theme.typography.pxToRem(24),\n      padding: 12,\n      borderRadius: '50%',\n      overflow: 'visible',\n      // Explicitly set the default value to solve a bug on IE 11.\n      color: theme.palette.action.active,\n      transition: theme.transitions.create('background-color', {\n        duration: theme.transitions.duration.shortest\n      }),\n      '&:hover': {\n        backgroundColor: alpha(theme.palette.action.active, theme.palette.action.hoverOpacity),\n        // Reset on touch devices, it doesn't add specificity\n        '@media (hover: none)': {\n          backgroundColor: 'transparent'\n        }\n      },\n      '&$disabled': {\n        backgroundColor: 'transparent',\n        color: theme.palette.action.disabled\n      }\n    },\n\n    /* Styles applied to the root element if `edge=\"start\"`. */\n    edgeStart: {\n      marginLeft: -12,\n      '$sizeSmall&': {\n        marginLeft: -3\n      }\n    },\n\n    /* Styles applied to the root element if `edge=\"end\"`. */\n    edgeEnd: {\n      marginRight: -12,\n      '$sizeSmall&': {\n        marginRight: -3\n      }\n    },\n\n    /* Styles applied to the root element if `color=\"inherit\"`. */\n    colorInherit: {\n      color: 'inherit'\n    },\n\n    /* Styles applied to the root element if `color=\"primary\"`. */\n    colorPrimary: {\n      color: theme.palette.primary.main,\n      '&:hover': {\n        backgroundColor: alpha(theme.palette.primary.main, theme.palette.action.hoverOpacity),\n        // Reset on touch devices, it doesn't add specificity\n        '@media (hover: none)': {\n          backgroundColor: 'transparent'\n        }\n      }\n    },\n\n    /* Styles applied to the root element if `color=\"secondary\"`. */\n    colorSecondary: {\n      color: theme.palette.secondary.main,\n      '&:hover': {\n        backgroundColor: alpha(theme.palette.secondary.main, theme.palette.action.hoverOpacity),\n        // Reset on touch devices, it doesn't add specificity\n        '@media (hover: none)': {\n          backgroundColor: 'transparent'\n        }\n      }\n    },\n\n    /* Pseudo-class applied to the root element if `disabled={true}`. */\n    disabled: {},\n\n    /* Styles applied to the root element if `size=\"small\"`. */\n    sizeSmall: {\n      padding: 3,\n      fontSize: theme.typography.pxToRem(18)\n    },\n\n    /* Styles applied to the children container element. */\n    label: {\n      width: '100%',\n      display: 'flex',\n      alignItems: 'inherit',\n      justifyContent: 'inherit'\n    }\n  };\n};\n/**\n * Refer to the [Icons](/components/icons/) section of the documentation\n * regarding the available icon options.\n */\n\nvar IconButton = /*#__PURE__*/React.forwardRef(function IconButton(props, ref) {\n  var _props$edge = props.edge,\n      edge = _props$edge === void 0 ? false : _props$edge,\n      children = props.children,\n      classes = props.classes,\n      className = props.className,\n      _props$color = props.color,\n      color = _props$color === void 0 ? 'default' : _props$color,\n      _props$disabled = props.disabled,\n      disabled = _props$disabled === void 0 ? false : _props$disabled,\n      _props$disableFocusRi = props.disableFocusRipple,\n      disableFocusRipple = _props$disableFocusRi === void 0 ? false : _props$disableFocusRi,\n      _props$size = props.size,\n      size = _props$size === void 0 ? 'medium' : _props$size,\n      other = _objectWithoutProperties(props, [\"edge\", \"children\", \"classes\", \"className\", \"color\", \"disabled\", \"disableFocusRipple\", \"size\"]);\n\n  return /*#__PURE__*/React.createElement(ButtonBase, _extends({\n    className: clsx(classes.root, className, color !== 'default' && classes[\"color\".concat(capitalize(color))], disabled && classes.disabled, size === \"small\" && classes[\"size\".concat(capitalize(size))], {\n      'start': classes.edgeStart,\n      'end': classes.edgeEnd\n    }[edge]),\n    centerRipple: true,\n    focusRipple: !disableFocusRipple,\n    disabled: disabled,\n    ref: ref\n  }, other), /*#__PURE__*/React.createElement(\"span\", {\n    className: classes.label\n  }, children));\n});\nprocess.env.NODE_ENV !== \"production\" ? IconButton.propTypes = {\n  /**\n   * The icon element.\n   */\n  children: chainPropTypes(PropTypes.node, function (props) {\n    var found = React.Children.toArray(props.children).some(function (child) {\n      return /*#__PURE__*/React.isValidElement(child) && child.props.onClick;\n    });\n\n    if (found) {\n      return new Error(['Material-UI: You are providing an onClick event listener ' + 'to a child of a button element.', 'Firefox will never trigger the event.', 'You should move the onClick listener to the parent button element.', 'https://github.com/mui-org/material-ui/issues/13957'].join('\\n'));\n    }\n\n    return null;\n  }),\n\n  /**\n   * Override or extend the styles applied to the component.\n   * See [CSS API](#css) below for more details.\n   */\n  classes: PropTypes.object.isRequired,\n\n  /**\n   * @ignore\n   */\n  className: PropTypes.string,\n\n  /**\n   * The color of the component. It supports those theme colors that make sense for this component.\n   */\n  color: PropTypes.oneOf(['default', 'inherit', 'primary', 'secondary']),\n\n  /**\n   * If `true`, the button will be disabled.\n   */\n  disabled: PropTypes.bool,\n\n  /**\n   * If `true`, the  keyboard focus ripple will be disabled.\n   */\n  disableFocusRipple: PropTypes.bool,\n\n  /**\n   * If `true`, the ripple effect will be disabled.\n   */\n  disableRipple: PropTypes.bool,\n\n  /**\n   * If given, uses a negative margin to counteract the padding on one\n   * side (this is often helpful for aligning the left or right\n   * side of the icon with content above or below, without ruining the border\n   * size and shape).\n   */\n  edge: PropTypes.oneOf(['start', 'end', false]),\n\n  /**\n   * The size of the button.\n   * `small` is equivalent to the dense button styling.\n   */\n  size: PropTypes.oneOf(['small', 'medium'])\n} : void 0;\nexport default withStyles(styles, {\n  name: 'MuiIconButton'\n})(IconButton);","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _slicedToArray from \"@babel/runtime/helpers/esm/slicedToArray\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/esm/objectWithoutProperties\";\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport clsx from 'clsx';\nimport { refType } from '@material-ui/utils';\nimport useControlled from '../utils/useControlled';\nimport useFormControl from '../FormControl/useFormControl';\nimport withStyles from '../styles/withStyles';\nimport IconButton from '../IconButton';\nexport var styles = {\n  root: {\n    padding: 9\n  },\n  checked: {},\n  disabled: {},\n  input: {\n    cursor: 'inherit',\n    position: 'absolute',\n    opacity: 0,\n    width: '100%',\n    height: '100%',\n    top: 0,\n    left: 0,\n    margin: 0,\n    padding: 0,\n    zIndex: 1\n  }\n};\n/**\n * @ignore - internal component.\n */\n\nvar SwitchBase = /*#__PURE__*/React.forwardRef(function SwitchBase(props, ref) {\n  var autoFocus = props.autoFocus,\n      checkedProp = props.checked,\n      checkedIcon = props.checkedIcon,\n      classes = props.classes,\n      className = props.className,\n      defaultChecked = props.defaultChecked,\n      disabledProp = props.disabled,\n      icon = props.icon,\n      id = props.id,\n      inputProps = props.inputProps,\n      inputRef = props.inputRef,\n      name = props.name,\n      onBlur = props.onBlur,\n      onChange = props.onChange,\n      onFocus = props.onFocus,\n      readOnly = props.readOnly,\n      required = props.required,\n      tabIndex = props.tabIndex,\n      type = props.type,\n      value = props.value,\n      other = _objectWithoutProperties(props, [\"autoFocus\", \"checked\", \"checkedIcon\", \"classes\", \"className\", \"defaultChecked\", \"disabled\", \"icon\", \"id\", \"inputProps\", \"inputRef\", \"name\", \"onBlur\", \"onChange\", \"onFocus\", \"readOnly\", \"required\", \"tabIndex\", \"type\", \"value\"]);\n\n  var _useControlled = useControlled({\n    controlled: checkedProp,\n    default: Boolean(defaultChecked),\n    name: 'SwitchBase',\n    state: 'checked'\n  }),\n      _useControlled2 = _slicedToArray(_useControlled, 2),\n      checked = _useControlled2[0],\n      setCheckedState = _useControlled2[1];\n\n  var muiFormControl = useFormControl();\n\n  var handleFocus = function handleFocus(event) {\n    if (onFocus) {\n      onFocus(event);\n    }\n\n    if (muiFormControl && muiFormControl.onFocus) {\n      muiFormControl.onFocus(event);\n    }\n  };\n\n  var handleBlur = function handleBlur(event) {\n    if (onBlur) {\n      onBlur(event);\n    }\n\n    if (muiFormControl && muiFormControl.onBlur) {\n      muiFormControl.onBlur(event);\n    }\n  };\n\n  var handleInputChange = function handleInputChange(event) {\n    var newChecked = event.target.checked;\n    setCheckedState(newChecked);\n\n    if (onChange) {\n      // TODO v5: remove the second argument.\n      onChange(event, newChecked);\n    }\n  };\n\n  var disabled = disabledProp;\n\n  if (muiFormControl) {\n    if (typeof disabled === 'undefined') {\n      disabled = muiFormControl.disabled;\n    }\n  }\n\n  var hasLabelFor = type === 'checkbox' || type === 'radio';\n  return /*#__PURE__*/React.createElement(IconButton, _extends({\n    component: \"span\",\n    className: clsx(classes.root, className, checked && classes.checked, disabled && classes.disabled),\n    disabled: disabled,\n    tabIndex: null,\n    role: undefined,\n    onFocus: handleFocus,\n    onBlur: handleBlur,\n    ref: ref\n  }, other), /*#__PURE__*/React.createElement(\"input\", _extends({\n    autoFocus: autoFocus,\n    checked: checkedProp,\n    defaultChecked: defaultChecked,\n    className: classes.input,\n    disabled: disabled,\n    id: hasLabelFor && id,\n    name: name,\n    onChange: handleInputChange,\n    readOnly: readOnly,\n    ref: inputRef,\n    required: required,\n    tabIndex: tabIndex,\n    type: type,\n    value: value\n  }, inputProps)), checked ? checkedIcon : icon);\n}); // NB: If changed, please update Checkbox, Switch and Radio\n// so that the API documentation is updated.\n\nprocess.env.NODE_ENV !== \"production\" ? SwitchBase.propTypes = {\n  /**\n   * If `true`, the `input` element will be focused during the first mount.\n   */\n  autoFocus: PropTypes.bool,\n\n  /**\n   * If `true`, the component is checked.\n   */\n  checked: PropTypes.bool,\n\n  /**\n   * The icon to display when the component is checked.\n   */\n  checkedIcon: PropTypes.node.isRequired,\n\n  /**\n   * Override or extend the styles applied to the component.\n   * See [CSS API](#css) below for more details.\n   */\n  classes: PropTypes.object.isRequired,\n\n  /**\n   * @ignore\n   */\n  className: PropTypes.string,\n\n  /**\n   * @ignore\n   */\n  defaultChecked: PropTypes.bool,\n\n  /**\n   * If `true`, the switch will be disabled.\n   */\n  disabled: PropTypes.bool,\n\n  /**\n   * The icon to display when the component is unchecked.\n   */\n  icon: PropTypes.node.isRequired,\n\n  /**\n   * The id of the `input` element.\n   */\n  id: PropTypes.string,\n\n  /**\n   * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.\n   */\n  inputProps: PropTypes.object,\n\n  /**\n   * Pass a ref to the `input` element.\n   */\n  inputRef: refType,\n\n  /*\n   * @ignore\n   */\n  name: PropTypes.string,\n\n  /**\n   * @ignore\n   */\n  onBlur: PropTypes.func,\n\n  /**\n   * Callback fired when the state is changed.\n   *\n   * @param {object} event The event source of the callback.\n   * You can pull out the new checked state by accessing `event.target.checked` (boolean).\n   */\n  onChange: PropTypes.func,\n\n  /**\n   * @ignore\n   */\n  onFocus: PropTypes.func,\n\n  /**\n   * It prevents the user from changing the value of the field\n   * (not from interacting with the field).\n   */\n  readOnly: PropTypes.bool,\n\n  /**\n   * If `true`, the `input` element will be required.\n   */\n  required: PropTypes.bool,\n\n  /**\n   * @ignore\n   */\n  tabIndex: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),\n\n  /**\n   * The input component prop `type`.\n   */\n  type: PropTypes.string.isRequired,\n\n  /**\n   * The value of the component.\n   */\n  value: PropTypes.any\n} : void 0;\nexport default withStyles(styles, {\n  name: 'PrivateSwitchBase'\n})(SwitchBase);","/* eslint-disable react-hooks/rules-of-hooks, react-hooks/exhaustive-deps */\nimport * as React from 'react';\nexport default function useControlled(_ref) {\n  var controlled = _ref.controlled,\n      defaultProp = _ref.default,\n      name = _ref.name,\n      _ref$state = _ref.state,\n      state = _ref$state === void 0 ? 'value' : _ref$state;\n\n  var _React$useRef = React.useRef(controlled !== undefined),\n      isControlled = _React$useRef.current;\n\n  var _React$useState = React.useState(defaultProp),\n      valueState = _React$useState[0],\n      setValue = _React$useState[1];\n\n  var value = isControlled ? controlled : valueState;\n\n  if (process.env.NODE_ENV !== 'production') {\n    React.useEffect(function () {\n      if (isControlled !== (controlled !== undefined)) {\n        console.error([\"Material-UI: A component is changing the \".concat(isControlled ? '' : 'un', \"controlled \").concat(state, \" state of \").concat(name, \" to be \").concat(isControlled ? 'un' : '', \"controlled.\"), 'Elements should not switch from uncontrolled to controlled (or vice versa).', \"Decide between using a controlled or uncontrolled \".concat(name, \" \") + 'element for the lifetime of the component.', \"The nature of the state is determined during the first render, it's considered controlled if the value is not `undefined`.\", 'More info: https://fb.me/react-controlled-components'].join('\\n'));\n      }\n    }, [controlled]);\n\n    var _React$useRef2 = React.useRef(defaultProp),\n        defaultValue = _React$useRef2.current;\n\n    React.useEffect(function () {\n      if (!isControlled && defaultValue !== defaultProp) {\n        console.error([\"Material-UI: A component is changing the default \".concat(state, \" state of an uncontrolled \").concat(name, \" after being initialized. \") + \"To suppress this warning opt to use a controlled \".concat(name, \".\")].join('\\n'));\n      }\n    }, [JSON.stringify(defaultProp)]);\n  }\n\n  var setValueIfUncontrolled = React.useCallback(function (newValue) {\n    if (!isControlled) {\n      setValue(newValue);\n    }\n  }, []);\n  return [value, setValueIfUncontrolled];\n}","import * as React from 'react';\nimport FormControlContext from './FormControlContext';\nexport default function useFormControl() {\n  return React.useContext(FormControlContext);\n}","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/esm/objectWithoutProperties\";\n// @inheritedComponent IconButton\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport clsx from 'clsx';\nimport { refType } from '@material-ui/utils';\nimport withStyles from '../styles/withStyles';\nimport { alpha } from '../styles/colorManipulator';\nimport capitalize from '../utils/capitalize';\nimport SwitchBase from '../internal/SwitchBase';\nexport var styles = function styles(theme) {\n  return {\n    /* Styles applied to the root element. */\n    root: {\n      display: 'inline-flex',\n      width: 34 + 12 * 2,\n      height: 14 + 12 * 2,\n      overflow: 'hidden',\n      padding: 12,\n      boxSizing: 'border-box',\n      position: 'relative',\n      flexShrink: 0,\n      zIndex: 0,\n      // Reset the stacking context.\n      verticalAlign: 'middle',\n      // For correct alignment with the text.\n      '@media print': {\n        colorAdjust: 'exact'\n      }\n    },\n\n    /* Styles applied to the root element if `edge=\"start\"`. */\n    edgeStart: {\n      marginLeft: -8\n    },\n\n    /* Styles applied to the root element if `edge=\"end\"`. */\n    edgeEnd: {\n      marginRight: -8\n    },\n\n    /* Styles applied to the internal `SwitchBase` component's `root` class. */\n    switchBase: {\n      position: 'absolute',\n      top: 0,\n      left: 0,\n      zIndex: 1,\n      // Render above the focus ripple.\n      color: theme.palette.type === 'light' ? theme.palette.grey[50] : theme.palette.grey[400],\n      transition: theme.transitions.create(['left', 'transform'], {\n        duration: theme.transitions.duration.shortest\n      }),\n      '&$checked': {\n        transform: 'translateX(20px)'\n      },\n      '&$disabled': {\n        color: theme.palette.type === 'light' ? theme.palette.grey[400] : theme.palette.grey[800]\n      },\n      '&$checked + $track': {\n        opacity: 0.5\n      },\n      '&$disabled + $track': {\n        opacity: theme.palette.type === 'light' ? 0.12 : 0.1\n      }\n    },\n\n    /* Styles applied to the internal SwitchBase component's root element if `color=\"primary\"`. */\n    colorPrimary: {\n      '&$checked': {\n        color: theme.palette.primary.main,\n        '&:hover': {\n          backgroundColor: alpha(theme.palette.primary.main, theme.palette.action.hoverOpacity),\n          '@media (hover: none)': {\n            backgroundColor: 'transparent'\n          }\n        }\n      },\n      '&$disabled': {\n        color: theme.palette.type === 'light' ? theme.palette.grey[400] : theme.palette.grey[800]\n      },\n      '&$checked + $track': {\n        backgroundColor: theme.palette.primary.main\n      },\n      '&$disabled + $track': {\n        backgroundColor: theme.palette.type === 'light' ? theme.palette.common.black : theme.palette.common.white\n      }\n    },\n\n    /* Styles applied to the internal SwitchBase component's root element if `color=\"secondary\"`. */\n    colorSecondary: {\n      '&$checked': {\n        color: theme.palette.secondary.main,\n        '&:hover': {\n          backgroundColor: alpha(theme.palette.secondary.main, theme.palette.action.hoverOpacity),\n          '@media (hover: none)': {\n            backgroundColor: 'transparent'\n          }\n        }\n      },\n      '&$disabled': {\n        color: theme.palette.type === 'light' ? theme.palette.grey[400] : theme.palette.grey[800]\n      },\n      '&$checked + $track': {\n        backgroundColor: theme.palette.secondary.main\n      },\n      '&$disabled + $track': {\n        backgroundColor: theme.palette.type === 'light' ? theme.palette.common.black : theme.palette.common.white\n      }\n    },\n\n    /* Styles applied to the root element if `size=\"small\"`. */\n    sizeSmall: {\n      width: 40,\n      height: 24,\n      padding: 7,\n      '& $thumb': {\n        width: 16,\n        height: 16\n      },\n      '& $switchBase': {\n        padding: 4,\n        '&$checked': {\n          transform: 'translateX(16px)'\n        }\n      }\n    },\n\n    /* Pseudo-class applied to the internal `SwitchBase` component's `checked` class. */\n    checked: {},\n\n    /* Pseudo-class applied to the internal SwitchBase component's disabled class. */\n    disabled: {},\n\n    /* Styles applied to the internal SwitchBase component's input element. */\n    input: {\n      left: '-100%',\n      width: '300%'\n    },\n\n    /* Styles used to create the thumb passed to the internal `SwitchBase` component `icon` prop. */\n    thumb: {\n      boxShadow: theme.shadows[1],\n      backgroundColor: 'currentColor',\n      width: 20,\n      height: 20,\n      borderRadius: '50%'\n    },\n\n    /* Styles applied to the track element. */\n    track: {\n      height: '100%',\n      width: '100%',\n      borderRadius: 14 / 2,\n      zIndex: -1,\n      transition: theme.transitions.create(['opacity', 'background-color'], {\n        duration: theme.transitions.duration.shortest\n      }),\n      backgroundColor: theme.palette.type === 'light' ? theme.palette.common.black : theme.palette.common.white,\n      opacity: theme.palette.type === 'light' ? 0.38 : 0.3\n    }\n  };\n};\nvar Switch = /*#__PURE__*/React.forwardRef(function Switch(props, ref) {\n  var classes = props.classes,\n      className = props.className,\n      _props$color = props.color,\n      color = _props$color === void 0 ? 'secondary' : _props$color,\n      _props$edge = props.edge,\n      edge = _props$edge === void 0 ? false : _props$edge,\n      _props$size = props.size,\n      size = _props$size === void 0 ? 'medium' : _props$size,\n      other = _objectWithoutProperties(props, [\"classes\", \"className\", \"color\", \"edge\", \"size\"]);\n\n  var icon = /*#__PURE__*/React.createElement(\"span\", {\n    className: classes.thumb\n  });\n  return /*#__PURE__*/React.createElement(\"span\", {\n    className: clsx(classes.root, className, {\n      'start': classes.edgeStart,\n      'end': classes.edgeEnd\n    }[edge], size === \"small\" && classes[\"size\".concat(capitalize(size))])\n  }, /*#__PURE__*/React.createElement(SwitchBase, _extends({\n    type: \"checkbox\",\n    icon: icon,\n    checkedIcon: icon,\n    classes: {\n      root: clsx(classes.switchBase, classes[\"color\".concat(capitalize(color))]),\n      input: classes.input,\n      checked: classes.checked,\n      disabled: classes.disabled\n    },\n    ref: ref\n  }, other)), /*#__PURE__*/React.createElement(\"span\", {\n    className: classes.track\n  }));\n});\nprocess.env.NODE_ENV !== \"production\" ? Switch.propTypes = {\n  // ----------------------------- Warning --------------------------------\n  // | These PropTypes are generated from the TypeScript type definitions |\n  // |     To update them edit the d.ts file and run \"yarn proptypes\"     |\n  // ----------------------------------------------------------------------\n\n  /**\n   * If `true`, the component is checked.\n   */\n  checked: PropTypes.bool,\n\n  /**\n   * The icon to display when the component is checked.\n   */\n  checkedIcon: PropTypes.node,\n\n  /**\n   * Override or extend the styles applied to the component.\n   * See [CSS API](#css) below for more details.\n   */\n  classes: PropTypes.object,\n\n  /**\n   * @ignore\n   */\n  className: PropTypes.string,\n\n  /**\n   * The color of the component. It supports those theme colors that make sense for this component.\n   */\n  color: PropTypes.oneOf(['default', 'primary', 'secondary']),\n\n  /**\n   * @ignore\n   */\n  defaultChecked: PropTypes.bool,\n\n  /**\n   * If `true`, the switch will be disabled.\n   */\n  disabled: PropTypes.bool,\n\n  /**\n   * If `true`, the ripple effect will be disabled.\n   */\n  disableRipple: PropTypes.bool,\n\n  /**\n   * If given, uses a negative margin to counteract the padding on one\n   * side (this is often helpful for aligning the left or right\n   * side of the icon with content above or below, without ruining the border\n   * size and shape).\n   */\n  edge: PropTypes.oneOf(['end', 'start', false]),\n\n  /**\n   * The icon to display when the component is unchecked.\n   */\n  icon: PropTypes.node,\n\n  /**\n   * The id of the `input` element.\n   */\n  id: PropTypes.string,\n\n  /**\n   * [Attributes](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#Attributes) applied to the `input` element.\n   */\n  inputProps: PropTypes.object,\n\n  /**\n   * Pass a ref to the `input` element.\n   */\n  inputRef: refType,\n\n  /**\n   * Callback fired when the state is changed.\n   *\n   * @param {object} event The event source of the callback.\n   * You can pull out the new value by accessing `event.target.value` (string).\n   * You can pull out the new checked state by accessing `event.target.checked` (boolean).\n   */\n  onChange: PropTypes.func,\n\n  /**\n   * If `true`, the `input` element will be required.\n   */\n  required: PropTypes.bool,\n\n  /**\n   * The size of the switch.\n   * `small` is equivalent to the dense switch styling.\n   */\n  size: PropTypes.oneOf(['medium', 'small']),\n\n  /**\n   * The value of the component. The DOM API casts this to a string.\n   * The browser uses \"on\" as the default value.\n   */\n  value: PropTypes.any\n} : void 0;\nexport default withStyles(styles, {\n  name: 'MuiSwitch'\n})(Switch);","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    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\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    // eslint-disable-next-line @typescript-eslint/unbound-method\n    originalFunctionToString = Function.prototype.toString;\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\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 { arrayify, logger } from '@sentry/utils';\nimport { getCurrentHub } from './hub.js';\nimport { addGlobalEventProcessor } from './scope.js';\n\nvar installedIntegrations = [];\n\n/** Map of integrations assigned to a client */\n\n/**\n * Remove duplicates from the given array, preferring the last instance of any duplicate. Not guaranteed to\n * preseve the order of integrations in the array.\n *\n * @private\n */\nfunction filterDuplicates(integrations) {\n  var integrationsByName = {};\n\n  integrations.forEach(currentInstance => {\n    const { name } = currentInstance;\n\n    var existingInstance = integrationsByName[name];\n\n    // We want integrations later in the array to overwrite earlier ones of the same type, except that we never want a\n    // default instance to overwrite an existing user instance\n    if (existingInstance && !existingInstance.isDefaultInstance && currentInstance.isDefaultInstance) {\n      return;\n    }\n\n    integrationsByName[name] = currentInstance;\n  });\n\n  return Object.values(integrationsByName);\n}\n\n/** Gets integrations to install */\nfunction getIntegrationsToSetup(options) {\n  var defaultIntegrations = options.defaultIntegrations || [];\n  var userIntegrations = options.integrations;\n\n  // We flag default instances, so that later we can tell them apart from any user-created instances of the same class\n  defaultIntegrations.forEach(integration => {\n    integration.isDefaultInstance = true;\n  });\n\n  let integrations;\n\n  if (Array.isArray(userIntegrations)) {\n    integrations = [...defaultIntegrations, ...userIntegrations];\n  } else if (typeof userIntegrations === 'function') {\n    integrations = arrayify(userIntegrations(defaultIntegrations));\n  } else {\n    integrations = defaultIntegrations;\n  }\n\n  var finalIntegrations = filterDuplicates(integrations);\n\n  // The `Debug` integration prints copies of the `event` and `hint` which will be passed to `beforeSend`. It therefore\n  // has to run after all other integrations, so that the changes of all event processors will be reflected in the\n  // printed values. For lack of a more elegant way to guarantee that, we therefore locate it and, assuming it exists,\n  // pop it out of its current spot and shove it onto the end of the array.\n  var debugIndex = finalIntegrations.findIndex(integration => integration.name === 'Debug');\n  if (debugIndex !== -1) {\n    const [debugInstance] = finalIntegrations.splice(debugIndex, 1);\n    finalIntegrations.push(debugInstance);\n  }\n\n  return finalIntegrations;\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","/** An error emitted by Sentry SDKs and related utilities. */\nclass SentryError extends Error {\n  /** Display name of this error instance. */\n\n   constructor( message, logLevel = 'warn') {\n    super(message);this.message = message;;\n\n    this.name = new.target.prototype.constructor.name;\n    // This sets the prototype to be `Error`, not `SentryError`. It's unclear why we do this, but commenting this line\n    // out causes various (seemingly totally unrelated) playwright tests consistently time out. FYI, this makes\n    // instances of `SentryError` fail `obj instanceof SentryError` checks.\n    Object.setPrototypeOf(this, new.target.prototype);\n    this.logLevel = logLevel;\n  }\n}\n\nexport { SentryError };\n//# sourceMappingURL=error.js.map\n","import { 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 { 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 { _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\n// eslint-disable-next-line complexity\nfunction node(getModule) {\n  var FILENAME_MATCH = /^\\s*[-]{4,}$/;\n  var FULL_MATCH = /at (?:async )?(?:(.+?)\\s+\\()?(?:(.+):(\\d+):(\\d+)?|([^)]+))\\)?/;\n\n  // eslint-disable-next-line complexity\n  return (line) => {\n    if (line.match(FILENAME_MATCH)) {\n      return {\n        filename: line,\n      };\n    }\n\n    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        // eslint-disable-next-line no-plusplus\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('http://www.example.com');\n    new Response();\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n/**\n * isNativeFetch checks if the given function is a native implementation of fetch()\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nfunction isNativeFetch(func) {\n  return func && /^function fetch\\(\\)\\s+\\{\\s+\\[native code\\]\\s+\\}$/.test(func.toString());\n}\n\n/**\n * Tells whether current environment supports Fetch API natively\n * {@link supportsNativeFetch}.\n *\n * @returns true if `window.fetch` is natively implemented, false otherwise\n */\nfunction supportsNativeFetch() {\n  if (!supportsFetch()) {\n    return false;\n  }\n\n  var global = getGlobalObject();\n\n  // Fast path to avoid DOM I/O\n  // eslint-disable-next-line @typescript-eslint/unbound-method\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  // eslint-disable-next-line deprecation/deprecation\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        // eslint-disable-next-line @typescript-eslint/unbound-method\n        result = isNativeFetch(sandbox.contentWindow.fetch);\n      }\n      doc.head.removeChild(sandbox);\n    } catch (err) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);\n    }\n  }\n\n  return result;\n}\n\n/**\n * Tells whether current environment supports ReportingObserver API\n * {@link supportsReportingObserver}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsReportingObserver() {\n  return 'ReportingObserver' in 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  /* eslint-disable @typescript-eslint/no-unsafe-member-access */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  var chrome = (global ).chrome;\n  var isChromePackagedApp = chrome && chrome.app && chrome.app.runtime;\n  /* eslint-enable @typescript-eslint/no-unsafe-member-access */\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      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\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/* eslint-disable @typescript-eslint/no-unsafe-member-access */\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/* eslint-enable @typescript-eslint/no-unsafe-member-access */\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      // eslint-disable-next-line @typescript-eslint/no-this-alias\n      var xhr = this;\n      var url = args[1];\n      var xhrInfo = (xhr.__sentry_xhr__ = {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        method: isString(args[0]) ? args[0].toUpperCase() : args[0],\n        url: args[1],\n      });\n\n      // if Sentry key appears in URL, don't capture it as a request\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n      if (isString(url) && xhrInfo.method === 'POST' && url.match(/sentry_key/)) {\n        xhr.__sentry_own_request__ = true;\n      }\n\n      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    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    var proto = (global )[target] && (global )[target].prototype;\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-prototype-builtins\n    if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n      return;\n    }\n\n    fill(proto, 'addEventListener', function (originalAddEventListener) {\n      return function (\n\n        type,\n        listener,\n        options,\n      ) {\n        if (type === 'click' || type == 'keypress') {\n          try {\n            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]; // eslint-disable-line @typescript-eslint/no-dynamic-delete\n                }\n\n                // If there are no longer any custom handlers of any type on this element, cleanup everything.\n                if (Object.keys(handlers).length === 0) {\n                  delete el.__sentry_instrumentation_handlers__;\n                }\n              }\n            } catch (e) {\n              // Accessing dom properties is always fragile.\n              // Also allows us to skip `addEventListenrs` calls with no proper `this` context.\n            }\n          }\n\n          return originalRemoveEventListener.call(this, type, listener, options);\n        };\n      },\n    );\n  });\n}\n\nlet _oldOnErrorHandler = null;\n/** JSDoc */\nfunction instrumentError() {\n  _oldOnErrorHandler = 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      // eslint-disable-next-line prefer-rest-params\n      return _oldOnErrorHandler.apply(this, arguments);\n    }\n\n    return false;\n  };\n}\n\nlet _oldOnUnhandledRejectionHandler = null;\n/** JSDoc */\nfunction instrumentUnhandledRejection() {\n  _oldOnUnhandledRejectionHandler = global.onunhandledrejection;\n\n  global.onunhandledrejection = function (e) {\n    triggerHandlers('unhandledrejection', e);\n\n    if (_oldOnUnhandledRejectionHandler) {\n      // eslint-disable-next-line prefer-rest-params\n      return _oldOnUnhandledRejectionHandler.apply(this, arguments);\n    }\n\n    return true;\n  };\n}\n\nexport { addInstrumentationHandler };\n//# sourceMappingURL=instrument.js.map\n","import { isNaN, isSyntheticEvent } from './is.js';\nimport { memoBuilder } from './memo.js';\nimport { convertToPlainObject } from './object.js';\nimport { getFunctionName } from './stacktrace.js';\n\n/**\n * Recursively normalizes the given object.\n *\n * - Creates a copy to prevent original input mutation\n * - Skips non-enumerable properties\n * - When stringifying, calls `toJSON` if implemented\n * - Removes circular references\n * - Translates non-serializable values (`undefined`/`NaN`/functions) to serializable format\n * - Translates known global objects/classes to a string representations\n * - Takes care of `Error` object serialization\n * - Optionally limits depth of final output\n * - Optionally limits number of properties/elements included in any single object/array\n *\n * @param input The object to be normalized.\n * @param depth The max depth to which to normalize the object. (Anything deeper stringified whole.)\n * @param maxProperties The max number of elements or properties to be included in any single array or\n * object in the normallized output.\n * @returns A normalized version of the object, or `\"**non-serializable**\"` if any errors are thrown during normalization.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction normalize(input, depth = +Infinity, maxProperties = +Infinity) {\n  try {\n    // since we're at the outermost level, we don't provide a key\n    return visit('', input, depth, maxProperties);\n  } catch (err) {\n    return { ERROR: `**non-serializable** (${err})` };\n  }\n}\n\n/** JSDoc */\nfunction normalizeToSize(\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  object,\n  // Default Node.js REPL depth\n  depth = 3,\n  // 100kB, as 200kB is max payload size, so half sounds reasonable\n  maxSize = 100 * 1024,\n) {\n  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    // eslint-disable-next-line no-restricted-globals\n    if (typeof window !== 'undefined' && value === window) {\n      return '[Window]';\n    }\n\n    // eslint-disable-next-line no-restricted-globals\n    if (typeof document !== 'undefined' && value === document) {\n      return '[Document]';\n    }\n\n    // React's SyntheticEvent thingy\n    if (isSyntheticEvent(value)) {\n      return '[SyntheticEvent]';\n    }\n\n    if (typeof value === 'number' && value !== value) {\n      return '[NaN]';\n    }\n\n    // this catches `undefined` (but not `null`, which is a primitive and can be serialized on its own)\n    if (value === void 0) {\n      return '[undefined]';\n    }\n\n    if (typeof value === 'function') {\n      return `[Function: ${getFunctionName(value)}]`;\n    }\n\n    if (typeof value === 'symbol') {\n      return `[${String(value)}]`;\n    }\n\n    // stringified BigInts are indistinguishable from regular numbers, so we need to label them to avoid confusion\n    if (typeof value === 'bigint') {\n      return `[BigInt: ${String(value)}]`;\n    }\n\n    // Now that we've knocked out all the special cases and the primitives, all we have left are objects. Simply casting\n    // them to strings means that instances of classes which haven't defined their `toStringTag` will just come out as\n    // `\"[object Object]\"`. If we instead look at the constructor's name (which is the same as the name of the class),\n    // we can make sure that only plain objects come out that way.\n    return `[object ${(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  // eslint-disable-next-line no-bitwise\n  return ~-encodeURI(value).split(/%..|./).length;\n}\n\n/** Calculates bytes size of input object */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction jsonSize(value) {\n  return utf8Length(JSON.stringify(value));\n}\n\nexport { normalize, normalizeToSize, visit as walk };\n//# sourceMappingURL=normalize.js.map\n","/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\n/**\n * Helper to decycle json objects\n */\nfunction memoBuilder() {\n  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    // eslint-disable-next-line @typescript-eslint/prefer-for-of\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 { normalize } from './normalize.js';\nimport { dropUndefinedKeys } from './object.js';\n\n/**\n * Creates an envelope.\n * Make sure to always explicitly provide the generic to this function\n * so that the envelope types resolve correctly.\n */\nfunction createEnvelope(headers, items = []) {\n  return [headers, items] ;\n}\n\n/**\n * Add an item to an envelope.\n * Make sure to always explicitly provide the generic to this function\n * so that the envelope types resolve correctly.\n */\nfunction addItemToEnvelope(envelope, newItem) {\n  const [headers, items] = envelope;\n  return [headers, [...items, newItem]] ;\n}\n\n/**\n * Convenience function to loop through the items and item types of an envelope.\n * (This function was mostly created because working with envelope types is painful at the moment)\n */\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\n    append(`\\n${JSON.stringify(itemHeaders)}\\n`);\n\n    if (typeof payload === 'string' || payload instanceof Uint8Array) {\n      append(payload);\n    } else {\n      let stringifiedPayload;\n      try {\n        stringifiedPayload = JSON.stringify(payload);\n      } catch (e) {\n        // In case, despite all our efforts to keep `payload` circular-dependency-free, `JSON.strinify()` still\n        // fails, we try again after normalizing it again with infinite normalization depth. This of course has a\n        // performance impact but in this case a performance hit is better than throwing.\n        stringifiedPayload = JSON.stringify(normalize(payload));\n      }\n      append(stringifiedPayload);\n    }\n  }\n\n  return typeof parts === 'string' ? parts : concatBuffers(parts);\n}\n\nfunction concatBuffers(buffers) {\n  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 { dsnToString, createEnvelope, dropUndefinedKeys } 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  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 = [{ type: eventType }, event];\n  return createEnvelope(envelopeHeaders, [eventItem]);\n}\n\nfunction createEventEnvelopeHeaders(\n  event,\n  sdkInfo,\n  tunnel,\n  dsn,\n) {\n  var dynamicSamplingContext = event.sdkProcessingMetadata && event.sdkProcessingMetadata.dynamicSamplingContext;\n\n  return {\n    event_id: event.event_id ,\n    sent_at: new Date().toISOString(),\n    ...(sdkInfo && { sdk: sdkInfo }),\n    ...(!!tunnel && { dsn: dsnToString(dsn) }),\n    ...(event.type === 'transaction' &&\n      dynamicSamplingContext && {\n        trace: dropUndefinedKeys({ ...dynamicSamplingContext }),\n      }),\n  };\n}\n\nexport { createEventEnvelope, createSessionEnvelope };\n//# sourceMappingURL=envelope.js.map\n","import { 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';\nimport { Scope } from './scope.js';\nimport { updateSession } from './session.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  /** The client Dsn, if specified in options. Without this Dsn, the SDK will be disabled. */\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  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\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    // eslint-disable-next-line deprecation/deprecation\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        if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {\n          // If something's gone wrong, log the error as a warning. If it's just us having used a `SentryError` for\n          // control flow, log just the message (no stack) as a log-level log.\n          var sentryError = reason ;\n          if (sentryError.logLevel === 'log') {\n            logger.log(sentryError.message);\n          } else {\n            logger.warn(sentryError);\n          }\n        }\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.', 'log'));\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          'log',\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.', 'log');\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.', 'log');\n        }\n\n        var session = scope && scope.getSession();\n        if (!isTransaction && session) {\n          this._updateSessionFromEvent(session, processedEvent);\n        }\n\n        // None of the Sentry built event processor will update transaction name,\n        // so if the transaction name has been changed by an event processor, we know\n        // it has to come from custom event processor added by a user\n        var transactionInfo = processedEvent.transaction_info;\n        if (isTransaction && transactionInfo && processedEvent.transaction !== event.transaction) {\n          var source = 'custom';\n          processedEvent.transaction_info = {\n            ...transactionInfo,\n            source,\n            changes: [\n              ...transactionInfo.changes,\n              {\n                source,\n                // use the same timestamp as the processed event.\n                timestamp: processedEvent.timestamp ,\n                propagations: transactionInfo.propagations,\n              },\n            ],\n          };\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  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\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 { getCurrentHub } from '@sentry/core';\nimport { 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 hub = getCurrentHub();\n  var client = hub.getClient();\n  var normalizeDepth = client && client.getOptions().normalizeDepth;\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, normalizeDepth),\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  // eslint-disable-next-line deprecation/deprecation\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  // eslint-disable-next-line no-useless-escape\n  return urlPath.split(/[\\?#]/, 1)[0];\n}\n\n/**\n * Returns number of URL segments of a passed string URL.\n */\nfunction getNumberOfUrlSegments(url) {\n  // split at '/' or at '\\/' to split regex urls correctly\n  return url.split(/\\\\?\\//).filter(s => s.length > 0 && s !== ',').length;\n}\n\nexport { getNumberOfUrlSegments, parseUrl, stripUrlQueryAndFragment };\n//# sourceMappingURL=url.js.map\n","import { getCurrentHub } from '@sentry/core';\nimport { addInstrumentationHandler, htmlTreeAsString, severityLevelFromString, safeJoin, getGlobalObject, parseUrl } from '@sentry/utils';\n\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\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   * @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 */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _domBreadcrumb(dom) {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\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 */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\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 */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\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 */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\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 */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\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 { 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';\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    // eslint-disable-next-line deprecation/deprecation\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      var global = getGlobalObject();\n      var isRealNavigator = Object.prototype.toString.call(global && global.navigator) === '[object Navigator]';\n      var hasSendBeacon = isRealNavigator && typeof global.navigator.sendBeacon === 'function';\n      // Make sure beacon is not used if user configures custom transport options\n      if (hasSendBeacon && !this._options.transportOptions) {\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, serializeEnvelope(envelope));\n      } else {\n        // If beacon is not supported or if they are using the tunnel option\n        // use our regular transport to send client reports to Sentry.\n        this._sendEnvelope(envelope);\n      }\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 { 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  // eslint-disable-next-line @typescript-eslint/no-explicit-any\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  /* eslint-disable prefer-rest-params */\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      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access\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  /* eslint-enable prefer-rest-params */\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) {} // eslint-disable-line no-empty\n\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    // eslint-disable-next-line no-empty\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   * @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  // eslint-disable-next-line @typescript-eslint/no-explicit-any\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 */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _wrapRAF(original) {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return function ( callback) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\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  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return function ( ...args) {\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\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        // eslint-disable-next-line @typescript-eslint/no-explicit-any\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  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  var global = getGlobalObject() ;\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  var proto = global[target] && global[target].prototype;\n\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-prototype-builtins\n  if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n    return;\n  }\n\n  fill(proto, 'addEventListener', function (original)\n\n {\n    return function (\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\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          // eslint-disable-next-line @typescript-eslint/unbound-method\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        // eslint-disable-next-line @typescript-eslint/no-explicit-any\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      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    ) {\n      return function (\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\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/* eslint-disable @typescript-eslint/no-unsafe-member-access */\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   * 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    // eslint-disable-next-line guard-for-in\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    // eslint-disable-next-line @typescript-eslint/no-explicit-any\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    // eslint-disable-next-line @typescript-eslint/no-explicit-any\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 */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\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 */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\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   * @inheritDoc\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   * @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","// 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 { 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    // eslint-disable-next-line @typescript-eslint/no-explicit-any\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 because buffer is full.');\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 because buffer limit was 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          // eslint-disable-next-line no-plusplus\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","import { getGlobalObject, isNativeFetch, logger } 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  /* eslint-disable @typescript-eslint/unbound-method */\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  // eslint-disable-next-line deprecation/deprecation\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  /* eslint-enable @typescript-eslint/unbound-method */\n}\n\nexport { getNativeFetchImplementation };\n//# sourceMappingURL=utils.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      // Outgoing requests are usually cancelled when navigating to a different page, causing a \"TypeError: Failed to\n      // fetch\" error and sending a \"network_error\" client-outcome - in Chrome, the request status shows \"(cancelled)\".\n      // The `keepalive` flag keeps outgoing requests alive, even when switching pages. We want this since we're\n      // frequently sending events right before the user is switching pages (eg. whenfinishing navigation transactions).\n      // Gotchas:\n      // - `keepalive` isn't supported by Firefox\n      // - As per spec (https://fetch.spec.whatwg.org/#http-network-or-cache-fetch), a request with `keepalive: true`\n      //   and a content length of > 64 kibibytes returns a network error. We will therefore only activate the flag when\n      //   we're below that limit.\n      keepalive: request.body.length <= 65536,\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    // eslint-disable-next-line @typescript-eslint/unbound-method\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 */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\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 { logger } from '@sentry/utils';\nimport { getCurrentHub } from './hub.js';\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      // eslint-disable-next-line no-console\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 { 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 */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\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  // eslint-disable-next-line deprecation/deprecation\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 */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\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({ ...context }, customSamplingContext);\n}\n\nexport { addBreadcrumb, captureEvent, captureException, captureMessage, configureScope, setContext, setExtra, setExtras, setTag, setTags, setUser, startTransaction, withScope };\n//# sourceMappingURL=exports.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   * 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  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\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    // eslint-disable-next-line deprecation/deprecation\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    // eslint-disable-next-line @typescript-eslint/unbound-method\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  // eslint-disable-next-line @typescript-eslint/no-explicit-any\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  // eslint-disable-next-line @typescript-eslint/no-explicit-any\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 { isPlainObject, dateTimestampInSeconds, getGlobalSingleton, SyncPromise, logger, isThenable, arrayify } from '@sentry/utils';\nimport { updateSession } from './session.js';\n\n/**\n * Default value for maximum number of breadcrumbs added to an event.\n */\nvar DEFAULT_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  /** Callback for client to receive scope changes. */\n\n  /** Callback list that will be called after {@link applyToEvent}. */\n\n  /** Array of breadcrumbs. */\n\n  /** User */\n\n  /** Tags */\n\n  /** Extra */\n\n  /** Contexts */\n\n  /** Attachments */\n\n  /**\n   * A place to stash data which is needed at some point in the SDK's event processing pipeline but which shouldn't get\n   * sent to Sentry\n   */\n\n  /** Fingerprint */\n\n  /** Severity */\n  // eslint-disable-next-line deprecation/deprecation\n\n  /** Transaction Name */\n\n  /** Span */\n\n  /** Session */\n\n  /** Request Mode Session Status */\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    // eslint-disable-next-line deprecation/deprecation\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      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\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      // eslint-disable-next-line no-param-reassign\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' ? maxBreadcrumbs : DEFAULT_MAX_BREADCRUMBS;\n\n    // No data has been changed, so don't notify scope listeners\n    if (maxCrumbs <= 0) {\n      return this;\n    }\n\n    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 data from the scope to the event and runs all event processors on it.\n   *\n   * @param event Event\n   * @param hint Object containing additional information about the original exception, for use by the event processors.\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 ? arrayify(event.fingerprint) : [];\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 { 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 */\n// eslint-disable-next-line complexity\nfunction updateSession(session, context = {}) {\n  if (context.user) {\n    if (!session.ipAddress && context.user.ip_address) {\n      session.ipAddress = context.user.ip_address;\n    }\n\n    if (!session.did && !context.did) {\n      session.did = context.user.id || context.user.email || context.user.username;\n    }\n  }\n\n  session.timestamp = context.timestamp || timestampInSeconds();\n\n  if (context.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","var SDK_VERSION = '7.15.0';\n\nexport { SDK_VERSION };\n//# sourceMappingURL=version.js.map\n","import { getCurrentHub } from '@sentry/browser';\nimport { timestampWithMs } from '@sentry/utils';\nimport hoistNonReactStatics from 'hoist-non-react-statics';\nimport * as React from 'react';\nimport { REACT_MOUNT_OP, REACT_UPDATE_OP, REACT_RENDER_OP } from './constants.js';\n\nvar _jsxFileName = \"/home/runner/work/sentry-javascript/sentry-javascript/packages/react/src/profiler.tsx\";/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n\nvar UNKNOWN_COMPONENT = 'unknown';\n\n/**\n * The Profiler component leverages Sentry's Tracing integration to generate\n * spans based on component lifecycles.\n */\nclass Profiler extends React.Component {\n  /**\n   * The span of the mount activity\n   * Made protected for the React Native SDK to access\n   */\n   __init() {this._mountSpan = undefined;}\n  /**\n   * The span that represents the duration of time between shouldComponentUpdate and componentDidUpdate\n   */\n   __init2() {this._updateSpan = undefined;}\n\n  // eslint-disable-next-line @typescript-eslint/member-ordering\n   static __initStatic() {this.defaultProps = {\n    disabled: false,\n    includeRender: true,\n    includeUpdates: true,\n  };}\n\n   constructor(props) {\n    super(props);Profiler.prototype.__init.call(this);Profiler.prototype.__init2.call(this);;\n    const { name, disabled = false } = this.props;\n\n    if (disabled) {\n      return;\n    }\n\n    var activeTransaction = getActiveTransaction();\n    if (activeTransaction) {\n      this._mountSpan = activeTransaction.startChild({\n        description: `<${name}>`,\n        op: REACT_MOUNT_OP,\n      });\n    }\n  }\n\n  // If a component mounted, we can finish the mount activity.\n   componentDidMount() {\n    if (this._mountSpan) {\n      this._mountSpan.finish();\n    }\n  }\n\n   shouldComponentUpdate({ updateProps, includeUpdates = true }) {\n    // Only generate an update span if includeUpdates is true, if there is a valid mountSpan,\n    // and if the updateProps have changed. It is ok to not do a deep equality check here as it is expensive.\n    // We are just trying to give baseline clues for further investigation.\n    if (includeUpdates && this._mountSpan && updateProps !== this.props.updateProps) {\n      // See what props haved changed between the previous props, and the current props. This is\n      // set as data on the span. We just store the prop keys as the values could be potenially very large.\n      var changedProps = Object.keys(updateProps).filter(k => updateProps[k] !== this.props.updateProps[k]);\n      if (changedProps.length > 0) {\n        var now = timestampWithMs();\n        this._updateSpan = this._mountSpan.startChild({\n          data: {\n            changedProps,\n          },\n          description: `<${this.props.name}>`,\n          op: REACT_UPDATE_OP,\n          startTimestamp: now,\n        });\n      }\n    }\n\n    return true;\n  }\n\n   componentDidUpdate() {\n    if (this._updateSpan) {\n      this._updateSpan.finish();\n      this._updateSpan = undefined;\n    }\n  }\n\n  // If a component is unmounted, we can say it is no longer on the screen.\n  // This means we can finish the span representing the component render.\n   componentWillUnmount() {\n    const { name, includeRender = true } = this.props;\n\n    if (this._mountSpan && includeRender) {\n      // If we were able to obtain the spanId of the mount activity, we should set the\n      // next activity as a child to the component mount activity.\n      this._mountSpan.startChild({\n        description: `<${name}>`,\n        endTimestamp: timestampWithMs(),\n        op: REACT_RENDER_OP,\n        startTimestamp: this._mountSpan.endTimestamp,\n      });\n    }\n  }\n\n   render() {\n    return this.props.children;\n  }\n} Profiler.__initStatic();\n\n/**\n * withProfiler is a higher order component that wraps a\n * component in a {@link Profiler} component. It is recommended that\n * the higher order component be used over the regular {@link Profiler} component.\n *\n * @param WrappedComponent component that is wrapped by Profiler\n * @param options the {@link ProfilerProps} you can pass into the Profiler\n */\nfunction withProfiler(\n  WrappedComponent,\n  // We do not want to have `updateProps` given in options, it is instead filled through the HOC.\n  options,\n) {\n  var componentDisplayName =\n    (options && options.name) || WrappedComponent.displayName || WrappedComponent.name || UNKNOWN_COMPONENT;\n\n  var Wrapped = (props) => (\n    React.createElement(Profiler, { ...options, name: componentDisplayName, updateProps: props, __self: this, __source: {fileName: _jsxFileName, lineNumber: 143}}\n      , React.createElement(WrappedComponent, { ...props, __self: this, __source: {fileName: _jsxFileName, lineNumber: 144}} )\n    )\n  );\n\n  Wrapped.displayName = `profiler(${componentDisplayName})`;\n\n  // Copy over static methods from Wrapped component to Profiler HOC\n  // See: https://reactjs.org/docs/higher-order-components.html#static-methods-must-be-copied-over\n  hoistNonReactStatics(Wrapped, WrappedComponent);\n  return Wrapped;\n}\n\n/**\n *\n * `useProfiler` is a React hook that profiles a React component.\n *\n * Requires React 16.8 or above.\n * @param name displayName of component being profiled\n */\nfunction useProfiler(\n  name,\n  options = {\n    disabled: false,\n    hasRenderSpan: true,\n  },\n) {\n  const [mountSpan] = React.useState(() => {\n    if (options && options.disabled) {\n      return undefined;\n    }\n\n    var activeTransaction = getActiveTransaction();\n    if (activeTransaction) {\n      return activeTransaction.startChild({\n        description: `<${name}>`,\n        op: REACT_MOUNT_OP,\n      });\n    }\n\n    return undefined;\n  });\n\n  React.useEffect(() => {\n    if (mountSpan) {\n      mountSpan.finish();\n    }\n\n    return () => {\n      if (mountSpan && options.hasRenderSpan) {\n        mountSpan.startChild({\n          description: `<${name}>`,\n          endTimestamp: timestampWithMs(),\n          op: REACT_RENDER_OP,\n          startTimestamp: mountSpan.endTimestamp,\n        });\n      }\n    };\n    // We only want this to run once.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n}\n\n/** Grabs active transaction off scope */\nfunction getActiveTransaction(hub = getCurrentHub()) {\n  if (hub) {\n    var scope = hub.getScope();\n    if (scope) {\n      return scope.getTransaction() ;\n    }\n  }\n\n  return undefined;\n}\n\nexport { Profiler, UNKNOWN_COMPONENT, getActiveTransaction, useProfiler, withProfiler };\n//# sourceMappingURL=profiler.js.map\n","var REACT_RENDER_OP = 'ui.react.render';\n\nvar REACT_UPDATE_OP = 'ui.react.update';\n\nvar REACT_MOUNT_OP = 'ui.react.mount';\n\nexport { REACT_MOUNT_OP, REACT_RENDER_OP, REACT_UPDATE_OP };\n//# sourceMappingURL=constants.js.map\n","import { getGlobalObject } from '@sentry/utils';\nimport hoistNonReactStatics from 'hoist-non-react-statics';\nimport * as React from 'react';\n\nvar _jsxFileName = \"/home/runner/work/sentry-javascript/sentry-javascript/packages/react/src/reactrouter.tsx\";\n\n// We need to disable eslint no-explict-any because any is required for the\n// react-router typings.\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\n/* eslint-enable @typescript-eslint/no-explicit-any */\n\nvar global = getGlobalObject();\n\nlet activeTransaction;\n\nfunction reactRouterV4Instrumentation(\n  history,\n  routes,\n  matchPath,\n) {\n  return createReactRouterInstrumentation(history, 'react-router-v4', routes, matchPath);\n}\n\nfunction reactRouterV5Instrumentation(\n  history,\n  routes,\n  matchPath,\n) {\n  return createReactRouterInstrumentation(history, 'react-router-v5', routes, matchPath);\n}\n\nfunction createReactRouterInstrumentation(\n  history,\n  name,\n  allRoutes = [],\n  matchPath,\n) {\n  function getInitPathName() {\n    if (history && history.location) {\n      return history.location.pathname;\n    }\n\n    if (global && global.location) {\n      return global.location.pathname;\n    }\n\n    return undefined;\n  }\n\n  /**\n   * Normalizes a transaction name. Returns the new name as well as the\n   * source of the transaction.\n   *\n   * @param pathname The initial pathname we normalize\n   */\n  function normalizeTransactionName(pathname) {\n    if (allRoutes.length === 0 || !matchPath) {\n      return [pathname, 'url'];\n    }\n\n    var branches = matchRoutes(allRoutes, pathname, matchPath);\n    // eslint-disable-next-line @typescript-eslint/prefer-for-of\n    for (let x = 0; x < branches.length; x++) {\n      if (branches[x].match.isExact) {\n        return [branches[x].match.path, 'route'];\n      }\n    }\n\n    return [pathname, 'url'];\n  }\n\n  var tags = {\n    'routing.instrumentation': name,\n  };\n\n  return (customStartTransaction, startTransactionOnPageLoad = true, startTransactionOnLocationChange = true) => {\n    var initPathName = getInitPathName();\n    if (startTransactionOnPageLoad && initPathName) {\n      const [name, source] = normalizeTransactionName(initPathName);\n      activeTransaction = customStartTransaction({\n        name,\n        op: 'pageload',\n        tags,\n        metadata: {\n          source,\n        },\n      });\n    }\n\n    if (startTransactionOnLocationChange && history.listen) {\n      history.listen((location, action) => {\n        if (action && (action === 'PUSH' || action === 'POP')) {\n          if (activeTransaction) {\n            activeTransaction.finish();\n          }\n\n          const [name, source] = normalizeTransactionName(location.pathname);\n          activeTransaction = customStartTransaction({\n            name,\n            op: 'navigation',\n            tags,\n            metadata: {\n              source,\n            },\n          });\n        }\n      });\n    }\n  };\n}\n\n/**\n * Matches a set of routes to a pathname\n * Based on implementation from\n */\nfunction matchRoutes(\n  routes,\n  pathname,\n  matchPath,\n  branch = [],\n) {\n  routes.some(route => {\n    var match = route.path\n      ? matchPath(pathname, route)\n      : branch.length\n      ? branch[branch.length - 1].match // use parent match\n      : computeRootMatch(pathname); // use default \"root\" match\n\n    if (match) {\n      branch.push({ route, match });\n\n      if (route.routes) {\n        matchRoutes(route.routes, pathname, matchPath, branch);\n      }\n    }\n\n    return !!match;\n  });\n\n  return branch;\n}\n\nfunction computeRootMatch(pathname) {\n  return { path: '/', url: '/', params: {}, isExact: pathname === '/' };\n}\n\n/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access */\nfunction withSentryRouting(Route) {\n  var componentDisplayName = (Route ).displayName || (Route ).name;\n\n  var WrappedRoute = (props) => {\n    if (activeTransaction && props && props.computedMatch && props.computedMatch.isExact) {\n      activeTransaction.setName(props.computedMatch.path, 'route');\n    }\n\n    // @ts-ignore Setting more specific React Component typing for `R` generic above\n    // will break advanced type inference done by react router params:\n    // https://github.com/DefinitelyTyped/DefinitelyTyped/blob/13dc4235c069e25fe7ee16e11f529d909f9f3ff8/types/react-router/index.d.ts#L154-L164\n    return React.createElement(Route, { ...props, __self: this, __source: {fileName: _jsxFileName, lineNumber: 176}} );\n  };\n\n  WrappedRoute.displayName = `sentryRoute(${componentDisplayName})`;\n  hoistNonReactStatics(WrappedRoute, Route);\n  // @ts-ignore Setting more specific React Component typing for `R` generic above\n  // will break advanced type inference done by react router params:\n  // https://github.com/DefinitelyTyped/DefinitelyTyped/blob/13dc4235c069e25fe7ee16e11f529d909f9f3ff8/types/react-router/index.d.ts#L154-L164\n  return WrappedRoute;\n}\n/* eslint-enable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access */\n\nexport { reactRouterV4Instrumentation, reactRouterV5Instrumentation, withSentryRouting };\n//# sourceMappingURL=reactrouter.js.map\n","import { SDK_VERSION, init as init$1 } from '@sentry/browser';\n\n/**\n * Inits the React SDK\n */\nfunction init(options) {\n  options._metadata = options._metadata || {};\n  options._metadata.sdk = options._metadata.sdk || {\n    name: 'sentry.javascript.react',\n    packages: [\n      {\n        name: 'npm:@sentry/react',\n        version: SDK_VERSION,\n      },\n    ],\n    version: SDK_VERSION,\n  };\n  init$1(options);\n}\n\nexport { init };\n//# sourceMappingURL=sdk.js.map\n","import { addExtensionMethods as addExtensionMethods$1, BrowserTracing as BrowserTracing$1, getActiveTransaction as getActiveTransaction$1, extractTraceparentData as extractTraceparentData$1, spanStatusfromHttpCode as spanStatusfromHttpCode$1, Transaction as Transaction$1, Span as Span$1, BROWSER_TRACING_INTEGRATION_ID as BROWSER_TRACING_INTEGRATION_ID$1, defaultRequestInstrumentationOptions as defaultRequestInstrumentationOptions$1, hasTracingEnabled as hasTracingEnabled$1, stripUrlQueryAndFragment as stripUrlQueryAndFragment$1, TRACEPARENT_REGEXP as TRACEPARENT_REGEXP$1, IdleTransaction as IdleTransaction$1, instrumentOutgoingRequests as instrumentOutgoingRequests$1, startIdleTransaction as startIdleTransaction$1, SpanStatus as SpanStatus$1, Apollo, Express, GraphQL, Mongo, Mysql, Postgres, Prisma } from '@sentry-internal/tracing';\n\n// BrowserTracing is already exported as part of `Integrations` below (and for the moment will remain so for\n// backwards compatibility), but that interferes with treeshaking, so we also export it separately\n// here.\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n * `BrowserTracing` can be imported from `@sentry/browser` or your framework SDK\n *\n * import { BrowserTracing } from '@sentry/browser';\n * new BrowserTracing()\n */\n// eslint-disable-next-line deprecation/deprecation\nconst BrowserTracing = BrowserTracing$1;\n\n// BrowserTracing is already exported as part of `Integrations` below (and for the moment will remain so for\n// backwards compatibility), but that interferes with treeshaking, so we also export it separately\n// here.\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n * `BrowserTracing` can be imported from `@sentry/browser` or your framework SDK\n *\n * import { BrowserTracing } from '@sentry/browser';\n * new BrowserTracing()\n */\n// eslint-disable-next-line deprecation/deprecation\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n */\nconst addExtensionMethods = addExtensionMethods$1;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n *\n * `getActiveTransaction` can be imported from `@sentry/node`, `@sentry/browser`, or your framework SDK\n */\n// eslint-disable-next-line deprecation/deprecation\nconst getActiveTransaction = getActiveTransaction$1;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n *\n * `extractTraceparentData` can be imported from `@sentry/node`, `@sentry/browser`, or your framework SDK\n */\n// eslint-disable-next-line deprecation/deprecation\nconst extractTraceparentData = extractTraceparentData$1;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n *\n * `spanStatusfromHttpCode` can be imported from `@sentry/node`, `@sentry/browser`, or your framework SDK\n */\n// eslint-disable-next-line deprecation/deprecation\nconst spanStatusfromHttpCode = spanStatusfromHttpCode$1;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n *\n * `SpanStatusType` can be imported from `@sentry/node`, `@sentry/browser`, or your framework SDK\n */\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n *\n * `Transaction` can be imported from `@sentry/node`, `@sentry/browser`, or your framework SDK\n */\nconst Transaction = Transaction$1;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n *\n * `Transaction` can be imported from `@sentry/node`, `@sentry/browser`, or your framework SDK\n */\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n *\n * `Span` can be imported from `@sentry/node`, `@sentry/browser`, or your framework SDK\n */\nconst Span = Span$1;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n *\n * `Span` can be imported from `@sentry/node`, `@sentry/browser`, or your framework SDK\n */\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n */\nconst BROWSER_TRACING_INTEGRATION_ID = BROWSER_TRACING_INTEGRATION_ID$1;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n *\n * `defaultRequestInstrumentationOptions` can be imported from `@sentry/browser`, or your framework SDK\n */\nconst defaultRequestInstrumentationOptions = defaultRequestInstrumentationOptions$1;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n *\n * `hasTracingEnabled` can be imported from `@sentry/utils`\n */\nconst hasTracingEnabled = hasTracingEnabled$1;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n *\n * `stripUrlQueryAndFragment` can be imported from `@sentry/utils`\n */\nconst stripUrlQueryAndFragment = stripUrlQueryAndFragment$1;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n *\n * `TRACEPARENT_REGEXP` can be imported from `@sentry/utils`\n */\nconst TRACEPARENT_REGEXP = TRACEPARENT_REGEXP$1;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n */\nconst IdleTransaction = IdleTransaction$1;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n */\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n */\nconst instrumentOutgoingRequests = instrumentOutgoingRequests$1;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n */\nconst startIdleTransaction = startIdleTransaction$1;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n */\n// eslint-disable-next-line deprecation/deprecation\nconst SpanStatus = SpanStatus$1;\n\n/**\n * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n */\n// eslint-disable-next-line deprecation/deprecation\n\nconst Integrations = {\n  /**\n   * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n   * `BrowserTracing` can be imported from `@sentry/browser` or your framework SDK\n   *\n   * import { BrowserTracing } from '@sentry/browser';\n   * new BrowserTracing()\n   */\n  // eslint-disable-next-line deprecation/deprecation\n  BrowserTracing: BrowserTracing,\n  /**\n   * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n   * `Apollo` can be imported from `@sentry/node`\n   *\n   * import { Integrations } from '@sentry/node';\n   * new Integrations.Apollo({ ... })\n   */\n  // eslint-disable-next-line deprecation/deprecation\n  Apollo: Apollo,\n  /**\n   * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n   * `Express` can be imported from `@sentry/node`\n   *\n   * import { Integrations } from '@sentry/node';\n   * new Integrations.Express({ ... })\n   */\n  // eslint-disable-next-line deprecation/deprecation\n  Express: Express,\n  /**\n   * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n   * `GraphQL` can be imported from `@sentry/node`\n   *\n   * import { Integrations } from '@sentry/node';\n   * new Integrations.GraphQL({ ... })\n   */\n  // eslint-disable-next-line deprecation/deprecation\n  GraphQL: GraphQL,\n  /**\n   * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n   * `Mongo` can be imported from `@sentry/node`\n   *\n   * import { Integrations } from '@sentry/node';\n   * new Integrations.Mongo({ ... })\n   */\n  // eslint-disable-next-line deprecation/deprecation\n  Mongo: Mongo,\n  /**\n   * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n   * `Mysql` can be imported from `@sentry/node`\n   *\n   * import { Integrations } from '@sentry/node';\n   * new Integrations.Mysql({ ... })\n   */\n  // eslint-disable-next-line deprecation/deprecation\n  Mysql: Mysql,\n  /**\n   * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n   * `Postgres` can be imported from `@sentry/node`\n   *\n   * import { Integrations } from '@sentry/node';\n   * new Integrations.Postgres({ ... })\n   */\n  // eslint-disable-next-line deprecation/deprecation\n  Postgres: Postgres,\n  /**\n   * @deprecated `@sentry/tracing` has been deprecated and will be moved to to `@sentry/node`, `@sentry/browser`, or your framework SDK in the next major version.\n   * `Prisma` can be imported from `@sentry/node`\n   *\n   * import { Integrations } from '@sentry/node';\n   * new Integrations.Prisma({ ... })\n   */\n  // eslint-disable-next-line deprecation/deprecation\n  Prisma: Prisma,\n};\n\n// Treeshakable guard to remove all code related to tracing\n\n// Guard for tree\nif (typeof __SENTRY_TRACING__ === 'undefined' || __SENTRY_TRACING__) {\n  // We are patching the global object with our hub extension methods\n  addExtensionMethods$1();\n}\n\nexport { BROWSER_TRACING_INTEGRATION_ID, BrowserTracing, IdleTransaction, Integrations, Span, SpanStatus, TRACEPARENT_REGEXP, Transaction, addExtensionMethods, defaultRequestInstrumentationOptions, extractTraceparentData, getActiveTransaction, hasTracingEnabled, instrumentOutgoingRequests, spanStatusfromHttpCode, startIdleTransaction, stripUrlQueryAndFragment };\n//# sourceMappingURL=index.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  // 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    // eslint-disable-next-line no-plusplus\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    // eslint-disable-next-line prefer-const\n    className = elem.className;\n    if (className && isString(className)) {\n      classes = className.split(/\\s+/);\n      for (i = 0; i < classes.length; i++) {\n        out.push(`.${classes[i]}`);\n      }\n    }\n  }\n  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\n/**\n * Gets a DOM element by using document.querySelector.\n *\n * This wrapper will first check for the existance of the function before\n * actually calling it so that we don't have to take care of this check,\n * every time we want to access the DOM.\n *\n * Reason: DOM/querySelector is not available in all environments.\n *\n * We have to cast to any because utils can be consumed by a variety of environments,\n * and we don't want to break TS users. If you know what element will be selected by\n * `document.querySelector`, specify it as part of the generic call. For example,\n * `var element = getDomElement<Element>('selector');`\n *\n * @param selector the selector string passed on to document.querySelector\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction getDomElement(selector) {\n  var global = getGlobalObject();\n  if (global.document && global.document.querySelector) {\n    return global.document.querySelector(selector) ;\n  }\n  return null;\n}\n\nexport { getDomElement, getLocationHref, htmlTreeAsString };\n//# sourceMappingURL=browser.js.map\n","/** Internal */\n\n// The code below for 'isGlobalObj' and 'GLOBAL' was copied from core-js before modification\n// https://github.com/zloirock/core-js/blob/1b944df55282cdc99c90db5f49eb0b6eda2cc0a3/packages/core-js/internals/global.js\n// core-js has the following licence:\n//\n// Copyright (c) 2014-2022 Denis Pushkarev\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n/** Returns 'obj' if it's the global object, otherwise returns undefined */\nfunction isGlobalObj(obj) {\n  return obj && obj.Math == Math ? obj : undefined;\n}\n\nvar GLOBAL =\n  (typeof globalThis == 'object' && isGlobalObj(globalThis)) ||\n  // eslint-disable-next-line no-restricted-globals\n  (typeof window == 'object' && isGlobalObj(window)) ||\n  (typeof self == 'object' && isGlobalObj(self)) ||\n  (typeof global == 'object' && isGlobalObj(global)) ||\n  (function () {\n    return this;\n  })() ||\n  {};\n\n/**\n * Safely get global scope object\n *\n * @returns Global scope object\n */\nfunction getGlobalObject() {\n  return GLOBAL ;\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 || GLOBAL) ;\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","// eslint-disable-next-line @typescript-eslint/unbound-method\nvar objectToString = Object.prototype.toString;\n\n/**\n * Checks whether given value's type is one of a few Error or Error-like\n * {@link isError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isError(wat) {\n  switch (objectToString.call(wat)) {\n    case '[object Error]':\n    case '[object Exception]':\n    case '[object DOMException]':\n      return true;\n    default:\n      return isInstanceOf(wat, Error);\n  }\n}\n/**\n * Checks whether given value is an instance of the given built-in class.\n *\n * @param wat The value to be checked\n * @param className\n * @returns A boolean representing the result.\n */\nfunction isBuiltin(wat, className) {\n  return objectToString.call(wat) === `[object ${className}]`;\n}\n\n/**\n * Checks whether given value's type is ErrorEvent\n * {@link isErrorEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isErrorEvent(wat) {\n  return isBuiltin(wat, 'ErrorEvent');\n}\n\n/**\n * Checks whether given value's type is DOMError\n * {@link isDOMError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isDOMError(wat) {\n  return isBuiltin(wat, 'DOMError');\n}\n\n/**\n * Checks whether given value's type is DOMException\n * {@link isDOMException}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isDOMException(wat) {\n  return isBuiltin(wat, 'DOMException');\n}\n\n/**\n * Checks whether given value's type is a string\n * {@link isString}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isString(wat) {\n  return isBuiltin(wat, 'String');\n}\n\n/**\n * Checks whether given value is a primitive (undefined, null, number, boolean, string, bigint, symbol)\n * {@link isPrimitive}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isPrimitive(wat) {\n  return wat === null || (typeof wat !== 'object' && typeof wat !== 'function');\n}\n\n/**\n * Checks whether given value's type is an object literal\n * {@link isPlainObject}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isPlainObject(wat) {\n  return isBuiltin(wat, 'Object');\n}\n\n/**\n * Checks whether given value's type is an Event instance\n * {@link isEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isEvent(wat) {\n  return typeof Event !== 'undefined' && isInstanceOf(wat, Event);\n}\n\n/**\n * Checks whether given value's type is an Element instance\n * {@link isElement}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isElement(wat) {\n  return typeof Element !== 'undefined' && isInstanceOf(wat, Element);\n}\n\n/**\n * Checks whether given value's type is an regexp\n * {@link isRegExp}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isRegExp(wat) {\n  return isBuiltin(wat, 'RegExp');\n}\n\n/**\n * Checks whether given value has a then function.\n * @param wat A value to be checked.\n */\nfunction isThenable(wat) {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  return Boolean(wat && wat.then && typeof wat.then === 'function');\n}\n\n/**\n * Checks whether given value's type is a SyntheticEvent\n * {@link isSyntheticEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isSyntheticEvent(wat) {\n  return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;\n}\n\n/**\n * Checks whether given value is NaN\n * {@link isNaN}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isNaN(wat) {\n  return typeof wat === 'number' && wat !== wat;\n}\n\n/**\n * Checks whether given value's type is an instance of provided constructor.\n * {@link isInstanceOf}.\n *\n * @param wat A value to be checked.\n * @param base A constructor to be used in a check.\n * @returns A boolean representing the result.\n */\nfunction isInstanceOf(wat, base) {\n  try {\n    return wat instanceof base;\n  } catch (_e) {\n    return false;\n  }\n}\n\nexport { isDOMError, isDOMException, isElement, isError, isErrorEvent, isEvent, isInstanceOf, isNaN, isPlainObject, isPrimitive, isRegExp, isString, isSyntheticEvent, isThenable };\n//# sourceMappingURL=is.js.map\n","import { 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      // eslint-disable-next-line @typescript-eslint/no-explicit-any\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","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    // eslint-disable-next-line no-bitwise\n    ((c ) ^ ((getRandomByte() & 15) >> ((c ) / 4))).toString(16),\n  );\n}\n\nfunction getFirstException(event) {\n  return event.exception && event.exception.values ? event.exception.values[0] : undefined;\n}\n\n/**\n * Extracts either message or type+value from an event that can be used for user-facing logs\n * @returns event's description\n */\nfunction getEventDescription(event) {\n  const { message, event_id: eventId } = event;\n  if (message) {\n    return message;\n  }\n\n  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  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  if (exception && (exception ).__sentry_captured__) {\n    return true;\n  }\n\n  try {\n    // set it this way rather than by assignment so that it's not ennumerable and therefore isn't recorded by the\n    // `ExtraErrorData` integration\n    addNonEnumerableProperty(exception , '__sentry_captured__', true);\n  } catch (err) {\n    // `exception` is a primitive, so we can't mark it seen\n  }\n\n  return false;\n}\n\n/**\n * Checks whether the given input is already an array, and if it isn't, wraps it in one.\n *\n * @param maybeArray Input to turn into an array, if necessary\n * @returns The input, if already an array, or an array with the input as the only element, if not\n */\nfunction arrayify(maybeArray) {\n  return Array.isArray(maybeArray) ? maybeArray : [maybeArray];\n}\n\nexport { addContextToFrame, addExceptionMechanism, addExceptionTypeValue, arrayify, checkOrSetAlreadyCaught, getEventDescription, parseSemver, uuid4 };\n//# sourceMappingURL=misc.js.map\n","import { isBrowserBundle } from './env.js';\n\n/**\n * NOTE: In order to avoid circular dependencies, if you add a function to this module and it needs to print something,\n * you must either a) use `console.log` rather than the logger, or b) put your function elsewhere.\n */\n\n/**\n * Checks whether we're in the Node.js or Browser environment\n *\n * @returns Answer to given question\n */\nfunction isNodeEnv() {\n  // explicitly check for browser bundles as those can be optimized statically\n  // by terser/rollup.\n  return (\n    !isBrowserBundle() &&\n    Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]'\n  );\n}\n\n/**\n * Requires a module which is protected against bundler minification.\n *\n * @param request The module path to resolve\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any\nfunction dynamicRequire(mod, request) {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  return mod.require(request);\n}\n\n/**\n * Helper for dynamically loading module that should work with linked dependencies.\n * The problem is that we _should_ be using `require(require.resolve(moduleName, { paths: [cwd()] }))`\n * However it's _not possible_ to do that with Webpack, as it has to know all the dependencies during\n * build time. `require.resolve` is also not available in any other way, so we cannot create,\n * a fake helper like we do with `dynamicRequire`.\n *\n * We always prefer to use local package, thus the value is not returned early from each `try/catch` block.\n * That is to mimic the behavior of `require.resolve` exactly.\n *\n * @param moduleName module name to require\n * @returns possibly required module\n */\nfunction loadModule(moduleName) {\n  let mod;\n\n  try {\n    mod = dynamicRequire(module, moduleName);\n  } catch (e) {\n    // no-empty\n  }\n\n  try {\n    const { cwd } = dynamicRequire(module, 'process');\n    mod = dynamicRequire(module, `${cwd()}/node_modules/${moduleName}`) ;\n  } catch (e) {\n    // no-empty\n  }\n\n  return mod;\n}\n\nexport { dynamicRequire, isNodeEnv, loadModule };\n//# sourceMappingURL=node.js.map\n","/*\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 { 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      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n      objectified = new (wat ).constructor(wat);\n      break;\n\n    // by process of elimination, at this point we know that `wat` must already be an object\n    default:\n      objectified = wat;\n      break;\n  }\n  return objectified;\n}\n\nexport { addNonEnumerableProperty, convertToPlainObject, dropUndefinedKeys, extractExceptionKeysForMessage, fill, getOriginalFunction, markFunctionWrapped, objectify, urlEncode };\n//# sourceMappingURL=object.js.map\n","import { 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    // eslint-disable-next-line no-param-reassign\n    colno = lineLength;\n  }\n\n  let start = Math.max(colno - 60, 0);\n  if (start < 5) {\n    start = 0;\n  }\n\n  let end = Math.min(start + 140, lineLength);\n  if (end > lineLength - 5) {\n    end = lineLength;\n  }\n  if (end === lineLength) {\n    start = Math.max(end - 140, 0);\n  }\n\n  newLine = newLine.slice(start, end);\n  if (start > 0) {\n    newLine = `'{snip} ${newLine}`;\n  }\n  if (end < lineLength) {\n    newLine += ' {snip}';\n  }\n\n  return newLine;\n}\n\n/**\n * Join values in array\n * @param input array of values to be joined together\n * @param delimiter string to be placed in-between values\n * @returns Joined values\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction safeJoin(input, delimiter) {\n  if (!Array.isArray(input)) {\n    return '';\n  }\n\n  var output = [];\n  // eslint-disable-next-line @typescript-eslint/prefer-for-of\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 { isThenable } from './is.js';\n\n/* eslint-disable @typescript-eslint/explicit-function-return-type */\n\n/** SyncPromise internal states */\nvar States; (function (States) {\n  /** Pending */\n  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   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        // eslint-disable-next-line @typescript-eslint/no-floating-promises\n        handler[1](this._value );\n      }\n\n      if (this._state === States.REJECTED) {\n        handler[2](this._value);\n      }\n\n      handler[0] = true;\n    });\n  };}\n}\n\nexport { SyncPromise, rejectedSyncPromise, resolvedSyncPromise };\n//# sourceMappingURL=syncpromise.js.map\n","import { 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  // eslint-disable-next-line deprecation/deprecation\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","import deepmerge from 'deepmerge';\nimport isPlainObject from 'lodash-es/isPlainObject';\nimport cloneDeep from 'lodash-es/cloneDeep';\nimport { createContext, useContext, Children, useRef, useEffect, useState, useCallback, useMemo, useImperativeHandle, createElement, useLayoutEffect, forwardRef, Component } from 'react';\nimport isEqual from 'react-fast-compare';\nimport invariant from 'tiny-warning';\nimport clone from 'lodash-es/clone';\nimport toPath from 'lodash-es/toPath';\nimport hoistNonReactStatics from 'hoist-non-react-statics';\n\nfunction _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}\n\nfunction _inheritsLoose(subClass, superClass) {\n  subClass.prototype = Object.create(superClass.prototype);\n  subClass.prototype.constructor = subClass;\n  subClass.__proto__ = superClass;\n}\n\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}\n\nfunction _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return self;\n}\n\nvar FormikContext = /*#__PURE__*/createContext(undefined);\nFormikContext.displayName = 'FormikContext';\nvar FormikProvider = FormikContext.Provider;\nvar FormikConsumer = FormikContext.Consumer;\nfunction useFormikContext() {\n  var formik = useContext(FormikContext);\n  !!!formik ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"Formik context is undefined, please verify you are calling useFormikContext() as child of a <Formik> component.\") : invariant(false) : void 0;\n  return formik;\n}\n\n/** @private is the value an empty array? */\n\nvar isEmptyArray = function isEmptyArray(value) {\n  return Array.isArray(value) && value.length === 0;\n};\n/** @private is the given object a Function? */\n\nvar isFunction = function isFunction(obj) {\n  return typeof obj === 'function';\n};\n/** @private is the given object an Object? */\n\nvar isObject = function isObject(obj) {\n  return obj !== null && typeof obj === 'object';\n};\n/** @private is the given object an integer? */\n\nvar isInteger = function isInteger(obj) {\n  return String(Math.floor(Number(obj))) === obj;\n};\n/** @private is the given object a string? */\n\nvar isString = function isString(obj) {\n  return Object.prototype.toString.call(obj) === '[object String]';\n};\n/** @private is the given object a NaN? */\n// eslint-disable-next-line no-self-compare\n\nvar isNaN$1 = function isNaN(obj) {\n  return obj !== obj;\n};\n/** @private Does a React component have exactly 0 children? */\n\nvar isEmptyChildren = function isEmptyChildren(children) {\n  return Children.count(children) === 0;\n};\n/** @private is the given object/value a promise? */\n\nvar isPromise = function isPromise(value) {\n  return isObject(value) && isFunction(value.then);\n};\n/** @private is the given object/value a type of synthetic event? */\n\nvar isInputEvent = function isInputEvent(value) {\n  return value && isObject(value) && isObject(value.target);\n};\n/**\r\n * Same as document.activeElement but wraps in a try-catch block. In IE it is\r\n * not safe to call document.activeElement if there is nothing focused.\r\n *\r\n * The activeElement will be null only if the document or document body is not\r\n * yet defined.\r\n *\r\n * @param {?Document} doc Defaults to current document.\r\n * @return {Element | null}\r\n * @see https://github.com/facebook/fbjs/blob/master/packages/fbjs/src/core/dom/getActiveElement.js\r\n */\n\nfunction getActiveElement(doc) {\n  doc = doc || (typeof document !== 'undefined' ? document : undefined);\n\n  if (typeof doc === 'undefined') {\n    return null;\n  }\n\n  try {\n    return doc.activeElement || doc.body;\n  } catch (e) {\n    return doc.body;\n  }\n}\n/**\r\n * Deeply get a value from an object via its path.\r\n */\n\nfunction getIn(obj, key, def, p) {\n  if (p === void 0) {\n    p = 0;\n  }\n\n  var path = toPath(key);\n\n  while (obj && p < path.length) {\n    obj = obj[path[p++]];\n  } // check if path is not in the end\n\n\n  if (p !== path.length && !obj) {\n    return def;\n  }\n\n  return obj === undefined ? def : obj;\n}\n/**\r\n * Deeply set a value from in object via it's path. If the value at `path`\r\n * has changed, return a shallow copy of obj with `value` set at `path`.\r\n * If `value` has not changed, return the original `obj`.\r\n *\r\n * Existing objects / arrays along `path` are also shallow copied. Sibling\r\n * objects along path retain the same internal js reference. Since new\r\n * objects / arrays are only created along `path`, we can test if anything\r\n * changed in a nested structure by comparing the object's reference in\r\n * the old and new object, similar to how russian doll cache invalidation\r\n * works.\r\n *\r\n * In earlier versions of this function, which used cloneDeep, there were\r\n * issues whereby settings a nested value would mutate the parent\r\n * instead of creating a new object. `clone` avoids that bug making a\r\n * shallow copy of the objects along the update path\r\n * so no object is mutated in place.\r\n *\r\n * Before changing this function, please read through the following\r\n * discussions.\r\n *\r\n * @see https://github.com/developit/linkstate\r\n * @see https://github.com/jaredpalmer/formik/pull/123\r\n */\n\nfunction setIn(obj, path, value) {\n  var res = clone(obj); // this keeps inheritance when obj is a class\n\n  var resVal = res;\n  var i = 0;\n  var pathArray = toPath(path);\n\n  for (; i < pathArray.length - 1; i++) {\n    var currentPath = pathArray[i];\n    var currentObj = getIn(obj, pathArray.slice(0, i + 1));\n\n    if (currentObj && (isObject(currentObj) || Array.isArray(currentObj))) {\n      resVal = resVal[currentPath] = clone(currentObj);\n    } else {\n      var nextPath = pathArray[i + 1];\n      resVal = resVal[currentPath] = isInteger(nextPath) && Number(nextPath) >= 0 ? [] : {};\n    }\n  } // Return original object if new value is the same as current\n\n\n  if ((i === 0 ? obj : resVal)[pathArray[i]] === value) {\n    return obj;\n  }\n\n  if (value === undefined) {\n    delete resVal[pathArray[i]];\n  } else {\n    resVal[pathArray[i]] = value;\n  } // If the path array has a single element, the loop did not run.\n  // Deleting on `resVal` had no effect in this scenario, so we delete on the result instead.\n\n\n  if (i === 0 && value === undefined) {\n    delete res[pathArray[i]];\n  }\n\n  return res;\n}\n/**\r\n * Recursively a set the same value for all keys and arrays nested object, cloning\r\n * @param object\r\n * @param value\r\n * @param visited\r\n * @param response\r\n */\n\nfunction setNestedObjectValues(object, value, visited, response) {\n  if (visited === void 0) {\n    visited = new WeakMap();\n  }\n\n  if (response === void 0) {\n    response = {};\n  }\n\n  for (var _i = 0, _Object$keys = Object.keys(object); _i < _Object$keys.length; _i++) {\n    var k = _Object$keys[_i];\n    var val = object[k];\n\n    if (isObject(val)) {\n      if (!visited.get(val)) {\n        visited.set(val, true); // In order to keep array values consistent for both dot path  and\n        // bracket syntax, we need to check if this is an array so that\n        // this will output  { friends: [true] } and not { friends: { \"0\": true } }\n\n        response[k] = Array.isArray(val) ? [] : {};\n        setNestedObjectValues(val, value, visited, response[k]);\n      }\n    } else {\n      response[k] = value;\n    }\n  }\n\n  return response;\n}\n\nfunction formikReducer(state, msg) {\n  switch (msg.type) {\n    case 'SET_VALUES':\n      return _extends({}, state, {\n        values: msg.payload\n      });\n\n    case 'SET_TOUCHED':\n      return _extends({}, state, {\n        touched: msg.payload\n      });\n\n    case 'SET_ERRORS':\n      if (isEqual(state.errors, msg.payload)) {\n        return state;\n      }\n\n      return _extends({}, state, {\n        errors: msg.payload\n      });\n\n    case 'SET_STATUS':\n      return _extends({}, state, {\n        status: msg.payload\n      });\n\n    case 'SET_ISSUBMITTING':\n      return _extends({}, state, {\n        isSubmitting: msg.payload\n      });\n\n    case 'SET_ISVALIDATING':\n      return _extends({}, state, {\n        isValidating: msg.payload\n      });\n\n    case 'SET_FIELD_VALUE':\n      return _extends({}, state, {\n        values: setIn(state.values, msg.payload.field, msg.payload.value)\n      });\n\n    case 'SET_FIELD_TOUCHED':\n      return _extends({}, state, {\n        touched: setIn(state.touched, msg.payload.field, msg.payload.value)\n      });\n\n    case 'SET_FIELD_ERROR':\n      return _extends({}, state, {\n        errors: setIn(state.errors, msg.payload.field, msg.payload.value)\n      });\n\n    case 'RESET_FORM':\n      return _extends({}, state, msg.payload);\n\n    case 'SET_FORMIK_STATE':\n      return msg.payload(state);\n\n    case 'SUBMIT_ATTEMPT':\n      return _extends({}, state, {\n        touched: setNestedObjectValues(state.values, true),\n        isSubmitting: true,\n        submitCount: state.submitCount + 1\n      });\n\n    case 'SUBMIT_FAILURE':\n      return _extends({}, state, {\n        isSubmitting: false\n      });\n\n    case 'SUBMIT_SUCCESS':\n      return _extends({}, state, {\n        isSubmitting: false\n      });\n\n    default:\n      return state;\n  }\n} // Initial empty states // objects\n\n\nvar emptyErrors = {};\nvar emptyTouched = {};\nfunction useFormik(_ref) {\n  var _ref$validateOnChange = _ref.validateOnChange,\n      validateOnChange = _ref$validateOnChange === void 0 ? true : _ref$validateOnChange,\n      _ref$validateOnBlur = _ref.validateOnBlur,\n      validateOnBlur = _ref$validateOnBlur === void 0 ? true : _ref$validateOnBlur,\n      _ref$validateOnMount = _ref.validateOnMount,\n      validateOnMount = _ref$validateOnMount === void 0 ? false : _ref$validateOnMount,\n      isInitialValid = _ref.isInitialValid,\n      _ref$enableReinitiali = _ref.enableReinitialize,\n      enableReinitialize = _ref$enableReinitiali === void 0 ? false : _ref$enableReinitiali,\n      onSubmit = _ref.onSubmit,\n      rest = _objectWithoutPropertiesLoose(_ref, [\"validateOnChange\", \"validateOnBlur\", \"validateOnMount\", \"isInitialValid\", \"enableReinitialize\", \"onSubmit\"]);\n\n  var props = _extends({\n    validateOnChange: validateOnChange,\n    validateOnBlur: validateOnBlur,\n    validateOnMount: validateOnMount,\n    onSubmit: onSubmit\n  }, rest);\n\n  var initialValues = useRef(props.initialValues);\n  var initialErrors = useRef(props.initialErrors || emptyErrors);\n  var initialTouched = useRef(props.initialTouched || emptyTouched);\n  var initialStatus = useRef(props.initialStatus);\n  var isMounted = useRef(false);\n  var fieldRegistry = useRef({});\n\n  if (process.env.NODE_ENV !== \"production\") {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    useEffect(function () {\n      !(typeof isInitialValid === 'undefined') ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'isInitialValid has been deprecated and will be removed in future versions of Formik. Please use initialErrors or validateOnMount instead.') : invariant(false) : void 0; // eslint-disable-next-line\n    }, []);\n  }\n\n  useEffect(function () {\n    isMounted.current = true;\n    return function () {\n      isMounted.current = false;\n    };\n  }, []);\n\n  var _React$useState = useState(0),\n      setIteration = _React$useState[1];\n\n  var stateRef = useRef({\n    values: cloneDeep(props.initialValues),\n    errors: cloneDeep(props.initialErrors) || emptyErrors,\n    touched: cloneDeep(props.initialTouched) || emptyTouched,\n    status: cloneDeep(props.initialStatus),\n    isSubmitting: false,\n    isValidating: false,\n    submitCount: 0\n  });\n  var state = stateRef.current;\n  var dispatch = useCallback(function (action) {\n    var prev = stateRef.current;\n    stateRef.current = formikReducer(prev, action); // force rerender\n\n    if (prev !== stateRef.current) setIteration(function (x) {\n      return x + 1;\n    });\n  }, []);\n  var runValidateHandler = useCallback(function (values, field) {\n    return new Promise(function (resolve, reject) {\n      var maybePromisedErrors = props.validate(values, field);\n\n      if (maybePromisedErrors == null) {\n        // use loose null check here on purpose\n        resolve(emptyErrors);\n      } else if (isPromise(maybePromisedErrors)) {\n        maybePromisedErrors.then(function (errors) {\n          resolve(errors || emptyErrors);\n        }, function (actualException) {\n          if (process.env.NODE_ENV !== 'production') {\n            console.warn(\"Warning: An unhandled error was caught during validation in <Formik validate />\", actualException);\n          }\n\n          reject(actualException);\n        });\n      } else {\n        resolve(maybePromisedErrors);\n      }\n    });\n  }, [props.validate]);\n  /**\r\n   * Run validation against a Yup schema and optionally run a function if successful\r\n   */\n\n  var runValidationSchema = useCallback(function (values, field) {\n    var validationSchema = props.validationSchema;\n    var schema = isFunction(validationSchema) ? validationSchema(field) : validationSchema;\n    var promise = field && schema.validateAt ? schema.validateAt(field, values) : validateYupSchema(values, schema);\n    return new Promise(function (resolve, reject) {\n      promise.then(function () {\n        resolve(emptyErrors);\n      }, function (err) {\n        // Yup will throw a validation error if validation fails. We catch those and\n        // resolve them into Formik errors. We can sniff if something is a Yup error\n        // by checking error.name.\n        // @see https://github.com/jquense/yup#validationerrorerrors-string--arraystring-value-any-path-string\n        if (err.name === 'ValidationError') {\n          resolve(yupToFormErrors(err));\n        } else {\n          // We throw any other errors\n          if (process.env.NODE_ENV !== 'production') {\n            console.warn(\"Warning: An unhandled error was caught during validation in <Formik validationSchema />\", err);\n          }\n\n          reject(err);\n        }\n      });\n    });\n  }, [props.validationSchema]);\n  var runSingleFieldLevelValidation = useCallback(function (field, value) {\n    return new Promise(function (resolve) {\n      return resolve(fieldRegistry.current[field].validate(value));\n    });\n  }, []);\n  var runFieldLevelValidations = useCallback(function (values) {\n    var fieldKeysWithValidation = Object.keys(fieldRegistry.current).filter(function (f) {\n      return isFunction(fieldRegistry.current[f].validate);\n    }); // Construct an array with all of the field validation functions\n\n    var fieldValidations = fieldKeysWithValidation.length > 0 ? fieldKeysWithValidation.map(function (f) {\n      return runSingleFieldLevelValidation(f, getIn(values, f));\n    }) : [Promise.resolve('DO_NOT_DELETE_YOU_WILL_BE_FIRED')]; // use special case ;)\n\n    return Promise.all(fieldValidations).then(function (fieldErrorsList) {\n      return fieldErrorsList.reduce(function (prev, curr, index) {\n        if (curr === 'DO_NOT_DELETE_YOU_WILL_BE_FIRED') {\n          return prev;\n        }\n\n        if (curr) {\n          prev = setIn(prev, fieldKeysWithValidation[index], curr);\n        }\n\n        return prev;\n      }, {});\n    });\n  }, [runSingleFieldLevelValidation]); // Run all validations and return the result\n\n  var runAllValidations = useCallback(function (values) {\n    return Promise.all([runFieldLevelValidations(values), props.validationSchema ? runValidationSchema(values) : {}, props.validate ? runValidateHandler(values) : {}]).then(function (_ref2) {\n      var fieldErrors = _ref2[0],\n          schemaErrors = _ref2[1],\n          validateErrors = _ref2[2];\n      var combinedErrors = deepmerge.all([fieldErrors, schemaErrors, validateErrors], {\n        arrayMerge: arrayMerge\n      });\n      return combinedErrors;\n    });\n  }, [props.validate, props.validationSchema, runFieldLevelValidations, runValidateHandler, runValidationSchema]); // Run all validations methods and update state accordingly\n\n  var validateFormWithHighPriority = useEventCallback(function (values) {\n    if (values === void 0) {\n      values = state.values;\n    }\n\n    dispatch({\n      type: 'SET_ISVALIDATING',\n      payload: true\n    });\n    return runAllValidations(values).then(function (combinedErrors) {\n      if (!!isMounted.current) {\n        dispatch({\n          type: 'SET_ISVALIDATING',\n          payload: false\n        });\n        dispatch({\n          type: 'SET_ERRORS',\n          payload: combinedErrors\n        });\n      }\n\n      return combinedErrors;\n    });\n  });\n  useEffect(function () {\n    if (validateOnMount && isMounted.current === true && isEqual(initialValues.current, props.initialValues)) {\n      validateFormWithHighPriority(initialValues.current);\n    }\n  }, [validateOnMount, validateFormWithHighPriority]);\n  var resetForm = useCallback(function (nextState) {\n    var values = nextState && nextState.values ? nextState.values : initialValues.current;\n    var errors = nextState && nextState.errors ? nextState.errors : initialErrors.current ? initialErrors.current : props.initialErrors || {};\n    var touched = nextState && nextState.touched ? nextState.touched : initialTouched.current ? initialTouched.current : props.initialTouched || {};\n    var status = nextState && nextState.status ? nextState.status : initialStatus.current ? initialStatus.current : props.initialStatus;\n    initialValues.current = values;\n    initialErrors.current = errors;\n    initialTouched.current = touched;\n    initialStatus.current = status;\n\n    var dispatchFn = function dispatchFn() {\n      dispatch({\n        type: 'RESET_FORM',\n        payload: {\n          isSubmitting: !!nextState && !!nextState.isSubmitting,\n          errors: errors,\n          touched: touched,\n          status: status,\n          values: values,\n          isValidating: !!nextState && !!nextState.isValidating,\n          submitCount: !!nextState && !!nextState.submitCount && typeof nextState.submitCount === 'number' ? nextState.submitCount : 0\n        }\n      });\n    };\n\n    if (props.onReset) {\n      var maybePromisedOnReset = props.onReset(state.values, imperativeMethods);\n\n      if (isPromise(maybePromisedOnReset)) {\n        maybePromisedOnReset.then(dispatchFn);\n      } else {\n        dispatchFn();\n      }\n    } else {\n      dispatchFn();\n    }\n  }, [props.initialErrors, props.initialStatus, props.initialTouched, props.onReset]);\n  useEffect(function () {\n    if (isMounted.current === true && !isEqual(initialValues.current, props.initialValues)) {\n      if (enableReinitialize) {\n        initialValues.current = props.initialValues;\n        resetForm();\n\n        if (validateOnMount) {\n          validateFormWithHighPriority(initialValues.current);\n        }\n      }\n    }\n  }, [enableReinitialize, props.initialValues, resetForm, validateOnMount, validateFormWithHighPriority]);\n  useEffect(function () {\n    if (enableReinitialize && isMounted.current === true && !isEqual(initialErrors.current, props.initialErrors)) {\n      initialErrors.current = props.initialErrors || emptyErrors;\n      dispatch({\n        type: 'SET_ERRORS',\n        payload: props.initialErrors || emptyErrors\n      });\n    }\n  }, [enableReinitialize, props.initialErrors]);\n  useEffect(function () {\n    if (enableReinitialize && isMounted.current === true && !isEqual(initialTouched.current, props.initialTouched)) {\n      initialTouched.current = props.initialTouched || emptyTouched;\n      dispatch({\n        type: 'SET_TOUCHED',\n        payload: props.initialTouched || emptyTouched\n      });\n    }\n  }, [enableReinitialize, props.initialTouched]);\n  useEffect(function () {\n    if (enableReinitialize && isMounted.current === true && !isEqual(initialStatus.current, props.initialStatus)) {\n      initialStatus.current = props.initialStatus;\n      dispatch({\n        type: 'SET_STATUS',\n        payload: props.initialStatus\n      });\n    }\n  }, [enableReinitialize, props.initialStatus, props.initialTouched]);\n  var validateField = useEventCallback(function (name) {\n    // This will efficiently validate a single field by avoiding state\n    // changes if the validation function is synchronous. It's different from\n    // what is called when using validateForm.\n    if (fieldRegistry.current[name] && isFunction(fieldRegistry.current[name].validate)) {\n      var value = getIn(state.values, name);\n      var maybePromise = fieldRegistry.current[name].validate(value);\n\n      if (isPromise(maybePromise)) {\n        // Only flip isValidating if the function is async.\n        dispatch({\n          type: 'SET_ISVALIDATING',\n          payload: true\n        });\n        return maybePromise.then(function (x) {\n          return x;\n        }).then(function (error) {\n          dispatch({\n            type: 'SET_FIELD_ERROR',\n            payload: {\n              field: name,\n              value: error\n            }\n          });\n          dispatch({\n            type: 'SET_ISVALIDATING',\n            payload: false\n          });\n        });\n      } else {\n        dispatch({\n          type: 'SET_FIELD_ERROR',\n          payload: {\n            field: name,\n            value: maybePromise\n          }\n        });\n        return Promise.resolve(maybePromise);\n      }\n    } else if (props.validationSchema) {\n      dispatch({\n        type: 'SET_ISVALIDATING',\n        payload: true\n      });\n      return runValidationSchema(state.values, name).then(function (x) {\n        return x;\n      }).then(function (error) {\n        dispatch({\n          type: 'SET_FIELD_ERROR',\n          payload: {\n            field: name,\n            value: getIn(error, name)\n          }\n        });\n        dispatch({\n          type: 'SET_ISVALIDATING',\n          payload: false\n        });\n      });\n    }\n\n    return Promise.resolve();\n  });\n  var registerField = useCallback(function (name, _ref3) {\n    var validate = _ref3.validate;\n    fieldRegistry.current[name] = {\n      validate: validate\n    };\n  }, []);\n  var unregisterField = useCallback(function (name) {\n    delete fieldRegistry.current[name];\n  }, []);\n  var setTouched = useEventCallback(function (touched, shouldValidate) {\n    dispatch({\n      type: 'SET_TOUCHED',\n      payload: touched\n    });\n    var willValidate = shouldValidate === undefined ? validateOnBlur : shouldValidate;\n    return willValidate ? validateFormWithHighPriority(state.values) : Promise.resolve();\n  });\n  var setErrors = useCallback(function (errors) {\n    dispatch({\n      type: 'SET_ERRORS',\n      payload: errors\n    });\n  }, []);\n  var setValues = useEventCallback(function (values, shouldValidate) {\n    var resolvedValues = isFunction(values) ? values(state.values) : values;\n    dispatch({\n      type: 'SET_VALUES',\n      payload: resolvedValues\n    });\n    var willValidate = shouldValidate === undefined ? validateOnChange : shouldValidate;\n    return willValidate ? validateFormWithHighPriority(resolvedValues) : Promise.resolve();\n  });\n  var setFieldError = useCallback(function (field, value) {\n    dispatch({\n      type: 'SET_FIELD_ERROR',\n      payload: {\n        field: field,\n        value: value\n      }\n    });\n  }, []);\n  var setFieldValue = useEventCallback(function (field, value, shouldValidate) {\n    dispatch({\n      type: 'SET_FIELD_VALUE',\n      payload: {\n        field: field,\n        value: value\n      }\n    });\n    var willValidate = shouldValidate === undefined ? validateOnChange : shouldValidate;\n    return willValidate ? validateFormWithHighPriority(setIn(state.values, field, value)) : Promise.resolve();\n  });\n  var executeChange = useCallback(function (eventOrTextValue, maybePath) {\n    // By default, assume that the first argument is a string. This allows us to use\n    // handleChange with React Native and React Native Web's onChangeText prop which\n    // provides just the value of the input.\n    var field = maybePath;\n    var val = eventOrTextValue;\n    var parsed; // If the first argument is not a string though, it has to be a synthetic React Event (or a fake one),\n    // so we handle like we would a normal HTML change event.\n\n    if (!isString(eventOrTextValue)) {\n      // If we can, persist the event\n      // @see https://reactjs.org/docs/events.html#event-pooling\n      if (eventOrTextValue.persist) {\n        eventOrTextValue.persist();\n      }\n\n      var target = eventOrTextValue.target ? eventOrTextValue.target : eventOrTextValue.currentTarget;\n      var type = target.type,\n          name = target.name,\n          id = target.id,\n          value = target.value,\n          checked = target.checked,\n          outerHTML = target.outerHTML,\n          options = target.options,\n          multiple = target.multiple;\n      field = maybePath ? maybePath : name ? name : id;\n\n      if (!field && process.env.NODE_ENV !== \"production\") {\n        warnAboutMissingIdentifier({\n          htmlContent: outerHTML,\n          documentationAnchorLink: 'handlechange-e-reactchangeeventany--void',\n          handlerName: 'handleChange'\n        });\n      }\n\n      val = /number|range/.test(type) ? (parsed = parseFloat(value), isNaN(parsed) ? '' : parsed) : /checkbox/.test(type) // checkboxes\n      ? getValueForCheckbox(getIn(state.values, field), checked, value) : options && multiple // <select multiple>\n      ? getSelectedValues(options) : value;\n    }\n\n    if (field) {\n      // Set form fields by name\n      setFieldValue(field, val);\n    }\n  }, [setFieldValue, state.values]);\n  var handleChange = useEventCallback(function (eventOrPath) {\n    if (isString(eventOrPath)) {\n      return function (event) {\n        return executeChange(event, eventOrPath);\n      };\n    } else {\n      executeChange(eventOrPath);\n    }\n  });\n  var setFieldTouched = useEventCallback(function (field, touched, shouldValidate) {\n    if (touched === void 0) {\n      touched = true;\n    }\n\n    dispatch({\n      type: 'SET_FIELD_TOUCHED',\n      payload: {\n        field: field,\n        value: touched\n      }\n    });\n    var willValidate = shouldValidate === undefined ? validateOnBlur : shouldValidate;\n    return willValidate ? validateFormWithHighPriority(state.values) : Promise.resolve();\n  });\n  var executeBlur = useCallback(function (e, path) {\n    if (e.persist) {\n      e.persist();\n    }\n\n    var _e$target = e.target,\n        name = _e$target.name,\n        id = _e$target.id,\n        outerHTML = _e$target.outerHTML;\n    var field = path ? path : name ? name : id;\n\n    if (!field && process.env.NODE_ENV !== \"production\") {\n      warnAboutMissingIdentifier({\n        htmlContent: outerHTML,\n        documentationAnchorLink: 'handleblur-e-any--void',\n        handlerName: 'handleBlur'\n      });\n    }\n\n    setFieldTouched(field, true);\n  }, [setFieldTouched]);\n  var handleBlur = useEventCallback(function (eventOrString) {\n    if (isString(eventOrString)) {\n      return function (event) {\n        return executeBlur(event, eventOrString);\n      };\n    } else {\n      executeBlur(eventOrString);\n    }\n  });\n  var setFormikState = useCallback(function (stateOrCb) {\n    if (isFunction(stateOrCb)) {\n      dispatch({\n        type: 'SET_FORMIK_STATE',\n        payload: stateOrCb\n      });\n    } else {\n      dispatch({\n        type: 'SET_FORMIK_STATE',\n        payload: function payload() {\n          return stateOrCb;\n        }\n      });\n    }\n  }, []);\n  var setStatus = useCallback(function (status) {\n    dispatch({\n      type: 'SET_STATUS',\n      payload: status\n    });\n  }, []);\n  var setSubmitting = useCallback(function (isSubmitting) {\n    dispatch({\n      type: 'SET_ISSUBMITTING',\n      payload: isSubmitting\n    });\n  }, []);\n  var submitForm = useEventCallback(function () {\n    dispatch({\n      type: 'SUBMIT_ATTEMPT'\n    });\n    return validateFormWithHighPriority().then(function (combinedErrors) {\n      // In case an error was thrown and passed to the resolved Promise,\n      // `combinedErrors` can be an instance of an Error. We need to check\n      // that and abort the submit.\n      // If we don't do that, calling `Object.keys(new Error())` yields an\n      // empty array, which causes the validation to pass and the form\n      // to be submitted.\n      var isInstanceOfError = combinedErrors instanceof Error;\n      var isActuallyValid = !isInstanceOfError && Object.keys(combinedErrors).length === 0;\n\n      if (isActuallyValid) {\n        // Proceed with submit...\n        //\n        // To respect sync submit fns, we can't simply wrap executeSubmit in a promise and\n        // _always_ dispatch SUBMIT_SUCCESS because isSubmitting would then always be false.\n        // This would be fine in simple cases, but make it impossible to disable submit\n        // buttons where people use callbacks or promises as side effects (which is basically\n        // all of v1 Formik code). Instead, recall that we are inside of a promise chain already,\n        //  so we can try/catch executeSubmit(), if it returns undefined, then just bail.\n        // If there are errors, throw em. Otherwise, wrap executeSubmit in a promise and handle\n        // cleanup of isSubmitting on behalf of the consumer.\n        var promiseOrUndefined;\n\n        try {\n          promiseOrUndefined = executeSubmit(); // Bail if it's sync, consumer is responsible for cleaning up\n          // via setSubmitting(false)\n\n          if (promiseOrUndefined === undefined) {\n            return;\n          }\n        } catch (error) {\n          throw error;\n        }\n\n        return Promise.resolve(promiseOrUndefined).then(function (result) {\n          if (!!isMounted.current) {\n            dispatch({\n              type: 'SUBMIT_SUCCESS'\n            });\n          }\n\n          return result;\n        })[\"catch\"](function (_errors) {\n          if (!!isMounted.current) {\n            dispatch({\n              type: 'SUBMIT_FAILURE'\n            }); // This is a legit error rejected by the onSubmit fn\n            // so we don't want to break the promise chain\n\n            throw _errors;\n          }\n        });\n      } else if (!!isMounted.current) {\n        // ^^^ Make sure Formik is still mounted before updating state\n        dispatch({\n          type: 'SUBMIT_FAILURE'\n        }); // throw combinedErrors;\n\n        if (isInstanceOfError) {\n          throw combinedErrors;\n        }\n      }\n\n      return;\n    });\n  });\n  var handleSubmit = useEventCallback(function (e) {\n    if (e && e.preventDefault && isFunction(e.preventDefault)) {\n      e.preventDefault();\n    }\n\n    if (e && e.stopPropagation && isFunction(e.stopPropagation)) {\n      e.stopPropagation();\n    } // Warn if form submission is triggered by a <button> without a\n    // specified `type` attribute during development. This mitigates\n    // a common gotcha in forms with both reset and submit buttons,\n    // where the dev forgets to add type=\"button\" to the reset button.\n\n\n    if (process.env.NODE_ENV !== \"production\" && typeof document !== 'undefined') {\n      // Safely get the active element (works with IE)\n      var activeElement = getActiveElement();\n\n      if (activeElement !== null && activeElement instanceof HTMLButtonElement) {\n        !(activeElement.attributes && activeElement.attributes.getNamedItem('type')) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'You submitted a Formik form using a button with an unspecified `type` attribute.  Most browsers default button elements to `type=\"submit\"`. If this is not a submit button, please add `type=\"button\"`.') : invariant(false) : void 0;\n      }\n    }\n\n    submitForm()[\"catch\"](function (reason) {\n      console.warn(\"Warning: An unhandled error was caught from submitForm()\", reason);\n    });\n  });\n  var imperativeMethods = {\n    resetForm: resetForm,\n    validateForm: validateFormWithHighPriority,\n    validateField: validateField,\n    setErrors: setErrors,\n    setFieldError: setFieldError,\n    setFieldTouched: setFieldTouched,\n    setFieldValue: setFieldValue,\n    setStatus: setStatus,\n    setSubmitting: setSubmitting,\n    setTouched: setTouched,\n    setValues: setValues,\n    setFormikState: setFormikState,\n    submitForm: submitForm\n  };\n  var executeSubmit = useEventCallback(function () {\n    return onSubmit(state.values, imperativeMethods);\n  });\n  var handleReset = useEventCallback(function (e) {\n    if (e && e.preventDefault && isFunction(e.preventDefault)) {\n      e.preventDefault();\n    }\n\n    if (e && e.stopPropagation && isFunction(e.stopPropagation)) {\n      e.stopPropagation();\n    }\n\n    resetForm();\n  });\n  var getFieldMeta = useCallback(function (name) {\n    return {\n      value: getIn(state.values, name),\n      error: getIn(state.errors, name),\n      touched: !!getIn(state.touched, name),\n      initialValue: getIn(initialValues.current, name),\n      initialTouched: !!getIn(initialTouched.current, name),\n      initialError: getIn(initialErrors.current, name)\n    };\n  }, [state.errors, state.touched, state.values]);\n  var getFieldHelpers = useCallback(function (name) {\n    return {\n      setValue: function setValue(value, shouldValidate) {\n        return setFieldValue(name, value, shouldValidate);\n      },\n      setTouched: function setTouched(value, shouldValidate) {\n        return setFieldTouched(name, value, shouldValidate);\n      },\n      setError: function setError(value) {\n        return setFieldError(name, value);\n      }\n    };\n  }, [setFieldValue, setFieldTouched, setFieldError]);\n  var getFieldProps = useCallback(function (nameOrOptions) {\n    var isAnObject = isObject(nameOrOptions);\n    var name = isAnObject ? nameOrOptions.name : nameOrOptions;\n    var valueState = getIn(state.values, name);\n    var field = {\n      name: name,\n      value: valueState,\n      onChange: handleChange,\n      onBlur: handleBlur\n    };\n\n    if (isAnObject) {\n      var type = nameOrOptions.type,\n          valueProp = nameOrOptions.value,\n          is = nameOrOptions.as,\n          multiple = nameOrOptions.multiple;\n\n      if (type === 'checkbox') {\n        if (valueProp === undefined) {\n          field.checked = !!valueState;\n        } else {\n          field.checked = !!(Array.isArray(valueState) && ~valueState.indexOf(valueProp));\n          field.value = valueProp;\n        }\n      } else if (type === 'radio') {\n        field.checked = valueState === valueProp;\n        field.value = valueProp;\n      } else if (is === 'select' && multiple) {\n        field.value = field.value || [];\n        field.multiple = true;\n      }\n    }\n\n    return field;\n  }, [handleBlur, handleChange, state.values]);\n  var dirty = useMemo(function () {\n    return !isEqual(initialValues.current, state.values);\n  }, [initialValues.current, state.values]);\n  var isValid = useMemo(function () {\n    return typeof isInitialValid !== 'undefined' ? dirty ? state.errors && Object.keys(state.errors).length === 0 : isInitialValid !== false && isFunction(isInitialValid) ? isInitialValid(props) : isInitialValid : state.errors && Object.keys(state.errors).length === 0;\n  }, [isInitialValid, dirty, state.errors, props]);\n\n  var ctx = _extends({}, state, {\n    initialValues: initialValues.current,\n    initialErrors: initialErrors.current,\n    initialTouched: initialTouched.current,\n    initialStatus: initialStatus.current,\n    handleBlur: handleBlur,\n    handleChange: handleChange,\n    handleReset: handleReset,\n    handleSubmit: handleSubmit,\n    resetForm: resetForm,\n    setErrors: setErrors,\n    setFormikState: setFormikState,\n    setFieldTouched: setFieldTouched,\n    setFieldValue: setFieldValue,\n    setFieldError: setFieldError,\n    setStatus: setStatus,\n    setSubmitting: setSubmitting,\n    setTouched: setTouched,\n    setValues: setValues,\n    submitForm: submitForm,\n    validateForm: validateFormWithHighPriority,\n    validateField: validateField,\n    isValid: isValid,\n    dirty: dirty,\n    unregisterField: unregisterField,\n    registerField: registerField,\n    getFieldProps: getFieldProps,\n    getFieldMeta: getFieldMeta,\n    getFieldHelpers: getFieldHelpers,\n    validateOnBlur: validateOnBlur,\n    validateOnChange: validateOnChange,\n    validateOnMount: validateOnMount\n  });\n\n  return ctx;\n}\nfunction Formik(props) {\n  var formikbag = useFormik(props);\n  var component = props.component,\n      children = props.children,\n      render = props.render,\n      innerRef = props.innerRef; // This allows folks to pass a ref to <Formik />\n\n  useImperativeHandle(innerRef, function () {\n    return formikbag;\n  });\n\n  if (process.env.NODE_ENV !== \"production\") {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    useEffect(function () {\n      !!props.render ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"<Formik render> has been deprecated and will be removed in future versions of Formik. Please use a child callback function instead. To get rid of this warning, replace <Formik render={(props) => ...} /> with <Formik>{(props) => ...}</Formik>\") : invariant(false) : void 0; // eslint-disable-next-line\n    }, []);\n  }\n\n  return createElement(FormikProvider, {\n    value: formikbag\n  }, component ? createElement(component, formikbag) : render ? render(formikbag) : children // children come last, always called\n  ? isFunction(children) ? children(formikbag) : !isEmptyChildren(children) ? Children.only(children) : null : null);\n}\n\nfunction warnAboutMissingIdentifier(_ref4) {\n  var htmlContent = _ref4.htmlContent,\n      documentationAnchorLink = _ref4.documentationAnchorLink,\n      handlerName = _ref4.handlerName;\n  console.warn(\"Warning: Formik called `\" + handlerName + \"`, but you forgot to pass an `id` or `name` attribute to your input:\\n    \" + htmlContent + \"\\n    Formik cannot determine which value to update. For more info see https://formik.org/docs/api/formik#\" + documentationAnchorLink + \"\\n  \");\n}\n/**\r\n * Transform Yup ValidationError to a more usable object\r\n */\n\n\nfunction yupToFormErrors(yupError) {\n  var errors = {};\n\n  if (yupError.inner) {\n    if (yupError.inner.length === 0) {\n      return setIn(errors, yupError.path, yupError.message);\n    }\n\n    for (var _iterator = yupError.inner, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {\n      var _ref5;\n\n      if (_isArray) {\n        if (_i >= _iterator.length) break;\n        _ref5 = _iterator[_i++];\n      } else {\n        _i = _iterator.next();\n        if (_i.done) break;\n        _ref5 = _i.value;\n      }\n\n      var err = _ref5;\n\n      if (!getIn(errors, err.path)) {\n        errors = setIn(errors, err.path, err.message);\n      }\n    }\n  }\n\n  return errors;\n}\n/**\r\n * Validate a yup schema.\r\n */\n\nfunction validateYupSchema(values, schema, sync, context) {\n  if (sync === void 0) {\n    sync = false;\n  }\n\n  var normalizedValues = prepareDataForValidation(values);\n  return schema[sync ? 'validateSync' : 'validate'](normalizedValues, {\n    abortEarly: false,\n    context: context || normalizedValues\n  });\n}\n/**\r\n * Recursively prepare values.\r\n */\n\nfunction prepareDataForValidation(values) {\n  var data = Array.isArray(values) ? [] : {};\n\n  for (var k in values) {\n    if (Object.prototype.hasOwnProperty.call(values, k)) {\n      var key = String(k);\n\n      if (Array.isArray(values[key]) === true) {\n        data[key] = values[key].map(function (value) {\n          if (Array.isArray(value) === true || isPlainObject(value)) {\n            return prepareDataForValidation(value);\n          } else {\n            return value !== '' ? value : undefined;\n          }\n        });\n      } else if (isPlainObject(values[key])) {\n        data[key] = prepareDataForValidation(values[key]);\n      } else {\n        data[key] = values[key] !== '' ? values[key] : undefined;\n      }\n    }\n  }\n\n  return data;\n}\n/**\r\n * deepmerge array merging algorithm\r\n * https://github.com/KyleAMathews/deepmerge#combine-array\r\n */\n\nfunction arrayMerge(target, source, options) {\n  var destination = target.slice();\n  source.forEach(function merge(e, i) {\n    if (typeof destination[i] === 'undefined') {\n      var cloneRequested = options.clone !== false;\n      var shouldClone = cloneRequested && options.isMergeableObject(e);\n      destination[i] = shouldClone ? deepmerge(Array.isArray(e) ? [] : {}, e, options) : e;\n    } else if (options.isMergeableObject(e)) {\n      destination[i] = deepmerge(target[i], e, options);\n    } else if (target.indexOf(e) === -1) {\n      destination.push(e);\n    }\n  });\n  return destination;\n}\n/** Return multi select values based on an array of options */\n\n\nfunction getSelectedValues(options) {\n  return Array.from(options).filter(function (el) {\n    return el.selected;\n  }).map(function (el) {\n    return el.value;\n  });\n}\n/** Return the next value for a checkbox */\n\n\nfunction getValueForCheckbox(currentValue, checked, valueProp) {\n  // If the current value was a boolean, return a boolean\n  if (typeof currentValue === 'boolean') {\n    return Boolean(checked);\n  } // If the currentValue was not a boolean we want to return an array\n\n\n  var currentArrayOfValues = [];\n  var isValueInArray = false;\n  var index = -1;\n\n  if (!Array.isArray(currentValue)) {\n    // eslint-disable-next-line eqeqeq\n    if (!valueProp || valueProp == 'true' || valueProp == 'false') {\n      return Boolean(checked);\n    }\n  } else {\n    // If the current value is already an array, use it\n    currentArrayOfValues = currentValue;\n    index = currentValue.indexOf(valueProp);\n    isValueInArray = index >= 0;\n  } // If the checkbox was checked and the value is not already present in the aray we want to add the new value to the array of values\n\n\n  if (checked && valueProp && !isValueInArray) {\n    return currentArrayOfValues.concat(valueProp);\n  } // If the checkbox was unchecked and the value is not in the array, simply return the already existing array of values\n\n\n  if (!isValueInArray) {\n    return currentArrayOfValues;\n  } // If the checkbox was unchecked and the value is in the array, remove the value and return the array\n\n\n  return currentArrayOfValues.slice(0, index).concat(currentArrayOfValues.slice(index + 1));\n} // React currently throws a warning when using useLayoutEffect on the server.\n// To get around it, we can conditionally useEffect on the server (no-op) and\n// useLayoutEffect in the browser.\n// @see https://gist.github.com/gaearon/e7d97cdf38a2907924ea12e4ebdf3c85\n\n\nvar useIsomorphicLayoutEffect = typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined' ? useLayoutEffect : useEffect;\n\nfunction useEventCallback(fn) {\n  var ref = useRef(fn); // we copy a ref to the callback scoped to the current state/props on each render\n\n  useIsomorphicLayoutEffect(function () {\n    ref.current = fn;\n  });\n  return useCallback(function () {\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    return ref.current.apply(void 0, args);\n  }, []);\n}\n\nfunction useField(propsOrFieldName) {\n  var formik = useFormikContext();\n  var getFieldProps = formik.getFieldProps,\n      getFieldMeta = formik.getFieldMeta,\n      getFieldHelpers = formik.getFieldHelpers,\n      registerField = formik.registerField,\n      unregisterField = formik.unregisterField;\n  var isAnObject = isObject(propsOrFieldName); // Normalize propsOrFieldName to FieldHookConfig<Val>\n\n  var props = isAnObject ? propsOrFieldName : {\n    name: propsOrFieldName\n  };\n  var fieldName = props.name,\n      validateFn = props.validate;\n  useEffect(function () {\n    if (fieldName) {\n      registerField(fieldName, {\n        validate: validateFn\n      });\n    }\n\n    return function () {\n      if (fieldName) {\n        unregisterField(fieldName);\n      }\n    };\n  }, [registerField, unregisterField, fieldName, validateFn]);\n\n  if (process.env.NODE_ENV !== \"production\") {\n    !formik ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'useField() / <Field /> must be used underneath a <Formik> component or withFormik() higher order component') : invariant(false) : void 0;\n  }\n\n  !fieldName ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Invalid field name. Either pass `useField` a string or an object containing a `name` key.') : invariant(false) : void 0;\n  var fieldHelpers = useMemo(function () {\n    return getFieldHelpers(fieldName);\n  }, [getFieldHelpers, fieldName]);\n  return [getFieldProps(props), getFieldMeta(fieldName), fieldHelpers];\n}\nfunction Field(_ref) {\n  var validate = _ref.validate,\n      name = _ref.name,\n      render = _ref.render,\n      children = _ref.children,\n      is = _ref.as,\n      component = _ref.component,\n      className = _ref.className,\n      props = _objectWithoutPropertiesLoose(_ref, [\"validate\", \"name\", \"render\", \"children\", \"as\", \"component\", \"className\"]);\n\n  var _useFormikContext = useFormikContext(),\n      formik = _objectWithoutPropertiesLoose(_useFormikContext, [\"validate\", \"validationSchema\"]);\n\n  if (process.env.NODE_ENV !== \"production\") {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    useEffect(function () {\n      !!render ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"<Field render> has been deprecated and will be removed in future versions of Formik. Please use a child callback function instead. To get rid of this warning, replace <Field name=\\\"\" + name + \"\\\" render={({field, form}) => ...} /> with <Field name=\\\"\" + name + \"\\\">{({field, form, meta}) => ...}</Field>\") : invariant(false) : void 0;\n      !!(is && children && isFunction(children)) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'You should not use <Field as> and <Field children> as a function in the same <Field> component; <Field as> will be ignored.') : invariant(false) : void 0;\n      !!(component && children && isFunction(children)) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'You should not use <Field component> and <Field children> as a function in the same <Field> component; <Field component> will be ignored.') : invariant(false) : void 0;\n      !!(render && children && !isEmptyChildren(children)) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'You should not use <Field render> and <Field children> in the same <Field> component; <Field children> will be ignored') : invariant(false) : void 0; // eslint-disable-next-line\n    }, []);\n  } // Register field and field-level validation with parent <Formik>\n\n\n  var registerField = formik.registerField,\n      unregisterField = formik.unregisterField;\n  useEffect(function () {\n    registerField(name, {\n      validate: validate\n    });\n    return function () {\n      unregisterField(name);\n    };\n  }, [registerField, unregisterField, name, validate]);\n  var field = formik.getFieldProps(_extends({\n    name: name\n  }, props));\n  var meta = formik.getFieldMeta(name);\n  var legacyBag = {\n    field: field,\n    form: formik\n  };\n\n  if (render) {\n    return render(_extends({}, legacyBag, {\n      meta: meta\n    }));\n  }\n\n  if (isFunction(children)) {\n    return children(_extends({}, legacyBag, {\n      meta: meta\n    }));\n  }\n\n  if (component) {\n    // This behavior is backwards compat with earlier Formik 0.9 to 1.x\n    if (typeof component === 'string') {\n      var innerRef = props.innerRef,\n          rest = _objectWithoutPropertiesLoose(props, [\"innerRef\"]);\n\n      return createElement(component, _extends({\n        ref: innerRef\n      }, field, rest, {\n        className: className\n      }), children);\n    } // We don't pass `meta` for backwards compat\n\n\n    return createElement(component, _extends({\n      field: field,\n      form: formik\n    }, props, {\n      className: className\n    }), children);\n  } // default to input here so we can check for both `as` and `children` above\n\n\n  var asElement = is || 'input';\n\n  if (typeof asElement === 'string') {\n    var _innerRef = props.innerRef,\n        _rest = _objectWithoutPropertiesLoose(props, [\"innerRef\"]);\n\n    return createElement(asElement, _extends({\n      ref: _innerRef\n    }, field, _rest, {\n      className: className\n    }), children);\n  }\n\n  return createElement(asElement, _extends({}, field, props, {\n    className: className\n  }), children);\n}\n\nvar Form = /*#__PURE__*/forwardRef(function (props, ref) {\n  // iOS needs an \"action\" attribute for nice input: https://stackoverflow.com/a/39485162/406725\n  // We default the action to \"#\" in case the preventDefault fails (just updates the URL hash)\n  var action = props.action,\n      rest = _objectWithoutPropertiesLoose(props, [\"action\"]);\n\n  var _action = action != null ? action : '#';\n\n  var _useFormikContext = useFormikContext(),\n      handleReset = _useFormikContext.handleReset,\n      handleSubmit = _useFormikContext.handleSubmit;\n\n  return createElement(\"form\", _extends({\n    onSubmit: handleSubmit,\n    ref: ref,\n    onReset: handleReset,\n    action: _action\n  }, rest));\n});\nForm.displayName = 'Form';\n\n/**\r\n * A public higher-order component to access the imperative API\r\n */\n\nfunction withFormik(_ref) {\n  var _ref$mapPropsToValues = _ref.mapPropsToValues,\n      mapPropsToValues = _ref$mapPropsToValues === void 0 ? function (vanillaProps) {\n    var val = {};\n\n    for (var k in vanillaProps) {\n      if (vanillaProps.hasOwnProperty(k) && typeof vanillaProps[k] !== 'function') {\n        // @todo TypeScript fix\n        val[k] = vanillaProps[k];\n      }\n    }\n\n    return val;\n  } : _ref$mapPropsToValues,\n      config = _objectWithoutPropertiesLoose(_ref, [\"mapPropsToValues\"]);\n\n  return function createFormik(Component$1) {\n    var componentDisplayName = Component$1.displayName || Component$1.name || Component$1.constructor && Component$1.constructor.name || 'Component';\n    /**\r\n     * We need to use closures here for to provide the wrapped component's props to\r\n     * the respective withFormik config methods.\r\n     */\n\n    var C = /*#__PURE__*/function (_React$Component) {\n      _inheritsLoose(C, _React$Component);\n\n      function C() {\n        var _this;\n\n        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n          args[_key] = arguments[_key];\n        }\n\n        _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;\n\n        _this.validate = function (values) {\n          return config.validate(values, _this.props);\n        };\n\n        _this.validationSchema = function () {\n          return isFunction(config.validationSchema) ? config.validationSchema(_this.props) : config.validationSchema;\n        };\n\n        _this.handleSubmit = function (values, actions) {\n          return config.handleSubmit(values, _extends({}, actions, {\n            props: _this.props\n          }));\n        };\n\n        _this.renderFormComponent = function (formikProps) {\n          return createElement(Component$1, _extends({}, _this.props, formikProps));\n        };\n\n        return _this;\n      }\n\n      var _proto = C.prototype;\n\n      _proto.render = function render() {\n        var _this$props = this.props,\n            props = _objectWithoutPropertiesLoose(_this$props, [\"children\"]);\n\n        return createElement(Formik, _extends({}, props, config, {\n          validate: config.validate && this.validate,\n          validationSchema: config.validationSchema && this.validationSchema,\n          initialValues: mapPropsToValues(this.props),\n          initialStatus: config.mapPropsToStatus && config.mapPropsToStatus(this.props),\n          initialErrors: config.mapPropsToErrors && config.mapPropsToErrors(this.props),\n          initialTouched: config.mapPropsToTouched && config.mapPropsToTouched(this.props),\n          onSubmit: this.handleSubmit,\n          children: this.renderFormComponent\n        }));\n      };\n\n      return C;\n    }(Component);\n\n    C.displayName = \"WithFormik(\" + componentDisplayName + \")\";\n    return hoistNonReactStatics(C, Component$1 // cast type to ComponentClass (even if SFC)\n    );\n  };\n}\n\n/**\r\n * Connect any component to Formik context, and inject as a prop called `formik`;\r\n * @param Comp React Component\r\n */\n\nfunction connect(Comp) {\n  var C = function C(props) {\n    return createElement(FormikConsumer, null, function (formik) {\n      !!!formik ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"Formik context is undefined, please verify you are rendering <Form>, <Field>, <FastField>, <FieldArray>, or your custom context-using component as a child of a <Formik> component. Component name: \" + Comp.name) : invariant(false) : void 0;\n      return createElement(Comp, _extends({}, props, {\n        formik: formik\n      }));\n    });\n  };\n\n  var componentDisplayName = Comp.displayName || Comp.name || Comp.constructor && Comp.constructor.name || 'Component'; // Assign Comp to C.WrappedComponent so we can access the inner component in tests\n  // For example, <Field.WrappedComponent /> gets us <FieldInner/>\n\n  C.WrappedComponent = Comp;\n  C.displayName = \"FormikConnect(\" + componentDisplayName + \")\";\n  return hoistNonReactStatics(C, Comp // cast type to ComponentClass (even if SFC)\n  );\n}\n\n/**\r\n * Some array helpers!\r\n */\n\nvar move = function move(array, from, to) {\n  var copy = copyArrayLike(array);\n  var value = copy[from];\n  copy.splice(from, 1);\n  copy.splice(to, 0, value);\n  return copy;\n};\nvar swap = function swap(arrayLike, indexA, indexB) {\n  var copy = copyArrayLike(arrayLike);\n  var a = copy[indexA];\n  copy[indexA] = copy[indexB];\n  copy[indexB] = a;\n  return copy;\n};\nvar insert = function insert(arrayLike, index, value) {\n  var copy = copyArrayLike(arrayLike);\n  copy.splice(index, 0, value);\n  return copy;\n};\nvar replace = function replace(arrayLike, index, value) {\n  var copy = copyArrayLike(arrayLike);\n  copy[index] = value;\n  return copy;\n};\n\nvar copyArrayLike = function copyArrayLike(arrayLike) {\n  if (!arrayLike) {\n    return [];\n  } else if (Array.isArray(arrayLike)) {\n    return [].concat(arrayLike);\n  } else {\n    var maxIndex = Object.keys(arrayLike).map(function (key) {\n      return parseInt(key);\n    }).reduce(function (max, el) {\n      return el > max ? el : max;\n    }, 0);\n    return Array.from(_extends({}, arrayLike, {\n      length: maxIndex + 1\n    }));\n  }\n};\n\nvar createAlterationHandler = function createAlterationHandler(alteration, defaultFunction) {\n  var fn = typeof alteration === 'function' ? alteration : defaultFunction;\n  return function (data) {\n    if (Array.isArray(data) || isObject(data)) {\n      var clone = copyArrayLike(data);\n      return fn(clone);\n    } // This can be assumed to be a primitive, which\n    // is a case for top level validation errors\n\n\n    return data;\n  };\n};\n\nvar FieldArrayInner = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(FieldArrayInner, _React$Component);\n\n  function FieldArrayInner(props) {\n    var _this;\n\n    _this = _React$Component.call(this, props) || this; // We need TypeScript generics on these, so we'll bind them in the constructor\n    // @todo Fix TS 3.2.1\n\n    _this.updateArrayField = function (fn, alterTouched, alterErrors) {\n      var _this$props = _this.props,\n          name = _this$props.name,\n          setFormikState = _this$props.formik.setFormikState;\n      setFormikState(function (prevState) {\n        var updateErrors = createAlterationHandler(alterErrors, fn);\n        var updateTouched = createAlterationHandler(alterTouched, fn); // values fn should be executed before updateErrors and updateTouched,\n        // otherwise it causes an error with unshift.\n\n        var values = setIn(prevState.values, name, fn(getIn(prevState.values, name)));\n        var fieldError = alterErrors ? updateErrors(getIn(prevState.errors, name)) : undefined;\n        var fieldTouched = alterTouched ? updateTouched(getIn(prevState.touched, name)) : undefined;\n\n        if (isEmptyArray(fieldError)) {\n          fieldError = undefined;\n        }\n\n        if (isEmptyArray(fieldTouched)) {\n          fieldTouched = undefined;\n        }\n\n        return _extends({}, prevState, {\n          values: values,\n          errors: alterErrors ? setIn(prevState.errors, name, fieldError) : prevState.errors,\n          touched: alterTouched ? setIn(prevState.touched, name, fieldTouched) : prevState.touched\n        });\n      });\n    };\n\n    _this.push = function (value) {\n      return _this.updateArrayField(function (arrayLike) {\n        return [].concat(copyArrayLike(arrayLike), [cloneDeep(value)]);\n      }, false, false);\n    };\n\n    _this.handlePush = function (value) {\n      return function () {\n        return _this.push(value);\n      };\n    };\n\n    _this.swap = function (indexA, indexB) {\n      return _this.updateArrayField(function (array) {\n        return swap(array, indexA, indexB);\n      }, true, true);\n    };\n\n    _this.handleSwap = function (indexA, indexB) {\n      return function () {\n        return _this.swap(indexA, indexB);\n      };\n    };\n\n    _this.move = function (from, to) {\n      return _this.updateArrayField(function (array) {\n        return move(array, from, to);\n      }, true, true);\n    };\n\n    _this.handleMove = function (from, to) {\n      return function () {\n        return _this.move(from, to);\n      };\n    };\n\n    _this.insert = function (index, value) {\n      return _this.updateArrayField(function (array) {\n        return insert(array, index, value);\n      }, function (array) {\n        return insert(array, index, null);\n      }, function (array) {\n        return insert(array, index, null);\n      });\n    };\n\n    _this.handleInsert = function (index, value) {\n      return function () {\n        return _this.insert(index, value);\n      };\n    };\n\n    _this.replace = function (index, value) {\n      return _this.updateArrayField(function (array) {\n        return replace(array, index, value);\n      }, false, false);\n    };\n\n    _this.handleReplace = function (index, value) {\n      return function () {\n        return _this.replace(index, value);\n      };\n    };\n\n    _this.unshift = function (value) {\n      var length = -1;\n\n      _this.updateArrayField(function (array) {\n        var arr = array ? [value].concat(array) : [value];\n        length = arr.length;\n        return arr;\n      }, function (array) {\n        return array ? [null].concat(array) : [null];\n      }, function (array) {\n        return array ? [null].concat(array) : [null];\n      });\n\n      return length;\n    };\n\n    _this.handleUnshift = function (value) {\n      return function () {\n        return _this.unshift(value);\n      };\n    };\n\n    _this.handleRemove = function (index) {\n      return function () {\n        return _this.remove(index);\n      };\n    };\n\n    _this.handlePop = function () {\n      return function () {\n        return _this.pop();\n      };\n    };\n\n    _this.remove = _this.remove.bind(_assertThisInitialized(_this));\n    _this.pop = _this.pop.bind(_assertThisInitialized(_this));\n    return _this;\n  }\n\n  var _proto = FieldArrayInner.prototype;\n\n  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {\n    if (this.props.validateOnChange && this.props.formik.validateOnChange && !isEqual(getIn(prevProps.formik.values, prevProps.name), getIn(this.props.formik.values, this.props.name))) {\n      this.props.formik.validateForm(this.props.formik.values);\n    }\n  };\n\n  _proto.remove = function remove(index) {\n    // We need to make sure we also remove relevant pieces of `touched` and `errors`\n    var result;\n    this.updateArrayField( // so this gets call 3 times\n    function (array) {\n      var copy = array ? copyArrayLike(array) : [];\n\n      if (!result) {\n        result = copy[index];\n      }\n\n      if (isFunction(copy.splice)) {\n        copy.splice(index, 1);\n      } // if the array only includes undefined values we have to return an empty array\n\n\n      return isFunction(copy.every) ? copy.every(function (v) {\n        return v === undefined;\n      }) ? [] : copy : copy;\n    }, true, true);\n    return result;\n  };\n\n  _proto.pop = function pop() {\n    // Remove relevant pieces of `touched` and `errors` too!\n    var result;\n    this.updateArrayField( // so this gets call 3 times\n    function (array) {\n      var tmp = array.slice();\n\n      if (!result) {\n        result = tmp && tmp.pop && tmp.pop();\n      }\n\n      return tmp;\n    }, true, true);\n    return result;\n  };\n\n  _proto.render = function render() {\n    var arrayHelpers = {\n      push: this.push,\n      pop: this.pop,\n      swap: this.swap,\n      move: this.move,\n      insert: this.insert,\n      replace: this.replace,\n      unshift: this.unshift,\n      remove: this.remove,\n      handlePush: this.handlePush,\n      handlePop: this.handlePop,\n      handleSwap: this.handleSwap,\n      handleMove: this.handleMove,\n      handleInsert: this.handleInsert,\n      handleReplace: this.handleReplace,\n      handleUnshift: this.handleUnshift,\n      handleRemove: this.handleRemove\n    };\n\n    var _this$props2 = this.props,\n        component = _this$props2.component,\n        render = _this$props2.render,\n        children = _this$props2.children,\n        name = _this$props2.name,\n        _this$props2$formik = _this$props2.formik,\n        restOfFormik = _objectWithoutPropertiesLoose(_this$props2$formik, [\"validate\", \"validationSchema\"]);\n\n    var props = _extends({}, arrayHelpers, {\n      form: restOfFormik,\n      name: name\n    });\n\n    return component ? createElement(component, props) : render ? render(props) : children // children come last, always called\n    ? typeof children === 'function' ? children(props) : !isEmptyChildren(children) ? Children.only(children) : null : null;\n  };\n\n  return FieldArrayInner;\n}(Component);\n\nFieldArrayInner.defaultProps = {\n  validateOnChange: true\n};\nvar FieldArray = /*#__PURE__*/connect(FieldArrayInner);\n\nvar ErrorMessageImpl = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(ErrorMessageImpl, _React$Component);\n\n  function ErrorMessageImpl() {\n    return _React$Component.apply(this, arguments) || this;\n  }\n\n  var _proto = ErrorMessageImpl.prototype;\n\n  _proto.shouldComponentUpdate = function shouldComponentUpdate(props) {\n    if (getIn(this.props.formik.errors, this.props.name) !== getIn(props.formik.errors, this.props.name) || getIn(this.props.formik.touched, this.props.name) !== getIn(props.formik.touched, this.props.name) || Object.keys(this.props).length !== Object.keys(props).length) {\n      return true;\n    } else {\n      return false;\n    }\n  };\n\n  _proto.render = function render() {\n    var _this$props = this.props,\n        component = _this$props.component,\n        formik = _this$props.formik,\n        render = _this$props.render,\n        children = _this$props.children,\n        name = _this$props.name,\n        rest = _objectWithoutPropertiesLoose(_this$props, [\"component\", \"formik\", \"render\", \"children\", \"name\"]);\n\n    var touch = getIn(formik.touched, name);\n    var error = getIn(formik.errors, name);\n    return !!touch && !!error ? render ? isFunction(render) ? render(error) : null : children ? isFunction(children) ? children(error) : null : component ? createElement(component, rest, error) : error : null;\n  };\n\n  return ErrorMessageImpl;\n}(Component);\n\nvar ErrorMessage = /*#__PURE__*/connect(ErrorMessageImpl);\n\n/**\r\n * Custom Field component for quickly hooking into Formik\r\n * context and wiring up forms.\r\n */\n\nvar FastFieldInner = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(FastFieldInner, _React$Component);\n\n  function FastFieldInner(props) {\n    var _this;\n\n    _this = _React$Component.call(this, props) || this;\n    var render = props.render,\n        children = props.children,\n        component = props.component,\n        is = props.as,\n        name = props.name;\n    !!render ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"<FastField render> has been deprecated. Please use a child callback function instead: <FastField name={\" + name + \"}>{props => ...}</FastField> instead.\") : invariant(false) : void 0;\n    !!(component && render) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'You should not use <FastField component> and <FastField render> in the same <FastField> component; <FastField component> will be ignored') : invariant(false) : void 0;\n    !!(is && children && isFunction(children)) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'You should not use <FastField as> and <FastField children> as a function in the same <FastField> component; <FastField as> will be ignored.') : invariant(false) : void 0;\n    !!(component && children && isFunction(children)) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'You should not use <FastField component> and <FastField children> as a function in the same <FastField> component; <FastField component> will be ignored.') : invariant(false) : void 0;\n    !!(render && children && !isEmptyChildren(children)) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'You should not use <FastField render> and <FastField children> in the same <FastField> component; <FastField children> will be ignored') : invariant(false) : void 0;\n    return _this;\n  }\n\n  var _proto = FastFieldInner.prototype;\n\n  _proto.shouldComponentUpdate = function shouldComponentUpdate(props) {\n    if (this.props.shouldUpdate) {\n      return this.props.shouldUpdate(props, this.props);\n    } else if (props.name !== this.props.name || getIn(props.formik.values, this.props.name) !== getIn(this.props.formik.values, this.props.name) || getIn(props.formik.errors, this.props.name) !== getIn(this.props.formik.errors, this.props.name) || getIn(props.formik.touched, this.props.name) !== getIn(this.props.formik.touched, this.props.name) || Object.keys(this.props).length !== Object.keys(props).length || props.formik.isSubmitting !== this.props.formik.isSubmitting) {\n      return true;\n    } else {\n      return false;\n    }\n  };\n\n  _proto.componentDidMount = function componentDidMount() {\n    // Register the Field with the parent Formik. Parent will cycle through\n    // registered Field's validate fns right prior to submit\n    this.props.formik.registerField(this.props.name, {\n      validate: this.props.validate\n    });\n  };\n\n  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {\n    if (this.props.name !== prevProps.name) {\n      this.props.formik.unregisterField(prevProps.name);\n      this.props.formik.registerField(this.props.name, {\n        validate: this.props.validate\n      });\n    }\n\n    if (this.props.validate !== prevProps.validate) {\n      this.props.formik.registerField(this.props.name, {\n        validate: this.props.validate\n      });\n    }\n  };\n\n  _proto.componentWillUnmount = function componentWillUnmount() {\n    this.props.formik.unregisterField(this.props.name);\n  };\n\n  _proto.render = function render() {\n    var _this$props = this.props,\n        name = _this$props.name,\n        render = _this$props.render,\n        is = _this$props.as,\n        children = _this$props.children,\n        component = _this$props.component,\n        formik = _this$props.formik,\n        props = _objectWithoutPropertiesLoose(_this$props, [\"validate\", \"name\", \"render\", \"as\", \"children\", \"component\", \"shouldUpdate\", \"formik\"]);\n\n    var restOfFormik = _objectWithoutPropertiesLoose(formik, [\"validate\", \"validationSchema\"]);\n\n    var field = formik.getFieldProps(_extends({\n      name: name\n    }, props));\n    var meta = {\n      value: getIn(formik.values, name),\n      error: getIn(formik.errors, name),\n      touched: !!getIn(formik.touched, name),\n      initialValue: getIn(formik.initialValues, name),\n      initialTouched: !!getIn(formik.initialTouched, name),\n      initialError: getIn(formik.initialErrors, name)\n    };\n    var bag = {\n      field: field,\n      meta: meta,\n      form: restOfFormik\n    };\n\n    if (render) {\n      return render(bag);\n    }\n\n    if (isFunction(children)) {\n      return children(bag);\n    }\n\n    if (component) {\n      // This behavior is backwards compat with earlier Formik 0.9 to 1.x\n      if (typeof component === 'string') {\n        var innerRef = props.innerRef,\n            rest = _objectWithoutPropertiesLoose(props, [\"innerRef\"]);\n\n        return createElement(component, _extends({\n          ref: innerRef\n        }, field, rest), children);\n      } // We don't pass `meta` for backwards compat\n\n\n      return createElement(component, _extends({\n        field: field,\n        form: formik\n      }, props), children);\n    } // default to input here so we can check for both `as` and `children` above\n\n\n    var asElement = is || 'input';\n\n    if (typeof asElement === 'string') {\n      var _innerRef = props.innerRef,\n          _rest = _objectWithoutPropertiesLoose(props, [\"innerRef\"]);\n\n      return createElement(asElement, _extends({\n        ref: _innerRef\n      }, field, _rest), children);\n    }\n\n    return createElement(asElement, _extends({}, field, props), children);\n  };\n\n  return FastFieldInner;\n}(Component);\n\nvar FastField = /*#__PURE__*/connect(FastFieldInner);\n\nexport { ErrorMessage, FastField, Field, FieldArray, Form, Formik, FormikConsumer, FormikContext, FormikProvider, connect, getActiveElement, getIn, insert, isEmptyArray, isEmptyChildren, isFunction, isInputEvent, isInteger, isNaN$1 as isNaN, isObject, isPromise, isString, move, prepareDataForValidation, replace, setIn, setNestedObjectValues, swap, useField, useFormik, useFormikContext, validateYupSchema, withFormik, yupToFormErrors };\n//# sourceMappingURL=formik.esm.js.map\n","'use strict';\n\nvar isArray = Array.isArray;\nvar keyList = Object.keys;\nvar hasProp = Object.prototype.hasOwnProperty;\nvar hasElementType = typeof Element !== 'undefined';\n\nfunction equal(a, b) {\n  // fast-deep-equal index.js 2.0.1\n  if (a === b) return true;\n\n  if (a && b && typeof a == 'object' && typeof b == 'object') {\n    var arrA = isArray(a)\n      , arrB = isArray(b)\n      , i\n      , length\n      , key;\n\n    if (arrA && arrB) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0;)\n        if (!equal(a[i], b[i])) return false;\n      return true;\n    }\n\n    if (arrA != arrB) return false;\n\n    var dateA = a instanceof Date\n      , dateB = b instanceof Date;\n    if (dateA != dateB) return false;\n    if (dateA && dateB) return a.getTime() == b.getTime();\n\n    var regexpA = a instanceof RegExp\n      , regexpB = b instanceof RegExp;\n    if (regexpA != regexpB) return false;\n    if (regexpA && regexpB) return a.toString() == b.toString();\n\n    var keys = keyList(a);\n    length = keys.length;\n\n    if (length !== keyList(b).length)\n      return false;\n\n    for (i = length; i-- !== 0;)\n      if (!hasProp.call(b, keys[i])) return false;\n    // end fast-deep-equal\n\n    // start react-fast-compare\n    // custom handling for DOM elements\n    if (hasElementType && a instanceof Element && b instanceof Element)\n      return a === b;\n\n    // custom handling for React\n    for (i = length; i-- !== 0;) {\n      key = keys[i];\n      if (key === '_owner' && a.$$typeof) {\n        // React-specific: avoid traversing React elements' _owner.\n        //  _owner contains circular references\n        // and is not needed when comparing the actual elements (and not their owners)\n        // .$$typeof and ._store on just reasonable markers of a react element\n        continue;\n      } else {\n        // all other properties should be traversed as usual\n        if (!equal(a[key], b[key])) return false;\n      }\n    }\n    // end react-fast-compare\n\n    // fast-deep-equal index.js 2.0.1\n    return true;\n  }\n\n  return a !== a && b !== b;\n}\n// end fast-deep-equal\n\nmodule.exports = function exportedEqual(a, b) {\n  try {\n    return equal(a, b);\n  } catch (error) {\n    if ((error.message && error.message.match(/stack|recursion/i)) || (error.number === -2146828260)) {\n      // warn on circular references, don't crash\n      // browsers give this different errors name and messages:\n      // chrome/safari: \"RangeError\", \"Maximum call stack size exceeded\"\n      // firefox: \"InternalError\", too much recursion\"\n      // edge: \"Error\", \"Out of stack space\"\n      console.warn('Warning: react-fast-compare does not handle circular references.', error.name, error.message);\n      return false;\n    }\n    // some other error. we should definitely know about these\n    throw error;\n  }\n};\n","import { getSideAxis, getAlignmentAxis, getAxisLength, getSide, getAlignment, evaluate, getPaddingObject, rectToClientRect, min, clamp, placements, getAlignmentSides, getOppositeAlignmentPlacement, getOppositePlacement, getExpandedPlacements, getOppositeAxisPlacements, sides, max, getOppositeAxis } from '@floating-ui/utils';\nexport { rectToClientRect } from '@floating-ui/utils';\n\nfunction computeCoordsFromPlacement(_ref, placement, rtl) {\n  let {\n    reference,\n    floating\n  } = _ref;\n  const sideAxis = getSideAxis(placement);\n  const alignmentAxis = getAlignmentAxis(placement);\n  const alignLength = getAxisLength(alignmentAxis);\n  const side = getSide(placement);\n  const isVertical = sideAxis === 'y';\n  const commonX = reference.x + reference.width / 2 - floating.width / 2;\n  const commonY = reference.y + reference.height / 2 - floating.height / 2;\n  const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;\n  let coords;\n  switch (side) {\n    case 'top':\n      coords = {\n        x: commonX,\n        y: reference.y - floating.height\n      };\n      break;\n    case 'bottom':\n      coords = {\n        x: commonX,\n        y: reference.y + reference.height\n      };\n      break;\n    case 'right':\n      coords = {\n        x: reference.x + reference.width,\n        y: commonY\n      };\n      break;\n    case 'left':\n      coords = {\n        x: reference.x - floating.width,\n        y: commonY\n      };\n      break;\n    default:\n      coords = {\n        x: reference.x,\n        y: reference.y\n      };\n  }\n  switch (getAlignment(placement)) {\n    case 'start':\n      coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);\n      break;\n    case 'end':\n      coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);\n      break;\n  }\n  return coords;\n}\n\n/**\n * Computes the `x` and `y` coordinates that will place the floating element\n * next to a given reference element.\n *\n * This export does not have any `platform` interface logic. You will need to\n * write one for the platform you are using Floating UI with.\n */\nconst computePosition = async (reference, floating, config) => {\n  const {\n    placement = 'bottom',\n    strategy = 'absolute',\n    middleware = [],\n    platform\n  } = config;\n  const validMiddleware = middleware.filter(Boolean);\n  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));\n  let rects = await platform.getElementRects({\n    reference,\n    floating,\n    strategy\n  });\n  let {\n    x,\n    y\n  } = computeCoordsFromPlacement(rects, placement, rtl);\n  let statefulPlacement = placement;\n  let middlewareData = {};\n  let resetCount = 0;\n  for (let i = 0; i < validMiddleware.length; i++) {\n    const {\n      name,\n      fn\n    } = validMiddleware[i];\n    const {\n      x: nextX,\n      y: nextY,\n      data,\n      reset\n    } = await fn({\n      x,\n      y,\n      initialPlacement: placement,\n      placement: statefulPlacement,\n      strategy,\n      middlewareData,\n      rects,\n      platform,\n      elements: {\n        reference,\n        floating\n      }\n    });\n    x = nextX != null ? nextX : x;\n    y = nextY != null ? nextY : y;\n    middlewareData = {\n      ...middlewareData,\n      [name]: {\n        ...middlewareData[name],\n        ...data\n      }\n    };\n    if (reset && resetCount <= 50) {\n      resetCount++;\n      if (typeof reset === 'object') {\n        if (reset.placement) {\n          statefulPlacement = reset.placement;\n        }\n        if (reset.rects) {\n          rects = reset.rects === true ? await platform.getElementRects({\n            reference,\n            floating,\n            strategy\n          }) : reset.rects;\n        }\n        ({\n          x,\n          y\n        } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));\n      }\n      i = -1;\n      continue;\n    }\n  }\n  return {\n    x,\n    y,\n    placement: statefulPlacement,\n    strategy,\n    middlewareData\n  };\n};\n\n/**\n * Resolves with an object of overflow side offsets that determine how much the\n * element is overflowing a given clipping boundary on each side.\n * - positive = overflowing the boundary by that number of pixels\n * - negative = how many pixels left before it will overflow\n * - 0 = lies flush with the boundary\n * @see https://floating-ui.com/docs/detectOverflow\n */\nasync function detectOverflow(state, options) {\n  var _await$platform$isEle;\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    x,\n    y,\n    platform,\n    rects,\n    elements,\n    strategy\n  } = state;\n  const {\n    boundary = 'clippingAncestors',\n    rootBoundary = 'viewport',\n    elementContext = 'floating',\n    altBoundary = false,\n    padding = 0\n  } = evaluate(options, state);\n  const paddingObject = getPaddingObject(padding);\n  const altContext = elementContext === 'floating' ? 'reference' : 'floating';\n  const element = elements[altBoundary ? altContext : elementContext];\n  const clippingClientRect = rectToClientRect(await platform.getClippingRect({\n    element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || (await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating))),\n    boundary,\n    rootBoundary,\n    strategy\n  }));\n  const rect = elementContext === 'floating' ? {\n    ...rects.floating,\n    x,\n    y\n  } : rects.reference;\n  const offsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating));\n  const offsetScale = (await (platform.isElement == null ? void 0 : platform.isElement(offsetParent))) ? (await (platform.getScale == null ? void 0 : platform.getScale(offsetParent))) || {\n    x: 1,\n    y: 1\n  } : {\n    x: 1,\n    y: 1\n  };\n  const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({\n    rect,\n    offsetParent,\n    strategy\n  }) : rect);\n  return {\n    top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,\n    bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,\n    left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,\n    right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x\n  };\n}\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = options => ({\n  name: 'arrow',\n  options,\n  async fn(state) {\n    const {\n      x,\n      y,\n      placement,\n      rects,\n      platform,\n      elements,\n      middlewareData\n    } = state;\n    // Since `element` is required, we don't Partial<> the type.\n    const {\n      element,\n      padding = 0\n    } = evaluate(options, state) || {};\n    if (element == null) {\n      return {};\n    }\n    const paddingObject = getPaddingObject(padding);\n    const coords = {\n      x,\n      y\n    };\n    const axis = getAlignmentAxis(placement);\n    const length = getAxisLength(axis);\n    const arrowDimensions = await platform.getDimensions(element);\n    const isYAxis = axis === 'y';\n    const minProp = isYAxis ? 'top' : 'left';\n    const maxProp = isYAxis ? 'bottom' : 'right';\n    const clientProp = isYAxis ? 'clientHeight' : 'clientWidth';\n    const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];\n    const startDiff = coords[axis] - rects.reference[axis];\n    const arrowOffsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(element));\n    let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;\n\n    // DOM platform can return `window` as the `offsetParent`.\n    if (!clientSize || !(await (platform.isElement == null ? void 0 : platform.isElement(arrowOffsetParent)))) {\n      clientSize = elements.floating[clientProp] || rects.floating[length];\n    }\n    const centerToReference = endDiff / 2 - startDiff / 2;\n\n    // If the padding is large enough that it causes the arrow to no longer be\n    // centered, modify the padding so that it is centered.\n    const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;\n    const minPadding = min(paddingObject[minProp], largestPossiblePadding);\n    const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);\n\n    // Make sure the arrow doesn't overflow the floating element if the center\n    // point is outside the floating element's bounds.\n    const min$1 = minPadding;\n    const max = clientSize - arrowDimensions[length] - maxPadding;\n    const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;\n    const offset = clamp(min$1, center, max);\n\n    // If the reference is small enough that the arrow's padding causes it to\n    // to point to nothing for an aligned placement, adjust the offset of the\n    // floating element itself. To ensure `shift()` continues to take action,\n    // a single reset is performed when this is true.\n    const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center != offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;\n    const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max : 0;\n    return {\n      [axis]: coords[axis] + alignmentOffset,\n      data: {\n        [axis]: offset,\n        centerOffset: center - offset - alignmentOffset,\n        ...(shouldAddOffset && {\n          alignmentOffset\n        })\n      },\n      reset: shouldAddOffset\n    };\n  }\n});\n\nfunction getPlacementList(alignment, autoAlignment, allowedPlacements) {\n  const allowedPlacementsSortedByAlignment = alignment ? [...allowedPlacements.filter(placement => getAlignment(placement) === alignment), ...allowedPlacements.filter(placement => getAlignment(placement) !== alignment)] : allowedPlacements.filter(placement => getSide(placement) === placement);\n  return allowedPlacementsSortedByAlignment.filter(placement => {\n    if (alignment) {\n      return getAlignment(placement) === alignment || (autoAlignment ? getOppositeAlignmentPlacement(placement) !== placement : false);\n    }\n    return true;\n  });\n}\n/**\n * Optimizes the visibility of the floating element by choosing the placement\n * that has the most space available automatically, without needing to specify a\n * preferred placement. Alternative to `flip`.\n * @see https://floating-ui.com/docs/autoPlacement\n */\nconst autoPlacement = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'autoPlacement',\n    options,\n    async fn(state) {\n      var _middlewareData$autoP, _middlewareData$autoP2, _placementsThatFitOnE;\n      const {\n        rects,\n        middlewareData,\n        placement,\n        platform,\n        elements\n      } = state;\n      const {\n        crossAxis = false,\n        alignment,\n        allowedPlacements = placements,\n        autoAlignment = true,\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const placements$1 = alignment !== undefined || allowedPlacements === placements ? getPlacementList(alignment || null, autoAlignment, allowedPlacements) : allowedPlacements;\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const currentIndex = ((_middlewareData$autoP = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP.index) || 0;\n      const currentPlacement = placements$1[currentIndex];\n      if (currentPlacement == null) {\n        return {};\n      }\n      const alignmentSides = getAlignmentSides(currentPlacement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)));\n\n      // Make `computeCoords` start from the right place.\n      if (placement !== currentPlacement) {\n        return {\n          reset: {\n            placement: placements$1[0]\n          }\n        };\n      }\n      const currentOverflows = [overflow[getSide(currentPlacement)], overflow[alignmentSides[0]], overflow[alignmentSides[1]]];\n      const allOverflows = [...(((_middlewareData$autoP2 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP2.overflows) || []), {\n        placement: currentPlacement,\n        overflows: currentOverflows\n      }];\n      const nextPlacement = placements$1[currentIndex + 1];\n\n      // There are more placements to check.\n      if (nextPlacement) {\n        return {\n          data: {\n            index: currentIndex + 1,\n            overflows: allOverflows\n          },\n          reset: {\n            placement: nextPlacement\n          }\n        };\n      }\n      const placementsSortedByMostSpace = allOverflows.map(d => {\n        const alignment = getAlignment(d.placement);\n        return [d.placement, alignment && crossAxis ?\n        // Check along the mainAxis and main crossAxis side.\n        d.overflows.slice(0, 2).reduce((acc, v) => acc + v, 0) :\n        // Check only the mainAxis.\n        d.overflows[0], d.overflows];\n      }).sort((a, b) => a[1] - b[1]);\n      const placementsThatFitOnEachSide = placementsSortedByMostSpace.filter(d => d[2].slice(0,\n      // Aligned placements should not check their opposite crossAxis\n      // side.\n      getAlignment(d[0]) ? 2 : 3).every(v => v <= 0));\n      const resetPlacement = ((_placementsThatFitOnE = placementsThatFitOnEachSide[0]) == null ? void 0 : _placementsThatFitOnE[0]) || placementsSortedByMostSpace[0][0];\n      if (resetPlacement !== placement) {\n        return {\n          data: {\n            index: currentIndex + 1,\n            overflows: allOverflows\n          },\n          reset: {\n            placement: resetPlacement\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\n/**\n * Optimizes the visibility of the floating element by flipping the `placement`\n * in order to keep it in view when the preferred placement(s) will overflow the\n * clipping boundary. Alternative to `autoPlacement`.\n * @see https://floating-ui.com/docs/flip\n */\nconst flip = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'flip',\n    options,\n    async fn(state) {\n      var _middlewareData$arrow, _middlewareData$flip;\n      const {\n        placement,\n        middlewareData,\n        rects,\n        initialPlacement,\n        platform,\n        elements\n      } = state;\n      const {\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = true,\n        fallbackPlacements: specifiedFallbackPlacements,\n        fallbackStrategy = 'bestFit',\n        fallbackAxisSideDirection = 'none',\n        flipAlignment = true,\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n\n      // If a reset by the arrow was caused due to an alignment offset being\n      // added, we should skip any logic now since `flip()` has already done its\n      // work.\n      // https://github.com/floating-ui/floating-ui/issues/2549#issuecomment-1719601643\n      if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {\n        return {};\n      }\n      const side = getSide(placement);\n      const isBasePlacement = getSide(initialPlacement) === initialPlacement;\n      const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));\n      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));\n      if (!specifiedFallbackPlacements && fallbackAxisSideDirection !== 'none') {\n        fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));\n      }\n      const placements = [initialPlacement, ...fallbackPlacements];\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const overflows = [];\n      let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];\n      if (checkMainAxis) {\n        overflows.push(overflow[side]);\n      }\n      if (checkCrossAxis) {\n        const sides = getAlignmentSides(placement, rects, rtl);\n        overflows.push(overflow[sides[0]], overflow[sides[1]]);\n      }\n      overflowsData = [...overflowsData, {\n        placement,\n        overflows\n      }];\n\n      // One or more sides is overflowing.\n      if (!overflows.every(side => side <= 0)) {\n        var _middlewareData$flip2, _overflowsData$filter;\n        const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;\n        const nextPlacement = placements[nextIndex];\n        if (nextPlacement) {\n          // Try next placement and re-run the lifecycle.\n          return {\n            data: {\n              index: nextIndex,\n              overflows: overflowsData\n            },\n            reset: {\n              placement: nextPlacement\n            }\n          };\n        }\n\n        // First, find the candidates that fit on the mainAxis side of overflow,\n        // then find the placement that fits the best on the main crossAxis side.\n        let resetPlacement = (_overflowsData$filter = overflowsData.filter(d => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;\n\n        // Otherwise fallback.\n        if (!resetPlacement) {\n          switch (fallbackStrategy) {\n            case 'bestFit':\n              {\n                var _overflowsData$map$so;\n                const placement = (_overflowsData$map$so = overflowsData.map(d => [d.placement, d.overflows.filter(overflow => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$map$so[0];\n                if (placement) {\n                  resetPlacement = placement;\n                }\n                break;\n              }\n            case 'initialPlacement':\n              resetPlacement = initialPlacement;\n              break;\n          }\n        }\n        if (placement !== resetPlacement) {\n          return {\n            reset: {\n              placement: resetPlacement\n            }\n          };\n        }\n      }\n      return {};\n    }\n  };\n};\n\nfunction getSideOffsets(overflow, rect) {\n  return {\n    top: overflow.top - rect.height,\n    right: overflow.right - rect.width,\n    bottom: overflow.bottom - rect.height,\n    left: overflow.left - rect.width\n  };\n}\nfunction isAnySideFullyClipped(overflow) {\n  return sides.some(side => overflow[side] >= 0);\n}\n/**\n * Provides data to hide the floating element in applicable situations, such as\n * when it is not in the same clipping context as the reference element.\n * @see https://floating-ui.com/docs/hide\n */\nconst hide = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'hide',\n    options,\n    async fn(state) {\n      const {\n        rects\n      } = state;\n      const {\n        strategy = 'referenceHidden',\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      switch (strategy) {\n        case 'referenceHidden':\n          {\n            const overflow = await detectOverflow(state, {\n              ...detectOverflowOptions,\n              elementContext: 'reference'\n            });\n            const offsets = getSideOffsets(overflow, rects.reference);\n            return {\n              data: {\n                referenceHiddenOffsets: offsets,\n                referenceHidden: isAnySideFullyClipped(offsets)\n              }\n            };\n          }\n        case 'escaped':\n          {\n            const overflow = await detectOverflow(state, {\n              ...detectOverflowOptions,\n              altBoundary: true\n            });\n            const offsets = getSideOffsets(overflow, rects.floating);\n            return {\n              data: {\n                escapedOffsets: offsets,\n                escaped: isAnySideFullyClipped(offsets)\n              }\n            };\n          }\n        default:\n          {\n            return {};\n          }\n      }\n    }\n  };\n};\n\nfunction getBoundingRect(rects) {\n  const minX = min(...rects.map(rect => rect.left));\n  const minY = min(...rects.map(rect => rect.top));\n  const maxX = max(...rects.map(rect => rect.right));\n  const maxY = max(...rects.map(rect => rect.bottom));\n  return {\n    x: minX,\n    y: minY,\n    width: maxX - minX,\n    height: maxY - minY\n  };\n}\nfunction getRectsByLine(rects) {\n  const sortedRects = rects.slice().sort((a, b) => a.y - b.y);\n  const groups = [];\n  let prevRect = null;\n  for (let i = 0; i < sortedRects.length; i++) {\n    const rect = sortedRects[i];\n    if (!prevRect || rect.y - prevRect.y > prevRect.height / 2) {\n      groups.push([rect]);\n    } else {\n      groups[groups.length - 1].push(rect);\n    }\n    prevRect = rect;\n  }\n  return groups.map(rect => rectToClientRect(getBoundingRect(rect)));\n}\n/**\n * Provides improved positioning for inline reference elements that can span\n * over multiple lines, such as hyperlinks or range selections.\n * @see https://floating-ui.com/docs/inline\n */\nconst inline = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'inline',\n    options,\n    async fn(state) {\n      const {\n        placement,\n        elements,\n        rects,\n        platform,\n        strategy\n      } = state;\n      // A MouseEvent's client{X,Y} coords can be up to 2 pixels off a\n      // ClientRect's bounds, despite the event listener being triggered. A\n      // padding of 2 seems to handle this issue.\n      const {\n        padding = 2,\n        x,\n        y\n      } = evaluate(options, state);\n      const nativeClientRects = Array.from((await (platform.getClientRects == null ? void 0 : platform.getClientRects(elements.reference))) || []);\n      const clientRects = getRectsByLine(nativeClientRects);\n      const fallback = rectToClientRect(getBoundingRect(nativeClientRects));\n      const paddingObject = getPaddingObject(padding);\n      function getBoundingClientRect() {\n        // There are two rects and they are disjoined.\n        if (clientRects.length === 2 && clientRects[0].left > clientRects[1].right && x != null && y != null) {\n          // Find the first rect in which the point is fully inside.\n          return clientRects.find(rect => x > rect.left - paddingObject.left && x < rect.right + paddingObject.right && y > rect.top - paddingObject.top && y < rect.bottom + paddingObject.bottom) || fallback;\n        }\n\n        // There are 2 or more connected rects.\n        if (clientRects.length >= 2) {\n          if (getSideAxis(placement) === 'y') {\n            const firstRect = clientRects[0];\n            const lastRect = clientRects[clientRects.length - 1];\n            const isTop = getSide(placement) === 'top';\n            const top = firstRect.top;\n            const bottom = lastRect.bottom;\n            const left = isTop ? firstRect.left : lastRect.left;\n            const right = isTop ? firstRect.right : lastRect.right;\n            const width = right - left;\n            const height = bottom - top;\n            return {\n              top,\n              bottom,\n              left,\n              right,\n              width,\n              height,\n              x: left,\n              y: top\n            };\n          }\n          const isLeftSide = getSide(placement) === 'left';\n          const maxRight = max(...clientRects.map(rect => rect.right));\n          const minLeft = min(...clientRects.map(rect => rect.left));\n          const measureRects = clientRects.filter(rect => isLeftSide ? rect.left === minLeft : rect.right === maxRight);\n          const top = measureRects[0].top;\n          const bottom = measureRects[measureRects.length - 1].bottom;\n          const left = minLeft;\n          const right = maxRight;\n          const width = right - left;\n          const height = bottom - top;\n          return {\n            top,\n            bottom,\n            left,\n            right,\n            width,\n            height,\n            x: left,\n            y: top\n          };\n        }\n        return fallback;\n      }\n      const resetRects = await platform.getElementRects({\n        reference: {\n          getBoundingClientRect\n        },\n        floating: elements.floating,\n        strategy\n      });\n      if (rects.reference.x !== resetRects.reference.x || rects.reference.y !== resetRects.reference.y || rects.reference.width !== resetRects.reference.width || rects.reference.height !== resetRects.reference.height) {\n        return {\n          reset: {\n            rects: resetRects\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\n// For type backwards-compatibility, the `OffsetOptions` type was also\n// Derivable.\n\nasync function convertValueToCoords(state, options) {\n  const {\n    placement,\n    platform,\n    elements\n  } = state;\n  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));\n  const side = getSide(placement);\n  const alignment = getAlignment(placement);\n  const isVertical = getSideAxis(placement) === 'y';\n  const mainAxisMulti = ['left', 'top'].includes(side) ? -1 : 1;\n  const crossAxisMulti = rtl && isVertical ? -1 : 1;\n  const rawValue = evaluate(options, state);\n\n  // eslint-disable-next-line prefer-const\n  let {\n    mainAxis,\n    crossAxis,\n    alignmentAxis\n  } = typeof rawValue === 'number' ? {\n    mainAxis: rawValue,\n    crossAxis: 0,\n    alignmentAxis: null\n  } : {\n    mainAxis: 0,\n    crossAxis: 0,\n    alignmentAxis: null,\n    ...rawValue\n  };\n  if (alignment && typeof alignmentAxis === 'number') {\n    crossAxis = alignment === 'end' ? alignmentAxis * -1 : alignmentAxis;\n  }\n  return isVertical ? {\n    x: crossAxis * crossAxisMulti,\n    y: mainAxis * mainAxisMulti\n  } : {\n    x: mainAxis * mainAxisMulti,\n    y: crossAxis * crossAxisMulti\n  };\n}\n\n/**\n * Modifies the placement by translating the floating element along the\n * specified axes.\n * A number (shorthand for `mainAxis` or distance), or an axes configuration\n * object may be passed.\n * @see https://floating-ui.com/docs/offset\n */\nconst offset = function (options) {\n  if (options === void 0) {\n    options = 0;\n  }\n  return {\n    name: 'offset',\n    options,\n    async fn(state) {\n      var _middlewareData$offse, _middlewareData$arrow;\n      const {\n        x,\n        y,\n        placement,\n        middlewareData\n      } = state;\n      const diffCoords = await convertValueToCoords(state, options);\n\n      // If the placement is the same and the arrow caused an alignment offset\n      // then we don't need to change the positioning coordinates.\n      if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {\n        return {};\n      }\n      return {\n        x: x + diffCoords.x,\n        y: y + diffCoords.y,\n        data: {\n          ...diffCoords,\n          placement\n        }\n      };\n    }\n  };\n};\n\n/**\n * Optimizes the visibility of the floating element by shifting it in order to\n * keep it in view when it will overflow the clipping boundary.\n * @see https://floating-ui.com/docs/shift\n */\nconst shift = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'shift',\n    options,\n    async fn(state) {\n      const {\n        x,\n        y,\n        placement\n      } = state;\n      const {\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = false,\n        limiter = {\n          fn: _ref => {\n            let {\n              x,\n              y\n            } = _ref;\n            return {\n              x,\n              y\n            };\n          }\n        },\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const coords = {\n        x,\n        y\n      };\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const crossAxis = getSideAxis(getSide(placement));\n      const mainAxis = getOppositeAxis(crossAxis);\n      let mainAxisCoord = coords[mainAxis];\n      let crossAxisCoord = coords[crossAxis];\n      if (checkMainAxis) {\n        const minSide = mainAxis === 'y' ? 'top' : 'left';\n        const maxSide = mainAxis === 'y' ? 'bottom' : 'right';\n        const min = mainAxisCoord + overflow[minSide];\n        const max = mainAxisCoord - overflow[maxSide];\n        mainAxisCoord = clamp(min, mainAxisCoord, max);\n      }\n      if (checkCrossAxis) {\n        const minSide = crossAxis === 'y' ? 'top' : 'left';\n        const maxSide = crossAxis === 'y' ? 'bottom' : 'right';\n        const min = crossAxisCoord + overflow[minSide];\n        const max = crossAxisCoord - overflow[maxSide];\n        crossAxisCoord = clamp(min, crossAxisCoord, max);\n      }\n      const limitedCoords = limiter.fn({\n        ...state,\n        [mainAxis]: mainAxisCoord,\n        [crossAxis]: crossAxisCoord\n      });\n      return {\n        ...limitedCoords,\n        data: {\n          x: limitedCoords.x - x,\n          y: limitedCoords.y - y\n        }\n      };\n    }\n  };\n};\n/**\n * Built-in `limiter` that will stop `shift()` at a certain point.\n */\nconst limitShift = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    options,\n    fn(state) {\n      const {\n        x,\n        y,\n        placement,\n        rects,\n        middlewareData\n      } = state;\n      const {\n        offset = 0,\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = true\n      } = evaluate(options, state);\n      const coords = {\n        x,\n        y\n      };\n      const crossAxis = getSideAxis(placement);\n      const mainAxis = getOppositeAxis(crossAxis);\n      let mainAxisCoord = coords[mainAxis];\n      let crossAxisCoord = coords[crossAxis];\n      const rawOffset = evaluate(offset, state);\n      const computedOffset = typeof rawOffset === 'number' ? {\n        mainAxis: rawOffset,\n        crossAxis: 0\n      } : {\n        mainAxis: 0,\n        crossAxis: 0,\n        ...rawOffset\n      };\n      if (checkMainAxis) {\n        const len = mainAxis === 'y' ? 'height' : 'width';\n        const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;\n        const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;\n        if (mainAxisCoord < limitMin) {\n          mainAxisCoord = limitMin;\n        } else if (mainAxisCoord > limitMax) {\n          mainAxisCoord = limitMax;\n        }\n      }\n      if (checkCrossAxis) {\n        var _middlewareData$offse, _middlewareData$offse2;\n        const len = mainAxis === 'y' ? 'width' : 'height';\n        const isOriginSide = ['top', 'left'].includes(getSide(placement));\n        const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);\n        const limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : ((_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0);\n        if (crossAxisCoord < limitMin) {\n          crossAxisCoord = limitMin;\n        } else if (crossAxisCoord > limitMax) {\n          crossAxisCoord = limitMax;\n        }\n      }\n      return {\n        [mainAxis]: mainAxisCoord,\n        [crossAxis]: crossAxisCoord\n      };\n    }\n  };\n};\n\n/**\n * Provides data that allows you to change the size of the floating element —\n * for instance, prevent it from overflowing the clipping boundary or match the\n * width of the reference element.\n * @see https://floating-ui.com/docs/size\n */\nconst size = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'size',\n    options,\n    async fn(state) {\n      const {\n        placement,\n        rects,\n        platform,\n        elements\n      } = state;\n      const {\n        apply = () => {},\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const side = getSide(placement);\n      const alignment = getAlignment(placement);\n      const isYAxis = getSideAxis(placement) === 'y';\n      const {\n        width,\n        height\n      } = rects.floating;\n      let heightSide;\n      let widthSide;\n      if (side === 'top' || side === 'bottom') {\n        heightSide = side;\n        widthSide = alignment === ((await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating))) ? 'start' : 'end') ? 'left' : 'right';\n      } else {\n        widthSide = side;\n        heightSide = alignment === 'end' ? 'top' : 'bottom';\n      }\n      const overflowAvailableHeight = height - overflow[heightSide];\n      const overflowAvailableWidth = width - overflow[widthSide];\n      const noShift = !state.middlewareData.shift;\n      let availableHeight = overflowAvailableHeight;\n      let availableWidth = overflowAvailableWidth;\n      if (isYAxis) {\n        const maximumClippingWidth = width - overflow.left - overflow.right;\n        availableWidth = alignment || noShift ? min(overflowAvailableWidth, maximumClippingWidth) : maximumClippingWidth;\n      } else {\n        const maximumClippingHeight = height - overflow.top - overflow.bottom;\n        availableHeight = alignment || noShift ? min(overflowAvailableHeight, maximumClippingHeight) : maximumClippingHeight;\n      }\n      if (noShift && !alignment) {\n        const xMin = max(overflow.left, 0);\n        const xMax = max(overflow.right, 0);\n        const yMin = max(overflow.top, 0);\n        const yMax = max(overflow.bottom, 0);\n        if (isYAxis) {\n          availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right));\n        } else {\n          availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom));\n        }\n      }\n      await apply({\n        ...state,\n        availableWidth,\n        availableHeight\n      });\n      const nextDimensions = await platform.getDimensions(elements.floating);\n      if (width !== nextDimensions.width || height !== nextDimensions.height) {\n        return {\n          reset: {\n            rects: true\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\nexport { arrow, autoPlacement, computePosition, detectOverflow, flip, hide, inline, limitShift, offset, shift, size };\n","import { rectToClientRect, autoPlacement as autoPlacement$1, shift as shift$1, flip as flip$1, size as size$1, hide as hide$1, arrow as arrow$1, inline as inline$1, limitShift as limitShift$1, computePosition as computePosition$1 } from '@floating-ui/core';\nexport { detectOverflow, offset } from '@floating-ui/core';\nimport { round, createCoords, max, min, floor } from '@floating-ui/utils';\nimport { getComputedStyle, isHTMLElement, isElement, getWindow, isWebKit, getDocumentElement, getNodeName, isOverflowElement, getNodeScroll, getOverflowAncestors, getParentNode, isLastTraversableNode, isContainingBlock, isTableElement, getContainingBlock } from '@floating-ui/utils/dom';\nexport { getOverflowAncestors } from '@floating-ui/utils/dom';\n\nfunction getCssDimensions(element) {\n  const css = getComputedStyle(element);\n  // In testing environments, the `width` and `height` properties are empty\n  // strings for SVG elements, returning NaN. Fallback to `0` in this case.\n  let width = parseFloat(css.width) || 0;\n  let height = parseFloat(css.height) || 0;\n  const hasOffset = isHTMLElement(element);\n  const offsetWidth = hasOffset ? element.offsetWidth : width;\n  const offsetHeight = hasOffset ? element.offsetHeight : height;\n  const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;\n  if (shouldFallback) {\n    width = offsetWidth;\n    height = offsetHeight;\n  }\n  return {\n    width,\n    height,\n    $: shouldFallback\n  };\n}\n\nfunction unwrapElement(element) {\n  return !isElement(element) ? element.contextElement : element;\n}\n\nfunction getScale(element) {\n  const domElement = unwrapElement(element);\n  if (!isHTMLElement(domElement)) {\n    return createCoords(1);\n  }\n  const rect = domElement.getBoundingClientRect();\n  const {\n    width,\n    height,\n    $\n  } = getCssDimensions(domElement);\n  let x = ($ ? round(rect.width) : rect.width) / width;\n  let y = ($ ? round(rect.height) : rect.height) / height;\n\n  // 0, NaN, or Infinity should always fallback to 1.\n\n  if (!x || !Number.isFinite(x)) {\n    x = 1;\n  }\n  if (!y || !Number.isFinite(y)) {\n    y = 1;\n  }\n  return {\n    x,\n    y\n  };\n}\n\nconst noOffsets = /*#__PURE__*/createCoords(0);\nfunction getVisualOffsets(element) {\n  const win = getWindow(element);\n  if (!isWebKit() || !win.visualViewport) {\n    return noOffsets;\n  }\n  return {\n    x: win.visualViewport.offsetLeft,\n    y: win.visualViewport.offsetTop\n  };\n}\nfunction shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {\n  if (isFixed === void 0) {\n    isFixed = false;\n  }\n  if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {\n    return false;\n  }\n  return isFixed;\n}\n\nfunction getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {\n  if (includeScale === void 0) {\n    includeScale = false;\n  }\n  if (isFixedStrategy === void 0) {\n    isFixedStrategy = false;\n  }\n  const clientRect = element.getBoundingClientRect();\n  const domElement = unwrapElement(element);\n  let scale = createCoords(1);\n  if (includeScale) {\n    if (offsetParent) {\n      if (isElement(offsetParent)) {\n        scale = getScale(offsetParent);\n      }\n    } else {\n      scale = getScale(element);\n    }\n  }\n  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);\n  let x = (clientRect.left + visualOffsets.x) / scale.x;\n  let y = (clientRect.top + visualOffsets.y) / scale.y;\n  let width = clientRect.width / scale.x;\n  let height = clientRect.height / scale.y;\n  if (domElement) {\n    const win = getWindow(domElement);\n    const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;\n    let currentIFrame = win.frameElement;\n    while (currentIFrame && offsetParent && offsetWin !== win) {\n      const iframeScale = getScale(currentIFrame);\n      const iframeRect = currentIFrame.getBoundingClientRect();\n      const css = getComputedStyle(currentIFrame);\n      const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;\n      const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;\n      x *= iframeScale.x;\n      y *= iframeScale.y;\n      width *= iframeScale.x;\n      height *= iframeScale.y;\n      x += left;\n      y += top;\n      currentIFrame = getWindow(currentIFrame).frameElement;\n    }\n  }\n  return rectToClientRect({\n    width,\n    height,\n    x,\n    y\n  });\n}\n\nfunction convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {\n  let {\n    rect,\n    offsetParent,\n    strategy\n  } = _ref;\n  const isOffsetParentAnElement = isHTMLElement(offsetParent);\n  const documentElement = getDocumentElement(offsetParent);\n  if (offsetParent === documentElement) {\n    return rect;\n  }\n  let scroll = {\n    scrollLeft: 0,\n    scrollTop: 0\n  };\n  let scale = createCoords(1);\n  const offsets = createCoords(0);\n  if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== 'fixed') {\n    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {\n      scroll = getNodeScroll(offsetParent);\n    }\n    if (isHTMLElement(offsetParent)) {\n      const offsetRect = getBoundingClientRect(offsetParent);\n      scale = getScale(offsetParent);\n      offsets.x = offsetRect.x + offsetParent.clientLeft;\n      offsets.y = offsetRect.y + offsetParent.clientTop;\n    }\n  }\n  return {\n    width: rect.width * scale.x,\n    height: rect.height * scale.y,\n    x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x,\n    y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y\n  };\n}\n\nfunction getClientRects(element) {\n  return Array.from(element.getClientRects());\n}\n\nfunction getWindowScrollBarX(element) {\n  // If <html> has a CSS width greater than the viewport, then this will be\n  // incorrect for RTL.\n  return getBoundingClientRect(getDocumentElement(element)).left + getNodeScroll(element).scrollLeft;\n}\n\n// Gets the entire size of the scrollable document area, even extending outside\n// of the `<html>` and `<body>` rect bounds if horizontally scrollable.\nfunction getDocumentRect(element) {\n  const html = getDocumentElement(element);\n  const scroll = getNodeScroll(element);\n  const body = element.ownerDocument.body;\n  const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);\n  const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);\n  let x = -scroll.scrollLeft + getWindowScrollBarX(element);\n  const y = -scroll.scrollTop;\n  if (getComputedStyle(body).direction === 'rtl') {\n    x += max(html.clientWidth, body.clientWidth) - width;\n  }\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\n\nfunction getViewportRect(element, strategy) {\n  const win = getWindow(element);\n  const html = getDocumentElement(element);\n  const visualViewport = win.visualViewport;\n  let width = html.clientWidth;\n  let height = html.clientHeight;\n  let x = 0;\n  let y = 0;\n  if (visualViewport) {\n    width = visualViewport.width;\n    height = visualViewport.height;\n    const visualViewportBased = isWebKit();\n    if (!visualViewportBased || visualViewportBased && strategy === 'fixed') {\n      x = visualViewport.offsetLeft;\n      y = visualViewport.offsetTop;\n    }\n  }\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\n\n// Returns the inner client rect, subtracting scrollbars if present.\nfunction getInnerBoundingClientRect(element, strategy) {\n  const clientRect = getBoundingClientRect(element, true, strategy === 'fixed');\n  const top = clientRect.top + element.clientTop;\n  const left = clientRect.left + element.clientLeft;\n  const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);\n  const width = element.clientWidth * scale.x;\n  const height = element.clientHeight * scale.y;\n  const x = left * scale.x;\n  const y = top * scale.y;\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\nfunction getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {\n  let rect;\n  if (clippingAncestor === 'viewport') {\n    rect = getViewportRect(element, strategy);\n  } else if (clippingAncestor === 'document') {\n    rect = getDocumentRect(getDocumentElement(element));\n  } else if (isElement(clippingAncestor)) {\n    rect = getInnerBoundingClientRect(clippingAncestor, strategy);\n  } else {\n    const visualOffsets = getVisualOffsets(element);\n    rect = {\n      ...clippingAncestor,\n      x: clippingAncestor.x - visualOffsets.x,\n      y: clippingAncestor.y - visualOffsets.y\n    };\n  }\n  return rectToClientRect(rect);\n}\nfunction hasFixedPositionAncestor(element, stopNode) {\n  const parentNode = getParentNode(element);\n  if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {\n    return false;\n  }\n  return getComputedStyle(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);\n}\n\n// A \"clipping ancestor\" is an `overflow` element with the characteristic of\n// clipping (or hiding) child elements. This returns all clipping ancestors\n// of the given element up the tree.\nfunction getClippingElementAncestors(element, cache) {\n  const cachedResult = cache.get(element);\n  if (cachedResult) {\n    return cachedResult;\n  }\n  let result = getOverflowAncestors(element, [], false).filter(el => isElement(el) && getNodeName(el) !== 'body');\n  let currentContainingBlockComputedStyle = null;\n  const elementIsFixed = getComputedStyle(element).position === 'fixed';\n  let currentNode = elementIsFixed ? getParentNode(element) : element;\n\n  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block\n  while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {\n    const computedStyle = getComputedStyle(currentNode);\n    const currentNodeIsContaining = isContainingBlock(currentNode);\n    if (!currentNodeIsContaining && computedStyle.position === 'fixed') {\n      currentContainingBlockComputedStyle = null;\n    }\n    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && ['absolute', 'fixed'].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);\n    if (shouldDropCurrentNode) {\n      // Drop non-containing blocks.\n      result = result.filter(ancestor => ancestor !== currentNode);\n    } else {\n      // Record last containing block for next iteration.\n      currentContainingBlockComputedStyle = computedStyle;\n    }\n    currentNode = getParentNode(currentNode);\n  }\n  cache.set(element, result);\n  return result;\n}\n\n// Gets the maximum area that the element is visible in due to any number of\n// clipping ancestors.\nfunction getClippingRect(_ref) {\n  let {\n    element,\n    boundary,\n    rootBoundary,\n    strategy\n  } = _ref;\n  const elementClippingAncestors = boundary === 'clippingAncestors' ? getClippingElementAncestors(element, this._c) : [].concat(boundary);\n  const clippingAncestors = [...elementClippingAncestors, rootBoundary];\n  const firstClippingAncestor = clippingAncestors[0];\n  const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {\n    const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);\n    accRect.top = max(rect.top, accRect.top);\n    accRect.right = min(rect.right, accRect.right);\n    accRect.bottom = min(rect.bottom, accRect.bottom);\n    accRect.left = max(rect.left, accRect.left);\n    return accRect;\n  }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));\n  return {\n    width: clippingRect.right - clippingRect.left,\n    height: clippingRect.bottom - clippingRect.top,\n    x: clippingRect.left,\n    y: clippingRect.top\n  };\n}\n\nfunction getDimensions(element) {\n  const {\n    width,\n    height\n  } = getCssDimensions(element);\n  return {\n    width,\n    height\n  };\n}\n\nfunction getRectRelativeToOffsetParent(element, offsetParent, strategy) {\n  const isOffsetParentAnElement = isHTMLElement(offsetParent);\n  const documentElement = getDocumentElement(offsetParent);\n  const isFixed = strategy === 'fixed';\n  const rect = getBoundingClientRect(element, true, isFixed, offsetParent);\n  let scroll = {\n    scrollLeft: 0,\n    scrollTop: 0\n  };\n  const offsets = createCoords(0);\n  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {\n    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {\n      scroll = getNodeScroll(offsetParent);\n    }\n    if (isOffsetParentAnElement) {\n      const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);\n      offsets.x = offsetRect.x + offsetParent.clientLeft;\n      offsets.y = offsetRect.y + offsetParent.clientTop;\n    } else if (documentElement) {\n      offsets.x = getWindowScrollBarX(documentElement);\n    }\n  }\n  return {\n    x: rect.left + scroll.scrollLeft - offsets.x,\n    y: rect.top + scroll.scrollTop - offsets.y,\n    width: rect.width,\n    height: rect.height\n  };\n}\n\nfunction getTrueOffsetParent(element, polyfill) {\n  if (!isHTMLElement(element) || getComputedStyle(element).position === 'fixed') {\n    return null;\n  }\n  if (polyfill) {\n    return polyfill(element);\n  }\n  return element.offsetParent;\n}\n\n// Gets the closest ancestor positioned element. Handles some edge cases,\n// such as table ancestors and cross browser bugs.\nfunction getOffsetParent(element, polyfill) {\n  const window = getWindow(element);\n  if (!isHTMLElement(element)) {\n    return window;\n  }\n  let offsetParent = getTrueOffsetParent(element, polyfill);\n  while (offsetParent && isTableElement(offsetParent) && getComputedStyle(offsetParent).position === 'static') {\n    offsetParent = getTrueOffsetParent(offsetParent, polyfill);\n  }\n  if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle(offsetParent).position === 'static' && !isContainingBlock(offsetParent))) {\n    return window;\n  }\n  return offsetParent || getContainingBlock(element) || window;\n}\n\nconst getElementRects = async function (_ref) {\n  let {\n    reference,\n    floating,\n    strategy\n  } = _ref;\n  const getOffsetParentFn = this.getOffsetParent || getOffsetParent;\n  const getDimensionsFn = this.getDimensions;\n  return {\n    reference: getRectRelativeToOffsetParent(reference, await getOffsetParentFn(floating), strategy),\n    floating: {\n      x: 0,\n      y: 0,\n      ...(await getDimensionsFn(floating))\n    }\n  };\n};\n\nfunction isRTL(element) {\n  return getComputedStyle(element).direction === 'rtl';\n}\n\nconst platform = {\n  convertOffsetParentRelativeRectToViewportRelativeRect,\n  getDocumentElement,\n  getClippingRect,\n  getOffsetParent,\n  getElementRects,\n  getClientRects,\n  getDimensions,\n  getScale,\n  isElement,\n  isRTL\n};\n\n// https://samthor.au/2021/observing-dom/\nfunction observeMove(element, onMove) {\n  let io = null;\n  let timeoutId;\n  const root = getDocumentElement(element);\n  function cleanup() {\n    clearTimeout(timeoutId);\n    io && io.disconnect();\n    io = null;\n  }\n  function refresh(skip, threshold) {\n    if (skip === void 0) {\n      skip = false;\n    }\n    if (threshold === void 0) {\n      threshold = 1;\n    }\n    cleanup();\n    const {\n      left,\n      top,\n      width,\n      height\n    } = element.getBoundingClientRect();\n    if (!skip) {\n      onMove();\n    }\n    if (!width || !height) {\n      return;\n    }\n    const insetTop = floor(top);\n    const insetRight = floor(root.clientWidth - (left + width));\n    const insetBottom = floor(root.clientHeight - (top + height));\n    const insetLeft = floor(left);\n    const rootMargin = -insetTop + \"px \" + -insetRight + \"px \" + -insetBottom + \"px \" + -insetLeft + \"px\";\n    const options = {\n      rootMargin,\n      threshold: max(0, min(1, threshold)) || 1\n    };\n    let isFirstUpdate = true;\n    function handleObserve(entries) {\n      const ratio = entries[0].intersectionRatio;\n      if (ratio !== threshold) {\n        if (!isFirstUpdate) {\n          return refresh();\n        }\n        if (!ratio) {\n          timeoutId = setTimeout(() => {\n            refresh(false, 1e-7);\n          }, 100);\n        } else {\n          refresh(false, ratio);\n        }\n      }\n      isFirstUpdate = false;\n    }\n\n    // Older browsers don't support a `document` as the root and will throw an\n    // error.\n    try {\n      io = new IntersectionObserver(handleObserve, {\n        ...options,\n        // Handle <iframe>s\n        root: root.ownerDocument\n      });\n    } catch (e) {\n      io = new IntersectionObserver(handleObserve, options);\n    }\n    io.observe(element);\n  }\n  refresh(true);\n  return cleanup;\n}\n\n/**\n * Automatically updates the position of the floating element when necessary.\n * Should only be called when the floating element is mounted on the DOM or\n * visible on the screen.\n * @returns cleanup function that should be invoked when the floating element is\n * removed from the DOM or hidden from the screen.\n * @see https://floating-ui.com/docs/autoUpdate\n */\nfunction autoUpdate(reference, floating, update, options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    ancestorScroll = true,\n    ancestorResize = true,\n    elementResize = typeof ResizeObserver === 'function',\n    layoutShift = typeof IntersectionObserver === 'function',\n    animationFrame = false\n  } = options;\n  const referenceEl = unwrapElement(reference);\n  const ancestors = ancestorScroll || ancestorResize ? [...(referenceEl ? getOverflowAncestors(referenceEl) : []), ...getOverflowAncestors(floating)] : [];\n  ancestors.forEach(ancestor => {\n    ancestorScroll && ancestor.addEventListener('scroll', update, {\n      passive: true\n    });\n    ancestorResize && ancestor.addEventListener('resize', update);\n  });\n  const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;\n  let reobserveFrame = -1;\n  let resizeObserver = null;\n  if (elementResize) {\n    resizeObserver = new ResizeObserver(_ref => {\n      let [firstEntry] = _ref;\n      if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {\n        // Prevent update loops when using the `size` middleware.\n        // https://github.com/floating-ui/floating-ui/issues/1740\n        resizeObserver.unobserve(floating);\n        cancelAnimationFrame(reobserveFrame);\n        reobserveFrame = requestAnimationFrame(() => {\n          resizeObserver && resizeObserver.observe(floating);\n        });\n      }\n      update();\n    });\n    if (referenceEl && !animationFrame) {\n      resizeObserver.observe(referenceEl);\n    }\n    resizeObserver.observe(floating);\n  }\n  let frameId;\n  let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;\n  if (animationFrame) {\n    frameLoop();\n  }\n  function frameLoop() {\n    const nextRefRect = getBoundingClientRect(reference);\n    if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) {\n      update();\n    }\n    prevRefRect = nextRefRect;\n    frameId = requestAnimationFrame(frameLoop);\n  }\n  update();\n  return () => {\n    ancestors.forEach(ancestor => {\n      ancestorScroll && ancestor.removeEventListener('scroll', update);\n      ancestorResize && ancestor.removeEventListener('resize', update);\n    });\n    cleanupIo && cleanupIo();\n    resizeObserver && resizeObserver.disconnect();\n    resizeObserver = null;\n    if (animationFrame) {\n      cancelAnimationFrame(frameId);\n    }\n  };\n}\n\n/**\n * Optimizes the visibility of the floating element by choosing the placement\n * that has the most space available automatically, without needing to specify a\n * preferred placement. Alternative to `flip`.\n * @see https://floating-ui.com/docs/autoPlacement\n */\nconst autoPlacement = autoPlacement$1;\n\n/**\n * Optimizes the visibility of the floating element by shifting it in order to\n * keep it in view when it will overflow the clipping boundary.\n * @see https://floating-ui.com/docs/shift\n */\nconst shift = shift$1;\n\n/**\n * Optimizes the visibility of the floating element by flipping the `placement`\n * in order to keep it in view when the preferred placement(s) will overflow the\n * clipping boundary. Alternative to `autoPlacement`.\n * @see https://floating-ui.com/docs/flip\n */\nconst flip = flip$1;\n\n/**\n * Provides data that allows you to change the size of the floating element —\n * for instance, prevent it from overflowing the clipping boundary or match the\n * width of the reference element.\n * @see https://floating-ui.com/docs/size\n */\nconst size = size$1;\n\n/**\n * Provides data to hide the floating element in applicable situations, such as\n * when it is not in the same clipping context as the reference element.\n * @see https://floating-ui.com/docs/hide\n */\nconst hide = hide$1;\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = arrow$1;\n\n/**\n * Provides improved positioning for inline reference elements that can span\n * over multiple lines, such as hyperlinks or range selections.\n * @see https://floating-ui.com/docs/inline\n */\nconst inline = inline$1;\n\n/**\n * Built-in `limiter` that will stop `shift()` at a certain point.\n */\nconst limitShift = limitShift$1;\n\n/**\n * Computes the `x` and `y` coordinates that will place the floating element\n * next to a given reference element.\n */\nconst computePosition = (reference, floating, options) => {\n  // This caches the expensive `getClippingElementAncestors` function so that\n  // multiple lifecycle resets re-use the same result. It only lives for a\n  // single call. If other functions become expensive, we can add them as well.\n  const cache = new Map();\n  const mergedOptions = {\n    platform,\n    ...options\n  };\n  const platformWithCache = {\n    ...mergedOptions.platform,\n    _c: cache\n  };\n  return computePosition$1(reference, floating, {\n    ...mergedOptions,\n    platform: platformWithCache\n  });\n};\n\nexport { arrow, autoPlacement, autoUpdate, computePosition, flip, hide, inline, limitShift, platform, shift, size };\n","function getNodeName(node) {\n  if (isNode(node)) {\n    return (node.nodeName || '').toLowerCase();\n  }\n  // Mocked nodes in testing environments may not be instances of Node. By\n  // returning `#document` an infinite loop won't occur.\n  // https://github.com/floating-ui/floating-ui/issues/2317\n  return '#document';\n}\nfunction getWindow(node) {\n  var _node$ownerDocument;\n  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;\n}\nfunction getDocumentElement(node) {\n  var _ref;\n  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;\n}\nfunction isNode(value) {\n  return value instanceof Node || value instanceof getWindow(value).Node;\n}\nfunction isElement(value) {\n  return value instanceof Element || value instanceof getWindow(value).Element;\n}\nfunction isHTMLElement(value) {\n  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;\n}\nfunction isShadowRoot(value) {\n  // Browsers without `ShadowRoot` support.\n  if (typeof ShadowRoot === 'undefined') {\n    return false;\n  }\n  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;\n}\nfunction isOverflowElement(element) {\n  const {\n    overflow,\n    overflowX,\n    overflowY,\n    display\n  } = getComputedStyle(element);\n  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);\n}\nfunction isTableElement(element) {\n  return ['table', 'td', 'th'].includes(getNodeName(element));\n}\nfunction isTopLayer(element) {\n  return [':popover-open', ':modal'].some(selector => {\n    try {\n      return element.matches(selector);\n    } catch (e) {\n      return false;\n    }\n  });\n}\nfunction isContainingBlock(elementOrCss) {\n  const webkit = isWebKit();\n  const css = isElement(elementOrCss) ? getComputedStyle(elementOrCss) : elementOrCss;\n\n  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block\n  return css.transform !== 'none' || css.perspective !== 'none' || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));\n}\nfunction getContainingBlock(element) {\n  let currentNode = getParentNode(element);\n  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {\n    if (isContainingBlock(currentNode)) {\n      return currentNode;\n    } else if (isTopLayer(currentNode)) {\n      return null;\n    }\n    currentNode = getParentNode(currentNode);\n  }\n  return null;\n}\nfunction isWebKit() {\n  if (typeof CSS === 'undefined' || !CSS.supports) return false;\n  return CSS.supports('-webkit-backdrop-filter', 'none');\n}\nfunction isLastTraversableNode(node) {\n  return ['html', 'body', '#document'].includes(getNodeName(node));\n}\nfunction getComputedStyle(element) {\n  return getWindow(element).getComputedStyle(element);\n}\nfunction getNodeScroll(element) {\n  if (isElement(element)) {\n    return {\n      scrollLeft: element.scrollLeft,\n      scrollTop: element.scrollTop\n    };\n  }\n  return {\n    scrollLeft: element.scrollX,\n    scrollTop: element.scrollY\n  };\n}\nfunction getParentNode(node) {\n  if (getNodeName(node) === 'html') {\n    return node;\n  }\n  const result =\n  // Step into the shadow DOM of the parent of a slotted node.\n  node.assignedSlot ||\n  // DOM Element detected.\n  node.parentNode ||\n  // ShadowRoot detected.\n  isShadowRoot(node) && node.host ||\n  // Fallback.\n  getDocumentElement(node);\n  return isShadowRoot(result) ? result.host : result;\n}\nfunction getNearestOverflowAncestor(node) {\n  const parentNode = getParentNode(node);\n  if (isLastTraversableNode(parentNode)) {\n    return node.ownerDocument ? node.ownerDocument.body : node.body;\n  }\n  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {\n    return parentNode;\n  }\n  return getNearestOverflowAncestor(parentNode);\n}\nfunction getOverflowAncestors(node, list, traverseIframes) {\n  var _node$ownerDocument2;\n  if (list === void 0) {\n    list = [];\n  }\n  if (traverseIframes === void 0) {\n    traverseIframes = true;\n  }\n  const scrollableAncestor = getNearestOverflowAncestor(node);\n  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);\n  const win = getWindow(scrollableAncestor);\n  if (isBody) {\n    const frameElement = getFrameElement(win);\n    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);\n  }\n  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));\n}\nfunction getFrameElement(win) {\n  return Object.getPrototypeOf(win.parent) ? win.frameElement : null;\n}\n\nexport { getComputedStyle, getContainingBlock, getDocumentElement, getFrameElement, getNearestOverflowAncestor, getNodeName, getNodeScroll, getOverflowAncestors, getParentNode, getWindow, isContainingBlock, isElement, isHTMLElement, isLastTraversableNode, isNode, isOverflowElement, isShadowRoot, isTableElement, isTopLayer, isWebKit };\n","/**\n * Custom positioning reference element.\n * @see https://floating-ui.com/docs/virtual-elements\n */\n\nconst sides = ['top', 'right', 'bottom', 'left'];\nconst alignments = ['start', 'end'];\nconst placements = /*#__PURE__*/sides.reduce((acc, side) => acc.concat(side, side + \"-\" + alignments[0], side + \"-\" + alignments[1]), []);\nconst min = Math.min;\nconst max = Math.max;\nconst round = Math.round;\nconst floor = Math.floor;\nconst createCoords = v => ({\n  x: v,\n  y: v\n});\nconst oppositeSideMap = {\n  left: 'right',\n  right: 'left',\n  bottom: 'top',\n  top: 'bottom'\n};\nconst oppositeAlignmentMap = {\n  start: 'end',\n  end: 'start'\n};\nfunction clamp(start, value, end) {\n  return max(start, min(value, end));\n}\nfunction evaluate(value, param) {\n  return typeof value === 'function' ? value(param) : value;\n}\nfunction getSide(placement) {\n  return placement.split('-')[0];\n}\nfunction getAlignment(placement) {\n  return placement.split('-')[1];\n}\nfunction getOppositeAxis(axis) {\n  return axis === 'x' ? 'y' : 'x';\n}\nfunction getAxisLength(axis) {\n  return axis === 'y' ? 'height' : 'width';\n}\nfunction getSideAxis(placement) {\n  return ['top', 'bottom'].includes(getSide(placement)) ? 'y' : 'x';\n}\nfunction getAlignmentAxis(placement) {\n  return getOppositeAxis(getSideAxis(placement));\n}\nfunction getAlignmentSides(placement, rects, rtl) {\n  if (rtl === void 0) {\n    rtl = false;\n  }\n  const alignment = getAlignment(placement);\n  const alignmentAxis = getAlignmentAxis(placement);\n  const length = getAxisLength(alignmentAxis);\n  let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';\n  if (rects.reference[length] > rects.floating[length]) {\n    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);\n  }\n  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];\n}\nfunction getExpandedPlacements(placement) {\n  const oppositePlacement = getOppositePlacement(placement);\n  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];\n}\nfunction getOppositeAlignmentPlacement(placement) {\n  return placement.replace(/start|end/g, alignment => oppositeAlignmentMap[alignment]);\n}\nfunction getSideList(side, isStart, rtl) {\n  const lr = ['left', 'right'];\n  const rl = ['right', 'left'];\n  const tb = ['top', 'bottom'];\n  const bt = ['bottom', 'top'];\n  switch (side) {\n    case 'top':\n    case 'bottom':\n      if (rtl) return isStart ? rl : lr;\n      return isStart ? lr : rl;\n    case 'left':\n    case 'right':\n      return isStart ? tb : bt;\n    default:\n      return [];\n  }\n}\nfunction getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {\n  const alignment = getAlignment(placement);\n  let list = getSideList(getSide(placement), direction === 'start', rtl);\n  if (alignment) {\n    list = list.map(side => side + \"-\" + alignment);\n    if (flipAlignment) {\n      list = list.concat(list.map(getOppositeAlignmentPlacement));\n    }\n  }\n  return list;\n}\nfunction getOppositePlacement(placement) {\n  return placement.replace(/left|right|bottom|top/g, side => oppositeSideMap[side]);\n}\nfunction expandPaddingObject(padding) {\n  return {\n    top: 0,\n    right: 0,\n    bottom: 0,\n    left: 0,\n    ...padding\n  };\n}\nfunction getPaddingObject(padding) {\n  return typeof padding !== 'number' ? expandPaddingObject(padding) : {\n    top: padding,\n    right: padding,\n    bottom: padding,\n    left: padding\n  };\n}\nfunction rectToClientRect(rect) {\n  const {\n    x,\n    y,\n    width,\n    height\n  } = rect;\n  return {\n    width,\n    height,\n    top: y,\n    left: x,\n    right: x + width,\n    bottom: y + height,\n    x,\n    y\n  };\n}\n\nexport { alignments, clamp, createCoords, evaluate, expandPaddingObject, floor, getAlignment, getAlignmentAxis, getAlignmentSides, getAxisLength, getExpandedPlacements, getOppositeAlignmentPlacement, getOppositeAxis, getOppositeAxisPlacements, getOppositePlacement, getPaddingObject, getSide, getSideAxis, max, min, placements, rectToClientRect, round, sides };\n"],"names":["mergeClasses","options","arguments","length","undefined","baseClasses","newClasses","Component","nextClasses","Object","keys","forEach","key","concat","multiKeyStore","set","cache","key1","key2","value","subCache","get","Map","delete","useTheme","Symbol","for","pseudoClasses","jss","plugins","window","defaultOptions","disableGeneration","generateClassName","_options$disableGloba","disableGlobal","_options$productionPr","productionPrefix","_options$seed","seed","seedPrefix","ruleCounter","getNextCounterId","rule","styleSheet","name","indexOf","link","prefix","theme","nested","createGenerateClassName","sheetsCache","sheetsManager","sheetsRegistry","StylesContext","indexCounter","isPlainObject","item","constructor","deepmerge","target","source","clone","output","makeStyles","stylesOrCreator","classNamePrefixOption","classNamePrefix","_options$defaultTheme","defaultTheme","stylesOptions2","stylesCreator","themingEnabled","create","styles","err","overrides","stylesWithOverrides","getStylesCreator","index","meta","props","stylesOptions","instance","shouldUpdate","func","values","current","currentKey","_ref2","state","sheetManager","refs","staticSheet","dynamicStyles","flip","direction","generateId","serverGenerateClassName","createStyleSheet","attach","add","dynamicSheet","update","classes","_ref4","removeStyleSheet","remove","detach","useSynchronousEffect","_ref3","_ref","cacheClasses","lastProp","lastJSS","generate","getClasses","createMixins","breakpoints","spacing","mixins","_toolbar","gutters","console","warn","join","paddingLeft","paddingRight","up","toolbar","minHeight","formatMuiErrorMessage","code","url","i","encodeURIComponent","black","white","A100","A200","A400","A700","clamp","min","max","Math","decomposeColor","color","type","charAt","substr","re","RegExp","colors","match","map","n","parseInt","round","hexToRgb","marker","substring","Error","split","parseFloat","recomposeColor","getLuminance","rgb","h","s","l","a","f","k","push","hslToRgb","val","pow","Number","toFixed","alpha","light","text","primary","secondary","disabled","hint","divider","background","paper","default","action","active","hover","hoverOpacity","selected","selectedOpacity","disabledBackground","disabledOpacity","focus","focusOpacity","activatedOpacity","dark","icon","addLightOrDark","intent","shade","tonalOffset","tonalOffsetLight","tonalOffsetDark","hasOwnProperty","coefficient","lighten","main","darken","roundWithDeprecationWarning","caseAllCaps","textTransform","defaultFontFamily","createTypography","palette","typography","_ref$fontFamily","fontFamily","_ref$fontSize","fontSize","_ref$fontWeightLight","fontWeightLight","_ref$fontWeightRegula","fontWeightRegular","_ref$fontWeightMedium","fontWeightMedium","_ref$fontWeightBold","fontWeightBold","_ref$htmlFontSize","htmlFontSize","allVariants","pxToRem2","pxToRem","other","coef","size","buildVariant","fontWeight","lineHeight","letterSpacing","casing","variants","h1","h2","h3","h4","h5","h6","subtitle1","subtitle2","body1","body2","button","caption","overline","createShadow","borderRadius","xs","sm","md","lg","xl","defaultBreakpoints","acc","fn","properties","m","p","directions","t","r","b","x","y","aliases","marginX","marginY","paddingX","paddingY","getCssProperties","prop","_prop$split","_prop$split2","property","Array","isArray","dir","arg","spacingKeys","createUnarySpacing","themeSpacing","abs","transformer","styleFromPropValue","cssProperties","propValue","reduce","cssProperty","transformed","getValue","getStyleFromPropValue","themeBreakpoints","_themeBreakpoints","breakpoint","handleBreakpoints","propTypes","filterProps","easing","easeInOut","easeOut","easeIn","sharp","duration","shortest","shorter","short","standard","complex","enteringScreen","leavingScreen","formatMs","milliseconds","_options$duration","durationOption","_options$easing","easingOption","_options$delay","delay","animatedProp","getAutoHeightDuration","height","constant","mobileStepper","speedDial","appBar","drawer","modal","snackbar","tooltip","_options$breakpoints","breakpointsInput","_options$mixins","mixinsInput","_options$palette","paletteInput","spacingInput","_options$typography","typographyInput","_palette$primary","_palette$secondary","_palette$error","error","_palette$warning","warning","_palette$info","info","_palette$success","success","_palette$type","_palette$contrastThre","contrastThreshold","_palette$tonalOffset","getContrastText","contrastText","foreground","lumA","lumB","getContrastRatio","augmentColor","mainShade","lightShade","darkShade","JSON","stringify","types","common","grey","createPalette","_breakpoints$values","_breakpoints$unit","unit","_breakpoints$step","step","between","start","end","endIndex","down","upperbound","only","width","createBreakpoints","mui","transform","_len","args","_key","argument","defineProperty","createSpacing","muiTheme","shadows","shape","transitions","zIndex","_options$withTheme","withTheme","useStyles","displayName","WithStyles","ref","innerRef","defaultProps","more","params","propName","getThemeProps","capitalize","string","toUpperCase","slice","setRef","useForkRef","refA","refB","refValue","useEnhancedEffect","useEventCallback","apply","hadKeyboardEvent","hadFocusVisibleRecently","hadFocusVisibleRecentlyTimeout","inputTypesWhitelist","search","tel","email","password","number","date","month","week","time","datetime","handleKeyDown","event","metaKey","altKey","ctrlKey","handlePointerDown","handleVisibilityChange","this","visibilityState","isFocusVisible","node","tagName","matches","readOnly","isContentEditable","handleBlurVisible","clearTimeout","setTimeout","useIsFocusVisible","onBlurVisible","doc","ownerDocument","addEventListener","_props$pulsate","pulsate","rippleX","rippleY","rippleSize","inProp","in","_props$onExited","onExited","timeout","_React$useState","leaving","setLeaving","rippleClassName","ripple","rippleVisible","ripplePulsate","rippleStyles","top","left","childClassName","child","childLeaving","childPulsate","handleExited","timeoutId","className","style","TouchRipple","_props$center","center","centerProp","ripples","setRipples","nextKey","rippleCallback","ignoringMouseDown","startTimer","startTimerCommit","container","startCommit","cb","oldRipples","_options$pulsate","_options$center","_options$fakeElement","fakeElement","element","rect","getBoundingClientRect","clientX","clientY","touches","sqrt","sizeX","clientWidth","sizeY","clientHeight","stop","persist","root","TransitionGroup","component","exit","overflow","pointerEvents","position","right","bottom","opacity","animation","animationDuration","display","backgroundColor","ButtonBase","buttonRefProp","buttonRef","_props$centerRipple","centerRipple","children","_props$component","_props$disabled","_props$disableRipple","disableRipple","_props$disableTouchRi","disableTouchRipple","_props$focusRipple","focusRipple","focusVisibleClassName","onBlur","onClick","onFocus","onFocusVisible","onKeyDown","onKeyUp","onMouseDown","onMouseLeave","onMouseUp","onTouchEnd","onTouchMove","onTouchStart","onDragLeave","_props$tabIndex","tabIndex","TouchRippleProps","_props$type","rippleRef","focusVisible","setFocusVisible","_useIsFocusVisible","focusVisibleRef","useRippleHandler","rippleAction","eventCallback","skipRippleAction","handleMouseDown","handleDragLeave","handleMouseUp","handleMouseLeave","preventDefault","handleTouchStart","handleTouchEnd","handleTouchMove","handleBlur","handleFocus","currentTarget","isNonNativeButton","href","keydownRef","handleKeyUp","defaultPrevented","ComponentProp","buttonProps","role","handleUserRef","handleOwnRef","handleRef","_React$useState2","mountedState","setMountedState","enableTouchRipple","alignItems","justifyContent","WebkitTapHighlightColor","outline","border","margin","padding","cursor","userSelect","verticalAlign","textDecoration","borderStyle","colorAdjust","IconButton","_props$edge","edge","_props$color","_props$disableFocusRi","disableFocusRipple","_props$size","edgeStart","edgeEnd","label","textAlign","flex","transition","marginLeft","marginRight","colorInherit","colorPrimary","colorSecondary","sizeSmall","SwitchBase","controlled","defaultProp","isControlled","valueState","setValue","autoFocus","checkedProp","checked","checkedIcon","defaultChecked","disabledProp","id","inputProps","inputRef","onChange","required","_useControlled","Boolean","newValue","_useControlled2","setCheckedState","muiFormControl","hasLabelFor","input","newChecked","Switch","thumb","switchBase","track","boxSizing","flexShrink","boxShadow","DEFAULT_IGNORE_ERRORS","InboundFilters","__initStatic","__init","_options","prototype","call","setupOnce","addGlobalEventProcessor","getCurrentHub","eventProcess","hub","self","getIntegration","client","getClient","clientOptions","getOptions","internalOptions","allowUrls","denyUrls","ignoreErrors","ignoreInternal","_mergeOptions","exception","e","_isSentryError","__SENTRY_DEBUG__","message","oO","_getPossibleEventMessages","some","pattern","_isIgnoredError","_getEventFilterUrl","_isDeniedUrl","_isAllowedUrl","_shouldDropEvent","frames","stacktrace","frame","filename","_getLastValidUrl","originalFunctionToString","FunctionToString","Function","toString","context","installedIntegrations","getIntegrationsToSetup","defaultIntegrations","userIntegrations","integrations","integration","isDefaultInstance","finalIntegrations","integrationsByName","currentInstance","existingInstance","filterDuplicates","debugIndex","findIndex","debugInstance","splice","SentryError","logLevel","super","setPrototypeOf","DSN_REGEX","dsnToString","dsn","withPassword","host","path","pass","port","projectId","protocol","publicKey","dsnFromComponents","components","makeDsn","from","str","exec","lastPath","pop","projectMatch","dsnFromString","isValidProtocol","isNaN","validateDsn","getBaseApiEndpoint","getEnvelopeEndpointWithUrlEncodedAuth","tunnelOrOptions","tunnel","sdkInfo","_metadata","sdk","_getIngestEndpoint","sentry_key","sentry_version","sentry_client","version","_encodedAuth","STACKTRACE_LIMIT","createStackParser","parsers","sortedParsers","sort","stack","skipFirst","line","cleanedLine","replace","parser","localStack","firstFrameFunction","function","lastFrameFunction","reverse","stripSentryFramesAndReverse","defaultFunctionName","getFunctionName","supportsFetch","Headers","Request","Response","isNativeFetch","test","global","handlers","instrumented","addInstrumentationHandler","callback","level","originalConsoleMethod","triggerHandlers","triggerDOMHandler","bind","globalDOMEventHandler","makeDOMEventHandler","document","proto","originalAddEventListener","listener","__sentry_instrumentation_handlers__","handlerForType","refCount","handler","originalRemoveEventListener","instrumentDOM","xhrproto","XMLHttpRequest","originalOpen","xhr","xhrInfo","__sentry_xhr__","method","is","__sentry_own_request__","onreadystatechangeHandler","readyState","status_code","status","endTimestamp","Date","now","startTimestamp","onreadystatechange","original","readyStateArgs","originalSend","body","instrumentXHR","fetch","result","sandbox","createElement","hidden","head","appendChild","contentWindow","removeChild","supportsNativeFetch","originalFetch","handlerData","fetchData","getFetchMethod","getFetchUrl","then","response","chrome","isChromePackagedApp","app","runtime","hasHistoryApi","history","pushState","replaceState","supportsHistory","oldOnPopState","onpopstate","to","location","lastHref","_oO","historyReplacementFunction","originalHistoryFunction","String","instrumentHistory","_oldOnErrorHandler","onerror","msg","column","_oldOnUnhandledRejectionHandler","onunhandledrejection","instrument","data","fetchArgs","debounceDuration","debounceTimerID","lastCapturedEvent","globalListener","shouldSkipDOMEvent","previous","shouldShortcircuitPreviousDebounce","normalize","depth","maxProperties","visit","ERROR","normalizeToSize","object","maxSize","normalized","encodeURI","utf8Length","memo","hasWeakSet","WeakSet","inner","obj","has","memoBuilder","memoize","unmemoize","includes","stringified","_events","g","getPrototypeOf","stringifyValue","startsWith","valueWithToJSON","toJSON","numAdded","visitable","visitKey","visitValue","createEnvelope","headers","items","addItemToEnvelope","envelope","newItem","forEachEnvelopeItem","envelopeItem","envelopeItemType","encodeUTF8","textEncoder","TextEncoder","encode","serializeEnvelope","envHeaders","parts","append","next","itemHeaders","payload","Uint8Array","stringifiedPayload","buffers","totalLength","buf","merged","offset","buffer","concatBuffers","createAttachmentEnvelopeItem","attachment","content_type","contentType","attachment_type","attachmentType","ITEM_TYPE_TO_DATA_CATEGORY_MAP","session","sessions","transaction","client_report","user_report","envelopeItemTypeToDataCategory","getSdkMetadataForEnvelopeHeader","metadata","ALREADY_SEEN_ERROR","BaseClient","_integrations","__init2","_integrationsInitialized","__init3","_numProcessing","__init4","_outcomes","_dsn","_transport","transport","recordDroppedEvent","transportOptions","captureException","scope","log","eventId","event_id","_process","eventFromException","_captureEvent","captureMessage","promisedEvent","eventFromMessage","captureEvent","originalException","captureSession","_isEnabled","release","sendSession","init","getDsn","getTransport","flush","_isClientDoneProcessing","clientFinished","transportFlushed","close","enabled","setupIntegrations","integrationIndex","getIntegrationById","integrationId","sendEvent","env","eventType","packages","enhanceEventWithSdkInfo","envelopeHeaders","dynamicSamplingContext","sdkProcessingMetadata","sent_at","toISOString","trace","createEventEnvelopeHeaders","createEventEnvelope","attachments","_sendEnvelope","createSessionEnvelope","reason","category","sendClientReports","_updateSessionFromEvent","crashed","errored","exceptions","ex","mechanism","handled","sessionNonTerminal","errors","resolve","ticked","interval","setInterval","clearInterval","_prepareEvent","normalizeDepth","normalizeMaxBreadth","prepared","timestamp","_applyClientOptions","_applyIntegrationsMetadata","finalScope","captureContext","getAttachments","applyToEvent","evt","_normalizeEvent","maxBreadth","breadcrumbs","user","contexts","extra","spans","span","environment","dist","maxValueLength","request","integrationsArray","_processEvent","finalEvent","sentryError","beforeSend","sampleRate","isTransaction","random","__sentry__","rv","nullErr","_ensureBeforeSendRv","processedEvent","getSession","transactionInfo","transaction_info","changes","propagations","promise","send","_clearOutcomes","outcomes","quantity","exceptionFromError","stackParser","parseStackFrames","extractMessage","eventFromError","popSize","framesToPop","reactMinifiedRegexp","getPopSize","eventFromUnknownInput","syntheticException","attachStacktrace","isUnhandledRejection","domException","eventFromString","tags","__serialized__","eventFromPlainObject","synthetic","validSeverityLevels","parseUrl","query","fragment","relative","BREADCRUMB_INTEGRATION_ID","Breadcrumbs","dom","sentry","_consoleBreadcrumb","keyAttrs","serializeAttribute","addBreadcrumb","_xhrBreadcrumb","_fetchBreadcrumb","_historyBreadcrumb","breadcrumb","logger","parsedLoc","parsedFrom","parsedTo","globalObject","BrowserClient","_flushOutcomes","breadcrumbIntegration","platform","discarded_events","navigator","sendBeacon","UNKNOWN_FUNCTION","createFrame","lineno","colno","in_app","chromeRegex","chromeEvalRegex","geckoREgex","geckoEvalRegex","winjsRegex","defaultStackParser","subMatch","extractSafariExtensionDetails","isSafariExtension","isSafariWebExtension","ignoreOnError","shouldIgnoreOnError","wrap","before","wrapper","__sentry_wrapped__","sentryWrapped","wrappedArguments","addEventProcessor","getOwnPropertyDescriptor","configurable","DEFAULT_EVENT_TARGET","TryCatch","eventTarget","requestAnimationFrame","_wrapTimeFunction","_wrapRAF","_wrapXHR","eventTargetOption","_wrapEventTarget","originalCallback","wrapOptions","originalFunction","eventName","handleEvent","wrappedEventHandler","originalEventHandler","GlobalHandlers","_installFunc","_installGlobalOnErrorHandler","_installGlobalOnUnhandledRejectionHandler","stackTraceLimit","installFunc","getHubAndOptions","groups","_enhanceEventWithInitialFrame","_eventFromIncompleteOnError","addMechanismAndCapture","detail","ev","ev0","ev0s","ev0sf","LinkedErrors","_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","fingerprint","previousFingerprint","HttpContext","referrer","userAgent","Referer","DEFAULT_RETRY_AFTER","DEFAULT_TRANSPORT_BUFFER_SIZE","createTransport","makeRequest","task","$","taskProducer","drain","reject","counter","capturedSetTimeout","makePromiseBuffer","bufferSize","rateLimits","filteredEnvelopeItems","envelopeItemDataCategory","limits","all","disabledUntil","isRateLimited","filteredEnvelope","recordEnvelopeLoss","_","statusCode","updatedRateLimits","rateLimitHeader","retryAfterHeader","trim","retryAfter","categories","headerDelay","header","headerDate","parse","parseRetryAfterHeader","updateRateLimits","cachedFetchImpl","makeFetchTransport","nativeFetch","fetchImpl","getNativeFetchImplementation","requestOptions","referrerPolicy","keepalive","fetchOptions","XHR_READYSTATE_DONE","makeXHRTransport","getResponseHeader","open","setRequestHeader","SENTRY_RELEASE","autoSessionTracking","clientClass","debug","enable","getScope","initialScope","bindClient","initAndBind","startSessionOnHub","startSessionTracking","showReportDialog","getStackTop","getUser","lastEventId","script","async","src","dsnLike","dialogOptions","endpoint","encodedOptions","getReportDialogEndpoint","onLoad","onload","injectionPoint","startSession","ignoreDuration","configureScope","withScope","API_VERSION","DEFAULT_BREADCRUMBS","Hub","_stack","_version","isOlderThan","pushScope","getStack","popScope","_lastEventId","_withClient","beforeBreadcrumb","maxBreadcrumbs","mergedBreadcrumb","finalBreadcrumb","setUser","setTags","setExtras","extras","setTag","setExtra","setContext","run","oldHub","makeMain","startTransaction","customSamplingContext","_callExtensionMethod","traceHeaders","endSession","_sendSessionUpdate","layer","setSession","currentSession","shouldSendDefaultPii","sendDefaultPii","getMainCarrier","__SENTRY__","extensions","carrier","registry","getHubFromCarrier","setHubOnCarrier","hasHubOnCarrier","activeDomain","domain","registryHubTopStack","_Oo","getHubFromActiveDomain","Scope","_notifyingListeners","_scopeListeners","_eventProcessors","_breadcrumbs","_attachments","_user","_tags","_extra","_contexts","_sdkProcessingMetadata","newScope","_level","_span","_session","_transactionName","_fingerprint","_requestSession","addScopeListener","_notifyScopeListeners","getRequestSession","setRequestSession","requestSession","setFingerprint","setLevel","setTransactionName","setSpan","getSpan","getTransaction","updatedScope","clear","maxCrumbs","clearBreadcrumbs","addAttachment","clearAttachments","getTraceContext","transactionName","_applyFingerprint","_notifyEventProcessors","getGlobalEventProcessors","setSDKProcessingMetadata","newData","processors","processor","final","makeSession","startingTime","sid","started","did","attrs","ip_address","ipAddress","user_agent","sessionToJSON","updateSession","username","closeSession","SDK_VERSION","_jsxFileName","UNKNOWN_COMPONENT","Profiler","_mountSpan","_updateSpan","includeRender","includeUpdates","activeTransaction","getActiveTransaction","startChild","description","op","componentDidMount","finish","shouldComponentUpdate","updateProps","changedProps","filter","componentDidUpdate","componentWillUnmount","render","withProfiler","WrappedComponent","componentDisplayName","Wrapped","__self","__source","fileName","lineNumber","reactRouterV5Instrumentation","routes","matchPath","allRoutes","normalizeTransactionName","pathname","branches","matchRoutes","isExact","customStartTransaction","startTransactionOnPageLoad","startTransactionOnLocationChange","initPathName","listen","createReactRouterInstrumentation","branch","route","computeRootMatch","withSentryRouting","Route","WrappedRoute","computedMatch","setName","BrowserTracing","__SENTRY_TRACING__","htmlTreeAsString","elem","currentElem","out","nextStr","len","_htmlElementAsString","separator","parentNode","el","attr","toLowerCase","keyAttrPairs","keyAttr","getAttribute","keyAttrPair","allowedAttrs","getLocationHref","isGlobalObj","GLOBAL","globalThis","getGlobalObject","getGlobalSingleton","creator","objectToString","isError","wat","isInstanceOf","isBuiltin","isErrorEvent","isDOMError","isDOMException","isString","isPrimitive","isEvent","Event","isElement","Element","isRegExp","isThenable","isSyntheticEvent","base","_e","CONSOLE_LEVELS","consoleSandbox","originalConsole","wrappedLevels","originalWrappedFunc","__sentry_original__","makeLogger","disable","uuid4","crypto","msCrypto","randomUUID","getRandomByte","getRandomValues","c","getFirstException","getEventDescription","firstException","addExceptionTypeValue","addExceptionMechanism","newMechanism","currentMechanism","mergedData","checkOrSetAlreadyCaught","__sentry_captured__","arrayify","maybeArray","isNodeEnv","__SENTRY_BROWSER_BUNDLE__","process","dynamicRequire","mod","require","fill","replacementFactory","wrapped","markFunctionWrapped","addNonEnumerableProperty","writable","getOriginalFunction","urlEncode","convertToPlainObject","getOwnProperties","newObj","serializeEventTarget","CustomEvent","extractedProps","extractExceptionKeysForMessage","maxLength","includedKeys","serialized","dropUndefinedKeys","inputValue","_dropUndefinedKeys","memoizationMap","memoVal","returnValue","truncate","safeJoin","delimiter","isMatchingPattern","States","resolvedSyncPromise","SyncPromise","rejectedSyncPromise","_state","PENDING","_handlers","executor","__init5","__init6","_resolve","_reject","onfulfilled","onrejected","_executeHandlers","onfinally","isRejected","_setResult","RESOLVED","REJECTED","_value","cachedHandlers","dateTimestampSource","nowSeconds","platformPerformance","module","performance","getNodePerformance","timeOrigin","getBrowserPerformance","timestampSource","dateTimestampInSeconds","timestampInSeconds","timestampWithMs","_browserPerformanceTimeOriginMode","threshold","performanceNow","dateNow","timeOriginDelta","timeOriginIsReliable","navigationStart","timing","navigationStartDelta","_extends","assign","_objectWithoutPropertiesLoose","excluded","sourceKeys","_assertThisInitialized","ReferenceError","FormikContext","createContext","FormikProvider","Provider","FormikConsumer","Consumer","useFormikContext","formik","useContext","isEmptyArray","isFunction","isObject","isInteger","floor","isEmptyChildren","Children","count","isPromise","getIn","def","setIn","res","resVal","pathArray","currentPath","currentObj","nextPath","setNestedObjectValues","visited","WeakMap","_i","_Object$keys","emptyErrors","emptyTouched","useFormik","_ref$validateOnChange","validateOnChange","_ref$validateOnBlur","validateOnBlur","_ref$validateOnMount","validateOnMount","isInitialValid","_ref$enableReinitiali","enableReinitialize","onSubmit","rest","initialValues","useRef","initialErrors","initialTouched","initialStatus","isMounted","fieldRegistry","useEffect","setIteration","useState","stateRef","touched","isSubmitting","isValidating","submitCount","dispatch","useCallback","prev","field","formikReducer","runValidateHandler","Promise","maybePromisedErrors","validate","actualException","runValidationSchema","validationSchema","schema","validateAt","sync","normalizedValues","prepareDataForValidation","abortEarly","validateYupSchema","yupError","_iterator","_isArray","iterator","_ref5","done","yupToFormErrors","runSingleFieldLevelValidation","runFieldLevelValidations","fieldKeysWithValidation","fieldValidations","fieldErrorsList","curr","runAllValidations","fieldErrors","schemaErrors","validateErrors","arrayMerge","validateFormWithHighPriority","combinedErrors","resetForm","nextState","dispatchFn","onReset","maybePromisedOnReset","imperativeMethods","validateField","maybePromise","registerField","unregisterField","setTouched","shouldValidate","setErrors","setValues","resolvedValues","setFieldError","setFieldValue","executeChange","eventOrTextValue","maybePath","parsed","outerHTML","multiple","currentValue","valueProp","currentArrayOfValues","isValueInArray","getValueForCheckbox","getSelectedValues","handleChange","eventOrPath","setFieldTouched","executeBlur","_e$target","eventOrString","setFormikState","stateOrCb","setStatus","setSubmitting","submitForm","isInstanceOfError","promiseOrUndefined","executeSubmit","_errors","handleSubmit","stopPropagation","validateForm","handleReset","getFieldMeta","initialValue","initialError","getFieldHelpers","setError","getFieldProps","nameOrOptions","isAnObject","as","dirty","useMemo","isValid","Formik","formikbag","useImperativeHandle","destination","shouldClone","isMergeableObject","useIsomorphicLayoutEffect","useLayoutEffect","Field","legacyBag","form","asElement","_innerRef","_rest","Form","forwardRef","_action","_useFormikContext","connect","Comp","C","insert","arrayLike","copy","copyArrayLike","maxIndex","createAlterationHandler","alteration","defaultFunction","FieldArrayInner","_React$Component","_this","updateArrayField","alterTouched","alterErrors","_this$props","prevState","updateErrors","updateTouched","fieldError","fieldTouched","handlePush","swap","indexA","indexB","array","handleSwap","move","handleMove","handleInsert","handleReplace","unshift","arr","handleUnshift","handleRemove","handlePop","subClass","superClass","__proto__","_proto","prevProps","every","v","tmp","arrayHelpers","_this$props2","FieldArray","keyList","hasProp","hasElementType","equal","arrA","arrB","dateA","dateB","getTime","regexpA","regexpB","$$typeof","exports","computeCoordsFromPlacement","placement","rtl","reference","floating","sideAxis","alignmentAxis","alignLength","side","isVertical","commonX","commonY","commonAlign","coords","computePosition","config","strategy","middleware","validMiddleware","isRTL","rects","getElementRects","statefulPlacement","middlewareData","resetCount","nextX","nextY","reset","initialPlacement","elements","detectOverflow","_await$platform$isEle","boundary","rootBoundary","elementContext","altBoundary","paddingObject","clippingClientRect","getClippingRect","contextElement","getDocumentElement","offsetParent","getOffsetParent","offsetScale","getScale","elementClientRect","convertOffsetParentRelativeRectToViewportRelativeRect","arrow","axis","arrowDimensions","getDimensions","isYAxis","minProp","maxProp","clientProp","endDiff","startDiff","arrowOffsetParent","clientSize","centerToReference","largestPossiblePadding","minPadding","maxPadding","min$1","shouldAddOffset","alignmentOffset","centerOffset","autoPlacement","_middlewareData$autoP","_middlewareData$autoP2","_placementsThatFitOnE","crossAxis","alignment","allowedPlacements","autoAlignment","detectOverflowOptions","placements$1","getPlacementList","currentIndex","currentPlacement","alignmentSides","currentOverflows","allOverflows","overflows","nextPlacement","placementsSortedByMostSpace","d","resetPlacement","_middlewareData$arrow","_middlewareData$flip","mainAxis","checkMainAxis","checkCrossAxis","fallbackPlacements","specifiedFallbackPlacements","fallbackStrategy","fallbackAxisSideDirection","flipAlignment","isBasePlacement","placements","overflowsData","sides","_middlewareData$flip2","_overflowsData$filter","nextIndex","_overflowsData$map$so","getSideOffsets","isAnySideFullyClipped","hide","offsets","referenceHiddenOffsets","referenceHidden","escapedOffsets","escaped","getBoundingRect","minX","minY","inline","nativeClientRects","getClientRects","clientRects","sortedRects","prevRect","getRectsByLine","fallback","resetRects","find","firstRect","lastRect","isTop","isLeftSide","maxRight","minLeft","measureRects","_middlewareData$offse","diffCoords","mainAxisMulti","crossAxisMulti","rawValue","convertValueToCoords","shift","limiter","mainAxisCoord","crossAxisCoord","maxSide","limitedCoords","limitShift","rawOffset","computedOffset","limitMin","limitMax","_middlewareData$offse2","isOriginSide","heightSide","widthSide","overflowAvailableHeight","overflowAvailableWidth","noShift","availableHeight","availableWidth","maximumClippingWidth","maximumClippingHeight","xMin","xMax","yMin","yMax","nextDimensions","getCssDimensions","css","hasOffset","offsetWidth","offsetHeight","shouldFallback","unwrapElement","domElement","isFinite","noOffsets","getVisualOffsets","win","visualViewport","offsetLeft","offsetTop","includeScale","isFixedStrategy","clientRect","scale","visualOffsets","isFixed","floatingOffsetParent","shouldAddVisualOffsets","offsetWin","currentIFrame","frameElement","iframeScale","iframeRect","clientLeft","clientTop","paddingTop","getWindowScrollBarX","scrollLeft","getClientRectFromClippingAncestor","clippingAncestor","html","visualViewportBased","getViewportRect","scroll","scrollWidth","scrollHeight","scrollTop","getDocumentRect","getInnerBoundingClientRect","hasFixedPositionAncestor","stopNode","getRectRelativeToOffsetParent","isOffsetParentAnElement","documentElement","offsetRect","getTrueOffsetParent","polyfill","clippingAncestors","cachedResult","currentContainingBlockComputedStyle","elementIsFixed","currentNode","computedStyle","currentNodeIsContaining","ancestor","getClippingElementAncestors","_c","firstClippingAncestor","clippingRect","accRect","getOffsetParentFn","getDimensionsFn","autoUpdate","ancestorScroll","ancestorResize","elementResize","ResizeObserver","layoutShift","IntersectionObserver","animationFrame","referenceEl","ancestors","passive","cleanupIo","onMove","io","cleanup","disconnect","refresh","skip","rootMargin","isFirstUpdate","handleObserve","entries","ratio","intersectionRatio","observe","observeMove","frameId","reobserveFrame","resizeObserver","firstEntry","unobserve","cancelAnimationFrame","prevRefRect","frameLoop","nextRefRect","removeEventListener","mergedOptions","platformWithCache","getNodeName","isNode","nodeName","getWindow","_node$ownerDocument","defaultView","Node","isHTMLElement","HTMLElement","isShadowRoot","ShadowRoot","isOverflowElement","overflowX","overflowY","getComputedStyle","isTableElement","isTopLayer","selector","isContainingBlock","elementOrCss","webkit","isWebKit","perspective","containerType","backdropFilter","willChange","contain","getContainingBlock","getParentNode","isLastTraversableNode","CSS","supports","getNodeScroll","scrollX","scrollY","assignedSlot","getNearestOverflowAncestor","getOverflowAncestors","list","traverseIframes","_node$ownerDocument2","scrollableAncestor","isBody","parent","getFrameElement","alignments","createCoords","oppositeSideMap","oppositeAlignmentMap","evaluate","param","getSide","getAlignment","getOppositeAxis","getAxisLength","getSideAxis","getAlignmentAxis","getAlignmentSides","mainAlignmentSide","getOppositePlacement","getExpandedPlacements","oppositePlacement","getOppositeAlignmentPlacement","getOppositeAxisPlacements","isStart","lr","rl","tb","bt","getSideList","getPaddingObject","expandPaddingObject","rectToClientRect"],"sourceRoot":""}