Tracking de l'application VApp (IHM du jeu)

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

@@ -0,0 +1,405 @@
+.v-chip {
+  align-items: center;
+  display: inline-flex;
+  font-weight: 400;
+  max-width: 100%;
+  min-width: 0;
+  overflow: hidden;
+  position: relative;
+  text-decoration: none;
+  white-space: nowrap;
+  vertical-align: middle;
+  border-color: rgba(var(--v-border-color), var(--v-border-opacity));
+  border-style: solid;
+  border-width: 0;
+  border-radius: 9999px;
+}
+.v-chip.v-chip--size-x-small {
+  --v-chip-size: 0.625rem;
+  --v-chip-height: 20px;
+  font-size: 0.625rem;
+  padding: 0 8px;
+}
+.v-chip.v-chip--size-x-small .v-avatar {
+  --v-avatar-height: 14px;
+}
+.v-chip--pill.v-chip.v-chip--size-x-small .v-avatar {
+  --v-avatar-height: 20px;
+}
+
+.v-chip.v-chip--size-x-small .v-avatar--start {
+  margin-inline-start: -5.6px;
+  margin-inline-end: 4px;
+}
+.v-chip--pill.v-chip.v-chip--size-x-small .v-avatar--start {
+  margin-inline-start: -8px;
+}
+
+.v-chip.v-chip--size-x-small .v-avatar--end {
+  margin-inline-start: 4px;
+  margin-inline-end: -5.6px;
+}
+.v-chip--pill.v-chip.v-chip--size-x-small .v-avatar--end {
+  margin-inline-end: -8px;
+}
+
+.v-chip--pill.v-chip.v-chip--size-x-small .v-avatar--end + .v-chip__close {
+  margin-inline-start: 12px;
+}
+
+.v-chip.v-chip--size-x-small .v-icon--start,
+.v-chip.v-chip--size-x-small .v-chip__filter {
+  margin-inline-start: -4px;
+  margin-inline-end: 4px;
+}
+.v-chip.v-chip--size-x-small .v-icon--end,
+.v-chip.v-chip--size-x-small .v-chip__close {
+  margin-inline-start: 4px;
+  margin-inline-end: -4px;
+}
+.v-chip.v-chip--size-x-small .v-icon--end + .v-chip__close,
+.v-chip.v-chip--size-x-small .v-avatar--end + .v-chip__close,
+.v-chip.v-chip--size-x-small .v-chip__append + .v-chip__close {
+  margin-inline-start: 8px;
+}
+
+.v-chip.v-chip--size-small {
+  --v-chip-size: 0.75rem;
+  --v-chip-height: 26px;
+  font-size: 0.75rem;
+  padding: 0 10px;
+}
+.v-chip.v-chip--size-small .v-avatar {
+  --v-avatar-height: 20px;
+}
+.v-chip--pill.v-chip.v-chip--size-small .v-avatar {
+  --v-avatar-height: 26px;
+}
+
+.v-chip.v-chip--size-small .v-avatar--start {
+  margin-inline-start: -7px;
+  margin-inline-end: 5px;
+}
+.v-chip--pill.v-chip.v-chip--size-small .v-avatar--start {
+  margin-inline-start: -10px;
+}
+
+.v-chip.v-chip--size-small .v-avatar--end {
+  margin-inline-start: 5px;
+  margin-inline-end: -7px;
+}
+.v-chip--pill.v-chip.v-chip--size-small .v-avatar--end {
+  margin-inline-end: -10px;
+}
+
+.v-chip--pill.v-chip.v-chip--size-small .v-avatar--end + .v-chip__close {
+  margin-inline-start: 15px;
+}
+
+.v-chip.v-chip--size-small .v-icon--start,
+.v-chip.v-chip--size-small .v-chip__filter {
+  margin-inline-start: -5px;
+  margin-inline-end: 5px;
+}
+.v-chip.v-chip--size-small .v-icon--end,
+.v-chip.v-chip--size-small .v-chip__close {
+  margin-inline-start: 5px;
+  margin-inline-end: -5px;
+}
+.v-chip.v-chip--size-small .v-icon--end + .v-chip__close,
+.v-chip.v-chip--size-small .v-avatar--end + .v-chip__close,
+.v-chip.v-chip--size-small .v-chip__append + .v-chip__close {
+  margin-inline-start: 10px;
+}
+
+.v-chip.v-chip--size-default {
+  --v-chip-size: 0.875rem;
+  --v-chip-height: 32px;
+  font-size: 0.875rem;
+  padding: 0 12px;
+}
+.v-chip.v-chip--size-default .v-avatar {
+  --v-avatar-height: 26px;
+}
+.v-chip--pill.v-chip.v-chip--size-default .v-avatar {
+  --v-avatar-height: 32px;
+}
+
+.v-chip.v-chip--size-default .v-avatar--start {
+  margin-inline-start: -8.4px;
+  margin-inline-end: 6px;
+}
+.v-chip--pill.v-chip.v-chip--size-default .v-avatar--start {
+  margin-inline-start: -12px;
+}
+
+.v-chip.v-chip--size-default .v-avatar--end {
+  margin-inline-start: 6px;
+  margin-inline-end: -8.4px;
+}
+.v-chip--pill.v-chip.v-chip--size-default .v-avatar--end {
+  margin-inline-end: -12px;
+}
+
+.v-chip--pill.v-chip.v-chip--size-default .v-avatar--end + .v-chip__close {
+  margin-inline-start: 18px;
+}
+
+.v-chip.v-chip--size-default .v-icon--start,
+.v-chip.v-chip--size-default .v-chip__filter {
+  margin-inline-start: -6px;
+  margin-inline-end: 6px;
+}
+.v-chip.v-chip--size-default .v-icon--end,
+.v-chip.v-chip--size-default .v-chip__close {
+  margin-inline-start: 6px;
+  margin-inline-end: -6px;
+}
+.v-chip.v-chip--size-default .v-icon--end + .v-chip__close,
+.v-chip.v-chip--size-default .v-avatar--end + .v-chip__close,
+.v-chip.v-chip--size-default .v-chip__append + .v-chip__close {
+  margin-inline-start: 12px;
+}
+
+.v-chip.v-chip--size-large {
+  --v-chip-size: 1rem;
+  --v-chip-height: 38px;
+  font-size: 1rem;
+  padding: 0 14px;
+}
+.v-chip.v-chip--size-large .v-avatar {
+  --v-avatar-height: 32px;
+}
+.v-chip--pill.v-chip.v-chip--size-large .v-avatar {
+  --v-avatar-height: 38px;
+}
+
+.v-chip.v-chip--size-large .v-avatar--start {
+  margin-inline-start: -9.8px;
+  margin-inline-end: 7px;
+}
+.v-chip--pill.v-chip.v-chip--size-large .v-avatar--start {
+  margin-inline-start: -14px;
+}
+
+.v-chip.v-chip--size-large .v-avatar--end {
+  margin-inline-start: 7px;
+  margin-inline-end: -9.8px;
+}
+.v-chip--pill.v-chip.v-chip--size-large .v-avatar--end {
+  margin-inline-end: -14px;
+}
+
+.v-chip--pill.v-chip.v-chip--size-large .v-avatar--end + .v-chip__close {
+  margin-inline-start: 21px;
+}
+
+.v-chip.v-chip--size-large .v-icon--start,
+.v-chip.v-chip--size-large .v-chip__filter {
+  margin-inline-start: -7px;
+  margin-inline-end: 7px;
+}
+.v-chip.v-chip--size-large .v-icon--end,
+.v-chip.v-chip--size-large .v-chip__close {
+  margin-inline-start: 7px;
+  margin-inline-end: -7px;
+}
+.v-chip.v-chip--size-large .v-icon--end + .v-chip__close,
+.v-chip.v-chip--size-large .v-avatar--end + .v-chip__close,
+.v-chip.v-chip--size-large .v-chip__append + .v-chip__close {
+  margin-inline-start: 14px;
+}
+
+.v-chip.v-chip--size-x-large {
+  --v-chip-size: 1.125rem;
+  --v-chip-height: 44px;
+  font-size: 1.125rem;
+  padding: 0 17px;
+}
+.v-chip.v-chip--size-x-large .v-avatar {
+  --v-avatar-height: 38px;
+}
+.v-chip--pill.v-chip.v-chip--size-x-large .v-avatar {
+  --v-avatar-height: 44px;
+}
+
+.v-chip.v-chip--size-x-large .v-avatar--start {
+  margin-inline-start: -11.9px;
+  margin-inline-end: 8.5px;
+}
+.v-chip--pill.v-chip.v-chip--size-x-large .v-avatar--start {
+  margin-inline-start: -17px;
+}
+
+.v-chip.v-chip--size-x-large .v-avatar--end {
+  margin-inline-start: 8.5px;
+  margin-inline-end: -11.9px;
+}
+.v-chip--pill.v-chip.v-chip--size-x-large .v-avatar--end {
+  margin-inline-end: -17px;
+}
+
+.v-chip--pill.v-chip.v-chip--size-x-large .v-avatar--end + .v-chip__close {
+  margin-inline-start: 25.5px;
+}
+
+.v-chip.v-chip--size-x-large .v-icon--start,
+.v-chip.v-chip--size-x-large .v-chip__filter {
+  margin-inline-start: -8.5px;
+  margin-inline-end: 8.5px;
+}
+.v-chip.v-chip--size-x-large .v-icon--end,
+.v-chip.v-chip--size-x-large .v-chip__close {
+  margin-inline-start: 8.5px;
+  margin-inline-end: -8.5px;
+}
+.v-chip.v-chip--size-x-large .v-icon--end + .v-chip__close,
+.v-chip.v-chip--size-x-large .v-avatar--end + .v-chip__close,
+.v-chip.v-chip--size-x-large .v-chip__append + .v-chip__close {
+  margin-inline-start: 17px;
+}
+
+.v-chip.v-chip--density-default {
+  height: calc(var(--v-chip-height) + 0px);
+}
+
+.v-chip.v-chip--density-comfortable {
+  height: calc(var(--v-chip-height) + -8px);
+}
+
+.v-chip.v-chip--density-compact {
+  height: calc(var(--v-chip-height) + -12px);
+}
+
+.v-chip:hover > .v-chip__overlay {
+  opacity: calc(var(--v-hover-opacity) * var(--v-theme-overlay-multiplier));
+}
+.v-chip:focus-visible > .v-chip__overlay {
+  opacity: calc(var(--v-focus-opacity) * var(--v-theme-overlay-multiplier));
+}
+@supports not selector(:focus-visible) {
+  .v-chip:focus > .v-chip__overlay {
+    opacity: calc(var(--v-focus-opacity) * var(--v-theme-overlay-multiplier));
+  }
+}
+.v-chip--active > .v-chip__overlay, .v-chip[aria-haspopup=menu][aria-expanded=true] > .v-chip__overlay {
+  opacity: calc(var(--v-activated-opacity) * var(--v-theme-overlay-multiplier));
+}
+.v-chip--active:hover > .v-chip__overlay, .v-chip[aria-haspopup=menu][aria-expanded=true]:hover > .v-chip__overlay {
+  opacity: calc((var(--v-activated-opacity) + var(--v-hover-opacity)) * var(--v-theme-overlay-multiplier));
+}
+.v-chip--active:focus-visible > .v-chip__overlay, .v-chip[aria-haspopup=menu][aria-expanded=true]:focus-visible > .v-chip__overlay {
+  opacity: calc((var(--v-activated-opacity) + var(--v-focus-opacity)) * var(--v-theme-overlay-multiplier));
+}
+@supports not selector(:focus-visible) {
+  .v-chip--active:focus > .v-chip__overlay, .v-chip[aria-haspopup=menu][aria-expanded=true]:focus > .v-chip__overlay {
+    opacity: calc((var(--v-activated-opacity) + var(--v-focus-opacity)) * var(--v-theme-overlay-multiplier));
+  }
+}
+.v-chip--variant-plain, .v-chip--variant-outlined, .v-chip--variant-text, .v-chip--variant-tonal {
+  background: transparent;
+  color: inherit;
+}
+.v-chip--variant-plain {
+  opacity: 0.26;
+}
+.v-chip--variant-plain:focus, .v-chip--variant-plain:hover {
+  opacity: 1;
+}
+.v-chip--variant-plain .v-chip__overlay {
+  display: none;
+}
+.v-chip--variant-elevated, .v-chip--variant-flat {
+  background: rgb(var(--v-theme-surface-variant));
+  color: rgb(var(--v-theme-on-surface-variant));
+}
+.v-chip--variant-elevated {
+  box-shadow: 0px 2px 1px -1px var(--v-shadow-key-umbra-opacity, rgba(0, 0, 0, 0.2)), 0px 1px 1px 0px var(--v-shadow-key-penumbra-opacity, rgba(0, 0, 0, 0.14)), 0px 1px 3px 0px var(--v-shadow-key-ambient-opacity, rgba(0, 0, 0, 0.12));
+}
+.v-chip--variant-flat {
+  box-shadow: 0px 0px 0px 0px var(--v-shadow-key-umbra-opacity, rgba(0, 0, 0, 0.2)), 0px 0px 0px 0px var(--v-shadow-key-penumbra-opacity, rgba(0, 0, 0, 0.14)), 0px 0px 0px 0px var(--v-shadow-key-ambient-opacity, rgba(0, 0, 0, 0.12));
+}
+.v-chip--variant-outlined {
+  border: thin solid currentColor;
+}
+.v-chip--variant-text .v-chip__overlay {
+  background: currentColor;
+}
+.v-chip--variant-tonal .v-chip__underlay {
+  background: currentColor;
+  opacity: var(--v-activated-opacity);
+  border-radius: inherit;
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  pointer-events: none;
+}
+.v-chip--border {
+  border-width: thin;
+}
+.v-chip--link {
+  cursor: pointer;
+}
+.v-chip--filter {
+  user-select: none;
+}
+.v-chip--label {
+  border-radius: 4px;
+}
+
+.v-chip__content {
+  align-items: center;
+  display: inline-flex;
+}
+.v-autocomplete__selection .v-chip__content, .v-combobox__selection .v-chip__content, .v-select__selection .v-chip__content {
+  overflow: hidden;
+}
+
+.v-chip__filter,
+.v-chip__prepend,
+.v-chip__append,
+.v-chip__close {
+  align-items: center;
+  display: inline-flex;
+}
+
+.v-chip__close {
+  cursor: pointer;
+  flex: 0 1 auto;
+  font-size: 18px;
+  max-height: 18px;
+  max-width: 18px;
+  user-select: none;
+}
+.v-chip__close .v-icon {
+  font-size: inherit;
+}
+
+.v-chip__filter {
+  transition: 0.15s cubic-bezier(0.4, 0, 0.2, 1);
+}
+
+.v-chip__overlay {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  background-color: currentColor;
+  border-radius: inherit;
+  pointer-events: none;
+  opacity: 0;
+  transition: opacity 0.2s ease-in-out;
+}
+
+.v-chip--disabled {
+  opacity: 0.3;
+  pointer-events: none;
+  user-select: none;
+}
+
+.v-chip--label {
+  border-radius: 4px;
+}

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

@@ -0,0 +1,273 @@
+import { mergeProps as _mergeProps, Fragment as _Fragment, withDirectives as _withDirectives, vShow as _vShow, resolveDirective as _resolveDirective, createVNode as _createVNode } from "vue";
+/* eslint-disable complexity */
+// Styles
+import "./VChip.css";
+
+// Components
+import { VExpandXTransition } from "../transitions/index.mjs";
+import { VAvatar } from "../VAvatar/index.mjs";
+import { VChipGroupSymbol } from "../VChipGroup/VChipGroup.mjs";
+import { VDefaultsProvider } from "../VDefaultsProvider/index.mjs";
+import { VIcon } from "../VIcon/index.mjs"; // Composables
+import { makeBorderProps, useBorder } from "../../composables/border.mjs";
+import { makeComponentProps } from "../../composables/component.mjs";
+import { makeDensityProps, useDensity } from "../../composables/density.mjs";
+import { makeElevationProps, useElevation } from "../../composables/elevation.mjs";
+import { makeGroupItemProps, useGroupItem } from "../../composables/group.mjs";
+import { IconValue } from "../../composables/icons.mjs";
+import { useLocale } from "../../composables/locale.mjs";
+import { useProxiedModel } from "../../composables/proxiedModel.mjs";
+import { makeRoundedProps, useRounded } from "../../composables/rounded.mjs";
+import { makeRouterProps, useLink } from "../../composables/router.mjs";
+import { makeSizeProps, useSize } from "../../composables/size.mjs";
+import { makeTagProps } from "../../composables/tag.mjs";
+import { makeThemeProps, provideTheme } from "../../composables/theme.mjs";
+import { genOverlays, makeVariantProps, useVariant } from "../../composables/variant.mjs"; // Directives
+import { Ripple } from "../../directives/ripple/index.mjs"; // Utilities
+import { computed } from 'vue';
+import { EventProp, genericComponent, propsFactory } from "../../util/index.mjs"; // Types
+export const makeVChipProps = propsFactory({
+  activeClass: String,
+  appendAvatar: String,
+  appendIcon: IconValue,
+  closable: Boolean,
+  closeIcon: {
+    type: IconValue,
+    default: '$delete'
+  },
+  closeLabel: {
+    type: String,
+    default: '$vuetify.close'
+  },
+  draggable: Boolean,
+  filter: Boolean,
+  filterIcon: {
+    type: String,
+    default: '$complete'
+  },
+  label: Boolean,
+  link: {
+    type: Boolean,
+    default: undefined
+  },
+  pill: Boolean,
+  prependAvatar: String,
+  prependIcon: IconValue,
+  ripple: {
+    type: [Boolean, Object],
+    default: true
+  },
+  text: String,
+  modelValue: {
+    type: Boolean,
+    default: true
+  },
+  onClick: EventProp(),
+  onClickOnce: EventProp(),
+  ...makeBorderProps(),
+  ...makeComponentProps(),
+  ...makeDensityProps(),
+  ...makeElevationProps(),
+  ...makeGroupItemProps(),
+  ...makeRoundedProps(),
+  ...makeRouterProps(),
+  ...makeSizeProps(),
+  ...makeTagProps({
+    tag: 'span'
+  }),
+  ...makeThemeProps(),
+  ...makeVariantProps({
+    variant: 'tonal'
+  })
+}, 'VChip');
+export const VChip = genericComponent()({
+  name: 'VChip',
+  directives: {
+    Ripple
+  },
+  props: makeVChipProps(),
+  emits: {
+    'click:close': e => true,
+    'update:modelValue': value => true,
+    'group:selected': val => true,
+    click: e => true
+  },
+  setup(props, _ref) {
+    let {
+      attrs,
+      emit,
+      slots
+    } = _ref;
+    const {
+      t
+    } = useLocale();
+    const {
+      borderClasses
+    } = useBorder(props);
+    const {
+      colorClasses,
+      colorStyles,
+      variantClasses
+    } = useVariant(props);
+    const {
+      densityClasses
+    } = useDensity(props);
+    const {
+      elevationClasses
+    } = useElevation(props);
+    const {
+      roundedClasses
+    } = useRounded(props);
+    const {
+      sizeClasses
+    } = useSize(props);
+    const {
+      themeClasses
+    } = provideTheme(props);
+    const isActive = useProxiedModel(props, 'modelValue');
+    const group = useGroupItem(props, VChipGroupSymbol, false);
+    const link = useLink(props, attrs);
+    const isLink = computed(() => props.link !== false && link.isLink.value);
+    const isClickable = computed(() => !props.disabled && props.link !== false && (!!group || props.link || link.isClickable.value));
+    const closeProps = computed(() => ({
+      'aria-label': t(props.closeLabel),
+      onClick(e) {
+        e.stopPropagation();
+        isActive.value = false;
+        emit('click:close', e);
+      }
+    }));
+    function onClick(e) {
+      emit('click', e);
+      if (!isClickable.value) return;
+      link.navigate?.(e);
+      group?.toggle();
+    }
+    function onKeyDown(e) {
+      if (e.key === 'Enter' || e.key === ' ') {
+        e.preventDefault();
+        onClick(e);
+      }
+    }
+    return () => {
+      const Tag = link.isLink.value ? 'a' : props.tag;
+      const hasAppendMedia = !!(props.appendIcon || props.appendAvatar);
+      const hasAppend = !!(hasAppendMedia || slots.append);
+      const hasClose = !!(slots.close || props.closable);
+      const hasFilter = !!(slots.filter || props.filter) && group;
+      const hasPrependMedia = !!(props.prependIcon || props.prependAvatar);
+      const hasPrepend = !!(hasPrependMedia || slots.prepend);
+      const hasColor = !group || group.isSelected.value;
+      return isActive.value && _withDirectives(_createVNode(Tag, {
+        "class": ['v-chip', {
+          'v-chip--disabled': props.disabled,
+          'v-chip--label': props.label,
+          'v-chip--link': isClickable.value,
+          'v-chip--filter': hasFilter,
+          'v-chip--pill': props.pill
+        }, themeClasses.value, borderClasses.value, hasColor ? colorClasses.value : undefined, densityClasses.value, elevationClasses.value, roundedClasses.value, sizeClasses.value, variantClasses.value, group?.selectedClass.value, props.class],
+        "style": [hasColor ? colorStyles.value : undefined, props.style],
+        "disabled": props.disabled || undefined,
+        "draggable": props.draggable,
+        "href": link.href.value,
+        "tabindex": isClickable.value ? 0 : undefined,
+        "onClick": onClick,
+        "onKeydown": isClickable.value && !isLink.value && onKeyDown
+      }, {
+        default: () => [genOverlays(isClickable.value, 'v-chip'), hasFilter && _createVNode(VExpandXTransition, {
+          "key": "filter"
+        }, {
+          default: () => [_withDirectives(_createVNode("div", {
+            "class": "v-chip__filter"
+          }, [!slots.filter ? _createVNode(VIcon, {
+            "key": "filter-icon",
+            "icon": props.filterIcon
+          }, null) : _createVNode(VDefaultsProvider, {
+            "key": "filter-defaults",
+            "disabled": !props.filterIcon,
+            "defaults": {
+              VIcon: {
+                icon: props.filterIcon
+              }
+            }
+          }, slots.filter)]), [[_vShow, group.isSelected.value]])]
+        }), hasPrepend && _createVNode("div", {
+          "key": "prepend",
+          "class": "v-chip__prepend"
+        }, [!slots.prepend ? _createVNode(_Fragment, null, [props.prependIcon && _createVNode(VIcon, {
+          "key": "prepend-icon",
+          "icon": props.prependIcon,
+          "start": true
+        }, null), props.prependAvatar && _createVNode(VAvatar, {
+          "key": "prepend-avatar",
+          "image": props.prependAvatar,
+          "start": true
+        }, null)]) : _createVNode(VDefaultsProvider, {
+          "key": "prepend-defaults",
+          "disabled": !hasPrependMedia,
+          "defaults": {
+            VAvatar: {
+              image: props.prependAvatar,
+              start: true
+            },
+            VIcon: {
+              icon: props.prependIcon,
+              start: true
+            }
+          }
+        }, slots.prepend)]), _createVNode("div", {
+          "class": "v-chip__content",
+          "data-no-activator": ""
+        }, [slots.default?.({
+          isSelected: group?.isSelected.value,
+          selectedClass: group?.selectedClass.value,
+          select: group?.select,
+          toggle: group?.toggle,
+          value: group?.value.value,
+          disabled: props.disabled
+        }) ?? props.text]), hasAppend && _createVNode("div", {
+          "key": "append",
+          "class": "v-chip__append"
+        }, [!slots.append ? _createVNode(_Fragment, null, [props.appendIcon && _createVNode(VIcon, {
+          "key": "append-icon",
+          "end": true,
+          "icon": props.appendIcon
+        }, null), props.appendAvatar && _createVNode(VAvatar, {
+          "key": "append-avatar",
+          "end": true,
+          "image": props.appendAvatar
+        }, null)]) : _createVNode(VDefaultsProvider, {
+          "key": "append-defaults",
+          "disabled": !hasAppendMedia,
+          "defaults": {
+            VAvatar: {
+              end: true,
+              image: props.appendAvatar
+            },
+            VIcon: {
+              end: true,
+              icon: props.appendIcon
+            }
+          }
+        }, slots.append)]), hasClose && _createVNode("button", _mergeProps({
+          "key": "close",
+          "class": "v-chip__close",
+          "type": "button"
+        }, closeProps.value), [!slots.close ? _createVNode(VIcon, {
+          "key": "close-icon",
+          "icon": props.closeIcon,
+          "size": "x-small"
+        }, null) : _createVNode(VDefaultsProvider, {
+          "key": "close-defaults",
+          "defaults": {
+            VIcon: {
+              icon: props.closeIcon,
+              size: 'x-small'
+            }
+          }
+        }, slots.close)])]
+      }), [[_resolveDirective("ripple"), isClickable.value && props.ripple, null]]);
+    };
+  }
+});
+//# sourceMappingURL=VChip.mjs.map

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

@@ -0,0 +1,83 @@
+@use '../../styles/tools'
+@use './variables' as *
+@use './mixins' as *
+
+.v-chip
+  align-items: center
+  display: inline-flex
+  font-weight: $chip-font-weight
+  max-width: $chip-max-width
+  min-width: 0
+  overflow: hidden
+  position: relative
+  text-decoration: none
+  white-space: $chip-white-space
+  vertical-align: middle
+
+  @at-root
+    @include chip-sizes()
+    @include chip-density('height', $chip-density)
+
+  @include tools.border($chip-border...)
+  @include tools.states('.v-chip__overlay')
+  @include tools.rounded($chip-border-radius)
+  @include tools.variant($chip-variants...)
+
+  &--border
+    border-width: $chip-border-thin-width
+
+  &--link
+    cursor: pointer
+
+  &--filter
+    user-select: none
+
+  &--label
+    @include tools.rounded($chip-label-border-radius)
+
+// Elements
+.v-chip__content
+  align-items: center
+  display: inline-flex
+
+  .v-autocomplete__selection &,
+  .v-combobox__selection &,
+  .v-select__selection &
+    overflow: hidden
+
+.v-chip__filter,
+.v-chip__prepend,
+.v-chip__append,
+.v-chip__close
+  align-items: center
+  display: inline-flex
+
+.v-chip__close
+  cursor: pointer
+  flex: 0 1 auto
+  font-size: $chip-close-size
+  max-height: $chip-close-size
+  max-width: $chip-close-size
+  user-select: none
+
+  .v-icon
+    font-size: inherit
+
+.v-chip__filter
+  transition: $chip-filter-transition
+
+.v-chip__overlay
+  @include tools.absolute()
+  background-color: currentColor
+  border-radius: inherit
+  pointer-events: none
+  opacity: 0
+  transition: opacity .2s ease-in-out
+
+.v-chip--disabled
+  opacity: $chip-disabled-opacity
+  pointer-events: none
+  user-select: none
+
+.v-chip--label
+  border-radius: $chip-label-border-radius

VApp/node_modules/vuetify/lib/components/VChip/_mixins.scss

@@ -0,0 +1,89 @@
+@use 'sass:map';
+@use 'sass:math';
+@use 'sass:meta';
+@use 'sass:selector';
+@use '../../styles/settings';
+@use './variables' as *;
+
+@mixin chip-sizes {
+  @each $sizeName, $multiplier in settings.$size-scales {
+    $size: map.get($chip-sizes, "font-size") + math.div(2 * $multiplier, 16);
+    $height: map.get($chip-sizes, "height") + (6 * $multiplier);
+    $padding: math.round(math.div($height, $chip-padding-ratio));
+
+    .v-chip.v-chip--size-#{$sizeName} {
+      --v-chip-size: #{$size};
+      --v-chip-height: #{$height};
+      font-size: $size;
+      padding: 0 $padding;
+
+      .v-avatar {
+        --v-avatar-height: #{$height - 6};
+
+        @at-root #{selector.append('.v-chip--pill', &)} {
+          --v-avatar-height: #{$height};
+        }
+      }
+
+      .v-avatar--start {
+        margin-inline-start: -$padding * .7;
+        margin-inline-end: $padding * .5;
+
+        @at-root #{selector.append('.v-chip--pill', &)} {
+          margin-inline-start: -$padding;
+        }
+      }
+
+      .v-avatar--end {
+        margin-inline-start: $padding * .5;
+        margin-inline-end: -$padding * .7;
+
+        @at-root #{selector.append('.v-chip--pill', &)} {
+          margin-inline-end: -$padding;
+        }
+
+        + .v-chip__close {
+          @at-root #{selector.append('.v-chip--pill', &)} {
+            margin-inline-start: $padding * 1.5;
+          }
+        }
+      }
+
+      .v-icon--start,
+      .v-chip__filter {
+        margin-inline-start: -$padding * .5;
+        margin-inline-end: $padding * .5;
+      }
+
+      .v-icon--end,
+      .v-chip__close {
+        margin-inline-start: $padding * .5;
+        margin-inline-end: -$padding * .5;
+      }
+
+      .v-icon--end,
+      .v-avatar--end,
+      .v-chip__append {
+        + .v-chip__close {
+          margin-inline-start: $padding;
+        }
+      }
+    }
+  }
+}
+
+@mixin chip-density($properties, $densities) {
+  @each $density, $multiplier in $densities {
+    $value: calc(var(--v-chip-height) + #{$multiplier * settings.$spacer});
+
+    &.v-chip--density-#{$density} {
+      @if meta.type-of($properties) == "list" {
+        @each $property in $properties {
+          #{$property}: $value;
+        }
+      } @else {
+        #{$properties}: $value;
+      }
+    }
+  }
+}

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

@@ -0,0 +1,47 @@
+@use 'sass:math';
+@use 'sass:map';
+@use '../../styles/settings';
+@use '../../styles/tools';
+
+// Defaults
+$chip-background: rgb(var(--v-theme-surface-variant)) !default;
+$chip-border-color: settings.$border-color-root !default;
+$chip-border-radius: map.get(settings.$rounded, "pill") !default;
+$chip-border-style: settings.$border-style-root !default;
+$chip-border-thin-width: thin !default;
+$chip-border-width: 0 !default;
+$chip-close-size: 18px !default;
+$chip-color: rgb(var(--v-theme-on-surface-variant)) !default;
+$chip-density: ("default": 0, "comfortable": -2, "compact": -3) !default;
+$chip-disabled-opacity: 0.3 !default;
+$chip-elevation: 1 !default;
+$chip-font-size: tools.map-deep-get(settings.$typography, "button", "size") !default;
+$chip-font-weight: 400 !default;
+$chip-height: 32px !default;
+$chip-icon-font-size: 1.25rem !default;
+$chip-label-border-radius: settings.$border-radius-root !default;
+$chip-max-width: 100% !default;
+$chip-overflow: hidden !default;
+$chip-padding-ratio: 2 + math.div(2, 3) !default;
+$chip-plain-opacity: 0.26 !default;
+$chip-filter-transition: .15s settings.$standard-easing !default;
+$chip-white-space: nowrap !default;
+
+$chip-sizes: (
+  "height": $chip-height,
+  "font-size": $chip-font-size,
+) !default;
+
+$chip-border: (
+  $chip-border-color,
+  $chip-border-style,
+  $chip-border-width
+) !default;
+
+$chip-variants: (
+  $chip-background,
+  $chip-color,
+  $chip-elevation,
+  $chip-plain-opacity,
+  'v-chip'
+) !default;

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

@@ -0,0 +1,739 @@
+import * as vue from 'vue';
+import { ComponentPropsOptions, ExtractPropTypes, JSXComponent, PropType } from 'vue';
+// @ts-ignore
+import * as vue_router from 'vue-router';
+
+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>;
+
+declare const VChip: {
+    new (...args: any[]): vue.CreateComponentPublicInstance<{
+        replace: boolean;
+        filter: boolean;
+        variant: NonNullable<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        exact: boolean;
+        label: boolean;
+        style: vue.StyleValue;
+        draggable: boolean;
+        disabled: boolean;
+        size: string | number;
+        tag: string;
+        density: Density;
+        modelValue: boolean;
+        ripple: boolean | {
+            class: string;
+        } | undefined;
+        closable: boolean;
+        closeIcon: IconValue;
+        closeLabel: string;
+        filterIcon: string;
+        pill: boolean;
+    } & {
+        link?: boolean | undefined;
+        border?: string | number | boolean | undefined;
+        color?: string | undefined;
+        value?: any;
+        text?: string | undefined;
+        class?: any;
+        onClick?: ((args_0: MouseEvent) => void) | undefined;
+        onClickOnce?: ((args_0: MouseEvent) => void) | undefined;
+        href?: string | undefined;
+        elevation?: string | number | undefined;
+        to?: vue_router.RouteLocationRaw | undefined;
+        theme?: string | undefined;
+        rounded?: string | number | boolean | undefined;
+        selectedClass?: string | undefined;
+        prependIcon?: IconValue | undefined;
+        appendIcon?: IconValue | undefined;
+        activeClass?: string | undefined;
+        appendAvatar?: string | undefined;
+        prependAvatar?: string | undefined;
+    } & {
+        $children?: vue.VNodeChild | {
+            default?: ((arg: {
+                isSelected: boolean | undefined;
+                selectedClass: boolean | (string | undefined)[] | undefined;
+                select: ((value: boolean) => void) | undefined;
+                toggle: (() => void) | undefined;
+                value: unknown;
+                disabled: boolean;
+            }) => vue.VNodeChild) | undefined;
+            label?: (() => vue.VNodeChild) | undefined;
+            prepend?: (() => vue.VNodeChild) | undefined;
+            append?: (() => vue.VNodeChild) | undefined;
+            close?: (() => vue.VNodeChild) | undefined;
+            filter?: (() => vue.VNodeChild) | undefined;
+        } | ((arg: {
+            isSelected: boolean | undefined;
+            selectedClass: boolean | (string | undefined)[] | undefined;
+            select: ((value: boolean) => void) | undefined;
+            toggle: (() => void) | undefined;
+            value: unknown;
+            disabled: boolean;
+        }) => vue.VNodeChild);
+        'v-slots'?: {
+            default?: false | ((arg: {
+                isSelected: boolean | undefined;
+                selectedClass: boolean | (string | undefined)[] | undefined;
+                select: ((value: boolean) => void) | undefined;
+                toggle: (() => void) | undefined;
+                value: unknown;
+                disabled: boolean;
+            }) => vue.VNodeChild) | undefined;
+            label?: false | (() => vue.VNodeChild) | undefined;
+            prepend?: false | (() => vue.VNodeChild) | undefined;
+            append?: false | (() => vue.VNodeChild) | undefined;
+            close?: false | (() => vue.VNodeChild) | undefined;
+            filter?: false | (() => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:default"?: false | ((arg: {
+            isSelected: boolean | undefined;
+            selectedClass: boolean | (string | undefined)[] | undefined;
+            select: ((value: boolean) => void) | undefined;
+            toggle: (() => void) | undefined;
+            value: unknown;
+            disabled: boolean;
+        }) => vue.VNodeChild) | undefined;
+        "v-slot:label"?: false | (() => vue.VNodeChild) | undefined;
+        "v-slot:prepend"?: false | (() => vue.VNodeChild) | undefined;
+        "v-slot:append"?: false | (() => vue.VNodeChild) | undefined;
+        "v-slot:close"?: false | (() => vue.VNodeChild) | undefined;
+        "v-slot:filter"?: false | (() => vue.VNodeChild) | undefined;
+    } & {
+        onClick?: ((e: MouseEvent | KeyboardEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+        "onGroup:selected"?: ((val: {
+            value: boolean;
+        }) => any) | undefined;
+        "onClick:close"?: ((e: MouseEvent) => any) | undefined;
+    }, () => false | JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+        'click:close': (e: MouseEvent) => true;
+        'update:modelValue': (value: boolean) => true;
+        'group:selected': (val: {
+            value: boolean;
+        }) => true;
+        click: (e: MouseEvent | KeyboardEvent) => true;
+    }, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
+        replace: boolean;
+        filter: boolean;
+        variant: NonNullable<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        exact: boolean;
+        label: boolean;
+        style: vue.StyleValue;
+        draggable: boolean;
+        disabled: boolean;
+        size: string | number;
+        tag: string;
+        density: Density;
+        modelValue: boolean;
+        ripple: boolean | {
+            class: string;
+        } | undefined;
+        closable: boolean;
+        closeIcon: IconValue;
+        closeLabel: string;
+        filterIcon: string;
+        pill: boolean;
+    } & {
+        link?: boolean | undefined;
+        border?: string | number | boolean | undefined;
+        color?: string | undefined;
+        value?: any;
+        text?: string | undefined;
+        class?: any;
+        onClick?: ((args_0: MouseEvent) => void) | undefined;
+        onClickOnce?: ((args_0: MouseEvent) => void) | undefined;
+        href?: string | undefined;
+        elevation?: string | number | undefined;
+        to?: vue_router.RouteLocationRaw | undefined;
+        theme?: string | undefined;
+        rounded?: string | number | boolean | undefined;
+        selectedClass?: string | undefined;
+        prependIcon?: IconValue | undefined;
+        appendIcon?: IconValue | undefined;
+        activeClass?: string | undefined;
+        appendAvatar?: string | undefined;
+        prependAvatar?: string | undefined;
+    } & {
+        $children?: vue.VNodeChild | {
+            default?: ((arg: {
+                isSelected: boolean | undefined;
+                selectedClass: boolean | (string | undefined)[] | undefined;
+                select: ((value: boolean) => void) | undefined;
+                toggle: (() => void) | undefined;
+                value: unknown;
+                disabled: boolean;
+            }) => vue.VNodeChild) | undefined;
+            label?: (() => vue.VNodeChild) | undefined;
+            prepend?: (() => vue.VNodeChild) | undefined;
+            append?: (() => vue.VNodeChild) | undefined;
+            close?: (() => vue.VNodeChild) | undefined;
+            filter?: (() => vue.VNodeChild) | undefined;
+        } | ((arg: {
+            isSelected: boolean | undefined;
+            selectedClass: boolean | (string | undefined)[] | undefined;
+            select: ((value: boolean) => void) | undefined;
+            toggle: (() => void) | undefined;
+            value: unknown;
+            disabled: boolean;
+        }) => vue.VNodeChild);
+        'v-slots'?: {
+            default?: false | ((arg: {
+                isSelected: boolean | undefined;
+                selectedClass: boolean | (string | undefined)[] | undefined;
+                select: ((value: boolean) => void) | undefined;
+                toggle: (() => void) | undefined;
+                value: unknown;
+                disabled: boolean;
+            }) => vue.VNodeChild) | undefined;
+            label?: false | (() => vue.VNodeChild) | undefined;
+            prepend?: false | (() => vue.VNodeChild) | undefined;
+            append?: false | (() => vue.VNodeChild) | undefined;
+            close?: false | (() => vue.VNodeChild) | undefined;
+            filter?: false | (() => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:default"?: false | ((arg: {
+            isSelected: boolean | undefined;
+            selectedClass: boolean | (string | undefined)[] | undefined;
+            select: ((value: boolean) => void) | undefined;
+            toggle: (() => void) | undefined;
+            value: unknown;
+            disabled: boolean;
+        }) => vue.VNodeChild) | undefined;
+        "v-slot:label"?: false | (() => vue.VNodeChild) | undefined;
+        "v-slot:prepend"?: false | (() => vue.VNodeChild) | undefined;
+        "v-slot:append"?: false | (() => vue.VNodeChild) | undefined;
+        "v-slot:close"?: false | (() => vue.VNodeChild) | undefined;
+        "v-slot:filter"?: false | (() => vue.VNodeChild) | undefined;
+    } & {
+        onClick?: ((e: MouseEvent | KeyboardEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+        "onGroup:selected"?: ((val: {
+            value: boolean;
+        }) => any) | undefined;
+        "onClick:close"?: ((e: MouseEvent) => any) | undefined;
+    }, {
+        replace: boolean;
+        link: boolean;
+        filter: boolean;
+        variant: NonNullable<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        exact: boolean;
+        label: boolean;
+        style: vue.StyleValue;
+        draggable: boolean;
+        disabled: boolean;
+        size: string | number;
+        tag: string;
+        rounded: string | number | boolean;
+        density: Density;
+        modelValue: boolean;
+        ripple: boolean | {
+            class: string;
+        } | undefined;
+        closable: boolean;
+        closeIcon: IconValue;
+        closeLabel: string;
+        filterIcon: string;
+        pill: boolean;
+    }, true, {}, vue.SlotsType<Partial<{
+        default: (arg: {
+            isSelected: boolean | undefined;
+            selectedClass: boolean | (string | undefined)[] | undefined;
+            select: ((value: boolean) => void) | undefined;
+            toggle: (() => void) | undefined;
+            value: unknown;
+            disabled: boolean;
+        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        label: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        prepend: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        append: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        close: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        filter: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+    }>>, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, {
+        replace: boolean;
+        filter: boolean;
+        variant: NonNullable<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        exact: boolean;
+        label: boolean;
+        style: vue.StyleValue;
+        draggable: boolean;
+        disabled: boolean;
+        size: string | number;
+        tag: string;
+        density: Density;
+        modelValue: boolean;
+        ripple: boolean | {
+            class: string;
+        } | undefined;
+        closable: boolean;
+        closeIcon: IconValue;
+        closeLabel: string;
+        filterIcon: string;
+        pill: boolean;
+    } & {
+        link?: boolean | undefined;
+        border?: string | number | boolean | undefined;
+        color?: string | undefined;
+        value?: any;
+        text?: string | undefined;
+        class?: any;
+        onClick?: ((args_0: MouseEvent) => void) | undefined;
+        onClickOnce?: ((args_0: MouseEvent) => void) | undefined;
+        href?: string | undefined;
+        elevation?: string | number | undefined;
+        to?: vue_router.RouteLocationRaw | undefined;
+        theme?: string | undefined;
+        rounded?: string | number | boolean | undefined;
+        selectedClass?: string | undefined;
+        prependIcon?: IconValue | undefined;
+        appendIcon?: IconValue | undefined;
+        activeClass?: string | undefined;
+        appendAvatar?: string | undefined;
+        prependAvatar?: string | undefined;
+    } & {
+        $children?: vue.VNodeChild | {
+            default?: ((arg: {
+                isSelected: boolean | undefined;
+                selectedClass: boolean | (string | undefined)[] | undefined;
+                select: ((value: boolean) => void) | undefined;
+                toggle: (() => void) | undefined;
+                value: unknown;
+                disabled: boolean;
+            }) => vue.VNodeChild) | undefined;
+            label?: (() => vue.VNodeChild) | undefined;
+            prepend?: (() => vue.VNodeChild) | undefined;
+            append?: (() => vue.VNodeChild) | undefined;
+            close?: (() => vue.VNodeChild) | undefined;
+            filter?: (() => vue.VNodeChild) | undefined;
+        } | ((arg: {
+            isSelected: boolean | undefined;
+            selectedClass: boolean | (string | undefined)[] | undefined;
+            select: ((value: boolean) => void) | undefined;
+            toggle: (() => void) | undefined;
+            value: unknown;
+            disabled: boolean;
+        }) => vue.VNodeChild);
+        'v-slots'?: {
+            default?: false | ((arg: {
+                isSelected: boolean | undefined;
+                selectedClass: boolean | (string | undefined)[] | undefined;
+                select: ((value: boolean) => void) | undefined;
+                toggle: (() => void) | undefined;
+                value: unknown;
+                disabled: boolean;
+            }) => vue.VNodeChild) | undefined;
+            label?: false | (() => vue.VNodeChild) | undefined;
+            prepend?: false | (() => vue.VNodeChild) | undefined;
+            append?: false | (() => vue.VNodeChild) | undefined;
+            close?: false | (() => vue.VNodeChild) | undefined;
+            filter?: false | (() => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:default"?: false | ((arg: {
+            isSelected: boolean | undefined;
+            selectedClass: boolean | (string | undefined)[] | undefined;
+            select: ((value: boolean) => void) | undefined;
+            toggle: (() => void) | undefined;
+            value: unknown;
+            disabled: boolean;
+        }) => vue.VNodeChild) | undefined;
+        "v-slot:label"?: false | (() => vue.VNodeChild) | undefined;
+        "v-slot:prepend"?: false | (() => vue.VNodeChild) | undefined;
+        "v-slot:append"?: false | (() => vue.VNodeChild) | undefined;
+        "v-slot:close"?: false | (() => vue.VNodeChild) | undefined;
+        "v-slot:filter"?: false | (() => vue.VNodeChild) | undefined;
+    } & {
+        onClick?: ((e: MouseEvent | KeyboardEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+        "onGroup:selected"?: ((val: {
+            value: boolean;
+        }) => any) | undefined;
+        "onClick:close"?: ((e: MouseEvent) => any) | undefined;
+    }, () => false | JSX.Element, {}, {}, {}, {
+        replace: boolean;
+        link: boolean;
+        filter: boolean;
+        variant: NonNullable<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        exact: boolean;
+        label: boolean;
+        style: vue.StyleValue;
+        draggable: boolean;
+        disabled: boolean;
+        size: string | number;
+        tag: string;
+        rounded: string | number | boolean;
+        density: Density;
+        modelValue: boolean;
+        ripple: boolean | {
+            class: string;
+        } | undefined;
+        closable: boolean;
+        closeIcon: IconValue;
+        closeLabel: string;
+        filterIcon: string;
+        pill: boolean;
+    }>;
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+} & vue.ComponentOptionsBase<{
+    replace: boolean;
+    filter: boolean;
+    variant: NonNullable<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+    exact: boolean;
+    label: boolean;
+    style: vue.StyleValue;
+    draggable: boolean;
+    disabled: boolean;
+    size: string | number;
+    tag: string;
+    density: Density;
+    modelValue: boolean;
+    ripple: boolean | {
+        class: string;
+    } | undefined;
+    closable: boolean;
+    closeIcon: IconValue;
+    closeLabel: string;
+    filterIcon: string;
+    pill: boolean;
+} & {
+    link?: boolean | undefined;
+    border?: string | number | boolean | undefined;
+    color?: string | undefined;
+    value?: any;
+    text?: string | undefined;
+    class?: any;
+    onClick?: ((args_0: MouseEvent) => void) | undefined;
+    onClickOnce?: ((args_0: MouseEvent) => void) | undefined;
+    href?: string | undefined;
+    elevation?: string | number | undefined;
+    to?: vue_router.RouteLocationRaw | undefined;
+    theme?: string | undefined;
+    rounded?: string | number | boolean | undefined;
+    selectedClass?: string | undefined;
+    prependIcon?: IconValue | undefined;
+    appendIcon?: IconValue | undefined;
+    activeClass?: string | undefined;
+    appendAvatar?: string | undefined;
+    prependAvatar?: string | undefined;
+} & {
+    $children?: vue.VNodeChild | {
+        default?: ((arg: {
+            isSelected: boolean | undefined;
+            selectedClass: boolean | (string | undefined)[] | undefined;
+            select: ((value: boolean) => void) | undefined;
+            toggle: (() => void) | undefined;
+            value: unknown;
+            disabled: boolean;
+        }) => vue.VNodeChild) | undefined;
+        label?: (() => vue.VNodeChild) | undefined;
+        prepend?: (() => vue.VNodeChild) | undefined;
+        append?: (() => vue.VNodeChild) | undefined;
+        close?: (() => vue.VNodeChild) | undefined;
+        filter?: (() => vue.VNodeChild) | undefined;
+    } | ((arg: {
+        isSelected: boolean | undefined;
+        selectedClass: boolean | (string | undefined)[] | undefined;
+        select: ((value: boolean) => void) | undefined;
+        toggle: (() => void) | undefined;
+        value: unknown;
+        disabled: boolean;
+    }) => vue.VNodeChild);
+    'v-slots'?: {
+        default?: false | ((arg: {
+            isSelected: boolean | undefined;
+            selectedClass: boolean | (string | undefined)[] | undefined;
+            select: ((value: boolean) => void) | undefined;
+            toggle: (() => void) | undefined;
+            value: unknown;
+            disabled: boolean;
+        }) => vue.VNodeChild) | undefined;
+        label?: false | (() => vue.VNodeChild) | undefined;
+        prepend?: false | (() => vue.VNodeChild) | undefined;
+        append?: false | (() => vue.VNodeChild) | undefined;
+        close?: false | (() => vue.VNodeChild) | undefined;
+        filter?: false | (() => vue.VNodeChild) | undefined;
+    } | undefined;
+} & {
+    "v-slot:default"?: false | ((arg: {
+        isSelected: boolean | undefined;
+        selectedClass: boolean | (string | undefined)[] | undefined;
+        select: ((value: boolean) => void) | undefined;
+        toggle: (() => void) | undefined;
+        value: unknown;
+        disabled: boolean;
+    }) => vue.VNodeChild) | undefined;
+    "v-slot:label"?: false | (() => vue.VNodeChild) | undefined;
+    "v-slot:prepend"?: false | (() => vue.VNodeChild) | undefined;
+    "v-slot:append"?: false | (() => vue.VNodeChild) | undefined;
+    "v-slot:close"?: false | (() => vue.VNodeChild) | undefined;
+    "v-slot:filter"?: false | (() => vue.VNodeChild) | undefined;
+} & {
+    onClick?: ((e: MouseEvent | KeyboardEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    "onGroup:selected"?: ((val: {
+        value: boolean;
+    }) => any) | undefined;
+    "onClick:close"?: ((e: MouseEvent) => any) | undefined;
+}, () => false | JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    'click:close': (e: MouseEvent) => true;
+    'update:modelValue': (value: boolean) => true;
+    'group:selected': (val: {
+        value: boolean;
+    }) => true;
+    click: (e: MouseEvent | KeyboardEvent) => true;
+}, string, {
+    replace: boolean;
+    link: boolean;
+    filter: boolean;
+    variant: NonNullable<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+    exact: boolean;
+    label: boolean;
+    style: vue.StyleValue;
+    draggable: boolean;
+    disabled: boolean;
+    size: string | number;
+    tag: string;
+    rounded: string | number | boolean;
+    density: Density;
+    modelValue: boolean;
+    ripple: boolean | {
+        class: string;
+    } | undefined;
+    closable: boolean;
+    closeIcon: IconValue;
+    closeLabel: string;
+    filterIcon: string;
+    pill: boolean;
+}, {}, string, vue.SlotsType<Partial<{
+    default: (arg: {
+        isSelected: boolean | undefined;
+        selectedClass: boolean | (string | undefined)[] | undefined;
+        select: ((value: boolean) => void) | undefined;
+        toggle: (() => void) | undefined;
+        value: unknown;
+        disabled: boolean;
+    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    label: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    prepend: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    append: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    close: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    filter: () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+}>>> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+    color: StringConstructor;
+    variant: Omit<{
+        type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        default: string;
+        validator: (v: any) => boolean;
+    }, "type" | "default"> & {
+        type: 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: PropType<string>;
+        default: string;
+    };
+    size: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: string;
+    };
+    href: StringConstructor;
+    replace: BooleanConstructor;
+    to: PropType<vue_router.RouteLocationRaw>;
+    exact: BooleanConstructor;
+    rounded: {
+        type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    value: null;
+    disabled: BooleanConstructor;
+    selectedClass: StringConstructor;
+    elevation: {
+        type: (StringConstructor | NumberConstructor)[];
+        validator(v: any): boolean;
+    };
+    density: {
+        type: PropType<Density>;
+        default: string;
+        validator: (v: any) => boolean;
+    };
+    class: PropType<any>;
+    style: {
+        type: PropType<vue.StyleValue>;
+        default: null;
+    };
+    border: (StringConstructor | BooleanConstructor | NumberConstructor)[];
+    activeClass: StringConstructor;
+    appendAvatar: StringConstructor;
+    appendIcon: PropType<IconValue>;
+    closable: BooleanConstructor;
+    closeIcon: {
+        type: PropType<IconValue>;
+        default: string;
+    };
+    closeLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    draggable: BooleanConstructor;
+    filter: BooleanConstructor;
+    filterIcon: {
+        type: StringConstructor;
+        default: string;
+    };
+    label: BooleanConstructor;
+    link: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    pill: BooleanConstructor;
+    prependAvatar: StringConstructor;
+    prependIcon: PropType<IconValue>;
+    ripple: {
+        type: PropType<boolean | {
+            class: string;
+        } | undefined>;
+        default: boolean;
+    };
+    text: StringConstructor;
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    onClick: PropType<(args_0: MouseEvent) => void>;
+    onClickOnce: PropType<(args_0: MouseEvent) => void>;
+}, vue.ExtractPropTypes<{
+    color: StringConstructor;
+    variant: Omit<{
+        type: PropType<"flat" | "text" | "elevated" | "tonal" | "outlined" | "plain">;
+        default: string;
+        validator: (v: any) => boolean;
+    }, "type" | "default"> & {
+        type: 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: PropType<string>;
+        default: string;
+    };
+    size: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: string;
+    };
+    href: StringConstructor;
+    replace: BooleanConstructor;
+    to: PropType<vue_router.RouteLocationRaw>;
+    exact: BooleanConstructor;
+    rounded: {
+        type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    value: null;
+    disabled: BooleanConstructor;
+    selectedClass: StringConstructor;
+    elevation: {
+        type: (StringConstructor | NumberConstructor)[];
+        validator(v: any): boolean;
+    };
+    density: {
+        type: PropType<Density>;
+        default: string;
+        validator: (v: any) => boolean;
+    };
+    class: PropType<any>;
+    style: {
+        type: PropType<vue.StyleValue>;
+        default: null;
+    };
+    border: (StringConstructor | BooleanConstructor | NumberConstructor)[];
+    activeClass: StringConstructor;
+    appendAvatar: StringConstructor;
+    appendIcon: PropType<IconValue>;
+    closable: BooleanConstructor;
+    closeIcon: {
+        type: PropType<IconValue>;
+        default: string;
+    };
+    closeLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    draggable: BooleanConstructor;
+    filter: BooleanConstructor;
+    filterIcon: {
+        type: StringConstructor;
+        default: string;
+    };
+    label: BooleanConstructor;
+    link: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    pill: BooleanConstructor;
+    prependAvatar: StringConstructor;
+    prependIcon: PropType<IconValue>;
+    ripple: {
+        type: PropType<boolean | {
+            class: string;
+        } | undefined>;
+        default: boolean;
+    };
+    text: StringConstructor;
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    onClick: PropType<(args_0: MouseEvent) => void>;
+    onClickOnce: PropType<(args_0: MouseEvent) => void>;
+}>>;
+type VChip = InstanceType<typeof VChip>;
+
+export { VChip };

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

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

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

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