likec4 1.51.0 → 1.52.0

package/react/index.mjs

@@ -1226,12 +1226,12 @@ function* selection_iterator() {
     for (var group = groups[j2], i2 = 0, n2 = group.length, node2; i2 < n2; ++i2)
       (node2 = group[i2]) && (yield node2);
 }
-var root = [null];
+var root$1 = [null];
 function Selection$1(groups, parents) {
   this._groups = groups, this._parents = parents;
 }
 function selection() {
-  return new Selection$1([[document.documentElement]], root);
+  return new Selection$1([[document.documentElement]], root$1);
 }
 function selection_selection() {
   return this;
@@ -1275,7 +1275,7 @@ Selection$1.prototype = selection.prototype = {
   [Symbol.iterator]: selection_iterator
 };
 function select$2(selector3) {
-  return typeof selector3 == "string" ? new Selection$1([[document.querySelector(selector3)]], [document.documentElement]) : new Selection$1([[selector3]], root);
+  return typeof selector3 == "string" ? new Selection$1([[document.querySelector(selector3)]], [document.documentElement]) : new Selection$1([[selector3]], root$1);
 }
 function sourceEvent(event) {
   let sourceEvent2;
@@ -3162,7 +3162,7 @@ function getPointerPosition(event, { snapGrid = [0, 0], snapToGrid = !1, transfo
     ...pointerPos
   };
 }
-const getDimensions$1 = (node2) => ({
+const getDimensions$2 = (node2) => ({
   width: node2.offsetWidth,
   height: node2.offsetHeight
 }), getHostForElement = (element) => element?.getRootNode?.() || window?.document, inputTags = ["INPUT", "SELECT", "TEXTAREA"];
@@ -3187,7 +3187,7 @@ const isMouseEvent = (event) => "clientX" in event, getEventPosition = (event, b
       position: handle.getAttribute("data-handlepos"),
       x: (handleBounds.left - nodeBounds.left) / zoom2,
       y: (handleBounds.top - nodeBounds.top) / zoom2,
-      ...getDimensions$1(handle)
+      ...getDimensions$2(handle)
     };
   });
 };
@@ -3634,7 +3634,7 @@ function updateNodeInternals(updates, nodeLookup, parentLookup, domNode, nodeOri
       }), updatedInternals = !0;
       continue;
     }
-    const dimensions = getDimensions$1(update.nodeElement), dimensionChanged = node2.measured.width !== dimensions.width || node2.measured.height !== dimensions.height;
+    const dimensions = getDimensions$2(update.nodeElement), dimensionChanged = node2.measured.width !== dimensions.width || node2.measured.height !== dimensions.height;
     if (!!(dimensions.width && dimensions.height && (dimensionChanged || !node2.internals.handleBounds || update.force))) {
       const nodeBounds = update.nodeElement.getBoundingClientRect(), extent = isCoordinateExtent(node2.extent) ? node2.extent : nodeExtent;
       let { positionAbsolute } = node2.internals;
@@ -5069,7 +5069,7 @@ function elementToRemoveChange(item) {
     type: "remove"
   };
 }
-const isNode$1 = (element) => isNodeBase(element), isEdge = (element) => isEdgeBase(element);
+const isNode$2 = (element) => isNodeBase(element), isEdge = (element) => isEdgeBase(element);
 function fixedForwardRef(render) {
   return forwardRef(render);
 }
@@ -5136,7 +5136,7 @@ function useReactFlow() {
     }, setEdges = (payload) => {
       batchContext.edgeQueue.push(payload);
     }, getNodeRect = (node2) => {
-      const { nodeLookup, nodeOrigin } = store.getState(), nodeToUse = isNode$1(node2) ? node2 : nodeLookup.get(node2.id), position = nodeToUse.parentId ? evaluateAbsolutePosition(nodeToUse.position, nodeToUse.measured, nodeToUse.parentId, nodeLookup, nodeOrigin) : nodeToUse.position, nodeWithPosition = {
+      const { nodeLookup, nodeOrigin } = store.getState(), nodeToUse = isNode$2(node2) ? node2 : nodeLookup.get(node2.id), position = nodeToUse.parentId ? evaluateAbsolutePosition(nodeToUse.position, nodeToUse.measured, nodeToUse.parentId, nodeLookup, nodeOrigin) : nodeToUse.position, nodeWithPosition = {
         ...nodeToUse,
         position,
         width: nodeToUse.measured?.width ?? nodeToUse.width,
@@ -5147,7 +5147,7 @@ function useReactFlow() {
       setNodes((prevNodes) => prevNodes.map((node2) => {
         if (node2.id === id2) {
           const nextNode = typeof nodeUpdate == "function" ? nodeUpdate(node2) : nodeUpdate;
-          return options.replace && isNode$1(nextNode) ? nextNode : { ...node2, ...nextNode };
+          return options.replace && isNode$2(nextNode) ? nextNode : { ...node2, ...nextNode };
         }
         return node2;
       }));
@@ -5281,7 +5281,7 @@ function useResizeHandler(domNode) {
     const updateDimensions = () => {
       if (!domNode.current || !(domNode.current.checkVisibility?.() ?? !0))
         return !1;
-      const size2 = getDimensions$1(domNode.current);
+      const size2 = getDimensions$2(domNode.current);
       (size2.height === 0 || size2.width === 0) && store.getState().onError?.("004", errorMessages.error004()), store.setState({ width: size2.width || 500, height: size2.height || 500 });
     };
     if (domNode.current) {
@@ -5318,7 +5318,7 @@ function ZoomPane({ onPaneContextMenu, zoomOnScroll = !0, zoomOnPinch = !0, panO
         maxZoom,
         translateExtent,
         viewport: defaultViewport2,
-        onDraggingChange: (paneDragging) => store.setState({ paneDragging }),
+        onDraggingChange: (paneDragging) => store.setState((prevState) => prevState.paneDragging === paneDragging ? prevState : { paneDragging }),
         onPanZoomStart: (event, vp) => {
           const { onViewportChangeStart, onMoveStart } = store.getState();
           onMoveStart?.(event, vp), onViewportChangeStart?.(vp);
@@ -5518,10 +5518,8 @@ function useDrag({ nodeRef: nodeRef2, disabled = !1, noDragClassName, handleSele
       }
     });
   }, []), useEffect(() => {
-    if (disabled)
-      xyDrag.current?.destroy();
-    else if (nodeRef2.current)
-      return xyDrag.current?.update({
+    if (!(disabled || !nodeRef2.current || !xyDrag.current))
+      return xyDrag.current.update({
         noDragClassName,
         handleSelector,
         domNode: nodeRef2.current,
@@ -5531,7 +5529,7 @@ function useDrag({ nodeRef: nodeRef2, disabled = !1, noDragClassName, handleSele
       }), () => {
         xyDrag.current?.destroy();
       };
-  }, [noDragClassName, handleSelector, disabled, isSelectable, nodeRef2, nodeId]), dragging;
+  }, [noDragClassName, handleSelector, disabled, isSelectable, nodeRef2, nodeId, nodeClickDistance]), dragging;
 }
 const selectedAndDraggable = (nodesDraggable) => (n2) => n2.selected && (n2.draggable || nodesDraggable && typeof n2.draggable > "u");
 function useMoveSelectedNodes() {
@@ -5611,10 +5609,10 @@ function HandleComponent({ type = "source", position = Position.Top, isValidConn
         panBy: currentStore.panBy,
         cancelConnection: currentStore.cancelConnection,
         onConnectStart: currentStore.onConnectStart,
-        onConnectEnd: currentStore.onConnectEnd,
+        onConnectEnd: (...args) => store.getState().onConnectEnd?.(...args),
         updateConnection: currentStore.updateConnection,
         onConnect: onConnectExtended,
-        isValidConnection: isValidConnection || currentStore.isValidConnection,
+        isValidConnection: isValidConnection || ((...args) => store.getState().isValidConnection?.(...args) ?? !0),
         getTransform: () => store.getState().transform,
         getFromHandle: () => store.getState().connection.fromHandle,
         autoPanSpeed: currentStore.autoPanSpeed,
@@ -5720,13 +5718,16 @@ const selector$f = (s2) => {
 };
 function NodesSelection({ onSelectionContextMenu, noPanClassName, disableKeyboardA11y }) {
   const store = useStoreApi(), { width, height, transformString, userSelectionActive } = useStore$1(selector$f, shallow$1), moveSelectedNodes = useMoveSelectedNodes(), nodeRef2 = useRef(null);
-  if (useEffect(() => {
+  useEffect(() => {
     disableKeyboardA11y || nodeRef2.current?.focus({
       preventScroll: !0
     });
-  }, [disableKeyboardA11y]), useDrag({
-    nodeRef: nodeRef2
-  }), userSelectionActive || !width || !height)
+  }, [disableKeyboardA11y]);
+  const shouldRender = !userSelectionActive && width !== null && height !== null;
+  if (useDrag({
+    nodeRef: nodeRef2,
+    disabled: !shouldRender
+  }), !shouldRender)
     return null;
   const onContextMenu = onSelectionContextMenu ? (event) => {
     const selectedNodes = store.getState().nodes.filter((n2) => n2.selected);
@@ -6110,7 +6111,7 @@ function EdgeUpdateAnchors({ isReconnectable, reconnectRadius, edge, sourceX, so
   const store = useStoreApi(), handleEdgeUpdater = (event, oppositeHandle) => {
     if (event.button !== 0)
       return;
-    const { autoPanOnConnect, domNode, isValidConnection, connectionMode, connectionRadius, lib: lib2, onConnectStart, onConnectEnd, cancelConnection, nodeLookup, rfId: flowId, panBy: panBy2, updateConnection } = store.getState(), isTarget = oppositeHandle.type === "target", _onReconnectEnd = (evt, connectionState) => {
+    const { autoPanOnConnect, domNode, connectionMode, connectionRadius, lib: lib2, onConnectStart, cancelConnection, nodeLookup, rfId: flowId, panBy: panBy2, updateConnection } = store.getState(), isTarget = oppositeHandle.type === "target", _onReconnectEnd = (evt, connectionState) => {
       setReconnecting(!1), onReconnectEnd?.(evt, edge, oppositeHandle.type, connectionState);
     }, onConnectEdge = (connection) => onReconnect?.(edge, connection), _onConnectStart = (_event, params) => {
       setReconnecting(!0), onReconnectStart?.(event, edge, oppositeHandle.type), onConnectStart?.(_event, params);
@@ -6129,10 +6130,10 @@ function EdgeUpdateAnchors({ isReconnectable, reconnectRadius, edge, sourceX, so
       flowId,
       cancelConnection,
       panBy: panBy2,
-      isValidConnection,
+      isValidConnection: (...args) => store.getState().isValidConnection?.(...args) ?? !0,
       onConnect: onConnectEdge,
       onConnectStart: _onConnectStart,
-      onConnectEnd,
+      onConnectEnd: (...args) => store.getState().onConnectEnd?.(...args),
       onReconnectEnd: _onReconnectEnd,
       updateConnection,
       getTransform: () => store.getState().transform,
@@ -6530,10 +6531,16 @@ const GraphView = memo$2(GraphViewComponent), getInitialState = ({ nodes, edges,
       triggerEdgeChanges(getSelectionChanges(edgeLookup, /* @__PURE__ */ new Set([...selectedEdgeIds]))), triggerNodeChanges(getSelectionChanges(nodeLookup, /* @__PURE__ */ new Set(), !0));
     },
     unselectNodesAndEdges: ({ nodes: nodes2, edges: edges2 } = {}) => {
-      const { edges: storeEdges, nodes: storeNodes, nodeLookup, triggerNodeChanges, triggerEdgeChanges } = get2(), nodesToUnselect = nodes2 || storeNodes, edgesToUnselect = edges2 || storeEdges, nodeChanges = nodesToUnselect.map((n2) => {
-        const internalNode = nodeLookup.get(n2.id);
-        return internalNode && (internalNode.selected = !1), createSelectionChange(n2.id, !1);
-      }), edgeChanges = edgesToUnselect.map((edge) => createSelectionChange(edge.id, !1));
+      const { edges: storeEdges, nodes: storeNodes, nodeLookup, triggerNodeChanges, triggerEdgeChanges } = get2(), nodesToUnselect = nodes2 || storeNodes, edgesToUnselect = edges2 || storeEdges, nodeChanges = [];
+      for (const node2 of nodesToUnselect) {
+        if (!node2.selected)
+          continue;
+        const internalNode = nodeLookup.get(node2.id);
+        internalNode && (internalNode.selected = !1), nodeChanges.push(createSelectionChange(node2.id, !1));
+      }
+      const edgeChanges = [];
+      for (const edge of edgesToUnselect)
+        edge.selected && edgeChanges.push(createSelectionChange(edge.id, !1));
       triggerNodeChanges(nodeChanges), triggerEdgeChanges(edgeChanges);
     },
     setMinZoom: (minZoom2) => {
@@ -6756,9 +6763,12 @@ function MiniMapNodes({
 }
 function NodeComponentWrapperInner({ id: id2, nodeColorFunc, nodeStrokeColorFunc, nodeClassNameFunc, nodeBorderRadius, nodeStrokeWidth, shapeRendering, NodeComponent, onClick }) {
   const { node: node2, x: x2, y: y2, width, height } = useStore$1((s2) => {
-    const { internals } = s2.nodeLookup.get(id2), node22 = internals.userNode, { x: x22, y: y22 } = internals.positionAbsolute, { width: width2, height: height2 } = getNodeDimensions(node22);
+    const node22 = s2.nodeLookup.get(id2);
+    if (!node22)
+      return { node: void 0, x: 0, y: 0, width: 0, height: 0 };
+    const userNode = node22.internals.userNode, { x: x22, y: y22 } = node22.internals.positionAbsolute, { width: width2, height: height2 } = getNodeDimensions(userNode);
     return {
-      node: node22,
+      node: userNode,
       x: x22,
       y: y22,
       width: width2,
@@ -8301,7 +8311,7 @@ function isNumberLike(value) {
   }
   return !1;
 }
-function isElement$1(value) {
+function isElement$2(value) {
   return Array.isArray(value) || value === null ? !1 : typeof value == "object" ? value.type !== Fragment$1 : !1;
 }
 function createSafeContext$1(errorMessage) {
@@ -9222,7 +9232,7 @@ function getRootElement(targetElement) {
 }
 function getSingleElementChild(children2) {
   const _children = Children.toArray(children2);
-  return _children.length !== 1 || !isElement$1(_children[0]) ? null : _children[0];
+  return _children.length !== 1 || !isElement$2(_children[0]) ? null : _children[0];
 }
 function r(e2) {
   var t2, f2, n2 = "";
@@ -11174,48 +11184,48 @@ const defaultProps$L = {
   );
 });
 Collapse.displayName = "@mantine/core/Collapse";
-function hasWindow() {
+function hasWindow$1() {
   return typeof window < "u";
 }
-function getNodeName(node2) {
-  return isNode(node2) ? (node2.nodeName || "").toLowerCase() : "#document";
+function getNodeName$1(node2) {
+  return isNode$1(node2) ? (node2.nodeName || "").toLowerCase() : "#document";
 }
-function getWindow(node2) {
+function getWindow$1(node2) {
   var _node$ownerDocument;
   return (node2 == null || (_node$ownerDocument = node2.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
 }
-function getDocumentElement(node2) {
+function getDocumentElement$1(node2) {
   var _ref;
-  return (_ref = (isNode(node2) ? node2.ownerDocument : node2.document) || window.document) == null ? void 0 : _ref.documentElement;
+  return (_ref = (isNode$1(node2) ? node2.ownerDocument : node2.document) || window.document) == null ? void 0 : _ref.documentElement;
 }
-function isNode(value) {
-  return hasWindow() ? value instanceof Node || value instanceof getWindow(value).Node : !1;
+function isNode$1(value) {
+  return hasWindow$1() ? value instanceof Node || value instanceof getWindow$1(value).Node : !1;
 }
-function isElement(value) {
-  return hasWindow() ? value instanceof Element || value instanceof getWindow(value).Element : !1;
+function isElement$1(value) {
+  return hasWindow$1() ? value instanceof Element || value instanceof getWindow$1(value).Element : !1;
 }
-function isHTMLElement$1(value) {
-  return hasWindow() ? value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement : !1;
+function isHTMLElement$2(value) {
+  return hasWindow$1() ? value instanceof HTMLElement || value instanceof getWindow$1(value).HTMLElement : !1;
 }
-function isShadowRoot(value) {
-  return !hasWindow() || typeof ShadowRoot > "u" ? !1 : value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
+function isShadowRoot$1(value) {
+  return !hasWindow$1() || typeof ShadowRoot > "u" ? !1 : value instanceof ShadowRoot || value instanceof getWindow$1(value).ShadowRoot;
 }
 const invalidOverflowDisplayValues = /* @__PURE__ */ new Set(["inline", "contents"]);
-function isOverflowElement(element) {
+function isOverflowElement$1(element) {
   const {
     overflow,
     overflowX,
     overflowY,
     display
-  } = getComputedStyle$2(element);
+  } = getComputedStyle$3(element);
   return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !invalidOverflowDisplayValues.has(display);
 }
 const tableElements = /* @__PURE__ */ new Set(["table", "td", "th"]);
-function isTableElement(element) {
-  return tableElements.has(getNodeName(element));
+function isTableElement$1(element) {
+  return tableElements.has(getNodeName$1(element));
 }
 const topLayerSelectors = [":popover-open", ":modal"];
-function isTopLayer(element) {
+function isTopLayer$1(element) {
   return topLayerSelectors.some((selector3) => {
     try {
       return element.matches(selector3);
@@ -11225,33 +11235,33 @@ function isTopLayer(element) {
   });
 }
 const transformProperties = ["transform", "translate", "scale", "rotate", "perspective"], willChangeValues = ["transform", "translate", "scale", "rotate", "perspective", "filter"], containValues = ["paint", "layout", "strict", "content"];
-function isContainingBlock(elementOrCss) {
-  const webkit = isWebKit(), css2 = isElement(elementOrCss) ? getComputedStyle$2(elementOrCss) : elementOrCss;
+function isContainingBlock$1(elementOrCss) {
+  const webkit = isWebKit$1(), css2 = isElement$1(elementOrCss) ? getComputedStyle$3(elementOrCss) : elementOrCss;
   return transformProperties.some((value) => css2[value] ? css2[value] !== "none" : !1) || (css2.containerType ? css2.containerType !== "normal" : !1) || !webkit && (css2.backdropFilter ? css2.backdropFilter !== "none" : !1) || !webkit && (css2.filter ? css2.filter !== "none" : !1) || willChangeValues.some((value) => (css2.willChange || "").includes(value)) || containValues.some((value) => (css2.contain || "").includes(value));
 }
-function getContainingBlock(element) {
-  let currentNode = getParentNode(element);
-  for (; isHTMLElement$1(currentNode) && !isLastTraversableNode(currentNode); ) {
-    if (isContainingBlock(currentNode))
+function getContainingBlock$1(element) {
+  let currentNode = getParentNode$1(element);
+  for (; isHTMLElement$2(currentNode) && !isLastTraversableNode$1(currentNode); ) {
+    if (isContainingBlock$1(currentNode))
       return currentNode;
-    if (isTopLayer(currentNode))
+    if (isTopLayer$1(currentNode))
       return null;
-    currentNode = getParentNode(currentNode);
+    currentNode = getParentNode$1(currentNode);
   }
   return null;
 }
-function isWebKit() {
+function isWebKit$1() {
   return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
 }
 const lastTraversableNodeNames = /* @__PURE__ */ new Set(["html", "body", "#document"]);
-function isLastTraversableNode(node2) {
-  return lastTraversableNodeNames.has(getNodeName(node2));
+function isLastTraversableNode$1(node2) {
+  return lastTraversableNodeNames.has(getNodeName$1(node2));
 }
-function getComputedStyle$2(element) {
-  return getWindow(element).getComputedStyle(element);
+function getComputedStyle$3(element) {
+  return getWindow$1(element).getComputedStyle(element);
 }
-function getNodeScroll(element) {
-  return isElement(element) ? {
+function getNodeScroll$1(element) {
+  return isElement$1(element) ? {
     scrollLeft: element.scrollLeft,
     scrollTop: element.scrollTop
   } : {
@@ -11259,39 +11269,39 @@ function getNodeScroll(element) {
     scrollTop: element.scrollY
   };
 }
-function getParentNode(node2) {
-  if (getNodeName(node2) === "html")
+function getParentNode$1(node2) {
+  if (getNodeName$1(node2) === "html")
     return node2;
   const result = (
     // Step into the shadow DOM of the parent of a slotted node.
     node2.assignedSlot || // DOM Element detected.
     node2.parentNode || // ShadowRoot detected.
-    isShadowRoot(node2) && node2.host || // Fallback.
-    getDocumentElement(node2)
+    isShadowRoot$1(node2) && node2.host || // Fallback.
+    getDocumentElement$1(node2)
   );
-  return isShadowRoot(result) ? result.host : result;
+  return isShadowRoot$1(result) ? result.host : result;
 }
-function getNearestOverflowAncestor(node2) {
-  const parentNode = getParentNode(node2);
-  return isLastTraversableNode(parentNode) ? node2.ownerDocument ? node2.ownerDocument.body : node2.body : isHTMLElement$1(parentNode) && isOverflowElement(parentNode) ? parentNode : getNearestOverflowAncestor(parentNode);
+function getNearestOverflowAncestor$1(node2) {
+  const parentNode = getParentNode$1(node2);
+  return isLastTraversableNode$1(parentNode) ? node2.ownerDocument ? node2.ownerDocument.body : node2.body : isHTMLElement$2(parentNode) && isOverflowElement$1(parentNode) ? parentNode : getNearestOverflowAncestor$1(parentNode);
 }
-function getOverflowAncestors(node2, list2, traverseIframes) {
+function getOverflowAncestors$1(node2, list2, traverseIframes) {
   var _node$ownerDocument2;
   list2 === void 0 && (list2 = []), traverseIframes === void 0 && (traverseIframes = !0);
-  const scrollableAncestor = getNearestOverflowAncestor(node2), isBody = scrollableAncestor === ((_node$ownerDocument2 = node2.ownerDocument) == null ? void 0 : _node$ownerDocument2.body), win2 = getWindow(scrollableAncestor);
+  const scrollableAncestor = getNearestOverflowAncestor$1(node2), isBody = scrollableAncestor === ((_node$ownerDocument2 = node2.ownerDocument) == null ? void 0 : _node$ownerDocument2.body), win2 = getWindow$1(scrollableAncestor);
   if (isBody) {
-    const frameElement = getFrameElement(win2);
-    return list2.concat(win2, win2.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
+    const frameElement = getFrameElement$1(win2);
+    return list2.concat(win2, win2.visualViewport || [], isOverflowElement$1(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors$1(frameElement) : []);
   }
-  return list2.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
+  return list2.concat(scrollableAncestor, getOverflowAncestors$1(scrollableAncestor, [], traverseIframes));
 }
-function getFrameElement(win2) {
+function getFrameElement$1(win2) {
   return win2.parent && Object.getPrototypeOf(win2.parent) ? win2.frameElement : null;
 }
-const sides = ["top", "right", "bottom", "left"], alignments = ["start", "end"], placements = /* @__PURE__ */ sides.reduce((acc, side) => acc.concat(side, side + "-" + alignments[0], side + "-" + alignments[1]), []), min$1 = Math.min, max$1 = Math.max, round = Math.round, floor = Math.floor, createCoords = (v2) => ({
+const sides$1 = ["top", "right", "bottom", "left"], min$2 = Math.min, max$2 = Math.max, round$1 = Math.round, floor$1 = Math.floor, createCoords$1 = (v2) => ({
   x: v2,
   y: v2
-}), oppositeSideMap = {
+}), oppositeSideMap$1 = {
   left: "right",
   right: "left",
   bottom: "top",
@@ -11301,41 +11311,41 @@ const sides = ["top", "right", "bottom", "left"], alignments = ["start", "end"],
   end: "start"
 };
 function clamp$2(start2, value, end) {
-  return max$1(start2, min$1(value, end));
+  return max$2(start2, min$2(value, end));
 }
-function evaluate(value, param) {
+function evaluate$1(value, param) {
   return typeof value == "function" ? value(param) : value;
 }
-function getSide(placement) {
+function getSide$1(placement) {
   return placement.split("-")[0];
 }
-function getAlignment(placement) {
+function getAlignment$1(placement) {
   return placement.split("-")[1];
 }
-function getOppositeAxis(axis) {
+function getOppositeAxis$1(axis) {
   return axis === "x" ? "y" : "x";
 }
-function getAxisLength(axis) {
+function getAxisLength$1(axis) {
   return axis === "y" ? "height" : "width";
 }
 const yAxisSides = /* @__PURE__ */ new Set(["top", "bottom"]);
-function getSideAxis(placement) {
-  return yAxisSides.has(getSide(placement)) ? "y" : "x";
+function getSideAxis$1(placement) {
+  return yAxisSides.has(getSide$1(placement)) ? "y" : "x";
 }
-function getAlignmentAxis(placement) {
-  return getOppositeAxis(getSideAxis(placement));
+function getAlignmentAxis$1(placement) {
+  return getOppositeAxis$1(getSideAxis$1(placement));
 }
-function getAlignmentSides(placement, rects, rtl) {
+function getAlignmentSides$1(placement, rects, rtl) {
   rtl === void 0 && (rtl = !1);
-  const alignment = getAlignment(placement), alignmentAxis = getAlignmentAxis(placement), length = getAxisLength(alignmentAxis);
+  const alignment = getAlignment$1(placement), alignmentAxis = getAlignmentAxis$1(placement), length = getAxisLength$1(alignmentAxis);
   let mainAlignmentSide = alignmentAxis === "x" ? alignment === (rtl ? "end" : "start") ? "right" : "left" : alignment === "start" ? "bottom" : "top";
-  return rects.reference[length] > rects.floating[length] && (mainAlignmentSide = getOppositePlacement(mainAlignmentSide)), [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
+  return rects.reference[length] > rects.floating[length] && (mainAlignmentSide = getOppositePlacement$1(mainAlignmentSide)), [mainAlignmentSide, getOppositePlacement$1(mainAlignmentSide)];
 }
 function getExpandedPlacements(placement) {
-  const oppositePlacement = getOppositePlacement(placement);
-  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
+  const oppositePlacement = getOppositePlacement$1(placement);
+  return [getOppositeAlignmentPlacement$1(placement), oppositePlacement, getOppositeAlignmentPlacement$1(oppositePlacement)];
 }
-function getOppositeAlignmentPlacement(placement) {
+function getOppositeAlignmentPlacement$1(placement) {
   return placement.replace(/start|end/g, (alignment) => oppositeAlignmentMap[alignment]);
 }
 const lrPlacement = ["left", "right"], rlPlacement = ["right", "left"], tbPlacement = ["top", "bottom"], btPlacement = ["bottom", "top"];
@@ -11352,14 +11362,14 @@ function getSideList(side, isStart, rtl) {
   }
 }
 function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
-  const alignment = getAlignment(placement);
-  let list2 = getSideList(getSide(placement), direction === "start", rtl);
-  return alignment && (list2 = list2.map((side) => side + "-" + alignment), flipAlignment && (list2 = list2.concat(list2.map(getOppositeAlignmentPlacement)))), list2;
+  const alignment = getAlignment$1(placement);
+  let list2 = getSideList(getSide$1(placement), direction === "start", rtl);
+  return alignment && (list2 = list2.map((side) => side + "-" + alignment), flipAlignment && (list2 = list2.concat(list2.map(getOppositeAlignmentPlacement$1)))), list2;
 }
-function getOppositePlacement(placement) {
-  return placement.replace(/left|right|bottom|top/g, (side) => oppositeSideMap[side]);
+function getOppositePlacement$1(placement) {
+  return placement.replace(/left|right|bottom|top/g, (side) => oppositeSideMap$1[side]);
 }
-function expandPaddingObject(padding) {
+function expandPaddingObject$1(padding) {
   return {
     top: 0,
     right: 0,
@@ -11368,15 +11378,15 @@ function expandPaddingObject(padding) {
     ...padding
   };
 }
-function getPaddingObject(padding) {
-  return typeof padding != "number" ? expandPaddingObject(padding) : {
+function getPaddingObject$1(padding) {
+  return typeof padding != "number" ? expandPaddingObject$1(padding) : {
     top: padding,
     right: padding,
     bottom: padding,
     left: padding
   };
 }
-function rectToClientRect(rect) {
+function rectToClientRect$1(rect) {
   const {
     x: x2,
     y: y2,
@@ -11432,7 +11442,7 @@ function contains(parent, child) {
   const rootNode = child.getRootNode == null ? void 0 : child.getRootNode();
   if (parent.contains(child))
     return !0;
-  if (rootNode && isShadowRoot(rootNode)) {
+  if (rootNode && isShadowRoot$1(rootNode)) {
     let next = child;
     for (; next; ) {
       if (parent === next)
@@ -11460,7 +11470,7 @@ function getDocument(node2) {
   return node2?.ownerDocument || document;
 }
 function isTypeableElement(element) {
-  return isHTMLElement$1(element) && element.matches(TYPEABLE_SELECTOR);
+  return isHTMLElement$2(element) && element.matches(TYPEABLE_SELECTOR);
 }
 function matchesFocusVisible(element) {
   if (!element || isJSDOM()) return !0;
@@ -11509,12 +11519,12 @@ function useEffectEvent(callback) {
     return ref.current == null ? void 0 : ref.current(...args);
   }, []);
 }
-function computeCoordsFromPlacement(_ref, placement, rtl) {
+function computeCoordsFromPlacement$1(_ref, placement, rtl) {
   let {
     reference,
     floating
   } = _ref;
-  const sideAxis = getSideAxis(placement), alignmentAxis = getAlignmentAxis(placement), alignLength = getAxisLength(alignmentAxis), side = getSide(placement), isVertical = sideAxis === "y", commonX = reference.x + reference.width / 2 - floating.width / 2, commonY = reference.y + reference.height / 2 - floating.height / 2, commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
+  const sideAxis = getSideAxis$1(placement), alignmentAxis = getAlignmentAxis$1(placement), alignLength = getAxisLength$1(alignmentAxis), side = getSide$1(placement), isVertical = sideAxis === "y", commonX = reference.x + reference.width / 2 - floating.width / 2, commonY = reference.y + reference.height / 2 - floating.height / 2, commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
   let coords;
   switch (side) {
     case "top":
@@ -11547,7 +11557,7 @@ function computeCoordsFromPlacement(_ref, placement, rtl) {
         y: reference.y
       };
   }
-  switch (getAlignment(placement)) {
+  switch (getAlignment$1(placement)) {
     case "start":
       coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
       break;
@@ -11557,7 +11567,7 @@ function computeCoordsFromPlacement(_ref, placement, rtl) {
   }
   return coords;
 }
-async function detectOverflow(state, options) {
+async function detectOverflow$1(state, options) {
   var _await$platform$isEle;
   options === void 0 && (options = {});
   const {
@@ -11573,7 +11583,7 @@ async function detectOverflow(state, options) {
     elementContext = "floating",
     altBoundary = !1,
     padding = 0
-  } = evaluate(options, state), paddingObject = getPaddingObject(padding), element = elements[altBoundary ? elementContext === "floating" ? "reference" : "floating" : elementContext], clippingClientRect = rectToClientRect(await platform2.getClippingRect({
+  } = evaluate$1(options, state), paddingObject = getPaddingObject$1(padding), element = elements[altBoundary ? elementContext === "floating" ? "reference" : "floating" : elementContext], clippingClientRect = rectToClientRect$1(await platform2.getClippingRect({
     element: (_await$platform$isEle = await (platform2.isElement == null ? void 0 : platform2.isElement(element))) == null || _await$platform$isEle ? element : element.contextElement || await (platform2.getDocumentElement == null ? void 0 : platform2.getDocumentElement(elements.floating)),
     boundary,
     rootBoundary,
@@ -11589,7 +11599,7 @@ async function detectOverflow(state, options) {
   } : {
     x: 1,
     y: 1
-  }, elementClientRect = rectToClientRect(platform2.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform2.convertOffsetParentRelativeRectToViewportRelativeRect({
+  }, elementClientRect = rectToClientRect$1(platform2.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform2.convertOffsetParentRelativeRectToViewportRelativeRect({
     elements,
     rect,
     offsetParent,
@@ -11602,7 +11612,7 @@ async function detectOverflow(state, options) {
     right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
   };
 }
-const computePosition$1 = async (reference, floating, config) => {
+const computePosition$3 = async (reference, floating, config) => {
   const {
     placement = "bottom",
     strategy = "absolute",
@@ -11616,7 +11626,7 @@ const computePosition$1 = async (reference, floating, config) => {
   }), {
     x: x2,
     y: y2
-  } = computeCoordsFromPlacement(rects, placement, rtl), statefulPlacement = placement, middlewareData = {}, resetCount = 0;
+  } = computeCoordsFromPlacement$1(rects, placement, rtl), statefulPlacement = placement, middlewareData = {}, resetCount = 0;
   for (let i2 = 0; i2 < validMiddleware.length; i2++) {
     var _platform$detectOverf;
     const {
@@ -11637,7 +11647,7 @@ const computePosition$1 = async (reference, floating, config) => {
       rects,
       platform: {
         ...platform2,
-        detectOverflow: (_platform$detectOverf = platform2.detectOverflow) != null ? _platform$detectOverf : detectOverflow
+        detectOverflow: (_platform$detectOverf = platform2.detectOverflow) != null ? _platform$detectOverf : detectOverflow$1
       },
       elements: {
         reference,
@@ -11657,7 +11667,7 @@ const computePosition$1 = async (reference, floating, config) => {
     }) : reset.rects), {
       x: x2,
       y: y2
-    } = computeCoordsFromPlacement(rects, statefulPlacement, rtl)), i2 = -1);
+    } = computeCoordsFromPlacement$1(rects, statefulPlacement, rtl)), i2 = -1);
   }
   return {
     x: x2,
@@ -11681,16 +11691,16 @@ const computePosition$1 = async (reference, floating, config) => {
     } = state, {
       element,
       padding = 0
-    } = evaluate(options, state) || {};
+    } = evaluate$1(options, state) || {};
     if (element == null)
       return {};
-    const paddingObject = getPaddingObject(padding), coords = {
+    const paddingObject = getPaddingObject$1(padding), coords = {
       x: x2,
       y: y2
-    }, axis = getAlignmentAxis(placement), length = getAxisLength(axis), arrowDimensions = await platform2.getDimensions(element), isYAxis = axis === "y", minProp = isYAxis ? "top" : "left", maxProp = isYAxis ? "bottom" : "right", clientProp = isYAxis ? "clientHeight" : "clientWidth", endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length], startDiff = coords[axis] - rects.reference[axis], arrowOffsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(element));
+    }, axis = getAlignmentAxis$1(placement), length = getAxisLength$1(axis), arrowDimensions = await platform2.getDimensions(element), isYAxis = axis === "y", minProp = isYAxis ? "top" : "left", maxProp = isYAxis ? "bottom" : "right", clientProp = isYAxis ? "clientHeight" : "clientWidth", endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length], startDiff = coords[axis] - rects.reference[axis], arrowOffsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(element));
     let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;
     (!clientSize || !await (platform2.isElement == null ? void 0 : platform2.isElement(arrowOffsetParent))) && (clientSize = elements.floating[clientProp] || rects.floating[length]);
-    const centerToReference = endDiff / 2 - startDiff / 2, largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1, minPadding = min$1(paddingObject[minProp], largestPossiblePadding), maxPadding = min$1(paddingObject[maxProp], largestPossiblePadding), min$1$1 = minPadding, max2 = clientSize - arrowDimensions[length] - maxPadding, center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference, offset2 = clamp$2(min$1$1, center, max2), shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset2 && rects.reference[length] / 2 - (center < min$1$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0, alignmentOffset = shouldAddOffset ? center < min$1$1 ? center - min$1$1 : center - max2 : 0;
+    const centerToReference = endDiff / 2 - startDiff / 2, largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1, minPadding = min$2(paddingObject[minProp], largestPossiblePadding), maxPadding = min$2(paddingObject[maxProp], largestPossiblePadding), min$12 = minPadding, max2 = clientSize - arrowDimensions[length] - maxPadding, center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference, offset2 = clamp$2(min$12, center, max2), shouldAddOffset = !middlewareData.arrow && getAlignment$1(placement) != null && center !== offset2 && rects.reference[length] / 2 - (center < min$12 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0, alignmentOffset = shouldAddOffset ? center < min$12 ? center - min$12 : center - max2 : 0;
     return {
       [axis]: coords[axis] + alignmentOffset,
       data: {
@@ -11703,79 +11713,7 @@ const computePosition$1 = async (reference, floating, config) => {
       reset: shouldAddOffset
     };
   }
-});
-function getPlacementList(alignment, autoAlignment, allowedPlacements) {
-  return (alignment ? [...allowedPlacements.filter((placement) => getAlignment(placement) === alignment), ...allowedPlacements.filter((placement) => getAlignment(placement) !== alignment)] : allowedPlacements.filter((placement) => getSide(placement) === placement)).filter((placement) => alignment ? getAlignment(placement) === alignment || (autoAlignment ? getOppositeAlignmentPlacement(placement) !== placement : !1) : !0);
-}
-const autoPlacement$1 = function(options) {
-  return options === void 0 && (options = {}), {
-    name: "autoPlacement",
-    options,
-    async fn(state) {
-      var _middlewareData$autoP, _middlewareData$autoP2, _placementsThatFitOnE;
-      const {
-        rects,
-        middlewareData,
-        placement,
-        platform: platform2,
-        elements
-      } = state, {
-        crossAxis = !1,
-        alignment,
-        allowedPlacements = placements,
-        autoAlignment = !0,
-        ...detectOverflowOptions
-      } = evaluate(options, state), placements$1 = alignment !== void 0 || allowedPlacements === placements ? getPlacementList(alignment || null, autoAlignment, allowedPlacements) : allowedPlacements, overflow = await platform2.detectOverflow(state, detectOverflowOptions), currentIndex = ((_middlewareData$autoP = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP.index) || 0, currentPlacement = placements$1[currentIndex];
-      if (currentPlacement == null)
-        return {};
-      const alignmentSides = getAlignmentSides(currentPlacement, rects, await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating)));
-      if (placement !== currentPlacement)
-        return {
-          reset: {
-            placement: placements$1[0]
-          }
-        };
-      const currentOverflows = [overflow[getSide(currentPlacement)], overflow[alignmentSides[0]], overflow[alignmentSides[1]]], allOverflows = [...((_middlewareData$autoP2 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP2.overflows) || [], {
-        placement: currentPlacement,
-        overflows: currentOverflows
-      }], nextPlacement = placements$1[currentIndex + 1];
-      if (nextPlacement)
-        return {
-          data: {
-            index: currentIndex + 1,
-            overflows: allOverflows
-          },
-          reset: {
-            placement: nextPlacement
-          }
-        };
-      const placementsSortedByMostSpace = allOverflows.map((d2) => {
-        const alignment2 = getAlignment(d2.placement);
-        return [d2.placement, alignment2 && crossAxis ? (
-          // Check along the mainAxis and main crossAxis side.
-          d2.overflows.slice(0, 2).reduce((acc, v2) => acc + v2, 0)
-        ) : (
-          // Check only the mainAxis.
-          d2.overflows[0]
-        ), d2.overflows];
-      }).sort((a2, b2) => a2[1] - b2[1]), resetPlacement = ((_placementsThatFitOnE = placementsSortedByMostSpace.filter((d2) => d2[2].slice(
-        0,
-        // Aligned placements should not check their opposite crossAxis
-        // side.
-        getAlignment(d2[0]) ? 2 : 3
-      ).every((v2) => v2 <= 0))[0]) == null ? void 0 : _placementsThatFitOnE[0]) || placementsSortedByMostSpace[0][0];
-      return resetPlacement !== placement ? {
-        data: {
-          index: currentIndex + 1,
-          overflows: allOverflows
-        },
-        reset: {
-          placement: resetPlacement
-        }
-      } : {};
-    }
-  };
-}, flip$2 = function(options) {
+}), flip$2 = function(options) {
   return options === void 0 && (options = {}), {
     name: "flip",
     options,
@@ -11796,15 +11734,15 @@ const autoPlacement$1 = function(options) {
         fallbackAxisSideDirection = "none",
         flipAlignment = !0,
         ...detectOverflowOptions
-      } = evaluate(options, state);
+      } = evaluate$1(options, state);
       if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset)
         return {};
-      const side = getSide(placement), initialSideAxis = getSideAxis(initialPlacement), isBasePlacement = getSide(initialPlacement) === initialPlacement, rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating)), fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement)), hasFallbackAxisSideDirection = fallbackAxisSideDirection !== "none";
+      const side = getSide$1(placement), initialSideAxis = getSideAxis$1(initialPlacement), isBasePlacement = getSide$1(initialPlacement) === initialPlacement, rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating)), fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement$1(initialPlacement)] : getExpandedPlacements(initialPlacement)), hasFallbackAxisSideDirection = fallbackAxisSideDirection !== "none";
       !specifiedFallbackPlacements && hasFallbackAxisSideDirection && fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
       const placements2 = [initialPlacement, ...fallbackPlacements], overflow = await platform2.detectOverflow(state, detectOverflowOptions), overflows = [];
       let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
       if (checkMainAxis && overflows.push(overflow[side]), checkCrossAxis) {
-        const sides2 = getAlignmentSides(placement, rects, rtl);
+        const sides2 = getAlignmentSides$1(placement, rects, rtl);
         overflows.push(overflow[sides2[0]], overflow[sides2[1]]);
       }
       if (overflowsData = [...overflowsData, {
@@ -11813,9 +11751,9 @@ const autoPlacement$1 = function(options) {
       }], !overflows.every((side2) => side2 <= 0)) {
         var _middlewareData$flip2, _overflowsData$filter;
         const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1, nextPlacement = placements2[nextIndex];
-        if (nextPlacement && (!(checkCrossAxis === "alignment" ? initialSideAxis !== getSideAxis(nextPlacement) : !1) || // We leave the current main axis only if every placement on that axis
+        if (nextPlacement && (!(checkCrossAxis === "alignment" ? initialSideAxis !== getSideAxis$1(nextPlacement) : !1) || // We leave the current main axis only if every placement on that axis
         // overflows the main axis.
-        overflowsData.every((d2) => getSideAxis(d2.placement) === initialSideAxis ? d2.overflows[0] > 0 : !0)))
+        overflowsData.every((d2) => getSideAxis$1(d2.placement) === initialSideAxis ? d2.overflows[0] > 0 : !0)))
           return {
             data: {
               index: nextIndex,
@@ -11832,7 +11770,7 @@ const autoPlacement$1 = function(options) {
               var _overflowsData$filter2;
               const placement2 = (_overflowsData$filter2 = overflowsData.filter((d2) => {
                 if (hasFallbackAxisSideDirection) {
-                  const currentSideAxis = getSideAxis(d2.placement);
+                  const currentSideAxis = getSideAxis$1(d2.placement);
                   return currentSideAxis === initialSideAxis || // Create a bias to the `y` side axis due to horizontal
                   // reading directions favoring greater width.
                   currentSideAxis === "y";
@@ -11857,7 +11795,7 @@ const autoPlacement$1 = function(options) {
     }
   };
 };
-function getSideOffsets(overflow, rect) {
+function getSideOffsets$1(overflow, rect) {
   return {
     top: overflow.top - rect.height,
     right: overflow.right - rect.width,
@@ -11865,10 +11803,10 @@ function getSideOffsets(overflow, rect) {
     left: overflow.left - rect.width
   };
 }
-function isAnySideFullyClipped(overflow) {
-  return sides.some((side) => overflow[side] >= 0);
+function isAnySideFullyClipped$1(overflow) {
+  return sides$1.some((side) => overflow[side] >= 0);
 }
-const hide$2 = function(options) {
+const hide$4 = function(options) {
   return options === void 0 && (options = {}), {
     name: "hide",
     options,
@@ -11879,17 +11817,17 @@ const hide$2 = function(options) {
       } = state, {
         strategy = "referenceHidden",
         ...detectOverflowOptions
-      } = evaluate(options, state);
+      } = evaluate$1(options, state);
       switch (strategy) {
         case "referenceHidden": {
           const overflow = await platform2.detectOverflow(state, {
             ...detectOverflowOptions,
             elementContext: "reference"
-          }), offsets = getSideOffsets(overflow, rects.reference);
+          }), offsets = getSideOffsets$1(overflow, rects.reference);
           return {
             data: {
               referenceHiddenOffsets: offsets,
-              referenceHidden: isAnySideFullyClipped(offsets)
+              referenceHidden: isAnySideFullyClipped$1(offsets)
             }
           };
         }
@@ -11897,11 +11835,11 @@ const hide$2 = function(options) {
           const overflow = await platform2.detectOverflow(state, {
             ...detectOverflowOptions,
             altBoundary: !0
-          }), offsets = getSideOffsets(overflow, rects.floating);
+          }), offsets = getSideOffsets$1(overflow, rects.floating);
           return {
             data: {
               escapedOffsets: offsets,
-              escaped: isAnySideFullyClipped(offsets)
+              escaped: isAnySideFullyClipped$1(offsets)
             }
           };
         }
@@ -11912,7 +11850,7 @@ const hide$2 = function(options) {
   };
 };
 function getBoundingRect(rects) {
-  const minX = min$1(...rects.map((rect) => rect.left)), minY = min$1(...rects.map((rect) => rect.top)), maxX = max$1(...rects.map((rect) => rect.right)), maxY = max$1(...rects.map((rect) => rect.bottom));
+  const minX = min$2(...rects.map((rect) => rect.left)), minY = min$2(...rects.map((rect) => rect.top)), maxX = max$2(...rects.map((rect) => rect.right)), maxY = max$2(...rects.map((rect) => rect.bottom));
   return {
     x: minX,
     y: minY,
@@ -11927,7 +11865,7 @@ function getRectsByLine(rects) {
     const rect = sortedRects[i2];
     !prevRect || rect.y - prevRect.y > prevRect.height / 2 ? groups.push([rect]) : groups[groups.length - 1].push(rect), prevRect = rect;
   }
-  return groups.map((rect) => rectToClientRect(getBoundingRect(rect)));
+  return groups.map((rect) => rectToClientRect$1(getBoundingRect(rect)));
 }
 const inline$2 = function(options) {
   return options === void 0 && (options = {}), {
@@ -11944,13 +11882,13 @@ const inline$2 = function(options) {
         padding = 2,
         x: x2,
         y: y2
-      } = evaluate(options, state), nativeClientRects = Array.from(await (platform2.getClientRects == null ? void 0 : platform2.getClientRects(elements.reference)) || []), clientRects = getRectsByLine(nativeClientRects), fallback = rectToClientRect(getBoundingRect(nativeClientRects)), paddingObject = getPaddingObject(padding);
+      } = evaluate$1(options, state), nativeClientRects = Array.from(await (platform2.getClientRects == null ? void 0 : platform2.getClientRects(elements.reference)) || []), clientRects = getRectsByLine(nativeClientRects), fallback = rectToClientRect$1(getBoundingRect(nativeClientRects)), paddingObject = getPaddingObject$1(padding);
       function getBoundingClientRect2() {
         if (clientRects.length === 2 && clientRects[0].left > clientRects[1].right && x2 != null && y2 != null)
           return clientRects.find((rect) => x2 > rect.left - paddingObject.left && x2 < rect.right + paddingObject.right && y2 > rect.top - paddingObject.top && y2 < rect.bottom + paddingObject.bottom) || fallback;
         if (clientRects.length >= 2) {
-          if (getSideAxis(placement) === "y") {
-            const firstRect = clientRects[0], lastRect = clientRects[clientRects.length - 1], isTop = getSide(placement) === "top", top2 = firstRect.top, bottom2 = lastRect.bottom, left2 = isTop ? firstRect.left : lastRect.left, right2 = isTop ? firstRect.right : lastRect.right, width2 = right2 - left2, height2 = bottom2 - top2;
+          if (getSideAxis$1(placement) === "y") {
+            const firstRect = clientRects[0], lastRect = clientRects[clientRects.length - 1], isTop = getSide$1(placement) === "top", top2 = firstRect.top, bottom2 = lastRect.bottom, left2 = isTop ? firstRect.left : lastRect.left, right2 = isTop ? firstRect.right : lastRect.right, width2 = right2 - left2, height2 = bottom2 - top2;
             return {
               top: top2,
               bottom: bottom2,
@@ -11962,7 +11900,7 @@ const inline$2 = function(options) {
               y: top2
             };
           }
-          const isLeftSide = getSide(placement) === "left", maxRight = max$1(...clientRects.map((rect) => rect.right)), minLeft = min$1(...clientRects.map((rect) => rect.left)), measureRects = clientRects.filter((rect) => isLeftSide ? rect.left === minLeft : rect.right === maxRight), top = measureRects[0].top, bottom = measureRects[measureRects.length - 1].bottom, left = minLeft, right = maxRight, width = right - left, height = bottom - top;
+          const isLeftSide = getSide$1(placement) === "left", maxRight = max$2(...clientRects.map((rect) => rect.right)), minLeft = min$2(...clientRects.map((rect) => rect.left)), measureRects = clientRects.filter((rect) => isLeftSide ? rect.left === minLeft : rect.right === maxRight), top = measureRects[0].top, bottom = measureRects[measureRects.length - 1].bottom, left = minLeft, right = maxRight, width = right - left, height = bottom - top;
           return {
             top,
             bottom,
@@ -11990,13 +11928,13 @@ const inline$2 = function(options) {
       } : {};
     }
   };
-}, originSides = /* @__PURE__ */ new Set(["left", "top"]);
-async function convertValueToCoords(state, options) {
+}, originSides$1 = /* @__PURE__ */ new Set(["left", "top"]);
+async function convertValueToCoords$1(state, options) {
   const {
     placement,
     platform: platform2,
     elements
-  } = state, rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating)), side = getSide(placement), alignment = getAlignment(placement), isVertical = getSideAxis(placement) === "y", mainAxisMulti = originSides.has(side) ? -1 : 1, crossAxisMulti = rtl && isVertical ? -1 : 1, rawValue = evaluate(options, state);
+  } = state, rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating)), side = getSide$1(placement), alignment = getAlignment$1(placement), isVertical = getSideAxis$1(placement) === "y", mainAxisMulti = originSides$1.has(side) ? -1 : 1, crossAxisMulti = rtl && isVertical ? -1 : 1, rawValue = evaluate$1(options, state);
   let {
     mainAxis,
     crossAxis,
@@ -12018,7 +11956,7 @@ async function convertValueToCoords(state, options) {
     y: crossAxis * crossAxisMulti
   };
 }
-const offset$2 = function(options) {
+const offset$4 = function(options) {
   return options === void 0 && (options = 0), {
     name: "offset",
     options,
@@ -12029,7 +11967,7 @@ const offset$2 = function(options) {
         y: y2,
         placement,
         middlewareData
-      } = state, diffCoords = await convertValueToCoords(state, options);
+      } = state, diffCoords = await convertValueToCoords$1(state, options);
       return placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset ? {} : {
         x: x2 + diffCoords.x,
         y: y2 + diffCoords.y,
@@ -12066,10 +12004,10 @@ const offset$2 = function(options) {
           }
         },
         ...detectOverflowOptions
-      } = evaluate(options, state), coords = {
+      } = evaluate$1(options, state), coords = {
         x: x2,
         y: y2
-      }, overflow = await platform2.detectOverflow(state, detectOverflowOptions), crossAxis = getSideAxis(getSide(placement)), mainAxis = getOppositeAxis(crossAxis);
+      }, overflow = await platform2.detectOverflow(state, detectOverflowOptions), crossAxis = getSideAxis$1(getSide$1(placement)), mainAxis = getOppositeAxis$1(crossAxis);
       let mainAxisCoord = coords[mainAxis], crossAxisCoord = coords[crossAxis];
       if (checkMainAxis) {
         const minSide = mainAxis === "y" ? "top" : "left", maxSide = mainAxis === "y" ? "bottom" : "right", min2 = mainAxisCoord + overflow[minSide], max2 = mainAxisCoord - overflow[maxSide];
@@ -12111,12 +12049,12 @@ const offset$2 = function(options) {
         offset: offset2 = 0,
         mainAxis: checkMainAxis = !0,
         crossAxis: checkCrossAxis = !0
-      } = evaluate(options, state), coords = {
+      } = evaluate$1(options, state), coords = {
         x: x2,
         y: y2
-      }, crossAxis = getSideAxis(placement), mainAxis = getOppositeAxis(crossAxis);
+      }, crossAxis = getSideAxis$1(placement), mainAxis = getOppositeAxis$1(crossAxis);
       let mainAxisCoord = coords[mainAxis], crossAxisCoord = coords[crossAxis];
-      const rawOffset = evaluate(offset2, state), computedOffset = typeof rawOffset == "number" ? {
+      const rawOffset = evaluate$1(offset2, state), computedOffset = typeof rawOffset == "number" ? {
         mainAxis: rawOffset,
         crossAxis: 0
       } : {
@@ -12130,7 +12068,7 @@ const offset$2 = function(options) {
       }
       if (checkCrossAxis) {
         var _middlewareData$offse, _middlewareData$offse2;
-        const len = mainAxis === "y" ? "width" : "height", isOriginSide = originSides.has(getSide(placement)), limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide && ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0) + (isOriginSide ? 0 : computedOffset.crossAxis), limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : ((_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0);
+        const len = mainAxis === "y" ? "width" : "height", isOriginSide = originSides$1.has(getSide$1(placement)), limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide && ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0) + (isOriginSide ? 0 : computedOffset.crossAxis), limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : ((_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0);
         crossAxisCoord < limitMin ? crossAxisCoord = limitMin : crossAxisCoord > limitMax && (crossAxisCoord = limitMax);
       }
       return {
@@ -12139,7 +12077,7 @@ const offset$2 = function(options) {
       };
     }
   };
-}, size$2 = function(options) {
+}, size$4 = function(options) {
   return options === void 0 && (options = {}), {
     name: "size",
     options,
@@ -12154,17 +12092,17 @@ const offset$2 = function(options) {
         apply = () => {
         },
         ...detectOverflowOptions
-      } = evaluate(options, state), overflow = await platform2.detectOverflow(state, detectOverflowOptions), side = getSide(placement), alignment = getAlignment(placement), isYAxis = getSideAxis(placement) === "y", {
+      } = evaluate$1(options, state), overflow = await platform2.detectOverflow(state, detectOverflowOptions), side = getSide$1(placement), alignment = getAlignment$1(placement), isYAxis = getSideAxis$1(placement) === "y", {
         width,
         height
       } = rects.floating;
       let heightSide, widthSide;
       side === "top" || side === "bottom" ? (heightSide = side, widthSide = alignment === (await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating)) ? "start" : "end") ? "left" : "right") : (widthSide = side, heightSide = alignment === "end" ? "top" : "bottom");
-      const maximumClippingHeight = height - overflow.top - overflow.bottom, maximumClippingWidth = width - overflow.left - overflow.right, overflowAvailableHeight = min$1(height - overflow[heightSide], maximumClippingHeight), overflowAvailableWidth = min$1(width - overflow[widthSide], maximumClippingWidth), noShift = !state.middlewareData.shift;
+      const maximumClippingHeight = height - overflow.top - overflow.bottom, maximumClippingWidth = width - overflow.left - overflow.right, overflowAvailableHeight = min$2(height - overflow[heightSide], maximumClippingHeight), overflowAvailableWidth = min$2(width - overflow[widthSide], maximumClippingWidth), noShift = !state.middlewareData.shift;
       let availableHeight = overflowAvailableHeight, availableWidth = overflowAvailableWidth;
       if ((_state$middlewareData = state.middlewareData.shift) != null && _state$middlewareData.enabled.x && (availableWidth = maximumClippingWidth), (_state$middlewareData2 = state.middlewareData.shift) != null && _state$middlewareData2.enabled.y && (availableHeight = maximumClippingHeight), noShift && !alignment) {
-        const xMin = max$1(overflow.left, 0), xMax = max$1(overflow.right, 0), yMin = max$1(overflow.top, 0), yMax = max$1(overflow.bottom, 0);
-        isYAxis ? availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max$1(overflow.left, overflow.right)) : availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max$1(overflow.top, overflow.bottom));
+        const xMin = max$2(overflow.left, 0), xMax = max$2(overflow.right, 0), yMin = max$2(overflow.top, 0), yMax = max$2(overflow.bottom, 0);
+        isYAxis ? availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max$2(overflow.left, overflow.right)) : availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max$2(overflow.top, overflow.bottom));
       }
       await apply({
         ...state,
@@ -12180,98 +12118,98 @@ const offset$2 = function(options) {
     }
   };
 };
-function getCssDimensions(element) {
-  const css2 = getComputedStyle$2(element);
+function getCssDimensions$1(element) {
+  const css2 = getComputedStyle$3(element);
   let width = parseFloat(css2.width) || 0, height = parseFloat(css2.height) || 0;
-  const hasOffset = isHTMLElement$1(element), offsetWidth = hasOffset ? element.offsetWidth : width, offsetHeight = hasOffset ? element.offsetHeight : height, shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
+  const hasOffset = isHTMLElement$2(element), offsetWidth = hasOffset ? element.offsetWidth : width, offsetHeight = hasOffset ? element.offsetHeight : height, shouldFallback = round$1(width) !== offsetWidth || round$1(height) !== offsetHeight;
   return shouldFallback && (width = offsetWidth, height = offsetHeight), {
     width,
     height,
     $: shouldFallback
   };
 }
-function unwrapElement(element) {
-  return isElement(element) ? element : element.contextElement;
+function unwrapElement$1(element) {
+  return isElement$1(element) ? element : element.contextElement;
 }
-function getScale(element) {
-  const domElement = unwrapElement(element);
-  if (!isHTMLElement$1(domElement))
-    return createCoords(1);
+function getScale$1(element) {
+  const domElement = unwrapElement$1(element);
+  if (!isHTMLElement$2(domElement))
+    return createCoords$1(1);
   const rect = domElement.getBoundingClientRect(), {
     width,
     height,
     $
-  } = getCssDimensions(domElement);
-  let x2 = ($ ? round(rect.width) : rect.width) / width, y2 = ($ ? round(rect.height) : rect.height) / height;
+  } = getCssDimensions$1(domElement);
+  let x2 = ($ ? round$1(rect.width) : rect.width) / width, y2 = ($ ? round$1(rect.height) : rect.height) / height;
   return (!x2 || !Number.isFinite(x2)) && (x2 = 1), (!y2 || !Number.isFinite(y2)) && (y2 = 1), {
     x: x2,
     y: y2
   };
 }
-const noOffsets = /* @__PURE__ */ createCoords(0);
-function getVisualOffsets(element) {
-  const win2 = getWindow(element);
-  return !isWebKit() || !win2.visualViewport ? noOffsets : {
+const noOffsets$1 = /* @__PURE__ */ createCoords$1(0);
+function getVisualOffsets$1(element) {
+  const win2 = getWindow$1(element);
+  return !isWebKit$1() || !win2.visualViewport ? noOffsets$1 : {
     x: win2.visualViewport.offsetLeft,
     y: win2.visualViewport.offsetTop
   };
 }
-function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
-  return isFixed === void 0 && (isFixed = !1), !floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element) ? !1 : isFixed;
+function shouldAddVisualOffsets$1(element, isFixed, floatingOffsetParent) {
+  return isFixed === void 0 && (isFixed = !1), !floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow$1(element) ? !1 : isFixed;
 }
-function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
+function getBoundingClientRect$1(element, includeScale, isFixedStrategy, offsetParent) {
   includeScale === void 0 && (includeScale = !1), isFixedStrategy === void 0 && (isFixedStrategy = !1);
-  const clientRect = element.getBoundingClientRect(), domElement = unwrapElement(element);
-  let scale2 = createCoords(1);
-  includeScale && (offsetParent ? isElement(offsetParent) && (scale2 = getScale(offsetParent)) : scale2 = getScale(element));
-  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
+  const clientRect = element.getBoundingClientRect(), domElement = unwrapElement$1(element);
+  let scale2 = createCoords$1(1);
+  includeScale && (offsetParent ? isElement$1(offsetParent) && (scale2 = getScale$1(offsetParent)) : scale2 = getScale$1(element));
+  const visualOffsets = shouldAddVisualOffsets$1(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets$1(domElement) : createCoords$1(0);
   let x2 = (clientRect.left + visualOffsets.x) / scale2.x, y2 = (clientRect.top + visualOffsets.y) / scale2.y, width = clientRect.width / scale2.x, height = clientRect.height / scale2.y;
   if (domElement) {
-    const win2 = getWindow(domElement), offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
-    let currentWin = win2, currentIFrame = getFrameElement(currentWin);
+    const win2 = getWindow$1(domElement), offsetWin = offsetParent && isElement$1(offsetParent) ? getWindow$1(offsetParent) : offsetParent;
+    let currentWin = win2, currentIFrame = getFrameElement$1(currentWin);
     for (; currentIFrame && offsetParent && offsetWin !== currentWin; ) {
-      const iframeScale = getScale(currentIFrame), iframeRect = currentIFrame.getBoundingClientRect(), css2 = getComputedStyle$2(currentIFrame), left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css2.paddingLeft)) * iframeScale.x, top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css2.paddingTop)) * iframeScale.y;
-      x2 *= iframeScale.x, y2 *= iframeScale.y, width *= iframeScale.x, height *= iframeScale.y, x2 += left, y2 += top, currentWin = getWindow(currentIFrame), currentIFrame = getFrameElement(currentWin);
+      const iframeScale = getScale$1(currentIFrame), iframeRect = currentIFrame.getBoundingClientRect(), css2 = getComputedStyle$3(currentIFrame), left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css2.paddingLeft)) * iframeScale.x, top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css2.paddingTop)) * iframeScale.y;
+      x2 *= iframeScale.x, y2 *= iframeScale.y, width *= iframeScale.x, height *= iframeScale.y, x2 += left, y2 += top, currentWin = getWindow$1(currentIFrame), currentIFrame = getFrameElement$1(currentWin);
     }
   }
-  return rectToClientRect({
+  return rectToClientRect$1({
     width,
     height,
     x: x2,
     y: y2
   });
 }
-function getWindowScrollBarX(element, rect) {
-  const leftScroll = getNodeScroll(element).scrollLeft;
-  return rect ? rect.left + leftScroll : getBoundingClientRect(getDocumentElement(element)).left + leftScroll;
+function getWindowScrollBarX$1(element, rect) {
+  const leftScroll = getNodeScroll$1(element).scrollLeft;
+  return rect ? rect.left + leftScroll : getBoundingClientRect$1(getDocumentElement$1(element)).left + leftScroll;
 }
-function getHTMLOffset(documentElement, scroll) {
-  const htmlRect = documentElement.getBoundingClientRect(), x2 = htmlRect.left + scroll.scrollLeft - getWindowScrollBarX(documentElement, htmlRect), y2 = htmlRect.top + scroll.scrollTop;
+function getHTMLOffset$1(documentElement, scroll) {
+  const htmlRect = documentElement.getBoundingClientRect(), x2 = htmlRect.left + scroll.scrollLeft - getWindowScrollBarX$1(documentElement, htmlRect), y2 = htmlRect.top + scroll.scrollTop;
   return {
     x: x2,
     y: y2
   };
 }
-function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
+function convertOffsetParentRelativeRectToViewportRelativeRect$1(_ref) {
   let {
     elements,
     rect,
     offsetParent,
     strategy
   } = _ref;
-  const isFixed = strategy === "fixed", documentElement = getDocumentElement(offsetParent), topLayer = elements ? isTopLayer(elements.floating) : !1;
+  const isFixed = strategy === "fixed", documentElement = getDocumentElement$1(offsetParent), topLayer = elements ? isTopLayer$1(elements.floating) : !1;
   if (offsetParent === documentElement || topLayer && isFixed)
     return rect;
   let scroll = {
     scrollLeft: 0,
     scrollTop: 0
-  }, scale2 = createCoords(1);
-  const offsets = createCoords(0), isOffsetParentAnElement = isHTMLElement$1(offsetParent);
-  if ((isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) && ((getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) && (scroll = getNodeScroll(offsetParent)), isHTMLElement$1(offsetParent))) {
-    const offsetRect = getBoundingClientRect(offsetParent);
-    scale2 = getScale(offsetParent), offsets.x = offsetRect.x + offsetParent.clientLeft, offsets.y = offsetRect.y + offsetParent.clientTop;
+  }, scale2 = createCoords$1(1);
+  const offsets = createCoords$1(0), isOffsetParentAnElement = isHTMLElement$2(offsetParent);
+  if ((isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) && ((getNodeName$1(offsetParent) !== "body" || isOverflowElement$1(documentElement)) && (scroll = getNodeScroll$1(offsetParent)), isHTMLElement$2(offsetParent))) {
+    const offsetRect = getBoundingClientRect$1(offsetParent);
+    scale2 = getScale$1(offsetParent), offsets.x = offsetRect.x + offsetParent.clientLeft, offsets.y = offsetRect.y + offsetParent.clientTop;
   }
-  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
+  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset$1(documentElement, scroll) : createCoords$1(0);
   return {
     width: rect.width * scale2.x,
     height: rect.height * scale2.y,
@@ -12279,34 +12217,34 @@ function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
     y: rect.y * scale2.y - scroll.scrollTop * scale2.y + offsets.y + htmlOffset.y
   };
 }
-function getClientRects(element) {
+function getClientRects$1(element) {
   return Array.from(element.getClientRects());
 }
-function getDocumentRect(element) {
-  const html = getDocumentElement(element), scroll = getNodeScroll(element), body2 = element.ownerDocument.body, width = max$1(html.scrollWidth, html.clientWidth, body2.scrollWidth, body2.clientWidth), height = max$1(html.scrollHeight, html.clientHeight, body2.scrollHeight, body2.clientHeight);
-  let x2 = -scroll.scrollLeft + getWindowScrollBarX(element);
+function getDocumentRect$1(element) {
+  const html = getDocumentElement$1(element), scroll = getNodeScroll$1(element), body = element.ownerDocument.body, width = max$2(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth), height = max$2(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
+  let x2 = -scroll.scrollLeft + getWindowScrollBarX$1(element);
   const y2 = -scroll.scrollTop;
-  return getComputedStyle$2(body2).direction === "rtl" && (x2 += max$1(html.clientWidth, body2.clientWidth) - width), {
+  return getComputedStyle$3(body).direction === "rtl" && (x2 += max$2(html.clientWidth, body.clientWidth) - width), {
     width,
     height,
     x: x2,
     y: y2
   };
 }
-const SCROLLBAR_MAX = 25;
-function getViewportRect(element, strategy) {
-  const win2 = getWindow(element), html = getDocumentElement(element), visualViewport = win2.visualViewport;
+const SCROLLBAR_MAX$1 = 25;
+function getViewportRect$1(element, strategy) {
+  const win2 = getWindow$1(element), html = getDocumentElement$1(element), visualViewport = win2.visualViewport;
   let width = html.clientWidth, height = html.clientHeight, x2 = 0, y2 = 0;
   if (visualViewport) {
     width = visualViewport.width, height = visualViewport.height;
-    const visualViewportBased = isWebKit();
+    const visualViewportBased = isWebKit$1();
     (!visualViewportBased || visualViewportBased && strategy === "fixed") && (x2 = visualViewport.offsetLeft, y2 = visualViewport.offsetTop);
   }
-  const windowScrollbarX = getWindowScrollBarX(html);
+  const windowScrollbarX = getWindowScrollBarX$1(html);
   if (windowScrollbarX <= 0) {
-    const doc = html.ownerDocument, body2 = doc.body, bodyStyles = getComputedStyle(body2), bodyMarginInline = doc.compatMode === "CSS1Compat" && parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight) || 0, clippingStableScrollbarWidth = Math.abs(html.clientWidth - body2.clientWidth - bodyMarginInline);
-    clippingStableScrollbarWidth <= SCROLLBAR_MAX && (width -= clippingStableScrollbarWidth);
-  } else windowScrollbarX <= SCROLLBAR_MAX && (width += windowScrollbarX);
+    const doc = html.ownerDocument, body = doc.body, bodyStyles = getComputedStyle(body), bodyMarginInline = doc.compatMode === "CSS1Compat" && parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight) || 0, clippingStableScrollbarWidth = Math.abs(html.clientWidth - body.clientWidth - bodyMarginInline);
+    clippingStableScrollbarWidth <= SCROLLBAR_MAX$1 && (width -= clippingStableScrollbarWidth);
+  } else windowScrollbarX <= SCROLLBAR_MAX$1 && (width += windowScrollbarX);
   return {
     width,
     height,
@@ -12315,8 +12253,8 @@ function getViewportRect(element, strategy) {
   };
 }
 const absoluteOrFixed = /* @__PURE__ */ new Set(["absolute", "fixed"]);
-function getInnerBoundingClientRect(element, strategy) {
-  const clientRect = getBoundingClientRect(element, !0, strategy === "fixed"), top = clientRect.top + element.clientTop, left = clientRect.left + element.clientLeft, scale2 = isHTMLElement$1(element) ? getScale(element) : createCoords(1), width = element.clientWidth * scale2.x, height = element.clientHeight * scale2.y, x2 = left * scale2.x, y2 = top * scale2.y;
+function getInnerBoundingClientRect$1(element, strategy) {
+  const clientRect = getBoundingClientRect$1(element, !0, strategy === "fixed"), top = clientRect.top + element.clientTop, left = clientRect.left + element.clientLeft, scale2 = isHTMLElement$2(element) ? getScale$1(element) : createCoords$1(1), width = element.clientWidth * scale2.x, height = element.clientHeight * scale2.y, x2 = left * scale2.x, y2 = top * scale2.y;
   return {
     width,
     height,
@@ -12324,16 +12262,16 @@ function getInnerBoundingClientRect(element, strategy) {
     y: y2
   };
 }
-function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
+function getClientRectFromClippingAncestor$1(element, clippingAncestor, strategy) {
   let rect;
   if (clippingAncestor === "viewport")
-    rect = getViewportRect(element, strategy);
+    rect = getViewportRect$1(element, strategy);
   else if (clippingAncestor === "document")
-    rect = getDocumentRect(getDocumentElement(element));
-  else if (isElement(clippingAncestor))
-    rect = getInnerBoundingClientRect(clippingAncestor, strategy);
+    rect = getDocumentRect$1(getDocumentElement$1(element));
+  else if (isElement$1(clippingAncestor))
+    rect = getInnerBoundingClientRect$1(clippingAncestor, strategy);
   else {
-    const visualOffsets = getVisualOffsets(element);
+    const visualOffsets = getVisualOffsets$1(element);
     rect = {
       x: clippingAncestor.x - visualOffsets.x,
       y: clippingAncestor.y - visualOffsets.y,
@@ -12341,36 +12279,36 @@ function getClientRectFromClippingAncestor(element, clippingAncestor, strategy)
       height: clippingAncestor.height
     };
   }
-  return rectToClientRect(rect);
+  return rectToClientRect$1(rect);
 }
-function hasFixedPositionAncestor(element, stopNode) {
-  const parentNode = getParentNode(element);
-  return parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode) ? !1 : getComputedStyle$2(parentNode).position === "fixed" || hasFixedPositionAncestor(parentNode, stopNode);
+function hasFixedPositionAncestor$1(element, stopNode) {
+  const parentNode = getParentNode$1(element);
+  return parentNode === stopNode || !isElement$1(parentNode) || isLastTraversableNode$1(parentNode) ? !1 : getComputedStyle$3(parentNode).position === "fixed" || hasFixedPositionAncestor$1(parentNode, stopNode);
 }
-function getClippingElementAncestors(element, cache) {
+function getClippingElementAncestors$1(element, cache) {
   const cachedResult = cache.get(element);
   if (cachedResult)
     return cachedResult;
-  let result = getOverflowAncestors(element, [], !1).filter((el) => isElement(el) && getNodeName(el) !== "body"), currentContainingBlockComputedStyle = null;
-  const elementIsFixed = getComputedStyle$2(element).position === "fixed";
-  let currentNode = elementIsFixed ? getParentNode(element) : element;
-  for (; isElement(currentNode) && !isLastTraversableNode(currentNode); ) {
-    const computedStyle = getComputedStyle$2(currentNode), currentNodeIsContaining = isContainingBlock(currentNode);
-    !currentNodeIsContaining && computedStyle.position === "fixed" && (currentContainingBlockComputedStyle = null), (elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === "static" && !!currentContainingBlockComputedStyle && absoluteOrFixed.has(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode)) ? result = result.filter((ancestor) => ancestor !== currentNode) : currentContainingBlockComputedStyle = computedStyle, currentNode = getParentNode(currentNode);
+  let result = getOverflowAncestors$1(element, [], !1).filter((el) => isElement$1(el) && getNodeName$1(el) !== "body"), currentContainingBlockComputedStyle = null;
+  const elementIsFixed = getComputedStyle$3(element).position === "fixed";
+  let currentNode = elementIsFixed ? getParentNode$1(element) : element;
+  for (; isElement$1(currentNode) && !isLastTraversableNode$1(currentNode); ) {
+    const computedStyle = getComputedStyle$3(currentNode), currentNodeIsContaining = isContainingBlock$1(currentNode);
+    !currentNodeIsContaining && computedStyle.position === "fixed" && (currentContainingBlockComputedStyle = null), (elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === "static" && !!currentContainingBlockComputedStyle && absoluteOrFixed.has(currentContainingBlockComputedStyle.position) || isOverflowElement$1(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor$1(element, currentNode)) ? result = result.filter((ancestor) => ancestor !== currentNode) : currentContainingBlockComputedStyle = computedStyle, currentNode = getParentNode$1(currentNode);
   }
   return cache.set(element, result), result;
 }
-function getClippingRect(_ref) {
+function getClippingRect$1(_ref) {
   let {
     element,
     boundary,
     rootBoundary,
     strategy
   } = _ref;
-  const clippingAncestors = [...boundary === "clippingAncestors" ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary), rootBoundary], firstClippingAncestor = clippingAncestors[0], clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
-    const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
-    return accRect.top = max$1(rect.top, accRect.top), accRect.right = min$1(rect.right, accRect.right), accRect.bottom = min$1(rect.bottom, accRect.bottom), accRect.left = max$1(rect.left, accRect.left), accRect;
-  }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
+  const clippingAncestors = [...boundary === "clippingAncestors" ? isTopLayer$1(element) ? [] : getClippingElementAncestors$1(element, this._c) : [].concat(boundary), rootBoundary], firstClippingAncestor = clippingAncestors[0], clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
+    const rect = getClientRectFromClippingAncestor$1(element, clippingAncestor, strategy);
+    return accRect.top = max$2(rect.top, accRect.top), accRect.right = min$2(rect.right, accRect.right), accRect.bottom = min$2(rect.bottom, accRect.bottom), accRect.left = max$2(rect.left, accRect.left), accRect;
+  }, getClientRectFromClippingAncestor$1(element, firstClippingAncestor, strategy));
   return {
     width: clippingRect.right - clippingRect.left,
     height: clippingRect.bottom - clippingRect.top,
@@ -12378,33 +12316,33 @@ function getClippingRect(_ref) {
     y: clippingRect.top
   };
 }
-function getDimensions(element) {
+function getDimensions$1(element) {
   const {
     width,
     height
-  } = getCssDimensions(element);
+  } = getCssDimensions$1(element);
   return {
     width,
     height
   };
 }
-function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
-  const isOffsetParentAnElement = isHTMLElement$1(offsetParent), documentElement = getDocumentElement(offsetParent), isFixed = strategy === "fixed", rect = getBoundingClientRect(element, !0, isFixed, offsetParent);
+function getRectRelativeToOffsetParent$1(element, offsetParent, strategy) {
+  const isOffsetParentAnElement = isHTMLElement$2(offsetParent), documentElement = getDocumentElement$1(offsetParent), isFixed = strategy === "fixed", rect = getBoundingClientRect$1(element, !0, isFixed, offsetParent);
   let scroll = {
     scrollLeft: 0,
     scrollTop: 0
   };
-  const offsets = createCoords(0);
+  const offsets = createCoords$1(0);
   function setLeftRTLScrollbarOffset() {
-    offsets.x = getWindowScrollBarX(documentElement);
+    offsets.x = getWindowScrollBarX$1(documentElement);
   }
   if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed)
-    if ((getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) && (scroll = getNodeScroll(offsetParent)), isOffsetParentAnElement) {
-      const offsetRect = getBoundingClientRect(offsetParent, !0, isFixed, offsetParent);
+    if ((getNodeName$1(offsetParent) !== "body" || isOverflowElement$1(documentElement)) && (scroll = getNodeScroll$1(offsetParent)), isOffsetParentAnElement) {
+      const offsetRect = getBoundingClientRect$1(offsetParent, !0, isFixed, offsetParent);
       offsets.x = offsetRect.x + offsetParent.clientLeft, offsets.y = offsetRect.y + offsetParent.clientTop;
     } else documentElement && setLeftRTLScrollbarOffset();
   isFixed && !isOffsetParentAnElement && documentElement && setLeftRTLScrollbarOffset();
-  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0), x2 = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x, y2 = rect.top + scroll.scrollTop - offsets.y - htmlOffset.y;
+  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset$1(documentElement, scroll) : createCoords$1(0), x2 = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x, y2 = rect.top + scroll.scrollTop - offsets.y - htmlOffset.y;
   return {
     x: x2,
     y: y2,
@@ -12412,39 +12350,39 @@ function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
     height: rect.height
   };
 }
-function isStaticPositioned(element) {
-  return getComputedStyle$2(element).position === "static";
+function isStaticPositioned$1(element) {
+  return getComputedStyle$3(element).position === "static";
 }
-function getTrueOffsetParent(element, polyfill) {
-  if (!isHTMLElement$1(element) || getComputedStyle$2(element).position === "fixed")
+function getTrueOffsetParent$1(element, polyfill) {
+  if (!isHTMLElement$2(element) || getComputedStyle$3(element).position === "fixed")
     return null;
   if (polyfill)
     return polyfill(element);
   let rawOffsetParent = element.offsetParent;
-  return getDocumentElement(element) === rawOffsetParent && (rawOffsetParent = rawOffsetParent.ownerDocument.body), rawOffsetParent;
+  return getDocumentElement$1(element) === rawOffsetParent && (rawOffsetParent = rawOffsetParent.ownerDocument.body), rawOffsetParent;
 }
-function getOffsetParent(element, polyfill) {
-  const win2 = getWindow(element);
-  if (isTopLayer(element))
+function getOffsetParent$1(element, polyfill) {
+  const win2 = getWindow$1(element);
+  if (isTopLayer$1(element))
     return win2;
-  if (!isHTMLElement$1(element)) {
-    let svgOffsetParent = getParentNode(element);
-    for (; svgOffsetParent && !isLastTraversableNode(svgOffsetParent); ) {
-      if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent))
+  if (!isHTMLElement$2(element)) {
+    let svgOffsetParent = getParentNode$1(element);
+    for (; svgOffsetParent && !isLastTraversableNode$1(svgOffsetParent); ) {
+      if (isElement$1(svgOffsetParent) && !isStaticPositioned$1(svgOffsetParent))
         return svgOffsetParent;
-      svgOffsetParent = getParentNode(svgOffsetParent);
+      svgOffsetParent = getParentNode$1(svgOffsetParent);
     }
     return win2;
   }
-  let offsetParent = getTrueOffsetParent(element, polyfill);
-  for (; offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent); )
-    offsetParent = getTrueOffsetParent(offsetParent, polyfill);
-  return offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent) ? win2 : offsetParent || getContainingBlock(element) || win2;
+  let offsetParent = getTrueOffsetParent$1(element, polyfill);
+  for (; offsetParent && isTableElement$1(offsetParent) && isStaticPositioned$1(offsetParent); )
+    offsetParent = getTrueOffsetParent$1(offsetParent, polyfill);
+  return offsetParent && isLastTraversableNode$1(offsetParent) && isStaticPositioned$1(offsetParent) && !isContainingBlock$1(offsetParent) ? win2 : offsetParent || getContainingBlock$1(element) || win2;
 }
-const getElementRects = async function(data2) {
-  const getOffsetParentFn = this.getOffsetParent || getOffsetParent, getDimensionsFn = this.getDimensions, floatingDimensions = await getDimensionsFn(data2.floating);
+const getElementRects$1 = async function(data2) {
+  const getOffsetParentFn = this.getOffsetParent || getOffsetParent$1, getDimensionsFn = this.getDimensions, floatingDimensions = await getDimensionsFn(data2.floating);
   return {
-    reference: getRectRelativeToOffsetParent(data2.reference, await getOffsetParentFn(data2.floating), data2.strategy),
+    reference: getRectRelativeToOffsetParent$1(data2.reference, await getOffsetParentFn(data2.floating), data2.strategy),
     floating: {
       x: 0,
       y: 0,
@@ -12453,27 +12391,27 @@ const getElementRects = async function(data2) {
     }
   };
 };
-function isRTL(element) {
-  return getComputedStyle$2(element).direction === "rtl";
-}
-const platform = {
-  convertOffsetParentRelativeRectToViewportRelativeRect,
-  getDocumentElement,
-  getClippingRect,
-  getOffsetParent,
-  getElementRects,
-  getClientRects,
-  getDimensions,
-  getScale,
-  isElement,
-  isRTL
+function isRTL$1(element) {
+  return getComputedStyle$3(element).direction === "rtl";
+}
+const platform$1 = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: convertOffsetParentRelativeRectToViewportRelativeRect$1,
+  getDocumentElement: getDocumentElement$1,
+  getClippingRect: getClippingRect$1,
+  getOffsetParent: getOffsetParent$1,
+  getElementRects: getElementRects$1,
+  getClientRects: getClientRects$1,
+  getDimensions: getDimensions$1,
+  getScale: getScale$1,
+  isElement: isElement$1,
+  isRTL: isRTL$1
 };
-function rectsAreEqual(a2, b2) {
+function rectsAreEqual$1(a2, b2) {
   return a2.x === b2.x && a2.y === b2.y && a2.width === b2.width && a2.height === b2.height;
 }
-function observeMove(element, onMove) {
+function observeMove$1(element, onMove) {
   let io = null, timeoutId;
-  const root2 = getDocumentElement(element);
+  const root2 = getDocumentElement$1(element);
   function cleanup() {
     var _io;
     clearTimeout(timeoutId), (_io = io) == null || _io.disconnect(), io = null;
@@ -12488,9 +12426,9 @@ function observeMove(element, onMove) {
     } = elementRectForRootMargin;
     if (skip || onMove(), !width || !height)
       return;
-    const insetTop = floor(top), insetRight = floor(root2.clientWidth - (left + width)), insetBottom = floor(root2.clientHeight - (top + height)), insetLeft = floor(left), options = {
+    const insetTop = floor$1(top), insetRight = floor$1(root2.clientWidth - (left + width)), insetBottom = floor$1(root2.clientHeight - (top + height)), insetLeft = floor$1(left), options = {
       rootMargin: -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px",
-      threshold: max$1(0, min$1(1, threshold)) || 1
+      threshold: max$2(0, min$2(1, threshold)) || 1
     };
     let isFirstUpdate = !0;
     function handleObserve(entries) {
@@ -12502,7 +12440,7 @@ function observeMove(element, onMove) {
           refresh(!1, 1e-7);
         }, 1e3);
       }
-      ratio === 1 && !rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect()) && refresh(), isFirstUpdate = !1;
+      ratio === 1 && !rectsAreEqual$1(elementRectForRootMargin, element.getBoundingClientRect()) && refresh(), isFirstUpdate = !1;
     }
     try {
       io = new IntersectionObserver(handleObserve, {
@@ -12517,7 +12455,7 @@ function observeMove(element, onMove) {
   }
   return refresh(!0), cleanup;
 }
-function autoUpdate(reference, floating, update, options) {
+function autoUpdate$1(reference, floating, update, options) {
   options === void 0 && (options = {});
   const {
     ancestorScroll = !0,
@@ -12525,13 +12463,13 @@ function autoUpdate(reference, floating, update, options) {
     elementResize = typeof ResizeObserver == "function",
     layoutShift = typeof IntersectionObserver == "function",
     animationFrame = !1
-  } = options, referenceEl = unwrapElement(reference), ancestors = ancestorScroll || ancestorResize ? [...referenceEl ? getOverflowAncestors(referenceEl) : [], ...getOverflowAncestors(floating)] : [];
+  } = options, referenceEl = unwrapElement$1(reference), ancestors = ancestorScroll || ancestorResize ? [...referenceEl ? getOverflowAncestors$1(referenceEl) : [], ...getOverflowAncestors$1(floating)] : [];
   ancestors.forEach((ancestor) => {
     ancestorScroll && ancestor.addEventListener("scroll", update, {
       passive: !0
     }), ancestorResize && ancestor.addEventListener("resize", update);
   });
-  const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;
+  const cleanupIo = referenceEl && layoutShift ? observeMove$1(referenceEl, update) : null;
   let reobserveFrame = -1, resizeObserver = null;
   elementResize && (resizeObserver = new ResizeObserver((_ref) => {
     let [firstEntry] = _ref;
@@ -12540,11 +12478,11 @@ function autoUpdate(reference, floating, update, options) {
       (_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);
     })), update();
   }), referenceEl && !animationFrame && resizeObserver.observe(referenceEl), resizeObserver.observe(floating));
-  let frameId, prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
+  let frameId, prevRefRect = animationFrame ? getBoundingClientRect$1(reference) : null;
   animationFrame && frameLoop();
   function frameLoop() {
-    const nextRefRect = getBoundingClientRect(reference);
-    prevRefRect && !rectsAreEqual(prevRefRect, nextRefRect) && update(), prevRefRect = nextRefRect, frameId = requestAnimationFrame(frameLoop);
+    const nextRefRect = getBoundingClientRect$1(reference);
+    prevRefRect && !rectsAreEqual$1(prevRefRect, nextRefRect) && update(), prevRefRect = nextRefRect, frameId = requestAnimationFrame(frameLoop);
   }
   return update(), () => {
     var _resizeObserver2;
@@ -12553,15 +12491,15 @@ function autoUpdate(reference, floating, update, options) {
     }), cleanupIo?.(), (_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect(), resizeObserver = null, animationFrame && cancelAnimationFrame(frameId);
   };
 }
-const offset$1 = offset$2, autoPlacement = autoPlacement$1, shift$1 = shift$2, flip$1 = flip$2, size$1 = size$2, hide$1 = hide$2, arrow$2 = arrow$3, inline$1 = inline$2, limitShift$1 = limitShift$2, computePosition = (reference, floating, options) => {
+const offset$3 = offset$4, shift$1 = shift$2, flip$1 = flip$2, size$3 = size$4, hide$3 = hide$4, arrow$2 = arrow$3, inline$1 = inline$2, limitShift$1 = limitShift$2, computePosition$2 = (reference, floating, options) => {
   const cache = /* @__PURE__ */ new Map(), mergedOptions = {
-    platform,
+    platform: platform$1,
     ...options
   }, platformWithCache = {
     ...mergedOptions.platform,
     _c: cache
   };
-  return computePosition$1(reference, floating, {
+  return computePosition$3(reference, floating, {
     ...mergedOptions,
     platform: platformWithCache
   });
@@ -12646,7 +12584,7 @@ function useFloating$1(options) {
       strategy,
       middleware: latestMiddleware
     };
-    platformRef.current && (config.platform = platformRef.current), computePosition(referenceRef.current, floatingRef.current, config).then((data3) => {
+    platformRef.current && (config.platform = platformRef.current), computePosition$2(referenceRef.current, floatingRef.current, config).then((data3) => {
       const fullData = {
         ...data3,
         // The floating element's position may be recomputed while it's closed
@@ -12734,8 +12672,8 @@ const arrow$1 = (options) => {
       }).fn(state) : {};
     }
   };
-}, offset = (options, deps) => ({
-  ...offset$1(options),
+}, offset$2 = (options, deps) => ({
+  ...offset$3(options),
   options: [options, deps]
 }), shift = (options, deps) => ({
   ...shift$1(options),
@@ -12746,11 +12684,11 @@ const arrow$1 = (options) => {
 }), flip = (options, deps) => ({
   ...flip$1(options),
   options: [options, deps]
-}), size = (options, deps) => ({
-  ...size$1(options),
+}), size$2 = (options, deps) => ({
+  ...size$3(options),
   options: [options, deps]
-}), hide = (options, deps) => ({
-  ...hide$1(options),
+}), hide$2 = (options, deps) => ({
+  ...hide$3(options),
   options: [options, deps]
 }), inline = (options, deps) => ({
   ...inline$1(options),
@@ -12891,8 +12829,8 @@ function useHover(context2, props) {
     unbindMouseMoveRef.current(), handlerRef.current = void 0;
   }), clearPointerEvents = useEffectEvent(() => {
     if (performedPointerEventsMutationRef.current) {
-      const body2 = getDocument(elements.floating).body;
-      body2.style.pointerEvents = "", body2.removeAttribute(safePolygonIdentifier), performedPointerEventsMutationRef.current = !1;
+      const body = getDocument(elements.floating).body;
+      body.style.pointerEvents = "", body.removeAttribute(safePolygonIdentifier), performedPointerEventsMutationRef.current = !1;
     }
   }), isClickLikeOpenEvent = useEffectEvent(() => dataRef.current.openEvent ? ["click", "mousedown"].includes(dataRef.current.openEvent.type) : !1);
   React.useEffect(() => {
@@ -12947,7 +12885,7 @@ function useHover(context2, props) {
     function onFloatingMouseLeave(event) {
       isClickLikeOpenEvent() || closeWithDelay(event, !1);
     }
-    if (isElement(elements.domReference)) {
+    if (isElement$1(elements.domReference)) {
       const reference2 = elements.domReference, floating = elements.floating;
       return open && reference2.addEventListener("mouseleave", onScrollMouseLeave), move && reference2.addEventListener("mousemove", onReferenceMouseEnter, {
         once: !0
@@ -12960,13 +12898,13 @@ function useHover(context2, props) {
     if (enabled && open && (_handleCloseRef$curre = handleCloseRef.current) != null && (_handleCloseRef$curre = _handleCloseRef$curre.__options) != null && _handleCloseRef$curre.blockPointerEvents && isHoverOpen()) {
       performedPointerEventsMutationRef.current = !0;
       const floatingEl = elements.floating;
-      if (isElement(elements.domReference) && floatingEl) {
+      if (isElement$1(elements.domReference) && floatingEl) {
         var _tree$nodesRef$curren;
-        const body2 = getDocument(elements.floating).body;
-        body2.setAttribute(safePolygonIdentifier, "");
+        const body = getDocument(elements.floating).body;
+        body.setAttribute(safePolygonIdentifier, "");
         const ref = elements.domReference, parentFloating = tree == null || (_tree$nodesRef$curren = tree.nodesRef.current.find((node2) => node2.id === parentId)) == null || (_tree$nodesRef$curren = _tree$nodesRef$curren.context) == null ? void 0 : _tree$nodesRef$curren.elements.floating;
-        return parentFloating && (parentFloating.style.pointerEvents = ""), body2.style.pointerEvents = "none", ref.style.pointerEvents = "auto", floatingEl.style.pointerEvents = "auto", () => {
-          body2.style.pointerEvents = "", ref.style.pointerEvents = "", floatingEl.style.pointerEvents = "";
+        return parentFloating && (parentFloating.style.pointerEvents = ""), body.style.pointerEvents = "none", ref.style.pointerEvents = "auto", floatingEl.style.pointerEvents = "auto", () => {
+          body.style.pointerEvents = "", ref.style.pointerEvents = "", floatingEl.style.pointerEvents = "";
         };
       }
     }
@@ -13154,20 +13092,20 @@ function useDismiss(context2, props) {
     if (endedOrStartedInsideRef.current = !1, outsidePressEvent === "click" && endedOrStartedInside || insideReactTree || typeof outsidePress == "function" && !outsidePress(event))
       return;
     const target = getTarget(event), inertSelector = "[" + createAttribute("inert") + "]", markers = getDocument(elements.floating).querySelectorAll(inertSelector);
-    let targetRootAncestor = isElement(target) ? target : null;
-    for (; targetRootAncestor && !isLastTraversableNode(targetRootAncestor); ) {
-      const nextParent = getParentNode(targetRootAncestor);
-      if (isLastTraversableNode(nextParent) || !isElement(nextParent))
+    let targetRootAncestor = isElement$1(target) ? target : null;
+    for (; targetRootAncestor && !isLastTraversableNode$1(targetRootAncestor); ) {
+      const nextParent = getParentNode$1(targetRootAncestor);
+      if (isLastTraversableNode$1(nextParent) || !isElement$1(nextParent))
         break;
       targetRootAncestor = nextParent;
     }
-    if (markers.length && isElement(target) && !isRootElement(target) && // Clicked on a direct ancestor (e.g. FloatingOverlay).
+    if (markers.length && isElement$1(target) && !isRootElement(target) && // Clicked on a direct ancestor (e.g. FloatingOverlay).
     !contains(target, elements.floating) && // If the target root element contains none of the markers, then the
     // element was injected after the floating element rendered.
     Array.from(markers).every((marker) => !contains(targetRootAncestor, marker)))
       return;
-    if (isHTMLElement$1(target) && floating) {
-      const lastTraversableNode = isLastTraversableNode(target), style2 = getComputedStyle$2(target), scrollRe = /auto|scroll/, isScrollableX = lastTraversableNode || scrollRe.test(style2.overflowX), isScrollableY = lastTraversableNode || scrollRe.test(style2.overflowY), canScrollX = isScrollableX && target.clientWidth > 0 && target.scrollWidth > target.clientWidth, canScrollY = isScrollableY && target.clientHeight > 0 && target.scrollHeight > target.clientHeight, isRTL2 = style2.direction === "rtl", pressedVerticalScrollbar = canScrollY && (isRTL2 ? event.offsetX <= target.offsetWidth - target.clientWidth : event.offsetX > target.clientWidth), pressedHorizontalScrollbar = canScrollX && event.offsetY > target.clientHeight;
+    if (isHTMLElement$2(target) && floating) {
+      const lastTraversableNode = isLastTraversableNode$1(target), style2 = getComputedStyle$3(target), scrollRe = /auto|scroll/, isScrollableX = lastTraversableNode || scrollRe.test(style2.overflowX), isScrollableY = lastTraversableNode || scrollRe.test(style2.overflowY), canScrollX = isScrollableX && target.clientWidth > 0 && target.scrollWidth > target.clientWidth, canScrollY = isScrollableY && target.clientHeight > 0 && target.scrollHeight > target.clientHeight, isRTL2 = style2.direction === "rtl", pressedVerticalScrollbar = canScrollY && (isRTL2 ? event.offsetX <= target.offsetWidth - target.clientWidth : event.offsetX > target.clientWidth), pressedHorizontalScrollbar = canScrollX && event.offsetY > target.clientHeight;
       if (pressedVerticalScrollbar || pressedHorizontalScrollbar)
         return;
     }
@@ -13216,13 +13154,13 @@ function useDismiss(context2, props) {
         },
         // 0ms or 1ms don't work in Safari. 5ms appears to consistently work.
         // Only apply to WebKit for the test to remain 0ms.
-        isWebKit() ? 5 : 0
+        isWebKit$1() ? 5 : 0
       );
     }
     const doc = getDocument(elements.floating);
     escapeKey && (doc.addEventListener("keydown", escapeKeyCapture ? closeOnEscapeKeyDownCapture : closeOnEscapeKeyDown, escapeKeyCapture), doc.addEventListener("compositionstart", handleCompositionStart), doc.addEventListener("compositionend", handleCompositionEnd)), outsidePress && doc.addEventListener(outsidePressEvent, outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);
     let ancestors = [];
-    return ancestorScroll && (isElement(elements.domReference) && (ancestors = getOverflowAncestors(elements.domReference)), isElement(elements.floating) && (ancestors = ancestors.concat(getOverflowAncestors(elements.floating))), !isElement(elements.reference) && elements.reference && elements.reference.contextElement && (ancestors = ancestors.concat(getOverflowAncestors(elements.reference.contextElement)))), ancestors = ancestors.filter((ancestor) => {
+    return ancestorScroll && (isElement$1(elements.domReference) && (ancestors = getOverflowAncestors$1(elements.domReference)), isElement$1(elements.floating) && (ancestors = ancestors.concat(getOverflowAncestors$1(elements.floating))), !isElement$1(elements.reference) && elements.reference && elements.reference.contextElement && (ancestors = ancestors.concat(getOverflowAncestors$1(elements.reference.contextElement)))), ancestors = ancestors.filter((ancestor) => {
       var _doc$defaultView;
       return ancestor !== ((_doc$defaultView = doc.defaultView) == null ? void 0 : _doc$defaultView.visualViewport);
     }), ancestors.forEach((ancestor) => {
@@ -13319,17 +13257,17 @@ function useFloating(options) {
       }
     }
   }), setPositionReference = React.useCallback((node2) => {
-    const computedPositionReference = isElement(node2) ? {
+    const computedPositionReference = isElement$1(node2) ? {
       getBoundingClientRect: () => node2.getBoundingClientRect(),
       getClientRects: () => node2.getClientRects(),
       contextElement: node2
     } : node2;
     _setPositionReference(computedPositionReference), position.refs.setReference(computedPositionReference);
   }, [position.refs]), setReference = React.useCallback((node2) => {
-    (isElement(node2) || node2 === null) && (domReferenceRef.current = node2, setDomReference(node2)), (isElement(position.refs.reference.current) || position.refs.reference.current === null || // Don't allow setting virtual elements using the old technique back to
+    (isElement$1(node2) || node2 === null) && (domReferenceRef.current = node2, setDomReference(node2)), (isElement$1(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.
-    node2 !== null && !isElement(node2)) && position.refs.setReference(node2);
+    node2 !== null && !isElement$1(node2)) && position.refs.setReference(node2);
   }, [position.refs]), refs = React.useMemo(() => ({
     ...position.refs,
     setReference,
@@ -13373,9 +13311,9 @@ function useFocus(context2, props) {
   } = props, blockFocusRef = React.useRef(!1), timeoutRef = React.useRef(-1), keyboardModalityRef = React.useRef(!0);
   React.useEffect(() => {
     if (!enabled) return;
-    const win2 = getWindow(elements.domReference);
+    const win2 = getWindow$1(elements.domReference);
     function onBlur() {
-      !open && isHTMLElement$1(elements.domReference) && elements.domReference === activeElement(getDocument(elements.domReference)) && (blockFocusRef.current = !0);
+      !open && isHTMLElement$2(elements.domReference) && elements.domReference === activeElement(getDocument(elements.domReference)) && (blockFocusRef.current = !0);
     }
     function onKeyDown() {
       keyboardModalityRef.current = !0;
@@ -13407,7 +13345,7 @@ function useFocus(context2, props) {
     onFocus(event) {
       if (blockFocusRef.current) return;
       const target = getTarget(event.nativeEvent);
-      if (visibleOnly && isElement(target)) {
+      if (visibleOnly && isElement$1(target)) {
         if (isMacSafari() && !event.relatedTarget) {
           if (!keyboardModalityRef.current && !isTypeableElement(target))
             return;
@@ -13418,7 +13356,7 @@ function useFocus(context2, props) {
     },
     onBlur(event) {
       blockFocusRef.current = !1;
-      const relatedTarget = event.relatedTarget, nativeEvent = event.nativeEvent, movedToFocusGuard = isElement(relatedTarget) && relatedTarget.hasAttribute(createAttribute("focus-guard")) && relatedTarget.getAttribute("data-type") === "outside";
+      const relatedTarget = event.relatedTarget, nativeEvent = event.nativeEvent, movedToFocusGuard = isElement$1(relatedTarget) && relatedTarget.hasAttribute(createAttribute("focus-guard")) && relatedTarget.getAttribute("data-type") === "outside";
       timeoutRef.current = window.setTimeout(() => {
         var _dataRef$current$floa;
         const activeEl = activeElement(elements.domReference ? elements.domReference.ownerDocument : document);
@@ -14911,7 +14849,7 @@ function getDefaultMiddlewares$1(middlewares) {
   return middlewares.shift === void 0 && (result.shift = !0), middlewares.flip === void 0 && (result.flip = !0), result;
 }
 function getPopoverMiddlewares(options, getFloating, env) {
-  const middlewaresOptions = getDefaultMiddlewares$1(options.middlewares), middlewares = [offset(options.offset), hide()];
+  const middlewaresOptions = getDefaultMiddlewares$1(options.middlewares), middlewares = [offset$2(options.offset), hide$2()];
   return options.dropdownVisible && env !== "test" && options.preventPositionChangeWhenVisible && (middlewaresOptions.flip = !1), middlewaresOptions.flip && middlewares.push(
     typeof middlewaresOptions.flip == "boolean" ? flip() : flip(middlewaresOptions.flip)
   ), middlewaresOptions.shift && middlewares.push(
@@ -14921,7 +14859,7 @@ function getPopoverMiddlewares(options, getFloating, env) {
   ), middlewaresOptions.inline && middlewares.push(
     typeof middlewaresOptions.inline == "boolean" ? inline() : inline(middlewaresOptions.inline)
   ), middlewares.push(arrow({ element: options.arrowRef, padding: options.arrowOffset })), (middlewaresOptions.size || options.width === "target") && middlewares.push(
-    size({
+    size$2({
       ...typeof middlewaresOptions.size == "boolean" ? {} : middlewaresOptions.size,
       apply({ rects, availableWidth, availableHeight, ...rest }) {
         const styles = getFloating().refs.floating.current?.style ?? {};
@@ -14949,11 +14887,11 @@ function usePopover(options) {
     strategy: options.strategy,
     placement: options.preventPositionChangeWhenVisible ? options.positionRef.current : options.position,
     middleware: getPopoverMiddlewares(options, () => floating, env),
-    whileElementsMounted: options.keepMounted ? void 0 : autoUpdate
+    whileElementsMounted: options.keepMounted ? void 0 : autoUpdate$1
   });
   return useEffect(() => {
     if (!(!floating.refs.reference.current || !floating.refs.floating.current) && _opened)
-      return autoUpdate(
+      return autoUpdate$1(
         floating.refs.reference.current,
         floating.refs.floating.current,
         floating.update
@@ -16612,7 +16550,7 @@ const defaultProps$t = {
   refProp: "ref"
 }, ComboboxDropdownTarget = factory((props, ref) => {
   const { children: children2, refProp } = useProps("ComboboxDropdownTarget", defaultProps$t, props);
-  if (useComboboxContext(), !isElement$1(children2))
+  if (useComboboxContext(), !isElement$2(children2))
     throw new Error(
       "Combobox.DropdownTarget component children should be an element or a component that accepts ref. Fragments, strings, numbers and other primitive values are not supported"
     );
@@ -17306,7 +17244,7 @@ const defaultProps$o = {
     vars,
     varsResolver: varsResolver$l
   }), items = Children.toArray(children2).reduce((acc, child, index2, array2) => {
-    const item = isElement$1(child) ? cloneElement(child, {
+    const item = isElement$2(child) ? cloneElement(child, {
       ...getStyles2("breadcrumb", { className: child.props?.className }),
       key: index2
     }) : /* @__PURE__ */ createElement("div", { ...getStyles2("breadcrumb"), key: index2 }, child);
@@ -18297,7 +18235,7 @@ const MenuSubItem = polymorphicFactory((props, ref) => {
 MenuSubItem.classes = classes$c;
 MenuSubItem.displayName = "@mantine/core/MenuSubItem";
 function MenuSubTarget({ children: children2, refProp }) {
-  if (!isElement$1(children2))
+  if (!isElement$2(children2))
     throw new Error(
       "Menu.Sub.Target component children should be an element or a component that accepts ref. Fragments, strings, numbers and other primitive values are not supported"
     );
@@ -18827,7 +18765,7 @@ function useFloatingTooltip({
     if (refs.floating.current) {
       const boundary = boundaryRef.current;
       boundary.addEventListener("mousemove", handleMouseMove);
-      const parents = getOverflowAncestors(refs.floating.current);
+      const parents = getOverflowAncestors$1(refs.floating.current);
       return parents.forEach((parent) => {
         parent.addEventListener("scroll", update);
       }), () => {
@@ -18948,7 +18886,7 @@ function getDefaultMiddlewares(middlewares) {
   return middlewares.shift === void 0 && (result.shift = !0), middlewares.flip === void 0 && (result.flip = !0), result;
 }
 function getTooltipMiddlewares(settings) {
-  const middlewaresOptions = getDefaultMiddlewares(settings.middlewares), middlewares = [offset(settings.offset)];
+  const middlewaresOptions = getDefaultMiddlewares(settings.middlewares), middlewares = [offset$2(settings.offset)];
   return middlewaresOptions.shift && middlewares.push(
     shift(
       typeof middlewaresOptions.shift == "boolean" ? { padding: 8 } : { padding: 8, ...middlewaresOptions.shift }
@@ -18978,7 +18916,7 @@ function useTooltip(settings) {
     open: opened,
     onOpenChange: onChange,
     middleware: getTooltipMiddlewares(settings),
-    whileElementsMounted: autoUpdate
+    whileElementsMounted: autoUpdate$1
   }), { delay: groupDelay, currentId, setCurrentId } = useDelayGroup(context2, { id: uid }), { getReferenceProps, getFloatingProps } = useInteractions([
     useHover(context2, {
       enabled: settings.events?.hover,
@@ -21067,7 +21005,7 @@ class PolyBezier {
     }), new PolyBezier(offset2);
   }
 }
-const { abs, min, max, cos, sin, acos, sqrt } = Math, pi$1 = Math.PI;
+const { abs, min: min$1, max: max$1, cos, sin, acos, sqrt } = Math, pi$1 = Math.PI;
 class Bezier {
   constructor(coords) {
     let args = coords && coords.forEach ? coords : Array.from(arguments).slice(), coordlen = !1;
@@ -21477,7 +21415,7 @@ class Bezier {
     )) : this.selfintersects(curveIntersectionThreshold);
   }
   lineIntersects(line) {
-    const mx = min(line.p1.x, line.p2.x), my = min(line.p1.y, line.p2.y), MX = max(line.p1.x, line.p2.x), MY = max(line.p1.y, line.p2.y);
+    const mx = min$1(line.p1.x, line.p2.x), my = min$1(line.p1.y, line.p2.y), MX = max$1(line.p1.x, line.p2.x), MY = max$1(line.p1.y, line.p2.y);
     return utils.roots(this.points, line).filter((t2) => {
       var p2 = this.get(t2);
       return utils.between(p2.x, mx, MX) && utils.between(p2.y, my, MY);
@@ -22959,7 +22897,7 @@ class JSAnimation extends WithPromise {
       !iterationProgress && progress2 >= 1 && (iterationProgress = 1), iterationProgress === 1 && currentIteration--, currentIteration = Math.min(currentIteration, repeat + 1), currentIteration % 2 && (repeatType === "reverse" ? (iterationProgress = 1 - iterationProgress, repeatDelay && (iterationProgress -= repeatDelay / resolvedDuration)) : repeatType === "mirror" && (frameGenerator = mirroredGenerator)), elapsed = clamp(0, 1, iterationProgress) * resolvedDuration;
     }
     const state = isInDelayPhase ? { done: !1, value: keyframes2[0] } : frameGenerator.next(elapsed);
-    mixKeyframes && (state.value = mixKeyframes(state.value));
+    mixKeyframes && !isInDelayPhase && (state.value = mixKeyframes(state.value));
     let { done } = state;
     !isInDelayPhase && calculatedDuration !== null && (done = this.playbackSpeed >= 0 ? this.currentTime >= totalDuration : this.currentTime <= 0);
     const isAnimationFinished = this.holdTime === null && (this.state === "finished" || this.state === "running" && done);
@@ -22984,15 +22922,14 @@ class JSAnimation extends WithPromise {
     return /* @__PURE__ */ millisecondsToSeconds(this.currentTime);
   }
   set time(newTime) {
-    newTime = /* @__PURE__ */ secondsToMilliseconds(newTime), this.currentTime = newTime, this.startTime === null || this.holdTime !== null || this.playbackSpeed === 0 ? this.holdTime = newTime : this.driver && (this.startTime = this.driver.now() - newTime / this.playbackSpeed), this.driver?.start(!1);
+    newTime = /* @__PURE__ */ secondsToMilliseconds(newTime), this.currentTime = newTime, this.startTime === null || this.holdTime !== null || this.playbackSpeed === 0 ? this.holdTime = newTime : this.driver && (this.startTime = this.driver.now() - newTime / this.playbackSpeed), this.driver ? this.driver.start(!1) : (this.startTime = 0, this.state = "paused", this.holdTime = newTime, this.tick(newTime));
   }
   get speed() {
     return this.playbackSpeed;
   }
   set speed(newSpeed) {
-    this.updateTime(time.now());
     const hasChanged = this.playbackSpeed !== newSpeed;
-    this.playbackSpeed = newSpeed, hasChanged && (this.time = /* @__PURE__ */ millisecondsToSeconds(this.currentTime));
+    hasChanged && this.driver && this.updateTime(time.now()), this.playbackSpeed = newSpeed, hasChanged && this.driver && (this.time = /* @__PURE__ */ millisecondsToSeconds(this.currentTime));
   }
   play() {
     if (this.isStopped)
@@ -23262,7 +23199,7 @@ class NativeAnimation extends WithPromise {
     this.animation = startWaapiAnimation(element, name, keyframes2, transition, pseudoElement), transition.autoplay === !1 && this.animation.pause(), this.animation.onfinish = () => {
       if (this.finishedTime = this.time, !pseudoElement) {
         const keyframe = getFinalKeyframe$1(keyframes2, this.options, finalKeyframe, this.speed);
-        this.updateMotionValue ? this.updateMotionValue(keyframe) : setStyle(element, name, keyframe), this.animation.cancel();
+        this.updateMotionValue && this.updateMotionValue(keyframe), setStyle(element, name, keyframe), this.animation.cancel();
       }
       onComplete?.(), this.notifyFinished();
     };
@@ -23317,7 +23254,8 @@ class NativeAnimation extends WithPromise {
     return /* @__PURE__ */ millisecondsToSeconds(Number(this.animation.currentTime) || 0);
   }
   set time(newTime) {
-    this.manualStartTime = null, this.finishedTime = null, this.animation.currentTime = /* @__PURE__ */ secondsToMilliseconds(newTime);
+    const wasFinished = this.finishedTime !== null;
+    this.manualStartTime = null, this.finishedTime = null, this.animation.currentTime = /* @__PURE__ */ secondsToMilliseconds(newTime), wasFinished && this.animation.pause();
   }
   /**
    * The playback speed of the animation.
@@ -23341,8 +23279,8 @@ class NativeAnimation extends WithPromise {
   /**
    * Attaches a timeline to the animation, for instance the `ScrollTimeline`.
    */
-  attachTimeline({ timeline, observe }) {
-    return this.allowFlatten && this.animation.effect?.updateTiming({ easing: "linear" }), this.animation.onfinish = null, timeline && supportsScrollTimeline() ? (this.animation.timeline = timeline, noop$1) : observe(this);
+  attachTimeline({ timeline, rangeStart, rangeEnd, observe }) {
+    return this.allowFlatten && this.animation.effect?.updateTiming({ easing: "linear" }), this.animation.onfinish = null, timeline && supportsScrollTimeline() ? (this.animation.timeline = timeline, rangeStart && (this.animation.rangeStart = rangeStart), rangeEnd && (this.animation.rangeEnd = rangeEnd), noop$1) : observe(this);
   }
 }
 const unsupportedEasingFunctions = {
@@ -23380,8 +23318,8 @@ class NativeAnimationExtended extends NativeAnimation {
     const sampleAnimation = new JSAnimation({
       ...options,
       autoplay: !1
-    }), sampleTime = Math.max(sampleDelta, time.now() - this.startTime), delta = clamp(0, sampleDelta, sampleTime - sampleDelta);
-    motionValue2.setWithVelocity(sampleAnimation.sample(Math.max(0, sampleTime - delta)).value, sampleAnimation.sample(sampleTime).value, delta), sampleAnimation.stop();
+    }), sampleTime = Math.max(sampleDelta, time.now() - this.startTime), delta = clamp(0, sampleDelta, sampleTime - sampleDelta), current2 = sampleAnimation.sample(sampleTime).value, { name } = this.options;
+    element && name && setStyle(element, name, current2), motionValue2.setWithVelocity(sampleAnimation.sample(Math.max(0, sampleTime - delta)).value, current2, delta), sampleAnimation.stop();
   }
 }
 const isAnimatable = (value, name) => name === "zIndex" ? !1 : !!(typeof value == "number" || Array.isArray(value) || typeof value == "string" && // It's animatable if we have a string
@@ -24329,7 +24267,7 @@ function createEffect(addValue) {
     };
   };
 }
-function isHTMLElement(element) {
+function isHTMLElement$1(element) {
   return isObject(element) && "offsetHeight" in element;
 }
 const translateAlias$1 = {
@@ -24361,7 +24299,7 @@ function buildTransform$1(state) {
 }
 const originProps = /* @__PURE__ */ new Set(["originX", "originY", "originZ"]), addStyleValue = (element, state, key2, value) => {
   let render, computed;
-  return transformProps.has(key2) ? (state.get("transform") || (!isHTMLElement(element) && !state.get("transformBox") && addStyleValue(element, state, "transformBox", new MotionValue("fill-box")), state.set("transform", new MotionValue("none"), () => {
+  return transformProps.has(key2) ? (state.get("transform") || (!isHTMLElement$1(element) && !state.get("transformBox") && addStyleValue(element, state, "transformBox", new MotionValue("fill-box")), state.set("transform", new MotionValue("none"), () => {
     element.style.transform = buildTransform$1(state);
   })), computed = state.get("transform")) : originProps.has(key2) ? (state.get("transformOrigin") || state.set("transformOrigin", new MotionValue(""), () => {
     const originX = state.latest.originX ?? "50%", originY = state.latest.originY ?? "50%", originZ = state.latest.originZ ?? 0;
@@ -24486,7 +24424,7 @@ function press(targetOrSelector, onPressStart, options = {}) {
     window.addEventListener("pointerup", onPointerUp, eventOptions), window.addEventListener("pointercancel", onPointerCancel, eventOptions);
   };
   return targets.forEach((target) => {
-    (options.useGlobalTarget ? window : target).addEventListener("pointerdown", startPress, eventOptions), isHTMLElement(target) && (target.addEventListener("focus", (event) => enableKeyboardPress(event, eventOptions)), !isElementKeyboardAccessible(target) && !target.hasAttribute("tabindex") && (target.tabIndex = 0));
+    (options.useGlobalTarget ? window : target).addEventListener("pointerdown", startPress, eventOptions), isHTMLElement$1(target) && (target.addEventListener("focus", (event) => enableKeyboardPress(event, eventOptions)), !isElementKeyboardAccessible(target) && !target.hasAttribute("tabindex") && (target.tabIndex = 0));
   }), cancelEvents;
 }
 function isSVGElement(element) {
@@ -24990,8 +24928,11 @@ function transformAxis(axis, axisTranslate, axisScale, boxScale, axisOrigin = 0.
   const originPoint = mixNumber$1(axis.min, axis.max, axisOrigin);
   applyAxisDelta(axis, axisTranslate, axisScale, originPoint, boxScale);
 }
+function resolveAxisTranslate(value, axis) {
+  return typeof value == "string" ? parseFloat(value) / 100 * (axis.max - axis.min) : value;
+}
 function transformBox(box, transform2) {
-  transformAxis(box.x, transform2.x, transform2.scaleX, transform2.scale, transform2.originX), transformAxis(box.y, transform2.y, transform2.scaleY, transform2.scale, transform2.originY);
+  transformAxis(box.x, resolveAxisTranslate(transform2.x, box.x), transform2.scaleX, transform2.scale, transform2.originX), transformAxis(box.y, resolveAxisTranslate(transform2.y, box.y), transform2.scaleY, transform2.scale, transform2.originY);
 }
 function measureViewportBox(instance, transformPoint2) {
   return convertBoundingBoxToBox(transformBoxPoints(instance.getBoundingClientRect(), transformPoint2));
@@ -25113,7 +25054,7 @@ function scrapeMotionValuesFromProps$1(props, prevProps, visualElement) {
     (isMotionValue(style2[key2]) || prevStyle && isMotionValue(prevStyle[key2]) || isForcedMotionValue(key2, props) || visualElement?.getValue(key2)?.liveStyle !== void 0) && (newValues[key2] = style2[key2]);
   return newValues;
 }
-function getComputedStyle$1(element) {
+function getComputedStyle$2(element) {
   return window.getComputedStyle(element);
 }
 class HTMLVisualElement extends DOMVisualElement {
@@ -25124,7 +25065,7 @@ class HTMLVisualElement extends DOMVisualElement {
     if (transformProps.has(key2))
       return this.projection?.isProjecting ? defaultTransformValue(key2) : readTransformValue(instance, key2);
     {
-      const computedStyle = getComputedStyle$1(instance), value = (isCSSVariableName(key2) ? computedStyle.getPropertyValue(key2) : computedStyle[key2]) || 0;
+      const computedStyle = getComputedStyle$2(instance), value = (isCSSVariableName(key2) ? computedStyle.getPropertyValue(key2) : computedStyle[key2]) || 0;
       return typeof value == "string" ? value.trim() : value;
     }
   }
@@ -25306,7 +25247,7 @@ function createAnimateFunction(visualElement) {
   return (animations2) => Promise.all(animations2.map(({ animation, options }) => animateVisualElement(visualElement, animation, options)));
 }
 function createAnimationState(visualElement) {
-  let animate2 = createAnimateFunction(visualElement), state = createState(), isInitialRender = !0;
+  let animate2 = createAnimateFunction(visualElement), state = createState(), isInitialRender = !0, wasReset = !1;
   const buildResolvedTypeValues = (type) => (acc, definition) => {
     const resolved = resolveVariant(visualElement, definition, type === "exit" ? visualElement.presenceContext?.custom : void 0);
     if (resolved) {
@@ -25325,7 +25266,7 @@ function createAnimationState(visualElement) {
       const type = reversePriorityOrder[i2], typeState = state[type], prop = props[type] !== void 0 ? props[type] : context2[type], propIsVariant = isVariantLabel(prop), activeDelta = type === changedActiveType ? typeState.isActive : null;
       activeDelta === !1 && (removedVariantIndex = i2);
       let isInherited = prop === context2[type] && prop !== props[type] && propIsVariant;
-      if (isInherited && isInitialRender && visualElement.manuallyAnimateOnMount && (isInherited = !1), typeState.protectedKeys = { ...encounteredKeys }, // If it isn't active and hasn't *just* been set as inactive
+      if (isInherited && (isInitialRender || wasReset) && visualElement.manuallyAnimateOnMount && (isInherited = !1), typeState.protectedKeys = { ...encounteredKeys }, // If it isn't active and hasn't *just* been set as inactive
       !typeState.isActive && activeDelta === null || // If we didn't and don't have any defined prop for this animation type
       !prop && !typeState.prevProp || // Or if the prop doesn't define an animation
       isAnimationControls(prop) || typeof prop == "boolean")
@@ -25359,11 +25300,11 @@ function createAnimationState(visualElement) {
         let valueHasChanged = !1;
         isKeyframesTarget(next) && isKeyframesTarget(prev) ? valueHasChanged = !shallowCompare(next, prev) : valueHasChanged = next !== prev, valueHasChanged ? next != null ? markToAnimate(key2) : removedKeys.add(key2) : next !== void 0 && removedKeys.has(key2) ? markToAnimate(key2) : typeState.protectedKeys[key2] = !0;
       }
-      typeState.prevProp = prop, typeState.prevResolvedValues = resolvedValues, typeState.isActive && (encounteredKeys = { ...encounteredKeys, ...resolvedValues }), isInitialRender && visualElement.blockInitialAnimation && (shouldAnimateType = !1);
+      typeState.prevProp = prop, typeState.prevResolvedValues = resolvedValues, typeState.isActive && (encounteredKeys = { ...encounteredKeys, ...resolvedValues }), (isInitialRender || wasReset) && visualElement.blockInitialAnimation && (shouldAnimateType = !1);
       const willAnimateViaParent = isInherited && variantDidChange;
       shouldAnimateType && (!willAnimateViaParent || handledRemovedValues) && animations2.push(...definitionList.map((animation) => {
         const options = { type };
-        if (typeof animation == "string" && isInitialRender && !willAnimateViaParent && visualElement.manuallyAnimateOnMount && visualElement.parent) {
+        if (typeof animation == "string" && (isInitialRender || wasReset) && !willAnimateViaParent && visualElement.manuallyAnimateOnMount && visualElement.parent) {
           const { parent } = visualElement, parentVariant = resolveVariant(parent, animation);
           if (parent.enteringChildren && parentVariant) {
             const { delayChildren } = parentVariant.transition || {};
@@ -25388,7 +25329,7 @@ function createAnimationState(visualElement) {
       }), animations2.push({ animation: fallbackAnimation });
     }
     let shouldAnimate = !!animations2.length;
-    return isInitialRender && (props.initial === !1 || props.initial === props.animate) && !visualElement.manuallyAnimateOnMount && (shouldAnimate = !1), isInitialRender = !1, shouldAnimate ? animate2(animations2) : Promise.resolve();
+    return isInitialRender && (props.initial === !1 || props.initial === props.animate) && !visualElement.manuallyAnimateOnMount && (shouldAnimate = !1), isInitialRender = !1, wasReset = !1, shouldAnimate ? animate2(animations2) : Promise.resolve();
   }
   function setActive(type, isActive) {
     if (state[type].isActive === isActive)
@@ -25405,7 +25346,7 @@ function createAnimationState(visualElement) {
     setAnimateFunction,
     getState: () => state,
     reset: () => {
-      state = createState();
+      state = createState(), wasReset = !0;
     }
   };
 }
@@ -25576,11 +25517,11 @@ class NodeStack {
   add(node2) {
     addUniqueItem(this.members, node2);
     for (let i2 = this.members.length - 1; i2 >= 0; i2--) {
-      const m3 = this.members[i2];
-      if (m3 === node2 || m3 === this.lead || m3 === this.prevLead)
+      const member = this.members[i2];
+      if (member === node2 || member === this.lead || member === this.prevLead)
         continue;
-      const inst = m3.instance;
-      inst && inst.isConnected === !1 && m3.isPresent !== !1 && !m3.snapshot && removeItem(this.members, m3);
+      const inst = member.instance;
+      (!inst || inst.isConnected === !1) && !member.snapshot && (removeItem(this.members, member), member.unmount());
     }
     node2.scheduleRender();
   }
@@ -25591,49 +25532,31 @@ class NodeStack {
     }
   }
   relegate(node2) {
-    const indexOfNode = this.members.findIndex((member) => node2 === member);
-    if (indexOfNode === 0)
-      return !1;
-    let prevLead;
-    for (let i2 = indexOfNode; i2 >= 0; i2--) {
-      const member = this.members[i2], inst = member.instance;
-      if (member.isPresent !== !1 && (!inst || inst.isConnected !== !1)) {
-        prevLead = member;
-        break;
-      }
+    for (let i2 = this.members.indexOf(node2) - 1; i2 >= 0; i2--) {
+      const member = this.members[i2];
+      if (member.isPresent !== !1 && member.instance?.isConnected !== !1)
+        return this.promote(member), !0;
     }
-    return prevLead ? (this.promote(prevLead), !0) : !1;
+    return !1;
   }
   promote(node2, preserveFollowOpacity) {
     const prevLead = this.lead;
     if (node2 !== prevLead && (this.prevLead = prevLead, this.lead = node2, node2.show(), prevLead)) {
-      prevLead.instance && prevLead.scheduleRender(), node2.scheduleRender();
-      const prevDep = prevLead.options.layoutDependency, nextDep = node2.options.layoutDependency;
-      if (!(prevDep !== void 0 && nextDep !== void 0 && prevDep === nextDep)) {
-        const prevInstance = prevLead.instance;
-        prevInstance && prevInstance.isConnected === !1 && !prevLead.snapshot || (node2.resumeFrom = prevLead, preserveFollowOpacity && (node2.resumeFrom.preserveOpacity = !0), prevLead.snapshot && (node2.snapshot = prevLead.snapshot, node2.snapshot.latestValues = prevLead.animationValues || prevLead.latestValues), node2.root && node2.root.isUpdating && (node2.isLayoutDirty = !0));
-      }
-      const { crossfade } = node2.options;
-      crossfade === !1 && prevLead.hide();
+      prevLead.updateSnapshot(), node2.scheduleRender();
+      const { layoutDependency: prevDep } = prevLead.options, { layoutDependency: nextDep } = node2.options;
+      (prevDep === void 0 || prevDep !== nextDep) && (node2.resumeFrom = prevLead, preserveFollowOpacity && (prevLead.preserveOpacity = !0), prevLead.snapshot && (node2.snapshot = prevLead.snapshot, node2.snapshot.latestValues = prevLead.animationValues || prevLead.latestValues), node2.root?.isUpdating && (node2.isLayoutDirty = !0)), node2.options.crossfade === !1 && prevLead.hide();
     }
   }
   exitAnimationComplete() {
-    this.members.forEach((node2) => {
-      const { options, resumingFrom } = node2;
-      options.onExitComplete && options.onExitComplete(), resumingFrom && resumingFrom.options.onExitComplete && resumingFrom.options.onExitComplete();
+    this.members.forEach((member) => {
+      member.options.onExitComplete?.(), member.resumingFrom?.options.onExitComplete?.();
     });
   }
   scheduleRender() {
-    this.members.forEach((node2) => {
-      node2.instance && node2.scheduleRender(!1);
-    });
+    this.members.forEach((member) => member.instance && member.scheduleRender(!1));
   }
-  /**
-   * Clear any leads that have been removed this render to prevent them from being
-   * used in future animations and to prevent memory leaks
-   */
   removeLeadSnapshot() {
-    this.lead && this.lead.snapshot && (this.lead.snapshot = void 0);
+    this.lead?.snapshot && (this.lead.snapshot = void 0);
   }
 }
 const globalProjectionState = {
@@ -26293,7 +26216,7 @@ class PopChildMeasure extends React.Component {
   getSnapshotBeforeUpdate(prevProps) {
     const element = this.props.childRef.current;
     if (element && prevProps.isPresent && !this.props.isPresent && this.props.pop !== !1) {
-      const parent = element.offsetParent, parentWidth = isHTMLElement(parent) && parent.offsetWidth || 0, parentHeight = isHTMLElement(parent) && parent.offsetHeight || 0, size2 = this.props.sizeRef.current;
+      const parent = element.offsetParent, parentWidth = isHTMLElement$1(parent) && parent.offsetWidth || 0, parentHeight = isHTMLElement$1(parent) && parent.offsetHeight || 0, size2 = this.props.sizeRef.current;
       size2.height = element.offsetHeight || 0, size2.width = element.offsetWidth || 0, size2.top = element.offsetTop, size2.left = element.offsetLeft, size2.right = parentWidth - size2.width - size2.left, size2.bottom = parentHeight - size2.height - size2.top;
     }
     return null;
@@ -26726,7 +26649,7 @@ function useMotionRef(visualState, visualElement, externalRef) {
   });
   const refCleanup = useRef(null);
   return useCallback((instance) => {
-    instance && visualState.onMount?.(instance), visualElement && (instance ? visualElement.mount(instance) : visualElement.unmount());
+    instance && visualState.onMount?.(instance);
     const ref = externalRefContainer.current;
     if (typeof ref == "function")
       if (instance) {
@@ -26734,6 +26657,7 @@ function useMotionRef(visualState, visualElement, externalRef) {
         typeof cleanup == "function" && (refCleanup.current = cleanup);
       } else refCleanup.current ? (refCleanup.current(), refCleanup.current = null) : ref(instance);
     else ref && (ref.current = instance);
+    visualElement && (instance ? visualElement.mount(instance) : visualElement.unmount());
   }, [visualElement]);
 }
 const SwitchLayoutGroupContext = createContext({});
@@ -26758,7 +26682,7 @@ function useVisualElement(Component2, visualState, props, createVisualElement, P
   useInsertionEffect$1(() => {
     visualElement && isMounted.current && visualElement.update(props, presenceContext);
   });
-  const optimisedAppearId = props[optimizedAppearDataAttribute], wantsHandoff = useRef(!!optimisedAppearId && !window.MotionHandoffIsComplete?.(optimisedAppearId) && window.MotionHasOptimisedAnimation?.(optimisedAppearId));
+  const optimisedAppearId = props[optimizedAppearDataAttribute], wantsHandoff = useRef(!!optimisedAppearId && typeof window < "u" && !window.MotionHandoffIsComplete?.(optimisedAppearId) && window.MotionHasOptimisedAnimation?.(optimisedAppearId));
   return useIsomorphicLayoutEffect(() => {
     hasMountedOnce.current = !0, visualElement && (isMounted.current = !0, window.MotionIsMounted = !0, visualElement.updateFeatures(), visualElement.scheduleRenderMicrotask(), wantsHandoff.current && visualElement.animationState && visualElement.animationState.animateChanges());
   }), useEffect(() => {
@@ -26802,7 +26726,7 @@ function createMotionComponent(Component2, { forwardMotionProps = !1, type } = {
       ...props,
       layoutId: useLayoutId(props)
     }, { isStatic } = configAndProps, context2 = useCreateMotionContext(props), visualState = useVisualState(props, isStatic);
-    if (!isStatic && isBrowser$1) {
+    if (!isStatic && typeof window < "u") {
       useStrictMode();
       const layoutProjection = getProjectionFunctionality(configAndProps);
       MeasureLayout2 = layoutProjection.MeasureLayout, context2.visualElement = useVisualElement(Component2, visualState, configAndProps, createVisualElement, layoutProjection.ProjectionNode, isSVG);
@@ -27827,9 +27751,10 @@ function createScopedAnimate(options = {}) {
   const { scope, reduceMotion } = options;
   function scopedAnimate(subjectOrSequence, optionsOrKeyframes, options2) {
     let animations2 = [], animationOnComplete;
-    if (isSequence(subjectOrSequence))
-      animations2 = animateSequence(subjectOrSequence, reduceMotion !== void 0 ? { reduceMotion, ...optionsOrKeyframes } : optionsOrKeyframes, scope);
-    else {
+    if (isSequence(subjectOrSequence)) {
+      const { onComplete, ...sequenceOptions } = optionsOrKeyframes || {};
+      typeof onComplete == "function" && (animationOnComplete = onComplete), animations2 = animateSequence(subjectOrSequence, reduceMotion !== void 0 ? { reduceMotion, ...sequenceOptions } : sequenceOptions, scope);
+    } else {
       const { onComplete, ...rest } = options2 || {};
       typeof onComplete == "function" && (animationOnComplete = onComplete), animations2 = animateSubject(subjectOrSequence, optionsOrKeyframes, reduceMotion !== void 0 ? { reduceMotion, ...rest } : rest, scope);
     }
@@ -40034,7 +39959,7 @@ const Logo$1 = forwardRef(
     }
   ) }) : null;
 };
-function SearchControl() {
+function SearchControl$1() {
   const diagram = useDiagram(), isMac2 = isMacOs();
   return /* @__PURE__ */ jsxs(
     UnstyledButton,
@@ -40497,7 +40422,7 @@ const selectBreadcrumbs = ({ context: context2 }) => {
       "actions"
     ),
     enableDynamicViewWalkthrough && isDynamicView && /* @__PURE__ */ jsx(DynamicViewControls, {}, "dynamic-view-controls"),
-    enableSearch && !enableCompareWithLatest && /* @__PURE__ */ jsx(SearchControl, {}, "search-control"),
+    enableSearch && !enableCompareWithLatest && /* @__PURE__ */ jsx(SearchControl$1, {}, "search-control"),
     /* @__PURE__ */ jsx(LayoutWarning, {}, "outdated-manual-layout-warning")
   ] });
 });
@@ -41209,7 +41134,7 @@ const useElementDetailsActorRef = () => {
   if (ctx === null)
     throw new Error("ElementDetailsActorRef is not provided");
   return ctx;
-}, backdropBlur$1 = "--_blur", backdropOpacity$1 = "--_opacity", dialog$1 = css({
+}, backdropBlur$1 = "--_blur", backdropOpacity$1 = "--_opacity", dialog = css({
   boxSizing: "border-box",
   margin: "0",
   padding: "0",
@@ -42173,7 +42098,7 @@ const node = css({
       color: "white"
     }
   }
-}), scrollArea$2 = css({
+}), scrollArea$1 = css({
   maxHeight: [
     "70vh",
     "calc(100cqh - 70px)"
@@ -42182,7 +42107,7 @@ const node = css({
   __proto__: null,
   label,
   node,
-  scrollArea: scrollArea$2
+  scrollArea: scrollArea$1
 }, Symbol.toStringTag, { value: "Module" })), selector2$1 = (state) => {
   const subjectExistsInScope = state.context.layouted?.subjectExistsInScope ?? !1;
   return {
@@ -42246,7 +42171,7 @@ const node = css({
                 children: /* @__PURE__ */ jsx(Text, { fz: "xs", fw: "500", truncate: !0, children: subject?.title ?? "???" })
               }
             ) }),
-            /* @__PURE__ */ jsx(PopoverDropdown, { p: 0, miw: 250, maw: 400, children: /* @__PURE__ */ jsx(ScrollAreaAutosize, { scrollbars: "y", type: "never", viewportRef: viewport, className: scrollArea$2, children: /* @__PURE__ */ jsx(
+            /* @__PURE__ */ jsx(PopoverDropdown, { p: 0, miw: 250, maw: 400, children: /* @__PURE__ */ jsx(ScrollAreaAutosize, { scrollbars: "y", type: "never", viewportRef: viewport, className: scrollArea$1, children: /* @__PURE__ */ jsx(
               Tree,
               {
                 allowRangeSelection: !1,
@@ -43007,7 +42932,7 @@ function ElementDetailsCard({
     m$2.dialog,
     {
       ref,
-      className: cx(dialog$1, ReactRemoveScroll.classNames.fullWidth),
+      className: cx(dialog, ReactRemoveScroll.classNames.fullWidth),
       layout: !0,
       initial: {
         [backdropBlur$1]: "0px",
@@ -44052,7 +43977,7 @@ css({
   alignItems: "baseline",
   justifyItems: "start"
 });
-const scrollArea$1 = css({
+const scrollArea = css({
   maxHeight: [
     "70vh",
     "calc(100cqh - 70px)"
@@ -44122,7 +44047,7 @@ const scrollArea$1 = css({
             ]
           }
         ) }),
-        /* @__PURE__ */ jsx(PopoverDropdown, { p: 0, miw: 250, maw: 400, children: /* @__PURE__ */ jsx(ScrollAreaAutosize, { className: scrollArea$1, scrollbars: "y", type: "never", viewportRef: viewport, children: /* @__PURE__ */ jsx(Box$1, { className: edgeGrid, p: "xs", maw: 400, children: edges.map((e2) => /* @__PURE__ */ jsxs(
+        /* @__PURE__ */ jsx(PopoverDropdown, { p: 0, miw: 250, maw: 400, children: /* @__PURE__ */ jsx(ScrollAreaAutosize, { className: scrollArea, scrollbars: "y", type: "never", viewportRef: viewport, children: /* @__PURE__ */ jsx(Box$1, { className: edgeGrid, p: "xs", maw: 400, children: edges.map((e2) => /* @__PURE__ */ jsxs(
           "div",
           {
             className: edgeRow,
@@ -44433,32 +44358,27 @@ const select = (s2) => s2.children.search ?? null;
 function useSearchActorRef() {
   return useDiagramSnapshot(select, Object.is);
 }
-function useSearchActor() {
-  const searchActorRef = useSearchActorRef();
-  if (!searchActorRef)
-    throw new Error("Search actor not found");
-  return searchActorRef;
+const SearchContext = createContext(null);
+function useSearchContext() {
+  const ctx = useContext(SearchContext);
+  if (!ctx)
+    throw new Error("useSearchContext must be used within a SearchContext.Provider");
+  return ctx;
 }
-const selectSearchValue = (s2) => s2.context.searchValue;
-function useSearch() {
-  const searchActorRef = useSearchActor(), searchValue = xstateReact_cjsExports.useSelector(searchActorRef, selectSearchValue), updateSearch = useCallback((search) => {
-    searchActorRef.send({ type: "change.search", search });
-  }, [searchActorRef]);
-  return [searchValue, updateSearch];
+function normalizeSearch(value) {
+  if (value === "") return value;
+  const v2 = value.trim().toLowerCase();
+  return v2.startsWith("#") && v2.length <= 2 ? "" : v2.length > 1 ? v2 : "";
 }
-const selectNormalizedSearchValue = (s2) => {
-  let v2 = selectSearchValue(s2);
-  return v2 === "" ? v2 : (v2 = v2.trim().toLowerCase(), v2.startsWith("#") && v2.length <= 2 ? "" : v2.length > 1 ? v2 : "");
-};
 function useNormalizedSearch() {
-  const searchActorRef = useSearchActor();
-  return useDeferredValue(xstateReact_cjsExports.useSelector(searchActorRef, selectNormalizedSearchValue));
+  const ctx = useSearchContext();
+  return useDeferredValue(ctx.normalizedSearch);
 }
 function useUpdateSearch() {
-  const searchActorRef = useSearchActor();
+  const { setSearchValue } = useSearchContext();
   return useCallback((search) => {
-    searchActorRef.send({ type: "change.search", search });
-  }, [searchActorRef]);
+    setSearchValue(search);
+  }, [setSearchValue]);
 }
 const buttonFocused = css.raw({
   outline: "none",
@@ -44728,7 +44648,7 @@ css({
   }
 });
 const NothingFound = () => /* @__PURE__ */ jsx(Box, { className: emptyBoX, children: "Nothing found" }), useFoundViews = () => {
-  const currentViewId = useCurrentViewId(), likec4model = useLikeC4Model(), search = useNormalizedSearch();
+  const { currentViewId } = useSearchContext(), likec4model = useLikeC4Model(), search = useNormalizedSearch();
   return useMemo(() => {
     let views = [...likec4model.views()];
     if (search)
@@ -44778,7 +44698,7 @@ const NothingFound = () => /* @__PURE__ */ jsx(Box, { className: emptyBoX, child
           ViewButton,
           {
             view,
-            currentViewId,
+            currentViewId: currentViewId ?? "",
             search,
             tabIndex: i2 === 0 ? 0 : -1
           }
@@ -44788,12 +44708,8 @@ const NothingFound = () => /* @__PURE__ */ jsx(Box, { className: emptyBoX, child
   );
 }), btn$1 = buttonsva();
 function ViewButton({ className, view, loop = !1, search, focusOnElement, currentViewId, ...props }) {
-  const searchActorRef = useSearchActor(), nextViewId = view.id, isCurrentView = nextViewId === currentViewId, navigate = () => {
-    searchActorRef.send({
-      type: "navigate.to",
-      viewId: nextViewId,
-      focusOnElement
-    });
+  const ctx = useSearchContext(), nextViewId = view.id, isCurrentView = nextViewId === currentViewId, navigate = () => {
+    ctx.navigateTo(nextViewId, focusOnElement);
   };
   return /* @__PURE__ */ jsxs(
     UnstyledButton,
@@ -45049,21 +44965,17 @@ function ElementTreeNode({ node: node2, elementProps, hasChildren, expanded, han
   ] });
 }
 function useHandleElementSelection() {
-  const searchActorRef = useSearchActor();
+  const ctx = useSearchContext();
   return useCallbackRef((element) => {
     const views = [...element.views()];
     if (views.length === 0)
       return;
     const elementFqn = element.id, onlyOneViewId = t$a(views)?.id;
     if (!onlyOneViewId) {
-      searchActorRef.send({ type: "pickview.open", elementFqn });
+      ctx.openPickView(elementFqn);
       return;
     }
-    searchActorRef.send({
-      type: "navigate.to",
-      viewId: onlyOneViewId,
-      focusOnElement: elementFqn
-    });
+    ctx.navigateTo(onlyOneViewId, elementFqn);
   });
 }
 const input = css({
@@ -45120,14 +45032,13 @@ css({
   }
 });
 function PickView({
-  searchActorRef,
   elementFqn
 }) {
-  const currentViewId = useCurrentViewId(), element = useLikeC4Model().element(elementFqn), scoped = [], others = [];
+  const ctx = useSearchContext(), currentViewId = ctx.currentViewId ?? "", element = useLikeC4Model().element(elementFqn), scoped = [], others = [];
   for (const view of element.views())
     view.viewOf === element ? scoped.push(view) : others.push(view);
   const closePickView = () => {
-    searchActorRef.send({ type: "pickview.close" });
+    ctx.closePickView();
   };
   return useWindowEvent(
     "keydown",
@@ -45309,7 +45220,7 @@ function startingWithKind(search) {
   return search.match(/^(k|ki|kin|kind|kind:)$/) != null;
 }
 const SEARCH_PREFIXES = ["#", "kind:"], LikeC4SearchInput = memo$2(() => {
-  const searchActorRef = useSearchActor(), likec4model = useLikeC4Model(), inputRef = useRef(null), { ref, focused: focused2 } = useFocusWithin(), [search, setSearch] = useSearch(), combobox = useCombobox({
+  const searchCtx = useSearchContext(), likec4model = useLikeC4Model(), inputRef = useRef(null), { ref, focused: focused2 } = useFocusWithin(), { searchValue: search, setSearchValue: setSearch } = searchCtx, combobox = useCombobox({
     scrollBehavior: "smooth",
     loop: !1
   });
@@ -45394,9 +45305,7 @@ const SEARCH_PREFIXES = ["#", "kind:"], LikeC4SearchInput = memo$2(() => {
               Input.ClearButton,
               {
                 onClick: (e2) => {
-                  e2.stopPropagation();
-                  const openedWithSearch = searchActorRef.getSnapshot().context.openedWithSearch;
-                  search === "" || search === openedWithSearch ? searchActorRef.send({ type: "close" }) : setSearch("");
+                  e2.stopPropagation(), search === "" || search === searchCtx.openedWithSearch ? searchCtx.close() : setSearch("");
                 }
               }
             ),
@@ -45447,23 +45356,58 @@ const SEARCH_PREFIXES = ["#", "kind:"], LikeC4SearchInput = memo$2(() => {
       ]
     }
   );
-}), dialog = css({
+}), selectSearchValue = (s2) => s2.context.searchValue, selectPickViewFor = (s2) => s2.context.pickViewFor, selectOpenedWithSearch = (s2) => s2.context.openedWithSearch;
+function XStateSearchAdapter({
+  searchActorRef,
+  children: children2
+}) {
+  const searchValue = xstateReact_cjsExports.useSelector(searchActorRef, selectSearchValue), pickViewFor = xstateReact_cjsExports.useSelector(searchActorRef, selectPickViewFor), openedWithSearch = xstateReact_cjsExports.useSelector(searchActorRef, selectOpenedWithSearch), currentViewId = useCurrentViewId(), setSearchValue = useCallbackRef((search) => {
+    searchActorRef.send({ type: "change.search", search });
+  }), navigateTo = useCallbackRef((viewId, focusOnElement) => {
+    searchActorRef.send({
+      type: "navigate.to",
+      viewId,
+      focusOnElement
+    });
+  }), openPickView = useCallbackRef((elementFqn) => {
+    searchActorRef.send({ type: "pickview.open", elementFqn });
+  }), closePickView = useCallbackRef(() => {
+    searchActorRef.send({ type: "pickview.close" });
+  }), close = useCallbackRef(() => {
+    searchActorRef.send({ type: "close" });
+  }), value = useMemo(() => ({
+    searchValue,
+    setSearchValue,
+    normalizedSearch: normalizeSearch(searchValue),
+    navigateTo,
+    openPickView,
+    closePickView,
+    pickViewFor,
+    close,
+    currentViewId,
+    openedWithSearch
+  }), [
+    searchValue,
+    pickViewFor,
+    currentViewId,
+    openedWithSearch,
+    // stable refs from useCallbackRef — listed for exhaustive-deps lint rule
+    setSearchValue,
+    navigateTo,
+    openPickView,
+    closePickView,
+    close
+  ]);
+  return /* @__PURE__ */ jsx(SearchContext.Provider, { value, children: children2 });
+}
+const dialogCss = css({
   backgroundColor: "[rgb(34 34 34 / var(--_opacity, 95%))]",
   _light: {
     backgroundColor: "[rgb(250 250 250 / var(--_opacity, 95%))]"
   },
   backdropFilter: "auto",
   backdropBlur: "var(--_blur, 10px)"
-  //   base: `[rgb(34 34 34 / var(${backdropOpacity}))]`,
-  //   _light: `[rgb(255 255 255/ var(${backdropOpacity}))]`,
-  // },
-}), body = css({
-  // containerName: 'likec4-search',
-  // containerType: 'size',
-  // position: 'fixed',
-  // zIndex: 901,
-  // top: '0',
-  // left: '0',
+}), bodyCss = css({
   width: "100%",
   height: "100%",
   maxHeight: "100vh",
@@ -45477,11 +45421,7 @@ const SEARCH_PREFIXES = ["#", "kind:"], LikeC4SearchInput = memo$2(() => {
   paddingRight: "md",
   paddingBottom: "sm",
   background: "transparent"
-  // backgroundColor: {
-  //   _dark: `[rgb(34 34 34 / 0.95)]`,
-  //   _light: `[rgb(255 255 255/ 0.95)]`,
-  // },
-}), scrollArea = css({
+}), scrollAreaCss = css({
   height: [
     "100%",
     "100cqh"
@@ -45524,33 +45464,20 @@ const SEARCH_PREFIXES = ["#", "kind:"], LikeC4SearchInput = memo$2(() => {
         opacity: 0.9
       },
       classes: {
-        dialog,
-        body
+        dialog: dialogCss,
+        body: bodyCss
       },
       openDelay: 0,
       onClose: close,
       "data-likec4-search": "true",
-      children: /* @__PURE__ */ jsx(SearchOverlayBody, { searchActorRef })
+      children: /* @__PURE__ */ jsx(XStateSearchAdapter, { searchActorRef, children: /* @__PURE__ */ jsx(SearchOverlayBody, { searchActorRef }) })
     }
   ) });
 });
 Search.displayName = "Search";
-const selectPickViewFor = (s2) => s2.context.pickViewFor, SearchOverlayBody = memo$2(({ searchActorRef }) => {
-  const ref = useRef(null), pickViewFor = xstateReact_cjsExports.useSelector(searchActorRef, selectPickViewFor);
-  useTimeoutEffect(() => {
-    e$1(searchActorRef.getSnapshot().context.openedWithSearch) && focusToFirstFoundElement(ref.current);
-  }, 150);
-  const [isPresent, safeToRemove] = usePresence();
-  return useEffect(() => {
-    if (!isPresent) {
-      safeToRemove();
-      try {
-        searchActorRef.send({ type: "animation.presence.end" });
-      } catch (e2) {
-        console.debug("SearchOverlayBody: animation.presence.end failed", e2);
-      }
-    }
-  }, [isPresent, searchActorRef, safeToRemove]), /* @__PURE__ */ jsxs(Box, { ref, display: "contents", children: [
+const SearchPanelContent = memo$2(() => {
+  const ref = useRef(null), { pickViewFor } = useSearchContext();
+  return /* @__PURE__ */ jsxs(Box, { ref, display: "contents", children: [
     /* @__PURE__ */ jsx(
       Group,
       {
@@ -45583,7 +45510,7 @@ const selectPickViewFor = (s2) => s2.context.pickViewFor, SearchOverlayBody = me
             ScrollArea,
             {
               type: "scroll",
-              className: scrollArea,
+              className: scrollAreaCss,
               pr: "xs",
               scrollbars: "y",
               children: /* @__PURE__ */ jsx(LayoutGroup, { id: "likec4-search-elements", children: /* @__PURE__ */ jsx(Suspense, { children: /* @__PURE__ */ jsx(ElementsColumn, {}) }) })
@@ -45593,7 +45520,7 @@ const selectPickViewFor = (s2) => s2.context.pickViewFor, SearchOverlayBody = me
             ScrollArea,
             {
               type: "scroll",
-              className: scrollArea,
+              className: scrollAreaCss,
               pr: "xs",
               scrollbars: "y",
               children: /* @__PURE__ */ jsx(Suspense, { children: /* @__PURE__ */ jsx(LayoutGroup, { id: "likec4-search-views", children: /* @__PURE__ */ jsx(ViewsColumn, {}) }) })
@@ -45602,9 +45529,980 @@ const selectPickViewFor = (s2) => s2.context.pickViewFor, SearchOverlayBody = me
         ]
       }
     ),
-    pickViewFor && /* @__PURE__ */ jsx(PickView, { searchActorRef, elementFqn: pickViewFor })
+    pickViewFor && /* @__PURE__ */ jsx(PickView, { elementFqn: pickViewFor })
   ] });
 });
+SearchPanelContent.displayName = "SearchPanelContent";
+const SearchOverlayBody = memo$2(function({ searchActorRef }) {
+  const ref = useRef(null);
+  useTimeoutEffect(() => {
+    e$1(searchActorRef.getSnapshot().context.openedWithSearch) && focusToFirstFoundElement(ref.current);
+  }, 150);
+  const [isPresent, safeToRemove] = usePresence();
+  return useEffect(() => {
+    if (!isPresent) {
+      safeToRemove();
+      try {
+        searchActorRef.send({ type: "animation.presence.end" });
+      } catch (e2) {
+        console.debug("SearchOverlayBody: animation.presence.end failed", e2);
+      }
+    }
+  }, [isPresent, searchActorRef, safeToRemove]), /* @__PURE__ */ jsx(Box, { ref, display: "contents", children: /* @__PURE__ */ jsx(SearchPanelContent, {}) });
+}), sides = ["top", "right", "bottom", "left"], alignments = ["start", "end"], placements = /* @__PURE__ */ sides.reduce((acc, side) => acc.concat(side, side + "-" + alignments[0], side + "-" + alignments[1]), []), min = Math.min, max = Math.max, round = Math.round, floor = Math.floor, createCoords = (v2) => ({
+  x: v2,
+  y: v2
+}), oppositeSideMap = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+};
+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) {
+  const firstChar = placement[0];
+  return firstChar === "t" || firstChar === "b" ? "y" : "x";
+}
+function getAlignmentAxis(placement) {
+  return getOppositeAxis(getSideAxis(placement));
+}
+function getAlignmentSides(placement, rects, rtl) {
+  rtl === void 0 && (rtl = !1);
+  const alignment = getAlignment(placement), alignmentAxis = getAlignmentAxis(placement), length = getAxisLength(alignmentAxis);
+  let mainAlignmentSide = alignmentAxis === "x" ? alignment === (rtl ? "end" : "start") ? "right" : "left" : alignment === "start" ? "bottom" : "top";
+  return rects.reference[length] > rects.floating[length] && (mainAlignmentSide = getOppositePlacement(mainAlignmentSide)), [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
+}
+function getOppositeAlignmentPlacement(placement) {
+  return placement.includes("start") ? placement.replace("start", "end") : placement.replace("end", "start");
+}
+function getOppositePlacement(placement) {
+  const side = getSide(placement);
+  return oppositeSideMap[side] + placement.slice(side.length);
+}
+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: x2,
+    y: y2,
+    width,
+    height
+  } = rect;
+  return {
+    width,
+    height,
+    top: y2,
+    left: x2,
+    right: x2 + width,
+    bottom: y2 + height,
+    x: x2,
+    y: y2
+  };
+}
+function computeCoordsFromPlacement(_ref, placement, rtl) {
+  let {
+    reference,
+    floating
+  } = _ref;
+  const sideAxis = getSideAxis(placement), alignmentAxis = getAlignmentAxis(placement), alignLength = getAxisLength(alignmentAxis), side = getSide(placement), isVertical = sideAxis === "y", commonX = reference.x + reference.width / 2 - floating.width / 2, commonY = reference.y + reference.height / 2 - floating.height / 2, 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;
+}
+async function detectOverflow(state, options) {
+  var _await$platform$isEle;
+  options === void 0 && (options = {});
+  const {
+    x: x2,
+    y: y2,
+    platform: platform2,
+    rects,
+    elements,
+    strategy
+  } = state, {
+    boundary = "clippingAncestors",
+    rootBoundary = "viewport",
+    elementContext = "floating",
+    altBoundary = !1,
+    padding = 0
+  } = evaluate(options, state), paddingObject = getPaddingObject(padding), element = elements[altBoundary ? elementContext === "floating" ? "reference" : "floating" : elementContext], clippingClientRect = rectToClientRect(await platform2.getClippingRect({
+    element: (_await$platform$isEle = await (platform2.isElement == null ? void 0 : platform2.isElement(element))) == null || _await$platform$isEle ? element : element.contextElement || await (platform2.getDocumentElement == null ? void 0 : platform2.getDocumentElement(elements.floating)),
+    boundary,
+    rootBoundary,
+    strategy
+  })), rect = elementContext === "floating" ? {
+    x: x2,
+    y: y2,
+    width: rects.floating.width,
+    height: rects.floating.height
+  } : rects.reference, offsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(elements.floating)), 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
+  }, 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 MAX_RESET_COUNT = 50, computePosition$1 = async (reference, floating, config) => {
+  const {
+    placement = "bottom",
+    strategy = "absolute",
+    middleware = [],
+    platform: platform2
+  } = config, platformWithDetectOverflow = platform2.detectOverflow ? platform2 : {
+    ...platform2,
+    detectOverflow
+  }, rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(floating));
+  let rects = await platform2.getElementRects({
+    reference,
+    floating,
+    strategy
+  }), {
+    x: x2,
+    y: y2
+  } = computeCoordsFromPlacement(rects, placement, rtl), statefulPlacement = placement, resetCount = 0;
+  const middlewareData = {};
+  for (let i2 = 0; i2 < middleware.length; i2++) {
+    const currentMiddleware = middleware[i2];
+    if (!currentMiddleware)
+      continue;
+    const {
+      name,
+      fn
+    } = currentMiddleware, {
+      x: nextX,
+      y: nextY,
+      data: data2,
+      reset
+    } = await fn({
+      x: x2,
+      y: y2,
+      initialPlacement: placement,
+      placement: statefulPlacement,
+      strategy,
+      middlewareData,
+      rects,
+      platform: platformWithDetectOverflow,
+      elements: {
+        reference,
+        floating
+      }
+    });
+    x2 = nextX ?? x2, y2 = nextY ?? y2, middlewareData[name] = {
+      ...middlewareData[name],
+      ...data2
+    }, reset && resetCount < MAX_RESET_COUNT && (resetCount++, typeof reset == "object" && (reset.placement && (statefulPlacement = reset.placement), reset.rects && (rects = reset.rects === !0 ? await platform2.getElementRects({
+      reference,
+      floating,
+      strategy
+    }) : reset.rects), {
+      x: x2,
+      y: y2
+    } = computeCoordsFromPlacement(rects, statefulPlacement, rtl)), i2 = -1);
+  }
+  return {
+    x: x2,
+    y: y2,
+    placement: statefulPlacement,
+    strategy,
+    middlewareData
+  };
+};
+function getPlacementList(alignment, autoAlignment, allowedPlacements) {
+  return (alignment ? [...allowedPlacements.filter((placement) => getAlignment(placement) === alignment), ...allowedPlacements.filter((placement) => getAlignment(placement) !== alignment)] : allowedPlacements.filter((placement) => getSide(placement) === placement)).filter((placement) => alignment ? getAlignment(placement) === alignment || (autoAlignment ? getOppositeAlignmentPlacement(placement) !== placement : !1) : !0);
+}
+const autoPlacement$1 = function(options) {
+  return options === void 0 && (options = {}), {
+    name: "autoPlacement",
+    options,
+    async fn(state) {
+      var _middlewareData$autoP, _middlewareData$autoP2, _placementsThatFitOnE;
+      const {
+        rects,
+        middlewareData,
+        placement,
+        platform: platform2,
+        elements
+      } = state, {
+        crossAxis = !1,
+        alignment,
+        allowedPlacements = placements,
+        autoAlignment = !0,
+        ...detectOverflowOptions
+      } = evaluate(options, state), placements$1 = alignment !== void 0 || allowedPlacements === placements ? getPlacementList(alignment || null, autoAlignment, allowedPlacements) : allowedPlacements, overflow = await platform2.detectOverflow(state, detectOverflowOptions), currentIndex = ((_middlewareData$autoP = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP.index) || 0, currentPlacement = placements$1[currentIndex];
+      if (currentPlacement == null)
+        return {};
+      const alignmentSides = getAlignmentSides(currentPlacement, rects, await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating)));
+      if (placement !== currentPlacement)
+        return {
+          reset: {
+            placement: placements$1[0]
+          }
+        };
+      const currentOverflows = [overflow[getSide(currentPlacement)], overflow[alignmentSides[0]], overflow[alignmentSides[1]]], allOverflows = [...((_middlewareData$autoP2 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP2.overflows) || [], {
+        placement: currentPlacement,
+        overflows: currentOverflows
+      }], nextPlacement = placements$1[currentIndex + 1];
+      if (nextPlacement)
+        return {
+          data: {
+            index: currentIndex + 1,
+            overflows: allOverflows
+          },
+          reset: {
+            placement: nextPlacement
+          }
+        };
+      const placementsSortedByMostSpace = allOverflows.map((d2) => {
+        const alignment2 = getAlignment(d2.placement);
+        return [d2.placement, alignment2 && crossAxis ? (
+          // Check along the mainAxis and main crossAxis side.
+          d2.overflows.slice(0, 2).reduce((acc, v2) => acc + v2, 0)
+        ) : (
+          // Check only the mainAxis.
+          d2.overflows[0]
+        ), d2.overflows];
+      }).sort((a2, b2) => a2[1] - b2[1]), resetPlacement = ((_placementsThatFitOnE = placementsSortedByMostSpace.filter((d2) => d2[2].slice(
+        0,
+        // Aligned placements should not check their opposite crossAxis
+        // side.
+        getAlignment(d2[0]) ? 2 : 3
+      ).every((v2) => v2 <= 0))[0]) == null ? void 0 : _placementsThatFitOnE[0]) || placementsSortedByMostSpace[0][0];
+      return resetPlacement !== placement ? {
+        data: {
+          index: currentIndex + 1,
+          overflows: allOverflows
+        },
+        reset: {
+          placement: resetPlacement
+        }
+      } : {};
+    }
+  };
+};
+function getSideOffsets(overflow, rect) {
+  return {
+    top: overflow.top - rect.height,
+    right: overflow.right - rect.width,
+    bottom: overflow.bottom - rect.height,
+    left: overflow.left - rect.width
+  };
+}
+function isAnySideFullyClipped(overflow) {
+  return sides.some((side) => overflow[side] >= 0);
+}
+const hide$1 = function(options) {
+  return options === void 0 && (options = {}), {
+    name: "hide",
+    options,
+    async fn(state) {
+      const {
+        rects,
+        platform: platform2
+      } = state, {
+        strategy = "referenceHidden",
+        ...detectOverflowOptions
+      } = evaluate(options, state);
+      switch (strategy) {
+        case "referenceHidden": {
+          const overflow = await platform2.detectOverflow(state, {
+            ...detectOverflowOptions,
+            elementContext: "reference"
+          }), offsets = getSideOffsets(overflow, rects.reference);
+          return {
+            data: {
+              referenceHiddenOffsets: offsets,
+              referenceHidden: isAnySideFullyClipped(offsets)
+            }
+          };
+        }
+        case "escaped": {
+          const overflow = await platform2.detectOverflow(state, {
+            ...detectOverflowOptions,
+            altBoundary: !0
+          }), offsets = getSideOffsets(overflow, rects.floating);
+          return {
+            data: {
+              escapedOffsets: offsets,
+              escaped: isAnySideFullyClipped(offsets)
+            }
+          };
+        }
+        default:
+          return {};
+      }
+    }
+  };
+}, originSides = /* @__PURE__ */ new Set(["left", "top"]);
+async function convertValueToCoords(state, options) {
+  const {
+    placement,
+    platform: platform2,
+    elements
+  } = state, rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating)), side = getSide(placement), alignment = getAlignment(placement), isVertical = getSideAxis(placement) === "y", mainAxisMulti = originSides.has(side) ? -1 : 1, crossAxisMulti = rtl && isVertical ? -1 : 1, 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
+  };
+  return alignment && typeof alignmentAxis == "number" && (crossAxis = alignment === "end" ? alignmentAxis * -1 : alignmentAxis), isVertical ? {
+    x: crossAxis * crossAxisMulti,
+    y: mainAxis * mainAxisMulti
+  } : {
+    x: mainAxis * mainAxisMulti,
+    y: crossAxis * crossAxisMulti
+  };
+}
+const offset$1 = function(options) {
+  return options === void 0 && (options = 0), {
+    name: "offset",
+    options,
+    async fn(state) {
+      var _middlewareData$offse, _middlewareData$arrow;
+      const {
+        x: x2,
+        y: y2,
+        placement,
+        middlewareData
+      } = state, diffCoords = await convertValueToCoords(state, options);
+      return placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset ? {} : {
+        x: x2 + diffCoords.x,
+        y: y2 + diffCoords.y,
+        data: {
+          ...diffCoords,
+          placement
+        }
+      };
+    }
+  };
+}, size$1 = function(options) {
+  return options === void 0 && (options = {}), {
+    name: "size",
+    options,
+    async fn(state) {
+      var _state$middlewareData, _state$middlewareData2;
+      const {
+        placement,
+        rects,
+        platform: platform2,
+        elements
+      } = state, {
+        apply = () => {
+        },
+        ...detectOverflowOptions
+      } = evaluate(options, state), overflow = await platform2.detectOverflow(state, detectOverflowOptions), side = getSide(placement), alignment = getAlignment(placement), isYAxis = getSideAxis(placement) === "y", {
+        width,
+        height
+      } = rects.floating;
+      let heightSide, widthSide;
+      side === "top" || side === "bottom" ? (heightSide = side, widthSide = alignment === (await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating)) ? "start" : "end") ? "left" : "right") : (widthSide = side, heightSide = alignment === "end" ? "top" : "bottom");
+      const maximumClippingHeight = height - overflow.top - overflow.bottom, maximumClippingWidth = width - overflow.left - overflow.right, overflowAvailableHeight = min(height - overflow[heightSide], maximumClippingHeight), overflowAvailableWidth = min(width - overflow[widthSide], maximumClippingWidth), noShift = !state.middlewareData.shift;
+      let availableHeight = overflowAvailableHeight, availableWidth = overflowAvailableWidth;
+      if ((_state$middlewareData = state.middlewareData.shift) != null && _state$middlewareData.enabled.x && (availableWidth = maximumClippingWidth), (_state$middlewareData2 = state.middlewareData.shift) != null && _state$middlewareData2.enabled.y && (availableHeight = maximumClippingHeight), noShift && !alignment) {
+        const xMin = max(overflow.left, 0), xMax = max(overflow.right, 0), yMin = max(overflow.top, 0), yMax = max(overflow.bottom, 0);
+        isYAxis ? availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right)) : availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom));
+      }
+      await apply({
+        ...state,
+        availableWidth,
+        availableHeight
+      });
+      const nextDimensions = await platform2.getDimensions(elements.floating);
+      return width !== nextDimensions.width || height !== nextDimensions.height ? {
+        reset: {
+          rects: !0
+        }
+      } : {};
+    }
+  };
+};
+function hasWindow() {
+  return typeof window < "u";
+}
+function getNodeName(node2) {
+  return isNode(node2) ? (node2.nodeName || "").toLowerCase() : "#document";
+}
+function getWindow(node2) {
+  var _node$ownerDocument;
+  return (node2 == null || (_node$ownerDocument = node2.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
+}
+function getDocumentElement(node2) {
+  var _ref;
+  return (_ref = (isNode(node2) ? node2.ownerDocument : node2.document) || window.document) == null ? void 0 : _ref.documentElement;
+}
+function isNode(value) {
+  return hasWindow() ? value instanceof Node || value instanceof getWindow(value).Node : !1;
+}
+function isElement(value) {
+  return hasWindow() ? value instanceof Element || value instanceof getWindow(value).Element : !1;
+}
+function isHTMLElement(value) {
+  return hasWindow() ? value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement : !1;
+}
+function isShadowRoot(value) {
+  return !hasWindow() || typeof ShadowRoot > "u" ? !1 : value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
+}
+function isOverflowElement(element) {
+  const {
+    overflow,
+    overflowX,
+    overflowY,
+    display
+  } = getComputedStyle$1(element);
+  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && display !== "inline" && display !== "contents";
+}
+function isTableElement(element) {
+  return /^(table|td|th)$/.test(getNodeName(element));
+}
+function isTopLayer(element) {
+  try {
+    if (element.matches(":popover-open"))
+      return !0;
+  } catch {
+  }
+  try {
+    return element.matches(":modal");
+  } catch {
+    return !1;
+  }
+}
+const willChangeRe = /transform|translate|scale|rotate|perspective|filter/, containRe = /paint|layout|strict|content/, isNotNone = (value) => !!value && value !== "none";
+let isWebKitValue;
+function isContainingBlock(elementOrCss) {
+  const css2 = isElement(elementOrCss) ? getComputedStyle$1(elementOrCss) : elementOrCss;
+  return isNotNone(css2.transform) || isNotNone(css2.translate) || isNotNone(css2.scale) || isNotNone(css2.rotate) || isNotNone(css2.perspective) || !isWebKit() && (isNotNone(css2.backdropFilter) || isNotNone(css2.filter)) || willChangeRe.test(css2.willChange || "") || containRe.test(css2.contain || "");
+}
+function getContainingBlock(element) {
+  let currentNode = getParentNode(element);
+  for (; isHTMLElement(currentNode) && !isLastTraversableNode(currentNode); ) {
+    if (isContainingBlock(currentNode))
+      return currentNode;
+    if (isTopLayer(currentNode))
+      return null;
+    currentNode = getParentNode(currentNode);
+  }
+  return null;
+}
+function isWebKit() {
+  return isWebKitValue == null && (isWebKitValue = typeof CSS < "u" && CSS.supports && CSS.supports("-webkit-backdrop-filter", "none")), isWebKitValue;
+}
+function isLastTraversableNode(node2) {
+  return /^(html|body|#document)$/.test(getNodeName(node2));
+}
+function getComputedStyle$1(element) {
+  return getWindow(element).getComputedStyle(element);
+}
+function getNodeScroll(element) {
+  return isElement(element) ? {
+    scrollLeft: element.scrollLeft,
+    scrollTop: element.scrollTop
+  } : {
+    scrollLeft: element.scrollX,
+    scrollTop: element.scrollY
+  };
+}
+function getParentNode(node2) {
+  if (getNodeName(node2) === "html")
+    return node2;
+  const result = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    node2.assignedSlot || // DOM Element detected.
+    node2.parentNode || // ShadowRoot detected.
+    isShadowRoot(node2) && node2.host || // Fallback.
+    getDocumentElement(node2)
+  );
+  return isShadowRoot(result) ? result.host : result;
+}
+function getNearestOverflowAncestor(node2) {
+  const parentNode = getParentNode(node2);
+  return isLastTraversableNode(parentNode) ? node2.ownerDocument ? node2.ownerDocument.body : node2.body : isHTMLElement(parentNode) && isOverflowElement(parentNode) ? parentNode : getNearestOverflowAncestor(parentNode);
+}
+function getOverflowAncestors(node2, list2, traverseIframes) {
+  var _node$ownerDocument2;
+  list2 === void 0 && (list2 = []), traverseIframes === void 0 && (traverseIframes = !0);
+  const scrollableAncestor = getNearestOverflowAncestor(node2), isBody = scrollableAncestor === ((_node$ownerDocument2 = node2.ownerDocument) == null ? void 0 : _node$ownerDocument2.body), win2 = getWindow(scrollableAncestor);
+  if (isBody) {
+    const frameElement = getFrameElement(win2);
+    return list2.concat(win2, win2.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
+  } else
+    return list2.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
+}
+function getFrameElement(win2) {
+  return win2.parent && Object.getPrototypeOf(win2.parent) ? win2.frameElement : null;
+}
+function getCssDimensions(element) {
+  const css2 = getComputedStyle$1(element);
+  let width = parseFloat(css2.width) || 0, height = parseFloat(css2.height) || 0;
+  const hasOffset = isHTMLElement(element), offsetWidth = hasOffset ? element.offsetWidth : width, offsetHeight = hasOffset ? element.offsetHeight : height, shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
+  return shouldFallback && (width = offsetWidth, height = offsetHeight), {
+    width,
+    height,
+    $: shouldFallback
+  };
+}
+function unwrapElement(element) {
+  return isElement(element) ? element : element.contextElement;
+}
+function getScale(element) {
+  const domElement = unwrapElement(element);
+  if (!isHTMLElement(domElement))
+    return createCoords(1);
+  const rect = domElement.getBoundingClientRect(), {
+    width,
+    height,
+    $
+  } = getCssDimensions(domElement);
+  let x2 = ($ ? round(rect.width) : rect.width) / width, y2 = ($ ? round(rect.height) : rect.height) / height;
+  return (!x2 || !Number.isFinite(x2)) && (x2 = 1), (!y2 || !Number.isFinite(y2)) && (y2 = 1), {
+    x: x2,
+    y: y2
+  };
+}
+const noOffsets = /* @__PURE__ */ createCoords(0);
+function getVisualOffsets(element) {
+  const win2 = getWindow(element);
+  return !isWebKit() || !win2.visualViewport ? noOffsets : {
+    x: win2.visualViewport.offsetLeft,
+    y: win2.visualViewport.offsetTop
+  };
+}
+function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
+  return isFixed === void 0 && (isFixed = !1), !floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element) ? !1 : isFixed;
+}
+function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
+  includeScale === void 0 && (includeScale = !1), isFixedStrategy === void 0 && (isFixedStrategy = !1);
+  const clientRect = element.getBoundingClientRect(), domElement = unwrapElement(element);
+  let scale2 = createCoords(1);
+  includeScale && (offsetParent ? isElement(offsetParent) && (scale2 = getScale(offsetParent)) : scale2 = getScale(element));
+  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
+  let x2 = (clientRect.left + visualOffsets.x) / scale2.x, y2 = (clientRect.top + visualOffsets.y) / scale2.y, width = clientRect.width / scale2.x, height = clientRect.height / scale2.y;
+  if (domElement) {
+    const win2 = getWindow(domElement), offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
+    let currentWin = win2, currentIFrame = getFrameElement(currentWin);
+    for (; currentIFrame && offsetParent && offsetWin !== currentWin; ) {
+      const iframeScale = getScale(currentIFrame), iframeRect = currentIFrame.getBoundingClientRect(), css2 = getComputedStyle$1(currentIFrame), left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css2.paddingLeft)) * iframeScale.x, top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css2.paddingTop)) * iframeScale.y;
+      x2 *= iframeScale.x, y2 *= iframeScale.y, width *= iframeScale.x, height *= iframeScale.y, x2 += left, y2 += top, currentWin = getWindow(currentIFrame), currentIFrame = getFrameElement(currentWin);
+    }
+  }
+  return rectToClientRect({
+    width,
+    height,
+    x: x2,
+    y: y2
+  });
+}
+function getWindowScrollBarX(element, rect) {
+  const leftScroll = getNodeScroll(element).scrollLeft;
+  return rect ? rect.left + leftScroll : getBoundingClientRect(getDocumentElement(element)).left + leftScroll;
+}
+function getHTMLOffset(documentElement, scroll) {
+  const htmlRect = documentElement.getBoundingClientRect(), x2 = htmlRect.left + scroll.scrollLeft - getWindowScrollBarX(documentElement, htmlRect), y2 = htmlRect.top + scroll.scrollTop;
+  return {
+    x: x2,
+    y: y2
+  };
+}
+function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
+  let {
+    elements,
+    rect,
+    offsetParent,
+    strategy
+  } = _ref;
+  const isFixed = strategy === "fixed", documentElement = getDocumentElement(offsetParent), topLayer = elements ? isTopLayer(elements.floating) : !1;
+  if (offsetParent === documentElement || topLayer && isFixed)
+    return rect;
+  let scroll = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, scale2 = createCoords(1);
+  const offsets = createCoords(0), isOffsetParentAnElement = isHTMLElement(offsetParent);
+  if ((isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) && ((getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) && (scroll = getNodeScroll(offsetParent)), isOffsetParentAnElement)) {
+    const offsetRect = getBoundingClientRect(offsetParent);
+    scale2 = getScale(offsetParent), offsets.x = offsetRect.x + offsetParent.clientLeft, offsets.y = offsetRect.y + offsetParent.clientTop;
+  }
+  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
+  return {
+    width: rect.width * scale2.x,
+    height: rect.height * scale2.y,
+    x: rect.x * scale2.x - scroll.scrollLeft * scale2.x + offsets.x + htmlOffset.x,
+    y: rect.y * scale2.y - scroll.scrollTop * scale2.y + offsets.y + htmlOffset.y
+  };
+}
+function getClientRects(element) {
+  return Array.from(element.getClientRects());
+}
+function getDocumentRect(element) {
+  const html = getDocumentElement(element), scroll = getNodeScroll(element), body = element.ownerDocument.body, width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth), height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
+  let x2 = -scroll.scrollLeft + getWindowScrollBarX(element);
+  const y2 = -scroll.scrollTop;
+  return getComputedStyle$1(body).direction === "rtl" && (x2 += max(html.clientWidth, body.clientWidth) - width), {
+    width,
+    height,
+    x: x2,
+    y: y2
+  };
+}
+const SCROLLBAR_MAX = 25;
+function getViewportRect(element, strategy) {
+  const win2 = getWindow(element), html = getDocumentElement(element), visualViewport = win2.visualViewport;
+  let width = html.clientWidth, height = html.clientHeight, x2 = 0, y2 = 0;
+  if (visualViewport) {
+    width = visualViewport.width, height = visualViewport.height;
+    const visualViewportBased = isWebKit();
+    (!visualViewportBased || visualViewportBased && strategy === "fixed") && (x2 = visualViewport.offsetLeft, y2 = visualViewport.offsetTop);
+  }
+  const windowScrollbarX = getWindowScrollBarX(html);
+  if (windowScrollbarX <= 0) {
+    const doc = html.ownerDocument, body = doc.body, bodyStyles = getComputedStyle(body), bodyMarginInline = doc.compatMode === "CSS1Compat" && parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight) || 0, clippingStableScrollbarWidth = Math.abs(html.clientWidth - body.clientWidth - bodyMarginInline);
+    clippingStableScrollbarWidth <= SCROLLBAR_MAX && (width -= clippingStableScrollbarWidth);
+  } else windowScrollbarX <= SCROLLBAR_MAX && (width += windowScrollbarX);
+  return {
+    width,
+    height,
+    x: x2,
+    y: y2
+  };
+}
+function getInnerBoundingClientRect(element, strategy) {
+  const clientRect = getBoundingClientRect(element, !0, strategy === "fixed"), top = clientRect.top + element.clientTop, left = clientRect.left + element.clientLeft, scale2 = isHTMLElement(element) ? getScale(element) : createCoords(1), width = element.clientWidth * scale2.x, height = element.clientHeight * scale2.y, x2 = left * scale2.x, y2 = top * scale2.y;
+  return {
+    width,
+    height,
+    x: x2,
+    y: y2
+  };
+}
+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);
+  return parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode) ? !1 : getComputedStyle$1(parentNode).position === "fixed" || hasFixedPositionAncestor(parentNode, stopNode);
+}
+function getClippingElementAncestors(element, cache) {
+  const cachedResult = cache.get(element);
+  if (cachedResult)
+    return cachedResult;
+  let result = getOverflowAncestors(element, [], !1).filter((el) => isElement(el) && getNodeName(el) !== "body"), currentContainingBlockComputedStyle = null;
+  const elementIsFixed = getComputedStyle$1(element).position === "fixed";
+  let currentNode = elementIsFixed ? getParentNode(element) : element;
+  for (; isElement(currentNode) && !isLastTraversableNode(currentNode); ) {
+    const computedStyle = getComputedStyle$1(currentNode), currentNodeIsContaining = isContainingBlock(currentNode);
+    !currentNodeIsContaining && computedStyle.position === "fixed" && (currentContainingBlockComputedStyle = null), (elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === "static" && !!currentContainingBlockComputedStyle && (currentContainingBlockComputedStyle.position === "absolute" || currentContainingBlockComputedStyle.position === "fixed") || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode)) ? result = result.filter((ancestor) => ancestor !== currentNode) : currentContainingBlockComputedStyle = computedStyle, currentNode = getParentNode(currentNode);
+  }
+  return cache.set(element, result), result;
+}
+function getClippingRect(_ref) {
+  let {
+    element,
+    boundary,
+    rootBoundary,
+    strategy
+  } = _ref;
+  const clippingAncestors = [...boundary === "clippingAncestors" ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary), rootBoundary], firstRect = getClientRectFromClippingAncestor(element, clippingAncestors[0], strategy);
+  let top = firstRect.top, right = firstRect.right, bottom = firstRect.bottom, left = firstRect.left;
+  for (let i2 = 1; i2 < clippingAncestors.length; i2++) {
+    const rect = getClientRectFromClippingAncestor(element, clippingAncestors[i2], strategy);
+    top = max(rect.top, top), right = min(rect.right, right), bottom = min(rect.bottom, bottom), left = max(rect.left, left);
+  }
+  return {
+    width: right - left,
+    height: bottom - top,
+    x: left,
+    y: top
+  };
+}
+function getDimensions(element) {
+  const {
+    width,
+    height
+  } = getCssDimensions(element);
+  return {
+    width,
+    height
+  };
+}
+function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
+  const isOffsetParentAnElement = isHTMLElement(offsetParent), documentElement = getDocumentElement(offsetParent), isFixed = strategy === "fixed", rect = getBoundingClientRect(element, !0, isFixed, offsetParent);
+  let scroll = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const offsets = createCoords(0);
+  function setLeftRTLScrollbarOffset() {
+    offsets.x = getWindowScrollBarX(documentElement);
+  }
+  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed)
+    if ((getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) && (scroll = getNodeScroll(offsetParent)), isOffsetParentAnElement) {
+      const offsetRect = getBoundingClientRect(offsetParent, !0, isFixed, offsetParent);
+      offsets.x = offsetRect.x + offsetParent.clientLeft, offsets.y = offsetRect.y + offsetParent.clientTop;
+    } else documentElement && setLeftRTLScrollbarOffset();
+  isFixed && !isOffsetParentAnElement && documentElement && setLeftRTLScrollbarOffset();
+  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0), x2 = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x, y2 = rect.top + scroll.scrollTop - offsets.y - htmlOffset.y;
+  return {
+    x: x2,
+    y: y2,
+    width: rect.width,
+    height: rect.height
+  };
+}
+function isStaticPositioned(element) {
+  return getComputedStyle$1(element).position === "static";
+}
+function getTrueOffsetParent(element, polyfill) {
+  if (!isHTMLElement(element) || getComputedStyle$1(element).position === "fixed")
+    return null;
+  if (polyfill)
+    return polyfill(element);
+  let rawOffsetParent = element.offsetParent;
+  return getDocumentElement(element) === rawOffsetParent && (rawOffsetParent = rawOffsetParent.ownerDocument.body), rawOffsetParent;
+}
+function getOffsetParent(element, polyfill) {
+  const win2 = getWindow(element);
+  if (isTopLayer(element))
+    return win2;
+  if (!isHTMLElement(element)) {
+    let svgOffsetParent = getParentNode(element);
+    for (; svgOffsetParent && !isLastTraversableNode(svgOffsetParent); ) {
+      if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent))
+        return svgOffsetParent;
+      svgOffsetParent = getParentNode(svgOffsetParent);
+    }
+    return win2;
+  }
+  let offsetParent = getTrueOffsetParent(element, polyfill);
+  for (; offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent); )
+    offsetParent = getTrueOffsetParent(offsetParent, polyfill);
+  return offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent) ? win2 : offsetParent || getContainingBlock(element) || win2;
+}
+const getElementRects = async function(data2) {
+  const getOffsetParentFn = this.getOffsetParent || getOffsetParent, getDimensionsFn = this.getDimensions, floatingDimensions = await getDimensionsFn(data2.floating);
+  return {
+    reference: getRectRelativeToOffsetParent(data2.reference, await getOffsetParentFn(data2.floating), data2.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: floatingDimensions.width,
+      height: floatingDimensions.height
+    }
+  };
+};
+function isRTL(element) {
+  return getComputedStyle$1(element).direction === "rtl";
+}
+const platform = {
+  convertOffsetParentRelativeRectToViewportRelativeRect,
+  getDocumentElement,
+  getClippingRect,
+  getOffsetParent,
+  getElementRects,
+  getClientRects,
+  getDimensions,
+  getScale,
+  isElement,
+  isRTL
+};
+function rectsAreEqual(a2, b2) {
+  return a2.x === b2.x && a2.y === b2.y && a2.width === b2.width && a2.height === b2.height;
+}
+function observeMove(element, onMove) {
+  let io = null, timeoutId;
+  const root2 = getDocumentElement(element);
+  function cleanup() {
+    var _io;
+    clearTimeout(timeoutId), (_io = io) == null || _io.disconnect(), io = null;
+  }
+  function refresh(skip, threshold) {
+    skip === void 0 && (skip = !1), threshold === void 0 && (threshold = 1), cleanup();
+    const elementRectForRootMargin = element.getBoundingClientRect(), {
+      left,
+      top,
+      width,
+      height
+    } = elementRectForRootMargin;
+    if (skip || onMove(), !width || !height)
+      return;
+    const insetTop = floor(top), insetRight = floor(root2.clientWidth - (left + width)), insetBottom = floor(root2.clientHeight - (top + height)), insetLeft = floor(left), options = {
+      rootMargin: -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px",
+      threshold: max(0, min(1, threshold)) || 1
+    };
+    let isFirstUpdate = !0;
+    function handleObserve(entries) {
+      const ratio = entries[0].intersectionRatio;
+      if (ratio !== threshold) {
+        if (!isFirstUpdate)
+          return refresh();
+        ratio ? refresh(!1, ratio) : timeoutId = setTimeout(() => {
+          refresh(!1, 1e-7);
+        }, 1e3);
+      }
+      ratio === 1 && !rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect()) && refresh(), isFirstUpdate = !1;
+    }
+    try {
+      io = new IntersectionObserver(handleObserve, {
+        ...options,
+        // Handle <iframe>s
+        root: root2.ownerDocument
+      });
+    } catch {
+      io = new IntersectionObserver(handleObserve, options);
+    }
+    io.observe(element);
+  }
+  return refresh(!0), cleanup;
+}
+function autoUpdate(reference, floating, update, options) {
+  options === void 0 && (options = {});
+  const {
+    ancestorScroll = !0,
+    ancestorResize = !0,
+    elementResize = typeof ResizeObserver == "function",
+    layoutShift = typeof IntersectionObserver == "function",
+    animationFrame = !1
+  } = options, referenceEl = unwrapElement(reference), ancestors = ancestorScroll || ancestorResize ? [...referenceEl ? getOverflowAncestors(referenceEl) : [], ...floating ? getOverflowAncestors(floating) : []] : [];
+  ancestors.forEach((ancestor) => {
+    ancestorScroll && ancestor.addEventListener("scroll", update, {
+      passive: !0
+    }), ancestorResize && ancestor.addEventListener("resize", update);
+  });
+  const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;
+  let reobserveFrame = -1, resizeObserver = null;
+  elementResize && (resizeObserver = new ResizeObserver((_ref) => {
+    let [firstEntry] = _ref;
+    firstEntry && firstEntry.target === referenceEl && resizeObserver && floating && (resizeObserver.unobserve(floating), cancelAnimationFrame(reobserveFrame), reobserveFrame = requestAnimationFrame(() => {
+      var _resizeObserver;
+      (_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);
+    })), update();
+  }), referenceEl && !animationFrame && resizeObserver.observe(referenceEl), floating && resizeObserver.observe(floating));
+  let frameId, prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
+  animationFrame && frameLoop();
+  function frameLoop() {
+    const nextRefRect = getBoundingClientRect(reference);
+    prevRefRect && !rectsAreEqual(prevRefRect, nextRefRect) && update(), prevRefRect = nextRefRect, frameId = requestAnimationFrame(frameLoop);
+  }
+  return update(), () => {
+    var _resizeObserver2;
+    ancestors.forEach((ancestor) => {
+      ancestorScroll && ancestor.removeEventListener("scroll", update), ancestorResize && ancestor.removeEventListener("resize", update);
+    }), cleanupIo?.(), (_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect(), resizeObserver = null, animationFrame && cancelAnimationFrame(frameId);
+  };
+}
+const offset = offset$1, autoPlacement = autoPlacement$1, size = size$1, hide = hide$1, computePosition = (reference, floating, options) => {
+  const cache = /* @__PURE__ */ new Map(), mergedOptions = {
+    platform,
+    ...options
+  }, platformWithCache = {
+    ...mergedOptions.platform,
+    _c: cache
+  };
+  return computePosition$1(reference, floating, {
+    ...mergedOptions,
+    platform: platformWithCache
+  });
+};
 function PortalToContainer({ children: children2 }) {
   const ctx = useRootContainerContext();
   if (!ctx)
@@ -45895,7 +46793,7 @@ const RelationshipPopover = memo$2(() => {
       computePosition(reference, popper, {
         placement: "bottom-start",
         middleware: [
-          offset$1(4),
+          offset(4),
           autoPlacement({
             crossAxis: !0,
             // padding: POPOVER_PADDING,
@@ -45910,7 +46808,7 @@ const RelationshipPopover = memo$2(() => {
               "left-end"
             ]
           }),
-          size$1({
+          size({
             apply({ availableHeight, availableWidth, elements }) {
               wasCanceled || Object.assign(elements.floating.style, {
                 maxWidth: `${t$t(roundDpr(availableWidth), { min: 220, max: 400 })}px`,
@@ -45918,7 +46816,7 @@ const RelationshipPopover = memo$2(() => {
               });
             }
           }),
-          hide$1({
+          hide({
             padding: POPOVER_PADDING * 2
           })
         ]
@@ -53541,15 +54439,14 @@ const { withProvider, withContext } = createStyleContext(navigationPanel), shoul
   shouldForwardProp
 }), Logo = withContext(LogoButton, "logo"), Label = withContext(MotionDiv, "label", {
   shouldForwardProp
-});
-withContext(MotionDiv, "dropdown", {
+}), Dropdown = withContext(MotionDiv, "dropdown", {
   shouldForwardProp
-});
-const NavigationPanel = {
+}), NavigationPanel = {
   Root,
   Body,
   Logo,
-  Label
+  Label,
+  Dropdown
 }, ProjectsOverviewPanel = () => /* @__PURE__ */ jsx(NavigationPanel.Root, { children: /* @__PURE__ */ jsxs(NavigationPanel.Body, { children: [
   /* @__PURE__ */ jsx(NavigationPanel.Logo, {}),
   /* @__PURE__ */ jsx(NavigationPanel.Label, { children: "Projects Overview" })
@@ -53741,6 +54638,87 @@ function LikeC4ProjectsOverview({
     ) })
   ] }) });
 }
+const root = css({
+  height: "30px",
+  paddingLeft: "sm",
+  paddingRight: "1",
+  borderRadius: "sm",
+  // TODO
+  // color: fallbackVar('var(--search-color)', 'mantine.colors.placeholder)',
+  border: "1px solid",
+  borderColor: {
+    base: "default.border",
+    _light: "mantine.colors.gray[4]",
+    _dark: "mantine.colors.dark[4]",
+    _hover: "default.border"
+  },
+  cursor: "pointer",
+  background: {
+    base: "default",
+    _light: "white",
+    _dark: "mantine.colors.dark[6]",
+    _hover: "default.hover"
+  },
+  width: "100%",
+  "& .tabler-icon": {
+    color: "text"
+  },
+  transition: {
+    base: "fast",
+    _whenPanning: "none !important"
+  },
+  boxShadow: {
+    base: "xs",
+    _hover: "sm",
+    _whenPanning: "none !important"
+  }
+}), placeholder = css({
+  fontSize: "sm",
+  // mantine.fontSizes.sm,
+  fontWeight: "medium",
+  paddingRight: "2.5",
+  // 10px
+  color: "text.placeholder",
+  flex: "1",
+  sm: {
+    paddingRight: "[30px]"
+  },
+  md: {
+    paddingRight: "[50px]"
+  }
+}), shortcut = css({
+  fontSize: "11px",
+  fontWeight: "bold",
+  lineHeight: 1,
+  padding: "[4px 7px]",
+  borderRadius: "sm",
+  border: "1px solid",
+  transition: "fast",
+  _light: {
+    color: "mantine.colors.gray[7]",
+    borderColor: "mantine.colors.gray[2]"
+  },
+  _dark: {
+    color: "mantine.colors.dark[0]",
+    borderColor: "mantine.colors.dark[7]"
+  },
+  backgroundColor: {
+    _light: "mantine.colors.gray[2]/70",
+    _dark: "mantine.colors.dark[8]/70",
+    _groupHover: {
+      _light: "mantine.colors.gray[2]",
+      _dark: "mantine.colors.dark[8]"
+    }
+  }
+});
+function SearchControl({ className, ...others }) {
+  const isMac2 = isMacOs();
+  return /* @__PURE__ */ jsx(UnstyledButton, { ...others, className: cx("group", root, className), children: /* @__PURE__ */ jsxs(Group, { gap: "xs", children: [
+    /* @__PURE__ */ jsx(IconSearch, { style: { width: "15px", height: "15px" }, stroke: 2 }),
+    /* @__PURE__ */ jsx(Text, { component: "div", className: placeholder, children: "Search" }),
+    /* @__PURE__ */ jsx(Text, { component: "div", className: shortcut, children: isMac2 ? "⌘ + K" : "Ctrl + K" })
+  ] }) });
+}
 function customDiagramNode(Node2) {
   return ((props) => {
     const viewId = props.data.viewId, viewModel = useLikeC4Model().findView(viewId);
@@ -53824,9 +54802,13 @@ export {
   LikeC4ProjectsProvider,
   LikeC4View,
   Markdown,
+  NavigationPanel,
   Overlay,
   PortalToContainer,
   ReactLikeC4,
+  SearchContext,
+  SearchControl,
+  SearchPanelContent,
   SequenceActorNode,
   SequenceParallelArea,
   ShadowRoot$1 as ShadowRoot,
@@ -53841,7 +54823,10 @@ export {
   elementNode,
   memoEdge,
   memoNode,
+  normalizeSearch,
   pickViewBounds,
+  bodyCss as searchBodyCss,
+  dialogCss as searchDialogCss,
   sequenceActorNode,
   useChangeLikeC4Project,
   useCurrentView,
@@ -53864,6 +54849,7 @@ export {
   useOnDiagramEvent,
   useOptionalCurrentViewModel,
   useOptionalLikeC4Model,
+  useSearchContext,
   useSetState,
   useUpdateEffect,
   viewGroupNode