cleek 2.3.51 → 2.3.52

package/dist/cleek.es.js

@@ -17,7 +17,2662 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-import { defineComponent, ref, computed as computed$2, openBlock, createElementBlock, normalizeClass, unref as unref$1, createElementVNode, renderSlot, createCommentVNode, normalizeStyle, watch, h, createBlock, Teleport, createVNode, createTextVNode, toDisplayString, withCtx, onMounted, nextTick as nextTick$1, onBeforeUnmount, getCurrentInstance, withDirectives, isRef as isRef$1, vModelDynamic, Fragment, renderList, mergeProps, withKeys, withModifiers, pushScopeId, popScopeId, vModelRadio, vModelSelect, vModelCheckbox, vModelText } from "vue";
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+import { pushScopeId, popScopeId, defineComponent, nextTick as nextTick$1, openBlock, createBlock, withScopeId, resolveComponent, createElementBlock, normalizeClass, normalizeStyle, withKeys, createElementVNode, Fragment, renderSlot, createCommentVNode, mergeProps, withCtx, createVNode, ref, createApp, h, toDisplayString, computed as computed$2, unref as unref$1, watch, Teleport, createTextVNode, onMounted, onBeforeUnmount, getCurrentInstance, withDirectives, isRef as isRef$1, vModelDynamic, renderList, withModifiers, vModelRadio, vModelSelect, vModelCheckbox, vModelText } from "vue";
+function getBasePlacement$2(placement) {
+  return placement.split("-")[0];
+}
+function getAlignment(placement) {
+  return placement.split("-")[1];
+}
+function getMainAxisFromPlacement$1(placement) {
+  return ["top", "bottom"].includes(getBasePlacement$2(placement)) ? "x" : "y";
+}
+function getLengthFromAxis(axis) {
+  return axis === "y" ? "height" : "width";
+}
+function computeCoordsFromPlacement(_ref2) {
+  let {
+    reference: reference2,
+    floating,
+    placement
+  } = _ref2;
+  const commonX = reference2.x + reference2.width / 2 - floating.width / 2;
+  const commonY = reference2.y + reference2.height / 2 - floating.height / 2;
+  let coords;
+  switch (getBasePlacement$2(placement)) {
+    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
+      };
+  }
+  const mainAxis = getMainAxisFromPlacement$1(placement);
+  const length = getLengthFromAxis(mainAxis);
+  switch (getAlignment(placement)) {
+    case "start":
+      coords[mainAxis] = coords[mainAxis] - (reference2[length] / 2 - floating[length] / 2);
+      break;
+    case "end":
+      coords[mainAxis] = coords[mainAxis] + (reference2[length] / 2 - floating[length] / 2);
+      break;
+  }
+  return coords;
+}
+const computePosition$1 = async (reference2, floating, config2) => {
+  const {
+    placement = "bottom",
+    strategy = "absolute",
+    middleware = [],
+    platform: platform2
+  } = config2;
+  let rects = await platform2.getElementRects({
+    reference: reference2,
+    floating,
+    strategy
+  });
+  let {
+    x,
+    y
+  } = computeCoordsFromPlacement(__spreadProps(__spreadValues({}, rects), {
+    placement
+  }));
+  let statefulPlacement = placement;
+  let middlewareData = {};
+  for (let i = 0; i < middleware.length; i++) {
+    const {
+      name,
+      fn: fn2
+    } = middleware[i];
+    const {
+      x: nextX,
+      y: nextY,
+      data,
+      reset
+    } = await fn2({
+      x,
+      y,
+      initialPlacement: placement,
+      placement: statefulPlacement,
+      strategy,
+      middlewareData,
+      rects,
+      platform: platform2,
+      elements: {
+        reference: reference2,
+        floating
+      }
+    });
+    x = nextX != null ? nextX : x;
+    y = nextY != null ? nextY : y;
+    middlewareData = __spreadProps(__spreadValues({}, middlewareData), {
+      [name]: data != null ? data : {}
+    });
+    if (reset) {
+      if (typeof reset === "object") {
+        if (reset.placement) {
+          statefulPlacement = reset.placement;
+        }
+        if (reset.rects) {
+          rects = reset.rects === true ? await platform2.getElementRects({
+            reference: reference2,
+            floating,
+            strategy
+          }) : reset.rects;
+        }
+        ({
+          x,
+          y
+        } = computeCoordsFromPlacement(__spreadProps(__spreadValues({}, rects), {
+          placement: statefulPlacement
+        })));
+      }
+      i = -1;
+      continue;
+    }
+  }
+  return {
+    x,
+    y,
+    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
+  };
+}
+function rectToClientRect$1(rect) {
+  return __spreadProps(__spreadValues({}, rect), {
+    top: rect.y,
+    left: rect.x,
+    right: rect.x + rect.width,
+    bottom: rect.y + rect.height
+  });
+}
+async function detectOverflow$1(middlewareArguments, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  const {
+    x,
+    y,
+    platform: platform2,
+    rects,
+    elements,
+    strategy
+  } = middlewareArguments;
+  const {
+    boundary = "clippingParents",
+    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 = await platform2.getClippingClientRect({
+    element: await platform2.isElement(element) ? element : element.contextElement || await platform2.getDocumentElement({
+      element: elements.floating
+    }),
+    boundary,
+    rootBoundary
+  });
+  const elementClientRect = rectToClientRect$1(await platform2.convertOffsetParentRelativeRectToViewportRelativeRect({
+    rect: elementContext === "floating" ? __spreadProps(__spreadValues({}, rects.floating), {
+      x,
+      y
+    }) : rects.reference,
+    offsetParent: await platform2.getOffsetParent({
+      element: elements.floating
+    }),
+    strategy
+  }));
+  return {
+    top: clippingClientRect.top - elementClientRect.top + paddingObject.top,
+    bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom,
+    left: clippingClientRect.left - elementClientRect.left + paddingObject.left,
+    right: elementClientRect.right - clippingClientRect.right + paddingObject.right
+  };
+}
+const min$2 = Math.min;
+const max$2 = Math.max;
+function within$1(min$12, value, max$12) {
+  return max$2(min$12, min$2(value, max$12));
+}
+const arrow$2 = (options) => ({
+  name: "arrow",
+  options,
+  async fn(middlewareArguments) {
+    const {
+      element,
+      padding = 0
+    } = options != null ? options : {};
+    const {
+      x,
+      y,
+      placement,
+      rects,
+      platform: platform2
+    } = middlewareArguments;
+    if (element == null) {
+      return {};
+    }
+    const paddingObject = getSideObjectFromPadding(padding);
+    const coords = {
+      x,
+      y
+    };
+    const basePlacement = getBasePlacement$2(placement);
+    const axis = getMainAxisFromPlacement$1(basePlacement);
+    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({
+      element
+    });
+    const clientSize = arrowOffsetParent ? axis === "y" ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;
+    const centerToReference = endDiff / 2 - startDiff / 2;
+    const min2 = paddingObject[minProp];
+    const max2 = clientSize - arrowDimensions[length] - paddingObject[maxProp];
+    const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
+    const offset2 = within$1(min2, center, max2);
+    return {
+      data: {
+        [axis]: offset2,
+        centerOffset: center - offset2
+      }
+    };
+  }
+});
+const hash$1$1 = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+};
+function getOppositePlacement$1(placement) {
+  return placement.replace(/left|right|bottom|top/g, (matched) => hash$1$1[matched]);
+}
+function getAlignmentSides(placement, rects) {
+  const isStart = getAlignment(placement) === "start";
+  const mainAxis = getMainAxisFromPlacement$1(placement);
+  const length = getLengthFromAxis(mainAxis);
+  let mainAlignmentSide = mainAxis === "x" ? isStart ? "right" : "left" : isStart ? "bottom" : "top";
+  if (rects.reference[length] > rects.floating[length]) {
+    mainAlignmentSide = getOppositePlacement$1(mainAlignmentSide);
+  }
+  return {
+    main: mainAlignmentSide,
+    cross: getOppositePlacement$1(mainAlignmentSide)
+  };
+}
+const hash$2 = {
+  start: "end",
+  end: "start"
+};
+function getOppositeAlignmentPlacement(placement) {
+  return placement.replace(/start|end/g, (matched) => hash$2[matched]);
+}
+const basePlacements$1 = ["top", "right", "bottom", "left"];
+const allPlacements = /* @__PURE__ */ basePlacements$1.reduce((acc, basePlacement) => acc.concat(basePlacement, basePlacement + "-start", basePlacement + "-end"), []);
+function getPlacementList(alignment, autoAlignment, allowedPlacements) {
+  const allowedPlacementsSortedByAlignment = alignment ? [...allowedPlacements.filter((placement) => getAlignment(placement) === alignment), ...allowedPlacements.filter((placement) => getAlignment(placement) !== alignment)] : allowedPlacements.filter((placement) => getBasePlacement$2(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: "autoPlacement",
+    options,
+    async fn(middlewareArguments) {
+      var _middlewareData$autoP, _middlewareData$autoP2, _middlewareData$autoP3, _middlewareData$autoP4, _middlewareData$autoP5, _placementsSortedByLe;
+      const {
+        x,
+        y,
+        rects,
+        middlewareData,
+        placement
+      } = middlewareArguments;
+      const _a = options, {
+        alignment = null,
+        allowedPlacements = allPlacements,
+        autoAlignment = true
+      } = _a, detectOverflowOptions = __objRest(_a, [
+        "alignment",
+        "allowedPlacements",
+        "autoAlignment"
+      ]);
+      if ((_middlewareData$autoP = middlewareData.autoPlacement) != null && _middlewareData$autoP.skip) {
+        return {};
+      }
+      const placements2 = getPlacementList(alignment, autoAlignment, allowedPlacements);
+      const overflow = await detectOverflow$1(middlewareArguments, detectOverflowOptions);
+      const currentIndex = (_middlewareData$autoP2 = (_middlewareData$autoP3 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP3.index) != null ? _middlewareData$autoP2 : 0;
+      const currentPlacement = placements2[currentIndex];
+      const {
+        main: main2,
+        cross
+      } = getAlignmentSides(currentPlacement, rects);
+      if (placement !== currentPlacement) {
+        return {
+          x,
+          y,
+          reset: {
+            placement: placements2[0]
+          }
+        };
+      }
+      const currentOverflows = [overflow[getBasePlacement$2(currentPlacement)], overflow[main2], overflow[cross]];
+      const allOverflows = [...(_middlewareData$autoP4 = (_middlewareData$autoP5 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP5.overflows) != null ? _middlewareData$autoP4 : [], {
+        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((a, b) => a.overflows[0] - b.overflows[0]);
+      const placementThatFitsOnAllSides = (_placementsSortedByLe = placementsSortedByLeastOverflow.find((_ref2) => {
+        let {
+          overflows
+        } = _ref2;
+        return overflows.every((overflow2) => overflow2 <= 0);
+      })) == null ? void 0 : _placementsSortedByLe.placement;
+      return {
+        data: {
+          skip: true
+        },
+        reset: {
+          placement: placementThatFitsOnAllSides != null ? placementThatFitsOnAllSides : placementsSortedByLeastOverflow[0].placement
+        }
+      };
+    }
+  };
+};
+function getExpandedPlacements(placement) {
+  const oppositePlacement = getOppositePlacement$1(placement);
+  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
+}
+const flip$2 = function(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    name: "flip",
+    options,
+    async fn(middlewareArguments) {
+      var _middlewareData$flip, _middlewareData$flip2;
+      const {
+        placement,
+        middlewareData,
+        rects,
+        initialPlacement
+      } = middlewareArguments;
+      if ((_middlewareData$flip = middlewareData.flip) != null && _middlewareData$flip.skip) {
+        return {};
+      }
+      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 basePlacement = getBasePlacement$2(placement);
+      const isBasePlacement = basePlacement === initialPlacement;
+      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement$1(initialPlacement)] : getExpandedPlacements(initialPlacement));
+      const placements2 = [initialPlacement, ...fallbackPlacements];
+      const overflow = await detectOverflow$1(middlewareArguments, detectOverflowOptions);
+      const overflows = [];
+      let overflowsData = ((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.overflows) || [];
+      if (checkMainAxis) {
+        overflows.push(overflow[basePlacement]);
+      }
+      if (checkCrossAxis) {
+        const {
+          main: main2,
+          cross
+        } = getAlignmentSides(placement, rects);
+        overflows.push(overflow[main2], overflow[cross]);
+      }
+      overflowsData = [...overflowsData, {
+        placement,
+        overflows
+      }];
+      if (!overflows.every((side) => side <= 0)) {
+        var _middlewareData$flip$, _middlewareData$flip3;
+        const nextIndex = ((_middlewareData$flip$ = (_middlewareData$flip3 = middlewareData.flip) == null ? void 0 : _middlewareData$flip3.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$slice$;
+            const placement2 = (_overflowsData$slice$ = overflowsData.slice().sort((a, b) => a.overflows.filter((overflow2) => overflow2 > 0).reduce((acc, overflow2) => acc + overflow2, 0) - b.overflows.filter((overflow2) => overflow2 > 0).reduce((acc, overflow2) => acc + overflow2, 0))[0]) == null ? void 0 : _overflowsData$slice$.placement;
+            if (placement2) {
+              resetPlacement = placement2;
+            }
+            break;
+          }
+          case "initialPlacement":
+            resetPlacement = initialPlacement;
+            break;
+        }
+        return {
+          data: {
+            skip: true
+          },
+          reset: {
+            placement: resetPlacement
+          }
+        };
+      }
+      return {};
+    }
+  };
+};
+function convertValueToCoords(_ref2) {
+  let {
+    placement,
+    rects,
+    value
+  } = _ref2;
+  const basePlacement = getBasePlacement$2(placement);
+  const multiplier = ["left", "top"].includes(basePlacement) ? -1 : 1;
+  const rawValue = typeof value === "function" ? value(__spreadProps(__spreadValues({}, rects), {
+    placement
+  })) : value;
+  const {
+    mainAxis,
+    crossAxis
+  } = typeof rawValue === "number" ? {
+    mainAxis: rawValue,
+    crossAxis: 0
+  } : __spreadValues({
+    mainAxis: 0,
+    crossAxis: 0
+  }, rawValue);
+  return getMainAxisFromPlacement$1(basePlacement) === "x" ? {
+    x: crossAxis,
+    y: mainAxis * multiplier
+  } : {
+    x: mainAxis * multiplier,
+    y: crossAxis
+  };
+}
+const offset$2 = function(value) {
+  if (value === void 0) {
+    value = 0;
+  }
+  return {
+    name: "offset",
+    options: value,
+    fn(middlewareArguments) {
+      const {
+        x,
+        y,
+        placement,
+        rects
+      } = middlewareArguments;
+      const diffCoords = convertValueToCoords({
+        placement,
+        rects,
+        value
+      });
+      return {
+        x: x + diffCoords.x,
+        y: y + diffCoords.y,
+        data: diffCoords
+      };
+    }
+  };
+};
+function getCrossAxis(axis) {
+  return axis === "x" ? "y" : "x";
+}
+const shift = function(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    name: "shift",
+    options,
+    async fn(middlewareArguments) {
+      const {
+        x,
+        y,
+        placement
+      } = middlewareArguments;
+      const _a = options, {
+        mainAxis: checkMainAxis = true,
+        crossAxis: checkCrossAxis = false,
+        limiter = {
+          fn: (_ref2) => {
+            let {
+              x: x2,
+              y: y2
+            } = _ref2;
+            return {
+              x: x2,
+              y: y2
+            };
+          }
+        }
+      } = _a, detectOverflowOptions = __objRest(_a, [
+        "mainAxis",
+        "crossAxis",
+        "limiter"
+      ]);
+      const coords = {
+        x,
+        y
+      };
+      const overflow = await detectOverflow$1(middlewareArguments, detectOverflowOptions);
+      const mainAxis = getMainAxisFromPlacement$1(getBasePlacement$2(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$1(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$1(min2, crossAxisCoord, max2);
+      }
+      const limitedCoords = limiter.fn(__spreadProps(__spreadValues({}, middlewareArguments), {
+        [mainAxis]: mainAxisCoord,
+        [crossAxis]: crossAxisCoord
+      }));
+      return __spreadProps(__spreadValues({}, limitedCoords), {
+        data: {
+          x: limitedCoords.x - x,
+          y: limitedCoords.y - y
+        }
+      });
+    }
+  };
+};
+const size = function(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    name: "size",
+    options,
+    async fn(middlewareArguments) {
+      var _middlewareData$size;
+      const {
+        placement,
+        rects,
+        middlewareData
+      } = middlewareArguments;
+      const _a = options, {
+        apply
+      } = _a, detectOverflowOptions = __objRest(_a, [
+        "apply"
+      ]);
+      if ((_middlewareData$size = middlewareData.size) != null && _middlewareData$size.skip) {
+        return {};
+      }
+      const overflow = await detectOverflow$1(middlewareArguments, detectOverflowOptions);
+      const basePlacement = getBasePlacement$2(placement);
+      const isEnd = getAlignment(placement) === "end";
+      let heightSide;
+      let widthSide;
+      if (basePlacement === "top" || basePlacement === "bottom") {
+        heightSide = basePlacement;
+        widthSide = isEnd ? "left" : "right";
+      } else {
+        widthSide = basePlacement;
+        heightSide = isEnd ? "top" : "bottom";
+      }
+      const xMin = max$2(overflow.left, 0);
+      const xMax = max$2(overflow.right, 0);
+      const yMin = max$2(overflow.top, 0);
+      const yMax = max$2(overflow.bottom, 0);
+      const dimensions = {
+        height: rects.floating.height - (["left", "right"].includes(placement) ? 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max$2(overflow.top, overflow.bottom)) : overflow[heightSide]),
+        width: rects.floating.width - (["top", "bottom"].includes(placement) ? 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max$2(overflow.left, overflow.right)) : overflow[widthSide])
+      };
+      apply == null ? void 0 : apply(__spreadValues(__spreadValues({}, dimensions), rects));
+      return {
+        data: {
+          skip: true
+        },
+        reset: {
+          rects: true
+        }
+      };
+    }
+  };
+};
+function isWindow(value) {
+  return (value == null ? void 0 : value.toString()) === "[object Window]";
+}
+function getWindow$1(node) {
+  if (node == null) {
+    return window;
+  }
+  if (!isWindow(node)) {
+    const ownerDocument = node.ownerDocument;
+    return ownerDocument ? ownerDocument.defaultView || window : window;
+  }
+  return node;
+}
+function getComputedStyle$1$1(element) {
+  return getWindow$1(element).getComputedStyle(element);
+}
+function getNodeName$1(node) {
+  return isWindow(node) ? "" : node ? (node.nodeName || "").toLowerCase() : "";
+}
+function isHTMLElement$1(value) {
+  return value instanceof getWindow$1(value).HTMLElement;
+}
+function isElement$2(value) {
+  return value instanceof getWindow$1(value).Element;
+}
+function isNode(value) {
+  return value instanceof getWindow$1(value).Node;
+}
+function isShadowRoot$1(node) {
+  const OwnElement = getWindow$1(node).ShadowRoot;
+  return node instanceof OwnElement || node instanceof ShadowRoot;
+}
+function isScrollParent$1(element) {
+  const {
+    overflow,
+    overflowX,
+    overflowY
+  } = getComputedStyle$1$1(element);
+  return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
+}
+function isTableElement$1(element) {
+  return ["table", "td", "th"].includes(getNodeName$1(element));
+}
+function isContainingBlock(element) {
+  const isFirefox = navigator.userAgent.toLowerCase().includes("firefox");
+  const css2 = getComputedStyle$1$1(element);
+  return css2.transform !== "none" || css2.perspective !== "none" || css2.contain === "paint" || ["transform", "perspective"].includes(css2.willChange) || isFirefox && css2.willChange === "filter" || isFirefox && (css2.filter ? css2.filter !== "none" : false);
+}
+const min$1 = Math.min;
+const max$1 = Math.max;
+const round$1 = Math.round;
+function getBoundingClientRect$1(element, includeScale) {
+  if (includeScale === void 0) {
+    includeScale = false;
+  }
+  const clientRect = element.getBoundingClientRect();
+  let scaleX = 1;
+  let scaleY = 1;
+  if (includeScale && isHTMLElement$1(element)) {
+    scaleX = element.offsetWidth > 0 ? round$1(clientRect.width) / element.offsetWidth || 1 : 1;
+    scaleY = element.offsetHeight > 0 ? round$1(clientRect.height) / element.offsetHeight || 1 : 1;
+  }
+  return {
+    width: clientRect.width / scaleX,
+    height: clientRect.height / scaleY,
+    top: clientRect.top / scaleY,
+    right: clientRect.right / scaleX,
+    bottom: clientRect.bottom / scaleY,
+    left: clientRect.left / scaleX,
+    x: clientRect.left / scaleX,
+    y: clientRect.top / scaleY
+  };
+}
+function getDocumentElement$1(node) {
+  return ((isNode(node) ? node.ownerDocument : node.document) || window.document).documentElement;
+}
+function getNodeScroll$1(element) {
+  if (isWindow(element)) {
+    return {
+      scrollLeft: element.pageXOffset,
+      scrollTop: element.pageYOffset
+    };
+  }
+  return {
+    scrollLeft: element.scrollLeft,
+    scrollTop: element.scrollTop
+  };
+}
+function getWindowScrollBarX$1(element) {
+  return getBoundingClientRect$1(getDocumentElement$1(element)).left + getNodeScroll$1(element).scrollLeft;
+}
+function isScaled(element) {
+  const rect = getBoundingClientRect$1(element);
+  return round$1(rect.width) !== element.offsetWidth || round$1(rect.height) !== element.offsetHeight;
+}
+function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
+  const isOffsetParentAnElement = isHTMLElement$1(offsetParent);
+  const documentElement = getDocumentElement$1(offsetParent);
+  const rect = getBoundingClientRect$1(element, isOffsetParentAnElement && isScaled(offsetParent));
+  let scroll = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const offsets = {
+    x: 0,
+    y: 0
+  };
+  if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== "fixed") {
+    if (getNodeName$1(offsetParent) !== "body" || isScrollParent$1(documentElement)) {
+      scroll = getNodeScroll$1(offsetParent);
+    }
+    if (isHTMLElement$1(offsetParent)) {
+      const offsetRect = getBoundingClientRect$1(offsetParent, true);
+      offsets.x = offsetRect.x + offsetParent.clientLeft;
+      offsets.y = offsetRect.y + offsetParent.clientTop;
+    } else if (documentElement) {
+      offsets.x = getWindowScrollBarX$1(documentElement);
+    }
+  }
+  return {
+    x: rect.left + scroll.scrollLeft - offsets.x,
+    y: rect.top + scroll.scrollTop - offsets.y,
+    width: rect.width,
+    height: rect.height
+  };
+}
+function getParentNode$1(node) {
+  if (getNodeName$1(node) === "html") {
+    return node;
+  }
+  return node.assignedSlot || node.parentNode || (isShadowRoot$1(node) ? node.host : null) || getDocumentElement$1(node);
+}
+function getTrueOffsetParent$1(element) {
+  if (!isHTMLElement$1(element) || getComputedStyle(element).position === "fixed") {
+    return null;
+  }
+  return element.offsetParent;
+}
+function getContainingBlock$1(element) {
+  let currentNode = getParentNode$1(element);
+  while (isHTMLElement$1(currentNode) && !["html", "body"].includes(getNodeName$1(currentNode))) {
+    if (isContainingBlock(currentNode)) {
+      return currentNode;
+    } else {
+      currentNode = currentNode.parentNode;
+    }
+  }
+  return null;
+}
+function getOffsetParent$1(element) {
+  const window2 = getWindow$1(element);
+  let offsetParent = getTrueOffsetParent$1(element);
+  while (offsetParent && isTableElement$1(offsetParent) && getComputedStyle(offsetParent).position === "static") {
+    offsetParent = getTrueOffsetParent$1(offsetParent);
+  }
+  if (offsetParent && (getNodeName$1(offsetParent) === "html" || getNodeName$1(offsetParent) === "body" && getComputedStyle(offsetParent).position === "static" && !isContainingBlock(offsetParent))) {
+    return window2;
+  }
+  return offsetParent || getContainingBlock$1(element) || window2;
+}
+function getDimensions(element) {
+  return {
+    width: element.offsetWidth,
+    height: element.offsetHeight
+  };
+}
+function convertOffsetParentRelativeRectToViewportRelativeRect(_ref2) {
+  let {
+    rect,
+    offsetParent,
+    strategy
+  } = _ref2;
+  const isOffsetParentAnElement = isHTMLElement$1(offsetParent);
+  const documentElement = getDocumentElement$1(offsetParent);
+  if (offsetParent === documentElement) {
+    return rect;
+  }
+  let scroll = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const offsets = {
+    x: 0,
+    y: 0
+  };
+  if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== "fixed") {
+    if (getNodeName$1(offsetParent) !== "body" || isScrollParent$1(documentElement)) {
+      scroll = getNodeScroll$1(offsetParent);
+    }
+    if (isHTMLElement$1(offsetParent)) {
+      const offsetRect = getBoundingClientRect$1(offsetParent, true);
+      offsets.x = offsetRect.x + offsetParent.clientLeft;
+      offsets.y = offsetRect.y + offsetParent.clientTop;
+    }
+  }
+  return __spreadProps(__spreadValues({}, rect), {
+    x: rect.x - scroll.scrollLeft + offsets.x,
+    y: rect.y - scroll.scrollTop + offsets.y
+  });
+}
+function getViewportRect$1(element) {
+  const win = getWindow$1(element);
+  const html = getDocumentElement$1(element);
+  const visualViewport = win.visualViewport;
+  let width = html.clientWidth;
+  let height = html.clientHeight;
+  let x = 0;
+  let y = 0;
+  if (visualViewport) {
+    width = visualViewport.width;
+    height = visualViewport.height;
+    if (Math.abs(win.innerWidth / visualViewport.scale - visualViewport.width) < 0.01) {
+      x = visualViewport.offsetLeft;
+      y = visualViewport.offsetTop;
+    }
+  }
+  return {
+    width,
+    height,
+    x,
+    y
+  };
+}
+function getDocumentRect$1(element) {
+  var _element$ownerDocumen;
+  const html = getDocumentElement$1(element);
+  const scroll = getNodeScroll$1(element);
+  const body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body;
+  const width = max$1(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
+  const height = max$1(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
+  let x = -scroll.scrollLeft + getWindowScrollBarX$1(element);
+  const y = -scroll.scrollTop;
+  if (getComputedStyle$1$1(body || html).direction === "rtl") {
+    x += max$1(html.clientWidth, body ? body.clientWidth : 0) - width;
+  }
+  return {
+    width,
+    height,
+    x,
+    y
+  };
+}
+function getScrollParent$1(node) {
+  if (["html", "body", "#document"].includes(getNodeName$1(node))) {
+    return node.ownerDocument.body;
+  }
+  if (isHTMLElement$1(node) && isScrollParent$1(node)) {
+    return node;
+  }
+  return getScrollParent$1(getParentNode$1(node));
+}
+function getScrollParents(node, list) {
+  var _node$ownerDocument;
+  if (list === void 0) {
+    list = [];
+  }
+  const scrollParent = getScrollParent$1(node);
+  const isBody = scrollParent === ((_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.body);
+  const win = getWindow$1(scrollParent);
+  const target = isBody ? [win].concat(win.visualViewport || [], isScrollParent$1(scrollParent) ? scrollParent : []) : scrollParent;
+  const updatedList = list.concat(target);
+  return isBody ? updatedList : updatedList.concat(getScrollParents(getParentNode$1(target)));
+}
+function contains$1(parent, child) {
+  const rootNode = child.getRootNode == null ? void 0 : child.getRootNode();
+  if (parent.contains(child)) {
+    return true;
+  } else if (rootNode && isShadowRoot$1(rootNode)) {
+    let next = child;
+    do {
+      if (next && parent === next) {
+        return true;
+      }
+      next = next.parentNode || next.host;
+    } while (next);
+  }
+  return false;
+}
+function getInnerBoundingClientRect$1(element) {
+  const clientRect = getBoundingClientRect$1(element);
+  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
+  };
+}
+function getClientRectFromClippingParent(element, clippingParent) {
+  if (clippingParent === "viewport") {
+    return rectToClientRect$1(getViewportRect$1(element));
+  }
+  if (isElement$2(clippingParent)) {
+    return getInnerBoundingClientRect$1(clippingParent);
+  }
+  return rectToClientRect$1(getDocumentRect$1(getDocumentElement$1(element)));
+}
+function getClippingParents$1(element) {
+  const clippingParents2 = getScrollParents(getParentNode$1(element));
+  const canEscapeClipping = ["absolute", "fixed"].includes(getComputedStyle$1$1(element).position);
+  const clipperElement = canEscapeClipping && isHTMLElement$1(element) ? getOffsetParent$1(element) : element;
+  if (!isElement$2(clipperElement)) {
+    return [];
+  }
+  return clippingParents2.filter((clippingParent) => isElement$2(clippingParent) && contains$1(clippingParent, clipperElement) && getNodeName$1(clippingParent) !== "body");
+}
+function getClippingClientRect(_ref2) {
+  let {
+    element,
+    boundary,
+    rootBoundary
+  } = _ref2;
+  const mainClippingParents = boundary === "clippingParents" ? getClippingParents$1(element) : [].concat(boundary);
+  const clippingParents2 = [...mainClippingParents, rootBoundary];
+  const firstClippingParent = clippingParents2[0];
+  const clippingRect = clippingParents2.reduce((accRect, clippingParent) => {
+    const rect = getClientRectFromClippingParent(element, clippingParent);
+    accRect.top = max$1(rect.top, accRect.top);
+    accRect.right = min$1(rect.right, accRect.right);
+    accRect.bottom = min$1(rect.bottom, accRect.bottom);
+    accRect.left = max$1(rect.left, accRect.left);
+    return accRect;
+  }, getClientRectFromClippingParent(element, firstClippingParent));
+  clippingRect.width = clippingRect.right - clippingRect.left;
+  clippingRect.height = clippingRect.bottom - clippingRect.top;
+  clippingRect.x = clippingRect.left;
+  clippingRect.y = clippingRect.top;
+  return clippingRect;
+}
+const platform = {
+  getElementRects: (_ref2) => {
+    let {
+      reference: reference2,
+      floating,
+      strategy
+    } = _ref2;
+    return {
+      reference: getRectRelativeToOffsetParent(reference2, getOffsetParent$1(floating), strategy),
+      floating: __spreadProps(__spreadValues({}, getDimensions(floating)), {
+        x: 0,
+        y: 0
+      })
+    };
+  },
+  convertOffsetParentRelativeRectToViewportRelativeRect: (args) => convertOffsetParentRelativeRectToViewportRelativeRect(args),
+  getOffsetParent: (_ref2) => {
+    let {
+      element
+    } = _ref2;
+    return getOffsetParent$1(element);
+  },
+  isElement: (value) => isElement$2(value),
+  getDocumentElement: (_ref3) => {
+    let {
+      element
+    } = _ref3;
+    return getDocumentElement$1(element);
+  },
+  getClippingClientRect: (args) => getClippingClientRect(args),
+  getDimensions: (_ref4) => {
+    let {
+      element
+    } = _ref4;
+    return getDimensions(element);
+  },
+  getClientRects: (_ref5) => {
+    let {
+      element
+    } = _ref5;
+    return element.getClientRects();
+  }
+};
+const computePosition = (reference2, floating, options) => computePosition$1(reference2, floating, __spreadValues({
+  platform
+}, options));
+var __defProp2 = Object.defineProperty;
+var __defProps2 = Object.defineProperties;
+var __getOwnPropDescs2 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols2 = Object.getOwnPropertySymbols;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __propIsEnum2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp2.call(b, prop))
+      __defNormalProp2(a, prop, b[prop]);
+  if (__getOwnPropSymbols2)
+    for (var prop of __getOwnPropSymbols2(b)) {
+      if (__propIsEnum2.call(b, prop))
+        __defNormalProp2(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps2 = (a, b) => __defProps2(a, __getOwnPropDescs2(b));
+function assign(to, from) {
+  for (const key in from) {
+    if (Object.prototype.hasOwnProperty.call(from, key)) {
+      if (typeof from[key] === "object" && to[key]) {
+        assign(to[key], from[key]);
+      } else {
+        to[key] = from[key];
+      }
+    }
+  }
+}
+const config$2 = {
+  disabled: false,
+  distance: 5,
+  skidding: 0,
+  container: "body",
+  boundary: void 0,
+  instantMove: false,
+  disposeTimeout: 5e3,
+  popperTriggers: [],
+  strategy: "absolute",
+  preventOverflow: true,
+  flip: true,
+  shift: true,
+  overflowPadding: 0,
+  arrowPadding: 0,
+  arrowOverflow: true,
+  themes: {
+    tooltip: {
+      placement: "top",
+      triggers: ["hover", "focus", "touch"],
+      hideTriggers: (events2) => [...events2, "click"],
+      delay: {
+        show: 200,
+        hide: 0
+      },
+      handleResize: false,
+      html: false,
+      loadingContent: "..."
+    },
+    dropdown: {
+      placement: "bottom",
+      triggers: ["click"],
+      delay: 0,
+      handleResize: true,
+      autoHide: true
+    },
+    menu: {
+      $extend: "dropdown",
+      triggers: ["hover", "focus"],
+      popperTriggers: ["hover", "focus"],
+      delay: {
+        show: 0,
+        hide: 400
+      }
+    }
+  }
+};
+function getDefaultConfig(theme, key) {
+  let themeConfig = config$2.themes[theme] || {};
+  let value;
+  do {
+    value = themeConfig[key];
+    if (typeof value === "undefined") {
+      if (themeConfig.$extend) {
+        themeConfig = config$2.themes[themeConfig.$extend] || {};
+      } else {
+        themeConfig = null;
+        value = config$2[key];
+      }
+    } else {
+      themeConfig = null;
+    }
+  } while (themeConfig);
+  return value;
+}
+function getThemeClasses(theme) {
+  const result = [theme];
+  let themeConfig = config$2.themes[theme] || {};
+  do {
+    if (themeConfig.$extend && !themeConfig.$resetCss) {
+      result.push(themeConfig.$extend);
+      themeConfig = config$2.themes[themeConfig.$extend] || {};
+    } else {
+      themeConfig = null;
+    }
+  } while (themeConfig);
+  return result.map((c) => `v-popper--theme-${c}`);
+}
+let supportsPassive = false;
+if (typeof window !== "undefined") {
+  supportsPassive = false;
+  try {
+    const opts = Object.defineProperty({}, "passive", {
+      get() {
+        supportsPassive = true;
+      }
+    });
+    window.addEventListener("test", null, opts);
+  } catch (e) {
+  }
+}
+let isIOS = false;
+if (typeof window !== "undefined" && typeof navigator !== "undefined") {
+  isIOS = /iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream;
+}
+const placements$1 = ["auto", "top", "bottom", "left", "right"].reduce((acc, base) => acc.concat([
+  base,
+  `${base}-start`,
+  `${base}-end`
+]), []);
+const SHOW_EVENT_MAP = {
+  hover: "mouseenter",
+  focus: "focus",
+  click: "click",
+  touch: "touchstart"
+};
+const HIDE_EVENT_MAP = {
+  hover: "mouseleave",
+  focus: "blur",
+  click: "click",
+  touch: "touchend"
+};
+function removeFromArray(array, item) {
+  const index = array.indexOf(item);
+  if (index !== -1) {
+    array.splice(index, 1);
+  }
+}
+function nextFrame() {
+  return new Promise((resolve) => requestAnimationFrame(() => {
+    requestAnimationFrame(resolve);
+  }));
+}
+const shownPoppers = [];
+let hidingPopper = null;
+let Element$1 = function() {
+};
+if (typeof window !== "undefined") {
+  Element$1 = window.Element;
+}
+function defaultPropFactory(prop) {
+  return function(props) {
+    return getDefaultConfig(props.theme, prop);
+  };
+}
+var PrivatePopper = () => defineComponent({
+  name: "VPopper",
+  props: {
+    theme: {
+      type: String,
+      required: true
+    },
+    targetNodes: {
+      type: Function,
+      required: true
+    },
+    referenceNode: {
+      type: Function,
+      required: true
+    },
+    popperNode: {
+      type: Function,
+      required: true
+    },
+    shown: {
+      type: Boolean,
+      default: false
+    },
+    showGroup: {
+      type: String,
+      default: null
+    },
+    ariaId: {
+      default: null
+    },
+    disabled: {
+      type: Boolean,
+      default: defaultPropFactory("disabled")
+    },
+    positioningDisabled: {
+      type: Boolean,
+      default: defaultPropFactory("positioningDisabled")
+    },
+    placement: {
+      type: String,
+      default: defaultPropFactory("placement"),
+      validator: (value) => placements$1.includes(value)
+    },
+    delay: {
+      type: [String, Number, Object],
+      default: defaultPropFactory("delay")
+    },
+    distance: {
+      type: [Number, String],
+      default: defaultPropFactory("distance")
+    },
+    skidding: {
+      type: [Number, String],
+      default: defaultPropFactory("skidding")
+    },
+    triggers: {
+      type: Array,
+      default: defaultPropFactory("triggers")
+    },
+    showTriggers: {
+      type: [Array, Function],
+      default: defaultPropFactory("showTriggers")
+    },
+    hideTriggers: {
+      type: [Array, Function],
+      default: defaultPropFactory("hideTriggers")
+    },
+    popperTriggers: {
+      type: Array,
+      default: defaultPropFactory("popperTriggers")
+    },
+    popperShowTriggers: {
+      type: [Array, Function],
+      default: defaultPropFactory("popperShowTriggers")
+    },
+    popperHideTriggers: {
+      type: [Array, Function],
+      default: defaultPropFactory("popperHideTriggers")
+    },
+    container: {
+      type: [String, Object, Element$1, Boolean],
+      default: defaultPropFactory("container")
+    },
+    boundary: {
+      type: [String, Element$1],
+      default: defaultPropFactory("boundary")
+    },
+    strategy: {
+      type: String,
+      validator: (value) => ["absolute", "fixed"].includes(value),
+      default: defaultPropFactory("strategy")
+    },
+    autoHide: {
+      type: Boolean,
+      default: defaultPropFactory("autoHide")
+    },
+    handleResize: {
+      type: Boolean,
+      default: defaultPropFactory("handleResize")
+    },
+    instantMove: {
+      type: Boolean,
+      default: defaultPropFactory("instantMove")
+    },
+    eagerMount: {
+      type: Boolean,
+      default: defaultPropFactory("eagerMount")
+    },
+    popperClass: {
+      type: [String, Array, Object],
+      default: defaultPropFactory("popperClass")
+    },
+    computeTransformOrigin: {
+      type: Boolean,
+      default: defaultPropFactory("computeTransformOrigin")
+    },
+    autoMinSize: {
+      type: Boolean,
+      default: defaultPropFactory("autoMinSize")
+    },
+    autoMaxSize: {
+      type: Boolean,
+      default: defaultPropFactory("autoMaxSize")
+    },
+    preventOverflow: {
+      type: Boolean,
+      default: defaultPropFactory("preventOverflow")
+    },
+    overflowPadding: {
+      type: [Number, String],
+      default: defaultPropFactory("overflowPadding")
+    },
+    arrowPadding: {
+      type: [Number, String],
+      default: defaultPropFactory("arrowPadding")
+    },
+    arrowOverflow: {
+      type: Boolean,
+      default: defaultPropFactory("arrowOverflow")
+    },
+    flip: {
+      type: Boolean,
+      default: defaultPropFactory("flip")
+    },
+    shift: {
+      type: Boolean,
+      default: defaultPropFactory("shift")
+    },
+    shiftCrossAxis: {
+      type: Boolean,
+      default: defaultPropFactory("shiftCrossAxis")
+    }
+  },
+  emits: [
+    "show",
+    "hide",
+    "update:shown",
+    "apply-show",
+    "apply-hide",
+    "close-group",
+    "close-directive",
+    "auto-hide",
+    "resize",
+    "dispose"
+  ],
+  data() {
+    return {
+      isShown: false,
+      isMounted: false,
+      skipTransition: false,
+      classes: {
+        showFrom: false,
+        showTo: false,
+        hideFrom: false,
+        hideTo: true
+      },
+      result: {
+        x: 0,
+        y: 0,
+        placement: "",
+        strategy: this.strategy,
+        arrow: {
+          x: 0,
+          y: 0,
+          centerOffset: 0
+        },
+        transformOrigin: null
+      }
+    };
+  },
+  computed: {
+    popperId() {
+      return this.ariaId != null ? this.ariaId : this.randomId;
+    },
+    shouldMountContent() {
+      return this.eagerMount || this.isMounted;
+    },
+    slotData() {
+      return {
+        popperId: this.popperId,
+        isShown: this.isShown,
+        shouldMountContent: this.shouldMountContent,
+        skipTransition: this.skipTransition,
+        autoHide: this.autoHide,
+        show: this.show,
+        hide: this.hide,
+        handleResize: this.handleResize,
+        onResize: this.onResize,
+        classes: __spreadProps2(__spreadValues2({}, this.classes), {
+          popperClass: this.popperClass
+        }),
+        result: this.positioningDisabled ? null : this.result
+      };
+    }
+  },
+  watch: __spreadValues2(__spreadValues2({
+    shown: "$_autoShowHide",
+    disabled(value) {
+      if (value) {
+        this.dispose();
+      } else {
+        this.init();
+      }
+    },
+    async container() {
+      if (this.isShown) {
+        this.$_ensureTeleport();
+        await this.$_computePosition();
+      }
+    }
+  }, [
+    "triggers",
+    "positioningDisabled"
+  ].reduce((acc, prop) => {
+    acc[prop] = "$_refreshListeners";
+    return acc;
+  }, {})), [
+    "placement",
+    "distance",
+    "skidding",
+    "boundary",
+    "strategy",
+    "overflowPadding",
+    "arrowPadding",
+    "preventOverflow",
+    "shift",
+    "shiftCrossAxis",
+    "flip"
+  ].reduce((acc, prop) => {
+    acc[prop] = "$_computePosition";
+    return acc;
+  }, {})),
+  created() {
+    this.$_isDisposed = true;
+    this.randomId = `popper_${[Math.random(), Date.now()].map((n) => n.toString(36).substring(2, 10)).join("_")}`;
+  },
+  mounted() {
+    this.init();
+    this.$_detachPopperNode();
+  },
+  activated() {
+    this.$_autoShowHide();
+  },
+  deactivated() {
+    this.hide();
+  },
+  beforeUnmount() {
+    this.dispose();
+  },
+  methods: {
+    show({ event = null, skipDelay = false, force = false } = {}) {
+      if (force || !this.disabled) {
+        this.$_scheduleShow(event, skipDelay);
+        this.$emit("show");
+        this.$_showFrameLocked = true;
+        requestAnimationFrame(() => {
+          this.$_showFrameLocked = false;
+        });
+      }
+      this.$emit("update:shown", true);
+    },
+    hide({ event = null, skipDelay = false } = {}) {
+      this.$_scheduleHide(event, skipDelay);
+      this.$emit("hide");
+      this.$emit("update:shown", false);
+    },
+    init() {
+      if (!this.$_isDisposed)
+        return;
+      this.$_isDisposed = false;
+      this.isMounted = false;
+      this.$_events = [];
+      this.$_preventShow = false;
+      this.$_referenceNode = this.referenceNode();
+      this.$_targetNodes = this.targetNodes().filter((e) => e.nodeType === e.ELEMENT_NODE);
+      this.$_popperNode = this.popperNode();
+      this.$_innerNode = this.$_popperNode.querySelector(".v-popper__inner");
+      this.$_arrowNode = this.$_popperNode.querySelector(".v-popper__arrow-container");
+      this.$_swapTargetAttrs("title", "data-original-title");
+      this.$_detachPopperNode();
+      if (this.triggers.length) {
+        this.$_addEventListeners();
+      }
+      if (this.shown) {
+        this.show();
+      }
+    },
+    dispose() {
+      if (this.$_isDisposed)
+        return;
+      this.$_isDisposed = true;
+      this.$_removeEventListeners();
+      this.hide({ skipDelay: true });
+      this.$_detachPopperNode();
+      this.isMounted = false;
+      this.isShown = false;
+      this.$_swapTargetAttrs("data-original-title", "title");
+      this.$emit("dispose");
+    },
+    async onResize() {
+      if (this.isShown) {
+        await this.$_computePosition();
+        this.$emit("resize");
+      }
+    },
+    async $_computePosition() {
+      var _a;
+      if (this.$_isDisposed || this.positioningDisabled)
+        return;
+      const options2 = {
+        strategy: this.strategy,
+        middleware: []
+      };
+      if (this.distance || this.skidding) {
+        options2.middleware.push(offset$2({
+          mainAxis: this.distance,
+          crossAxis: this.skidding
+        }));
+      }
+      const isPlacementAuto = this.placement.startsWith("auto");
+      if (isPlacementAuto) {
+        options2.middleware.push(autoPlacement({
+          alignment: (_a = this.placement.split("-")[1]) != null ? _a : ""
+        }));
+      } else {
+        options2.placement = this.placement;
+      }
+      if (this.preventOverflow) {
+        if (this.shift) {
+          options2.middleware.push(shift({
+            padding: this.overflowPadding,
+            boundary: this.boundary,
+            crossAxis: this.shiftCrossAxis
+          }));
+        }
+        if (!isPlacementAuto && this.flip) {
+          options2.middleware.push(flip$2({
+            padding: this.overflowPadding,
+            boundary: this.boundary
+          }));
+        }
+      }
+      options2.middleware.push(arrow$2({
+        element: this.$_arrowNode,
+        padding: this.arrowPadding
+      }));
+      if (this.arrowOverflow) {
+        options2.middleware.push({
+          name: "arrowOverflow",
+          fn: ({ placement, rects, middlewareData }) => {
+            let overflow;
+            const { centerOffset } = middlewareData.arrow;
+            if (placement.startsWith("top") || placement.startsWith("bottom")) {
+              overflow = Math.abs(centerOffset) > rects.reference.width / 2;
+            } else {
+              overflow = Math.abs(centerOffset) > rects.reference.height / 2;
+            }
+            return {
+              data: {
+                overflow
+              }
+            };
+          }
+        });
+      }
+      if (this.autoMinSize) {
+        options2.middleware.push({
+          name: "autoMinSize",
+          fn: ({ rects, placement, middlewareData }) => {
+            var _a2;
+            if ((_a2 = middlewareData.autoMinSize) == null ? void 0 : _a2.skip) {
+              return {};
+            }
+            let width;
+            let height;
+            if (placement.startsWith("top") || placement.startsWith("bottom")) {
+              width = rects.reference.width;
+            } else {
+              height = rects.reference.height;
+            }
+            this.$_innerNode.style.minWidth = width != null ? `${width}px` : null;
+            this.$_innerNode.style.minHeight = height != null ? `${height}px` : null;
+            return {
+              data: {
+                skip: true
+              },
+              reset: {
+                rects: true
+              }
+            };
+          }
+        });
+      }
+      if (this.autoMaxSize) {
+        this.$_innerNode.style.maxWidth = null;
+        this.$_innerNode.style.maxHeight = null;
+        options2.middleware.push(size({
+          boundary: this.boundary,
+          padding: this.overflowPadding,
+          apply: ({ width, height }) => {
+            this.$_innerNode.style.maxWidth = width != null ? `${width}px` : null;
+            this.$_innerNode.style.maxHeight = height != null ? `${height}px` : null;
+          }
+        }));
+      }
+      const data = await computePosition(this.$_referenceNode, this.$_popperNode, options2);
+      Object.assign(this.result, {
+        x: data.x,
+        y: data.y,
+        placement: data.placement,
+        strategy: data.strategy,
+        arrow: __spreadValues2(__spreadValues2({}, data.middlewareData.arrow), data.middlewareData.arrowOverflow)
+      });
+    },
+    $_scheduleShow(event = null, skipDelay = false) {
+      this.$_hideInProgress = false;
+      clearTimeout(this.$_scheduleTimer);
+      if (hidingPopper && this.instantMove && hidingPopper.instantMove) {
+        hidingPopper.$_applyHide(true);
+        this.$_applyShow(true);
+        return;
+      }
+      if (skipDelay) {
+        this.$_applyShow();
+      } else {
+        this.$_scheduleTimer = setTimeout(this.$_applyShow.bind(this), this.$_computeDelay("show"));
+      }
+    },
+    $_scheduleHide(event = null, skipDelay = false) {
+      this.$_hideInProgress = true;
+      clearTimeout(this.$_scheduleTimer);
+      if (this.isShown) {
+        hidingPopper = this;
+      }
+      if (skipDelay) {
+        this.$_applyHide();
+      } else {
+        this.$_scheduleTimer = setTimeout(this.$_applyHide.bind(this), this.$_computeDelay("hide"));
+      }
+    },
+    $_computeDelay(type) {
+      const delay = this.delay;
+      return parseInt(delay && delay[type] || delay || 0);
+    },
+    async $_applyShow(skipTransition = false) {
+      clearTimeout(this.$_disposeTimer);
+      clearTimeout(this.$_scheduleTimer);
+      this.skipTransition = skipTransition;
+      if (this.isShown) {
+        return;
+      }
+      this.$_ensureTeleport();
+      await nextFrame();
+      await this.$_computePosition();
+      await this.$_applyShowEffect();
+    },
+    async $_applyShowEffect() {
+      if (this.$_hideInProgress)
+        return;
+      if (this.computeTransformOrigin) {
+        const bounds = this.$_referenceNode.getBoundingClientRect();
+        const popperWrapper = this.$_popperNode.querySelector(".v-popper__wrapper");
+        const parentBounds = popperWrapper.parentNode.getBoundingClientRect();
+        const x = bounds.x + bounds.width / 2 - (parentBounds.left + popperWrapper.offsetLeft);
+        const y = bounds.y + bounds.height / 2 - (parentBounds.top + popperWrapper.offsetTop);
+        this.result.transformOrigin = `${x}px ${y}px`;
+      }
+      this.isShown = true;
+      this.$_applyAttrsToTarget({
+        "aria-describedby": this.popperId,
+        "data-popper-shown": ""
+      });
+      const showGroup = this.showGroup;
+      if (showGroup) {
+        let popover;
+        for (let i = 0; i < shownPoppers.length; i++) {
+          popover = shownPoppers[i];
+          if (popover.showGroup !== showGroup) {
+            popover.hide();
+            popover.$emit("close-group");
+          }
+        }
+      }
+      shownPoppers.push(this);
+      this.$emit("apply-show");
+      this.classes.showFrom = true;
+      this.classes.showTo = false;
+      this.classes.hideFrom = false;
+      this.classes.hideTo = false;
+      await nextFrame();
+      this.classes.showFrom = false;
+      this.classes.showTo = true;
+    },
+    async $_applyHide(skipTransition = false) {
+      clearTimeout(this.$_scheduleTimer);
+      if (!this.isShown) {
+        return;
+      }
+      this.skipTransition = skipTransition;
+      removeFromArray(shownPoppers, this);
+      if (hidingPopper === this) {
+        hidingPopper = null;
+      }
+      this.isShown = false;
+      this.$_applyAttrsToTarget({
+        "aria-describedby": void 0,
+        "data-popper-shown": void 0
+      });
+      clearTimeout(this.$_disposeTimer);
+      const disposeTime = getDefaultConfig(this.theme, "disposeTimeout");
+      if (disposeTime !== null) {
+        this.$_disposeTimer = setTimeout(() => {
+          if (this.$_popperNode) {
+            this.$_detachPopperNode();
+            this.isMounted = false;
+          }
+        }, disposeTime);
+      }
+      this.$emit("apply-hide");
+      this.classes.showFrom = false;
+      this.classes.showTo = false;
+      this.classes.hideFrom = true;
+      this.classes.hideTo = false;
+      await nextFrame();
+      this.classes.hideFrom = false;
+      this.classes.hideTo = true;
+    },
+    $_autoShowHide() {
+      if (this.shown) {
+        this.show();
+      } else {
+        this.hide();
+      }
+    },
+    $_ensureTeleport() {
+      if (this.$_isDisposed)
+        return;
+      let container = this.container;
+      if (typeof container === "string") {
+        container = window.document.querySelector(container);
+      } else if (container === false) {
+        container = this.$_targetNodes[0].parentNode;
+      }
+      if (!container) {
+        throw new Error("No container for popover: " + this.container);
+      }
+      container.appendChild(this.$_popperNode);
+      this.isMounted = true;
+    },
+    $_addEventListeners() {
+      const addListeners2 = (targetNodes, eventType, handler) => {
+        this.$_events.push({ targetNodes, eventType, handler });
+        targetNodes.forEach((node) => node.addEventListener(eventType, handler, supportsPassive ? {
+          passive: true
+        } : void 0));
+      };
+      const addEvents = (targetNodes, eventMap, commonTriggers, customTrigger, handler) => {
+        let triggers = commonTriggers;
+        if (customTrigger != null) {
+          triggers = typeof customTrigger === "function" ? customTrigger(triggers) : customTrigger;
+        }
+        triggers.forEach((trigger) => {
+          const eventType = eventMap[trigger];
+          if (eventType) {
+            addListeners2(targetNodes, eventType, handler);
+          }
+        });
+      };
+      const handleShow = (event) => {
+        if (this.isShown && !this.$_hideInProgress) {
+          return;
+        }
+        event.usedByTooltip = true;
+        !this.$_preventShow && this.show({ event });
+      };
+      addEvents(this.$_targetNodes, SHOW_EVENT_MAP, this.triggers, this.showTriggers, handleShow);
+      addEvents([this.$_popperNode], SHOW_EVENT_MAP, this.popperTriggers, this.popperShowTriggers, handleShow);
+      const handleHide = (event) => {
+        if (event.usedByTooltip) {
+          return;
+        }
+        this.hide({ event });
+      };
+      addEvents(this.$_targetNodes, HIDE_EVENT_MAP, this.triggers, this.hideTriggers, handleHide);
+      addEvents([this.$_popperNode], HIDE_EVENT_MAP, this.popperTriggers, this.popperHideTriggers, handleHide);
+      if (!this.positioningDisabled) {
+        addListeners2([
+          ...getScrollParents(this.$_referenceNode),
+          ...getScrollParents(this.$_popperNode)
+        ], "scroll", () => {
+          this.$_computePosition();
+        });
+      }
+    },
+    $_removeEventListeners() {
+      this.$_events.forEach(({ targetNodes, eventType, handler }) => {
+        targetNodes.forEach((node) => node.removeEventListener(eventType, handler));
+      });
+      this.$_events = [];
+    },
+    $_refreshListeners() {
+      if (!this.$_isDisposed) {
+        this.$_removeEventListeners();
+        this.$_addEventListeners();
+      }
+    },
+    $_handleGlobalClose(event, touch = false) {
+      if (this.$_showFrameLocked)
+        return;
+      this.hide({ event });
+      if (event.closePopover) {
+        this.$emit("close-directive");
+      } else {
+        this.$emit("auto-hide");
+      }
+      if (touch) {
+        this.$_preventShow = true;
+        setTimeout(() => {
+          this.$_preventShow = false;
+        }, 300);
+      }
+    },
+    $_detachPopperNode() {
+      this.$_popperNode.parentNode && this.$_popperNode.parentNode.removeChild(this.$_popperNode);
+    },
+    $_swapTargetAttrs(attrFrom, attrTo) {
+      for (const el of this.$_targetNodes) {
+        const value = el.getAttribute(attrFrom);
+        if (value) {
+          el.removeAttribute(attrFrom);
+          el.setAttribute(attrTo, value);
+        }
+      }
+    },
+    $_applyAttrsToTarget(attrs) {
+      for (const el of this.$_targetNodes) {
+        for (const n in attrs) {
+          const value = attrs[n];
+          if (value == null) {
+            el.removeAttribute(n);
+          } else {
+            el.setAttribute(n, value);
+          }
+        }
+      }
+    }
+  },
+  render() {
+    return this.$slots.default(this.slotData);
+  }
+});
+if (typeof document !== "undefined" && typeof window !== "undefined") {
+  if (isIOS) {
+    document.addEventListener("touchstart", handleGlobalMousedown, supportsPassive ? {
+      passive: true,
+      capture: true
+    } : true);
+    document.addEventListener("touchend", handleGlobalTouchend, supportsPassive ? {
+      passive: true,
+      capture: true
+    } : true);
+  } else {
+    window.addEventListener("mousedown", handleGlobalMousedown, true);
+    window.addEventListener("click", handleGlobalClick, true);
+  }
+  window.addEventListener("resize", computePositionAllShownPoppers);
+}
+function handleGlobalMousedown(event) {
+  for (let i = 0; i < shownPoppers.length; i++) {
+    const popper2 = shownPoppers[i];
+    const popperContent = popper2.popperNode();
+    popper2.$_mouseDownContains = popperContent.contains(event.target);
+  }
+}
+function handleGlobalClick(event) {
+  handleGlobalClose(event);
+}
+function handleGlobalTouchend(event) {
+  handleGlobalClose(event, true);
+}
+function handleGlobalClose(event, touch = false) {
+  for (let i = 0; i < shownPoppers.length; i++) {
+    const popper2 = shownPoppers[i];
+    const popperContent = popper2.popperNode();
+    const contains2 = popper2.$_mouseDownContains || popperContent.contains(event.target);
+    requestAnimationFrame(() => {
+      if (event.closeAllPopover || event.closePopover && contains2 || popper2.autoHide && !contains2) {
+        popper2.$_handleGlobalClose(event, touch);
+      }
+    });
+  }
+}
+function computePositionAllShownPoppers(event) {
+  for (let i = 0; i < shownPoppers.length; i++) {
+    const popper2 = shownPoppers[i];
+    popper2.$_computePosition(event);
+  }
+}
+function getInternetExplorerVersion() {
+  var ua = window.navigator.userAgent;
+  var msie = ua.indexOf("MSIE ");
+  if (msie > 0) {
+    return parseInt(ua.substring(msie + 5, ua.indexOf(".", msie)), 10);
+  }
+  var trident = ua.indexOf("Trident/");
+  if (trident > 0) {
+    var rv = ua.indexOf("rv:");
+    return parseInt(ua.substring(rv + 3, ua.indexOf(".", rv)), 10);
+  }
+  var edge = ua.indexOf("Edge/");
+  if (edge > 0) {
+    return parseInt(ua.substring(edge + 5, ua.indexOf(".", edge)), 10);
+  }
+  return -1;
+}
+let isIE;
+function initCompat() {
+  if (!initCompat.init) {
+    initCompat.init = true;
+    isIE = getInternetExplorerVersion() !== -1;
+  }
+}
+var script = {
+  name: "ResizeObserver",
+  props: {
+    emitOnMount: {
+      type: Boolean,
+      default: false
+    },
+    ignoreWidth: {
+      type: Boolean,
+      default: false
+    },
+    ignoreHeight: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: [
+    "notify"
+  ],
+  mounted() {
+    initCompat();
+    nextTick$1(() => {
+      this._w = this.$el.offsetWidth;
+      this._h = this.$el.offsetHeight;
+      if (this.emitOnMount) {
+        this.emitSize();
+      }
+    });
+    const object = document.createElement("object");
+    this._resizeObject = object;
+    object.setAttribute("aria-hidden", "true");
+    object.setAttribute("tabindex", -1);
+    object.onload = this.addResizeHandlers;
+    object.type = "text/html";
+    if (isIE) {
+      this.$el.appendChild(object);
+    }
+    object.data = "about:blank";
+    if (!isIE) {
+      this.$el.appendChild(object);
+    }
+  },
+  beforeUnmount() {
+    this.removeResizeHandlers();
+  },
+  methods: {
+    compareAndNotify() {
+      if (!this.ignoreWidth && this._w !== this.$el.offsetWidth || !this.ignoreHeight && this._h !== this.$el.offsetHeight) {
+        this._w = this.$el.offsetWidth;
+        this._h = this.$el.offsetHeight;
+        this.emitSize();
+      }
+    },
+    emitSize() {
+      this.$emit("notify", {
+        width: this._w,
+        height: this._h
+      });
+    },
+    addResizeHandlers() {
+      this._resizeObject.contentDocument.defaultView.addEventListener("resize", this.compareAndNotify);
+      this.compareAndNotify();
+    },
+    removeResizeHandlers() {
+      if (this._resizeObject && this._resizeObject.onload) {
+        if (!isIE && this._resizeObject.contentDocument) {
+          this._resizeObject.contentDocument.defaultView.removeEventListener("resize", this.compareAndNotify);
+        }
+        this.$el.removeChild(this._resizeObject);
+        this._resizeObject.onload = null;
+        this._resizeObject = null;
+      }
+    }
+  }
+};
+const _withId = /* @__PURE__ */ withScopeId("data-v-b329ee4c");
+pushScopeId("data-v-b329ee4c");
+const _hoisted_1$2$1 = {
+  class: "resize-observer",
+  tabindex: "-1"
+};
+popScopeId();
+const render$3 = /* @__PURE__ */ _withId((_ctx, _cache, $props, $setup, $data, $options) => {
+  return openBlock(), createBlock("div", _hoisted_1$2$1);
+});
+script.render = render$3;
+script.__scopeId = "data-v-b329ee4c";
+script.__file = "src/components/ResizeObserver.vue";
+var PrivateThemeClass = {
+  computed: {
+    themeClass() {
+      return getThemeClasses(this.theme);
+    }
+  }
+};
+var _export_sfc$1 = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const _sfc_main$5$1 = defineComponent({
+  name: "VPopperContent",
+  components: {
+    ResizeObserver: script
+  },
+  mixins: [
+    PrivateThemeClass
+  ],
+  props: {
+    popperId: String,
+    theme: String,
+    shown: Boolean,
+    mounted: Boolean,
+    skipTransition: Boolean,
+    autoHide: Boolean,
+    handleResize: Boolean,
+    classes: Object,
+    result: Object
+  },
+  emits: [
+    "hide",
+    "resize"
+  ],
+  methods: {
+    toPx(value) {
+      if (value != null && !isNaN(value)) {
+        return `${value}px`;
+      }
+      return null;
+    }
+  }
+});
+const _hoisted_1$1$1 = ["id", "aria-hidden", "tabindex", "data-popper-placement"];
+const _hoisted_2$1$1 = {
+  ref: "inner",
+  class: "v-popper__inner"
+};
+const _hoisted_3$7 = /* @__PURE__ */ createElementVNode("div", { class: "v-popper__arrow-outer" }, null, -1);
+const _hoisted_4$5 = /* @__PURE__ */ createElementVNode("div", { class: "v-popper__arrow-inner" }, null, -1);
+const _hoisted_5$2 = [
+  _hoisted_3$7,
+  _hoisted_4$5
+];
+function _sfc_render$2(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_ResizeObserver = resolveComponent("ResizeObserver");
+  return openBlock(), createElementBlock("div", {
+    id: _ctx.popperId,
+    ref: "popover",
+    class: normalizeClass(["v-popper__popper", [
+      _ctx.themeClass,
+      _ctx.classes.popperClass,
+      {
+        "v-popper__popper--shown": _ctx.shown,
+        "v-popper__popper--hidden": !_ctx.shown,
+        "v-popper__popper--show-from": _ctx.classes.showFrom,
+        "v-popper__popper--show-to": _ctx.classes.showTo,
+        "v-popper__popper--hide-from": _ctx.classes.hideFrom,
+        "v-popper__popper--hide-to": _ctx.classes.hideTo,
+        "v-popper__popper--skip-transition": _ctx.skipTransition,
+        "v-popper__popper--arrow-overflow": _ctx.result && _ctx.result.arrow.overflow,
+        "v-popper__popper--no-positioning": !_ctx.result
+      }
+    ]]),
+    style: normalizeStyle(_ctx.result ? {
+      position: _ctx.result.strategy,
+      transform: `translate3d(${Math.round(_ctx.result.x)}px,${Math.round(_ctx.result.y)}px,0)`
+    } : void 0),
+    "aria-hidden": _ctx.shown ? "false" : "true",
+    tabindex: _ctx.autoHide ? 0 : void 0,
+    "data-popper-placement": _ctx.result ? _ctx.result.placement : void 0,
+    onKeyup: _cache[2] || (_cache[2] = withKeys(($event) => _ctx.autoHide && _ctx.$emit("hide"), ["esc"]))
+  }, [
+    createElementVNode("div", {
+      class: "v-popper__backdrop",
+      onClick: _cache[0] || (_cache[0] = ($event) => _ctx.autoHide && _ctx.$emit("hide"))
+    }),
+    createElementVNode("div", {
+      class: "v-popper__wrapper",
+      style: normalizeStyle(_ctx.result ? {
+        transformOrigin: _ctx.result.transformOrigin
+      } : void 0)
+    }, [
+      createElementVNode("div", _hoisted_2$1$1, [
+        _ctx.mounted ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+          createElementVNode("div", null, [
+            renderSlot(_ctx.$slots, "default")
+          ]),
+          _ctx.handleResize ? (openBlock(), createBlock(_component_ResizeObserver, {
+            key: 0,
+            onNotify: _cache[1] || (_cache[1] = ($event) => _ctx.$emit("resize", $event))
+          })) : createCommentVNode("", true)
+        ], 64)) : createCommentVNode("", true)
+      ], 512),
+      createElementVNode("div", {
+        ref: "arrow",
+        class: "v-popper__arrow-container",
+        style: normalizeStyle(_ctx.result ? {
+          left: _ctx.toPx(_ctx.result.arrow.x),
+          top: _ctx.toPx(_ctx.result.arrow.y)
+        } : void 0)
+      }, _hoisted_5$2, 4)
+    ], 4)
+  ], 46, _hoisted_1$1$1);
+}
+var PrivatePopperContent = /* @__PURE__ */ _export_sfc$1(_sfc_main$5$1, [["render", _sfc_render$2]]);
+var PrivatePopperMethods = {
+  methods: {
+    show(...args) {
+      return this.$refs.popper.show(...args);
+    },
+    hide(...args) {
+      return this.$refs.popper.hide(...args);
+    },
+    dispose(...args) {
+      return this.$refs.popper.dispose(...args);
+    },
+    onResize(...args) {
+      return this.$refs.popper.onResize(...args);
+    }
+  }
+};
+const _sfc_main$4$1 = defineComponent({
+  name: "VPopperWrapper",
+  components: {
+    Popper: PrivatePopper(),
+    PopperContent: PrivatePopperContent
+  },
+  mixins: [
+    PrivatePopperMethods,
+    PrivateThemeClass
+  ],
+  inheritAttrs: false,
+  props: {
+    theme: {
+      type: String,
+      default: null
+    }
+  },
+  computed: {
+    finalTheme() {
+      var _a;
+      return (_a = this.theme) != null ? _a : this.$options.vPopperTheme;
+    },
+    popperAttrs() {
+      const result = __spreadValues2({}, this.$attrs);
+      delete result.class;
+      delete result.style;
+      return result;
+    }
+  },
+  methods: {
+    getTargetNodes() {
+      return Array.from(this.$refs.reference.children).filter((node) => node !== this.$refs.popperContent.$el);
+    }
+  }
+});
+function _sfc_render$1(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_PopperContent = resolveComponent("PopperContent");
+  const _component_Popper = resolveComponent("Popper");
+  return openBlock(), createBlock(_component_Popper, mergeProps({ ref: "popper" }, _ctx.popperAttrs, {
+    theme: _ctx.finalTheme,
+    "target-nodes": _ctx.getTargetNodes,
+    "reference-node": () => _ctx.$refs.reference,
+    "popper-node": () => _ctx.$refs.popperContent.$el
+  }), {
+    default: withCtx(({
+      popperId,
+      isShown,
+      shouldMountContent,
+      skipTransition,
+      autoHide,
+      show,
+      hide: hide2,
+      handleResize,
+      onResize,
+      classes,
+      result
+    }) => [
+      createElementVNode("div", {
+        ref: "reference",
+        class: normalizeClass(["v-popper", [
+          _ctx.$attrs.class,
+          _ctx.themeClass,
+          {
+            "v-popper--shown": isShown
+          }
+        ]]),
+        style: normalizeStyle(_ctx.$attrs.style)
+      }, [
+        renderSlot(_ctx.$slots, "default", {
+          shown: isShown,
+          show,
+          hide: hide2
+        }),
+        createVNode(_component_PopperContent, {
+          ref: "popperContent",
+          "popper-id": popperId,
+          theme: _ctx.finalTheme,
+          shown: isShown,
+          mounted: shouldMountContent,
+          "skip-transition": skipTransition,
+          "auto-hide": autoHide,
+          "handle-resize": handleResize,
+          classes,
+          result,
+          onHide: hide2,
+          onResize
+        }, {
+          default: withCtx(() => [
+            renderSlot(_ctx.$slots, "popper", {
+              shown: isShown,
+              hide: hide2
+            })
+          ]),
+          _: 2
+        }, 1032, ["popper-id", "theme", "shown", "mounted", "skip-transition", "auto-hide", "handle-resize", "classes", "result", "onHide", "onResize"])
+      ], 6)
+    ]),
+    _: 3
+  }, 16, ["theme", "target-nodes", "reference-node", "popper-node"]);
+}
+var PrivatePopperWrapper = /* @__PURE__ */ _export_sfc$1(_sfc_main$4$1, [["render", _sfc_render$1]]);
+const _sfc_main$3$1 = defineComponent(__spreadProps2(__spreadValues2({}, PrivatePopperWrapper), {
+  name: "VDropdown",
+  vPopperTheme: "dropdown"
+}));
+const _sfc_main$2$1 = defineComponent(__spreadProps2(__spreadValues2({}, PrivatePopperWrapper), {
+  name: "VMenu",
+  vPopperTheme: "menu"
+}));
+const _sfc_main$1$1 = defineComponent(__spreadProps2(__spreadValues2({}, PrivatePopperWrapper), {
+  name: "VTooltip",
+  vPopperTheme: "tooltip"
+}));
+const _sfc_main$q = defineComponent({
+  name: "VTooltipDirective",
+  components: {
+    Popper: PrivatePopper(),
+    PopperContent: PrivatePopperContent
+  },
+  mixins: [
+    PrivatePopperMethods
+  ],
+  inheritAttrs: false,
+  props: {
+    theme: {
+      type: String,
+      default: "tooltip"
+    },
+    html: {
+      type: Boolean,
+      default: (props) => getDefaultConfig(props.theme, "html")
+    },
+    content: {
+      type: [String, Number, Function],
+      default: null
+    },
+    loadingContent: {
+      type: String,
+      default: (props) => getDefaultConfig(props.theme, "loadingContent")
+    }
+  },
+  data() {
+    return {
+      asyncContent: null
+    };
+  },
+  computed: {
+    isContentAsync() {
+      return typeof this.content === "function";
+    },
+    loading() {
+      return this.isContentAsync && this.asyncContent == null;
+    },
+    finalContent() {
+      if (this.isContentAsync) {
+        return this.loading ? this.loadingContent : this.asyncContent;
+      }
+      return this.content;
+    }
+  },
+  watch: {
+    content: {
+      handler() {
+        this.fetchContent(true);
+      },
+      immediate: true
+    },
+    async finalContent() {
+      await this.$nextTick();
+      this.$refs.popper.onResize();
+    }
+  },
+  created() {
+    this.$_fetchId = 0;
+  },
+  methods: {
+    fetchContent(force) {
+      if (typeof this.content === "function" && this.$_isShown && (force || !this.$_loading && this.asyncContent == null)) {
+        this.asyncContent = null;
+        this.$_loading = true;
+        const fetchId = ++this.$_fetchId;
+        const result = this.content(this);
+        if (result.then) {
+          result.then((res) => this.onResult(fetchId, res));
+        } else {
+          this.onResult(fetchId, result);
+        }
+      }
+    },
+    onResult(fetchId, result) {
+      if (fetchId !== this.$_fetchId)
+        return;
+      this.$_loading = false;
+      this.asyncContent = result;
+    },
+    onShow() {
+      this.$_isShown = true;
+      this.fetchContent();
+    },
+    onHide() {
+      this.$_isShown = false;
+    }
+  }
+});
+const _hoisted_1$l = ["innerHTML"];
+const _hoisted_2$a = ["textContent"];
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_PopperContent = resolveComponent("PopperContent");
+  const _component_Popper = resolveComponent("Popper");
+  return openBlock(), createBlock(_component_Popper, mergeProps({ ref: "popper" }, _ctx.$attrs, {
+    theme: _ctx.theme,
+    "popper-node": () => _ctx.$refs.popperContent.$el,
+    onApplyShow: _ctx.onShow,
+    onApplyHide: _ctx.onHide
+  }), {
+    default: withCtx(({
+      popperId,
+      isShown,
+      shouldMountContent,
+      skipTransition,
+      autoHide,
+      hide: hide2,
+      handleResize,
+      onResize,
+      classes,
+      result
+    }) => [
+      createVNode(_component_PopperContent, {
+        ref: "popperContent",
+        class: normalizeClass({
+          "v-popper--tooltip-loading": _ctx.loading
+        }),
+        "popper-id": popperId,
+        theme: _ctx.theme,
+        shown: isShown,
+        mounted: shouldMountContent,
+        "skip-transition": skipTransition,
+        "auto-hide": autoHide,
+        "handle-resize": handleResize,
+        classes,
+        result,
+        onHide: hide2,
+        onResize
+      }, {
+        default: withCtx(() => [
+          _ctx.html ? (openBlock(), createElementBlock("div", {
+            key: 0,
+            innerHTML: _ctx.finalContent
+          }, null, 8, _hoisted_1$l)) : (openBlock(), createElementBlock("div", {
+            key: 1,
+            textContent: toDisplayString(_ctx.finalContent)
+          }, null, 8, _hoisted_2$a))
+        ]),
+        _: 2
+      }, 1032, ["class", "popper-id", "theme", "shown", "mounted", "skip-transition", "auto-hide", "handle-resize", "classes", "result", "onHide", "onResize"])
+    ]),
+    _: 1
+  }, 16, ["theme", "popper-node", "onApplyShow", "onApplyHide"]);
+}
+var PrivateTooltipDirective = /* @__PURE__ */ _export_sfc$1(_sfc_main$q, [["render", _sfc_render]]);
+const TARGET_CLASS = "v-popper--has-tooltip";
+function getPlacement(options2, modifiers) {
+  let result = options2.placement;
+  if (!result && modifiers) {
+    for (const pos of placements$1) {
+      if (modifiers[pos]) {
+        result = pos;
+      }
+    }
+  }
+  if (!result) {
+    result = getDefaultConfig(options2.theme || "tooltip", "placement");
+  }
+  return result;
+}
+function getOptions(el, value, modifiers) {
+  let options2;
+  const type = typeof value;
+  if (type === "string") {
+    options2 = { content: value };
+  } else if (value && type === "object") {
+    options2 = value;
+  } else {
+    options2 = { content: false };
+  }
+  options2.placement = getPlacement(options2, modifiers);
+  options2.targetNodes = () => [el];
+  options2.referenceNode = () => el;
+  return options2;
+}
+let directiveApp;
+let directives;
+let uid = 0;
+function ensureDirectiveApp() {
+  if (directiveApp)
+    return;
+  directives = ref([]);
+  directiveApp = createApp({
+    name: "VTooltipDirectiveApp",
+    setup() {
+      return {
+        directives
+      };
+    },
+    render() {
+      return this.directives.map((directive) => {
+        return h(PrivateTooltipDirective, __spreadProps2(__spreadValues2({}, directive.options), {
+          shown: directive.shown.value || directive.options.shown,
+          key: directive.id
+        }));
+      });
+    },
+    devtools: {
+      hide: true
+    }
+  });
+  const mountTarget = document.createElement("div");
+  document.body.appendChild(mountTarget);
+  directiveApp.mount(mountTarget);
+}
+function createTooltip(el, value, modifiers) {
+  ensureDirectiveApp();
+  const options2 = ref(getOptions(el, value, modifiers));
+  const shown = ref(false);
+  const item = {
+    id: uid++,
+    options: options2,
+    shown
+  };
+  directives.value.push(item);
+  if (el.classList) {
+    el.classList.add(TARGET_CLASS);
+  }
+  const result = el.$_popper = {
+    options: options2,
+    item,
+    show() {
+      shown.value = true;
+    },
+    hide() {
+      shown.value = false;
+    }
+  };
+  return result;
+}
+function destroyTooltip(el) {
+  if (el.$_popper) {
+    const index = directives.value.indexOf(el.$_popper.item);
+    if (index !== -1)
+      directives.value.splice(index, 1);
+    delete el.$_popper;
+    delete el.$_popperOldShown;
+    delete el.$_popperMountTarget;
+  }
+  if (el.classList) {
+    el.classList.remove(TARGET_CLASS);
+  }
+}
+function bind(el, { value, oldValue, modifiers }) {
+  const options2 = getOptions(el, value, modifiers);
+  if (!options2.content || getDefaultConfig(options2.theme || "tooltip", "disabled")) {
+    destroyTooltip(el);
+  } else {
+    let directive;
+    if (el.$_popper) {
+      directive = el.$_popper;
+      directive.options.value = options2;
+    } else {
+      directive = createTooltip(el, value, modifiers);
+    }
+    if (typeof value.shown !== "undefined" && value.shown !== el.$_popperOldShown) {
+      el.$_popperOldShown = value.shown;
+      value.shown ? directive.show() : directive.hide();
+    }
+  }
+}
+var PrivateVTooltip = {
+  beforeMount: bind,
+  updated: bind,
+  beforeUnmount(el) {
+    destroyTooltip(el);
+  }
+};
+function addListeners(el) {
+  el.addEventListener("click", onClick);
+  el.addEventListener("touchstart", onTouchStart, supportsPassive ? {
+    passive: true
+  } : false);
+}
+function removeListeners(el) {
+  el.removeEventListener("click", onClick);
+  el.removeEventListener("touchstart", onTouchStart);
+  el.removeEventListener("touchend", onTouchEnd);
+  el.removeEventListener("touchcancel", onTouchCancel);
+}
+function onClick(event) {
+  const el = event.currentTarget;
+  event.closePopover = !el.$_vclosepopover_touch;
+  event.closeAllPopover = el.$_closePopoverModifiers && !!el.$_closePopoverModifiers.all;
+}
+function onTouchStart(event) {
+  if (event.changedTouches.length === 1) {
+    const el = event.currentTarget;
+    el.$_vclosepopover_touch = true;
+    const touch = event.changedTouches[0];
+    el.$_vclosepopover_touchPoint = touch;
+    el.addEventListener("touchend", onTouchEnd);
+    el.addEventListener("touchcancel", onTouchCancel);
+  }
+}
+function onTouchEnd(event) {
+  const el = event.currentTarget;
+  el.$_vclosepopover_touch = false;
+  if (event.changedTouches.length === 1) {
+    const touch = event.changedTouches[0];
+    const firstTouch = el.$_vclosepopover_touchPoint;
+    event.closePopover = Math.abs(touch.screenY - firstTouch.screenY) < 20 && Math.abs(touch.screenX - firstTouch.screenX) < 20;
+    event.closeAllPopover = el.$_closePopoverModifiers && !!el.$_closePopoverModifiers.all;
+  }
+}
+function onTouchCancel(event) {
+  const el = event.currentTarget;
+  el.$_vclosepopover_touch = false;
+}
+var PrivateVClosePopper = {
+  beforeMount(el, { value, modifiers }) {
+    el.$_closePopoverModifiers = modifiers;
+    if (typeof value === "undefined" || value) {
+      addListeners(el);
+    }
+  },
+  updated(el, { value, oldValue, modifiers }) {
+    el.$_closePopoverModifiers = modifiers;
+    if (value !== oldValue) {
+      if (typeof value === "undefined" || value) {
+        addListeners(el);
+      } else {
+        removeListeners(el);
+      }
+    }
+  },
+  beforeUnmount(el) {
+    removeListeners(el);
+  }
+};
+function install$1(app, options2 = {}) {
+  if (app.$_vTooltipInstalled)
+    return;
+  app.$_vTooltipInstalled = true;
+  assign(config$2, options2);
+  app.directive("tooltip", PrivateVTooltip);
+  app.directive("close-popper", PrivateVClosePopper);
+  app.component("v-tooltip", _sfc_main$1$1);
+  app.component("VTooltip", _sfc_main$1$1);
+  app.component("v-dropdown", _sfc_main$3$1);
+  app.component("VDropdown", _sfc_main$3$1);
+  app.component("v-menu", _sfc_main$2$1);
+  app.component("VMenu", _sfc_main$2$1);
+}
+const plugin = {
+  version: "2.0.0-beta.6",
+  install: install$1,
+  options: config$2
+};
 var defaultCleekOptions = {
   colors: {
     primary: "#559933",
@@ -488,9 +3143,9 @@ function insertCss(css2) {
 }
 var idPool = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
 function nextUniqueId() {
-  var size = 12;
+  var size2 = 12;
   var id = "";
-  while (size-- > 0) {
+  while (size2-- > 0) {
     id += idPool[Math.random() * 62 | 0];
   }
   return id;
@@ -694,10 +3349,10 @@ function toHex(unicode) {
   return decoded.length === 1 ? decoded[0].toString(16) : null;
 }
 function codePointAt(string, index) {
-  var size = string.length;
+  var size2 = string.length;
   var first = string.charCodeAt(index);
   var second;
-  if (first >= 55296 && first <= 56319 && size > index + 1) {
+  if (first >= 55296 && first <= 56319 && size2 > index + 1) {
     second = string.charCodeAt(index + 1);
     if (second >= 56320 && second <= 57343) {
       return (first - 55296) * 1024 + second - 56320 + 65536;
@@ -970,8 +3625,8 @@ function registerPlugins(nextPlugins, _ref2) {
       delete providers[k];
     }
   });
-  _plugins.forEach(function(plugin) {
-    var mixout8 = plugin.mixout ? plugin.mixout() : {};
+  _plugins.forEach(function(plugin2) {
+    var mixout8 = plugin2.mixout ? plugin2.mixout() : {};
     Object.keys(mixout8).forEach(function(tk) {
       if (typeof mixout8[tk] === "function") {
         obj[tk] = mixout8[tk];
@@ -985,8 +3640,8 @@ function registerPlugins(nextPlugins, _ref2) {
         });
       }
     });
-    if (plugin.hooks) {
-      var hooks8 = plugin.hooks();
+    if (plugin2.hooks) {
+      var hooks8 = plugin2.hooks();
       Object.keys(hooks8).forEach(function(hook) {
         if (!_hooks[hook]) {
           _hooks[hook] = [];
@@ -994,8 +3649,8 @@ function registerPlugins(nextPlugins, _ref2) {
         _hooks[hook].push(hooks8[hook]);
       });
     }
-    if (plugin.provides) {
-      plugin.provides(providers);
+    if (plugin2.provides) {
+      plugin2.provides(providers);
     }
   });
   return obj;
@@ -16436,14 +19091,14 @@ const _sfc_main$n = /* @__PURE__ */ defineComponent({
       }
       return list;
     });
-    function onClick(event) {
+    function onClick2(event) {
       emits("click", event);
     }
     return (_ctx, _cache) => {
       return openBlock(), createElementBlock("div", {
         class: normalizeClass(["ck-icon", unref$1(computedClass)]),
         style: normalizeStyle(unref$1(computedStyle)),
-        onClick: _cache[0] || (_cache[0] = ($event) => onClick($event))
+        onClick: _cache[0] || (_cache[0] = ($event) => onClick2($event))
       }, [
         unref$1(computediconPack) === "font-awesome" ? (openBlock(), createBlock(unref$1(FontAwesomeIcon), {
           key: 0,
@@ -16795,7 +19450,7 @@ const _sfc_main$h = /* @__PURE__ */ defineComponent({
         list.push({ width: props.width });
       return list;
     });
-    function onClick(event) {
+    function onClick2(event) {
       emits("click", event);
     }
     onMounted(() => {
@@ -16810,7 +19465,7 @@ const _sfc_main$h = /* @__PURE__ */ defineComponent({
         "aria-label": __props.title,
         disabled: __props.disabled,
         style: normalizeStyle(unref$1(computedStyle)),
-        onClick: _cache[0] || (_cache[0] = ($event) => onClick($event))
+        onClick: _cache[0] || (_cache[0] = ($event) => onClick2($event))
       }, [
         __props.icon ? (openBlock(), createBlock(ckIcon, {
           key: 0,
@@ -16907,7 +19562,7 @@ const _sfc_main$f = /* @__PURE__ */ defineComponent({
         return props.align;
       return "left";
     });
-    const onClick = (event) => {
+    const onClick2 = (event) => {
       if (props.autoSelect)
         event.target.select();
       emits("click", event);
@@ -16992,7 +19647,7 @@ const _sfc_main$f = /* @__PURE__ */ defineComponent({
           disabled: __props.disabled,
           onChange: _cache[1] || (_cache[1] = ($event) => onChange2($event)),
           onInput: _cache[2] || (_cache[2] = ($event) => onInput($event)),
-          onClick: _cache[3] || (_cache[3] = ($event) => onClick($event))
+          onClick: _cache[3] || (_cache[3] = ($event) => onClick2($event))
         }, null, 42, _hoisted_1$e), [
           [vModelDynamic, unref$1(value)]
         ]),
@@ -18386,8 +21041,8 @@ const qmStr = {
     }
     return result;
   },
-  padZeros(num, size = 2) {
-    return `000000000${num}`.substr(-size);
+  padZeros(num, size2 = 2) {
+    return `000000000${num}`.substr(-size2);
   },
   removeDiacritics(str) {
     return str.normalize("NFD").replace(/([^n\u0300-\u036f]|n(?!\u0303(?![\u0300-\u036f])))[\u0300-\u036f]+/gi, "$1").normalize();
@@ -19127,7 +21782,7 @@ const _sfc_main$4 = /* @__PURE__ */ defineComponent({
           return props.modelValue === null;
       }
     });
-    function onClick(event) {
+    function onClick2(event) {
       emits("click", event);
     }
     function onChange2(event) {
@@ -19175,7 +21830,7 @@ const _sfc_main$4 = /* @__PURE__ */ defineComponent({
           "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => isRef$1(value) ? value.value = $event : null),
           class: normalizeClass(unref$1(computedClassSelect)),
           disabled: __props.disabled,
-          onClick: _cache[2] || (_cache[2] = ($event) => onClick($event)),
+          onClick: _cache[2] || (_cache[2] = ($event) => onClick2($event)),
           onChange: _cache[3] || (_cache[3] = ($event) => onChange2($event))
         }, [
           (openBlock(true), createElementBlock(Fragment, null, renderList(unref$1(filteredOptions), (option) => {
@@ -19228,10 +21883,10 @@ const _sfc_main$3 = /* @__PURE__ */ defineComponent({
         list.push("is-squared");
       if (props.outlined)
         list.push("is-outlined");
-      let size = "s";
+      let size2 = "s";
       if (props.size === "xs" || props.size === "m" || props.size === "l")
-        size = props.size;
-      list.push(`ck-switch--size-${size}`);
+        size2 = props.size;
+      list.push(`ck-switch--size-${size2}`);
       return list;
     });
     const computedAttributes = computed$2(() => {
@@ -19618,8 +22273,8 @@ function getTrueOffsetParent(element) {
 }
 function getContainingBlock(element) {
   var isFirefox = navigator.userAgent.toLowerCase().indexOf("firefox") !== -1;
-  var isIE = navigator.userAgent.indexOf("Trident") !== -1;
-  if (isIE && isHTMLElement(element)) {
+  var isIE2 = navigator.userAgent.indexOf("Trident") !== -1;
+  if (isIE2 && isHTMLElement(element)) {
     var elementCss = getComputedStyle$1(element);
     if (elementCss.position === "fixed") {
       return null;
@@ -19650,8 +22305,8 @@ function getOffsetParent(element) {
 function getMainAxisFromPlacement(placement) {
   return ["top", "bottom"].indexOf(placement) >= 0 ? "x" : "y";
 }
-function within(min$1, value, max$1) {
-  return max(min$1, min(value, max$1));
+function within(min$12, value, max$12) {
+  return max(min$12, min(value, max$12));
 }
 function withinMaxClamp(min2, value, max2) {
   var v = within(min2, value, max2);
@@ -20132,14 +22787,14 @@ function computeAutoPlacement(state, options) {
   }
   var _options = options, placement = _options.placement, boundary = _options.boundary, rootBoundary = _options.rootBoundary, padding = _options.padding, flipVariations = _options.flipVariations, _options$allowedAutoP = _options.allowedAutoPlacements, allowedAutoPlacements = _options$allowedAutoP === void 0 ? placements : _options$allowedAutoP;
   var variation = getVariation(placement);
-  var placements$1 = variation ? flipVariations ? variationPlacements : variationPlacements.filter(function(placement2) {
+  var placements$12 = variation ? flipVariations ? variationPlacements : variationPlacements.filter(function(placement2) {
     return getVariation(placement2) === variation;
   }) : basePlacements;
-  var allowedPlacements = placements$1.filter(function(placement2) {
+  var allowedPlacements = placements$12.filter(function(placement2) {
     return allowedAutoPlacements.indexOf(placement2) >= 0;
   });
   if (allowedPlacements.length === 0) {
-    allowedPlacements = placements$1;
+    allowedPlacements = placements$12;
   }
   var overflows = allowedPlacements.reduce(function(acc, placement2) {
     acc[placement2] = detectOverflow(state, {
@@ -20407,8 +23062,8 @@ function preventOverflow(_ref2) {
     var altSide = mainAxis === "y" ? bottom : right;
     var len = mainAxis === "y" ? "height" : "width";
     var offset2 = popperOffsets2[mainAxis];
-    var min$1 = offset2 + overflow[mainSide];
-    var max$1 = offset2 - overflow[altSide];
+    var min$12 = offset2 + overflow[mainSide];
+    var max$12 = offset2 - overflow[altSide];
     var additive = tether ? -popperRect[len] / 2 : 0;
     var minLen = variation === start ? referenceRect[len] : popperRect[len];
     var maxLen = variation === start ? -popperRect[len] : -referenceRect[len];
@@ -20428,7 +23083,7 @@ function preventOverflow(_ref2) {
     var offsetModifierValue = (_offsetModifierState$ = offsetModifierState == null ? void 0 : offsetModifierState[mainAxis]) != null ? _offsetModifierState$ : 0;
     var tetherMin = offset2 + minOffset - offsetModifierValue - clientOffset;
     var tetherMax = offset2 + maxOffset - offsetModifierValue;
-    var preventedOffset = within(tether ? min(min$1, tetherMin) : min$1, offset2, tether ? max(max$1, tetherMax) : max$1);
+    var preventedOffset = within(tether ? min(min$12, tetherMin) : min$12, offset2, tether ? max(max$12, tetherMax) : max$12);
     popperOffsets2[mainAxis] = preventedOffset;
     data[mainAxis] = preventedOffset - offset2;
   }
@@ -20973,8 +23628,8 @@ var setDefaultProps = function setDefaultProps2(partialProps) {
 };
 function getExtendedPassedProps(passedProps) {
   var plugins2 = passedProps.plugins || [];
-  var pluginProps2 = plugins2.reduce(function(acc, plugin) {
-    var name = plugin.name, defaultValue = plugin.defaultValue;
+  var pluginProps2 = plugins2.reduce(function(acc, plugin2) {
+    var name = plugin2.name, defaultValue = plugin2.defaultValue;
     if (name) {
       var _name;
       acc[name] = passedProps[name] !== void 0 ? passedProps[name] : (_name = defaultProps[name]) != null ? _name : defaultValue;
@@ -21176,11 +23831,11 @@ function createTippy(reference2, passedProps) {
   instance.popper = popper2;
   reference2._tippy = instance;
   popper2._tippy = instance;
-  var pluginsHooks = plugins2.map(function(plugin) {
-    return plugin.fn(instance);
+  var pluginsHooks = plugins2.map(function(plugin2) {
+    return plugin2.fn(instance);
   });
   var hasAriaExpanded = reference2.hasAttribute("aria-expanded");
-  addListeners();
+  addListeners2();
   handleAriaExpandedAttribute();
   handleStyles();
   invokeHook("onCreate", [instance]);
@@ -21324,21 +23979,21 @@ function createTippy(reference2, passedProps) {
   function onTouchMove() {
     didTouchMove = true;
   }
-  function onTouchStart() {
+  function onTouchStart2() {
     didTouchMove = false;
   }
   function addDocumentPress() {
     var doc = getDocument();
     doc.addEventListener("mousedown", onDocumentPress, true);
     doc.addEventListener("touchend", onDocumentPress, TOUCH_OPTIONS);
-    doc.addEventListener("touchstart", onTouchStart, TOUCH_OPTIONS);
+    doc.addEventListener("touchstart", onTouchStart2, TOUCH_OPTIONS);
     doc.addEventListener("touchmove", onTouchMove, TOUCH_OPTIONS);
   }
   function removeDocumentPress() {
     var doc = getDocument();
     doc.removeEventListener("mousedown", onDocumentPress, true);
     doc.removeEventListener("touchend", onDocumentPress, TOUCH_OPTIONS);
-    doc.removeEventListener("touchstart", onTouchStart, TOUCH_OPTIONS);
+    doc.removeEventListener("touchstart", onTouchStart2, TOUCH_OPTIONS);
     doc.removeEventListener("touchmove", onTouchMove, TOUCH_OPTIONS);
   }
   function onTransitionedOut(duration, callback) {
@@ -21381,7 +24036,7 @@ function createTippy(reference2, passedProps) {
       });
     });
   }
-  function addListeners() {
+  function addListeners2() {
     if (getIsCustomTouchBehavior()) {
       on("touchstart", onTrigger2, {
         passive: true
@@ -21408,7 +24063,7 @@ function createTippy(reference2, passedProps) {
       }
     });
   }
-  function removeListeners() {
+  function removeListeners2() {
     listeners.forEach(function(_ref2) {
       var node = _ref2.node, eventType = _ref2.eventType, handler = _ref2.handler, options = _ref2.options;
       node.removeEventListener(eventType, handler, options);
@@ -21646,13 +24301,13 @@ function createTippy(reference2, passedProps) {
       return;
     }
     invokeHook("onBeforeUpdate", [instance, partialProps]);
-    removeListeners();
+    removeListeners2();
     var prevProps = instance.props;
     var nextProps = evaluateProps(reference2, Object.assign({}, prevProps, removeUndefinedProps(partialProps), {
       ignoreAttributes: true
     }));
     instance.props = nextProps;
-    addListeners();
+    addListeners2();
     if (prevProps.interactiveDebounce !== nextProps.interactiveDebounce) {
       cleanupInteractiveMouseListeners();
       debouncedOnMouseMove = debounce(onMouseMove, nextProps.interactiveDebounce);
@@ -21808,7 +24463,7 @@ function createTippy(reference2, passedProps) {
     }
     instance.clearDelayTimeouts();
     instance.unmount();
-    removeListeners();
+    removeListeners2();
     delete reference2._tippy;
     instance.state.isDestroyed = true;
     invokeHook("onDestroy", [instance]);
@@ -22067,6 +24722,7 @@ function getCleekOptions(userOptions) {
 }
 const install = function installCleek(app, options) {
   app.config.globalProperties.$cleekOptions = getCleekOptions(options);
+  app.use(plugin);
   Object.entries(components).forEach(([componentName, component]) => {
     app.component(componentName, component);
   });