@indielayer/ui 1.18.1 → 2.1.0

package/lib/node_modules/.pnpm/floating-vue@5.2.2_@nuxt_kit@4.4.6_magicast@0.5.3__vue@3.5.34_typescript@5.2.2_/node_modules/floating-vue/dist/floating-vue.js

@@ -0,0 +1,1243 @@
+import { arrow as e, autoPlacement as t, flip as n, offset as r, shift as i, size as a } from "../../../../@floating-ui_core@1.5.3/node_modules/@floating-ui/core/dist/floating-ui.core.js";
+import { B as o, D as s } from "../../../../@floating-ui_dom@1.1.1/node_modules/@floating-ui/dom/dist/floating-ui.dom.browser.min.js";
+import { Fragment as c, createBlock as l, createCommentVNode as u, createElementBlock as d, createElementVNode as f, createVNode as ee, defineComponent as p, guardReactiveProps as te, mergeProps as ne, nextTick as re, normalizeClass as m, normalizeProps as ie, normalizeStyle as h, openBlock as g, popScopeId as ae, pushScopeId as oe, renderSlot as _, resolveComponent as v, withCtx as y, withKeys as se, withScopeId as ce } from "vue";
+//#region ../../node_modules/.pnpm/floating-vue@5.2.2_@nuxt+kit@4.4.6_magicast@0.5.3__vue@3.5.34_typescript@5.2.2_/node_modules/floating-vue/dist/floating-vue.mjs
+var b = {
+	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 x(e, t) {
+	let n = b.themes[e] || {}, r;
+	do
+		r = n[t], typeof r > "u" ? n.$extend ? n = b.themes[n.$extend] || {} : (n = null, r = b[t]) : n = null;
+	while (n);
+	return r;
+}
+function le(e) {
+	let t = [e], n = b.themes[e] || {};
+	do
+		n.$extend && !n.$resetCss ? (t.push(n.$extend), n = b.themes[n.$extend] || {}) : n = null;
+	while (n);
+	return t.map((e) => `v-popper--theme-${e}`);
+}
+function S(e) {
+	let t = [e], n = b.themes[e] || {};
+	do
+		n.$extend ? (t.push(n.$extend), n = b.themes[n.$extend] || {}) : n = null;
+	while (n);
+	return t;
+}
+var C = !1;
+if (typeof window < "u") {
+	C = !1;
+	try {
+		let e = Object.defineProperty({}, "passive", { get() {
+			C = !0;
+		} });
+		window.addEventListener("test", null, e);
+	} catch {}
+}
+var w = !1;
+typeof window < "u" && typeof navigator < "u" && (w = /iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream);
+var ue = [
+	"auto",
+	"top",
+	"bottom",
+	"left",
+	"right"
+].reduce((e, t) => e.concat([
+	t,
+	`${t}-start`,
+	`${t}-end`
+]), []), T = {
+	hover: "mouseenter",
+	focus: "focus",
+	click: "click",
+	touch: "touchstart",
+	pointer: "pointerdown"
+}, E = {
+	hover: "mouseleave",
+	focus: "blur",
+	click: "click",
+	touch: "touchend",
+	pointer: "pointerup"
+};
+function D(e, t) {
+	let n = e.indexOf(t);
+	n !== -1 && e.splice(n, 1);
+}
+function O() {
+	return new Promise((e) => requestAnimationFrame(() => {
+		requestAnimationFrame(e);
+	}));
+}
+var k = [], A = null, j = {};
+function M(e) {
+	let t = j[e];
+	return t ||= j[e] = [], t;
+}
+var N = function() {};
+typeof window < "u" && (N = window.Element);
+function P(e) {
+	return function(t) {
+		return x(t.theme, e);
+	};
+}
+var F = "__floating-vue__popper", I = () => p({
+	name: "VPopper",
+	provide() {
+		return { [F]: { parentPopper: this } };
+	},
+	inject: { [F]: { 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: P("disabled")
+		},
+		positioningDisabled: {
+			type: Boolean,
+			default: P("positioningDisabled")
+		},
+		placement: {
+			type: String,
+			default: P("placement"),
+			validator: (e) => ue.includes(e)
+		},
+		delay: {
+			type: [
+				String,
+				Number,
+				Object
+			],
+			default: P("delay")
+		},
+		distance: {
+			type: [Number, String],
+			default: P("distance")
+		},
+		skidding: {
+			type: [Number, String],
+			default: P("skidding")
+		},
+		triggers: {
+			type: Array,
+			default: P("triggers")
+		},
+		showTriggers: {
+			type: [Array, Function],
+			default: P("showTriggers")
+		},
+		hideTriggers: {
+			type: [Array, Function],
+			default: P("hideTriggers")
+		},
+		popperTriggers: {
+			type: Array,
+			default: P("popperTriggers")
+		},
+		popperShowTriggers: {
+			type: [Array, Function],
+			default: P("popperShowTriggers")
+		},
+		popperHideTriggers: {
+			type: [Array, Function],
+			default: P("popperHideTriggers")
+		},
+		container: {
+			type: [
+				String,
+				Object,
+				N,
+				Boolean
+			],
+			default: P("container")
+		},
+		boundary: {
+			type: [String, N],
+			default: P("boundary")
+		},
+		strategy: {
+			type: String,
+			validator: (e) => ["absolute", "fixed"].includes(e),
+			default: P("strategy")
+		},
+		autoHide: {
+			type: [Boolean, Function],
+			default: P("autoHide")
+		},
+		handleResize: {
+			type: Boolean,
+			default: P("handleResize")
+		},
+		instantMove: {
+			type: Boolean,
+			default: P("instantMove")
+		},
+		eagerMount: {
+			type: Boolean,
+			default: P("eagerMount")
+		},
+		popperClass: {
+			type: [
+				String,
+				Array,
+				Object
+			],
+			default: P("popperClass")
+		},
+		computeTransformOrigin: {
+			type: Boolean,
+			default: P("computeTransformOrigin")
+		},
+		autoMinSize: {
+			type: Boolean,
+			default: P("autoMinSize")
+		},
+		autoSize: {
+			type: [Boolean, String],
+			default: P("autoSize")
+		},
+		autoMaxSize: {
+			type: Boolean,
+			default: P("autoMaxSize")
+		},
+		autoBoundaryMaxSize: {
+			type: Boolean,
+			default: P("autoBoundaryMaxSize")
+		},
+		preventOverflow: {
+			type: Boolean,
+			default: P("preventOverflow")
+		},
+		overflowPadding: {
+			type: [Number, String],
+			default: P("overflowPadding")
+		},
+		arrowPadding: {
+			type: [Number, String],
+			default: P("arrowPadding")
+		},
+		arrowOverflow: {
+			type: Boolean,
+			default: P("arrowOverflow")
+		},
+		flip: {
+			type: Boolean,
+			default: P("flip")
+		},
+		shift: {
+			type: Boolean,
+			default: P("shift")
+		},
+		shiftCrossAxis: {
+			type: Boolean,
+			default: P("shiftCrossAxis")
+		},
+		noAutoFocus: {
+			type: Boolean,
+			default: P("noAutoFocus")
+		},
+		disposeTimeout: {
+			type: Number,
+			default: P("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: /* @__PURE__ */ new Set(),
+			lastAutoHide: !0,
+			pendingHide: !1,
+			containsGlobalTarget: !1,
+			isDisposed: !0,
+			mouseDownContains: !1
+		};
+	},
+	computed: {
+		popperId() {
+			return this.ariaId == null ? this.randomId : this.ariaId;
+		},
+		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() {
+			return this[F]?.parentPopper;
+		},
+		hasPopperShowTriggerHover() {
+			return this.popperTriggers?.includes("hover") || this.popperShowTriggers?.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: n = !1 } = {}) {
+			var r;
+			(r = this.parentPopper) != null && r.lockedChild && this.parentPopper.lockedChild !== this || (this.pendingHide = !1, (n || !this.disabled) && (this.parentPopper?.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 } = {}) {
+			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;
+				}
+				this.parentPopper?.lockedChild === this && (this.parentPopper.lockedChild = null), this.pendingHide = !1, this.$_scheduleHide(e, t), this.$emit("hide"), this.$emit("update:shown", !1);
+			}
+		},
+		init() {
+			this.isDisposed && (this.isDisposed = !1, this.isMounted = !1, this.$_events = [], this.$_preventShow = !1, this.$_referenceNode = this.referenceNode?.call(this) ?? this.$el, this.$_targetNodes = this.targetNodes().filter((e) => e.nodeType === e.ELEMENT_NODE), this.$_popperNode = this.popperNode(), this.$_innerNode = this.$_popperNode.querySelector(".v-popper__inner"), this.$_arrowNode = this.$_popperNode.querySelector(".v-popper__arrow-container"), this.$_swapTargetAttrs("title", "data-original-title"), this.$_detachPopperNode(), 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;
+			let s = {
+				strategy: this.strategy,
+				middleware: []
+			};
+			(this.distance || this.skidding) && s.middleware.push(r({
+				mainAxis: this.distance,
+				crossAxis: this.skidding
+			}));
+			let c = this.placement.startsWith("auto");
+			if (c ? s.middleware.push(t({ alignment: this.placement.split("-")[1] ?? "" })) : s.placement = this.placement, this.preventOverflow && (this.shift && s.middleware.push(i({
+				padding: this.overflowPadding,
+				boundary: this.boundary,
+				crossAxis: this.shiftCrossAxis
+			})), !c && this.flip && s.middleware.push(n({
+				padding: this.overflowPadding,
+				boundary: this.boundary
+			}))), s.middleware.push(e({
+				element: this.$_arrowNode,
+				padding: this.arrowPadding
+			})), this.arrowOverflow && s.middleware.push({
+				name: "arrowOverflow",
+				fn: ({ placement: e, rects: t, middlewareData: n }) => {
+					let r, { centerOffset: i } = n.arrow;
+					return r = e.startsWith("top") || e.startsWith("bottom") ? Math.abs(i) > t.reference.width / 2 : Math.abs(i) > t.reference.height / 2, { data: { overflow: r } };
+				}
+			}), this.autoMinSize || this.autoSize) {
+				let e = this.autoSize ? this.autoSize : this.autoMinSize ? "min" : null;
+				s.middleware.push({
+					name: "autoSize",
+					fn: ({ rects: t, placement: n, middlewareData: r }) => {
+						var i;
+						if ((i = r.autoSize) != null && i.skip) return {};
+						let a, o;
+						return n.startsWith("top") || n.startsWith("bottom") ? a = t.reference.width : o = t.reference.height, this.$_innerNode.style[e === "min" ? "minWidth" : e === "max" ? "maxWidth" : "width"] = a == null ? null : `${a}px`, this.$_innerNode.style[e === "min" ? "minHeight" : e === "max" ? "maxHeight" : "height"] = o == null ? null : `${o}px`, {
+							data: { skip: !0 },
+							reset: { rects: !0 }
+						};
+					}
+				});
+			}
+			(this.autoMaxSize || this.autoBoundaryMaxSize) && (this.$_innerNode.style.maxWidth = null, this.$_innerNode.style.maxHeight = null, s.middleware.push(a({
+				boundary: this.boundary,
+				padding: this.overflowPadding,
+				apply: ({ availableWidth: e, availableHeight: t }) => {
+					this.$_innerNode.style.maxWidth = e == null ? null : `${e}px`, this.$_innerNode.style.maxHeight = t == null ? null : `${t}px`;
+				}
+			})));
+			let l = await o(this.$_referenceNode, this.$_popperNode, s);
+			Object.assign(this.result, {
+				x: l.x,
+				y: l.y,
+				placement: l.placement,
+				strategy: l.strategy,
+				arrow: {
+					...l.middlewareData.arrow,
+					...l.middlewareData.arrowOverflow
+				}
+			});
+		},
+		$_scheduleShow(e, t = !1) {
+			if (this.$_updateParentShownChildren(!0), this.$_hideInProgress = !1, clearTimeout(this.$_scheduleTimer), A && this.instantMove && A.instantMove && A !== this.parentPopper) {
+				A.$_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 && (A = this), t ? this.$_applyHide() : this.$_scheduleTimer = setTimeout(this.$_applyHide.bind(this), this.$_computeDelay("hide"));
+		},
+		$_computeDelay(e) {
+			let 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 O(), await this.$_computePosition(), await this.$_applyShowEffect(), this.positioningDisabled || this.$_registerEventListeners([...s(this.$_referenceNode), ...s(this.$_popperNode)], "scroll", () => {
+				this.$_computePosition();
+			}));
+		},
+		async $_applyShowEffect() {
+			if (this.$_hideInProgress) return;
+			if (this.computeTransformOrigin) {
+				let e = this.$_referenceNode.getBoundingClientRect(), t = this.$_popperNode.querySelector(".v-popper__wrapper"), n = t.parentNode.getBoundingClientRect(), r = e.x + e.width / 2 - (n.left + t.offsetLeft), i = e.y + e.height / 2 - (n.top + t.offsetTop);
+				this.result.transformOrigin = `${r}px ${i}px`;
+			}
+			this.isShown = !0, this.$_applyAttrsToTarget({
+				"aria-describedby": this.popperId,
+				"data-popper-shown": ""
+			});
+			let e = this.showGroup;
+			if (e) {
+				let t;
+				for (let n = 0; n < k.length; n++) t = k[n], t.showGroup !== e && (t.hide(), t.$emit("close-group"));
+			}
+			k.push(this), document.body.classList.add("v-popper--some-open");
+			for (let e of S(this.theme)) M(e).push(this), document.body.classList.add(`v-popper--some-open--${e}`);
+			this.$emit("apply-show"), this.classes.showFrom = !0, this.classes.showTo = !1, this.classes.hideFrom = !1, this.classes.hideTo = !1, await O(), 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, D(k, this), k.length === 0 && document.body.classList.remove("v-popper--some-open");
+			for (let e of S(this.theme)) {
+				let t = M(e);
+				D(t, this), t.length === 0 && document.body.classList.remove(`v-popper--some-open--${e}`);
+			}
+			A === this && (A = null), this.isShown = !1, this.$_applyAttrsToTarget({
+				"aria-describedby": void 0,
+				"data-popper-shown": void 0
+			}), clearTimeout(this.$_disposeTimer);
+			let 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 O(), 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 Error("No container for popover: " + this.container);
+			e.appendChild(this.$_popperNode), this.isMounted = !0;
+		},
+		$_addEventListeners() {
+			let e = (e) => {
+				this.isShown && !this.$_hideInProgress || (e.usedByTooltip = !0, !this.$_preventShow && this.show({ event: e }));
+			};
+			this.$_registerTriggerListeners(this.$_targetNodes, T, this.triggers, this.showTriggers, e), this.$_registerTriggerListeners([this.$_popperNode], T, this.popperTriggers, this.popperShowTriggers, e);
+			let t = (e) => {
+				e.usedByTooltip || this.hide({ event: e });
+			};
+			this.$_registerTriggerListeners(this.$_targetNodes, E, this.triggers, this.hideTriggers, t), this.$_registerTriggerListeners([this.$_popperNode], E, this.popperTriggers, this.popperHideTriggers, t);
+		},
+		$_registerEventListeners(e, t, n) {
+			this.$_events.push({
+				targetNodes: e,
+				eventType: t,
+				handler: n
+			}), e.forEach((e) => e.addEventListener(t, n, C ? { passive: !0 } : void 0));
+		},
+		$_registerTriggerListeners(e, t, n, r, i) {
+			let a = n;
+			r != null && (a = typeof r == "function" ? r(a) : r), a.forEach((n) => {
+				let r = t[n];
+				r && this.$_registerEventListeners(e, r, i);
+			});
+		},
+		$_removeEventListeners(e) {
+			let t = [];
+			this.$_events.forEach((n) => {
+				let { targetNodes: r, eventType: i, handler: a } = n;
+				!e || e === i ? r.forEach((e) => e.removeEventListener(i, a)) : t.push(n);
+			}), 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 (let n of this.$_targetNodes) {
+				let r = n.getAttribute(e);
+				r && (n.removeAttribute(e), n.setAttribute(t, r));
+			}
+		},
+		$_applyAttrsToTarget(e) {
+			for (let t of this.$_targetNodes) for (let n in e) {
+				let r = e[n];
+				r == null ? t.removeAttribute(n) : t.setAttribute(n, r);
+			}
+		},
+		$_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() {
+			let e = this.$_referenceNode.getBoundingClientRect();
+			if (U >= e.left && U <= e.right && W >= e.top && W <= e.bottom) {
+				let e = this.$_popperNode.getBoundingClientRect(), t = U - V, n = W - H, r = e.left + e.width / 2 - V + (e.top + e.height / 2) - H + e.width + e.height, i = V + t * r, a = H + n * r;
+				return G(V, H, i, a, e.left, e.top, e.left, e.bottom) || G(V, H, i, a, e.left, e.top, e.right, e.top) || G(V, H, i, a, e.right, e.top, e.right, e.bottom) || G(V, H, i, a, e.left, e.bottom, e.right, e.bottom);
+			}
+			return !1;
+		}
+	},
+	render() {
+		return this.$slots.default(this.slotData);
+	}
+});
+if (typeof document < "u" && typeof window < "u") {
+	if (w) {
+		let e = C ? {
+			passive: !0,
+			capture: !0
+		} : !0;
+		document.addEventListener("touchstart", (e) => L(e, !0), e), document.addEventListener("touchend", (e) => R(e, !0), e);
+	} else window.addEventListener("mousedown", (e) => L(e, !1), !0), window.addEventListener("click", (e) => R(e, !1), !0);
+	window.addEventListener("resize", fe);
+}
+function L(e, t) {
+	if (b.autoHideOnMousedown) z(e, t);
+	else for (let t = 0; t < k.length; t++) {
+		let n = k[t];
+		try {
+			n.mouseDownContains = n.popperNode().contains(e.target);
+		} catch {}
+	}
+}
+function R(e, t) {
+	b.autoHideOnMousedown || z(e, t);
+}
+function z(e, t) {
+	let n = {};
+	for (let r = k.length - 1; r >= 0; r--) {
+		let i = k[r];
+		try {
+			let r = i.containsGlobalTarget = i.mouseDownContains || i.popperNode().contains(e.target);
+			i.pendingHide = !1, requestAnimationFrame(() => {
+				if (i.pendingHide = !1, !n[i.randomId] && B(i, r, e)) {
+					if (i.$_handleGlobalClose(e, t), !e.closeAllPopover && e.closePopover && r) {
+						let e = i.parentPopper;
+						for (; e;) n[e.randomId] = !0, e = e.parentPopper;
+						return;
+					}
+					let a = i.parentPopper;
+					for (; a && B(a, a.containsGlobalTarget, e);) a.$_handleGlobalClose(e, t), a = a.parentPopper;
+				}
+			});
+		} catch {}
+	}
+}
+function B(e, t, n) {
+	return n.closeAllPopover || n.closePopover && t || de(e, n) && !t;
+}
+function de(e, t) {
+	if (typeof e.autoHide == "function") {
+		let n = e.autoHide(t);
+		return e.lastAutoHide = n, n;
+	}
+	return e.autoHide;
+}
+function fe() {
+	for (let e = 0; e < k.length; e++) k[e].$_computePosition();
+}
+var V = 0, H = 0, U = 0, W = 0;
+typeof window < "u" && window.addEventListener("mousemove", (e) => {
+	V = U, H = W, U = e.clientX, W = e.clientY;
+}, C ? { passive: !0 } : void 0);
+function G(e, t, n, r, i, a, o, s) {
+	let c = ((o - i) * (t - a) - (s - a) * (e - i)) / ((s - a) * (n - e) - (o - i) * (r - t)), l = ((n - e) * (t - a) - (r - t) * (e - i)) / ((s - a) * (n - e) - (o - i) * (r - t));
+	return c >= 0 && c <= 1 && l >= 0 && l <= 1;
+}
+var pe = { extends: I() }, K = (e, t) => {
+	let n = e.__vccOpts || e;
+	for (let [e, r] of t) n[e] = r;
+	return n;
+};
+function me(e, t, n, r, i, a) {
+	return g(), d("div", {
+		ref: "reference",
+		class: m(["v-popper", { "v-popper--shown": e.slotData.isShown }])
+	}, [_(e.$slots, "default", ie(te(e.slotData)))], 2);
+}
+var he = /* @__PURE__ */ K(pe, [["render", me]]);
+function ge() {
+	var e = window.navigator.userAgent, t = e.indexOf("MSIE ");
+	if (t > 0) return parseInt(e.substring(t + 5, e.indexOf(".", t)), 10);
+	if (e.indexOf("Trident/") > 0) {
+		var n = e.indexOf("rv:");
+		return parseInt(e.substring(n + 3, e.indexOf(".", n)), 10);
+	}
+	var r = e.indexOf("Edge/");
+	return r > 0 ? parseInt(e.substring(r + 5, e.indexOf(".", r)), 10) : -1;
+}
+var q;
+function J() {
+	J.init || (J.init = !0, q = ge() !== -1);
+}
+var Y = {
+	name: "ResizeObserver",
+	props: {
+		emitOnMount: {
+			type: Boolean,
+			default: !1
+		},
+		ignoreWidth: {
+			type: Boolean,
+			default: !1
+		},
+		ignoreHeight: {
+			type: Boolean,
+			default: !1
+		}
+	},
+	emits: ["notify"],
+	mounted() {
+		J(), re(() => {
+			this._w = this.$el.offsetWidth, this._h = this.$el.offsetHeight, this.emitOnMount && this.emitSize();
+		});
+		let e = document.createElement("object");
+		this._resizeObject = e, e.setAttribute("aria-hidden", "true"), e.setAttribute("tabindex", -1), e.onload = this.addResizeHandlers, e.type = "text/html", q && this.$el.appendChild(e), e.data = "about:blank", q || 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 && (!q && this._resizeObject.contentDocument && this._resizeObject.contentDocument.defaultView.removeEventListener("resize", this.compareAndNotify), this.$el.removeChild(this._resizeObject), this._resizeObject.onload = null, this._resizeObject = null);
+		}
+	}
+}, _e = /* @__PURE__ */ ce("data-v-b329ee4c");
+oe("data-v-b329ee4c");
+var ve = {
+	class: "resize-observer",
+	tabindex: "-1"
+};
+ae(), Y.render = /* @__PURE__ */ _e((e, t, n, r, i, a) => (g(), l("div", ve))), Y.__scopeId = "data-v-b329ee4c", Y.__file = "src/components/ResizeObserver.vue";
+var X = (e = "theme") => ({ computed: { themeClass() {
+	return le(this[e]);
+} } }), ye = p({
+	name: "VPopperContent",
+	components: { ResizeObserver: Y },
+	mixins: [X()],
+	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;
+	} }
+}), be = [
+	"id",
+	"aria-hidden",
+	"tabindex",
+	"data-popper-placement"
+], xe = {
+	ref: "inner",
+	class: "v-popper__inner"
+}, Se = [/* @__PURE__ */ f("div", { class: "v-popper__arrow-outer" }, null, -1), /* @__PURE__ */ f("div", { class: "v-popper__arrow-inner" }, null, -1)];
+function Ce(e, t, n, r, i, a) {
+	let o = v("ResizeObserver");
+	return g(), d("div", {
+		id: e.popperId,
+		ref: "popover",
+		class: m(["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: h(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] ||= se((t) => e.autoHide && e.$emit("hide"), ["esc"])
+	}, [f("div", {
+		class: "v-popper__backdrop",
+		onClick: t[0] ||= (t) => e.autoHide && e.$emit("hide")
+	}), f("div", {
+		class: "v-popper__wrapper",
+		style: h(e.result ? { transformOrigin: e.result.transformOrigin } : void 0)
+	}, [f("div", xe, [e.mounted ? (g(), d(c, { key: 0 }, [f("div", null, [_(e.$slots, "default")]), e.handleResize ? (g(), l(o, {
+		key: 0,
+		onNotify: t[1] ||= (t) => e.$emit("resize", t)
+	})) : u("", !0)], 64)) : u("", !0)], 512), f("div", {
+		ref: "arrow",
+		class: "v-popper__arrow-container",
+		style: h(e.result ? {
+			left: e.toPx(e.result.arrow.x),
+			top: e.toPx(e.result.arrow.y)
+		} : void 0)
+	}, Se, 4)], 4)], 46, be);
+}
+var Z = /* @__PURE__ */ K(ye, [["render", Ce]]), we = { 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);
+	}
+} }, Q = function() {};
+typeof window < "u" && (Q = window.Element);
+var Te = p({
+	name: "VPopperWrapper",
+	components: {
+		Popper: he,
+		PopperContent: Z
+	},
+	mixins: [we, X("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,
+				Q,
+				Boolean
+			],
+			default: void 0
+		},
+		boundary: {
+			type: [String, Q],
+			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 Ee(e, t, n, r, i, a) {
+	let o = v("PopperContent"), s = v("Popper");
+	return g(), l(s, ne({ ref: "popper" }, e.$props, {
+		theme: e.finalTheme,
+		"target-nodes": e.getTargetNodes,
+		"popper-node": () => e.$refs.popperContent.$el,
+		class: [e.themeClass],
+		onShow: t[0] ||= () => e.$emit("show"),
+		onHide: t[1] ||= () => e.$emit("hide"),
+		"onUpdate:shown": t[2] ||= (t) => e.$emit("update:shown", t),
+		onApplyShow: t[3] ||= () => e.$emit("apply-show"),
+		onApplyHide: t[4] ||= () => e.$emit("apply-hide"),
+		onCloseGroup: t[5] ||= () => e.$emit("close-group"),
+		onCloseDirective: t[6] ||= () => e.$emit("close-directive"),
+		onAutoHide: t[7] ||= () => e.$emit("auto-hide"),
+		onResize: t[8] ||= () => e.$emit("resize")
+	}), {
+		default: y(({ popperId: t, isShown: n, shouldMountContent: r, skipTransition: i, autoHide: a, show: s, hide: c, handleResize: l, onResize: u, classes: d, result: f }) => [_(e.$slots, "default", {
+			shown: n,
+			show: s,
+			hide: c
+		}), ee(o, {
+			ref: "popperContent",
+			"popper-id": t,
+			theme: e.finalTheme,
+			shown: n,
+			mounted: r,
+			"skip-transition": i,
+			"auto-hide": a,
+			"handle-resize": l,
+			classes: d,
+			result: f,
+			onHide: c,
+			onResize: u
+		}, {
+			default: y(() => [_(e.$slots, "popper", {
+				shown: n,
+				hide: c
+			})]),
+			_: 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"
+	]);
+}
+var $ = /* @__PURE__ */ K(Te, [["render", Ee]]), De = {
+	...$,
+	name: "VDropdown",
+	vPopperTheme: "dropdown"
+};
+({ ...$ }), { ...$ }, p({
+	name: "VTooltipDirective",
+	components: {
+		Popper: I(),
+		PopperContent: Z
+	},
+	mixins: [we],
+	inheritAttrs: !1,
+	props: {
+		theme: {
+			type: String,
+			default: "tooltip"
+		},
+		html: {
+			type: Boolean,
+			default: (e) => x(e.theme, "html")
+		},
+		content: {
+			type: [
+				String,
+				Number,
+				Function
+			],
+			default: null
+		},
+		loadingContent: {
+			type: String,
+			default: (e) => x(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;
+				let e = ++this.$_fetchId, t = this.content(this);
+				t.then ? t.then((t) => this.onResult(e, t)) : this.onResult(e, t);
+			}
+		},
+		onResult(e, t) {
+			e === this.$_fetchId && (this.$_loading = !1, this.asyncContent = t);
+		},
+		onShow() {
+			this.$_isShown = !0, this.fetchContent();
+		},
+		onHide() {
+			this.$_isShown = !1;
+		}
+	}
+});
+var Oe = De;
+//#endregion
+export { Oe as kt };