@patternfly/patternfly-doc-core 1.10.0 → 1.11.1

package/dist/server/chunks/angle-down-icon_BO1Ed-9Z.mjs

@@ -1,3288 +0,0 @@
-import { r as getUniqueId, a as canUseDOM, w as getLanguageDirection, x as clearTimeouts, c as css, b as createIcon, K as KeyTypes, g as getDefaultOUIAId, e as getOUIAProps, B as Button, d as ExclamationCircleIcon, E as ExclamationTriangleIcon, C as CheckCircleIcon, l as formatBreakpointMods, u as useOUIAProps } from './Button_BKhHR-ak.mjs';
-import { __rest } from 'tslib';
-import { jsxs, Fragment, jsx } from 'react/jsx-runtime';
-import { Component, useLayoutEffect, useEffect, useRef, useState, useMemo, useCallback, isValidElement, cloneElement, createRef, createContext, forwardRef, useContext } from 'react';
-/* empty css                          */
-import * as ReactDOM from 'react-dom';
-
-/** 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 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 = '*';
-
-/**
- * @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 ? useLayoutEffect : 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 = useRef(null);
-    const optionsWithDefaults = {
-        onFirstUpdate: options.onFirstUpdate,
-        placement: options.placement || 'bottom',
-        strategy: options.strategy || 'absolute',
-        modifiers: options.modifiers || EMPTY_MODIFIERS
-    };
-    const [state, setState] = useState({
-        styles: {
-            popper: {
-                position: optionsWithDefaults.strategy,
-                left: '0',
-                top: '0'
-            }
-        },
-        attributes: {}
-    });
-    const updateStateModifier = 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 = 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 = useRef(undefined);
-    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] = useState(null);
-    const [refElement, setRefElement] = useState(null);
-    const [popperElement, setPopperElement] = useState(null);
-    const [popperContent, setPopperContent] = useState(null);
-    const [ready, setReady] = useState(false);
-    const [opacity, setOpacity] = useState(0);
-    const [internalIsVisible, setInternalIsVisible] = useState(isVisible);
-    const transitionTimerRef = useRef(null);
-    const showTimerRef = useRef(null);
-    const hideTimerRef = useRef(null);
-    const prevExitDelayRef = useRef(undefined);
-    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 = 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 = useCallback((event) => onDocumentClick(event, refOrTrigger, popperElement), [showPopper, triggerElement, refElement, popperElement, onDocumentClick]);
-    useEffect(() => {
-        setReady(true);
-        onMount();
-    }, []);
-    // Cancel all timers on unmount
-    useEffect(() => () => {
-        clearTimeouts([transitionTimerRef, hideTimerRef, showTimerRef]);
-    }, []);
-    useEffect(() => {
-        if (triggerRef) {
-            if (triggerRef.current) {
-                setRefElement(triggerRef.current);
-            }
-            else if (typeof triggerRef === 'function') {
-                setRefElement(triggerRef());
-            }
-        }
-    }, [triggerRef, trigger]);
-    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]);
-    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 });
-        }
-    };
-    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 = useMemo(getPlacement, [direction, internalPosition, placement]);
-    const getOppositePlacementMemo = useMemo(() => getOppositePlacement(getPlacement()), [direction, internalPosition, placement]);
-    const widthMods = 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
-     */
-    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]);
-    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);
-    };
-    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 = cloneElement(popper, options);
-        return popperRef ? (localPopper) : (jsx("div", { style: { display: 'contents' }, ref: (node) => {
-                setPopperElement(node === null || node === void 0 ? void 0 : node.firstElementChild);
-            }, children: localPopper }));
-    };
-    const getPopper = () => {
-        if (appendTo === 'inline') {
-            return getMenuWithPopper();
-        }
-        else {
-            const target = typeof appendTo === 'function' ? appendTo() : appendTo;
-            return ReactDOM.createPortal(getMenuWithPopper(), target);
-        }
-    };
-    return (jsxs(Fragment, { children: [!triggerRef && trigger && isValidElement(trigger) && (jsx("div", { style: { display: 'contents' }, ref: (node) => {
-                    setTriggerElement(node === null || node === void 0 ? void 0 : node.firstElementChild);
-                }, children: trigger })), triggerRef && trigger && 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 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);
-            // Initialize 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 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 (jsx("div", Object.assign({ className: css(styles$1.tooltipContent, isLeftAligned && styles$1.modifiers.textAlignLeft, className) }, props, { children: children })));
-};
-TooltipContent.displayName = 'TooltipContent';
-
-const TooltipArrow = (_a) => {
-    var { className } = _a, props = __rest(_a, ["className"]);
-    return jsx("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] = useState(false);
-    const popperRef = 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();
-            }
-        }
-    };
-    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 = (jsxs("div", Object.assign({ "aria-live": ariaLive, className: css(styles$1.tooltip, className), role: "tooltip", id: id, style: {
-            maxWidth: hasCustomMaxWidth ? maxWidth : null
-        }, ref: popperRef }, rest, { children: [jsx(TooltipArrow, {}), jsx(TooltipContent, { isLeftAligned: isContentLeftAligned, children: 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 cloneElement(children, { 'aria-describedby': id });
-        }
-        else if (aria === 'labelledby' && children.props && !children.props['aria-labelledby']) {
-            return cloneElement(children, { 'aria-labelledby': id });
-        }
-        return children;
-    };
-    return (jsx(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 = 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 = createContext({
-    itemId: null,
-    isDisabled: false
-});
-
-class MenuBase extends Component {
-    constructor(props) {
-        super(props);
-        this.menuRef = 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 (jsxs(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
-            }, children: [isRootMenu && (jsx(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 })), jsx("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: children }))] }));
-    }
-}
-MenuBase.displayName = 'Menu';
-MenuBase.contextType = MenuContext;
-MenuBase.defaultProps = {
-    ouiaSafe: true,
-    isRootMenu: true,
-    isPlain: false,
-    isScrollable: false,
-    role: 'menu'
-};
-const Menu = forwardRef((props, ref) => (jsx(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 = forwardRef((props, ref) => {
-    const { getHeight, children, menuHeight, maxMenuHeight } = props, rest = __rest(props, ["getHeight", "children", "menuHeight", "maxMenuHeight"]);
-    const menuContentRef = 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 (jsx(MenuContext.Consumer, { children: ({ menuId, onGetMenuHeight }) => (jsx("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: 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 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 = (jsx("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 ? (jsxs(Label, { className: css(checkStyles.checkLabel, isDisabled && checkStyles.modifiers.disabled), htmlFor: !wrapWithLabel ? props.id : undefined, children: [label, isRequired && (jsx("span", { className: css(checkStyles.checkLabelRequired), "aria-hidden": "true", children: ASTERISK }))] })) : null;
-        const Component = component !== null && component !== void 0 ? component : (wrapWithLabel ? 'label' : 'div');
-        checkedProps.checked = checkedProps.checked === null ? false : checkedProps.checked;
-        return (jsxs(Component, { className: css(checkStyles.check, !label && checkStyles.modifiers.standalone, className), htmlFor: wrapWithLabel ? props.id : undefined, children: [labelPosition === 'start' ? (jsxs(Fragment, { children: [labelRendered, inputRendered] })) : (jsxs(Fragment, { children: [inputRendered, labelRendered] })), description && jsx("span", { className: css(checkStyles.checkDescription), children: description }), body && jsx("span", { className: css(checkStyles.checkBody), children: 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 (jsx(MenuContext.Consumer, { children: ({ onActionClick }) => (jsx(MenuItemContext.Consumer, { children: ({ 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 (jsx("div", Object.assign({ className: css(menuStyles.menuItemAction, isFavorited !== null && 'pf-m-favorite', isFavorited && menuStyles.modifiers.favorited, className) }, props, { children: jsx(Button, { "aria-label": ariaLabel, onClick: onClickButton, ref: innerRef, role: "menuitem", variant: "plain", tabIndex: -1, isDisabled: isDisabled || isDisabledContext, icon: icon === 'favorites' || isFavorited !== null ? jsx(StarIcon, {}) : icon }) })));
-            } })) }));
-};
-const MenuItemAction = forwardRef((props, ref) => (jsx(MenuItemActionBase, Object.assign({}, props, { innerRef: ref }))));
-MenuItemAction.displayName = 'MenuItemAction';
-
-const FlyoutContext = 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 } = useContext(MenuContext);
-    let Component = (to ? 'a' : component);
-    if (hasCheckbox && !to) {
-        Component = 'label';
-    }
-    const [flyoutTarget, setFlyoutTarget] = useState(null);
-    const flyoutContext = useContext(FlyoutContext);
-    const [flyoutXDirection, setFlyoutXDirection] = useState(flyoutContext.direction);
-    const ref = useRef(undefined);
-    const privateRef = useRef(undefined);
-    const innerComponentRef = innerRef || privateRef;
-    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]);
-    useEffect(() => {
-        setFlyoutXDirection(flyoutContext.direction);
-    }, [flyoutContext]);
-    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);
-        }
-    };
-    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 = (jsxs(Fragment, { children: [jsx(GenerateId, { children: (randomId) => (jsxs(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: innerComponentRef }, (!hasCheckbox && {
-                    onClick: (event) => {
-                        if (!isAriaDisabled) {
-                            onItemSelect(event, onSelect);
-                            drill && drill(event);
-                            flyoutMenu && handleFlyout(event);
-                        }
-                        else {
-                            event.preventDefault();
-                        }
-                    }
-                }), (hasCheckbox && { htmlFor: randomId }), additionalProps, { children: [jsxs("span", { className: css(menuStyles.menuItemMain), children: [direction === 'up' && (jsx("span", { className: css(menuStyles.menuItemToggleIcon), children: jsx(AngleLeftIcon, {}) })), icon && jsx("span", { className: css(menuStyles.menuItemIcon), children: icon }), hasCheckbox && (jsx("span", { className: css(menuStyles.menuItemCheck), children: jsx(Checkbox, { id: randomId, component: "span", isChecked: isSelected || false, onChange: (event) => onItemSelect(event, onSelect), isDisabled: isDisabled, "aria-disabled": isAriaDisabled }) })), jsx("span", { className: css(menuStyles.menuItemText), children: children }), isExternalLink && (jsx("span", { className: css(menuStyles.menuItemExternalIcon), children: jsx(ExternalLinkAltIcon, {}) })), (flyoutMenu || direction === 'down') && (jsx("span", { className: css(menuStyles.menuItemToggleIcon), children: jsx(AngleRightIcon, {}) })), getIsSelected() && (jsx("span", { className: css(menuStyles.menuItemSelectIcon), children: jsx(CheckIcon, {}) }))] }), description && direction !== 'up' && (jsx("span", { className: css(menuStyles.menuItemDescription), children: jsx("span", { children: description }) }))] }))) }), flyoutVisible && (jsx(MenuContext.Provider, { value: { disableHover }, children: jsx(FlyoutContext.Provider, { value: { direction: flyoutXDirection }, children: flyoutMenu }) })), typeof drilldownMenu === 'function' ? drilldownMenu() : drilldownMenu, jsxs(MenuItemContext.Provider, { value: { itemId, isDisabled }, children: [actions, isFavorited !== null && (jsx(MenuItemAction, { icon: "favorites", isFavorited: isFavorited, "aria-label": isFavorited ? 'starred' : 'not starred', onClick: (event) => onActionClick(event, itemId), tabIndex: -1, actionId: "fav" }))] })] }));
-    return (jsxs(Fragment, { children: [jsx("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, { children: renderItem })), tooltipProps && jsx(Tooltip, Object.assign({}, tooltipProps, { triggerRef: innerComponentRef }))] }));
-};
-const MenuItem = forwardRef((props, ref) => (jsx(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 } = useContext(MenuContext);
-    return (jsx("ul", Object.assign({ role: role }, (role === 'listbox' && { 'aria-multiselectable': isAriaMultiselectable }), { className: css(menuStyles.menuList, className), "aria-label": ariaLabel }, props, { children: 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 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 = jsx(CheckCircleIcon, {});
-                    break;
-                case MenuToggleStatus.warning:
-                    _statusIcon = jsx(ExclamationTriangleIcon, {});
-                    break;
-                case MenuToggleStatus.danger:
-                    _statusIcon = jsx(ExclamationCircleIcon, {});
-                    break;
-            }
-        }
-        const toggleControls = (jsxs("span", { className: css(styles.menuToggleControls), children: [status !== undefined && jsx("span", { className: css(styles.menuToggleStatusIcon), children: _statusIcon }), jsx("span", { className: css(styles.menuToggleToggleIcon), children: jsx(CaretDownIcon, {}) })] }));
-        const content = (jsxs(Fragment, { children: [icon && jsx("span", { className: css(styles.menuToggleIcon), children: icon }), isTypeahead ? children : children && jsx("span", { className: css(styles.menuToggleText), children: children }), isValidElement(badge) && jsx("span", { className: css(styles.menuToggleCount), children: badge }), isTypeahead ? (jsx("button", Object.assign({ type: "button", className: css(styles.menuToggleButton), "aria-expanded": isExpanded, onClick: onClick, "aria-label": ariaLabel || 'Menu toggle', tabIndex: -1 }, ouiaProps, { children: 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 (jsx("div", Object.assign({ ref: innerRef, className: css(commonStyles, styles.modifiers.typeahead) }, componentProps)));
-        }
-        if (splitButtonItems) {
-            return (jsxs("div", { ref: innerRef, className: css(commonStyles, styles.modifiers.splitButton), children: [splitButtonItems, jsxs("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: [children && jsx("span", { className: css(styles.menuToggleText), children: children }), toggleControls] }))] }));
-        }
-        return (jsx("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 = forwardRef((props, ref) => (jsx(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 (jsx(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 = useRef(undefined);
-    const localToggleRef = useRef(undefined);
-    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 = useRef(isOpen);
-    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]);
-    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 = (jsx(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, { children: jsx(MenuContent, { menuHeight: menuHeight, maxMenuHeight: maxMenuHeight, children: children }) })));
-    return (jsx(Popper, Object.assign({ trigger: typeof toggle === 'function' ? toggle(toggleRef) : toggle.toggleNode, triggerRef: toggleRef, popper: menu, popperRef: menuRef, isVisible: isOpen, zIndex: zIndex }, popperProps)));
-};
-const Dropdown = forwardRef((props, ref) => (jsx(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 (jsx(MenuItem, Object.assign({ className: css(className), description: description, isDisabled: isDisabled, isAriaDisabled: isAriaDisabled, itemId: value, onClick: onClick, tooltipProps: tooltipProps, ref: innerRef }, ouiaProps, props, { children: children })));
-};
-const DropdownItem = forwardRef((props, ref) => (jsx(DropdownItemBase, Object.assign({}, props, { innerRef: ref }))));
-DropdownItem.displayName = 'DropdownItem';
-
-const DropdownList = (_a) => {
-    var { children, className } = _a, props = __rest(_a, ["children", "className"]);
-    return (jsx(MenuList, Object.assign({ className: css(className) }, props, { children: 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, CaretDownIcon as C, Divider as D, GenerateId as G, MenuToggle as M, Popper as P, StarIcon as S, TimesIcon as T, AngleDownIcon as a, Dropdown as b, DropdownList as c, DropdownItem as d, Tooltip as e, checkStyles as f, Checkbox as g, handleArrows as h, menuStyles as m, setTabIndex as s, useIsomorphicLayoutEffect as u };