@webitel/ui-sdk 3.1.98 → 3.1.99

package/dist/ui-sdk.umd.js

@@ -5297,3347 +5297,11 @@ if (typeof window !== 'undefined') {
 
 // EXTERNAL MODULE: external {"commonjs":"vue","commonjs2":"vue","root":"Vue"}
 var external_commonjs_vue_commonjs2_vue_root_Vue_ = __webpack_require__(203);
-;// CONCATENATED MODULE: ./node_modules/@floating-ui/core/dist/floating-ui.core.esm.js
-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 = async (reference, floating, config) => {
-  const {
-    placement = 'bottom',
-    strategy = 'absolute',
-    middleware = [],
-    platform
-  } = config;
-
-  if (false) {}
-
-  let rects = await platform.getElementRects({
-    reference,
-    floating,
-    strategy
-  });
-  let {
-    x,
-    y
-  } = computeCoordsFromPlacement({ ...rects,
-    placement
-  });
-  let statefulPlacement = placement;
-  let middlewareData = {};
-  let _debug_loop_count_ = 0;
-
-  for (let i = 0; i < middleware.length; i++) {
-    if (false) {}
-
-    const {
-      name,
-      fn
-    } = middleware[i];
-    const {
-      x: nextX,
-      y: nextY,
-      data,
-      reset
-    } = await fn({
-      x,
-      y,
-      initialPlacement: placement,
-      placement: statefulPlacement,
-      strategy,
-      middlewareData,
-      rects,
-      platform,
-      elements: {
-        reference,
-        floating
-      }
-    });
-    x = nextX != null ? nextX : x;
-    y = nextY != null ? nextY : y;
-    middlewareData = { ...middlewareData,
-      [name]: data != null ? data : {}
-    };
-
-    if (reset) {
-      if (typeof reset === 'object') {
-        if (reset.placement) {
-          statefulPlacement = reset.placement;
-        }
-
-        if (reset.rects) {
-          rects = reset.rects === true ? await platform.getElementRects({
-            reference,
-            floating,
-            strategy
-          }) : reset.rects;
-        }
-
-        ({
-          x,
-          y
-        } = computeCoordsFromPlacement({ ...rects,
-          placement: statefulPlacement
-        }));
-      }
-
-      i = -1;
-      continue;
-    }
-  }
-
-  return {
-    x,
-    y,
-    placement: statefulPlacement,
-    strategy,
-    middlewareData
-  };
-};
-
-function expandPaddingObject(padding) {
-  return {
-    top: 0,
-    right: 0,
-    bottom: 0,
-    left: 0,
-    ...padding
-  };
-}
-
-function getSideObjectFromPadding(padding) {
-  return typeof padding !== 'number' ? expandPaddingObject(padding) : {
-    top: padding,
-    right: padding,
-    bottom: padding,
-    left: padding
-  };
-}
-
-function rectToClientRect(rect) {
-  return { ...rect,
-    top: rect.y,
-    left: rect.x,
-    right: rect.x + rect.width,
-    bottom: rect.y + rect.height
-  };
-}
-
-async function detectOverflow(middlewareArguments, options) {
-  if (options === void 0) {
-    options = {};
-  }
-
-  const {
-    x,
-    y,
-    platform,
-    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 platform.getClippingClientRect({
-    element: (await platform.isElement(element)) ? element : element.contextElement || (await platform.getDocumentElement({
-      element: elements.floating
-    })),
-    boundary,
-    rootBoundary
-  });
-  const elementClientRect = rectToClientRect(await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
-    rect: elementContext === 'floating' ? { ...rects.floating,
-      x,
-      y
-    } : rects.reference,
-    offsetParent: await platform.getOffsetParent({
-      element: elements.floating
-    }),
-    strategy
-  })); // positive = overflowing the clipping rect
-  // 0 or negative = within the clipping rect
-
-  return {
-    top: clippingClientRect.top - elementClientRect.top + paddingObject.top,
-    bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom,
-    left: clippingClientRect.left - elementClientRect.left + paddingObject.left,
-    right: elementClientRect.right - clippingClientRect.right + paddingObject.right
-  };
-}
-
-const min = Math.min;
-const max = Math.max;
-
-function within(min$1, value, max$1) {
-  return max(min$1, min(value, max$1));
-}
-
-const arrow = options => ({
-  name: 'arrow',
-  options,
-
-  async fn(middlewareArguments) {
-    // Since `element` is required, we don't Partial<> the type
-    const {
-      element,
-      padding = 0
-    } = options != null ? options : {};
-    const {
-      x,
-      y,
-      placement,
-      rects,
-      platform
-    } = middlewareArguments;
-
-    if (element == null) {
-      if (false) {}
-
-      return {};
-    }
-
-    const paddingObject = getSideObjectFromPadding(padding);
-    const coords = {
-      x,
-      y
-    };
-    const basePlacement = getBasePlacement(placement);
-    const axis = getMainAxisFromPlacement(basePlacement);
-    const length = getLengthFromAxis(axis);
-    const arrowDimensions = await platform.getDimensions({
-      element
-    });
-    const minProp = axis === 'y' ? 'top' : 'left';
-    const maxProp = axis === 'y' ? 'bottom' : 'right';
-    const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
-    const startDiff = coords[axis] - rects.reference[axis];
-    const arrowOffsetParent = await platform.getOffsetParent({
-      element
-    });
-    const clientSize = arrowOffsetParent ? axis === 'y' ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;
-    const centerToReference = endDiff / 2 - startDiff / 2; // Make sure the arrow doesn't overflow the floating element if the center
-    // point is outside of the floating element's bounds
-
-    const min = paddingObject[minProp];
-    const max = clientSize - arrowDimensions[length] - paddingObject[maxProp];
-    const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
-    const offset = within(min, center, max);
-    return {
-      data: {
-        [axis]: offset,
-        centerOffset: center - offset
-      }
-    };
-  }
-
-});
-
-const hash$1 = {
-  left: 'right',
-  right: 'left',
-  bottom: 'top',
-  top: 'bottom'
-};
-function getOppositePlacement(placement) {
-  return placement.replace(/left|right|bottom|top/g, matched => hash$1[matched]);
-}
-
-function getAlignmentSides(placement, rects) {
-  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 {
-        alignment = null,
-        allowedPlacements = allPlacements,
-        autoAlignment = true,
-        ...detectOverflowOptions
-      } = options;
-
-      if ((_middlewareData$autoP = middlewareData.autoPlacement) != null && _middlewareData$autoP.skip) {
-        return {};
-      }
-
-      const placements = 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 = placements[currentIndex];
-      const {
-        main,
-        cross
-      } = getAlignmentSides(currentPlacement, rects); // Make `computeCoords` start from the right place
-
-      if (placement !== currentPlacement) {
-        return {
-          x,
-          y,
-          reset: {
-            placement: placements[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 = placements[currentIndex + 1]; // There are more placements to check
-
-      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(overflow => overflow <= 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 {
-        mainAxis: checkMainAxis = true,
-        crossAxis: checkCrossAxis = true,
-        fallbackPlacements: specifiedFallbackPlacements,
-        fallbackStrategy = 'bestFit',
-        flipAlignment = true,
-        ...detectOverflowOptions
-      } = options;
-      const basePlacement = getBasePlacement(placement);
-      const isBasePlacement = basePlacement === initialPlacement;
-      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
-      const placements = [initialPlacement, ...fallbackPlacements];
-      const overflow = await detectOverflow(middlewareArguments, detectOverflowOptions);
-      const overflows = [];
-      let overflowsData = ((_middlewareData$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
-      }]; // One or more sides is overflowing
-
-      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 = placements[nextIndex];
-
-        if (nextPlacement) {
-          // Try next placement and re-run the lifecycle
-          return {
-            data: {
-              index: nextIndex,
-              overflows: overflowsData
-            },
-            reset: {
-              placement: nextPlacement
-            }
-          };
-        }
-
-        let resetPlacement = 'bottom';
-
-        switch (fallbackStrategy) {
-          case 'bestFit':
-            {
-              var _overflowsData$slice$;
-
-              const placement = (_overflowsData$slice$ = overflowsData.slice().sort((a, b) => a.overflows.filter(overflow => overflow > 0).reduce((acc, overflow) => acc + overflow, 0) - b.overflows.filter(overflow => overflow > 0).reduce((acc, overflow) => acc + overflow, 0))[0]) == null ? void 0 : _overflowsData$slice$.placement;
-
-              if (placement) {
-                resetPlacement = placement;
-              }
-
-              break;
-            }
-
-          case 'initialPlacement':
-            resetPlacement = initialPlacement;
-            break;
-        }
-
-        return {
-          data: {
-            skip: true
-          },
-          reset: {
-            placement: resetPlacement
-          }
-        };
-      }
-
-      return {};
-    }
-
-  };
-};
-
-function getSideOffsets(overflow, rect) {
-  return {
-    top: overflow.top - rect.height,
-    right: overflow.right - rect.width,
-    bottom: overflow.bottom - rect.height,
-    left: overflow.left - rect.width
-  };
-}
-
-function isAnySideFullyClipped(overflow) {
-  return basePlacements.some(side => overflow[side] >= 0);
-}
-
-const hide = () => ({
-  name: 'hide',
-
-  async fn(modifierArguments) {
-    const referenceOverflow = await detectOverflow(modifierArguments, {
-      elementContext: 'reference'
-    });
-    const floatingAltOverflow = await detectOverflow(modifierArguments, {
-      altBoundary: true
-    });
-    const referenceHiddenOffsets = getSideOffsets(referenceOverflow, modifierArguments.rects.reference);
-    const escapedOffsets = getSideOffsets(floatingAltOverflow, modifierArguments.rects.floating);
-    const referenceHidden = isAnySideFullyClipped(referenceHiddenOffsets);
-    const escaped = isAnySideFullyClipped(escapedOffsets);
-    return {
-      data: {
-        referenceHidden,
-        referenceHiddenOffsets,
-        escaped,
-        escapedOffsets
-      }
-    };
-  }
-
-});
-
-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({ ...rects,
-    placement
-  }) : value;
-  const {
-    mainAxis,
-    crossAxis
-  } = typeof rawValue === 'number' ? {
-    mainAxis: rawValue,
-    crossAxis: 0
-  } : {
-    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 {
-        mainAxis: checkMainAxis = true,
-        crossAxis: checkCrossAxis = false,
-        limiter = {
-          fn: _ref => {
-            let {
-              x,
-              y
-            } = _ref;
-            return {
-              x,
-              y
-            };
-          }
-        },
-        ...detectOverflowOptions
-      } = options;
-      const coords = {
-        x,
-        y
-      };
-      const overflow = await detectOverflow(middlewareArguments, detectOverflowOptions);
-      const mainAxis = getMainAxisFromPlacement(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 min = mainAxisCoord + overflow[minSide];
-        const max = mainAxisCoord - overflow[maxSide];
-        mainAxisCoord = within(min, mainAxisCoord, max);
-      }
-
-      if (checkCrossAxis) {
-        const minSide = crossAxis === 'y' ? 'top' : 'left';
-        const maxSide = crossAxis === 'y' ? 'bottom' : 'right';
-        const min = crossAxisCoord + overflow[minSide];
-        const max = crossAxisCoord - overflow[maxSide];
-        crossAxisCoord = within(min, crossAxisCoord, max);
-      }
-
-      const limitedCoords = limiter.fn({ ...middlewareArguments,
-        [mainAxis]: mainAxisCoord,
-        [crossAxis]: crossAxisCoord
-      });
-      return { ...limitedCoords,
-        data: {
-          x: limitedCoords.x - x,
-          y: limitedCoords.y - y
-        }
-      };
-    }
-
-  };
-};
-const limitShift = function (options) {
-  if (options === void 0) {
-    options = {};
-  }
-
-  return {
-    options,
-
-    fn(middlewareArguments) {
-      const {
-        x,
-        y,
-        placement,
-        rects,
-        middlewareData
-      } = middlewareArguments;
-      const {
-        offset = 0,
-        mainAxis: checkMainAxis = true,
-        crossAxis: checkCrossAxis = true
-      } = options;
-      const coords = {
-        x,
-        y
-      };
-      const mainAxis = getMainAxisFromPlacement(placement);
-      const crossAxis = getCrossAxis(mainAxis);
-      let mainAxisCoord = coords[mainAxis];
-      let crossAxisCoord = coords[crossAxis];
-      const rawOffset = typeof offset === 'function' ? offset({ ...rects,
-        placement
-      }) : offset;
-      const computedOffset = typeof rawOffset === 'number' ? {
-        mainAxis: rawOffset,
-        crossAxis: 0
-      } : {
-        mainAxis: 0,
-        crossAxis: 0,
-        ...rawOffset
-      };
-
-      if (checkMainAxis) {
-        const len = mainAxis === 'y' ? 'height' : 'width';
-        const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;
-        const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;
-
-        if (mainAxisCoord < limitMin) {
-          mainAxisCoord = limitMin;
-        } else if (mainAxisCoord > limitMax) {
-          mainAxisCoord = limitMax;
-        }
-      }
-
-      if (checkCrossAxis) {
-        var _middlewareData$offse, _middlewareData$offse2, _middlewareData$offse3, _middlewareData$offse4;
-
-        const len = mainAxis === 'y' ? 'width' : 'height';
-        const isOriginSide = ['top', 'left'].includes(getBasePlacement(placement));
-        const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? (_middlewareData$offse = (_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) != null ? _middlewareData$offse : 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);
-        const limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : (_middlewareData$offse3 = (_middlewareData$offse4 = middlewareData.offset) == null ? void 0 : _middlewareData$offse4[crossAxis]) != null ? _middlewareData$offse3 : 0) - (isOriginSide ? computedOffset.crossAxis : 0);
-
-        if (crossAxisCoord < limitMin) {
-          crossAxisCoord = limitMin;
-        } else if (crossAxisCoord > limitMax) {
-          crossAxisCoord = limitMax;
-        }
-      }
-
-      return {
-        [mainAxis]: mainAxisCoord,
-        [crossAxis]: crossAxisCoord
-      };
-    }
-
-  };
-};
-
-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 {
-        apply,
-        ...detectOverflowOptions
-      } = options;
-
-      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(overflow.left, 0);
-      const xMax = max(overflow.right, 0);
-      const yMin = max(overflow.top, 0);
-      const yMax = max(overflow.bottom, 0);
-      const dimensions = {
-        height: rects.floating.height - (['left', 'right'].includes(placement) ? 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom)) : overflow[heightSide]),
-        width: rects.floating.width - (['top', 'bottom'].includes(placement) ? 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right)) : overflow[widthSide])
-      };
-      apply == null ? void 0 : apply({ ...dimensions,
-        ...rects
-      });
-      return {
-        data: {
-          skip: true
-        },
-        reset: {
-          rects: true
-        }
-      };
-    }
-
-  };
-};
-
-const inline = function (options) {
-  if (options === void 0) {
-    options = {};
-  }
-
-  return {
-    name: 'inline',
-    options,
-
-    async fn(middlewareArguments) {
-      var _middlewareData$inlin, _await$platform$getCl;
-
-      const {
-        placement,
-        elements,
-        rects,
-        platform,
-        strategy,
-        middlewareData
-      } = middlewareArguments; // A MouseEvent's client{X,Y} coords can be up to 2 pixels off a
-      // ClientRect's bounds, despite the event listener being triggered. A
-      // padding of 2 seems to handle this issue.
-
-      const {
-        padding = 2,
-        x,
-        y
-      } = options;
-
-      if ((_middlewareData$inlin = middlewareData.inline) != null && _middlewareData$inlin.skip) {
-        return {};
-      }
-
-      const fallback = rectToClientRect(await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
-        rect: rects.reference,
-        offsetParent: await platform.getOffsetParent({
-          element: elements.floating
-        }),
-        strategy
-      }));
-      const clientRects = Array.from((_await$platform$getCl = await (platform.getClientRects == null ? void 0 : platform.getClientRects({
-        element: elements.reference
-      }))) != null ? _await$platform$getCl : []);
-      const paddingObject = getSideObjectFromPadding(padding);
-
-      function getBoundingClientRect() {
-        // There are two rects and they are disjoined
-        if (clientRects.length === 2 && clientRects[0].left > clientRects[1].right && x != null && y != null) {
-          var _clientRects$find;
-
-          // Find the first rect in which the point is fully inside
-          return (_clientRects$find = clientRects.find(rect => x > rect.left - paddingObject.left && x < rect.right + paddingObject.right && y > rect.top - paddingObject.top && y < rect.bottom + paddingObject.bottom)) != null ? _clientRects$find : fallback;
-        } // There are 2 or more connected rects
-
-
-        if (clientRects.length >= 2) {
-          if (getMainAxisFromPlacement(placement) === 'x') {
-            const firstRect = clientRects[0];
-            const lastRect = clientRects[clientRects.length - 1];
-            const isTop = getBasePlacement(placement) === 'top';
-            const top = firstRect.top;
-            const bottom = lastRect.bottom;
-            const left = isTop ? firstRect.left : lastRect.left;
-            const right = isTop ? firstRect.right : lastRect.right;
-            const width = right - left;
-            const height = bottom - top;
-            return {
-              top,
-              bottom,
-              left,
-              right,
-              width,
-              height,
-              x: left,
-              y: top
-            };
-          }
-
-          const isLeftPlacement = getBasePlacement(placement) === 'left';
-          const maxRight = max(...clientRects.map(rect => rect.right));
-          const minLeft = min(...clientRects.map(rect => rect.left));
-          const measureRects = clientRects.filter(rect => isLeftPlacement ? rect.left === minLeft : rect.right === maxRight);
-          const top = measureRects[0].top;
-          const bottom = measureRects[measureRects.length - 1].bottom;
-          const left = minLeft;
-          const right = maxRight;
-          const width = right - left;
-          const height = bottom - top;
-          return {
-            top,
-            bottom,
-            left,
-            right,
-            width,
-            height,
-            x: left,
-            y: top
-          };
-        }
-
-        return fallback;
-      }
-
-      return {
-        data: {
-          skip: true
-        },
-        reset: {
-          rects: await platform.getElementRects({
-            reference: {
-              getBoundingClientRect
-            },
-            floating: elements.floating,
-            strategy
-          })
-        }
-      };
-    }
-
-  };
-};
-
-
-
-;// CONCATENATED MODULE: ./node_modules/@floating-ui/dom/dist/floating-ui.dom.esm.js
-
-
-
-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) {
-  // Firefox wants us to check `-x` and `-y` variations as well
-  const {
-    overflow,
-    overflowX,
-    overflowY
-  } = getComputedStyle$1(element);
-  return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
-}
-function isTableElement(element) {
-  return ['table', 'td', 'th'].includes(getNodeName(element));
-}
-function isContainingBlock(element) {
-  // TODO: Try and use feature detection here instead
-  const isFirefox = navigator.userAgent.toLowerCase().includes('firefox');
-  const css = getComputedStyle$1(element); // This is non-exhaustive but covers the most common CSS properties that
-  // create a containing block.
-  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
-
-  return css.transform !== 'none' || css.perspective !== 'none' || css.contain === 'paint' || ['transform', 'perspective'].includes(css.willChange) || isFirefox && css.willChange === 'filter' || isFirefox && (css.filter ? css.filter !== 'none' : false);
-}
-
-const floating_ui_dom_esm_min = Math.min;
-const floating_ui_dom_esm_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) {
-  // If <html> has a CSS width greater than the viewport, then this will be
-  // incorrect for RTL.
-  return getBoundingClientRect(getDocumentElement(element)).left + getNodeScroll(element).scrollLeft;
-}
-
-function isScaled(element) {
-  const rect = getBoundingClientRect(element);
-  return round(rect.width) !== element.offsetWidth || round(rect.height) !== element.offsetHeight;
-}
-
-function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
-  const isOffsetParentAnElement = isHTMLElement(offsetParent);
-  const documentElement = getDocumentElement(offsetParent);
-  const rect = getBoundingClientRect(element, 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 (// this is a quicker (but less type safe) way to save quite some bytes from the bundle
-    // @ts-ignore
-    node.assignedSlot || // step into the shadow DOM of the parent of a slotted node
-    node.parentNode || ( // DOM Element detected
-    isShadowRoot(node) ? node.host : null) || // ShadowRoot detected
-    getDocumentElement(node) // fallback
-
-  );
-}
-
-function getTrueOffsetParent(element) {
-  if (!isHTMLElement(element) || getComputedStyle(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;
-} // Gets the closest ancestor positioned element. Handles some edge cases,
-// such as table ancestors and cross browser bugs.
-
-
-function getOffsetParent(element) {
-  const window = getWindow(element);
-  let offsetParent = getTrueOffsetParent(element);
-
-  while (offsetParent && isTableElement(offsetParent) && getComputedStyle(offsetParent).position === 'static') {
-    offsetParent = getTrueOffsetParent(offsetParent);
-  }
-
-  if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle(offsetParent).position === 'static' && !isContainingBlock(offsetParent))) {
-    return window;
-  }
-
-  return offsetParent || getContainingBlock(element) || window;
-}
-
-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;
-    } // This doesn't appear to be need to be negated.
-    // else if (documentElement) {
-    //   offsets.x = getWindowScrollBarX(documentElement);
-    // }
-
-  }
-
-  return { ...rect,
-    x: rect.x - scroll.scrollLeft + offsets.x,
-    y: rect.y - scroll.scrollTop + offsets.y
-  };
-}
-
-function getViewportRect(element) {
-  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; // Uses Layout Viewport (like Chrome; Safari does not currently)
-    // In Chrome, it returns a value very close to 0 (+/-) but contains rounding
-    // errors due to floating point numbers, so we need to check precision.
-    // Safari returns a number <= 0, usually < -1 when pinch-zoomed
-
-    if (Math.abs(win.innerWidth / visualViewport.scale - visualViewport.width) < 0.01) {
-      x = visualViewport.offsetLeft;
-      y = visualViewport.offsetTop;
-    }
-  }
-
-  return {
-    width,
-    height,
-    x,
-    y
-  };
-}
-
-// of the `<html>` and `<body>` rect bounds if horizontally scrollable
-
-function getDocumentRect(element) {
-  var _element$ownerDocumen;
-
-  const html = getDocumentElement(element);
-  const scroll = getNodeScroll(element);
-  const body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body;
-  const width = floating_ui_dom_esm_max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
-  const height = floating_ui_dom_esm_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 += floating_ui_dom_esm_max(html.clientWidth, body ? body.clientWidth : 0) - width;
-  }
-
-  return {
-    width,
-    height,
-    x,
-    y
-  };
-}
-
-function getScrollParent(node) {
-  if (['html', 'body', '#document'].includes(getNodeName(node))) {
-    // @ts-ignore assume body is always available
-    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 : // @ts-ignore: isBody tells us target will be an HTMLElement here
-  updatedList.concat(getScrollParents(getParentNode(target)));
-}
-
-function contains(parent, child) {
-  const rootNode = child.getRootNode == null ? void 0 : child.getRootNode(); // First, attempt with faster native method
-
-  if (parent.contains(child)) {
-    return true;
-  } // then fallback to custom implementation with Shadow DOM support
-  else if (rootNode && isShadowRoot(rootNode)) {
-    let next = child;
-
-    do {
-      // use `===` replace node.isSameNode()
-      if (next && parent === next) {
-        return true;
-      } // @ts-ignore: need a better way to handle this...
-
-
-      next = next.parentNode || next.host;
-    } while (next);
-  }
-
-  return false;
-}
-
-function getInnerBoundingClientRect(element) {
-  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)));
-} // A "clipping parent" is an overflowable container with the characteristic of
-// clipping (or hiding) overflowing elements with a position different from
-// `initial`
-
-
-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 [];
-  } // @ts-ignore isElement check ensures we return Array<Element>
-
-
-  return clippingParents.filter(clippingParent => isElement(clippingParent) && contains(clippingParent, clipperElement) && getNodeName(clippingParent) !== 'body');
-} // Gets the maximum area that the element is visible in due to any number of
-// clipping parents
-
-
-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 = floating_ui_dom_esm_max(rect.top, accRect.top);
-    accRect.right = floating_ui_dom_esm_min(rect.right, accRect.right);
-    accRect.bottom = floating_ui_dom_esm_min(rect.bottom, accRect.bottom);
-    accRect.left = floating_ui_dom_esm_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: { ...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 floating_ui_dom_esm_computePosition = (reference, floating, options) => computePosition(reference, floating, {
-  platform,
-  ...options
-});
-
-
-
-;// CONCATENATED MODULE: ./node_modules/floating-vue/dist/floating-vue.es.js
-/* provided dependency */ var console = __webpack_require__(108);
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-
-
-function floating_vue_es_assign(to, from) {
-  for (const key in from) {
-    if (Object.prototype.hasOwnProperty.call(from, key)) {
-      if (typeof from[key] === "object" && to[key]) {
-        floating_vue_es_assign(to[key], from[key]);
-      } else {
-        to[key] = from[key];
-      }
-    }
-  }
-}
-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}`);
-}
-function getAllParentThemes(theme) {
-  const result = [theme];
-  let themeConfig = config.themes[theme] || {};
-  do {
-    if (themeConfig.$extend) {
-      result.push(themeConfig.$extend);
-      themeConfig = config.themes[themeConfig.$extend] || {};
-    } else {
-      themeConfig = null;
-    }
-  } while (themeConfig);
-  return result;
-}
-var vueResize = "";
-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;
-const shownPoppersByTheme = {};
-function getShownPoppersByTheme(theme) {
-  let list = shownPoppersByTheme[theme];
-  if (!list) {
-    list = shownPoppersByTheme[theme] = [];
-  }
-  return list;
-}
-let Element = function() {
-};
-if (typeof window !== "undefined") {
-  Element = window.Element;
-}
-function defaultPropFactory(prop) {
-  return function(props) {
-    return getDefaultConfig(props.theme, prop);
-  };
-}
-const PROVIDE_KEY = "__floating-vue__popper";
-var PrivatePopper = () => (0,external_commonjs_vue_commonjs2_vue_root_Vue_.defineComponent)({
-  name: "VPopper",
-  provide() {
-    return {
-      [PROVIDE_KEY]: {
-        parentPopper: this
-      }
-    };
-  },
-  inject: {
-    [PROVIDE_KEY]: { default: null }
-  },
-  props: {
-    theme: {
-      type: String,
-      required: true
-    },
-    targetNodes: {
-      type: Function,
-      required: true
-    },
-    referenceNode: {
-      type: Function,
-      default: null
-    },
-    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, Function],
-      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")
-    },
-    noAutoFocus: {
-      type: Boolean,
-      default: defaultPropFactory("noAutoFocus")
-    }
-  },
-  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
-      },
-      shownChildren: new Set(),
-      lastAutoHide: true
-    };
-  },
-  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: typeof this.autoHide === "function" ? this.lastAutoHide : this.autoHide,
-        show: this.show,
-        hide: this.hide,
-        handleResize: this.handleResize,
-        onResize: this.onResize,
-        classes: __spreadProps(__spreadValues({}, this.classes), {
-          popperClass: this.popperClass
-        }),
-        result: this.positioningDisabled ? null : this.result,
-        attrs: this.$attrs
-      };
-    },
-    parentPopper() {
-      var _a;
-      return (_a = this[PROVIDE_KEY]) == null ? void 0 : _a.parentPopper;
-    },
-    hasPopperShowTriggerHover() {
-      var _a, _b;
-      return ((_a = this.popperTriggers) == null ? void 0 : _a.includes("hover")) || ((_b = this.popperShowTriggers) == null ? void 0 : _b.includes("hover"));
-    }
-  },
-  watch: __spreadValues(__spreadValues({
-    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 } = {}) {
-      var _a, _b;
-      if (((_a = this.parentPopper) == null ? void 0 : _a.lockedChild) && this.parentPopper.lockedChild !== this)
-        return;
-      this.$_pendingHide = false;
-      if (force || !this.disabled) {
-        if (((_b = this.parentPopper) == null ? void 0 : _b.lockedChild) === this) {
-          this.parentPopper.lockedChild = null;
-        }
-        this.$_scheduleShow(event, skipDelay);
-        this.$emit("show");
-        this.$_showFrameLocked = true;
-        requestAnimationFrame(() => {
-          this.$_showFrameLocked = false;
-        });
-      }
-      this.$emit("update:shown", true);
-    },
-    hide({ event = null, skipDelay = false } = {}) {
-      var _a;
-      if (this.$_hideInProgress)
-        return;
-      if (this.shownChildren.size > 0) {
-        this.$_pendingHide = true;
-        return;
-      }
-      if (this.hasPopperShowTriggerHover && this.$_isAimingPopper()) {
-        if (this.parentPopper) {
-          this.parentPopper.lockedChild = this;
-          clearTimeout(this.parentPopper.lockedChildTimer);
-          this.parentPopper.lockedChildTimer = setTimeout(() => {
-            if (this.parentPopper.lockedChild === this) {
-              this.parentPopper.lockedChild.hide({ skipDelay });
-              this.parentPopper.lockedChild = null;
-            }
-          }, 1e3);
-        }
-        return;
-      }
-      if (((_a = this.parentPopper) == null ? void 0 : _a.lockedChild) === this) {
-        this.parentPopper.lockedChild = null;
-      }
-      this.$_pendingHide = false;
-      this.$_scheduleHide(event, skipDelay);
-      this.$emit("hide");
-      this.$emit("update:shown", false);
-    },
-    init() {
-      var _a, _b;
-      if (!this.$_isDisposed)
-        return;
-      this.$_isDisposed = false;
-      this.isMounted = false;
-      this.$_events = [];
-      this.$_preventShow = false;
-      this.$_referenceNode = (_b = (_a = this.referenceNode) == null ? void 0 : _a.call(this)) != null ? _b : this.$el;
-      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.$_updateParentShownChildren(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 floating_ui_dom_esm_computePosition(this.$_referenceNode, this.$_popperNode, options2);
-      Object.assign(this.result, {
-        x: data.x,
-        y: data.y,
-        placement: data.placement,
-        strategy: data.strategy,
-        arrow: __spreadValues(__spreadValues({}, data.middlewareData.arrow), data.middlewareData.arrowOverflow)
-      });
-    },
-    $_scheduleShow(event = null, skipDelay = false) {
-      this.$_updateParentShownChildren(true);
-      this.$_hideInProgress = false;
-      clearTimeout(this.$_scheduleTimer);
-      if (hidingPopper && this.instantMove && hidingPopper.instantMove && hidingPopper !== this.parentPopper) {
-        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) {
-      if (this.shownChildren.size > 0) {
-        this.$_pendingHide = true;
-        return;
-      }
-      this.$_updateParentShownChildren(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);
-      document.body.classList.add("v-popper--some-open");
-      for (const theme of getAllParentThemes(this.theme)) {
-        getShownPoppersByTheme(theme).push(this);
-        document.body.classList.add(`v-popper--some-open--${theme}`);
-      }
-      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;
-      if (!this.noAutoFocus)
-        this.$_popperNode.focus();
-    },
-    async $_applyHide(skipTransition = false) {
-      if (this.shownChildren.size > 0) {
-        this.$_pendingHide = true;
-        this.$_hideInProgress = false;
-        return;
-      }
-      clearTimeout(this.$_scheduleTimer);
-      if (!this.isShown) {
-        return;
-      }
-      this.skipTransition = skipTransition;
-      removeFromArray(shownPoppers, this);
-      if (shownPoppers.length === 0) {
-        document.body.classList.remove("v-popper--some-open");
-      }
-      for (const theme of getAllParentThemes(this.theme)) {
-        const list = getShownPoppersByTheme(theme);
-        removeFromArray(list, this);
-        if (list.length === 0) {
-          document.body.classList.remove(`v-popper--some-open--${theme}`);
-        }
-      }
-      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);
-          }
-        }
-      }
-    },
-    $_updateParentShownChildren(value) {
-      let parent = this.parentPopper;
-      while (parent) {
-        if (value) {
-          parent.shownChildren.add(this.randomId);
-        } else {
-          parent.shownChildren.delete(this.randomId);
-          if (parent.$_pendingHide) {
-            parent.hide();
-          }
-        }
-        parent = parent.parentPopper;
-      }
-    },
-    $_isAimingPopper() {
-      const referenceBounds = this.$_referenceNode.getBoundingClientRect();
-      if (mouseX >= referenceBounds.left && mouseX <= referenceBounds.right && mouseY >= referenceBounds.top && mouseY <= referenceBounds.bottom) {
-        const popperBounds = this.$_popperNode.getBoundingClientRect();
-        const vectorX = mouseX - mousePreviousX;
-        const vectorY = mouseY - mousePreviousY;
-        const distance = popperBounds.left + popperBounds.width / 2 - mousePreviousX + (popperBounds.top + popperBounds.height / 2) - mousePreviousY;
-        const newVectorLength = distance + popperBounds.width + popperBounds.height;
-        const edgeX = mousePreviousX + vectorX * newVectorLength;
-        const edgeY = mousePreviousY + vectorY * newVectorLength;
-        return lineIntersectsLine(mousePreviousX, mousePreviousY, edgeX, edgeY, popperBounds.left, popperBounds.top, popperBounds.left, popperBounds.bottom) || lineIntersectsLine(mousePreviousX, mousePreviousY, edgeX, edgeY, popperBounds.left, popperBounds.top, popperBounds.right, popperBounds.top) || lineIntersectsLine(mousePreviousX, mousePreviousY, edgeX, edgeY, popperBounds.right, popperBounds.top, popperBounds.right, popperBounds.bottom) || lineIntersectsLine(mousePreviousX, mousePreviousY, edgeX, edgeY, popperBounds.left, popperBounds.bottom, popperBounds.right, popperBounds.bottom);
-      }
-      return false;
-    }
-  },
-  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) {
-  const preventClose = {};
-  for (let i = shownPoppers.length - 1; i >= 0; i--) {
-    const popper = shownPoppers[i];
-    try {
-      const contains = popper.$_containsGlobalTarget = isContainingEventTarget(popper, event);
-      popper.$_pendingHide = false;
-      requestAnimationFrame(() => {
-        popper.$_pendingHide = false;
-        if (preventClose[popper.randomId])
-          return;
-        if (shouldAutoHide(popper, contains, event)) {
-          popper.$_handleGlobalClose(event, touch);
-          if (!event.closeAllPopover && event.closePopover && contains) {
-            let parent2 = popper.parentPopper;
-            while (parent2) {
-              preventClose[parent2.randomId] = true;
-              parent2 = parent2.parentPopper;
-            }
-            return;
-          }
-          let parent = popper.parentPopper;
-          while (parent) {
-            if (shouldAutoHide(parent, parent.$_containsGlobalTarget, event)) {
-              parent.$_handleGlobalClose(event, touch);
-            } else {
-              break;
-            }
-            parent = parent.parentPopper;
-          }
-        }
-      });
-    } catch (e) {
-    }
-  }
-}
-function isContainingEventTarget(popper, event) {
-  const popperContent = popper.popperNode();
-  return popper.$_mouseDownContains || popperContent.contains(event.target);
-}
-function shouldAutoHide(popper, contains, event) {
-  return event.closeAllPopover || event.closePopover && contains || getAutoHideResult(popper, event) && !contains;
-}
-function getAutoHideResult(popper, event) {
-  if (typeof popper.autoHide === "function") {
-    const result = popper.autoHide(event);
-    popper.lastAutoHide = result;
-    return result;
-  }
-  return popper.autoHide;
-}
-function computePositionAllShownPoppers(event) {
-  for (let i = 0; i < shownPoppers.length; i++) {
-    const popper = shownPoppers[i];
-    popper.$_computePosition(event);
-  }
-}
-function hideAllPoppers() {
-  for (let i = 0; i < shownPoppers.length; i++) {
-    const popper = shownPoppers[i];
-    popper.hide();
-  }
-}
-let mousePreviousX = 0;
-let mousePreviousY = 0;
-let mouseX = 0;
-let mouseY = 0;
-if (typeof window !== "undefined") {
-  window.addEventListener("mousemove", (event) => {
-    mousePreviousX = mouseX;
-    mousePreviousY = mouseY;
-    mouseX = event.clientX;
-    mouseY = event.clientY;
-  }, supportsPassive ? {
-    passive: true
-  } : void 0);
-}
-function lineIntersectsLine(x1, y1, x2, y2, x3, y3, x4, y4) {
-  const uA = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / ((y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1));
-  const uB = ((x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3)) / ((y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1));
-  return uA >= 0 && uA <= 1 && uB >= 0 && uB <= 1;
-}
-var _export_sfc = (sfc, props) => {
-  const target = sfc.__vccOpts || sfc;
-  for (const [key, val] of props) {
-    target[key] = val;
-  }
-  return target;
-};
-const _sfc_main$6 = {
-  extends: PrivatePopper()
-};
-function _sfc_render$3(_ctx, _cache, $props, $setup, $data, $options) {
-  return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.openBlock)(), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementBlock)("div", {
-    ref: "reference",
-    class: (0,external_commonjs_vue_commonjs2_vue_root_Vue_.normalizeClass)(["v-popper", {
-      "v-popper--shown": _ctx.slotData.isShown
-    }])
-  }, [
-    (0,external_commonjs_vue_commonjs2_vue_root_Vue_.renderSlot)(_ctx.$slots, "default", (0,external_commonjs_vue_commonjs2_vue_root_Vue_.normalizeProps)((0,external_commonjs_vue_commonjs2_vue_root_Vue_.guardReactiveProps)(_ctx.slotData)))
-  ], 2);
-}
-var Popper$1 = /* @__PURE__ */ _export_sfc(_sfc_main$6, [["render", _sfc_render$3]]);
-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();
-    (0,external_commonjs_vue_commonjs2_vue_root_Vue_.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__ */ (0,external_commonjs_vue_commonjs2_vue_root_Vue_.withScopeId)("data-v-b329ee4c");
-(0,external_commonjs_vue_commonjs2_vue_root_Vue_.pushScopeId)("data-v-b329ee4c");
-const _hoisted_1$2 = {
-  class: "resize-observer",
-  tabindex: "-1"
-};
-(0,external_commonjs_vue_commonjs2_vue_root_Vue_.popScopeId)();
-const render = /* @__PURE__ */ _withId((_ctx, _cache, $props, $setup, $data, $options) => {
-  return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.openBlock)(), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createBlock)("div", _hoisted_1$2);
-});
-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 PopperContent_vue_vue_type_style_index_0_lang = "";
-const _sfc_main$5 = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.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 = ["id", "aria-hidden", "tabindex", "data-popper-placement"];
-const _hoisted_2$1 = {
-  ref: "inner",
-  class: "v-popper__inner"
-};
-const _hoisted_3 = /* @__PURE__ */ (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementVNode)("div", { class: "v-popper__arrow-outer" }, null, -1);
-const _hoisted_4 = /* @__PURE__ */ (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementVNode)("div", { class: "v-popper__arrow-inner" }, null, -1);
-const _hoisted_5 = [
-  _hoisted_3,
-  _hoisted_4
-];
-function _sfc_render$2(_ctx, _cache, $props, $setup, $data, $options) {
-  const _component_ResizeObserver = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.resolveComponent)("ResizeObserver");
-  return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.openBlock)(), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementBlock)("div", {
-    id: _ctx.popperId,
-    ref: "popover",
-    class: (0,external_commonjs_vue_commonjs2_vue_root_Vue_.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: (0,external_commonjs_vue_commonjs2_vue_root_Vue_.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] = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.withKeys)(($event) => _ctx.autoHide && _ctx.$emit("hide"), ["esc"]))
-  }, [
-    (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementVNode)("div", {
-      class: "v-popper__backdrop",
-      onClick: _cache[0] || (_cache[0] = ($event) => _ctx.autoHide && _ctx.$emit("hide"))
-    }),
-    (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementVNode)("div", {
-      class: "v-popper__wrapper",
-      style: (0,external_commonjs_vue_commonjs2_vue_root_Vue_.normalizeStyle)(_ctx.result ? {
-        transformOrigin: _ctx.result.transformOrigin
-      } : void 0)
-    }, [
-      (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementVNode)("div", _hoisted_2$1, [
-        _ctx.mounted ? ((0,external_commonjs_vue_commonjs2_vue_root_Vue_.openBlock)(), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementBlock)(external_commonjs_vue_commonjs2_vue_root_Vue_.Fragment, { key: 0 }, [
-          (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementVNode)("div", null, [
-            (0,external_commonjs_vue_commonjs2_vue_root_Vue_.renderSlot)(_ctx.$slots, "default")
-          ]),
-          _ctx.handleResize ? ((0,external_commonjs_vue_commonjs2_vue_root_Vue_.openBlock)(), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createBlock)(_component_ResizeObserver, {
-            key: 0,
-            onNotify: _cache[1] || (_cache[1] = ($event) => _ctx.$emit("resize", $event))
-          })) : (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createCommentVNode)("", true)
-        ], 64)) : (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createCommentVNode)("", true)
-      ], 512),
-      (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementVNode)("div", {
-        ref: "arrow",
-        class: "v-popper__arrow-container",
-        style: (0,external_commonjs_vue_commonjs2_vue_root_Vue_.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);
-}
-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 = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.defineComponent)({
-  name: "VPopperWrapper",
-  components: {
-    Popper: Popper$1,
-    PopperContent: PrivatePopperContent
-  },
-  mixins: [
-    PrivatePopperMethods,
-    PrivateThemeClass("finalTheme")
-  ],
-  props: {
-    theme: {
-      type: String,
-      default: null
-    }
-  },
-  computed: {
-    finalTheme() {
-      var _a;
-      return (_a = this.theme) != null ? _a : this.$options.vPopperTheme;
-    }
-  },
-  methods: {
-    getTargetNodes() {
-      return Array.from(this.$el.children).filter((node) => node !== this.$refs.popperContent.$el);
-    }
-  }
-});
-function _sfc_render$1(_ctx, _cache, $props, $setup, $data, $options) {
-  const _component_PopperContent = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.resolveComponent)("PopperContent");
-  const _component_Popper = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.resolveComponent)("Popper");
-  return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.openBlock)(), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createBlock)(_component_Popper, {
-    ref: "popper",
-    theme: _ctx.finalTheme,
-    "target-nodes": _ctx.getTargetNodes,
-    "popper-node": () => _ctx.$refs.popperContent.$el,
-    class: (0,external_commonjs_vue_commonjs2_vue_root_Vue_.normalizeClass)([
-      _ctx.themeClass
-    ])
-  }, {
-    default: (0,external_commonjs_vue_commonjs2_vue_root_Vue_.withCtx)(({
-      popperId,
-      isShown,
-      shouldMountContent,
-      skipTransition,
-      autoHide,
-      show,
-      hide,
-      handleResize,
-      onResize,
-      classes,
-      result
-    }) => [
-      (0,external_commonjs_vue_commonjs2_vue_root_Vue_.renderSlot)(_ctx.$slots, "default", {
-        shown: isShown,
-        show,
-        hide
-      }),
-      (0,external_commonjs_vue_commonjs2_vue_root_Vue_.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: (0,external_commonjs_vue_commonjs2_vue_root_Vue_.withCtx)(() => [
-          (0,external_commonjs_vue_commonjs2_vue_root_Vue_.renderSlot)(_ctx.$slots, "popper", {
-            shown: isShown,
-            hide
-          })
-        ]),
-        _: 2
-      }, 1032, ["popper-id", "theme", "shown", "mounted", "skip-transition", "auto-hide", "handle-resize", "classes", "result", "onHide", "onResize"])
-    ]),
-    _: 3
-  }, 8, ["theme", "target-nodes", "popper-node", "class"]);
-}
-var PrivatePopperWrapper = /* @__PURE__ */ _export_sfc(_sfc_main$4, [["render", _sfc_render$1]]);
-var Dropdown_vue_vue_type_style_index_0_lang = "";
-const _sfc_main$3 = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.defineComponent)(__spreadProps(__spreadValues({}, PrivatePopperWrapper), {
-  name: "VDropdown",
-  vPopperTheme: "dropdown"
-}));
-const _sfc_main$2 = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.defineComponent)(__spreadProps(__spreadValues({}, PrivatePopperWrapper), {
-  name: "VMenu",
-  vPopperTheme: "menu"
-}));
-var Tooltip_vue_vue_type_style_index_0_lang = "";
-const _sfc_main$1 = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.defineComponent)(__spreadProps(__spreadValues({}, PrivatePopperWrapper), {
-  name: "VTooltip",
-  vPopperTheme: "tooltip"
-}));
-const _sfc_main = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.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 = ["innerHTML"];
-const _hoisted_2 = ["textContent"];
-function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
-  const _component_PopperContent = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.resolveComponent)("PopperContent");
-  const _component_Popper = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.resolveComponent)("Popper");
-  return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.openBlock)(), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createBlock)(_component_Popper, (0,external_commonjs_vue_commonjs2_vue_root_Vue_.mergeProps)({ ref: "popper" }, _ctx.$attrs, {
-    theme: _ctx.theme,
-    "popper-node": () => _ctx.$refs.popperContent.$el,
-    onApplyShow: _ctx.onShow,
-    onApplyHide: _ctx.onHide
-  }), {
-    default: (0,external_commonjs_vue_commonjs2_vue_root_Vue_.withCtx)(({
-      popperId,
-      isShown,
-      shouldMountContent,
-      skipTransition,
-      autoHide,
-      hide,
-      handleResize,
-      onResize,
-      classes,
-      result
-    }) => [
-      (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createVNode)(_component_PopperContent, {
-        ref: "popperContent",
-        class: (0,external_commonjs_vue_commonjs2_vue_root_Vue_.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: (0,external_commonjs_vue_commonjs2_vue_root_Vue_.withCtx)(() => [
-          _ctx.html ? ((0,external_commonjs_vue_commonjs2_vue_root_Vue_.openBlock)(), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementBlock)("div", {
-            key: 0,
-            innerHTML: _ctx.finalContent
-          }, null, 8, _hoisted_1)) : ((0,external_commonjs_vue_commonjs2_vue_root_Vue_.openBlock)(), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementBlock)("div", {
-            key: 1,
-            textContent: (0,external_commonjs_vue_commonjs2_vue_root_Vue_.toDisplayString)(_ctx.finalContent)
-          }, null, 8, _hoisted_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, [["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 = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)([]);
-  directiveApp = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createApp)({
-    name: "VTooltipDirectiveApp",
-    setup() {
-      return {
-        directives
-      };
-    },
-    render() {
-      return this.directives.map((directive) => {
-        return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)(PrivateTooltipDirective, __spreadProps(__spreadValues({}, directive.options), {
-          shown: directive.shown || 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 = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)(getOptions(el, value, modifiers));
-  const shown = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.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, modifiers }) {
-  const options2 = getOptions(el, value, modifiers);
-  if (!options2.content || getDefaultConfig(options2.theme || "tooltip", "disabled")) {
-    destroyTooltip(el);
-  } else {
-    let directive;
-    if (el.$_popper) {
-      directive = el.$_popper;
-      directive.options.value = options2;
-    } else {
-      directive = createTooltip(el, value, modifiers);
-    }
-    if (typeof value.shown !== "undefined" && value.shown !== el.$_popperOldShown) {
-      el.$_popperOldShown = value.shown;
-      value.shown ? directive.show() : directive.hide();
-    }
-  }
-}
-var PrivateVTooltip = {
-  beforeMount: bind,
-  updated: bind,
-  beforeUnmount(el) {
-    destroyTooltip(el);
-  }
-};
-function addListeners(el) {
-  el.addEventListener("click", onClick);
-  el.addEventListener("touchstart", onTouchStart, supportsPassive ? {
-    passive: true
-  } : false);
-}
-function removeListeners(el) {
-  el.removeEventListener("click", onClick);
-  el.removeEventListener("touchstart", onTouchStart);
-  el.removeEventListener("touchend", onTouchEnd);
-  el.removeEventListener("touchcancel", onTouchCancel);
-}
-function onClick(event) {
-  const el = event.currentTarget;
-  event.closePopover = !el.$_vclosepopover_touch;
-  event.closeAllPopover = el.$_closePopoverModifiers && !!el.$_closePopoverModifiers.all;
-}
-function onTouchStart(event) {
-  if (event.changedTouches.length === 1) {
-    const el = event.currentTarget;
-    el.$_vclosepopover_touch = true;
-    const touch = event.changedTouches[0];
-    el.$_vclosepopover_touchPoint = touch;
-    el.addEventListener("touchend", onTouchEnd);
-    el.addEventListener("touchcancel", onTouchCancel);
-  }
-}
-function onTouchEnd(event) {
-  const el = event.currentTarget;
-  el.$_vclosepopover_touch = false;
-  if (event.changedTouches.length === 1) {
-    const touch = event.changedTouches[0];
-    const firstTouch = el.$_vclosepopover_touchPoint;
-    event.closePopover = Math.abs(touch.screenY - firstTouch.screenY) < 20 && Math.abs(touch.screenX - firstTouch.screenX) < 20;
-    event.closeAllPopover = el.$_closePopoverModifiers && !!el.$_closePopoverModifiers.all;
-  }
-}
-function onTouchCancel(event) {
-  const el = event.currentTarget;
-  el.$_vclosepopover_touch = false;
-}
-var PrivateVClosePopper = {
-  beforeMount(el, { value, modifiers }) {
-    el.$_closePopoverModifiers = modifiers;
-    if (typeof value === "undefined" || value) {
-      addListeners(el);
-    }
-  },
-  updated(el, { value, oldValue, modifiers }) {
-    el.$_closePopoverModifiers = modifiers;
-    if (value !== oldValue) {
-      if (typeof value === "undefined" || value) {
-        addListeners(el);
-      } else {
-        removeListeners(el);
-      }
-    }
-  },
-  beforeUnmount(el) {
-    removeListeners(el);
-  }
-};
-const options = (/* unused pure expression or super */ null && (config));
-const VTooltip = (/* unused pure expression or super */ null && (PrivateVTooltip));
-const VClosePopper = (/* unused pure expression or super */ null && (PrivateVClosePopper));
-const Dropdown = (/* unused pure expression or super */ null && (_sfc_main$3));
-const Menu = (/* unused pure expression or super */ null && (_sfc_main$2));
-const Popper = (/* unused pure expression or super */ null && (PrivatePopper));
-const PopperContent = (/* unused pure expression or super */ null && (PrivatePopperContent));
-const PopperMethods = (/* unused pure expression or super */ null && (PrivatePopperMethods));
-const PopperWrapper = (/* unused pure expression or super */ null && (PrivatePopperWrapper));
-const ThemeClass = (/* unused pure expression or super */ null && (PrivateThemeClass));
-const Tooltip = (/* unused pure expression or super */ null && (_sfc_main$1));
-const TooltipDirective = (/* unused pure expression or super */ null && (PrivateTooltipDirective));
-function install(app, options2 = {}) {
-  if (app.$_vTooltipInstalled)
-    return;
-  app.$_vTooltipInstalled = true;
-  floating_vue_es_assign(config, options2);
-  app.directive("tooltip", PrivateVTooltip);
-  app.directive("close-popper", PrivateVClosePopper);
-  app.component("VTooltip", _sfc_main$1);
-  app.component("VDropdown", _sfc_main$3);
-  app.component("VMenu", _sfc_main$2);
-}
-const floating_vue_es_plugin = {
-  version: "2.0.0-beta.20",
-  install,
-  options: config
-};
-
-
 ;// CONCATENATED MODULE: ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-83.use[1]!./node_modules/vue-loader/dist/templateLoader.js??ruleSet[1].rules[3]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./src/components/atoms/wt-avatar/wt-avatar.vue?vue&type=template&id=9d3af56a&scoped=true
 
 const _withScopeId = n => (_pushScopeId("data-v-9d3af56a"), n = n(), _popScopeId(), n);
-const wt_avatarvue_type_template_id_9d3af56a_scoped_true_hoisted_1 = ["src"];
-function wt_avatarvue_type_template_id_9d3af56a_scoped_true_render(_ctx, _cache, $props, $setup, $data, $options) {
+const _hoisted_1 = ["src"];
+function render(_ctx, _cache, $props, $setup, $data, $options) {
   const _component_wt_badge = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.resolveComponent)("wt-badge");
   return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.openBlock)(), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementBlock)("div", {
     class: (0,external_commonjs_vue_commonjs2_vue_root_Vue_.normalizeClass)(["wt-avatar", [`wt-avatar--size-${$props.size}`]])
@@ -8649,7 +5313,7 @@ function wt_avatarvue_type_template_id_9d3af56a_scoped_true_render(_ctx, _cache,
     class: "wt-avatar__img",
     src: $options.imgSrc,
     alt: "avatar"
-  }, null, 8, wt_avatarvue_type_template_id_9d3af56a_scoped_true_hoisted_1)], 2);
+  }, null, 8, _hoisted_1)], 2);
 }
 ;// CONCATENATED MODULE: ./src/components/atoms/wt-avatar/wt-avatar.vue?vue&type=template&id=9d3af56a&scoped=true
 
@@ -8727,7 +5391,7 @@ var exportHelper = __webpack_require__(744);
 ;
 
 
-const __exports__ = /*#__PURE__*/(0,exportHelper/* default */.Z)(wt_avatarvue_type_script_lang_js, [['render',wt_avatarvue_type_template_id_9d3af56a_scoped_true_render],['__scopeId',"data-v-9d3af56a"]])
+const __exports__ = /*#__PURE__*/(0,exportHelper/* default */.Z)(wt_avatarvue_type_script_lang_js, [['render',render],['__scopeId',"data-v-9d3af56a"]])
 
 /* harmony default export */ var wt_avatar = (__exports__);
 ;// CONCATENATED MODULE: ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-83.use[1]!./node_modules/vue-loader/dist/templateLoader.js??ruleSet[1].rules[3]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./src/components/atoms/wt-badge/wt-badge.vue?vue&type=template&id=5ad93da4&scoped=true
@@ -8799,7 +5463,7 @@ const wt_iconvue_type_template_id_13e7ac92_scoped_true_withScopeId = n => (_push
 const wt_iconvue_type_template_id_13e7ac92_scoped_true_hoisted_1 = {
   class: "wt-icon__icon"
 };
-const wt_iconvue_type_template_id_13e7ac92_scoped_true_hoisted_2 = ["xlink:href"];
+const _hoisted_2 = ["xlink:href"];
 function wt_iconvue_type_template_id_13e7ac92_scoped_true_render(_ctx, _cache, $props, $setup, $data, $options) {
   return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.openBlock)(), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementBlock)("i", {
     class: (0,external_commonjs_vue_commonjs2_vue_root_Vue_.normalizeClass)(["wt-icon", [`wt-icon--size-${$props.size}`, `wt-icon--color-${$props.color}`, {
@@ -8807,7 +5471,7 @@ function wt_iconvue_type_template_id_13e7ac92_scoped_true_render(_ctx, _cache, $
     }]])
   }, [((0,external_commonjs_vue_commonjs2_vue_root_Vue_.openBlock)(), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementBlock)("svg", wt_iconvue_type_template_id_13e7ac92_scoped_true_hoisted_1, [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementVNode)("use", {
     "xlink:href": $options.iconName
-  }, null, 8, wt_iconvue_type_template_id_13e7ac92_scoped_true_hoisted_2)]))], 2);
+  }, null, 8, _hoisted_2)]))], 2);
 }
 ;// CONCATENATED MODULE: ./src/components/atoms/wt-icon/wt-icon.vue?vue&type=template&id=13e7ac92&scoped=true
 
@@ -9142,7 +5806,7 @@ var isVue2 = false
 var isVue3 = true
 var Vue2 = (/* unused pure expression or super */ null && (undefined))
 
-function lib_install() {}
+function install() {}
 
 function set(target, key, val) {
   if (Array.isArray(target)) {
@@ -9180,7 +5844,7 @@ function unwrapElement(element) {
  * @param options The arrow options.
  * @see https://floating-ui.com/docs/arrow
  */
-function floating_ui_vue_esm_arrow(options) {
+function arrow(options) {
   return {
     name: 'arrow',
     options,
@@ -9340,7 +6004,7 @@ function useFloating(reference, floating, options) {
 
 
 ;// CONCATENATED MODULE: ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-83.use[1]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./src/components/atoms/wt-tooltip/wt-tooltip.vue?vue&type=script&setup=true&lang=js
-/* provided dependency */ var wt_tooltipvue_type_script_setup_true_lang_js_console = __webpack_require__(108);
+/* provided dependency */ var console = __webpack_require__(108);
 
 
 
@@ -9350,6 +6014,10 @@ function useFloating(reference, floating, options) {
 /* harmony default export */ var wt_tooltipvue_type_script_setup_true_lang_js = ({
   __name: 'wt-tooltip',
   props: {
+    visible: {
+      type: Boolean,
+      default: false
+    },
     contrast: {
       type: Boolean,
       default: false
@@ -9392,14 +6060,14 @@ function useFloating(reference, floating, options) {
     const activator = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)(null);
     const floating = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)(null);
     const isVisible = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)(false);
-    const showTooltip = event => {
+    const showTooltip = (event = {}) => {
       if (isVisible.value) return;
       isVisible.value = true;
 
       // https://github.com/Akryum/floating-vue/blob/main/packages/floating-vue/src/components/Popper.ts#L884
       event.usedByTooltip = true;
     };
-    const hideTooltip = event => {
+    const hideTooltip = (event = {}) => {
       if (event.usedByTooltip) return;
       isVisible.value = false;
     };
@@ -9410,13 +6078,13 @@ function useFloating(reference, floating, options) {
           if (showEvent) {
             target.addEventListener(showEvent, showTooltip);
           } else {
-            wt_tooltipvue_type_script_setup_true_lang_js_console.log(`No Tooltip Show event for ${trigger} trigger`);
+            console.log(`No Tooltip Show event for ${trigger} trigger`);
           }
           const hideEvent = HIDE_EVENT_MAP[trigger];
           if (hideEvent) {
             target.addEventListener(hideEvent, hideTooltip);
           } else {
-            wt_tooltipvue_type_script_setup_true_lang_js_console.log(`No Tooltip Hide event for ${trigger} trigger`);
+            console.log(`No Tooltip Hide event for ${trigger} trigger`);
           }
         });
       };
@@ -9430,13 +6098,13 @@ function useFloating(reference, floating, options) {
           if (showEvent) {
             target.removeEventListener(showEvent, showTooltip);
           } else {
-            wt_tooltipvue_type_script_setup_true_lang_js_console.log(`No Tooltip Show event for ${trigger} trigger`);
+            console.log(`No Tooltip Show event for ${trigger} trigger`);
           }
           const hideEvent = HIDE_EVENT_MAP[trigger];
           if (hideEvent) {
             target.removeEventListener(hideEvent, hideTooltip);
           } else {
-            wt_tooltipvue_type_script_setup_true_lang_js_console.log(`No Tooltip Hide event for ${trigger} trigger`);
+            console.log(`No Tooltip Hide event for ${trigger} trigger`);
           }
         });
       };
@@ -9446,12 +6114,20 @@ function useFloating(reference, floating, options) {
     const {
       floatingStyles
     } = useFloating(activator, floating, {
+      placement: props.placement,
       // https://floating-ui.com/docs/middleware
-      middleware: [b(), O(), A(), L(8)]
+      middleware: [O(), A(), L(8)]
+    });
+    (0,external_commonjs_vue_commonjs2_vue_root_Vue_.watch)(props.visible, value => {
+      if (value) showTooltip();else hideTooltip();
+    });
+    (0,external_commonjs_vue_commonjs2_vue_root_Vue_.onMounted)(() => {
+      subscribeTriggers();
+      if (props.visible) showTooltip();
     });
-    (0,external_commonjs_vue_commonjs2_vue_root_Vue_.onMounted)(() => subscribeTriggers());
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.onBeforeUnmount)(() => unsubscribeTriggers());
     return (_ctx, _cache) => {
+      const _directive_clickaway = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.resolveDirective)("clickaway");
       return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.openBlock)(), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementBlock)("div", {
         class: (0,external_commonjs_vue_commonjs2_vue_root_Vue_.normalizeClass)([{
           'wt-tooltip--contrast': __props.contrast,
@@ -9461,21 +6137,23 @@ function useFloating(reference, floating, options) {
         ref_key: "activator",
         ref: activator,
         class: "wt-tooltip__activator"
-      }, [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.renderSlot)(_ctx.$slots, "activator")], 512), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementVNode)("div", {
+      }, [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.renderSlot)(_ctx.$slots, "activator")], 512), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.withDirectives)(((0,external_commonjs_vue_commonjs2_vue_root_Vue_.openBlock)(), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementBlock)("div", {
         ref_key: "floating",
         ref: floating,
         class: (0,external_commonjs_vue_commonjs2_vue_root_Vue_.normalizeClass)(["wt-tooltip__floating", [__props.popperClass]]),
         style: (0,external_commonjs_vue_commonjs2_vue_root_Vue_.normalizeStyle)((0,external_commonjs_vue_commonjs2_vue_root_Vue_.unref)(floatingStyles))
-      }, [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.renderSlot)(_ctx.$slots, "default")], 6)], 2);
+      }, [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.renderSlot)(_ctx.$slots, "default", (0,external_commonjs_vue_commonjs2_vue_root_Vue_.normalizeProps)((0,external_commonjs_vue_commonjs2_vue_root_Vue_.guardReactiveProps)({
+        hide: hideTooltip
+      })))], 6)), [[_directive_clickaway, hideTooltip]])], 2);
     };
   }
 });
 ;// CONCATENATED MODULE: ./src/components/atoms/wt-tooltip/wt-tooltip.vue?vue&type=script&setup=true&lang=js
  
-;// CONCATENATED MODULE: ./node_modules/mini-css-extract-plugin/dist/loader.js??clonedRuleSet-65.use[0]!./node_modules/css-loader/dist/cjs.js??clonedRuleSet-65.use[1]!./node_modules/vue-loader/dist/stylePostLoader.js!./node_modules/postcss-loader/dist/cjs.js??clonedRuleSet-65.use[2]!./node_modules/sass-loader/dist/cjs.js??clonedRuleSet-65.use[3]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./src/components/atoms/wt-tooltip/wt-tooltip.vue?vue&type=style&index=0&id=24739540&lang=scss&scoped=true
+;// CONCATENATED MODULE: ./node_modules/mini-css-extract-plugin/dist/loader.js??clonedRuleSet-65.use[0]!./node_modules/css-loader/dist/cjs.js??clonedRuleSet-65.use[1]!./node_modules/vue-loader/dist/stylePostLoader.js!./node_modules/postcss-loader/dist/cjs.js??clonedRuleSet-65.use[2]!./node_modules/sass-loader/dist/cjs.js??clonedRuleSet-65.use[3]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./src/components/atoms/wt-tooltip/wt-tooltip.vue?vue&type=style&index=0&id=73e084de&lang=scss&scoped=true
 // extracted by mini-css-extract-plugin
 
-;// CONCATENATED MODULE: ./src/components/atoms/wt-tooltip/wt-tooltip.vue?vue&type=style&index=0&id=24739540&lang=scss&scoped=true
+;// CONCATENATED MODULE: ./src/components/atoms/wt-tooltip/wt-tooltip.vue?vue&type=style&index=0&id=73e084de&lang=scss&scoped=true
 
 ;// CONCATENATED MODULE: ./src/components/atoms/wt-tooltip/wt-tooltip.vue
 
@@ -9484,7 +6162,7 @@ function useFloating(reference, floating, options) {
 ;
 
 
-const wt_tooltip_exports_ = /*#__PURE__*/(0,exportHelper/* default */.Z)(wt_tooltipvue_type_script_setup_true_lang_js, [['__scopeId',"data-v-24739540"]])
+const wt_tooltip_exports_ = /*#__PURE__*/(0,exportHelper/* default */.Z)(wt_tooltipvue_type_script_setup_true_lang_js, [['__scopeId',"data-v-73e084de"]])
 
 /* harmony default export */ var wt_tooltip = (wt_tooltip_exports_);
 ;// CONCATENATED MODULE: ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-83.use[1]!./node_modules/vue-loader/dist/templateLoader.js??ruleSet[1].rules[3]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./src/components/atoms/wt-rounded-action/wt-rounded-action.vue?vue&type=template&id=2877e1be&scoped=true
@@ -9657,9 +6335,9 @@ const wt_loader_mdvue_type_template_id_4cf61586_scoped_true_hoisted_2 = /*#__PUR
   width: "64",
   height: "64"
 })], -1));
-const wt_loader_mdvue_type_template_id_4cf61586_scoped_true_hoisted_3 = [wt_loader_mdvue_type_template_id_4cf61586_scoped_true_hoisted_2];
+const _hoisted_3 = [wt_loader_mdvue_type_template_id_4cf61586_scoped_true_hoisted_2];
 function wt_loader_mdvue_type_template_id_4cf61586_scoped_true_render(_ctx, _cache, $props, $setup, $data, $options) {
-  return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.openBlock)(), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementBlock)("div", wt_loader_mdvue_type_template_id_4cf61586_scoped_true_hoisted_1, wt_loader_mdvue_type_template_id_4cf61586_scoped_true_hoisted_3);
+  return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.openBlock)(), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementBlock)("div", wt_loader_mdvue_type_template_id_4cf61586_scoped_true_hoisted_1, _hoisted_3);
 }
 ;// CONCATENATED MODULE: ./src/components/atoms/wt-loader/_internals/wt-loader--md.vue?vue&type=template&id=4cf61586&scoped=true
 
@@ -9716,55 +6394,20 @@ const wt_loader_md_exports_ = /*#__PURE__*/(0,exportHelper/* default */.Z)(wt_lo
 const wt_loader_exports_ = /*#__PURE__*/(0,exportHelper/* default */.Z)(wt_loadervue_type_script_lang_js, [['render',wt_loadervue_type_template_id_9bbe5b8c_render]])
 
 /* harmony default export */ var wt_loader = (wt_loader_exports_);
-;// CONCATENATED MODULE: ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-83.use[1]!./node_modules/vue-loader/dist/templateLoader.js??ruleSet[1].rules[3]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./src/components/atoms/wt-context-menu/wt-context-menu.vue?vue&type=template&id=bbe96dac&scoped=true
-
-const wt_context_menuvue_type_template_id_bbe96dac_scoped_true_withScopeId = n => (_pushScopeId("data-v-bbe96dac"), n = n(), _popScopeId(), n);
-const wt_context_menuvue_type_template_id_bbe96dac_scoped_true_hoisted_1 = ["onClick"];
-function wt_context_menuvue_type_template_id_bbe96dac_scoped_true_render(_ctx, _cache, $props, $setup, $data, $options) {
-  const _component_v_dropdown = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.resolveComponent)("v-dropdown");
-  return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.openBlock)(), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createBlock)(_component_v_dropdown, {
-    class: "wt-context-menu",
-    shown: $props.visible,
-    triggers: ['click', 'touch'],
-    placement: "bottom-end"
-  }, {
-    popper: (0,external_commonjs_vue_commonjs2_vue_root_Vue_.withCtx)(({
-      hide
-    }) => [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementVNode)("ul", {
-      class: "wt-context-menu__menu",
-      style: (0,external_commonjs_vue_commonjs2_vue_root_Vue_.normalizeStyle)(`width: ${$props.width}; min-width: ${$props.minWidth}; max-width: ${$props.maxWidth};`)
-    }, [((0,external_commonjs_vue_commonjs2_vue_root_Vue_.openBlock)(true), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementBlock)(external_commonjs_vue_commonjs2_vue_root_Vue_.Fragment, null, (0,external_commonjs_vue_commonjs2_vue_root_Vue_.renderList)($props.options, (option, index) => {
-      return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.openBlock)(), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementBlock)("li", {
-        class: "wt-context-menu__option-wrapper",
-        key: index
-      }, [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementVNode)("a", {
-        class: "wt-context-menu__option",
-        href: "#",
-        onClick: (0,external_commonjs_vue_commonjs2_vue_root_Vue_.withModifiers)($event => $options.handleOptionClick({
-          option,
-          index,
-          hide
-        }), ["prevent"])
-      }, [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.renderSlot)(_ctx.$slots, "option", (0,external_commonjs_vue_commonjs2_vue_root_Vue_.normalizeProps)((0,external_commonjs_vue_commonjs2_vue_root_Vue_.guardReactiveProps)(option)), () => [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.createTextVNode)((0,external_commonjs_vue_commonjs2_vue_root_Vue_.toDisplayString)(option.text || option), 1)], true)], 8, wt_context_menuvue_type_template_id_bbe96dac_scoped_true_hoisted_1)]);
-    }), 128))], 4)]),
-    default: (0,external_commonjs_vue_commonjs2_vue_root_Vue_.withCtx)(() => [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.renderSlot)(_ctx.$slots, "activator", {}, undefined, true)], undefined, true),
-    _: 3
-  }, 8, ["shown"]);
-}
-;// CONCATENATED MODULE: ./src/components/atoms/wt-context-menu/wt-context-menu.vue?vue&type=template&id=bbe96dac&scoped=true
+;// CONCATENATED MODULE: ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-83.use[1]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./src/components/atoms/wt-context-menu/wt-context-menu.vue?vue&type=script&setup=true&lang=js
 
-;// CONCATENATED MODULE: ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-83.use[1]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./src/components/atoms/wt-context-menu/wt-context-menu.vue?vue&type=script&lang=js
-/* harmony default export */ var wt_context_menuvue_type_script_lang_js = ({
-  name: 'wt-context-menu',
+const wt_context_menuvue_type_script_setup_true_lang_js_withScopeId = n => (_pushScopeId("data-v-51f34e9e"), n = n(), _popScopeId(), n);
+const wt_context_menuvue_type_script_setup_true_lang_js_hoisted_1 = ["onClick"];
+/* harmony default export */ var wt_context_menuvue_type_script_setup_true_lang_js = ({
+  __name: 'wt-context-menu',
   props: {
     options: {
       type: Array,
       required: true,
-      description: '[{ text }] or [\'str\']'
+      description: '[{ text }]'
     },
     visible: {
-      type: Boolean,
-      default: false
+      type: Boolean
     },
     width: {
       type: [String],
@@ -9779,8 +6422,9 @@ function wt_context_menuvue_type_template_id_bbe96dac_scoped_true_render(_ctx, _
       default: '300px'
     }
   },
-  methods: {
-    handleOptionClick({
+  setup(__props) {
+    const props = __props;
+    function handleOptionClick({
       option,
       index,
       hide
@@ -9791,24 +6435,54 @@ function wt_context_menuvue_type_template_id_bbe96dac_scoped_true_render(_ctx, _
       });
       hide();
     }
+    return (_ctx, _cache) => {
+      const _component_wt_tooltip = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.resolveComponent)("wt-tooltip");
+      return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.openBlock)(), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createBlock)(_component_wt_tooltip, {
+        class: "wt-context-menu",
+        visible: __props.visible,
+        triggers: ['click', 'touch'],
+        placement: "bottom-end"
+      }, {
+        activator: (0,external_commonjs_vue_commonjs2_vue_root_Vue_.withCtx)(() => [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.renderSlot)(_ctx.$slots, "activator")]),
+        default: (0,external_commonjs_vue_commonjs2_vue_root_Vue_.withCtx)(({
+          hide
+        }) => [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementVNode)("ul", {
+          class: "wt-context-menu__menu",
+          style: (0,external_commonjs_vue_commonjs2_vue_root_Vue_.normalizeStyle)(`width: ${__props.width}; min-width: ${__props.minWidth}; max-width: ${__props.maxWidth};`)
+        }, [((0,external_commonjs_vue_commonjs2_vue_root_Vue_.openBlock)(true), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementBlock)(external_commonjs_vue_commonjs2_vue_root_Vue_.Fragment, null, (0,external_commonjs_vue_commonjs2_vue_root_Vue_.renderList)(__props.options, (option, index) => {
+          return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.openBlock)(), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementBlock)("li", {
+            class: "wt-context-menu__option-wrapper",
+            key: index
+          }, [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementVNode)("a", {
+            class: "wt-context-menu__option",
+            href: "#",
+            onClick: (0,external_commonjs_vue_commonjs2_vue_root_Vue_.withModifiers)($event => handleOptionClick({
+              option,
+              index,
+              hide
+            }), ["prevent"])
+          }, [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.renderSlot)(_ctx.$slots, "option", (0,external_commonjs_vue_commonjs2_vue_root_Vue_.normalizeProps)((0,external_commonjs_vue_commonjs2_vue_root_Vue_.guardReactiveProps)(option)), () => [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.createTextVNode)((0,external_commonjs_vue_commonjs2_vue_root_Vue_.toDisplayString)(option.text || option), 1)])], 8, wt_context_menuvue_type_script_setup_true_lang_js_hoisted_1)]);
+        }), 128))], 4)]),
+        _: 3
+      }, 8, ["visible"]);
+    };
   }
 });
-;// CONCATENATED MODULE: ./src/components/atoms/wt-context-menu/wt-context-menu.vue?vue&type=script&lang=js
+;// CONCATENATED MODULE: ./src/components/atoms/wt-context-menu/wt-context-menu.vue?vue&type=script&setup=true&lang=js
  
-;// CONCATENATED MODULE: ./node_modules/mini-css-extract-plugin/dist/loader.js??clonedRuleSet-65.use[0]!./node_modules/css-loader/dist/cjs.js??clonedRuleSet-65.use[1]!./node_modules/vue-loader/dist/stylePostLoader.js!./node_modules/postcss-loader/dist/cjs.js??clonedRuleSet-65.use[2]!./node_modules/sass-loader/dist/cjs.js??clonedRuleSet-65.use[3]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./src/components/atoms/wt-context-menu/wt-context-menu.vue?vue&type=style&index=0&id=bbe96dac&lang=scss&scoped=true
+;// CONCATENATED MODULE: ./node_modules/mini-css-extract-plugin/dist/loader.js??clonedRuleSet-65.use[0]!./node_modules/css-loader/dist/cjs.js??clonedRuleSet-65.use[1]!./node_modules/vue-loader/dist/stylePostLoader.js!./node_modules/postcss-loader/dist/cjs.js??clonedRuleSet-65.use[2]!./node_modules/sass-loader/dist/cjs.js??clonedRuleSet-65.use[3]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./src/components/atoms/wt-context-menu/wt-context-menu.vue?vue&type=style&index=0&id=51f34e9e&lang=scss&scoped=true
 // extracted by mini-css-extract-plugin
 
-;// CONCATENATED MODULE: ./src/components/atoms/wt-context-menu/wt-context-menu.vue?vue&type=style&index=0&id=bbe96dac&lang=scss&scoped=true
+;// CONCATENATED MODULE: ./src/components/atoms/wt-context-menu/wt-context-menu.vue?vue&type=style&index=0&id=51f34e9e&lang=scss&scoped=true
 
 ;// CONCATENATED MODULE: ./src/components/atoms/wt-context-menu/wt-context-menu.vue
 
 
 
-
 ;
 
 
-const wt_context_menu_exports_ = /*#__PURE__*/(0,exportHelper/* default */.Z)(wt_context_menuvue_type_script_lang_js, [['render',wt_context_menuvue_type_template_id_bbe96dac_scoped_true_render],['__scopeId',"data-v-bbe96dac"]])
+const wt_context_menu_exports_ = /*#__PURE__*/(0,exportHelper/* default */.Z)(wt_context_menuvue_type_script_setup_true_lang_js, [['__scopeId',"data-v-51f34e9e"]])
 
 /* harmony default export */ var wt_context_menu = (wt_context_menu_exports_);
 ;// CONCATENATED MODULE: ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-83.use[1]!./node_modules/vue-loader/dist/templateLoader.js??ruleSet[1].rules[3]!./node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./src/components/molecules/wt-checkbox/wt-checkbox.vue?vue&type=template&id=3460d02e&scoped=true
@@ -22719,7 +19393,7 @@ const wt_popupvue_type_template_id_f37b5e8a_scoped_true_hoisted_3 = {
   key: 0,
   class: "wt-popup__main"
 };
-const wt_popupvue_type_template_id_f37b5e8a_scoped_true_hoisted_4 = {
+const _hoisted_4 = {
   key: 1,
   class: "wt-popup__actions"
 };
@@ -22736,7 +19410,7 @@ function wt_popupvue_type_template_id_f37b5e8a_scoped_true_render(_ctx, _cache,
     class: "wt-popup__close-btn",
     icon: "close",
     onClick: _cache[0] || (_cache[0] = $event => _ctx.$emit('close'))
-  })]), _ctx.$slots.main ? ((0,external_commonjs_vue_commonjs2_vue_root_Vue_.openBlock)(), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementBlock)("section", wt_popupvue_type_template_id_f37b5e8a_scoped_true_hoisted_3, [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.renderSlot)(_ctx.$slots, "main", {}, undefined, true)])) : (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createCommentVNode)("", true), _ctx.$slots.actions ? ((0,external_commonjs_vue_commonjs2_vue_root_Vue_.openBlock)(), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementBlock)("footer", wt_popupvue_type_template_id_f37b5e8a_scoped_true_hoisted_4, [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.renderSlot)(_ctx.$slots, "actions", {}, undefined, true)])) : (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createCommentVNode)("", true)], 4)], 2);
+  })]), _ctx.$slots.main ? ((0,external_commonjs_vue_commonjs2_vue_root_Vue_.openBlock)(), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementBlock)("section", wt_popupvue_type_template_id_f37b5e8a_scoped_true_hoisted_3, [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.renderSlot)(_ctx.$slots, "main", {}, undefined, true)])) : (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createCommentVNode)("", true), _ctx.$slots.actions ? ((0,external_commonjs_vue_commonjs2_vue_root_Vue_.openBlock)(), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createElementBlock)("footer", _hoisted_4, [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.renderSlot)(_ctx.$slots, "actions", {}, undefined, true)])) : (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createCommentVNode)("", true)], 4)], 2);
 }
 ;// CONCATENATED MODULE: ./src/components/molecules/wt-popup/wt-popup.vue?vue&type=template&id=f37b5e8a&scoped=true
 
@@ -24078,7 +20752,7 @@ var pointerMixin = {
   }
 };
 
-var vue_multiselect_esm_script = {
+var script = {
   name: 'vue-multiselect',
   mixins: [multiselectMixin, pointerMixin],
   props: {
@@ -24312,7 +20986,7 @@ const vue_multiselect_esm_hoisted_1 = {
 const vue_multiselect_esm_hoisted_2 = { class: "multiselect__tags-wrap" };
 const vue_multiselect_esm_hoisted_3 = { class: "multiselect__spinner" };
 const vue_multiselect_esm_hoisted_4 = { key: 0 };
-const vue_multiselect_esm_hoisted_5 = { class: "multiselect__option" };
+const _hoisted_5 = { class: "multiselect__option" };
 const _hoisted_6 = { class: "multiselect__option" };
 const _hoisted_7 = /*#__PURE__*/(0,external_commonjs_vue_commonjs2_vue_root_Vue_.createTextVNode)("No elements found. Consider changing the search query.");
 const _hoisted_8 = { class: "multiselect__option" };
@@ -24462,7 +21136,7 @@ function vue_multiselect_esm_render(_ctx, _cache, $props, $setup, $data, $option
             (0,external_commonjs_vue_commonjs2_vue_root_Vue_.renderSlot)(_ctx.$slots, "beforeList"),
             (_ctx.multiple && _ctx.max === _ctx.internalValue.length)
               ? ((0,external_commonjs_vue_commonjs2_vue_root_Vue_.openBlock)(), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createBlock)("li", vue_multiselect_esm_hoisted_4, [
-                  (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createVNode)("span", vue_multiselect_esm_hoisted_5, [
+                  (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createVNode)("span", _hoisted_5, [
                     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.renderSlot)(_ctx.$slots, "maxElements", {}, () => [
                       (0,external_commonjs_vue_commonjs2_vue_root_Vue_.createTextVNode)("Maximum of " + (0,external_commonjs_vue_commonjs2_vue_root_Vue_.toDisplayString)(_ctx.max) + " options selected. First remove a selected option to select another.", 1 /* TEXT */)
                     ])
@@ -24546,9 +21220,9 @@ function vue_multiselect_esm_render(_ctx, _cache, $props, $setup, $data, $option
   ], 42 /* CLASS, PROPS, HYDRATE_EVENTS */, ["tabindex", "aria-owns"]))
 }
 
-vue_multiselect_esm_script.render = vue_multiselect_esm_render;
+script.render = vue_multiselect_esm_render;
 
-/* harmony default export */ var vue_multiselect_esm = (vue_multiselect_esm_script);
+/* harmony default export */ var vue_multiselect_esm = (script);
 
 
 ;// CONCATENATED MODULE: ./node_modules/vue-observe-visibility/dist/vue-observe-visibility.esm.js
@@ -24779,7 +21453,7 @@ function () {
   return VisibilityState;
 }();
 
-function vue_observe_visibility_esm_bind(el, _ref2, vnode) {
+function bind(el, _ref2, vnode) {
   var value = _ref2.value;
   if (!value) return;
 
@@ -24805,7 +21479,7 @@ function update(el, _ref3, vnode) {
   if (state) {
     state.createObserver(value, vnode);
   } else {
-    vue_observe_visibility_esm_bind(el, {
+    bind(el, {
       value: value
     }, vnode);
   }
@@ -24821,7 +21495,7 @@ function unbind(el) {
 }
 
 var ObserveVisibility = {
-  bind: vue_observe_visibility_esm_bind,
+  bind: bind,
   update: update,
   unbind: unbind
 };
@@ -34633,12 +31307,9 @@ const clickaway = {
 const Directives = {
   clickaway: clickaway_clickaway
 };
-/* harmony default export */ var src_directives = (Directives);
+/* harmony default export */ var directives = (Directives);
 ;// CONCATENATED MODULE: ./src/install.js
 /* eslint-disable */
-
-
-
  // init all components
  // init all directives
 
@@ -34648,8 +31319,8 @@ const Directives = {
     router,
     globals = {}
   }) {
-    Object.keys(src_directives).forEach(name => {
-      app.directive(name, src_directives[name]);
+    Object.keys(directives).forEach(name => {
+      app.directive(name, directives[name]);
     });
     Object.keys(components).forEach(name => {
       app.component(name, components[name]);
@@ -34662,7 +31333,6 @@ const Directives = {
     });
     app.provide('$eventBus', eventBus);
     if (router) app.use(router);
-    app.use(floating_vue_es_plugin);
   }
 });
 ;// CONCATENATED MODULE: ./node_modules/@vue/cli-service/lib/commands/build/entry-lib.js