@vuetify/nightly 3.2.0-dev-20230322.0 → 3.2.0-dev-20230407.0

package/dist/vuetify.js

@@ -1,5 +1,5 @@
 /*!
-* Vuetify v3.2.0-dev-20230322.0
+* Vuetify v3.2.0-dev-20230407.0
 * Forged by John Leider
 * Released under the MIT License.
 */
@@ -13,7 +13,7 @@
   const IN_BROWSER = typeof window !== 'undefined';
   const SUPPORTS_INTERSECTION = IN_BROWSER && 'IntersectionObserver' in window;
   const SUPPORTS_TOUCH = IN_BROWSER && ('ontouchstart' in window || window.navigator.maxTouchPoints > 0);
-  const SUPPORTS_FOCUS_VISIBLE = IN_BROWSER && typeof CSS !== 'undefined' && CSS.supports('selector(:focus-visible)');
+  const SUPPORTS_FOCUS_VISIBLE = IN_BROWSER && typeof CSS !== 'undefined' && typeof CSS.supports !== 'undefined' && CSS.supports('selector(:focus-visible)');
 
   // Utilities
   function useResizeObserver(callback) {
@@ -983,7 +983,7 @@
         }
         return properties;
       }
-      return mergeDeep(properties.prev, properties);
+      return properties.prev ? mergeDeep(properties.prev, properties) : properties;
     });
     vue.provide(DefaultsSymbol, newDefaults);
     return newDefaults;
@@ -1933,7 +1933,8 @@
       ariaLabel: {
         item: 'Rating {0} of {1}'
       }
-    }
+    },
+    loading: 'Loading...'
   };
 
   const LANG_PREFIX = '$vuetify.';
@@ -2210,6 +2211,7 @@
     return genericComponent()({
       name,
       props: {
+        disabled: Boolean,
         group: Boolean,
         hideOnLeave: Boolean,
         leaveAbsolute: Boolean,
@@ -2226,56 +2228,62 @@
         let {
           slots
         } = _ref;
+        const functions = {
+          onBeforeEnter(el) {
+            el.style.transformOrigin = props.origin;
+          },
+          onLeave(el) {
+            if (props.leaveAbsolute) {
+              const {
+                offsetTop,
+                offsetLeft,
+                offsetWidth,
+                offsetHeight
+              } = el;
+              el._transitionInitialStyles = {
+                position: el.style.position,
+                top: el.style.top,
+                left: el.style.left,
+                width: el.style.width,
+                height: el.style.height
+              };
+              el.style.position = 'absolute';
+              el.style.top = `${offsetTop}px`;
+              el.style.left = `${offsetLeft}px`;
+              el.style.width = `${offsetWidth}px`;
+              el.style.height = `${offsetHeight}px`;
+            }
+            if (props.hideOnLeave) {
+              el.style.setProperty('display', 'none', 'important');
+            }
+          },
+          onAfterLeave(el) {
+            if (props.leaveAbsolute && el?._transitionInitialStyles) {
+              const {
+                position,
+                top,
+                left,
+                width,
+                height
+              } = el._transitionInitialStyles;
+              delete el._transitionInitialStyles;
+              el.style.position = position || '';
+              el.style.top = top || '';
+              el.style.left = left || '';
+              el.style.width = width || '';
+              el.style.height = height || '';
+            }
+          }
+        };
         return () => {
           const tag = props.group ? vue.TransitionGroup : vue.Transition;
           return vue.h(tag, {
-            name,
-            mode: props.mode,
-            onBeforeEnter(el) {
-              el.style.transformOrigin = props.origin;
-            },
-            onLeave(el) {
-              if (props.leaveAbsolute) {
-                const {
-                  offsetTop,
-                  offsetLeft,
-                  offsetWidth,
-                  offsetHeight
-                } = el;
-                el._transitionInitialStyles = {
-                  position: el.style.position,
-                  top: el.style.top,
-                  left: el.style.left,
-                  width: el.style.width,
-                  height: el.style.height
-                };
-                el.style.position = 'absolute';
-                el.style.top = `${offsetTop}px`;
-                el.style.left = `${offsetLeft}px`;
-                el.style.width = `${offsetWidth}px`;
-                el.style.height = `${offsetHeight}px`;
-              }
-              if (props.hideOnLeave) {
-                el.style.setProperty('display', 'none', 'important');
-              }
-            },
-            onAfterLeave(el) {
-              if (props.leaveAbsolute && el?._transitionInitialStyles) {
-                const {
-                  position,
-                  top,
-                  left,
-                  width,
-                  height
-                } = el._transitionInitialStyles;
-                delete el._transitionInitialStyles;
-                el.style.position = position || '';
-                el.style.top = top || '';
-                el.style.left = left || '';
-                el.style.width = width || '';
-                el.style.height = height || '';
-              }
-            }
+            name: props.disabled ? '' : name,
+            css: !props.disabled,
+            ...(props.group ? undefined : {
+              mode: props.mode
+            }),
+            ...(props.disabled ? {} : functions)
           }, slots.default);
         };
       }
@@ -2289,7 +2297,8 @@
         mode: {
           type: String,
           default: mode
-        }
+        },
+        disabled: Boolean
       },
       setup(props, _ref2) {
         let {
@@ -2297,9 +2306,10 @@
         } = _ref2;
         return () => {
           return vue.h(vue.Transition, {
-            name,
+            name: props.disabled ? '' : name,
+            css: !props.disabled,
             // mode: props.mode, // TODO: vuejs/vue-next#3104
-            ...functions
+            ...(props.disabled ? {} : functions)
           }, slots.default);
         };
       }
@@ -5509,7 +5519,11 @@
           "key": "clear"
         }, {
           default: () => [vue.withDirectives(vue.createVNode("div", {
-            "class": "v-field__clearable"
+            "class": "v-field__clearable",
+            "onMousedown": e => {
+              e.preventDefault();
+              e.stopPropagation();
+            }
           }, [slots.clear ? slots.clear() : vue.createVNode(InputIcon, {
             "name": "clear"
           }, null)]), [[vue.vShow, props.dirty]])]
@@ -5829,7 +5843,7 @@
       const results = [];
       isValidating.value = true;
       for (const rule of props.rules) {
-        if (results.length >= (props.maxErrors ?? 1)) {
+        if (results.length >= +(props.maxErrors ?? 1)) {
           break;
         }
         const handler = typeof rule === 'function' ? rule : () => rule;
@@ -6015,6 +6029,15 @@
 
   /** Omit properties starting with P */
 
+  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];
@@ -6025,6 +6048,9 @@
         if (Reflect.has(target, key)) {
           return Reflect.get(target, key);
         }
+
+        // Skip internal properties
+        if (typeof key === 'symbol' || key.startsWith('__')) return;
         for (const ref of refs) {
           if (ref.value && Reflect.has(ref.value, key)) {
             const val = Reflect.get(ref.value, key);
@@ -6032,6 +6058,20 @@
           }
         }
       },
+      has(target, key) {
+        if (Reflect.has(target, key)) {
+          return true;
+        }
+
+        // Skip internal properties
+        if (typeof key === 'symbol' || key.startsWith('__')) return false;
+        for (const ref of refs) {
+          if (ref.value && Reflect.has(ref.value, key)) {
+            return true;
+          }
+        }
+        return false;
+      },
       getOwnPropertyDescriptor(target, key) {
         const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
         if (descriptor) return descriptor;
@@ -6042,30 +6082,18 @@
         // Check each ref's own properties
         for (const ref of refs) {
           if (!ref.value) continue;
-          const descriptor = Reflect.getOwnPropertyDescriptor(ref.value, key);
+          const descriptor = getDescriptor(ref.value, key) ?? ('_' in ref.value ? getDescriptor(ref.value._?.setupState, key) : undefined);
           if (descriptor) return descriptor;
-          if ('_' in ref.value && 'setupState' in ref.value._) {
-            const descriptor = Reflect.getOwnPropertyDescriptor(ref.value._.setupState, key);
-            if (descriptor) return descriptor;
-          }
         }
+
         // Recursive search up each ref's prototype
-        for (const ref of refs) {
-          let obj = ref.value && Object.getPrototypeOf(ref.value);
-          while (obj) {
-            const descriptor = Reflect.getOwnPropertyDescriptor(obj, key);
-            if (descriptor) return descriptor;
-            obj = Object.getPrototypeOf(obj);
-          }
-        }
-        // Call forwarded refs' proxies
         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 = Reflect.getOwnPropertyDescriptor(ref.value, key);
+            const descriptor = getDescriptor(ref.value, key);
             if (descriptor) return descriptor;
             const childRefs = ref.value && ref.value[Refs];
             if (childRefs) queue.push(...childRefs);
@@ -6167,12 +6195,14 @@
       }
       function onInput(e) {
         const el = e.target;
-        const caretPosition = [el.selectionStart, el.selectionEnd];
         model.value = el.value;
-        vue.nextTick(() => {
-          el.selectionStart = caretPosition[0];
-          el.selectionEnd = caretPosition[1];
-        });
+        if (['text', 'search', 'password', 'tel', 'url'].includes(props.type)) {
+          const caretPosition = [el.selectionStart, el.selectionEnd];
+          vue.nextTick(() => {
+            el.selectionStart = caretPosition[0];
+            el.selectionEnd = caretPosition[1];
+          });
+        }
       }
       useRender(() => {
         const hasCounter = !!(slots.counter || props.counter || props.counterValue);
@@ -6586,7 +6616,7 @@
     inheritAttrs: false,
     props: {
       ...makeVInputProps(),
-      ...makeVCheckboxBtnProps()
+      ...omit(makeVCheckboxBtnProps(), ['inline'])
     },
     emits: {
       'update:focused': focused => true
@@ -7555,6 +7585,9 @@
       } = useNestedItem(vue.toRef(props, 'value'), true);
       const id = vue.computed(() => `v-list-group--id-${String(_id.value)}`);
       const list = useList();
+      const {
+        isBooted
+      } = useSsrBoot();
       function onClick(e) {
         open(!isOpen.value, e);
       }
@@ -7564,6 +7597,17 @@
         id: id.value
       }));
       const toggleIcon = vue.computed(() => isOpen.value ? props.collapseIcon : props.expandIcon);
+      const activatorDefaults = vue.computed(() => ({
+        VListItem: {
+          active: isOpen.value,
+          activeColor: props.activeColor,
+          color: props.color,
+          prependIcon: props.prependIcon || props.subgroup && toggleIcon.value,
+          appendIcon: props.appendIcon || !props.subgroup && toggleIcon.value,
+          title: props.title,
+          value: props.value
+        }
+      }));
       useRender(() => vue.createVNode(props.tag, {
         "class": ['v-list-group', {
           'v-list-group--prepend': list?.hasPrepend.value,
@@ -7573,17 +7617,7 @@
         }]
       }, {
         default: () => [slots.activator && vue.createVNode(VDefaultsProvider, {
-          "defaults": {
-            VListItem: {
-              active: isOpen.value,
-              activeColor: props.activeColor,
-              color: props.color,
-              prependIcon: props.prependIcon || props.subgroup && toggleIcon.value,
-              appendIcon: props.appendIcon || !props.subgroup && toggleIcon.value,
-              title: props.title,
-              value: props.value
-            }
-          }
+          "defaults": activatorDefaults.value
         }, {
           default: () => [vue.createVNode(VListGroupActivator, null, {
             default: () => [slots.activator({
@@ -7591,7 +7625,12 @@
               isOpen: isOpen.value
             })]
           })]
-        }), vue.createVNode(VExpandTransition, null, {
+        }), vue.createVNode(MaybeTransition, {
+          "transition": {
+            component: VExpandTransition
+          },
+          "disabled": !isBooted.value
+        }, {
           default: () => [vue.withDirectives(vue.createVNode("div", {
             "class": "v-list-group__items",
             "role": "group",
@@ -10396,14 +10435,13 @@
             }, {
               default: () => [!displayItems.value.length && !props.hideNoData && (slots['no-data']?.() ?? vue.createVNode(VListItem, {
                 "title": t(props.noDataText)
-              }, null)), slots['prepend-item']?.(), displayItems.value.map((item, index) => slots.item?.({
+              }, null)), slots['prepend-item']?.(), displayItems.value.map(item => slots.item?.({
                 item,
-                index,
                 props: vue.mergeProps(item.props, {
                   onClick: () => select(item)
                 })
               }) ?? vue.createVNode(VListItem, vue.mergeProps({
-                "key": index
+                "key": item.value
               }, item.props, {
                 "onClick": () => select(item)
               }), {
@@ -10538,7 +10576,7 @@
       });
       useRender(() => {
         const value = Number(props.content);
-        const content = !props.max || isNaN(value) ? props.content : value <= props.max ? value : `${props.max}+`;
+        const content = !props.max || isNaN(value) ? props.content : value <= +props.max ? value : `${props.max}+`;
         const [badgeAttrs, attrs] = pick(ctx.attrs, ['aria-atomic', 'aria-label', 'aria-live', 'role', 'title']);
         return vue.createVNode(props.tag, vue.mergeProps({
           "class": ['v-badge', {
@@ -11335,47 +11373,48 @@
 
   const VWindowSymbol = Symbol.for('vuetify:v-window');
   const VWindowGroupSymbol = Symbol.for('vuetify:v-window-group');
+  const makeVWindowProps = propsFactory({
+    continuous: Boolean,
+    nextIcon: {
+      type: [Boolean, String, Function, Object],
+      default: '$next'
+    },
+    prevIcon: {
+      type: [Boolean, String, Function, Object],
+      default: '$prev'
+    },
+    reverse: Boolean,
+    showArrows: {
+      type: [Boolean, String],
+      validator: v => typeof v === 'boolean' || v === 'hover'
+    },
+    touch: {
+      type: [Object, Boolean],
+      default: undefined
+    },
+    direction: {
+      type: String,
+      default: 'horizontal'
+    },
+    modelValue: null,
+    disabled: Boolean,
+    selectedClass: {
+      type: String,
+      default: 'v-window-item--active'
+    },
+    // TODO: mandatory should probably not be exposed but do this for now
+    mandatory: {
+      default: 'force'
+    },
+    ...makeTagProps(),
+    ...makeThemeProps()
+  }, 'v-window');
   const VWindow = genericComponent()({
     name: 'VWindow',
     directives: {
       Touch
     },
-    props: {
-      continuous: Boolean,
-      nextIcon: {
-        type: [Boolean, String, Function, Object],
-        default: '$next'
-      },
-      prevIcon: {
-        type: [Boolean, String, Function, Object],
-        default: '$prev'
-      },
-      reverse: Boolean,
-      showArrows: {
-        type: [Boolean, String],
-        validator: v => typeof v === 'boolean' || v === 'hover'
-      },
-      touch: {
-        type: [Object, Boolean],
-        default: undefined
-      },
-      direction: {
-        type: String,
-        default: 'horizontal'
-      },
-      modelValue: null,
-      disabled: Boolean,
-      selectedClass: {
-        type: String,
-        default: 'v-window-item--active'
-      },
-      // TODO: mandatory should probably not be exposed but do this for now
-      mandatory: {
-        default: 'force'
-      },
-      ...makeTagProps(),
-      ...makeThemeProps()
-    },
+    props: makeVWindowProps(),
     emits: {
       'update:modelValue': v => true
     },
@@ -11503,112 +11542,6 @@
     }
   });
 
-  const VWindowItem = genericComponent()({
-    name: 'VWindowItem',
-    directives: {
-      Touch
-    },
-    props: {
-      reverseTransition: {
-        type: [Boolean, String],
-        default: undefined
-      },
-      transition: {
-        type: [Boolean, String],
-        default: undefined
-      },
-      ...makeGroupItemProps(),
-      ...makeLazyProps()
-    },
-    emits: {
-      'group:selected': val => true
-    },
-    setup(props, _ref) {
-      let {
-        slots
-      } = _ref;
-      const window = vue.inject(VWindowSymbol);
-      const groupItem = useGroupItem(props, VWindowGroupSymbol);
-      const {
-        isBooted
-      } = useSsrBoot();
-      if (!window || !groupItem) throw new Error('[Vuetify] VWindowItem must be used inside VWindow');
-      const isTransitioning = vue.ref(false);
-      const hasTransition = vue.computed(() => window.isReversed.value ? props.reverseTransition !== false : props.transition !== false);
-      function onAfterTransition() {
-        if (!isTransitioning.value || !window) {
-          return;
-        }
-
-        // Finalize transition state.
-        isTransitioning.value = false;
-        if (window.transitionCount.value > 0) {
-          window.transitionCount.value -= 1;
-
-          // Remove container height if we are out of transition.
-          if (window.transitionCount.value === 0) {
-            window.transitionHeight.value = undefined;
-          }
-        }
-      }
-      function onBeforeTransition() {
-        if (isTransitioning.value || !window) {
-          return;
-        }
-
-        // Initialize transition state here.
-        isTransitioning.value = true;
-        if (window.transitionCount.value === 0) {
-          // Set initial height for height transition.
-          window.transitionHeight.value = convertToUnit(window.rootRef.value?.clientHeight);
-        }
-        window.transitionCount.value += 1;
-      }
-      function onTransitionCancelled() {
-        onAfterTransition(); // This should have the same path as normal transition end.
-      }
-
-      function onEnterTransition(el) {
-        if (!isTransitioning.value) {
-          return;
-        }
-        vue.nextTick(() => {
-          // Do not set height if no transition or cancelled.
-          if (!hasTransition.value || !isTransitioning.value || !window) {
-            return;
-          }
-
-          // Set transition target height.
-          window.transitionHeight.value = convertToUnit(el.clientHeight);
-        });
-      }
-      const transition = vue.computed(() => {
-        const name = window.isReversed.value ? props.reverseTransition : props.transition;
-        return !hasTransition.value ? false : {
-          name: typeof name !== 'string' ? window.transition.value : name,
-          onBeforeEnter: onBeforeTransition,
-          onAfterEnter: onAfterTransition,
-          onEnterCancelled: onTransitionCancelled,
-          onBeforeLeave: onBeforeTransition,
-          onAfterLeave: onAfterTransition,
-          onLeaveCancelled: onTransitionCancelled,
-          onEnter: onEnterTransition
-        };
-      });
-      const {
-        hasContent
-      } = useLazy(props, groupItem.isSelected);
-      useRender(() => vue.createVNode(MaybeTransition, {
-        "transition": isBooted.value && transition.value
-      }, {
-        default: () => [vue.withDirectives(vue.createVNode("div", {
-          "class": ['v-window-item', groupItem.selectedClass.value]
-        }, [hasContent.value && slots.default?.()]), [[vue.vShow, groupItem.isSelected.value]])]
-      }));
-      return {};
-    }
-  });
-
   // Types
 
   const VCarousel = genericComponent()({
@@ -11629,16 +11562,15 @@
       interval: {
         type: [Number, String],
         default: 6000,
-        validator: value => value > 0
+        validator: value => Number(value) > 0
       },
-      modelValue: null,
       progress: [Boolean, String],
-      showArrows: {
-        type: [Boolean, String],
-        default: true,
-        validator: v => typeof v === 'boolean' || v === 'hover'
-      },
-      verticalDelimiters: [Boolean, String]
+      verticalDelimiters: [Boolean, String],
+      ...makeVWindowProps({
+        continuous: true,
+        mandatory: 'force',
+        showArrows: true
+      })
     },
     emits: {
       'update:modelValue': val => true
@@ -11706,6 +11638,7 @@
           }, {
             default: () => [group.items.value.map((item, index) => {
               const props = {
+                id: `carousel-item-${item.id}`,
                 'aria-label': t('$vuetify.carousel.ariaLabel.delimiter', index + 1, group.items.value.length),
                 class: [group.isSelected(item.id) && 'v-btn--active'],
                 onClick: () => group.select(item.id, true)
@@ -11728,31 +11661,191 @@
     }
   });
 
-  // Types
-
-  const VCarouselItem = genericComponent()({
-    name: 'VCarouselItem',
-    inheritAttrs: false,
+  const VWindowItem = genericComponent()({
+    name: 'VWindowItem',
+    directives: {
+      Touch
+    },
     props: {
-      value: null
+      reverseTransition: {
+        type: [Boolean, String],
+        default: undefined
+      },
+      transition: {
+        type: [Boolean, String],
+        default: undefined
+      },
+      ...makeGroupItemProps(),
+      ...makeLazyProps()
+    },
+    emits: {
+      'group:selected': val => true
     },
     setup(props, _ref) {
       let {
-        slots,
-        attrs
+        slots
       } = _ref;
-      useRender(() => vue.createVNode(VWindowItem, {
-        "class": "v-carousel-item",
-        "value": props.value
-      }, {
-        default: () => [vue.createVNode(VImg, attrs, slots)]
-      }));
-    }
-  });
-
-  const VCode = createSimpleFunctional('v-code');
-
-  // Types
+      const window = vue.inject(VWindowSymbol);
+      const groupItem = useGroupItem(props, VWindowGroupSymbol);
+      const {
+        isBooted
+      } = useSsrBoot();
+      if (!window || !groupItem) throw new Error('[Vuetify] VWindowItem must be used inside VWindow');
+      const isTransitioning = vue.ref(false);
+      const hasTransition = vue.computed(() => window.isReversed.value ? props.reverseTransition !== false : props.transition !== false);
+      function onAfterTransition() {
+        if (!isTransitioning.value || !window) {
+          return;
+        }
+
+        // Finalize transition state.
+        isTransitioning.value = false;
+        if (window.transitionCount.value > 0) {
+          window.transitionCount.value -= 1;
+
+          // Remove container height if we are out of transition.
+          if (window.transitionCount.value === 0) {
+            window.transitionHeight.value = undefined;
+          }
+        }
+      }
+      function onBeforeTransition() {
+        if (isTransitioning.value || !window) {
+          return;
+        }
+
+        // Initialize transition state here.
+        isTransitioning.value = true;
+        if (window.transitionCount.value === 0) {
+          // Set initial height for height transition.
+          window.transitionHeight.value = convertToUnit(window.rootRef.value?.clientHeight);
+        }
+        window.transitionCount.value += 1;
+      }
+      function onTransitionCancelled() {
+        onAfterTransition(); // This should have the same path as normal transition end.
+      }
+
+      function onEnterTransition(el) {
+        if (!isTransitioning.value) {
+          return;
+        }
+        vue.nextTick(() => {
+          // Do not set height if no transition or cancelled.
+          if (!hasTransition.value || !isTransitioning.value || !window) {
+            return;
+          }
+
+          // Set transition target height.
+          window.transitionHeight.value = convertToUnit(el.clientHeight);
+        });
+      }
+      const transition = vue.computed(() => {
+        const name = window.isReversed.value ? props.reverseTransition : props.transition;
+        return !hasTransition.value ? false : {
+          name: typeof name !== 'string' ? window.transition.value : name,
+          onBeforeEnter: onBeforeTransition,
+          onAfterEnter: onAfterTransition,
+          onEnterCancelled: onTransitionCancelled,
+          onBeforeLeave: onBeforeTransition,
+          onAfterLeave: onAfterTransition,
+          onLeaveCancelled: onTransitionCancelled,
+          onEnter: onEnterTransition
+        };
+      });
+      const {
+        hasContent
+      } = useLazy(props, groupItem.isSelected);
+      useRender(() => vue.createVNode(MaybeTransition, {
+        "transition": transition.value,
+        "disabled": !isBooted.value
+      }, {
+        default: () => [vue.withDirectives(vue.createVNode("div", {
+          "class": ['v-window-item', groupItem.selectedClass.value]
+        }, [hasContent.value && slots.default?.()]), [[vue.vShow, groupItem.isSelected.value]])]
+      }));
+      return {};
+    }
+  });
+
+  // Types
+
+  const VCarouselItem = genericComponent()({
+    name: 'VCarouselItem',
+    inheritAttrs: false,
+    props: {
+      value: null
+    },
+    setup(props, _ref) {
+      let {
+        slots,
+        attrs
+      } = _ref;
+      useRender(() => vue.createVNode(VWindowItem, {
+        "class": "v-carousel-item",
+        "value": props.value
+      }, {
+        default: () => [vue.createVNode(VImg, attrs, slots)]
+      }));
+    }
+  });
+
+  const VCode = createSimpleFunctional('v-code');
+
+  const makeVSheetProps = propsFactory({
+    color: String,
+    ...makeBorderProps(),
+    ...makeDimensionProps(),
+    ...makeElevationProps(),
+    ...makeLocationProps(),
+    ...makePositionProps(),
+    ...makeRoundedProps(),
+    ...makeTagProps(),
+    ...makeThemeProps()
+  }, 'v-sheet');
+  const VSheet = genericComponent()({
+    name: 'VSheet',
+    props: {
+      ...makeVSheetProps()
+    },
+    setup(props, _ref) {
+      let {
+        slots
+      } = _ref;
+      const {
+        themeClasses
+      } = provideTheme(props);
+      const {
+        backgroundColorClasses,
+        backgroundColorStyles
+      } = useBackgroundColor(vue.toRef(props, 'color'));
+      const {
+        borderClasses
+      } = useBorder(props);
+      const {
+        dimensionStyles
+      } = useDimension(props);
+      const {
+        elevationClasses
+      } = useElevation(props);
+      const {
+        locationStyles
+      } = useLocation(props);
+      const {
+        positionClasses
+      } = usePosition(props);
+      const {
+        roundedClasses
+      } = useRounded(props);
+      useRender(() => vue.createVNode(props.tag, {
+        "class": ['v-sheet', themeClasses.value, backgroundColorClasses.value, borderClasses.value, elevationClasses.value, positionClasses.value, roundedClasses.value],
+        "style": [backgroundColorStyles.value, dimensionStyles.value, locationStyles.value]
+      }, slots));
+      return {};
+    }
+  });
+
+  // Types
 
   const VColorPickerCanvas = defineComponent({
     name: 'VColorPickerCanvas',
@@ -12294,7 +12387,7 @@
     });
     const min = vue.computed(() => parseFloat(props.min));
     const max = vue.computed(() => parseFloat(props.max));
-    const step = vue.computed(() => props.step > 0 ? parseFloat(props.step) : 0);
+    const step = vue.computed(() => +props.step > 0 ? parseFloat(props.step) : 0);
     const decimals = vue.computed(() => Math.max(getDecimals(step.value), getDecimals(min.value)));
     const thumbSize = vue.computed(() => parseInt(props.thumbSize, 10));
     const tickSize = vue.computed(() => parseInt(props.tickSize, 10));
@@ -12788,7 +12881,7 @@
         }), {
           ...slots,
           prepend: hasPrepend ? slotProps => vue.createVNode(vue.Fragment, null, [slots.label?.(slotProps) ?? props.label ? vue.createVNode(VLabel, {
-            "id": slotProps.id,
+            "id": slotProps.id.value,
             "class": "v-slider__label",
             "text": props.label
           }, null) : undefined, slots.prepend?.(slotProps)]) : undefined,
@@ -13273,59 +13366,6 @@
     }
   });
 
-  const makeVSheetProps = propsFactory({
-    color: String,
-    ...makeBorderProps(),
-    ...makeDimensionProps(),
-    ...makeElevationProps(),
-    ...makeLocationProps(),
-    ...makePositionProps(),
-    ...makeRoundedProps(),
-    ...makeTagProps(),
-    ...makeThemeProps()
-  }, 'v-sheet');
-  const VSheet = genericComponent()({
-    name: 'VSheet',
-    props: {
-      ...makeVSheetProps()
-    },
-    setup(props, _ref) {
-      let {
-        slots
-      } = _ref;
-      const {
-        themeClasses
-      } = provideTheme(props);
-      const {
-        backgroundColorClasses,
-        backgroundColorStyles
-      } = useBackgroundColor(vue.toRef(props, 'color'));
-      const {
-        borderClasses
-      } = useBorder(props);
-      const {
-        dimensionStyles
-      } = useDimension(props);
-      const {
-        elevationClasses
-      } = useElevation(props);
-      const {
-        locationStyles
-      } = useLocation(props);
-      const {
-        positionClasses
-      } = usePosition(props);
-      const {
-        roundedClasses
-      } = useRounded(props);
-      useRender(() => vue.createVNode(props.tag, {
-        "class": ['v-sheet', themeClasses.value, backgroundColorClasses.value, borderClasses.value, elevationClasses.value, positionClasses.value, roundedClasses.value],
-        "style": [backgroundColorStyles.value, dimensionStyles.value, locationStyles.value]
-      }, slots));
-      return {};
-    }
-  });
-
   // Types
 
   const VColorPicker = defineComponent({
@@ -13362,13 +13402,9 @@
       modelValue: {
         type: [Object, String]
       },
-      width: {
-        type: [Number, String],
-        default: 300
-      },
-      ...makeElevationProps(),
-      ...makeRoundedProps(),
-      ...makeThemeProps()
+      ...omit(makeVSheetProps({
+        width: 300
+      }), ['height', 'location', 'minHeight', 'maxHeight', 'minWidth', 'maxWidth'])
     },
     emits: {
       'update:modelValue': color => true,
@@ -13406,53 +13442,57 @@
           trackFillColor: undefined
         }
       });
-      useRender(() => vue.createVNode(VSheet, {
-        "rounded": props.rounded,
-        "elevation": props.elevation,
-        "theme": props.theme,
-        "class": ['v-color-picker'],
-        "style": {
-          '--v-color-picker-color-hsv': HSVtoCSS({
-            ...(currentColor.value ?? nullColor),
-            a: 1
-          })
-        },
-        "maxWidth": props.width
-      }, {
-        default: () => [!props.hideCanvas && vue.createVNode(VColorPickerCanvas, {
-          "key": "canvas",
-          "color": currentColor.value,
-          "onUpdate:color": updateColor,
-          "disabled": props.disabled,
-          "dotSize": props.dotSize,
-          "width": props.width,
-          "height": props.canvasHeight
-        }, null), (!props.hideSliders || !props.hideInputs) && vue.createVNode("div", {
-          "key": "controls",
-          "class": "v-color-picker__controls"
-        }, [!props.hideSliders && vue.createVNode(VColorPickerPreview, {
-          "key": "preview",
-          "color": currentColor.value,
-          "onUpdate:color": updateColor,
-          "hideAlpha": !mode.value.endsWith('a'),
-          "disabled": props.disabled
-        }, null), !props.hideInputs && vue.createVNode(VColorPickerEdit, {
-          "key": "edit",
-          "modes": props.modes,
-          "mode": mode.value,
-          "onUpdate:mode": m => mode.value = m,
-          "color": currentColor.value,
-          "onUpdate:color": updateColor,
-          "disabled": props.disabled
-        }, null)]), props.showSwatches && vue.createVNode(VColorPickerSwatches, {
-          "key": "swatches",
-          "color": currentColor.value,
-          "onUpdate:color": updateColor,
-          "maxHeight": props.swatchesMaxHeight,
-          "swatches": props.swatches,
-          "disabled": props.disabled
-        }, null)]
-      }));
+      useRender(() => {
+        const [sheetProps] = VSheet.filterProps(props);
+        return vue.createVNode(VSheet, vue.mergeProps({
+          "rounded": props.rounded,
+          "elevation": props.elevation,
+          "theme": props.theme,
+          "class": ['v-color-picker'],
+          "style": {
+            '--v-color-picker-color-hsv': HSVtoCSS({
+              ...(currentColor.value ?? nullColor),
+              a: 1
+            })
+          }
+        }, sheetProps, {
+          "maxWidth": props.width
+        }), {
+          default: () => [!props.hideCanvas && vue.createVNode(VColorPickerCanvas, {
+            "key": "canvas",
+            "color": currentColor.value,
+            "onUpdate:color": updateColor,
+            "disabled": props.disabled,
+            "dotSize": props.dotSize,
+            "width": props.width,
+            "height": props.canvasHeight
+          }, null), (!props.hideSliders || !props.hideInputs) && vue.createVNode("div", {
+            "key": "controls",
+            "class": "v-color-picker__controls"
+          }, [!props.hideSliders && vue.createVNode(VColorPickerPreview, {
+            "key": "preview",
+            "color": currentColor.value,
+            "onUpdate:color": updateColor,
+            "hideAlpha": !mode.value.endsWith('a'),
+            "disabled": props.disabled
+          }, null), !props.hideInputs && vue.createVNode(VColorPickerEdit, {
+            "key": "edit",
+            "modes": props.modes,
+            "mode": mode.value,
+            "onUpdate:mode": m => mode.value = m,
+            "color": currentColor.value,
+            "onUpdate:color": updateColor,
+            "disabled": props.disabled
+          }, null)]), props.showSwatches && vue.createVNode(VColorPickerSwatches, {
+            "key": "swatches",
+            "color": currentColor.value,
+            "onUpdate:color": updateColor,
+            "maxHeight": props.swatchesMaxHeight,
+            "swatches": props.swatches,
+            "disabled": props.disabled
+          }, null)]
+        });
+      });
       return {};
     }
   });
@@ -13516,6 +13556,7 @@
         }
       });
       const selectionIndex = vue.ref(-1);
+      let cleared = false;
       const color = vue.computed(() => vTextFieldRef.value?.color);
       const {
         items,
@@ -13552,11 +13593,17 @@
             }
           }
           if (!val) selectionIndex.value = -1;
-          if (isFocused.value) menu.value = true;
           isPristine.value = !val;
         }
       });
       vue.watch(_search, value => {
+        if (cleared) {
+          // wait for clear to finish, VTextField sets _search to null
+          // then search computed triggers and updates _search to ''
+          vue.nextTick(() => cleared = false);
+        } else if (isFocused.value && !menu.value) {
+          menu.value = true;
+        }
         emit('update:search', value);
       });
       vue.watch(model, value => {
@@ -13583,6 +13630,7 @@
       const selection = vue.computed(() => selections.value[selectionIndex.value]);
       const listRef = vue.ref();
       function onClear(e) {
+        cleared = true;
         if (props.openOnClear) {
           menu.value = true;
         }
@@ -13745,14 +13793,13 @@
             }, {
               default: () => [!displayItems.value.length && !props.hideNoData && (slots['no-data']?.() ?? vue.createVNode(VListItem, {
                 "title": t(props.noDataText)
-              }, null)), slots['prepend-item']?.(), displayItems.value.map((item, index) => slots.item?.({
+              }, null)), slots['prepend-item']?.(), displayItems.value.map(item => slots.item?.({
                 item,
-                index,
                 props: vue.mergeProps(item.props, {
                   onClick: () => select(item)
                 })
               }) ?? vue.createVNode(VListItem, vue.mergeProps({
-                "key": index
+                "key": item.value
               }, item.props, {
                 "onClick": () => select(item)
               }), {
@@ -13915,9 +13962,9 @@
         }, overlayProps, {
           "modelValue": isActive.value,
           "onUpdate:modelValue": $event => isActive.value = $event,
-          "aria-role": "dialog",
           "aria-modal": "true",
-          "activatorProps": activatorProps.value
+          "activatorProps": activatorProps.value,
+          "role": "dialog"
         }, scopeId), {
           activator: slots.activator,
           default: function () {
@@ -15496,12 +15543,18 @@
           bgColor: 'transparent'
         }
       });
+      function onMouseenter() {
+        isHovering.value = true;
+      }
+      function onMouseleave() {
+        isHovering.value = false;
+      }
       useRender(() => {
         const hasImage = slots.image || props.image;
         return vue.createVNode(vue.Fragment, null, [vue.createVNode(props.tag, vue.mergeProps({
           "ref": rootEl,
-          "onMouseenter": () => isHovering.value = true,
-          "onMouseleave": () => isHovering.value = false,
+          "onMouseenter": onMouseenter,
+          "onMouseleave": onMouseleave,
           "class": ['v-navigation-drawer', `v-navigation-drawer--${location.value}`, {
             'v-navigation-drawer--expand-on-hover': props.expandOnHover,
             'v-navigation-drawer--floating': props.floating,
@@ -15777,7 +15830,7 @@
                 ref,
                 ellipsis: false,
                 icon: true,
-                disabled: !!props.disabled || props.length < 2,
+                disabled: !!props.disabled || +props.length < 2,
                 color: isActive ? props.activeColor : props.color,
                 ariaCurrent: isActive,
                 ariaLabel: t(isActive ? props.currentPageAriaLabel : props.pageAriaLabel, item),
@@ -15826,7 +15879,7 @@
         refs.value[currentIndex]?.$el.focus();
       }
       function onKeydown(e) {
-        if (e.key === keyValues.left && !props.disabled && page.value > props.start) {
+        if (e.key === keyValues.left && !props.disabled && page.value > +props.start) {
           page.value = page.value - 1;
           vue.nextTick(updateFocus);
         } else if (e.key === keyValues.right && !props.disabled && page.value < start.value + length.value - 1) {
@@ -16501,35 +16554,36 @@
   // Types
 
   const VSlideGroupSymbol = Symbol.for('vuetify:v-slide-group');
+  const makeVSlideGroupProps = propsFactory({
+    centerActive: Boolean,
+    direction: {
+      type: String,
+      default: 'horizontal'
+    },
+    symbol: {
+      type: null,
+      default: VSlideGroupSymbol
+    },
+    nextIcon: {
+      type: IconValue,
+      default: '$next'
+    },
+    prevIcon: {
+      type: IconValue,
+      default: '$prev'
+    },
+    showArrows: {
+      type: [Boolean, String],
+      validator: v => typeof v === 'boolean' || ['always', 'desktop', 'mobile'].includes(v)
+    },
+    ...makeTagProps(),
+    ...makeGroupProps({
+      selectedClass: 'v-slide-group-item--active'
+    })
+  }, 'v-slide-group');
   const VSlideGroup = genericComponent()({
     name: 'VSlideGroup',
-    props: {
-      centerActive: Boolean,
-      direction: {
-        type: String,
-        default: 'horizontal'
-      },
-      symbol: {
-        type: null,
-        default: VSlideGroupSymbol
-      },
-      nextIcon: {
-        type: IconValue,
-        default: '$next'
-      },
-      prevIcon: {
-        type: IconValue,
-        default: '$prev'
-      },
-      showArrows: {
-        type: [Boolean, String],
-        validator: v => typeof v === 'boolean' || ['always', 'desktop', 'mobile'].includes(v)
-      },
-      ...makeTagProps(),
-      ...makeGroupProps({
-        selectedClass: 'v-slide-group-item--active'
-      })
-    },
+    props: makeVSlideGroupProps(),
     emits: {
       'update:modelValue': value => true
     },
@@ -17238,10 +17292,6 @@
         default: 'start'
       },
       color: String,
-      direction: {
-        type: String,
-        default: 'horizontal'
-      },
       fixedTabs: Boolean,
       items: {
         type: Array,
@@ -17256,11 +17306,9 @@
       },
       hideSlider: Boolean,
       sliderColor: String,
-      modelValue: null,
-      mandatory: {
-        type: [Boolean, String],
-        default: 'force'
-      },
+      ...makeVSlideGroupProps({
+        mandatory: 'force'
+      }),
       ...makeDensityProps(),
       ...makeTagProps()
     },
@@ -17290,26 +17338,27 @@
           hideSlider: vue.toRef(props, 'hideSlider')
         }
       });
-      useRender(() => vue.createVNode(VSlideGroup, {
-        "modelValue": model.value,
-        "onUpdate:modelValue": $event => model.value = $event,
-        "class": ['v-tabs', `v-tabs--${props.direction}`, `v-tabs--align-tabs-${props.alignTabs}`, {
-          'v-tabs--fixed-tabs': props.fixedTabs,
-          'v-tabs--grow': props.grow,
-          'v-tabs--stacked': props.stacked
-        }, densityClasses.value, backgroundColorClasses.value],
-        "style": [{
-          '--v-tabs-height': convertToUnit(props.height)
-        }, backgroundColorStyles.value],
-        "role": "tablist",
-        "symbol": VTabsSymbol,
-        "mandatory": props.mandatory,
-        "direction": props.direction
-      }, {
-        default: () => [slots.default ? slots.default() : parsedItems.value.map(item => vue.createVNode(VTab, vue.mergeProps(item, {
-          "key": item.title
-        }), null))]
-      }));
+      useRender(() => {
+        const [slideGroupProps] = VSlideGroup.filterProps(props);
+        return vue.createVNode(VSlideGroup, vue.mergeProps(slideGroupProps, {
+          "modelValue": model.value,
+          "onUpdate:modelValue": $event => model.value = $event,
+          "class": ['v-tabs', `v-tabs--${props.direction}`, `v-tabs--align-tabs-${props.alignTabs}`, {
+            'v-tabs--fixed-tabs': props.fixedTabs,
+            'v-tabs--grow': props.grow,
+            'v-tabs--stacked': props.stacked
+          }, densityClasses.value, backgroundColorClasses.value],
+          "style": [{
+            '--v-tabs-height': convertToUnit(props.height)
+          }, backgroundColorStyles.value],
+          "role": "tablist",
+          "symbol": VTabsSymbol
+        }), {
+          default: () => [slots.default ? slots.default() : parsedItems.value.map(item => vue.createVNode(VTab, vue.mergeProps(item, {
+            "key": item.title
+          }), null))]
+        });
+      });
       return {};
     }
   });
@@ -17425,7 +17474,7 @@
       const textareaRef = vue.ref();
       const isActive = vue.computed(() => isFocused.value || props.persistentPlaceholder);
       const messages = vue.computed(() => {
-        return props.messages.length ? props.messages : isActive.value || props.persistentHint ? props.hint : '';
+        return props.messages.length ? props.messages : isFocused.value || props.persistentHint ? props.hint : '';
       });
       function onFocus() {
         if (textareaRef.value !== document.activeElement) {
@@ -17944,14 +17993,185 @@
     }
   });
 
+  const VVirtualScrollItem = genericComponent()({
+    name: 'VVirtualScrollItem',
+    props: {
+      dynamicHeight: Boolean
+    },
+    emits: {
+      'update:height': height => true
+    },
+    setup(props, _ref) {
+      let {
+        emit,
+        slots
+      } = _ref;
+      const {
+        resizeRef,
+        contentRect
+      } = useResizeObserver();
+      useToggleScope(() => props.dynamicHeight, () => {
+        vue.watch(() => contentRect.value?.height, height => {
+          if (height != null) emit('update:height', height);
+        });
+      });
+      function updateHeight() {
+        if (props.dynamicHeight && contentRect.value) {
+          emit('update:height', contentRect.value.height);
+        }
+      }
+      vue.onUpdated(updateHeight);
+      useRender(() => vue.createVNode("div", {
+        "ref": props.dynamicHeight ? resizeRef : undefined,
+        "class": "v-virtual-scroll__item"
+      }, [slots.default?.()]));
+    }
+  });
+
+  // Types
+
+  const UP = -1;
+  const DOWN = 1;
+  const VVirtualScroll = genericComponent()({
+    name: 'VVirtualScroll',
+    props: {
+      items: {
+        type: Array,
+        default: () => []
+      },
+      itemHeight: [Number, String],
+      visibleItems: [Number, String],
+      ...makeDimensionProps()
+    },
+    setup(props, _ref) {
+      let {
+        slots
+      } = _ref;
+      const first = vue.ref(0);
+      const baseItemHeight = vue.ref(props.itemHeight);
+      const itemHeight = vue.computed({
+        get: () => parseInt(baseItemHeight.value ?? 0, 10),
+        set(val) {
+          baseItemHeight.value = val;
+        }
+      });
+      const rootEl = vue.ref();
+      const {
+        resizeRef,
+        contentRect
+      } = useResizeObserver();
+      vue.watchEffect(() => {
+        resizeRef.value = rootEl.value;
+      });
+      const display = useDisplay();
+      const sizeMap = new Map();
+      let sizes = createRange(props.items.length).map(() => itemHeight.value);
+      const visibleItems = vue.computed(() => {
+        return props.visibleItems ? parseInt(props.visibleItems, 10) : Math.max(12, Math.ceil((contentRect.value?.height ?? display.height.value) / itemHeight.value * 1.7 + 1));
+      });
+      function handleItemResize(index, height) {
+        itemHeight.value = Math.max(itemHeight.value, height);
+        sizes[index] = height;
+        sizeMap.set(props.items[index], height);
+      }
+      function calculateOffset(index) {
+        return sizes.slice(0, index).reduce((curr, value) => curr + (value || itemHeight.value), 0);
+      }
+      function calculateMidPointIndex(scrollTop) {
+        let start = 0;
+        let end = props.items.length;
+        while (start <= end) {
+          const middle = start + Math.floor((end - start) / 2);
+          const middleOffset = calculateOffset(middle);
+          if (middleOffset === scrollTop) {
+            return middle;
+          } else if (middleOffset < scrollTop) {
+            start = middle + 1;
+          } else if (middleOffset > scrollTop) {
+            end = middle - 1;
+          }
+        }
+        return start;
+      }
+      let lastScrollTop = 0;
+      function handleScroll() {
+        if (!rootEl.value || !contentRect.value) return;
+        const height = contentRect.value.height;
+        const scrollTop = rootEl.value.scrollTop;
+        const direction = scrollTop < lastScrollTop ? UP : DOWN;
+        const midPointIndex = calculateMidPointIndex(scrollTop + height / 2);
+        const buffer = Math.round(visibleItems.value / 3);
+        if (direction === UP && midPointIndex <= first.value + buffer * 2 - 1) {
+          first.value = clamp(midPointIndex - buffer, 0, props.items.length);
+        } else if (direction === DOWN && midPointIndex >= first.value + buffer * 2 - 1) {
+          first.value = clamp(midPointIndex - buffer, 0, props.items.length - visibleItems.value);
+        }
+        lastScrollTop = rootEl.value.scrollTop;
+      }
+      function scrollToIndex(index) {
+        if (!rootEl.value) return;
+        const offset = calculateOffset(index);
+        rootEl.value.scrollTop = offset;
+      }
+      const last = vue.computed(() => Math.min(props.items.length, first.value + visibleItems.value));
+      const computedItems = vue.computed(() => props.items.slice(first.value, last.value));
+      const paddingTop = vue.computed(() => calculateOffset(first.value));
+      const paddingBottom = vue.computed(() => calculateOffset(props.items.length) - calculateOffset(last.value));
+      const {
+        dimensionStyles
+      } = useDimension(props);
+      vue.onMounted(() => {
+        if (!itemHeight.value) {
+          // If itemHeight prop is not set, then calculate an estimated height from the average of inital items
+          itemHeight.value = sizes.slice(first.value, last.value).reduce((curr, height) => curr + height, 0) / visibleItems.value;
+        }
+      });
+      vue.watch(() => props.items.length, () => {
+        sizes = createRange(props.items.length).map(() => itemHeight.value);
+        sizeMap.forEach((height, item) => {
+          const index = props.items.indexOf(item);
+          if (index === -1) {
+            sizeMap.delete(item);
+          } else {
+            sizes[index] = height;
+          }
+        });
+      });
+      useRender(() => vue.createVNode("div", {
+        "ref": rootEl,
+        "class": "v-virtual-scroll",
+        "onScroll": handleScroll,
+        "style": dimensionStyles.value
+      }, [vue.createVNode("div", {
+        "class": "v-virtual-scroll__container",
+        "style": {
+          paddingTop: convertToUnit(paddingTop.value),
+          paddingBottom: convertToUnit(paddingBottom.value)
+        }
+      }, [computedItems.value.map((item, index) => vue.createVNode(VVirtualScrollItem, {
+        "key": index,
+        "dynamicHeight": !props.itemHeight,
+        "onUpdate:height": height => handleItemResize(index + first.value, height)
+      }, {
+        default: () => [slots.default?.({
+          item,
+          index: index + first.value
+        })]
+      }))])]));
+      return {
+        scrollToIndex
+      };
+    }
+  });
+
   var components = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    VAlert: VAlert,
+    VAlertTitle: VAlertTitle,
     VApp: VApp,
     VAppBar: VAppBar,
     VAppBarNavIcon: VAppBarNavIcon,
     VAppBarTitle: VAppBarTitle,
-    VAlert: VAlert,
-    VAlertTitle: VAlertTitle,
     VAutocomplete: VAutocomplete,
     VAvatar: VAvatar,
     VBadge: VBadge,
@@ -17960,8 +18180,8 @@
     VBannerText: VBannerText,
     VBottomNavigation: VBottomNavigation,
     VBreadcrumbs: VBreadcrumbs,
-    VBreadcrumbsItem: VBreadcrumbsItem,
     VBreadcrumbsDivider: VBreadcrumbsDivider,
+    VBreadcrumbsItem: VBreadcrumbsItem,
     VBtn: VBtn,
     VBtnGroup: VBtnGroup,
     VBtnToggle: VBtnToggle,
@@ -17977,41 +18197,45 @@
     VCheckboxBtn: VCheckboxBtn,
     VChip: VChip,
     VChipGroup: VChipGroup,
+    VClassIcon: VClassIcon,
     VCode: VCode,
+    VCol: VCol,
     VColorPicker: VColorPicker,
     VCombobox: VCombobox,
+    VComponentIcon: VComponentIcon,
+    VContainer: VContainer,
     VCounter: VCounter,
     VDefaultsProvider: VDefaultsProvider,
     VDialog: VDialog,
+    VDialogBottomTransition: VDialogBottomTransition,
+    VDialogTopTransition: VDialogTopTransition,
+    VDialogTransition: VDialogTransition,
     VDivider: VDivider,
-    VExpansionPanels: VExpansionPanels,
+    VExpandTransition: VExpandTransition,
+    VExpandXTransition: VExpandXTransition,
     VExpansionPanel: VExpansionPanel,
     VExpansionPanelText: VExpansionPanelText,
     VExpansionPanelTitle: VExpansionPanelTitle,
+    VExpansionPanels: VExpansionPanels,
+    VFabTransition: VFabTransition,
+    VFadeTransition: VFadeTransition,
     VField: VField,
     VFieldLabel: VFieldLabel,
     VFileInput: VFileInput,
     VFooter: VFooter,
     VForm: VForm,
-    VContainer: VContainer,
-    VCol: VCol,
-    VRow: VRow,
-    VSpacer: VSpacer,
     VHover: VHover,
     VIcon: VIcon,
-    VComponentIcon: VComponentIcon,
-    VSvgIcon: VSvgIcon,
-    VLigatureIcon: VLigatureIcon,
-    VClassIcon: VClassIcon,
     VImg: VImg,
     VInput: VInput,
-    VItemGroup: VItemGroup,
     VItem: VItem,
+    VItemGroup: VItemGroup,
     VKbd: VKbd,
     VLabel: VLabel,
     VLayout: VLayout,
     VLayoutItem: VLayoutItem,
     VLazy: VLazy,
+    VLigatureIcon: VLigatureIcon,
     VList: VList,
     VListGroup: VListGroup,
     VListImg: VListImg,
@@ -18037,47 +18261,44 @@
     VRangeSlider: VRangeSlider,
     VRating: VRating,
     VResponsive: VResponsive,
+    VRow: VRow,
+    VScaleTransition: VScaleTransition,
+    VScrollXReverseTransition: VScrollXReverseTransition,
+    VScrollXTransition: VScrollXTransition,
+    VScrollYReverseTransition: VScrollYReverseTransition,
+    VScrollYTransition: VScrollYTransition,
     VSelect: VSelect,
     VSelectionControl: VSelectionControl,
     VSelectionControlGroup: VSelectionControlGroup,
     VSheet: VSheet,
     VSlideGroup: VSlideGroup,
     VSlideGroupItem: VSlideGroupItem,
+    VSlideXReverseTransition: VSlideXReverseTransition,
+    VSlideXTransition: VSlideXTransition,
+    VSlideYReverseTransition: VSlideYReverseTransition,
+    VSlideYTransition: VSlideYTransition,
     VSlider: VSlider,
     VSnackbar: VSnackbar,
+    VSpacer: VSpacer,
+    VSvgIcon: VSvgIcon,
     VSwitch: VSwitch,
     VSystemBar: VSystemBar,
-    VTabs: VTabs,
     VTab: VTab,
     VTable: VTable,
-    VTextarea: VTextarea,
+    VTabs: VTabs,
     VTextField: VTextField,
+    VTextarea: VTextarea,
     VThemeProvider: VThemeProvider,
     VTimeline: VTimeline,
     VTimelineItem: VTimelineItem,
     VToolbar: VToolbar,
-    VToolbarTitle: VToolbarTitle,
     VToolbarItems: VToolbarItems,
+    VToolbarTitle: VToolbarTitle,
     VTooltip: VTooltip,
     VValidation: VValidation,
+    VVirtualScroll: VVirtualScroll,
     VWindow: VWindow,
-    VWindowItem: VWindowItem,
-    VDialogTransition: VDialogTransition,
-    VFabTransition: VFabTransition,
-    VDialogBottomTransition: VDialogBottomTransition,
-    VDialogTopTransition: VDialogTopTransition,
-    VFadeTransition: VFadeTransition,
-    VScaleTransition: VScaleTransition,
-    VScrollXTransition: VScrollXTransition,
-    VScrollXReverseTransition: VScrollXReverseTransition,
-    VScrollYTransition: VScrollYTransition,
-    VScrollYReverseTransition: VScrollYReverseTransition,
-    VSlideXTransition: VSlideXTransition,
-    VSlideXReverseTransition: VSlideXReverseTransition,
-    VSlideYTransition: VSlideYTransition,
-    VSlideYReverseTransition: VSlideYReverseTransition,
-    VExpandTransition: VExpandTransition,
-    VExpandXTransition: VExpandXTransition
+    VWindowItem: VWindowItem
   });
 
   // Types
@@ -18288,7 +18509,7 @@
       locale
     };
   }
-  const version$1 = "3.2.0-dev-20230322.0";
+  const version$1 = "3.2.0-dev-20230407.0";
   createVuetify$1.version = version$1;
 
   // Vue's inject() can only be used in setup
@@ -18308,7 +18529,7 @@
       ...options
     });
   };
-  const version = "3.2.0-dev-20230322.0";
+  const version = "3.2.0-dev-20230407.0";
   createVuetify.version = version;
 
   exports.components = components;
@@ -18321,7 +18542,5 @@
   exports.useTheme = useTheme;
   exports.version = version;
 
-  Object.defineProperty(exports, '__esModule', { value: true });
-
 }));
 //# sourceMappingURL=vuetify.js.map