{"version":3,"file":"static/js/vendors-810db3d8.2015605d.js","mappings":"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","sources":["../node_modules/@mui/utils/esm/integerPropType/integerPropType.js","../node_modules/@mui/utils/esm/isHostComponent/isHostComponent.js","../node_modules/@mui/utils/esm/isMuiElement/isMuiElement.js","../node_modules/@mui/utils/esm/omitEventHandlers/omitEventHandlers.js","../node_modules/@mui/utils/esm/mergeSlotProps/mergeSlotProps.js","../node_modules/@mui/utils/esm/ownerDocument/ownerDocument.js","../node_modules/@mui/utils/esm/ownerWindow/ownerWindow.js","../node_modules/@mui/utils/esm/ponyfillGlobal/ponyfillGlobal.js","../node_modules/@mui/utils/esm/refType/refType.js","../node_modules/@mui/utils/esm/requirePropFactory/requirePropFactory.js","../node_modules/@mui/utils/esm/resolveComponentProps/resolveComponentProps.js","../node_modules/@mui/utils/esm/resolveProps/resolveProps.js","../node_modules/@mui/utils/esm/scrollLeft/scrollLeft.js","../node_modules/@mui/utils/esm/setRef/setRef.js","../node_modules/@mui/utils/esm/unsupportedProp/unsupportedProp.js","../node_modules/@mui/utils/esm/useControlled/useControlled.js","../node_modules/@mui/utils/esm/useEnhancedEffect/useEnhancedEffect.js","../node_modules/@mui/utils/esm/useEventCallback/useEventCallback.js","../node_modules/@mui/utils/esm/useForkRef/useForkRef.js","../node_modules/@mui/utils/esm/useId/useId.js","../node_modules/@mui/utils/esm/useIsFocusVisible/useIsFocusVisible.js","../node_modules/@mui/utils/esm/useLazyRef/useLazyRef.js","../node_modules/@mui/utils/esm/useOnMount/useOnMount.js","../node_modules/@mui/utils/esm/usePreviousProps/usePreviousProps.js","../node_modules/@mui/utils/esm/useSlotProps/useSlotProps.js","../node_modules/@mui/utils/esm/useTimeout/useTimeout.js","../node_modules/@mui/utils/esm/visuallyHidden/visuallyHidden.js","../node_modules/@mui/utils/node_modules/react-is/cjs/react-is.production.js","../node_modules/@mui/utils/node_modules/react-is/index.js"],"sourcesContent":["export function getTypeByValue(value) {\n  const valueType = typeof value;\n  switch (valueType) {\n    case 'number':\n      if (Number.isNaN(value)) {\n        return 'NaN';\n      }\n      if (!Number.isFinite(value)) {\n        return 'Infinity';\n      }\n      if (value !== Math.floor(value)) {\n        return 'float';\n      }\n      return 'number';\n    case 'object':\n      if (value === null) {\n        return 'null';\n      }\n      return value.constructor.name;\n    default:\n      return valueType;\n  }\n}\n\n// IE 11 support\nfunction ponyfillIsInteger(x) {\n  // eslint-disable-next-line no-restricted-globals\n  return typeof x === 'number' && isFinite(x) && Math.floor(x) === x;\n}\nconst isInteger = Number.isInteger || ponyfillIsInteger;\nfunction requiredInteger(props, propName, componentName, location) {\n  const propValue = props[propName];\n  if (propValue == null || !isInteger(propValue)) {\n    const propType = getTypeByValue(propValue);\n    return new RangeError(`Invalid ${location} \\`${propName}\\` of type \\`${propType}\\` supplied to \\`${componentName}\\`, expected \\`integer\\`.`);\n  }\n  return null;\n}\nfunction validator(props, propName, ...other) {\n  const propValue = props[propName];\n  if (propValue === undefined) {\n    return null;\n  }\n  return requiredInteger(props, propName, ...other);\n}\nfunction validatorNoop() {\n  return null;\n}\nvalidator.isRequired = requiredInteger;\nvalidatorNoop.isRequired = validatorNoop;\nexport default process.env.NODE_ENV === 'production' ? validatorNoop : validator;","/**\n * Determines if a given element is a DOM element name (i.e. not a React component).\n */\nfunction isHostComponent(element) {\n  return typeof element === 'string';\n}\nexport default isHostComponent;","import * as React from 'react';\nexport default function isMuiElement(element, muiNames) {\n  var _muiName, _element$type;\n  return /*#__PURE__*/React.isValidElement(element) && muiNames.indexOf( // For server components `muiName` is avaialble in element.type._payload.value.muiName\n  // relevant info - https://github.com/facebook/react/blob/2807d781a08db8e9873687fccc25c0f12b4fb3d4/packages/react/src/ReactLazy.js#L45\n  // eslint-disable-next-line no-underscore-dangle\n  (_muiName = element.type.muiName) != null ? _muiName : (_element$type = element.type) == null || (_element$type = _element$type._payload) == null || (_element$type = _element$type.value) == null ? void 0 : _element$type.muiName) !== -1;\n}","/**\n * Removes event handlers from the given object.\n * A field is considered an event handler if it is a function with a name beginning with `on`.\n *\n * @param object Object to remove event handlers from.\n * @returns Object with event handlers removed.\n */\nfunction omitEventHandlers(object) {\n  if (object === undefined) {\n    return {};\n  }\n  const result = {};\n  Object.keys(object).filter(prop => !(prop.match(/^on[A-Z]/) && typeof object[prop] === 'function')).forEach(prop => {\n    result[prop] = object[prop];\n  });\n  return result;\n}\nexport default omitEventHandlers;","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport clsx from 'clsx';\nimport extractEventHandlers from '../extractEventHandlers';\nimport omitEventHandlers from '../omitEventHandlers';\n/**\n * Merges the slot component internal props (usually coming from a hook)\n * with the externally provided ones.\n *\n * The merge order is (the latter overrides the former):\n * 1. The internal props (specified as a getter function to work with get*Props hook result)\n * 2. Additional props (specified internally on a Base UI component)\n * 3. External props specified on the owner component. These should only be used on a root slot.\n * 4. External props specified in the `slotProps.*` prop.\n * 5. The `className` prop - combined from all the above.\n * @param parameters\n * @returns\n */\nfunction mergeSlotProps(parameters) {\n  const {\n    getSlotProps,\n    additionalProps,\n    externalSlotProps,\n    externalForwardedProps,\n    className\n  } = parameters;\n  if (!getSlotProps) {\n    // The simpler case - getSlotProps is not defined, so no internal event handlers are defined,\n    // so we can simply merge all the props without having to worry about extracting event handlers.\n    const joinedClasses = clsx(additionalProps == null ? void 0 : additionalProps.className, className, externalForwardedProps == null ? void 0 : externalForwardedProps.className, externalSlotProps == null ? void 0 : externalSlotProps.className);\n    const mergedStyle = _extends({}, additionalProps == null ? void 0 : additionalProps.style, externalForwardedProps == null ? void 0 : externalForwardedProps.style, externalSlotProps == null ? void 0 : externalSlotProps.style);\n    const props = _extends({}, additionalProps, externalForwardedProps, externalSlotProps);\n    if (joinedClasses.length > 0) {\n      props.className = joinedClasses;\n    }\n    if (Object.keys(mergedStyle).length > 0) {\n      props.style = mergedStyle;\n    }\n    return {\n      props,\n      internalRef: undefined\n    };\n  }\n\n  // In this case, getSlotProps is responsible for calling the external event handlers.\n  // We don't need to include them in the merged props because of this.\n\n  const eventHandlers = extractEventHandlers(_extends({}, externalForwardedProps, externalSlotProps));\n  const componentsPropsWithoutEventHandlers = omitEventHandlers(externalSlotProps);\n  const otherPropsWithoutEventHandlers = omitEventHandlers(externalForwardedProps);\n  const internalSlotProps = getSlotProps(eventHandlers);\n\n  // The order of classes is important here.\n  // Emotion (that we use in libraries consuming Base UI) depends on this order\n  // to properly override style. It requires the most important classes to be last\n  // (see https://github.com/mui/material-ui/pull/33205) for the related discussion.\n  const joinedClasses = clsx(internalSlotProps == null ? void 0 : internalSlotProps.className, additionalProps == null ? void 0 : additionalProps.className, className, externalForwardedProps == null ? void 0 : externalForwardedProps.className, externalSlotProps == null ? void 0 : externalSlotProps.className);\n  const mergedStyle = _extends({}, internalSlotProps == null ? void 0 : internalSlotProps.style, additionalProps == null ? void 0 : additionalProps.style, externalForwardedProps == null ? void 0 : externalForwardedProps.style, externalSlotProps == null ? void 0 : externalSlotProps.style);\n  const props = _extends({}, internalSlotProps, additionalProps, otherPropsWithoutEventHandlers, componentsPropsWithoutEventHandlers);\n  if (joinedClasses.length > 0) {\n    props.className = joinedClasses;\n  }\n  if (Object.keys(mergedStyle).length > 0) {\n    props.style = mergedStyle;\n  }\n  return {\n    props,\n    internalRef: internalSlotProps.ref\n  };\n}\nexport default mergeSlotProps;","export default function ownerDocument(node) {\n  return node && node.ownerDocument || document;\n}","import ownerDocument from '../ownerDocument';\nexport default function ownerWindow(node) {\n  const doc = ownerDocument(node);\n  return doc.defaultView || window;\n}","/* eslint-disable */\n// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nexport default typeof window != 'undefined' && window.Math == Math ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();","import PropTypes from 'prop-types';\nconst refType = PropTypes.oneOfType([PropTypes.func, PropTypes.object]);\nexport default refType;","import _extends from \"@babel/runtime/helpers/esm/extends\";\nexport default function requirePropFactory(componentNameInError, Component) {\n  if (process.env.NODE_ENV === 'production') {\n    return () => null;\n  }\n\n  // eslint-disable-next-line react/forbid-foreign-prop-types\n  const prevPropTypes = Component ? _extends({}, Component.propTypes) : null;\n  const requireProp = requiredProp => (props, propName, componentName, location, propFullName, ...args) => {\n    const propFullNameSafe = propFullName || propName;\n    const defaultTypeChecker = prevPropTypes == null ? void 0 : prevPropTypes[propFullNameSafe];\n    if (defaultTypeChecker) {\n      const typeCheckerResult = defaultTypeChecker(props, propName, componentName, location, propFullName, ...args);\n      if (typeCheckerResult) {\n        return typeCheckerResult;\n      }\n    }\n    if (typeof props[propName] !== 'undefined' && !props[requiredProp]) {\n      return new Error(`The prop \\`${propFullNameSafe}\\` of ` + `\\`${componentNameInError}\\` can only be used together with the \\`${requiredProp}\\` prop.`);\n    }\n    return null;\n  };\n  return requireProp;\n}","/**\n * If `componentProps` is a function, calls it with the provided `ownerState`.\n * Otherwise, just returns `componentProps`.\n */\nfunction resolveComponentProps(componentProps, ownerState, slotState) {\n  if (typeof componentProps === 'function') {\n    return componentProps(ownerState, slotState);\n  }\n  return componentProps;\n}\nexport default resolveComponentProps;","import _extends from \"@babel/runtime/helpers/esm/extends\";\n/**\n * Add keys, values of `defaultProps` that does not exist in `props`\n * @param {object} defaultProps\n * @param {object} props\n * @returns {object} resolved props\n */\nexport default function resolveProps(defaultProps, props) {\n  const output = _extends({}, props);\n  Object.keys(defaultProps).forEach(propName => {\n    if (propName.toString().match(/^(components|slots)$/)) {\n      output[propName] = _extends({}, defaultProps[propName], output[propName]);\n    } else if (propName.toString().match(/^(componentsProps|slotProps)$/)) {\n      const defaultSlotProps = defaultProps[propName] || {};\n      const slotProps = props[propName];\n      output[propName] = {};\n      if (!slotProps || !Object.keys(slotProps)) {\n        // Reduce the iteration if the slot props is empty\n        output[propName] = defaultSlotProps;\n      } else if (!defaultSlotProps || !Object.keys(defaultSlotProps)) {\n        // Reduce the iteration if the default slot props is empty\n        output[propName] = slotProps;\n      } else {\n        output[propName] = _extends({}, slotProps);\n        Object.keys(defaultSlotProps).forEach(slotPropName => {\n          output[propName][slotPropName] = resolveProps(defaultSlotProps[slotPropName], slotProps[slotPropName]);\n        });\n      }\n    } else if (output[propName] === undefined) {\n      output[propName] = defaultProps[propName];\n    }\n  });\n  return output;\n}","// Source from https://github.com/alitaheri/normalize-scroll-left\nlet cachedType;\n\n/**\n * Based on the jquery plugin https://github.com/othree/jquery.rtl-scroll-type\n *\n * Types of scrollLeft, assuming scrollWidth=100 and direction is rtl.\n *\n * Type             | <- Most Left | Most Right -> | Initial\n * ---------------- | ------------ | ------------- | -------\n * default          | 0            | 100           | 100\n * negative (spec*) | -100         | 0             | 0\n * reverse          | 100          | 0             | 0\n *\n * Edge 85: default\n * Safari 14: negative\n * Chrome 85: negative\n * Firefox 81: negative\n * IE11: reverse\n *\n * spec* https://drafts.csswg.org/cssom-view/#dom-window-scroll\n */\nexport function detectScrollType() {\n  if (cachedType) {\n    return cachedType;\n  }\n  const dummy = document.createElement('div');\n  const container = document.createElement('div');\n  container.style.width = '10px';\n  container.style.height = '1px';\n  dummy.appendChild(container);\n  dummy.dir = 'rtl';\n  dummy.style.fontSize = '14px';\n  dummy.style.width = '4px';\n  dummy.style.height = '1px';\n  dummy.style.position = 'absolute';\n  dummy.style.top = '-1000px';\n  dummy.style.overflow = 'scroll';\n  document.body.appendChild(dummy);\n  cachedType = 'reverse';\n  if (dummy.scrollLeft > 0) {\n    cachedType = 'default';\n  } else {\n    dummy.scrollLeft = 1;\n    if (dummy.scrollLeft === 0) {\n      cachedType = 'negative';\n    }\n  }\n  document.body.removeChild(dummy);\n  return cachedType;\n}\n\n// Based on https://stackoverflow.com/a/24394376\nexport function getNormalizedScrollLeft(element, direction) {\n  const scrollLeft = element.scrollLeft;\n\n  // Perform the calculations only when direction is rtl to avoid messing up the ltr behavior\n  if (direction !== 'rtl') {\n    return scrollLeft;\n  }\n  const type = detectScrollType();\n  switch (type) {\n    case 'negative':\n      return element.scrollWidth - element.clientWidth + scrollLeft;\n    case 'reverse':\n      return element.scrollWidth - element.clientWidth - scrollLeft;\n    default:\n      return scrollLeft;\n  }\n}","/**\n * TODO v5: consider making it private\n *\n * passes {value} to {ref}\n *\n * WARNING: Be sure to only call this inside a callback that is passed as a ref.\n * Otherwise, make sure to cleanup the previous {ref} if it changes. See\n * https://github.com/mui/material-ui/issues/13539\n *\n * Useful if you want to expose the ref of an inner component to the public API\n * while still using it inside the component.\n * @param ref A ref callback or ref object. If anything falsy, this is a no-op.\n */\nexport default function setRef(ref, value) {\n  if (typeof ref === 'function') {\n    ref(value);\n  } else if (ref) {\n    ref.current = value;\n  }\n}","export default function unsupportedProp(props, propName, componentName, location, propFullName) {\n  if (process.env.NODE_ENV === 'production') {\n    return null;\n  }\n  const propFullNameSafe = propFullName || propName;\n  if (typeof props[propName] !== 'undefined') {\n    return new Error(`The prop \\`${propFullNameSafe}\\` is not supported. Please remove it.`);\n  }\n  return null;\n}","'use client';\n\n/* eslint-disable react-hooks/rules-of-hooks, react-hooks/exhaustive-deps */\nimport * as React from 'react';\nexport default function useControlled({\n  controlled,\n  default: defaultProp,\n  name,\n  state = 'value'\n}) {\n  // isControlled is ignored in the hook dependency lists as it should never change.\n  const {\n    current: isControlled\n  } = React.useRef(controlled !== undefined);\n  const [valueState, setValue] = React.useState(defaultProp);\n  const value = isControlled ? controlled : valueState;\n  if (process.env.NODE_ENV !== 'production') {\n    React.useEffect(() => {\n      if (isControlled !== (controlled !== undefined)) {\n        console.error([`MUI: A component is changing the ${isControlled ? '' : 'un'}controlled ${state} state of ${name} to be ${isControlled ? 'un' : ''}controlled.`, 'Elements should not switch from uncontrolled to controlled (or vice versa).', `Decide between using a controlled or uncontrolled ${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    }, [state, name, controlled]);\n    const {\n      current: defaultValue\n    } = React.useRef(defaultProp);\n    React.useEffect(() => {\n      if (!isControlled && !Object.is(defaultValue, defaultProp)) {\n        console.error([`MUI: A component is changing the default ${state} state of an uncontrolled ${name} after being initialized. ` + `To suppress this warning opt to use a controlled ${name}.`].join('\\n'));\n      }\n    }, [JSON.stringify(defaultProp)]);\n  }\n  const setValueIfUncontrolled = React.useCallback(newValue => {\n    if (!isControlled) {\n      setValue(newValue);\n    }\n  }, []);\n  return [value, setValueIfUncontrolled];\n}","'use client';\n\nimport * as React from 'react';\n\n/**\n * A version of `React.useLayoutEffect` that does not show a warning when server-side rendering.\n * This is useful for effects that are only needed for client-side rendering but not for SSR.\n *\n * Before you use this hook, make sure to read https://gist.github.com/gaearon/e7d97cdf38a2907924ea12e4ebdf3c85\n * and confirm it doesn't apply to your use-case.\n */\nconst useEnhancedEffect = typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect;\nexport default useEnhancedEffect;","'use client';\n\nimport * as React from 'react';\nimport useEnhancedEffect from '../useEnhancedEffect';\n\n/**\n * Inspired by https://github.com/facebook/react/issues/14099#issuecomment-440013892\n * See RFC in https://github.com/reactjs/rfcs/pull/220\n */\n\nfunction useEventCallback(fn) {\n  const ref = React.useRef(fn);\n  useEnhancedEffect(() => {\n    ref.current = fn;\n  });\n  return React.useRef((...args) =>\n  // @ts-expect-error hide `this`\n  (0, ref.current)(...args)).current;\n}\nexport default useEventCallback;","'use client';\n\nimport * as React from 'react';\nimport setRef from '../setRef';\nexport default function useForkRef(...refs) {\n  /**\n   * This will create a new function if the refs passed to this hook change and are all 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(() => {\n    if (refs.every(ref => ref == null)) {\n      return null;\n    }\n    return instance => {\n      refs.forEach(ref => {\n        setRef(ref, instance);\n      });\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, refs);\n}","'use client';\n\nimport * as React from 'react';\nlet globalId = 0;\nfunction useGlobalId(idOverride) {\n  const [defaultId, setDefaultId] = React.useState(idOverride);\n  const id = idOverride || defaultId;\n  React.useEffect(() => {\n    if (defaultId == null) {\n      // Fallback to this default id when possible.\n      // Use the incrementing value for client-side rendering only.\n      // We can't use it server-side.\n      // If you want to use random values please consider the Birthday Problem: https://en.wikipedia.org/wiki/Birthday_problem\n      globalId += 1;\n      setDefaultId(`mui-${globalId}`);\n    }\n  }, [defaultId]);\n  return id;\n}\n\n// downstream bundlers may remove unnecessary concatenation, but won't remove toString call -- Workaround for https://github.com/webpack/webpack/issues/14814\nconst maybeReactUseId = React['useId'.toString()];\n/**\n *\n * @example <div id={useId()} />\n * @param idOverride\n * @returns {string}\n */\nexport default function useId(idOverride) {\n  if (maybeReactUseId !== undefined) {\n    const reactId = maybeReactUseId();\n    return idOverride != null ? idOverride : reactId;\n  }\n  // eslint-disable-next-line react-hooks/rules-of-hooks -- `React.useId` is invariant at runtime.\n  return useGlobalId(idOverride);\n}","'use client';\n\n// based on https://github.com/WICG/focus-visible/blob/v4.1.5/src/focus-visible.js\nimport * as React from 'react';\nimport { Timeout } from '../useTimeout/useTimeout';\nlet hadKeyboardEvent = true;\nlet hadFocusVisibleRecently = false;\nconst hadFocusVisibleRecentlyTimeout = new Timeout();\nconst 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/**\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 * @returns {boolean}\n */\nfunction focusTriggersKeyboardModality(node) {\n  const {\n    type,\n    tagName\n  } = node;\n  if (tagName === 'INPUT' && inputTypesWhitelist[type] && !node.readOnly) {\n    return true;\n  }\n  if (tagName === 'TEXTAREA' && !node.readOnly) {\n    return true;\n  }\n  if (node.isContentEditable) {\n    return true;\n  }\n  return false;\n}\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 */\nfunction handleKeyDown(event) {\n  if (event.metaKey || event.altKey || event.ctrlKey) {\n    return;\n  }\n  hadKeyboardEvent = true;\n}\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 */\nfunction handlePointerDown() {\n  hadKeyboardEvent = false;\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}\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}\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}\nfunction isFocusVisible(event) {\n  const {\n    target\n  } = event;\n  try {\n    return target.matches(':focus-visible');\n  } catch (error) {\n    // 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  }\n\n  // No need for validFocusTarget check. The user does that by attaching it to\n  // focusable events only.\n  return hadKeyboardEvent || focusTriggersKeyboardModality(target);\n}\nexport default function useIsFocusVisible() {\n  const ref = React.useCallback(node => {\n    if (node != null) {\n      prepare(node.ownerDocument);\n    }\n  }, []);\n  const isFocusVisibleRef = React.useRef(false);\n\n  /**\n   * Should be called if a blur event is fired\n   */\n  function handleBlurVisible() {\n    // checking against potential state variable does not suffice if we focus and blur synchronously.\n    // React wouldn't have time to trigger a re-render so `focusVisible` would be stale.\n    // Ideally we would adjust `isFocusVisible(event)` to look at `relatedTarget` for blur events.\n    // This doesn't work in IE11 due to https://github.com/facebook/react/issues/3751\n    // TODO: check again if React releases their internal changes to focus event handling (https://github.com/facebook/react/pull/19186).\n    if (isFocusVisibleRef.current) {\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      hadFocusVisibleRecentlyTimeout.start(100, () => {\n        hadFocusVisibleRecently = false;\n      });\n      isFocusVisibleRef.current = false;\n      return true;\n    }\n    return false;\n  }\n\n  /**\n   * Should be called if a blur event is fired\n   */\n  function handleFocusVisible(event) {\n    if (isFocusVisible(event)) {\n      isFocusVisibleRef.current = true;\n      return true;\n    }\n    return false;\n  }\n  return {\n    isFocusVisibleRef,\n    onFocus: handleFocusVisible,\n    onBlur: handleBlurVisible,\n    ref\n  };\n}","'use client';\n\nimport * as React from 'react';\nconst UNINITIALIZED = {};\n\n/**\n * A React.useRef() that is initialized lazily with a function. Note that it accepts an optional\n * initialization argument, so the initialization function doesn't need to be an inline closure.\n *\n * @usage\n *   const ref = useLazyRef(sortColumns, columns)\n */\nexport default function useLazyRef(init, initArg) {\n  const ref = React.useRef(UNINITIALIZED);\n  if (ref.current === UNINITIALIZED) {\n    ref.current = init(initArg);\n  }\n  return ref;\n}","'use client';\n\nimport * as React from 'react';\nconst EMPTY = [];\n\n/**\n * A React.useEffect equivalent that runs once, when the component is mounted.\n */\nexport default function useOnMount(fn) {\n  /* eslint-disable react-hooks/exhaustive-deps */\n  React.useEffect(fn, EMPTY);\n  /* eslint-enable react-hooks/exhaustive-deps */\n}","'use client';\n\nimport * as React from 'react';\nconst usePreviousProps = value => {\n  const ref = React.useRef({});\n  React.useEffect(() => {\n    ref.current = value;\n  });\n  return ref.current;\n};\nexport default usePreviousProps;","'use client';\n\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nconst _excluded = [\"elementType\", \"externalSlotProps\", \"ownerState\", \"skipResolvingSlotProps\"];\nimport useForkRef from '../useForkRef';\nimport appendOwnerState from '../appendOwnerState';\nimport mergeSlotProps from '../mergeSlotProps';\nimport resolveComponentProps from '../resolveComponentProps';\n/**\n * @ignore - do not document.\n * Builds the props to be passed into the slot of an unstyled component.\n * It merges the internal props of the component with the ones supplied by the user, allowing to customize the behavior.\n * If the slot component is not a host component, it also merges in the `ownerState`.\n *\n * @param parameters.getSlotProps - A function that returns the props to be passed to the slot component.\n */\nfunction useSlotProps(parameters) {\n  var _parameters$additiona;\n  const {\n      elementType,\n      externalSlotProps,\n      ownerState,\n      skipResolvingSlotProps = false\n    } = parameters,\n    rest = _objectWithoutPropertiesLoose(parameters, _excluded);\n  const resolvedComponentsProps = skipResolvingSlotProps ? {} : resolveComponentProps(externalSlotProps, ownerState);\n  const {\n    props: mergedProps,\n    internalRef\n  } = mergeSlotProps(_extends({}, rest, {\n    externalSlotProps: resolvedComponentsProps\n  }));\n  const ref = useForkRef(internalRef, resolvedComponentsProps == null ? void 0 : resolvedComponentsProps.ref, (_parameters$additiona = parameters.additionalProps) == null ? void 0 : _parameters$additiona.ref);\n  const props = appendOwnerState(elementType, _extends({}, mergedProps, {\n    ref\n  }), ownerState);\n  return props;\n}\nexport default useSlotProps;","'use client';\n\nimport useLazyRef from '../useLazyRef/useLazyRef';\nimport useOnMount from '../useOnMount/useOnMount';\nexport class Timeout {\n  constructor() {\n    this.currentId = null;\n    this.clear = () => {\n      if (this.currentId !== null) {\n        clearTimeout(this.currentId);\n        this.currentId = null;\n      }\n    };\n    this.disposeEffect = () => {\n      return this.clear;\n    };\n  }\n  static create() {\n    return new Timeout();\n  }\n  /**\n   * Executes `fn` after `delay`, clearing any previously scheduled call.\n   */\n  start(delay, fn) {\n    this.clear();\n    this.currentId = setTimeout(() => {\n      this.currentId = null;\n      fn();\n    }, delay);\n  }\n}\nexport default function useTimeout() {\n  const timeout = useLazyRef(Timeout.create).current;\n  useOnMount(timeout.disposeEffect);\n  return timeout;\n}","const visuallyHidden = {\n  border: 0,\n  clip: 'rect(0 0 0 0)',\n  height: '1px',\n  margin: '-1px',\n  overflow: 'hidden',\n  padding: 0,\n  position: 'absolute',\n  whiteSpace: 'nowrap',\n  width: '1px'\n};\nexport default visuallyHidden;","/**\n * @license React\n * react-is.production.js\n *\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n\"use strict\";\nvar REACT_ELEMENT_TYPE = Symbol.for(\"react.transitional.element\"),\n  REACT_PORTAL_TYPE = Symbol.for(\"react.portal\"),\n  REACT_FRAGMENT_TYPE = Symbol.for(\"react.fragment\"),\n  REACT_STRICT_MODE_TYPE = Symbol.for(\"react.strict_mode\"),\n  REACT_PROFILER_TYPE = Symbol.for(\"react.profiler\");\nSymbol.for(\"react.provider\");\nvar REACT_CONSUMER_TYPE = Symbol.for(\"react.consumer\"),\n  REACT_CONTEXT_TYPE = Symbol.for(\"react.context\"),\n  REACT_FORWARD_REF_TYPE = Symbol.for(\"react.forward_ref\"),\n  REACT_SUSPENSE_TYPE = Symbol.for(\"react.suspense\"),\n  REACT_SUSPENSE_LIST_TYPE = Symbol.for(\"react.suspense_list\"),\n  REACT_MEMO_TYPE = Symbol.for(\"react.memo\"),\n  REACT_LAZY_TYPE = Symbol.for(\"react.lazy\"),\n  REACT_OFFSCREEN_TYPE = Symbol.for(\"react.offscreen\"),\n  REACT_CLIENT_REFERENCE = Symbol.for(\"react.client.reference\");\nfunction typeOf(object) {\n  if (\"object\" === typeof object && null !== object) {\n    var $$typeof = object.$$typeof;\n    switch ($$typeof) {\n      case REACT_ELEMENT_TYPE:\n        switch (((object = object.type), object)) {\n          case REACT_FRAGMENT_TYPE:\n          case REACT_PROFILER_TYPE:\n          case REACT_STRICT_MODE_TYPE:\n          case REACT_SUSPENSE_TYPE:\n          case REACT_SUSPENSE_LIST_TYPE:\n            return object;\n          default:\n            switch (((object = object && object.$$typeof), object)) {\n              case REACT_CONTEXT_TYPE:\n              case REACT_FORWARD_REF_TYPE:\n              case REACT_LAZY_TYPE:\n              case REACT_MEMO_TYPE:\n                return object;\n              case REACT_CONSUMER_TYPE:\n                return object;\n              default:\n                return $$typeof;\n            }\n        }\n      case REACT_PORTAL_TYPE:\n        return $$typeof;\n    }\n  }\n}\nexports.ContextConsumer = REACT_CONSUMER_TYPE;\nexports.ContextProvider = REACT_CONTEXT_TYPE;\nexports.Element = REACT_ELEMENT_TYPE;\nexports.ForwardRef = REACT_FORWARD_REF_TYPE;\nexports.Fragment = REACT_FRAGMENT_TYPE;\nexports.Lazy = REACT_LAZY_TYPE;\nexports.Memo = REACT_MEMO_TYPE;\nexports.Portal = REACT_PORTAL_TYPE;\nexports.Profiler = REACT_PROFILER_TYPE;\nexports.StrictMode = REACT_STRICT_MODE_TYPE;\nexports.Suspense = REACT_SUSPENSE_TYPE;\nexports.SuspenseList = REACT_SUSPENSE_LIST_TYPE;\nexports.isContextConsumer = function (object) {\n  return typeOf(object) === REACT_CONSUMER_TYPE;\n};\nexports.isContextProvider = function (object) {\n  return typeOf(object) === REACT_CONTEXT_TYPE;\n};\nexports.isElement = function (object) {\n  return (\n    \"object\" === typeof object &&\n    null !== object &&\n    object.$$typeof === REACT_ELEMENT_TYPE\n  );\n};\nexports.isForwardRef = function (object) {\n  return typeOf(object) === REACT_FORWARD_REF_TYPE;\n};\nexports.isFragment = function (object) {\n  return typeOf(object) === REACT_FRAGMENT_TYPE;\n};\nexports.isLazy = function (object) {\n  return typeOf(object) === REACT_LAZY_TYPE;\n};\nexports.isMemo = function (object) {\n  return typeOf(object) === REACT_MEMO_TYPE;\n};\nexports.isPortal = function (object) {\n  return typeOf(object) === REACT_PORTAL_TYPE;\n};\nexports.isProfiler = function (object) {\n  return typeOf(object) === REACT_PROFILER_TYPE;\n};\nexports.isStrictMode = function (object) {\n  return typeOf(object) === REACT_STRICT_MODE_TYPE;\n};\nexports.isSuspense = function (object) {\n  return typeOf(object) === REACT_SUSPENSE_TYPE;\n};\nexports.isSuspenseList = function (object) {\n  return typeOf(object) === REACT_SUSPENSE_LIST_TYPE;\n};\nexports.isValidElementType = function (type) {\n  return \"string\" === typeof type ||\n    \"function\" === typeof type ||\n    type === REACT_FRAGMENT_TYPE ||\n    type === REACT_PROFILER_TYPE ||\n    type === REACT_STRICT_MODE_TYPE ||\n    type === REACT_SUSPENSE_TYPE ||\n    type === REACT_SUSPENSE_LIST_TYPE ||\n    type === REACT_OFFSCREEN_TYPE ||\n    (\"object\" === typeof type &&\n      null !== type &&\n      (type.$$typeof === REACT_LAZY_TYPE ||\n        type.$$typeof === REACT_MEMO_TYPE ||\n        type.$$typeof === REACT_CONTEXT_TYPE ||\n        type.$$typeof === REACT_CONSUMER_TYPE ||\n        type.$$typeof === REACT_FORWARD_REF_TYPE ||\n        type.$$typeof === REACT_CLIENT_REFERENCE ||\n        void 0 !== type.getModuleId))\n    ? !0\n    : !1;\n};\nexports.typeOf = typeOf;\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-is.production.js');\n} else {\n  module.exports = require('./cjs/react-is.development.js');\n}\n"],"names":["Number","isInteger","validatorNoop","isRequired","element","isMuiElement","muiNames","_muiName","_element$type","React","indexOf","type","muiName","_payload","value","object","undefined","result","Object","keys","filter","prop","match","forEach","parameters","getSlotProps","additionalProps","externalSlotProps","externalForwardedProps","className","joinedClasses","clsx","mergedStyle","_extends","style","props","length","internalRef","eventHandlers","extractEventHandlers","componentsPropsWithoutEventHandlers","omitEventHandlers","otherPropsWithoutEventHandlers","internalSlotProps","ref","ownerDocument","node","document","ownerWindow","defaultView","window","Math","self","Function","PropTypes","requirePropFactory","componentNameInError","Component","componentProps","ownerState","slotState","resolveProps","defaultProps","output","propName","toString","defaultSlotProps","slotProps","slotPropName","cachedType","detectScrollType","dummy","createElement","container","width","height","appendChild","dir","fontSize","position","top","overflow","body","scrollLeft","removeChild","getNormalizedScrollLeft","direction","scrollWidth","clientWidth","setRef","current","unsupportedProp","componentName","location","propFullName","useControlled","_ref","controlled","default","defaultProp","name","state","isControlled","valueState","setValue","newValue","fn","useEnhancedEffect","arguments","useForkRef","_len","refs","Array","_key","every","instance","globalId","maybeReactUseId","useId","idOverride","reactId","defaultId","setDefaultId","id","concat","useGlobalId","hadKeyboardEvent","hadFocusVisibleRecently","hadFocusVisibleRecentlyTimeout","Timeout","inputTypesWhitelist","text","search","url","tel","email","password","number","date","month","week","time","datetime","handleKeyDown","event","metaKey","altKey","ctrlKey","handlePointerDown","handleVisibilityChange","this","visibilityState","isFocusVisible","target","matches","error","tagName","readOnly","isContentEditable","focusTriggersKeyboardModality","useIsFocusVisible","doc","addEventListener","isFocusVisibleRef","onFocus","onBlur","start","UNINITIALIZED","useLazyRef","init","initArg","EMPTY","useOnMount","_excluded","_parameters$additiona","elementType","skipResolvingSlotProps","rest","_objectWithoutPropertiesLoose","resolvedComponentsProps","resolveComponentProps","mergedProps","mergeSlotProps","appendOwnerState","constructor","currentId","clear","clearTimeout","disposeEffect","create","delay","setTimeout","useTimeout","timeout","border","clip","margin","padding","whiteSpace","REACT_ELEMENT_TYPE","Symbol","for","REACT_PORTAL_TYPE","REACT_FRAGMENT_TYPE","REACT_STRICT_MODE_TYPE","REACT_PROFILER_TYPE","REACT_CONSUMER_TYPE","REACT_CONTEXT_TYPE","REACT_FORWARD_REF_TYPE","REACT_SUSPENSE_TYPE","REACT_SUSPENSE_LIST_TYPE","REACT_MEMO_TYPE","REACT_LAZY_TYPE","REACT_OFFSCREEN_TYPE","REACT_CLIENT_REFERENCE","typeOf","$$typeof","exports","ForwardRef","Memo","module"],"sourceRoot":""}