@xuda.io/xuda-widget-plugin-xuda-drive 1.0.64 → 1.0.65

package/floating-vue@5.2.2/floating-vue.umd.js

@@ -0,0 +1,1751 @@
+(function (l, s) {
+  typeof exports == "object" && typeof module < "u"
+    ? s(exports, require("vue"), require("@floating-ui/dom"))
+    : typeof define == "function" && define.amd
+    ? define(["exports", "vue", "@floating-ui/dom"], s)
+    : ((l = typeof globalThis < "u" ? globalThis : l || self),
+      s((l.FloatingVue = {}), l.Vue, l.FloatingUIDOM));
+})(this, function (l, s, m) {
+  "use strict";
+  function ee(e, t) {
+    for (const o in t)
+      Object.prototype.hasOwnProperty.call(t, o) &&
+        (typeof t[o] == "object" && e[o] ? ee(e[o], t[o]) : (e[o] = t[o]));
+  }
+  const u = {
+    disabled: !1,
+    distance: 5,
+    skidding: 0,
+    container: "body",
+    boundary: void 0,
+    instantMove: !1,
+    disposeTimeout: 150,
+    popperTriggers: [],
+    strategy: "absolute",
+    preventOverflow: !0,
+    flip: !0,
+    shift: !0,
+    overflowPadding: 0,
+    arrowPadding: 0,
+    arrowOverflow: !0,
+    autoHideOnMousedown: !1,
+    themes: {
+      tooltip: {
+        placement: "top",
+        triggers: ["hover", "focus", "touch"],
+        hideTriggers: (e) => [...e, "click"],
+        delay: { show: 200, hide: 0 },
+        handleResize: !1,
+        html: !1,
+        loadingContent: "...",
+      },
+      dropdown: {
+        placement: "bottom",
+        triggers: ["click"],
+        delay: 0,
+        handleResize: !0,
+        autoHide: !0,
+      },
+      menu: {
+        $extend: "dropdown",
+        triggers: ["hover", "focus"],
+        popperTriggers: ["hover"],
+        delay: { show: 0, hide: 400 },
+      },
+    },
+  };
+  function _(e, t) {
+    let o = u.themes[e] || {},
+      i;
+    do
+      (i = o[t]),
+        typeof i > "u"
+          ? o.$extend
+            ? (o = u.themes[o.$extend] || {})
+            : ((o = null), (i = u[t]))
+          : (o = null);
+    while (o);
+    return i;
+  }
+  function Ce(e) {
+    const t = [e];
+    let o = u.themes[e] || {};
+    do
+      o.$extend && !o.$resetCss
+        ? (t.push(o.$extend), (o = u.themes[o.$extend] || {}))
+        : (o = null);
+    while (o);
+    return t.map((i) => `v-popper--theme-${i}`);
+  }
+  function te(e) {
+    const t = [e];
+    let o = u.themes[e] || {};
+    do
+      o.$extend
+        ? (t.push(o.$extend), (o = u.themes[o.$extend] || {}))
+        : (o = null);
+    while (o);
+    return t;
+  }
+  const ht = "",
+    ut = "";
+  let y = !1;
+  if (typeof window < "u") {
+    y = !1;
+    try {
+      const e = Object.defineProperty({}, "passive", {
+        get() {
+          y = !0;
+        },
+      });
+      window.addEventListener("test", null, e);
+    } catch {}
+  }
+  let oe = !1;
+  typeof window < "u" &&
+    typeof navigator < "u" &&
+    (oe = /iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream);
+  const E = ["auto", "top", "bottom", "left", "right"].reduce(
+      (e, t) => e.concat([t, `${t}-start`, `${t}-end`]),
+      []
+    ),
+    M = {
+      hover: "mouseenter",
+      focus: "focus",
+      click: "click",
+      touch: "touchstart",
+      pointer: "pointerdown",
+    },
+    O = {
+      hover: "mouseleave",
+      focus: "blur",
+      click: "click",
+      touch: "touchend",
+      pointer: "pointerup",
+    };
+  function ie(e, t) {
+    const o = e.indexOf(t);
+    o !== -1 && e.splice(o, 1);
+  }
+  function H() {
+    return new Promise((e) =>
+      requestAnimationFrame(() => {
+        requestAnimationFrame(e);
+      })
+    );
+  }
+  const h = [];
+  let $ = null;
+  const se = {};
+  function ne(e) {
+    let t = se[e];
+    return t || (t = se[e] = []), t;
+  }
+  let k = function () {};
+  typeof window < "u" && (k = window.Element);
+  function r(e) {
+    return function (t) {
+      return _(t.theme, e);
+    };
+  }
+  const L = "__floating-vue__popper",
+    D = () =>
+      s.defineComponent({
+        name: "VPopper",
+        provide() {
+          return { [L]: { parentPopper: this } };
+        },
+        inject: { [L]: { default: null } },
+        props: {
+          theme: { type: String, required: !0 },
+          targetNodes: { type: Function, required: !0 },
+          referenceNode: { type: Function, default: null },
+          popperNode: { type: Function, required: !0 },
+          shown: { type: Boolean, default: !1 },
+          showGroup: { type: String, default: null },
+          ariaId: { default: null },
+          disabled: { type: Boolean, default: r("disabled") },
+          positioningDisabled: {
+            type: Boolean,
+            default: r("positioningDisabled"),
+          },
+          placement: {
+            type: String,
+            default: r("placement"),
+            validator: (e) => E.includes(e),
+          },
+          delay: { type: [String, Number, Object], default: r("delay") },
+          distance: { type: [Number, String], default: r("distance") },
+          skidding: { type: [Number, String], default: r("skidding") },
+          triggers: { type: Array, default: r("triggers") },
+          showTriggers: { type: [Array, Function], default: r("showTriggers") },
+          hideTriggers: { type: [Array, Function], default: r("hideTriggers") },
+          popperTriggers: { type: Array, default: r("popperTriggers") },
+          popperShowTriggers: {
+            type: [Array, Function],
+            default: r("popperShowTriggers"),
+          },
+          popperHideTriggers: {
+            type: [Array, Function],
+            default: r("popperHideTriggers"),
+          },
+          container: {
+            type: [String, Object, k, Boolean],
+            default: r("container"),
+          },
+          boundary: { type: [String, k], default: r("boundary") },
+          strategy: {
+            type: String,
+            validator: (e) => ["absolute", "fixed"].includes(e),
+            default: r("strategy"),
+          },
+          autoHide: { type: [Boolean, Function], default: r("autoHide") },
+          handleResize: { type: Boolean, default: r("handleResize") },
+          instantMove: { type: Boolean, default: r("instantMove") },
+          eagerMount: { type: Boolean, default: r("eagerMount") },
+          popperClass: {
+            type: [String, Array, Object],
+            default: r("popperClass"),
+          },
+          computeTransformOrigin: {
+            type: Boolean,
+            default: r("computeTransformOrigin"),
+          },
+          autoMinSize: { type: Boolean, default: r("autoMinSize") },
+          autoSize: { type: [Boolean, String], default: r("autoSize") },
+          autoMaxSize: { type: Boolean, default: r("autoMaxSize") },
+          autoBoundaryMaxSize: {
+            type: Boolean,
+            default: r("autoBoundaryMaxSize"),
+          },
+          preventOverflow: { type: Boolean, default: r("preventOverflow") },
+          overflowPadding: {
+            type: [Number, String],
+            default: r("overflowPadding"),
+          },
+          arrowPadding: { type: [Number, String], default: r("arrowPadding") },
+          arrowOverflow: { type: Boolean, default: r("arrowOverflow") },
+          flip: { type: Boolean, default: r("flip") },
+          shift: { type: Boolean, default: r("shift") },
+          shiftCrossAxis: { type: Boolean, default: r("shiftCrossAxis") },
+          noAutoFocus: { type: Boolean, default: r("noAutoFocus") },
+          disposeTimeout: { type: Number, default: r("disposeTimeout") },
+        },
+        emits: {
+          show: () => !0,
+          hide: () => !0,
+          "update:shown": (e) => !0,
+          "apply-show": () => !0,
+          "apply-hide": () => !0,
+          "close-group": () => !0,
+          "close-directive": () => !0,
+          "auto-hide": () => !0,
+          resize: () => !0,
+        },
+        data() {
+          return {
+            isShown: !1,
+            isMounted: !1,
+            skipTransition: !1,
+            classes: { showFrom: !1, showTo: !1, hideFrom: !1, hideTo: !0 },
+            result: {
+              x: 0,
+              y: 0,
+              placement: "",
+              strategy: this.strategy,
+              arrow: { x: 0, y: 0, centerOffset: 0 },
+              transformOrigin: null,
+            },
+            randomId: `popper_${[Math.random(), Date.now()]
+              .map((e) => e.toString(36).substring(2, 10))
+              .join("_")}`,
+            shownChildren: new Set(),
+            lastAutoHide: !0,
+            pendingHide: !1,
+            containsGlobalTarget: !1,
+            isDisposed: !0,
+            mouseDownContains: !1,
+          };
+        },
+        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: { ...this.classes, popperClass: this.popperClass },
+              result: this.positioningDisabled ? null : this.result,
+              attrs: this.$attrs,
+            };
+          },
+          parentPopper() {
+            var e;
+            return (e = this[L]) == null ? void 0 : e.parentPopper;
+          },
+          hasPopperShowTriggerHover() {
+            var e, t;
+            return (
+              ((e = this.popperTriggers) == null
+                ? void 0
+                : e.includes("hover")) ||
+              ((t = this.popperShowTriggers) == null
+                ? void 0
+                : t.includes("hover"))
+            );
+          },
+        },
+        watch: {
+          shown: "$_autoShowHide",
+          disabled(e) {
+            e ? this.dispose() : this.init();
+          },
+          async container() {
+            this.isShown &&
+              (this.$_ensureTeleport(), await this.$_computePosition());
+          },
+          triggers: { handler: "$_refreshListeners", deep: !0 },
+          positioningDisabled: "$_refreshListeners",
+          ...[
+            "placement",
+            "distance",
+            "skidding",
+            "boundary",
+            "strategy",
+            "overflowPadding",
+            "arrowPadding",
+            "preventOverflow",
+            "shift",
+            "shiftCrossAxis",
+            "flip",
+          ].reduce((e, t) => ((e[t] = "$_computePosition"), e), {}),
+        },
+        created() {
+          this.autoMinSize &&
+            console.warn(
+              '[floating-vue] `autoMinSize` option is deprecated. Use `autoSize="min"` instead.'
+            ),
+            this.autoMaxSize &&
+              console.warn(
+                "[floating-vue] `autoMaxSize` option is deprecated. Use `autoBoundaryMaxSize` instead."
+              );
+        },
+        mounted() {
+          this.init(), this.$_detachPopperNode();
+        },
+        activated() {
+          this.$_autoShowHide();
+        },
+        deactivated() {
+          this.hide();
+        },
+        beforeUnmount() {
+          this.dispose();
+        },
+        methods: {
+          show({ event: e = null, skipDelay: t = !1, force: o = !1 } = {}) {
+            var i, n;
+            ((i = this.parentPopper) != null &&
+              i.lockedChild &&
+              this.parentPopper.lockedChild !== this) ||
+              ((this.pendingHide = !1),
+              (o || !this.disabled) &&
+                (((n = this.parentPopper) == null ? void 0 : n.lockedChild) ===
+                  this && (this.parentPopper.lockedChild = null),
+                this.$_scheduleShow(e, t),
+                this.$emit("show"),
+                (this.$_showFrameLocked = !0),
+                requestAnimationFrame(() => {
+                  this.$_showFrameLocked = !1;
+                })),
+              this.$emit("update:shown", !0));
+          },
+          hide({ event: e = null, skipDelay: t = !1 } = {}) {
+            var o;
+            if (!this.$_hideInProgress) {
+              if (this.shownChildren.size > 0) {
+                this.pendingHide = !0;
+                return;
+              }
+              if (this.hasPopperShowTriggerHover && this.$_isAimingPopper()) {
+                this.parentPopper &&
+                  ((this.parentPopper.lockedChild = this),
+                  clearTimeout(this.parentPopper.lockedChildTimer),
+                  (this.parentPopper.lockedChildTimer = setTimeout(() => {
+                    this.parentPopper.lockedChild === this &&
+                      (this.parentPopper.lockedChild.hide({ skipDelay: t }),
+                      (this.parentPopper.lockedChild = null));
+                  }, 1e3)));
+                return;
+              }
+              ((o = this.parentPopper) == null ? void 0 : o.lockedChild) ===
+                this && (this.parentPopper.lockedChild = null),
+                (this.pendingHide = !1),
+                this.$_scheduleHide(e, t),
+                this.$emit("hide"),
+                this.$emit("update:shown", !1);
+            }
+          },
+          init() {
+            var e;
+            this.isDisposed &&
+              ((this.isDisposed = !1),
+              (this.isMounted = !1),
+              (this.$_events = []),
+              (this.$_preventShow = !1),
+              (this.$_referenceNode =
+                ((e = this.referenceNode) == null ? void 0 : e.call(this)) ??
+                this.$el),
+              (this.$_targetNodes = this.targetNodes().filter(
+                (t) => t.nodeType === t.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(),
+              this.triggers.length && this.$_addEventListeners(),
+              this.shown && this.show());
+          },
+          dispose() {
+            this.isDisposed ||
+              ((this.isDisposed = !0),
+              this.$_removeEventListeners(),
+              this.hide({ skipDelay: !0 }),
+              this.$_detachPopperNode(),
+              (this.isMounted = !1),
+              (this.isShown = !1),
+              this.$_updateParentShownChildren(!1),
+              this.$_swapTargetAttrs("data-original-title", "title"));
+          },
+          async onResize() {
+            this.isShown &&
+              (await this.$_computePosition(), this.$emit("resize"));
+          },
+          async $_computePosition() {
+            if (this.isDisposed || this.positioningDisabled) return;
+            const e = { strategy: this.strategy, middleware: [] };
+            (this.distance || this.skidding) &&
+              e.middleware.push(
+                m.offset({ mainAxis: this.distance, crossAxis: this.skidding })
+              );
+            const t = this.placement.startsWith("auto");
+            if (
+              (t
+                ? e.middleware.push(
+                    m.autoPlacement({
+                      alignment: this.placement.split("-")[1] ?? "",
+                    })
+                  )
+                : (e.placement = this.placement),
+              this.preventOverflow &&
+                (this.shift &&
+                  e.middleware.push(
+                    m.shift({
+                      padding: this.overflowPadding,
+                      boundary: this.boundary,
+                      crossAxis: this.shiftCrossAxis,
+                    })
+                  ),
+                !t &&
+                  this.flip &&
+                  e.middleware.push(
+                    m.flip({
+                      padding: this.overflowPadding,
+                      boundary: this.boundary,
+                    })
+                  )),
+              e.middleware.push(
+                m.arrow({
+                  element: this.$_arrowNode,
+                  padding: this.arrowPadding,
+                })
+              ),
+              this.arrowOverflow &&
+                e.middleware.push({
+                  name: "arrowOverflow",
+                  fn: ({ placement: i, rects: n, middlewareData: p }) => {
+                    let a;
+                    const { centerOffset: d } = p.arrow;
+                    return (
+                      i.startsWith("top") || i.startsWith("bottom")
+                        ? (a = Math.abs(d) > n.reference.width / 2)
+                        : (a = Math.abs(d) > n.reference.height / 2),
+                      { data: { overflow: a } }
+                    );
+                  },
+                }),
+              this.autoMinSize || this.autoSize)
+            ) {
+              const i = this.autoSize
+                ? this.autoSize
+                : this.autoMinSize
+                ? "min"
+                : null;
+              e.middleware.push({
+                name: "autoSize",
+                fn: ({ rects: n, placement: p, middlewareData: a }) => {
+                  var c;
+                  if ((c = a.autoSize) != null && c.skip) return {};
+                  let d, f;
+                  return (
+                    p.startsWith("top") || p.startsWith("bottom")
+                      ? (d = n.reference.width)
+                      : (f = n.reference.height),
+                    (this.$_innerNode.style[
+                      i === "min"
+                        ? "minWidth"
+                        : i === "max"
+                        ? "maxWidth"
+                        : "width"
+                    ] = d != null ? `${d}px` : null),
+                    (this.$_innerNode.style[
+                      i === "min"
+                        ? "minHeight"
+                        : i === "max"
+                        ? "maxHeight"
+                        : "height"
+                    ] = f != null ? `${f}px` : null),
+                    { data: { skip: !0 }, reset: { rects: !0 } }
+                  );
+                },
+              });
+            }
+            (this.autoMaxSize || this.autoBoundaryMaxSize) &&
+              ((this.$_innerNode.style.maxWidth = null),
+              (this.$_innerNode.style.maxHeight = null),
+              e.middleware.push(
+                m.size({
+                  boundary: this.boundary,
+                  padding: this.overflowPadding,
+                  apply: ({ availableWidth: i, availableHeight: n }) => {
+                    (this.$_innerNode.style.maxWidth =
+                      i != null ? `${i}px` : null),
+                      (this.$_innerNode.style.maxHeight =
+                        n != null ? `${n}px` : null);
+                  },
+                })
+              ));
+            const o = await m.computePosition(
+              this.$_referenceNode,
+              this.$_popperNode,
+              e
+            );
+            Object.assign(this.result, {
+              x: o.x,
+              y: o.y,
+              placement: o.placement,
+              strategy: o.strategy,
+              arrow: {
+                ...o.middlewareData.arrow,
+                ...o.middlewareData.arrowOverflow,
+              },
+            });
+          },
+          $_scheduleShow(e, t = !1) {
+            if (
+              (this.$_updateParentShownChildren(!0),
+              (this.$_hideInProgress = !1),
+              clearTimeout(this.$_scheduleTimer),
+              $ && this.instantMove && $.instantMove && $ !== this.parentPopper)
+            ) {
+              $.$_applyHide(!0), this.$_applyShow(!0);
+              return;
+            }
+            t
+              ? this.$_applyShow()
+              : (this.$_scheduleTimer = setTimeout(
+                  this.$_applyShow.bind(this),
+                  this.$_computeDelay("show")
+                ));
+          },
+          $_scheduleHide(e, t = !1) {
+            if (this.shownChildren.size > 0) {
+              this.pendingHide = !0;
+              return;
+            }
+            this.$_updateParentShownChildren(!1),
+              (this.$_hideInProgress = !0),
+              clearTimeout(this.$_scheduleTimer),
+              this.isShown && ($ = this),
+              t
+                ? this.$_applyHide()
+                : (this.$_scheduleTimer = setTimeout(
+                    this.$_applyHide.bind(this),
+                    this.$_computeDelay("hide")
+                  ));
+          },
+          $_computeDelay(e) {
+            const t = this.delay;
+            return parseInt((t && t[e]) || t || 0);
+          },
+          async $_applyShow(e = !1) {
+            clearTimeout(this.$_disposeTimer),
+              clearTimeout(this.$_scheduleTimer),
+              (this.skipTransition = e),
+              !this.isShown &&
+                (this.$_ensureTeleport(),
+                await H(),
+                await this.$_computePosition(),
+                await this.$_applyShowEffect(),
+                this.positioningDisabled ||
+                  this.$_registerEventListeners(
+                    [
+                      ...m.getOverflowAncestors(this.$_referenceNode),
+                      ...m.getOverflowAncestors(this.$_popperNode),
+                    ],
+                    "scroll",
+                    () => {
+                      this.$_computePosition();
+                    }
+                  ));
+          },
+          async $_applyShowEffect() {
+            if (this.$_hideInProgress) return;
+            if (this.computeTransformOrigin) {
+              const t = this.$_referenceNode.getBoundingClientRect(),
+                o = this.$_popperNode.querySelector(".v-popper__wrapper"),
+                i = o.parentNode.getBoundingClientRect(),
+                n = t.x + t.width / 2 - (i.left + o.offsetLeft),
+                p = t.y + t.height / 2 - (i.top + o.offsetTop);
+              this.result.transformOrigin = `${n}px ${p}px`;
+            }
+            (this.isShown = !0),
+              this.$_applyAttrsToTarget({
+                "aria-describedby": this.popperId,
+                "data-popper-shown": "",
+              });
+            const e = this.showGroup;
+            if (e) {
+              let t;
+              for (let o = 0; o < h.length; o++)
+                (t = h[o]),
+                  t.showGroup !== e && (t.hide(), t.$emit("close-group"));
+            }
+            h.push(this), document.body.classList.add("v-popper--some-open");
+            for (const t of te(this.theme))
+              ne(t).push(this),
+                document.body.classList.add(`v-popper--some-open--${t}`);
+            this.$emit("apply-show"),
+              (this.classes.showFrom = !0),
+              (this.classes.showTo = !1),
+              (this.classes.hideFrom = !1),
+              (this.classes.hideTo = !1),
+              await H(),
+              (this.classes.showFrom = !1),
+              (this.classes.showTo = !0),
+              this.noAutoFocus || this.$_popperNode.focus();
+          },
+          async $_applyHide(e = !1) {
+            if (this.shownChildren.size > 0) {
+              (this.pendingHide = !0), (this.$_hideInProgress = !1);
+              return;
+            }
+            if ((clearTimeout(this.$_scheduleTimer), !this.isShown)) return;
+            (this.skipTransition = e),
+              ie(h, this),
+              h.length === 0 &&
+                document.body.classList.remove("v-popper--some-open");
+            for (const o of te(this.theme)) {
+              const i = ne(o);
+              ie(i, this),
+                i.length === 0 &&
+                  document.body.classList.remove(`v-popper--some-open--${o}`);
+            }
+            $ === this && ($ = null),
+              (this.isShown = !1),
+              this.$_applyAttrsToTarget({
+                "aria-describedby": void 0,
+                "data-popper-shown": void 0,
+              }),
+              clearTimeout(this.$_disposeTimer);
+            const t = this.disposeTimeout;
+            t !== null &&
+              (this.$_disposeTimer = setTimeout(() => {
+                this.$_popperNode &&
+                  (this.$_detachPopperNode(), (this.isMounted = !1));
+              }, t)),
+              this.$_removeEventListeners("scroll"),
+              this.$emit("apply-hide"),
+              (this.classes.showFrom = !1),
+              (this.classes.showTo = !1),
+              (this.classes.hideFrom = !0),
+              (this.classes.hideTo = !1),
+              await H(),
+              (this.classes.hideFrom = !1),
+              (this.classes.hideTo = !0);
+          },
+          $_autoShowHide() {
+            this.shown ? this.show() : this.hide();
+          },
+          $_ensureTeleport() {
+            if (this.isDisposed) return;
+            let e = this.container;
+            if (
+              (typeof e == "string"
+                ? (e = window.document.querySelector(e))
+                : e === !1 && (e = this.$_targetNodes[0].parentNode),
+              !e)
+            )
+              throw new Error("No container for popover: " + this.container);
+            e.appendChild(this.$_popperNode), (this.isMounted = !0);
+          },
+          $_addEventListeners() {
+            const e = (o) => {
+              (this.isShown && !this.$_hideInProgress) ||
+                ((o.usedByTooltip = !0),
+                !this.$_preventShow && this.show({ event: o }));
+            };
+            this.$_registerTriggerListeners(
+              this.$_targetNodes,
+              M,
+              this.triggers,
+              this.showTriggers,
+              e
+            ),
+              this.$_registerTriggerListeners(
+                [this.$_popperNode],
+                M,
+                this.popperTriggers,
+                this.popperShowTriggers,
+                e
+              );
+            const t = (o) => {
+              o.usedByTooltip || this.hide({ event: o });
+            };
+            this.$_registerTriggerListeners(
+              this.$_targetNodes,
+              O,
+              this.triggers,
+              this.hideTriggers,
+              t
+            ),
+              this.$_registerTriggerListeners(
+                [this.$_popperNode],
+                O,
+                this.popperTriggers,
+                this.popperHideTriggers,
+                t
+              );
+          },
+          $_registerEventListeners(e, t, o) {
+            this.$_events.push({ targetNodes: e, eventType: t, handler: o }),
+              e.forEach((i) =>
+                i.addEventListener(t, o, y ? { passive: !0 } : void 0)
+              );
+          },
+          $_registerTriggerListeners(e, t, o, i, n) {
+            let p = o;
+            i != null && (p = typeof i == "function" ? i(p) : i),
+              p.forEach((a) => {
+                const d = t[a];
+                d && this.$_registerEventListeners(e, d, n);
+              });
+          },
+          $_removeEventListeners(e) {
+            const t = [];
+            this.$_events.forEach((o) => {
+              const { targetNodes: i, eventType: n, handler: p } = o;
+              !e || e === n
+                ? i.forEach((a) => a.removeEventListener(n, p))
+                : t.push(o);
+            }),
+              (this.$_events = t);
+          },
+          $_refreshListeners() {
+            this.isDisposed ||
+              (this.$_removeEventListeners(), this.$_addEventListeners());
+          },
+          $_handleGlobalClose(e, t = !1) {
+            this.$_showFrameLocked ||
+              (this.hide({ event: e }),
+              e.closePopover
+                ? this.$emit("close-directive")
+                : this.$emit("auto-hide"),
+              t &&
+                ((this.$_preventShow = !0),
+                setTimeout(() => {
+                  this.$_preventShow = !1;
+                }, 300)));
+          },
+          $_detachPopperNode() {
+            this.$_popperNode.parentNode &&
+              this.$_popperNode.parentNode.removeChild(this.$_popperNode);
+          },
+          $_swapTargetAttrs(e, t) {
+            for (const o of this.$_targetNodes) {
+              const i = o.getAttribute(e);
+              i && (o.removeAttribute(e), o.setAttribute(t, i));
+            }
+          },
+          $_applyAttrsToTarget(e) {
+            for (const t of this.$_targetNodes)
+              for (const o in e) {
+                const i = e[o];
+                i == null ? t.removeAttribute(o) : t.setAttribute(o, i);
+              }
+          },
+          $_updateParentShownChildren(e) {
+            let t = this.parentPopper;
+            for (; t; )
+              e
+                ? t.shownChildren.add(this.randomId)
+                : (t.shownChildren.delete(this.randomId),
+                  t.pendingHide && t.hide()),
+                (t = t.parentPopper);
+          },
+          $_isAimingPopper() {
+            const e = this.$_referenceNode.getBoundingClientRect();
+            if (v >= e.left && v <= e.right && T >= e.top && T <= e.bottom) {
+              const t = this.$_popperNode.getBoundingClientRect(),
+                o = v - g,
+                i = T - w,
+                p =
+                  t.left +
+                  t.width / 2 -
+                  g +
+                  (t.top + t.height / 2) -
+                  w +
+                  t.width +
+                  t.height,
+                a = g + o * p,
+                d = w + i * p;
+              return (
+                C(g, w, a, d, t.left, t.top, t.left, t.bottom) ||
+                C(g, w, a, d, t.left, t.top, t.right, t.top) ||
+                C(g, w, a, d, t.right, t.top, t.right, t.bottom) ||
+                C(g, w, a, d, t.left, t.bottom, t.right, t.bottom)
+              );
+            }
+            return !1;
+          },
+        },
+        render() {
+          return this.$slots.default(this.slotData);
+        },
+      });
+  if (typeof document < "u" && typeof window < "u") {
+    if (oe) {
+      const e = y ? { passive: !0, capture: !0 } : !0;
+      document.addEventListener("touchstart", (t) => re(t, !0), e),
+        document.addEventListener("touchend", (t) => pe(t, !0), e);
+    } else
+      window.addEventListener("mousedown", (e) => re(e, !1), !0),
+        window.addEventListener("click", (e) => pe(e, !1), !0);
+    window.addEventListener("resize", le);
+  }
+  function re(e, t) {
+    if (u.autoHideOnMousedown) ae(e, t);
+    else
+      for (let o = 0; o < h.length; o++) {
+        const i = h[o];
+        try {
+          i.mouseDownContains = i.popperNode().contains(e.target);
+        } catch {}
+      }
+  }
+  function pe(e, t) {
+    u.autoHideOnMousedown || ae(e, t);
+  }
+  function ae(e, t) {
+    const o = {};
+    for (let i = h.length - 1; i >= 0; i--) {
+      const n = h[i];
+      try {
+        const p = (n.containsGlobalTarget =
+          n.mouseDownContains || n.popperNode().contains(e.target));
+        (n.pendingHide = !1),
+          requestAnimationFrame(() => {
+            if (((n.pendingHide = !1), !o[n.randomId] && de(n, p, e))) {
+              if (
+                (n.$_handleGlobalClose(e, t),
+                !e.closeAllPopover && e.closePopover && p)
+              ) {
+                let d = n.parentPopper;
+                for (; d; ) (o[d.randomId] = !0), (d = d.parentPopper);
+                return;
+              }
+              let a = n.parentPopper;
+              for (; a && de(a, a.containsGlobalTarget, e); ) {
+                a.$_handleGlobalClose(e, t);
+                a = a.parentPopper;
+              }
+            }
+          });
+      } catch {}
+    }
+  }
+  function de(e, t, o) {
+    return o.closeAllPopover || (o.closePopover && t) || (be(e, o) && !t);
+  }
+  function be(e, t) {
+    if (typeof e.autoHide == "function") {
+      const o = e.autoHide(t);
+      return (e.lastAutoHide = o), o;
+    }
+    return e.autoHide;
+  }
+  function le() {
+    for (let e = 0; e < h.length; e++) h[e].$_computePosition();
+  }
+  function Ne() {
+    for (let e = 0; e < h.length; e++) h[e].hide();
+  }
+  let g = 0,
+    w = 0,
+    v = 0,
+    T = 0;
+  typeof window < "u" &&
+    window.addEventListener(
+      "mousemove",
+      (e) => {
+        (g = v), (w = T), (v = e.clientX), (T = e.clientY);
+      },
+      y ? { passive: !0 } : void 0
+    );
+  function C(e, t, o, i, n, p, a, d) {
+    const f =
+        ((a - n) * (t - p) - (d - p) * (e - n)) /
+        ((d - p) * (o - e) - (a - n) * (i - t)),
+      c =
+        ((o - e) * (t - p) - (i - t) * (e - n)) /
+        ((d - p) * (o - e) - (a - n) * (i - t));
+    return f >= 0 && f <= 1 && c >= 0 && c <= 1;
+  }
+  const ze = { extends: D() },
+    b = (e, t) => {
+      const o = e.__vccOpts || e;
+      for (const [i, n] of t) o[i] = n;
+      return o;
+    };
+  function Ae(e, t, o, i, n, p) {
+    return (
+      s.openBlock(),
+      s.createElementBlock(
+        "div",
+        {
+          ref: "reference",
+          class: s.normalizeClass([
+            "v-popper",
+            { "v-popper--shown": e.slotData.isShown },
+          ]),
+        },
+        [
+          s.renderSlot(
+            e.$slots,
+            "default",
+            s.normalizeProps(s.guardReactiveProps(e.slotData))
+          ),
+        ],
+        2
+      )
+    );
+  }
+  const Be = b(ze, [["render", Ae]]);
+  function Ee() {
+    var e = window.navigator.userAgent,
+      t = e.indexOf("MSIE ");
+    if (t > 0) return parseInt(e.substring(t + 5, e.indexOf(".", t)), 10);
+    var o = e.indexOf("Trident/");
+    if (o > 0) {
+      var i = e.indexOf("rv:");
+      return parseInt(e.substring(i + 3, e.indexOf(".", i)), 10);
+    }
+    var n = e.indexOf("Edge/");
+    return n > 0 ? parseInt(e.substring(n + 5, e.indexOf(".", n)), 10) : -1;
+  }
+  let N;
+  function I() {
+    I.init || ((I.init = !0), (N = Ee() !== -1));
+  }
+  var z = {
+    name: "ResizeObserver",
+    props: {
+      emitOnMount: { type: Boolean, default: !1 },
+      ignoreWidth: { type: Boolean, default: !1 },
+      ignoreHeight: { type: Boolean, default: !1 },
+    },
+    emits: ["notify"],
+    mounted() {
+      I(),
+        s.nextTick(() => {
+          (this._w = this.$el.offsetWidth),
+            (this._h = this.$el.offsetHeight),
+            this.emitOnMount && this.emitSize();
+        });
+      const e = document.createElement("object");
+      (this._resizeObject = e),
+        e.setAttribute("aria-hidden", "true"),
+        e.setAttribute("tabindex", -1),
+        (e.onload = this.addResizeHandlers),
+        (e.type = "text/html"),
+        N && this.$el.appendChild(e),
+        (e.data = "about:blank"),
+        N || this.$el.appendChild(e);
+    },
+    beforeUnmount() {
+      this.removeResizeHandlers();
+    },
+    methods: {
+      compareAndNotify() {
+        ((!this.ignoreWidth && this._w !== this.$el.offsetWidth) ||
+          (!this.ignoreHeight && this._h !== this.$el.offsetHeight)) &&
+          ((this._w = this.$el.offsetWidth),
+          (this._h = this.$el.offsetHeight),
+          this.emitSize());
+      },
+      emitSize() {
+        this.$emit("notify", { width: this._w, height: this._h });
+      },
+      addResizeHandlers() {
+        this._resizeObject.contentDocument.defaultView.addEventListener(
+          "resize",
+          this.compareAndNotify
+        ),
+          this.compareAndNotify();
+      },
+      removeResizeHandlers() {
+        this._resizeObject &&
+          this._resizeObject.onload &&
+          (!N &&
+            this._resizeObject.contentDocument &&
+            this._resizeObject.contentDocument.defaultView.removeEventListener(
+              "resize",
+              this.compareAndNotify
+            ),
+          this.$el.removeChild(this._resizeObject),
+          (this._resizeObject.onload = null),
+          (this._resizeObject = null));
+      },
+    },
+  };
+  const Me = s.withScopeId("data-v-b329ee4c");
+  s.pushScopeId("data-v-b329ee4c");
+  const Oe = { class: "resize-observer", tabindex: "-1" };
+  s.popScopeId();
+  const He = Me(
+    (e, t, o, i, n, p) => (s.openBlock(), s.createBlock("div", Oe))
+  );
+  (z.render = He),
+    (z.__scopeId = "data-v-b329ee4c"),
+    (z.__file = "src/components/ResizeObserver.vue");
+  const F = (e = "theme") => ({
+      computed: {
+        themeClass() {
+          return Ce(this[e]);
+        },
+      },
+    }),
+    ke = s.defineComponent({
+      name: "VPopperContent",
+      components: { ResizeObserver: z },
+      mixins: [F()],
+      props: {
+        popperId: String,
+        theme: String,
+        shown: Boolean,
+        mounted: Boolean,
+        skipTransition: Boolean,
+        autoHide: Boolean,
+        handleResize: Boolean,
+        classes: Object,
+        result: Object,
+      },
+      emits: ["hide", "resize"],
+      methods: {
+        toPx(e) {
+          return e != null && !isNaN(e) ? `${e}px` : null;
+        },
+      },
+    }),
+    Le = ["id", "aria-hidden", "tabindex", "data-popper-placement"],
+    De = { ref: "inner", class: "v-popper__inner" },
+    Ie = [
+      s.createElementVNode("div", { class: "v-popper__arrow-outer" }, null, -1),
+      s.createElementVNode("div", { class: "v-popper__arrow-inner" }, null, -1),
+    ];
+  function Fe(e, t, o, i, n, p) {
+    const a = s.resolveComponent("ResizeObserver");
+    return (
+      s.openBlock(),
+      s.createElementBlock(
+        "div",
+        {
+          id: e.popperId,
+          ref: "popover",
+          class: s.normalizeClass([
+            "v-popper__popper",
+            [
+              e.themeClass,
+              e.classes.popperClass,
+              {
+                "v-popper__popper--shown": e.shown,
+                "v-popper__popper--hidden": !e.shown,
+                "v-popper__popper--show-from": e.classes.showFrom,
+                "v-popper__popper--show-to": e.classes.showTo,
+                "v-popper__popper--hide-from": e.classes.hideFrom,
+                "v-popper__popper--hide-to": e.classes.hideTo,
+                "v-popper__popper--skip-transition": e.skipTransition,
+                "v-popper__popper--arrow-overflow":
+                  e.result && e.result.arrow.overflow,
+                "v-popper__popper--no-positioning": !e.result,
+              },
+            ],
+          ]),
+          style: s.normalizeStyle(
+            e.result
+              ? {
+                  position: e.result.strategy,
+                  transform: `translate3d(${Math.round(
+                    e.result.x
+                  )}px,${Math.round(e.result.y)}px,0)`,
+                }
+              : void 0
+          ),
+          "aria-hidden": e.shown ? "false" : "true",
+          tabindex: e.autoHide ? 0 : void 0,
+          "data-popper-placement": e.result ? e.result.placement : void 0,
+          onKeyup:
+            t[2] ||
+            (t[2] = s.withKeys((d) => e.autoHide && e.$emit("hide"), ["esc"])),
+        },
+        [
+          s.createElementVNode("div", {
+            class: "v-popper__backdrop",
+            onClick: t[0] || (t[0] = (d) => e.autoHide && e.$emit("hide")),
+          }),
+          s.createElementVNode(
+            "div",
+            {
+              class: "v-popper__wrapper",
+              style: s.normalizeStyle(
+                e.result
+                  ? { transformOrigin: e.result.transformOrigin }
+                  : void 0
+              ),
+            },
+            [
+              s.createElementVNode(
+                "div",
+                De,
+                [
+                  e.mounted
+                    ? (s.openBlock(),
+                      s.createElementBlock(
+                        s.Fragment,
+                        { key: 0 },
+                        [
+                          s.createElementVNode("div", null, [
+                            s.renderSlot(e.$slots, "default"),
+                          ]),
+                          e.handleResize
+                            ? (s.openBlock(),
+                              s.createBlock(a, {
+                                key: 0,
+                                onNotify:
+                                  t[1] || (t[1] = (d) => e.$emit("resize", d)),
+                              }))
+                            : s.createCommentVNode("", !0),
+                        ],
+                        64
+                      ))
+                    : s.createCommentVNode("", !0),
+                ],
+                512
+              ),
+              s.createElementVNode(
+                "div",
+                {
+                  ref: "arrow",
+                  class: "v-popper__arrow-container",
+                  style: s.normalizeStyle(
+                    e.result
+                      ? {
+                          left: e.toPx(e.result.arrow.x),
+                          top: e.toPx(e.result.arrow.y),
+                        }
+                      : void 0
+                  ),
+                },
+                Ie,
+                4
+              ),
+            ],
+            4
+          ),
+        ],
+        46,
+        Le
+      )
+    );
+  }
+  const R = b(ke, [["render", Fe]]),
+    V = {
+      methods: {
+        show(...e) {
+          return this.$refs.popper.show(...e);
+        },
+        hide(...e) {
+          return this.$refs.popper.hide(...e);
+        },
+        dispose(...e) {
+          return this.$refs.popper.dispose(...e);
+        },
+        onResize(...e) {
+          return this.$refs.popper.onResize(...e);
+        },
+      },
+    };
+  let j = function () {};
+  typeof window < "u" && (j = window.Element);
+  const Re = s.defineComponent({
+    name: "VPopperWrapper",
+    components: { Popper: Be, PopperContent: R },
+    mixins: [V, F("finalTheme")],
+    props: {
+      theme: { type: String, default: null },
+      referenceNode: { type: Function, default: null },
+      shown: { type: Boolean, default: !1 },
+      showGroup: { type: String, default: null },
+      ariaId: { default: null },
+      disabled: { type: Boolean, default: void 0 },
+      positioningDisabled: { type: Boolean, default: void 0 },
+      placement: { type: String, default: void 0 },
+      delay: { type: [String, Number, Object], default: void 0 },
+      distance: { type: [Number, String], default: void 0 },
+      skidding: { type: [Number, String], default: void 0 },
+      triggers: { type: Array, default: void 0 },
+      showTriggers: { type: [Array, Function], default: void 0 },
+      hideTriggers: { type: [Array, Function], default: void 0 },
+      popperTriggers: { type: Array, default: void 0 },
+      popperShowTriggers: { type: [Array, Function], default: void 0 },
+      popperHideTriggers: { type: [Array, Function], default: void 0 },
+      container: { type: [String, Object, j, Boolean], default: void 0 },
+      boundary: { type: [String, j], default: void 0 },
+      strategy: { type: String, default: void 0 },
+      autoHide: { type: [Boolean, Function], default: void 0 },
+      handleResize: { type: Boolean, default: void 0 },
+      instantMove: { type: Boolean, default: void 0 },
+      eagerMount: { type: Boolean, default: void 0 },
+      popperClass: { type: [String, Array, Object], default: void 0 },
+      computeTransformOrigin: { type: Boolean, default: void 0 },
+      autoMinSize: { type: Boolean, default: void 0 },
+      autoSize: { type: [Boolean, String], default: void 0 },
+      autoMaxSize: { type: Boolean, default: void 0 },
+      autoBoundaryMaxSize: { type: Boolean, default: void 0 },
+      preventOverflow: { type: Boolean, default: void 0 },
+      overflowPadding: { type: [Number, String], default: void 0 },
+      arrowPadding: { type: [Number, String], default: void 0 },
+      arrowOverflow: { type: Boolean, default: void 0 },
+      flip: { type: Boolean, default: void 0 },
+      shift: { type: Boolean, default: void 0 },
+      shiftCrossAxis: { type: Boolean, default: void 0 },
+      noAutoFocus: { type: Boolean, default: void 0 },
+      disposeTimeout: { type: Number, default: void 0 },
+    },
+    emits: {
+      show: () => !0,
+      hide: () => !0,
+      "update:shown": (e) => !0,
+      "apply-show": () => !0,
+      "apply-hide": () => !0,
+      "close-group": () => !0,
+      "close-directive": () => !0,
+      "auto-hide": () => !0,
+      resize: () => !0,
+    },
+    computed: {
+      finalTheme() {
+        return this.theme ?? this.$options.vPopperTheme;
+      },
+    },
+    methods: {
+      getTargetNodes() {
+        return Array.from(this.$el.children).filter(
+          (e) => e !== this.$refs.popperContent.$el
+        );
+      },
+    },
+  });
+  function Ve(e, t, o, i, n, p) {
+    const a = s.resolveComponent("PopperContent"),
+      d = s.resolveComponent("Popper");
+    return (
+      s.openBlock(),
+      s.createBlock(
+        d,
+        s.mergeProps({ ref: "popper" }, e.$props, {
+          theme: e.finalTheme,
+          "target-nodes": e.getTargetNodes,
+          "popper-node": () => e.$refs.popperContent.$el,
+          class: [e.themeClass],
+          onShow: t[0] || (t[0] = () => e.$emit("show")),
+          onHide: t[1] || (t[1] = () => e.$emit("hide")),
+          "onUpdate:shown": t[2] || (t[2] = (f) => e.$emit("update:shown", f)),
+          onApplyShow: t[3] || (t[3] = () => e.$emit("apply-show")),
+          onApplyHide: t[4] || (t[4] = () => e.$emit("apply-hide")),
+          onCloseGroup: t[5] || (t[5] = () => e.$emit("close-group")),
+          onCloseDirective: t[6] || (t[6] = () => e.$emit("close-directive")),
+          onAutoHide: t[7] || (t[7] = () => e.$emit("auto-hide")),
+          onResize: t[8] || (t[8] = () => e.$emit("resize")),
+        }),
+        {
+          default: s.withCtx(
+            ({
+              popperId: f,
+              isShown: c,
+              shouldMountContent: Y,
+              skipTransition: X,
+              autoHide: K,
+              show: J,
+              hide: S,
+              handleResize: Q,
+              onResize: Z,
+              classes: x,
+              result: lt,
+            }) => [
+              s.renderSlot(e.$slots, "default", { shown: c, show: J, hide: S }),
+              s.createVNode(
+                a,
+                {
+                  ref: "popperContent",
+                  "popper-id": f,
+                  theme: e.finalTheme,
+                  shown: c,
+                  mounted: Y,
+                  "skip-transition": X,
+                  "auto-hide": K,
+                  "handle-resize": Q,
+                  classes: x,
+                  result: lt,
+                  onHide: S,
+                  onResize: Z,
+                },
+                {
+                  default: s.withCtx(() => [
+                    s.renderSlot(e.$slots, "popper", { shown: c, hide: S }),
+                  ]),
+                  _: 2,
+                },
+                1032,
+                [
+                  "popper-id",
+                  "theme",
+                  "shown",
+                  "mounted",
+                  "skip-transition",
+                  "auto-hide",
+                  "handle-resize",
+                  "classes",
+                  "result",
+                  "onHide",
+                  "onResize",
+                ]
+              ),
+            ]
+          ),
+          _: 3,
+        },
+        16,
+        ["theme", "target-nodes", "popper-node", "class"]
+      )
+    );
+  }
+  const A = b(Re, [["render", Ve]]),
+    he = { ...A, name: "VDropdown", vPopperTheme: "dropdown" },
+    ue = { ...A, name: "VMenu", vPopperTheme: "menu" },
+    fe = { ...A, name: "VTooltip", vPopperTheme: "tooltip" },
+    je = s.defineComponent({
+      name: "VTooltipDirective",
+      components: { Popper: D(), PopperContent: R },
+      mixins: [V],
+      inheritAttrs: !1,
+      props: {
+        theme: { type: String, default: "tooltip" },
+        html: { type: Boolean, default: (e) => _(e.theme, "html") },
+        content: { type: [String, Number, Function], default: null },
+        loadingContent: {
+          type: String,
+          default: (e) => _(e.theme, "loadingContent"),
+        },
+        targetNodes: { type: Function, required: !0 },
+      },
+      data() {
+        return { asyncContent: null };
+      },
+      computed: {
+        isContentAsync() {
+          return typeof this.content == "function";
+        },
+        loading() {
+          return this.isContentAsync && this.asyncContent == null;
+        },
+        finalContent() {
+          return this.isContentAsync
+            ? this.loading
+              ? this.loadingContent
+              : this.asyncContent
+            : this.content;
+        },
+      },
+      watch: {
+        content: {
+          handler() {
+            this.fetchContent(!0);
+          },
+          immediate: !0,
+        },
+        async finalContent() {
+          await this.$nextTick(), this.$refs.popper.onResize();
+        },
+      },
+      created() {
+        this.$_fetchId = 0;
+      },
+      methods: {
+        fetchContent(e) {
+          if (
+            typeof this.content == "function" &&
+            this.$_isShown &&
+            (e || (!this.$_loading && this.asyncContent == null))
+          ) {
+            (this.asyncContent = null), (this.$_loading = !0);
+            const t = ++this.$_fetchId,
+              o = this.content(this);
+            o.then ? o.then((i) => this.onResult(t, i)) : this.onResult(t, o);
+          }
+        },
+        onResult(e, t) {
+          e === this.$_fetchId &&
+            ((this.$_loading = !1), (this.asyncContent = t));
+        },
+        onShow() {
+          (this.$_isShown = !0), this.fetchContent();
+        },
+        onHide() {
+          this.$_isShown = !1;
+        },
+      },
+    }),
+    We = ["innerHTML"],
+    Ge = ["textContent"];
+  function qe(e, t, o, i, n, p) {
+    const a = s.resolveComponent("PopperContent"),
+      d = s.resolveComponent("Popper");
+    return (
+      s.openBlock(),
+      s.createBlock(
+        d,
+        s.mergeProps({ ref: "popper" }, e.$attrs, {
+          theme: e.theme,
+          "target-nodes": e.targetNodes,
+          "popper-node": () => e.$refs.popperContent.$el,
+          onApplyShow: e.onShow,
+          onApplyHide: e.onHide,
+        }),
+        {
+          default: s.withCtx(
+            ({
+              popperId: f,
+              isShown: c,
+              shouldMountContent: Y,
+              skipTransition: X,
+              autoHide: K,
+              hide: J,
+              handleResize: S,
+              onResize: Q,
+              classes: Z,
+              result: x,
+            }) => [
+              s.createVNode(
+                a,
+                {
+                  ref: "popperContent",
+                  class: s.normalizeClass({
+                    "v-popper--tooltip-loading": e.loading,
+                  }),
+                  "popper-id": f,
+                  theme: e.theme,
+                  shown: c,
+                  mounted: Y,
+                  "skip-transition": X,
+                  "auto-hide": K,
+                  "handle-resize": S,
+                  classes: Z,
+                  result: x,
+                  onHide: J,
+                  onResize: Q,
+                },
+                {
+                  default: s.withCtx(() => [
+                    e.html
+                      ? (s.openBlock(),
+                        s.createElementBlock(
+                          "div",
+                          { key: 0, innerHTML: e.finalContent },
+                          null,
+                          8,
+                          We
+                        ))
+                      : (s.openBlock(),
+                        s.createElementBlock(
+                          "div",
+                          {
+                            key: 1,
+                            textContent: s.toDisplayString(e.finalContent),
+                          },
+                          null,
+                          8,
+                          Ge
+                        )),
+                  ]),
+                  _: 2,
+                },
+                1032,
+                [
+                  "class",
+                  "popper-id",
+                  "theme",
+                  "shown",
+                  "mounted",
+                  "skip-transition",
+                  "auto-hide",
+                  "handle-resize",
+                  "classes",
+                  "result",
+                  "onHide",
+                  "onResize",
+                ]
+              ),
+            ]
+          ),
+          _: 1,
+        },
+        16,
+        ["theme", "target-nodes", "popper-node", "onApplyShow", "onApplyHide"]
+      )
+    );
+  }
+  const ce = b(je, [["render", qe]]),
+    me = "v-popper--has-tooltip";
+  function Ue(e, t) {
+    let o = e.placement;
+    if (!o && t) for (const i of E) t[i] && (o = i);
+    return o || (o = _(e.theme || "tooltip", "placement")), o;
+  }
+  function ge(e, t, o) {
+    let i;
+    const n = typeof t;
+    return (
+      n === "string"
+        ? (i = { content: t })
+        : t && n === "object"
+        ? (i = t)
+        : (i = { content: !1 }),
+      (i.placement = Ue(i, o)),
+      (i.targetNodes = () => [e]),
+      (i.referenceNode = () => e),
+      i
+    );
+  }
+  let W,
+    P,
+    Ye = 0;
+  function Xe() {
+    if (W) return;
+    (P = s.ref([])),
+      (W = s.createApp({
+        name: "VTooltipDirectiveApp",
+        setup() {
+          return { directives: P };
+        },
+        render() {
+          return this.directives.map((t) =>
+            s.h(ce, {
+              ...t.options,
+              shown: t.shown || t.options.shown,
+              key: t.id,
+            })
+          );
+        },
+        devtools: { hide: !0 },
+      }));
+    const e = document.createElement("div");
+    document.body.appendChild(e), W.mount(e);
+  }
+  function we(e, t, o) {
+    Xe();
+    const i = s.ref(ge(e, t, o)),
+      n = s.ref(!1),
+      p = { id: Ye++, options: i, shown: n };
+    return (
+      P.value.push(p),
+      e.classList && e.classList.add(me),
+      (e.$_popper = {
+        options: i,
+        item: p,
+        show() {
+          n.value = !0;
+        },
+        hide() {
+          n.value = !1;
+        },
+      })
+    );
+  }
+  function G(e) {
+    if (e.$_popper) {
+      const t = P.value.indexOf(e.$_popper.item);
+      t !== -1 && P.value.splice(t, 1),
+        delete e.$_popper,
+        delete e.$_popperOldShown,
+        delete e.$_popperMountTarget;
+    }
+    e.classList && e.classList.remove(me);
+  }
+  function $e(e, { value: t, modifiers: o }) {
+    const i = ge(e, t, o);
+    if (!i.content || _(i.theme || "tooltip", "disabled")) G(e);
+    else {
+      let n;
+      e.$_popper
+        ? ((n = e.$_popper), (n.options.value = i))
+        : (n = we(e, t, o)),
+        typeof t.shown < "u" &&
+          t.shown !== e.$_popperOldShown &&
+          ((e.$_popperOldShown = t.shown), t.shown ? n.show() : n.hide());
+    }
+  }
+  const q = {
+    beforeMount: $e,
+    updated: $e,
+    beforeUnmount(e) {
+      G(e);
+    },
+  };
+  function ye(e) {
+    e.addEventListener("mousedown", B),
+      e.addEventListener("click", B),
+      e.addEventListener("touchstart", ve, y ? { passive: !0 } : !1);
+  }
+  function _e(e) {
+    e.removeEventListener("mousedown", B),
+      e.removeEventListener("click", B),
+      e.removeEventListener("touchstart", ve),
+      e.removeEventListener("touchend", Te),
+      e.removeEventListener("touchcancel", Pe);
+  }
+  function B(e) {
+    const t = e.currentTarget;
+    (e.closePopover = !t.$_vclosepopover_touch),
+      (e.closeAllPopover =
+        t.$_closePopoverModifiers && !!t.$_closePopoverModifiers.all);
+  }
+  function ve(e) {
+    if (e.changedTouches.length === 1) {
+      const t = e.currentTarget;
+      t.$_vclosepopover_touch = !0;
+      const o = e.changedTouches[0];
+      (t.$_vclosepopover_touchPoint = o),
+        t.addEventListener("touchend", Te),
+        t.addEventListener("touchcancel", Pe);
+    }
+  }
+  function Te(e) {
+    const t = e.currentTarget;
+    if (((t.$_vclosepopover_touch = !1), e.changedTouches.length === 1)) {
+      const o = e.changedTouches[0],
+        i = t.$_vclosepopover_touchPoint;
+      (e.closePopover =
+        Math.abs(o.screenY - i.screenY) < 20 &&
+        Math.abs(o.screenX - i.screenX) < 20),
+        (e.closeAllPopover =
+          t.$_closePopoverModifiers && !!t.$_closePopoverModifiers.all);
+    }
+  }
+  function Pe(e) {
+    const t = e.currentTarget;
+    t.$_vclosepopover_touch = !1;
+  }
+  const U = {
+      beforeMount(e, { value: t, modifiers: o }) {
+        (e.$_closePopoverModifiers = o), (typeof t > "u" || t) && ye(e);
+      },
+      updated(e, { value: t, oldValue: o, modifiers: i }) {
+        (e.$_closePopoverModifiers = i),
+          t !== o && (typeof t > "u" || t ? ye(e) : _e(e));
+      },
+      beforeUnmount(e) {
+        _e(e);
+      },
+    },
+    Ke = u,
+    Je = q,
+    Qe = q,
+    Ze = U,
+    xe = U,
+    et = he,
+    tt = ue,
+    ot = D,
+    it = R,
+    st = V,
+    nt = A,
+    rt = F,
+    pt = fe,
+    at = ce;
+  function Se(e, t = {}) {
+    e.$_vTooltipInstalled ||
+      ((e.$_vTooltipInstalled = !0),
+      ee(u, t),
+      e.directive("tooltip", q),
+      e.directive("close-popper", U),
+      e.component("VTooltip", fe),
+      e.component("VDropdown", he),
+      e.component("VMenu", ue));
+  }
+  const dt = { version: "5.2.2", install: Se, options: u };
+  (l.Dropdown = et),
+    (l.HIDE_EVENT_MAP = O),
+    (l.Menu = tt),
+    (l.Popper = ot),
+    (l.PopperContent = it),
+    (l.PopperMethods = st),
+    (l.PopperWrapper = nt),
+    (l.SHOW_EVENT_MAP = M),
+    (l.ThemeClass = rt),
+    (l.Tooltip = pt),
+    (l.TooltipDirective = at),
+    (l.VClosePopper = Ze),
+    (l.VTooltip = Je),
+    (l.createTooltip = we),
+    (l.default = dt),
+    (l.destroyTooltip = G),
+    (l.hideAllPoppers = Ne),
+    (l.install = Se),
+    (l.options = Ke),
+    (l.placements = E),
+    (l.recomputeAllPoppers = le),
+    (l.vClosePopper = xe),
+    (l.vTooltip = Qe),
+    Object.defineProperties(l, {
+      __esModule: { value: !0 },
+      [Symbol.toStringTag]: { value: "Module" },
+    });
+});