@vuetify/nightly 3.8.10-dev.2025-06-18 → 3.8.10-dev.2025-06-19

package/dist/vuetify.cjs

@@ -1,5 +1,5 @@
 /*!
-* Vuetify v3.8.10-dev.2025-06-18
+* Vuetify v3.8.10-dev.2025-06-19
 * Forged by John Leider
 * Released under the MIT License.
 */
@@ -3175,15 +3175,13 @@
     }
     const globalName = new Proxy(name, {
       get(target, prop) {
-        return target[prop];
+        return Reflect.get(target, prop);
       },
       set(target, prop, val) {
         if (prop === 'value') {
           deprecate(`theme.global.name.value = ${val}`, `theme.change('${val}')`);
         }
-        // @ts-expect-error
-        target[prop] = val;
-        return true;
+        return Reflect.set(target, prop, val);
       }
     });
     return {
@@ -7558,6 +7556,103 @@
 
   // Types
 
+  const Refs = Symbol('Forwarded refs');
+
+  /** Omit properties starting with P */
+
+  /** Omit keyof $props from T */
+
+  function getDescriptor(obj, key) {
+    let currentObj = obj;
+    while (currentObj) {
+      const descriptor = Reflect.getOwnPropertyDescriptor(currentObj, key);
+      if (descriptor) return descriptor;
+      currentObj = Object.getPrototypeOf(currentObj);
+    }
+    return undefined;
+  }
+  function forwardRefs(target) {
+    for (var _len = arguments.length, refs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      refs[_key - 1] = arguments[_key];
+    }
+    target[Refs] = refs;
+    return new Proxy(target, {
+      get(target, key) {
+        if (Reflect.has(target, key)) {
+          return Reflect.get(target, key);
+        }
+
+        // Skip internal properties
+        if (typeof key === 'symbol' || key.startsWith('$') || key.startsWith('__')) return;
+        for (const ref of refs) {
+          if (ref.value && Reflect.has(ref.value, key)) {
+            const val = Reflect.get(ref.value, key);
+            return typeof val === 'function' ? val.bind(ref.value) : val;
+          }
+        }
+      },
+      has(target, key) {
+        if (Reflect.has(target, key)) {
+          return true;
+        }
+
+        // Skip internal properties
+        if (typeof key === 'symbol' || key.startsWith('$') || key.startsWith('__')) return false;
+        for (const ref of refs) {
+          if (ref.value && Reflect.has(ref.value, key)) {
+            return true;
+          }
+        }
+        return false;
+      },
+      set(target, key, value) {
+        if (Reflect.has(target, key)) {
+          return Reflect.set(target, key, value);
+        }
+
+        // Skip internal properties
+        if (typeof key === 'symbol' || key.startsWith('$') || key.startsWith('__')) return false;
+        for (const ref of refs) {
+          if (ref.value && Reflect.has(ref.value, key)) {
+            return Reflect.set(ref.value, key, value);
+          }
+        }
+        return false;
+      },
+      getOwnPropertyDescriptor(target, key) {
+        const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
+        if (descriptor) return descriptor;
+
+        // Skip internal properties
+        if (typeof key === 'symbol' || key.startsWith('$') || key.startsWith('__')) return;
+
+        // Check each ref's own properties
+        for (const ref of refs) {
+          if (!ref.value) continue;
+          const descriptor = getDescriptor(ref.value, key) ?? ('_' in ref.value ? getDescriptor(ref.value._?.setupState, key) : undefined);
+          if (descriptor) return descriptor;
+        }
+
+        // Recursive search up each ref's prototype
+        for (const ref of refs) {
+          const childRefs = ref.value && ref.value[Refs];
+          if (!childRefs) continue;
+          const queue = childRefs.slice();
+          while (queue.length) {
+            const ref = queue.shift();
+            const descriptor = getDescriptor(ref.value, key);
+            if (descriptor) return descriptor;
+            const childRefs = ref.value && ref.value[Refs];
+            if (childRefs) queue.push(...childRefs);
+          }
+        }
+        return undefined;
+      }
+    });
+  }
+
+  // Types
+
   const makeVCheckboxProps = propsFactory({
     ...makeVInputProps(),
     ...omit(makeVCheckboxBtnProps(), ['inline'])
@@ -7581,12 +7676,14 @@
         focus,
         blur
       } = useFocus(props);
+      const inputRef = vue.ref();
       const uid = vue.useId();
       useRender(() => {
         const [rootAttrs, controlAttrs] = filterInputAttrs(attrs);
         const inputProps = VInput.filterProps(props);
         const checkboxProps = VCheckboxBtn.filterProps(props);
         return vue.createVNode(VInput, vue.mergeProps({
+          "ref": inputRef,
           "class": ['v-checkbox', props.class]
         }, rootAttrs, inputProps, {
           "modelValue": model.value,
@@ -7619,7 +7716,7 @@
           }
         });
       });
-      return {};
+      return forwardRefs({}, inputRef);
     }
   });
 
@@ -11830,103 +11927,6 @@
 
   // Types
 
-  const Refs = Symbol('Forwarded refs');
-
-  /** Omit properties starting with P */
-
-  /** Omit keyof $props from T */
-
-  function getDescriptor(obj, key) {
-    let currentObj = obj;
-    while (currentObj) {
-      const descriptor = Reflect.getOwnPropertyDescriptor(currentObj, key);
-      if (descriptor) return descriptor;
-      currentObj = Object.getPrototypeOf(currentObj);
-    }
-    return undefined;
-  }
-  function forwardRefs(target) {
-    for (var _len = arguments.length, refs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-      refs[_key - 1] = arguments[_key];
-    }
-    target[Refs] = refs;
-    return new Proxy(target, {
-      get(target, key) {
-        if (Reflect.has(target, key)) {
-          return Reflect.get(target, key);
-        }
-
-        // Skip internal properties
-        if (typeof key === 'symbol' || key.startsWith('$') || key.startsWith('__')) return;
-        for (const ref of refs) {
-          if (ref.value && Reflect.has(ref.value, key)) {
-            const val = Reflect.get(ref.value, key);
-            return typeof val === 'function' ? val.bind(ref.value) : val;
-          }
-        }
-      },
-      has(target, key) {
-        if (Reflect.has(target, key)) {
-          return true;
-        }
-
-        // Skip internal properties
-        if (typeof key === 'symbol' || key.startsWith('$') || key.startsWith('__')) return false;
-        for (const ref of refs) {
-          if (ref.value && Reflect.has(ref.value, key)) {
-            return true;
-          }
-        }
-        return false;
-      },
-      set(target, key, value) {
-        if (Reflect.has(target, key)) {
-          return Reflect.set(target, key, value);
-        }
-
-        // Skip internal properties
-        if (typeof key === 'symbol' || key.startsWith('$') || key.startsWith('__')) return false;
-        for (const ref of refs) {
-          if (ref.value && Reflect.has(ref.value, key)) {
-            return Reflect.set(ref.value, key, value);
-          }
-        }
-        return false;
-      },
-      getOwnPropertyDescriptor(target, key) {
-        const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
-        if (descriptor) return descriptor;
-
-        // Skip internal properties
-        if (typeof key === 'symbol' || key.startsWith('$') || key.startsWith('__')) return;
-
-        // Check each ref's own properties
-        for (const ref of refs) {
-          if (!ref.value) continue;
-          const descriptor = getDescriptor(ref.value, key) ?? ('_' in ref.value ? getDescriptor(ref.value._?.setupState, key) : undefined);
-          if (descriptor) return descriptor;
-        }
-
-        // Recursive search up each ref's prototype
-        for (const ref of refs) {
-          const childRefs = ref.value && ref.value[Refs];
-          if (!childRefs) continue;
-          const queue = childRefs.slice();
-          while (queue.length) {
-            const ref = queue.shift();
-            const descriptor = getDescriptor(ref.value, key);
-            if (descriptor) return descriptor;
-            const childRefs = ref.value && ref.value[Refs];
-            if (childRefs) queue.push(...childRefs);
-          }
-        }
-        return undefined;
-      }
-    });
-  }
-
-  // Types
-
   const makeVMenuProps = propsFactory({
     // TODO
     // disableKeys: Boolean,
@@ -15427,6 +15427,7 @@
       type: [Boolean, String],
       validator: v => typeof v === 'boolean' || v === 'hover'
     },
+    verticalArrows: [Boolean, String],
     touch: {
       type: [Object, Boolean],
       default: undefined
@@ -15561,7 +15562,8 @@
       useRender(() => vue.withDirectives(vue.createVNode(props.tag, {
         "ref": rootRef,
         "class": vue.normalizeClass(['v-window', {
-          'v-window--show-arrows-on-hover': props.showArrows === 'hover'
+          'v-window--show-arrows-on-hover': props.showArrows === 'hover',
+          'v-window--vertical-arrows': !!props.verticalArrows
         }, themeClasses.value, props.class]),
         "style": vue.normalizeStyle(props.style)
       }, {
@@ -15573,7 +15575,11 @@
         }, [slots.default?.({
           group
         }), props.showArrows !== false && vue.createElementVNode("div", {
-          "class": "v-window__controls"
+          "class": vue.normalizeClass(['v-window__controls', {
+            'v-window__controls--left': props.verticalArrows === 'left' || props.verticalArrows === true
+          }, {
+            'v-window__controls--right': props.verticalArrows === 'right'
+          }])
         }, [arrows.value])]), slots.additional?.({
           group
         })]
@@ -16902,6 +16908,7 @@
         emit
       } = _ref;
       const thumbContainerRef = vue.ref();
+      const inputRef = vue.ref();
       const {
         rtlClasses
       } = useRtl();
@@ -16952,6 +16959,7 @@
         const inputProps = VInput.filterProps(props);
         const hasPrepend = !!(props.label || slots.label || slots.prepend);
         return vue.createVNode(VInput, vue.mergeProps({
+          "ref": inputRef,
           "class": ['v-slider', {
             'v-slider--has-labels': !!slots['tick-label'] || hasLabels.value,
             'v-slider--focused': isFocused.value,
@@ -17010,7 +17018,7 @@
           }
         });
       });
-      return {};
+      return forwardRefs({}, inputRef);
     }
   });
 
@@ -26304,6 +26312,7 @@
       const uid = vue.useId();
       const id = vue.computed(() => props.id || `radio-group-${uid}`);
       const model = useProxiedModel(props, 'modelValue');
+      const inputRef = vue.ref();
       useRender(() => {
         const [rootAttrs, controlAttrs] = filterInputAttrs(attrs);
         const inputProps = VInput.filterProps(props);
@@ -26315,6 +26324,7 @@
           }
         }) : props.label;
         return vue.createVNode(VInput, vue.mergeProps({
+          "ref": inputRef,
           "class": ['v-radio-group', props.class],
           "style": props.style
         }, rootAttrs, inputProps, {
@@ -26352,7 +26362,7 @@
           }
         });
       });
-      return {};
+      return forwardRefs({}, inputRef);
     }
   });
 
@@ -26563,7 +26573,7 @@
           }
         });
       });
-      return {};
+      return forwardRefs({}, inputRef);
     }
   });
 
@@ -28211,6 +28221,7 @@
         blur
       } = useFocus(props);
       const control = vue.ref();
+      const inputRef = vue.ref();
       const isForcedColorsModeActive = IN_BROWSER && window.matchMedia('(forced-colors: active)').matches;
       const loaderColor = vue.toRef(() => {
         return typeof props.loading === 'string' && props.loading !== '' ? props.loading : props.color;
@@ -28232,6 +28243,7 @@
         const inputProps = VInput.filterProps(props);
         const controlProps = VSelectionControl.filterProps(props);
         return vue.createVNode(VInput, vue.mergeProps({
+          "ref": inputRef,
           "class": ['v-switch', {
             'v-switch--flat': props.flat
           }, {
@@ -28339,7 +28351,7 @@
           }
         });
       });
-      return {};
+      return forwardRefs({}, inputRef);
     }
   });
 
@@ -29205,58 +29217,675 @@
     }
   });
 
-  const makeVToolbarItemsProps = propsFactory({
-    ...makeComponentProps(),
-    ...makeVariantProps({
-      variant: 'text'
-    })
-  }, 'VToolbarItems');
-  const VToolbarItems = genericComponent()({
-    name: 'VToolbarItems',
-    props: makeVToolbarItemsProps(),
-    setup(props, _ref) {
-      let {
-        slots
-      } = _ref;
-      provideDefaults({
-        VBtn: {
-          color: vue.toRef(() => props.color),
-          height: 'inherit',
-          variant: vue.toRef(() => props.variant)
-        }
-      });
-      useRender(() => vue.createElementVNode("div", {
-        "class": vue.normalizeClass(['v-toolbar-items', props.class]),
-        "style": vue.normalizeStyle(props.style)
-      }, [slots.default?.()]));
-      return {};
-    }
-  });
+  function pad(n) {
+    let length = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;
+    return String(n).padStart(length, '0');
+  }
 
   // Types
 
-  const makeVTooltipProps = propsFactory({
-    id: String,
-    interactive: Boolean,
-    text: String,
-    ...omit(makeVOverlayProps({
-      closeOnBack: false,
-      location: 'end',
-      locationStrategy: 'connected',
-      eager: true,
-      minWidth: 0,
-      offset: 10,
-      openOnClick: false,
-      openOnHover: true,
-      origin: 'auto',
-      scrim: false,
-      scrollStrategy: 'reposition',
-      transition: null
-    }), ['absolute', 'persistent'])
-  }, 'VTooltip');
-  const VTooltip = genericComponent()({
-    name: 'VTooltip',
-    props: makeVTooltipProps(),
+  const makeVTimePickerClockProps = propsFactory({
+    allowedValues: Function,
+    ampm: Boolean,
+    color: String,
+    disabled: Boolean,
+    displayedValue: null,
+    double: Boolean,
+    format: {
+      type: Function,
+      default: val => val
+    },
+    max: {
+      type: Number,
+      required: true
+    },
+    min: {
+      type: Number,
+      required: true
+    },
+    scrollable: Boolean,
+    readonly: Boolean,
+    rotate: {
+      type: Number,
+      default: 0
+    },
+    step: {
+      type: Number,
+      default: 1
+    },
+    modelValue: {
+      type: Number
+    }
+  }, 'VTimePickerClock');
+  const VTimePickerClock = genericComponent()({
+    name: 'VTimePickerClock',
+    props: makeVTimePickerClockProps(),
+    emits: {
+      change: val => true,
+      input: val => true
+    },
+    setup(props, _ref) {
+      let {
+        emit
+      } = _ref;
+      const clockRef = vue.ref(null);
+      const innerClockRef = vue.ref(null);
+      const inputValue = vue.ref(undefined);
+      const isDragging = vue.ref(false);
+      const valueOnMouseDown = vue.ref(null);
+      const valueOnMouseUp = vue.ref(null);
+      const emitChangeDebounced = debounce(value => emit('change', value), 750);
+      const {
+        textColorClasses,
+        textColorStyles
+      } = useTextColor(() => props.color);
+      const {
+        backgroundColorClasses,
+        backgroundColorStyles
+      } = useBackgroundColor(() => props.color);
+      const count = vue.computed(() => props.max - props.min + 1);
+      const roundCount = vue.computed(() => props.double ? count.value / 2 : count.value);
+      const degreesPerUnit = vue.computed(() => 360 / roundCount.value);
+      const degrees = vue.computed(() => degreesPerUnit.value * Math.PI / 180);
+      const displayedValue = vue.computed(() => props.modelValue == null ? props.min : props.modelValue);
+      const innerRadiusScale = vue.computed(() => 0.62);
+      const genChildren = vue.computed(() => {
+        const children = [];
+        for (let value = props.min; value <= props.max; value = value + props.step) {
+          children.push(value);
+        }
+        return children;
+      });
+      vue.watch(() => props.modelValue, val => {
+        inputValue.value = val;
+      });
+      function update(value) {
+        if (inputValue.value !== value) {
+          inputValue.value = value;
+        }
+        emit('input', value);
+      }
+      function isAllowed(value) {
+        return !props.allowedValues || props.allowedValues(value);
+      }
+      function wheel(e) {
+        if (!props.scrollable || props.disabled) return;
+        e.preventDefault();
+        const delta = Math.sign(-e.deltaY || 1);
+        let value = displayedValue.value;
+        do {
+          value = value + delta;
+          value = (value - props.min + count.value) % count.value + props.min;
+        } while (!isAllowed(value) && value !== displayedValue.value);
+        if (value !== props.displayedValue) {
+          update(value);
+        }
+        emitChangeDebounced(value);
+      }
+      function isInner(value) {
+        return props.double && value - props.min >= roundCount.value;
+      }
+      function handScale(value) {
+        return isInner(value) ? innerRadiusScale.value : 1;
+      }
+      function getPosition(value) {
+        const rotateRadians = props.rotate * Math.PI / 180;
+        return {
+          x: Math.sin((value - props.min) * degrees.value + rotateRadians) * handScale(value),
+          y: -Math.cos((value - props.min) * degrees.value + rotateRadians) * handScale(value)
+        };
+      }
+      function angleToValue(angle, insideClick) {
+        const value = (Math.round(angle / degreesPerUnit.value) + (insideClick ? roundCount.value : 0)) % count.value + props.min;
+
+        // Necessary to fix edge case when selecting left part of the value(s) at 12 o'clock
+        if (angle < 360 - degreesPerUnit.value / 2) return value;
+        return insideClick ? props.max - roundCount.value + 1 : props.min;
+      }
+      function getTransform(i) {
+        const {
+          x,
+          y
+        } = getPosition(i);
+        return {
+          left: `${Math.round(50 + x * 50)}%`,
+          top: `${Math.round(50 + y * 50)}%`
+        };
+      }
+      function euclidean(p0, p1) {
+        const dx = p1.x - p0.x;
+        const dy = p1.y - p0.y;
+        return Math.sqrt(dx * dx + dy * dy);
+      }
+      function angle(center, p1) {
+        const value = 2 * Math.atan2(p1.y - center.y - euclidean(center, p1), p1.x - center.x);
+        return Math.abs(value * 180 / Math.PI);
+      }
+      function setMouseDownValue(value) {
+        if (valueOnMouseDown.value === null) {
+          valueOnMouseDown.value = value;
+        }
+        valueOnMouseUp.value = value;
+        update(value);
+      }
+      function onDragMove(e) {
+        e.preventDefault();
+        if (!isDragging.value && e.type !== 'click' || !clockRef.value) return;
+        const {
+          width,
+          top,
+          left
+        } = clockRef.value?.getBoundingClientRect();
+        const {
+          width: innerWidth
+        } = innerClockRef.value?.getBoundingClientRect() ?? {
+          width: 0
+        };
+        const {
+          clientX,
+          clientY
+        } = 'touches' in e ? e.touches[0] : e;
+        const center = {
+          x: width / 2,
+          y: -width / 2
+        };
+        const coords = {
+          x: clientX - left,
+          y: top - clientY
+        };
+        const handAngle = Math.round(angle(center, coords) - props.rotate + 360) % 360;
+        const insideClick = props.double && euclidean(center, coords) < (innerWidth + innerWidth * innerRadiusScale.value) / 4;
+        const checksCount = Math.ceil(15 / degreesPerUnit.value);
+        let value;
+        for (let i = 0; i < checksCount; i++) {
+          value = angleToValue(handAngle + i * degreesPerUnit.value, insideClick);
+          if (isAllowed(value)) return setMouseDownValue(value);
+          value = angleToValue(handAngle - i * degreesPerUnit.value, insideClick);
+          if (isAllowed(value)) return setMouseDownValue(value);
+        }
+      }
+      function onMouseDown(e) {
+        if (props.disabled) return;
+        e.preventDefault();
+        window.addEventListener('mousemove', onDragMove);
+        window.addEventListener('touchmove', onDragMove);
+        window.addEventListener('mouseup', onMouseUp);
+        window.addEventListener('touchend', onMouseUp);
+        valueOnMouseDown.value = null;
+        valueOnMouseUp.value = null;
+        isDragging.value = true;
+        onDragMove(e);
+      }
+      function onMouseUp(e) {
+        e.stopPropagation();
+        window.removeEventListener('mousemove', onDragMove);
+        window.removeEventListener('touchmove', onDragMove);
+        window.removeEventListener('mouseup', onMouseUp);
+        window.removeEventListener('touchend', onMouseUp);
+        isDragging.value = false;
+        if (valueOnMouseUp.value !== null && isAllowed(valueOnMouseUp.value)) {
+          emit('change', valueOnMouseUp.value);
+        }
+      }
+      useRender(() => {
+        return vue.createElementVNode("div", {
+          "class": vue.normalizeClass([{
+            'v-time-picker-clock': true,
+            'v-time-picker-clock--indeterminate': props.modelValue == null,
+            'v-time-picker-clock--readonly': props.readonly
+          }]),
+          "onMousedown": onMouseDown,
+          "onTouchstart": onMouseDown,
+          "onWheel": wheel,
+          "ref": clockRef
+        }, [vue.createElementVNode("div", {
+          "class": "v-time-picker-clock__inner",
+          "ref": innerClockRef
+        }, [vue.createElementVNode("div", {
+          "class": vue.normalizeClass([{
+            'v-time-picker-clock__hand': true,
+            'v-time-picker-clock__hand--inner': isInner(props.modelValue)
+          }, textColorClasses.value]),
+          "style": vue.normalizeStyle([{
+            transform: `rotate(${props.rotate + degreesPerUnit.value * (displayedValue.value - props.min)}deg) scaleY(${handScale(displayedValue.value)})`
+          }, textColorStyles.value])
+        }, null), genChildren.value.map(value => {
+          const isActive = value === displayedValue.value;
+          return vue.createElementVNode("div", {
+            "class": vue.normalizeClass([{
+              'v-time-picker-clock__item': true,
+              'v-time-picker-clock__item--active': isActive,
+              'v-time-picker-clock__item--disabled': props.disabled || !isAllowed(value)
+            }, isActive && backgroundColorClasses.value]),
+            "style": vue.normalizeStyle([getTransform(value), isActive && backgroundColorStyles.value])
+          }, [vue.createElementVNode("span", null, [props.format(value)])]);
+        })])]);
+      });
+    }
+  });
+
+  // Types
+
+  const makeVTimePickerControlsProps = propsFactory({
+    ampm: Boolean,
+    color: String,
+    disabled: Boolean,
+    hour: Number,
+    minute: Number,
+    second: Number,
+    period: String,
+    readonly: Boolean,
+    useSeconds: Boolean,
+    value: Number,
+    viewMode: String
+  }, 'VTimePickerControls');
+  const VTimePickerControls = genericComponent()({
+    name: 'VTimePickerControls',
+    props: makeVTimePickerControlsProps(),
+    emits: {
+      'update:period': data => true,
+      'update:viewMode': data => true
+    },
+    setup(props, _ref) {
+      let {
+        emit,
+        slots
+      } = _ref;
+      const {
+        t
+      } = useLocale();
+      useRender(() => {
+        let hour = props.hour;
+        if (props.ampm) {
+          hour = hour ? (hour - 1) % 12 + 1 : 12;
+        }
+        return vue.createElementVNode("div", {
+          "class": "v-time-picker-controls"
+        }, [vue.createElementVNode("div", {
+          "class": vue.normalizeClass({
+            'v-time-picker-controls__time': true,
+            'v-time-picker-controls__time--with-seconds': props.useSeconds
+          })
+        }, [vue.createVNode(VBtn, {
+          "active": props.viewMode === 'hour',
+          "color": props.viewMode === 'hour' ? props.color : undefined,
+          "disabled": props.disabled,
+          "variant": "tonal",
+          "class": vue.normalizeClass({
+            'v-time-picker-controls__time__btn': true,
+            'v-time-picker-controls__time--with-ampm__btn': props.ampm,
+            'v-time-picker-controls__time--with-seconds__btn': props.useSeconds
+          }),
+          "text": props.hour == null ? '--' : pad(`${hour}`),
+          "onClick": () => emit('update:viewMode', 'hour')
+        }, null), vue.createElementVNode("span", {
+          "class": vue.normalizeClass(['v-time-picker-controls__time__separator', {
+            'v-time-picker-controls--with-seconds__time__separator': props.useSeconds
+          }])
+        }, [vue.createTextVNode(":")]), vue.createVNode(VBtn, {
+          "active": props.viewMode === 'minute',
+          "color": props.viewMode === 'minute' ? props.color : undefined,
+          "class": vue.normalizeClass({
+            'v-time-picker-controls__time__btn': true,
+            'v-time-picker-controls__time__btn__active': props.viewMode === 'minute',
+            'v-time-picker-controls__time--with-ampm__btn': props.ampm,
+            'v-time-picker-controls__time--with-seconds__btn': props.useSeconds
+          }),
+          "disabled": props.disabled,
+          "variant": "tonal",
+          "text": props.minute == null ? '--' : pad(props.minute),
+          "onClick": () => emit('update:viewMode', 'minute')
+        }, null), props.useSeconds && vue.createElementVNode("span", {
+          "class": vue.normalizeClass(['v-time-picker-controls__time__separator', {
+            'v-time-picker-controls--with-seconds__time__separator': props.useSeconds
+          }]),
+          "key": "secondsDivider"
+        }, [vue.createTextVNode(":")]), props.useSeconds && vue.createVNode(VBtn, {
+          "key": "secondsVal",
+          "active": props.viewMode === 'second',
+          "color": props.viewMode === 'second' ? props.color : undefined,
+          "variant": "tonal",
+          "onClick": () => emit('update:viewMode', 'second'),
+          "class": vue.normalizeClass({
+            'v-time-picker-controls__time__btn': true,
+            'v-time-picker-controls__time__btn__active': props.viewMode === 'second',
+            'v-time-picker-controls__time--with-seconds__btn': props.useSeconds
+          }),
+          "disabled": props.disabled,
+          "text": props.second == null ? '--' : pad(props.second)
+        }, null), props.ampm && vue.createElementVNode("div", {
+          "class": "v-time-picker-controls__ampm"
+        }, [vue.createVNode(VBtn, {
+          "active": props.period === 'am',
+          "color": props.period === 'am' ? props.color : undefined,
+          "class": vue.normalizeClass({
+            'v-time-picker-controls__ampm__am': true,
+            'v-time-picker-controls__ampm__btn': true,
+            'v-time-picker-controls__ampm__btn__active': props.period === 'am'
+          }),
+          "disabled": props.disabled,
+          "text": t('$vuetify.timePicker.am'),
+          "variant": props.disabled && props.period === 'am' ? 'elevated' : 'tonal',
+          "onClick": () => props.period !== 'am' ? emit('update:period', 'am') : null
+        }, null), vue.createVNode(VBtn, {
+          "active": props.period === 'pm',
+          "color": props.period === 'pm' ? props.color : undefined,
+          "class": vue.normalizeClass({
+            'v-time-picker-controls__ampm__pm': true,
+            'v-time-picker-controls__ampm__btn': true,
+            'v-time-picker-controls__ampm__btn__active': props.period === 'pm'
+          }),
+          "disabled": props.disabled,
+          "text": t('$vuetify.timePicker.pm'),
+          "variant": props.disabled && props.period === 'pm' ? 'elevated' : 'tonal',
+          "onClick": () => props.period !== 'pm' ? emit('update:period', 'pm') : null
+        }, null)])])]);
+      });
+      return {};
+    }
+  });
+
+  // Types
+
+  const rangeHours24 = createRange(24);
+  const rangeHours12am = createRange(12);
+  const rangeHours12pm = rangeHours12am.map(v => v + 12);
+  createRange(60);
+  const makeVTimePickerProps = propsFactory({
+    allowedHours: [Function, Array],
+    allowedMinutes: [Function, Array],
+    allowedSeconds: [Function, Array],
+    disabled: Boolean,
+    format: {
+      type: String,
+      default: 'ampm'
+    },
+    max: String,
+    min: String,
+    viewMode: {
+      type: String,
+      default: 'hour'
+    },
+    modelValue: null,
+    readonly: Boolean,
+    scrollable: Boolean,
+    useSeconds: Boolean,
+    ...omit(makeVPickerProps({
+      title: '$vuetify.timePicker.title'
+    }), ['landscape'])
+  }, 'VTimePicker');
+  const VTimePicker = genericComponent()({
+    name: 'VTimePicker',
+    props: makeVTimePickerProps(),
+    emits: {
+      'update:hour': val => true,
+      'update:minute': val => true,
+      'update:period': val => true,
+      'update:second': val => true,
+      'update:modelValue': val => true,
+      'update:viewMode': val => true
+    },
+    setup(props, _ref) {
+      let {
+        emit,
+        slots
+      } = _ref;
+      const {
+        t
+      } = useLocale();
+      const inputHour = vue.ref(null);
+      const inputMinute = vue.ref(null);
+      const inputSecond = vue.ref(null);
+      const lazyInputHour = vue.ref(null);
+      const lazyInputMinute = vue.ref(null);
+      const lazyInputSecond = vue.ref(null);
+      const period = vue.ref('am');
+      const viewMode = useProxiedModel(props, 'viewMode', 'hour');
+      const controlsRef = vue.ref(null);
+      const clockRef = vue.ref(null);
+      const isAllowedHourCb = vue.computed(() => {
+        let cb;
+        if (props.allowedHours instanceof Array) {
+          cb = val => props.allowedHours.includes(val);
+        } else {
+          cb = props.allowedHours;
+        }
+        if (!props.min && !props.max) return cb;
+        const minHour = props.min ? Number(props.min.split(':')[0]) : 0;
+        const maxHour = props.max ? Number(props.max.split(':')[0]) : 23;
+        return val => {
+          return val >= Number(minHour) && val <= Number(maxHour) && (!cb || cb(val));
+        };
+      });
+      const isAllowedMinuteCb = vue.computed(() => {
+        let cb;
+        const isHourAllowed = !isAllowedHourCb.value || inputHour.value === null || isAllowedHourCb.value(inputHour.value);
+        if (props.allowedMinutes instanceof Array) {
+          cb = val => props.allowedMinutes.includes(val);
+        } else {
+          cb = props.allowedMinutes;
+        }
+        if (!props.min && !props.max) {
+          return isHourAllowed ? cb : () => false;
+        }
+        const [minHour, minMinute] = props.min ? props.min.split(':').map(Number) : [0, 0];
+        const [maxHour, maxMinute] = props.max ? props.max.split(':').map(Number) : [23, 59];
+        const minTime = minHour * 60 + Number(minMinute);
+        const maxTime = maxHour * 60 + Number(maxMinute);
+        return val => {
+          const time = 60 * inputHour.value + val;
+          return time >= minTime && time <= maxTime && isHourAllowed && (!cb || cb(val));
+        };
+      });
+      const isAllowedSecondCb = vue.computed(() => {
+        let cb;
+        const isHourAllowed = !isAllowedHourCb.value || inputHour.value === null || isAllowedHourCb.value(inputHour.value);
+        const isMinuteAllowed = isHourAllowed && (!isAllowedMinuteCb.value || inputMinute.value === null || isAllowedMinuteCb.value(inputMinute.value));
+        if (props.allowedSeconds instanceof Array) {
+          cb = val => props.allowedSeconds.includes(val);
+        } else {
+          cb = props.allowedSeconds;
+        }
+        if (!props.min && !props.max) {
+          return isMinuteAllowed ? cb : () => false;
+        }
+        const [minHour, minMinute, minSecond] = props.min ? props.min.split(':').map(Number) : [0, 0, 0];
+        const [maxHour, maxMinute, maxSecond] = props.max ? props.max.split(':').map(Number) : [23, 59, 59];
+        const minTime = minHour * 3600 + minMinute * 60 + Number(minSecond || 0);
+        const maxTime = maxHour * 3600 + maxMinute * 60 + Number(maxSecond || 0);
+        return val => {
+          const time = 3600 * inputHour.value + 60 * inputMinute.value + val;
+          return time >= minTime && time <= maxTime && isMinuteAllowed && (!cb || cb(val));
+        };
+      });
+      const isAmPm = vue.computed(() => {
+        return props.format === 'ampm';
+      });
+      vue.watch(() => props.modelValue, val => setInputData(val));
+      vue.onMounted(() => {
+        setInputData(props.modelValue);
+      });
+      function genValue() {
+        if (inputHour.value != null && inputMinute.value != null && (!props.useSeconds || inputSecond.value != null)) {
+          return `${pad(inputHour.value)}:${pad(inputMinute.value)}` + (props.useSeconds ? `:${pad(inputSecond.value)}` : '');
+        }
+        return null;
+      }
+      function emitValue() {
+        const value = genValue();
+        if (value !== null) emit('update:modelValue', value);
+      }
+      function convert24to12(hour) {
+        return hour ? (hour - 1) % 12 + 1 : 12;
+      }
+      function convert12to24(hour, period) {
+        return hour % 12 + (period === 'pm' ? 12 : 0);
+      }
+      function setInputData(value) {
+        if (value == null || value === '') {
+          inputHour.value = null;
+          inputMinute.value = null;
+          inputSecond.value = null;
+        } else if (value instanceof Date) {
+          inputHour.value = value.getHours();
+          inputMinute.value = value.getMinutes();
+          inputSecond.value = value.getSeconds();
+        } else {
+          const [hour,, minute,, second, period] = value.trim().toLowerCase().match(/^(\d+):(\d+)(:(\d+))?([ap]m)?$/) || new Array(6);
+          inputHour.value = period ? convert12to24(parseInt(hour, 10), period) : parseInt(hour, 10);
+          inputMinute.value = parseInt(minute, 10);
+          inputSecond.value = parseInt(second || 0, 10);
+        }
+        period.value = inputHour.value == null || inputHour.value < 12 ? 'am' : 'pm';
+      }
+      function firstAllowed(type, value) {
+        const allowedFn = isAllowedHourCb.value ;
+        if (!allowedFn) return value;
+
+        // TODO: clean up (Note from V2 code)
+        const range = isAmPm.value ? value < 12 ? rangeHours12am : rangeHours12pm : rangeHours24;
+        const first = range.find(v => allowedFn((v + value) % range.length + range[0]));
+        return ((first || 0) + value) % range.length + range[0];
+      }
+      function setPeriod(val) {
+        period.value = val;
+        if (inputHour.value != null) {
+          const newHour = inputHour.value + (period.value === 'am' ? -12 : 12);
+          inputHour.value = firstAllowed('hour', newHour);
+        }
+        emit('update:period', val);
+        emitValue();
+        return true;
+      }
+      function onInput(value) {
+        if (viewMode.value === 'hour') {
+          inputHour.value = isAmPm.value ? convert12to24(value, period.value) : value;
+        } else if (viewMode.value === 'minute') {
+          inputMinute.value = value;
+        } else {
+          inputSecond.value = value;
+        }
+      }
+      function onChange(value) {
+        switch (viewMode.value || 'hour') {
+          case 'hour':
+            emit('update:hour', value);
+            break;
+          case 'minute':
+            emit('update:minute', value);
+            break;
+          case 'second':
+            emit('update:second', value);
+            break;
+        }
+        const emitChange = inputHour.value !== null && inputMinute.value !== null && (props.useSeconds ? inputSecond.value !== null : true);
+        if (viewMode.value === 'hour') {
+          viewMode.value = 'minute';
+        } else if (props.useSeconds && viewMode.value === 'minute') {
+          viewMode.value = 'second';
+        }
+        if (inputHour.value === lazyInputHour.value && inputMinute.value === lazyInputMinute.value && (!props.useSeconds || inputSecond.value === lazyInputSecond.value)) return;
+        const time = genValue();
+        if (time === null) return;
+        lazyInputHour.value = inputHour.value;
+        lazyInputMinute.value = inputMinute.value;
+        props.useSeconds && (lazyInputSecond.value = inputSecond.value);
+        emitChange && emitValue();
+      }
+      useRender(() => {
+        const pickerProps = VPicker.filterProps(props);
+        const timePickerControlsProps = VTimePickerControls.filterProps(props);
+        const timePickerClockProps = VTimePickerClock.filterProps(omit(props, ['format', 'modelValue', 'min', 'max']));
+        return vue.createVNode(VPicker, vue.mergeProps(pickerProps, {
+          "color": undefined,
+          "class": ['v-time-picker', props.class],
+          "style": props.style
+        }), {
+          title: () => slots.title?.() ?? vue.createElementVNode("div", {
+            "class": "v-time-picker__title"
+          }, [t(props.title)]),
+          header: () => vue.createVNode(VTimePickerControls, vue.mergeProps(timePickerControlsProps, {
+            "ampm": isAmPm.value,
+            "hour": inputHour.value,
+            "minute": inputMinute.value,
+            "period": period.value,
+            "second": inputSecond.value,
+            "viewMode": viewMode.value,
+            "onUpdate:period": val => setPeriod(val),
+            "onUpdate:viewMode": value => viewMode.value = value,
+            "ref": controlsRef
+          }), null),
+          default: () => vue.createVNode(VTimePickerClock, vue.mergeProps(timePickerClockProps, {
+            "allowedValues": viewMode.value === 'hour' ? isAllowedHourCb.value : viewMode.value === 'minute' ? isAllowedMinuteCb.value : isAllowedSecondCb.value,
+            "double": viewMode.value === 'hour' && !isAmPm.value,
+            "format": viewMode.value === 'hour' ? isAmPm.value ? convert24to12 : val => val : val => pad(val, 2),
+            "max": viewMode.value === 'hour' ? isAmPm.value && period.value === 'am' ? 11 : 23 : 59,
+            "min": viewMode.value === 'hour' && isAmPm.value && period.value === 'pm' ? 12 : 0,
+            "size": 20,
+            "step": viewMode.value === 'hour' ? 1 : 5,
+            "modelValue": viewMode.value === 'hour' ? inputHour.value : viewMode.value === 'minute' ? inputMinute.value : inputSecond.value,
+            "onChange": onChange,
+            "onInput": onInput,
+            "ref": clockRef
+          }), null),
+          actions: slots.actions
+        });
+      });
+    }
+  });
+
+  const makeVToolbarItemsProps = propsFactory({
+    ...makeComponentProps(),
+    ...makeVariantProps({
+      variant: 'text'
+    })
+  }, 'VToolbarItems');
+  const VToolbarItems = genericComponent()({
+    name: 'VToolbarItems',
+    props: makeVToolbarItemsProps(),
+    setup(props, _ref) {
+      let {
+        slots
+      } = _ref;
+      provideDefaults({
+        VBtn: {
+          color: vue.toRef(() => props.color),
+          height: 'inherit',
+          variant: vue.toRef(() => props.variant)
+        }
+      });
+      useRender(() => vue.createElementVNode("div", {
+        "class": vue.normalizeClass(['v-toolbar-items', props.class]),
+        "style": vue.normalizeStyle(props.style)
+      }, [slots.default?.()]));
+      return {};
+    }
+  });
+
+  // Types
+
+  const makeVTooltipProps = propsFactory({
+    id: String,
+    interactive: Boolean,
+    text: String,
+    ...omit(makeVOverlayProps({
+      closeOnBack: false,
+      location: 'end',
+      locationStrategy: 'connected',
+      eager: true,
+      minWidth: 0,
+      offset: 10,
+      openOnClick: false,
+      openOnHover: true,
+      origin: 'auto',
+      scrim: false,
+      scrollStrategy: 'reposition',
+      transition: null
+    }), ['absolute', 'persistent'])
+  }, 'VTooltip');
+  const VTooltip = genericComponent()({
+    name: 'VTooltip',
+    props: makeVTooltipProps(),
     emits: {
       'update:modelValue': value => true
     },
@@ -29318,6 +29947,429 @@
     }
   });
 
+  // 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.createElementVNode(vue.Fragment, null, [vue.createVNode(VDefaultsProvider, {
+            "defaults": activatorDefaults.value
+          }, {
+            default: () => [slots.activator?.(slotProps)]
+          })]) : undefined
+        });
+      });
+      return {};
+    }
+  });
+
+  // Types
+
+  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(),
+    emits: {
+      toggleExpand: value => true
+    },
+    setup(props, _ref) {
+      let {
+        slots,
+        emit
+      } = _ref;
+      const visibleIds = vue.inject(VTreeviewSymbol, {
+        visibleIds: vue.ref()
+      }).visibleIds;
+      const vListItemRef = vue.ref();
+      const isActivatableGroupActivator = vue.computed(() => vListItemRef.value?.root.activatable.value && vListItemRef.value?.isGroupActivator);
+      const vListItemRefIsClickable = vue.computed(() => vListItemRef.value?.link.isClickable.value || props.value != null && !!vListItemRef.value?.list);
+      const isClickable = vue.computed(() => !props.disabled && props.link !== false && (props.link || vListItemRefIsClickable.value || isActivatableGroupActivator.value));
+      const isFiltered = vue.computed(() => visibleIds.value && !visibleIds.value.has(vue.toRaw(vListItemRef.value?.id)));
+      function activateGroupActivator(e) {
+        if (isClickable.value && isActivatableGroupActivator.value) {
+          vListItemRef.value?.activate(!vListItemRef.value?.isActivated, e);
+        }
+      }
+      function onClickAction(e) {
+        e.preventDefault();
+        e.stopPropagation();
+        emit('toggleExpand', e);
+      }
+      useRender(() => {
+        const listItemProps = omit(VListItem.filterProps(props), ['onClick']);
+        const hasPrepend = slots.prepend || props.toggleIcon;
+        return vue.createVNode(VListItem, vue.mergeProps({
+          "ref": vListItemRef
+        }, listItemProps, {
+          "active": vListItemRef.value?.isActivated,
+          "class": ['v-treeview-item', {
+            'v-treeview-item--activatable-group-activator': isActivatableGroupActivator.value,
+            'v-treeview-item--filtered': isFiltered.value
+          }, props.class],
+          "ripple": false,
+          "onClick": props.onClick ?? activateGroupActivator
+        }), {
+          ...slots,
+          prepend: hasPrepend ? slotProps => {
+            return vue.createElementVNode(vue.Fragment, null, [vue.createVNode(VListItemAction, {
+              "start": false
+            }, {
+              default: () => [props.toggleIcon ? vue.createVNode(VBtn, {
+                "density": "compact",
+                "icon": props.toggleIcon,
+                "loading": props.loading,
+                "variant": "text",
+                "onClick": onClickAction
+              }, {
+                loader() {
+                  return vue.createVNode(VProgressCircular, {
+                    "indeterminate": "disable-shrink",
+                    "size": "20",
+                    "width": "2"
+                  }, null);
+                }
+              }) : vue.createElementVNode("div", {
+                "class": "v-treeview-item__level"
+              }, null)]
+            }), slots.prepend?.(slotProps)]);
+          } : undefined
+        });
+      });
+      return {};
+    }
+  });
+
+  // Types
+
+  const makeVTreeviewChildrenProps = propsFactory({
+    disabled: Boolean,
+    loadChildren: Function,
+    loadingIcon: {
+      type: String,
+      default: '$loading'
+    },
+    items: Array,
+    openOnClick: {
+      type: Boolean,
+      default: undefined
+    },
+    indeterminateIcon: {
+      type: IconValue,
+      default: '$checkboxIndeterminate'
+    },
+    falseIcon: IconValue,
+    trueIcon: IconValue,
+    returnObject: Boolean,
+    selectable: Boolean,
+    selectedColor: String,
+    selectStrategy: [String, Function, Object],
+    index: Number,
+    path: {
+      type: Array,
+      default: () => []
+    },
+    ...makeDensityProps()
+  }, 'VTreeviewChildren');
+  const VTreeviewChildren = genericComponent()({
+    name: 'VTreeviewChildren',
+    props: makeVTreeviewChildrenProps(),
+    setup(props, _ref) {
+      let {
+        slots
+      } = _ref;
+      const isLoading = vue.reactive(new Set());
+      const isClickOnOpen = vue.computed(() => !props.disabled && (props.openOnClick != null ? props.openOnClick : props.selectable));
+      async function checkChildren(item) {
+        try {
+          if (!props.items?.length || !props.loadChildren) return;
+          if (item?.children?.length === 0) {
+            isLoading.add(item.value);
+            await props.loadChildren(item.raw);
+          }
+        } finally {
+          isLoading.delete(item.value);
+        }
+      }
+      function selectItem(select, isSelected) {
+        if (props.selectable) {
+          select(!isSelected);
+        }
+      }
+      return () => slots.default?.() ?? props.items?.map((item, index) => {
+        const {
+          children,
+          props: itemProps
+        } = item;
+        const loading = isLoading.has(item.value);
+        const treeItemProps = {
+          index,
+          depth: props.path?.length ?? 0,
+          isFirst: index === 0,
+          isLast: props.items ? props.items.length - 1 === index : false,
+          path: [...props.path, index]
+        };
+        const slotsWithItem = {
+          prepend: slotProps => vue.createElementVNode(vue.Fragment, null, [props.selectable && (!children || children && !['leaf', 'single-leaf'].includes(props.selectStrategy)) && vue.createElementVNode("div", null, [vue.createVNode(VCheckboxBtn, {
+            "key": item.value,
+            "modelValue": slotProps.isSelected,
+            "disabled": props.disabled,
+            "loading": loading,
+            "color": props.selectedColor,
+            "density": props.density,
+            "indeterminate": slotProps.isIndeterminate,
+            "indeterminateIcon": props.indeterminateIcon,
+            "falseIcon": props.falseIcon,
+            "trueIcon": props.trueIcon,
+            "onClick": vue.withModifiers(() => selectItem(slotProps.select, slotProps.isSelected), ['stop']),
+            "onKeydown": e => {
+              if (!['Enter', 'Space'].includes(e.key)) return;
+              e.stopPropagation();
+              selectItem(slotProps.select, slotProps.isSelected);
+            }
+          }, null)]), slots.prepend?.({
+            ...slotProps,
+            ...treeItemProps,
+            item: item.raw,
+            internalItem: item
+          })]),
+          append: slots.append ? slotProps => slots.append?.({
+            ...slotProps,
+            ...treeItemProps,
+            item: item.raw,
+            internalItem: item
+          }) : undefined,
+          title: slots.title ? slotProps => slots.title?.({
+            ...slotProps,
+            item: item.raw,
+            internalItem: item
+          }) : undefined,
+          subtitle: slots.subtitle ? slotProps => slots.subtitle?.({
+            ...slotProps,
+            item: item.raw,
+            internalItem: item
+          }) : undefined
+        };
+        const treeviewGroupProps = VTreeviewGroup.filterProps(itemProps);
+        const treeviewChildrenProps = VTreeviewChildren.filterProps({
+          ...props,
+          ...treeItemProps
+        });
+        return children ? vue.createVNode(VTreeviewGroup, vue.mergeProps(treeviewGroupProps, {
+          "value": props.returnObject ? item.raw : treeviewGroupProps?.value,
+          "rawId": treeviewGroupProps?.value
+        }), {
+          activator: _ref2 => {
+            let {
+              props: activatorProps
+            } = _ref2;
+            const listItemProps = {
+              ...itemProps,
+              ...activatorProps,
+              value: itemProps?.value,
+              onToggleExpand: [() => checkChildren(item), activatorProps.onClick],
+              onClick: isClickOnOpen.value ? [() => checkChildren(item), activatorProps.onClick] : undefined
+            };
+            return vue.createVNode(VTreeviewItem, vue.mergeProps(listItemProps, {
+              "value": props.returnObject ? item.raw : itemProps.value,
+              "loading": loading
+            }), slotsWithItem);
+          },
+          default: () => vue.createVNode(VTreeviewChildren, vue.mergeProps(treeviewChildrenProps, {
+            "items": children,
+            "returnObject": props.returnObject
+          }), slots)
+        }) : slots.item?.({
+          props: itemProps,
+          item: item.raw,
+          internalItem: item
+        }) ?? vue.createVNode(VTreeviewItem, vue.mergeProps(itemProps, {
+          "value": props.returnObject ? vue.toRaw(item.raw) : itemProps.value
+        }), slotsWithItem);
+      });
+    }
+  });
+
+  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({
+    fluid: Boolean,
+    openAll: Boolean,
+    search: String,
+    ...makeFilterProps({
+      filterKeys: ['title']
+    }),
+    ...omit(makeVTreeviewChildrenProps(), ['index', 'path']),
+    ...omit(makeVListProps({
+      collapseIcon: '$treeviewCollapse',
+      expandIcon: '$treeviewExpand',
+      slim: true
+    }), ['itemType', 'nav', 'openStrategy']),
+    modelValue: {
+      type: Array,
+      default: () => []
+    }
+  }, 'VTreeview');
+  const VTreeview = genericComponent()({
+    name: 'VTreeview',
+    props: makeVTreeviewProps(),
+    emits: {
+      'update:opened': val => true,
+      'update:activated': val => true,
+      'update:selected': val => true,
+      'update:modelValue': val => true,
+      'click:open': value => true,
+      'click:select': value => true
+    },
+    setup(props, _ref) {
+      let {
+        slots
+      } = _ref;
+      const {
+        items
+      } = useListItems(props);
+      const activeColor = vue.toRef(() => props.activeColor);
+      const baseColor = vue.toRef(() => props.baseColor);
+      const color = vue.toRef(() => props.color);
+      const activated = useProxiedModel(props, 'activated');
+      const model = useProxiedModel(props, 'modelValue');
+      const _selected = useProxiedModel(props, 'selected', props.modelValue);
+      const selected = vue.computed({
+        get: () => _selected.value,
+        set(val) {
+          _selected.value = val;
+          model.value = val;
+        }
+      });
+      const vListRef = vue.ref();
+      const opened = vue.computed(() => props.openAll ? openAll(items.value) : props.opened);
+      const flatItems = vue.computed(() => flatten(items.value));
+      const search = vue.toRef(() => props.search);
+      const {
+        filteredItems
+      } = useFilter(props, flatItems, search);
+      const visibleIds = vue.computed(() => {
+        if (!search.value) return null;
+        const getPath = vListRef.value?.getPath;
+        if (!getPath) return null;
+        return new Set(filteredItems.value.flatMap(item => {
+          const itemVal = props.returnObject ? item.raw : item.props.value;
+          return [...getPath(itemVal), ...getChildren(itemVal)].map(vue.toRaw);
+        }));
+      });
+      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;
+      }
+      function openAll(items) {
+        let ids = [];
+        for (const i of items) {
+          if (!i.children) continue;
+          ids.push(props.returnObject ? vue.toRaw(i.raw) : i.value);
+          if (i.children) {
+            ids = ids.concat(openAll(i.children));
+          }
+        }
+        return ids;
+      }
+      vue.provide(VTreeviewSymbol, {
+        visibleIds
+      });
+      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', {
+            'v-treeview--fluid': props.fluid
+          }, props.class],
+          "open-strategy": "multiple",
+          "style": props.style,
+          "opened": opened.value,
+          "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, {
+            "density": props.density,
+            "returnObject": props.returnObject,
+            "items": items.value
+          }), slots)]
+        });
+      });
+      return {};
+    }
+  });
+
   // Composables
 
   // Types
@@ -29495,12 +30547,18 @@
     VTextField: VTextField,
     VTextarea: VTextarea,
     VThemeProvider: VThemeProvider,
+    VTimePicker: VTimePicker,
+    VTimePickerClock: VTimePickerClock,
+    VTimePickerControls: VTimePickerControls,
     VTimeline: VTimeline,
     VTimelineItem: VTimelineItem,
     VToolbar: VToolbar,
     VToolbarItems: VToolbarItems,
     VToolbarTitle: VToolbarTitle,
     VTooltip: VTooltip,
+    VTreeview: VTreeview,
+    VTreeviewGroup: VTreeviewGroup,
+    VTreeviewItem: VTreeviewItem,
     VValidation: VValidation,
     VVirtualScroll: VVirtualScroll,
     VWindow: VWindow,
@@ -29824,7 +30882,7 @@
       };
     });
   }
-  const version$1 = "3.8.10-dev.2025-06-18";
+  const version$1 = "3.8.10-dev.2025-06-19";
   createVuetify$1.version = version$1;
 
   // Vue's inject() can only be used in setup
@@ -29849,7 +30907,7 @@
       ...options
     });
   };
-  const version = "3.8.10-dev.2025-06-18";
+  const version = "3.8.10-dev.2025-06-19";
   createVuetify.version = version;
 
   exports.blueprints = index;