Tracking de l'application VApp (IHM du jeu)

VApp/node_modules/vuetify/lib/components/VPagination/VPagination.css

@@ -0,0 +1,9 @@
+.v-pagination__list {
+  display: inline-flex;
+  list-style-type: none;
+  justify-content: center;
+  width: 100%;
+}
+.v-pagination__item, .v-pagination__first, .v-pagination__prev, .v-pagination__next, .v-pagination__last {
+  margin: 0.3rem;
+}

VApp/node_modules/vuetify/lib/components/VPagination/VPagination.mjs

@@ -0,0 +1,340 @@
+import { createVNode as _createVNode, mergeProps as _mergeProps } from "vue";
+// Styles
+import "./VPagination.css";
+
+// Components
+import { VBtn } from "../VBtn/index.mjs"; // Composables
+import { useDisplay } from "../../composables/index.mjs";
+import { makeBorderProps } from "../../composables/border.mjs";
+import { makeComponentProps } from "../../composables/component.mjs";
+import { provideDefaults } from "../../composables/defaults.mjs";
+import { makeDensityProps } from "../../composables/density.mjs";
+import { makeElevationProps } from "../../composables/elevation.mjs";
+import { IconValue } from "../../composables/icons.mjs";
+import { useLocale, useRtl } from "../../composables/locale.mjs";
+import { useProxiedModel } from "../../composables/proxiedModel.mjs";
+import { useRefs } from "../../composables/refs.mjs";
+import { useResizeObserver } from "../../composables/resizeObserver.mjs";
+import { makeRoundedProps } from "../../composables/rounded.mjs";
+import { makeSizeProps } from "../../composables/size.mjs";
+import { makeTagProps } from "../../composables/tag.mjs";
+import { makeThemeProps, provideTheme } from "../../composables/theme.mjs";
+import { makeVariantProps } from "../../composables/variant.mjs"; // Utilities
+import { computed, nextTick, shallowRef, toRef } from 'vue';
+import { createRange, genericComponent, keyValues, propsFactory, useRender } from "../../util/index.mjs"; // Types
+export const makeVPaginationProps = propsFactory({
+  activeColor: String,
+  start: {
+    type: [Number, String],
+    default: 1
+  },
+  modelValue: {
+    type: Number,
+    default: props => props.start
+  },
+  disabled: Boolean,
+  length: {
+    type: [Number, String],
+    default: 1,
+    validator: val => val % 1 === 0
+  },
+  totalVisible: [Number, String],
+  firstIcon: {
+    type: IconValue,
+    default: '$first'
+  },
+  prevIcon: {
+    type: IconValue,
+    default: '$prev'
+  },
+  nextIcon: {
+    type: IconValue,
+    default: '$next'
+  },
+  lastIcon: {
+    type: IconValue,
+    default: '$last'
+  },
+  ariaLabel: {
+    type: String,
+    default: '$vuetify.pagination.ariaLabel.root'
+  },
+  pageAriaLabel: {
+    type: String,
+    default: '$vuetify.pagination.ariaLabel.page'
+  },
+  currentPageAriaLabel: {
+    type: String,
+    default: '$vuetify.pagination.ariaLabel.currentPage'
+  },
+  firstAriaLabel: {
+    type: String,
+    default: '$vuetify.pagination.ariaLabel.first'
+  },
+  previousAriaLabel: {
+    type: String,
+    default: '$vuetify.pagination.ariaLabel.previous'
+  },
+  nextAriaLabel: {
+    type: String,
+    default: '$vuetify.pagination.ariaLabel.next'
+  },
+  lastAriaLabel: {
+    type: String,
+    default: '$vuetify.pagination.ariaLabel.last'
+  },
+  ellipsis: {
+    type: String,
+    default: '...'
+  },
+  showFirstLastPage: Boolean,
+  ...makeBorderProps(),
+  ...makeComponentProps(),
+  ...makeDensityProps(),
+  ...makeElevationProps(),
+  ...makeRoundedProps(),
+  ...makeSizeProps(),
+  ...makeTagProps({
+    tag: 'nav'
+  }),
+  ...makeThemeProps(),
+  ...makeVariantProps({
+    variant: 'text'
+  })
+}, 'VPagination');
+export const VPagination = genericComponent()({
+  name: 'VPagination',
+  props: makeVPaginationProps(),
+  emits: {
+    'update:modelValue': value => true,
+    first: value => true,
+    prev: value => true,
+    next: value => true,
+    last: value => true
+  },
+  setup(props, _ref) {
+    let {
+      slots,
+      emit
+    } = _ref;
+    const page = useProxiedModel(props, 'modelValue');
+    const {
+      t,
+      n
+    } = useLocale();
+    const {
+      isRtl
+    } = useRtl();
+    const {
+      themeClasses
+    } = provideTheme(props);
+    const {
+      width
+    } = useDisplay();
+    const maxButtons = shallowRef(-1);
+    provideDefaults(undefined, {
+      scoped: true
+    });
+    const {
+      resizeRef
+    } = useResizeObserver(entries => {
+      if (!entries.length) return;
+      const {
+        target,
+        contentRect
+      } = entries[0];
+      const firstItem = target.querySelector('.v-pagination__list > *');
+      if (!firstItem) return;
+      const totalWidth = contentRect.width;
+      const itemWidth = firstItem.offsetWidth + parseFloat(getComputedStyle(firstItem).marginRight) * 2;
+      maxButtons.value = getMax(totalWidth, itemWidth);
+    });
+    const length = computed(() => parseInt(props.length, 10));
+    const start = computed(() => parseInt(props.start, 10));
+    const totalVisible = computed(() => {
+      if (props.totalVisible != null) return parseInt(props.totalVisible, 10);else if (maxButtons.value >= 0) return maxButtons.value;
+      return getMax(width.value, 58);
+    });
+    function getMax(totalWidth, itemWidth) {
+      const minButtons = props.showFirstLastPage ? 5 : 3;
+      return Math.max(0, Math.floor(
+      // Round to two decimal places to avoid floating point errors
+      +((totalWidth - itemWidth * minButtons) / itemWidth).toFixed(2)));
+    }
+    const range = computed(() => {
+      if (length.value <= 0 || isNaN(length.value) || length.value > Number.MAX_SAFE_INTEGER) return [];
+      if (totalVisible.value <= 0) return [];else if (totalVisible.value === 1) return [page.value];
+      if (length.value <= totalVisible.value) {
+        return createRange(length.value, start.value);
+      }
+      const even = totalVisible.value % 2 === 0;
+      const middle = even ? totalVisible.value / 2 : Math.floor(totalVisible.value / 2);
+      const left = even ? middle : middle + 1;
+      const right = length.value - middle;
+      if (left - page.value >= 0) {
+        return [...createRange(Math.max(1, totalVisible.value - 1), start.value), props.ellipsis, length.value];
+      } else if (page.value - right >= (even ? 1 : 0)) {
+        const rangeLength = totalVisible.value - 1;
+        const rangeStart = length.value - rangeLength + start.value;
+        return [start.value, props.ellipsis, ...createRange(rangeLength, rangeStart)];
+      } else {
+        const rangeLength = Math.max(1, totalVisible.value - 3);
+        const rangeStart = rangeLength === 1 ? page.value : page.value - Math.ceil(rangeLength / 2) + start.value;
+        return [start.value, props.ellipsis, ...createRange(rangeLength, rangeStart), props.ellipsis, length.value];
+      }
+    });
+
+    // TODO: 'first' | 'prev' | 'next' | 'last' does not work here?
+    function setValue(e, value, event) {
+      e.preventDefault();
+      page.value = value;
+      event && emit(event, value);
+    }
+    const {
+      refs,
+      updateRef
+    } = useRefs();
+    provideDefaults({
+      VPaginationBtn: {
+        color: toRef(props, 'color'),
+        border: toRef(props, 'border'),
+        density: toRef(props, 'density'),
+        size: toRef(props, 'size'),
+        variant: toRef(props, 'variant'),
+        rounded: toRef(props, 'rounded'),
+        elevation: toRef(props, 'elevation')
+      }
+    });
+    const items = computed(() => {
+      return range.value.map((item, index) => {
+        const ref = e => updateRef(e, index);
+        if (typeof item === 'string') {
+          return {
+            isActive: false,
+            key: `ellipsis-${index}`,
+            page: item,
+            props: {
+              ref,
+              ellipsis: true,
+              icon: true,
+              disabled: true
+            }
+          };
+        } else {
+          const isActive = item === page.value;
+          return {
+            isActive,
+            key: item,
+            page: n(item),
+            props: {
+              ref,
+              ellipsis: false,
+              icon: true,
+              disabled: !!props.disabled || +props.length < 2,
+              color: isActive ? props.activeColor : props.color,
+              'aria-current': isActive,
+              'aria-label': t(isActive ? props.currentPageAriaLabel : props.pageAriaLabel, item),
+              onClick: e => setValue(e, item)
+            }
+          };
+        }
+      });
+    });
+    const controls = computed(() => {
+      const prevDisabled = !!props.disabled || page.value <= start.value;
+      const nextDisabled = !!props.disabled || page.value >= start.value + length.value - 1;
+      return {
+        first: props.showFirstLastPage ? {
+          icon: isRtl.value ? props.lastIcon : props.firstIcon,
+          onClick: e => setValue(e, start.value, 'first'),
+          disabled: prevDisabled,
+          'aria-label': t(props.firstAriaLabel),
+          'aria-disabled': prevDisabled
+        } : undefined,
+        prev: {
+          icon: isRtl.value ? props.nextIcon : props.prevIcon,
+          onClick: e => setValue(e, page.value - 1, 'prev'),
+          disabled: prevDisabled,
+          'aria-label': t(props.previousAriaLabel),
+          'aria-disabled': prevDisabled
+        },
+        next: {
+          icon: isRtl.value ? props.prevIcon : props.nextIcon,
+          onClick: e => setValue(e, page.value + 1, 'next'),
+          disabled: nextDisabled,
+          'aria-label': t(props.nextAriaLabel),
+          'aria-disabled': nextDisabled
+        },
+        last: props.showFirstLastPage ? {
+          icon: isRtl.value ? props.firstIcon : props.lastIcon,
+          onClick: e => setValue(e, start.value + length.value - 1, 'last'),
+          disabled: nextDisabled,
+          'aria-label': t(props.lastAriaLabel),
+          'aria-disabled': nextDisabled
+        } : undefined
+      };
+    });
+    function updateFocus() {
+      const currentIndex = page.value - start.value;
+      refs.value[currentIndex]?.$el.focus();
+    }
+    function onKeydown(e) {
+      if (e.key === keyValues.left && !props.disabled && page.value > +props.start) {
+        page.value = page.value - 1;
+        nextTick(updateFocus);
+      } else if (e.key === keyValues.right && !props.disabled && page.value < start.value + length.value - 1) {
+        page.value = page.value + 1;
+        nextTick(updateFocus);
+      }
+    }
+    useRender(() => _createVNode(props.tag, {
+      "ref": resizeRef,
+      "class": ['v-pagination', themeClasses.value, props.class],
+      "style": props.style,
+      "role": "navigation",
+      "aria-label": t(props.ariaLabel),
+      "onKeydown": onKeydown,
+      "data-test": "v-pagination-root"
+    }, {
+      default: () => [_createVNode("ul", {
+        "class": "v-pagination__list"
+      }, [props.showFirstLastPage && _createVNode("li", {
+        "key": "first",
+        "class": "v-pagination__first",
+        "data-test": "v-pagination-first"
+      }, [slots.first ? slots.first(controls.value.first) : _createVNode(VBtn, _mergeProps({
+        "_as": "VPaginationBtn"
+      }, controls.value.first), null)]), _createVNode("li", {
+        "key": "prev",
+        "class": "v-pagination__prev",
+        "data-test": "v-pagination-prev"
+      }, [slots.prev ? slots.prev(controls.value.prev) : _createVNode(VBtn, _mergeProps({
+        "_as": "VPaginationBtn"
+      }, controls.value.prev), null)]), items.value.map((item, index) => _createVNode("li", {
+        "key": item.key,
+        "class": ['v-pagination__item', {
+          'v-pagination__item--is-active': item.isActive
+        }],
+        "data-test": "v-pagination-item"
+      }, [slots.item ? slots.item(item) : _createVNode(VBtn, _mergeProps({
+        "_as": "VPaginationBtn"
+      }, item.props), {
+        default: () => [item.page]
+      })])), _createVNode("li", {
+        "key": "next",
+        "class": "v-pagination__next",
+        "data-test": "v-pagination-next"
+      }, [slots.next ? slots.next(controls.value.next) : _createVNode(VBtn, _mergeProps({
+        "_as": "VPaginationBtn"
+      }, controls.value.next), null)]), props.showFirstLastPage && _createVNode("li", {
+        "key": "last",
+        "class": "v-pagination__last",
+        "data-test": "v-pagination-last"
+      }, [slots.last ? slots.last(controls.value.last) : _createVNode(VBtn, _mergeProps({
+        "_as": "VPaginationBtn"
+      }, controls.value.last), null)])])]
+    }));
+    return {};
+  }
+});
+//# sourceMappingURL=VPagination.mjs.map

VApp/node_modules/vuetify/lib/components/VPagination/VPagination.sass

@@ -0,0 +1,15 @@
+@use './variables' as *
+
+.v-pagination
+  &__list
+    display: inline-flex
+    list-style-type: none
+    justify-content: center
+    width: 100%
+
+  &__item,
+  &__first,
+  &__prev,
+  &__next,
+  &__last
+    margin: $pagination-item-margin

VApp/node_modules/vuetify/lib/components/VPagination/_variables.scss

@@ -0,0 +1,2 @@
+// Defaults
+$pagination-item-margin: .3rem !default;

VApp/node_modules/vuetify/lib/components/VPagination/index.d.mts

@@ -0,0 +1,605 @@
+import * as vue from 'vue';
+import { ComponentPropsOptions, ExtractPropTypes, JSXComponent, PropType } from 'vue';
+
+interface FilterPropsOptions<PropsOptions extends Readonly<ComponentPropsOptions>, Props = ExtractPropTypes<PropsOptions>> {
+    filterProps<T extends Partial<Props>, U extends Exclude<keyof Props, Exclude<keyof Props, keyof T>>>(props: T): Partial<Pick<T, U>>;
+}
+
+type Density = null | 'default' | 'comfortable' | 'compact';
+
+type IconValue = string | (string | [path: string, opacity: number])[] | JSXComponent;
+declare const IconValue: PropType<IconValue>;
+
+type ItemSlot = {
+    isActive: boolean;
+    key: string | number;
+    page: string;
+    props: Record<string, any>;
+};
+type ControlSlot = {
+    icon: IconValue;
+    onClick: (e: Event) => void;
+    disabled: boolean;
+    'aria-label': string;
+    'aria-disabled': boolean;
+};
+declare const VPagination: {
+    new (...args: any[]): vue.CreateComponentPublicInstance<{
+        length: string | number;
+        variant: NonNullable<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        start: string | number;
+        style: vue.StyleValue;
+        ariaLabel: string;
+        disabled: boolean;
+        size: string | number;
+        tag: string;
+        ellipsis: string;
+        density: Density;
+        modelValue: number;
+        nextIcon: IconValue;
+        prevIcon: IconValue;
+        firstIcon: IconValue;
+        lastIcon: IconValue;
+        pageAriaLabel: string;
+        currentPageAriaLabel: string;
+        firstAriaLabel: string;
+        previousAriaLabel: string;
+        nextAriaLabel: string;
+        lastAriaLabel: string;
+        showFirstLastPage: boolean;
+    } & {
+        border?: string | number | boolean | undefined;
+        color?: string | undefined;
+        class?: any;
+        elevation?: string | number | undefined;
+        theme?: string | undefined;
+        rounded?: string | number | boolean | undefined;
+        activeColor?: string | undefined;
+        totalVisible?: string | number | undefined;
+    } & {
+        $children?: {} | vue.VNodeChild | {
+            item?: ((arg: ItemSlot) => vue.VNodeChild) | undefined;
+            first?: ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+            prev?: ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+            next?: ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+            last?: ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+        };
+        'v-slots'?: {
+            item?: false | ((arg: ItemSlot) => vue.VNodeChild) | undefined;
+            first?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+            prev?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+            next?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+            last?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:item"?: false | ((arg: ItemSlot) => vue.VNodeChild) | undefined;
+        "v-slot:first"?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+        "v-slot:prev"?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+        "v-slot:next"?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+        "v-slot:last"?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+    } & {
+        "onUpdate:modelValue"?: ((value: number) => any) | undefined;
+        onNext?: ((value: number) => any) | undefined;
+        onPrev?: ((value: number) => any) | undefined;
+        onFirst?: ((value: number) => any) | undefined;
+        onLast?: ((value: number) => any) | undefined;
+    }, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+        'update:modelValue': (value: number) => true;
+        first: (value: number) => true;
+        prev: (value: number) => true;
+        next: (value: number) => true;
+        last: (value: number) => true;
+    }, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
+        length: string | number;
+        variant: NonNullable<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        start: string | number;
+        style: vue.StyleValue;
+        ariaLabel: string;
+        disabled: boolean;
+        size: string | number;
+        tag: string;
+        ellipsis: string;
+        density: Density;
+        modelValue: number;
+        nextIcon: IconValue;
+        prevIcon: IconValue;
+        firstIcon: IconValue;
+        lastIcon: IconValue;
+        pageAriaLabel: string;
+        currentPageAriaLabel: string;
+        firstAriaLabel: string;
+        previousAriaLabel: string;
+        nextAriaLabel: string;
+        lastAriaLabel: string;
+        showFirstLastPage: boolean;
+    } & {
+        border?: string | number | boolean | undefined;
+        color?: string | undefined;
+        class?: any;
+        elevation?: string | number | undefined;
+        theme?: string | undefined;
+        rounded?: string | number | boolean | undefined;
+        activeColor?: string | undefined;
+        totalVisible?: string | number | undefined;
+    } & {
+        $children?: {} | vue.VNodeChild | {
+            item?: ((arg: ItemSlot) => vue.VNodeChild) | undefined;
+            first?: ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+            prev?: ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+            next?: ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+            last?: ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+        };
+        'v-slots'?: {
+            item?: false | ((arg: ItemSlot) => vue.VNodeChild) | undefined;
+            first?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+            prev?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+            next?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+            last?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:item"?: false | ((arg: ItemSlot) => vue.VNodeChild) | undefined;
+        "v-slot:first"?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+        "v-slot:prev"?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+        "v-slot:next"?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+        "v-slot:last"?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+    } & {
+        "onUpdate:modelValue"?: ((value: number) => any) | undefined;
+        onNext?: ((value: number) => any) | undefined;
+        onPrev?: ((value: number) => any) | undefined;
+        onFirst?: ((value: number) => any) | undefined;
+        onLast?: ((value: number) => any) | undefined;
+    }, {
+        length: string | number;
+        variant: NonNullable<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        start: string | number;
+        style: vue.StyleValue;
+        ariaLabel: string;
+        disabled: boolean;
+        size: string | number;
+        tag: string;
+        ellipsis: string;
+        rounded: string | number | boolean;
+        density: Density;
+        modelValue: number;
+        nextIcon: IconValue;
+        prevIcon: IconValue;
+        firstIcon: IconValue;
+        lastIcon: IconValue;
+        pageAriaLabel: string;
+        currentPageAriaLabel: string;
+        firstAriaLabel: string;
+        previousAriaLabel: string;
+        nextAriaLabel: string;
+        lastAriaLabel: string;
+        showFirstLastPage: boolean;
+    }, true, {}, vue.SlotsType<Partial<{
+        item: (arg: ItemSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        first: (arg: ControlSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        prev: (arg: ControlSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        next: (arg: ControlSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        last: (arg: ControlSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+    }>>, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, {
+        length: string | number;
+        variant: NonNullable<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        start: string | number;
+        style: vue.StyleValue;
+        ariaLabel: string;
+        disabled: boolean;
+        size: string | number;
+        tag: string;
+        ellipsis: string;
+        density: Density;
+        modelValue: number;
+        nextIcon: IconValue;
+        prevIcon: IconValue;
+        firstIcon: IconValue;
+        lastIcon: IconValue;
+        pageAriaLabel: string;
+        currentPageAriaLabel: string;
+        firstAriaLabel: string;
+        previousAriaLabel: string;
+        nextAriaLabel: string;
+        lastAriaLabel: string;
+        showFirstLastPage: boolean;
+    } & {
+        border?: string | number | boolean | undefined;
+        color?: string | undefined;
+        class?: any;
+        elevation?: string | number | undefined;
+        theme?: string | undefined;
+        rounded?: string | number | boolean | undefined;
+        activeColor?: string | undefined;
+        totalVisible?: string | number | undefined;
+    } & {
+        $children?: {} | vue.VNodeChild | {
+            item?: ((arg: ItemSlot) => vue.VNodeChild) | undefined;
+            first?: ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+            prev?: ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+            next?: ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+            last?: ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+        };
+        'v-slots'?: {
+            item?: false | ((arg: ItemSlot) => vue.VNodeChild) | undefined;
+            first?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+            prev?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+            next?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+            last?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:item"?: false | ((arg: ItemSlot) => vue.VNodeChild) | undefined;
+        "v-slot:first"?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+        "v-slot:prev"?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+        "v-slot:next"?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+        "v-slot:last"?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+    } & {
+        "onUpdate:modelValue"?: ((value: number) => any) | undefined;
+        onNext?: ((value: number) => any) | undefined;
+        onPrev?: ((value: number) => any) | undefined;
+        onFirst?: ((value: number) => any) | undefined;
+        onLast?: ((value: number) => any) | undefined;
+    }, {}, {}, {}, {}, {
+        length: string | number;
+        variant: NonNullable<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        start: string | number;
+        style: vue.StyleValue;
+        ariaLabel: string;
+        disabled: boolean;
+        size: string | number;
+        tag: string;
+        ellipsis: string;
+        rounded: string | number | boolean;
+        density: Density;
+        modelValue: number;
+        nextIcon: IconValue;
+        prevIcon: IconValue;
+        firstIcon: IconValue;
+        lastIcon: IconValue;
+        pageAriaLabel: string;
+        currentPageAriaLabel: string;
+        firstAriaLabel: string;
+        previousAriaLabel: string;
+        nextAriaLabel: string;
+        lastAriaLabel: string;
+        showFirstLastPage: boolean;
+    }>;
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+} & vue.ComponentOptionsBase<{
+    length: string | number;
+    variant: NonNullable<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+    start: string | number;
+    style: vue.StyleValue;
+    ariaLabel: string;
+    disabled: boolean;
+    size: string | number;
+    tag: string;
+    ellipsis: string;
+    density: Density;
+    modelValue: number;
+    nextIcon: IconValue;
+    prevIcon: IconValue;
+    firstIcon: IconValue;
+    lastIcon: IconValue;
+    pageAriaLabel: string;
+    currentPageAriaLabel: string;
+    firstAriaLabel: string;
+    previousAriaLabel: string;
+    nextAriaLabel: string;
+    lastAriaLabel: string;
+    showFirstLastPage: boolean;
+} & {
+    border?: string | number | boolean | undefined;
+    color?: string | undefined;
+    class?: any;
+    elevation?: string | number | undefined;
+    theme?: string | undefined;
+    rounded?: string | number | boolean | undefined;
+    activeColor?: string | undefined;
+    totalVisible?: string | number | undefined;
+} & {
+    $children?: {} | vue.VNodeChild | {
+        item?: ((arg: ItemSlot) => vue.VNodeChild) | undefined;
+        first?: ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+        prev?: ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+        next?: ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+        last?: ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+    };
+    'v-slots'?: {
+        item?: false | ((arg: ItemSlot) => vue.VNodeChild) | undefined;
+        first?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+        prev?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+        next?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+        last?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+    } | undefined;
+} & {
+    "v-slot:item"?: false | ((arg: ItemSlot) => vue.VNodeChild) | undefined;
+    "v-slot:first"?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+    "v-slot:prev"?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+    "v-slot:next"?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+    "v-slot:last"?: false | ((arg: ControlSlot) => vue.VNodeChild) | undefined;
+} & {
+    "onUpdate:modelValue"?: ((value: number) => any) | undefined;
+    onNext?: ((value: number) => any) | undefined;
+    onPrev?: ((value: number) => any) | undefined;
+    onFirst?: ((value: number) => any) | undefined;
+    onLast?: ((value: number) => any) | undefined;
+}, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    'update:modelValue': (value: number) => true;
+    first: (value: number) => true;
+    prev: (value: number) => true;
+    next: (value: number) => true;
+    last: (value: number) => true;
+}, string, {
+    length: string | number;
+    variant: NonNullable<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+    start: string | number;
+    style: vue.StyleValue;
+    ariaLabel: string;
+    disabled: boolean;
+    size: string | number;
+    tag: string;
+    ellipsis: string;
+    rounded: string | number | boolean;
+    density: Density;
+    modelValue: number;
+    nextIcon: IconValue;
+    prevIcon: IconValue;
+    firstIcon: IconValue;
+    lastIcon: IconValue;
+    pageAriaLabel: string;
+    currentPageAriaLabel: string;
+    firstAriaLabel: string;
+    previousAriaLabel: string;
+    nextAriaLabel: string;
+    lastAriaLabel: string;
+    showFirstLastPage: boolean;
+}, {}, string, vue.SlotsType<Partial<{
+    item: (arg: ItemSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    first: (arg: ControlSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    prev: (arg: ControlSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    next: (arg: ControlSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    last: (arg: ControlSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+}>>> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+    color: StringConstructor;
+    variant: Omit<{
+        type: vue.PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        default: string;
+        validator: (v: any) => boolean;
+    }, "type" | "default"> & {
+        type: vue.PropType<NonNullable<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">>;
+        default: NonNullable<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+    };
+    theme: StringConstructor;
+    tag: Omit<{
+        type: StringConstructor;
+        default: string;
+    }, "type" | "default"> & {
+        type: vue.PropType<string>;
+        default: string;
+    };
+    size: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: string;
+    };
+    rounded: {
+        type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    elevation: {
+        type: (StringConstructor | NumberConstructor)[];
+        validator(v: any): boolean;
+    };
+    density: {
+        type: vue.PropType<Density>;
+        default: string;
+        validator: (v: any) => boolean;
+    };
+    class: vue.PropType<any>;
+    style: {
+        type: vue.PropType<vue.StyleValue>;
+        default: null;
+    };
+    border: (StringConstructor | BooleanConstructor | NumberConstructor)[];
+    activeColor: StringConstructor;
+    start: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    modelValue: {
+        type: NumberConstructor;
+        default: (props: any) => number;
+    };
+    disabled: BooleanConstructor;
+    length: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+        validator: (val: number) => boolean;
+    };
+    totalVisible: (StringConstructor | NumberConstructor)[];
+    firstIcon: {
+        type: vue.PropType<IconValue>;
+        default: string;
+    };
+    prevIcon: {
+        type: vue.PropType<IconValue>;
+        default: string;
+    };
+    nextIcon: {
+        type: vue.PropType<IconValue>;
+        default: string;
+    };
+    lastIcon: {
+        type: vue.PropType<IconValue>;
+        default: string;
+    };
+    ariaLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    pageAriaLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    currentPageAriaLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    firstAriaLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    previousAriaLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    nextAriaLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    lastAriaLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    ellipsis: {
+        type: StringConstructor;
+        default: string;
+    };
+    showFirstLastPage: BooleanConstructor;
+}, vue.ExtractPropTypes<{
+    color: StringConstructor;
+    variant: Omit<{
+        type: vue.PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        default: string;
+        validator: (v: any) => boolean;
+    }, "type" | "default"> & {
+        type: vue.PropType<NonNullable<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">>;
+        default: NonNullable<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+    };
+    theme: StringConstructor;
+    tag: Omit<{
+        type: StringConstructor;
+        default: string;
+    }, "type" | "default"> & {
+        type: vue.PropType<string>;
+        default: string;
+    };
+    size: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: string;
+    };
+    rounded: {
+        type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    elevation: {
+        type: (StringConstructor | NumberConstructor)[];
+        validator(v: any): boolean;
+    };
+    density: {
+        type: vue.PropType<Density>;
+        default: string;
+        validator: (v: any) => boolean;
+    };
+    class: vue.PropType<any>;
+    style: {
+        type: vue.PropType<vue.StyleValue>;
+        default: null;
+    };
+    border: (StringConstructor | BooleanConstructor | NumberConstructor)[];
+    activeColor: StringConstructor;
+    start: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    modelValue: {
+        type: NumberConstructor;
+        default: (props: any) => number;
+    };
+    disabled: BooleanConstructor;
+    length: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+        validator: (val: number) => boolean;
+    };
+    totalVisible: (StringConstructor | NumberConstructor)[];
+    firstIcon: {
+        type: vue.PropType<IconValue>;
+        default: string;
+    };
+    prevIcon: {
+        type: vue.PropType<IconValue>;
+        default: string;
+    };
+    nextIcon: {
+        type: vue.PropType<IconValue>;
+        default: string;
+    };
+    lastIcon: {
+        type: vue.PropType<IconValue>;
+        default: string;
+    };
+    ariaLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    pageAriaLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    currentPageAriaLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    firstAriaLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    previousAriaLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    nextAriaLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    lastAriaLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    ellipsis: {
+        type: StringConstructor;
+        default: string;
+    };
+    showFirstLastPage: BooleanConstructor;
+}>>;
+type VPagination = InstanceType<typeof VPagination>;
+
+export { VPagination };

VApp/node_modules/vuetify/lib/components/VPagination/index.mjs

@@ -0,0 +1,2 @@
+export { VPagination } from "./VPagination.mjs";
+//# sourceMappingURL=index.mjs.map

VApp/node_modules/vuetify/lib/components/VPagination/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["VPagination"],"sources":["../../../src/components/VPagination/index.ts"],"sourcesContent":["export { VPagination } from './VPagination'\n"],"mappings":"SAASA,WAAW"}