@element-plus/nightly 0.0.20220324 → 0.0.20220325

package/dist/index.full.js

@@ -1,4 +1,4 @@
-/*! Element Plus v0.0.20220324 */
+/*! Element Plus v0.0.20220325 */
 
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('vue')) :
@@ -2272,7 +2272,7 @@
 
   const isUndefined = (val) => val === void 0;
   const isEmpty = (val) => !val && val !== 0 || isArray(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;
@@ -4308,7 +4308,703 @@
     };
   };
 
-  const version$1 = "0.0.20220324";
+  function getSide(placement) {
+    return placement.split("-")[0];
+  }
+  function getAlignment(placement) {
+    return placement.split("-")[1];
+  }
+  function getMainAxisFromPlacement$1(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$1(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;
+  }
+  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 = {};
+    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) {
+        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$1(rect) {
+    return {
+      ...rect,
+      top: rect.y,
+      left: rect.x,
+      right: rect.x + rect.width,
+      bottom: rect.y + rect.height
+    };
+  }
+  const min$3 = Math.min;
+  const max$3 = Math.max;
+  function within$1(min$1, value, max$1) {
+    return max$3(min$1, min$3(value, max$1));
+  }
+  const arrow$2 = (options) => ({
+    name: "arrow",
+    options,
+    async fn(middlewareArguments) {
+      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$1(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));
+      const clientSize = arrowOffsetParent ? axis === "y" ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;
+      const centerToReference = endDiff / 2 - startDiff / 2;
+      const min2 = paddingObject[minProp];
+      const max2 = clientSize - arrowDimensions[length] - paddingObject[maxProp];
+      const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
+      const offset2 = within$1(min2, center, max2);
+      return {
+        data: {
+          [axis]: offset2,
+          centerOffset: center - offset2
+        }
+      };
+    }
+  });
+
+  function isWindow(value) {
+    return (value == null ? void 0 : value.toString()) === "[object Window]";
+  }
+  function getWindow$1(node) {
+    if (node == null) {
+      return window;
+    }
+    if (!isWindow(node)) {
+      const ownerDocument = node.ownerDocument;
+      return ownerDocument ? ownerDocument.defaultView || window : window;
+    }
+    return node;
+  }
+  function getComputedStyle$1$1(element) {
+    return getWindow$1(element).getComputedStyle(element);
+  }
+  function getNodeName$1(node) {
+    return isWindow(node) ? "" : node ? (node.nodeName || "").toLowerCase() : "";
+  }
+  function isHTMLElement$1(value) {
+    return value instanceof getWindow$1(value).HTMLElement;
+  }
+  function isElement$1(value) {
+    return value instanceof getWindow$1(value).Element;
+  }
+  function isNode(value) {
+    return value instanceof getWindow$1(value).Node;
+  }
+  function isShadowRoot$1(node) {
+    const OwnElement = getWindow$1(node).ShadowRoot;
+    return node instanceof OwnElement || node instanceof ShadowRoot;
+  }
+  function isOverflowElement(element) {
+    const {
+      overflow,
+      overflowX,
+      overflowY
+    } = getComputedStyle$1$1(element);
+    return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
+  }
+  function isTableElement$1(element) {
+    return ["table", "td", "th"].includes(getNodeName$1(element));
+  }
+  function isContainingBlock(element) {
+    const isFirefox = navigator.userAgent.toLowerCase().includes("firefox");
+    const css = getComputedStyle$1$1(element);
+    return css.transform !== "none" || css.perspective !== "none" || css.contain === "paint" || ["transform", "perspective"].includes(css.willChange) || isFirefox && css.willChange === "filter" || isFirefox && (css.filter ? css.filter !== "none" : false);
+  }
+  function isLayoutViewport() {
+    return !/^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+  }
+  const min$2 = Math.min;
+  const max$2 = Math.max;
+  const round$1 = Math.round;
+  function getBoundingClientRect$1(element, includeScale, isFixedStrategy) {
+    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$1(element)) {
+      scaleX = element.offsetWidth > 0 ? round$1(clientRect.width) / element.offsetWidth || 1 : 1;
+      scaleY = element.offsetHeight > 0 ? round$1(clientRect.height) / element.offsetHeight || 1 : 1;
+    }
+    const win = isElement$1(element) ? getWindow$1(element) : window;
+    const addVisualOffsets = !isLayoutViewport() && isFixedStrategy;
+    const x = (clientRect.left + (addVisualOffsets ? win.visualViewport.offsetLeft : 0)) / scaleX;
+    const y = (clientRect.top + (addVisualOffsets ? win.visualViewport.offsetTop : 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$1(node) {
+    return ((isNode(node) ? node.ownerDocument : node.document) || window.document).documentElement;
+  }
+  function getNodeScroll$1(element) {
+    if (isWindow(element)) {
+      return {
+        scrollLeft: element.pageXOffset,
+        scrollTop: element.pageYOffset
+      };
+    }
+    return {
+      scrollLeft: element.scrollLeft,
+      scrollTop: element.scrollTop
+    };
+  }
+  function getWindowScrollBarX$1(element) {
+    return getBoundingClientRect$1(getDocumentElement$1(element)).left + getNodeScroll$1(element).scrollLeft;
+  }
+  function isScaled(element) {
+    const rect = getBoundingClientRect$1(element);
+    return round$1(rect.width) !== element.offsetWidth || round$1(rect.height) !== element.offsetHeight;
+  }
+  function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
+    const isOffsetParentAnElement = isHTMLElement$1(offsetParent);
+    const documentElement = getDocumentElement$1(offsetParent);
+    const rect = getBoundingClientRect$1(element, isOffsetParentAnElement && isScaled(offsetParent), strategy === "fixed");
+    let scroll = {
+      scrollLeft: 0,
+      scrollTop: 0
+    };
+    const offsets = {
+      x: 0,
+      y: 0
+    };
+    if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== "fixed") {
+      if (getNodeName$1(offsetParent) !== "body" || isOverflowElement(documentElement)) {
+        scroll = getNodeScroll$1(offsetParent);
+      }
+      if (isHTMLElement$1(offsetParent)) {
+        const offsetRect = getBoundingClientRect$1(offsetParent, true);
+        offsets.x = offsetRect.x + offsetParent.clientLeft;
+        offsets.y = offsetRect.y + offsetParent.clientTop;
+      } else if (documentElement) {
+        offsets.x = getWindowScrollBarX$1(documentElement);
+      }
+    }
+    return {
+      x: rect.left + scroll.scrollLeft - offsets.x,
+      y: rect.top + scroll.scrollTop - offsets.y,
+      width: rect.width,
+      height: rect.height
+    };
+  }
+  function getParentNode$1(node) {
+    if (getNodeName$1(node) === "html") {
+      return node;
+    }
+    return node.assignedSlot || node.parentNode || (isShadowRoot$1(node) ? node.host : null) || getDocumentElement$1(node);
+  }
+  function getTrueOffsetParent$1(element) {
+    if (!isHTMLElement$1(element) || getComputedStyle(element).position === "fixed") {
+      return null;
+    }
+    return element.offsetParent;
+  }
+  function getContainingBlock$1(element) {
+    let currentNode = getParentNode$1(element);
+    if (isShadowRoot$1(currentNode)) {
+      currentNode = currentNode.host;
+    }
+    while (isHTMLElement$1(currentNode) && !["html", "body"].includes(getNodeName$1(currentNode))) {
+      if (isContainingBlock(currentNode)) {
+        return currentNode;
+      } else {
+        currentNode = currentNode.parentNode;
+      }
+    }
+    return null;
+  }
+  function getOffsetParent$1(element) {
+    const window2 = getWindow$1(element);
+    let offsetParent = getTrueOffsetParent$1(element);
+    while (offsetParent && isTableElement$1(offsetParent) && getComputedStyle(offsetParent).position === "static") {
+      offsetParent = getTrueOffsetParent$1(offsetParent);
+    }
+    if (offsetParent && (getNodeName$1(offsetParent) === "html" || getNodeName$1(offsetParent) === "body" && getComputedStyle(offsetParent).position === "static" && !isContainingBlock(offsetParent))) {
+      return window2;
+    }
+    return offsetParent || getContainingBlock$1(element) || window2;
+  }
+  function getDimensions(element) {
+    if (isHTMLElement$1(element)) {
+      return {
+        width: element.offsetWidth,
+        height: element.offsetHeight
+      };
+    }
+    const rect = getBoundingClientRect$1(element);
+    return {
+      width: rect.width,
+      height: rect.height
+    };
+  }
+  function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
+    let {
+      rect,
+      offsetParent,
+      strategy
+    } = _ref;
+    const isOffsetParentAnElement = isHTMLElement$1(offsetParent);
+    const documentElement = getDocumentElement$1(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$1(offsetParent) !== "body" || isOverflowElement(documentElement)) {
+        scroll = getNodeScroll$1(offsetParent);
+      }
+      if (isHTMLElement$1(offsetParent)) {
+        const offsetRect = getBoundingClientRect$1(offsetParent, true);
+        offsets.x = offsetRect.x + offsetParent.clientLeft;
+        offsets.y = offsetRect.y + offsetParent.clientTop;
+      }
+    }
+    return {
+      ...rect,
+      x: rect.x - scroll.scrollLeft + offsets.x,
+      y: rect.y - scroll.scrollTop + offsets.y
+    };
+  }
+  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") {
+        x = visualViewport.offsetLeft;
+        y = visualViewport.offsetTop;
+      }
+    }
+    return {
+      width,
+      height,
+      x,
+      y
+    };
+  }
+  function getDocumentRect$1(element) {
+    var _element$ownerDocumen;
+    const html = getDocumentElement$1(element);
+    const scroll = getNodeScroll$1(element);
+    const body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body;
+    const width = max$2(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
+    const height = max$2(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
+    let x = -scroll.scrollLeft + getWindowScrollBarX$1(element);
+    const y = -scroll.scrollTop;
+    if (getComputedStyle$1$1(body || html).direction === "rtl") {
+      x += max$2(html.clientWidth, body ? body.clientWidth : 0) - width;
+    }
+    return {
+      width,
+      height,
+      x,
+      y
+    };
+  }
+  function getNearestOverflowAncestor(node) {
+    const parentNode = getParentNode$1(node);
+    if (["html", "body", "#document"].includes(getNodeName$1(parentNode))) {
+      return node.ownerDocument.body;
+    }
+    if (isHTMLElement$1(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$1(scrollableAncestor);
+    const target = isBody ? [win].concat(win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : []) : scrollableAncestor;
+    const updatedList = list.concat(target);
+    return isBody ? updatedList : updatedList.concat(getOverflowAncestors(getParentNode$1(target)));
+  }
+  function contains$1(parent, child) {
+    const rootNode = child.getRootNode == null ? void 0 : child.getRootNode();
+    if (parent.contains(child)) {
+      return true;
+    } else if (rootNode && isShadowRoot$1(rootNode)) {
+      let next = child;
+      do {
+        if (next && parent === next) {
+          return true;
+        }
+        next = next.parentNode || next.host;
+      } while (next);
+    }
+    return false;
+  }
+  function getInnerBoundingClientRect$1(element, strategy) {
+    const clientRect = getBoundingClientRect$1(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$1(getViewportRect$1(element, strategy));
+    }
+    if (isElement$1(clippingParent)) {
+      return getInnerBoundingClientRect$1(clippingParent, strategy);
+    }
+    return rectToClientRect$1(getDocumentRect$1(getDocumentElement$1(element)));
+  }
+  function getClippingAncestors(element) {
+    const clippingAncestors = getOverflowAncestors(element);
+    const canEscapeClipping = ["absolute", "fixed"].includes(getComputedStyle$1$1(element).position);
+    const clipperElement = canEscapeClipping && isHTMLElement$1(element) ? getOffsetParent$1(element) : element;
+    if (!isElement$1(clipperElement)) {
+      return [];
+    }
+    return clippingAncestors.filter((clippingAncestors2) => isElement$1(clippingAncestors2) && contains$1(clippingAncestors2, clipperElement) && getNodeName$1(clippingAncestors2) !== "body");
+  }
+  function getClippingRect$1(_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$2(rect.top, accRect.top);
+      accRect.right = min$2(rect.right, accRect.right);
+      accRect.bottom = min$2(rect.bottom, accRect.bottom);
+      accRect.left = max$2(rect.left, accRect.left);
+      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: getClippingRect$1,
+    convertOffsetParentRelativeRectToViewportRelativeRect,
+    isElement: isElement$1,
+    getDimensions,
+    getOffsetParent: getOffsetParent$1,
+    getDocumentElement: getDocumentElement$1,
+    getElementRects: (_ref) => {
+      let {
+        reference,
+        floating,
+        strategy
+      } = _ref;
+      return {
+        reference: getRectRelativeToOffsetParent(reference, getOffsetParent$1(floating), strategy),
+        floating: {
+          ...getDimensions(floating),
+          x: 0,
+          y: 0
+        }
+      };
+    },
+    getClientRects: (element) => Array.from(element.getClientRects()),
+    isRTL: (element) => getComputedStyle$1$1(element).direction === "rtl"
+  };
+  const computePosition = (reference, floating, options) => computePosition$1(reference, floating, {
+    platform,
+    ...options
+  });
+
+  const useFloatingProps = buildProps({});
+  const unrefReference = (elRef) => {
+    if (!isClient)
+      return;
+    if (!elRef)
+      return elRef;
+    const unrefEl = unrefElement(elRef);
+    if (unrefEl)
+      return unrefEl;
+    return elRef;
+  };
+  const getPositionDataWithUnit = (record, key) => {
+    const value = record == null ? void 0 : record[key];
+    return isNil(value) ? "" : `${value}px`;
+  };
+  const useFloating = ({
+    middleware,
+    placement,
+    strategy
+  }) => {
+    const referenceRef = vue.ref();
+    const contentRef = vue.ref();
+    const x = vue.ref();
+    const y = vue.ref();
+    const middlewareData = vue.ref({});
+    const states = {
+      x,
+      y,
+      placement,
+      strategy,
+      middlewareData
+    };
+    const update = async () => {
+      if (!isClient)
+        return;
+      const referenceEl = unrefReference(referenceRef);
+      const contentEl = unrefElement(contentRef);
+      if (!referenceEl || !contentEl)
+        return;
+      const data = await computePosition(referenceEl, contentEl, {
+        placement: vue.unref(placement),
+        strategy: vue.unref(strategy),
+        middleware: vue.unref(middleware)
+      });
+      ["x", "y"].forEach((key) => data[key] = getPositionDataWithUnit(data, key));
+      Object.keys(states).forEach((key) => {
+        states[key].value = data[key];
+      });
+    };
+    vue.watch(referenceRef, () => update());
+    vue.watch(contentRef, () => update());
+    vue.onMounted(() => update());
+    return {
+      ...states,
+      update,
+      referenceRef,
+      contentRef
+    };
+  };
+  const arrowMiddleware = ({
+    arrowRef,
+    padding
+  }) => {
+    return {
+      name: "arrow",
+      options: {
+        element: arrowRef,
+        padding
+      },
+      fn(args) {
+        const arrowEl = vue.unref(arrowRef);
+        if (!arrowEl)
+          return {};
+        return arrow$2({
+          element: arrowEl,
+          padding
+        }).fn(args);
+      }
+    };
+  };
+
+  const version$1 = "0.0.20220325";
 
   const INSTALLED_KEY = Symbol("INSTALLED_KEY");
   const makeInstaller = (components = []) => {
@@ -5779,7 +6475,7 @@
           immediate: true
         });
         vue.watch(() => triggerRef.value, (el, prevEl) => {
-          if (isElement$1(el)) {
+          if (isElement$2(el)) {
             [
               "onMouseenter",
               "onMouseleave",
@@ -8110,6 +8806,7 @@
         emit("input", value);
         emit(UPDATE_MODEL_EVENT, value);
         suggestionDisabled.value = false;
+        activated.value = Boolean(value);
         if (!props.triggerOnFocus && !value) {
           suggestionDisabled.value = true;
           suggestions.value = [];
@@ -10979,7 +11676,7 @@
     let excludes = [];
     if (Array.isArray(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) {
@@ -14786,7 +15483,7 @@
           ref_for: true,
           ref: (item) => _ctx.menuList[index] = item,
           index,
-          nodes: menu
+          nodes: [...menu]
         }, null, 8, ["index", "nodes"]);
       }), 128))
     ], 34);
@@ -24465,7 +25162,7 @@
           return;
         await vue.nextTick();
         const { scrollContainer } = props;
-        if (isElement$1(scrollContainer)) {
+        if (isElement$2(scrollContainer)) {
           _scrollContainer.value = scrollContainer;
         } else if (isString(scrollContainer) && scrollContainer !== "") {
           _scrollContainer.value = (_a = document.querySelector(scrollContainer)) != null ? _a : void 0;
@@ -24673,11 +25370,11 @@
       });
       const { formItem } = useFormItem();
       const ns = useNamespace("input-number");
-      const minDisabled = vue.computed(() => _decrease(props.modelValue) < props.min);
-      const maxDisabled = vue.computed(() => _increase(props.modelValue) > props.max);
+      const minDisabled = vue.computed(() => ensurePrecision(props.modelValue, -1) < props.min);
+      const maxDisabled = vue.computed(() => ensurePrecision(props.modelValue) > props.max);
       const numPrecision = vue.computed(() => {
         const stepPrecision = getPrecision(props.step);
-        if (props.precision !== void 0) {
+        if (!isUndefined(props.precision)) {
           if (stepPrecision > props.precision) ;
           return props.precision;
         } else {
@@ -24697,19 +25394,19 @@
         if (isNumber(currentValue)) {
           if (Number.isNaN(currentValue))
             return "";
-          if (props.precision !== void 0) {
+          if (!isUndefined(props.precision)) {
             currentValue = currentValue.toFixed(props.precision);
           }
         }
         return currentValue;
       });
       const toPrecision = (num, pre) => {
-        if (pre === void 0)
+        if (isUndefined(pre))
           pre = numPrecision.value;
         return Number.parseFloat(`${Math.round(num * 10 ** pre) / 10 ** pre}`);
       };
       const getPrecision = (value) => {
-        if (value === void 0)
+        if (isUndefined(value))
           return 0;
         const valueString = value.toString();
         const dotPosition = valueString.indexOf(".");
@@ -24719,52 +25416,53 @@
         }
         return precision;
       };
-      const _increase = (val) => {
+      const ensurePrecision = (val, coefficient = 1) => {
         if (!isNumber(val))
           return data.currentValue;
-        const precisionFactor = 10 ** numPrecision.value;
         val = isNumber(val) ? val : Number.NaN;
-        return toPrecision((precisionFactor * val + precisionFactor * props.step) / precisionFactor);
-      };
-      const _decrease = (val) => {
-        if (!isNumber(val))
-          return data.currentValue;
-        const precisionFactor = 10 ** numPrecision.value;
-        val = isNumber(val) ? val : Number.NaN;
-        return toPrecision((precisionFactor * val - precisionFactor * props.step) / precisionFactor);
+        return toPrecision(val + props.step * coefficient);
       };
       const increase = () => {
         if (inputNumberDisabled.value || maxDisabled.value)
           return;
         const value = props.modelValue || 0;
-        const newVal = _increase(value);
+        const newVal = ensurePrecision(value);
         setCurrentValue(newVal);
       };
       const decrease = () => {
         if (inputNumberDisabled.value || minDisabled.value)
           return;
         const value = props.modelValue || 0;
-        const newVal = _decrease(value);
+        const newVal = ensurePrecision(value, -1);
         setCurrentValue(newVal);
       };
-      const setCurrentValue = (newVal) => {
+      const verifyValue = (value, update) => {
+        const { max, min, step, precision, stepStrictly } = props;
+        let newVal = Number(value);
+        if (value === null) {
+          newVal = Number.NaN;
+        }
+        if (!Number.isNaN(newVal)) {
+          if (stepStrictly) {
+            newVal = Math.round(newVal / step) * step;
+          }
+          if (!isUndefined(precision)) {
+            newVal = toPrecision(newVal, precision);
+          }
+          if (newVal > max || newVal < min) {
+            newVal = newVal > max ? max : min;
+            update && emit("update:modelValue", newVal);
+          }
+        }
+        return newVal;
+      };
+      const setCurrentValue = (value) => {
         var _a;
         const oldVal = data.currentValue;
-        if (props.stepStrictly) {
-          const stepPrecision = getPrecision(props.step);
-          const precisionFactor = 10 ** stepPrecision;
-          newVal = Math.round(newVal / props.step) * precisionFactor * props.step / precisionFactor;
-        }
-        if (typeof newVal === "number" && props.precision !== void 0) {
-          newVal = toPrecision(newVal, props.precision);
-        }
-        if (newVal !== void 0 && newVal >= props.max)
-          newVal = props.max;
-        if (newVal !== void 0 && newVal <= props.min)
-          newVal = props.min;
+        let newVal = verifyValue(value);
         if (oldVal === newVal)
           return;
-        if (!isNumber(newVal)) {
+        if (Number.isNaN(newVal)) {
           newVal = void 0;
         }
         data.userInput = null;
@@ -24801,28 +25499,7 @@
         (_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, "blur").catch((err) => debugWarn());
       };
       vue.watch(() => props.modelValue, (value) => {
-        let newVal = Number(value);
-        if (value === null) {
-          newVal = Number.NaN;
-        }
-        if (!Number.isNaN(newVal)) {
-          if (props.stepStrictly) {
-            const stepPrecision = getPrecision(props.step);
-            const precisionFactor = 10 ** stepPrecision;
-            newVal = Math.round(newVal / props.step) * precisionFactor * props.step / precisionFactor;
-          }
-          if (props.precision !== void 0) {
-            newVal = toPrecision(newVal, props.precision);
-          }
-          if (newVal > props.max) {
-            newVal = props.max;
-            emit("update:modelValue", newVal);
-          }
-          if (newVal < props.min) {
-            newVal = props.min;
-            emit("update:modelValue", newVal);
-          }
-        }
+        const newVal = verifyValue(value, true);
         data.currentValue = newVal;
         data.userInput = null;
       }, { immediate: true });
@@ -38608,7 +39285,8 @@
         column.renderCell = (data) => {
           let children = null;
           if (slots.default) {
-            children = slots.default(data);
+            const vnodes = slots.default(data);
+            children = vnodes.some((v) => v.type !== vue.Comment) ? vnodes : originRenderCell(data);
           } else {
             children = originRenderCell(data);
           }
@@ -42233,6 +42911,7 @@
     }
     function setCheckedKeys(keys) {
       checkedKeys.value.clear();
+      indeterminateKeys.value.clear();
       _setCheckedKeys(keys);
     }
     function setChecked(key, isChecked2) {
@@ -44465,12 +45144,12 @@
       }
     };
     let appendTo = document.body;
-    if (isElement$1(options.appendTo)) {
+    if (isElement$2(options.appendTo)) {
       appendTo = options.appendTo;
     } else if (isString(options.appendTo)) {
       appendTo = document.querySelector(options.appendTo);
     }
-    if (!isElement$1(appendTo)) {
+    if (!isElement$2(appendTo)) {
       appendTo = document.body;
     }
     const container = document.createElement("div");
@@ -45329,12 +46008,12 @@
       }
     };
     let appendTo = document.body;
-    if (isElement$1(options.appendTo)) {
+    if (isElement$2(options.appendTo)) {
       appendTo = options.appendTo;
     } else if (isString(options.appendTo)) {
       appendTo = document.querySelector(options.appendTo);
     }
-    if (!isElement$1(appendTo)) {
+    if (!isElement$2(appendTo)) {
       appendTo = document.body;
     }
     const container = document.createElement("div");
@@ -45567,6 +46246,7 @@
   exports.alertEffects = alertEffects;
   exports.alertEmits = alertEmits;
   exports.alertProps = alertProps;
+  exports.arrowMiddleware = arrowMiddleware;
   exports.autocompleteEmits = autocompleteEmits;
   exports.autocompleteProps = autocompleteProps;
   exports.avatarEmits = avatarEmits;
@@ -45626,6 +46306,7 @@
   exports.formItemValidateStates = formItemValidateStates;
   exports.formProps = formProps;
   exports.genFileId = genFileId;
+  exports.getPositionDataWithUnit = getPositionDataWithUnit;
   exports.iconProps = iconProps;
   exports.imageEmits = imageEmits;
   exports.imageProps = imageProps;
@@ -45718,6 +46399,8 @@
   exports.useDisabled = useDisabled$1;
   exports.useDraggable = useDraggable;
   exports.useEscapeKeydown = useEscapeKeydown;
+  exports.useFloating = useFloating;
+  exports.useFloatingProps = useFloatingProps;
   exports.useFocus = useFocus;
   exports.useFormItem = useFormItem;
   exports.useForwardRef = useForwardRef;