vuetify 3.9.0-beta.0 → 3.9.0

package/dist/vuetify-labs.js

@@ -1,5 +1,5 @@
 /*!
-* Vuetify v3.9.0-beta.0
+* Vuetify v3.9.0
 * Forged by John Leider
 * Released under the MIT License.
 */
@@ -550,6 +550,10 @@
       return child.type !== vue.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();
@@ -1624,6 +1628,40 @@
     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') {
@@ -2145,6 +2183,24 @@
       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}'
     }
   };
 
@@ -4655,7 +4711,18 @@
     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 (?)
@@ -8797,7 +8864,7 @@
         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({
@@ -8805,7 +8872,8 @@
             value: true,
             selected: map,
             children,
-            parents
+            parents,
+            disabled
           });
         }
         return map;
@@ -8837,9 +8905,9 @@
           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();
       },
@@ -8905,23 +8973,32 @@
           value,
           selected,
           children,
-          parents
+          parents,
+          disabled
         } = _ref6;
         id = vue.toRaw(id);
         const original = new Map(selected);
         const items = [id];
         while (items.length) {
           const item = items.shift();
-          selected.set(vue.toRaw(item), value ? 'on' : 'off');
+          if (!disabled.has(item)) {
+            selected.set(vue.toRaw(item), value ? 'on' : 'off');
+          }
           if (children.has(item)) {
             items.push(...children.get(item));
           }
         }
         let parent = vue.toRaw(parents.get(id));
         while (parent) {
-          const childrenIds = children.get(parent);
-          const everySelected = childrenIds.every(cid => selected.get(vue.toRaw(cid)) === 'on');
-          const noneSelected = childrenIds.every(cid => !selected.has(vue.toRaw(cid)) || selected.get(vue.toRaw(cid)) === 'off');
+          let everySelected = true;
+          let noneSelected = true;
+          for (const child of children.get(parent)) {
+            const cid = vue.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 = vue.toRaw(parents.get(parent));
         }
@@ -8938,7 +9015,7 @@
         }
         return selected;
       },
-      in: (v, children, parents) => {
+      in: (v, children, parents, disabled) => {
         let map = new Map();
         for (const id of v || []) {
           map = strategy.select({
@@ -8946,7 +9023,8 @@
             value: true,
             selected: map,
             children,
-            parents
+            parents,
+            disabled
           });
         }
         return map;
@@ -8993,8 +9071,9 @@
     root: {
       register: () => null,
       unregister: () => null,
-      parents: vue.ref(new Map()),
       children: vue.ref(new Map()),
+      parents: vue.ref(new Map()),
+      disabled: vue.ref(new Set()),
       open: () => null,
       openOnSelect: () => null,
       activate: () => null,
@@ -9021,9 +9100,10 @@
   }, 'nested');
   const useNested = props => {
     let isUnmounted = false;
-    const children = vue.ref(new Map());
-    const parents = vue.ref(new Map());
-    const opened = useProxiedModel(props, 'opened', props.opened, v => new Set(v), v => [...v.values()]);
+    const children = vue.shallowRef(new Map());
+    const parents = vue.shallowRef(new Map());
+    const disabled = vue.shallowRef(new Set());
+    const opened = useProxiedModel(props, 'opened', props.opened, v => new Set(Array.isArray(v) ? v.map(i => vue.toRaw(i)) : v), v => [...v.values()]);
     const activeStrategy = vue.computed(() => {
       if (typeof props.activeStrategy === 'object') return props.activeStrategy;
       if (typeof props.activeStrategy === 'function') return props.activeStrategy(props.mandatory);
@@ -9071,13 +9151,13 @@
       }
     });
     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));
     vue.onBeforeUnmount(() => {
       isUnmounted = true;
     });
     function getPath(id) {
       const path = [];
-      let parent = id;
+      let parent = vue.toRaw(id);
       while (parent != null) {
         path.unshift(parent);
         parent = parents.value.get(parent);
@@ -9101,7 +9181,7 @@
           }
           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(' -> ');
@@ -9111,6 +9191,7 @@
             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]);
@@ -9120,6 +9201,7 @@
           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) ?? [];
@@ -9169,6 +9251,7 @@
             selected: new Map(selected.value),
             children: children.value,
             parents: parents.value,
+            disabled: disabled.value,
             event
           });
           newSelected && (selected.value = newSelected);
@@ -9211,16 +9294,17 @@
         },
         children,
         parents,
+        disabled,
         getPath
       }
     };
     vue.provide(VNestedSymbol, nested);
     return nested.root;
   };
-  const useNestedItem = (id, isGroup) => {
+  const useNestedItem = (id, isDisabled, isGroup) => {
     const parent = vue.inject(VNestedSymbol, emptyNested);
     const uidSymbol = Symbol('nested item');
-    const computedId = vue.computed(() => vue.toValue(id) ?? uidSymbol);
+    const computedId = vue.computed(() => vue.toRaw(vue.toValue(id)) ?? uidSymbol);
     const item = {
       ...parent,
       id: computedId,
@@ -9229,18 +9313,22 @@
       isOpen: vue.computed(() => parent.root.opened.value.has(computedId.value)),
       parent: vue.computed(() => parent.root.parents.value.get(computedId.value)),
       activate: (activated, e) => parent.root.activate(computedId.value, activated, e),
-      isActivated: vue.computed(() => parent.root.activated.value.has(vue.toRaw(computedId.value))),
+      isActivated: vue.computed(() => parent.root.activated.value.has(computedId.value)),
       select: (selected, e) => parent.root.select(computedId.value, selected, e),
-      isSelected: vue.computed(() => parent.root.selected.value.get(vue.toRaw(computedId.value)) === 'on'),
-      isIndeterminate: vue.computed(() => parent.root.selected.value.get(vue.toRaw(computedId.value)) === 'indeterminate'),
+      isSelected: vue.computed(() => parent.root.selected.value.get(computedId.value) === 'on'),
+      isIndeterminate: vue.computed(() => parent.root.selected.value.get(computedId.value) === 'indeterminate'),
       isLeaf: vue.computed(() => !parent.root.children.value.get(computedId.value)),
       isGroupActivator: parent.isGroupActivator
     };
     vue.onBeforeMount(() => {
-      !parent.isGroupActivator && parent.root.register(computedId.value, parent.id.value, isGroup);
+      if (!parent.isGroupActivator) {
+        parent.root.register(computedId.value, parent.id.value, vue.toValue(isDisabled), isGroup);
+      }
     });
     vue.onBeforeUnmount(() => {
-      !parent.isGroupActivator && parent.root.unregister(computedId.value);
+      if (!parent.isGroupActivator) {
+        parent.root.unregister(computedId.value);
+      }
     });
     isGroup && vue.provide(VNestedSymbol, item);
     return item;
@@ -9272,6 +9360,7 @@
       type: IconValue,
       default: '$collapse'
     },
+    disabled: Boolean,
     expandIcon: {
       type: IconValue,
       default: '$expand'
@@ -9297,7 +9386,7 @@
         isOpen,
         open,
         id: _id
-      } = useNestedItem(() => props.value, true);
+      } = useNestedItem(() => props.value, () => props.disabled, true);
       const id = vue.computed(() => `v-list-group--id-${String(props.rawId ?? _id.value)}`);
       const list = useList();
       const {
@@ -9467,7 +9556,7 @@
         parent,
         openOnSelect,
         id: uid
-      } = useNestedItem(id, false);
+      } = useNestedItem(id, () => props.disabled, false);
       const list = useList();
       const isActive = vue.computed(() => props.active !== false && (props.active || link.isActive?.value || (root.activatable.value ? isActivated.value : isSelected.value)));
       const isLink = vue.toRef(() => props.link !== false && link.isLink.value);
@@ -9819,6 +9908,10 @@
       type: [Boolean, String, Array, Function],
       default: 'props'
     },
+    itemType: {
+      type: [Boolean, String, Array, Function],
+      default: 'type'
+    },
     returnObject: Boolean,
     valueComparator: Function
   }, 'list-items');
@@ -9826,6 +9919,7 @@
     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,
@@ -9833,15 +9927,16 @@
       ...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));
@@ -9883,7 +9978,7 @@
       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
@@ -9945,7 +10040,7 @@
   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 = {
@@ -10003,10 +10098,6 @@
     ...makeDensityProps(),
     ...makeDimensionProps(),
     ...makeElevationProps(),
-    itemType: {
-      type: String,
-      default: 'type'
-    },
     ...makeItemsProps(),
     ...makeRoundedProps(),
     ...makeTagProps(),
@@ -10427,7 +10518,7 @@
       });
       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;
         }
@@ -12097,11 +12188,7 @@
           default: slots.loader
         }), hasPrepend && vue.createElementVNode("div", {
           "key": "prepend",
-          "class": "v-field__prepend-inner",
-          "onMousedown": e => {
-            e.preventDefault();
-            e.stopPropagation();
-          }
+          "class": "v-field__prepend-inner"
         }, [props.prependInnerIcon && vue.createVNode(InputIcon, {
           "key": "prepend-icon",
           "name": "prependInner",
@@ -12170,11 +12257,7 @@
           })]), [[vue.vShow, props.dirty]])]
         }), hasAppend && vue.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 && vue.createVNode(InputIcon, {
           "key": "append-icon",
           "name": "appendInner",
@@ -12285,7 +12368,7 @@
         if (!isFocused.value) focus();
         vue.nextTick(() => {
           if (inputRef.value !== document.activeElement) {
-            inputRef.value?.focus();
+            vue.nextTick(() => inputRef.value?.focus());
           }
         });
       }
@@ -12624,7 +12707,7 @@
       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);
@@ -13233,7 +13316,7 @@
                     key: item.value,
                     onClick: () => select(item, null)
                   });
-                  if (item.raw.type === 'divider') {
+                  if (item.type === 'divider') {
                     return slots.divider?.({
                       props: item.raw,
                       index
@@ -13241,7 +13324,7 @@
                       "key": `divider-${index}`
                     }), null);
                   }
-                  if (item.raw.type === 'subheader') {
+                  if (item.type === 'subheader') {
                     return slots.subheader?.({
                       props: item.raw,
                       index
@@ -13409,7 +13492,7 @@
       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);
@@ -13851,7 +13934,7 @@
                     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
@@ -13859,7 +13942,7 @@
                       "key": `divider-${index}`
                     }), null);
                   }
-                  if (item.raw.type === 'subheader') {
+                  if (item.type === 'subheader') {
                     return slots.subheader?.({
                       props: item.raw,
                       index
@@ -15420,6 +15503,7 @@
                 }) : vue.createVNode(VBtn, vue.mergeProps(item, props), null);
               })]
             })]), props.progress && vue.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
@@ -17506,7 +17590,7 @@
       case 'fullDate':
         options = {
           year: 'numeric',
-          month: 'long',
+          month: 'short',
           day: 'numeric'
         };
         break;
@@ -18084,6 +18168,317 @@
     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 (vue.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 (vue.toValue(preventDefault)) e.preventDefault();
+      if (!isSequence) {
+        callback(e);
+        return;
+      }
+      clearTimer();
+      groupIndex++;
+      if (groupIndex === keyGroups.length) {
+        callback(e);
+        resetSequence();
+        return;
+      }
+      timeout = window.setTimeout(resetSequence, vue.toValue(sequenceTimeout));
+    }
+    function cleanup() {
+      window.removeEventListener(vue.toValue(event), handler);
+      clearTimer();
+    }
+    vue.watch(() => vue.toValue(keys), function (unrefKeys) {
+      cleanup();
+      if (unrefKeys) {
+        const groups = splitKeySequence(unrefKeys.toLowerCase());
+        isSequence = groups.length > 1;
+        keyGroups = groups;
+        resetSequence();
+        window.addEventListener(vue.toValue(event), handler);
+      }
+    }, {
+      immediate: true
+    });
+
+    // Watch for changes in the event type to re-register the listener
+    vue.watch(() => vue.toValue(event), function (newEvent, oldEvent) {
+      if (oldEvent && keyGroups && keyGroups.length > 0) {
+        window.removeEventListener(oldEvent, handler);
+        window.addEventListener(newEvent, handler);
+      }
+    });
+    try {
+      getCurrentInstance('useHotkey');
+      vue.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({
@@ -18630,7 +19025,7 @@
                     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
@@ -18638,7 +19033,7 @@
                       "key": `divider-${index}`
                     }), null);
                   }
-                  if (item.raw.type === 'subheader') {
+                  if (item.type === 'subheader') {
                     return slots.subheader?.({
                       props: item.raw,
                       index
@@ -19512,7 +19907,8 @@
 
         // 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) {
@@ -20221,10 +20617,15 @@
       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],
@@ -20235,11 +20636,13 @@
       slots
     } = _ref;
     const Tag = props.tag ?? 'td';
+    const fixedSide = typeof props.fixed === 'string' ? props.fixed : props.fixed ? 'start' : 'none';
     return vue.createVNode(Tag, {
-      "tabindex": "0",
       "class": vue.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}`]),
@@ -20247,7 +20650,8 @@
         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?.()]
@@ -20344,20 +20748,28 @@
   }
   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 {
@@ -20366,36 +20778,57 @@
           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 = [];
@@ -20528,7 +20961,6 @@
     color: String,
     disableSort: Boolean,
     fixedHeader: Boolean,
-    lastFixed: Boolean,
     multiSort: Boolean,
     sortAscIcon: {
       type: IconValue,
@@ -20575,11 +21007,12 @@
         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
         };
       }
@@ -20639,14 +21072,15 @@
           },
           "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 = {
@@ -20922,7 +21356,9 @@
           },
           "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,
@@ -22332,10 +22768,9 @@
       const date = adapter.setYear(adapter.startOfMonth(adapter.date()), adapter.getYear(year.value));
       return adapter.setMonth(date, value);
     }, v => adapter.getMonth(v));
-    const weekDays = vue.computed(() => {
+    const weekdayLabels = vue.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 = vue.computed(() => {
       const weeks = adapter.getWeekArray(month.value, props.firstDayOfWeek);
@@ -22359,13 +22794,14 @@
     });
     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'),
@@ -22377,8 +22813,8 @@
           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),
@@ -22416,7 +22852,7 @@
       if (typeof props.allowedDates === 'function') {
         return !props.allowedDates(date);
       }
-      return !props.weekdays.includes(adapter.toJsDate(date).getDay());
+      return false;
     }
     return {
       displayValue,
@@ -22425,7 +22861,7 @@
       genDays,
       model,
       weeksInMonth,
-      weekDays,
+      weekdayLabels,
       weekNumbers
     };
   }
@@ -22464,7 +22900,8 @@
       const {
         daysInMonth,
         model,
-        weekNumbers
+        weekNumbers,
+        weekdayLabels
       } = useCalendar(props);
       const adapter = useDate();
       const rangeStart = vue.shallowRef();
@@ -22536,7 +22973,10 @@
         }
       }
       useRender(() => vue.createElementVNode("div", {
-        "class": "v-date-picker-month"
+        "class": "v-date-picker-month",
+        "style": {
+          '--v-date-picker-days-in-week': props.weekdays.length
+        }
       }, [props.showWeek && vue.createElementVNode("div", {
         "key": "weeks",
         "class": "v-date-picker-month__weeks"
@@ -22552,7 +22992,7 @@
           "ref": daysRef,
           "key": daysInMonth.value[0].date?.toString(),
           "class": "v-date-picker-month__days"
-        }, [!props.hideWeekdays && adapter.getWeekdays(props.firstDayOfWeek, props.weekdayFormat).map(weekDay => vue.createElementVNode("div", {
+        }, [!props.hideWeekdays && weekdayLabels.value.map(weekDay => vue.createElementVNode("div", {
           "class": vue.normalizeClass(['v-date-picker-month__day', 'v-date-picker-month__weekday'])
         }, [weekDay])), daysInMonth.value.map((item, i) => {
           const slotProps = {
@@ -22935,7 +23375,8 @@
       }
       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) {
@@ -25232,6 +25673,8 @@
     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);
@@ -25239,6 +25682,8 @@
     function holdStop() {
       window.clearTimeout(timeout);
       window.clearInterval(interval);
+      window.removeEventListener('pointerup', holdStop);
+      document.removeEventListener('blur', holdStop);
     }
     function tick(value) {
       toggleUpDown(value === 'up');
@@ -25374,7 +25819,7 @@
           onClick: onControlClick,
           onPointerup: onControlMouseup,
           onPointerdown: onUpControlMousedown,
-          onPointercancel: onControlPointerCancel
+          onPointercancel: onControlMouseup
         }
       };
       const decrementSlotProps = {
@@ -25382,7 +25827,7 @@
           onClick: onControlClick,
           onPointerup: onControlMouseup,
           onPointerdown: onDownControlMousedown,
-          onPointercancel: onControlPointerCancel
+          onPointercancel: onControlMouseup
         }
       };
       vue.watch(() => props.precision, () => formatInputValue());
@@ -25463,7 +25908,6 @@
         const el = e.currentTarget;
         el?.releasePointerCapture(e.pointerId);
         e.preventDefault();
-        e.stopPropagation();
         holdStop();
       }
       function onUpControlMousedown(e) {
@@ -25480,11 +25924,6 @@
         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;
@@ -25531,7 +25970,7 @@
             "onClick": onControlClick,
             "onPointerdown": onUpControlMousedown,
             "onPointerup": onControlMouseup,
-            "onPointercancel": onControlPointerCancel,
+            "onPointercancel": onControlMouseup,
             "size": controlNodeSize.value,
             "tabindex": "-1"
           }, null) : vue.createVNode(VDefaultsProvider, {
@@ -25561,7 +26000,7 @@
             "onClick": onControlClick,
             "onPointerdown": onDownControlMousedown,
             "onPointerup": onControlMouseup,
-            "onPointercancel": onControlPointerCancel,
+            "onPointercancel": onControlMouseup,
             "size": controlNodeSize.value,
             "tabindex": "-1"
           }, null) : vue.createVNode(VDefaultsProvider, {
@@ -25708,19 +26147,21 @@
       const contentRef = vue.ref();
       const inputRef = vue.ref([]);
       const current = vue.computed(() => inputRef.value[focusIndex.value]);
-      const intersectScope = vue.effectScope();
-      intersectScope.run(() => {
-        const {
-          intersectionRef,
-          isIntersecting
-        } = useIntersectionObserver();
-        vue.watch(isIntersecting, v => {
-          if (!v) return;
-          intersectionRef.value?.focus();
-          intersectScope.stop();
-        });
-        vue.watchEffect(() => {
-          intersectionRef.value = inputRef.value[0];
+      useToggleScope(() => props.autofocus, () => {
+        const intersectScope = vue.effectScope();
+        intersectScope.run(() => {
+          const {
+            intersectionRef,
+            isIntersecting
+          } = useIntersectionObserver();
+          vue.watchEffect(() => {
+            intersectionRef.value = inputRef.value[0];
+          });
+          vue.watch(isIntersecting, v => {
+            if (!v) return;
+            intersectionRef.value?.focus();
+            intersectScope.stop();
+          });
         });
       });
       function onInput() {
@@ -29731,6 +30172,8 @@
 
   const makeVTreeviewItemProps = propsFactory({
     loading: Boolean,
+    hideActions: Boolean,
+    indentLines: Array,
     toggleIcon: IconValue,
     ...makeVListItemProps({
       slim: true
@@ -29766,23 +30209,31 @@
         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 vue.createVNode(VListItem, vue.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 vue.createElementVNode(vue.Fragment, null, [vue.createVNode(VListItemAction, {
-              "start": false
+            return vue.createElementVNode(vue.Fragment, null, [props.indentLines && props.indentLines.length > 0 ? vue.createElementVNode("div", {
+              "key": "indent-lines",
+              "class": "v-treeview-indent-lines",
+              "style": {
+                '--v-indent-parts': props.indentLines.length
+              }
+            }, [props.indentLines.map(type => vue.createElementVNode("div", {
+              "class": vue.normalizeClass(`v-treeview-indent-line v-treeview-indent-line--${type}`)
+            }, null))]) : '', !props.hideActions && vue.createVNode(VListItemAction, {
+              "start": true
             }, {
               default: () => [props.toggleIcon ? vue.createVNode(VBtn, {
                 "density": "compact",
@@ -29791,13 +30242,11 @@
                 "variant": "text",
                 "onClick": onClickAction
               }, {
-                loader() {
-                  return vue.createVNode(VProgressCircular, {
-                    "indeterminate": "disable-shrink",
-                    "size": "20",
-                    "width": "2"
-                  }, null);
-                }
+                loader: () => vue.createVNode(VProgressCircular, {
+                  "indeterminate": "disable-shrink",
+                  "size": "20",
+                  "width": "2"
+                }, null)
               }) : vue.createElementVNode("div", {
                 "class": "v-treeview-item__level"
               }, null)]
@@ -29805,7 +30254,7 @@
           } : undefined
         });
       });
-      return {};
+      return forwardRefs({}, vListItemRef);
     }
   });
 
@@ -29830,14 +30279,20 @@
     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()({
@@ -29848,7 +30303,8 @@
         slots
       } = _ref;
       const isLoading = vue.reactive(new Set());
-      const isClickOnOpen = vue.computed(() => !props.disabled && (props.openOnClick != null ? props.openOnClick : props.selectable));
+      const activatorItems = vue.ref([]);
+      const isClickOnOpen = vue.computed(() => !props.disabled && (props.openOnClick != null ? props.openOnClick : props.selectable && !props.activatable));
       async function checkChildren(item) {
         try {
           if (!props.items?.length || !props.loadChildren) return;
@@ -29862,22 +30318,35 @@
       }
       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 => vue.createElementVNode(vue.Fragment, null, [props.selectable && (!children || children && !['leaf', 'single-leaf'].includes(props.selectStrategy)) && vue.createElementVNode("div", null, [vue.createVNode(VCheckboxBtn, {
             "key": item.value,
@@ -29890,7 +30359,8 @@
             "indeterminateIcon": props.indeterminateIcon,
             "falseIcon": props.falseIcon,
             "trueIcon": props.trueIcon,
-            "onClick": vue.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();
@@ -29937,24 +30407,45 @@
               ...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 vue.createVNode(VTreeviewItem, vue.mergeProps(listItemProps, {
+            return vue.createVNode(VTreeviewItem, vue.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: () => vue.createVNode(VTreeviewChildren, vue.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
-        }) ?? vue.createVNode(VTreeviewItem, vue.mergeProps(itemProps, {
-          "value": props.returnObject ? vue.toRaw(item.raw) : itemProps.value
-        }), slotsWithItem);
+        }, () => {
+          if (item.type === 'divider') {
+            return renderSlot(slots.divider, {
+              props: item.raw
+            }, () => vue.createVNode(VDivider, item.props, null));
+          }
+          if (item.type === 'subheader') {
+            return renderSlot(slots.subheader, {
+              props: item.raw
+            }, () => vue.createVNode(VListSubheader, item.props, null));
+          }
+          return vue.createVNode(VTreeviewItem, vue.mergeProps(itemProps, {
+            "hideActions": props.hideActions,
+            "indentLines": indentLines.leaf,
+            "value": props.returnObject ? vue.toRaw(item.raw) : itemProps.value
+          }), slotsWithItem);
+        });
       });
     }
   });
@@ -29970,20 +30461,18 @@
   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',
@@ -29998,7 +30487,8 @@
     },
     setup(props, _ref) {
       let {
-        slots
+        slots,
+        emit
       } = _ref;
       const {
         items
@@ -30007,13 +30497,12 @@
       const baseColor = vue.toRef(() => props.baseColor);
       const color = vue.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 = vue.computed({
-        get: () => _selected.value,
+        get: () => props.modelValue ?? _selected.value,
         set(val) {
           _selected.value = val;
-          model.value = val;
+          emit('update:modelValue', val);
         }
       });
       const vListRef = vue.ref();
@@ -30079,6 +30568,7 @@
       useRender(() => {
         const listProps = VList.filterProps(props);
         const treeviewChildrenProps = VTreeviewChildren.filterProps(props);
+        const indentLinesVariant = typeof props.indentLines === 'boolean' ? 'default' : props.indentLines;
         return vue.createVNode(VList, vue.mergeProps({
           "ref": vListRef
         }, listProps, {
@@ -30096,7 +30586,9 @@
           default: () => [vue.createVNode(VTreeviewChildren, vue.mergeProps(treeviewChildrenProps, {
             "density": props.density,
             "returnObject": props.returnObject,
-            "items": items.value
+            "items": items.value,
+            "parentIndentLines": props.indentLines ? [] : undefined,
+            "indentLinesVariant": indentLinesVariant
           }), slots)]
         });
       });
@@ -30185,7 +30677,7 @@
         }
       };
       useRender(() => {
-        return vue.createElementVNode("div", null, [slots.intervalEvent?.({
+        return vue.createElementVNode("div", null, [slots['interval-event']?.({
           height: calcHeight().height,
           margin: calcHeight().margin,
           eventClass: 'v-calendar-internal-event',
@@ -30282,13 +30774,13 @@
           "style": vue.normalizeStyle(`height: ${convertToUnit(props.intervalHeight)}`)
         }, [vue.createElementVNode("div", vue.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')]), vue.createElementVNode("div", {
           "class": "v-calendar-day__row-hairline"
         }, null), vue.createElementVNode("div", vue.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
         }) ?? vue.createElementVNode("div", null, [interval.value.events?.map(event => vue.createVNode(VCalendarIntervalEvent, vue.mergeProps({
           "event": event,
@@ -30297,8 +30789,8 @@
           "intervalDuration": props.intervalDuration,
           "intervalHeight": props.intervalHeight
         }, attrs), {
-          ...(slots.intervalEvent ? {
-            intervalEvent: _ref2 => {
+          ...(slots['interval-event'] ? {
+            'interval-event': _ref2 => {
               let {
                 height,
                 margin,
@@ -30306,7 +30798,7 @@
                 event,
                 interval
               } = _ref2;
-              return slots.intervalEvent?.({
+              return slots['interval-event']?.({
                 height,
                 margin,
                 eventClass,
@@ -30320,7 +30812,7 @@
           "style": vue.normalizeStyle(`height: ${convertToUnit(props.intervalHeight)}`)
         }, [vue.createElementVNode("div", vue.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 => vue.createVNode(VCalendarIntervalEvent, vue.mergeProps({
           "event": event,
@@ -30329,8 +30821,8 @@
           "intervalDuration": props.intervalDuration,
           "intervalHeight": props.intervalHeight
         }, attrs), {
-          ...(slots.intervalEvent ? {
-            intervalEvent: _ref3 => {
+          ...(slots['interval-event'] ? {
+            'interval-event': _ref3 => {
               let {
                 height,
                 margin,
@@ -30338,7 +30830,7 @@
                 event,
                 interval
               } = _ref3;
-              return slots.intervalEvent?.({
+              return slots['interval-event']?.({
                 height,
                 margin,
                 eventClass,
@@ -30393,7 +30885,7 @@
         }), null)])]), intervals.value.map((_, index) => slots.interval?.(calendarIntervalProps) ?? vue.createVNode(VCalendarInterval, vue.mergeProps({
           "index": index
         }, calendarIntervalProps, attrs, getPrefixedEventHandlers(attrs, ':interval', () => calendarIntervalProps)), {
-          ...pick(slots, ['intervalBody', 'intervalEvent', 'intervalTitle'])
+          ...pick(slots, ['interval-body', 'interval-event', 'interval-title'])
         }))]);
       });
       return {
@@ -30537,7 +31029,7 @@
         }, getPrefixedEventHandlers(attrs, ':day', () => props)), [!props.day?.isHidden ? vue.createElementVNode("div", {
           "key": "title",
           "class": "v-calendar-weekly__day-label"
-        }, [slots.dayTitle?.({
+        }, [slots['day-title']?.({
           title: props.title
         }) ?? vue.createVNode(VBtn, vue.mergeProps({
           "class": props.day?.isToday ? 'v-calendar-weekly__day-label__today' : undefined,
@@ -30550,12 +31042,12 @@
         }, getPrefixedEventHandlers(attrs, ':date', () => props)), null)]) : undefined, !props.day?.isHidden ? vue.createElementVNode("div", {
           "key": "content",
           "class": "v-calendar-weekly__day-content"
-        }, [slots.dayBody?.({
+        }, [slots['day-body']?.({
           day: props.day,
           events: props.events
         }) ?? vue.createElementVNode("div", null, [vue.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
@@ -30565,7 +31057,7 @@
           "allDay": true
         }, attrs), null))]), vue.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
@@ -30610,9 +31102,8 @@
         model,
         displayValue,
         weekNumbers,
-        weekDays
+        weekdayLabels
       } = useCalendar(props);
-      const dayNames = adapter.getWeekdays();
       function onClickNext() {
         if (props.viewMode === 'month') {
           model.value = [adapter.addMonths(displayValue.value, 1)];
@@ -30650,6 +31141,7 @@
       useRender(() => {
         const calendarDayProps = VCalendarDay.filterProps(props);
         const calendarHeaderProps = VCalendarHeader.filterProps(props);
+        const weekdaysCount = daysInWeek.value.length;
         return vue.createElementVNode("div", {
           "class": vue.normalizeClass(['v-calendar', {
             'v-calendar-monthly': props.viewMode === 'month',
@@ -30671,25 +31163,25 @@
         }), {
           title: slots.title
         }))]), vue.createElementVNode("div", {
-          "class": vue.normalizeClass(['v-calendar__container', `days__${weekDays.value.length}`])
+          "class": vue.normalizeClass(['v-calendar__container', `days__${weekdaysCount}`])
         }, [props.viewMode === 'month' && !props.hideDayHeader && vue.createElementVNode("div", {
-          "class": vue.normalizeClass(['v-calendar-weekly__head', `days__${weekDays.value.length}`, ...(!props.hideWeekNumber ? ['v-calendar-weekly__head-weeknumbers'] : [])]),
+          "class": vue.normalizeClass(['v-calendar-weekly__head', `days__${weekdaysCount}`, ...(!props.hideWeekNumber ? ['v-calendar-weekly__head-weeknumbers'] : [])]),
           "key": "calendarWeeklyHead"
         }, [!props.hideWeekNumber ? vue.createElementVNode("div", {
           "key": "weekNumber0",
           "class": "v-calendar-weekly__head-weeknumber"
-        }, null) : '', weekDays.value.map(weekday => vue.createElementVNode("div", {
+        }, null) : '', weekdayLabels.value.map(weekday => vue.createElementVNode("div", {
           "class": vue.normalizeClass(`v-calendar-weekly__head-weekday${!props.hideWeekNumber ? '-with-weeknumber' : ''}`)
-        }, [dayNames[weekday]]))]), props.viewMode === 'month' && vue.createElementVNode("div", {
+        }, [weekday]))]), props.viewMode === 'month' && vue.createElementVNode("div", {
           "key": "VCalendarMonth",
-          "class": vue.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 ? vue.createElementVNode("div", vue.mergeProps({
+          "class": vue.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 ? vue.createElementVNode("div", vue.mergeProps({
           "class": "v-calendar-month__weeknumber"
         }, getPrefixedEventHandlers(attrs, ':weekNumber', () => ({
           weekNumber: weekNumbers.value[wi],
           week
         }))), [weekNumbers.value[wi]]) : '', week.map(day => vue.createVNode(VCalendarMonthDay, vue.mergeProps({
-          "key": day.date.getTime()
+          "key": adapter.toJsDate(day.date).getTime()
         }, calendarDayProps, {
           "day": day,
           "title": adapter.format(day.date, 'dayOfMonth'),
@@ -30706,7 +31198,7 @@
           "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,
@@ -31621,6 +32113,7 @@
           opacity: props.opacity
         };
         return vue.createVNode(props.tag, {
+          "type": props.tag === 'button' ? 'button' : undefined,
           "class": vue.normalizeClass([{
             'v-icon-btn': true,
             'v-icon-btn--active': isActive.value,
@@ -32279,6 +32772,398 @@
     }
   });
 
+  // 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 = vue.computed(() => props.variant === 'contained');
+      const effectiveVariantProps = vue.computed(() => ({
+        ...props,
+        variant: isContainedVariant.value ? 'elevated' : props.variant
+      }));
+      const {
+        colorClasses,
+        colorStyles,
+        variantClasses
+      } = useVariant(effectiveVariantProps);
+      const isMac = vue.computed(() => props.platform === 'auto' ? typeof navigator !== 'undefined' && /macintosh/i.test(navigator.userAgent) : props.platform === 'mac');
+      const effectiveDisplayMode = vue.computed(() => props.displayMode);
+      const AND_DELINEATOR = new Delineator('and'); // For + separators
+      const THEN_DELINEATOR = new Delineator('then'); // For - separators
+
+      const effectiveKeyMap = vue.computed(() => props.keyMap);
+      const keyCombinations = vue.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 = vue.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 vue.createVNode(KeyComponent, {
+          "key": keyIndex,
+          "class": vue.normalizeClass(keyClasses),
+          "style": vue.normalizeStyle(isContained ? undefined : colorStyles.value),
+          "aria-hidden": "true",
+          "title": getKeyTooltip(key)
+        }, {
+          default: () => [key[0] === 'icon' ? vue.createVNode(VIcon, {
+            "icon": key[1],
+            "aria-hidden": "true"
+          }, null) : translateKey(key[1])]
+        });
+      }
+      function renderDivider(key, keyIndex) {
+        return vue.createElementVNode("span", {
+          "key": keyIndex,
+          "class": "v-hotkey__divider",
+          "aria-hidden": "true"
+        }, [AND_DELINEATOR.isEqual(key) ? '+' : t('$vuetify.hotkey.then')]);
+      }
+      useRender(() => vue.createElementVNode("div", {
+        "class": vue.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": vue.normalizeStyle(props.style),
+        "role": "img",
+        "aria-label": accessibleLabel.value
+      }, [isContainedVariant.value ? vue.createVNode(VKbd, {
+        "key": "contained",
+        "class": vue.normalizeClass(['v-hotkey__contained-wrapper', borderClasses.value, roundedClasses.value, elevationClasses.value, colorClasses.value]),
+        "style": vue.normalizeStyle(colorStyles.value),
+        "aria-hidden": "true"
+      }, {
+        default: () => [props.prefix && vue.createElementVNode("span", {
+          "key": "contained-prefix",
+          "class": "v-hotkey__prefix"
+        }, [props.prefix]), keyCombinations.value.map((combination, comboIndex) => vue.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 && vue.createElementVNode("span", {
+          "aria-hidden": "true"
+        }, [vue.createTextVNode("\xA0")])])), props.suffix && vue.createElementVNode("span", {
+          "key": "contained-suffix",
+          "class": "v-hotkey__suffix"
+        }, [props.suffix])]
+      }) : vue.createElementVNode(vue.Fragment, null, [props.prefix && vue.createElementVNode("span", {
+        "key": "prefix",
+        "class": "v-hotkey__prefix"
+      }, [props.prefix]), keyCombinations.value.map((combination, comboIndex) => vue.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 && vue.createElementVNode("span", {
+        "aria-hidden": "true"
+      }, [vue.createTextVNode("\xA0")])])), props.suffix && vue.createElementVNode("span", {
+        "key": "suffix",
+        "class": "v-hotkey__suffix"
+      }, [props.suffix])])]));
+    }
+  });
+
   var components = /*#__PURE__*/Object.freeze({
     __proto__: null,
     VAlert: VAlert,
@@ -32367,6 +33252,7 @@
     VFileUploadItem: VFileUploadItem,
     VFooter: VFooter,
     VForm: VForm,
+    VHotkey: VHotkey,
     VHover: VHover,
     VIcon: VIcon,
     VIconBtn: VIconBtn,
@@ -32790,7 +33676,7 @@
       };
     });
   }
-  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
@@ -33088,7 +33974,7 @@
 
   /* eslint-disable local-rules/sort-imports */
 
-  const version = "3.9.0-beta.0";
+  const version = "3.9.0";
 
   /* eslint-disable local-rules/sort-imports */
 
@@ -33109,6 +33995,7 @@
   exports.useDefaults = useDefaults;
   exports.useDisplay = useDisplay;
   exports.useGoTo = useGoTo;
+  exports.useHotkey = useHotkey;
   exports.useLayout = useLayout;
   exports.useLocale = useLocale;
   exports.useRtl = useRtl;