1242 lines
36 KiB
JavaScript
1242 lines
36 KiB
JavaScript
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
|