@histoire/controls 0.1.5 → 0.2.2

package/dist/index.es.js

@@ -17,24 +17,2645 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-import { defineComponent, ref, computed, watch, openBlock, createElementBlock, withKeys, withModifiers, createElementVNode, normalizeClass, unref, renderSlot, normalizeStyle, createCommentVNode, mergeProps } from "vue";
-const _hoisted_1$1 = { class: "htw-text-white htw-w-[16px] htw-h-[16px] htw-relative" };
-const _hoisted_2$1 = {
+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, openBlock, createBlock, withScopeId, resolveComponent, createElementBlock, normalizeClass, normalizeStyle, withKeys, createElementVNode, Fragment, renderSlot, createCommentVNode, mergeProps, withCtx, createVNode, ref, createApp, h, toDisplayString, withDirectives, createTextVNode, unref, computed, watch, withModifiers, onUnmounted, isRef, vModelText } from "vue";
+function getBasePlacement(placement) {
+  return placement.split("-")[0];
+}
+function getAlignment(placement) {
+  return placement.split("-")[1];
+}
+function getMainAxisFromPlacement(placement) {
+  return ["top", "bottom"].includes(getBasePlacement(placement)) ? "x" : "y";
+}
+function getLengthFromAxis(axis) {
+  return axis === "y" ? "height" : "width";
+}
+function computeCoordsFromPlacement(_ref) {
+  let {
+    reference,
+    floating,
+    placement
+  } = _ref;
+  const commonX = reference.x + reference.width / 2 - floating.width / 2;
+  const commonY = reference.y + reference.height / 2 - floating.height / 2;
+  let coords;
+  switch (getBasePlacement(placement)) {
+    case "top":
+      coords = {
+        x: commonX,
+        y: reference.y - floating.height
+      };
+      break;
+    case "bottom":
+      coords = {
+        x: commonX,
+        y: reference.y + reference.height
+      };
+      break;
+    case "right":
+      coords = {
+        x: reference.x + reference.width,
+        y: commonY
+      };
+      break;
+    case "left":
+      coords = {
+        x: reference.x - floating.width,
+        y: commonY
+      };
+      break;
+    default:
+      coords = {
+        x: reference.x,
+        y: reference.y
+      };
+  }
+  const mainAxis = getMainAxisFromPlacement(placement);
+  const length = getLengthFromAxis(mainAxis);
+  switch (getAlignment(placement)) {
+    case "start":
+      coords[mainAxis] = coords[mainAxis] - (reference[length] / 2 - floating[length] / 2);
+      break;
+    case "end":
+      coords[mainAxis] = coords[mainAxis] + (reference[length] / 2 - floating[length] / 2);
+      break;
+  }
+  return coords;
+}
+const computePosition$1 = async (reference, floating, config2) => {
+  const {
+    placement = "bottom",
+    strategy = "absolute",
+    middleware = [],
+    platform: platform2
+  } = config2;
+  let rects = await platform2.getElementRects({
+    reference,
+    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
+    } = middleware[i];
+    const {
+      x: nextX,
+      y: nextY,
+      data,
+      reset
+    } = await fn({
+      x,
+      y,
+      initialPlacement: placement,
+      placement: statefulPlacement,
+      strategy,
+      middlewareData,
+      rects,
+      platform: platform2,
+      elements: {
+        reference,
+        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,
+            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(rect) {
+  return __spreadProps(__spreadValues({}, rect), {
+    top: rect.y,
+    left: rect.x,
+    right: rect.x + rect.width,
+    bottom: rect.y + rect.height
+  });
+}
+async function detectOverflow(middlewareArguments, options) {
+  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(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$1 = Math.min;
+const max$1 = Math.max;
+function within(min$1$1, value, max$1$1) {
+  return max$1(min$1$1, min$1(value, max$1$1));
+}
+const arrow = (options) => ({
+  name: "arrow",
+  options,
+  async fn(middlewareArguments) {
+    const {
+      element,
+      padding = 0
+    } = options != null ? options : {};
+    const {
+      x,
+      y,
+      placement,
+      rects,
+      platform: platform2
+    } = middlewareArguments;
+    if (element == null) {
+      return {};
+    }
+    const paddingObject = getSideObjectFromPadding(padding);
+    const coords = {
+      x,
+      y
+    };
+    const basePlacement = getBasePlacement(placement);
+    const axis = getMainAxisFromPlacement(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(min2, center, max2);
+    return {
+      data: {
+        [axis]: offset2,
+        centerOffset: center - offset2
+      }
+    };
+  }
+});
+const hash$1 = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+};
+function getOppositePlacement(placement) {
+  return placement.replace(/left|right|bottom|top/g, (matched) => hash$1[matched]);
+}
+function getAlignmentSides(placement, rects) {
+  const isStart = getAlignment(placement) === "start";
+  const mainAxis = getMainAxisFromPlacement(placement);
+  const length = getLengthFromAxis(mainAxis);
+  let mainAlignmentSide = mainAxis === "x" ? isStart ? "right" : "left" : isStart ? "bottom" : "top";
+  if (rects.reference[length] > rects.floating[length]) {
+    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
+  }
+  return {
+    main: mainAlignmentSide,
+    cross: getOppositePlacement(mainAlignmentSide)
+  };
+}
+const hash = {
+  start: "end",
+  end: "start"
+};
+function getOppositeAlignmentPlacement(placement) {
+  return placement.replace(/start|end/g, (matched) => hash[matched]);
+}
+const basePlacements = ["top", "right", "bottom", "left"];
+const allPlacements = /* @__PURE__ */ basePlacements.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(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(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,
+        cross
+      } = getAlignmentSides(currentPlacement, rects);
+      if (placement !== currentPlacement) {
+        return {
+          x,
+          y,
+          reset: {
+            placement: placements2[0]
+          }
+        };
+      }
+      const currentOverflows = [overflow[getBasePlacement(currentPlacement)], overflow[main], 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((_ref) => {
+        let {
+          overflows
+        } = _ref;
+        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(placement);
+  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
+}
+const flip = 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(placement);
+      const isBasePlacement = basePlacement === initialPlacement;
+      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
+      const placements2 = [initialPlacement, ...fallbackPlacements];
+      const overflow = await detectOverflow(middlewareArguments, detectOverflowOptions);
+      const overflows = [];
+      let overflowsData = ((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.overflows) || [];
+      if (checkMainAxis) {
+        overflows.push(overflow[basePlacement]);
+      }
+      if (checkCrossAxis) {
+        const {
+          main,
+          cross
+        } = getAlignmentSides(placement, rects);
+        overflows.push(overflow[main], 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(_ref) {
+  let {
+    placement,
+    rects,
+    value
+  } = _ref;
+  const basePlacement = getBasePlacement(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(basePlacement) === "x" ? {
+    x: crossAxis,
+    y: mainAxis * multiplier
+  } : {
+    x: mainAxis * multiplier,
+    y: crossAxis
+  };
+}
+const offset = 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: (_ref) => {
+            let {
+              x: x2,
+              y: y2
+            } = _ref;
+            return {
+              x: x2,
+              y: y2
+            };
+          }
+        }
+      } = _a, detectOverflowOptions = __objRest(_a, [
+        "mainAxis",
+        "crossAxis",
+        "limiter"
+      ]);
+      const coords = {
+        x,
+        y
+      };
+      const overflow = await detectOverflow(middlewareArguments, detectOverflowOptions);
+      const mainAxis = getMainAxisFromPlacement(getBasePlacement(placement));
+      const crossAxis = getCrossAxis(mainAxis);
+      let mainAxisCoord = coords[mainAxis];
+      let crossAxisCoord = coords[crossAxis];
+      if (checkMainAxis) {
+        const minSide = mainAxis === "y" ? "top" : "left";
+        const maxSide = mainAxis === "y" ? "bottom" : "right";
+        const min2 = mainAxisCoord + overflow[minSide];
+        const max2 = mainAxisCoord - overflow[maxSide];
+        mainAxisCoord = within(min2, mainAxisCoord, max2);
+      }
+      if (checkCrossAxis) {
+        const minSide = crossAxis === "y" ? "top" : "left";
+        const maxSide = crossAxis === "y" ? "bottom" : "right";
+        const min2 = crossAxisCoord + overflow[minSide];
+        const max2 = crossAxisCoord - overflow[maxSide];
+        crossAxisCoord = within(min2, crossAxisCoord, max2);
+      }
+      const limitedCoords = limiter.fn(__spreadProps(__spreadValues({}, middlewareArguments), {
+        [mainAxis]: mainAxisCoord,
+        [crossAxis]: crossAxisCoord
+      }));
+      return __spreadProps(__spreadValues({}, limitedCoords), {
+        data: {
+          x: limitedCoords.x - 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(middlewareArguments, detectOverflowOptions);
+      const basePlacement = getBasePlacement(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$1(overflow.left, 0);
+      const xMax = max$1(overflow.right, 0);
+      const yMin = max$1(overflow.top, 0);
+      const yMax = max$1(overflow.bottom, 0);
+      const dimensions = {
+        height: rects.floating.height - (["left", "right"].includes(placement) ? 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max$1(overflow.top, overflow.bottom)) : overflow[heightSide]),
+        width: rects.floating.width - (["top", "bottom"].includes(placement) ? 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max$1(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(node) {
+  if (node == null) {
+    return window;
+  }
+  if (!isWindow(node)) {
+    const ownerDocument = node.ownerDocument;
+    return ownerDocument ? ownerDocument.defaultView || window : window;
+  }
+  return node;
+}
+function getComputedStyle$1(element) {
+  return getWindow(element).getComputedStyle(element);
+}
+function getNodeName(node) {
+  return isWindow(node) ? "" : node ? (node.nodeName || "").toLowerCase() : "";
+}
+function isHTMLElement(value) {
+  return value instanceof getWindow(value).HTMLElement;
+}
+function isElement(value) {
+  return value instanceof getWindow(value).Element;
+}
+function isNode(value) {
+  return value instanceof getWindow(value).Node;
+}
+function isShadowRoot(node) {
+  const OwnElement = getWindow(node).ShadowRoot;
+  return node instanceof OwnElement || node instanceof ShadowRoot;
+}
+function isScrollParent(element) {
+  const {
+    overflow,
+    overflowX,
+    overflowY
+  } = getComputedStyle$1(element);
+  return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
+}
+function isTableElement(element) {
+  return ["table", "td", "th"].includes(getNodeName(element));
+}
+function isContainingBlock(element) {
+  const isFirefox = navigator.userAgent.toLowerCase().includes("firefox");
+  const css = getComputedStyle$1(element);
+  return css.transform !== "none" || css.perspective !== "none" || css.contain === "paint" || ["transform", "perspective"].includes(css.willChange) || isFirefox && css.willChange === "filter" || isFirefox && (css.filter ? css.filter !== "none" : false);
+}
+const min = Math.min;
+const max = Math.max;
+const round = Math.round;
+function getBoundingClientRect(element, includeScale) {
+  if (includeScale === void 0) {
+    includeScale = false;
+  }
+  const clientRect = element.getBoundingClientRect();
+  let scaleX = 1;
+  let scaleY = 1;
+  if (includeScale && isHTMLElement(element)) {
+    scaleX = element.offsetWidth > 0 ? round(clientRect.width) / element.offsetWidth || 1 : 1;
+    scaleY = element.offsetHeight > 0 ? round(clientRect.height) / element.offsetHeight || 1 : 1;
+  }
+  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(node) {
+  return ((isNode(node) ? node.ownerDocument : node.document) || window.document).documentElement;
+}
+function getNodeScroll(element) {
+  if (isWindow(element)) {
+    return {
+      scrollLeft: element.pageXOffset,
+      scrollTop: element.pageYOffset
+    };
+  }
+  return {
+    scrollLeft: element.scrollLeft,
+    scrollTop: element.scrollTop
+  };
+}
+function getWindowScrollBarX(element) {
+  return getBoundingClientRect(getDocumentElement(element)).left + getNodeScroll(element).scrollLeft;
+}
+function isScaled(element) {
+  const rect = getBoundingClientRect(element);
+  return round(rect.width) !== element.offsetWidth || round(rect.height) !== element.offsetHeight;
+}
+function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
+  const isOffsetParentAnElement = isHTMLElement(offsetParent);
+  const documentElement = getDocumentElement(offsetParent);
+  const rect = getBoundingClientRect(element, isOffsetParentAnElement && isScaled(offsetParent));
+  let scroll = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const offsets = {
+    x: 0,
+    y: 0
+  };
+  if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== "fixed") {
+    if (getNodeName(offsetParent) !== "body" || isScrollParent(documentElement)) {
+      scroll = getNodeScroll(offsetParent);
+    }
+    if (isHTMLElement(offsetParent)) {
+      const offsetRect = getBoundingClientRect(offsetParent, true);
+      offsets.x = offsetRect.x + offsetParent.clientLeft;
+      offsets.y = offsetRect.y + offsetParent.clientTop;
+    } else if (documentElement) {
+      offsets.x = getWindowScrollBarX(documentElement);
+    }
+  }
+  return {
+    x: rect.left + scroll.scrollLeft - offsets.x,
+    y: rect.top + scroll.scrollTop - offsets.y,
+    width: rect.width,
+    height: rect.height
+  };
+}
+function getParentNode(node) {
+  if (getNodeName(node) === "html") {
+    return node;
+  }
+  return node.assignedSlot || node.parentNode || (isShadowRoot(node) ? node.host : null) || getDocumentElement(node);
+}
+function getTrueOffsetParent(element) {
+  if (!isHTMLElement(element) || getComputedStyle(element).position === "fixed") {
+    return null;
+  }
+  return element.offsetParent;
+}
+function getContainingBlock(element) {
+  let currentNode = getParentNode(element);
+  while (isHTMLElement(currentNode) && !["html", "body"].includes(getNodeName(currentNode))) {
+    if (isContainingBlock(currentNode)) {
+      return currentNode;
+    } else {
+      currentNode = currentNode.parentNode;
+    }
+  }
+  return null;
+}
+function getOffsetParent(element) {
+  const window2 = getWindow(element);
+  let offsetParent = getTrueOffsetParent(element);
+  while (offsetParent && isTableElement(offsetParent) && getComputedStyle(offsetParent).position === "static") {
+    offsetParent = getTrueOffsetParent(offsetParent);
+  }
+  if (offsetParent && (getNodeName(offsetParent) === "html" || getNodeName(offsetParent) === "body" && getComputedStyle(offsetParent).position === "static" && !isContainingBlock(offsetParent))) {
+    return window2;
+  }
+  return offsetParent || getContainingBlock(element) || window2;
+}
+function getDimensions(element) {
+  return {
+    width: element.offsetWidth,
+    height: element.offsetHeight
+  };
+}
+function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
+  let {
+    rect,
+    offsetParent,
+    strategy
+  } = _ref;
+  const isOffsetParentAnElement = isHTMLElement(offsetParent);
+  const documentElement = getDocumentElement(offsetParent);
+  if (offsetParent === documentElement) {
+    return rect;
+  }
+  let scroll = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const offsets = {
+    x: 0,
+    y: 0
+  };
+  if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== "fixed") {
+    if (getNodeName(offsetParent) !== "body" || isScrollParent(documentElement)) {
+      scroll = getNodeScroll(offsetParent);
+    }
+    if (isHTMLElement(offsetParent)) {
+      const offsetRect = getBoundingClientRect(offsetParent, true);
+      offsets.x = offsetRect.x + offsetParent.clientLeft;
+      offsets.y = offsetRect.y + offsetParent.clientTop;
+    }
+  }
+  return __spreadProps(__spreadValues({}, rect), {
+    x: rect.x - scroll.scrollLeft + offsets.x,
+    y: rect.y - scroll.scrollTop + offsets.y
+  });
+}
+function getViewportRect(element) {
+  const win = getWindow(element);
+  const html = getDocumentElement(element);
+  const visualViewport = win.visualViewport;
+  let width = html.clientWidth;
+  let height = html.clientHeight;
+  let x = 0;
+  let y = 0;
+  if (visualViewport) {
+    width = visualViewport.width;
+    height = visualViewport.height;
+    if (Math.abs(win.innerWidth / visualViewport.scale - visualViewport.width) < 0.01) {
+      x = visualViewport.offsetLeft;
+      y = visualViewport.offsetTop;
+    }
+  }
+  return {
+    width,
+    height,
+    x,
+    y
+  };
+}
+function getDocumentRect(element) {
+  var _element$ownerDocumen;
+  const html = getDocumentElement(element);
+  const scroll = getNodeScroll(element);
+  const body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body;
+  const width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
+  const height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
+  let x = -scroll.scrollLeft + getWindowScrollBarX(element);
+  const y = -scroll.scrollTop;
+  if (getComputedStyle$1(body || html).direction === "rtl") {
+    x += max(html.clientWidth, body ? body.clientWidth : 0) - width;
+  }
+  return {
+    width,
+    height,
+    x,
+    y
+  };
+}
+function getScrollParent(node) {
+  if (["html", "body", "#document"].includes(getNodeName(node))) {
+    return node.ownerDocument.body;
+  }
+  if (isHTMLElement(node) && isScrollParent(node)) {
+    return node;
+  }
+  return getScrollParent(getParentNode(node));
+}
+function getScrollParents(node, list) {
+  var _node$ownerDocument;
+  if (list === void 0) {
+    list = [];
+  }
+  const scrollParent = getScrollParent(node);
+  const isBody = scrollParent === ((_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.body);
+  const win = getWindow(scrollParent);
+  const target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent;
+  const updatedList = list.concat(target);
+  return isBody ? updatedList : updatedList.concat(getScrollParents(getParentNode(target)));
+}
+function contains(parent, child) {
+  const rootNode = child.getRootNode == null ? void 0 : child.getRootNode();
+  if (parent.contains(child)) {
+    return true;
+  } else if (rootNode && isShadowRoot(rootNode)) {
+    let next = child;
+    do {
+      if (next && parent === next) {
+        return true;
+      }
+      next = next.parentNode || next.host;
+    } while (next);
+  }
+  return false;
+}
+function getInnerBoundingClientRect(element) {
+  const clientRect = getBoundingClientRect(element);
+  const top = clientRect.top + element.clientTop;
+  const left = clientRect.left + element.clientLeft;
+  return {
+    top,
+    left,
+    x: left,
+    y: top,
+    right: left + element.clientWidth,
+    bottom: top + element.clientHeight,
+    width: element.clientWidth,
+    height: element.clientHeight
+  };
+}
+function getClientRectFromClippingParent(element, clippingParent) {
+  if (clippingParent === "viewport") {
+    return rectToClientRect(getViewportRect(element));
+  }
+  if (isElement(clippingParent)) {
+    return getInnerBoundingClientRect(clippingParent);
+  }
+  return rectToClientRect(getDocumentRect(getDocumentElement(element)));
+}
+function getClippingParents(element) {
+  const clippingParents = getScrollParents(getParentNode(element));
+  const canEscapeClipping = ["absolute", "fixed"].includes(getComputedStyle$1(element).position);
+  const clipperElement = canEscapeClipping && isHTMLElement(element) ? getOffsetParent(element) : element;
+  if (!isElement(clipperElement)) {
+    return [];
+  }
+  return clippingParents.filter((clippingParent) => isElement(clippingParent) && contains(clippingParent, clipperElement) && getNodeName(clippingParent) !== "body");
+}
+function getClippingClientRect(_ref) {
+  let {
+    element,
+    boundary,
+    rootBoundary
+  } = _ref;
+  const mainClippingParents = boundary === "clippingParents" ? getClippingParents(element) : [].concat(boundary);
+  const clippingParents = [...mainClippingParents, rootBoundary];
+  const firstClippingParent = clippingParents[0];
+  const clippingRect = clippingParents.reduce((accRect, clippingParent) => {
+    const rect = getClientRectFromClippingParent(element, clippingParent);
+    accRect.top = max(rect.top, accRect.top);
+    accRect.right = min(rect.right, accRect.right);
+    accRect.bottom = min(rect.bottom, accRect.bottom);
+    accRect.left = max(rect.left, accRect.left);
+    return accRect;
+  }, 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: (_ref) => {
+    let {
+      reference,
+      floating,
+      strategy
+    } = _ref;
+    return {
+      reference: getRectRelativeToOffsetParent(reference, getOffsetParent(floating), strategy),
+      floating: __spreadProps(__spreadValues({}, getDimensions(floating)), {
+        x: 0,
+        y: 0
+      })
+    };
+  },
+  convertOffsetParentRelativeRectToViewportRelativeRect: (args) => convertOffsetParentRelativeRectToViewportRelativeRect(args),
+  getOffsetParent: (_ref2) => {
+    let {
+      element
+    } = _ref2;
+    return getOffsetParent(element);
+  },
+  isElement: (value) => isElement(value),
+  getDocumentElement: (_ref3) => {
+    let {
+      element
+    } = _ref3;
+    return getDocumentElement(element);
+  },
+  getClippingClientRect: (args) => getClippingClientRect(args),
+  getDimensions: (_ref4) => {
+    let {
+      element
+    } = _ref4;
+    return getDimensions(element);
+  },
+  getClientRects: (_ref5) => {
+    let {
+      element
+    } = _ref5;
+    return element.getClientRects();
+  }
+};
+const computePosition = (reference, floating, options) => computePosition$1(reference, 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));
+const config = {
+  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: (events) => [...events, "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.themes[theme] || {};
+  let value;
+  do {
+    value = themeConfig[key];
+    if (typeof value === "undefined") {
+      if (themeConfig.$extend) {
+        themeConfig = config.themes[themeConfig.$extend] || {};
+      } else {
+        themeConfig = null;
+        value = config[key];
+      }
+    } else {
+      themeConfig = null;
+    }
+  } while (themeConfig);
+  return value;
+}
+function getThemeClasses(theme) {
+  const result = [theme];
+  let themeConfig = config.themes[theme] || {};
+  do {
+    if (themeConfig.$extend && !themeConfig.$resetCss) {
+      result.push(themeConfig.$extend);
+      themeConfig = config.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 = ["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 = function() {
+};
+if (typeof window !== "undefined") {
+  Element = 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.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, Boolean],
+      default: defaultPropFactory("container")
+    },
+    boundary: {
+      type: [String, Element],
+      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")
+    },
+    autoSize: {
+      type: [Boolean, String],
+      default: defaultPropFactory("autoSize")
+    },
+    autoMaxSize: {
+      type: Boolean,
+      default: defaultPropFactory("autoMaxSize")
+    },
+    autoBoundaryMaxSize: {
+      type: Boolean,
+      default: defaultPropFactory("autoBoundaryMaxSize")
+    },
+    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("_")}`;
+    if (this.autoMinSize) {
+      console.warn('[floating-vue] `autoMinSize` option is deprecated. Use `autoSize="min"` instead.');
+    }
+    if (this.autoMaxSize) {
+      console.warn("[floating-vue] `autoMaxSize` option is deprecated. Use `autoBoundaryMaxSize` instead.");
+    }
+  },
+  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 } = {}) {
+      if (this.$_hideInProgress)
+        return;
+      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({
+          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({
+            padding: this.overflowPadding,
+            boundary: this.boundary
+          }));
+        }
+      }
+      options2.middleware.push(arrow({
+        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 || this.autoSize) {
+        const autoSize = this.autoSize ? this.autoSize : this.autoMinSize ? "min" : null;
+        options2.middleware.push({
+          name: "autoSize",
+          fn: ({ rects, placement, middlewareData }) => {
+            var _a2;
+            if ((_a2 = middlewareData.autoSize) == 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[autoSize === "min" ? "minWidth" : autoSize === "max" ? "maxWidth" : "width"] = width != null ? `${width}px` : null;
+            this.$_innerNode.style[autoSize === "min" ? "minHeight" : autoSize === "max" ? "maxHeight" : "height"] = height != null ? `${height}px` : null;
+            return {
+              data: {
+                skip: true
+              },
+              reset: {
+                rects: true
+              }
+            };
+          }
+        });
+      }
+      if (this.autoMaxSize || this.autoBoundaryMaxSize) {
+        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();
+      if (!this.positioningDisabled) {
+        this.$_registerEventListeners([
+          ...getScrollParents(this.$_referenceNode),
+          ...getScrollParents(this.$_popperNode)
+        ], "scroll", () => {
+          this.$_computePosition();
+        });
+      }
+    },
+    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.$_removeEventListeners("scroll");
+      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 handleShow = (event) => {
+        if (this.isShown && !this.$_hideInProgress) {
+          return;
+        }
+        event.usedByTooltip = true;
+        !this.$_preventShow && this.show({ event });
+      };
+      this.$_registerTriggerListeners(this.$_targetNodes, SHOW_EVENT_MAP, this.triggers, this.showTriggers, handleShow);
+      this.$_registerTriggerListeners([this.$_popperNode], SHOW_EVENT_MAP, this.popperTriggers, this.popperShowTriggers, handleShow);
+      const handleHide = (event) => {
+        if (event.usedByTooltip) {
+          return;
+        }
+        this.hide({ event });
+      };
+      this.$_registerTriggerListeners(this.$_targetNodes, HIDE_EVENT_MAP, this.triggers, this.hideTriggers, handleHide);
+      this.$_registerTriggerListeners([this.$_popperNode], HIDE_EVENT_MAP, this.popperTriggers, this.popperHideTriggers, handleHide);
+    },
+    $_registerEventListeners(targetNodes, eventType, handler) {
+      this.$_events.push({ targetNodes, eventType, handler });
+      targetNodes.forEach((node) => node.addEventListener(eventType, handler, supportsPassive ? {
+        passive: true
+      } : void 0));
+    },
+    $_registerTriggerListeners(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) {
+          this.$_registerEventListeners(targetNodes, eventType, handler);
+        }
+      });
+    },
+    $_removeEventListeners(filterEventType) {
+      const newList = [];
+      this.$_events.forEach((listener) => {
+        const { targetNodes, eventType, handler } = listener;
+        if (!filterEventType || filterEventType === eventType) {
+          targetNodes.forEach((node) => node.removeEventListener(eventType, handler));
+        } else {
+          newList.push(listener);
+        }
+      });
+      this.$_events = newList;
+    },
+    $_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 popper = shownPoppers[i];
+    try {
+      const popperContent = popper.popperNode();
+      popper.$_mouseDownContains = popperContent.contains(event.target);
+    } catch (e) {
+    }
+  }
+}
+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 popper = shownPoppers[i];
+    try {
+      const popperContent = popper.popperNode();
+      const contains2 = popper.$_mouseDownContains || popperContent.contains(event.target);
+      requestAnimationFrame(() => {
+        if (event.closeAllPopover || event.closePopover && contains2 || popper.autoHide && !contains2) {
+          popper.$_handleGlobalClose(event, touch);
+        }
+      });
+    } catch (e) {
+    }
+  }
+}
+function computePositionAllShownPoppers(event) {
+  for (let i = 0; i < shownPoppers.length; i++) {
+    const popper = shownPoppers[i];
+    popper.$_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(() => {
+      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 = /* @__PURE__ */ _withId((_ctx, _cache, $props, $setup, $data, $options) => {
+  return openBlock(), createBlock("div", _hoisted_1$2$1);
+});
+script.render = render;
+script.__scopeId = "data-v-b329ee4c";
+script.__file = "src/components/ResizeObserver.vue";
+var PrivateThemeClass = (prop = "theme") => ({
+  computed: {
+    themeClass() {
+      return getThemeClasses(this[prop]);
+    }
+  }
+});
+var _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const _sfc_main$5 = 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$2 = /* @__PURE__ */ createElementVNode("div", { class: "v-popper__arrow-outer" }, null, -1);
+const _hoisted_4 = /* @__PURE__ */ createElementVNode("div", { class: "v-popper__arrow-inner" }, null, -1);
+const _hoisted_5 = [
+  _hoisted_3$2,
+  _hoisted_4
+];
+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, 4)
+    ], 4)
+  ], 46, _hoisted_1$1$1);
+}
+var PrivatePopperContent = /* @__PURE__ */ _export_sfc(_sfc_main$5, [["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("finalTheme")
+  ],
+  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,
+      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
+        }),
+        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: hide,
+          onResize
+        }, {
+          default: withCtx(() => [
+            renderSlot(_ctx.$slots, "popper", {
+              shown: isShown,
+              hide
+            })
+          ]),
+          _: 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(_sfc_main$4$1, [["render", _sfc_render$1]]);
+defineComponent(__spreadProps2(__spreadValues2({}, PrivatePopperWrapper), {
+  name: "VDropdown",
+  vPopperTheme: "dropdown"
+}));
+defineComponent(__spreadProps2(__spreadValues2({}, PrivatePopperWrapper), {
+  name: "VMenu",
+  vPopperTheme: "menu"
+}));
+defineComponent(__spreadProps2(__spreadValues2({}, PrivatePopperWrapper), {
+  name: "VTooltip",
+  vPopperTheme: "tooltip"
+}));
+const _sfc_main$6 = 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$4 = ["innerHTML"];
+const _hoisted_2$2 = ["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,
+      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: hide,
+        onResize
+      }, {
+        default: withCtx(() => [
+          _ctx.html ? (openBlock(), createElementBlock("div", {
+            key: 0,
+            innerHTML: _ctx.finalContent
+          }, null, 8, _hoisted_1$4)) : (openBlock(), createElementBlock("div", {
+            key: 1,
+            textContent: toDisplayString(_ctx.finalContent)
+          }, null, 8, _hoisted_2$2))
+        ]),
+        _: 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(_sfc_main$6, [["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) {
+      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);
+  }
+};
+const VTooltip = PrivateVTooltip;
+const _hoisted_1$3 = { class: "htw-p-2 hover:htw-bg-primary-100 dark:hover:htw-bg-primary-800 htw-flex htw-gap-2 htw-flex-wrap" };
+const _hoisted_2$1 = { class: "htw-w-28 htw-whitespace-nowrap htw-text-ellipsis htw-overflow-hidden htw-shrink-0" };
+const _hoisted_3$1 = { class: "htw-block htw-grow" };
+const __default__$4 = {
+  name: "HstWrapper"
+};
+const _sfc_main$4 = /* @__PURE__ */ defineComponent(__spreadProps(__spreadValues({}, __default__$4), {
+  props: {
+    title: null
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("label", _hoisted_1$3, [
+        withDirectives((openBlock(), createElementBlock("span", _hoisted_2$1, [
+          createTextVNode(toDisplayString(__props.title), 1)
+        ])), [
+          [unref(VTooltip), {
+            content: __props.title,
+            placement: "left",
+            distance: 12
+          }]
+        ]),
+        createElementVNode("span", _hoisted_3$1, [
+          renderSlot(_ctx.$slots, "default")
+        ])
+      ]);
+    };
+  }
+}));
+const _hoisted_1$2 = { class: "htw-text-white htw-w-[16px] htw-h-[16px] htw-relative" };
+const _hoisted_2 = {
   width: "16",
   height: "16",
   viewBox: "0 0 24 24",
   class: "htw-relative htw-z-10"
 };
 const _hoisted_3 = ["stroke-dasharray", "stroke-dashoffset"];
-const __default__$1 = {
+const __default__$3 = {
   name: "HstCheckbox"
 };
-const _sfc_main$1 = /* @__PURE__ */ defineComponent(__spreadProps(__spreadValues({}, __default__$1), {
+const _sfc_main$3 = /* @__PURE__ */ defineComponent(__spreadProps(__spreadValues({}, __default__$3), {
   props: {
-    modelValue: {
-      type: Boolean,
-      default: false
-    }
+    modelValue: { type: Boolean },
+    title: null
   },
   emits: {
     "update:modelValue": (newValue) => true
@@ -55,59 +2676,178 @@ const _sfc_main$1 = /* @__PURE__ */ defineComponent(__spreadProps(__spreadValues
       dasharray.value = (_c = (_b = (_a = path.value).getTotalLength) == null ? void 0 : _b.call(_a)) != null ? _c : 21.21;
     });
     return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", {
+      return openBlock(), createBlock(_sfc_main$4, {
         role: "checkbox",
         tabindex: "0",
-        class: "htw-flex htw-items-center htw-gap-2 htw-select-none htw-px-4 htw-py-3 htw-cursor-pointer hover:htw-bg-primary-100 dark:hover:htw-bg-primary-700",
+        class: "htw-cursor-pointer htw-items-center",
+        title: __props.title,
         onClick: _cache[0] || (_cache[0] = ($event) => toggle()),
         onKeydown: [
           _cache[1] || (_cache[1] = withKeys(withModifiers(($event) => toggle(), ["prevent"]), ["enter"])),
           _cache[2] || (_cache[2] = withKeys(withModifiers(($event) => toggle(), ["prevent"]), ["space"]))
         ]
-      }, [
-        createElementVNode("div", _hoisted_1$1, [
-          createElementVNode("div", {
-            class: normalizeClass(["htw-border group-active:htw-bg-gray-500/20 htw-rounded-sm htw-box-border htw-absolute htw-inset-0 htw-transition-border htw-duration-150 htw-ease-out", [
-              __props.modelValue ? "htw-border-primary-500 htw-border-8" : "htw-border-gray-300 dark:htw-border-gray-500 htw-delay-150"
-            ]])
-          }, null, 2),
-          (openBlock(), createElementBlock("svg", _hoisted_2$1, [
-            createElementVNode("path", {
-              ref_key: "path",
-              ref: path,
-              d: "m 4 12 l 5 5 l 10 -10",
-              fill: "none",
-              class: normalizeClass(["htw-stroke-white htw-stroke-2 htw-duration-200 htw-ease-in-out", [
-                animationEnabled.value ? "htw-transition-all" : "htw-transition-none",
-                {
-                  "htw-delay-150": __props.modelValue
-                }
-              ]]),
-              "stroke-dasharray": dasharray.value,
-              "stroke-dashoffset": unref(dashoffset)
-            }, null, 10, _hoisted_3)
-          ]))
+      }, {
+        default: withCtx(() => [
+          createElementVNode("div", _hoisted_1$2, [
+            createElementVNode("div", {
+              class: normalizeClass(["htw-border htw-border-solid group-active:htw-bg-gray-500/20 htw-rounded-sm htw-box-border htw-absolute htw-inset-0 htw-transition-border htw-duration-150 htw-ease-out", [
+                __props.modelValue ? "htw-border-primary-500 htw-border-8" : "htw-border-black/25 dark:htw-border-white/25 htw-delay-150"
+              ]])
+            }, null, 2),
+            (openBlock(), createElementBlock("svg", _hoisted_2, [
+              createElementVNode("path", {
+                ref_key: "path",
+                ref: path,
+                d: "m 4 12 l 5 5 l 10 -10",
+                fill: "none",
+                class: normalizeClass(["htw-stroke-white htw-stroke-2 htw-duration-200 htw-ease-in-out", [
+                  animationEnabled.value ? "htw-transition-all" : "htw-transition-none",
+                  {
+                    "htw-delay-150": __props.modelValue
+                  }
+                ]]),
+                "stroke-dasharray": dasharray.value,
+                "stroke-dashoffset": unref(dashoffset)
+              }, null, 10, _hoisted_3)
+            ]))
+          ])
         ]),
-        renderSlot(_ctx.$slots, "default")
-      ], 32);
+        _: 1
+      }, 8, ["title"]);
     };
   }
 }));
-const _hoisted_1 = {
-  key: 0,
-  class: "htw-text-sm htw-px-2 htw-cursor-text"
+const _hoisted_1$1 = ["value"];
+const __default__$2 = {
+  name: "HstText"
 };
-const _hoisted_2 = ["value"];
+const _sfc_main$2 = /* @__PURE__ */ defineComponent(__spreadProps(__spreadValues({}, __default__$2), {
+  props: {
+    title: null,
+    modelValue: null
+  },
+  emits: {
+    "update:modelValue": (newValue) => true
+  },
+  setup(__props, { emit }) {
+    const input = ref();
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$4, {
+        title: __props.title,
+        class: normalizeClass(["htw-cursor-text htw-items-center", _ctx.$attrs.class]),
+        style: normalizeStyle(_ctx.$attrs.style),
+        onClick: _cache[1] || (_cache[1] = ($event) => input.value.focus())
+      }, {
+        default: withCtx(() => [
+          createElementVNode("input", mergeProps({
+            ref_key: "input",
+            ref: input
+          }, __spreadProps(__spreadValues({}, _ctx.$attrs), { class: null, style: null }), {
+            type: "text",
+            value: __props.modelValue,
+            class: "htw-text-inherit htw-bg-transparent htw-w-full htw-outline-none htw-px-2 htw-py-1 -htw-my-1 htw-border htw-border-solid htw-border-black/25 dark:htw-border-white/25 focus:htw-border-primary-500 dark:focus:htw-border-primary-500 htw-rounded-sm",
+            onInput: _cache[0] || (_cache[0] = ($event) => emit("update:modelValue", $event.target.value))
+          }), null, 16, _hoisted_1$1)
+        ]),
+        _: 1
+      }, 8, ["title", "class", "style"]);
+    };
+  }
+}));
+const __default__$1 = {
+  name: "HstNumber",
+  inheritAttrs: false
+};
+const _sfc_main$1 = /* @__PURE__ */ defineComponent(__spreadProps(__spreadValues({}, __default__$1), {
+  props: {
+    title: null,
+    modelValue: null
+  },
+  emits: {
+    "update:modelValue": (newValue) => true
+  },
+  setup(__props, { emit }) {
+    const props = __props;
+    const numberModel = computed({
+      get: () => props.modelValue,
+      set: (value) => {
+        emit("update:modelValue", value);
+      }
+    });
+    const input = ref();
+    function focusAndSelect() {
+      input.value.focus();
+      input.value.select();
+    }
+    const isDragging = ref(false);
+    let startX;
+    let startValue;
+    function onMouseDown(event) {
+      isDragging.value = true;
+      startX = event.clientX;
+      startValue = numberModel.value;
+      window.addEventListener("mousemove", onMouseMove);
+      window.addEventListener("mouseup", stopDragging);
+    }
+    function onMouseMove(event) {
+      let step = parseFloat(input.value.step);
+      if (isNaN(step)) {
+        step = 1;
+      }
+      numberModel.value = startValue + Math.round((event.clientX - startX) / 10 / step) * step;
+    }
+    function stopDragging() {
+      isDragging.value = false;
+      window.removeEventListener("mousemove", onMouseMove);
+      window.removeEventListener("mouseup", stopDragging);
+    }
+    onUnmounted(() => {
+      stopDragging();
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$4, {
+        class: normalizeClass(["htw-cursor-ew-resize htw-items-center", [
+          _ctx.$attrs.class,
+          { "htw-select-none": isDragging.value }
+        ]]),
+        title: __props.title,
+        style: normalizeStyle(_ctx.$attrs.style),
+        onClick: focusAndSelect,
+        onMousedown: onMouseDown
+      }, {
+        default: withCtx(() => [
+          withDirectives(createElementVNode("input", mergeProps({
+            ref_key: "input",
+            ref: input
+          }, __spreadProps(__spreadValues({}, _ctx.$attrs), { class: null, style: null }), {
+            "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(numberModel) ? numberModel.value = $event : null),
+            type: "number",
+            class: [{
+              "htw-select-none": isDragging.value
+            }, "htw-text-inherit htw-bg-transparent htw-w-full htw-outline-none htw-pl-2 htw-py-1 -htw-my-1 htw-border htw-border-solid htw-border-black/25 dark:htw-border-white/25 focus:htw-border-primary-500 dark:focus:htw-border-primary-500 htw-rounded-sm htw-cursor-ew-resize"]
+          }), null, 16), [
+            [
+              vModelText,
+              unref(numberModel),
+              void 0,
+              { number: true }
+            ]
+          ])
+        ]),
+        _: 1
+      }, 8, ["title", "class", "style"]);
+    };
+  }
+}));
+const _hoisted_1 = ["value"];
 const __default__ = {
-  name: "HstInput",
+  name: "HstTextarea",
   inheritAttrs: false
 };
 const _sfc_main = /* @__PURE__ */ defineComponent(__spreadProps(__spreadValues({}, __default__), {
   props: {
-    modelValue: {
-      type: [String, Number],
-      default: ""
-    }
+    title: null,
+    modelValue: null
   },
   emits: {
     "update:modelValue": (newValue) => true
@@ -115,30 +2855,35 @@ const _sfc_main = /* @__PURE__ */ defineComponent(__spreadProps(__spreadValues({
   setup(__props, { emit }) {
     const input = ref();
     return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", {
-        class: normalizeClass(["htw-p-2 hover:htw-bg-primary-100 dark:hover:htw-bg-primary-700 htw-cursor-text", _ctx.$attrs.class]),
+      return openBlock(), createBlock(_sfc_main$4, {
+        title: __props.title,
+        class: normalizeClass(["htw-cursor-text", _ctx.$attrs.class]),
         style: normalizeStyle(_ctx.$attrs.style),
         onClick: _cache[1] || (_cache[1] = ($event) => input.value.focus())
-      }, [
-        _ctx.$slots.default ? (openBlock(), createElementBlock("label", _hoisted_1, [
-          renderSlot(_ctx.$slots, "default")
-        ])) : createCommentVNode("", true),
-        createElementVNode("input", mergeProps({
-          ref_key: "input",
-          ref: input
-        }, __spreadProps(__spreadValues({}, _ctx.$attrs), { style: null, class: null }), {
-          value: __props.modelValue,
-          class: "htw-text-inherit htw-bg-transparent htw-w-full htw-outline-none htw-px-2 htw-py-0 htw-border htw-border-gray-300 dark:htw-border-gray-500 focus:htw-border-primary-500 dark:focus:htw-border-primary-500 htw-rounded-sm",
-          onInput: _cache[0] || (_cache[0] = ($event) => emit("update:modelValue", $event.target.value))
-        }), null, 16, _hoisted_2)
-      ], 6);
+      }, {
+        default: withCtx(() => [
+          createElementVNode("textarea", mergeProps({
+            ref_key: "input",
+            ref: input
+          }, __spreadProps(__spreadValues({}, _ctx.$attrs), { class: null, style: null }), {
+            value: __props.modelValue,
+            class: "htw-text-inherit htw-bg-transparent htw-w-full htw-outline-none htw-px-2 htw-py-1 -htw-my-1 htw-border htw-border-solid htw-border-black/25 dark:htw-border-white/25 focus:htw-border-primary-500 dark:focus:htw-border-primary-500 htw-rounded-sm htw-box-border htw-resize-y htw-min-h-[26px]",
+            onInput: _cache[0] || (_cache[0] = ($event) => emit("update:modelValue", $event.target.value))
+          }), null, 16, _hoisted_1)
+        ]),
+        _: 1
+      }, 8, ["title", "class", "style"]);
     };
   }
 }));
-const HstCheckbox = _sfc_main$1;
-const HstInput = _sfc_main;
+const HstCheckbox = _sfc_main$3;
+const HstText = _sfc_main$2;
+const HstNumber = _sfc_main$1;
+const HstTextarea = _sfc_main;
 function registerVueComponents(app) {
-  app.component("HstCheckbox", _sfc_main$1);
-  app.component("HstInput", _sfc_main);
+  app.component("HstCheckbox", _sfc_main$3);
+  app.component("HstText", _sfc_main$2);
+  app.component("HstNumber", _sfc_main$1);
+  app.component("HstTextarea", _sfc_main);
 }
-export { HstCheckbox, HstInput, registerVueComponents };
+export { HstCheckbox, HstNumber, HstText, HstTextarea, registerVueComponents };