Tracking de l'application VApp (IHM du jeu)

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

@@ -0,0 +1,37 @@
+.v-img {
+  --v-theme-overlay-multiplier: 3;
+  z-index: 0;
+}
+.v-img--booting .v-responsive__sizer {
+  transition: none;
+}
+.v-img--rounded {
+  border-radius: 4px;
+}
+
+.v-img__img,
+.v-img__picture,
+.v-img__gradient,
+.v-img__placeholder,
+.v-img__error {
+  z-index: -1;
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+}
+
+.v-img__img--preload {
+  filter: blur(4px);
+}
+.v-img__img--contain {
+  object-fit: contain;
+}
+.v-img__img--cover {
+  object-fit: cover;
+}
+
+.v-img__gradient {
+  background-repeat: no-repeat;
+}

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

@@ -0,0 +1,300 @@
+import { withDirectives as _withDirectives, mergeProps as _mergeProps, resolveDirective as _resolveDirective, Fragment as _Fragment, createVNode as _createVNode } from "vue";
+// Styles
+import "./VImg.css";
+
+// Components
+import { makeVResponsiveProps, VResponsive } from "../VResponsive/VResponsive.mjs"; // Composables
+import { useBackgroundColor } from "../../composables/color.mjs";
+import { makeComponentProps } from "../../composables/component.mjs";
+import { makeRoundedProps, useRounded } from "../../composables/rounded.mjs";
+import { makeTransitionProps, MaybeTransition } from "../../composables/transition.mjs"; // Directives
+import intersect from "../../directives/intersect/index.mjs"; // Utilities
+import { computed, nextTick, onBeforeMount, onBeforeUnmount, ref, shallowRef, toRef, vShow, watch, withDirectives } from 'vue';
+import { convertToUnit, genericComponent, getCurrentInstance, propsFactory, SUPPORTS_INTERSECTION, useRender } from "../../util/index.mjs"; // Types
+// not intended for public use, this is passed in by vuetify-loader
+export const makeVImgProps = propsFactory({
+  alt: String,
+  cover: Boolean,
+  color: String,
+  draggable: {
+    type: [Boolean, String],
+    default: undefined
+  },
+  eager: Boolean,
+  gradient: String,
+  lazySrc: String,
+  options: {
+    type: Object,
+    // For more information on types, navigate to:
+    // https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API
+    default: () => ({
+      root: undefined,
+      rootMargin: undefined,
+      threshold: undefined
+    })
+  },
+  sizes: String,
+  src: {
+    type: [String, Object],
+    default: ''
+  },
+  crossorigin: String,
+  referrerpolicy: String,
+  srcset: String,
+  position: String,
+  ...makeVResponsiveProps(),
+  ...makeComponentProps(),
+  ...makeRoundedProps(),
+  ...makeTransitionProps()
+}, 'VImg');
+export const VImg = genericComponent()({
+  name: 'VImg',
+  directives: {
+    intersect
+  },
+  props: makeVImgProps(),
+  emits: {
+    loadstart: value => true,
+    load: value => true,
+    error: value => true
+  },
+  setup(props, _ref) {
+    let {
+      emit,
+      slots
+    } = _ref;
+    const {
+      backgroundColorClasses,
+      backgroundColorStyles
+    } = useBackgroundColor(toRef(props, 'color'));
+    const {
+      roundedClasses
+    } = useRounded(props);
+    const vm = getCurrentInstance('VImg');
+    const currentSrc = shallowRef(''); // Set from srcset
+    const image = ref();
+    const state = shallowRef(props.eager ? 'loading' : 'idle');
+    const naturalWidth = shallowRef();
+    const naturalHeight = shallowRef();
+    const normalisedSrc = computed(() => {
+      return props.src && typeof props.src === 'object' ? {
+        src: props.src.src,
+        srcset: props.srcset || props.src.srcset,
+        lazySrc: props.lazySrc || props.src.lazySrc,
+        aspect: Number(props.aspectRatio || props.src.aspect || 0)
+      } : {
+        src: props.src,
+        srcset: props.srcset,
+        lazySrc: props.lazySrc,
+        aspect: Number(props.aspectRatio || 0)
+      };
+    });
+    const aspectRatio = computed(() => {
+      return normalisedSrc.value.aspect || naturalWidth.value / naturalHeight.value || 0;
+    });
+    watch(() => props.src, () => {
+      init(state.value !== 'idle');
+    });
+    watch(aspectRatio, (val, oldVal) => {
+      if (!val && oldVal && image.value) {
+        pollForSize(image.value);
+      }
+    });
+
+    // TODO: getSrc when window width changes
+
+    onBeforeMount(() => init());
+    function init(isIntersecting) {
+      if (props.eager && isIntersecting) return;
+      if (SUPPORTS_INTERSECTION && !isIntersecting && !props.eager) return;
+      state.value = 'loading';
+      if (normalisedSrc.value.lazySrc) {
+        const lazyImg = new Image();
+        lazyImg.src = normalisedSrc.value.lazySrc;
+        pollForSize(lazyImg, null);
+      }
+      if (!normalisedSrc.value.src) return;
+      nextTick(() => {
+        emit('loadstart', image.value?.currentSrc || normalisedSrc.value.src);
+        setTimeout(() => {
+          if (vm.isUnmounted) return;
+          if (image.value?.complete) {
+            if (!image.value.naturalWidth) {
+              onError();
+            }
+            if (state.value === 'error') return;
+            if (!aspectRatio.value) pollForSize(image.value, null);
+            if (state.value === 'loading') onLoad();
+          } else {
+            if (!aspectRatio.value) pollForSize(image.value);
+            getSrc();
+          }
+        });
+      });
+    }
+    function onLoad() {
+      if (vm.isUnmounted) return;
+      getSrc();
+      pollForSize(image.value);
+      state.value = 'loaded';
+      emit('load', image.value?.currentSrc || normalisedSrc.value.src);
+    }
+    function onError() {
+      if (vm.isUnmounted) return;
+      state.value = 'error';
+      emit('error', image.value?.currentSrc || normalisedSrc.value.src);
+    }
+    function getSrc() {
+      const img = image.value;
+      if (img) currentSrc.value = img.currentSrc || img.src;
+    }
+    let timer = -1;
+    onBeforeUnmount(() => {
+      clearTimeout(timer);
+    });
+    function pollForSize(img) {
+      let timeout = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 100;
+      const poll = () => {
+        clearTimeout(timer);
+        if (vm.isUnmounted) return;
+        const {
+          naturalHeight: imgHeight,
+          naturalWidth: imgWidth
+        } = img;
+        if (imgHeight || imgWidth) {
+          naturalWidth.value = imgWidth;
+          naturalHeight.value = imgHeight;
+        } else if (!img.complete && state.value === 'loading' && timeout != null) {
+          timer = window.setTimeout(poll, timeout);
+        } else if (img.currentSrc.endsWith('.svg') || img.currentSrc.startsWith('data:image/svg+xml')) {
+          naturalWidth.value = 1;
+          naturalHeight.value = 1;
+        }
+      };
+      poll();
+    }
+    const containClasses = computed(() => ({
+      'v-img__img--cover': props.cover,
+      'v-img__img--contain': !props.cover
+    }));
+    const __image = () => {
+      if (!normalisedSrc.value.src || state.value === 'idle') return null;
+      const img = _createVNode("img", {
+        "class": ['v-img__img', containClasses.value],
+        "style": {
+          objectPosition: props.position
+        },
+        "src": normalisedSrc.value.src,
+        "srcset": normalisedSrc.value.srcset,
+        "alt": props.alt,
+        "crossorigin": props.crossorigin,
+        "referrerpolicy": props.referrerpolicy,
+        "draggable": props.draggable,
+        "sizes": props.sizes,
+        "ref": image,
+        "onLoad": onLoad,
+        "onError": onError
+      }, null);
+      const sources = slots.sources?.();
+      return _createVNode(MaybeTransition, {
+        "transition": props.transition,
+        "appear": true
+      }, {
+        default: () => [withDirectives(sources ? _createVNode("picture", {
+          "class": "v-img__picture"
+        }, [sources, img]) : img, [[vShow, state.value === 'loaded']])]
+      });
+    };
+    const __preloadImage = () => _createVNode(MaybeTransition, {
+      "transition": props.transition
+    }, {
+      default: () => [normalisedSrc.value.lazySrc && state.value !== 'loaded' && _createVNode("img", {
+        "class": ['v-img__img', 'v-img__img--preload', containClasses.value],
+        "style": {
+          objectPosition: props.position
+        },
+        "src": normalisedSrc.value.lazySrc,
+        "alt": props.alt,
+        "crossorigin": props.crossorigin,
+        "referrerpolicy": props.referrerpolicy,
+        "draggable": props.draggable
+      }, null)]
+    });
+    const __placeholder = () => {
+      if (!slots.placeholder) return null;
+      return _createVNode(MaybeTransition, {
+        "transition": props.transition,
+        "appear": true
+      }, {
+        default: () => [(state.value === 'loading' || state.value === 'error' && !slots.error) && _createVNode("div", {
+          "class": "v-img__placeholder"
+        }, [slots.placeholder()])]
+      });
+    };
+    const __error = () => {
+      if (!slots.error) return null;
+      return _createVNode(MaybeTransition, {
+        "transition": props.transition,
+        "appear": true
+      }, {
+        default: () => [state.value === 'error' && _createVNode("div", {
+          "class": "v-img__error"
+        }, [slots.error()])]
+      });
+    };
+    const __gradient = () => {
+      if (!props.gradient) return null;
+      return _createVNode("div", {
+        "class": "v-img__gradient",
+        "style": {
+          backgroundImage: `linear-gradient(${props.gradient})`
+        }
+      }, null);
+    };
+    const isBooted = shallowRef(false);
+    {
+      const stop = watch(aspectRatio, val => {
+        if (val) {
+          // Doesn't work with nextTick, idk why
+          requestAnimationFrame(() => {
+            requestAnimationFrame(() => {
+              isBooted.value = true;
+            });
+          });
+          stop();
+        }
+      });
+    }
+    useRender(() => {
+      const responsiveProps = VResponsive.filterProps(props);
+      return _withDirectives(_createVNode(VResponsive, _mergeProps({
+        "class": ['v-img', {
+          'v-img--booting': !isBooted.value
+        }, backgroundColorClasses.value, roundedClasses.value, props.class],
+        "style": [{
+          width: convertToUnit(props.width === 'auto' ? naturalWidth.value : props.width)
+        }, backgroundColorStyles.value, props.style]
+      }, responsiveProps, {
+        "aspectRatio": aspectRatio.value,
+        "aria-label": props.alt,
+        "role": props.alt ? 'img' : undefined
+      }), {
+        additional: () => _createVNode(_Fragment, null, [_createVNode(__image, null, null), _createVNode(__preloadImage, null, null), _createVNode(__gradient, null, null), _createVNode(__placeholder, null, null), _createVNode(__error, null, null)]),
+        default: slots.default
+      }), [[_resolveDirective("intersect"), {
+        handler: init,
+        options: props.options
+      }, null, {
+        once: true
+      }]]);
+    });
+    return {
+      currentSrc,
+      image,
+      state,
+      naturalWidth,
+      naturalHeight
+    };
+  }
+});
+//# sourceMappingURL=VImg.mjs.map

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

@@ -0,0 +1,34 @@
+@use '../../styles/tools'
+@use './variables' as *
+
+.v-img
+  --v-theme-overlay-multiplier: 3
+  z-index: 0
+
+  &--booting .v-responsive__sizer
+    transition: none
+
+  &--rounded
+    @include tools.rounded($img-rounded-border-radius)
+
+.v-img__img,
+.v-img__picture,
+.v-img__gradient,
+.v-img__placeholder,
+.v-img__error
+  z-index: -1
+
+  @include tools.absolute()
+
+.v-img__img
+  &--preload
+    filter: $img-preload-filter
+
+  &--contain
+    object-fit: contain
+
+  &--cover
+    object-fit: cover
+
+.v-img__gradient
+  background-repeat: no-repeat

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

@@ -0,0 +1,6 @@
+@use '../../styles/settings';
+
+// Defaults
+$img-rounded-border-radius: settings.$border-radius-root !default;
+$img-preload-filter: blur(4px) !default;
+$img-card-media-height: 200px !default;

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

@@ -0,0 +1,435 @@
+import * as vue from 'vue';
+import { ComponentPropsOptions, ExtractPropTypes, 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>>;
+}
+
+interface srcObject {
+    src?: string;
+    srcset?: string;
+    lazySrc?: string;
+    aspect: number;
+}
+declare const VImg: {
+    new (...args: any[]): vue.CreateComponentPublicInstance<{
+        inline: boolean;
+        transition: string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        });
+        style: vue.StyleValue;
+        eager: boolean;
+        options: IntersectionObserverInit;
+        cover: boolean;
+        src: string | srcObject;
+    } & {
+        height?: string | number | undefined;
+        width?: string | number | undefined;
+        aspectRatio?: string | number | undefined;
+        color?: string | undefined;
+        maxHeight?: string | number | undefined;
+        maxWidth?: string | number | undefined;
+        minHeight?: string | number | undefined;
+        minWidth?: string | number | undefined;
+        position?: string | undefined;
+        draggable?: boolean | "false" | "true" | undefined;
+        class?: any;
+        referrerpolicy?: "origin" | "same-origin" | "no-referrer" | "no-referrer-when-downgrade" | "origin-when-cross-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url" | undefined;
+        alt?: string | undefined;
+        crossorigin?: "" | "anonymous" | "use-credentials" | undefined;
+        sizes?: string | undefined;
+        srcset?: string | undefined;
+        contentClass?: string | undefined;
+        rounded?: string | number | boolean | undefined;
+        gradient?: string | undefined;
+        lazySrc?: string | undefined;
+    } & {
+        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+            default?: (() => vue.VNodeChild) | undefined;
+            placeholder?: (() => vue.VNodeChild) | undefined;
+            error?: (() => vue.VNodeChild) | undefined;
+            sources?: (() => vue.VNodeChild) | undefined;
+        };
+        'v-slots'?: {
+            default?: false | (() => vue.VNodeChild) | undefined;
+            placeholder?: false | (() => vue.VNodeChild) | undefined;
+            error?: false | (() => vue.VNodeChild) | undefined;
+            sources?: false | (() => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+        "v-slot:placeholder"?: false | (() => vue.VNodeChild) | undefined;
+        "v-slot:error"?: false | (() => vue.VNodeChild) | undefined;
+        "v-slot:sources"?: false | (() => vue.VNodeChild) | undefined;
+    } & {
+        onError?: ((value: string | undefined) => any) | undefined;
+        onLoad?: ((value: string | undefined) => any) | undefined;
+        onLoadstart?: ((value: string | undefined) => any) | undefined;
+    }, {
+        currentSrc: vue.ShallowRef<string>;
+        image: vue.Ref<HTMLImageElement | undefined>;
+        state: vue.ShallowRef<"error" | "loaded" | "idle" | "loading">;
+        naturalWidth: vue.ShallowRef<number | undefined>;
+        naturalHeight: vue.ShallowRef<number | undefined>;
+    }, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+        loadstart: (value: string | undefined) => true;
+        load: (value: string | undefined) => true;
+        error: (value: string | undefined) => true;
+    }, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
+        inline: boolean;
+        transition: string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        });
+        style: vue.StyleValue;
+        eager: boolean;
+        options: IntersectionObserverInit;
+        cover: boolean;
+        src: string | srcObject;
+    } & {
+        height?: string | number | undefined;
+        width?: string | number | undefined;
+        aspectRatio?: string | number | undefined;
+        color?: string | undefined;
+        maxHeight?: string | number | undefined;
+        maxWidth?: string | number | undefined;
+        minHeight?: string | number | undefined;
+        minWidth?: string | number | undefined;
+        position?: string | undefined;
+        draggable?: boolean | "false" | "true" | undefined;
+        class?: any;
+        referrerpolicy?: "origin" | "same-origin" | "no-referrer" | "no-referrer-when-downgrade" | "origin-when-cross-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url" | undefined;
+        alt?: string | undefined;
+        crossorigin?: "" | "anonymous" | "use-credentials" | undefined;
+        sizes?: string | undefined;
+        srcset?: string | undefined;
+        contentClass?: string | undefined;
+        rounded?: string | number | boolean | undefined;
+        gradient?: string | undefined;
+        lazySrc?: string | undefined;
+    } & {
+        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+            default?: (() => vue.VNodeChild) | undefined;
+            placeholder?: (() => vue.VNodeChild) | undefined;
+            error?: (() => vue.VNodeChild) | undefined;
+            sources?: (() => vue.VNodeChild) | undefined;
+        };
+        'v-slots'?: {
+            default?: false | (() => vue.VNodeChild) | undefined;
+            placeholder?: false | (() => vue.VNodeChild) | undefined;
+            error?: false | (() => vue.VNodeChild) | undefined;
+            sources?: false | (() => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+        "v-slot:placeholder"?: false | (() => vue.VNodeChild) | undefined;
+        "v-slot:error"?: false | (() => vue.VNodeChild) | undefined;
+        "v-slot:sources"?: false | (() => vue.VNodeChild) | undefined;
+    } & {
+        onError?: ((value: string | undefined) => any) | undefined;
+        onLoad?: ((value: string | undefined) => any) | undefined;
+        onLoadstart?: ((value: string | undefined) => any) | undefined;
+    }, {
+        inline: boolean;
+        transition: string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        });
+        style: vue.StyleValue;
+        draggable: boolean | "false" | "true";
+        eager: boolean;
+        options: IntersectionObserverInit;
+        cover: boolean;
+        src: string | srcObject;
+        rounded: string | number | boolean;
+    }, true, {}, vue.SlotsType<Partial<{
+        default: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        placeholder: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        error: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        sources: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+    }>>, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, {
+        inline: boolean;
+        transition: string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        });
+        style: vue.StyleValue;
+        eager: boolean;
+        options: IntersectionObserverInit;
+        cover: boolean;
+        src: string | srcObject;
+    } & {
+        height?: string | number | undefined;
+        width?: string | number | undefined;
+        aspectRatio?: string | number | undefined;
+        color?: string | undefined;
+        maxHeight?: string | number | undefined;
+        maxWidth?: string | number | undefined;
+        minHeight?: string | number | undefined;
+        minWidth?: string | number | undefined;
+        position?: string | undefined;
+        draggable?: boolean | "false" | "true" | undefined;
+        class?: any;
+        referrerpolicy?: "origin" | "same-origin" | "no-referrer" | "no-referrer-when-downgrade" | "origin-when-cross-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url" | undefined;
+        alt?: string | undefined;
+        crossorigin?: "" | "anonymous" | "use-credentials" | undefined;
+        sizes?: string | undefined;
+        srcset?: string | undefined;
+        contentClass?: string | undefined;
+        rounded?: string | number | boolean | undefined;
+        gradient?: string | undefined;
+        lazySrc?: string | undefined;
+    } & {
+        $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+            default?: (() => vue.VNodeChild) | undefined;
+            placeholder?: (() => vue.VNodeChild) | undefined;
+            error?: (() => vue.VNodeChild) | undefined;
+            sources?: (() => vue.VNodeChild) | undefined;
+        };
+        'v-slots'?: {
+            default?: false | (() => vue.VNodeChild) | undefined;
+            placeholder?: false | (() => vue.VNodeChild) | undefined;
+            error?: false | (() => vue.VNodeChild) | undefined;
+            sources?: false | (() => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+        "v-slot:placeholder"?: false | (() => vue.VNodeChild) | undefined;
+        "v-slot:error"?: false | (() => vue.VNodeChild) | undefined;
+        "v-slot:sources"?: false | (() => vue.VNodeChild) | undefined;
+    } & {
+        onError?: ((value: string | undefined) => any) | undefined;
+        onLoad?: ((value: string | undefined) => any) | undefined;
+        onLoadstart?: ((value: string | undefined) => any) | undefined;
+    }, {
+        currentSrc: vue.ShallowRef<string>;
+        image: vue.Ref<HTMLImageElement | undefined>;
+        state: vue.ShallowRef<"error" | "loaded" | "idle" | "loading">;
+        naturalWidth: vue.ShallowRef<number | undefined>;
+        naturalHeight: vue.ShallowRef<number | undefined>;
+    }, {}, {}, {}, {
+        inline: boolean;
+        transition: string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        });
+        style: vue.StyleValue;
+        draggable: boolean | "false" | "true";
+        eager: boolean;
+        options: IntersectionObserverInit;
+        cover: boolean;
+        src: string | srcObject;
+        rounded: string | number | boolean;
+    }>;
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+} & vue.ComponentOptionsBase<{
+    inline: boolean;
+    transition: string | boolean | (vue.TransitionProps & {
+        component?: vue.Component | undefined;
+    });
+    style: vue.StyleValue;
+    eager: boolean;
+    options: IntersectionObserverInit;
+    cover: boolean;
+    src: string | srcObject;
+} & {
+    height?: string | number | undefined;
+    width?: string | number | undefined;
+    aspectRatio?: string | number | undefined;
+    color?: string | undefined;
+    maxHeight?: string | number | undefined;
+    maxWidth?: string | number | undefined;
+    minHeight?: string | number | undefined;
+    minWidth?: string | number | undefined;
+    position?: string | undefined;
+    draggable?: boolean | "false" | "true" | undefined;
+    class?: any;
+    referrerpolicy?: "origin" | "same-origin" | "no-referrer" | "no-referrer-when-downgrade" | "origin-when-cross-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url" | undefined;
+    alt?: string | undefined;
+    crossorigin?: "" | "anonymous" | "use-credentials" | undefined;
+    sizes?: string | undefined;
+    srcset?: string | undefined;
+    contentClass?: string | undefined;
+    rounded?: string | number | boolean | undefined;
+    gradient?: string | undefined;
+    lazySrc?: string | undefined;
+} & {
+    $children?: vue.VNodeChild | (() => vue.VNodeChild) | {
+        default?: (() => vue.VNodeChild) | undefined;
+        placeholder?: (() => vue.VNodeChild) | undefined;
+        error?: (() => vue.VNodeChild) | undefined;
+        sources?: (() => vue.VNodeChild) | undefined;
+    };
+    'v-slots'?: {
+        default?: false | (() => vue.VNodeChild) | undefined;
+        placeholder?: false | (() => vue.VNodeChild) | undefined;
+        error?: false | (() => vue.VNodeChild) | undefined;
+        sources?: false | (() => vue.VNodeChild) | undefined;
+    } | undefined;
+} & {
+    "v-slot:default"?: false | (() => vue.VNodeChild) | undefined;
+    "v-slot:placeholder"?: false | (() => vue.VNodeChild) | undefined;
+    "v-slot:error"?: false | (() => vue.VNodeChild) | undefined;
+    "v-slot:sources"?: false | (() => vue.VNodeChild) | undefined;
+} & {
+    onError?: ((value: string | undefined) => any) | undefined;
+    onLoad?: ((value: string | undefined) => any) | undefined;
+    onLoadstart?: ((value: string | undefined) => any) | undefined;
+}, {
+    currentSrc: vue.ShallowRef<string>;
+    image: vue.Ref<HTMLImageElement | undefined>;
+    state: vue.ShallowRef<"error" | "loaded" | "idle" | "loading">;
+    naturalWidth: vue.ShallowRef<number | undefined>;
+    naturalHeight: vue.ShallowRef<number | undefined>;
+}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    loadstart: (value: string | undefined) => true;
+    load: (value: string | undefined) => true;
+    error: (value: string | undefined) => true;
+}, string, {
+    inline: boolean;
+    transition: string | boolean | (vue.TransitionProps & {
+        component?: vue.Component | undefined;
+    });
+    style: vue.StyleValue;
+    draggable: boolean | "false" | "true";
+    eager: boolean;
+    options: IntersectionObserverInit;
+    cover: boolean;
+    src: string | srcObject;
+    rounded: string | number | boolean;
+}, {}, string, vue.SlotsType<Partial<{
+    default: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    placeholder: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    error: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    sources: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+}>>> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+    transition: {
+        type: PropType<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        })>;
+        default: string;
+        validator: (val: unknown) => boolean;
+    };
+    rounded: {
+        type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    class: PropType<any>;
+    style: {
+        type: PropType<vue.StyleValue>;
+        default: null;
+    };
+    height: (StringConstructor | NumberConstructor)[];
+    maxHeight: (StringConstructor | NumberConstructor)[];
+    maxWidth: (StringConstructor | NumberConstructor)[];
+    minHeight: (StringConstructor | NumberConstructor)[];
+    minWidth: (StringConstructor | NumberConstructor)[];
+    width: (StringConstructor | NumberConstructor)[];
+    aspectRatio: (StringConstructor | NumberConstructor)[];
+    contentClass: StringConstructor;
+    inline: BooleanConstructor;
+    alt: StringConstructor;
+    cover: BooleanConstructor;
+    color: StringConstructor;
+    draggable: {
+        type: PropType<boolean | "false" | "true">;
+        default: undefined;
+    };
+    eager: BooleanConstructor;
+    gradient: StringConstructor;
+    lazySrc: StringConstructor;
+    options: {
+        type: PropType<IntersectionObserverInit>;
+        default: () => {
+            root: undefined;
+            rootMargin: undefined;
+            threshold: undefined;
+        };
+    };
+    sizes: StringConstructor;
+    src: {
+        type: PropType<string | srcObject>;
+        default: string;
+    };
+    crossorigin: PropType<"" | "anonymous" | "use-credentials">;
+    referrerpolicy: PropType<"origin" | "same-origin" | "no-referrer" | "no-referrer-when-downgrade" | "origin-when-cross-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url">;
+    srcset: StringConstructor;
+    position: StringConstructor;
+}, vue.ExtractPropTypes<{
+    transition: {
+        type: PropType<string | boolean | (vue.TransitionProps & {
+            component?: vue.Component | undefined;
+        })>;
+        default: string;
+        validator: (val: unknown) => boolean;
+    };
+    rounded: {
+        type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    class: PropType<any>;
+    style: {
+        type: PropType<vue.StyleValue>;
+        default: null;
+    };
+    height: (StringConstructor | NumberConstructor)[];
+    maxHeight: (StringConstructor | NumberConstructor)[];
+    maxWidth: (StringConstructor | NumberConstructor)[];
+    minHeight: (StringConstructor | NumberConstructor)[];
+    minWidth: (StringConstructor | NumberConstructor)[];
+    width: (StringConstructor | NumberConstructor)[];
+    aspectRatio: (StringConstructor | NumberConstructor)[];
+    contentClass: StringConstructor;
+    inline: BooleanConstructor;
+    alt: StringConstructor;
+    cover: BooleanConstructor;
+    color: StringConstructor;
+    draggable: {
+        type: PropType<boolean | "false" | "true">;
+        default: undefined;
+    };
+    eager: BooleanConstructor;
+    gradient: StringConstructor;
+    lazySrc: StringConstructor;
+    options: {
+        type: PropType<IntersectionObserverInit>;
+        default: () => {
+            root: undefined;
+            rootMargin: undefined;
+            threshold: undefined;
+        };
+    };
+    sizes: StringConstructor;
+    src: {
+        type: PropType<string | srcObject>;
+        default: string;
+    };
+    crossorigin: PropType<"" | "anonymous" | "use-credentials">;
+    referrerpolicy: PropType<"origin" | "same-origin" | "no-referrer" | "no-referrer-when-downgrade" | "origin-when-cross-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url">;
+    srcset: StringConstructor;
+    position: StringConstructor;
+}>>;
+type VImg = InstanceType<typeof VImg>;
+
+export { VImg };

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

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

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

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