@radui/ui 0.0.1 → 0.0.2

package/dist/index.es.js

@@ -1,3228 +0,0 @@
-
-/**
-         * rollup-plugin-banner2
-         */
-
-'use client';
-import * as React$1 from 'react';
-import React__default, {useState, useLayoutEffect, useEffect, useRef} from 'react';
-import * as ReactDOM from 'react-dom';
-
-function _extends$1() {
-    _extends$1 = Object.assign ? Object.assign.bind() : function(target) {
-        for (let i = 1; i < arguments.length; i++) {
-            const source = arguments[i];
-            for (const key in source) {
-                if (Object.prototype.hasOwnProperty.call(source, key)) {
-                    target[key] = source[key];
-                }
-            }
-        }
-        return target;
-    };
-    return _extends$1.apply(this, arguments);
-}
-
-// make the color prop default accent color
-const Button = (_ref) => {
-    const {
-        children,
-        type = 'button',
-        color = undefined,
-        className = '',
-        variant = 'solid',
-        ...props
-    } = _ref;
-    // apply data attribute for accent color
-    // apply attribute only if color is present
-    if (color) {
-        props['data-accent-color'] = color;
-    }
-    return /* #__PURE__*/React__default.createElement('button', _extends$1({
-        type: 'button',
-        className: `rad-ui-button button-${variant} ${className}`,
-    }, props), children);
-};
-
-const RAD_UI_CLASS_PREFIX = 'rad-ui';
-const customClassSwitcher = function(customRootClass) {
-    const componentName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
-    // applies a custom root class the user provides, else applies the default rad-ui classes to the component
-    // rad ui's classes are based on this logic
-
-    // add dashes between capitalized words
-    const componentClassName = componentName.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
-    if (customRootClass) return customRootClass;
-    if (componentName) return `${RAD_UI_CLASS_PREFIX}-${componentClassName}`;
-    return '';
-};
-
-const COMPONENT_NAME$c = 'TabTrigger';
-const TabTrigger = (_ref) => {
-    const {
-        tab,
-        setActiveTab,
-        activeTab,
-        className = '',
-        customRootClass,
-        ...props
-    } = _ref;
-    const rootClass = customClassSwitcher(customRootClass, COMPONENT_NAME$c);
-    const isActive = activeTab === tab.value;
-    const handleClick = (tab) => {
-        setActiveTab(tab.value);
-    };
-    return /* #__PURE__*/React__default.createElement('button', _extends$1({
-        role: 'tab',
-        className: `${rootClass} ${isActive ? 'active' : ''} ${className}`,
-    }, props, {
-        onClick: () => handleClick(tab),
-    }), /* #__PURE__*/React__default.createElement('span', {
-        className: `${rootClass}-inner`,
-    }, tab.label));
-};
-TabTrigger.displayName = 'TabTrigger';
-
-const COMPONENT_NAME$b = 'TabList';
-const TabList = (_ref) => {
-    const {
-        tabs = [],
-        className = '',
-        setActiveTab,
-        activeTab,
-        customRootClass = '',
-    } = _ref;
-    const rootClass = customClassSwitcher(customRootClass, COMPONENT_NAME$b);
-    return /* #__PURE__*/React__default.createElement('div', {
-        'role': 'tablist',
-        'aria-orientation': 'horizontal',
-        'aria-label': 'todo',
-        'className': `${rootClass} ${className}`,
-    }, tabs.map((tab, index) => {
-        return /* #__PURE__*/React__default.createElement(TabTrigger, {
-            activeTab: activeTab,
-            setActiveTab: setActiveTab,
-            key: index,
-            tab: tab,
-            index: index,
-        });
-    }));
-};
-TabList.displayName = COMPONENT_NAME$b;
-
-const COMPONENT_NAME$a = 'TabContent';
-const TabContent = (_ref) => {
-    const {
-        tabs = [],
-        activeTab,
-        className = '',
-        customRootClass = '',
-    } = _ref;
-    const rootClass = customClassSwitcher(customRootClass, COMPONENT_NAME$a);
-    return /* #__PURE__*/React__default.createElement('div', {
-        className: `${rootClass} ${className}`,
-    }, tabs.map((tab, index) => {
-        if (tab.value === activeTab) {
-            return /* #__PURE__*/React__default.createElement('div', {
-                key: index,
-            }, tab.content);
-        }
-        return null;
-    }));
-};
-TabContent.displayName = COMPONENT_NAME$a;
-
-const COMPONENT_NAME$9 = 'TabRoot';
-const TabRoot = (_ref) => {
-    const {
-        children,
-        customRootClass = '',
-        className = '',
-        color = undefined,
-        ...props
-    } = _ref;
-    const rootClass = customClassSwitcher(customRootClass, COMPONENT_NAME$9);
-    if (color) {
-        props['data-accent-color'] = color;
-    }
-    return /* #__PURE__*/React__default.createElement('div', _extends$1({
-        className: `${rootClass} ${className}`,
-    }, props), children);
-};
-TabRoot.displayName = COMPONENT_NAME$9;
-
-const Tabs = (_ref) => {
-    const {
-        tabs = [],
-        ...props
-    } = _ref;
-    // This should be a value <`tabs.value`> that is passed in from the parent component
-    const [activeTab, setActiveTab] = useState(tabs[0].value || '');
-    return /* #__PURE__*/React__default.createElement(TabRoot, props, /* #__PURE__*/React__default.createElement(TabList, {
-        activeTab: activeTab,
-        setActiveTab: setActiveTab,
-        tabs: tabs,
-    }), /* #__PURE__*/React__default.createElement(TabContent, {
-        activeTab: activeTab,
-        tabs: tabs,
-    }));
-};
-Tabs.List = TabList;
-Tabs.Content = TabContent;
-Tabs.Root = TabRoot;
-
-const COMPONENT_NAME$8 = 'Separator';
-const Separator = (_ref) => {
-    const {
-        orientation = 'horizontal',
-        className = '',
-        customRootClass = '',
-    } = _ref;
-    const rootClass = customClassSwitcher(customRootClass, COMPONENT_NAME$8);
-    const orientationClass = orientation === 'vertical' ? `${rootClass}-vertical` : `${rootClass}-horizontal`;
-    return /* #__PURE__*/React__default.createElement('div', {
-        className: `${rootClass} ${orientationClass} ${className}`,
-    });
-};
-Separator.displayName = COMPONENT_NAME$8;
-
-const COMPONENT_NAME$7 = 'Badge';
-const Badge = (_ref) => {
-    const {
-        children,
-        customRootClass = '',
-        className = '',
-        color = undefined,
-        ...props
-    } = _ref;
-    const rootClass = customClassSwitcher(customRootClass, COMPONENT_NAME$7);
-    if (color) {
-        props['data-accent-color'] = color;
-    }
-    return /* #__PURE__*/React__default.createElement('span', _extends$1({
-        className: `${rootClass} ${className}`,
-    }, props), children);
-};
-Badge.displayName = COMPONENT_NAME$7;
-
-const COMPONENT_NAME$6 = 'Em';
-const Em = (_ref) => {
-    const {
-        children,
-        customRootClass = '',
-        className = '',
-        ...props
-    } = _ref;
-    const rootClass = customClassSwitcher(customRootClass, COMPONENT_NAME$6);
-    return /* #__PURE__*/React__default.createElement('em', _extends$1({
-        className: `${rootClass} ${className}`,
-    }, props), children);
-};
-Em.displayName = COMPONENT_NAME$6;
-
-const RENDER_AS_ENUMS = [{
-    label: 'H1',
-    tag: 'h1',
-}, {
-    label: 'H2',
-    tag: 'h2',
-}, {
-    label: 'H3',
-    tag: 'h3',
-}, {
-    label: 'H4',
-    tag: 'h4',
-}, {
-    label: 'H5',
-    tag: 'h5',
-}, {
-    label: 'H6',
-    tag: 'h6',
-}];
-const Heading = function(_ref) {
-    const {
-        children,
-        as = undefined,
-        customRootClass = '',
-        className = '',
-    } = _ref;
-    const rootClass = customClassSwitcher(customRootClass, as || 'h1');
-    for (var _len = arguments.length, props = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-        props[_key - 1] = arguments[_key];
-    }
-    if (as !== undefined && RENDER_AS_ENUMS.find((item) => item.tag === as)) {
-        const {
-            tag: Tag,
-        } = RENDER_AS_ENUMS.find((item) => item.tag === as);
-        return /* #__PURE__*/React__default.createElement(Tag, _extends$1({
-            className: `${rootClass} ${className}`,
-        }, props), children);
-    }
-    return /* #__PURE__*/React__default.createElement('h1', _extends$1({
-        className: `${rootClass} ${className}`,
-    }, props), children);
-};
-Heading.displayName = 'Heading';
-
-// Can be rendered as p, label, div, span, etc.
-// TODO: Add as prop support
-// TODO: Add a core reusable function to check and render an as prop
-
-const COMPONENT_NAME$5 = 'Text';
-const Text = (_ref) => {
-    const {
-        children,
-        customRootClass = '',
-        className = '',
-        ...props
-    } = _ref;
-    const rootClass = customClassSwitcher(customRootClass, COMPONENT_NAME$5);
-    return /* #__PURE__*/React__default.createElement('p', _extends$1({
-        className: `${rootClass} ${className}`,
-    }, props), children);
-};
-Text.displayName = COMPONENT_NAME$5;
-
-const COMPONENT_NAME$4 = 'BlockQuote';
-const BlockQuote = (_ref) => {
-    const {
-        children,
-        customRootClass = '',
-        className = '',
-        ...props
-    } = _ref;
-    const rootClass = customClassSwitcher(customRootClass, COMPONENT_NAME$4);
-    return /* #__PURE__*/React__default.createElement('blockquote', _extends$1({
-        className: `${rootClass} ${className}`,
-    }, props), children);
-};
-BlockQuote.displayName = COMPONENT_NAME$4;
-
-const COMPONENT_NAME$3 = 'Link';
-const Link = (_ref) => {
-    const {
-        children,
-        href = '#',
-        alt = '',
-        customRootClass = '',
-        className = '',
-        ...props
-    } = _ref;
-    const rootClass = customClassSwitcher(customRootClass, COMPONENT_NAME$3);
-    return /* #__PURE__*/React__default.createElement('a', _extends$1({
-        href: href,
-        alt: alt,
-        className: `${rootClass} ${className}`,
-    }, props), children);
-};
-Link.displayName = COMPONENT_NAME$3;
-
-const COMPONENT_NAME$2 = 'Quote';
-const Quote = (_ref) => {
-    const {
-        children,
-        customRootClass = '',
-        className = '',
-        ...props
-    } = _ref;
-    const rootClass = customClassSwitcher(customRootClass, COMPONENT_NAME$2);
-    return /* #__PURE__*/React__default.createElement('q', _extends$1({
-        className: `${rootClass} ${className}`,
-    }, props), children);
-};
-Quote.displayName = COMPONENT_NAME$2;
-
-const Code = (_ref) => {
-    const {
-        children,
-    } = _ref;
-    return /* #__PURE__*/React__default.createElement('code', {
-        className: 'rui-code-root',
-    }, children);
-};
-
-const TextRenderer = (_ref) => {
-    const {
-        fallback,
-        ...rest
-    } = _ref;
-    return /* #__PURE__*/React__default.createElement('div', _extends$1({
-        className: 'rad-ui-avatar rad-ui-avatar-fallback',
-    }, rest), fallback);
-};
-const Avatar = (_ref2) => {
-    const {
-        src,
-        alt,
-        ...rest
-    } = _ref2;
-    if (!src) {
-        return /* #__PURE__*/React__default.createElement(TextRenderer, rest);
-    }
-    return /* #__PURE__*/React__default.createElement(React__default.Fragment, null, /* #__PURE__*/React__default.createElement('img', _extends$1({
-        src: src,
-        alt: alt,
-        className: 'rad-ui-avatar',
-    }, rest)));
-};
-
-const COMPONENT_NAME$1 = 'Callout';
-const InfoIcon = () => {
-    return /* #__PURE__*/React.createElement('svg', {
-        width: '18',
-        height: '18',
-        viewBox: '0 0 15 15',
-        fill: 'none',
-        xmlns: 'http://www.w3.org/2000/svg',
-    }, /* #__PURE__*/React.createElement('path', {
-        'd': 'M7.49991 0.876892C3.84222 0.876892 0.877075 3.84204 0.877075 7.49972C0.877075 11.1574 3.84222 14.1226 7.49991 14.1226C11.1576 14.1226 14.1227 11.1574 14.1227 7.49972C14.1227 3.84204 11.1576 0.876892 7.49991 0.876892ZM1.82707 7.49972C1.82707 4.36671 4.36689 1.82689 7.49991 1.82689C10.6329 1.82689 13.1727 4.36671 13.1727 7.49972C13.1727 10.6327 10.6329 13.1726 7.49991 13.1726C4.36689 13.1726 1.82707 10.6327 1.82707 7.49972ZM8.24992 4.49999C8.24992 4.9142 7.91413 5.24999 7.49992 5.24999C7.08571 5.24999 6.74992 4.9142 6.74992 4.49999C6.74992 4.08577 7.08571 3.74999 7.49992 3.74999C7.91413 3.74999 8.24992 4.08577 8.24992 4.49999ZM6.00003 5.99999H6.50003H7.50003C7.77618 5.99999 8.00003 6.22384 8.00003 6.49999V9.99999H8.50003H9.00003V11H8.50003H7.50003H6.50003H6.00003V9.99999H6.50003H7.00003V6.99999H6.50003H6.00003V5.99999Z',
-        'fill': 'currentColor',
-        'fill-rule': 'evenodd',
-        'clip-rule': 'evenodd',
-    }));
-};
-const Callout = (_ref) => {
-    const {
-        children,
-        className = '',
-        color = undefined,
-        customRootClass = '',
-        ...restOfTheProps
-    } = _ref;
-    const rootClass = customClassSwitcher(customRootClass, COMPONENT_NAME$1);
-    if (color) {
-        restOfTheProps['data-accent-color'] = color;
-    }
-
-    // TODO:  if children is a string then wrap it in a Text component, else return the children as is - need to add this to core logic helpers
-
-    return /* #__PURE__*/React.createElement('div', _extends$1({
-        className: `${rootClass} ${className}`,
-    }, restOfTheProps), /* #__PURE__*/React.createElement(InfoIcon, null), '    ', children);
-};
-Callout.displayName = COMPONENT_NAME$1;
-
-function getNodeName(node) {
-    if (isNode(node)) {
-        return (node.nodeName || '').toLowerCase();
-    }
-    // Mocked nodes in testing environments may not be instances of Node. By
-    // returning `#document` an infinite loop won't occur.
-    // https://github.com/floating-ui/floating-ui/issues/2317
-    return '#document';
-}
-function getWindow(node) {
-    let _node$ownerDocument;
-    return (node == null ? void 0 : (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
-}
-function getDocumentElement(node) {
-    let _ref;
-    return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
-}
-function isNode(value) {
-    return value instanceof Node || value instanceof getWindow(value).Node;
-}
-function isElement(value) {
-    return value instanceof Element || value instanceof getWindow(value).Element;
-}
-function isHTMLElement(value) {
-    return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
-}
-function isShadowRoot(value) {
-    // Browsers without `ShadowRoot` support.
-    if (typeof ShadowRoot === 'undefined') {
-        return false;
-    }
-    return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
-}
-function isOverflowElement(element) {
-    const {
-        overflow,
-        overflowX,
-        overflowY,
-        display,
-    } = getComputedStyle(element);
-    return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);
-}
-function isTableElement(element) {
-    return ['table', 'td', 'th'].includes(getNodeName(element));
-}
-function isContainingBlock(element) {
-    const webkit = isWebKit();
-    const css = getComputedStyle(element);
-
-    // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
-    return css.transform !== 'none' || css.perspective !== 'none' || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'perspective', 'filter'].some((value) => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some((value) => (css.contain || '').includes(value));
-}
-function getContainingBlock(element) {
-    let currentNode = getParentNode(element);
-    while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
-        if (isContainingBlock(currentNode)) {
-            return currentNode;
-        } else {
-            currentNode = getParentNode(currentNode);
-        }
-    }
-    return null;
-}
-function isWebKit() {
-    if (typeof CSS === 'undefined' || !CSS.supports) return false;
-    return CSS.supports('-webkit-backdrop-filter', 'none');
-}
-function isLastTraversableNode(node) {
-    return ['html', 'body', '#document'].includes(getNodeName(node));
-}
-function getComputedStyle(element) {
-    return getWindow(element).getComputedStyle(element);
-}
-function getNodeScroll(element) {
-    if (isElement(element)) {
-        return {
-            scrollLeft: element.scrollLeft,
-            scrollTop: element.scrollTop,
-        };
-    }
-    return {
-        scrollLeft: element.pageXOffset,
-        scrollTop: element.pageYOffset,
-    };
-}
-function getParentNode(node) {
-    if (getNodeName(node) === 'html') {
-        return node;
-    }
-    const result =
-  // Step into the shadow DOM of the parent of a slotted node.
-  node.assignedSlot ||
-  // DOM Element detected.
-  node.parentNode ||
-  // ShadowRoot detected.
-  isShadowRoot(node) && node.host ||
-  // Fallback.
-  getDocumentElement(node);
-    return isShadowRoot(result) ? result.host : result;
-}
-function getNearestOverflowAncestor(node) {
-    const parentNode = getParentNode(node);
-    if (isLastTraversableNode(parentNode)) {
-        return node.ownerDocument ? node.ownerDocument.body : node.body;
-    }
-    if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
-        return parentNode;
-    }
-    return getNearestOverflowAncestor(parentNode);
-}
-function getOverflowAncestors(node, list, traverseIframes) {
-    let _node$ownerDocument2;
-    if (list === void 0) {
-        list = [];
-    }
-    if (traverseIframes === void 0) {
-        traverseIframes = true;
-    }
-    const scrollableAncestor = getNearestOverflowAncestor(node);
-    const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
-    const win = getWindow(scrollableAncestor);
-    if (isBody) {
-        return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], win.frameElement && traverseIframes ? getOverflowAncestors(win.frameElement) : []);
-    }
-    return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
-}
-
-function contains(parent, child) {
-    if (!parent || !child) {
-        return false;
-    }
-    const rootNode = child.getRootNode && child.getRootNode();
-
-    // First, attempt with faster native method
-    if (parent.contains(child)) {
-        return true;
-    }
-
-    // then fallback to custom implementation with Shadow DOM support
-    if (rootNode && isShadowRoot(rootNode)) {
-        let next = child;
-        while (next) {
-            if (parent === next) {
-                return true;
-            }
-            // @ts-ignore
-            next = next.parentNode || next.host;
-        }
-    }
-
-    // Give up, the result is false
-    return false;
-}
-function isMouseLikePointerType(pointerType, strict) {
-    // On some Linux machines with Chromium, mouse inputs return a `pointerType`
-    // of "pen": https://github.com/floating-ui/floating-ui/issues/2015
-    const values = ['mouse', 'pen'];
-    if (!strict) {
-        values.push('', undefined);
-    }
-    return values.includes(pointerType);
-}
-function isReactEvent(event) {
-    return 'nativeEvent' in event;
-}
-function isRootElement(element) {
-    return element.matches('html,body');
-}
-function getDocument(node) {
-    return (node == null ? void 0 : node.ownerDocument) || document;
-}
-function isEventTargetWithin(event, node) {
-    if (node == null) {
-        return false;
-    }
-    if ('composedPath' in event) {
-        return event.composedPath().includes(node);
-    }
-
-    // TS thinks `event` is of type never as it assumes all browsers support composedPath, but browsers without shadow dom don't
-    const e = event;
-    return e.target != null && node.contains(e.target);
-}
-function getTarget(event) {
-    if ('composedPath' in event) {
-        return event.composedPath()[0];
-    }
-
-    // TS thinks `event` is of type never as it assumes all browsers support
-    // `composedPath()`, but browsers without shadow DOM don't.
-    return event.target;
-}
-
-const min = Math.min;
-const max = Math.max;
-const round = Math.round;
-const floor = Math.floor;
-const createCoords = (v) => ({
-    x: v,
-    y: v,
-});
-const oppositeSideMap = {
-    left: 'right',
-    right: 'left',
-    bottom: 'top',
-    top: 'bottom',
-};
-const oppositeAlignmentMap = {
-    start: 'end',
-    end: 'start',
-};
-function clamp(start, value, end) {
-    return max(start, min(value, end));
-}
-function evaluate(value, param) {
-    return typeof value === 'function' ? value(param) : value;
-}
-function getSide(placement) {
-    return placement.split('-')[0];
-}
-function getAlignment(placement) {
-    return placement.split('-')[1];
-}
-function getOppositeAxis(axis) {
-    return axis === 'x' ? 'y' : 'x';
-}
-function getAxisLength(axis) {
-    return axis === 'y' ? 'height' : 'width';
-}
-function getSideAxis(placement) {
-    return ['top', 'bottom'].includes(getSide(placement)) ? 'y' : 'x';
-}
-function getAlignmentAxis(placement) {
-    return getOppositeAxis(getSideAxis(placement));
-}
-function getAlignmentSides(placement, rects, rtl) {
-    if (rtl === void 0) {
-        rtl = false;
-    }
-    const alignment = getAlignment(placement);
-    const alignmentAxis = getAlignmentAxis(placement);
-    const length = getAxisLength(alignmentAxis);
-    let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';
-    if (rects.reference[length] > rects.floating[length]) {
-        mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
-    }
-    return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
-}
-function getExpandedPlacements(placement) {
-    const oppositePlacement = getOppositePlacement(placement);
-    return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
-}
-function getOppositeAlignmentPlacement(placement) {
-    return placement.replace(/start|end/g, (alignment) => oppositeAlignmentMap[alignment]);
-}
-function getSideList(side, isStart, rtl) {
-    const lr = ['left', 'right'];
-    const rl = ['right', 'left'];
-    const tb = ['top', 'bottom'];
-    const bt = ['bottom', 'top'];
-    switch (side) {
-    case 'top':
-    case 'bottom':
-        if (rtl) return isStart ? rl : lr;
-        return isStart ? lr : rl;
-    case 'left':
-    case 'right':
-        return isStart ? tb : bt;
-    default:
-        return [];
-    }
-}
-function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
-    const alignment = getAlignment(placement);
-    let list = getSideList(getSide(placement), direction === 'start', rtl);
-    if (alignment) {
-        list = list.map((side) => side + '-' + alignment);
-        if (flipAlignment) {
-            list = list.concat(list.map(getOppositeAlignmentPlacement));
-        }
-    }
-    return list;
-}
-function getOppositePlacement(placement) {
-    return placement.replace(/left|right|bottom|top/g, (side) => oppositeSideMap[side]);
-}
-function expandPaddingObject(padding) {
-    return {
-        top: 0,
-        right: 0,
-        bottom: 0,
-        left: 0,
-        ...padding,
-    };
-}
-function getPaddingObject(padding) {
-    return typeof padding !== 'number' ? expandPaddingObject(padding) : {
-        top: padding,
-        right: padding,
-        bottom: padding,
-        left: padding,
-    };
-}
-function rectToClientRect(rect) {
-    return {
-        ...rect,
-        top: rect.y,
-        left: rect.x,
-        right: rect.x + rect.width,
-        bottom: rect.y + rect.height,
-    };
-}
-
-function computeCoordsFromPlacement(_ref, placement, rtl) {
-    const {
-        reference,
-        floating,
-    } = _ref;
-    const sideAxis = getSideAxis(placement);
-    const alignmentAxis = getAlignmentAxis(placement);
-    const alignLength = getAxisLength(alignmentAxis);
-    const side = getSide(placement);
-    const isVertical = sideAxis === 'y';
-    const commonX = reference.x + reference.width / 2 - floating.width / 2;
-    const commonY = reference.y + reference.height / 2 - floating.height / 2;
-    const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
-    let coords;
-    switch (side) {
-    case 'top':
-        coords = {
-            x: commonX,
-            y: reference.y - floating.height,
-        };
-        break;
-    case 'bottom':
-        coords = {
-            x: commonX,
-            y: reference.y + reference.height,
-        };
-        break;
-    case 'right':
-        coords = {
-            x: reference.x + reference.width,
-            y: commonY,
-        };
-        break;
-    case 'left':
-        coords = {
-            x: reference.x - floating.width,
-            y: commonY,
-        };
-        break;
-    default:
-        coords = {
-            x: reference.x,
-            y: reference.y,
-        };
-    }
-    switch (getAlignment(placement)) {
-    case 'start':
-        coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
-        break;
-    case 'end':
-        coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
-        break;
-    }
-    return coords;
-}
-
-/**
- * Computes the `x` and `y` coordinates that will place the floating element
- * next to a reference element when it is given a certain positioning strategy.
- *
- * This export does not have any `platform` interface logic. You will need to
- * write one for the platform you are using Floating UI with.
- */
-const computePosition$1 = async(reference, floating, config) => {
-    const {
-        placement = 'bottom',
-        strategy = 'absolute',
-        middleware = [],
-        platform,
-    } = config;
-    const validMiddleware = middleware.filter(Boolean);
-    const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));
-    let rects = await platform.getElementRects({
-        reference,
-        floating,
-        strategy,
-    });
-    let {
-        x,
-        y,
-    } = computeCoordsFromPlacement(rects, placement, rtl);
-    let statefulPlacement = placement;
-    let middlewareData = {};
-    let resetCount = 0;
-    for (let i = 0; i < validMiddleware.length; i++) {
-        const {
-            name,
-            fn,
-        } = validMiddleware[i];
-        const {
-            x: nextX,
-            y: nextY,
-            data,
-            reset,
-        } = await fn({
-            x,
-            y,
-            initialPlacement: placement,
-            placement: statefulPlacement,
-            strategy,
-            middlewareData,
-            rects,
-            platform,
-            elements: {
-                reference,
-                floating,
-            },
-        });
-        x = nextX != null ? nextX : x;
-        y = nextY != null ? nextY : y;
-        middlewareData = {
-            ...middlewareData,
-            [name]: {
-                ...middlewareData[name],
-                ...data,
-            },
-        };
-        if (reset && resetCount <= 50) {
-            resetCount++;
-            if (typeof reset === 'object') {
-                if (reset.placement) {
-                    statefulPlacement = reset.placement;
-                }
-                if (reset.rects) {
-                    rects = reset.rects === true ? await platform.getElementRects({
-                        reference,
-                        floating,
-                        strategy,
-                    }) : reset.rects;
-                }
-                ({
-                    x,
-                    y,
-                } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
-            }
-            i = -1;
-            continue;
-        }
-    }
-    return {
-        x,
-        y,
-        placement: statefulPlacement,
-        strategy,
-        middlewareData,
-    };
-};
-
-/**
- * Resolves with an object of overflow side offsets that determine how much the
- * element is overflowing a given clipping boundary on each side.
- * - positive = overflowing the boundary by that number of pixels
- * - negative = how many pixels left before it will overflow
- * - 0 = lies flush with the boundary
- * @see https://floating-ui.com/docs/detectOverflow
- */
-async function detectOverflow(state, options) {
-    let _await$platform$isEle;
-    if (options === void 0) {
-        options = {};
-    }
-    const {
-        x,
-        y,
-        platform,
-        rects,
-        elements,
-        strategy,
-    } = state;
-    const {
-        boundary = 'clippingAncestors',
-        rootBoundary = 'viewport',
-        elementContext = 'floating',
-        altBoundary = false,
-        padding = 0,
-    } = evaluate(options, state);
-    const paddingObject = getPaddingObject(padding);
-    const altContext = elementContext === 'floating' ? 'reference' : 'floating';
-    const element = elements[altBoundary ? altContext : elementContext];
-    const clippingClientRect = rectToClientRect(await platform.getClippingRect({
-        element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || (await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating))),
-        boundary,
-        rootBoundary,
-        strategy,
-    }));
-    const rect = elementContext === 'floating' ? {
-        ...rects.floating,
-        x,
-        y,
-    } : rects.reference;
-    const offsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating));
-    const offsetScale = (await (platform.isElement == null ? void 0 : platform.isElement(offsetParent))) ? (await (platform.getScale == null ? void 0 : platform.getScale(offsetParent))) || {
-        x: 1,
-        y: 1,
-    } : {
-        x: 1,
-        y: 1,
-    };
-    const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
-        rect,
-        offsetParent,
-        strategy,
-    }) : rect);
-    return {
-        top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
-        bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
-        left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
-        right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x,
-    };
-}
-
-/**
- * Provides data to position an inner element of the floating element so that it
- * appears centered to the reference element.
- * @see https://floating-ui.com/docs/arrow
- */
-const arrow$1 = (options) => ({
-    name: 'arrow',
-    options,
-    async fn(state) {
-        const {
-            x,
-            y,
-            placement,
-            rects,
-            platform,
-            elements,
-        } = state;
-        // Since `element` is required, we don't Partial<> the type.
-        const {
-            element,
-            padding = 0,
-        } = evaluate(options, state) || {};
-        if (element == null) {
-            return {};
-        }
-        const paddingObject = getPaddingObject(padding);
-        const coords = {
-            x,
-            y,
-        };
-        const axis = getAlignmentAxis(placement);
-        const length = getAxisLength(axis);
-        const arrowDimensions = await platform.getDimensions(element);
-        const isYAxis = axis === 'y';
-        const minProp = isYAxis ? 'top' : 'left';
-        const maxProp = isYAxis ? 'bottom' : 'right';
-        const clientProp = isYAxis ? 'clientHeight' : 'clientWidth';
-        const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
-        const startDiff = coords[axis] - rects.reference[axis];
-        const arrowOffsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(element));
-        let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;
-
-        // DOM platform can return `window` as the `offsetParent`.
-        if (!clientSize || !(await (platform.isElement == null ? void 0 : platform.isElement(arrowOffsetParent)))) {
-            clientSize = elements.floating[clientProp] || rects.floating[length];
-        }
-        const centerToReference = endDiff / 2 - startDiff / 2;
-
-        // If the padding is large enough that it causes the arrow to no longer be
-        // centered, modify the padding so that it is centered.
-        const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;
-        const minPadding = min(paddingObject[minProp], largestPossiblePadding);
-        const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);
-
-        // Make sure the arrow doesn't overflow the floating element if the center
-        // point is outside the floating element's bounds.
-        const min$1 = minPadding;
-        const max = clientSize - arrowDimensions[length] - maxPadding;
-        const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
-        const offset = clamp(min$1, center, max);
-
-        // If the reference is small enough that the arrow's padding causes it to
-        // to point to nothing for an aligned placement, adjust the offset of the
-        // floating element itself. This stops `shift()` from taking action, but can
-        // be worked around by calling it again after the `arrow()` if desired.
-        const shouldAddOffset = getAlignment(placement) != null && center != offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
-        const alignmentOffset = shouldAddOffset ? center < min$1 ? min$1 - center : max - center : 0;
-        return {
-            [axis]: coords[axis] - alignmentOffset,
-            data: {
-                [axis]: offset,
-                centerOffset: center - offset + alignmentOffset,
-            },
-        };
-    },
-});
-
-/**
- * Optimizes the visibility of the floating element by flipping the `placement`
- * in order to keep it in view when the preferred placement(s) will overflow the
- * clipping boundary. Alternative to `autoPlacement`.
- * @see https://floating-ui.com/docs/flip
- */
-const flip = function(options) {
-    if (options === void 0) {
-        options = {};
-    }
-    return {
-        name: 'flip',
-        options,
-        async fn(state) {
-            let _middlewareData$flip;
-            const {
-                placement,
-                middlewareData,
-                rects,
-                initialPlacement,
-                platform,
-                elements,
-            } = state;
-            const {
-                mainAxis: checkMainAxis = true,
-                crossAxis: checkCrossAxis = true,
-                fallbackPlacements: specifiedFallbackPlacements,
-                fallbackStrategy = 'bestFit',
-                fallbackAxisSideDirection = 'none',
-                flipAlignment = true,
-                ...detectOverflowOptions
-            } = evaluate(options, state);
-            const side = getSide(placement);
-            const isBasePlacement = getSide(initialPlacement) === initialPlacement;
-            const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
-            const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
-            if (!specifiedFallbackPlacements && fallbackAxisSideDirection !== 'none') {
-                fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
-            }
-            const placements = [initialPlacement, ...fallbackPlacements];
-            const overflow = await detectOverflow(state, detectOverflowOptions);
-            const overflows = [];
-            let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
-            if (checkMainAxis) {
-                overflows.push(overflow[side]);
-            }
-            if (checkCrossAxis) {
-                const sides = getAlignmentSides(placement, rects, rtl);
-                overflows.push(overflow[sides[0]], overflow[sides[1]]);
-            }
-            overflowsData = [...overflowsData, {
-                placement,
-                overflows,
-            }];
-
-            // One or more sides is overflowing.
-            if (!overflows.every((side) => side <= 0)) {
-                let _middlewareData$flip2; let _overflowsData$filter;
-                const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
-                const nextPlacement = placements[nextIndex];
-                if (nextPlacement) {
-                    // Try next placement and re-run the lifecycle.
-                    return {
-                        data: {
-                            index: nextIndex,
-                            overflows: overflowsData,
-                        },
-                        reset: {
-                            placement: nextPlacement,
-                        },
-                    };
-                }
-
-                // First, find the candidates that fit on the mainAxis side of overflow,
-                // then find the placement that fits the best on the main crossAxis side.
-                let resetPlacement = (_overflowsData$filter = overflowsData.filter((d) => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;
-
-                // Otherwise fallback.
-                if (!resetPlacement) {
-                    switch (fallbackStrategy) {
-                    case 'bestFit':
-                    {
-                        let _overflowsData$map$so;
-                        const placement = (_overflowsData$map$so = overflowsData.map((d) => [d.placement, d.overflows.filter((overflow) => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$map$so[0];
-                        if (placement) {
-                            resetPlacement = placement;
-                        }
-                        break;
-                    }
-                    case 'initialPlacement':
-                        resetPlacement = initialPlacement;
-                        break;
-                    }
-                }
-                if (placement !== resetPlacement) {
-                    return {
-                        reset: {
-                            placement: resetPlacement,
-                        },
-                    };
-                }
-            }
-            return {};
-        },
-    };
-};
-
-// For type backwards-compatibility, the `OffsetOptions` type was also
-// Derivable.
-async function convertValueToCoords(state, options) {
-    const {
-        placement,
-        platform,
-        elements,
-    } = state;
-    const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
-    const side = getSide(placement);
-    const alignment = getAlignment(placement);
-    const isVertical = getSideAxis(placement) === 'y';
-    const mainAxisMulti = ['left', 'top'].includes(side) ? -1 : 1;
-    const crossAxisMulti = rtl && isVertical ? -1 : 1;
-    const rawValue = evaluate(options, state);
-
-    // eslint-disable-next-line prefer-const
-    let {
-        mainAxis,
-        crossAxis,
-        alignmentAxis,
-    } = typeof rawValue === 'number' ? {
-        mainAxis: rawValue,
-        crossAxis: 0,
-        alignmentAxis: null,
-    } : {
-        mainAxis: 0,
-        crossAxis: 0,
-        alignmentAxis: null,
-        ...rawValue,
-    };
-    if (alignment && typeof alignmentAxis === 'number') {
-        crossAxis = alignment === 'end' ? alignmentAxis * -1 : alignmentAxis;
-    }
-    return isVertical ? {
-        x: crossAxis * crossAxisMulti,
-        y: mainAxis * mainAxisMulti,
-    } : {
-        x: mainAxis * mainAxisMulti,
-        y: crossAxis * crossAxisMulti,
-    };
-}
-
-/**
- * Modifies the placement by translating the floating element along the
- * specified axes.
- * A number (shorthand for `mainAxis` or distance), or an axes configuration
- * object may be passed.
- * @see https://floating-ui.com/docs/offset
- */
-const offset = function(options) {
-    if (options === void 0) {
-        options = 0;
-    }
-    return {
-        name: 'offset',
-        options,
-        async fn(state) {
-            const {
-                x,
-                y,
-            } = state;
-            const diffCoords = await convertValueToCoords(state, options);
-            return {
-                x: x + diffCoords.x,
-                y: y + diffCoords.y,
-                data: diffCoords,
-            };
-        },
-    };
-};
-
-/**
- * Optimizes the visibility of the floating element by shifting it in order to
- * keep it in view when it will overflow the clipping boundary.
- * @see https://floating-ui.com/docs/shift
- */
-const shift = function(options) {
-    if (options === void 0) {
-        options = {};
-    }
-    return {
-        name: 'shift',
-        options,
-        async fn(state) {
-            const {
-                x,
-                y,
-                placement,
-            } = state;
-            const {
-                mainAxis: checkMainAxis = true,
-                crossAxis: checkCrossAxis = false,
-                limiter = {
-                    fn: (_ref) => {
-                        const {
-                            x,
-                            y,
-                        } = _ref;
-                        return {
-                            x,
-                            y,
-                        };
-                    },
-                },
-                ...detectOverflowOptions
-            } = evaluate(options, state);
-            const coords = {
-                x,
-                y,
-            };
-            const overflow = await detectOverflow(state, detectOverflowOptions);
-            const crossAxis = getSideAxis(getSide(placement));
-            const mainAxis = getOppositeAxis(crossAxis);
-            let mainAxisCoord = coords[mainAxis];
-            let crossAxisCoord = coords[crossAxis];
-            if (checkMainAxis) {
-                const minSide = mainAxis === 'y' ? 'top' : 'left';
-                const maxSide = mainAxis === 'y' ? 'bottom' : 'right';
-                const min = mainAxisCoord + overflow[minSide];
-                const max = mainAxisCoord - overflow[maxSide];
-                mainAxisCoord = clamp(min, mainAxisCoord, max);
-            }
-            if (checkCrossAxis) {
-                const minSide = crossAxis === 'y' ? 'top' : 'left';
-                const maxSide = crossAxis === 'y' ? 'bottom' : 'right';
-                const min = crossAxisCoord + overflow[minSide];
-                const max = crossAxisCoord - overflow[maxSide];
-                crossAxisCoord = clamp(min, crossAxisCoord, max);
-            }
-            const limitedCoords = limiter.fn({
-                ...state,
-                [mainAxis]: mainAxisCoord,
-                [crossAxis]: crossAxisCoord,
-            });
-            return {
-                ...limitedCoords,
-                data: {
-                    x: limitedCoords.x - x,
-                    y: limitedCoords.y - y,
-                },
-            };
-        },
-    };
-};
-
-function getCssDimensions(element) {
-    const css = getComputedStyle(element);
-    // In testing environments, the `width` and `height` properties are empty
-    // strings for SVG elements, returning NaN. Fallback to `0` in this case.
-    let width = parseFloat(css.width) || 0;
-    let height = parseFloat(css.height) || 0;
-    const hasOffset = isHTMLElement(element);
-    const offsetWidth = hasOffset ? element.offsetWidth : width;
-    const offsetHeight = hasOffset ? element.offsetHeight : height;
-    const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
-    if (shouldFallback) {
-        width = offsetWidth;
-        height = offsetHeight;
-    }
-    return {
-        width,
-        height,
-        $: shouldFallback,
-    };
-}
-
-function unwrapElement(element) {
-    return !isElement(element) ? element.contextElement : element;
-}
-
-function getScale(element) {
-    const domElement = unwrapElement(element);
-    if (!isHTMLElement(domElement)) {
-        return createCoords(1);
-    }
-    const rect = domElement.getBoundingClientRect();
-    const {
-        width,
-        height,
-        $,
-    } = getCssDimensions(domElement);
-    let x = ($ ? round(rect.width) : rect.width) / width;
-    let y = ($ ? round(rect.height) : rect.height) / height;
-
-    // 0, NaN, or Infinity should always fallback to 1.
-
-    if (!x || !Number.isFinite(x)) {
-        x = 1;
-    }
-    if (!y || !Number.isFinite(y)) {
-        y = 1;
-    }
-    return {
-        x,
-        y,
-    };
-}
-
-const noOffsets = /* #__PURE__*/createCoords(0);
-function getVisualOffsets(element) {
-    const win = getWindow(element);
-    if (!isWebKit() || !win.visualViewport) {
-        return noOffsets;
-    }
-    return {
-        x: win.visualViewport.offsetLeft,
-        y: win.visualViewport.offsetTop,
-    };
-}
-function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
-    if (isFixed === void 0) {
-        isFixed = false;
-    }
-    if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {
-        return false;
-    }
-    return isFixed;
-}
-
-function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
-    if (includeScale === void 0) {
-        includeScale = false;
-    }
-    if (isFixedStrategy === void 0) {
-        isFixedStrategy = false;
-    }
-    const clientRect = element.getBoundingClientRect();
-    const domElement = unwrapElement(element);
-    let scale = createCoords(1);
-    if (includeScale) {
-        if (offsetParent) {
-            if (isElement(offsetParent)) {
-                scale = getScale(offsetParent);
-            }
-        } else {
-            scale = getScale(element);
-        }
-    }
-    const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
-    let x = (clientRect.left + visualOffsets.x) / scale.x;
-    let y = (clientRect.top + visualOffsets.y) / scale.y;
-    let width = clientRect.width / scale.x;
-    let height = clientRect.height / scale.y;
-    if (domElement) {
-        const win = getWindow(domElement);
-        const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
-        let currentIFrame = win.frameElement;
-        while (currentIFrame && offsetParent && offsetWin !== win) {
-            const iframeScale = getScale(currentIFrame);
-            const iframeRect = currentIFrame.getBoundingClientRect();
-            const css = getComputedStyle(currentIFrame);
-            const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
-            const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
-            x *= iframeScale.x;
-            y *= iframeScale.y;
-            width *= iframeScale.x;
-            height *= iframeScale.y;
-            x += left;
-            y += top;
-            currentIFrame = getWindow(currentIFrame).frameElement;
-        }
-    }
-    return rectToClientRect({
-        width,
-        height,
-        x,
-        y,
-    });
-}
-
-function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
-    const {
-        rect,
-        offsetParent,
-        strategy,
-    } = _ref;
-    const isOffsetParentAnElement = isHTMLElement(offsetParent);
-    const documentElement = getDocumentElement(offsetParent);
-    if (offsetParent === documentElement) {
-        return rect;
-    }
-    let scroll = {
-        scrollLeft: 0,
-        scrollTop: 0,
-    };
-    let scale = createCoords(1);
-    const offsets = createCoords(0);
-    if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== 'fixed') {
-        if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
-            scroll = getNodeScroll(offsetParent);
-        }
-        if (isHTMLElement(offsetParent)) {
-            const offsetRect = getBoundingClientRect(offsetParent);
-            scale = getScale(offsetParent);
-            offsets.x = offsetRect.x + offsetParent.clientLeft;
-            offsets.y = offsetRect.y + offsetParent.clientTop;
-        }
-    }
-    return {
-        width: rect.width * scale.x,
-        height: rect.height * scale.y,
-        x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x,
-        y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y,
-    };
-}
-
-function getClientRects(element) {
-    return Array.from(element.getClientRects());
-}
-
-function getWindowScrollBarX(element) {
-    // If <html> has a CSS width greater than the viewport, then this will be
-    // incorrect for RTL.
-    return getBoundingClientRect(getDocumentElement(element)).left + getNodeScroll(element).scrollLeft;
-}
-
-// Gets the entire size of the scrollable document area, even extending outside
-// of the `<html>` and `<body>` rect bounds if horizontally scrollable.
-function getDocumentRect(element) {
-    const html = getDocumentElement(element);
-    const scroll = getNodeScroll(element);
-    const body = element.ownerDocument.body;
-    const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
-    const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
-    let x = -scroll.scrollLeft + getWindowScrollBarX(element);
-    const y = -scroll.scrollTop;
-    if (getComputedStyle(body).direction === 'rtl') {
-        x += max(html.clientWidth, body.clientWidth) - width;
-    }
-    return {
-        width,
-        height,
-        x,
-        y,
-    };
-}
-
-function getViewportRect(element, strategy) {
-    const win = getWindow(element);
-    const html = getDocumentElement(element);
-    const visualViewport = win.visualViewport;
-    let width = html.clientWidth;
-    let height = html.clientHeight;
-    let x = 0;
-    let y = 0;
-    if (visualViewport) {
-        width = visualViewport.width;
-        height = visualViewport.height;
-        const visualViewportBased = isWebKit();
-        if (!visualViewportBased || visualViewportBased && strategy === 'fixed') {
-            x = visualViewport.offsetLeft;
-            y = visualViewport.offsetTop;
-        }
-    }
-    return {
-        width,
-        height,
-        x,
-        y,
-    };
-}
-
-// Returns the inner client rect, subtracting scrollbars if present.
-function getInnerBoundingClientRect(element, strategy) {
-    const clientRect = getBoundingClientRect(element, true, strategy === 'fixed');
-    const top = clientRect.top + element.clientTop;
-    const left = clientRect.left + element.clientLeft;
-    const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);
-    const width = element.clientWidth * scale.x;
-    const height = element.clientHeight * scale.y;
-    const x = left * scale.x;
-    const y = top * scale.y;
-    return {
-        width,
-        height,
-        x,
-        y,
-    };
-}
-function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
-    let rect;
-    if (clippingAncestor === 'viewport') {
-        rect = getViewportRect(element, strategy);
-    } else if (clippingAncestor === 'document') {
-        rect = getDocumentRect(getDocumentElement(element));
-    } else if (isElement(clippingAncestor)) {
-        rect = getInnerBoundingClientRect(clippingAncestor, strategy);
-    } else {
-        const visualOffsets = getVisualOffsets(element);
-        rect = {
-            ...clippingAncestor,
-            x: clippingAncestor.x - visualOffsets.x,
-            y: clippingAncestor.y - visualOffsets.y,
-        };
-    }
-    return rectToClientRect(rect);
-}
-function hasFixedPositionAncestor(element, stopNode) {
-    const parentNode = getParentNode(element);
-    if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {
-        return false;
-    }
-    return getComputedStyle(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);
-}
-
-// A "clipping ancestor" is an `overflow` element with the characteristic of
-// clipping (or hiding) child elements. This returns all clipping ancestors
-// of the given element up the tree.
-function getClippingElementAncestors(element, cache) {
-    const cachedResult = cache.get(element);
-    if (cachedResult) {
-        return cachedResult;
-    }
-    let result = getOverflowAncestors(element).filter((el) => isElement(el) && getNodeName(el) !== 'body');
-    let currentContainingBlockComputedStyle = null;
-    const elementIsFixed = getComputedStyle(element).position === 'fixed';
-    let currentNode = elementIsFixed ? getParentNode(element) : element;
-
-    // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
-    while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
-        const computedStyle = getComputedStyle(currentNode);
-        const currentNodeIsContaining = isContainingBlock(currentNode);
-        if (!currentNodeIsContaining && computedStyle.position === 'fixed') {
-            currentContainingBlockComputedStyle = null;
-        }
-        const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && ['absolute', 'fixed'].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
-        if (shouldDropCurrentNode) {
-            // Drop non-containing blocks.
-            result = result.filter((ancestor) => ancestor !== currentNode);
-        } else {
-            // Record last containing block for next iteration.
-            currentContainingBlockComputedStyle = computedStyle;
-        }
-        currentNode = getParentNode(currentNode);
-    }
-    cache.set(element, result);
-    return result;
-}
-
-// Gets the maximum area that the element is visible in due to any number of
-// clipping ancestors.
-function getClippingRect(_ref) {
-    const {
-        element,
-        boundary,
-        rootBoundary,
-        strategy,
-    } = _ref;
-    const elementClippingAncestors = boundary === 'clippingAncestors' ? getClippingElementAncestors(element, this._c) : [].concat(boundary);
-    const clippingAncestors = [...elementClippingAncestors, rootBoundary];
-    const firstClippingAncestor = clippingAncestors[0];
-    const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
-        const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
-        accRect.top = max(rect.top, accRect.top);
-        accRect.right = min(rect.right, accRect.right);
-        accRect.bottom = min(rect.bottom, accRect.bottom);
-        accRect.left = max(rect.left, accRect.left);
-        return accRect;
-    }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
-    return {
-        width: clippingRect.right - clippingRect.left,
-        height: clippingRect.bottom - clippingRect.top,
-        x: clippingRect.left,
-        y: clippingRect.top,
-    };
-}
-
-function getDimensions(element) {
-    return getCssDimensions(element);
-}
-
-function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
-    const isOffsetParentAnElement = isHTMLElement(offsetParent);
-    const documentElement = getDocumentElement(offsetParent);
-    const isFixed = strategy === 'fixed';
-    const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
-    let scroll = {
-        scrollLeft: 0,
-        scrollTop: 0,
-    };
-    const offsets = createCoords(0);
-    if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
-        if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
-            scroll = getNodeScroll(offsetParent);
-        }
-        if (isOffsetParentAnElement) {
-            const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
-            offsets.x = offsetRect.x + offsetParent.clientLeft;
-            offsets.y = offsetRect.y + offsetParent.clientTop;
-        } else if (documentElement) {
-            offsets.x = getWindowScrollBarX(documentElement);
-        }
-    }
-    return {
-        x: rect.left + scroll.scrollLeft - offsets.x,
-        y: rect.top + scroll.scrollTop - offsets.y,
-        width: rect.width,
-        height: rect.height,
-    };
-}
-
-function getTrueOffsetParent(element, polyfill) {
-    if (!isHTMLElement(element) || getComputedStyle(element).position === 'fixed') {
-        return null;
-    }
-    if (polyfill) {
-        return polyfill(element);
-    }
-    return element.offsetParent;
-}
-
-// Gets the closest ancestor positioned element. Handles some edge cases,
-// such as table ancestors and cross browser bugs.
-function getOffsetParent(element, polyfill) {
-    const window = getWindow(element);
-    if (!isHTMLElement(element)) {
-        return window;
-    }
-    let offsetParent = getTrueOffsetParent(element, polyfill);
-    while (offsetParent && isTableElement(offsetParent) && getComputedStyle(offsetParent).position === 'static') {
-        offsetParent = getTrueOffsetParent(offsetParent, polyfill);
-    }
-    if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle(offsetParent).position === 'static' && !isContainingBlock(offsetParent))) {
-        return window;
-    }
-    return offsetParent || getContainingBlock(element) || window;
-}
-
-const getElementRects = async function(_ref) {
-    const {
-        reference,
-        floating,
-        strategy,
-    } = _ref;
-    const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
-    const getDimensionsFn = this.getDimensions;
-    return {
-        reference: getRectRelativeToOffsetParent(reference, await getOffsetParentFn(floating), strategy),
-        floating: {
-            x: 0,
-            y: 0,
-            ...(await getDimensionsFn(floating)),
-        },
-    };
-};
-
-function isRTL(element) {
-    return getComputedStyle(element).direction === 'rtl';
-}
-
-const platform = {
-    convertOffsetParentRelativeRectToViewportRelativeRect,
-    getDocumentElement,
-    getClippingRect,
-    getOffsetParent,
-    getElementRects,
-    getClientRects,
-    getDimensions,
-    getScale,
-    isElement,
-    isRTL,
-};
-
-// https://samthor.au/2021/observing-dom/
-function observeMove(element, onMove) {
-    let io = null;
-    let timeoutId;
-    const root = getDocumentElement(element);
-    function cleanup() {
-        clearTimeout(timeoutId);
-        io && io.disconnect();
-        io = null;
-    }
-    function refresh(skip, threshold) {
-        if (skip === void 0) {
-            skip = false;
-        }
-        if (threshold === void 0) {
-            threshold = 1;
-        }
-        cleanup();
-        const {
-            left,
-            top,
-            width,
-            height,
-        } = element.getBoundingClientRect();
-        if (!skip) {
-            onMove();
-        }
-        if (!width || !height) {
-            return;
-        }
-        const insetTop = floor(top);
-        const insetRight = floor(root.clientWidth - (left + width));
-        const insetBottom = floor(root.clientHeight - (top + height));
-        const insetLeft = floor(left);
-        const rootMargin = -insetTop + 'px ' + -insetRight + 'px ' + -insetBottom + 'px ' + -insetLeft + 'px';
-        const options = {
-            rootMargin,
-            threshold: max(0, min(1, threshold)) || 1,
-        };
-        let isFirstUpdate = true;
-        function handleObserve(entries) {
-            const ratio = entries[0].intersectionRatio;
-            if (ratio !== threshold) {
-                if (!isFirstUpdate) {
-                    return refresh();
-                }
-                if (!ratio) {
-                    timeoutId = setTimeout(() => {
-                        refresh(false, 1e-7);
-                    }, 100);
-                } else {
-                    refresh(false, ratio);
-                }
-            }
-            isFirstUpdate = false;
-        }
-
-        // Older browsers don't support a `document` as the root and will throw an
-        // error.
-        try {
-            io = new IntersectionObserver(handleObserve, {
-                ...options,
-                // Handle <iframe>s
-                root: root.ownerDocument,
-            });
-        } catch (e) {
-            io = new IntersectionObserver(handleObserve, options);
-        }
-        io.observe(element);
-    }
-    refresh(true);
-    return cleanup;
-}
-
-/**
- * Automatically updates the position of the floating element when necessary.
- * Should only be called when the floating element is mounted on the DOM or
- * visible on the screen.
- * @return cleanup function that should be invoked when the floating element is
- * removed from the DOM or hidden from the screen.
- * @see https://floating-ui.com/docs/autoUpdate
- */
-function autoUpdate(reference, floating, update, options) {
-    if (options === void 0) {
-        options = {};
-    }
-    const {
-        ancestorScroll = true,
-        ancestorResize = true,
-        elementResize = typeof ResizeObserver === 'function',
-        layoutShift = typeof IntersectionObserver === 'function',
-        animationFrame = false,
-    } = options;
-    const referenceEl = unwrapElement(reference);
-    const ancestors = ancestorScroll || ancestorResize ? [...(referenceEl ? getOverflowAncestors(referenceEl) : []), ...getOverflowAncestors(floating)] : [];
-    ancestors.forEach((ancestor) => {
-        ancestorScroll && ancestor.addEventListener('scroll', update, {
-            passive: true,
-        });
-        ancestorResize && ancestor.addEventListener('resize', update);
-    });
-    const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;
-    let reobserveFrame = -1;
-    let resizeObserver = null;
-    if (elementResize) {
-        resizeObserver = new ResizeObserver((_ref) => {
-            const [firstEntry] = _ref;
-            if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {
-                // Prevent update loops when using the `size` middleware.
-                // https://github.com/floating-ui/floating-ui/issues/1740
-                resizeObserver.unobserve(floating);
-                cancelAnimationFrame(reobserveFrame);
-                reobserveFrame = requestAnimationFrame(() => {
-                    resizeObserver && resizeObserver.observe(floating);
-                });
-            }
-            update();
-        });
-        if (referenceEl && !animationFrame) {
-            resizeObserver.observe(referenceEl);
-        }
-        resizeObserver.observe(floating);
-    }
-    let frameId;
-    let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
-    if (animationFrame) {
-        frameLoop();
-    }
-    function frameLoop() {
-        const nextRefRect = getBoundingClientRect(reference);
-        if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) {
-            update();
-        }
-        prevRefRect = nextRefRect;
-        frameId = requestAnimationFrame(frameLoop);
-    }
-    update();
-    return () => {
-        ancestors.forEach((ancestor) => {
-            ancestorScroll && ancestor.removeEventListener('scroll', update);
-            ancestorResize && ancestor.removeEventListener('resize', update);
-        });
-        cleanupIo && cleanupIo();
-        resizeObserver && resizeObserver.disconnect();
-        resizeObserver = null;
-        if (animationFrame) {
-            cancelAnimationFrame(frameId);
-        }
-    };
-}
-
-/**
- * Computes the `x` and `y` coordinates that will place the floating element
- * next to a reference element when it is given a certain CSS positioning
- * strategy.
- */
-const computePosition = (reference, floating, options) => {
-    // This caches the expensive `getClippingElementAncestors` function so that
-    // multiple lifecycle resets re-use the same result. It only lives for a
-    // single call. If other functions become expensive, we can add them as well.
-    const cache = new Map();
-    const mergedOptions = {
-        platform,
-        ...options,
-    };
-    const platformWithCache = {
-        ...mergedOptions.platform,
-        _c: cache,
-    };
-    return computePosition$1(reference, floating, {
-        ...mergedOptions,
-        platform: platformWithCache,
-    });
-};
-
-/**
- * Provides data to position an inner element of the floating element so that it
- * appears centered to the reference element.
- * This wraps the core `arrow` middleware to allow React refs as the element.
- * @see https://floating-ui.com/docs/arrow
- */
-const arrow = (options) => {
-    function isRef(value) {
-        return {}.hasOwnProperty.call(value, 'current');
-    }
-    return {
-        name: 'arrow',
-        options,
-        fn(state) {
-            const {
-                element,
-                padding,
-            } = typeof options === 'function' ? options(state) : options;
-            if (element && isRef(element)) {
-                if (element.current != null) {
-                    return arrow$1({
-                        element: element.current,
-                        padding,
-                    }).fn(state);
-                }
-                return {};
-            } else if (element) {
-                return arrow$1({
-                    element,
-                    padding,
-                }).fn(state);
-            }
-            return {};
-        },
-    };
-};
-
-const index$1 = typeof document !== 'undefined' ? useLayoutEffect : useEffect;
-
-// Fork of `fast-deep-equal` that only does the comparisons we need and compares
-// functions
-function deepEqual(a, b) {
-    if (a === b) {
-        return true;
-    }
-    if (typeof a !== typeof b) {
-        return false;
-    }
-    if (typeof a === 'function' && a.toString() === b.toString()) {
-        return true;
-    }
-    let length; let i; let keys;
-    if (a && b && typeof a == 'object') {
-        if (Array.isArray(a)) {
-            length = a.length;
-            if (length != b.length) return false;
-            for (i = length; i-- !== 0;) {
-                if (!deepEqual(a[i], b[i])) {
-                    return false;
-                }
-            }
-            return true;
-        }
-        keys = Object.keys(a);
-        length = keys.length;
-        if (length !== Object.keys(b).length) {
-            return false;
-        }
-        for (i = length; i-- !== 0;) {
-            if (!{}.hasOwnProperty.call(b, keys[i])) {
-                return false;
-            }
-        }
-        for (i = length; i-- !== 0;) {
-            const key = keys[i];
-            if (key === '_owner' && a.$$typeof) {
-                continue;
-            }
-            if (!deepEqual(a[key], b[key])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    return a !== a && b !== b;
-}
-
-function getDPR(element) {
-    if (typeof window === 'undefined') {
-        return 1;
-    }
-    const win = element.ownerDocument.defaultView || window;
-    return win.devicePixelRatio || 1;
-}
-
-function roundByDPR(element, value) {
-    const dpr = getDPR(element);
-    return Math.round(value * dpr) / dpr;
-}
-
-function useLatestRef$1(value) {
-    const ref = React$1.useRef(value);
-    index$1(() => {
-        ref.current = value;
-    });
-    return ref;
-}
-
-/**
- * Provides data to position a floating element.
- * @see https://floating-ui.com/docs/useFloating
- */
-function useFloating$1(options) {
-    if (options === void 0) {
-        options = {};
-    }
-    const {
-        placement = 'bottom',
-        strategy = 'absolute',
-        middleware = [],
-        platform,
-        elements: {
-            reference: externalReference,
-            floating: externalFloating,
-        } = {},
-        transform = true,
-        whileElementsMounted,
-        open,
-    } = options;
-    const [data, setData] = React$1.useState({
-        x: 0,
-        y: 0,
-        strategy,
-        placement,
-        middlewareData: {},
-        isPositioned: false,
-    });
-    const [latestMiddleware, setLatestMiddleware] = React$1.useState(middleware);
-    if (!deepEqual(latestMiddleware, middleware)) {
-        setLatestMiddleware(middleware);
-    }
-    const [_reference, _setReference] = React$1.useState(null);
-    const [_floating, _setFloating] = React$1.useState(null);
-    const setReference = React$1.useCallback((node) => {
-        if (node != referenceRef.current) {
-            referenceRef.current = node;
-            _setReference(node);
-        }
-    }, [_setReference]);
-    const setFloating = React$1.useCallback((node) => {
-        if (node !== floatingRef.current) {
-            floatingRef.current = node;
-            _setFloating(node);
-        }
-    }, [_setFloating]);
-    const referenceEl = externalReference || _reference;
-    const floatingEl = externalFloating || _floating;
-    const referenceRef = React$1.useRef(null);
-    const floatingRef = React$1.useRef(null);
-    const dataRef = React$1.useRef(data);
-    const whileElementsMountedRef = useLatestRef$1(whileElementsMounted);
-    const platformRef = useLatestRef$1(platform);
-    const update = React$1.useCallback(() => {
-        if (!referenceRef.current || !floatingRef.current) {
-            return;
-        }
-        const config = {
-            placement,
-            strategy,
-            middleware: latestMiddleware,
-        };
-        if (platformRef.current) {
-            config.platform = platformRef.current;
-        }
-        computePosition(referenceRef.current, floatingRef.current, config).then((data) => {
-            const fullData = {
-                ...data,
-                isPositioned: true,
-            };
-            if (isMountedRef.current && !deepEqual(dataRef.current, fullData)) {
-                dataRef.current = fullData;
-                ReactDOM.flushSync(() => {
-                    setData(fullData);
-                });
-            }
-        });
-    }, [latestMiddleware, placement, strategy, platformRef]);
-    index$1(() => {
-        if (open === false && dataRef.current.isPositioned) {
-            dataRef.current.isPositioned = false;
-            setData((data) => ({
-                ...data,
-                isPositioned: false,
-            }));
-        }
-    }, [open]);
-    const isMountedRef = React$1.useRef(false);
-    index$1(() => {
-        isMountedRef.current = true;
-        return () => {
-            isMountedRef.current = false;
-        };
-    }, []);
-    index$1(() => {
-        if (referenceEl) referenceRef.current = referenceEl;
-        if (floatingEl) floatingRef.current = floatingEl;
-        if (referenceEl && floatingEl) {
-            if (whileElementsMountedRef.current) {
-                return whileElementsMountedRef.current(referenceEl, floatingEl, update);
-            } else {
-                update();
-            }
-        }
-    }, [referenceEl, floatingEl, update, whileElementsMountedRef]);
-    const refs = React$1.useMemo(() => ({
-        reference: referenceRef,
-        floating: floatingRef,
-        setReference,
-        setFloating,
-    }), [setReference, setFloating]);
-    const elements = React$1.useMemo(() => ({
-        reference: referenceEl,
-        floating: floatingEl,
-    }), [referenceEl, floatingEl]);
-    const floatingStyles = React$1.useMemo(() => {
-        const initialStyles = {
-            position: strategy,
-            left: 0,
-            top: 0,
-        };
-        if (!elements.floating) {
-            return initialStyles;
-        }
-        const x = roundByDPR(elements.floating, data.x);
-        const y = roundByDPR(elements.floating, data.y);
-        if (transform) {
-            return {
-                ...initialStyles,
-                transform: 'translate(' + x + 'px, ' + y + 'px)',
-                ...(getDPR(elements.floating) >= 1.5 && {
-                    willChange: 'transform',
-                }),
-            };
-        }
-        return {
-            position: strategy,
-            left: x,
-            top: y,
-        };
-    }, [strategy, transform, elements.floating, data.x, data.y]);
-    return React$1.useMemo(() => ({
-        ...data,
-        update,
-        refs,
-        elements,
-        floatingStyles,
-    }), [data, update, refs, elements, floatingStyles]);
-}
-
-// `toString()` prevents bundlers from trying to `import { useInsertionEffect } from 'react'`
-const useInsertionEffect = React$1[/* #__PURE__*/'useInsertionEffect'.toString()];
-const useSafeInsertionEffect = useInsertionEffect || ((fn) => fn());
-function useEffectEvent(callback) {
-    const ref = React$1.useRef(() => {
-        if (process.env.NODE_ENV !== 'production') {
-            throw new Error('Cannot call an event handler while rendering.');
-        }
-    });
-    useSafeInsertionEffect(() => {
-        ref.current = callback;
-    });
-    return React$1.useCallback(function() {
-        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-            args[_key] = arguments[_key];
-        }
-        return ref.current == null ? void 0 : ref.current(...args);
-    }, []);
-}
-
-const index = typeof document !== 'undefined' ? useLayoutEffect : useEffect;
-
-function _extends() {
-    _extends = Object.assign ? Object.assign.bind() : function(target) {
-        for (let i = 1; i < arguments.length; i++) {
-            const source = arguments[i];
-            for (const key in source) {
-                if (Object.prototype.hasOwnProperty.call(source, key)) {
-                    target[key] = source[key];
-                }
-            }
-        }
-        return target;
-    };
-    return _extends.apply(this, arguments);
-}
-
-let serverHandoffComplete = false;
-let count = 0;
-const genId = () => 'floating-ui-' + count++;
-function useFloatingId() {
-    const [id, setId] = React$1.useState(() => serverHandoffComplete ? genId() : undefined);
-    index(() => {
-        if (id == null) {
-            setId(genId());
-        }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, []);
-    React$1.useEffect(() => {
-        if (!serverHandoffComplete) {
-            serverHandoffComplete = true;
-        }
-    }, []);
-    return id;
-}
-
-// `toString()` prevents bundlers from trying to `import { useId } from 'react'`
-const useReactId = React$1[/* #__PURE__*/'useId'.toString()];
-
-/**
- * Uses React 18's built-in `useId()` when available, or falls back to a
- * slightly less performant (requiring a double render) implementation for
- * earlier React versions.
- * @see https://floating-ui.com/docs/useId
- */
-const useId = useReactId || useFloatingId;
-
-/**
- * Renders a pointing arrow triangle.
- * @see https://floating-ui.com/docs/FloatingArrow
- */
-const FloatingArrow = /* #__PURE__*/React$1.forwardRef(function FloatingArrow(_ref, ref) {
-    let {
-        context: {
-            placement,
-            elements: {
-                floating,
-            },
-            middlewareData: {
-                arrow,
-            },
-        },
-        width = 14,
-        height = 7,
-        tipRadius = 0,
-        strokeWidth = 0,
-        staticOffset,
-        stroke,
-        d,
-        style: {
-            transform,
-            ...restStyle
-        } = {},
-        ...rest
-    } = _ref;
-    if (process.env.NODE_ENV !== 'production') {
-        if (!ref) {
-            console.warn('Floating UI: The `ref` prop is required for the `FloatingArrow`', 'component.');
-        }
-    }
-    const clipPathId = useId();
-    if (!floating) {
-        return null;
-    }
-
-    // Strokes must be double the border width, this ensures the stroke's width
-    // works as you'd expect.
-    strokeWidth *= 2;
-    const halfStrokeWidth = strokeWidth / 2;
-    const svgX = width / 2 * (tipRadius / -8 + 1);
-    const svgY = height / 2 * tipRadius / 4;
-    const [side, alignment] = placement.split('-');
-    const isRTL = platform.isRTL(floating);
-    const isCustomShape = !!d;
-    const isVerticalSide = side === 'top' || side === 'bottom';
-    const yOffsetProp = staticOffset && alignment === 'end' ? 'bottom' : 'top';
-    let xOffsetProp = staticOffset && alignment === 'end' ? 'right' : 'left';
-    if (staticOffset && isRTL) {
-        xOffsetProp = alignment === 'end' ? 'left' : 'right';
-    }
-    const arrowX = (arrow == null ? void 0 : arrow.x) != null ? staticOffset || arrow.x : '';
-    const arrowY = (arrow == null ? void 0 : arrow.y) != null ? staticOffset || arrow.y : '';
-    const dValue = d || 'M0,0' + (' H' + width) + (' L' + (width - svgX) + ',' + (height - svgY)) + (' Q' + width / 2 + ',' + height + ' ' + svgX + ',' + (height - svgY)) + ' Z';
-    const rotation = {
-        top: isCustomShape ? 'rotate(180deg)' : '',
-        left: isCustomShape ? 'rotate(90deg)' : 'rotate(-90deg)',
-        bottom: isCustomShape ? '' : 'rotate(180deg)',
-        right: isCustomShape ? 'rotate(-90deg)' : 'rotate(90deg)',
-    }[side];
-    return /* #__PURE__*/React$1.createElement('svg', _extends({}, rest, {
-        'aria-hidden': true,
-        'ref': ref,
-        'width': isCustomShape ? width : width + strokeWidth,
-        'height': width,
-        'viewBox': '0 0 ' + width + ' ' + (height > width ? height : width),
-        'style': {
-            position: 'absolute',
-            pointerEvents: 'none',
-            [xOffsetProp]: arrowX,
-            [yOffsetProp]: arrowY,
-            [side]: isVerticalSide || isCustomShape ? '100%' : 'calc(100% - ' + strokeWidth / 2 + 'px)',
-            transform: '' + rotation + (transform != null ? transform : ''),
-            ...restStyle,
-        },
-    }), strokeWidth > 0 && /* #__PURE__*/React$1.createElement('path', {
-        clipPath: 'url(#' + clipPathId + ')',
-        fill: 'none',
-        stroke: stroke, // Account for the stroke on the fill path rendered below.
-
-        strokeWidth: strokeWidth + (d ? 0 : 1),
-        d: dValue,
-    }), /* #__PURE__*/React$1.createElement('path', {
-        stroke: strokeWidth && !d ? rest.fill : 'none',
-        d: dValue,
-    }), /* #__PURE__*/React$1.createElement('clipPath', {
-        id: clipPathId,
-    }, /* #__PURE__*/React$1.createElement('rect', {
-        x: -halfStrokeWidth,
-        y: halfStrokeWidth * (isCustomShape ? -1 : 1),
-        width: width + strokeWidth,
-        height: width,
-    })));
-});
-
-function createPubSub() {
-    const map = new Map();
-    return {
-        emit(event, data) {
-            let _map$get;
-            (_map$get = map.get(event)) == null ? void 0 : _map$get.forEach((handler) => handler(data));
-        },
-        on(event, listener) {
-            map.set(event, [...(map.get(event) || []), listener]);
-        },
-        off(event, listener) {
-            let _map$get2;
-            map.set(event, ((_map$get2 = map.get(event)) == null ? void 0 : _map$get2.filter((l) => l !== listener)) || []);
-        },
-    };
-}
-
-const FloatingNodeContext = /* #__PURE__*/React$1.createContext(null);
-const FloatingTreeContext = /* #__PURE__*/React$1.createContext(null);
-const useFloatingParentNodeId = () => {
-    let _React$useContext;
-    return ((_React$useContext = React$1.useContext(FloatingNodeContext)) == null ? void 0 : _React$useContext.id) || null;
-};
-const useFloatingTree = () => React$1.useContext(FloatingTreeContext);
-
-function createAttribute(name) {
-    return 'data-floating-ui-' + name;
-}
-
-function useLatestRef(value) {
-    const ref = useRef(value);
-    index(() => {
-        ref.current = value;
-    });
-    return ref;
-}
-
-const safePolygonIdentifier = /* #__PURE__*/createAttribute('safe-polygon');
-function getDelay(value, prop, pointerType) {
-    if (pointerType && !isMouseLikePointerType(pointerType)) {
-        return 0;
-    }
-    if (typeof value === 'number') {
-        return value;
-    }
-    return value == null ? void 0 : value[prop];
-}
-/**
- * Opens the floating element while hovering over the reference element, like
- * CSS `:hover`.
- * @see https://floating-ui.com/docs/useHover
- */
-function useHover(context, props) {
-    if (props === void 0) {
-        props = {};
-    }
-    const {
-        open,
-        onOpenChange,
-        dataRef,
-        events,
-        elements: {
-            domReference,
-            floating,
-        },
-        refs,
-    } = context;
-    const {
-        enabled = true,
-        delay = 0,
-        handleClose = null,
-        mouseOnly = false,
-        restMs = 0,
-        move = true,
-    } = props;
-    const tree = useFloatingTree();
-    const parentId = useFloatingParentNodeId();
-    const handleCloseRef = useLatestRef(handleClose);
-    const delayRef = useLatestRef(delay);
-    const pointerTypeRef = React$1.useRef();
-    const timeoutRef = React$1.useRef();
-    const handlerRef = React$1.useRef();
-    const restTimeoutRef = React$1.useRef();
-    const blockMouseMoveRef = React$1.useRef(true);
-    const performedPointerEventsMutationRef = React$1.useRef(false);
-    const unbindMouseMoveRef = React$1.useRef(() => {});
-    const isHoverOpen = React$1.useCallback(() => {
-        let _dataRef$current$open;
-        const type = (_dataRef$current$open = dataRef.current.openEvent) == null ? void 0 : _dataRef$current$open.type;
-        return (type == null ? void 0 : type.includes('mouse')) && type !== 'mousedown';
-    }, [dataRef]);
-
-    // When closing before opening, clear the delay timeouts to cancel it
-    // from showing.
-    React$1.useEffect(() => {
-        if (!enabled) {
-            return;
-        }
-        function onOpenChange(_ref) {
-            const {
-                open,
-            } = _ref;
-            if (!open) {
-                clearTimeout(timeoutRef.current);
-                clearTimeout(restTimeoutRef.current);
-                blockMouseMoveRef.current = true;
-            }
-        }
-        events.on('openchange', onOpenChange);
-        return () => {
-            events.off('openchange', onOpenChange);
-        };
-    }, [enabled, events]);
-    React$1.useEffect(() => {
-        if (!enabled || !handleCloseRef.current || !open) {
-            return;
-        }
-        function onLeave(event) {
-            if (isHoverOpen()) {
-                onOpenChange(false, event, 'hover');
-            }
-        }
-        const html = getDocument(floating).documentElement;
-        html.addEventListener('mouseleave', onLeave);
-        return () => {
-            html.removeEventListener('mouseleave', onLeave);
-        };
-    }, [floating, open, onOpenChange, enabled, handleCloseRef, dataRef, isHoverOpen]);
-    const closeWithDelay = React$1.useCallback(function(event, runElseBranch, reason) {
-        if (runElseBranch === void 0) {
-            runElseBranch = true;
-        }
-        if (reason === void 0) {
-            reason = 'hover';
-        }
-        const closeDelay = getDelay(delayRef.current, 'close', pointerTypeRef.current);
-        if (closeDelay && !handlerRef.current) {
-            clearTimeout(timeoutRef.current);
-            timeoutRef.current = setTimeout(() => onOpenChange(false, event, reason), closeDelay);
-        } else if (runElseBranch) {
-            clearTimeout(timeoutRef.current);
-            onOpenChange(false, event, reason);
-        }
-    }, [delayRef, onOpenChange]);
-    const cleanupMouseMoveHandler = React$1.useCallback(() => {
-        unbindMouseMoveRef.current();
-        handlerRef.current = undefined;
-    }, []);
-    const clearPointerEvents = React$1.useCallback(() => {
-        if (performedPointerEventsMutationRef.current) {
-            const body = getDocument(refs.floating.current).body;
-            body.style.pointerEvents = '';
-            body.removeAttribute(safePolygonIdentifier);
-            performedPointerEventsMutationRef.current = false;
-        }
-    }, [refs]);
-
-    // Registering the mouse events on the reference directly to bypass React's
-    // delegation system. If the cursor was on a disabled element and then entered
-    // the reference (no gap), `mouseenter` doesn't fire in the delegation system.
-    React$1.useEffect(() => {
-        if (!enabled) {
-            return;
-        }
-        function isClickLikeOpenEvent() {
-            return dataRef.current.openEvent ? ['click', 'mousedown'].includes(dataRef.current.openEvent.type) : false;
-        }
-        function onMouseEnter(event) {
-            clearTimeout(timeoutRef.current);
-            blockMouseMoveRef.current = false;
-            if (mouseOnly && !isMouseLikePointerType(pointerTypeRef.current) || restMs > 0 && getDelay(delayRef.current, 'open') === 0) {
-                return;
-            }
-            const openDelay = getDelay(delayRef.current, 'open', pointerTypeRef.current);
-            if (openDelay) {
-                timeoutRef.current = setTimeout(() => {
-                    onOpenChange(true, event, 'hover');
-                }, openDelay);
-            } else {
-                onOpenChange(true, event, 'hover');
-            }
-        }
-        function onMouseLeave(event) {
-            if (isClickLikeOpenEvent()) {
-                return;
-            }
-            unbindMouseMoveRef.current();
-            const doc = getDocument(floating);
-            clearTimeout(restTimeoutRef.current);
-            if (handleCloseRef.current) {
-                // Prevent clearing `onScrollMouseLeave` timeout.
-                if (!open) {
-                    clearTimeout(timeoutRef.current);
-                }
-                handlerRef.current = handleCloseRef.current({
-                    ...context,
-                    tree,
-                    x: event.clientX,
-                    y: event.clientY,
-                    onClose() {
-                        clearPointerEvents();
-                        cleanupMouseMoveHandler();
-                        closeWithDelay(event, true, 'safe-polygon');
-                    },
-                });
-                const handler = handlerRef.current;
-                doc.addEventListener('mousemove', handler);
-                unbindMouseMoveRef.current = () => {
-                    doc.removeEventListener('mousemove', handler);
-                };
-                return;
-            }
-
-            // Allow interactivity without `safePolygon` on touch devices. With a
-            // pointer, a short close delay is an alternative, so it should work
-            // consistently.
-            const shouldClose = pointerTypeRef.current === 'touch' ? !contains(floating, event.relatedTarget) : true;
-            if (shouldClose) {
-                closeWithDelay(event);
-            }
-        }
-
-        // Ensure the floating element closes after scrolling even if the pointer
-        // did not move.
-        // https://github.com/floating-ui/floating-ui/discussions/1692
-        function onScrollMouseLeave(event) {
-            if (isClickLikeOpenEvent()) {
-                return;
-            }
-            handleCloseRef.current == null ? void 0 : handleCloseRef.current({
-                ...context,
-                tree,
-                x: event.clientX,
-                y: event.clientY,
-                onClose() {
-                    clearPointerEvents();
-                    cleanupMouseMoveHandler();
-                    closeWithDelay(event);
-                },
-            })(event);
-        }
-        if (isElement(domReference)) {
-            const ref = domReference;
-            open && ref.addEventListener('mouseleave', onScrollMouseLeave);
-            floating == null ? void 0 : floating.addEventListener('mouseleave', onScrollMouseLeave);
-            move && ref.addEventListener('mousemove', onMouseEnter, {
-                once: true,
-            });
-            ref.addEventListener('mouseenter', onMouseEnter);
-            ref.addEventListener('mouseleave', onMouseLeave);
-            return () => {
-                open && ref.removeEventListener('mouseleave', onScrollMouseLeave);
-                floating == null ? void 0 : floating.removeEventListener('mouseleave', onScrollMouseLeave);
-                move && ref.removeEventListener('mousemove', onMouseEnter);
-                ref.removeEventListener('mouseenter', onMouseEnter);
-                ref.removeEventListener('mouseleave', onMouseLeave);
-            };
-        }
-    }, [domReference, floating, enabled, context, mouseOnly, restMs, move, closeWithDelay, cleanupMouseMoveHandler, clearPointerEvents, onOpenChange, open, tree, delayRef, handleCloseRef, dataRef]);
-
-    // Block pointer-events of every element other than the reference and floating
-    // while the floating element is open and has a `handleClose` handler. Also
-    // handles nested floating elements.
-    // https://github.com/floating-ui/floating-ui/issues/1722
-    index(() => {
-        let _handleCloseRef$curre;
-        if (!enabled) {
-            return;
-        }
-        if (open && (_handleCloseRef$curre = handleCloseRef.current) != null && _handleCloseRef$curre.__options.blockPointerEvents && isHoverOpen()) {
-            const body = getDocument(floating).body;
-            body.setAttribute(safePolygonIdentifier, '');
-            body.style.pointerEvents = 'none';
-            performedPointerEventsMutationRef.current = true;
-            if (isElement(domReference) && floating) {
-                let _tree$nodesRef$curren; let _tree$nodesRef$curren2;
-                const ref = domReference;
-                const parentFloating = tree == null ? void 0 : (_tree$nodesRef$curren = tree.nodesRef.current.find((node) => node.id === parentId)) == null ? void 0 : (_tree$nodesRef$curren2 = _tree$nodesRef$curren.context) == null ? void 0 : _tree$nodesRef$curren2.elements.floating;
-                if (parentFloating) {
-                    parentFloating.style.pointerEvents = '';
-                }
-                ref.style.pointerEvents = 'auto';
-                floating.style.pointerEvents = 'auto';
-                return () => {
-                    ref.style.pointerEvents = '';
-                    floating.style.pointerEvents = '';
-                };
-            }
-        }
-    }, [enabled, open, parentId, floating, domReference, tree, handleCloseRef, dataRef, isHoverOpen]);
-    index(() => {
-        if (!open) {
-            pointerTypeRef.current = undefined;
-            cleanupMouseMoveHandler();
-            clearPointerEvents();
-        }
-    }, [open, cleanupMouseMoveHandler, clearPointerEvents]);
-    React$1.useEffect(() => {
-        return () => {
-            cleanupMouseMoveHandler();
-            clearTimeout(timeoutRef.current);
-            clearTimeout(restTimeoutRef.current);
-            clearPointerEvents();
-        };
-    }, [enabled, domReference, cleanupMouseMoveHandler, clearPointerEvents]);
-    return React$1.useMemo(() => {
-        if (!enabled) {
-            return {};
-        }
-        function setPointerRef(event) {
-            pointerTypeRef.current = event.pointerType;
-        }
-        return {
-            reference: {
-                onPointerDown: setPointerRef,
-                onPointerEnter: setPointerRef,
-                onMouseMove(event) {
-                    if (open || restMs === 0) {
-                        return;
-                    }
-                    clearTimeout(restTimeoutRef.current);
-                    restTimeoutRef.current = setTimeout(() => {
-                        if (!blockMouseMoveRef.current) {
-                            onOpenChange(true, event.nativeEvent, 'hover');
-                        }
-                    }, restMs);
-                },
-            },
-            floating: {
-                onMouseEnter() {
-                    clearTimeout(timeoutRef.current);
-                },
-                onMouseLeave(event) {
-                    closeWithDelay(event.nativeEvent, false);
-                },
-            },
-        };
-    }, [enabled, restMs, open, onOpenChange, closeWithDelay]);
-}
-
-function getChildren(nodes, id) {
-    let allChildren = nodes.filter((node) => {
-        let _node$context;
-        return node.parentId === id && ((_node$context = node.context) == null ? void 0 : _node$context.open);
-    });
-    let currentChildren = allChildren;
-    while (currentChildren.length) {
-        currentChildren = nodes.filter((node) => {
-            let _currentChildren;
-            return (_currentChildren = currentChildren) == null ? void 0 : _currentChildren.some((n) => {
-                let _node$context2;
-                return node.parentId === n.id && ((_node$context2 = node.context) == null ? void 0 : _node$context2.open);
-            });
-        });
-        allChildren = allChildren.concat(currentChildren);
-    }
-    return allChildren;
-}
-
-const bubbleHandlerKeys = {
-    pointerdown: 'onPointerDown',
-    mousedown: 'onMouseDown',
-    click: 'onClick',
-};
-const captureHandlerKeys = {
-    pointerdown: 'onPointerDownCapture',
-    mousedown: 'onMouseDownCapture',
-    click: 'onClickCapture',
-};
-const normalizeProp = (normalizable) => {
-    let _normalizable$escapeK; let _normalizable$outside;
-    return {
-        escapeKey: typeof normalizable === 'boolean' ? normalizable : (_normalizable$escapeK = normalizable == null ? void 0 : normalizable.escapeKey) != null ? _normalizable$escapeK : false,
-        outsidePress: typeof normalizable === 'boolean' ? normalizable : (_normalizable$outside = normalizable == null ? void 0 : normalizable.outsidePress) != null ? _normalizable$outside : true,
-    };
-};
-/**
- * Closes the floating element when a dismissal is requested — by default, when
- * the user presses the `escape` key or outside of the floating element.
- * @see https://floating-ui.com/docs/useDismiss
- */
-function useDismiss(context, props) {
-    if (props === void 0) {
-        props = {};
-    }
-    const {
-        open,
-        onOpenChange,
-        nodeId,
-        elements: {
-            reference,
-            domReference,
-            floating,
-        },
-        dataRef,
-    } = context;
-    const {
-        enabled = true,
-        escapeKey = true,
-        outsidePress: unstable_outsidePress = true,
-        outsidePressEvent = 'pointerdown',
-        referencePress = false,
-        referencePressEvent = 'pointerdown',
-        ancestorScroll = false,
-        bubbles,
-        capture,
-    } = props;
-    const tree = useFloatingTree();
-    const outsidePressFn = useEffectEvent(typeof unstable_outsidePress === 'function' ? unstable_outsidePress : () => false);
-    const outsidePress = typeof unstable_outsidePress === 'function' ? outsidePressFn : unstable_outsidePress;
-    const insideReactTreeRef = React$1.useRef(false);
-    const endedOrStartedInsideRef = React$1.useRef(false);
-    const {
-        escapeKey: escapeKeyBubbles,
-        outsidePress: outsidePressBubbles,
-    } = normalizeProp(bubbles);
-    const {
-        escapeKey: escapeKeyCapture,
-        outsidePress: outsidePressCapture,
-    } = normalizeProp(capture);
-    const closeOnEscapeKeyDown = useEffectEvent((event) => {
-        if (!open || !enabled || !escapeKey || event.key !== 'Escape') {
-            return;
-        }
-        const children = tree ? getChildren(tree.nodesRef.current, nodeId) : [];
-        if (!escapeKeyBubbles) {
-            event.stopPropagation();
-            if (children.length > 0) {
-                let shouldDismiss = true;
-                children.forEach((child) => {
-                    let _child$context;
-                    if ((_child$context = child.context) != null && _child$context.open && !child.context.dataRef.current.__escapeKeyBubbles) {
-                        shouldDismiss = false;
-                        return;
-                    }
-                });
-                if (!shouldDismiss) {
-                    return;
-                }
-            }
-        }
-        onOpenChange(false, isReactEvent(event) ? event.nativeEvent : event, 'escape-key');
-    });
-    const closeOnEscapeKeyDownCapture = useEffectEvent((event) => {
-        let _getTarget2;
-        const callback = () => {
-            let _getTarget;
-            closeOnEscapeKeyDown(event);
-            (_getTarget = getTarget(event)) == null ? void 0 : _getTarget.removeEventListener('keydown', callback);
-        };
-        (_getTarget2 = getTarget(event)) == null ? void 0 : _getTarget2.addEventListener('keydown', callback);
-    });
-    const closeOnPressOutside = useEffectEvent((event) => {
-    // Given developers can stop the propagation of the synthetic event,
-    // we can only be confident with a positive value.
-        const insideReactTree = insideReactTreeRef.current;
-        insideReactTreeRef.current = false;
-
-        // When click outside is lazy (`click` event), handle dragging.
-        // Don't close if:
-        // - The click started inside the floating element.
-        // - The click ended inside the floating element.
-        const endedOrStartedInside = endedOrStartedInsideRef.current;
-        endedOrStartedInsideRef.current = false;
-        if (outsidePressEvent === 'click' && endedOrStartedInside) {
-            return;
-        }
-        if (insideReactTree) {
-            return;
-        }
-        if (typeof outsidePress === 'function' && !outsidePress(event)) {
-            return;
-        }
-        const target = getTarget(event);
-        const inertSelector = '[' + createAttribute('inert') + ']';
-        const markers = getDocument(floating).querySelectorAll(inertSelector);
-        let targetRootAncestor = isElement(target) ? target : null;
-        while (targetRootAncestor && !isLastTraversableNode(targetRootAncestor)) {
-            const nextParent = getParentNode(targetRootAncestor);
-            if (nextParent === getDocument(floating).body || !isElement(nextParent)) {
-                break;
-            } else {
-                targetRootAncestor = nextParent;
-            }
-        }
-
-        // Check if the click occurred on a third-party element injected after the
-        // floating element rendered.
-        if (markers.length && isElement(target) && !isRootElement(target) &&
-    // Clicked on a direct ancestor (e.g. FloatingOverlay).
-    !contains(target, floating) &&
-    // If the target root element contains none of the markers, then the
-    // element was injected after the floating element rendered.
-    Array.from(markers).every((marker) => !contains(targetRootAncestor, marker))) {
-            return;
-        }
-
-        // Check if the click occurred on the scrollbar
-        if (isHTMLElement(target) && floating) {
-            // In Firefox, `target.scrollWidth > target.clientWidth` for inline
-            // elements.
-            const canScrollX = target.clientWidth > 0 && target.scrollWidth > target.clientWidth;
-            const canScrollY = target.clientHeight > 0 && target.scrollHeight > target.clientHeight;
-            let xCond = canScrollY && event.offsetX > target.clientWidth;
-
-            // In some browsers it is possible to change the <body> (or window)
-            // scrollbar to the left side, but is very rare and is difficult to
-            // check for. Plus, for modal dialogs with backdrops, it is more
-            // important that the backdrop is checked but not so much the window.
-            if (canScrollY) {
-                const isRTL = getComputedStyle(target).direction === 'rtl';
-                if (isRTL) {
-                    xCond = event.offsetX <= target.offsetWidth - target.clientWidth;
-                }
-            }
-            if (xCond || canScrollX && event.offsetY > target.clientHeight) {
-                return;
-            }
-        }
-        const targetIsInsideChildren = tree && getChildren(tree.nodesRef.current, nodeId).some((node) => {
-            let _node$context;
-            return isEventTargetWithin(event, (_node$context = node.context) == null ? void 0 : _node$context.elements.floating);
-        });
-        if (isEventTargetWithin(event, floating) || isEventTargetWithin(event, domReference) || targetIsInsideChildren) {
-            return;
-        }
-        const children = tree ? getChildren(tree.nodesRef.current, nodeId) : [];
-        if (children.length > 0) {
-            let shouldDismiss = true;
-            children.forEach((child) => {
-                let _child$context2;
-                if ((_child$context2 = child.context) != null && _child$context2.open && !child.context.dataRef.current.__outsidePressBubbles) {
-                    shouldDismiss = false;
-                    return;
-                }
-            });
-            if (!shouldDismiss) {
-                return;
-            }
-        }
-        onOpenChange(false, event, 'outside-press');
-    });
-    const closeOnPressOutsideCapture = useEffectEvent((event) => {
-        let _getTarget4;
-        const callback = () => {
-            let _getTarget3;
-            closeOnPressOutside(event);
-            (_getTarget3 = getTarget(event)) == null ? void 0 : _getTarget3.removeEventListener(outsidePressEvent, callback);
-        };
-        (_getTarget4 = getTarget(event)) == null ? void 0 : _getTarget4.addEventListener(outsidePressEvent, callback);
-    });
-    React$1.useEffect(() => {
-        if (!open || !enabled) {
-            return;
-        }
-        dataRef.current.__escapeKeyBubbles = escapeKeyBubbles;
-        dataRef.current.__outsidePressBubbles = outsidePressBubbles;
-        function onScroll(event) {
-            onOpenChange(false, event, 'ancestor-scroll');
-        }
-        const doc = getDocument(floating);
-        escapeKey && doc.addEventListener('keydown', escapeKeyCapture ? closeOnEscapeKeyDownCapture : closeOnEscapeKeyDown, escapeKeyCapture);
-        outsidePress && doc.addEventListener(outsidePressEvent, outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);
-        let ancestors = [];
-        if (ancestorScroll) {
-            if (isElement(domReference)) {
-                ancestors = getOverflowAncestors(domReference);
-            }
-            if (isElement(floating)) {
-                ancestors = ancestors.concat(getOverflowAncestors(floating));
-            }
-            if (!isElement(reference) && reference && reference.contextElement) {
-                ancestors = ancestors.concat(getOverflowAncestors(reference.contextElement));
-            }
-        }
-
-        // Ignore the visual viewport for scrolling dismissal (allow pinch-zoom)
-        ancestors = ancestors.filter((ancestor) => {
-            let _doc$defaultView;
-            return ancestor !== ((_doc$defaultView = doc.defaultView) == null ? void 0 : _doc$defaultView.visualViewport);
-        });
-        ancestors.forEach((ancestor) => {
-            ancestor.addEventListener('scroll', onScroll, {
-                passive: true,
-            });
-        });
-        return () => {
-            escapeKey && doc.removeEventListener('keydown', escapeKeyCapture ? closeOnEscapeKeyDownCapture : closeOnEscapeKeyDown, escapeKeyCapture);
-            outsidePress && doc.removeEventListener(outsidePressEvent, outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);
-            ancestors.forEach((ancestor) => {
-                ancestor.removeEventListener('scroll', onScroll);
-            });
-        };
-    }, [dataRef, floating, domReference, reference, escapeKey, outsidePress, outsidePressEvent, open, onOpenChange, ancestorScroll, enabled, escapeKeyBubbles, outsidePressBubbles, closeOnEscapeKeyDown, escapeKeyCapture, closeOnEscapeKeyDownCapture, closeOnPressOutside, outsidePressCapture, closeOnPressOutsideCapture]);
-    React$1.useEffect(() => {
-        insideReactTreeRef.current = false;
-    }, [outsidePress, outsidePressEvent]);
-    return React$1.useMemo(() => {
-        if (!enabled) {
-            return {};
-        }
-        return {
-            reference: {
-                onKeyDown: closeOnEscapeKeyDown,
-                [bubbleHandlerKeys[referencePressEvent]]: (event) => {
-                    if (referencePress) {
-                        onOpenChange(false, event.nativeEvent, 'reference-press');
-                    }
-                },
-            },
-            floating: {
-                onKeyDown: closeOnEscapeKeyDown,
-                onMouseDown() {
-                    endedOrStartedInsideRef.current = true;
-                },
-                onMouseUp() {
-                    endedOrStartedInsideRef.current = true;
-                },
-                [captureHandlerKeys[outsidePressEvent]]: () => {
-                    insideReactTreeRef.current = true;
-                },
-            },
-        };
-    }, [enabled, referencePress, outsidePressEvent, referencePressEvent, onOpenChange, closeOnEscapeKeyDown]);
-}
-
-let devMessageSet;
-if (process.env.NODE_ENV !== 'production') {
-    devMessageSet = /* #__PURE__*/new Set();
-}
-
-/**
- * Provides data to position a floating element and context to add interactions.
- * @see https://floating-ui.com/docs/useFloating
- */
-function useFloating(options) {
-    let _options$elements2;
-    if (options === void 0) {
-        options = {};
-    }
-    const {
-        open = false,
-        onOpenChange: unstable_onOpenChange,
-        nodeId,
-    } = options;
-    if (process.env.NODE_ENV !== 'production') {
-        let _options$elements;
-        const err = 'Floating UI: Cannot pass a virtual element to the ' + '`elements.reference` option, as it must be a real DOM element. ' + 'Use `refs.setPositionReference` instead.';
-        if ((_options$elements = options.elements) != null && _options$elements.reference && !isElement(options.elements.reference)) {
-            let _devMessageSet;
-            if (!((_devMessageSet = devMessageSet) != null && _devMessageSet.has(err))) {
-                let _devMessageSet2;
-                (_devMessageSet2 = devMessageSet) == null ? void 0 : _devMessageSet2.add(err);
-                console.error(err);
-            }
-        }
-    }
-    const [_domReference, setDomReference] = React$1.useState(null);
-    const domReference = ((_options$elements2 = options.elements) == null ? void 0 : _options$elements2.reference) || _domReference;
-    const position = useFloating$1(options);
-    const tree = useFloatingTree();
-    const nested = useFloatingParentNodeId() != null;
-    const onOpenChange = useEffectEvent((open, event, reason) => {
-        if (open) {
-            dataRef.current.openEvent = event;
-        }
-        events.emit('openchange', {
-            open,
-            event,
-            reason,
-            nested,
-        });
-        unstable_onOpenChange == null ? void 0 : unstable_onOpenChange(open, event, reason);
-    });
-    const domReferenceRef = React$1.useRef(null);
-    const dataRef = React$1.useRef({});
-    const events = React$1.useState(() => createPubSub())[0];
-    const floatingId = useId();
-    const setPositionReference = React$1.useCallback((node) => {
-        const positionReference = isElement(node) ? {
-            getBoundingClientRect: () => node.getBoundingClientRect(),
-            contextElement: node,
-        } : node;
-        position.refs.setReference(positionReference);
-    }, [position.refs]);
-    const setReference = React$1.useCallback((node) => {
-        if (isElement(node) || node === null) {
-            domReferenceRef.current = node;
-            setDomReference(node);
-        }
-
-        // Backwards-compatibility for passing a virtual element to `reference`
-        // after it has set the DOM reference.
-        if (isElement(position.refs.reference.current) || position.refs.reference.current === null ||
-    // Don't allow setting virtual elements using the old technique back to
-    // `null` to support `positionReference` + an unstable `reference`
-    // callback ref.
-    node !== null && !isElement(node)) {
-            position.refs.setReference(node);
-        }
-    }, [position.refs]);
-    const refs = React$1.useMemo(() => ({
-        ...position.refs,
-        setReference,
-        setPositionReference,
-        domReference: domReferenceRef,
-    }), [position.refs, setReference, setPositionReference]);
-    const elements = React$1.useMemo(() => ({
-        ...position.elements,
-        domReference: domReference,
-    }), [position.elements, domReference]);
-    const context = React$1.useMemo(() => ({
-        ...position,
-        refs,
-        elements,
-        dataRef,
-        nodeId,
-        floatingId,
-        events,
-        open,
-        onOpenChange,
-    }), [position, nodeId, floatingId, events, open, onOpenChange, refs, elements]);
-    index(() => {
-        const node = tree == null ? void 0 : tree.nodesRef.current.find((node) => node.id === nodeId);
-        if (node) {
-            node.context = context;
-        }
-    });
-    return React$1.useMemo(() => ({
-        ...position,
-        context,
-        refs,
-        elements,
-    }), [position, refs, elements, context]);
-}
-
-function mergeProps(userProps, propsList, elementKey) {
-    const map = new Map();
-    return {
-        ...(elementKey === 'floating' && {
-            tabIndex: -1,
-        }),
-        ...userProps,
-        ...propsList.map((value) => value ? value[elementKey] : null).concat(userProps).reduce((acc, props) => {
-            if (!props) {
-                return acc;
-            }
-            Object.entries(props).forEach((_ref) => {
-                const [key, value] = _ref;
-                if (key.indexOf('on') === 0) {
-                    if (!map.has(key)) {
-                        map.set(key, []);
-                    }
-                    if (typeof value === 'function') {
-                        let _map$get;
-                        (_map$get = map.get(key)) == null ? void 0 : _map$get.push(value);
-                        acc[key] = function() {
-                            let _map$get2;
-                            for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-                                args[_key] = arguments[_key];
-                            }
-                            return (_map$get2 = map.get(key)) == null ? void 0 : _map$get2.map((fn) => fn(...args)).find((val) => val !== undefined);
-                        };
-                    }
-                } else {
-                    acc[key] = value;
-                }
-            });
-            return acc;
-        }, {}),
-    };
-}
-
-/**
- * Merges an array of interaction hooks' props into prop getters, allowing
- * event handler functions to be composed together without overwriting one
- * another.
- * @see https://floating-ui.com/docs/useInteractions
- */
-function useInteractions(propsList) {
-    if (propsList === void 0) {
-        propsList = [];
-    }
-    // The dependencies are a dynamic array, so we can't use the linter's
-    // suggestion to add it to the deps array.
-    const deps = propsList;
-    const getReferenceProps = React$1.useCallback((userProps) => mergeProps(userProps, propsList, 'reference'),
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-        deps);
-    const getFloatingProps = React$1.useCallback((userProps) => mergeProps(userProps, propsList, 'floating'),
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-        deps);
-    const getItemProps = React$1.useCallback((userProps) => mergeProps(userProps, propsList, 'item'),
-        // Granularly check for `item` changes, because the `getItemProps` getter
-        // should be as referentially stable as possible since it may be passed as
-        // a prop to many components. All `item` key values must therefore be
-        // memoized.
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-        propsList.map((key) => key == null ? void 0 : key.item));
-    return React$1.useMemo(() => ({
-        getReferenceProps,
-        getFloatingProps,
-        getItemProps,
-    }), [getReferenceProps, getFloatingProps, getItemProps]);
-}
-
-/**
- * Adds base screen reader props to the reference and floating elements for a
- * given floating element `role`.
- * @see https://floating-ui.com/docs/useRole
- */
-function useRole(context, props) {
-    if (props === void 0) {
-        props = {};
-    }
-    const {
-        open,
-        floatingId,
-    } = context;
-    const {
-        enabled = true,
-        role = 'dialog',
-    } = props;
-    const referenceId = useId();
-    return React$1.useMemo(() => {
-        if (!enabled) return {};
-        const floatingProps = {
-            id: floatingId,
-            ...(role !== 'label' && {
-                role,
-            }),
-        };
-        if (role === 'tooltip' || role === 'label') {
-            return {
-                reference: {
-                    ['aria-' + (role === 'label' ? 'labelledby' : 'describedby')]: open ? floatingId : undefined,
-                },
-                floating: floatingProps,
-            };
-        }
-        return {
-            reference: {
-                'aria-expanded': open ? 'true' : 'false',
-                'aria-haspopup': role === 'alertdialog' ? 'dialog' : role,
-                'aria-controls': open ? floatingId : undefined,
-                ...(role === 'listbox' && {
-                    role: 'combobox',
-                }),
-                ...(role === 'menu' && {
-                    id: referenceId,
-                }),
-            },
-            floating: {
-                ...floatingProps,
-                ...(role === 'menu' && {
-                    'aria-labelledby': referenceId,
-                }),
-            },
-        };
-    }, [enabled, role, open, floatingId, referenceId]);
-}
-
-const Dropdown = (_ref) => {
-    const [isOpen, setIsOpen] = useState(false);
-    useFloating({
-        open: isOpen,
-        onOpenChange: setIsOpen,
-        middleware: [offset(10), flip(), shift()],
-        whileElementsMounted: autoUpdate,
-    });
-    return /* #__PURE__*/React.createElement('div', null, 'Dropdown');
-};
-
-// TODO : Use Floating Portal?
-// TODO : Collisions dont seem to be working as expected, need to investigate
-
-const ARROW_HEIGHT = 7;
-const GAP = 2;
-const Popper = (_ref) => {
-    const {
-        popperName = '',
-        customRootClass = '',
-        className = '',
-        children,
-        open = false,
-        hoverDelay = 10,
-        showArrow = true,
-        pop = /* #__PURE__*/React.createElement(React.Fragment, null),
-        ...props
-    } = _ref;
-    const rootClass = customClassSwitcher(customRootClass, popperName);
-    const arrowRef = useRef(null);
-    const [isOpen, setIsOpen] = useState(open);
-    const {
-        refs,
-        floatingStyles,
-        context,
-    } = useFloating({
-        open: isOpen,
-        middleware: [arrow({
-            element: arrowRef,
-        }), offset(ARROW_HEIGHT + GAP),
-        // autoPlacement({
-        //     crossAxis: 'center',
-        //     alignment: 'start',
-        //     autoAlignment: true,
-        //     allowedPlacements: ['top', 'bottom', 'left', 'right'],
-        //     padding: 5,
-        // }),
-        flip()],
-        onOpenChange: setIsOpen,
-        placement: 'top',
-    });
-    const role = useRole(context);
-    const dismiss = useDismiss(context);
-    const hover = useHover(context, {
-    // delay: hoverDelay,
-    });
-    const {
-        getReferenceProps,
-        getFloatingProps,
-    } = useInteractions([hover, role, dismiss]);
-    return /* #__PURE__*/React.createElement(React.Fragment, null, /* #__PURE__*/React.createElement('span', _extends$1({
-        className: `${rootClass}-reference-element ${className}`,
-        ref: refs.setReference,
-    }, getReferenceProps({
-        onClick: () => {
-            console.log('click');
-        },
-    })), children), isOpen && /* #__PURE__*/React.createElement('div', _extends$1({
-        className: `${rootClass}-floating-element`,
-        ref: refs.setFloating,
-        style: floatingStyles,
-    }, getFloatingProps()), showArrow && /* #__PURE__*/React.createElement(FloatingArrow, {
-        className: `rad-ui-arrow ${rootClass}-arrow`,
-        ref: arrowRef,
-        context: context,
-    }), pop));
-};
-
-const COMPONENT_NAME = 'Tooltip';
-const Tooltip = (_ref) => {
-    const {
-        children,
-        label,
-        ...props
-    } = _ref;
-    return /* #__PURE__*/React.createElement('div', null, /* #__PURE__*/React.createElement(Popper, _extends$1({
-        popperName: COMPONENT_NAME,
-        pop: 'hello',
-    }, props), children));
-};
-
-export {Avatar, Badge, BlockQuote, Button, Callout, Code, Dropdown, Em, Heading, Link, Quote, Separator, Tabs, Text, Tooltip};