@patternfly/patternfly-doc-core 1.2.0 → 1.3.0

package/dist/server/chunks/angle-down-icon_BNJvzYv-.mjs

@@ -0,0 +1,3970 @@
+import { __rest } from 'tslib';
+import * as React from 'react';
+import React__default, { useMemo } from 'react';
+/* empty css                          */
+import * as ReactDOM from 'react-dom';
+
+/** Joins args into a className string
+ *
+ * @param {any} args list of objects, string, or arrays to reduce
+ */
+function css(...args) {
+    // Adapted from https://github.com/JedWatson/classnames/blob/master/index.js
+    const classes = [];
+    const hasOwn = {}.hasOwnProperty;
+    args.filter(Boolean).forEach((arg) => {
+        const argType = typeof arg;
+        if (argType === 'string' || argType === 'number') {
+            classes.push(arg);
+        }
+        else if (Array.isArray(arg) && arg.length) {
+            const inner = css(...arg);
+            if (inner) {
+                classes.push(inner);
+            }
+        }
+        else if (argType === 'object') {
+            for (const key in arg) {
+                if (hasOwn.call(arg, key) && arg[key]) {
+                    classes.push(key);
+                }
+            }
+        }
+    });
+    return classes.join(' ');
+}
+
+const t_global_breakpoint_sm = {
+  "value": "36rem"};
+
+const t_global_breakpoint_md = {
+  "value": "48rem"};
+
+const t_global_breakpoint_lg = {
+  "value": "62rem"};
+
+const t_global_breakpoint_xl = {
+  "value": "75rem"};
+
+const t_global_breakpoint_2xl = {
+  "value": "90.625rem"};
+
+const t_global_breakpoint_height_sm = {
+  "value": "0rem"};
+
+const t_global_breakpoint_height_md = {
+  "value": "40rem"};
+
+const t_global_breakpoint_height_lg = {
+  "value": "48rem"};
+
+const t_global_breakpoint_height_xl = {
+  "value": "60rem"};
+
+const t_global_breakpoint_height_2xl = {
+  "value": "80rem"};
+
+let currentId$1 = 0;
+/**
+ * Factory to create Icon class components for consumers
+ */
+function createIcon({ name, xOffset = 0, yOffset = 0, width, height, svgPath }) {
+    var _a;
+    return _a = class SVGIcon extends React.Component {
+            constructor() {
+                super(...arguments);
+                this.id = `icon-title-${currentId$1++}`;
+            }
+            render() {
+                const _b = this.props, { title, className } = _b, props = __rest(_b, ["title", "className"]);
+                const classes = className ? `pf-v6-svg ${className}` : 'pf-v6-svg';
+                const hasTitle = Boolean(title);
+                const viewBox = [xOffset, yOffset, width, height].join(' ');
+                return (React.createElement("svg", Object.assign({ className: classes, viewBox: viewBox, fill: "currentColor", "aria-labelledby": hasTitle ? this.id : null, "aria-hidden": hasTitle ? null : true, role: "img", width: "1em", height: "1em" }, props),
+                    hasTitle && React.createElement("title", { id: this.id }, title),
+                    React.createElement("path", { d: svgPath })));
+            }
+        },
+        _a.displayName = name,
+        _a;
+}
+
+const CheckCircleIconConfig = {
+  name: 'CheckCircleIcon',
+  height: 512,
+  width: 512,
+  svgPath: 'M504 256c0 136.967-111.033 248-248 248S8 392.967 8 256 119.033 8 256 8s248 111.033 248 248zM227.314 387.314l184-184c6.248-6.248 6.248-16.379 0-22.627l-22.627-22.627c-6.248-6.249-16.379-6.249-22.628 0L216 308.118l-70.059-70.059c-6.248-6.248-16.379-6.248-22.628 0l-22.627 22.627c-6.248 6.248-6.248 16.379 0 22.627l104 104c6.249 6.249 16.379 6.249 22.628.001z',
+  yOffset: 0,
+  xOffset: 0,
+};
+
+const CheckCircleIcon = createIcon(CheckCircleIconConfig);
+
+const ExclamationCircleIconConfig = {
+  name: 'ExclamationCircleIcon',
+  height: 512,
+  width: 512,
+  svgPath: 'M504 256c0 136.997-111.043 248-248 248S8 392.997 8 256C8 119.083 119.043 8 256 8s248 111.083 248 248zm-248 50c-25.405 0-46 20.595-46 46s20.595 46 46 46 46-20.595 46-46-20.595-46-46-46zm-43.673-165.346l7.418 136c.347 6.364 5.609 11.346 11.982 11.346h48.546c6.373 0 11.635-4.982 11.982-11.346l7.418-136c.375-6.874-5.098-12.654-11.982-12.654h-63.383c-6.884 0-12.356 5.78-11.981 12.654z',
+  yOffset: 0,
+  xOffset: 0,
+};
+
+const ExclamationCircleIcon = createIcon(ExclamationCircleIconConfig);
+
+const ExclamationTriangleIconConfig = {
+  name: 'ExclamationTriangleIcon',
+  height: 512,
+  width: 576,
+  svgPath: 'M569.517 440.013C587.975 472.007 564.806 512 527.94 512H48.054c-36.937 0-59.999-40.055-41.577-71.987L246.423 23.985c18.467-32.009 64.72-31.951 83.154 0l239.94 416.028zM288 354c-25.405 0-46 20.595-46 46s20.595 46 46 46 46-20.595 46-46-20.595-46-46-46zm-43.673-165.346l7.418 136c.347 6.364 5.609 11.346 11.982 11.346h48.546c6.373 0 11.635-4.982 11.982-11.346l7.418-136c.375-6.874-5.098-12.654-11.982-12.654h-63.383c-6.884 0-12.356 5.78-11.981 12.654z',
+  yOffset: 0,
+  xOffset: 0,
+};
+
+const ExclamationTriangleIcon = createIcon(ExclamationTriangleIconConfig);
+
+const InfoCircleIconConfig = {
+  name: 'InfoCircleIcon',
+  height: 512,
+  width: 512,
+  svgPath: 'M256 8C119.043 8 8 119.083 8 256c0 136.997 111.043 248 248 248s248-111.003 248-248C504 119.083 392.957 8 256 8zm0 110c23.196 0 42 18.804 42 42s-18.804 42-42 42-42-18.804-42-42 18.804-42 42-42zm56 254c0 6.627-5.373 12-12 12h-88c-6.627 0-12-5.373-12-12v-24c0-6.627 5.373-12 12-12h12v-64h-12c-6.627 0-12-5.373-12-12v-24c0-6.627 5.373-12 12-12h64c6.627 0 12 5.373 12 12v100h12c6.627 0 12 5.373 12 12v24z',
+  yOffset: 0,
+  xOffset: 0,
+};
+
+const InfoCircleIcon = createIcon(InfoCircleIconConfig);
+
+const BellIconConfig = {
+  name: 'BellIcon',
+  height: 1024,
+  width: 896,
+  svgPath: 'M448,0 C465.333333,0 480.333333,6.33333333 493,19 C505.666667,31.6666667 512,46.6666667 512,64 L512,106 L514.23,106.45 C587.89,121.39 648.48,157.24 696,214 C744,271.333333 768,338.666667 768,416 C768,500 780,568.666667 804,622 C818.666667,652.666667 841.333333,684 872,716 C873.773676,718.829136 875.780658,721.505113 878,724 C890,737.333333 896,752.333333 896,769 C896,785.666667 890,800.333333 878,813 C866,825.666667 850.666667,832 832,832 L63.3,832 C44.9533333,831.84 29.8533333,825.506667 18,813 C6,800.333333 0,785.666667 0,769 C0,752.333333 6,737.333333 18,724 L24,716 L25.06,714.9 C55.1933333,683.28 77.5066667,652.313333 92,622 C116,568.666667 128,500 128,416 C128,338.666667 152,271.333333 200,214 C248,156.666667 309.333333,120.666667 384,106 L384,63.31 C384.166667,46.27 390.5,31.5 403,19 C415.666667,6.33333333 430.666667,0 448,0 Z M576,896 L576,897.08 C575.74,932.6 563.073333,962.573333 538,987 C512.666667,1011.66667 482.666667,1024 448,1024 C413.333333,1024 383.333333,1011.66667 358,987 C332.666667,962.333333 320,932 320,896 L576,896 Z',
+  yOffset: 0,
+  xOffset: 0,
+};
+
+const BellIcon = createIcon(BellIconConfig);
+
+var ValidatedOptions;
+(function (ValidatedOptions) {
+    ValidatedOptions["success"] = "success";
+    ValidatedOptions["error"] = "error";
+    ValidatedOptions["warning"] = "warning";
+    ValidatedOptions["default"] = "default";
+})(ValidatedOptions || (ValidatedOptions = {}));
+const KeyTypes = {
+    Space: ' ',
+    Escape: 'Escape',
+    Enter: 'Enter'};
+const globalWidthBreakpoints = {
+    sm: parseInt(t_global_breakpoint_sm.value) * 16,
+    md: parseInt(t_global_breakpoint_md.value) * 16,
+    lg: parseInt(t_global_breakpoint_lg.value) * 16,
+    xl: parseInt(t_global_breakpoint_xl.value) * 16,
+    '2xl': parseInt(t_global_breakpoint_2xl.value) * 16
+};
+const globalHeightBreakpoints = {
+    sm: parseInt(t_global_breakpoint_height_sm.value) * 16,
+    md: parseInt(t_global_breakpoint_height_md.value) * 16,
+    lg: parseInt(t_global_breakpoint_height_lg.value) * 16,
+    xl: parseInt(t_global_breakpoint_height_xl.value) * 16,
+    '2xl': parseInt(t_global_breakpoint_height_2xl.value) * 16
+};
+const statusIcons = {
+    success: CheckCircleIcon,
+    danger: ExclamationCircleIcon,
+    warning: ExclamationTriangleIcon,
+    info: InfoCircleIcon,
+    custom: BellIcon
+};
+
+/**
+ * @param {string} prefix - String to prefix ID with
+ */
+function getUniqueId(prefix = 'pf') {
+    const uid = new Date().getTime() + Math.random().toString(36).slice(2);
+    return `${prefix}-${uid}`;
+}
+/**
+ * This function is a helper for turning arrays of breakpointMod objects for flex and grid into style object
+ *
+ * @param {object} mods The modifiers object
+ * @param {string} css-variable The appropriate css variable for the component
+ */
+const setBreakpointCssVars = (mods, cssVar) => Object.entries(mods || {}).reduce((acc, [breakpoint, value]) => breakpoint === 'default' ? Object.assign(Object.assign({}, acc), { [cssVar]: value }) : Object.assign(Object.assign({}, acc), { [`${cssVar}-on-${breakpoint}`]: value }), {});
+/**
+ * This function is a helper for turning arrays of breakpointMod objects for data toolbar and flex into classes
+ *
+ * @param {object} mods The modifiers object
+ * @param {any} styles The appropriate styles object for the component
+ */
+const formatBreakpointMods = (mods, styles, stylePrefix = '', breakpoint, vertical) => {
+    if (!mods) {
+        return '';
+    }
+    if (breakpoint && !vertical) {
+        if (breakpoint in mods) {
+            return styles.modifiers[toCamel(`${stylePrefix}${mods[breakpoint]}`)];
+        }
+        // the current breakpoint is not specified in mods, so we try to find the next nearest
+        const breakpointsOrder = ['2xl', 'xl', 'lg', 'md', 'sm', 'default'];
+        const breakpointsIndex = breakpointsOrder.indexOf(breakpoint);
+        for (let i = breakpointsIndex; i < breakpointsOrder.length; i++) {
+            if (breakpointsOrder[i] in mods) {
+                return styles.modifiers[toCamel(`${stylePrefix}${mods[breakpointsOrder[i]]}`)];
+            }
+        }
+        return '';
+    }
+    return Object.entries(mods || {})
+        .map(([breakpoint, mod]) => `${stylePrefix}${mod}${breakpoint !== 'default' ? `-on-${breakpoint}` : ''}${vertical && breakpoint !== 'default' ? '-height' : ''}`)
+        .map(toCamel)
+        .map((mod) => mod.replace(/-?(\dxl)/gi, (_res, group) => `_${group}`))
+        .map((modifierKey) => styles.modifiers[modifierKey])
+        .filter(Boolean)
+        .join(' ');
+};
+/**
+ * Return the breakpoint for the given height
+ *
+ * @param {number | null} height The height to check
+ * @returns {'default' | 'sm' | 'md' | 'lg' | 'xl' | '2xl'} The breakpoint
+ */
+const getVerticalBreakpoint = (height) => {
+    if (height === null) {
+        return null;
+    }
+    if (height >= globalHeightBreakpoints['2xl']) {
+        return '2xl';
+    }
+    if (height >= globalHeightBreakpoints.xl) {
+        return 'xl';
+    }
+    if (height >= globalHeightBreakpoints.lg) {
+        return 'lg';
+    }
+    if (height >= globalHeightBreakpoints.md) {
+        return 'md';
+    }
+    if (height >= globalHeightBreakpoints.sm) {
+        return 'sm';
+    }
+    return 'default';
+};
+/**
+ * Return the breakpoint for the given width
+ *
+ * @param {number | null} width The width to check
+ * @returns {'default' | 'sm' | 'md' | 'lg' | 'xl' | '2xl'} The breakpoint
+ */
+const getBreakpoint = (width) => {
+    if (width === null) {
+        return null;
+    }
+    if (width >= globalWidthBreakpoints['2xl']) {
+        return '2xl';
+    }
+    if (width >= globalWidthBreakpoints.xl) {
+        return 'xl';
+    }
+    if (width >= globalWidthBreakpoints.lg) {
+        return 'lg';
+    }
+    if (width >= globalWidthBreakpoints.md) {
+        return 'md';
+    }
+    if (width >= globalWidthBreakpoints.sm) {
+        return 'sm';
+    }
+    return 'default';
+};
+const camelize = (s) => s.toUpperCase().replace('-', '').replace('_', '');
+/**
+ *
+ * @param {string} s string to make camelCased
+ */
+const toCamel = (s) => s.replace(/([-_][a-z])/gi, camelize);
+/**
+ * Copied from exenv
+ */
+const canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);
+/**
+ * Calculate the width of the text
+ * Example:
+ * getTextWidth('my text', node)
+ *
+ * @param {string} text The text to calculate the width for
+ * @param {HTMLElement} node The HTML element
+ */
+const getTextWidth = (text, node) => {
+    const computedStyle = getComputedStyle(node);
+    // Firefox returns the empty string for .font, so this function creates the .font property manually
+    const getFontFromComputedStyle = () => {
+        let computedFont = '';
+        // Firefox uses percentages for font-stretch, but Canvas does not accept percentages
+        // so convert to keywords, as listed at:
+        // https://developer.mozilla.org/en-US/docs/Web/CSS/font-stretch
+        const fontStretchLookupTable = {
+            '50%': 'ultra-condensed',
+            '62.5%': 'extra-condensed',
+            '75%': 'condensed',
+            '87.5%': 'semi-condensed',
+            '100%': 'normal',
+            '112.5%': 'semi-expanded',
+            '125%': 'expanded',
+            '150%': 'extra-expanded',
+            '200%': 'ultra-expanded'
+        };
+        // If the retrieved font-stretch percentage isn't found in the lookup table, use
+        // 'normal' as a last resort.
+        let fontStretch;
+        if (computedStyle.fontStretch in fontStretchLookupTable) {
+            fontStretch = fontStretchLookupTable[computedStyle.fontStretch];
+        }
+        else {
+            fontStretch = 'normal';
+        }
+        computedFont =
+            computedStyle.fontStyle +
+                ' ' +
+                computedStyle.fontVariant +
+                ' ' +
+                computedStyle.fontWeight +
+                ' ' +
+                fontStretch +
+                ' ' +
+                computedStyle.fontSize +
+                '/' +
+                computedStyle.lineHeight +
+                ' ' +
+                computedStyle.fontFamily;
+        return computedFont;
+    };
+    const canvas = document.createElement('canvas');
+    const context = canvas.getContext('2d');
+    context.font = computedStyle.font || getFontFromComputedStyle();
+    return context.measureText(text).width;
+};
+/**
+ * Get the inner dimensions of an element
+ *
+ * @param {HTMLElement} node HTML element to calculate the inner dimensions for
+ */
+const innerDimensions = (node) => {
+    const computedStyle = getComputedStyle(node);
+    let width = node.clientWidth; // width with padding
+    let height = node.clientHeight; // height with padding
+    height -= parseFloat(computedStyle.paddingTop) + parseFloat(computedStyle.paddingBottom);
+    width -= parseFloat(computedStyle.paddingLeft) + parseFloat(computedStyle.paddingRight);
+    return { height, width };
+};
+/**
+ * This function is a helper for truncating text content on the left, leaving the right side of the content in view
+ *
+ * @param {HTMLElement} node HTML element
+ * @param {string} value The original text value
+ */
+const trimLeft = (node, value) => {
+    const availableWidth = innerDimensions(node).width;
+    let newValue = value;
+    if (getTextWidth(value, node) > availableWidth) {
+        // we have text overflow, trim the text to the left and add ... in the front until it fits
+        while (getTextWidth(`...${newValue}`, node) > availableWidth) {
+            newValue = newValue.substring(1);
+        }
+        // replace text with our truncated text
+        if (node.value) {
+            node.value = `...${newValue}`;
+        }
+        else {
+            node.innerText = `...${newValue}`;
+        }
+    }
+    else {
+        if (node.value) {
+            node.value = value;
+        }
+        else {
+            node.innerText = value;
+        }
+    }
+};
+/**
+ * @param {React.RefObject<any>[]} timeoutRefs - Timeout refs to clear
+ */
+const clearTimeouts = (timeoutRefs) => {
+    timeoutRefs.forEach((ref) => {
+        if (ref.current) {
+            clearTimeout(ref.current);
+        }
+    });
+};
+/**
+ * Helper function to get the language direction of a given element, useful for figuring out if left-to-right
+ * or right-to-left specific logic should be applied.
+ *
+ * @param {HTMLElement} targetElement  - Element the helper will get the language direction of
+ * @param {'ltr' | 'rtl'} defaultDirection - Language direction to assume if one can't be determined, defaults to 'ltr'
+ * @returns {'ltr' | 'rtl'} - The language direction of the target element
+ */
+const getLanguageDirection = (targetElement, defaultDirection = 'ltr') => {
+    if (!targetElement) {
+        return defaultDirection;
+    }
+    const computedDirection = getComputedStyle(targetElement).getPropertyValue('direction');
+    if (['ltr', 'rtl'].includes(computedDirection)) {
+        return computedDirection;
+    }
+    return defaultDirection;
+};
+
+/** This Component can be used to wrap a functional component in order to generate a random ID
+ * Example of how to use this component
+ *
+ * const Component = ({id}: {id: string}) => (
+ *  <GenerateId>{randomId => (
+ *     <div id={id || randomId}>
+ *       div with random ID
+ *     </div>
+ *   )}
+ *  </GenerateId>
+ *  );
+ */
+let currentId = 0;
+// gives us a unique (enough) id to add to the generated id that it should prevent issues with duplicate ids
+function getRandomId() {
+    if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+        return crypto.randomUUID();
+    }
+    else {
+        return getUniqueId();
+    }
+}
+class GenerateId extends React.Component {
+    constructor() {
+        super(...arguments);
+        this.uniqueElement = this.props.isRandom ? getRandomId() : currentId++;
+        this.id = `${this.props.prefix}${this.uniqueElement}`;
+    }
+    render() {
+        return this.props.children(this.id);
+    }
+}
+GenerateId.displayName = 'GenerateId';
+GenerateId.defaultProps = {
+    prefix: 'pf-random-id-',
+    isRandom: false
+};
+
+const ASTERISK = '*';
+
+let uid = 0;
+const ouiaPrefix = 'OUIA-Generated-';
+const ouiaIdByRoute = {};
+/** Get props to conform to OUIA spec
+ *
+ * For functional components, use the useOUIAProps function instead
+ *
+ * In class based components, create a state variable ouiaStateId to create a static generated ID:
+ * state = {
+ *  ouiaStateId: getDefaultOUIAId(Chip.displayName)
+ * }
+ * This generated ID should remain alive as long as the component is not unmounted.
+ *
+ * Then add the attributes to the component
+ * {...getOUIAProps('OverflowChip', this.props.ouiaId !== undefined ? this.props.ouiaId : this.state.ouiaStateId)}
+ *
+ * @param {string} componentType OUIA component type
+ * @param {number|string} id OUIA component id
+ * @param {boolean} ouiaSafe false if in animation
+ */
+function getOUIAProps(componentType, id, ouiaSafe = true) {
+    return {
+        'data-ouia-component-type': `PF6/${componentType}`,
+        'data-ouia-safe': ouiaSafe,
+        'data-ouia-component-id': id
+    };
+}
+/**
+ * Hooks version of the getOUIAProps function that also memoizes the generated ID
+ * Can only be used in functional components
+ *
+ * @param {string} componentType OUIA component type
+ * @param {number|string} id OUIA component id
+ * @param {boolean} ouiaSafe false if in animation
+ * @param {string} variant Optional variant to add to the generated ID
+ */
+const useOUIAProps = (componentType, id, ouiaSafe = true, variant) => ({
+    'data-ouia-component-type': `PF6/${componentType}`,
+    'data-ouia-safe': ouiaSafe,
+    'data-ouia-component-id': useOUIAId(componentType, id, variant)
+});
+/**
+ * Returns the ID or the memoized generated ID
+ *
+ * @param {string} componentType OUIA component type
+ * @param {number|string} id OUIA component id
+ * @param {string} variant Optional variant to add to the generated ID
+ */
+const useOUIAId = (componentType, id, variant) => {
+    const defaultOUIAId = useMemo(() => getDefaultOUIAId(componentType, variant), [componentType, variant]);
+    return id !== null && id !== void 0 ? id : defaultOUIAId;
+};
+/**
+ * Returns a generated id based on the URL location
+ *
+ * @param {string} componentType OUIA component type
+ * @param {string} variant Optional variant to add to the generated ID
+ */
+function getDefaultOUIAId(componentType, variant) {
+    /*
+    ouiaIdByRoute = {
+      [route+componentType]: [number]
+    }
+    */
+    try {
+        let key;
+        if (typeof window !== 'undefined') {
+            // browser environments
+            key = `${window.location.href}-${componentType}-${variant || ''}`;
+        }
+        else {
+            // node/SSR environments
+            key = `${componentType}-${variant || ''}`;
+        }
+        if (!ouiaIdByRoute[key]) {
+            ouiaIdByRoute[key] = 0;
+        }
+        return `${ouiaPrefix}${componentType}-${variant ? `${variant}-` : ''}${++ouiaIdByRoute[key]}`;
+    }
+    catch (exception) {
+        return `${ouiaPrefix}${componentType}-${variant ? `${variant}-` : ''}${++uid}`;
+    }
+}
+
+/**
+ * @param element
+ */
+function getBoundingClientRect(element) {
+    const rect = element.getBoundingClientRect();
+    return {
+        width: rect.width,
+        height: rect.height,
+        top: rect.top,
+        right: rect.right,
+        bottom: rect.bottom,
+        left: rect.left,
+        x: rect.left,
+        y: rect.top
+    };
+}
+
+// @ts-nocheck
+/* :: import type { Window } from '../types'; */
+/* :: declare function getWindow(node: Node | Window): Window; */
+/**
+ * @param node
+ */
+function getWindow(node) {
+    if (node.toString() !== '[object Window]') {
+        const ownerDocument = node.ownerDocument;
+        return ownerDocument ? ownerDocument.defaultView : window;
+    }
+    return node;
+}
+
+// @ts-nocheck
+/**
+ * @param node
+ */
+function getWindowScroll(node) {
+    const win = getWindow(node);
+    const scrollLeft = win.pageXOffset;
+    const scrollTop = win.pageYOffset;
+    return {
+        scrollLeft,
+        scrollTop
+    };
+}
+
+// @ts-nocheck
+/* :: declare function isElement(node: mixed): boolean %checks(node instanceof
+  Element); */
+/**
+ * @param node
+ */
+function isElement(node) {
+    const OwnElement = getWindow(node).Element;
+    return node instanceof OwnElement || node instanceof Element;
+}
+/* :: declare function isHTMLElement(node: mixed): boolean %checks(node instanceof
+  HTMLElement); */
+/**
+ * @param node
+ */
+function isHTMLElement(node) {
+    const OwnElement = getWindow(node).HTMLElement;
+    return node instanceof OwnElement || node instanceof HTMLElement;
+}
+
+// @ts-nocheck
+/**
+ * @param element
+ */
+function getHTMLElementScroll(element) {
+    return {
+        scrollLeft: element.scrollLeft,
+        scrollTop: element.scrollTop
+    };
+}
+
+// @ts-nocheck
+/**
+ * @param node
+ */
+function getNodeScroll(node) {
+    if (node === getWindow(node) || !isHTMLElement(node)) {
+        return getWindowScroll(node);
+    }
+    else {
+        return getHTMLElementScroll(node);
+    }
+}
+
+/**
+ * @param element
+ */
+function getNodeName(element) {
+    return element ? (element.nodeName || '').toLowerCase() : null;
+}
+
+// @ts-nocheck
+/**
+ * @param element
+ */
+function getDocumentElement(element) {
+    // $FlowFixMe: assume body is always available
+    return (isElement(element) ? element.ownerDocument : element.document).documentElement;
+}
+
+// @ts-nocheck
+/**
+ * @param element
+ */
+function getWindowScrollBarX(element) {
+    // If <html> has a CSS width greater than the viewport, then this will be
+    // incorrect for RTL.
+    // Popper 1 is broken in this case and never had a bug report so let's assume
+    // it's not an issue. I don't think anyone ever specifies width on <html>
+    // anyway.
+    // Browsers where the left scrollbar doesn't cause an issue report `0` for
+    // this (e.g. Edge 2019, IE11, Safari)
+    return getBoundingClientRect(getDocumentElement(element)).left + getWindowScroll(element).scrollLeft;
+}
+
+// @ts-nocheck
+/**
+ * @param element
+ */
+function getComputedStyle$1(element) {
+    return getWindow(element).getComputedStyle(element);
+}
+
+// @ts-nocheck
+/**
+ * @param element
+ */
+function isScrollParent(element) {
+    // Firefox wants us to check `-x` and `-y` variations as well
+    const { overflow, overflowX, overflowY } = getComputedStyle$1(element);
+    return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
+}
+
+// Returns the composite rect of an element relative to its offsetParent.
+// Composite means it takes into account transforms as well as layout.
+/**
+ * @param elementOrVirtualElement
+ * @param offsetParent
+ * @param isFixed
+ */
+function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed = false) {
+    const documentElement = getDocumentElement(offsetParent);
+    const rect = getBoundingClientRect(elementOrVirtualElement);
+    const isOffsetParentAnElement = isHTMLElement(offsetParent);
+    let scroll = { scrollLeft: 0, scrollTop: 0 };
+    let offsets = { x: 0, y: 0 };
+    if (isOffsetParentAnElement || (!isOffsetParentAnElement && !isFixed)) {
+        if (getNodeName(offsetParent) !== 'body' || // https://github.com/popperjs/popper-core/issues/1078
+            isScrollParent(documentElement)) {
+            scroll = getNodeScroll(offsetParent);
+        }
+        if (isHTMLElement(offsetParent)) {
+            offsets = getBoundingClientRect(offsetParent);
+            offsets.x += offsetParent.clientLeft;
+            offsets.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
+    };
+}
+
+// Returns the layout rect of an element relative to its offsetParent. Layout
+// means it doesn't take into account transforms.
+/**
+ * @param element
+ */
+function getLayoutRect(element) {
+    return {
+        x: element.offsetLeft,
+        y: element.offsetTop,
+        width: element.offsetWidth,
+        height: element.offsetHeight
+    };
+}
+
+// @ts-nocheck
+/**
+ * @param element
+ */
+function getParentNode(element) {
+    if (getNodeName(element) === 'html') {
+        return element;
+    }
+    return (
+    // $FlowFixMe: this is a quicker (but less type safe) way to save quite some bytes from the bundle
+    element.assignedSlot || // step into the shadow DOM of the parent of a slotted node
+        element.parentNode || // DOM Element detected
+        // $FlowFixMe: need a better way to handle this...
+        element.host || // ShadowRoot detected
+        // $FlowFixMe: HTMLElement is a Node
+        getDocumentElement(element) // fallback
+    );
+}
+
+// @ts-nocheck
+/**
+ * @param node
+ */
+function getScrollParent(node) {
+    if (['html', 'body', '#document'].indexOf(getNodeName(node)) >= 0) {
+        // $FlowFixMe: assume body is always available
+        return node.ownerDocument.body;
+    }
+    if (isHTMLElement(node) && isScrollParent(node)) {
+        return node;
+    }
+    return getScrollParent(getParentNode(node));
+}
+
+// @ts-nocheck
+/*
+given a DOM element, return the list of all scroll parents, up the list of ancesors
+until we get to the top window object. This list is what we attach scroll listeners
+to, because if any of these parent elements scroll, we'll need to re-calculate the
+reference element's position.
+*/
+/**
+ * @param element
+ * @param list
+ */
+function listScrollParents(element, list = []) {
+    const scrollParent = getScrollParent(element);
+    const isBody = getNodeName(scrollParent) === 'body';
+    const win = getWindow(scrollParent);
+    const target = isBody
+        ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : [])
+        : scrollParent;
+    const updatedList = list.concat(target);
+    return isBody
+        ? updatedList // $FlowFixMe: isBody tells us target will be an HTMLElement here
+        : updatedList.concat(listScrollParents(getParentNode(target)));
+}
+
+// @ts-nocheck
+/**
+ * @param element
+ */
+function isTableElement(element) {
+    return ['table', 'td', 'th'].indexOf(getNodeName(element)) >= 0;
+}
+
+// @ts-nocheck
+/**
+ * @param element
+ */
+function getTrueOffsetParent(element) {
+    if (!isHTMLElement(element) || // https://github.com/popperjs/popper-core/issues/837
+        getComputedStyle$1(element).position === 'fixed') {
+        return null;
+    }
+    const offsetParent = element.offsetParent;
+    if (offsetParent) {
+        const html = getDocumentElement(offsetParent);
+        if (getNodeName(offsetParent) === 'body' &&
+            getComputedStyle$1(offsetParent).position === 'static' &&
+            getComputedStyle$1(html).position !== 'static') {
+            return html;
+        }
+    }
+    return offsetParent;
+}
+// `.offsetParent` reports `null` for fixed elements, while absolute elements
+// return the containing block
+/**
+ * @param element
+ */
+function getContainingBlock(element) {
+    let currentNode = getParentNode(element);
+    while (isHTMLElement(currentNode) && ['html', 'body'].indexOf(getNodeName(currentNode)) < 0) {
+        const css = getComputedStyle$1(currentNode);
+        // This is non-exhaustive but covers the most common CSS properties that
+        // create a containing block.
+        if (css.transform !== 'none' || css.perspective !== 'none' || (css.willChange && css.willChange !== 'auto')) {
+            return currentNode;
+        }
+        else {
+            currentNode = currentNode.parentNode;
+        }
+    }
+    return null;
+}
+// Gets the closest ancestor positioned element. Handles some edge cases,
+// such as table ancestors and cross browser bugs.
+/**
+ * @param element
+ */
+function getOffsetParent(element) {
+    const window = getWindow(element);
+    let offsetParent = getTrueOffsetParent(element);
+    while (offsetParent && isTableElement(offsetParent) && getComputedStyle$1(offsetParent).position === 'static') {
+        offsetParent = getTrueOffsetParent(offsetParent);
+    }
+    if (offsetParent && getNodeName(offsetParent) === 'body' && getComputedStyle$1(offsetParent).position === 'static') {
+        return window;
+    }
+    return offsetParent || getContainingBlock(element) || window;
+}
+
+// @ts-nocheck
+const top = 'top';
+const bottom = 'bottom';
+const right = 'right';
+const left = 'left';
+const auto = 'auto';
+const basePlacements = [top, bottom, right, left];
+const start = 'start';
+const end = 'end';
+const clippingParents = 'clippingParents';
+const viewport = 'viewport';
+const popper = 'popper';
+const reference = 'reference';
+const variationPlacements = basePlacements.reduce((acc, placement) => acc.concat([`${placement}-${start}`, `${placement}-${end}`]), []);
+const placements = [...basePlacements, auto].reduce((acc, placement) => acc.concat([placement, `${placement}-${start}`, `${placement}-${end}`]), []);
+// modifiers that need to read the DOM
+const beforeRead = 'beforeRead';
+const read = 'read';
+const afterRead = 'afterRead';
+// pure-logic modifiers
+const beforeMain = 'beforeMain';
+const main = 'main';
+const afterMain = 'afterMain';
+// modifier with the purpose to write to the DOM (or write into a framework state)
+const beforeWrite = 'beforeWrite';
+const write = 'write';
+const afterWrite = 'afterWrite';
+const modifierPhases = [
+    beforeRead,
+    read,
+    afterRead,
+    beforeMain,
+    main,
+    afterMain,
+    beforeWrite,
+    write,
+    afterWrite
+];
+
+// source: https://stackoverflow.com/questions/49875255
+/**
+ * @param modifiers
+ */
+function order(modifiers) {
+    const map = new Map();
+    const visited = new Set();
+    const result = [];
+    modifiers.forEach(modifier => {
+        map.set(modifier.name, modifier);
+    });
+    // On visiting object, check for its dependencies and visit them recursively
+    /**
+     * @param modifier
+     */
+    function sort(modifier) {
+        visited.add(modifier.name);
+        const requires = [...(modifier.requires || []), ...(modifier.requiresIfExists || [])];
+        requires.forEach(dep => {
+            if (!visited.has(dep)) {
+                const depModifier = map.get(dep);
+                if (depModifier) {
+                    sort(depModifier);
+                }
+            }
+        });
+        result.push(modifier);
+    }
+    modifiers.forEach(modifier => {
+        if (!visited.has(modifier.name)) {
+            // check for visited object
+            sort(modifier);
+        }
+    });
+    return result;
+}
+/**
+ * @param modifiers
+ */
+function orderModifiers(modifiers) {
+    // order based on dependencies
+    const orderedModifiers = order(modifiers);
+    // order based on phase
+    return modifierPhases.reduce((acc, phase) => acc.concat(orderedModifiers.filter(modifier => modifier.phase === phase)), []);
+}
+
+// @ts-nocheck
+/**
+ * @param fn
+ */
+function debounce(fn) {
+    let pending;
+    return () => {
+        if (!pending) {
+            pending = new Promise(resolve => {
+                Promise.resolve().then(() => {
+                    pending = undefined;
+                    resolve(fn());
+                });
+            });
+        }
+        return pending;
+    };
+}
+
+/**
+ * @param placement
+ */
+function getBasePlacement(placement) {
+    return placement.split('-')[0];
+}
+
+/**
+ * @param modifiers
+ */
+function mergeByName(modifiers) {
+    const merged = modifiers.reduce((merged, current) => {
+        const existing = merged[current.name];
+        merged[current.name] = existing
+            ? Object.assign(Object.assign(Object.assign({}, existing), current), { options: Object.assign(Object.assign({}, existing.options), current.options), data: Object.assign(Object.assign({}, existing.data), current.data) }) : current;
+        return merged;
+    }, {});
+    // IE11 does not support Object.values
+    return Object.keys(merged).map(key => merged[key]);
+}
+
+// @ts-nocheck
+/**
+ * @param element
+ */
+function getViewportRect(element) {
+    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;
+    // NB: This isn't supported on iOS <= 12. If the keyboard is open, the popper
+    // can be obscured underneath it.
+    // Also, `html.clientHeight` adds the bottom bar height in Safari iOS, even
+    // if it isn't open, so if this isn't available, the popper will be detected
+    // to overflow the bottom of the screen too early.
+    if (visualViewport) {
+        width = visualViewport.width;
+        height = visualViewport.height;
+        // Uses Layout Viewport (like Chrome; Safari does not currently)
+        // In Chrome, it returns a value very close to 0 (+/-) but contains rounding
+        // errors due to floating point numbers, so we need to check precision.
+        // Safari returns a number <= 0, usually < -1 when pinch-zoomed
+        // Feature detection fails in mobile emulation mode in Chrome.
+        // Math.abs(win.innerWidth / visualViewport.scale - visualViewport.width) <
+        // 0.001
+        // Fallback here: "Not Safari" userAgent
+        if (!/^((?!chrome|android).)*safari/i.test(navigator.userAgent)) {
+            x = visualViewport.offsetLeft;
+            y = visualViewport.offsetTop;
+        }
+    }
+    return {
+        width,
+        height,
+        x: x + getWindowScrollBarX(element),
+        y
+    };
+}
+
+// Gets the entire size of the scrollable document area, even extending outside
+// of the `<html>` and `<body>` rect bounds if horizontally scrollable
+/**
+ * @param element
+ */
+function getDocumentRect(element) {
+    const html = getDocumentElement(element);
+    const winScroll = getWindowScroll(element);
+    const body = element.ownerDocument.body;
+    const width = Math.max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
+    const height = Math.max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
+    let x = -winScroll.scrollLeft + getWindowScrollBarX(element);
+    const y = -winScroll.scrollTop;
+    if (getComputedStyle$1(body || html).direction === 'rtl') {
+        x += Math.max(html.clientWidth, body ? body.clientWidth : 0) - width;
+    }
+    return { width, height, x, y };
+}
+
+// @ts-nocheck
+/**
+ * @param parent
+ * @param child
+ */
+function contains(parent, child) {
+    // $FlowFixMe: hasOwnProperty doesn't seem to work in tests
+    const isShadow = Boolean(child.getRootNode && child.getRootNode().host);
+    // First, attempt with faster native method
+    if (parent.contains(child)) {
+        return true;
+    } // then fallback to custom implementation with Shadow DOM support
+    else if (isShadow) {
+        let next = child;
+        do {
+            if (next && parent.isSameNode(next)) {
+                return true;
+            }
+            // $FlowFixMe: need a better way to handle this...
+            next = next.parentNode || next.host;
+        } while (next);
+    }
+    // Give up, the result is false
+    return false;
+}
+
+/**
+ * @param rect
+ */
+function rectToClientRect(rect) {
+    return Object.assign(Object.assign({}, rect), { left: rect.x, top: rect.y, right: rect.x + rect.width, bottom: rect.y + rect.height });
+}
+
+/**
+ * @param element
+ */
+function getInnerBoundingClientRect(element) {
+    const rect = getBoundingClientRect(element);
+    rect.top = rect.top + element.clientTop;
+    rect.left = rect.left + element.clientLeft;
+    rect.bottom = rect.top + element.clientHeight;
+    rect.right = rect.left + element.clientWidth;
+    rect.width = element.clientWidth;
+    rect.height = element.clientHeight;
+    rect.x = rect.left;
+    rect.y = rect.top;
+    return rect;
+}
+/**
+ * @param element
+ * @param clippingParent
+ */
+function getClientRectFromMixedType(element, clippingParent) {
+    return clippingParent === viewport
+        ? rectToClientRect(getViewportRect(element))
+        : isHTMLElement(clippingParent)
+            ? getInnerBoundingClientRect(clippingParent)
+            : rectToClientRect(getDocumentRect(getDocumentElement(element)));
+}
+// A "clipping parent" is an overflowable container with the characteristic of
+// clipping (or hiding) overflowing elements with a position different from
+// `initial`
+/**
+ * @param element
+ */
+function getClippingParents(element) {
+    const clippingParents = listScrollParents(getParentNode(element));
+    const canEscapeClipping = ['absolute', 'fixed'].indexOf(getComputedStyle$1(element).position) >= 0;
+    const clipperElement = canEscapeClipping && isHTMLElement(element) ? getOffsetParent(element) : element;
+    if (!isElement(clipperElement)) {
+        return [];
+    }
+    // $FlowFixMe: https://github.com/facebook/flow/issues/1414
+    return clippingParents.filter(clippingParent => isElement(clippingParent) && contains(clippingParent, clipperElement) && getNodeName(clippingParent) !== 'body');
+}
+// Gets the maximum area that the element is visible in due to any number of
+// clipping parents
+/**
+ * @param element
+ * @param boundary
+ * @param rootBoundary
+ */
+function getClippingRect(element, boundary, rootBoundary) {
+    const mainClippingParents = boundary === 'clippingParents' ? getClippingParents(element) : [].concat(boundary);
+    const clippingParents = [...mainClippingParents, rootBoundary];
+    const firstClippingParent = clippingParents[0];
+    const clippingRect = clippingParents.reduce((accRect, clippingParent) => {
+        const rect = getClientRectFromMixedType(element, clippingParent);
+        accRect.top = Math.max(rect.top, accRect.top);
+        accRect.right = Math.min(rect.right, accRect.right);
+        accRect.bottom = Math.min(rect.bottom, accRect.bottom);
+        accRect.left = Math.max(rect.left, accRect.left);
+        return accRect;
+    }, getClientRectFromMixedType(element, firstClippingParent));
+    clippingRect.width = clippingRect.right - clippingRect.left;
+    clippingRect.height = clippingRect.bottom - clippingRect.top;
+    clippingRect.x = clippingRect.left;
+    clippingRect.y = clippingRect.top;
+    return clippingRect;
+}
+
+/**
+ * @param placement
+ */
+function getVariation(placement) {
+    return placement.split('-')[1];
+}
+
+/**
+ * @param placement
+ */
+function getMainAxisFromPlacement(placement) {
+    return ['top', 'bottom'].indexOf(placement) >= 0 ? 'x' : 'y';
+}
+
+// @ts-nocheck
+/**
+ *
+ */
+function computeOffsets({ reference, element, placement }) {
+    const basePlacement = placement ? getBasePlacement(placement) : null;
+    const variation = placement ? getVariation(placement) : null;
+    const commonX = reference.x + reference.width / 2 - element.width / 2;
+    const commonY = reference.y + reference.height / 2 - element.height / 2;
+    let offsets;
+    switch (basePlacement) {
+        case top:
+            offsets = {
+                x: commonX,
+                y: reference.y - element.height
+            };
+            break;
+        case bottom:
+            offsets = {
+                x: commonX,
+                y: reference.y + reference.height
+            };
+            break;
+        case right:
+            offsets = {
+                x: reference.x + reference.width,
+                y: commonY
+            };
+            break;
+        case left:
+            offsets = {
+                x: reference.x - element.width,
+                y: commonY
+            };
+            break;
+        default:
+            offsets = {
+                x: reference.x,
+                y: reference.y
+            };
+    }
+    const mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null;
+    if (mainAxis != null) {
+        const len = mainAxis === 'y' ? 'height' : 'width';
+        switch (variation) {
+            case start:
+                offsets[mainAxis] = Math.floor(offsets[mainAxis]) - Math.floor(reference[len] / 2 - element[len] / 2);
+                break;
+            case end:
+                offsets[mainAxis] = Math.floor(offsets[mainAxis]) + Math.ceil(reference[len] / 2 - element[len] / 2);
+                break;
+        }
+    }
+    return offsets;
+}
+
+/**
+ *
+ */
+function getFreshSideObject() {
+    return {
+        top: 0,
+        right: 0,
+        bottom: 0,
+        left: 0
+    };
+}
+
+/**
+ * @param paddingObject
+ */
+function mergePaddingObject(paddingObject) {
+    return Object.assign(Object.assign({}, getFreshSideObject()), paddingObject);
+}
+
+// @ts-nocheck
+/**
+ * @param value
+ * @param keys
+ */
+function expandToHashMap(value, keys) {
+    return keys.reduce((hashMap, key) => {
+        hashMap[key] = value;
+        return hashMap;
+    }, {});
+}
+
+/**
+ * @param state
+ * @param options
+ */
+function detectOverflow(state, options = {}) {
+    const { placement = state.placement, boundary = clippingParents, rootBoundary = viewport, elementContext = popper, altBoundary = false, padding = 0 } = options;
+    const paddingObject = mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements));
+    const altContext = elementContext === popper ? reference : popper;
+    const referenceElement = state.elements.reference;
+    const popperRect = state.rects.popper;
+    const element = state.elements[altBoundary ? altContext : elementContext];
+    const clippingClientRect = getClippingRect(isElement(element) ? element : element.contextElement || getDocumentElement(state.elements.popper), boundary, rootBoundary);
+    const referenceClientRect = getBoundingClientRect(referenceElement);
+    const popperOffsets = computeOffsets({
+        reference: referenceClientRect,
+        element: popperRect,
+        placement
+    });
+    const popperClientRect = rectToClientRect(Object.assign(Object.assign({}, popperRect), popperOffsets));
+    const elementClientRect = elementContext === popper ? popperClientRect : referenceClientRect;
+    // positive = overflowing the clipping rect
+    // 0 or negative = within the clipping rect
+    const overflowOffsets = {
+        top: clippingClientRect.top - elementClientRect.top + paddingObject.top,
+        bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom,
+        left: clippingClientRect.left - elementClientRect.left + paddingObject.left,
+        right: elementClientRect.right - clippingClientRect.right + paddingObject.right
+    };
+    const offsetData = state.modifiersData.offset;
+    // Offsets can be applied only to the popper element
+    if (elementContext === popper && offsetData) {
+        const offset = offsetData[placement];
+        Object.keys(overflowOffsets).forEach(key => {
+            const multiply = [right, bottom].indexOf(key) >= 0 ? 1 : -1;
+            const axis = [top, bottom].indexOf(key) >= 0 ? 'y' : 'x';
+            overflowOffsets[key] += offset[axis] * multiply;
+        });
+    }
+    return overflowOffsets;
+}
+
+const DEFAULT_OPTIONS = {
+    placement: 'bottom',
+    modifiers: [],
+    strategy: 'absolute'
+};
+/**
+ * @param args
+ */
+function areValidElements(...args) {
+    return !args.some(element => !(element && typeof element.getBoundingClientRect === 'function'));
+}
+/**
+ * @param generatorOptions
+ */
+function popperGenerator(generatorOptions = {}) {
+    const { defaultModifiers = [], defaultOptions = DEFAULT_OPTIONS } = generatorOptions;
+    return function createPopper(reference, popper, options = defaultOptions) {
+        let state = {
+            placement: 'bottom',
+            orderedModifiers: [],
+            options: Object.assign(Object.assign({}, DEFAULT_OPTIONS), defaultOptions),
+            modifiersData: {},
+            elements: {
+                reference,
+                popper
+            },
+            attributes: {},
+            styles: {}
+        };
+        let effectCleanupFns = [];
+        let isDestroyed = false;
+        const instance = {
+            state,
+            setOptions(options) {
+                cleanupModifierEffects();
+                state.options = Object.assign(Object.assign(Object.assign({}, defaultOptions), state.options), options);
+                state.scrollParents = {
+                    reference: isElement(reference)
+                        ? listScrollParents(reference)
+                        : reference.contextElement
+                            ? listScrollParents(reference.contextElement)
+                            : [],
+                    popper: listScrollParents(popper)
+                };
+                // Orders the modifiers based on their dependencies and `phase`
+                // properties
+                const orderedModifiers = orderModifiers(mergeByName([...defaultModifiers, ...state.options.modifiers]));
+                // Strip out disabled modifiers
+                state.orderedModifiers = orderedModifiers.filter(m => m.enabled);
+                runModifierEffects();
+                return instance.update();
+            },
+            // Sync update – it will always be executed, even if not necessary. This
+            // is useful for low frequency updates where sync behavior simplifies the
+            // logic.
+            // For high frequency updates (e.g. `resize` and `scroll` events), always
+            // prefer the async Popper#update method
+            forceUpdate() {
+                if (isDestroyed) {
+                    return;
+                }
+                const { reference, popper } = state.elements;
+                // Don't proceed if `reference` or `popper` are not valid elements
+                // anymore
+                if (!areValidElements(reference, popper)) {
+                    return;
+                }
+                // Store the reference and popper rects to be read by modifiers
+                state.rects = {
+                    reference: getCompositeRect(reference, getOffsetParent(popper), state.options.strategy === 'fixed'),
+                    popper: getLayoutRect(popper)
+                };
+                // Modifiers have the ability to reset the current update cycle. The
+                // most common use case for this is the `flip` modifier changing the
+                // placement, which then needs to re-run all the modifiers, because the
+                // logic was previously ran for the previous placement and is therefore
+                // stale/incorrect
+                state.reset = false;
+                state.placement = state.options.placement;
+                // On each update cycle, the `modifiersData` property for each modifier
+                // is filled with the initial data specified by the modifier. This means
+                // it doesn't persist and is fresh on each update.
+                // To ensure persistent data, use `${name}#persistent`
+                state.orderedModifiers.forEach(modifier => (state.modifiersData[modifier.name] = Object.assign({}, modifier.data)));
+                for (let index = 0; index < state.orderedModifiers.length; index++) {
+                    if (state.reset === true) {
+                        state.reset = false;
+                        index = -1;
+                        continue;
+                    }
+                    const { fn, options = {}, name } = state.orderedModifiers[index];
+                    if (typeof fn === 'function') {
+                        state = fn({ state, options, name, instance }) || state;
+                    }
+                }
+            },
+            // Async and optimistically optimized update – it will not be executed if
+            // not necessary (debounced to run at most once-per-tick)
+            update: debounce(() => new Promise(resolve => {
+                instance.forceUpdate();
+                resolve(state);
+            })),
+            destroy() {
+                cleanupModifierEffects();
+                isDestroyed = true;
+            }
+        };
+        if (!areValidElements(reference, popper)) {
+            return instance;
+        }
+        instance.setOptions(options).then(state => {
+            if (!isDestroyed && options.onFirstUpdate) {
+                options.onFirstUpdate(state);
+            }
+        });
+        // Modifiers have the ability to execute arbitrary code before the first
+        // update cycle runs. They will be executed in the same order as the update
+        // cycle. This is useful when a modifier adds some persistent data that
+        // other modifiers need to use, but the modifier is run after the dependent
+        // one.
+        /**
+         *
+         */
+        function runModifierEffects() {
+            state.orderedModifiers.forEach(({ name, options = {}, effect }) => {
+                if (typeof effect === 'function') {
+                    const cleanupFn = effect({ state, name, instance, options });
+                    const noopFn = () => { };
+                    effectCleanupFns.push(cleanupFn || noopFn);
+                }
+            });
+        }
+        /**
+         *
+         */
+        function cleanupModifierEffects() {
+            effectCleanupFns.forEach(fn => fn());
+            effectCleanupFns = [];
+        }
+        return instance;
+    };
+}
+popperGenerator();
+
+const passive = { passive: true };
+/**
+ *
+ */
+function effect$2({ state, instance, options }) {
+    const { scroll = true, resize = true } = options;
+    const window = getWindow(state.elements.popper);
+    const scrollParents = [...state.scrollParents.reference, ...state.scrollParents.popper];
+    if (scroll) {
+        scrollParents.forEach(scrollParent => {
+            scrollParent.addEventListener('scroll', instance.update, passive);
+        });
+    }
+    if (resize) {
+        window.addEventListener('resize', instance.update, passive);
+    }
+    return () => {
+        if (scroll) {
+            scrollParents.forEach(scrollParent => {
+                scrollParent.removeEventListener('scroll', instance.update, passive);
+            });
+        }
+        if (resize) {
+            window.removeEventListener('resize', instance.update, passive);
+        }
+    };
+}
+const eventListeners = {
+    name: 'eventListeners',
+    enabled: true,
+    phase: 'write',
+    fn: () => { },
+    effect: effect$2,
+    data: {}
+};
+
+/**
+ *
+ */
+function popperOffsets({ state, name }) {
+    // Offsets are the actual position the popper needs to have to be
+    // properly positioned near its reference element
+    // This is the most basic placement, and will be adjusted by
+    // the modifiers in the next step
+    state.modifiersData[name] = computeOffsets({
+        reference: state.rects.reference,
+        element: state.rects.popper,
+        placement: state.placement
+    });
+}
+const popperOffsets$1 = {
+    name: 'popperOffsets',
+    enabled: true,
+    phase: 'read',
+    fn: popperOffsets,
+    data: {}
+};
+
+const unsetSides = {
+    top: 'auto',
+    right: 'auto',
+    bottom: 'auto',
+    left: 'auto'
+};
+// Round the offsets to the nearest suitable subpixel based on the DPR.
+// Zooming can change the DPR, but it seems to report a value that will
+// cleanly divide the values into the appropriate subpixels.
+/**
+ *
+ */
+function roundOffsets({ x, y }) {
+    const win = window;
+    const dpr = win.devicePixelRatio || 1;
+    return {
+        x: Math.round(x * dpr) / dpr || 0,
+        y: Math.round(y * dpr) / dpr || 0
+    };
+}
+/**
+ *
+ */
+function mapToStyles({ popper, popperRect, placement, offsets, position, gpuAcceleration, adaptive }) {
+    let { x, y } = roundOffsets(offsets);
+    const hasX = offsets.hasOwnProperty('x');
+    const hasY = offsets.hasOwnProperty('y');
+    let sideX = left;
+    let sideY = top;
+    const win = window;
+    if (adaptive) {
+        let offsetParent = getOffsetParent(popper);
+        if (offsetParent === getWindow(popper)) {
+            offsetParent = getDocumentElement(popper);
+        }
+        // $FlowFixMe: force type refinement, we compare offsetParent with window above, but Flow doesn't detect it
+        /* :: offsetParent = (offsetParent: Element); */
+        if (placement === top) {
+            sideY = bottom;
+            y -= offsetParent.clientHeight - popperRect.height;
+            y *= gpuAcceleration ? 1 : -1;
+        }
+        if (placement === left) {
+            sideX = right;
+            x -= offsetParent.clientWidth - popperRect.width;
+            x *= gpuAcceleration ? 1 : -1;
+        }
+    }
+    const commonStyles = Object.assign({ position }, (adaptive && unsetSides));
+    if (gpuAcceleration) {
+        return Object.assign(Object.assign({}, commonStyles), { [sideY]: hasY ? '0' : '', [sideX]: hasX ? '0' : '', 
+            // Layer acceleration can disable subpixel rendering which causes slightly
+            // blurry text on low PPI displays, so we want to use 2D transforms
+            // instead
+            transform: (win.devicePixelRatio || 1) < 2 ? `translate(${x}px, ${y}px)` : `translate3d(${x}px, ${y}px, 0)` });
+    }
+    return Object.assign(Object.assign({}, commonStyles), { [sideY]: hasY ? `${y}px` : '', [sideX]: hasX ? `${x}px` : '', transform: '' });
+}
+/**
+ *
+ */
+function computeStyles({ state, options }) {
+    const { gpuAcceleration = true, adaptive = true } = options;
+    const commonStyles = {
+        placement: getBasePlacement(state.placement),
+        popper: state.elements.popper,
+        popperRect: state.rects.popper,
+        gpuAcceleration
+    };
+    if (state.modifiersData.popperOffsets != null) {
+        state.styles.popper = Object.assign(Object.assign({}, state.styles.popper), mapToStyles(Object.assign(Object.assign({}, commonStyles), { offsets: state.modifiersData.popperOffsets, position: state.options.strategy, adaptive })));
+    }
+    if (state.modifiersData.arrow != null) {
+        state.styles.arrow = Object.assign(Object.assign({}, state.styles.arrow), mapToStyles(Object.assign(Object.assign({}, commonStyles), { offsets: state.modifiersData.arrow, position: 'absolute', adaptive: false })));
+    }
+    state.attributes.popper = Object.assign(Object.assign({}, state.attributes.popper), { 'data-popper-placement': state.placement });
+}
+const computeStyles$1 = {
+    name: 'computeStyles',
+    enabled: true,
+    phase: 'beforeWrite',
+    fn: computeStyles,
+    data: {}
+};
+
+// This modifier takes the styles prepared by the `computeStyles` modifier
+// and applies them to the HTMLElements such as popper and arrow
+/**
+ *
+ */
+function applyStyles({ state }) {
+    Object.keys(state.elements).forEach(name => {
+        const style = state.styles[name] || {};
+        const attributes = state.attributes[name] || {};
+        const element = state.elements[name];
+        // arrow is optional + virtual elements
+        if (!isHTMLElement(element) || !getNodeName(element)) {
+            return;
+        }
+        // Flow doesn't support to extend this property, but it's the most
+        // effective way to apply styles to an HTMLElement
+        // $FlowFixMe
+        Object.assign(element.style, style);
+        Object.keys(attributes).forEach(name => {
+            const value = attributes[name];
+            if (value === false) {
+                element.removeAttribute(name);
+            }
+            else {
+                element.setAttribute(name, value === true ? '' : value);
+            }
+        });
+    });
+}
+/**
+ *
+ */
+function effect$1({ state }) {
+    const initialStyles = {
+        popper: {
+            position: state.options.strategy,
+            left: '0',
+            top: '0',
+            margin: '0'
+        },
+        arrow: {
+            position: 'absolute'
+        },
+        reference: {}
+    };
+    Object.assign(state.elements.popper.style, initialStyles.popper);
+    if (state.elements.arrow) {
+        Object.assign(state.elements.arrow.style, initialStyles.arrow);
+    }
+    return () => {
+        Object.keys(state.elements).forEach(name => {
+            const element = state.elements[name];
+            const attributes = state.attributes[name] || {};
+            const styleProperties = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]);
+            // Set all values to an empty string to unset them
+            const style = styleProperties.reduce((style, property) => {
+                style[property] = '';
+                return style;
+            }, {});
+            // arrow is optional + virtual elements
+            if (!isHTMLElement(element) || !getNodeName(element)) {
+                return;
+            }
+            // Flow doesn't support to extend this property, but it's the most
+            // effective way to apply styles to an HTMLElement
+            // $FlowFixMe
+            Object.assign(element.style, style);
+            Object.keys(attributes).forEach(attribute => {
+                element.removeAttribute(attribute);
+            });
+        });
+    };
+}
+const applyStyles$1 = {
+    name: 'applyStyles',
+    enabled: true,
+    phase: 'write',
+    fn: applyStyles,
+    effect: effect$1,
+    requires: ['computeStyles']
+};
+
+/**
+ * @param placement
+ * @param rects
+ * @param offset
+ */
+function distanceAndSkiddingToXY(placement, rects, offset) {
+    const basePlacement = getBasePlacement(placement);
+    const invertDistance = [left, top].indexOf(basePlacement) >= 0 ? -1 : 1;
+    let [skidding, distance] = typeof offset === 'function'
+        ? offset(Object.assign(Object.assign({}, rects), { placement }))
+        : offset;
+    skidding = skidding || 0;
+    distance = (distance || 0) * invertDistance;
+    return [left, right].indexOf(basePlacement) >= 0 ? { x: distance, y: skidding } : { x: skidding, y: distance };
+}
+/**
+ *
+ */
+function offset({ state, options, name }) {
+    const { offset = [0, 0] } = options;
+    const data = placements.reduce((acc, placement) => {
+        acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset);
+        return acc;
+    }, {});
+    const { x, y } = data[state.placement];
+    if (state.modifiersData.popperOffsets != null) {
+        state.modifiersData.popperOffsets.x += x;
+        state.modifiersData.popperOffsets.y += y;
+    }
+    state.modifiersData[name] = data;
+}
+const offset$1 = {
+    name: 'offset',
+    enabled: true,
+    phase: 'main',
+    requires: ['popperOffsets'],
+    fn: offset
+};
+
+const hash$2 = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' };
+/**
+ * @param placement
+ */
+function getOppositePlacement$1(placement) {
+    return placement.replace(/left|right|bottom|top/g, matched => hash$2[matched]);
+}
+
+const hash$1 = { start: 'end', end: 'start' };
+/**
+ * @param placement
+ */
+function getOppositeVariationPlacement(placement) {
+    return placement.replace(/start|end/g, matched => hash$1[matched]);
+}
+
+/* :: type OverflowsMap = { [ComputedPlacement]: number }; */
+/* ;; type OverflowsMap = { [key in ComputedPlacement]: number }; */
+/**
+ * @param state
+ * @param options
+ */
+function computeAutoPlacement(state, options = {}) {
+    const { placement, boundary, rootBoundary, padding, flipVariations, allowedAutoPlacements = placements } = options;
+    const variation = getVariation(placement);
+    const placements$1 = variation
+        ? flipVariations
+            ? variationPlacements
+            : variationPlacements.filter(placement => getVariation(placement) === variation)
+        : basePlacements;
+    // $FlowFixMe
+    let allowedPlacements = placements$1.filter(placement => allowedAutoPlacements.indexOf(placement) >= 0);
+    if (allowedPlacements.length === 0) {
+        allowedPlacements = placements$1;
+    }
+    // $FlowFixMe: Flow seems to have problems with two array unions...
+    const overflows = allowedPlacements.reduce((acc, placement) => {
+        acc[placement] = detectOverflow(state, {
+            placement,
+            boundary,
+            rootBoundary,
+            padding
+        })[getBasePlacement(placement)];
+        return acc;
+    }, {});
+    return Object.keys(overflows).sort((a, b) => overflows[a] - overflows[b]);
+}
+
+/**
+ * @param placement
+ */
+function getExpandedFallbackPlacements(placement) {
+    if (getBasePlacement(placement) === auto) {
+        return [];
+    }
+    const oppositePlacement = getOppositePlacement$1(placement);
+    return [
+        getOppositeVariationPlacement(placement),
+        oppositePlacement,
+        getOppositeVariationPlacement(oppositePlacement)
+    ];
+}
+/**
+ *
+ */
+function flip({ state, options, name }) {
+    if (state.modifiersData[name]._skip) {
+        return;
+    }
+    const { mainAxis: checkMainAxis = true, altAxis: checkAltAxis = true, fallbackPlacements: specifiedFallbackPlacements, padding, boundary, rootBoundary, altBoundary, flipVariations = true, allowedAutoPlacements } = options;
+    const preferredPlacement = state.options.placement;
+    const basePlacement = getBasePlacement(preferredPlacement);
+    const isBasePlacement = basePlacement === preferredPlacement;
+    const fallbackPlacements = specifiedFallbackPlacements ||
+        (isBasePlacement || !flipVariations
+            ? [getOppositePlacement$1(preferredPlacement)]
+            : getExpandedFallbackPlacements(preferredPlacement));
+    const placements = [preferredPlacement, ...fallbackPlacements].reduce((acc, placement) => acc.concat(getBasePlacement(placement) === auto
+        ? computeAutoPlacement(state, {
+            placement,
+            boundary,
+            rootBoundary,
+            padding,
+            flipVariations,
+            allowedAutoPlacements
+        })
+        : placement), []);
+    const referenceRect = state.rects.reference;
+    const popperRect = state.rects.popper;
+    const checksMap = new Map();
+    let makeFallbackChecks = true;
+    let firstFittingPlacement = placements[0];
+    for (let i = 0; i < placements.length; i++) {
+        const placement = placements[i];
+        const basePlacement = getBasePlacement(placement);
+        const isStartVariation = getVariation(placement) === start;
+        const isVertical = [top, bottom].indexOf(basePlacement) >= 0;
+        const len = isVertical ? 'width' : 'height';
+        const overflow = detectOverflow(state, {
+            placement,
+            boundary,
+            rootBoundary,
+            altBoundary,
+            padding
+        });
+        let mainVariationSide = isVertical ? (isStartVariation ? right : left) : isStartVariation ? bottom : top;
+        if (referenceRect[len] > popperRect[len]) {
+            mainVariationSide = getOppositePlacement$1(mainVariationSide);
+        }
+        const altVariationSide = getOppositePlacement$1(mainVariationSide);
+        const checks = [];
+        if (checkMainAxis) {
+            checks.push(overflow[basePlacement] <= 0);
+        }
+        if (checkAltAxis) {
+            checks.push(overflow[mainVariationSide] <= 0, overflow[altVariationSide] <= 0);
+        }
+        if (checks.every(check => check)) {
+            firstFittingPlacement = placement;
+            makeFallbackChecks = false;
+            break;
+        }
+        checksMap.set(placement, checks);
+    }
+    if (makeFallbackChecks) {
+        // `2` may be desired in some cases – research later
+        const numberOfChecks = flipVariations ? 3 : 1;
+        for (let i = numberOfChecks; i > 0; i--) {
+            const fittingPlacement = placements.find(placement => {
+                const checks = checksMap.get(placement);
+                if (checks) {
+                    return checks.slice(0, i).every(check => check);
+                }
+            });
+            if (fittingPlacement) {
+                firstFittingPlacement = fittingPlacement;
+                break;
+            }
+        }
+    }
+    if (state.placement !== firstFittingPlacement) {
+        state.modifiersData[name]._skip = true;
+        state.placement = firstFittingPlacement;
+        state.reset = true;
+    }
+}
+const flip$1 = {
+    name: 'flip',
+    enabled: true,
+    phase: 'main',
+    fn: flip,
+    requiresIfExists: ['offset'],
+    data: { _skip: false }
+};
+
+// @ts-nocheck
+/**
+ * @param axis
+ */
+function getAltAxis(axis) {
+    return axis === 'x' ? 'y' : 'x';
+}
+
+// @ts-nocheck
+/**
+ * @param min
+ * @param value
+ * @param max
+ */
+function within(min, value, max) {
+    return Math.max(min, Math.min(value, max));
+}
+
+// @ts-nocheck
+/**
+ *
+ */
+function preventOverflow({ state, options, name }) {
+    const { mainAxis: checkMainAxis = true, altAxis: checkAltAxis = false, boundary, rootBoundary, altBoundary, padding, tether = true, tetherOffset = 0 } = options;
+    const overflow = detectOverflow(state, {
+        boundary,
+        rootBoundary,
+        padding,
+        altBoundary
+    });
+    const basePlacement = getBasePlacement(state.placement);
+    const variation = getVariation(state.placement);
+    const isBasePlacement = !variation;
+    const mainAxis = getMainAxisFromPlacement(basePlacement);
+    const altAxis = getAltAxis(mainAxis);
+    const popperOffsets = state.modifiersData.popperOffsets;
+    const referenceRect = state.rects.reference;
+    const popperRect = state.rects.popper;
+    const tetherOffsetValue = typeof tetherOffset === 'function'
+        ? tetherOffset(Object.assign(Object.assign({}, state.rects), { placement: state.placement }))
+        : tetherOffset;
+    const data = { x: 0, y: 0 };
+    if (!popperOffsets) {
+        return;
+    }
+    if (checkMainAxis) {
+        const mainSide = mainAxis === 'y' ? top : left;
+        const altSide = mainAxis === 'y' ? bottom : right;
+        const len = mainAxis === 'y' ? 'height' : 'width';
+        const offset = popperOffsets[mainAxis];
+        const min = popperOffsets[mainAxis] + overflow[mainSide];
+        const max = popperOffsets[mainAxis] - overflow[altSide];
+        const additive = tether ? -popperRect[len] / 2 : 0;
+        const minLen = variation === start ? referenceRect[len] : popperRect[len];
+        const maxLen = variation === start ? -popperRect[len] : -referenceRect[len];
+        // We need to include the arrow in the calculation so the arrow doesn't go
+        // outside the reference bounds
+        const arrowElement = state.elements.arrow;
+        const arrowRect = tether && arrowElement ? getLayoutRect(arrowElement) : { width: 0, height: 0 };
+        const arrowPaddingObject = state.modifiersData['arrow#persistent']
+            ? state.modifiersData['arrow#persistent'].padding
+            : getFreshSideObject();
+        const arrowPaddingMin = arrowPaddingObject[mainSide];
+        const arrowPaddingMax = arrowPaddingObject[altSide];
+        // If the reference length is smaller than the arrow length, we don't want
+        // to include its full size in the calculation. If the reference is small
+        // and near the edge of a boundary, the popper can overflow even if the
+        // reference is not overflowing as well (e.g. virtual elements with no
+        // width or height)
+        const arrowLen = within(0, referenceRect[len], arrowRect[len]);
+        const minOffset = isBasePlacement
+            ? referenceRect[len] / 2 - additive - arrowLen - arrowPaddingMin - tetherOffsetValue
+            : minLen - arrowLen - arrowPaddingMin - tetherOffsetValue;
+        const maxOffset = isBasePlacement
+            ? -referenceRect[len] / 2 + additive + arrowLen + arrowPaddingMax + tetherOffsetValue
+            : maxLen + arrowLen + arrowPaddingMax + tetherOffsetValue;
+        const arrowOffsetParent = state.elements.arrow && getOffsetParent(state.elements.arrow);
+        const clientOffset = arrowOffsetParent
+            ? mainAxis === 'y'
+                ? arrowOffsetParent.clientTop || 0
+                : arrowOffsetParent.clientLeft || 0
+            : 0;
+        const offsetModifierValue = state.modifiersData.offset ? state.modifiersData.offset[state.placement][mainAxis] : 0;
+        const tetherMin = popperOffsets[mainAxis] + minOffset - offsetModifierValue - clientOffset;
+        const tetherMax = popperOffsets[mainAxis] + maxOffset - offsetModifierValue;
+        const preventedOffset = within(tether ? Math.min(min, tetherMin) : min, offset, tether ? Math.max(max, tetherMax) : max);
+        popperOffsets[mainAxis] = preventedOffset;
+        data[mainAxis] = preventedOffset - offset;
+    }
+    if (checkAltAxis) {
+        const mainSide = mainAxis === 'x' ? top : left;
+        const altSide = mainAxis === 'x' ? bottom : right;
+        const offset = popperOffsets[altAxis];
+        const min = offset + overflow[mainSide];
+        const max = offset - overflow[altSide];
+        const preventedOffset = within(min, offset, max);
+        popperOffsets[altAxis] = preventedOffset;
+        data[altAxis] = preventedOffset - offset;
+    }
+    state.modifiersData[name] = data;
+}
+const preventOverflow$1 = {
+    name: 'preventOverflow',
+    enabled: true,
+    phase: 'main',
+    fn: preventOverflow,
+    requiresIfExists: ['offset']
+};
+
+/**
+ *
+ */
+function arrow({ state, name }) {
+    const arrowElement = state.elements.arrow;
+    const popperOffsets = state.modifiersData.popperOffsets;
+    const basePlacement = getBasePlacement(state.placement);
+    const axis = getMainAxisFromPlacement(basePlacement);
+    const isVertical = [left, right].indexOf(basePlacement) >= 0;
+    const len = isVertical ? 'height' : 'width';
+    if (!arrowElement || !popperOffsets) {
+        return;
+    }
+    const paddingObject = state.modifiersData[`${name}#persistent`].padding;
+    const arrowRect = getLayoutRect(arrowElement);
+    const minProp = axis === 'y' ? top : left;
+    const maxProp = axis === 'y' ? bottom : right;
+    const endDiff = state.rects.reference[len] + state.rects.reference[axis] - popperOffsets[axis] - state.rects.popper[len];
+    const startDiff = popperOffsets[axis] - state.rects.reference[axis];
+    const arrowOffsetParent = getOffsetParent(arrowElement);
+    const clientSize = arrowOffsetParent
+        ? axis === 'y'
+            ? arrowOffsetParent.clientHeight || 0
+            : arrowOffsetParent.clientWidth || 0
+        : 0;
+    const centerToReference = endDiff / 2 - startDiff / 2;
+    // Make sure the arrow doesn't overflow the popper if the center point is
+    // outside of the popper bounds
+    const min = paddingObject[minProp];
+    const max = clientSize - arrowRect[len] - paddingObject[maxProp];
+    const center = clientSize / 2 - arrowRect[len] / 2 + centerToReference;
+    const offset = within(min, center, max);
+    // Prevents breaking syntax highlighting...
+    const axisProp = axis;
+    state.modifiersData[name] = {
+        [axisProp]: offset,
+        centerOffset: offset - center
+    };
+}
+/**
+ *
+ */
+function effect({ state, options, name }) {
+    let { element: arrowElement = '[data-popper-arrow]', padding = 0 } = options;
+    if (arrowElement == null) {
+        return;
+    }
+    // CSS selector
+    if (typeof arrowElement === 'string') {
+        arrowElement = state.elements.popper.querySelector(arrowElement);
+        if (!arrowElement) {
+            return;
+        }
+    }
+    if (!contains(state.elements.popper, arrowElement)) {
+        return;
+    }
+    state.elements.arrow = arrowElement;
+    state.modifiersData[`${name}#persistent`] = {
+        padding: mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements))
+    };
+}
+const arrow$1 = {
+    name: 'arrow',
+    enabled: true,
+    phase: 'main',
+    fn: arrow,
+    effect,
+    requires: ['popperOffsets'],
+    requiresIfExists: ['preventOverflow']
+};
+
+/**
+ * @param overflow
+ * @param rect
+ * @param preventedOffsets
+ */
+function getSideOffsets(overflow, rect, preventedOffsets = { x: 0, y: 0 }) {
+    return {
+        top: overflow.top - rect.height - preventedOffsets.y,
+        right: overflow.right - rect.width + preventedOffsets.x,
+        bottom: overflow.bottom - rect.height + preventedOffsets.y,
+        left: overflow.left - rect.width - preventedOffsets.x
+    };
+}
+/**
+ * @param overflow
+ */
+function isAnySideFullyClipped(overflow) {
+    return [top, right, bottom, left].some(side => overflow[side] >= 0);
+}
+/**
+ *
+ */
+function hide({ state, name }) {
+    const referenceRect = state.rects.reference;
+    const popperRect = state.rects.popper;
+    const preventedOffsets = state.modifiersData.preventOverflow;
+    const referenceOverflow = detectOverflow(state, {
+        elementContext: 'reference'
+    });
+    const popperAltOverflow = detectOverflow(state, {
+        altBoundary: true
+    });
+    const referenceClippingOffsets = getSideOffsets(referenceOverflow, referenceRect);
+    const popperEscapeOffsets = getSideOffsets(popperAltOverflow, popperRect, preventedOffsets);
+    const isReferenceHidden = isAnySideFullyClipped(referenceClippingOffsets);
+    const hasPopperEscaped = isAnySideFullyClipped(popperEscapeOffsets);
+    state.modifiersData[name] = {
+        referenceClippingOffsets,
+        popperEscapeOffsets,
+        isReferenceHidden,
+        hasPopperEscaped
+    };
+    state.attributes.popper = Object.assign(Object.assign({}, state.attributes.popper), { 'data-popper-reference-hidden': isReferenceHidden, 'data-popper-escaped': hasPopperEscaped });
+}
+const hide$1 = {
+    name: 'hide',
+    enabled: true,
+    phase: 'main',
+    requiresIfExists: ['preventOverflow'],
+    fn: hide
+};
+
+// @ts-nocheck
+const defaultModifiers = [
+    eventListeners,
+    popperOffsets$1,
+    computeStyles$1,
+    applyStyles$1,
+    offset$1,
+    flip$1,
+    preventOverflow$1,
+    arrow$1,
+    hide$1
+];
+const createPopper = popperGenerator({ defaultModifiers });
+
+/**
+ * Small wrapper around `useLayoutEffect` to get rid of the warning on SSR envs
+ */
+const useIsomorphicLayoutEffect = canUseDOM ? React.useLayoutEffect : React.useEffect;
+
+/* eslint-disable @typescript-eslint/consistent-type-definitions */
+const isEqual = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+/**
+ * Simple ponyfill for Object.fromEntries
+ */
+const fromEntries = (entries) => entries.reduce((acc, [key, value]) => {
+    acc[key] = value;
+    return acc;
+}, {});
+const EMPTY_MODIFIERS = [];
+const usePopper = (referenceElement, popperElement, options = {}) => {
+    const prevOptions = React.useRef(null);
+    const optionsWithDefaults = {
+        onFirstUpdate: options.onFirstUpdate,
+        placement: options.placement || 'bottom',
+        strategy: options.strategy || 'absolute',
+        modifiers: options.modifiers || EMPTY_MODIFIERS
+    };
+    const [state, setState] = React.useState({
+        styles: {
+            popper: {
+                position: optionsWithDefaults.strategy,
+                left: '0',
+                top: '0'
+            }
+        },
+        attributes: {}
+    });
+    const updateStateModifier = React.useMemo(() => ({
+        name: 'updateState',
+        enabled: true,
+        phase: 'write',
+        // eslint-disable-next-line no-shadow
+        fn: ({ state }) => {
+            const elements = Object.keys(state.elements);
+            setState({
+                styles: fromEntries(elements.map(element => [element, state.styles[element] || {}])),
+                attributes: fromEntries(elements.map(element => [element, state.attributes[element]]))
+            });
+        },
+        requires: ['computeStyles']
+    }), []);
+    const popperOptions = React.useMemo(() => {
+        const newOptions = {
+            onFirstUpdate: optionsWithDefaults.onFirstUpdate,
+            placement: optionsWithDefaults.placement,
+            strategy: optionsWithDefaults.strategy,
+            modifiers: [...optionsWithDefaults.modifiers, updateStateModifier, { name: 'applyStyles', enabled: false }]
+        };
+        if (isEqual(prevOptions.current, newOptions)) {
+            return prevOptions.current || newOptions;
+        }
+        else {
+            prevOptions.current = newOptions;
+            return newOptions;
+        }
+    }, [
+        optionsWithDefaults.onFirstUpdate,
+        optionsWithDefaults.placement,
+        optionsWithDefaults.strategy,
+        optionsWithDefaults.modifiers,
+        updateStateModifier
+    ]);
+    const popperInstanceRef = React.useRef();
+    useIsomorphicLayoutEffect(() => {
+        if (popperInstanceRef && popperInstanceRef.current) {
+            popperInstanceRef.current.setOptions(popperOptions);
+        }
+    }, [popperOptions]);
+    useIsomorphicLayoutEffect(() => {
+        if (referenceElement == null || popperElement == null) {
+            return;
+        }
+        const createPopper$1 = options.createPopper || createPopper;
+        const popperInstance = createPopper$1(referenceElement, popperElement, popperOptions);
+        popperInstanceRef.current = popperInstance;
+        return () => {
+            popperInstance.destroy();
+            popperInstanceRef.current = null;
+        };
+    }, [referenceElement, popperElement, options.createPopper]);
+    return {
+        state: popperInstanceRef.current ? popperInstanceRef.current.state : null,
+        styles: state.styles,
+        attributes: state.attributes,
+        update: popperInstanceRef.current ? popperInstanceRef.current.update : null,
+        forceUpdate: popperInstanceRef.current ? popperInstanceRef.current.forceUpdate : null
+    };
+};
+
+const hash = {
+    left: 'right',
+    right: 'left',
+    bottom: 'top',
+    top: 'bottom',
+    'top-start': 'bottom-end',
+    'top-end': 'bottom-start',
+    'bottom-start': 'top-end',
+    'bottom-end': 'top-start',
+    'left-start': 'right-end',
+    'left-end': 'right-start',
+    'right-start': 'left-end',
+    'right-end': 'left-start'
+};
+const getOppositePlacement = (placement) => placement.replace(/left|right|bottom|top|top-start|top-end|bottom-start|bottom-end|right-start|right-end|left-start|left-end/g, (matched) => hash[matched]);
+const getOpacityTransition = (animationDuration) => `opacity ${animationDuration}ms cubic-bezier(.54, 1.5, .38, 1.11)`;
+const Popper = ({ trigger, popper, direction = 'down', position = 'start', placement, width, minWidth = 'trigger', maxWidth, appendTo = () => document.body, zIndex = 9999, isVisible = true, positionModifiers, distance = 0, onMouseEnter, onMouseLeave, onFocus, onBlur, onDocumentClick, onTriggerClick, onTriggerEnter, onPopperClick, onPopperMouseEnter, onPopperMouseLeave, onDocumentKeyDown, enableFlip = true, flipBehavior = 'flip', triggerRef, popperRef, animationDuration = 0, entryDelay = 0, exitDelay = 0, onHidden = () => { }, onHide = () => { }, onMount = () => { }, onShow = () => { }, onShown = () => { }, preventOverflow = false }) => {
+    var _a;
+    const [triggerElement, setTriggerElement] = React.useState(null);
+    const [refElement, setRefElement] = React.useState(null);
+    const [popperElement, setPopperElement] = React.useState(null);
+    const [popperContent, setPopperContent] = React.useState(null);
+    const [ready, setReady] = React.useState(false);
+    const [opacity, setOpacity] = React.useState(0);
+    const [internalIsVisible, setInternalIsVisible] = React.useState(isVisible);
+    const transitionTimerRef = React.useRef(null);
+    const showTimerRef = React.useRef(null);
+    const hideTimerRef = React.useRef(null);
+    const prevExitDelayRef = React.useRef();
+    const refOrTrigger = refElement || triggerElement;
+    const showPopper = isVisible || internalIsVisible;
+    const triggerParent = (_a = ((triggerRef === null || triggerRef === void 0 ? void 0 : triggerRef.current) || triggerElement)) === null || _a === void 0 ? void 0 : _a.parentElement;
+    const languageDirection = getLanguageDirection(triggerParent);
+    const internalPosition = React.useMemo(() => {
+        const fixedPositions = { left: 'left', right: 'right', center: 'center' };
+        const positionMap = {
+            ltr: Object.assign({ start: 'left', end: 'right' }, fixedPositions),
+            rtl: Object.assign({ start: 'right', end: 'left' }, fixedPositions)
+        };
+        return positionMap[languageDirection][position];
+    }, [position, languageDirection]);
+    const onDocumentClickCallback = React.useCallback((event) => onDocumentClick(event, refOrTrigger, popperElement), [showPopper, triggerElement, refElement, popperElement, onDocumentClick]);
+    React.useEffect(() => {
+        setReady(true);
+        onMount();
+    }, []);
+    // Cancel all timers on unmount
+    React.useEffect(() => () => {
+        clearTimeouts([transitionTimerRef, hideTimerRef, showTimerRef]);
+    }, []);
+    React.useEffect(() => {
+        if (triggerRef) {
+            if (triggerRef.current) {
+                setRefElement(triggerRef.current);
+            }
+            else if (typeof triggerRef === 'function') {
+                setRefElement(triggerRef());
+            }
+        }
+    }, [triggerRef, trigger]);
+    React.useEffect(() => {
+        // When the popperRef is defined or the popper visibility changes, ensure the popper element is up to date
+        if (popperRef) {
+            if (popperRef.current) {
+                setPopperElement(popperRef.current);
+            }
+            else if (typeof popperRef === 'function') {
+                setPopperElement(popperRef());
+            }
+        }
+    }, [showPopper, popperRef]);
+    React.useEffect(() => {
+        // Trigger a Popper update when content changes.
+        const observer = new MutationObserver(() => {
+            update && update();
+        });
+        popperElement && observer.observe(popperElement, { attributes: true, childList: true, subtree: true });
+        return () => {
+            observer.disconnect();
+        };
+    }, [popperElement]);
+    const addEventListener = (listener, element, event, capture = false) => {
+        if (listener && element) {
+            element.addEventListener(event, listener, { capture });
+        }
+    };
+    const removeEventListener = (listener, element, event, capture = false) => {
+        if (listener && element) {
+            element.removeEventListener(event, listener, { capture });
+        }
+    };
+    React.useEffect(() => {
+        addEventListener(onMouseEnter, refOrTrigger, 'mouseenter');
+        addEventListener(onMouseLeave, refOrTrigger, 'mouseleave');
+        addEventListener(onFocus, refOrTrigger, 'focus');
+        addEventListener(onBlur, refOrTrigger, 'blur');
+        addEventListener(onTriggerClick, refOrTrigger, 'click');
+        addEventListener(onTriggerEnter, refOrTrigger, 'keydown');
+        addEventListener(onPopperClick, popperElement, 'click');
+        addEventListener(onPopperMouseEnter, popperElement, 'mouseenter');
+        addEventListener(onPopperMouseLeave, popperElement, 'mouseleave');
+        onDocumentClick && addEventListener(onDocumentClickCallback, document, 'click', true);
+        addEventListener(onDocumentKeyDown, document, 'keydown', true);
+        return () => {
+            removeEventListener(onMouseEnter, refOrTrigger, 'mouseenter');
+            removeEventListener(onMouseLeave, refOrTrigger, 'mouseleave');
+            removeEventListener(onFocus, refOrTrigger, 'focus');
+            removeEventListener(onBlur, refOrTrigger, 'blur');
+            removeEventListener(onTriggerClick, refOrTrigger, 'click');
+            removeEventListener(onTriggerEnter, refOrTrigger, 'keydown');
+            removeEventListener(onPopperClick, popperElement, 'click');
+            removeEventListener(onPopperMouseEnter, popperElement, 'mouseenter');
+            removeEventListener(onPopperMouseLeave, popperElement, 'mouseleave');
+            onDocumentClick && removeEventListener(onDocumentClickCallback, document, 'click', true);
+            removeEventListener(onDocumentKeyDown, document, 'keydown', true);
+        };
+    }, [
+        triggerElement,
+        popperElement,
+        onMouseEnter,
+        onMouseLeave,
+        onFocus,
+        onBlur,
+        onTriggerClick,
+        onTriggerEnter,
+        onPopperClick,
+        onPopperMouseEnter,
+        onPopperMouseLeave,
+        onDocumentClick,
+        onDocumentKeyDown,
+        refElement
+    ]);
+    const getPlacement = () => {
+        if (placement) {
+            return placement;
+        }
+        let convertedPlacement = direction === 'up' ? 'top' : 'bottom';
+        if (internalPosition !== 'center') {
+            convertedPlacement = `${convertedPlacement}-${internalPosition === 'right' ? 'end' : 'start'}`;
+        }
+        return convertedPlacement;
+    };
+    const getPlacementMemo = React.useMemo(getPlacement, [direction, internalPosition, placement]);
+    const getOppositePlacementMemo = React.useMemo(() => getOppositePlacement(getPlacement()), [direction, internalPosition, placement]);
+    const widthMods = React.useMemo(() => ({
+        name: 'widthMods',
+        enabled: width !== undefined || minWidth !== undefined || maxWidth !== undefined,
+        phase: 'beforeWrite',
+        requires: ['computeStyles'],
+        fn: ({ state }) => {
+            const triggerWidth = state.rects.reference.width;
+            if (width) {
+                state.styles.popper.width = width === 'trigger' ? `${triggerWidth}px` : width;
+            }
+            if (minWidth) {
+                state.styles.popper.minWidth = minWidth === 'trigger' ? `${triggerWidth}px` : minWidth;
+            }
+            if (maxWidth) {
+                state.styles.popper.maxWidth = maxWidth === 'trigger' ? `${triggerWidth}px` : maxWidth;
+            }
+        },
+        effect: ({ state }) => {
+            const triggerWidth = state.elements.reference.offsetWidth;
+            if (width) {
+                state.elements.popper.style.width = width === 'trigger' ? `${triggerWidth}px` : width;
+            }
+            if (minWidth) {
+                state.elements.popper.style.minWidth = minWidth === 'trigger' ? `${triggerWidth}px` : minWidth;
+            }
+            if (maxWidth) {
+                state.elements.popper.style.maxWidth = maxWidth === 'trigger' ? `${triggerWidth}px` : maxWidth;
+            }
+            return () => { };
+        }
+    }), [width, minWidth, maxWidth]);
+    const { styles: popperStyles, attributes, update, forceUpdate } = usePopper(refOrTrigger, popperElement, {
+        placement: getPlacementMemo,
+        modifiers: [
+            {
+                name: 'offset',
+                options: {
+                    offset: [0, distance]
+                }
+            },
+            {
+                name: 'preventOverflow',
+                enabled: preventOverflow
+            },
+            {
+                // adds attribute [data-popper-reference-hidden] to the popper element which can be used to hide it using CSS
+                name: 'hide',
+                enabled: true
+            },
+            {
+                name: 'flip',
+                enabled: getPlacementMemo.startsWith('auto') || enableFlip,
+                options: {
+                    fallbackPlacements: flipBehavior === 'flip' ? [getOppositePlacementMemo] : flipBehavior
+                }
+            },
+            widthMods
+        ]
+    });
+    /** We want to forceUpdate only when a tooltip's content is dynamically updated.
+     * TODO: Investigate into 3rd party libraries for a less limited/specific solution
+     */
+    React.useEffect(() => {
+        var _a, _b, _c, _d, _e, _f, _g;
+        // currentPopperContent = {tooltip children} || {dropdown children}
+        const currentPopperContent = ((_d = (_c = (_b = (_a = popper === null || popper === void 0 ? void 0 : popper.props) === null || _a === void 0 ? void 0 : _a.children) === null || _b === void 0 ? void 0 : _b[1]) === null || _c === void 0 ? void 0 : _c.props) === null || _d === void 0 ? void 0 : _d.children) || ((_g = (_f = (_e = popper === null || popper === void 0 ? void 0 : popper.props) === null || _e === void 0 ? void 0 : _e.children) === null || _f === void 0 ? void 0 : _f.props) === null || _g === void 0 ? void 0 : _g.children);
+        setPopperContent(currentPopperContent);
+        if (currentPopperContent && popperContent && currentPopperContent !== popperContent) {
+            forceUpdate && forceUpdate();
+        }
+    }, [popper]);
+    React.useEffect(() => {
+        if (prevExitDelayRef.current < exitDelay) {
+            clearTimeouts([transitionTimerRef, hideTimerRef]);
+            hideTimerRef.current = setTimeout(() => {
+                transitionTimerRef.current = setTimeout(() => {
+                    setInternalIsVisible(false);
+                }, animationDuration);
+            }, exitDelay);
+        }
+        prevExitDelayRef.current = exitDelay;
+    }, [exitDelay]);
+    const show = () => {
+        onShow();
+        clearTimeouts([transitionTimerRef, hideTimerRef]);
+        showTimerRef.current = setTimeout(() => {
+            setInternalIsVisible(true);
+            setOpacity(1);
+            onShown();
+        }, entryDelay);
+    };
+    const hide = () => {
+        onHide();
+        clearTimeouts([showTimerRef]);
+        hideTimerRef.current = setTimeout(() => {
+            setOpacity(0);
+            transitionTimerRef.current = setTimeout(() => {
+                setInternalIsVisible(false);
+                onHidden();
+            }, animationDuration);
+        }, exitDelay);
+    };
+    React.useEffect(() => {
+        if (isVisible) {
+            show();
+        }
+        else {
+            hide();
+        }
+    }, [isVisible]);
+    // Returns the CSS modifier class in order to place the Popper's arrow properly
+    // Depends on the position of the Popper relative to the reference element
+    const modifierFromPopperPosition = () => {
+        if (attributes && attributes.popper && attributes.popper['data-popper-placement']) {
+            const popperPlacement = attributes.popper['data-popper-placement'];
+            return positionModifiers[popperPlacement];
+        }
+        return positionModifiers.top;
+    };
+    const options = Object.assign({ className: css(popper.props && popper.props.className, positionModifiers && modifierFromPopperPosition()), style: Object.assign(Object.assign(Object.assign({}, ((popper.props && popper.props.style) || {})), popperStyles.popper), { zIndex,
+            opacity, transition: getOpacityTransition(animationDuration) }) }, attributes.popper);
+    const getMenuWithPopper = () => {
+        const localPopper = React.cloneElement(popper, options);
+        return popperRef ? (localPopper) : (React.createElement("div", { style: { display: 'contents' }, ref: (node) => setPopperElement(node === null || node === void 0 ? void 0 : node.firstElementChild) }, localPopper));
+    };
+    const getPopper = () => {
+        if (appendTo === 'inline') {
+            return getMenuWithPopper();
+        }
+        else {
+            const target = typeof appendTo === 'function' ? appendTo() : appendTo;
+            return ReactDOM.createPortal(getMenuWithPopper(), target);
+        }
+    };
+    return (React.createElement(React.Fragment, null,
+        !triggerRef && trigger && React.isValidElement(trigger) && (React.createElement("div", { style: { display: 'contents' }, ref: (node) => setTriggerElement(node === null || node === void 0 ? void 0 : node.firstElementChild) }, trigger)),
+        triggerRef && trigger && React.isValidElement(trigger) && trigger,
+        ready && showPopper && getPopper()));
+};
+Popper.displayName = 'Popper';
+
+/**
+ * This function is a helper for handling basic arrow keyboard interactions. If a component already has its own key handler and event start up/tear down, this function may be easier to integrate in over the full component.
+ *
+ * @param {event} event Event triggered by the keyboard
+ * @param {element[]} navigableElements Valid traversable elements of the container
+ * @param {function} isActiveElement Callback to determine if a given element from the navigable elements array is the active element of the page
+ * @param {function} getFocusableElement Callback returning the focusable element of a given element from the navigable elements array
+ * @param {string[]} validSiblingTags Valid sibling tags that horizontal arrow handling will focus
+ * @param {boolean} noVerticalArrowHandling Flag indicating that the included vertical arrow key handling should be ignored
+ * @param {boolean} noHorizontalArrowHandling Flag indicating that the included horizontal arrow key handling should be ignored
+ * @param {boolean} updateTabIndex Flag indicating that the tabIndex of the currently focused element and next focused element should be updated, in the case of using a roving tabIndex
+ * @param {boolean} onlyTraverseSiblings Flag indicating that next focusable element of a horizontal movement will be this element's sibling
+ */
+const handleArrows = (event, navigableElements, isActiveElement = (element) => document.activeElement.contains(element), getFocusableElement = (element) => element, validSiblingTags = ['A', 'BUTTON', 'INPUT'], noVerticalArrowHandling = false, noHorizontalArrowHandling = false, updateTabIndex = true, onlyTraverseSiblings = true) => {
+    const activeElement = document.activeElement;
+    const key = event.key;
+    let moveTarget = null;
+    // Handle vertical arrow keys. If noVerticalArrowHandling is passed, skip this block
+    if (!noVerticalArrowHandling) {
+        if (['ArrowUp', 'ArrowDown'].includes(key)) {
+            event.preventDefault();
+            event.stopImmediatePropagation(); // For menus in menus
+            // Traverse navigableElements to find the element which is currently active
+            let currentIndex = -1;
+            // while (currentIndex === -1) {
+            navigableElements.forEach((element, index) => {
+                if (isActiveElement(element)) {
+                    // Once found, move up or down the array by 1. Determined by the vertical arrow key direction
+                    let increment = 0;
+                    // keep increasing the increment until you've tried the whole navigableElement
+                    while (!moveTarget && increment < navigableElements.length && increment * -1 < navigableElements.length) {
+                        key === 'ArrowUp' ? increment-- : increment++;
+                        currentIndex = index + increment;
+                        if (currentIndex >= navigableElements.length) {
+                            currentIndex = 0;
+                        }
+                        if (currentIndex < 0) {
+                            currentIndex = navigableElements.length - 1;
+                        }
+                        // Set the next target element (undefined if none found)
+                        moveTarget = getFocusableElement(navigableElements[currentIndex]);
+                    }
+                }
+            });
+            // }
+        }
+    }
+    // Handle horizontal arrow keys. If noHorizontalArrowHandling is passed, skip this block
+    if (!noHorizontalArrowHandling) {
+        if (['ArrowLeft', 'ArrowRight'].includes(key)) {
+            event.preventDefault();
+            event.stopImmediatePropagation(); // For menus in menus
+            let currentIndex = -1;
+            navigableElements.forEach((element, index) => {
+                if (isActiveElement(element)) {
+                    const activeRow = navigableElements[index].querySelectorAll(validSiblingTags.join(',')); // all focusable elements in my row
+                    if (!activeRow.length || onlyTraverseSiblings) {
+                        let nextSibling = activeElement;
+                        while (nextSibling) {
+                            const isDirectChildOfNavigableElement = nextSibling.parentElement === element;
+                            const nextSiblingMainElement = isDirectChildOfNavigableElement ? nextSibling : nextSibling.parentElement;
+                            nextSibling =
+                                key === 'ArrowLeft'
+                                    ? nextSiblingMainElement.previousElementSibling
+                                    : nextSiblingMainElement.nextElementSibling;
+                            if (nextSibling) {
+                                if (validSiblingTags.includes(nextSibling.tagName)) {
+                                    moveTarget = nextSibling;
+                                    break;
+                                }
+                                // For cases where the validSiblingTag is inside a div wrapper
+                                if (validSiblingTags.includes(nextSibling.children[0].tagName)) {
+                                    moveTarget = nextSibling.children[0];
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        activeRow.forEach((focusableElement, index) => {
+                            if (event.target === focusableElement) {
+                                const increment = key === 'ArrowLeft' ? -1 : 1;
+                                currentIndex = index + increment;
+                                if (currentIndex >= activeRow.length) {
+                                    currentIndex = 0;
+                                }
+                                if (currentIndex < 0) {
+                                    currentIndex = activeRow.length - 1;
+                                }
+                                moveTarget = activeRow[currentIndex];
+                            }
+                        });
+                    }
+                }
+            });
+        }
+    }
+    if (moveTarget) {
+        // If updateTabIndex is true, set the previously focussed element's tabIndex to -1 and the next focussed element's tabIndex to 0
+        // This updates the tabIndex for a roving tabIndex
+        if (updateTabIndex) {
+            activeElement.tabIndex = -1;
+            moveTarget.tabIndex = 0;
+        }
+        // If a move target has been set by either arrow handler, focus that target
+        moveTarget.focus();
+    }
+};
+/**
+ * This function is a helper for setting the initial tabIndexes in a roving tabIndex
+ *
+ * @param {HTMLElement[]} options Array of elements which should have a tabIndex of -1, except for the first element which will have a tabIndex of 0
+ */
+const setTabIndex = (options) => {
+    if (options && options.length > 0) {
+        // Iterate the options and set the tabIndex to -1 on every option
+        options.forEach((option) => {
+            option.tabIndex = -1;
+        });
+        // Manually set the tabIndex of the first option to 0
+        options[0].tabIndex = 0;
+    }
+};
+/**
+ * This function is used in Dropdown, Select and MenuContainer as a default toggle keydown behavior. When the toggle has focus and the menu is open, pressing the up/down arrow keys will focus a valid non-disabled menu item - the first item for the down arrow key and last item for the up arrow key.
+ *
+ * @param event Event triggered by the keyboard
+ * @param menuRef Menu reference
+ */
+const onToggleArrowKeydownDefault = (event, menuRef) => {
+    var _a;
+    if (event.key !== 'ArrowDown' && event.key !== 'ArrowUp') {
+        return;
+    }
+    event.preventDefault();
+    const listItems = Array.from((_a = menuRef.current) === null || _a === void 0 ? void 0 : _a.querySelectorAll('li'));
+    const focusableElements = listItems
+        .map((li) => li.querySelector('button:not(:disabled),input:not(:disabled),a:not([aria-disabled="true"])'))
+        .filter((el) => el !== null);
+    let focusableElement;
+    if (event.key === 'ArrowDown') {
+        focusableElement = focusableElements[0];
+    }
+    else {
+        focusableElement = focusableElements[focusableElements.length - 1];
+    }
+    focusableElement && focusableElement.focus();
+};
+class KeyboardHandler extends React.Component {
+    constructor() {
+        super(...arguments);
+        this.keyHandler = (event) => {
+            const { isEventFromContainer } = this.props;
+            // If the passed keyboard event is not from the container, ignore the event by returning
+            if (isEventFromContainer ? !isEventFromContainer(event) : !this._isEventFromContainer(event)) {
+                return;
+            }
+            const { isActiveElement, getFocusableElement, noVerticalArrowHandling, noHorizontalArrowHandling, noEnterHandling, noSpaceHandling, updateTabIndex, validSiblingTags, additionalKeyHandler, createNavigableElements, onlyTraverseSiblings } = this.props;
+            // Pass the event off to be handled by any custom handler
+            additionalKeyHandler && additionalKeyHandler(event);
+            // Initalize navigableElements from the createNavigableElements callback
+            const navigableElements = createNavigableElements();
+            if (!navigableElements) {
+                // eslint-disable-next-line no-console
+                console.warn('No navigable elements have been passed to the KeyboardHandler. Keyboard navigation provided by this component will be ignored.');
+                return;
+            }
+            const key = event.key;
+            // Handle enter key. If noEnterHandling is passed, skip this block
+            if (!noEnterHandling) {
+                if (key === 'Enter') {
+                    event.preventDefault();
+                    event.stopImmediatePropagation(); // For menus in menus
+                    document.activeElement.click();
+                }
+            }
+            // Handle space key. If noSpaceHandling is passed, skip this block
+            if (!noSpaceHandling) {
+                if (key === ' ') {
+                    event.preventDefault();
+                    event.stopImmediatePropagation(); // For menus in menus
+                    document.activeElement.click();
+                }
+            }
+            // Inject helper handler for arrow navigation
+            handleArrows(event, navigableElements, isActiveElement, getFocusableElement, validSiblingTags, noVerticalArrowHandling, noHorizontalArrowHandling, updateTabIndex, onlyTraverseSiblings);
+        };
+        this._isEventFromContainer = (event) => {
+            const { containerRef } = this.props;
+            return containerRef.current && containerRef.current.contains(event.target);
+        };
+    }
+    componentDidMount() {
+        if (canUseDOM) {
+            window.addEventListener('keydown', this.keyHandler);
+        }
+    }
+    componentWillUnmount() {
+        if (canUseDOM) {
+            window.removeEventListener('keydown', this.keyHandler);
+        }
+    }
+    render() {
+        return null;
+    }
+}
+KeyboardHandler.displayName = 'KeyboardHandler';
+KeyboardHandler.defaultProps = {
+    containerRef: null,
+    createNavigableElements: () => null,
+    isActiveElement: (navigableElement) => document.activeElement === navigableElement,
+    getFocusableElement: (navigableElement) => navigableElement,
+    validSiblingTags: ['BUTTON', 'A'],
+    onlyTraverseSiblings: true,
+    updateTabIndex: true,
+    noHorizontalArrowHandling: false,
+    noVerticalArrowHandling: false,
+    noEnterHandling: false,
+    noSpaceHandling: false
+};
+
+const styles$4 = {
+  "button": "pf-v6-c-button",
+  "buttonCount": "pf-v6-c-button__count",
+  "buttonIcon": "pf-v6-c-button__icon",
+  "buttonProgress": "pf-v6-c-button__progress",
+  "modifiers": {
+    "primary": "pf-m-primary",
+    "unread": "pf-m-unread",
+    "secondary": "pf-m-secondary",
+    "danger": "pf-m-danger",
+    "tertiary": "pf-m-tertiary",
+    "link": "pf-m-link",
+    "inline": "pf-m-inline",
+    "displayLg": "pf-m-display-lg",
+    "warning": "pf-m-warning",
+    "control": "pf-m-control",
+    "stateful": "pf-m-stateful",
+    "read": "pf-m-read",
+    "attention": "pf-m-attention",
+    "plain": "pf-m-plain",
+    "noPadding": "pf-m-no-padding",
+    "block": "pf-m-block",
+    "small": "pf-m-small",
+    "clicked": "pf-m-clicked",
+    "disabled": "pf-m-disabled",
+    "ariaDisabled": "pf-m-aria-disabled",
+    "progress": "pf-m-progress",
+    "inProgress": "pf-m-in-progress",
+    "start": "pf-m-start",
+    "end": "pf-m-end"
+  }};
+
+const styles$3 = {
+  "modifiers": {
+    "inline": "pf-m-inline",
+    "sm": "pf-m-sm",
+    "md": "pf-m-md",
+    "lg": "pf-m-lg",
+    "xl": "pf-m-xl"
+  },
+  "spinner": "pf-v6-c-spinner",
+  "spinnerPath": "pf-v6-c-spinner__path"
+};
+
+const c_spinner_diameter = {
+  "name": "--pf-v6-c-spinner--diameter"};
+
+var spinnerSize;
+(function (spinnerSize) {
+    spinnerSize["sm"] = "sm";
+    spinnerSize["md"] = "md";
+    spinnerSize["lg"] = "lg";
+    spinnerSize["xl"] = "xl";
+})(spinnerSize || (spinnerSize = {}));
+const Spinner = (_a) => {
+    var { className = '', size = 'xl', 'aria-valuetext': ariaValueText = 'Loading...', diameter, isInline = false, 'aria-label': ariaLabel, 'aria-labelledBy': ariaLabelledBy } = _a, props = __rest(_a, ["className", "size", 'aria-valuetext', "diameter", "isInline", 'aria-label', 'aria-labelledBy']);
+    return (React.createElement("svg", Object.assign({ className: css(styles$3.spinner, isInline ? styles$3.modifiers.inline : styles$3.modifiers[size], className), role: "progressbar", "aria-valuetext": ariaValueText, viewBox: "0 0 100 100" }, (diameter && { style: { [c_spinner_diameter.name]: diameter } }), (ariaLabel && { 'aria-label': ariaLabel }), (ariaLabelledBy && { 'aria-labelledBy': ariaLabelledBy }), (!ariaLabel && !ariaLabelledBy && { 'aria-label': 'Contents' }), props),
+        React.createElement("circle", { className: styles$3.spinnerPath, cx: "50", cy: "50", r: "45", fill: "none" })));
+};
+Spinner.displayName = 'Spinner';
+
+const styles$2 = {
+  "badge": "pf-v6-c-badge",
+  "modifiers": {
+    "read": "pf-m-read",
+    "unread": "pf-m-unread",
+    "disabled": "pf-m-disabled"
+  }
+};
+
+const Badge = (_a) => {
+    var { isRead = false, isDisabled = false, className = '', children = '', screenReaderText } = _a, props = __rest(_a, ["isRead", "isDisabled", "className", "children", "screenReaderText"]);
+    return (React.createElement("span", Object.assign({}, props, { className: css(styles$2.badge, (isRead ? styles$2.modifiers.read : styles$2.modifiers.unread), isDisabled && styles$2.modifiers.disabled, className) }),
+        children,
+        screenReaderText && React.createElement("span", { className: "pf-v6-screen-reader" }, screenReaderText)));
+};
+Badge.displayName = 'Badge';
+
+var ButtonVariant;
+(function (ButtonVariant) {
+    ButtonVariant["primary"] = "primary";
+    ButtonVariant["secondary"] = "secondary";
+    ButtonVariant["tertiary"] = "tertiary";
+    ButtonVariant["danger"] = "danger";
+    ButtonVariant["warning"] = "warning";
+    ButtonVariant["link"] = "link";
+    ButtonVariant["plain"] = "plain";
+    ButtonVariant["control"] = "control";
+    ButtonVariant["stateful"] = "stateful";
+})(ButtonVariant || (ButtonVariant = {}));
+var ButtonType;
+(function (ButtonType) {
+    ButtonType["button"] = "button";
+    ButtonType["submit"] = "submit";
+    ButtonType["reset"] = "reset";
+})(ButtonType || (ButtonType = {}));
+var ButtonSize;
+(function (ButtonSize) {
+    ButtonSize["default"] = "default";
+    ButtonSize["sm"] = "sm";
+    ButtonSize["lg"] = "lg";
+})(ButtonSize || (ButtonSize = {}));
+var ButtonState;
+(function (ButtonState) {
+    ButtonState["read"] = "read";
+    ButtonState["unread"] = "unread";
+    ButtonState["attention"] = "attention";
+})(ButtonState || (ButtonState = {}));
+const ButtonBase = (_a) => {
+    var { children = null, className = '', component = 'button', isClicked = false, isBlock = false, isDisabled = false, isAriaDisabled = false, isLoading = null, isDanger = false, spinnerAriaValueText, spinnerAriaLabelledBy, spinnerAriaLabel, size = ButtonSize.default, inoperableEvents = ['onClick', 'onKeyPress'], isInline = false, type = ButtonType.button, variant = ButtonVariant.primary, state = ButtonState.unread, hasNoPadding = false, iconPosition = 'start', 'aria-label': ariaLabel = null, icon = null, role, ouiaId, ouiaSafe = true, tabIndex = null, innerRef, countOptions } = _a, props = __rest(_a, ["children", "className", "component", "isClicked", "isBlock", "isDisabled", "isAriaDisabled", "isLoading", "isDanger", "spinnerAriaValueText", "spinnerAriaLabelledBy", "spinnerAriaLabel", "size", "inoperableEvents", "isInline", "type", "variant", "state", "hasNoPadding", "iconPosition", 'aria-label', "icon", "role", "ouiaId", "ouiaSafe", "tabIndex", "innerRef", "countOptions"]);
+    const ouiaProps = useOUIAProps(Button.displayName, ouiaId, ouiaSafe, variant);
+    const Component = component;
+    const isButtonElement = Component === 'button';
+    const isInlineSpan = isInline && Component === 'span';
+    const isIconAlignedAtEnd = iconPosition === 'end' || iconPosition === 'right';
+    const preventedEvents = inoperableEvents.reduce((handlers, eventToPrevent) => (Object.assign(Object.assign({}, handlers), { [eventToPrevent]: (event) => {
+            event.preventDefault();
+        } })), {});
+    const getDefaultTabIdx = () => {
+        if (isDisabled) {
+            return isButtonElement ? null : -1;
+        }
+        else if (isAriaDisabled) {
+            return null;
+        }
+        else if (isInlineSpan) {
+            return 0;
+        }
+    };
+    const _icon = icon && (React.createElement("span", { className: css(styles$4.buttonIcon, children && styles$4.modifiers[isIconAlignedAtEnd ? 'end' : 'start']) }, icon));
+    const _children = children && React.createElement("span", { className: css('pf-v6-c-button__text') }, children);
+    return (React.createElement(Component, Object.assign({}, props, (isAriaDisabled ? preventedEvents : null), { "aria-disabled": isAriaDisabled || (!isButtonElement && isDisabled), "aria-label": ariaLabel, className: css(styles$4.button, styles$4.modifiers[variant], isBlock && styles$4.modifiers.block, isDisabled && !isButtonElement && styles$4.modifiers.disabled, isAriaDisabled && styles$4.modifiers.ariaDisabled, isClicked && styles$4.modifiers.clicked, isInline && variant === ButtonVariant.link && styles$4.modifiers.inline, isDanger && (variant === ButtonVariant.secondary || variant === ButtonVariant.link) && styles$4.modifiers.danger, isLoading !== null && variant !== ButtonVariant.plain && styles$4.modifiers.progress, isLoading && styles$4.modifiers.inProgress, hasNoPadding && variant === ButtonVariant.plain && styles$4.modifiers.noPadding, variant === ButtonVariant.stateful && styles$4.modifiers[state], size === ButtonSize.sm && styles$4.modifiers.small, size === ButtonSize.lg && styles$4.modifiers.displayLg, className), disabled: isButtonElement ? isDisabled : null, tabIndex: tabIndex !== null ? tabIndex : getDefaultTabIdx(), type: isButtonElement || isInlineSpan ? type : null, role: isInlineSpan ? 'button' : role, ref: innerRef }, ouiaProps),
+        isLoading && (React.createElement("span", { className: css(styles$4.buttonProgress) },
+            React.createElement(Spinner, { size: spinnerSize.md, isInline: isInline, "aria-valuetext": spinnerAriaValueText, "aria-label": spinnerAriaLabel, "aria-labelledby": spinnerAriaLabelledBy }))),
+        isIconAlignedAtEnd ? (React.createElement(React.Fragment, null,
+            _children,
+            _icon)) : (React.createElement(React.Fragment, null,
+            _icon,
+            _children)),
+        countOptions && (React.createElement("span", { className: css(styles$4.buttonCount, countOptions.className) },
+            React.createElement(Badge, { isRead: countOptions.isRead, isDisabled: isDisabled }, countOptions.count)))));
+};
+const Button = React.forwardRef((props, ref) => (React.createElement(ButtonBase, Object.assign({ innerRef: ref }, props))));
+Button.displayName = 'Button';
+
+const TimesIconConfig = {
+  name: 'TimesIcon',
+  height: 512,
+  width: 352,
+  svgPath: 'M242.72 256l100.07-100.07c12.28-12.28 12.28-32.19 0-44.48l-22.24-22.24c-12.28-12.28-32.19-12.28-44.48 0L176 189.28 75.93 89.21c-12.28-12.28-32.19-12.28-44.48 0L9.21 111.45c-12.28 12.28-12.28 32.19 0 44.48L109.28 256 9.21 356.07c-12.28 12.28-12.28 32.19 0 44.48l22.24 22.24c12.28 12.28 32.2 12.28 44.48 0L176 322.72l100.07 100.07c12.28 12.28 32.2 12.28 44.48 0l22.24-22.24c12.28-12.28 12.28-32.19 0-44.48L242.72 256z',
+  yOffset: 0,
+  xOffset: 0,
+};
+
+const TimesIcon = createIcon(TimesIconConfig);
+
+const styles$1 = {
+  "modifiers": {
+    "top": "pf-m-top",
+    "topLeft": "pf-m-top-left",
+    "topRight": "pf-m-top-right",
+    "bottom": "pf-m-bottom",
+    "bottomLeft": "pf-m-bottom-left",
+    "bottomRight": "pf-m-bottom-right",
+    "left": "pf-m-left",
+    "leftTop": "pf-m-left-top",
+    "leftBottom": "pf-m-left-bottom",
+    "right": "pf-m-right",
+    "rightTop": "pf-m-right-top",
+    "rightBottom": "pf-m-right-bottom",
+    "textAlignLeft": "pf-m-text-align-left"
+  },
+  "tooltip": "pf-v6-c-tooltip",
+  "tooltipArrow": "pf-v6-c-tooltip__arrow",
+  "tooltipContent": "pf-v6-c-tooltip__content"
+};
+
+const TooltipContent = (_a) => {
+    var { className, children, isLeftAligned } = _a, props = __rest(_a, ["className", "children", "isLeftAligned"]);
+    return (React.createElement("div", Object.assign({ className: css(styles$1.tooltipContent, isLeftAligned && styles$1.modifiers.textAlignLeft, className) }, props), children));
+};
+TooltipContent.displayName = 'TooltipContent';
+
+const TooltipArrow = (_a) => {
+    var { className } = _a, props = __rest(_a, ["className"]);
+    return React.createElement("div", Object.assign({ className: css(styles$1.tooltipArrow, className) }, props));
+};
+TooltipArrow.displayName = 'TooltipArrow';
+
+const c_tooltip_MaxWidth = {
+  "value": "18.75rem"};
+
+var TooltipPosition;
+(function (TooltipPosition) {
+    TooltipPosition["auto"] = "auto";
+    TooltipPosition["top"] = "top";
+    TooltipPosition["bottom"] = "bottom";
+    TooltipPosition["left"] = "left";
+    TooltipPosition["right"] = "right";
+    TooltipPosition["topStart"] = "top-start";
+    TooltipPosition["topEnd"] = "top-end";
+    TooltipPosition["bottomStart"] = "bottom-start";
+    TooltipPosition["bottomEnd"] = "bottom-end";
+    TooltipPosition["leftStart"] = "left-start";
+    TooltipPosition["leftEnd"] = "left-end";
+    TooltipPosition["rightStart"] = "right-start";
+    TooltipPosition["rightEnd"] = "right-end";
+})(TooltipPosition || (TooltipPosition = {}));
+// id for associating trigger with the content aria-describedby or aria-labelledby
+let pfTooltipIdCounter = 1;
+const Tooltip = (_a) => {
+    var { content: bodyContent, position = 'top', trigger = 'mouseenter focus', isVisible = false, isContentLeftAligned = false, enableFlip = true, className = '', entryDelay = 300, exitDelay = 300, appendTo = () => document.body, zIndex = 9999, minWidth, maxWidth = c_tooltip_MaxWidth.value, distance = 15, aria = 'describedby', 
+    // For every initial starting position, there are 3 escape positions
+    flipBehavior = ['top', 'right', 'bottom', 'left', 'top', 'right', 'bottom'], id = `pf-tooltip-${pfTooltipIdCounter++}`, children, animationDuration = 300, triggerRef, 'aria-live': ariaLive = triggerRef ? 'polite' : 'off', onTooltipHidden = () => { } } = _a, rest = __rest(_a, ["content", "position", "trigger", "isVisible", "isContentLeftAligned", "enableFlip", "className", "entryDelay", "exitDelay", "appendTo", "zIndex", "minWidth", "maxWidth", "distance", "aria", "flipBehavior", "id", "children", "animationDuration", "triggerRef", 'aria-live', "onTooltipHidden"]);
+    const triggerOnMouseenter = trigger.includes('mouseenter');
+    const triggerOnFocus = trigger.includes('focus');
+    const triggerOnClick = trigger.includes('click');
+    const triggerManually = trigger === 'manual';
+    const [visible, setVisible] = React.useState(false);
+    const popperRef = React.createRef();
+    const onDocumentKeyDown = (event) => {
+        if (!triggerManually) {
+            if (event.key === KeyTypes.Escape && visible) {
+                hide();
+            }
+        }
+    };
+    const onTriggerEnter = (event) => {
+        if (event.key === KeyTypes.Enter) {
+            if (!visible) {
+                show();
+            }
+            else {
+                hide();
+            }
+        }
+    };
+    React.useEffect(() => {
+        if (isVisible) {
+            show();
+        }
+        else {
+            hide();
+        }
+    }, [isVisible]);
+    const show = () => {
+        setVisible(true);
+    };
+    const hide = () => {
+        setVisible(false);
+    };
+    const positionModifiers = {
+        top: styles$1.modifiers.top,
+        bottom: styles$1.modifiers.bottom,
+        left: styles$1.modifiers.left,
+        right: styles$1.modifiers.right,
+        'top-start': styles$1.modifiers.topLeft,
+        'top-end': styles$1.modifiers.topRight,
+        'bottom-start': styles$1.modifiers.bottomLeft,
+        'bottom-end': styles$1.modifiers.bottomRight,
+        'left-start': styles$1.modifiers.leftTop,
+        'left-end': styles$1.modifiers.leftBottom,
+        'right-start': styles$1.modifiers.rightTop,
+        'right-end': styles$1.modifiers.rightBottom
+    };
+    const hasCustomMaxWidth = maxWidth !== c_tooltip_MaxWidth.value;
+    const content = (React.createElement("div", Object.assign({ "aria-live": ariaLive, className: css(styles$1.tooltip, className), role: "tooltip", id: id, style: {
+            maxWidth: hasCustomMaxWidth ? maxWidth : null
+        }, ref: popperRef }, rest),
+        React.createElement(TooltipArrow, null),
+        React.createElement(TooltipContent, { isLeftAligned: isContentLeftAligned }, bodyContent)));
+    const onDocumentClick = (event, triggerElement) => {
+        // event.currentTarget = document
+        // event.target could be triggerElement or something else
+        {
+            // hide on inside the toggle as well as on outside clicks
+            if (visible) {
+                hide();
+            }
+            else if (event.target === triggerElement) {
+                show();
+            }
+        }
+    };
+    const addAriaToTrigger = () => {
+        if (aria === 'describedby' && children && children.props && !children.props['aria-describedby']) {
+            return React.cloneElement(children, { 'aria-describedby': id });
+        }
+        else if (aria === 'labelledby' && children.props && !children.props['aria-labelledby']) {
+            return React.cloneElement(children, { 'aria-labelledby': id });
+        }
+        return children;
+    };
+    return (React.createElement(Popper, { trigger: aria !== 'none' && visible ? addAriaToTrigger() : children, triggerRef: triggerRef, popper: content, popperRef: popperRef, minWidth: minWidth !== undefined ? minWidth : 'revert', appendTo: appendTo, isVisible: visible, positionModifiers: positionModifiers, distance: distance, placement: position, onMouseEnter: triggerOnMouseenter && show, onMouseLeave: triggerOnMouseenter && hide, onPopperMouseEnter: triggerOnMouseenter && show, onPopperMouseLeave: triggerOnMouseenter && hide, onFocus: triggerOnFocus && show, onBlur: triggerOnFocus && hide, onDocumentClick: triggerOnClick && onDocumentClick, onDocumentKeyDown: triggerManually ? null : onDocumentKeyDown, onTriggerEnter: triggerManually ? null : onTriggerEnter, enableFlip: enableFlip, zIndex: zIndex, flipBehavior: flipBehavior, animationDuration: animationDuration, entryDelay: entryDelay, exitDelay: exitDelay, onHidden: onTooltipHidden }));
+};
+Tooltip.displayName = 'Tooltip';
+
+const AngleRightIconConfig = {
+  name: 'AngleRightIcon',
+  height: 512,
+  width: 256,
+  svgPath: 'M224.3 273l-136 136c-9.4 9.4-24.6 9.4-33.9 0l-22.6-22.6c-9.4-9.4-9.4-24.6 0-33.9l96.4-96.4-96.4-96.4c-9.4-9.4-9.4-24.6 0-33.9L54.3 103c9.4-9.4 24.6-9.4 33.9 0l136 136c9.5 9.4 9.5 24.6.1 34z',
+  yOffset: 0,
+  xOffset: 0,
+};
+
+const AngleRightIcon = createIcon(AngleRightIconConfig);
+
+const breadcrumbStyles = {
+  "breadcrumbLink": "pf-v6-c-breadcrumb__link"};
+
+const menuStyles = {
+  "divider": "pf-v6-c-divider",
+  "menu": "pf-v6-c-menu",
+  "menuContent": "pf-v6-c-menu__content",
+  "menuGroup": "pf-v6-c-menu__group",
+  "menuGroupTitle": "pf-v6-c-menu__group-title",
+  "menuItem": "pf-v6-c-menu__item",
+  "menuItemAction": "pf-v6-c-menu__item-action",
+  "menuItemCheck": "pf-v6-c-menu__item-check",
+  "menuItemDescription": "pf-v6-c-menu__item-description",
+  "menuItemExternalIcon": "pf-v6-c-menu__item-external-icon",
+  "menuItemIcon": "pf-v6-c-menu__item-icon",
+  "menuItemMain": "pf-v6-c-menu__item-main",
+  "menuItemSelectIcon": "pf-v6-c-menu__item-select-icon",
+  "menuItemText": "pf-v6-c-menu__item-text",
+  "menuItemToggleIcon": "pf-v6-c-menu__item-toggle-icon",
+  "menuList": "pf-v6-c-menu__list",
+  "menuListItem": "pf-v6-c-menu__list-item",
+  "menuSearch": "pf-v6-c-menu__search",
+  "modifiers": {
+    "disabled": "pf-m-disabled",
+    "ariaDisabled": "pf-m-aria-disabled",
+    "flyout": "pf-m-flyout",
+    "left": "pf-m-left",
+    "drilldown": "pf-m-drilldown",
+    "drilledIn": "pf-m-drilled-in",
+    "currentPath": "pf-m-current-path",
+    "plain": "pf-m-plain",
+    "scrollable": "pf-m-scrollable",
+    "load": "pf-m-load",
+    "loading": "pf-m-loading",
+    "danger": "pf-m-danger",
+    "selected": "pf-m-selected",
+    "favorited": "pf-m-favorited"
+  }
+};
+
+const MenuContext = React.createContext({
+    menuId: null,
+    parentMenu: null,
+    onActionClick: () => null,
+    onSelect: () => null,
+    activeItemId: null,
+    selected: null,
+    drilledInMenus: [],
+    drilldownItemPath: [],
+    onDrillIn: null,
+    onDrillOut: null,
+    onGetMenuHeight: () => null,
+    flyoutRef: null,
+    setFlyoutRef: () => null,
+    disableHover: false,
+    role: 'menu'
+});
+const MenuItemContext = React.createContext({
+    itemId: null,
+    isDisabled: false
+});
+
+class MenuBase extends React.Component {
+    constructor(props) {
+        super(props);
+        this.menuRef = React.createRef();
+        this.activeMenu = null;
+        this.state = {
+            ouiaStateId: getDefaultOUIAId(Menu.displayName),
+            transitionMoveTarget: null,
+            flyoutRef: null,
+            disableHover: false,
+            currentDrilldownMenuId: this.props.id
+        };
+        this.handleDrilldownTransition = (event) => {
+            const current = this.menuRef.current;
+            if (!current ||
+                (current !== event.target.closest(`.${menuStyles.menu}`) &&
+                    !Array.from(current.getElementsByClassName(menuStyles.menu)).includes(event.target.closest(`.${menuStyles.menu}`)))) {
+                return;
+            }
+            if (this.state.transitionMoveTarget) {
+                this.state.transitionMoveTarget.focus();
+                this.setState({ transitionMoveTarget: null });
+            }
+            else {
+                const nextMenu = current.querySelector('#' + this.props.activeMenu) || current || null;
+                const nextMenuLists = nextMenu.getElementsByTagName('UL');
+                if (nextMenuLists.length === 0) {
+                    return;
+                }
+                const nextMenuChildren = Array.from(nextMenuLists[0].children);
+                if (!this.state.currentDrilldownMenuId || nextMenu.id !== this.state.currentDrilldownMenuId) {
+                    this.setState({ currentDrilldownMenuId: nextMenu.id });
+                }
+                else {
+                    // if the drilldown transition ends on the same menu, do not focus the first item
+                    return;
+                }
+                const nextTarget = nextMenuChildren.filter((el) => !(el.classList.contains('pf-m-disabled') || el.classList.contains(menuStyles.divider)))[0].firstChild;
+                nextTarget.focus();
+                nextTarget.tabIndex = 0;
+            }
+        };
+        this.handleExtraKeys = (event) => {
+            const isDrilldown = this.props.containsDrilldown;
+            const activeElement = document.activeElement;
+            if (event.target.closest(`.${menuStyles.menu}`) !== this.activeMenu &&
+                !event.target.classList.contains(breadcrumbStyles.breadcrumbLink)) {
+                this.activeMenu = event.target.closest(`.${menuStyles.menu}`);
+                this.setState({ disableHover: true });
+            }
+            if (event.target.tagName === 'INPUT') {
+                return;
+            }
+            const parentMenu = this.activeMenu;
+            const key = event.key;
+            const isFromBreadcrumb = activeElement.classList.contains(breadcrumbStyles.breadcrumbLink);
+            if (key === ' ' || key === 'Enter') {
+                event.preventDefault();
+                if (isDrilldown && !isFromBreadcrumb) {
+                    const isDrillingOut = activeElement.closest('li').classList.contains('pf-m-current-path');
+                    if (isDrillingOut && parentMenu.parentElement.tagName === 'LI') {
+                        activeElement.tabIndex = -1;
+                        parentMenu.parentElement.firstChild.tabIndex = 0;
+                        this.setState({ transitionMoveTarget: parentMenu.parentElement.firstChild });
+                    }
+                    else {
+                        if (activeElement.nextElementSibling && activeElement.nextElementSibling.classList.contains(menuStyles.menu)) {
+                            const childItems = Array.from(activeElement.nextElementSibling.getElementsByTagName('UL')[0].children).filter((el) => !(el.classList.contains('pf-m-disabled') || el.classList.contains(menuStyles.divider)));
+                            activeElement.tabIndex = -1;
+                            childItems[0].firstChild.tabIndex = 0;
+                            this.setState({ transitionMoveTarget: childItems[0].firstChild });
+                        }
+                    }
+                }
+                document.activeElement.click();
+            }
+        };
+        this.createNavigableElements = () => {
+            const isDrilldown = this.props.containsDrilldown;
+            if (isDrilldown) {
+                return this.activeMenu
+                    ? Array.from(this.activeMenu.getElementsByTagName('UL')[0].children).filter((el) => !(el.classList.contains('pf-m-disabled') || el.classList.contains(menuStyles.divider)))
+                    : [];
+            }
+            else {
+                return this.menuRef.current
+                    ? Array.from(this.menuRef.current.getElementsByTagName('LI')).filter((el) => !(el.classList.contains('pf-m-disabled') || el.classList.contains(menuStyles.divider)))
+                    : [];
+            }
+        };
+        if (props.innerRef) {
+            this.menuRef = props.innerRef;
+        }
+    }
+    allowTabFirstItem() {
+        // Allow tabbing to first menu item
+        const current = this.menuRef.current;
+        if (current) {
+            const first = current.querySelector('ul button:not(:disabled), ul a:not(:disabled)');
+            if (first) {
+                first.tabIndex = 0;
+            }
+        }
+    }
+    componentDidMount() {
+        if (this.context) {
+            this.setState({ disableHover: this.context.disableHover });
+        }
+        if (canUseDOM && this.props.containsDrilldown) {
+            window.addEventListener('transitionend', this.props.isRootMenu ? this.handleDrilldownTransition : null);
+        }
+        this.allowTabFirstItem();
+    }
+    componentWillUnmount() {
+        if (canUseDOM && this.props.containsDrilldown) {
+            window.removeEventListener('transitionend', this.handleDrilldownTransition);
+        }
+    }
+    componentDidUpdate(prevProps) {
+        if (prevProps.children !== this.props.children) {
+            this.allowTabFirstItem();
+        }
+    }
+    render() {
+        const _a = this.props, { id, children, className, onSelect, selected = null, onActionClick, ouiaId, ouiaSafe, containsFlyout, containsDrilldown, isMenuDrilledIn, isPlain, isScrollable, drilldownItemPath, drilledInMenus, onDrillIn, onDrillOut, onGetMenuHeight, parentMenu = null, activeItemId = null, 
+        /* eslint-disable @typescript-eslint/no-unused-vars */
+        innerRef, isRootMenu, activeMenu, role, isNavFlyout } = _a, 
+        /* eslint-enable @typescript-eslint/no-unused-vars */
+        props = __rest(_a, ["id", "children", "className", "onSelect", "selected", "onActionClick", "ouiaId", "ouiaSafe", "containsFlyout", "containsDrilldown", "isMenuDrilledIn", "isPlain", "isScrollable", "drilldownItemPath", "drilledInMenus", "onDrillIn", "onDrillOut", "onGetMenuHeight", "parentMenu", "activeItemId", "innerRef", "isRootMenu", "activeMenu", "role", "isNavFlyout"]);
+        const _isMenuDrilledIn = isMenuDrilledIn || (drilledInMenus && drilledInMenus.includes(id)) || false;
+        return (React.createElement(MenuContext.Provider, { value: {
+                menuId: id,
+                parentMenu: parentMenu || id,
+                onSelect,
+                onActionClick,
+                activeItemId,
+                selected,
+                drilledInMenus,
+                drilldownItemPath,
+                onDrillIn,
+                onDrillOut,
+                onGetMenuHeight,
+                flyoutRef: this.state.flyoutRef,
+                setFlyoutRef: (flyoutRef) => this.setState({ flyoutRef }),
+                disableHover: this.state.disableHover,
+                role
+            } },
+            isRootMenu && (React.createElement(KeyboardHandler, { containerRef: this.menuRef || null, additionalKeyHandler: this.handleExtraKeys, createNavigableElements: this.createNavigableElements, isActiveElement: (element) => document.activeElement.closest('li') === element || // if element is a basic MenuItem
+                    document.activeElement.parentElement === element ||
+                    document.activeElement.closest(`.${menuStyles.menuSearch}`) === element || // if element is a MenuSearch
+                    (document.activeElement.closest('ol') && document.activeElement.closest('ol').firstChild === element), getFocusableElement: (navigableElement) => {
+                    var _a, _b;
+                    return ((navigableElement === null || navigableElement === void 0 ? void 0 : navigableElement.tagName) === 'DIV' && navigableElement.querySelector('input')) || // for MenuSearchInput
+                        (((_a = navigableElement.firstChild) === null || _a === void 0 ? void 0 : _a.tagName) === 'LABEL' &&
+                            navigableElement.querySelector('input')) || // for MenuItem checkboxes
+                        (((_b = navigableElement.firstChild) === null || _b === void 0 ? void 0 : _b.tagName) === 'DIV' &&
+                            navigableElement.querySelector('a, button, input')) || // For aria-disabled element that is rendered inside a div with "display: contents" styling
+                        navigableElement.firstChild;
+                }, noHorizontalArrowHandling: document.activeElement &&
+                    (document.activeElement.classList.contains(breadcrumbStyles.breadcrumbLink) ||
+                        document.activeElement.tagName === 'INPUT'), noEnterHandling: true, noSpaceHandling: true })),
+            React.createElement("div", Object.assign({ id: id, className: css(menuStyles.menu, isPlain && menuStyles.modifiers.plain, isScrollable && menuStyles.modifiers.scrollable, containsFlyout && menuStyles.modifiers.flyout, isNavFlyout && 'pf-m-nav', containsDrilldown && menuStyles.modifiers.drilldown, _isMenuDrilledIn && menuStyles.modifiers.drilledIn, className), ref: this.menuRef }, getOUIAProps(Menu.displayName, ouiaId !== undefined ? ouiaId : this.state.ouiaStateId, ouiaSafe), props), children)));
+    }
+}
+MenuBase.displayName = 'Menu';
+MenuBase.contextType = MenuContext;
+MenuBase.defaultProps = {
+    ouiaSafe: true,
+    isRootMenu: true,
+    isPlain: false,
+    isScrollable: false,
+    role: 'menu'
+};
+const Menu = React.forwardRef((props, ref) => (React.createElement(MenuBase, Object.assign({}, props, { innerRef: ref }))));
+Menu.displayName = 'Menu';
+
+const c_menu__content_Height = {
+  "name": "--pf-v6-c-menu__content--Height"};
+
+const c_menu__content_MaxHeight = {
+  "name": "--pf-v6-c-menu__content--MaxHeight"};
+
+const MenuContent = React.forwardRef((props, ref) => {
+    const { getHeight, children, menuHeight, maxMenuHeight } = props, rest = __rest(props, ["getHeight", "children", "menuHeight", "maxMenuHeight"]);
+    const menuContentRef = React.createRef();
+    const refCallback = (el, menuId, onGetMenuHeight) => {
+        if (el) {
+            let clientHeight = el.clientHeight;
+            // if this menu is a submenu, we need to account for the root menu list's padding and root menu content's border.
+            let rootMenuList = null;
+            let parentEl = el.closest(`.${menuStyles.menuList}`);
+            while (parentEl !== null && parentEl.nodeType === 1) {
+                if (parentEl.classList.contains(menuStyles.menuList)) {
+                    rootMenuList = parentEl;
+                }
+                parentEl = parentEl.parentElement;
+            }
+            if (rootMenuList) {
+                const rootMenuListStyles = getComputedStyle(rootMenuList);
+                const rootMenuListPaddingOffset = parseFloat(rootMenuListStyles.getPropertyValue('padding-top').replace(/px/g, '')) +
+                    parseFloat(rootMenuListStyles.getPropertyValue('padding-bottom').replace(/px/g, '')) +
+                    parseFloat(getComputedStyle(rootMenuList.parentElement).getPropertyValue('border-bottom-width').replace(/px/g, ''));
+                clientHeight = clientHeight + rootMenuListPaddingOffset;
+            }
+            onGetMenuHeight && onGetMenuHeight(menuId, clientHeight);
+            getHeight && getHeight(clientHeight.toString());
+        }
+        return ref || menuContentRef;
+    };
+    return (React.createElement(MenuContext.Consumer, null, ({ menuId, onGetMenuHeight }) => (React.createElement("div", Object.assign({}, rest, { className: css(menuStyles.menuContent, props.className), ref: (el) => refCallback(el, menuId, onGetMenuHeight), style: Object.assign(Object.assign({}, (menuHeight && { [c_menu__content_Height.name]: menuHeight })), (maxMenuHeight && { [c_menu__content_MaxHeight.name]: maxMenuHeight })) }), children))));
+});
+MenuContent.displayName = 'MenuContent';
+
+const c_menu_m_flyout__menu_top_offset = {
+  "name": "--pf-v6-c-menu--m-flyout__menu--top-offset"};
+
+const c_menu_m_flyout__menu_m_left_right_offset = {
+  "name": "--pf-v6-c-menu--m-flyout__menu--m-left--right-offset"};
+
+const c_menu_m_flyout__menu_left_offset = {
+  "name": "--pf-v6-c-menu--m-flyout__menu--left-offset"};
+
+const ExternalLinkAltIconConfig = {
+  name: 'ExternalLinkAltIcon',
+  height: 512,
+  width: 512,
+  svgPath: 'M432,320H400a16,16,0,0,0-16,16V448H64V128H208a16,16,0,0,0,16-16V80a16,16,0,0,0-16-16H48A48,48,0,0,0,0,112V464a48,48,0,0,0,48,48H400a48,48,0,0,0,48-48V336A16,16,0,0,0,432,320ZM488,0h-128c-21.37,0-32.05,25.91-17,41l35.73,35.73L135,320.37a24,24,0,0,0,0,34L157.67,377a24,24,0,0,0,34,0L435.28,133.32,471,169c15,15,41,4.5,41-17V24A24,24,0,0,0,488,0Z',
+  yOffset: 0,
+  xOffset: 0,
+};
+
+const ExternalLinkAltIcon = createIcon(ExternalLinkAltIconConfig);
+
+const AngleLeftIconConfig = {
+  name: 'AngleLeftIcon',
+  height: 512,
+  width: 256,
+  svgPath: 'M31.7 239l136-136c9.4-9.4 24.6-9.4 33.9 0l22.6 22.6c9.4 9.4 9.4 24.6 0 33.9L127.9 256l96.4 96.4c9.4 9.4 9.4 24.6 0 33.9L201.7 409c-9.4 9.4-24.6 9.4-33.9 0l-136-136c-9.5-9.4-9.5-24.6-.1-34z',
+  yOffset: 0,
+  xOffset: 0,
+};
+
+const AngleLeftIcon = createIcon(AngleLeftIconConfig);
+
+const CheckIconConfig = {
+  name: 'CheckIcon',
+  height: 512,
+  width: 512,
+  svgPath: 'M173.898 439.404l-166.4-166.4c-9.997-9.997-9.997-26.206 0-36.204l36.203-36.204c9.997-9.998 26.207-9.998 36.204 0L192 312.69 432.095 72.596c9.997-9.997 26.207-9.997 36.204 0l36.203 36.204c9.997 9.997 9.997 26.206 0 36.204l-294.4 294.401c-9.998 9.997-26.207 9.997-36.204-.001z',
+  yOffset: 0,
+  xOffset: 0,
+};
+
+const CheckIcon = createIcon(CheckIconConfig);
+
+const checkStyles = {
+  "check": "pf-v6-c-check",
+  "checkBody": "pf-v6-c-check__body",
+  "checkDescription": "pf-v6-c-check__description",
+  "checkInput": "pf-v6-c-check__input",
+  "checkLabel": "pf-v6-c-check__label",
+  "checkLabelRequired": "pf-v6-c-check__label-required",
+  "modifiers": {
+    "standalone": "pf-m-standalone",
+    "disabled": "pf-m-disabled"
+  }
+};
+
+// tslint:disable-next-line:no-empty
+const defaultOnChange = () => { };
+class Checkbox extends React.Component {
+    constructor(props) {
+        super(props);
+        this.handleChange = (event) => {
+            this.props.onChange(event, event.currentTarget.checked);
+        };
+        this.state = {
+            ouiaStateId: getDefaultOUIAId(Checkbox.displayName)
+        };
+    }
+    render() {
+        const _a = this.props, { 'aria-label': ariaLabel, className, inputClassName, onChange, isLabelWrapped, labelPosition = 'end', isValid, isDisabled, isRequired, isChecked, label, checked, defaultChecked, description, body, ouiaId, ouiaSafe, component } = _a, props = __rest(_a, ['aria-label', "className", "inputClassName", "onChange", "isLabelWrapped", "labelPosition", "isValid", "isDisabled", "isRequired", "isChecked", "label", "checked", "defaultChecked", "description", "body", "ouiaId", "ouiaSafe", "component"]);
+        if (!props.id) {
+            // eslint-disable-next-line no-console
+            console.error('Checkbox:', 'id is required to make input accessible');
+        }
+        const checkedProps = {};
+        if ([true, false].includes(checked) || isChecked === true) {
+            checkedProps.checked = checked || isChecked;
+        }
+        if (onChange !== defaultOnChange) {
+            checkedProps.checked = isChecked;
+        }
+        if ([false, true].includes(defaultChecked)) {
+            checkedProps.defaultChecked = defaultChecked;
+        }
+        const inputRendered = (React.createElement("input", Object.assign({}, props, { className: css(checkStyles.checkInput, inputClassName), type: "checkbox", onChange: this.handleChange, "aria-invalid": !isValid, "aria-label": ariaLabel, disabled: isDisabled, required: isRequired, ref: (elem) => elem && (elem.indeterminate = isChecked === null) }, checkedProps, getOUIAProps(Checkbox.displayName, ouiaId !== undefined ? ouiaId : this.state.ouiaStateId, ouiaSafe))));
+        const wrapWithLabel = (isLabelWrapped && !component) || component === 'label';
+        const Label = wrapWithLabel ? 'span' : 'label';
+        const labelRendered = label ? (React.createElement(Label, { className: css(checkStyles.checkLabel, isDisabled && checkStyles.modifiers.disabled), htmlFor: !wrapWithLabel ? props.id : undefined },
+            label,
+            isRequired && (React.createElement("span", { className: css(checkStyles.checkLabelRequired), "aria-hidden": "true" }, ASTERISK)))) : null;
+        const Component = component !== null && component !== void 0 ? component : (wrapWithLabel ? 'label' : 'div');
+        checkedProps.checked = checkedProps.checked === null ? false : checkedProps.checked;
+        return (React.createElement(Component, { className: css(checkStyles.check, !label && checkStyles.modifiers.standalone, className), htmlFor: wrapWithLabel ? props.id : undefined },
+            labelPosition === 'start' ? (React.createElement(React.Fragment, null,
+                labelRendered,
+                inputRendered)) : (React.createElement(React.Fragment, null,
+                inputRendered,
+                labelRendered)),
+            description && React.createElement("span", { className: css(checkStyles.checkDescription) }, description),
+            body && React.createElement("span", { className: css(checkStyles.checkBody) }, body)));
+    }
+}
+Checkbox.displayName = 'Checkbox';
+Checkbox.defaultProps = {
+    className: '',
+    isLabelWrapped: false,
+    isValid: true,
+    isDisabled: false,
+    isRequired: false,
+    isChecked: false,
+    onChange: defaultOnChange,
+    ouiaSafe: true
+};
+
+const StarIconConfig = {
+  name: 'StarIcon',
+  height: 512,
+  width: 576,
+  svgPath: 'M259.3 17.8L194 150.2 47.9 171.5c-26.2 3.8-36.7 36.1-17.7 54.6l105.7 103-25 145.5c-4.5 26.3 23.2 46 46.4 33.7L288 439.6l130.7 68.7c23.2 12.2 50.9-7.4 46.4-33.7l-25-145.5 105.7-103c19-18.5 8.5-50.8-17.7-54.6L382 150.2 316.7 17.8c-11.7-23.6-45.6-23.9-57.4 0z',
+  yOffset: 0,
+  xOffset: 0,
+};
+
+const StarIcon = createIcon(StarIconConfig);
+
+const MenuItemActionBase = (_a) => {
+    var { className, icon, onClick, 'aria-label': ariaLabel, isFavorited = null, isDisabled, actionId, innerRef } = _a, props = __rest(_a, ["className", "icon", "onClick", 'aria-label', "isFavorited", "isDisabled", "actionId", "innerRef"]);
+    return (React.createElement(MenuContext.Consumer, null, ({ onActionClick }) => (React.createElement(MenuItemContext.Consumer, null, ({ itemId, isDisabled: isDisabledContext }) => {
+        const onClickButton = (event) => {
+            // event specified on the MenuItemAction
+            onClick && onClick(event);
+            // event specified on the Menu
+            onActionClick && onActionClick(event, itemId, actionId);
+        };
+        return (React.createElement("div", Object.assign({ className: css(menuStyles.menuItemAction, isFavorited !== null && 'pf-m-favorite', isFavorited && menuStyles.modifiers.favorited, className) }, props),
+            React.createElement(Button, { "aria-label": ariaLabel, onClick: onClickButton, ref: innerRef, role: "menuitem", variant: "plain", tabIndex: -1, isDisabled: isDisabled || isDisabledContext, icon: icon === 'favorites' || isFavorited !== null ? React.createElement(StarIcon, { "aria-hidden": true }) : icon })));
+    }))));
+};
+const MenuItemAction = React.forwardRef((props, ref) => (React.createElement(MenuItemActionBase, Object.assign({}, props, { innerRef: ref }))));
+MenuItemAction.displayName = 'MenuItemAction';
+
+const FlyoutContext = React.createContext({
+    direction: 'right'
+});
+const MenuItemBase = (_a) => {
+    var { children, className, itemId = null, to, hasCheckbox = false, isActive = null, isFavorited = null, isLoadButton = false, isLoading = false, flyoutMenu, direction, description = null, onClick = () => { }, component = 'button', isDisabled = false, isAriaDisabled = false, isExternalLink = false, isSelected = null, isFocused, isDanger = false, icon, actions, onShowFlyout, drilldownMenu, isOnPath, innerRef, id, 'aria-label': ariaLabel, tooltipProps, rel, target, download } = _a, props = __rest(_a, ["children", "className", "itemId", "to", "hasCheckbox", "isActive", "isFavorited", "isLoadButton", "isLoading", "flyoutMenu", "direction", "description", "onClick", "component", "isDisabled", "isAriaDisabled", "isExternalLink", "isSelected", "isFocused", "isDanger", "icon", "actions", "onShowFlyout", "drilldownMenu", "isOnPath", "innerRef", "id", 'aria-label', "tooltipProps", "rel", "target", "download"]);
+    const { menuId, parentMenu, onSelect, onActionClick, activeItemId, selected, drilldownItemPath, onDrillIn, onDrillOut, flyoutRef, setFlyoutRef, disableHover, role: menuRole } = React.useContext(MenuContext);
+    let Component = (to ? 'a' : component);
+    if (hasCheckbox && !to) {
+        Component = 'label';
+    }
+    const [flyoutTarget, setFlyoutTarget] = React.useState(null);
+    const flyoutContext = React.useContext(FlyoutContext);
+    const [flyoutXDirection, setFlyoutXDirection] = React.useState(flyoutContext.direction);
+    const ref = React.useRef();
+    const flyoutVisible = ref === flyoutRef;
+    const hasFlyout = flyoutMenu !== undefined;
+    const showFlyout = (show) => {
+        if (!flyoutVisible && show) {
+            setFlyoutRef(ref);
+        }
+        else if (flyoutVisible && !show) {
+            setFlyoutRef(null);
+        }
+        onShowFlyout && show && onShowFlyout();
+    };
+    useIsomorphicLayoutEffect(() => {
+        if (hasFlyout && ref.current && canUseDOM) {
+            const flyoutMenu = ref.current.lastElementChild;
+            if (flyoutMenu && flyoutMenu.classList.contains(menuStyles.menu)) {
+                const origin = ref.current.getClientRects()[0];
+                const rect = flyoutMenu.getClientRects()[0];
+                if (origin && rect) {
+                    const spaceLeftLeft = origin.x - rect.width;
+                    const spaceLeftRight = window.innerWidth - origin.x - origin.width - rect.width;
+                    let xDir = flyoutXDirection;
+                    if (spaceLeftRight < 0 && xDir !== 'left') {
+                        setFlyoutXDirection('left');
+                        xDir = 'left';
+                    }
+                    else if (spaceLeftLeft < 0 && xDir !== 'right') {
+                        setFlyoutXDirection('right');
+                        xDir = 'right';
+                    }
+                    let xOffset = 0;
+                    if (spaceLeftLeft < 0 && spaceLeftRight < 0) {
+                        xOffset = xDir === 'right' ? -spaceLeftRight : -spaceLeftLeft;
+                    }
+                    if (xDir === 'left') {
+                        flyoutMenu.classList.add(menuStyles.modifiers.left);
+                        flyoutMenu.style.setProperty(c_menu_m_flyout__menu_m_left_right_offset.name, `-${xOffset}px`);
+                    }
+                    else {
+                        flyoutMenu.style.setProperty(c_menu_m_flyout__menu_left_offset.name, `-${xOffset}px`);
+                    }
+                    const spaceLeftBot = window.innerHeight - origin.y - rect.height;
+                    const spaceLeftTop = window.innerHeight - rect.height;
+                    if (spaceLeftTop < 0 && spaceLeftBot < 0) ;
+                    else if (spaceLeftBot < 0) {
+                        flyoutMenu.style.setProperty(c_menu_m_flyout__menu_top_offset.name, `${spaceLeftBot}px`);
+                    }
+                }
+            }
+        }
+    }, [flyoutVisible, flyoutMenu]);
+    React.useEffect(() => {
+        setFlyoutXDirection(flyoutContext.direction);
+    }, [flyoutContext]);
+    React.useEffect(() => {
+        if (flyoutTarget) {
+            if (flyoutVisible) {
+                const flyoutMenu = flyoutTarget.nextElementSibling;
+                const flyoutItems = Array.from(flyoutMenu.getElementsByTagName('UL')[0].children).filter((el) => !(el.classList.contains('pf-m-disabled') || el.classList.contains(menuStyles.divider)));
+                flyoutItems[0].firstChild.focus();
+            }
+            else {
+                flyoutTarget.focus();
+            }
+        }
+    }, [flyoutVisible, flyoutTarget]);
+    const handleFlyout = (event) => {
+        const key = event.key;
+        const target = event.target;
+        const type = event.type;
+        if (key === ' ' || key === 'Enter' || key === 'ArrowRight' || type === 'click') {
+            event.stopPropagation();
+            event.preventDefault();
+            if (!flyoutVisible) {
+                showFlyout(true);
+                setFlyoutTarget(target);
+            }
+        }
+        if (key === 'Escape' || key === 'ArrowLeft') {
+            if (flyoutVisible) {
+                event.stopPropagation();
+                showFlyout(false);
+            }
+        }
+    };
+    const onItemSelect = (event, onSelect) => {
+        if (!isAriaDisabled) {
+            // Trigger callback for Menu onSelect
+            onSelect && onSelect(event, itemId);
+            // Trigger callback for item onClick
+            onClick && onClick(event);
+        }
+    };
+    const _isOnPath = (isOnPath && isOnPath) || (drilldownItemPath && drilldownItemPath.includes(itemId)) || false;
+    let drill;
+    if (direction) {
+        if (direction === 'down') {
+            drill = (event) => onDrillIn &&
+                onDrillIn(event, menuId, typeof drilldownMenu === 'function'
+                    ? drilldownMenu().props.id
+                    : drilldownMenu.props.id, itemId);
+        }
+        else {
+            drill = (event) => onDrillOut && onDrillOut(event, parentMenu, itemId);
+        }
+    }
+    let additionalProps = {};
+    if (Component === 'a') {
+        additionalProps = {
+            href: to,
+            'aria-disabled': isDisabled || isAriaDisabled ? true : null,
+            // prevent invalid 'disabled' attribute on <a> tags
+            disabled: null,
+            target: isExternalLink ? '_blank' : target,
+            rel,
+            download
+        };
+    }
+    else if (Component === 'button') {
+        additionalProps = {
+            type: 'button',
+            'aria-disabled': isAriaDisabled ? true : null
+        };
+    }
+    if (isOnPath) {
+        additionalProps['aria-expanded'] = true;
+    }
+    else if (hasFlyout) {
+        additionalProps['aria-haspopup'] = 'menu';
+        additionalProps['aria-expanded'] = flyoutVisible;
+    }
+    const getAriaCurrent = () => {
+        if (isActive !== null) {
+            if (isActive) {
+                return 'page';
+            }
+            else {
+                return null;
+            }
+        }
+        else if (itemId !== null && activeItemId !== null) {
+            return itemId === activeItemId;
+        }
+        return null;
+    };
+    const getIsSelected = () => {
+        if (isSelected !== null) {
+            return isSelected;
+        }
+        else if (selected !== null && itemId !== null) {
+            return (Array.isArray(selected) && selected.includes(itemId)) || itemId === selected;
+        }
+        return false;
+    };
+    const onMouseOver = () => {
+        if (disableHover) {
+            return;
+        }
+        if (hasFlyout) {
+            showFlyout(true);
+        }
+        else {
+            setFlyoutRef(null);
+        }
+    };
+    React.useEffect(() => {
+        if (isFocused && ref.current) {
+            const itemEl = ref.current;
+            const parentListEl = itemEl.parentElement;
+            if (parentListEl) {
+                const isAboveTop = itemEl.offsetTop - parentListEl.offsetTop < parentListEl.scrollTop;
+                const isBelowBottom = itemEl.offsetTop - parentListEl.offsetTop + itemEl.clientHeight;
+                if (isAboveTop || isBelowBottom) {
+                    itemEl.scrollIntoView({ behavior: 'auto', block: 'nearest' });
+                }
+            }
+        }
+    }, [isFocused]);
+    const isSelectMenu = menuRole === 'listbox';
+    const renderItem = (React.createElement(React.Fragment, null,
+        React.createElement(GenerateId, null, (randomId) => (React.createElement(Component, Object.assign({ id: id, tabIndex: -1, className: css(menuStyles.menuItem, getIsSelected() && !hasCheckbox && menuStyles.modifiers.selected, className), "aria-current": getAriaCurrent() }, (!hasCheckbox && { disabled: isDisabled, 'aria-label': ariaLabel }), (!hasCheckbox && !flyoutMenu && { role: isSelectMenu ? 'option' : 'menuitem' }), (!hasCheckbox && !flyoutMenu && isSelectMenu && { 'aria-selected': getIsSelected() }), { ref: innerRef }, (!hasCheckbox && {
+            onClick: (event) => {
+                if (!isAriaDisabled) {
+                    onItemSelect(event, onSelect);
+                    drill && drill(event);
+                    flyoutMenu && handleFlyout(event);
+                }
+                else {
+                    event.preventDefault();
+                }
+            }
+        }), (hasCheckbox && { htmlFor: randomId }), additionalProps),
+            React.createElement("span", { className: css(menuStyles.menuItemMain) },
+                direction === 'up' && (React.createElement("span", { className: css(menuStyles.menuItemToggleIcon) },
+                    React.createElement(AngleLeftIcon, { "aria-hidden": true }))),
+                icon && React.createElement("span", { className: css(menuStyles.menuItemIcon) }, icon),
+                hasCheckbox && (React.createElement("span", { className: css(menuStyles.menuItemCheck) },
+                    React.createElement(Checkbox, { id: randomId, component: "span", isChecked: isSelected || false, onChange: (event) => onItemSelect(event, onSelect), isDisabled: isDisabled, "aria-disabled": isAriaDisabled }))),
+                React.createElement("span", { className: css(menuStyles.menuItemText) }, children),
+                isExternalLink && (React.createElement("span", { className: css(menuStyles.menuItemExternalIcon) },
+                    React.createElement(ExternalLinkAltIcon, { "aria-hidden": true }))),
+                (flyoutMenu || direction === 'down') && (React.createElement("span", { className: css(menuStyles.menuItemToggleIcon) },
+                    React.createElement(AngleRightIcon, { "aria-hidden": true }))),
+                getIsSelected() && (React.createElement("span", { className: css(menuStyles.menuItemSelectIcon) },
+                    React.createElement(CheckIcon, { "aria-hidden": true })))),
+            description && direction !== 'up' && (React.createElement("span", { className: css(menuStyles.menuItemDescription) },
+                React.createElement("span", null, description)))))),
+        flyoutVisible && (React.createElement(MenuContext.Provider, { value: { disableHover } },
+            React.createElement(FlyoutContext.Provider, { value: { direction: flyoutXDirection } }, flyoutMenu))),
+        typeof drilldownMenu === 'function' ? drilldownMenu() : drilldownMenu,
+        React.createElement(MenuItemContext.Provider, { value: { itemId, isDisabled } },
+            actions,
+            isFavorited !== null && (React.createElement(MenuItemAction, { icon: "favorites", isFavorited: isFavorited, "aria-label": isFavorited ? 'starred' : 'not starred', onClick: (event) => onActionClick(event, itemId), tabIndex: -1, actionId: "fav" })))));
+    return (React.createElement("li", Object.assign({ className: css(menuStyles.menuListItem, isDisabled && menuStyles.modifiers.disabled, isAriaDisabled && menuStyles.modifiers.ariaDisabled, _isOnPath && menuStyles.modifiers.currentPath, isLoadButton && menuStyles.modifiers.load, isLoading && menuStyles.modifiers.loading, isFocused && 'pf-m-focus', isDanger && menuStyles.modifiers.danger, className), onMouseOver: () => {
+            if (!isAriaDisabled) {
+                onMouseOver();
+            }
+        } }, (flyoutMenu && !isAriaDisabled && { onKeyDown: handleFlyout }), { ref: ref, role: !hasCheckbox ? 'none' : 'menuitem' }, (hasCheckbox && { 'aria-label': ariaLabel }), props), tooltipProps ? React.createElement(Tooltip, Object.assign({}, tooltipProps), renderItem) : renderItem));
+};
+const MenuItem = React.forwardRef((props, ref) => (React.createElement(MenuItemBase, Object.assign({}, props, { innerRef: ref }))));
+MenuItem.displayName = 'MenuItem';
+
+const MenuList = (_a) => {
+    var { children = null, className, isAriaMultiselectable = false, 'aria-label': ariaLabel } = _a, props = __rest(_a, ["children", "className", "isAriaMultiselectable", 'aria-label']);
+    const { role } = React.useContext(MenuContext);
+    return (React.createElement("ul", Object.assign({ role: role }, (role === 'listbox' && { 'aria-multiselectable': isAriaMultiselectable }), { className: css(menuStyles.menuList, className), "aria-label": ariaLabel }, props), children));
+};
+MenuList.displayName = 'MenuList';
+
+const styles = {
+  "menuToggle": "pf-v6-c-menu-toggle",
+  "menuToggleButton": "pf-v6-c-menu-toggle__button",
+  "menuToggleControls": "pf-v6-c-menu-toggle__controls",
+  "menuToggleCount": "pf-v6-c-menu-toggle__count",
+  "menuToggleIcon": "pf-v6-c-menu-toggle__icon",
+  "menuToggleStatusIcon": "pf-v6-c-menu-toggle__status-icon",
+  "menuToggleText": "pf-v6-c-menu-toggle__text",
+  "menuToggleToggleIcon": "pf-v6-c-menu-toggle__toggle-icon",
+  "modifiers": {
+    "primary": "pf-m-primary",
+    "secondary": "pf-m-secondary",
+    "fullHeight": "pf-m-full-height",
+    "fullWidth": "pf-m-full-width",
+    "plain": "pf-m-plain",
+    "expanded": "pf-m-expanded",
+    "disabled": "pf-m-disabled",
+    "small": "pf-m-small",
+    "success": "pf-m-success",
+    "warning": "pf-m-warning",
+    "danger": "pf-m-danger",
+    "placeholder": "pf-m-placeholder",
+    "splitButton": "pf-m-split-button",
+    "standalone": "pf-m-standalone",
+    "typeahead": "pf-m-typeahead",
+    "text": "pf-m-text",
+    "avatar": "pf-m-avatar"
+  }};
+
+const CaretDownIconConfig = {
+  name: 'CaretDownIcon',
+  height: 512,
+  width: 320,
+  svgPath: 'M31.3 192h257.3c17.8 0 26.7 21.5 14.1 34.1L174.1 354.8c-7.8 7.8-20.5 7.8-28.3 0L17.2 226.1C4.6 213.5 13.5 192 31.3 192z',
+  yOffset: 0,
+  xOffset: 0,
+};
+
+const CaretDownIcon = createIcon(CaretDownIconConfig);
+
+var MenuToggleStatus;
+(function (MenuToggleStatus) {
+    MenuToggleStatus["success"] = "success";
+    MenuToggleStatus["danger"] = "danger";
+    MenuToggleStatus["warning"] = "warning";
+})(MenuToggleStatus || (MenuToggleStatus = {}));
+var MenuToggleSize;
+(function (MenuToggleSize) {
+    MenuToggleSize["default"] = "default";
+    MenuToggleSize["sm"] = "sm";
+})(MenuToggleSize || (MenuToggleSize = {}));
+class MenuToggleBase extends React.Component {
+    constructor() {
+        super(...arguments);
+        this.displayName = 'MenuToggleBase';
+        this.state = {
+            ouiaStateId: getDefaultOUIAId(MenuToggle.displayName, this.props.variant)
+        };
+    }
+    render() {
+        const _a = this.props, { children, className, icon, badge, isExpanded, isDisabled, isFullHeight, isFullWidth, isPlaceholder, splitButtonItems, variant, status, statusIcon, innerRef, onClick, 'aria-label': ariaLabel, ouiaId, ouiaSafe, size } = _a, otherProps = __rest(_a, ["children", "className", "icon", "badge", "isExpanded", "isDisabled", "isFullHeight", "isFullWidth", "isPlaceholder", "splitButtonItems", "variant", "status", "statusIcon", "innerRef", "onClick", 'aria-label', "ouiaId", "ouiaSafe", "size"]);
+        const isPlain = variant === 'plain';
+        const isPlainText = variant === 'plainText';
+        const isTypeahead = variant === 'typeahead';
+        const ouiaProps = getOUIAProps(MenuToggle.displayName, ouiaId !== null && ouiaId !== void 0 ? ouiaId : this.state.ouiaStateId, ouiaSafe);
+        let _statusIcon = statusIcon;
+        if (!statusIcon) {
+            switch (status) {
+                case MenuToggleStatus.success:
+                    _statusIcon = React.createElement(CheckCircleIcon, { "aria-hidden": "true" });
+                    break;
+                case MenuToggleStatus.warning:
+                    _statusIcon = React.createElement(ExclamationTriangleIcon, { "aria-hidden": "true" });
+                    break;
+                case MenuToggleStatus.danger:
+                    _statusIcon = React.createElement(ExclamationCircleIcon, { "aria-hidden": "true" });
+                    break;
+            }
+        }
+        const toggleControls = (React.createElement("span", { className: css(styles.menuToggleControls) },
+            status !== undefined && React.createElement("span", { className: css(styles.menuToggleStatusIcon) }, _statusIcon),
+            React.createElement("span", { className: css(styles.menuToggleToggleIcon) },
+                React.createElement(CaretDownIcon, { "aria-hidden": true }))));
+        const content = (React.createElement(React.Fragment, null,
+            icon && React.createElement("span", { className: css(styles.menuToggleIcon) }, icon),
+            isTypeahead ? children : children && React.createElement("span", { className: css(styles.menuToggleText) }, children),
+            React.isValidElement(badge) && React.createElement("span", { className: css(styles.menuToggleCount) }, badge),
+            isTypeahead ? (React.createElement("button", Object.assign({ type: "button", className: css(styles.menuToggleButton), "aria-expanded": isExpanded, onClick: onClick, "aria-label": ariaLabel || 'Menu toggle', tabIndex: -1 }, ouiaProps), toggleControls)) : (!isPlain && toggleControls)));
+        const commonStyles = css(styles.menuToggle, isExpanded && styles.modifiers.expanded, variant === 'primary' && styles.modifiers.primary, variant === 'secondary' && styles.modifiers.secondary, status && styles.modifiers[status], (isPlain || isPlainText) && styles.modifiers.plain, isPlainText && 'pf-m-text', isFullHeight && styles.modifiers.fullHeight, isFullWidth && styles.modifiers.fullWidth, isDisabled && styles.modifiers.disabled, isPlaceholder && styles.modifiers.placeholder, size === MenuToggleSize.sm && styles.modifiers.small, className);
+        const componentProps = Object.assign(Object.assign({ children: content }, (isDisabled && { disabled: true })), otherProps);
+        if (isTypeahead) {
+            return (React.createElement("div", Object.assign({ ref: innerRef, className: css(commonStyles, styles.modifiers.typeahead) }, componentProps)));
+        }
+        if (splitButtonItems) {
+            return (React.createElement("div", { ref: innerRef, className: css(commonStyles, styles.modifiers.splitButton) },
+                splitButtonItems,
+                React.createElement("button", Object.assign({ className: css(styles.menuToggleButton, children && styles.modifiers.text), type: "button", "aria-expanded": isExpanded, "aria-label": ariaLabel, disabled: isDisabled, onClick: onClick }, otherProps, ouiaProps),
+                    children && React.createElement("span", { className: css(styles.menuToggleText) }, children),
+                    toggleControls)));
+        }
+        return (React.createElement("button", Object.assign({ className: css(commonStyles), type: "button", "aria-label": ariaLabel, "aria-expanded": isExpanded, ref: innerRef, disabled: isDisabled, onClick: onClick }, componentProps, ouiaProps)));
+    }
+}
+MenuToggleBase.defaultProps = {
+    className: '',
+    isExpanded: false,
+    isDisabled: false,
+    isFullWidth: false,
+    isFullHeight: false,
+    isPlaceholder: false,
+    size: 'default',
+    ouiaSafe: true
+};
+const MenuToggle = React.forwardRef((props, ref) => (React.createElement(MenuToggleBase, Object.assign({ innerRef: ref }, props))));
+MenuToggle.displayName = 'MenuToggle';
+
+const dividerStyles = {
+  "divider": "pf-v6-c-divider",
+  "modifiers": {
+    "hidden": "pf-m-hidden",
+    "hiddenOnSm": "pf-m-hidden-on-sm",
+    "visibleOnSm": "pf-m-visible-on-sm",
+    "hiddenOnMd": "pf-m-hidden-on-md",
+    "visibleOnMd": "pf-m-visible-on-md",
+    "hiddenOnLg": "pf-m-hidden-on-lg",
+    "visibleOnLg": "pf-m-visible-on-lg",
+    "hiddenOnXl": "pf-m-hidden-on-xl",
+    "visibleOnXl": "pf-m-visible-on-xl",
+    "hiddenOn_2xl": "pf-m-hidden-on-2xl",
+    "visibleOn_2xl": "pf-m-visible-on-2xl",
+    "horizontal": "pf-m-horizontal",
+    "vertical": "pf-m-vertical",
+    "insetNone": "pf-m-inset-none",
+    "insetXs": "pf-m-inset-xs",
+    "insetSm": "pf-m-inset-sm",
+    "insetMd": "pf-m-inset-md",
+    "insetLg": "pf-m-inset-lg",
+    "insetXl": "pf-m-inset-xl",
+    "inset_2xl": "pf-m-inset-2xl",
+    "inset_3xl": "pf-m-inset-3xl",
+    "horizontalOnSm": "pf-m-horizontal-on-sm",
+    "verticalOnSm": "pf-m-vertical-on-sm",
+    "insetNoneOnSm": "pf-m-inset-none-on-sm",
+    "insetXsOnSm": "pf-m-inset-xs-on-sm",
+    "insetSmOnSm": "pf-m-inset-sm-on-sm",
+    "insetMdOnSm": "pf-m-inset-md-on-sm",
+    "insetLgOnSm": "pf-m-inset-lg-on-sm",
+    "insetXlOnSm": "pf-m-inset-xl-on-sm",
+    "inset_2xlOnSm": "pf-m-inset-2xl-on-sm",
+    "inset_3xlOnSm": "pf-m-inset-3xl-on-sm",
+    "horizontalOnMd": "pf-m-horizontal-on-md",
+    "verticalOnMd": "pf-m-vertical-on-md",
+    "insetNoneOnMd": "pf-m-inset-none-on-md",
+    "insetXsOnMd": "pf-m-inset-xs-on-md",
+    "insetSmOnMd": "pf-m-inset-sm-on-md",
+    "insetMdOnMd": "pf-m-inset-md-on-md",
+    "insetLgOnMd": "pf-m-inset-lg-on-md",
+    "insetXlOnMd": "pf-m-inset-xl-on-md",
+    "inset_2xlOnMd": "pf-m-inset-2xl-on-md",
+    "inset_3xlOnMd": "pf-m-inset-3xl-on-md",
+    "horizontalOnLg": "pf-m-horizontal-on-lg",
+    "verticalOnLg": "pf-m-vertical-on-lg",
+    "insetNoneOnLg": "pf-m-inset-none-on-lg",
+    "insetXsOnLg": "pf-m-inset-xs-on-lg",
+    "insetSmOnLg": "pf-m-inset-sm-on-lg",
+    "insetMdOnLg": "pf-m-inset-md-on-lg",
+    "insetLgOnLg": "pf-m-inset-lg-on-lg",
+    "insetXlOnLg": "pf-m-inset-xl-on-lg",
+    "inset_2xlOnLg": "pf-m-inset-2xl-on-lg",
+    "inset_3xlOnLg": "pf-m-inset-3xl-on-lg",
+    "horizontalOnXl": "pf-m-horizontal-on-xl",
+    "verticalOnXl": "pf-m-vertical-on-xl",
+    "insetNoneOnXl": "pf-m-inset-none-on-xl",
+    "insetXsOnXl": "pf-m-inset-xs-on-xl",
+    "insetSmOnXl": "pf-m-inset-sm-on-xl",
+    "insetMdOnXl": "pf-m-inset-md-on-xl",
+    "insetLgOnXl": "pf-m-inset-lg-on-xl",
+    "insetXlOnXl": "pf-m-inset-xl-on-xl",
+    "inset_2xlOnXl": "pf-m-inset-2xl-on-xl",
+    "inset_3xlOnXl": "pf-m-inset-3xl-on-xl",
+    "horizontalOn_2xl": "pf-m-horizontal-on-2xl",
+    "verticalOn_2xl": "pf-m-vertical-on-2xl",
+    "insetNoneOn_2xl": "pf-m-inset-none-on-2xl",
+    "insetXsOn_2xl": "pf-m-inset-xs-on-2xl",
+    "insetSmOn_2xl": "pf-m-inset-sm-on-2xl",
+    "insetMdOn_2xl": "pf-m-inset-md-on-2xl",
+    "insetLgOn_2xl": "pf-m-inset-lg-on-2xl",
+    "insetXlOn_2xl": "pf-m-inset-xl-on-2xl",
+    "inset_2xlOn_2xl": "pf-m-inset-2xl-on-2xl",
+    "inset_3xlOn_2xl": "pf-m-inset-3xl-on-2xl"
+  }
+};
+
+var DividerVariant;
+(function (DividerVariant) {
+    DividerVariant["hr"] = "hr";
+    DividerVariant["li"] = "li";
+    DividerVariant["div"] = "div";
+})(DividerVariant || (DividerVariant = {}));
+const Divider = (_a) => {
+    var { className, component = DividerVariant.hr, inset, orientation } = _a, props = __rest(_a, ["className", "component", "inset", "orientation"]);
+    const Component = component;
+    return (React.createElement(Component, Object.assign({ className: css(dividerStyles.divider, formatBreakpointMods(inset, dividerStyles), formatBreakpointMods(orientation, dividerStyles), className) }, (component !== 'hr' && { role: 'separator' }), props)));
+};
+Divider.displayName = 'Divider';
+
+const DropdownBase = (_a) => {
+    var { children, className, onSelect, isOpen, toggle, shouldFocusToggleOnSelect = false, onOpenChange, onToggleKeydown, isPlain, isScrollable, innerRef, ouiaId, ouiaSafe = true, zIndex = 9999, popperProps, onOpenChangeKeys = ['Escape', 'Tab'], menuHeight, maxMenuHeight, shouldFocusFirstItemOnOpen = false, shouldPreventScrollOnItemFocus = true, focusTimeoutDelay = 0 } = _a, props = __rest(_a, ["children", "className", "onSelect", "isOpen", "toggle", "shouldFocusToggleOnSelect", "onOpenChange", "onToggleKeydown", "isPlain", "isScrollable", "innerRef", "ouiaId", "ouiaSafe", "zIndex", "popperProps", "onOpenChangeKeys", "menuHeight", "maxMenuHeight", "shouldFocusFirstItemOnOpen", "shouldPreventScrollOnItemFocus", "focusTimeoutDelay"]);
+    const localMenuRef = React__default.useRef();
+    const localToggleRef = React__default.useRef();
+    const ouiaProps = useOUIAProps(Dropdown.displayName, ouiaId, ouiaSafe);
+    const menuRef = innerRef || localMenuRef;
+    const toggleRef = typeof toggle === 'function' || (typeof toggle !== 'function' && !toggle.toggleRef)
+        ? localToggleRef
+        : toggle === null || toggle === void 0 ? void 0 : toggle.toggleRef;
+    const prevIsOpen = React__default.useRef(isOpen);
+    React__default.useEffect(() => {
+        // menu was opened, focus on first menu item
+        if (prevIsOpen.current === false && isOpen === true && shouldFocusFirstItemOnOpen) {
+            setTimeout(() => {
+                var _a;
+                const firstElement = (_a = menuRef === null || menuRef === void 0 ? void 0 : menuRef.current) === null || _a === void 0 ? void 0 : _a.querySelector('li button:not(:disabled),li input:not(:disabled),li a:not([aria-disabled="true"])');
+                firstElement && firstElement.focus({ preventScroll: shouldPreventScrollOnItemFocus });
+            }, focusTimeoutDelay);
+        }
+        prevIsOpen.current = isOpen;
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [isOpen]);
+    React__default.useEffect(() => {
+        const handleMenuKeys = (event) => {
+            var _a, _b, _c, _d;
+            // Close the menu on tab or escape if onOpenChange is provided
+            if (isOpen &&
+                onOpenChange &&
+                (((_a = menuRef.current) === null || _a === void 0 ? void 0 : _a.contains(event.target)) || ((_b = toggleRef.current) === null || _b === void 0 ? void 0 : _b.contains(event.target)))) {
+                if (onOpenChangeKeys.includes(event.key)) {
+                    onOpenChange(false);
+                    (_c = toggleRef.current) === null || _c === void 0 ? void 0 : _c.focus();
+                }
+            }
+            if ((_d = toggleRef.current) === null || _d === void 0 ? void 0 : _d.contains(event.target)) {
+                if (onToggleKeydown) {
+                    onToggleKeydown(event);
+                }
+                else if (isOpen) {
+                    onToggleArrowKeydownDefault(event, menuRef);
+                }
+            }
+        };
+        const handleClick = (event) => {
+            var _a, _b;
+            // If the event is not on the toggle and onOpenChange callback is provided, close the menu
+            if (isOpen && onOpenChange && !((_a = toggleRef === null || toggleRef === void 0 ? void 0 : toggleRef.current) === null || _a === void 0 ? void 0 : _a.contains(event.target))) {
+                if (isOpen && !((_b = menuRef.current) === null || _b === void 0 ? void 0 : _b.contains(event.target))) {
+                    onOpenChange(false);
+                }
+            }
+        };
+        window.addEventListener('keydown', handleMenuKeys);
+        window.addEventListener('click', handleClick);
+        return () => {
+            window.removeEventListener('keydown', handleMenuKeys);
+            window.removeEventListener('click', handleClick);
+        };
+    }, [
+        isOpen,
+        menuRef,
+        toggleRef,
+        onOpenChange,
+        onOpenChangeKeys,
+        onToggleKeydown,
+        shouldPreventScrollOnItemFocus,
+        shouldFocusFirstItemOnOpen,
+        focusTimeoutDelay
+    ]);
+    const scrollable = maxMenuHeight !== undefined || menuHeight !== undefined || isScrollable;
+    const menu = (React__default.createElement(Menu, Object.assign({ className: css(className), ref: menuRef, onSelect: (event, value) => {
+            var _a;
+            onSelect && onSelect(event, value);
+            shouldFocusToggleOnSelect && ((_a = toggleRef.current) === null || _a === void 0 ? void 0 : _a.focus());
+        }, isPlain: isPlain, isScrollable: scrollable }, props, ouiaProps),
+        React__default.createElement(MenuContent, { menuHeight: menuHeight, maxMenuHeight: maxMenuHeight }, children)));
+    return (React__default.createElement(Popper, Object.assign({ trigger: typeof toggle === 'function' ? toggle(toggleRef) : toggle.toggleNode, triggerRef: toggleRef, popper: menu, popperRef: menuRef, isVisible: isOpen, zIndex: zIndex }, popperProps)));
+};
+const Dropdown = React__default.forwardRef((props, ref) => (React__default.createElement(DropdownBase, Object.assign({ innerRef: ref }, props))));
+Dropdown.displayName = 'Dropdown';
+
+const DropdownItemBase = (_a) => {
+    var { children, className, description, isDisabled, isAriaDisabled, value, onClick, ouiaId, ouiaSafe, innerRef, tooltipProps } = _a, props = __rest(_a, ["children", "className", "description", "isDisabled", "isAriaDisabled", "value", "onClick", "ouiaId", "ouiaSafe", "innerRef", "tooltipProps"]);
+    const ouiaProps = useOUIAProps(DropdownItem.displayName, ouiaId, ouiaSafe);
+    return (React__default.createElement(MenuItem, Object.assign({ className: css(className), description: description, isDisabled: isDisabled, isAriaDisabled: isAriaDisabled, itemId: value, onClick: onClick, tooltipProps: tooltipProps, ref: innerRef }, ouiaProps, props), children));
+};
+const DropdownItem = React__default.forwardRef((props, ref) => (React__default.createElement(DropdownItemBase, Object.assign({}, props, { innerRef: ref }))));
+DropdownItem.displayName = 'DropdownItem';
+
+const DropdownList = (_a) => {
+    var { children, className } = _a, props = __rest(_a, ["children", "className"]);
+    return (React__default.createElement(MenuList, Object.assign({ className: css(className) }, props), children));
+};
+DropdownList.displayName = 'DropdownList';
+
+const AngleDownIconConfig = {
+  name: 'AngleDownIcon',
+  height: 512,
+  width: 320,
+  svgPath: 'M143 352.3L7 216.3c-9.4-9.4-9.4-24.6 0-33.9l22.6-22.6c9.4-9.4 24.6-9.4 33.9 0l96.4 96.4 96.4-96.4c9.4-9.4 24.6-9.4 33.9 0l22.6 22.6c9.4 9.4 9.4 24.6 0 33.9l-136 136c-9.2 9.4-24.4 9.4-33.8 0z',
+  yOffset: 0,
+  xOffset: 0,
+};
+
+const AngleDownIcon = createIcon(AngleDownIconConfig);
+
+export { ASTERISK as A, Button as B, CheckCircleIcon as C, Divider as D, ExclamationTriangleIcon as E, getUniqueId as F, GenerateId as G, useIsomorphicLayoutEffect as H, Tooltip as I, BellIcon as J, KeyTypes as K, InfoCircleIcon as L, MenuToggle as M, checkStyles as N, StarIcon as O, Popper as P, Checkbox as Q, setTabIndex as R, Spinner as S, TimesIcon as T, handleArrows as U, ValidatedOptions as V, canUseDOM as a, createIcon as b, css as c, ExclamationCircleIcon as d, getOUIAProps as e, statusIcons as f, getDefaultOUIAId as g, ButtonVariant as h, CaretDownIcon as i, Badge as j, AngleDownIcon as k, getVerticalBreakpoint as l, menuStyles as m, getBreakpoint as n, formatBreakpointMods as o, t_global_breakpoint_2xl as p, t_global_breakpoint_xl as q, t_global_breakpoint_lg as r, setBreakpointCssVars as s, trimLeft as t, useOUIAProps as u, t_global_breakpoint_md as v, toCamel as w, Dropdown as x, DropdownList as y, DropdownItem as z };