Tracking de l'application VApp (IHM du jeu)

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

@@ -0,0 +1,6 @@
+.v-checkbox.v-input {
+  flex: 0 1 auto;
+}
+.v-checkbox .v-selection-control {
+  min-height: var(--v-input-control-height);
+}

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

@@ -0,0 +1,75 @@
+import { createVNode as _createVNode, mergeProps as _mergeProps, resolveDirective as _resolveDirective } from "vue";
+// Styles
+import "./VCheckbox.css";
+
+// Components
+import { makeVCheckboxBtnProps, VCheckboxBtn } from "./VCheckboxBtn.mjs";
+import { makeVInputProps, VInput } from "../VInput/VInput.mjs"; // Composables
+import { useFocus } from "../../composables/focus.mjs";
+import { useProxiedModel } from "../../composables/proxiedModel.mjs"; // Utilities
+import { computed } from 'vue';
+import { filterInputAttrs, genericComponent, getUid, omit, propsFactory, useRender } from "../../util/index.mjs"; // Types
+export const makeVCheckboxProps = propsFactory({
+  ...makeVInputProps(),
+  ...omit(makeVCheckboxBtnProps(), ['inline'])
+}, 'VCheckbox');
+export const VCheckbox = genericComponent()({
+  name: 'VCheckbox',
+  inheritAttrs: false,
+  props: makeVCheckboxProps(),
+  emits: {
+    'update:modelValue': value => true,
+    'update:focused': focused => true
+  },
+  setup(props, _ref) {
+    let {
+      attrs,
+      slots
+    } = _ref;
+    const model = useProxiedModel(props, 'modelValue');
+    const {
+      isFocused,
+      focus,
+      blur
+    } = useFocus(props);
+    const uid = getUid();
+    const id = computed(() => props.id || `checkbox-${uid}`);
+    useRender(() => {
+      const [rootAttrs, controlAttrs] = filterInputAttrs(attrs);
+      const inputProps = VInput.filterProps(props);
+      const checkboxProps = VCheckboxBtn.filterProps(props);
+      return _createVNode(VInput, _mergeProps({
+        "class": ['v-checkbox', props.class]
+      }, rootAttrs, inputProps, {
+        "modelValue": model.value,
+        "onUpdate:modelValue": $event => model.value = $event,
+        "id": id.value,
+        "focused": isFocused.value,
+        "style": props.style
+      }), {
+        ...slots,
+        default: _ref2 => {
+          let {
+            id,
+            messagesId,
+            isDisabled,
+            isReadonly
+          } = _ref2;
+          return _createVNode(VCheckboxBtn, _mergeProps(checkboxProps, {
+            "id": id.value,
+            "aria-describedby": messagesId.value,
+            "disabled": isDisabled.value,
+            "readonly": isReadonly.value
+          }, controlAttrs, {
+            "modelValue": model.value,
+            "onUpdate:modelValue": $event => model.value = $event,
+            "onFocus": focus,
+            "onBlur": blur
+          }), slots);
+        }
+      });
+    });
+    return {};
+  }
+});
+//# sourceMappingURL=VCheckbox.mjs.map

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

@@ -0,0 +1,11 @@
+@use 'sass:map'
+@use '../../styles/settings'
+@use '../../styles/tools'
+@use './variables' as *
+
+.v-checkbox
+  &.v-input
+    flex: $checkbox-flex
+
+  .v-selection-control
+    min-height: var(--v-input-control-height)

VApp/node_modules/vuetify/lib/components/VCheckbox/VCheckboxBtn.mjs

@@ -0,0 +1,59 @@
+import { createVNode as _createVNode, mergeProps as _mergeProps, resolveDirective as _resolveDirective } from "vue";
+// Components
+import { makeVSelectionControlProps, VSelectionControl } from "../VSelectionControl/VSelectionControl.mjs"; // Composables
+import { IconValue } from "../../composables/icons.mjs";
+import { useProxiedModel } from "../../composables/proxiedModel.mjs"; // Utilities
+import { computed } from 'vue';
+import { genericComponent, omit, propsFactory, useRender } from "../../util/index.mjs"; // Types
+export const makeVCheckboxBtnProps = propsFactory({
+  indeterminate: Boolean,
+  indeterminateIcon: {
+    type: IconValue,
+    default: '$checkboxIndeterminate'
+  },
+  ...makeVSelectionControlProps({
+    falseIcon: '$checkboxOff',
+    trueIcon: '$checkboxOn'
+  })
+}, 'VCheckboxBtn');
+export const VCheckboxBtn = genericComponent()({
+  name: 'VCheckboxBtn',
+  props: makeVCheckboxBtnProps(),
+  emits: {
+    'update:modelValue': value => true,
+    'update:indeterminate': value => true
+  },
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    const indeterminate = useProxiedModel(props, 'indeterminate');
+    const model = useProxiedModel(props, 'modelValue');
+    function onChange(v) {
+      if (indeterminate.value) {
+        indeterminate.value = false;
+      }
+    }
+    const falseIcon = computed(() => {
+      return indeterminate.value ? props.indeterminateIcon : props.falseIcon;
+    });
+    const trueIcon = computed(() => {
+      return indeterminate.value ? props.indeterminateIcon : props.trueIcon;
+    });
+    useRender(() => {
+      const controlProps = omit(VSelectionControl.filterProps(props), ['modelValue']);
+      return _createVNode(VSelectionControl, _mergeProps(controlProps, {
+        "modelValue": model.value,
+        "onUpdate:modelValue": [$event => model.value = $event, onChange],
+        "class": ['v-checkbox-btn', props.class],
+        "style": props.style,
+        "type": "checkbox",
+        "falseIcon": falseIcon.value,
+        "trueIcon": trueIcon.value,
+        "aria-checked": indeterminate.value ? 'mixed' : undefined
+      }), slots);
+    });
+    return {};
+  }
+});
+//# sourceMappingURL=VCheckboxBtn.mjs.map

VApp/node_modules/vuetify/lib/components/VCheckbox/VCheckboxBtn.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"VCheckboxBtn.mjs","names":["makeVSelectionControlProps","VSelectionControl","IconValue","useProxiedModel","computed","genericComponent","omit","propsFactory","useRender","makeVCheckboxBtnProps","indeterminate","Boolean","indeterminateIcon","type","default","falseIcon","trueIcon","VCheckboxBtn","name","props","emits","value","setup","_ref","slots","model","onChange","v","controlProps","filterProps","_createVNode","_mergeProps","$event","class","style","undefined"],"sources":["../../../src/components/VCheckbox/VCheckboxBtn.tsx"],"sourcesContent":["// Components\nimport { makeVSelectionControlProps, VSelectionControl } from '@/components/VSelectionControl/VSelectionControl'\n\n// Composables\nimport { IconValue } from '@/composables/icons'\nimport { useProxiedModel } from '@/composables/proxiedModel'\n\n// Utilities\nimport { computed } from 'vue'\nimport { genericComponent, omit, propsFactory, useRender } from '@/util'\n\n// Types\nimport type { VSelectionControlSlots } from '@/components/VSelectionControl/VSelectionControl'\nimport type { GenericProps } from '@/util'\n\nexport const makeVCheckboxBtnProps = propsFactory({\n  indeterminate: Boolean,\n  indeterminateIcon: {\n    type: IconValue,\n    default: '$checkboxIndeterminate',\n  },\n\n  ...makeVSelectionControlProps({\n    falseIcon: '$checkboxOff',\n    trueIcon: '$checkboxOn',\n  }),\n}, 'VCheckboxBtn')\n\nexport const VCheckboxBtn = genericComponent<new <T>(\n  props: {\n    modelValue?: T\n    'onUpdate:modelValue'?: (value: T) => void\n  },\n  slots: VSelectionControlSlots,\n) => GenericProps<typeof props, typeof slots>>()({\n  name: 'VCheckboxBtn',\n\n  props: makeVCheckboxBtnProps(),\n\n  emits: {\n    'update:modelValue': (value: any) => true,\n    'update:indeterminate': (value: boolean) => true,\n  },\n\n  setup (props, { slots }) {\n    const indeterminate = useProxiedModel(props, 'indeterminate')\n    const model = useProxiedModel(props, 'modelValue')\n\n    function onChange (v: any) {\n      if (indeterminate.value) {\n        indeterminate.value = false\n      }\n    }\n\n    const falseIcon = computed(() => {\n      return indeterminate.value\n        ? props.indeterminateIcon\n        : props.falseIcon\n    })\n\n    const trueIcon = computed(() => {\n      return indeterminate.value\n        ? props.indeterminateIcon\n        : props.trueIcon\n    })\n\n    useRender(() => {\n      const controlProps = omit(VSelectionControl.filterProps(props), ['modelValue'])\n      return (\n        <VSelectionControl\n          { ...controlProps }\n          v-model={ model.value }\n          class={[\n            'v-checkbox-btn',\n            props.class,\n          ]}\n          style={ props.style }\n          type=\"checkbox\"\n          onUpdate:modelValue={ onChange }\n          falseIcon={ falseIcon.value }\n          trueIcon={ trueIcon.value }\n          aria-checked={ indeterminate.value ? 'mixed' : undefined }\n          v-slots={ slots }\n        />\n      )\n    })\n\n    return {}\n  },\n})\n\nexport type VCheckboxBtn = InstanceType<typeof VCheckboxBtn>\n"],"mappings":";AAAA;AAAA,SACSA,0BAA0B,EAAEC,iBAAiB,sDAEtD;AAAA,SACSC,SAAS;AAAA,SACTC,eAAe,8CAExB;AACA,SAASC,QAAQ,QAAQ,KAAK;AAAA,SACrBC,gBAAgB,EAAEC,IAAI,EAAEC,YAAY,EAAEC,SAAS,gCAExD;AAIA,OAAO,MAAMC,qBAAqB,GAAGF,YAAY,CAAC;EAChDG,aAAa,EAAEC,OAAO;EACtBC,iBAAiB,EAAE;IACjBC,IAAI,EAAEX,SAAS;IACfY,OAAO,EAAE;EACX,CAAC;EAED,GAAGd,0BAA0B,CAAC;IAC5Be,SAAS,EAAE,cAAc;IACzBC,QAAQ,EAAE;EACZ,CAAC;AACH,CAAC,EAAE,cAAc,CAAC;AAElB,OAAO,MAAMC,YAAY,GAAGZ,gBAAgB,CAMG,CAAC,CAAC;EAC/Ca,IAAI,EAAE,cAAc;EAEpBC,KAAK,EAAEV,qBAAqB,CAAC,CAAC;EAE9BW,KAAK,EAAE;IACL,mBAAmB,EAAGC,KAAU,IAAK,IAAI;IACzC,sBAAsB,EAAGA,KAAc,IAAK;EAC9C,CAAC;EAEDC,KAAKA,CAAEH,KAAK,EAAAI,IAAA,EAAa;IAAA,IAAX;MAAEC;IAAM,CAAC,GAAAD,IAAA;IACrB,MAAMb,aAAa,GAAGP,eAAe,CAACgB,KAAK,EAAE,eAAe,CAAC;IAC7D,MAAMM,KAAK,GAAGtB,eAAe,CAACgB,KAAK,EAAE,YAAY,CAAC;IAElD,SAASO,QAAQA,CAAEC,CAAM,EAAE;MACzB,IAAIjB,aAAa,CAACW,KAAK,EAAE;QACvBX,aAAa,CAACW,KAAK,GAAG,KAAK;MAC7B;IACF;IAEA,MAAMN,SAAS,GAAGX,QAAQ,CAAC,MAAM;MAC/B,OAAOM,aAAa,CAACW,KAAK,GACtBF,KAAK,CAACP,iBAAiB,GACvBO,KAAK,CAACJ,SAAS;IACrB,CAAC,CAAC;IAEF,MAAMC,QAAQ,GAAGZ,QAAQ,CAAC,MAAM;MAC9B,OAAOM,aAAa,CAACW,KAAK,GACtBF,KAAK,CAACP,iBAAiB,GACvBO,KAAK,CAACH,QAAQ;IACpB,CAAC,CAAC;IAEFR,SAAS,CAAC,MAAM;MACd,MAAMoB,YAAY,GAAGtB,IAAI,CAACL,iBAAiB,CAAC4B,WAAW,CAACV,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,CAAC;MAC/E,OAAAW,YAAA,CAAA7B,iBAAA,EAAA8B,WAAA,CAESH,YAAY;QAAA,cACPH,KAAK,CAACJ,KAAK;QAAA,wBAAAW,MAAA,IAAXP,KAAK,CAACJ,KAAK,GAAAW,MAAA,EAOCN,QAAQ;QAAA,SANvB,CACL,gBAAgB,EAChBP,KAAK,CAACc,KAAK,CACZ;QAAA,SACOd,KAAK,CAACe,KAAK;QAAA;QAAA,aAGPnB,SAAS,CAACM,KAAK;QAAA,YAChBL,QAAQ,CAACK,KAAK;QAAA,gBACVX,aAAa,CAACW,KAAK,GAAG,OAAO,GAAGc;MAAS,IAC9CX,KAAK;IAGrB,CAAC,CAAC;IAEF,OAAO,CAAC,CAAC;EACX;AACF,CAAC,CAAC"}

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

@@ -0,0 +1,5 @@
+@use '../../styles/settings';
+
+$checkbox-flex: 0 1 auto !default;
+$checkbox-disabled-color: rgba(var(--v-theme-on-surface), var(--v-disabled-opacity)) !default;
+$checkbox-error-color: rgb(var(--v-theme-error)) !default;

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

@@ -0,0 +1,949 @@
+import * as vue from 'vue';
+import { ComponentPropsOptions, ExtractPropTypes, VNodeChild, VNode, JSXComponent, PropType, WritableComputedRef, Ref, CSSProperties, ComputedRef } from 'vue';
+
+type SlotsToProps<U extends RawSlots, T = MakeInternalSlots<U>> = {
+    $children?: (VNodeChild | (T extends {
+        default: infer V;
+    } ? V : {}) | {
+        [K in keyof T]?: T[K];
+    });
+    'v-slots'?: {
+        [K in keyof T]?: T[K] | false;
+    };
+} & {
+    [K in keyof T as `v-slot:${K & string}`]?: T[K] | false;
+};
+type RawSlots = Record<string, unknown>;
+type Slot<T> = [T] extends [never] ? () => VNodeChild : (arg: T) => VNodeChild;
+type VueSlot<T> = [T] extends [never] ? () => VNode[] : (arg: T) => VNode[];
+type MakeInternalSlots<T extends RawSlots> = {
+    [K in keyof T]: Slot<T[K]>;
+};
+type MakeSlots<T extends RawSlots> = {
+    [K in keyof T]: VueSlot<T[K]>;
+};
+type GenericProps<Props, Slots extends Record<string, unknown>> = {
+    $props: Props & SlotsToProps<Slots>;
+    $slots: MakeSlots<Slots>;
+};
+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>>;
+}
+
+declare function deepEqual(a: any, b: any): boolean;
+
+type Density = null | 'default' | 'comfortable' | 'compact';
+
+type IconValue = string | (string | [path: string, opacity: number])[] | JSXComponent;
+declare const IconValue: PropType<IconValue>;
+
+type SelectionControlSlot = {
+    model: WritableComputedRef<boolean>;
+    textColorClasses: Ref<string[]>;
+    textColorStyles: Ref<CSSProperties>;
+    backgroundColorClasses: Ref<string[]>;
+    backgroundColorStyles: Ref<CSSProperties>;
+    inputNode: VNode;
+    icon: IconValue | undefined;
+    props: {
+        onBlur: (e: Event) => void;
+        onFocus: (e: FocusEvent) => void;
+        id: string;
+    };
+};
+type VSelectionControlSlots = {
+    default: {
+        backgroundColorClasses: Ref<string[]>;
+        backgroundColorStyles: Ref<CSSProperties>;
+    };
+    label: {
+        label: string | undefined;
+        props: Record<string, unknown>;
+    };
+    input: SelectionControlSlot;
+};
+
+type ValidationResult = string | boolean;
+type ValidationRule = ValidationResult | PromiseLike<ValidationResult> | ((value: any) => ValidationResult) | ((value: any) => PromiseLike<ValidationResult>);
+
+type VMessageSlot = {
+    message: string;
+};
+
+interface VInputSlot {
+    id: ComputedRef<string>;
+    messagesId: ComputedRef<string>;
+    isDirty: ComputedRef<boolean>;
+    isDisabled: ComputedRef<boolean>;
+    isReadonly: ComputedRef<boolean>;
+    isPristine: Ref<boolean>;
+    isValid: ComputedRef<boolean | null>;
+    isValidating: Ref<boolean>;
+    reset: () => void;
+    resetValidation: () => void;
+    validate: () => void;
+}
+type VInputSlots = {
+    default: VInputSlot;
+    prepend: VInputSlot;
+    append: VInputSlot;
+    details: VInputSlot;
+    message: VMessageSlot;
+};
+
+type VCheckboxSlots = Omit<VInputSlots, 'default'> & VSelectionControlSlots;
+declare const VCheckbox: {
+    new (...args: any[]): vue.CreateComponentPublicInstance<{
+        error: boolean;
+        direction: "horizontal" | "vertical";
+        style: vue.StyleValue;
+        disabled: boolean | null;
+        multiple: boolean | null;
+        readonly: boolean | null;
+        indeterminate: boolean;
+        messages: string | readonly string[];
+        density: Density;
+        ripple: boolean;
+        falseIcon: NonNullable<IconValue>;
+        trueIcon: NonNullable<IconValue>;
+        valueComparator: typeof deepEqual;
+        indeterminateIcon: IconValue;
+        focused: boolean;
+        errorMessages: string | readonly string[] | null;
+        maxErrors: string | number;
+        rules: readonly ValidationRule[];
+        centerAffix: boolean;
+        hideSpinButtons: boolean;
+        persistentHint: boolean;
+    } & {
+        type?: string | undefined;
+        id?: string | undefined;
+        name?: string | undefined;
+        color?: string | undefined;
+        value?: any;
+        label?: string | undefined;
+        class?: any;
+        theme?: string | undefined;
+        prependIcon?: IconValue | undefined;
+        appendIcon?: IconValue | undefined;
+        defaultsTarget?: string | undefined;
+        baseColor?: string | undefined;
+        trueValue?: any;
+        falseValue?: any;
+        'onClick:append'?: ((args_0: MouseEvent) => void) | undefined;
+        'onClick:prepend'?: ((args_0: MouseEvent) => void) | undefined;
+        'onUpdate:focused'?: ((args_0: boolean) => void) | undefined;
+        validateOn?: "lazy" | ("input" | "blur" | "submit") | "input lazy" | "blur lazy" | "submit lazy" | "lazy input" | "lazy blur" | "lazy submit" | undefined;
+        validationValue?: any;
+        hint?: string | undefined;
+        hideDetails?: boolean | "auto" | undefined;
+    } & {
+        "onUpdate:focused"?: ((focused: boolean) => any) | undefined;
+    }, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
+        'update:modelValue': (value: any) => boolean;
+        'update:focused': (focused: boolean) => boolean;
+    }, "$children" | "v-slot:default" | "v-slots" | "v-slot:append" | "v-slot:prepend" | "modelValue" | "update:modelValue" | "v-slot:input" | "v-slot:label" | "v-slot:message" | "v-slot:details">, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
+        error: boolean;
+        direction: "horizontal" | "vertical";
+        style: vue.StyleValue;
+        disabled: boolean | null;
+        multiple: boolean | null;
+        readonly: boolean | null;
+        indeterminate: boolean;
+        messages: string | readonly string[];
+        density: Density;
+        ripple: boolean;
+        falseIcon: NonNullable<IconValue>;
+        trueIcon: NonNullable<IconValue>;
+        valueComparator: typeof deepEqual;
+        indeterminateIcon: IconValue;
+        focused: boolean;
+        errorMessages: string | readonly string[] | null;
+        maxErrors: string | number;
+        rules: readonly ValidationRule[];
+        centerAffix: boolean;
+        hideSpinButtons: boolean;
+        persistentHint: boolean;
+    } & {
+        type?: string | undefined;
+        id?: string | undefined;
+        name?: string | undefined;
+        color?: string | undefined;
+        value?: any;
+        label?: string | undefined;
+        class?: any;
+        theme?: string | undefined;
+        prependIcon?: IconValue | undefined;
+        appendIcon?: IconValue | undefined;
+        defaultsTarget?: string | undefined;
+        baseColor?: string | undefined;
+        trueValue?: any;
+        falseValue?: any;
+        'onClick:append'?: ((args_0: MouseEvent) => void) | undefined;
+        'onClick:prepend'?: ((args_0: MouseEvent) => void) | undefined;
+        'onUpdate:focused'?: ((args_0: boolean) => void) | undefined;
+        validateOn?: "lazy" | ("input" | "blur" | "submit") | "input lazy" | "blur lazy" | "submit lazy" | "lazy input" | "lazy blur" | "lazy submit" | undefined;
+        validationValue?: any;
+        hint?: string | undefined;
+        hideDetails?: boolean | "auto" | undefined;
+    } & {
+        "onUpdate:focused"?: ((focused: boolean) => any) | undefined;
+    }, {
+        error: boolean;
+        direction: "horizontal" | "vertical";
+        style: vue.StyleValue;
+        disabled: boolean | null;
+        multiple: boolean | null;
+        readonly: boolean | null;
+        indeterminate: boolean;
+        messages: string | readonly string[];
+        density: Density;
+        ripple: boolean;
+        falseIcon: NonNullable<IconValue>;
+        trueIcon: NonNullable<IconValue>;
+        valueComparator: typeof deepEqual;
+        indeterminateIcon: IconValue;
+        focused: boolean;
+        errorMessages: string | readonly string[] | null;
+        maxErrors: string | number;
+        rules: readonly ValidationRule[];
+        centerAffix: boolean;
+        hideSpinButtons: boolean;
+        persistentHint: boolean;
+    }, true, {}, vue.SlotsType<Partial<{
+        message: (arg: VMessageSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        details: (arg: VInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        append: (arg: VInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        prepend: (arg: VInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        default: (arg: {
+            backgroundColorClasses: vue.Ref<string[]>;
+            backgroundColorStyles: vue.Ref<vue.CSSProperties>;
+        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        label: (arg: {
+            label: string | undefined;
+            props: Record<string, unknown>;
+        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        input: (arg: SelectionControlSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+    }>>, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, {
+        error: boolean;
+        direction: "horizontal" | "vertical";
+        style: vue.StyleValue;
+        disabled: boolean | null;
+        multiple: boolean | null;
+        readonly: boolean | null;
+        indeterminate: boolean;
+        messages: string | readonly string[];
+        density: Density;
+        ripple: boolean;
+        falseIcon: NonNullable<IconValue>;
+        trueIcon: NonNullable<IconValue>;
+        valueComparator: typeof deepEqual;
+        indeterminateIcon: IconValue;
+        focused: boolean;
+        errorMessages: string | readonly string[] | null;
+        maxErrors: string | number;
+        rules: readonly ValidationRule[];
+        centerAffix: boolean;
+        hideSpinButtons: boolean;
+        persistentHint: boolean;
+    } & {
+        type?: string | undefined;
+        id?: string | undefined;
+        name?: string | undefined;
+        color?: string | undefined;
+        value?: any;
+        label?: string | undefined;
+        class?: any;
+        theme?: string | undefined;
+        prependIcon?: IconValue | undefined;
+        appendIcon?: IconValue | undefined;
+        defaultsTarget?: string | undefined;
+        baseColor?: string | undefined;
+        trueValue?: any;
+        falseValue?: any;
+        'onClick:append'?: ((args_0: MouseEvent) => void) | undefined;
+        'onClick:prepend'?: ((args_0: MouseEvent) => void) | undefined;
+        'onUpdate:focused'?: ((args_0: boolean) => void) | undefined;
+        validateOn?: "lazy" | ("input" | "blur" | "submit") | "input lazy" | "blur lazy" | "submit lazy" | "lazy input" | "lazy blur" | "lazy submit" | undefined;
+        validationValue?: any;
+        hint?: string | undefined;
+        hideDetails?: boolean | "auto" | undefined;
+    } & {
+        "onUpdate:focused"?: ((focused: boolean) => any) | undefined;
+    }, {}, {}, {}, {}, {
+        error: boolean;
+        direction: "horizontal" | "vertical";
+        style: vue.StyleValue;
+        disabled: boolean | null;
+        multiple: boolean | null;
+        readonly: boolean | null;
+        indeterminate: boolean;
+        messages: string | readonly string[];
+        density: Density;
+        ripple: boolean;
+        falseIcon: NonNullable<IconValue>;
+        trueIcon: NonNullable<IconValue>;
+        valueComparator: typeof deepEqual;
+        indeterminateIcon: IconValue;
+        focused: boolean;
+        errorMessages: string | readonly string[] | null;
+        maxErrors: string | number;
+        rules: readonly ValidationRule[];
+        centerAffix: boolean;
+        hideSpinButtons: boolean;
+        persistentHint: boolean;
+    }>;
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+} & vue.ComponentOptionsBase<{
+    error: boolean;
+    direction: "horizontal" | "vertical";
+    style: vue.StyleValue;
+    disabled: boolean | null;
+    multiple: boolean | null;
+    readonly: boolean | null;
+    indeterminate: boolean;
+    messages: string | readonly string[];
+    density: Density;
+    ripple: boolean;
+    falseIcon: NonNullable<IconValue>;
+    trueIcon: NonNullable<IconValue>;
+    valueComparator: typeof deepEqual;
+    indeterminateIcon: IconValue;
+    focused: boolean;
+    errorMessages: string | readonly string[] | null;
+    maxErrors: string | number;
+    rules: readonly ValidationRule[];
+    centerAffix: boolean;
+    hideSpinButtons: boolean;
+    persistentHint: boolean;
+} & {
+    type?: string | undefined;
+    id?: string | undefined;
+    name?: string | undefined;
+    color?: string | undefined;
+    value?: any;
+    label?: string | undefined;
+    class?: any;
+    theme?: string | undefined;
+    prependIcon?: IconValue | undefined;
+    appendIcon?: IconValue | undefined;
+    defaultsTarget?: string | undefined;
+    baseColor?: string | undefined;
+    trueValue?: any;
+    falseValue?: any;
+    'onClick:append'?: ((args_0: MouseEvent) => void) | undefined;
+    'onClick:prepend'?: ((args_0: MouseEvent) => void) | undefined;
+    'onUpdate:focused'?: ((args_0: boolean) => void) | undefined;
+    validateOn?: "lazy" | ("input" | "blur" | "submit") | "input lazy" | "blur lazy" | "submit lazy" | "lazy input" | "lazy blur" | "lazy submit" | undefined;
+    validationValue?: any;
+    hint?: string | undefined;
+    hideDetails?: boolean | "auto" | undefined;
+} & {
+    "onUpdate:focused"?: ((focused: boolean) => any) | undefined;
+}, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
+    'update:modelValue': (value: any) => boolean;
+    'update:focused': (focused: boolean) => boolean;
+}, "$children" | "v-slot:default" | "v-slots" | "v-slot:append" | "v-slot:prepend" | "modelValue" | "update:modelValue" | "v-slot:input" | "v-slot:label" | "v-slot:message" | "v-slot:details">, string, {
+    error: boolean;
+    direction: "horizontal" | "vertical";
+    style: vue.StyleValue;
+    disabled: boolean | null;
+    multiple: boolean | null;
+    readonly: boolean | null;
+    indeterminate: boolean;
+    messages: string | readonly string[];
+    density: Density;
+    ripple: boolean;
+    falseIcon: NonNullable<IconValue>;
+    trueIcon: NonNullable<IconValue>;
+    valueComparator: typeof deepEqual;
+    indeterminateIcon: IconValue;
+    focused: boolean;
+    errorMessages: string | readonly string[] | null;
+    maxErrors: string | number;
+    rules: readonly ValidationRule[];
+    centerAffix: boolean;
+    hideSpinButtons: boolean;
+    persistentHint: boolean;
+}, {}, string, vue.SlotsType<Partial<{
+    message: (arg: VMessageSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    details: (arg: VInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    append: (arg: VInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    prepend: (arg: VInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    default: (arg: {
+        backgroundColorClasses: vue.Ref<string[]>;
+        backgroundColorStyles: vue.Ref<vue.CSSProperties>;
+    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    label: (arg: {
+        label: string | undefined;
+        props: Record<string, unknown>;
+    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    input: (arg: SelectionControlSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+}>>> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new <T>(props: {
+    modelValue?: T | null | undefined;
+    'onUpdate:modelValue'?: ((value: T | null) => void) | undefined;
+}, slots: VCheckboxSlots) => GenericProps<{
+    modelValue?: T | null | undefined;
+    'onUpdate:modelValue'?: ((value: T | null) => void) | undefined;
+}, VCheckboxSlots>) & FilterPropsOptions<{
+    type: StringConstructor;
+    error: BooleanConstructor;
+    id: StringConstructor;
+    name: StringConstructor;
+    color: StringConstructor;
+    value: null;
+    label: StringConstructor;
+    style: {
+        type: vue.PropType<vue.StyleValue>;
+        default: null;
+    };
+    disabled: {
+        type: vue.PropType<boolean | null>;
+        default: null;
+    };
+    multiple: {
+        type: vue.PropType<boolean | null>;
+        default: null;
+    };
+    readonly: {
+        type: vue.PropType<boolean | null>;
+        default: null;
+    };
+    class: vue.PropType<any>;
+    indeterminate: BooleanConstructor;
+    theme: StringConstructor;
+    density: {
+        type: vue.PropType<Density>;
+        default: string;
+        validator: (v: any) => boolean;
+    };
+    modelValue: null;
+    ripple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    defaultsTarget: StringConstructor;
+    falseIcon: {
+        type: vue.PropType<NonNullable<IconValue>>;
+        default: NonNullable<IconValue>;
+    };
+    trueIcon: {
+        type: vue.PropType<NonNullable<IconValue>>;
+        default: NonNullable<IconValue>;
+    };
+    valueComparator: {
+        type: vue.PropType<typeof deepEqual>;
+        default: typeof deepEqual;
+    };
+    baseColor: StringConstructor;
+    trueValue: null;
+    falseValue: null;
+    indeterminateIcon: {
+        type: vue.PropType<IconValue>;
+        default: string;
+    };
+    focused: BooleanConstructor;
+    'onUpdate:focused': vue.PropType<(args_0: boolean) => void>;
+    errorMessages: {
+        type: vue.PropType<string | readonly string[] | null>;
+        default: () => never[];
+    };
+    maxErrors: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    rules: {
+        type: vue.PropType<readonly ValidationRule[]>;
+        default: () => never[];
+    };
+    validateOn: vue.PropType<"lazy" | ("input" | "blur" | "submit") | "input lazy" | "blur lazy" | "submit lazy" | "lazy input" | "lazy blur" | "lazy submit" | undefined>;
+    validationValue: null;
+    appendIcon: vue.PropType<IconValue>;
+    centerAffix: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    prependIcon: vue.PropType<IconValue>;
+    hideDetails: vue.PropType<boolean | "auto">;
+    hideSpinButtons: BooleanConstructor;
+    hint: StringConstructor;
+    persistentHint: BooleanConstructor;
+    messages: {
+        type: vue.PropType<string | readonly string[]>;
+        default: () => never[];
+    };
+    direction: {
+        type: vue.PropType<"horizontal" | "vertical">;
+        default: string;
+        validator: (v: any) => boolean;
+    };
+    'onClick:prepend': vue.PropType<(args_0: MouseEvent) => void>;
+    'onClick:append': vue.PropType<(args_0: MouseEvent) => void>;
+}, vue.ExtractPropTypes<{
+    type: StringConstructor;
+    error: BooleanConstructor;
+    id: StringConstructor;
+    name: StringConstructor;
+    color: StringConstructor;
+    value: null;
+    label: StringConstructor;
+    style: {
+        type: vue.PropType<vue.StyleValue>;
+        default: null;
+    };
+    disabled: {
+        type: vue.PropType<boolean | null>;
+        default: null;
+    };
+    multiple: {
+        type: vue.PropType<boolean | null>;
+        default: null;
+    };
+    readonly: {
+        type: vue.PropType<boolean | null>;
+        default: null;
+    };
+    class: vue.PropType<any>;
+    indeterminate: BooleanConstructor;
+    theme: StringConstructor;
+    density: {
+        type: vue.PropType<Density>;
+        default: string;
+        validator: (v: any) => boolean;
+    };
+    modelValue: null;
+    ripple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    defaultsTarget: StringConstructor;
+    falseIcon: {
+        type: vue.PropType<NonNullable<IconValue>>;
+        default: NonNullable<IconValue>;
+    };
+    trueIcon: {
+        type: vue.PropType<NonNullable<IconValue>>;
+        default: NonNullable<IconValue>;
+    };
+    valueComparator: {
+        type: vue.PropType<typeof deepEqual>;
+        default: typeof deepEqual;
+    };
+    baseColor: StringConstructor;
+    trueValue: null;
+    falseValue: null;
+    indeterminateIcon: {
+        type: vue.PropType<IconValue>;
+        default: string;
+    };
+    focused: BooleanConstructor;
+    'onUpdate:focused': vue.PropType<(args_0: boolean) => void>;
+    errorMessages: {
+        type: vue.PropType<string | readonly string[] | null>;
+        default: () => never[];
+    };
+    maxErrors: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    rules: {
+        type: vue.PropType<readonly ValidationRule[]>;
+        default: () => never[];
+    };
+    validateOn: vue.PropType<"lazy" | ("input" | "blur" | "submit") | "input lazy" | "blur lazy" | "submit lazy" | "lazy input" | "lazy blur" | "lazy submit" | undefined>;
+    validationValue: null;
+    appendIcon: vue.PropType<IconValue>;
+    centerAffix: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    prependIcon: vue.PropType<IconValue>;
+    hideDetails: vue.PropType<boolean | "auto">;
+    hideSpinButtons: BooleanConstructor;
+    hint: StringConstructor;
+    persistentHint: BooleanConstructor;
+    messages: {
+        type: vue.PropType<string | readonly string[]>;
+        default: () => never[];
+    };
+    direction: {
+        type: vue.PropType<"horizontal" | "vertical">;
+        default: string;
+        validator: (v: any) => boolean;
+    };
+    'onClick:prepend': vue.PropType<(args_0: MouseEvent) => void>;
+    'onClick:append': vue.PropType<(args_0: MouseEvent) => void>;
+}>>;
+type VCheckbox = InstanceType<typeof VCheckbox>;
+
+declare const VCheckboxBtn: {
+    new (...args: any[]): vue.CreateComponentPublicInstance<{
+        inline: boolean;
+        error: boolean;
+        style: vue.StyleValue;
+        disabled: boolean | null;
+        multiple: boolean | null;
+        readonly: boolean | null;
+        indeterminate: boolean;
+        density: Density;
+        ripple: boolean;
+        falseIcon: NonNullable<IconValue>;
+        trueIcon: NonNullable<IconValue>;
+        valueComparator: typeof deepEqual;
+        indeterminateIcon: IconValue;
+    } & {
+        type?: string | undefined;
+        id?: string | undefined;
+        name?: string | undefined;
+        color?: string | undefined;
+        value?: any;
+        label?: string | undefined;
+        class?: any;
+        theme?: string | undefined;
+        defaultsTarget?: string | undefined;
+        baseColor?: string | undefined;
+        trueValue?: any;
+        falseValue?: any;
+    } & {
+        "onUpdate:indeterminate"?: ((value: boolean) => any) | undefined;
+    }, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
+        'update:modelValue': (value: any) => boolean;
+        'update:indeterminate': (value: boolean) => boolean;
+    }, "$children" | "v-slot:default" | "v-slots" | "modelValue" | "update:modelValue" | "v-slot:input" | "v-slot:label">, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
+        inline: boolean;
+        error: boolean;
+        style: vue.StyleValue;
+        disabled: boolean | null;
+        multiple: boolean | null;
+        readonly: boolean | null;
+        indeterminate: boolean;
+        density: Density;
+        ripple: boolean;
+        falseIcon: NonNullable<IconValue>;
+        trueIcon: NonNullable<IconValue>;
+        valueComparator: typeof deepEqual;
+        indeterminateIcon: IconValue;
+    } & {
+        type?: string | undefined;
+        id?: string | undefined;
+        name?: string | undefined;
+        color?: string | undefined;
+        value?: any;
+        label?: string | undefined;
+        class?: any;
+        theme?: string | undefined;
+        defaultsTarget?: string | undefined;
+        baseColor?: string | undefined;
+        trueValue?: any;
+        falseValue?: any;
+    } & {
+        "onUpdate:indeterminate"?: ((value: boolean) => any) | undefined;
+    }, {
+        inline: boolean;
+        error: boolean;
+        style: vue.StyleValue;
+        disabled: boolean | null;
+        multiple: boolean | null;
+        readonly: boolean | null;
+        indeterminate: boolean;
+        density: Density;
+        ripple: boolean;
+        falseIcon: NonNullable<IconValue>;
+        trueIcon: NonNullable<IconValue>;
+        valueComparator: typeof deepEqual;
+        indeterminateIcon: IconValue;
+    }, true, {}, vue.SlotsType<Partial<{
+        default: (arg: {
+            backgroundColorClasses: vue.Ref<string[]>;
+            backgroundColorStyles: vue.Ref<vue.CSSProperties>;
+        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        label: (arg: {
+            label: string | undefined;
+            props: Record<string, unknown>;
+        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        input: (arg: SelectionControlSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+    }>>, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, {
+        inline: boolean;
+        error: boolean;
+        style: vue.StyleValue;
+        disabled: boolean | null;
+        multiple: boolean | null;
+        readonly: boolean | null;
+        indeterminate: boolean;
+        density: Density;
+        ripple: boolean;
+        falseIcon: NonNullable<IconValue>;
+        trueIcon: NonNullable<IconValue>;
+        valueComparator: typeof deepEqual;
+        indeterminateIcon: IconValue;
+    } & {
+        type?: string | undefined;
+        id?: string | undefined;
+        name?: string | undefined;
+        color?: string | undefined;
+        value?: any;
+        label?: string | undefined;
+        class?: any;
+        theme?: string | undefined;
+        defaultsTarget?: string | undefined;
+        baseColor?: string | undefined;
+        trueValue?: any;
+        falseValue?: any;
+    } & {
+        "onUpdate:indeterminate"?: ((value: boolean) => any) | undefined;
+    }, {}, {}, {}, {}, {
+        inline: boolean;
+        error: boolean;
+        style: vue.StyleValue;
+        disabled: boolean | null;
+        multiple: boolean | null;
+        readonly: boolean | null;
+        indeterminate: boolean;
+        density: Density;
+        ripple: boolean;
+        falseIcon: NonNullable<IconValue>;
+        trueIcon: NonNullable<IconValue>;
+        valueComparator: typeof deepEqual;
+        indeterminateIcon: IconValue;
+    }>;
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+} & vue.ComponentOptionsBase<{
+    inline: boolean;
+    error: boolean;
+    style: vue.StyleValue;
+    disabled: boolean | null;
+    multiple: boolean | null;
+    readonly: boolean | null;
+    indeterminate: boolean;
+    density: Density;
+    ripple: boolean;
+    falseIcon: NonNullable<IconValue>;
+    trueIcon: NonNullable<IconValue>;
+    valueComparator: typeof deepEqual;
+    indeterminateIcon: IconValue;
+} & {
+    type?: string | undefined;
+    id?: string | undefined;
+    name?: string | undefined;
+    color?: string | undefined;
+    value?: any;
+    label?: string | undefined;
+    class?: any;
+    theme?: string | undefined;
+    defaultsTarget?: string | undefined;
+    baseColor?: string | undefined;
+    trueValue?: any;
+    falseValue?: any;
+} & {
+    "onUpdate:indeterminate"?: ((value: boolean) => any) | undefined;
+}, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Omit<{
+    'update:modelValue': (value: any) => boolean;
+    'update:indeterminate': (value: boolean) => boolean;
+}, "$children" | "v-slot:default" | "v-slots" | "modelValue" | "update:modelValue" | "v-slot:input" | "v-slot:label">, string, {
+    inline: boolean;
+    error: boolean;
+    style: vue.StyleValue;
+    disabled: boolean | null;
+    multiple: boolean | null;
+    readonly: boolean | null;
+    indeterminate: boolean;
+    density: Density;
+    ripple: boolean;
+    falseIcon: NonNullable<IconValue>;
+    trueIcon: NonNullable<IconValue>;
+    valueComparator: typeof deepEqual;
+    indeterminateIcon: IconValue;
+}, {}, string, vue.SlotsType<Partial<{
+    default: (arg: {
+        backgroundColorClasses: vue.Ref<string[]>;
+        backgroundColorStyles: vue.Ref<vue.CSSProperties>;
+    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    label: (arg: {
+        label: string | undefined;
+        props: Record<string, unknown>;
+    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    input: (arg: SelectionControlSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+}>>> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & (new <T>(props: {
+    modelValue?: T | undefined;
+    'onUpdate:modelValue'?: ((value: T) => void) | undefined;
+}, slots: VSelectionControlSlots) => GenericProps<{
+    modelValue?: T | undefined;
+    'onUpdate:modelValue'?: ((value: T) => void) | undefined;
+}, VSelectionControlSlots>) & FilterPropsOptions<{
+    theme: StringConstructor;
+    density: {
+        type: vue.PropType<Density>;
+        default: string;
+        validator: (v: any) => boolean;
+    };
+    class: vue.PropType<any>;
+    style: {
+        type: vue.PropType<vue.StyleValue>;
+        default: null;
+    };
+    color: StringConstructor;
+    disabled: {
+        type: vue.PropType<boolean | null>;
+        default: null;
+    };
+    defaultsTarget: StringConstructor;
+    error: BooleanConstructor;
+    id: StringConstructor;
+    inline: BooleanConstructor;
+    falseIcon: {
+        type: vue.PropType<NonNullable<IconValue>>;
+        default: NonNullable<IconValue>;
+    };
+    trueIcon: {
+        type: vue.PropType<NonNullable<IconValue>>;
+        default: NonNullable<IconValue>;
+    };
+    ripple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    multiple: {
+        type: vue.PropType<boolean | null>;
+        default: null;
+    };
+    name: StringConstructor;
+    readonly: {
+        type: vue.PropType<boolean | null>;
+        default: null;
+    };
+    modelValue: null;
+    type: StringConstructor;
+    valueComparator: {
+        type: vue.PropType<typeof deepEqual>;
+        default: typeof deepEqual;
+    };
+    label: StringConstructor;
+    baseColor: StringConstructor;
+    trueValue: null;
+    falseValue: null;
+    value: null;
+    indeterminate: BooleanConstructor;
+    indeterminateIcon: {
+        type: vue.PropType<IconValue>;
+        default: string;
+    };
+}, vue.ExtractPropTypes<{
+    theme: StringConstructor;
+    density: {
+        type: vue.PropType<Density>;
+        default: string;
+        validator: (v: any) => boolean;
+    };
+    class: vue.PropType<any>;
+    style: {
+        type: vue.PropType<vue.StyleValue>;
+        default: null;
+    };
+    color: StringConstructor;
+    disabled: {
+        type: vue.PropType<boolean | null>;
+        default: null;
+    };
+    defaultsTarget: StringConstructor;
+    error: BooleanConstructor;
+    id: StringConstructor;
+    inline: BooleanConstructor;
+    falseIcon: {
+        type: vue.PropType<NonNullable<IconValue>>;
+        default: NonNullable<IconValue>;
+    };
+    trueIcon: {
+        type: vue.PropType<NonNullable<IconValue>>;
+        default: NonNullable<IconValue>;
+    };
+    ripple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    multiple: {
+        type: vue.PropType<boolean | null>;
+        default: null;
+    };
+    name: StringConstructor;
+    readonly: {
+        type: vue.PropType<boolean | null>;
+        default: null;
+    };
+    modelValue: null;
+    type: StringConstructor;
+    valueComparator: {
+        type: vue.PropType<typeof deepEqual>;
+        default: typeof deepEqual;
+    };
+    label: StringConstructor;
+    baseColor: StringConstructor;
+    trueValue: null;
+    falseValue: null;
+    value: null;
+    indeterminate: BooleanConstructor;
+    indeterminateIcon: {
+        type: vue.PropType<IconValue>;
+        default: string;
+    };
+}>>;
+type VCheckboxBtn = InstanceType<typeof VCheckboxBtn>;
+
+export { VCheckbox, VCheckboxBtn };

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["VCheckbox","VCheckboxBtn"],"sources":["../../../src/components/VCheckbox/index.ts"],"sourcesContent":["export { VCheckbox } from './VCheckbox'\nexport { VCheckboxBtn } from './VCheckboxBtn'\n"],"mappings":"SAASA,SAAS;AAAA,SACTC,YAAY"}