vuetify 3.5.8 → 3.5.10

package/dist/vuetify-labs.js

@@ -1,5 +1,5 @@
 /*!
-* Vuetify v3.5.8
+* Vuetify v3.5.10
 * Forged by John Leider
 * Released under the MIT License.
 */
@@ -2392,7 +2392,7 @@
     const current = vue.computed(() => computedThemes.value[name.value]);
     const styles = vue.computed(() => {
       const lines = [];
-      if (current.value.dark) {
+      if (current.value?.dark) {
         createCssClass(lines, ':root', ['color-scheme: dark']);
       }
       createCssClass(lines, ':root', genCssVariables(current.value));
@@ -4376,6 +4376,8 @@
     plus: 'mdi-plus',
     minus: 'mdi-minus',
     calendar: 'mdi-calendar',
+    treeviewCollapse: 'mdi-menu-down',
+    treeviewExpand: 'mdi-menu-right',
     eyeDropper: 'mdi-eyedropper'
   };
   const mdi = {
@@ -4570,6 +4572,7 @@
 
   const makeVIconProps = propsFactory({
     color: String,
+    disabled: Boolean,
     start: Boolean,
     end: Boolean,
     icon: IconValue,
@@ -4607,11 +4610,13 @@
         if (slotValue) {
           slotIcon.value = flattenFragments(slotValue).filter(node => node.type === vue.Text && node.children && typeof node.children === 'string')[0]?.children;
         }
+        const hasClick = !!(attrs.onClick || attrs.onClickOnce);
         return vue.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],
@@ -4620,8 +4625,9 @@
             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]
         });
@@ -7762,6 +7768,126 @@
     return vue.inject(ListKey, null);
   }
 
+  /* eslint-disable sonarjs/no-identical-functions */
+  // Utilities
+  const independentActiveStrategy = mandatory => {
+    const strategy = {
+      activate: _ref => {
+        let {
+          id,
+          value,
+          activated
+        } = _ref;
+        id = vue.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 = vue.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 = vue.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 = vue.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 {
@@ -7846,7 +7972,8 @@
         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;
         }
@@ -7988,7 +8115,8 @@
         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;
         }
@@ -8032,16 +8160,24 @@
       children: vue.ref(new Map()),
       open: () => null,
       openOnSelect: () => null,
+      activate: () => null,
       select: () => null,
+      activatable: vue.ref(false),
+      selectable: vue.ref(false),
       opened: vue.ref(new Set()),
+      activated: vue.ref(new Set()),
       selected: vue.ref(new Map()),
       selectedValues: vue.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');
@@ -8050,6 +8186,20 @@
     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 activeStrategy = vue.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 = vue.computed(() => {
       if (typeof props.selectStrategy === 'object') return props.selectStrategy;
       switch (props.selectStrategy) {
@@ -8078,6 +8228,7 @@
           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));
     vue.onBeforeUnmount(() => {
       isUnmounted = true;
@@ -8096,6 +8247,9 @@
       id: vue.shallowRef(),
       root: {
         opened,
+        activatable: vue.toRef(props, 'activatable'),
+        selectable: vue.toRef(props, 'selectable'),
+        activated,
         selected,
         selectedValues: vue.computed(() => {
           const arr = [];
@@ -8169,6 +8323,26 @@
           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
       }
@@ -8187,6 +8361,8 @@
       openOnSelect: (open, e) => parent.root.openOnSelect(computedId.value, open, e),
       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))),
       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(computedId.value) === 'indeterminate'),
@@ -8309,7 +8485,9 @@
           }, [slots.default?.()]), [[vue.vShow, isOpen.value]])]
         })]
       }));
-      return {};
+      return {
+        isOpen
+      };
     }
   });
 
@@ -8382,6 +8560,8 @@
       const link = useLink(props, attrs);
       const id = vue.computed(() => props.value === undefined ? link.href.value : props.value);
       const {
+        activate,
+        isActivated,
         select,
         isSelected,
         isIndeterminate,
@@ -8391,9 +8571,9 @@
         openOnSelect
       } = useNestedItem(id, false);
       const list = useList();
-      const isActive = vue.computed(() => props.active !== false && (props.active || link.isActive?.value || isSelected.value));
+      const isActive = vue.computed(() => props.active !== false && (props.active || link.isActive?.value || (root.activatable.value ? isActivated.value : isSelected.value)));
       const isLink = vue.computed(() => props.link !== false && link.isLink.value);
-      const isClickable = vue.computed(() => !props.disabled && props.link !== false && (props.link || link.isClickable.value || props.value != null && !!list));
+      const isClickable = vue.computed(() => !props.disabled && props.link !== false && (props.link || link.isClickable.value || !!list && (root.selectable.value || root.activatable.value || props.value != null)));
       const roundedProps = vue.computed(() => props.rounded || props.nav);
       const color = vue.computed(() => props.color ?? props.activeColor);
       const variantProps = vue.computed(() => ({
@@ -8444,7 +8624,13 @@
         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 === ' ') {
@@ -8560,7 +8746,12 @@
           }, null)])]
         }), [[vue.resolveDirective("ripple"), isClickable.value && props.ripple]]);
       });
-      return {};
+      return {
+        isGroupActivator,
+        isSelected,
+        list,
+        select
+      };
     }
   });
 
@@ -8902,8 +9093,10 @@
     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) {
@@ -8936,7 +9129,9 @@
         roundedClasses
       } = useRounded(props);
       const {
+        children,
         open,
+        parents,
         select
       } = useNested(props);
       const lineClasses = vue.computed(() => props.lines ? `v-list--${props.lines}-line` : undefined);
@@ -9026,7 +9221,9 @@
       return {
         open,
         select,
-        focus
+        focus,
+        children,
+        parents
       };
     }
   });
@@ -9568,7 +9765,7 @@
       scope?.stop();
       if (!(data.isActive.value && props.scrollStrategy)) return;
       scope = vue.effectScope();
-      await vue.nextTick();
+      await new Promise(resolve => setTimeout(resolve));
       scope.active && scope.run(() => {
         if (typeof props.scrollStrategy === 'function') {
           props.scrollStrategy(data, props, scope);
@@ -10317,6 +10514,7 @@
         if (v) isActive.value = false;
       });
       const root = vue.ref();
+      const scrimEl = vue.ref();
       const contentEl = vue.ref();
       const {
         contentStyles,
@@ -10338,8 +10536,10 @@
         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 && vue.watch(isActive, val => {
         if (val) {
@@ -10426,7 +10626,8 @@
           "ref": root
         }, scopeId, attrs), [vue.createVNode(Scrim, vue.mergeProps({
           "color": scrimColor,
-          "modelValue": isActive.value && !!props.scrim
+          "modelValue": isActive.value && !!props.scrim,
+          "ref": scrimEl
         }, scrimEvents.value), null), vue.createVNode(MaybeTransition, {
           "appear": true,
           "persisted": true,
@@ -10449,6 +10650,7 @@
       })]));
       return {
         activatorEl,
+        scrimEl,
         target,
         animateClick,
         contentEl,
@@ -10644,6 +10846,9 @@
             isActive.value = false;
             overlay.value?.activatorEl?.focus();
           }
+        } else if (['Enter', ' '].includes(e.key) && props.closeOnContentClick) {
+          isActive.value = false;
+          parent?.closeParents();
         }
       }
       function onActivatorKeydown(e) {
@@ -10921,7 +11126,7 @@
       }
       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({
@@ -11906,9 +12111,11 @@
           });
         }
       });
-      vue.watch(() => props.items, val => {
-        if (!isFocused.value || !val.length || menu.value) return;
-        menu.value = true;
+      vue.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);
@@ -12343,8 +12550,8 @@
         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;
@@ -12352,10 +12559,10 @@
             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;
@@ -12408,7 +12615,7 @@
       /** @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;
@@ -12468,9 +12675,11 @@
           });
         }
       });
-      vue.watch(() => props.items, val => {
-        if (!isFocused.value || !val.length || menu.value) return;
-        menu.value = true;
+      vue.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']);
@@ -16127,6 +16336,7 @@
         }
         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;
@@ -16153,8 +16363,8 @@
           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;
@@ -16162,10 +16372,10 @@
             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;
@@ -16196,7 +16406,7 @@
       /** @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;
@@ -16273,9 +16483,11 @@
           });
         }
       });
-      vue.watch(() => props.items, val => {
-        if (!isFocused.value || !val.length || menu.value) return;
-        menu.value = true;
+      vue.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']);
@@ -17422,7 +17634,7 @@
     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);
@@ -20296,6 +20508,7 @@
         emit('click:month');
       }
       useRender(() => {
+        // TODO: add slot support and scope defaults
         return vue.createVNode("div", {
           "class": ['v-date-picker-controls']
         }, [vue.createVNode(VBtn, {
@@ -20574,6 +20787,12 @@
       const adapter = useDate();
       const rangeStart = vue.shallowRef();
       const rangeStop = vue.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 = vue.computed(() => {
         const max = ['number', 'string'].includes(typeof props.multiple) ? Number(props.multiple) : Infinity;
         return model.value.length >= max;
@@ -20584,15 +20803,15 @@
           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];
@@ -22759,12 +22978,24 @@
           default: () => [hasImage && vue.createVNode("div", {
             "key": "image",
             "class": "v-navigation-drawer__img"
-          }, [slots.image ? slots.image?.({
-            image: props.image
-          }) : vue.createVNode("img", {
-            "src": props.image,
-            "alt": ""
-          }, null)]), slots.prepend && vue.createVNode("div", {
+          }, [!slots.image ? vue.createVNode(VImg, {
+            "key": "image-img",
+            "alt": "",
+            "cover": true,
+            "height": "inherit",
+            "src": props.image
+          }, null) : vue.createVNode(VDefaultsProvider, {
+            "key": "image-defaults",
+            "disabled": !props.image,
+            "defaults": {
+              VImg: {
+                alt: '',
+                cover: true,
+                height: 'inherit',
+                src: props.image
+              }
+            }
+          }, slots.image)]), slots.prepend && vue.createVNode("div", {
             "class": "v-navigation-drawer__prepend"
           }, [slots.prepend?.()]), vue.createVNode("div", {
             "class": "v-navigation-drawer__content"
@@ -22865,7 +23096,7 @@
       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;
         }
@@ -22911,7 +23142,9 @@
       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() {
@@ -22925,6 +23158,9 @@
         blur();
         focusIndex.value = -1;
       }
+      function isValidNumber(value) {
+        return props.type === 'number' && !isNaN(Number(value));
+      }
       provideDefaults({
         VField: {
           color: vue.computed(() => props.color),
@@ -25402,78 +25638,6 @@
     }
   });
 
-  // 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 = vue.ref();
-      vue.watchEffect(() => {
-        internalModel.value = structuredClone(vue.toRaw(model.value));
-      });
-      const {
-        t
-      } = useLocale();
-      const isPristine = vue.computed(() => {
-        return deepEqual(model.value, internalModel.value);
-      });
-      function save() {
-        model.value = internalModel.value;
-        emit('save', internalModel.value);
-      }
-      function cancel() {
-        internalModel.value = structuredClone(vue.toRaw(model.value));
-        emit('cancel');
-      }
-      let actionsUsed = false;
-      useRender(() => {
-        const actions = vue.createVNode(vue.Fragment, null, [vue.createVNode(VBtn, {
-          "disabled": isPristine.value,
-          "variant": "text",
-          "color": props.color,
-          "onClick": cancel,
-          "text": t(props.cancelText)
-        }, null), vue.createVNode(VBtn, {
-          "disabled": isPristine.value,
-          "variant": "text",
-          "color": props.color,
-          "onClick": save,
-          "text": t(props.okText)
-        }, null)]);
-        return vue.createVNode(vue.Fragment, null, [slots.default?.({
-          model: internalModel,
-          get actions() {
-            actionsUsed = true;
-            return actions;
-          }
-        }), !actionsUsed && actions]);
-      });
-    }
-  });
-
   const makeVCalendarIntervalEventProps = propsFactory({
     allDay: Boolean,
     interval: Object,
@@ -25945,20 +26109,223 @@
     }
   });
 
-  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 = vue.ref();
+      vue.watchEffect(() => {
+        internalModel.value = structuredClone(vue.toRaw(model.value));
+      });
+      const {
+        t
+      } = useLocale();
+      const isPristine = vue.computed(() => {
+        return deepEqual(model.value, internalModel.value);
+      });
+      function save() {
+        model.value = internalModel.value;
+        emit('save', internalModel.value);
+      }
+      function cancel() {
+        internalModel.value = structuredClone(vue.toRaw(model.value));
+        emit('cancel');
+      }
+      let actionsUsed = false;
+      useRender(() => {
+        const actions = vue.createVNode(vue.Fragment, null, [vue.createVNode(VBtn, {
+          "disabled": isPristine.value,
+          "variant": "text",
+          "color": props.color,
+          "onClick": cancel,
+          "text": t(props.cancelText)
+        }, null), vue.createVNode(VBtn, {
+          "disabled": isPristine.value,
+          "variant": "text",
+          "color": props.color,
+          "onClick": save,
+          "text": t(props.okText)
+        }, null)]);
+        return vue.createVNode(vue.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(vue.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 vue.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 && vue.createVNode("div", {
+          "key": "media",
+          "class": "v-empty-state__media"
+        }, [!slots.media ? vue.createVNode(vue.Fragment, null, [props.image ? vue.createVNode(VImg, {
+          "key": "image",
+          "src": props.image,
+          "height": size
+        }, null) : props.icon ? vue.createVNode(VIcon, {
+          "key": "icon",
+          "size": size,
+          "icon": props.icon
+        }, null) : undefined]) : vue.createVNode(VDefaultsProvider, {
+          "key": "media-defaults",
+          "defaults": {
+            VImg: {
+              src: props.image,
+              height: size
+            },
+            VIcon: {
+              size,
+              icon: props.icon
+            }
+          }
+        }, {
+          default: () => [slots.media()]
+        })]), hasHeadline && vue.createVNode("div", {
+          "key": "headline",
+          "class": "v-empty-state__headline"
+        }, [slots.headline?.() ?? props.headline]), hasTitle && vue.createVNode("div", {
+          "key": "title",
+          "class": "v-empty-state__title"
+        }, [slots.title?.() ?? props.title]), hasText && vue.createVNode("div", {
+          "key": "text",
+          "class": "v-empty-state__text",
+          "style": {
+            maxWidth: convertToUnit(props.textWidth)
+          }
+        }, [slots.text?.() ?? props.text]), slots.default && vue.createVNode("div", {
+          "key": "content",
+          "class": "v-empty-state__content"
+        }, [slots.default()]), hasActions && vue.createVNode("div", {
+          "key": "actions",
+          "class": "v-empty-state__actions"
+        }, [vue.createVNode(VDefaultsProvider, {
+          "defaults": {
+            VBtn: {
+              class: 'v-empty-state__action-btn',
+              color: props.color,
+              text: props.actionText
+            }
+          }
+        }, {
+          default: () => [slots.actions?.({
+            props: {
+              onClick: onClickAction
+            }
+          }) ?? vue.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(),
@@ -26045,6 +26412,203 @@
     }
   });
 
+  // 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 = vue.ref();
+      function onFocus() {
+        if (!isFocused.value) focus();
+      }
+      const controlVariant = vue.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 = vue.computed(() => ({
+        click: onClickUp
+      }));
+      const decrementSlotProps = vue.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 vue.createVNode("div", {
+            "class": "v-number-input__control"
+          }, [!slots.decrement ? vue.createVNode(VBtn, {
+            "flat": true,
+            "key": "decrement-btn",
+            "height": defaultHeight,
+            "icon": "mdi-chevron-down",
+            "rounded": "0",
+            "size": "small",
+            "onClick": onClickDown
+          }, null) : vue.createVNode(VDefaultsProvider, {
+            "key": "decrement-defaults",
+            "defaults": {
+              VBtn: {
+                flat: true,
+                rounded: '0',
+                height: defaultHeight,
+                size: 'small',
+                icon: 'mdi-chevron-down'
+              }
+            }
+          }, {
+            default: () => [slots.decrement(decrementSlotProps.value)]
+          }), vue.createVNode(VDivider, {
+            "vertical": controlVariant.value !== 'stacked'
+          }, null), !slots.increment ? vue.createVNode(VBtn, {
+            "flat": true,
+            "key": "increment-btn",
+            "height": defaultHeight,
+            "icon": "mdi-chevron-up",
+            "onClick": onClickUp,
+            "rounded": "0",
+            "size": "small"
+          }, null) : vue.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 ? vue.createVNode(VDivider, {
+            "vertical": true
+          }, null) : undefined;
+        }
+        return vue.createVNode(VInput, vue.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: () => vue.createVNode(VField, vue.mergeProps(fieldProps, {
+            "active": true,
+            "focused": isFocused.value
+          }), {
+            ...slots,
+            default: _ref2 => {
+              let {
+                props: {
+                  class: fieldClass,
+                  ...slotProps
+                }
+              } = _ref2;
+              return vue.createVNode("input", vue.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' ? () => vue.createVNode("div", {
+              "class": "v-number-input__control"
+            }, [vue.createVNode(VDivider, {
+              "vertical": true
+            }, null), vue.createVNode(VBtn, {
+              "flat": true,
+              "height": "100%",
+              "icon": "mdi-plus",
+              "tile": true,
+              "onClick": onClickUp
+            }, null)]) : !props.reverse ? () => vue.createVNode(vue.Fragment, null, [dividerNode(), controlNode()]) : undefined,
+            'prepend-inner': controlVariant.value === 'split' ? () => vue.createVNode("div", {
+              "class": "v-number-input__control"
+            }, [vue.createVNode(VBtn, {
+              "flat": true,
+              "height": "100%",
+              "icon": "mdi-minus",
+              "tile": true,
+              "onClick": onClickDown
+            }, null), vue.createVNode(VDivider, {
+              "vertical": true
+            }, null)]) : props.reverse ? () => vue.createVNode(vue.Fragment, null, [controlNode(), dividerNode()]) : undefined
+          })
+        });
+      });
+    }
+  });
+
   // Utilities
 
   // Types
@@ -26492,6 +27056,8 @@
     }
   });
 
+  // Types
+
   const makeVSpeedDialProps = propsFactory({
     ...makeComponentProps(),
     ...makeVMenuProps({
@@ -26510,14 +27076,17 @@
       let {
         slots
       } = _ref;
+      const menuRef = vue.ref();
       useRender(() => {
         const menuProps = VMenu.filterProps(props);
         return vue.createVNode(VMenu, vue.mergeProps(menuProps, {
           "class": props.class,
           "style": props.style,
-          "contentClass": "v-speed-dial__content"
+          "contentClass": "v-speed-dial__content",
+          "ref": menuRef
         }), {
-          default: () => [vue.createVNode(VDefaultsProvider, {
+          ...slots,
+          default: slotProps => vue.createVNode(VDefaultsProvider, {
             "defaults": {
               VBtn: {
                 size: 'small'
@@ -26529,9 +27098,9 @@
               "group": true,
               "transition": props.transition
             }, {
-              default: () => [slots.default?.()]
+              default: () => [slots.default?.(slotProps)]
             })]
-          })]
+          })
         });
       });
       return {};
@@ -26540,132 +27109,358 @@
 
   // 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 = vue.ref();
+      const toggleIcon = vue.computed(() => vListGroupRef.value?.isOpen ? props.collapseIcon : props.expandIcon);
+      const activatorDefaults = vue.computed(() => ({
+        VTreeviewItem: {
+          prependIcon: undefined,
+          appendIcon: undefined,
+          active: vListGroupRef.value?.isOpen,
+          toggleIcon: toggleIcon.value
+        }
+      }));
+      useRender(() => {
+        const listGroupProps = VListGroup.filterProps(props);
+        return vue.createVNode(VListGroup, vue.mergeProps(listGroupProps, {
+          "ref": vListGroupRef,
+          "class": ['v-treeview-group', props.class],
+          "subgroup": true
+        }), {
+          ...slots,
+          activator: slots.activator ? slotProps => vue.createVNode(vue.Fragment, null, [vue.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 = vue.computed(() => props.value === undefined ? link.href.value : props.value);
+      const vListItemRef = vue.ref();
+      const isClickable = vue.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 = vue.inject(VTreeviewSymbol, {
+        visibleIds: vue.ref()
+      }).visibleIds;
+      useRender(() => {
+        const listItemProps = VListItem.filterProps(props);
+        const hasPrepend = slots.prepend || props.toggleIcon;
+        return vue.createVNode(VListItem, vue.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 vue.createVNode(vue.Fragment, null, [props.toggleIcon && vue.createVNode(VListItemAction, {
+              "start": false
+            }, {
+              default: () => [vue.createVNode(VBtn, {
+                "density": "compact",
+                "icon": props.toggleIcon,
+                "loading": props.loading,
+                "variant": "text"
+              }, {
+                loader() {
+                  return vue.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 = vue.shallowRef(false);
+      const hasLoaded = vue.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 vue.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 ? vue.createVNode(VTreeviewGroup, vue.mergeProps({
+          "value": itemProps?.value
+        }, treeviewGroupProps), {
+          activator: _ref4 => {
+            let {
+              props: activatorProps
+            } = _ref4;
+            return vue.createVNode(VTreeviewItem, vue.mergeProps(itemProps, activatorProps, {
+              "loading": isLoading.value,
+              "onClick": e => onClick(e, item)
+            }), slotsWithItem);
+          },
+          default: () => vue.createVNode(VTreeviewChildren, vue.mergeProps(treeviewChildrenProps, {
+            "items": children
+          }), slots)
+        }) : slots.item?.({
+          props: itemProps
+        }) ?? vue.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(vue.toRef(props, 'bgColor'));
+        items
+      } = useListItems(props);
+      const activeColor = vue.toRef(props, 'activeColor');
+      const baseColor = vue.toRef(props, 'baseColor');
+      const color = vue.toRef(props, 'color');
+      const opened = useProxiedModel(props, 'opened');
+      const activated = useProxiedModel(props, 'activated');
+      const selected = useProxiedModel(props, 'selected');
+      const vListRef = vue.ref();
+      const flatItems = vue.computed(() => flatten(items.value));
+      const search = vue.toRef(props, 'search');
       const {
-        dimensionStyles
-      } = useDimension(props);
-      function onClickAction(e) {
-        emit('click:action', e);
+        filteredItems
+      } = useFilter(props, flatItems, search);
+      const visibleIds = vue.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 vue.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 && vue.createVNode("div", {
-          "key": "media",
-          "class": "v-empty-state__media"
-        }, [!slots.media ? vue.createVNode(vue.Fragment, null, [props.image ? vue.createVNode(VImg, {
-          "key": "image",
-          "src": props.image,
-          "height": size
-        }, null) : props.icon ? vue.createVNode(VIcon, {
-          "key": "icon",
-          "size": size,
-          "icon": props.icon
-        }, null) : undefined]) : vue.createVNode(VDefaultsProvider, {
-          "key": "media-defaults",
-          "defaults": {
-            VImg: {
-              src: props.image,
-              height: size
-            },
-            VIcon: {
-              size,
-              icon: props.icon
-            }
-          }
-        }, {
-          default: () => [slots.media()]
-        })]), hasHeadline && vue.createVNode("div", {
-          "key": "headline",
-          "class": "v-empty-state__headline"
-        }, [slots.headline?.() ?? props.headline]), hasTitle && vue.createVNode("div", {
-          "key": "title",
-          "class": "v-empty-state__title"
-        }, [slots.title?.() ?? props.title]), hasText && vue.createVNode("div", {
-          "key": "text",
-          "class": "v-empty-state__text",
-          "style": {
-            maxWidth: convertToUnit(props.textWidth)
-          }
-        }, [slots.text?.() ?? props.text]), slots.default && vue.createVNode("div", {
-          "key": "content",
-          "class": "v-empty-state__content"
-        }, [slots.default()]), hasActions && vue.createVNode("div", {
-          "key": "actions",
-          "class": "v-empty-state__actions"
-        }, [vue.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;
+      }
+      vue.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
-            }
-          }) ?? vue.createVNode(VBtn, {
-            "onClick": onClickAction
-          }, null)]
-        })])]);
+        }
+        return ids;
+      }
+      vue.provide(VTreeviewSymbol, {
+        visibleIds
       });
-      return {};
+      provideDefaults({
+        VTreeviewGroup: {
+          activeColor,
+          baseColor,
+          color,
+          collapseIcon: vue.toRef(props, 'collapseIcon'),
+          expandIcon: vue.toRef(props, 'expandIcon')
+        },
+        VTreeviewItem: {
+          activeClass: vue.toRef(props, 'activeClass'),
+          activeColor,
+          baseColor,
+          color,
+          density: vue.toRef(props, 'density'),
+          disabled: vue.toRef(props, 'disabled'),
+          lines: vue.toRef(props, 'lines'),
+          variant: vue.toRef(props, 'variant')
+        }
+      });
+      useRender(() => {
+        const listProps = VList.filterProps(props);
+        const treeviewChildrenProps = VTreeviewChildren.filterProps(props);
+        return vue.createVNode(VList, vue.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: () => [vue.createVNode(VTreeviewChildren, vue.mergeProps(treeviewChildrenProps, {
+            "items": items.value
+          }), slots)]
+        });
+      });
+      return {
+        open
+      };
     }
   });
 
@@ -26781,6 +27576,7 @@
     VMessages: VMessages,
     VNavigationDrawer: VNavigationDrawer,
     VNoSsr: VNoSsr,
+    VNumberInput: VNumberInput,
     VOtpInput: VOtpInput,
     VOverlay: VOverlay,
     VPagination: VPagination,
@@ -26837,6 +27633,9 @@
     VToolbarItems: VToolbarItems,
     VToolbarTitle: VToolbarTitle,
     VTooltip: VTooltip,
+    VTreeview: VTreeview,
+    VTreeviewGroup: VTreeviewGroup,
+    VTreeviewItem: VTreeviewItem,
     VValidation: VValidation,
     VVirtualScroll: VVirtualScroll,
     VWindow: VWindow,
@@ -27063,7 +27862,7 @@
       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
@@ -27075,9 +27874,248 @@
     }
   }
 
+  // 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 */
 
@@ -27090,6 +28128,7 @@
     });
   };
 
+  exports.blueprints = index;
   exports.components = components;
   exports.createVuetify = createVuetify;
   exports.directives = directives;