565 lines
17 KiB
JavaScript
565 lines
17 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 } from "./vue.runtime.esm-bundler-BvoXUmaf.js";
|
|
import { G as mergeDeep, I as includes, a as createDefaults, ct as consoleWarn, i as DefaultsSymbol, nt as IN_BROWSER, s as useDefaults, t as defineComponent, ut as propsFactory, z as isObject } from "./defineComponent-92h8LsW-.js";
|
|
import { a as useLayout } from "./layout-Booh7E97.js";
|
|
import { i as useRtl, n as createLocale, r as useLocale, t as LocaleSymbol } from "./locale-BI-ulWIe.js";
|
|
import { a as useTheme, n as createTheme, t as ThemeSymbol } from "./theme-CwW_z-RC.js";
|
|
import { o as VSvgIcon, r as VClassIcon, t as IconSymbol } from "./icons-BqOQHwEN.js";
|
|
import { a as useDisplay, r as createDisplay, t as DisplaySymbol } from "./display-NNQAdN_b.js";
|
|
import { n as DateOptionsSymbol, o as useDate, r as createDate, t as DateAdapterSymbol } from "./date-DIfArSSH.js";
|
|
import { n as createGoTo, r as useGoTo, t as GoToSymbol } from "./goto-CD4cxzRn.js";
|
|
//#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/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/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
|