@jskit-ai/assistant-core 0.1.165 → 0.1.166

package/examples/conversation/node_modules/.vite/deps/VTooltip-jIxO6ULs.js

@@ -0,0 +1,2311 @@
+import { C as vShow, Cn as withDirectives, Dt as mergeProps, Ft as onMounted, Gn as readonly, I as Teleport, Kn as ref, M as Fragment, Mn as effectScope, Ot as nextTick, Qn as toRef, U as computed, Ut as provide, Vn as onScopeDispose, W as createBaseVNode, Wn as reactive, Yn as shallowRef, Zn as toRaw, Zt as resolveDynamicComponent, _n as watchEffect, cn as useId, er as toValue, et as createVNode, gn as watch, hn as warn, jt as onBeforeUnmount, n as Transition, pt as h, r as TransitionGroup, xt as inject } from "./vue.runtime.esm-bundler-YcakWsDn.js";
+import { $ as omit, C as destructComputed, E as eventName, G as isObject, K as isOn, M as focusableChildren, S as defer, V as includes, X as matchesSelector, Y as keys, _ as clamp, c as getCurrentInstance, d as CircularBuffer, et as onlyDefinedProps, gt as consoleError, pt as SUPPORTS_INTERSECTION, q as isPrimitive, r as genericComponent, st as templateRef, u as propsFactory, ut as IN_BROWSER, v as convertToUnit, z as hasEvent } from "./defineComponent-DK6LSjDW.js";
+import { M as isCssColor, N as isParsableColor, P as parseColor, _ as useToggleScope, g as useProxiedModel, h as useRtl, i as provideTheme, j as hasLightForeground, r as makeThemeProps, u as useDisplay } from "./theme-D78LVcJg.js";
+import "/home/merc/Development/current/jskit-ai/node_modules/vuetify/lib/directives/ripple/VRipple.css";
+import "/home/merc/Development/current/jskit-ai/node_modules/vuetify/lib/components/VOverlay/VOverlay.css";
+import "/home/merc/Development/current/jskit-ai/node_modules/vuetify/lib/components/VTooltip/VTooltip.css";
+//#region ../../../../node_modules/vuetify/lib/util/anchor.js
+var block = ["top", "bottom"];
+var inline = [
+	"start",
+	"end",
+	"left",
+	"right"
+];
+/** Parse a raw anchor string into an object */
+function parseAnchor(anchor, isRtl) {
+	let [side, align] = anchor.split(" ");
+	if (!align) align = includes(block, side) ? "start" : includes(inline, side) ? "top" : "center";
+	return {
+		side: toPhysical(side, isRtl),
+		align: toPhysical(align, isRtl)
+	};
+}
+function toPhysical(str, isRtl) {
+	if (str === "start") return isRtl ? "right" : "left";
+	if (str === "end") return isRtl ? "left" : "right";
+	return str;
+}
+function flipSide(anchor) {
+	return {
+		side: {
+			center: "center",
+			top: "bottom",
+			bottom: "top",
+			left: "right",
+			right: "left"
+		}[anchor.side],
+		align: anchor.align
+	};
+}
+function flipAlign(anchor) {
+	return {
+		side: anchor.side,
+		align: {
+			center: "center",
+			top: "bottom",
+			bottom: "top",
+			left: "right",
+			right: "left"
+		}[anchor.align]
+	};
+}
+function flipCorner(anchor) {
+	return {
+		side: anchor.align,
+		align: anchor.side
+	};
+}
+function getAxis(anchor) {
+	return includes(block, anchor.side) ? "y" : "x";
+}
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/util/box.js
+var Box = class {
+	constructor(args) {
+		const pageScale = document.body.currentCSSZoom ?? 1;
+		const isElement = args instanceof Element;
+		const factor = isElement ? 1 + (1 - pageScale) / pageScale : 1;
+		const { x, y, width, height } = isElement ? args.getBoundingClientRect() : args;
+		this.x = x * factor;
+		this.y = y * factor;
+		this.width = width * factor;
+		this.height = height * factor;
+	}
+	get top() {
+		return this.y;
+	}
+	get bottom() {
+		return this.y + this.height;
+	}
+	get left() {
+		return this.x;
+	}
+	get right() {
+		return this.x + this.width;
+	}
+};
+function getOverflow(a, b) {
+	return {
+		x: {
+			before: Math.max(0, b.left - a.left),
+			after: Math.max(0, a.right - b.right)
+		},
+		y: {
+			before: Math.max(0, b.top - a.top),
+			after: Math.max(0, a.bottom - b.bottom)
+		}
+	};
+}
+function getTargetBox(target) {
+	if (Array.isArray(target)) {
+		const pageScale = document.body.currentCSSZoom ?? 1;
+		const factor = 1 + (1 - pageScale) / pageScale;
+		return new Box({
+			x: target[0] * factor,
+			y: target[1] * factor,
+			width: 0 * factor,
+			height: 0 * factor
+		});
+	} else return new Box(target);
+}
+function getElementBox(el) {
+	if (el === document.documentElement) {
+		if (!visualViewport) return new Box({
+			x: 0,
+			y: 0,
+			width: document.documentElement.clientWidth,
+			height: document.documentElement.clientHeight
+		});
+		else {
+			const pageScale = document.body.currentCSSZoom ?? 1;
+			return new Box({
+				x: visualViewport.scale > 1 ? 0 : visualViewport.offsetLeft,
+				y: visualViewport.scale > 1 ? 0 : visualViewport.offsetTop,
+				width: visualViewport.width * visualViewport.scale / pageScale,
+				height: visualViewport.height * visualViewport.scale / pageScale
+			});
+		}
+	} else return new Box(el);
+}
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/util/animation.js
+/** @see https://stackoverflow.com/a/57876601/2074736 */
+function nullifyTransforms(el) {
+	const rect = new Box(el);
+	const style = getComputedStyle(el);
+	const tx = style.transform;
+	if (tx) {
+		let ta, sx, sy, dx, dy;
+		if (tx.startsWith("matrix3d(")) {
+			ta = tx.slice(9, -1).split(/, /);
+			sx = Number(ta[0]);
+			sy = Number(ta[5]);
+			dx = Number(ta[12]);
+			dy = Number(ta[13]);
+		} else if (tx.startsWith("matrix(")) {
+			ta = tx.slice(7, -1).split(/, /);
+			sx = Number(ta[0]);
+			sy = Number(ta[3]);
+			dx = Number(ta[4]);
+			dy = Number(ta[5]);
+		} else return new Box(rect);
+		const to = style.transformOrigin;
+		return new Box({
+			x: rect.x - dx - (1 - sx) * parseFloat(to),
+			y: rect.y - dy - (1 - sy) * parseFloat(to.slice(to.indexOf(" ") + 1)),
+			width: sx ? rect.width / sx : el.offsetWidth + 1,
+			height: sy ? rect.height / sy : el.offsetHeight + 1
+		});
+	} else return new Box(rect);
+}
+function animate(el, keyframes, options) {
+	if (typeof el.animate === "undefined") return { finished: Promise.resolve() };
+	let animation;
+	try {
+		animation = el.animate(keyframes, options);
+	} catch (err) {
+		return { finished: Promise.resolve() };
+	}
+	if (typeof animation.finished === "undefined") animation.finished = new Promise((resolve) => {
+		animation.onfinish = () => {
+			resolve(animation);
+		};
+	});
+	return animation;
+}
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/util/bindProps.js
+var handlers = /* @__PURE__ */ new WeakMap();
+function bindProps(el, props) {
+	Object.keys(props).forEach((k) => {
+		if (isOn(k)) {
+			const name = eventName(k);
+			const handler = handlers.get(el);
+			if (props[k] == null) handler?.forEach((v) => {
+				const [n, fn] = v;
+				if (n === name) {
+					el.removeEventListener(name, fn);
+					handler.delete(v);
+				}
+			});
+			else if (!handler || ![...handler].some((v) => v[0] === name && v[1] === props[k])) {
+				el.addEventListener(name, props[k]);
+				const _handler = handler || /* @__PURE__ */ new Set();
+				_handler.add([name, props[k]]);
+				if (!handlers.has(el)) handlers.set(el, _handler);
+			}
+		} else if (props[k] == null) el.removeAttribute(k);
+		else el.setAttribute(k, props[k]);
+	});
+}
+function unbindProps(el, props) {
+	Object.keys(props).forEach((k) => {
+		if (isOn(k)) {
+			const name = eventName(k);
+			const handler = handlers.get(el);
+			handler?.forEach((v) => {
+				const [n, fn] = v;
+				if (n === name) {
+					el.removeEventListener(name, fn);
+					handler.delete(v);
+				}
+			});
+		} else el.removeAttribute(k);
+	});
+}
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/composables/component.js
+var makeComponentProps = propsFactory({
+	class: [
+		String,
+		Array,
+		Object
+	],
+	style: {
+		type: [
+			String,
+			Array,
+			Object
+		],
+		default: null
+	}
+}, "component");
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/util/deepEqual.js
+function updateRecursionCache(a, b, cache, result) {
+	if (!cache || isPrimitive(a) || isPrimitive(b)) return;
+	const visitedObject = cache.get(a);
+	if (visitedObject) visitedObject.set(b, result);
+	else {
+		const newCacheItem = /* @__PURE__ */ new WeakMap();
+		newCacheItem.set(b, result);
+		cache.set(a, newCacheItem);
+	}
+}
+function findCachedComparison(a, b, cache) {
+	if (!cache || isPrimitive(a) || isPrimitive(b)) return null;
+	const r1 = cache.get(a)?.get(b);
+	if (typeof r1 === "boolean") return r1;
+	const r2 = cache.get(b)?.get(a);
+	if (typeof r2 === "boolean") return r2;
+	return null;
+}
+function deepEqual(a, b, recursionCache = /* @__PURE__ */ new WeakMap()) {
+	if (a === b) return true;
+	if (a instanceof Date && b instanceof Date && a.getTime() !== b.getTime()) return false;
+	if (a !== Object(a) || b !== Object(b)) return false;
+	const props = Object.keys(a);
+	if (props.length !== Object.keys(b).length) return false;
+	const cachedComparisonResult = findCachedComparison(a, b, recursionCache);
+	if (cachedComparisonResult) return cachedComparisonResult;
+	updateRecursionCache(a, b, recursionCache, true);
+	return props.every((p) => deepEqual(a[p], b[p], recursionCache));
+}
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/util/dom.js
+/**
+* Returns:
+*  - 'null' if the node is not attached to the DOM
+*  - the root node (HTMLDocument | ShadowRoot) otherwise
+*/
+function attachedRoot(node) {
+	/* istanbul ignore next */
+	if (typeof node.getRootNode !== "function") {
+		while (node.parentNode) node = node.parentNode;
+		if (node !== document) return null;
+		return document;
+	}
+	const root = node.getRootNode();
+	if (root !== document && root.getRootNode({ composed: true }) !== document) return null;
+	return root;
+}
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/util/getScrollParent.js
+function getScrollParent(el, includeHidden = false) {
+	while (el) {
+		if (includeHidden ? isPotentiallyScrollable(el) : hasScrollbar(el)) return el;
+		el = el.parentElement;
+	}
+	return document.scrollingElement;
+}
+function getScrollParents(el, stopAt) {
+	const elements = [];
+	if (stopAt && el && !stopAt.contains(el)) return elements;
+	while (el) {
+		if (hasScrollbar(el)) elements.push(el);
+		if (el === stopAt) break;
+		el = el.parentElement;
+	}
+	return elements;
+}
+function hasScrollbar(el) {
+	if (!el || el.nodeType !== Node.ELEMENT_NODE) return false;
+	const style = window.getComputedStyle(el);
+	const hasVerticalScrollbar = style.overflowY === "scroll" || style.overflowY === "auto" && el.scrollHeight > el.clientHeight;
+	const hasHorizontalScrollbar = style.overflowX === "scroll" || style.overflowX === "auto" && el.scrollWidth > el.clientWidth;
+	return hasVerticalScrollbar || hasHorizontalScrollbar;
+}
+function isPotentiallyScrollable(el) {
+	if (!el || el.nodeType !== Node.ELEMENT_NODE) return false;
+	const style = window.getComputedStyle(el);
+	return ["scroll", "auto"].includes(style.overflowY);
+}
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/util/isFixedPosition.js
+function isFixedPosition(el) {
+	while (el) {
+		if (window.getComputedStyle(el).position === "fixed") return true;
+		el = el.offsetParent;
+	}
+	return false;
+}
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/util/useRender.js
+function useRender(render) {
+	const vm = getCurrentInstance("useRender");
+	vm.render = render;
+}
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/composables/dimensions.js
+var makeDimensionProps = propsFactory({
+	height: [Number, String],
+	maxHeight: [Number, String],
+	maxWidth: [Number, String],
+	minHeight: [Number, String],
+	minWidth: [Number, String],
+	width: [Number, String]
+}, "dimension");
+function useDimension(props) {
+	return { dimensionStyles: computed(() => {
+		const styles = {};
+		const height = convertToUnit(props.height);
+		const maxHeight = convertToUnit(props.maxHeight);
+		const maxWidth = convertToUnit(props.maxWidth);
+		const minHeight = convertToUnit(props.minHeight);
+		const minWidth = convertToUnit(props.minWidth);
+		const width = convertToUnit(props.width);
+		if (height != null) styles.height = height;
+		if (maxHeight != null) styles.maxHeight = maxHeight;
+		if (maxWidth != null) styles.maxWidth = maxWidth;
+		if (minHeight != null) styles.minHeight = minHeight;
+		if (minWidth != null) styles.minWidth = minWidth;
+		if (width != null) styles.width = width;
+		return styles;
+	}) };
+}
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/composables/color.js
+function useColor(colors) {
+	return destructComputed(() => {
+		const { class: colorClasses, style: colorStyles } = computeColor(colors);
+		return {
+			colorClasses,
+			colorStyles
+		};
+	});
+}
+function useTextColor(color) {
+	const { colorClasses: textColorClasses, colorStyles: textColorStyles } = useColor(() => ({ text: toValue(color) }));
+	return {
+		textColorClasses,
+		textColorStyles
+	};
+}
+function useBackgroundColor(color) {
+	const { colorClasses: backgroundColorClasses, colorStyles: backgroundColorStyles } = useColor(() => ({ background: toValue(color) }));
+	return {
+		backgroundColorClasses,
+		backgroundColorStyles
+	};
+}
+function normalizeColors(colors) {
+	return {
+		text: typeof colors.text === "string" ? colors.text.replace(/^text-/, "") : colors.text,
+		background: typeof colors.background === "string" ? colors.background.replace(/^bg-/, "") : colors.background
+	};
+}
+function computeColor(colors) {
+	const _colors = normalizeColors(toValue(colors));
+	const classes = [];
+	const styles = {};
+	if (_colors.background) {
+		if (isCssColor(_colors.background)) {
+			styles.backgroundColor = _colors.background;
+			if (!_colors.text && isParsableColor(_colors.background)) {
+				const backgroundColor = parseColor(_colors.background);
+				if (backgroundColor.a == null || backgroundColor.a === 1) classes.push(hasLightForeground(backgroundColor) ? "v-theme-on-dark" : "v-theme-on-light");
+			}
+		} else classes.push(`bg-${_colors.background}`);
+	}
+	if (_colors.text) {
+		if (isCssColor(_colors.text)) {
+			styles.color = _colors.text;
+			styles.caretColor = _colors.text;
+		} else classes.push(`text-${_colors.text}`);
+	}
+	return {
+		class: classes,
+		style: styles
+	};
+}
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/composables/transition.js
+var makeTransitionProps = propsFactory({ transition: {
+	type: null,
+	default: "fade-transition",
+	validator: (val) => val !== true
+} }, "transition");
+var MaybeTransition = (props, { slots }) => {
+	const { transition, disabled, group, ...rest } = props;
+	const { component = group ? TransitionGroup : Transition, ...customProps } = isObject(transition) ? transition : {};
+	let transitionProps;
+	if (isObject(transition)) transitionProps = mergeProps(customProps, onlyDefinedProps({
+		disabled,
+		group
+	}), rest);
+	else transitionProps = mergeProps({ name: disabled || !transition ? "" : transition }, rest);
+	return h(component, transitionProps, slots);
+};
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/directives/intersect/index.js
+function mounted$3(el, binding) {
+	if (!SUPPORTS_INTERSECTION) return;
+	const modifiers = binding.modifiers || {};
+	const value = binding.value;
+	const { handler, options } = typeof value === "object" ? value : {
+		handler: value,
+		options: {}
+	};
+	const observer = new IntersectionObserver((entries = [], observer) => {
+		const _observe = el._observe?.[binding.instance.$.uid];
+		if (!_observe) return;
+		const isIntersecting = entries.some((entry) => entry.isIntersecting);
+		if (handler && (!modifiers.quiet || _observe.init) && (!modifiers.once || isIntersecting || _observe.init)) handler(isIntersecting, entries, observer);
+		if (isIntersecting && modifiers.once) unmounted$3(el, binding);
+		else _observe.init = true;
+	}, options);
+	el._observe = Object(el._observe);
+	el._observe[binding.instance.$.uid] = {
+		init: false,
+		observer
+	};
+	observer.observe(el);
+}
+function unmounted$3(el, binding) {
+	const observe = el._observe?.[binding.instance.$.uid];
+	if (!observe) return;
+	observe.observer.unobserve(el);
+	delete el._observe[binding.instance.$.uid];
+}
+var Intersect = {
+	mounted: mounted$3,
+	unmounted: unmounted$3,
+	updated: (el, binding) => {
+		if (el._observe?.[binding.instance.$.uid]) {
+			unmounted$3(el, binding);
+			mounted$3(el, binding);
+		}
+	}
+};
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/composables/router.js
+function useRoute() {
+	const vm = getCurrentInstance("useRoute");
+	return computed(() => vm?.proxy?.$route);
+}
+function useRouter() {
+	return getCurrentInstance("useRouter")?.proxy?.$router;
+}
+function useLink(props, attrs) {
+	const RouterLink = resolveDynamicComponent("RouterLink");
+	const isLink = toRef(() => !!(props.href || props.to));
+	const isClickable = computed(() => {
+		return isLink?.value || hasEvent(attrs, "click") || hasEvent(props, "click");
+	});
+	if (typeof RouterLink === "string" || !("useLink" in RouterLink)) {
+		const href = toRef(() => props.href);
+		return {
+			isLink,
+			isRouterLink: toRef(() => false),
+			isClickable,
+			href,
+			linkProps: reactive({ href }),
+			route: toRef(() => void 0),
+			navigate: toRef(() => void 0)
+		};
+	}
+	const routerLink = RouterLink.useLink({
+		to: toRef(() => props.to || ""),
+		replace: toRef(() => props.replace)
+	});
+	const link = computed(() => props.to ? routerLink : void 0);
+	const route = useRoute();
+	const isActive = computed(() => {
+		if (!link.value) return false;
+		if (!props.exact) return link.value.isActive?.value ?? false;
+		if (!route.value) return link.value.isExactActive?.value ?? false;
+		return link.value.isExactActive?.value && deepEqual(link.value.route.value.query, route.value.query);
+	});
+	const href = computed(() => props.to ? link.value?.route.value.href : props.href);
+	return {
+		isLink,
+		isRouterLink: toRef(() => !!props.to),
+		isClickable,
+		isActive,
+		route: toRef(() => link.value?.route.value),
+		navigate: toRef(() => link.value?.navigate),
+		href,
+		linkProps: reactive({
+			href,
+			"aria-current": toRef(() => isActive.value ? "page" : void 0),
+			"aria-disabled": toRef(() => props.disabled && isLink.value ? "true" : void 0),
+			tabindex: toRef(() => props.disabled && isLink.value ? "-1" : void 0)
+		})
+	};
+}
+var makeRouterProps = propsFactory({
+	href: String,
+	replace: Boolean,
+	to: [String, Object],
+	exact: Boolean
+}, "router");
+var inTransition = false;
+function useBackButton(router, cb) {
+	let popped = false;
+	let removeBefore;
+	let removeAfter;
+	if (IN_BROWSER && router?.beforeEach) {
+		nextTick(() => {
+			window.addEventListener("popstate", onPopstate);
+			removeBefore = router.beforeEach((to, from, next) => {
+				if (!inTransition) setTimeout(() => popped ? cb(next) : next());
+				else popped ? cb(next) : next();
+				inTransition = true;
+			});
+			removeAfter = router?.afterEach(() => {
+				inTransition = false;
+			});
+		});
+		onScopeDispose(() => {
+			window.removeEventListener("popstate", onPopstate);
+			removeBefore?.();
+			removeAfter?.();
+		});
+	}
+	function onPopstate(e) {
+		if (e.state?.replaced) return;
+		popped = true;
+		setTimeout(() => popped = false);
+	}
+}
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/directives/ripple/index.js
+var stopSymbol = Symbol("rippleStop");
+var DELAY_RIPPLE = 80;
+function transform(el, value) {
+	el.style.transform = value;
+	el.style.webkitTransform = value;
+}
+function isTouchEvent(e) {
+	return e.constructor.name === "TouchEvent";
+}
+function isKeyboardEvent(e) {
+	return e.constructor.name === "KeyboardEvent";
+}
+var calculate = (e, el, value = {}) => {
+	let localX = 0;
+	let localY = 0;
+	if (!isKeyboardEvent(e)) {
+		const offset = el.getBoundingClientRect();
+		const target = isTouchEvent(e) ? e.touches[e.touches.length - 1] : e;
+		localX = target.clientX - offset.left;
+		localY = target.clientY - offset.top;
+	}
+	let radius = 0;
+	let scale = .3;
+	if (el._ripple?.circle) {
+		scale = .15;
+		radius = el.clientWidth / 2;
+		radius = value.center ? radius : radius + Math.sqrt((localX - radius) ** 2 + (localY - radius) ** 2) / 4;
+	} else radius = Math.sqrt(el.clientWidth ** 2 + el.clientHeight ** 2) / 2;
+	const centerX = `${(el.clientWidth - radius * 2) / 2}px`;
+	const centerY = `${(el.clientHeight - radius * 2) / 2}px`;
+	const x = value.center ? centerX : `${localX - radius}px`;
+	const y = value.center ? centerY : `${localY - radius}px`;
+	return {
+		radius,
+		scale,
+		x,
+		y,
+		centerX,
+		centerY
+	};
+};
+var ripples = {
+	show(e, el, value = {}) {
+		if (!el?._ripple?.enabled) return;
+		const container = document.createElement("span");
+		const animation = document.createElement("span");
+		container.appendChild(animation);
+		container.className = "v-ripple__container";
+		if (value.class) container.className += ` ${value.class}`;
+		const { radius, scale, x, y, centerX, centerY } = calculate(e, el, value);
+		const size = `${radius * 2}px`;
+		animation.className = "v-ripple__animation";
+		animation.style.width = size;
+		animation.style.height = size;
+		el.appendChild(container);
+		const computed = window.getComputedStyle(el);
+		if (computed && computed.position === "static") {
+			el.style.position = "relative";
+			el.dataset.previousPosition = "static";
+		}
+		animation.classList.add("v-ripple__animation--enter");
+		animation.classList.add("v-ripple__animation--visible");
+		transform(animation, `translate(${x}, ${y}) scale3d(${scale},${scale},${scale})`);
+		animation.dataset.activated = String(performance.now());
+		requestAnimationFrame(() => {
+			requestAnimationFrame(() => {
+				animation.classList.remove("v-ripple__animation--enter");
+				animation.classList.add("v-ripple__animation--in");
+				transform(animation, `translate(${centerX}, ${centerY}) scale3d(1,1,1)`);
+			});
+		});
+	},
+	hide(el) {
+		if (!el?._ripple?.enabled) return;
+		const ripples = el.getElementsByClassName("v-ripple__animation");
+		if (ripples.length === 0) return;
+		const animation = Array.from(ripples).findLast((ripple) => !ripple.dataset.isHiding);
+		if (!animation) return;
+		else animation.dataset.isHiding = "true";
+		const diff = performance.now() - Number(animation.dataset.activated);
+		const delay = Math.max(250 - diff, 0);
+		setTimeout(() => {
+			animation.classList.remove("v-ripple__animation--in");
+			animation.classList.add("v-ripple__animation--out");
+			setTimeout(() => {
+				if (el.getElementsByClassName("v-ripple__animation").length === 1 && el.dataset.previousPosition) {
+					el.style.position = el.dataset.previousPosition;
+					delete el.dataset.previousPosition;
+				}
+				if (animation.parentNode?.parentNode === el) el.removeChild(animation.parentNode);
+			}, 300);
+		}, delay);
+	}
+};
+function isRippleEnabled(value) {
+	return typeof value === "undefined" || !!value;
+}
+function rippleShow(e) {
+	const value = {};
+	const element = e.currentTarget;
+	if (!element?._ripple || element._ripple.touched || e[stopSymbol]) return;
+	e[stopSymbol] = true;
+	if (isTouchEvent(e)) {
+		element._ripple.touched = true;
+		element._ripple.isTouch = true;
+	} else if (element._ripple.isTouch) return;
+	value.center = element._ripple.centered || isKeyboardEvent(e);
+	if (element._ripple.class) value.class = element._ripple.class;
+	if (isTouchEvent(e)) {
+		if (element._ripple.showTimerCommit) return;
+		element._ripple.showTimerCommit = () => {
+			ripples.show(e, element, value);
+		};
+		element._ripple.showTimer = window.setTimeout(() => {
+			if (element?._ripple?.showTimerCommit) {
+				element._ripple.showTimerCommit();
+				element._ripple.showTimerCommit = null;
+			}
+		}, DELAY_RIPPLE);
+	} else ripples.show(e, element, value);
+}
+function rippleStop(e) {
+	e[stopSymbol] = true;
+}
+function rippleHide(e) {
+	const element = e.currentTarget;
+	if (!element?._ripple) return;
+	window.clearTimeout(element._ripple.showTimer);
+	if (e.type === "touchend" && element._ripple.showTimerCommit) {
+		element._ripple.showTimerCommit();
+		element._ripple.showTimerCommit = null;
+		element._ripple.showTimer = window.setTimeout(() => {
+			rippleHide(e);
+		});
+		return;
+	}
+	window.setTimeout(() => {
+		if (element._ripple) element._ripple.touched = false;
+	});
+	ripples.hide(element);
+}
+function rippleCancelShow(e) {
+	const element = e.currentTarget;
+	if (!element?._ripple) return;
+	if (element._ripple.showTimerCommit) element._ripple.showTimerCommit = null;
+	window.clearTimeout(element._ripple.showTimer);
+}
+var keyboardRipple = false;
+function keyboardRippleShow(e, keys) {
+	if (!keyboardRipple && keys.includes(e.key)) {
+		keyboardRipple = true;
+		rippleShow(e);
+	}
+}
+function keyboardRippleHide(e) {
+	keyboardRipple = false;
+	rippleHide(e);
+}
+function focusRippleHide(e) {
+	if (keyboardRipple) {
+		keyboardRipple = false;
+		rippleHide(e);
+	}
+}
+function updateRipple(el, binding, wasEnabled) {
+	const { value, modifiers } = binding;
+	const enabled = isRippleEnabled(value);
+	if (!enabled) ripples.hide(el);
+	el._ripple = el._ripple ?? {};
+	el._ripple.enabled = enabled;
+	el._ripple.centered = modifiers.center;
+	el._ripple.circle = modifiers.circle;
+	const bindingValue = isObject(value) ? value : {};
+	if (bindingValue.class) el._ripple.class = bindingValue.class;
+	const allowedKeys = bindingValue.keys ?? ["Enter", "Space"];
+	el._ripple.keyDownHandler = (e) => keyboardRippleShow(e, allowedKeys);
+	if (enabled && !wasEnabled) {
+		if (modifiers.stop) {
+			el.addEventListener("touchstart", rippleStop, { passive: true });
+			el.addEventListener("mousedown", rippleStop);
+			return;
+		}
+		el.addEventListener("touchstart", rippleShow, { passive: true });
+		el.addEventListener("touchend", rippleHide, { passive: true });
+		el.addEventListener("touchmove", rippleCancelShow, { passive: true });
+		el.addEventListener("touchcancel", rippleHide);
+		el.addEventListener("mousedown", rippleShow);
+		el.addEventListener("mouseup", rippleHide);
+		el.addEventListener("mouseleave", rippleHide);
+		el.addEventListener("keydown", el._ripple.keyDownHandler);
+		el.addEventListener("keyup", keyboardRippleHide);
+		el.addEventListener("blur", focusRippleHide);
+		el.addEventListener("dragstart", rippleHide, { passive: true });
+	} else if (!enabled && wasEnabled) removeListeners(el);
+}
+function removeListeners(el) {
+	el.removeEventListener("touchstart", rippleStop);
+	el.removeEventListener("mousedown", rippleStop);
+	el.removeEventListener("touchstart", rippleShow);
+	el.removeEventListener("touchend", rippleHide);
+	el.removeEventListener("touchmove", rippleCancelShow);
+	el.removeEventListener("touchcancel", rippleHide);
+	el.removeEventListener("mousedown", rippleShow);
+	el.removeEventListener("mouseup", rippleHide);
+	el.removeEventListener("mouseleave", rippleHide);
+	if (el._ripple?.keyDownHandler) el.removeEventListener("keydown", el._ripple.keyDownHandler);
+	el.removeEventListener("keyup", keyboardRippleHide);
+	el.removeEventListener("blur", focusRippleHide);
+	el.removeEventListener("dragstart", rippleHide);
+}
+function mounted$2(el, binding) {
+	updateRipple(el, binding, false);
+}
+function unmounted$2(el) {
+	removeListeners(el);
+	delete el._ripple;
+}
+function updated(el, binding) {
+	if (binding.value === binding.oldValue) return;
+	updateRipple(el, binding, isRippleEnabled(binding.oldValue));
+}
+var Ripple = {
+	mounted: mounted$2,
+	unmounted: unmounted$2,
+	updated
+};
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/composables/forwardRefs.js
+var Refs = Symbol("Forwarded refs");
+/** Omit properties starting with P */
+/** Omit keyof $props from T */
+function getDescriptor(obj, key) {
+	let currentObj = obj;
+	while (currentObj) {
+		const descriptor = Reflect.getOwnPropertyDescriptor(currentObj, key);
+		if (descriptor) return descriptor;
+		currentObj = Object.getPrototypeOf(currentObj);
+	}
+}
+function forwardRefs(target, ...refs) {
+	target[Refs] = refs;
+	return new Proxy(target, {
+		get(target, key) {
+			if (Reflect.has(target, key)) return Reflect.get(target, key);
+			if (typeof key === "symbol" || key.startsWith("$") || key.startsWith("__")) return;
+			for (const ref of refs) if (ref.value && Reflect.has(ref.value, key)) {
+				const val = Reflect.get(ref.value, key);
+				return typeof val === "function" ? val.bind(ref.value) : val;
+			}
+		},
+		has(target, key) {
+			if (Reflect.has(target, key)) return true;
+			if (typeof key === "symbol" || key.startsWith("$") || key.startsWith("__")) return false;
+			for (const ref of refs) if (ref.value && Reflect.has(ref.value, key)) return true;
+			return false;
+		},
+		set(target, key, value) {
+			if (Reflect.has(target, key)) return Reflect.set(target, key, value);
+			if (typeof key === "symbol" || key.startsWith("$") || key.startsWith("__")) return false;
+			for (const ref of refs) if (ref.value && Reflect.has(ref.value, key)) return Reflect.set(ref.value, key, value);
+			return false;
+		},
+		getOwnPropertyDescriptor(target, key) {
+			const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
+			if (descriptor) return descriptor;
+			if (typeof key === "symbol" || key.startsWith("$") || key.startsWith("__")) return;
+			for (const ref of refs) {
+				if (!ref.value) continue;
+				const descriptor = getDescriptor(ref.value, key) ?? ("_" in ref.value ? getDescriptor(ref.value._?.setupState, key) : void 0);
+				if (descriptor) return descriptor;
+			}
+			for (const ref of refs) {
+				const childRefs = ref.value && ref.value[Refs];
+				if (!childRefs) continue;
+				const queue = childRefs.slice();
+				while (queue.length) {
+					const ref = queue.shift();
+					const descriptor = getDescriptor(ref.value, key);
+					if (descriptor) return descriptor;
+					const childRefs = ref.value && ref.value[Refs];
+					if (childRefs) queue.push(...childRefs);
+				}
+			}
+		}
+	});
+}
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/components/VOverlay/util/point.js
+/** Convert a point in local space to viewport space */
+function elementToViewport(point, offset) {
+	return {
+		x: point.x + offset.x,
+		y: point.y + offset.y
+	};
+}
+/** Get the difference between two points */
+function getOffset(a, b) {
+	return {
+		x: a.x - b.x,
+		y: a.y - b.y
+	};
+}
+/** Convert an anchor object to a point in local space */
+function anchorToPoint(anchor, box) {
+	if (anchor.side === "top" || anchor.side === "bottom") {
+		const { side, align } = anchor;
+		return elementToViewport({
+			x: align === "left" ? 0 : align === "center" ? box.width / 2 : align === "right" ? box.width : align,
+			y: side === "top" ? 0 : side === "bottom" ? box.height : side
+		}, box);
+	} else if (anchor.side === "left" || anchor.side === "right") {
+		const { side, align } = anchor;
+		return elementToViewport({
+			x: side === "left" ? 0 : side === "right" ? box.width : side,
+			y: align === "top" ? 0 : align === "center" ? box.height / 2 : align === "bottom" ? box.height : align
+		}, box);
+	}
+	return elementToViewport({
+		x: box.width / 2,
+		y: box.height / 2
+	}, box);
+}
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/components/VOverlay/locationStrategies.js
+var locationStrategies = {
+	static: staticLocationStrategy,
+	connected: connectedLocationStrategy
+};
+var makeLocationStrategyProps = propsFactory({
+	locationStrategy: {
+		type: [String, Function],
+		default: "static",
+		validator: (val) => typeof val === "function" || val in locationStrategies
+	},
+	location: {
+		type: String,
+		default: "bottom"
+	},
+	origin: {
+		type: String,
+		default: "auto"
+	},
+	offset: [
+		Number,
+		String,
+		Array
+	],
+	stickToTarget: Boolean,
+	viewportMargin: {
+		type: [Number, String],
+		default: 12
+	}
+}, "VOverlay-location-strategies");
+function useLocationStrategies(props, data) {
+	const contentStyles = ref({});
+	const updateLocation = ref();
+	if (IN_BROWSER) useToggleScope(() => !!(data.isActive.value && props.locationStrategy), (reset) => {
+		watch(() => props.locationStrategy, reset);
+		onScopeDispose(() => {
+			window.removeEventListener("resize", onResize);
+			visualViewport?.removeEventListener("resize", onVisualResize);
+			visualViewport?.removeEventListener("scroll", onVisualScroll);
+			updateLocation.value = void 0;
+		});
+		window.addEventListener("resize", onResize, { passive: true });
+		visualViewport?.addEventListener("resize", onVisualResize, { passive: true });
+		visualViewport?.addEventListener("scroll", onVisualScroll, { passive: true });
+		if (typeof props.locationStrategy === "function") updateLocation.value = props.locationStrategy(data, props, contentStyles)?.updateLocation;
+		else updateLocation.value = locationStrategies[props.locationStrategy](data, props, contentStyles)?.updateLocation;
+	});
+	function onResize(e) {
+		updateLocation.value?.(e);
+	}
+	function onVisualResize(e) {
+		updateLocation.value?.(e);
+	}
+	function onVisualScroll(e) {
+		updateLocation.value?.(e);
+	}
+	return {
+		contentStyles,
+		updateLocation
+	};
+}
+function staticLocationStrategy() {}
+/** Get size of element ignoring max-width/max-height */
+function getIntrinsicSize(el, isRtl) {
+	const contentBox = nullifyTransforms(el);
+	if (isRtl) contentBox.x += parseFloat(el.style.right || 0);
+	else contentBox.x -= parseFloat(el.style.left || 0);
+	contentBox.y -= parseFloat(el.style.top || 0);
+	return contentBox;
+}
+function connectedLocationStrategy(data, props, contentStyles) {
+	if (Array.isArray(data.target.value) || isFixedPosition(data.target.value)) Object.assign(contentStyles.value, {
+		position: "fixed",
+		top: 0,
+		[data.isRtl.value ? "right" : "left"]: 0
+	});
+	const { preferredAnchor, preferredOrigin } = destructComputed(() => {
+		const parsedAnchor = parseAnchor(props.location, data.isRtl.value);
+		const parsedOrigin = props.origin === "overlap" ? parsedAnchor : props.origin === "auto" ? flipSide(parsedAnchor) : parseAnchor(props.origin, data.isRtl.value);
+		if (parsedAnchor.side === parsedOrigin.side && parsedAnchor.align === flipAlign(parsedOrigin).align) return {
+			preferredAnchor: flipCorner(parsedAnchor),
+			preferredOrigin: flipCorner(parsedOrigin)
+		};
+		else return {
+			preferredAnchor: parsedAnchor,
+			preferredOrigin: parsedOrigin
+		};
+	});
+	const [minWidth, minHeight, maxWidth, maxHeight] = [
+		"minWidth",
+		"minHeight",
+		"maxWidth",
+		"maxHeight"
+	].map((key) => {
+		return computed(() => {
+			const val = parseFloat(props[key]);
+			return isNaN(val) ? Infinity : val;
+		});
+	});
+	const offset = computed(() => {
+		if (Array.isArray(props.offset)) return props.offset;
+		if (typeof props.offset === "string") {
+			const offset = props.offset.split(" ").map(parseFloat);
+			if (offset.length < 2) offset.push(0);
+			return offset;
+		}
+		return typeof props.offset === "number" ? [props.offset, 0] : [0, 0];
+	});
+	let observe = false;
+	let lastFrame = -1;
+	const flipped = new CircularBuffer(4);
+	const observer = new ResizeObserver(() => {
+		if (!observe) return;
+		requestAnimationFrame((newTime) => {
+			if (newTime !== lastFrame) flipped.clear();
+			requestAnimationFrame((newNewTime) => {
+				lastFrame = newNewTime;
+			});
+		});
+		if (flipped.isFull) {
+			const values = flipped.values();
+			if (deepEqual(values.at(-1), values.at(-3)) && !deepEqual(values.at(-1), values.at(-2))) return;
+		}
+		const result = updateLocation();
+		if (result) flipped.push(result.flipped);
+	});
+	let targetBox = new Box({
+		x: 0,
+		y: 0,
+		width: 0,
+		height: 0
+	});
+	watch(data.target, (newTarget, oldTarget) => {
+		if (oldTarget && !Array.isArray(oldTarget)) observer.unobserve(oldTarget);
+		if (!Array.isArray(newTarget)) {
+			if (newTarget) observer.observe(newTarget);
+		} else if (!deepEqual(newTarget, oldTarget)) updateLocation();
+	}, { immediate: true });
+	watch(data.contentEl, (newContentEl, oldContentEl) => {
+		if (oldContentEl) observer.unobserve(oldContentEl);
+		if (newContentEl) observer.observe(newContentEl);
+	}, { immediate: true });
+	onScopeDispose(() => {
+		observer.disconnect();
+	});
+	function updateLocation() {
+		observe = false;
+		requestAnimationFrame(() => observe = true);
+		if (!data.target.value || !data.contentEl.value) return;
+		if (Array.isArray(data.target.value) || data.target.value.offsetParent || data.target.value.getClientRects().length) targetBox = getTargetBox(data.target.value);
+		const contentBox = getIntrinsicSize(data.contentEl.value, data.isRtl.value);
+		const scrollParents = getScrollParents(data.contentEl.value);
+		const viewportMargin = Number(props.viewportMargin);
+		if (!scrollParents.length) {
+			scrollParents.push(document.documentElement);
+			if (!(data.contentEl.value.style.top && data.contentEl.value.style.left)) {
+				contentBox.x -= parseFloat(document.documentElement.style.getPropertyValue("--v-body-scroll-x") || 0);
+				contentBox.y -= parseFloat(document.documentElement.style.getPropertyValue("--v-body-scroll-y") || 0);
+			}
+		}
+		const viewport = scrollParents.reduce((box, el) => {
+			const scrollBox = getElementBox(el);
+			if (box) return new Box({
+				x: Math.max(box.left, scrollBox.left),
+				y: Math.max(box.top, scrollBox.top),
+				width: Math.min(box.right, scrollBox.right) - Math.max(box.left, scrollBox.left),
+				height: Math.min(box.bottom, scrollBox.bottom) - Math.max(box.top, scrollBox.top)
+			});
+			return scrollBox;
+		}, void 0);
+		if (props.stickToTarget) {
+			viewport.x += Math.min(viewportMargin, targetBox.x);
+			viewport.y += Math.min(viewportMargin, targetBox.y);
+			viewport.width = Math.max(viewport.width - viewportMargin * 2, targetBox.x + targetBox.width - viewportMargin);
+			viewport.height = Math.max(viewport.height - viewportMargin * 2, targetBox.y + targetBox.height - viewportMargin);
+		} else {
+			viewport.x += viewportMargin;
+			viewport.y += viewportMargin;
+			viewport.width -= viewportMargin * 2;
+			viewport.height -= viewportMargin * 2;
+		}
+		let placement = {
+			anchor: preferredAnchor.value,
+			origin: preferredOrigin.value
+		};
+		function checkOverflow(_placement) {
+			const box = new Box(contentBox);
+			let { x, y } = getOffset(anchorToPoint(_placement.anchor, targetBox), anchorToPoint(_placement.origin, box));
+			switch (_placement.anchor.side) {
+				case "top":
+					y -= offset.value[0];
+					break;
+				case "bottom":
+					y += offset.value[0];
+					break;
+				case "left":
+					x -= offset.value[0];
+					break;
+				case "right": x += offset.value[0];
+			}
+			switch (_placement.anchor.align) {
+				case "top":
+					y -= offset.value[1];
+					break;
+				case "bottom":
+					y += offset.value[1];
+					break;
+				case "left":
+					x -= offset.value[1];
+					break;
+				case "right": x += offset.value[1];
+			}
+			box.x += x;
+			box.y += y;
+			box.width = Math.min(box.width, maxWidth.value);
+			box.height = Math.min(box.height, maxHeight.value);
+			return {
+				overflows: getOverflow(box, viewport),
+				x,
+				y
+			};
+		}
+		let x = 0;
+		let y = 0;
+		const available = {
+			x: 0,
+			y: 0
+		};
+		const flipped = {
+			x: false,
+			y: false
+		};
+		let resets = -1;
+		while (true) {
+			if (resets++ > 10) {
+				consoleError("Infinite loop detected in connectedLocationStrategy");
+				break;
+			}
+			const { x: _x, y: _y, overflows } = checkOverflow(placement);
+			x += _x;
+			y += _y;
+			contentBox.x += _x;
+			contentBox.y += _y;
+			{
+				const axis = getAxis(placement.anchor);
+				const hasOverflowX = overflows.x.before || overflows.x.after;
+				const hasOverflowY = overflows.y.before || overflows.y.after;
+				let reset = false;
+				["x", "y"].forEach((key) => {
+					if (key === "x" && hasOverflowX && !flipped.x || key === "y" && hasOverflowY && !flipped.y) {
+						const newPlacement = {
+							anchor: { ...placement.anchor },
+							origin: { ...placement.origin }
+						};
+						const flip = key === "x" ? axis === "y" ? flipAlign : flipSide : axis === "y" ? flipSide : flipAlign;
+						newPlacement.anchor = flip(newPlacement.anchor);
+						newPlacement.origin = flip(newPlacement.origin);
+						const { overflows: newOverflows } = checkOverflow(newPlacement);
+						if (newOverflows[key].before <= overflows[key].before && newOverflows[key].after <= overflows[key].after || newOverflows[key].before + newOverflows[key].after < (overflows[key].before + overflows[key].after) / 2) {
+							placement = newPlacement;
+							reset = flipped[key] = true;
+						}
+					}
+				});
+				if (reset) continue;
+			}
+			if (overflows.x.before) {
+				x += overflows.x.before;
+				contentBox.x += overflows.x.before;
+			}
+			if (overflows.x.after) {
+				x -= overflows.x.after;
+				contentBox.x -= overflows.x.after;
+			}
+			if (overflows.y.before) {
+				y += overflows.y.before;
+				contentBox.y += overflows.y.before;
+			}
+			if (overflows.y.after) {
+				y -= overflows.y.after;
+				contentBox.y -= overflows.y.after;
+			}
+			{
+				const overflows = getOverflow(contentBox, viewport);
+				available.x = viewport.width - overflows.x.before - overflows.x.after;
+				available.y = viewport.height - overflows.y.before - overflows.y.after;
+				x += overflows.x.before;
+				contentBox.x += overflows.x.before;
+				y += overflows.y.before;
+				contentBox.y += overflows.y.before;
+			}
+			break;
+		}
+		const axis = getAxis(placement.anchor);
+		Object.assign(contentStyles.value, {
+			"--v-overlay-anchor-origin": `${placement.anchor.side} ${placement.anchor.align}`,
+			transformOrigin: `${placement.origin.side} ${placement.origin.align}`,
+			top: convertToUnit(pixelRound(y)),
+			left: data.isRtl.value ? void 0 : convertToUnit(pixelRound(x)),
+			right: data.isRtl.value ? convertToUnit(pixelRound(-x)) : void 0,
+			minWidth: convertToUnit(axis === "y" ? Math.min(minWidth.value, targetBox.width) : minWidth.value),
+			maxWidth: convertToUnit(pixelCeil(clamp(available.x, minWidth.value === Infinity ? 0 : minWidth.value, maxWidth.value))),
+			maxHeight: convertToUnit(pixelCeil(clamp(available.y, minHeight.value === Infinity ? 0 : minHeight.value, maxHeight.value)))
+		});
+		return {
+			available,
+			contentBox,
+			flipped
+		};
+	}
+	watch(() => [
+		preferredAnchor.value,
+		preferredOrigin.value,
+		props.offset,
+		props.minWidth,
+		props.minHeight,
+		props.maxWidth,
+		props.maxHeight
+	], () => updateLocation());
+	nextTick(() => {
+		const result = updateLocation();
+		if (!result) return;
+		const { available, contentBox } = result;
+		if (contentBox.height > available.y) requestAnimationFrame(() => {
+			updateLocation();
+			requestAnimationFrame(() => {
+				updateLocation();
+			});
+		});
+	});
+	return { updateLocation };
+}
+function pixelRound(val) {
+	return Math.round(val * devicePixelRatio) / devicePixelRatio;
+}
+function pixelCeil(val) {
+	return Math.ceil(val * devicePixelRatio) / devicePixelRatio;
+}
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/components/VOverlay/requestNewFrame.js
+var clean = true;
+var frames = [];
+/**
+* Schedule a task to run in an animation frame on its own
+* This is useful for heavy tasks that may cause jank if all ran together
+*/
+function requestNewFrame(cb) {
+	if (!clean || frames.length) {
+		frames.push(cb);
+		run();
+	} else {
+		clean = false;
+		cb();
+		run();
+	}
+}
+var raf = -1;
+function run() {
+	cancelAnimationFrame(raf);
+	raf = requestAnimationFrame(() => {
+		const frame = frames.shift();
+		if (frame) frame();
+		if (frames.length) run();
+		else clean = true;
+	});
+}
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/components/VOverlay/scrollStrategies.js
+var scrollStrategies = {
+	none: null,
+	close: closeScrollStrategy,
+	block: blockScrollStrategy,
+	reposition: repositionScrollStrategy
+};
+var makeScrollStrategyProps = propsFactory({ scrollStrategy: {
+	type: [String, Function],
+	default: "block",
+	validator: (val) => typeof val === "function" || val in scrollStrategies
+} }, "VOverlay-scroll-strategies");
+function useScrollStrategies(props, data) {
+	if (!IN_BROWSER) return;
+	let scope;
+	watchEffect(async () => {
+		scope?.stop();
+		if (!(data.isActive.value && props.scrollStrategy)) return;
+		scope = effectScope();
+		await new Promise((resolve) => setTimeout(resolve));
+		scope.active && scope.run(() => {
+			if (typeof props.scrollStrategy === "function") props.scrollStrategy(data, props, scope);
+			else scrollStrategies[props.scrollStrategy]?.(data, props, scope);
+		});
+	});
+	onScopeDispose(() => {
+		scope?.stop();
+	});
+}
+function closeScrollStrategy(data) {
+	function onScroll(e) {
+		data.isActive.value = false;
+	}
+	bindScroll(getTargetEl(data.target.value, data.contentEl.value), onScroll);
+}
+function blockScrollStrategy(data, props) {
+	const offsetParent = data.root.value?.offsetParent;
+	const target = getTargetEl(data.target.value, data.contentEl.value);
+	const scrollElements = [.../* @__PURE__ */ new Set([...getScrollParents(target, props.contained ? offsetParent : void 0), ...getScrollParents(data.contentEl.value, props.contained ? offsetParent : void 0)])].filter((el) => !el.classList.contains("v-overlay-scroll-blocked"));
+	const scrollbarWidth = window.innerWidth - document.documentElement.offsetWidth;
+	const scrollableParent = ((el) => hasScrollbar(el) && el)(offsetParent || document.documentElement);
+	if (scrollableParent) data.root.value.classList.add("v-overlay--scroll-blocked");
+	scrollElements.forEach((el, i) => {
+		el.style.setProperty("--v-body-scroll-x", convertToUnit(-el.scrollLeft));
+		el.style.setProperty("--v-body-scroll-y", convertToUnit(-el.scrollTop));
+		if (el !== document.documentElement || getComputedStyle(el).overflowY !== "scroll") el.style.setProperty("--v-scrollbar-offset", convertToUnit(scrollbarWidth));
+		el.classList.add("v-overlay-scroll-blocked");
+	});
+	onScopeDispose(() => {
+		scrollElements.forEach((el, i) => {
+			const x = parseFloat(el.style.getPropertyValue("--v-body-scroll-x"));
+			const y = parseFloat(el.style.getPropertyValue("--v-body-scroll-y"));
+			const scrollBehavior = el.style.scrollBehavior;
+			el.style.scrollBehavior = "auto";
+			el.style.removeProperty("--v-body-scroll-x");
+			el.style.removeProperty("--v-body-scroll-y");
+			el.style.removeProperty("--v-scrollbar-offset");
+			el.classList.remove("v-overlay-scroll-blocked");
+			el.scrollLeft = -x;
+			el.scrollTop = -y;
+			el.style.scrollBehavior = scrollBehavior;
+		});
+		if (scrollableParent) data.root.value.classList.remove("v-overlay--scroll-blocked");
+	});
+}
+function repositionScrollStrategy(data, props, scope) {
+	let slow = false;
+	let raf = -1;
+	let ric = -1;
+	function update(e) {
+		requestNewFrame(() => {
+			const start = performance.now();
+			data.updateLocation.value?.(e);
+			slow = (performance.now() - start) / (1e3 / 60) > 2;
+		});
+	}
+	ric = (typeof requestIdleCallback === "undefined" ? (cb) => cb() : requestIdleCallback)(() => {
+		scope.run(() => {
+			bindScroll(getTargetEl(data.target.value, data.contentEl.value), (e) => {
+				if (slow) {
+					cancelAnimationFrame(raf);
+					raf = requestAnimationFrame(() => {
+						raf = requestAnimationFrame(() => {
+							update(e);
+						});
+					});
+				} else update(e);
+			});
+		});
+	});
+	onScopeDispose(() => {
+		typeof cancelIdleCallback !== "undefined" && cancelIdleCallback(ric);
+		cancelAnimationFrame(raf);
+	});
+}
+function getTargetEl(target, contentEl) {
+	return Array.isArray(target) ? document.elementsFromPoint(...target).find((el) => !contentEl?.contains(el)) : target ?? contentEl;
+}
+function bindScroll(el, onScroll) {
+	const scrollElements = [document, ...getScrollParents(el)];
+	scrollElements.forEach((el) => {
+		el.addEventListener("scroll", onScroll, { passive: true });
+	});
+	onScopeDispose(() => {
+		scrollElements.forEach((el) => {
+			el.removeEventListener("scroll", onScroll);
+		});
+	});
+}
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/components/VMenu/shared.js
+var VMenuSymbol = Symbol.for("vuetify:v-menu");
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/composables/delay.js
+var makeDelayProps = propsFactory({
+	closeDelay: [Number, String],
+	openDelay: [Number, String]
+}, "delay");
+function useDelay(props, cb) {
+	let clearDelay = () => {};
+	function runDelay(isOpening, options) {
+		clearDelay?.();
+		const delay = isOpening ? props.openDelay : props.closeDelay;
+		const normalizedDelay = Math.max(options?.minDelay ?? 0, Number(delay ?? 0));
+		return new Promise((resolve) => {
+			clearDelay = defer(normalizedDelay, () => {
+				cb?.(isOpening);
+				resolve(isOpening);
+			});
+		});
+	}
+	function runOpenDelay() {
+		return runDelay(true);
+	}
+	function runCloseDelay(options) {
+		return runDelay(false, options);
+	}
+	return {
+		clearDelay,
+		runOpenDelay,
+		runCloseDelay
+	};
+}
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/components/VOverlay/useActivator.js
+var makeActivatorProps = propsFactory({
+	target: [String, Object],
+	activator: [String, Object],
+	activatorProps: {
+		type: Object,
+		default: () => ({})
+	},
+	openOnClick: {
+		type: Boolean,
+		default: void 0
+	},
+	openOnHover: Boolean,
+	openOnFocus: {
+		type: Boolean,
+		default: void 0
+	},
+	closeOnContentClick: Boolean,
+	...makeDelayProps()
+}, "VOverlay-activator");
+function useActivator(props, { isActive, isTop, contentEl }) {
+	const vm = getCurrentInstance("useActivator");
+	const activatorEl = ref();
+	let isHovered = false;
+	let isFocused = false;
+	let firstEnter = true;
+	const openOnFocus = computed(() => props.openOnFocus || props.openOnFocus == null && props.openOnHover);
+	const openOnClick = computed(() => props.openOnClick || props.openOnClick == null && !props.openOnHover && !openOnFocus.value);
+	const { runOpenDelay, runCloseDelay } = useDelay(props, (value) => {
+		if (value === (props.openOnHover && isHovered || openOnFocus.value && isFocused) && !(props.openOnHover && isActive.value && !isTop.value)) {
+			if (isActive.value !== value) firstEnter = true;
+			isActive.value = value;
+		}
+	});
+	const cursorTarget = ref();
+	const availableEvents = {
+		onClick: (e) => {
+			e.stopPropagation();
+			activatorEl.value = e.currentTarget || e.target;
+			if (!isActive.value) cursorTarget.value = [e.clientX, e.clientY];
+			isActive.value = !isActive.value;
+		},
+		onMouseenter: (e) => {
+			isHovered = true;
+			activatorEl.value = e.currentTarget || e.target;
+			runOpenDelay();
+		},
+		onMouseleave: (e) => {
+			isHovered = false;
+			runCloseDelay();
+		},
+		onFocus: (e) => {
+			if (matchesSelector(e.target, ":focus-visible") === false) return;
+			isFocused = true;
+			e.stopPropagation();
+			activatorEl.value = e.currentTarget || e.target;
+			runOpenDelay();
+		},
+		onBlur: (e) => {
+			isFocused = false;
+			e.stopPropagation();
+			runCloseDelay({ minDelay: 1 });
+		}
+	};
+	const activatorEvents = computed(() => {
+		const events = {};
+		if (openOnClick.value) events.onClick = availableEvents.onClick;
+		if (props.openOnHover) {
+			events.onMouseenter = availableEvents.onMouseenter;
+			events.onMouseleave = availableEvents.onMouseleave;
+		}
+		if (openOnFocus.value) {
+			events.onFocus = availableEvents.onFocus;
+			events.onBlur = availableEvents.onBlur;
+		}
+		return events;
+	});
+	const contentEvents = computed(() => {
+		const events = {};
+		if (props.openOnHover) {
+			events.onMouseenter = () => {
+				isHovered = true;
+				runOpenDelay();
+			};
+			events.onMouseleave = () => {
+				isHovered = false;
+				runCloseDelay();
+			};
+		}
+		if (openOnFocus.value) {
+			events.onFocusin = (e) => {
+				if (!e.target.matches(":focus-visible")) return;
+				isFocused = true;
+				runOpenDelay();
+			};
+			events.onFocusout = () => {
+				isFocused = false;
+				runCloseDelay({ minDelay: 1 });
+			};
+		}
+		if (props.closeOnContentClick) {
+			const menu = inject(VMenuSymbol, null);
+			events.onClick = () => {
+				isActive.value = false;
+				menu?.closeParents();
+			};
+		}
+		return events;
+	});
+	const scrimEvents = computed(() => {
+		const events = {};
+		if (props.openOnHover) {
+			events.onMouseenter = () => {
+				if (firstEnter) {
+					isHovered = true;
+					firstEnter = false;
+					runOpenDelay();
+				}
+			};
+			events.onMouseleave = () => {
+				isHovered = false;
+				runCloseDelay();
+			};
+		}
+		return events;
+	});
+	watch(isTop, (val) => {
+		if (val && (props.openOnHover && !isHovered && (!openOnFocus.value || !isFocused) || openOnFocus.value && !isFocused && (!props.openOnHover || !isHovered)) && !contentEl.value?.contains(document.activeElement)) isActive.value = false;
+	});
+	watch(isActive, (val) => {
+		if (!val) setTimeout(() => {
+			cursorTarget.value = void 0;
+		});
+	}, { flush: "post" });
+	const activatorRef = templateRef();
+	watchEffect(() => {
+		if (!activatorRef.value) return;
+		nextTick(() => {
+			activatorEl.value = activatorRef.el;
+		});
+	});
+	const targetRef = templateRef();
+	const target = computed(() => {
+		if (props.target === "cursor" && cursorTarget.value) return cursorTarget.value;
+		if (targetRef.value) return targetRef.el;
+		return getTarget(props.target, vm) || activatorEl.value;
+	});
+	const targetEl = computed(() => {
+		return Array.isArray(target.value) ? void 0 : target.value;
+	});
+	let scope;
+	watch(() => !!props.activator, (val) => {
+		if (val && IN_BROWSER) {
+			scope = effectScope();
+			scope.run(() => {
+				_useActivator(props, vm, {
+					activatorEl,
+					activatorEvents
+				});
+			});
+		} else if (scope) scope.stop();
+	}, {
+		flush: "post",
+		immediate: true
+	});
+	onScopeDispose(() => {
+		scope?.stop();
+	});
+	return {
+		activatorEl,
+		activatorRef,
+		target,
+		targetEl,
+		targetRef,
+		activatorEvents,
+		contentEvents,
+		scrimEvents
+	};
+}
+function _useActivator(props, vm, { activatorEl, activatorEvents }) {
+	watch(() => props.activator, (val, oldVal) => {
+		if (oldVal && val !== oldVal) {
+			const activator = getActivator(oldVal);
+			activator && unbindActivatorProps(activator);
+		}
+		if (val) nextTick(() => bindActivatorProps());
+	}, { immediate: true });
+	watch(() => props.activatorProps, () => {
+		bindActivatorProps();
+	});
+	onScopeDispose(() => {
+		unbindActivatorProps();
+	});
+	function bindActivatorProps(el = getActivator(), _props = props.activatorProps) {
+		if (!el) return;
+		bindProps(el, mergeProps(activatorEvents.value, _props));
+	}
+	function unbindActivatorProps(el = getActivator(), _props = props.activatorProps) {
+		if (!el) return;
+		unbindProps(el, mergeProps(activatorEvents.value, _props));
+	}
+	function getActivator(selector = props.activator) {
+		const activator = getTarget(selector, vm);
+		activatorEl.value = activator?.nodeType === Node.ELEMENT_NODE ? activator : void 0;
+		return activatorEl.value;
+	}
+}
+function getTarget(selector, vm) {
+	if (!selector) return;
+	let target;
+	if (selector === "parent") {
+		let el = vm?.proxy?.$el?.parentNode;
+		while (el?.hasAttribute("data-no-activator")) el = el.parentNode;
+		target = el;
+	} else if (typeof selector === "string") target = document.querySelector(selector);
+	else if ("$el" in selector) target = selector.$el;
+	else target = selector;
+	return target;
+}
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/composables/focusTrap.js
+var makeFocusTrapProps = propsFactory({
+	retainFocus: Boolean,
+	captureFocus: Boolean,
+	/** @deprecated */
+	disableInitialFocus: Boolean
+}, "focusTrap");
+var registry = /* @__PURE__ */ new Map();
+var subscribers = 0;
+function onKeydown(e) {
+	const activeElement = document.activeElement;
+	if (e.key !== "Tab" || !activeElement) return;
+	const parentTraps = Array.from(registry.values()).filter(({ isActive, contentEl }) => isActive.value && contentEl.value?.contains(activeElement)).map((x) => x.contentEl.value);
+	let closestTrap;
+	let currentParent = activeElement.parentElement;
+	while (currentParent) {
+		if (parentTraps.includes(currentParent)) {
+			closestTrap = currentParent;
+			break;
+		}
+		currentParent = currentParent.parentElement;
+	}
+	if (!closestTrap) return;
+	const focusable = focusableChildren(closestTrap).filter((x) => x.tabIndex >= 0);
+	if (!focusable.length) return;
+	const active = document.activeElement;
+	if (focusable.length === 1 && focusable[0].classList.contains("v-list") && focusable[0].contains(active)) {
+		e.preventDefault();
+		return;
+	}
+	const firstElement = focusable[0];
+	const lastElement = focusable[focusable.length - 1];
+	if (e.shiftKey && (active === firstElement || firstElement.classList.contains("v-list") && firstElement.contains(active))) {
+		e.preventDefault();
+		lastElement.focus();
+	}
+	if (!e.shiftKey && (active === lastElement || lastElement.classList.contains("v-list") && lastElement.contains(active))) {
+		e.preventDefault();
+		firstElement.focus();
+	}
+}
+function useFocusTrap(props, { isActive, localTop, activatorEl, contentEl }) {
+	const trapId = Symbol("trap");
+	let focusTrapSuppressed = false;
+	let focusTrapSuppressionTimeout = -1;
+	async function onPointerdown() {
+		focusTrapSuppressed = true;
+		focusTrapSuppressionTimeout = window.setTimeout(() => {
+			focusTrapSuppressed = false;
+		}, 100);
+	}
+	async function captureOnFocus(e) {
+		const before = e.relatedTarget;
+		const after = e.target;
+		document.removeEventListener("pointerdown", onPointerdown);
+		document.removeEventListener("keydown", captureOnKeydown);
+		await nextTick();
+		if (isActive.value && !focusTrapSuppressed && before !== after && contentEl.value && toValue(localTop) && ![document, contentEl.value].includes(after) && !contentEl.value.contains(after)) focusableChildren(contentEl.value)[0]?.focus();
+	}
+	function captureOnKeydown(e) {
+		if (e.key !== "Tab") return;
+		document.removeEventListener("keydown", captureOnKeydown);
+		if (isActive.value && contentEl.value && e.target && !contentEl.value.contains(e.target)) {
+			const allFocusableElements = focusableChildren(document.documentElement);
+			if (e.shiftKey && e.target === allFocusableElements.at(0) || !e.shiftKey && e.target === allFocusableElements.at(-1)) {
+				const focusable = focusableChildren(contentEl.value);
+				if (focusable.length > 0) {
+					e.preventDefault();
+					focusable[0].focus();
+				}
+			}
+		}
+	}
+	const shouldCapture = toRef(() => isActive.value && props.captureFocus && !props.disableInitialFocus);
+	if (IN_BROWSER) {
+		watch(() => props.retainFocus, (val) => {
+			if (val) registry.set(trapId, {
+				isActive,
+				contentEl
+			});
+			else registry.delete(trapId);
+		}, { immediate: true });
+		watch(shouldCapture, (val) => {
+			if (val) {
+				document.addEventListener("pointerdown", onPointerdown);
+				document.addEventListener("focusin", captureOnFocus, { once: true });
+				document.addEventListener("keydown", captureOnKeydown);
+			} else {
+				document.removeEventListener("pointerdown", onPointerdown);
+				document.removeEventListener("focusin", captureOnFocus);
+				document.removeEventListener("keydown", captureOnKeydown);
+			}
+		}, { immediate: true });
+		if (subscribers++ < 1) document.addEventListener("keydown", onKeydown);
+	}
+	onScopeDispose(() => {
+		registry.delete(trapId);
+		clearTimeout(focusTrapSuppressionTimeout);
+		document.removeEventListener("pointerdown", onPointerdown);
+		document.removeEventListener("focusin", captureOnFocus);
+		document.removeEventListener("keydown", captureOnKeydown);
+		if (--subscribers < 1) document.removeEventListener("keydown", onKeydown);
+	});
+}
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/composables/hydration.js
+function useHydration() {
+	if (!IN_BROWSER) return shallowRef(false);
+	const { ssr } = useDisplay();
+	if (ssr) {
+		const isMounted = shallowRef(false);
+		onMounted(() => {
+			isMounted.value = true;
+		});
+		return isMounted;
+	} else return shallowRef(true);
+}
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/composables/lazy.js
+var makeLazyProps = propsFactory({ eager: Boolean }, "lazy");
+function useLazy(props, active) {
+	const isBooted = shallowRef(false);
+	const hasContent = toRef(() => isBooted.value || props.eager || active.value);
+	watch(active, () => isBooted.value = true);
+	function onAfterLeave() {
+		if (!props.eager) isBooted.value = false;
+	}
+	return {
+		isBooted,
+		hasContent,
+		onAfterLeave
+	};
+}
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/composables/scopeId.js
+function useScopeId() {
+	const scopeId = getCurrentInstance("useScopeId").vnode.scopeId;
+	return { scopeId: scopeId ? { [scopeId]: "" } : void 0 };
+}
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/composables/stack.js
+var StackSymbol = Symbol.for("vuetify:stack");
+var globalStack = reactive([]);
+function useStack(isActive, zIndex, disableGlobalStack) {
+	const vm = getCurrentInstance("useStack");
+	const createStackEntry = !disableGlobalStack;
+	const parent = inject(StackSymbol, void 0);
+	const stack = reactive({ activeChildren: /* @__PURE__ */ new Set() });
+	provide(StackSymbol, stack);
+	const _zIndex = shallowRef(Number(toValue(zIndex)));
+	useToggleScope(isActive, () => {
+		const lastZIndex = globalStack.at(-1)?.[1];
+		_zIndex.value = lastZIndex ? lastZIndex + 10 : Number(toValue(zIndex));
+		if (createStackEntry) globalStack.push([vm.uid, _zIndex.value]);
+		parent?.activeChildren.add(vm.uid);
+		onScopeDispose(() => {
+			if (createStackEntry) {
+				const idx = toRaw(globalStack).findIndex((v) => v[0] === vm.uid);
+				globalStack.splice(idx, 1);
+			}
+			parent?.activeChildren.delete(vm.uid);
+		});
+	});
+	const globalTop = shallowRef(true);
+	if (createStackEntry) watchEffect(() => {
+		const _isTop = globalStack.at(-1)?.[0] === vm.uid;
+		setTimeout(() => globalTop.value = _isTop);
+	});
+	const localTop = toRef(() => !stack.activeChildren.size);
+	return {
+		globalTop: readonly(globalTop),
+		localTop,
+		stackStyles: toRef(() => ({ zIndex: _zIndex.value }))
+	};
+}
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/composables/teleport.js
+function useTeleport(target) {
+	return { teleportTarget: computed(() => {
+		const _target = target();
+		if (_target === true || !IN_BROWSER) return void 0;
+		const targetElement = _target === false ? document.body : typeof _target === "string" ? document.querySelector(_target) : _target;
+		if (targetElement == null) {
+			warn(`Unable to locate target ${_target}`);
+			return;
+		}
+		let container = [...targetElement.children].find((el) => el.matches(".v-overlay-container"));
+		if (!container) {
+			container = document.createElement("div");
+			container.className = "v-overlay-container";
+			targetElement.appendChild(container);
+		}
+		return container;
+	}) };
+}
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/directives/click-outside/index.js
+function defaultConditional() {
+	return true;
+}
+function checkEvent(e, el, binding) {
+	if (!e || checkIsActive(e, binding) === false) return false;
+	const root = attachedRoot(el);
+	if (typeof ShadowRoot !== "undefined" && root instanceof ShadowRoot && root.host === e.target) return false;
+	const elements = (typeof binding.value === "object" && binding.value.include || (() => []))();
+	elements.push(el);
+	return !elements.some((el) => el?.contains(e.target));
+}
+function checkIsActive(e, binding) {
+	return (typeof binding.value === "object" && binding.value.closeConditional || defaultConditional)(e);
+}
+function directive(e, el, binding) {
+	const handler = typeof binding.value === "function" ? binding.value : binding.value.handler;
+	e.shadowTarget = e.target;
+	el._clickOutside.lastMousedownWasOutside && checkEvent(e, el, binding) && setTimeout(() => {
+		checkIsActive(e, binding) && handler && handler(e);
+	}, 0);
+}
+function handleShadow(el, callback) {
+	const root = attachedRoot(el);
+	callback(document);
+	if (typeof ShadowRoot !== "undefined" && root instanceof ShadowRoot) callback(root);
+}
+var ClickOutside = {
+	mounted(el, binding) {
+		const onClick = (e) => directive(e, el, binding);
+		const onMousedown = (e) => {
+			el._clickOutside.lastMousedownWasOutside = checkEvent(e, el, binding);
+		};
+		handleShadow(el, (app) => {
+			app.addEventListener("click", onClick, true);
+			app.addEventListener("mousedown", onMousedown, true);
+		});
+		if (!el._clickOutside) el._clickOutside = { lastMousedownWasOutside: false };
+		el._clickOutside[binding.instance.$.uid] = {
+			onClick,
+			onMousedown
+		};
+	},
+	beforeUnmount(el, binding) {
+		if (!el._clickOutside) return;
+		handleShadow(el, (app) => {
+			if (!app || !el._clickOutside?.[binding.instance.$.uid]) return;
+			const { onClick, onMousedown } = el._clickOutside[binding.instance.$.uid];
+			app.removeEventListener("click", onClick, true);
+			app.removeEventListener("mousedown", onMousedown, true);
+		});
+		delete el._clickOutside[binding.instance.$.uid];
+	}
+};
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/components/VOverlay/VOverlay.js
+function Scrim(props) {
+	const { modelValue, color, ...rest } = props;
+	return createVNode(Transition, {
+		"name": "fade-transition",
+		"appear": true
+	}, { default: () => [props.modelValue && createBaseVNode("div", mergeProps({
+		"class": ["v-overlay__scrim", props.color.backgroundColorClasses.value],
+		"style": props.color.backgroundColorStyles.value
+	}, rest), null)] });
+}
+var makeVOverlayProps = propsFactory({
+	absolute: Boolean,
+	attach: [
+		Boolean,
+		String,
+		Object
+	],
+	closeOnBack: {
+		type: Boolean,
+		default: true
+	},
+	contained: Boolean,
+	contentClass: null,
+	contentProps: null,
+	disabled: Boolean,
+	opacity: [Number, String],
+	noClickAnimation: Boolean,
+	modelValue: Boolean,
+	persistent: Boolean,
+	scrim: {
+		type: [Boolean, String],
+		default: true
+	},
+	zIndex: {
+		type: [Number, String],
+		default: 2e3
+	},
+	...makeActivatorProps(),
+	...makeComponentProps(),
+	...makeDimensionProps(),
+	...makeLazyProps(),
+	...makeLocationStrategyProps(),
+	...makeScrollStrategyProps(),
+	...makeFocusTrapProps(),
+	...makeThemeProps(),
+	...makeTransitionProps()
+}, "VOverlay");
+var VOverlay = genericComponent()({
+	name: "VOverlay",
+	directives: { vClickOutside: ClickOutside },
+	inheritAttrs: false,
+	props: {
+		_disableGlobalStack: Boolean,
+		...omit(makeVOverlayProps(), ["disableInitialFocus"])
+	},
+	emits: {
+		"click:outside": (e) => true,
+		"update:modelValue": (value) => true,
+		keydown: (e) => true,
+		afterEnter: () => true,
+		afterLeave: () => true
+	},
+	setup(props, { slots, attrs, emit }) {
+		const vm = getCurrentInstance("VOverlay");
+		const root = ref();
+		const scrimEl = ref();
+		const contentEl = ref();
+		const model = useProxiedModel(props, "modelValue");
+		const isActive = computed({
+			get: () => model.value,
+			set: (v) => {
+				if (!(v && props.disabled)) model.value = v;
+			}
+		});
+		const { themeClasses } = provideTheme(props);
+		const { rtlClasses, isRtl } = useRtl();
+		const { hasContent, onAfterLeave: _onAfterLeave } = useLazy(props, isActive);
+		const scrimColor = useBackgroundColor(() => {
+			return typeof props.scrim === "string" ? props.scrim : null;
+		});
+		const { globalTop, localTop, stackStyles } = useStack(isActive, () => props.zIndex, props._disableGlobalStack);
+		const { activatorEl, activatorRef, target, targetEl, targetRef, activatorEvents, contentEvents, scrimEvents } = useActivator(props, {
+			isActive,
+			isTop: localTop,
+			contentEl
+		});
+		const { teleportTarget } = useTeleport(() => {
+			const target = props.attach || props.contained;
+			if (target) return target;
+			const rootNode = activatorEl?.value?.getRootNode() || vm.proxy?.$el?.getRootNode();
+			if (rootNode instanceof ShadowRoot) return rootNode;
+			return false;
+		});
+		const { dimensionStyles } = useDimension(props);
+		const isMounted = useHydration();
+		const { scopeId } = useScopeId();
+		watch(() => props.disabled, (v) => {
+			if (v) isActive.value = false;
+		});
+		const { contentStyles, updateLocation } = useLocationStrategies(props, {
+			isRtl,
+			contentEl,
+			target,
+			isActive
+		});
+		useScrollStrategies(props, {
+			root,
+			contentEl,
+			targetEl,
+			target,
+			isActive,
+			updateLocation
+		});
+		function onClickOutside(e) {
+			emit("click:outside", e);
+			if (!props.persistent) isActive.value = false;
+			else animateClick();
+		}
+		function closeConditional(e) {
+			return isActive.value && localTop.value && (!props.scrim || e.target === scrimEl.value || e instanceof MouseEvent && e.shadowTarget === scrimEl.value);
+		}
+		useFocusTrap(props, {
+			isActive,
+			localTop,
+			contentEl,
+			activatorEl
+		});
+		IN_BROWSER && watch(isActive, (val) => {
+			if (val) window.addEventListener("keydown", onKeydown);
+			else window.removeEventListener("keydown", onKeydown);
+		}, { immediate: true });
+		onBeforeUnmount(() => {
+			if (!IN_BROWSER) return;
+			window.removeEventListener("keydown", onKeydown);
+		});
+		function onKeydown(e) {
+			if (e.key === "Escape" && globalTop.value) {
+				if (!contentEl.value?.contains(document.activeElement)) emit("keydown", e);
+				if (!props.persistent) {
+					isActive.value = false;
+					if (contentEl.value?.contains(document.activeElement)) activatorEl.value?.focus();
+				} else animateClick();
+			}
+		}
+		function onKeydownSelf(e) {
+			if (e.key === "Escape" && !globalTop.value) return;
+			emit("keydown", e);
+		}
+		const router = useRouter();
+		useToggleScope(() => props.closeOnBack, () => {
+			useBackButton(router, (next) => {
+				if (globalTop.value && isActive.value) {
+					next(false);
+					if (!props.persistent) isActive.value = false;
+					else animateClick();
+				} else next();
+			});
+		});
+		const top = ref();
+		watch(() => isActive.value && (props.absolute || props.contained) && teleportTarget.value == null, (val) => {
+			if (val) {
+				const scrollParent = getScrollParent(root.value);
+				if (scrollParent && scrollParent !== document.scrollingElement) top.value = scrollParent.scrollTop;
+			}
+		});
+		function animateClick() {
+			if (props.noClickAnimation) return;
+			contentEl.value && animate(contentEl.value, [
+				{ transformOrigin: "center" },
+				{ transform: "scale(1.03)" },
+				{ transformOrigin: "center" }
+			], {
+				duration: 150,
+				easing: "cubic-bezier(0.4, 0, 0.2, 1)"
+			});
+		}
+		function onAfterEnter() {
+			emit("afterEnter");
+		}
+		function onAfterLeave() {
+			_onAfterLeave();
+			emit("afterLeave");
+		}
+		useRender(() => createBaseVNode(Fragment, null, [slots.activator?.({
+			isActive: isActive.value,
+			targetRef,
+			props: mergeProps({ ref: activatorRef }, activatorEvents.value, props.activatorProps)
+		}), isMounted.value && hasContent.value && createVNode(Teleport, {
+			"disabled": !teleportTarget.value,
+			"to": teleportTarget.value
+		}, { default: () => [createBaseVNode("div", mergeProps({
+			"class": [
+				"v-overlay",
+				{
+					"v-overlay--absolute": props.absolute || props.contained,
+					"v-overlay--active": isActive.value,
+					"v-overlay--contained": props.contained
+				},
+				themeClasses.value,
+				rtlClasses.value,
+				props.class
+			],
+			"style": [
+				stackStyles.value,
+				{
+					"--v-overlay-opacity": props.opacity,
+					top: convertToUnit(top.value)
+				},
+				props.style
+			],
+			"ref": root,
+			"onKeydown": onKeydownSelf
+		}, scopeId, attrs), [createVNode(Scrim, mergeProps({
+			"color": scrimColor,
+			"modelValue": isActive.value && !!props.scrim,
+			"ref": scrimEl
+		}, scrimEvents.value), null), createVNode(MaybeTransition, {
+			"appear": true,
+			"persisted": true,
+			"transition": props.transition,
+			"target": target.value,
+			"onAfterEnter": onAfterEnter,
+			"onAfterLeave": onAfterLeave
+		}, { default: () => [withDirectives(createBaseVNode("div", mergeProps({
+			"ref": contentEl,
+			"class": ["v-overlay__content", props.contentClass],
+			"style": [dimensionStyles.value, contentStyles.value]
+		}, contentEvents.value, props.contentProps), [slots.default?.({ isActive })]), [[vShow, isActive.value], [ClickOutside, {
+			handler: onClickOutside,
+			closeConditional,
+			include: () => [activatorEl.value]
+		}]])] })])] })]));
+		return {
+			activatorEl,
+			scrimEl,
+			target,
+			animateClick,
+			contentEl,
+			rootEl: root,
+			globalTop,
+			localTop,
+			updateLocation
+		};
+	}
+});
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/directives/resize/index.js
+function mounted$1(el, binding) {
+	const handler = binding.value;
+	const options = { passive: !binding.modifiers?.active };
+	window.addEventListener("resize", handler, options);
+	el._onResize = Object(el._onResize);
+	el._onResize[binding.instance.$.uid] = {
+		handler,
+		options
+	};
+	if (!binding.modifiers?.quiet) handler();
+}
+function unmounted$1(el, binding) {
+	if (!el._onResize?.[binding.instance.$.uid]) return;
+	const { handler, options } = el._onResize[binding.instance.$.uid];
+	window.removeEventListener("resize", handler, options);
+	delete el._onResize[binding.instance.$.uid];
+}
+var Resize = {
+	mounted: mounted$1,
+	unmounted: unmounted$1
+};
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/directives/touch/index.js
+var handleGesture = (wrapper) => {
+	const { touchstartX, touchendX, touchstartY, touchendY } = wrapper;
+	const dirRatio = .5;
+	const minDistance = 16;
+	wrapper.offsetX = touchendX - touchstartX;
+	wrapper.offsetY = touchendY - touchstartY;
+	if (Math.abs(wrapper.offsetY) < dirRatio * Math.abs(wrapper.offsetX)) {
+		wrapper.left && touchendX < touchstartX - minDistance && wrapper.left(wrapper);
+		wrapper.right && touchendX > touchstartX + minDistance && wrapper.right(wrapper);
+	}
+	if (Math.abs(wrapper.offsetX) < dirRatio * Math.abs(wrapper.offsetY)) {
+		wrapper.up && touchendY < touchstartY - minDistance && wrapper.up(wrapper);
+		wrapper.down && touchendY > touchstartY + minDistance && wrapper.down(wrapper);
+	}
+};
+function touchstart(event, wrapper) {
+	const touch = event.changedTouches[0];
+	wrapper.touchstartX = touch.clientX;
+	wrapper.touchstartY = touch.clientY;
+	wrapper.start?.({
+		originalEvent: event,
+		...wrapper
+	});
+}
+function touchend(event, wrapper) {
+	const touch = event.changedTouches[0];
+	wrapper.touchendX = touch.clientX;
+	wrapper.touchendY = touch.clientY;
+	wrapper.end?.({
+		originalEvent: event,
+		...wrapper
+	});
+	handleGesture(wrapper);
+}
+function touchmove(event, wrapper) {
+	const touch = event.changedTouches[0];
+	wrapper.touchmoveX = touch.clientX;
+	wrapper.touchmoveY = touch.clientY;
+	wrapper.move?.({
+		originalEvent: event,
+		...wrapper
+	});
+}
+function createHandlers(value = {}) {
+	const wrapper = {
+		touchstartX: 0,
+		touchstartY: 0,
+		touchendX: 0,
+		touchendY: 0,
+		touchmoveX: 0,
+		touchmoveY: 0,
+		offsetX: 0,
+		offsetY: 0,
+		left: value.left,
+		right: value.right,
+		up: value.up,
+		down: value.down,
+		start: value.start,
+		move: value.move,
+		end: value.end
+	};
+	return {
+		touchstart: (e) => touchstart(e, wrapper),
+		touchend: (e) => touchend(e, wrapper),
+		touchmove: (e) => touchmove(e, wrapper)
+	};
+}
+function mounted(el, binding) {
+	const value = binding.value;
+	const target = value?.parent ? el.parentElement : el;
+	const options = value?.options ?? { passive: true };
+	const uid = binding.instance?.$.uid;
+	if (!target || uid === void 0) return;
+	const handlers = createHandlers(binding.value);
+	target._touchHandlers = target._touchHandlers ?? Object.create(null);
+	target._touchHandlers[uid] = handlers;
+	keys(handlers).forEach((eventName) => {
+		target.addEventListener(eventName, handlers[eventName], options);
+	});
+}
+function unmounted(el, binding) {
+	const target = binding.value?.parent ? el.parentElement : el;
+	const uid = binding.instance?.$.uid;
+	if (!target?._touchHandlers || uid === void 0) return;
+	const handlers = target._touchHandlers[uid];
+	keys(handlers).forEach((eventName) => {
+		target.removeEventListener(eventName, handlers[eventName]);
+	});
+	delete target._touchHandlers[uid];
+}
+var Touch = {
+	mounted,
+	unmounted
+};
+//#endregion
+//#region ../../../../node_modules/vuetify/lib/components/VTooltip/VTooltip.js
+var makeVTooltipProps = propsFactory({
+	id: String,
+	interactive: Boolean,
+	text: String,
+	...omit(makeVOverlayProps({
+		closeOnBack: false,
+		location: "end",
+		locationStrategy: "connected",
+		eager: true,
+		minWidth: 0,
+		offset: 10,
+		openOnClick: false,
+		openOnHover: true,
+		origin: "auto",
+		scrim: false,
+		scrollStrategy: "reposition",
+		transition: null
+	}), [
+		"absolute",
+		"retainFocus",
+		"captureFocus",
+		"disableInitialFocus"
+	])
+}, "VTooltip");
+var VTooltip = genericComponent()({
+	name: "VTooltip",
+	props: makeVTooltipProps(),
+	emits: { "update:modelValue": (value) => true },
+	setup(props, { slots }) {
+		const isActive = useProxiedModel(props, "modelValue");
+		const { scopeId } = useScopeId();
+		const uid = useId();
+		const id = toRef(() => props.id || `v-tooltip-${uid}`);
+		const overlay = ref();
+		const location = computed(() => {
+			return props.location.split(" ").length > 1 ? props.location : props.location + " center";
+		});
+		const origin = computed(() => {
+			return props.origin === "auto" || props.origin === "overlap" || props.origin.split(" ").length > 1 || props.location.split(" ").length > 1 ? props.origin : props.origin + " center";
+		});
+		const transition = toRef(() => {
+			if (props.transition != null) return props.transition;
+			return isActive.value ? "scale-transition" : "fade-transition";
+		});
+		const activatorProps = computed(() => mergeProps({ "aria-describedby": id.value }, props.activatorProps));
+		useRender(() => {
+			const overlayProps = VOverlay.filterProps(props);
+			return createVNode(VOverlay, mergeProps({
+				"ref": overlay,
+				"class": [
+					"v-tooltip",
+					{ "v-tooltip--interactive": props.interactive },
+					props.class
+				],
+				"style": props.style,
+				"id": id.value
+			}, overlayProps, {
+				"modelValue": isActive.value,
+				"onUpdate:modelValue": ($event) => isActive.value = $event,
+				"transition": transition.value,
+				"absolute": true,
+				"location": location.value,
+				"origin": origin.value,
+				"role": "tooltip",
+				"activatorProps": activatorProps.value,
+				"_disableGlobalStack": true
+			}, scopeId), {
+				activator: slots.activator,
+				default: (...args) => slots.default?.(...args) ?? props.text
+			});
+		});
+		return forwardRefs({}, overlay);
+	}
+});
+//#endregion
+export { useRender as A, makeTransitionProps as C, useTextColor as D, useColor as E, nullifyTransforms as F, getTargetBox as I, parseAnchor as L, deepEqual as M, makeComponentProps as N, makeDimensionProps as O, animate as P, toPhysical as R, MaybeTransition as S, useBackgroundColor as T, Ripple as _, makeVOverlayProps as a, useRouter as b, makeLazyProps as c, makeFocusTrapProps as d, useFocusTrap as f, forwardRefs as g, VMenuSymbol as h, VOverlay as i, getScrollParent as j, useDimension as k, useLazy as l, useDelay as m, Touch as n, ClickOutside as o, makeDelayProps as p, Resize as r, useScopeId as s, VTooltip as t, useHydration as u, makeRouterProps as v, computeColor as w, Intersect as x, useLink as y };