element-plus 2.10.6 → 2.10.7

package/dist/index.full.js

@@ -1,4 +1,4 @@
-/*! Element Plus v2.10.6 */
+/*! Element Plus v2.10.7 */
 
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('vue')) :
@@ -3040,7 +3040,7 @@
     return number;
   }
 
-  function clamp(number, lower, upper) {
+  function clamp$1(number, lower, upper) {
     if (upper === void 0) {
       upper = lower;
       lower = void 0;
@@ -4649,7 +4649,7 @@
   }
 
   var WRAP_FLIP_FLAG = 512;
-  function flip$1(func) {
+  function flip$2(func) {
     return createWrap(func, WRAP_FLIP_FLAG);
   }
 
@@ -4984,7 +4984,7 @@
   var nodeIsDate = nodeUtil && nodeUtil.isDate;
   var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate;
 
-  function isElement$2(value) {
+  function isElement$3(value) {
     return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value);
   }
 
@@ -5195,7 +5195,7 @@
     return result;
   }
 
-  function max$3(array) {
+  function max$4(array) {
     return array && array.length ? baseExtremum(array, identity, baseGt) : void 0;
   }
 
@@ -5244,7 +5244,7 @@
     };
   });
 
-  function min$3(array) {
+  function min$4(array) {
     return array && array.length ? baseExtremum(array, identity, baseLt) : void 0;
   }
 
@@ -5963,7 +5963,7 @@
     return array == null ? array : nativeReverse.call(array);
   }
 
-  var round$1 = createRound("round");
+  var round$2 = createRound("round");
 
   function arraySample(array) {
     var length = array.length;
@@ -6034,7 +6034,7 @@
 
   var mapTag = "[object Map]";
   var setTag = "[object Set]";
-  function size(collection) {
+  function size$1(collection) {
     if (collection == null) {
       return 0;
     }
@@ -6970,7 +6970,7 @@
     sample,
     sampleSize,
     shuffle,
-    size,
+    size: size$1,
     some,
     sortBy
   };
@@ -6990,7 +6990,7 @@
     debounce,
     defer,
     delay,
-    flip: flip$1,
+    flip: flip$2,
     memoize,
     negate,
     once,
@@ -7023,7 +7023,7 @@
     isBoolean: isBoolean$1,
     isBuffer,
     isDate,
-    isElement: isElement$2,
+    isElement: isElement$3,
     isEmpty: isEmpty$1,
     isEqual: isEqual$1,
     isEqualWith,
@@ -7069,21 +7069,21 @@
     ceil,
     divide,
     floor: floor$1,
-    max: max$3,
+    max: max$4,
     maxBy,
     mean,
     meanBy,
-    min: min$3,
+    min: min$4,
     minBy,
     multiply,
-    round: round$1,
+    round: round$2,
     subtract,
     sum: sum$1,
     sumBy
   };
 
   var number = {
-    clamp,
+    clamp: clamp$1,
     inRange,
     random
   };
@@ -7811,7 +7811,7 @@
   const isBoolean = (val) => typeof val === "boolean";
   const isNumber = (val) => typeof val === "number";
   const isEmpty = (val) => !val && val !== 0 || isArray$1(val) && val.length === 0 || isObject$1(val) && !Object.keys(val).length;
-  const isElement$1 = (e) => {
+  const isElement$2 = (e) => {
     if (typeof Element === "undefined")
       return false;
     return e instanceof Element;
@@ -10115,36 +10115,156 @@
     };
   };
 
-  function getSide(placement) {
+  /**
+   * Custom positioning reference element.
+   * @see https://floating-ui.com/docs/virtual-elements
+   */
+
+  const sides = ['top', 'right', 'bottom', 'left'];
+  const alignments = ['start', 'end'];
+  const placements = /*#__PURE__*/sides.reduce((acc, side) => acc.concat(side, side + "-" + alignments[0], side + "-" + alignments[1]), []);
+  const min$3 = Math.min;
+  const max$3 = Math.max;
+  const round$1 = Math.round;
+  const createCoords = v => ({
+    x: v,
+    y: v
+  });
+  const oppositeSideMap = {
+    left: 'right',
+    right: 'left',
+    bottom: 'top',
+    top: 'bottom'
+  };
+  const oppositeAlignmentMap = {
+    start: 'end',
+    end: 'start'
+  };
+  function clamp(start, value, end) {
+    return max$3(start, min$3(value, end));
+  }
+  function evaluate(value, param) {
+    return typeof value === 'function' ? value(param) : value;
+  }
+  function getSide$1(placement) {
     return placement.split('-')[0];
   }
-
-  function getAlignment(placement) {
+  function getAlignment$1(placement) {
     return placement.split('-')[1];
   }
-
-  function getMainAxisFromPlacement(placement) {
-    return ['top', 'bottom'].includes(getSide(placement)) ? 'x' : 'y';
+  function getOppositeAxis(axis) {
+    return axis === 'x' ? 'y' : 'x';
   }
-
-  function getLengthFromAxis(axis) {
+  function getAxisLength(axis) {
     return axis === 'y' ? 'height' : 'width';
   }
+  function getSideAxis(placement) {
+    return ['top', 'bottom'].includes(getSide$1(placement)) ? 'y' : 'x';
+  }
+  function getAlignmentAxis(placement) {
+    return getOppositeAxis(getSideAxis(placement));
+  }
+  function getAlignmentSides$1(placement, rects, rtl) {
+    if (rtl === void 0) {
+      rtl = false;
+    }
+    const alignment = getAlignment$1(placement);
+    const alignmentAxis = getAlignmentAxis(placement);
+    const length = getAxisLength(alignmentAxis);
+    let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';
+    if (rects.reference[length] > rects.floating[length]) {
+      mainAlignmentSide = getOppositePlacement$1(mainAlignmentSide);
+    }
+    return [mainAlignmentSide, getOppositePlacement$1(mainAlignmentSide)];
+  }
+  function getExpandedPlacements$1(placement) {
+    const oppositePlacement = getOppositePlacement$1(placement);
+    return [getOppositeAlignmentPlacement$1(placement), oppositePlacement, getOppositeAlignmentPlacement$1(oppositePlacement)];
+  }
+  function getOppositeAlignmentPlacement$1(placement) {
+    return placement.replace(/start|end/g, alignment => oppositeAlignmentMap[alignment]);
+  }
+  function getSideList(side, isStart, rtl) {
+    const lr = ['left', 'right'];
+    const rl = ['right', 'left'];
+    const tb = ['top', 'bottom'];
+    const bt = ['bottom', 'top'];
+    switch (side) {
+      case 'top':
+      case 'bottom':
+        if (rtl) return isStart ? rl : lr;
+        return isStart ? lr : rl;
+      case 'left':
+      case 'right':
+        return isStart ? tb : bt;
+      default:
+        return [];
+    }
+  }
+  function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
+    const alignment = getAlignment$1(placement);
+    let list = getSideList(getSide$1(placement), direction === 'start', rtl);
+    if (alignment) {
+      list = list.map(side => side + "-" + alignment);
+      if (flipAlignment) {
+        list = list.concat(list.map(getOppositeAlignmentPlacement$1));
+      }
+    }
+    return list;
+  }
+  function getOppositePlacement$1(placement) {
+    return placement.replace(/left|right|bottom|top/g, side => oppositeSideMap[side]);
+  }
+  function expandPaddingObject$1(padding) {
+    return {
+      top: 0,
+      right: 0,
+      bottom: 0,
+      left: 0,
+      ...padding
+    };
+  }
+  function getPaddingObject(padding) {
+    return typeof padding !== 'number' ? expandPaddingObject$1(padding) : {
+      top: padding,
+      right: padding,
+      bottom: padding,
+      left: padding
+    };
+  }
+  function rectToClientRect$1(rect) {
+    const {
+      x,
+      y,
+      width,
+      height
+    } = rect;
+    return {
+      width,
+      height,
+      top: y,
+      left: x,
+      right: x + width,
+      bottom: y + height,
+      x,
+      y
+    };
+  }
 
-  function computeCoordsFromPlacement(_ref, placement, rtl) {
+  function computeCoordsFromPlacement$1(_ref, placement, rtl) {
     let {
       reference,
       floating
     } = _ref;
+    const sideAxis = getSideAxis(placement);
+    const alignmentAxis = getAlignmentAxis(placement);
+    const alignLength = getAxisLength(alignmentAxis);
+    const side = getSide$1(placement);
+    const isVertical = sideAxis === 'y';
     const commonX = reference.x + reference.width / 2 - floating.width / 2;
     const commonY = reference.y + reference.height / 2 - floating.height / 2;
-    const mainAxis = getMainAxisFromPlacement(placement);
-    const length = getLengthFromAxis(mainAxis);
-    const commonAlign = reference[length] / 2 - floating[length] / 2;
-    const side = getSide(placement);
-    const isVertical = mainAxis === 'x';
+    const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
     let coords;
-
     switch (side) {
       case 'top':
         coords = {
@@ -10152,65 +10272,57 @@
           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)) {
+    switch (getAlignment$1(placement)) {
       case 'start':
-        coords[mainAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
+        coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
         break;
-
       case 'end':
-        coords[mainAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
+        coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
         break;
     }
-
     return coords;
   }
 
   /**
    * Computes the `x` and `y` coordinates that will place the floating element
-   * next to a reference element when it is given a certain positioning strategy.
+   * next to a given reference element.
    *
    * This export does not have any `platform` interface logic. You will need to
    * write one for the platform you are using Floating UI with.
    */
-
-  const computePosition$1 = async (reference, floating, config) => {
+  const computePosition$3 = async (reference, floating, config) => {
     const {
       placement = 'bottom',
       strategy = 'absolute',
       middleware = [],
       platform
     } = config;
+    const validMiddleware = middleware.filter(Boolean);
     const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));
-
     let rects = await platform.getElementRects({
       reference,
       floating,
@@ -10219,16 +10331,15 @@
     let {
       x,
       y
-    } = computeCoordsFromPlacement(rects, placement, rtl);
+    } = computeCoordsFromPlacement$1(rects, placement, rtl);
     let statefulPlacement = placement;
     let middlewareData = {};
     let resetCount = 0;
-
-    for (let i = 0; i < middleware.length; i++) {
+    for (let i = 0; i < validMiddleware.length; i++) {
       const {
         name,
         fn
-      } = middleware[i];
+      } = validMiddleware[i];
       const {
         x: nextX,
         y: nextY,
@@ -10250,20 +10361,19 @@
       });
       x = nextX != null ? nextX : x;
       y = nextY != null ? nextY : y;
-      middlewareData = { ...middlewareData,
-        [name]: { ...middlewareData[name],
+      middlewareData = {
+        ...middlewareData,
+        [name]: {
+          ...middlewareData[name],
           ...data
         }
       };
-
       if (reset && resetCount <= 50) {
         resetCount++;
-
         if (typeof reset === 'object') {
           if (reset.placement) {
             statefulPlacement = reset.placement;
           }
-
           if (reset.rects) {
             rects = reset.rects === true ? await platform.getElementRects({
               reference,
@@ -10271,18 +10381,14 @@
               strategy
             }) : reset.rects;
           }
-
           ({
             x,
             y
-          } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
+          } = computeCoordsFromPlacement$1(rects, statefulPlacement, rtl));
         }
-
         i = -1;
-        continue;
       }
     }
-
     return {
       x,
       y,
@@ -10292,49 +10398,19 @@
     };
   };
 
-  function expandPaddingObject(padding) {
-    return {
-      top: 0,
-      right: 0,
-      bottom: 0,
-      left: 0,
-      ...padding
-    };
-  }
-
-  function getSideObjectFromPadding(padding) {
-    return typeof padding !== 'number' ? expandPaddingObject(padding) : {
-      top: padding,
-      right: padding,
-      bottom: padding,
-      left: padding
-    };
-  }
-
-  function rectToClientRect(rect) {
-    return { ...rect,
-      top: rect.y,
-      left: rect.x,
-      right: rect.x + rect.width,
-      bottom: rect.y + rect.height
-    };
-  }
-
   /**
    * Resolves with an object of overflow side offsets that determine how much the
-   * element is overflowing a given clipping boundary.
+   * element is overflowing a given clipping boundary on each side.
    * - positive = overflowing the boundary by that number of pixels
    * - negative = how many pixels left before it will overflow
    * - 0 = lies flush with the boundary
    * @see https://floating-ui.com/docs/detectOverflow
    */
-  async function detectOverflow(middlewareArguments, options) {
+  async function detectOverflow$1(state, options) {
     var _await$platform$isEle;
-
     if (options === void 0) {
       options = {};
     }
-
     const {
       x,
       y,
@@ -10342,176 +10418,251 @@
       rects,
       elements,
       strategy
-    } = middlewareArguments;
+    } = state;
     const {
       boundary = 'clippingAncestors',
       rootBoundary = 'viewport',
       elementContext = 'floating',
       altBoundary = false,
       padding = 0
-    } = options;
-    const paddingObject = getSideObjectFromPadding(padding);
+    } = evaluate(options, state);
+    const paddingObject = getPaddingObject(padding);
     const altContext = elementContext === 'floating' ? 'reference' : 'floating';
     const element = elements[altBoundary ? altContext : elementContext];
-    const clippingClientRect = rectToClientRect(await platform.getClippingRect({
+    const clippingClientRect = rectToClientRect$1(await platform.getClippingRect({
       element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || (await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating))),
       boundary,
       rootBoundary,
       strategy
     }));
-    const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
-      rect: elementContext === 'floating' ? { ...rects.floating,
-        x,
-        y
-      } : rects.reference,
-      offsetParent: await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating)),
+    const rect = elementContext === 'floating' ? {
+      x,
+      y,
+      width: rects.floating.width,
+      height: rects.floating.height
+    } : rects.reference;
+    const offsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating));
+    const offsetScale = (await (platform.isElement == null ? void 0 : platform.isElement(offsetParent))) ? (await (platform.getScale == null ? void 0 : platform.getScale(offsetParent))) || {
+      x: 1,
+      y: 1
+    } : {
+      x: 1,
+      y: 1
+    };
+    const elementClientRect = rectToClientRect$1(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
+      elements,
+      rect,
+      offsetParent,
       strategy
-    }) : rects[elementContext]);
+    }) : rect);
     return {
-      top: clippingClientRect.top - elementClientRect.top + paddingObject.top,
-      bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom,
-      left: clippingClientRect.left - elementClientRect.left + paddingObject.left,
-      right: elementClientRect.right - clippingClientRect.right + paddingObject.right
+      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 min$2 = Math.min;
-  const max$2 = Math.max;
-
-  function within(min$1, value, max$1) {
-    return max$2(min$1, min$2(value, max$1));
-  }
-
   /**
-   * Positions an inner element of the floating element such that it is centered
-   * to the reference element.
+   * Provides data to position an inner element of the floating element so that it
+   * appears centered to the reference element.
    * @see https://floating-ui.com/docs/arrow
    */
-  const arrow = options => ({
+  const arrow$2 = options => ({
     name: 'arrow',
     options,
-
-    async fn(middlewareArguments) {
-      // Since `element` is required, we don't Partial<> the type
-      const {
-        element,
-        padding = 0
-      } = options != null ? options : {};
+    async fn(state) {
       const {
         x,
         y,
         placement,
         rects,
-        platform
-      } = middlewareArguments;
-
+        platform,
+        elements,
+        middlewareData
+      } = state;
+      // Since `element` is required, we don't Partial<> the type.
+      const {
+        element,
+        padding = 0
+      } = evaluate(options, state) || {};
       if (element == null) {
-
         return {};
       }
-
-      const paddingObject = getSideObjectFromPadding(padding);
+      const paddingObject = getPaddingObject(padding);
       const coords = {
         x,
         y
       };
-      const axis = getMainAxisFromPlacement(placement);
-      const alignment = getAlignment(placement);
-      const length = getLengthFromAxis(axis);
+      const axis = getAlignmentAxis(placement);
+      const length = getAxisLength(axis);
       const arrowDimensions = await platform.getDimensions(element);
-      const minProp = axis === 'y' ? 'top' : 'left';
-      const maxProp = axis === 'y' ? 'bottom' : 'right';
+      const isYAxis = axis === 'y';
+      const minProp = isYAxis ? 'top' : 'left';
+      const maxProp = isYAxis ? 'bottom' : 'right';
+      const clientProp = isYAxis ? 'clientHeight' : 'clientWidth';
       const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
       const startDiff = coords[axis] - rects.reference[axis];
       const arrowOffsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(element));
-      let clientSize = arrowOffsetParent ? axis === 'y' ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;
+      let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;
 
-      if (clientSize === 0) {
-        clientSize = rects.floating[length];
+      // DOM platform can return `window` as the `offsetParent`.
+      if (!clientSize || !(await (platform.isElement == null ? void 0 : platform.isElement(arrowOffsetParent)))) {
+        clientSize = elements.floating[clientProp] || rects.floating[length];
       }
+      const centerToReference = endDiff / 2 - startDiff / 2;
 
-      const centerToReference = endDiff / 2 - startDiff / 2; // Make sure the arrow doesn't overflow the floating element if the center
-      // point is outside the floating element's bounds
+      // If the padding is large enough that it causes the arrow to no longer be
+      // centered, modify the padding so that it is centered.
+      const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;
+      const minPadding = min$3(paddingObject[minProp], largestPossiblePadding);
+      const maxPadding = min$3(paddingObject[maxProp], largestPossiblePadding);
 
-      const min = paddingObject[minProp];
-      const max = clientSize - arrowDimensions[length] - paddingObject[maxProp];
+      // Make sure the arrow doesn't overflow the floating element if the center
+      // point is outside the floating element's bounds.
+      const min$1 = minPadding;
+      const max = clientSize - arrowDimensions[length] - maxPadding;
       const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
-      const offset = within(min, center, max); // Make sure that arrow points at the reference
-
-      const alignmentPadding = alignment === 'start' ? paddingObject[minProp] : paddingObject[maxProp];
-      const shouldAddOffset = alignmentPadding > 0 && center !== offset && rects.reference[length] <= rects.floating[length];
-      const alignmentOffset = shouldAddOffset ? center < min ? min - center : max - center : 0;
+      const offset = clamp(min$1, center, max);
+
+      // If the reference is small enough that the arrow's padding causes it to
+      // to point to nothing for an aligned placement, adjust the offset of the
+      // floating element itself. To ensure `shift()` continues to take action,
+      // a single reset is performed when this is true.
+      const shouldAddOffset = !middlewareData.arrow && getAlignment$1(placement) != null && center !== offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
+      const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max : 0;
       return {
-        [axis]: coords[axis] - alignmentOffset,
+        [axis]: coords[axis] + alignmentOffset,
         data: {
           [axis]: offset,
-          centerOffset: center - offset
-        }
+          centerOffset: center - offset - alignmentOffset,
+          ...(shouldAddOffset && {
+            alignmentOffset
+          })
+        },
+        reset: shouldAddOffset
       };
     }
-
   });
 
-  const hash$1 = {
-    left: 'right',
-    right: 'left',
-    bottom: 'top',
-    top: 'bottom'
-  };
-  function getOppositePlacement(placement) {
-    return placement.replace(/left|right|bottom|top/g, matched => hash$1[matched]);
+  function getPlacementList(alignment, autoAlignment, allowedPlacements) {
+    const allowedPlacementsSortedByAlignment = alignment ? [...allowedPlacements.filter(placement => getAlignment$1(placement) === alignment), ...allowedPlacements.filter(placement => getAlignment$1(placement) !== alignment)] : allowedPlacements.filter(placement => getSide$1(placement) === placement);
+    return allowedPlacementsSortedByAlignment.filter(placement => {
+      if (alignment) {
+        return getAlignment$1(placement) === alignment || (autoAlignment ? getOppositeAlignmentPlacement$1(placement) !== placement : false);
+      }
+      return true;
+    });
   }
-
-  function getAlignmentSides(placement, rects, rtl) {
-    if (rtl === void 0) {
-      rtl = false;
+  /**
+   * Optimizes the visibility of the floating element by choosing the placement
+   * that has the most space available automatically, without needing to specify a
+   * preferred placement. Alternative to `flip`.
+   * @see https://floating-ui.com/docs/autoPlacement
+   */
+  const autoPlacement = function (options) {
+    if (options === void 0) {
+      options = {};
     }
+    return {
+      name: 'autoPlacement',
+      options,
+      async fn(state) {
+        var _middlewareData$autoP, _middlewareData$autoP2, _placementsThatFitOnE;
+        const {
+          rects,
+          middlewareData,
+          placement,
+          platform,
+          elements
+        } = state;
+        const {
+          crossAxis = false,
+          alignment,
+          allowedPlacements = placements,
+          autoAlignment = true,
+          ...detectOverflowOptions
+        } = evaluate(options, state);
+        const placements$1 = alignment !== undefined || allowedPlacements === placements ? getPlacementList(alignment || null, autoAlignment, allowedPlacements) : allowedPlacements;
+        const overflow = await detectOverflow$1(state, detectOverflowOptions);
+        const currentIndex = ((_middlewareData$autoP = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP.index) || 0;
+        const currentPlacement = placements$1[currentIndex];
+        if (currentPlacement == null) {
+          return {};
+        }
+        const alignmentSides = getAlignmentSides$1(currentPlacement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)));
 
-    const alignment = getAlignment(placement);
-    const mainAxis = getMainAxisFromPlacement(placement);
-    const length = getLengthFromAxis(mainAxis);
-    let mainAlignmentSide = mainAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';
-
-    if (rects.reference[length] > rects.floating[length]) {
-      mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
-    }
+        // Make `computeCoords` start from the right place.
+        if (placement !== currentPlacement) {
+          return {
+            reset: {
+              placement: placements$1[0]
+            }
+          };
+        }
+        const currentOverflows = [overflow[getSide$1(currentPlacement)], overflow[alignmentSides[0]], overflow[alignmentSides[1]]];
+        const allOverflows = [...(((_middlewareData$autoP2 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP2.overflows) || []), {
+          placement: currentPlacement,
+          overflows: currentOverflows
+        }];
+        const nextPlacement = placements$1[currentIndex + 1];
 
-    return {
-      main: mainAlignmentSide,
-      cross: getOppositePlacement(mainAlignmentSide)
+        // There are more placements to check.
+        if (nextPlacement) {
+          return {
+            data: {
+              index: currentIndex + 1,
+              overflows: allOverflows
+            },
+            reset: {
+              placement: nextPlacement
+            }
+          };
+        }
+        const placementsSortedByMostSpace = allOverflows.map(d => {
+          const alignment = getAlignment$1(d.placement);
+          return [d.placement, alignment && crossAxis ?
+          // Check along the mainAxis and main crossAxis side.
+          d.overflows.slice(0, 2).reduce((acc, v) => acc + v, 0) :
+          // Check only the mainAxis.
+          d.overflows[0], d.overflows];
+        }).sort((a, b) => a[1] - b[1]);
+        const placementsThatFitOnEachSide = placementsSortedByMostSpace.filter(d => d[2].slice(0,
+        // Aligned placements should not check their opposite crossAxis
+        // side.
+        getAlignment$1(d[0]) ? 2 : 3).every(v => v <= 0));
+        const resetPlacement = ((_placementsThatFitOnE = placementsThatFitOnEachSide[0]) == null ? void 0 : _placementsThatFitOnE[0]) || placementsSortedByMostSpace[0][0];
+        if (resetPlacement !== placement) {
+          return {
+            data: {
+              index: currentIndex + 1,
+              overflows: allOverflows
+            },
+            reset: {
+              placement: resetPlacement
+            }
+          };
+        }
+        return {};
+      }
     };
-  }
-
-  const hash = {
-    start: 'end',
-    end: 'start'
   };
-  function getOppositeAlignmentPlacement(placement) {
-    return placement.replace(/start|end/g, matched => hash[matched]);
-  }
-
-  function getExpandedPlacements(placement) {
-    const oppositePlacement = getOppositePlacement(placement);
-    return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
-  }
 
   /**
-   * Changes the placement of the floating element to one that will fit if the
-   * initially specified `placement` does not.
+   * Optimizes the visibility of the floating element by flipping the `placement`
+   * in order to keep it in view when the preferred placement(s) will overflow the
+   * clipping boundary. Alternative to `autoPlacement`.
    * @see https://floating-ui.com/docs/flip
    */
-  const flip = function (options) {
+  const flip$1 = function (options) {
     if (options === void 0) {
       options = {};
     }
-
     return {
       name: 'flip',
       options,
-
-      async fn(middlewareArguments) {
-        var _middlewareData$flip;
-
+      async fn(state) {
+        var _middlewareData$arrow, _middlewareData$flip;
         const {
           placement,
           middlewareData,
@@ -10519,48 +10670,56 @@
           initialPlacement,
           platform,
           elements
-        } = middlewareArguments;
+        } = state;
         const {
           mainAxis: checkMainAxis = true,
           crossAxis: checkCrossAxis = true,
           fallbackPlacements: specifiedFallbackPlacements,
           fallbackStrategy = 'bestFit',
+          fallbackAxisSideDirection = 'none',
           flipAlignment = true,
           ...detectOverflowOptions
-        } = options;
-        const side = getSide(placement);
-        const isBasePlacement = side === initialPlacement;
-        const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
+        } = evaluate(options, state);
+
+        // If a reset by the arrow was caused due to an alignment offset being
+        // added, we should skip any logic now since `flip()` has already done its
+        // work.
+        // https://github.com/floating-ui/floating-ui/issues/2549#issuecomment-1719601643
+        if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
+          return {};
+        }
+        const side = getSide$1(placement);
+        const initialSideAxis = getSideAxis(initialPlacement);
+        const isBasePlacement = getSide$1(initialPlacement) === initialPlacement;
+        const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
+        const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement$1(initialPlacement)] : getExpandedPlacements$1(initialPlacement));
+        const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== 'none';
+        if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {
+          fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
+        }
         const placements = [initialPlacement, ...fallbackPlacements];
-        const overflow = await detectOverflow(middlewareArguments, detectOverflowOptions);
+        const overflow = await detectOverflow$1(state, detectOverflowOptions);
         const overflows = [];
         let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
-
         if (checkMainAxis) {
           overflows.push(overflow[side]);
         }
-
         if (checkCrossAxis) {
-          const {
-            main,
-            cross
-          } = getAlignmentSides(placement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)));
-          overflows.push(overflow[main], overflow[cross]);
+          const sides = getAlignmentSides$1(placement, rects, rtl);
+          overflows.push(overflow[sides[0]], overflow[sides[1]]);
         }
-
         overflowsData = [...overflowsData, {
           placement,
           overflows
-        }]; // One or more sides is overflowing
+        }];
 
+        // One or more sides is overflowing.
         if (!overflows.every(side => side <= 0)) {
-          var _middlewareData$flip$, _middlewareData$flip2;
-
-          const nextIndex = ((_middlewareData$flip$ = (_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) != null ? _middlewareData$flip$ : 0) + 1;
+          var _middlewareData$flip2, _overflowsData$filter;
+          const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
           const nextPlacement = placements[nextIndex];
-
           if (nextPlacement) {
-            // Try next placement and re-run the lifecycle
+            // Try next placement and re-run the lifecycle.
             return {
               data: {
                 index: nextIndex,
@@ -10572,27 +10731,36 @@
             };
           }
 
-          let resetPlacement = 'bottom';
-
-          switch (fallbackStrategy) {
-            case 'bestFit':
-              {
-                var _overflowsData$map$so;
-
-                const placement = (_overflowsData$map$so = overflowsData.map(d => [d, d.overflows.filter(overflow => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$map$so[0].placement;
+          // First, find the candidates that fit on the mainAxis side of overflow,
+          // then find the placement that fits the best on the main crossAxis side.
+          let resetPlacement = (_overflowsData$filter = overflowsData.filter(d => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;
 
-                if (placement) {
-                  resetPlacement = placement;
+          // Otherwise fallback.
+          if (!resetPlacement) {
+            switch (fallbackStrategy) {
+              case 'bestFit':
+                {
+                  var _overflowsData$filter2;
+                  const placement = (_overflowsData$filter2 = overflowsData.filter(d => {
+                    if (hasFallbackAxisSideDirection) {
+                      const currentSideAxis = getSideAxis(d.placement);
+                      return currentSideAxis === initialSideAxis ||
+                      // Create a bias to the `y` side axis due to horizontal
+                      // reading directions favoring greater width.
+                      currentSideAxis === 'y';
+                    }
+                    return true;
+                  }).map(d => [d.placement, d.overflows.filter(overflow => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0];
+                  if (placement) {
+                    resetPlacement = placement;
+                  }
+                  break;
                 }
-
+              case 'initialPlacement':
+                resetPlacement = initialPlacement;
                 break;
-              }
-
-            case 'initialPlacement':
-              resetPlacement = initialPlacement;
-              break;
+            }
           }
-
           if (placement !== resetPlacement) {
             return {
               reset: {
@@ -10601,27 +10769,229 @@
             };
           }
         }
-
         return {};
       }
+    };
+  };
 
+  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);
+  }
+  /**
+   * Provides data to hide the floating element in applicable situations, such as
+   * when it is not in the same clipping context as the reference element.
+   * @see https://floating-ui.com/docs/hide
+   */
+  const hide = function (options) {
+    if (options === void 0) {
+      options = {};
+    }
+    return {
+      name: 'hide',
+      options,
+      async fn(state) {
+        const {
+          rects
+        } = state;
+        const {
+          strategy = 'referenceHidden',
+          ...detectOverflowOptions
+        } = evaluate(options, state);
+        switch (strategy) {
+          case 'referenceHidden':
+            {
+              const overflow = await detectOverflow$1(state, {
+                ...detectOverflowOptions,
+                elementContext: 'reference'
+              });
+              const offsets = getSideOffsets(overflow, rects.reference);
+              return {
+                data: {
+                  referenceHiddenOffsets: offsets,
+                  referenceHidden: isAnySideFullyClipped(offsets)
+                }
+              };
+            }
+          case 'escaped':
+            {
+              const overflow = await detectOverflow$1(state, {
+                ...detectOverflowOptions,
+                altBoundary: true
+              });
+              const offsets = getSideOffsets(overflow, rects.floating);
+              return {
+                data: {
+                  escapedOffsets: offsets,
+                  escaped: isAnySideFullyClipped(offsets)
+                }
+              };
+            }
+          default:
+            {
+              return {};
+            }
+        }
+      }
     };
   };
 
-  async function convertValueToCoords(middlewareArguments, value) {
+  function getBoundingRect(rects) {
+    const minX = min$3(...rects.map(rect => rect.left));
+    const minY = min$3(...rects.map(rect => rect.top));
+    const maxX = max$3(...rects.map(rect => rect.right));
+    const maxY = max$3(...rects.map(rect => rect.bottom));
+    return {
+      x: minX,
+      y: minY,
+      width: maxX - minX,
+      height: maxY - minY
+    };
+  }
+  function getRectsByLine(rects) {
+    const sortedRects = rects.slice().sort((a, b) => a.y - b.y);
+    const groups = [];
+    let prevRect = null;
+    for (let i = 0; i < sortedRects.length; i++) {
+      const rect = sortedRects[i];
+      if (!prevRect || rect.y - prevRect.y > prevRect.height / 2) {
+        groups.push([rect]);
+      } else {
+        groups[groups.length - 1].push(rect);
+      }
+      prevRect = rect;
+    }
+    return groups.map(rect => rectToClientRect$1(getBoundingRect(rect)));
+  }
+  /**
+   * Provides improved positioning for inline reference elements that can span
+   * over multiple lines, such as hyperlinks or range selections.
+   * @see https://floating-ui.com/docs/inline
+   */
+  const inline = function (options) {
+    if (options === void 0) {
+      options = {};
+    }
+    return {
+      name: 'inline',
+      options,
+      async fn(state) {
+        const {
+          placement,
+          elements,
+          rects,
+          platform,
+          strategy
+        } = state;
+        // A MouseEvent's client{X,Y} coords can be up to 2 pixels off a
+        // ClientRect's bounds, despite the event listener being triggered. A
+        // padding of 2 seems to handle this issue.
+        const {
+          padding = 2,
+          x,
+          y
+        } = evaluate(options, state);
+        const nativeClientRects = Array.from((await (platform.getClientRects == null ? void 0 : platform.getClientRects(elements.reference))) || []);
+        const clientRects = getRectsByLine(nativeClientRects);
+        const fallback = rectToClientRect$1(getBoundingRect(nativeClientRects));
+        const paddingObject = getPaddingObject(padding);
+        function getBoundingClientRect() {
+          // There are two rects and they are disjoined.
+          if (clientRects.length === 2 && clientRects[0].left > clientRects[1].right && x != null && y != null) {
+            // Find the first rect in which the point is fully inside.
+            return clientRects.find(rect => x > rect.left - paddingObject.left && x < rect.right + paddingObject.right && y > rect.top - paddingObject.top && y < rect.bottom + paddingObject.bottom) || fallback;
+          }
+
+          // There are 2 or more connected rects.
+          if (clientRects.length >= 2) {
+            if (getSideAxis(placement) === 'y') {
+              const firstRect = clientRects[0];
+              const lastRect = clientRects[clientRects.length - 1];
+              const isTop = getSide$1(placement) === 'top';
+              const top = firstRect.top;
+              const bottom = lastRect.bottom;
+              const left = isTop ? firstRect.left : lastRect.left;
+              const right = isTop ? firstRect.right : lastRect.right;
+              const width = right - left;
+              const height = bottom - top;
+              return {
+                top,
+                bottom,
+                left,
+                right,
+                width,
+                height,
+                x: left,
+                y: top
+              };
+            }
+            const isLeftSide = getSide$1(placement) === 'left';
+            const maxRight = max$3(...clientRects.map(rect => rect.right));
+            const minLeft = min$3(...clientRects.map(rect => rect.left));
+            const measureRects = clientRects.filter(rect => isLeftSide ? rect.left === minLeft : rect.right === maxRight);
+            const top = measureRects[0].top;
+            const bottom = measureRects[measureRects.length - 1].bottom;
+            const left = minLeft;
+            const right = maxRight;
+            const width = right - left;
+            const height = bottom - top;
+            return {
+              top,
+              bottom,
+              left,
+              right,
+              width,
+              height,
+              x: left,
+              y: top
+            };
+          }
+          return fallback;
+        }
+        const resetRects = await platform.getElementRects({
+          reference: {
+            getBoundingClientRect
+          },
+          floating: elements.floating,
+          strategy
+        });
+        if (rects.reference.x !== resetRects.reference.x || rects.reference.y !== resetRects.reference.y || rects.reference.width !== resetRects.reference.width || rects.reference.height !== resetRects.reference.height) {
+          return {
+            reset: {
+              rects: resetRects
+            }
+          };
+        }
+        return {};
+      }
+    };
+  };
+
+  // For type backwards-compatibility, the `OffsetOptions` type was also
+  // Derivable.
+
+  async function convertValueToCoords$1(state, options) {
     const {
       placement,
       platform,
       elements
-    } = middlewareArguments;
+    } = state;
     const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
-    const side = getSide(placement);
-    const alignment = getAlignment(placement);
-    const isVertical = getMainAxisFromPlacement(placement) === 'x';
+    const side = getSide$1(placement);
+    const alignment = getAlignment$1(placement);
+    const isVertical = getSideAxis(placement) === 'y';
     const mainAxisMulti = ['left', 'top'].includes(side) ? -1 : 1;
     const crossAxisMulti = rtl && isVertical ? -1 : 1;
-    const rawValue = typeof value === 'function' ? value(middlewareArguments) : value; // eslint-disable-next-line prefer-const
+    const rawValue = evaluate(options, state);
 
+    // eslint-disable-next-line prefer-const
     let {
       mainAxis,
       crossAxis,
@@ -10636,11 +11006,9 @@
       alignmentAxis: null,
       ...rawValue
     };
-
     if (alignment && typeof alignmentAxis === 'number') {
       crossAxis = alignment === 'end' ? alignmentAxis * -1 : alignmentAxis;
     }
-
     return isVertical ? {
       x: crossAxis * crossAxisMulti,
       y: mainAxis * mainAxisMulti
@@ -10649,60 +11017,66 @@
       y: crossAxis * crossAxisMulti
     };
   }
+
   /**
-   * Displaces the floating element from its reference element.
+   * Modifies the placement by translating the floating element along the
+   * specified axes.
+   * A number (shorthand for `mainAxis` or distance), or an axes configuration
+   * object may be passed.
    * @see https://floating-ui.com/docs/offset
    */
-
-  const offset = function (value) {
-    if (value === void 0) {
-      value = 0;
+  const offset$1 = function (options) {
+    if (options === void 0) {
+      options = 0;
     }
-
     return {
       name: 'offset',
-      options: value,
-
-      async fn(middlewareArguments) {
+      options,
+      async fn(state) {
+        var _middlewareData$offse, _middlewareData$arrow;
         const {
           x,
-          y
-        } = middlewareArguments;
-        const diffCoords = await convertValueToCoords(middlewareArguments, value);
+          y,
+          placement,
+          middlewareData
+        } = state;
+        const diffCoords = await convertValueToCoords$1(state, options);
+
+        // If the placement is the same and the arrow caused an alignment offset
+        // then we don't need to change the positioning coordinates.
+        if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
+          return {};
+        }
         return {
           x: x + diffCoords.x,
           y: y + diffCoords.y,
-          data: diffCoords
+          data: {
+            ...diffCoords,
+            placement
+          }
         };
       }
-
     };
   };
 
-  function getCrossAxis(axis) {
-    return axis === 'x' ? 'y' : 'x';
-  }
-
   /**
-   * Shifts the floating element in order to keep it in view when it will overflow
-   * a clipping boundary.
+   * Optimizes the visibility of the floating element by shifting it in order to
+   * keep it in view when it will overflow the clipping boundary.
    * @see https://floating-ui.com/docs/shift
    */
-  const shift = function (options) {
+  const shift$1 = function (options) {
     if (options === void 0) {
       options = {};
     }
-
     return {
       name: 'shift',
       options,
-
-      async fn(middlewareArguments) {
+      async fn(state) {
         const {
           x,
           y,
           placement
-        } = middlewareArguments;
+        } = state;
         const {
           mainAxis: checkMainAxis = true,
           crossAxis: checkCrossAxis = false,
@@ -10719,424 +11093,547 @@
             }
           },
           ...detectOverflowOptions
-        } = options;
+        } = evaluate(options, state);
         const coords = {
           x,
           y
         };
-        const overflow = await detectOverflow(middlewareArguments, detectOverflowOptions);
-        const mainAxis = getMainAxisFromPlacement(getSide(placement));
-        const crossAxis = getCrossAxis(mainAxis);
+        const overflow = await detectOverflow$1(state, detectOverflowOptions);
+        const crossAxis = getSideAxis(getSide$1(placement));
+        const mainAxis = getOppositeAxis(crossAxis);
         let mainAxisCoord = coords[mainAxis];
         let crossAxisCoord = coords[crossAxis];
-
         if (checkMainAxis) {
           const minSide = mainAxis === 'y' ? 'top' : 'left';
           const maxSide = mainAxis === 'y' ? 'bottom' : 'right';
           const min = mainAxisCoord + overflow[minSide];
           const max = mainAxisCoord - overflow[maxSide];
-          mainAxisCoord = within(min, mainAxisCoord, max);
+          mainAxisCoord = clamp(min, mainAxisCoord, max);
         }
-
         if (checkCrossAxis) {
           const minSide = crossAxis === 'y' ? 'top' : 'left';
           const maxSide = crossAxis === 'y' ? 'bottom' : 'right';
           const min = crossAxisCoord + overflow[minSide];
           const max = crossAxisCoord - overflow[maxSide];
-          crossAxisCoord = within(min, crossAxisCoord, max);
+          crossAxisCoord = clamp(min, crossAxisCoord, max);
         }
-
-        const limitedCoords = limiter.fn({ ...middlewareArguments,
+        const limitedCoords = limiter.fn({
+          ...state,
           [mainAxis]: mainAxisCoord,
           [crossAxis]: crossAxisCoord
         });
-        return { ...limitedCoords,
+        return {
+          ...limitedCoords,
           data: {
             x: limitedCoords.x - x,
             y: limitedCoords.y - y
           }
         };
       }
-
     };
   };
-
-  function isWindow(value) {
-    return value && value.document && value.location && value.alert && value.setInterval;
-  }
-  function getWindow(node) {
-    if (node == null) {
-      return window;
+  /**
+   * Built-in `limiter` that will stop `shift()` at a certain point.
+   */
+  const limitShift = function (options) {
+    if (options === void 0) {
+      options = {};
     }
+    return {
+      options,
+      fn(state) {
+        const {
+          x,
+          y,
+          placement,
+          rects,
+          middlewareData
+        } = state;
+        const {
+          offset = 0,
+          mainAxis: checkMainAxis = true,
+          crossAxis: checkCrossAxis = true
+        } = evaluate(options, state);
+        const coords = {
+          x,
+          y
+        };
+        const crossAxis = getSideAxis(placement);
+        const mainAxis = getOppositeAxis(crossAxis);
+        let mainAxisCoord = coords[mainAxis];
+        let crossAxisCoord = coords[crossAxis];
+        const rawOffset = evaluate(offset, state);
+        const computedOffset = typeof rawOffset === 'number' ? {
+          mainAxis: rawOffset,
+          crossAxis: 0
+        } : {
+          mainAxis: 0,
+          crossAxis: 0,
+          ...rawOffset
+        };
+        if (checkMainAxis) {
+          const len = mainAxis === 'y' ? 'height' : 'width';
+          const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;
+          const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;
+          if (mainAxisCoord < limitMin) {
+            mainAxisCoord = limitMin;
+          } else if (mainAxisCoord > limitMax) {
+            mainAxisCoord = limitMax;
+          }
+        }
+        if (checkCrossAxis) {
+          var _middlewareData$offse, _middlewareData$offse2;
+          const len = mainAxis === 'y' ? 'width' : 'height';
+          const isOriginSide = ['top', 'left'].includes(getSide$1(placement));
+          const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);
+          const limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : ((_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0);
+          if (crossAxisCoord < limitMin) {
+            crossAxisCoord = limitMin;
+          } else if (crossAxisCoord > limitMax) {
+            crossAxisCoord = limitMax;
+          }
+        }
+        return {
+          [mainAxis]: mainAxisCoord,
+          [crossAxis]: crossAxisCoord
+        };
+      }
+    };
+  };
 
-    if (!isWindow(node)) {
-      const ownerDocument = node.ownerDocument;
-      return ownerDocument ? ownerDocument.defaultView || window : window;
+  /**
+   * Provides data that allows you to change the size of the floating element —
+   * for instance, prevent it from overflowing the clipping boundary or match the
+   * width of the reference element.
+   * @see https://floating-ui.com/docs/size
+   */
+  const size = function (options) {
+    if (options === void 0) {
+      options = {};
     }
+    return {
+      name: 'size',
+      options,
+      async fn(state) {
+        const {
+          placement,
+          rects,
+          platform,
+          elements
+        } = state;
+        const {
+          apply = () => {},
+          ...detectOverflowOptions
+        } = evaluate(options, state);
+        const overflow = await detectOverflow$1(state, detectOverflowOptions);
+        const side = getSide$1(placement);
+        const alignment = getAlignment$1(placement);
+        const isYAxis = getSideAxis(placement) === 'y';
+        const {
+          width,
+          height
+        } = rects.floating;
+        let heightSide;
+        let widthSide;
+        if (side === 'top' || side === 'bottom') {
+          heightSide = side;
+          widthSide = alignment === ((await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating))) ? 'start' : 'end') ? 'left' : 'right';
+        } else {
+          widthSide = side;
+          heightSide = alignment === 'end' ? 'top' : 'bottom';
+        }
+        const maximumClippingHeight = height - overflow.top - overflow.bottom;
+        const maximumClippingWidth = width - overflow.left - overflow.right;
+        const overflowAvailableHeight = min$3(height - overflow[heightSide], maximumClippingHeight);
+        const overflowAvailableWidth = min$3(width - overflow[widthSide], maximumClippingWidth);
+        const noShift = !state.middlewareData.shift;
+        let availableHeight = overflowAvailableHeight;
+        let availableWidth = overflowAvailableWidth;
+        if (isYAxis) {
+          availableWidth = alignment || noShift ? min$3(overflowAvailableWidth, maximumClippingWidth) : maximumClippingWidth;
+        } else {
+          availableHeight = alignment || noShift ? min$3(overflowAvailableHeight, maximumClippingHeight) : maximumClippingHeight;
+        }
+        if (noShift && !alignment) {
+          const xMin = max$3(overflow.left, 0);
+          const xMax = max$3(overflow.right, 0);
+          const yMin = max$3(overflow.top, 0);
+          const yMax = max$3(overflow.bottom, 0);
+          if (isYAxis) {
+            availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max$3(overflow.left, overflow.right));
+          } else {
+            availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max$3(overflow.top, overflow.bottom));
+          }
+        }
+        await apply({
+          ...state,
+          availableWidth,
+          availableHeight
+        });
+        const nextDimensions = await platform.getDimensions(elements.floating);
+        if (width !== nextDimensions.width || height !== nextDimensions.height) {
+          return {
+            reset: {
+              rects: true
+            }
+          };
+        }
+        return {};
+      }
+    };
+  };
 
-    return node;
-  }
-
-  function getComputedStyle$1(element) {
-    return getWindow(element).getComputedStyle(element);
+  function getNodeName$1(node) {
+    if (isNode$1(node)) {
+      return (node.nodeName || '').toLowerCase();
+    }
+    // Mocked nodes in testing environments may not be instances of Node. By
+    // returning `#document` an infinite loop won't occur.
+    // https://github.com/floating-ui/floating-ui/issues/2317
+    return '#document';
   }
-
-  function getNodeName(node) {
-    return isWindow(node) ? '' : node ? (node.nodeName || '').toLowerCase() : '';
+  function getWindow$1(node) {
+    var _node$ownerDocument;
+    return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
   }
-
-  function getUAString() {
-    const uaData = navigator.userAgentData;
-
-    if (uaData != null && uaData.brands) {
-      return uaData.brands.map(item => item.brand + "/" + item.version).join(' ');
-    }
-
-    return navigator.userAgent;
+  function getDocumentElement$1(node) {
+    var _ref;
+    return (_ref = (isNode$1(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
   }
-
-  function isHTMLElement(value) {
-    return value instanceof getWindow(value).HTMLElement;
+  function isNode$1(value) {
+    return value instanceof Node || value instanceof getWindow$1(value).Node;
   }
-  function isElement(value) {
-    return value instanceof getWindow(value).Element;
+  function isElement$1(value) {
+    return value instanceof Element || value instanceof getWindow$1(value).Element;
   }
-  function isNode(value) {
-    return value instanceof getWindow(value).Node;
+  function isHTMLElement$1(value) {
+    return value instanceof HTMLElement || value instanceof getWindow$1(value).HTMLElement;
   }
-  function isShadowRoot(node) {
-    // Browsers without `ShadowRoot` support
+  function isShadowRoot$1(value) {
+    // Browsers without `ShadowRoot` support.
     if (typeof ShadowRoot === 'undefined') {
       return false;
     }
-
-    const OwnElement = getWindow(node).ShadowRoot;
-    return node instanceof OwnElement || node instanceof ShadowRoot;
+    return value instanceof ShadowRoot || value instanceof getWindow$1(value).ShadowRoot;
   }
-  function isOverflowElement(element) {
-    // Firefox wants us to check `-x` and `-y` variations as well
+  function isOverflowElement$1(element) {
     const {
       overflow,
       overflowX,
-      overflowY
-    } = getComputedStyle$1(element);
-    return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
-  }
-  function isTableElement(element) {
-    return ['table', 'td', 'th'].includes(getNodeName(element));
+      overflowY,
+      display
+    } = getComputedStyle$2(element);
+    return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);
   }
-  function isContainingBlock(element) {
-    // TODO: Try and use feature detection here instead
-    const isFirefox = /firefox/i.test(getUAString());
-    const css = getComputedStyle$1(element); // This is non-exhaustive but covers the most common CSS properties that
-    // create a containing block.
-    // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
-
-    return css.transform !== 'none' || css.perspective !== 'none' || // @ts-ignore (TS 4.1 compat)
-    css.contain === 'paint' || ['transform', 'perspective'].includes(css.willChange) || isFirefox && css.willChange === 'filter' || isFirefox && (css.filter ? css.filter !== 'none' : false);
+  function isTableElement$1(element) {
+    return ['table', 'td', 'th'].includes(getNodeName$1(element));
   }
-  function isLayoutViewport() {
-    // Not Safari
-    return !/^((?!chrome|android).)*safari/i.test(getUAString()); // Feature detection for this fails in various ways
-    // • Always-visible scrollbar or not
-    // • Width of <html>, etc.
-    // const vV = win.visualViewport;
-    // return vV ? Math.abs(win.innerWidth / vV.scale - vV.width) < 0.5 : true;
+  function isTopLayer(element) {
+    return [':popover-open', ':modal'].some(selector => {
+      try {
+        return element.matches(selector);
+      } catch (e) {
+        return false;
+      }
+    });
   }
+  function isContainingBlock$1(elementOrCss) {
+    const webkit = isWebKit();
+    const css = isElement$1(elementOrCss) ? getComputedStyle$2(elementOrCss) : elementOrCss;
 
-  const min$1 = Math.min;
-  const max$1 = Math.max;
-  const round = Math.round;
-
-  function getBoundingClientRect(element, includeScale, isFixedStrategy) {
-    var _win$visualViewport$o, _win$visualViewport, _win$visualViewport$o2, _win$visualViewport2;
-
-    if (includeScale === void 0) {
-      includeScale = false;
-    }
-
-    if (isFixedStrategy === void 0) {
-      isFixedStrategy = false;
-    }
-
-    const clientRect = element.getBoundingClientRect();
-    let scaleX = 1;
-    let scaleY = 1;
-
-    if (includeScale && isHTMLElement(element)) {
-      scaleX = element.offsetWidth > 0 ? round(clientRect.width) / element.offsetWidth || 1 : 1;
-      scaleY = element.offsetHeight > 0 ? round(clientRect.height) / element.offsetHeight || 1 : 1;
+    // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
+    return css.transform !== 'none' || css.perspective !== 'none' || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));
+  }
+  function getContainingBlock$1(element) {
+    let currentNode = getParentNode$1(element);
+    while (isHTMLElement$1(currentNode) && !isLastTraversableNode(currentNode)) {
+      if (isContainingBlock$1(currentNode)) {
+        return currentNode;
+      } else if (isTopLayer(currentNode)) {
+        return null;
+      }
+      currentNode = getParentNode$1(currentNode);
     }
-
-    const win = isElement(element) ? getWindow(element) : window;
-    const addVisualOffsets = !isLayoutViewport() && isFixedStrategy;
-    const x = (clientRect.left + (addVisualOffsets ? (_win$visualViewport$o = (_win$visualViewport = win.visualViewport) == null ? void 0 : _win$visualViewport.offsetLeft) != null ? _win$visualViewport$o : 0 : 0)) / scaleX;
-    const y = (clientRect.top + (addVisualOffsets ? (_win$visualViewport$o2 = (_win$visualViewport2 = win.visualViewport) == null ? void 0 : _win$visualViewport2.offsetTop) != null ? _win$visualViewport$o2 : 0 : 0)) / scaleY;
-    const width = clientRect.width / scaleX;
-    const height = clientRect.height / scaleY;
-    return {
-      width,
-      height,
-      top: y,
-      right: x + width,
-      bottom: y + height,
-      left: x,
-      x,
-      y
-    };
+    return null;
   }
-
-  function getDocumentElement(node) {
-    return ((isNode(node) ? node.ownerDocument : node.document) || window.document).documentElement;
+  function isWebKit() {
+    if (typeof CSS === 'undefined' || !CSS.supports) return false;
+    return CSS.supports('-webkit-backdrop-filter', 'none');
   }
-
-  function getNodeScroll(element) {
-    if (isElement(element)) {
+  function isLastTraversableNode(node) {
+    return ['html', 'body', '#document'].includes(getNodeName$1(node));
+  }
+  function getComputedStyle$2(element) {
+    return getWindow$1(element).getComputedStyle(element);
+  }
+  function getNodeScroll$1(element) {
+    if (isElement$1(element)) {
       return {
         scrollLeft: element.scrollLeft,
         scrollTop: element.scrollTop
       };
     }
-
     return {
-      scrollLeft: element.pageXOffset,
-      scrollTop: element.pageYOffset
+      scrollLeft: element.scrollX,
+      scrollTop: element.scrollY
     };
   }
-
-  function getWindowScrollBarX(element) {
-    // If <html> has a CSS width greater than the viewport, then this will be
-    // incorrect for RTL.
-    return getBoundingClientRect(getDocumentElement(element)).left + getNodeScroll(element).scrollLeft;
+  function getParentNode$1(node) {
+    if (getNodeName$1(node) === 'html') {
+      return node;
+    }
+    const result =
+    // Step into the shadow DOM of the parent of a slotted node.
+    node.assignedSlot ||
+    // DOM Element detected.
+    node.parentNode ||
+    // ShadowRoot detected.
+    isShadowRoot$1(node) && node.host ||
+    // Fallback.
+    getDocumentElement$1(node);
+    return isShadowRoot$1(result) ? result.host : result;
+  }
+  function getNearestOverflowAncestor$1(node) {
+    const parentNode = getParentNode$1(node);
+    if (isLastTraversableNode(parentNode)) {
+      return node.ownerDocument ? node.ownerDocument.body : node.body;
+    }
+    if (isHTMLElement$1(parentNode) && isOverflowElement$1(parentNode)) {
+      return parentNode;
+    }
+    return getNearestOverflowAncestor$1(parentNode);
   }
-
-  function isScaled(element) {
-    const rect = getBoundingClientRect(element);
-    return round(rect.width) !== element.offsetWidth || round(rect.height) !== element.offsetHeight;
+  function getOverflowAncestors$1(node, list, traverseIframes) {
+    var _node$ownerDocument2;
+    if (list === void 0) {
+      list = [];
+    }
+    if (traverseIframes === void 0) {
+      traverseIframes = true;
+    }
+    const scrollableAncestor = getNearestOverflowAncestor$1(node);
+    const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
+    const win = getWindow$1(scrollableAncestor);
+    if (isBody) {
+      return list.concat(win, win.visualViewport || [], isOverflowElement$1(scrollableAncestor) ? scrollableAncestor : [], win.frameElement && traverseIframes ? getOverflowAncestors$1(win.frameElement) : []);
+    }
+    return list.concat(scrollableAncestor, getOverflowAncestors$1(scrollableAncestor, [], traverseIframes));
   }
 
-  function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
-    const isOffsetParentAnElement = isHTMLElement(offsetParent);
-    const documentElement = getDocumentElement(offsetParent);
-    const rect = getBoundingClientRect(element, // @ts-ignore - checked above (TS 4.1 compat)
-    isOffsetParentAnElement && isScaled(offsetParent), strategy === 'fixed');
-    let scroll = {
-      scrollLeft: 0,
-      scrollTop: 0
-    };
-    const offsets = {
-      x: 0,
-      y: 0
-    };
-
-    if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== 'fixed') {
-      if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
-        scroll = getNodeScroll(offsetParent);
-      }
-
-      if (isHTMLElement(offsetParent)) {
-        const offsetRect = getBoundingClientRect(offsetParent, true);
-        offsets.x = offsetRect.x + offsetParent.clientLeft;
-        offsets.y = offsetRect.y + offsetParent.clientTop;
-      } else if (documentElement) {
-        offsets.x = getWindowScrollBarX(documentElement);
-      }
+  function getCssDimensions(element) {
+    const css = getComputedStyle$2(element);
+    // In testing environments, the `width` and `height` properties are empty
+    // strings for SVG elements, returning NaN. Fallback to `0` in this case.
+    let width = parseFloat(css.width) || 0;
+    let height = parseFloat(css.height) || 0;
+    const hasOffset = isHTMLElement$1(element);
+    const offsetWidth = hasOffset ? element.offsetWidth : width;
+    const offsetHeight = hasOffset ? element.offsetHeight : height;
+    const shouldFallback = round$1(width) !== offsetWidth || round$1(height) !== offsetHeight;
+    if (shouldFallback) {
+      width = offsetWidth;
+      height = offsetHeight;
     }
-
     return {
-      x: rect.left + scroll.scrollLeft - offsets.x,
-      y: rect.top + scroll.scrollTop - offsets.y,
-      width: rect.width,
-      height: rect.height
+      width,
+      height,
+      $: shouldFallback
     };
   }
 
-  function getParentNode(node) {
-    if (getNodeName(node) === 'html') {
-      return node;
-    }
-
-    return (// this is a quicker (but less type safe) way to save quite some bytes from the bundle
-      // @ts-ignore
-      node.assignedSlot || // step into the shadow DOM of the parent of a slotted node
-      node.parentNode || ( // DOM Element detected
-      isShadowRoot(node) ? node.host : null) || // ShadowRoot detected
-      getDocumentElement(node) // fallback
-
-    );
+  function unwrapElement(element) {
+    return !isElement$1(element) ? element.contextElement : element;
   }
 
-  function getTrueOffsetParent(element) {
-    if (!isHTMLElement(element) || getComputedStyle$1(element).position === 'fixed') {
-      return null;
+  function getScale(element) {
+    const domElement = unwrapElement(element);
+    if (!isHTMLElement$1(domElement)) {
+      return createCoords(1);
     }
+    const rect = domElement.getBoundingClientRect();
+    const {
+      width,
+      height,
+      $
+    } = getCssDimensions(domElement);
+    let x = ($ ? round$1(rect.width) : rect.width) / width;
+    let y = ($ ? round$1(rect.height) : rect.height) / height;
 
-    return composedOffsetParent(element);
-  }
-  /**
-   * Polyfills the old offsetParent behavior from before the spec was changed:
-   * https://github.com/w3c/csswg-drafts/issues/159
-   */
-
-
-  function composedOffsetParent(element) {
-    let {
-      offsetParent
-    } = element;
-    let ancestor = element;
-    let foundInsideSlot = false;
-
-    while (ancestor && ancestor !== offsetParent) {
-      const {
-        assignedSlot
-      } = ancestor;
-
-      if (assignedSlot) {
-        let newOffsetParent = assignedSlot.offsetParent;
-
-        if (getComputedStyle$1(assignedSlot).display === 'contents') {
-          const hadStyleAttribute = assignedSlot.hasAttribute('style');
-          const oldDisplay = assignedSlot.style.display;
-          assignedSlot.style.display = getComputedStyle$1(ancestor).display;
-          newOffsetParent = assignedSlot.offsetParent;
-          assignedSlot.style.display = oldDisplay;
-
-          if (!hadStyleAttribute) {
-            assignedSlot.removeAttribute('style');
-          }
-        }
-
-        ancestor = assignedSlot;
-
-        if (offsetParent !== newOffsetParent) {
-          offsetParent = newOffsetParent;
-          foundInsideSlot = true;
-        }
-      } else if (isShadowRoot(ancestor) && ancestor.host && foundInsideSlot) {
-        break;
-      }
+    // 0, NaN, or Infinity should always fallback to 1.
 
-      ancestor = isShadowRoot(ancestor) && ancestor.host || ancestor.parentNode;
+    if (!x || !Number.isFinite(x)) {
+      x = 1;
     }
-
-    return offsetParent;
-  }
-
-  function getContainingBlock(element) {
-    let currentNode = getParentNode(element);
-
-    if (isShadowRoot(currentNode)) {
-      currentNode = currentNode.host;
+    if (!y || !Number.isFinite(y)) {
+      y = 1;
     }
+    return {
+      x,
+      y
+    };
+  }
 
-    while (isHTMLElement(currentNode) && !['html', 'body'].includes(getNodeName(currentNode))) {
-      if (isContainingBlock(currentNode)) {
-        return currentNode;
-      } else {
-        const parent = currentNode.parentNode;
-        currentNode = isShadowRoot(parent) ? parent.host : parent;
-      }
+  const noOffsets = /*#__PURE__*/createCoords(0);
+  function getVisualOffsets(element) {
+    const win = getWindow$1(element);
+    if (!isWebKit() || !win.visualViewport) {
+      return noOffsets;
     }
-
-    return null;
-  } // Gets the closest ancestor positioned element. Handles some edge cases,
-  // such as table ancestors and cross browser bugs.
-
-
-  function getOffsetParent(element) {
-    const window = getWindow(element);
-    let offsetParent = getTrueOffsetParent(element);
-
-    while (offsetParent && isTableElement(offsetParent) && getComputedStyle$1(offsetParent).position === 'static') {
-      offsetParent = getTrueOffsetParent(offsetParent);
+    return {
+      x: win.visualViewport.offsetLeft,
+      y: win.visualViewport.offsetTop
+    };
+  }
+  function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
+    if (isFixed === void 0) {
+      isFixed = false;
     }
-
-    if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle$1(offsetParent).position === 'static' && !isContainingBlock(offsetParent))) {
-      return window;
+    if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow$1(element)) {
+      return false;
     }
-
-    return offsetParent || getContainingBlock(element) || window;
+    return isFixed;
   }
 
-  function getDimensions(element) {
-    if (isHTMLElement(element)) {
-      return {
-        width: element.offsetWidth,
-        height: element.offsetHeight
-      };
+  function getBoundingClientRect$1(element, includeScale, isFixedStrategy, offsetParent) {
+    if (includeScale === void 0) {
+      includeScale = false;
     }
-
-    const rect = getBoundingClientRect(element);
-    return {
-      width: rect.width,
-      height: rect.height
-    };
+    if (isFixedStrategy === void 0) {
+      isFixedStrategy = false;
+    }
+    const clientRect = element.getBoundingClientRect();
+    const domElement = unwrapElement(element);
+    let scale = createCoords(1);
+    if (includeScale) {
+      if (offsetParent) {
+        if (isElement$1(offsetParent)) {
+          scale = getScale(offsetParent);
+        }
+      } else {
+        scale = getScale(element);
+      }
+    }
+    const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
+    let x = (clientRect.left + visualOffsets.x) / scale.x;
+    let y = (clientRect.top + visualOffsets.y) / scale.y;
+    let width = clientRect.width / scale.x;
+    let height = clientRect.height / scale.y;
+    if (domElement) {
+      const win = getWindow$1(domElement);
+      const offsetWin = offsetParent && isElement$1(offsetParent) ? getWindow$1(offsetParent) : offsetParent;
+      let currentWin = win;
+      let currentIFrame = currentWin.frameElement;
+      while (currentIFrame && offsetParent && offsetWin !== currentWin) {
+        const iframeScale = getScale(currentIFrame);
+        const iframeRect = currentIFrame.getBoundingClientRect();
+        const css = getComputedStyle$2(currentIFrame);
+        const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
+        const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
+        x *= iframeScale.x;
+        y *= iframeScale.y;
+        width *= iframeScale.x;
+        height *= iframeScale.y;
+        x += left;
+        y += top;
+        currentWin = getWindow$1(currentIFrame);
+        currentIFrame = currentWin.frameElement;
+      }
+    }
+    return rectToClientRect$1({
+      width,
+      height,
+      x,
+      y
+    });
   }
 
-  function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
+  function convertOffsetParentRelativeRectToViewportRelativeRect$1(_ref) {
     let {
+      elements,
       rect,
       offsetParent,
       strategy
     } = _ref;
-    const isOffsetParentAnElement = isHTMLElement(offsetParent);
-    const documentElement = getDocumentElement(offsetParent);
-
-    if (offsetParent === documentElement) {
+    const isFixed = strategy === 'fixed';
+    const documentElement = getDocumentElement$1(offsetParent);
+    const topLayer = elements ? isTopLayer(elements.floating) : false;
+    if (offsetParent === documentElement || topLayer && isFixed) {
       return rect;
     }
-
     let scroll = {
       scrollLeft: 0,
       scrollTop: 0
     };
-    const offsets = {
-      x: 0,
-      y: 0
-    };
-
-    if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== 'fixed') {
-      if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
-        scroll = getNodeScroll(offsetParent);
+    let scale = createCoords(1);
+    const offsets = createCoords(0);
+    const isOffsetParentAnElement = isHTMLElement$1(offsetParent);
+    if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+      if (getNodeName$1(offsetParent) !== 'body' || isOverflowElement$1(documentElement)) {
+        scroll = getNodeScroll$1(offsetParent);
       }
-
-      if (isHTMLElement(offsetParent)) {
-        const offsetRect = getBoundingClientRect(offsetParent, true);
+      if (isHTMLElement$1(offsetParent)) {
+        const offsetRect = getBoundingClientRect$1(offsetParent);
+        scale = getScale(offsetParent);
         offsets.x = offsetRect.x + offsetParent.clientLeft;
         offsets.y = offsetRect.y + offsetParent.clientTop;
-      } // This doesn't appear to be need to be negated.
-      // else if (documentElement) {
-      //   offsets.x = getWindowScrollBarX(documentElement);
-      // }
-
+      }
     }
+    return {
+      width: rect.width * scale.x,
+      height: rect.height * scale.y,
+      x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x,
+      y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y
+    };
+  }
 
-    return { ...rect,
-      x: rect.x - scroll.scrollLeft + offsets.x,
-      y: rect.y - scroll.scrollTop + offsets.y
+  function getClientRects(element) {
+    return Array.from(element.getClientRects());
+  }
+
+  function getWindowScrollBarX$1(element) {
+    // If <html> has a CSS width greater than the viewport, then this will be
+    // incorrect for RTL.
+    return getBoundingClientRect$1(getDocumentElement$1(element)).left + getNodeScroll$1(element).scrollLeft;
+  }
+
+  // Gets the entire size of the scrollable document area, even extending outside
+  // of the `<html>` and `<body>` rect bounds if horizontally scrollable.
+  function getDocumentRect$1(element) {
+    const html = getDocumentElement$1(element);
+    const scroll = getNodeScroll$1(element);
+    const body = element.ownerDocument.body;
+    const width = max$3(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
+    const height = max$3(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
+    let x = -scroll.scrollLeft + getWindowScrollBarX$1(element);
+    const y = -scroll.scrollTop;
+    if (getComputedStyle$2(body).direction === 'rtl') {
+      x += max$3(html.clientWidth, body.clientWidth) - width;
+    }
+    return {
+      width,
+      height,
+      x,
+      y
     };
   }
 
-  function getViewportRect(element, strategy) {
-    const win = getWindow(element);
-    const html = getDocumentElement(element);
+  function getViewportRect$1(element, strategy) {
+    const win = getWindow$1(element);
+    const html = getDocumentElement$1(element);
     const visualViewport = win.visualViewport;
     let width = html.clientWidth;
     let height = html.clientHeight;
     let x = 0;
     let y = 0;
-
     if (visualViewport) {
       width = visualViewport.width;
       height = visualViewport.height;
-      const layoutViewport = isLayoutViewport();
-
-      if (layoutViewport || !layoutViewport && strategy === 'fixed') {
+      const visualViewportBased = isWebKit();
+      if (!visualViewportBased || visualViewportBased && strategy === 'fixed') {
         x = visualViewport.offsetLeft;
         y = visualViewport.offsetTop;
       }
     }
-
     return {
       width,
       height,
@@ -11145,23 +11642,16 @@
     };
   }
 
-  // of the `<html>` and `<body>` rect bounds if horizontally scrollable
-
-  function getDocumentRect(element) {
-    var _element$ownerDocumen;
-
-    const html = getDocumentElement(element);
-    const scroll = getNodeScroll(element);
-    const body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body;
-    const width = max$1(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
-    const height = max$1(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
-    let x = -scroll.scrollLeft + getWindowScrollBarX(element);
-    const y = -scroll.scrollTop;
-
-    if (getComputedStyle$1(body || html).direction === 'rtl') {
-      x += max$1(html.clientWidth, body ? body.clientWidth : 0) - width;
-    }
-
+  // Returns the inner client rect, subtracting scrollbars if present.
+  function getInnerBoundingClientRect$1(element, strategy) {
+    const clientRect = getBoundingClientRect$1(element, true, strategy === 'fixed');
+    const top = clientRect.top + element.clientTop;
+    const left = clientRect.left + element.clientLeft;
+    const scale = isHTMLElement$1(element) ? getScale(element) : createCoords(1);
+    const width = element.clientWidth * scale.x;
+    const height = element.clientHeight * scale.y;
+    const x = left * scale.x;
+    const y = top * scale.y;
     return {
       width,
       height,
@@ -11169,125 +11659,86 @@
       y
     };
   }
-
-  function getNearestOverflowAncestor(node) {
-    const parentNode = getParentNode(node);
-
-    if (['html', 'body', '#document'].includes(getNodeName(parentNode))) {
-      // @ts-ignore assume body is always available
-      return node.ownerDocument.body;
-    }
-
-    if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
-      return parentNode;
-    }
-
-    return getNearestOverflowAncestor(parentNode);
-  }
-
-  function getOverflowAncestors(node, list) {
-    var _node$ownerDocument;
-
-    if (list === void 0) {
-      list = [];
+  function getClientRectFromClippingAncestor$1(element, clippingAncestor, strategy) {
+    let rect;
+    if (clippingAncestor === 'viewport') {
+      rect = getViewportRect$1(element, strategy);
+    } else if (clippingAncestor === 'document') {
+      rect = getDocumentRect$1(getDocumentElement$1(element));
+    } else if (isElement$1(clippingAncestor)) {
+      rect = getInnerBoundingClientRect$1(clippingAncestor, strategy);
+    } else {
+      const visualOffsets = getVisualOffsets(element);
+      rect = {
+        ...clippingAncestor,
+        x: clippingAncestor.x - visualOffsets.x,
+        y: clippingAncestor.y - visualOffsets.y
+      };
     }
-
-    const scrollableAncestor = getNearestOverflowAncestor(node);
-    const isBody = scrollableAncestor === ((_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.body);
-    const win = getWindow(scrollableAncestor);
-    const target = isBody ? [win].concat(win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : []) : scrollableAncestor;
-    const updatedList = list.concat(target);
-    return isBody ? updatedList : // @ts-ignore: isBody tells us target will be an HTMLElement here
-    updatedList.concat(getOverflowAncestors(target));
+    return rectToClientRect$1(rect);
   }
-
-  function contains(parent, child) {
-    const rootNode = child.getRootNode == null ? void 0 : child.getRootNode(); // First, attempt with faster native method
-
-    if (parent.contains(child)) {
-      return true;
-    } // then fallback to custom implementation with Shadow DOM support
-    else if (rootNode && isShadowRoot(rootNode)) {
-      let next = child;
-
-      do {
-        // use `===` replace node.isSameNode()
-        if (next && parent === next) {
-          return true;
-        } // @ts-ignore: need a better way to handle this...
-
-
-        next = next.parentNode || next.host;
-      } while (next);
+  function hasFixedPositionAncestor(element, stopNode) {
+    const parentNode = getParentNode$1(element);
+    if (parentNode === stopNode || !isElement$1(parentNode) || isLastTraversableNode(parentNode)) {
+      return false;
     }
-
-    return false;
-  }
-
-  function getInnerBoundingClientRect(element, strategy) {
-    const clientRect = getBoundingClientRect(element, false, strategy === 'fixed');
-    const top = clientRect.top + element.clientTop;
-    const left = clientRect.left + element.clientLeft;
-    return {
-      top,
-      left,
-      x: left,
-      y: top,
-      right: left + element.clientWidth,
-      bottom: top + element.clientHeight,
-      width: element.clientWidth,
-      height: element.clientHeight
-    };
+    return getComputedStyle$2(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);
   }
 
-  function getClientRectFromClippingAncestor(element, clippingParent, strategy) {
-    if (clippingParent === 'viewport') {
-      return rectToClientRect(getViewportRect(element, strategy));
+  // A "clipping ancestor" is an `overflow` element with the characteristic of
+  // clipping (or hiding) child elements. This returns all clipping ancestors
+  // of the given element up the tree.
+  function getClippingElementAncestors(element, cache) {
+    const cachedResult = cache.get(element);
+    if (cachedResult) {
+      return cachedResult;
     }
+    let result = getOverflowAncestors$1(element, [], false).filter(el => isElement$1(el) && getNodeName$1(el) !== 'body');
+    let currentContainingBlockComputedStyle = null;
+    const elementIsFixed = getComputedStyle$2(element).position === 'fixed';
+    let currentNode = elementIsFixed ? getParentNode$1(element) : element;
 
-    if (isElement(clippingParent)) {
-      return getInnerBoundingClientRect(clippingParent, strategy);
+    // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
+    while (isElement$1(currentNode) && !isLastTraversableNode(currentNode)) {
+      const computedStyle = getComputedStyle$2(currentNode);
+      const currentNodeIsContaining = isContainingBlock$1(currentNode);
+      if (!currentNodeIsContaining && computedStyle.position === 'fixed') {
+        currentContainingBlockComputedStyle = null;
+      }
+      const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && ['absolute', 'fixed'].includes(currentContainingBlockComputedStyle.position) || isOverflowElement$1(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
+      if (shouldDropCurrentNode) {
+        // Drop non-containing blocks.
+        result = result.filter(ancestor => ancestor !== currentNode);
+      } else {
+        // Record last containing block for next iteration.
+        currentContainingBlockComputedStyle = computedStyle;
+      }
+      currentNode = getParentNode$1(currentNode);
     }
+    cache.set(element, result);
+    return result;
+  }
 
-    return rectToClientRect(getDocumentRect(getDocumentElement(element)));
-  } // A "clipping ancestor" is an overflowable container with the characteristic of
-  // clipping (or hiding) overflowing elements with a position different from
-  // `initial`
-
-
-  function getClippingAncestors(element) {
-    const clippingAncestors = getOverflowAncestors(element);
-    const canEscapeClipping = ['absolute', 'fixed'].includes(getComputedStyle$1(element).position);
-    const clipperElement = canEscapeClipping && isHTMLElement(element) ? getOffsetParent(element) : element;
-
-    if (!isElement(clipperElement)) {
-      return [];
-    } // @ts-ignore isElement check ensures we return Array<Element>
-
-
-    return clippingAncestors.filter(clippingAncestors => isElement(clippingAncestors) && contains(clippingAncestors, clipperElement) && getNodeName(clippingAncestors) !== 'body');
-  } // Gets the maximum area that the element is visible in due to any number of
-  // clipping ancestors
-
-
-  function getClippingRect(_ref) {
+  // Gets the maximum area that the element is visible in due to any number of
+  // clipping ancestors.
+  function getClippingRect$1(_ref) {
     let {
       element,
       boundary,
       rootBoundary,
       strategy
     } = _ref;
-    const mainClippingAncestors = boundary === 'clippingAncestors' ? getClippingAncestors(element) : [].concat(boundary);
-    const clippingAncestors = [...mainClippingAncestors, rootBoundary];
+    const elementClippingAncestors = boundary === 'clippingAncestors' ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);
+    const clippingAncestors = [...elementClippingAncestors, rootBoundary];
     const firstClippingAncestor = clippingAncestors[0];
     const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
-      const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
-      accRect.top = max$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);
+      const rect = getClientRectFromClippingAncestor$1(element, clippingAncestor, strategy);
+      accRect.top = max$3(rect.top, accRect.top);
+      accRect.right = min$3(rect.right, accRect.right);
+      accRect.bottom = min$3(rect.bottom, accRect.bottom);
+      accRect.left = max$3(rect.left, accRect.left);
       return accRect;
-    }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
+    }, getClientRectFromClippingAncestor$1(element, firstClippingAncestor, strategy));
     return {
       width: clippingRect.right - clippingRect.left,
       height: clippingRect.bottom - clippingRect.top,
@@ -11296,115 +11747,210 @@
     };
   }
 
-  const platform = {
-    getClippingRect,
-    convertOffsetParentRelativeRectToViewportRelativeRect,
-    isElement,
-    getDimensions,
-    getOffsetParent,
-    getDocumentElement,
-    getElementRects: _ref => {
-      let {
-        reference,
-        floating,
-        strategy
-      } = _ref;
-      return {
-        reference: getRectRelativeToOffsetParent(reference, getOffsetParent(floating), strategy),
-        floating: { ...getDimensions(floating),
-          x: 0,
-          y: 0
-        }
-      };
-    },
-    getClientRects: element => Array.from(element.getClientRects()),
-    isRTL: element => getComputedStyle$1(element).direction === 'rtl'
-  };
+  function getDimensions$1(element) {
+    const {
+      width,
+      height
+    } = getCssDimensions(element);
+    return {
+      width,
+      height
+    };
+  }
 
-  /**
-   * Automatically updates the position of the floating element when necessary.
-   * @see https://floating-ui.com/docs/autoUpdate
-   */
-  function autoUpdate(reference, floating, update, options) {
-    if (options === void 0) {
-      options = {};
+  function getRectRelativeToOffsetParent$1(element, offsetParent, strategy) {
+    const isOffsetParentAnElement = isHTMLElement$1(offsetParent);
+    const documentElement = getDocumentElement$1(offsetParent);
+    const isFixed = strategy === 'fixed';
+    const rect = getBoundingClientRect$1(element, true, isFixed, offsetParent);
+    let scroll = {
+      scrollLeft: 0,
+      scrollTop: 0
+    };
+    const offsets = createCoords(0);
+    if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+      if (getNodeName$1(offsetParent) !== 'body' || isOverflowElement$1(documentElement)) {
+        scroll = getNodeScroll$1(offsetParent);
+      }
+      if (isOffsetParentAnElement) {
+        const offsetRect = getBoundingClientRect$1(offsetParent, true, isFixed, offsetParent);
+        offsets.x = offsetRect.x + offsetParent.clientLeft;
+        offsets.y = offsetRect.y + offsetParent.clientTop;
+      } else if (documentElement) {
+        offsets.x = getWindowScrollBarX$1(documentElement);
+      }
     }
+    const x = rect.left + scroll.scrollLeft - offsets.x;
+    const y = rect.top + scroll.scrollTop - offsets.y;
+    return {
+      x,
+      y,
+      width: rect.width,
+      height: rect.height
+    };
+  }
 
-    const {
-      ancestorScroll: _ancestorScroll = true,
-      ancestorResize: _ancestorResize = true,
-      elementResize = true,
-      animationFrame = false
-    } = options;
-    const ancestorScroll = _ancestorScroll && !animationFrame;
-    const ancestorResize = _ancestorResize && !animationFrame;
-    const ancestors = ancestorScroll || ancestorResize ? [...(isElement(reference) ? getOverflowAncestors(reference) : []), ...getOverflowAncestors(floating)] : [];
-    ancestors.forEach(ancestor => {
-      ancestorScroll && ancestor.addEventListener('scroll', update, {
-        passive: true
-      });
-      ancestorResize && ancestor.addEventListener('resize', update);
-    });
-    let observer = null;
+  function isStaticPositioned(element) {
+    return getComputedStyle$2(element).position === 'static';
+  }
 
-    if (elementResize) {
-      let initialUpdate = true;
-      observer = new ResizeObserver(() => {
-        if (!initialUpdate) {
-          update();
-        }
+  function getTrueOffsetParent$1(element, polyfill) {
+    if (!isHTMLElement$1(element) || getComputedStyle$2(element).position === 'fixed') {
+      return null;
+    }
+    if (polyfill) {
+      return polyfill(element);
+    }
+    return element.offsetParent;
+  }
 
-        initialUpdate = false;
-      });
-      isElement(reference) && !animationFrame && observer.observe(reference);
-      observer.observe(floating);
+  // Gets the closest ancestor positioned element. Handles some edge cases,
+  // such as table ancestors and cross browser bugs.
+  function getOffsetParent$1(element, polyfill) {
+    const win = getWindow$1(element);
+    if (isTopLayer(element)) {
+      return win;
     }
+    if (!isHTMLElement$1(element)) {
+      let svgOffsetParent = getParentNode$1(element);
+      while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {
+        if (isElement$1(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {
+          return svgOffsetParent;
+        }
+        svgOffsetParent = getParentNode$1(svgOffsetParent);
+      }
+      return win;
+    }
+    let offsetParent = getTrueOffsetParent$1(element, polyfill);
+    while (offsetParent && isTableElement$1(offsetParent) && isStaticPositioned(offsetParent)) {
+      offsetParent = getTrueOffsetParent$1(offsetParent, polyfill);
+    }
+    if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock$1(offsetParent)) {
+      return win;
+    }
+    return offsetParent || getContainingBlock$1(element) || win;
+  }
 
-    let frameId;
-    let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
+  const getElementRects = async function (data) {
+    const getOffsetParentFn = this.getOffsetParent || getOffsetParent$1;
+    const getDimensionsFn = this.getDimensions;
+    const floatingDimensions = await getDimensionsFn(data.floating);
+    return {
+      reference: getRectRelativeToOffsetParent$1(data.reference, await getOffsetParentFn(data.floating), data.strategy),
+      floating: {
+        x: 0,
+        y: 0,
+        width: floatingDimensions.width,
+        height: floatingDimensions.height
+      }
+    };
+  };
 
-    if (animationFrame) {
-      frameLoop();
-    }
+  function isRTL$1(element) {
+    return getComputedStyle$2(element).direction === 'rtl';
+  }
 
-    function frameLoop() {
-      const nextRefRect = getBoundingClientRect(reference);
+  const platform$1 = {
+    convertOffsetParentRelativeRectToViewportRelativeRect: convertOffsetParentRelativeRectToViewportRelativeRect$1,
+    getDocumentElement: getDocumentElement$1,
+    getClippingRect: getClippingRect$1,
+    getOffsetParent: getOffsetParent$1,
+    getElementRects,
+    getClientRects,
+    getDimensions: getDimensions$1,
+    getScale,
+    isElement: isElement$1,
+    isRTL: isRTL$1
+  };
 
-      if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) {
-        update();
-      }
+  /**
+   * Modifies the placement by translating the floating element along the
+   * specified axes.
+   * A number (shorthand for `mainAxis` or distance), or an axes configuration
+   * object may be passed.
+   * @see https://floating-ui.com/docs/offset
+   */
+  offset$1;
 
-      prevRefRect = nextRefRect;
-      frameId = requestAnimationFrame(frameLoop);
-    }
+  /**
+   * Optimizes the visibility of the floating element by choosing the placement
+   * that has the most space available automatically, without needing to specify a
+   * preferred placement. Alternative to `flip`.
+   * @see https://floating-ui.com/docs/autoPlacement
+   */
+  autoPlacement;
 
-    update();
-    return () => {
-      var _observer;
+  /**
+   * Optimizes the visibility of the floating element by shifting it in order to
+   * keep it in view when it will overflow the clipping boundary.
+   * @see https://floating-ui.com/docs/shift
+   */
+  shift$1;
 
-      ancestors.forEach(ancestor => {
-        ancestorScroll && ancestor.removeEventListener('scroll', update);
-        ancestorResize && ancestor.removeEventListener('resize', update);
-      });
-      (_observer = observer) == null ? void 0 : _observer.disconnect();
-      observer = null;
+  /**
+   * Optimizes the visibility of the floating element by flipping the `placement`
+   * in order to keep it in view when the preferred placement(s) will overflow the
+   * clipping boundary. Alternative to `autoPlacement`.
+   * @see https://floating-ui.com/docs/flip
+   */
+  flip$1;
 
-      if (animationFrame) {
-        cancelAnimationFrame(frameId);
-      }
-    };
-  }
+  /**
+   * Provides data that allows you to change the size of the floating element —
+   * for instance, prevent it from overflowing the clipping boundary or match the
+   * width of the reference element.
+   * @see https://floating-ui.com/docs/size
+   */
+  size;
 
   /**
-   * Computes the `x` and `y` coordinates that will place the floating element
-   * next to a reference element when it is given a certain CSS positioning
-   * strategy.
+   * Provides data to hide the floating element in applicable situations, such as
+   * when it is not in the same clipping context as the reference element.
+   * @see https://floating-ui.com/docs/hide
    */
+  hide;
 
-  const computePosition = (reference, floating, options) => computePosition$1(reference, floating, {
-    platform,
-    ...options
-  });
+  /**
+   * Provides data to position an inner element of the floating element so that it
+   * appears centered to the reference element.
+   * @see https://floating-ui.com/docs/arrow
+   */
+  const arrow$1 = arrow$2;
+
+  /**
+   * Provides improved positioning for inline reference elements that can span
+   * over multiple lines, such as hyperlinks or range selections.
+   * @see https://floating-ui.com/docs/inline
+   */
+  inline;
+
+  /**
+   * Built-in `limiter` that will stop `shift()` at a certain point.
+   */
+  limitShift;
+
+  /**
+   * Computes the `x` and `y` coordinates that will place the floating element
+   * next to a given reference element.
+   */
+  const computePosition$2 = (reference, floating, options) => {
+    // This caches the expensive `getClippingElementAncestors` function so that
+    // multiple lifecycle resets re-use the same result. It only lives for a
+    // single call. If other functions become expensive, we can add them as well.
+    const cache = new Map();
+    const mergedOptions = {
+      platform: platform$1,
+      ...options
+    };
+    const platformWithCache = {
+      ...mergedOptions.platform,
+      _c: cache
+    };
+    return computePosition$3(reference, floating, {
+      ...mergedOptions,
+      platform: platformWithCache
+    });
+  };
 
   const useFloatingProps = buildProps({});
   const unrefReference = (elRef) => {
@@ -11445,7 +11991,7 @@
       const contentEl = unrefElement(contentRef);
       if (!referenceEl || !contentEl)
         return;
-      const data = await computePosition(referenceEl, contentEl, {
+      const data = await computePosition$2(referenceEl, contentEl, {
         placement: vue.unref(placement),
         strategy: vue.unref(strategy),
         middleware: vue.unref(middleware)
@@ -11480,7 +12026,7 @@
         const arrowEl = vue.unref(arrowRef);
         if (!arrowEl)
           return {};
-        return arrow({
+        return arrow$1({
           element: arrowEl,
           padding
         }).fn(args);
@@ -11848,6 +12394,9 @@
     card: {
       type: definePropType(Object)
     },
+    dialog: {
+      type: definePropType(Object)
+    },
     link: {
       type: definePropType(Object)
     },
@@ -11885,7 +12434,7 @@
 
   const ElConfigProvider = withInstall(ConfigProvider);
 
-  const version$1 = "2.10.6";
+  const version$1 = "2.10.7";
 
   const makeInstaller = (components = []) => {
     const install = (app, options) => {
@@ -14101,10 +14650,10 @@
     return { contextStyle, paddingSize, borderSize, boxSizing };
   }
   function calcTextareaHeight(targetElement, minRows = 1, maxRows) {
-    var _a;
+    var _a, _b;
     if (!hiddenTextarea) {
       hiddenTextarea = document.createElement("textarea");
-      document.body.appendChild(hiddenTextarea);
+      ((_a = targetElement.parentNode) != null ? _a : document.body).appendChild(hiddenTextarea);
     }
     const { paddingSize, borderSize, boxSizing, contextStyle } = calculateNodeStyling(targetElement);
     contextStyle.forEach(([key, value]) => hiddenTextarea == null ? void 0 : hiddenTextarea.style.setProperty(key, value));
@@ -14135,7 +14684,7 @@
       height = Math.min(maxHeight, height);
     }
     result.height = `${height}px`;
-    (_a = hiddenTextarea.parentNode) == null ? void 0 : _a.removeChild(hiddenTextarea);
+    (_b = hiddenTextarea.parentNode) == null ? void 0 : _b.removeChild(hiddenTextarea);
     hiddenTextarea = void 0;
     return result;
   }
@@ -14977,6 +15526,7 @@
       const props = __props;
       const ns = useNamespace("scrollbar");
       let stopResizeObserver = void 0;
+      let stopWrapResizeObserver = void 0;
       let stopResizeListener = void 0;
       let wrapScrollTop = 0;
       let wrapScrollLeft = 0;
@@ -15093,9 +15643,11 @@
       vue.watch(() => props.noresize, (noresize) => {
         if (noresize) {
           stopResizeObserver == null ? void 0 : stopResizeObserver();
+          stopWrapResizeObserver == null ? void 0 : stopWrapResizeObserver();
           stopResizeListener == null ? void 0 : stopResizeListener();
         } else {
           ({ stop: stopResizeObserver } = useResizeObserver(resizeRef, update));
+          ({ stop: stopWrapResizeObserver } = useResizeObserver(wrapRef, update));
           stopResizeListener = useEventListener("resize", update);
         }
       }, { immediate: true });
@@ -15399,7 +15951,7 @@
         vue.watch(triggerRef, (el, prevEl) => {
           virtualTriggerAriaStopWatch == null ? void 0 : virtualTriggerAriaStopWatch();
           virtualTriggerAriaStopWatch = void 0;
-          if (isElement$1(el)) {
+          if (isElement$2(el)) {
             TRIGGER_ELE_EVENTS.forEach((eventName) => {
               var _a;
               const handler = props[eventName];
@@ -15421,7 +15973,7 @@
               }, { immediate: true });
             }
           }
-          if (isElement$1(prevEl) && isFocusable(prevEl)) {
+          if (isElement$2(prevEl) && isFocusable(prevEl)) {
             [
               "aria-controls",
               "aria-describedby",
@@ -15436,7 +15988,7 @@
       vue.onBeforeUnmount(() => {
         virtualTriggerAriaStopWatch == null ? void 0 : virtualTriggerAriaStopWatch();
         virtualTriggerAriaStopWatch = void 0;
-        if (triggerRef.value && isElement$1(triggerRef.value)) {
+        if (triggerRef.value && isElement$2(triggerRef.value)) {
           const el = triggerRef.value;
           TRIGGER_ELE_EVENTS.forEach((eventName) => {
             const handler = props[eventName];
@@ -15531,7 +16083,7 @@
     if (element && element.focus) {
       const prevFocusedElement = document.activeElement;
       let cleanup = false;
-      if (isElement$1(element) && !isFocusable(element) && !element.getAttribute("tabindex")) {
+      if (isElement$2(element) && !isFocusable(element) && !element.getAttribute("tabindex")) {
         element.setAttribute("tabindex", "-1");
         cleanup = true;
       }
@@ -15540,7 +16092,7 @@
       if (element !== prevFocusedElement && isSelectable(element) && shouldSelect) {
         element.select();
       }
-      if (isElement$1(element) && cleanup) {
+      if (isElement$2(element) && cleanup) {
         element.removeAttribute("tabindex");
       }
     }
@@ -16226,14 +16778,14 @@
           triggerTargetAriaStopWatch = void 0;
           const el = vue.unref(triggerTargetEl || contentRef.value);
           const prevEl = vue.unref(prevTriggerTargetEl || contentRef.value);
-          if (isElement$1(el)) {
+          if (isElement$2(el)) {
             triggerTargetAriaStopWatch = vue.watch([role, () => props.ariaLabel, ariaModal, () => props.id], (watches) => {
               ["role", "aria-label", "aria-modal", "id"].forEach((key, idx) => {
                 isNil(watches[idx]) ? el.removeAttribute(key) : el.setAttribute(key, watches[idx]);
               });
             }, { immediate: true });
           }
-          if (prevEl !== el && isElement$1(prevEl)) {
+          if (prevEl !== el && isElement$2(prevEl)) {
             ["role", "aria-label", "aria-modal", "id"].forEach((key) => {
               prevEl.removeAttribute(key);
             });
@@ -18338,6 +18890,10 @@
       this.roundA = Math.round(100 * this.a) / 100;
       return this;
     };
+    TinyColor2.prototype.isMonochrome = function() {
+      var s = this.toHsl().s;
+      return s === 0;
+    };
     TinyColor2.prototype.toHsv = function() {
       var hsv = rgbToHsv(this.r, this.g, this.b);
       return { h: hsv.h * 360, s: hsv.s, v: hsv.v, a: this.a };
@@ -18384,6 +18940,12 @@
       }
       return "#" + this.toHex8(allow4Char);
     };
+    TinyColor2.prototype.toHexShortString = function(allowShortChar) {
+      if (allowShortChar === void 0) {
+        allowShortChar = false;
+      }
+      return this.a === 1 ? this.toHexString(allowShortChar) : this.toHex8String(allowShortChar);
+    };
     TinyColor2.prototype.toRgb = function() {
       return {
         r: Math.round(this.r),
@@ -18609,10 +19171,12 @@
     TinyColor2.prototype.onBackground = function(background) {
       var fg = this.toRgb();
       var bg = new TinyColor2(background).toRgb();
+      var alpha = fg.a + bg.a * (1 - fg.a);
       return new TinyColor2({
-        r: bg.r + (fg.r - bg.r) * fg.a,
-        g: bg.g + (fg.g - bg.g) * fg.a,
-        b: bg.b + (fg.b - bg.b) * fg.a
+        r: (fg.r * fg.a + bg.r * bg.a * (1 - fg.a)) / alpha,
+        g: (fg.g * fg.a + bg.g * bg.a * (1 - fg.a)) / alpha,
+        b: (fg.b * fg.a + bg.b * bg.a * (1 - fg.a)) / alpha,
+        a: alpha
       });
     };
     TinyColor2.prototype.triad = function() {
@@ -20313,7 +20877,7 @@
     let excludes = [];
     if (isArray$1(binding.arg)) {
       excludes = binding.arg;
-    } else if (isElement$1(binding.arg)) {
+    } else if (isElement$2(binding.arg)) {
       excludes.push(binding.arg);
     }
     return function(mouseup, mousedown) {
@@ -23871,7 +24435,7 @@
     }
     return nodes;
   };
-  class Node$2 {
+  class Node$3 {
     constructor(data, config, parent, root = false) {
       this.data = data;
       this.config = config;
@@ -23891,7 +24455,7 @@
       this.pathValues = pathNodes.map((node) => node.value);
       this.pathLabels = pathNodes.map((node) => node.label);
       this.childrenData = childrenData;
-      this.children = (childrenData || []).map((child) => new Node$2(child, config, this));
+      this.children = (childrenData || []).map((child) => new Node$3(child, config, this));
       this.loaded = !config.lazy || this.isLeaf || !isEmpty(childrenData);
       this.text = "";
     }
@@ -23912,7 +24476,7 @@
     }
     appendChild(childData) {
       const { childrenData, children } = this;
-      const node = new Node$2(childData, this.config, this);
+      const node = new Node$3(childData, this.config, this);
       if (isArray$1(childrenData)) {
         childrenData.push(childData);
       } else {
@@ -23976,7 +24540,7 @@
       }
     }
   }
-  var Node$3 = Node$2;
+  var Node$4 = Node$3;
 
   const flatNodes = (nodes, leafOnly) => {
     return nodes.reduce((res, node) => {
@@ -23992,7 +24556,7 @@
   class Store {
     constructor(data, config) {
       this.config = config;
-      const nodes = (data || []).map((nodeData) => new Node$3(nodeData, this.config));
+      const nodes = (data || []).map((nodeData) => new Node$4(nodeData, this.config));
       this.nodes = nodes;
       this.allNodes = flatNodes(nodes, false);
       this.leafNodes = flatNodes(nodes, true);
@@ -24004,7 +24568,7 @@
       return leafOnly ? this.leafNodes : this.allNodes;
     }
     appendNode(nodeData, parentNode) {
-      const node = parentNode ? parentNode.appendChild(nodeData) : new Node$3(nodeData, this.config);
+      const node = parentNode ? parentNode.appendChild(nodeData) : new Node$4(nodeData, this.config);
       if (!parentNode)
         this.nodes.push(node);
       this.appendAllNodesAndLeafNodes(node);
@@ -24166,7 +24730,7 @@
       };
       const lazyLoad = (node, cb) => {
         const cfg = config.value;
-        node = node || new Node$3({}, cfg, void 0, true);
+        node = node || new Node$4({}, cfg, void 0, true);
         node.loading = true;
         const resolve = (dataList) => {
           const _node = node;
@@ -29415,6 +29979,7 @@
       vue.watch([maxDate, minDate], ([max, min]) => {
         if (max && min) {
           handleRangeConfirm(shouldBeVisible);
+          shouldBeVisible = true;
         }
       });
       const minTimePickerVisible = vue.ref(false);
@@ -31152,12 +31717,21 @@
 
   const dialogContentProps = buildProps({
     center: Boolean,
-    alignCenter: Boolean,
+    alignCenter: {
+      type: Boolean,
+      default: void 0
+    },
     closeIcon: {
       type: iconPropType
     },
-    draggable: Boolean,
-    overflow: Boolean,
+    draggable: {
+      type: Boolean,
+      default: void 0
+    },
+    overflow: {
+      type: Boolean,
+      default: void 0
+    },
     fullscreen: Boolean,
     headerClass: String,
     bodyClass: String,
@@ -31193,13 +31767,13 @@
       const dialogKls = vue.computed(() => [
         ns.b(),
         ns.is("fullscreen", props.fullscreen),
-        ns.is("draggable", props.draggable),
-        ns.is("align-center", props.alignCenter),
+        ns.is("draggable", !!props.draggable),
+        ns.is("align-center", !!props.alignCenter),
         { [ns.m("center")]: props.center }
       ]);
       const composedDialogRef = composeRefs(focusTrapRef, dialogRef);
-      const draggable = vue.computed(() => props.draggable);
-      const overflow = vue.computed(() => props.overflow);
+      const draggable = vue.computed(() => !!props.draggable);
+      const overflow = vue.computed(() => !!props.overflow);
       const { resetPosition, updatePosition } = useDraggable(dialogRef, headerRef, draggable, overflow);
       expose({
         resetPosition,
@@ -31316,7 +31890,7 @@
     },
     transition: {
       type: definePropType([String, Object]),
-      default: DEFAULT_DIALOG_TRANSITION
+      default: void 0
     }
   });
   const dialogEmits = {
@@ -31328,6 +31902,7 @@
     openAutoFocus: () => true,
     closeAutoFocus: () => true
   };
+  const dialogContextKey = Symbol("dialogContextKey");
 
   const useDialog = (props, targetRef) => {
     var _a;
@@ -31343,7 +31918,15 @@
     const zIndex = vue.ref((_a = props.zIndex) != null ? _a : nextZIndex());
     let openTimer = void 0;
     let closeTimer = void 0;
-    const namespace = useGlobalConfig("namespace", defaultNamespace);
+    const config = useGlobalConfig();
+    const namespace = vue.computed(() => {
+      var _a2, _b;
+      return (_b = (_a2 = config.value) == null ? void 0 : _a2.namespace) != null ? _b : defaultNamespace;
+    });
+    const globalConfig = vue.computed(() => {
+      var _a2;
+      return (_a2 = config.value) == null ? void 0 : _a2.dialog;
+    });
     const style = vue.computed(() => {
       const style2 = {};
       const varPrefix = `--${namespace.value}-dialog`;
@@ -31357,21 +31940,35 @@
       }
       return style2;
     });
+    const _draggable = vue.computed(() => {
+      var _a2, _b, _c;
+      return ((_c = (_b = props.draggable) != null ? _b : (_a2 = globalConfig.value) == null ? void 0 : _a2.draggable) != null ? _c : false) && !props.fullscreen;
+    });
+    const _alignCenter = vue.computed(() => {
+      var _a2, _b, _c;
+      return (_c = (_b = props.alignCenter) != null ? _b : (_a2 = globalConfig.value) == null ? void 0 : _a2.alignCenter) != null ? _c : false;
+    });
+    const _overflow = vue.computed(() => {
+      var _a2, _b, _c;
+      return (_c = (_b = props.overflow) != null ? _b : (_a2 = globalConfig.value) == null ? void 0 : _a2.overflow) != null ? _c : false;
+    });
     const overlayDialogStyle = vue.computed(() => {
-      if (props.alignCenter) {
+      if (_alignCenter.value) {
         return { display: "flex" };
       }
       return {};
     });
     const transitionConfig = vue.computed(() => {
+      var _a2, _b, _c;
+      const transition = (_c = (_b = props.transition) != null ? _b : (_a2 = globalConfig.value) == null ? void 0 : _a2.transition) != null ? _c : DEFAULT_DIALOG_TRANSITION;
       const baseConfig = {
-        name: props.transition,
+        name: transition,
         onAfterEnter: afterEnter,
         onBeforeLeave: beforeLeave,
         onAfterLeave: afterLeave
       };
-      if (isObject$1(props.transition)) {
-        const config = { ...props.transition };
+      if (isObject$1(transition)) {
+        const config2 = { ...transition };
         const _mergeHook = (userHook, defaultHook) => {
           return (el) => {
             if (isArray$1(userHook)) {
@@ -31385,13 +31982,13 @@
             defaultHook();
           };
         };
-        config.onAfterEnter = _mergeHook(config.onAfterEnter, afterEnter);
-        config.onBeforeLeave = _mergeHook(config.onBeforeLeave, beforeLeave);
-        config.onAfterLeave = _mergeHook(config.onAfterLeave, afterLeave);
-        if (!config.name) {
-          config.name = DEFAULT_DIALOG_TRANSITION;
+        config2.onAfterEnter = _mergeHook(config2.onAfterEnter, afterEnter);
+        config2.onBeforeLeave = _mergeHook(config2.onBeforeLeave, beforeLeave);
+        config2.onAfterLeave = _mergeHook(config2.onAfterLeave, afterLeave);
+        if (!config2.name) {
+          config2.name = DEFAULT_DIALOG_TRANSITION;
         }
-        return config;
+        return config2;
       }
       return baseConfig;
     });
@@ -31534,7 +32131,10 @@
       rendered,
       visible,
       zIndex,
-      transitionConfig
+      transitionConfig,
+      _draggable,
+      _alignCenter,
+      _overflow
     };
   };
 
@@ -31569,6 +32169,9 @@
         rendered,
         transitionConfig,
         zIndex,
+        _draggable,
+        _alignCenter,
+        _overflow,
         handleClose,
         onModalClick,
         onOpenAutoFocus,
@@ -31585,7 +32188,6 @@
         style
       });
       const overlayEvent = useSameTarget(onModalClick);
-      const draggable = vue.computed(() => props.draggable && !props.fullscreen);
       const penetrable = vue.computed(() => props.modalPenetrable && !props.modal && !props.fullscreen);
       const resetPosition = () => {
         var _a;
@@ -31646,10 +32248,10 @@
                               ref: dialogContentRef
                             }, _ctx.$attrs, {
                               center: _ctx.center,
-                              "align-center": _ctx.alignCenter,
+                              "align-center": vue.unref(_alignCenter),
                               "close-icon": _ctx.closeIcon,
-                              draggable: vue.unref(draggable),
-                              overflow: _ctx.overflow,
+                              draggable: vue.unref(_draggable),
+                              overflow: vue.unref(_overflow),
                               fullscreen: _ctx.fullscreen,
                               "header-class": _ctx.headerClass,
                               "body-class": _ctx.bodyClass,
@@ -33811,7 +34413,7 @@
           return;
         await vue.nextTick();
         const { scrollContainer } = props;
-        if (isElement$1(scrollContainer)) {
+        if (isElement$2(scrollContainer)) {
           _scrollContainer.value = scrollContainer;
         } else if (isString$1(scrollContainer) && scrollContainer !== "") {
           _scrollContainer.value = (_a = document.querySelector(scrollContainer)) != null ? _a : void 0;
@@ -36907,7 +37509,7 @@
     const handleClickOutside = (event) => {
       expanded.value = false;
       if (isFocused.value) {
-        const _event = new FocusEvent("focus", event);
+        const _event = new FocusEvent("blur", event);
         vue.nextTick(() => handleBlur(_event));
       }
     };
@@ -38543,11 +39145,15 @@
     ...__default__$M,
     props: popconfirmProps,
     emits: popconfirmEmits,
-    setup(__props, { emit }) {
+    setup(__props, { expose, emit }) {
       const props = __props;
       const { t } = useLocale();
       const ns = useNamespace("popconfirm");
       const tooltipRef = vue.ref();
+      const popperRef = vue.computed(() => {
+        var _a;
+        return (_a = vue.unref(tooltipRef)) == null ? void 0 : _a.popperRef;
+      });
       const hidePopper = () => {
         var _a, _b;
         (_b = (_a = tooltipRef.value) == null ? void 0 : _a.onClose) == null ? void 0 : _b.call(_a);
@@ -38567,6 +39173,10 @@
       };
       const finalConfirmButtonText = vue.computed(() => props.confirmButtonText || t("el.popconfirm.confirmButtonText"));
       const finalCancelButtonText = vue.computed(() => props.cancelButtonText || t("el.popconfirm.cancelButtonText"));
+      expose({
+        popperRef,
+        hide: hidePopper
+      });
       return (_ctx, _cache) => {
         return vue.openBlock(), vue.createBlock(vue.unref(ElTooltip), vue.mergeProps({
           ref_key: "tooltipRef",
@@ -41085,7 +41695,7 @@
   });
   var FixedSizeGrid$1 = FixedSizeGrid;
 
-  const { max, min, floor } = Math;
+  const { max: max$2, min: min$2, floor } = Math;
   const ACCESS_SIZER_KEY_MAP = {
     column: "columnWidth",
     row: "rowHeight"
@@ -41130,7 +41740,7 @@
         high = mid - 1;
       }
     }
-    return max(0, low - 1);
+    return max$2(0, low - 1);
   };
   const es = (props, gridCache, idx, offset, type) => {
     const total = type === "column" ? props.totalColumn : props.totalRow;
@@ -41139,7 +41749,7 @@
       idx += exponent;
       exponent *= 2;
     }
-    return bs(props, gridCache, floor(idx / 2), min(idx, total - 1), offset, type);
+    return bs(props, gridCache, floor(idx / 2), min$2(idx, total - 1), offset, type);
   };
   const findItem = (props, gridCache, offset, type) => {
     const [cache, lastVisitedIndex] = [
@@ -41150,7 +41760,7 @@
     if (lastVisitedItemOffset >= offset) {
       return bs(props, gridCache, 0, lastVisitedIndex, offset, type);
     }
-    return es(props, gridCache, max(0, lastVisitedIndex), offset, type);
+    return es(props, gridCache, max$2(0, lastVisitedIndex), offset, type);
   };
   const getEstimatedTotalHeight = ({ totalRow }, { estimatedRowHeight, lastVisitedRowIndex, row }) => {
     let sizeOfVisitedRows = 0;
@@ -41189,8 +41799,8 @@
     ];
     const item = getItemFromCache(props, index, cache, type);
     const estimatedSize = estimatedSizeAssociates(props, cache);
-    const maxOffset = max(0, min(estimatedSize - size, item.offset));
-    const minOffset = max(0, item.offset - size + scrollBarWidth + item.size);
+    const maxOffset = max$2(0, min$2(estimatedSize - size, item.offset));
+    const minOffset = max$2(0, item.offset - size + scrollBarWidth + item.size);
     if (alignment === SMART_ALIGNMENT) {
       if (scrollOffset >= minOffset - size && scrollOffset <= maxOffset + size) {
         alignment = AUTO_ALIGNMENT;
@@ -42411,7 +43021,7 @@
     const handleClickOutside = (event) => {
       expanded.value = false;
       if (isFocused.value) {
-        const _event = new FocusEvent("focus", event);
+        const _event = new FocusEvent("blur", event);
         handleBlur(_event);
       }
     };
@@ -47142,7 +47752,7 @@
       if (column.children && column.children.length > 0)
         return;
       const el = event.target;
-      if (!isElement$1(el)) {
+      if (!isElement$2(el)) {
         return;
       }
       const target = el == null ? void 0 : el.closest("th");
@@ -53267,6 +53877,1297 @@
   });
   var TooltipV2Arrow = /* @__PURE__ */ _export_sfc(_sfc_main$w, [["__file", "arrow.vue"]]);
 
+  function getSide(placement) {
+    return placement.split('-')[0];
+  }
+
+  function getAlignment(placement) {
+    return placement.split('-')[1];
+  }
+
+  function getMainAxisFromPlacement(placement) {
+    return ['top', 'bottom'].includes(getSide(placement)) ? 'x' : 'y';
+  }
+
+  function getLengthFromAxis(axis) {
+    return axis === 'y' ? 'height' : 'width';
+  }
+
+  function computeCoordsFromPlacement(_ref, placement, rtl) {
+    let {
+      reference,
+      floating
+    } = _ref;
+    const commonX = reference.x + reference.width / 2 - floating.width / 2;
+    const commonY = reference.y + reference.height / 2 - floating.height / 2;
+    const mainAxis = getMainAxisFromPlacement(placement);
+    const length = getLengthFromAxis(mainAxis);
+    const commonAlign = reference[length] / 2 - floating[length] / 2;
+    const side = getSide(placement);
+    const isVertical = mainAxis === 'x';
+    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[mainAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
+        break;
+
+      case 'end':
+        coords[mainAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
+        break;
+    }
+
+    return coords;
+  }
+
+  /**
+   * Computes the `x` and `y` coordinates that will place the floating element
+   * next to a reference element when it is given a certain positioning strategy.
+   *
+   * This export does not have any `platform` interface logic. You will need to
+   * write one for the platform you are using Floating UI with.
+   */
+
+  const computePosition$1 = async (reference, floating, config) => {
+    const {
+      placement = 'bottom',
+      strategy = 'absolute',
+      middleware = [],
+      platform
+    } = config;
+    const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));
+
+    let rects = await platform.getElementRects({
+      reference,
+      floating,
+      strategy
+    });
+    let {
+      x,
+      y
+    } = computeCoordsFromPlacement(rects, placement, rtl);
+    let statefulPlacement = placement;
+    let middlewareData = {};
+    let resetCount = 0;
+
+    for (let i = 0; i < middleware.length; i++) {
+      const {
+        name,
+        fn
+      } = middleware[i];
+      const {
+        x: nextX,
+        y: nextY,
+        data,
+        reset
+      } = await fn({
+        x,
+        y,
+        initialPlacement: placement,
+        placement: statefulPlacement,
+        strategy,
+        middlewareData,
+        rects,
+        platform,
+        elements: {
+          reference,
+          floating
+        }
+      });
+      x = nextX != null ? nextX : x;
+      y = nextY != null ? nextY : y;
+      middlewareData = { ...middlewareData,
+        [name]: { ...middlewareData[name],
+          ...data
+        }
+      };
+
+      if (reset && resetCount <= 50) {
+        resetCount++;
+
+        if (typeof reset === 'object') {
+          if (reset.placement) {
+            statefulPlacement = reset.placement;
+          }
+
+          if (reset.rects) {
+            rects = reset.rects === true ? await platform.getElementRects({
+              reference,
+              floating,
+              strategy
+            }) : reset.rects;
+          }
+
+          ({
+            x,
+            y
+          } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
+        }
+
+        i = -1;
+        continue;
+      }
+    }
+
+    return {
+      x,
+      y,
+      placement: statefulPlacement,
+      strategy,
+      middlewareData
+    };
+  };
+
+  function expandPaddingObject(padding) {
+    return {
+      top: 0,
+      right: 0,
+      bottom: 0,
+      left: 0,
+      ...padding
+    };
+  }
+
+  function getSideObjectFromPadding(padding) {
+    return typeof padding !== 'number' ? expandPaddingObject(padding) : {
+      top: padding,
+      right: padding,
+      bottom: padding,
+      left: padding
+    };
+  }
+
+  function rectToClientRect(rect) {
+    return { ...rect,
+      top: rect.y,
+      left: rect.x,
+      right: rect.x + rect.width,
+      bottom: rect.y + rect.height
+    };
+  }
+
+  /**
+   * Resolves with an object of overflow side offsets that determine how much the
+   * element is overflowing a given clipping boundary.
+   * - positive = overflowing the boundary by that number of pixels
+   * - negative = how many pixels left before it will overflow
+   * - 0 = lies flush with the boundary
+   * @see https://floating-ui.com/docs/detectOverflow
+   */
+  async function detectOverflow(middlewareArguments, options) {
+    var _await$platform$isEle;
+
+    if (options === void 0) {
+      options = {};
+    }
+
+    const {
+      x,
+      y,
+      platform,
+      rects,
+      elements,
+      strategy
+    } = middlewareArguments;
+    const {
+      boundary = 'clippingAncestors',
+      rootBoundary = 'viewport',
+      elementContext = 'floating',
+      altBoundary = false,
+      padding = 0
+    } = options;
+    const paddingObject = getSideObjectFromPadding(padding);
+    const altContext = elementContext === 'floating' ? 'reference' : 'floating';
+    const element = elements[altBoundary ? altContext : elementContext];
+    const clippingClientRect = rectToClientRect(await platform.getClippingRect({
+      element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || (await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating))),
+      boundary,
+      rootBoundary,
+      strategy
+    }));
+    const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
+      rect: elementContext === 'floating' ? { ...rects.floating,
+        x,
+        y
+      } : rects.reference,
+      offsetParent: await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating)),
+      strategy
+    }) : rects[elementContext]);
+    return {
+      top: clippingClientRect.top - elementClientRect.top + paddingObject.top,
+      bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom,
+      left: clippingClientRect.left - elementClientRect.left + paddingObject.left,
+      right: elementClientRect.right - clippingClientRect.right + paddingObject.right
+    };
+  }
+
+  const min$1 = Math.min;
+  const max$1 = Math.max;
+
+  function within(min$1$1, value, max$1$1) {
+    return max$1(min$1$1, min$1(value, max$1$1));
+  }
+
+  /**
+   * Positions an inner element of the floating element such that it is centered
+   * to the reference element.
+   * @see https://floating-ui.com/docs/arrow
+   */
+  const arrow = options => ({
+    name: 'arrow',
+    options,
+
+    async fn(middlewareArguments) {
+      // Since `element` is required, we don't Partial<> the type
+      const {
+        element,
+        padding = 0
+      } = options != null ? options : {};
+      const {
+        x,
+        y,
+        placement,
+        rects,
+        platform
+      } = middlewareArguments;
+
+      if (element == null) {
+
+        return {};
+      }
+
+      const paddingObject = getSideObjectFromPadding(padding);
+      const coords = {
+        x,
+        y
+      };
+      const axis = getMainAxisFromPlacement(placement);
+      const alignment = getAlignment(placement);
+      const length = getLengthFromAxis(axis);
+      const arrowDimensions = await platform.getDimensions(element);
+      const minProp = axis === 'y' ? 'top' : 'left';
+      const maxProp = axis === 'y' ? 'bottom' : 'right';
+      const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
+      const startDiff = coords[axis] - rects.reference[axis];
+      const arrowOffsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(element));
+      let clientSize = arrowOffsetParent ? axis === 'y' ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;
+
+      if (clientSize === 0) {
+        clientSize = rects.floating[length];
+      }
+
+      const centerToReference = endDiff / 2 - startDiff / 2; // Make sure the arrow doesn't overflow the floating element if the center
+      // point is outside the floating element's bounds
+
+      const min = paddingObject[minProp];
+      const max = clientSize - arrowDimensions[length] - paddingObject[maxProp];
+      const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
+      const offset = within(min, center, max); // Make sure that arrow points at the reference
+
+      const alignmentPadding = alignment === 'start' ? paddingObject[minProp] : paddingObject[maxProp];
+      const shouldAddOffset = alignmentPadding > 0 && center !== offset && rects.reference[length] <= rects.floating[length];
+      const alignmentOffset = shouldAddOffset ? center < min ? min - center : max - center : 0;
+      return {
+        [axis]: coords[axis] - alignmentOffset,
+        data: {
+          [axis]: offset,
+          centerOffset: center - offset
+        }
+      };
+    }
+
+  });
+
+  const hash$1 = {
+    left: 'right',
+    right: 'left',
+    bottom: 'top',
+    top: 'bottom'
+  };
+  function getOppositePlacement(placement) {
+    return placement.replace(/left|right|bottom|top/g, matched => hash$1[matched]);
+  }
+
+  function getAlignmentSides(placement, rects, rtl) {
+    if (rtl === void 0) {
+      rtl = false;
+    }
+
+    const alignment = getAlignment(placement);
+    const mainAxis = getMainAxisFromPlacement(placement);
+    const length = getLengthFromAxis(mainAxis);
+    let mainAlignmentSide = mainAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';
+
+    if (rects.reference[length] > rects.floating[length]) {
+      mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
+    }
+
+    return {
+      main: mainAlignmentSide,
+      cross: getOppositePlacement(mainAlignmentSide)
+    };
+  }
+
+  const hash = {
+    start: 'end',
+    end: 'start'
+  };
+  function getOppositeAlignmentPlacement(placement) {
+    return placement.replace(/start|end/g, matched => hash[matched]);
+  }
+
+  function getExpandedPlacements(placement) {
+    const oppositePlacement = getOppositePlacement(placement);
+    return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
+  }
+
+  /**
+   * Changes the placement of the floating element to one that will fit if the
+   * initially specified `placement` does not.
+   * @see https://floating-ui.com/docs/flip
+   */
+  const flip = function (options) {
+    if (options === void 0) {
+      options = {};
+    }
+
+    return {
+      name: 'flip',
+      options,
+
+      async fn(middlewareArguments) {
+        var _middlewareData$flip;
+
+        const {
+          placement,
+          middlewareData,
+          rects,
+          initialPlacement,
+          platform,
+          elements
+        } = middlewareArguments;
+        const {
+          mainAxis: checkMainAxis = true,
+          crossAxis: checkCrossAxis = true,
+          fallbackPlacements: specifiedFallbackPlacements,
+          fallbackStrategy = 'bestFit',
+          flipAlignment = true,
+          ...detectOverflowOptions
+        } = options;
+        const side = getSide(placement);
+        const isBasePlacement = side === initialPlacement;
+        const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
+        const placements = [initialPlacement, ...fallbackPlacements];
+        const overflow = await detectOverflow(middlewareArguments, detectOverflowOptions);
+        const overflows = [];
+        let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
+
+        if (checkMainAxis) {
+          overflows.push(overflow[side]);
+        }
+
+        if (checkCrossAxis) {
+          const {
+            main,
+            cross
+          } = getAlignmentSides(placement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)));
+          overflows.push(overflow[main], overflow[cross]);
+        }
+
+        overflowsData = [...overflowsData, {
+          placement,
+          overflows
+        }]; // One or more sides is overflowing
+
+        if (!overflows.every(side => side <= 0)) {
+          var _middlewareData$flip$, _middlewareData$flip2;
+
+          const nextIndex = ((_middlewareData$flip$ = (_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) != null ? _middlewareData$flip$ : 0) + 1;
+          const nextPlacement = placements[nextIndex];
+
+          if (nextPlacement) {
+            // Try next placement and re-run the lifecycle
+            return {
+              data: {
+                index: nextIndex,
+                overflows: overflowsData
+              },
+              reset: {
+                placement: nextPlacement
+              }
+            };
+          }
+
+          let resetPlacement = 'bottom';
+
+          switch (fallbackStrategy) {
+            case 'bestFit':
+              {
+                var _overflowsData$map$so;
+
+                const placement = (_overflowsData$map$so = overflowsData.map(d => [d, d.overflows.filter(overflow => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$map$so[0].placement;
+
+                if (placement) {
+                  resetPlacement = placement;
+                }
+
+                break;
+              }
+
+            case 'initialPlacement':
+              resetPlacement = initialPlacement;
+              break;
+          }
+
+          if (placement !== resetPlacement) {
+            return {
+              reset: {
+                placement: resetPlacement
+              }
+            };
+          }
+        }
+
+        return {};
+      }
+
+    };
+  };
+
+  async function convertValueToCoords(middlewareArguments, value) {
+    const {
+      placement,
+      platform,
+      elements
+    } = middlewareArguments;
+    const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
+    const side = getSide(placement);
+    const alignment = getAlignment(placement);
+    const isVertical = getMainAxisFromPlacement(placement) === 'x';
+    const mainAxisMulti = ['left', 'top'].includes(side) ? -1 : 1;
+    const crossAxisMulti = rtl && isVertical ? -1 : 1;
+    const rawValue = typeof value === 'function' ? value(middlewareArguments) : value; // eslint-disable-next-line prefer-const
+
+    let {
+      mainAxis,
+      crossAxis,
+      alignmentAxis
+    } = typeof rawValue === 'number' ? {
+      mainAxis: rawValue,
+      crossAxis: 0,
+      alignmentAxis: null
+    } : {
+      mainAxis: 0,
+      crossAxis: 0,
+      alignmentAxis: null,
+      ...rawValue
+    };
+
+    if (alignment && typeof alignmentAxis === 'number') {
+      crossAxis = alignment === 'end' ? alignmentAxis * -1 : alignmentAxis;
+    }
+
+    return isVertical ? {
+      x: crossAxis * crossAxisMulti,
+      y: mainAxis * mainAxisMulti
+    } : {
+      x: mainAxis * mainAxisMulti,
+      y: crossAxis * crossAxisMulti
+    };
+  }
+  /**
+   * Displaces the floating element from its reference element.
+   * @see https://floating-ui.com/docs/offset
+   */
+
+  const offset = function (value) {
+    if (value === void 0) {
+      value = 0;
+    }
+
+    return {
+      name: 'offset',
+      options: value,
+
+      async fn(middlewareArguments) {
+        const {
+          x,
+          y
+        } = middlewareArguments;
+        const diffCoords = await convertValueToCoords(middlewareArguments, value);
+        return {
+          x: x + diffCoords.x,
+          y: y + diffCoords.y,
+          data: diffCoords
+        };
+      }
+
+    };
+  };
+
+  function getCrossAxis(axis) {
+    return axis === 'x' ? 'y' : 'x';
+  }
+
+  /**
+   * Shifts the floating element in order to keep it in view when it will overflow
+   * a clipping boundary.
+   * @see https://floating-ui.com/docs/shift
+   */
+  const shift = function (options) {
+    if (options === void 0) {
+      options = {};
+    }
+
+    return {
+      name: 'shift',
+      options,
+
+      async fn(middlewareArguments) {
+        const {
+          x,
+          y,
+          placement
+        } = middlewareArguments;
+        const {
+          mainAxis: checkMainAxis = true,
+          crossAxis: checkCrossAxis = false,
+          limiter = {
+            fn: _ref => {
+              let {
+                x,
+                y
+              } = _ref;
+              return {
+                x,
+                y
+              };
+            }
+          },
+          ...detectOverflowOptions
+        } = options;
+        const coords = {
+          x,
+          y
+        };
+        const overflow = await detectOverflow(middlewareArguments, detectOverflowOptions);
+        const mainAxis = getMainAxisFromPlacement(getSide(placement));
+        const crossAxis = getCrossAxis(mainAxis);
+        let mainAxisCoord = coords[mainAxis];
+        let crossAxisCoord = coords[crossAxis];
+
+        if (checkMainAxis) {
+          const minSide = mainAxis === 'y' ? 'top' : 'left';
+          const maxSide = mainAxis === 'y' ? 'bottom' : 'right';
+          const min = mainAxisCoord + overflow[minSide];
+          const max = mainAxisCoord - overflow[maxSide];
+          mainAxisCoord = within(min, mainAxisCoord, max);
+        }
+
+        if (checkCrossAxis) {
+          const minSide = crossAxis === 'y' ? 'top' : 'left';
+          const maxSide = crossAxis === 'y' ? 'bottom' : 'right';
+          const min = crossAxisCoord + overflow[minSide];
+          const max = crossAxisCoord - overflow[maxSide];
+          crossAxisCoord = within(min, crossAxisCoord, max);
+        }
+
+        const limitedCoords = limiter.fn({ ...middlewareArguments,
+          [mainAxis]: mainAxisCoord,
+          [crossAxis]: crossAxisCoord
+        });
+        return { ...limitedCoords,
+          data: {
+            x: limitedCoords.x - x,
+            y: limitedCoords.y - y
+          }
+        };
+      }
+
+    };
+  };
+
+  function isWindow(value) {
+    return value && value.document && value.location && value.alert && value.setInterval;
+  }
+  function getWindow(node) {
+    if (node == null) {
+      return window;
+    }
+
+    if (!isWindow(node)) {
+      const ownerDocument = node.ownerDocument;
+      return ownerDocument ? ownerDocument.defaultView || window : window;
+    }
+
+    return node;
+  }
+
+  function getComputedStyle$1(element) {
+    return getWindow(element).getComputedStyle(element);
+  }
+
+  function getNodeName(node) {
+    return isWindow(node) ? '' : node ? (node.nodeName || '').toLowerCase() : '';
+  }
+
+  function getUAString() {
+    const uaData = navigator.userAgentData;
+
+    if (uaData != null && uaData.brands) {
+      return uaData.brands.map(item => item.brand + "/" + item.version).join(' ');
+    }
+
+    return navigator.userAgent;
+  }
+
+  function isHTMLElement(value) {
+    return value instanceof getWindow(value).HTMLElement;
+  }
+  function isElement(value) {
+    return value instanceof getWindow(value).Element;
+  }
+  function isNode(value) {
+    return value instanceof getWindow(value).Node;
+  }
+  function isShadowRoot(node) {
+    // Browsers without `ShadowRoot` support
+    if (typeof ShadowRoot === 'undefined') {
+      return false;
+    }
+
+    const OwnElement = getWindow(node).ShadowRoot;
+    return node instanceof OwnElement || node instanceof ShadowRoot;
+  }
+  function isOverflowElement(element) {
+    // Firefox wants us to check `-x` and `-y` variations as well
+    const {
+      overflow,
+      overflowX,
+      overflowY
+    } = getComputedStyle$1(element);
+    return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
+  }
+  function isTableElement(element) {
+    return ['table', 'td', 'th'].includes(getNodeName(element));
+  }
+  function isContainingBlock(element) {
+    // TODO: Try and use feature detection here instead
+    const isFirefox = /firefox/i.test(getUAString());
+    const css = getComputedStyle$1(element); // This is non-exhaustive but covers the most common CSS properties that
+    // create a containing block.
+    // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
+
+    return css.transform !== 'none' || css.perspective !== 'none' || // @ts-ignore (TS 4.1 compat)
+    css.contain === 'paint' || ['transform', 'perspective'].includes(css.willChange) || isFirefox && css.willChange === 'filter' || isFirefox && (css.filter ? css.filter !== 'none' : false);
+  }
+  function isLayoutViewport() {
+    // Not Safari
+    return !/^((?!chrome|android).)*safari/i.test(getUAString()); // Feature detection for this fails in various ways
+    // • Always-visible scrollbar or not
+    // • Width of <html>, etc.
+    // const vV = win.visualViewport;
+    // return vV ? Math.abs(win.innerWidth / vV.scale - vV.width) < 0.5 : true;
+  }
+
+  const min = Math.min;
+  const max = Math.max;
+  const round = Math.round;
+
+  function getBoundingClientRect(element, includeScale, isFixedStrategy) {
+    var _win$visualViewport$o, _win$visualViewport, _win$visualViewport$o2, _win$visualViewport2;
+
+    if (includeScale === void 0) {
+      includeScale = false;
+    }
+
+    if (isFixedStrategy === void 0) {
+      isFixedStrategy = false;
+    }
+
+    const clientRect = element.getBoundingClientRect();
+    let scaleX = 1;
+    let scaleY = 1;
+
+    if (includeScale && isHTMLElement(element)) {
+      scaleX = element.offsetWidth > 0 ? round(clientRect.width) / element.offsetWidth || 1 : 1;
+      scaleY = element.offsetHeight > 0 ? round(clientRect.height) / element.offsetHeight || 1 : 1;
+    }
+
+    const win = isElement(element) ? getWindow(element) : window;
+    const addVisualOffsets = !isLayoutViewport() && isFixedStrategy;
+    const x = (clientRect.left + (addVisualOffsets ? (_win$visualViewport$o = (_win$visualViewport = win.visualViewport) == null ? void 0 : _win$visualViewport.offsetLeft) != null ? _win$visualViewport$o : 0 : 0)) / scaleX;
+    const y = (clientRect.top + (addVisualOffsets ? (_win$visualViewport$o2 = (_win$visualViewport2 = win.visualViewport) == null ? void 0 : _win$visualViewport2.offsetTop) != null ? _win$visualViewport$o2 : 0 : 0)) / scaleY;
+    const width = clientRect.width / scaleX;
+    const height = clientRect.height / scaleY;
+    return {
+      width,
+      height,
+      top: y,
+      right: x + width,
+      bottom: y + height,
+      left: x,
+      x,
+      y
+    };
+  }
+
+  function getDocumentElement(node) {
+    return ((isNode(node) ? node.ownerDocument : node.document) || window.document).documentElement;
+  }
+
+  function getNodeScroll(element) {
+    if (isElement(element)) {
+      return {
+        scrollLeft: element.scrollLeft,
+        scrollTop: element.scrollTop
+      };
+    }
+
+    return {
+      scrollLeft: element.pageXOffset,
+      scrollTop: element.pageYOffset
+    };
+  }
+
+  function getWindowScrollBarX(element) {
+    // If <html> has a CSS width greater than the viewport, then this will be
+    // incorrect for RTL.
+    return getBoundingClientRect(getDocumentElement(element)).left + getNodeScroll(element).scrollLeft;
+  }
+
+  function isScaled(element) {
+    const rect = getBoundingClientRect(element);
+    return round(rect.width) !== element.offsetWidth || round(rect.height) !== element.offsetHeight;
+  }
+
+  function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
+    const isOffsetParentAnElement = isHTMLElement(offsetParent);
+    const documentElement = getDocumentElement(offsetParent);
+    const rect = getBoundingClientRect(element, // @ts-ignore - checked above (TS 4.1 compat)
+    isOffsetParentAnElement && isScaled(offsetParent), strategy === 'fixed');
+    let scroll = {
+      scrollLeft: 0,
+      scrollTop: 0
+    };
+    const offsets = {
+      x: 0,
+      y: 0
+    };
+
+    if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== 'fixed') {
+      if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
+        scroll = getNodeScroll(offsetParent);
+      }
+
+      if (isHTMLElement(offsetParent)) {
+        const offsetRect = getBoundingClientRect(offsetParent, true);
+        offsets.x = offsetRect.x + offsetParent.clientLeft;
+        offsets.y = offsetRect.y + offsetParent.clientTop;
+      } else if (documentElement) {
+        offsets.x = getWindowScrollBarX(documentElement);
+      }
+    }
+
+    return {
+      x: rect.left + scroll.scrollLeft - offsets.x,
+      y: rect.top + scroll.scrollTop - offsets.y,
+      width: rect.width,
+      height: rect.height
+    };
+  }
+
+  function getParentNode(node) {
+    if (getNodeName(node) === 'html') {
+      return node;
+    }
+
+    return (// this is a quicker (but less type safe) way to save quite some bytes from the bundle
+      // @ts-ignore
+      node.assignedSlot || // step into the shadow DOM of the parent of a slotted node
+      node.parentNode || ( // DOM Element detected
+      isShadowRoot(node) ? node.host : null) || // ShadowRoot detected
+      getDocumentElement(node) // fallback
+
+    );
+  }
+
+  function getTrueOffsetParent(element) {
+    if (!isHTMLElement(element) || getComputedStyle$1(element).position === 'fixed') {
+      return null;
+    }
+
+    return composedOffsetParent(element);
+  }
+  /**
+   * Polyfills the old offsetParent behavior from before the spec was changed:
+   * https://github.com/w3c/csswg-drafts/issues/159
+   */
+
+
+  function composedOffsetParent(element) {
+    let {
+      offsetParent
+    } = element;
+    let ancestor = element;
+    let foundInsideSlot = false;
+
+    while (ancestor && ancestor !== offsetParent) {
+      const {
+        assignedSlot
+      } = ancestor;
+
+      if (assignedSlot) {
+        let newOffsetParent = assignedSlot.offsetParent;
+
+        if (getComputedStyle$1(assignedSlot).display === 'contents') {
+          const hadStyleAttribute = assignedSlot.hasAttribute('style');
+          const oldDisplay = assignedSlot.style.display;
+          assignedSlot.style.display = getComputedStyle$1(ancestor).display;
+          newOffsetParent = assignedSlot.offsetParent;
+          assignedSlot.style.display = oldDisplay;
+
+          if (!hadStyleAttribute) {
+            assignedSlot.removeAttribute('style');
+          }
+        }
+
+        ancestor = assignedSlot;
+
+        if (offsetParent !== newOffsetParent) {
+          offsetParent = newOffsetParent;
+          foundInsideSlot = true;
+        }
+      } else if (isShadowRoot(ancestor) && ancestor.host && foundInsideSlot) {
+        break;
+      }
+
+      ancestor = isShadowRoot(ancestor) && ancestor.host || ancestor.parentNode;
+    }
+
+    return offsetParent;
+  }
+
+  function getContainingBlock(element) {
+    let currentNode = getParentNode(element);
+
+    if (isShadowRoot(currentNode)) {
+      currentNode = currentNode.host;
+    }
+
+    while (isHTMLElement(currentNode) && !['html', 'body'].includes(getNodeName(currentNode))) {
+      if (isContainingBlock(currentNode)) {
+        return currentNode;
+      } else {
+        const parent = currentNode.parentNode;
+        currentNode = isShadowRoot(parent) ? parent.host : parent;
+      }
+    }
+
+    return null;
+  } // Gets the closest ancestor positioned element. Handles some edge cases,
+  // such as table ancestors and cross browser bugs.
+
+
+  function getOffsetParent(element) {
+    const window = getWindow(element);
+    let offsetParent = getTrueOffsetParent(element);
+
+    while (offsetParent && isTableElement(offsetParent) && getComputedStyle$1(offsetParent).position === 'static') {
+      offsetParent = getTrueOffsetParent(offsetParent);
+    }
+
+    if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle$1(offsetParent).position === 'static' && !isContainingBlock(offsetParent))) {
+      return window;
+    }
+
+    return offsetParent || getContainingBlock(element) || window;
+  }
+
+  function getDimensions(element) {
+    if (isHTMLElement(element)) {
+      return {
+        width: element.offsetWidth,
+        height: element.offsetHeight
+      };
+    }
+
+    const rect = getBoundingClientRect(element);
+    return {
+      width: rect.width,
+      height: rect.height
+    };
+  }
+
+  function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
+    let {
+      rect,
+      offsetParent,
+      strategy
+    } = _ref;
+    const isOffsetParentAnElement = isHTMLElement(offsetParent);
+    const documentElement = getDocumentElement(offsetParent);
+
+    if (offsetParent === documentElement) {
+      return rect;
+    }
+
+    let scroll = {
+      scrollLeft: 0,
+      scrollTop: 0
+    };
+    const offsets = {
+      x: 0,
+      y: 0
+    };
+
+    if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== 'fixed') {
+      if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
+        scroll = getNodeScroll(offsetParent);
+      }
+
+      if (isHTMLElement(offsetParent)) {
+        const offsetRect = getBoundingClientRect(offsetParent, true);
+        offsets.x = offsetRect.x + offsetParent.clientLeft;
+        offsets.y = offsetRect.y + offsetParent.clientTop;
+      } // This doesn't appear to be need to be negated.
+      // else if (documentElement) {
+      //   offsets.x = getWindowScrollBarX(documentElement);
+      // }
+
+    }
+
+    return { ...rect,
+      x: rect.x - scroll.scrollLeft + offsets.x,
+      y: rect.y - scroll.scrollTop + offsets.y
+    };
+  }
+
+  function getViewportRect(element, strategy) {
+    const win = getWindow(element);
+    const html = getDocumentElement(element);
+    const visualViewport = win.visualViewport;
+    let width = html.clientWidth;
+    let height = html.clientHeight;
+    let x = 0;
+    let y = 0;
+
+    if (visualViewport) {
+      width = visualViewport.width;
+      height = visualViewport.height;
+      const layoutViewport = isLayoutViewport();
+
+      if (layoutViewport || !layoutViewport && strategy === 'fixed') {
+        x = visualViewport.offsetLeft;
+        y = visualViewport.offsetTop;
+      }
+    }
+
+    return {
+      width,
+      height,
+      x,
+      y
+    };
+  }
+
+  // of the `<html>` and `<body>` rect bounds if horizontally scrollable
+
+  function getDocumentRect(element) {
+    var _element$ownerDocumen;
+
+    const html = getDocumentElement(element);
+    const scroll = getNodeScroll(element);
+    const body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body;
+    const width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
+    const height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
+    let x = -scroll.scrollLeft + getWindowScrollBarX(element);
+    const y = -scroll.scrollTop;
+
+    if (getComputedStyle$1(body || html).direction === 'rtl') {
+      x += max(html.clientWidth, body ? body.clientWidth : 0) - width;
+    }
+
+    return {
+      width,
+      height,
+      x,
+      y
+    };
+  }
+
+  function getNearestOverflowAncestor(node) {
+    const parentNode = getParentNode(node);
+
+    if (['html', 'body', '#document'].includes(getNodeName(parentNode))) {
+      // @ts-ignore assume body is always available
+      return node.ownerDocument.body;
+    }
+
+    if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
+      return parentNode;
+    }
+
+    return getNearestOverflowAncestor(parentNode);
+  }
+
+  function getOverflowAncestors(node, list) {
+    var _node$ownerDocument;
+
+    if (list === void 0) {
+      list = [];
+    }
+
+    const scrollableAncestor = getNearestOverflowAncestor(node);
+    const isBody = scrollableAncestor === ((_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.body);
+    const win = getWindow(scrollableAncestor);
+    const target = isBody ? [win].concat(win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : []) : scrollableAncestor;
+    const updatedList = list.concat(target);
+    return isBody ? updatedList : // @ts-ignore: isBody tells us target will be an HTMLElement here
+    updatedList.concat(getOverflowAncestors(target));
+  }
+
+  function contains(parent, child) {
+    const rootNode = child.getRootNode == null ? void 0 : child.getRootNode(); // First, attempt with faster native method
+
+    if (parent.contains(child)) {
+      return true;
+    } // then fallback to custom implementation with Shadow DOM support
+    else if (rootNode && isShadowRoot(rootNode)) {
+      let next = child;
+
+      do {
+        // use `===` replace node.isSameNode()
+        if (next && parent === next) {
+          return true;
+        } // @ts-ignore: need a better way to handle this...
+
+
+        next = next.parentNode || next.host;
+      } while (next);
+    }
+
+    return false;
+  }
+
+  function getInnerBoundingClientRect(element, strategy) {
+    const clientRect = getBoundingClientRect(element, false, strategy === 'fixed');
+    const top = clientRect.top + element.clientTop;
+    const left = clientRect.left + element.clientLeft;
+    return {
+      top,
+      left,
+      x: left,
+      y: top,
+      right: left + element.clientWidth,
+      bottom: top + element.clientHeight,
+      width: element.clientWidth,
+      height: element.clientHeight
+    };
+  }
+
+  function getClientRectFromClippingAncestor(element, clippingParent, strategy) {
+    if (clippingParent === 'viewport') {
+      return rectToClientRect(getViewportRect(element, strategy));
+    }
+
+    if (isElement(clippingParent)) {
+      return getInnerBoundingClientRect(clippingParent, strategy);
+    }
+
+    return rectToClientRect(getDocumentRect(getDocumentElement(element)));
+  } // A "clipping ancestor" is an overflowable container with the characteristic of
+  // clipping (or hiding) overflowing elements with a position different from
+  // `initial`
+
+
+  function getClippingAncestors(element) {
+    const clippingAncestors = getOverflowAncestors(element);
+    const canEscapeClipping = ['absolute', 'fixed'].includes(getComputedStyle$1(element).position);
+    const clipperElement = canEscapeClipping && isHTMLElement(element) ? getOffsetParent(element) : element;
+
+    if (!isElement(clipperElement)) {
+      return [];
+    } // @ts-ignore isElement check ensures we return Array<Element>
+
+
+    return clippingAncestors.filter(clippingAncestors => isElement(clippingAncestors) && contains(clippingAncestors, clipperElement) && getNodeName(clippingAncestors) !== 'body');
+  } // Gets the maximum area that the element is visible in due to any number of
+  // clipping ancestors
+
+
+  function getClippingRect(_ref) {
+    let {
+      element,
+      boundary,
+      rootBoundary,
+      strategy
+    } = _ref;
+    const mainClippingAncestors = boundary === 'clippingAncestors' ? getClippingAncestors(element) : [].concat(boundary);
+    const clippingAncestors = [...mainClippingAncestors, rootBoundary];
+    const firstClippingAncestor = clippingAncestors[0];
+    const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
+      const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
+      accRect.top = max(rect.top, accRect.top);
+      accRect.right = min(rect.right, accRect.right);
+      accRect.bottom = min(rect.bottom, accRect.bottom);
+      accRect.left = max(rect.left, accRect.left);
+      return accRect;
+    }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
+    return {
+      width: clippingRect.right - clippingRect.left,
+      height: clippingRect.bottom - clippingRect.top,
+      x: clippingRect.left,
+      y: clippingRect.top
+    };
+  }
+
+  const platform = {
+    getClippingRect,
+    convertOffsetParentRelativeRectToViewportRelativeRect,
+    isElement,
+    getDimensions,
+    getOffsetParent,
+    getDocumentElement,
+    getElementRects: _ref => {
+      let {
+        reference,
+        floating,
+        strategy
+      } = _ref;
+      return {
+        reference: getRectRelativeToOffsetParent(reference, getOffsetParent(floating), strategy),
+        floating: { ...getDimensions(floating),
+          x: 0,
+          y: 0
+        }
+      };
+    },
+    getClientRects: element => Array.from(element.getClientRects()),
+    isRTL: element => getComputedStyle$1(element).direction === 'rtl'
+  };
+
+  /**
+   * Automatically updates the position of the floating element when necessary.
+   * @see https://floating-ui.com/docs/autoUpdate
+   */
+  function autoUpdate(reference, floating, update, options) {
+    if (options === void 0) {
+      options = {};
+    }
+
+    const {
+      ancestorScroll: _ancestorScroll = true,
+      ancestorResize: _ancestorResize = true,
+      elementResize = true,
+      animationFrame = false
+    } = options;
+    const ancestorScroll = _ancestorScroll && !animationFrame;
+    const ancestorResize = _ancestorResize && !animationFrame;
+    const ancestors = ancestorScroll || ancestorResize ? [...(isElement(reference) ? getOverflowAncestors(reference) : []), ...getOverflowAncestors(floating)] : [];
+    ancestors.forEach(ancestor => {
+      ancestorScroll && ancestor.addEventListener('scroll', update, {
+        passive: true
+      });
+      ancestorResize && ancestor.addEventListener('resize', update);
+    });
+    let observer = null;
+
+    if (elementResize) {
+      let initialUpdate = true;
+      observer = new ResizeObserver(() => {
+        if (!initialUpdate) {
+          update();
+        }
+
+        initialUpdate = false;
+      });
+      isElement(reference) && !animationFrame && observer.observe(reference);
+      observer.observe(floating);
+    }
+
+    let frameId;
+    let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
+
+    if (animationFrame) {
+      frameLoop();
+    }
+
+    function frameLoop() {
+      const nextRefRect = getBoundingClientRect(reference);
+
+      if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) {
+        update();
+      }
+
+      prevRefRect = nextRefRect;
+      frameId = requestAnimationFrame(frameLoop);
+    }
+
+    update();
+    return () => {
+      var _observer;
+
+      ancestors.forEach(ancestor => {
+        ancestorScroll && ancestor.removeEventListener('scroll', update);
+        ancestorResize && ancestor.removeEventListener('resize', update);
+      });
+      (_observer = observer) == null ? void 0 : _observer.disconnect();
+      observer = null;
+
+      if (animationFrame) {
+        cancelAnimationFrame(frameId);
+      }
+    };
+  }
+
+  /**
+   * Computes the `x` and `y` coordinates that will place the floating element
+   * next to a reference element when it is given a certain CSS positioning
+   * strategy.
+   */
+
+  const computePosition = (reference, floating, options) => computePosition$1(reference, floating, {
+    platform,
+    ...options
+  });
+
   const visualHiddenProps = buildProps({
     style: {
       type: definePropType([String, Object, Array]),
@@ -54199,7 +56100,7 @@
     });
   };
   let nodeIdSeed = 0;
-  class Node {
+  class Node$1 {
     constructor(options) {
       this.isLeafByUser = void 0;
       this.isLeaf = void 0;
@@ -54330,7 +56231,7 @@
     insertChild(child, index, batch) {
       if (!child)
         throw new Error("InsertChild error: child is required.");
-      if (!(child instanceof Node)) {
+      if (!(child instanceof Node$1)) {
         if (!batch) {
           const children = this.getChildren(true);
           if (!(children == null ? void 0 : children.includes(child.data))) {
@@ -54345,8 +56246,8 @@
           parent: this,
           store: this.store
         });
-        child = vue.reactive(new Node(child));
-        if (child instanceof Node) {
+        child = vue.reactive(new Node$1(child));
+        if (child instanceof Node$1) {
           child.initialize();
         }
       }
@@ -54580,7 +56481,7 @@
       reInitChecked(this);
     }
   }
-  var Node$1 = Node;
+  var Node$2 = Node$1;
 
   class TreeStore {
     constructor(options) {
@@ -54599,7 +56500,7 @@
       this.nodesMap = {};
     }
     initialize() {
-      this.root = new Node$1({
+      this.root = new Node$2({
         data: this.data,
         store: this
       });
@@ -54657,7 +56558,7 @@
       }
     }
     getNode(data) {
-      if (data instanceof Node$1)
+      if (data instanceof Node$2)
         return data;
       const key = isObject$1(data) ? getNodeKey(this.key, data) : data;
       return this.nodesMap[key] || null;
@@ -55135,7 +57036,7 @@
     },
     props: {
       node: {
-        type: Node$1,
+        type: Node$2,
         default: () => ({})
       },
       props: {
@@ -61780,7 +63681,7 @@
       normalized.appendTo = document.body;
     } else if (isString$1(normalized.appendTo)) {
       let appendTo = document.querySelector(normalized.appendTo);
-      if (!isElement$1(appendTo)) {
+      if (!isElement$2(appendTo)) {
         appendTo = document.body;
       }
       normalized.appendTo = appendTo;
@@ -62367,10 +64268,10 @@
       if (isString$1(props.appendTo)) {
         appendTo = document.querySelector(props.appendTo);
       }
-      if (isElement$1(props.appendTo)) {
+      if (isElement$2(props.appendTo)) {
         appendTo = props.appendTo;
       }
-      if (!isElement$1(appendTo)) {
+      if (!isElement$2(appendTo)) {
         appendTo = document.body;
       }
     }
@@ -62738,12 +64639,12 @@
       }
     };
     let appendTo = document.body;
-    if (isElement$1(options.appendTo)) {
+    if (isElement$2(options.appendTo)) {
       appendTo = options.appendTo;
     } else if (isString$1(options.appendTo)) {
       appendTo = document.querySelector(options.appendTo);
     }
-    if (!isElement$1(appendTo)) {
+    if (!isElement$2(appendTo)) {
       appendTo = document.body;
     }
     const container = document.createElement("div");
@@ -63091,6 +64992,7 @@
   exports.defaultProps = defaultProps;
   exports.descriptionItemProps = descriptionItemProps;
   exports.descriptionProps = descriptionProps;
+  exports.dialogContextKey = dialogContextKey;
   exports.dialogEmits = dialogEmits;
   exports.dialogInjectionKey = dialogInjectionKey;
   exports.dialogProps = dialogProps;