vuetify 3.5.8 → 3.5.10

package/dist/vuetify-labs.esm.js

@@ -1,5 +1,5 @@
 /*!
-* Vuetify v3.5.8
+* Vuetify v3.5.10
 * Forged by John Leider
 * Released under the MIT License.
 */
@@ -2388,7 +2388,7 @@ function createTheme(options) {
   const current = computed(() => computedThemes.value[name.value]);
   const styles = computed(() => {
     const lines = [];
-    if (current.value.dark) {
+    if (current.value?.dark) {
       createCssClass(lines, ':root', ['color-scheme: dark']);
     }
     createCssClass(lines, ':root', genCssVariables(current.value));
@@ -4372,6 +4372,8 @@ const aliases = {
   plus: 'mdi-plus',
   minus: 'mdi-minus',
   calendar: 'mdi-calendar',
+  treeviewCollapse: 'mdi-menu-down',
+  treeviewExpand: 'mdi-menu-right',
   eyeDropper: 'mdi-eyedropper'
 };
 const mdi = {
@@ -4566,6 +4568,7 @@ function useSize(props) {
 
 const makeVIconProps = propsFactory({
   color: String,
+  disabled: Boolean,
   start: Boolean,
   end: Boolean,
   icon: IconValue,
@@ -4603,11 +4606,13 @@ const VIcon = genericComponent()({
       if (slotValue) {
         slotIcon.value = flattenFragments(slotValue).filter(node => node.type === Text && node.children && typeof node.children === 'string')[0]?.children;
       }
+      const hasClick = !!(attrs.onClick || attrs.onClickOnce);
       return createVNode(iconData.value.component, {
         "tag": props.tag,
         "icon": iconData.value.icon,
         "class": ['v-icon', 'notranslate', themeClasses.value, sizeClasses.value, textColorClasses.value, {
-          'v-icon--clickable': !!attrs.onClick,
+          'v-icon--clickable': hasClick,
+          'v-icon--disabled': props.disabled,
           'v-icon--start': props.start,
           'v-icon--end': props.end
         }, props.class],
@@ -4616,8 +4621,9 @@ const VIcon = genericComponent()({
           height: convertToUnit(props.size),
           width: convertToUnit(props.size)
         } : undefined, textColorStyles.value, props.style],
-        "role": attrs.onClick ? 'button' : undefined,
-        "aria-hidden": !attrs.onClick
+        "role": hasClick ? 'button' : undefined,
+        "aria-hidden": !hasClick,
+        "tabindex": hasClick ? props.disabled ? -1 : 0 : undefined
       }, {
         default: () => [slotValue]
       });
@@ -7758,6 +7764,126 @@ function useList() {
   return inject$1(ListKey, null);
 }
 
+/* eslint-disable sonarjs/no-identical-functions */
+// Utilities
+const independentActiveStrategy = mandatory => {
+  const strategy = {
+    activate: _ref => {
+      let {
+        id,
+        value,
+        activated
+      } = _ref;
+      id = toRaw(id);
+
+      // When mandatory and we're trying to deselect when id
+      // is the only currently selected item then do nothing
+      if (mandatory && !value && activated.size === 1 && activated.has(id)) return activated;
+      if (value) {
+        activated.add(id);
+      } else {
+        activated.delete(id);
+      }
+      return activated;
+    },
+    in: (v, children, parents) => {
+      let set = new Set();
+      for (const id of v || []) {
+        set = strategy.activate({
+          id,
+          value: true,
+          activated: new Set(set),
+          children,
+          parents
+        });
+      }
+      return set;
+    },
+    out: v => {
+      return Array.from(v);
+    }
+  };
+  return strategy;
+};
+const independentSingleActiveStrategy = mandatory => {
+  const parentStrategy = independentActiveStrategy(mandatory);
+  const strategy = {
+    activate: _ref2 => {
+      let {
+        activated,
+        id,
+        ...rest
+      } = _ref2;
+      id = toRaw(id);
+      const singleSelected = activated.has(id) ? new Set([id]) : new Set();
+      return parentStrategy.activate({
+        ...rest,
+        id,
+        activated: singleSelected
+      });
+    },
+    in: (v, children, parents) => {
+      let set = new Set();
+      if (v?.length) {
+        set = parentStrategy.in(v.slice(0, 1), children, parents);
+      }
+      return set;
+    },
+    out: (v, children, parents) => {
+      return parentStrategy.out(v, children, parents);
+    }
+  };
+  return strategy;
+};
+const leafActiveStrategy = mandatory => {
+  const parentStrategy = independentActiveStrategy(mandatory);
+  const strategy = {
+    activate: _ref3 => {
+      let {
+        id,
+        activated,
+        children,
+        ...rest
+      } = _ref3;
+      id = toRaw(id);
+      if (children.has(id)) return activated;
+      return parentStrategy.activate({
+        id,
+        activated,
+        children,
+        ...rest
+      });
+    },
+    in: parentStrategy.in,
+    out: parentStrategy.out
+  };
+  return strategy;
+};
+const leafSingleActiveStrategy = mandatory => {
+  const parentStrategy = independentSingleActiveStrategy(mandatory);
+  const strategy = {
+    activate: _ref4 => {
+      let {
+        id,
+        activated,
+        children,
+        ...rest
+      } = _ref4;
+      id = toRaw(id);
+      if (children.has(id)) return activated;
+      return parentStrategy.activate({
+        id,
+        activated,
+        children,
+        ...rest
+      });
+    },
+    in: parentStrategy.in,
+    out: parentStrategy.out
+  };
+  return strategy;
+};
+
 const singleOpenStrategy = {
   open: _ref => {
     let {
@@ -7842,7 +7968,8 @@ const independentSelectStrategy = mandatory => {
       if (mandatory && !value) {
         const on = Array.from(selected.entries()).reduce((arr, _ref2) => {
           let [key, value] = _ref2;
-          return value === 'on' ? [...arr, key] : arr;
+          if (value === 'on') arr.push(key);
+          return arr;
         }, []);
         if (on.length === 1 && on[0] === id) return selected;
       }
@@ -7984,7 +8111,8 @@ const classicSelectStrategy = mandatory => {
       if (mandatory && !value) {
         const on = Array.from(selected.entries()).reduce((arr, _ref7) => {
           let [key, value] = _ref7;
-          return value === 'on' ? [...arr, key] : arr;
+          if (value === 'on') arr.push(key);
+          return arr;
         }, []);
         if (on.length === 0) return original;
       }
@@ -8028,16 +8156,24 @@ const emptyNested = {
     children: ref(new Map()),
     open: () => null,
     openOnSelect: () => null,
+    activate: () => null,
     select: () => null,
+    activatable: ref(false),
+    selectable: ref(false),
     opened: ref(new Set()),
+    activated: ref(new Set()),
     selected: ref(new Map()),
     selectedValues: ref([])
   }
 };
 const makeNestedProps = propsFactory({
+  activatable: Boolean,
+  selectable: Boolean,
+  activeStrategy: [String, Function],
   selectStrategy: [String, Function],
   openStrategy: [String, Object],
   opened: Array,
+  activated: Array,
   selected: Array,
   mandatory: Boolean
 }, 'nested');
@@ -8046,6 +8182,20 @@ const useNested = props => {
   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 activeStrategy = computed(() => {
+    if (typeof props.activeStrategy === 'object') return props.activeStrategy;
+    switch (props.activeStrategy) {
+      case 'leaf':
+        return leafActiveStrategy(props.mandatory);
+      case 'single-leaf':
+        return leafSingleActiveStrategy(props.mandatory);
+      case 'independent':
+        return independentActiveStrategy(props.mandatory);
+      case 'single-independent':
+      default:
+        return independentSingleActiveStrategy(props.mandatory);
+    }
+  });
   const selectStrategy = computed(() => {
     if (typeof props.selectStrategy === 'object') return props.selectStrategy;
     switch (props.selectStrategy) {
@@ -8074,6 +8224,7 @@ const useNested = props => {
         return multipleOpenStrategy;
     }
   });
+  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));
   onBeforeUnmount(() => {
     isUnmounted = true;
@@ -8092,6 +8243,9 @@ const useNested = props => {
     id: shallowRef(),
     root: {
       opened,
+      activatable: toRef(props, 'activatable'),
+      selectable: toRef(props, 'selectable'),
+      activated,
       selected,
       selectedValues: computed(() => {
         const arr = [];
@@ -8165,6 +8319,26 @@ const useNested = props => {
         newSelected && (selected.value = newSelected);
         nested.root.openOnSelect(id, value, event);
       },
+      activate: (id, value, event) => {
+        if (!props.activatable) {
+          return nested.root.select(id, true, event);
+        }
+        vm.emit('click:activate', {
+          id,
+          value,
+          path: getPath(id),
+          event
+        });
+        const newActivated = activeStrategy.value.activate({
+          id,
+          value,
+          activated: new Set(activated.value),
+          children: children.value,
+          parents: parents.value,
+          event
+        });
+        newActivated && (activated.value = newActivated);
+      },
       children,
       parents
     }
@@ -8183,6 +8357,8 @@ const useNestedItem = (id, isGroup) => {
     openOnSelect: (open, e) => parent.root.openOnSelect(computedId.value, open, e),
     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))),
     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(computedId.value) === 'indeterminate'),
@@ -8305,7 +8481,9 @@ const VListGroup = genericComponent()({
         }, [slots.default?.()]), [[vShow, isOpen.value]])]
       })]
     }));
-    return {};
+    return {
+      isOpen
+    };
   }
 });
 
@@ -8378,6 +8556,8 @@ const VListItem = genericComponent()({
     const link = useLink(props, attrs);
     const id = computed(() => props.value === undefined ? link.href.value : props.value);
     const {
+      activate,
+      isActivated,
       select,
       isSelected,
       isIndeterminate,
@@ -8387,9 +8567,9 @@ const VListItem = genericComponent()({
       openOnSelect
     } = useNestedItem(id, false);
     const list = useList();
-    const isActive = computed(() => props.active !== false && (props.active || link.isActive?.value || isSelected.value));
+    const isActive = computed(() => props.active !== false && (props.active || link.isActive?.value || (root.activatable.value ? isActivated.value : isSelected.value)));
     const isLink = computed(() => props.link !== false && link.isLink.value);
-    const isClickable = computed(() => !props.disabled && props.link !== false && (props.link || link.isClickable.value || props.value != null && !!list));
+    const isClickable = computed(() => !props.disabled && props.link !== false && (props.link || link.isClickable.value || !!list && (root.selectable.value || root.activatable.value || props.value != null)));
     const roundedProps = computed(() => props.rounded || props.nav);
     const color = computed(() => props.color ?? props.activeColor);
     const variantProps = computed(() => ({
@@ -8440,7 +8620,13 @@ const VListItem = genericComponent()({
       emit('click', e);
       if (isGroupActivator || !isClickable.value) return;
       link.navigate?.(e);
-      props.value != null && select(!isSelected.value, e);
+      if (root.activatable.value) {
+        activate(!isActivated.value, e);
+      } else if (root.selectable.value) {
+        select(!isSelected.value, e);
+      } else if (props.value != null) {
+        select(!isSelected.value, e);
+      }
     }
     function onKeyDown(e) {
       if (e.key === 'Enter' || e.key === ' ') {
@@ -8556,7 +8742,12 @@ const VListItem = genericComponent()({
         }, null)])]
       }), [[resolveDirective("ripple"), isClickable.value && props.ripple]]);
     });
-    return {};
+    return {
+      isGroupActivator,
+      isSelected,
+      list,
+      select
+    };
   }
 });
 
@@ -8898,8 +9089,10 @@ const VList = genericComponent()({
   props: makeVListProps(),
   emits: {
     'update:selected': value => true,
+    'update:activated': value => true,
     'update:opened': value => true,
     'click:open': value => true,
+    'click:activate': value => true,
     'click:select': value => true
   },
   setup(props, _ref) {
@@ -8932,7 +9125,9 @@ const VList = genericComponent()({
       roundedClasses
     } = useRounded(props);
     const {
+      children,
       open,
+      parents,
       select
     } = useNested(props);
     const lineClasses = computed(() => props.lines ? `v-list--${props.lines}-line` : undefined);
@@ -9022,7 +9217,9 @@ const VList = genericComponent()({
     return {
       open,
       select,
-      focus
+      focus,
+      children,
+      parents
     };
   }
 });
@@ -9564,7 +9761,7 @@ function useScrollStrategies(props, data) {
     scope?.stop();
     if (!(data.isActive.value && props.scrollStrategy)) return;
     scope = effectScope();
-    await nextTick();
+    await new Promise(resolve => setTimeout(resolve));
     scope.active && scope.run(() => {
       if (typeof props.scrollStrategy === 'function') {
         props.scrollStrategy(data, props, scope);
@@ -10313,6 +10510,7 @@ const VOverlay = genericComponent()({
       if (v) isActive.value = false;
     });
     const root = ref();
+    const scrimEl = ref();
     const contentEl = ref();
     const {
       contentStyles,
@@ -10334,8 +10532,10 @@ const VOverlay = genericComponent()({
       emit('click:outside', e);
       if (!props.persistent) isActive.value = false;else animateClick();
     }
-    function closeConditional() {
-      return isActive.value && globalTop.value;
+    function closeConditional(e) {
+      return isActive.value && globalTop.value && (
+      // If using scrim, only close if clicking on it rather than anything opened on top
+      !props.scrim || e.target === scrimEl.value);
     }
     IN_BROWSER && watch(isActive, val => {
       if (val) {
@@ -10422,7 +10622,8 @@ const VOverlay = genericComponent()({
         "ref": root
       }, scopeId, attrs), [createVNode(Scrim, mergeProps({
         "color": scrimColor,
-        "modelValue": isActive.value && !!props.scrim
+        "modelValue": isActive.value && !!props.scrim,
+        "ref": scrimEl
       }, scrimEvents.value), null), createVNode(MaybeTransition, {
         "appear": true,
         "persisted": true,
@@ -10445,6 +10646,7 @@ const VOverlay = genericComponent()({
     })]));
     return {
       activatorEl,
+      scrimEl,
       target,
       animateClick,
       contentEl,
@@ -10640,6 +10842,9 @@ const VMenu = genericComponent()({
           isActive.value = false;
           overlay.value?.activatorEl?.focus();
         }
+      } else if (['Enter', ' '].includes(e.key) && props.closeOnContentClick) {
+        isActive.value = false;
+        parent?.closeParents();
       }
     }
     function onActivatorKeydown(e) {
@@ -10917,7 +11122,7 @@ const VField = genericComponent()({
     }
     useRender(() => {
       const isOutlined = props.variant === 'outlined';
-      const hasPrepend = slots['prepend-inner'] || props.prependInnerIcon;
+      const hasPrepend = !!(slots['prepend-inner'] || props.prependInnerIcon);
       const hasClear = !!(props.clearable || slots.clear);
       const hasAppend = !!(slots['append-inner'] || props.appendInnerIcon || hasClear);
       const label = () => slots.label ? slots.label({
@@ -11902,9 +12107,11 @@ const VSelect = genericComponent()({
         });
       }
     });
-    watch(() => props.items, val => {
-      if (!isFocused.value || !val.length || menu.value) return;
-      menu.value = true;
+    watch(() => props.items, (newVal, oldVal) => {
+      if (menu.value) return;
+      if (isFocused.value && !oldVal.length && newVal.length) {
+        menu.value = true;
+      }
     });
     useRender(() => {
       const hasChips = !!(props.chips || slots.chip);
@@ -12339,8 +12546,8 @@ const VAutocomplete = genericComponent()({
       if (e.key === 'ArrowDown' && highlightFirst.value) {
         listRef.value?.focus('next');
       }
-      if (!props.multiple) return;
       if (['Backspace', 'Delete'].includes(e.key)) {
+        if (!props.multiple && hasSelectionSlot.value && model.value.length > 0) return select(model.value[0], false);
         if (selectionIndex.value < 0) {
           if (e.key === 'Backspace' && !search.value) {
             selectionIndex.value = length - 1;
@@ -12348,10 +12555,10 @@ const VAutocomplete = genericComponent()({
           return;
         }
         const originalSelectionIndex = selectionIndex.value;
-        const selectedItem = model.value[selectionIndex.value];
-        if (selectedItem && !selectedItem.props.disabled) select(selectedItem, false);
+        select(model.value[selectionIndex.value], false);
         selectionIndex.value = originalSelectionIndex >= length - 1 ? length - 2 : originalSelectionIndex;
       }
+      if (!props.multiple) return;
       if (e.key === 'ArrowLeft') {
         if (selectionIndex.value < 0 && selectionStart > 0) return;
         const prev = selectionIndex.value > -1 ? selectionIndex.value - 1 : length - 1;
@@ -12404,7 +12611,7 @@ const VAutocomplete = genericComponent()({
     /** @param set - null means toggle */
     function select(item) {
       let set = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-      if (item.props.disabled) return;
+      if (!item || item.props.disabled) return;
       if (props.multiple) {
         const index = model.value.findIndex(selection => props.valueComparator(selection.value, item.value));
         const add = set == null ? !~index : set;
@@ -12464,9 +12671,11 @@ const VAutocomplete = genericComponent()({
         });
       }
     });
-    watch(() => props.items, val => {
-      if (!isFocused.value || !val.length || menu.value) return;
-      menu.value = true;
+    watch(() => props.items, (newVal, oldVal) => {
+      if (menu.value) return;
+      if (isFocused.value && !oldVal.length && newVal.length) {
+        menu.value = true;
+      }
     });
     useRender(() => {
       const hasList = !!(!props.hideNoData || displayItems.value.length || slots['prepend-item'] || slots['append-item'] || slots['no-data']);
@@ -16123,6 +16332,7 @@ const VCombobox = genericComponent()({
       }
       menu.value = !menu.value;
     }
+    // eslint-disable-next-line complexity
     function onKeydown(e) {
       if (isComposingIgnoreKey(e) || props.readonly || form?.isReadonly.value) return;
       const selectionStart = vTextFieldRef.value.selectionStart;
@@ -16149,8 +16359,8 @@ const VCombobox = genericComponent()({
         select(transformItem$3(props, search.value));
         if (hasSelectionSlot.value) _search.value = '';
       }
-      if (!props.multiple) return;
       if (['Backspace', 'Delete'].includes(e.key)) {
+        if (!props.multiple && hasSelectionSlot.value && model.value.length > 0) return select(model.value[0], false);
         if (selectionIndex.value < 0) {
           if (e.key === 'Backspace' && !search.value) {
             selectionIndex.value = length - 1;
@@ -16158,10 +16368,10 @@ const VCombobox = genericComponent()({
           return;
         }
         const originalSelectionIndex = selectionIndex.value;
-        const selectedItem = model.value[selectionIndex.value];
-        if (selectedItem && !selectedItem.props.disabled) select(selectedItem, false);
+        select(model.value[selectionIndex.value], false);
         selectionIndex.value = originalSelectionIndex >= length - 1 ? length - 2 : originalSelectionIndex;
       }
+      if (!props.multiple) return;
       if (e.key === 'ArrowLeft') {
         if (selectionIndex.value < 0 && selectionStart > 0) return;
         const prev = selectionIndex.value > -1 ? selectionIndex.value - 1 : length - 1;
@@ -16192,7 +16402,7 @@ const VCombobox = genericComponent()({
     /** @param set - null means toggle */
     function select(item) {
       let set = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-      if (item.props.disabled) return;
+      if (!item || item.props.disabled) return;
       if (props.multiple) {
         const index = model.value.findIndex(selection => props.valueComparator(selection.value, item.value));
         const add = set == null ? !~index : set;
@@ -16269,9 +16479,11 @@ const VCombobox = genericComponent()({
         });
       }
     });
-    watch(() => props.items, val => {
-      if (!isFocused.value || !val.length || menu.value) return;
-      menu.value = true;
+    watch(() => props.items, (newVal, oldVal) => {
+      if (menu.value) return;
+      if (isFocused.value && !oldVal.length && newVal.length) {
+        menu.value = true;
+      }
     });
     useRender(() => {
       const hasList = !!(!props.hideNoData || displayItems.value.length || slots['prepend-item'] || slots['append-item'] || slots['no-data']);
@@ -17418,7 +17630,7 @@ function setYear(date, year) {
   return d;
 }
 function startOfDay(date) {
-  return new Date(date.getFullYear(), date.getMonth(), date.getDate());
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate(), 0, 0, 0, 0);
 }
 function endOfDay(date) {
   return new Date(date.getFullYear(), date.getMonth(), date.getDate(), 23, 59, 59, 999);
@@ -20292,6 +20504,7 @@ const VDatePickerControls = genericComponent()({
       emit('click:month');
     }
     useRender(() => {
+      // TODO: add slot support and scope defaults
       return createVNode("div", {
         "class": ['v-date-picker-controls']
       }, [createVNode(VBtn, {
@@ -20570,6 +20783,12 @@ const VDatePickerMonth = genericComponent()({
     const adapter = useDate();
     const rangeStart = shallowRef();
     const rangeStop = shallowRef();
+    if (props.multiple === 'range' && model.value.length > 0) {
+      rangeStart.value = model.value[0];
+      if (model.value.length > 1) {
+        rangeStop.value = model.value[model.value.length - 1];
+      }
+    }
     const atMax = computed(() => {
       const max = ['number', 'string'].includes(typeof props.multiple) ? Number(props.multiple) : Infinity;
       return model.value.length >= max;
@@ -20580,15 +20799,15 @@ const VDatePickerMonth = genericComponent()({
         rangeStart.value = _value;
         model.value = [rangeStart.value];
       } else if (!rangeStop.value) {
-        if (adapter.isSameDay(value, rangeStart.value)) {
+        if (adapter.isSameDay(_value, rangeStart.value)) {
           rangeStart.value = undefined;
           model.value = [];
           return;
-        } else if (adapter.isBefore(value, rangeStart.value)) {
-          rangeStop.value = rangeStart.value;
+        } else if (adapter.isBefore(_value, rangeStart.value)) {
+          rangeStop.value = adapter.endOfDay(rangeStart.value);
           rangeStart.value = _value;
         } else {
-          rangeStop.value = _value;
+          rangeStop.value = adapter.endOfDay(_value);
         }
         const diff = adapter.getDiff(rangeStop.value, rangeStart.value, 'days');
         const datesInRange = [rangeStart.value];
@@ -22755,12 +22974,24 @@ const VNavigationDrawer = genericComponent()({
         default: () => [hasImage && createVNode("div", {
           "key": "image",
           "class": "v-navigation-drawer__img"
-        }, [slots.image ? slots.image?.({
-          image: props.image
-        }) : createVNode("img", {
-          "src": props.image,
-          "alt": ""
-        }, null)]), slots.prepend && createVNode("div", {
+        }, [!slots.image ? createVNode(VImg, {
+          "key": "image-img",
+          "alt": "",
+          "cover": true,
+          "height": "inherit",
+          "src": props.image
+        }, null) : createVNode(VDefaultsProvider, {
+          "key": "image-defaults",
+          "disabled": !props.image,
+          "defaults": {
+            VImg: {
+              alt: '',
+              cover: true,
+              height: 'inherit',
+              src: props.image
+            }
+          }
+        }, slots.image)]), slots.prepend && createVNode("div", {
           "class": "v-navigation-drawer__prepend"
         }, [slots.prepend?.()]), createVNode("div", {
           "class": "v-navigation-drawer__content"
@@ -22861,7 +23092,7 @@ const VOtpInput = genericComponent()({
     function onInput() {
       // The maxlength attribute doesn't work for the number type input, so the text type is used.
       // The following logic simulates the behavior of a number input.
-      if (props.type === 'number' && /[^0-9]/g.test(current.value.value)) {
+      if (isValidNumber(current.value.value)) {
         current.value.value = '';
         return;
       }
@@ -22907,7 +23138,9 @@ const VOtpInput = genericComponent()({
     function onPaste(index, e) {
       e.preventDefault();
       e.stopPropagation();
-      model.value = (e?.clipboardData?.getData('Text') ?? '').split('');
+      const clipboardText = e?.clipboardData?.getData('Text') ?? '';
+      if (!isValidNumber(clipboardText)) return;
+      model.value = clipboardText.split('');
       inputRef.value?.[index].blur();
     }
     function reset() {
@@ -22921,6 +23154,9 @@ const VOtpInput = genericComponent()({
       blur();
       focusIndex.value = -1;
     }
+    function isValidNumber(value) {
+      return props.type === 'number' && !isNaN(Number(value));
+    }
     provideDefaults({
       VField: {
         color: computed(() => props.color),
@@ -25398,78 +25634,6 @@ const VValidation = genericComponent()({
   }
 });
 
-// Types
-
-const makeVConfirmEditProps = propsFactory({
-  modelValue: null,
-  color: String,
-  cancelText: {
-    type: String,
-    default: '$vuetify.confirmEdit.cancel'
-  },
-  okText: {
-    type: String,
-    default: '$vuetify.confirmEdit.ok'
-  }
-}, 'VConfirmEdit');
-const VConfirmEdit = genericComponent()({
-  name: 'VConfirmEdit',
-  props: makeVConfirmEditProps(),
-  emits: {
-    cancel: () => true,
-    save: value => true,
-    'update:modelValue': value => true
-  },
-  setup(props, _ref) {
-    let {
-      emit,
-      slots
-    } = _ref;
-    const model = useProxiedModel(props, 'modelValue');
-    const internalModel = ref();
-    watchEffect(() => {
-      internalModel.value = structuredClone(toRaw(model.value));
-    });
-    const {
-      t
-    } = useLocale();
-    const isPristine = computed(() => {
-      return deepEqual(model.value, internalModel.value);
-    });
-    function save() {
-      model.value = internalModel.value;
-      emit('save', internalModel.value);
-    }
-    function cancel() {
-      internalModel.value = structuredClone(toRaw(model.value));
-      emit('cancel');
-    }
-    let actionsUsed = false;
-    useRender(() => {
-      const actions = createVNode(Fragment, null, [createVNode(VBtn, {
-        "disabled": isPristine.value,
-        "variant": "text",
-        "color": props.color,
-        "onClick": cancel,
-        "text": t(props.cancelText)
-      }, null), createVNode(VBtn, {
-        "disabled": isPristine.value,
-        "variant": "text",
-        "color": props.color,
-        "onClick": save,
-        "text": t(props.okText)
-      }, null)]);
-      return createVNode(Fragment, null, [slots.default?.({
-        model: internalModel,
-        get actions() {
-          actionsUsed = true;
-          return actions;
-        }
-      }), !actionsUsed && actions]);
-    });
-  }
-});
-
 const makeVCalendarIntervalEventProps = propsFactory({
   allDay: Boolean,
   interval: Object,
@@ -25941,20 +26105,223 @@ const VCalendar = genericComponent()({
   }
 });
 
-const makeVFabProps = propsFactory({
-  app: Boolean,
-  appear: Boolean,
-  extended: Boolean,
-  location: {
+// Types
+
+const makeVConfirmEditProps = propsFactory({
+  modelValue: null,
+  color: String,
+  cancelText: {
     type: String,
-    default: 'bottom end'
+    default: '$vuetify.confirmEdit.cancel'
   },
-  offset: Boolean,
-  modelValue: {
-    type: Boolean,
-    default: true
+  okText: {
+    type: String,
+    default: '$vuetify.confirmEdit.ok'
+  }
+}, 'VConfirmEdit');
+const VConfirmEdit = genericComponent()({
+  name: 'VConfirmEdit',
+  props: makeVConfirmEditProps(),
+  emits: {
+    cancel: () => true,
+    save: value => true,
+    'update:modelValue': value => true
   },
-  ...omit(makeVBtnProps({
+  setup(props, _ref) {
+    let {
+      emit,
+      slots
+    } = _ref;
+    const model = useProxiedModel(props, 'modelValue');
+    const internalModel = ref();
+    watchEffect(() => {
+      internalModel.value = structuredClone(toRaw(model.value));
+    });
+    const {
+      t
+    } = useLocale();
+    const isPristine = computed(() => {
+      return deepEqual(model.value, internalModel.value);
+    });
+    function save() {
+      model.value = internalModel.value;
+      emit('save', internalModel.value);
+    }
+    function cancel() {
+      internalModel.value = structuredClone(toRaw(model.value));
+      emit('cancel');
+    }
+    let actionsUsed = false;
+    useRender(() => {
+      const actions = createVNode(Fragment, null, [createVNode(VBtn, {
+        "disabled": isPristine.value,
+        "variant": "text",
+        "color": props.color,
+        "onClick": cancel,
+        "text": t(props.cancelText)
+      }, null), createVNode(VBtn, {
+        "disabled": isPristine.value,
+        "variant": "text",
+        "color": props.color,
+        "onClick": save,
+        "text": t(props.okText)
+      }, null)]);
+      return createVNode(Fragment, null, [slots.default?.({
+        model: internalModel,
+        get actions() {
+          actionsUsed = true;
+          return actions;
+        }
+      }), !actionsUsed && actions]);
+    });
+  }
+});
+
+// Types
+
+// Types
+
+const makeVEmptyStateProps = propsFactory({
+  actionText: String,
+  bgColor: String,
+  color: String,
+  icon: IconValue,
+  image: String,
+  justify: {
+    type: String,
+    default: 'center'
+  },
+  headline: String,
+  title: String,
+  text: String,
+  textWidth: {
+    type: [Number, String],
+    default: 500
+  },
+  href: String,
+  to: String,
+  ...makeComponentProps(),
+  ...makeDimensionProps(),
+  ...makeSizeProps({
+    size: undefined
+  }),
+  ...makeThemeProps()
+}, 'VEmptyState');
+const VEmptyState = genericComponent()({
+  name: 'VEmptyState',
+  props: makeVEmptyStateProps(),
+  emits: {
+    'click:action': e => true
+  },
+  setup(props, _ref) {
+    let {
+      emit,
+      slots
+    } = _ref;
+    const {
+      themeClasses
+    } = provideTheme(props);
+    const {
+      backgroundColorClasses,
+      backgroundColorStyles
+    } = useBackgroundColor(toRef(props, 'bgColor'));
+    const {
+      dimensionStyles
+    } = useDimension(props);
+    function onClickAction(e) {
+      emit('click:action', e);
+    }
+    useRender(() => {
+      const hasActions = !!(slots.actions || props.actionText);
+      const hasHeadline = !!(slots.headline || props.headline);
+      const hasTitle = !!(slots.title || props.title);
+      const hasText = !!(slots.text || props.text);
+      const hasMedia = !!(slots.media || props.image || props.icon);
+      const size = props.size || (props.image ? 200 : 96);
+      return createVNode("div", {
+        "class": ['v-empty-state', {
+          [`v-empty-state--${props.justify}`]: true
+        }, themeClasses.value, backgroundColorClasses.value, props.class],
+        "style": [backgroundColorStyles.value, dimensionStyles.value, props.style]
+      }, [hasMedia && createVNode("div", {
+        "key": "media",
+        "class": "v-empty-state__media"
+      }, [!slots.media ? createVNode(Fragment, null, [props.image ? createVNode(VImg, {
+        "key": "image",
+        "src": props.image,
+        "height": size
+      }, null) : props.icon ? createVNode(VIcon, {
+        "key": "icon",
+        "size": size,
+        "icon": props.icon
+      }, null) : undefined]) : createVNode(VDefaultsProvider, {
+        "key": "media-defaults",
+        "defaults": {
+          VImg: {
+            src: props.image,
+            height: size
+          },
+          VIcon: {
+            size,
+            icon: props.icon
+          }
+        }
+      }, {
+        default: () => [slots.media()]
+      })]), hasHeadline && createVNode("div", {
+        "key": "headline",
+        "class": "v-empty-state__headline"
+      }, [slots.headline?.() ?? props.headline]), hasTitle && createVNode("div", {
+        "key": "title",
+        "class": "v-empty-state__title"
+      }, [slots.title?.() ?? props.title]), hasText && createVNode("div", {
+        "key": "text",
+        "class": "v-empty-state__text",
+        "style": {
+          maxWidth: convertToUnit(props.textWidth)
+        }
+      }, [slots.text?.() ?? props.text]), slots.default && createVNode("div", {
+        "key": "content",
+        "class": "v-empty-state__content"
+      }, [slots.default()]), hasActions && createVNode("div", {
+        "key": "actions",
+        "class": "v-empty-state__actions"
+      }, [createVNode(VDefaultsProvider, {
+        "defaults": {
+          VBtn: {
+            class: 'v-empty-state__action-btn',
+            color: props.color,
+            text: props.actionText
+          }
+        }
+      }, {
+        default: () => [slots.actions?.({
+          props: {
+            onClick: onClickAction
+          }
+        }) ?? createVNode(VBtn, {
+          "onClick": onClickAction
+        }, null)]
+      })])]);
+    });
+    return {};
+  }
+});
+
+const makeVFabProps = propsFactory({
+  app: Boolean,
+  appear: Boolean,
+  extended: Boolean,
+  location: {
+    type: String,
+    default: 'bottom end'
+  },
+  offset: Boolean,
+  modelValue: {
+    type: Boolean,
+    default: true
+  },
+  ...omit(makeVBtnProps({
     active: true
   }), ['location']),
   ...makeLayoutItemProps(),
@@ -26041,6 +26408,203 @@ const VFab = genericComponent()({
   }
 });
 
+// Types
+
+const makeVNumberInputProps = propsFactory({
+  controlVariant: {
+    type: String,
+    default: 'default'
+  },
+  inset: Boolean,
+  hideInput: Boolean,
+  min: Number,
+  max: Number,
+  step: Number,
+  ...only(makeVInputProps(), ['density', 'disabled', 'focused', 'hideDetails', 'hint', 'label', 'persistentHint', 'readonly']),
+  ...only(makeVFieldProps(), ['baseColor', 'bgColor', 'class', 'color', 'disabled', 'error', 'loading', 'reverse', 'rounded', 'style', 'theme', 'variant']),
+  ...makeFocusProps()
+}, 'VNumberInput');
+const VNumberInput = genericComponent()({
+  name: 'VNumberInput',
+  inheritAttrs: false,
+  props: {
+    ...makeVNumberInputProps(),
+    modelValue: {
+      type: [Number, String],
+      default: 0
+    }
+  },
+  emits: {
+    'update:modelValue': val => true
+  },
+  setup(props, _ref) {
+    let {
+      attrs,
+      emit,
+      slots
+    } = _ref;
+    const model = useProxiedModel(props, 'modelValue');
+    const {
+      isFocused,
+      focus,
+      blur
+    } = useFocus(props);
+    const inputRef = ref();
+    function onFocus() {
+      if (!isFocused.value) focus();
+    }
+    const controlVariant = computed(() => {
+      return props.hideInput ? 'stacked' : props.controlVariant;
+    });
+    function toggleUpDown() {
+      let increment = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      if (increment) {
+        inputRef.value?.stepUp();
+      } else {
+        inputRef.value?.stepDown();
+      }
+      if (inputRef.value) model.value = parseInt(inputRef.value.value, 10);
+    }
+    function onClickUp() {
+      toggleUpDown();
+    }
+    function onClickDown() {
+      toggleUpDown(false);
+    }
+    const incrementSlotProps = computed(() => ({
+      click: onClickUp
+    }));
+    const decrementSlotProps = computed(() => ({
+      click: onClickDown
+    }));
+    useRender(() => {
+      const fieldProps = filterFieldProps(props);
+      const [rootAttrs, inputAttrs] = filterInputAttrs(attrs);
+      const {
+        modelValue: _,
+        ...inputProps
+      } = VInput.filterProps(props);
+      function controlNode() {
+        const defaultHeight = controlVariant.value === 'stacked' ? 'auto' : '100%';
+        return createVNode("div", {
+          "class": "v-number-input__control"
+        }, [!slots.decrement ? createVNode(VBtn, {
+          "flat": true,
+          "key": "decrement-btn",
+          "height": defaultHeight,
+          "icon": "mdi-chevron-down",
+          "rounded": "0",
+          "size": "small",
+          "onClick": onClickDown
+        }, null) : createVNode(VDefaultsProvider, {
+          "key": "decrement-defaults",
+          "defaults": {
+            VBtn: {
+              flat: true,
+              rounded: '0',
+              height: defaultHeight,
+              size: 'small',
+              icon: 'mdi-chevron-down'
+            }
+          }
+        }, {
+          default: () => [slots.decrement(decrementSlotProps.value)]
+        }), createVNode(VDivider, {
+          "vertical": controlVariant.value !== 'stacked'
+        }, null), !slots.increment ? createVNode(VBtn, {
+          "flat": true,
+          "key": "increment-btn",
+          "height": defaultHeight,
+          "icon": "mdi-chevron-up",
+          "onClick": onClickUp,
+          "rounded": "0",
+          "size": "small"
+        }, null) : createVNode(VDefaultsProvider, {
+          "key": "increment-defaults",
+          "defaults": {
+            VBtn: {
+              flat: true,
+              height: defaultHeight,
+              rounded: '0',
+              size: 'small',
+              icon: 'mdi-chevron-up'
+            }
+          }
+        }, {
+          default: () => [slots.increment(incrementSlotProps.value)]
+        })]);
+      }
+      function dividerNode() {
+        return !props.hideInput && !props.inset ? createVNode(VDivider, {
+          "vertical": true
+        }, null) : undefined;
+      }
+      return createVNode(VInput, mergeProps({
+        "class": ['v-number-input', {
+          'v-number-input--default': controlVariant.value === 'default',
+          'v-number-input--hide-input': props.hideInput,
+          'v-number-input--inset': props.inset,
+          'v-number-input--reverse': props.reverse,
+          'v-number-input--split': controlVariant.value === 'split',
+          'v-number-input--stacked': controlVariant.value === 'stacked'
+        }, props.class]
+      }, rootAttrs, inputProps, {
+        "focused": isFocused.value,
+        "style": props.style
+      }), {
+        ...slots,
+        default: () => createVNode(VField, mergeProps(fieldProps, {
+          "active": true,
+          "focused": isFocused.value
+        }), {
+          ...slots,
+          default: _ref2 => {
+            let {
+              props: {
+                class: fieldClass,
+                ...slotProps
+              }
+            } = _ref2;
+            return createVNode("input", mergeProps({
+              "ref": inputRef,
+              "type": "number",
+              "value": model.value,
+              "class": fieldClass,
+              "max": props.max,
+              "min": props.min,
+              "step": props.step,
+              "onFocus": onFocus,
+              "onBlur": blur
+            }, inputAttrs), null);
+          },
+          'append-inner': controlVariant.value === 'split' ? () => createVNode("div", {
+            "class": "v-number-input__control"
+          }, [createVNode(VDivider, {
+            "vertical": true
+          }, null), createVNode(VBtn, {
+            "flat": true,
+            "height": "100%",
+            "icon": "mdi-plus",
+            "tile": true,
+            "onClick": onClickUp
+          }, null)]) : !props.reverse ? () => createVNode(Fragment, null, [dividerNode(), controlNode()]) : undefined,
+          'prepend-inner': controlVariant.value === 'split' ? () => createVNode("div", {
+            "class": "v-number-input__control"
+          }, [createVNode(VBtn, {
+            "flat": true,
+            "height": "100%",
+            "icon": "mdi-minus",
+            "tile": true,
+            "onClick": onClickDown
+          }, null), createVNode(VDivider, {
+            "vertical": true
+          }, null)]) : props.reverse ? () => createVNode(Fragment, null, [controlNode(), dividerNode()]) : undefined
+        })
+      });
+    });
+  }
+});
+
 // Utilities
 
 // Types
@@ -26488,6 +27052,8 @@ const VSparkline = genericComponent()({
   }
 });
 
+// Types
+
 const makeVSpeedDialProps = propsFactory({
   ...makeComponentProps(),
   ...makeVMenuProps({
@@ -26506,14 +27072,17 @@ const VSpeedDial = genericComponent()({
     let {
       slots
     } = _ref;
+    const menuRef = ref();
     useRender(() => {
       const menuProps = VMenu.filterProps(props);
       return createVNode(VMenu, mergeProps(menuProps, {
         "class": props.class,
         "style": props.style,
-        "contentClass": "v-speed-dial__content"
+        "contentClass": "v-speed-dial__content",
+        "ref": menuRef
       }), {
-        default: () => [createVNode(VDefaultsProvider, {
+        ...slots,
+        default: slotProps => createVNode(VDefaultsProvider, {
           "defaults": {
             VBtn: {
               size: 'small'
@@ -26525,9 +27094,9 @@ const VSpeedDial = genericComponent()({
             "group": true,
             "transition": props.transition
           }, {
-            default: () => [slots.default?.()]
+            default: () => [slots.default?.(slotProps)]
           })]
-        })]
+        })
       });
     });
     return {};
@@ -26536,132 +27105,358 @@ const VSpeedDial = genericComponent()({
 
 // Types
 
+const makeVTreeviewGroupProps = propsFactory({
+  ...omit(makeVListGroupProps({
+    collapseIcon: '$treeviewCollapse',
+    expandIcon: '$treeviewExpand'
+  }), ['subgroup'])
+}, 'VTreeviewGroup');
+const VTreeviewGroup = genericComponent()({
+  name: 'VTreeviewGroup',
+  props: makeVTreeviewGroupProps(),
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    const vListGroupRef = ref();
+    const toggleIcon = computed(() => vListGroupRef.value?.isOpen ? props.collapseIcon : props.expandIcon);
+    const activatorDefaults = computed(() => ({
+      VTreeviewItem: {
+        prependIcon: undefined,
+        appendIcon: undefined,
+        active: vListGroupRef.value?.isOpen,
+        toggleIcon: toggleIcon.value
+      }
+    }));
+    useRender(() => {
+      const listGroupProps = VListGroup.filterProps(props);
+      return createVNode(VListGroup, mergeProps(listGroupProps, {
+        "ref": vListGroupRef,
+        "class": ['v-treeview-group', props.class],
+        "subgroup": true
+      }), {
+        ...slots,
+        activator: slots.activator ? slotProps => createVNode(Fragment, null, [createVNode(VDefaultsProvider, {
+          "defaults": activatorDefaults.value
+        }, {
+          default: () => [slots.activator?.(slotProps)]
+        })]) : undefined
+      });
+    });
+    return {};
+  }
+});
+
 // Types
 
-const makeVEmptyStateProps = propsFactory({
-  actionText: String,
-  bgColor: String,
-  color: String,
-  icon: IconValue,
-  image: String,
-  justify: {
+const VTreeviewSymbol = Symbol.for('vuetify:v-treeview');
+
+const makeVTreeviewItemProps = propsFactory({
+  loading: Boolean,
+  toggleIcon: IconValue,
+  ...makeVListItemProps({
+    slim: true
+  })
+}, 'VTreeviewItem');
+const VTreeviewItem = genericComponent()({
+  name: 'VTreeviewItem',
+  props: makeVTreeviewItemProps(),
+  setup(props, _ref) {
+    let {
+      attrs,
+      slots,
+      emit
+    } = _ref;
+    const link = useLink(props, attrs);
+    const id = computed(() => props.value === undefined ? link.href.value : props.value);
+    const vListItemRef = ref();
+    const isClickable = computed(() => !props.disabled && props.link !== false && (props.link || link.isClickable.value || props.value != null && !!vListItemRef.value?.list));
+    function onClick(e) {
+      if (!vListItemRef.value?.isGroupActivator || !isClickable.value) return;
+      props.value != null && vListItemRef.value?.select(!vListItemRef.value?.isSelected, e);
+    }
+    function onKeyDown(e) {
+      if (e.key === 'Enter' || e.key === ' ') {
+        e.preventDefault();
+        onClick(e);
+      }
+    }
+    const visibleIds = inject$1(VTreeviewSymbol, {
+      visibleIds: ref()
+    }).visibleIds;
+    useRender(() => {
+      const listItemProps = VListItem.filterProps(props);
+      const hasPrepend = slots.prepend || props.toggleIcon;
+      return createVNode(VListItem, mergeProps({
+        "ref": vListItemRef
+      }, listItemProps, {
+        "class": ['v-treeview-item', {
+          'v-treeview-item--filtered': visibleIds.value && !visibleIds.value.has(id.value)
+        }, props.class],
+        "onClick": onClick,
+        "onKeydown": isClickable.value && onKeyDown
+      }), {
+        ...slots,
+        prepend: hasPrepend ? slotProps => {
+          return createVNode(Fragment, null, [props.toggleIcon && createVNode(VListItemAction, {
+            "start": false
+          }, {
+            default: () => [createVNode(VBtn, {
+              "density": "compact",
+              "icon": props.toggleIcon,
+              "loading": props.loading,
+              "variant": "text"
+            }, {
+              loader() {
+                return createVNode(VProgressCircular, {
+                  "indeterminate": "disable-shrink",
+                  "size": "20",
+                  "width": "2"
+                }, null);
+              }
+            })]
+          }), slots.prepend?.(slotProps)]);
+        } : undefined
+      });
+    });
+    return {};
+  }
+});
+
+// Types
+
+const makeVTreeviewChildrenProps = propsFactory({
+  loadChildren: Function,
+  loadingIcon: {
     type: String,
-    default: 'center'
-  },
-  headline: String,
-  title: String,
-  text: String,
-  textWidth: {
-    type: [Number, String],
-    default: 500
+    default: '$loading'
   },
-  href: String,
-  to: String,
-  ...makeComponentProps(),
-  ...makeDimensionProps(),
-  ...makeSizeProps({
-    size: undefined
+  items: Array,
+  selectable: Boolean
+}, 'VTreeviewChildren');
+const VTreeviewChildren = genericComponent()({
+  name: 'VTreeviewChildren',
+  props: makeVTreeviewChildrenProps(),
+  setup(props, _ref) {
+    let {
+      emit,
+      slots
+    } = _ref;
+    const isLoading = shallowRef(false);
+    const hasLoaded = shallowRef(false);
+    function checkChildren(item) {
+      return new Promise(resolve => {
+        if (!props.items?.length || !props.loadChildren || hasLoaded.value) return resolve();
+        isLoading.value = true;
+        props.loadChildren(item).then(resolve);
+      }).then(() => {
+        hasLoaded.value = true;
+      }).finally(() => {
+        isLoading.value = false;
+      });
+    }
+    function onClick(e, item) {
+      e.stopPropagation();
+      checkChildren(item);
+    }
+    return () => slots.default?.() ?? props.items?.map(_ref2 => {
+      let {
+        children,
+        props: itemProps,
+        raw: item
+      } = _ref2;
+      const slotsWithItem = {
+        prepend: slots.prepend ? slotProps => slots.prepend?.({
+          ...slotProps,
+          item
+        }) : props.selectable ? _ref3 => {
+          let {
+            isSelected,
+            isIndeterminate
+          } = _ref3;
+          return createVNode(VCheckboxBtn, {
+            "key": item.value,
+            "tabindex": "-1",
+            "modelValue": isSelected,
+            "loading": isLoading.value,
+            "indeterminate": isIndeterminate,
+            "onClick": e => onClick(e, item)
+          }, null);
+        } : undefined,
+        append: slots.append ? slotProps => slots.append?.({
+          ...slotProps,
+          item
+        }) : undefined,
+        title: slots.title ? slotProps => slots.title?.({
+          ...slotProps,
+          item
+        }) : undefined
+      };
+      const treeviewGroupProps = VTreeviewGroup.filterProps(itemProps);
+      const treeviewChildrenProps = VTreeviewChildren.filterProps(props);
+      return children ? createVNode(VTreeviewGroup, mergeProps({
+        "value": itemProps?.value
+      }, treeviewGroupProps), {
+        activator: _ref4 => {
+          let {
+            props: activatorProps
+          } = _ref4;
+          return createVNode(VTreeviewItem, mergeProps(itemProps, activatorProps, {
+            "loading": isLoading.value,
+            "onClick": e => onClick(e, item)
+          }), slotsWithItem);
+        },
+        default: () => createVNode(VTreeviewChildren, mergeProps(treeviewChildrenProps, {
+          "items": children
+        }), slots)
+      }) : slots.item?.({
+        props: itemProps
+      }) ?? createVNode(VTreeviewItem, itemProps, slotsWithItem);
+    });
+  }
+});
+
+function flatten(items) {
+  let flat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  for (const item of items) {
+    flat.push(item);
+    if (item.children) flatten(item.children, flat);
+  }
+  return flat;
+}
+const makeVTreeviewProps = propsFactory({
+  openAll: Boolean,
+  search: String,
+  ...makeFilterProps({
+    filterKeys: ['title']
   }),
-  ...makeThemeProps()
-}, 'VEmptyState');
-const VEmptyState = genericComponent()({
-  name: 'VEmptyState',
-  props: makeVEmptyStateProps(),
+  ...makeVTreeviewChildrenProps(),
+  ...omit(makeVListProps({
+    collapseIcon: '$treeviewCollapse',
+    expandIcon: '$treeviewExpand',
+    selectStrategy: 'independent',
+    openStrategy: 'multiple',
+    slim: true
+  }), ['nav'])
+}, 'VTreeview');
+const VTreeview = genericComponent()({
+  name: 'VTreeview',
+  props: makeVTreeviewProps(),
   emits: {
-    'click:action': e => true
+    'update:opened': val => true,
+    'update:activated': val => true,
+    'update:selected': val => true,
+    'click:open': value => true,
+    'click:select': value => true
   },
   setup(props, _ref) {
     let {
-      emit,
       slots
     } = _ref;
     const {
-      themeClasses
-    } = provideTheme(props);
-    const {
-      backgroundColorClasses,
-      backgroundColorStyles
-    } = useBackgroundColor(toRef(props, 'bgColor'));
+      items
+    } = useListItems(props);
+    const activeColor = toRef(props, 'activeColor');
+    const baseColor = toRef(props, 'baseColor');
+    const color = toRef(props, 'color');
+    const opened = useProxiedModel(props, 'opened');
+    const activated = useProxiedModel(props, 'activated');
+    const selected = useProxiedModel(props, 'selected');
+    const vListRef = ref();
+    const flatItems = computed(() => flatten(items.value));
+    const search = toRef(props, 'search');
     const {
-      dimensionStyles
-    } = useDimension(props);
-    function onClickAction(e) {
-      emit('click:action', e);
+      filteredItems
+    } = useFilter(props, flatItems, search);
+    const visibleIds = computed(() => {
+      if (!search.value) {
+        return null;
+      }
+      return new Set(filteredItems.value.flatMap(item => {
+        return [...getPath(item.props.value), ...getChildren(item.props.value)];
+      }));
+    });
+    function getPath(id) {
+      const path = [];
+      let parent = id;
+      while (parent != null) {
+        path.unshift(parent);
+        parent = vListRef.value?.parents.get(parent);
+      }
+      return path;
     }
-    useRender(() => {
-      const hasActions = !!(slots.actions || props.actionText);
-      const hasHeadline = !!(slots.headline || props.headline);
-      const hasTitle = !!(slots.title || props.title);
-      const hasText = !!(slots.text || props.text);
-      const hasMedia = !!(slots.media || props.image || props.icon);
-      const size = props.size || (props.image ? 200 : 96);
-      return createVNode("div", {
-        "class": ['v-empty-state', {
-          [`v-empty-state--${props.justify}`]: true
-        }, themeClasses.value, backgroundColorClasses.value, props.class],
-        "style": [backgroundColorStyles.value, dimensionStyles.value, props.style]
-      }, [hasMedia && createVNode("div", {
-        "key": "media",
-        "class": "v-empty-state__media"
-      }, [!slots.media ? createVNode(Fragment, null, [props.image ? createVNode(VImg, {
-        "key": "image",
-        "src": props.image,
-        "height": size
-      }, null) : props.icon ? createVNode(VIcon, {
-        "key": "icon",
-        "size": size,
-        "icon": props.icon
-      }, null) : undefined]) : createVNode(VDefaultsProvider, {
-        "key": "media-defaults",
-        "defaults": {
-          VImg: {
-            src: props.image,
-            height: size
-          },
-          VIcon: {
-            size,
-            icon: props.icon
-          }
-        }
-      }, {
-        default: () => [slots.media()]
-      })]), hasHeadline && createVNode("div", {
-        "key": "headline",
-        "class": "v-empty-state__headline"
-      }, [slots.headline?.() ?? props.headline]), hasTitle && createVNode("div", {
-        "key": "title",
-        "class": "v-empty-state__title"
-      }, [slots.title?.() ?? props.title]), hasText && createVNode("div", {
-        "key": "text",
-        "class": "v-empty-state__text",
-        "style": {
-          maxWidth: convertToUnit(props.textWidth)
-        }
-      }, [slots.text?.() ?? props.text]), slots.default && createVNode("div", {
-        "key": "content",
-        "class": "v-empty-state__content"
-      }, [slots.default()]), hasActions && createVNode("div", {
-        "key": "actions",
-        "class": "v-empty-state__actions"
-      }, [createVNode(VDefaultsProvider, {
-        "defaults": {
-          VBtn: {
-            class: 'v-empty-state__action-btn',
-            color: props.color,
-            text: props.actionText
-          }
+    function getChildren(id) {
+      const arr = [];
+      const queue = (vListRef.value?.children.get(id) ?? []).slice();
+      while (queue.length) {
+        const child = queue.shift();
+        if (!child) continue;
+        arr.push(child);
+        queue.push(...(vListRef.value?.children.get(child) ?? []).slice());
+      }
+      return arr;
+    }
+    watch(() => props.openAll, val => {
+      opened.value = val ? openAll(items.value) : [];
+    }, {
+      immediate: true
+    });
+    function openAll(item) {
+      let ids = [];
+      for (const i of item) {
+        if (!i.children) continue;
+        ids.push(i.value);
+        if (i.children) {
+          ids = ids.concat(openAll(i.children));
         }
-      }, {
-        default: () => [slots.actions?.({
-          props: {
-            onClick: onClickAction
-          }
-        }) ?? createVNode(VBtn, {
-          "onClick": onClickAction
-        }, null)]
-      })])]);
+      }
+      return ids;
+    }
+    provide(VTreeviewSymbol, {
+      visibleIds
     });
-    return {};
+    provideDefaults({
+      VTreeviewGroup: {
+        activeColor,
+        baseColor,
+        color,
+        collapseIcon: toRef(props, 'collapseIcon'),
+        expandIcon: toRef(props, 'expandIcon')
+      },
+      VTreeviewItem: {
+        activeClass: toRef(props, 'activeClass'),
+        activeColor,
+        baseColor,
+        color,
+        density: toRef(props, 'density'),
+        disabled: toRef(props, 'disabled'),
+        lines: toRef(props, 'lines'),
+        variant: toRef(props, 'variant')
+      }
+    });
+    useRender(() => {
+      const listProps = VList.filterProps(props);
+      const treeviewChildrenProps = VTreeviewChildren.filterProps(props);
+      return createVNode(VList, mergeProps({
+        "ref": vListRef
+      }, listProps, {
+        "class": ['v-treeview', props.class],
+        "style": props.style,
+        "opened": opened.value,
+        "onUpdate:opened": $event => opened.value = $event,
+        "activated": activated.value,
+        "onUpdate:activated": $event => activated.value = $event,
+        "selected": selected.value,
+        "onUpdate:selected": $event => selected.value = $event
+      }), {
+        default: () => [createVNode(VTreeviewChildren, mergeProps(treeviewChildrenProps, {
+          "items": items.value
+        }), slots)]
+      });
+    });
+    return {
+      open
+    };
   }
 });
 
@@ -26777,6 +27572,7 @@ var components = /*#__PURE__*/Object.freeze({
   VMessages: VMessages,
   VNavigationDrawer: VNavigationDrawer,
   VNoSsr: VNoSsr,
+  VNumberInput: VNumberInput,
   VOtpInput: VOtpInput,
   VOverlay: VOverlay,
   VPagination: VPagination,
@@ -26833,6 +27629,9 @@ var components = /*#__PURE__*/Object.freeze({
   VToolbarItems: VToolbarItems,
   VToolbarTitle: VToolbarTitle,
   VTooltip: VTooltip,
+  VTreeview: VTreeview,
+  VTreeviewGroup: VTreeviewGroup,
+  VTreeviewItem: VTreeviewItem,
   VValidation: VValidation,
   VVirtualScroll: VVirtualScroll,
   VWindow: VWindow,
@@ -27059,7 +27858,7 @@ function createVuetify$1() {
     goTo
   };
 }
-const version$1 = "3.5.8";
+const version$1 = "3.5.10";
 createVuetify$1.version = version$1;
 
 // Vue's inject() can only be used in setup
@@ -27071,9 +27870,248 @@ function inject(key) {
   }
 }
 
+// Icons
+
+// Types
+
+const md1 = {
+  defaults: {
+    global: {
+      rounded: 'sm'
+    },
+    VAvatar: {
+      rounded: 'circle'
+    },
+    VAutocomplete: {
+      variant: 'underlined'
+    },
+    VBanner: {
+      color: 'primary'
+    },
+    VBtn: {
+      color: 'primary',
+      rounded: 0
+    },
+    VCheckbox: {
+      color: 'secondary'
+    },
+    VCombobox: {
+      variant: 'underlined'
+    },
+    VSelect: {
+      variant: 'underlined'
+    },
+    VSlider: {
+      color: 'primary'
+    },
+    VTabs: {
+      color: 'primary'
+    },
+    VTextarea: {
+      variant: 'underlined'
+    },
+    VTextField: {
+      variant: 'underlined'
+    },
+    VToolbar: {
+      VBtn: {
+        color: null
+      }
+    }
+  },
+  icons: {
+    defaultSet: 'mdi',
+    sets: {
+      mdi
+    }
+  },
+  theme: {
+    themes: {
+      light: {
+        colors: {
+          primary: '#3F51B5',
+          'primary-darken-1': '#303F9F',
+          'primary-lighten-1': '#C5CAE9',
+          secondary: '#FF4081',
+          'secondary-darken-1': '#F50057',
+          'secondary-lighten-1': '#FF80AB',
+          accent: '#009688'
+        }
+      }
+    }
+  }
+};
+
+// Icons
+
+// Types
+
+const md2 = {
+  defaults: {
+    global: {
+      rounded: 'md'
+    },
+    VAvatar: {
+      rounded: 'circle'
+    },
+    VAutocomplete: {
+      variant: 'filled'
+    },
+    VBanner: {
+      color: 'primary'
+    },
+    VBtn: {
+      color: 'primary'
+    },
+    VCheckbox: {
+      color: 'secondary'
+    },
+    VCombobox: {
+      variant: 'filled'
+    },
+    VSelect: {
+      variant: 'filled'
+    },
+    VSlider: {
+      color: 'primary'
+    },
+    VTabs: {
+      color: 'primary'
+    },
+    VTextarea: {
+      variant: 'filled'
+    },
+    VTextField: {
+      variant: 'filled'
+    },
+    VToolbar: {
+      VBtn: {
+        color: null
+      }
+    }
+  },
+  icons: {
+    defaultSet: 'mdi',
+    sets: {
+      mdi
+    }
+  },
+  theme: {
+    themes: {
+      light: {
+        colors: {
+          primary: '#6200EE',
+          'primary-darken-1': '#3700B3',
+          secondary: '#03DAC6',
+          'secondary-darken-1': '#018786',
+          error: '#B00020'
+        }
+      }
+    }
+  }
+};
+
+// Icons
+
+// Types
+
+const md3 = {
+  defaults: {
+    VAppBar: {
+      flat: true
+    },
+    VAutocomplete: {
+      variant: 'filled'
+    },
+    VBanner: {
+      color: 'primary'
+    },
+    VBottomSheet: {
+      contentClass: 'rounded-t-xl overflow-hidden'
+    },
+    VBtn: {
+      color: 'primary',
+      rounded: 'xl'
+    },
+    VBtnGroup: {
+      rounded: 'xl',
+      VBtn: {
+        rounded: null
+      }
+    },
+    VCard: {
+      rounded: 'lg'
+    },
+    VCheckbox: {
+      color: 'secondary',
+      inset: true
+    },
+    VChip: {
+      rounded: 'sm'
+    },
+    VCombobox: {
+      variant: 'filled'
+    },
+    VNavigationDrawer: {
+      // VList: {
+      //   nav: true,
+      //   VListItem: {
+      //     rounded: 'xl',
+      //   },
+      // },
+    },
+    VSelect: {
+      variant: 'filled'
+    },
+    VSlider: {
+      color: 'primary'
+    },
+    VTabs: {
+      color: 'primary'
+    },
+    VTextarea: {
+      variant: 'filled'
+    },
+    VTextField: {
+      variant: 'filled'
+    },
+    VToolbar: {
+      VBtn: {
+        color: null
+      }
+    }
+  },
+  icons: {
+    defaultSet: 'mdi',
+    sets: {
+      mdi
+    }
+  },
+  theme: {
+    themes: {
+      light: {
+        colors: {
+          primary: '#6750a4',
+          secondary: '#b4b0bb',
+          tertiary: '#7d5260',
+          error: '#b3261e',
+          surface: '#fffbfe'
+        }
+      }
+    }
+  }
+};
+
+var index = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  md1: md1,
+  md2: md2,
+  md3: md3
+});
+
 /* eslint-disable local-rules/sort-imports */
 
-const version = "3.5.8";
+const version = "3.5.10";
 
 /* eslint-disable local-rules/sort-imports */
 
@@ -27086,5 +28124,5 @@ const createVuetify = function () {
   });
 };
 
-export { components, createVuetify, directives, useDate, useDefaults, useDisplay, useGoTo, useLayout, useLocale, useRtl, useTheme, version };
+export { index as blueprints, components, createVuetify, directives, useDate, useDefaults, useDisplay, useGoTo, useLayout, useLocale, useRtl, useTheme, version };
 //# sourceMappingURL=vuetify-labs.esm.js.map