bkui-vue 0.0.1-beta.100 → 0.0.1-beta.101

package/dist/index.esm.js

@@ -33,7 +33,7 @@ var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
-import { inject, createVNode, h as h$1, mergeProps, defineComponent, reactive, ref, computed, watch, onMounted, onBeforeUnmount, getCurrentInstance, nextTick, Transition, provide, createTextVNode, withDirectives, vShow, isVNode, Fragment, toRefs, toRef, onUnmounted, Teleport, customRef, onBeforeMount, vModelText, resolveDirective, watchEffect, onUpdated, render, toRaw, withModifiers } from "vue";
+import { inject, createVNode, h as h$1, mergeProps, defineComponent, reactive, ref, computed, watch, onMounted, onBeforeUnmount, getCurrentInstance, nextTick, Transition, provide, createTextVNode, withDirectives, vShow, isVNode, Fragment, toRefs, onUnmounted, Teleport, resolveDirective, customRef, onBeforeMount, toRef, vModelText, watchEffect, onUpdated, render, toRaw, withModifiers } from "vue";
 var reset = "";
 var alert = "";
 var affix = "";
@@ -8923,7 +8923,10 @@ const loadingTypes = {
   theme: PropTypes.theme(["white", "primary", "warning", "success", "danger"]),
   title: PropTypes.string.def(""),
   size: PropTypes.commonType(Object.values(BkLoadingSize)).def(BkLoadingSize.Normal),
-  mode: PropTypes.commonType(Object.values(BkLoadingMode)).def("default")
+  mode: PropTypes.commonType(Object.values(BkLoadingMode)).def("default"),
+  opacity: PropTypes.number.def(0.9),
+  color: PropTypes.string.def("white"),
+  zIndex: PropTypes.number.def(1)
 };
 var Component$z = defineComponent({
   name: "Loading",
@@ -8937,6 +8940,13 @@ var Component$z = defineComponent({
     }, [[1, 2, 3, 4, 5, 6, 7, 8].map((i2) => createVNode("span", {
       "class": `oval oval-${i2}`
     }, null))]);
+    const zIndexStyle = computed(() => ({
+      zIndex: props.zIndex
+    }));
+    const maskStyle = computed(() => __spreadValues({
+      opacity: props.opacity,
+      backgroundColor: props.color
+    }, zIndexStyle.value));
     const loadingWrapperCls = computed(() => classes({
       "bk-loading-wrapper": props.loading,
       "bk-nested-loading": !!ctx.slots.default
@@ -8960,13 +8970,15 @@ var Component$z = defineComponent({
       var _a, _b;
       return createVNode("div", {
         "class": loadingWrapperCls.value
-      }, [props.loading && [createVNode("div", {
-        "class": containerCls.value
+      }, [props.loading && [ctx.slots.default && createVNode("div", {
+        "class": "bk-loading-mask",
+        "style": maskStyle.value
+      }, null), createVNode("div", {
+        "class": containerCls.value,
+        "style": zIndexStyle.value
       }, [indicator.value, hasTitle.value && createVNode("div", {
         "class": "bk-loading-title"
-      }, [props.title])]), ctx.slots.default && createVNode("div", {
-        "class": "bk-loading-mask"
-      }, null)], (_b = (_a = ctx.slots).default) == null ? void 0 : _b.call(_a)]);
+      }, [props.title])])], (_b = (_a = ctx.slots).default) == null ? void 0 : _b.call(_a)]);
     };
   }
 });
@@ -10452,845 +10464,879 @@ var Component$o = defineComponent({
   }
 });
 const BkPopover = withInstall(Component$o);
-var Arrow = defineComponent({
-  name: "PopArrow",
-  render() {
-    const arrowClassName = resolveClassName("pop2-arrow");
-    return createVNode("div", {
-      "class": arrowClassName
-    }, null);
+var _populated = false;
+var _ie, _firefox, _opera, _webkit, _chrome;
+var _ie_real_version;
+var _osx, _windows, _linux, _android;
+var _win64;
+var _iphone, _ipad, _native;
+var _mobile;
+function _populate() {
+  if (_populated) {
+    return;
   }
-});
-var Content = defineComponent({
-  name: "PopContent",
-  props: {
-    width: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).def("auto"),
-    height: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).def("auto")
+  _populated = true;
+  var uas = navigator.userAgent;
+  var agent = /(?:MSIE.(\d+\.\d+))|(?:(?:Firefox|GranParadiso|Iceweasel).(\d+\.\d+))|(?:Opera(?:.+Version.|.)(\d+\.\d+))|(?:AppleWebKit.(\d+(?:\.\d+)?))|(?:Trident\/\d+\.\d+.*rv:(\d+\.\d+))/.exec(uas);
+  var os = /(Mac OS X)|(Windows)|(Linux)/.exec(uas);
+  _iphone = /\b(iPhone|iP[ao]d)/.exec(uas);
+  _ipad = /\b(iP[ao]d)/.exec(uas);
+  _android = /Android/i.exec(uas);
+  _native = /FBAN\/\w+;/i.exec(uas);
+  _mobile = /Mobile/i.exec(uas);
+  _win64 = !!/Win64/.exec(uas);
+  if (agent) {
+    _ie = agent[1] ? parseFloat(agent[1]) : agent[5] ? parseFloat(agent[5]) : NaN;
+    if (_ie && document && document.documentMode) {
+      _ie = document.documentMode;
+    }
+    var trident = /(?:Trident\/(\d+.\d+))/.exec(uas);
+    _ie_real_version = trident ? parseFloat(trident[1]) + 4 : _ie;
+    _firefox = agent[2] ? parseFloat(agent[2]) : NaN;
+    _opera = agent[3] ? parseFloat(agent[3]) : NaN;
+    _webkit = agent[4] ? parseFloat(agent[4]) : NaN;
+    if (_webkit) {
+      agent = /(?:Chrome\/(\d+\.\d+))/.exec(uas);
+      _chrome = agent && agent[1] ? parseFloat(agent[1]) : NaN;
+    } else {
+      _chrome = NaN;
+    }
+  } else {
+    _ie = _firefox = _opera = _chrome = _webkit = NaN;
+  }
+  if (os) {
+    if (os[1]) {
+      var ver = /(?:Mac OS X (\d+(?:[._]\d+)?))/.exec(uas);
+      _osx = ver ? parseFloat(ver[1].replace("_", ".")) : true;
+    } else {
+      _osx = false;
+    }
+    _windows = !!os[2];
+    _linux = !!os[3];
+  } else {
+    _osx = _windows = _linux = false;
+  }
+}
+var UserAgent_DEPRECATED$1 = {
+  ie: function() {
+    return _populate() || _ie;
   },
-  setup(props) {
-    const resolveValToPix = (val) => {
-      if (/^\d+\.?\d*$/.test(`${val}`)) {
-        return `${val}px`;
-      }
-      return val;
-    };
-    const style = computed(() => ({
-      width: resolveValToPix(props.width),
-      height: resolveValToPix(props.height)
-    }));
-    return {
-      style
-    };
+  ieCompatibilityMode: function() {
+    return _populate() || _ie_real_version > _ie;
   },
-  render() {
-    var _a, _b, _c, _d, _e, _f;
-    const className = [resolveClassName("popover2"), resolveClassName("pop2-content")];
-    return createVNode("div", {
-      "class": className,
-      "tabindex": "-1",
-      "style": this.style
-    }, [(_c = (_b = (_a = this.$slots).default) == null ? void 0 : _b.call(_a)) != null ? _c : "", (_f = (_e = (_d = this.$slots).arrow) == null ? void 0 : _e.call(_d)) != null ? _f : ""]);
+  ie64: function() {
+    return UserAgent_DEPRECATED$1.ie() && _win64;
+  },
+  firefox: function() {
+    return _populate() || _firefox;
+  },
+  opera: function() {
+    return _populate() || _opera;
+  },
+  webkit: function() {
+    return _populate() || _webkit;
+  },
+  safari: function() {
+    return UserAgent_DEPRECATED$1.webkit();
+  },
+  chrome: function() {
+    return _populate() || _chrome;
+  },
+  windows: function() {
+    return _populate() || _windows;
+  },
+  osx: function() {
+    return _populate() || _osx;
+  },
+  linux: function() {
+    return _populate() || _linux;
+  },
+  iphone: function() {
+    return _populate() || _iphone;
+  },
+  mobile: function() {
+    return _populate() || (_iphone || _ipad || _android || _mobile);
+  },
+  nativeApp: function() {
+    return _populate() || _native;
+  },
+  android: function() {
+    return _populate() || _android;
+  },
+  ipad: function() {
+    return _populate() || _ipad;
   }
-});
-const placements = ["auto", "auto-start", "auto-end", "top", "top-start", "top-end", "bottom", "bottom-start", "bottom-end", "right", "right-start", "right-end", "left", "left-start", "left-end"];
-const EventProps$1 = {
-  onAfterHidden: Function,
-  onAfterShow: Function
 };
-const PopoverProps = __spreadValues({
-  isShow: PropTypes.bool.def(false),
-  always: PropTypes.bool.def(false),
-  disabled: PropTypes.bool.def(false),
-  width: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).def("auto"),
-  height: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).def("auto"),
-  content: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).def(""),
-  placement: PropTypes.placement(placements).def("top"),
-  theme: PropTypes.string.def("dark"),
-  trigger: PropTypes.string.def("hover"),
-  arrow: PropTypes.bool.def(true),
-  padding: PropTypes.number.def(5),
-  offset: PropTypes.number.def(6),
-  boundary: PropTypes.string.def(void 0),
-  zIndex: PropTypes.number.def(void 0),
-  disableTeleport: PropTypes.bool.def(false),
-  autoPlacement: PropTypes.bool.def(false)
-}, EventProps$1);
-var Reference = defineComponent({
-  name: "PopReference",
-  render() {
-    var _a, _b, _c;
-    return (_c = (_b = (_a = this.$slots).default) == null ? void 0 : _b.call(_a)) != null ? _c : "";
-  }
-});
-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";
+var UserAgent_DEPRECATED_1 = UserAgent_DEPRECATED$1;
+var canUseDOM = !!(typeof window !== "undefined" && window.document && window.document.createElement);
+var ExecutionEnvironment$1 = {
+  canUseDOM,
+  canUseWorkers: typeof Worker !== "undefined",
+  canUseEventListeners: canUseDOM && !!(window.addEventListener || window.attachEvent),
+  canUseViewport: canUseDOM && !!window.screen,
+  isInWorker: !canUseDOM
+};
+var ExecutionEnvironment_1 = ExecutionEnvironment$1;
+var ExecutionEnvironment = ExecutionEnvironment_1;
+var useHasFeature;
+if (ExecutionEnvironment.canUseDOM) {
+  useHasFeature = document.implementation && document.implementation.hasFeature && document.implementation.hasFeature("", "") !== true;
 }
-function computeCoordsFromPlacement(_ref, placement, rtl) {
-  let {
-    reference: reference2,
-    floating
-  } = _ref;
-  const commonX = reference2.x + reference2.width / 2 - floating.width / 2;
-  const commonY = reference2.y + reference2.height / 2 - floating.height / 2;
-  const mainAxis = getMainAxisFromPlacement(placement);
-  const length = getLengthFromAxis(mainAxis);
-  const commonAlign = reference2[length] / 2 - floating[length] / 2;
-  const side = getSide(placement);
-  const isVertical = mainAxis === "x";
-  let coords;
-  switch (side) {
-    case "top":
-      coords = {
-        x: commonX,
-        y: reference2.y - floating.height
-      };
-      break;
-    case "bottom":
-      coords = {
-        x: commonX,
-        y: reference2.y + reference2.height
-      };
-      break;
-    case "right":
-      coords = {
-        x: reference2.x + reference2.width,
-        y: commonY
-      };
-      break;
-    case "left":
-      coords = {
-        x: reference2.x - floating.width,
-        y: commonY
-      };
-      break;
-    default:
-      coords = {
-        x: reference2.x,
-        y: reference2.y
-      };
+/**
+ * Checks if an event is supported in the current execution environment.
+ *
+ * NOTE: This will not work correctly for non-generic events such as `change`,
+ * `reset`, `load`, `error`, and `select`.
+ *
+ * Borrows from Modernizr.
+ *
+ * @param {string} eventNameSuffix Event name, e.g. "click".
+ * @param {?boolean} capture Check if the capture phase is supported.
+ * @return {boolean} True if the event is supported.
+ * @internal
+ * @license Modernizr 3.0.0pre (Custom Build) | MIT
+ */
+function isEventSupported$1(eventNameSuffix, capture) {
+  if (!ExecutionEnvironment.canUseDOM || capture && !("addEventListener" in document)) {
+    return false;
   }
-  switch (getAlignment(placement)) {
-    case "start":
-      coords[mainAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
-      break;
-    case "end":
-      coords[mainAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
-      break;
+  var eventName = "on" + eventNameSuffix;
+  var isSupported = eventName in document;
+  if (!isSupported) {
+    var element = document.createElement("div");
+    element.setAttribute(eventName, "return;");
+    isSupported = typeof element[eventName] === "function";
   }
-  return coords;
+  if (!isSupported && useHasFeature && eventNameSuffix === "wheel") {
+    isSupported = document.implementation.hasFeature("Events.wheel", "3.0");
+  }
+  return isSupported;
 }
-const computePosition$1 = async (reference2, floating, config) => {
-  const {
-    placement = "bottom",
-    strategy = "absolute",
-    middleware = [],
-    platform: platform2
-  } = config;
-  const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(floating));
-  let rects = await platform2.getElementRects({
-    reference: reference2,
-    floating,
-    strategy
-  });
-  let {
-    x: x2,
-    y: y2
-  } = computeCoordsFromPlacement(rects, placement, rtl);
-  let statefulPlacement = placement;
-  let middlewareData = {};
-  for (let i2 = 0; i2 < middleware.length; i2++) {
-    const {
-      name,
-      fn: fn2
-    } = middleware[i2];
-    const {
-      x: nextX,
-      y: nextY,
-      data: data2,
-      reset: reset2
-    } = await fn2({
-      x: x2,
-      y: y2,
-      initialPlacement: placement,
-      placement: statefulPlacement,
-      strategy,
-      middlewareData,
-      rects,
-      platform: platform2,
-      elements: {
-        reference: reference2,
-        floating
-      }
-    });
-    x2 = nextX != null ? nextX : x2;
-    y2 = nextY != null ? nextY : y2;
-    middlewareData = __spreadProps(__spreadValues({}, middlewareData), {
-      [name]: __spreadValues(__spreadValues({}, middlewareData[name]), data2)
-    });
-    if (reset2) {
-      if (typeof reset2 === "object") {
-        if (reset2.placement) {
-          statefulPlacement = reset2.placement;
-        }
-        if (reset2.rects) {
-          rects = reset2.rects === true ? await platform2.getElementRects({
-            reference: reference2,
-            floating,
-            strategy
-          }) : reset2.rects;
-        }
-        ({
-          x: x2,
-          y: y2
-        } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
-      }
-      i2 = -1;
-      continue;
+var isEventSupported_1 = isEventSupported$1;
+var UserAgent_DEPRECATED = UserAgent_DEPRECATED_1;
+var isEventSupported = isEventSupported_1;
+var PIXEL_STEP = 10;
+var LINE_HEIGHT = 40;
+var PAGE_HEIGHT = 800;
+function normalizeWheel$1(event) {
+  var sX = 0, sY = 0, pX = 0, pY = 0;
+  if ("detail" in event) {
+    sY = event.detail;
+  }
+  if ("wheelDelta" in event) {
+    sY = -event.wheelDelta / 120;
+  }
+  if ("wheelDeltaY" in event) {
+    sY = -event.wheelDeltaY / 120;
+  }
+  if ("wheelDeltaX" in event) {
+    sX = -event.wheelDeltaX / 120;
+  }
+  if ("axis" in event && event.axis === event.HORIZONTAL_AXIS) {
+    sX = sY;
+    sY = 0;
+  }
+  pX = sX * PIXEL_STEP;
+  pY = sY * PIXEL_STEP;
+  if ("deltaY" in event) {
+    pY = event.deltaY;
+  }
+  if ("deltaX" in event) {
+    pX = event.deltaX;
+  }
+  if ((pX || pY) && event.deltaMode) {
+    if (event.deltaMode == 1) {
+      pX *= LINE_HEIGHT;
+      pY *= LINE_HEIGHT;
+    } else {
+      pX *= PAGE_HEIGHT;
+      pY *= PAGE_HEIGHT;
     }
   }
+  if (pX && !sX) {
+    sX = pX < 1 ? -1 : 1;
+  }
+  if (pY && !sY) {
+    sY = pY < 1 ? -1 : 1;
+  }
   return {
-    x: x2,
-    y: y2,
-    placement: statefulPlacement,
-    strategy,
-    middlewareData
-  };
-};
-function expandPaddingObject(padding) {
-  return __spreadValues({
-    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
+    spinX: sX,
+    spinY: sY,
+    pixelX: pX,
+    pixelY: pY
   };
 }
-function rectToClientRect(rect) {
-  return __spreadProps(__spreadValues({}, rect), {
-    top: rect.y,
-    left: rect.x,
-    right: rect.x + rect.width,
-    bottom: rect.y + rect.height
-  });
-}
-async function detectOverflow(middlewareArguments, options) {
-  var _await$platform$isEle;
-  if (options === void 0) {
-    options = {};
+normalizeWheel$1.getEventType = function() {
+  return UserAgent_DEPRECATED.firefox() ? "DOMMouseScroll" : isEventSupported("wheel") ? "wheel" : "mousewheel";
+};
+var normalizeWheel_1 = normalizeWheel$1;
+var normalizeWheel = normalizeWheel_1;
+const isFirefox = typeof navigator !== "undefined" && navigator.userAgent.toLowerCase().indexOf("firefox") > -1;
+const mousewheelHandler = function(element, callback) {
+  if (element == null ? void 0 : element.addEventListener) {
+    element.addEventListener(isFirefox ? "DOMMouseScroll" : "mousewheel", function(e) {
+      const normalized = normalizeWheel(e);
+      callback == null ? void 0 : callback.apply(this, [e, normalized]);
+    });
   }
-  const {
-    x: x2,
-    y: y2,
-    platform: platform2,
-    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 platform2.getClippingRect({
-    element: ((_await$platform$isEle = await (platform2.isElement == null ? void 0 : platform2.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || await (platform2.getDocumentElement == null ? void 0 : platform2.getDocumentElement(elements.floating)),
-    boundary,
-    rootBoundary,
-    strategy
-  }));
-  const elementClientRect = rectToClientRect(platform2.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform2.convertOffsetParentRelativeRectToViewportRelativeRect({
-    rect: elementContext === "floating" ? __spreadProps(__spreadValues({}, rects.floating), {
-      x: x2,
-      y: y2
-    }) : rects.reference,
-    offsetParent: await (platform2.getOffsetParent == null ? void 0 : platform2.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 mousewheel = {
+  beforeMount(el, binding) {
+    console.error(el, binding);
+    mousewheelHandler(el, binding.value);
+  }
+};
+const isElement$1 = (e) => {
+  if (typeof Element === "undefined")
+    return false;
+  return e instanceof Element;
+};
+const nodeList = /* @__PURE__ */ new Map();
+let startClick;
+document.addEventListener("mousedown", (e) => startClick = e);
+document.addEventListener("mouseup", (e) => {
+  for (const handlers of nodeList.values()) {
+    for (const { documentHandler } of handlers) {
+      documentHandler(e, startClick);
+    }
+  }
+});
+function createDocumentHandler(el, binding) {
+  let excludes = [];
+  if (Array.isArray(binding.arg)) {
+    excludes = binding.arg;
+  } else if (isElement$1(binding.arg)) {
+    excludes.push(binding.arg);
+  }
+  return function(mouseup, mousedown) {
+    const { popperRef } = binding.instance;
+    const mouseUpTarget = mouseup.target;
+    const mouseDownTarget = mousedown == null ? void 0 : mousedown.target;
+    const isBound = !binding || !binding.instance;
+    const isTargetExists = !mouseUpTarget || !mouseDownTarget;
+    const isContainedByEl = el.contains(mouseUpTarget) || el.contains(mouseDownTarget);
+    const isSelf = el === mouseUpTarget;
+    const isTargetExcluded = excludes.length && excludes.some((item) => item == null ? void 0 : item.contains(mouseUpTarget)) || excludes.length && excludes.includes(mouseDownTarget);
+    const isContainedByPopper = popperRef && (popperRef.contains(mouseUpTarget) || popperRef.contains(mouseDownTarget));
+    if (isBound || isTargetExists || isContainedByEl || isSelf || isTargetExcluded || isContainedByPopper) {
+      return;
+    }
+    binding.value(mouseup, mousedown);
   };
 }
-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));
-}
-const arrow = (options) => ({
-  name: "arrow",
-  options,
-  async fn(middlewareArguments) {
-    const {
-      element,
-      padding = 0
-    } = options != null ? options : {};
-    const {
-      x: x2,
-      y: y2,
-      placement,
-      rects,
-      platform: platform2
-    } = middlewareArguments;
-    if (element == null) {
-      return {};
+const ClickOutside = {
+  beforeMount(el, binding) {
+    if (!nodeList.has(el)) {
+      nodeList.set(el, []);
     }
-    const paddingObject = getSideObjectFromPadding(padding);
-    const coords = {
-      x: x2,
-      y: y2
-    };
-    const axis = getMainAxisFromPlacement(placement);
-    const alignment = getAlignment(placement);
-    const length = getLengthFromAxis(axis);
-    const arrowDimensions = await platform2.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 (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(element));
-    let clientSize = arrowOffsetParent ? axis === "y" ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;
-    if (clientSize === 0) {
-      clientSize = rects.floating[length];
+    nodeList.get(el).push({
+      documentHandler: createDocumentHandler(el, binding),
+      bindingFn: binding.value
+    });
+  },
+  updated(el, binding) {
+    if (!nodeList.has(el)) {
+      nodeList.set(el, []);
     }
-    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(min2, center, max2);
-    const alignmentPadding = alignment === "start" ? paddingObject[minProp] : paddingObject[maxProp];
-    const shouldAddOffset = alignmentPadding > 0 && center !== offset2 && rects.reference[length] <= rects.floating[length];
-    const alignmentOffset = shouldAddOffset ? center < min2 ? min2 - center : max2 - center : 0;
-    return {
-      [axis]: coords[axis] - alignmentOffset,
-      data: {
-        [axis]: offset2,
-        centerOffset: center - offset2
-      }
+    const handlers = nodeList.get(el);
+    const oldHandlerIndex = handlers.findIndex((item) => item.bindingFn === binding.oldValue);
+    const newHandler = {
+      documentHandler: createDocumentHandler(el, binding),
+      bindingFn: binding.value
     };
+    if (oldHandlerIndex >= 0) {
+      handlers.splice(oldHandlerIndex, 1, newHandler);
+    } else {
+      handlers.push(newHandler);
+    }
+  },
+  unmounted(el) {
+    nodeList.delete(el);
   }
-});
-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);
+var popper = "";
+const tooltips = {
+  mounted(el, binding) {
+    const opts = initOptions();
+    if (typeof binding.value === "object") {
+      Object.assign(opts, binding.value);
+    } else {
+      opts.content = binding.value;
+    }
+    const { disabled, arrow: arrow2, theme } = opts;
+    if (disabled) {
+      return;
+    }
+    const popper2 = renderContent(opts.content, arrow2, theme === "light");
+    createPopperInstance(el, popper2, opts);
   }
-  return {
-    main: mainAlignmentSide,
-    cross: getOppositePlacement(mainAlignmentSide)
-  };
-}
-const hash = {
-  start: "end",
-  end: "start"
 };
-function getOppositeAlignmentPlacement(placement) {
-  return placement.replace(/start|end/g, (matched) => hash[matched]);
-}
-const sides = ["top", "right", "bottom", "left"];
-const allPlacements = /* @__PURE__ */ sides.reduce((acc, side) => acc.concat(side, side + "-start", side + "-end"), []);
-function getPlacementList(alignment, autoAlignment, allowedPlacements) {
-  const allowedPlacementsSortedByAlignment = alignment ? [...allowedPlacements.filter((placement) => getAlignment(placement) === alignment), ...allowedPlacements.filter((placement) => getAlignment(placement) !== alignment)] : allowedPlacements.filter((placement) => getSide(placement) === placement);
-  return allowedPlacementsSortedByAlignment.filter((placement) => {
-    if (alignment) {
-      return getAlignment(placement) === alignment || (autoAlignment ? getOppositeAlignmentPlacement(placement) !== placement : false);
+function initOptions() {
+  const defaultOpts = {
+    arrow: true,
+    disabled: false,
+    trigger: "hover",
+    theme: "dark",
+    content: "",
+    showOnInit: false,
+    placement: "top",
+    distance: 8,
+    onShow: () => {
+    },
+    onHide: () => {
     }
-    return true;
-  });
+  };
+  return defaultOpts;
 }
-const autoPlacement = function(options) {
-  if (options === void 0) {
-    options = {};
+function renderContent(value, hasArrow, isLight) {
+  const zIndex = bkZIndexManager.getPopperIndex();
+  const content = document.createElement("div");
+  content.className = `bk-popper ${isLight ? "light" : "dark"}`;
+  content.innerText = value;
+  content.style.zIndex = String(zIndex);
+  if (hasArrow) {
+    const arrow2 = renderArrow();
+    content.appendChild(arrow2);
   }
-  return {
-    name: "autoPlacement",
-    options,
-    async fn(middlewareArguments) {
-      var _middlewareData$autoP, _middlewareData$autoP2, _middlewareData$autoP3, _middlewareData$autoP4, _placementsSortedByLe;
-      const {
-        x: x2,
-        y: y2,
-        rects,
-        middlewareData,
-        placement,
-        platform: platform2,
-        elements
-      } = middlewareArguments;
-      const _a = options, {
-        alignment = null,
-        allowedPlacements = allPlacements,
-        autoAlignment = true
-      } = _a, detectOverflowOptions = __objRest(_a, [
-        "alignment",
-        "allowedPlacements",
-        "autoAlignment"
-      ]);
-      const placements2 = getPlacementList(alignment, autoAlignment, allowedPlacements);
-      const overflow = await detectOverflow(middlewareArguments, detectOverflowOptions);
-      const currentIndex = (_middlewareData$autoP = (_middlewareData$autoP2 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP2.index) != null ? _middlewareData$autoP : 0;
-      const currentPlacement = placements2[currentIndex];
-      if (currentPlacement == null) {
-        return {};
-      }
-      const {
-        main: main2,
-        cross
-      } = getAlignmentSides(currentPlacement, rects, await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating)));
-      if (placement !== currentPlacement) {
-        return {
-          x: x2,
-          y: y2,
-          reset: {
-            placement: placements2[0]
-          }
-        };
+  document.body.appendChild(content);
+  return content;
+}
+function renderArrow() {
+  const arrow2 = document.createElement("div");
+  arrow2.className = "bk-popper-arrow";
+  arrow2.setAttribute("data-popper-arrow", "");
+  return arrow2;
+}
+function createPopperInstance(el, popper2, options) {
+  const { placement, distance, trigger, showOnInit, onShow, onHide } = options;
+  const popperInstance = createPopper(el, popper2, {
+    placement,
+    modifiers: [
+      {
+        name: "offset",
+        options: {
+          offset: [0, distance]
+        }
       }
-      const currentOverflows = [overflow[getSide(currentPlacement)], overflow[main2], overflow[cross]];
-      const allOverflows = [...(_middlewareData$autoP3 = (_middlewareData$autoP4 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP4.overflows) != null ? _middlewareData$autoP3 : [], {
-        placement: currentPlacement,
-        overflows: currentOverflows
-      }];
-      const nextPlacement = placements2[currentIndex + 1];
-      if (nextPlacement) {
-        return {
-          data: {
-            index: currentIndex + 1,
-            overflows: allOverflows
-          },
-          reset: {
-            placement: nextPlacement
-          }
-        };
+    ]
+  });
+  if (trigger === "hover") {
+    const showEvents = ["mouseenter", "focus"];
+    const hideEvents = ["mouseleave", "blur"];
+    showEvents.forEach((event) => {
+      el.addEventListener(event, show);
+    });
+    hideEvents.forEach((event) => {
+      el.addEventListener(event, hide2);
+    });
+  } else if (trigger === "click") {
+    document.body.addEventListener("click", (event) => {
+      if (el.contains(event.target) && !popper2.hasAttribute("data-show")) {
+        show();
+      } else if (popper2.hasAttribute("data-show")) {
+        hide2();
       }
-      const placementsSortedByLeastOverflow = allOverflows.slice().sort((a2, b2) => a2.overflows[0] - b2.overflows[0]);
-      const placementThatFitsOnAllSides = (_placementsSortedByLe = placementsSortedByLeastOverflow.find((_ref) => {
-        let {
-          overflows
-        } = _ref;
-        return overflows.every((overflow2) => overflow2 <= 0);
-      })) == null ? void 0 : _placementsSortedByLe.placement;
-      const resetPlacement = placementThatFitsOnAllSides != null ? placementThatFitsOnAllSides : placementsSortedByLeastOverflow[0].placement;
-      if (resetPlacement !== placement) {
-        return {
-          data: {
-            index: currentIndex + 1,
-            overflows: allOverflows
-          },
-          reset: {
-            placement: resetPlacement
-          }
-        };
-      }
-      return {};
-    }
-  };
-};
-function getExpandedPlacements(placement) {
-  const oppositePlacement = getOppositePlacement(placement);
-  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
+    });
+  }
+  if (showOnInit)
+    show();
+  function show() {
+    popper2.setAttribute("data-show", "");
+    onShow();
+    popperInstance.setOptions((options2) => __spreadProps(__spreadValues({}, options2), {
+      modifiers: [
+        ...options2.modifiers,
+        { name: "eventListeners", enabled: true }
+      ]
+    }));
+    popperInstance.update();
+  }
+  function hide2() {
+    popper2.removeAttribute("data-show");
+    onHide();
+    popperInstance.setOptions((options2) => __spreadProps(__spreadValues({}, options2), {
+      modifiers: [
+        ...options2.modifiers,
+        { name: "eventListeners", enabled: false }
+      ]
+    }));
+  }
 }
-const flip = function(options) {
-  if (options === void 0) {
-    options = {};
+var Arrow = defineComponent({
+  name: "PopArrow",
+  render() {
+    const arrowClassName = resolveClassName("pop2-arrow");
+    return createVNode("div", {
+      "class": arrowClassName
+    }, null);
   }
-  return {
-    name: "flip",
-    options,
-    async fn(middlewareArguments) {
-      var _middlewareData$flip;
-      const {
-        placement,
-        middlewareData,
-        rects,
-        initialPlacement,
-        platform: platform2,
-        elements
-      } = middlewareArguments;
-      const _a = options, {
-        mainAxis: checkMainAxis = true,
-        crossAxis: checkCrossAxis = true,
-        fallbackPlacements: specifiedFallbackPlacements,
-        fallbackStrategy = "bestFit",
-        flipAlignment = true
-      } = _a, detectOverflowOptions = __objRest(_a, [
-        "mainAxis",
-        "crossAxis",
-        "fallbackPlacements",
-        "fallbackStrategy",
-        "flipAlignment"
-      ]);
-      const side = getSide(placement);
-      const isBasePlacement = side === initialPlacement;
-      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
-      const placements2 = [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: main2,
-          cross
-        } = getAlignmentSides(placement, rects, await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating)));
-        overflows.push(overflow[main2], overflow[cross]);
-      }
-      overflowsData = [...overflowsData, {
-        placement,
-        overflows
-      }];
-      if (!overflows.every((side2) => side2 <= 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 = placements2[nextIndex];
-        if (nextPlacement) {
-          return {
-            data: {
-              index: nextIndex,
-              overflows: overflowsData
-            },
-            reset: {
-              placement: nextPlacement
-            }
-          };
-        }
-        let resetPlacement = "bottom";
-        switch (fallbackStrategy) {
-          case "bestFit": {
-            var _overflowsData$map$so;
-            const placement2 = (_overflowsData$map$so = overflowsData.map((d2) => [d2, d2.overflows.filter((overflow2) => overflow2 > 0).reduce((acc, overflow2) => acc + overflow2, 0)]).sort((a2, b2) => a2[1] - b2[1])[0]) == null ? void 0 : _overflowsData$map$so[0].placement;
-            if (placement2) {
-              resetPlacement = placement2;
-            }
-            break;
-          }
-          case "initialPlacement":
-            resetPlacement = initialPlacement;
-            break;
-        }
-        if (placement !== resetPlacement) {
-          return {
-            reset: {
-              placement: resetPlacement
-            }
-          };
-        }
+});
+const EMPTY$2 = (..._args) => true;
+let EMITEVENTS$1;
+(function(EMITEVENTS2) {
+  EMITEVENTS2["SHOW"] = "show";
+  EMITEVENTS2["HIDE"] = "hide";
+  EMITEVENTS2["CLICK_OUTSIDE"] = "clickoutside";
+})(EMITEVENTS$1 || (EMITEVENTS$1 = {}));
+const EMIT_EVENT_TYPES$1 = {
+  [EMITEVENTS$1.SHOW]: EMPTY$2,
+  [EMITEVENTS$1.HIDE]: EMPTY$2,
+  [EMITEVENTS$1.CLICK_OUTSIDE]: EMPTY$2
+};
+var Content = defineComponent({
+  name: "PopContent",
+  props: {
+    width: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).def("auto"),
+    height: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).def("auto")
+  },
+  setup(props) {
+    const resolveValToPix = (val) => {
+      if (/^\d+\.?\d*$/.test(`${val}`)) {
+        return `${val}px`;
       }
-      return {};
-    }
-  };
+      return val;
+    };
+    const style = computed(() => ({
+      width: resolveValToPix(props.width),
+      height: resolveValToPix(props.height)
+    }));
+    return {
+      style
+    };
+  },
+  render() {
+    var _a, _b, _c, _d, _e, _f;
+    const className = [resolveClassName("popover2"), resolveClassName("pop2-content")];
+    return createVNode("div", {
+      "class": className,
+      "tabindex": "-1",
+      "style": this.style
+    }, [(_c = (_b = (_a = this.$slots).default) == null ? void 0 : _b.call(_a)) != null ? _c : "", (_f = (_e = (_d = this.$slots).arrow) == null ? void 0 : _e.call(_d)) != null ? _f : ""]);
+  }
+});
+const placements = ["auto", "auto-start", "auto-end", "top", "top-start", "top-end", "bottom", "bottom-start", "bottom-end", "right", "right-start", "right-end", "left", "left-start", "left-end"];
+const EventProps$1 = {
+  onAfterHidden: Function,
+  onAfterShow: Function
 };
-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
-  };
+const PopoverProps = __spreadValues({
+  isShow: PropTypes.bool.def(false),
+  always: PropTypes.bool.def(false),
+  disabled: PropTypes.bool.def(false),
+  width: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).def("auto"),
+  height: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).def("auto"),
+  content: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).def(""),
+  placement: PropTypes.placement(placements).def("top"),
+  theme: PropTypes.string.def("dark"),
+  trigger: PropTypes.string.def("hover"),
+  arrow: PropTypes.bool.def(true),
+  padding: PropTypes.number.def(5),
+  offset: PropTypes.number.def(6),
+  boundary: PropTypes.string.def(void 0),
+  zIndex: PropTypes.number.def(void 0),
+  disableTeleport: PropTypes.bool.def(false),
+  autoPlacement: PropTypes.bool.def(false),
+  disableOutsideClick: PropTypes.bool.def(false)
+}, EventProps$1);
+var Reference = defineComponent({
+  name: "PopReference",
+  render() {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = this.$slots).default) == null ? void 0 : _b.call(_a)) != null ? _c : "";
+  }
+});
+function getSide(placement) {
+  return placement.split("-")[0];
 }
-function isAnySideFullyClipped(overflow) {
-  return sides.some((side) => overflow[side] >= 0);
+function getAlignment(placement) {
+  return placement.split("-")[1];
 }
-const hide = function(_temp) {
-  let _a = _temp === void 0 ? {} : _temp, {
-    strategy = "referenceHidden"
-  } = _a, detectOverflowOptions = __objRest(_a, [
-    "strategy"
-  ]);
-  return {
-    name: "hide",
-    async fn(middlewareArguments) {
-      const {
-        rects
-      } = middlewareArguments;
-      switch (strategy) {
-        case "referenceHidden": {
-          const overflow = await detectOverflow(middlewareArguments, __spreadProps(__spreadValues({}, detectOverflowOptions), {
-            elementContext: "reference"
-          }));
-          const offsets = getSideOffsets(overflow, rects.reference);
-          return {
-            data: {
-              referenceHiddenOffsets: offsets,
-              referenceHidden: isAnySideFullyClipped(offsets)
-            }
-          };
-        }
-        case "escaped": {
-          const overflow = await detectOverflow(middlewareArguments, __spreadProps(__spreadValues({}, detectOverflowOptions), {
-            altBoundary: true
-          }));
-          const offsets = getSideOffsets(overflow, rects.floating);
-          return {
-            data: {
-              escapedOffsets: offsets,
-              escaped: isAnySideFullyClipped(offsets)
-            }
-          };
-        }
-        default: {
-          return {};
-        }
-      }
-    }
-  };
-};
-async function convertValueToCoords(middlewareArguments, value) {
-  const {
-    placement,
-    platform: platform2,
-    elements
-  } = middlewareArguments;
-  const rtl = await (platform2.isRTL == null ? void 0 : platform2.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;
+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 {
-    mainAxis,
-    crossAxis,
-    alignmentAxis
-  } = typeof rawValue === "number" ? {
-    mainAxis: rawValue,
-    crossAxis: 0,
-    alignmentAxis: null
-  } : __spreadValues({
-    mainAxis: 0,
-    crossAxis: 0,
-    alignmentAxis: null
-  }, rawValue);
-  if (alignment && typeof alignmentAxis === "number") {
-    crossAxis = alignment === "end" ? alignmentAxis * -1 : alignmentAxis;
+    reference: reference2,
+    floating
+  } = _ref;
+  const commonX = reference2.x + reference2.width / 2 - floating.width / 2;
+  const commonY = reference2.y + reference2.height / 2 - floating.height / 2;
+  const mainAxis = getMainAxisFromPlacement(placement);
+  const length = getLengthFromAxis(mainAxis);
+  const commonAlign = reference2[length] / 2 - floating[length] / 2;
+  const side = getSide(placement);
+  const isVertical = mainAxis === "x";
+  let coords;
+  switch (side) {
+    case "top":
+      coords = {
+        x: commonX,
+        y: reference2.y - floating.height
+      };
+      break;
+    case "bottom":
+      coords = {
+        x: commonX,
+        y: reference2.y + reference2.height
+      };
+      break;
+    case "right":
+      coords = {
+        x: reference2.x + reference2.width,
+        y: commonY
+      };
+      break;
+    case "left":
+      coords = {
+        x: reference2.x - floating.width,
+        y: commonY
+      };
+      break;
+    default:
+      coords = {
+        x: reference2.x,
+        y: reference2.y
+      };
   }
-  return isVertical ? {
-    x: crossAxis * crossAxisMulti,
-    y: mainAxis * mainAxisMulti
-  } : {
-    x: mainAxis * mainAxisMulti,
-    y: crossAxis * crossAxisMulti
-  };
+  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 offset = function(value) {
-  if (value === void 0) {
-    value = 0;
+const computePosition$1 = async (reference2, floating, config) => {
+  const {
+    placement = "bottom",
+    strategy = "absolute",
+    middleware = [],
+    platform: platform2
+  } = config;
+  const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(floating));
+  let rects = await platform2.getElementRects({
+    reference: reference2,
+    floating,
+    strategy
+  });
+  let {
+    x: x2,
+    y: y2
+  } = computeCoordsFromPlacement(rects, placement, rtl);
+  let statefulPlacement = placement;
+  let middlewareData = {};
+  for (let i2 = 0; i2 < middleware.length; i2++) {
+    const {
+      name,
+      fn: fn2
+    } = middleware[i2];
+    const {
+      x: nextX,
+      y: nextY,
+      data: data2,
+      reset: reset2
+    } = await fn2({
+      x: x2,
+      y: y2,
+      initialPlacement: placement,
+      placement: statefulPlacement,
+      strategy,
+      middlewareData,
+      rects,
+      platform: platform2,
+      elements: {
+        reference: reference2,
+        floating
+      }
+    });
+    x2 = nextX != null ? nextX : x2;
+    y2 = nextY != null ? nextY : y2;
+    middlewareData = __spreadProps(__spreadValues({}, middlewareData), {
+      [name]: __spreadValues(__spreadValues({}, middlewareData[name]), data2)
+    });
+    if (reset2) {
+      if (typeof reset2 === "object") {
+        if (reset2.placement) {
+          statefulPlacement = reset2.placement;
+        }
+        if (reset2.rects) {
+          rects = reset2.rects === true ? await platform2.getElementRects({
+            reference: reference2,
+            floating,
+            strategy
+          }) : reset2.rects;
+        }
+        ({
+          x: x2,
+          y: y2
+        } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
+      }
+      i2 = -1;
+      continue;
+    }
   }
   return {
-    name: "offset",
-    options: value,
-    async fn(middlewareArguments) {
-      const {
-        x: x2,
-        y: y2
-      } = middlewareArguments;
-      const diffCoords = await convertValueToCoords(middlewareArguments, value);
-      return {
-        x: x2 + diffCoords.x,
-        y: y2 + diffCoords.y,
-        data: diffCoords
-      };
-    }
+    x: x2,
+    y: y2,
+    placement: statefulPlacement,
+    strategy,
+    middlewareData
   };
 };
-function getCrossAxis(axis) {
-  return axis === "x" ? "y" : "x";
+function expandPaddingObject(padding) {
+  return __spreadValues({
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0
+  }, padding);
 }
-const shift = function(options) {
+function getSideObjectFromPadding(padding) {
+  return typeof padding !== "number" ? expandPaddingObject(padding) : {
+    top: padding,
+    right: padding,
+    bottom: padding,
+    left: padding
+  };
+}
+function rectToClientRect(rect) {
+  return __spreadProps(__spreadValues({}, rect), {
+    top: rect.y,
+    left: rect.x,
+    right: rect.x + rect.width,
+    bottom: rect.y + rect.height
+  });
+}
+async function detectOverflow(middlewareArguments, options) {
+  var _await$platform$isEle;
   if (options === void 0) {
     options = {};
   }
+  const {
+    x: x2,
+    y: y2,
+    platform: platform2,
+    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 platform2.getClippingRect({
+    element: ((_await$platform$isEle = await (platform2.isElement == null ? void 0 : platform2.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || await (platform2.getDocumentElement == null ? void 0 : platform2.getDocumentElement(elements.floating)),
+    boundary,
+    rootBoundary,
+    strategy
+  }));
+  const elementClientRect = rectToClientRect(platform2.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform2.convertOffsetParentRelativeRectToViewportRelativeRect({
+    rect: elementContext === "floating" ? __spreadProps(__spreadValues({}, rects.floating), {
+      x: x2,
+      y: y2
+    }) : rects.reference,
+    offsetParent: await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(elements.floating)),
+    strategy
+  }) : rects[elementContext]);
   return {
-    name: "shift",
-    options,
-    async fn(middlewareArguments) {
-      const {
-        x: x2,
-        y: y2,
-        placement
-      } = middlewareArguments;
-      const _a = options, {
-        mainAxis: checkMainAxis = true,
-        crossAxis: checkCrossAxis = false,
-        limiter = {
-          fn: (_ref) => {
-            let {
-              x: x3,
-              y: y3
-            } = _ref;
-            return {
-              x: x3,
-              y: y3
-            };
-          }
-        }
-      } = _a, detectOverflowOptions = __objRest(_a, [
-        "mainAxis",
-        "crossAxis",
-        "limiter"
-      ]);
-      const coords = {
-        x: x2,
-        y: y2
-      };
-      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 min2 = mainAxisCoord + overflow[minSide];
-        const max2 = mainAxisCoord - overflow[maxSide];
-        mainAxisCoord = within(min2, mainAxisCoord, max2);
-      }
-      if (checkCrossAxis) {
-        const minSide = crossAxis === "y" ? "top" : "left";
-        const maxSide = crossAxis === "y" ? "bottom" : "right";
-        const min2 = crossAxisCoord + overflow[minSide];
-        const max2 = crossAxisCoord - overflow[maxSide];
-        crossAxisCoord = within(min2, crossAxisCoord, max2);
-      }
-      const limitedCoords = limiter.fn(__spreadProps(__spreadValues({}, middlewareArguments), {
-        [mainAxis]: mainAxisCoord,
-        [crossAxis]: crossAxisCoord
-      }));
-      return __spreadProps(__spreadValues({}, limitedCoords), {
-        data: {
-          x: limitedCoords.x - x2,
-          y: limitedCoords.y - y2
-        }
-      });
+    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));
+}
+const arrow = (options) => ({
+  name: "arrow",
+  options,
+  async fn(middlewareArguments) {
+    const {
+      element,
+      padding = 0
+    } = options != null ? options : {};
+    const {
+      x: x2,
+      y: y2,
+      placement,
+      rects,
+      platform: platform2
+    } = middlewareArguments;
+    if (element == null) {
+      return {};
+    }
+    const paddingObject = getSideObjectFromPadding(padding);
+    const coords = {
+      x: x2,
+      y: y2
+    };
+    const axis = getMainAxisFromPlacement(placement);
+    const alignment = getAlignment(placement);
+    const length = getLengthFromAxis(axis);
+    const arrowDimensions = await platform2.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 (platform2.getOffsetParent == null ? void 0 : platform2.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;
+    const min2 = paddingObject[minProp];
+    const max2 = clientSize - arrowDimensions[length] - paddingObject[maxProp];
+    const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
+    const offset2 = within(min2, center, max2);
+    const alignmentPadding = alignment === "start" ? paddingObject[minProp] : paddingObject[maxProp];
+    const shouldAddOffset = alignmentPadding > 0 && center !== offset2 && rects.reference[length] <= rects.floating[length];
+    const alignmentOffset = shouldAddOffset ? center < min2 ? min2 - center : max2 - center : 0;
+    return {
+      [axis]: coords[axis] - alignmentOffset,
+      data: {
+        [axis]: offset2,
+        centerOffset: center - offset2
+      }
+    };
+  }
+});
+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"
 };
-const inline = function(options) {
+function getOppositeAlignmentPlacement(placement) {
+  return placement.replace(/start|end/g, (matched) => hash[matched]);
+}
+const sides = ["top", "right", "bottom", "left"];
+const allPlacements = /* @__PURE__ */ sides.reduce((acc, side) => acc.concat(side, side + "-start", side + "-end"), []);
+function getPlacementList(alignment, autoAlignment, allowedPlacements) {
+  const allowedPlacementsSortedByAlignment = alignment ? [...allowedPlacements.filter((placement) => getAlignment(placement) === alignment), ...allowedPlacements.filter((placement) => getAlignment(placement) !== alignment)] : allowedPlacements.filter((placement) => getSide(placement) === placement);
+  return allowedPlacementsSortedByAlignment.filter((placement) => {
+    if (alignment) {
+      return getAlignment(placement) === alignment || (autoAlignment ? getOppositeAlignmentPlacement(placement) !== placement : false);
+    }
+    return true;
+  });
+}
+const autoPlacement = function(options) {
   if (options === void 0) {
     options = {};
   }
   return {
-    name: "inline",
+    name: "autoPlacement",
     options,
     async fn(middlewareArguments) {
-      var _await$platform$getCl;
+      var _middlewareData$autoP, _middlewareData$autoP2, _middlewareData$autoP3, _middlewareData$autoP4, _placementsSortedByLe;
       const {
-        placement,
-        elements,
+        x: x2,
+        y: y2,
         rects,
+        middlewareData,
+        placement,
         platform: platform2,
-        strategy
+        elements
       } = middlewareArguments;
-      const {
-        padding = 2,
-        x: x2,
-        y: y2
-      } = options;
-      const fallback = rectToClientRect(platform2.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform2.convertOffsetParentRelativeRectToViewportRelativeRect({
-        rect: rects.reference,
-        offsetParent: await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(elements.floating)),
-        strategy
-      }) : rects.reference);
-      const clientRects = (_await$platform$getCl = await (platform2.getClientRects == null ? void 0 : platform2.getClientRects(elements.reference))) != null ? _await$platform$getCl : [];
-      const paddingObject = getSideObjectFromPadding(padding);
-      function getBoundingClientRect2() {
-        if (clientRects.length === 2 && clientRects[0].left > clientRects[1].right && x2 != null && y2 != null) {
-          var _clientRects$find;
-          return (_clientRects$find = clientRects.find((rect) => x2 > rect.left - paddingObject.left && x2 < rect.right + paddingObject.right && y2 > rect.top - paddingObject.top && y2 < rect.bottom + paddingObject.bottom)) != null ? _clientRects$find : fallback;
-        }
-        if (clientRects.length >= 2) {
-          if (getMainAxisFromPlacement(placement) === "x") {
-            const firstRect = clientRects[0];
-            const lastRect = clientRects[clientRects.length - 1];
-            const isTop = getSide(placement) === "top";
-            const top3 = firstRect.top;
-            const bottom3 = lastRect.bottom;
-            const left3 = isTop ? firstRect.left : lastRect.left;
-            const right3 = isTop ? firstRect.right : lastRect.right;
-            const width2 = right3 - left3;
-            const height2 = bottom3 - top3;
-            return {
-              top: top3,
-              bottom: bottom3,
-              left: left3,
-              right: right3,
-              width: width2,
-              height: height2,
-              x: left3,
-              y: top3
-            };
-          }
-          const isLeftSide = getSide(placement) === "left";
-          const maxRight = max$1(...clientRects.map((rect) => rect.right));
-          const minLeft = min$1(...clientRects.map((rect) => rect.left));
-          const measureRects = clientRects.filter((rect) => isLeftSide ? rect.left === minLeft : rect.right === maxRight);
-          const top2 = measureRects[0].top;
-          const bottom2 = measureRects[measureRects.length - 1].bottom;
-          const left2 = minLeft;
-          const right2 = maxRight;
-          const width = right2 - left2;
-          const height = bottom2 - top2;
-          return {
-            top: top2,
-            bottom: bottom2,
-            left: left2,
-            right: right2,
-            width,
-            height,
-            x: left2,
-            y: top2
-          };
-        }
-        return fallback;
+      const _a = options, {
+        alignment = null,
+        allowedPlacements = allPlacements,
+        autoAlignment = true
+      } = _a, detectOverflowOptions = __objRest(_a, [
+        "alignment",
+        "allowedPlacements",
+        "autoAlignment"
+      ]);
+      const placements2 = getPlacementList(alignment, autoAlignment, allowedPlacements);
+      const overflow = await detectOverflow(middlewareArguments, detectOverflowOptions);
+      const currentIndex = (_middlewareData$autoP = (_middlewareData$autoP2 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP2.index) != null ? _middlewareData$autoP : 0;
+      const currentPlacement = placements2[currentIndex];
+      if (currentPlacement == null) {
+        return {};
       }
-      const resetRects = await platform2.getElementRects({
-        reference: {
-          getBoundingClientRect: getBoundingClientRect2
-        },
-        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) {
+      const {
+        main: main2,
+        cross
+      } = getAlignmentSides(currentPlacement, rects, await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating)));
+      if (placement !== currentPlacement) {
         return {
+          x: x2,
+          y: y2,
           reset: {
-            rects: resetRects
+            placement: placements2[0]
+          }
+        };
+      }
+      const currentOverflows = [overflow[getSide(currentPlacement)], overflow[main2], overflow[cross]];
+      const allOverflows = [...(_middlewareData$autoP3 = (_middlewareData$autoP4 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP4.overflows) != null ? _middlewareData$autoP3 : [], {
+        placement: currentPlacement,
+        overflows: currentOverflows
+      }];
+      const nextPlacement = placements2[currentIndex + 1];
+      if (nextPlacement) {
+        return {
+          data: {
+            index: currentIndex + 1,
+            overflows: allOverflows
+          },
+          reset: {
+            placement: nextPlacement
+          }
+        };
+      }
+      const placementsSortedByLeastOverflow = allOverflows.slice().sort((a2, b2) => a2.overflows[0] - b2.overflows[0]);
+      const placementThatFitsOnAllSides = (_placementsSortedByLe = placementsSortedByLeastOverflow.find((_ref) => {
+        let {
+          overflows
+        } = _ref;
+        return overflows.every((overflow2) => overflow2 <= 0);
+      })) == null ? void 0 : _placementsSortedByLe.placement;
+      const resetPlacement = placementThatFitsOnAllSides != null ? placementThatFitsOnAllSides : placementsSortedByLeastOverflow[0].placement;
+      if (resetPlacement !== placement) {
+        return {
+          data: {
+            index: currentIndex + 1,
+            overflows: allOverflows
+          },
+          reset: {
+            placement: resetPlacement
           }
         };
       }
@@ -11298,734 +11344,1146 @@ const inline = function(options) {
     }
   };
 };
-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$1(value) {
-  return value instanceof getWindow(value).Element;
-}
-function isNode(value) {
-  return value instanceof getWindow(value).Node;
-}
-function isShadowRoot(node) {
-  if (typeof ShadowRoot === "undefined") {
-    return false;
-  }
-  const OwnElement = getWindow(node).ShadowRoot;
-  return node instanceof OwnElement || node instanceof ShadowRoot;
-}
-function isOverflowElement(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));
-}
-function isContainingBlock(element) {
-  const isFirefox2 = /firefox/i.test(getUAString());
-  const css = getComputedStyle$1(element);
-  return css.transform !== "none" || css.perspective !== "none" || css.contain === "paint" || ["transform", "perspective"].includes(css.willChange) || isFirefox2 && css.willChange === "filter" || isFirefox2 && (css.filter ? css.filter !== "none" : false);
-}
-function isLayoutViewport() {
-  return !/^((?!chrome|android).)*safari/i.test(getUAString());
+function getExpandedPlacements(placement) {
+  const oppositePlacement = getOppositePlacement(placement);
+  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
 }
-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 flip = function(options) {
+  if (options === void 0) {
+    options = {};
   }
-  const win = isElement$1(element) ? getWindow(element) : window;
-  const addVisualOffsets = !isLayoutViewport() && isFixedStrategy;
-  const x2 = (clientRect.left + (addVisualOffsets ? (_win$visualViewport$o = (_win$visualViewport = win.visualViewport) == null ? void 0 : _win$visualViewport.offsetLeft) != null ? _win$visualViewport$o : 0 : 0)) / scaleX;
-  const y2 = (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: y2,
-    right: x2 + width,
-    bottom: y2 + height,
-    left: x2,
-    x: x2,
-    y: y2
+    name: "flip",
+    options,
+    async fn(middlewareArguments) {
+      var _middlewareData$flip;
+      const {
+        placement,
+        middlewareData,
+        rects,
+        initialPlacement,
+        platform: platform2,
+        elements
+      } = middlewareArguments;
+      const _a = options, {
+        mainAxis: checkMainAxis = true,
+        crossAxis: checkCrossAxis = true,
+        fallbackPlacements: specifiedFallbackPlacements,
+        fallbackStrategy = "bestFit",
+        flipAlignment = true
+      } = _a, detectOverflowOptions = __objRest(_a, [
+        "mainAxis",
+        "crossAxis",
+        "fallbackPlacements",
+        "fallbackStrategy",
+        "flipAlignment"
+      ]);
+      const side = getSide(placement);
+      const isBasePlacement = side === initialPlacement;
+      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
+      const placements2 = [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: main2,
+          cross
+        } = getAlignmentSides(placement, rects, await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating)));
+        overflows.push(overflow[main2], overflow[cross]);
+      }
+      overflowsData = [...overflowsData, {
+        placement,
+        overflows
+      }];
+      if (!overflows.every((side2) => side2 <= 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 = placements2[nextIndex];
+        if (nextPlacement) {
+          return {
+            data: {
+              index: nextIndex,
+              overflows: overflowsData
+            },
+            reset: {
+              placement: nextPlacement
+            }
+          };
+        }
+        let resetPlacement = "bottom";
+        switch (fallbackStrategy) {
+          case "bestFit": {
+            var _overflowsData$map$so;
+            const placement2 = (_overflowsData$map$so = overflowsData.map((d2) => [d2, d2.overflows.filter((overflow2) => overflow2 > 0).reduce((acc, overflow2) => acc + overflow2, 0)]).sort((a2, b2) => a2[1] - b2[1])[0]) == null ? void 0 : _overflowsData$map$so[0].placement;
+            if (placement2) {
+              resetPlacement = placement2;
+            }
+            break;
+          }
+          case "initialPlacement":
+            resetPlacement = initialPlacement;
+            break;
+        }
+        if (placement !== resetPlacement) {
+          return {
+            reset: {
+              placement: resetPlacement
+            }
+          };
+        }
+      }
+      return {};
+    }
   };
-}
-function getDocumentElement(node) {
-  return ((isNode(node) ? node.ownerDocument : node.document) || window.document).documentElement;
-}
-function getNodeScroll(element) {
-  if (isElement$1(element)) {
-    return {
-      scrollLeft: element.scrollLeft,
-      scrollTop: element.scrollTop
-    };
-  }
+};
+function getSideOffsets(overflow, rect) {
   return {
-    scrollLeft: element.pageXOffset,
-    scrollTop: element.pageYOffset
+    top: overflow.top - rect.height,
+    right: overflow.right - rect.width,
+    bottom: overflow.bottom - rect.height,
+    left: overflow.left - rect.width
   };
 }
-function getWindowScrollBarX(element) {
-  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 isAnySideFullyClipped(overflow) {
+  return sides.some((side) => overflow[side] >= 0);
 }
-function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
-  const isOffsetParentAnElement = isHTMLElement(offsetParent);
-  const documentElement = getDocumentElement(offsetParent);
-  const rect = getBoundingClientRect(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(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);
-    }
-  }
+const hide = function(_temp) {
+  let _a = _temp === void 0 ? {} : _temp, {
+    strategy = "referenceHidden"
+  } = _a, detectOverflowOptions = __objRest(_a, [
+    "strategy"
+  ]);
   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 node.assignedSlot || node.parentNode || (isShadowRoot(node) ? node.host : null) || getDocumentElement(node);
-}
-function getTrueOffsetParent(element) {
-  if (!isHTMLElement(element) || getComputedStyle(element).position === "fixed") {
-    return null;
-  }
-  return element.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 {
-      currentNode = currentNode.parentNode;
+    name: "hide",
+    async fn(middlewareArguments) {
+      const {
+        rects
+      } = middlewareArguments;
+      switch (strategy) {
+        case "referenceHidden": {
+          const overflow = await detectOverflow(middlewareArguments, __spreadProps(__spreadValues({}, detectOverflowOptions), {
+            elementContext: "reference"
+          }));
+          const offsets = getSideOffsets(overflow, rects.reference);
+          return {
+            data: {
+              referenceHiddenOffsets: offsets,
+              referenceHidden: isAnySideFullyClipped(offsets)
+            }
+          };
+        }
+        case "escaped": {
+          const overflow = await detectOverflow(middlewareArguments, __spreadProps(__spreadValues({}, detectOverflowOptions), {
+            altBoundary: true
+          }));
+          const offsets = getSideOffsets(overflow, rects.floating);
+          return {
+            data: {
+              escapedOffsets: offsets,
+              escaped: isAnySideFullyClipped(offsets)
+            }
+          };
+        }
+        default: {
+          return {};
+        }
+      }
     }
-  }
-  return null;
-}
-function getOffsetParent(element) {
-  const window2 = getWindow(element);
-  let offsetParent = getTrueOffsetParent(element);
-  while (offsetParent && isTableElement(offsetParent) && getComputedStyle(offsetParent).position === "static") {
-    offsetParent = getTrueOffsetParent(offsetParent);
-  }
-  if (offsetParent && (getNodeName(offsetParent) === "html" || getNodeName(offsetParent) === "body" && getComputedStyle(offsetParent).position === "static" && !isContainingBlock(offsetParent))) {
-    return window2;
-  }
-  return offsetParent || getContainingBlock(element) || window2;
-}
-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) {
+};
+async function convertValueToCoords(middlewareArguments, value) {
+  const {
+    placement,
+    platform: platform2,
+    elements
+  } = middlewareArguments;
+  const rtl = await (platform2.isRTL == null ? void 0 : platform2.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;
   let {
-    rect,
-    offsetParent,
-    strategy
-  } = _ref;
-  const isOffsetParentAnElement = isHTMLElement(offsetParent);
-  const documentElement = getDocumentElement(offsetParent);
-  if (offsetParent === documentElement) {
-    return rect;
+    mainAxis,
+    crossAxis,
+    alignmentAxis
+  } = typeof rawValue === "number" ? {
+    mainAxis: rawValue,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : __spreadValues({
+    mainAxis: 0,
+    crossAxis: 0,
+    alignmentAxis: null
+  }, rawValue);
+  if (alignment && typeof alignmentAxis === "number") {
+    crossAxis = alignment === "end" ? alignmentAxis * -1 : alignmentAxis;
   }
-  let scroll = {
-    scrollLeft: 0,
-    scrollTop: 0
-  };
-  const offsets = {
-    x: 0,
-    y: 0
+  return isVertical ? {
+    x: crossAxis * crossAxisMulti,
+    y: mainAxis * mainAxisMulti
+  } : {
+    x: mainAxis * mainAxisMulti,
+    y: crossAxis * crossAxisMulti
   };
-  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;
-    }
-  }
-  return __spreadProps(__spreadValues({}, 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 x2 = 0;
-  let y2 = 0;
-  if (visualViewport) {
-    width = visualViewport.width;
-    height = visualViewport.height;
-    const layoutViewport = isLayoutViewport();
-    if (layoutViewport || !layoutViewport && strategy === "fixed") {
-      x2 = visualViewport.offsetLeft;
-      y2 = visualViewport.offsetTop;
-    }
+const offset = function(value) {
+  if (value === void 0) {
+    value = 0;
   }
   return {
-    width,
-    height,
-    x: x2,
-    y: y2
+    name: "offset",
+    options: value,
+    async fn(middlewareArguments) {
+      const {
+        x: x2,
+        y: y2
+      } = middlewareArguments;
+      const diffCoords = await convertValueToCoords(middlewareArguments, value);
+      return {
+        x: x2 + diffCoords.x,
+        y: y2 + diffCoords.y,
+        data: diffCoords
+      };
+    }
   };
+};
+function getCrossAxis(axis) {
+  return axis === "x" ? "y" : "x";
 }
-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 x2 = -scroll.scrollLeft + getWindowScrollBarX(element);
-  const y2 = -scroll.scrollTop;
-  if (getComputedStyle$1(body || html).direction === "rtl") {
-    x2 += max(html.clientWidth, body ? body.clientWidth : 0) - width;
+const shift = function(options) {
+  if (options === void 0) {
+    options = {};
   }
   return {
-    width,
-    height,
-    x: x2,
-    y: y2
-  };
-}
-function getNearestOverflowAncestor(node) {
-  const parentNode = getParentNode(node);
-  if (["html", "body", "#document"].includes(getNodeName(parentNode))) {
-    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 : updatedList.concat(getOverflowAncestors(target));
-}
-function contains(parent, child) {
-  const rootNode = child.getRootNode == null ? void 0 : child.getRootNode();
-  if (parent.contains(child)) {
-    return true;
-  } else if (rootNode && isShadowRoot(rootNode)) {
-    let next = child;
-    do {
-      if (next && parent === next) {
-        return true;
+    name: "shift",
+    options,
+    async fn(middlewareArguments) {
+      const {
+        x: x2,
+        y: y2,
+        placement
+      } = middlewareArguments;
+      const _a = options, {
+        mainAxis: checkMainAxis = true,
+        crossAxis: checkCrossAxis = false,
+        limiter = {
+          fn: (_ref) => {
+            let {
+              x: x3,
+              y: y3
+            } = _ref;
+            return {
+              x: x3,
+              y: y3
+            };
+          }
+        }
+      } = _a, detectOverflowOptions = __objRest(_a, [
+        "mainAxis",
+        "crossAxis",
+        "limiter"
+      ]);
+      const coords = {
+        x: x2,
+        y: y2
+      };
+      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 min2 = mainAxisCoord + overflow[minSide];
+        const max2 = mainAxisCoord - overflow[maxSide];
+        mainAxisCoord = within(min2, mainAxisCoord, max2);
       }
-      next = next.parentNode || next.host;
-    } while (next);
+      if (checkCrossAxis) {
+        const minSide = crossAxis === "y" ? "top" : "left";
+        const maxSide = crossAxis === "y" ? "bottom" : "right";
+        const min2 = crossAxisCoord + overflow[minSide];
+        const max2 = crossAxisCoord - overflow[maxSide];
+        crossAxisCoord = within(min2, crossAxisCoord, max2);
+      }
+      const limitedCoords = limiter.fn(__spreadProps(__spreadValues({}, middlewareArguments), {
+        [mainAxis]: mainAxisCoord,
+        [crossAxis]: crossAxisCoord
+      }));
+      return __spreadProps(__spreadValues({}, limitedCoords), {
+        data: {
+          x: limitedCoords.x - x2,
+          y: limitedCoords.y - y2
+        }
+      });
+    }
+  };
+};
+const inline = function(options) {
+  if (options === void 0) {
+    options = {};
   }
-  return false;
-}
-function getInnerBoundingClientRect(element, strategy) {
-  const clientRect = getBoundingClientRect(element, false, strategy === "fixed");
-  const top2 = clientRect.top + element.clientTop;
-  const left2 = clientRect.left + element.clientLeft;
   return {
-    top: top2,
-    left: left2,
-    x: left2,
-    y: top2,
-    right: left2 + element.clientWidth,
-    bottom: top2 + element.clientHeight,
-    width: element.clientWidth,
-    height: element.clientHeight
+    name: "inline",
+    options,
+    async fn(middlewareArguments) {
+      var _await$platform$getCl;
+      const {
+        placement,
+        elements,
+        rects,
+        platform: platform2,
+        strategy
+      } = middlewareArguments;
+      const {
+        padding = 2,
+        x: x2,
+        y: y2
+      } = options;
+      const fallback = rectToClientRect(platform2.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform2.convertOffsetParentRelativeRectToViewportRelativeRect({
+        rect: rects.reference,
+        offsetParent: await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(elements.floating)),
+        strategy
+      }) : rects.reference);
+      const clientRects = (_await$platform$getCl = await (platform2.getClientRects == null ? void 0 : platform2.getClientRects(elements.reference))) != null ? _await$platform$getCl : [];
+      const paddingObject = getSideObjectFromPadding(padding);
+      function getBoundingClientRect2() {
+        if (clientRects.length === 2 && clientRects[0].left > clientRects[1].right && x2 != null && y2 != null) {
+          var _clientRects$find;
+          return (_clientRects$find = clientRects.find((rect) => x2 > rect.left - paddingObject.left && x2 < rect.right + paddingObject.right && y2 > rect.top - paddingObject.top && y2 < rect.bottom + paddingObject.bottom)) != null ? _clientRects$find : fallback;
+        }
+        if (clientRects.length >= 2) {
+          if (getMainAxisFromPlacement(placement) === "x") {
+            const firstRect = clientRects[0];
+            const lastRect = clientRects[clientRects.length - 1];
+            const isTop = getSide(placement) === "top";
+            const top3 = firstRect.top;
+            const bottom3 = lastRect.bottom;
+            const left3 = isTop ? firstRect.left : lastRect.left;
+            const right3 = isTop ? firstRect.right : lastRect.right;
+            const width2 = right3 - left3;
+            const height2 = bottom3 - top3;
+            return {
+              top: top3,
+              bottom: bottom3,
+              left: left3,
+              right: right3,
+              width: width2,
+              height: height2,
+              x: left3,
+              y: top3
+            };
+          }
+          const isLeftSide = getSide(placement) === "left";
+          const maxRight = max$1(...clientRects.map((rect) => rect.right));
+          const minLeft = min$1(...clientRects.map((rect) => rect.left));
+          const measureRects = clientRects.filter((rect) => isLeftSide ? rect.left === minLeft : rect.right === maxRight);
+          const top2 = measureRects[0].top;
+          const bottom2 = measureRects[measureRects.length - 1].bottom;
+          const left2 = minLeft;
+          const right2 = maxRight;
+          const width = right2 - left2;
+          const height = bottom2 - top2;
+          return {
+            top: top2,
+            bottom: bottom2,
+            left: left2,
+            right: right2,
+            width,
+            height,
+            x: left2,
+            y: top2
+          };
+        }
+        return fallback;
+      }
+      const resetRects = await platform2.getElementRects({
+        reference: {
+          getBoundingClientRect: getBoundingClientRect2
+        },
+        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 {};
+    }
   };
+};
+function isWindow(value) {
+  return value && value.document && value.location && value.alert && value.setInterval;
 }
-function getClientRectFromClippingAncestor(element, clippingParent, strategy) {
-  if (clippingParent === "viewport") {
-    return rectToClientRect(getViewportRect(element, strategy));
+function getWindow(node) {
+  if (node == null) {
+    return window;
   }
-  if (isElement$1(clippingParent)) {
-    return getInnerBoundingClientRect(clippingParent, strategy);
+  if (!isWindow(node)) {
+    const ownerDocument = node.ownerDocument;
+    return ownerDocument ? ownerDocument.defaultView || window : window;
   }
-  return rectToClientRect(getDocumentRect(getDocumentElement(element)));
+  return node;
 }
-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$1(clipperElement)) {
-    return [];
-  }
-  return clippingAncestors.filter((clippingAncestors2) => isElement$1(clippingAncestors2) && contains(clippingAncestors2, clipperElement) && getNodeName(clippingAncestors2) !== "body");
+function getComputedStyle$1(element) {
+  return getWindow(element).getComputedStyle(element);
 }
-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
-  };
+function getNodeName(node) {
+  return isWindow(node) ? "" : node ? (node.nodeName || "").toLowerCase() : "";
 }
-const platform = {
-  getClippingRect,
-  convertOffsetParentRelativeRectToViewportRelativeRect,
-  isElement: isElement$1,
-  getDimensions,
-  getOffsetParent,
-  getDocumentElement,
-  getElementRects: (_ref) => {
-    let {
-      reference: reference2,
-      floating,
-      strategy
-    } = _ref;
-    return {
-      reference: getRectRelativeToOffsetParent(reference2, getOffsetParent(floating), strategy),
-      floating: __spreadProps(__spreadValues({}, getDimensions(floating)), {
-        x: 0,
-        y: 0
-      })
-    };
-  },
-  getClientRects: (element) => Array.from(element.getClientRects()),
-  isRTL: (element) => getComputedStyle$1(element).direction === "rtl"
-};
-function autoUpdate(reference2, floating, update, options) {
-  if (options === void 0) {
-    options = {};
+function getUAString() {
+  const uaData = navigator.userAgentData;
+  if (uaData != null && uaData.brands) {
+    return uaData.brands.map((item) => item.brand + "/" + item.version).join(" ");
   }
-  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$1(reference2) ? getOverflowAncestors(reference2) : [], ...getOverflowAncestors(floating)] : [];
-  ancestors.forEach((ancestor) => {
-    ancestorScroll && ancestor.addEventListener("scroll", update, {
-      passive: true
-    });
-    ancestorResize && ancestor.addEventListener("resize", update);
-  });
-  let observer = null;
-  if (elementResize) {
-    observer = new ResizeObserver(update);
-    isElement$1(reference2) && !animationFrame && observer.observe(reference2);
-    observer.observe(floating);
+  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) {
+  if (typeof ShadowRoot === "undefined") {
+    return false;
   }
-  let frameId;
-  let prevRefRect = animationFrame ? getBoundingClientRect(reference2) : null;
-  if (animationFrame) {
-    frameLoop();
+  const OwnElement = getWindow(node).ShadowRoot;
+  return node instanceof OwnElement || node instanceof ShadowRoot;
+}
+function isOverflowElement(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));
+}
+function isContainingBlock(element) {
+  const isFirefox2 = /firefox/i.test(getUAString());
+  const css = getComputedStyle$1(element);
+  return css.transform !== "none" || css.perspective !== "none" || css.contain === "paint" || ["transform", "perspective"].includes(css.willChange) || isFirefox2 && css.willChange === "filter" || isFirefox2 && (css.filter ? css.filter !== "none" : false);
+}
+function isLayoutViewport() {
+  return !/^((?!chrome|android).)*safari/i.test(getUAString());
+}
+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;
   }
-  function frameLoop() {
-    const nextRefRect = getBoundingClientRect(reference2);
-    if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) {
-      update();
-    }
-    prevRefRect = nextRefRect;
-    frameId = requestAnimationFrame(frameLoop);
+  if (isFixedStrategy === void 0) {
+    isFixedStrategy = false;
   }
-  if (!elementResize) {
-    update();
+  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;
   }
-  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);
-    }
+  const win = isElement(element) ? getWindow(element) : window;
+  const addVisualOffsets = !isLayoutViewport() && isFixedStrategy;
+  const x2 = (clientRect.left + (addVisualOffsets ? (_win$visualViewport$o = (_win$visualViewport = win.visualViewport) == null ? void 0 : _win$visualViewport.offsetLeft) != null ? _win$visualViewport$o : 0 : 0)) / scaleX;
+  const y2 = (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: y2,
+    right: x2 + width,
+    bottom: y2 + height,
+    left: x2,
+    x: x2,
+    y: y2
   };
 }
-const computePosition = (reference2, floating, options) => computePosition$1(reference2, floating, __spreadValues({
-  platform
-}, options));
-var useFloating = (props, ctx, refReference, refContent, refArrow) => {
-  const localIsShow = ref(props.isShow);
-  const themeList = ["dark", "light"];
-  const compTheme = computed(() => {
-    const themes = props.theme.split(/\s+/);
-    themes.sort((a2, b2) => Number(themeList.includes(b2)) - Number(themeList.includes(a2)));
-    const systemThemes = themes;
-    const customThemes = themes.filter((item) => !themeList.includes(item));
-    return {
-      systemThemes,
-      customThemes
-    };
-  });
-  const resolvePopElements = () => {
-    var _a, _b, _c;
-    const elReference = resolveTargetElement((_a = refReference.value) == null ? void 0 : _a.$el);
-    const elContent = resolveTargetElement((_b = refContent.value) == null ? void 0 : _b.$el);
-    const elArrow = props.arrow ? resolveTargetElement((_c = refArrow.value) == null ? void 0 : _c.$el) : null;
+function getDocumentElement(node) {
+  return ((isNode(node) ? node.ownerDocument : node.document) || window.document).documentElement;
+}
+function getNodeScroll(element) {
+  if (isElement(element)) {
     return {
-      elReference,
-      elContent,
-      elArrow
+      scrollLeft: element.scrollLeft,
+      scrollTop: element.scrollTop
     };
+  }
+  return {
+    scrollLeft: element.pageXOffset,
+    scrollTop: element.pageYOffset
   };
-  const resolvePopOptions = (elArrow) => ({
-    placement: props.placement,
-    middleware: [inline(), offset(props.offset), props.autoPlacement ? autoPlacement() : flip(), shift({
-      padding: props.padding
-    }), arrow({
-      element: elArrow
-    }), hide()]
-  });
-  const resolveTargetElement = (target) => {
-    if (target instanceof HTMLElement) {
-      return target;
+}
+function getWindowScrollBarX(element) {
+  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, 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 (target instanceof Text) {
-      return resolveTargetElement(target.nextElementSibling);
+    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 node.assignedSlot || node.parentNode || (isShadowRoot(node) ? node.host : null) || getDocumentElement(node);
+}
+function getTrueOffsetParent(element) {
+  if (!isHTMLElement(element) || getComputedStyle(element).position === "fixed") {
     return null;
+  }
+  return element.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 {
+      currentNode = currentNode.parentNode;
+    }
+  }
+  return null;
+}
+function getOffsetParent(element) {
+  const window2 = getWindow(element);
+  let offsetParent = getTrueOffsetParent(element);
+  while (offsetParent && isTableElement(offsetParent) && getComputedStyle(offsetParent).position === "static") {
+    offsetParent = getTrueOffsetParent(offsetParent);
+  }
+  if (offsetParent && (getNodeName(offsetParent) === "html" || getNodeName(offsetParent) === "body" && getComputedStyle(offsetParent).position === "static" && !isContainingBlock(offsetParent))) {
+    return window2;
+  }
+  return offsetParent || getContainingBlock(element) || window2;
+}
+function getDimensions(element) {
+  if (isHTMLElement(element)) {
+    return {
+      width: element.offsetWidth,
+      height: element.offsetHeight
+    };
+  }
+  const rect = getBoundingClientRect(element);
+  return {
+    width: rect.width,
+    height: rect.height
   };
-  const customThemeCls = compTheme.value.customThemes.join(" ");
-  const customTheme = compTheme.value.customThemes.reduce((out, cur) => __spreadValues({
-    [`data-${cur}-theme`]: true
-  }, out), {});
-  const contentClass = `${customThemeCls}`;
-  let cleanup = null;
-  const updatePopover = () => {
-    const {
-      elReference,
-      elContent,
-      elArrow
-    } = resolvePopElements();
-    const options = resolvePopOptions(elArrow);
-    cleanup = autoUpdate(elReference, elContent, () => {
-      computePosition(elReference, elContent, options).then(({
-        x: x2,
-        y: y2,
-        placement,
-        middlewareData
-      }) => {
-        const oldClass = elContent.className;
-        elContent.className = `${oldClass.replace(contentClass, "")} ${contentClass}`.replace(/\s+/mg, " ").replace(/^\s+|\s+$/g, "");
-        Object.keys(customTheme).forEach((key) => {
-          elContent.setAttribute(key, customTheme[key]);
-        });
-        const {
-          referenceHidden
-        } = middlewareData.hide;
-        Object.assign(elContent.style, {
-          left: `${x2}px`,
-          top: `${y2}px`,
-          visibility: referenceHidden ? "hidden" : "visible"
-        });
-        if (props.arrow) {
-          const {
-            x: arrowX,
-            y: arrowY
-          } = middlewareData.arrow;
-          const placementStr = placement.split("-")[0];
-          const staticSide = {
-            top: "bottom",
-            right: "left",
-            bottom: "top",
-            left: "right"
-          }[placementStr];
-          elArrow.setAttribute("data-arrow", placementStr);
-          Object.assign(elArrow.style, {
-            left: isNumber(arrowX) ? `${arrowX}px` : "",
-            top: isNumber(arrowY) ? `${arrowY}px` : "",
-            right: "",
-            bottom: "",
-            [staticSide]: "-4px"
-          });
-        }
-      });
-    });
-  };
-  const isNumber = (val) => /^-?\d+\.?\d*$/.test(`${val}`);
-  const showPopover = () => {
-    var _a;
-    const elContent = resolveTargetElement((_a = refContent.value) == null ? void 0 : _a.$el);
-    elContent.style.setProperty("display", "block");
-    elContent.style.setProperty("z-index", `${props.zIndex ? props.zIndex : bkZIndexManager.getModalNextIndex()}`);
-    updatePopover();
-    ctx.emit("update:isShow", true);
-    ctx.emit("afterShow", false);
+}
+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 hidePopover = () => {
-    var _a;
-    const elContent = resolveTargetElement((_a = refContent.value) == null ? void 0 : _a.$el);
-    elContent.style.setProperty("display", "none");
-    ctx.emit("update:isShow", false);
-    ctx.emit("afterHidden", false);
+  const offsets = {
+    x: 0,
+    y: 0
   };
-  const triggerPopover = () => {
-    if (!localIsShow.value) {
-      showPopover();
-    } else {
-      hidePopover();
+  if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== "fixed") {
+    if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
+      scroll = getNodeScroll(offsetParent);
     }
-    localIsShow.value = !localIsShow.value;
-  };
-  const resolveTriggerEvents = () => {
-    var _a;
-    const triggerEvents = {
-      hover: [["mouseenter", showPopover], ["mouseleave", hidePopover], ["focus", showPopover], ["blur", hidePopover]],
-      click: [["click", triggerPopover]],
-      manual: [[]]
-    };
-    return (_a = triggerEvents[props.trigger]) != null ? _a : [];
+    if (isHTMLElement(offsetParent)) {
+      const offsetRect = getBoundingClientRect(offsetParent, true);
+      offsets.x = offsetRect.x + offsetParent.clientLeft;
+      offsets.y = offsetRect.y + offsetParent.clientTop;
+    }
+  }
+  return __spreadProps(__spreadValues({}, 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 x2 = 0;
+  let y2 = 0;
+  if (visualViewport) {
+    width = visualViewport.width;
+    height = visualViewport.height;
+    const layoutViewport = isLayoutViewport();
+    if (layoutViewport || !layoutViewport && strategy === "fixed") {
+      x2 = visualViewport.offsetLeft;
+      y2 = visualViewport.offsetTop;
+    }
+  }
+  return {
+    width,
+    height,
+    x: x2,
+    y: y2
   };
+}
+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 x2 = -scroll.scrollLeft + getWindowScrollBarX(element);
+  const y2 = -scroll.scrollTop;
+  if (getComputedStyle$1(body || html).direction === "rtl") {
+    x2 += max(html.clientWidth, body ? body.clientWidth : 0) - width;
+  }
   return {
-    showPopover,
-    hidePopover,
-    resolveTriggerEvents,
-    updatePopover,
-    triggerPopover,
-    resolvePopElements,
-    localIsShow,
-    cleanup
+    width,
+    height,
+    x: x2,
+    y: y2
   };
-};
-let popContainerId = null;
-var usePopperId = (prefix = "#") => {
-  const getPrefixId = () => `${prefix}${popContainerId}`;
-  const isAvaiableId = () => {
-    const container2 = document.querySelector(getPrefixId());
-    return container2 instanceof HTMLElement;
+}
+function getNearestOverflowAncestor(node) {
+  const parentNode = getParentNode(node);
+  if (["html", "body", "#document"].includes(getNodeName(parentNode))) {
+    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 : updatedList.concat(getOverflowAncestors(target));
+}
+function contains(parent, child) {
+  const rootNode = child.getRootNode == null ? void 0 : child.getRootNode();
+  if (parent.contains(child)) {
+    return true;
+  } else if (rootNode && isShadowRoot(rootNode)) {
+    let next = child;
+    do {
+      if (next && parent === next) {
+        return true;
+      }
+      next = next.parentNode || next.host;
+    } while (next);
+  }
+  return false;
+}
+function getInnerBoundingClientRect(element, strategy) {
+  const clientRect = getBoundingClientRect(element, false, strategy === "fixed");
+  const top2 = clientRect.top + element.clientTop;
+  const left2 = clientRect.left + element.clientLeft;
+  return {
+    top: top2,
+    left: left2,
+    x: left2,
+    y: top2,
+    right: left2 + element.clientWidth,
+    bottom: top2 + element.clientHeight,
+    width: element.clientWidth,
+    height: element.clientHeight
   };
-  if (popContainerId === null || !isAvaiableId()) {
-    popContainerId = `id_${uuid_1.v4()}`;
-    const popContainer = document.createElement("div");
-    popContainer.setAttribute("id", popContainerId);
-    popContainer.setAttribute("data-popper-id", popContainerId);
-    document.body.append(popContainer);
+}
+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)));
+}
+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 [];
   }
+  return clippingAncestors.filter((clippingAncestors2) => isElement(clippingAncestors2) && contains(clippingAncestors2, clipperElement) && getNodeName(clippingAncestors2) !== "body");
+}
+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 {
-    popContainerId,
-    prefixId: getPrefixId()
+    width: clippingRect.right - clippingRect.left,
+    height: clippingRect.bottom - clippingRect.top,
+    x: clippingRect.left,
+    y: clippingRect.top
   };
-};
-var Component$n = defineComponent({
-  name: "Popover2",
-  components: {
-    Content,
-    Arrow
-  },
-  props: PopoverProps,
-  setup(props, ctx) {
-    const {
-      content,
-      theme,
-      disableTeleport,
-      width,
-      height
-    } = props;
-    const refIsShow = toRef(props, "isShow");
-    const refReference = ref();
-    const refContent = ref();
-    const refArrow = ref();
-    let storeEvents = null;
-    const {
-      localIsShow,
-      showPopover,
-      triggerPopover,
-      resolveTriggerEvents,
-      updatePopover,
-      resolvePopElements,
-      cleanup
-    } = useFloating(props, ctx, refReference, refContent, refArrow);
-    const show = () => {
-      localIsShow.value = true;
-      triggerPopover();
-    };
-    const hide2 = () => {
-      localIsShow.value = false;
-      triggerPopover();
-    };
-    const createPopInstance = () => {
-      updatePopover();
-      if (props.always) {
-        showPopover();
-      } else {
-        addEventToReferenceEl();
-      }
+}
+const platform = {
+  getClippingRect,
+  convertOffsetParentRelativeRectToViewportRelativeRect,
+  isElement,
+  getDimensions,
+  getOffsetParent,
+  getDocumentElement,
+  getElementRects: (_ref) => {
+    let {
+      reference: reference2,
+      floating,
+      strategy
+    } = _ref;
+    return {
+      reference: getRectRelativeToOffsetParent(reference2, getOffsetParent(floating), strategy),
+      floating: __spreadProps(__spreadValues({}, getDimensions(floating)), {
+        x: 0,
+        y: 0
+      })
     };
-    if (!props.always && !props.disabled) {
-      watch([refIsShow], () => {
-        localIsShow.value = props.isShow;
-        triggerPopover();
-      });
+  },
+  getClientRects: (element) => Array.from(element.getClientRects()),
+  isRTL: (element) => getComputedStyle$1(element).direction === "rtl"
+};
+function autoUpdate(reference2, 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(reference2) ? getOverflowAncestors(reference2) : [], ...getOverflowAncestors(floating)] : [];
+  ancestors.forEach((ancestor) => {
+    ancestorScroll && ancestor.addEventListener("scroll", update, {
+      passive: true
+    });
+    ancestorResize && ancestor.addEventListener("resize", update);
+  });
+  let observer = null;
+  if (elementResize) {
+    observer = new ResizeObserver(update);
+    isElement(reference2) && !animationFrame && observer.observe(reference2);
+    observer.observe(floating);
+  }
+  let frameId;
+  let prevRefRect = animationFrame ? getBoundingClientRect(reference2) : null;
+  if (animationFrame) {
+    frameLoop();
+  }
+  function frameLoop() {
+    const nextRefRect = getBoundingClientRect(reference2);
+    if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) {
+      update();
     }
-    watch(() => [props.disabled], (val) => {
-      if (val[0]) {
-        createPopInstance();
-      } else {
-        beforeInstanceUnmount();
-      }
+    prevRefRect = nextRefRect;
+    frameId = requestAnimationFrame(frameLoop);
+  }
+  if (!elementResize) {
+    update();
+  }
+  return () => {
+    var _observer;
+    ancestors.forEach((ancestor) => {
+      ancestorScroll && ancestor.removeEventListener("scroll", update);
+      ancestorResize && ancestor.removeEventListener("resize", update);
     });
-    const addEventToReferenceEl = () => {
-      const {
-        elReference
-      } = resolvePopElements();
-      storeEvents = resolveTriggerEvents();
-      storeEvents.forEach(([event, listener]) => {
-        elReference.addEventListener(event, listener);
-      });
+    (_observer = observer) == null ? void 0 : _observer.disconnect();
+    observer = null;
+    if (animationFrame) {
+      cancelAnimationFrame(frameId);
+    }
+  };
+}
+const computePosition = (reference2, floating, options) => computePosition$1(reference2, floating, __spreadValues({
+  platform
+}, options));
+var useFloating = (props, ctx, refReference, refContent, refArrow) => {
+  const localIsShow = ref(false);
+  const themeList = ["dark", "light"];
+  const compTheme = computed(() => {
+    const themes = props.theme.split(/\s+/);
+    themes.sort((a2, b2) => Number(themeList.includes(b2)) - Number(themeList.includes(a2)));
+    const systemThemes = themes;
+    const customThemes = themes.filter((item) => !themeList.includes(item));
+    return {
+      systemThemes,
+      customThemes
     };
-    const removeEventListener2 = () => {
-      if (storeEvents == null ? void 0 : storeEvents.length) {
+  });
+  const resolvePopElements = () => {
+    var _a, _b, _c;
+    const elReference = resolveTargetElement((_a = refReference.value) == null ? void 0 : _a.$el);
+    const elContent = resolveTargetElement((_b = refContent.value) == null ? void 0 : _b.$el);
+    const elArrow = props.arrow ? resolveTargetElement((_c = refArrow.value) == null ? void 0 : _c.$el) : null;
+    return {
+      elReference,
+      elContent,
+      elArrow
+    };
+  };
+  const resolvePopOptions = (elArrow) => ({
+    placement: props.placement,
+    middleware: [inline(), offset(props.offset), props.autoPlacement ? autoPlacement() : flip(), shift({
+      padding: props.padding
+    }), arrow({
+      element: elArrow
+    }), hide()]
+  });
+  const resolveTargetElement = (target) => {
+    if (target instanceof HTMLElement) {
+      return target;
+    }
+    if (target instanceof Text) {
+      return resolveTargetElement(target.nextElementSibling);
+    }
+    return null;
+  };
+  const customThemeCls = compTheme.value.customThemes.join(" ");
+  const customTheme = compTheme.value.customThemes.reduce((out, cur) => __spreadValues({
+    [`data-${cur}-theme`]: true
+  }, out), {});
+  const contentClass = `${customThemeCls}`;
+  let cleanup = null;
+  const updatePopover = () => {
+    const {
+      elReference,
+      elContent,
+      elArrow
+    } = resolvePopElements();
+    const options = resolvePopOptions(elArrow);
+    cleanup = autoUpdate(elReference, elContent, () => {
+      computePosition(elReference, elContent, options).then(({
+        x: x2,
+        y: y2,
+        placement,
+        middlewareData
+      }) => {
+        const oldClass = elContent.className;
+        elContent.className = `${oldClass.replace(contentClass, "")} ${contentClass}`.replace(/\s+/mg, " ").replace(/^\s+|\s+$/g, "");
+        Object.keys(customTheme).forEach((key) => {
+          elContent.setAttribute(key, customTheme[key]);
+        });
         const {
-          elReference
-        } = resolvePopElements();
-        if (elReference) {
-          storeEvents.forEach(([event, listener]) => {
-            elReference.removeEventListener(event, listener);
+          referenceHidden
+        } = middlewareData.hide;
+        Object.assign(elContent.style, {
+          left: `${x2}px`,
+          top: `${y2}px`,
+          visibility: referenceHidden ? "hidden" : "visible"
+        });
+        if (props.arrow) {
+          const {
+            x: arrowX,
+            y: arrowY
+          } = middlewareData.arrow;
+          const placementStr = placement.split("-")[0];
+          const staticSide = {
+            top: "bottom",
+            right: "left",
+            bottom: "top",
+            left: "right"
+          }[placementStr];
+          elArrow.setAttribute("data-arrow", placementStr);
+          Object.assign(elArrow.style, {
+            left: isNumber(arrowX) ? `${arrowX}px` : "",
+            top: isNumber(arrowY) ? `${arrowY}px` : "",
+            right: "",
+            bottom: "",
+            [staticSide]: "-4px"
           });
         }
-        storeEvents = null;
-      }
-    };
-    const beforeInstanceUnmount = () => {
-      if (typeof cleanup === "function") {
-        cleanup();
-      }
-      removeEventListener2();
-    };
-    onMounted(() => {
-      if (props.disabled) {
-        return;
-      }
-      createPopInstance();
+      });
     });
-    onUnmounted(() => {
-      beforeInstanceUnmount();
+  };
+  const isNumber = (val) => /^-?\d+\.?\d*$/.test(`${val}`);
+  const showPopover = () => {
+    localIsShow.value = true;
+  };
+  const hidePopover = () => {
+    localIsShow.value = false;
+  };
+  const hanldePopoverShow = () => {
+    var _a;
+    const elContent = resolveTargetElement((_a = refContent.value) == null ? void 0 : _a.$el);
+    elContent.style.setProperty("display", "block");
+    elContent.style.setProperty("z-index", `${props.zIndex ? props.zIndex : bkZIndexManager.getModalNextIndex()}`);
+    updatePopover();
+    ctx.emit("afterShow", {
+      isSHow: true
     });
-    ctx.expose({
-      show,
-      hide: hide2
+  };
+  const handlePopoverHide = () => {
+    var _a;
+    const elContent = resolveTargetElement((_a = refContent.value) == null ? void 0 : _a.$el);
+    elContent.style.setProperty("display", "none");
+    ctx.emit("afterHidden", {
+      isSHow: false
     });
-    const {
-      prefixId
-    } = usePopperId();
-    const boundary = typeof props.boundary === "string" ? props.boundary : prefixId;
-    return {
-      boundary,
-      arrow: props.arrow,
-      refReference,
-      refContent,
-      refArrow,
+  };
+  const triggerPopover = () => {
+    if (!localIsShow.value) {
+      showPopover();
+    } else {
+      hidePopover();
+    }
+  };
+  const hanldeClickRef = (e) => {
+    e.stopImmediatePropagation();
+    e.stopPropagation();
+    e.preventDefault();
+    triggerPopover();
+  };
+  const resolveTriggerEvents = () => {
+    var _a;
+    const triggerEvents = {
+      hover: [["mouseenter", showPopover], ["mouseleave", hidePopover], ["focus", showPopover], ["blur", hidePopover]],
+      click: [["click", hanldeClickRef]],
+      manual: [[]]
+    };
+    return (_a = triggerEvents[props.trigger]) != null ? _a : [];
+  };
+  watch(localIsShow, (val) => {
+    if (val) {
+      hanldePopoverShow();
+    } else {
+      handlePopoverHide();
+    }
+  });
+  return {
+    showPopover,
+    hidePopover,
+    resolveTriggerEvents,
+    updatePopover,
+    triggerPopover,
+    resolvePopElements,
+    localIsShow,
+    cleanup
+  };
+};
+let popContainerId = null;
+var usePopperId = (prefix = "#") => {
+  const getPrefixId = () => `${prefix}${popContainerId}`;
+  const isAvaiableId = () => {
+    const container2 = document.querySelector(getPrefixId());
+    return container2 instanceof HTMLElement;
+  };
+  if (popContainerId === null || !isAvaiableId()) {
+    popContainerId = `id_${uuid_1.v4()}`;
+    const popContainer = document.createElement("div");
+    popContainer.setAttribute("id", popContainerId);
+    popContainer.setAttribute("data-popper-id", popContainerId);
+    document.body.append(popContainer);
+  }
+  return {
+    popContainerId,
+    prefixId: getPrefixId()
+  };
+};
+var Component$n = defineComponent({
+  name: "Popover2",
+  components: {
+    Content,
+    Arrow
+  },
+  directives: {
+    clickoutside: ClickOutside
+  },
+  props: PopoverProps,
+  emits: EMIT_EVENT_TYPES$1,
+  setup(props, ctx) {
+    const {
       content,
       theme,
       disableTeleport,
       width,
       height
+    } = props;
+    const refReference = ref();
+    const refContent = ref();
+    const refArrow = ref();
+    let storeEvents = null;
+    const {
+      localIsShow,
+      showPopover,
+      hidePopover,
+      resolveTriggerEvents,
+      updatePopover,
+      resolvePopElements,
+      cleanup
+    } = useFloating(props, ctx, refReference, refContent, refArrow);
+    const show = () => {
+      showPopover();
+    };
+    const hide2 = () => {
+      hidePopover();
+    };
+    const createPopInstance = () => {
+      updatePopover();
+      if (props.always) {
+        showPopover();
+      } else {
+        addEventToReferenceEl();
+      }
+    };
+    if (!props.always && !props.disabled) {
+      watch(() => props.isShow, () => {
+        props.isShow ? showPopover() : hidePopover();
+      }, {
+        immediate: true
+      });
+    }
+    watch(() => [props.disabled], (val) => {
+      if (val[0]) {
+        createPopInstance();
+      } else {
+        beforeInstanceUnmount();
+      }
+    });
+    const addEventToReferenceEl = () => {
+      const {
+        elReference
+      } = resolvePopElements();
+      storeEvents = resolveTriggerEvents();
+      storeEvents.forEach(([event, listener]) => {
+        elReference.addEventListener(event, listener);
+      });
+    };
+    const removeEventListener2 = () => {
+      if (storeEvents == null ? void 0 : storeEvents.length) {
+        const {
+          elReference
+        } = resolvePopElements();
+        if (elReference) {
+          storeEvents.forEach(([event, listener]) => {
+            elReference.removeEventListener(event, listener);
+          });
+        }
+        storeEvents = null;
+      }
+    };
+    const beforeInstanceUnmount = () => {
+      if (typeof cleanup === "function") {
+        cleanup();
+      }
+      removeEventListener2();
+    };
+    onMounted(() => {
+      if (props.disabled) {
+        return;
+      }
+      createPopInstance();
+    });
+    onUnmounted(() => {
+      beforeInstanceUnmount();
+    });
+    ctx.expose({
+      show,
+      hide: hide2
+    });
+    const {
+      prefixId
+    } = usePopperId();
+    const boundary = typeof props.boundary === "string" ? props.boundary : prefixId;
+    const handleClickOutside = (_e) => {
+      console.log("handleClickOutside", localIsShow.value);
+      ctx.emit(EMITEVENTS$1.CLICK_OUTSIDE, {
+        isShow: localIsShow.value
+      });
+      if (props.disableOutsideClick || props.always || props.disabled || props.trigger === "manual") {
+        return;
+      }
+      if (localIsShow.value) {
+        hide2();
+      }
+    };
+    return {
+      boundary,
+      arrow: props.arrow,
+      refReference,
+      refContent,
+      refArrow,
+      content,
+      theme,
+      disableTeleport,
+      width,
+      height,
+      handleClickOutside
     };
   },
   render() {
@@ -12040,7 +12498,7 @@ var Component$n = defineComponent({
       "to": this.boundary,
       "disabled": this.disableTeleport
     }, {
-      default: () => [createVNode(Content, {
+      default: () => [withDirectives(createVNode(Content, {
         "ref": "refContent",
         "data-theme": this.theme,
         "width": this.width,
@@ -12058,7 +12516,7 @@ var Component$n = defineComponent({
             return [(_b = (_a = this.$slots).arrow) == null ? void 0 : _b.call(_a)];
           }
         }) : ""
-      })]
+      }), [[resolveDirective("clickoutside"), this.handleClickOutside]])]
     })]);
   }
 });
@@ -12795,691 +13253,293 @@ var Component$j = defineComponent({
       return createVNode("h3", {
         "class": "bk-swiper-card",
         "style": computedSwiperRenderStyle.value
-      }, [(_b = (_a = slots.default) == null ? void 0 : _a.call(slots, renderData)) != null ? _b : createVNode("span", {
-        "class": getRenderItemClass(renderData),
-        "style": getRenderItemStyle(renderData),
-        "onClick": () => goToLink(renderData.link)
-      }, null)]);
-    })]), createVNode("ul", {
-      "class": "bk-swiper-index"
-    }, [computedRenderDataList.value.map((_2, index) => createVNode("li", {
-      "class": getRenderIndexStyle(index),
-      "onMouseover": () => changeIndex(index)
-    }, null))]), createVNode("span", {
-      "class": "bk-swiper-nav bk-nav-prev",
-      "onClick": () => changeIndex(swiperIndex.value - 1)
-    }, [createVNode("i", {
-      "class": "bk-swiper-nav-icon"
-    }, null)]), createVNode("span", {
-      "class": "bk-swiper-nav bk-nav-next",
-      "onClick": () => changeIndex(swiperIndex.value + 1)
-    }, [createVNode("i", {
-      "class": "bk-swiper-nav-icon"
-    }, null)])]);
-  }
-});
-const BkSwiper = withInstall(Component$j);
-const selectKey = Symbol("BkSelect");
-const optionGroupKey = Symbol("BkOptionGroup");
-function useFocus() {
-  const isFocus = ref(false);
-  const handleFocus = () => {
-    isFocus.value = true;
-  };
-  const handleBlur = () => {
-    isFocus.value = false;
-  };
-  return {
-    isFocus,
-    handleFocus,
-    handleBlur
-  };
-}
-function useHover() {
-  const isHover = ref(false);
-  const setHover = () => {
-    isHover.value = true;
-  };
-  const cancelHover = () => {
-    isHover.value = false;
-  };
-  return {
-    isHover,
-    setHover,
-    cancelHover
-  };
-}
-function useRegistry(data2) {
-  const register = (item) => {
-    if (!item || data2.value.find((d2) => d2 === item))
-      return;
-    return data2.value.push(item);
-  };
-  const unregister = (item) => {
-    const index = data2.value.findIndex((d2) => d2 === item);
-    if (index > -1) {
-      data2.value.splice(index, 1);
-    }
-  };
-  return {
-    register,
-    unregister
-  };
-}
-function useDebouncedRef(value, delay = 200) {
-  let timeout;
-  let innerValue = value;
-  return customRef((track, trigger) => ({
-    get() {
-      track();
-      return innerValue;
-    },
-    set(newValue) {
-      clearTimeout(timeout);
-      if (newValue === void 0 || newValue === "") {
-        innerValue = newValue;
-        trigger();
-      } else {
-        timeout = setTimeout(() => {
-          innerValue = newValue;
-          trigger();
-        }, delay);
-      }
-    }
-  }));
-}
-function usePopover(config) {
-  const { popoverMinWidth } = config;
-  const popperWidth = ref("auto");
-  const isPopoverShow = ref(false);
-  const onPopoverFirstUpdate = (instance) => {
-    const { reference: reference2 } = instance.elements;
-    popperWidth.value = Math.max(reference2.offsetWidth, popoverMinWidth);
-  };
-  const togglePopover = () => {
-    isPopoverShow.value = !isPopoverShow.value;
-  };
-  const hidePopover = () => {
-    isPopoverShow.value = false;
-  };
-  const showPopover = () => {
-    isPopoverShow.value = true;
-  };
-  return {
-    isPopoverShow,
-    popperWidth,
-    togglePopover,
-    onPopoverFirstUpdate,
-    hidePopover,
-    showPopover
-  };
-}
-function useRemoteSearch(method, callBack) {
-  const searchKey = useDebouncedRef("");
-  const searchLoading = ref(false);
-  watch(searchKey, async () => {
-    try {
-      searchLoading.value = true;
-      await method(searchKey.value);
-      searchLoading.value = false;
-    } catch (err) {
-      console.error(err);
-    } finally {
-      callBack == null ? void 0 : callBack();
-    }
-  });
-  return {
-    searchKey,
-    searchLoading
-  };
-}
-function toLowerCase(value = "") {
-  if (!value)
-    return value;
-  return String(value).trim().toLowerCase();
-}
-var BkOption = defineComponent({
-  name: "Option",
-  props: {
-    value: PropTypes.any,
-    label: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
-    disabled: PropTypes.bool.def(false)
-  },
-  setup(props) {
-    const {
-      proxy
-    } = getCurrentInstance();
-    const states = reactive({
-      visible: true
-    });
-    const {
-      disabled,
-      value
-    } = toRefs(props);
-    const select2 = inject(selectKey, null);
-    const group = inject(optionGroupKey, null);
-    const selected = computed(() => {
-      var _a;
-      return (_a = select2 == null ? void 0 : select2.selected) == null ? void 0 : _a.some((data2) => data2.value === value.value);
-    });
-    const multiple = computed(() => select2 == null ? void 0 : select2.multiple);
-    const isHover = computed(() => (select2 == null ? void 0 : select2.activeOptionValue) === value.value);
-    const handleOptionClick = () => {
-      if (disabled.value)
-        return;
-      select2 == null ? void 0 : select2.handleOptionSelected(proxy);
-    };
-    const handleMouseEnter = () => {
-      select2.activeOptionValue = value.value;
-    };
-    onBeforeMount(() => {
-      select2 == null ? void 0 : select2.register(proxy);
-      group == null ? void 0 : group.register(proxy);
-    });
-    onBeforeUnmount(() => {
-      select2 == null ? void 0 : select2.unregister(proxy);
-      group == null ? void 0 : group.unregister(proxy);
-    });
-    return __spreadProps(__spreadValues({}, toRefs(states)), {
-      selected,
-      multiple,
-      isHover,
-      handleOptionClick,
-      handleMouseEnter
-    });
-  },
-  render() {
-    var _a, _b, _c;
-    const selectItemClass = classes({
-      "is-selected": this.selected,
-      "is-disabled": this.disabled,
-      "is-multiple": this.multiple,
-      "is-hover": this.isHover,
-      "bk-select-option": true
-    });
-    return withDirectives(createVNode("li", {
-      "class": selectItemClass,
-      "onClick": this.handleOptionClick,
-      "onMouseenter": this.handleMouseEnter
-    }, [(_c = (_b = (_a = this.$slots).default) == null ? void 0 : _b.call(_a)) != null ? _c : createVNode("span", null, [this.label])]), [[vShow, this.visible]]);
-  }
-});
-var OptionGroup = defineComponent({
-  name: "Group",
-  props: {
-    label: PropTypes.string.def(""),
-    disabled: PropTypes.bool.def(false),
-    collapsible: PropTypes.bool.def(false),
-    collapse: PropTypes.bool.def(false)
-  },
-  setup(props, {
-    emit
-  }) {
-    const {
-      proxy
-    } = getCurrentInstance();
-    const select2 = inject(selectKey, null);
-    const states = reactive({
-      groupCollapse: props.collapse,
-      visible: true
-    });
-    const options = ref([]);
-    const {
-      register,
-      unregister
-    } = useRegistry(options);
-    const groupLabel = computed(() => `${props.label} (${[...options.value.values()].filter((option) => option.visible).length})`);
-    const handleToggleCollapse = () => {
-      if (!props.collapsible || props.disabled)
-        return;
-      states.groupCollapse = !states.groupCollapse;
-      emit("update:collapse", states.groupCollapse);
-    };
-    provide(optionGroupKey, reactive(__spreadProps(__spreadValues({}, toRefs(props)), {
-      register,
-      unregister,
-      groupCollapse: toRef(states, "groupCollapse")
-    })));
-    onBeforeMount(() => {
-      select2 == null ? void 0 : select2.registerGroup(proxy);
-    });
-    onBeforeUnmount(() => {
-      select2 == null ? void 0 : select2.unregisterGroup(proxy);
-    });
-    return __spreadProps(__spreadValues({}, toRefs(states)), {
-      groupLabel,
-      handleToggleCollapse
-    });
-  },
-  render() {
-    var _a, _b;
-    const groupClass = classes({
-      "bk-option-group": true,
-      collapsible: this.collapsible,
-      disabled: this.disabled
-    });
-    const groupLabelClass = classes({
-      "bk-option-group-label": true,
-      collapsible: this.collapsible
-    });
-    const groupLabelIconClass = classes({
-      "default-group-label-icon": true,
-      collapse: this.groupCollapse
-    });
-    return withDirectives(createVNode("ul", {
-      "class": groupClass
-    }, [createVNode("li", {
-      "class": groupLabelClass,
-      "onClick": this.handleToggleCollapse
-    }, [this.$slots.label ? this.$slots.label() : createVNode("span", {
-      "class": "default-group-label"
-    }, [this.collapsible && createVNode(angleUpFill, {
-      "class": groupLabelIconClass
-    }, null), createVNode("span", {
-      "class": "default-group-label-title"
-    }, [this.groupLabel])])]), withDirectives(createVNode("ul", {
-      "class": "bk-option-group-content"
-    }, [(_b = (_a = this.$slots).default) == null ? void 0 : _b.call(_a)]), [[vShow, !this.groupCollapse]])]), [[vShow, this.visible]]);
-  }
-});
-var _populated = false;
-var _ie, _firefox, _opera, _webkit, _chrome;
-var _ie_real_version;
-var _osx, _windows, _linux, _android;
-var _win64;
-var _iphone, _ipad, _native;
-var _mobile;
-function _populate() {
-  if (_populated) {
-    return;
-  }
-  _populated = true;
-  var uas = navigator.userAgent;
-  var agent = /(?:MSIE.(\d+\.\d+))|(?:(?:Firefox|GranParadiso|Iceweasel).(\d+\.\d+))|(?:Opera(?:.+Version.|.)(\d+\.\d+))|(?:AppleWebKit.(\d+(?:\.\d+)?))|(?:Trident\/\d+\.\d+.*rv:(\d+\.\d+))/.exec(uas);
-  var os = /(Mac OS X)|(Windows)|(Linux)/.exec(uas);
-  _iphone = /\b(iPhone|iP[ao]d)/.exec(uas);
-  _ipad = /\b(iP[ao]d)/.exec(uas);
-  _android = /Android/i.exec(uas);
-  _native = /FBAN\/\w+;/i.exec(uas);
-  _mobile = /Mobile/i.exec(uas);
-  _win64 = !!/Win64/.exec(uas);
-  if (agent) {
-    _ie = agent[1] ? parseFloat(agent[1]) : agent[5] ? parseFloat(agent[5]) : NaN;
-    if (_ie && document && document.documentMode) {
-      _ie = document.documentMode;
-    }
-    var trident = /(?:Trident\/(\d+.\d+))/.exec(uas);
-    _ie_real_version = trident ? parseFloat(trident[1]) + 4 : _ie;
-    _firefox = agent[2] ? parseFloat(agent[2]) : NaN;
-    _opera = agent[3] ? parseFloat(agent[3]) : NaN;
-    _webkit = agent[4] ? parseFloat(agent[4]) : NaN;
-    if (_webkit) {
-      agent = /(?:Chrome\/(\d+\.\d+))/.exec(uas);
-      _chrome = agent && agent[1] ? parseFloat(agent[1]) : NaN;
-    } else {
-      _chrome = NaN;
-    }
-  } else {
-    _ie = _firefox = _opera = _chrome = _webkit = NaN;
-  }
-  if (os) {
-    if (os[1]) {
-      var ver = /(?:Mac OS X (\d+(?:[._]\d+)?))/.exec(uas);
-      _osx = ver ? parseFloat(ver[1].replace("_", ".")) : true;
-    } else {
-      _osx = false;
-    }
-    _windows = !!os[2];
-    _linux = !!os[3];
-  } else {
-    _osx = _windows = _linux = false;
-  }
-}
-var UserAgent_DEPRECATED$1 = {
-  ie: function() {
-    return _populate() || _ie;
-  },
-  ieCompatibilityMode: function() {
-    return _populate() || _ie_real_version > _ie;
-  },
-  ie64: function() {
-    return UserAgent_DEPRECATED$1.ie() && _win64;
-  },
-  firefox: function() {
-    return _populate() || _firefox;
-  },
-  opera: function() {
-    return _populate() || _opera;
-  },
-  webkit: function() {
-    return _populate() || _webkit;
-  },
-  safari: function() {
-    return UserAgent_DEPRECATED$1.webkit();
-  },
-  chrome: function() {
-    return _populate() || _chrome;
-  },
-  windows: function() {
-    return _populate() || _windows;
-  },
-  osx: function() {
-    return _populate() || _osx;
-  },
-  linux: function() {
-    return _populate() || _linux;
-  },
-  iphone: function() {
-    return _populate() || _iphone;
-  },
-  mobile: function() {
-    return _populate() || (_iphone || _ipad || _android || _mobile);
-  },
-  nativeApp: function() {
-    return _populate() || _native;
-  },
-  android: function() {
-    return _populate() || _android;
-  },
-  ipad: function() {
-    return _populate() || _ipad;
-  }
-};
-var UserAgent_DEPRECATED_1 = UserAgent_DEPRECATED$1;
-var canUseDOM = !!(typeof window !== "undefined" && window.document && window.document.createElement);
-var ExecutionEnvironment$1 = {
-  canUseDOM,
-  canUseWorkers: typeof Worker !== "undefined",
-  canUseEventListeners: canUseDOM && !!(window.addEventListener || window.attachEvent),
-  canUseViewport: canUseDOM && !!window.screen,
-  isInWorker: !canUseDOM
-};
-var ExecutionEnvironment_1 = ExecutionEnvironment$1;
-var ExecutionEnvironment = ExecutionEnvironment_1;
-var useHasFeature;
-if (ExecutionEnvironment.canUseDOM) {
-  useHasFeature = document.implementation && document.implementation.hasFeature && document.implementation.hasFeature("", "") !== true;
-}
-/**
- * Checks if an event is supported in the current execution environment.
- *
- * NOTE: This will not work correctly for non-generic events such as `change`,
- * `reset`, `load`, `error`, and `select`.
- *
- * Borrows from Modernizr.
- *
- * @param {string} eventNameSuffix Event name, e.g. "click".
- * @param {?boolean} capture Check if the capture phase is supported.
- * @return {boolean} True if the event is supported.
- * @internal
- * @license Modernizr 3.0.0pre (Custom Build) | MIT
- */
-function isEventSupported$1(eventNameSuffix, capture) {
-  if (!ExecutionEnvironment.canUseDOM || capture && !("addEventListener" in document)) {
-    return false;
-  }
-  var eventName = "on" + eventNameSuffix;
-  var isSupported = eventName in document;
-  if (!isSupported) {
-    var element = document.createElement("div");
-    element.setAttribute(eventName, "return;");
-    isSupported = typeof element[eventName] === "function";
-  }
-  if (!isSupported && useHasFeature && eventNameSuffix === "wheel") {
-    isSupported = document.implementation.hasFeature("Events.wheel", "3.0");
+      }, [(_b = (_a = slots.default) == null ? void 0 : _a.call(slots, renderData)) != null ? _b : createVNode("span", {
+        "class": getRenderItemClass(renderData),
+        "style": getRenderItemStyle(renderData),
+        "onClick": () => goToLink(renderData.link)
+      }, null)]);
+    })]), createVNode("ul", {
+      "class": "bk-swiper-index"
+    }, [computedRenderDataList.value.map((_2, index) => createVNode("li", {
+      "class": getRenderIndexStyle(index),
+      "onMouseover": () => changeIndex(index)
+    }, null))]), createVNode("span", {
+      "class": "bk-swiper-nav bk-nav-prev",
+      "onClick": () => changeIndex(swiperIndex.value - 1)
+    }, [createVNode("i", {
+      "class": "bk-swiper-nav-icon"
+    }, null)]), createVNode("span", {
+      "class": "bk-swiper-nav bk-nav-next",
+      "onClick": () => changeIndex(swiperIndex.value + 1)
+    }, [createVNode("i", {
+      "class": "bk-swiper-nav-icon"
+    }, null)])]);
   }
-  return isSupported;
+});
+const BkSwiper = withInstall(Component$j);
+const selectKey = Symbol("BkSelect");
+const optionGroupKey = Symbol("BkOptionGroup");
+function useFocus() {
+  const isFocus = ref(false);
+  const handleFocus = () => {
+    isFocus.value = true;
+  };
+  const handleBlur = () => {
+    isFocus.value = false;
+  };
+  return {
+    isFocus,
+    handleFocus,
+    handleBlur
+  };
 }
-var isEventSupported_1 = isEventSupported$1;
-var UserAgent_DEPRECATED = UserAgent_DEPRECATED_1;
-var isEventSupported = isEventSupported_1;
-var PIXEL_STEP = 10;
-var LINE_HEIGHT = 40;
-var PAGE_HEIGHT = 800;
-function normalizeWheel$1(event) {
-  var sX = 0, sY = 0, pX = 0, pY = 0;
-  if ("detail" in event) {
-    sY = event.detail;
-  }
-  if ("wheelDelta" in event) {
-    sY = -event.wheelDelta / 120;
-  }
-  if ("wheelDeltaY" in event) {
-    sY = -event.wheelDeltaY / 120;
-  }
-  if ("wheelDeltaX" in event) {
-    sX = -event.wheelDeltaX / 120;
-  }
-  if ("axis" in event && event.axis === event.HORIZONTAL_AXIS) {
-    sX = sY;
-    sY = 0;
-  }
-  pX = sX * PIXEL_STEP;
-  pY = sY * PIXEL_STEP;
-  if ("deltaY" in event) {
-    pY = event.deltaY;
-  }
-  if ("deltaX" in event) {
-    pX = event.deltaX;
-  }
-  if ((pX || pY) && event.deltaMode) {
-    if (event.deltaMode == 1) {
-      pX *= LINE_HEIGHT;
-      pY *= LINE_HEIGHT;
-    } else {
-      pX *= PAGE_HEIGHT;
-      pY *= PAGE_HEIGHT;
+function useHover() {
+  const isHover = ref(false);
+  const setHover = () => {
+    isHover.value = true;
+  };
+  const cancelHover = () => {
+    isHover.value = false;
+  };
+  return {
+    isHover,
+    setHover,
+    cancelHover
+  };
+}
+function useRegistry(data2) {
+  const register = (item) => {
+    if (!item || data2.value.find((d2) => d2 === item))
+      return;
+    return data2.value.push(item);
+  };
+  const unregister = (item) => {
+    const index = data2.value.findIndex((d2) => d2 === item);
+    if (index > -1) {
+      data2.value.splice(index, 1);
     }
-  }
-  if (pX && !sX) {
-    sX = pX < 1 ? -1 : 1;
-  }
-  if (pY && !sY) {
-    sY = pY < 1 ? -1 : 1;
-  }
+  };
   return {
-    spinX: sX,
-    spinY: sY,
-    pixelX: pX,
-    pixelY: pY
+    register,
+    unregister
   };
 }
-normalizeWheel$1.getEventType = function() {
-  return UserAgent_DEPRECATED.firefox() ? "DOMMouseScroll" : isEventSupported("wheel") ? "wheel" : "mousewheel";
-};
-var normalizeWheel_1 = normalizeWheel$1;
-var normalizeWheel = normalizeWheel_1;
-const isFirefox = typeof navigator !== "undefined" && navigator.userAgent.toLowerCase().indexOf("firefox") > -1;
-const mousewheelHandler = function(element, callback) {
-  if (element == null ? void 0 : element.addEventListener) {
-    element.addEventListener(isFirefox ? "DOMMouseScroll" : "mousewheel", function(e) {
-      const normalized = normalizeWheel(e);
-      callback == null ? void 0 : callback.apply(this, [e, normalized]);
+function useDebouncedRef(value, delay = 200) {
+  let timeout;
+  let innerValue = value;
+  return customRef((track, trigger) => ({
+    get() {
+      track();
+      return innerValue;
+    },
+    set(newValue) {
+      clearTimeout(timeout);
+      if (newValue === void 0 || newValue === "") {
+        innerValue = newValue;
+        trigger();
+      } else {
+        timeout = setTimeout(() => {
+          innerValue = newValue;
+          trigger();
+        }, delay);
+      }
+    }
+  }));
+}
+function usePopover(config) {
+  const { popoverMinWidth } = config;
+  const popperWidth = ref("auto");
+  const isPopoverShow = ref(false);
+  const onPopoverFirstUpdate = (instance) => {
+    const { reference: reference2 } = instance.elements;
+    popperWidth.value = Math.max(reference2.offsetWidth, popoverMinWidth);
+  };
+  const togglePopover = () => {
+    isPopoverShow.value = !isPopoverShow.value;
+  };
+  const hidePopover = () => {
+    isPopoverShow.value = false;
+  };
+  const showPopover = () => {
+    isPopoverShow.value = true;
+  };
+  return {
+    isPopoverShow,
+    popperWidth,
+    togglePopover,
+    onPopoverFirstUpdate,
+    hidePopover,
+    showPopover
+  };
+}
+function useRemoteSearch(method, callBack) {
+  const searchKey = useDebouncedRef("");
+  const searchLoading = ref(false);
+  watch(searchKey, async () => {
+    try {
+      searchLoading.value = true;
+      await method(searchKey.value);
+      searchLoading.value = false;
+    } catch (err) {
+      console.error(err);
+    } finally {
+      callBack == null ? void 0 : callBack();
+    }
+  });
+  return {
+    searchKey,
+    searchLoading
+  };
+}
+function toLowerCase(value = "") {
+  if (!value)
+    return value;
+  return String(value).trim().toLowerCase();
+}
+var BkOption = defineComponent({
+  name: "Option",
+  props: {
+    value: PropTypes.any,
+    label: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
+    disabled: PropTypes.bool.def(false)
+  },
+  setup(props) {
+    const {
+      proxy
+    } = getCurrentInstance();
+    const states = reactive({
+      visible: true
+    });
+    const {
+      disabled,
+      value
+    } = toRefs(props);
+    const select2 = inject(selectKey, null);
+    const group = inject(optionGroupKey, null);
+    const selected = computed(() => {
+      var _a;
+      return (_a = select2 == null ? void 0 : select2.selected) == null ? void 0 : _a.some((data2) => data2.value === value.value);
+    });
+    const multiple = computed(() => select2 == null ? void 0 : select2.multiple);
+    const isHover = computed(() => (select2 == null ? void 0 : select2.activeOptionValue) === value.value);
+    const handleOptionClick = () => {
+      if (disabled.value)
+        return;
+      select2 == null ? void 0 : select2.handleOptionSelected(proxy);
+    };
+    const handleMouseEnter = () => {
+      select2.activeOptionValue = value.value;
+    };
+    onBeforeMount(() => {
+      select2 == null ? void 0 : select2.register(proxy);
+      group == null ? void 0 : group.register(proxy);
+    });
+    onBeforeUnmount(() => {
+      select2 == null ? void 0 : select2.unregister(proxy);
+      group == null ? void 0 : group.unregister(proxy);
+    });
+    return __spreadProps(__spreadValues({}, toRefs(states)), {
+      selected,
+      multiple,
+      isHover,
+      handleOptionClick,
+      handleMouseEnter
+    });
+  },
+  render() {
+    var _a, _b, _c;
+    const selectItemClass = classes({
+      "is-selected": this.selected,
+      "is-disabled": this.disabled,
+      "is-multiple": this.multiple,
+      "is-hover": this.isHover,
+      "bk-select-option": true
     });
-  }
-};
-const mousewheel = {
-  beforeMount(el, binding) {
-    console.error(el, binding);
-    mousewheelHandler(el, binding.value);
-  }
-};
-const isElement = (e) => {
-  if (typeof Element === "undefined")
-    return false;
-  return e instanceof Element;
-};
-const nodeList = /* @__PURE__ */ new Map();
-let startClick;
-document.addEventListener("mousedown", (e) => startClick = e);
-document.addEventListener("mouseup", (e) => {
-  for (const handlers of nodeList.values()) {
-    for (const { documentHandler } of handlers) {
-      documentHandler(e, startClick);
-    }
+    return withDirectives(createVNode("li", {
+      "class": selectItemClass,
+      "onClick": this.handleOptionClick,
+      "onMouseenter": this.handleMouseEnter
+    }, [(_c = (_b = (_a = this.$slots).default) == null ? void 0 : _b.call(_a)) != null ? _c : createVNode("span", null, [this.label])]), [[vShow, this.visible]]);
   }
 });
-function createDocumentHandler(el, binding) {
-  let excludes = [];
-  if (Array.isArray(binding.arg)) {
-    excludes = binding.arg;
-  } else if (isElement(binding.arg)) {
-    excludes.push(binding.arg);
-  }
-  return function(mouseup, mousedown) {
-    const { popperRef } = binding.instance;
-    const mouseUpTarget = mouseup.target;
-    const mouseDownTarget = mousedown == null ? void 0 : mousedown.target;
-    const isBound = !binding || !binding.instance;
-    const isTargetExists = !mouseUpTarget || !mouseDownTarget;
-    const isContainedByEl = el.contains(mouseUpTarget) || el.contains(mouseDownTarget);
-    const isSelf = el === mouseUpTarget;
-    const isTargetExcluded = excludes.length && excludes.some((item) => item == null ? void 0 : item.contains(mouseUpTarget)) || excludes.length && excludes.includes(mouseDownTarget);
-    const isContainedByPopper = popperRef && (popperRef.contains(mouseUpTarget) || popperRef.contains(mouseDownTarget));
-    if (isBound || isTargetExists || isContainedByEl || isSelf || isTargetExcluded || isContainedByPopper) {
-      return;
-    }
-    binding.value(mouseup, mousedown);
-  };
-}
-const ClickOutside = {
-  beforeMount(el, binding) {
-    if (!nodeList.has(el)) {
-      nodeList.set(el, []);
-    }
-    nodeList.get(el).push({
-      documentHandler: createDocumentHandler(el, binding),
-      bindingFn: binding.value
-    });
+var OptionGroup = defineComponent({
+  name: "Group",
+  props: {
+    label: PropTypes.string.def(""),
+    disabled: PropTypes.bool.def(false),
+    collapsible: PropTypes.bool.def(false),
+    collapse: PropTypes.bool.def(false)
   },
-  updated(el, binding) {
-    if (!nodeList.has(el)) {
-      nodeList.set(el, []);
-    }
-    const handlers = nodeList.get(el);
-    const oldHandlerIndex = handlers.findIndex((item) => item.bindingFn === binding.oldValue);
-    const newHandler = {
-      documentHandler: createDocumentHandler(el, binding),
-      bindingFn: binding.value
+  setup(props, {
+    emit
+  }) {
+    const {
+      proxy
+    } = getCurrentInstance();
+    const select2 = inject(selectKey, null);
+    const states = reactive({
+      groupCollapse: props.collapse,
+      visible: true
+    });
+    const options = ref([]);
+    const {
+      register,
+      unregister
+    } = useRegistry(options);
+    const groupLabel = computed(() => `${props.label} (${[...options.value.values()].filter((option) => option.visible).length})`);
+    const handleToggleCollapse = () => {
+      if (!props.collapsible || props.disabled)
+        return;
+      states.groupCollapse = !states.groupCollapse;
+      emit("update:collapse", states.groupCollapse);
     };
-    if (oldHandlerIndex >= 0) {
-      handlers.splice(oldHandlerIndex, 1, newHandler);
-    } else {
-      handlers.push(newHandler);
-    }
+    provide(optionGroupKey, reactive(__spreadProps(__spreadValues({}, toRefs(props)), {
+      register,
+      unregister,
+      groupCollapse: toRef(states, "groupCollapse")
+    })));
+    onBeforeMount(() => {
+      select2 == null ? void 0 : select2.registerGroup(proxy);
+    });
+    onBeforeUnmount(() => {
+      select2 == null ? void 0 : select2.unregisterGroup(proxy);
+    });
+    return __spreadProps(__spreadValues({}, toRefs(states)), {
+      groupLabel,
+      handleToggleCollapse
+    });
   },
-  unmounted(el) {
-    nodeList.delete(el);
-  }
-};
-var popper = "";
-const tooltips = {
-  mounted(el, binding) {
-    const opts = initOptions();
-    if (typeof binding.value === "object") {
-      Object.assign(opts, binding.value);
-    } else {
-      opts.content = binding.value;
-    }
-    const { disabled, arrow: arrow2, theme } = opts;
-    if (disabled) {
-      return;
-    }
-    const popper2 = renderContent(opts.content, arrow2, theme === "light");
-    createPopperInstance(el, popper2, opts);
-  }
-};
-function initOptions() {
-  const defaultOpts = {
-    arrow: true,
-    disabled: false,
-    trigger: "hover",
-    theme: "dark",
-    content: "",
-    showOnInit: false,
-    placement: "top",
-    distance: 8,
-    onShow: () => {
-    },
-    onHide: () => {
-    }
-  };
-  return defaultOpts;
-}
-function renderContent(value, hasArrow, isLight) {
-  const zIndex = bkZIndexManager.getPopperIndex();
-  const content = document.createElement("div");
-  content.className = `bk-popper ${isLight ? "light" : "dark"}`;
-  content.innerText = value;
-  content.style.zIndex = String(zIndex);
-  if (hasArrow) {
-    const arrow2 = renderArrow();
-    content.appendChild(arrow2);
-  }
-  document.body.appendChild(content);
-  return content;
-}
-function renderArrow() {
-  const arrow2 = document.createElement("div");
-  arrow2.className = "bk-popper-arrow";
-  arrow2.setAttribute("data-popper-arrow", "");
-  return arrow2;
-}
-function createPopperInstance(el, popper2, options) {
-  const { placement, distance, trigger, showOnInit, onShow, onHide } = options;
-  const popperInstance = createPopper(el, popper2, {
-    placement,
-    modifiers: [
-      {
-        name: "offset",
-        options: {
-          offset: [0, distance]
-        }
-      }
-    ]
-  });
-  if (trigger === "hover") {
-    const showEvents = ["mouseenter", "focus"];
-    const hideEvents = ["mouseleave", "blur"];
-    showEvents.forEach((event) => {
-      el.addEventListener(event, show);
+  render() {
+    var _a, _b;
+    const groupClass = classes({
+      "bk-option-group": true,
+      collapsible: this.collapsible,
+      disabled: this.disabled
     });
-    hideEvents.forEach((event) => {
-      el.addEventListener(event, hide2);
+    const groupLabelClass = classes({
+      "bk-option-group-label": true,
+      collapsible: this.collapsible
     });
-  } else if (trigger === "click") {
-    document.body.addEventListener("click", (event) => {
-      if (el.contains(event.target) && !popper2.hasAttribute("data-show")) {
-        show();
-      } else if (popper2.hasAttribute("data-show")) {
-        hide2();
-      }
+    const groupLabelIconClass = classes({
+      "default-group-label-icon": true,
+      collapse: this.groupCollapse
     });
+    return withDirectives(createVNode("ul", {
+      "class": groupClass
+    }, [createVNode("li", {
+      "class": groupLabelClass,
+      "onClick": this.handleToggleCollapse
+    }, [this.$slots.label ? this.$slots.label() : createVNode("span", {
+      "class": "default-group-label"
+    }, [this.collapsible && createVNode(angleUpFill, {
+      "class": groupLabelIconClass
+    }, null), createVNode("span", {
+      "class": "default-group-label-title"
+    }, [this.groupLabel])])]), withDirectives(createVNode("ul", {
+      "class": "bk-option-group-content"
+    }, [(_b = (_a = this.$slots).default) == null ? void 0 : _b.call(_a)]), [[vShow, !this.groupCollapse]])]), [[vShow, this.visible]]);
   }
-  if (showOnInit)
-    show();
-  function show() {
-    popper2.setAttribute("data-show", "");
-    onShow();
-    popperInstance.setOptions((options2) => __spreadProps(__spreadValues({}, options2), {
-      modifiers: [
-        ...options2.modifiers,
-        { name: "eventListeners", enabled: true }
-      ]
-    }));
-    popperInstance.update();
-  }
-  function hide2() {
-    popper2.removeAttribute("data-show");
-    onHide();
-    popperInstance.setOptions((options2) => __spreadProps(__spreadValues({}, options2), {
-      modifiers: [
-        ...options2.modifiers,
-        { name: "eventListeners", enabled: false }
-      ]
-    }));
-  }
-}
+});
 var Component$i = defineComponent({
   name: "Tag",
   props: {
@@ -14805,7 +14865,14 @@ var Component$d = defineComponent({
   }
 });
 const BkVirtualRender = withInstall(Component$d);
-const BORDER_OPRIONS = ["none", "row", "col", "outer"];
+var BORDER_OPTION = /* @__PURE__ */ ((BORDER_OPTION2) => {
+  BORDER_OPTION2["NONE"] = "none";
+  BORDER_OPTION2["ROW"] = "row";
+  BORDER_OPTION2["COL"] = "col";
+  BORDER_OPTION2["OUTER"] = "outer";
+  return BORDER_OPTION2;
+})(BORDER_OPTION || {});
+const BORDER_OPTIONS = ["none", "row", "col", "outer"];
 var EVENTS$1 = /* @__PURE__ */ ((EVENTS2) => {
   EVENTS2["ON_SORT_BY_CLICK"] = "onSortByClick";
   EVENTS2["ON_FILTER_CLICK"] = "onFilterClick";
@@ -15007,7 +15074,7 @@ const tableProps = {
     cellFn: PropTypes.func.def(void 0)
   }),
   virtualEnabled: PropTypes.bool.def(false),
-  border: PropTypes.arrayOf(PropTypes.commonType(BORDER_OPRIONS, "border")).def(["row"]),
+  border: PropTypes.arrayOf(PropTypes.commonType(BORDER_OPTIONS, "border")).def([BORDER_OPTION.ROW]),
   pagination: PropTypes.oneOfType([PropTypes.bool.def(false), PropTypes.object.def({})]).def(false),
   remotePagination: PropTypes.bool.def(false),
   emptyText: PropTypes.string.def("\u6682\u65E0\u6570\u636E"),
@@ -15524,7 +15591,7 @@ const resolvePropBorderToClassStr = (val) => {
     defaultVal.push(val);
   }
   if (Array.isArray(val)) {
-    defaultVal.push(...val.filter((str) => BORDER_OPRIONS.includes(str)));
+    defaultVal.push(...val.filter((str) => BORDER_OPTIONS.includes(str)));
   }
   return [...new Set(defaultVal)].map((item) => `bordered-${item}`).join(" ");
 };
@@ -15532,11 +15599,11 @@ const getColumnReactWidth = (colmun, orders = ["resizeWidth", "calcWidth", "widt
   var _a, _b;
   return (_b = (_a = colmun[orders[0]]) != null ? _a : colmun[orders[1]]) != null ? _b : colmun[orders[2]];
 };
-const resolveColumnWidth = (root, colgroups, autoWidth = 20, hasScrollY = false) => {
+const resolveColumnWidth = (root, colgroups, autoWidth = 20, offsetWidth = 0) => {
   const {
     width
   } = root.getBoundingClientRect() || {};
-  const availableWidth = width - (hasScrollY ? 4 : 0);
+  const availableWidth = width - offsetWidth;
   let avgWidth = availableWidth;
   const avgColIndexList = [];
   const getMinWidth = (col, computedWidth) => {
@@ -16697,6 +16764,16 @@ const useClass = (props, root, reactiveProp, pageData) => {
       }
     }
   };
+  const getColumnsWidthOffsetWidth = () => {
+    let offsetWidth = 0;
+    if (hasScrollY.value) {
+      offsetWidth = offsetWidth + 4;
+    }
+    if (props.border.includes(BORDER_OPTION.OUTER) && !props.border.includes(BORDER_OPTION.NONE)) {
+      offsetWidth = offsetWidth + 2;
+    }
+    return offsetWidth;
+  };
   return {
     tableClass,
     headClass,
@@ -16707,6 +16784,7 @@ const useClass = (props, root, reactiveProp, pageData) => {
     headStyle,
     resetTableHeight,
     updateBorderClass,
+    getColumnsWidthOffsetWidth,
     hasFooter,
     hasScrollY
   };
@@ -16821,8 +16899,8 @@ var Component$b = defineComponent({
       headStyle,
       updateBorderClass,
       resetTableHeight,
-      hasFooter,
-      hasScrollY
+      getColumnsWidthOffsetWidth,
+      hasFooter
     } = useClass(props, root, reactiveSchema, pageData);
     const tableRender = new TableRender(props, ctx, reactiveSchema, colgroups);
     watch(() => [props.data, props.pagination], () => {
@@ -16836,8 +16914,11 @@ var Component$b = defineComponent({
       immediate: true,
       deep: true
     });
-    watch(hasScrollY, (val) => {
-      resolveColumnWidth(root.value, colgroups, 20, !!val);
+    watchEffect(() => {
+      if ((root == null ? void 0 : root.value) instanceof HTMLElement) {
+        const offset2 = getColumnsWidthOffsetWidth();
+        resolveColumnWidth(root.value, colgroups, 20, offset2);
+      }
     });
     tableRender.on(EVENTS$1.ON_SORT_BY_CLICK, (args) => {
       const {
@@ -16878,7 +16959,8 @@ var Component$b = defineComponent({
         size,
         height
       } = args;
-      checked.length && resolveColumnWidth(root.value, colgroups, 20, hasScrollY.value);
+      const offset2 = getColumnsWidthOffsetWidth();
+      checked.length && resolveColumnWidth(root.value, colgroups, 20, offset2);
       (_b = (_a = refVirtualRender.value) == null ? void 0 : _a.reset) == null ? void 0 : _b.call(_a);
       ctx.emit(EMITEVENTS.SETTING_CHANGE, {
         checked,