@vuetify/nightly 3.9.0-beta.1-dev.2025-06-26 → 3.9.0-beta.1-dev.2025-06-28

package/dist/vuetify.d.ts

@@ -305,6 +305,17 @@ interface IconAliases {
     eyeDropper: IconValue;
     upload: IconValue;
     color: IconValue;
+    command: IconValue;
+    ctrl: IconValue;
+    space: IconValue;
+    shift: IconValue;
+    alt: IconValue;
+    enter: IconValue;
+    arrowup: IconValue;
+    arrowdown: IconValue;
+    arrowleft: IconValue;
+    arrowright: IconValue;
+    backspace: IconValue;
 }
 interface IconProps {
     tag: string | JSXComponent;
@@ -3295,6 +3306,14 @@ declare function useLayout(): {
     mainStyles: Ref<CSSProperties, CSSProperties>;
 };
 
+interface HotkeyOptions {
+    event?: MaybeRef<'keydown' | 'keyup'>;
+    inputs?: MaybeRef<boolean>;
+    preventDefault?: MaybeRef<boolean>;
+    sequenceTimeout?: MaybeRef<number>;
+}
+declare function useHotkey(keys: MaybeRef<string | undefined>, callback: (e: KeyboardEvent) => void, options?: HotkeyOptions): () => void;
+
 interface VuetifyOptions {
     aliases?: Record<string, any>;
     blueprint?: Blueprint;
@@ -93432,7 +93451,7 @@ declare const createVuetify: {
 };
 declare const version: string;
 
-export { index_d$2 as blueprints, index_d$1 as components, createVuetify, index_d as directives, useDate, useDefaults, useDisplay, useGoTo, useLayout, useLocale, useRtl, useTheme, version };
+export { index_d$2 as blueprints, index_d$1 as components, createVuetify, index_d as directives, useDate, useDefaults, useDisplay, useGoTo, useHotkey, useLayout, useLocale, useRtl, useTheme, version };
 
 /* eslint-disable local-rules/sort-imports */
 
@@ -93469,38 +93488,44 @@ declare module 'vue' {
     $children?: VNodeChild
   }
   export interface GlobalComponents {
+    VApp: VApp
     VAppBar: VAppBar
     VAppBarNavIcon: VAppBarNavIcon
     VAppBarTitle: VAppBarTitle
     VAlert: VAlert
     VAlertTitle: VAlertTitle
-    VApp: VApp
-    VAutocomplete: VAutocomplete
     VBadge: VBadge
-    VBottomNavigation: VBottomNavigation
+    VAutocomplete: VAutocomplete
+    VAvatar: VAvatar
+    VBottomSheet: VBottomSheet
     VBreadcrumbs: VBreadcrumbs
     VBreadcrumbsItem: VBreadcrumbsItem
     VBreadcrumbsDivider: VBreadcrumbsDivider
-    VBanner: VBanner
-    VBannerActions: VBannerActions
-    VBannerText: VBannerText
     VBtnGroup: VBtnGroup
-    VBottomSheet: VBottomSheet
+    VBtnToggle: VBtnToggle
     VCard: VCard
     VCardActions: VCardActions
     VCardItem: VCardItem
     VCardSubtitle: VCardSubtitle
     VCardText: VCardText
     VCardTitle: VCardTitle
-    VChip: VChip
-    VBtn: VBtn
-    VBtnToggle: VBtnToggle
+    VCarousel: VCarousel
+    VCarouselItem: VCarouselItem
+    VCode: VCode
     VCheckbox: VCheckbox
     VCheckboxBtn: VCheckboxBtn
-    VAvatar: VAvatar
-    VCombobox: VCombobox
-    VCode: VCode
+    VColorPicker: VColorPicker
+    VChip: VChip
+    VChipGroup: VChipGroup
+    VBtn: VBtn
     VCounter: VCounter
+    VCombobox: VCombobox
+    VDatePicker: VDatePicker
+    VDatePickerControls: VDatePickerControls
+    VDatePickerHeader: VDatePickerHeader
+    VDatePickerMonth: VDatePickerMonth
+    VDatePickerMonths: VDatePickerMonths
+    VDatePickerYears: VDatePickerYears
     VDataTable: VDataTable
     VDataTableHeaders: VDataTableHeaders
     VDataTableFooter: VDataTableFooter
@@ -93508,35 +93533,32 @@ declare module 'vue' {
     VDataTableRow: VDataTableRow
     VDataTableVirtual: VDataTableVirtual
     VDataTableServer: VDataTableServer
-    VDatePicker: VDatePicker
-    VDatePickerControls: VDatePickerControls
-    VDatePickerHeader: VDatePickerHeader
-    VDatePickerMonth: VDatePickerMonth
-    VDatePickerMonths: VDatePickerMonths
-    VDatePickerYears: VDatePickerYears
-    VColorPicker: VColorPicker
-    VChipGroup: VChipGroup
     VDialog: VDialog
     VDivider: VDivider
-    VEmptyState: VEmptyState
-    VFab: VFab
     VField: VField
     VFieldLabel: VFieldLabel
-    VFileInput: VFileInput
+    VFab: VFab
+    VExpansionPanels: VExpansionPanels
+    VExpansionPanel: VExpansionPanel
+    VExpansionPanelText: VExpansionPanelText
+    VExpansionPanelTitle: VExpansionPanelTitle
     VFooter: VFooter
+    VImg: VImg
+    VFileInput: VFileInput
+    VEmptyState: VEmptyState
     VIcon: VIcon
     VComponentIcon: VComponentIcon
     VSvgIcon: VSvgIcon
     VLigatureIcon: VLigatureIcon
     VClassIcon: VClassIcon
-    VExpansionPanels: VExpansionPanels
-    VExpansionPanel: VExpansionPanel
-    VExpansionPanelText: VExpansionPanelText
-    VExpansionPanelTitle: VExpansionPanelTitle
     VInfiniteScroll: VInfiniteScroll
-    VInput: VInput
+    VLabel: VLabel
     VItemGroup: VItemGroup
     VItem: VItem
+    VInput: VInput
+    VKbd: VKbd
+    VMenu: VMenu
+    VMain: VMain
     VList: VList
     VListGroup: VListGroup
     VListImg: VListImg
@@ -93546,69 +93568,65 @@ declare module 'vue' {
     VListItemSubtitle: VListItemSubtitle
     VListItemTitle: VListItemTitle
     VListSubheader: VListSubheader
-    VKbd: VKbd
-    VLabel: VLabel
-    VImg: VImg
-    VMain: VMain
-    VNavigationDrawer: VNavigationDrawer
     VMessages: VMessages
-    VOtpInput: VOtpInput
-    VMenu: VMenu
+    VNavigationDrawer: VNavigationDrawer
     VNumberInput: VNumberInput
     VOverlay: VOverlay
     VPagination: VPagination
     VProgressCircular: VProgressCircular
+    VBottomNavigation: VBottomNavigation
     VProgressLinear: VProgressLinear
-    VRadioGroup: VRadioGroup
-    VSheet: VSheet
+    VOtpInput: VOtpInput
     VRating: VRating
+    VSelect: VSelect
     VSelectionControl: VSelectionControl
-    VSkeletonLoader: VSkeletonLoader
+    VSheet: VSheet
     VSelectionControlGroup: VSelectionControlGroup
-    VSlider: VSlider
-    VSelect: VSelect
+    VSkeletonLoader: VSkeletonLoader
     VSlideGroup: VSlideGroup
     VSlideGroupItem: VSlideGroupItem
+    VSlider: VSlider
     VSnackbar: VSnackbar
+    VSystemBar: VSystemBar
+    VSwitch: VSwitch
     VStepper: VStepper
     VStepperActions: VStepperActions
     VStepperHeader: VStepperHeader
     VStepperItem: VStepperItem
     VStepperWindow: VStepperWindow
     VStepperWindowItem: VStepperWindowItem
-    VSystemBar: VSystemBar
-    VSwitch: VSwitch
-    VTable: VTable
     VTab: VTab
     VTabs: VTabs
     VTabsWindow: VTabsWindow
     VTabsWindowItem: VTabsWindowItem
+    VTextarea: VTextarea
     VTextField: VTextField
     VTimeline: VTimeline
     VTimelineItem: VTimelineItem
-    VTextarea: VTextarea
     VTreeview: VTreeview
     VTreeviewItem: VTreeviewItem
     VTreeviewGroup: VTreeviewGroup
-    VTooltip: VTooltip
-    VTimePicker: VTimePicker
-    VTimePickerClock: VTimePickerClock
-    VTimePickerControls: VTimePickerControls
     VToolbar: VToolbar
     VToolbarTitle: VToolbarTitle
     VToolbarItems: VToolbarItems
+    VTimePicker: VTimePicker
+    VTimePickerClock: VTimePickerClock
+    VTimePickerControls: VTimePickerControls
+    VTooltip: VTooltip
     VWindow: VWindow
     VWindowItem: VWindowItem
-    VCarousel: VCarousel
-    VCarouselItem: VCarouselItem
+    VBanner: VBanner
+    VBannerActions: VBannerActions
+    VBannerText: VBannerText
     VConfirmEdit: VConfirmEdit
+    VDataIterator: VDataIterator
     VDefaultsProvider: VDefaultsProvider
     VForm: VForm
-    VHover: VHover
     VContainer: VContainer
     VCol: VCol
     VRow: VRow
     VSpacer: VSpacer
+    VHover: VHover
     VLayout: VLayout
     VLayoutItem: VLayoutItem
     VLazy: VLazy
@@ -93618,13 +93636,12 @@ declare module 'vue' {
     VRadio: VRadio
     VRangeSlider: VRangeSlider
     VResponsive: VResponsive
+    VSnackbarQueue: VSnackbarQueue
     VSparkline: VSparkline
     VSpeedDial: VSpeedDial
-    VSnackbarQueue: VSnackbarQueue
     VThemeProvider: VThemeProvider
-    VVirtualScroll: VVirtualScroll
     VValidation: VValidation
-    VDataIterator: VDataIterator
+    VVirtualScroll: VVirtualScroll
     VFabTransition: VFabTransition
     VDialogBottomTransition: VDialogBottomTransition
     VDialogTopTransition: VDialogTopTransition
@@ -93641,13 +93658,9 @@ declare module 'vue' {
     VExpandTransition: VExpandTransition
     VExpandXTransition: VExpandXTransition
     VDialogTransition: VDialogTransition
+    VRadioGroup: VRadioGroup
+    VTable: VTable
     VColorInput: VColorInput
-    VCalendar: VCalendar
-    VCalendarDay: VCalendarDay
-    VCalendarHeader: VCalendarHeader
-    VCalendarInterval: VCalendarInterval
-    VCalendarIntervalEvent: VCalendarIntervalEvent
-    VCalendarMonthDay: VCalendarMonthDay
     VFileUpload: VFileUpload
     VFileUploadItem: VFileUploadItem
     VIconBtn: VIconBtn
@@ -93656,6 +93669,13 @@ declare module 'vue' {
     VStepperVertical: VStepperVertical
     VStepperVerticalItem: VStepperVerticalItem
     VStepperVerticalActions: VStepperVerticalActions
+    VHotkey: VHotkey
+    VCalendar: VCalendar
+    VCalendarDay: VCalendarDay
+    VCalendarHeader: VCalendarHeader
+    VCalendarInterval: VCalendarInterval
+    VCalendarIntervalEvent: VCalendarIntervalEvent
+    VCalendarMonthDay: VCalendarMonthDay
     VDateInput: VDateInput
     VMaskInput: VMaskInput
     VPullToRefresh: VPullToRefresh

package/dist/vuetify.esm.js

@@ -1,5 +1,5 @@
 /*!
-* Vuetify v3.9.0-beta.1-dev.2025-06-26
+* Vuetify v3.9.0-beta.1-dev.2025-06-28
 * Forged by John Leider
 * Released under the MIT License.
 */
@@ -1832,7 +1832,18 @@ const aliases = {
   treeviewExpand: 'mdi-menu-right',
   eyeDropper: 'mdi-eyedropper',
   upload: 'mdi-cloud-upload',
-  color: 'mdi-palette'
+  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'
 };
 const mdi = {
   // Not using mergeProps here, functional components merge props by default (?)
@@ -2628,6 +2639,24 @@ var en = {
     exclude: 'The {0} character is not allowed',
     notEmpty: 'Please choose at least one value',
     pattern: 'Invalid format'
+  },
+  hotkey: {
+    then: 'then',
+    ctrl: 'Ctrl',
+    command: 'Command',
+    space: 'Space',
+    shift: 'Shift',
+    alt: 'Alt',
+    enter: 'Enter',
+    escape: 'Escape',
+    upArrow: 'Up Arrow',
+    downArrow: 'Down Arrow',
+    leftArrow: 'Left Arrow',
+    rightArrow: 'Right Arrow',
+    backspace: 'Backspace',
+    option: 'Option',
+    plus: 'plus',
+    shortcut: 'Keyboard shortcut: {0}'
   }
 };
 
@@ -18351,6 +18380,317 @@ function useDate() {
   return createInstance(options, locale);
 }
 
+/**
+ * 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.
+ */
+const keyAliasMap = {
+  // Modifier aliases (from vue-use, other libraries, and current implementation)
+  control: 'ctrl',
+  command: 'cmd',
+  option: 'alt',
+  // Arrow key aliases (common abbreviations)
+  up: 'arrowup',
+  down: 'arrowdown',
+  left: 'arrowleft',
+  right: 'arrowright',
+  // Other common key aliases
+  esc: 'escape',
+  spacebar: ' ',
+  space: ' ',
+  return: 'enter',
+  del: 'delete',
+  // Symbol aliases (existing from hotkey-parsing.ts)
+  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;
+}
+
+// Utilities
+
+/**
+ * Splits a single combination string into individual key parts.
+ *
+ * A combination is a set of keys that must be pressed simultaneously.
+ * e.g. `ctrl+k`, `shift--`
+ */
+function splitKeyCombination(combination) {
+  let isInternal = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  if (!combination) {
+    if (!isInternal) consoleWarn('Invalid hotkey combination: empty string provided');
+    return [];
+  }
+
+  // --- VALIDATION ---
+  const startsWithPlusOrUnderscore = combination.startsWith('+') || combination.startsWith('_');
+  const hasInvalidLeadingSeparator =
+  // Starts with a single '+' or '_' followed by a non-separator character (e.g. '+a', '_a')
+  startsWithPlusOrUnderscore && !(combination.startsWith('++') || combination.startsWith('__'));
+  const hasInvalidStructure =
+  // Invalid leading separator patterns
+  combination.length > 1 && hasInvalidLeadingSeparator ||
+  // Disallow literal + or _ keys (they require shift)
+  combination.includes('++') || combination.includes('__') || combination === '+' || combination === '_' ||
+  // Ends with a separator that is not part of a doubled literal
+  combination.length > 1 && (combination.endsWith('+') || combination.endsWith('_')) && combination.at(-2) !== combination.at(-1) ||
+  // Stand-alone doubled separators (dangling)
+  combination === '++' || combination === '--' || combination === '__';
+  if (hasInvalidStructure) {
+    if (!isInternal) consoleWarn(`Invalid hotkey combination: "${combination}" has invalid structure`);
+    return [];
+  }
+  const keys = [];
+  let buffer = '';
+  const flushBuffer = () => {
+    if (buffer) {
+      keys.push(normalizeKey(buffer));
+      buffer = '';
+    }
+  };
+  for (let i = 0; i < combination.length; i++) {
+    const char = combination[i];
+    const nextChar = combination[i + 1];
+    if (char === '+' || char === '_' || char === '-') {
+      if (char === nextChar) {
+        flushBuffer();
+        keys.push(char);
+        i++;
+      } else if (char === '+' || char === '_') {
+        flushBuffer();
+      } else {
+        buffer += char;
+      }
+    } else {
+      buffer += char;
+    }
+  }
+  flushBuffer();
+
+  // Within a combination, `-` is only valid as a literal key (e.g., `ctrl+-`).
+  // `-` cannot be part of a longer key name within a combination.
+  const hasInvalidMinus = keys.some(key => key.length > 1 && key.includes('-') && key !== '--');
+  if (hasInvalidMinus) {
+    if (!isInternal) consoleWarn(`Invalid hotkey combination: "${combination}" has invalid structure`);
+    return [];
+  }
+  if (keys.length === 0 && combination) {
+    return [normalizeKey(combination)];
+  }
+  return keys;
+}
+
+/**
+ * Splits a hotkey string into its constituent combination groups.
+ *
+ * A sequence is a series of combinations that must be pressed in order.
+ * e.g. `a-b`, `ctrl+k-p`
+ */
+function splitKeySequence(str) {
+  if (!str) {
+    consoleWarn('Invalid hotkey sequence: empty string provided');
+    return [];
+  }
+
+  // A sequence is invalid if it starts or ends with a separator,
+  // unless it is part of a combination (e.g., `shift+-`).
+  const hasInvalidStart = str.startsWith('-') && !['---', '--+'].includes(str);
+  const hasInvalidEnd = str.endsWith('-') && !str.endsWith('+-') && !str.endsWith('_-') && str !== '-' && str !== '---';
+  if (hasInvalidStart || hasInvalidEnd) {
+    consoleWarn(`Invalid hotkey sequence: "${str}" contains invalid combinations`);
+    return [];
+  }
+  const result = [];
+  let buffer = '';
+  let i = 0;
+  while (i < str.length) {
+    const char = str[i];
+    if (char === '-') {
+      // Determine if this hyphen is part of the current combination
+      const prevChar = str[i - 1];
+      const prevPrevChar = i > 1 ? str[i - 2] : undefined;
+      const precededBySinglePlusOrUnderscore = (prevChar === '+' || prevChar === '_') && prevPrevChar !== '+';
+      if (precededBySinglePlusOrUnderscore) {
+        // Treat as part of the combination (e.g., 'ctrl+-')
+        buffer += char;
+        i++;
+      } else {
+        // Treat as sequence separator
+        if (buffer) {
+          result.push(buffer);
+          buffer = '';
+        } else {
+          // Empty buffer means we have a literal '-' key
+          result.push('-');
+        }
+        i++;
+      }
+    } else {
+      buffer += char;
+      i++;
+    }
+  }
+
+  // Add final buffer if it exists
+  if (buffer) {
+    result.push(buffer);
+  }
+
+  // Collapse runs of '-' so that every second '-' is removed
+  const collapsed = [];
+  let minusCount = 0;
+  for (const part of result) {
+    if (part === '-') {
+      if (minusCount % 2 === 0) collapsed.push('-');
+      minusCount++;
+    } else {
+      minusCount = 0;
+      collapsed.push(part);
+    }
+  }
+
+  // Validate that each part of the sequence is a valid combination
+  const areAllValid = collapsed.every(s => splitKeyCombination(s, true).length > 0);
+  if (!areAllValid) {
+    consoleWarn(`Invalid hotkey sequence: "${str}" contains invalid combinations`);
+    return [];
+  }
+  return collapsed;
+}
+
+// Composables
+
+// Types
+
+function useHotkey(keys, callback) {
+  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  if (!IN_BROWSER) return function () {};
+  const {
+    event = 'keydown',
+    inputs = false,
+    preventDefault = true,
+    sequenceTimeout = 1000
+  } = options;
+  const isMac = navigator?.userAgent?.includes('Macintosh') ?? false;
+  let timeout = 0;
+  let keyGroups;
+  let isSequence = false;
+  let groupIndex = 0;
+  function clearTimer() {
+    if (!timeout) return;
+    clearTimeout(timeout);
+    timeout = 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;
+    clearTimer();
+  }
+  function handler(e) {
+    const group = keyGroups[groupIndex];
+    if (!group || isInputFocused()) return;
+    if (!matchesKeyGroup(e, group)) {
+      if (isSequence) resetSequence();
+      return;
+    }
+    if (toValue(preventDefault)) e.preventDefault();
+    if (!isSequence) {
+      callback(e);
+      return;
+    }
+    clearTimer();
+    groupIndex++;
+    if (groupIndex === keyGroups.length) {
+      callback(e);
+      resetSequence();
+      return;
+    }
+    timeout = window.setTimeout(resetSequence, toValue(sequenceTimeout));
+  }
+  function cleanup() {
+    window.removeEventListener(toValue(event), handler);
+    clearTimer();
+  }
+  watch(() => toValue(keys), function (unrefKeys) {
+    cleanup();
+    if (unrefKeys) {
+      const groups = splitKeySequence(unrefKeys.toLowerCase());
+      isSequence = groups.length > 1;
+      keyGroups = groups;
+      resetSequence();
+      window.addEventListener(toValue(event), handler);
+    }
+  }, {
+    immediate: true
+  });
+
+  // Watch for changes in the event type to re-register the listener
+  watch(() => toValue(event), function (newEvent, oldEvent) {
+    if (oldEvent && keyGroups && keyGroups.length > 0) {
+      window.removeEventListener(oldEvent, handler);
+      window.addEventListener(newEvent, handler);
+    }
+  });
+  try {
+    getCurrentInstance('useHotkey');
+    onBeforeUnmount(cleanup);
+  } catch {
+    // Not in Vue setup context
+  }
+  function parseKeyGroup(group) {
+    const MODIFIERS = ['ctrl', 'shift', 'alt', 'meta', 'cmd'];
+
+    // Use the shared combination splitting logic
+    const parts = splitKeyCombination(group.toLowerCase());
+
+    // If the combination is invalid, return empty result
+    if (parts.length === 0) {
+      return {
+        modifiers: Object.fromEntries(MODIFIERS.map(m => [m, false])),
+        actualKey: undefined
+      };
+    }
+    const modifiers = Object.fromEntries(MODIFIERS.map(m => [m, false]));
+    let actualKey;
+    for (const part of parts) {
+      if (MODIFIERS.includes(part)) {
+        modifiers[part] = true;
+      } else {
+        actualKey = part;
+      }
+    }
+    return {
+      modifiers,
+      actualKey
+    };
+  }
+  function matchesKeyGroup(e, group) {
+    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();
+  }
+  return cleanup;
+}
+
 // Types
 
 const makeVColorPickerProps = propsFactory({
@@ -30893,7 +31233,7 @@ function createVuetify$1() {
     };
   });
 }
-const version$1 = "3.9.0-beta.1-dev.2025-06-26";
+const version$1 = "3.9.0-beta.1-dev.2025-06-28";
 createVuetify$1.version = version$1;
 
 // Vue's inject() can only be used in setup
@@ -30918,8 +31258,8 @@ const createVuetify = function () {
     ...options
   });
 };
-const version = "3.9.0-beta.1-dev.2025-06-26";
+const version = "3.9.0-beta.1-dev.2025-06-28";
 createVuetify.version = version;
 
-export { index as blueprints, components, createVuetify, directives, useDate, useDefaults, useDisplay, useGoTo, useLayout, useLocale, useRtl, useTheme, version };
+export { index as blueprints, components, createVuetify, directives, useDate, useDefaults, useDisplay, useGoTo, useHotkey, useLayout, useLocale, useRtl, useTheme, version };
 //# sourceMappingURL=vuetify.esm.js.map