Tracking de l'application VApp (IHM du jeu)

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

@@ -0,0 +1,58 @@
+.v-slider .v-slider__container input {
+  cursor: default;
+  padding: 0;
+  width: 100%;
+  display: none;
+}
+.v-slider > .v-input__append,
+.v-slider > .v-input__prepend {
+  padding: 0;
+}
+
+.v-slider__container {
+  position: relative;
+  min-height: inherit;
+  width: 100%;
+  height: 100%;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  cursor: pointer;
+}
+.v-input--disabled .v-slider__container {
+  opacity: var(--v-disabled-opacity);
+}
+.v-input--error:not(.v-input--disabled) .v-slider__container {
+  color: rgb(var(--v-theme-error));
+}
+
+.v-slider.v-input--horizontal {
+  align-items: center;
+  margin-inline: 8px 8px;
+}
+.v-slider.v-input--horizontal > .v-input__control {
+  min-height: 32px;
+  display: flex;
+  align-items: center;
+}
+
+.v-slider.v-input--vertical {
+  justify-content: center;
+  margin-top: 12px;
+  margin-bottom: 12px;
+}
+.v-slider.v-input--vertical > .v-input__control {
+  min-height: 300px;
+}
+
+.v-slider.v-input--disabled {
+  pointer-events: none;
+}
+
+.v-slider--has-labels > .v-input__control {
+  margin-bottom: 4px;
+}
+
+.v-slider__label {
+  margin-inline-end: 12px;
+}

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

@@ -0,0 +1,150 @@
+import { mergeProps as _mergeProps, createVNode as _createVNode, Fragment as _Fragment } from "vue";
+// Styles
+import "./VSlider.css";
+
+// Components
+import { VSliderThumb } from "./VSliderThumb.mjs";
+import { VSliderTrack } from "./VSliderTrack.mjs";
+import { makeVInputProps, VInput } from "../VInput/VInput.mjs";
+import { VLabel } from "../VLabel/index.mjs"; // Composables
+import { makeSliderProps, useSlider, useSteps } from "./slider.mjs";
+import { makeFocusProps, useFocus } from "../../composables/focus.mjs";
+import { useRtl } from "../../composables/locale.mjs";
+import { useProxiedModel } from "../../composables/proxiedModel.mjs"; // Utilities
+import { computed, ref } from 'vue';
+import { genericComponent, propsFactory, useRender } from "../../util/index.mjs"; // Types
+export const makeVSliderProps = propsFactory({
+  ...makeFocusProps(),
+  ...makeSliderProps(),
+  ...makeVInputProps(),
+  modelValue: {
+    type: [Number, String],
+    default: 0
+  }
+}, 'VSlider');
+export const VSlider = genericComponent()({
+  name: 'VSlider',
+  props: makeVSliderProps(),
+  emits: {
+    'update:focused': value => true,
+    'update:modelValue': v => true,
+    start: value => true,
+    end: value => true
+  },
+  setup(props, _ref) {
+    let {
+      slots,
+      emit
+    } = _ref;
+    const thumbContainerRef = ref();
+    const {
+      rtlClasses
+    } = useRtl();
+    const steps = useSteps(props);
+    const model = useProxiedModel(props, 'modelValue', undefined, value => {
+      return steps.roundValue(value == null ? steps.min.value : value);
+    });
+    const {
+      min,
+      max,
+      mousePressed,
+      roundValue,
+      onSliderMousedown,
+      onSliderTouchstart,
+      trackContainerRef,
+      position,
+      hasLabels,
+      readonly
+    } = useSlider({
+      props,
+      steps,
+      onSliderStart: () => {
+        emit('start', model.value);
+      },
+      onSliderEnd: _ref2 => {
+        let {
+          value
+        } = _ref2;
+        const roundedValue = roundValue(value);
+        model.value = roundedValue;
+        emit('end', roundedValue);
+      },
+      onSliderMove: _ref3 => {
+        let {
+          value
+        } = _ref3;
+        return model.value = roundValue(value);
+      },
+      getActiveThumb: () => thumbContainerRef.value?.$el
+    });
+    const {
+      isFocused,
+      focus,
+      blur
+    } = useFocus(props);
+    const trackStop = computed(() => position(model.value));
+    useRender(() => {
+      const inputProps = VInput.filterProps(props);
+      const hasPrepend = !!(props.label || slots.label || slots.prepend);
+      return _createVNode(VInput, _mergeProps({
+        "class": ['v-slider', {
+          'v-slider--has-labels': !!slots['tick-label'] || hasLabels.value,
+          'v-slider--focused': isFocused.value,
+          'v-slider--pressed': mousePressed.value,
+          'v-slider--disabled': props.disabled
+        }, rtlClasses.value, props.class],
+        "style": props.style
+      }, inputProps, {
+        "focused": isFocused.value
+      }), {
+        ...slots,
+        prepend: hasPrepend ? slotProps => _createVNode(_Fragment, null, [slots.label?.(slotProps) ?? (props.label ? _createVNode(VLabel, {
+          "id": slotProps.id.value,
+          "class": "v-slider__label",
+          "text": props.label
+        }, null) : undefined), slots.prepend?.(slotProps)]) : undefined,
+        default: _ref4 => {
+          let {
+            id,
+            messagesId
+          } = _ref4;
+          return _createVNode("div", {
+            "class": "v-slider__container",
+            "onMousedown": !readonly.value ? onSliderMousedown : undefined,
+            "onTouchstartPassive": !readonly.value ? onSliderTouchstart : undefined
+          }, [_createVNode("input", {
+            "id": id.value,
+            "name": props.name || id.value,
+            "disabled": !!props.disabled,
+            "readonly": !!props.readonly,
+            "tabindex": "-1",
+            "value": model.value
+          }, null), _createVNode(VSliderTrack, {
+            "ref": trackContainerRef,
+            "start": 0,
+            "stop": trackStop.value
+          }, {
+            'tick-label': slots['tick-label']
+          }), _createVNode(VSliderThumb, {
+            "ref": thumbContainerRef,
+            "aria-describedby": messagesId.value,
+            "focused": isFocused.value,
+            "min": min.value,
+            "max": max.value,
+            "modelValue": model.value,
+            "onUpdate:modelValue": v => model.value = v,
+            "position": trackStop.value,
+            "elevation": props.elevation,
+            "onFocus": focus,
+            "onBlur": blur,
+            "ripple": props.ripple
+          }, {
+            'thumb-label': slots['thumb-label']
+          })]);
+        }
+      });
+    });
+    return {};
+  }
+});
+//# sourceMappingURL=VSlider.mjs.map

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

@@ -0,0 +1,62 @@
+@use 'sass:map'
+@use 'sass:selector'
+@use '../../styles/settings'
+@use '../../styles/tools'
+@use './variables' as *
+
+// Block
+.v-slider
+  .v-slider__container
+    input
+      cursor: default
+      padding: 0
+      width: 100%
+      display: none
+
+  > .v-input__append,
+  > .v-input__prepend
+    padding: 0
+
+// Elements
+.v-slider__container
+  position: relative
+  min-height: inherit
+  width: 100%
+  height: 100%
+  display: flex
+  justify-content: center
+  align-items: center
+  cursor: pointer
+
+  .v-input--disabled &
+    opacity: var(--v-disabled-opacity)
+
+  .v-input--error:not(.v-input--disabled) &
+    color: rgb(var(--v-theme-error))
+
+// Modifiers
+.v-slider.v-input--horizontal
+  align-items: center
+  margin-inline: $slider-horizontal-start $slider-horizontal-end
+
+  > .v-input__control
+    min-height: $slider-horizontal-min-height
+    display: flex
+    align-items: center
+
+.v-slider.v-input--vertical
+  justify-content: center
+  margin-top: $slider-vertical-margin-top
+  margin-bottom: $slider-vertical-margin-bottom
+
+  > .v-input__control
+    min-height: $slider-vertical-min-height
+
+.v-slider.v-input--disabled
+  pointer-events: none
+
+.v-slider--has-labels > .v-input__control
+  margin-bottom: $slider-tick-label-margin-top * .5
+
+.v-slider__label
+  margin-inline-end: $slider-label-margin-end

VApp/node_modules/vuetify/lib/components/VSlider/VSliderThumb.css

@@ -0,0 +1,153 @@
+.v-slider-thumb {
+  touch-action: none;
+  color: rgb(var(--v-theme-surface-variant));
+}
+.v-input--error:not(.v-input--disabled) .v-slider-thumb {
+  color: inherit;
+}
+
+.v-slider-thumb__label {
+  background: rgba(var(--v-theme-surface-variant), 0.7);
+  color: rgb(var(--v-theme-on-surface-variant));
+}
+.v-slider-thumb__label::before {
+  color: rgba(var(--v-theme-surface-variant), 0.7);
+}
+
+.v-slider-thumb {
+  outline: none;
+  position: absolute;
+  transition: 0.3s cubic-bezier(0.25, 0.8, 0.5, 1);
+}
+
+.v-slider-thumb__surface {
+  cursor: pointer;
+  width: var(--v-slider-thumb-size);
+  height: var(--v-slider-thumb-size);
+  border-radius: 50%;
+  user-select: none;
+  background-color: currentColor;
+}
+.v-slider-thumb__surface::before {
+  transition: 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+  content: "";
+  color: inherit;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  border-radius: 50%;
+  background: currentColor;
+  position: absolute;
+  pointer-events: none;
+  opacity: 0;
+}
+.v-slider-thumb__surface::after {
+  content: "";
+  width: 42px;
+  height: 42px;
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+}
+
+.v-slider-thumb__label-container {
+  position: absolute;
+  transition: 0.2s cubic-bezier(0.4, 0, 1, 1);
+}
+
+.v-slider-thumb__label {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 0.75rem;
+  min-width: 35px;
+  height: 25px;
+  border-radius: 4px;
+  padding: 6px;
+  position: absolute;
+  user-select: none;
+  transition: 0.2s cubic-bezier(0.4, 0, 1, 1);
+}
+.v-slider-thumb__label::before {
+  content: "";
+  width: 0;
+  height: 0;
+  position: absolute;
+}
+
+.v-slider-thumb__ripple {
+  position: absolute;
+  left: calc(var(--v-slider-thumb-size) / -2);
+  top: calc(var(--v-slider-thumb-size) / -2);
+  width: calc(var(--v-slider-thumb-size) * 2);
+  height: calc(var(--v-slider-thumb-size) * 2);
+  background: inherit;
+}
+
+.v-slider.v-input--horizontal .v-slider-thumb {
+  top: 50%;
+  transform: translateY(-50%);
+  inset-inline-start: calc(var(--v-slider-thumb-position) - var(--v-slider-thumb-size) / 2);
+}
+.v-slider.v-input--horizontal .v-slider-thumb__label-container {
+  left: calc(var(--v-slider-thumb-size) / 2);
+  top: 0;
+}
+.v-slider.v-input--horizontal .v-slider-thumb__label {
+  bottom: calc(var(--v-slider-thumb-size) / 2);
+}
+.v-locale--is-ltr.v-slider.v-input--horizontal .v-slider-thumb__label, .v-locale--is-ltr .v-slider.v-input--horizontal .v-slider-thumb__label {
+  transform: translateX(-50%);
+}
+
+.v-locale--is-rtl.v-slider.v-input--horizontal .v-slider-thumb__label, .v-locale--is-rtl .v-slider.v-input--horizontal .v-slider-thumb__label {
+  transform: translateX(50%);
+}
+
+.v-slider.v-input--horizontal .v-slider-thumb__label::before {
+  border-left: 6px solid transparent;
+  border-right: 6px solid transparent;
+  border-top: 6px solid currentColor;
+  bottom: -6px;
+}
+
+.v-slider.v-input--vertical .v-slider-thumb {
+  top: calc(var(--v-slider-thumb-position) - var(--v-slider-thumb-size) / 2);
+}
+.v-slider.v-input--vertical .v-slider-thumb__label-container {
+  top: calc(var(--v-slider-thumb-size) / 2);
+  right: 0;
+}
+.v-slider.v-input--vertical .v-slider-thumb__label {
+  top: -12.5px;
+  left: calc(var(--v-slider-thumb-size) / 2);
+}
+.v-slider.v-input--vertical .v-slider-thumb__label::before {
+  border-right: 6px solid currentColor;
+  border-top: 6px solid transparent;
+  border-bottom: 6px solid transparent;
+  left: -6px;
+}
+
+.v-slider-thumb--focused .v-slider-thumb__surface::before {
+  transform: scale(2);
+  opacity: var(--v-focus-opacity);
+}
+
+.v-slider-thumb--pressed {
+  transition: none;
+}
+.v-slider-thumb--pressed .v-slider-thumb__surface::before {
+  opacity: var(--v-pressed-opacity);
+}
+
+@media (hover: hover) {
+  .v-slider-thumb:hover .v-slider-thumb__surface::before {
+    transform: scale(2);
+  }
+  .v-slider-thumb:hover:not(.v-slider-thumb--focused) .v-slider-thumb__surface::before {
+    opacity: var(--v-hover-opacity);
+  }
+}

VApp/node_modules/vuetify/lib/components/VSlider/VSliderThumb.mjs

@@ -0,0 +1,165 @@
+import { vShow as _vShow, withDirectives as _withDirectives, resolveDirective as _resolveDirective, createVNode as _createVNode } from "vue";
+// Styles
+import "./VSliderThumb.css";
+
+// Components
+import { VSliderSymbol } from "./slider.mjs";
+import { VScaleTransition } from "../transitions/index.mjs"; // Composables
+import { useTextColor } from "../../composables/color.mjs";
+import { makeComponentProps } from "../../composables/component.mjs";
+import { useElevation } from "../../composables/elevation.mjs";
+import { useRtl } from "../../composables/locale.mjs"; // Directives
+import Ripple from "../../directives/ripple/index.mjs"; // Utilities
+import { computed, inject } from 'vue';
+import { convertToUnit, genericComponent, keyValues, propsFactory, useRender } from "../../util/index.mjs"; // Types
+export const makeVSliderThumbProps = propsFactory({
+  focused: Boolean,
+  max: {
+    type: Number,
+    required: true
+  },
+  min: {
+    type: Number,
+    required: true
+  },
+  modelValue: {
+    type: Number,
+    required: true
+  },
+  position: {
+    type: Number,
+    required: true
+  },
+  ripple: {
+    type: [Boolean, Object],
+    default: true
+  },
+  ...makeComponentProps()
+}, 'VSliderThumb');
+export const VSliderThumb = genericComponent()({
+  name: 'VSliderThumb',
+  directives: {
+    Ripple
+  },
+  props: makeVSliderThumbProps(),
+  emits: {
+    'update:modelValue': v => true
+  },
+  setup(props, _ref) {
+    let {
+      slots,
+      emit
+    } = _ref;
+    const slider = inject(VSliderSymbol);
+    const {
+      isRtl,
+      rtlClasses
+    } = useRtl();
+    if (!slider) throw new Error('[Vuetify] v-slider-thumb must be used inside v-slider or v-range-slider');
+    const {
+      thumbColor,
+      step,
+      disabled,
+      thumbSize,
+      thumbLabel,
+      direction,
+      isReversed,
+      vertical,
+      readonly,
+      elevation,
+      mousePressed,
+      decimals,
+      indexFromEnd
+    } = slider;
+    const elevationProps = computed(() => !disabled.value ? elevation.value : undefined);
+    const {
+      elevationClasses
+    } = useElevation(elevationProps);
+    const {
+      textColorClasses,
+      textColorStyles
+    } = useTextColor(thumbColor);
+    const {
+      pageup,
+      pagedown,
+      end,
+      home,
+      left,
+      right,
+      down,
+      up
+    } = keyValues;
+    const relevantKeys = [pageup, pagedown, end, home, left, right, down, up];
+    const multipliers = computed(() => {
+      if (step.value) return [1, 2, 3];else return [1, 5, 10];
+    });
+    function parseKeydown(e, value) {
+      if (!relevantKeys.includes(e.key)) return;
+      e.preventDefault();
+      const _step = step.value || 0.1;
+      const steps = (props.max - props.min) / _step;
+      if ([left, right, down, up].includes(e.key)) {
+        const increase = vertical.value ? [isRtl.value ? left : right, isReversed.value ? down : up] : indexFromEnd.value !== isRtl.value ? [left, up] : [right, up];
+        const direction = increase.includes(e.key) ? 1 : -1;
+        const multiplier = e.shiftKey ? 2 : e.ctrlKey ? 1 : 0;
+        value = value + direction * _step * multipliers.value[multiplier];
+      } else if (e.key === home) {
+        value = props.min;
+      } else if (e.key === end) {
+        value = props.max;
+      } else {
+        const direction = e.key === pagedown ? 1 : -1;
+        value = value - direction * _step * (steps > 100 ? steps / 10 : 10);
+      }
+      return Math.max(props.min, Math.min(props.max, value));
+    }
+    function onKeydown(e) {
+      const newValue = parseKeydown(e, props.modelValue);
+      newValue != null && emit('update:modelValue', newValue);
+    }
+    useRender(() => {
+      const positionPercentage = convertToUnit(indexFromEnd.value ? 100 - props.position : props.position, '%');
+      return _createVNode("div", {
+        "class": ['v-slider-thumb', {
+          'v-slider-thumb--focused': props.focused,
+          'v-slider-thumb--pressed': props.focused && mousePressed.value
+        }, props.class, rtlClasses.value],
+        "style": [{
+          '--v-slider-thumb-position': positionPercentage,
+          '--v-slider-thumb-size': convertToUnit(thumbSize.value)
+        }, props.style],
+        "role": "slider",
+        "tabindex": disabled.value ? -1 : 0,
+        "aria-valuemin": props.min,
+        "aria-valuemax": props.max,
+        "aria-valuenow": props.modelValue,
+        "aria-readonly": !!readonly.value,
+        "aria-orientation": direction.value,
+        "onKeydown": !readonly.value ? onKeydown : undefined
+      }, [_createVNode("div", {
+        "class": ['v-slider-thumb__surface', textColorClasses.value, elevationClasses.value],
+        "style": {
+          ...textColorStyles.value
+        }
+      }, null), _withDirectives(_createVNode("div", {
+        "class": ['v-slider-thumb__ripple', textColorClasses.value],
+        "style": textColorStyles.value
+      }, null), [[_resolveDirective("ripple"), props.ripple, null, {
+        circle: true,
+        center: true
+      }]]), _createVNode(VScaleTransition, {
+        "origin": "bottom center"
+      }, {
+        default: () => [_withDirectives(_createVNode("div", {
+          "class": "v-slider-thumb__label-container"
+        }, [_createVNode("div", {
+          "class": ['v-slider-thumb__label']
+        }, [_createVNode("div", null, [slots['thumb-label']?.({
+          modelValue: props.modelValue
+        }) ?? props.modelValue.toFixed(step.value ? decimals.value : 1)])])]), [[_vShow, thumbLabel.value && props.focused || thumbLabel.value === 'always']])]
+      })]);
+    });
+    return {};
+  }
+});
+//# sourceMappingURL=VSliderThumb.mjs.map

VApp/node_modules/vuetify/lib/components/VSlider/VSliderThumb.sass

@@ -0,0 +1,154 @@
+@use 'sass:map'
+@use 'sass:selector'
+@use 'sass:math'
+@use '../../styles/settings'
+@use '../../styles/tools'
+@use './variables' as *
+
+// Theme
+.v-slider-thumb
+  touch-action: none
+  color: rgb(var(--v-theme-surface-variant))
+
+  .v-input--error:not(.v-input--disabled) &
+    color: inherit
+
+.v-slider-thumb__label
+  background: rgba(var(--v-theme-surface-variant), .7)
+  color: rgb(var(--v-theme-on-surface-variant))
+
+  &::before
+    color: rgba(var(--v-theme-surface-variant), .7)
+
+// Block
+.v-slider-thumb
+  outline: none
+  position: absolute
+  transition: $slider-transition
+
+.v-slider-thumb__surface
+  cursor: pointer
+  width: var(--v-slider-thumb-size)
+  height: var(--v-slider-thumb-size)
+  border-radius: $slider-thumb-border-radius
+  user-select: none
+  background-color: currentColor
+
+  &::before
+    transition: 0.3s settings.$standard-easing
+    content: ''
+    color: inherit
+    top: 0
+    left: 0
+    width: 100%
+    height: 100%
+    border-radius: $slider-thumb-border-radius
+    background: currentColor
+    position: absolute
+    pointer-events: none
+    opacity: 0
+
+  &::after
+    content: ''
+    width: $slider-thumb-touch-size
+    height: $slider-thumb-touch-size
+    position: absolute
+    top: 50%
+    left: 50%
+    transform: translate(-50%, -50%)
+
+.v-slider-thumb__label-container
+  position: absolute
+  transition: $slider-thumb-label-transition
+
+.v-slider-thumb__label
+  display: flex
+  align-items: center
+  justify-content: center
+  font-size: $slider-thumb-label-font-size
+  min-width: $slider-thumb-label-min-width
+  height: $slider-thumb-label-height
+  border-radius: $slider-thumb-label-border-radius
+  padding: $slider-thumb-label-padding
+  position: absolute
+  user-select: none
+  transition: $slider-thumb-label-transition
+
+  &::before
+    content: ''
+    width: 0
+    height: 0
+    position: absolute
+
+.v-slider-thumb__ripple
+  position: absolute
+  left: calc(var(--v-slider-thumb-size) / -2)
+  top: calc(var(--v-slider-thumb-size) / -2)
+  width: calc(var(--v-slider-thumb-size) * 2)
+  height: calc(var(--v-slider-thumb-size) * 2)
+  background: inherit
+
+// Horizontal
+.v-slider.v-input--horizontal
+  .v-slider-thumb
+    top: 50%
+    transform: translateY(-50%)
+    inset-inline-start: calc(var(--v-slider-thumb-position) - var(--v-slider-thumb-size) / 2)
+
+  .v-slider-thumb__label-container
+    left: calc(var(--v-slider-thumb-size) / 2)
+    top: 0
+
+  .v-slider-thumb__label
+    bottom: $slider-thumb-label-offset
+
+    +tools.ltr()
+      transform: translateX(-50%)
+    +tools.rtl()
+      transform: translateX(50%)
+
+    &::before
+      border-left: $slider-thumb-label-wedge-size solid transparent
+      border-right: $slider-thumb-label-wedge-size solid transparent
+      border-top: $slider-thumb-label-wedge-size solid currentColor
+      bottom: -$slider-thumb-label-wedge-size
+
+// Vertical
+.v-slider.v-input--vertical
+  .v-slider-thumb
+    top: calc(var(--v-slider-thumb-position) - var(--v-slider-thumb-size) / 2)
+
+  .v-slider-thumb__label-container
+    top: calc(var(--v-slider-thumb-size) / 2)
+    right: 0
+
+  .v-slider-thumb__label
+    top: math.div($slider-thumb-label-height, -2)
+    left: $slider-thumb-label-offset
+
+    &::before
+      border-right: $slider-thumb-label-wedge-size solid currentColor
+      border-top: $slider-thumb-label-wedge-size solid transparent
+      border-bottom: $slider-thumb-label-wedge-size solid transparent
+      left: -$slider-thumb-label-wedge-size
+
+// Modifiers
+.v-slider-thumb--focused
+  .v-slider-thumb__surface::before
+    transform: scale(2)
+    opacity: $slider-thumb-focus-opacity
+
+.v-slider-thumb--pressed
+  transition: none
+
+  .v-slider-thumb__surface::before
+    opacity: $slider-thumb-pressed-opacity
+
+@media (hover: hover)
+  .v-slider-thumb:hover
+    .v-slider-thumb__surface::before
+      transform: scale(2)
+
+  .v-slider-thumb:hover:not(.v-slider-thumb--focused)
+    .v-slider-thumb__surface::before
+      opacity: $slider-thumb-hover-opacity

VApp/node_modules/vuetify/lib/components/VSlider/VSliderTrack.css

@@ -0,0 +1,163 @@
+.v-slider-track__background {
+  background-color: rgb(var(--v-theme-surface-variant));
+}
+
+.v-slider-track__fill {
+  background-color: rgb(var(--v-theme-surface-variant));
+}
+
+.v-slider-track__tick {
+  background-color: rgb(var(--v-theme-surface-variant));
+}
+.v-slider-track__tick--filled {
+  background-color: rgb(var(--v-theme-surface-light));
+}
+
+.v-slider-track {
+  border-radius: 6px;
+}
+
+.v-slider-track__background, .v-slider-track__fill {
+  position: absolute;
+  transition: 0.3s cubic-bezier(0.25, 0.8, 0.5, 1);
+  border-radius: inherit;
+}
+.v-slider--pressed .v-slider-track__background, .v-slider--pressed .v-slider-track__fill {
+  transition: none;
+}
+.v-input--error:not(.v-input--disabled) .v-slider-track__background, .v-input--error:not(.v-input--disabled) .v-slider-track__fill {
+  background-color: currentColor;
+}
+
+.v-slider-track__ticks {
+  height: 100%;
+  width: 100%;
+  position: relative;
+}
+
+.v-slider-track__tick {
+  position: absolute;
+  opacity: 0;
+  transition: 0.2s opacity cubic-bezier(0.4, 0, 0.2, 1);
+  border-radius: 2px;
+  width: var(--v-slider-tick-size);
+  height: var(--v-slider-tick-size);
+  transform: translate(calc(var(--v-slider-tick-size) / -2), calc(var(--v-slider-tick-size) / -2));
+}
+.v-locale--is-ltr.v-slider-track__tick--first .v-slider-track__tick-label, .v-locale--is-ltr .v-slider-track__tick--first .v-slider-track__tick-label {
+  transform: none;
+}
+
+.v-locale--is-rtl.v-slider-track__tick--first .v-slider-track__tick-label, .v-locale--is-rtl .v-slider-track__tick--first .v-slider-track__tick-label {
+  transform: translateX(100%);
+}
+
+.v-locale--is-ltr.v-slider-track__tick--last .v-slider-track__tick-label, .v-locale--is-ltr .v-slider-track__tick--last .v-slider-track__tick-label {
+  transform: translateX(-100%);
+}
+
+.v-locale--is-rtl.v-slider-track__tick--last .v-slider-track__tick-label, .v-locale--is-rtl .v-slider-track__tick--last .v-slider-track__tick-label {
+  transform: none;
+}
+
+.v-slider-track__tick-label {
+  position: absolute;
+  user-select: none;
+  white-space: nowrap;
+}
+
+.v-slider.v-input--horizontal .v-slider-track {
+  display: flex;
+  align-items: center;
+  width: 100%;
+  height: calc(var(--v-slider-track-size) + 2px);
+  touch-action: pan-y;
+}
+.v-slider.v-input--horizontal .v-slider-track__background {
+  height: var(--v-slider-track-size);
+}
+.v-slider.v-input--horizontal .v-slider-track__fill {
+  height: inherit;
+}
+.v-slider.v-input--horizontal .v-slider-track__tick {
+  margin-top: calc(calc(var(--v-slider-track-size) + 2px) / 2);
+}
+.v-locale--is-rtl.v-slider.v-input--horizontal .v-slider-track__tick, .v-locale--is-rtl .v-slider.v-input--horizontal .v-slider-track__tick {
+  transform: translate(calc(var(--v-slider-tick-size) / 2), calc(var(--v-slider-tick-size) / -2));
+}
+
+.v-slider.v-input--horizontal .v-slider-track__tick .v-slider-track__tick-label {
+  margin-top: calc(var(--v-slider-track-size) / 2 + 8px);
+}
+.v-locale--is-ltr.v-slider.v-input--horizontal .v-slider-track__tick .v-slider-track__tick-label, .v-locale--is-ltr .v-slider.v-input--horizontal .v-slider-track__tick .v-slider-track__tick-label {
+  transform: translateX(-50%);
+}
+
+.v-locale--is-rtl.v-slider.v-input--horizontal .v-slider-track__tick .v-slider-track__tick-label, .v-locale--is-rtl .v-slider.v-input--horizontal .v-slider-track__tick .v-slider-track__tick-label {
+  transform: translateX(50%);
+}
+
+.v-slider.v-input--horizontal .v-slider-track__tick--first {
+  margin-inline-start: calc(var(--v-slider-tick-size) + 1px);
+}
+.v-locale--is-ltr.v-slider.v-input--horizontal .v-slider-track__tick--first .v-slider-track__tick-label, .v-locale--is-ltr .v-slider.v-input--horizontal .v-slider-track__tick--first .v-slider-track__tick-label {
+  transform: translateX(0%);
+}
+
+.v-locale--is-rtl.v-slider.v-input--horizontal .v-slider-track__tick--first .v-slider-track__tick-label, .v-locale--is-rtl .v-slider.v-input--horizontal .v-slider-track__tick--first .v-slider-track__tick-label {
+  transform: translateX(0%);
+}
+
+.v-slider.v-input--horizontal .v-slider-track__tick--last {
+  margin-inline-start: calc(100% - var(--v-slider-tick-size) - 1px);
+}
+.v-locale--is-ltr.v-slider.v-input--horizontal .v-slider-track__tick--last .v-slider-track__tick-label, .v-locale--is-ltr .v-slider.v-input--horizontal .v-slider-track__tick--last .v-slider-track__tick-label {
+  transform: translateX(-100%);
+}
+
+.v-locale--is-rtl.v-slider.v-input--horizontal .v-slider-track__tick--last .v-slider-track__tick-label, .v-locale--is-rtl .v-slider.v-input--horizontal .v-slider-track__tick--last .v-slider-track__tick-label {
+  transform: translateX(100%);
+}
+
+.v-slider.v-input--vertical .v-slider-track {
+  height: 100%;
+  display: flex;
+  justify-content: center;
+  width: calc(var(--v-slider-track-size) + 2px);
+  touch-action: pan-x;
+}
+.v-slider.v-input--vertical .v-slider-track__background {
+  width: var(--v-slider-track-size);
+}
+.v-slider.v-input--vertical .v-slider-track__fill {
+  width: inherit;
+}
+.v-slider.v-input--vertical .v-slider-track__ticks {
+  height: 100%;
+}
+.v-slider.v-input--vertical .v-slider-track__tick {
+  margin-inline-start: calc(calc(var(--v-slider-track-size) + 2px) / 2);
+  transform: translate(calc(var(--v-slider-tick-size) / -2), calc(var(--v-slider-tick-size) / 2));
+}
+.v-locale--is-rtl.v-slider.v-input--vertical .v-slider-track__tick, .v-locale--is-rtl .v-slider.v-input--vertical .v-slider-track__tick {
+  transform: translate(calc(var(--v-slider-tick-size) / 2), calc(var(--v-slider-tick-size) / 2));
+}
+
+.v-slider.v-input--vertical .v-slider-track__tick--first {
+  bottom: calc(0% + var(--v-slider-tick-size) + 1px);
+}
+.v-slider.v-input--vertical .v-slider-track__tick--last {
+  bottom: calc(100% - var(--v-slider-tick-size) - 1px);
+}
+.v-slider.v-input--vertical .v-slider-track__tick .v-slider-track__tick-label {
+  margin-inline-start: calc(var(--v-slider-track-size) / 2 + 12px);
+  transform: translateY(-50%);
+}
+
+.v-slider-track__ticks--always-show .v-slider-track__tick, .v-slider--focused .v-slider-track__tick {
+  opacity: 1;
+}
+
+.v-slider-track__background--opacity {
+  opacity: 0.38;
+}

VApp/node_modules/vuetify/lib/components/VSlider/VSliderTrack.mjs

@@ -0,0 +1,126 @@
+import { createVNode as _createVNode } from "vue";
+// Styles
+import "./VSliderTrack.css";
+
+// Components
+import { VSliderSymbol } from "./slider.mjs"; // Composables
+import { useBackgroundColor } from "../../composables/color.mjs";
+import { makeComponentProps } from "../../composables/component.mjs";
+import { useRounded } from "../../composables/rounded.mjs"; // Utilities
+import { computed, inject } from 'vue';
+import { convertToUnit, genericComponent, propsFactory, useRender } from "../../util/index.mjs"; // Types
+export const makeVSliderTrackProps = propsFactory({
+  start: {
+    type: Number,
+    required: true
+  },
+  stop: {
+    type: Number,
+    required: true
+  },
+  ...makeComponentProps()
+}, 'VSliderTrack');
+export const VSliderTrack = genericComponent()({
+  name: 'VSliderTrack',
+  props: makeVSliderTrackProps(),
+  emits: {},
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    const slider = inject(VSliderSymbol);
+    if (!slider) throw new Error('[Vuetify] v-slider-track must be inside v-slider or v-range-slider');
+    const {
+      color,
+      parsedTicks,
+      rounded,
+      showTicks,
+      tickSize,
+      trackColor,
+      trackFillColor,
+      trackSize,
+      vertical,
+      min,
+      max,
+      indexFromEnd
+    } = slider;
+    const {
+      roundedClasses
+    } = useRounded(rounded);
+    const {
+      backgroundColorClasses: trackFillColorClasses,
+      backgroundColorStyles: trackFillColorStyles
+    } = useBackgroundColor(trackFillColor);
+    const {
+      backgroundColorClasses: trackColorClasses,
+      backgroundColorStyles: trackColorStyles
+    } = useBackgroundColor(trackColor);
+    const startDir = computed(() => `inset-${vertical.value ? 'block' : 'inline'}-${indexFromEnd.value ? 'end' : 'start'}`);
+    const endDir = computed(() => vertical.value ? 'height' : 'width');
+    const backgroundStyles = computed(() => {
+      return {
+        [startDir.value]: '0%',
+        [endDir.value]: '100%'
+      };
+    });
+    const trackFillWidth = computed(() => props.stop - props.start);
+    const trackFillStyles = computed(() => {
+      return {
+        [startDir.value]: convertToUnit(props.start, '%'),
+        [endDir.value]: convertToUnit(trackFillWidth.value, '%')
+      };
+    });
+    const computedTicks = computed(() => {
+      if (!showTicks.value) return [];
+      const ticks = vertical.value ? parsedTicks.value.slice().reverse() : parsedTicks.value;
+      return ticks.map((tick, index) => {
+        const directionValue = tick.value !== min.value && tick.value !== max.value ? convertToUnit(tick.position, '%') : undefined;
+        return _createVNode("div", {
+          "key": tick.value,
+          "class": ['v-slider-track__tick', {
+            'v-slider-track__tick--filled': tick.position >= props.start && tick.position <= props.stop,
+            'v-slider-track__tick--first': tick.value === min.value,
+            'v-slider-track__tick--last': tick.value === max.value
+          }],
+          "style": {
+            [startDir.value]: directionValue
+          }
+        }, [(tick.label || slots['tick-label']) && _createVNode("div", {
+          "class": "v-slider-track__tick-label"
+        }, [slots['tick-label']?.({
+          tick,
+          index
+        }) ?? tick.label])]);
+      });
+    });
+    useRender(() => {
+      return _createVNode("div", {
+        "class": ['v-slider-track', roundedClasses.value, props.class],
+        "style": [{
+          '--v-slider-track-size': convertToUnit(trackSize.value),
+          '--v-slider-tick-size': convertToUnit(tickSize.value)
+        }, props.style]
+      }, [_createVNode("div", {
+        "class": ['v-slider-track__background', trackColorClasses.value, {
+          'v-slider-track__background--opacity': !!color.value || !trackFillColor.value
+        }],
+        "style": {
+          ...backgroundStyles.value,
+          ...trackColorStyles.value
+        }
+      }, null), _createVNode("div", {
+        "class": ['v-slider-track__fill', trackFillColorClasses.value],
+        "style": {
+          ...trackFillStyles.value,
+          ...trackFillColorStyles.value
+        }
+      }, null), showTicks.value && _createVNode("div", {
+        "class": ['v-slider-track__ticks', {
+          'v-slider-track__ticks--always-show': showTicks.value === 'always'
+        }]
+      }, [computedTicks.value])]);
+    });
+    return {};
+  }
+});
+//# sourceMappingURL=VSliderTrack.mjs.map

VApp/node_modules/vuetify/lib/components/VSlider/VSliderTrack.sass

@@ -0,0 +1,159 @@
+@use 'sass:map'
+@use 'sass:selector'
+@use '../../styles/settings'
+@use '../../styles/tools'
+@use './variables' as *
+
+// Theme
+.v-slider-track__background
+  background-color: rgb(var(--v-theme-surface-variant))
+
+.v-slider-track__fill
+  background-color: rgb(var(--v-theme-surface-variant))
+
+.v-slider-track__tick
+  background-color: rgb(var(--v-theme-surface-variant))
+
+  &--filled
+    background-color: $slider-tick-background
+
+// Elements
+.v-slider-track
+  border-radius: $slider-track-border-radius
+
+.v-slider-track
+  &__background, &__fill
+    position: absolute
+    transition: $slider-transition
+    border-radius: inherit
+
+    .v-slider--pressed &
+      transition: none
+
+    .v-input--error:not(.v-input--disabled) &
+      background-color: currentColor
+
+.v-slider-track__ticks
+  height: 100%
+  width: 100%
+  position: relative
+
+.v-slider-track__tick
+  position: absolute
+  opacity: 0
+  transition: 0.2s opacity settings.$standard-easing
+  border-radius: $slider-tick-border-radius
+  width: var(--v-slider-tick-size)
+  height: var(--v-slider-tick-size)
+  transform: translate(calc(var(--v-slider-tick-size) / -2), calc(var(--v-slider-tick-size) / -2))
+
+  &--first .v-slider-track__tick-label
+    @include tools.ltr()
+      transform: none
+
+    @include tools.rtl()
+      transform: translateX(100%)
+
+  &--last .v-slider-track__tick-label
+    @include tools.ltr()
+      transform: translateX(-100%)
+
+    @include tools.rtl()
+      transform: none
+
+.v-slider-track__tick-label
+  position: absolute
+  user-select: none
+  white-space: nowrap
+
+// Horizontal
+.v-slider.v-input--horizontal
+  .v-slider-track
+    display: flex
+    align-items: center
+    width: 100%
+    height: $slider-track-active-size
+    touch-action: pan-y
+
+    &__background
+      height: var(--v-slider-track-size)
+
+    &__fill
+      height: inherit
+
+  .v-slider-track__tick
+    margin-top: calc(#{$slider-track-active-size} / 2)
+
+    @include tools.rtl()
+      transform: translate(calc(var(--v-slider-tick-size) / 2), calc(var(--v-slider-tick-size) / -2))
+
+    .v-slider-track__tick-label
+      margin-top: calc(var(--v-slider-track-size) / 2 + #{$slider-tick-label-margin-top})
+
+      @include tools.ltr()
+        transform: translateX(-50%)
+
+      @include tools.rtl()
+        transform: translateX(50%)
+
+    &--first
+      margin-inline-start: calc(var(--v-slider-tick-size) + 1px)
+
+      .v-slider-track__tick-label
+        @include tools.ltr()
+          transform: translateX(0%)
+
+        @include tools.rtl()
+          transform: translateX(0%)
+
+    &--last
+      margin-inline-start: calc(100% - var(--v-slider-tick-size) - 1px)
+
+      .v-slider-track__tick-label
+        @include tools.ltr()
+          transform: translateX(-100%)
+
+        @include tools.rtl()
+          transform: translateX(100%)
+
+// Vertical
+.v-slider.v-input--vertical
+  .v-slider-track
+    height: 100%
+    display: flex
+    justify-content: center
+    width: $slider-track-active-size
+    touch-action: pan-x
+
+    &__background
+      width: var(--v-slider-track-size)
+
+    &__fill
+      width: inherit
+
+  .v-slider-track__ticks
+    height: 100%
+
+  .v-slider-track__tick
+    margin-inline-start: calc(#{$slider-track-active-size} / 2)
+    transform: translate(calc(var(--v-slider-tick-size) / -2), calc(var(--v-slider-tick-size) / 2))
+
+    @include tools.rtl()
+      transform: translate(calc(var(--v-slider-tick-size) / 2), calc(var(--v-slider-tick-size) / 2))
+
+    &--first
+      bottom: calc(0% + var(--v-slider-tick-size) + 1px)
+    &--last
+      bottom: calc(100% - var(--v-slider-tick-size) - 1px)
+
+    .v-slider-track__tick-label
+      margin-inline-start: calc(var(--v-slider-track-size) / 2 + #{$slider-tick-label-margin-start})
+      transform: translateY(-50%)
+
+// Modifiers
+.v-slider-track__ticks--always-show, .v-slider--focused
+  .v-slider-track__tick
+    opacity: 1
+
+.v-slider-track__background--opacity
+  opacity: 0.38

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

@@ -0,0 +1,35 @@
+@use '../../styles/settings';
+@use '../../styles/tools';
+
+$slider-horizontal-start: 8px !default;
+$slider-horizontal-min-height: 32px !default;
+$slider-horizontal-end: 8px !default;
+$slider-label-margin-end: 12px !default;
+$slider-label-margin-start: 12px !default;
+$slider-state-track-background-opacity: 0.4 !default;
+$slider-thumb-hover-opacity: var(--v-hover-opacity) !default;
+$slider-thumb-focus-opacity: var(--v-focus-opacity) !default;
+$slider-thumb-pressed-opacity: var(--v-pressed-opacity) !default;
+$slider-thumb-border-radius: 50% !default;
+$slider-thumb-focused-size-increase: 24px !default;
+$slider-thumb-label-font-size: tools.map-deep-get(settings.$typography, 'caption', 'size') !default;
+$slider-thumb-label-border-radius: 4px !default;
+$slider-thumb-label-height: 25px !default;
+$slider-thumb-label-min-width: 35px !default;
+$slider-thumb-label-wedge-size: 6px !default;
+$slider-thumb-label-offset: calc(var(--v-slider-thumb-size) / 2) !default;
+$slider-thumb-label-transition: .2s settings.$accelerated-easing !default;
+$slider-thumb-label-padding: 6px !default;
+$slider-thumb-touch-size: 42px !default;
+$slider-tick-background: rgb(var(--v-theme-surface-light)) !default;
+$slider-tick-border-radius: 2px !default;
+$slider-tick-label-margin-top: 8px !default;
+$slider-tick-label-margin-start: 12px !default;
+$slider-track-border-radius: 6px !default;
+$slider-track-active-size-offset: 2px !default;
+$slider-transition: .3s cubic-bezier(0.25, 0.8, 0.5, 1) !default;
+$slider-vertical-margin-bottom: 12px !default;
+$slider-vertical-margin-top: 12px !default;
+$slider-vertical-min-height: 300px !default;
+
+$slider-track-active-size: calc(var(--v-slider-track-size) + #{$slider-track-active-size-offset}) !default;

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

@@ -0,0 +1,839 @@
+import * as vue from 'vue';
+import { ComponentPropsOptions, ExtractPropTypes, JSXComponent, PropType, ComputedRef, Ref } from 'vue';
+
+interface FilterPropsOptions<PropsOptions extends Readonly<ComponentPropsOptions>, Props = ExtractPropTypes<PropsOptions>> {
+    filterProps<T extends Partial<Props>, U extends Exclude<keyof Props, Exclude<keyof Props, keyof T>>>(props: T): Partial<Pick<T, U>>;
+}
+
+type Tick = {
+    value: number;
+    position: number;
+    label?: string;
+};
+
+type VMessageSlot = {
+    message: string;
+};
+
+type IconValue = string | (string | [path: string, opacity: number])[] | JSXComponent;
+declare const IconValue: PropType<IconValue>;
+
+type Density = null | 'default' | 'comfortable' | 'compact';
+
+type ValidationResult = string | boolean;
+type ValidationRule = ValidationResult | PromiseLike<ValidationResult> | ((value: any) => ValidationResult) | ((value: any) => PromiseLike<ValidationResult>);
+
+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;
+}
+
+declare const VSlider: {
+    new (...args: any[]): vue.CreateComponentPublicInstance<{
+        reverse: boolean;
+        max: string | number;
+        error: boolean;
+        min: string | number;
+        direction: "horizontal" | "vertical";
+        style: vue.StyleValue;
+        disabled: boolean | null;
+        readonly: boolean | null;
+        step: string | number;
+        elevation: NonNullable<string | number>;
+        messages: string | readonly string[];
+        density: Density;
+        modelValue: string | number;
+        ripple: boolean;
+        focused: boolean;
+        errorMessages: string | readonly string[] | null;
+        maxErrors: string | number;
+        rules: readonly ValidationRule[];
+        centerAffix: boolean;
+        hideSpinButtons: boolean;
+        persistentHint: boolean;
+        showTicks: boolean | "always";
+        tickSize: string | number;
+        trackSize: string | number;
+        thumbSize: string | number;
+    } & {
+        id?: string | undefined;
+        name?: string | undefined;
+        color?: string | undefined;
+        label?: string | undefined;
+        class?: any;
+        rounded?: string | number | boolean | undefined;
+        prependIcon?: IconValue | undefined;
+        appendIcon?: IconValue | undefined;
+        '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;
+        trackColor?: string | undefined;
+        trackFillColor?: string | undefined;
+        thumbColor?: string | undefined;
+        thumbLabel?: boolean | "always" | undefined;
+        ticks?: readonly number[] | Record<number, string> | undefined;
+    } & {
+        $children?: vue.VNodeChild | ((arg: VInputSlot) => vue.VNodeChild) | {
+            default?: ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+            prepend?: ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+            append?: ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+            details?: ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+            message?: ((arg: VMessageSlot) => vue.VNodeChild) | undefined;
+            'thumb-label'?: ((arg: {
+                modelValue: number;
+            }) => vue.VNodeChild) | undefined;
+            'tick-label'?: ((arg: {
+                tick: Tick;
+                index: number;
+            }) => vue.VNodeChild) | undefined;
+            label?: ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+        };
+        'v-slots'?: {
+            default?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+            prepend?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+            append?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+            details?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+            message?: false | ((arg: VMessageSlot) => vue.VNodeChild) | undefined;
+            'thumb-label'?: false | ((arg: {
+                modelValue: number;
+            }) => vue.VNodeChild) | undefined;
+            'tick-label'?: false | ((arg: {
+                tick: Tick;
+                index: number;
+            }) => vue.VNodeChild) | undefined;
+            label?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:default"?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+        "v-slot:prepend"?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+        "v-slot:append"?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+        "v-slot:details"?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+        "v-slot:message"?: false | ((arg: VMessageSlot) => vue.VNodeChild) | undefined;
+        "v-slot:thumb-label"?: false | ((arg: {
+            modelValue: number;
+        }) => vue.VNodeChild) | undefined;
+        "v-slot:tick-label"?: false | ((arg: {
+            tick: Tick;
+            index: number;
+        }) => vue.VNodeChild) | undefined;
+        "v-slot:label"?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+    } & {
+        "onUpdate:modelValue"?: ((v: number) => any) | undefined;
+        "onUpdate:focused"?: ((value: boolean) => any) | undefined;
+        onEnd?: ((value: number) => any) | undefined;
+        onStart?: ((value: number) => any) | undefined;
+    }, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+        'update:focused': (value: boolean) => true;
+        'update:modelValue': (v: number) => true;
+        start: (value: number) => true;
+        end: (value: number) => true;
+    }, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & {
+        reverse: boolean;
+        max: string | number;
+        error: boolean;
+        min: string | number;
+        direction: "horizontal" | "vertical";
+        style: vue.StyleValue;
+        disabled: boolean | null;
+        readonly: boolean | null;
+        step: string | number;
+        elevation: NonNullable<string | number>;
+        messages: string | readonly string[];
+        density: Density;
+        modelValue: string | number;
+        ripple: boolean;
+        focused: boolean;
+        errorMessages: string | readonly string[] | null;
+        maxErrors: string | number;
+        rules: readonly ValidationRule[];
+        centerAffix: boolean;
+        hideSpinButtons: boolean;
+        persistentHint: boolean;
+        showTicks: boolean | "always";
+        tickSize: string | number;
+        trackSize: string | number;
+        thumbSize: string | number;
+    } & {
+        id?: string | undefined;
+        name?: string | undefined;
+        color?: string | undefined;
+        label?: string | undefined;
+        class?: any;
+        rounded?: string | number | boolean | undefined;
+        prependIcon?: IconValue | undefined;
+        appendIcon?: IconValue | undefined;
+        '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;
+        trackColor?: string | undefined;
+        trackFillColor?: string | undefined;
+        thumbColor?: string | undefined;
+        thumbLabel?: boolean | "always" | undefined;
+        ticks?: readonly number[] | Record<number, string> | undefined;
+    } & {
+        $children?: vue.VNodeChild | ((arg: VInputSlot) => vue.VNodeChild) | {
+            default?: ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+            prepend?: ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+            append?: ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+            details?: ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+            message?: ((arg: VMessageSlot) => vue.VNodeChild) | undefined;
+            'thumb-label'?: ((arg: {
+                modelValue: number;
+            }) => vue.VNodeChild) | undefined;
+            'tick-label'?: ((arg: {
+                tick: Tick;
+                index: number;
+            }) => vue.VNodeChild) | undefined;
+            label?: ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+        };
+        'v-slots'?: {
+            default?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+            prepend?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+            append?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+            details?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+            message?: false | ((arg: VMessageSlot) => vue.VNodeChild) | undefined;
+            'thumb-label'?: false | ((arg: {
+                modelValue: number;
+            }) => vue.VNodeChild) | undefined;
+            'tick-label'?: false | ((arg: {
+                tick: Tick;
+                index: number;
+            }) => vue.VNodeChild) | undefined;
+            label?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:default"?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+        "v-slot:prepend"?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+        "v-slot:append"?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+        "v-slot:details"?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+        "v-slot:message"?: false | ((arg: VMessageSlot) => vue.VNodeChild) | undefined;
+        "v-slot:thumb-label"?: false | ((arg: {
+            modelValue: number;
+        }) => vue.VNodeChild) | undefined;
+        "v-slot:tick-label"?: false | ((arg: {
+            tick: Tick;
+            index: number;
+        }) => vue.VNodeChild) | undefined;
+        "v-slot:label"?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+    } & {
+        "onUpdate:modelValue"?: ((v: number) => any) | undefined;
+        "onUpdate:focused"?: ((value: boolean) => any) | undefined;
+        onEnd?: ((value: number) => any) | undefined;
+        onStart?: ((value: number) => any) | undefined;
+    }, {
+        reverse: boolean;
+        max: string | number;
+        error: boolean;
+        min: string | number;
+        direction: "horizontal" | "vertical";
+        style: vue.StyleValue;
+        disabled: boolean | null;
+        readonly: boolean | null;
+        step: string | number;
+        elevation: NonNullable<string | number>;
+        messages: string | readonly string[];
+        rounded: string | number | boolean;
+        density: Density;
+        modelValue: string | number;
+        ripple: boolean;
+        focused: boolean;
+        errorMessages: string | readonly string[] | null;
+        maxErrors: string | number;
+        rules: readonly ValidationRule[];
+        centerAffix: boolean;
+        hideSpinButtons: boolean;
+        persistentHint: boolean;
+        showTicks: boolean | "always";
+        tickSize: string | number;
+        trackSize: string | number;
+        thumbLabel: boolean | "always" | undefined;
+        thumbSize: string | number;
+    }, true, {}, vue.SlotsType<Partial<{
+        default: (arg: VInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        prepend: (arg: VInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        append: (arg: VInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        details: (arg: VInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        message: (arg: VMessageSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        'thumb-label': (arg: {
+            modelValue: number;
+        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        'tick-label': (arg: {
+            tick: Tick;
+            index: number;
+        }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+        label: (arg: VInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+            [key: string]: any;
+        }>[];
+    }>>, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, {
+        reverse: boolean;
+        max: string | number;
+        error: boolean;
+        min: string | number;
+        direction: "horizontal" | "vertical";
+        style: vue.StyleValue;
+        disabled: boolean | null;
+        readonly: boolean | null;
+        step: string | number;
+        elevation: NonNullable<string | number>;
+        messages: string | readonly string[];
+        density: Density;
+        modelValue: string | number;
+        ripple: boolean;
+        focused: boolean;
+        errorMessages: string | readonly string[] | null;
+        maxErrors: string | number;
+        rules: readonly ValidationRule[];
+        centerAffix: boolean;
+        hideSpinButtons: boolean;
+        persistentHint: boolean;
+        showTicks: boolean | "always";
+        tickSize: string | number;
+        trackSize: string | number;
+        thumbSize: string | number;
+    } & {
+        id?: string | undefined;
+        name?: string | undefined;
+        color?: string | undefined;
+        label?: string | undefined;
+        class?: any;
+        rounded?: string | number | boolean | undefined;
+        prependIcon?: IconValue | undefined;
+        appendIcon?: IconValue | undefined;
+        '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;
+        trackColor?: string | undefined;
+        trackFillColor?: string | undefined;
+        thumbColor?: string | undefined;
+        thumbLabel?: boolean | "always" | undefined;
+        ticks?: readonly number[] | Record<number, string> | undefined;
+    } & {
+        $children?: vue.VNodeChild | ((arg: VInputSlot) => vue.VNodeChild) | {
+            default?: ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+            prepend?: ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+            append?: ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+            details?: ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+            message?: ((arg: VMessageSlot) => vue.VNodeChild) | undefined;
+            'thumb-label'?: ((arg: {
+                modelValue: number;
+            }) => vue.VNodeChild) | undefined;
+            'tick-label'?: ((arg: {
+                tick: Tick;
+                index: number;
+            }) => vue.VNodeChild) | undefined;
+            label?: ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+        };
+        'v-slots'?: {
+            default?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+            prepend?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+            append?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+            details?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+            message?: false | ((arg: VMessageSlot) => vue.VNodeChild) | undefined;
+            'thumb-label'?: false | ((arg: {
+                modelValue: number;
+            }) => vue.VNodeChild) | undefined;
+            'tick-label'?: false | ((arg: {
+                tick: Tick;
+                index: number;
+            }) => vue.VNodeChild) | undefined;
+            label?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+        } | undefined;
+    } & {
+        "v-slot:default"?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+        "v-slot:prepend"?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+        "v-slot:append"?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+        "v-slot:details"?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+        "v-slot:message"?: false | ((arg: VMessageSlot) => vue.VNodeChild) | undefined;
+        "v-slot:thumb-label"?: false | ((arg: {
+            modelValue: number;
+        }) => vue.VNodeChild) | undefined;
+        "v-slot:tick-label"?: false | ((arg: {
+            tick: Tick;
+            index: number;
+        }) => vue.VNodeChild) | undefined;
+        "v-slot:label"?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+    } & {
+        "onUpdate:modelValue"?: ((v: number) => any) | undefined;
+        "onUpdate:focused"?: ((value: boolean) => any) | undefined;
+        onEnd?: ((value: number) => any) | undefined;
+        onStart?: ((value: number) => any) | undefined;
+    }, {}, {}, {}, {}, {
+        reverse: boolean;
+        max: string | number;
+        error: boolean;
+        min: string | number;
+        direction: "horizontal" | "vertical";
+        style: vue.StyleValue;
+        disabled: boolean | null;
+        readonly: boolean | null;
+        step: string | number;
+        elevation: NonNullable<string | number>;
+        messages: string | readonly string[];
+        rounded: string | number | boolean;
+        density: Density;
+        modelValue: string | number;
+        ripple: boolean;
+        focused: boolean;
+        errorMessages: string | readonly string[] | null;
+        maxErrors: string | number;
+        rules: readonly ValidationRule[];
+        centerAffix: boolean;
+        hideSpinButtons: boolean;
+        persistentHint: boolean;
+        showTicks: boolean | "always";
+        tickSize: string | number;
+        trackSize: string | number;
+        thumbLabel: boolean | "always" | undefined;
+        thumbSize: string | number;
+    }>;
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+} & vue.ComponentOptionsBase<{
+    reverse: boolean;
+    max: string | number;
+    error: boolean;
+    min: string | number;
+    direction: "horizontal" | "vertical";
+    style: vue.StyleValue;
+    disabled: boolean | null;
+    readonly: boolean | null;
+    step: string | number;
+    elevation: NonNullable<string | number>;
+    messages: string | readonly string[];
+    density: Density;
+    modelValue: string | number;
+    ripple: boolean;
+    focused: boolean;
+    errorMessages: string | readonly string[] | null;
+    maxErrors: string | number;
+    rules: readonly ValidationRule[];
+    centerAffix: boolean;
+    hideSpinButtons: boolean;
+    persistentHint: boolean;
+    showTicks: boolean | "always";
+    tickSize: string | number;
+    trackSize: string | number;
+    thumbSize: string | number;
+} & {
+    id?: string | undefined;
+    name?: string | undefined;
+    color?: string | undefined;
+    label?: string | undefined;
+    class?: any;
+    rounded?: string | number | boolean | undefined;
+    prependIcon?: IconValue | undefined;
+    appendIcon?: IconValue | undefined;
+    '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;
+    trackColor?: string | undefined;
+    trackFillColor?: string | undefined;
+    thumbColor?: string | undefined;
+    thumbLabel?: boolean | "always" | undefined;
+    ticks?: readonly number[] | Record<number, string> | undefined;
+} & {
+    $children?: vue.VNodeChild | ((arg: VInputSlot) => vue.VNodeChild) | {
+        default?: ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+        prepend?: ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+        append?: ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+        details?: ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+        message?: ((arg: VMessageSlot) => vue.VNodeChild) | undefined;
+        'thumb-label'?: ((arg: {
+            modelValue: number;
+        }) => vue.VNodeChild) | undefined;
+        'tick-label'?: ((arg: {
+            tick: Tick;
+            index: number;
+        }) => vue.VNodeChild) | undefined;
+        label?: ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+    };
+    'v-slots'?: {
+        default?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+        prepend?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+        append?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+        details?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+        message?: false | ((arg: VMessageSlot) => vue.VNodeChild) | undefined;
+        'thumb-label'?: false | ((arg: {
+            modelValue: number;
+        }) => vue.VNodeChild) | undefined;
+        'tick-label'?: false | ((arg: {
+            tick: Tick;
+            index: number;
+        }) => vue.VNodeChild) | undefined;
+        label?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+    } | undefined;
+} & {
+    "v-slot:default"?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+    "v-slot:prepend"?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+    "v-slot:append"?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+    "v-slot:details"?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+    "v-slot:message"?: false | ((arg: VMessageSlot) => vue.VNodeChild) | undefined;
+    "v-slot:thumb-label"?: false | ((arg: {
+        modelValue: number;
+    }) => vue.VNodeChild) | undefined;
+    "v-slot:tick-label"?: false | ((arg: {
+        tick: Tick;
+        index: number;
+    }) => vue.VNodeChild) | undefined;
+    "v-slot:label"?: false | ((arg: VInputSlot) => vue.VNodeChild) | undefined;
+} & {
+    "onUpdate:modelValue"?: ((v: number) => any) | undefined;
+    "onUpdate:focused"?: ((value: boolean) => any) | undefined;
+    onEnd?: ((value: number) => any) | undefined;
+    onStart?: ((value: number) => any) | undefined;
+}, {}, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    'update:focused': (value: boolean) => true;
+    'update:modelValue': (v: number) => true;
+    start: (value: number) => true;
+    end: (value: number) => true;
+}, string, {
+    reverse: boolean;
+    max: string | number;
+    error: boolean;
+    min: string | number;
+    direction: "horizontal" | "vertical";
+    style: vue.StyleValue;
+    disabled: boolean | null;
+    readonly: boolean | null;
+    step: string | number;
+    elevation: NonNullable<string | number>;
+    messages: string | readonly string[];
+    rounded: string | number | boolean;
+    density: Density;
+    modelValue: string | number;
+    ripple: boolean;
+    focused: boolean;
+    errorMessages: string | readonly string[] | null;
+    maxErrors: string | number;
+    rules: readonly ValidationRule[];
+    centerAffix: boolean;
+    hideSpinButtons: boolean;
+    persistentHint: boolean;
+    showTicks: boolean | "always";
+    tickSize: string | number;
+    trackSize: string | number;
+    thumbLabel: boolean | "always" | undefined;
+    thumbSize: string | number;
+}, {}, string, vue.SlotsType<Partial<{
+    default: (arg: VInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    prepend: (arg: VInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    append: (arg: VInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    details: (arg: VInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    message: (arg: VMessageSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    'thumb-label': (arg: {
+        modelValue: number;
+    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    'tick-label': (arg: {
+        tick: Tick;
+        index: number;
+    }) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+    label: (arg: VInputSlot) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>[];
+}>>> & vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps & FilterPropsOptions<{
+    modelValue: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    focused: BooleanConstructor;
+    'onUpdate:focused': vue.PropType<(args_0: boolean) => void>;
+    disabled: {
+        type: vue.PropType<boolean | null>;
+        default: null;
+    };
+    error: BooleanConstructor;
+    errorMessages: {
+        type: vue.PropType<string | readonly string[] | null>;
+        default: () => never[];
+    };
+    maxErrors: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    name: StringConstructor;
+    label: StringConstructor;
+    readonly: {
+        type: vue.PropType<boolean | null>;
+        default: null;
+    };
+    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;
+    density: {
+        type: vue.PropType<Density>;
+        default: string;
+        validator: (v: any) => boolean;
+    };
+    class: vue.PropType<any>;
+    style: {
+        type: vue.PropType<vue.StyleValue>;
+        default: null;
+    };
+    id: StringConstructor;
+    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>;
+    ripple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    elevation: Omit<{
+        type: (StringConstructor | NumberConstructor)[];
+        validator(v: any): boolean;
+    }, "type" | "default"> & {
+        type: vue.PropType<NonNullable<string | number>>;
+        default: NonNullable<string | number>;
+    };
+    rounded: {
+        type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    max: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    min: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    step: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    thumbColor: StringConstructor;
+    thumbLabel: {
+        type: vue.PropType<boolean | "always" | undefined>;
+        default: undefined;
+        validator: (v: any) => boolean;
+    };
+    thumbSize: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    showTicks: {
+        type: vue.PropType<boolean | "always">;
+        default: boolean;
+        validator: (v: any) => boolean;
+    };
+    ticks: {
+        type: vue.PropType<readonly number[] | Record<number, string>>;
+    };
+    tickSize: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    color: StringConstructor;
+    trackColor: StringConstructor;
+    trackFillColor: StringConstructor;
+    trackSize: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    reverse: BooleanConstructor;
+}, vue.ExtractPropTypes<{
+    modelValue: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    focused: BooleanConstructor;
+    'onUpdate:focused': vue.PropType<(args_0: boolean) => void>;
+    disabled: {
+        type: vue.PropType<boolean | null>;
+        default: null;
+    };
+    error: BooleanConstructor;
+    errorMessages: {
+        type: vue.PropType<string | readonly string[] | null>;
+        default: () => never[];
+    };
+    maxErrors: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    name: StringConstructor;
+    label: StringConstructor;
+    readonly: {
+        type: vue.PropType<boolean | null>;
+        default: null;
+    };
+    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;
+    density: {
+        type: vue.PropType<Density>;
+        default: string;
+        validator: (v: any) => boolean;
+    };
+    class: vue.PropType<any>;
+    style: {
+        type: vue.PropType<vue.StyleValue>;
+        default: null;
+    };
+    id: StringConstructor;
+    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>;
+    ripple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    elevation: Omit<{
+        type: (StringConstructor | NumberConstructor)[];
+        validator(v: any): boolean;
+    }, "type" | "default"> & {
+        type: vue.PropType<NonNullable<string | number>>;
+        default: NonNullable<string | number>;
+    };
+    rounded: {
+        type: (StringConstructor | BooleanConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    max: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    min: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    step: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    thumbColor: StringConstructor;
+    thumbLabel: {
+        type: vue.PropType<boolean | "always" | undefined>;
+        default: undefined;
+        validator: (v: any) => boolean;
+    };
+    thumbSize: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    showTicks: {
+        type: vue.PropType<boolean | "always">;
+        default: boolean;
+        validator: (v: any) => boolean;
+    };
+    ticks: {
+        type: vue.PropType<readonly number[] | Record<number, string>>;
+    };
+    tickSize: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    color: StringConstructor;
+    trackColor: StringConstructor;
+    trackFillColor: StringConstructor;
+    trackSize: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    reverse: BooleanConstructor;
+}>>;
+type VSlider = InstanceType<typeof VSlider>;
+
+export { VSlider };

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

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

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

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

VApp/node_modules/vuetify/lib/components/VSlider/slider.mjs

@@ -0,0 +1,287 @@
+/* eslint-disable max-statements */
+// Composables
+import { makeElevationProps } from "../../composables/elevation.mjs";
+import { useRtl } from "../../composables/locale.mjs";
+import { makeRoundedProps } from "../../composables/rounded.mjs"; // Utilities
+import { computed, provide, ref, shallowRef, toRef } from 'vue';
+import { clamp, createRange, getDecimals, propsFactory } from "../../util/index.mjs"; // Types
+export const VSliderSymbol = Symbol.for('vuetify:v-slider');
+export function getOffset(e, el, direction) {
+  const vertical = direction === 'vertical';
+  const rect = el.getBoundingClientRect();
+  const touch = 'touches' in e ? e.touches[0] : e;
+  return vertical ? touch.clientY - (rect.top + rect.height / 2) : touch.clientX - (rect.left + rect.width / 2);
+}
+function getPosition(e, position) {
+  if ('touches' in e && e.touches.length) return e.touches[0][position];else if ('changedTouches' in e && e.changedTouches.length) return e.changedTouches[0][position];else return e[position];
+}
+export const makeSliderProps = propsFactory({
+  disabled: {
+    type: Boolean,
+    default: null
+  },
+  error: Boolean,
+  readonly: {
+    type: Boolean,
+    default: null
+  },
+  max: {
+    type: [Number, String],
+    default: 100
+  },
+  min: {
+    type: [Number, String],
+    default: 0
+  },
+  step: {
+    type: [Number, String],
+    default: 0
+  },
+  thumbColor: String,
+  thumbLabel: {
+    type: [Boolean, String],
+    default: undefined,
+    validator: v => typeof v === 'boolean' || v === 'always'
+  },
+  thumbSize: {
+    type: [Number, String],
+    default: 20
+  },
+  showTicks: {
+    type: [Boolean, String],
+    default: false,
+    validator: v => typeof v === 'boolean' || v === 'always'
+  },
+  ticks: {
+    type: [Array, Object]
+  },
+  tickSize: {
+    type: [Number, String],
+    default: 2
+  },
+  color: String,
+  trackColor: String,
+  trackFillColor: String,
+  trackSize: {
+    type: [Number, String],
+    default: 4
+  },
+  direction: {
+    type: String,
+    default: 'horizontal',
+    validator: v => ['vertical', 'horizontal'].includes(v)
+  },
+  reverse: Boolean,
+  ...makeRoundedProps(),
+  ...makeElevationProps({
+    elevation: 2
+  }),
+  ripple: {
+    type: Boolean,
+    default: true
+  }
+}, 'Slider');
+export const useSteps = props => {
+  const min = computed(() => parseFloat(props.min));
+  const max = computed(() => parseFloat(props.max));
+  const step = computed(() => +props.step > 0 ? parseFloat(props.step) : 0);
+  const decimals = computed(() => Math.max(getDecimals(step.value), getDecimals(min.value)));
+  function roundValue(value) {
+    value = parseFloat(value);
+    if (step.value <= 0) return value;
+    const clamped = clamp(value, min.value, max.value);
+    const offset = min.value % step.value;
+    const newValue = Math.round((clamped - offset) / step.value) * step.value + offset;
+    return parseFloat(Math.min(newValue, max.value).toFixed(decimals.value));
+  }
+  return {
+    min,
+    max,
+    step,
+    decimals,
+    roundValue
+  };
+};
+export const useSlider = _ref => {
+  let {
+    props,
+    steps,
+    onSliderStart,
+    onSliderMove,
+    onSliderEnd,
+    getActiveThumb
+  } = _ref;
+  const {
+    isRtl
+  } = useRtl();
+  const isReversed = toRef(props, 'reverse');
+  const vertical = computed(() => props.direction === 'vertical');
+  const indexFromEnd = computed(() => vertical.value !== isReversed.value);
+  const {
+    min,
+    max,
+    step,
+    decimals,
+    roundValue
+  } = steps;
+  const thumbSize = computed(() => parseInt(props.thumbSize, 10));
+  const tickSize = computed(() => parseInt(props.tickSize, 10));
+  const trackSize = computed(() => parseInt(props.trackSize, 10));
+  const numTicks = computed(() => (max.value - min.value) / step.value);
+  const disabled = toRef(props, 'disabled');
+  const thumbColor = computed(() => props.error || props.disabled ? undefined : props.thumbColor ?? props.color);
+  const trackColor = computed(() => props.error || props.disabled ? undefined : props.trackColor ?? props.color);
+  const trackFillColor = computed(() => props.error || props.disabled ? undefined : props.trackFillColor ?? props.color);
+  const mousePressed = shallowRef(false);
+  const startOffset = shallowRef(0);
+  const trackContainerRef = ref();
+  const activeThumbRef = ref();
+  function parseMouseMove(e) {
+    const vertical = props.direction === 'vertical';
+    const start = vertical ? 'top' : 'left';
+    const length = vertical ? 'height' : 'width';
+    const position = vertical ? 'clientY' : 'clientX';
+    const {
+      [start]: trackStart,
+      [length]: trackLength
+    } = trackContainerRef.value?.$el.getBoundingClientRect();
+    const clickOffset = getPosition(e, position);
+
+    // It is possible for left to be NaN, force to number
+    let clickPos = Math.min(Math.max((clickOffset - trackStart - startOffset.value) / trackLength, 0), 1) || 0;
+    if (vertical ? indexFromEnd.value : indexFromEnd.value !== isRtl.value) clickPos = 1 - clickPos;
+    return roundValue(min.value + clickPos * (max.value - min.value));
+  }
+  const handleStop = e => {
+    onSliderEnd({
+      value: parseMouseMove(e)
+    });
+    mousePressed.value = false;
+    startOffset.value = 0;
+  };
+  const handleStart = e => {
+    activeThumbRef.value = getActiveThumb(e);
+    if (!activeThumbRef.value) return;
+    activeThumbRef.value.focus();
+    mousePressed.value = true;
+    if (activeThumbRef.value.contains(e.target)) {
+      startOffset.value = getOffset(e, activeThumbRef.value, props.direction);
+    } else {
+      startOffset.value = 0;
+      onSliderMove({
+        value: parseMouseMove(e)
+      });
+    }
+    onSliderStart({
+      value: parseMouseMove(e)
+    });
+  };
+  const moveListenerOptions = {
+    passive: true,
+    capture: true
+  };
+  function onMouseMove(e) {
+    onSliderMove({
+      value: parseMouseMove(e)
+    });
+  }
+  function onSliderMouseUp(e) {
+    e.stopPropagation();
+    e.preventDefault();
+    handleStop(e);
+    window.removeEventListener('mousemove', onMouseMove, moveListenerOptions);
+    window.removeEventListener('mouseup', onSliderMouseUp);
+  }
+  function onSliderTouchend(e) {
+    handleStop(e);
+    window.removeEventListener('touchmove', onMouseMove, moveListenerOptions);
+    e.target?.removeEventListener('touchend', onSliderTouchend);
+  }
+  function onSliderTouchstart(e) {
+    handleStart(e);
+    window.addEventListener('touchmove', onMouseMove, moveListenerOptions);
+    e.target?.addEventListener('touchend', onSliderTouchend, {
+      passive: false
+    });
+  }
+  function onSliderMousedown(e) {
+    e.preventDefault();
+    handleStart(e);
+    window.addEventListener('mousemove', onMouseMove, moveListenerOptions);
+    window.addEventListener('mouseup', onSliderMouseUp, {
+      passive: false
+    });
+  }
+  const position = val => {
+    const percentage = (val - min.value) / (max.value - min.value) * 100;
+    return clamp(isNaN(percentage) ? 0 : percentage, 0, 100);
+  };
+  const showTicks = toRef(props, 'showTicks');
+  const parsedTicks = computed(() => {
+    if (!showTicks.value) return [];
+    if (!props.ticks) {
+      return numTicks.value !== Infinity ? createRange(numTicks.value + 1).map(t => {
+        const value = min.value + t * step.value;
+        return {
+          value,
+          position: position(value)
+        };
+      }) : [];
+    }
+    if (Array.isArray(props.ticks)) return props.ticks.map(t => ({
+      value: t,
+      position: position(t),
+      label: t.toString()
+    }));
+    return Object.keys(props.ticks).map(key => ({
+      value: parseFloat(key),
+      position: position(parseFloat(key)),
+      label: props.ticks[key]
+    }));
+  });
+  const hasLabels = computed(() => parsedTicks.value.some(_ref2 => {
+    let {
+      label
+    } = _ref2;
+    return !!label;
+  }));
+  const data = {
+    activeThumbRef,
+    color: toRef(props, 'color'),
+    decimals,
+    disabled,
+    direction: toRef(props, 'direction'),
+    elevation: toRef(props, 'elevation'),
+    hasLabels,
+    isReversed,
+    indexFromEnd,
+    min,
+    max,
+    mousePressed,
+    numTicks,
+    onSliderMousedown,
+    onSliderTouchstart,
+    parsedTicks,
+    parseMouseMove,
+    position,
+    readonly: toRef(props, 'readonly'),
+    rounded: toRef(props, 'rounded'),
+    roundValue,
+    showTicks,
+    startOffset,
+    step,
+    thumbSize,
+    thumbColor,
+    thumbLabel: toRef(props, 'thumbLabel'),
+    ticks: toRef(props, 'ticks'),
+    tickSize,
+    trackColor,
+    trackContainerRef,
+    trackFillColor,
+    trackSize,
+    vertical
+  };
+  provide(VSliderSymbol, data);
+  return data;
+};
+//# sourceMappingURL=slider.mjs.map