{"version":3,"file":"1299.chunk.js","mappings":"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","sources":["webpack://oricheckoutclientapp/../../node_modules/@mui/base/Portal/Portal.js","webpack://oricheckoutclientapp/../../node_modules/@mui/base/unstable_useModal/ModalManager.js","webpack://oricheckoutclientapp/../../node_modules/@mui/base/unstable_useModal/useModal.js","webpack://oricheckoutclientapp/../../node_modules/@mui/base/FocusTrap/FocusTrap.js","webpack://oricheckoutclientapp/../../node_modules/@mui/base/Modal/modalClasses.js","webpack://oricheckoutclientapp/../../node_modules/@mui/base/Modal/Modal.js","webpack://oricheckoutclientapp/../../node_modules/@mui/base/utils/ClassNameConfigurator.js","webpack://oricheckoutclientapp/../../node_modules/@mui/base/utils/appendOwnerState.js","webpack://oricheckoutclientapp/../../node_modules/@mui/base/utils/extractEventHandlers.js","webpack://oricheckoutclientapp/../../node_modules/@mui/base/utils/isHostComponent.js","webpack://oricheckoutclientapp/../../node_modules/@mui/base/utils/omitEventHandlers.js","webpack://oricheckoutclientapp/../../node_modules/@mui/base/utils/mergeSlotProps.js","webpack://oricheckoutclientapp/../../node_modules/@mui/base/utils/resolveComponentProps.js","webpack://oricheckoutclientapp/../../node_modules/@mui/base/utils/useSlotProps.js"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport * as ReactDOM from 'react-dom';\nimport PropTypes from 'prop-types';\nimport { exactProp, HTMLElementType, unstable_useEnhancedEffect as useEnhancedEffect, unstable_useForkRef as useForkRef, unstable_setRef as setRef } from '@mui/utils';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction getContainer(container) {\n  return typeof container === 'function' ? container() : container;\n}\n\n/**\n * Portals provide a first-class way to render children into a DOM node\n * that exists outside the DOM hierarchy of the parent component.\n *\n * Demos:\n *\n * - [Portal](https://mui.com/base-ui/react-portal/)\n *\n * API:\n *\n * - [Portal API](https://mui.com/base-ui/react-portal/components-api/#portal)\n */\nconst Portal = /*#__PURE__*/React.forwardRef(function Portal(props, forwardedRef) {\n  const {\n    children,\n    container,\n    disablePortal = false\n  } = props;\n  const [mountNode, setMountNode] = React.useState(null);\n  // @ts-expect-error TODO upstream fix\n  const handleRef = useForkRef( /*#__PURE__*/React.isValidElement(children) ? children.ref : null, forwardedRef);\n  useEnhancedEffect(() => {\n    if (!disablePortal) {\n      setMountNode(getContainer(container) || document.body);\n    }\n  }, [container, disablePortal]);\n  useEnhancedEffect(() => {\n    if (mountNode && !disablePortal) {\n      setRef(forwardedRef, mountNode);\n      return () => {\n        setRef(forwardedRef, null);\n      };\n    }\n    return undefined;\n  }, [forwardedRef, mountNode, disablePortal]);\n  if (disablePortal) {\n    if ( /*#__PURE__*/React.isValidElement(children)) {\n      const newProps = {\n        ref: handleRef\n      };\n      return /*#__PURE__*/React.cloneElement(children, newProps);\n    }\n    return /*#__PURE__*/_jsx(React.Fragment, {\n      children: children\n    });\n  }\n  return /*#__PURE__*/_jsx(React.Fragment, {\n    children: mountNode ? /*#__PURE__*/ReactDOM.createPortal(children, mountNode) : mountNode\n  });\n});\nprocess.env.NODE_ENV !== \"production\" ? Portal.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * The children to render into the `container`.\n   */\n  children: PropTypes.node,\n  /**\n   * An HTML element or function that returns one.\n   * The `container` will have the portal children appended to it.\n   *\n   * You can also provide a callback, which is called in a React layout effect.\n   * This lets you set the container from a ref, and also makes server-side rendering possible.\n   *\n   * By default, it uses the body of the top-level document object,\n   * so it's simply `document.body` most of the time.\n   */\n  container: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([HTMLElementType, PropTypes.func]),\n  /**\n   * The `children` will be under the DOM hierarchy of the parent component.\n   * @default false\n   */\n  disablePortal: PropTypes.bool\n} : void 0;\nif (process.env.NODE_ENV !== 'production') {\n  // eslint-disable-next-line\n  Portal['propTypes' + ''] = exactProp(Portal.propTypes);\n}\nexport { Portal };","import { unstable_ownerWindow as ownerWindow, unstable_ownerDocument as ownerDocument, unstable_getScrollbarSize as getScrollbarSize } from '@mui/utils';\n// Is a vertical scrollbar displayed?\nfunction isOverflowing(container) {\n  const doc = ownerDocument(container);\n  if (doc.body === container) {\n    return ownerWindow(container).innerWidth > doc.documentElement.clientWidth;\n  }\n  return container.scrollHeight > container.clientHeight;\n}\nexport function ariaHidden(element, show) {\n  if (show) {\n    element.setAttribute('aria-hidden', 'true');\n  } else {\n    element.removeAttribute('aria-hidden');\n  }\n}\nfunction getPaddingRight(element) {\n  return parseInt(ownerWindow(element).getComputedStyle(element).paddingRight, 10) || 0;\n}\nfunction isAriaHiddenForbiddenOnElement(element) {\n  // The forbidden HTML tags are the ones from ARIA specification that\n  // can be children of body and can't have aria-hidden attribute.\n  // cf. https://www.w3.org/TR/html-aria/#docconformance\n  const forbiddenTagNames = ['TEMPLATE', 'SCRIPT', 'STYLE', 'LINK', 'MAP', 'META', 'NOSCRIPT', 'PICTURE', 'COL', 'COLGROUP', 'PARAM', 'SLOT', 'SOURCE', 'TRACK'];\n  const isForbiddenTagName = forbiddenTagNames.indexOf(element.tagName) !== -1;\n  const isInputHidden = element.tagName === 'INPUT' && element.getAttribute('type') === 'hidden';\n  return isForbiddenTagName || isInputHidden;\n}\nfunction ariaHiddenSiblings(container, mountElement, currentElement, elementsToExclude, show) {\n  const blacklist = [mountElement, currentElement, ...elementsToExclude];\n  [].forEach.call(container.children, element => {\n    const isNotExcludedElement = blacklist.indexOf(element) === -1;\n    const isNotForbiddenElement = !isAriaHiddenForbiddenOnElement(element);\n    if (isNotExcludedElement && isNotForbiddenElement) {\n      ariaHidden(element, show);\n    }\n  });\n}\nfunction findIndexOf(items, callback) {\n  let idx = -1;\n  items.some((item, index) => {\n    if (callback(item)) {\n      idx = index;\n      return true;\n    }\n    return false;\n  });\n  return idx;\n}\nfunction handleContainer(containerInfo, props) {\n  const restoreStyle = [];\n  const container = containerInfo.container;\n  if (!props.disableScrollLock) {\n    if (isOverflowing(container)) {\n      // Compute the size before applying overflow hidden to avoid any scroll jumps.\n      const scrollbarSize = getScrollbarSize(ownerDocument(container));\n      restoreStyle.push({\n        value: container.style.paddingRight,\n        property: 'padding-right',\n        el: container\n      });\n      // Use computed style, here to get the real padding to add our scrollbar width.\n      container.style.paddingRight = `${getPaddingRight(container) + scrollbarSize}px`;\n\n      // .mui-fixed is a global helper.\n      const fixedElements = ownerDocument(container).querySelectorAll('.mui-fixed');\n      [].forEach.call(fixedElements, element => {\n        restoreStyle.push({\n          value: element.style.paddingRight,\n          property: 'padding-right',\n          el: element\n        });\n        element.style.paddingRight = `${getPaddingRight(element) + scrollbarSize}px`;\n      });\n    }\n    let scrollContainer;\n    if (container.parentNode instanceof DocumentFragment) {\n      scrollContainer = ownerDocument(container).body;\n    } else {\n      // Support html overflow-y: auto for scroll stability between pages\n      // https://css-tricks.com/snippets/css/force-vertical-scrollbar/\n      const parent = container.parentElement;\n      const containerWindow = ownerWindow(container);\n      scrollContainer = (parent == null ? void 0 : parent.nodeName) === 'HTML' && containerWindow.getComputedStyle(parent).overflowY === 'scroll' ? parent : container;\n    }\n\n    // Block the scroll even if no scrollbar is visible to account for mobile keyboard\n    // screensize shrink.\n    restoreStyle.push({\n      value: scrollContainer.style.overflow,\n      property: 'overflow',\n      el: scrollContainer\n    }, {\n      value: scrollContainer.style.overflowX,\n      property: 'overflow-x',\n      el: scrollContainer\n    }, {\n      value: scrollContainer.style.overflowY,\n      property: 'overflow-y',\n      el: scrollContainer\n    });\n    scrollContainer.style.overflow = 'hidden';\n  }\n  const restore = () => {\n    restoreStyle.forEach(({\n      value,\n      el,\n      property\n    }) => {\n      if (value) {\n        el.style.setProperty(property, value);\n      } else {\n        el.style.removeProperty(property);\n      }\n    });\n  };\n  return restore;\n}\nfunction getHiddenSiblings(container) {\n  const hiddenSiblings = [];\n  [].forEach.call(container.children, element => {\n    if (element.getAttribute('aria-hidden') === 'true') {\n      hiddenSiblings.push(element);\n    }\n  });\n  return hiddenSiblings;\n}\n/**\n * @ignore - do not document.\n *\n * Proper state management for containers and the modals in those containers.\n * Simplified, but inspired by react-overlay's ModalManager class.\n * Used by the Modal to ensure proper styling of containers.\n */\nexport class ModalManager {\n  constructor() {\n    this.containers = void 0;\n    this.modals = void 0;\n    this.modals = [];\n    this.containers = [];\n  }\n  add(modal, container) {\n    let modalIndex = this.modals.indexOf(modal);\n    if (modalIndex !== -1) {\n      return modalIndex;\n    }\n    modalIndex = this.modals.length;\n    this.modals.push(modal);\n\n    // If the modal we are adding is already in the DOM.\n    if (modal.modalRef) {\n      ariaHidden(modal.modalRef, false);\n    }\n    const hiddenSiblings = getHiddenSiblings(container);\n    ariaHiddenSiblings(container, modal.mount, modal.modalRef, hiddenSiblings, true);\n    const containerIndex = findIndexOf(this.containers, item => item.container === container);\n    if (containerIndex !== -1) {\n      this.containers[containerIndex].modals.push(modal);\n      return modalIndex;\n    }\n    this.containers.push({\n      modals: [modal],\n      container,\n      restore: null,\n      hiddenSiblings\n    });\n    return modalIndex;\n  }\n  mount(modal, props) {\n    const containerIndex = findIndexOf(this.containers, item => item.modals.indexOf(modal) !== -1);\n    const containerInfo = this.containers[containerIndex];\n    if (!containerInfo.restore) {\n      containerInfo.restore = handleContainer(containerInfo, props);\n    }\n  }\n  remove(modal, ariaHiddenState = true) {\n    const modalIndex = this.modals.indexOf(modal);\n    if (modalIndex === -1) {\n      return modalIndex;\n    }\n    const containerIndex = findIndexOf(this.containers, item => item.modals.indexOf(modal) !== -1);\n    const containerInfo = this.containers[containerIndex];\n    containerInfo.modals.splice(containerInfo.modals.indexOf(modal), 1);\n    this.modals.splice(modalIndex, 1);\n\n    // If that was the last modal in a container, clean up the container.\n    if (containerInfo.modals.length === 0) {\n      // The modal might be closed before it had the chance to be mounted in the DOM.\n      if (containerInfo.restore) {\n        containerInfo.restore();\n      }\n      if (modal.modalRef) {\n        // In case the modal wasn't in the DOM yet.\n        ariaHidden(modal.modalRef, ariaHiddenState);\n      }\n      ariaHiddenSiblings(containerInfo.container, modal.mount, modal.modalRef, containerInfo.hiddenSiblings, false);\n      this.containers.splice(containerIndex, 1);\n    } else {\n      // Otherwise make sure the next top modal is visible to a screen reader.\n      const nextTop = containerInfo.modals[containerInfo.modals.length - 1];\n      // as soon as a modal is adding its modalRef is undefined. it can't set\n      // aria-hidden because the dom element doesn't exist either\n      // when modal was unmounted before modalRef gets null\n      if (nextTop.modalRef) {\n        ariaHidden(nextTop.modalRef, false);\n      }\n    }\n    return modalIndex;\n  }\n  isTopModal(modal) {\n    return this.modals.length > 0 && this.modals[this.modals.length - 1] === modal;\n  }\n}","'use client';\n\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport { unstable_ownerDocument as ownerDocument, unstable_useForkRef as useForkRef, unstable_useEventCallback as useEventCallback, unstable_createChainedFunction as createChainedFunction } from '@mui/utils';\nimport { extractEventHandlers } from '../utils';\nimport { ModalManager, ariaHidden } from './ModalManager';\nfunction getContainer(container) {\n  return typeof container === 'function' ? container() : container;\n}\nfunction getHasTransition(children) {\n  return children ? children.props.hasOwnProperty('in') : false;\n}\n\n// A modal manager used to track and manage the state of open Modals.\n// Modals don't open on the server so this won't conflict with concurrent requests.\nconst defaultManager = new ModalManager();\n/**\n *\n * Demos:\n *\n * - [Modal](https://mui.com/base-ui/react-modal/#hook)\n *\n * API:\n *\n * - [useModal API](https://mui.com/base-ui/react-modal/hooks-api/#use-modal)\n */\nexport function useModal(parameters) {\n  const {\n    container,\n    disableEscapeKeyDown = false,\n    disableScrollLock = false,\n    // @ts-ignore internal logic - Base UI supports the manager as a prop too\n    manager = defaultManager,\n    closeAfterTransition = false,\n    onTransitionEnter,\n    onTransitionExited,\n    children,\n    onClose,\n    open,\n    rootRef\n  } = parameters;\n\n  // @ts-ignore internal logic\n  const modal = React.useRef({});\n  const mountNodeRef = React.useRef(null);\n  const modalRef = React.useRef(null);\n  const handleRef = useForkRef(modalRef, rootRef);\n  const [exited, setExited] = React.useState(!open);\n  const hasTransition = getHasTransition(children);\n  let ariaHiddenProp = true;\n  if (parameters['aria-hidden'] === 'false' || parameters['aria-hidden'] === false) {\n    ariaHiddenProp = false;\n  }\n  const getDoc = () => ownerDocument(mountNodeRef.current);\n  const getModal = () => {\n    modal.current.modalRef = modalRef.current;\n    modal.current.mount = mountNodeRef.current;\n    return modal.current;\n  };\n  const handleMounted = () => {\n    manager.mount(getModal(), {\n      disableScrollLock\n    });\n\n    // Fix a bug on Chrome where the scroll isn't initially 0.\n    if (modalRef.current) {\n      modalRef.current.scrollTop = 0;\n    }\n  };\n  const handleOpen = useEventCallback(() => {\n    const resolvedContainer = getContainer(container) || getDoc().body;\n    manager.add(getModal(), resolvedContainer);\n\n    // The element was already mounted.\n    if (modalRef.current) {\n      handleMounted();\n    }\n  });\n  const isTopModal = React.useCallback(() => manager.isTopModal(getModal()), [manager]);\n  const handlePortalRef = useEventCallback(node => {\n    mountNodeRef.current = node;\n    if (!node) {\n      return;\n    }\n    if (open && isTopModal()) {\n      handleMounted();\n    } else if (modalRef.current) {\n      ariaHidden(modalRef.current, ariaHiddenProp);\n    }\n  });\n  const handleClose = React.useCallback(() => {\n    manager.remove(getModal(), ariaHiddenProp);\n  }, [ariaHiddenProp, manager]);\n  React.useEffect(() => {\n    return () => {\n      handleClose();\n    };\n  }, [handleClose]);\n  React.useEffect(() => {\n    if (open) {\n      handleOpen();\n    } else if (!hasTransition || !closeAfterTransition) {\n      handleClose();\n    }\n  }, [open, handleClose, hasTransition, closeAfterTransition, handleOpen]);\n  const createHandleKeyDown = otherHandlers => event => {\n    var _otherHandlers$onKeyD;\n    (_otherHandlers$onKeyD = otherHandlers.onKeyDown) == null || _otherHandlers$onKeyD.call(otherHandlers, event);\n\n    // The handler doesn't take event.defaultPrevented into account:\n    //\n    // event.preventDefault() is meant to stop default behaviors like\n    // clicking a checkbox to check it, hitting a button to submit a form,\n    // and hitting left arrow to move the cursor in a text input etc.\n    // Only special HTML elements have these default behaviors.\n    if (event.key !== 'Escape' || event.which === 229 ||\n    // Wait until IME is settled.\n    !isTopModal()) {\n      return;\n    }\n    if (!disableEscapeKeyDown) {\n      // Swallow the event, in case someone is listening for the escape key on the body.\n      event.stopPropagation();\n      if (onClose) {\n        onClose(event, 'escapeKeyDown');\n      }\n    }\n  };\n  const createHandleBackdropClick = otherHandlers => event => {\n    var _otherHandlers$onClic;\n    (_otherHandlers$onClic = otherHandlers.onClick) == null || _otherHandlers$onClic.call(otherHandlers, event);\n    if (event.target !== event.currentTarget) {\n      return;\n    }\n    if (onClose) {\n      onClose(event, 'backdropClick');\n    }\n  };\n  const getRootProps = (otherHandlers = {}) => {\n    const propsEventHandlers = extractEventHandlers(parameters);\n\n    // The custom event handlers shouldn't be spread on the root element\n    delete propsEventHandlers.onTransitionEnter;\n    delete propsEventHandlers.onTransitionExited;\n    const externalEventHandlers = _extends({}, propsEventHandlers, otherHandlers);\n    return _extends({\n      role: 'presentation'\n    }, externalEventHandlers, {\n      onKeyDown: createHandleKeyDown(externalEventHandlers),\n      ref: handleRef\n    });\n  };\n  const getBackdropProps = (otherHandlers = {}) => {\n    const externalEventHandlers = otherHandlers;\n    return _extends({\n      'aria-hidden': true\n    }, externalEventHandlers, {\n      onClick: createHandleBackdropClick(externalEventHandlers),\n      open\n    });\n  };\n  const getTransitionProps = () => {\n    const handleEnter = () => {\n      setExited(false);\n      if (onTransitionEnter) {\n        onTransitionEnter();\n      }\n    };\n    const handleExited = () => {\n      setExited(true);\n      if (onTransitionExited) {\n        onTransitionExited();\n      }\n      if (closeAfterTransition) {\n        handleClose();\n      }\n    };\n    return {\n      onEnter: createChainedFunction(handleEnter, children == null ? void 0 : children.props.onEnter),\n      onExited: createChainedFunction(handleExited, children == null ? void 0 : children.props.onExited)\n    };\n  };\n  return {\n    getRootProps,\n    getBackdropProps,\n    getTransitionProps,\n    rootRef: handleRef,\n    portalRef: handlePortalRef,\n    isTopModal,\n    exited,\n    hasTransition\n  };\n}","'use client';\n\n/* eslint-disable consistent-return, jsx-a11y/no-noninteractive-tabindex */\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { exactProp, elementAcceptingRef, unstable_useForkRef as useForkRef, unstable_ownerDocument as ownerDocument } from '@mui/utils';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nimport { jsxs as _jsxs } from \"react/jsx-runtime\";\n// Inspired by https://github.com/focus-trap/tabbable\nconst candidatesSelector = ['input', 'select', 'textarea', 'a[href]', 'button', '[tabindex]', 'audio[controls]', 'video[controls]', '[contenteditable]:not([contenteditable=\"false\"])'].join(',');\nfunction getTabIndex(node) {\n  const tabindexAttr = parseInt(node.getAttribute('tabindex') || '', 10);\n  if (!Number.isNaN(tabindexAttr)) {\n    return tabindexAttr;\n  }\n\n  // Browsers do not return `tabIndex` correctly for contentEditable nodes;\n  // https://bugs.chromium.org/p/chromium/issues/detail?id=661108&q=contenteditable%20tabindex&can=2\n  // so if they don't have a tabindex attribute specifically set, assume it's 0.\n  // in Chrome, <details/>, <audio controls/> and <video controls/> elements get a default\n  //  `tabIndex` of -1 when the 'tabindex' attribute isn't specified in the DOM,\n  //  yet they are still part of the regular tab order; in FF, they get a default\n  //  `tabIndex` of 0; since Chrome still puts those elements in the regular tab\n  //  order, consider their tab index to be 0.\n  if (node.contentEditable === 'true' || (node.nodeName === 'AUDIO' || node.nodeName === 'VIDEO' || node.nodeName === 'DETAILS') && node.getAttribute('tabindex') === null) {\n    return 0;\n  }\n  return node.tabIndex;\n}\nfunction isNonTabbableRadio(node) {\n  if (node.tagName !== 'INPUT' || node.type !== 'radio') {\n    return false;\n  }\n  if (!node.name) {\n    return false;\n  }\n  const getRadio = selector => node.ownerDocument.querySelector(`input[type=\"radio\"]${selector}`);\n  let roving = getRadio(`[name=\"${node.name}\"]:checked`);\n  if (!roving) {\n    roving = getRadio(`[name=\"${node.name}\"]`);\n  }\n  return roving !== node;\n}\nfunction isNodeMatchingSelectorFocusable(node) {\n  if (node.disabled || node.tagName === 'INPUT' && node.type === 'hidden' || isNonTabbableRadio(node)) {\n    return false;\n  }\n  return true;\n}\nfunction defaultGetTabbable(root) {\n  const regularTabNodes = [];\n  const orderedTabNodes = [];\n  Array.from(root.querySelectorAll(candidatesSelector)).forEach((node, i) => {\n    const nodeTabIndex = getTabIndex(node);\n    if (nodeTabIndex === -1 || !isNodeMatchingSelectorFocusable(node)) {\n      return;\n    }\n    if (nodeTabIndex === 0) {\n      regularTabNodes.push(node);\n    } else {\n      orderedTabNodes.push({\n        documentOrder: i,\n        tabIndex: nodeTabIndex,\n        node: node\n      });\n    }\n  });\n  return orderedTabNodes.sort((a, b) => a.tabIndex === b.tabIndex ? a.documentOrder - b.documentOrder : a.tabIndex - b.tabIndex).map(a => a.node).concat(regularTabNodes);\n}\nfunction defaultIsEnabled() {\n  return true;\n}\n\n/**\n * Utility component that locks focus inside the component.\n *\n * Demos:\n *\n * - [Focus Trap](https://mui.com/base-ui/react-focus-trap/)\n *\n * API:\n *\n * - [FocusTrap API](https://mui.com/base-ui/react-focus-trap/components-api/#focus-trap)\n */\nfunction FocusTrap(props) {\n  const {\n    children,\n    disableAutoFocus = false,\n    disableEnforceFocus = false,\n    disableRestoreFocus = false,\n    getTabbable = defaultGetTabbable,\n    isEnabled = defaultIsEnabled,\n    open\n  } = props;\n  const ignoreNextEnforceFocus = React.useRef(false);\n  const sentinelStart = React.useRef(null);\n  const sentinelEnd = React.useRef(null);\n  const nodeToRestore = React.useRef(null);\n  const reactFocusEventTarget = React.useRef(null);\n  // This variable is useful when disableAutoFocus is true.\n  // It waits for the active element to move into the component to activate.\n  const activated = React.useRef(false);\n  const rootRef = React.useRef(null);\n  // @ts-expect-error TODO upstream fix\n  const handleRef = useForkRef(children.ref, rootRef);\n  const lastKeydown = React.useRef(null);\n  React.useEffect(() => {\n    // We might render an empty child.\n    if (!open || !rootRef.current) {\n      return;\n    }\n    activated.current = !disableAutoFocus;\n  }, [disableAutoFocus, open]);\n  React.useEffect(() => {\n    // We might render an empty child.\n    if (!open || !rootRef.current) {\n      return;\n    }\n    const doc = ownerDocument(rootRef.current);\n    if (!rootRef.current.contains(doc.activeElement)) {\n      if (!rootRef.current.hasAttribute('tabIndex')) {\n        if (process.env.NODE_ENV !== 'production') {\n          console.error(['MUI: The modal content node does not accept focus.', 'For the benefit of assistive technologies, ' + 'the tabIndex of the node is being set to \"-1\".'].join('\\n'));\n        }\n        rootRef.current.setAttribute('tabIndex', '-1');\n      }\n      if (activated.current) {\n        rootRef.current.focus();\n      }\n    }\n    return () => {\n      // restoreLastFocus()\n      if (!disableRestoreFocus) {\n        // In IE11 it is possible for document.activeElement to be null resulting\n        // in nodeToRestore.current being null.\n        // Not all elements in IE11 have a focus method.\n        // Once IE11 support is dropped the focus() call can be unconditional.\n        if (nodeToRestore.current && nodeToRestore.current.focus) {\n          ignoreNextEnforceFocus.current = true;\n          nodeToRestore.current.focus();\n        }\n        nodeToRestore.current = null;\n      }\n    };\n    // Missing `disableRestoreFocus` which is fine.\n    // We don't support changing that prop on an open FocusTrap\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [open]);\n  React.useEffect(() => {\n    // We might render an empty child.\n    if (!open || !rootRef.current) {\n      return;\n    }\n    const doc = ownerDocument(rootRef.current);\n    const loopFocus = nativeEvent => {\n      lastKeydown.current = nativeEvent;\n      if (disableEnforceFocus || !isEnabled() || nativeEvent.key !== 'Tab') {\n        return;\n      }\n\n      // Make sure the next tab starts from the right place.\n      // doc.activeElement refers to the origin.\n      if (doc.activeElement === rootRef.current && nativeEvent.shiftKey) {\n        // We need to ignore the next contain as\n        // it will try to move the focus back to the rootRef element.\n        ignoreNextEnforceFocus.current = true;\n        if (sentinelEnd.current) {\n          sentinelEnd.current.focus();\n        }\n      }\n    };\n    const contain = () => {\n      const rootElement = rootRef.current;\n\n      // Cleanup functions are executed lazily in React 17.\n      // Contain can be called between the component being unmounted and its cleanup function being run.\n      if (rootElement === null) {\n        return;\n      }\n      if (!doc.hasFocus() || !isEnabled() || ignoreNextEnforceFocus.current) {\n        ignoreNextEnforceFocus.current = false;\n        return;\n      }\n\n      // The focus is already inside\n      if (rootElement.contains(doc.activeElement)) {\n        return;\n      }\n\n      // The disableEnforceFocus is set and the focus is outside of the focus trap (and sentinel nodes)\n      if (disableEnforceFocus && doc.activeElement !== sentinelStart.current && doc.activeElement !== sentinelEnd.current) {\n        return;\n      }\n\n      // if the focus event is not coming from inside the children's react tree, reset the refs\n      if (doc.activeElement !== reactFocusEventTarget.current) {\n        reactFocusEventTarget.current = null;\n      } else if (reactFocusEventTarget.current !== null) {\n        return;\n      }\n      if (!activated.current) {\n        return;\n      }\n      let tabbable = [];\n      if (doc.activeElement === sentinelStart.current || doc.activeElement === sentinelEnd.current) {\n        tabbable = getTabbable(rootRef.current);\n      }\n\n      // one of the sentinel nodes was focused, so move the focus\n      // to the first/last tabbable element inside the focus trap\n      if (tabbable.length > 0) {\n        var _lastKeydown$current, _lastKeydown$current2;\n        const isShiftTab = Boolean(((_lastKeydown$current = lastKeydown.current) == null ? void 0 : _lastKeydown$current.shiftKey) && ((_lastKeydown$current2 = lastKeydown.current) == null ? void 0 : _lastKeydown$current2.key) === 'Tab');\n        const focusNext = tabbable[0];\n        const focusPrevious = tabbable[tabbable.length - 1];\n        if (typeof focusNext !== 'string' && typeof focusPrevious !== 'string') {\n          if (isShiftTab) {\n            focusPrevious.focus();\n          } else {\n            focusNext.focus();\n          }\n        }\n        // no tabbable elements in the trap focus or the focus was outside of the focus trap\n      } else {\n        rootElement.focus();\n      }\n    };\n    doc.addEventListener('focusin', contain);\n    doc.addEventListener('keydown', loopFocus, true);\n\n    // With Edge, Safari and Firefox, no focus related events are fired when the focused area stops being a focused area.\n    // for example https://bugzilla.mozilla.org/show_bug.cgi?id=559561.\n    // Instead, we can look if the active element was restored on the BODY element.\n    //\n    // The whatwg spec defines how the browser should behave but does not explicitly mention any events:\n    // https://html.spec.whatwg.org/multipage/interaction.html#focus-fixup-rule.\n    const interval = setInterval(() => {\n      if (doc.activeElement && doc.activeElement.tagName === 'BODY') {\n        contain();\n      }\n    }, 50);\n    return () => {\n      clearInterval(interval);\n      doc.removeEventListener('focusin', contain);\n      doc.removeEventListener('keydown', loopFocus, true);\n    };\n  }, [disableAutoFocus, disableEnforceFocus, disableRestoreFocus, isEnabled, open, getTabbable]);\n  const onFocus = event => {\n    if (nodeToRestore.current === null) {\n      nodeToRestore.current = event.relatedTarget;\n    }\n    activated.current = true;\n    reactFocusEventTarget.current = event.target;\n    const childrenPropsHandler = children.props.onFocus;\n    if (childrenPropsHandler) {\n      childrenPropsHandler(event);\n    }\n  };\n  const handleFocusSentinel = event => {\n    if (nodeToRestore.current === null) {\n      nodeToRestore.current = event.relatedTarget;\n    }\n    activated.current = true;\n  };\n  return /*#__PURE__*/_jsxs(React.Fragment, {\n    children: [/*#__PURE__*/_jsx(\"div\", {\n      tabIndex: open ? 0 : -1,\n      onFocus: handleFocusSentinel,\n      ref: sentinelStart,\n      \"data-testid\": \"sentinelStart\"\n    }), /*#__PURE__*/React.cloneElement(children, {\n      ref: handleRef,\n      onFocus\n    }), /*#__PURE__*/_jsx(\"div\", {\n      tabIndex: open ? 0 : -1,\n      onFocus: handleFocusSentinel,\n      ref: sentinelEnd,\n      \"data-testid\": \"sentinelEnd\"\n    })]\n  });\n}\nprocess.env.NODE_ENV !== \"production\" ? FocusTrap.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * A single child content element.\n   */\n  children: elementAcceptingRef,\n  /**\n   * If `true`, the focus trap will not automatically shift focus to itself when it opens, and\n   * replace it to the last focused element when it closes.\n   * This also works correctly with any focus trap children that have the `disableAutoFocus` prop.\n   *\n   * Generally this should never be set to `true` as it makes the focus trap less\n   * accessible to assistive technologies, like screen readers.\n   * @default false\n   */\n  disableAutoFocus: PropTypes.bool,\n  /**\n   * If `true`, the focus trap will not prevent focus from leaving the focus trap while open.\n   *\n   * Generally this should never be set to `true` as it makes the focus trap less\n   * accessible to assistive technologies, like screen readers.\n   * @default false\n   */\n  disableEnforceFocus: PropTypes.bool,\n  /**\n   * If `true`, the focus trap will not restore focus to previously focused element once\n   * focus trap is hidden or unmounted.\n   * @default false\n   */\n  disableRestoreFocus: PropTypes.bool,\n  /**\n   * Returns an array of ordered tabbable nodes (i.e. in tab order) within the root.\n   * For instance, you can provide the \"tabbable\" npm dependency.\n   * @param {HTMLElement} root\n   */\n  getTabbable: PropTypes.func,\n  /**\n   * This prop extends the `open` prop.\n   * It allows to toggle the open state without having to wait for a rerender when changing the `open` prop.\n   * This prop should be memoized.\n   * It can be used to support multiple focus trap mounted at the same time.\n   * @default function defaultIsEnabled(): boolean {\n   *   return true;\n   * }\n   */\n  isEnabled: PropTypes.func,\n  /**\n   * If `true`, focus is locked.\n   */\n  open: PropTypes.bool.isRequired\n} : void 0;\nif (process.env.NODE_ENV !== 'production') {\n  // eslint-disable-next-line\n  FocusTrap['propTypes' + ''] = exactProp(FocusTrap.propTypes);\n}\nexport { FocusTrap };","import { generateUtilityClasses } from '../generateUtilityClasses';\nimport { generateUtilityClass } from '../generateUtilityClass';\nconst COMPONENT_NAME = 'Modal';\nexport function getModalUtilityClass(slot) {\n  return generateUtilityClass(COMPONENT_NAME, slot);\n}\nexport const modalClasses = generateUtilityClasses(COMPONENT_NAME, ['root', 'hidden', 'backdrop']);","'use client';\n\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nconst _excluded = [\"children\", \"closeAfterTransition\", \"container\", \"disableAutoFocus\", \"disableEnforceFocus\", \"disableEscapeKeyDown\", \"disablePortal\", \"disableRestoreFocus\", \"disableScrollLock\", \"hideBackdrop\", \"keepMounted\", \"onBackdropClick\", \"onClose\", \"onKeyDown\", \"open\", \"onTransitionEnter\", \"onTransitionExited\", \"slotProps\", \"slots\"];\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { elementAcceptingRef, HTMLElementType } from '@mui/utils';\nimport { useSlotProps } from '../utils';\nimport { useClassNamesOverride } from '../utils/ClassNameConfigurator';\nimport { unstable_composeClasses as composeClasses } from '../composeClasses';\nimport { Portal } from '../Portal';\nimport { unstable_useModal as useModal } from '../unstable_useModal';\nimport { FocusTrap } from '../FocusTrap';\nimport { getModalUtilityClass } from './modalClasses';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nimport { jsxs as _jsxs } from \"react/jsx-runtime\";\nconst useUtilityClasses = ownerState => {\n  const {\n    open,\n    exited\n  } = ownerState;\n  const slots = {\n    root: ['root', !open && exited && 'hidden'],\n    backdrop: ['backdrop']\n  };\n  return composeClasses(slots, useClassNamesOverride(getModalUtilityClass));\n};\n\n/**\n * Modal is a lower-level construct that is leveraged by the following components:\n *\n * *   [Dialog](https://mui.com/material-ui/api/dialog/)\n * *   [Drawer](https://mui.com/material-ui/api/drawer/)\n * *   [Menu](https://mui.com/material-ui/api/menu/)\n * *   [Popover](https://mui.com/material-ui/api/popover/)\n *\n * If you are creating a modal dialog, you probably want to use the [Dialog](https://mui.com/material-ui/api/dialog/) component\n * rather than directly using Modal.\n *\n * This component shares many concepts with [react-overlays](https://react-bootstrap.github.io/react-overlays/#modals).\n *\n * Demos:\n *\n * - [Modal](https://mui.com/base-ui/react-modal/)\n *\n * API:\n *\n * - [Modal API](https://mui.com/base-ui/react-modal/components-api/#modal)\n */\nconst Modal = /*#__PURE__*/React.forwardRef(function Modal(props, forwardedRef) {\n  var _slots$root;\n  const {\n      children,\n      closeAfterTransition = false,\n      container,\n      disableAutoFocus = false,\n      disableEnforceFocus = false,\n      disableEscapeKeyDown = false,\n      disablePortal = false,\n      disableRestoreFocus = false,\n      disableScrollLock = false,\n      hideBackdrop = false,\n      keepMounted = false,\n      onBackdropClick,\n      open,\n      slotProps = {},\n      slots = {}\n    } = props,\n    other = _objectWithoutPropertiesLoose(props, _excluded);\n  const propsWithDefaults = _extends({}, props, {\n    closeAfterTransition,\n    disableAutoFocus,\n    disableEnforceFocus,\n    disableEscapeKeyDown,\n    disablePortal,\n    disableRestoreFocus,\n    disableScrollLock,\n    hideBackdrop,\n    keepMounted\n  });\n  const {\n    getRootProps,\n    getBackdropProps,\n    getTransitionProps,\n    portalRef,\n    isTopModal,\n    exited,\n    hasTransition\n  } = useModal(_extends({}, propsWithDefaults, {\n    rootRef: forwardedRef\n  }));\n  const ownerState = _extends({}, propsWithDefaults, {\n    exited,\n    hasTransition\n  });\n  const classes = useUtilityClasses(ownerState);\n  const childProps = {};\n  if (children.props.tabIndex === undefined) {\n    childProps.tabIndex = '-1';\n  }\n\n  // It's a Transition like component\n  if (hasTransition) {\n    const {\n      onEnter,\n      onExited\n    } = getTransitionProps();\n    childProps.onEnter = onEnter;\n    childProps.onExited = onExited;\n  }\n  const Root = (_slots$root = slots.root) != null ? _slots$root : 'div';\n  const rootProps = useSlotProps({\n    elementType: Root,\n    externalSlotProps: slotProps.root,\n    externalForwardedProps: other,\n    getSlotProps: getRootProps,\n    className: classes.root,\n    ownerState\n  });\n  const BackdropComponent = slots.backdrop;\n  const backdropProps = useSlotProps({\n    elementType: BackdropComponent,\n    externalSlotProps: slotProps.backdrop,\n    getSlotProps: otherHandlers => {\n      return getBackdropProps(_extends({}, otherHandlers, {\n        onClick: e => {\n          if (onBackdropClick) {\n            onBackdropClick(e);\n          }\n          if (otherHandlers != null && otherHandlers.onClick) {\n            otherHandlers.onClick(e);\n          }\n        }\n      }));\n    },\n    className: classes.backdrop,\n    ownerState\n  });\n  if (!keepMounted && !open && (!hasTransition || exited)) {\n    return null;\n  }\n  return /*#__PURE__*/_jsx(Portal, {\n    ref: portalRef,\n    container: container,\n    disablePortal: disablePortal,\n    children: /*#__PURE__*/_jsxs(Root, _extends({}, rootProps, {\n      children: [!hideBackdrop && BackdropComponent ? /*#__PURE__*/_jsx(BackdropComponent, _extends({}, backdropProps)) : null, /*#__PURE__*/_jsx(FocusTrap, {\n        disableEnforceFocus: disableEnforceFocus,\n        disableAutoFocus: disableAutoFocus,\n        disableRestoreFocus: disableRestoreFocus,\n        isEnabled: isTopModal,\n        open: open,\n        children: /*#__PURE__*/React.cloneElement(children, childProps)\n      })]\n    }))\n  });\n});\nprocess.env.NODE_ENV !== \"production\" ? Modal.propTypes /* remove-proptypes */ = {\n  // ┌────────────────────────────── Warning ──────────────────────────────┐\n  // │ These PropTypes are generated from the TypeScript type definitions. │\n  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │\n  // └─────────────────────────────────────────────────────────────────────┘\n  /**\n   * A single child content element.\n   */\n  children: elementAcceptingRef.isRequired,\n  /**\n   * When set to true the Modal waits until a nested Transition is completed before closing.\n   * @default false\n   */\n  closeAfterTransition: PropTypes.bool,\n  /**\n   * An HTML element or function that returns one.\n   * The `container` will have the portal children appended to it.\n   *\n   * You can also provide a callback, which is called in a React layout effect.\n   * This lets you set the container from a ref, and also makes server-side rendering possible.\n   *\n   * By default, it uses the body of the top-level document object,\n   * so it's simply `document.body` most of the time.\n   */\n  container: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([HTMLElementType, PropTypes.func]),\n  /**\n   * If `true`, the modal will not automatically shift focus to itself when it opens, and\n   * replace it to the last focused element when it closes.\n   * This also works correctly with any modal children that have the `disableAutoFocus` prop.\n   *\n   * Generally this should never be set to `true` as it makes the modal less\n   * accessible to assistive technologies, like screen readers.\n   * @default false\n   */\n  disableAutoFocus: PropTypes.bool,\n  /**\n   * If `true`, the modal will not prevent focus from leaving the modal while open.\n   *\n   * Generally this should never be set to `true` as it makes the modal less\n   * accessible to assistive technologies, like screen readers.\n   * @default false\n   */\n  disableEnforceFocus: PropTypes.bool,\n  /**\n   * If `true`, hitting escape will not fire the `onClose` callback.\n   * @default false\n   */\n  disableEscapeKeyDown: PropTypes.bool,\n  /**\n   * The `children` will be under the DOM hierarchy of the parent component.\n   * @default false\n   */\n  disablePortal: PropTypes.bool,\n  /**\n   * If `true`, the modal will not restore focus to previously focused element once\n   * modal is hidden or unmounted.\n   * @default false\n   */\n  disableRestoreFocus: PropTypes.bool,\n  /**\n   * Disable the scroll lock behavior.\n   * @default false\n   */\n  disableScrollLock: PropTypes.bool,\n  /**\n   * If `true`, the backdrop is not rendered.\n   * @default false\n   */\n  hideBackdrop: PropTypes.bool,\n  /**\n   * Always keep the children in the DOM.\n   * This prop can be useful in SEO situation or\n   * when you want to maximize the responsiveness of the Modal.\n   * @default false\n   */\n  keepMounted: PropTypes.bool,\n  /**\n   * Callback fired when the backdrop is clicked.\n   * @deprecated Use the `onClose` prop with the `reason` argument to handle the `backdropClick` events.\n   */\n  onBackdropClick: PropTypes.func,\n  /**\n   * Callback fired when the component requests to be closed.\n   * The `reason` parameter can optionally be used to control the response to `onClose`.\n   *\n   * @param {object} event The event source of the callback.\n   * @param {string} reason Can be: `\"escapeKeyDown\"`, `\"backdropClick\"`.\n   */\n  onClose: PropTypes.func,\n  /**\n   * A function called when a transition enters.\n   */\n  onTransitionEnter: PropTypes.func,\n  /**\n   * A function called when a transition has exited.\n   */\n  onTransitionExited: PropTypes.func,\n  /**\n   * If `true`, the component is shown.\n   */\n  open: PropTypes.bool.isRequired,\n  /**\n   * The props used for each slot inside the Modal.\n   * @default {}\n   */\n  slotProps: PropTypes.shape({\n    backdrop: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),\n    root: PropTypes.oneOfType([PropTypes.func, PropTypes.object])\n  }),\n  /**\n   * The components used for each slot inside the Modal.\n   * Either a string to use a HTML element or a component.\n   * @default {}\n   */\n  slots: PropTypes.shape({\n    backdrop: PropTypes.elementType,\n    root: PropTypes.elementType\n  })\n} : void 0;\nexport { Modal };","'use client';\n\nimport * as React from 'react';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst defaultContextValue = {\n  disableDefaultClasses: false\n};\nconst ClassNameConfiguratorContext = /*#__PURE__*/React.createContext(defaultContextValue);\nif (process.env.NODE_ENV !== 'production') {\n  ClassNameConfiguratorContext.displayName = 'ClassNameConfiguratorContext';\n}\n/**\n * @ignore - internal hook.\n *\n * Wraps the `generateUtilityClass` function and controls how the classes are generated.\n * Currently it only affects whether the classes are applied or not.\n *\n * @returns Function to be called with the `generateUtilityClass` function specific to a component to generate the classes.\n */\nexport function useClassNamesOverride(generateUtilityClass) {\n  const {\n    disableDefaultClasses\n  } = React.useContext(ClassNameConfiguratorContext);\n  return slot => {\n    if (disableDefaultClasses) {\n      return '';\n    }\n    return generateUtilityClass(slot);\n  };\n}\n\n/**\n * Allows to configure the components within to not apply any built-in classes.\n */\nexport function ClassNameConfigurator(props) {\n  const {\n    disableDefaultClasses,\n    children\n  } = props;\n  const contextValue = React.useMemo(() => ({\n    disableDefaultClasses: disableDefaultClasses != null ? disableDefaultClasses : false\n  }), [disableDefaultClasses]);\n  return /*#__PURE__*/_jsx(ClassNameConfiguratorContext.Provider, {\n    value: contextValue,\n    children: children\n  });\n}","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport { isHostComponent } from './isHostComponent';\n\n/**\n * Type of the ownerState based on the type of an element it applies to.\n * This resolves to the provided OwnerState for React components and `undefined` for host components.\n * Falls back to `OwnerState | undefined` when the exact type can't be determined in development time.\n */\n\n/**\n * Appends the ownerState object to the props, merging with the existing one if necessary.\n *\n * @param elementType Type of the element that owns the `existingProps`. If the element is a DOM node or undefined, `ownerState` is not applied.\n * @param otherProps Props of the element.\n * @param ownerState\n */\nexport function appendOwnerState(elementType, otherProps, ownerState) {\n  if (elementType === undefined || isHostComponent(elementType)) {\n    return otherProps;\n  }\n  return _extends({}, otherProps, {\n    ownerState: _extends({}, otherProps.ownerState, ownerState)\n  });\n}","/**\n * Extracts event handlers from a given object.\n * A prop is considered an event handler if it is a function and its name starts with `on`.\n *\n * @param object An object to extract event handlers from.\n * @param excludeKeys An array of keys to exclude from the returned object.\n */\nexport function extractEventHandlers(object, excludeKeys = []) {\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' && !excludeKeys.includes(prop)).forEach(prop => {\n    result[prop] = object[prop];\n  });\n  return result;\n}","/**\n * Determines if a given element is a DOM element name (i.e. not a React component).\n */\nexport function isHostComponent(element) {\n  return typeof element === 'string';\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 */\nexport function 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}","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 */\nexport function 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}","/**\n * If `componentProps` is a function, calls it with the provided `ownerState`.\n * Otherwise, just returns `componentProps`.\n */\nexport function resolveComponentProps(componentProps, ownerState, slotState) {\n  if (typeof componentProps === 'function') {\n    return componentProps(ownerState, slotState);\n  }\n  return componentProps;\n}","'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 { unstable_useForkRef as useForkRef } from '@mui/utils';\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 */\nexport function 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}"],"names":["Portal","props","forwardedRef","children","container","disablePortal","mountNode","setMountNode","handleRef","useForkRef","ref","useEnhancedEffect","getContainer","document","body","setRef","newProps","ariaHidden","element","show","setAttribute","removeAttribute","getPaddingRight","parseInt","ownerWindow","getComputedStyle","paddingRight","ariaHiddenSiblings","mountElement","currentElement","elementsToExclude","blacklist","forEach","call","isNotExcludedElement","indexOf","isNotForbiddenElement","isForbiddenTagName","tagName","isInputHidden","getAttribute","isAriaHiddenForbiddenOnElement","findIndexOf","items","callback","idx","some","item","index","handleContainer","containerInfo","restoreStyle","disableScrollLock","doc","ownerDocument","innerWidth","documentElement","clientWidth","scrollHeight","clientHeight","isOverflowing","scrollbarSize","getScrollbarSize","push","value","style","property","el","fixedElements","querySelectorAll","scrollContainer","parentNode","DocumentFragment","parent","parentElement","containerWindow","nodeName","overflowY","overflow","overflowX","setProperty","removeProperty","defaultManager","constructor","this","containers","modals","add","modal","modalIndex","length","modalRef","hiddenSiblings","getHiddenSiblings","mount","containerIndex","restore","remove","ariaHiddenState","splice","nextTop","isTopModal","useModal","parameters","disableEscapeKeyDown","manager","closeAfterTransition","onTransitionEnter","onTransitionExited","onClose","open","rootRef","mountNodeRef","exited","setExited","hasTransition","hasOwnProperty","getHasTransition","ariaHiddenProp","getModal","current","handleMounted","scrollTop","handleOpen","useEventCallback","resolvedContainer","handlePortalRef","node","handleClose","createHandleKeyDown","otherHandlers","event","_otherHandlers$onKeyD","onKeyDown","key","which","stopPropagation","createHandleBackdropClick","_otherHandlers$onClic","onClick","target","currentTarget","getRootProps","propsEventHandlers","extractEventHandlers","externalEventHandlers","role","getBackdropProps","getTransitionProps","onEnter","createChainedFunction","onExited","portalRef","candidatesSelector","join","defaultGetTabbable","root","regularTabNodes","orderedTabNodes","Array","from","i","nodeTabIndex","tabindexAttr","Number","isNaN","contentEditable","tabIndex","getTabIndex","disabled","type","name","getRadio","selector","querySelector","roving","isNonTabbableRadio","isNodeMatchingSelectorFocusable","documentOrder","sort","a","b","map","concat","defaultIsEnabled","FocusTrap","disableAutoFocus","disableEnforceFocus","disableRestoreFocus","getTabbable","isEnabled","ignoreNextEnforceFocus","sentinelStart","sentinelEnd","nodeToRestore","reactFocusEventTarget","activated","lastKeydown","contains","activeElement","hasAttribute","focus","loopFocus","nativeEvent","shiftKey","contain","rootElement","hasFocus","tabbable","_lastKeydown$current","_lastKeydown$current2","isShiftTab","Boolean","focusNext","focusPrevious","addEventListener","interval","setInterval","clearInterval","removeEventListener","handleFocusSentinel","relatedTarget","onFocus","childrenPropsHandler","COMPONENT_NAME","getModalUtilityClass","slot","generateUtilityClass","generateUtilityClasses","_excluded","Modal","_slots$root","hideBackdrop","keepMounted","onBackdropClick","slotProps","slots","other","propsWithDefaults","ownerState","classes","backdrop","composeClasses","useUtilityClasses","childProps","undefined","Root","rootProps","useSlotProps","elementType","externalSlotProps","externalForwardedProps","getSlotProps","className","BackdropComponent","backdropProps","e","defaultContextValue","disableDefaultClasses","ClassNameConfiguratorContext","useClassNamesOverride","ClassNameConfigurator","contextValue","Provider","appendOwnerState","otherProps","object","excludeKeys","result","Object","keys","filter","prop","match","includes","isHostComponent","omitEventHandlers","mergeSlotProps","additionalProps","joinedClasses","clsx","mergedStyle","internalRef","eventHandlers","componentsPropsWithoutEventHandlers","otherPropsWithoutEventHandlers","internalSlotProps","resolveComponentProps","componentProps","slotState","_parameters$additiona","skipResolvingSlotProps","rest","resolvedComponentsProps","mergedProps"],"sourceRoot":""}