{"version":3,"file":"js/4782-59618caab4b01c6de7b2.js","mappings":"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","sources":["webpack://app/./node_modules/@mui/icons-material/esm/ChevronRight.js","webpack://app/./node_modules/@mui/icons-material/esm/ExpandMore.js","webpack://app/./node_modules/@mui/x-tree-view/internals/TreeViewProvider/useTreeViewContext.js","webpack://app/./node_modules/@mui/x-tree-view/TreeItem/TreeItemContent.js","webpack://app/./node_modules/@mui/x-tree-view/TreeItem/useTreeItem.js","webpack://app/./node_modules/@mui/x-tree-view/TreeItem/treeItemClasses.js","webpack://app/./node_modules/@mui/x-tree-view/TreeItem/TreeItem.js","webpack://app/./node_modules/@mui/base/node_modules/@mui/utils/composeClasses/composeClasses.js","webpack://app/./node_modules/@mui/base/utils/omitEventHandlers.js","webpack://app/./node_modules/@mui/base/utils/mergeSlotProps.js","webpack://app/./node_modules/@mui/base/utils/extractEventHandlers.js","webpack://app/./node_modules/@mui/base/utils/useSlotProps.js","webpack://app/./node_modules/@mui/base/utils/resolveComponentProps.js","webpack://app/./node_modules/@mui/base/utils/appendOwnerState.js","webpack://app/./node_modules/@mui/base/utils/isHostComponent.js","webpack://app/./node_modules/@mui/base/node_modules/@mui/utils/useForkRef/useForkRef.js","webpack://app/./node_modules/@mui/base/node_modules/@mui/utils/setRef/setRef.js","webpack://app/./node_modules/@mui/x-tree-view/TreeView/treeViewClasses.js","webpack://app/./node_modules/@mui/x-tree-view/internals/utils/EventManager.js","webpack://app/./node_modules/@mui/x-tree-view/internals/useTreeView/useTreeView.utils.js","webpack://app/./node_modules/@mui/x-tree-view/internals/corePlugins/corePlugins.js","webpack://app/./node_modules/@mui/x-tree-view/internals/corePlugins/useTreeViewInstanceEvents/useTreeViewInstanceEvents.js","webpack://app/./node_modules/@mui/x-tree-view/internals/useTreeView/useTreeView.js","webpack://app/./node_modules/@mui/x-tree-view/internals/useTreeView/useTreeViewModels.js","webpack://app/./node_modules/@mui/x-tree-view/internals/TreeViewProvider/TreeViewProvider.js","webpack://app/./node_modules/@mui/x-tree-view/internals/utils/publishTreeViewEvent.js","webpack://app/./node_modules/@mui/x-tree-view/internals/plugins/useTreeViewExpansion/useTreeViewExpansion.js","webpack://app/./node_modules/@mui/x-tree-view/internals/plugins/useTreeViewSelection/useTreeViewSelection.utils.js","webpack://app/./node_modules/@mui/x-tree-view/internals/plugins/useTreeViewSelection/useTreeViewSelection.js","webpack://app/./node_modules/@mui/x-tree-view/internals/utils/cleanupTracking/TimerBasedCleanupTracking.js","webpack://app/./node_modules/@mui/x-tree-view/internals/utils/cleanupTracking/FinalizationRegistryBasedCleanupTracking.js","webpack://app/./node_modules/@mui/x-tree-view/internals/hooks/useInstanceEventHandler.js","webpack://app/./node_modules/@mui/x-tree-view/internals/plugins/useTreeViewFocus/useTreeViewFocus.js","webpack://app/./node_modules/@mui/x-tree-view/internals/plugins/useTreeViewKeyboardNavigation/useTreeViewKeyboardNavigation.js","webpack://app/./node_modules/@mui/x-tree-view/internals/plugins/useTreeViewContextValueBuilder/useTreeViewContextValueBuilder.js","webpack://app/./node_modules/@mui/x-tree-view/internals/plugins/defaultPlugins.js","webpack://app/./node_modules/@mui/x-tree-view/internals/plugins/useTreeViewNodes/useTreeViewNodes.js","webpack://app/./node_modules/@mui/x-tree-view/TreeView/TreeView.js","webpack://app/./node_modules/@mui/x-tree-view/internals/TreeViewProvider/DescendantProvider.js","webpack://app/./node_modules/@mui/x-tree-view/internals/TreeViewProvider/TreeViewContext.js"],"sourcesContent":["\"use client\";\n\nimport createSvgIcon from './utils/createSvgIcon';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport default createSvgIcon( /*#__PURE__*/_jsx(\"path\", {\n  d: \"M10 6 8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z\"\n}), 'ChevronRight');","\"use client\";\n\nimport createSvgIcon from './utils/createSvgIcon';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport default createSvgIcon( /*#__PURE__*/_jsx(\"path\", {\n  d: \"M16.59 8.59 12 13.17 7.41 8.59 6 10l6 6 6-6z\"\n}), 'ExpandMore');","import * as React from 'react';\nimport { TreeViewContext } from './TreeViewContext';\nexport const useTreeViewContext = () => React.useContext(TreeViewContext);","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nconst _excluded = [\"classes\", \"className\", \"displayIcon\", \"expansionIcon\", \"icon\", \"label\", \"nodeId\", \"onClick\", \"onMouseDown\"];\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport clsx from 'clsx';\nimport { useTreeItem } from './useTreeItem';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nimport { jsxs as _jsxs } from \"react/jsx-runtime\";\n/**\n * @ignore - internal component.\n */\nconst TreeItemContent = /*#__PURE__*/React.forwardRef(function TreeItemContent(props, ref) {\n  const {\n      classes,\n      className,\n      displayIcon,\n      expansionIcon,\n      icon: iconProp,\n      label,\n      nodeId,\n      onClick,\n      onMouseDown\n    } = props,\n    other = _objectWithoutPropertiesLoose(props, _excluded);\n  const {\n    disabled,\n    expanded,\n    selected,\n    focused,\n    handleExpansion,\n    handleSelection,\n    preventSelection\n  } = useTreeItem(nodeId);\n  const icon = iconProp || expansionIcon || displayIcon;\n  const handleMouseDown = event => {\n    preventSelection(event);\n    if (onMouseDown) {\n      onMouseDown(event);\n    }\n  };\n  const handleClick = event => {\n    handleExpansion(event);\n    handleSelection(event);\n    if (onClick) {\n      onClick(event);\n    }\n  };\n  return (\n    /*#__PURE__*/\n    /* eslint-disable-next-line jsx-a11y/click-events-have-key-events,jsx-a11y/no-static-element-interactions -- Key event is handled by the TreeView */\n    _jsxs(\"div\", _extends({}, other, {\n      className: clsx(className, classes.root, expanded && classes.expanded, selected && classes.selected, focused && classes.focused, disabled && classes.disabled),\n      onClick: handleClick,\n      onMouseDown: handleMouseDown,\n      ref: ref,\n      children: [/*#__PURE__*/_jsx(\"div\", {\n        className: classes.iconContainer,\n        children: icon\n      }), /*#__PURE__*/_jsx(\"div\", {\n        className: classes.label,\n        children: label\n      })]\n    }))\n  );\n});\nprocess.env.NODE_ENV !== \"production\" ? TreeItemContent.propTypes = {\n  // ----------------------------- Warning --------------------------------\n  // | These PropTypes are generated from the TypeScript type definitions |\n  // | To update them edit the TypeScript types and run \"yarn proptypes\"  |\n  // ----------------------------------------------------------------------\n  /**\n   * Override or extend the styles applied to the component.\n   */\n  classes: PropTypes.object.isRequired,\n  /**\n   * className applied to the root element.\n   */\n  className: PropTypes.string,\n  /**\n   * The icon to display next to the tree node's label. Either a parent or end icon.\n   */\n  displayIcon: PropTypes.node,\n  /**\n   * The icon to display next to the tree node's label. Either an expansion or collapse icon.\n   */\n  expansionIcon: PropTypes.node,\n  /**\n   * The icon to display next to the tree node's label.\n   */\n  icon: PropTypes.node,\n  /**\n   * The tree node label.\n   */\n  label: PropTypes.node,\n  /**\n   * The id of the node.\n   */\n  nodeId: PropTypes.string.isRequired\n} : void 0;\nexport { TreeItemContent };","import { useTreeViewContext } from '../internals/TreeViewProvider/useTreeViewContext';\nexport function useTreeItem(nodeId) {\n  const {\n    instance,\n    multiSelect\n  } = useTreeViewContext();\n  const expandable = instance ? instance.isNodeExpandable(nodeId) : false;\n  const expanded = instance ? instance.isNodeExpanded(nodeId) : false;\n  const focused = instance ? instance.isNodeFocused(nodeId) : false;\n  const selected = instance ? instance.isNodeSelected(nodeId) : false;\n  const disabled = instance ? instance.isNodeDisabled(nodeId) : false;\n  const handleExpansion = event => {\n    if (instance && !disabled) {\n      if (!focused) {\n        instance.focusNode(event, nodeId);\n      }\n      const multiple = multiSelect && (event.shiftKey || event.ctrlKey || event.metaKey);\n\n      // If already expanded and trying to toggle selection don't close\n      if (expandable && !(multiple && instance.isNodeExpanded(nodeId))) {\n        instance.toggleNodeExpansion(event, nodeId);\n      }\n    }\n  };\n  const handleSelection = event => {\n    if (instance && !disabled) {\n      if (!focused) {\n        instance.focusNode(event, nodeId);\n      }\n      const multiple = multiSelect && (event.shiftKey || event.ctrlKey || event.metaKey);\n      if (multiple) {\n        if (event.shiftKey) {\n          instance.selectRange(event, {\n            end: nodeId\n          });\n        } else {\n          instance.selectNode(event, nodeId, true);\n        }\n      } else {\n        instance.selectNode(event, nodeId);\n      }\n    }\n  };\n  const preventSelection = event => {\n    if (event.shiftKey || event.ctrlKey || event.metaKey || disabled) {\n      // Prevent text selection\n      event.preventDefault();\n    }\n  };\n  return {\n    disabled,\n    expanded,\n    selected,\n    focused,\n    handleExpansion,\n    handleSelection,\n    preventSelection\n  };\n}","import generateUtilityClass from '@mui/utils/generateUtilityClass';\nimport generateUtilityClasses from '@mui/utils/generateUtilityClasses';\nexport function getTreeItemUtilityClass(slot) {\n  return generateUtilityClass('MuiTreeItem', slot);\n}\nexport const treeItemClasses = generateUtilityClasses('MuiTreeItem', ['root', 'group', 'content', 'expanded', 'selected', 'focused', 'disabled', 'iconContainer', 'label']);","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nconst _excluded = [\"children\", \"className\", \"collapseIcon\", \"ContentComponent\", \"ContentProps\", \"endIcon\", \"expandIcon\", \"disabled\", \"icon\", \"id\", \"label\", \"nodeId\", \"onClick\", \"onMouseDown\", \"TransitionComponent\", \"TransitionProps\"];\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport clsx from 'clsx';\nimport Collapse from '@mui/material/Collapse';\nimport { alpha, styled, useThemeProps } from '@mui/material/styles';\nimport ownerDocument from '@mui/utils/ownerDocument';\nimport useForkRef from '@mui/utils/useForkRef';\nimport unsupportedProp from '@mui/utils/unsupportedProp';\nimport elementTypeAcceptingRef from '@mui/utils/elementTypeAcceptingRef';\nimport { unstable_composeClasses as composeClasses } from '@mui/base';\nimport { DescendantProvider, useDescendant } from '../internals/TreeViewProvider/DescendantProvider';\nimport { TreeItemContent } from './TreeItemContent';\nimport { treeItemClasses, getTreeItemUtilityClass } from './treeItemClasses';\nimport { useTreeViewContext } from '../internals/TreeViewProvider/useTreeViewContext';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nimport { jsxs as _jsxs } from \"react/jsx-runtime\";\nconst useUtilityClasses = ownerState => {\n  const {\n    classes\n  } = ownerState;\n  const slots = {\n    root: ['root'],\n    content: ['content'],\n    expanded: ['expanded'],\n    selected: ['selected'],\n    focused: ['focused'],\n    disabled: ['disabled'],\n    iconContainer: ['iconContainer'],\n    label: ['label'],\n    group: ['group']\n  };\n  return composeClasses(slots, getTreeItemUtilityClass, classes);\n};\nconst TreeItemRoot = styled('li', {\n  name: 'MuiTreeItem',\n  slot: 'Root',\n  overridesResolver: (props, styles) => styles.root\n})({\n  listStyle: 'none',\n  margin: 0,\n  padding: 0,\n  outline: 0\n});\nconst StyledTreeItemContent = styled(TreeItemContent, {\n  name: 'MuiTreeItem',\n  slot: 'Content',\n  overridesResolver: (props, styles) => {\n    return [styles.content, styles.iconContainer && {\n      [`& .${treeItemClasses.iconContainer}`]: styles.iconContainer\n    }, styles.label && {\n      [`& .${treeItemClasses.label}`]: styles.label\n    }];\n  }\n})(({\n  theme\n}) => ({\n  padding: '0 8px',\n  width: '100%',\n  boxSizing: 'border-box',\n  // prevent width + padding to overflow\n  display: 'flex',\n  alignItems: 'center',\n  cursor: 'pointer',\n  WebkitTapHighlightColor: 'transparent',\n  '&:hover': {\n    backgroundColor: (theme.vars || theme).palette.action.hover,\n    // Reset on touch devices, it doesn't add specificity\n    '@media (hover: none)': {\n      backgroundColor: 'transparent'\n    }\n  },\n  [`&.${treeItemClasses.disabled}`]: {\n    opacity: (theme.vars || theme).palette.action.disabledOpacity,\n    backgroundColor: 'transparent'\n  },\n  [`&.${treeItemClasses.focused}`]: {\n    backgroundColor: (theme.vars || theme).palette.action.focus\n  },\n  [`&.${treeItemClasses.selected}`]: {\n    backgroundColor: theme.vars ? `rgba(${theme.vars.palette.primary.mainChannel} / ${theme.vars.palette.action.selectedOpacity})` : alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity),\n    '&:hover': {\n      backgroundColor: theme.vars ? `rgba(${theme.vars.palette.primary.mainChannel} / calc(${theme.vars.palette.action.selectedOpacity} + ${theme.vars.palette.action.hoverOpacity}))` : alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity + theme.palette.action.hoverOpacity),\n      // Reset on touch devices, it doesn't add specificity\n      '@media (hover: none)': {\n        backgroundColor: theme.vars ? `rgba(${theme.vars.palette.primary.mainChannel} / ${theme.vars.palette.action.selectedOpacity})` : alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity)\n      }\n    },\n    [`&.${treeItemClasses.focused}`]: {\n      backgroundColor: theme.vars ? `rgba(${theme.vars.palette.primary.mainChannel} / calc(${theme.vars.palette.action.selectedOpacity} + ${theme.vars.palette.action.focusOpacity}))` : alpha(theme.palette.primary.main, theme.palette.action.selectedOpacity + theme.palette.action.focusOpacity)\n    }\n  },\n  [`& .${treeItemClasses.iconContainer}`]: {\n    marginRight: 4,\n    width: 15,\n    display: 'flex',\n    flexShrink: 0,\n    justifyContent: 'center',\n    '& svg': {\n      fontSize: 18\n    }\n  },\n  [`& .${treeItemClasses.label}`]: _extends({\n    paddingLeft: 4,\n    width: '100%',\n    boxSizing: 'border-box',\n    // prevent width + padding to overflow\n    // fixes overflow - see https://github.com/mui/material-ui/issues/27372\n    minWidth: 0,\n    position: 'relative'\n  }, theme.typography.body1)\n}));\nconst TreeItemGroup = styled(Collapse, {\n  name: 'MuiTreeItem',\n  slot: 'Group',\n  overridesResolver: (props, styles) => styles.group\n})({\n  margin: 0,\n  padding: 0,\n  marginLeft: 17\n});\n\n/**\n *\n * Demos:\n *\n * - [Tree View](https://mui.com/x/react-tree-view/)\n *\n * API:\n *\n * - [TreeItem API](https://mui.com/x/api/tree-view/tree-item/)\n */\nexport const TreeItem = /*#__PURE__*/React.forwardRef(function TreeItem(inProps, ref) {\n  const props = useThemeProps({\n    props: inProps,\n    name: 'MuiTreeItem'\n  });\n  const {\n      children,\n      className,\n      collapseIcon,\n      ContentComponent = TreeItemContent,\n      ContentProps,\n      endIcon,\n      expandIcon,\n      disabled: disabledProp,\n      icon,\n      id: idProp,\n      label,\n      nodeId,\n      onClick,\n      onMouseDown,\n      TransitionComponent = Collapse,\n      TransitionProps\n    } = props,\n    other = _objectWithoutPropertiesLoose(props, _excluded);\n  const {\n    icons: contextIcons,\n    multiSelect,\n    disabledItemsFocusable,\n    treeId,\n    instance\n  } = useTreeViewContext();\n  let id;\n  if (idProp != null) {\n    id = idProp;\n  } else if (treeId && nodeId) {\n    id = `${treeId}-${nodeId}`;\n  }\n  const [treeItemElement, setTreeItemElement] = React.useState(null);\n  const contentRef = React.useRef(null);\n  const handleRef = useForkRef(setTreeItemElement, ref);\n  const descendant = React.useMemo(() => ({\n    element: treeItemElement,\n    id: nodeId\n  }), [nodeId, treeItemElement]);\n  const {\n    index,\n    parentId\n  } = useDescendant(descendant);\n  const expandable = Boolean(Array.isArray(children) ? children.length : children);\n  const expanded = instance ? instance.isNodeExpanded(nodeId) : false;\n  const focused = instance ? instance.isNodeFocused(nodeId) : false;\n  const selected = instance ? instance.isNodeSelected(nodeId) : false;\n  const disabled = instance ? instance.isNodeDisabled(nodeId) : false;\n  const ownerState = _extends({}, props, {\n    expanded,\n    focused,\n    selected,\n    disabled\n  });\n  const classes = useUtilityClasses(ownerState);\n  let displayIcon;\n  let expansionIcon;\n  if (expandable) {\n    if (!expanded) {\n      expansionIcon = expandIcon || contextIcons.defaultExpandIcon;\n    } else {\n      expansionIcon = collapseIcon || contextIcons.defaultCollapseIcon;\n    }\n  }\n  if (expandable) {\n    displayIcon = contextIcons.defaultParentIcon;\n  } else {\n    displayIcon = endIcon || contextIcons.defaultEndIcon;\n  }\n  React.useEffect(() => {\n    // On the first render a node's index will be -1. We want to wait for the real index.\n    if (instance && index !== -1) {\n      instance.updateNode({\n        id: nodeId,\n        idAttribute: id,\n        index,\n        parentId,\n        expandable,\n        disabled: disabledProp\n      });\n      return () => instance.removeNode(nodeId);\n    }\n    return undefined;\n  }, [instance, parentId, index, nodeId, expandable, disabledProp, id]);\n  React.useEffect(() => {\n    if (instance && label) {\n      var _contentRef$current$t, _contentRef$current;\n      return instance.mapFirstChar(nodeId, ((_contentRef$current$t = (_contentRef$current = contentRef.current) == null ? void 0 : _contentRef$current.textContent) != null ? _contentRef$current$t : '').substring(0, 1).toLowerCase());\n    }\n    return undefined;\n  }, [instance, nodeId, label]);\n  let ariaSelected;\n  if (multiSelect) {\n    ariaSelected = selected;\n  } else if (selected) {\n    /* single-selection trees unset aria-selected on un-selected items.\n     *\n     * If the tree does not support multiple selection, aria-selected\n     * is set to true for the selected node and it is not present on any other node in the tree.\n     * Source: https://www.w3.org/WAI/ARIA/apg/patterns/treeview/\n     */\n    ariaSelected = true;\n  }\n  function handleFocus(event) {\n    // DOM focus stays on the tree which manages focus with aria-activedescendant\n    if (event.target === event.currentTarget) {\n      let rootElement;\n      if (typeof event.target.getRootNode === 'function') {\n        rootElement = event.target.getRootNode();\n      } else {\n        rootElement = ownerDocument(event.target);\n      }\n      rootElement.getElementById(treeId).focus({\n        preventScroll: true\n      });\n    }\n    const unfocusable = !disabledItemsFocusable && disabled;\n    if (instance && !focused && event.currentTarget === event.target && !unfocusable) {\n      instance.focusNode(event, nodeId);\n    }\n  }\n  return /*#__PURE__*/_jsxs(TreeItemRoot, _extends({\n    className: clsx(classes.root, className),\n    role: \"treeitem\",\n    \"aria-expanded\": expandable ? expanded : undefined,\n    \"aria-selected\": ariaSelected,\n    \"aria-disabled\": disabled || undefined,\n    id: id,\n    tabIndex: -1\n  }, other, {\n    ownerState: ownerState,\n    onFocus: handleFocus,\n    ref: handleRef,\n    children: [/*#__PURE__*/_jsx(StyledTreeItemContent, _extends({\n      as: ContentComponent,\n      ref: contentRef,\n      classes: {\n        root: classes.content,\n        expanded: classes.expanded,\n        selected: classes.selected,\n        focused: classes.focused,\n        disabled: classes.disabled,\n        iconContainer: classes.iconContainer,\n        label: classes.label\n      },\n      label: label,\n      nodeId: nodeId,\n      onClick: onClick,\n      onMouseDown: onMouseDown,\n      icon: icon,\n      expansionIcon: expansionIcon,\n      displayIcon: displayIcon,\n      ownerState: ownerState\n    }, ContentProps)), children && /*#__PURE__*/_jsx(DescendantProvider, {\n      id: nodeId,\n      children: /*#__PURE__*/_jsx(TreeItemGroup, _extends({\n        as: TransitionComponent,\n        unmountOnExit: true,\n        className: classes.group,\n        in: expanded,\n        component: \"ul\",\n        role: \"group\"\n      }, TransitionProps, {\n        children: children\n      }))\n    })]\n  }));\n});\nprocess.env.NODE_ENV !== \"production\" ? TreeItem.propTypes = {\n  // ----------------------------- Warning --------------------------------\n  // | These PropTypes are generated from the TypeScript type definitions |\n  // | To update them edit the TypeScript types and run \"yarn proptypes\"  |\n  // ----------------------------------------------------------------------\n  /**\n   * The content of the component.\n   */\n  children: PropTypes.node,\n  /**\n   * Override or extend the styles applied to the component.\n   */\n  classes: PropTypes.object,\n  /**\n   * className applied to the root element.\n   */\n  className: PropTypes.string,\n  /**\n   * The icon used to collapse the node.\n   */\n  collapseIcon: PropTypes.node,\n  /**\n   * The component used for the content node.\n   * @default TreeItemContent\n   */\n  ContentComponent: elementTypeAcceptingRef,\n  /**\n   * Props applied to ContentComponent.\n   */\n  ContentProps: PropTypes.object,\n  /**\n   * If `true`, the node is disabled.\n   * @default false\n   */\n  disabled: PropTypes.bool,\n  /**\n   * The icon displayed next to an end node.\n   */\n  endIcon: PropTypes.node,\n  /**\n   * The icon used to expand the node.\n   */\n  expandIcon: PropTypes.node,\n  /**\n   * The icon to display next to the tree node's label.\n   */\n  icon: PropTypes.node,\n  /**\n   * The tree node label.\n   */\n  label: PropTypes.node,\n  /**\n   * The id of the node.\n   */\n  nodeId: PropTypes.string.isRequired,\n  /**\n   * This prop isn't supported.\n   * Use the `onNodeFocus` callback on the tree if you need to monitor a node's focus.\n   */\n  onFocus: unsupportedProp,\n  /**\n   * The system prop that allows defining system overrides as well as additional CSS styles.\n   */\n  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),\n  /**\n   * The component used for the transition.\n   * [Follow this guide](/material-ui/transitions/#transitioncomponent-prop) to learn more about the requirements for this component.\n   * @default Collapse\n   */\n  TransitionComponent: PropTypes.elementType,\n  /**\n   * Props applied to the transition element.\n   * By default, the element is based on this [`Transition`](http://reactcommunity.org/react-transition-group/transition/) component.\n   */\n  TransitionProps: PropTypes.object\n} : void 0;","export default function composeClasses(slots, getUtilityClass, classes = undefined) {\n  const output = {};\n  Object.keys(slots).forEach(\n  // `Object.keys(slots)` can't be wider than `T` because we infer `T` from `slots`.\n  // @ts-expect-error https://github.com/microsoft/TypeScript/pull/12253#issuecomment-263132208\n  slot => {\n    output[slot] = slots[slot].reduce((acc, key) => {\n      if (key) {\n        const utilityClass = getUtilityClass(key);\n        if (utilityClass !== '') {\n          acc.push(utilityClass);\n        }\n        if (classes && classes[key]) {\n          acc.push(classes[key]);\n        }\n      }\n      return acc;\n    }, []).join(' ');\n  });\n  return output;\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 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?.className, className, externalForwardedProps?.className, externalSlotProps?.className);\n    const mergedStyle = {\n      ...additionalProps?.style,\n      ...externalForwardedProps?.style,\n      ...externalSlotProps?.style\n    };\n    const props = {\n      ...additionalProps,\n      ...externalForwardedProps,\n      ...externalSlotProps\n    };\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({\n    ...externalForwardedProps,\n    ...externalSlotProps\n  });\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?.className, additionalProps?.className, className, externalForwardedProps?.className, externalSlotProps?.className);\n  const mergedStyle = {\n    ...internalSlotProps?.style,\n    ...additionalProps?.style,\n    ...externalForwardedProps?.style,\n    ...externalSlotProps?.style\n  };\n  const props = {\n    ...internalSlotProps,\n    ...additionalProps,\n    ...otherPropsWithoutEventHandlers,\n    ...componentsPropsWithoutEventHandlers\n  };\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 * 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}","'use client';\n\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  const {\n    elementType,\n    externalSlotProps,\n    ownerState,\n    skipResolvingSlotProps = false,\n    ...rest\n  } = parameters;\n  const resolvedComponentsProps = skipResolvingSlotProps ? {} : resolveComponentProps(externalSlotProps, ownerState);\n  const {\n    props: mergedProps,\n    internalRef\n  } = mergeSlotProps({\n    ...rest,\n    externalSlotProps: resolvedComponentsProps\n  });\n  const ref = useForkRef(internalRef, resolvedComponentsProps?.ref, parameters.additionalProps?.ref);\n  const props = appendOwnerState(elementType, {\n    ...mergedProps,\n    ref\n  }, ownerState);\n  return props;\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}","import { 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 {\n    ...otherProps,\n    ownerState: {\n      ...otherProps.ownerState,\n      ...ownerState\n    }\n  };\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}","'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}","/**\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}","import generateUtilityClass from '@mui/utils/generateUtilityClass';\nimport generateUtilityClasses from '@mui/utils/generateUtilityClasses';\nexport function getTreeViewUtilityClass(slot) {\n  return generateUtilityClass('MuiTreeView', slot);\n}\nexport const treeViewClasses = generateUtilityClasses('MuiTreeView', ['root']);","// Used https://gist.github.com/mudge/5830382 as a starting point.\n// See https://github.com/browserify/events/blob/master/events.js for\n// the Node.js (https://nodejs.org/api/events.html) polyfill used by webpack.\nexport class EventManager {\n  constructor() {\n    this.maxListeners = 20;\n    this.warnOnce = false;\n    this.events = {};\n  }\n  on(eventName, listener, options = {}) {\n    let collection = this.events[eventName];\n    if (!collection) {\n      collection = {\n        highPriority: new Map(),\n        regular: new Map()\n      };\n      this.events[eventName] = collection;\n    }\n    if (options.isFirst) {\n      collection.highPriority.set(listener, true);\n    } else {\n      collection.regular.set(listener, true);\n    }\n    if (process.env.NODE_ENV !== 'production') {\n      const collectionSize = collection.highPriority.size + collection.regular.size;\n      if (collectionSize > this.maxListeners && !this.warnOnce) {\n        this.warnOnce = true;\n        console.warn([`Possible EventEmitter memory leak detected. ${collectionSize} ${eventName} listeners added.`].join('\\n'));\n      }\n    }\n  }\n  removeListener(eventName, listener) {\n    if (this.events[eventName]) {\n      this.events[eventName].regular.delete(listener);\n      this.events[eventName].highPriority.delete(listener);\n    }\n  }\n  removeAllListeners() {\n    this.events = {};\n  }\n  emit(eventName, ...args) {\n    const collection = this.events[eventName];\n    if (!collection) {\n      return;\n    }\n    const highPriorityListeners = Array.from(collection.highPriority.keys());\n    const regularListeners = Array.from(collection.regular.keys());\n    for (let i = highPriorityListeners.length - 1; i >= 0; i -= 1) {\n      const listener = highPriorityListeners[i];\n      if (collection.highPriority.has(listener)) {\n        listener.apply(this, args);\n      }\n    }\n    for (let i = 0; i < regularListeners.length; i += 1) {\n      const listener = regularListeners[i];\n      if (collection.regular.has(listener)) {\n        listener.apply(this, args);\n      }\n    }\n  }\n  once(eventName, listener) {\n    // eslint-disable-next-line consistent-this\n    const that = this;\n    this.on(eventName, function oneTimeListener(...args) {\n      that.removeListener(eventName, oneTimeListener);\n      listener.apply(that, args);\n    });\n  }\n}","export const getPreviousNode = (instance, nodeId) => {\n  const node = instance.getNode(nodeId);\n  const siblings = instance.getNavigableChildrenIds(node.parentId);\n  const nodeIndex = siblings.indexOf(nodeId);\n  if (nodeIndex === 0) {\n    return node.parentId;\n  }\n  let currentNode = siblings[nodeIndex - 1];\n  while (instance.isNodeExpanded(currentNode) && instance.getNavigableChildrenIds(currentNode).length > 0) {\n    currentNode = instance.getNavigableChildrenIds(currentNode).pop();\n  }\n  return currentNode;\n};\nexport const getNextNode = (instance, nodeId) => {\n  // If expanded get first child\n  if (instance.isNodeExpanded(nodeId) && instance.getNavigableChildrenIds(nodeId).length > 0) {\n    return instance.getNavigableChildrenIds(nodeId)[0];\n  }\n  let node = instance.getNode(nodeId);\n  while (node != null) {\n    // Try to get next sibling\n    const siblings = instance.getNavigableChildrenIds(node.parentId);\n    const nextSibling = siblings[siblings.indexOf(node.id) + 1];\n    if (nextSibling) {\n      return nextSibling;\n    }\n\n    // If the sibling does not exist, go up a level to the parent and try again.\n    node = instance.getNode(node.parentId);\n  }\n  return null;\n};\nexport const getLastNode = instance => {\n  let lastNode = instance.getNavigableChildrenIds(null).pop();\n  while (instance.isNodeExpanded(lastNode)) {\n    lastNode = instance.getNavigableChildrenIds(lastNode).pop();\n  }\n  return lastNode;\n};\nexport const getFirstNode = instance => instance.getNavigableChildrenIds(null)[0];\nexport const populateInstance = (instance, methods) => {\n  Object.assign(instance, methods);\n};","import { useTreeViewInstanceEvents } from './useTreeViewInstanceEvents';\n/**\n * Internal plugins that creates the tools used by the other plugins.\n * These plugins are used by the tree view components.\n */\nexport const TREE_VIEW_CORE_PLUGINS = [useTreeViewInstanceEvents];","import * as React from 'react';\nimport { EventManager } from '../../utils/EventManager';\nimport { populateInstance } from '../../useTreeView/useTreeView.utils';\nconst isSyntheticEvent = event => {\n  return event.isPropagationStopped !== undefined;\n};\n\n/**\n * Plugin responsible for the registration of the nodes defined as JSX children of the TreeView.\n * When we will have both a SimpleTreeView using JSX children and a TreeView using a data prop,\n * this plugin will only be used by SimpleTreeView.\n */\nexport const useTreeViewInstanceEvents = ({\n  instance\n}) => {\n  const [eventManager] = React.useState(() => new EventManager());\n  const publishEvent = React.useCallback((...args) => {\n    const [name, params, event = {}] = args;\n    event.defaultMuiPrevented = false;\n    if (isSyntheticEvent(event) && event.isPropagationStopped()) {\n      return;\n    }\n    eventManager.emit(name, params, event);\n  }, [eventManager]);\n  const subscribeEvent = React.useCallback((event, handler) => {\n    eventManager.on(event, handler);\n    return () => {\n      eventManager.removeListener(event, handler);\n    };\n  }, [eventManager]);\n  populateInstance(instance, {\n    $$publishEvent: publishEvent,\n    $$subscribeEvent: subscribeEvent\n  });\n};","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport useForkRef from '@mui/utils/useForkRef';\nimport { DEFAULT_TREE_VIEW_CONTEXT_VALUE } from '../TreeViewProvider/TreeViewContext';\nimport { useTreeViewModels } from './useTreeViewModels';\nimport { TREE_VIEW_CORE_PLUGINS } from '../corePlugins';\nexport const useTreeView = inParams => {\n  const plugins = [...TREE_VIEW_CORE_PLUGINS, ...inParams.plugins];\n  const params = plugins.reduce((acc, plugin) => {\n    if (plugin.getDefaultizedParams) {\n      return plugin.getDefaultizedParams(acc);\n    }\n    return acc;\n  }, inParams);\n  const models = useTreeViewModels(plugins, params);\n  const instanceRef = React.useRef({});\n  const instance = instanceRef.current;\n  const innerRootRef = React.useRef(null);\n  const handleRootRef = useForkRef(innerRootRef, inParams.rootRef);\n  const [state, setState] = React.useState(() => {\n    const temp = {};\n    plugins.forEach(plugin => {\n      if (plugin.getInitialState) {\n        Object.assign(temp, plugin.getInitialState(params));\n      }\n    });\n    return temp;\n  });\n  const rootPropsGetters = [];\n  let contextValue = DEFAULT_TREE_VIEW_CONTEXT_VALUE;\n  const runPlugin = plugin => {\n    const pluginResponse = plugin({\n      instance,\n      params,\n      state,\n      setState,\n      rootRef: innerRootRef,\n      models\n    }) || {};\n    if (pluginResponse.getRootProps) {\n      rootPropsGetters.push(pluginResponse.getRootProps);\n    }\n    if (pluginResponse.contextValue) {\n      contextValue = pluginResponse.contextValue;\n    }\n  };\n  plugins.forEach(runPlugin);\n  const getRootProps = (otherHandlers = {}) => {\n    const rootProps = _extends({\n      role: 'tree',\n      tabIndex: 0\n    }, otherHandlers, {\n      ref: handleRootRef\n    });\n    rootPropsGetters.forEach(rootPropsGetter => {\n      Object.assign(rootProps, rootPropsGetter(otherHandlers));\n    });\n    return rootProps;\n  };\n  return {\n    getRootProps,\n    rootRef: handleRootRef,\n    contextValue\n  };\n};","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\n/**\n * Implements the same behavior as `useControlled` but for several models.\n * The controlled models are never stored in the state and the state is only updated if the model is not controlled.\n */\nexport const useTreeViewModels = (plugins, props) => {\n  const modelsRef = React.useRef({});\n  const [modelsState, setModelsState] = React.useState(() => {\n    const initialState = {};\n    plugins.forEach(plugin => {\n      if (plugin.models) {\n        Object.entries(plugin.models).forEach(([modelName, model]) => {\n          modelsRef.current[modelName] = {\n            controlledProp: model.controlledProp,\n            defaultProp: model.defaultProp,\n            isControlled: props[model.controlledProp] !== undefined\n          };\n          initialState[modelName] = props[model.defaultProp];\n        });\n      }\n    });\n    return initialState;\n  });\n  const models = Object.fromEntries(Object.entries(modelsRef.current).map(([modelName, model]) => {\n    const value = model.isControlled ? props[model.controlledProp] : modelsState[modelName];\n    return [modelName, {\n      value,\n      setValue: newValue => {\n        if (!model.isControlled) {\n          setModelsState(prevState => _extends({}, prevState, {\n            [modelName]: newValue\n          }));\n        }\n      }\n    }];\n  }));\n\n  // We know that `modelsRef` do not vary across renders.\n  /* eslint-disable react-hooks/rules-of-hooks, react-hooks/exhaustive-deps */\n  if (process.env.NODE_ENV !== 'production') {\n    Object.entries(modelsRef.current).forEach(([modelName, model]) => {\n      const controlled = props[model.controlledProp];\n      const defaultProp = props[model.defaultProp];\n      React.useEffect(() => {\n        if (model.isControlled !== (controlled !== undefined)) {\n          console.error([`MUI: A component is changing the ${model.isControlled ? '' : 'un'}controlled ${modelName} state of TreeView to be ${model.isControlled ? 'un' : ''}controlled.`, 'Elements should not switch from uncontrolled to controlled (or vice versa).', `Decide between using a controlled or uncontrolled ${modelName} ` + 'element for the lifetime of the component.', \"The nature of the state is determined during the first render. It's considered controlled if the value is not `undefined`.\", 'More info: https://fb.me/react-controlled-components'].join('\\n'));\n        }\n      }, [controlled]);\n      const {\n        current: defaultValue\n      } = React.useRef(defaultProp);\n      React.useEffect(() => {\n        if (!model.isControlled && defaultValue !== defaultProp) {\n          console.error([`MUI: A component is changing the default ${modelName} state of an uncontrolled TreeView after being initialized. ` + `To suppress this warning opt to use a controlled TreeView.`].join('\\n'));\n        }\n      }, [JSON.stringify(defaultValue)]);\n    });\n  }\n  /* eslint-enable react-hooks/rules-of-hooks, react-hooks/exhaustive-deps */\n\n  return models;\n};","import * as React from 'react';\nimport { TreeViewContext } from './TreeViewContext';\nimport { DescendantProvider } from './DescendantProvider';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\n/**\n * Sets up the contexts for the underlying TreeItem components.\n *\n * @ignore - do not document.\n */\nexport function TreeViewProvider(props) {\n  const {\n    value,\n    children\n  } = props;\n  return /*#__PURE__*/_jsx(TreeViewContext.Provider, {\n    value: value,\n    children: /*#__PURE__*/_jsx(DescendantProvider, {\n      children: children\n    })\n  });\n}","export const publishTreeViewEvent = (instance, eventName, params) => {\n  instance.$$publishEvent(eventName, params);\n};","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport useEventCallback from '@mui/utils/useEventCallback';\nimport { populateInstance } from '../../useTreeView/useTreeView.utils';\nexport const useTreeViewExpansion = ({\n  instance,\n  params,\n  models\n}) => {\n  const isNodeExpanded = React.useCallback(nodeId => {\n    return Array.isArray(models.expanded.value) ? models.expanded.value.indexOf(nodeId) !== -1 : false;\n  }, [models.expanded.value]);\n  const isNodeExpandable = React.useCallback(nodeId => {\n    var _instance$getNode;\n    return !!((_instance$getNode = instance.getNode(nodeId)) != null && _instance$getNode.expandable);\n  }, [instance]);\n  const toggleNodeExpansion = useEventCallback((event, nodeId) => {\n    if (nodeId == null) {\n      return;\n    }\n    let newExpanded;\n    if (models.expanded.value.indexOf(nodeId) !== -1) {\n      newExpanded = models.expanded.value.filter(id => id !== nodeId);\n    } else {\n      newExpanded = [nodeId].concat(models.expanded.value);\n    }\n    if (params.onNodeToggle) {\n      params.onNodeToggle(event, newExpanded);\n    }\n    models.expanded.setValue(newExpanded);\n  });\n  const expandAllSiblings = (event, nodeId) => {\n    const node = instance.getNode(nodeId);\n    const siblings = instance.getChildrenIds(node.parentId);\n    const diff = siblings.filter(child => instance.isNodeExpandable(child) && !instance.isNodeExpanded(child));\n    const newExpanded = models.expanded.value.concat(diff);\n    if (diff.length > 0) {\n      models.expanded.setValue(newExpanded);\n      if (params.onNodeToggle) {\n        params.onNodeToggle(event, newExpanded);\n      }\n    }\n  };\n  populateInstance(instance, {\n    isNodeExpanded,\n    isNodeExpandable,\n    toggleNodeExpansion,\n    expandAllSiblings\n  });\n};\nuseTreeViewExpansion.models = {\n  expanded: {\n    controlledProp: 'expanded',\n    defaultProp: 'defaultExpanded'\n  }\n};\nconst DEFAULT_EXPANDED = [];\nuseTreeViewExpansion.getDefaultizedParams = params => {\n  var _params$defaultExpand;\n  return _extends({}, params, {\n    defaultExpanded: (_params$defaultExpand = params.defaultExpanded) != null ? _params$defaultExpand : DEFAULT_EXPANDED\n  });\n};","/**\n * This is used to determine the start and end of a selection range so\n * we can get the nodes between the two border nodes.\n *\n * It finds the nodes' common ancestor using\n * a naive implementation of a lowest common ancestor algorithm\n * (https://en.wikipedia.org/wiki/Lowest_common_ancestor).\n * Then compares the ancestor's 2 children that are ancestors of nodeA and NodeB\n * so we can compare their indexes to work out which node comes first in a depth first search.\n * (https://en.wikipedia.org/wiki/Depth-first_search)\n *\n * Another way to put it is which node is shallower in a trémaux tree\n * https://en.wikipedia.org/wiki/Tr%C3%A9maux_tree\n */\nexport const findOrderInTremauxTree = (instance, nodeAId, nodeBId) => {\n  if (nodeAId === nodeBId) {\n    return [nodeAId, nodeBId];\n  }\n  const nodeA = instance.getNode(nodeAId);\n  const nodeB = instance.getNode(nodeBId);\n  if (nodeA.parentId === nodeB.id || nodeB.parentId === nodeA.id) {\n    return nodeB.parentId === nodeA.id ? [nodeA.id, nodeB.id] : [nodeB.id, nodeA.id];\n  }\n  const aFamily = [nodeA.id];\n  const bFamily = [nodeB.id];\n  let aAncestor = nodeA.parentId;\n  let bAncestor = nodeB.parentId;\n  let aAncestorIsCommon = bFamily.indexOf(aAncestor) !== -1;\n  let bAncestorIsCommon = aFamily.indexOf(bAncestor) !== -1;\n  let continueA = true;\n  let continueB = true;\n  while (!bAncestorIsCommon && !aAncestorIsCommon) {\n    if (continueA) {\n      aFamily.push(aAncestor);\n      aAncestorIsCommon = bFamily.indexOf(aAncestor) !== -1;\n      continueA = aAncestor !== null;\n      if (!aAncestorIsCommon && continueA) {\n        aAncestor = instance.getNode(aAncestor).parentId;\n      }\n    }\n    if (continueB && !aAncestorIsCommon) {\n      bFamily.push(bAncestor);\n      bAncestorIsCommon = aFamily.indexOf(bAncestor) !== -1;\n      continueB = bAncestor !== null;\n      if (!bAncestorIsCommon && continueB) {\n        bAncestor = instance.getNode(bAncestor).parentId;\n      }\n    }\n  }\n  const commonAncestor = aAncestorIsCommon ? aAncestor : bAncestor;\n  const ancestorFamily = instance.getChildrenIds(commonAncestor);\n  const aSide = aFamily[aFamily.indexOf(commonAncestor) - 1];\n  const bSide = bFamily[bFamily.indexOf(commonAncestor) - 1];\n  return ancestorFamily.indexOf(aSide) < ancestorFamily.indexOf(bSide) ? [nodeAId, nodeBId] : [nodeBId, nodeAId];\n};","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport { populateInstance, getNextNode, getFirstNode, getLastNode } from '../../useTreeView/useTreeView.utils';\nimport { findOrderInTremauxTree } from './useTreeViewSelection.utils';\nexport const useTreeViewSelection = ({\n  instance,\n  params,\n  models\n}) => {\n  const lastSelectedNode = React.useRef(null);\n  const lastSelectionWasRange = React.useRef(false);\n  const currentRangeSelection = React.useRef([]);\n  const isNodeSelected = nodeId => Array.isArray(models.selected.value) ? models.selected.value.indexOf(nodeId) !== -1 : models.selected.value === nodeId;\n  const selectNode = (event, nodeId, multiple = false) => {\n    if (params.disableSelection) {\n      return;\n    }\n    if (multiple) {\n      if (Array.isArray(models.selected.value)) {\n        let newSelected;\n        if (models.selected.value.indexOf(nodeId) !== -1) {\n          newSelected = models.selected.value.filter(id => id !== nodeId);\n        } else {\n          newSelected = [nodeId].concat(models.selected.value);\n        }\n        if (params.onNodeSelect) {\n          params.onNodeSelect(event, newSelected);\n        }\n        models.selected.setValue(newSelected);\n      }\n    } else {\n      const newSelected = params.multiSelect ? [nodeId] : nodeId;\n      if (params.onNodeSelect) {\n        params.onNodeSelect(event, newSelected);\n      }\n      models.selected.setValue(newSelected);\n    }\n    lastSelectedNode.current = nodeId;\n    lastSelectionWasRange.current = false;\n    currentRangeSelection.current = [];\n  };\n  const getNodesInRange = (nodeAId, nodeBId) => {\n    const [first, last] = findOrderInTremauxTree(instance, nodeAId, nodeBId);\n    const nodes = [first];\n    let current = first;\n    while (current !== last) {\n      current = getNextNode(instance, current);\n      nodes.push(current);\n    }\n    return nodes;\n  };\n  const handleRangeArrowSelect = (event, nodes) => {\n    let base = models.selected.value.slice();\n    const {\n      start,\n      next,\n      current\n    } = nodes;\n    if (!next || !current) {\n      return;\n    }\n    if (currentRangeSelection.current.indexOf(current) === -1) {\n      currentRangeSelection.current = [];\n    }\n    if (lastSelectionWasRange.current) {\n      if (currentRangeSelection.current.indexOf(next) !== -1) {\n        base = base.filter(id => id === start || id !== current);\n        currentRangeSelection.current = currentRangeSelection.current.filter(id => id === start || id !== current);\n      } else {\n        base.push(next);\n        currentRangeSelection.current.push(next);\n      }\n    } else {\n      base.push(next);\n      currentRangeSelection.current.push(current, next);\n    }\n    if (params.onNodeSelect) {\n      params.onNodeSelect(event, base);\n    }\n    models.selected.setValue(base);\n  };\n  const handleRangeSelect = (event, nodes) => {\n    let base = models.selected.value.slice();\n    const {\n      start,\n      end\n    } = nodes;\n    // If last selection was a range selection ignore nodes that were selected.\n    if (lastSelectionWasRange.current) {\n      base = base.filter(id => currentRangeSelection.current.indexOf(id) === -1);\n    }\n    let range = getNodesInRange(start, end);\n    range = range.filter(node => !instance.isNodeDisabled(node));\n    currentRangeSelection.current = range;\n    let newSelected = base.concat(range);\n    newSelected = newSelected.filter((id, i) => newSelected.indexOf(id) === i);\n    if (params.onNodeSelect) {\n      params.onNodeSelect(event, newSelected);\n    }\n    models.selected.setValue(newSelected);\n  };\n  const selectRange = (event, nodes, stacked = false) => {\n    if (params.disableSelection) {\n      return;\n    }\n    const {\n      start = lastSelectedNode.current,\n      end,\n      current\n    } = nodes;\n    if (stacked) {\n      handleRangeArrowSelect(event, {\n        start,\n        next: end,\n        current\n      });\n    } else if (start != null && end != null) {\n      handleRangeSelect(event, {\n        start,\n        end\n      });\n    }\n    lastSelectionWasRange.current = true;\n  };\n  const rangeSelectToFirst = (event, nodeId) => {\n    if (!lastSelectedNode.current) {\n      lastSelectedNode.current = nodeId;\n    }\n    const start = lastSelectionWasRange.current ? lastSelectedNode.current : nodeId;\n    instance.selectRange(event, {\n      start,\n      end: getFirstNode(instance)\n    });\n  };\n  const rangeSelectToLast = (event, nodeId) => {\n    if (!lastSelectedNode.current) {\n      lastSelectedNode.current = nodeId;\n    }\n    const start = lastSelectionWasRange.current ? lastSelectedNode.current : nodeId;\n    instance.selectRange(event, {\n      start,\n      end: getLastNode(instance)\n    });\n  };\n  populateInstance(instance, {\n    isNodeSelected,\n    selectNode,\n    selectRange,\n    rangeSelectToLast,\n    rangeSelectToFirst\n  });\n  return {\n    getRootProps: () => ({\n      'aria-multiselectable': params.multiSelect\n    })\n  };\n};\nuseTreeViewSelection.models = {\n  selected: {\n    controlledProp: 'selected',\n    defaultProp: 'defaultSelected'\n  }\n};\nconst DEFAULT_SELECTED = [];\nuseTreeViewSelection.getDefaultizedParams = params => {\n  var _params$disableSelect, _params$multiSelect, _params$defaultSelect;\n  return _extends({}, params, {\n    disableSelection: (_params$disableSelect = params.disableSelection) != null ? _params$disableSelect : false,\n    multiSelect: (_params$multiSelect = params.multiSelect) != null ? _params$multiSelect : false,\n    defaultSelected: (_params$defaultSelect = params.defaultSelected) != null ? _params$defaultSelect : params.multiSelect ? DEFAULT_SELECTED : null\n  });\n};","// If no effect ran after this amount of time, we assume that the render was not committed by React\nconst CLEANUP_TIMER_LOOP_MILLIS = 1000;\nexport class TimerBasedCleanupTracking {\n  constructor(timeout = CLEANUP_TIMER_LOOP_MILLIS) {\n    this.timeouts = new Map();\n    this.cleanupTimeout = CLEANUP_TIMER_LOOP_MILLIS;\n    this.cleanupTimeout = timeout;\n  }\n  register(object, unsubscribe, unregisterToken) {\n    if (!this.timeouts) {\n      this.timeouts = new Map();\n    }\n    const timeout = setTimeout(() => {\n      if (typeof unsubscribe === 'function') {\n        unsubscribe();\n      }\n      this.timeouts.delete(unregisterToken.cleanupToken);\n    }, this.cleanupTimeout);\n    this.timeouts.set(unregisterToken.cleanupToken, timeout);\n  }\n  unregister(unregisterToken) {\n    const timeout = this.timeouts.get(unregisterToken.cleanupToken);\n    if (timeout) {\n      this.timeouts.delete(unregisterToken.cleanupToken);\n      clearTimeout(timeout);\n    }\n  }\n  reset() {\n    if (this.timeouts) {\n      this.timeouts.forEach((value, key) => {\n        this.unregister({\n          cleanupToken: key\n        });\n      });\n      this.timeouts = undefined;\n    }\n  }\n}","export class FinalizationRegistryBasedCleanupTracking {\n  constructor() {\n    this.registry = new FinalizationRegistry(unsubscribe => {\n      if (typeof unsubscribe === 'function') {\n        unsubscribe();\n      }\n    });\n  }\n  register(object, unsubscribe, unregisterToken) {\n    this.registry.register(object, unsubscribe, unregisterToken);\n  }\n  unregister(unregisterToken) {\n    this.registry.unregister(unregisterToken);\n  }\n\n  // eslint-disable-next-line class-methods-use-this\n  reset() {}\n}","import * as React from 'react';\nimport { TimerBasedCleanupTracking } from '../utils/cleanupTracking/TimerBasedCleanupTracking';\nimport { FinalizationRegistryBasedCleanupTracking } from '../utils/cleanupTracking/FinalizationRegistryBasedCleanupTracking';\n// We use class to make it easier to detect in heap snapshots by name\nclass ObjectToBeRetainedByReact {}\n\n// Based on https://github.com/Bnaya/use-dispose-uncommitted/blob/main/src/finalization-registry-based-impl.ts\n// Check https://github.com/facebook/react/issues/15317 to get more information\nexport function createUseInstanceEventHandler(registryContainer) {\n  let cleanupTokensCounter = 0;\n  return function useInstanceEventHandler(instance, eventName, handler) {\n    if (registryContainer.registry === null) {\n      registryContainer.registry = typeof FinalizationRegistry !== 'undefined' ? new FinalizationRegistryBasedCleanupTracking() : new TimerBasedCleanupTracking();\n    }\n    const [objectRetainedByReact] = React.useState(new ObjectToBeRetainedByReact());\n    const subscription = React.useRef(null);\n    const handlerRef = React.useRef();\n    handlerRef.current = handler;\n    const cleanupTokenRef = React.useRef(null);\n    if (!subscription.current && handlerRef.current) {\n      const enhancedHandler = (params, event) => {\n        if (!event.defaultMuiPrevented) {\n          var _handlerRef$current;\n          (_handlerRef$current = handlerRef.current) == null || _handlerRef$current.call(handlerRef, params, event);\n        }\n      };\n      subscription.current = instance.$$subscribeEvent(eventName, enhancedHandler);\n      cleanupTokensCounter += 1;\n      cleanupTokenRef.current = {\n        cleanupToken: cleanupTokensCounter\n      };\n      registryContainer.registry.register(objectRetainedByReact,\n      // The callback below will be called once this reference stops being retained\n      () => {\n        var _subscription$current;\n        (_subscription$current = subscription.current) == null || _subscription$current.call(subscription);\n        subscription.current = null;\n        cleanupTokenRef.current = null;\n      }, cleanupTokenRef.current);\n    } else if (!handlerRef.current && subscription.current) {\n      subscription.current();\n      subscription.current = null;\n      if (cleanupTokenRef.current) {\n        registryContainer.registry.unregister(cleanupTokenRef.current);\n        cleanupTokenRef.current = null;\n      }\n    }\n    React.useEffect(() => {\n      if (!subscription.current && handlerRef.current) {\n        const enhancedHandler = (params, event) => {\n          if (!event.defaultMuiPrevented) {\n            var _handlerRef$current2;\n            (_handlerRef$current2 = handlerRef.current) == null || _handlerRef$current2.call(handlerRef, params, event);\n          }\n        };\n        subscription.current = instance.$$subscribeEvent(eventName, enhancedHandler);\n      }\n      if (cleanupTokenRef.current && registryContainer.registry) {\n        // If the effect was called, it means that this render was committed\n        // so we can trust the cleanup function to remove the listener.\n        registryContainer.registry.unregister(cleanupTokenRef.current);\n        cleanupTokenRef.current = null;\n      }\n      return () => {\n        var _subscription$current2;\n        (_subscription$current2 = subscription.current) == null || _subscription$current2.call(subscription);\n        subscription.current = null;\n      };\n    }, [instance, eventName]);\n  };\n}\nconst registryContainer = {\n  registry: null\n};\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const unstable_resetCleanupTracking = () => {\n  var _registryContainer$re;\n  (_registryContainer$re = registryContainer.registry) == null || _registryContainer$re.reset();\n  registryContainer.registry = null;\n};\nexport const useInstanceEventHandler = createUseInstanceEventHandler(registryContainer);","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport useEventCallback from '@mui/utils/useEventCallback';\nimport ownerDocument from '@mui/utils/ownerDocument';\nimport { populateInstance } from '../../useTreeView/useTreeView.utils';\nimport { useInstanceEventHandler } from '../../hooks/useInstanceEventHandler';\nexport const useTreeViewFocus = ({\n  instance,\n  params,\n  state,\n  setState,\n  models,\n  rootRef\n}) => {\n  const setFocusedNodeId = useEventCallback(nodeId => {\n    const cleanNodeId = typeof nodeId === 'function' ? nodeId(state.focusedNodeId) : nodeId;\n    setState(prevState => _extends({}, prevState, {\n      focusedNodeId: cleanNodeId\n    }));\n  });\n  const isNodeFocused = React.useCallback(nodeId => state.focusedNodeId === nodeId, [state.focusedNodeId]);\n  const focusNode = useEventCallback((event, nodeId) => {\n    if (nodeId) {\n      setFocusedNodeId(nodeId);\n      if (params.onNodeFocus) {\n        params.onNodeFocus(event, nodeId);\n      }\n    }\n  });\n  populateInstance(instance, {\n    isNodeFocused,\n    focusNode\n  });\n  useInstanceEventHandler(instance, 'removeNode', ({\n    id\n  }) => {\n    setFocusedNodeId(oldFocusedNodeId => {\n      if (oldFocusedNodeId === id && rootRef.current === ownerDocument(rootRef.current).activeElement) {\n        return instance.getChildrenIds(null)[0];\n      }\n      return oldFocusedNodeId;\n    });\n  });\n  const createHandleFocus = otherHandlers => event => {\n    var _otherHandlers$onFocu;\n    (_otherHandlers$onFocu = otherHandlers.onFocus) == null || _otherHandlers$onFocu.call(otherHandlers, event);\n\n    // if the event bubbled (which is React specific) we don't want to steal focus\n    if (event.target === event.currentTarget) {\n      const isNodeVisible = nodeId => {\n        const node = instance.getNode(nodeId);\n        return node && (node.parentId == null || instance.isNodeExpanded(node.parentId));\n      };\n      let nodeToFocusId;\n      if (Array.isArray(models.selected.value)) {\n        nodeToFocusId = models.selected.value.find(isNodeVisible);\n      } else if (models.selected.value != null && isNodeVisible(models.selected.value)) {\n        nodeToFocusId = models.selected.value;\n      }\n      if (nodeToFocusId == null) {\n        nodeToFocusId = instance.getNavigableChildrenIds(null)[0];\n      }\n      instance.focusNode(event, nodeToFocusId);\n    }\n  };\n  const createHandleBlur = otherHandlers => event => {\n    var _otherHandlers$onBlur;\n    (_otherHandlers$onBlur = otherHandlers.onBlur) == null || _otherHandlers$onBlur.call(otherHandlers, event);\n    setFocusedNodeId(null);\n  };\n  const focusedNode = instance.getNode(state.focusedNodeId);\n  const activeDescendant = focusedNode ? focusedNode.idAttribute : null;\n  return {\n    getRootProps: otherHandlers => ({\n      onFocus: createHandleFocus(otherHandlers),\n      onBlur: createHandleBlur(otherHandlers),\n      'aria-activedescendant': activeDescendant != null ? activeDescendant : undefined\n    })\n  };\n};\nuseTreeViewFocus.getInitialState = () => ({\n  focusedNodeId: null\n});\nuseTreeViewFocus.getDefaultizedParams = params => {\n  var _params$disabledItems;\n  return _extends({}, params, {\n    disabledItemsFocusable: (_params$disabledItems = params.disabledItemsFocusable) != null ? _params$disabledItems : false\n  });\n};","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport { useTheme } from '@mui/material/styles';\nimport useEventCallback from '@mui/utils/useEventCallback';\nimport { getFirstNode, getLastNode, getNextNode, getPreviousNode, populateInstance } from '../../useTreeView/useTreeView.utils';\nfunction isPrintableCharacter(string) {\n  return string && string.length === 1 && string.match(/\\S/);\n}\nfunction findNextFirstChar(firstChars, startIndex, char) {\n  for (let i = startIndex; i < firstChars.length; i += 1) {\n    if (char === firstChars[i]) {\n      return i;\n    }\n  }\n  return -1;\n}\nexport const useTreeViewKeyboardNavigation = ({\n  instance,\n  params,\n  state\n}) => {\n  const theme = useTheme();\n  const isRtl = theme.direction === 'rtl';\n  const firstCharMap = React.useRef({});\n  const mapFirstChar = useEventCallback((nodeId, firstChar) => {\n    firstCharMap.current[nodeId] = firstChar;\n    return () => {\n      const newMap = _extends({}, firstCharMap.current);\n      delete newMap[nodeId];\n      firstCharMap.current = newMap;\n    };\n  });\n  populateInstance(instance, {\n    mapFirstChar\n  });\n  const handleNextArrow = event => {\n    if (state.focusedNodeId != null && instance.isNodeExpandable(state.focusedNodeId)) {\n      if (instance.isNodeExpanded(state.focusedNodeId)) {\n        instance.focusNode(event, getNextNode(instance, state.focusedNodeId));\n      } else if (!instance.isNodeDisabled(state.focusedNodeId)) {\n        instance.toggleNodeExpansion(event, state.focusedNodeId);\n      }\n    }\n    return true;\n  };\n  const handlePreviousArrow = event => {\n    if (state.focusedNodeId == null) {\n      return false;\n    }\n    if (instance.isNodeExpanded(state.focusedNodeId) && !instance.isNodeDisabled(state.focusedNodeId)) {\n      instance.toggleNodeExpansion(event, state.focusedNodeId);\n      return true;\n    }\n    const parent = instance.getNode(state.focusedNodeId).parentId;\n    if (parent) {\n      instance.focusNode(event, parent);\n      return true;\n    }\n    return false;\n  };\n  const focusByFirstCharacter = (event, nodeId, firstChar) => {\n    let start;\n    let index;\n    const lowercaseChar = firstChar.toLowerCase();\n    const firstCharIds = [];\n    const firstChars = [];\n    // This really only works since the ids are strings\n    Object.keys(firstCharMap.current).forEach(mapNodeId => {\n      const map = instance.getNode(mapNodeId);\n      const visible = map.parentId ? instance.isNodeExpanded(map.parentId) : true;\n      const shouldBeSkipped = params.disabledItemsFocusable ? false : instance.isNodeDisabled(mapNodeId);\n      if (visible && !shouldBeSkipped) {\n        firstCharIds.push(mapNodeId);\n        firstChars.push(firstCharMap.current[mapNodeId]);\n      }\n    });\n\n    // Get start index for search based on position of currentItem\n    start = firstCharIds.indexOf(nodeId) + 1;\n    if (start >= firstCharIds.length) {\n      start = 0;\n    }\n\n    // Check remaining slots in the menu\n    index = findNextFirstChar(firstChars, start, lowercaseChar);\n\n    // If not found in remaining slots, check from beginning\n    if (index === -1) {\n      index = findNextFirstChar(firstChars, 0, lowercaseChar);\n    }\n\n    // If match was found...\n    if (index > -1) {\n      instance.focusNode(event, firstCharIds[index]);\n    }\n  };\n  const selectNextNode = (event, id) => {\n    if (!instance.isNodeDisabled(getNextNode(instance, id))) {\n      instance.selectRange(event, {\n        end: getNextNode(instance, id),\n        current: id\n      }, true);\n    }\n  };\n  const selectPreviousNode = (event, nodeId) => {\n    if (!instance.isNodeDisabled(getPreviousNode(instance, nodeId))) {\n      instance.selectRange(event, {\n        end: getPreviousNode(instance, nodeId),\n        current: nodeId\n      }, true);\n    }\n  };\n  const createHandleKeyDown = otherHandlers => event => {\n    var _otherHandlers$onKeyD;\n    (_otherHandlers$onKeyD = otherHandlers.onKeyDown) == null || _otherHandlers$onKeyD.call(otherHandlers, event);\n    let flag = false;\n    const key = event.key;\n\n    // If the tree is empty there will be no focused node\n    if (event.altKey || event.currentTarget !== event.target || state.focusedNodeId == null) {\n      return;\n    }\n    const ctrlPressed = event.ctrlKey || event.metaKey;\n    switch (key) {\n      case ' ':\n        if (!params.disableSelection && !instance.isNodeDisabled(state.focusedNodeId)) {\n          flag = true;\n          if (params.multiSelect && event.shiftKey) {\n            instance.selectRange(event, {\n              end: state.focusedNodeId\n            });\n          } else if (params.multiSelect) {\n            instance.selectNode(event, state.focusedNodeId, true);\n          } else {\n            instance.selectNode(event, state.focusedNodeId);\n          }\n        }\n        event.stopPropagation();\n        break;\n      case 'Enter':\n        if (!instance.isNodeDisabled(state.focusedNodeId)) {\n          if (instance.isNodeExpandable(state.focusedNodeId)) {\n            instance.toggleNodeExpansion(event, state.focusedNodeId);\n            flag = true;\n          } else if (!params.disableSelection) {\n            flag = true;\n            if (params.multiSelect) {\n              instance.selectNode(event, state.focusedNodeId, true);\n            } else {\n              instance.selectNode(event, state.focusedNodeId);\n            }\n          }\n        }\n        event.stopPropagation();\n        break;\n      case 'ArrowDown':\n        if (params.multiSelect && event.shiftKey && !params.disableSelection) {\n          selectNextNode(event, state.focusedNodeId);\n        }\n        instance.focusNode(event, getNextNode(instance, state.focusedNodeId));\n        flag = true;\n        break;\n      case 'ArrowUp':\n        if (params.multiSelect && event.shiftKey && !params.disableSelection) {\n          selectPreviousNode(event, state.focusedNodeId);\n        }\n        instance.focusNode(event, getPreviousNode(instance, state.focusedNodeId));\n        flag = true;\n        break;\n      case 'ArrowRight':\n        if (isRtl) {\n          flag = handlePreviousArrow(event);\n        } else {\n          flag = handleNextArrow(event);\n        }\n        break;\n      case 'ArrowLeft':\n        if (isRtl) {\n          flag = handleNextArrow(event);\n        } else {\n          flag = handlePreviousArrow(event);\n        }\n        break;\n      case 'Home':\n        if (params.multiSelect && ctrlPressed && event.shiftKey && !params.disableSelection && !instance.isNodeDisabled(state.focusedNodeId)) {\n          instance.rangeSelectToFirst(event, state.focusedNodeId);\n        }\n        instance.focusNode(event, getFirstNode(instance));\n        flag = true;\n        break;\n      case 'End':\n        if (params.multiSelect && ctrlPressed && event.shiftKey && !params.disableSelection && !instance.isNodeDisabled(state.focusedNodeId)) {\n          instance.rangeSelectToLast(event, state.focusedNodeId);\n        }\n        instance.focusNode(event, getLastNode(instance));\n        flag = true;\n        break;\n      default:\n        if (key === '*') {\n          instance.expandAllSiblings(event, state.focusedNodeId);\n          flag = true;\n        } else if (params.multiSelect && ctrlPressed && key.toLowerCase() === 'a' && !params.disableSelection) {\n          instance.selectRange(event, {\n            start: getFirstNode(instance),\n            end: getLastNode(instance)\n          });\n          flag = true;\n        } else if (!ctrlPressed && !event.shiftKey && isPrintableCharacter(key)) {\n          focusByFirstCharacter(event, state.focusedNodeId, key);\n          flag = true;\n        }\n    }\n    if (flag) {\n      event.preventDefault();\n      event.stopPropagation();\n    }\n  };\n  return {\n    getRootProps: otherHandlers => ({\n      onKeyDown: createHandleKeyDown(otherHandlers)\n    })\n  };\n};","import useId from '@mui/utils/useId';\nexport const useTreeViewContextValueBuilder = ({\n  instance,\n  params\n}) => {\n  const treeId = useId(params.id);\n  return {\n    getRootProps: () => ({\n      id: treeId\n    }),\n    contextValue: {\n      treeId,\n      instance: instance,\n      multiSelect: params.multiSelect,\n      disabledItemsFocusable: params.disabledItemsFocusable,\n      icons: {\n        defaultCollapseIcon: params.defaultCollapseIcon,\n        defaultEndIcon: params.defaultEndIcon,\n        defaultExpandIcon: params.defaultExpandIcon,\n        defaultParentIcon: params.defaultParentIcon\n      }\n    }\n  };\n};","import { useTreeViewNodes } from './useTreeViewNodes';\nimport { useTreeViewExpansion } from './useTreeViewExpansion';\nimport { useTreeViewSelection } from './useTreeViewSelection';\nimport { useTreeViewFocus } from './useTreeViewFocus';\nimport { useTreeViewKeyboardNavigation } from './useTreeViewKeyboardNavigation';\nimport { useTreeViewContextValueBuilder } from './useTreeViewContextValueBuilder';\nexport const DEFAULT_TREE_VIEW_PLUGINS = [useTreeViewNodes, useTreeViewExpansion, useTreeViewSelection, useTreeViewFocus, useTreeViewKeyboardNavigation, useTreeViewContextValueBuilder];\n\n// We can't infer this type from the plugin, otherwise we would lose the generics.","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport useEventCallback from '@mui/utils/useEventCallback';\nimport { populateInstance } from '../../useTreeView/useTreeView.utils';\nimport { publishTreeViewEvent } from '../../utils/publishTreeViewEvent';\nexport const useTreeViewNodes = ({\n  instance,\n  params\n}) => {\n  const nodeMap = React.useRef({});\n  const getNode = React.useCallback(nodeId => nodeMap.current[nodeId], []);\n  const insertNode = React.useCallback(node => {\n    nodeMap.current[node.id] = node;\n  }, []);\n  const removeNode = React.useCallback(nodeId => {\n    const newMap = _extends({}, nodeMap.current);\n    delete newMap[nodeId];\n    nodeMap.current = newMap;\n    publishTreeViewEvent(instance, 'removeNode', {\n      id: nodeId\n    });\n  }, [instance]);\n  const isNodeDisabled = React.useCallback(nodeId => {\n    if (nodeId == null) {\n      return false;\n    }\n    let node = instance.getNode(nodeId);\n\n    // This can be called before the node has been added to the node map.\n    if (!node) {\n      return false;\n    }\n    if (node.disabled) {\n      return true;\n    }\n    while (node.parentId != null) {\n      node = instance.getNode(node.parentId);\n      if (node.disabled) {\n        return true;\n      }\n    }\n    return false;\n  }, [instance]);\n  const getChildrenIds = useEventCallback(nodeId => Object.values(nodeMap.current).filter(node => node.parentId === nodeId).sort((a, b) => a.index - b.index).map(child => child.id));\n  const getNavigableChildrenIds = nodeId => {\n    let childrenIds = instance.getChildrenIds(nodeId);\n    if (!params.disabledItemsFocusable) {\n      childrenIds = childrenIds.filter(node => !instance.isNodeDisabled(node));\n    }\n    return childrenIds;\n  };\n  populateInstance(instance, {\n    getNode,\n    updateNode: insertNode,\n    removeNode,\n    getChildrenIds,\n    getNavigableChildrenIds,\n    isNodeDisabled\n  });\n};","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nconst _excluded = [\"disabledItemsFocusable\", \"expanded\", \"defaultExpanded\", \"onNodeToggle\", \"onNodeFocus\", \"disableSelection\", \"defaultSelected\", \"selected\", \"multiSelect\", \"onNodeSelect\", \"id\", \"defaultCollapseIcon\", \"defaultEndIcon\", \"defaultExpandIcon\", \"defaultParentIcon\", \"children\"];\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport { styled, useThemeProps } from '@mui/material/styles';\nimport composeClasses from '@mui/utils/composeClasses';\nimport { useSlotProps } from '@mui/base/utils';\nimport { getTreeViewUtilityClass } from './treeViewClasses';\nimport { useTreeView } from '../internals/useTreeView';\nimport { TreeViewProvider } from '../internals/TreeViewProvider';\nimport { DEFAULT_TREE_VIEW_PLUGINS } from '../internals/plugins';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst useUtilityClasses = ownerState => {\n  const {\n    classes\n  } = ownerState;\n  const slots = {\n    root: ['root']\n  };\n  return composeClasses(slots, getTreeViewUtilityClass, classes);\n};\nconst TreeViewRoot = styled('ul', {\n  name: 'MuiTreeView',\n  slot: 'Root',\n  overridesResolver: (props, styles) => styles.root\n})({\n  padding: 0,\n  margin: 0,\n  listStyle: 'none',\n  outline: 0\n});\n/**\n *\n * Demos:\n *\n * - [Tree View](https://mui.com/x/react-tree-view/)\n *\n * API:\n *\n * - [TreeView API](https://mui.com/x/api/tree-view/tree-view/)\n */\nconst TreeView = /*#__PURE__*/React.forwardRef(function TreeView(inProps, ref) {\n  const themeProps = useThemeProps({\n    props: inProps,\n    name: 'MuiTreeView'\n  });\n  const ownerState = themeProps;\n  const _ref = themeProps,\n    {\n      // Headless implementation\n      disabledItemsFocusable,\n      expanded,\n      defaultExpanded,\n      onNodeToggle,\n      onNodeFocus,\n      disableSelection,\n      defaultSelected,\n      selected,\n      multiSelect,\n      onNodeSelect,\n      id,\n      defaultCollapseIcon,\n      defaultEndIcon,\n      defaultExpandIcon,\n      defaultParentIcon,\n      // Component implementation\n      children\n    } = _ref,\n    other = _objectWithoutPropertiesLoose(_ref, _excluded);\n  const {\n    getRootProps,\n    contextValue\n  } = useTreeView({\n    disabledItemsFocusable,\n    expanded,\n    defaultExpanded,\n    onNodeToggle,\n    onNodeFocus,\n    disableSelection,\n    defaultSelected,\n    selected,\n    multiSelect,\n    onNodeSelect,\n    id,\n    defaultCollapseIcon,\n    defaultEndIcon,\n    defaultExpandIcon,\n    defaultParentIcon,\n    plugins: DEFAULT_TREE_VIEW_PLUGINS,\n    rootRef: ref\n  });\n  const classes = useUtilityClasses(themeProps);\n  const rootProps = useSlotProps({\n    elementType: TreeViewRoot,\n    externalSlotProps: {},\n    externalForwardedProps: other,\n    className: classes.root,\n    getSlotProps: getRootProps,\n    ownerState\n  });\n  return /*#__PURE__*/_jsx(TreeViewProvider, {\n    value: contextValue,\n    children: /*#__PURE__*/_jsx(TreeViewRoot, _extends({}, rootProps, {\n      children: children\n    }))\n  });\n});\nprocess.env.NODE_ENV !== \"production\" ? TreeView.propTypes = {\n  // ----------------------------- Warning --------------------------------\n  // | These PropTypes are generated from the TypeScript type definitions |\n  // | To update them edit the TypeScript types and run \"yarn proptypes\"  |\n  // ----------------------------------------------------------------------\n  /**\n   * The content of the component.\n   */\n  children: PropTypes.node,\n  /**\n   * Override or extend the styles applied to the component.\n   */\n  classes: PropTypes.object,\n  /**\n   * className applied to the root element.\n   */\n  className: PropTypes.string,\n  /**\n   * The default icon used to collapse the node.\n   */\n  defaultCollapseIcon: PropTypes.node,\n  /**\n   * The default icon displayed next to a end node. This is applied to all\n   * tree nodes and can be overridden by the TreeItem `icon` prop.\n   */\n  defaultEndIcon: PropTypes.node,\n  /**\n   * Expanded node ids.\n   * Used when the item's expansion is not controlled.\n   * @default []\n   */\n  defaultExpanded: PropTypes.arrayOf(PropTypes.string),\n  /**\n   * The default icon used to expand the node.\n   */\n  defaultExpandIcon: PropTypes.node,\n  /**\n   * The default icon displayed next to a parent node. This is applied to all\n   * parent nodes and can be overridden by the TreeItem `icon` prop.\n   */\n  defaultParentIcon: PropTypes.node,\n  /**\n   * Selected node ids. (Uncontrolled)\n   * When `multiSelect` is true this takes an array of strings; when false (default) a string.\n   * @default []\n   */\n  defaultSelected: PropTypes /* @typescript-to-proptypes-ignore */.oneOfType([PropTypes.arrayOf(PropTypes.string), PropTypes.string]),\n  /**\n   * If `true`, will allow focus on disabled items.\n   * @default false\n   */\n  disabledItemsFocusable: PropTypes.bool,\n  /**\n   * If `true` selection is disabled.\n   * @default false\n   */\n  disableSelection: PropTypes.bool,\n  /**\n   * Expanded node ids.\n   * Used when the item's expansion is controlled.\n   */\n  expanded: PropTypes.arrayOf(PropTypes.string),\n  /**\n   * This prop is used to help implement the accessibility logic.\n   * If you don't provide this prop. It falls back to a randomly generated id.\n   */\n  id: PropTypes.string,\n  /**\n   * If true `ctrl` and `shift` will trigger multiselect.\n   * @default false\n   */\n  multiSelect: PropTypes.bool,\n  /**\n   * Callback fired when tree items are focused.\n   * @param {React.SyntheticEvent} event The event source of the callback **Warning**: This is a generic event not a focus event.\n   * @param {string} nodeId The id of the node focused.\n   * @param {string} value of the focused node.\n   */\n  onNodeFocus: PropTypes.func,\n  /**\n   * Callback fired when tree items are selected/unselected.\n   * @param {React.SyntheticEvent} event The event source of the callback\n   * @param {string[] | string} nodeIds Ids of the selected nodes. When `multiSelect` is true\n   * this is an array of strings; when false (default) a string.\n   */\n  onNodeSelect: PropTypes.func,\n  /**\n   * Callback fired when tree items are expanded/collapsed.\n   * @param {React.SyntheticEvent} event The event source of the callback.\n   * @param {array} nodeIds The ids of the expanded nodes.\n   */\n  onNodeToggle: PropTypes.func,\n  /**\n   * Selected node ids. (Controlled)\n   * When `multiSelect` is true this takes an array of strings; when false (default) a string.\n   */\n  selected: PropTypes.any,\n  /**\n   * The system prop that allows defining system overrides as well as additional CSS styles.\n   */\n  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object])\n} : void 0;\nexport { TreeView };","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nconst _excluded = [\"element\"];\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport useEnhancedEffect from '@mui/utils/useEnhancedEffect';\n\n/** Credit: https://github.com/reach/reach-ui/blob/86a046f54d53b6420e392b3fa56dd991d9d4e458/packages/descendants/README.md\n *  Modified slightly to suit our purposes.\n */\n\n// To replace with .findIndex() once we stop IE11 support.\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nfunction findIndex(array, comp) {\n  for (let i = 0; i < array.length; i += 1) {\n    if (comp(array[i])) {\n      return i;\n    }\n  }\n  return -1;\n}\nfunction binaryFindElement(array, element) {\n  let start = 0;\n  let end = array.length - 1;\n  while (start <= end) {\n    const middle = Math.floor((start + end) / 2);\n    if (array[middle].element === element) {\n      return middle;\n    }\n\n    // eslint-disable-next-line no-bitwise\n    if (array[middle].element.compareDocumentPosition(element) & Node.DOCUMENT_POSITION_PRECEDING) {\n      end = middle - 1;\n    } else {\n      start = middle + 1;\n    }\n  }\n  return start;\n}\nconst DescendantContext = /*#__PURE__*/React.createContext({});\nif (process.env.NODE_ENV !== 'production') {\n  DescendantContext.displayName = 'DescendantContext';\n}\nfunction usePrevious(value) {\n  const ref = React.useRef(null);\n  React.useEffect(() => {\n    ref.current = value;\n  }, [value]);\n  return ref.current;\n}\nconst noop = () => {};\n\n/**\n * This hook registers our descendant by passing it into an array. We can then\n * search that array by to find its index when registering it in the component.\n * We use this for focus management, keyboard navigation, and typeahead\n * functionality for some components.\n *\n * The hook accepts the element node\n *\n * Our main goals with this are:\n *   1) maximum composability,\n *   2) minimal API friction\n *   3) SSR compatibility*\n *   4) concurrent safe\n *   5) index always up-to-date with the tree despite changes\n *   6) works with memoization of any component in the tree (hopefully)\n *\n * * As for SSR, the good news is that we don't actually need the index on the\n * server for most use-cases, as we are only using it to determine the order of\n * composed descendants for keyboard navigation.\n */\nexport function useDescendant(descendant) {\n  const [, forceUpdate] = React.useState();\n  const {\n    registerDescendant = noop,\n    unregisterDescendant = noop,\n    descendants = [],\n    parentId = null\n  } = React.useContext(DescendantContext);\n\n  // This will initially return -1 because we haven't registered the descendant\n  // on the first render. After we register, this will then return the correct\n  // index on the following render, and we will re-register descendants\n  // so that everything is up-to-date before the user interacts with a\n  // collection.\n  const index = findIndex(descendants, item => item.element === descendant.element);\n  const previousDescendants = usePrevious(descendants);\n\n  // We also need to re-register descendants any time ANY of the other\n  // descendants have changed. My brain was melting when I wrote this and it\n  // feels a little off, but checking in render and using the result in the\n  // effect's dependency array works well enough.\n  const someDescendantsHaveChanged = descendants.some((newDescendant, position) => {\n    return previousDescendants && previousDescendants[position] && previousDescendants[position].element !== newDescendant.element;\n  });\n\n  // Prevent any flashing\n  useEnhancedEffect(() => {\n    if (descendant.element) {\n      registerDescendant(_extends({}, descendant, {\n        index\n      }));\n      return () => {\n        unregisterDescendant(descendant.element);\n      };\n    }\n    forceUpdate({});\n    return undefined;\n  }, [registerDescendant, unregisterDescendant, index, someDescendantsHaveChanged, descendant]);\n  return {\n    parentId,\n    index\n  };\n}\nexport function DescendantProvider(props) {\n  const {\n    children,\n    id\n  } = props;\n  const [items, set] = React.useState([]);\n  const registerDescendant = React.useCallback(_ref => {\n    let {\n        element\n      } = _ref,\n      other = _objectWithoutPropertiesLoose(_ref, _excluded);\n    set(oldItems => {\n      if (oldItems.length === 0) {\n        // If there are no items, register at index 0 and bail.\n        return [_extends({}, other, {\n          element,\n          index: 0\n        })];\n      }\n      const index = binaryFindElement(oldItems, element);\n      let newItems;\n      if (oldItems[index] && oldItems[index].element === element) {\n        // If the element is already registered, just use the same array\n        newItems = oldItems;\n      } else {\n        // When registering a descendant, we need to make sure we insert in\n        // into the array in the same order that it appears in the DOM. So as\n        // new descendants are added or maybe some are removed, we always know\n        // that the array is up-to-date and correct.\n        //\n        // So here we look at our registered descendants and see if the new\n        // element we are adding appears earlier than an existing descendant's\n        // DOM node via `node.compareDocumentPosition`. If it does, we insert\n        // the new element at this index. Because `registerDescendant` will be\n        // called in an effect every time the descendants state value changes,\n        // we should be sure that this index is accurate when descendent\n        // elements come or go from our component.\n\n        const newItem = _extends({}, other, {\n          element,\n          index\n        });\n\n        // If an index is not found we will push the element to the end.\n        newItems = oldItems.slice();\n        newItems.splice(index, 0, newItem);\n      }\n      newItems.forEach((item, position) => {\n        item.index = position;\n      });\n      return newItems;\n    });\n  }, []);\n  const unregisterDescendant = React.useCallback(element => {\n    set(oldItems => oldItems.filter(item => element !== item.element));\n  }, []);\n  const value = React.useMemo(() => ({\n    descendants: items,\n    registerDescendant,\n    unregisterDescendant,\n    parentId: id\n  }), [items, registerDescendant, unregisterDescendant, id]);\n  return /*#__PURE__*/_jsx(DescendantContext.Provider, {\n    value: value,\n    children: children\n  });\n}\nprocess.env.NODE_ENV !== \"production\" ? DescendantProvider.propTypes = {\n  children: PropTypes.node,\n  id: PropTypes.string\n} : void 0;","import * as React from 'react';\nexport const DEFAULT_TREE_VIEW_CONTEXT_VALUE = {\n  instance: null,\n  multiSelect: false,\n  disabledItemsFocusable: false,\n  treeId: undefined,\n  icons: {\n    defaultCollapseIcon: null,\n    defaultExpandIcon: null,\n    defaultParentIcon: null,\n    defaultEndIcon: null\n  }\n};\n\n/**\n * @ignore - internal component.\n */\nexport const TreeViewContext = /*#__PURE__*/React.createContext(DEFAULT_TREE_VIEW_CONTEXT_VALUE);\nif (process.env.NODE_ENV !== 'production') {\n  TreeViewContext.displayName = 'TreeViewContext';\n}"],"names":["d","useTreeViewContext","TreeViewContext","_excluded","TreeItemContent","props","ref","classes","className","displayIcon","expansionIcon","icon","iconProp","label","nodeId","onClick","onMouseDown","other","disabled","expanded","selected","focused","handleExpansion","handleSelection","preventSelection","instance","multiSelect","expandable","isNodeExpandable","isNodeExpanded","isNodeFocused","isNodeSelected","isNodeDisabled","event","focusNode","multiple","shiftKey","ctrlKey","metaKey","toggleNodeExpansion","selectRange","end","selectNode","preventDefault","useTreeItem","clsx","root","children","iconContainer","getTreeItemUtilityClass","slot","generateUtilityClass","treeItemClasses","useUtilityClasses","ownerState","slots","getUtilityClass","output","Object","keys","forEach","reduce","acc","key","utilityClass","push","join","composeClasses","content","group","TreeItemRoot","styled","name","overridesResolver","styles","listStyle","margin","padding","outline","StyledTreeItemContent","theme","width","boxSizing","display","alignItems","cursor","WebkitTapHighlightColor","backgroundColor","vars","palette","action","hover","opacity","disabledOpacity","focus","primary","mainChannel","selectedOpacity","main","hoverOpacity","focusOpacity","marginRight","flexShrink","justifyContent","fontSize","paddingLeft","minWidth","position","typography","body1","TreeItemGroup","Collapse","marginLeft","TreeItem","inProps","useThemeProps","collapseIcon","ContentComponent","ContentProps","endIcon","expandIcon","disabledProp","id","idProp","TransitionComponent","TransitionProps","icons","contextIcons","disabledItemsFocusable","treeId","treeItemElement","setTreeItemElement","contentRef","handleRef","useForkRef","descendant","element","index","parentId","Boolean","Array","isArray","length","ariaSelected","defaultCollapseIcon","defaultExpandIcon","defaultParentIcon","defaultEndIcon","updateNode","idAttribute","removeNode","_contentRef$current$t","_contentRef$current","mapFirstChar","current","textContent","substring","toLowerCase","role","undefined","tabIndex","onFocus","target","currentTarget","rootElement","getRootNode","ownerDocument","getElementById","preventScroll","unfocusable","as","DescendantProvider","unmountOnExit","in","component","omitEventHandlers","object","result","filter","prop","match","mergeSlotProps","parameters","getSlotProps","additionalProps","externalSlotProps","externalForwardedProps","joinedClasses","mergedStyle","style","internalRef","eventHandlers","excludeKeys","includes","extractEventHandlers","componentsPropsWithoutEventHandlers","otherPropsWithoutEventHandlers","internalSlotProps","useSlotProps","elementType","skipResolvingSlotProps","rest","resolvedComponentsProps","componentProps","slotState","resolveComponentProps","mergedProps","otherProps","appendOwnerState","refs","every","value","setRef","getTreeViewUtilityClass","EventManager","constructor","this","maxListeners","warnOnce","events","on","eventName","listener","options","collection","highPriority","Map","regular","isFirst","set","removeListener","delete","removeAllListeners","emit","args","highPriorityListeners","from","regularListeners","i","has","apply","once","that","oneTimeListener","getPreviousNode","node","getNode","siblings","getNavigableChildrenIds","nodeIndex","indexOf","currentNode","pop","getNextNode","nextSibling","getLastNode","lastNode","getFirstNode","populateInstance","methods","assign","TREE_VIEW_CORE_PLUGINS","eventManager","publishEvent","params","defaultMuiPrevented","isPropagationStopped","isSyntheticEvent","subscribeEvent","handler","$$publishEvent","$$subscribeEvent","useTreeView","inParams","plugins","plugin","getDefaultizedParams","models","modelsRef","modelsState","setModelsState","initialState","entries","modelName","model","controlledProp","defaultProp","isControlled","fromEntries","map","setValue","newValue","prevState","useTreeViewModels","innerRootRef","handleRootRef","rootRef","state","setState","temp","getInitialState","rootPropsGetters","contextValue","pluginResponse","getRootProps","otherHandlers","rootProps","rootPropsGetter","TreeViewProvider","Provider","useTreeViewExpansion","_instance$getNode","useEventCallback","newExpanded","concat","onNodeToggle","expandAllSiblings","diff","getChildrenIds","child","DEFAULT_EXPANDED","_params$defaultExpand","defaultExpanded","useTreeViewSelection","lastSelectedNode","lastSelectionWasRange","currentRangeSelection","handleRangeSelect","nodes","base","slice","start","range","nodeAId","nodeBId","first","last","nodeA","nodeB","aFamily","bFamily","aAncestor","bAncestor","aAncestorIsCommon","bAncestorIsCommon","continueA","continueB","commonAncestor","ancestorFamily","aSide","bSide","findOrderInTremauxTree","getNodesInRange","newSelected","onNodeSelect","disableSelection","stacked","next","handleRangeArrowSelect","rangeSelectToLast","rangeSelectToFirst","DEFAULT_SELECTED","_params$disableSelect","_params$multiSelect","_params$defaultSelect","defaultSelected","TimerBasedCleanupTracking","timeout","timeouts","cleanupTimeout","register","unsubscribe","unregisterToken","setTimeout","cleanupToken","unregister","get","clearTimeout","reset","FinalizationRegistryBasedCleanupTracking","registry","FinalizationRegistry","ObjectToBeRetainedByReact","registryContainer","useInstanceEventHandler","cleanupTokensCounter","objectRetainedByReact","subscription","handlerRef","cleanupTokenRef","enhancedHandler","_handlerRef$current","call","_subscription$current","_handlerRef$current2","_subscription$current2","createUseInstanceEventHandler","useTreeViewFocus","setFocusedNodeId","cleanNodeId","focusedNodeId","onNodeFocus","oldFocusedNodeId","activeElement","createHandleFocus","_otherHandlers$onFocu","isNodeVisible","nodeToFocusId","find","createHandleBlur","_otherHandlers$onBlur","onBlur","focusedNode","activeDescendant","_params$disabledItems","findNextFirstChar","firstChars","startIndex","char","DEFAULT_TREE_VIEW_PLUGINS","nodeMap","insertNode","newMap","publishTreeViewEvent","values","sort","a","b","childrenIds","isRtl","useTheme","direction","firstCharMap","firstChar","handleNextArrow","handlePreviousArrow","parent","createHandleKeyDown","_otherHandlers$onKeyD","onKeyDown","flag","altKey","ctrlPressed","stopPropagation","selectNextNode","selectPreviousNode","string","lowercaseChar","firstCharIds","mapNodeId","visible","shouldBeSkipped","focusByFirstCharacter","useId","TreeViewRoot","TreeView","themeProps","_ref","DescendantContext","noop","useDescendant","forceUpdate","registerDescendant","unregisterDescendant","descendants","array","comp","findIndex","item","previousDescendants","usePrevious","someDescendantsHaveChanged","some","newDescendant","items","oldItems","middle","Math","floor","compareDocumentPosition","Node","DOCUMENT_POSITION_PRECEDING","binaryFindElement","newItems","newItem","splice","DEFAULT_TREE_VIEW_CONTEXT_VALUE"],"sourceRoot":""}