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

package/dist/vuetify.esm.js

@@ -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.
 */
@@ -3171,15 +3171,13 @@ function createTheme(options) {
   }
   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 {
@@ -7554,6 +7552,103 @@ const VInput = genericComponent()({
 
 // 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'])
@@ -7577,12 +7672,14 @@ const VCheckbox = genericComponent()({
       focus,
       blur
     } = useFocus(props);
+    const inputRef = ref();
     const uid = useId();
     useRender(() => {
       const [rootAttrs, controlAttrs] = filterInputAttrs(attrs);
       const inputProps = VInput.filterProps(props);
       const checkboxProps = VCheckboxBtn.filterProps(props);
       return createVNode(VInput, mergeProps({
+        "ref": inputRef,
         "class": ['v-checkbox', props.class]
       }, rootAttrs, inputProps, {
         "modelValue": model.value,
@@ -7615,7 +7712,7 @@ const VCheckbox = genericComponent()({
         }
       });
     });
-    return {};
+    return forwardRefs({}, inputRef);
   }
 });
 
@@ -11826,103 +11923,6 @@ const VOverlay = genericComponent()({
 
 // 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,
@@ -15423,6 +15423,7 @@ const makeVWindowProps = propsFactory({
     type: [Boolean, String],
     validator: v => typeof v === 'boolean' || v === 'hover'
   },
+  verticalArrows: [Boolean, String],
   touch: {
     type: [Object, Boolean],
     default: undefined
@@ -15557,7 +15558,8 @@ const VWindow = genericComponent()({
     useRender(() => withDirectives(createVNode(props.tag, {
       "ref": rootRef,
       "class": 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": normalizeStyle(props.style)
     }, {
@@ -15569,7 +15571,11 @@ const VWindow = genericComponent()({
       }, [slots.default?.({
         group
       }), props.showArrows !== false && createElementVNode("div", {
-        "class": "v-window__controls"
+        "class": 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
       })]
@@ -16898,6 +16904,7 @@ const VSlider = genericComponent()({
       emit
     } = _ref;
     const thumbContainerRef = ref();
+    const inputRef = ref();
     const {
       rtlClasses
     } = useRtl();
@@ -16948,6 +16955,7 @@ const VSlider = genericComponent()({
       const inputProps = VInput.filterProps(props);
       const hasPrepend = !!(props.label || slots.label || slots.prepend);
       return createVNode(VInput, mergeProps({
+        "ref": inputRef,
         "class": ['v-slider', {
           'v-slider--has-labels': !!slots['tick-label'] || hasLabels.value,
           'v-slider--focused': isFocused.value,
@@ -17006,7 +17014,7 @@ const VSlider = genericComponent()({
         }
       });
     });
-    return {};
+    return forwardRefs({}, inputRef);
   }
 });
 
@@ -26300,6 +26308,7 @@ const VRadioGroup = genericComponent()({
     const uid = useId();
     const id = computed(() => props.id || `radio-group-${uid}`);
     const model = useProxiedModel(props, 'modelValue');
+    const inputRef = ref();
     useRender(() => {
       const [rootAttrs, controlAttrs] = filterInputAttrs(attrs);
       const inputProps = VInput.filterProps(props);
@@ -26311,6 +26320,7 @@ const VRadioGroup = genericComponent()({
         }
       }) : props.label;
       return createVNode(VInput, mergeProps({
+        "ref": inputRef,
         "class": ['v-radio-group', props.class],
         "style": props.style
       }, rootAttrs, inputProps, {
@@ -26348,7 +26358,7 @@ const VRadioGroup = genericComponent()({
         }
       });
     });
-    return {};
+    return forwardRefs({}, inputRef);
   }
 });
 
@@ -26559,7 +26569,7 @@ const VRangeSlider = genericComponent()({
         }
       });
     });
-    return {};
+    return forwardRefs({}, inputRef);
   }
 });
 
@@ -28207,6 +28217,7 @@ const VSwitch = genericComponent()({
       blur
     } = useFocus(props);
     const control = ref();
+    const inputRef = ref();
     const isForcedColorsModeActive = IN_BROWSER && window.matchMedia('(forced-colors: active)').matches;
     const loaderColor = toRef(() => {
       return typeof props.loading === 'string' && props.loading !== '' ? props.loading : props.color;
@@ -28228,6 +28239,7 @@ const VSwitch = genericComponent()({
       const inputProps = VInput.filterProps(props);
       const controlProps = VSelectionControl.filterProps(props);
       return createVNode(VInput, mergeProps({
+        "ref": inputRef,
         "class": ['v-switch', {
           'v-switch--flat': props.flat
         }, {
@@ -28335,7 +28347,7 @@ const VSwitch = genericComponent()({
         }
       });
     });
-    return {};
+    return forwardRefs({}, inputRef);
   }
 });
 
@@ -29201,58 +29213,675 @@ const VTimeline = genericComponent()({
   }
 });
 
-const makeVToolbarItemsProps = propsFactory({
-  ...makeComponentProps(),
-  ...makeVariantProps({
-    variant: 'text'
-  })
-}, 'VToolbarItems');
-const VToolbarItems = genericComponent()({
-  name: 'VToolbarItems',
-  props: makeVToolbarItemsProps(),
-  setup(props, _ref) {
-    let {
-      slots
-    } = _ref;
-    provideDefaults({
-      VBtn: {
-        color: toRef(() => props.color),
-        height: 'inherit',
-        variant: toRef(() => props.variant)
-      }
-    });
-    useRender(() => createElementVNode("div", {
-      "class": normalizeClass(['v-toolbar-items', props.class]),
-      "style": 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 = ref(null);
+    const innerClockRef = ref(null);
+    const inputValue = ref(undefined);
+    const isDragging = ref(false);
+    const valueOnMouseDown = ref(null);
+    const valueOnMouseUp = ref(null);
+    const emitChangeDebounced = debounce(value => emit('change', value), 750);
+    const {
+      textColorClasses,
+      textColorStyles
+    } = useTextColor(() => props.color);
+    const {
+      backgroundColorClasses,
+      backgroundColorStyles
+    } = useBackgroundColor(() => props.color);
+    const count = computed(() => props.max - props.min + 1);
+    const roundCount = computed(() => props.double ? count.value / 2 : count.value);
+    const degreesPerUnit = computed(() => 360 / roundCount.value);
+    const degrees = computed(() => degreesPerUnit.value * Math.PI / 180);
+    const displayedValue = computed(() => props.modelValue == null ? props.min : props.modelValue);
+    const innerRadiusScale = computed(() => 0.62);
+    const genChildren = computed(() => {
+      const children = [];
+      for (let value = props.min; value <= props.max; value = value + props.step) {
+        children.push(value);
+      }
+      return children;
+    });
+    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 createElementVNode("div", {
+        "class": 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
+      }, [createElementVNode("div", {
+        "class": "v-time-picker-clock__inner",
+        "ref": innerClockRef
+      }, [createElementVNode("div", {
+        "class": normalizeClass([{
+          'v-time-picker-clock__hand': true,
+          'v-time-picker-clock__hand--inner': isInner(props.modelValue)
+        }, textColorClasses.value]),
+        "style": 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 createElementVNode("div", {
+          "class": 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": normalizeStyle([getTransform(value), isActive && backgroundColorStyles.value])
+        }, [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 createElementVNode("div", {
+        "class": "v-time-picker-controls"
+      }, [createElementVNode("div", {
+        "class": normalizeClass({
+          'v-time-picker-controls__time': true,
+          'v-time-picker-controls__time--with-seconds': props.useSeconds
+        })
+      }, [createVNode(VBtn, {
+        "active": props.viewMode === 'hour',
+        "color": props.viewMode === 'hour' ? props.color : undefined,
+        "disabled": props.disabled,
+        "variant": "tonal",
+        "class": 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), createElementVNode("span", {
+        "class": normalizeClass(['v-time-picker-controls__time__separator', {
+          'v-time-picker-controls--with-seconds__time__separator': props.useSeconds
+        }])
+      }, [createTextVNode(":")]), createVNode(VBtn, {
+        "active": props.viewMode === 'minute',
+        "color": props.viewMode === 'minute' ? props.color : undefined,
+        "class": 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 && createElementVNode("span", {
+        "class": normalizeClass(['v-time-picker-controls__time__separator', {
+          'v-time-picker-controls--with-seconds__time__separator': props.useSeconds
+        }]),
+        "key": "secondsDivider"
+      }, [createTextVNode(":")]), props.useSeconds && createVNode(VBtn, {
+        "key": "secondsVal",
+        "active": props.viewMode === 'second',
+        "color": props.viewMode === 'second' ? props.color : undefined,
+        "variant": "tonal",
+        "onClick": () => emit('update:viewMode', 'second'),
+        "class": 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 && createElementVNode("div", {
+        "class": "v-time-picker-controls__ampm"
+      }, [createVNode(VBtn, {
+        "active": props.period === 'am',
+        "color": props.period === 'am' ? props.color : undefined,
+        "class": 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), createVNode(VBtn, {
+        "active": props.period === 'pm',
+        "color": props.period === 'pm' ? props.color : undefined,
+        "class": 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 = ref(null);
+    const inputMinute = ref(null);
+    const inputSecond = ref(null);
+    const lazyInputHour = ref(null);
+    const lazyInputMinute = ref(null);
+    const lazyInputSecond = ref(null);
+    const period = ref('am');
+    const viewMode = useProxiedModel(props, 'viewMode', 'hour');
+    const controlsRef = ref(null);
+    const clockRef = ref(null);
+    const isAllowedHourCb = 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 = 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 = 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 = computed(() => {
+      return props.format === 'ampm';
+    });
+    watch(() => props.modelValue, val => setInputData(val));
+    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 createVNode(VPicker, mergeProps(pickerProps, {
+        "color": undefined,
+        "class": ['v-time-picker', props.class],
+        "style": props.style
+      }), {
+        title: () => slots.title?.() ?? createElementVNode("div", {
+          "class": "v-time-picker__title"
+        }, [t(props.title)]),
+        header: () => createVNode(VTimePickerControls, 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: () => createVNode(VTimePickerClock, 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: toRef(() => props.color),
+        height: 'inherit',
+        variant: toRef(() => props.variant)
+      }
+    });
+    useRender(() => createElementVNode("div", {
+      "class": normalizeClass(['v-toolbar-items', props.class]),
+      "style": 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
   },
@@ -29314,6 +29943,429 @@ const VTooltip = genericComponent()({
   }
 });
 
+// Types
+
+const makeVTreeviewGroupProps = propsFactory({
+  ...omit(makeVListGroupProps({
+    collapseIcon: '$treeviewCollapse',
+    expandIcon: '$treeviewExpand'
+  }), ['subgroup'])
+}, 'VTreeviewGroup');
+const VTreeviewGroup = genericComponent()({
+  name: 'VTreeviewGroup',
+  props: makeVTreeviewGroupProps(),
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    const vListGroupRef = ref();
+    const toggleIcon = computed(() => vListGroupRef.value?.isOpen ? props.collapseIcon : props.expandIcon);
+    const activatorDefaults = computed(() => ({
+      VTreeviewItem: {
+        prependIcon: undefined,
+        appendIcon: undefined,
+        active: vListGroupRef.value?.isOpen,
+        toggleIcon: toggleIcon.value
+      }
+    }));
+    useRender(() => {
+      const listGroupProps = VListGroup.filterProps(props);
+      return createVNode(VListGroup, mergeProps(listGroupProps, {
+        "ref": vListGroupRef,
+        "class": ['v-treeview-group', props.class],
+        "subgroup": true
+      }), {
+        ...slots,
+        activator: slots.activator ? slotProps => createElementVNode(Fragment, null, [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 = inject$1(VTreeviewSymbol, {
+      visibleIds: ref()
+    }).visibleIds;
+    const vListItemRef = ref();
+    const isActivatableGroupActivator = computed(() => vListItemRef.value?.root.activatable.value && vListItemRef.value?.isGroupActivator);
+    const vListItemRefIsClickable = computed(() => vListItemRef.value?.link.isClickable.value || props.value != null && !!vListItemRef.value?.list);
+    const isClickable = computed(() => !props.disabled && props.link !== false && (props.link || vListItemRefIsClickable.value || isActivatableGroupActivator.value));
+    const isFiltered = computed(() => visibleIds.value && !visibleIds.value.has(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 createVNode(VListItem, 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 createElementVNode(Fragment, null, [createVNode(VListItemAction, {
+            "start": false
+          }, {
+            default: () => [props.toggleIcon ? createVNode(VBtn, {
+              "density": "compact",
+              "icon": props.toggleIcon,
+              "loading": props.loading,
+              "variant": "text",
+              "onClick": onClickAction
+            }, {
+              loader() {
+                return createVNode(VProgressCircular, {
+                  "indeterminate": "disable-shrink",
+                  "size": "20",
+                  "width": "2"
+                }, null);
+              }
+            }) : 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 = reactive(new Set());
+    const isClickOnOpen = 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 => createElementVNode(Fragment, null, [props.selectable && (!children || children && !['leaf', 'single-leaf'].includes(props.selectStrategy)) && createElementVNode("div", null, [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": 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 ? createVNode(VTreeviewGroup, 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 createVNode(VTreeviewItem, mergeProps(listItemProps, {
+            "value": props.returnObject ? item.raw : itemProps.value,
+            "loading": loading
+          }), slotsWithItem);
+        },
+        default: () => createVNode(VTreeviewChildren, mergeProps(treeviewChildrenProps, {
+          "items": children,
+          "returnObject": props.returnObject
+        }), slots)
+      }) : slots.item?.({
+        props: itemProps,
+        item: item.raw,
+        internalItem: item
+      }) ?? createVNode(VTreeviewItem, mergeProps(itemProps, {
+        "value": props.returnObject ? 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 = toRef(() => props.activeColor);
+    const baseColor = toRef(() => props.baseColor);
+    const color = toRef(() => props.color);
+    const activated = useProxiedModel(props, 'activated');
+    const model = useProxiedModel(props, 'modelValue');
+    const _selected = useProxiedModel(props, 'selected', props.modelValue);
+    const selected = computed({
+      get: () => _selected.value,
+      set(val) {
+        _selected.value = val;
+        model.value = val;
+      }
+    });
+    const vListRef = ref();
+    const opened = computed(() => props.openAll ? openAll(items.value) : props.opened);
+    const flatItems = computed(() => flatten(items.value));
+    const search = toRef(() => props.search);
+    const {
+      filteredItems
+    } = useFilter(props, flatItems, search);
+    const visibleIds = 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(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 ? toRaw(i.raw) : i.value);
+        if (i.children) {
+          ids = ids.concat(openAll(i.children));
+        }
+      }
+      return ids;
+    }
+    provide(VTreeviewSymbol, {
+      visibleIds
+    });
+    provideDefaults({
+      VTreeviewGroup: {
+        activeColor,
+        baseColor,
+        color,
+        collapseIcon: toRef(() => props.collapseIcon),
+        expandIcon: toRef(() => props.expandIcon)
+      },
+      VTreeviewItem: {
+        activeClass: toRef(() => props.activeClass),
+        activeColor,
+        baseColor,
+        color,
+        density: toRef(() => props.density),
+        disabled: toRef(() => props.disabled),
+        lines: toRef(() => props.lines),
+        variant: toRef(() => props.variant)
+      }
+    });
+    useRender(() => {
+      const listProps = VList.filterProps(props);
+      const treeviewChildrenProps = VTreeviewChildren.filterProps(props);
+      return createVNode(VList, mergeProps({
+        "ref": vListRef
+      }, listProps, {
+        "class": ['v-treeview', {
+          '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: () => [createVNode(VTreeviewChildren, mergeProps(treeviewChildrenProps, {
+          "density": props.density,
+          "returnObject": props.returnObject,
+          "items": items.value
+        }), slots)]
+      });
+    });
+    return {};
+  }
+});
+
 // Composables
 
 // Types
@@ -29491,12 +30543,18 @@ var components = /*#__PURE__*/Object.freeze({
   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,
@@ -29820,7 +30878,7 @@ function createVuetify$1() {
     };
   });
 }
-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
@@ -29845,7 +30903,7 @@ const createVuetify = function () {
     ...options
   });
 };
-const version = "3.8.10-dev.2025-06-18";
+const version = "3.8.10-dev.2025-06-19";
 createVuetify.version = version;
 
 export { index as blueprints, components, createVuetify, directives, useDate, useDefaults, useDisplay, useGoTo, useLayout, useLocale, useRtl, useTheme, version };