import { Mn as effectScope, Ot as nextTick, 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-BvoXUmaf.js";
import { G as padStart, I as isObject, P as includes, Q as IN_BROWSER, V as mergeDeep, i as createDefaults, it as consoleWarn, l as propsFactory, o as useDefaults, r as DefaultsSymbol, t as defineComponent, v as createRange } from "./defineComponent-DB6xIcDy.js";
import { a as useTheme, n as createTheme, t as ThemeSymbol } from "./theme-Cx5kFg0-.js";
import { o as VSvgIcon, r as VClassIcon, t as IconSymbol } from "./icons-k2ZLE_i8.js";
import { i as useRtl, n as createLocale, r as useLocale, t as LocaleSymbol } from "./locale-DDGMqzqb.js";
import { a as useDisplay, r as createDisplay, t as DisplaySymbol } from "./display-DKaCj-_K.js";
import { n as createGoTo, r as useGoTo, t as GoToSymbol } from "./goto-Bn-PzNUr.js";
import { i as useLayout } from "./layout-C9QMoF7I.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() {
	return {
		svg: { component: VSvgIcon },
		class: { component: VClassIcon }
	};
}
function createIcons(options) {
	const sets = genDefaults();
	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/date/adapters/vuetify.js
function weekInfo(locale) {
	const code = locale.slice(-2).toUpperCase();
	switch (true) {
		case locale === "GB-alt-variant": return {
			firstDay: 0,
			firstWeekSize: 4
		};
		case locale === "001": return {
			firstDay: 1,
			firstWeekSize: 1
		};
		case `AG AS BD BR BS BT BW BZ CA CO DM DO ET GT GU HK HN ID IL IN JM JP KE
    KH KR LA MH MM MO MT MX MZ NI NP PA PE PH PK PR PY SA SG SV TH TT TW UM US
    VE VI WS YE ZA ZW`.includes(code): return {
			firstDay: 0,
			firstWeekSize: 1
		};
		case `AI AL AM AR AU AZ BA BM BN BY CL CM CN CR CY EC GE HR KG KZ LB LK LV
    MD ME MK MN MY NZ RO RS SI TJ TM TR UA UY UZ VN XK`.includes(code): return {
			firstDay: 1,
			firstWeekSize: 1
		};
		case `AD AN AT AX BE BG CH CZ DE DK EE ES FI FJ FO FR GB GF GP GR HU IE IS
    IT LI LT LU MC MQ NL NO PL RE RU SE SK SM VA`.includes(code): return {
			firstDay: 1,
			firstWeekSize: 4
		};
		case `AE AF BH DJ DZ EG IQ IR JO KW LY OM QA SD SY`.includes(code): return {
			firstDay: 6,
			firstWeekSize: 1
		};
		case code === "MV": return {
			firstDay: 5,
			firstWeekSize: 1
		};
		case code === "PT": return {
			firstDay: 0,
			firstWeekSize: 4
		};
		default: return null;
	}
}
function getWeekArray(date, locale, firstDayOfWeek) {
	const weeks = [];
	let currentWeek = [];
	const firstDayOfMonth = startOfMonth(date);
	const lastDayOfMonth = endOfMonth(date);
	const first = firstDayOfWeek ?? weekInfo(locale)?.firstDay ?? 0;
	const firstDayWeekIndex = (firstDayOfMonth.getDay() - first + 7) % 7;
	const lastDayWeekIndex = (lastDayOfMonth.getDay() - first + 7) % 7;
	for (let i = 0; i < firstDayWeekIndex; i++) {
		const adjacentDay = new Date(firstDayOfMonth);
		adjacentDay.setDate(adjacentDay.getDate() - (firstDayWeekIndex - i));
		currentWeek.push(adjacentDay);
	}
	for (let i = 1; i <= lastDayOfMonth.getDate(); i++) {
		const day = new Date(date.getFullYear(), date.getMonth(), i);
		currentWeek.push(day);
		if (currentWeek.length === 7) {
			weeks.push(currentWeek);
			currentWeek = [];
		}
	}
	for (let i = 1; i < 7 - lastDayWeekIndex; i++) {
		const adjacentDay = new Date(lastDayOfMonth);
		adjacentDay.setDate(adjacentDay.getDate() + i);
		currentWeek.push(adjacentDay);
	}
	if (currentWeek.length > 0) weeks.push(currentWeek);
	return weeks;
}
function startOfWeek(date, locale, firstDayOfWeek) {
	let day = (firstDayOfWeek ?? weekInfo(locale)?.firstDay ?? 0) % 7;
	if (![
		0,
		1,
		2,
		3,
		4,
		5,
		6
	].includes(day)) {
		consoleWarn("Invalid firstDayOfWeek, expected discrete number in range [0-6]");
		day = 0;
	}
	const d = new Date(date);
	while (d.getDay() !== day) d.setDate(d.getDate() - 1);
	return d;
}
function endOfWeek(date, locale) {
	const d = new Date(date);
	const lastDay = ((weekInfo(locale)?.firstDay ?? 0) + 6) % 7;
	while (d.getDay() !== lastDay) d.setDate(d.getDate() + 1);
	return d;
}
function startOfMonth(date) {
	return new Date(date.getFullYear(), date.getMonth(), 1);
}
function endOfMonth(date) {
	return new Date(date.getFullYear(), date.getMonth() + 1, 0);
}
function parseLocalDate(value) {
	const parts = value.split("-").map(Number);
	return new Date(parts[0], parts[1] - 1, parts[2]);
}
var _YYYMMDD = /^([12]\d{3}-([1-9]|0[1-9]|1[0-2])-([1-9]|0[1-9]|[12]\d|3[01]))$/;
function date(value) {
	if (value == null) return /* @__PURE__ */ new Date();
	if (value instanceof Date) return value;
	if (typeof value === "string") {
		let parsed;
		if (_YYYMMDD.test(value)) return parseLocalDate(value);
		else parsed = Date.parse(value);
		if (!isNaN(parsed)) return new Date(parsed);
	}
	return null;
}
var sundayJanuarySecond2000 = new Date(2e3, 0, 2);
function getWeekdays(locale, firstDayOfWeek, weekdayFormat) {
	const daysFromSunday = firstDayOfWeek ?? weekInfo(locale)?.firstDay ?? 0;
	return createRange(7).map((i) => {
		const weekday = new Date(sundayJanuarySecond2000);
		weekday.setDate(sundayJanuarySecond2000.getDate() + daysFromSunday + i);
		return new Intl.DateTimeFormat(locale, { weekday: weekdayFormat ?? "narrow" }).format(weekday);
	});
}
function format(value, formatString, locale, formats) {
	const newDate = date(value) ?? /* @__PURE__ */ new Date();
	const customFormat = formats?.[formatString];
	if (typeof customFormat === "function") return customFormat(newDate, formatString, locale);
	let options = {};
	switch (formatString) {
		case "fullDate":
			options = {
				year: "numeric",
				month: "short",
				day: "numeric"
			};
			break;
		case "fullDateWithWeekday":
			options = {
				weekday: "long",
				year: "numeric",
				month: "long",
				day: "numeric"
			};
			break;
		case "normalDate": return `${newDate.getDate()} ${new Intl.DateTimeFormat(locale, { month: "long" }).format(newDate)}`;
		case "normalDateWithWeekday":
			options = {
				weekday: "short",
				day: "numeric",
				month: "short"
			};
			break;
		case "shortDate":
			options = {
				month: "short",
				day: "numeric"
			};
			break;
		case "year":
			options = { year: "numeric" };
			break;
		case "month":
			options = { month: "long" };
			break;
		case "monthShort":
			options = { month: "short" };
			break;
		case "monthAndYear":
			options = {
				month: "long",
				year: "numeric"
			};
			break;
		case "monthAndDate":
			options = {
				month: "long",
				day: "numeric"
			};
			break;
		case "weekday":
			options = { weekday: "long" };
			break;
		case "weekdayShort":
			options = { weekday: "short" };
			break;
		case "dayOfMonth": return new Intl.NumberFormat(locale).format(newDate.getDate());
		case "hours12h":
			options = {
				hour: "numeric",
				hour12: true
			};
			break;
		case "hours24h":
			options = {
				hour: "numeric",
				hour12: false
			};
			break;
		case "minutes":
			options = { minute: "numeric" };
			break;
		case "seconds":
			options = { second: "numeric" };
			break;
		case "fullTime":
			options = {
				hour: "numeric",
				minute: "numeric"
			};
			break;
		case "fullTime12h":
			options = {
				hour: "numeric",
				minute: "numeric",
				hour12: true
			};
			break;
		case "fullTime24h":
			options = {
				hour: "numeric",
				minute: "numeric",
				hour12: false
			};
			break;
		case "fullDateTime":
			options = {
				year: "numeric",
				month: "short",
				day: "numeric",
				hour: "numeric",
				minute: "numeric"
			};
			break;
		case "fullDateTime12h":
			options = {
				year: "numeric",
				month: "short",
				day: "numeric",
				hour: "numeric",
				minute: "numeric",
				hour12: true
			};
			break;
		case "fullDateTime24h":
			options = {
				year: "numeric",
				month: "short",
				day: "numeric",
				hour: "numeric",
				minute: "numeric",
				hour12: false
			};
			break;
		case "keyboardDate":
			options = {
				year: "numeric",
				month: "2-digit",
				day: "2-digit"
			};
			break;
		case "keyboardDateTime":
			options = {
				year: "numeric",
				month: "2-digit",
				day: "2-digit",
				hour: "numeric",
				minute: "numeric"
			};
			return new Intl.DateTimeFormat(locale, options).format(newDate).replace(/, /g, " ");
		case "keyboardDateTime12h":
			options = {
				year: "numeric",
				month: "2-digit",
				day: "2-digit",
				hour: "numeric",
				minute: "numeric",
				hour12: true
			};
			return new Intl.DateTimeFormat(locale, options).format(newDate).replace(/, /g, " ");
		case "keyboardDateTime24h":
			options = {
				year: "numeric",
				month: "2-digit",
				day: "2-digit",
				hour: "numeric",
				minute: "numeric",
				hour12: false
			};
			return new Intl.DateTimeFormat(locale, options).format(newDate).replace(/, /g, " ");
		default: options = customFormat ?? {
			timeZone: "UTC",
			timeZoneName: "short"
		};
	}
	return new Intl.DateTimeFormat(locale, options).format(newDate);
}
function toISO(adapter, value) {
	const date = adapter.toJsDate(value);
	return `${date.getFullYear()}-${padStart(String(date.getMonth() + 1), 2, "0")}-${padStart(String(date.getDate()), 2, "0")}`;
}
function parseISO(value) {
	const [year, month, day] = value.split("-").map(Number);
	return new Date(year, month - 1, day);
}
function addMinutes(date, amount) {
	const d = new Date(date);
	d.setMinutes(d.getMinutes() + amount);
	return d;
}
function addHours(date, amount) {
	const d = new Date(date);
	d.setHours(d.getHours() + amount);
	return d;
}
function addDays(date, amount) {
	const d = new Date(date);
	d.setDate(d.getDate() + amount);
	return d;
}
function addWeeks(date, amount) {
	const d = new Date(date);
	d.setDate(d.getDate() + amount * 7);
	return d;
}
function addMonths(date, amount) {
	const d = new Date(date);
	d.setDate(1);
	d.setMonth(d.getMonth() + amount);
	return d;
}
function getYear(date) {
	return date.getFullYear();
}
function getMonth(date) {
	return date.getMonth();
}
function getWeek(date, locale, firstDayOfWeek, firstDayOfYear) {
	const weekInfoFromLocale = weekInfo(locale);
	const weekStart = firstDayOfWeek ?? weekInfoFromLocale?.firstDay ?? 0;
	const minWeekSize = weekInfoFromLocale?.firstWeekSize ?? 1;
	return firstDayOfYear !== void 0 ? calculateWeekWithFirstDayOfYear(date, locale, weekStart, firstDayOfYear) : calculateWeekWithMinWeekSize(date, locale, weekStart, minWeekSize);
}
function calculateWeekWithFirstDayOfYear(date, locale, weekStart, firstDayOfYear) {
	const firstDayOfYearOffset = (7 + firstDayOfYear - weekStart) % 7;
	const currentWeekStart = startOfWeek(date, locale, weekStart);
	const currentWeekEnd = addDays(currentWeekStart, 6);
	function yearStartWeekdayOffset(year) {
		return (7 + new Date(year, 0, 1).getDay() - weekStart) % 7;
	}
	let year = getYear(currentWeekStart);
	if (year < getYear(currentWeekEnd) && yearStartWeekdayOffset(year + 1) <= firstDayOfYearOffset) year++;
	const yearStart = new Date(year, 0, 1);
	const offset = yearStartWeekdayOffset(year);
	const d1w1 = offset <= firstDayOfYearOffset ? addDays(yearStart, -offset) : addDays(yearStart, 7 - offset);
	return 1 + getDiff(endOfDay(currentWeekStart), startOfDay(d1w1), "weeks");
}
function calculateWeekWithMinWeekSize(date, locale, weekStart, minWeekSize) {
	const currentWeekStart = startOfWeek(date, locale, weekStart);
	const currentWeekEnd = addDays(startOfWeek(date, locale, weekStart), 6);
	function firstWeekSize(year) {
		const yearStart = new Date(year, 0, 1);
		return 7 - getDiff(yearStart, startOfWeek(yearStart, locale, weekStart), "days");
	}
	let year = getYear(currentWeekStart);
	if (year < getYear(currentWeekEnd) && firstWeekSize(year + 1) >= minWeekSize) year++;
	const yearStart = new Date(year, 0, 1);
	const size = firstWeekSize(year);
	const d1w1 = size >= minWeekSize ? addDays(yearStart, size - 7) : addDays(yearStart, size);
	return 1 + getDiff(endOfDay(currentWeekStart), startOfDay(d1w1), "weeks");
}
function getDate(date) {
	return date.getDate();
}
function getNextMonth(date) {
	return new Date(date.getFullYear(), date.getMonth() + 1, 1);
}
function getPreviousMonth(date) {
	return new Date(date.getFullYear(), date.getMonth() - 1, 1);
}
function getHours(date) {
	return date.getHours();
}
function getMinutes(date) {
	return date.getMinutes();
}
function startOfYear(date) {
	return new Date(date.getFullYear(), 0, 1);
}
function endOfYear(date) {
	return new Date(date.getFullYear(), 11, 31);
}
function isWithinRange(date, range) {
	return isEqual(date, range[0]) || isEqual(date, range[1]) || isAfter(date, range[0]) && isBefore(date, range[1]);
}
function isValid(date) {
	const d = new Date(date);
	return d instanceof Date && !isNaN(d.getTime());
}
function isAfter(date, comparing) {
	return date.getTime() > comparing.getTime();
}
function isAfterDay(date, comparing) {
	return isAfter(startOfDay(date), startOfDay(comparing));
}
function isBefore(date, comparing) {
	return date.getTime() < comparing.getTime();
}
function isEqual(date, comparing) {
	return date.getTime() === comparing.getTime();
}
function isSameDay(date, comparing) {
	return date.getDate() === comparing.getDate() && date.getMonth() === comparing.getMonth() && date.getFullYear() === comparing.getFullYear();
}
function isSameMonth(date, comparing) {
	return date.getMonth() === comparing.getMonth() && date.getFullYear() === comparing.getFullYear();
}
function isSameYear(date, comparing) {
	return date.getFullYear() === comparing.getFullYear();
}
function getDiff(date, comparing, unit) {
	const d = new Date(date);
	const c = new Date(comparing);
	switch (unit) {
		case "years": return d.getFullYear() - c.getFullYear();
		case "quarters": return Math.floor((d.getMonth() - c.getMonth() + (d.getFullYear() - c.getFullYear()) * 12) / 4);
		case "months": return d.getMonth() - c.getMonth() + (d.getFullYear() - c.getFullYear()) * 12;
		case "weeks": return Math.floor((d.getTime() - c.getTime()) / (1e3 * 60 * 60 * 24 * 7));
		case "days": return Math.floor((d.getTime() - c.getTime()) / (1e3 * 60 * 60 * 24));
		case "hours": return Math.floor((d.getTime() - c.getTime()) / (1e3 * 60 * 60));
		case "minutes": return Math.floor((d.getTime() - c.getTime()) / (1e3 * 60));
		case "seconds": return Math.floor((d.getTime() - c.getTime()) / 1e3);
		default: return d.getTime() - c.getTime();
	}
}
function setHours(date, count) {
	const d = new Date(date);
	d.setHours(count);
	return d;
}
function setMinutes(date, count) {
	const d = new Date(date);
	d.setMinutes(count);
	return d;
}
function setMonth(date, count) {
	const d = new Date(date);
	d.setMonth(count);
	return d;
}
function setDate(date, day) {
	const d = new Date(date);
	d.setDate(day);
	return d;
}
function setYear(date, year) {
	const d = new Date(date);
	d.setFullYear(year);
	return d;
}
function startOfDay(date) {
	return new Date(date.getFullYear(), date.getMonth(), date.getDate(), 0, 0, 0, 0);
}
function endOfDay(date) {
	return new Date(date.getFullYear(), date.getMonth(), date.getDate(), 23, 59, 59, 999);
}
var VuetifyDateAdapter = class {
	constructor(options) {
		this.locale = options.locale;
		this.formats = options.formats;
	}
	date(value) {
		return date(value);
	}
	toJsDate(date) {
		return date;
	}
	toISO(date) {
		return toISO(this, date);
	}
	parseISO(date) {
		return parseISO(date);
	}
	addMinutes(date, amount) {
		return addMinutes(date, amount);
	}
	addHours(date, amount) {
		return addHours(date, amount);
	}
	addDays(date, amount) {
		return addDays(date, amount);
	}
	addWeeks(date, amount) {
		return addWeeks(date, amount);
	}
	addMonths(date, amount) {
		return addMonths(date, amount);
	}
	getWeekArray(date, firstDayOfWeek) {
		const firstDay = firstDayOfWeek !== void 0 ? Number(firstDayOfWeek) : void 0;
		return getWeekArray(date, this.locale, firstDay);
	}
	startOfWeek(date, firstDayOfWeek) {
		const firstDay = firstDayOfWeek !== void 0 ? Number(firstDayOfWeek) : void 0;
		return startOfWeek(date, this.locale, firstDay);
	}
	endOfWeek(date) {
		return endOfWeek(date, this.locale);
	}
	startOfMonth(date) {
		return startOfMonth(date);
	}
	endOfMonth(date) {
		return endOfMonth(date);
	}
	format(date, formatString) {
		return format(date, formatString, this.locale, this.formats);
	}
	isEqual(date, comparing) {
		return isEqual(date, comparing);
	}
	isValid(date) {
		return isValid(date);
	}
	isWithinRange(date, range) {
		return isWithinRange(date, range);
	}
	isAfter(date, comparing) {
		return isAfter(date, comparing);
	}
	isAfterDay(date, comparing) {
		return isAfterDay(date, comparing);
	}
	isBefore(date, comparing) {
		return !isAfter(date, comparing) && !isEqual(date, comparing);
	}
	isSameDay(date, comparing) {
		return isSameDay(date, comparing);
	}
	isSameMonth(date, comparing) {
		return isSameMonth(date, comparing);
	}
	isSameYear(date, comparing) {
		return isSameYear(date, comparing);
	}
	setMinutes(date, count) {
		return setMinutes(date, count);
	}
	setHours(date, count) {
		return setHours(date, count);
	}
	setMonth(date, count) {
		return setMonth(date, count);
	}
	setDate(date, day) {
		return setDate(date, day);
	}
	setYear(date, year) {
		return setYear(date, year);
	}
	getDiff(date, comparing, unit) {
		return getDiff(date, comparing, unit);
	}
	getWeekdays(firstDayOfWeek, weekdayFormat) {
		const firstDay = firstDayOfWeek !== void 0 ? Number(firstDayOfWeek) : void 0;
		return getWeekdays(this.locale, firstDay, weekdayFormat);
	}
	getYear(date) {
		return getYear(date);
	}
	getMonth(date) {
		return getMonth(date);
	}
	getWeek(date, firstDayOfWeek, firstDayOfYear) {
		const firstDay = firstDayOfWeek !== void 0 ? Number(firstDayOfWeek) : void 0;
		const firstWeekStart = firstDayOfYear !== void 0 ? Number(firstDayOfYear) : void 0;
		return getWeek(date, this.locale, firstDay, firstWeekStart);
	}
	getDate(date) {
		return getDate(date);
	}
	getNextMonth(date) {
		return getNextMonth(date);
	}
	getPreviousMonth(date) {
		return getPreviousMonth(date);
	}
	getHours(date) {
		return getHours(date);
	}
	getMinutes(date) {
		return getMinutes(date);
	}
	startOfDay(date) {
		return startOfDay(date);
	}
	endOfDay(date) {
		return endOfDay(date);
	}
	startOfYear(date) {
		return startOfYear(date);
	}
	endOfYear(date) {
		return endOfYear(date);
	}
};
//#endregion
//#region node_modules/vuetify/lib/composables/date/date.js
var DateOptionsSymbol = Symbol.for("vuetify:date-options");
var DateAdapterSymbol = Symbol.for("vuetify:date-adapter");
function createDate(options, locale) {
	const _options = mergeDeep({
		adapter: VuetifyDateAdapter,
		locale: {
			af: "af-ZA",
			bg: "bg-BG",
			ca: "ca-ES",
			ckb: "",
			cs: "cs-CZ",
			de: "de-DE",
			el: "el-GR",
			en: "en-US",
			et: "et-EE",
			fa: "fa-IR",
			fi: "fi-FI",
			hr: "hr-HR",
			hu: "hu-HU",
			he: "he-IL",
			id: "id-ID",
			it: "it-IT",
			ja: "ja-JP",
			ko: "ko-KR",
			lv: "lv-LV",
			lt: "lt-LT",
			nl: "nl-NL",
			no: "no-NO",
			pl: "pl-PL",
			pt: "pt-PT",
			ro: "ro-RO",
			ru: "ru-RU",
			sk: "sk-SK",
			sl: "sl-SI",
			srCyrl: "sr-SP",
			srLatn: "sr-SP",
			sv: "sv-SE",
			th: "th-TH",
			tr: "tr-TR",
			az: "az-AZ",
			uk: "uk-UA",
			vi: "vi-VN",
			zhHans: "zh-CN",
			zhHant: "zh-TW"
		}
	}, options);
	return {
		options: _options,
		instance: createInstance(_options, locale)
	};
}
function createInstance(options, locale) {
	const instance = reactive(typeof options.adapter === "function" ? new options.adapter({
		locale: options.locale[locale.current.value] ?? locale.current.value,
		formats: options.formats
	}) : options.adapter);
	watch(locale.current, (value) => {
		instance.locale = options.locale[value] ?? value ?? instance.locale;
	});
	return instance;
}
function useDate() {
	const options = inject$1(DateOptionsSymbol);
	if (!options) throw new Error("[Vuetify] Could not find injected date options");
	return createInstance(options, useLocale());
}
//#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.6";
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