@entur/menu 5.2.0 → 5.2.1-beta.0

package/dist/menu.esm.js

@@ -1,347 +1,3462 @@
-import { useOnClickOutside, useOnEscape, getNodeText, useRandomId, warnAboutMissingStyles } from '@entur/utils';
-import React, { useState, useEffect, useRef, cloneElement, useContext } from 'react';
-import classNames from 'classnames';
-import { RightArrowIcon, MenuIcon, LeftArrowIcon, VerticalDotsIcon, DownArrowIcon } from '@entur/icons';
-import { useFloating, offset, flip, shift, autoUpdate, useListNavigation, useTypeahead, useRole, useInteractions, FloatingList, useListItem } from '@floating-ui/react';
-import { IconButton } from '@entur/button';
-import { standardisePlacement } from '@entur/tooltip';
-import { space } from '@entur/tokens';
-import { VisuallyHidden } from '@entur/a11y';
-import { Label } from '@entur/typography';
-import { ExpandArrow, BaseExpand } from '@entur/expand';
-
-var BreadcrumbNavigation = function BreadcrumbNavigation(_ref) {
-  var _ref$ariaLabel = _ref['aria-label'],
-    ariaLabel = _ref$ariaLabel === void 0 ? 'Brødsmulesti' : _ref$ariaLabel,
-    children = _ref.children;
-  return React.createElement("nav", {
-    "aria-label": ariaLabel
-  }, React.createElement("ol", {
-    className: "eds-breadcrumbs"
-  }, React.Children.map(children, function (child, index) {
-    // @ts-expect-error should check if children are correct but for now it is only mentioned in the documentation
-    return React.cloneElement(child, {
-      isCurrent: index + 1 === React.Children.count(children)
+import { useOnClickOutside, useOnEscape, getNodeText, useRandomId, warnAboutMissingStyles } from "@entur/utils";
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+import * as React from "react";
+import React__default, { useState, useEffect, useLayoutEffect, useRef, cloneElement, useContext } from "react";
+import { RightArrowIcon, MenuIcon, LeftArrowIcon, VerticalDotsIcon, DownArrowIcon } from "@entur/icons";
+import * as ReactDOM from "react-dom";
+import { IconButton } from "@entur/button";
+import { standardisePlacement } from "@entur/tooltip";
+import { space } from "@entur/tokens";
+import { VisuallyHidden } from "@entur/a11y";
+import { Label } from "@entur/typography";
+import { ExpandArrow, BaseExpand } from "@entur/expand";
+const BreadcrumbNavigation = ({
+  "aria-label": ariaLabel = "Brødsmulesti",
+  children
+}) => {
+  return /* @__PURE__ */ jsx("nav", { "aria-label": ariaLabel, children: /* @__PURE__ */ jsx("ol", { className: "eds-breadcrumbs", children: React__default.Children.map(children, (child, index2) => {
+    return React__default.cloneElement(child, {
+      isCurrent: index2 + 1 === React__default.Children.count(children)
     });
-  })));
+  }) }) });
 };
-
-function _extends() {
-  return _extends = Object.assign ? Object.assign.bind() : function (n) {
-    for (var e = 1; e < arguments.length; e++) {
-      var t = arguments[e];
-      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
-    }
-    return n;
-  }, _extends.apply(null, arguments);
-}
-function _objectWithoutPropertiesLoose(r, e) {
-  if (null == r) return {};
-  var t = {};
-  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
-    if (e.includes(n)) continue;
-    t[n] = r[n];
-  }
-  return t;
-}
-
-var _excluded$8 = ["className", "isCurrent", "as"];
-var defaultElement$1 = 'a';
-var BreadcrumbItem = function BreadcrumbItem(_ref) {
-  var className = _ref.className,
-    isCurrent = _ref.isCurrent,
-    as = _ref.as,
-    rest = _objectWithoutPropertiesLoose(_ref, _excluded$8);
-  var Element = as || defaultElement$1;
-  return React.createElement(React.Fragment, null, React.createElement("li", {
-    className: classNames('eds-breadcrumb__item', className)
-  }, React.createElement(Element, _extends({
-    "aria-current": isCurrent ? 'page' : undefined,
-    className: classNames('eds-breadcrumb__link', {
-      'eds-breadcrumb__link--current': isCurrent
-    })
-  }, rest))), !isCurrent && React.createElement(RightArrowIcon, {
-    className: "eds-breadcrumb__separator",
-    inline: true,
-    role: "presentation"
-  }));
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var classnames = { exports: {} };
+/*!
+	Copyright (c) 2018 Jed Watson.
+	Licensed under the MIT License (MIT), see
+	http://jedwatson.github.io/classnames
+*/
+var hasRequiredClassnames;
+function requireClassnames() {
+  if (hasRequiredClassnames) return classnames.exports;
+  hasRequiredClassnames = 1;
+  (function(module) {
+    (function() {
+      var hasOwn = {}.hasOwnProperty;
+      function classNames2() {
+        var classes = "";
+        for (var i = 0; i < arguments.length; i++) {
+          var arg = arguments[i];
+          if (arg) {
+            classes = appendClass(classes, parseValue(arg));
+          }
+        }
+        return classes;
+      }
+      function parseValue(arg) {
+        if (typeof arg === "string" || typeof arg === "number") {
+          return arg;
+        }
+        if (typeof arg !== "object") {
+          return "";
+        }
+        if (Array.isArray(arg)) {
+          return classNames2.apply(null, arg);
+        }
+        if (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes("[native code]")) {
+          return arg.toString();
+        }
+        var classes = "";
+        for (var key in arg) {
+          if (hasOwn.call(arg, key) && arg[key]) {
+            classes = appendClass(classes, key);
+          }
+        }
+        return classes;
+      }
+      function appendClass(value, newClass) {
+        if (!newClass) {
+          return value;
+        }
+        if (value) {
+          return value + " " + newClass;
+        }
+        return value + newClass;
+      }
+      if (module.exports) {
+        classNames2.default = classNames2;
+        module.exports = classNames2;
+      } else {
+        window.classNames = classNames2;
+      }
+    })();
+  })(classnames);
+  return classnames.exports;
+}
+var classnamesExports = requireClassnames();
+const classNames = /* @__PURE__ */ getDefaultExportFromCjs(classnamesExports);
+const defaultElement$1 = "a";
+const BreadcrumbItem = ({
+  className,
+  isCurrent,
+  as,
+  ...rest
+}) => {
+  const Element2 = as || defaultElement$1;
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx("li", { className: classNames("eds-breadcrumb__item", className), children: /* @__PURE__ */ jsx(
+      Element2,
+      {
+        "aria-current": isCurrent ? "page" : void 0,
+        className: classNames("eds-breadcrumb__link", {
+          "eds-breadcrumb__link--current": isCurrent
+        }),
+        ...rest
+      }
+    ) }),
+    !isCurrent && /* @__PURE__ */ jsx(
+      RightArrowIcon,
+      {
+        className: "eds-breadcrumb__separator",
+        inline: true,
+        role: "presentation"
+      }
+    )
+  ] });
 };
-
-function useControllableProp(_ref) {
-  var prop = _ref.prop,
-    _ref$updater = _ref.updater,
-    updater = _ref$updater === void 0 ? function () {
-      return undefined;
-    } : _ref$updater,
-    defaultValue = _ref.defaultValue;
-  var _useState = useState(defaultValue),
-    internalState = _useState[0],
-    setInternalState = _useState[1];
-  useEffect(function () {
-    if (prop !== undefined) {
+function useControllableProp({
+  prop,
+  updater = () => void 0,
+  defaultValue
+}) {
+  const [internalState, setInternalState] = useState(defaultValue);
+  useEffect(() => {
+    if (prop !== void 0) {
       setInternalState(prop);
     }
-  }, [prop]);
-  return prop === undefined ? [internalState, setInternalState] : [prop, updater];
-}
-
-var _excluded$7 = ["className", "children", "size", "collapsed", "onCollapseToggle", "collapsibleButtonPosition", "openSideMenuAriaLabel", "closeSideMenuAriaLabel"];
-var CollapsibleSideNavigation = function CollapsibleSideNavigation(_ref) {
-  var className = _ref.className,
-    children = _ref.children,
-    size = _ref.size,
-    collapsible = _ref.collapsed,
-    onCollapseToggle = _ref.onCollapseToggle,
-    _ref$collapsibleButto = _ref.collapsibleButtonPosition,
-    collapsibleButtonPosition = _ref$collapsibleButto === void 0 ? '50%' : _ref$collapsibleButto,
-    _ref$openSideMenuAria = _ref.openSideMenuAriaLabel,
-    openSideMenuAriaLabel = _ref$openSideMenuAria === void 0 ? 'Åpne sidemeny' : _ref$openSideMenuAria,
-    _ref$closeSideMenuAri = _ref.closeSideMenuAriaLabel,
-    closeSideMenuAriaLabel = _ref$closeSideMenuAri === void 0 ? 'Lukk sidemeny' : _ref$closeSideMenuAri,
-    rest = _objectWithoutPropertiesLoose(_ref, _excluded$7);
-  var _useControllableProp = useControllableProp({
-      prop: collapsible,
-      defaultValue: false,
-      updater: onCollapseToggle
-    }),
-    collapsedMenu = _useControllableProp[0],
-    setCollapsedMenu = _useControllableProp[1];
-  return React.createElement(SideNavigationContext.Provider, {
-    value: {
-      isCollapsed: collapsedMenu
-    }
-  }, React.createElement("ul", _extends({
-    className: classNames('eds-side-navigation', {
-      'eds-side-navigation--small': size === 'small'
-    }, {
-      'eds-side-navigation--collapsed': collapsedMenu
-    }, className)
-  }, rest), children, React.createElement("button", {
-    className: "eds-side-navigation__collapse-button",
-    onClick: function onClick() {
-      return setCollapsedMenu(!collapsedMenu);
-    },
-    style: {
-      top: "" + collapsibleButtonPosition
-    }
-  }, collapsedMenu ? React.createElement(MenuIcon, {
-    "aria-label": openSideMenuAriaLabel
-  }) : React.createElement(LeftArrowIcon, {
-    "aria-label": closeSideMenuAriaLabel
-  }))));
-};
-var SideNavigationContext = /*#__PURE__*/React.createContext({
-  isCollapsed: false
+  }, [prop]);
+  return prop === void 0 ? [internalState, setInternalState] : [prop, updater];
+}
+const CollapsibleSideNavigation = ({
+  className,
+  children,
+  size,
+  collapsed: collapsible,
+  onCollapseToggle,
+  collapsibleButtonPosition = "50%",
+  openSideMenuAriaLabel = "Åpne sidemeny",
+  closeSideMenuAriaLabel = "Lukk sidemeny",
+  ...rest
+}) => {
+  const [collapsedMenu, setCollapsedMenu] = useControllableProp({
+    prop: collapsible,
+    defaultValue: false,
+    updater: onCollapseToggle
+  });
+  return /* @__PURE__ */ jsx(
+    SideNavigationContext.Provider,
+    {
+      value: {
+        isCollapsed: collapsedMenu
+      },
+      children: /* @__PURE__ */ jsxs(
+        "ul",
+        {
+          className: classNames(
+            "eds-side-navigation",
+            { "eds-side-navigation--small": size === "small" },
+            { "eds-side-navigation--collapsed": collapsedMenu },
+            className
+          ),
+          ...rest,
+          children: [
+            children,
+            /* @__PURE__ */ jsx(
+              "button",
+              {
+                className: "eds-side-navigation__collapse-button",
+                onClick: () => setCollapsedMenu(!collapsedMenu),
+                style: { top: `${collapsibleButtonPosition}` },
+                children: collapsedMenu ? /* @__PURE__ */ jsx(MenuIcon, { "aria-label": openSideMenuAriaLabel }) : /* @__PURE__ */ jsx(LeftArrowIcon, { "aria-label": closeSideMenuAriaLabel })
+              }
+            )
+          ]
+        }
+      )
+    }
+  );
+};
+const SideNavigationContext = React__default.createContext({
+  isCollapsed: false
+});
+const useSideNavigationContext = () => {
+  const context = React__default.useContext(SideNavigationContext);
+  if (!context) {
+    console.error(
+      "Error reading SideNavigationContext. Please contact maintainer of @entur/menu"
+    );
+  }
+  return context;
+};
+function hasWindow() {
+  return typeof window !== "undefined";
+}
+function getNodeName(node) {
+  if (isNode(node)) {
+    return (node.nodeName || "").toLowerCase();
+  }
+  return "#document";
+}
+function getWindow(node) {
+  var _node$ownerDocument;
+  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
+}
+function getDocumentElement(node) {
+  var _ref;
+  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
+}
+function isNode(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof Node || value instanceof getWindow(value).Node;
+}
+function isElement(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof Element || value instanceof getWindow(value).Element;
+}
+function isHTMLElement(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
+}
+function isShadowRoot(value) {
+  if (!hasWindow() || typeof ShadowRoot === "undefined") {
+    return false;
+  }
+  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
+}
+function isOverflowElement(element) {
+  const {
+    overflow,
+    overflowX,
+    overflowY,
+    display
+  } = getComputedStyle(element);
+  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !["inline", "contents"].includes(display);
+}
+function isTableElement(element) {
+  return ["table", "td", "th"].includes(getNodeName(element));
+}
+function isTopLayer(element) {
+  return [":popover-open", ":modal"].some((selector) => {
+    try {
+      return element.matches(selector);
+    } catch (e) {
+      return false;
+    }
+  });
+}
+function isContainingBlock(elementOrCss) {
+  const webkit = isWebKit();
+  const css = isElement(elementOrCss) ? getComputedStyle(elementOrCss) : elementOrCss;
+  return css.transform !== "none" || css.perspective !== "none" || (css.containerType ? css.containerType !== "normal" : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== "none" : false) || !webkit && (css.filter ? css.filter !== "none" : false) || ["transform", "perspective", "filter"].some((value) => (css.willChange || "").includes(value)) || ["paint", "layout", "strict", "content"].some((value) => (css.contain || "").includes(value));
+}
+function getContainingBlock(element) {
+  let currentNode = getParentNode(element);
+  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
+    if (isContainingBlock(currentNode)) {
+      return currentNode;
+    } else if (isTopLayer(currentNode)) {
+      return null;
+    }
+    currentNode = getParentNode(currentNode);
+  }
+  return null;
+}
+function isWebKit() {
+  if (typeof CSS === "undefined" || !CSS.supports) return false;
+  return CSS.supports("-webkit-backdrop-filter", "none");
+}
+function isLastTraversableNode(node) {
+  return ["html", "body", "#document"].includes(getNodeName(node));
+}
+function getComputedStyle(element) {
+  return getWindow(element).getComputedStyle(element);
+}
+function getNodeScroll(element) {
+  if (isElement(element)) {
+    return {
+      scrollLeft: element.scrollLeft,
+      scrollTop: element.scrollTop
+    };
+  }
+  return {
+    scrollLeft: element.scrollX,
+    scrollTop: element.scrollY
+  };
+}
+function getParentNode(node) {
+  if (getNodeName(node) === "html") {
+    return node;
+  }
+  const result = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    node.assignedSlot || // DOM Element detected.
+    node.parentNode || // ShadowRoot detected.
+    isShadowRoot(node) && node.host || // Fallback.
+    getDocumentElement(node)
+  );
+  return isShadowRoot(result) ? result.host : result;
+}
+function getNearestOverflowAncestor(node) {
+  const parentNode = getParentNode(node);
+  if (isLastTraversableNode(parentNode)) {
+    return node.ownerDocument ? node.ownerDocument.body : node.body;
+  }
+  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
+    return parentNode;
+  }
+  return getNearestOverflowAncestor(parentNode);
+}
+function getOverflowAncestors(node, list, traverseIframes) {
+  var _node$ownerDocument2;
+  if (list === void 0) {
+    list = [];
+  }
+  if (traverseIframes === void 0) {
+    traverseIframes = true;
+  }
+  const scrollableAncestor = getNearestOverflowAncestor(node);
+  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
+  const win = getWindow(scrollableAncestor);
+  if (isBody) {
+    const frameElement = getFrameElement(win);
+    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
+  }
+  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
+}
+function getFrameElement(win) {
+  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
+}
+function activeElement(doc) {
+  let activeElement2 = doc.activeElement;
+  while (((_activeElement = activeElement2) == null || (_activeElement = _activeElement.shadowRoot) == null ? void 0 : _activeElement.activeElement) != null) {
+    var _activeElement;
+    activeElement2 = activeElement2.shadowRoot.activeElement;
+  }
+  return activeElement2;
+}
+function contains(parent, child) {
+  if (!parent || !child) {
+    return false;
+  }
+  const rootNode = child.getRootNode == null ? void 0 : child.getRootNode();
+  if (parent.contains(child)) {
+    return true;
+  }
+  if (rootNode && isShadowRoot(rootNode)) {
+    let next = child;
+    while (next) {
+      if (parent === next) {
+        return true;
+      }
+      next = next.parentNode || next.host;
+    }
+  }
+  return false;
+}
+function getPlatform() {
+  const uaData = navigator.userAgentData;
+  if (uaData != null && uaData.platform) {
+    return uaData.platform;
+  }
+  return navigator.platform;
+}
+function getUserAgent() {
+  const uaData = navigator.userAgentData;
+  if (uaData && Array.isArray(uaData.brands)) {
+    return uaData.brands.map((_ref) => {
+      let {
+        brand,
+        version
+      } = _ref;
+      return brand + "/" + version;
+    }).join(" ");
+  }
+  return navigator.userAgent;
+}
+function isVirtualClick(event) {
+  if (event.mozInputSource === 0 && event.isTrusted) {
+    return true;
+  }
+  if (isAndroid() && event.pointerType) {
+    return event.type === "click" && event.buttons === 1;
+  }
+  return event.detail === 0 && !event.pointerType;
+}
+function isVirtualPointerEvent(event) {
+  if (isJSDOM()) return false;
+  return !isAndroid() && event.width === 0 && event.height === 0 || isAndroid() && event.width === 1 && event.height === 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === "mouse" || // iOS VoiceOver returns 0.333• for width/height.
+  event.width < 1 && event.height < 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === "touch";
+}
+function isSafari() {
+  return /apple/i.test(navigator.vendor);
+}
+function isAndroid() {
+  const re = /android/i;
+  return re.test(getPlatform()) || re.test(getUserAgent());
+}
+function isMac() {
+  return getPlatform().toLowerCase().startsWith("mac") && !navigator.maxTouchPoints;
+}
+function isJSDOM() {
+  return getUserAgent().includes("jsdom/");
+}
+function getDocument(node) {
+  return (node == null ? void 0 : node.ownerDocument) || document;
+}
+const TYPEABLE_SELECTOR = "input:not([type='hidden']):not([disabled]),[contenteditable]:not([contenteditable='false']),textarea:not([disabled])";
+function isTypeableElement(element) {
+  return isHTMLElement(element) && element.matches(TYPEABLE_SELECTOR);
+}
+function stopEvent(event) {
+  event.preventDefault();
+  event.stopPropagation();
+}
+function isTypeableCombobox(element) {
+  if (!element) return false;
+  return element.getAttribute("role") === "combobox" && isTypeableElement(element);
+}
+const min = Math.min;
+const max = Math.max;
+const round = Math.round;
+const floor = Math.floor;
+const createCoords = (v) => ({
+  x: v,
+  y: v
+});
+const oppositeSideMap = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+};
+const oppositeAlignmentMap = {
+  start: "end",
+  end: "start"
+};
+function clamp(start, value, end) {
+  return max(start, min(value, end));
+}
+function evaluate(value, param) {
+  return typeof value === "function" ? value(param) : value;
+}
+function getSide(placement) {
+  return placement.split("-")[0];
+}
+function getAlignment(placement) {
+  return placement.split("-")[1];
+}
+function getOppositeAxis(axis) {
+  return axis === "x" ? "y" : "x";
+}
+function getAxisLength(axis) {
+  return axis === "y" ? "height" : "width";
+}
+function getSideAxis(placement) {
+  return ["top", "bottom"].includes(getSide(placement)) ? "y" : "x";
+}
+function getAlignmentAxis(placement) {
+  return getOppositeAxis(getSideAxis(placement));
+}
+function getAlignmentSides(placement, rects, rtl) {
+  if (rtl === void 0) {
+    rtl = false;
+  }
+  const alignment = getAlignment(placement);
+  const alignmentAxis = getAlignmentAxis(placement);
+  const length = getAxisLength(alignmentAxis);
+  let mainAlignmentSide = alignmentAxis === "x" ? alignment === (rtl ? "end" : "start") ? "right" : "left" : alignment === "start" ? "bottom" : "top";
+  if (rects.reference[length] > rects.floating[length]) {
+    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
+  }
+  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
+}
+function getExpandedPlacements(placement) {
+  const oppositePlacement = getOppositePlacement(placement);
+  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
+}
+function getOppositeAlignmentPlacement(placement) {
+  return placement.replace(/start|end/g, (alignment) => oppositeAlignmentMap[alignment]);
+}
+function getSideList(side, isStart, rtl) {
+  const lr = ["left", "right"];
+  const rl = ["right", "left"];
+  const tb = ["top", "bottom"];
+  const bt = ["bottom", "top"];
+  switch (side) {
+    case "top":
+    case "bottom":
+      if (rtl) return isStart ? rl : lr;
+      return isStart ? lr : rl;
+    case "left":
+    case "right":
+      return isStart ? tb : bt;
+    default:
+      return [];
+  }
+}
+function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
+  const alignment = getAlignment(placement);
+  let list = getSideList(getSide(placement), direction === "start", rtl);
+  if (alignment) {
+    list = list.map((side) => side + "-" + alignment);
+    if (flipAlignment) {
+      list = list.concat(list.map(getOppositeAlignmentPlacement));
+    }
+  }
+  return list;
+}
+function getOppositePlacement(placement) {
+  return placement.replace(/left|right|bottom|top/g, (side) => oppositeSideMap[side]);
+}
+function expandPaddingObject(padding) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...padding
+  };
+}
+function getPaddingObject(padding) {
+  return typeof padding !== "number" ? expandPaddingObject(padding) : {
+    top: padding,
+    right: padding,
+    bottom: padding,
+    left: padding
+  };
+}
+function rectToClientRect(rect) {
+  const {
+    x,
+    y,
+    width,
+    height
+  } = rect;
+  return {
+    width,
+    height,
+    top: y,
+    left: x,
+    right: x + width,
+    bottom: y + height,
+    x,
+    y
+  };
+}
+function computeCoordsFromPlacement(_ref, placement, rtl) {
+  let {
+    reference,
+    floating
+  } = _ref;
+  const sideAxis = getSideAxis(placement);
+  const alignmentAxis = getAlignmentAxis(placement);
+  const alignLength = getAxisLength(alignmentAxis);
+  const side = getSide(placement);
+  const isVertical = sideAxis === "y";
+  const commonX = reference.x + reference.width / 2 - floating.width / 2;
+  const commonY = reference.y + reference.height / 2 - floating.height / 2;
+  const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
+  let coords;
+  switch (side) {
+    case "top":
+      coords = {
+        x: commonX,
+        y: reference.y - floating.height
+      };
+      break;
+    case "bottom":
+      coords = {
+        x: commonX,
+        y: reference.y + reference.height
+      };
+      break;
+    case "right":
+      coords = {
+        x: reference.x + reference.width,
+        y: commonY
+      };
+      break;
+    case "left":
+      coords = {
+        x: reference.x - floating.width,
+        y: commonY
+      };
+      break;
+    default:
+      coords = {
+        x: reference.x,
+        y: reference.y
+      };
+  }
+  switch (getAlignment(placement)) {
+    case "start":
+      coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
+      break;
+    case "end":
+      coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
+      break;
+  }
+  return coords;
+}
+const computePosition$1 = async (reference, floating, config) => {
+  const {
+    placement = "bottom",
+    strategy = "absolute",
+    middleware = [],
+    platform: platform2
+  } = config;
+  const validMiddleware = middleware.filter(Boolean);
+  const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(floating));
+  let rects = await platform2.getElementRects({
+    reference,
+    floating,
+    strategy
+  });
+  let {
+    x,
+    y
+  } = computeCoordsFromPlacement(rects, placement, rtl);
+  let statefulPlacement = placement;
+  let middlewareData = {};
+  let resetCount = 0;
+  for (let i = 0; i < validMiddleware.length; i++) {
+    const {
+      name,
+      fn
+    } = validMiddleware[i];
+    const {
+      x: nextX,
+      y: nextY,
+      data,
+      reset
+    } = await fn({
+      x,
+      y,
+      initialPlacement: placement,
+      placement: statefulPlacement,
+      strategy,
+      middlewareData,
+      rects,
+      platform: platform2,
+      elements: {
+        reference,
+        floating
+      }
+    });
+    x = nextX != null ? nextX : x;
+    y = nextY != null ? nextY : y;
+    middlewareData = {
+      ...middlewareData,
+      [name]: {
+        ...middlewareData[name],
+        ...data
+      }
+    };
+    if (reset && resetCount <= 50) {
+      resetCount++;
+      if (typeof reset === "object") {
+        if (reset.placement) {
+          statefulPlacement = reset.placement;
+        }
+        if (reset.rects) {
+          rects = reset.rects === true ? await platform2.getElementRects({
+            reference,
+            floating,
+            strategy
+          }) : reset.rects;
+        }
+        ({
+          x,
+          y
+        } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
+      }
+      i = -1;
+    }
+  }
+  return {
+    x,
+    y,
+    placement: statefulPlacement,
+    strategy,
+    middlewareData
+  };
+};
+async function detectOverflow(state, options) {
+  var _await$platform$isEle;
+  if (options === void 0) {
+    options = {};
+  }
+  const {
+    x,
+    y,
+    platform: platform2,
+    rects,
+    elements,
+    strategy
+  } = state;
+  const {
+    boundary = "clippingAncestors",
+    rootBoundary = "viewport",
+    elementContext = "floating",
+    altBoundary = false,
+    padding = 0
+  } = evaluate(options, state);
+  const paddingObject = getPaddingObject(padding);
+  const altContext = elementContext === "floating" ? "reference" : "floating";
+  const element = elements[altBoundary ? altContext : elementContext];
+  const clippingClientRect = rectToClientRect(await platform2.getClippingRect({
+    element: ((_await$platform$isEle = await (platform2.isElement == null ? void 0 : platform2.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || await (platform2.getDocumentElement == null ? void 0 : platform2.getDocumentElement(elements.floating)),
+    boundary,
+    rootBoundary,
+    strategy
+  }));
+  const rect = elementContext === "floating" ? {
+    x,
+    y,
+    width: rects.floating.width,
+    height: rects.floating.height
+  } : rects.reference;
+  const offsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(elements.floating));
+  const offsetScale = await (platform2.isElement == null ? void 0 : platform2.isElement(offsetParent)) ? await (platform2.getScale == null ? void 0 : platform2.getScale(offsetParent)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  };
+  const elementClientRect = rectToClientRect(platform2.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform2.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements,
+    rect,
+    offsetParent,
+    strategy
+  }) : rect);
+  return {
+    top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
+    bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
+    left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
+    right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
+  };
+}
+const flip$2 = function(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    name: "flip",
+    options,
+    async fn(state) {
+      var _middlewareData$arrow, _middlewareData$flip;
+      const {
+        placement,
+        middlewareData,
+        rects,
+        initialPlacement,
+        platform: platform2,
+        elements
+      } = state;
+      const {
+        mainAxis: checkMainAxis = true,
+        crossAxis: checkCrossAxis = true,
+        fallbackPlacements: specifiedFallbackPlacements,
+        fallbackStrategy = "bestFit",
+        fallbackAxisSideDirection = "none",
+        flipAlignment = true,
+        ...detectOverflowOptions
+      } = evaluate(options, state);
+      if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
+        return {};
+      }
+      const side = getSide(placement);
+      const initialSideAxis = getSideAxis(initialPlacement);
+      const isBasePlacement = getSide(initialPlacement) === initialPlacement;
+      const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating));
+      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
+      const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== "none";
+      if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {
+        fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
+      }
+      const placements = [initialPlacement, ...fallbackPlacements];
+      const overflow = await detectOverflow(state, detectOverflowOptions);
+      const overflows = [];
+      let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
+      if (checkMainAxis) {
+        overflows.push(overflow[side]);
+      }
+      if (checkCrossAxis) {
+        const sides = getAlignmentSides(placement, rects, rtl);
+        overflows.push(overflow[sides[0]], overflow[sides[1]]);
+      }
+      overflowsData = [...overflowsData, {
+        placement,
+        overflows
+      }];
+      if (!overflows.every((side2) => side2 <= 0)) {
+        var _middlewareData$flip2, _overflowsData$filter;
+        const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
+        const nextPlacement = placements[nextIndex];
+        if (nextPlacement) {
+          return {
+            data: {
+              index: nextIndex,
+              overflows: overflowsData
+            },
+            reset: {
+              placement: nextPlacement
+            }
+          };
+        }
+        let resetPlacement = (_overflowsData$filter = overflowsData.filter((d) => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;
+        if (!resetPlacement) {
+          switch (fallbackStrategy) {
+            case "bestFit": {
+              var _overflowsData$filter2;
+              const placement2 = (_overflowsData$filter2 = overflowsData.filter((d) => {
+                if (hasFallbackAxisSideDirection) {
+                  const currentSideAxis = getSideAxis(d.placement);
+                  return currentSideAxis === initialSideAxis || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  currentSideAxis === "y";
+                }
+                return true;
+              }).map((d) => [d.placement, d.overflows.filter((overflow2) => overflow2 > 0).reduce((acc, overflow2) => acc + overflow2, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0];
+              if (placement2) {
+                resetPlacement = placement2;
+              }
+              break;
+            }
+            case "initialPlacement":
+              resetPlacement = initialPlacement;
+              break;
+          }
+        }
+        if (placement !== resetPlacement) {
+          return {
+            reset: {
+              placement: resetPlacement
+            }
+          };
+        }
+      }
+      return {};
+    }
+  };
+};
+async function convertValueToCoords(state, options) {
+  const {
+    placement,
+    platform: platform2,
+    elements
+  } = state;
+  const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating));
+  const side = getSide(placement);
+  const alignment = getAlignment(placement);
+  const isVertical = getSideAxis(placement) === "y";
+  const mainAxisMulti = ["left", "top"].includes(side) ? -1 : 1;
+  const crossAxisMulti = rtl && isVertical ? -1 : 1;
+  const rawValue = evaluate(options, state);
+  let {
+    mainAxis,
+    crossAxis,
+    alignmentAxis
+  } = typeof rawValue === "number" ? {
+    mainAxis: rawValue,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: rawValue.mainAxis || 0,
+    crossAxis: rawValue.crossAxis || 0,
+    alignmentAxis: rawValue.alignmentAxis
+  };
+  if (alignment && typeof alignmentAxis === "number") {
+    crossAxis = alignment === "end" ? alignmentAxis * -1 : alignmentAxis;
+  }
+  return isVertical ? {
+    x: crossAxis * crossAxisMulti,
+    y: mainAxis * mainAxisMulti
+  } : {
+    x: mainAxis * mainAxisMulti,
+    y: crossAxis * crossAxisMulti
+  };
+}
+const offset$2 = function(options) {
+  if (options === void 0) {
+    options = 0;
+  }
+  return {
+    name: "offset",
+    options,
+    async fn(state) {
+      var _middlewareData$offse, _middlewareData$arrow;
+      const {
+        x,
+        y,
+        placement,
+        middlewareData
+      } = state;
+      const diffCoords = await convertValueToCoords(state, options);
+      if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
+        return {};
+      }
+      return {
+        x: x + diffCoords.x,
+        y: y + diffCoords.y,
+        data: {
+          ...diffCoords,
+          placement
+        }
+      };
+    }
+  };
+};
+const shift$2 = function(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    name: "shift",
+    options,
+    async fn(state) {
+      const {
+        x,
+        y,
+        placement
+      } = state;
+      const {
+        mainAxis: checkMainAxis = true,
+        crossAxis: checkCrossAxis = false,
+        limiter = {
+          fn: (_ref) => {
+            let {
+              x: x2,
+              y: y2
+            } = _ref;
+            return {
+              x: x2,
+              y: y2
+            };
+          }
+        },
+        ...detectOverflowOptions
+      } = evaluate(options, state);
+      const coords = {
+        x,
+        y
+      };
+      const overflow = await detectOverflow(state, detectOverflowOptions);
+      const crossAxis = getSideAxis(getSide(placement));
+      const mainAxis = getOppositeAxis(crossAxis);
+      let mainAxisCoord = coords[mainAxis];
+      let crossAxisCoord = coords[crossAxis];
+      if (checkMainAxis) {
+        const minSide = mainAxis === "y" ? "top" : "left";
+        const maxSide = mainAxis === "y" ? "bottom" : "right";
+        const min2 = mainAxisCoord + overflow[minSide];
+        const max2 = mainAxisCoord - overflow[maxSide];
+        mainAxisCoord = clamp(min2, mainAxisCoord, max2);
+      }
+      if (checkCrossAxis) {
+        const minSide = crossAxis === "y" ? "top" : "left";
+        const maxSide = crossAxis === "y" ? "bottom" : "right";
+        const min2 = crossAxisCoord + overflow[minSide];
+        const max2 = crossAxisCoord - overflow[maxSide];
+        crossAxisCoord = clamp(min2, crossAxisCoord, max2);
+      }
+      const limitedCoords = limiter.fn({
+        ...state,
+        [mainAxis]: mainAxisCoord,
+        [crossAxis]: crossAxisCoord
+      });
+      return {
+        ...limitedCoords,
+        data: {
+          x: limitedCoords.x - x,
+          y: limitedCoords.y - y,
+          enabled: {
+            [mainAxis]: checkMainAxis,
+            [crossAxis]: checkCrossAxis
+          }
+        }
+      };
+    }
+  };
+};
+function getCssDimensions(element) {
+  const css = getComputedStyle(element);
+  let width = parseFloat(css.width) || 0;
+  let height = parseFloat(css.height) || 0;
+  const hasOffset = isHTMLElement(element);
+  const offsetWidth = hasOffset ? element.offsetWidth : width;
+  const offsetHeight = hasOffset ? element.offsetHeight : height;
+  const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
+  if (shouldFallback) {
+    width = offsetWidth;
+    height = offsetHeight;
+  }
+  return {
+    width,
+    height,
+    $: shouldFallback
+  };
+}
+function unwrapElement(element) {
+  return !isElement(element) ? element.contextElement : element;
+}
+function getScale(element) {
+  const domElement = unwrapElement(element);
+  if (!isHTMLElement(domElement)) {
+    return createCoords(1);
+  }
+  const rect = domElement.getBoundingClientRect();
+  const {
+    width,
+    height,
+    $
+  } = getCssDimensions(domElement);
+  let x = ($ ? round(rect.width) : rect.width) / width;
+  let y = ($ ? round(rect.height) : rect.height) / height;
+  if (!x || !Number.isFinite(x)) {
+    x = 1;
+  }
+  if (!y || !Number.isFinite(y)) {
+    y = 1;
+  }
+  return {
+    x,
+    y
+  };
+}
+const noOffsets = /* @__PURE__ */ createCoords(0);
+function getVisualOffsets(element) {
+  const win = getWindow(element);
+  if (!isWebKit() || !win.visualViewport) {
+    return noOffsets;
+  }
+  return {
+    x: win.visualViewport.offsetLeft,
+    y: win.visualViewport.offsetTop
+  };
+}
+function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
+  if (isFixed === void 0) {
+    isFixed = false;
+  }
+  if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {
+    return false;
+  }
+  return isFixed;
+}
+function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
+  if (includeScale === void 0) {
+    includeScale = false;
+  }
+  if (isFixedStrategy === void 0) {
+    isFixedStrategy = false;
+  }
+  const clientRect = element.getBoundingClientRect();
+  const domElement = unwrapElement(element);
+  let scale = createCoords(1);
+  if (includeScale) {
+    if (offsetParent) {
+      if (isElement(offsetParent)) {
+        scale = getScale(offsetParent);
+      }
+    } else {
+      scale = getScale(element);
+    }
+  }
+  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
+  let x = (clientRect.left + visualOffsets.x) / scale.x;
+  let y = (clientRect.top + visualOffsets.y) / scale.y;
+  let width = clientRect.width / scale.x;
+  let height = clientRect.height / scale.y;
+  if (domElement) {
+    const win = getWindow(domElement);
+    const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
+    let currentWin = win;
+    let currentIFrame = getFrameElement(currentWin);
+    while (currentIFrame && offsetParent && offsetWin !== currentWin) {
+      const iframeScale = getScale(currentIFrame);
+      const iframeRect = currentIFrame.getBoundingClientRect();
+      const css = getComputedStyle(currentIFrame);
+      const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
+      const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
+      x *= iframeScale.x;
+      y *= iframeScale.y;
+      width *= iframeScale.x;
+      height *= iframeScale.y;
+      x += left;
+      y += top;
+      currentWin = getWindow(currentIFrame);
+      currentIFrame = getFrameElement(currentWin);
+    }
+  }
+  return rectToClientRect({
+    width,
+    height,
+    x,
+    y
+  });
+}
+function getWindowScrollBarX(element, rect) {
+  const leftScroll = getNodeScroll(element).scrollLeft;
+  if (!rect) {
+    return getBoundingClientRect(getDocumentElement(element)).left + leftScroll;
+  }
+  return rect.left + leftScroll;
+}
+function getHTMLOffset(documentElement, scroll, ignoreScrollbarX) {
+  if (ignoreScrollbarX === void 0) {
+    ignoreScrollbarX = false;
+  }
+  const htmlRect = documentElement.getBoundingClientRect();
+  const x = htmlRect.left + scroll.scrollLeft - (ignoreScrollbarX ? 0 : (
+    // RTL <body> scrollbar.
+    getWindowScrollBarX(documentElement, htmlRect)
+  ));
+  const y = htmlRect.top + scroll.scrollTop;
+  return {
+    x,
+    y
+  };
+}
+function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
+  let {
+    elements,
+    rect,
+    offsetParent,
+    strategy
+  } = _ref;
+  const isFixed = strategy === "fixed";
+  const documentElement = getDocumentElement(offsetParent);
+  const topLayer = elements ? isTopLayer(elements.floating) : false;
+  if (offsetParent === documentElement || topLayer && isFixed) {
+    return rect;
+  }
+  let scroll = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  let scale = createCoords(1);
+  const offsets = createCoords(0);
+  const isOffsetParentAnElement = isHTMLElement(offsetParent);
+  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+    if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
+      scroll = getNodeScroll(offsetParent);
+    }
+    if (isHTMLElement(offsetParent)) {
+      const offsetRect = getBoundingClientRect(offsetParent);
+      scale = getScale(offsetParent);
+      offsets.x = offsetRect.x + offsetParent.clientLeft;
+      offsets.y = offsetRect.y + offsetParent.clientTop;
+    }
+  }
+  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll, true) : createCoords(0);
+  return {
+    width: rect.width * scale.x,
+    height: rect.height * scale.y,
+    x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x + htmlOffset.x,
+    y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y + htmlOffset.y
+  };
+}
+function getClientRects(element) {
+  return Array.from(element.getClientRects());
+}
+function getDocumentRect(element) {
+  const html = getDocumentElement(element);
+  const scroll = getNodeScroll(element);
+  const body = element.ownerDocument.body;
+  const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
+  const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
+  let x = -scroll.scrollLeft + getWindowScrollBarX(element);
+  const y = -scroll.scrollTop;
+  if (getComputedStyle(body).direction === "rtl") {
+    x += max(html.clientWidth, body.clientWidth) - width;
+  }
+  return {
+    width,
+    height,
+    x,
+    y
+  };
+}
+function getViewportRect(element, strategy) {
+  const win = getWindow(element);
+  const html = getDocumentElement(element);
+  const visualViewport = win.visualViewport;
+  let width = html.clientWidth;
+  let height = html.clientHeight;
+  let x = 0;
+  let y = 0;
+  if (visualViewport) {
+    width = visualViewport.width;
+    height = visualViewport.height;
+    const visualViewportBased = isWebKit();
+    if (!visualViewportBased || visualViewportBased && strategy === "fixed") {
+      x = visualViewport.offsetLeft;
+      y = visualViewport.offsetTop;
+    }
+  }
+  return {
+    width,
+    height,
+    x,
+    y
+  };
+}
+function getInnerBoundingClientRect(element, strategy) {
+  const clientRect = getBoundingClientRect(element, true, strategy === "fixed");
+  const top = clientRect.top + element.clientTop;
+  const left = clientRect.left + element.clientLeft;
+  const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);
+  const width = element.clientWidth * scale.x;
+  const height = element.clientHeight * scale.y;
+  const x = left * scale.x;
+  const y = top * scale.y;
+  return {
+    width,
+    height,
+    x,
+    y
+  };
+}
+function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
+  let rect;
+  if (clippingAncestor === "viewport") {
+    rect = getViewportRect(element, strategy);
+  } else if (clippingAncestor === "document") {
+    rect = getDocumentRect(getDocumentElement(element));
+  } else if (isElement(clippingAncestor)) {
+    rect = getInnerBoundingClientRect(clippingAncestor, strategy);
+  } else {
+    const visualOffsets = getVisualOffsets(element);
+    rect = {
+      x: clippingAncestor.x - visualOffsets.x,
+      y: clippingAncestor.y - visualOffsets.y,
+      width: clippingAncestor.width,
+      height: clippingAncestor.height
+    };
+  }
+  return rectToClientRect(rect);
+}
+function hasFixedPositionAncestor(element, stopNode) {
+  const parentNode = getParentNode(element);
+  if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {
+    return false;
+  }
+  return getComputedStyle(parentNode).position === "fixed" || hasFixedPositionAncestor(parentNode, stopNode);
+}
+function getClippingElementAncestors(element, cache) {
+  const cachedResult = cache.get(element);
+  if (cachedResult) {
+    return cachedResult;
+  }
+  let result = getOverflowAncestors(element, [], false).filter((el) => isElement(el) && getNodeName(el) !== "body");
+  let currentContainingBlockComputedStyle = null;
+  const elementIsFixed = getComputedStyle(element).position === "fixed";
+  let currentNode = elementIsFixed ? getParentNode(element) : element;
+  while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
+    const computedStyle = getComputedStyle(currentNode);
+    const currentNodeIsContaining = isContainingBlock(currentNode);
+    if (!currentNodeIsContaining && computedStyle.position === "fixed") {
+      currentContainingBlockComputedStyle = null;
+    }
+    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === "static" && !!currentContainingBlockComputedStyle && ["absolute", "fixed"].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
+    if (shouldDropCurrentNode) {
+      result = result.filter((ancestor) => ancestor !== currentNode);
+    } else {
+      currentContainingBlockComputedStyle = computedStyle;
+    }
+    currentNode = getParentNode(currentNode);
+  }
+  cache.set(element, result);
+  return result;
+}
+function getClippingRect(_ref) {
+  let {
+    element,
+    boundary,
+    rootBoundary,
+    strategy
+  } = _ref;
+  const elementClippingAncestors = boundary === "clippingAncestors" ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);
+  const clippingAncestors = [...elementClippingAncestors, rootBoundary];
+  const firstClippingAncestor = clippingAncestors[0];
+  const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
+    const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
+    accRect.top = max(rect.top, accRect.top);
+    accRect.right = min(rect.right, accRect.right);
+    accRect.bottom = min(rect.bottom, accRect.bottom);
+    accRect.left = max(rect.left, accRect.left);
+    return accRect;
+  }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
+  return {
+    width: clippingRect.right - clippingRect.left,
+    height: clippingRect.bottom - clippingRect.top,
+    x: clippingRect.left,
+    y: clippingRect.top
+  };
+}
+function getDimensions(element) {
+  const {
+    width,
+    height
+  } = getCssDimensions(element);
+  return {
+    width,
+    height
+  };
+}
+function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
+  const isOffsetParentAnElement = isHTMLElement(offsetParent);
+  const documentElement = getDocumentElement(offsetParent);
+  const isFixed = strategy === "fixed";
+  const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
+  let scroll = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const offsets = createCoords(0);
+  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+    if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
+      scroll = getNodeScroll(offsetParent);
+    }
+    if (isOffsetParentAnElement) {
+      const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
+      offsets.x = offsetRect.x + offsetParent.clientLeft;
+      offsets.y = offsetRect.y + offsetParent.clientTop;
+    } else if (documentElement) {
+      offsets.x = getWindowScrollBarX(documentElement);
+    }
+  }
+  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
+  const x = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x;
+  const y = rect.top + scroll.scrollTop - offsets.y - htmlOffset.y;
+  return {
+    x,
+    y,
+    width: rect.width,
+    height: rect.height
+  };
+}
+function isStaticPositioned(element) {
+  return getComputedStyle(element).position === "static";
+}
+function getTrueOffsetParent(element, polyfill) {
+  if (!isHTMLElement(element) || getComputedStyle(element).position === "fixed") {
+    return null;
+  }
+  if (polyfill) {
+    return polyfill(element);
+  }
+  let rawOffsetParent = element.offsetParent;
+  if (getDocumentElement(element) === rawOffsetParent) {
+    rawOffsetParent = rawOffsetParent.ownerDocument.body;
+  }
+  return rawOffsetParent;
+}
+function getOffsetParent(element, polyfill) {
+  const win = getWindow(element);
+  if (isTopLayer(element)) {
+    return win;
+  }
+  if (!isHTMLElement(element)) {
+    let svgOffsetParent = getParentNode(element);
+    while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {
+      if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {
+        return svgOffsetParent;
+      }
+      svgOffsetParent = getParentNode(svgOffsetParent);
+    }
+    return win;
+  }
+  let offsetParent = getTrueOffsetParent(element, polyfill);
+  while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {
+    offsetParent = getTrueOffsetParent(offsetParent, polyfill);
+  }
+  if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) {
+    return win;
+  }
+  return offsetParent || getContainingBlock(element) || win;
+}
+const getElementRects = async function(data) {
+  const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
+  const getDimensionsFn = this.getDimensions;
+  const floatingDimensions = await getDimensionsFn(data.floating);
+  return {
+    reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: floatingDimensions.width,
+      height: floatingDimensions.height
+    }
+  };
+};
+function isRTL(element) {
+  return getComputedStyle(element).direction === "rtl";
+}
+const platform = {
+  convertOffsetParentRelativeRectToViewportRelativeRect,
+  getDocumentElement,
+  getClippingRect,
+  getOffsetParent,
+  getElementRects,
+  getClientRects,
+  getDimensions,
+  getScale,
+  isElement,
+  isRTL
+};
+function observeMove(element, onMove) {
+  let io = null;
+  let timeoutId;
+  const root = getDocumentElement(element);
+  function cleanup() {
+    var _io;
+    clearTimeout(timeoutId);
+    (_io = io) == null || _io.disconnect();
+    io = null;
+  }
+  function refresh(skip, threshold) {
+    if (skip === void 0) {
+      skip = false;
+    }
+    if (threshold === void 0) {
+      threshold = 1;
+    }
+    cleanup();
+    const {
+      left,
+      top,
+      width,
+      height
+    } = element.getBoundingClientRect();
+    if (!skip) {
+      onMove();
+    }
+    if (!width || !height) {
+      return;
+    }
+    const insetTop = floor(top);
+    const insetRight = floor(root.clientWidth - (left + width));
+    const insetBottom = floor(root.clientHeight - (top + height));
+    const insetLeft = floor(left);
+    const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
+    const options = {
+      rootMargin,
+      threshold: max(0, min(1, threshold)) || 1
+    };
+    let isFirstUpdate = true;
+    function handleObserve(entries) {
+      const ratio = entries[0].intersectionRatio;
+      if (ratio !== threshold) {
+        if (!isFirstUpdate) {
+          return refresh();
+        }
+        if (!ratio) {
+          timeoutId = setTimeout(() => {
+            refresh(false, 1e-7);
+          }, 1e3);
+        } else {
+          refresh(false, ratio);
+        }
+      }
+      isFirstUpdate = false;
+    }
+    try {
+      io = new IntersectionObserver(handleObserve, {
+        ...options,
+        // Handle <iframe>s
+        root: root.ownerDocument
+      });
+    } catch (e) {
+      io = new IntersectionObserver(handleObserve, options);
+    }
+    io.observe(element);
+  }
+  refresh(true);
+  return cleanup;
+}
+function autoUpdate(reference, floating, update, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  const {
+    ancestorScroll = true,
+    ancestorResize = true,
+    elementResize = typeof ResizeObserver === "function",
+    layoutShift = typeof IntersectionObserver === "function",
+    animationFrame = false
+  } = options;
+  const referenceEl = unwrapElement(reference);
+  const ancestors = ancestorScroll || ancestorResize ? [...referenceEl ? getOverflowAncestors(referenceEl) : [], ...getOverflowAncestors(floating)] : [];
+  ancestors.forEach((ancestor) => {
+    ancestorScroll && ancestor.addEventListener("scroll", update, {
+      passive: true
+    });
+    ancestorResize && ancestor.addEventListener("resize", update);
+  });
+  const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;
+  let reobserveFrame = -1;
+  let resizeObserver = null;
+  if (elementResize) {
+    resizeObserver = new ResizeObserver((_ref) => {
+      let [firstEntry] = _ref;
+      if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {
+        resizeObserver.unobserve(floating);
+        cancelAnimationFrame(reobserveFrame);
+        reobserveFrame = requestAnimationFrame(() => {
+          var _resizeObserver;
+          (_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);
+        });
+      }
+      update();
+    });
+    if (referenceEl && !animationFrame) {
+      resizeObserver.observe(referenceEl);
+    }
+    resizeObserver.observe(floating);
+  }
+  let frameId;
+  let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
+  if (animationFrame) {
+    frameLoop();
+  }
+  function frameLoop() {
+    const nextRefRect = getBoundingClientRect(reference);
+    if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) {
+      update();
+    }
+    prevRefRect = nextRefRect;
+    frameId = requestAnimationFrame(frameLoop);
+  }
+  update();
+  return () => {
+    var _resizeObserver2;
+    ancestors.forEach((ancestor) => {
+      ancestorScroll && ancestor.removeEventListener("scroll", update);
+      ancestorResize && ancestor.removeEventListener("resize", update);
+    });
+    cleanupIo == null || cleanupIo();
+    (_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();
+    resizeObserver = null;
+    if (animationFrame) {
+      cancelAnimationFrame(frameId);
+    }
+  };
+}
+const offset$1 = offset$2;
+const shift$1 = shift$2;
+const flip$1 = flip$2;
+const computePosition = (reference, floating, options) => {
+  const cache = /* @__PURE__ */ new Map();
+  const mergedOptions = {
+    platform,
+    ...options
+  };
+  const platformWithCache = {
+    ...mergedOptions.platform,
+    _c: cache
+  };
+  return computePosition$1(reference, floating, {
+    ...mergedOptions,
+    platform: platformWithCache
+  });
+};
+var index$1 = typeof document !== "undefined" ? useLayoutEffect : useEffect;
+function deepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (typeof a !== typeof b) {
+    return false;
+  }
+  if (typeof a === "function" && a.toString() === b.toString()) {
+    return true;
+  }
+  let length;
+  let i;
+  let keys;
+  if (a && b && typeof a === "object") {
+    if (Array.isArray(a)) {
+      length = a.length;
+      if (length !== b.length) return false;
+      for (i = length; i-- !== 0; ) {
+        if (!deepEqual(a[i], b[i])) {
+          return false;
+        }
+      }
+      return true;
+    }
+    keys = Object.keys(a);
+    length = keys.length;
+    if (length !== Object.keys(b).length) {
+      return false;
+    }
+    for (i = length; i-- !== 0; ) {
+      if (!{}.hasOwnProperty.call(b, keys[i])) {
+        return false;
+      }
+    }
+    for (i = length; i-- !== 0; ) {
+      const key = keys[i];
+      if (key === "_owner" && a.$$typeof) {
+        continue;
+      }
+      if (!deepEqual(a[key], b[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return a !== a && b !== b;
+}
+function getDPR(element) {
+  if (typeof window === "undefined") {
+    return 1;
+  }
+  const win = element.ownerDocument.defaultView || window;
+  return win.devicePixelRatio || 1;
+}
+function roundByDPR(element, value) {
+  const dpr = getDPR(element);
+  return Math.round(value * dpr) / dpr;
+}
+function useLatestRef$1(value) {
+  const ref = React.useRef(value);
+  index$1(() => {
+    ref.current = value;
+  });
+  return ref;
+}
+function useFloating$1(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  const {
+    placement = "bottom",
+    strategy = "absolute",
+    middleware = [],
+    platform: platform2,
+    elements: {
+      reference: externalReference,
+      floating: externalFloating
+    } = {},
+    transform = true,
+    whileElementsMounted,
+    open
+  } = options;
+  const [data, setData] = React.useState({
+    x: 0,
+    y: 0,
+    strategy,
+    placement,
+    middlewareData: {},
+    isPositioned: false
+  });
+  const [latestMiddleware, setLatestMiddleware] = React.useState(middleware);
+  if (!deepEqual(latestMiddleware, middleware)) {
+    setLatestMiddleware(middleware);
+  }
+  const [_reference, _setReference] = React.useState(null);
+  const [_floating, _setFloating] = React.useState(null);
+  const setReference = React.useCallback((node) => {
+    if (node !== referenceRef.current) {
+      referenceRef.current = node;
+      _setReference(node);
+    }
+  }, []);
+  const setFloating = React.useCallback((node) => {
+    if (node !== floatingRef.current) {
+      floatingRef.current = node;
+      _setFloating(node);
+    }
+  }, []);
+  const referenceEl = externalReference || _reference;
+  const floatingEl = externalFloating || _floating;
+  const referenceRef = React.useRef(null);
+  const floatingRef = React.useRef(null);
+  const dataRef = React.useRef(data);
+  const hasWhileElementsMounted = whileElementsMounted != null;
+  const whileElementsMountedRef = useLatestRef$1(whileElementsMounted);
+  const platformRef = useLatestRef$1(platform2);
+  const openRef = useLatestRef$1(open);
+  const update = React.useCallback(() => {
+    if (!referenceRef.current || !floatingRef.current) {
+      return;
+    }
+    const config = {
+      placement,
+      strategy,
+      middleware: latestMiddleware
+    };
+    if (platformRef.current) {
+      config.platform = platformRef.current;
+    }
+    computePosition(referenceRef.current, floatingRef.current, config).then((data2) => {
+      const fullData = {
+        ...data2,
+        // The floating element's position may be recomputed while it's closed
+        // but still mounted (such as when transitioning out). To ensure
+        // `isPositioned` will be `false` initially on the next open, avoid
+        // setting it to `true` when `open === false` (must be specified).
+        isPositioned: openRef.current !== false
+      };
+      if (isMountedRef.current && !deepEqual(dataRef.current, fullData)) {
+        dataRef.current = fullData;
+        ReactDOM.flushSync(() => {
+          setData(fullData);
+        });
+      }
+    });
+  }, [latestMiddleware, placement, strategy, platformRef, openRef]);
+  index$1(() => {
+    if (open === false && dataRef.current.isPositioned) {
+      dataRef.current.isPositioned = false;
+      setData((data2) => ({
+        ...data2,
+        isPositioned: false
+      }));
+    }
+  }, [open]);
+  const isMountedRef = React.useRef(false);
+  index$1(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+    };
+  }, []);
+  index$1(() => {
+    if (referenceEl) referenceRef.current = referenceEl;
+    if (floatingEl) floatingRef.current = floatingEl;
+    if (referenceEl && floatingEl) {
+      if (whileElementsMountedRef.current) {
+        return whileElementsMountedRef.current(referenceEl, floatingEl, update);
+      }
+      update();
+    }
+  }, [referenceEl, floatingEl, update, whileElementsMountedRef, hasWhileElementsMounted]);
+  const refs = React.useMemo(() => ({
+    reference: referenceRef,
+    floating: floatingRef,
+    setReference,
+    setFloating
+  }), [setReference, setFloating]);
+  const elements = React.useMemo(() => ({
+    reference: referenceEl,
+    floating: floatingEl
+  }), [referenceEl, floatingEl]);
+  const floatingStyles = React.useMemo(() => {
+    const initialStyles = {
+      position: strategy,
+      left: 0,
+      top: 0
+    };
+    if (!elements.floating) {
+      return initialStyles;
+    }
+    const x = roundByDPR(elements.floating, data.x);
+    const y = roundByDPR(elements.floating, data.y);
+    if (transform) {
+      return {
+        ...initialStyles,
+        transform: "translate(" + x + "px, " + y + "px)",
+        ...getDPR(elements.floating) >= 1.5 && {
+          willChange: "transform"
+        }
+      };
+    }
+    return {
+      position: strategy,
+      left: x,
+      top: y
+    };
+  }, [strategy, transform, elements.floating, data.x, data.y]);
+  return React.useMemo(() => ({
+    ...data,
+    update,
+    refs,
+    elements,
+    floatingStyles
+  }), [data, update, refs, elements, floatingStyles]);
+}
+const offset = (options, deps) => ({
+  ...offset$1(options),
+  options: [options, deps]
+});
+const shift = (options, deps) => ({
+  ...shift$1(options),
+  options: [options, deps]
+});
+const flip = (options, deps) => ({
+  ...flip$1(options),
+  options: [options, deps]
+});
+const SafeReact = {
+  ...React
+};
+const useInsertionEffect = SafeReact.useInsertionEffect;
+const useSafeInsertionEffect = useInsertionEffect || ((fn) => fn());
+function useEffectEvent(callback) {
+  const ref = React.useRef(() => {
+    if (process.env.NODE_ENV !== "production") {
+      throw new Error("Cannot call an event handler while rendering.");
+    }
+  });
+  useSafeInsertionEffect(() => {
+    ref.current = callback;
+  });
+  return React.useCallback(function() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return ref.current == null ? void 0 : ref.current(...args);
+  }, []);
+}
+const ARROW_UP = "ArrowUp";
+const ARROW_DOWN = "ArrowDown";
+const ARROW_LEFT = "ArrowLeft";
+const ARROW_RIGHT = "ArrowRight";
+function isDifferentRow(index2, cols, prevRow) {
+  return Math.floor(index2 / cols) !== prevRow;
+}
+function isIndexOutOfBounds(listRef, index2) {
+  return index2 < 0 || index2 >= listRef.current.length;
+}
+function getMinIndex(listRef, disabledIndices) {
+  return findNonDisabledIndex(listRef, {
+    disabledIndices
+  });
+}
+function getMaxIndex(listRef, disabledIndices) {
+  return findNonDisabledIndex(listRef, {
+    decrement: true,
+    startingIndex: listRef.current.length,
+    disabledIndices
+  });
+}
+function findNonDisabledIndex(listRef, _temp) {
+  let {
+    startingIndex = -1,
+    decrement = false,
+    disabledIndices,
+    amount = 1
+  } = _temp === void 0 ? {} : _temp;
+  const list = listRef.current;
+  let index2 = startingIndex;
+  do {
+    index2 += decrement ? -amount : amount;
+  } while (index2 >= 0 && index2 <= list.length - 1 && isDisabled(list, index2, disabledIndices));
+  return index2;
+}
+function getGridNavigatedIndex(elementsRef, _ref) {
+  let {
+    event,
+    orientation,
+    loop,
+    rtl,
+    cols,
+    disabledIndices,
+    minIndex,
+    maxIndex,
+    prevIndex,
+    stopEvent: stop = false
+  } = _ref;
+  let nextIndex = prevIndex;
+  if (event.key === ARROW_UP) {
+    stop && stopEvent(event);
+    if (prevIndex === -1) {
+      nextIndex = maxIndex;
+    } else {
+      nextIndex = findNonDisabledIndex(elementsRef, {
+        startingIndex: nextIndex,
+        amount: cols,
+        decrement: true,
+        disabledIndices
+      });
+      if (loop && (prevIndex - cols < minIndex || nextIndex < 0)) {
+        const col = prevIndex % cols;
+        const maxCol = maxIndex % cols;
+        const offset2 = maxIndex - (maxCol - col);
+        if (maxCol === col) {
+          nextIndex = maxIndex;
+        } else {
+          nextIndex = maxCol > col ? offset2 : offset2 - cols;
+        }
+      }
+    }
+    if (isIndexOutOfBounds(elementsRef, nextIndex)) {
+      nextIndex = prevIndex;
+    }
+  }
+  if (event.key === ARROW_DOWN) {
+    stop && stopEvent(event);
+    if (prevIndex === -1) {
+      nextIndex = minIndex;
+    } else {
+      nextIndex = findNonDisabledIndex(elementsRef, {
+        startingIndex: prevIndex,
+        amount: cols,
+        disabledIndices
+      });
+      if (loop && prevIndex + cols > maxIndex) {
+        nextIndex = findNonDisabledIndex(elementsRef, {
+          startingIndex: prevIndex % cols - cols,
+          amount: cols,
+          disabledIndices
+        });
+      }
+    }
+    if (isIndexOutOfBounds(elementsRef, nextIndex)) {
+      nextIndex = prevIndex;
+    }
+  }
+  if (orientation === "both") {
+    const prevRow = floor(prevIndex / cols);
+    if (event.key === (rtl ? ARROW_LEFT : ARROW_RIGHT)) {
+      stop && stopEvent(event);
+      if (prevIndex % cols !== cols - 1) {
+        nextIndex = findNonDisabledIndex(elementsRef, {
+          startingIndex: prevIndex,
+          disabledIndices
+        });
+        if (loop && isDifferentRow(nextIndex, cols, prevRow)) {
+          nextIndex = findNonDisabledIndex(elementsRef, {
+            startingIndex: prevIndex - prevIndex % cols - 1,
+            disabledIndices
+          });
+        }
+      } else if (loop) {
+        nextIndex = findNonDisabledIndex(elementsRef, {
+          startingIndex: prevIndex - prevIndex % cols - 1,
+          disabledIndices
+        });
+      }
+      if (isDifferentRow(nextIndex, cols, prevRow)) {
+        nextIndex = prevIndex;
+      }
+    }
+    if (event.key === (rtl ? ARROW_RIGHT : ARROW_LEFT)) {
+      stop && stopEvent(event);
+      if (prevIndex % cols !== 0) {
+        nextIndex = findNonDisabledIndex(elementsRef, {
+          startingIndex: prevIndex,
+          decrement: true,
+          disabledIndices
+        });
+        if (loop && isDifferentRow(nextIndex, cols, prevRow)) {
+          nextIndex = findNonDisabledIndex(elementsRef, {
+            startingIndex: prevIndex + (cols - prevIndex % cols),
+            decrement: true,
+            disabledIndices
+          });
+        }
+      } else if (loop) {
+        nextIndex = findNonDisabledIndex(elementsRef, {
+          startingIndex: prevIndex + (cols - prevIndex % cols),
+          decrement: true,
+          disabledIndices
+        });
+      }
+      if (isDifferentRow(nextIndex, cols, prevRow)) {
+        nextIndex = prevIndex;
+      }
+    }
+    const lastRow = floor(maxIndex / cols) === prevRow;
+    if (isIndexOutOfBounds(elementsRef, nextIndex)) {
+      if (loop && lastRow) {
+        nextIndex = event.key === (rtl ? ARROW_RIGHT : ARROW_LEFT) ? maxIndex : findNonDisabledIndex(elementsRef, {
+          startingIndex: prevIndex - prevIndex % cols - 1,
+          disabledIndices
+        });
+      } else {
+        nextIndex = prevIndex;
+      }
+    }
+  }
+  return nextIndex;
+}
+function buildCellMap(sizes, cols, dense) {
+  const cellMap = [];
+  let startIndex = 0;
+  sizes.forEach((_ref2, index2) => {
+    let {
+      width,
+      height
+    } = _ref2;
+    if (width > cols) {
+      if (process.env.NODE_ENV !== "production") {
+        throw new Error("[Floating UI]: Invalid grid - item width at index " + index2 + " is greater than grid columns");
+      }
+    }
+    let itemPlaced = false;
+    if (dense) {
+      startIndex = 0;
+    }
+    while (!itemPlaced) {
+      const targetCells = [];
+      for (let i = 0; i < width; i++) {
+        for (let j = 0; j < height; j++) {
+          targetCells.push(startIndex + i + j * cols);
+        }
+      }
+      if (startIndex % cols + width <= cols && targetCells.every((cell) => cellMap[cell] == null)) {
+        targetCells.forEach((cell) => {
+          cellMap[cell] = index2;
+        });
+        itemPlaced = true;
+      } else {
+        startIndex++;
+      }
+    }
+  });
+  return [...cellMap];
+}
+function getCellIndexOfCorner(index2, sizes, cellMap, cols, corner) {
+  if (index2 === -1) return -1;
+  const firstCellIndex = cellMap.indexOf(index2);
+  const sizeItem = sizes[index2];
+  switch (corner) {
+    case "tl":
+      return firstCellIndex;
+    case "tr":
+      if (!sizeItem) {
+        return firstCellIndex;
+      }
+      return firstCellIndex + sizeItem.width - 1;
+    case "bl":
+      if (!sizeItem) {
+        return firstCellIndex;
+      }
+      return firstCellIndex + (sizeItem.height - 1) * cols;
+    case "br":
+      return cellMap.lastIndexOf(index2);
+  }
+}
+function getCellIndices(indices, cellMap) {
+  return cellMap.flatMap((index2, cellIndex) => indices.includes(index2) ? [cellIndex] : []);
+}
+function isDisabled(list, index2, disabledIndices) {
+  if (disabledIndices) {
+    return disabledIndices.includes(index2);
+  }
+  const element = list[index2];
+  return element == null || element.hasAttribute("disabled") || element.getAttribute("aria-disabled") === "true";
+}
+var index = typeof document !== "undefined" ? useLayoutEffect : useEffect;
+function sortByDocumentPosition(a, b) {
+  const position = a.compareDocumentPosition(b);
+  if (position & Node.DOCUMENT_POSITION_FOLLOWING || position & Node.DOCUMENT_POSITION_CONTAINED_BY) {
+    return -1;
+  }
+  if (position & Node.DOCUMENT_POSITION_PRECEDING || position & Node.DOCUMENT_POSITION_CONTAINS) {
+    return 1;
+  }
+  return 0;
+}
+function areMapsEqual(map1, map2) {
+  if (map1.size !== map2.size) {
+    return false;
+  }
+  for (const [key, value] of map1.entries()) {
+    if (value !== map2.get(key)) {
+      return false;
+    }
+  }
+  return true;
+}
+const FloatingListContext = /* @__PURE__ */ React.createContext({
+  register: () => {
+  },
+  unregister: () => {
+  },
+  map: /* @__PURE__ */ new Map(),
+  elementsRef: {
+    current: []
+  }
 });
-var useSideNavigationContext = function useSideNavigationContext() {
-  var context = React.useContext(SideNavigationContext);
-  if (!context) {
-    console.error('Error reading SideNavigationContext. Please contact maintainer of @entur/menu');
+function FloatingList(props) {
+  const {
+    children,
+    elementsRef,
+    labelsRef
+  } = props;
+  const [map, setMap] = React.useState(() => /* @__PURE__ */ new Map());
+  const register = React.useCallback((node) => {
+    setMap((prevMap) => new Map(prevMap).set(node, null));
+  }, []);
+  const unregister = React.useCallback((node) => {
+    setMap((prevMap) => {
+      const map2 = new Map(prevMap);
+      map2.delete(node);
+      return map2;
+    });
+  }, []);
+  index(() => {
+    const newMap = new Map(map);
+    const nodes = Array.from(newMap.keys()).sort(sortByDocumentPosition);
+    nodes.forEach((node, index2) => {
+      newMap.set(node, index2);
+    });
+    if (!areMapsEqual(map, newMap)) {
+      setMap(newMap);
+    }
+  }, [map]);
+  return /* @__PURE__ */ React.createElement(FloatingListContext.Provider, {
+    value: React.useMemo(() => ({
+      register,
+      unregister,
+      map,
+      elementsRef,
+      labelsRef
+    }), [register, unregister, map, elementsRef, labelsRef])
+  }, children);
+}
+function useListItem(props) {
+  if (props === void 0) {
+    props = {};
   }
-  return context;
+  const {
+    label
+  } = props;
+  const {
+    register,
+    unregister,
+    map,
+    elementsRef,
+    labelsRef
+  } = React.useContext(FloatingListContext);
+  const [index$12, setIndex] = React.useState(null);
+  const componentRef = React.useRef(null);
+  const ref = React.useCallback((node) => {
+    componentRef.current = node;
+    if (index$12 !== null) {
+      elementsRef.current[index$12] = node;
+      if (labelsRef) {
+        var _node$textContent;
+        const isLabelDefined = label !== void 0;
+        labelsRef.current[index$12] = isLabelDefined ? label : (_node$textContent = node == null ? void 0 : node.textContent) != null ? _node$textContent : null;
+      }
+    }
+  }, [index$12, elementsRef, labelsRef, label]);
+  index(() => {
+    const node = componentRef.current;
+    if (node) {
+      register(node);
+      return () => {
+        unregister(node);
+      };
+    }
+  }, [register, unregister]);
+  index(() => {
+    const index2 = componentRef.current ? map.get(componentRef.current) : null;
+    if (index2 != null) {
+      setIndex(index2);
+    }
+  }, [map]);
+  return React.useMemo(() => ({
+    ref,
+    index: index$12 == null ? -1 : index$12
+  }), [index$12, ref]);
+}
+let serverHandoffComplete = false;
+let count = 0;
+const genId = () => (
+  // Ensure the id is unique with multiple independent versions of Floating UI
+  // on <React 18
+  "floating-ui-" + Math.random().toString(36).slice(2, 6) + count++
+);
+function useFloatingId() {
+  const [id, setId] = React.useState(() => serverHandoffComplete ? genId() : void 0);
+  index(() => {
+    if (id == null) {
+      setId(genId());
+    }
+  }, []);
+  React.useEffect(() => {
+    serverHandoffComplete = true;
+  }, []);
+  return id;
+}
+const useReactId = SafeReact.useId;
+const useId = useReactId || useFloatingId;
+let devMessageSet;
+if (process.env.NODE_ENV !== "production") {
+  devMessageSet = /* @__PURE__ */ new Set();
+}
+function warn() {
+  var _devMessageSet;
+  for (var _len = arguments.length, messages = new Array(_len), _key = 0; _key < _len; _key++) {
+    messages[_key] = arguments[_key];
+  }
+  const message = "Floating UI: " + messages.join(" ");
+  if (!((_devMessageSet = devMessageSet) != null && _devMessageSet.has(message))) {
+    var _devMessageSet2;
+    (_devMessageSet2 = devMessageSet) == null || _devMessageSet2.add(message);
+    console.warn(message);
+  }
+}
+function error() {
+  var _devMessageSet3;
+  for (var _len2 = arguments.length, messages = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    messages[_key2] = arguments[_key2];
+  }
+  const message = "Floating UI: " + messages.join(" ");
+  if (!((_devMessageSet3 = devMessageSet) != null && _devMessageSet3.has(message))) {
+    var _devMessageSet4;
+    (_devMessageSet4 = devMessageSet) == null || _devMessageSet4.add(message);
+    console.error(message);
+  }
+}
+function createPubSub() {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    emit(event, data) {
+      var _map$get;
+      (_map$get = map.get(event)) == null || _map$get.forEach((handler) => handler(data));
+    },
+    on(event, listener) {
+      map.set(event, [...map.get(event) || [], listener]);
+    },
+    off(event, listener) {
+      var _map$get2;
+      map.set(event, ((_map$get2 = map.get(event)) == null ? void 0 : _map$get2.filter((l) => l !== listener)) || []);
+    }
+  };
+}
+const FloatingNodeContext = /* @__PURE__ */ React.createContext(null);
+const FloatingTreeContext = /* @__PURE__ */ React.createContext(null);
+const useFloatingParentNodeId = () => {
+  var _React$useContext;
+  return ((_React$useContext = React.useContext(FloatingNodeContext)) == null ? void 0 : _React$useContext.id) || null;
 };
-
-var _excluded$6 = ["children", "className", "button", "buttonIcon", "placement", "aria-label"],
-  _excluded2$1 = ["children", "className", "onSelect", "href", "disabled", "as"];
-var SelectContext = /*#__PURE__*/React.createContext({});
-var OverflowMenu = function OverflowMenu(_ref) {
-  var children = _ref.children,
-    className = _ref.className,
-    button = _ref.button,
-    buttonIcon = _ref.buttonIcon,
-    _ref$placement = _ref.placement,
-    placement = _ref$placement === void 0 ? 'bottom-start' : _ref$placement,
-    _ref$ariaLabel = _ref['aria-label'],
-    ariaLabel = _ref$ariaLabel === void 0 ? 'åpne valgmeny' : _ref$ariaLabel,
-    rest = _objectWithoutPropertiesLoose(_ref, _excluded$6);
-  var _useState = useState(false),
-    isOpen = _useState[0],
-    setIsOpen = _useState[1];
-  var _useState2 = useState(null),
-    activeIndex = _useState2[0],
-    setActiveIndex = _useState2[1];
-  var listRef = useRef([]);
-  var labelsRef = useRef([]);
-  var _useFloating = useFloating({
-      placement: standardisePlacement(
+const useFloatingTree = () => React.useContext(FloatingTreeContext);
+function useLatestRef(value) {
+  const ref = useRef(value);
+  index(() => {
+    ref.current = value;
+  });
+  return ref;
+}
+let rafId = 0;
+function enqueueFocus(el, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  const {
+    preventScroll = false,
+    cancelPrevious = true,
+    sync = false
+  } = options;
+  cancelPrevious && cancelAnimationFrame(rafId);
+  const exec = () => el == null ? void 0 : el.focus({
+    preventScroll
+  });
+  if (sync) {
+    exec();
+  } else {
+    rafId = requestAnimationFrame(exec);
+  }
+}
+function getChildren(nodes, id) {
+  let allChildren = nodes.filter((node) => {
+    var _node$context;
+    return node.parentId === id && ((_node$context = node.context) == null ? void 0 : _node$context.open);
+  });
+  let currentChildren = allChildren;
+  while (currentChildren.length) {
+    currentChildren = nodes.filter((node) => {
+      var _currentChildren;
+      return (_currentChildren = currentChildren) == null ? void 0 : _currentChildren.some((n) => {
+        var _node$context2;
+        return node.parentId === n.id && ((_node$context2 = node.context) == null ? void 0 : _node$context2.open);
+      });
+    });
+    allChildren = allChildren.concat(currentChildren);
+  }
+  return allChildren;
+}
+function getDeepestNode(nodes, id) {
+  let deepestNodeId;
+  let maxDepth = -1;
+  function findDeepest(nodeId, depth) {
+    if (depth > maxDepth) {
+      deepestNodeId = nodeId;
+      maxDepth = depth;
+    }
+    const children = getChildren(nodes, nodeId);
+    children.forEach((child) => {
+      findDeepest(child.id, depth + 1);
+    });
+  }
+  findDeepest(id, 0);
+  return nodes.find((node) => node.id === deepestNodeId);
+}
+const FOCUSABLE_ATTRIBUTE = "data-floating-ui-focusable";
+function getFloatingFocusElement(floatingElement) {
+  if (!floatingElement) {
+    return null;
+  }
+  return floatingElement.hasAttribute(FOCUSABLE_ATTRIBUTE) ? floatingElement : floatingElement.querySelector("[" + FOCUSABLE_ATTRIBUTE + "]") || floatingElement;
+}
+function useFloatingRootContext(options) {
+  const {
+    open = false,
+    onOpenChange: onOpenChangeProp,
+    elements: elementsProp
+  } = options;
+  const floatingId = useId();
+  const dataRef = React.useRef({});
+  const [events] = React.useState(() => createPubSub());
+  const nested = useFloatingParentNodeId() != null;
+  if (process.env.NODE_ENV !== "production") {
+    const optionDomReference = elementsProp.reference;
+    if (optionDomReference && !isElement(optionDomReference)) {
+      error("Cannot pass a virtual element to the `elements.reference` option,", "as it must be a real DOM element. Use `refs.setPositionReference()`", "instead.");
+    }
+  }
+  const [positionReference, setPositionReference] = React.useState(elementsProp.reference);
+  const onOpenChange = useEffectEvent((open2, event, reason) => {
+    dataRef.current.openEvent = open2 ? event : void 0;
+    events.emit("openchange", {
+      open: open2,
+      event,
+      reason,
+      nested
+    });
+    onOpenChangeProp == null || onOpenChangeProp(open2, event, reason);
+  });
+  const refs = React.useMemo(() => ({
+    setPositionReference
+  }), []);
+  const elements = React.useMemo(() => ({
+    reference: positionReference || elementsProp.reference || null,
+    floating: elementsProp.floating || null,
+    domReference: elementsProp.reference
+  }), [positionReference, elementsProp.reference, elementsProp.floating]);
+  return React.useMemo(() => ({
+    dataRef,
+    open,
+    onOpenChange,
+    elements,
+    events,
+    floatingId,
+    refs
+  }), [open, onOpenChange, elements, events, floatingId, refs]);
+}
+function useFloating(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  const {
+    nodeId
+  } = options;
+  const internalRootContext = useFloatingRootContext({
+    ...options,
+    elements: {
+      reference: null,
+      floating: null,
+      ...options.elements
+    }
+  });
+  const rootContext = options.rootContext || internalRootContext;
+  const computedElements = rootContext.elements;
+  const [_domReference, setDomReference] = React.useState(null);
+  const [positionReference, _setPositionReference] = React.useState(null);
+  const optionDomReference = computedElements == null ? void 0 : computedElements.domReference;
+  const domReference = optionDomReference || _domReference;
+  const domReferenceRef = React.useRef(null);
+  const tree = useFloatingTree();
+  index(() => {
+    if (domReference) {
+      domReferenceRef.current = domReference;
+    }
+  }, [domReference]);
+  const position = useFloating$1({
+    ...options,
+    elements: {
+      ...computedElements,
+      ...positionReference && {
+        reference: positionReference
+      }
+    }
+  });
+  const setPositionReference = React.useCallback((node) => {
+    const computedPositionReference = isElement(node) ? {
+      getBoundingClientRect: () => node.getBoundingClientRect(),
+      contextElement: node
+    } : node;
+    _setPositionReference(computedPositionReference);
+    position.refs.setReference(computedPositionReference);
+  }, [position.refs]);
+  const setReference = React.useCallback((node) => {
+    if (isElement(node) || node === null) {
+      domReferenceRef.current = node;
+      setDomReference(node);
+    }
+    if (isElement(position.refs.reference.current) || position.refs.reference.current === null || // Don't allow setting virtual elements using the old technique back to
+    // `null` to support `positionReference` + an unstable `reference`
+    // callback ref.
+    node !== null && !isElement(node)) {
+      position.refs.setReference(node);
+    }
+  }, [position.refs]);
+  const refs = React.useMemo(() => ({
+    ...position.refs,
+    setReference,
+    setPositionReference,
+    domReference: domReferenceRef
+  }), [position.refs, setReference, setPositionReference]);
+  const elements = React.useMemo(() => ({
+    ...position.elements,
+    domReference
+  }), [position.elements, domReference]);
+  const context = React.useMemo(() => ({
+    ...position,
+    ...rootContext,
+    refs,
+    elements,
+    nodeId
+  }), [position, refs, elements, nodeId, rootContext]);
+  index(() => {
+    rootContext.dataRef.current.floatingContext = context;
+    const node = tree == null ? void 0 : tree.nodesRef.current.find((node2) => node2.id === nodeId);
+    if (node) {
+      node.context = context;
+    }
+  });
+  return React.useMemo(() => ({
+    ...position,
+    context,
+    refs,
+    elements
+  }), [position, refs, elements, context]);
+}
+const ACTIVE_KEY = "active";
+const SELECTED_KEY = "selected";
+function mergeProps(userProps, propsList, elementKey) {
+  const map = /* @__PURE__ */ new Map();
+  const isItem = elementKey === "item";
+  let domUserProps = userProps;
+  if (isItem && userProps) {
+    const {
+      [ACTIVE_KEY]: _,
+      [SELECTED_KEY]: __,
+      ...validProps
+    } = userProps;
+    domUserProps = validProps;
+  }
+  return {
+    ...elementKey === "floating" && {
+      tabIndex: -1,
+      [FOCUSABLE_ATTRIBUTE]: ""
+    },
+    ...domUserProps,
+    ...propsList.map((value) => {
+      const propsOrGetProps = value ? value[elementKey] : null;
+      if (typeof propsOrGetProps === "function") {
+        return userProps ? propsOrGetProps(userProps) : null;
+      }
+      return propsOrGetProps;
+    }).concat(userProps).reduce((acc, props) => {
+      if (!props) {
+        return acc;
+      }
+      Object.entries(props).forEach((_ref) => {
+        let [key, value] = _ref;
+        if (isItem && [ACTIVE_KEY, SELECTED_KEY].includes(key)) {
+          return;
+        }
+        if (key.indexOf("on") === 0) {
+          if (!map.has(key)) {
+            map.set(key, []);
+          }
+          if (typeof value === "function") {
+            var _map$get;
+            (_map$get = map.get(key)) == null || _map$get.push(value);
+            acc[key] = function() {
+              var _map$get2;
+              for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+                args[_key] = arguments[_key];
+              }
+              return (_map$get2 = map.get(key)) == null ? void 0 : _map$get2.map((fn) => fn(...args)).find((val) => val !== void 0);
+            };
+          }
+        } else {
+          acc[key] = value;
+        }
+      });
+      return acc;
+    }, {})
+  };
+}
+function useInteractions(propsList) {
+  if (propsList === void 0) {
+    propsList = [];
+  }
+  const referenceDeps = propsList.map((key) => key == null ? void 0 : key.reference);
+  const floatingDeps = propsList.map((key) => key == null ? void 0 : key.floating);
+  const itemDeps = propsList.map((key) => key == null ? void 0 : key.item);
+  const getReferenceProps = React.useCallback(
+    (userProps) => mergeProps(userProps, propsList, "reference"),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    referenceDeps
+  );
+  const getFloatingProps = React.useCallback(
+    (userProps) => mergeProps(userProps, propsList, "floating"),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    floatingDeps
+  );
+  const getItemProps = React.useCallback(
+    (userProps) => mergeProps(userProps, propsList, "item"),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    itemDeps
+  );
+  return React.useMemo(() => ({
+    getReferenceProps,
+    getFloatingProps,
+    getItemProps
+  }), [getReferenceProps, getFloatingProps, getItemProps]);
+}
+let isPreventScrollSupported = false;
+function doSwitch(orientation, vertical, horizontal) {
+  switch (orientation) {
+    case "vertical":
+      return vertical;
+    case "horizontal":
+      return horizontal;
+    default:
+      return vertical || horizontal;
+  }
+}
+function isMainOrientationKey(key, orientation) {
+  const vertical = key === ARROW_UP || key === ARROW_DOWN;
+  const horizontal = key === ARROW_LEFT || key === ARROW_RIGHT;
+  return doSwitch(orientation, vertical, horizontal);
+}
+function isMainOrientationToEndKey(key, orientation, rtl) {
+  const vertical = key === ARROW_DOWN;
+  const horizontal = rtl ? key === ARROW_LEFT : key === ARROW_RIGHT;
+  return doSwitch(orientation, vertical, horizontal) || key === "Enter" || key === " " || key === "";
+}
+function isCrossOrientationOpenKey(key, orientation, rtl) {
+  const vertical = rtl ? key === ARROW_LEFT : key === ARROW_RIGHT;
+  const horizontal = key === ARROW_DOWN;
+  return doSwitch(orientation, vertical, horizontal);
+}
+function isCrossOrientationCloseKey(key, orientation, rtl) {
+  const vertical = rtl ? key === ARROW_RIGHT : key === ARROW_LEFT;
+  const horizontal = key === ARROW_UP;
+  return doSwitch(orientation, vertical, horizontal);
+}
+function useListNavigation(context, props) {
+  const {
+    open,
+    onOpenChange,
+    elements
+  } = context;
+  const {
+    listRef,
+    activeIndex,
+    onNavigate: unstable_onNavigate = () => {
+    },
+    enabled = true,
+    selectedIndex = null,
+    allowEscape = false,
+    loop = false,
+    nested = false,
+    rtl = false,
+    virtual = false,
+    focusItemOnOpen = "auto",
+    focusItemOnHover = true,
+    openOnArrowKeyDown = true,
+    disabledIndices = void 0,
+    orientation = "vertical",
+    cols = 1,
+    scrollItemIntoView = true,
+    virtualItemRef,
+    itemSizes,
+    dense = false
+  } = props;
+  if (process.env.NODE_ENV !== "production") {
+    if (allowEscape) {
+      if (!loop) {
+        warn("`useListNavigation` looping must be enabled to allow escaping.");
+      }
+      if (!virtual) {
+        warn("`useListNavigation` must be virtual to allow escaping.");
+      }
+    }
+    if (orientation === "vertical" && cols > 1) {
+      warn("In grid list navigation mode (`cols` > 1), the `orientation` should", 'be either "horizontal" or "both".');
+    }
+  }
+  const floatingFocusElement = getFloatingFocusElement(elements.floating);
+  const floatingFocusElementRef = useLatestRef(floatingFocusElement);
+  const parentId = useFloatingParentNodeId();
+  const tree = useFloatingTree();
+  const onNavigate = useEffectEvent(unstable_onNavigate);
+  const typeableComboboxReference = isTypeableCombobox(elements.domReference);
+  const focusItemOnOpenRef = React.useRef(focusItemOnOpen);
+  const indexRef = React.useRef(selectedIndex != null ? selectedIndex : -1);
+  const keyRef = React.useRef(null);
+  const isPointerModalityRef = React.useRef(true);
+  const previousOnNavigateRef = React.useRef(onNavigate);
+  const previousMountedRef = React.useRef(!!elements.floating);
+  const previousOpenRef = React.useRef(open);
+  const forceSyncFocus = React.useRef(false);
+  const forceScrollIntoViewRef = React.useRef(false);
+  const disabledIndicesRef = useLatestRef(disabledIndices);
+  const latestOpenRef = useLatestRef(open);
+  const scrollItemIntoViewRef = useLatestRef(scrollItemIntoView);
+  const selectedIndexRef = useLatestRef(selectedIndex);
+  const [activeId, setActiveId] = React.useState();
+  const [virtualId, setVirtualId] = React.useState();
+  const focusItem = useEffectEvent(function(listRef2, indexRef2, forceScrollIntoView) {
+    if (forceScrollIntoView === void 0) {
+      forceScrollIntoView = false;
+    }
+    function runFocus(item2) {
+      if (virtual) {
+        setActiveId(item2.id);
+        tree == null || tree.events.emit("virtualfocus", item2);
+        if (virtualItemRef) {
+          virtualItemRef.current = item2;
+        }
+      } else {
+        enqueueFocus(item2, {
+          preventScroll: true,
+          // Mac Safari does not move the virtual cursor unless the focus call
+          // is sync. However, for the very first focus call, we need to wait
+          // for the position to be ready in order to prevent unwanted
+          // scrolling. This means the virtual cursor will not move to the first
+          // item when first opening the floating element, but will on
+          // subsequent calls. `preventScroll` is supported in modern Safari,
+          // so we can use that instead.
+          // iOS Safari must be async or the first item will not be focused.
+          sync: isMac() && isSafari() ? isPreventScrollSupported || forceSyncFocus.current : false
+        });
+      }
+    }
+    const initialItem = listRef2.current[indexRef2.current];
+    if (initialItem) {
+      runFocus(initialItem);
+    }
+    requestAnimationFrame(() => {
+      const waitedItem = listRef2.current[indexRef2.current] || initialItem;
+      if (!waitedItem) return;
+      if (!initialItem) {
+        runFocus(waitedItem);
+      }
+      const scrollIntoViewOptions = scrollItemIntoViewRef.current;
+      const shouldScrollIntoView = scrollIntoViewOptions && item && (forceScrollIntoView || !isPointerModalityRef.current);
+      if (shouldScrollIntoView) {
+        waitedItem.scrollIntoView == null || waitedItem.scrollIntoView(typeof scrollIntoViewOptions === "boolean" ? {
+          block: "nearest",
+          inline: "nearest"
+        } : scrollIntoViewOptions);
+      }
+    });
+  });
+  index(() => {
+    document.createElement("div").focus({
+      get preventScroll() {
+        isPreventScrollSupported = true;
+        return false;
+      }
+    });
+  }, []);
+  index(() => {
+    if (!enabled) return;
+    if (open && elements.floating) {
+      if (focusItemOnOpenRef.current && selectedIndex != null) {
+        forceScrollIntoViewRef.current = true;
+        indexRef.current = selectedIndex;
+        onNavigate(selectedIndex);
+      }
+    } else if (previousMountedRef.current) {
+      indexRef.current = -1;
+      previousOnNavigateRef.current(null);
+    }
+  }, [enabled, open, elements.floating, selectedIndex, onNavigate]);
+  index(() => {
+    if (!enabled) return;
+    if (open && elements.floating) {
+      if (activeIndex == null) {
+        forceSyncFocus.current = false;
+        if (selectedIndexRef.current != null) {
+          return;
+        }
+        if (previousMountedRef.current) {
+          indexRef.current = -1;
+          focusItem(listRef, indexRef);
+        }
+        if ((!previousOpenRef.current || !previousMountedRef.current) && focusItemOnOpenRef.current && (keyRef.current != null || focusItemOnOpenRef.current === true && keyRef.current == null)) {
+          let runs = 0;
+          const waitForListPopulated = () => {
+            if (listRef.current[0] == null) {
+              if (runs < 2) {
+                const scheduler = runs ? requestAnimationFrame : queueMicrotask;
+                scheduler(waitForListPopulated);
+              }
+              runs++;
+            } else {
+              indexRef.current = keyRef.current == null || isMainOrientationToEndKey(keyRef.current, orientation, rtl) || nested ? getMinIndex(listRef, disabledIndicesRef.current) : getMaxIndex(listRef, disabledIndicesRef.current);
+              keyRef.current = null;
+              onNavigate(indexRef.current);
+            }
+          };
+          waitForListPopulated();
+        }
+      } else if (!isIndexOutOfBounds(listRef, activeIndex)) {
+        indexRef.current = activeIndex;
+        focusItem(listRef, indexRef, forceScrollIntoViewRef.current);
+        forceScrollIntoViewRef.current = false;
+      }
+    }
+  }, [enabled, open, elements.floating, activeIndex, selectedIndexRef, nested, listRef, orientation, rtl, onNavigate, focusItem, disabledIndicesRef]);
+  index(() => {
+    var _nodes$find;
+    if (!enabled || elements.floating || !tree || virtual || !previousMountedRef.current) {
+      return;
+    }
+    const nodes = tree.nodesRef.current;
+    const parent = (_nodes$find = nodes.find((node) => node.id === parentId)) == null || (_nodes$find = _nodes$find.context) == null ? void 0 : _nodes$find.elements.floating;
+    const activeEl = activeElement(getDocument(elements.floating));
+    const treeContainsActiveEl = nodes.some((node) => node.context && contains(node.context.elements.floating, activeEl));
+    if (parent && !treeContainsActiveEl && isPointerModalityRef.current) {
+      parent.focus({
+        preventScroll: true
+      });
+    }
+  }, [enabled, elements.floating, tree, parentId, virtual]);
+  index(() => {
+    if (!enabled) return;
+    if (!tree) return;
+    if (!virtual) return;
+    if (parentId) return;
+    function handleVirtualFocus(item2) {
+      setVirtualId(item2.id);
+      if (virtualItemRef) {
+        virtualItemRef.current = item2;
+      }
+    }
+    tree.events.on("virtualfocus", handleVirtualFocus);
+    return () => {
+      tree.events.off("virtualfocus", handleVirtualFocus);
+    };
+  }, [enabled, tree, virtual, parentId, virtualItemRef]);
+  index(() => {
+    previousOnNavigateRef.current = onNavigate;
+    previousMountedRef.current = !!elements.floating;
+  });
+  index(() => {
+    if (!open) {
+      keyRef.current = null;
+    }
+  }, [open]);
+  index(() => {
+    previousOpenRef.current = open;
+  }, [open]);
+  const hasActiveIndex = activeIndex != null;
+  const item = React.useMemo(() => {
+    function syncCurrentTarget(currentTarget) {
+      if (!open) return;
+      const index2 = listRef.current.indexOf(currentTarget);
+      if (index2 !== -1) {
+        onNavigate(index2);
+      }
+    }
+    const props2 = {
+      onFocus(_ref) {
+        let {
+          currentTarget
+        } = _ref;
+        syncCurrentTarget(currentTarget);
+      },
+      onClick: (_ref2) => {
+        let {
+          currentTarget
+        } = _ref2;
+        return currentTarget.focus({
+          preventScroll: true
+        });
+      },
+      // Safari
+      ...focusItemOnHover && {
+        onMouseMove(_ref3) {
+          let {
+            currentTarget
+          } = _ref3;
+          syncCurrentTarget(currentTarget);
+        },
+        onPointerLeave(_ref4) {
+          let {
+            pointerType
+          } = _ref4;
+          if (!isPointerModalityRef.current || pointerType === "touch") {
+            return;
+          }
+          indexRef.current = -1;
+          focusItem(listRef, indexRef);
+          onNavigate(null);
+          if (!virtual) {
+            enqueueFocus(floatingFocusElementRef.current, {
+              preventScroll: true
+            });
+          }
+        }
+      }
+    };
+    return props2;
+  }, [open, floatingFocusElementRef, focusItem, focusItemOnHover, listRef, onNavigate, virtual]);
+  const commonOnKeyDown = useEffectEvent((event) => {
+    isPointerModalityRef.current = false;
+    forceSyncFocus.current = true;
+    if (event.which === 229) {
+      return;
+    }
+    if (!latestOpenRef.current && event.currentTarget === floatingFocusElementRef.current) {
+      return;
+    }
+    if (nested && isCrossOrientationCloseKey(event.key, orientation, rtl)) {
+      stopEvent(event);
+      onOpenChange(false, event.nativeEvent, "list-navigation");
+      if (isHTMLElement(elements.domReference)) {
+        if (virtual) {
+          tree == null || tree.events.emit("virtualfocus", elements.domReference);
+        } else {
+          elements.domReference.focus();
+        }
+      }
+      return;
+    }
+    const currentIndex = indexRef.current;
+    const minIndex = getMinIndex(listRef, disabledIndices);
+    const maxIndex = getMaxIndex(listRef, disabledIndices);
+    if (!typeableComboboxReference) {
+      if (event.key === "Home") {
+        stopEvent(event);
+        indexRef.current = minIndex;
+        onNavigate(indexRef.current);
+      }
+      if (event.key === "End") {
+        stopEvent(event);
+        indexRef.current = maxIndex;
+        onNavigate(indexRef.current);
+      }
+    }
+    if (cols > 1) {
+      const sizes = itemSizes || Array.from({
+        length: listRef.current.length
+      }, () => ({
+        width: 1,
+        height: 1
+      }));
+      const cellMap = buildCellMap(sizes, cols, dense);
+      const minGridIndex = cellMap.findIndex((index3) => index3 != null && !isDisabled(listRef.current, index3, disabledIndices));
+      const maxGridIndex = cellMap.reduce((foundIndex, index3, cellIndex) => index3 != null && !isDisabled(listRef.current, index3, disabledIndices) ? cellIndex : foundIndex, -1);
+      const index2 = cellMap[getGridNavigatedIndex({
+        current: cellMap.map((itemIndex) => itemIndex != null ? listRef.current[itemIndex] : null)
+      }, {
+        event,
+        orientation,
+        loop,
+        rtl,
+        cols,
+        // treat undefined (empty grid spaces) as disabled indices so we
+        // don't end up in them
+        disabledIndices: getCellIndices([...disabledIndices || listRef.current.map((_, index3) => isDisabled(listRef.current, index3) ? index3 : void 0), void 0], cellMap),
+        minIndex: minGridIndex,
+        maxIndex: maxGridIndex,
+        prevIndex: getCellIndexOfCorner(
+          indexRef.current > maxIndex ? minIndex : indexRef.current,
+          sizes,
+          cellMap,
+          cols,
+          // use a corner matching the edge closest to the direction
+          // we're moving in so we don't end up in the same item. Prefer
+          // top/left over bottom/right.
+          event.key === ARROW_DOWN ? "bl" : event.key === (rtl ? ARROW_LEFT : ARROW_RIGHT) ? "tr" : "tl"
+        ),
+        stopEvent: true
+      })];
+      if (index2 != null) {
+        indexRef.current = index2;
+        onNavigate(indexRef.current);
+      }
+      if (orientation === "both") {
+        return;
+      }
+    }
+    if (isMainOrientationKey(event.key, orientation)) {
+      stopEvent(event);
+      if (open && !virtual && activeElement(event.currentTarget.ownerDocument) === event.currentTarget) {
+        indexRef.current = isMainOrientationToEndKey(event.key, orientation, rtl) ? minIndex : maxIndex;
+        onNavigate(indexRef.current);
+        return;
+      }
+      if (isMainOrientationToEndKey(event.key, orientation, rtl)) {
+        if (loop) {
+          indexRef.current = currentIndex >= maxIndex ? allowEscape && currentIndex !== listRef.current.length ? -1 : minIndex : findNonDisabledIndex(listRef, {
+            startingIndex: currentIndex,
+            disabledIndices
+          });
+        } else {
+          indexRef.current = Math.min(maxIndex, findNonDisabledIndex(listRef, {
+            startingIndex: currentIndex,
+            disabledIndices
+          }));
+        }
+      } else {
+        if (loop) {
+          indexRef.current = currentIndex <= minIndex ? allowEscape && currentIndex !== -1 ? listRef.current.length : maxIndex : findNonDisabledIndex(listRef, {
+            startingIndex: currentIndex,
+            decrement: true,
+            disabledIndices
+          });
+        } else {
+          indexRef.current = Math.max(minIndex, findNonDisabledIndex(listRef, {
+            startingIndex: currentIndex,
+            decrement: true,
+            disabledIndices
+          }));
+        }
+      }
+      if (isIndexOutOfBounds(listRef, indexRef.current)) {
+        onNavigate(null);
+      } else {
+        onNavigate(indexRef.current);
+      }
+    }
+  });
+  const ariaActiveDescendantProp = React.useMemo(() => {
+    return virtual && open && hasActiveIndex && {
+      "aria-activedescendant": virtualId || activeId
+    };
+  }, [virtual, open, hasActiveIndex, virtualId, activeId]);
+  const floating = React.useMemo(() => {
+    return {
+      "aria-orientation": orientation === "both" ? void 0 : orientation,
+      ...!isTypeableCombobox(elements.domReference) && ariaActiveDescendantProp,
+      onKeyDown: commonOnKeyDown,
+      onPointerMove() {
+        isPointerModalityRef.current = true;
+      }
+    };
+  }, [ariaActiveDescendantProp, commonOnKeyDown, elements.domReference, orientation]);
+  const reference = React.useMemo(() => {
+    function checkVirtualMouse(event) {
+      if (focusItemOnOpen === "auto" && isVirtualClick(event.nativeEvent)) {
+        focusItemOnOpenRef.current = true;
+      }
+    }
+    function checkVirtualPointer(event) {
+      focusItemOnOpenRef.current = focusItemOnOpen;
+      if (focusItemOnOpen === "auto" && isVirtualPointerEvent(event.nativeEvent)) {
+        focusItemOnOpenRef.current = true;
+      }
+    }
+    return {
+      ...ariaActiveDescendantProp,
+      onKeyDown(event) {
+        isPointerModalityRef.current = false;
+        const isArrowKey = event.key.startsWith("Arrow");
+        const isHomeOrEndKey = ["Home", "End"].includes(event.key);
+        const isMoveKey = isArrowKey || isHomeOrEndKey;
+        const isCrossOpenKey = isCrossOrientationOpenKey(event.key, orientation, rtl);
+        const isCrossCloseKey = isCrossOrientationCloseKey(event.key, orientation, rtl);
+        const isMainKey = isMainOrientationKey(event.key, orientation);
+        const isNavigationKey = (nested ? isCrossOpenKey : isMainKey) || event.key === "Enter" || event.key.trim() === "";
+        if (virtual && open) {
+          const rootNode = tree == null ? void 0 : tree.nodesRef.current.find((node) => node.parentId == null);
+          const deepestNode = tree && rootNode ? getDeepestNode(tree.nodesRef.current, rootNode.id) : null;
+          if (isMoveKey && deepestNode && virtualItemRef) {
+            const eventObject = new KeyboardEvent("keydown", {
+              key: event.key,
+              bubbles: true
+            });
+            if (isCrossOpenKey || isCrossCloseKey) {
+              var _deepestNode$context, _deepestNode$context2;
+              const isCurrentTarget = ((_deepestNode$context = deepestNode.context) == null ? void 0 : _deepestNode$context.elements.domReference) === event.currentTarget;
+              const dispatchItem = isCrossCloseKey && !isCurrentTarget ? (_deepestNode$context2 = deepestNode.context) == null ? void 0 : _deepestNode$context2.elements.domReference : isCrossOpenKey ? listRef.current.find((item2) => (item2 == null ? void 0 : item2.id) === activeId) : null;
+              if (dispatchItem) {
+                stopEvent(event);
+                dispatchItem.dispatchEvent(eventObject);
+                setVirtualId(void 0);
+              }
+            }
+            if ((isMainKey || isHomeOrEndKey) && deepestNode.context) {
+              if (deepestNode.context.open && deepestNode.parentId && event.currentTarget !== deepestNode.context.elements.domReference) {
+                var _deepestNode$context$;
+                stopEvent(event);
+                (_deepestNode$context$ = deepestNode.context.elements.domReference) == null || _deepestNode$context$.dispatchEvent(eventObject);
+                return;
+              }
+            }
+          }
+          return commonOnKeyDown(event);
+        }
+        if (!open && !openOnArrowKeyDown && isArrowKey) {
+          return;
+        }
+        if (isNavigationKey) {
+          keyRef.current = nested && isMainKey ? null : event.key;
+        }
+        if (nested) {
+          if (isCrossOpenKey) {
+            stopEvent(event);
+            if (open) {
+              indexRef.current = getMinIndex(listRef, disabledIndicesRef.current);
+              onNavigate(indexRef.current);
+            } else {
+              onOpenChange(true, event.nativeEvent, "list-navigation");
+            }
+          }
+          return;
+        }
+        if (isMainKey) {
+          if (selectedIndex != null) {
+            indexRef.current = selectedIndex;
+          }
+          stopEvent(event);
+          if (!open && openOnArrowKeyDown) {
+            onOpenChange(true, event.nativeEvent, "list-navigation");
+          } else {
+            commonOnKeyDown(event);
+          }
+          if (open) {
+            onNavigate(indexRef.current);
+          }
+        }
+      },
+      onFocus() {
+        if (open && !virtual) {
+          onNavigate(null);
+        }
+      },
+      onPointerDown: checkVirtualPointer,
+      onMouseDown: checkVirtualMouse,
+      onClick: checkVirtualMouse
+    };
+  }, [activeId, ariaActiveDescendantProp, commonOnKeyDown, disabledIndicesRef, focusItemOnOpen, listRef, nested, onNavigate, onOpenChange, open, openOnArrowKeyDown, orientation, rtl, selectedIndex, tree, virtual, virtualItemRef]);
+  return React.useMemo(() => enabled ? {
+    reference,
+    floating,
+    item
+  } : {}, [enabled, reference, floating, item]);
+}
+const componentRoleToAriaRoleMap = /* @__PURE__ */ new Map([["select", "listbox"], ["combobox", "listbox"], ["label", false]]);
+function useRole(context, props) {
+  var _componentRoleToAriaR;
+  if (props === void 0) {
+    props = {};
+  }
+  const {
+    open,
+    floatingId
+  } = context;
+  const {
+    enabled = true,
+    role = "dialog"
+  } = props;
+  const ariaRole = (_componentRoleToAriaR = componentRoleToAriaRoleMap.get(role)) != null ? _componentRoleToAriaR : role;
+  const referenceId = useId();
+  const parentId = useFloatingParentNodeId();
+  const isNested = parentId != null;
+  const reference = React.useMemo(() => {
+    if (ariaRole === "tooltip" || role === "label") {
+      return {
+        ["aria-" + (role === "label" ? "labelledby" : "describedby")]: open ? floatingId : void 0
+      };
+    }
+    return {
+      "aria-expanded": open ? "true" : "false",
+      "aria-haspopup": ariaRole === "alertdialog" ? "dialog" : ariaRole,
+      "aria-controls": open ? floatingId : void 0,
+      ...ariaRole === "listbox" && {
+        role: "combobox"
+      },
+      ...ariaRole === "menu" && {
+        id: referenceId
+      },
+      ...ariaRole === "menu" && isNested && {
+        role: "menuitem"
+      },
+      ...role === "select" && {
+        "aria-autocomplete": "none"
+      },
+      ...role === "combobox" && {
+        "aria-autocomplete": "list"
+      }
+    };
+  }, [ariaRole, floatingId, isNested, open, referenceId, role]);
+  const floating = React.useMemo(() => {
+    const floatingProps = {
+      id: floatingId,
+      ...ariaRole && {
+        role: ariaRole
+      }
+    };
+    if (ariaRole === "tooltip" || role === "label") {
+      return floatingProps;
+    }
+    return {
+      ...floatingProps,
+      ...ariaRole === "menu" && {
+        "aria-labelledby": referenceId
+      }
+    };
+  }, [ariaRole, floatingId, referenceId, role]);
+  const item = React.useCallback((_ref) => {
+    let {
+      active,
+      selected
+    } = _ref;
+    const commonProps = {
+      role: "option",
+      ...active && {
+        id: floatingId + "-option"
+      }
+    };
+    switch (role) {
+      case "select":
+        return {
+          ...commonProps,
+          "aria-selected": active && selected
+        };
+      case "combobox": {
+        return {
+          ...commonProps,
+          ...active && {
+            "aria-selected": true
+          }
+        };
+      }
+    }
+    return {};
+  }, [floatingId, role]);
+  return React.useMemo(() => enabled ? {
+    reference,
+    floating,
+    item
+  } : {}, [enabled, reference, floating, item]);
+}
+function useTypeahead(context, props) {
+  var _ref;
+  const {
+    open,
+    dataRef
+  } = context;
+  const {
+    listRef,
+    activeIndex,
+    onMatch: unstable_onMatch,
+    onTypingChange: unstable_onTypingChange,
+    enabled = true,
+    findMatch = null,
+    resetMs = 750,
+    ignoreKeys = [],
+    selectedIndex = null
+  } = props;
+  const timeoutIdRef = React.useRef();
+  const stringRef = React.useRef("");
+  const prevIndexRef = React.useRef((_ref = selectedIndex != null ? selectedIndex : activeIndex) != null ? _ref : -1);
+  const matchIndexRef = React.useRef(null);
+  const onMatch = useEffectEvent(unstable_onMatch);
+  const onTypingChange = useEffectEvent(unstable_onTypingChange);
+  const findMatchRef = useLatestRef(findMatch);
+  const ignoreKeysRef = useLatestRef(ignoreKeys);
+  index(() => {
+    if (open) {
+      clearTimeout(timeoutIdRef.current);
+      matchIndexRef.current = null;
+      stringRef.current = "";
+    }
+  }, [open]);
+  index(() => {
+    if (open && stringRef.current === "") {
+      var _ref2;
+      prevIndexRef.current = (_ref2 = selectedIndex != null ? selectedIndex : activeIndex) != null ? _ref2 : -1;
+    }
+  }, [open, selectedIndex, activeIndex]);
+  const setTypingChange = useEffectEvent((value) => {
+    if (value) {
+      if (!dataRef.current.typing) {
+        dataRef.current.typing = value;
+        onTypingChange(value);
+      }
+    } else {
+      if (dataRef.current.typing) {
+        dataRef.current.typing = value;
+        onTypingChange(value);
+      }
+    }
+  });
+  const onKeyDown = useEffectEvent((event) => {
+    function getMatchingIndex(list, orderedList, string) {
+      const str = findMatchRef.current ? findMatchRef.current(orderedList, string) : orderedList.find((text) => (text == null ? void 0 : text.toLocaleLowerCase().indexOf(string.toLocaleLowerCase())) === 0);
+      return str ? list.indexOf(str) : -1;
+    }
+    const listContent = listRef.current;
+    if (stringRef.current.length > 0 && stringRef.current[0] !== " ") {
+      if (getMatchingIndex(listContent, listContent, stringRef.current) === -1) {
+        setTypingChange(false);
+      } else if (event.key === " ") {
+        stopEvent(event);
+      }
+    }
+    if (listContent == null || ignoreKeysRef.current.includes(event.key) || // Character key.
+    event.key.length !== 1 || // Modifier key.
+    event.ctrlKey || event.metaKey || event.altKey) {
+      return;
+    }
+    if (open && event.key !== " ") {
+      stopEvent(event);
+      setTypingChange(true);
+    }
+    const allowRapidSuccessionOfFirstLetter = listContent.every((text) => {
+      var _text$, _text$2;
+      return text ? ((_text$ = text[0]) == null ? void 0 : _text$.toLocaleLowerCase()) !== ((_text$2 = text[1]) == null ? void 0 : _text$2.toLocaleLowerCase()) : true;
+    });
+    if (allowRapidSuccessionOfFirstLetter && stringRef.current === event.key) {
+      stringRef.current = "";
+      prevIndexRef.current = matchIndexRef.current;
+    }
+    stringRef.current += event.key;
+    clearTimeout(timeoutIdRef.current);
+    timeoutIdRef.current = setTimeout(() => {
+      stringRef.current = "";
+      prevIndexRef.current = matchIndexRef.current;
+      setTypingChange(false);
+    }, resetMs);
+    const prevIndex = prevIndexRef.current;
+    const index2 = getMatchingIndex(listContent, [...listContent.slice((prevIndex || 0) + 1), ...listContent.slice(0, (prevIndex || 0) + 1)], stringRef.current);
+    if (index2 !== -1) {
+      onMatch(index2);
+      matchIndexRef.current = index2;
+    } else if (event.key !== " ") {
+      stringRef.current = "";
+      setTypingChange(false);
+    }
+  });
+  const reference = React.useMemo(() => ({
+    onKeyDown
+  }), [onKeyDown]);
+  const floating = React.useMemo(() => {
+    return {
+      onKeyDown,
+      onKeyUp(event) {
+        if (event.key === " ") {
+          setTypingChange(false);
+        }
+      }
+    };
+  }, [onKeyDown, setTypingChange]);
+  return React.useMemo(() => enabled ? {
+    reference,
+    floating
+  } : {}, [enabled, reference, floating]);
+}
+const SelectContext = React__default.createContext(
+  {}
+);
+const OverflowMenu = ({
+  children,
+  className,
+  button,
+  buttonIcon,
+  placement = "bottom-start",
+  "aria-label": ariaLabel = "åpne valgmeny",
+  ...rest
+}) => {
+  const [isOpen, setIsOpen] = useState(false);
+  const [activeIndex, setActiveIndex] = useState(null);
+  const listRef = useRef([]);
+  const labelsRef = useRef([]);
+  const { refs, floatingStyles, context, elements, update } = useFloating({
+    placement: standardisePlacement(
       // check for left is added for backwards compatibility
-      rest.position === 'left' ? 'bottom-end' : placement),
-      open: isOpen,
-      onOpenChange: setIsOpen,
-      middleware: [offset(space.extraSmall2), flip(), shift({
-        padding: space.extraSmall
-      })]
-    }),
-    refs = _useFloating.refs,
-    floatingStyles = _useFloating.floatingStyles,
-    context = _useFloating.context,
-    elements = _useFloating.elements,
-    update = _useFloating.update;
-  // Since we use CSS instead of conditional rendering when hiding dropdownlist
-  // we can't use the whileElementsMounted option and need to handle
-  // cleanup ourselves. See https://floating-ui.com/docs/autoupdate
-  useEffect(function () {
+      rest.position === "left" ? "bottom-end" : placement
+    ),
+    open: isOpen,
+    onOpenChange: setIsOpen,
+    middleware: [
+      offset(space.extraSmall2),
+      flip(),
+      shift({ padding: space.extraSmall })
+    ]
+  });
+  useEffect(() => {
     if (isOpen && elements.reference && elements.floating) {
-      var cleanup = autoUpdate(elements.reference, elements.floating, update);
+      const cleanup = autoUpdate(elements.reference, elements.floating, update);
       return cleanup;
     }
   }, [isOpen, elements, update]);
-  var listNav = useListNavigation(context, {
-    listRef: listRef,
-    activeIndex: activeIndex,
+  const listNav = useListNavigation(context, {
+    listRef,
+    activeIndex,
     onNavigate: setActiveIndex
   });
-  var typeahead = useTypeahead(context, {
+  const typeahead = useTypeahead(context, {
     listRef: labelsRef,
-    activeIndex: activeIndex,
-    onMatch: function onMatch(index) {
-      return isOpen && setActiveIndex(index);
-    }
+    activeIndex,
+    onMatch: (index2) => isOpen && setActiveIndex(index2)
   });
-  var role = useRole(context, {
-    role: 'menu'
-  });
-  var _useInteractions = useInteractions([listNav, typeahead, role]),
-    getReferenceProps = _useInteractions.getReferenceProps,
-    getFloatingProps = _useInteractions.getFloatingProps,
-    getItemProps = _useInteractions.getItemProps;
-  var closeMenuAndReturnFocus = function closeMenuAndReturnFocus() {
-    var _refs$reference$curre;
+  const role = useRole(context, { role: "menu" });
+  const { getReferenceProps, getFloatingProps, getItemProps } = useInteractions(
+    [listNav, typeahead, role]
+  );
+  const closeMenuAndReturnFocus = () => {
     setIsOpen(false);
-    // @ts-expect-error the reference element is actually focusable
-    (_refs$reference$curre = refs.reference.current) == null || _refs$reference$curre.focus == null || _refs$reference$curre.focus();
+    refs.reference.current?.focus?.();
   };
-  useOnClickOutside([refs.floating, refs.reference], function () {
-    return setIsOpen(false);
-  });
+  useOnClickOutside([refs.floating, refs.reference], () => setIsOpen(false));
   useOnEscape(refs.floating, closeMenuAndReturnFocus);
   useOnEscape(refs.reference, closeMenuAndReturnFocus);
-  var selectContext = React.useMemo(function () {
-    return {
-      activeIndex: activeIndex,
-      getItemProps: getItemProps,
-      closeMenuAndReturnFocus: closeMenuAndReturnFocus
-    };
-  }, [activeIndex, getItemProps, closeMenuAndReturnFocus]);
-  var _buttonIcon = buttonIcon != null ? buttonIcon : React.createElement(VerticalDotsIcon, null);
-  return React.createElement(React.Fragment, null, !button ? React.createElement(IconButton, _extends({
-    ref: refs.setReference
-  }, getReferenceProps({
-    onClick: function onClick() {
-      return setIsOpen(!isOpen);
-    },
-    className: className,
-    'aria-label': ariaLabel,
-    type: 'button'
-  }), rest), _buttonIcon) : cloneElement(button, _extends({
-    ref: refs.setReference
-  }, getReferenceProps({
-    onClick: function onClick() {
-      return setIsOpen(!isOpen);
-    },
-    className: className,
-    'aria-label': ariaLabel,
-    type: 'button'
-  }), rest)), React.createElement(SelectContext.Provider, {
-    value: selectContext
-  }, React.createElement("div", _extends({
-    ref: refs.setFloating,
-    style: _extends({}, floatingStyles, {
-      display: isOpen ? 'initial' : 'none'
-    })
-  }, getFloatingProps({
-    className: 'eds-overflow-menu__menu-list'
-  })), React.createElement(FloatingList, {
-    elementsRef: listRef,
-    labelsRef: labelsRef
-  }, children))));
-};
-var OverflowMenuItem = function OverflowMenuItem(_ref2) {
-  var children = _ref2.children,
-    className = _ref2.className,
-    _ref2$onSelect = _ref2.onSelect,
-    onSelect = _ref2$onSelect === void 0 ? function () {
-      return undefined;
-    } : _ref2$onSelect,
-    href = _ref2.href,
-    disabled = _ref2.disabled,
-    as = _ref2.as,
-    rest = _objectWithoutPropertiesLoose(_ref2, _excluded2$1);
-  var _useContext = useContext(SelectContext),
-    activeIndex = _useContext.activeIndex,
-    getItemProps = _useContext.getItemProps,
-    closeMenuAndReturnFocus = _useContext.closeMenuAndReturnFocus;
-  var _useListItem = useListItem({
-      label: !disabled ? getNodeText(children) : null
+  const selectContext = React__default.useMemo(
+    () => ({
+      activeIndex,
+      getItemProps,
+      closeMenuAndReturnFocus
     }),
-    listItemRef = _useListItem.ref,
-    index = _useListItem.index;
-  var isHighlighted = activeIndex === index;
-  var isLink = href !== undefined;
-  var Element = as != null ? as : isLink ? 'a' : 'button';
-  return React.createElement(Element, _extends({
-    ref: listItemRef,
-    className: classNames('eds-overflow-menu__item', {
-      'eds-overflow-menu__item--disabled': disabled,
-      'eds-overflow-menu__item--highlighted': isHighlighted
-    }, className),
-    role: "menuitem",
-    type: Element === 'button' ? 'button' : undefined,
-    "aria-disabled": disabled,
-    "aria-selected": isHighlighted
-  }, getItemProps({
-    onClick: isLink || disabled ? undefined : function () {
-      onSelect();
-      closeMenuAndReturnFocus();
-    },
-    href: disabled ? undefined : href,
-    tabIndex: isHighlighted ? 0 : -1
-  }), rest), children);
+    [activeIndex, getItemProps, closeMenuAndReturnFocus]
+  );
+  const _buttonIcon = buttonIcon ?? /* @__PURE__ */ jsx(VerticalDotsIcon, {});
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    !button ? /* @__PURE__ */ jsx(
+      IconButton,
+      {
+        ref: refs.setReference,
+        ...getReferenceProps({
+          onClick: () => setIsOpen(!isOpen),
+          className,
+          "aria-label": ariaLabel,
+          type: "button"
+        }),
+        ...rest,
+        children: _buttonIcon
+      }
+    ) : cloneElement(button, {
+      ref: refs.setReference,
+      ...getReferenceProps({
+        onClick: () => setIsOpen(!isOpen),
+        className,
+        "aria-label": ariaLabel,
+        type: "button"
+      }),
+      ...rest
+    }),
+    /* @__PURE__ */ jsx(SelectContext.Provider, { value: selectContext, children: /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref: refs.setFloating,
+        style: { ...floatingStyles, display: isOpen ? "initial" : "none" },
+        ...getFloatingProps({
+          className: "eds-overflow-menu__menu-list"
+        }),
+        children: /* @__PURE__ */ jsx(FloatingList, { elementsRef: listRef, labelsRef, children })
+      }
+    ) })
+  ] });
 };
-var OverflowMenuLink = function OverflowMenuLink(props) {
-  return React.createElement(OverflowMenuItem, _extends({}, props));
+const OverflowMenuItem = ({
+  children,
+  className,
+  onSelect = () => void 0,
+  href,
+  disabled,
+  as,
+  ...rest
+}) => {
+  const { activeIndex, getItemProps, closeMenuAndReturnFocus } = useContext(SelectContext);
+  const { ref: listItemRef, index: index2 } = useListItem({
+    label: !disabled ? getNodeText(children) : null
+  });
+  const isHighlighted = activeIndex === index2;
+  const isLink = href !== void 0;
+  const Element2 = as ?? (isLink ? "a" : "button");
+  return /* @__PURE__ */ jsx(
+    Element2,
+    {
+      ref: listItemRef,
+      className: classNames(
+        "eds-overflow-menu__item",
+        {
+          "eds-overflow-menu__item--disabled": disabled,
+          "eds-overflow-menu__item--highlighted": isHighlighted
+        },
+        className
+      ),
+      role: "menuitem",
+      type: Element2 === "button" ? "button" : void 0,
+      "aria-disabled": disabled,
+      "aria-selected": isHighlighted,
+      ...getItemProps({
+        onClick: isLink || disabled ? void 0 : () => {
+          onSelect();
+          closeMenuAndReturnFocus();
+        },
+        href: disabled ? void 0 : href,
+        tabIndex: isHighlighted ? 0 : -1
+      }),
+      ...rest,
+      children
+    }
+  );
+};
+const OverflowMenuLink = (props) => {
+  return /* @__PURE__ */ jsx(OverflowMenuItem, { ...props });
 };
-
-var PaginationPage = function PaginationPage(_ref) {
-  var children = _ref.children,
-    className = _ref.className,
-    selected = _ref.selected,
-    disabled = _ref.disabled,
-    onClick = _ref.onClick,
-    ariaLabel = _ref['aria-label'],
-    ariaDescribedby = _ref['aria-describedby'];
-  return React.createElement("button", {
-    className: classNames('eds-pagination__controls__page', {
-      'eds-pagination__controls__page--selected': selected
-    }, {
-      'eds-pagination__controls__page--disabled': disabled
-    }, className),
+const PaginationPage = ({
+  children,
+  className,
+  selected,
+  disabled,
+  onClick,
+  "aria-label": ariaLabel,
+  "aria-describedby": ariaDescribedby
+}) => /* @__PURE__ */ jsx(
+  "button",
+  {
+    className: classNames(
+      "eds-pagination__controls__page",
+      { "eds-pagination__controls__page--selected": selected },
+      { "eds-pagination__controls__page--disabled": disabled },
+      className
+    ),
     disabled: selected || disabled,
     type: "button",
-    onClick: onClick,
+    onClick,
     "aria-label": ariaLabel,
     "aria-describedby": ariaDescribedby,
-    "aria-current": selected ? 'page' : false
-  }, children);
-};
-
-var PaginationInput = function PaginationInput(_ref) {
-  var currentPage = _ref.currentPage,
-    pageCount = _ref.pageCount,
-    _ref$label = _ref.label,
-    label = _ref$label === void 0 ? 'Gå til side' : _ref$label,
-    onPageChange = _ref.onPageChange;
-  var _React$useState = React.useState(String(currentPage)),
-    input = _React$useState[0],
-    setInput = _React$useState[1];
-  // If the currentPage prop changes, we want to reset the input field
-  React.useEffect(function () {
+    "aria-current": selected ? "page" : false,
+    children
+  }
+);
+const PaginationInput = ({
+  currentPage,
+  pageCount,
+  label = "Gå til side",
+  onPageChange
+}) => {
+  const [input, setInput] = React__default.useState(String(currentPage));
+  React__default.useEffect(() => {
     setInput(String(currentPage));
   }, [currentPage]);
-  var handleSubmit = function handleSubmit(e) {
+  const handleSubmit = (e) => {
     e.preventDefault();
     e.stopPropagation();
-    var pageNumber = Number(input);
+    let pageNumber = Number(input);
     if (pageNumber === currentPage) {
       return;
     }
@@ -359,210 +3474,232 @@ var PaginationInput = function PaginationInput(_ref) {
     }
     onPageChange(pageNumber);
   };
-  var handleChange = function handleChange(e) {
+  const handleChange = (e) => {
     setInput(e.target.value);
   };
-  return React.createElement("form", {
-    onSubmit: handleSubmit,
-    noValidate: true,
-    "aria-label": "form"
-  }, React.createElement("label", {
-    className: "eds-pagination__controls__input__wrapper"
-  }, React.createElement("span", {
-    className: "eds-pagination__controls__input__label"
-  }, label), React.createElement("input", {
-    type: "number",
-    max: pageCount,
-    className: "eds-pagination__controls__input__field",
-    value: input,
-    onChange: handleChange
-  })));
+  return /* @__PURE__ */ jsx("form", { onSubmit: handleSubmit, noValidate: true, "aria-label": "form", children: /* @__PURE__ */ jsxs("label", { className: "eds-pagination__controls__input__wrapper", children: [
+    /* @__PURE__ */ jsx("span", { className: "eds-pagination__controls__input__label", children: label }),
+    /* @__PURE__ */ jsx(
+      "input",
+      {
+        type: "number",
+        max: pageCount,
+        className: "eds-pagination__controls__input__field",
+        value: input,
+        onChange: handleChange
+      }
+    )
+  ] }) });
 };
-
-var _excluded$5 = ["className", "currentPage", "inputLabel", "onPageChange", "pageCount", "pageLabel", "previousPageLabel", "currentPageLabelForScreenreader", "lastPageLabelForScreenreader", "showInput", "numberOfResults", "resultsPerPage", "resultsPerPageOptions", "onResultsPerPageChange", "showNumberOfResultsLabel", "nextPageLabel", "showingResultsLabel", "changeNumberOfResultsLabelForScreenreader", "hideNextButton", "hidePrevButton"];
-var Pagination = function Pagination(_ref) {
-  var className = _ref.className,
-    currentPage = _ref.currentPage,
-    inputLabel = _ref.inputLabel,
-    onPageChange = _ref.onPageChange,
-    pageCount = _ref.pageCount,
-    _ref$pageLabel = _ref.pageLabel,
-    pageLabel = _ref$pageLabel === void 0 ? function (pageNumber) {
-      return "G\xE5 til side " + pageNumber;
-    } : _ref$pageLabel,
-    _ref$previousPageLabe = _ref.previousPageLabel,
-    previousPageLabel = _ref$previousPageLabe === void 0 ? 'Gå til forrige side' : _ref$previousPageLabe,
-    _ref$currentPageLabel = _ref.currentPageLabelForScreenreader,
-    currentPageLabelForScreenreader = _ref$currentPageLabel === void 0 ? 'Nåværende side:' : _ref$currentPageLabel,
-    _ref$lastPageLabelFor = _ref.lastPageLabelForScreenreader,
-    lastPageLabelForScreenreader = _ref$lastPageLabelFor === void 0 ? ', siste side' : _ref$lastPageLabelFor,
-    showInput = _ref.showInput,
-    numberOfResults = _ref.numberOfResults,
-    resultsPerPage = _ref.resultsPerPage,
-    _ref$resultsPerPageOp = _ref.resultsPerPageOptions,
-    resultsPerPageOptions = _ref$resultsPerPageOp === void 0 ? [10, 25, 50] : _ref$resultsPerPageOp,
-    onResultsPerPageChange = _ref.onResultsPerPageChange,
-    _ref$showNumberOfResu = _ref.showNumberOfResultsLabel,
-    showNumberOfResultsLabel = _ref$showNumberOfResu === void 0 ? 'Vis' : _ref$showNumberOfResu,
-    _ref$nextPageLabel = _ref.nextPageLabel,
-    nextPageLabel = _ref$nextPageLabel === void 0 ? 'Gå til neste side' : _ref$nextPageLabel,
-    _ref$showingResultsLa = _ref.showingResultsLabel,
-    showingResultsLabel = _ref$showingResultsLa === void 0 ? function (minPage, maxPage, pageCount) {
-      return "Viser resultat " + minPage + "\u2013" + maxPage + " av " + pageCount;
-    } : _ref$showingResultsLa,
-    _ref$changeNumberOfRe = _ref.changeNumberOfResultsLabelForScreenreader,
-    changeNumberOfResultsLabelForScreenreader = _ref$changeNumberOfRe === void 0 ? "Viser " + resultsPerPage + " resultater. Trykk for \xE5 endre antall. \xC5pner en flervalgsmeny." : _ref$changeNumberOfRe,
-    _ref$hideNextButton = _ref.hideNextButton,
-    hideNextButton = _ref$hideNextButton === void 0 ? false : _ref$hideNextButton,
-    _ref$hidePrevButton = _ref.hidePrevButton,
-    hidePrevButton = _ref$hidePrevButton === void 0 ? false : _ref$hidePrevButton,
-    rest = _objectWithoutPropertiesLoose(_ref, _excluded$5);
-  var _useState = useState([]),
-    listedEntries = _useState[0],
-    setListedEntries = _useState[1];
-  var paginationId = useRandomId('eds-pagination');
-  var isFirstPostSelected = currentPage === 1;
-  var isLastPostSelected = currentPage === pageCount;
-  var noEllipsis = pageCount <= 7;
-  var onlyLeadingEllipsis = !noEllipsis && currentPage < 5;
-  var onlyTrailingEllipsis = !noEllipsis && pageCount - currentPage <= 3;
-  useEffect(function () {
+const Pagination = ({
+  className,
+  currentPage,
+  inputLabel,
+  onPageChange,
+  pageCount,
+  pageLabel = (pageNumber) => `Gå til side ${pageNumber}`,
+  previousPageLabel = "Gå til forrige side",
+  currentPageLabelForScreenreader = "Nåværende side:",
+  lastPageLabelForScreenreader = ", siste side",
+  showInput,
+  numberOfResults,
+  resultsPerPage,
+  resultsPerPageOptions = [10, 25, 50],
+  onResultsPerPageChange,
+  showNumberOfResultsLabel = "Vis",
+  nextPageLabel = "Gå til neste side",
+  showingResultsLabel = (minPage, maxPage, pageCount2) => `Viser resultat ${minPage}–${maxPage} av ${pageCount2}`,
+  changeNumberOfResultsLabelForScreenreader = `Viser ${resultsPerPage} resultater. Trykk for å endre antall. Åpner en flervalgsmeny.`,
+  hideNextButton = false,
+  hidePrevButton = false,
+  ...rest
+}) => {
+  const [listedEntries, setListedEntries] = useState([]);
+  const paginationId = useRandomId("eds-pagination");
+  const isFirstPostSelected = currentPage === 1;
+  const isLastPostSelected = currentPage === pageCount;
+  const noEllipsis = pageCount <= 7;
+  const onlyLeadingEllipsis = !noEllipsis && currentPage < 5;
+  const onlyTrailingEllipsis = !noEllipsis && pageCount - currentPage <= 3;
+  useEffect(() => {
     if (pageCount < 1) return;
     if (noEllipsis) {
-      setListedEntries(Array(pageCount).fill(null).map(function (_, i) {
-        return i + 1;
-      }));
+      setListedEntries(
+        Array(pageCount).fill(null).map((_, i) => i + 1)
+      );
     } else if (onlyLeadingEllipsis) {
-      setListedEntries([1, 2, 3, 4, 5, '…', pageCount]);
+      setListedEntries([1, 2, 3, 4, 5, "…", pageCount]);
     } else if (onlyTrailingEllipsis) {
-      setListedEntries([1, '…', pageCount - 4, pageCount - 3, pageCount - 2, pageCount - 1, pageCount]);
+      setListedEntries([
+        1,
+        "…",
+        pageCount - 4,
+        pageCount - 3,
+        pageCount - 2,
+        pageCount - 1,
+        pageCount
+      ]);
     } else {
-      // leading and trailing ellipsis
-      setListedEntries([1, '…', currentPage - 1, currentPage, currentPage + 1, '…', pageCount]);
+      setListedEntries([
+        1,
+        "…",
+        currentPage - 1,
+        currentPage,
+        currentPage + 1,
+        "…",
+        pageCount
+      ]);
     }
-  }, [noEllipsis, onlyLeadingEllipsis, onlyTrailingEllipsis, currentPage, pageCount]);
+  }, [
+    noEllipsis,
+    onlyLeadingEllipsis,
+    onlyTrailingEllipsis,
+    currentPage,
+    pageCount
+  ]);
   if (pageCount < 1) {
     return null;
   }
-  return React.createElement("nav", _extends({
-    className: classNames('eds-pagination', className),
-    "aria-label": "Paginering"
-  }, rest), resultsPerPage && numberOfResults && React.createElement("div", {
-    className: "eds-pagination__results"
-  }, onResultsPerPageChange && React.createElement(React.Fragment, null, React.createElement(Label, {
-    as: "p",
-    "aria-hidden": "true"
-  }, showNumberOfResultsLabel), React.createElement(OverflowMenu, {
-    className: "eds-pagination__results__change-number-of-results",
-    buttonIcon: React.createElement(React.Fragment, null, resultsPerPage, ' ', React.createElement(DownArrowIcon, {
-      className: "eds-pagination__results__change-number-of-results__arrow",
-      "aria-hidden": "true"
-    })),
-    "aria-label": changeNumberOfResultsLabelForScreenreader,
-    placement: "bottom-end"
-  }, resultsPerPageOptions.map(function (option, key) {
-    return React.createElement(OverflowMenuItem, {
-      key: key,
-      onSelect: function onSelect() {
-        return onResultsPerPageChange(option);
-      }
-    }, option);
-  }))), React.createElement(Label, {
-    as: "p"
-  }, showingResultsLabel((currentPage - 1) * resultsPerPage + 1, currentPage * resultsPerPage > numberOfResults ? numberOfResults : currentPage * resultsPerPage, numberOfResults))), React.createElement("div", {
-    className: "eds-pagination__controls"
-  }, !hidePrevButton && React.createElement(PaginationPage, {
-    onClick: function onClick() {
-      return onPageChange(currentPage - 1);
-    },
-    "aria-label": previousPageLabel,
-    "aria-describedby": paginationId,
-    disabled: isFirstPostSelected
-  }, React.createElement(LeftArrowIcon, {
-    "aria-hidden": "true"
-  })), listedEntries.map(function (entry, index) {
-    return entry === '…' ? React.createElement(Ellipsis, {
-      key: "ellipsis-" + index
-    }) : React.createElement(PaginationPage, {
-      selected: entry === currentPage,
-      onClick: function onClick() {
-        return onPageChange(entry);
-      },
-      "aria-label": "" + pageLabel(entry) + (entry === pageCount ? lastPageLabelForScreenreader : ''),
-      "aria-describedby": entry !== currentPage ? paginationId : undefined,
-      key: entry
-    }, entry);
-  }), !hideNextButton && React.createElement(PaginationPage, {
-    onClick: function onClick() {
-      return onPageChange(currentPage + 1);
-    },
-    "aria-label": nextPageLabel,
-    "aria-describedby": paginationId,
-    disabled: isLastPostSelected
-  }, React.createElement(RightArrowIcon, {
-    "aria-hidden": "true"
-  })), showInput && React.createElement(PaginationInput, {
-    pageCount: pageCount,
-    currentPage: currentPage,
-    onPageChange: onPageChange,
-    label: inputLabel
-  })), React.createElement(VisuallyHidden, {
-    id: paginationId
-  }, currentPageLabelForScreenreader, " ", currentPage));
-};
-var Ellipsis = function Ellipsis() {
-  return React.createElement("span", {
-    className: "eds-pagination__controls__page__ellipsis",
-    "aria-hidden": "true"
-  }, "\u2026");
+  return /* @__PURE__ */ jsxs(
+    "nav",
+    {
+      className: classNames("eds-pagination", className),
+      "aria-label": "Paginering",
+      ...rest,
+      children: [
+        resultsPerPage && numberOfResults && /* @__PURE__ */ jsxs("div", { className: "eds-pagination__results", children: [
+          onResultsPerPageChange && /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(Label, { as: "p", "aria-hidden": "true", children: showNumberOfResultsLabel }),
+            /* @__PURE__ */ jsx(
+              OverflowMenu,
+              {
+                className: "eds-pagination__results__change-number-of-results",
+                buttonIcon: /* @__PURE__ */ jsxs(Fragment, { children: [
+                  resultsPerPage,
+                  " ",
+                  /* @__PURE__ */ jsx(
+                    DownArrowIcon,
+                    {
+                      className: "eds-pagination__results__change-number-of-results__arrow",
+                      "aria-hidden": "true"
+                    }
+                  )
+                ] }),
+                "aria-label": changeNumberOfResultsLabelForScreenreader,
+                placement: "bottom-end",
+                children: resultsPerPageOptions.map((option, key) => /* @__PURE__ */ jsx(
+                  OverflowMenuItem,
+                  {
+                    onSelect: () => onResultsPerPageChange(option),
+                    children: option
+                  },
+                  key
+                ))
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx(Label, { as: "p", children: showingResultsLabel(
+            (currentPage - 1) * resultsPerPage + 1,
+            currentPage * resultsPerPage > numberOfResults ? numberOfResults : currentPage * resultsPerPage,
+            numberOfResults
+          ) })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "eds-pagination__controls", children: [
+          !hidePrevButton && /* @__PURE__ */ jsx(
+            PaginationPage,
+            {
+              onClick: () => onPageChange(currentPage - 1),
+              "aria-label": previousPageLabel,
+              "aria-describedby": paginationId,
+              disabled: isFirstPostSelected,
+              children: /* @__PURE__ */ jsx(LeftArrowIcon, { "aria-hidden": "true" })
+            }
+          ),
+          listedEntries.map(
+            (entry, index2) => entry === "…" ? /* @__PURE__ */ jsx(Ellipsis, {}, `ellipsis-${index2}`) : /* @__PURE__ */ jsx(
+              PaginationPage,
+              {
+                selected: entry === currentPage,
+                onClick: () => onPageChange(entry),
+                "aria-label": `${pageLabel(entry)}${entry === pageCount ? lastPageLabelForScreenreader : ""}`,
+                "aria-describedby": entry !== currentPage ? paginationId : void 0,
+                children: entry
+              },
+              entry
+            )
+          ),
+          !hideNextButton && /* @__PURE__ */ jsx(
+            PaginationPage,
+            {
+              onClick: () => onPageChange(currentPage + 1),
+              "aria-label": nextPageLabel,
+              "aria-describedby": paginationId,
+              disabled: isLastPostSelected,
+              children: /* @__PURE__ */ jsx(RightArrowIcon, { "aria-hidden": "true" })
+            }
+          ),
+          showInput && /* @__PURE__ */ jsx(
+            PaginationInput,
+            {
+              pageCount,
+              currentPage,
+              onPageChange,
+              label: inputLabel
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs(VisuallyHidden, { id: paginationId, children: [
+          currentPageLabelForScreenreader,
+          " ",
+          currentPage
+        ] })
+      ]
+    }
+  );
 };
-
-var _excluded$4 = ["className", "children", "size"];
-var SideNavigation = function SideNavigation(_ref) {
-  var className = _ref.className,
-    children = _ref.children,
-    _ref$size = _ref.size,
-    size = _ref$size === void 0 ? 'medium' : _ref$size,
-    rest = _objectWithoutPropertiesLoose(_ref, _excluded$4);
-  if (!children || !React.Children.count(children)) {
+const Ellipsis = () => /* @__PURE__ */ jsx("span", { className: "eds-pagination__controls__page__ellipsis", "aria-hidden": "true", children: "…" });
+const SideNavigation = ({
+  className,
+  children,
+  size = "medium",
+  ...rest
+}) => {
+  if (!children || !React__default.Children.count(children)) {
     return null;
   }
-  return React.createElement("ul", _extends({
-    className: classNames('eds-side-navigation', {
-      'eds-side-navigation--small': size === 'small'
-    }, className)
-  }, rest), children);
+  return /* @__PURE__ */ jsx(
+    "ul",
+    {
+      className: classNames(
+        "eds-side-navigation",
+        { "eds-side-navigation--small": size === "small" },
+        className
+      ),
+      ...rest,
+      children
+    }
+  );
 };
-/** This is required to check that the Menu */
 SideNavigation.__IS_ENTUR_MENU__ = true;
-
-var useShowDelayedLabel = function useShowDelayedLabel(isCollapsed) {
-  var _useState = useState(true),
-    showLabel = _useState[0],
-    setShowLabel = _useState[1];
-  var hideDelay = 50;
-  var showDelay = 200;
-  useEffect(function () {
+const useShowDelayedLabel = (isCollapsed) => {
+  const [showLabel, setShowLabel] = useState(true);
+  const hideDelay = 50;
+  const showDelay = 200;
+  useEffect(() => {
     if (isCollapsed) {
-      setTimeout(function () {
+      setTimeout(() => {
         setShowLabel(false);
       }, hideDelay);
     }
     if (!isCollapsed) {
-      setTimeout(function () {
+      setTimeout(() => {
         setShowLabel(true);
       }, showDelay);
     }
-    return function () {
-      return undefined;
-    };
+    return () => void 0;
   }, [isCollapsed]);
   return [showLabel];
 };
-
-var _excluded$3 = ["className", "active", "subMenu", "icon", "children", "as"],
-  _excluded2 = ["children"],
-  _excluded3 = ["active", "disabled", "children", "forceExpandSubMenus", "as"];
 function isActiveRecursively(child) {
   if (!child.props) {
     return false;
@@ -573,205 +3710,255 @@ function isActiveRecursively(child) {
   if (!child.props.children) {
     return false;
   }
-  return React.Children.toArray(child.props.children).some(function (child) {
-    return isActiveRecursively(child);
-  });
+  return React__default.Children.toArray(child.props.children).some(
+    (child2) => isActiveRecursively(child2)
+  );
 }
-var defaultElementBaseItem = 'a';
-var BaseSideNavigationItem = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
-  var className = _ref.className,
-    _ref$active = _ref.active,
-    active = _ref$active === void 0 ? false : _ref$active,
-    subMenu = _ref.subMenu,
-    icon = _ref.icon,
-    children = _ref.children,
-    as = _ref.as,
-    rest = _objectWithoutPropertiesLoose(_ref, _excluded$3);
-  var Element = as || defaultElementBaseItem;
-  var _useSideNavigationCon = useSideNavigationContext(),
-    isCollapsed = _useSideNavigationCon.isCollapsed;
-  var _useShowDelayedLabel = useShowDelayedLabel(isCollapsed),
-    showLabel = _useShowDelayedLabel[0];
-  return React.createElement("li", {
-    className: classNames('eds-side-navigation__item', className)
-  }, React.createElement(Element, _extends({
-    className: classNames('eds-side-navigation__click-target', {
-      'eds-side-navigation__click-target--active': active
-    }),
-    "aria-label": isCollapsed ? children : undefined,
-    "aria-current": active ? 'page' : undefined,
-    ref: ref
-  }, rest), icon, showLabel && children), subMenu);
-});
-var DisabledSideNavigationItem = /*#__PURE__*/React.forwardRef(function (_ref2, ref) {
-  var children = _ref2.children,
-    rest = _objectWithoutPropertiesLoose(_ref2, _excluded2);
-  return React.createElement(BaseSideNavigationItem, _extends({
+const defaultElementBaseItem = "a";
+const BaseSideNavigationItem = React__default.forwardRef(
+  ({
+    className,
+    active = false,
+    subMenu,
+    icon,
+    children,
+    as,
+    ...rest
+  }, ref) => {
+    const Element2 = as || defaultElementBaseItem;
+    const { isCollapsed } = useSideNavigationContext();
+    const [showLabel] = useShowDelayedLabel(isCollapsed);
+    return /* @__PURE__ */ jsxs("li", { className: classNames("eds-side-navigation__item", className), children: [
+      /* @__PURE__ */ jsxs(
+        Element2,
+        {
+          className: classNames("eds-side-navigation__click-target", {
+            "eds-side-navigation__click-target--active": active
+          }),
+          "aria-label": isCollapsed ? children : void 0,
+          "aria-current": active ? "page" : void 0,
+          ref,
+          ...rest,
+          children: [
+            icon,
+            showLabel && children
+          ]
+        }
+      ),
+      subMenu
+    ] });
+  }
+);
+const DisabledSideNavigationItem = React__default.forwardRef(({ children, ...rest }, ref) => /* @__PURE__ */ jsx(
+  BaseSideNavigationItem,
+  {
     as: "button",
     disabled: true,
     "aria-disabled": true,
-    ref: ref,
-    type: "button"
-  }, rest), children);
-});
-var defaultElementItem = 'a';
-var SideNavigationItem = /*#__PURE__*/React.forwardRef(function (_ref3, ref) {
-  var active = _ref3.active,
-    disabled = _ref3.disabled,
-    children = _ref3.children,
-    forceExpandSubMenus = _ref3.forceExpandSubMenus,
-    as = _ref3.as,
-    rest = _objectWithoutPropertiesLoose(_ref3, _excluded3);
-  var Element = as || defaultElementItem;
-  var childrenArray = React.Children.toArray(children);
-  var subMenu = childrenArray.find(function (child) {
-    return child && child.type && child.type.__IS_ENTUR_MENU__;
-  });
-  var label = subMenu ? childrenArray.filter(function (child) {
-    return child !== subMenu;
-  }) : children;
-  if (disabled) {
-    return React.createElement(DisabledSideNavigationItem, _extends({
-      ref: ref
-    }, rest), label);
-  }
-  if (!subMenu) {
-    return React.createElement(BaseSideNavigationItem, _extends({
-      as: Element,
-      active: active,
-      ref: ref
-    }, rest), label);
-  }
-  var isExpanded = forceExpandSubMenus || isActiveRecursively({
-    props: {
-      children: children,
-      active: active
+    ref,
+    type: "button",
+    ...rest,
+    children
+  }
+));
+const defaultElementItem = "a";
+const SideNavigationItem = React__default.forwardRef(
+  ({
+    active,
+    disabled,
+    children,
+    forceExpandSubMenus,
+    as,
+    ...rest
+  }, ref) => {
+    const Element2 = as || defaultElementItem;
+    const childrenArray = React__default.Children.toArray(children);
+    const subMenu = childrenArray.find(
+      (child) => child && child.type && child.type.__IS_ENTUR_MENU__
+    );
+    const label = subMenu ? childrenArray.filter((child) => child !== subMenu) : children;
+    if (disabled) {
+      return /* @__PURE__ */ jsx(DisabledSideNavigationItem, { ref, ...rest, children: label });
     }
+    if (!subMenu) {
+      return /* @__PURE__ */ jsx(
+        BaseSideNavigationItem,
+        {
+          as: Element2,
+          active,
+          ref,
+          ...rest,
+          children: label
+        }
+      );
+    }
+    const isExpanded = forceExpandSubMenus || isActiveRecursively({ props: { children, active } });
+    return /* @__PURE__ */ jsx(
+      BaseSideNavigationItem,
+      {
+        active,
+        subMenu: isExpanded && subMenu,
+        "aria-expanded": isExpanded,
+        as: Element2,
+        ref,
+        ...rest,
+        children: label
+      }
+    );
+  }
+);
+const SideNavigationGroup = ({
+  defaultOpen = false,
+  open,
+  onToggle,
+  className,
+  children,
+  title,
+  icon,
+  ...rest
+}) => {
+  const [isOpen, setOpen] = useControllableProp({
+    prop: open,
+    updater: onToggle,
+    defaultValue: defaultOpen
   });
-  return React.createElement(BaseSideNavigationItem, _extends({
-    active: active,
-    subMenu: isExpanded && subMenu,
-    "aria-expanded": isExpanded,
-    as: Element,
-    ref: ref
-  }, rest), label);
-});
-
-var _excluded$2 = ["defaultOpen", "open", "onToggle", "className", "children", "title", "icon"];
-var SideNavigationGroup = function SideNavigationGroup(_ref) {
-  var _ref$defaultOpen = _ref.defaultOpen,
-    defaultOpen = _ref$defaultOpen === void 0 ? false : _ref$defaultOpen,
-    open = _ref.open,
-    onToggle = _ref.onToggle,
-    className = _ref.className,
-    children = _ref.children,
-    title = _ref.title,
-    icon = _ref.icon,
-    rest = _objectWithoutPropertiesLoose(_ref, _excluded$2);
-  var _useControllableProp = useControllableProp({
-      prop: open,
-      updater: onToggle,
-      defaultValue: defaultOpen
-    }),
-    isOpen = _useControllableProp[0],
-    setOpen = _useControllableProp[1];
-  var _useSideNavigationCon = useSideNavigationContext(),
-    isCollapsed = _useSideNavigationCon.isCollapsed;
-  var _useShowDelayedLabel = useShowDelayedLabel(isCollapsed),
-    showLabel = _useShowDelayedLabel[0];
-  return React.createElement("div", _extends({
-    className: classNames('eds-side-navigation-group', className)
-  }, rest), React.createElement("button", {
-    onClick: function onClick() {
-      return setOpen(!isOpen);
-    },
-    type: "button",
-    className: "eds-side-navigation-group__trigger",
-    "aria-label": title + ", utvidbar meny, " + (isOpen ? 'åpen' : 'lukket')
-  }, React.createElement("span", null, icon && React.createElement("span", {
-    className: "eds-side-navigation-group__trigger-icon"
-  }, icon), showLabel && title), showLabel && React.createElement(ExpandArrow, {
-    open: isOpen,
-    className: "eds-side-navigation-group__expand-icon"
-  })), React.createElement(BaseExpand, {
-    className: "eds-side-navigation-group__expand-content",
-    open: isOpen
-  }, children));
+  const { isCollapsed } = useSideNavigationContext();
+  const [showLabel] = useShowDelayedLabel(isCollapsed);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: classNames("eds-side-navigation-group", className),
+      ...rest,
+      children: [
+        /* @__PURE__ */ jsxs(
+          "button",
+          {
+            onClick: () => setOpen(!isOpen),
+            type: "button",
+            className: "eds-side-navigation-group__trigger",
+            "aria-label": `${title}, utvidbar meny, ${isOpen ? "åpen" : "lukket"}`,
+            children: [
+              /* @__PURE__ */ jsxs("span", { children: [
+                icon && /* @__PURE__ */ jsx("span", { className: "eds-side-navigation-group__trigger-icon", children: icon }),
+                showLabel && title
+              ] }),
+              showLabel && /* @__PURE__ */ jsx(
+                ExpandArrow,
+                {
+                  open: isOpen,
+                  className: "eds-side-navigation-group__expand-icon"
+                }
+              )
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          BaseExpand,
+          {
+            className: "eds-side-navigation-group__expand-content",
+            open: isOpen,
+            children
+          }
+        )
+      ]
+    }
+  );
 };
-
-var _excluded$1 = ["activeIndex", "className", "interactive", "onStepClick", "showStepperIndex", "steps", "ariaLabelStep", "ariaLabelOf", "ariaLabelCompleted", "ariaLabelSummary"];
-var Stepper = function Stepper(_ref) {
-  var activeIndex = _ref.activeIndex,
-    className = _ref.className,
-    _ref$interactive = _ref.interactive,
-    interactive = _ref$interactive === void 0 ? false : _ref$interactive,
-    onStepClick = _ref.onStepClick,
-    _ref$showStepperIndex = _ref.showStepperIndex,
-    showStepperIndex = _ref$showStepperIndex === void 0 ? true : _ref$showStepperIndex,
-    steps = _ref.steps,
-    _ref$ariaLabelStep = _ref.ariaLabelStep,
-    ariaLabelStep = _ref$ariaLabelStep === void 0 ? 'Steg' : _ref$ariaLabelStep,
-    _ref$ariaLabelOf = _ref.ariaLabelOf,
-    ariaLabelOf = _ref$ariaLabelOf === void 0 ? 'av' : _ref$ariaLabelOf,
-    _ref$ariaLabelComplet = _ref.ariaLabelCompleted,
-    ariaLabelCompleted = _ref$ariaLabelComplet === void 0 ? 'fullført' : _ref$ariaLabelComplet,
-    _ref$ariaLabelSummary = _ref.ariaLabelSummary,
-    ariaLabelSummary = _ref$ariaLabelSummary === void 0 ? "Stegindikator med " + steps.length + " steg, du er p\xE5 steg " + (activeIndex + 1) + " " + steps[activeIndex] + "," : _ref$ariaLabelSummary,
-    rest = _objectWithoutPropertiesLoose(_ref, _excluded$1);
-  return React.createElement("ol", _extends({
-    className: classNames('eds-stepper', className),
-    "aria-label": ariaLabelSummary
-  }, rest), steps.map(function (step, i) {
-    var isCurrent = i === activeIndex;
-    var isInteractive = interactive && activeIndex > i;
-    var Element = isInteractive ? 'button' : 'div';
-    var isCompleted = activeIndex > i;
-    var currentStepSummary = ariaLabelStep + " " + (i + 1) + " " + ariaLabelOf + " " + steps.length + ", " + step + " " + (isCompleted ? ", " + ariaLabelCompleted : '');
-    var props = isInteractive ? {
-      onClick: function onClick() {
-        return onStepClick == null ? void 0 : onStepClick(i);
-      }
-    } : {};
-    return React.createElement("li", {
-      key: step,
-      className: "eds-stepper__step__wrapper"
-    }, React.createElement(Element, _extends({
-      className: classNames('eds-stepper__step', {
-        'eds-stepper__step--active': isCurrent
-      }, {
-        'eds-stepper__step--completed': isCompleted
-      }, {
-        'eds-stepper__step--interactive': isInteractive
-      }),
-      "aria-current": isCurrent ? 'step' : undefined,
-      type: Element === 'button' ? 'button' : undefined
-    }, props), React.createElement("div", {
-      className: "eds-stepper__step__line",
-      "aria-hidden": true
-    }), React.createElement("span", {
-      className: "eds-stepper__step__label",
-      "aria-hidden": true
-    }, showStepperIndex && i + 1 + '.', " ", step), React.createElement(VisuallyHidden, null, currentStepSummary)));
-  }));
+const Stepper = ({
+  activeIndex,
+  className,
+  interactive = false,
+  onStepClick,
+  showStepperIndex = true,
+  steps,
+  ariaLabelStep = "Steg",
+  ariaLabelOf = "av",
+  ariaLabelCompleted = "fullført",
+  ariaLabelSummary = `Stegindikator med ${steps.length} steg, du er på steg ${activeIndex + 1} ${steps[activeIndex]},`,
+  ...rest
+}) => {
+  return /* @__PURE__ */ jsx(
+    "ol",
+    {
+      className: classNames("eds-stepper", className),
+      "aria-label": ariaLabelSummary,
+      ...rest,
+      children: steps.map((step, i) => {
+        const isCurrent = i === activeIndex;
+        const isInteractive = interactive && activeIndex > i;
+        const Element2 = isInteractive ? "button" : "div";
+        const isCompleted = activeIndex > i;
+        const currentStepSummary = `${ariaLabelStep} ${i + 1} ${ariaLabelOf} ${steps.length}, ${step} ${isCompleted ? `, ${ariaLabelCompleted}` : ""}`;
+        const props = isInteractive ? { onClick: () => onStepClick?.(i) } : {};
+        return /* @__PURE__ */ jsx("li", { className: "eds-stepper__step__wrapper", children: /* @__PURE__ */ jsxs(
+          Element2,
+          {
+            className: classNames(
+              "eds-stepper__step",
+              { "eds-stepper__step--active": isCurrent },
+              { "eds-stepper__step--completed": isCompleted },
+              { "eds-stepper__step--interactive": isInteractive }
+            ),
+            "aria-current": isCurrent ? "step" : void 0,
+            type: Element2 === "button" ? "button" : void 0,
+            ...props,
+            children: [
+              /* @__PURE__ */ jsx("div", { className: "eds-stepper__step__line", "aria-hidden": true }),
+              /* @__PURE__ */ jsxs("span", { className: "eds-stepper__step__label", "aria-hidden": true, children: [
+                showStepperIndex && i + 1 + ".",
+                " ",
+                step
+              ] }),
+              /* @__PURE__ */ jsx(VisuallyHidden, { children: currentStepSummary })
+            ]
+          }
+        ) }, step);
+      })
+    }
+  );
+};
+const defaultElement = "a";
+const TopNavigationItem = ({
+  active = false,
+  className,
+  as,
+  ...rest
+}) => {
+  const Element2 = as || defaultElement;
+  return /* @__PURE__ */ jsx(
+    Element2,
+    {
+      className: classNames([
+        "eds-top-navigation-item",
+        className,
+        { "eds-top-navigation-item--active": active }
+      ]),
+      ...rest
+    }
+  );
 };
-
-var _excluded = ["active", "className", "as"];
-var defaultElement = 'a';
-var TopNavigationItem = function TopNavigationItem(_ref) {
-  var _ref$active = _ref.active,
-    active = _ref$active === void 0 ? false : _ref$active,
-    className = _ref.className,
-    as = _ref.as,
-    rest = _objectWithoutPropertiesLoose(_ref, _excluded);
-  var Element = as || defaultElement;
-  return React.createElement(Element, _extends({
-    className: classNames(['eds-top-navigation-item', className, {
-      'eds-top-navigation-item--active': active
-    }])
-  }, rest));
+warnAboutMissingStyles(
+  "menu",
+  "expand",
+  "icons",
+  "typography",
+  "button",
+  "layout",
+  "a11y"
+);
+export {
+  BreadcrumbItem,
+  BreadcrumbNavigation,
+  CollapsibleSideNavigation,
+  OverflowMenu,
+  OverflowMenuItem,
+  OverflowMenuLink,
+  Pagination,
+  SideNavigation,
+  SideNavigationGroup,
+  SideNavigationItem,
+  Stepper,
+  TopNavigationItem,
+  useSideNavigationContext
 };
-
-warnAboutMissingStyles('menu', 'expand', 'icons', 'typography', 'button', 'layout', 'a11y');
-
-export { BreadcrumbItem, BreadcrumbNavigation, CollapsibleSideNavigation, OverflowMenu, OverflowMenuItem, OverflowMenuLink, Pagination, SideNavigation, SideNavigationGroup, SideNavigationItem, Stepper, TopNavigationItem, useSideNavigationContext };
 //# sourceMappingURL=menu.esm.js.map