vuetify 3.6.0 → 3.6.1

package/dist/vuetify.esm.js

@@ -1,5 +1,5 @@
 /*!
-* Vuetify v3.6.0
+* Vuetify v3.6.1
 * Forged by John Leider
 * Released under the MIT License.
 */
@@ -17272,764 +17272,255 @@ const VCombobox = genericComponent()({
   }
 });
 
-// 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 = 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
-  };
-  provide(VDataTableExpandedKey, data);
-  return data;
+  return weeks;
 }
-function useExpanded() {
-  const data = inject$1(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 = ref(new Set());
-  const sortByWithGroups = 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
-  };
-  provide(VDataTableGroupSymbol, data);
-  return data;
-}
-function useGroupBy() {
-  const data = inject$1(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 = 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 = computed(() => ({
-    page: page.value,
-    itemsPerPage: itemsPerPage.value,
-    sortBy: sortBy.value,
-    groupBy: groupBy.value,
-    search: search.value
-  }));
-  let oldOptions = null;
-  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 = computed(() => {
-    if (itemsPerPage.value === -1) return 0;
-    return itemsPerPage.value * (page.value - 1);
-  });
-  const stopIndex = computed(() => {
-    if (itemsPerPage.value === -1) return itemsLength.value;
-    return Math.min(itemsLength.value, startIndex.value + itemsPerPage.value);
-  });
-  const pageCount = computed(() => {
-    if (itemsPerPage.value === -1 || itemsLength.value === 0) return 1;
-    return Math.ceil(itemsLength.value / itemsPerPage.value);
-  });
-  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
-  };
-  provide(VDataTablePaginationSymbol, data);
-  return data;
-}
-function usePagination() {
-  const data = inject$1(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 = computed(() => {
-    if (itemsPerPage.value <= 0) return items.value;
-    return items.value.slice(startIndex.value, stopIndex.value);
-  });
-  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 ? [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(toRaw(item.value));else selected.delete(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(toRaw(item.value));else selected.delete(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 = computed(() => allItems.value.filter(item => item.selectable));
-  const currentPageSelectable = computed(() => currentPage.value.filter(item => item.selectable));
-  const selectStrategy = 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(toRaw(item.value)));
-  }
-  function isSomeSelected(items) {
-    return wrapInArray(items).some(item => selected.value.has(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 = 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 = computed(() => selected.value.size > 0);
-  const allSelected = 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
-  };
-  provide(VDataTableSelectionSymbol, data);
-  return data;
-}
-function useSelection() {
-  const data = inject$1(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) {
@@ -18434,178 +17925,759 @@ class VuetifyDateAdapter {
   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 = 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);
+  watch(locale.current, value => {
+    instance.locale = options.locale[value] ?? value ?? instance.locale;
+  });
+  return instance;
+}
+function useDate() {
+  const options = inject$1(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 = ref();
+    watchEffect(() => {
+      internalModel.value = structuredClone(toRaw(model.value));
+    });
+    const {
+      t
+    } = useLocale();
+    const isPristine = computed(() => {
+      return deepEqual(model.value, internalModel.value);
+    });
+    function save() {
+      model.value = internalModel.value;
+      emit('save', internalModel.value);
+    }
+    function cancel() {
+      internalModel.value = structuredClone(toRaw(model.value));
+      emit('cancel');
+    }
+    let actionsUsed = false;
+    useRender(() => {
+      const actions = createVNode(Fragment, null, [createVNode(VBtn, {
+        "disabled": isPristine.value,
+        "variant": "text",
+        "color": props.color,
+        "onClick": cancel,
+        "text": t(props.cancelText)
+      }, null), createVNode(VBtn, {
+        "disabled": isPristine.value,
+        "variant": "text",
+        "color": props.color,
+        "onClick": save,
+        "text": t(props.okText)
+      }, null)]);
+      return createVNode(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 = 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
+  };
+  provide(VDataTableExpandedKey, data);
+  return data;
+}
+function useExpanded() {
+  const data = inject$1(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 = ref(new Set());
+  const sortByWithGroups = 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
+  };
+  provide(VDataTableGroupSymbol, data);
+  return data;
+}
+function useGroupBy() {
+  const data = inject$1(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 = 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 = computed(() => ({
+    page: page.value,
+    itemsPerPage: itemsPerPage.value,
+    sortBy: sortBy.value,
+    groupBy: groupBy.value,
+    search: search.value
+  }));
+  let oldOptions = null;
+  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 = computed(() => {
+    if (itemsPerPage.value === -1) return 0;
+    return itemsPerPage.value * (page.value - 1);
+  });
+  const stopIndex = computed(() => {
+    if (itemsPerPage.value === -1) return itemsLength.value;
+    return Math.min(itemsLength.value, startIndex.value + itemsPerPage.value);
+  });
+  const pageCount = computed(() => {
+    if (itemsPerPage.value === -1 || itemsLength.value === 0) return 1;
+    return Math.ceil(itemsLength.value / itemsPerPage.value);
+  });
+  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
+  };
+  provide(VDataTablePaginationSymbol, data);
+  return data;
+}
+function usePagination() {
+  const data = inject$1(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 = computed(() => {
+    if (itemsPerPage.value <= 0) return items.value;
+    return items.value.slice(startIndex.value, stopIndex.value);
+  });
+  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 ? [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(toRaw(item.value));else selected.delete(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(toRaw(item.value));else selected.delete(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 = computed(() => allItems.value.filter(item => item.selectable));
+  const currentPageSelectable = computed(() => currentPage.value.filter(item => item.selectable));
+  const selectStrategy = 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(toRaw(item.value)));
   }
-  startOfDay(date) {
-    return startOfDay(date);
+  function isSomeSelected(items) {
+    return wrapInArray(items).some(item => selected.value.has(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 = 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 = 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);
-  watch(locale.current, value => {
-    instance.locale = options.locale[value] ?? value ?? instance.locale;
+  const someSelected = computed(() => selected.value.size > 0);
+  const allSelected = computed(() => {
+    const items = selectStrategy.value.allSelected({
+      allItems: allSelectable.value,
+      currentPage: currentPageSelectable.value
+    });
+    return !!items.length && isSelected(items);
   });
-  return instance;
-}
-function useDate() {
-  const options = inject$1(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
+  };
+  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 = inject$1(VDataTableSelectionSymbol);
+  if (!data) throw new Error('Missing selection!');
+  return data;
 }
 
 // Composables
@@ -22191,6 +22263,141 @@ const VDatePicker = genericComponent()({
   }
 });
 
+// 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(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 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 && createVNode("div", {
+        "key": "media",
+        "class": "v-empty-state__media"
+      }, [!slots.media ? createVNode(Fragment, null, [props.image ? createVNode(VImg, {
+        "key": "image",
+        "src": props.image,
+        "height": size
+      }, null) : props.icon ? createVNode(VIcon, {
+        "key": "icon",
+        "color": props.color,
+        "size": size,
+        "icon": props.icon
+      }, null) : undefined]) : createVNode(VDefaultsProvider, {
+        "key": "media-defaults",
+        "defaults": {
+          VImg: {
+            src: props.image,
+            height: size
+          },
+          VIcon: {
+            size,
+            icon: props.icon
+          }
+        }
+      }, {
+        default: () => [slots.media()]
+      })]), hasHeadline && createVNode("div", {
+        "key": "headline",
+        "class": "v-empty-state__headline"
+      }, [slots.headline?.() ?? props.headline]), hasTitle && createVNode("div", {
+        "key": "title",
+        "class": "v-empty-state__title"
+      }, [slots.title?.() ?? props.title]), hasText && createVNode("div", {
+        "key": "text",
+        "class": "v-empty-state__text",
+        "style": {
+          maxWidth: convertToUnit(props.textWidth)
+        }
+      }, [slots.text?.() ?? props.text]), slots.default && createVNode("div", {
+        "key": "content",
+        "class": "v-empty-state__content"
+      }, [slots.default()]), hasActions && createVNode("div", {
+        "key": "actions",
+        "class": "v-empty-state__actions"
+      }, [createVNode(VDefaultsProvider, {
+        "defaults": {
+          VBtn: {
+            class: 'v-empty-state__action-btn',
+            color: props.color,
+            text: props.actionText
+          }
+        }
+      }, {
+        default: () => [slots.actions?.({
+          props: {
+            onClick: onClickAction
+          }
+        }) ?? createVNode(VBtn, {
+          "onClick": onClickAction
+        }, null)]
+      })])]);
+    });
+    return {};
+  }
+});
+
 const makeVExpansionPanelTextProps = propsFactory({
   ...makeComponentProps(),
   ...makeLazyProps()
@@ -22424,6 +22631,107 @@ const VExpansionPanels = genericComponent()({
   }
 });
 
+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 = shallowRef(56);
+    const layoutItemStyles = ref();
+    const {
+      resizeRef
+    } = useResizeObserver(entries => {
+      if (!entries.length) return;
+      height.value = entries[0].target.clientHeight;
+    });
+    const hasPosition = computed(() => props.app || props.absolute);
+    const position = computed(() => {
+      if (!hasPosition.value) return false;
+      return props.location.split(' ').shift();
+    });
+    const orientation = computed(() => {
+      if (!hasPosition.value) return false;
+      return props.location.split(' ')[1] ?? 'end';
+    });
+    useToggleScope(() => props.app, () => {
+      const layout = useLayoutItem({
+        id: props.name,
+        order: computed(() => parseInt(props.order, 10)),
+        position,
+        layoutSize: computed(() => props.layout ? height.value + 24 : 0),
+        elementSize: computed(() => height.value + 24),
+        active: computed(() => props.app && model.value),
+        absolute: toRef(props, 'absolute')
+      });
+      watchEffect(() => {
+        layoutItemStyles.value = layout.layoutItemStyles.value;
+      });
+    });
+    const vFabRef = ref();
+    useRender(() => {
+      const btnProps = VBtn.filterProps(props);
+      return 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]
+      }, [createVNode("div", {
+        "class": "v-fab__container"
+      }, [createVNode(MaybeTransition, {
+        "appear": props.appear,
+        "transition": props.transition
+      }, {
+        default: () => [withDirectives(createVNode(VBtn, mergeProps({
+          "ref": resizeRef
+        }, btnProps, {
+          "active": undefined,
+          "location": undefined
+        }), slots), [[vShow, props.active]])]
+      })])]);
+    });
+    return {};
+  }
+});
+
 // Types
 
 const makeVFileInputProps = propsFactory({
@@ -25084,6 +25392,519 @@ const VSnackbar = genericComponent()({
   }
 });
 
+// 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 = computed(() => props.id || `barline-${uid}`);
+    const autoDrawDuration = computed(() => Number(props.autoDrawDuration) || 500);
+    const hasLabels = computed(() => {
+      return Boolean(props.showLabels || props.labels.length > 0 || !!slots?.label);
+    });
+    const lineWidth = computed(() => parseFloat(props.lineWidth) || 4);
+    const totalWidth = computed(() => Math.max(props.modelValue.length * lineWidth.value, Number(props.width)));
+    const boundary = computed(() => {
+      return {
+        minX: 0,
+        maxX: totalWidth.value,
+        minY: 0,
+        maxY: parseInt(props.height, 10)
+      };
+    });
+    const items = 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 = 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 = computed(() => genBars(items.value, boundary.value));
+    const offsetX = 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 createVNode("svg", {
+        "display": "block"
+      }, [createVNode("defs", null, [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) => createVNode("stop", {
+        "offset": index / Math.max(gradientData.length - 1, 1),
+        "stop-color": color || 'currentColor'
+      }, null))])]), createVNode("clipPath", {
+        "id": `${id.value}-clip`
+      }, [bars.value.map(item => 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 && createVNode(Fragment, null, [createVNode("animate", {
+        "attributeName": "y",
+        "from": item.y + item.height,
+        "to": item.y,
+        "dur": `${autoDrawDuration.value}ms`,
+        "fill": "freeze"
+      }, null), createVNode("animate", {
+        "attributeName": "height",
+        "from": "0",
+        "to": item.height,
+        "dur": `${autoDrawDuration.value}ms`,
+        "fill": "freeze"
+      }, null)])]))]), hasLabels.value && createVNode("g", {
+        "key": "labels",
+        "style": {
+          textAnchor: 'middle',
+          dominantBaseline: 'mathematical',
+          fill: 'currentColor'
+        }
+      }, [parsedLabels.value.map((item, i) => 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]))]), createVNode("g", {
+        "clip-path": `url(#${id.value}-clip)`,
+        "fill": `url(#${id.value})`
+      }, [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 = computed(() => props.id || `trendline-${uid}`);
+    const autoDrawDuration = computed(() => Number(props.autoDrawDuration) || (props.fill ? 500 : 2000));
+    const lastLength = ref(0);
+    const path = 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 = computed(() => {
+      return Boolean(props.showLabels || props.labels.length > 0 || !!slots?.label);
+    });
+    const lineWidth = computed(() => {
+      return parseFloat(props.lineWidth) || 4;
+    });
+    const totalWidth = computed(() => Number(props.width));
+    const boundary = computed(() => {
+      const padding = Number(props.padding);
+      return {
+        minX: padding,
+        maxX: totalWidth.value - padding,
+        minY: padding,
+        maxY: parseInt(props.height, 10) - padding
+      };
+    });
+    const items = computed(() => props.modelValue.map(item => getPropertyFromItem(item, props.itemValue, item)));
+    const parsedLabels = 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;
+    });
+    watch(() => props.modelValue, async () => {
+      await 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 createVNode("svg", {
+        "display": "block",
+        "stroke-width": parseFloat(props.lineWidth) ?? 4
+      }, [createVNode("defs", null, [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) => createVNode("stop", {
+        "offset": index / Math.max(gradientData.length - 1, 1),
+        "stop-color": color || 'currentColor'
+      }, null))])]), hasLabels.value && createVNode("g", {
+        "key": "labels",
+        "style": {
+          textAnchor: 'middle',
+          dominantBaseline: 'mathematical',
+          fill: 'currentColor'
+        }
+      }, [parsedLabels.value.map((item, i) => 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]))]), 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 && 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(toRef(props, 'color'));
+    const hasLabels = computed(() => {
+      return Boolean(props.showLabels || props.labels.length > 0 || !!slots?.label);
+    });
+    const totalHeight = 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 createVNode(Tag, 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 = ref();
+    const location = computed(() => {
+      const [y, x = 'center'] = props.location.split(' ');
+      return `${y} ${x}`;
+    });
+    const locationClasses = computed(() => ({
+      [`v-speed-dial__content--${location.value.replace(' ', '-')}`]: true
+    }));
+    useRender(() => {
+      const menuProps = VMenu.filterProps(props);
+      return createVNode(VMenu, 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 => createVNode(VDefaultsProvider, {
+          "defaults": {
+            VBtn: {
+              size: 'small'
+            }
+          }
+        }, {
+          default: () => [createVNode(MaybeTransition, {
+            "appear": true,
+            "group": true,
+            "transition": props.transition
+          }, {
+            default: () => [slots.default?.(slotProps)]
+          })]
+        })
+      });
+    });
+    return {};
+  }
+});
+
 // Types
 
 const makeVStepperActionsProps = propsFactory({
@@ -26662,6 +27483,7 @@ var components = /*#__PURE__*/Object.freeze({
   VColorPicker: VColorPicker,
   VCombobox: VCombobox,
   VComponentIcon: VComponentIcon,
+  VConfirmEdit: VConfirmEdit,
   VContainer: VContainer,
   VCounter: VCounter,
   VDataIterator: VDataIterator,
@@ -26684,12 +27506,14 @@ var components = /*#__PURE__*/Object.freeze({
   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,
@@ -26756,6 +27580,8 @@ var components = /*#__PURE__*/Object.freeze({
   VSlider: VSlider,
   VSnackbar: VSnackbar,
   VSpacer: VSpacer,
+  VSparkline: VSparkline,
+  VSpeedDial: VSpeedDial,
   VStepper: VStepper,
   VStepperActions: VStepperActions,
   VStepperHeader: VStepperHeader,
@@ -26932,9 +27758,7 @@ function mountComponent(component, props) {
     // 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 = h(component, mergeProps(_props, value), {
-      default: () => children
-    });
+    const node = h(component, mergeProps(_props, value), children);
     node.appContext = Object.assign(Object.create(null), binding.instance.$.appContext, {
       provides
     });
@@ -27093,7 +27917,7 @@ function createVuetify$1() {
     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
@@ -27118,7 +27942,7 @@ const createVuetify = function () {
     ...options
   });
 };
-const version = "3.6.0";
+const version = "3.6.1";
 createVuetify.version = version;
 
 export { index as blueprints, components, createVuetify, directives, useDate, useDefaults, useDisplay, useGoTo, useLayout, useLocale, useRtl, useTheme, version };