import { Mn as effectScope, Ot as nextTick, Qn as toRef, U as computed, Vn as onScopeDispose, Wn as reactive, er as toValue, gn as watch, pt as h, xt as inject$1 } from "./vue.runtime.esm-bundler-C6sZGmPl.js";
import { A as easingPatterns, B as propsFactory, C as IconSymbol, Ct as PREFERS_REDUCED_MOTION, E as VSvgIcon, Et as consoleWarn, F as createDefaults, J as clamp, L as useDefaults, M as defineComponent, P as DefaultsSymbol, St as IN_BROWSER, T as VClassIcon, _ as LocaleSymbol, b as useRtl, c as createDisplay, ct as includes, d as DateAdapterSymbol, f as DateOptionsSymbol, g as useDate, mt as mergeDeep, n as ThemeSymbol, o as useTheme, p as createDate, r as createTheme, s as DisplaySymbol, u as useDisplay, ut as isObject, v as createLocale, y as useLocale, yt as refElement } from "./resizeObserver-DXFuuv3h.js";
//#region node_modules/vuetify/lib/iconsets/mdi.js
var aliases = {
	collapse: "mdi-chevron-up",
	complete: "mdi-check",
	cancel: "mdi-close-circle",
	close: "mdi-close",
	delete: "mdi-close-circle",
	clear: "mdi-close-circle",
	success: "mdi-check-circle",
	info: "mdi-information",
	warning: "mdi-alert-circle",
	error: "mdi-close-circle",
	prev: "mdi-chevron-left",
	next: "mdi-chevron-right",
	checkboxOn: "mdi-checkbox-marked",
	checkboxOff: "mdi-checkbox-blank-outline",
	checkboxIndeterminate: "mdi-minus-box",
	delimiter: "mdi-circle",
	sortAsc: "mdi-arrow-up",
	sortDesc: "mdi-arrow-down",
	expand: "mdi-chevron-down",
	menu: "mdi-menu",
	subgroup: "mdi-menu-down",
	dropdown: "mdi-menu-down",
	radioOn: "mdi-radiobox-marked",
	radioOff: "mdi-radiobox-blank",
	edit: "mdi-pencil",
	ratingEmpty: "mdi-star-outline",
	ratingFull: "mdi-star",
	ratingHalf: "mdi-star-half-full",
	loading: "mdi-cached",
	first: "mdi-page-first",
	last: "mdi-page-last",
	unfold: "mdi-unfold-more-horizontal",
	file: "mdi-paperclip",
	plus: "mdi-plus",
	minus: "mdi-minus",
	calendar: "mdi-calendar",
	treeviewCollapse: "mdi-menu-down",
	treeviewExpand: "mdi-menu-right",
	tableGroupCollapse: "mdi-chevron-down",
	tableGroupExpand: "mdi-chevron-right",
	eyeDropper: "mdi-eyedropper",
	upload: "mdi-cloud-upload",
	color: "mdi-palette",
	command: "mdi-apple-keyboard-command",
	ctrl: "mdi-apple-keyboard-control",
	space: "mdi-keyboard-space",
	shift: "mdi-apple-keyboard-shift",
	alt: "mdi-apple-keyboard-option",
	enter: "mdi-keyboard-return",
	arrowup: "mdi-arrow-up",
	arrowdown: "mdi-arrow-down",
	arrowleft: "mdi-arrow-left",
	arrowright: "mdi-arrow-right",
	backspace: "mdi-backspace",
	play: "mdi-play",
	pause: "mdi-pause",
	fullscreen: "mdi-fullscreen",
	fullscreenExit: "mdi-fullscreen-exit",
	volumeHigh: "mdi-volume-high",
	volumeMedium: "mdi-volume-medium",
	volumeLow: "mdi-volume-low",
	volumeOff: "mdi-volume-variant-off",
	search: "mdi-magnify"
};
var mdi = { component: (props) => h(VClassIcon, {
	...props,
	class: "mdi"
}) };
//#endregion
//#region node_modules/vuetify/lib/icons.js
function genDefaults$1() {
	return {
		svg: { component: VSvgIcon },
		class: { component: VClassIcon }
	};
}
function createIcons(options) {
	const sets = genDefaults$1();
	const defaultSet = options?.defaultSet ?? "mdi";
	if (defaultSet === "mdi" && !sets.mdi) sets.mdi = mdi;
	return mergeDeep({
		defaultSet,
		sets,
		aliases: {
			...aliases,
			vuetify: ["M8.2241 14.2009L12 21L22 3H14.4459L8.2241 14.2009Z", ["M7.26303 12.4733L7.00113 12L2 3H12.5261C12.5261 3 12.5261 3 12.5261 3L7.26303 12.4733Z", .6]],
			"vuetify-outline": "svg:M7.26 12.47 12.53 3H2L7.26 12.47ZM14.45 3 8.22 14.2 12 21 22 3H14.45ZM18.6 5 12 16.88 10.51 14.2 15.62 5ZM7.26 8.35 5.4 5H9.13L7.26 8.35Z",
			"vuetify-play": ["m6.376 13.184-4.11-7.192C1.505 4.66 2.467 3 4.003 3h8.532l-.953 1.576-.006.01-.396.677c-.429.732-.214 1.507.194 2.015.404.503 1.092.878 1.869.806a3.72 3.72 0 0 1 1.005.022c.276.053.434.143.523.237.138.146.38.635-.25 2.09-.893 1.63-1.553 1.722-1.847 1.677-.213-.033-.468-.158-.756-.406a4.95 4.95 0 0 1-.8-.927c-.39-.564-1.04-.84-1.66-.846-.625-.006-1.316.27-1.693.921l-.478.826-.911 1.506Z", ["M9.093 11.552c.046-.079.144-.15.32-.148a.53.53 0 0 1 .43.207c.285.414.636.847 1.046 1.2.405.35.914.662 1.516.754 1.334.205 2.502-.698 3.48-2.495l.014-.028.013-.03c.687-1.574.774-2.852-.005-3.675-.37-.391-.861-.586-1.333-.676a5.243 5.243 0 0 0-1.447-.044c-.173.016-.393-.073-.54-.257-.145-.18-.127-.316-.082-.392l.393-.672L14.287 3h5.71c1.536 0 2.499 1.659 1.737 2.992l-7.997 13.996c-.768 1.344-2.706 1.344-3.473 0l-3.037-5.314 1.377-2.278.004-.006.004-.007.481-.831Z", .6]]
		}
	}, options);
}
//#endregion
//#region node_modules/vuetify/lib/composables/goto.js
var GoToSymbol = Symbol.for("vuetify:goto");
function genDefaults() {
	return {
		container: void 0,
		duration: 300,
		layout: false,
		offset: 0,
		easing: "easeInOutCubic",
		patterns: easingPatterns
	};
}
function getContainer(el) {
	return getTarget(el) ?? (document.scrollingElement || document.body);
}
function getTarget(el) {
	return typeof el === "string" ? document.querySelector(el) : refElement(el);
}
function getOffset(target, horizontal, rtl) {
	if (typeof target === "number") return horizontal && rtl ? -target : target;
	let el = getTarget(target);
	let totalOffset = 0;
	while (el) {
		totalOffset += horizontal ? el.offsetLeft : el.offsetTop;
		el = el.offsetParent;
	}
	return totalOffset;
}
function createGoTo(options, locale) {
	return {
		rtl: locale.isRtl,
		options: mergeDeep(genDefaults(), options)
	};
}
async function scrollTo(_target, _options, horizontal, goTo) {
	const property = horizontal ? "scrollLeft" : "scrollTop";
	const options = mergeDeep(goTo?.options ?? genDefaults(), _options);
	const rtl = goTo?.rtl.value;
	const target = (typeof _target === "number" ? _target : getTarget(_target)) ?? 0;
	const container = options.container === "parent" && target instanceof HTMLElement ? target.parentElement : getContainer(options.container);
	const ease = PREFERS_REDUCED_MOTION() ? options.patterns.instant : typeof options.easing === "function" ? options.easing : options.patterns[options.easing];
	if (!ease) throw new TypeError(`Easing function "${options.easing}" not found.`);
	let targetLocation;
	if (typeof target === "number") targetLocation = getOffset(target, horizontal, rtl);
	else {
		targetLocation = getOffset(target, horizontal, rtl) - getOffset(container, horizontal, rtl);
		if (options.layout) {
			const layoutOffset = window.getComputedStyle(target).getPropertyValue("--v-layout-top");
			if (layoutOffset) targetLocation -= parseInt(layoutOffset, 10);
		}
	}
	targetLocation += options.offset;
	targetLocation = clampTarget(container, targetLocation, !!rtl, !!horizontal);
	const startLocation = container[property] ?? 0;
	if (targetLocation === startLocation) return Promise.resolve(targetLocation);
	const startTime = performance.now();
	return new Promise((resolve) => requestAnimationFrame(function step(currentTime) {
		const progress = (currentTime - startTime) / options.duration;
		const location = Math.floor(startLocation + (targetLocation - startLocation) * ease(clamp(progress, 0, 1)));
		container[property] = location;
		if (progress >= 1 && Math.abs(location - container[property]) < 10) return resolve(targetLocation);
		else if (progress > 2) {
			consoleWarn("Scroll target is not reachable");
			return resolve(container[property]);
		}
		requestAnimationFrame(step);
	}));
}
function useGoTo(_options = {}) {
	const goToInstance = inject$1(GoToSymbol);
	const { isRtl } = useRtl();
	if (!goToInstance) throw new Error("[Vuetify] Could not find injected goto instance");
	const goTo = {
		...goToInstance,
		rtl: toRef(() => goToInstance.rtl.value || isRtl.value)
	};
	async function go(target, options) {
		return scrollTo(target, mergeDeep(_options, options), false, goTo);
	}
	go.horizontal = async (target, options) => {
		return scrollTo(target, mergeDeep(_options, options), true, goTo);
	};
	return go;
}
/**
* Clamp target value to achieve a smooth scroll animation
* when the value goes outside the scroll container size
*/
function clampTarget(container, value, rtl, horizontal) {
	const { scrollWidth, scrollHeight } = container;
	const [containerWidth, containerHeight] = container === document.scrollingElement ? [window.innerWidth, window.innerHeight] : [container.offsetWidth, container.offsetHeight];
	let min;
	let max;
	if (horizontal) if (rtl) {
		min = -(scrollWidth - containerWidth);
		max = 0;
	} else {
		min = 0;
		max = scrollWidth - containerWidth;
	}
	else {
		min = 0;
		max = scrollHeight + -containerHeight;
	}
	return clamp(value, min, max);
}
//#endregion
//#region node_modules/vuetify/lib/composables/layout.js
var VuetifyLayoutKey = Symbol.for("vuetify:layout");
propsFactory({
	overlaps: {
		type: Array,
		default: () => []
	},
	fullHeight: Boolean
}, "layout");
propsFactory({
	name: { type: String },
	order: {
		type: [Number, String],
		default: 0
	},
	absolute: Boolean
}, "layout-item");
function useLayout() {
	const layout = inject$1(VuetifyLayoutKey);
	if (!layout) throw new Error("[Vuetify] Could not find injected layout");
	return {
		getLayoutItem: layout.getLayoutItem,
		mainRect: layout.mainRect,
		mainStyles: layout.mainStyles
	};
}
//#endregion
//#region node_modules/vuetify/lib/composables/hotkey/key-aliases.js
/**
* Centralized key alias mapping for consistent key normalization across the hotkey system.
*
* This maps various user-friendly aliases to canonical key names that match
* KeyboardEvent.key values (in lowercase) where possible.
*/
var keyAliasMap = {
	control: "ctrl",
	command: "cmd",
	option: "alt",
	up: "arrowup",
	down: "arrowdown",
	left: "arrowleft",
	right: "arrowright",
	esc: "escape",
	spacebar: " ",
	space: " ",
	return: "enter",
	del: "delete",
	plus: "+",
	slash: "/",
	underscore: "_",
	minus: "-",
	hyphen: "-"
};
/**
* Normalizes a key string to its canonical form using the alias map.
*
* @param key - The key string to normalize
* @returns The canonical key name in lowercase
*/
function normalizeKey(key) {
	const lowerKey = key.toLowerCase();
	return keyAliasMap[lowerKey] || lowerKey;
}
//#endregion
//#region node_modules/vuetify/lib/composables/hotkey/hotkey-parsing.js
var ParseError = class extends Error {};
/**
* Splits a single combination string into individual key parts.
* Grammar:
*
* sequence   = alternate *('-' alternate)
* alternate  = combo *('/' combo)
* combo      = key *(('+' | '_') key)
* key        = /./ *(/[^-/+_ ]/)
*
*/
function parseKeyCombination(input) {
	let pos = 0;
	try {
		const result = parseSequence();
		if (!atEnd()) throw new ParseError(`Unexpected character '${peek()}' at position ${pos}`);
		return result;
	} catch (err) {
		if (err instanceof ParseError) {
			consoleWarn(`Invalid hotkey combination: ${err.message}\n  ${input}\n  ${" ".repeat(pos)}^`);
			return "";
		} else throw err;
	}
	function peek(ahead = 0) {
		return pos + ahead < input.length ? input[pos + ahead] : null;
	}
	function consume() {
		if (pos >= input.length) throw new ParseError("Unexpected end of input");
		return input[pos++];
	}
	function atEnd() {
		return pos >= input.length;
	}
	function parseSequence() {
		const parts = [parseAlternate()];
		while (peek() === "-") {
			consume();
			parts.push(parseAlternate());
		}
		if (parts.length === 1) return parts[0];
		return {
			type: "sequence",
			parts
		};
	}
	function parseAlternate() {
		const parts = [parseCombo()];
		while (peek() === "/") {
			consume();
			parts.push(parseCombo());
		}
		if (parts.length === 1) return parts[0];
		return {
			type: "alternate",
			parts
		};
	}
	function parseCombo() {
		const keys = [parseKey()];
		while (includes(["+", "_"], peek())) {
			consume();
			keys.push(parseKey());
		}
		if (keys.length === 1) return keys[0];
		return {
			type: "combo",
			parts: keys
		};
	}
	function parseKey() {
		const ch = peek();
		if (ch == null) throw new ParseError("Unexpected end of input");
		const next = peek(1);
		if (isSep(ch) && next != null && !isSep(next)) throw new ParseError(`Unexpected separator '${ch}' at position ${pos}`);
		const first = consume();
		if (isSep(first)) return first;
		const chars = [first];
		while (!atEnd() && !isSep(peek()) && peek() !== " ") chars.push(consume());
		return normalizeKey(chars.join(""));
	}
}
function isSep(char) {
	return includes([
		"-",
		"/",
		"+",
		"_"
	], char);
}
//#endregion
//#region node_modules/vuetify/lib/composables/hotkey/hotkey.js
var MODIFIERS = [
	"ctrl",
	"shift",
	"alt",
	"meta",
	"cmd"
];
var modifiersSet = new Set(MODIFIERS);
function isModifier(key) {
	return modifiersSet.has(key);
}
var emptyModifiers = Object.fromEntries(MODIFIERS.map((m) => [m, false]));
function useHotkey(keys, callback, options = {}) {
	if (!IN_BROWSER) return function() {};
	const { event = "keydown", inputs = false, preventDefault = true, sequenceTimeout = 1e3 } = options;
	const isMac = navigator?.userAgent?.includes("Macintosh") ?? false;
	let timeout = 0;
	let keyGroups;
	let isSequence = false;
	let groupIndex = 0;
	function isInputFocused() {
		if (toValue(inputs)) return false;
		const activeElement = document.activeElement;
		return activeElement && (activeElement.tagName === "INPUT" || activeElement.tagName === "TEXTAREA" || activeElement.isContentEditable || activeElement.contentEditable === "true");
	}
	function resetSequence() {
		groupIndex = 0;
		clearTimeout(timeout);
	}
	function handler(e) {
		const group = keyGroups[groupIndex];
		if (!group || isInputFocused()) return;
		if (!matchesKeyGroup(e, group, isMac)) {
			if (isSequence) resetSequence();
			return;
		}
		if (toValue(preventDefault)) e.preventDefault();
		if (!isSequence) {
			callback(e);
			return;
		}
		clearTimeout(timeout);
		groupIndex++;
		if (groupIndex === keyGroups.length) {
			callback(e);
			resetSequence();
			return;
		}
		timeout = window.setTimeout(resetSequence, toValue(sequenceTimeout));
	}
	function cleanup() {
		window.removeEventListener(toValue(event), handler);
		clearTimeout(timeout);
	}
	watch(() => toValue(keys), (newKeys) => {
		cleanup();
		if (newKeys) {
			const parsed = parseKeyCombination(newKeys.toLowerCase());
			if (parsed) {
				const parts = typeof parsed !== "string" && parsed.type === "sequence" ? parsed.parts : [parsed];
				isSequence = parts.length > 1;
				keyGroups = parts;
				resetSequence();
				window.addEventListener(toValue(event), handler);
			}
		}
	}, { immediate: true });
	watch(() => toValue(event), (newEvent, oldEvent) => {
		if (oldEvent && keyGroups && keyGroups.length > 0) {
			window.removeEventListener(oldEvent, handler);
			window.addEventListener(newEvent, handler);
		}
	});
	onScopeDispose(cleanup, true);
	return cleanup;
}
function matchesKeyGroup(e, group, isMac) {
	if (typeof group !== "string" && group.type === "alternate") return group.parts.some((part) => matchesKeyGroup(e, part, isMac));
	const { modifiers, actualKey } = parseKeyGroup(group);
	const expectCtrl = modifiers.ctrl || !isMac && (modifiers.cmd || modifiers.meta);
	const expectMeta = isMac && (modifiers.cmd || modifiers.meta);
	return e.ctrlKey === expectCtrl && e.metaKey === expectMeta && e.shiftKey === modifiers.shift && e.altKey === modifiers.alt && e.key.toLowerCase() === actualKey?.toLowerCase();
}
function parseKeyGroup(group) {
	const parts = typeof group === "string" ? [group] : group.parts;
	const modifiers = { ...emptyModifiers };
	let actualKey;
	for (const part of parts) if (isModifier(part)) modifiers[part] = true;
	else actualKey = part;
	return {
		modifiers,
		actualKey
	};
}
propsFactory({ mask: [String, Object] }, "mask");
var defaultDelimiters = /[-!$%^&*()_+|~=`{}[\]:";'<>?,./\\ ]/;
var presets = {
	"credit-card": "#### - #### - #### - ####",
	date: "##/##/####",
	"date-time": "##/##/#### ##:##",
	"iso-date": "####-##-##",
	"iso-date-time": "####-##-## ##:##",
	phone: "(###) ### - ####",
	social: "###-##-####",
	time: "##:##",
	"time-with-seconds": "##:##:##"
};
var defaultTokens = {
	"#": { pattern: /[0-9]/ },
	A: {
		pattern: /[A-Z]/i,
		convert: (v) => v.toUpperCase()
	},
	a: {
		pattern: /[a-z]/i,
		convert: (v) => v.toLowerCase()
	},
	N: {
		pattern: /[0-9A-Z]/i,
		convert: (v) => v.toUpperCase()
	},
	n: {
		pattern: /[0-9a-z]/i,
		convert: (v) => v.toLowerCase()
	},
	X: { pattern: defaultDelimiters }
};
function useMask(props) {
	const mask = computed(() => {
		if (typeof props.mask === "string") {
			if (props.mask in presets) return presets[props.mask];
			return props.mask;
		}
		return props.mask?.mask ?? "";
	});
	const tokens = computed(() => {
		return {
			...defaultTokens,
			...isObject(props.mask) ? props.mask.tokens : null
		};
	});
	function isMask(char) {
		return char in tokens.value;
	}
	function maskValidates(mask, char) {
		if (char == null || !isMask(mask)) return false;
		const item = tokens.value[mask];
		if (item.pattern) return item.pattern.test(char);
		return item.test(char);
	}
	function convert(mask, char) {
		const item = tokens.value[mask];
		return item.convert ? item.convert(char) : char;
	}
	function maskText(text) {
		const trimmedText = text?.trim().replace(/\s+/g, " ");
		if (trimmedText == null) return "";
		if (!mask.value.length || !trimmedText.length) return trimmedText;
		let textIndex = 0;
		let maskIndex = 0;
		let newText = "";
		while (maskIndex < mask.value.length) {
			const mchar = mask.value[maskIndex];
			const tchar = trimmedText[textIndex];
			if (mchar === "\\") {
				newText += mask.value[maskIndex + 1];
				maskIndex += 2;
				continue;
			}
			if (!isMask(mchar)) {
				newText += mchar;
				if (tchar === mchar) textIndex++;
			} else if (maskValidates(mchar, tchar)) {
				newText += convert(mchar, tchar);
				textIndex++;
			} else if (textIndex < trimmedText.length) {
				textIndex++;
				continue;
			} else break;
			maskIndex++;
		}
		return newText;
	}
	function unmaskText(text) {
		if (text == null) return null;
		if (!mask.value.length || !text.length) return text;
		let result = "";
		const unmaskMap = getUnmaskMap(text);
		for (let i = 0; i < text.length; i++) if (!unmaskMap[i]) result += text[i];
		return result;
	}
	function isDelimiter(text, index) {
		if (!mask.value.length || !text.length) return false;
		return !!getUnmaskMap(text)[index];
	}
	function getUnmaskMap(text) {
		if (text == null || !mask.value.length || !text.length) return [];
		let textIndex = 0;
		let maskIndex = 0;
		const result = Array.from({ length: text.length }, () => true);
		while (true) {
			const mchar = mask.value[maskIndex];
			const tchar = text[textIndex];
			if (tchar == null) break;
			if (mchar == null) {
				result[textIndex] = false;
				textIndex++;
				continue;
			}
			if (mchar === "\\") {
				if (tchar === mask.value[maskIndex + 1]) textIndex++;
				maskIndex += 2;
				continue;
			}
			if (maskValidates(mchar, tchar)) {
				result[textIndex] = false;
				textIndex++;
				maskIndex++;
				continue;
			} else if (mchar !== tchar) {
				while (true) {
					const mchar = mask.value[maskIndex++];
					if (mchar == null || maskValidates(mchar, tchar)) break;
				}
				continue;
			}
			textIndex++;
			maskIndex++;
		}
		return result;
	}
	function isValid(text) {
		if (!text) return false;
		return unmaskText(text) === unmaskText(maskText(text));
	}
	function isComplete(text) {
		if (!text) return false;
		return maskText(text).length === mask.value.length && isValid(text);
	}
	return {
		isDelimiter,
		isValid,
		isComplete,
		mask: maskText,
		unmask: unmaskText
	};
}
//#endregion
//#region node_modules/vuetify/lib/framework.js
function createVuetify(vuetify = {}) {
	const { blueprint, ...rest } = vuetify;
	const options = mergeDeep(blueprint, rest);
	const { aliases = {}, components = {}, directives = {} } = options;
	const scope = effectScope();
	return scope.run(() => {
		const defaults = createDefaults(options.defaults);
		const display = createDisplay(options.display, options.ssr);
		const theme = createTheme(options.theme);
		const icons = createIcons(options.icons);
		const locale = createLocale(options.locale);
		const date = createDate(options.date, locale);
		const goTo = createGoTo(options.goTo, locale);
		function install(app) {
			for (const key in directives) app.directive(key, directives[key]);
			for (const key in components) app.component(key, components[key]);
			for (const key in aliases) app.component(key, defineComponent({
				...aliases[key],
				name: key,
				aliasName: aliases[key].name
			}));
			const appScope = effectScope();
			appScope.run(() => {
				theme.install(app);
			});
			app.onUnmount(() => appScope.stop());
			app.provide(DefaultsSymbol, defaults);
			app.provide(DisplaySymbol, display);
			app.provide(ThemeSymbol, theme);
			app.provide(IconSymbol, icons);
			app.provide(LocaleSymbol, locale);
			app.provide(DateOptionsSymbol, date.options);
			app.provide(DateAdapterSymbol, date.instance);
			app.provide(GoToSymbol, goTo);
			if (IN_BROWSER && options.ssr) if (app.$nuxt) app.$nuxt.hook("app:suspense:resolve", () => {
				display.update();
			});
			else {
				const { mount } = app;
				app.mount = (...args) => {
					const vm = mount(...args);
					nextTick(() => display.update());
					app.mount = mount;
					return vm;
				};
			}
			if (typeof __VUE_OPTIONS_API__ !== "boolean" || __VUE_OPTIONS_API__) app.mixin({ computed: { $vuetify() {
				return reactive({
					defaults: inject.call(this, DefaultsSymbol),
					display: inject.call(this, DisplaySymbol),
					theme: inject.call(this, ThemeSymbol),
					icons: inject.call(this, IconSymbol),
					locale: inject.call(this, LocaleSymbol),
					date: inject.call(this, DateAdapterSymbol)
				});
			} } });
		}
		function unmount() {
			scope.stop();
		}
		return {
			install,
			unmount,
			defaults,
			display,
			theme,
			icons,
			locale,
			date,
			goTo
		};
	});
}
var version = "4.0.7";
createVuetify.version = version;
function inject(key) {
	const vm = this.$;
	const provides = vm.parent?.provides ?? vm.vnode.appContext?.provides;
	if (provides && key in provides) return provides[key];
}
//#endregion
export { createVuetify, useDate, useDefaults, useDisplay, useGoTo, useHotkey, useLayout, useLocale, useMask, useRtl, useTheme, version };

//# sourceMappingURL=vuetify.js.map