@webitel/ui-sdk 1.0.42 → 1.0.43

package/dist/ui-sdk.common.js

@@ -11939,9 +11939,3411 @@ var es_array_filter = __webpack_require__(7327);
 ;// CONCATENATED MODULE: external {"commonjs":"vue","commonjs2":"vue","root":"Vue"}
 var external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject = require("vue");
 var external_commonjs_vue_commonjs2_vue_root_Vue_default = /*#__PURE__*/__webpack_require__.n(external_commonjs_vue_commonjs2_vue_root_Vue_namespaceObject);
+;// 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__(5108);
+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));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+
+
+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() {
+    const props = this.$props;
+    return getDefaultConfig(props.theme, prop);
+  };
+}
+const PROVIDE_KEY = "__floating-vue__popper";
+var PrivatePopper = () => ({
+  name: "VPopper",
+  props: {
+    theme: {
+      type: String,
+      required: true
+    },
+    targetNodes: {
+      type: Function,
+      required: true
+    },
+    referenceNode: {
+      type: Function,
+      required: true
+    },
+    popperNode: {
+      type: Function,
+      required: true
+    },
+    shown: {
+      type: Boolean,
+      default: false
+    },
+    showGroup: {
+      type: String,
+      default: null
+    },
+    ariaId: {
+      default: null
+    },
+    disabled: {
+      type: Boolean,
+      default: defaultPropFactory("disabled")
+    },
+    positioningDisabled: {
+      type: Boolean,
+      default: defaultPropFactory("positioningDisabled")
+    },
+    placement: {
+      type: String,
+      default: defaultPropFactory("placement"),
+      validator: (value) => placements.includes(value)
+    },
+    delay: {
+      type: [String, Number, Object],
+      default: defaultPropFactory("delay")
+    },
+    distance: {
+      type: [Number, String],
+      default: defaultPropFactory("distance")
+    },
+    skidding: {
+      type: [Number, String],
+      default: defaultPropFactory("skidding")
+    },
+    triggers: {
+      type: Array,
+      default: defaultPropFactory("triggers")
+    },
+    showTriggers: {
+      type: [Array, Function],
+      default: defaultPropFactory("showTriggers")
+    },
+    hideTriggers: {
+      type: [Array, Function],
+      default: defaultPropFactory("hideTriggers")
+    },
+    popperTriggers: {
+      type: Array,
+      default: defaultPropFactory("popperTriggers")
+    },
+    popperShowTriggers: {
+      type: [Array, Function],
+      default: defaultPropFactory("popperShowTriggers")
+    },
+    popperHideTriggers: {
+      type: [Array, Function],
+      default: defaultPropFactory("popperHideTriggers")
+    },
+    container: {
+      type: [String, Object, Element, Boolean],
+      default: defaultPropFactory("container")
+    },
+    boundary: {
+      type: [String, Element],
+      default: defaultPropFactory("boundary")
+    },
+    strategy: {
+      type: String,
+      validator: (value) => ["absolute", "fixed"].includes(value),
+      default: defaultPropFactory("strategy")
+    },
+    autoHide: {
+      type: [Boolean, 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")
+    }
+  },
+  provide() {
+    return {
+      [PROVIDE_KEY]: {
+        parentPopper: this
+      }
+    };
+  },
+  inject: {
+    [PROVIDE_KEY]: { default: null }
+  },
+  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: /* @__PURE__ */ 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
+      };
+    },
+    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();
+  },
+  beforeDestroy() {
+    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() {
+      if (!this.$_isDisposed)
+        return;
+      this.$_isDisposed = false;
+      this.isMounted = false;
+      this.$_events = [];
+      this.$_preventShow = false;
+      this.$_referenceNode = this.referenceNode();
+      this.$_targetNodes = this.targetNodes().filter((e) => e.nodeType === e.ELEMENT_NODE);
+      this.$_popperNode = this.popperNode();
+      this.$_innerNode = this.$_popperNode.querySelector(".v-popper__inner");
+      this.$_arrowNode = this.$_popperNode.querySelector(".v-popper__arrow-container");
+      this.$_swapTargetAttrs("title", "data-original-title");
+      this.$_detachPopperNode();
+      if (this.triggers.length) {
+        this.$_addEventListeners();
+      }
+      if (this.shown) {
+        this.show();
+      }
+    },
+    dispose() {
+      if (this.$_isDisposed)
+        return;
+      this.$_isDisposed = true;
+      this.$_removeEventListeners();
+      this.hide({ skipDelay: true });
+      this.$_detachPopperNode();
+      this.isMounted = false;
+      this.isShown = false;
+      this.$_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;
+      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.$el.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.$scopedSlots.default(this.slotData)[0];
+  }
+});
+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;
+}
+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;
+}
+var 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
+    }
+  },
+  mounted: function mounted() {
+    var _this = this;
+    initCompat();
+    this.$nextTick(function() {
+      _this._w = _this.$el.offsetWidth;
+      _this._h = _this.$el.offsetHeight;
+      if (_this.emitOnMount) {
+        _this.emitSize();
+      }
+    });
+    var 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);
+    }
+  },
+  beforeDestroy: function beforeDestroy() {
+    this.removeResizeHandlers();
+  },
+  methods: {
+    compareAndNotify: function 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: function emitSize() {
+      this.$emit("notify", {
+        width: this._w,
+        height: this._h
+      });
+    },
+    addResizeHandlers: function addResizeHandlers() {
+      this._resizeObject.contentDocument.defaultView.addEventListener("resize", this.compareAndNotify);
+      this.compareAndNotify();
+    },
+    removeResizeHandlers: function 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;
+      }
+    }
+  }
+};
+function normalizeComponent$1(template, style, script2, scopeId, isFunctionalTemplate, moduleIdentifier, shadowMode, createInjector, createInjectorSSR, createInjectorShadow) {
+  if (typeof shadowMode !== "boolean") {
+    createInjectorSSR = createInjector;
+    createInjector = shadowMode;
+    shadowMode = false;
+  }
+  var options2 = typeof script2 === "function" ? script2.options : script2;
+  if (template && template.render) {
+    options2.render = template.render;
+    options2.staticRenderFns = template.staticRenderFns;
+    options2._compiled = true;
+    if (isFunctionalTemplate) {
+      options2.functional = true;
+    }
+  }
+  if (scopeId) {
+    options2._scopeId = scopeId;
+  }
+  var hook;
+  if (moduleIdentifier) {
+    hook = function hook2(context) {
+      context = context || this.$vnode && this.$vnode.ssrContext || this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext;
+      if (!context && typeof __VUE_SSR_CONTEXT__ !== "undefined") {
+        context = __VUE_SSR_CONTEXT__;
+      }
+      if (style) {
+        style.call(this, createInjectorSSR(context));
+      }
+      if (context && context._registeredComponents) {
+        context._registeredComponents.add(moduleIdentifier);
+      }
+    };
+    options2._ssrRegister = hook;
+  } else if (style) {
+    hook = shadowMode ? function(context) {
+      style.call(this, createInjectorShadow(context, this.$root.$options.shadowRoot));
+    } : function(context) {
+      style.call(this, createInjector(context));
+    };
+  }
+  if (hook) {
+    if (options2.functional) {
+      var originalRender = options2.render;
+      options2.render = function renderWithStyleInjection(h, context) {
+        hook.call(context);
+        return originalRender(h, context);
+      };
+    } else {
+      var existing = options2.beforeCreate;
+      options2.beforeCreate = existing ? [].concat(existing, hook) : [hook];
+    }
+  }
+  return script2;
+}
+var __vue_script__ = script;
+var __vue_render__ = function __vue_render__2() {
+  var _vm = this;
+  var _h = _vm.$createElement;
+  var _c = _vm._self._c || _h;
+  return _c("div", {
+    staticClass: "resize-observer",
+    attrs: {
+      tabindex: "-1"
+    }
+  });
+};
+var __vue_staticRenderFns__ = [];
+__vue_render__._withStripped = true;
+var __vue_inject_styles__ = void 0;
+var __vue_scope_id__ = "data-v-8859cc6c";
+var __vue_module_identifier__ = void 0;
+var __vue_is_functional_template__ = false;
+var __vue_component__ = /* @__PURE__ */ normalizeComponent$1({
+  render: __vue_render__,
+  staticRenderFns: __vue_staticRenderFns__
+}, __vue_inject_styles__, __vue_script__, __vue_scope_id__, __vue_is_functional_template__, __vue_module_identifier__, false, void 0, void 0, void 0);
+function install$1(Vue2) {
+  Vue2.component("resize-observer", __vue_component__);
+  Vue2.component("ResizeObserver", __vue_component__);
+}
+var plugin$1 = {
+  version: "1.0.1",
+  install: install$1
+};
+var GlobalVue$1 = null;
+if (typeof window !== "undefined") {
+  GlobalVue$1 = window.Vue;
+} else if (typeof __webpack_require__.g !== "undefined") {
+  GlobalVue$1 = __webpack_require__.g.Vue;
+}
+if (GlobalVue$1) {
+  GlobalVue$1.use(plugin$1);
+}
+var PrivateThemeClass = {
+  computed: {
+    themeClass() {
+      return getThemeClasses(this.theme);
+    }
+  }
+};
+var __vue2_script$5 = {
+  name: "VPopperContent",
+  components: {
+    ResizeObserver: __vue_component__
+  },
+  mixins: [
+    PrivateThemeClass
+  ],
+  props: {
+    popperId: String,
+    theme: String,
+    shown: Boolean,
+    mounted: Boolean,
+    skipTransition: Boolean,
+    autoHide: Boolean,
+    handleResize: Boolean,
+    classes: Object,
+    result: Object
+  },
+  methods: {
+    toPx(value) {
+      if (value != null && !isNaN(value)) {
+        return `${value}px`;
+      }
+      return null;
+    }
+  }
+};
+var render$2 = function() {
+  var _vm = this;
+  var _h = _vm.$createElement;
+  var _c = _vm._self._c || _h;
+  return _c("div", { ref: "popover", staticClass: "v-popper__popper", class: [
+    _vm.themeClass,
+    _vm.classes.popperClass,
+    {
+      "v-popper__popper--shown": _vm.shown,
+      "v-popper__popper--hidden": !_vm.shown,
+      "v-popper__popper--show-from": _vm.classes.showFrom,
+      "v-popper__popper--show-to": _vm.classes.showTo,
+      "v-popper__popper--hide-from": _vm.classes.hideFrom,
+      "v-popper__popper--hide-to": _vm.classes.hideTo,
+      "v-popper__popper--skip-transition": _vm.skipTransition,
+      "v-popper__popper--arrow-overflow": _vm.result && _vm.result.arrow.overflow,
+      "v-popper__popper--no-positioning": !_vm.result
+    }
+  ], style: _vm.result ? {
+    position: _vm.result.strategy,
+    transform: "translate3d(" + Math.round(_vm.result.x) + "px," + Math.round(_vm.result.y) + "px,0)"
+  } : void 0, attrs: { "id": _vm.popperId, "aria-hidden": _vm.shown ? "false" : "true", "tabindex": _vm.autoHide ? 0 : void 0, "data-popper-placement": _vm.result ? _vm.result.placement : void 0 }, on: { "keyup": function($event) {
+    if (!$event.type.indexOf("key") && _vm._k($event.keyCode, "esc", 27, $event.key, ["Esc", "Escape"])) {
+      return null;
+    }
+    _vm.autoHide && _vm.$emit("hide");
+  } } }, [_c("div", { staticClass: "v-popper__backdrop", on: { "click": function($event) {
+    _vm.autoHide && _vm.$emit("hide");
+  } } }), _c("div", { staticClass: "v-popper__wrapper", style: _vm.result ? {
+    transformOrigin: _vm.result.transformOrigin
+  } : void 0 }, [_c("div", { ref: "inner", staticClass: "v-popper__inner" }, [_vm.mounted ? [_c("div", [_vm._t("default")], 2), _vm.handleResize ? _c("ResizeObserver", { on: { "notify": function($event) {
+    return _vm.$emit("resize", $event);
+  } } }) : _vm._e()] : _vm._e()], 2), _c("div", { ref: "arrow", staticClass: "v-popper__arrow-container", style: _vm.result ? {
+    left: _vm.toPx(_vm.result.arrow.x),
+    top: _vm.toPx(_vm.result.arrow.y)
+  } : void 0 }, [_c("div", { staticClass: "v-popper__arrow-outer" }), _c("div", { staticClass: "v-popper__arrow-inner" })])])]);
+};
+var staticRenderFns$2 = [];
+var PopperContent_vue_vue_type_style_index_0_lang = "";
+function normalizeComponent(scriptExports, render2, staticRenderFns2, functionalTemplate, injectStyles, scopeId, moduleIdentifier, shadowMode) {
+  var options2 = typeof scriptExports === "function" ? scriptExports.options : scriptExports;
+  if (render2) {
+    options2.render = render2;
+    options2.staticRenderFns = staticRenderFns2;
+    options2._compiled = true;
+  }
+  if (functionalTemplate) {
+    options2.functional = true;
+  }
+  if (scopeId) {
+    options2._scopeId = "data-v-" + scopeId;
+  }
+  var hook;
+  if (moduleIdentifier) {
+    hook = function(context) {
+      context = context || this.$vnode && this.$vnode.ssrContext || this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext;
+      if (!context && typeof __VUE_SSR_CONTEXT__ !== "undefined") {
+        context = __VUE_SSR_CONTEXT__;
+      }
+      if (injectStyles) {
+        injectStyles.call(this, context);
+      }
+      if (context && context._registeredComponents) {
+        context._registeredComponents.add(moduleIdentifier);
+      }
+    };
+    options2._ssrRegister = hook;
+  } else if (injectStyles) {
+    hook = shadowMode ? function() {
+      injectStyles.call(this, (options2.functional ? this.parent : this).$root.$options.shadowRoot);
+    } : injectStyles;
+  }
+  if (hook) {
+    if (options2.functional) {
+      options2._injectStyles = hook;
+      var originalRender = options2.render;
+      options2.render = function renderWithStyleInjection(h, context) {
+        hook.call(context);
+        return originalRender(h, context);
+      };
+    } else {
+      var existing = options2.beforeCreate;
+      options2.beforeCreate = existing ? [].concat(existing, hook) : [hook];
+    }
+  }
+  return {
+    exports: scriptExports,
+    options: options2
+  };
+}
+const __cssModules$5 = {};
+var __component__$5 = /* @__PURE__ */ normalizeComponent(__vue2_script$5, render$2, staticRenderFns$2, false, __vue2_injectStyles$5, null, null, null);
+function __vue2_injectStyles$5(context) {
+  for (let o in __cssModules$5) {
+    this[o] = __cssModules$5[o];
+  }
+}
+var PrivatePopperContent = /* @__PURE__ */ function() {
+  return __component__$5.exports;
+}();
+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);
+    }
+  }
+};
+var __vue2_script$4 = {
+  name: "VPopperWrapper",
+  components: {
+    Popper: PrivatePopper(),
+    PopperContent: PrivatePopperContent
+  },
+  mixins: [
+    PrivatePopperMethods,
+    PrivateThemeClass
+  ],
+  inheritAttrs: false,
+  props: {
+    theme: {
+      type: String,
+      default() {
+        return this.$options.vPopperTheme;
+      }
+    }
+  },
+  methods: {
+    getTargetNodes() {
+      return Array.from(this.$refs.reference.children).filter((node) => node !== this.$refs.popperContent.$el);
+    }
+  }
+};
+var render$1 = function() {
+  var _vm = this;
+  var _h = _vm.$createElement;
+  var _c = _vm._self._c || _h;
+  return _c("Popper", _vm._g(_vm._b({ ref: "popper", attrs: { "theme": _vm.theme, "target-nodes": _vm.getTargetNodes, "reference-node": function() {
+    return _vm.$refs.reference;
+  }, "popper-node": function() {
+    return _vm.$refs.popperContent.$el;
+  } }, scopedSlots: _vm._u([{ key: "default", fn: function(ref) {
+    var popperId = ref.popperId;
+    var isShown = ref.isShown;
+    var shouldMountContent = ref.shouldMountContent;
+    var skipTransition = ref.skipTransition;
+    var autoHide = ref.autoHide;
+    var show = ref.show;
+    var hide = ref.hide;
+    var handleResize = ref.handleResize;
+    var onResize = ref.onResize;
+    var classes = ref.classes;
+    var result = ref.result;
+    return [_c("div", { ref: "reference", staticClass: "v-popper", class: [
+      _vm.themeClass,
+      {
+        "v-popper--shown": isShown
+      }
+    ] }, [_vm._t("default", null, { "shown": isShown, "show": show, "hide": hide }), _c("PopperContent", { ref: "popperContent", attrs: { "popper-id": popperId, "theme": _vm.theme, "shown": isShown, "mounted": shouldMountContent, "skip-transition": skipTransition, "auto-hide": autoHide, "handle-resize": handleResize, "classes": classes, "result": result }, on: { "hide": hide, "resize": onResize } }, [_vm._t("popper", null, { "shown": isShown, "hide": hide })], 2)], 2)];
+  } }], null, true) }, "Popper", _vm.$attrs, false), _vm.$listeners));
+};
+var staticRenderFns$1 = [];
+const __cssModules$4 = {};
+var __component__$4 = /* @__PURE__ */ normalizeComponent(__vue2_script$4, render$1, staticRenderFns$1, false, __vue2_injectStyles$4, null, null, null);
+function __vue2_injectStyles$4(context) {
+  for (let o in __cssModules$4) {
+    this[o] = __cssModules$4[o];
+  }
+}
+var PrivatePopperWrapper = /* @__PURE__ */ function() {
+  return __component__$4.exports;
+}();
+var __vue2_script$3 = __spreadProps(__spreadValues({}, PrivatePopperWrapper), {
+  name: "VDropdown",
+  vPopperTheme: "dropdown"
+});
+var Dropdown_vue_vue_type_style_index_0_lang = "";
+let __vue2_render$2, __vue2_staticRenderFns$2;
+const __cssModules$3 = {};
+var __component__$3 = /* @__PURE__ */ normalizeComponent(__vue2_script$3, __vue2_render$2, __vue2_staticRenderFns$2, false, __vue2_injectStyles$3, null, null, null);
+function __vue2_injectStyles$3(context) {
+  for (let o in __cssModules$3) {
+    this[o] = __cssModules$3[o];
+  }
+}
+var PrivateDropdown = /* @__PURE__ */ function() {
+  return __component__$3.exports;
+}();
+var __vue2_script$2 = __spreadProps(__spreadValues({}, PrivatePopperWrapper), {
+  name: "VMenu",
+  vPopperTheme: "menu"
+});
+let __vue2_render$1, __vue2_staticRenderFns$1;
+const __cssModules$2 = {};
+var __component__$2 = /* @__PURE__ */ normalizeComponent(__vue2_script$2, __vue2_render$1, __vue2_staticRenderFns$1, false, __vue2_injectStyles$2, null, null, null);
+function __vue2_injectStyles$2(context) {
+  for (let o in __cssModules$2) {
+    this[o] = __cssModules$2[o];
+  }
+}
+var PrivateMenu = /* @__PURE__ */ function() {
+  return __component__$2.exports;
+}();
+var __vue2_script$1 = __spreadProps(__spreadValues({}, PrivatePopperWrapper), {
+  name: "VTooltip",
+  vPopperTheme: "tooltip"
+});
+var Tooltip_vue_vue_type_style_index_0_lang = "";
+let __vue2_render, __vue2_staticRenderFns;
+const __cssModules$1 = {};
+var __component__$1 = /* @__PURE__ */ normalizeComponent(__vue2_script$1, __vue2_render, __vue2_staticRenderFns, false, __vue2_injectStyles$1, null, null, null);
+function __vue2_injectStyles$1(context) {
+  for (let o in __cssModules$1) {
+    this[o] = __cssModules$1[o];
+  }
+}
+var PrivateTooltip = /* @__PURE__ */ function() {
+  return __component__$1.exports;
+}();
+var __vue2_script = {
+  name: "VTooltipDirective",
+  components: {
+    Popper: PrivatePopper(),
+    PopperContent: PrivatePopperContent
+  },
+  mixins: [
+    PrivatePopperMethods
+  ],
+  inheritAttrs: false,
+  props: {
+    theme: {
+      type: String,
+      default: "tooltip"
+    },
+    html: {
+      type: Boolean,
+      default() {
+        return getDefaultConfig(this.theme, "html");
+      }
+    },
+    content: {
+      type: [String, Number, Function],
+      default: null
+    },
+    loadingContent: {
+      type: String,
+      default() {
+        return getDefaultConfig(this.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(value) {
+      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;
+    }
+  }
+};
+var render = function() {
+  var _vm = this;
+  var _h = _vm.$createElement;
+  var _c = _vm._self._c || _h;
+  return _c("Popper", _vm._g(_vm._b({ ref: "popper", attrs: { "theme": _vm.theme, "popper-node": function() {
+    return _vm.$refs.popperContent.$el;
+  } }, on: { "apply-show": _vm.onShow, "apply-hide": _vm.onHide }, scopedSlots: _vm._u([{ key: "default", fn: function(ref) {
+    var popperId = ref.popperId;
+    var isShown = ref.isShown;
+    var shouldMountContent = ref.shouldMountContent;
+    var skipTransition = ref.skipTransition;
+    var autoHide = ref.autoHide;
+    var hide = ref.hide;
+    var handleResize = ref.handleResize;
+    var onResize = ref.onResize;
+    var classes = ref.classes;
+    var result = ref.result;
+    return [_c("PopperContent", { ref: "popperContent", class: {
+      "v-popper--tooltip-loading": _vm.loading
+    }, attrs: { "popper-id": popperId, "theme": _vm.theme, "shown": isShown, "mounted": shouldMountContent, "skip-transition": skipTransition, "auto-hide": autoHide, "handle-resize": handleResize, "classes": classes, "result": result }, on: { "hide": hide, "resize": onResize } }, [_vm.html ? _c("div", { domProps: { "innerHTML": _vm._s(_vm.finalContent) } }) : _c("div", { domProps: { "textContent": _vm._s(_vm.finalContent) } })])];
+  } }]) }, "Popper", _vm.$attrs, false), _vm.$listeners));
+};
+var staticRenderFns = [];
+const __cssModules = {};
+var __component__ = /* @__PURE__ */ normalizeComponent(__vue2_script, render, staticRenderFns, false, __vue2_injectStyles, null, null, null);
+function __vue2_injectStyles(context) {
+  for (let o in __cssModules) {
+    this[o] = __cssModules[o];
+  }
+}
+var PrivateTooltipDirective = /* @__PURE__ */ function() {
+  return __component__.exports;
+}();
+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;
+}
+function createTooltip(el, value, modifiers) {
+  const options2 = getOptions(el, value, modifiers);
+  const tooltipApp = el.$_popper = new (external_commonjs_vue_commonjs2_vue_root_Vue_default())({
+    mixins: [
+      PrivatePopperMethods
+    ],
+    data() {
+      return {
+        options: options2
+      };
+    },
+    render(h) {
+      const _a = this.options, {
+        theme,
+        html,
+        content,
+        loadingContent
+      } = _a, otherOptions = __objRest(_a, [
+        "theme",
+        "html",
+        "content",
+        "loadingContent"
+      ]);
+      return h(PrivateTooltipDirective, {
+        props: {
+          theme,
+          html,
+          content,
+          loadingContent
+        },
+        attrs: otherOptions,
+        ref: "popper"
+      });
+    },
+    devtools: {
+      hide: true
+    }
+  });
+  const mountTarget = document.createElement("div");
+  document.body.appendChild(mountTarget);
+  tooltipApp.$mount(mountTarget);
+  if (el.classList) {
+    el.classList.add(TARGET_CLASS);
+  }
+  return tooltipApp;
+}
+function destroyTooltip(el) {
+  if (el.$_popper) {
+    el.$_popper.$destroy();
+    delete el.$_popper;
+    delete el.$_popperOldShown;
+  }
+  if (el.classList) {
+    el.classList.remove(TARGET_CLASS);
+  }
+}
+function bind(el, { value, oldValue, modifiers }) {
+  const options2 = getOptions(el, value, modifiers);
+  if (!options2.content || getDefaultConfig(options2.theme || "tooltip", "disabled")) {
+    destroyTooltip(el);
+  } else {
+    let tooltipApp;
+    if (el.$_popper) {
+      tooltipApp = el.$_popper;
+      tooltipApp.options = options2;
+    } else {
+      tooltipApp = createTooltip(el, value, modifiers);
+    }
+    if (typeof value.shown !== "undefined" && value.shown !== el.$_popperOldShown) {
+      el.$_popperOldShown = value.shown;
+      value.shown ? tooltipApp.show() : tooltipApp.hide();
+    }
+  }
+}
+var PrivateVTooltip = {
+  bind,
+  update: bind,
+  unbind(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 = {
+  bind(el, { value, modifiers }) {
+    el.$_closePopoverModifiers = modifiers;
+    if (typeof value === "undefined" || value) {
+      addListeners(el);
+    }
+  },
+  update(el, { value, oldValue, modifiers }) {
+    el.$_closePopoverModifiers = modifiers;
+    if (value !== oldValue) {
+      if (typeof value === "undefined" || value) {
+        addListeners(el);
+      } else {
+        removeListeners(el);
+      }
+    }
+  },
+  unbind(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 && (PrivateDropdown));
+const Menu = (/* unused pure expression or super */ null && (PrivateMenu));
+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 && (PrivateTooltip));
+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("v-tooltip", PrivateTooltip);
+  app.component("VTooltip", PrivateTooltip);
+  app.component("v-dropdown", PrivateDropdown);
+  app.component("VDropdown", PrivateDropdown);
+  app.component("v-menu", PrivateMenu);
+  app.component("VMenu", PrivateMenu);
+}
+const floating_vue_es_plugin = {
+  version: "1.0.0-beta.17",
+  install,
+  options: config
+};
+let GlobalVue = null;
+if (typeof window !== "undefined") {
+  GlobalVue = window.Vue;
+} else if (typeof __webpack_require__.g !== "undefined") {
+  GlobalVue = __webpack_require__.g.Vue;
+}
+if (GlobalVue) {
+  GlobalVue.use(floating_vue_es_plugin);
+}
+
+
 ;// CONCATENATED MODULE: ./node_modules/@vue/vue-loader-v15/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./src/components/atoms/wt-avatar/wt-avatar.vue?vue&type=template&id=49b0d3b8&scoped=true&
-var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticClass:"wt-avatar",class:[("wt-avatar--size-" + _vm.size)]},[(_vm.badge)?_c('wt-badge',{attrs:{"color-variable":_vm.badgeColorVar}}):_vm._e(),_c('img',{staticClass:"wt-avatar__img",attrs:{"src":__webpack_require__(1578),"alt":"avatar"}})],1)}
-var staticRenderFns = []
+var wt_avatarvue_type_template_id_49b0d3b8_scoped_true_render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticClass:"wt-avatar",class:[("wt-avatar--size-" + _vm.size)]},[(_vm.badge)?_c('wt-badge',{attrs:{"color-variable":_vm.badgeColorVar}}):_vm._e(),_c('img',{staticClass:"wt-avatar__img",attrs:{"src":__webpack_require__(1578),"alt":"avatar"}})],1)}
+var wt_avatarvue_type_template_id_49b0d3b8_scoped_true_staticRenderFns = []
 
 
 ;// CONCATENATED MODULE: ./src/components/atoms/wt-avatar/wt-avatar.vue?vue&type=template&id=49b0d3b8&scoped=true&
@@ -12029,7 +15431,7 @@ var AbstractUserStatus = Object.freeze({
 // This module is a runtime utility for cleaner component module output and will
 // be included in the final webpack user bundle.
 
-function normalizeComponent (
+function componentNormalizer_normalizeComponent (
   scriptExports,
   render,
   staticRenderFns,
@@ -12131,10 +15533,10 @@ function normalizeComponent (
 
 /* normalize component */
 
-var component = normalizeComponent(
+var component = componentNormalizer_normalizeComponent(
   wt_avatar_wt_avatarvue_type_script_lang_js_,
-  render,
-  staticRenderFns,
+  wt_avatarvue_type_template_id_49b0d3b8_scoped_true_render,
+  wt_avatarvue_type_template_id_49b0d3b8_scoped_true_staticRenderFns,
   false,
   null,
   "49b0d3b8",
@@ -12187,7 +15589,7 @@ var wt_badgevue_type_template_id_94557de2_scoped_true_staticRenderFns = []
 
 /* normalize component */
 
-var wt_badge_component = normalizeComponent(
+var wt_badge_component = componentNormalizer_normalizeComponent(
   wt_badge_wt_badgevue_type_script_lang_js_,
   wt_badgevue_type_template_id_94557de2_scoped_true_render,
   wt_badgevue_type_template_id_94557de2_scoped_true_staticRenderFns,
@@ -12277,7 +15679,7 @@ var es_array_concat = __webpack_require__(2222);
 
 /* normalize component */
 
-var wt_icon_component = normalizeComponent(
+var wt_icon_component = componentNormalizer_normalizeComponent(
   wt_icon_wt_iconvue_type_script_lang_js_,
   wt_iconvue_type_template_id_7b466648_scoped_true_render,
   wt_iconvue_type_template_id_7b466648_scoped_true_staticRenderFns,
@@ -12359,7 +15761,7 @@ var es_number_constructor = __webpack_require__(9653);
 
 /* normalize component */
 
-var wt_indicator_component = normalizeComponent(
+var wt_indicator_component = componentNormalizer_normalizeComponent(
   wt_indicator_wt_indicatorvue_type_script_lang_js_,
   wt_indicatorvue_type_template_id_b50e50a2_scoped_true_render,
   wt_indicatorvue_type_template_id_b50e50a2_scoped_true_staticRenderFns,
@@ -12415,7 +15817,7 @@ var wt_input_infovue_type_template_id_7743f2f2_scoped_true_staticRenderFns = []
 
 /* normalize component */
 
-var wt_input_info_component = normalizeComponent(
+var wt_input_info_component = componentNormalizer_normalizeComponent(
   wt_input_info_wt_input_infovue_type_script_lang_js_,
   wt_input_infovue_type_template_id_7743f2f2_scoped_true_render,
   wt_input_infovue_type_template_id_7743f2f2_scoped_true_staticRenderFns,
@@ -12539,7 +15941,7 @@ var es_array_includes = __webpack_require__(6699);
 
 /* normalize component */
 
-var wt_button_component = normalizeComponent(
+var wt_button_component = componentNormalizer_normalizeComponent(
   wt_button_wt_buttonvue_type_script_lang_js_,
   wt_buttonvue_type_template_id_427095ff_scoped_true_render,
   wt_buttonvue_type_template_id_427095ff_scoped_true_staticRenderFns,
@@ -12590,7 +15992,7 @@ var wt_chipvue_type_template_id_7d722038_scoped_true_staticRenderFns = []
 
 /* normalize component */
 
-var wt_chip_component = normalizeComponent(
+var wt_chip_component = componentNormalizer_normalizeComponent(
   wt_chip_wt_chipvue_type_script_lang_js_,
   wt_chipvue_type_template_id_7d722038_scoped_true_render,
   wt_chipvue_type_template_id_7d722038_scoped_true_staticRenderFns,
@@ -12631,7 +16033,7 @@ var wt_dividervue_type_template_id_10fa1714_scoped_true_staticRenderFns = []
 
 /* normalize component */
 
-var wt_divider_component = normalizeComponent(
+var wt_divider_component = componentNormalizer_normalizeComponent(
   wt_divider_wt_dividervue_type_script_lang_js_,
   wt_dividervue_type_template_id_10fa1714_scoped_true_render,
   wt_dividervue_type_template_id_10fa1714_scoped_true_staticRenderFns,
@@ -12693,7 +16095,7 @@ var wt_tooltipvue_type_template_id_1bd9146d_scoped_true_staticRenderFns = []
 
 /* normalize component */
 
-var wt_tooltip_component = normalizeComponent(
+var wt_tooltip_component = componentNormalizer_normalizeComponent(
   wt_tooltip_wt_tooltipvue_type_script_lang_js_,
   wt_tooltipvue_type_template_id_1bd9146d_scoped_true_render,
   wt_tooltipvue_type_template_id_1bd9146d_scoped_true_staticRenderFns,
@@ -12787,7 +16189,7 @@ var wt_rounded_actionvue_type_template_id_6abe1700_scoped_true_staticRenderFns =
 
 /* normalize component */
 
-var wt_rounded_action_component = normalizeComponent(
+var wt_rounded_action_component = componentNormalizer_normalizeComponent(
   wt_rounded_action_wt_rounded_actionvue_type_script_lang_js_,
   wt_rounded_actionvue_type_template_id_6abe1700_scoped_true_render,
   wt_rounded_actionvue_type_template_id_6abe1700_scoped_true_staticRenderFns,
@@ -12845,7 +16247,7 @@ var wt_loader_smvue_type_template_id_030f3ed0_scoped_true_staticRenderFns = []
 
 /* normalize component */
 
-var wt_loader_sm_component = normalizeComponent(
+var wt_loader_sm_component = componentNormalizer_normalizeComponent(
   _internals_wt_loader_smvue_type_script_lang_js_,
   wt_loader_smvue_type_template_id_030f3ed0_scoped_true_render,
   wt_loader_smvue_type_template_id_030f3ed0_scoped_true_staticRenderFns,
@@ -12888,7 +16290,7 @@ var wt_loader_mdvue_type_template_id_4cf61586_scoped_true_staticRenderFns = []
 
 /* normalize component */
 
-var wt_loader_md_component = normalizeComponent(
+var wt_loader_md_component = componentNormalizer_normalizeComponent(
   _internals_wt_loader_mdvue_type_script_lang_js_,
   wt_loader_mdvue_type_template_id_4cf61586_scoped_true_render,
   wt_loader_mdvue_type_template_id_4cf61586_scoped_true_staticRenderFns,
@@ -12937,7 +16339,7 @@ var wt_loader_md_component = normalizeComponent(
 
 /* normalize component */
 ;
-var wt_loader_component = normalizeComponent(
+var wt_loader_component = componentNormalizer_normalizeComponent(
   wt_loader_wt_loadervue_type_script_lang_js_,
   wt_loadervue_type_template_id_9bbe5b8c_scoped_true_render,
   wt_loadervue_type_template_id_9bbe5b8c_scoped_true_staticRenderFns,
@@ -13007,7 +16409,7 @@ var wt_context_menuvue_type_template_id_23f9fa99_scoped_true_staticRenderFns = [
 
 /* normalize component */
 
-var wt_context_menu_component = normalizeComponent(
+var wt_context_menu_component = componentNormalizer_normalizeComponent(
   wt_context_menu_wt_context_menuvue_type_script_lang_js_,
   wt_context_menuvue_type_template_id_23f9fa99_scoped_true_render,
   wt_context_menuvue_type_template_id_23f9fa99_scoped_true_staticRenderFns,
@@ -13238,7 +16640,7 @@ var es_string_includes = __webpack_require__(2023);
 
 /* normalize component */
 
-var wt_checkbox_component = normalizeComponent(
+var wt_checkbox_component = componentNormalizer_normalizeComponent(
   wt_checkbox_wt_checkboxvue_type_script_lang_js_,
   wt_checkboxvue_type_template_id_3460d02e_scoped_true_render,
   wt_checkboxvue_type_template_id_3460d02e_scoped_true_staticRenderFns,
@@ -13654,7 +17056,7 @@ var makeDateUtils = function makeDateUtils(useUtc) {
 var utils$1 = _objectSpread({}, utils) // eslint-disable-next-line
 ;
 
-var script = {
+var vuejs_datepicker_esm_script = {
   props: {
     selectedDate: Date,
     resetTypedDate: [Date],
@@ -13857,10 +17259,10 @@ function vuejs_datepicker_esm_normalizeComponent(template, style, script, scopeI
 var normalizeComponent_1 = vuejs_datepicker_esm_normalizeComponent;
 
 /* script */
-const __vue_script__ = script;
+const vuejs_datepicker_esm_vue_script_ = vuejs_datepicker_esm_script;
 
 /* template */
-var __vue_render__ = function() {
+var vuejs_datepicker_esm_vue_render_ = function() {
   var _vm = this;
   var _h = _vm.$createElement;
   var _c = _vm._self._c || _h;
@@ -13952,17 +17354,17 @@ var __vue_render__ = function() {
     2
   )
 };
-var __vue_staticRenderFns__ = [];
-__vue_render__._withStripped = true;
+var vuejs_datepicker_esm_vue_staticRenderFns_ = [];
+vuejs_datepicker_esm_vue_render_._withStripped = true;
 
   /* style */
-  const __vue_inject_styles__ = undefined;
+  const vuejs_datepicker_esm_vue_inject_styles_ = undefined;
   /* scoped */
-  const __vue_scope_id__ = undefined;
+  const vuejs_datepicker_esm_vue_scope_id_ = undefined;
   /* module identifier */
-  const __vue_module_identifier__ = undefined;
+  const vuejs_datepicker_esm_vue_module_identifier_ = undefined;
   /* functional template */
-  const __vue_is_functional_template__ = false;
+  const vuejs_datepicker_esm_vue_is_functional_template_ = false;
   /* style inject */
   
   /* style inject SSR */
@@ -13970,12 +17372,12 @@ __vue_render__._withStripped = true;
 
   
   var DateInput = normalizeComponent_1(
-    { render: __vue_render__, staticRenderFns: __vue_staticRenderFns__ },
-    __vue_inject_styles__,
-    __vue_script__,
-    __vue_scope_id__,
-    __vue_is_functional_template__,
-    __vue_module_identifier__,
+    { render: vuejs_datepicker_esm_vue_render_, staticRenderFns: vuejs_datepicker_esm_vue_staticRenderFns_ },
+    vuejs_datepicker_esm_vue_inject_styles_,
+    vuejs_datepicker_esm_vue_script_,
+    vuejs_datepicker_esm_vue_scope_id_,
+    vuejs_datepicker_esm_vue_is_functional_template_,
+    vuejs_datepicker_esm_vue_module_identifier_,
     undefined,
     undefined
   );
@@ -15810,7 +19212,7 @@ __vue_render__$4._withStripped = true;
 
 /* normalize component */
 
-var wt_datepicker_component = normalizeComponent(
+var wt_datepicker_component = componentNormalizer_normalizeComponent(
   wt_datepicker_wt_datepickervue_type_script_lang_js_,
   wt_datepickervue_type_template_id_55e6d929_scoped_true_render,
   wt_datepickervue_type_template_id_55e6d929_scoped_true_staticRenderFns,
@@ -16010,7 +19412,7 @@ var wt_datetimepickervue_type_template_id_2e6c604c_scoped_true_staticRenderFns =
 
 /* normalize component */
 
-var wt_datetimepicker_component = normalizeComponent(
+var wt_datetimepicker_component = componentNormalizer_normalizeComponent(
   wt_datetimepicker_wt_datetimepickervue_type_script_lang_js_,
   wt_datetimepickervue_type_template_id_2e6c604c_scoped_true_render,
   wt_datetimepickervue_type_template_id_2e6c604c_scoped_true_staticRenderFns,
@@ -16099,7 +19501,7 @@ var wt_icon_btnvue_type_template_id_fa414596_scoped_true_staticRenderFns = []
 
 /* normalize component */
 
-var wt_icon_btn_component = normalizeComponent(
+var wt_icon_btn_component = componentNormalizer_normalizeComponent(
   wt_icon_btn_wt_icon_btnvue_type_script_lang_js_,
   wt_icon_btnvue_type_template_id_fa414596_scoped_true_render,
   wt_icon_btnvue_type_template_id_fa414596_scoped_true_staticRenderFns,
@@ -16545,7 +19947,7 @@ function _createForOfIteratorHelper(o, allowArrayLike) {
 
 /* normalize component */
 
-var wt_input_component = normalizeComponent(
+var wt_input_component = componentNormalizer_normalizeComponent(
   wt_input_wt_inputvue_type_script_lang_js_,
   wt_inputvue_type_template_id_1b3a94f8_scoped_true_render,
   wt_inputvue_type_template_id_1b3a94f8_scoped_true_staticRenderFns,
@@ -16631,7 +20033,7 @@ var wt_notificationvue_type_template_id_7981c292_scoped_true_staticRenderFns = [
 
 /* normalize component */
 
-var wt_notification_component = normalizeComponent(
+var wt_notification_component = componentNormalizer_normalizeComponent(
   wt_notification_wt_notificationvue_type_script_lang_js_,
   wt_notificationvue_type_template_id_7981c292_scoped_true_render,
   wt_notificationvue_type_template_id_7981c292_scoped_true_staticRenderFns,
@@ -16715,7 +20117,7 @@ var wt_popupvue_type_template_id_31f45e68_scoped_true_staticRenderFns = []
 
 /* normalize component */
 
-var wt_popup_component = normalizeComponent(
+var wt_popup_component = componentNormalizer_normalizeComponent(
   wt_popup_wt_popupvue_type_script_lang_js_,
   wt_popupvue_type_template_id_31f45e68_scoped_true_render,
   wt_popupvue_type_template_id_31f45e68_scoped_true_staticRenderFns,
@@ -16793,7 +20195,7 @@ var wt_progress_barvue_type_template_id_0645a925_scoped_true_staticRenderFns = [
 
 /* normalize component */
 
-var wt_progress_bar_component = normalizeComponent(
+var wt_progress_bar_component = componentNormalizer_normalizeComponent(
   wt_progress_bar_wt_progress_barvue_type_script_lang_js_,
   wt_progress_barvue_type_template_id_0645a925_scoped_true_render,
   wt_progress_barvue_type_template_id_0645a925_scoped_true_staticRenderFns,
@@ -16907,7 +20309,7 @@ var wt_radiovue_type_template_id_3fafcdf2_scoped_true_staticRenderFns = []
 
 /* normalize component */
 
-var wt_radio_component = normalizeComponent(
+var wt_radio_component = componentNormalizer_normalizeComponent(
   wt_radio_wt_radiovue_type_script_lang_js_,
   wt_radiovue_type_template_id_3fafcdf2_scoped_true_render,
   wt_radiovue_type_template_id_3fafcdf2_scoped_true_staticRenderFns,
@@ -17062,7 +20464,7 @@ var debounce = function debounce(method) {
 
 /* normalize component */
 
-var wt_search_bar_component = normalizeComponent(
+var wt_search_bar_component = componentNormalizer_normalizeComponent(
   wt_search_bar_wt_search_barvue_type_script_lang_js_,
   wt_search_barvue_type_template_id_d775d3ca_scoped_true_render,
   wt_search_barvue_type_template_id_d775d3ca_scoped_true_staticRenderFns,
@@ -17534,7 +20936,7 @@ function _asyncToGenerator(fn) {
 var vue_multiselect_min = __webpack_require__(7907);
 var vue_multiselect_min_default = /*#__PURE__*/__webpack_require__.n(vue_multiselect_min);
 ;// CONCATENATED MODULE: ./node_modules/vue-observe-visibility/dist/vue-observe-visibility.esm.js
-/* provided dependency */ var console = __webpack_require__(5108);
+/* provided dependency */ var vue_observe_visibility_esm_console = __webpack_require__(5108);
 function vue_observe_visibility_esm_typeof(obj) {
   if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
     vue_observe_visibility_esm_typeof = function (obj) {
@@ -17761,12 +21163,12 @@ function () {
   return VisibilityState;
 }();
 
-function bind(el, _ref2, vnode) {
+function vue_observe_visibility_esm_bind(el, _ref2, vnode) {
   var value = _ref2.value;
   if (!value) return;
 
   if (typeof IntersectionObserver === 'undefined') {
-    console.warn('[vue-observe-visibility] IntersectionObserver API is not available in your browser. Please install this polyfill: https://github.com/w3c/IntersectionObserver/tree/master/polyfill');
+    vue_observe_visibility_esm_console.warn('[vue-observe-visibility] IntersectionObserver API is not available in your browser. Please install this polyfill: https://github.com/w3c/IntersectionObserver/tree/master/polyfill');
   } else {
     var state = new VisibilityState(el, value, vnode);
     el._vue_visibilityState = state;
@@ -17787,7 +21189,7 @@ function update(el, _ref3, vnode) {
   if (state) {
     state.createObserver(value, vnode);
   } else {
-    bind(el, {
+    vue_observe_visibility_esm_bind(el, {
       value: value
     }, vnode);
   }
@@ -17803,12 +21205,12 @@ function unbind(el) {
 }
 
 var ObserveVisibility = {
-  bind: bind,
+  bind: vue_observe_visibility_esm_bind,
   update: update,
   unbind: unbind
 };
 
-function install(Vue) {
+function vue_observe_visibility_esm_install(Vue) {
   Vue.directive('observe-visibility', ObserveVisibility);
   /* -- Add more components here -- */
 }
@@ -17820,19 +21222,19 @@ function install(Vue) {
 var vue_observe_visibility_esm_plugin = {
   // eslint-disable-next-line no-undef
   version: "1.0.0",
-  install: install
+  install: vue_observe_visibility_esm_install
 };
 
-var GlobalVue = null;
+var vue_observe_visibility_esm_GlobalVue = null;
 
 if (typeof window !== 'undefined') {
-  GlobalVue = window.Vue;
+  vue_observe_visibility_esm_GlobalVue = window.Vue;
 } else if (typeof __webpack_require__.g !== 'undefined') {
-  GlobalVue = __webpack_require__.g.Vue;
+  vue_observe_visibility_esm_GlobalVue = __webpack_require__.g.Vue;
 }
 
-if (GlobalVue) {
-  GlobalVue.use(vue_observe_visibility_esm_plugin);
+if (vue_observe_visibility_esm_GlobalVue) {
+  vue_observe_visibility_esm_GlobalVue.use(vue_observe_visibility_esm_plugin);
 }
 
 /* harmony default export */ var vue_observe_visibility_esm = ((/* unused pure expression or super */ null && (vue_observe_visibility_esm_plugin)));
@@ -18165,7 +21567,7 @@ var isEmpty = function isEmpty(value) {
 
 /* normalize component */
 
-var wt_select_component = normalizeComponent(
+var wt_select_component = componentNormalizer_normalizeComponent(
   wt_select_wt_selectvue_type_script_lang_js_,
   wt_selectvue_type_template_id_5e1ce59d_scoped_true_render,
   wt_selectvue_type_template_id_5e1ce59d_scoped_true_staticRenderFns,
@@ -18298,7 +21700,7 @@ var wt_slidervue_type_template_id_1503f9dc_scoped_true_staticRenderFns = []
 
 /* normalize component */
 
-var wt_slider_component = normalizeComponent(
+var wt_slider_component = componentNormalizer_normalizeComponent(
   wt_slider_wt_slidervue_type_script_lang_js_,
   wt_slidervue_type_template_id_1503f9dc_scoped_true_render,
   wt_slidervue_type_template_id_1503f9dc_scoped_true_staticRenderFns,
@@ -18400,7 +21802,7 @@ var wt_switchervue_type_template_id_61d9ee31_scoped_true_staticRenderFns = []
 
 /* normalize component */
 
-var wt_switcher_component = normalizeComponent(
+var wt_switcher_component = componentNormalizer_normalizeComponent(
   wt_switcher_wt_switchervue_type_script_lang_js_,
   wt_switchervue_type_template_id_61d9ee31_scoped_true_render,
   wt_switchervue_type_template_id_61d9ee31_scoped_true_staticRenderFns,
@@ -18509,7 +21911,7 @@ var wt_tabsvue_type_template_id_5dcc6dcb_scoped_true_staticRenderFns = []
 
 /* normalize component */
 
-var wt_tabs_component = normalizeComponent(
+var wt_tabs_component = componentNormalizer_normalizeComponent(
   wt_tabs_wt_tabsvue_type_script_lang_js_,
   wt_tabsvue_type_template_id_5dcc6dcb_scoped_true_render,
   wt_tabsvue_type_template_id_5dcc6dcb_scoped_true_staticRenderFns,
@@ -18706,7 +22108,7 @@ var vue_tags_input_default = /*#__PURE__*/__webpack_require__.n(vue_tags_input);
 
 /* normalize component */
 
-var wt_tags_input_component = normalizeComponent(
+var wt_tags_input_component = componentNormalizer_normalizeComponent(
   wt_tags_input_wt_tags_inputvue_type_script_lang_js_,
   wt_tags_inputvue_type_template_id_d5ed3a8a_scoped_true_render,
   wt_tags_inputvue_type_template_id_d5ed3a8a_scoped_true_staticRenderFns,
@@ -18870,7 +22272,7 @@ var wt_time_inputvue_type_template_id_3a47b4a2_scoped_true_staticRenderFns = []
 
 /* normalize component */
 
-var wt_time_input_component = normalizeComponent(
+var wt_time_input_component = componentNormalizer_normalizeComponent(
   wt_time_input_wt_time_inputvue_type_script_lang_js_,
   wt_time_inputvue_type_template_id_3a47b4a2_scoped_true_render,
   wt_time_inputvue_type_template_id_3a47b4a2_scoped_true_staticRenderFns,
@@ -19034,7 +22436,7 @@ var wt_textareavue_type_template_id_1069007b_scoped_true_staticRenderFns = []
 
 /* normalize component */
 
-var wt_textarea_component = normalizeComponent(
+var wt_textarea_component = componentNormalizer_normalizeComponent(
   wt_textarea_wt_textareavue_type_script_lang_js_,
   wt_textareavue_type_template_id_1069007b_scoped_true_render,
   wt_textareavue_type_template_id_1069007b_scoped_true_staticRenderFns,
@@ -19193,7 +22595,7 @@ var SEC_IN_MIN = 60;
 
 /* normalize component */
 
-var wt_timepicker_component = normalizeComponent(
+var wt_timepicker_component = componentNormalizer_normalizeComponent(
   wt_timepicker_wt_timepickervue_type_script_lang_js_,
   wt_timepickervue_type_template_id_7d43a4a8_scoped_true_render,
   wt_timepickervue_type_template_id_7d43a4a8_scoped_true_staticRenderFns,
@@ -19281,7 +22683,7 @@ var wt_labelvue_type_template_id_43536ef5_scoped_true_staticRenderFns = []
 
 /* normalize component */
 
-var wt_label_component = normalizeComponent(
+var wt_label_component = componentNormalizer_normalizeComponent(
   wt_label_wt_labelvue_type_script_lang_js_,
   wt_labelvue_type_template_id_43536ef5_scoped_true_render,
   wt_labelvue_type_template_id_43536ef5_scoped_true_staticRenderFns,
@@ -19382,7 +22784,7 @@ var wt_button_selectvue_type_template_id_4d6cee4a_scoped_true_staticRenderFns =
 
 /* normalize component */
 
-var wt_button_select_component = normalizeComponent(
+var wt_button_select_component = componentNormalizer_normalizeComponent(
   wt_button_select_wt_button_selectvue_type_script_lang_js_,
   wt_button_selectvue_type_template_id_4d6cee4a_scoped_true_render,
   wt_button_selectvue_type_template_id_4d6cee4a_scoped_true_staticRenderFns,
@@ -19425,7 +22827,7 @@ var wt_app_headervue_type_template_id_747a7a52_scoped_true_staticRenderFns = []
 
 /* normalize component */
 
-var wt_app_header_component = normalizeComponent(
+var wt_app_header_component = componentNormalizer_normalizeComponent(
   wt_app_header_wt_app_headervue_type_script_lang_js_,
   wt_app_headervue_type_template_id_747a7a52_scoped_true_render,
   wt_app_headervue_type_template_id_747a7a52_scoped_true_staticRenderFns,
@@ -19652,7 +23054,7 @@ var WebitelApplications = Object.freeze({
 
 /* normalize component */
 
-var wt_app_navigator_component = normalizeComponent(
+var wt_app_navigator_component = componentNormalizer_normalizeComponent(
   wt_app_header_wt_app_navigatorvue_type_script_lang_js_,
   wt_app_navigatorvue_type_template_id_ee5ad508_scoped_true_render,
   wt_app_navigatorvue_type_template_id_ee5ad508_scoped_true_staticRenderFns,
@@ -19730,7 +23132,7 @@ var wt_filters_panel_wrappervue_type_template_id_74cbecee_scoped_true_staticRend
 
 /* normalize component */
 
-var wt_filters_panel_wrapper_component = normalizeComponent(
+var wt_filters_panel_wrapper_component = componentNormalizer_normalizeComponent(
   wt_filters_panel_wrapper_wt_filters_panel_wrappervue_type_script_lang_js_,
   wt_filters_panel_wrappervue_type_template_id_74cbecee_scoped_true_render,
   wt_filters_panel_wrappervue_type_template_id_74cbecee_scoped_true_staticRenderFns,
@@ -19876,7 +23278,7 @@ var wt_header_actionsvue_type_template_id_6c4b4559_scoped_true_staticRenderFns =
 
 /* normalize component */
 
-var wt_header_actions_component = normalizeComponent(
+var wt_header_actions_component = componentNormalizer_normalizeComponent(
   wt_app_header_wt_header_actionsvue_type_script_lang_js_,
   wt_header_actionsvue_type_template_id_6c4b4559_scoped_true_render,
   wt_header_actionsvue_type_template_id_6c4b4559_scoped_true_staticRenderFns,
@@ -19990,7 +23392,7 @@ var _404_namespaceObject = "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iODYzIiBoZW
 
 /* normalize component */
 
-var wt_error_page_component = normalizeComponent(
+var wt_error_page_component = componentNormalizer_normalizeComponent(
   wt_error_page_wt_error_pagevue_type_script_lang_js_,
   wt_error_pagevue_type_template_id_12b4fe57_scoped_true_render,
   wt_error_pagevue_type_template_id_12b4fe57_scoped_true_staticRenderFns,
@@ -20043,7 +23445,7 @@ var wt_headlinevue_type_template_id_b90f7186_scoped_true_staticRenderFns = []
 
 /* normalize component */
 
-var wt_headline_component = normalizeComponent(
+var wt_headline_component = componentNormalizer_normalizeComponent(
   wt_headline_wt_headlinevue_type_script_lang_js_,
   wt_headlinevue_type_template_id_b90f7186_scoped_true_render,
   wt_headlinevue_type_template_id_b90f7186_scoped_true_staticRenderFns,
@@ -20140,7 +23542,7 @@ var expand_transition_render, expand_transition_staticRenderFns
 
 /* normalize component */
 
-var expand_transition_component = normalizeComponent(
+var expand_transition_component = componentNormalizer_normalizeComponent(
   transitions_expand_transitionvue_type_script_lang_js_,
   expand_transition_render,
   expand_transition_staticRenderFns,
@@ -20345,7 +23747,7 @@ var expand_transition_component = normalizeComponent(
 
 /* normalize component */
 
-var wt_navigation_bar_component = normalizeComponent(
+var wt_navigation_bar_component = componentNormalizer_normalizeComponent(
   wt_navigation_bar_wt_navigation_barvue_type_script_lang_js_,
   wt_navigation_barvue_type_template_id_5e445474_scoped_true_render,
   wt_navigation_barvue_type_template_id_5e445474_scoped_true_staticRenderFns,
@@ -20430,7 +23832,7 @@ var es_array_splice = __webpack_require__(561);
 
 /* normalize component */
 
-var wt_notifications_bar_component = normalizeComponent(
+var wt_notifications_bar_component = componentNormalizer_normalizeComponent(
   wt_notifications_bar_wt_notifications_barvue_type_script_lang_js_,
   wt_notifications_barvue_type_template_id_581c3820_scoped_true_render,
   wt_notifications_barvue_type_template_id_581c3820_scoped_true_staticRenderFns,
@@ -20487,7 +23889,7 @@ var wt_page_wrappervue_type_template_id_1592578a_scoped_true_staticRenderFns = [
 
 /* normalize component */
 
-var wt_page_wrapper_component = normalizeComponent(
+var wt_page_wrapper_component = componentNormalizer_normalizeComponent(
   wt_page_wrapper_wt_page_wrappervue_type_script_lang_js_,
   wt_page_wrappervue_type_template_id_1592578a_scoped_true_render,
   wt_page_wrappervue_type_template_id_1592578a_scoped_true_staticRenderFns,
@@ -20614,7 +24016,7 @@ var wt_paginationvue_type_template_id_1b5e4262_scoped_true_staticRenderFns = []
 
 /* normalize component */
 
-var wt_pagination_component = normalizeComponent(
+var wt_pagination_component = componentNormalizer_normalizeComponent(
   wt_pagination_wt_paginationvue_type_script_lang_js_,
   wt_paginationvue_type_template_id_1b5e4262_scoped_true_render,
   wt_paginationvue_type_template_id_1b5e4262_scoped_true_staticRenderFns,
@@ -20815,7 +24217,7 @@ var plyr_min_default = /*#__PURE__*/__webpack_require__.n(plyr_min);
 
 /* normalize component */
 
-var wt_player_component = normalizeComponent(
+var wt_player_component = componentNormalizer_normalizeComponent(
   wt_player_wt_playervue_type_script_lang_js_,
   wt_playervue_type_template_id_50031408_render,
   wt_playervue_type_template_id_50031408_staticRenderFns,
@@ -21004,7 +24406,7 @@ var convertDuration = function convertDuration(duration) {
 
 /* normalize component */
 
-var wt_status_select_component = normalizeComponent(
+var wt_status_select_component = componentNormalizer_normalizeComponent(
   wt_status_select_wt_status_selectvue_type_script_lang_js_,
   wt_status_selectvue_type_template_id_9d8ec644_scoped_true_render,
   wt_status_selectvue_type_template_id_9d8ec644_scoped_true_staticRenderFns,
@@ -21228,7 +24630,7 @@ var getNextSortOrder = function getNextSortOrder(sort) {
 
 /* normalize component */
 
-var wt_table_component = normalizeComponent(
+var wt_table_component = componentNormalizer_normalizeComponent(
   wt_table_wt_tablevue_type_script_lang_js_,
   wt_tablevue_type_template_id_21c730bb_scoped_true_render,
   wt_tablevue_type_template_id_21c730bb_scoped_true_staticRenderFns,
@@ -21340,7 +24742,7 @@ var wt_table_actionsvue_type_template_id_715b4258_scoped_true_staticRenderFns =
 
 /* normalize component */
 
-var wt_table_actions_component = normalizeComponent(
+var wt_table_actions_component = componentNormalizer_normalizeComponent(
   wt_table_actions_wt_table_actionsvue_type_script_lang_js_,
   wt_table_actionsvue_type_template_id_715b4258_scoped_true_render,
   wt_table_actionsvue_type_template_id_715b4258_scoped_true_staticRenderFns,
@@ -21483,7 +24885,7 @@ var deep_copy_default = /*#__PURE__*/__webpack_require__.n(deep_copy);
 
 /* normalize component */
 
-var wt_table_column_select_component = normalizeComponent(
+var wt_table_column_select_component = componentNormalizer_normalizeComponent(
   wt_table_column_select_wt_table_column_selectvue_type_script_lang_js_,
   wt_table_column_selectvue_type_template_id_35dddfd2_scoped_true_render,
   wt_table_column_selectvue_type_template_id_35dddfd2_scoped_true_staticRenderFns,
@@ -21717,6 +25119,7 @@ Object.keys(Filters).forEach(function (name) {
 
 /* eslint-disable */
 
+
  // init all components
 
  // init all directives
@@ -21746,6 +25149,7 @@ Object.keys(Filters).forEach(function (name) {
     });
     (external_commonjs_vue_commonjs2_vue_root_Vue_default()).prototype.$eventBus = eventBus;
     if (router) external_commonjs_vue_commonjs2_vue_root_Vue_default().use(router);
+    external_commonjs_vue_commonjs2_vue_root_Vue_default().use(floating_vue_es_plugin);
   }
 });
 ;// CONCATENATED MODULE: ./node_modules/@vue/cli-service/lib/commands/build/entry-lib.js