vuetify 3.6.0 → 3.6.1

package/dist/vuetify.js

@@ -1,5 +1,5 @@
 /*!
-* Vuetify v3.6.0
+* Vuetify v3.6.1
 * Forged by John Leider
 * Released under the MIT License.
 */
@@ -17276,764 +17276,255 @@
     }
   });
 
-  // Composables
+  // Utilities
 
   // Types
 
-  const makeDataTableExpandProps = propsFactory({
-    expandOnClick: Boolean,
-    showExpand: Boolean,
-    expanded: {
-      type: Array,
-      default: () => []
+  const firstDay = {
+    '001': 1,
+    AD: 1,
+    AE: 6,
+    AF: 6,
+    AG: 0,
+    AI: 1,
+    AL: 1,
+    AM: 1,
+    AN: 1,
+    AR: 1,
+    AS: 0,
+    AT: 1,
+    AU: 1,
+    AX: 1,
+    AZ: 1,
+    BA: 1,
+    BD: 0,
+    BE: 1,
+    BG: 1,
+    BH: 6,
+    BM: 1,
+    BN: 1,
+    BR: 0,
+    BS: 0,
+    BT: 0,
+    BW: 0,
+    BY: 1,
+    BZ: 0,
+    CA: 0,
+    CH: 1,
+    CL: 1,
+    CM: 1,
+    CN: 1,
+    CO: 0,
+    CR: 1,
+    CY: 1,
+    CZ: 1,
+    DE: 1,
+    DJ: 6,
+    DK: 1,
+    DM: 0,
+    DO: 0,
+    DZ: 6,
+    EC: 1,
+    EE: 1,
+    EG: 6,
+    ES: 1,
+    ET: 0,
+    FI: 1,
+    FJ: 1,
+    FO: 1,
+    FR: 1,
+    GB: 1,
+    'GB-alt-variant': 0,
+    GE: 1,
+    GF: 1,
+    GP: 1,
+    GR: 1,
+    GT: 0,
+    GU: 0,
+    HK: 0,
+    HN: 0,
+    HR: 1,
+    HU: 1,
+    ID: 0,
+    IE: 1,
+    IL: 0,
+    IN: 0,
+    IQ: 6,
+    IR: 6,
+    IS: 1,
+    IT: 1,
+    JM: 0,
+    JO: 6,
+    JP: 0,
+    KE: 0,
+    KG: 1,
+    KH: 0,
+    KR: 0,
+    KW: 6,
+    KZ: 1,
+    LA: 0,
+    LB: 1,
+    LI: 1,
+    LK: 1,
+    LT: 1,
+    LU: 1,
+    LV: 1,
+    LY: 6,
+    MC: 1,
+    MD: 1,
+    ME: 1,
+    MH: 0,
+    MK: 1,
+    MM: 0,
+    MN: 1,
+    MO: 0,
+    MQ: 1,
+    MT: 0,
+    MV: 5,
+    MX: 0,
+    MY: 1,
+    MZ: 0,
+    NI: 0,
+    NL: 1,
+    NO: 1,
+    NP: 0,
+    NZ: 1,
+    OM: 6,
+    PA: 0,
+    PE: 0,
+    PH: 0,
+    PK: 0,
+    PL: 1,
+    PR: 0,
+    PT: 0,
+    PY: 0,
+    QA: 6,
+    RE: 1,
+    RO: 1,
+    RS: 1,
+    RU: 1,
+    SA: 0,
+    SD: 6,
+    SE: 1,
+    SG: 0,
+    SI: 1,
+    SK: 1,
+    SM: 1,
+    SV: 0,
+    SY: 6,
+    TH: 0,
+    TJ: 1,
+    TM: 1,
+    TR: 1,
+    TT: 0,
+    TW: 0,
+    UA: 1,
+    UM: 0,
+    US: 0,
+    UY: 1,
+    UZ: 1,
+    VA: 1,
+    VE: 0,
+    VI: 0,
+    VN: 1,
+    WS: 0,
+    XK: 1,
+    YE: 0,
+    ZA: 0,
+    ZW: 0
+  };
+  function getWeekArray(date, locale) {
+    const weeks = [];
+    let currentWeek = [];
+    const firstDayOfMonth = startOfMonth(date);
+    const lastDayOfMonth = endOfMonth(date);
+    const firstDayWeekIndex = (firstDayOfMonth.getDay() - firstDay[locale.slice(-2).toUpperCase()] + 7) % 7;
+    const lastDayWeekIndex = (lastDayOfMonth.getDay() - firstDay[locale.slice(-2).toUpperCase()] + 7) % 7;
+    for (let i = 0; i < firstDayWeekIndex; i++) {
+      const adjacentDay = new Date(firstDayOfMonth);
+      adjacentDay.setDate(adjacentDay.getDate() - (firstDayWeekIndex - i));
+      currentWeek.push(adjacentDay);
     }
-  }, 'DataTable-expand');
-  const VDataTableExpandedKey = Symbol.for('vuetify:datatable:expanded');
-  function provideExpanded(props) {
-    const expandOnClick = vue.toRef(props, 'expandOnClick');
-    const expanded = useProxiedModel(props, 'expanded', props.expanded, v => {
-      return new Set(v);
-    }, v => {
-      return [...v.values()];
-    });
-    function expand(item, value) {
-      const newExpanded = new Set(expanded.value);
-      if (!value) {
-        newExpanded.delete(item.value);
-      } else {
-        newExpanded.add(item.value);
+    for (let i = 1; i <= lastDayOfMonth.getDate(); i++) {
+      const day = new Date(date.getFullYear(), date.getMonth(), i);
+
+      // Add the day to the current week
+      currentWeek.push(day);
+
+      // If the current week has 7 days, add it to the weeks array and start a new week
+      if (currentWeek.length === 7) {
+        weeks.push(currentWeek);
+        currentWeek = [];
       }
-      expanded.value = newExpanded;
     }
-    function isExpanded(item) {
-      return expanded.value.has(item.value);
+    for (let i = 1; i < 7 - lastDayWeekIndex; i++) {
+      const adjacentDay = new Date(lastDayOfMonth);
+      adjacentDay.setDate(adjacentDay.getDate() + i);
+      currentWeek.push(adjacentDay);
     }
-    function toggleExpand(item) {
-      expand(item, !isExpanded(item));
+    if (currentWeek.length > 0) {
+      weeks.push(currentWeek);
     }
-    const data = {
-      expand,
-      expanded,
-      expandOnClick,
-      isExpanded,
-      toggleExpand
-    };
-    vue.provide(VDataTableExpandedKey, data);
-    return data;
+    return weeks;
   }
-  function useExpanded() {
-    const data = vue.inject(VDataTableExpandedKey);
-    if (!data) throw new Error('foo');
-    return data;
+  function startOfWeek(date, locale) {
+    const d = new Date(date);
+    while (d.getDay() !== (firstDay[locale.slice(-2).toUpperCase()] ?? 0)) {
+      d.setDate(d.getDate() - 1);
+    }
+    return d;
   }
-
-  // Composables
-
-  // Types
-
-  const makeDataTableGroupProps = propsFactory({
-    groupBy: {
-      type: Array,
-      default: () => []
+  function endOfWeek(date, locale) {
+    const d = new Date(date);
+    const lastDay = ((firstDay[locale.slice(-2).toUpperCase()] ?? 0) + 6) % 7;
+    while (d.getDay() !== lastDay) {
+      d.setDate(d.getDate() + 1);
     }
-  }, 'DataTable-group');
-  const VDataTableGroupSymbol = Symbol.for('vuetify:data-table-group');
-  function createGroupBy(props) {
-    const groupBy = useProxiedModel(props, 'groupBy');
-    return {
-      groupBy
-    };
+    return d;
   }
-  function provideGroupBy(options) {
-    const {
-      groupBy,
-      sortBy
-    } = options;
-    const opened = vue.ref(new Set());
-    const sortByWithGroups = vue.computed(() => {
-      return groupBy.value.map(val => ({
-        ...val,
-        order: val.order ?? false
-      })).concat(sortBy.value);
-    });
-    function isGroupOpen(group) {
-      return opened.value.has(group.id);
-    }
-    function toggleGroup(group) {
-      const newOpened = new Set(opened.value);
-      if (!isGroupOpen(group)) newOpened.add(group.id);else newOpened.delete(group.id);
-      opened.value = newOpened;
-    }
-    function extractRows(items) {
-      function dive(group) {
-        const arr = [];
-        for (const item of group.items) {
-          if ('type' in item && item.type === 'group') {
-            arr.push(...dive(item));
-          } else {
-            arr.push(item);
-          }
-        }
-        return arr;
-      }
-      return dive({
-        type: 'group',
-        items,
-        id: 'dummy',
-        key: 'dummy',
-        value: 'dummy',
-        depth: 0
-      });
-    }
-
-    // onBeforeMount(() => {
-    //   for (const key of groupedItems.value.keys()) {
-    //     opened.value.add(key)
-    //   }
-    // })
-
-    const data = {
-      sortByWithGroups,
-      toggleGroup,
-      opened,
-      groupBy,
-      extractRows,
-      isGroupOpen
-    };
-    vue.provide(VDataTableGroupSymbol, data);
-    return data;
-  }
-  function useGroupBy() {
-    const data = vue.inject(VDataTableGroupSymbol);
-    if (!data) throw new Error('Missing group!');
-    return data;
+  function startOfMonth(date) {
+    return new Date(date.getFullYear(), date.getMonth(), 1);
   }
-  function groupItemsByProperty(items, groupBy) {
-    if (!items.length) return [];
-    const groups = new Map();
-    for (const item of items) {
-      const value = getObjectValueByPath(item.raw, groupBy);
-      if (!groups.has(value)) {
-        groups.set(value, []);
-      }
-      groups.get(value).push(item);
-    }
-    return groups;
+  function endOfMonth(date) {
+    return new Date(date.getFullYear(), date.getMonth() + 1, 0);
   }
-  function groupItems(items, groupBy) {
-    let depth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-    let prefix = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'root';
-    if (!groupBy.length) return [];
-    const groupedItems = groupItemsByProperty(items, groupBy[0]);
-    const groups = [];
-    const rest = groupBy.slice(1);
-    groupedItems.forEach((items, value) => {
-      const key = groupBy[0];
-      const id = `${prefix}_${key}_${value}`;
-      groups.push({
-        depth,
-        id,
-        key,
-        value,
-        items: rest.length ? groupItems(items, rest, depth + 1, id) : items,
-        type: 'group'
-      });
-    });
-    return groups;
+  function parseLocalDate(value) {
+    const parts = value.split('-').map(Number);
+
+    // new Date() uses local time zone when passing individual date component values
+    return new Date(parts[0], parts[1] - 1, parts[2]);
   }
-  function flattenItems(items, opened) {
-    const flatItems = [];
-    for (const item of items) {
-      // TODO: make this better
-      if ('type' in item && item.type === 'group') {
-        if (item.value != null) {
-          flatItems.push(item);
-        }
-        if (opened.has(item.id) || item.value == null) {
-          flatItems.push(...flattenItems(item.items, opened));
-        }
+  const _YYYMMDD = /^([12]\d{3}-([1-9]|0[1-9]|1[0-2])-([1-9]|0[1-9]|[12]\d|3[01]))$/;
+  function date(value) {
+    if (value == null) return new Date();
+    if (value instanceof Date) return value;
+    if (typeof value === 'string') {
+      let parsed;
+      if (_YYYMMDD.test(value)) {
+        return parseLocalDate(value);
       } else {
-        flatItems.push(item);
+        parsed = Date.parse(value);
       }
+      if (!isNaN(parsed)) return new Date(parsed);
     }
-    return flatItems;
-  }
-  function useGroupedItems(items, groupBy, opened) {
-    const flatItems = vue.computed(() => {
-      if (!groupBy.value.length) return items.value;
-      const groupedItems = groupItems(items.value, groupBy.value.map(item => item.key));
-      return flattenItems(groupedItems, opened.value);
-    });
-    return {
-      flatItems
-    };
+    return null;
   }
-
-  // Utilities
-
-  // Types
-
-  function useOptions(_ref) {
-    let {
-      page,
-      itemsPerPage,
-      sortBy,
-      groupBy,
-      search
-    } = _ref;
-    const vm = getCurrentInstance('VDataTable');
-    const options = vue.computed(() => ({
-      page: page.value,
-      itemsPerPage: itemsPerPage.value,
-      sortBy: sortBy.value,
-      groupBy: groupBy.value,
-      search: search.value
-    }));
-    let oldOptions = null;
-    vue.watch(options, () => {
-      if (deepEqual(oldOptions, options.value)) return;
-
-      // Reset page when searching
-      if (oldOptions && oldOptions.search !== options.value.search) {
-        page.value = 1;
-      }
-      vm.emit('update:options', options.value);
-      oldOptions = options.value;
-    }, {
-      deep: true,
-      immediate: true
+  const sundayJanuarySecond2000 = new Date(2000, 0, 2);
+  function getWeekdays(locale) {
+    const daysFromSunday = firstDay[locale.slice(-2).toUpperCase()];
+    return createRange(7).map(i => {
+      const weekday = new Date(sundayJanuarySecond2000);
+      weekday.setDate(sundayJanuarySecond2000.getDate() + daysFromSunday + i);
+      return new Intl.DateTimeFormat(locale, {
+        weekday: 'narrow'
+      }).format(weekday);
     });
   }
-
-  // Composables
-
-  // Types
-
-  const makeDataTablePaginateProps = propsFactory({
-    page: {
-      type: [Number, String],
-      default: 1
-    },
-    itemsPerPage: {
-      type: [Number, String],
-      default: 10
-    }
-  }, 'DataTable-paginate');
-  const VDataTablePaginationSymbol = Symbol.for('vuetify:data-table-pagination');
-  function createPagination(props) {
-    const page = useProxiedModel(props, 'page', undefined, value => +(value ?? 1));
-    const itemsPerPage = useProxiedModel(props, 'itemsPerPage', undefined, value => +(value ?? 10));
-    return {
-      page,
-      itemsPerPage
-    };
-  }
-  function providePagination(options) {
-    const {
-      page,
-      itemsPerPage,
-      itemsLength
-    } = options;
-    const startIndex = vue.computed(() => {
-      if (itemsPerPage.value === -1) return 0;
-      return itemsPerPage.value * (page.value - 1);
-    });
-    const stopIndex = vue.computed(() => {
-      if (itemsPerPage.value === -1) return itemsLength.value;
-      return Math.min(itemsLength.value, startIndex.value + itemsPerPage.value);
-    });
-    const pageCount = vue.computed(() => {
-      if (itemsPerPage.value === -1 || itemsLength.value === 0) return 1;
-      return Math.ceil(itemsLength.value / itemsPerPage.value);
-    });
-    vue.watchEffect(() => {
-      if (page.value > pageCount.value) {
-        page.value = pageCount.value;
-      }
-    });
-    function setItemsPerPage(value) {
-      itemsPerPage.value = value;
-      page.value = 1;
-    }
-    function nextPage() {
-      page.value = clamp(page.value + 1, 1, pageCount.value);
-    }
-    function prevPage() {
-      page.value = clamp(page.value - 1, 1, pageCount.value);
-    }
-    function setPage(value) {
-      page.value = clamp(value, 1, pageCount.value);
-    }
-    const data = {
-      page,
-      itemsPerPage,
-      startIndex,
-      stopIndex,
-      pageCount,
-      itemsLength,
-      nextPage,
-      prevPage,
-      setPage,
-      setItemsPerPage
-    };
-    vue.provide(VDataTablePaginationSymbol, data);
-    return data;
-  }
-  function usePagination() {
-    const data = vue.inject(VDataTablePaginationSymbol);
-    if (!data) throw new Error('Missing pagination!');
-    return data;
-  }
-  function usePaginatedItems(options) {
-    const vm = getCurrentInstance('usePaginatedItems');
-    const {
-      items,
-      startIndex,
-      stopIndex,
-      itemsPerPage
-    } = options;
-    const paginatedItems = vue.computed(() => {
-      if (itemsPerPage.value <= 0) return items.value;
-      return items.value.slice(startIndex.value, stopIndex.value);
-    });
-    vue.watch(paginatedItems, val => {
-      vm.emit('update:currentItems', val);
-    });
-    return {
-      paginatedItems
-    };
-  }
-
-  // Composables
-
-  // Types
-
-  const singleSelectStrategy = {
-    showSelectAll: false,
-    allSelected: () => [],
-    select: _ref => {
-      let {
-        items,
-        value
-      } = _ref;
-      return new Set(value ? [vue.toRaw(items[0]?.value)] : []);
-    },
-    selectAll: _ref2 => {
-      let {
-        selected
-      } = _ref2;
-      return selected;
-    }
-  };
-  const pageSelectStrategy = {
-    showSelectAll: true,
-    allSelected: _ref3 => {
-      let {
-        currentPage
-      } = _ref3;
-      return currentPage;
-    },
-    select: _ref4 => {
-      let {
-        items,
-        value,
-        selected
-      } = _ref4;
-      for (const item of items) {
-        if (value) selected.add(vue.toRaw(item.value));else selected.delete(vue.toRaw(item.value));
-      }
-      return selected;
-    },
-    selectAll: _ref5 => {
-      let {
-        value,
-        currentPage,
-        selected
-      } = _ref5;
-      return pageSelectStrategy.select({
-        items: currentPage,
-        value,
-        selected
-      });
-    }
-  };
-  const allSelectStrategy = {
-    showSelectAll: true,
-    allSelected: _ref6 => {
-      let {
-        allItems
-      } = _ref6;
-      return allItems;
-    },
-    select: _ref7 => {
-      let {
-        items,
-        value,
-        selected
-      } = _ref7;
-      for (const item of items) {
-        if (value) selected.add(vue.toRaw(item.value));else selected.delete(vue.toRaw(item.value));
-      }
-      return selected;
-    },
-    selectAll: _ref8 => {
-      let {
-        value,
-        allItems,
-        selected
-      } = _ref8;
-      return allSelectStrategy.select({
-        items: allItems,
-        value,
-        selected
-      });
-    }
-  };
-  const makeDataTableSelectProps = propsFactory({
-    showSelect: Boolean,
-    selectStrategy: {
-      type: [String, Object],
-      default: 'page'
-    },
-    modelValue: {
-      type: Array,
-      default: () => []
-    },
-    valueComparator: {
-      type: Function,
-      default: deepEqual
-    }
-  }, 'DataTable-select');
-  const VDataTableSelectionSymbol = Symbol.for('vuetify:data-table-selection');
-  function provideSelection(props, _ref9) {
-    let {
-      allItems,
-      currentPage
-    } = _ref9;
-    const selected = useProxiedModel(props, 'modelValue', props.modelValue, v => {
-      return new Set(wrapInArray(v).map(v => {
-        return allItems.value.find(item => props.valueComparator(v, item.value))?.value ?? v;
-      }));
-    }, v => {
-      return [...v.values()];
-    });
-    const allSelectable = vue.computed(() => allItems.value.filter(item => item.selectable));
-    const currentPageSelectable = vue.computed(() => currentPage.value.filter(item => item.selectable));
-    const selectStrategy = vue.computed(() => {
-      if (typeof props.selectStrategy === 'object') return props.selectStrategy;
-      switch (props.selectStrategy) {
-        case 'single':
-          return singleSelectStrategy;
-        case 'all':
-          return allSelectStrategy;
-        case 'page':
-        default:
-          return pageSelectStrategy;
-      }
-    });
-    function isSelected(items) {
-      return wrapInArray(items).every(item => selected.value.has(vue.toRaw(item.value)));
-    }
-    function isSomeSelected(items) {
-      return wrapInArray(items).some(item => selected.value.has(vue.toRaw(item.value)));
-    }
-    function select(items, value) {
-      const newSelected = selectStrategy.value.select({
-        items,
-        value,
-        selected: new Set(selected.value)
-      });
-      selected.value = newSelected;
-    }
-    function toggleSelect(item) {
-      const newItem = vue.toRef(item);
-      select([newItem.value], !isSelected([newItem.value]));
-    }
-    function selectAll(value) {
-      const newSelected = selectStrategy.value.selectAll({
-        value,
-        allItems: allSelectable.value,
-        currentPage: currentPageSelectable.value,
-        selected: new Set(selected.value)
-      });
-      selected.value = newSelected;
-    }
-    const someSelected = vue.computed(() => selected.value.size > 0);
-    const allSelected = vue.computed(() => {
-      const items = selectStrategy.value.allSelected({
-        allItems: allSelectable.value,
-        currentPage: currentPageSelectable.value
-      });
-      return !!items.length && isSelected(items);
-    });
-    const data = {
-      toggleSelect,
-      select,
-      selectAll,
-      isSelected,
-      isSomeSelected,
-      someSelected,
-      allSelected,
-      showSelectAll: selectStrategy.value.showSelectAll
-    };
-    vue.provide(VDataTableSelectionSymbol, data);
-    return data;
-  }
-  function useSelection() {
-    const data = vue.inject(VDataTableSelectionSymbol);
-    if (!data) throw new Error('Missing selection!');
-    return data;
-  }
-
-  // Utilities
-
-  // Types
-
-  const firstDay = {
-    '001': 1,
-    AD: 1,
-    AE: 6,
-    AF: 6,
-    AG: 0,
-    AI: 1,
-    AL: 1,
-    AM: 1,
-    AN: 1,
-    AR: 1,
-    AS: 0,
-    AT: 1,
-    AU: 1,
-    AX: 1,
-    AZ: 1,
-    BA: 1,
-    BD: 0,
-    BE: 1,
-    BG: 1,
-    BH: 6,
-    BM: 1,
-    BN: 1,
-    BR: 0,
-    BS: 0,
-    BT: 0,
-    BW: 0,
-    BY: 1,
-    BZ: 0,
-    CA: 0,
-    CH: 1,
-    CL: 1,
-    CM: 1,
-    CN: 1,
-    CO: 0,
-    CR: 1,
-    CY: 1,
-    CZ: 1,
-    DE: 1,
-    DJ: 6,
-    DK: 1,
-    DM: 0,
-    DO: 0,
-    DZ: 6,
-    EC: 1,
-    EE: 1,
-    EG: 6,
-    ES: 1,
-    ET: 0,
-    FI: 1,
-    FJ: 1,
-    FO: 1,
-    FR: 1,
-    GB: 1,
-    'GB-alt-variant': 0,
-    GE: 1,
-    GF: 1,
-    GP: 1,
-    GR: 1,
-    GT: 0,
-    GU: 0,
-    HK: 0,
-    HN: 0,
-    HR: 1,
-    HU: 1,
-    ID: 0,
-    IE: 1,
-    IL: 0,
-    IN: 0,
-    IQ: 6,
-    IR: 6,
-    IS: 1,
-    IT: 1,
-    JM: 0,
-    JO: 6,
-    JP: 0,
-    KE: 0,
-    KG: 1,
-    KH: 0,
-    KR: 0,
-    KW: 6,
-    KZ: 1,
-    LA: 0,
-    LB: 1,
-    LI: 1,
-    LK: 1,
-    LT: 1,
-    LU: 1,
-    LV: 1,
-    LY: 6,
-    MC: 1,
-    MD: 1,
-    ME: 1,
-    MH: 0,
-    MK: 1,
-    MM: 0,
-    MN: 1,
-    MO: 0,
-    MQ: 1,
-    MT: 0,
-    MV: 5,
-    MX: 0,
-    MY: 1,
-    MZ: 0,
-    NI: 0,
-    NL: 1,
-    NO: 1,
-    NP: 0,
-    NZ: 1,
-    OM: 6,
-    PA: 0,
-    PE: 0,
-    PH: 0,
-    PK: 0,
-    PL: 1,
-    PR: 0,
-    PT: 0,
-    PY: 0,
-    QA: 6,
-    RE: 1,
-    RO: 1,
-    RS: 1,
-    RU: 1,
-    SA: 0,
-    SD: 6,
-    SE: 1,
-    SG: 0,
-    SI: 1,
-    SK: 1,
-    SM: 1,
-    SV: 0,
-    SY: 6,
-    TH: 0,
-    TJ: 1,
-    TM: 1,
-    TR: 1,
-    TT: 0,
-    TW: 0,
-    UA: 1,
-    UM: 0,
-    US: 0,
-    UY: 1,
-    UZ: 1,
-    VA: 1,
-    VE: 0,
-    VI: 0,
-    VN: 1,
-    WS: 0,
-    XK: 1,
-    YE: 0,
-    ZA: 0,
-    ZW: 0
-  };
-  function getWeekArray(date, locale) {
-    const weeks = [];
-    let currentWeek = [];
-    const firstDayOfMonth = startOfMonth(date);
-    const lastDayOfMonth = endOfMonth(date);
-    const firstDayWeekIndex = (firstDayOfMonth.getDay() - firstDay[locale.slice(-2).toUpperCase()] + 7) % 7;
-    const lastDayWeekIndex = (lastDayOfMonth.getDay() - firstDay[locale.slice(-2).toUpperCase()] + 7) % 7;
-    for (let i = 0; i < firstDayWeekIndex; i++) {
-      const adjacentDay = new Date(firstDayOfMonth);
-      adjacentDay.setDate(adjacentDay.getDate() - (firstDayWeekIndex - i));
-      currentWeek.push(adjacentDay);
-    }
-    for (let i = 1; i <= lastDayOfMonth.getDate(); i++) {
-      const day = new Date(date.getFullYear(), date.getMonth(), i);
-
-      // Add the day to the current week
-      currentWeek.push(day);
-
-      // If the current week has 7 days, add it to the weeks array and start a new week
-      if (currentWeek.length === 7) {
-        weeks.push(currentWeek);
-        currentWeek = [];
-      }
-    }
-    for (let i = 1; i < 7 - lastDayWeekIndex; i++) {
-      const adjacentDay = new Date(lastDayOfMonth);
-      adjacentDay.setDate(adjacentDay.getDate() + i);
-      currentWeek.push(adjacentDay);
-    }
-    if (currentWeek.length > 0) {
-      weeks.push(currentWeek);
-    }
-    return weeks;
-  }
-  function startOfWeek(date, locale) {
-    const d = new Date(date);
-    while (d.getDay() !== (firstDay[locale.slice(-2).toUpperCase()] ?? 0)) {
-      d.setDate(d.getDate() - 1);
-    }
-    return d;
-  }
-  function endOfWeek(date, locale) {
-    const d = new Date(date);
-    const lastDay = ((firstDay[locale.slice(-2).toUpperCase()] ?? 0) + 6) % 7;
-    while (d.getDay() !== lastDay) {
-      d.setDate(d.getDate() + 1);
-    }
-    return d;
-  }
-  function startOfMonth(date) {
-    return new Date(date.getFullYear(), date.getMonth(), 1);
-  }
-  function endOfMonth(date) {
-    return new Date(date.getFullYear(), date.getMonth() + 1, 0);
-  }
-  function parseLocalDate(value) {
-    const parts = value.split('-').map(Number);
-
-    // new Date() uses local time zone when passing individual date component values
-    return new Date(parts[0], parts[1] - 1, parts[2]);
-  }
-  const _YYYMMDD = /^([12]\d{3}-([1-9]|0[1-9]|1[0-2])-([1-9]|0[1-9]|[12]\d|3[01]))$/;
-  function date(value) {
-    if (value == null) return new Date();
-    if (value instanceof Date) return value;
-    if (typeof value === 'string') {
-      let parsed;
-      if (_YYYMMDD.test(value)) {
-        return parseLocalDate(value);
-      } else {
-        parsed = Date.parse(value);
-      }
-      if (!isNaN(parsed)) return new Date(parsed);
-    }
-    return null;
-  }
-  const sundayJanuarySecond2000 = new Date(2000, 0, 2);
-  function getWeekdays(locale) {
-    const daysFromSunday = firstDay[locale.slice(-2).toUpperCase()];
-    return createRange(7).map(i => {
-      const weekday = new Date(sundayJanuarySecond2000);
-      weekday.setDate(sundayJanuarySecond2000.getDate() + daysFromSunday + i);
-      return new Intl.DateTimeFormat(locale, {
-        weekday: 'narrow'
-      }).format(weekday);
-    });
-  }
-  function format(value, formatString, locale, formats) {
-    const newDate = date(value) ?? new Date();
-    const customFormat = formats?.[formatString];
-    if (typeof customFormat === 'function') {
-      return customFormat(newDate, formatString, locale);
+  function format(value, formatString, locale, formats) {
+    const newDate = date(value) ?? new Date();
+    const customFormat = formats?.[formatString];
+    if (typeof customFormat === 'function') {
+      return customFormat(newDate, formatString, locale);
     }
     let options = {};
     switch (formatString) {
@@ -18438,178 +17929,759 @@
     isEqual(date, comparing) {
       return isEqual(date, comparing);
     }
-    isValid(date) {
-      return isValid(date);
+    isValid(date) {
+      return isValid(date);
+    }
+    isWithinRange(date, range) {
+      return isWithinRange(date, range);
+    }
+    isAfter(date, comparing) {
+      return isAfter(date, comparing);
+    }
+    isAfterDay(date, comparing) {
+      return isAfterDay(date, comparing);
+    }
+    isBefore(date, comparing) {
+      return !isAfter(date, comparing) && !isEqual(date, comparing);
+    }
+    isSameDay(date, comparing) {
+      return isSameDay(date, comparing);
+    }
+    isSameMonth(date, comparing) {
+      return isSameMonth(date, comparing);
+    }
+    isSameYear(date, comparing) {
+      return isSameYear(date, comparing);
+    }
+    setMinutes(date, count) {
+      return setMinutes(date, count);
+    }
+    setHours(date, count) {
+      return setHours(date, count);
+    }
+    setMonth(date, count) {
+      return setMonth(date, count);
+    }
+    setDate(date, day) {
+      return setDate(date, day);
+    }
+    setYear(date, year) {
+      return setYear(date, year);
+    }
+    getDiff(date, comparing, unit) {
+      return getDiff(date, comparing, unit);
+    }
+    getWeekdays() {
+      return getWeekdays(this.locale);
+    }
+    getYear(date) {
+      return getYear(date);
+    }
+    getMonth(date) {
+      return getMonth(date);
+    }
+    getDate(date) {
+      return getDate(date);
+    }
+    getNextMonth(date) {
+      return getNextMonth(date);
+    }
+    getPreviousMonth(date) {
+      return getPreviousMonth(date);
+    }
+    getHours(date) {
+      return getHours(date);
+    }
+    getMinutes(date) {
+      return getMinutes(date);
+    }
+    startOfDay(date) {
+      return startOfDay(date);
+    }
+    endOfDay(date) {
+      return endOfDay(date);
+    }
+    startOfYear(date) {
+      return startOfYear(date);
+    }
+    endOfYear(date) {
+      return endOfYear(date);
+    }
+  }
+
+  // Composables
+  const DateOptionsSymbol = Symbol.for('vuetify:date-options');
+  const DateAdapterSymbol = Symbol.for('vuetify:date-adapter');
+  function createDate(options, locale) {
+    const _options = mergeDeep({
+      adapter: VuetifyDateAdapter,
+      locale: {
+        af: 'af-ZA',
+        // ar: '', # not the same value for all variants
+        bg: 'bg-BG',
+        ca: 'ca-ES',
+        ckb: '',
+        cs: 'cs-CZ',
+        de: 'de-DE',
+        el: 'el-GR',
+        en: 'en-US',
+        // es: '', # not the same value for all variants
+        et: 'et-EE',
+        fa: 'fa-IR',
+        fi: 'fi-FI',
+        // fr: '', #not the same value for all variants
+        hr: 'hr-HR',
+        hu: 'hu-HU',
+        he: 'he-IL',
+        id: 'id-ID',
+        it: 'it-IT',
+        ja: 'ja-JP',
+        ko: 'ko-KR',
+        lv: 'lv-LV',
+        lt: 'lt-LT',
+        nl: 'nl-NL',
+        no: 'no-NO',
+        pl: 'pl-PL',
+        pt: 'pt-PT',
+        ro: 'ro-RO',
+        ru: 'ru-RU',
+        sk: 'sk-SK',
+        sl: 'sl-SI',
+        srCyrl: 'sr-SP',
+        srLatn: 'sr-SP',
+        sv: 'sv-SE',
+        th: 'th-TH',
+        tr: 'tr-TR',
+        az: 'az-AZ',
+        uk: 'uk-UA',
+        vi: 'vi-VN',
+        zhHans: 'zh-CN',
+        zhHant: 'zh-TW'
+      }
+    }, options);
+    return {
+      options: _options,
+      instance: createInstance(_options, locale)
+    };
+  }
+  function createInstance(options, locale) {
+    const instance = vue.reactive(typeof options.adapter === 'function'
+    // eslint-disable-next-line new-cap
+    ? new options.adapter({
+      locale: options.locale[locale.current.value] ?? locale.current.value,
+      formats: options.formats
+    }) : options.adapter);
+    vue.watch(locale.current, value => {
+      instance.locale = options.locale[value] ?? value ?? instance.locale;
+    });
+    return instance;
+  }
+  function useDate() {
+    const options = vue.inject(DateOptionsSymbol);
+    if (!options) throw new Error('[Vuetify] Could not find injected date options');
+    const locale = useLocale();
+    return createInstance(options, locale);
+  }
+
+  // https://stackoverflow.com/questions/274861/how-do-i-calculate-the-week-number-given-a-date/275024#275024
+  function getWeek(adapter, value) {
+    const date = adapter.toJsDate(value);
+    let year = date.getFullYear();
+    let d1w1 = new Date(year, 0, 1);
+    if (date < d1w1) {
+      year = year - 1;
+      d1w1 = new Date(year, 0, 1);
+    } else {
+      const tv = new Date(year + 1, 0, 1);
+      if (date >= tv) {
+        year = year + 1;
+        d1w1 = tv;
+      }
+    }
+    const diffTime = Math.abs(date.getTime() - d1w1.getTime());
+    const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24));
+    return Math.floor(diffDays / 7) + 1;
+  }
+
+  // Types
+
+  const makeVConfirmEditProps = propsFactory({
+    modelValue: null,
+    color: String,
+    cancelText: {
+      type: String,
+      default: '$vuetify.confirmEdit.cancel'
+    },
+    okText: {
+      type: String,
+      default: '$vuetify.confirmEdit.ok'
     }
-    isWithinRange(date, range) {
-      return isWithinRange(date, range);
+  }, 'VConfirmEdit');
+  const VConfirmEdit = genericComponent()({
+    name: 'VConfirmEdit',
+    props: makeVConfirmEditProps(),
+    emits: {
+      cancel: () => true,
+      save: value => true,
+      'update:modelValue': value => true
+    },
+    setup(props, _ref) {
+      let {
+        emit,
+        slots
+      } = _ref;
+      const model = useProxiedModel(props, 'modelValue');
+      const internalModel = vue.ref();
+      vue.watchEffect(() => {
+        internalModel.value = structuredClone(vue.toRaw(model.value));
+      });
+      const {
+        t
+      } = useLocale();
+      const isPristine = vue.computed(() => {
+        return deepEqual(model.value, internalModel.value);
+      });
+      function save() {
+        model.value = internalModel.value;
+        emit('save', internalModel.value);
+      }
+      function cancel() {
+        internalModel.value = structuredClone(vue.toRaw(model.value));
+        emit('cancel');
+      }
+      let actionsUsed = false;
+      useRender(() => {
+        const actions = vue.createVNode(vue.Fragment, null, [vue.createVNode(VBtn, {
+          "disabled": isPristine.value,
+          "variant": "text",
+          "color": props.color,
+          "onClick": cancel,
+          "text": t(props.cancelText)
+        }, null), vue.createVNode(VBtn, {
+          "disabled": isPristine.value,
+          "variant": "text",
+          "color": props.color,
+          "onClick": save,
+          "text": t(props.okText)
+        }, null)]);
+        return vue.createVNode(vue.Fragment, null, [slots.default?.({
+          model: internalModel,
+          get actions() {
+            actionsUsed = true;
+            return actions;
+          }
+        }), !actionsUsed && actions]);
+      });
     }
-    isAfter(date, comparing) {
-      return isAfter(date, comparing);
+  });
+
+  // Composables
+
+  // Types
+
+  const makeDataTableExpandProps = propsFactory({
+    expandOnClick: Boolean,
+    showExpand: Boolean,
+    expanded: {
+      type: Array,
+      default: () => []
     }
-    isAfterDay(date, comparing) {
-      return isAfterDay(date, comparing);
+  }, 'DataTable-expand');
+  const VDataTableExpandedKey = Symbol.for('vuetify:datatable:expanded');
+  function provideExpanded(props) {
+    const expandOnClick = vue.toRef(props, 'expandOnClick');
+    const expanded = useProxiedModel(props, 'expanded', props.expanded, v => {
+      return new Set(v);
+    }, v => {
+      return [...v.values()];
+    });
+    function expand(item, value) {
+      const newExpanded = new Set(expanded.value);
+      if (!value) {
+        newExpanded.delete(item.value);
+      } else {
+        newExpanded.add(item.value);
+      }
+      expanded.value = newExpanded;
     }
-    isBefore(date, comparing) {
-      return !isAfter(date, comparing) && !isEqual(date, comparing);
+    function isExpanded(item) {
+      return expanded.value.has(item.value);
     }
-    isSameDay(date, comparing) {
-      return isSameDay(date, comparing);
+    function toggleExpand(item) {
+      expand(item, !isExpanded(item));
     }
-    isSameMonth(date, comparing) {
-      return isSameMonth(date, comparing);
+    const data = {
+      expand,
+      expanded,
+      expandOnClick,
+      isExpanded,
+      toggleExpand
+    };
+    vue.provide(VDataTableExpandedKey, data);
+    return data;
+  }
+  function useExpanded() {
+    const data = vue.inject(VDataTableExpandedKey);
+    if (!data) throw new Error('foo');
+    return data;
+  }
+
+  // Composables
+
+  // Types
+
+  const makeDataTableGroupProps = propsFactory({
+    groupBy: {
+      type: Array,
+      default: () => []
     }
-    isSameYear(date, comparing) {
-      return isSameYear(date, comparing);
+  }, 'DataTable-group');
+  const VDataTableGroupSymbol = Symbol.for('vuetify:data-table-group');
+  function createGroupBy(props) {
+    const groupBy = useProxiedModel(props, 'groupBy');
+    return {
+      groupBy
+    };
+  }
+  function provideGroupBy(options) {
+    const {
+      groupBy,
+      sortBy
+    } = options;
+    const opened = vue.ref(new Set());
+    const sortByWithGroups = vue.computed(() => {
+      return groupBy.value.map(val => ({
+        ...val,
+        order: val.order ?? false
+      })).concat(sortBy.value);
+    });
+    function isGroupOpen(group) {
+      return opened.value.has(group.id);
     }
-    setMinutes(date, count) {
-      return setMinutes(date, count);
+    function toggleGroup(group) {
+      const newOpened = new Set(opened.value);
+      if (!isGroupOpen(group)) newOpened.add(group.id);else newOpened.delete(group.id);
+      opened.value = newOpened;
     }
-    setHours(date, count) {
-      return setHours(date, count);
+    function extractRows(items) {
+      function dive(group) {
+        const arr = [];
+        for (const item of group.items) {
+          if ('type' in item && item.type === 'group') {
+            arr.push(...dive(item));
+          } else {
+            arr.push(item);
+          }
+        }
+        return arr;
+      }
+      return dive({
+        type: 'group',
+        items,
+        id: 'dummy',
+        key: 'dummy',
+        value: 'dummy',
+        depth: 0
+      });
     }
-    setMonth(date, count) {
-      return setMonth(date, count);
+
+    // onBeforeMount(() => {
+    //   for (const key of groupedItems.value.keys()) {
+    //     opened.value.add(key)
+    //   }
+    // })
+
+    const data = {
+      sortByWithGroups,
+      toggleGroup,
+      opened,
+      groupBy,
+      extractRows,
+      isGroupOpen
+    };
+    vue.provide(VDataTableGroupSymbol, data);
+    return data;
+  }
+  function useGroupBy() {
+    const data = vue.inject(VDataTableGroupSymbol);
+    if (!data) throw new Error('Missing group!');
+    return data;
+  }
+  function groupItemsByProperty(items, groupBy) {
+    if (!items.length) return [];
+    const groups = new Map();
+    for (const item of items) {
+      const value = getObjectValueByPath(item.raw, groupBy);
+      if (!groups.has(value)) {
+        groups.set(value, []);
+      }
+      groups.get(value).push(item);
     }
-    setDate(date, day) {
-      return setDate(date, day);
+    return groups;
+  }
+  function groupItems(items, groupBy) {
+    let depth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    let prefix = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'root';
+    if (!groupBy.length) return [];
+    const groupedItems = groupItemsByProperty(items, groupBy[0]);
+    const groups = [];
+    const rest = groupBy.slice(1);
+    groupedItems.forEach((items, value) => {
+      const key = groupBy[0];
+      const id = `${prefix}_${key}_${value}`;
+      groups.push({
+        depth,
+        id,
+        key,
+        value,
+        items: rest.length ? groupItems(items, rest, depth + 1, id) : items,
+        type: 'group'
+      });
+    });
+    return groups;
+  }
+  function flattenItems(items, opened) {
+    const flatItems = [];
+    for (const item of items) {
+      // TODO: make this better
+      if ('type' in item && item.type === 'group') {
+        if (item.value != null) {
+          flatItems.push(item);
+        }
+        if (opened.has(item.id) || item.value == null) {
+          flatItems.push(...flattenItems(item.items, opened));
+        }
+      } else {
+        flatItems.push(item);
+      }
     }
-    setYear(date, year) {
-      return setYear(date, year);
+    return flatItems;
+  }
+  function useGroupedItems(items, groupBy, opened) {
+    const flatItems = vue.computed(() => {
+      if (!groupBy.value.length) return items.value;
+      const groupedItems = groupItems(items.value, groupBy.value.map(item => item.key));
+      return flattenItems(groupedItems, opened.value);
+    });
+    return {
+      flatItems
+    };
+  }
+
+  // Utilities
+
+  // Types
+
+  function useOptions(_ref) {
+    let {
+      page,
+      itemsPerPage,
+      sortBy,
+      groupBy,
+      search
+    } = _ref;
+    const vm = getCurrentInstance('VDataTable');
+    const options = vue.computed(() => ({
+      page: page.value,
+      itemsPerPage: itemsPerPage.value,
+      sortBy: sortBy.value,
+      groupBy: groupBy.value,
+      search: search.value
+    }));
+    let oldOptions = null;
+    vue.watch(options, () => {
+      if (deepEqual(oldOptions, options.value)) return;
+
+      // Reset page when searching
+      if (oldOptions && oldOptions.search !== options.value.search) {
+        page.value = 1;
+      }
+      vm.emit('update:options', options.value);
+      oldOptions = options.value;
+    }, {
+      deep: true,
+      immediate: true
+    });
+  }
+
+  // Composables
+
+  // Types
+
+  const makeDataTablePaginateProps = propsFactory({
+    page: {
+      type: [Number, String],
+      default: 1
+    },
+    itemsPerPage: {
+      type: [Number, String],
+      default: 10
     }
-    getDiff(date, comparing, unit) {
-      return getDiff(date, comparing, unit);
+  }, 'DataTable-paginate');
+  const VDataTablePaginationSymbol = Symbol.for('vuetify:data-table-pagination');
+  function createPagination(props) {
+    const page = useProxiedModel(props, 'page', undefined, value => +(value ?? 1));
+    const itemsPerPage = useProxiedModel(props, 'itemsPerPage', undefined, value => +(value ?? 10));
+    return {
+      page,
+      itemsPerPage
+    };
+  }
+  function providePagination(options) {
+    const {
+      page,
+      itemsPerPage,
+      itemsLength
+    } = options;
+    const startIndex = vue.computed(() => {
+      if (itemsPerPage.value === -1) return 0;
+      return itemsPerPage.value * (page.value - 1);
+    });
+    const stopIndex = vue.computed(() => {
+      if (itemsPerPage.value === -1) return itemsLength.value;
+      return Math.min(itemsLength.value, startIndex.value + itemsPerPage.value);
+    });
+    const pageCount = vue.computed(() => {
+      if (itemsPerPage.value === -1 || itemsLength.value === 0) return 1;
+      return Math.ceil(itemsLength.value / itemsPerPage.value);
+    });
+    vue.watchEffect(() => {
+      if (page.value > pageCount.value) {
+        page.value = pageCount.value;
+      }
+    });
+    function setItemsPerPage(value) {
+      itemsPerPage.value = value;
+      page.value = 1;
     }
-    getWeekdays() {
-      return getWeekdays(this.locale);
+    function nextPage() {
+      page.value = clamp(page.value + 1, 1, pageCount.value);
     }
-    getYear(date) {
-      return getYear(date);
+    function prevPage() {
+      page.value = clamp(page.value - 1, 1, pageCount.value);
     }
-    getMonth(date) {
-      return getMonth(date);
+    function setPage(value) {
+      page.value = clamp(value, 1, pageCount.value);
     }
-    getDate(date) {
-      return getDate(date);
+    const data = {
+      page,
+      itemsPerPage,
+      startIndex,
+      stopIndex,
+      pageCount,
+      itemsLength,
+      nextPage,
+      prevPage,
+      setPage,
+      setItemsPerPage
+    };
+    vue.provide(VDataTablePaginationSymbol, data);
+    return data;
+  }
+  function usePagination() {
+    const data = vue.inject(VDataTablePaginationSymbol);
+    if (!data) throw new Error('Missing pagination!');
+    return data;
+  }
+  function usePaginatedItems(options) {
+    const vm = getCurrentInstance('usePaginatedItems');
+    const {
+      items,
+      startIndex,
+      stopIndex,
+      itemsPerPage
+    } = options;
+    const paginatedItems = vue.computed(() => {
+      if (itemsPerPage.value <= 0) return items.value;
+      return items.value.slice(startIndex.value, stopIndex.value);
+    });
+    vue.watch(paginatedItems, val => {
+      vm.emit('update:currentItems', val);
+    });
+    return {
+      paginatedItems
+    };
+  }
+
+  // Composables
+
+  // Types
+
+  const singleSelectStrategy = {
+    showSelectAll: false,
+    allSelected: () => [],
+    select: _ref => {
+      let {
+        items,
+        value
+      } = _ref;
+      return new Set(value ? [vue.toRaw(items[0]?.value)] : []);
+    },
+    selectAll: _ref2 => {
+      let {
+        selected
+      } = _ref2;
+      return selected;
     }
-    getNextMonth(date) {
-      return getNextMonth(date);
+  };
+  const pageSelectStrategy = {
+    showSelectAll: true,
+    allSelected: _ref3 => {
+      let {
+        currentPage
+      } = _ref3;
+      return currentPage;
+    },
+    select: _ref4 => {
+      let {
+        items,
+        value,
+        selected
+      } = _ref4;
+      for (const item of items) {
+        if (value) selected.add(vue.toRaw(item.value));else selected.delete(vue.toRaw(item.value));
+      }
+      return selected;
+    },
+    selectAll: _ref5 => {
+      let {
+        value,
+        currentPage,
+        selected
+      } = _ref5;
+      return pageSelectStrategy.select({
+        items: currentPage,
+        value,
+        selected
+      });
     }
-    getPreviousMonth(date) {
-      return getPreviousMonth(date);
+  };
+  const allSelectStrategy = {
+    showSelectAll: true,
+    allSelected: _ref6 => {
+      let {
+        allItems
+      } = _ref6;
+      return allItems;
+    },
+    select: _ref7 => {
+      let {
+        items,
+        value,
+        selected
+      } = _ref7;
+      for (const item of items) {
+        if (value) selected.add(vue.toRaw(item.value));else selected.delete(vue.toRaw(item.value));
+      }
+      return selected;
+    },
+    selectAll: _ref8 => {
+      let {
+        value,
+        allItems,
+        selected
+      } = _ref8;
+      return allSelectStrategy.select({
+        items: allItems,
+        value,
+        selected
+      });
     }
-    getHours(date) {
-      return getHours(date);
+  };
+  const makeDataTableSelectProps = propsFactory({
+    showSelect: Boolean,
+    selectStrategy: {
+      type: [String, Object],
+      default: 'page'
+    },
+    modelValue: {
+      type: Array,
+      default: () => []
+    },
+    valueComparator: {
+      type: Function,
+      default: deepEqual
     }
-    getMinutes(date) {
-      return getMinutes(date);
+  }, 'DataTable-select');
+  const VDataTableSelectionSymbol = Symbol.for('vuetify:data-table-selection');
+  function provideSelection(props, _ref9) {
+    let {
+      allItems,
+      currentPage
+    } = _ref9;
+    const selected = useProxiedModel(props, 'modelValue', props.modelValue, v => {
+      return new Set(wrapInArray(v).map(v => {
+        return allItems.value.find(item => props.valueComparator(v, item.value))?.value ?? v;
+      }));
+    }, v => {
+      return [...v.values()];
+    });
+    const allSelectable = vue.computed(() => allItems.value.filter(item => item.selectable));
+    const currentPageSelectable = vue.computed(() => currentPage.value.filter(item => item.selectable));
+    const selectStrategy = vue.computed(() => {
+      if (typeof props.selectStrategy === 'object') return props.selectStrategy;
+      switch (props.selectStrategy) {
+        case 'single':
+          return singleSelectStrategy;
+        case 'all':
+          return allSelectStrategy;
+        case 'page':
+        default:
+          return pageSelectStrategy;
+      }
+    });
+    function isSelected(items) {
+      return wrapInArray(items).every(item => selected.value.has(vue.toRaw(item.value)));
     }
-    startOfDay(date) {
-      return startOfDay(date);
+    function isSomeSelected(items) {
+      return wrapInArray(items).some(item => selected.value.has(vue.toRaw(item.value)));
     }
-    endOfDay(date) {
-      return endOfDay(date);
+    function select(items, value) {
+      const newSelected = selectStrategy.value.select({
+        items,
+        value,
+        selected: new Set(selected.value)
+      });
+      selected.value = newSelected;
     }
-    startOfYear(date) {
-      return startOfYear(date);
+    function toggleSelect(item) {
+      const newItem = vue.toRef(item);
+      select([newItem.value], !isSelected([newItem.value]));
     }
-    endOfYear(date) {
-      return endOfYear(date);
+    function selectAll(value) {
+      const newSelected = selectStrategy.value.selectAll({
+        value,
+        allItems: allSelectable.value,
+        currentPage: currentPageSelectable.value,
+        selected: new Set(selected.value)
+      });
+      selected.value = newSelected;
     }
-  }
-
-  // Composables
-  const DateOptionsSymbol = Symbol.for('vuetify:date-options');
-  const DateAdapterSymbol = Symbol.for('vuetify:date-adapter');
-  function createDate(options, locale) {
-    const _options = mergeDeep({
-      adapter: VuetifyDateAdapter,
-      locale: {
-        af: 'af-ZA',
-        // ar: '', # not the same value for all variants
-        bg: 'bg-BG',
-        ca: 'ca-ES',
-        ckb: '',
-        cs: 'cs-CZ',
-        de: 'de-DE',
-        el: 'el-GR',
-        en: 'en-US',
-        // es: '', # not the same value for all variants
-        et: 'et-EE',
-        fa: 'fa-IR',
-        fi: 'fi-FI',
-        // fr: '', #not the same value for all variants
-        hr: 'hr-HR',
-        hu: 'hu-HU',
-        he: 'he-IL',
-        id: 'id-ID',
-        it: 'it-IT',
-        ja: 'ja-JP',
-        ko: 'ko-KR',
-        lv: 'lv-LV',
-        lt: 'lt-LT',
-        nl: 'nl-NL',
-        no: 'no-NO',
-        pl: 'pl-PL',
-        pt: 'pt-PT',
-        ro: 'ro-RO',
-        ru: 'ru-RU',
-        sk: 'sk-SK',
-        sl: 'sl-SI',
-        srCyrl: 'sr-SP',
-        srLatn: 'sr-SP',
-        sv: 'sv-SE',
-        th: 'th-TH',
-        tr: 'tr-TR',
-        az: 'az-AZ',
-        uk: 'uk-UA',
-        vi: 'vi-VN',
-        zhHans: 'zh-CN',
-        zhHant: 'zh-TW'
-      }
-    }, options);
-    return {
-      options: _options,
-      instance: createInstance(_options, locale)
-    };
-  }
-  function createInstance(options, locale) {
-    const instance = vue.reactive(typeof options.adapter === 'function'
-    // eslint-disable-next-line new-cap
-    ? new options.adapter({
-      locale: options.locale[locale.current.value] ?? locale.current.value,
-      formats: options.formats
-    }) : options.adapter);
-    vue.watch(locale.current, value => {
-      instance.locale = options.locale[value] ?? value ?? instance.locale;
+    const someSelected = vue.computed(() => selected.value.size > 0);
+    const allSelected = vue.computed(() => {
+      const items = selectStrategy.value.allSelected({
+        allItems: allSelectable.value,
+        currentPage: currentPageSelectable.value
+      });
+      return !!items.length && isSelected(items);
     });
-    return instance;
-  }
-  function useDate() {
-    const options = vue.inject(DateOptionsSymbol);
-    if (!options) throw new Error('[Vuetify] Could not find injected date options');
-    const locale = useLocale();
-    return createInstance(options, locale);
+    const data = {
+      toggleSelect,
+      select,
+      selectAll,
+      isSelected,
+      isSomeSelected,
+      someSelected,
+      allSelected,
+      showSelectAll: selectStrategy.value.showSelectAll
+    };
+    vue.provide(VDataTableSelectionSymbol, data);
+    return data;
   }
-
-  // https://stackoverflow.com/questions/274861/how-do-i-calculate-the-week-number-given-a-date/275024#275024
-  function getWeek(adapter, value) {
-    const date = adapter.toJsDate(value);
-    let year = date.getFullYear();
-    let d1w1 = new Date(year, 0, 1);
-    if (date < d1w1) {
-      year = year - 1;
-      d1w1 = new Date(year, 0, 1);
-    } else {
-      const tv = new Date(year + 1, 0, 1);
-      if (date >= tv) {
-        year = year + 1;
-        d1w1 = tv;
-      }
-    }
-    const diffTime = Math.abs(date.getTime() - d1w1.getTime());
-    const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24));
-    return Math.floor(diffDays / 7) + 1;
+  function useSelection() {
+    const data = vue.inject(VDataTableSelectionSymbol);
+    if (!data) throw new Error('Missing selection!');
+    return data;
   }
 
   // Composables
@@ -22195,6 +22267,141 @@
     }
   });
 
+  // Types
+
+  // Types
+
+  const makeVEmptyStateProps = propsFactory({
+    actionText: String,
+    bgColor: String,
+    color: String,
+    icon: IconValue,
+    image: String,
+    justify: {
+      type: String,
+      default: 'center'
+    },
+    headline: String,
+    title: String,
+    text: String,
+    textWidth: {
+      type: [Number, String],
+      default: 500
+    },
+    href: String,
+    to: String,
+    ...makeComponentProps(),
+    ...makeDimensionProps(),
+    ...makeSizeProps({
+      size: undefined
+    }),
+    ...makeThemeProps()
+  }, 'VEmptyState');
+  const VEmptyState = genericComponent()({
+    name: 'VEmptyState',
+    props: makeVEmptyStateProps(),
+    emits: {
+      'click:action': e => true
+    },
+    setup(props, _ref) {
+      let {
+        emit,
+        slots
+      } = _ref;
+      const {
+        themeClasses
+      } = provideTheme(props);
+      const {
+        backgroundColorClasses,
+        backgroundColorStyles
+      } = useBackgroundColor(vue.toRef(props, 'bgColor'));
+      const {
+        dimensionStyles
+      } = useDimension(props);
+      const {
+        displayClasses
+      } = useDisplay();
+      function onClickAction(e) {
+        emit('click:action', e);
+      }
+      useRender(() => {
+        const hasActions = !!(slots.actions || props.actionText);
+        const hasHeadline = !!(slots.headline || props.headline);
+        const hasTitle = !!(slots.title || props.title);
+        const hasText = !!(slots.text || props.text);
+        const hasMedia = !!(slots.media || props.image || props.icon);
+        const size = props.size || (props.image ? 200 : 96);
+        return vue.createVNode("div", {
+          "class": ['v-empty-state', {
+            [`v-empty-state--${props.justify}`]: true
+          }, themeClasses.value, backgroundColorClasses.value, displayClasses.value, props.class],
+          "style": [backgroundColorStyles.value, dimensionStyles.value, props.style]
+        }, [hasMedia && vue.createVNode("div", {
+          "key": "media",
+          "class": "v-empty-state__media"
+        }, [!slots.media ? vue.createVNode(vue.Fragment, null, [props.image ? vue.createVNode(VImg, {
+          "key": "image",
+          "src": props.image,
+          "height": size
+        }, null) : props.icon ? vue.createVNode(VIcon, {
+          "key": "icon",
+          "color": props.color,
+          "size": size,
+          "icon": props.icon
+        }, null) : undefined]) : vue.createVNode(VDefaultsProvider, {
+          "key": "media-defaults",
+          "defaults": {
+            VImg: {
+              src: props.image,
+              height: size
+            },
+            VIcon: {
+              size,
+              icon: props.icon
+            }
+          }
+        }, {
+          default: () => [slots.media()]
+        })]), hasHeadline && vue.createVNode("div", {
+          "key": "headline",
+          "class": "v-empty-state__headline"
+        }, [slots.headline?.() ?? props.headline]), hasTitle && vue.createVNode("div", {
+          "key": "title",
+          "class": "v-empty-state__title"
+        }, [slots.title?.() ?? props.title]), hasText && vue.createVNode("div", {
+          "key": "text",
+          "class": "v-empty-state__text",
+          "style": {
+            maxWidth: convertToUnit(props.textWidth)
+          }
+        }, [slots.text?.() ?? props.text]), slots.default && vue.createVNode("div", {
+          "key": "content",
+          "class": "v-empty-state__content"
+        }, [slots.default()]), hasActions && vue.createVNode("div", {
+          "key": "actions",
+          "class": "v-empty-state__actions"
+        }, [vue.createVNode(VDefaultsProvider, {
+          "defaults": {
+            VBtn: {
+              class: 'v-empty-state__action-btn',
+              color: props.color,
+              text: props.actionText
+            }
+          }
+        }, {
+          default: () => [slots.actions?.({
+            props: {
+              onClick: onClickAction
+            }
+          }) ?? vue.createVNode(VBtn, {
+            "onClick": onClickAction
+          }, null)]
+        })])]);
+      });
+      return {};
+    }
+  });
+
   const makeVExpansionPanelTextProps = propsFactory({
     ...makeComponentProps(),
     ...makeLazyProps()
@@ -22428,6 +22635,107 @@
     }
   });
 
+  const makeVFabProps = propsFactory({
+    app: Boolean,
+    appear: Boolean,
+    extended: Boolean,
+    layout: Boolean,
+    location: {
+      type: String,
+      default: 'bottom end'
+    },
+    offset: Boolean,
+    modelValue: {
+      type: Boolean,
+      default: true
+    },
+    ...omit(makeVBtnProps({
+      active: true
+    }), ['location']),
+    ...makeLayoutItemProps(),
+    ...makeTransitionProps({
+      transition: 'fab-transition'
+    })
+  }, 'VFab');
+  const VFab = genericComponent()({
+    name: 'VFab',
+    props: makeVFabProps(),
+    emits: {
+      'update:modelValue': value => true
+    },
+    setup(props, _ref) {
+      let {
+        slots
+      } = _ref;
+      const model = useProxiedModel(props, 'modelValue');
+      const height = vue.shallowRef(56);
+      const layoutItemStyles = vue.ref();
+      const {
+        resizeRef
+      } = useResizeObserver(entries => {
+        if (!entries.length) return;
+        height.value = entries[0].target.clientHeight;
+      });
+      const hasPosition = vue.computed(() => props.app || props.absolute);
+      const position = vue.computed(() => {
+        if (!hasPosition.value) return false;
+        return props.location.split(' ').shift();
+      });
+      const orientation = vue.computed(() => {
+        if (!hasPosition.value) return false;
+        return props.location.split(' ')[1] ?? 'end';
+      });
+      useToggleScope(() => props.app, () => {
+        const layout = useLayoutItem({
+          id: props.name,
+          order: vue.computed(() => parseInt(props.order, 10)),
+          position,
+          layoutSize: vue.computed(() => props.layout ? height.value + 24 : 0),
+          elementSize: vue.computed(() => height.value + 24),
+          active: vue.computed(() => props.app && model.value),
+          absolute: vue.toRef(props, 'absolute')
+        });
+        vue.watchEffect(() => {
+          layoutItemStyles.value = layout.layoutItemStyles.value;
+        });
+      });
+      const vFabRef = vue.ref();
+      useRender(() => {
+        const btnProps = VBtn.filterProps(props);
+        return vue.createVNode("div", {
+          "ref": vFabRef,
+          "class": ['v-fab', {
+            'v-fab--absolute': props.absolute,
+            'v-fab--app': !!props.app,
+            'v-fab--extended': props.extended,
+            'v-fab--offset': props.offset,
+            [`v-fab--${position.value}`]: hasPosition.value,
+            [`v-fab--${orientation.value}`]: hasPosition.value
+          }, props.class],
+          "style": [props.app ? {
+            ...layoutItemStyles.value
+          } : {
+            height: 'inherit',
+            width: undefined
+          }, props.style]
+        }, [vue.createVNode("div", {
+          "class": "v-fab__container"
+        }, [vue.createVNode(MaybeTransition, {
+          "appear": props.appear,
+          "transition": props.transition
+        }, {
+          default: () => [vue.withDirectives(vue.createVNode(VBtn, vue.mergeProps({
+            "ref": resizeRef
+          }, btnProps, {
+            "active": undefined,
+            "location": undefined
+          }), slots), [[vue.vShow, props.active]])]
+        })])]);
+      });
+      return {};
+    }
+  });
+
   // Types
 
   const makeVFileInputProps = propsFactory({
@@ -25088,6 +25396,519 @@
     }
   });
 
+  // Utilities
+
+  // Types
+
+  const makeLineProps = propsFactory({
+    autoDraw: Boolean,
+    autoDrawDuration: [Number, String],
+    autoDrawEasing: {
+      type: String,
+      default: 'ease'
+    },
+    color: String,
+    gradient: {
+      type: Array,
+      default: () => []
+    },
+    gradientDirection: {
+      type: String,
+      validator: val => ['top', 'bottom', 'left', 'right'].includes(val),
+      default: 'top'
+    },
+    height: {
+      type: [String, Number],
+      default: 75
+    },
+    labels: {
+      type: Array,
+      default: () => []
+    },
+    labelSize: {
+      type: [Number, String],
+      default: 7
+    },
+    lineWidth: {
+      type: [String, Number],
+      default: 4
+    },
+    id: String,
+    itemValue: {
+      type: String,
+      default: 'value'
+    },
+    modelValue: {
+      type: Array,
+      default: () => []
+    },
+    min: [String, Number],
+    max: [String, Number],
+    padding: {
+      type: [String, Number],
+      default: 8
+    },
+    showLabels: Boolean,
+    smooth: Boolean,
+    width: {
+      type: [Number, String],
+      default: 300
+    }
+  }, 'Line');
+
+  // Types
+
+  const makeVBarlineProps = propsFactory({
+    autoLineWidth: Boolean,
+    ...makeLineProps()
+  }, 'VBarline');
+  const VBarline = genericComponent()({
+    name: 'VBarline',
+    props: makeVBarlineProps(),
+    setup(props, _ref) {
+      let {
+        slots
+      } = _ref;
+      const uid = getUid();
+      const id = vue.computed(() => props.id || `barline-${uid}`);
+      const autoDrawDuration = vue.computed(() => Number(props.autoDrawDuration) || 500);
+      const hasLabels = vue.computed(() => {
+        return Boolean(props.showLabels || props.labels.length > 0 || !!slots?.label);
+      });
+      const lineWidth = vue.computed(() => parseFloat(props.lineWidth) || 4);
+      const totalWidth = vue.computed(() => Math.max(props.modelValue.length * lineWidth.value, Number(props.width)));
+      const boundary = vue.computed(() => {
+        return {
+          minX: 0,
+          maxX: totalWidth.value,
+          minY: 0,
+          maxY: parseInt(props.height, 10)
+        };
+      });
+      const items = vue.computed(() => props.modelValue.map(item => getPropertyFromItem(item, props.itemValue, item)));
+      function genBars(values, boundary) {
+        const {
+          minX,
+          maxX,
+          minY,
+          maxY
+        } = boundary;
+        const totalValues = values.length;
+        let maxValue = props.max != null ? Number(props.max) : Math.max(...values);
+        let minValue = props.min != null ? Number(props.min) : Math.min(...values);
+        if (minValue > 0 && props.min == null) minValue = 0;
+        if (maxValue < 0 && props.max == null) maxValue = 0;
+        const gridX = maxX / totalValues;
+        const gridY = (maxY - minY) / (maxValue - minValue || 1);
+        const horizonY = maxY - Math.abs(minValue * gridY);
+        return values.map((value, index) => {
+          const height = Math.abs(gridY * value);
+          return {
+            x: minX + index * gridX,
+            y: horizonY - height + +(value < 0) * height,
+            height,
+            value
+          };
+        });
+      }
+      const parsedLabels = vue.computed(() => {
+        const labels = [];
+        const points = genBars(items.value, boundary.value);
+        const len = points.length;
+        for (let i = 0; labels.length < len; i++) {
+          const item = points[i];
+          let value = props.labels[i];
+          if (!value) {
+            value = typeof item === 'object' ? item.value : item;
+          }
+          labels.push({
+            x: item.x,
+            value: String(value)
+          });
+        }
+        return labels;
+      });
+      const bars = vue.computed(() => genBars(items.value, boundary.value));
+      const offsetX = vue.computed(() => (Math.abs(bars.value[0].x - bars.value[1].x) - lineWidth.value) / 2);
+      useRender(() => {
+        const gradientData = !props.gradient.slice().length ? [''] : props.gradient.slice().reverse();
+        return vue.createVNode("svg", {
+          "display": "block"
+        }, [vue.createVNode("defs", null, [vue.createVNode("linearGradient", {
+          "id": id.value,
+          "gradientUnits": "userSpaceOnUse",
+          "x1": props.gradientDirection === 'left' ? '100%' : '0',
+          "y1": props.gradientDirection === 'top' ? '100%' : '0',
+          "x2": props.gradientDirection === 'right' ? '100%' : '0',
+          "y2": props.gradientDirection === 'bottom' ? '100%' : '0'
+        }, [gradientData.map((color, index) => vue.createVNode("stop", {
+          "offset": index / Math.max(gradientData.length - 1, 1),
+          "stop-color": color || 'currentColor'
+        }, null))])]), vue.createVNode("clipPath", {
+          "id": `${id.value}-clip`
+        }, [bars.value.map(item => vue.createVNode("rect", {
+          "x": item.x + offsetX.value,
+          "y": item.y,
+          "width": lineWidth.value,
+          "height": item.height,
+          "rx": typeof props.smooth === 'number' ? props.smooth : props.smooth ? 2 : 0,
+          "ry": typeof props.smooth === 'number' ? props.smooth : props.smooth ? 2 : 0
+        }, [props.autoDraw && vue.createVNode(vue.Fragment, null, [vue.createVNode("animate", {
+          "attributeName": "y",
+          "from": item.y + item.height,
+          "to": item.y,
+          "dur": `${autoDrawDuration.value}ms`,
+          "fill": "freeze"
+        }, null), vue.createVNode("animate", {
+          "attributeName": "height",
+          "from": "0",
+          "to": item.height,
+          "dur": `${autoDrawDuration.value}ms`,
+          "fill": "freeze"
+        }, null)])]))]), hasLabels.value && vue.createVNode("g", {
+          "key": "labels",
+          "style": {
+            textAnchor: 'middle',
+            dominantBaseline: 'mathematical',
+            fill: 'currentColor'
+          }
+        }, [parsedLabels.value.map((item, i) => vue.createVNode("text", {
+          "x": item.x + offsetX.value + lineWidth.value / 2,
+          "y": parseInt(props.height, 10) - 2 + (parseInt(props.labelSize, 10) || 7 * 0.75),
+          "font-size": Number(props.labelSize) || 7
+        }, [slots.label?.({
+          index: i,
+          value: item.value
+        }) ?? item.value]))]), vue.createVNode("g", {
+          "clip-path": `url(#${id.value}-clip)`,
+          "fill": `url(#${id.value})`
+        }, [vue.createVNode("rect", {
+          "x": 0,
+          "y": 0,
+          "width": Math.max(props.modelValue.length * lineWidth.value, Number(props.width)),
+          "height": props.height
+        }, null)])]);
+      });
+    }
+  });
+
+  // @ts-nocheck
+  /* eslint-disable */
+
+  // import { checkCollinear, getDistance, moveTo } from './math'
+
+  /**
+   * From https://github.com/unsplash/react-trend/blob/master/src/helpers/DOM.helpers.js#L18
+   */
+  function genPath(points, radius) {
+    let fill = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    let height = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 75;
+    if (points.length === 0) return '';
+    const start = points.shift();
+    const end = points[points.length - 1];
+    return (fill ? `M${start.x} ${height - start.x + 2} L${start.x} ${start.y}` : `M${start.x} ${start.y}`) + points.map((point, index) => {
+      const next = points[index + 1];
+      const prev = points[index - 1] || start;
+      const isCollinear = next && checkCollinear(next, point, prev);
+      if (!next || isCollinear) {
+        return `L${point.x} ${point.y}`;
+      }
+      const threshold = Math.min(getDistance(prev, point), getDistance(next, point));
+      const isTooCloseForRadius = threshold / 2 < radius;
+      const radiusForPoint = isTooCloseForRadius ? threshold / 2 : radius;
+      const before = moveTo(prev, point, radiusForPoint);
+      const after = moveTo(next, point, radiusForPoint);
+      return `L${before.x} ${before.y}S${point.x} ${point.y} ${after.x} ${after.y}`;
+    }).join('') + (fill ? `L${end.x} ${height - start.x + 2} Z` : '');
+  }
+  function int(value) {
+    return parseInt(value, 10);
+  }
+
+  /**
+   * https://en.wikipedia.org/wiki/Collinearity
+   * x=(x1+x2)/2
+   * y=(y1+y2)/2
+   */
+  function checkCollinear(p0, p1, p2) {
+    return int(p0.x + p2.x) === int(2 * p1.x) && int(p0.y + p2.y) === int(2 * p1.y);
+  }
+  function getDistance(p1, p2) {
+    return Math.sqrt(Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2));
+  }
+  function moveTo(to, from, radius) {
+    const vector = {
+      x: to.x - from.x,
+      y: to.y - from.y
+    };
+    const length = Math.sqrt(vector.x * vector.x + vector.y * vector.y);
+    const unitVector = {
+      x: vector.x / length,
+      y: vector.y / length
+    };
+    return {
+      x: from.x + unitVector.x * radius,
+      y: from.y + unitVector.y * radius
+    };
+  }
+
+  // Types
+
+  const makeVTrendlineProps = propsFactory({
+    fill: Boolean,
+    ...makeLineProps()
+  }, 'VTrendline');
+  const VTrendline = genericComponent()({
+    name: 'VTrendline',
+    props: makeVTrendlineProps(),
+    setup(props, _ref) {
+      let {
+        slots
+      } = _ref;
+      const uid = getUid();
+      const id = vue.computed(() => props.id || `trendline-${uid}`);
+      const autoDrawDuration = vue.computed(() => Number(props.autoDrawDuration) || (props.fill ? 500 : 2000));
+      const lastLength = vue.ref(0);
+      const path = vue.ref(null);
+      function genPoints(values, boundary) {
+        const {
+          minX,
+          maxX,
+          minY,
+          maxY
+        } = boundary;
+        const totalValues = values.length;
+        const maxValue = props.max != null ? Number(props.max) : Math.max(...values);
+        const minValue = props.min != null ? Number(props.min) : Math.min(...values);
+        const gridX = (maxX - minX) / (totalValues - 1);
+        const gridY = (maxY - minY) / (maxValue - minValue || 1);
+        return values.map((value, index) => {
+          return {
+            x: minX + index * gridX,
+            y: maxY - (value - minValue) * gridY,
+            value
+          };
+        });
+      }
+      const hasLabels = vue.computed(() => {
+        return Boolean(props.showLabels || props.labels.length > 0 || !!slots?.label);
+      });
+      const lineWidth = vue.computed(() => {
+        return parseFloat(props.lineWidth) || 4;
+      });
+      const totalWidth = vue.computed(() => Number(props.width));
+      const boundary = vue.computed(() => {
+        const padding = Number(props.padding);
+        return {
+          minX: padding,
+          maxX: totalWidth.value - padding,
+          minY: padding,
+          maxY: parseInt(props.height, 10) - padding
+        };
+      });
+      const items = vue.computed(() => props.modelValue.map(item => getPropertyFromItem(item, props.itemValue, item)));
+      const parsedLabels = vue.computed(() => {
+        const labels = [];
+        const points = genPoints(items.value, boundary.value);
+        const len = points.length;
+        for (let i = 0; labels.length < len; i++) {
+          const item = points[i];
+          let value = props.labels[i];
+          if (!value) {
+            value = typeof item === 'object' ? item.value : item;
+          }
+          labels.push({
+            x: item.x,
+            value: String(value)
+          });
+        }
+        return labels;
+      });
+      vue.watch(() => props.modelValue, async () => {
+        await vue.nextTick();
+        if (!props.autoDraw || !path.value) return;
+        const pathRef = path.value;
+        const length = pathRef.getTotalLength();
+        if (!props.fill) {
+          // Initial setup to "hide" the line by using the stroke dash array
+          pathRef.style.strokeDasharray = `${length}`;
+          pathRef.style.strokeDashoffset = `${length}`;
+
+          // Force reflow to ensure the transition starts from this state
+          pathRef.getBoundingClientRect();
+
+          // Animate the stroke dash offset to "draw" the line
+          pathRef.style.transition = `stroke-dashoffset ${autoDrawDuration.value}ms ${props.autoDrawEasing}`;
+          pathRef.style.strokeDashoffset = '0';
+        } else {
+          // Your existing logic for filled paths remains the same
+          pathRef.style.transformOrigin = 'bottom center';
+          pathRef.style.transition = 'none';
+          pathRef.style.transform = `scaleY(0)`;
+          pathRef.getBoundingClientRect();
+          pathRef.style.transition = `transform ${autoDrawDuration.value}ms ${props.autoDrawEasing}`;
+          pathRef.style.transform = `scaleY(1)`;
+        }
+        lastLength.value = length;
+      }, {
+        immediate: true
+      });
+      function genPath$1(fill) {
+        return genPath(genPoints(items.value, boundary.value), props.smooth ? 8 : Number(props.smooth), fill, parseInt(props.height, 10));
+      }
+      useRender(() => {
+        const gradientData = !props.gradient.slice().length ? [''] : props.gradient.slice().reverse();
+        return vue.createVNode("svg", {
+          "display": "block",
+          "stroke-width": parseFloat(props.lineWidth) ?? 4
+        }, [vue.createVNode("defs", null, [vue.createVNode("linearGradient", {
+          "id": id.value,
+          "gradientUnits": "userSpaceOnUse",
+          "x1": props.gradientDirection === 'left' ? '100%' : '0',
+          "y1": props.gradientDirection === 'top' ? '100%' : '0',
+          "x2": props.gradientDirection === 'right' ? '100%' : '0',
+          "y2": props.gradientDirection === 'bottom' ? '100%' : '0'
+        }, [gradientData.map((color, index) => vue.createVNode("stop", {
+          "offset": index / Math.max(gradientData.length - 1, 1),
+          "stop-color": color || 'currentColor'
+        }, null))])]), hasLabels.value && vue.createVNode("g", {
+          "key": "labels",
+          "style": {
+            textAnchor: 'middle',
+            dominantBaseline: 'mathematical',
+            fill: 'currentColor'
+          }
+        }, [parsedLabels.value.map((item, i) => vue.createVNode("text", {
+          "x": item.x + lineWidth.value / 2 + lineWidth.value / 2,
+          "y": parseInt(props.height, 10) - 4 + (parseInt(props.labelSize, 10) || 7 * 0.75),
+          "font-size": Number(props.labelSize) || 7
+        }, [slots.label?.({
+          index: i,
+          value: item.value
+        }) ?? item.value]))]), vue.createVNode("path", {
+          "ref": path,
+          "d": genPath$1(props.fill),
+          "fill": props.fill ? `url(#${id.value})` : 'none',
+          "stroke": props.fill ? 'none' : `url(#${id.value})`
+        }, null), props.fill && vue.createVNode("path", {
+          "d": genPath$1(false),
+          "fill": "none",
+          "stroke": props.color ?? props.gradient?.[0]
+        }, null)]);
+      });
+    }
+  });
+
+  // Types
+
+  // Types
+
+  const makeVSparklineProps = propsFactory({
+    type: {
+      type: String,
+      default: 'trend'
+    },
+    ...makeVBarlineProps(),
+    ...makeVTrendlineProps()
+  }, 'VSparkline');
+  const VSparkline = genericComponent()({
+    name: 'VSparkline',
+    props: makeVSparklineProps(),
+    setup(props, _ref) {
+      let {
+        slots
+      } = _ref;
+      const {
+        textColorClasses,
+        textColorStyles
+      } = useTextColor(vue.toRef(props, 'color'));
+      const hasLabels = vue.computed(() => {
+        return Boolean(props.showLabels || props.labels.length > 0 || !!slots?.label);
+      });
+      const totalHeight = vue.computed(() => {
+        let height = parseInt(props.height, 10);
+        if (hasLabels.value) height += parseInt(props.labelSize, 10) * 1.5;
+        return height;
+      });
+      useRender(() => {
+        const Tag = props.type === 'trend' ? VTrendline : VBarline;
+        const lineProps = props.type === 'trend' ? VTrendline.filterProps(props) : VBarline.filterProps(props);
+        return vue.createVNode(Tag, vue.mergeProps({
+          "key": props.type,
+          "class": textColorClasses.value,
+          "style": textColorStyles.value,
+          "viewBox": `0 0 ${props.width} ${parseInt(totalHeight.value, 10)}`
+        }, lineProps), slots);
+      });
+    }
+  });
+
+  // Types
+
+  const makeVSpeedDialProps = propsFactory({
+    ...makeComponentProps(),
+    ...makeVMenuProps({
+      offset: 8,
+      minWidth: 0,
+      openDelay: 0,
+      closeDelay: 100,
+      location: 'top center',
+      transition: 'scale-transition'
+    })
+  }, 'VSpeedDial');
+  const VSpeedDial = genericComponent()({
+    name: 'VSpeedDial',
+    props: makeVSpeedDialProps(),
+    emits: {
+      'update:modelValue': value => true
+    },
+    setup(props, _ref) {
+      let {
+        slots
+      } = _ref;
+      const model = useProxiedModel(props, 'modelValue');
+      const menuRef = vue.ref();
+      const location = vue.computed(() => {
+        const [y, x = 'center'] = props.location.split(' ');
+        return `${y} ${x}`;
+      });
+      const locationClasses = vue.computed(() => ({
+        [`v-speed-dial__content--${location.value.replace(' ', '-')}`]: true
+      }));
+      useRender(() => {
+        const menuProps = VMenu.filterProps(props);
+        return vue.createVNode(VMenu, vue.mergeProps(menuProps, {
+          "modelValue": model.value,
+          "onUpdate:modelValue": $event => model.value = $event,
+          "class": props.class,
+          "style": props.style,
+          "contentClass": ['v-speed-dial__content', locationClasses.value],
+          "location": location.value,
+          "ref": menuRef,
+          "transition": "fade-transition"
+        }), {
+          ...slots,
+          default: slotProps => vue.createVNode(VDefaultsProvider, {
+            "defaults": {
+              VBtn: {
+                size: 'small'
+              }
+            }
+          }, {
+            default: () => [vue.createVNode(MaybeTransition, {
+              "appear": true,
+              "group": true,
+              "transition": props.transition
+            }, {
+              default: () => [slots.default?.(slotProps)]
+            })]
+          })
+        });
+      });
+      return {};
+    }
+  });
+
   // Types
 
   const makeVStepperActionsProps = propsFactory({
@@ -26666,6 +27487,7 @@
     VColorPicker: VColorPicker,
     VCombobox: VCombobox,
     VComponentIcon: VComponentIcon,
+    VConfirmEdit: VConfirmEdit,
     VContainer: VContainer,
     VCounter: VCounter,
     VDataIterator: VDataIterator,
@@ -26688,12 +27510,14 @@
     VDialogTopTransition: VDialogTopTransition,
     VDialogTransition: VDialogTransition,
     VDivider: VDivider,
+    VEmptyState: VEmptyState,
     VExpandTransition: VExpandTransition,
     VExpandXTransition: VExpandXTransition,
     VExpansionPanel: VExpansionPanel,
     VExpansionPanelText: VExpansionPanelText,
     VExpansionPanelTitle: VExpansionPanelTitle,
     VExpansionPanels: VExpansionPanels,
+    VFab: VFab,
     VFabTransition: VFabTransition,
     VFadeTransition: VFadeTransition,
     VField: VField,
@@ -26760,6 +27584,8 @@
     VSlider: VSlider,
     VSnackbar: VSnackbar,
     VSpacer: VSpacer,
+    VSparkline: VSparkline,
+    VSpeedDial: VSpeedDial,
     VStepper: VStepper,
     VStepperActions: VStepperActions,
     VStepperHeader: VStepperHeader,
@@ -26936,9 +27762,7 @@
       // If vnode.ctx is the same as the instance, then we're bound to a plain element
       // and need to find the nearest parent component instance to inherit provides from
       const provides = (vnode.ctx === binding.instance.$ ? findComponentParent(vnode, binding.instance.$)?.provides : vnode.ctx?.provides) ?? binding.instance.$.provides;
-      const node = vue.h(component, vue.mergeProps(_props, value), {
-        default: () => children
-      });
+      const node = vue.h(component, vue.mergeProps(_props, value), children);
       node.appContext = Object.assign(Object.create(null), binding.instance.$.appContext, {
         provides
       });
@@ -27097,7 +27921,7 @@
       goTo
     };
   }
-  const version$1 = "3.6.0";
+  const version$1 = "3.6.1";
   createVuetify$1.version = version$1;
 
   // Vue's inject() can only be used in setup
@@ -27122,7 +27946,7 @@
       ...options
     });
   };
-  const version = "3.6.0";
+  const version = "3.6.1";
   createVuetify.version = version;
 
   exports.blueprints = index;