vuetify 3.9.0-beta.0 → 3.9.0

package/dist/vuetify-labs.esm.js

@@ -1,5 +1,5 @@
 /*!
-* Vuetify v3.9.0-beta.0
+* Vuetify v3.9.0
 * Forged by John Leider
 * Released under the MIT License.
 */
@@ -546,6 +546,10 @@ function ensureValidVNode(vnodes) {
     return child.type !== Fragment || ensureValidVNode(child.children);
   }) ? vnodes : null;
 }
+function renderSlot(slot, props, fallback) {
+  // TODO: check if slot returns elements: #18308
+  return slot?.(props) ?? fallback?.(props);
+}
 function defer(timeout, cb) {
   if (!IN_BROWSER || timeout === 0) {
     cb();
@@ -1620,6 +1624,40 @@ function isPotentiallyScrollable(el) {
   return ['scroll', 'auto'].includes(style.overflowY);
 }
 
+// Types
+
+function getIndentLines(_ref) {
+  let {
+    depth,
+    isLast,
+    isLastGroup,
+    leafLinks,
+    separateRoots,
+    parentIndentLines,
+    variant
+  } = _ref;
+  if (!parentIndentLines || !depth) {
+    return {
+      leaf: undefined,
+      node: undefined,
+      children: parentIndentLines
+    };
+  }
+  if (variant === 'simple') {
+    return {
+      leaf: [...parentIndentLines, 'line'],
+      node: [...parentIndentLines, 'line'],
+      children: [...parentIndentLines, 'line']
+    };
+  }
+  const isLastLeaf = isLast && (!isLastGroup || separateRoots || depth > 1);
+  return {
+    leaf: [...parentIndentLines, isLastLeaf ? 'last-leaf' : 'leaf', ...(leafLinks ? ['leaf-link'] : [])],
+    node: [...parentIndentLines, isLastLeaf ? 'last-leaf' : 'leaf'],
+    children: [...parentIndentLines, isLastLeaf ? 'none' : 'line']
+  };
+}
+
 function isFixedPosition(el) {
   while (el) {
     if (window.getComputedStyle(el).position === 'fixed') {
@@ -2141,6 +2179,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}'
   }
 };
 
@@ -4651,7 +4707,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 (?)
@@ -8793,7 +8860,7 @@ const independentSelectStrategy = mandatory => {
       selected.set(id, value ? 'on' : 'off');
       return selected;
     },
-    in: (v, children, parents) => {
+    in: (v, children, parents, disabled) => {
       const map = new Map();
       for (const id of v || []) {
         strategy.select({
@@ -8801,7 +8868,8 @@ const independentSelectStrategy = mandatory => {
           value: true,
           selected: map,
           children,
-          parents
+          parents,
+          disabled
         });
       }
       return map;
@@ -8833,9 +8901,9 @@ const independentSingleSelectStrategy = mandatory => {
         selected: singleSelected
       });
     },
-    in: (v, children, parents) => {
+    in: (v, children, parents, disabled) => {
       if (v?.length) {
-        return parentStrategy.in(v.slice(0, 1), children, parents);
+        return parentStrategy.in(v.slice(0, 1), children, parents, disabled);
       }
       return new Map();
     },
@@ -8901,23 +8969,32 @@ const classicSelectStrategy = mandatory => {
         value,
         selected,
         children,
-        parents
+        parents,
+        disabled
       } = _ref6;
       id = toRaw(id);
       const original = new Map(selected);
       const items = [id];
       while (items.length) {
         const item = items.shift();
-        selected.set(toRaw(item), value ? 'on' : 'off');
+        if (!disabled.has(item)) {
+          selected.set(toRaw(item), value ? 'on' : 'off');
+        }
         if (children.has(item)) {
           items.push(...children.get(item));
         }
       }
       let parent = toRaw(parents.get(id));
       while (parent) {
-        const childrenIds = children.get(parent);
-        const everySelected = childrenIds.every(cid => selected.get(toRaw(cid)) === 'on');
-        const noneSelected = childrenIds.every(cid => !selected.has(toRaw(cid)) || selected.get(toRaw(cid)) === 'off');
+        let everySelected = true;
+        let noneSelected = true;
+        for (const child of children.get(parent)) {
+          const cid = toRaw(child);
+          if (disabled.has(cid)) continue;
+          if (selected.get(cid) !== 'on') everySelected = false;
+          if (selected.has(cid) && selected.get(cid) !== 'off') noneSelected = false;
+          if (!everySelected && !noneSelected) break;
+        }
         selected.set(parent, everySelected ? 'on' : noneSelected ? 'off' : 'indeterminate');
         parent = toRaw(parents.get(parent));
       }
@@ -8934,7 +9011,7 @@ const classicSelectStrategy = mandatory => {
       }
       return selected;
     },
-    in: (v, children, parents) => {
+    in: (v, children, parents, disabled) => {
       let map = new Map();
       for (const id of v || []) {
         map = strategy.select({
@@ -8942,7 +9019,8 @@ const classicSelectStrategy = mandatory => {
           value: true,
           selected: map,
           children,
-          parents
+          parents,
+          disabled
         });
       }
       return map;
@@ -8989,8 +9067,9 @@ const emptyNested = {
   root: {
     register: () => null,
     unregister: () => null,
-    parents: ref(new Map()),
     children: ref(new Map()),
+    parents: ref(new Map()),
+    disabled: ref(new Set()),
     open: () => null,
     openOnSelect: () => null,
     activate: () => null,
@@ -9017,9 +9096,10 @@ const makeNestedProps = propsFactory({
 }, 'nested');
 const useNested = props => {
   let isUnmounted = false;
-  const children = ref(new Map());
-  const parents = ref(new Map());
-  const opened = useProxiedModel(props, 'opened', props.opened, v => new Set(v), v => [...v.values()]);
+  const children = shallowRef(new Map());
+  const parents = shallowRef(new Map());
+  const disabled = shallowRef(new Set());
+  const opened = useProxiedModel(props, 'opened', props.opened, v => new Set(Array.isArray(v) ? v.map(i => toRaw(i)) : v), v => [...v.values()]);
   const activeStrategy = computed(() => {
     if (typeof props.activeStrategy === 'object') return props.activeStrategy;
     if (typeof props.activeStrategy === 'function') return props.activeStrategy(props.mandatory);
@@ -9067,13 +9147,13 @@ const useNested = props => {
     }
   });
   const activated = useProxiedModel(props, 'activated', props.activated, v => activeStrategy.value.in(v, children.value, parents.value), v => activeStrategy.value.out(v, children.value, parents.value));
-  const selected = useProxiedModel(props, 'selected', props.selected, v => selectStrategy.value.in(v, children.value, parents.value), v => selectStrategy.value.out(v, children.value, parents.value));
+  const selected = useProxiedModel(props, 'selected', props.selected, v => selectStrategy.value.in(v, children.value, parents.value, disabled.value), v => selectStrategy.value.out(v, children.value, parents.value));
   onBeforeUnmount(() => {
     isUnmounted = true;
   });
   function getPath(id) {
     const path = [];
-    let parent = id;
+    let parent = toRaw(id);
     while (parent != null) {
       path.unshift(parent);
       parent = parents.value.get(parent);
@@ -9097,7 +9177,7 @@ const useNested = props => {
         }
         return arr;
       }),
-      register: (id, parentId, isGroup) => {
+      register: (id, parentId, isDisabled, isGroup) => {
         if (nodeIds.has(id)) {
           const path = getPath(id).map(String).join(' -> ');
           const newPath = getPath(parentId).concat(id).map(String).join(' -> ');
@@ -9107,6 +9187,7 @@ const useNested = props => {
           nodeIds.add(id);
         }
         parentId && id !== parentId && parents.value.set(id, parentId);
+        isDisabled && disabled.value.add(id);
         isGroup && children.value.set(id, []);
         if (parentId != null) {
           children.value.set(parentId, [...(children.value.get(parentId) || []), id]);
@@ -9116,6 +9197,7 @@ const useNested = props => {
         if (isUnmounted) return;
         nodeIds.delete(id);
         children.value.delete(id);
+        disabled.value.delete(id);
         const parent = parents.value.get(id);
         if (parent) {
           const list = children.value.get(parent) ?? [];
@@ -9165,6 +9247,7 @@ const useNested = props => {
           selected: new Map(selected.value),
           children: children.value,
           parents: parents.value,
+          disabled: disabled.value,
           event
         });
         newSelected && (selected.value = newSelected);
@@ -9207,16 +9290,17 @@ const useNested = props => {
       },
       children,
       parents,
+      disabled,
       getPath
     }
   };
   provide(VNestedSymbol, nested);
   return nested.root;
 };
-const useNestedItem = (id, isGroup) => {
+const useNestedItem = (id, isDisabled, isGroup) => {
   const parent = inject$1(VNestedSymbol, emptyNested);
   const uidSymbol = Symbol('nested item');
-  const computedId = computed(() => toValue(id) ?? uidSymbol);
+  const computedId = computed(() => toRaw(toValue(id)) ?? uidSymbol);
   const item = {
     ...parent,
     id: computedId,
@@ -9225,18 +9309,22 @@ const useNestedItem = (id, isGroup) => {
     isOpen: computed(() => parent.root.opened.value.has(computedId.value)),
     parent: computed(() => parent.root.parents.value.get(computedId.value)),
     activate: (activated, e) => parent.root.activate(computedId.value, activated, e),
-    isActivated: computed(() => parent.root.activated.value.has(toRaw(computedId.value))),
+    isActivated: computed(() => parent.root.activated.value.has(computedId.value)),
     select: (selected, e) => parent.root.select(computedId.value, selected, e),
-    isSelected: computed(() => parent.root.selected.value.get(toRaw(computedId.value)) === 'on'),
-    isIndeterminate: computed(() => parent.root.selected.value.get(toRaw(computedId.value)) === 'indeterminate'),
+    isSelected: computed(() => parent.root.selected.value.get(computedId.value) === 'on'),
+    isIndeterminate: computed(() => parent.root.selected.value.get(computedId.value) === 'indeterminate'),
     isLeaf: computed(() => !parent.root.children.value.get(computedId.value)),
     isGroupActivator: parent.isGroupActivator
   };
   onBeforeMount(() => {
-    !parent.isGroupActivator && parent.root.register(computedId.value, parent.id.value, isGroup);
+    if (!parent.isGroupActivator) {
+      parent.root.register(computedId.value, parent.id.value, toValue(isDisabled), isGroup);
+    }
   });
   onBeforeUnmount(() => {
-    !parent.isGroupActivator && parent.root.unregister(computedId.value);
+    if (!parent.isGroupActivator) {
+      parent.root.unregister(computedId.value);
+    }
   });
   isGroup && provide(VNestedSymbol, item);
   return item;
@@ -9268,6 +9356,7 @@ const makeVListGroupProps = propsFactory({
     type: IconValue,
     default: '$collapse'
   },
+  disabled: Boolean,
   expandIcon: {
     type: IconValue,
     default: '$expand'
@@ -9293,7 +9382,7 @@ const VListGroup = genericComponent()({
       isOpen,
       open,
       id: _id
-    } = useNestedItem(() => props.value, true);
+    } = useNestedItem(() => props.value, () => props.disabled, true);
     const id = computed(() => `v-list-group--id-${String(props.rawId ?? _id.value)}`);
     const list = useList();
     const {
@@ -9463,7 +9552,7 @@ const VListItem = genericComponent()({
       parent,
       openOnSelect,
       id: uid
-    } = useNestedItem(id, false);
+    } = useNestedItem(id, () => props.disabled, false);
     const list = useList();
     const isActive = computed(() => props.active !== false && (props.active || link.isActive?.value || (root.activatable.value ? isActivated.value : isSelected.value)));
     const isLink = toRef(() => props.link !== false && link.isLink.value);
@@ -9815,6 +9904,10 @@ const makeItemsProps = propsFactory({
     type: [Boolean, String, Array, Function],
     default: 'props'
   },
+  itemType: {
+    type: [Boolean, String, Array, Function],
+    default: 'type'
+  },
   returnObject: Boolean,
   valueComparator: Function
 }, 'list-items');
@@ -9822,6 +9915,7 @@ function transformItem$3(props, item) {
   const title = getPropertyFromItem(item, props.itemTitle, item);
   const value = getPropertyFromItem(item, props.itemValue, title);
   const children = getPropertyFromItem(item, props.itemChildren);
+  const type = getPropertyFromItem(item, props.itemType, 'item');
   const itemProps = props.itemProps === true ? typeof item === 'object' && item != null && !Array.isArray(item) ? 'children' in item ? omit(item, ['children']) : item : undefined : getPropertyFromItem(item, props.itemProps);
   const _props = {
     title,
@@ -9829,15 +9923,16 @@ function transformItem$3(props, item) {
     ...itemProps
   };
   return {
+    type,
     title: String(_props.title ?? ''),
     value: _props.value,
     props: _props,
-    children: Array.isArray(children) ? transformItems$3(props, children) : undefined,
+    children: type === 'item' && Array.isArray(children) ? transformItems$3(props, children) : undefined,
     raw: item
   };
 }
 function transformItems$3(props, items) {
-  const _props = pick(props, ['itemTitle', 'itemValue', 'itemChildren', 'itemProps', 'returnObject', 'valueComparator']);
+  const _props = pick(props, ['itemTitle', 'itemValue', 'itemChildren', 'itemProps', 'itemType', 'returnObject', 'valueComparator']);
   const array = [];
   for (const item of items) {
     array.push(transformItem$3(_props, item));
@@ -9879,7 +9974,7 @@ function useItems(props) {
     const _returnObject = props.returnObject;
     const hasValueComparator = !!props.valueComparator;
     const valueComparator = props.valueComparator || deepEqual;
-    const _props = pick(props, ['itemTitle', 'itemValue', 'itemChildren', 'itemProps', 'returnObject', 'valueComparator']);
+    const _props = pick(props, ['itemTitle', 'itemValue', 'itemChildren', 'itemProps', 'itemType', 'returnObject', 'valueComparator']);
     const returnValue = [];
     main: for (const v of value) {
       // When the model value is null, return an InternalItem
@@ -9941,7 +10036,7 @@ function useItems(props) {
 function transformItem$2(props, item) {
   const type = getPropertyFromItem(item, props.itemType, 'item');
   const title = isPrimitive(item) ? item : getPropertyFromItem(item, props.itemTitle);
-  const value = getPropertyFromItem(item, props.itemValue, undefined);
+  const value = isPrimitive(item) ? item : getPropertyFromItem(item, props.itemValue, undefined);
   const children = getPropertyFromItem(item, props.itemChildren);
   const itemProps = props.itemProps === true ? omit(item, ['children']) : getPropertyFromItem(item, props.itemProps);
   const _props = {
@@ -9999,10 +10094,6 @@ const makeVListProps = propsFactory({
   ...makeDensityProps(),
   ...makeDimensionProps(),
   ...makeElevationProps(),
-  itemType: {
-    type: String,
-    default: 'type'
-  },
   ...makeItemsProps(),
   ...makeRoundedProps(),
   ...makeTagProps(),
@@ -10423,7 +10514,7 @@ function connectedLocationStrategy(data, props, contentStyles) {
     });
     if (flipped.isFull) {
       const values = flipped.values();
-      if (deepEqual(values.at(-1), values.at(-3))) {
+      if (deepEqual(values.at(-1), values.at(-3)) && !deepEqual(values.at(-1), values.at(-2))) {
         // Flipping is causing a container resize loop
         return;
       }
@@ -12093,11 +12184,7 @@ const VField = genericComponent()({
         default: slots.loader
       }), hasPrepend && createElementVNode("div", {
         "key": "prepend",
-        "class": "v-field__prepend-inner",
-        "onMousedown": e => {
-          e.preventDefault();
-          e.stopPropagation();
-        }
+        "class": "v-field__prepend-inner"
       }, [props.prependInnerIcon && createVNode(InputIcon, {
         "key": "prepend-icon",
         "name": "prependInner",
@@ -12166,11 +12253,7 @@ const VField = genericComponent()({
         })]), [[vShow, props.dirty]])]
       }), hasAppend && createElementVNode("div", {
         "key": "append",
-        "class": "v-field__append-inner",
-        "onMousedown": e => {
-          e.preventDefault();
-          e.stopPropagation();
-        }
+        "class": "v-field__append-inner"
       }, [slots['append-inner']?.(slotProps.value), props.appendInnerIcon && createVNode(InputIcon, {
         "key": "append-icon",
         "name": "appendInner",
@@ -12281,7 +12364,7 @@ const VTextField = genericComponent()({
       if (!isFocused.value) focus();
       nextTick(() => {
         if (inputRef.value !== document.activeElement) {
-          inputRef.value?.focus();
+          nextTick(() => inputRef.value?.focus());
         }
       });
     }
@@ -12620,7 +12703,7 @@ function useVirtual(props, items) {
     raf = requestAnimationFrame(_calculateVisibleItems);
   }
   function _calculateVisibleItems() {
-    if (!containerRef.value || !viewportHeight.value) return;
+    if (!containerRef.value || !viewportHeight.value || !itemHeight.value) return;
     const scrollTop = lastScrollTop - markerOffset;
     const direction = Math.sign(scrollVelocity);
     const startPx = Math.max(0, scrollTop - BUFFER_PX);
@@ -13229,7 +13312,7 @@ const VSelect = genericComponent()({
                   key: item.value,
                   onClick: () => select(item, null)
                 });
-                if (item.raw.type === 'divider') {
+                if (item.type === 'divider') {
                   return slots.divider?.({
                     props: item.raw,
                     index
@@ -13237,7 +13320,7 @@ const VSelect = genericComponent()({
                     "key": `divider-${index}`
                   }), null);
                 }
-                if (item.raw.type === 'subheader') {
+                if (item.type === 'subheader') {
                   return slots.subheader?.({
                     props: item.raw,
                     index
@@ -13405,7 +13488,7 @@ function filterItems(items, query, options) {
     let match = -1;
     if ((query || customFiltersLength > 0) && !options?.noFilter) {
       if (typeof item === 'object') {
-        if (['divider', 'subheader'].includes(item.raw?.type)) {
+        if (item.type === 'divider' || item.type === 'subheader') {
           continue;
         }
         const filterKeys = keys || Object.keys(transformed);
@@ -13847,7 +13930,7 @@ const VAutocomplete = genericComponent()({
                   active: highlightFirst.value && index === 0 ? true : undefined,
                   onClick: () => select(item, null)
                 });
-                if (item.raw.type === 'divider') {
+                if (item.type === 'divider') {
                   return slots.divider?.({
                     props: item.raw,
                     index
@@ -13855,7 +13938,7 @@ const VAutocomplete = genericComponent()({
                     "key": `divider-${index}`
                   }), null);
                 }
-                if (item.raw.type === 'subheader') {
+                if (item.type === 'subheader') {
                   return slots.subheader?.({
                     props: item.raw,
                     index
@@ -15416,6 +15499,7 @@ const VCarousel = genericComponent()({
               }) : createVNode(VBtn, mergeProps(item, props), null);
             })]
           })]), props.progress && createVNode(VProgressLinear, {
+            "absolute": true,
             "class": "v-carousel__progress",
             "color": typeof props.progress === 'string' ? props.progress : undefined,
             "modelValue": (group.getItemIndex(model.value) + 1) / group.items.value.length * 100
@@ -17502,7 +17586,7 @@ function format(value, formatString, locale, formats) {
     case 'fullDate':
       options = {
         year: 'numeric',
-        month: 'long',
+        month: 'short',
         day: 'numeric'
       };
       break;
@@ -18080,6 +18164,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({
@@ -18626,7 +19021,7 @@ const VCombobox = genericComponent()({
                   active: highlightFirst.value && index === 0 ? true : undefined,
                   onClick: () => select(item, null)
                 });
-                if (item.raw.type === 'divider') {
+                if (item.type === 'divider') {
                   return slots.divider?.({
                     props: item.raw,
                     index
@@ -18634,7 +19029,7 @@ const VCombobox = genericComponent()({
                     "key": `divider-${index}`
                   }), null);
                 }
-                if (item.raw.type === 'subheader') {
+                if (item.type === 'subheader') {
                   return slots.subheader?.({
                     props: item.raw,
                     index
@@ -19508,7 +19903,8 @@ function sortItems(items, sortByItems, locale, options) {
 
       // Dates should be compared numerically
       if (sortA instanceof Date && sortB instanceof Date) {
-        return sortA.getTime() - sortB.getTime();
+        sortA = sortA.getTime();
+        sortB = sortB.getTime();
       }
       [sortA, sortB] = [sortA, sortB].map(s => s != null ? s.toString().toLocaleLowerCase() : s);
       if (sortA !== sortB) {
@@ -20217,10 +20613,15 @@ const VDataTableColumn = defineFunctionalComponent({
     type: String,
     default: 'start'
   },
-  fixed: Boolean,
+  fixed: {
+    type: [Boolean, String],
+    default: false
+  },
   fixedOffset: [Number, String],
+  fixedEndOffset: [Number, String],
   height: [Number, String],
   lastFixed: Boolean,
+  firstFixedEnd: Boolean,
   noPadding: Boolean,
   tag: String,
   width: [Number, String],
@@ -20231,11 +20632,13 @@ const VDataTableColumn = defineFunctionalComponent({
     slots
   } = _ref;
   const Tag = props.tag ?? 'td';
+  const fixedSide = typeof props.fixed === 'string' ? props.fixed : props.fixed ? 'start' : 'none';
   return createVNode(Tag, {
-    "tabindex": "0",
     "class": normalizeClass(['v-data-table__td', {
-      'v-data-table-column--fixed': props.fixed,
+      'v-data-table-column--fixed': fixedSide === 'start',
+      'v-data-table-column--fixed-end': fixedSide === 'end',
       'v-data-table-column--last-fixed': props.lastFixed,
+      'v-data-table-column--first-fixed-end': props.firstFixedEnd,
       'v-data-table-column--no-padding': props.noPadding,
       'v-data-table-column--nowrap': props.nowrap
     }, `v-data-table-column--align-${props.align}`]),
@@ -20243,7 +20646,8 @@ const VDataTableColumn = defineFunctionalComponent({
       height: convertToUnit(props.height),
       width: convertToUnit(props.width),
       maxWidth: convertToUnit(props.maxWidth),
-      left: convertToUnit(props.fixedOffset || null)
+      left: fixedSide === 'start' ? convertToUnit(props.fixedOffset || null) : undefined,
+      right: fixedSide === 'end' ? convertToUnit(props.fixedEndOffset || null) : undefined
     }
   }, {
     default: () => [slots.default?.()]
@@ -20340,20 +20744,28 @@ function getDepth(item) {
 }
 function parseFixedColumns(items) {
   let seenFixed = false;
-  function setFixed(item) {
-    let parentFixed = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  function setFixed(item, side) {
+    let parentFixedSide = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'none';
     if (!item) return;
-    if (parentFixed) {
-      item.fixed = true;
+    if (parentFixedSide !== 'none') {
+      item.fixed = parentFixedSide;
     }
-    if (item.fixed) {
-      if (item.children) {
-        for (let i = item.children.length - 1; i >= 0; i--) {
-          setFixed(item.children[i], true);
+
+    // normalize to simplify logic below
+    if (item.fixed === true) {
+      item.fixed = 'start';
+    }
+    const orderedChildren = side === 'start' ? item.children?.toReversed() : item.children;
+    if (item.fixed === side) {
+      if (orderedChildren) {
+        for (const child of orderedChildren) {
+          setFixed(child, side, side);
         }
       } else {
-        if (!seenFixed) {
+        if (!seenFixed && side === 'start') {
           item.lastFixed = true;
+        } else if (!seenFixed && side === 'end') {
+          item.firstFixedEnd = true;
         } else if (isNaN(Number(item.width))) {
           consoleError(`Multiple fixed columns should have a static width (key: ${item.key})`);
         } else {
@@ -20362,36 +20774,57 @@ function parseFixedColumns(items) {
         seenFixed = true;
       }
     } else {
-      if (item.children) {
-        for (let i = item.children.length - 1; i >= 0; i--) {
-          setFixed(item.children[i]);
+      if (orderedChildren) {
+        for (const child of orderedChildren) {
+          setFixed(child, side);
         }
       } else {
         seenFixed = false;
       }
     }
   }
-  for (let i = items.length - 1; i >= 0; i--) {
-    setFixed(items[i]);
+  for (const item of items.toReversed()) {
+    setFixed(item, 'start');
+  }
+  for (const item of items) {
+    setFixed(item, 'end');
   }
   function setFixedOffset(item) {
-    let fixedOffset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-    if (!item) return fixedOffset;
+    let offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    if (!item) return offset;
     if (item.children) {
-      item.fixedOffset = fixedOffset;
+      item.fixedOffset = offset;
       for (const child of item.children) {
-        fixedOffset = setFixedOffset(child, fixedOffset);
+        offset = setFixedOffset(child, offset);
       }
-    } else if (item.fixed) {
-      item.fixedOffset = fixedOffset;
-      fixedOffset += parseFloat(item.width || '0') || 0;
+    } else if (item.fixed && item.fixed !== 'end') {
+      item.fixedOffset = offset;
+      offset += parseFloat(item.width || '0') || 0;
     }
-    return fixedOffset;
+    return offset;
   }
   let fixedOffset = 0;
   for (const item of items) {
     fixedOffset = setFixedOffset(item, fixedOffset);
   }
+  function setFixedEndOffset(item) {
+    let offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    if (!item) return offset;
+    if (item.children) {
+      item.fixedEndOffset = offset;
+      for (const child of item.children) {
+        offset = setFixedEndOffset(child, offset);
+      }
+    } else if (item.fixed === 'end') {
+      item.fixedEndOffset = offset;
+      offset += parseFloat(item.width || '0') || 0;
+    }
+    return offset;
+  }
+  let fixedEndOffset = 0;
+  for (const item of items.toReversed()) {
+    fixedEndOffset = setFixedEndOffset(item, fixedEndOffset);
+  }
 }
 function parse(items, maxDepth) {
   const headers = [];
@@ -20524,7 +20957,6 @@ const makeVDataTableHeadersProps = propsFactory({
   color: String,
   disableSort: Boolean,
   fixedHeader: Boolean,
-  lastFixed: Boolean,
   multiSort: Boolean,
   sortAscIcon: {
     type: IconValue,
@@ -20571,11 +21003,12 @@ const VDataTableHeaders = genericComponent()({
       loaderClasses
     } = useLoader(props);
     function getFixedStyles(column, y) {
-      if (!(props.sticky || props.fixedHeader) && !(column.fixed || column.lastFixed)) return undefined;
+      if (!(props.sticky || props.fixedHeader) && !column.fixed) return undefined;
+      const fixedSide = typeof column.fixed === 'string' ? column.fixed : column.fixed ? 'start' : 'none';
       return {
         position: 'sticky',
-        left: column.fixed || column.lastFixed ? convertToUnit(column.fixedOffset) : undefined,
-        right: column.lastFixed ? convertToUnit(column.fixedOffset ?? 0) : undefined,
+        left: fixedSide === 'start' ? convertToUnit(column.fixedOffset) : undefined,
+        right: fixedSide === 'end' ? convertToUnit(column.fixedEndOffset) : undefined,
         top: props.sticky || props.fixedHeader ? `calc(var(--v-table-header-height) * ${y})` : undefined
       };
     }
@@ -20635,14 +21068,15 @@ const VDataTableHeaders = genericComponent()({
         },
         "colspan": column.colspan,
         "rowspan": column.rowspan,
-        "onClick": column.sortable ? () => toggleSort(column) : undefined,
         "fixed": column.fixed,
         "nowrap": column.nowrap,
         "lastFixed": column.lastFixed,
-        "noPadding": noPadding
-      }, headerProps, {
-        "onKeydown": event => column.sortable && handleEnterKeyPress(event, column)
-      }), {
+        "firstFixedEnd": column.firstFixedEnd,
+        "noPadding": noPadding,
+        "tabindex": column.sortable ? 0 : undefined,
+        "onClick": column.sortable ? () => toggleSort(column) : undefined,
+        "onKeydown": column.sortable ? event => handleEnterKeyPress(event, column) : undefined
+      }, headerProps), {
         default: () => {
           const columnSlotName = `header.${column.key}`;
           const columnSlotProps = {
@@ -20918,7 +21352,9 @@ const VDataTableRow = genericComponent()({
         },
         "fixed": column.fixed,
         "fixedOffset": column.fixedOffset,
+        "fixedEndOffset": column.fixedEndOffset,
         "lastFixed": column.lastFixed,
+        "firstFixedEnd": column.firstFixedEnd,
         "maxWidth": !mobile.value ? column.maxWidth : undefined,
         "noPadding": column.key === 'data-table-select' || column.key === 'data-table-expand',
         "nowrap": column.nowrap,
@@ -22328,10 +22764,9 @@ function useCalendar(props) {
     const date = adapter.setYear(adapter.startOfMonth(adapter.date()), adapter.getYear(year.value));
     return adapter.setMonth(date, value);
   }, v => adapter.getMonth(v));
-  const weekDays = computed(() => {
+  const weekdayLabels = computed(() => {
     const firstDayOfWeek = adapter.toJsDate(adapter.startOfWeek(adapter.date(), props.firstDayOfWeek)).getDay();
-    // Always generate all days, regardless of props.weekdays
-    return [0, 1, 2, 3, 4, 5, 6].map(day => (day + firstDayOfWeek) % 7);
+    return adapter.getWeekdays(props.firstDayOfWeek, props.weekdayFormat).filter((_, i) => props.weekdays.includes((i + firstDayOfWeek) % 7));
   });
   const weeksInMonth = computed(() => {
     const weeks = adapter.getWeekArray(month.value, props.firstDayOfWeek);
@@ -22355,13 +22790,14 @@ function useCalendar(props) {
   });
   function genDays(days, today) {
     return days.filter(date => {
-      return weekDays.value.includes(adapter.toJsDate(date).getDay());
+      return props.weekdays.includes(adapter.toJsDate(date).getDay());
     }).map((date, index) => {
       const isoDate = adapter.toISO(date);
       const isAdjacent = !adapter.isSameMonth(date, month.value);
       const isStart = adapter.isSameDay(date, adapter.startOfMonth(month.value));
       const isEnd = adapter.isSameDay(date, adapter.endOfMonth(month.value));
       const isSame = adapter.isSameDay(date, month.value);
+      const weekdaysCount = props.weekdays.length;
       return {
         date,
         formatted: adapter.format(date, 'keyboardDate'),
@@ -22373,8 +22809,8 @@ function useCalendar(props) {
         isSelected: model.value.some(value => adapter.isSameDay(date, value)),
         isStart,
         isToday: adapter.isSameDay(date, today),
-        isWeekEnd: index % 7 === 6,
-        isWeekStart: index % 7 === 0,
+        isWeekEnd: index % weekdaysCount === weekdaysCount - 1,
+        isWeekStart: index % weekdaysCount === 0,
         isoDate,
         localized: adapter.format(date, 'dayOfMonth'),
         month: adapter.getMonth(date),
@@ -22412,7 +22848,7 @@ function useCalendar(props) {
     if (typeof props.allowedDates === 'function') {
       return !props.allowedDates(date);
     }
-    return !props.weekdays.includes(adapter.toJsDate(date).getDay());
+    return false;
   }
   return {
     displayValue,
@@ -22421,7 +22857,7 @@ function useCalendar(props) {
     genDays,
     model,
     weeksInMonth,
-    weekDays,
+    weekdayLabels,
     weekNumbers
   };
 }
@@ -22460,7 +22896,8 @@ const VDatePickerMonth = genericComponent()({
     const {
       daysInMonth,
       model,
-      weekNumbers
+      weekNumbers,
+      weekdayLabels
     } = useCalendar(props);
     const adapter = useDate();
     const rangeStart = shallowRef();
@@ -22532,7 +22969,10 @@ const VDatePickerMonth = genericComponent()({
       }
     }
     useRender(() => createElementVNode("div", {
-      "class": "v-date-picker-month"
+      "class": "v-date-picker-month",
+      "style": {
+        '--v-date-picker-days-in-week': props.weekdays.length
+      }
     }, [props.showWeek && createElementVNode("div", {
       "key": "weeks",
       "class": "v-date-picker-month__weeks"
@@ -22548,7 +22988,7 @@ const VDatePickerMonth = genericComponent()({
         "ref": daysRef,
         "key": daysInMonth.value[0].date?.toString(),
         "class": "v-date-picker-month__days"
-      }, [!props.hideWeekdays && adapter.getWeekdays(props.firstDayOfWeek, props.weekdayFormat).map(weekDay => createElementVNode("div", {
+      }, [!props.hideWeekdays && weekdayLabels.value.map(weekDay => createElementVNode("div", {
         "class": normalizeClass(['v-date-picker-month__day', 'v-date-picker-month__weekday'])
       }, [weekDay])), daysInMonth.value.map((item, i) => {
         const slotProps = {
@@ -22931,7 +23371,8 @@ const VDatePicker = genericComponent()({
     }
     function allowedMonths(month) {
       if (typeof props.allowedDates === 'function') {
-        const startOfMonth = adapter.parseISO(`${year.value}-${month + 1}-01`);
+        const monthTwoDigits = String(month + 1).padStart(2, '0');
+        const startOfMonth = adapter.parseISO(`${year.value}-${monthTwoDigits}-01`);
         return isAllowedInRange(startOfMonth, adapter.endOfMonth(startOfMonth));
       }
       if (Array.isArray(props.allowedDates) && props.allowedDates.length) {
@@ -25228,6 +25669,8 @@ function useHold(_ref) {
   function holdStart(value) {
     holdStop();
     tick(value);
+    window.addEventListener('pointerup', holdStop);
+    document.addEventListener('blur', holdStop);
     timeout = window.setTimeout(() => {
       interval = window.setInterval(() => tick(value), HOLD_REPEAT);
     }, HOLD_DELAY);
@@ -25235,6 +25678,8 @@ function useHold(_ref) {
   function holdStop() {
     window.clearTimeout(timeout);
     window.clearInterval(interval);
+    window.removeEventListener('pointerup', holdStop);
+    document.removeEventListener('blur', holdStop);
   }
   function tick(value) {
     toggleUpDown(value === 'up');
@@ -25370,7 +25815,7 @@ const VNumberInput = genericComponent()({
         onClick: onControlClick,
         onPointerup: onControlMouseup,
         onPointerdown: onUpControlMousedown,
-        onPointercancel: onControlPointerCancel
+        onPointercancel: onControlMouseup
       }
     };
     const decrementSlotProps = {
@@ -25378,7 +25823,7 @@ const VNumberInput = genericComponent()({
         onClick: onControlClick,
         onPointerup: onControlMouseup,
         onPointerdown: onDownControlMousedown,
-        onPointercancel: onControlPointerCancel
+        onPointercancel: onControlMouseup
       }
     };
     watch(() => props.precision, () => formatInputValue());
@@ -25459,7 +25904,6 @@ const VNumberInput = genericComponent()({
       const el = e.currentTarget;
       el?.releasePointerCapture(e.pointerId);
       e.preventDefault();
-      e.stopPropagation();
       holdStop();
     }
     function onUpControlMousedown(e) {
@@ -25476,11 +25920,6 @@ const VNumberInput = genericComponent()({
       e.stopPropagation();
       holdStart('down');
     }
-    function onControlPointerCancel(e) {
-      const el = e.currentTarget;
-      el?.releasePointerCapture(e.pointerId);
-      holdStop();
-    }
     function clampModel() {
       if (controlsDisabled.value) return;
       if (!vTextFieldRef.value) return;
@@ -25527,7 +25966,7 @@ const VNumberInput = genericComponent()({
           "onClick": onControlClick,
           "onPointerdown": onUpControlMousedown,
           "onPointerup": onControlMouseup,
-          "onPointercancel": onControlPointerCancel,
+          "onPointercancel": onControlMouseup,
           "size": controlNodeSize.value,
           "tabindex": "-1"
         }, null) : createVNode(VDefaultsProvider, {
@@ -25557,7 +25996,7 @@ const VNumberInput = genericComponent()({
           "onClick": onControlClick,
           "onPointerdown": onDownControlMousedown,
           "onPointerup": onControlMouseup,
-          "onPointercancel": onControlPointerCancel,
+          "onPointercancel": onControlMouseup,
           "size": controlNodeSize.value,
           "tabindex": "-1"
         }, null) : createVNode(VDefaultsProvider, {
@@ -25704,19 +26143,21 @@ const VOtpInput = genericComponent()({
     const contentRef = ref();
     const inputRef = ref([]);
     const current = computed(() => inputRef.value[focusIndex.value]);
-    const intersectScope = effectScope();
-    intersectScope.run(() => {
-      const {
-        intersectionRef,
-        isIntersecting
-      } = useIntersectionObserver();
-      watch(isIntersecting, v => {
-        if (!v) return;
-        intersectionRef.value?.focus();
-        intersectScope.stop();
-      });
-      watchEffect(() => {
-        intersectionRef.value = inputRef.value[0];
+    useToggleScope(() => props.autofocus, () => {
+      const intersectScope = effectScope();
+      intersectScope.run(() => {
+        const {
+          intersectionRef,
+          isIntersecting
+        } = useIntersectionObserver();
+        watchEffect(() => {
+          intersectionRef.value = inputRef.value[0];
+        });
+        watch(isIntersecting, v => {
+          if (!v) return;
+          intersectionRef.value?.focus();
+          intersectScope.stop();
+        });
       });
     });
     function onInput() {
@@ -29727,6 +30168,8 @@ const VTreeviewSymbol = Symbol.for('vuetify:v-treeview');
 
 const makeVTreeviewItemProps = propsFactory({
   loading: Boolean,
+  hideActions: Boolean,
+  indentLines: Array,
   toggleIcon: IconValue,
   ...makeVListItemProps({
     slim: true
@@ -29762,23 +30205,31 @@ const VTreeviewItem = genericComponent()({
       emit('toggleExpand', e);
     }
     useRender(() => {
-      const listItemProps = omit(VListItem.filterProps(props), ['onClick']);
-      const hasPrepend = slots.prepend || props.toggleIcon;
+      const listItemProps = VListItem.filterProps(props);
+      const hasPrepend = slots.prepend || props.toggleIcon || props.indentLines;
       return createVNode(VListItem, mergeProps({
         "ref": vListItemRef
       }, listItemProps, {
-        "active": vListItemRef.value?.isActivated,
+        "active": vListItemRef.value?.isActivated || undefined,
         "class": ['v-treeview-item', {
           'v-treeview-item--activatable-group-activator': isActivatableGroupActivator.value,
           'v-treeview-item--filtered': isFiltered.value
         }, props.class],
         "ripple": false,
-        "onClick": props.onClick ?? activateGroupActivator
+        "onClick": activateGroupActivator
       }), {
         ...slots,
         prepend: hasPrepend ? slotProps => {
-          return createElementVNode(Fragment, null, [createVNode(VListItemAction, {
-            "start": false
+          return createElementVNode(Fragment, null, [props.indentLines && props.indentLines.length > 0 ? createElementVNode("div", {
+            "key": "indent-lines",
+            "class": "v-treeview-indent-lines",
+            "style": {
+              '--v-indent-parts': props.indentLines.length
+            }
+          }, [props.indentLines.map(type => createElementVNode("div", {
+            "class": normalizeClass(`v-treeview-indent-line v-treeview-indent-line--${type}`)
+          }, null))]) : '', !props.hideActions && createVNode(VListItemAction, {
+            "start": true
           }, {
             default: () => [props.toggleIcon ? createVNode(VBtn, {
               "density": "compact",
@@ -29787,13 +30238,11 @@ const VTreeviewItem = genericComponent()({
               "variant": "text",
               "onClick": onClickAction
             }, {
-              loader() {
-                return createVNode(VProgressCircular, {
-                  "indeterminate": "disable-shrink",
-                  "size": "20",
-                  "width": "2"
-                }, null);
-              }
+              loader: () => createVNode(VProgressCircular, {
+                "indeterminate": "disable-shrink",
+                "size": "20",
+                "width": "2"
+              }, null)
             }) : createElementVNode("div", {
               "class": "v-treeview-item__level"
             }, null)]
@@ -29801,7 +30250,7 @@ const VTreeviewItem = genericComponent()({
         } : undefined
       });
     });
-    return {};
+    return forwardRefs({}, vListItemRef);
   }
 });
 
@@ -29826,14 +30275,20 @@ const makeVTreeviewChildrenProps = propsFactory({
   falseIcon: IconValue,
   trueIcon: IconValue,
   returnObject: Boolean,
+  activatable: Boolean,
   selectable: Boolean,
   selectedColor: String,
   selectStrategy: [String, Function, Object],
   index: Number,
+  isLastGroup: Boolean,
+  separateRoots: Boolean,
+  parentIndentLines: Array,
+  indentLinesVariant: String,
   path: {
     type: Array,
     default: () => []
   },
+  ...pick(makeVTreeviewItemProps(), ['hideActions']),
   ...makeDensityProps()
 }, 'VTreeviewChildren');
 const VTreeviewChildren = genericComponent()({
@@ -29844,7 +30299,8 @@ const VTreeviewChildren = genericComponent()({
       slots
     } = _ref;
     const isLoading = reactive(new Set());
-    const isClickOnOpen = computed(() => !props.disabled && (props.openOnClick != null ? props.openOnClick : props.selectable));
+    const activatorItems = ref([]);
+    const isClickOnOpen = computed(() => !props.disabled && (props.openOnClick != null ? props.openOnClick : props.selectable && !props.activatable));
     async function checkChildren(item) {
       try {
         if (!props.items?.length || !props.loadChildren) return;
@@ -29858,22 +30314,35 @@ const VTreeviewChildren = genericComponent()({
     }
     function selectItem(select, isSelected) {
       if (props.selectable) {
-        select(!isSelected);
+        select(isSelected);
       }
     }
-    return () => slots.default?.() ?? props.items?.map((item, index) => {
+    return () => slots.default?.() ?? props.items?.map((item, index, items) => {
       const {
         children,
         props: itemProps
       } = item;
       const loading = isLoading.has(item.value);
+      const nextItemHasChildren = !!items.at(index + 1)?.children;
+      const depth = props.path?.length ?? 0;
+      const isLast = items.length - 1 === index;
       const treeItemProps = {
         index,
-        depth: props.path?.length ?? 0,
+        depth,
         isFirst: index === 0,
-        isLast: props.items ? props.items.length - 1 === index : false,
-        path: [...props.path, index]
+        isLast,
+        path: [...props.path, index],
+        hideAction: props.hideActions
       };
+      const indentLines = getIndentLines({
+        depth,
+        isLast,
+        isLastGroup: props.isLastGroup,
+        leafLinks: !props.hideActions,
+        separateRoots: props.separateRoots,
+        parentIndentLines: props.parentIndentLines,
+        variant: props.indentLinesVariant
+      });
       const slotsWithItem = {
         prepend: slotProps => createElementVNode(Fragment, null, [props.selectable && (!children || children && !['leaf', 'single-leaf'].includes(props.selectStrategy)) && createElementVNode("div", null, [createVNode(VCheckboxBtn, {
           "key": item.value,
@@ -29886,7 +30355,8 @@ const VTreeviewChildren = genericComponent()({
           "indeterminateIcon": props.indeterminateIcon,
           "falseIcon": props.falseIcon,
           "trueIcon": props.trueIcon,
-          "onClick": withModifiers(() => selectItem(slotProps.select, slotProps.isSelected), ['stop']),
+          "onUpdate:modelValue": v => selectItem(slotProps.select, v),
+          "onClick": e => e.stopPropagation(),
           "onKeydown": e => {
             if (!['Enter', 'Space'].includes(e.key)) return;
             e.stopPropagation();
@@ -29933,24 +30403,45 @@ const VTreeviewChildren = genericComponent()({
             ...activatorProps,
             value: itemProps?.value,
             onToggleExpand: [() => checkChildren(item), activatorProps.onClick],
-            onClick: isClickOnOpen.value ? [() => checkChildren(item), activatorProps.onClick] : undefined
+            onClick: isClickOnOpen.value ? [() => checkChildren(item), activatorProps.onClick] : () => selectItem(activatorItems.value[index]?.select, !activatorItems.value[index]?.isSelected)
           };
-          return createVNode(VTreeviewItem, mergeProps(listItemProps, {
+          return createVNode(VTreeviewItem, mergeProps({
+            "ref": el => activatorItems.value[index] = el
+          }, listItemProps, {
+            "hideActions": props.hideActions,
+            "indentLines": indentLines.node,
             "value": props.returnObject ? item.raw : itemProps.value,
             "loading": loading
           }), slotsWithItem);
         },
         default: () => createVNode(VTreeviewChildren, mergeProps(treeviewChildrenProps, {
           "items": children,
+          "indentLinesVariant": props.indentLinesVariant,
+          "parentIndentLines": indentLines.children,
+          "isLastGroup": nextItemHasChildren,
           "returnObject": props.returnObject
         }), slots)
-      }) : slots.item?.({
+      }) : renderSlot(slots.item, {
         props: itemProps,
         item: item.raw,
         internalItem: item
-      }) ?? createVNode(VTreeviewItem, mergeProps(itemProps, {
-        "value": props.returnObject ? toRaw(item.raw) : itemProps.value
-      }), slotsWithItem);
+      }, () => {
+        if (item.type === 'divider') {
+          return renderSlot(slots.divider, {
+            props: item.raw
+          }, () => createVNode(VDivider, item.props, null));
+        }
+        if (item.type === 'subheader') {
+          return renderSlot(slots.subheader, {
+            props: item.raw
+          }, () => createVNode(VListSubheader, item.props, null));
+        }
+        return createVNode(VTreeviewItem, mergeProps(itemProps, {
+          "hideActions": props.hideActions,
+          "indentLines": indentLines.leaf,
+          "value": props.returnObject ? toRaw(item.raw) : itemProps.value
+        }), slotsWithItem);
+      });
     });
   }
 });
@@ -29966,20 +30457,18 @@ function flatten(items) {
 const makeVTreeviewProps = propsFactory({
   fluid: Boolean,
   openAll: Boolean,
+  indentLines: [Boolean, String],
   search: String,
   ...makeFilterProps({
     filterKeys: ['title']
   }),
-  ...omit(makeVTreeviewChildrenProps(), ['index', 'path']),
+  ...omit(makeVTreeviewChildrenProps(), ['index', 'path', 'indentLinesVariant', 'parentIndentLines', 'isLastGroup']),
   ...omit(makeVListProps({
     collapseIcon: '$treeviewCollapse',
     expandIcon: '$treeviewExpand',
     slim: true
-  }), ['itemType', 'nav', 'openStrategy']),
-  modelValue: {
-    type: Array,
-    default: () => []
-  }
+  }), ['nav', 'openStrategy']),
+  modelValue: Array
 }, 'VTreeview');
 const VTreeview = genericComponent()({
   name: 'VTreeview',
@@ -29994,7 +30483,8 @@ const VTreeview = genericComponent()({
   },
   setup(props, _ref) {
     let {
-      slots
+      slots,
+      emit
     } = _ref;
     const {
       items
@@ -30003,13 +30493,12 @@ const VTreeview = genericComponent()({
     const baseColor = toRef(() => props.baseColor);
     const color = toRef(() => props.color);
     const activated = useProxiedModel(props, 'activated');
-    const model = useProxiedModel(props, 'modelValue');
-    const _selected = useProxiedModel(props, 'selected', props.modelValue);
+    const _selected = useProxiedModel(props, 'selected');
     const selected = computed({
-      get: () => _selected.value,
+      get: () => props.modelValue ?? _selected.value,
       set(val) {
         _selected.value = val;
-        model.value = val;
+        emit('update:modelValue', val);
       }
     });
     const vListRef = ref();
@@ -30075,6 +30564,7 @@ const VTreeview = genericComponent()({
     useRender(() => {
       const listProps = VList.filterProps(props);
       const treeviewChildrenProps = VTreeviewChildren.filterProps(props);
+      const indentLinesVariant = typeof props.indentLines === 'boolean' ? 'default' : props.indentLines;
       return createVNode(VList, mergeProps({
         "ref": vListRef
       }, listProps, {
@@ -30092,7 +30582,9 @@ const VTreeview = genericComponent()({
         default: () => [createVNode(VTreeviewChildren, mergeProps(treeviewChildrenProps, {
           "density": props.density,
           "returnObject": props.returnObject,
-          "items": items.value
+          "items": items.value,
+          "parentIndentLines": props.indentLines ? [] : undefined,
+          "indentLinesVariant": indentLinesVariant
         }), slots)]
       });
     });
@@ -30181,7 +30673,7 @@ const VCalendarIntervalEvent = genericComponent()({
       }
     };
     useRender(() => {
-      return createElementVNode("div", null, [slots.intervalEvent?.({
+      return createElementVNode("div", null, [slots['interval-event']?.({
         height: calcHeight().height,
         margin: calcHeight().margin,
         eventClass: 'v-calendar-internal-event',
@@ -30278,13 +30770,13 @@ const VCalendarInterval = genericComponent()({
         "style": normalizeStyle(`height: ${convertToUnit(props.intervalHeight)}`)
       }, [createElementVNode("div", mergeProps({
         "class": "v-calendar-day__row-label"
-      }, getPrefixedEventHandlers(attrs, ':time', () => props)), [slots.intervalTitle?.({
+      }, getPrefixedEventHandlers(attrs, ':time', () => props)), [slots['interval-title']?.({
         interval: interval.value
       }) ?? (props.index ? props.intervalFormat ? typeof props.intervalFormat === 'string' ? adapter.format(interval.value.start, 'hours12h') : props.intervalFormat(interval.value) : interval.value.label : '12 AM')]), createElementVNode("div", {
         "class": "v-calendar-day__row-hairline"
       }, null), createElementVNode("div", mergeProps({
         "class": ['v-calendar-day__row-content', interval.value.events.some(e => !e.last) ? 'v-calendar-day__row-content-through' : '']
-      }, getPrefixedEventHandlers(attrs, ':interval', () => interval.value)), [slots.intervalBody?.({
+      }, getPrefixedEventHandlers(attrs, ':interval', () => interval.value)), [slots['interval-body']?.({
         interval: interval.value
       }) ?? createElementVNode("div", null, [interval.value.events?.map(event => createVNode(VCalendarIntervalEvent, mergeProps({
         "event": event,
@@ -30293,8 +30785,8 @@ const VCalendarInterval = genericComponent()({
         "intervalDuration": props.intervalDuration,
         "intervalHeight": props.intervalHeight
       }, attrs), {
-        ...(slots.intervalEvent ? {
-          intervalEvent: _ref2 => {
+        ...(slots['interval-event'] ? {
+          'interval-event': _ref2 => {
             let {
               height,
               margin,
@@ -30302,7 +30794,7 @@ const VCalendarInterval = genericComponent()({
               event,
               interval
             } = _ref2;
-            return slots.intervalEvent?.({
+            return slots['interval-event']?.({
               height,
               margin,
               eventClass,
@@ -30316,7 +30808,7 @@ const VCalendarInterval = genericComponent()({
         "style": normalizeStyle(`height: ${convertToUnit(props.intervalHeight)}`)
       }, [createElementVNode("div", mergeProps({
         "class": ['v-calendar-day__row-content', interval.value.events.some(e => !e.last) ? 'v-calendar-day__row-content-through' : '']
-      }, getPrefixedEventHandlers(attrs, ':interval', () => interval.value)), [slots.intervalBody?.({
+      }, getPrefixedEventHandlers(attrs, ':interval', () => interval.value)), [slots['interval-body']?.({
         interval: interval.value
       }) ?? interval.value.events?.map(event => createVNode(VCalendarIntervalEvent, mergeProps({
         "event": event,
@@ -30325,8 +30817,8 @@ const VCalendarInterval = genericComponent()({
         "intervalDuration": props.intervalDuration,
         "intervalHeight": props.intervalHeight
       }, attrs), {
-        ...(slots.intervalEvent ? {
-          intervalEvent: _ref3 => {
+        ...(slots['interval-event'] ? {
+          'interval-event': _ref3 => {
             let {
               height,
               margin,
@@ -30334,7 +30826,7 @@ const VCalendarInterval = genericComponent()({
               event,
               interval
             } = _ref3;
-            return slots.intervalEvent?.({
+            return slots['interval-event']?.({
               height,
               margin,
               eventClass,
@@ -30389,7 +30881,7 @@ const VCalendarDay = genericComponent()({
       }), null)])]), intervals.value.map((_, index) => slots.interval?.(calendarIntervalProps) ?? createVNode(VCalendarInterval, mergeProps({
         "index": index
       }, calendarIntervalProps, attrs, getPrefixedEventHandlers(attrs, ':interval', () => calendarIntervalProps)), {
-        ...pick(slots, ['intervalBody', 'intervalEvent', 'intervalTitle'])
+        ...pick(slots, ['interval-body', 'interval-event', 'interval-title'])
       }))]);
     });
     return {
@@ -30533,7 +31025,7 @@ const VCalendarMonthDay = genericComponent()({
       }, getPrefixedEventHandlers(attrs, ':day', () => props)), [!props.day?.isHidden ? createElementVNode("div", {
         "key": "title",
         "class": "v-calendar-weekly__day-label"
-      }, [slots.dayTitle?.({
+      }, [slots['day-title']?.({
         title: props.title
       }) ?? createVNode(VBtn, mergeProps({
         "class": props.day?.isToday ? 'v-calendar-weekly__day-label__today' : undefined,
@@ -30546,12 +31038,12 @@ const VCalendarMonthDay = genericComponent()({
       }, getPrefixedEventHandlers(attrs, ':date', () => props)), null)]) : undefined, !props.day?.isHidden ? createElementVNode("div", {
         "key": "content",
         "class": "v-calendar-weekly__day-content"
-      }, [slots.dayBody?.({
+      }, [slots['day-body']?.({
         day: props.day,
         events: props.events
       }) ?? createElementVNode("div", null, [createElementVNode("div", {
         "class": "v-calendar-weekly__day-alldayevents-container"
-      }, [props.events?.filter(event => event.allDay).map(event => slots.dayEvent ? slots.dayEvent({
+      }, [props.events?.filter(event => event.allDay).map(event => slots['day-event'] ? slots['day-event']({
         day: props.day,
         allDay: true,
         event
@@ -30561,7 +31053,7 @@ const VCalendarMonthDay = genericComponent()({
         "allDay": true
       }, attrs), null))]), createElementVNode("div", {
         "class": "v-calendar-weekly__day-events-container"
-      }, [props.events?.filter(event => !event.allDay).map(event => slots.dayEvent ? slots.dayEvent({
+      }, [props.events?.filter(event => !event.allDay).map(event => slots['day-event'] ? slots['day-event']({
         day: props.day,
         event,
         allDay: false
@@ -30606,9 +31098,8 @@ const VCalendar = genericComponent()({
       model,
       displayValue,
       weekNumbers,
-      weekDays
+      weekdayLabels
     } = useCalendar(props);
-    const dayNames = adapter.getWeekdays();
     function onClickNext() {
       if (props.viewMode === 'month') {
         model.value = [adapter.addMonths(displayValue.value, 1)];
@@ -30646,6 +31137,7 @@ const VCalendar = genericComponent()({
     useRender(() => {
       const calendarDayProps = VCalendarDay.filterProps(props);
       const calendarHeaderProps = VCalendarHeader.filterProps(props);
+      const weekdaysCount = daysInWeek.value.length;
       return createElementVNode("div", {
         "class": normalizeClass(['v-calendar', {
           'v-calendar-monthly': props.viewMode === 'month',
@@ -30667,25 +31159,25 @@ const VCalendar = genericComponent()({
       }), {
         title: slots.title
       }))]), createElementVNode("div", {
-        "class": normalizeClass(['v-calendar__container', `days__${weekDays.value.length}`])
+        "class": normalizeClass(['v-calendar__container', `days__${weekdaysCount}`])
       }, [props.viewMode === 'month' && !props.hideDayHeader && createElementVNode("div", {
-        "class": normalizeClass(['v-calendar-weekly__head', `days__${weekDays.value.length}`, ...(!props.hideWeekNumber ? ['v-calendar-weekly__head-weeknumbers'] : [])]),
+        "class": normalizeClass(['v-calendar-weekly__head', `days__${weekdaysCount}`, ...(!props.hideWeekNumber ? ['v-calendar-weekly__head-weeknumbers'] : [])]),
         "key": "calendarWeeklyHead"
       }, [!props.hideWeekNumber ? createElementVNode("div", {
         "key": "weekNumber0",
         "class": "v-calendar-weekly__head-weeknumber"
-      }, null) : '', weekDays.value.map(weekday => createElementVNode("div", {
+      }, null) : '', weekdayLabels.value.map(weekday => createElementVNode("div", {
         "class": normalizeClass(`v-calendar-weekly__head-weekday${!props.hideWeekNumber ? '-with-weeknumber' : ''}`)
-      }, [dayNames[weekday]]))]), props.viewMode === 'month' && createElementVNode("div", {
+      }, [weekday]))]), props.viewMode === 'month' && createElementVNode("div", {
         "key": "VCalendarMonth",
-        "class": normalizeClass(['v-calendar-month__days', `days${!props.hideWeekNumber ? '-with-weeknumbers' : ''}__${weekDays.value.length}`, ...(!props.hideWeekNumber ? ['v-calendar-month__weeknumbers'] : [])])
-      }, [chunkArray(daysInMonth.value, weekDays.value.length).map((week, wi) => [!props.hideWeekNumber ? createElementVNode("div", mergeProps({
+        "class": normalizeClass(['v-calendar-month__days', `days${!props.hideWeekNumber ? '-with-weeknumbers' : ''}__${weekdaysCount}`, ...(!props.hideWeekNumber ? ['v-calendar-month__weeknumbers'] : [])])
+      }, [chunkArray(daysInMonth.value, weekdaysCount).map((week, wi) => [!props.hideWeekNumber ? createElementVNode("div", mergeProps({
         "class": "v-calendar-month__weeknumber"
       }, getPrefixedEventHandlers(attrs, ':weekNumber', () => ({
         weekNumber: weekNumbers.value[wi],
         week
       }))), [weekNumbers.value[wi]]) : '', week.map(day => createVNode(VCalendarMonthDay, mergeProps({
-        "key": day.date.getTime()
+        "key": adapter.toJsDate(day.date).getTime()
       }, calendarDayProps, {
         "day": day,
         "title": adapter.format(day.date, 'dayOfMonth'),
@@ -30702,7 +31194,7 @@ const VCalendar = genericComponent()({
         "dayIndex": i,
         "events": props.events?.filter(e => adapter.isSameDay(e.start, day.date) || adapter.isSameDay(e.end, day.date))
       }, attrs), {
-        ...pick(slots, ['interval', 'intervalBody', 'intervalEvent', 'intervalTitle'])
+        ...pick(slots, ['interval', 'interval-body', 'interval-event', 'interval-title'])
       })), props.viewMode === 'day' && (slots['day-interval'] ? slots['day-interval']({
         day: genDays([displayValue.value], adapter.date())[0],
         dayIndex: 0,
@@ -31617,6 +32109,7 @@ const VIconBtn = genericComponent()({
         opacity: props.opacity
       };
       return createVNode(props.tag, {
+        "type": props.tag === 'button' ? 'button' : undefined,
         "class": normalizeClass([{
           'v-icon-btn': true,
           'v-icon-btn--active': isActive.value,
@@ -32275,6 +32768,398 @@ const VPullToRefresh = genericComponent()({
   }
 });
 
+// Types
+
+// Display mode types for different visual representations
+
+// Extended variant type that includes our custom 'contained' variant
+
+// Key display tuple: [mode, content] where content is string or IconValue
+
+// Key tuple: [mode, content] where content is string or IconValue
+
+function processKey(config, requestedMode, isMac) {
+  const keyCfg = isMac && config.mac ? config.mac : config.default;
+
+  // 1. Resolve the safest display mode for the current platform
+  const mode = (() => {
+    // Non-Mac platforms rarely use icons – prefer text
+    if (requestedMode === 'icon' && !isMac) return 'text';
+
+    // If the requested mode lacks an asset, fall back to text
+    if (requestedMode === 'icon' && !keyCfg.icon) return 'text';
+    if (requestedMode === 'symbol' && !keyCfg.symbol) return 'text';
+    return requestedMode;
+  })();
+
+  // 2. Pick value for the chosen mode, defaulting to text representation
+  let value = keyCfg[mode] ?? keyCfg.text;
+
+  // 3. Guard against icon tokens leaking into text mode (e.g. "$ctrl")
+  if (mode === 'text' && typeof value === 'string' && value.startsWith('$') && !value.startsWith('$vuetify.')) {
+    value = value.slice(1).toUpperCase(); // "$ctrl" → "CTRL"
+  }
+  return mode === 'icon' ? ['icon', value] : [mode, value];
+}
+const hotkeyMap = {
+  ctrl: {
+    mac: {
+      symbol: '⌃',
+      icon: '$ctrl',
+      text: '$vuetify.hotkey.ctrl'
+    },
+    default: {
+      text: 'Ctrl'
+    }
+  },
+  meta: {
+    mac: {
+      symbol: '⌘',
+      icon: '$command',
+      text: '$vuetify.hotkey.command'
+    },
+    default: {
+      text: 'Ctrl'
+    }
+  },
+  cmd: {
+    mac: {
+      symbol: '⌘',
+      icon: '$command',
+      text: '$vuetify.hotkey.command'
+    },
+    default: {
+      text: 'Ctrl'
+    }
+  },
+  shift: {
+    mac: {
+      symbol: '⇧',
+      icon: '$shift',
+      text: '$vuetify.hotkey.shift'
+    },
+    default: {
+      text: 'Shift'
+    }
+  },
+  alt: {
+    mac: {
+      symbol: '⌥',
+      icon: '$alt',
+      text: '$vuetify.hotkey.option'
+    },
+    default: {
+      text: 'Alt'
+    }
+  },
+  enter: {
+    default: {
+      symbol: '↵',
+      icon: '$enter',
+      text: '$vuetify.hotkey.enter'
+    }
+  },
+  arrowup: {
+    default: {
+      symbol: '↑',
+      icon: '$arrowup',
+      text: '$vuetify.hotkey.upArrow'
+    }
+  },
+  arrowdown: {
+    default: {
+      symbol: '↓',
+      icon: '$arrowdown',
+      text: '$vuetify.hotkey.downArrow'
+    }
+  },
+  arrowleft: {
+    default: {
+      symbol: '←',
+      icon: '$arrowleft',
+      text: '$vuetify.hotkey.leftArrow'
+    }
+  },
+  arrowright: {
+    default: {
+      symbol: '→',
+      icon: '$arrowright',
+      text: '$vuetify.hotkey.rightArrow'
+    }
+  },
+  backspace: {
+    default: {
+      symbol: '⌫',
+      icon: '$backspace',
+      text: '$vuetify.hotkey.backspace'
+    }
+  },
+  escape: {
+    default: {
+      text: '$vuetify.hotkey.escape'
+    }
+  },
+  ' ': {
+    mac: {
+      symbol: '␣',
+      icon: '$space',
+      text: '$vuetify.hotkey.space'
+    },
+    default: {
+      text: '$vuetify.hotkey.space'
+    }
+  },
+  '-': {
+    default: {
+      text: '-'
+    }
+  }
+};
+
+// Create custom variant props that extend the base variant props with our 'contained' option
+const makeVHotkeyVariantProps = propsFactory({
+  variant: {
+    type: String,
+    default: 'elevated',
+    validator: v => ['elevated', 'flat', 'tonal', 'outlined', 'text', 'plain', 'contained'].includes(v)
+  }
+}, 'VHotkeyVariant');
+const makeVHotkeyProps = propsFactory({
+  // String representing keyboard shortcuts (e.g., "ctrl+k", "meta+shift+p")
+  keys: String,
+  // How to display keys: 'symbol' uses special characters (⌘, ⌃), 'icon' uses SVG icons, 'text' uses words
+  displayMode: {
+    type: String,
+    default: 'icon'
+  },
+  // Custom key mapping configuration. Users can import and modify the exported hotkeyMap as needed
+  keyMap: {
+    type: Object,
+    default: () => hotkeyMap
+  },
+  platform: {
+    type: String,
+    default: 'auto'
+  },
+  inline: Boolean,
+  disabled: Boolean,
+  prefix: String,
+  suffix: String,
+  ...makeComponentProps(),
+  ...makeThemeProps(),
+  ...makeBorderProps(),
+  ...makeRoundedProps(),
+  ...makeElevationProps(),
+  ...makeVHotkeyVariantProps(),
+  color: String
+}, 'VHotkey');
+class Delineator {
+  constructor(delineator) {
+    if (['and', 'then'].includes(delineator)) this.val = delineator;else {
+      throw new Error('Not a valid delineator');
+    }
+  }
+  isEqual(d) {
+    return this.val === d.val;
+  }
+}
+function isDelineator(value) {
+  return value instanceof Delineator;
+}
+function isString(value) {
+  return typeof value === 'string';
+}
+function getKeyText(keyMap, key, isMac) {
+  const lowerKey = key.toLowerCase();
+  if (lowerKey in keyMap) {
+    const result = processKey(keyMap[lowerKey], 'text', isMac);
+    return typeof result[1] === 'string' ? result[1] : String(result[1]);
+  }
+  return key.toUpperCase();
+}
+function applyDisplayModeToKey(keyMap, mode, key, isMac) {
+  const lowerKey = key.toLowerCase();
+  if (lowerKey in keyMap) {
+    const result = processKey(keyMap[lowerKey], mode, isMac);
+    if (result[0] === 'text' && typeof result[1] === 'string' && result[1].startsWith('$') && !result[1].startsWith('$vuetify.')) {
+      return ['text', result[1].replace('$', '').toUpperCase(), key];
+    }
+    return [...result, key];
+  }
+  return ['text', key.toUpperCase(), key];
+}
+const VHotkey = genericComponent()({
+  name: 'VHotkey',
+  props: makeVHotkeyProps(),
+  setup(props) {
+    const {
+      t
+    } = useLocale();
+    const {
+      themeClasses
+    } = provideTheme(props);
+    const {
+      rtlClasses
+    } = useRtl();
+    const {
+      borderClasses
+    } = useBorder(props);
+    const {
+      roundedClasses
+    } = useRounded(props);
+    const {
+      elevationClasses
+    } = useElevation(props);
+    const isContainedVariant = computed(() => props.variant === 'contained');
+    const effectiveVariantProps = computed(() => ({
+      ...props,
+      variant: isContainedVariant.value ? 'elevated' : props.variant
+    }));
+    const {
+      colorClasses,
+      colorStyles,
+      variantClasses
+    } = useVariant(effectiveVariantProps);
+    const isMac = computed(() => props.platform === 'auto' ? typeof navigator !== 'undefined' && /macintosh/i.test(navigator.userAgent) : props.platform === 'mac');
+    const effectiveDisplayMode = computed(() => props.displayMode);
+    const AND_DELINEATOR = new Delineator('and'); // For + separators
+    const THEN_DELINEATOR = new Delineator('then'); // For - separators
+
+    const effectiveKeyMap = computed(() => props.keyMap);
+    const keyCombinations = computed(() => {
+      if (!props.keys) return [];
+
+      // Split by spaces to handle multiple key combinations
+      // Example: "ctrl+k meta+p" -> ["ctrl+k", "meta+p"]
+      return props.keys.split(' ').map(combination => {
+        // Use the shared sequence splitting logic
+        const sequenceGroups = splitKeySequence(combination);
+
+        // Process each sequence group
+        return sequenceGroups.flatMap((group, groupIndex) => {
+          // Use the shared key combination splitting logic
+          const keyParts = splitKeyCombination(group);
+          const parts = keyParts.reduce((acc, part, index) => {
+            if (index !== 0) {
+              // Add AND delineator between keys
+              return [...acc, AND_DELINEATOR, part];
+            }
+            return [...acc, part];
+          }, []);
+
+          // Add THEN delineator between sequence groups
+          const result = parts.map(key => {
+            if (isString(key)) {
+              return applyDisplayModeToKey(effectiveKeyMap.value, effectiveDisplayMode.value, key, isMac.value);
+            }
+            return key;
+          });
+
+          // Add sequence separator if not the last group
+          if (groupIndex < sequenceGroups.length - 1) {
+            result.push(THEN_DELINEATOR);
+          }
+          return result;
+        });
+      });
+    });
+    const accessibleLabel = computed(() => {
+      if (!props.keys) return '';
+
+      // Convert the parsed key combinations into readable text
+      const readableShortcuts = keyCombinations.value.map(combination => {
+        const readableParts = [];
+        for (const key of combination) {
+          if (isDelineator(key)) {
+            if (AND_DELINEATOR.isEqual(key)) {
+              readableParts.push(t('$vuetify.hotkey.plus'));
+            } else if (THEN_DELINEATOR.isEqual(key)) {
+              readableParts.push(t('$vuetify.hotkey.then'));
+            }
+          } else {
+            // Always use text representation for screen readers
+            const textKey = key[0] === 'icon' || key[0] === 'symbol' ? applyDisplayModeToKey(mergeDeep(hotkeyMap, props.keyMap), 'text', String(key[1]), isMac.value)[1] : key[1];
+            readableParts.push(translateKey(textKey));
+          }
+        }
+        return readableParts.join(' ');
+      });
+      const shortcutText = readableShortcuts.join(', ');
+      return t('$vuetify.hotkey.shortcut', shortcutText);
+    });
+    function translateKey(key) {
+      return key.startsWith('$vuetify.') ? t(key) : key;
+    }
+    function getKeyTooltip(key) {
+      if (effectiveDisplayMode.value === 'text') return undefined;
+      const textKey = getKeyText(effectiveKeyMap.value, String(key[2]), isMac.value);
+      return translateKey(textKey);
+    }
+    function renderKey(key, keyIndex, isContained) {
+      const KeyComponent = isContained ? 'kbd' : VKbd;
+      const keyClasses = ['v-hotkey__key', `v-hotkey__key-${key[0]}`, ...(isContained ? ['v-hotkey__key--nested'] : [borderClasses.value, roundedClasses.value, elevationClasses.value, colorClasses.value])];
+      return createVNode(KeyComponent, {
+        "key": keyIndex,
+        "class": normalizeClass(keyClasses),
+        "style": normalizeStyle(isContained ? undefined : colorStyles.value),
+        "aria-hidden": "true",
+        "title": getKeyTooltip(key)
+      }, {
+        default: () => [key[0] === 'icon' ? createVNode(VIcon, {
+          "icon": key[1],
+          "aria-hidden": "true"
+        }, null) : translateKey(key[1])]
+      });
+    }
+    function renderDivider(key, keyIndex) {
+      return createElementVNode("span", {
+        "key": keyIndex,
+        "class": "v-hotkey__divider",
+        "aria-hidden": "true"
+      }, [AND_DELINEATOR.isEqual(key) ? '+' : t('$vuetify.hotkey.then')]);
+    }
+    useRender(() => createElementVNode("div", {
+      "class": normalizeClass(['v-hotkey', {
+        'v-hotkey--disabled': props.disabled,
+        'v-hotkey--inline': props.inline,
+        'v-hotkey--contained': isContainedVariant.value
+      }, themeClasses.value, rtlClasses.value, variantClasses.value, props.class]),
+      "style": normalizeStyle(props.style),
+      "role": "img",
+      "aria-label": accessibleLabel.value
+    }, [isContainedVariant.value ? createVNode(VKbd, {
+      "key": "contained",
+      "class": normalizeClass(['v-hotkey__contained-wrapper', borderClasses.value, roundedClasses.value, elevationClasses.value, colorClasses.value]),
+      "style": normalizeStyle(colorStyles.value),
+      "aria-hidden": "true"
+    }, {
+      default: () => [props.prefix && createElementVNode("span", {
+        "key": "contained-prefix",
+        "class": "v-hotkey__prefix"
+      }, [props.prefix]), keyCombinations.value.map((combination, comboIndex) => createElementVNode("span", {
+        "class": "v-hotkey__combination",
+        "key": comboIndex
+      }, [combination.map((key, keyIndex) => isDelineator(key) ? renderDivider(key, keyIndex) : renderKey(key, keyIndex, true)), comboIndex < keyCombinations.value.length - 1 && createElementVNode("span", {
+        "aria-hidden": "true"
+      }, [createTextVNode("\xA0")])])), props.suffix && createElementVNode("span", {
+        "key": "contained-suffix",
+        "class": "v-hotkey__suffix"
+      }, [props.suffix])]
+    }) : createElementVNode(Fragment, null, [props.prefix && createElementVNode("span", {
+      "key": "prefix",
+      "class": "v-hotkey__prefix"
+    }, [props.prefix]), keyCombinations.value.map((combination, comboIndex) => createElementVNode("span", {
+      "class": "v-hotkey__combination",
+      "key": comboIndex
+    }, [combination.map((key, keyIndex) => isDelineator(key) ? renderDivider(key, keyIndex) : renderKey(key, keyIndex, false)), comboIndex < keyCombinations.value.length - 1 && createElementVNode("span", {
+      "aria-hidden": "true"
+    }, [createTextVNode("\xA0")])])), props.suffix && createElementVNode("span", {
+      "key": "suffix",
+      "class": "v-hotkey__suffix"
+    }, [props.suffix])])]));
+  }
+});
+
 var components = /*#__PURE__*/Object.freeze({
   __proto__: null,
   VAlert: VAlert,
@@ -32363,6 +33248,7 @@ var components = /*#__PURE__*/Object.freeze({
   VFileUploadItem: VFileUploadItem,
   VFooter: VFooter,
   VForm: VForm,
+  VHotkey: VHotkey,
   VHover: VHover,
   VIcon: VIcon,
   VIconBtn: VIconBtn,
@@ -32786,7 +33672,7 @@ function createVuetify$1() {
     };
   });
 }
-const version$1 = "3.9.0-beta.0";
+const version$1 = "3.9.0";
 createVuetify$1.version = version$1;
 
 // Vue's inject() can only be used in setup
@@ -33084,7 +33970,7 @@ var index = /*#__PURE__*/Object.freeze({
 
 /* eslint-disable local-rules/sort-imports */
 
-const version = "3.9.0-beta.0";
+const version = "3.9.0";
 
 /* eslint-disable local-rules/sort-imports */
 
@@ -33097,5 +33983,5 @@ const createVuetify = function () {
   });
 };
 
-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-labs.esm.js.map