Tracking de l'application VApp (IHM du jeu)

VApp/node_modules/.vite/deps/_metadata.json

@@ -0,0 +1,286 @@
+{
+  "hash": "628e8015",
+  "configHash": "2b93e7ef",
+  "lockfileHash": "699d5541",
+  "browserHash": "d545c740",
+  "optimized": {
+    "mqtt": {
+      "src": "../../mqtt/dist/mqtt.esm.js",
+      "file": "mqtt.js",
+      "fileHash": "2b2a859b",
+      "needsInterop": false
+    },
+    "video.js": {
+      "src": "../../video.js/dist/video.es.js",
+      "file": "video__js.js",
+      "fileHash": "4fef3f1f",
+      "needsInterop": false
+    },
+    "vue": {
+      "src": "../../vue/dist/vue.runtime.esm-bundler.js",
+      "file": "vue.js",
+      "fileHash": "15a6de07",
+      "needsInterop": false
+    },
+    "vue-router": {
+      "src": "../../vue-router/dist/vue-router.mjs",
+      "file": "vue-router.js",
+      "fileHash": "1152f15e",
+      "needsInterop": false
+    },
+    "vuetify": {
+      "src": "../../vuetify/lib/framework.mjs",
+      "file": "vuetify.js",
+      "fileHash": "33db8bf0",
+      "needsInterop": false
+    },
+    "vuetify/lib/components/VApp/index.mjs": {
+      "src": "../../vuetify/lib/components/VApp/index.mjs",
+      "file": "vuetify_lib_components_VApp_index__mjs.js",
+      "fileHash": "f96b7fbb",
+      "needsInterop": false
+    },
+    "vuetify/lib/components/VMain/index.mjs": {
+      "src": "../../vuetify/lib/components/VMain/index.mjs",
+      "file": "vuetify_lib_components_VMain_index__mjs.js",
+      "fileHash": "b70c376c",
+      "needsInterop": false
+    },
+    "vuetify/lib/components/VNavigationDrawer/index.mjs": {
+      "src": "../../vuetify/lib/components/VNavigationDrawer/index.mjs",
+      "file": "vuetify_lib_components_VNavigationDrawer_index__mjs.js",
+      "fileHash": "14e50f28",
+      "needsInterop": false
+    },
+    "vuetify/lib/components/VAppBar/index.mjs": {
+      "src": "../../vuetify/lib/components/VAppBar/index.mjs",
+      "file": "vuetify_lib_components_VAppBar_index__mjs.js",
+      "fileHash": "6349634b",
+      "needsInterop": false
+    },
+    "vuetify/lib/components/VBtn/index.mjs": {
+      "src": "../../vuetify/lib/components/VBtn/index.mjs",
+      "file": "vuetify_lib_components_VBtn_index__mjs.js",
+      "fileHash": "42554de7",
+      "needsInterop": false
+    },
+    "vuetify/lib/components/VLabel/index.mjs": {
+      "src": "../../vuetify/lib/components/VLabel/index.mjs",
+      "file": "vuetify_lib_components_VLabel_index__mjs.js",
+      "fileHash": "b67e7a24",
+      "needsInterop": false
+    },
+    "vuetify/lib/components/VSelect/index.mjs": {
+      "src": "../../vuetify/lib/components/VSelect/index.mjs",
+      "file": "vuetify_lib_components_VSelect_index__mjs.js",
+      "fileHash": "1c51e63b",
+      "needsInterop": false
+    },
+    "vuetify/lib/components/VDivider/index.mjs": {
+      "src": "../../vuetify/lib/components/VDivider/index.mjs",
+      "file": "vuetify_lib_components_VDivider_index__mjs.js",
+      "fileHash": "72f94815",
+      "needsInterop": false
+    },
+    "vuetify/lib/components/VGrid/index.mjs": {
+      "src": "../../vuetify/lib/components/VGrid/index.mjs",
+      "file": "vuetify_lib_components_VGrid_index__mjs.js",
+      "fileHash": "e0a97983",
+      "needsInterop": false
+    },
+    "vuetify/lib/components/VIcon/index.mjs": {
+      "src": "../../vuetify/lib/components/VIcon/index.mjs",
+      "file": "vuetify_lib_components_VIcon_index__mjs.js",
+      "fileHash": "750d68fa",
+      "needsInterop": false
+    },
+    "vuetify/lib/components/VList/index.mjs": {
+      "src": "../../vuetify/lib/components/VList/index.mjs",
+      "file": "vuetify_lib_components_VList_index__mjs.js",
+      "fileHash": "8c643c9f",
+      "needsInterop": false
+    },
+    "vuetify/lib/components/VMenu/index.mjs": {
+      "src": "../../vuetify/lib/components/VMenu/index.mjs",
+      "file": "vuetify_lib_components_VMenu_index__mjs.js",
+      "fileHash": "608e5ee1",
+      "needsInterop": false
+    },
+    "vuetify/lib/components/VImg/index.mjs": {
+      "src": "../../vuetify/lib/components/VImg/index.mjs",
+      "file": "vuetify_lib_components_VImg_index__mjs.js",
+      "fileHash": "a6aec654",
+      "needsInterop": false
+    },
+    "vuetify/lib/components/VCard/index.mjs": {
+      "src": "../../vuetify/lib/components/VCard/index.mjs",
+      "file": "vuetify_lib_components_VCard_index__mjs.js",
+      "fileHash": "66c62b31",
+      "needsInterop": false
+    },
+    "vuetify/lib/components/VSlider/index.mjs": {
+      "src": "../../vuetify/lib/components/VSlider/index.mjs",
+      "file": "vuetify_lib_components_VSlider_index__mjs.js",
+      "fileHash": "ab495512",
+      "needsInterop": false
+    },
+    "vuetify/lib/components/VSwitch/index.mjs": {
+      "src": "../../vuetify/lib/components/VSwitch/index.mjs",
+      "file": "vuetify_lib_components_VSwitch_index__mjs.js",
+      "fileHash": "4ee3b628",
+      "needsInterop": false
+    },
+    "vuetify/lib/components/VTextField/index.mjs": {
+      "src": "../../vuetify/lib/components/VTextField/index.mjs",
+      "file": "vuetify_lib_components_VTextField_index__mjs.js",
+      "fileHash": "089842d9",
+      "needsInterop": false
+    },
+    "vuetify/lib/components/VColorPicker/index.mjs": {
+      "src": "../../vuetify/lib/components/VColorPicker/index.mjs",
+      "file": "vuetify_lib_components_VColorPicker_index__mjs.js",
+      "fileHash": "de521c27",
+      "needsInterop": false
+    }
+  },
+  "chunks": {
+    "chunk-GCLA33SA": {
+      "file": "chunk-GCLA33SA.js"
+    },
+    "chunk-5XLJYRDC": {
+      "file": "chunk-5XLJYRDC.js"
+    },
+    "chunk-2SRC7F4H": {
+      "file": "chunk-2SRC7F4H.js"
+    },
+    "chunk-4HSTIW6R": {
+      "file": "chunk-4HSTIW6R.js"
+    },
+    "chunk-NUVQUA75": {
+      "file": "chunk-NUVQUA75.js"
+    },
+    "chunk-7GUKMFNW": {
+      "file": "chunk-7GUKMFNW.js"
+    },
+    "chunk-35WI6QQQ": {
+      "file": "chunk-35WI6QQQ.js"
+    },
+    "chunk-7EFRYS5N": {
+      "file": "chunk-7EFRYS5N.js"
+    },
+    "chunk-3JAGB4CS": {
+      "file": "chunk-3JAGB4CS.js"
+    },
+    "chunk-DOBNCX34": {
+      "file": "chunk-DOBNCX34.js"
+    },
+    "chunk-4GJMZCX5": {
+      "file": "chunk-4GJMZCX5.js"
+    },
+    "chunk-2PSEIA2V": {
+      "file": "chunk-2PSEIA2V.js"
+    },
+    "chunk-XCL3R7PH": {
+      "file": "chunk-XCL3R7PH.js"
+    },
+    "chunk-XJDRWBAV": {
+      "file": "chunk-XJDRWBAV.js"
+    },
+    "chunk-YRMIN6NY": {
+      "file": "chunk-YRMIN6NY.js"
+    },
+    "chunk-37564NA2": {
+      "file": "chunk-37564NA2.js"
+    },
+    "chunk-XQKRKMJT": {
+      "file": "chunk-XQKRKMJT.js"
+    },
+    "chunk-NMCVREUK": {
+      "file": "chunk-NMCVREUK.js"
+    },
+    "chunk-O7K6SSRF": {
+      "file": "chunk-O7K6SSRF.js"
+    },
+    "chunk-QXA6VMYU": {
+      "file": "chunk-QXA6VMYU.js"
+    },
+    "chunk-FHRMVSBZ": {
+      "file": "chunk-FHRMVSBZ.js"
+    },
+    "chunk-O7EUYO3B": {
+      "file": "chunk-O7EUYO3B.js"
+    },
+    "chunk-D42AK3WB": {
+      "file": "chunk-D42AK3WB.js"
+    },
+    "chunk-PCNFKUUR": {
+      "file": "chunk-PCNFKUUR.js"
+    },
+    "chunk-ZCXGZYP7": {
+      "file": "chunk-ZCXGZYP7.js"
+    },
+    "chunk-44S2JOLY": {
+      "file": "chunk-44S2JOLY.js"
+    },
+    "chunk-VQPKT5F7": {
+      "file": "chunk-VQPKT5F7.js"
+    },
+    "chunk-24LK52JF": {
+      "file": "chunk-24LK52JF.js"
+    },
+    "chunk-IFUDBK56": {
+      "file": "chunk-IFUDBK56.js"
+    },
+    "chunk-JVZUVJAC": {
+      "file": "chunk-JVZUVJAC.js"
+    },
+    "chunk-XRWT7YWI": {
+      "file": "chunk-XRWT7YWI.js"
+    },
+    "chunk-ZZ55KHRR": {
+      "file": "chunk-ZZ55KHRR.js"
+    },
+    "chunk-AGK43WUJ": {
+      "file": "chunk-AGK43WUJ.js"
+    },
+    "chunk-O5EKZW2J": {
+      "file": "chunk-O5EKZW2J.js"
+    },
+    "chunk-472DNWSX": {
+      "file": "chunk-472DNWSX.js"
+    },
+    "chunk-IR5437QA": {
+      "file": "chunk-IR5437QA.js"
+    },
+    "chunk-PVQHDZXM": {
+      "file": "chunk-PVQHDZXM.js"
+    },
+    "chunk-VDFYLV2V": {
+      "file": "chunk-VDFYLV2V.js"
+    },
+    "chunk-DJRL4NAD": {
+      "file": "chunk-DJRL4NAD.js"
+    },
+    "chunk-JVLWTAZ5": {
+      "file": "chunk-JVLWTAZ5.js"
+    },
+    "chunk-6MYZNPKW": {
+      "file": "chunk-6MYZNPKW.js"
+    },
+    "chunk-J5HFPFMJ": {
+      "file": "chunk-J5HFPFMJ.js"
+    },
+    "chunk-CYOEVGGH": {
+      "file": "chunk-CYOEVGGH.js"
+    },
+    "chunk-I4KGD5X4": {
+      "file": "chunk-I4KGD5X4.js"
+    },
+    "chunk-PD2AWGJV": {
+      "file": "chunk-PD2AWGJV.js"
+    },
+    "chunk-QWN5BXRD": {
+      "file": "chunk-QWN5BXRD.js"
+    }
+  }
+}

VApp/node_modules/.vite/deps/chunk-24LK52JF.js

@@ -0,0 +1,40 @@
+import {
+  getCurrentInstanceName,
+  propsFactory
+} from "./chunk-I4KGD5X4.js";
+import {
+  computed,
+  isRef
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/composables/rounded.mjs
+var makeRoundedProps = propsFactory({
+  rounded: {
+    type: [Boolean, Number, String],
+    default: void 0
+  }
+}, "rounded");
+function useRounded(props) {
+  let name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : getCurrentInstanceName();
+  const roundedClasses = computed(() => {
+    const rounded = isRef(props) ? props.value : props.rounded;
+    const classes = [];
+    if (rounded === true || rounded === "") {
+      classes.push(`${name}--rounded`);
+    } else if (typeof rounded === "string" || rounded === 0) {
+      for (const value of String(rounded).split(" ")) {
+        classes.push(`rounded-${value}`);
+      }
+    }
+    return classes;
+  });
+  return {
+    roundedClasses
+  };
+}
+
+export {
+  makeRoundedProps,
+  useRounded
+};
+//# sourceMappingURL=chunk-24LK52JF.js.map

VApp/node_modules/.vite/deps/chunk-24LK52JF.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../vuetify/src/composables/rounded.ts"],
+  "sourcesContent": ["// Utilities\nimport { computed, isRef } from 'vue'\nimport { getCurrentInstanceName, propsFactory } from '@/util'\n\n// Types\nimport type { Ref } from 'vue'\n\ntype RoundedValue = boolean | string | number | null | undefined\n\nexport interface RoundedProps {\n  rounded?: RoundedValue\n  tile?: boolean\n}\n\ntype RoundedData = {\n  roundedClasses: Ref<string[]>\n}\n\n// Composables\nexport const makeRoundedProps = propsFactory({\n  rounded: {\n    type: [Boolean, Number, String],\n    default: undefined,\n  },\n}, 'rounded')\n\nexport function useRounded (\n  props: RoundedProps | Ref<RoundedValue>,\n  name = getCurrentInstanceName(),\n): RoundedData {\n  const roundedClasses = computed(() => {\n    const rounded = isRef(props) ? props.value : props.rounded\n    const classes: string[] = []\n\n    if (rounded === true || rounded === '') {\n      classes.push(`${name}--rounded`)\n    } else if (\n      typeof rounded === 'string' ||\n      rounded === 0\n    ) {\n      for (const value of String(rounded).split(' ')) {\n        classes.push(`rounded-${value}`)\n      }\n    }\n\n    return classes\n  })\n\n  return { roundedClasses }\n}\n"],
+  "mappings": ";;;;;;;;;;AAmBO,IAAMA,mBAAmBC,aAAa;EAC3CC,SAAS;IACPC,MAAM,CAACC,SAASC,QAAQC,MAAM;IAC9BC,SAASC;EACX;AACF,GAAG,SAAS;AAEL,SAASC,WACdC,OAEa;AAAA,MADbC,OAAIC,UAAAC,SAAA,KAAAD,UAAA,CAAA,MAAAJ,SAAAI,UAAA,CAAA,IAAGE,uBAAuB;AAE9B,QAAMC,iBAAiBC,SAAS,MAAM;AACpC,UAAMd,UAAUe,MAAMP,KAAK,IAAIA,MAAMQ,QAAQR,MAAMR;AACnD,UAAMiB,UAAoB,CAAA;AAE1B,QAAIjB,YAAY,QAAQA,YAAY,IAAI;AACtCiB,cAAQC,KAAM,GAAET,IAAK,WAAU;IACjC,WACE,OAAOT,YAAY,YACnBA,YAAY,GACZ;AACA,iBAAWgB,SAASZ,OAAOJ,OAAO,EAAEmB,MAAM,GAAG,GAAG;AAC9CF,gBAAQC,KAAM,WAAUF,KAAM,EAAC;MACjC;IACF;AAEA,WAAOC;EACT,CAAC;AAED,SAAO;IAAEJ;EAAe;AAC1B;",
+  "names": ["makeRoundedProps", "propsFactory", "rounded", "type", "Boolean", "Number", "String", "default", "undefined", "useRounded", "props", "name", "arguments", "length", "getCurrentInstanceName", "roundedClasses", "computed", "isRef", "value", "classes", "push", "split"]
+}

VApp/node_modules/.vite/deps/chunk-2PSEIA2V.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-2PSEIA2V.js.map

VApp/node_modules/.vite/deps/chunk-2PSEIA2V.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

VApp/node_modules/.vite/deps/chunk-2SRC7F4H.js

@@ -0,0 +1,359 @@
+import {
+  Ripple
+} from "./chunk-NMCVREUK.js";
+import {
+  makeDensityProps,
+  useDensity
+} from "./chunk-VQPKT5F7.js";
+import {
+  VIcon
+} from "./chunk-IFUDBK56.js";
+import {
+  useBackgroundColor,
+  useTextColor
+} from "./chunk-ZZ55KHRR.js";
+import {
+  IconValue
+} from "./chunk-472DNWSX.js";
+import {
+  useProxiedModel
+} from "./chunk-PVQHDZXM.js";
+import {
+  VLabel
+} from "./chunk-J5HFPFMJ.js";
+import {
+  makeThemeProps
+} from "./chunk-CYOEVGGH.js";
+import {
+  deepEqual,
+  filterInputAttrs,
+  genericComponent,
+  getUid,
+  makeComponentProps,
+  matchesSelector,
+  propsFactory,
+  provideDefaults,
+  useRender,
+  wrapInArray
+} from "./chunk-I4KGD5X4.js";
+import {
+  Fragment,
+  computed,
+  createVNode,
+  inject,
+  mergeProps,
+  nextTick,
+  onScopeDispose,
+  provide,
+  ref,
+  resolveDirective,
+  shallowRef,
+  toRef,
+  withDirectives
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/components/VSelectionControl/VSelectionControl.mjs
+import "C:/Users/Jeremy/Documents/Dev/Projects.cloudsucks.net/Vulture/VApp/node_modules/vuetify/lib/components/VSelectionControl/VSelectionControl.css";
+
+// node_modules/vuetify/lib/components/VSelectionControlGroup/VSelectionControlGroup.mjs
+import "C:/Users/Jeremy/Documents/Dev/Projects.cloudsucks.net/Vulture/VApp/node_modules/vuetify/lib/components/VSelectionControlGroup/VSelectionControlGroup.css";
+var VSelectionControlGroupSymbol = Symbol.for("vuetify:selection-control-group");
+var makeSelectionControlGroupProps = propsFactory({
+  color: String,
+  disabled: {
+    type: Boolean,
+    default: null
+  },
+  defaultsTarget: String,
+  error: Boolean,
+  id: String,
+  inline: Boolean,
+  falseIcon: IconValue,
+  trueIcon: IconValue,
+  ripple: {
+    type: Boolean,
+    default: true
+  },
+  multiple: {
+    type: Boolean,
+    default: null
+  },
+  name: String,
+  readonly: {
+    type: Boolean,
+    default: null
+  },
+  modelValue: null,
+  type: String,
+  valueComparator: {
+    type: Function,
+    default: deepEqual
+  },
+  ...makeComponentProps(),
+  ...makeDensityProps(),
+  ...makeThemeProps()
+}, "SelectionControlGroup");
+var makeVSelectionControlGroupProps = propsFactory({
+  ...makeSelectionControlGroupProps({
+    defaultsTarget: "VSelectionControl"
+  })
+}, "VSelectionControlGroup");
+var VSelectionControlGroup = genericComponent()({
+  name: "VSelectionControlGroup",
+  props: makeVSelectionControlGroupProps(),
+  emits: {
+    "update:modelValue": (value) => true
+  },
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    const modelValue = useProxiedModel(props, "modelValue");
+    const uid = getUid();
+    const id = computed(() => props.id || `v-selection-control-group-${uid}`);
+    const name = computed(() => props.name || id.value);
+    const updateHandlers = /* @__PURE__ */ new Set();
+    provide(VSelectionControlGroupSymbol, {
+      modelValue,
+      forceUpdate: () => {
+        updateHandlers.forEach((fn) => fn());
+      },
+      onForceUpdate: (cb) => {
+        updateHandlers.add(cb);
+        onScopeDispose(() => {
+          updateHandlers.delete(cb);
+        });
+      }
+    });
+    provideDefaults({
+      [props.defaultsTarget]: {
+        color: toRef(props, "color"),
+        disabled: toRef(props, "disabled"),
+        density: toRef(props, "density"),
+        error: toRef(props, "error"),
+        inline: toRef(props, "inline"),
+        modelValue,
+        multiple: computed(() => !!props.multiple || props.multiple == null && Array.isArray(modelValue.value)),
+        name,
+        falseIcon: toRef(props, "falseIcon"),
+        trueIcon: toRef(props, "trueIcon"),
+        readonly: toRef(props, "readonly"),
+        ripple: toRef(props, "ripple"),
+        type: toRef(props, "type"),
+        valueComparator: toRef(props, "valueComparator")
+      }
+    });
+    useRender(() => {
+      var _a;
+      return createVNode("div", {
+        "class": ["v-selection-control-group", {
+          "v-selection-control-group--inline": props.inline
+        }, props.class],
+        "style": props.style,
+        "role": props.type === "radio" ? "radiogroup" : void 0
+      }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
+    });
+    return {};
+  }
+});
+
+// node_modules/vuetify/lib/components/VSelectionControl/VSelectionControl.mjs
+var makeVSelectionControlProps = propsFactory({
+  label: String,
+  baseColor: String,
+  trueValue: null,
+  falseValue: null,
+  value: null,
+  ...makeComponentProps(),
+  ...makeSelectionControlGroupProps()
+}, "VSelectionControl");
+function useSelectionControl(props) {
+  const group = inject(VSelectionControlGroupSymbol, void 0);
+  const {
+    densityClasses
+  } = useDensity(props);
+  const modelValue = useProxiedModel(props, "modelValue");
+  const trueValue = computed(() => props.trueValue !== void 0 ? props.trueValue : props.value !== void 0 ? props.value : true);
+  const falseValue = computed(() => props.falseValue !== void 0 ? props.falseValue : false);
+  const isMultiple = computed(() => !!props.multiple || props.multiple == null && Array.isArray(modelValue.value));
+  const model = computed({
+    get() {
+      const val = group ? group.modelValue.value : modelValue.value;
+      return isMultiple.value ? wrapInArray(val).some((v) => props.valueComparator(v, trueValue.value)) : props.valueComparator(val, trueValue.value);
+    },
+    set(val) {
+      if (props.readonly) return;
+      const currentValue = val ? trueValue.value : falseValue.value;
+      let newVal = currentValue;
+      if (isMultiple.value) {
+        newVal = val ? [...wrapInArray(modelValue.value), currentValue] : wrapInArray(modelValue.value).filter((item) => !props.valueComparator(item, trueValue.value));
+      }
+      if (group) {
+        group.modelValue.value = newVal;
+      } else {
+        modelValue.value = newVal;
+      }
+    }
+  });
+  const {
+    textColorClasses,
+    textColorStyles
+  } = useTextColor(computed(() => {
+    if (props.error || props.disabled) return void 0;
+    return model.value ? props.color : props.baseColor;
+  }));
+  const {
+    backgroundColorClasses,
+    backgroundColorStyles
+  } = useBackgroundColor(computed(() => {
+    return model.value && !props.error && !props.disabled ? props.color : void 0;
+  }));
+  const icon = computed(() => model.value ? props.trueIcon : props.falseIcon);
+  return {
+    group,
+    densityClasses,
+    trueValue,
+    falseValue,
+    model,
+    textColorClasses,
+    textColorStyles,
+    backgroundColorClasses,
+    backgroundColorStyles,
+    icon
+  };
+}
+var VSelectionControl = genericComponent()({
+  name: "VSelectionControl",
+  directives: {
+    Ripple
+  },
+  inheritAttrs: false,
+  props: makeVSelectionControlProps(),
+  emits: {
+    "update:modelValue": (value) => true
+  },
+  setup(props, _ref) {
+    let {
+      attrs,
+      slots
+    } = _ref;
+    const {
+      group,
+      densityClasses,
+      icon,
+      model,
+      textColorClasses,
+      textColorStyles,
+      backgroundColorClasses,
+      backgroundColorStyles,
+      trueValue
+    } = useSelectionControl(props);
+    const uid = getUid();
+    const isFocused = shallowRef(false);
+    const isFocusVisible = shallowRef(false);
+    const input = ref();
+    const id = computed(() => props.id || `input-${uid}`);
+    const isInteractive = computed(() => !props.disabled && !props.readonly);
+    group == null ? void 0 : group.onForceUpdate(() => {
+      if (input.value) {
+        input.value.checked = model.value;
+      }
+    });
+    function onFocus(e) {
+      if (!isInteractive.value) return;
+      isFocused.value = true;
+      if (matchesSelector(e.target, ":focus-visible") !== false) {
+        isFocusVisible.value = true;
+      }
+    }
+    function onBlur() {
+      isFocused.value = false;
+      isFocusVisible.value = false;
+    }
+    function onClickLabel(e) {
+      e.stopPropagation();
+    }
+    function onInput(e) {
+      if (!isInteractive.value) return;
+      if (props.readonly && group) {
+        nextTick(() => group.forceUpdate());
+      }
+      model.value = e.target.checked;
+    }
+    useRender(() => {
+      var _a, _b;
+      const label = slots.label ? slots.label({
+        label: props.label,
+        props: {
+          for: id.value
+        }
+      }) : props.label;
+      const [rootAttrs, inputAttrs] = filterInputAttrs(attrs);
+      const inputNode = createVNode("input", mergeProps({
+        "ref": input,
+        "checked": model.value,
+        "disabled": !!props.disabled,
+        "id": id.value,
+        "onBlur": onBlur,
+        "onFocus": onFocus,
+        "onInput": onInput,
+        "aria-disabled": !!props.disabled,
+        "type": props.type,
+        "value": trueValue.value,
+        "name": props.name,
+        "aria-checked": props.type === "checkbox" ? model.value : void 0
+      }, inputAttrs), null);
+      return createVNode("div", mergeProps({
+        "class": ["v-selection-control", {
+          "v-selection-control--dirty": model.value,
+          "v-selection-control--disabled": props.disabled,
+          "v-selection-control--error": props.error,
+          "v-selection-control--focused": isFocused.value,
+          "v-selection-control--focus-visible": isFocusVisible.value,
+          "v-selection-control--inline": props.inline
+        }, densityClasses.value, props.class]
+      }, rootAttrs, {
+        "style": props.style
+      }), [createVNode("div", {
+        "class": ["v-selection-control__wrapper", textColorClasses.value],
+        "style": textColorStyles.value
+      }, [(_a = slots.default) == null ? void 0 : _a.call(slots, {
+        backgroundColorClasses,
+        backgroundColorStyles
+      }), withDirectives(createVNode("div", {
+        "class": ["v-selection-control__input"]
+      }, [((_b = slots.input) == null ? void 0 : _b.call(slots, {
+        model,
+        textColorClasses,
+        textColorStyles,
+        backgroundColorClasses,
+        backgroundColorStyles,
+        inputNode,
+        icon: icon.value,
+        props: {
+          onFocus,
+          onBlur,
+          id: id.value
+        }
+      })) ?? createVNode(Fragment, null, [icon.value && createVNode(VIcon, {
+        "key": "icon",
+        "icon": icon.value
+      }, null), inputNode])]), [[resolveDirective("ripple"), props.ripple && [!props.disabled && !props.readonly, null, ["center", "circle"]]]])]), label && createVNode(VLabel, {
+        "for": id.value,
+        "onClick": onClickLabel
+      }, {
+        default: () => [label]
+      })]);
+    });
+    return {
+      isFocused,
+      input
+    };
+  }
+});
+
+export {
+  makeVSelectionControlProps,
+  VSelectionControl
+};
+//# sourceMappingURL=chunk-2SRC7F4H.js.map

VApp/node_modules/.vite/deps/chunk-35WI6QQQ.js

@@ -0,0 +1,19 @@
+import {
+  getCurrentInstance
+} from "./chunk-I4KGD5X4.js";
+
+// node_modules/vuetify/lib/composables/scopeId.mjs
+function useScopeId() {
+  const vm = getCurrentInstance("useScopeId");
+  const scopeId = vm.vnode.scopeId;
+  return {
+    scopeId: scopeId ? {
+      [scopeId]: ""
+    } : void 0
+  };
+}
+
+export {
+  useScopeId
+};
+//# sourceMappingURL=chunk-35WI6QQQ.js.map

VApp/node_modules/.vite/deps/chunk-35WI6QQQ.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../vuetify/src/composables/scopeId.ts"],
+  "sourcesContent": ["// Utilities\nimport { getCurrentInstance } from '@/util'\n\nexport function useScopeId () {\n  const vm = getCurrentInstance('useScopeId')\n\n  const scopeId = vm!.vnode.scopeId\n\n  return { scopeId: scopeId ? { [scopeId]: '' } : undefined }\n}\n"],
+  "mappings": ";;;;;AAGO,SAASA,aAAc;AAC5B,QAAMC,KAAKC,mBAAmB,YAAY;AAE1C,QAAMC,UAAUF,GAAIG,MAAMD;AAE1B,SAAO;IAAEA,SAASA,UAAU;MAAE,CAACA,OAAO,GAAG;IAAG,IAAIE;EAAU;AAC5D;",
+  "names": ["useScopeId", "vm", "getCurrentInstance", "scopeId", "vnode", "undefined"]
+}

VApp/node_modules/.vite/deps/chunk-37564NA2.js

@@ -0,0 +1,217 @@
+import {
+  useProxiedModel
+} from "./chunk-PVQHDZXM.js";
+import {
+  consoleWarn,
+  deepEqual,
+  findChildrenWithProvide,
+  getCurrentInstance,
+  getUid,
+  propsFactory,
+  wrapInArray
+} from "./chunk-I4KGD5X4.js";
+import {
+  computed,
+  inject,
+  onBeforeUnmount,
+  onMounted,
+  provide,
+  reactive,
+  toRef,
+  unref,
+  watch
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/composables/group.mjs
+var makeGroupProps = propsFactory({
+  modelValue: {
+    type: null,
+    default: void 0
+  },
+  multiple: Boolean,
+  mandatory: [Boolean, String],
+  max: Number,
+  selectedClass: String,
+  disabled: Boolean
+}, "group");
+var makeGroupItemProps = propsFactory({
+  value: null,
+  disabled: Boolean,
+  selectedClass: String
+}, "group-item");
+function useGroupItem(props, injectKey) {
+  let required = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : true;
+  const vm = getCurrentInstance("useGroupItem");
+  if (!vm) {
+    throw new Error("[Vuetify] useGroupItem composable must be used inside a component setup function");
+  }
+  const id = getUid();
+  provide(Symbol.for(`${injectKey.description}:id`), id);
+  const group = inject(injectKey, null);
+  if (!group) {
+    if (!required) return group;
+    throw new Error(`[Vuetify] Could not find useGroup injection with symbol ${injectKey.description}`);
+  }
+  const value = toRef(props, "value");
+  const disabled = computed(() => !!(group.disabled.value || props.disabled));
+  group.register({
+    id,
+    value,
+    disabled
+  }, vm);
+  onBeforeUnmount(() => {
+    group.unregister(id);
+  });
+  const isSelected = computed(() => {
+    return group.isSelected(id);
+  });
+  const selectedClass = computed(() => isSelected.value && [group.selectedClass.value, props.selectedClass]);
+  watch(isSelected, (value2) => {
+    vm.emit("group:selected", {
+      value: value2
+    });
+  });
+  return {
+    id,
+    isSelected,
+    toggle: () => group.select(id, !isSelected.value),
+    select: (value2) => group.select(id, value2),
+    selectedClass,
+    value,
+    disabled,
+    group
+  };
+}
+function useGroup(props, injectKey) {
+  let isUnmounted = false;
+  const items = reactive([]);
+  const selected = useProxiedModel(props, "modelValue", [], (v) => {
+    if (v == null) return [];
+    return getIds(items, wrapInArray(v));
+  }, (v) => {
+    const arr = getValues(items, v);
+    return props.multiple ? arr : arr[0];
+  });
+  const groupVm = getCurrentInstance("useGroup");
+  function register(item, vm) {
+    const unwrapped = item;
+    const key = Symbol.for(`${injectKey.description}:id`);
+    const children = findChildrenWithProvide(key, groupVm == null ? void 0 : groupVm.vnode);
+    const index = children.indexOf(vm);
+    if (unref(unwrapped.value) == null) {
+      unwrapped.value = index;
+    }
+    if (index > -1) {
+      items.splice(index, 0, unwrapped);
+    } else {
+      items.push(unwrapped);
+    }
+  }
+  function unregister(id) {
+    if (isUnmounted) return;
+    forceMandatoryValue();
+    const index = items.findIndex((item) => item.id === id);
+    items.splice(index, 1);
+  }
+  function forceMandatoryValue() {
+    const item = items.find((item2) => !item2.disabled);
+    if (item && props.mandatory === "force" && !selected.value.length) {
+      selected.value = [item.id];
+    }
+  }
+  onMounted(() => {
+    forceMandatoryValue();
+  });
+  onBeforeUnmount(() => {
+    isUnmounted = true;
+  });
+  function select(id, value) {
+    const item = items.find((item2) => item2.id === id);
+    if (value && (item == null ? void 0 : item.disabled)) return;
+    if (props.multiple) {
+      const internalValue = selected.value.slice();
+      const index = internalValue.findIndex((v) => v === id);
+      const isSelected = ~index;
+      value = value ?? !isSelected;
+      if (isSelected && props.mandatory && internalValue.length <= 1) return;
+      if (!isSelected && props.max != null && internalValue.length + 1 > props.max) return;
+      if (index < 0 && value) internalValue.push(id);
+      else if (index >= 0 && !value) internalValue.splice(index, 1);
+      selected.value = internalValue;
+    } else {
+      const isSelected = selected.value.includes(id);
+      if (props.mandatory && isSelected) return;
+      selected.value = value ?? !isSelected ? [id] : [];
+    }
+  }
+  function step(offset) {
+    if (props.multiple) consoleWarn('This method is not supported when using "multiple" prop');
+    if (!selected.value.length) {
+      const item = items.find((item2) => !item2.disabled);
+      item && (selected.value = [item.id]);
+    } else {
+      const currentId = selected.value[0];
+      const currentIndex = items.findIndex((i) => i.id === currentId);
+      let newIndex = (currentIndex + offset) % items.length;
+      let newItem = items[newIndex];
+      while (newItem.disabled && newIndex !== currentIndex) {
+        newIndex = (newIndex + offset) % items.length;
+        newItem = items[newIndex];
+      }
+      if (newItem.disabled) return;
+      selected.value = [items[newIndex].id];
+    }
+  }
+  const state = {
+    register,
+    unregister,
+    selected,
+    select,
+    disabled: toRef(props, "disabled"),
+    prev: () => step(items.length - 1),
+    next: () => step(1),
+    isSelected: (id) => selected.value.includes(id),
+    selectedClass: computed(() => props.selectedClass),
+    items: computed(() => items),
+    getItemIndex: (value) => getItemIndex(items, value)
+  };
+  provide(injectKey, state);
+  return state;
+}
+function getItemIndex(items, value) {
+  const ids = getIds(items, [value]);
+  if (!ids.length) return -1;
+  return items.findIndex((item) => item.id === ids[0]);
+}
+function getIds(items, modelValue) {
+  const ids = [];
+  modelValue.forEach((value) => {
+    const item = items.find((item2) => deepEqual(value, item2.value));
+    const itemByIndex = items[value];
+    if ((item == null ? void 0 : item.value) != null) {
+      ids.push(item.id);
+    } else if (itemByIndex != null) {
+      ids.push(itemByIndex.id);
+    }
+  });
+  return ids;
+}
+function getValues(items, ids) {
+  const values = [];
+  ids.forEach((id) => {
+    const itemIndex = items.findIndex((item) => item.id === id);
+    if (~itemIndex) {
+      const item = items[itemIndex];
+      values.push(item.value != null ? item.value : itemIndex);
+    }
+  });
+  return values;
+}
+
+export {
+  makeGroupProps,
+  makeGroupItemProps,
+  useGroupItem,
+  useGroup
+};
+//# sourceMappingURL=chunk-37564NA2.js.map

VApp/node_modules/.vite/deps/chunk-3JAGB4CS.js

@@ -0,0 +1,53 @@
+import {
+  SUPPORTS_INTERSECTION
+} from "./chunk-I4KGD5X4.js";
+
+// node_modules/vuetify/lib/directives/intersect/index.mjs
+function mounted(el, binding) {
+  if (!SUPPORTS_INTERSECTION) return;
+  const modifiers = binding.modifiers || {};
+  const value = binding.value;
+  const {
+    handler,
+    options
+  } = typeof value === "object" ? value : {
+    handler: value,
+    options: {}
+  };
+  const observer = new IntersectionObserver(function() {
+    var _a;
+    let entries = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+    let observer2 = arguments.length > 1 ? arguments[1] : void 0;
+    const _observe = (_a = el._observe) == null ? void 0 : _a[binding.instance.$.uid];
+    if (!_observe) return;
+    const isIntersecting = entries.some((entry) => entry.isIntersecting);
+    if (handler && (!modifiers.quiet || _observe.init) && (!modifiers.once || isIntersecting || _observe.init)) {
+      handler(isIntersecting, entries, observer2);
+    }
+    if (isIntersecting && modifiers.once) unmounted(el, binding);
+    else _observe.init = true;
+  }, options);
+  el._observe = Object(el._observe);
+  el._observe[binding.instance.$.uid] = {
+    init: false,
+    observer
+  };
+  observer.observe(el);
+}
+function unmounted(el, binding) {
+  var _a;
+  const observe = (_a = el._observe) == null ? void 0 : _a[binding.instance.$.uid];
+  if (!observe) return;
+  observe.observer.unobserve(el);
+  delete el._observe[binding.instance.$.uid];
+}
+var Intersect = {
+  mounted,
+  unmounted
+};
+var intersect_default = Intersect;
+
+export {
+  intersect_default
+};
+//# sourceMappingURL=chunk-3JAGB4CS.js.map

VApp/node_modules/.vite/deps/chunk-3JAGB4CS.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../vuetify/src/directives/intersect/index.ts"],
+  "sourcesContent": ["// Utilities\nimport { SUPPORTS_INTERSECTION } from '@/util'\n\n// Types\nimport type {\n  DirectiveBinding,\n} from 'vue'\n\ntype ObserveHandler = (\n  isIntersecting: boolean,\n  entries: IntersectionObserverEntry[],\n  observer: IntersectionObserver,\n) => void\n\nexport interface ObserveDirectiveBinding extends Omit<DirectiveBinding, 'modifiers' | 'value'> {\n  value?: ObserveHandler | { handler: ObserveHandler, options?: IntersectionObserverInit }\n  modifiers: {\n    once?: boolean\n    quiet?: boolean\n  }\n}\n\nfunction mounted (el: HTMLElement, binding: ObserveDirectiveBinding) {\n  if (!SUPPORTS_INTERSECTION) return\n\n  const modifiers = binding.modifiers || {}\n  const value = binding.value\n  const { handler, options } = typeof value === 'object'\n    ? value\n    : { handler: value, options: {} }\n\n  const observer = new IntersectionObserver((\n    entries: IntersectionObserverEntry[] = [],\n    observer: IntersectionObserver\n  ) => {\n    const _observe = el._observe?.[binding.instance!.$.uid]\n    if (!_observe) return // Just in case, should never fire\n\n    const isIntersecting = entries.some(entry => entry.isIntersecting)\n\n    // If is not quiet or has already been\n    // initted, invoke the user callback\n    if (\n      handler && (\n        !modifiers.quiet ||\n        _observe.init\n      ) && (\n        !modifiers.once ||\n        isIntersecting ||\n        _observe.init\n      )\n    ) {\n      handler(isIntersecting, entries, observer)\n    }\n\n    if (isIntersecting && modifiers.once) unmounted(el, binding)\n    else _observe.init = true\n  }, options)\n\n  el._observe = Object(el._observe)\n  el._observe![binding.instance!.$.uid] = { init: false, observer }\n\n  observer.observe(el)\n}\n\nfunction unmounted (el: HTMLElement, binding: ObserveDirectiveBinding) {\n  const observe = el._observe?.[binding.instance!.$.uid]\n  if (!observe) return\n\n  observe.observer.unobserve(el)\n  delete el._observe![binding.instance!.$.uid]\n}\n\nexport const Intersect = {\n  mounted,\n  unmounted,\n}\n\nexport default Intersect\n"],
+  "mappings": ";;;;;AAsBA,SAASA,QAASC,IAAiBC,SAAkC;AACnE,MAAI,CAACC,sBAAuB;AAE5B,QAAMC,YAAYF,QAAQE,aAAa,CAAC;AACxC,QAAMC,QAAQH,QAAQG;AACtB,QAAM;IAAEC;IAASC;EAAQ,IAAI,OAAOF,UAAU,WAC1CA,QACA;IAAEC,SAASD;IAAOE,SAAS,CAAC;EAAE;AAElC,QAAMC,WAAW,IAAIC,qBAAqB,WAGrC;AAlCP;AAkCO,QAFHC,UAAoCC,UAAAC,SAAA,KAAAD,UAAA,CAAA,MAAAE,SAAAF,UAAA,CAAA,IAAG,CAAA;AAAE,QACzCH,YAA8BG,UAAAC,SAAA,IAAAD,UAAA,CAAA,IAAAE;AAE9B,UAAMC,YAAWb,QAAGa,aAAHb,mBAAcC,QAAQa,SAAUC,EAAEC;AACnD,QAAI,CAACH,SAAU;AAEf,UAAMI,iBAAiBR,QAAQS,KAAKC,WAASA,MAAMF,cAAc;AAIjE,QACEZ,YACE,CAACF,UAAUiB,SACXP,SAASQ,UAET,CAAClB,UAAUmB,QACXL,kBACAJ,SAASQ,OAEX;AACAhB,cAAQY,gBAAgBR,SAASF,SAAQ;IAC3C;AAEA,QAAIU,kBAAkBd,UAAUmB,KAAMC,WAAUvB,IAAIC,OAAO;QACtDY,UAASQ,OAAO;EACvB,GAAGf,OAAO;AAEVN,KAAGa,WAAWW,OAAOxB,GAAGa,QAAQ;AAChCb,KAAGa,SAAUZ,QAAQa,SAAUC,EAAEC,GAAG,IAAI;IAAEK,MAAM;IAAOd;EAAS;AAEhEA,WAASkB,QAAQzB,EAAE;AACrB;AAEA,SAASuB,UAAWvB,IAAiBC,SAAkC;AAjEvE;AAkEE,QAAMwB,WAAUzB,QAAGa,aAAHb,mBAAcC,QAAQa,SAAUC,EAAEC;AAClD,MAAI,CAACS,QAAS;AAEdA,UAAQlB,SAASmB,UAAU1B,EAAE;AAC7B,SAAOA,GAAGa,SAAUZ,QAAQa,SAAUC,EAAEC,GAAG;AAC7C;AAEO,IAAMW,YAAY;EACvB5B;EACAwB;AACF;AAEA,IAAA,oBAAeI;",
+  "names": ["mounted", "el", "binding", "SUPPORTS_INTERSECTION", "modifiers", "value", "handler", "options", "observer", "IntersectionObserver", "entries", "arguments", "length", "undefined", "_observe", "instance", "$", "uid", "isIntersecting", "some", "entry", "quiet", "init", "once", "unmounted", "Object", "observe", "unobserve", "Intersect"]
+}

VApp/node_modules/.vite/deps/chunk-44S2JOLY.js

@@ -0,0 +1,339 @@
+import {
+  makeRoundedProps,
+  useRounded
+} from "./chunk-24LK52JF.js";
+import {
+  useBackgroundColor,
+  useTextColor
+} from "./chunk-ZZ55KHRR.js";
+import {
+  useRtl
+} from "./chunk-IR5437QA.js";
+import {
+  useProxiedModel
+} from "./chunk-PVQHDZXM.js";
+import {
+  makeTagProps
+} from "./chunk-DJRL4NAD.js";
+import {
+  makeThemeProps,
+  provideTheme
+} from "./chunk-CYOEVGGH.js";
+import {
+  SUPPORTS_INTERSECTION,
+  convertToUnit,
+  genericComponent,
+  getCurrentInstanceName,
+  makeComponentProps,
+  parseAnchor,
+  propsFactory,
+  useRender
+} from "./chunk-I4KGD5X4.js";
+import {
+  Transition,
+  computed,
+  createVNode,
+  onBeforeUnmount,
+  ref,
+  shallowRef,
+  watch
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/composables/location.mjs
+var oppositeMap = {
+  center: "center",
+  top: "bottom",
+  bottom: "top",
+  left: "right",
+  right: "left"
+};
+var makeLocationProps = propsFactory({
+  location: String
+}, "location");
+function useLocation(props) {
+  let opposite = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+  let offset = arguments.length > 2 ? arguments[2] : void 0;
+  const {
+    isRtl
+  } = useRtl();
+  const locationStyles = computed(() => {
+    if (!props.location) return {};
+    const {
+      side,
+      align
+    } = parseAnchor(props.location.split(" ").length > 1 ? props.location : `${props.location} center`, isRtl.value);
+    function getOffset(side2) {
+      return offset ? offset(side2) : 0;
+    }
+    const styles = {};
+    if (side !== "center") {
+      if (opposite) styles[oppositeMap[side]] = `calc(100% - ${getOffset(side)}px)`;
+      else styles[side] = 0;
+    }
+    if (align !== "center") {
+      if (opposite) styles[oppositeMap[align]] = `calc(100% - ${getOffset(align)}px)`;
+      else styles[align] = 0;
+    } else {
+      if (side === "center") styles.top = styles.left = "50%";
+      else {
+        styles[{
+          top: "left",
+          bottom: "left",
+          left: "top",
+          right: "top"
+        }[side]] = "50%";
+      }
+      styles.transform = {
+        top: "translateX(-50%)",
+        bottom: "translateX(-50%)",
+        left: "translateY(-50%)",
+        right: "translateY(-50%)",
+        center: "translate(-50%, -50%)"
+      }[side];
+    }
+    return styles;
+  });
+  return {
+    locationStyles
+  };
+}
+
+// node_modules/vuetify/lib/components/VProgressLinear/VProgressLinear.mjs
+import "C:/Users/Jeremy/Documents/Dev/Projects.cloudsucks.net/Vulture/VApp/node_modules/vuetify/lib/components/VProgressLinear/VProgressLinear.css";
+
+// node_modules/vuetify/lib/composables/intersectionObserver.mjs
+function useIntersectionObserver(callback, options) {
+  const intersectionRef = ref();
+  const isIntersecting = shallowRef(false);
+  if (SUPPORTS_INTERSECTION) {
+    const observer = new IntersectionObserver((entries) => {
+      callback == null ? void 0 : callback(entries, observer);
+      isIntersecting.value = !!entries.find((entry) => entry.isIntersecting);
+    }, options);
+    onBeforeUnmount(() => {
+      observer.disconnect();
+    });
+    watch(intersectionRef, (newValue, oldValue) => {
+      if (oldValue) {
+        observer.unobserve(oldValue);
+        isIntersecting.value = false;
+      }
+      if (newValue) observer.observe(newValue);
+    }, {
+      flush: "post"
+    });
+  }
+  return {
+    intersectionRef,
+    isIntersecting
+  };
+}
+
+// node_modules/vuetify/lib/components/VProgressLinear/VProgressLinear.mjs
+var makeVProgressLinearProps = propsFactory({
+  absolute: Boolean,
+  active: {
+    type: Boolean,
+    default: true
+  },
+  bgColor: String,
+  bgOpacity: [Number, String],
+  bufferValue: {
+    type: [Number, String],
+    default: 0
+  },
+  clickable: Boolean,
+  color: String,
+  height: {
+    type: [Number, String],
+    default: 4
+  },
+  indeterminate: Boolean,
+  max: {
+    type: [Number, String],
+    default: 100
+  },
+  modelValue: {
+    type: [Number, String],
+    default: 0
+  },
+  reverse: Boolean,
+  stream: Boolean,
+  striped: Boolean,
+  roundedBar: Boolean,
+  ...makeComponentProps(),
+  ...makeLocationProps({
+    location: "top"
+  }),
+  ...makeRoundedProps(),
+  ...makeTagProps(),
+  ...makeThemeProps()
+}, "VProgressLinear");
+var VProgressLinear = genericComponent()({
+  name: "VProgressLinear",
+  props: makeVProgressLinearProps(),
+  emits: {
+    "update:modelValue": (value) => true
+  },
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    const progress = useProxiedModel(props, "modelValue");
+    const {
+      isRtl,
+      rtlClasses
+    } = useRtl();
+    const {
+      themeClasses
+    } = provideTheme(props);
+    const {
+      locationStyles
+    } = useLocation(props);
+    const {
+      textColorClasses,
+      textColorStyles
+    } = useTextColor(props, "color");
+    const {
+      backgroundColorClasses,
+      backgroundColorStyles
+    } = useBackgroundColor(computed(() => props.bgColor || props.color));
+    const {
+      backgroundColorClasses: barColorClasses,
+      backgroundColorStyles: barColorStyles
+    } = useBackgroundColor(props, "color");
+    const {
+      roundedClasses
+    } = useRounded(props);
+    const {
+      intersectionRef,
+      isIntersecting
+    } = useIntersectionObserver();
+    const max = computed(() => parseInt(props.max, 10));
+    const height = computed(() => parseInt(props.height, 10));
+    const normalizedBuffer = computed(() => parseFloat(props.bufferValue) / max.value * 100);
+    const normalizedValue = computed(() => parseFloat(progress.value) / max.value * 100);
+    const isReversed = computed(() => isRtl.value !== props.reverse);
+    const transition = computed(() => props.indeterminate ? "fade-transition" : "slide-x-transition");
+    const opacity = computed(() => {
+      return props.bgOpacity == null ? props.bgOpacity : parseFloat(props.bgOpacity);
+    });
+    function handleClick(e) {
+      if (!intersectionRef.value) return;
+      const {
+        left,
+        right,
+        width
+      } = intersectionRef.value.getBoundingClientRect();
+      const value = isReversed.value ? width - e.clientX + (right - width) : e.clientX - left;
+      progress.value = Math.round(value / width * max.value);
+    }
+    useRender(() => createVNode(props.tag, {
+      "ref": intersectionRef,
+      "class": ["v-progress-linear", {
+        "v-progress-linear--absolute": props.absolute,
+        "v-progress-linear--active": props.active && isIntersecting.value,
+        "v-progress-linear--reverse": isReversed.value,
+        "v-progress-linear--rounded": props.rounded,
+        "v-progress-linear--rounded-bar": props.roundedBar,
+        "v-progress-linear--striped": props.striped
+      }, roundedClasses.value, themeClasses.value, rtlClasses.value, props.class],
+      "style": [{
+        bottom: props.location === "bottom" ? 0 : void 0,
+        top: props.location === "top" ? 0 : void 0,
+        height: props.active ? convertToUnit(height.value) : 0,
+        "--v-progress-linear-height": convertToUnit(height.value),
+        ...locationStyles.value
+      }, props.style],
+      "role": "progressbar",
+      "aria-hidden": props.active ? "false" : "true",
+      "aria-valuemin": "0",
+      "aria-valuemax": props.max,
+      "aria-valuenow": props.indeterminate ? void 0 : normalizedValue.value,
+      "onClick": props.clickable && handleClick
+    }, {
+      default: () => [props.stream && createVNode("div", {
+        "key": "stream",
+        "class": ["v-progress-linear__stream", textColorClasses.value],
+        "style": {
+          ...textColorStyles.value,
+          [isReversed.value ? "left" : "right"]: convertToUnit(-height.value),
+          borderTop: `${convertToUnit(height.value / 2)} dotted`,
+          opacity: opacity.value,
+          top: `calc(50% - ${convertToUnit(height.value / 4)})`,
+          width: convertToUnit(100 - normalizedBuffer.value, "%"),
+          "--v-progress-linear-stream-to": convertToUnit(height.value * (isReversed.value ? 1 : -1))
+        }
+      }, null), createVNode("div", {
+        "class": ["v-progress-linear__background", backgroundColorClasses.value],
+        "style": [backgroundColorStyles.value, {
+          opacity: opacity.value,
+          width: convertToUnit(!props.stream ? 100 : normalizedBuffer.value, "%")
+        }]
+      }, null), createVNode(Transition, {
+        "name": transition.value
+      }, {
+        default: () => [!props.indeterminate ? createVNode("div", {
+          "class": ["v-progress-linear__determinate", barColorClasses.value],
+          "style": [barColorStyles.value, {
+            width: convertToUnit(normalizedValue.value, "%")
+          }]
+        }, null) : createVNode("div", {
+          "class": "v-progress-linear__indeterminate"
+        }, [["long", "short"].map((bar) => createVNode("div", {
+          "key": bar,
+          "class": ["v-progress-linear__indeterminate", bar, barColorClasses.value],
+          "style": barColorStyles.value
+        }, null))])]
+      }), slots.default && createVNode("div", {
+        "class": "v-progress-linear__content"
+      }, [slots.default({
+        value: normalizedValue.value,
+        buffer: normalizedBuffer.value
+      })])]
+    }));
+    return {};
+  }
+});
+
+// node_modules/vuetify/lib/composables/loader.mjs
+var makeLoaderProps = propsFactory({
+  loading: [Boolean, String]
+}, "loader");
+function useLoader(props) {
+  let name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : getCurrentInstanceName();
+  const loaderClasses = computed(() => ({
+    [`${name}--loading`]: props.loading
+  }));
+  return {
+    loaderClasses
+  };
+}
+function LoaderSlot(props, _ref) {
+  var _a;
+  let {
+    slots
+  } = _ref;
+  return createVNode("div", {
+    "class": `${props.name}__loader`
+  }, [((_a = slots.default) == null ? void 0 : _a.call(slots, {
+    color: props.color,
+    isActive: props.active
+  })) || createVNode(VProgressLinear, {
+    "absolute": props.absolute,
+    "active": props.active,
+    "color": props.color,
+    "height": "2",
+    "indeterminate": true
+  }, null)]);
+}
+
+export {
+  useIntersectionObserver,
+  makeLocationProps,
+  useLocation,
+  makeLoaderProps,
+  useLoader,
+  LoaderSlot
+};
+//# sourceMappingURL=chunk-44S2JOLY.js.map

VApp/node_modules/.vite/deps/chunk-472DNWSX.js

@@ -0,0 +1,224 @@
+import {
+  defineComponent,
+  genericComponent,
+  mergeDeep,
+  propsFactory
+} from "./chunk-I4KGD5X4.js";
+import {
+  computed,
+  createVNode,
+  h,
+  inject,
+  mergeProps,
+  unref
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/iconsets/mdi.mjs
+var aliases = {
+  collapse: "mdi-chevron-up",
+  complete: "mdi-check",
+  cancel: "mdi-close-circle",
+  close: "mdi-close",
+  delete: "mdi-close-circle",
+  // delete (e.g. v-chip close)
+  clear: "mdi-close-circle",
+  success: "mdi-check-circle",
+  info: "mdi-information",
+  warning: "mdi-alert-circle",
+  error: "mdi-close-circle",
+  prev: "mdi-chevron-left",
+  next: "mdi-chevron-right",
+  checkboxOn: "mdi-checkbox-marked",
+  checkboxOff: "mdi-checkbox-blank-outline",
+  checkboxIndeterminate: "mdi-minus-box",
+  delimiter: "mdi-circle",
+  // for carousel
+  sortAsc: "mdi-arrow-up",
+  sortDesc: "mdi-arrow-down",
+  expand: "mdi-chevron-down",
+  menu: "mdi-menu",
+  subgroup: "mdi-menu-down",
+  dropdown: "mdi-menu-down",
+  radioOn: "mdi-radiobox-marked",
+  radioOff: "mdi-radiobox-blank",
+  edit: "mdi-pencil",
+  ratingEmpty: "mdi-star-outline",
+  ratingFull: "mdi-star",
+  ratingHalf: "mdi-star-half-full",
+  loading: "mdi-cached",
+  first: "mdi-page-first",
+  last: "mdi-page-last",
+  unfold: "mdi-unfold-more-horizontal",
+  file: "mdi-paperclip",
+  plus: "mdi-plus",
+  minus: "mdi-minus",
+  calendar: "mdi-calendar",
+  eyeDropper: "mdi-eyedropper"
+};
+var mdi = {
+  // Not using mergeProps here, functional components merge props by default (?)
+  component: (props) => h(VClassIcon, {
+    ...props,
+    class: "mdi"
+  })
+};
+
+// node_modules/vuetify/lib/composables/icons.mjs
+var IconValue = [String, Function, Object, Array];
+var IconSymbol = Symbol.for("vuetify:icons");
+var makeIconProps = propsFactory({
+  icon: {
+    type: IconValue
+  },
+  // Could not remove this and use makeTagProps, types complained because it is not required
+  tag: {
+    type: String,
+    required: true
+  }
+}, "icon");
+var VComponentIcon = genericComponent()({
+  name: "VComponentIcon",
+  props: makeIconProps(),
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    return () => {
+      const Icon = props.icon;
+      return createVNode(props.tag, null, {
+        default: () => {
+          var _a;
+          return [props.icon ? createVNode(Icon, null, null) : (_a = slots.default) == null ? void 0 : _a.call(slots)];
+        }
+      });
+    };
+  }
+});
+var VSvgIcon = defineComponent({
+  name: "VSvgIcon",
+  inheritAttrs: false,
+  props: makeIconProps(),
+  setup(props, _ref2) {
+    let {
+      attrs
+    } = _ref2;
+    return () => {
+      return createVNode(props.tag, mergeProps(attrs, {
+        "style": null
+      }), {
+        default: () => [createVNode("svg", {
+          "class": "v-icon__svg",
+          "xmlns": "http://www.w3.org/2000/svg",
+          "viewBox": "0 0 24 24",
+          "role": "img",
+          "aria-hidden": "true"
+        }, [Array.isArray(props.icon) ? props.icon.map((path) => Array.isArray(path) ? createVNode("path", {
+          "d": path[0],
+          "fill-opacity": path[1]
+        }, null) : createVNode("path", {
+          "d": path
+        }, null)) : createVNode("path", {
+          "d": props.icon
+        }, null)])]
+      });
+    };
+  }
+});
+var VLigatureIcon = defineComponent({
+  name: "VLigatureIcon",
+  props: makeIconProps(),
+  setup(props) {
+    return () => {
+      return createVNode(props.tag, null, {
+        default: () => [props.icon]
+      });
+    };
+  }
+});
+var VClassIcon = defineComponent({
+  name: "VClassIcon",
+  props: makeIconProps(),
+  setup(props) {
+    return () => {
+      return createVNode(props.tag, {
+        "class": props.icon
+      }, null);
+    };
+  }
+});
+var defaultSets = {
+  svg: {
+    component: VSvgIcon
+  },
+  class: {
+    component: VClassIcon
+  }
+};
+function createIcons(options) {
+  return mergeDeep({
+    defaultSet: "mdi",
+    sets: {
+      ...defaultSets,
+      mdi
+    },
+    aliases: {
+      ...aliases,
+      /* eslint-disable max-len */
+      vuetify: ["M8.2241 14.2009L12 21L22 3H14.4459L8.2241 14.2009Z", ["M7.26303 12.4733L7.00113 12L2 3H12.5261C12.5261 3 12.5261 3 12.5261 3L7.26303 12.4733Z", 0.6]],
+      "vuetify-outline": "svg:M7.26 12.47 12.53 3H2L7.26 12.47ZM14.45 3 8.22 14.2 12 21 22 3H14.45ZM18.6 5 12 16.88 10.51 14.2 15.62 5ZM7.26 8.35 5.4 5H9.13L7.26 8.35Z"
+      /* eslint-enable max-len */
+    }
+  }, options);
+}
+var useIcon = (props) => {
+  const icons = inject(IconSymbol);
+  if (!icons) throw new Error("Missing Vuetify Icons provide!");
+  const iconData = computed(() => {
+    var _a;
+    const iconAlias = unref(props);
+    if (!iconAlias) return {
+      component: VComponentIcon
+    };
+    let icon = iconAlias;
+    if (typeof icon === "string") {
+      icon = icon.trim();
+      if (icon.startsWith("$")) {
+        icon = (_a = icons.aliases) == null ? void 0 : _a[icon.slice(1)];
+      }
+    }
+    if (!icon) throw new Error(`Could not find aliased icon "${iconAlias}"`);
+    if (Array.isArray(icon)) {
+      return {
+        component: VSvgIcon,
+        icon
+      };
+    } else if (typeof icon !== "string") {
+      return {
+        component: VComponentIcon,
+        icon
+      };
+    }
+    const iconSetName = Object.keys(icons.sets).find((setName) => typeof icon === "string" && icon.startsWith(`${setName}:`));
+    const iconName = iconSetName ? icon.slice(iconSetName.length + 1) : icon;
+    const iconSet = icons.sets[iconSetName ?? icons.defaultSet];
+    return {
+      component: iconSet.component,
+      icon: iconName
+    };
+  });
+  return {
+    iconData
+  };
+};
+
+export {
+  IconValue,
+  IconSymbol,
+  VComponentIcon,
+  VSvgIcon,
+  VLigatureIcon,
+  VClassIcon,
+  createIcons,
+  useIcon
+};
+//# sourceMappingURL=chunk-472DNWSX.js.map

VApp/node_modules/.vite/deps/chunk-4GJMZCX5.js

@@ -0,0 +1,769 @@
+import {
+  ripple_default
+} from "./chunk-NMCVREUK.js";
+import {
+  makeElevationProps,
+  useElevation
+} from "./chunk-QXA6VMYU.js";
+import {
+  VInput,
+  makeFocusProps,
+  makeVInputProps,
+  useFocus
+} from "./chunk-ZCXGZYP7.js";
+import {
+  makeRoundedProps,
+  useRounded
+} from "./chunk-24LK52JF.js";
+import {
+  VScaleTransition
+} from "./chunk-JVZUVJAC.js";
+import {
+  useBackgroundColor,
+  useTextColor
+} from "./chunk-ZZ55KHRR.js";
+import {
+  useRtl
+} from "./chunk-IR5437QA.js";
+import {
+  useProxiedModel
+} from "./chunk-PVQHDZXM.js";
+import {
+  VLabel
+} from "./chunk-J5HFPFMJ.js";
+import {
+  clamp,
+  convertToUnit,
+  createRange,
+  genericComponent,
+  getDecimals,
+  keyValues,
+  makeComponentProps,
+  propsFactory,
+  useRender
+} from "./chunk-I4KGD5X4.js";
+import {
+  Fragment,
+  computed,
+  createVNode,
+  inject,
+  mergeProps,
+  provide,
+  ref,
+  resolveDirective,
+  shallowRef,
+  toRef,
+  vShow,
+  withDirectives
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/components/VSlider/VSlider.mjs
+import "C:/Users/Jeremy/Documents/Dev/Projects.cloudsucks.net/Vulture/VApp/node_modules/vuetify/lib/components/VSlider/VSlider.css";
+
+// node_modules/vuetify/lib/components/VSlider/VSliderThumb.mjs
+import "C:/Users/Jeremy/Documents/Dev/Projects.cloudsucks.net/Vulture/VApp/node_modules/vuetify/lib/components/VSlider/VSliderThumb.css";
+
+// node_modules/vuetify/lib/components/VSlider/slider.mjs
+var VSliderSymbol = Symbol.for("vuetify:v-slider");
+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];
+}
+var 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: void 0,
+    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");
+var 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
+  };
+};
+var 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 ? void 0 : props.thumbColor ?? props.color);
+  const trackColor = computed(() => props.error || props.disabled ? void 0 : props.trackColor ?? props.color);
+  const trackFillColor = computed(() => props.error || props.disabled ? void 0 : props.trackFillColor ?? props.color);
+  const mousePressed = shallowRef(false);
+  const startOffset = shallowRef(0);
+  const trackContainerRef = ref();
+  const activeThumbRef = ref();
+  function parseMouseMove(e) {
+    var _a;
+    const vertical2 = props.direction === "vertical";
+    const start = vertical2 ? "top" : "left";
+    const length = vertical2 ? "height" : "width";
+    const position2 = vertical2 ? "clientY" : "clientX";
+    const {
+      [start]: trackStart,
+      [length]: trackLength
+    } = (_a = trackContainerRef.value) == null ? void 0 : _a.$el.getBoundingClientRect();
+    const clickOffset = getPosition(e, position2);
+    let clickPos = Math.min(Math.max((clickOffset - trackStart - startOffset.value) / trackLength, 0), 1) || 0;
+    if (vertical2 ? 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) {
+    var _a;
+    handleStop(e);
+    window.removeEventListener("touchmove", onMouseMove, moveListenerOptions);
+    (_a = e.target) == null ? void 0 : _a.removeEventListener("touchend", onSliderTouchend);
+  }
+  function onSliderTouchstart(e) {
+    var _a;
+    handleStart(e);
+    window.addEventListener("touchmove", onMouseMove, moveListenerOptions);
+    (_a = e.target) == null ? void 0 : _a.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;
+};
+
+// node_modules/vuetify/lib/components/VSlider/VSliderThumb.mjs
+var 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");
+var VSliderThumb = genericComponent()({
+  name: "VSliderThumb",
+  directives: {
+    Ripple: ripple_default
+  },
+  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 : void 0);
+    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 direction2 = increase.includes(e.key) ? 1 : -1;
+        const multiplier = e.shiftKey ? 2 : e.ctrlKey ? 1 : 0;
+        value = value + direction2 * _step * multipliers.value[multiplier];
+      } else if (e.key === home) {
+        value = props.min;
+      } else if (e.key === end) {
+        value = props.max;
+      } else {
+        const direction2 = e.key === pagedown ? 1 : -1;
+        value = value - direction2 * _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 : void 0
+      }, [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: () => {
+          var _a;
+          return [withDirectives(createVNode("div", {
+            "class": "v-slider-thumb__label-container"
+          }, [createVNode("div", {
+            "class": ["v-slider-thumb__label"]
+          }, [createVNode("div", null, [((_a = slots["thumb-label"]) == null ? void 0 : _a.call(slots, {
+            modelValue: props.modelValue
+          })) ?? props.modelValue.toFixed(step.value ? decimals.value : 1)])])]), [[vShow, thumbLabel.value && props.focused || thumbLabel.value === "always"]])];
+        }
+      })]);
+    });
+    return {};
+  }
+});
+
+// node_modules/vuetify/lib/components/VSlider/VSliderTrack.mjs
+import "C:/Users/Jeremy/Documents/Dev/Projects.cloudsucks.net/Vulture/VApp/node_modules/vuetify/lib/components/VSlider/VSliderTrack.css";
+var makeVSliderTrackProps = propsFactory({
+  start: {
+    type: Number,
+    required: true
+  },
+  stop: {
+    type: Number,
+    required: true
+  },
+  ...makeComponentProps()
+}, "VSliderTrack");
+var 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) => {
+        var _a;
+        const directionValue = tick.value !== min.value && tick.value !== max.value ? convertToUnit(tick.position, "%") : void 0;
+        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"
+        }, [((_a = slots["tick-label"]) == null ? void 0 : _a.call(slots, {
+          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 {};
+  }
+});
+
+// node_modules/vuetify/lib/components/VSlider/VSlider.mjs
+var makeVSliderProps = propsFactory({
+  ...makeFocusProps(),
+  ...makeSliderProps(),
+  ...makeVInputProps(),
+  modelValue: {
+    type: [Number, String],
+    default: 0
+  }
+}, "VSlider");
+var 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", void 0, (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: () => {
+        var _a;
+        return (_a = thumbContainerRef.value) == null ? void 0 : _a.$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) => {
+          var _a, _b;
+          return createVNode(Fragment, null, [((_a = slots.label) == null ? void 0 : _a.call(slots, slotProps)) ?? (props.label ? createVNode(VLabel, {
+            "id": slotProps.id.value,
+            "class": "v-slider__label",
+            "text": props.label
+          }, null) : void 0), (_b = slots.prepend) == null ? void 0 : _b.call(slots, slotProps)]);
+        } : void 0,
+        default: (_ref4) => {
+          let {
+            id,
+            messagesId
+          } = _ref4;
+          return createVNode("div", {
+            "class": "v-slider__container",
+            "onMousedown": !readonly.value ? onSliderMousedown : void 0,
+            "onTouchstartPassive": !readonly.value ? onSliderTouchstart : void 0
+          }, [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 {};
+  }
+});
+
+export {
+  VSlider
+};
+//# sourceMappingURL=chunk-4GJMZCX5.js.map

VApp/node_modules/.vite/deps/chunk-4HSTIW6R.js

@@ -0,0 +1,389 @@
+import {
+  intersect_default
+} from "./chunk-3JAGB4CS.js";
+import {
+  makeDimensionProps,
+  useDimension
+} from "./chunk-O7EUYO3B.js";
+import {
+  makeRoundedProps,
+  useRounded
+} from "./chunk-24LK52JF.js";
+import {
+  MaybeTransition,
+  makeTransitionProps
+} from "./chunk-XRWT7YWI.js";
+import {
+  useBackgroundColor
+} from "./chunk-ZZ55KHRR.js";
+import {
+  SUPPORTS_INTERSECTION,
+  convertToUnit,
+  genericComponent,
+  getCurrentInstance,
+  makeComponentProps,
+  propsFactory,
+  useRender
+} from "./chunk-I4KGD5X4.js";
+import {
+  Fragment,
+  computed,
+  createVNode,
+  mergeProps,
+  nextTick,
+  onBeforeMount,
+  onBeforeUnmount,
+  ref,
+  resolveDirective,
+  shallowRef,
+  toRef,
+  vShow,
+  watch,
+  withDirectives
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/components/VImg/VImg.mjs
+import "C:/Users/Jeremy/Documents/Dev/Projects.cloudsucks.net/Vulture/VApp/node_modules/vuetify/lib/components/VImg/VImg.css";
+
+// node_modules/vuetify/lib/components/VResponsive/VResponsive.mjs
+import "C:/Users/Jeremy/Documents/Dev/Projects.cloudsucks.net/Vulture/VApp/node_modules/vuetify/lib/components/VResponsive/VResponsive.css";
+function useAspectStyles(props) {
+  return {
+    aspectStyles: computed(() => {
+      const ratio = Number(props.aspectRatio);
+      return ratio ? {
+        paddingBottom: String(1 / ratio * 100) + "%"
+      } : void 0;
+    })
+  };
+}
+var makeVResponsiveProps = propsFactory({
+  aspectRatio: [String, Number],
+  contentClass: String,
+  inline: Boolean,
+  ...makeComponentProps(),
+  ...makeDimensionProps()
+}, "VResponsive");
+var VResponsive = genericComponent()({
+  name: "VResponsive",
+  props: makeVResponsiveProps(),
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    const {
+      aspectStyles
+    } = useAspectStyles(props);
+    const {
+      dimensionStyles
+    } = useDimension(props);
+    useRender(() => {
+      var _a;
+      return createVNode("div", {
+        "class": ["v-responsive", {
+          "v-responsive--inline": props.inline
+        }, props.class],
+        "style": [dimensionStyles.value, props.style]
+      }, [createVNode("div", {
+        "class": "v-responsive__sizer",
+        "style": aspectStyles.value
+      }, null), (_a = slots.additional) == null ? void 0 : _a.call(slots), slots.default && createVNode("div", {
+        "class": ["v-responsive__content", props.contentClass]
+      }, [slots.default()])]);
+    });
+    return {};
+  }
+});
+
+// node_modules/vuetify/lib/components/VImg/VImg.mjs
+var makeVImgProps = propsFactory({
+  alt: String,
+  cover: Boolean,
+  color: String,
+  draggable: {
+    type: [Boolean, String],
+    default: void 0
+  },
+  eager: Boolean,
+  gradient: String,
+  lazySrc: String,
+  options: {
+    type: Object,
+    // For more information on types, navigate to:
+    // https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API
+    default: () => ({
+      root: void 0,
+      rootMargin: void 0,
+      threshold: void 0
+    })
+  },
+  sizes: String,
+  src: {
+    type: [String, Object],
+    default: ""
+  },
+  crossorigin: String,
+  referrerpolicy: String,
+  srcset: String,
+  position: String,
+  ...makeVResponsiveProps(),
+  ...makeComponentProps(),
+  ...makeRoundedProps(),
+  ...makeTransitionProps()
+}, "VImg");
+var VImg = genericComponent()({
+  name: "VImg",
+  directives: {
+    intersect: intersect_default
+  },
+  props: makeVImgProps(),
+  emits: {
+    loadstart: (value) => true,
+    load: (value) => true,
+    error: (value) => true
+  },
+  setup(props, _ref) {
+    let {
+      emit,
+      slots
+    } = _ref;
+    const {
+      backgroundColorClasses,
+      backgroundColorStyles
+    } = useBackgroundColor(toRef(props, "color"));
+    const {
+      roundedClasses
+    } = useRounded(props);
+    const vm = getCurrentInstance("VImg");
+    const currentSrc = shallowRef("");
+    const image = ref();
+    const state = shallowRef(props.eager ? "loading" : "idle");
+    const naturalWidth = shallowRef();
+    const naturalHeight = shallowRef();
+    const normalisedSrc = computed(() => {
+      return props.src && typeof props.src === "object" ? {
+        src: props.src.src,
+        srcset: props.srcset || props.src.srcset,
+        lazySrc: props.lazySrc || props.src.lazySrc,
+        aspect: Number(props.aspectRatio || props.src.aspect || 0)
+      } : {
+        src: props.src,
+        srcset: props.srcset,
+        lazySrc: props.lazySrc,
+        aspect: Number(props.aspectRatio || 0)
+      };
+    });
+    const aspectRatio = computed(() => {
+      return normalisedSrc.value.aspect || naturalWidth.value / naturalHeight.value || 0;
+    });
+    watch(() => props.src, () => {
+      init(state.value !== "idle");
+    });
+    watch(aspectRatio, (val, oldVal) => {
+      if (!val && oldVal && image.value) {
+        pollForSize(image.value);
+      }
+    });
+    onBeforeMount(() => init());
+    function init(isIntersecting) {
+      if (props.eager && isIntersecting) return;
+      if (SUPPORTS_INTERSECTION && !isIntersecting && !props.eager) return;
+      state.value = "loading";
+      if (normalisedSrc.value.lazySrc) {
+        const lazyImg = new Image();
+        lazyImg.src = normalisedSrc.value.lazySrc;
+        pollForSize(lazyImg, null);
+      }
+      if (!normalisedSrc.value.src) return;
+      nextTick(() => {
+        var _a;
+        emit("loadstart", ((_a = image.value) == null ? void 0 : _a.currentSrc) || normalisedSrc.value.src);
+        setTimeout(() => {
+          var _a2;
+          if (vm.isUnmounted) return;
+          if ((_a2 = image.value) == null ? void 0 : _a2.complete) {
+            if (!image.value.naturalWidth) {
+              onError();
+            }
+            if (state.value === "error") return;
+            if (!aspectRatio.value) pollForSize(image.value, null);
+            if (state.value === "loading") onLoad();
+          } else {
+            if (!aspectRatio.value) pollForSize(image.value);
+            getSrc();
+          }
+        });
+      });
+    }
+    function onLoad() {
+      var _a;
+      if (vm.isUnmounted) return;
+      getSrc();
+      pollForSize(image.value);
+      state.value = "loaded";
+      emit("load", ((_a = image.value) == null ? void 0 : _a.currentSrc) || normalisedSrc.value.src);
+    }
+    function onError() {
+      var _a;
+      if (vm.isUnmounted) return;
+      state.value = "error";
+      emit("error", ((_a = image.value) == null ? void 0 : _a.currentSrc) || normalisedSrc.value.src);
+    }
+    function getSrc() {
+      const img = image.value;
+      if (img) currentSrc.value = img.currentSrc || img.src;
+    }
+    let timer = -1;
+    onBeforeUnmount(() => {
+      clearTimeout(timer);
+    });
+    function pollForSize(img) {
+      let timeout = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 100;
+      const poll = () => {
+        clearTimeout(timer);
+        if (vm.isUnmounted) return;
+        const {
+          naturalHeight: imgHeight,
+          naturalWidth: imgWidth
+        } = img;
+        if (imgHeight || imgWidth) {
+          naturalWidth.value = imgWidth;
+          naturalHeight.value = imgHeight;
+        } else if (!img.complete && state.value === "loading" && timeout != null) {
+          timer = window.setTimeout(poll, timeout);
+        } else if (img.currentSrc.endsWith(".svg") || img.currentSrc.startsWith("data:image/svg+xml")) {
+          naturalWidth.value = 1;
+          naturalHeight.value = 1;
+        }
+      };
+      poll();
+    }
+    const containClasses = computed(() => ({
+      "v-img__img--cover": props.cover,
+      "v-img__img--contain": !props.cover
+    }));
+    const __image = () => {
+      var _a;
+      if (!normalisedSrc.value.src || state.value === "idle") return null;
+      const img = createVNode("img", {
+        "class": ["v-img__img", containClasses.value],
+        "style": {
+          objectPosition: props.position
+        },
+        "src": normalisedSrc.value.src,
+        "srcset": normalisedSrc.value.srcset,
+        "alt": props.alt,
+        "crossorigin": props.crossorigin,
+        "referrerpolicy": props.referrerpolicy,
+        "draggable": props.draggable,
+        "sizes": props.sizes,
+        "ref": image,
+        "onLoad": onLoad,
+        "onError": onError
+      }, null);
+      const sources = (_a = slots.sources) == null ? void 0 : _a.call(slots);
+      return createVNode(MaybeTransition, {
+        "transition": props.transition,
+        "appear": true
+      }, {
+        default: () => [withDirectives(sources ? createVNode("picture", {
+          "class": "v-img__picture"
+        }, [sources, img]) : img, [[vShow, state.value === "loaded"]])]
+      });
+    };
+    const __preloadImage = () => createVNode(MaybeTransition, {
+      "transition": props.transition
+    }, {
+      default: () => [normalisedSrc.value.lazySrc && state.value !== "loaded" && createVNode("img", {
+        "class": ["v-img__img", "v-img__img--preload", containClasses.value],
+        "style": {
+          objectPosition: props.position
+        },
+        "src": normalisedSrc.value.lazySrc,
+        "alt": props.alt,
+        "crossorigin": props.crossorigin,
+        "referrerpolicy": props.referrerpolicy,
+        "draggable": props.draggable
+      }, null)]
+    });
+    const __placeholder = () => {
+      if (!slots.placeholder) return null;
+      return createVNode(MaybeTransition, {
+        "transition": props.transition,
+        "appear": true
+      }, {
+        default: () => [(state.value === "loading" || state.value === "error" && !slots.error) && createVNode("div", {
+          "class": "v-img__placeholder"
+        }, [slots.placeholder()])]
+      });
+    };
+    const __error = () => {
+      if (!slots.error) return null;
+      return createVNode(MaybeTransition, {
+        "transition": props.transition,
+        "appear": true
+      }, {
+        default: () => [state.value === "error" && createVNode("div", {
+          "class": "v-img__error"
+        }, [slots.error()])]
+      });
+    };
+    const __gradient = () => {
+      if (!props.gradient) return null;
+      return createVNode("div", {
+        "class": "v-img__gradient",
+        "style": {
+          backgroundImage: `linear-gradient(${props.gradient})`
+        }
+      }, null);
+    };
+    const isBooted = shallowRef(false);
+    {
+      const stop = watch(aspectRatio, (val) => {
+        if (val) {
+          requestAnimationFrame(() => {
+            requestAnimationFrame(() => {
+              isBooted.value = true;
+            });
+          });
+          stop();
+        }
+      });
+    }
+    useRender(() => {
+      const responsiveProps = VResponsive.filterProps(props);
+      return withDirectives(createVNode(VResponsive, mergeProps({
+        "class": ["v-img", {
+          "v-img--booting": !isBooted.value
+        }, backgroundColorClasses.value, roundedClasses.value, props.class],
+        "style": [{
+          width: convertToUnit(props.width === "auto" ? naturalWidth.value : props.width)
+        }, backgroundColorStyles.value, props.style]
+      }, responsiveProps, {
+        "aspectRatio": aspectRatio.value,
+        "aria-label": props.alt,
+        "role": props.alt ? "img" : void 0
+      }), {
+        additional: () => createVNode(Fragment, null, [createVNode(__image, null, null), createVNode(__preloadImage, null, null), createVNode(__gradient, null, null), createVNode(__placeholder, null, null), createVNode(__error, null, null)]),
+        default: slots.default
+      }), [[resolveDirective("intersect"), {
+        handler: init,
+        options: props.options
+      }, null, {
+        once: true
+      }]]);
+    });
+    return {
+      currentSrc,
+      image,
+      state,
+      naturalWidth,
+      naturalHeight
+    };
+  }
+});
+
+export {
+  VImg
+};
+//# sourceMappingURL=chunk-4HSTIW6R.js.map

VApp/node_modules/.vite/deps/chunk-5XLJYRDC.js

@@ -0,0 +1,125 @@
+import {
+  VImg
+} from "./chunk-4HSTIW6R.js";
+import {
+  genOverlays,
+  makeVariantProps,
+  useVariant
+} from "./chunk-XQKRKMJT.js";
+import {
+  VDefaultsProvider
+} from "./chunk-D42AK3WB.js";
+import {
+  makeDensityProps,
+  useDensity
+} from "./chunk-VQPKT5F7.js";
+import {
+  makeRoundedProps,
+  useRounded
+} from "./chunk-24LK52JF.js";
+import {
+  VIcon,
+  makeSizeProps,
+  useSize
+} from "./chunk-IFUDBK56.js";
+import {
+  IconValue
+} from "./chunk-472DNWSX.js";
+import {
+  makeTagProps
+} from "./chunk-DJRL4NAD.js";
+import {
+  makeThemeProps,
+  provideTheme
+} from "./chunk-CYOEVGGH.js";
+import {
+  genericComponent,
+  makeComponentProps,
+  propsFactory,
+  useRender
+} from "./chunk-I4KGD5X4.js";
+import {
+  createVNode
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/components/VAvatar/VAvatar.mjs
+import "C:/Users/Jeremy/Documents/Dev/Projects.cloudsucks.net/Vulture/VApp/node_modules/vuetify/lib/components/VAvatar/VAvatar.css";
+var makeVAvatarProps = propsFactory({
+  start: Boolean,
+  end: Boolean,
+  icon: IconValue,
+  image: String,
+  text: String,
+  ...makeComponentProps(),
+  ...makeDensityProps(),
+  ...makeRoundedProps(),
+  ...makeSizeProps(),
+  ...makeTagProps(),
+  ...makeThemeProps(),
+  ...makeVariantProps({
+    variant: "flat"
+  })
+}, "VAvatar");
+var VAvatar = genericComponent()({
+  name: "VAvatar",
+  props: makeVAvatarProps(),
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    const {
+      themeClasses
+    } = provideTheme(props);
+    const {
+      colorClasses,
+      colorStyles,
+      variantClasses
+    } = useVariant(props);
+    const {
+      densityClasses
+    } = useDensity(props);
+    const {
+      roundedClasses
+    } = useRounded(props);
+    const {
+      sizeClasses,
+      sizeStyles
+    } = useSize(props);
+    useRender(() => createVNode(props.tag, {
+      "class": ["v-avatar", {
+        "v-avatar--start": props.start,
+        "v-avatar--end": props.end
+      }, themeClasses.value, colorClasses.value, densityClasses.value, roundedClasses.value, sizeClasses.value, variantClasses.value, props.class],
+      "style": [colorStyles.value, sizeStyles.value, props.style]
+    }, {
+      default: () => [!slots.default ? props.image ? createVNode(VImg, {
+        "key": "image",
+        "src": props.image,
+        "alt": "",
+        "cover": true
+      }, null) : props.icon ? createVNode(VIcon, {
+        "key": "icon",
+        "icon": props.icon
+      }, null) : props.text : createVNode(VDefaultsProvider, {
+        "key": "content-defaults",
+        "defaults": {
+          VImg: {
+            cover: true,
+            image: props.image
+          },
+          VIcon: {
+            icon: props.icon
+          }
+        }
+      }, {
+        default: () => [slots.default()]
+      }), genOverlays(false, "v-avatar")]
+    }));
+    return {};
+  }
+});
+
+export {
+  VAvatar
+};
+//# sourceMappingURL=chunk-5XLJYRDC.js.map

VApp/node_modules/.vite/deps/chunk-5XLJYRDC.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../vuetify/src/components/VAvatar/VAvatar.tsx"],
+  "sourcesContent": ["// Styles\nimport './VAvatar.sass'\n\n// Components\nimport { VDefaultsProvider } from '@/components/VDefaultsProvider'\nimport { VIcon } from '@/components/VIcon'\nimport { VImg } from '@/components/VImg'\n\n// Composables\nimport { makeComponentProps } from '@/composables/component'\nimport { makeDensityProps, useDensity } from '@/composables/density'\nimport { IconValue } from '@/composables/icons'\nimport { makeRoundedProps, useRounded } from '@/composables/rounded'\nimport { makeSizeProps, useSize } from '@/composables/size'\nimport { makeTagProps } from '@/composables/tag'\nimport { makeThemeProps, provideTheme } from '@/composables/theme'\nimport { genOverlays, makeVariantProps, useVariant } from '@/composables/variant'\n\n// Utilities\nimport { genericComponent, propsFactory, useRender } from '@/util'\n\nexport const makeVAvatarProps = propsFactory({\n  start: Boolean,\n  end: Boolean,\n  icon: IconValue,\n  image: String,\n  text: String,\n\n  ...makeComponentProps(),\n  ...makeDensityProps(),\n  ...makeRoundedProps(),\n  ...makeSizeProps(),\n  ...makeTagProps(),\n  ...makeThemeProps(),\n  ...makeVariantProps({ variant: 'flat' } as const),\n}, 'VAvatar')\n\nexport const VAvatar = genericComponent()({\n  name: 'VAvatar',\n\n  props: makeVAvatarProps(),\n\n  setup (props, { slots }) {\n    const { themeClasses } = provideTheme(props)\n    const { colorClasses, colorStyles, variantClasses } = useVariant(props)\n    const { densityClasses } = useDensity(props)\n    const { roundedClasses } = useRounded(props)\n    const { sizeClasses, sizeStyles } = useSize(props)\n\n    useRender(() => (\n      <props.tag\n        class={[\n          'v-avatar',\n          {\n            'v-avatar--start': props.start,\n            'v-avatar--end': props.end,\n          },\n          themeClasses.value,\n          colorClasses.value,\n          densityClasses.value,\n          roundedClasses.value,\n          sizeClasses.value,\n          variantClasses.value,\n          props.class,\n        ]}\n        style={[\n          colorStyles.value,\n          sizeStyles.value,\n          props.style,\n        ]}\n      >\n        { !slots.default ? (\n          props.image\n            ? (<VImg key=\"image\" src={ props.image } alt=\"\" cover />)\n            : props.icon\n              ? (<VIcon key=\"icon\" icon={ props.icon } />)\n              : props.text\n        ) : (\n          <VDefaultsProvider\n            key=\"content-defaults\"\n            defaults={{\n              VImg: {\n                cover: true,\n                image: props.image,\n              },\n              VIcon: {\n                icon: props.icon,\n              },\n            }}\n          >\n            { slots.default() }\n          </VDefaultsProvider>\n        )}\n\n        { genOverlays(false, 'v-avatar') }\n      </props.tag>\n    ))\n\n    return {}\n  },\n})\n\nexport type VAvatar = InstanceType<typeof VAvatar>\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,OAAA;AAoBO,IAAMA,mBAAmBC,aAAa;EAC3CC,OAAOC;EACPC,KAAKD;EACLE,MAAMC;EACNC,OAAOC;EACPC,MAAMD;EAEN,GAAGE,mBAAmB;EACtB,GAAGC,iBAAiB;EACpB,GAAGC,iBAAiB;EACpB,GAAGC,cAAc;EACjB,GAAGC,aAAa;EAChB,GAAGC,eAAe;EAClB,GAAGC,iBAAiB;IAAEC,SAAS;EAAO,CAAU;AAClD,GAAG,SAAS;AAEL,IAAMC,UAAUC,iBAAiB,EAAE;EACxCC,MAAM;EAENC,OAAOrB,iBAAiB;EAExBsB,MAAOD,OAAKE,MAAa;AAAA,QAAX;MAAEC;IAAM,IAACD;AACrB,UAAM;MAAEE;IAAa,IAAIC,aAAaL,KAAK;AAC3C,UAAM;MAAEM;MAAcC;MAAaC;IAAe,IAAIC,WAAWT,KAAK;AACtE,UAAM;MAAEU;IAAe,IAAIC,WAAWX,KAAK;AAC3C,UAAM;MAAEY;IAAe,IAAIC,WAAWb,KAAK;AAC3C,UAAM;MAAEc;MAAaC;IAAW,IAAIC,QAAQhB,KAAK;AAEjDiB,cAAU,MAAAC,YAAAlB,MAAAmB,KAAA;MAAA,SAEC,CACL,YACA;QACE,mBAAmBnB,MAAMnB;QACzB,iBAAiBmB,MAAMjB;MACzB,GACAqB,aAAagB,OACbd,aAAac,OACbV,eAAeU,OACfR,eAAeQ,OACfN,YAAYM,OACZZ,eAAeY,OACfpB,MAAMqB,KAAK;MACZ,SACM,CACLd,YAAYa,OACZL,WAAWK,OACXpB,MAAMsB,KAAK;IACZ,GAAA;MAAAC,SAAAA,MAAA,CAEC,CAACpB,MAAMoB,UACPvB,MAAMd,QAAKgC,YAAAM,MAAA;QAAA,OAAA;QAAA,OACkBxB,MAAMd;QAAK,OAAA;QAAA,SAAA;MAAA,GAAA,IAAA,IACpCc,MAAMhB,OAAIkC,YAAAO,OAAA;QAAA,OAAA;QAAA,QACkBzB,MAAMhB;MAAI,GAAA,IAAA,IACpCgB,MAAMZ,OAAI8B,YAAAQ,mBAAA;QAAA,OAAA;QAAA,YAIJ;UACRF,MAAM;YACJG,OAAO;YACPzC,OAAOc,MAAMd;UACf;UACAuC,OAAO;YACLzC,MAAMgB,MAAMhB;UACd;QACF;MAAC,GAAA;QAAAuC,SAAAA,MAAA,CAECpB,MAAMoB,QAAQ,CAAC;MAAA,CAAA,GAInBK,YAAY,OAAO,UAAU,CAAC;IAAA,CAAA,CAEnC;AAED,WAAO,CAAC;EACV;AACF,CAAC;",
+  "names": ["makeVAvatarProps", "propsFactory", "start", "Boolean", "end", "icon", "IconValue", "image", "String", "text", "makeComponentProps", "makeDensityProps", "makeRoundedProps", "makeSizeProps", "makeTagProps", "makeThemeProps", "makeVariantProps", "variant", "VAvatar", "genericComponent", "name", "props", "setup", "_ref", "slots", "themeClasses", "provideTheme", "colorClasses", "colorStyles", "variantClasses", "useVariant", "densityClasses", "useDensity", "roundedClasses", "useRounded", "sizeClasses", "sizeStyles", "useSize", "useRender", "_createVNode", "tag", "value", "class", "style", "default", "VImg", "VIcon", "VDefaultsProvider", "cover", "genOverlays"]
+}

VApp/node_modules/.vite/deps/chunk-6MYZNPKW.js

@@ -0,0 +1,49 @@
+import {
+  IN_BROWSER,
+  refElement
+} from "./chunk-I4KGD5X4.js";
+import {
+  onBeforeUnmount,
+  readonly,
+  ref,
+  watch
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/composables/resizeObserver.mjs
+function useResizeObserver(callback) {
+  let box = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "content";
+  const resizeRef = ref();
+  const contentRect = ref();
+  if (IN_BROWSER) {
+    const observer = new ResizeObserver((entries) => {
+      callback == null ? void 0 : callback(entries, observer);
+      if (!entries.length) return;
+      if (box === "content") {
+        contentRect.value = entries[0].contentRect;
+      } else {
+        contentRect.value = entries[0].target.getBoundingClientRect();
+      }
+    });
+    onBeforeUnmount(() => {
+      observer.disconnect();
+    });
+    watch(resizeRef, (newValue, oldValue) => {
+      if (oldValue) {
+        observer.unobserve(refElement(oldValue));
+        contentRect.value = void 0;
+      }
+      if (newValue) observer.observe(refElement(newValue));
+    }, {
+      flush: "post"
+    });
+  }
+  return {
+    resizeRef,
+    contentRect: readonly(contentRect)
+  };
+}
+
+export {
+  useResizeObserver
+};
+//# sourceMappingURL=chunk-6MYZNPKW.js.map

VApp/node_modules/.vite/deps/chunk-6MYZNPKW.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../vuetify/src/composables/resizeObserver.ts"],
+  "sourcesContent": ["// Utilities\nimport { onBeforeUnmount, readonly, ref, watch } from 'vue'\nimport { refElement } from '@/util'\nimport { IN_BROWSER } from '@/util/globals'\n\n// Types\nimport type { DeepReadonly, Ref } from 'vue'\n\ninterface ResizeState {\n  resizeRef: Ref<HTMLElement | undefined>\n  contentRect: DeepReadonly<Ref<DOMRectReadOnly | undefined>>\n}\n\nexport function useResizeObserver (callback?: ResizeObserverCallback, box: 'content' | 'border' = 'content'): ResizeState {\n  const resizeRef = ref<HTMLElement>()\n  const contentRect = ref<DOMRectReadOnly>()\n\n  if (IN_BROWSER) {\n    const observer = new ResizeObserver((entries: ResizeObserverEntry[]) => {\n      callback?.(entries, observer)\n\n      if (!entries.length) return\n\n      if (box === 'content') {\n        contentRect.value = entries[0].contentRect\n      } else {\n        contentRect.value = entries[0].target.getBoundingClientRect()\n      }\n    })\n\n    onBeforeUnmount(() => {\n      observer.disconnect()\n    })\n\n    watch(resizeRef, (newValue, oldValue) => {\n      if (oldValue) {\n        observer.unobserve(refElement(oldValue) as Element)\n        contentRect.value = undefined\n      }\n\n      if (newValue) observer.observe(refElement(newValue) as Element)\n    }, {\n      flush: 'post',\n    })\n  }\n\n  return {\n    resizeRef,\n    contentRect: readonly(contentRect),\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;AAaO,SAASA,kBAAmBC,UAAuF;AAAA,MAApDC,MAAyBC,UAAAC,SAAA,KAAAD,UAAA,CAAA,MAAAE,SAAAF,UAAA,CAAA,IAAG;AAChG,QAAMG,YAAYC,IAAiB;AACnC,QAAMC,cAAcD,IAAqB;AAEzC,MAAIE,YAAY;AACd,UAAMC,WAAW,IAAIC,eAAgBC,aAAmC;AACtEX,2CAAWW,SAASF;AAEpB,UAAI,CAACE,QAAQR,OAAQ;AAErB,UAAIF,QAAQ,WAAW;AACrBM,oBAAYK,QAAQD,QAAQ,CAAC,EAAEJ;MACjC,OAAO;AACLA,oBAAYK,QAAQD,QAAQ,CAAC,EAAEE,OAAOC,sBAAsB;MAC9D;IACF,CAAC;AAEDC,oBAAgB,MAAM;AACpBN,eAASO,WAAW;IACtB,CAAC;AAEDC,UAAMZ,WAAW,CAACa,UAAUC,aAAa;AACvC,UAAIA,UAAU;AACZV,iBAASW,UAAUC,WAAWF,QAAQ,CAAY;AAClDZ,oBAAYK,QAAQR;MACtB;AAEA,UAAIc,SAAUT,UAASa,QAAQD,WAAWH,QAAQ,CAAY;IAChE,GAAG;MACDK,OAAO;IACT,CAAC;EACH;AAEA,SAAO;IACLlB;IACAE,aAAaiB,SAASjB,WAAW;EACnC;AACF;",
+  "names": ["useResizeObserver", "callback", "box", "arguments", "length", "undefined", "resizeRef", "ref", "contentRect", "IN_BROWSER", "observer", "ResizeObserver", "entries", "value", "target", "getBoundingClientRect", "onBeforeUnmount", "disconnect", "watch", "newValue", "oldValue", "unobserve", "refElement", "observe", "flush", "readonly"]
+}

VApp/node_modules/.vite/deps/chunk-7EFRYS5N.js

@@ -0,0 +1,635 @@
+import {
+  intersect_default
+} from "./chunk-3JAGB4CS.js";
+import {
+  forwardRefs
+} from "./chunk-DOBNCX34.js";
+import {
+  VInput,
+  makeFocusProps,
+  makeVInputProps,
+  useFocus,
+  useInputIcon
+} from "./chunk-ZCXGZYP7.js";
+import {
+  LoaderSlot,
+  makeLoaderProps,
+  useLoader
+} from "./chunk-44S2JOLY.js";
+import {
+  makeRoundedProps,
+  useRounded
+} from "./chunk-24LK52JF.js";
+import {
+  VExpandXTransition,
+  VSlideYTransition
+} from "./chunk-JVZUVJAC.js";
+import {
+  MaybeTransition,
+  makeTransitionProps
+} from "./chunk-XRWT7YWI.js";
+import {
+  useBackgroundColor,
+  useTextColor
+} from "./chunk-ZZ55KHRR.js";
+import {
+  IconValue
+} from "./chunk-472DNWSX.js";
+import {
+  useRtl
+} from "./chunk-IR5437QA.js";
+import {
+  useProxiedModel
+} from "./chunk-PVQHDZXM.js";
+import {
+  VLabel
+} from "./chunk-J5HFPFMJ.js";
+import {
+  makeThemeProps,
+  provideTheme
+} from "./chunk-CYOEVGGH.js";
+import {
+  EventProp,
+  animate,
+  callEvent,
+  convertToUnit,
+  filterInputAttrs,
+  genericComponent,
+  getUid,
+  isOn,
+  makeComponentProps,
+  nullifyTransforms,
+  pick,
+  propsFactory,
+  standardEasing,
+  useRender
+} from "./chunk-I4KGD5X4.js";
+import {
+  Fragment,
+  cloneVNode,
+  computed,
+  createVNode,
+  mergeProps,
+  nextTick,
+  ref,
+  resolveDirective,
+  toRef,
+  vShow,
+  watch,
+  withDirectives
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/components/VTextField/VTextField.mjs
+import "C:/Users/Jeremy/Documents/Dev/Projects.cloudsucks.net/Vulture/VApp/node_modules/vuetify/lib/components/VTextField/VTextField.css";
+
+// node_modules/vuetify/lib/components/VCounter/VCounter.mjs
+import "C:/Users/Jeremy/Documents/Dev/Projects.cloudsucks.net/Vulture/VApp/node_modules/vuetify/lib/components/VCounter/VCounter.css";
+var makeVCounterProps = propsFactory({
+  active: Boolean,
+  max: [Number, String],
+  value: {
+    type: [Number, String],
+    default: 0
+  },
+  ...makeComponentProps(),
+  ...makeTransitionProps({
+    transition: {
+      component: VSlideYTransition
+    }
+  })
+}, "VCounter");
+var VCounter = genericComponent()({
+  name: "VCounter",
+  functional: true,
+  props: makeVCounterProps(),
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    const counter = computed(() => {
+      return props.max ? `${props.value} / ${props.max}` : String(props.value);
+    });
+    useRender(() => createVNode(MaybeTransition, {
+      "transition": props.transition
+    }, {
+      default: () => [withDirectives(createVNode("div", {
+        "class": ["v-counter", props.class],
+        "style": props.style
+      }, [slots.default ? slots.default({
+        counter: counter.value,
+        max: props.max,
+        value: props.value
+      }) : counter.value]), [[vShow, props.active]])]
+    }));
+    return {};
+  }
+});
+
+// node_modules/vuetify/lib/components/VField/VField.mjs
+import "C:/Users/Jeremy/Documents/Dev/Projects.cloudsucks.net/Vulture/VApp/node_modules/vuetify/lib/components/VField/VField.css";
+
+// node_modules/vuetify/lib/components/VField/VFieldLabel.mjs
+var makeVFieldLabelProps = propsFactory({
+  floating: Boolean,
+  ...makeComponentProps()
+}, "VFieldLabel");
+var VFieldLabel = genericComponent()({
+  name: "VFieldLabel",
+  props: makeVFieldLabelProps(),
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    useRender(() => createVNode(VLabel, {
+      "class": ["v-field-label", {
+        "v-field-label--floating": props.floating
+      }, props.class],
+      "style": props.style,
+      "aria-hidden": props.floating || void 0
+    }, slots));
+    return {};
+  }
+});
+
+// node_modules/vuetify/lib/components/VField/VField.mjs
+var allowedVariants = ["underlined", "outlined", "filled", "solo", "solo-inverted", "solo-filled", "plain"];
+var makeVFieldProps = propsFactory({
+  appendInnerIcon: IconValue,
+  bgColor: String,
+  clearable: Boolean,
+  clearIcon: {
+    type: IconValue,
+    default: "$clear"
+  },
+  active: Boolean,
+  centerAffix: {
+    type: Boolean,
+    default: void 0
+  },
+  color: String,
+  baseColor: String,
+  dirty: Boolean,
+  disabled: {
+    type: Boolean,
+    default: null
+  },
+  error: Boolean,
+  flat: Boolean,
+  label: String,
+  persistentClear: Boolean,
+  prependInnerIcon: IconValue,
+  reverse: Boolean,
+  singleLine: Boolean,
+  variant: {
+    type: String,
+    default: "filled",
+    validator: (v) => allowedVariants.includes(v)
+  },
+  "onClick:clear": EventProp(),
+  "onClick:appendInner": EventProp(),
+  "onClick:prependInner": EventProp(),
+  ...makeComponentProps(),
+  ...makeLoaderProps(),
+  ...makeRoundedProps(),
+  ...makeThemeProps()
+}, "VField");
+var VField = genericComponent()({
+  name: "VField",
+  inheritAttrs: false,
+  props: {
+    id: String,
+    ...makeFocusProps(),
+    ...makeVFieldProps()
+  },
+  emits: {
+    "update:focused": (focused) => true,
+    "update:modelValue": (value) => true
+  },
+  setup(props, _ref) {
+    let {
+      attrs,
+      emit,
+      slots
+    } = _ref;
+    const {
+      themeClasses
+    } = provideTheme(props);
+    const {
+      loaderClasses
+    } = useLoader(props);
+    const {
+      focusClasses,
+      isFocused,
+      focus,
+      blur
+    } = useFocus(props);
+    const {
+      InputIcon
+    } = useInputIcon(props);
+    const {
+      roundedClasses
+    } = useRounded(props);
+    const {
+      rtlClasses
+    } = useRtl();
+    const isActive = computed(() => props.dirty || props.active);
+    const hasLabel = computed(() => !props.singleLine && !!(props.label || slots.label));
+    const uid = getUid();
+    const id = computed(() => props.id || `input-${uid}`);
+    const messagesId = computed(() => `${id.value}-messages`);
+    const labelRef = ref();
+    const floatingLabelRef = ref();
+    const controlRef = ref();
+    const isPlainOrUnderlined = computed(() => ["plain", "underlined"].includes(props.variant));
+    const {
+      backgroundColorClasses,
+      backgroundColorStyles
+    } = useBackgroundColor(toRef(props, "bgColor"));
+    const {
+      textColorClasses,
+      textColorStyles
+    } = useTextColor(computed(() => {
+      return props.error || props.disabled ? void 0 : isActive.value && isFocused.value ? props.color : props.baseColor;
+    }));
+    watch(isActive, (val) => {
+      if (hasLabel.value) {
+        const el = labelRef.value.$el;
+        const targetEl = floatingLabelRef.value.$el;
+        requestAnimationFrame(() => {
+          const rect = nullifyTransforms(el);
+          const targetRect = targetEl.getBoundingClientRect();
+          const x = targetRect.x - rect.x;
+          const y = targetRect.y - rect.y - (rect.height / 2 - targetRect.height / 2);
+          const targetWidth = targetRect.width / 0.75;
+          const width = Math.abs(targetWidth - rect.width) > 1 ? {
+            maxWidth: convertToUnit(targetWidth)
+          } : void 0;
+          const style = getComputedStyle(el);
+          const targetStyle = getComputedStyle(targetEl);
+          const duration = parseFloat(style.transitionDuration) * 1e3 || 150;
+          const scale = parseFloat(targetStyle.getPropertyValue("--v-field-label-scale"));
+          const color = targetStyle.getPropertyValue("color");
+          el.style.visibility = "visible";
+          targetEl.style.visibility = "hidden";
+          animate(el, {
+            transform: `translate(${x}px, ${y}px) scale(${scale})`,
+            color,
+            ...width
+          }, {
+            duration,
+            easing: standardEasing,
+            direction: val ? "normal" : "reverse"
+          }).finished.then(() => {
+            el.style.removeProperty("visibility");
+            targetEl.style.removeProperty("visibility");
+          });
+        });
+      }
+    }, {
+      flush: "post"
+    });
+    const slotProps = computed(() => ({
+      isActive,
+      isFocused,
+      controlRef,
+      blur,
+      focus
+    }));
+    function onClick(e) {
+      if (e.target !== document.activeElement) {
+        e.preventDefault();
+      }
+    }
+    useRender(() => {
+      var _a, _b, _c;
+      const isOutlined = props.variant === "outlined";
+      const hasPrepend = slots["prepend-inner"] || props.prependInnerIcon;
+      const hasClear = !!(props.clearable || slots.clear);
+      const hasAppend = !!(slots["append-inner"] || props.appendInnerIcon || hasClear);
+      const label = () => slots.label ? slots.label({
+        ...slotProps.value,
+        label: props.label,
+        props: {
+          for: id.value
+        }
+      }) : props.label;
+      return createVNode("div", mergeProps({
+        "class": ["v-field", {
+          "v-field--active": isActive.value,
+          "v-field--appended": hasAppend,
+          "v-field--center-affix": props.centerAffix ?? !isPlainOrUnderlined.value,
+          "v-field--disabled": props.disabled,
+          "v-field--dirty": props.dirty,
+          "v-field--error": props.error,
+          "v-field--flat": props.flat,
+          "v-field--has-background": !!props.bgColor,
+          "v-field--persistent-clear": props.persistentClear,
+          "v-field--prepended": hasPrepend,
+          "v-field--reverse": props.reverse,
+          "v-field--single-line": props.singleLine,
+          "v-field--no-label": !label(),
+          [`v-field--variant-${props.variant}`]: true
+        }, themeClasses.value, backgroundColorClasses.value, focusClasses.value, loaderClasses.value, roundedClasses.value, rtlClasses.value, props.class],
+        "style": [backgroundColorStyles.value, props.style],
+        "onClick": onClick
+      }, attrs), [createVNode("div", {
+        "class": "v-field__overlay"
+      }, null), createVNode(LoaderSlot, {
+        "name": "v-field",
+        "active": !!props.loading,
+        "color": props.error ? "error" : typeof props.loading === "string" ? props.loading : props.color
+      }, {
+        default: slots.loader
+      }), hasPrepend && createVNode("div", {
+        "key": "prepend",
+        "class": "v-field__prepend-inner"
+      }, [props.prependInnerIcon && createVNode(InputIcon, {
+        "key": "prepend-icon",
+        "name": "prependInner"
+      }, null), (_a = slots["prepend-inner"]) == null ? void 0 : _a.call(slots, slotProps.value)]), createVNode("div", {
+        "class": "v-field__field",
+        "data-no-activator": ""
+      }, [["filled", "solo", "solo-inverted", "solo-filled"].includes(props.variant) && hasLabel.value && createVNode(VFieldLabel, {
+        "key": "floating-label",
+        "ref": floatingLabelRef,
+        "class": [textColorClasses.value],
+        "floating": true,
+        "for": id.value,
+        "style": textColorStyles.value
+      }, {
+        default: () => [label()]
+      }), createVNode(VFieldLabel, {
+        "ref": labelRef,
+        "for": id.value
+      }, {
+        default: () => [label()]
+      }), (_b = slots.default) == null ? void 0 : _b.call(slots, {
+        ...slotProps.value,
+        props: {
+          id: id.value,
+          class: "v-field__input",
+          "aria-describedby": messagesId.value
+        },
+        focus,
+        blur
+      })]), hasClear && createVNode(VExpandXTransition, {
+        "key": "clear"
+      }, {
+        default: () => [withDirectives(createVNode("div", {
+          "class": "v-field__clearable",
+          "onMousedown": (e) => {
+            e.preventDefault();
+            e.stopPropagation();
+          }
+        }, [slots.clear ? slots.clear() : createVNode(InputIcon, {
+          "name": "clear"
+        }, null)]), [[vShow, props.dirty]])]
+      }), hasAppend && createVNode("div", {
+        "key": "append",
+        "class": "v-field__append-inner"
+      }, [(_c = slots["append-inner"]) == null ? void 0 : _c.call(slots, slotProps.value), props.appendInnerIcon && createVNode(InputIcon, {
+        "key": "append-icon",
+        "name": "appendInner"
+      }, null)]), createVNode("div", {
+        "class": ["v-field__outline", textColorClasses.value],
+        "style": textColorStyles.value
+      }, [isOutlined && createVNode(Fragment, null, [createVNode("div", {
+        "class": "v-field__outline__start"
+      }, null), hasLabel.value && createVNode("div", {
+        "class": "v-field__outline__notch"
+      }, [createVNode(VFieldLabel, {
+        "ref": floatingLabelRef,
+        "floating": true,
+        "for": id.value
+      }, {
+        default: () => [label()]
+      })]), createVNode("div", {
+        "class": "v-field__outline__end"
+      }, null)]), isPlainOrUnderlined.value && hasLabel.value && createVNode(VFieldLabel, {
+        "ref": floatingLabelRef,
+        "floating": true,
+        "for": id.value
+      }, {
+        default: () => [label()]
+      })])]);
+    });
+    return {
+      controlRef
+    };
+  }
+});
+function filterFieldProps(attrs) {
+  const keys = Object.keys(VField.props).filter((k) => !isOn(k) && k !== "class" && k !== "style");
+  return pick(attrs, keys);
+}
+
+// node_modules/vuetify/lib/components/VTextField/VTextField.mjs
+var activeTypes = ["color", "file", "time", "date", "datetime-local", "week", "month"];
+var makeVTextFieldProps = propsFactory({
+  autofocus: Boolean,
+  counter: [Boolean, Number, String],
+  counterValue: [Number, Function],
+  prefix: String,
+  placeholder: String,
+  persistentPlaceholder: Boolean,
+  persistentCounter: Boolean,
+  suffix: String,
+  role: String,
+  type: {
+    type: String,
+    default: "text"
+  },
+  modelModifiers: Object,
+  ...makeVInputProps(),
+  ...makeVFieldProps()
+}, "VTextField");
+var VTextField = genericComponent()({
+  name: "VTextField",
+  directives: {
+    Intersect: intersect_default
+  },
+  inheritAttrs: false,
+  props: makeVTextFieldProps(),
+  emits: {
+    "click:control": (e) => true,
+    "mousedown:control": (e) => true,
+    "update:focused": (focused) => true,
+    "update:modelValue": (val) => true
+  },
+  setup(props, _ref) {
+    let {
+      attrs,
+      emit,
+      slots
+    } = _ref;
+    const model = useProxiedModel(props, "modelValue");
+    const {
+      isFocused,
+      focus,
+      blur
+    } = useFocus(props);
+    const counterValue = computed(() => {
+      return typeof props.counterValue === "function" ? props.counterValue(model.value) : typeof props.counterValue === "number" ? props.counterValue : (model.value ?? "").toString().length;
+    });
+    const max = computed(() => {
+      if (attrs.maxlength) return attrs.maxlength;
+      if (!props.counter || typeof props.counter !== "number" && typeof props.counter !== "string") return void 0;
+      return props.counter;
+    });
+    const isPlainOrUnderlined = computed(() => ["plain", "underlined"].includes(props.variant));
+    function onIntersect(isIntersecting, entries) {
+      var _a, _b;
+      if (!props.autofocus || !isIntersecting) return;
+      (_b = (_a = entries[0].target) == null ? void 0 : _a.focus) == null ? void 0 : _b.call(_a);
+    }
+    const vInputRef = ref();
+    const vFieldRef = ref();
+    const inputRef = ref();
+    const isActive = computed(() => activeTypes.includes(props.type) || props.persistentPlaceholder || isFocused.value || props.active);
+    function onFocus() {
+      var _a;
+      if (inputRef.value !== document.activeElement) {
+        (_a = inputRef.value) == null ? void 0 : _a.focus();
+      }
+      if (!isFocused.value) focus();
+    }
+    function onControlMousedown(e) {
+      emit("mousedown:control", e);
+      if (e.target === inputRef.value) return;
+      onFocus();
+      e.preventDefault();
+    }
+    function onControlClick(e) {
+      onFocus();
+      emit("click:control", e);
+    }
+    function onClear(e) {
+      e.stopPropagation();
+      onFocus();
+      nextTick(() => {
+        model.value = null;
+        callEvent(props["onClick:clear"], e);
+      });
+    }
+    function onInput(e) {
+      var _a;
+      const el = e.target;
+      model.value = el.value;
+      if (((_a = props.modelModifiers) == null ? void 0 : _a.trim) && ["text", "search", "password", "tel", "url"].includes(props.type)) {
+        const caretPosition = [el.selectionStart, el.selectionEnd];
+        nextTick(() => {
+          el.selectionStart = caretPosition[0];
+          el.selectionEnd = caretPosition[1];
+        });
+      }
+    }
+    useRender(() => {
+      const hasCounter = !!(slots.counter || props.counter !== false && props.counter != null);
+      const hasDetails = !!(hasCounter || slots.details);
+      const [rootAttrs, inputAttrs] = filterInputAttrs(attrs);
+      const {
+        modelValue: _,
+        ...inputProps
+      } = VInput.filterProps(props);
+      const fieldProps = filterFieldProps(props);
+      return createVNode(VInput, mergeProps({
+        "ref": vInputRef,
+        "modelValue": model.value,
+        "onUpdate:modelValue": ($event) => model.value = $event,
+        "class": ["v-text-field", {
+          "v-text-field--prefixed": props.prefix,
+          "v-text-field--suffixed": props.suffix,
+          "v-input--plain-underlined": isPlainOrUnderlined.value
+        }, props.class],
+        "style": props.style
+      }, rootAttrs, inputProps, {
+        "centerAffix": !isPlainOrUnderlined.value,
+        "focused": isFocused.value
+      }), {
+        ...slots,
+        default: (_ref2) => {
+          let {
+            id,
+            isDisabled,
+            isDirty,
+            isReadonly,
+            isValid
+          } = _ref2;
+          return createVNode(VField, mergeProps({
+            "ref": vFieldRef,
+            "onMousedown": onControlMousedown,
+            "onClick": onControlClick,
+            "onClick:clear": onClear,
+            "onClick:prependInner": props["onClick:prependInner"],
+            "onClick:appendInner": props["onClick:appendInner"],
+            "role": props.role
+          }, fieldProps, {
+            "id": id.value,
+            "active": isActive.value || isDirty.value,
+            "dirty": isDirty.value || props.dirty,
+            "disabled": isDisabled.value,
+            "focused": isFocused.value,
+            "error": isValid.value === false
+          }), {
+            ...slots,
+            default: (_ref3) => {
+              let {
+                props: {
+                  class: fieldClass,
+                  ...slotProps
+                }
+              } = _ref3;
+              const inputNode = withDirectives(createVNode("input", mergeProps({
+                "ref": inputRef,
+                "value": model.value,
+                "onInput": onInput,
+                "autofocus": props.autofocus,
+                "readonly": isReadonly.value,
+                "disabled": isDisabled.value,
+                "name": props.name,
+                "placeholder": props.placeholder,
+                "size": 1,
+                "type": props.type,
+                "onFocus": onFocus,
+                "onBlur": blur
+              }, slotProps, inputAttrs), null), [[resolveDirective("intersect"), {
+                handler: onIntersect
+              }, null, {
+                once: true
+              }]]);
+              return createVNode(Fragment, null, [props.prefix && createVNode("span", {
+                "class": "v-text-field__prefix"
+              }, [createVNode("span", {
+                "class": "v-text-field__prefix__text"
+              }, [props.prefix])]), slots.default ? createVNode("div", {
+                "class": fieldClass,
+                "data-no-activator": ""
+              }, [slots.default(), inputNode]) : cloneVNode(inputNode, {
+                class: fieldClass
+              }), props.suffix && createVNode("span", {
+                "class": "v-text-field__suffix"
+              }, [createVNode("span", {
+                "class": "v-text-field__suffix__text"
+              }, [props.suffix])])]);
+            }
+          });
+        },
+        details: hasDetails ? (slotProps) => {
+          var _a;
+          return createVNode(Fragment, null, [(_a = slots.details) == null ? void 0 : _a.call(slots, slotProps), hasCounter && createVNode(Fragment, null, [createVNode("span", null, null), createVNode(VCounter, {
+            "active": props.persistentCounter || isFocused.value,
+            "value": counterValue.value,
+            "max": max.value
+          }, slots.counter)])]);
+        } : void 0
+      });
+    });
+    return forwardRefs({}, vInputRef, vFieldRef, inputRef);
+  }
+});
+
+export {
+  makeVTextFieldProps,
+  VTextField
+};
+//# sourceMappingURL=chunk-7EFRYS5N.js.map

VApp/node_modules/.vite/deps/chunk-AGK43WUJ.js

@@ -0,0 +1,750 @@
+import {
+  useLocale
+} from "./chunk-IR5437QA.js";
+import {
+  createRange,
+  mergeDeep,
+  padStart,
+  refElement
+} from "./chunk-I4KGD5X4.js";
+import {
+  inject,
+  reactive,
+  watch
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/composables/date/adapters/vuetify.mjs
+var firstDay = {
+  "001": 1,
+  AD: 1,
+  AE: 6,
+  AF: 6,
+  AG: 0,
+  AI: 1,
+  AL: 1,
+  AM: 1,
+  AN: 1,
+  AR: 1,
+  AS: 0,
+  AT: 1,
+  AU: 1,
+  AX: 1,
+  AZ: 1,
+  BA: 1,
+  BD: 0,
+  BE: 1,
+  BG: 1,
+  BH: 6,
+  BM: 1,
+  BN: 1,
+  BR: 0,
+  BS: 0,
+  BT: 0,
+  BW: 0,
+  BY: 1,
+  BZ: 0,
+  CA: 0,
+  CH: 1,
+  CL: 1,
+  CM: 1,
+  CN: 1,
+  CO: 0,
+  CR: 1,
+  CY: 1,
+  CZ: 1,
+  DE: 1,
+  DJ: 6,
+  DK: 1,
+  DM: 0,
+  DO: 0,
+  DZ: 6,
+  EC: 1,
+  EE: 1,
+  EG: 6,
+  ES: 1,
+  ET: 0,
+  FI: 1,
+  FJ: 1,
+  FO: 1,
+  FR: 1,
+  GB: 1,
+  "GB-alt-variant": 0,
+  GE: 1,
+  GF: 1,
+  GP: 1,
+  GR: 1,
+  GT: 0,
+  GU: 0,
+  HK: 0,
+  HN: 0,
+  HR: 1,
+  HU: 1,
+  ID: 0,
+  IE: 1,
+  IL: 0,
+  IN: 0,
+  IQ: 6,
+  IR: 6,
+  IS: 1,
+  IT: 1,
+  JM: 0,
+  JO: 6,
+  JP: 0,
+  KE: 0,
+  KG: 1,
+  KH: 0,
+  KR: 0,
+  KW: 6,
+  KZ: 1,
+  LA: 0,
+  LB: 1,
+  LI: 1,
+  LK: 1,
+  LT: 1,
+  LU: 1,
+  LV: 1,
+  LY: 6,
+  MC: 1,
+  MD: 1,
+  ME: 1,
+  MH: 0,
+  MK: 1,
+  MM: 0,
+  MN: 1,
+  MO: 0,
+  MQ: 1,
+  MT: 0,
+  MV: 5,
+  MX: 0,
+  MY: 1,
+  MZ: 0,
+  NI: 0,
+  NL: 1,
+  NO: 1,
+  NP: 0,
+  NZ: 1,
+  OM: 6,
+  PA: 0,
+  PE: 0,
+  PH: 0,
+  PK: 0,
+  PL: 1,
+  PR: 0,
+  PT: 0,
+  PY: 0,
+  QA: 6,
+  RE: 1,
+  RO: 1,
+  RS: 1,
+  RU: 1,
+  SA: 0,
+  SD: 6,
+  SE: 1,
+  SG: 0,
+  SI: 1,
+  SK: 1,
+  SM: 1,
+  SV: 0,
+  SY: 6,
+  TH: 0,
+  TJ: 1,
+  TM: 1,
+  TR: 1,
+  TT: 0,
+  TW: 0,
+  UA: 1,
+  UM: 0,
+  US: 0,
+  UY: 1,
+  UZ: 1,
+  VA: 1,
+  VE: 0,
+  VI: 0,
+  VN: 1,
+  WS: 0,
+  XK: 1,
+  YE: 0,
+  ZA: 0,
+  ZW: 0
+};
+function getWeekArray(date2, locale) {
+  const weeks = [];
+  let currentWeek = [];
+  const firstDayOfMonth = startOfMonth(date2);
+  const lastDayOfMonth = endOfMonth(date2);
+  const firstDayWeekIndex = (firstDayOfMonth.getDay() - firstDay[locale.slice(-2).toUpperCase()] + 7) % 7;
+  const lastDayWeekIndex = (lastDayOfMonth.getDay() - firstDay[locale.slice(-2).toUpperCase()] + 7) % 7;
+  for (let i = 0; i < firstDayWeekIndex; i++) {
+    const adjacentDay = new Date(firstDayOfMonth);
+    adjacentDay.setDate(adjacentDay.getDate() - (firstDayWeekIndex - i));
+    currentWeek.push(adjacentDay);
+  }
+  for (let i = 1; i <= lastDayOfMonth.getDate(); i++) {
+    const day = new Date(date2.getFullYear(), date2.getMonth(), i);
+    currentWeek.push(day);
+    if (currentWeek.length === 7) {
+      weeks.push(currentWeek);
+      currentWeek = [];
+    }
+  }
+  for (let i = 1; i < 7 - lastDayWeekIndex; i++) {
+    const adjacentDay = new Date(lastDayOfMonth);
+    adjacentDay.setDate(adjacentDay.getDate() + i);
+    currentWeek.push(adjacentDay);
+  }
+  if (currentWeek.length > 0) {
+    weeks.push(currentWeek);
+  }
+  return weeks;
+}
+function startOfWeek(date2) {
+  const d = new Date(date2);
+  while (d.getDay() !== 0) {
+    d.setDate(d.getDate() - 1);
+  }
+  return d;
+}
+function endOfWeek(date2) {
+  const d = new Date(date2);
+  while (d.getDay() !== 6) {
+    d.setDate(d.getDate() + 1);
+  }
+  return d;
+}
+function startOfMonth(date2) {
+  return new Date(date2.getFullYear(), date2.getMonth(), 1);
+}
+function endOfMonth(date2) {
+  return new Date(date2.getFullYear(), date2.getMonth() + 1, 0);
+}
+function parseLocalDate(value) {
+  const parts = value.split("-").map(Number);
+  return new Date(parts[0], parts[1] - 1, parts[2]);
+}
+var _YYYMMDD = /^([12]\d{3}-([1-9]|0[1-9]|1[0-2])-([1-9]|0[1-9]|[12]\d|3[01]))$/;
+function date(value) {
+  if (value == null) return /* @__PURE__ */ new Date();
+  if (value instanceof Date) return value;
+  if (typeof value === "string") {
+    let parsed;
+    if (_YYYMMDD.test(value)) {
+      return parseLocalDate(value);
+    } else {
+      parsed = Date.parse(value);
+    }
+    if (!isNaN(parsed)) return new Date(parsed);
+  }
+  return null;
+}
+var sundayJanuarySecond2000 = new Date(2e3, 0, 2);
+function getWeekdays(locale) {
+  const daysFromSunday = firstDay[locale.slice(-2).toUpperCase()];
+  return createRange(7).map((i) => {
+    const weekday = new Date(sundayJanuarySecond2000);
+    weekday.setDate(sundayJanuarySecond2000.getDate() + daysFromSunday + i);
+    return new Intl.DateTimeFormat(locale, {
+      weekday: "narrow"
+    }).format(weekday);
+  });
+}
+function format(value, formatString, locale, formats) {
+  const newDate = date(value) ?? /* @__PURE__ */ new Date();
+  const customFormat = formats == null ? void 0 : formats[formatString];
+  if (typeof customFormat === "function") {
+    return customFormat(newDate, formatString, locale);
+  }
+  let options = {};
+  switch (formatString) {
+    case "fullDateWithWeekday":
+      options = {
+        weekday: "long",
+        day: "numeric",
+        month: "long",
+        year: "numeric"
+      };
+      break;
+    case "hours12h":
+      options = {
+        hour: "numeric",
+        hour12: true
+      };
+      break;
+    case "normalDateWithWeekday":
+      options = {
+        weekday: "short",
+        day: "numeric",
+        month: "short"
+      };
+      break;
+    case "keyboardDate":
+      options = {
+        day: "2-digit",
+        month: "2-digit",
+        year: "numeric"
+      };
+      break;
+    case "monthAndDate":
+      options = {
+        month: "long",
+        day: "numeric"
+      };
+      break;
+    case "monthAndYear":
+      options = {
+        month: "long",
+        year: "numeric"
+      };
+      break;
+    case "month":
+      options = {
+        month: "long"
+      };
+      break;
+    case "monthShort":
+      options = {
+        month: "short"
+      };
+      break;
+    case "dayOfMonth":
+      return new Intl.NumberFormat(locale).format(newDate.getDate());
+    case "shortDate":
+      options = {
+        year: "2-digit",
+        month: "numeric",
+        day: "numeric"
+      };
+      break;
+    case "weekdayShort":
+      options = {
+        weekday: "short"
+      };
+      break;
+    case "year":
+      options = {
+        year: "numeric"
+      };
+      break;
+    default:
+      options = customFormat ?? {
+        timeZone: "UTC",
+        timeZoneName: "short"
+      };
+  }
+  return new Intl.DateTimeFormat(locale, options).format(newDate);
+}
+function toISO(adapter, value) {
+  const date2 = adapter.toJsDate(value);
+  const year = date2.getFullYear();
+  const month = padStart(String(date2.getMonth() + 1), 2, "0");
+  const day = padStart(String(date2.getDate()), 2, "0");
+  return `${year}-${month}-${day}`;
+}
+function parseISO(value) {
+  const [year, month, day] = value.split("-").map(Number);
+  return new Date(year, month - 1, day);
+}
+function addMinutes(date2, amount) {
+  const d = new Date(date2);
+  d.setMinutes(d.getMinutes() + amount);
+  return d;
+}
+function addHours(date2, amount) {
+  const d = new Date(date2);
+  d.setHours(d.getHours() + amount);
+  return d;
+}
+function addDays(date2, amount) {
+  const d = new Date(date2);
+  d.setDate(d.getDate() + amount);
+  return d;
+}
+function addWeeks(date2, amount) {
+  const d = new Date(date2);
+  d.setDate(d.getDate() + amount * 7);
+  return d;
+}
+function addMonths(date2, amount) {
+  const d = new Date(date2);
+  d.setMonth(d.getMonth() + amount);
+  return d;
+}
+function getYear(date2) {
+  return date2.getFullYear();
+}
+function getMonth(date2) {
+  return date2.getMonth();
+}
+function getNextMonth(date2) {
+  return new Date(date2.getFullYear(), date2.getMonth() + 1, 1);
+}
+function getHours(date2) {
+  return date2.getHours();
+}
+function getMinutes(date2) {
+  return date2.getMinutes();
+}
+function startOfYear(date2) {
+  return new Date(date2.getFullYear(), 0, 1);
+}
+function endOfYear(date2) {
+  return new Date(date2.getFullYear(), 11, 31);
+}
+function isWithinRange(date2, range) {
+  return isAfter(date2, range[0]) && isBefore(date2, range[1]);
+}
+function isValid(date2) {
+  const d = new Date(date2);
+  return d instanceof Date && !isNaN(d.getTime());
+}
+function isAfter(date2, comparing) {
+  return date2.getTime() > comparing.getTime();
+}
+function isBefore(date2, comparing) {
+  return date2.getTime() < comparing.getTime();
+}
+function isEqual(date2, comparing) {
+  return date2.getTime() === comparing.getTime();
+}
+function isSameDay(date2, comparing) {
+  return date2.getDate() === comparing.getDate() && date2.getMonth() === comparing.getMonth() && date2.getFullYear() === comparing.getFullYear();
+}
+function isSameMonth(date2, comparing) {
+  return date2.getMonth() === comparing.getMonth() && date2.getFullYear() === comparing.getFullYear();
+}
+function getDiff(date2, comparing, unit) {
+  const d = new Date(date2);
+  const c = new Date(comparing);
+  if (unit === "month") {
+    return d.getMonth() - c.getMonth() + (d.getFullYear() - c.getFullYear()) * 12;
+  }
+  return Math.floor((d.getTime() - c.getTime()) / (1e3 * 60 * 60 * 24));
+}
+function setHours(date2, count) {
+  const d = new Date(date2);
+  d.setHours(count);
+  return d;
+}
+function setMinutes(date2, count) {
+  const d = new Date(date2);
+  d.setMinutes(count);
+  return d;
+}
+function setMonth(date2, count) {
+  const d = new Date(date2);
+  d.setMonth(count);
+  return d;
+}
+function setYear(date2, year) {
+  const d = new Date(date2);
+  d.setFullYear(year);
+  return d;
+}
+function startOfDay(date2) {
+  return new Date(date2.getFullYear(), date2.getMonth(), date2.getDate());
+}
+function endOfDay(date2) {
+  return new Date(date2.getFullYear(), date2.getMonth(), date2.getDate(), 23, 59, 59, 999);
+}
+var VuetifyDateAdapter = class {
+  constructor(options) {
+    this.locale = options.locale;
+    this.formats = options.formats;
+  }
+  date(value) {
+    return date(value);
+  }
+  toJsDate(date2) {
+    return date2;
+  }
+  toISO(date2) {
+    return toISO(this, date2);
+  }
+  parseISO(date2) {
+    return parseISO(date2);
+  }
+  addMinutes(date2, amount) {
+    return addMinutes(date2, amount);
+  }
+  addHours(date2, amount) {
+    return addHours(date2, amount);
+  }
+  addDays(date2, amount) {
+    return addDays(date2, amount);
+  }
+  addWeeks(date2, amount) {
+    return addWeeks(date2, amount);
+  }
+  addMonths(date2, amount) {
+    return addMonths(date2, amount);
+  }
+  getWeekArray(date2) {
+    return getWeekArray(date2, this.locale);
+  }
+  startOfWeek(date2) {
+    return startOfWeek(date2);
+  }
+  endOfWeek(date2) {
+    return endOfWeek(date2);
+  }
+  startOfMonth(date2) {
+    return startOfMonth(date2);
+  }
+  endOfMonth(date2) {
+    return endOfMonth(date2);
+  }
+  format(date2, formatString) {
+    return format(date2, formatString, this.locale, this.formats);
+  }
+  isEqual(date2, comparing) {
+    return isEqual(date2, comparing);
+  }
+  isValid(date2) {
+    return isValid(date2);
+  }
+  isWithinRange(date2, range) {
+    return isWithinRange(date2, range);
+  }
+  isAfter(date2, comparing) {
+    return isAfter(date2, comparing);
+  }
+  isBefore(date2, comparing) {
+    return !isAfter(date2, comparing) && !isEqual(date2, comparing);
+  }
+  isSameDay(date2, comparing) {
+    return isSameDay(date2, comparing);
+  }
+  isSameMonth(date2, comparing) {
+    return isSameMonth(date2, comparing);
+  }
+  setMinutes(date2, count) {
+    return setMinutes(date2, count);
+  }
+  setHours(date2, count) {
+    return setHours(date2, count);
+  }
+  setMonth(date2, count) {
+    return setMonth(date2, count);
+  }
+  setYear(date2, year) {
+    return setYear(date2, year);
+  }
+  getDiff(date2, comparing, unit) {
+    return getDiff(date2, comparing, unit);
+  }
+  getWeekdays() {
+    return getWeekdays(this.locale);
+  }
+  getYear(date2) {
+    return getYear(date2);
+  }
+  getMonth(date2) {
+    return getMonth(date2);
+  }
+  getNextMonth(date2) {
+    return getNextMonth(date2);
+  }
+  getHours(date2) {
+    return getHours(date2);
+  }
+  getMinutes(date2) {
+    return getMinutes(date2);
+  }
+  startOfDay(date2) {
+    return startOfDay(date2);
+  }
+  endOfDay(date2) {
+    return endOfDay(date2);
+  }
+  startOfYear(date2) {
+    return startOfYear(date2);
+  }
+  endOfYear(date2) {
+    return endOfYear(date2);
+  }
+};
+
+// node_modules/vuetify/lib/composables/date/date.mjs
+var DateOptionsSymbol = Symbol.for("vuetify:date-options");
+var DateAdapterSymbol = Symbol.for("vuetify:date-adapter");
+function createDate(options, locale) {
+  const _options = mergeDeep({
+    adapter: VuetifyDateAdapter,
+    locale: {
+      af: "af-ZA",
+      // ar: '', # not the same value for all variants
+      bg: "bg-BG",
+      ca: "ca-ES",
+      ckb: "",
+      cs: "cs-CZ",
+      de: "de-DE",
+      el: "el-GR",
+      en: "en-US",
+      // es: '', # not the same value for all variants
+      et: "et-EE",
+      fa: "fa-IR",
+      fi: "fi-FI",
+      // fr: '', #not the same value for all variants
+      hr: "hr-HR",
+      hu: "hu-HU",
+      he: "he-IL",
+      id: "id-ID",
+      it: "it-IT",
+      ja: "ja-JP",
+      ko: "ko-KR",
+      lv: "lv-LV",
+      lt: "lt-LT",
+      nl: "nl-NL",
+      no: "no-NO",
+      pl: "pl-PL",
+      pt: "pt-PT",
+      ro: "ro-RO",
+      ru: "ru-RU",
+      sk: "sk-SK",
+      sl: "sl-SI",
+      srCyrl: "sr-SP",
+      srLatn: "sr-SP",
+      sv: "sv-SE",
+      th: "th-TH",
+      tr: "tr-TR",
+      az: "az-AZ",
+      uk: "uk-UA",
+      vi: "vi-VN",
+      zhHans: "zh-CN",
+      zhHant: "zh-TW"
+    }
+  }, options);
+  return {
+    options: _options,
+    instance: createInstance(_options, locale)
+  };
+}
+function createInstance(options, locale) {
+  const instance = reactive(typeof options.adapter === "function" ? new options.adapter({
+    locale: options.locale[locale.current.value] ?? locale.current.value,
+    formats: options.formats
+  }) : options.adapter);
+  watch(locale.current, (value) => {
+    instance.locale = options.locale[value] ?? value ?? instance.locale;
+  });
+  return instance;
+}
+function useDate() {
+  const options = inject(DateOptionsSymbol);
+  if (!options) throw new Error("[Vuetify] Could not find injected date options");
+  const locale = useLocale();
+  return createInstance(options, locale);
+}
+
+// node_modules/vuetify/lib/composables/goto.mjs
+var GoToSymbol = Symbol.for("vuetify:goto");
+function genDefaults() {
+  return {
+    container: void 0,
+    duration: 300,
+    layout: false,
+    offset: 0,
+    easing: "easeInOutCubic",
+    patterns: {
+      linear: (t) => t,
+      easeInQuad: (t) => t ** 2,
+      easeOutQuad: (t) => t * (2 - t),
+      easeInOutQuad: (t) => t < 0.5 ? 2 * t ** 2 : -1 + (4 - 2 * t) * t,
+      easeInCubic: (t) => t ** 3,
+      easeOutCubic: (t) => --t ** 3 + 1,
+      easeInOutCubic: (t) => t < 0.5 ? 4 * t ** 3 : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1,
+      easeInQuart: (t) => t ** 4,
+      easeOutQuart: (t) => 1 - --t ** 4,
+      easeInOutQuart: (t) => t < 0.5 ? 8 * t ** 4 : 1 - 8 * --t ** 4,
+      easeInQuint: (t) => t ** 5,
+      easeOutQuint: (t) => 1 + --t ** 5,
+      easeInOutQuint: (t) => t < 0.5 ? 16 * t ** 5 : 1 + 16 * --t ** 5
+    }
+  };
+}
+function getContainer(el) {
+  return getTarget(el) ?? (document.scrollingElement || document.body);
+}
+function getTarget(el) {
+  return typeof el === "string" ? document.querySelector(el) : refElement(el);
+}
+function getOffset(target, horizontal, rtl) {
+  if (typeof target === "number") return horizontal && rtl ? -target : target;
+  let el = getTarget(target);
+  let totalOffset = 0;
+  while (el) {
+    totalOffset += horizontal ? el.offsetLeft : el.offsetTop;
+    el = el.offsetParent;
+  }
+  return totalOffset;
+}
+function createGoTo(options, locale) {
+  return {
+    rtl: locale.isRtl,
+    options: mergeDeep(genDefaults(), options)
+  };
+}
+async function scrollTo(_target, _options, horizontal, goTo) {
+  const options = mergeDeep(goTo == null ? void 0 : goTo.options, _options);
+  const rtl = goTo == null ? void 0 : goTo.rtl.value;
+  const target = (typeof _target === "number" ? _target : getTarget(_target)) ?? 0;
+  const container = options.container === "parent" && target instanceof HTMLElement ? target.parentElement : getContainer(options.container);
+  const ease = typeof options.easing === "function" ? options.easing : options.patterns[options.easing];
+  if (!ease) throw new TypeError(`Easing function "${options.easing}" not found.`);
+  let targetLocation;
+  if (typeof target === "number") {
+    targetLocation = getOffset(target, horizontal, rtl);
+  } else {
+    targetLocation = getOffset(target, horizontal, rtl) - getOffset(container, horizontal, rtl);
+    if (options.layout) {
+      const styles = window.getComputedStyle(target);
+      const layoutOffset = styles.getPropertyValue("--v-layout-top");
+      if (layoutOffset) targetLocation -= parseInt(layoutOffset, 10);
+    }
+  }
+  targetLocation += options.offset;
+  const startLocation = (horizontal ? container.scrollLeft : container.scrollTop) ?? 0;
+  if (targetLocation === startLocation) return Promise.resolve(targetLocation);
+  const startTime = performance.now();
+  return new Promise((resolve) => requestAnimationFrame(function step(currentTime) {
+    const timeElapsed = currentTime - startTime;
+    const progress = Math.abs(options.duration ? Math.min(timeElapsed / options.duration, 1) : 1);
+    const location = Math.floor(startLocation + (targetLocation - startLocation) * ease(progress));
+    container[horizontal ? "scrollLeft" : "scrollTop"] = location;
+    if (progress === 1) return resolve(targetLocation);
+    let clientSize;
+    let reachEnd;
+    if (!horizontal) {
+      clientSize = container === document.body ? document.documentElement.clientHeight : container.clientHeight;
+      reachEnd = clientSize + container.scrollTop >= container.scrollHeight;
+      if (targetLocation > container.scrollTop && reachEnd) return resolve(targetLocation);
+    } else {
+      clientSize = container === document.body ? document.documentElement.clientWidth : container.clientWidth;
+      reachEnd = clientSize + container.scrollLeft >= container.scrollWidth;
+      if (targetLocation > container.scrollLeft && reachEnd) return resolve(targetLocation);
+    }
+    requestAnimationFrame(step);
+  }));
+}
+function useGoTo() {
+  let _options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+  const goTo = inject(GoToSymbol);
+  if (!goTo) throw new Error("[Vuetify] Could not find injected goto instance");
+  async function go(target, options) {
+    return scrollTo(target, mergeDeep(_options, options), false, goTo);
+  }
+  go.horizontal = async (target, options) => {
+    return scrollTo(target, mergeDeep(_options, options), true, goTo);
+  };
+  return go;
+}
+
+export {
+  DateOptionsSymbol,
+  DateAdapterSymbol,
+  createDate,
+  useDate,
+  GoToSymbol,
+  createGoTo,
+  useGoTo
+};
+//# sourceMappingURL=chunk-AGK43WUJ.js.map

VApp/node_modules/.vite/deps/chunk-CYOEVGGH.js

@@ -0,0 +1,312 @@
+import {
+  IN_BROWSER,
+  RGBtoHex,
+  createRange,
+  darken,
+  getCurrentInstance,
+  getForeground,
+  getLuma,
+  lighten,
+  mergeDeep,
+  parseColor,
+  propsFactory
+} from "./chunk-I4KGD5X4.js";
+import {
+  computed,
+  inject,
+  provide,
+  ref,
+  watch,
+  watchEffect
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/composables/theme.mjs
+var ThemeSymbol = Symbol.for("vuetify:theme");
+var makeThemeProps = propsFactory({
+  theme: String
+}, "theme");
+function genDefaults() {
+  return {
+    defaultTheme: "light",
+    variations: {
+      colors: [],
+      lighten: 0,
+      darken: 0
+    },
+    themes: {
+      light: {
+        dark: false,
+        colors: {
+          background: "#FFFFFF",
+          surface: "#FFFFFF",
+          "surface-bright": "#FFFFFF",
+          "surface-light": "#EEEEEE",
+          "surface-variant": "#424242",
+          "on-surface-variant": "#EEEEEE",
+          primary: "#1867C0",
+          "primary-darken-1": "#1F5592",
+          secondary: "#48A9A6",
+          "secondary-darken-1": "#018786",
+          error: "#B00020",
+          info: "#2196F3",
+          success: "#4CAF50",
+          warning: "#FB8C00"
+        },
+        variables: {
+          "border-color": "#000000",
+          "border-opacity": 0.12,
+          "high-emphasis-opacity": 0.87,
+          "medium-emphasis-opacity": 0.6,
+          "disabled-opacity": 0.38,
+          "idle-opacity": 0.04,
+          "hover-opacity": 0.04,
+          "focus-opacity": 0.12,
+          "selected-opacity": 0.08,
+          "activated-opacity": 0.12,
+          "pressed-opacity": 0.12,
+          "dragged-opacity": 0.08,
+          "theme-kbd": "#212529",
+          "theme-on-kbd": "#FFFFFF",
+          "theme-code": "#F5F5F5",
+          "theme-on-code": "#000000"
+        }
+      },
+      dark: {
+        dark: true,
+        colors: {
+          background: "#121212",
+          surface: "#212121",
+          "surface-bright": "#ccbfd6",
+          "surface-light": "#424242",
+          "surface-variant": "#a3a3a3",
+          "on-surface-variant": "#424242",
+          primary: "#2196F3",
+          "primary-darken-1": "#277CC1",
+          secondary: "#54B6B2",
+          "secondary-darken-1": "#48A9A6",
+          error: "#CF6679",
+          info: "#2196F3",
+          success: "#4CAF50",
+          warning: "#FB8C00"
+        },
+        variables: {
+          "border-color": "#FFFFFF",
+          "border-opacity": 0.12,
+          "high-emphasis-opacity": 1,
+          "medium-emphasis-opacity": 0.7,
+          "disabled-opacity": 0.5,
+          "idle-opacity": 0.1,
+          "hover-opacity": 0.04,
+          "focus-opacity": 0.12,
+          "selected-opacity": 0.08,
+          "activated-opacity": 0.12,
+          "pressed-opacity": 0.16,
+          "dragged-opacity": 0.08,
+          "theme-kbd": "#212529",
+          "theme-on-kbd": "#FFFFFF",
+          "theme-code": "#343434",
+          "theme-on-code": "#CCCCCC"
+        }
+      }
+    }
+  };
+}
+function parseThemeOptions() {
+  var _a, _b;
+  let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : genDefaults();
+  const defaults = genDefaults();
+  if (!options) return {
+    ...defaults,
+    isDisabled: true
+  };
+  const themes = {};
+  for (const [key, theme] of Object.entries(options.themes ?? {})) {
+    const defaultTheme = theme.dark || key === "dark" ? (_a = defaults.themes) == null ? void 0 : _a.dark : (_b = defaults.themes) == null ? void 0 : _b.light;
+    themes[key] = mergeDeep(defaultTheme, theme);
+  }
+  return mergeDeep(defaults, {
+    ...options,
+    themes
+  });
+}
+function createTheme(options) {
+  const parsedOptions = parseThemeOptions(options);
+  const name = ref(parsedOptions.defaultTheme);
+  const themes = ref(parsedOptions.themes);
+  const computedThemes = computed(() => {
+    const acc = {};
+    for (const [name2, original] of Object.entries(themes.value)) {
+      const theme = acc[name2] = {
+        ...original,
+        colors: {
+          ...original.colors
+        }
+      };
+      if (parsedOptions.variations) {
+        for (const name3 of parsedOptions.variations.colors) {
+          const color = theme.colors[name3];
+          if (!color) continue;
+          for (const variation of ["lighten", "darken"]) {
+            const fn = variation === "lighten" ? lighten : darken;
+            for (const amount of createRange(parsedOptions.variations[variation], 1)) {
+              theme.colors[`${name3}-${variation}-${amount}`] = RGBtoHex(fn(parseColor(color), amount));
+            }
+          }
+        }
+      }
+      for (const color of Object.keys(theme.colors)) {
+        if (/^on-[a-z]/.test(color) || theme.colors[`on-${color}`]) continue;
+        const onColor = `on-${color}`;
+        const colorVal = parseColor(theme.colors[color]);
+        theme.colors[onColor] = getForeground(colorVal);
+      }
+    }
+    return acc;
+  });
+  const current = computed(() => computedThemes.value[name.value]);
+  const styles = computed(() => {
+    const lines = [];
+    if (current.value.dark) {
+      createCssClass(lines, ":root", ["color-scheme: dark"]);
+    }
+    createCssClass(lines, ":root", genCssVariables(current.value));
+    for (const [themeName, theme] of Object.entries(computedThemes.value)) {
+      createCssClass(lines, `.v-theme--${themeName}`, [`color-scheme: ${theme.dark ? "dark" : "normal"}`, ...genCssVariables(theme)]);
+    }
+    const bgLines = [];
+    const fgLines = [];
+    const colors = new Set(Object.values(computedThemes.value).flatMap((theme) => Object.keys(theme.colors)));
+    for (const key of colors) {
+      if (/^on-[a-z]/.test(key)) {
+        createCssClass(fgLines, `.${key}`, [`color: rgb(var(--v-theme-${key})) !important`]);
+      } else {
+        createCssClass(bgLines, `.bg-${key}`, [`--v-theme-overlay-multiplier: var(--v-theme-${key}-overlay-multiplier)`, `background-color: rgb(var(--v-theme-${key})) !important`, `color: rgb(var(--v-theme-on-${key})) !important`]);
+        createCssClass(fgLines, `.text-${key}`, [`color: rgb(var(--v-theme-${key})) !important`]);
+        createCssClass(fgLines, `.border-${key}`, [`--v-border-color: var(--v-theme-${key})`]);
+      }
+    }
+    lines.push(...bgLines, ...fgLines);
+    return lines.map((str, i) => i === 0 ? str : `    ${str}`).join("");
+  });
+  function getHead() {
+    return {
+      style: [{
+        children: styles.value,
+        id: "vuetify-theme-stylesheet",
+        nonce: parsedOptions.cspNonce || false
+      }]
+    };
+  }
+  function install(app) {
+    if (parsedOptions.isDisabled) return;
+    const head = app._context.provides.usehead;
+    if (head) {
+      if (head.push) {
+        const entry = head.push(getHead);
+        if (IN_BROWSER) {
+          watch(styles, () => {
+            entry.patch(getHead);
+          });
+        }
+      } else {
+        if (IN_BROWSER) {
+          head.addHeadObjs(computed(getHead));
+          watchEffect(() => head.updateDOM());
+        } else {
+          head.addHeadObjs(getHead());
+        }
+      }
+    } else {
+      let updateStyles = function() {
+        if (typeof document !== "undefined" && !styleEl) {
+          const el = document.createElement("style");
+          el.type = "text/css";
+          el.id = "vuetify-theme-stylesheet";
+          if (parsedOptions.cspNonce) el.setAttribute("nonce", parsedOptions.cspNonce);
+          styleEl = el;
+          document.head.appendChild(styleEl);
+        }
+        if (styleEl) styleEl.innerHTML = styles.value;
+      };
+      let styleEl = IN_BROWSER ? document.getElementById("vuetify-theme-stylesheet") : null;
+      if (IN_BROWSER) {
+        watch(styles, updateStyles, {
+          immediate: true
+        });
+      } else {
+        updateStyles();
+      }
+    }
+  }
+  const themeClasses = computed(() => parsedOptions.isDisabled ? void 0 : `v-theme--${name.value}`);
+  return {
+    install,
+    isDisabled: parsedOptions.isDisabled,
+    name,
+    themes,
+    current,
+    computedThemes,
+    themeClasses,
+    styles,
+    global: {
+      name,
+      current
+    }
+  };
+}
+function provideTheme(props) {
+  getCurrentInstance("provideTheme");
+  const theme = inject(ThemeSymbol, null);
+  if (!theme) throw new Error("Could not find Vuetify theme injection");
+  const name = computed(() => {
+    return props.theme ?? theme.name.value;
+  });
+  const current = computed(() => theme.themes.value[name.value]);
+  const themeClasses = computed(() => theme.isDisabled ? void 0 : `v-theme--${name.value}`);
+  const newTheme = {
+    ...theme,
+    name,
+    current,
+    themeClasses
+  };
+  provide(ThemeSymbol, newTheme);
+  return newTheme;
+}
+function useTheme() {
+  getCurrentInstance("useTheme");
+  const theme = inject(ThemeSymbol, null);
+  if (!theme) throw new Error("Could not find Vuetify theme injection");
+  return theme;
+}
+function createCssClass(lines, selector, content) {
+  lines.push(`${selector} {
+`, ...content.map((line) => `  ${line};
+`), "}\n");
+}
+function genCssVariables(theme) {
+  const lightOverlay = theme.dark ? 2 : 1;
+  const darkOverlay = theme.dark ? 1 : 2;
+  const variables = [];
+  for (const [key, value] of Object.entries(theme.colors)) {
+    const rgb = parseColor(value);
+    variables.push(`--v-theme-${key}: ${rgb.r},${rgb.g},${rgb.b}`);
+    if (!key.startsWith("on-")) {
+      variables.push(`--v-theme-${key}-overlay-multiplier: ${getLuma(value) > 0.18 ? lightOverlay : darkOverlay}`);
+    }
+  }
+  for (const [key, value] of Object.entries(theme.variables)) {
+    const color = typeof value === "string" && value.startsWith("#") ? parseColor(value) : void 0;
+    const rgb = color ? `${color.r}, ${color.g}, ${color.b}` : void 0;
+    variables.push(`--v-${key}: ${rgb ?? value}`);
+  }
+  return variables;
+}
+
+export {
+  ThemeSymbol,
+  makeThemeProps,
+  createTheme,
+  provideTheme,
+  useTheme
+};
+//# sourceMappingURL=chunk-CYOEVGGH.js.map

VApp/node_modules/.vite/deps/chunk-D42AK3WB.js

@@ -0,0 +1,48 @@
+import {
+  genericComponent,
+  propsFactory,
+  provideDefaults
+} from "./chunk-I4KGD5X4.js";
+import {
+  toRefs
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/components/VDefaultsProvider/VDefaultsProvider.mjs
+var makeVDefaultsProviderProps = propsFactory({
+  defaults: Object,
+  disabled: Boolean,
+  reset: [Number, String],
+  root: [Boolean, String],
+  scoped: Boolean
+}, "VDefaultsProvider");
+var VDefaultsProvider = genericComponent(false)({
+  name: "VDefaultsProvider",
+  props: makeVDefaultsProviderProps(),
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    const {
+      defaults,
+      disabled,
+      reset,
+      root,
+      scoped
+    } = toRefs(props);
+    provideDefaults(defaults, {
+      reset,
+      root,
+      scoped,
+      disabled
+    });
+    return () => {
+      var _a;
+      return (_a = slots.default) == null ? void 0 : _a.call(slots);
+    };
+  }
+});
+
+export {
+  VDefaultsProvider
+};
+//# sourceMappingURL=chunk-D42AK3WB.js.map

VApp/node_modules/.vite/deps/chunk-D42AK3WB.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../vuetify/src/components/VDefaultsProvider/VDefaultsProvider.tsx"],
+  "sourcesContent": ["// Composables\nimport { provideDefaults } from '@/composables/defaults'\n\n// Utilities\nimport { toRefs } from 'vue'\nimport { genericComponent, propsFactory } from '@/util'\n\n// Types\nimport type { PropType } from 'vue'\nimport type { DefaultsOptions } from '@/composables/defaults'\n\nexport const makeVDefaultsProviderProps = propsFactory({\n  defaults: Object as PropType<DefaultsOptions>,\n  disabled: Boolean,\n  reset: [Number, String],\n  root: [Boolean, String],\n  scoped: Boolean,\n}, 'VDefaultsProvider')\n\nexport const VDefaultsProvider = genericComponent(false)({\n  name: 'VDefaultsProvider',\n\n  props: makeVDefaultsProviderProps(),\n\n  setup (props, { slots }) {\n    const { defaults, disabled, reset, root, scoped } = toRefs(props)\n\n    provideDefaults(defaults, {\n      reset,\n      root,\n      scoped,\n      disabled,\n    })\n\n    return () => slots.default?.()\n  },\n})\n\nexport type VDefaultsProvider = InstanceType<typeof VDefaultsProvider>\n"],
+  "mappings": ";;;;;;;;;;AAWO,IAAMA,6BAA6BC,aAAa;EACrDC,UAAUC;EACVC,UAAUC;EACVC,OAAO,CAACC,QAAQC,MAAM;EACtBC,MAAM,CAACJ,SAASG,MAAM;EACtBE,QAAQL;AACV,GAAG,mBAAmB;AAEf,IAAMM,oBAAoBC,iBAAiB,KAAK,EAAE;EACvDC,MAAM;EAENC,OAAOd,2BAA2B;EAElCe,MAAOD,OAAKE,MAAa;AAAA,QAAX;MAAEC;IAAM,IAACD;AACrB,UAAM;MAAEd;MAAUE;MAAUE;MAAOG;MAAMC;IAAO,IAAIQ,OAAOJ,KAAK;AAEhEK,oBAAgBjB,UAAU;MACxBI;MACAG;MACAC;MACAN;IACF,CAAC;AAED,WAAO,MAAA;AAlCX;AAkCiBa,yBAAMG,YAANH;;EACf;AACF,CAAC;",
+  "names": ["makeVDefaultsProviderProps", "propsFactory", "defaults", "Object", "disabled", "Boolean", "reset", "Number", "String", "root", "scoped", "VDefaultsProvider", "genericComponent", "name", "props", "setup", "_ref", "slots", "toRefs", "provideDefaults", "default"]
+}

VApp/node_modules/.vite/deps/chunk-DJRL4NAD.js

@@ -0,0 +1,16 @@
+import {
+  propsFactory
+} from "./chunk-I4KGD5X4.js";
+
+// node_modules/vuetify/lib/composables/tag.mjs
+var makeTagProps = propsFactory({
+  tag: {
+    type: String,
+    default: "div"
+  }
+}, "tag");
+
+export {
+  makeTagProps
+};
+//# sourceMappingURL=chunk-DJRL4NAD.js.map

VApp/node_modules/.vite/deps/chunk-DJRL4NAD.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../vuetify/src/composables/tag.ts"],
+  "sourcesContent": ["// Utilities\nimport { propsFactory } from '@/util'\n\n// Types\nexport interface TagProps {\n  tag: string\n}\n\n// Composables\nexport const makeTagProps = propsFactory({\n  tag: {\n    type: String,\n    default: 'div',\n  },\n}, 'tag')\n"],
+  "mappings": ";;;;;AASO,IAAMA,eAAeC,aAAa;EACvCC,KAAK;IACHC,MAAMC;IACNC,SAAS;EACX;AACF,GAAG,KAAK;",
+  "names": ["makeTagProps", "propsFactory", "tag", "type", "String", "default"]
+}

VApp/node_modules/.vite/deps/chunk-DOBNCX34.js

@@ -0,0 +1,84 @@
+// node_modules/vuetify/lib/composables/forwardRefs.mjs
+var Refs = Symbol("Forwarded refs");
+function getDescriptor(obj, key) {
+  let currentObj = obj;
+  while (currentObj) {
+    const descriptor = Reflect.getOwnPropertyDescriptor(currentObj, key);
+    if (descriptor) return descriptor;
+    currentObj = Object.getPrototypeOf(currentObj);
+  }
+  return void 0;
+}
+function forwardRefs(target) {
+  for (var _len = arguments.length, refs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    refs[_key - 1] = arguments[_key];
+  }
+  target[Refs] = refs;
+  return new Proxy(target, {
+    get(target2, key) {
+      if (Reflect.has(target2, key)) {
+        return Reflect.get(target2, key);
+      }
+      if (typeof key === "symbol" || key.startsWith("$") || key.startsWith("__")) return;
+      for (const ref of refs) {
+        if (ref.value && Reflect.has(ref.value, key)) {
+          const val = Reflect.get(ref.value, key);
+          return typeof val === "function" ? val.bind(ref.value) : val;
+        }
+      }
+    },
+    has(target2, key) {
+      if (Reflect.has(target2, key)) {
+        return true;
+      }
+      if (typeof key === "symbol" || key.startsWith("$") || key.startsWith("__")) return false;
+      for (const ref of refs) {
+        if (ref.value && Reflect.has(ref.value, key)) {
+          return true;
+        }
+      }
+      return false;
+    },
+    set(target2, key, value) {
+      if (Reflect.has(target2, key)) {
+        return Reflect.set(target2, key, value);
+      }
+      if (typeof key === "symbol" || key.startsWith("$") || key.startsWith("__")) return false;
+      for (const ref of refs) {
+        if (ref.value && Reflect.has(ref.value, key)) {
+          return Reflect.set(ref.value, key, value);
+        }
+      }
+      return false;
+    },
+    getOwnPropertyDescriptor(target2, key) {
+      var _a;
+      const descriptor = Reflect.getOwnPropertyDescriptor(target2, key);
+      if (descriptor) return descriptor;
+      if (typeof key === "symbol" || key.startsWith("$") || key.startsWith("__")) return;
+      for (const ref of refs) {
+        if (!ref.value) continue;
+        const descriptor2 = getDescriptor(ref.value, key) ?? ("_" in ref.value ? getDescriptor((_a = ref.value._) == null ? void 0 : _a.setupState, key) : void 0);
+        if (descriptor2) return descriptor2;
+      }
+      for (const ref of refs) {
+        const childRefs = ref.value && ref.value[Refs];
+        if (!childRefs) continue;
+        const queue = childRefs.slice();
+        while (queue.length) {
+          const ref2 = queue.shift();
+          const descriptor2 = getDescriptor(ref2.value, key);
+          if (descriptor2) return descriptor2;
+          const childRefs2 = ref2.value && ref2.value[Refs];
+          if (childRefs2) queue.push(...childRefs2);
+        }
+      }
+      return void 0;
+    }
+  });
+}
+
+export {
+  forwardRefs
+};
+//# sourceMappingURL=chunk-DOBNCX34.js.map

VApp/node_modules/.vite/deps/chunk-DOBNCX34.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../vuetify/src/composables/forwardRefs.ts"],
+  "sourcesContent": ["// Types\nimport type { ComponentPublicInstance, Ref, UnwrapRef } from 'vue'\nimport type { UnionToIntersection } from '@/util'\n\nconst Refs = Symbol('Forwarded refs')\n\n/** Omit properties starting with P */\ntype OmitPrefix<T, P extends string> = [Extract<keyof T, `${P}${any}`>] extends [never] ? T : Omit<T, `${P}${any}`>\n\ntype OmitProps<T> = T extends { $props: any } ? Omit<T, keyof T['$props']> : T\n\nfunction getDescriptor (obj: any, key: PropertyKey) {\n  let currentObj = obj\n  while (currentObj) {\n    const descriptor = Reflect.getOwnPropertyDescriptor(currentObj, key)\n    if (descriptor) return descriptor\n    currentObj = Object.getPrototypeOf(currentObj)\n  }\n  return undefined\n}\n\nexport function forwardRefs<T extends {}, U extends Ref<HTMLElement | Omit<ComponentPublicInstance, '$emit' | '$slots'> | undefined>[]> (\n  target: T,\n  ...refs: U\n): T & UnionToIntersection<{ [K in keyof U]: OmitPrefix<OmitProps<NonNullable<UnwrapRef<U[K]>>>, '$'> }[number]> {\n  (target as any)[Refs] = refs\n\n  return new Proxy(target, {\n    get (target, key) {\n      if (Reflect.has(target, key)) {\n        return Reflect.get(target, key)\n      }\n\n      // Skip internal properties\n      if (typeof key === 'symbol' || key.startsWith('$') || key.startsWith('__')) return\n\n      for (const ref of refs) {\n        if (ref.value && Reflect.has(ref.value, key)) {\n          const val = Reflect.get(ref.value, key)\n          return typeof val === 'function'\n            ? val.bind(ref.value)\n            : val\n        }\n      }\n    },\n    has (target, key) {\n      if (Reflect.has(target, key)) {\n        return true\n      }\n\n      // Skip internal properties\n      if (typeof key === 'symbol' || key.startsWith('$') || key.startsWith('__')) return false\n\n      for (const ref of refs) {\n        if (ref.value && Reflect.has(ref.value, key)) {\n          return true\n        }\n      }\n      return false\n    },\n    set (target, key, value) {\n      if (Reflect.has(target, key)) {\n        return Reflect.set(target, key, value)\n      }\n\n      // Skip internal properties\n      if (typeof key === 'symbol' || key.startsWith('$') || key.startsWith('__')) return false\n\n      for (const ref of refs) {\n        if (ref.value && Reflect.has(ref.value, key)) {\n          return Reflect.set(ref.value, key, value)\n        }\n      }\n\n      return false\n    },\n    getOwnPropertyDescriptor (target, key) {\n      const descriptor = Reflect.getOwnPropertyDescriptor(target, key)\n      if (descriptor) return descriptor\n\n      // Skip internal properties\n      if (typeof key === 'symbol' || key.startsWith('$') || key.startsWith('__')) return\n\n      // Check each ref's own properties\n      for (const ref of refs) {\n        if (!ref.value) continue\n        const descriptor = getDescriptor(ref.value, key) ?? ('_' in ref.value ? getDescriptor(ref.value._?.setupState, key) : undefined)\n        if (descriptor) return descriptor\n      }\n\n      // Recursive search up each ref's prototype\n      for (const ref of refs) {\n        const childRefs = ref.value && (ref.value as any)[Refs]\n        if (!childRefs) continue\n        const queue = childRefs.slice()\n        while (queue.length) {\n          const ref = queue.shift()\n          const descriptor = getDescriptor(ref.value, key)\n          if (descriptor) return descriptor\n          const childRefs = ref.value && (ref.value as any)[Refs]\n          if (childRefs) queue.push(...childRefs)\n        }\n      }\n\n      return undefined\n    },\n  }) as any\n}\n"],
+  "mappings": ";AAIA,IAAMA,OAAOC,OAAO,gBAAgB;AAOpC,SAASC,cAAeC,KAAUC,KAAkB;AAClD,MAAIC,aAAaF;AACjB,SAAOE,YAAY;AACjB,UAAMC,aAAaC,QAAQC,yBAAyBH,YAAYD,GAAG;AACnE,QAAIE,WAAY,QAAOA;AACvBD,iBAAaI,OAAOC,eAAeL,UAAU;EAC/C;AACA,SAAOM;AACT;AAEO,SAASC,YACdC,QAE+G;AAAA,WAAAC,OAAAC,UAAAC,QAD5GC,OAAI,IAAAC,MAAAJ,OAAA,IAAAA,OAAA,IAAA,CAAA,GAAAK,OAAA,GAAAA,OAAAL,MAAAK,QAAA;AAAJF,SAAIE,OAAA,CAAA,IAAAJ,UAAAI,IAAA;EAAA;AAENN,SAAeb,IAAI,IAAIiB;AAExB,SAAO,IAAIG,MAAMP,QAAQ;IACvBQ,IAAKR,SAAQT,KAAK;AAChB,UAAIG,QAAQe,IAAIT,SAAQT,GAAG,GAAG;AAC5B,eAAOG,QAAQc,IAAIR,SAAQT,GAAG;MAChC;AAGA,UAAI,OAAOA,QAAQ,YAAYA,IAAImB,WAAW,GAAG,KAAKnB,IAAImB,WAAW,IAAI,EAAG;AAE5E,iBAAWC,OAAOP,MAAM;AACtB,YAAIO,IAAIC,SAASlB,QAAQe,IAAIE,IAAIC,OAAOrB,GAAG,GAAG;AAC5C,gBAAMsB,MAAMnB,QAAQc,IAAIG,IAAIC,OAAOrB,GAAG;AACtC,iBAAO,OAAOsB,QAAQ,aAClBA,IAAIC,KAAKH,IAAIC,KAAK,IAClBC;QACN;MACF;IACF;IACAJ,IAAKT,SAAQT,KAAK;AAChB,UAAIG,QAAQe,IAAIT,SAAQT,GAAG,GAAG;AAC5B,eAAO;MACT;AAGA,UAAI,OAAOA,QAAQ,YAAYA,IAAImB,WAAW,GAAG,KAAKnB,IAAImB,WAAW,IAAI,EAAG,QAAO;AAEnF,iBAAWC,OAAOP,MAAM;AACtB,YAAIO,IAAIC,SAASlB,QAAQe,IAAIE,IAAIC,OAAOrB,GAAG,GAAG;AAC5C,iBAAO;QACT;MACF;AACA,aAAO;IACT;IACAwB,IAAKf,SAAQT,KAAKqB,OAAO;AACvB,UAAIlB,QAAQe,IAAIT,SAAQT,GAAG,GAAG;AAC5B,eAAOG,QAAQqB,IAAIf,SAAQT,KAAKqB,KAAK;MACvC;AAGA,UAAI,OAAOrB,QAAQ,YAAYA,IAAImB,WAAW,GAAG,KAAKnB,IAAImB,WAAW,IAAI,EAAG,QAAO;AAEnF,iBAAWC,OAAOP,MAAM;AACtB,YAAIO,IAAIC,SAASlB,QAAQe,IAAIE,IAAIC,OAAOrB,GAAG,GAAG;AAC5C,iBAAOG,QAAQqB,IAAIJ,IAAIC,OAAOrB,KAAKqB,KAAK;QAC1C;MACF;AAEA,aAAO;IACT;IACAjB,yBAA0BK,SAAQT,KAAK;AA5E3C;AA6EM,YAAME,aAAaC,QAAQC,yBAAyBK,SAAQT,GAAG;AAC/D,UAAIE,WAAY,QAAOA;AAGvB,UAAI,OAAOF,QAAQ,YAAYA,IAAImB,WAAW,GAAG,KAAKnB,IAAImB,WAAW,IAAI,EAAG;AAG5E,iBAAWC,OAAOP,MAAM;AACtB,YAAI,CAACO,IAAIC,MAAO;AAChB,cAAMnB,cAAaJ,cAAcsB,IAAIC,OAAOrB,GAAG,MAAM,OAAOoB,IAAIC,QAAQvB,eAAcsB,SAAIC,MAAMI,MAAVL,mBAAaM,YAAY1B,GAAG,IAAIO;AACtH,YAAIL,YAAY,QAAOA;MACzB;AAGA,iBAAWkB,OAAOP,MAAM;AACtB,cAAMc,YAAYP,IAAIC,SAAUD,IAAIC,MAAczB,IAAI;AACtD,YAAI,CAAC+B,UAAW;AAChB,cAAMC,QAAQD,UAAUE,MAAM;AAC9B,eAAOD,MAAMhB,QAAQ;AACnB,gBAAMQ,OAAMQ,MAAME,MAAM;AACxB,gBAAM5B,cAAaJ,cAAcsB,KAAIC,OAAOrB,GAAG;AAC/C,cAAIE,YAAY,QAAOA;AACvB,gBAAMyB,aAAYP,KAAIC,SAAUD,KAAIC,MAAczB,IAAI;AACtD,cAAI+B,WAAWC,OAAMG,KAAK,GAAGJ,UAAS;QACxC;MACF;AAEA,aAAOpB;IACT;EACF,CAAC;AACH;",
+  "names": ["Refs", "Symbol", "getDescriptor", "obj", "key", "currentObj", "descriptor", "Reflect", "getOwnPropertyDescriptor", "Object", "getPrototypeOf", "undefined", "forwardRefs", "target", "_len", "arguments", "length", "refs", "Array", "_key", "Proxy", "get", "has", "startsWith", "ref", "value", "val", "bind", "set", "_", "setupState", "childRefs", "queue", "slice", "shift", "push"]
+}

VApp/node_modules/.vite/deps/chunk-FHRMVSBZ.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-FHRMVSBZ.js.map

VApp/node_modules/.vite/deps/chunk-FHRMVSBZ.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

VApp/node_modules/.vite/deps/chunk-IFUDBK56.js

@@ -0,0 +1,134 @@
+import {
+  useTextColor
+} from "./chunk-ZZ55KHRR.js";
+import {
+  IconValue,
+  useIcon
+} from "./chunk-472DNWSX.js";
+import {
+  makeTagProps
+} from "./chunk-DJRL4NAD.js";
+import {
+  makeThemeProps,
+  provideTheme
+} from "./chunk-CYOEVGGH.js";
+import {
+  convertToUnit,
+  destructComputed,
+  flattenFragments,
+  genericComponent,
+  getCurrentInstanceName,
+  includes,
+  makeComponentProps,
+  propsFactory,
+  useRender
+} from "./chunk-I4KGD5X4.js";
+import {
+  Text,
+  computed,
+  createVNode,
+  ref,
+  toRef
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/components/VIcon/VIcon.mjs
+import "C:/Users/Jeremy/Documents/Dev/Projects.cloudsucks.net/Vulture/VApp/node_modules/vuetify/lib/components/VIcon/VIcon.css";
+
+// node_modules/vuetify/lib/composables/size.mjs
+var predefinedSizes = ["x-small", "small", "default", "large", "x-large"];
+var makeSizeProps = propsFactory({
+  size: {
+    type: [String, Number],
+    default: "default"
+  }
+}, "size");
+function useSize(props) {
+  let name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : getCurrentInstanceName();
+  return destructComputed(() => {
+    let sizeClasses;
+    let sizeStyles;
+    if (includes(predefinedSizes, props.size)) {
+      sizeClasses = `${name}--size-${props.size}`;
+    } else if (props.size) {
+      sizeStyles = {
+        width: convertToUnit(props.size),
+        height: convertToUnit(props.size)
+      };
+    }
+    return {
+      sizeClasses,
+      sizeStyles
+    };
+  });
+}
+
+// node_modules/vuetify/lib/components/VIcon/VIcon.mjs
+var makeVIconProps = propsFactory({
+  color: String,
+  start: Boolean,
+  end: Boolean,
+  icon: IconValue,
+  ...makeComponentProps(),
+  ...makeSizeProps(),
+  ...makeTagProps({
+    tag: "i"
+  }),
+  ...makeThemeProps()
+}, "VIcon");
+var VIcon = genericComponent()({
+  name: "VIcon",
+  props: makeVIconProps(),
+  setup(props, _ref) {
+    let {
+      attrs,
+      slots
+    } = _ref;
+    const slotIcon = ref();
+    const {
+      themeClasses
+    } = provideTheme(props);
+    const {
+      iconData
+    } = useIcon(computed(() => slotIcon.value || props.icon));
+    const {
+      sizeClasses
+    } = useSize(props);
+    const {
+      textColorClasses,
+      textColorStyles
+    } = useTextColor(toRef(props, "color"));
+    useRender(() => {
+      var _a, _b;
+      const slotValue = (_a = slots.default) == null ? void 0 : _a.call(slots);
+      if (slotValue) {
+        slotIcon.value = (_b = flattenFragments(slotValue).filter((node) => node.type === Text && node.children && typeof node.children === "string")[0]) == null ? void 0 : _b.children;
+      }
+      return createVNode(iconData.value.component, {
+        "tag": props.tag,
+        "icon": iconData.value.icon,
+        "class": ["v-icon", "notranslate", themeClasses.value, sizeClasses.value, textColorClasses.value, {
+          "v-icon--clickable": !!attrs.onClick,
+          "v-icon--start": props.start,
+          "v-icon--end": props.end
+        }, props.class],
+        "style": [!sizeClasses.value ? {
+          fontSize: convertToUnit(props.size),
+          height: convertToUnit(props.size),
+          width: convertToUnit(props.size)
+        } : void 0, textColorStyles.value, props.style],
+        "role": attrs.onClick ? "button" : void 0,
+        "aria-hidden": !attrs.onClick
+      }, {
+        default: () => [slotValue]
+      });
+    });
+    return {};
+  }
+});
+
+export {
+  makeSizeProps,
+  useSize,
+  VIcon
+};
+//# sourceMappingURL=chunk-IFUDBK56.js.map

VApp/node_modules/.vite/deps/chunk-IFUDBK56.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../vuetify/src/components/VIcon/VIcon.tsx", "../../vuetify/src/composables/size.ts"],
+  "sourcesContent": ["// Styles\nimport './VIcon.sass'\n\n// Composables\nimport { useTextColor } from '@/composables/color'\nimport { makeComponentProps } from '@/composables/component'\nimport { IconValue, useIcon } from '@/composables/icons'\nimport { makeSizeProps, useSize } from '@/composables/size'\nimport { makeTagProps } from '@/composables/tag'\nimport { makeThemeProps, provideTheme } from '@/composables/theme'\n\n// Utilities\nimport { computed, ref, Text, toRef } from 'vue'\nimport { convertToUnit, flattenFragments, genericComponent, propsFactory, useRender } from '@/util'\n\nexport const makeVIconProps = propsFactory({\n  color: String,\n  start: Boolean,\n  end: Boolean,\n  icon: IconValue,\n\n  ...makeComponentProps(),\n  ...makeSizeProps(),\n  ...makeTagProps({ tag: 'i' }),\n  ...makeThemeProps(),\n}, 'VIcon')\n\nexport const VIcon = genericComponent()({\n  name: 'VIcon',\n\n  props: makeVIconProps(),\n\n  setup (props, { attrs, slots }) {\n    const slotIcon = ref<string>()\n\n    const { themeClasses } = provideTheme(props)\n    const { iconData } = useIcon(computed(() => slotIcon.value || props.icon))\n    const { sizeClasses } = useSize(props)\n    const { textColorClasses, textColorStyles } = useTextColor(toRef(props, 'color'))\n\n    useRender(() => {\n      const slotValue = slots.default?.()\n      if (slotValue) {\n        slotIcon.value = flattenFragments(slotValue).filter(node =>\n          node.type === Text && node.children && typeof node.children === 'string'\n        )[0]?.children as string\n      }\n\n      return (\n        <iconData.value.component\n          tag={ props.tag }\n          icon={ iconData.value.icon }\n          class={[\n            'v-icon',\n            'notranslate',\n            themeClasses.value,\n            sizeClasses.value,\n            textColorClasses.value,\n            {\n              'v-icon--clickable': !!attrs.onClick,\n              'v-icon--start': props.start,\n              'v-icon--end': props.end,\n            },\n            props.class,\n          ]}\n          style={[\n            !sizeClasses.value ? ({\n              fontSize: convertToUnit(props.size),\n              height: convertToUnit(props.size),\n              width: convertToUnit(props.size),\n            }) : undefined,\n            textColorStyles.value,\n            props.style,\n          ]}\n          role={ attrs.onClick ? 'button' : undefined }\n          aria-hidden={ !attrs.onClick }\n        >\n          { slotValue }\n        </iconData.value.component>\n      )\n    })\n\n    return {}\n  },\n})\n\nexport type VIcon = InstanceType<typeof VIcon>\n", "// Utilities\nimport { convertToUnit, destructComputed, getCurrentInstanceName, includes, propsFactory } from '@/util'\n\n// Types\nconst predefinedSizes = ['x-small', 'small', 'default', 'large', 'x-large']\n\nexport interface SizeProps {\n  size?: string | number\n}\n\n// Composables\nexport const makeSizeProps = propsFactory({\n  size: {\n    type: [String, Number],\n    default: 'default',\n  },\n}, 'size')\n\nexport function useSize (\n  props: SizeProps,\n  name = getCurrentInstanceName(),\n) {\n  return destructComputed(() => {\n    let sizeClasses\n    let sizeStyles\n    if (includes(predefinedSizes, props.size)) {\n      sizeClasses = `${name}--size-${props.size}`\n    } else if (props.size) {\n      sizeStyles = {\n        width: convertToUnit(props.size),\n        height: convertToUnit(props.size),\n      }\n    }\n    return { sizeClasses, sizeStyles }\n  })\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,OAAA;;;ACGA,IAAMA,kBAAkB,CAAC,WAAW,SAAS,WAAW,SAAS,SAAS;AAOnE,IAAMC,gBAAgBC,aAAa;EACxCC,MAAM;IACJC,MAAM,CAACC,QAAQC,MAAM;IACrBC,SAAS;EACX;AACF,GAAG,MAAM;AAEF,SAASC,QACdC,OAEA;AAAA,MADAC,OAAIC,UAAAC,SAAA,KAAAD,UAAA,CAAA,MAAAE,SAAAF,UAAA,CAAA,IAAGG,uBAAuB;AAE9B,SAAOC,iBAAiB,MAAM;AAC5B,QAAIC;AACJ,QAAIC;AACJ,QAAIC,SAASlB,iBAAiBS,MAAMN,IAAI,GAAG;AACzCa,oBAAe,GAAEN,IAAK,UAASD,MAAMN,IAAK;IAC5C,WAAWM,MAAMN,MAAM;AACrBc,mBAAa;QACXE,OAAOC,cAAcX,MAAMN,IAAI;QAC/BkB,QAAQD,cAAcX,MAAMN,IAAI;MAClC;IACF;AACA,WAAO;MAAEa;MAAaC;IAAW;EACnC,CAAC;AACH;;;ADpBO,IAAMK,iBAAiBC,aAAa;EACzCC,OAAOC;EACPC,OAAOC;EACPC,KAAKD;EACLE,MAAMC;EAEN,GAAGC,mBAAmB;EACtB,GAAGC,cAAc;EACjB,GAAGC,aAAa;IAAEC,KAAK;EAAI,CAAC;EAC5B,GAAGC,eAAe;AACpB,GAAG,OAAO;AAEH,IAAMC,QAAQC,iBAAiB,EAAE;EACtCC,MAAM;EAENC,OAAOjB,eAAe;EAEtBkB,MAAOD,OAAKE,MAAoB;AAAA,QAAlB;MAAEC;MAAOC;IAAM,IAACF;AAC5B,UAAMG,WAAWC,IAAY;AAE7B,UAAM;MAAEC;IAAa,IAAIC,aAAaR,KAAK;AAC3C,UAAM;MAAES;IAAS,IAAIC,QAAQC,SAAS,MAAMN,SAASO,SAASZ,MAAMV,IAAI,CAAC;AACzE,UAAM;MAAEuB;IAAY,IAAIC,QAAQd,KAAK;AACrC,UAAM;MAAEe;MAAkBC;IAAgB,IAAIC,aAAaC,MAAMlB,OAAO,OAAO,CAAC;AAEhFmB,cAAU,MAAM;;AACd,YAAMC,aAAYhB,WAAMiB,YAANjB;AAClB,UAAIgB,WAAW;AACbf,iBAASO,SAAQU,sBAAiBF,SAAS,EAAEG,OAAOC,UAClDA,KAAKC,SAASC,QAAQF,KAAKG,YAAY,OAAOH,KAAKG,aAAa,QAClE,EAAE,CAAC,MAFcL,mBAEXK;MACR;AAEA,aAAAC,YAAAnB,SAAAG,MAAAiB,WAAA;QAAA,OAEU7B,MAAML;QAAG,QACRc,SAASG,MAAMtB;QAAI,SACnB,CACL,UACA,eACAiB,aAAaK,OACbC,YAAYD,OACZG,iBAAiBH,OACjB;UACE,qBAAqB,CAAC,CAACT,MAAM2B;UAC7B,iBAAiB9B,MAAMb;UACvB,eAAea,MAAMX;QACvB,GACAW,MAAM+B,KAAK;QACZ,SACM,CACL,CAAClB,YAAYD,QAAS;UACpBoB,UAAUC,cAAcjC,MAAMkC,IAAI;UAClCC,QAAQF,cAAcjC,MAAMkC,IAAI;UAChCE,OAAOH,cAAcjC,MAAMkC,IAAI;QACjC,IAAKG,QACLrB,gBAAgBJ,OAChBZ,MAAMsC,KAAK;QACZ,QACMnC,MAAM2B,UAAU,WAAWO;QAAS,eAC7B,CAAClC,MAAM2B;MAAO,GAAA;QAAAT,SAAAA,MAAA,CAE1BD,SAAS;MAAA,CAAA;IAGjB,CAAC;AAED,WAAO,CAAC;EACV;AACF,CAAC;",
+  "names": ["predefinedSizes", "makeSizeProps", "propsFactory", "size", "type", "String", "Number", "default", "useSize", "props", "name", "arguments", "length", "undefined", "getCurrentInstanceName", "destructComputed", "sizeClasses", "sizeStyles", "includes", "width", "convertToUnit", "height", "makeVIconProps", "propsFactory", "color", "String", "start", "Boolean", "end", "icon", "IconValue", "makeComponentProps", "makeSizeProps", "makeTagProps", "tag", "makeThemeProps", "VIcon", "genericComponent", "name", "props", "setup", "_ref", "attrs", "slots", "slotIcon", "ref", "themeClasses", "provideTheme", "iconData", "useIcon", "computed", "value", "sizeClasses", "useSize", "textColorClasses", "textColorStyles", "useTextColor", "toRef", "useRender", "slotValue", "default", "flattenFragments", "filter", "node", "type", "Text", "children", "_createVNode", "component", "onClick", "class", "fontSize", "convertToUnit", "size", "height", "width", "undefined", "style"]
+}

VApp/node_modules/.vite/deps/chunk-IR5437QA.js

@@ -0,0 +1,300 @@
+import {
+  useProxiedModel
+} from "./chunk-PVQHDZXM.js";
+import {
+  consoleError,
+  consoleWarn,
+  getObjectValueByPath
+} from "./chunk-I4KGD5X4.js";
+import {
+  computed,
+  inject,
+  ref,
+  shallowRef,
+  watch
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/locale/en.mjs
+var en_default = {
+  badge: "Badge",
+  open: "Open",
+  close: "Close",
+  confirmEdit: {
+    ok: "OK",
+    cancel: "Cancel"
+  },
+  dataIterator: {
+    noResultsText: "No matching records found",
+    loadingText: "Loading items..."
+  },
+  dataTable: {
+    itemsPerPageText: "Rows per page:",
+    ariaLabel: {
+      sortDescending: "Sorted descending.",
+      sortAscending: "Sorted ascending.",
+      sortNone: "Not sorted.",
+      activateNone: "Activate to remove sorting.",
+      activateDescending: "Activate to sort descending.",
+      activateAscending: "Activate to sort ascending."
+    },
+    sortBy: "Sort by"
+  },
+  dataFooter: {
+    itemsPerPageText: "Items per page:",
+    itemsPerPageAll: "All",
+    nextPage: "Next page",
+    prevPage: "Previous page",
+    firstPage: "First page",
+    lastPage: "Last page",
+    pageText: "{0}-{1} of {2}"
+  },
+  dateRangeInput: {
+    divider: "to"
+  },
+  datePicker: {
+    itemsSelected: "{0} selected",
+    range: {
+      title: "Select dates",
+      header: "Enter dates"
+    },
+    title: "Select date",
+    header: "Enter date",
+    input: {
+      placeholder: "Enter date"
+    }
+  },
+  noDataText: "No data available",
+  carousel: {
+    prev: "Previous visual",
+    next: "Next visual",
+    ariaLabel: {
+      delimiter: "Carousel slide {0} of {1}"
+    }
+  },
+  calendar: {
+    moreEvents: "{0} more",
+    today: "Today"
+  },
+  input: {
+    clear: "Clear {0}",
+    prependAction: "{0} prepended action",
+    appendAction: "{0} appended action",
+    otp: "Please enter OTP character {0}"
+  },
+  fileInput: {
+    counter: "{0} files",
+    counterSize: "{0} files ({1} in total)"
+  },
+  timePicker: {
+    am: "AM",
+    pm: "PM"
+  },
+  pagination: {
+    ariaLabel: {
+      root: "Pagination Navigation",
+      next: "Next page",
+      previous: "Previous page",
+      page: "Go to page {0}",
+      currentPage: "Page {0}, Current page",
+      first: "First page",
+      last: "Last page"
+    }
+  },
+  stepper: {
+    next: "Next",
+    prev: "Previous"
+  },
+  rating: {
+    ariaLabel: {
+      item: "Rating {0} of {1}"
+    }
+  },
+  loading: "Loading...",
+  infiniteScroll: {
+    loadMore: "Load more",
+    empty: "No more"
+  }
+};
+
+// node_modules/vuetify/lib/locale/adapters/vuetify.mjs
+var LANG_PREFIX = "$vuetify.";
+var replace = (str, params) => {
+  return str.replace(/\{(\d+)\}/g, (match, index) => {
+    return String(params[+index]);
+  });
+};
+var createTranslateFunction = (current, fallback, messages) => {
+  return function(key) {
+    for (var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      params[_key - 1] = arguments[_key];
+    }
+    if (!key.startsWith(LANG_PREFIX)) {
+      return replace(key, params);
+    }
+    const shortKey = key.replace(LANG_PREFIX, "");
+    const currentLocale = current.value && messages.value[current.value];
+    const fallbackLocale = fallback.value && messages.value[fallback.value];
+    let str = getObjectValueByPath(currentLocale, shortKey, null);
+    if (!str) {
+      consoleWarn(`Translation key "${key}" not found in "${current.value}", trying fallback locale`);
+      str = getObjectValueByPath(fallbackLocale, shortKey, null);
+    }
+    if (!str) {
+      consoleError(`Translation key "${key}" not found in fallback`);
+      str = key;
+    }
+    if (typeof str !== "string") {
+      consoleError(`Translation key "${key}" has a non-string value`);
+      str = key;
+    }
+    return replace(str, params);
+  };
+};
+function createNumberFunction(current, fallback) {
+  return (value, options) => {
+    const numberFormat = new Intl.NumberFormat([current.value, fallback.value], options);
+    return numberFormat.format(value);
+  };
+}
+function useProvided(props, prop, provided) {
+  const internal = useProxiedModel(props, prop, props[prop] ?? provided.value);
+  internal.value = props[prop] ?? provided.value;
+  watch(provided, (v) => {
+    if (props[prop] == null) {
+      internal.value = provided.value;
+    }
+  });
+  return internal;
+}
+function createProvideFunction(state) {
+  return (props) => {
+    const current = useProvided(props, "locale", state.current);
+    const fallback = useProvided(props, "fallback", state.fallback);
+    const messages = useProvided(props, "messages", state.messages);
+    return {
+      name: "vuetify",
+      current,
+      fallback,
+      messages,
+      t: createTranslateFunction(current, fallback, messages),
+      n: createNumberFunction(current, fallback),
+      provide: createProvideFunction({
+        current,
+        fallback,
+        messages
+      })
+    };
+  };
+}
+function createVuetifyAdapter(options) {
+  const current = shallowRef((options == null ? void 0 : options.locale) ?? "en");
+  const fallback = shallowRef((options == null ? void 0 : options.fallback) ?? "en");
+  const messages = ref({
+    en: en_default,
+    ...options == null ? void 0 : options.messages
+  });
+  return {
+    name: "vuetify",
+    current,
+    fallback,
+    messages,
+    t: createTranslateFunction(current, fallback, messages),
+    n: createNumberFunction(current, fallback),
+    provide: createProvideFunction({
+      current,
+      fallback,
+      messages
+    })
+  };
+}
+
+// node_modules/vuetify/lib/composables/locale.mjs
+var LocaleSymbol = Symbol.for("vuetify:locale");
+function isLocaleInstance(obj) {
+  return obj.name != null;
+}
+function createLocale(options) {
+  const i18n = (options == null ? void 0 : options.adapter) && isLocaleInstance(options == null ? void 0 : options.adapter) ? options == null ? void 0 : options.adapter : createVuetifyAdapter(options);
+  const rtl = createRtl(i18n, options);
+  return {
+    ...i18n,
+    ...rtl
+  };
+}
+function useLocale() {
+  const locale = inject(LocaleSymbol);
+  if (!locale) throw new Error("[Vuetify] Could not find injected locale instance");
+  return locale;
+}
+var RtlSymbol = Symbol.for("vuetify:rtl");
+function genDefaults() {
+  return {
+    af: false,
+    ar: true,
+    bg: false,
+    ca: false,
+    ckb: false,
+    cs: false,
+    de: false,
+    el: false,
+    en: false,
+    es: false,
+    et: false,
+    fa: true,
+    fi: false,
+    fr: false,
+    hr: false,
+    hu: false,
+    he: true,
+    id: false,
+    it: false,
+    ja: false,
+    km: false,
+    ko: false,
+    lv: false,
+    lt: false,
+    nl: false,
+    no: false,
+    pl: false,
+    pt: false,
+    ro: false,
+    ru: false,
+    sk: false,
+    sl: false,
+    srCyrl: false,
+    srLatn: false,
+    sv: false,
+    th: false,
+    tr: false,
+    az: false,
+    uk: false,
+    vi: false,
+    zhHans: false,
+    zhHant: false
+  };
+}
+function createRtl(i18n, options) {
+  const rtl = ref((options == null ? void 0 : options.rtl) ?? genDefaults());
+  const isRtl = computed(() => rtl.value[i18n.current.value] ?? false);
+  return {
+    isRtl,
+    rtl,
+    rtlClasses: computed(() => `v-locale--is-${isRtl.value ? "rtl" : "ltr"}`)
+  };
+}
+function useRtl() {
+  const locale = inject(LocaleSymbol);
+  if (!locale) throw new Error("[Vuetify] Could not find injected rtl instance");
+  return {
+    isRtl: locale.isRtl,
+    rtlClasses: locale.rtlClasses
+  };
+}
+
+export {
+  LocaleSymbol,
+  createLocale,
+  useLocale,
+  useRtl
+};
+//# sourceMappingURL=chunk-IR5437QA.js.map

VApp/node_modules/.vite/deps/chunk-J5HFPFMJ.js

@@ -0,0 +1,47 @@
+import {
+  makeThemeProps
+} from "./chunk-CYOEVGGH.js";
+import {
+  EventProp,
+  genericComponent,
+  makeComponentProps,
+  propsFactory,
+  useRender
+} from "./chunk-I4KGD5X4.js";
+import {
+  createVNode
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/components/VLabel/VLabel.mjs
+import "C:/Users/Jeremy/Documents/Dev/Projects.cloudsucks.net/Vulture/VApp/node_modules/vuetify/lib/components/VLabel/VLabel.css";
+var makeVLabelProps = propsFactory({
+  text: String,
+  onClick: EventProp(),
+  ...makeComponentProps(),
+  ...makeThemeProps()
+}, "VLabel");
+var VLabel = genericComponent()({
+  name: "VLabel",
+  props: makeVLabelProps(),
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    useRender(() => {
+      var _a;
+      return createVNode("label", {
+        "class": ["v-label", {
+          "v-label--clickable": !!props.onClick
+        }, props.class],
+        "style": props.style,
+        "onClick": props.onClick
+      }, [props.text, (_a = slots.default) == null ? void 0 : _a.call(slots)]);
+    });
+    return {};
+  }
+});
+
+export {
+  VLabel
+};
+//# sourceMappingURL=chunk-J5HFPFMJ.js.map

VApp/node_modules/.vite/deps/chunk-J5HFPFMJ.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../vuetify/src/components/VLabel/VLabel.tsx"],
+  "sourcesContent": ["// Styles\nimport './VLabel.sass'\n\n// Composables\nimport { makeComponentProps } from '@/composables/component'\nimport { makeThemeProps } from '@/composables/theme'\n\n// Utilities\nimport { EventProp, genericComponent, propsFactory, useRender } from '@/util'\n\nexport const makeVLabelProps = propsFactory({\n  text: String,\n\n  onClick: EventProp<[MouseEvent]>(),\n\n  ...makeComponentProps(),\n  ...makeThemeProps(),\n}, 'VLabel')\n\nexport const VLabel = genericComponent()({\n  name: 'VLabel',\n\n  props: makeVLabelProps(),\n\n  setup (props, { slots }) {\n    useRender(() => (\n      <label\n        class={[\n          'v-label',\n          {\n            'v-label--clickable': !!props.onClick,\n          },\n          props.class,\n        ]}\n        style={ props.style }\n        onClick={ props.onClick }\n      >\n        { props.text }\n\n        { slots.default?.() }\n      </label>\n    ))\n\n    return {}\n  },\n})\n\nexport type VLabel = InstanceType<typeof VLabel>\n"],
+  "mappings": ";;;;;;;;;;;;;;;AACA,OAAA;AASO,IAAMA,kBAAkBC,aAAa;EAC1CC,MAAMC;EAENC,SAASC,UAAwB;EAEjC,GAAGC,mBAAmB;EACtB,GAAGC,eAAe;AACpB,GAAG,QAAQ;AAEJ,IAAMC,SAASC,iBAAiB,EAAE;EACvCC,MAAM;EAENC,OAAOX,gBAAgB;EAEvBY,MAAOD,OAAKE,MAAa;AAAA,QAAX;MAAEC;IAAM,IAACD;AACrBE,cAAU,MAAA;;AAAAC,yBAAA,SAAA;QAAA,SAEC,CACL,WACA;UACE,sBAAsB,CAAC,CAACL,MAAMP;QAChC,GACAO,MAAMM,KAAK;QACZ,SACON,MAAMO;QAAK,WACTP,MAAMP;MAAO,GAAA,CAErBO,MAAMT,OAENY,WAAMK,YAANL,8BAAiB,CAAA;KAEtB;AAED,WAAO,CAAC;EACV;AACF,CAAC;",
+  "names": ["makeVLabelProps", "propsFactory", "text", "String", "onClick", "EventProp", "makeComponentProps", "makeThemeProps", "VLabel", "genericComponent", "name", "props", "setup", "_ref", "slots", "useRender", "_createVNode", "class", "style", "default"]
+}

VApp/node_modules/.vite/deps/chunk-JVLWTAZ5.js

@@ -0,0 +1,302 @@
+import {
+  useResizeObserver
+} from "./chunk-6MYZNPKW.js";
+import {
+  convertToUnit,
+  findChildrenWithProvide,
+  getCurrentInstance,
+  getUid,
+  propsFactory
+} from "./chunk-I4KGD5X4.js";
+import {
+  computed,
+  inject,
+  onActivated,
+  onBeforeUnmount,
+  onDeactivated,
+  onMounted,
+  provide,
+  reactive,
+  ref,
+  shallowRef
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/composables/layout.mjs
+var VuetifyLayoutKey = Symbol.for("vuetify:layout");
+var VuetifyLayoutItemKey = Symbol.for("vuetify:layout-item");
+var ROOT_ZINDEX = 1e3;
+var makeLayoutProps = propsFactory({
+  overlaps: {
+    type: Array,
+    default: () => []
+  },
+  fullHeight: Boolean
+}, "layout");
+var makeLayoutItemProps = propsFactory({
+  name: {
+    type: String
+  },
+  order: {
+    type: [Number, String],
+    default: 0
+  },
+  absolute: Boolean
+}, "layout-item");
+function useLayout() {
+  const layout = inject(VuetifyLayoutKey);
+  if (!layout) throw new Error("[Vuetify] Could not find injected layout");
+  return {
+    getLayoutItem: layout.getLayoutItem,
+    mainRect: layout.mainRect,
+    mainStyles: layout.mainStyles
+  };
+}
+function useLayoutItem(options) {
+  const layout = inject(VuetifyLayoutKey);
+  if (!layout) throw new Error("[Vuetify] Could not find injected layout");
+  const id = options.id ?? `layout-item-${getUid()}`;
+  const vm = getCurrentInstance("useLayoutItem");
+  provide(VuetifyLayoutItemKey, {
+    id
+  });
+  const isKeptAlive = shallowRef(false);
+  onDeactivated(() => isKeptAlive.value = true);
+  onActivated(() => isKeptAlive.value = false);
+  const {
+    layoutItemStyles,
+    layoutItemScrimStyles
+  } = layout.register(vm, {
+    ...options,
+    active: computed(() => isKeptAlive.value ? false : options.active.value),
+    id
+  });
+  onBeforeUnmount(() => layout.unregister(id));
+  return {
+    layoutItemStyles,
+    layoutRect: layout.layoutRect,
+    layoutItemScrimStyles
+  };
+}
+var generateLayers = (layout, positions, layoutSizes, activeItems) => {
+  let previousLayer = {
+    top: 0,
+    left: 0,
+    right: 0,
+    bottom: 0
+  };
+  const layers = [{
+    id: "",
+    layer: {
+      ...previousLayer
+    }
+  }];
+  for (const id of layout) {
+    const position = positions.get(id);
+    const amount = layoutSizes.get(id);
+    const active = activeItems.get(id);
+    if (!position || !amount || !active) continue;
+    const layer = {
+      ...previousLayer,
+      [position.value]: parseInt(previousLayer[position.value], 10) + (active.value ? parseInt(amount.value, 10) : 0)
+    };
+    layers.push({
+      id,
+      layer
+    });
+    previousLayer = layer;
+  }
+  return layers;
+};
+function createLayout(props) {
+  const parentLayout = inject(VuetifyLayoutKey, null);
+  const rootZIndex = computed(() => parentLayout ? parentLayout.rootZIndex.value - 100 : ROOT_ZINDEX);
+  const registered = ref([]);
+  const positions = reactive(/* @__PURE__ */ new Map());
+  const layoutSizes = reactive(/* @__PURE__ */ new Map());
+  const priorities = reactive(/* @__PURE__ */ new Map());
+  const activeItems = reactive(/* @__PURE__ */ new Map());
+  const disabledTransitions = reactive(/* @__PURE__ */ new Map());
+  const {
+    resizeRef,
+    contentRect: layoutRect
+  } = useResizeObserver();
+  const computedOverlaps = computed(() => {
+    const map = /* @__PURE__ */ new Map();
+    const overlaps = props.overlaps ?? [];
+    for (const overlap of overlaps.filter((item) => item.includes(":"))) {
+      const [top, bottom] = overlap.split(":");
+      if (!registered.value.includes(top) || !registered.value.includes(bottom)) continue;
+      const topPosition = positions.get(top);
+      const bottomPosition = positions.get(bottom);
+      const topAmount = layoutSizes.get(top);
+      const bottomAmount = layoutSizes.get(bottom);
+      if (!topPosition || !bottomPosition || !topAmount || !bottomAmount) continue;
+      map.set(bottom, {
+        position: topPosition.value,
+        amount: parseInt(topAmount.value, 10)
+      });
+      map.set(top, {
+        position: bottomPosition.value,
+        amount: -parseInt(bottomAmount.value, 10)
+      });
+    }
+    return map;
+  });
+  const layers = computed(() => {
+    const uniquePriorities = [...new Set([...priorities.values()].map((p) => p.value))].sort((a, b) => a - b);
+    const layout = [];
+    for (const p of uniquePriorities) {
+      const items2 = registered.value.filter((id) => {
+        var _a;
+        return ((_a = priorities.get(id)) == null ? void 0 : _a.value) === p;
+      });
+      layout.push(...items2);
+    }
+    return generateLayers(layout, positions, layoutSizes, activeItems);
+  });
+  const transitionsEnabled = computed(() => {
+    return !Array.from(disabledTransitions.values()).some((ref2) => ref2.value);
+  });
+  const mainRect = computed(() => {
+    return layers.value[layers.value.length - 1].layer;
+  });
+  const mainStyles = computed(() => {
+    return {
+      "--v-layout-left": convertToUnit(mainRect.value.left),
+      "--v-layout-right": convertToUnit(mainRect.value.right),
+      "--v-layout-top": convertToUnit(mainRect.value.top),
+      "--v-layout-bottom": convertToUnit(mainRect.value.bottom),
+      ...transitionsEnabled.value ? void 0 : {
+        transition: "none"
+      }
+    };
+  });
+  const items = computed(() => {
+    return layers.value.slice(1).map((_ref, index) => {
+      let {
+        id
+      } = _ref;
+      const {
+        layer
+      } = layers.value[index];
+      const size = layoutSizes.get(id);
+      const position = positions.get(id);
+      return {
+        id,
+        ...layer,
+        size: Number(size.value),
+        position: position.value
+      };
+    });
+  });
+  const getLayoutItem = (id) => {
+    return items.value.find((item) => item.id === id);
+  };
+  const rootVm = getCurrentInstance("createLayout");
+  const isMounted = shallowRef(false);
+  onMounted(() => {
+    isMounted.value = true;
+  });
+  provide(VuetifyLayoutKey, {
+    register: (vm, _ref2) => {
+      let {
+        id,
+        order,
+        position,
+        layoutSize,
+        elementSize,
+        active,
+        disableTransitions,
+        absolute
+      } = _ref2;
+      priorities.set(id, order);
+      positions.set(id, position);
+      layoutSizes.set(id, layoutSize);
+      activeItems.set(id, active);
+      disableTransitions && disabledTransitions.set(id, disableTransitions);
+      const instances = findChildrenWithProvide(VuetifyLayoutItemKey, rootVm == null ? void 0 : rootVm.vnode);
+      const instanceIndex = instances.indexOf(vm);
+      if (instanceIndex > -1) registered.value.splice(instanceIndex, 0, id);
+      else registered.value.push(id);
+      const index = computed(() => items.value.findIndex((i) => i.id === id));
+      const zIndex = computed(() => rootZIndex.value + layers.value.length * 2 - index.value * 2);
+      const layoutItemStyles = computed(() => {
+        const isHorizontal = position.value === "left" || position.value === "right";
+        const isOppositeHorizontal = position.value === "right";
+        const isOppositeVertical = position.value === "bottom";
+        const styles = {
+          [position.value]: 0,
+          zIndex: zIndex.value,
+          transform: `translate${isHorizontal ? "X" : "Y"}(${(active.value ? 0 : -110) * (isOppositeHorizontal || isOppositeVertical ? -1 : 1)}%)`,
+          position: absolute.value || rootZIndex.value !== ROOT_ZINDEX ? "absolute" : "fixed",
+          ...transitionsEnabled.value ? void 0 : {
+            transition: "none"
+          }
+        };
+        if (!isMounted.value) return styles;
+        const item = items.value[index.value];
+        if (!item) throw new Error(`[Vuetify] Could not find layout item "${id}"`);
+        const overlap = computedOverlaps.value.get(id);
+        if (overlap) {
+          item[overlap.position] += overlap.amount;
+        }
+        return {
+          ...styles,
+          height: isHorizontal ? `calc(100% - ${item.top}px - ${item.bottom}px)` : elementSize.value ? `${elementSize.value}px` : void 0,
+          left: isOppositeHorizontal ? void 0 : `${item.left}px`,
+          right: isOppositeHorizontal ? `${item.right}px` : void 0,
+          top: position.value !== "bottom" ? `${item.top}px` : void 0,
+          bottom: position.value !== "top" ? `${item.bottom}px` : void 0,
+          width: !isHorizontal ? `calc(100% - ${item.left}px - ${item.right}px)` : elementSize.value ? `${elementSize.value}px` : void 0
+        };
+      });
+      const layoutItemScrimStyles = computed(() => ({
+        zIndex: zIndex.value - 1
+      }));
+      return {
+        layoutItemStyles,
+        layoutItemScrimStyles,
+        zIndex
+      };
+    },
+    unregister: (id) => {
+      priorities.delete(id);
+      positions.delete(id);
+      layoutSizes.delete(id);
+      activeItems.delete(id);
+      disabledTransitions.delete(id);
+      registered.value = registered.value.filter((v) => v !== id);
+    },
+    mainRect,
+    mainStyles,
+    getLayoutItem,
+    items,
+    layoutRect,
+    rootZIndex
+  });
+  const layoutClasses = computed(() => ["v-layout", {
+    "v-layout--full-height": props.fullHeight
+  }]);
+  const layoutStyles = computed(() => ({
+    zIndex: parentLayout ? rootZIndex.value : void 0,
+    position: parentLayout ? "relative" : void 0,
+    overflow: parentLayout ? "hidden" : void 0
+  }));
+  return {
+    layoutClasses,
+    layoutStyles,
+    getLayoutItem,
+    items,
+    layoutRect,
+    layoutRef: resizeRef
+  };
+}
+
+export {
+  makeLayoutProps,
+  makeLayoutItemProps,
+  useLayout,
+  useLayoutItem,
+  createLayout
+};
+//# sourceMappingURL=chunk-JVLWTAZ5.js.map

VApp/node_modules/.vite/deps/chunk-JVZUVJAC.js

@@ -0,0 +1,352 @@
+import {
+  acceleratedEasing,
+  animate,
+  deceleratedEasing,
+  genericComponent,
+  getTargetBox,
+  nullifyTransforms,
+  propsFactory,
+  standardEasing
+} from "./chunk-I4KGD5X4.js";
+import {
+  Transition,
+  TransitionGroup,
+  camelize,
+  createVNode,
+  h,
+  mergeProps
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/components/transitions/dialog-transition.mjs
+var makeVDialogTransitionProps = propsFactory({
+  target: [Object, Array]
+}, "v-dialog-transition");
+var VDialogTransition = genericComponent()({
+  name: "VDialogTransition",
+  props: makeVDialogTransitionProps(),
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    const functions = {
+      onBeforeEnter(el) {
+        el.style.pointerEvents = "none";
+        el.style.visibility = "hidden";
+      },
+      async onEnter(el, done) {
+        var _a;
+        await new Promise((resolve) => requestAnimationFrame(resolve));
+        await new Promise((resolve) => requestAnimationFrame(resolve));
+        el.style.visibility = "";
+        const {
+          x,
+          y,
+          sx,
+          sy,
+          speed
+        } = getDimensions(props.target, el);
+        const animation = animate(el, [{
+          transform: `translate(${x}px, ${y}px) scale(${sx}, ${sy})`,
+          opacity: 0
+        }, {}], {
+          duration: 225 * speed,
+          easing: deceleratedEasing
+        });
+        (_a = getChildren(el)) == null ? void 0 : _a.forEach((el2) => {
+          animate(el2, [{
+            opacity: 0
+          }, {
+            opacity: 0,
+            offset: 0.33
+          }, {}], {
+            duration: 225 * 2 * speed,
+            easing: standardEasing
+          });
+        });
+        animation.finished.then(() => done());
+      },
+      onAfterEnter(el) {
+        el.style.removeProperty("pointer-events");
+      },
+      onBeforeLeave(el) {
+        el.style.pointerEvents = "none";
+      },
+      async onLeave(el, done) {
+        var _a;
+        await new Promise((resolve) => requestAnimationFrame(resolve));
+        const {
+          x,
+          y,
+          sx,
+          sy,
+          speed
+        } = getDimensions(props.target, el);
+        const animation = animate(el, [{}, {
+          transform: `translate(${x}px, ${y}px) scale(${sx}, ${sy})`,
+          opacity: 0
+        }], {
+          duration: 125 * speed,
+          easing: acceleratedEasing
+        });
+        animation.finished.then(() => done());
+        (_a = getChildren(el)) == null ? void 0 : _a.forEach((el2) => {
+          animate(el2, [{}, {
+            opacity: 0,
+            offset: 0.2
+          }, {
+            opacity: 0
+          }], {
+            duration: 125 * 2 * speed,
+            easing: standardEasing
+          });
+        });
+      },
+      onAfterLeave(el) {
+        el.style.removeProperty("pointer-events");
+      }
+    };
+    return () => {
+      return props.target ? createVNode(Transition, mergeProps({
+        "name": "dialog-transition"
+      }, functions, {
+        "css": false
+      }), slots) : createVNode(Transition, {
+        "name": "dialog-transition"
+      }, slots);
+    };
+  }
+});
+function getChildren(el) {
+  var _a;
+  const els = (_a = el.querySelector(":scope > .v-card, :scope > .v-sheet, :scope > .v-list")) == null ? void 0 : _a.children;
+  return els && [...els];
+}
+function getDimensions(target, el) {
+  const targetBox = getTargetBox(target);
+  const elBox = nullifyTransforms(el);
+  const [originX, originY] = getComputedStyle(el).transformOrigin.split(" ").map((v) => parseFloat(v));
+  const [anchorSide, anchorOffset] = getComputedStyle(el).getPropertyValue("--v-overlay-anchor-origin").split(" ");
+  let offsetX = targetBox.left + targetBox.width / 2;
+  if (anchorSide === "left" || anchorOffset === "left") {
+    offsetX -= targetBox.width / 2;
+  } else if (anchorSide === "right" || anchorOffset === "right") {
+    offsetX += targetBox.width / 2;
+  }
+  let offsetY = targetBox.top + targetBox.height / 2;
+  if (anchorSide === "top" || anchorOffset === "top") {
+    offsetY -= targetBox.height / 2;
+  } else if (anchorSide === "bottom" || anchorOffset === "bottom") {
+    offsetY += targetBox.height / 2;
+  }
+  const tsx = targetBox.width / elBox.width;
+  const tsy = targetBox.height / elBox.height;
+  const maxs = Math.max(1, tsx, tsy);
+  const sx = tsx / maxs || 0;
+  const sy = tsy / maxs || 0;
+  const asa = elBox.width * elBox.height / (window.innerWidth * window.innerHeight);
+  const speed = asa > 0.12 ? Math.min(1.5, (asa - 0.12) * 10 + 1) : 1;
+  return {
+    x: offsetX - (originX + elBox.left),
+    y: offsetY - (originY + elBox.top),
+    sx,
+    sy,
+    speed
+  };
+}
+
+// node_modules/vuetify/lib/components/transitions/createTransition.mjs
+var makeTransitionProps = propsFactory({
+  disabled: Boolean,
+  group: Boolean,
+  hideOnLeave: Boolean,
+  leaveAbsolute: Boolean,
+  mode: String,
+  origin: String
+}, "transition");
+function createCssTransition(name, origin, mode) {
+  return genericComponent()({
+    name,
+    props: makeTransitionProps({
+      mode,
+      origin
+    }),
+    setup(props, _ref) {
+      let {
+        slots
+      } = _ref;
+      const functions = {
+        onBeforeEnter(el) {
+          if (props.origin) {
+            el.style.transformOrigin = props.origin;
+          }
+        },
+        onLeave(el) {
+          if (props.leaveAbsolute) {
+            const {
+              offsetTop,
+              offsetLeft,
+              offsetWidth,
+              offsetHeight
+            } = el;
+            el._transitionInitialStyles = {
+              position: el.style.position,
+              top: el.style.top,
+              left: el.style.left,
+              width: el.style.width,
+              height: el.style.height
+            };
+            el.style.position = "absolute";
+            el.style.top = `${offsetTop}px`;
+            el.style.left = `${offsetLeft}px`;
+            el.style.width = `${offsetWidth}px`;
+            el.style.height = `${offsetHeight}px`;
+          }
+          if (props.hideOnLeave) {
+            el.style.setProperty("display", "none", "important");
+          }
+        },
+        onAfterLeave(el) {
+          if (props.leaveAbsolute && (el == null ? void 0 : el._transitionInitialStyles)) {
+            const {
+              position,
+              top,
+              left,
+              width,
+              height
+            } = el._transitionInitialStyles;
+            delete el._transitionInitialStyles;
+            el.style.position = position || "";
+            el.style.top = top || "";
+            el.style.left = left || "";
+            el.style.width = width || "";
+            el.style.height = height || "";
+          }
+        }
+      };
+      return () => {
+        const tag = props.group ? TransitionGroup : Transition;
+        return h(tag, {
+          name: props.disabled ? "" : name,
+          css: !props.disabled,
+          ...props.group ? void 0 : {
+            mode: props.mode
+          },
+          ...props.disabled ? {} : functions
+        }, slots.default);
+      };
+    }
+  });
+}
+function createJavascriptTransition(name, functions) {
+  let mode = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "in-out";
+  return genericComponent()({
+    name,
+    props: {
+      mode: {
+        type: String,
+        default: mode
+      },
+      disabled: Boolean
+    },
+    setup(props, _ref2) {
+      let {
+        slots
+      } = _ref2;
+      return () => {
+        return h(Transition, {
+          name: props.disabled ? "" : name,
+          css: !props.disabled,
+          // mode: props.mode, // TODO: vuejs/vue-next#3104
+          ...props.disabled ? {} : functions
+        }, slots.default);
+      };
+    }
+  });
+}
+
+// node_modules/vuetify/lib/components/transitions/expand-transition.mjs
+function expand_transition_default() {
+  let expandedParentClass = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "";
+  let x = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+  const sizeProperty = x ? "width" : "height";
+  const offsetProperty = camelize(`offset-${sizeProperty}`);
+  return {
+    onBeforeEnter(el) {
+      el._parent = el.parentNode;
+      el._initialStyle = {
+        transition: el.style.transition,
+        overflow: el.style.overflow,
+        [sizeProperty]: el.style[sizeProperty]
+      };
+    },
+    onEnter(el) {
+      const initialStyle = el._initialStyle;
+      el.style.setProperty("transition", "none", "important");
+      el.style.overflow = "hidden";
+      const offset = `${el[offsetProperty]}px`;
+      el.style[sizeProperty] = "0";
+      void el.offsetHeight;
+      el.style.transition = initialStyle.transition;
+      if (expandedParentClass && el._parent) {
+        el._parent.classList.add(expandedParentClass);
+      }
+      requestAnimationFrame(() => {
+        el.style[sizeProperty] = offset;
+      });
+    },
+    onAfterEnter: resetStyles,
+    onEnterCancelled: resetStyles,
+    onLeave(el) {
+      el._initialStyle = {
+        transition: "",
+        overflow: el.style.overflow,
+        [sizeProperty]: el.style[sizeProperty]
+      };
+      el.style.overflow = "hidden";
+      el.style[sizeProperty] = `${el[offsetProperty]}px`;
+      void el.offsetHeight;
+      requestAnimationFrame(() => el.style[sizeProperty] = "0");
+    },
+    onAfterLeave,
+    onLeaveCancelled: onAfterLeave
+  };
+  function onAfterLeave(el) {
+    if (expandedParentClass && el._parent) {
+      el._parent.classList.remove(expandedParentClass);
+    }
+    resetStyles(el);
+  }
+  function resetStyles(el) {
+    const size = el._initialStyle[sizeProperty];
+    el.style.overflow = el._initialStyle.overflow;
+    if (size != null) el.style[sizeProperty] = size;
+    delete el._initialStyle;
+  }
+}
+
+// node_modules/vuetify/lib/components/transitions/index.mjs
+var VFabTransition = createCssTransition("fab-transition", "center center", "out-in");
+var VDialogBottomTransition = createCssTransition("dialog-bottom-transition");
+var VDialogTopTransition = createCssTransition("dialog-top-transition");
+var VFadeTransition = createCssTransition("fade-transition");
+var VScaleTransition = createCssTransition("scale-transition");
+var VScrollXTransition = createCssTransition("scroll-x-transition");
+var VScrollXReverseTransition = createCssTransition("scroll-x-reverse-transition");
+var VScrollYTransition = createCssTransition("scroll-y-transition");
+var VScrollYReverseTransition = createCssTransition("scroll-y-reverse-transition");
+var VSlideXTransition = createCssTransition("slide-x-transition");
+var VSlideXReverseTransition = createCssTransition("slide-x-reverse-transition");
+var VSlideYTransition = createCssTransition("slide-y-transition");
+var VSlideYReverseTransition = createCssTransition("slide-y-reverse-transition");
+var VExpandTransition = createJavascriptTransition("expand-transition", expand_transition_default());
+var VExpandXTransition = createJavascriptTransition("expand-x-transition", expand_transition_default("", true));
+
+export {
+  VDialogTransition,
+  VFadeTransition,
+  VScaleTransition,
+  VSlideYTransition,
+  VExpandTransition,
+  VExpandXTransition
+};
+//# sourceMappingURL=chunk-JVZUVJAC.js.map

VApp/node_modules/.vite/deps/chunk-NMCVREUK.js

@@ -0,0 +1,287 @@
+import {
+  isObject,
+  keyCodes
+} from "./chunk-I4KGD5X4.js";
+
+// node_modules/vuetify/lib/directives/ripple/index.mjs
+import "C:/Users/Jeremy/Documents/Dev/Projects.cloudsucks.net/Vulture/VApp/node_modules/vuetify/lib/directives/ripple/VRipple.css";
+var stopSymbol = Symbol("rippleStop");
+var DELAY_RIPPLE = 80;
+function transform(el, value) {
+  el.style.transform = value;
+  el.style.webkitTransform = value;
+}
+function isTouchEvent(e) {
+  return e.constructor.name === "TouchEvent";
+}
+function isKeyboardEvent(e) {
+  return e.constructor.name === "KeyboardEvent";
+}
+var calculate = function(e, el) {
+  var _a;
+  let value = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+  let localX = 0;
+  let localY = 0;
+  if (!isKeyboardEvent(e)) {
+    const offset = el.getBoundingClientRect();
+    const target = isTouchEvent(e) ? e.touches[e.touches.length - 1] : e;
+    localX = target.clientX - offset.left;
+    localY = target.clientY - offset.top;
+  }
+  let radius = 0;
+  let scale = 0.3;
+  if ((_a = el._ripple) == null ? void 0 : _a.circle) {
+    scale = 0.15;
+    radius = el.clientWidth / 2;
+    radius = value.center ? radius : radius + Math.sqrt((localX - radius) ** 2 + (localY - radius) ** 2) / 4;
+  } else {
+    radius = Math.sqrt(el.clientWidth ** 2 + el.clientHeight ** 2) / 2;
+  }
+  const centerX = `${(el.clientWidth - radius * 2) / 2}px`;
+  const centerY = `${(el.clientHeight - radius * 2) / 2}px`;
+  const x = value.center ? centerX : `${localX - radius}px`;
+  const y = value.center ? centerY : `${localY - radius}px`;
+  return {
+    radius,
+    scale,
+    x,
+    y,
+    centerX,
+    centerY
+  };
+};
+var ripples = {
+  /* eslint-disable max-statements */
+  show(e, el) {
+    var _a;
+    let value = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+    if (!((_a = el == null ? void 0 : el._ripple) == null ? void 0 : _a.enabled)) {
+      return;
+    }
+    const container = document.createElement("span");
+    const animation = document.createElement("span");
+    container.appendChild(animation);
+    container.className = "v-ripple__container";
+    if (value.class) {
+      container.className += ` ${value.class}`;
+    }
+    const {
+      radius,
+      scale,
+      x,
+      y,
+      centerX,
+      centerY
+    } = calculate(e, el, value);
+    const size = `${radius * 2}px`;
+    animation.className = "v-ripple__animation";
+    animation.style.width = size;
+    animation.style.height = size;
+    el.appendChild(container);
+    const computed = window.getComputedStyle(el);
+    if (computed && computed.position === "static") {
+      el.style.position = "relative";
+      el.dataset.previousPosition = "static";
+    }
+    animation.classList.add("v-ripple__animation--enter");
+    animation.classList.add("v-ripple__animation--visible");
+    transform(animation, `translate(${x}, ${y}) scale3d(${scale},${scale},${scale})`);
+    animation.dataset.activated = String(performance.now());
+    setTimeout(() => {
+      animation.classList.remove("v-ripple__animation--enter");
+      animation.classList.add("v-ripple__animation--in");
+      transform(animation, `translate(${centerX}, ${centerY}) scale3d(1,1,1)`);
+    }, 0);
+  },
+  hide(el) {
+    var _a;
+    if (!((_a = el == null ? void 0 : el._ripple) == null ? void 0 : _a.enabled)) return;
+    const ripples2 = el.getElementsByClassName("v-ripple__animation");
+    if (ripples2.length === 0) return;
+    const animation = ripples2[ripples2.length - 1];
+    if (animation.dataset.isHiding) return;
+    else animation.dataset.isHiding = "true";
+    const diff = performance.now() - Number(animation.dataset.activated);
+    const delay = Math.max(250 - diff, 0);
+    setTimeout(() => {
+      animation.classList.remove("v-ripple__animation--in");
+      animation.classList.add("v-ripple__animation--out");
+      setTimeout(() => {
+        var _a2;
+        const ripples3 = el.getElementsByClassName("v-ripple__animation");
+        if (ripples3.length === 1 && el.dataset.previousPosition) {
+          el.style.position = el.dataset.previousPosition;
+          delete el.dataset.previousPosition;
+        }
+        if (((_a2 = animation.parentNode) == null ? void 0 : _a2.parentNode) === el) el.removeChild(animation.parentNode);
+      }, 300);
+    }, delay);
+  }
+};
+function isRippleEnabled(value) {
+  return typeof value === "undefined" || !!value;
+}
+function rippleShow(e) {
+  const value = {};
+  const element = e.currentTarget;
+  if (!(element == null ? void 0 : element._ripple) || element._ripple.touched || e[stopSymbol]) return;
+  e[stopSymbol] = true;
+  if (isTouchEvent(e)) {
+    element._ripple.touched = true;
+    element._ripple.isTouch = true;
+  } else {
+    if (element._ripple.isTouch) return;
+  }
+  value.center = element._ripple.centered || isKeyboardEvent(e);
+  if (element._ripple.class) {
+    value.class = element._ripple.class;
+  }
+  if (isTouchEvent(e)) {
+    if (element._ripple.showTimerCommit) return;
+    element._ripple.showTimerCommit = () => {
+      ripples.show(e, element, value);
+    };
+    element._ripple.showTimer = window.setTimeout(() => {
+      var _a;
+      if ((_a = element == null ? void 0 : element._ripple) == null ? void 0 : _a.showTimerCommit) {
+        element._ripple.showTimerCommit();
+        element._ripple.showTimerCommit = null;
+      }
+    }, DELAY_RIPPLE);
+  } else {
+    ripples.show(e, element, value);
+  }
+}
+function rippleStop(e) {
+  e[stopSymbol] = true;
+}
+function rippleHide(e) {
+  const element = e.currentTarget;
+  if (!(element == null ? void 0 : element._ripple)) return;
+  window.clearTimeout(element._ripple.showTimer);
+  if (e.type === "touchend" && element._ripple.showTimerCommit) {
+    element._ripple.showTimerCommit();
+    element._ripple.showTimerCommit = null;
+    element._ripple.showTimer = window.setTimeout(() => {
+      rippleHide(e);
+    });
+    return;
+  }
+  window.setTimeout(() => {
+    if (element._ripple) {
+      element._ripple.touched = false;
+    }
+  });
+  ripples.hide(element);
+}
+function rippleCancelShow(e) {
+  const element = e.currentTarget;
+  if (!(element == null ? void 0 : element._ripple)) return;
+  if (element._ripple.showTimerCommit) {
+    element._ripple.showTimerCommit = null;
+  }
+  window.clearTimeout(element._ripple.showTimer);
+}
+var keyboardRipple = false;
+function keyboardRippleShow(e) {
+  if (!keyboardRipple && (e.keyCode === keyCodes.enter || e.keyCode === keyCodes.space)) {
+    keyboardRipple = true;
+    rippleShow(e);
+  }
+}
+function keyboardRippleHide(e) {
+  keyboardRipple = false;
+  rippleHide(e);
+}
+function focusRippleHide(e) {
+  if (keyboardRipple) {
+    keyboardRipple = false;
+    rippleHide(e);
+  }
+}
+function updateRipple(el, binding, wasEnabled) {
+  const {
+    value,
+    modifiers
+  } = binding;
+  const enabled = isRippleEnabled(value);
+  if (!enabled) {
+    ripples.hide(el);
+  }
+  el._ripple = el._ripple ?? {};
+  el._ripple.enabled = enabled;
+  el._ripple.centered = modifiers.center;
+  el._ripple.circle = modifiers.circle;
+  if (isObject(value) && value.class) {
+    el._ripple.class = value.class;
+  }
+  if (enabled && !wasEnabled) {
+    if (modifiers.stop) {
+      el.addEventListener("touchstart", rippleStop, {
+        passive: true
+      });
+      el.addEventListener("mousedown", rippleStop);
+      return;
+    }
+    el.addEventListener("touchstart", rippleShow, {
+      passive: true
+    });
+    el.addEventListener("touchend", rippleHide, {
+      passive: true
+    });
+    el.addEventListener("touchmove", rippleCancelShow, {
+      passive: true
+    });
+    el.addEventListener("touchcancel", rippleHide);
+    el.addEventListener("mousedown", rippleShow);
+    el.addEventListener("mouseup", rippleHide);
+    el.addEventListener("mouseleave", rippleHide);
+    el.addEventListener("keydown", keyboardRippleShow);
+    el.addEventListener("keyup", keyboardRippleHide);
+    el.addEventListener("blur", focusRippleHide);
+    el.addEventListener("dragstart", rippleHide, {
+      passive: true
+    });
+  } else if (!enabled && wasEnabled) {
+    removeListeners(el);
+  }
+}
+function removeListeners(el) {
+  el.removeEventListener("mousedown", rippleShow);
+  el.removeEventListener("touchstart", rippleShow);
+  el.removeEventListener("touchend", rippleHide);
+  el.removeEventListener("touchmove", rippleCancelShow);
+  el.removeEventListener("touchcancel", rippleHide);
+  el.removeEventListener("mouseup", rippleHide);
+  el.removeEventListener("mouseleave", rippleHide);
+  el.removeEventListener("keydown", keyboardRippleShow);
+  el.removeEventListener("keyup", keyboardRippleHide);
+  el.removeEventListener("dragstart", rippleHide);
+  el.removeEventListener("blur", focusRippleHide);
+}
+function mounted(el, binding) {
+  updateRipple(el, binding, false);
+}
+function unmounted(el) {
+  delete el._ripple;
+  removeListeners(el);
+}
+function updated(el, binding) {
+  if (binding.value === binding.oldValue) {
+    return;
+  }
+  const wasEnabled = isRippleEnabled(binding.oldValue);
+  updateRipple(el, binding, wasEnabled);
+}
+var Ripple = {
+  mounted,
+  unmounted,
+  updated
+};
+var ripple_default = Ripple;
+
+export {
+  Ripple,
+  ripple_default
+};
+//# sourceMappingURL=chunk-NMCVREUK.js.map

VApp/node_modules/.vite/deps/chunk-NUVQUA75.js

@@ -0,0 +1,73 @@
+import {
+  useTextColor
+} from "./chunk-ZZ55KHRR.js";
+import {
+  makeThemeProps,
+  provideTheme
+} from "./chunk-CYOEVGGH.js";
+import {
+  convertToUnit,
+  genericComponent,
+  makeComponentProps,
+  propsFactory,
+  useRender
+} from "./chunk-I4KGD5X4.js";
+import {
+  computed,
+  createVNode,
+  toRef
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/components/VDivider/VDivider.mjs
+import "C:/Users/Jeremy/Documents/Dev/Projects.cloudsucks.net/Vulture/VApp/node_modules/vuetify/lib/components/VDivider/VDivider.css";
+var makeVDividerProps = propsFactory({
+  color: String,
+  inset: Boolean,
+  length: [Number, String],
+  thickness: [Number, String],
+  vertical: Boolean,
+  ...makeComponentProps(),
+  ...makeThemeProps()
+}, "VDivider");
+var VDivider = genericComponent()({
+  name: "VDivider",
+  props: makeVDividerProps(),
+  setup(props, _ref) {
+    let {
+      attrs
+    } = _ref;
+    const {
+      themeClasses
+    } = provideTheme(props);
+    const {
+      textColorClasses,
+      textColorStyles
+    } = useTextColor(toRef(props, "color"));
+    const dividerStyles = computed(() => {
+      const styles = {};
+      if (props.length) {
+        styles[props.vertical ? "maxHeight" : "maxWidth"] = convertToUnit(props.length);
+      }
+      if (props.thickness) {
+        styles[props.vertical ? "borderRightWidth" : "borderTopWidth"] = convertToUnit(props.thickness);
+      }
+      return styles;
+    });
+    useRender(() => createVNode("hr", {
+      "class": [{
+        "v-divider": true,
+        "v-divider--inset": props.inset,
+        "v-divider--vertical": props.vertical
+      }, themeClasses.value, textColorClasses.value, props.class],
+      "style": [dividerStyles.value, textColorStyles.value, props.style],
+      "aria-orientation": !attrs.role || attrs.role === "separator" ? props.vertical ? "vertical" : "horizontal" : void 0,
+      "role": `${attrs.role || "separator"}`
+    }, null));
+    return {};
+  }
+});
+
+export {
+  VDivider
+};
+//# sourceMappingURL=chunk-NUVQUA75.js.map

VApp/node_modules/.vite/deps/chunk-NUVQUA75.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../vuetify/src/components/VDivider/VDivider.tsx"],
+  "sourcesContent": ["// Styles\nimport './VDivider.sass'\n\n// Composables\nimport { useTextColor } from '@/composables/color'\nimport { makeComponentProps } from '@/composables/component'\nimport { makeThemeProps, provideTheme } from '@/composables/theme'\n\n// Utilities\nimport { computed, toRef } from 'vue'\nimport { convertToUnit, genericComponent, propsFactory, useRender } from '@/util'\n\ntype DividerKey = 'borderRightWidth' | 'borderTopWidth' | 'maxHeight' | 'maxWidth'\ntype DividerStyles = Partial<Record<DividerKey, string>>\n\nexport const makeVDividerProps = propsFactory({\n  color: String,\n  inset: Boolean,\n  length: [Number, String],\n  thickness: [Number, String],\n  vertical: Boolean,\n\n  ...makeComponentProps(),\n  ...makeThemeProps(),\n}, 'VDivider')\n\nexport const VDivider = genericComponent()({\n  name: 'VDivider',\n\n  props: makeVDividerProps(),\n\n  setup (props, { attrs }) {\n    const { themeClasses } = provideTheme(props)\n    const { textColorClasses, textColorStyles } = useTextColor(toRef(props, 'color'))\n    const dividerStyles = computed(() => {\n      const styles: DividerStyles = {}\n\n      if (props.length) {\n        styles[props.vertical ? 'maxHeight' : 'maxWidth'] = convertToUnit(props.length)\n      }\n\n      if (props.thickness) {\n        styles[props.vertical ? 'borderRightWidth' : 'borderTopWidth'] = convertToUnit(props.thickness)\n      }\n\n      return styles\n    })\n\n    useRender(() => (\n      <hr\n        class={[\n          {\n            'v-divider': true,\n            'v-divider--inset': props.inset,\n            'v-divider--vertical': props.vertical,\n          },\n          themeClasses.value,\n          textColorClasses.value,\n          props.class,\n        ]}\n        style={[\n          dividerStyles.value,\n          textColorStyles.value,\n          props.style,\n        ]}\n        aria-orientation={\n          !attrs.role || attrs.role === 'separator'\n            ? props.vertical ? 'vertical' : 'horizontal'\n            : undefined\n        }\n        role={ `${attrs.role || 'separator'}` }\n      />\n    ))\n\n    return {}\n  },\n})\n\nexport type VDivider = InstanceType<typeof VDivider>\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;AACA,OAAA;AAcO,IAAMA,oBAAoBC,aAAa;EAC5CC,OAAOC;EACPC,OAAOC;EACPC,QAAQ,CAACC,QAAQJ,MAAM;EACvBK,WAAW,CAACD,QAAQJ,MAAM;EAC1BM,UAAUJ;EAEV,GAAGK,mBAAmB;EACtB,GAAGC,eAAe;AACpB,GAAG,UAAU;AAEN,IAAMC,WAAWC,iBAAiB,EAAE;EACzCC,MAAM;EAENC,OAAOf,kBAAkB;EAEzBgB,MAAOD,OAAKE,MAAa;AAAA,QAAX;MAAEC;IAAM,IAACD;AACrB,UAAM;MAAEE;IAAa,IAAIC,aAAaL,KAAK;AAC3C,UAAM;MAAEM;MAAkBC;IAAgB,IAAIC,aAAaC,MAAMT,OAAO,OAAO,CAAC;AAChF,UAAMU,gBAAgBC,SAAS,MAAM;AACnC,YAAMC,SAAwB,CAAC;AAE/B,UAAIZ,MAAMT,QAAQ;AAChBqB,eAAOZ,MAAMN,WAAW,cAAc,UAAU,IAAImB,cAAcb,MAAMT,MAAM;MAChF;AAEA,UAAIS,MAAMP,WAAW;AACnBmB,eAAOZ,MAAMN,WAAW,qBAAqB,gBAAgB,IAAImB,cAAcb,MAAMP,SAAS;MAChG;AAEA,aAAOmB;IACT,CAAC;AAEDE,cAAU,MAAAC,YAAA,MAAA;MAAA,SAEC,CACL;QACE,aAAa;QACb,oBAAoBf,MAAMX;QAC1B,uBAAuBW,MAAMN;MAC/B,GACAU,aAAaY,OACbV,iBAAiBU,OACjBhB,MAAMiB,KAAK;MACZ,SACM,CACLP,cAAcM,OACdT,gBAAgBS,OAChBhB,MAAMkB,KAAK;MACZ,oBAEC,CAACf,MAAMgB,QAAQhB,MAAMgB,SAAS,cAC1BnB,MAAMN,WAAW,aAAa,eAC9B0B;MAAS,QAEP,GAAEjB,MAAMgB,QAAQ,WAAY;IAAC,GAAA,IAAA,CAExC;AAED,WAAO,CAAC;EACV;AACF,CAAC;",
+  "names": ["makeVDividerProps", "propsFactory", "color", "String", "inset", "Boolean", "length", "Number", "thickness", "vertical", "makeComponentProps", "makeThemeProps", "VDivider", "genericComponent", "name", "props", "setup", "_ref", "attrs", "themeClasses", "provideTheme", "textColorClasses", "textColorStyles", "useTextColor", "toRef", "dividerStyles", "computed", "styles", "convertToUnit", "useRender", "_createVNode", "value", "class", "style", "role", "undefined"]
+}

VApp/node_modules/.vite/deps/chunk-O5EKZW2J.js

@@ -0,0 +1,166 @@
+import {
+  IN_BROWSER,
+  SUPPORTS_TOUCH,
+  getCurrentInstanceName,
+  mergeDeep,
+  propsFactory
+} from "./chunk-I4KGD5X4.js";
+import {
+  computed,
+  inject,
+  reactive,
+  shallowRef,
+  toRefs,
+  watchEffect
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/composables/display.mjs
+var breakpoints = ["sm", "md", "lg", "xl", "xxl"];
+var DisplaySymbol = Symbol.for("vuetify:display");
+var defaultDisplayOptions = {
+  mobileBreakpoint: "lg",
+  thresholds: {
+    xs: 0,
+    sm: 600,
+    md: 960,
+    lg: 1280,
+    xl: 1920,
+    xxl: 2560
+  }
+};
+var parseDisplayOptions = function() {
+  let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : defaultDisplayOptions;
+  return mergeDeep(defaultDisplayOptions, options);
+};
+function getClientWidth(ssr) {
+  return IN_BROWSER && !ssr ? window.innerWidth : typeof ssr === "object" && ssr.clientWidth || 0;
+}
+function getClientHeight(ssr) {
+  return IN_BROWSER && !ssr ? window.innerHeight : typeof ssr === "object" && ssr.clientHeight || 0;
+}
+function getPlatform(ssr) {
+  const userAgent = IN_BROWSER && !ssr ? window.navigator.userAgent : "ssr";
+  function match(regexp) {
+    return Boolean(userAgent.match(regexp));
+  }
+  const android = match(/android/i);
+  const ios = match(/iphone|ipad|ipod/i);
+  const cordova = match(/cordova/i);
+  const electron = match(/electron/i);
+  const chrome = match(/chrome/i);
+  const edge = match(/edge/i);
+  const firefox = match(/firefox/i);
+  const opera = match(/opera/i);
+  const win = match(/win/i);
+  const mac = match(/mac/i);
+  const linux = match(/linux/i);
+  return {
+    android,
+    ios,
+    cordova,
+    electron,
+    chrome,
+    edge,
+    firefox,
+    opera,
+    win,
+    mac,
+    linux,
+    touch: SUPPORTS_TOUCH,
+    ssr: userAgent === "ssr"
+  };
+}
+function createDisplay(options, ssr) {
+  const {
+    thresholds,
+    mobileBreakpoint
+  } = parseDisplayOptions(options);
+  const height = shallowRef(getClientHeight(ssr));
+  const platform = shallowRef(getPlatform(ssr));
+  const state = reactive({});
+  const width = shallowRef(getClientWidth(ssr));
+  function updateSize() {
+    height.value = getClientHeight();
+    width.value = getClientWidth();
+  }
+  function update() {
+    updateSize();
+    platform.value = getPlatform();
+  }
+  watchEffect(() => {
+    const xs = width.value < thresholds.sm;
+    const sm = width.value < thresholds.md && !xs;
+    const md = width.value < thresholds.lg && !(sm || xs);
+    const lg = width.value < thresholds.xl && !(md || sm || xs);
+    const xl = width.value < thresholds.xxl && !(lg || md || sm || xs);
+    const xxl = width.value >= thresholds.xxl;
+    const name = xs ? "xs" : sm ? "sm" : md ? "md" : lg ? "lg" : xl ? "xl" : "xxl";
+    const breakpointValue = typeof mobileBreakpoint === "number" ? mobileBreakpoint : thresholds[mobileBreakpoint];
+    const mobile = width.value < breakpointValue;
+    state.xs = xs;
+    state.sm = sm;
+    state.md = md;
+    state.lg = lg;
+    state.xl = xl;
+    state.xxl = xxl;
+    state.smAndUp = !xs;
+    state.mdAndUp = !(xs || sm);
+    state.lgAndUp = !(xs || sm || md);
+    state.xlAndUp = !(xs || sm || md || lg);
+    state.smAndDown = !(md || lg || xl || xxl);
+    state.mdAndDown = !(lg || xl || xxl);
+    state.lgAndDown = !(xl || xxl);
+    state.xlAndDown = !xxl;
+    state.name = name;
+    state.height = height.value;
+    state.width = width.value;
+    state.mobile = mobile;
+    state.mobileBreakpoint = mobileBreakpoint;
+    state.platform = platform.value;
+    state.thresholds = thresholds;
+  });
+  if (IN_BROWSER) {
+    window.addEventListener("resize", updateSize, {
+      passive: true
+    });
+  }
+  return {
+    ...toRefs(state),
+    update,
+    ssr: !!ssr
+  };
+}
+var makeDisplayProps = propsFactory({
+  mobileBreakpoint: [Number, String]
+}, "display");
+function useDisplay() {
+  let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+  let name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : getCurrentInstanceName();
+  const display = inject(DisplaySymbol);
+  if (!display) throw new Error("Could not find Vuetify display injection");
+  const mobile = computed(() => {
+    if (!props.mobileBreakpoint) return display.mobile.value;
+    const breakpointValue = typeof props.mobileBreakpoint === "number" ? props.mobileBreakpoint : display.thresholds.value[props.mobileBreakpoint];
+    return display.width.value < breakpointValue;
+  });
+  const displayClasses = computed(() => {
+    if (!name) return {};
+    return {
+      [`${name}--mobile`]: mobile.value
+    };
+  });
+  return {
+    ...display,
+    displayClasses,
+    mobile
+  };
+}
+
+export {
+  breakpoints,
+  DisplaySymbol,
+  createDisplay,
+  makeDisplayProps,
+  useDisplay
+};
+//# sourceMappingURL=chunk-O5EKZW2J.js.map

VApp/node_modules/.vite/deps/chunk-O7EUYO3B.js

@@ -0,0 +1,36 @@
+import {
+  convertToUnit,
+  propsFactory
+} from "./chunk-I4KGD5X4.js";
+import {
+  computed
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/composables/dimensions.mjs
+var makeDimensionProps = propsFactory({
+  height: [Number, String],
+  maxHeight: [Number, String],
+  maxWidth: [Number, String],
+  minHeight: [Number, String],
+  minWidth: [Number, String],
+  width: [Number, String]
+}, "dimension");
+function useDimension(props) {
+  const dimensionStyles = computed(() => ({
+    height: convertToUnit(props.height),
+    maxHeight: convertToUnit(props.maxHeight),
+    maxWidth: convertToUnit(props.maxWidth),
+    minHeight: convertToUnit(props.minHeight),
+    minWidth: convertToUnit(props.minWidth),
+    width: convertToUnit(props.width)
+  }));
+  return {
+    dimensionStyles
+  };
+}
+
+export {
+  makeDimensionProps,
+  useDimension
+};
+//# sourceMappingURL=chunk-O7EUYO3B.js.map

VApp/node_modules/.vite/deps/chunk-O7EUYO3B.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../vuetify/src/composables/dimensions.ts"],
+  "sourcesContent": ["// Utilities\nimport { computed } from 'vue'\nimport { convertToUnit, propsFactory } from '@/util'\n\n// Types\nexport interface DimensionProps {\n  height?: number | string\n  maxHeight?: number | string\n  maxWidth?: number | string\n  minHeight?: number | string\n  minWidth?: number | string\n  width?: number | string\n}\n\n// Composables\nexport const makeDimensionProps = propsFactory({\n  height: [Number, String],\n  maxHeight: [Number, String],\n  maxWidth: [Number, String],\n  minHeight: [Number, String],\n  minWidth: [Number, String],\n  width: [Number, String],\n}, 'dimension')\n\nexport function useDimension (props: DimensionProps) {\n  const dimensionStyles = computed(() => ({\n    height: convertToUnit(props.height),\n    maxHeight: convertToUnit(props.maxHeight),\n    maxWidth: convertToUnit(props.maxWidth),\n    minHeight: convertToUnit(props.minHeight),\n    minWidth: convertToUnit(props.minWidth),\n    width: convertToUnit(props.width),\n  }))\n\n  return { dimensionStyles }\n}\n"],
+  "mappings": ";;;;;;;;;AAeO,IAAMA,qBAAqBC,aAAa;EAC7CC,QAAQ,CAACC,QAAQC,MAAM;EACvBC,WAAW,CAACF,QAAQC,MAAM;EAC1BE,UAAU,CAACH,QAAQC,MAAM;EACzBG,WAAW,CAACJ,QAAQC,MAAM;EAC1BI,UAAU,CAACL,QAAQC,MAAM;EACzBK,OAAO,CAACN,QAAQC,MAAM;AACxB,GAAG,WAAW;AAEP,SAASM,aAAcC,OAAuB;AACnD,QAAMC,kBAAkBC,SAAS,OAAO;IACtCX,QAAQY,cAAcH,MAAMT,MAAM;IAClCG,WAAWS,cAAcH,MAAMN,SAAS;IACxCC,UAAUQ,cAAcH,MAAML,QAAQ;IACtCC,WAAWO,cAAcH,MAAMJ,SAAS;IACxCC,UAAUM,cAAcH,MAAMH,QAAQ;IACtCC,OAAOK,cAAcH,MAAMF,KAAK;EAClC,EAAE;AAEF,SAAO;IAAEG;EAAgB;AAC3B;",
+  "names": ["makeDimensionProps", "propsFactory", "height", "Number", "String", "maxHeight", "maxWidth", "minHeight", "minWidth", "width", "useDimension", "props", "dimensionStyles", "computed", "convertToUnit"]
+}

VApp/node_modules/.vite/deps/chunk-O7K6SSRF.js

@@ -0,0 +1,37 @@
+import {
+  getCurrentInstanceName,
+  propsFactory
+} from "./chunk-I4KGD5X4.js";
+import {
+  computed,
+  isRef
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/composables/border.mjs
+var makeBorderProps = propsFactory({
+  border: [Boolean, Number, String]
+}, "border");
+function useBorder(props) {
+  let name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : getCurrentInstanceName();
+  const borderClasses = computed(() => {
+    const border = isRef(props) ? props.value : props.border;
+    const classes = [];
+    if (border === true || border === "") {
+      classes.push(`${name}--border`);
+    } else if (typeof border === "string" || border === 0) {
+      for (const value of String(border).split(" ")) {
+        classes.push(`border-${value}`);
+      }
+    }
+    return classes;
+  });
+  return {
+    borderClasses
+  };
+}
+
+export {
+  makeBorderProps,
+  useBorder
+};
+//# sourceMappingURL=chunk-O7K6SSRF.js.map

VApp/node_modules/.vite/deps/chunk-O7K6SSRF.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../vuetify/src/composables/border.ts"],
+  "sourcesContent": ["// Utilities\nimport { computed, isRef } from 'vue'\nimport { getCurrentInstanceName, propsFactory } from '@/util'\n\n// Types\nexport interface BorderProps {\n  border?: boolean | number | string\n}\n\n// Composables\nexport const makeBorderProps = propsFactory({\n  border: [Boolean, Number, String],\n}, 'border')\n\nexport function useBorder (\n  props: BorderProps,\n  name = getCurrentInstanceName(),\n) {\n  const borderClasses = computed(() => {\n    const border = isRef(props) ? props.value : props.border\n    const classes: string[] = []\n\n    if (border === true || border === '') {\n      classes.push(`${name}--border`)\n    } else if (\n      typeof border === 'string' ||\n      border === 0\n    ) {\n      for (const value of String(border).split(' ')) {\n        classes.push(`border-${value}`)\n      }\n    }\n\n    return classes\n  })\n\n  return { borderClasses }\n}\n"],
+  "mappings": ";;;;;;;;;;AAUO,IAAMA,kBAAkBC,aAAa;EAC1CC,QAAQ,CAACC,SAASC,QAAQC,MAAM;AAClC,GAAG,QAAQ;AAEJ,SAASC,UACdC,OAEA;AAAA,MADAC,OAAIC,UAAAC,SAAA,KAAAD,UAAA,CAAA,MAAAE,SAAAF,UAAA,CAAA,IAAGG,uBAAuB;AAE9B,QAAMC,gBAAgBC,SAAS,MAAM;AACnC,UAAMZ,SAASa,MAAMR,KAAK,IAAIA,MAAMS,QAAQT,MAAML;AAClD,UAAMe,UAAoB,CAAA;AAE1B,QAAIf,WAAW,QAAQA,WAAW,IAAI;AACpCe,cAAQC,KAAM,GAAEV,IAAK,UAAS;IAChC,WACE,OAAON,WAAW,YAClBA,WAAW,GACX;AACA,iBAAWc,SAASX,OAAOH,MAAM,EAAEiB,MAAM,GAAG,GAAG;AAC7CF,gBAAQC,KAAM,UAASF,KAAM,EAAC;MAChC;IACF;AAEA,WAAOC;EACT,CAAC;AAED,SAAO;IAAEJ;EAAc;AACzB;",
+  "names": ["makeBorderProps", "propsFactory", "border", "Boolean", "Number", "String", "useBorder", "props", "name", "arguments", "length", "undefined", "getCurrentInstanceName", "borderClasses", "computed", "isRef", "value", "classes", "push", "split"]
+}

VApp/node_modules/.vite/deps/chunk-PCNFKUUR.js

@@ -0,0 +1,103 @@
+import {
+  IN_BROWSER,
+  deepEqual,
+  getCurrentInstance,
+  hasEvent,
+  propsFactory
+} from "./chunk-I4KGD5X4.js";
+import {
+  computed,
+  nextTick,
+  onScopeDispose,
+  resolveDynamicComponent,
+  toRef
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/composables/router.mjs
+function useRoute() {
+  const vm = getCurrentInstance("useRoute");
+  return computed(() => {
+    var _a;
+    return (_a = vm == null ? void 0 : vm.proxy) == null ? void 0 : _a.$route;
+  });
+}
+function useRouter() {
+  var _a, _b;
+  return (_b = (_a = getCurrentInstance("useRouter")) == null ? void 0 : _a.proxy) == null ? void 0 : _b.$router;
+}
+function useLink(props, attrs) {
+  const RouterLink = resolveDynamicComponent("RouterLink");
+  const isLink = computed(() => !!(props.href || props.to));
+  const isClickable = computed(() => {
+    return (isLink == null ? void 0 : isLink.value) || hasEvent(attrs, "click") || hasEvent(props, "click");
+  });
+  if (typeof RouterLink === "string") {
+    return {
+      isLink,
+      isClickable,
+      href: toRef(props, "href")
+    };
+  }
+  const link = props.to ? RouterLink.useLink(props) : void 0;
+  const route = useRoute();
+  return {
+    isLink,
+    isClickable,
+    route: link == null ? void 0 : link.route,
+    navigate: link == null ? void 0 : link.navigate,
+    isActive: link && computed(() => {
+      var _a, _b, _c;
+      if (!props.exact) return (_a = link.isActive) == null ? void 0 : _a.value;
+      if (!route.value) return (_b = link.isExactActive) == null ? void 0 : _b.value;
+      return ((_c = link.isExactActive) == null ? void 0 : _c.value) && deepEqual(link.route.value.query, route.value.query);
+    }),
+    href: computed(() => props.to ? link == null ? void 0 : link.route.value.href : props.href)
+  };
+}
+var makeRouterProps = propsFactory({
+  href: String,
+  replace: Boolean,
+  to: [String, Object],
+  exact: Boolean
+}, "router");
+var inTransition = false;
+function useBackButton(router, cb) {
+  let popped = false;
+  let removeBefore;
+  let removeAfter;
+  if (IN_BROWSER) {
+    nextTick(() => {
+      window.addEventListener("popstate", onPopstate);
+      removeBefore = router == null ? void 0 : router.beforeEach((to, from, next) => {
+        if (!inTransition) {
+          setTimeout(() => popped ? cb(next) : next());
+        } else {
+          popped ? cb(next) : next();
+        }
+        inTransition = true;
+      });
+      removeAfter = router == null ? void 0 : router.afterEach(() => {
+        inTransition = false;
+      });
+    });
+    onScopeDispose(() => {
+      window.removeEventListener("popstate", onPopstate);
+      removeBefore == null ? void 0 : removeBefore();
+      removeAfter == null ? void 0 : removeAfter();
+    });
+  }
+  function onPopstate(e) {
+    var _a;
+    if ((_a = e.state) == null ? void 0 : _a.replaced) return;
+    popped = true;
+    setTimeout(() => popped = false);
+  }
+}
+
+export {
+  useRouter,
+  useLink,
+  makeRouterProps,
+  useBackButton
+};
+//# sourceMappingURL=chunk-PCNFKUUR.js.map

VApp/node_modules/.vite/deps/chunk-PCNFKUUR.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../vuetify/src/composables/router.tsx"],
+  "sourcesContent": ["// Utilities\nimport {\n  computed,\n  nextTick,\n  onScopeDispose,\n  resolveDynamicComponent,\n  toRef,\n} from 'vue'\nimport { deepEqual, getCurrentInstance, hasEvent, IN_BROWSER, propsFactory } from '@/util'\n\n// Types\nimport type { ComputedRef, PropType, Ref, SetupContext } from 'vue'\nimport type {\n  RouterLink as _RouterLink,\n  useLink as _useLink,\n  NavigationGuardNext,\n  RouteLocationNormalizedLoaded,\n  RouteLocationRaw,\n  Router,\n  UseLinkOptions,\n} from 'vue-router'\nimport type { EventProp } from '@/util'\n\nexport function useRoute (): Ref<RouteLocationNormalizedLoaded | undefined> {\n  const vm = getCurrentInstance('useRoute')\n\n  return computed(() => vm?.proxy?.$route)\n}\n\nexport function useRouter (): Router | undefined {\n  return getCurrentInstance('useRouter')?.proxy?.$router\n}\n\nexport interface LinkProps {\n  href: string | undefined\n  replace: boolean | undefined\n  to: RouteLocationRaw | undefined\n  exact: boolean | undefined\n}\n\nexport interface LinkListeners {\n  onClick?: EventProp | undefined\n  onClickOnce?: EventProp | undefined\n}\n\nexport interface UseLink extends Omit<Partial<ReturnType<typeof _useLink>>, 'href'> {\n  isLink: ComputedRef<boolean>\n  isClickable: ComputedRef<boolean>\n  href: Ref<string | undefined>\n}\n\nexport function useLink (props: LinkProps & LinkListeners, attrs: SetupContext['attrs']): UseLink {\n  const RouterLink = resolveDynamicComponent('RouterLink') as typeof _RouterLink | string\n\n  const isLink = computed(() => !!(props.href || props.to))\n  const isClickable = computed(() => {\n    return isLink?.value || hasEvent(attrs, 'click') || hasEvent(props, 'click')\n  })\n\n  if (typeof RouterLink === 'string') {\n    return {\n      isLink,\n      isClickable,\n      href: toRef(props, 'href'),\n    }\n  }\n\n  const link = props.to ? RouterLink.useLink(props as UseLinkOptions) : undefined\n  const route = useRoute()\n\n  return {\n    isLink,\n    isClickable,\n    route: link?.route,\n    navigate: link?.navigate,\n    isActive: link && computed(() => {\n      if (!props.exact) return link.isActive?.value\n      if (!route.value) return link.isExactActive?.value\n\n      return link.isExactActive?.value && deepEqual(link.route.value.query, route.value.query)\n    }),\n    href: computed(() => props.to ? link?.route.value.href : props.href),\n  }\n}\n\nexport const makeRouterProps = propsFactory({\n  href: String,\n  replace: Boolean,\n  to: [String, Object] as PropType<RouteLocationRaw>,\n  exact: Boolean,\n}, 'router')\n\nlet inTransition = false\nexport function useBackButton (router: Router | undefined, cb: (next: NavigationGuardNext) => void) {\n  let popped = false\n  let removeBefore: (() => void) | undefined\n  let removeAfter: (() => void) | undefined\n\n  if (IN_BROWSER) {\n    nextTick(() => {\n      window.addEventListener('popstate', onPopstate)\n      removeBefore = router?.beforeEach((to, from, next) => {\n        if (!inTransition) {\n          setTimeout(() => popped ? cb(next) : next())\n        } else {\n          popped ? cb(next) : next()\n        }\n        inTransition = true\n      })\n      removeAfter = router?.afterEach(() => {\n        inTransition = false\n      })\n    })\n    onScopeDispose(() => {\n      window.removeEventListener('popstate', onPopstate)\n      removeBefore?.()\n      removeAfter?.()\n    })\n  }\n\n  function onPopstate (e: PopStateEvent) {\n    if (e.state?.replaced) return\n\n    popped = true\n    setTimeout(() => (popped = false))\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;AAuBO,SAASA,WAA4D;AAC1E,QAAMC,KAAKC,mBAAmB,UAAU;AAExC,SAAOC,SAAS,MAAA;AA1BlB;AA0BwBF,0CAAIG,UAAJH,mBAAWI;GAAM;AACzC;AAEO,SAASC,YAAiC;AA7BjD;AA8BE,UAAOJ,8BAAmB,WAAW,MAA9BA,mBAAiCE,UAAjCF,mBAAwCK;AACjD;AAoBO,SAASC,QAASC,OAAkCC,OAAuC;AAChG,QAAMC,aAAaC,wBAAwB,YAAY;AAEvD,QAAMC,SAASV,SAAS,MAAM,CAAC,EAAEM,MAAMK,QAAQL,MAAMM,GAAG;AACxD,QAAMC,cAAcb,SAAS,MAAM;AACjC,YAAOU,iCAAQI,UAASC,SAASR,OAAO,OAAO,KAAKQ,SAAST,OAAO,OAAO;EAC7E,CAAC;AAED,MAAI,OAAOE,eAAe,UAAU;AAClC,WAAO;MACLE;MACAG;MACAF,MAAMK,MAAMV,OAAO,MAAM;IAC3B;EACF;AAEA,QAAMW,OAAOX,MAAMM,KAAKJ,WAAWH,QAAQC,KAAuB,IAAIY;AACtE,QAAMC,QAAQtB,SAAS;AAEvB,SAAO;IACLa;IACAG;IACAM,OAAOF,6BAAME;IACbC,UAAUH,6BAAMG;IAChBC,UAAUJ,QAAQjB,SAAS,MAAM;AA3ErC;AA4EM,UAAI,CAACM,MAAMgB,MAAO,SAAOL,UAAKI,aAALJ,mBAAeH;AACxC,UAAI,CAACK,MAAML,MAAO,SAAOG,UAAKM,kBAALN,mBAAoBH;AAE7C,eAAOG,UAAKM,kBAALN,mBAAoBH,UAASU,UAAUP,KAAKE,MAAML,MAAMW,OAAON,MAAML,MAAMW,KAAK;IACzF,CAAC;IACDd,MAAMX,SAAS,MAAMM,MAAMM,KAAKK,6BAAME,MAAML,MAAMH,OAAOL,MAAMK,IAAI;EACrE;AACF;AAEO,IAAMe,kBAAkBC,aAAa;EAC1ChB,MAAMiB;EACNC,SAASC;EACTlB,IAAI,CAACgB,QAAQG,MAAM;EACnBT,OAAOQ;AACT,GAAG,QAAQ;AAEX,IAAIE,eAAe;AACZ,SAASC,cAAeC,QAA4BC,IAAyC;AAClG,MAAIC,SAAS;AACb,MAAIC;AACJ,MAAIC;AAEJ,MAAIC,YAAY;AACdC,aAAS,MAAM;AACbC,aAAOC,iBAAiB,YAAYC,UAAU;AAC9CN,qBAAeH,iCAAQU,WAAW,CAAChC,IAAIiC,MAAMC,SAAS;AACpD,YAAI,CAACd,cAAc;AACjBe,qBAAW,MAAMX,SAASD,GAAGW,IAAI,IAAIA,KAAK,CAAC;QAC7C,OAAO;AACLV,mBAASD,GAAGW,IAAI,IAAIA,KAAK;QAC3B;AACAd,uBAAe;MACjB;AACAM,oBAAcJ,iCAAQc,UAAU,MAAM;AACpChB,uBAAe;MACjB;IACF,CAAC;AACDiB,mBAAe,MAAM;AACnBR,aAAOS,oBAAoB,YAAYP,UAAU;AACjDN;AACAC;IACF,CAAC;EACH;AAEA,WAASK,WAAYQ,GAAkB;AAxHzC;AAyHI,SAAIA,OAAEC,UAAFD,mBAASE,SAAU;AAEvBjB,aAAS;AACTW,eAAW,MAAOX,SAAS,KAAM;EACnC;AACF;",
+  "names": ["useRoute", "vm", "getCurrentInstance", "computed", "proxy", "$route", "useRouter", "$router", "useLink", "props", "attrs", "RouterLink", "resolveDynamicComponent", "isLink", "href", "to", "isClickable", "value", "hasEvent", "toRef", "link", "undefined", "route", "navigate", "isActive", "exact", "isExactActive", "deepEqual", "query", "makeRouterProps", "propsFactory", "String", "replace", "Boolean", "Object", "inTransition", "useBackButton", "router", "cb", "popped", "removeBefore", "removeAfter", "IN_BROWSER", "nextTick", "window", "addEventListener", "onPopstate", "beforeEach", "from", "next", "setTimeout", "afterEach", "onScopeDispose", "removeEventListener", "e", "state", "replaced"]
+}

VApp/node_modules/.vite/deps/chunk-PVQHDZXM.js

@@ -0,0 +1,86 @@
+import {
+  getCurrentInstance,
+  toKebabCase
+} from "./chunk-I4KGD5X4.js";
+import {
+  computed,
+  effectScope,
+  onScopeDispose,
+  ref,
+  toRaw,
+  watch
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/composables/toggleScope.mjs
+function useToggleScope(source, fn) {
+  let scope;
+  function start() {
+    scope = effectScope();
+    scope.run(() => fn.length ? fn(() => {
+      scope == null ? void 0 : scope.stop();
+      start();
+    }) : fn());
+  }
+  watch(source, (active) => {
+    if (active && !scope) {
+      start();
+    } else if (!active) {
+      scope == null ? void 0 : scope.stop();
+      scope = void 0;
+    }
+  }, {
+    immediate: true
+  });
+  onScopeDispose(() => {
+    scope == null ? void 0 : scope.stop();
+  });
+}
+
+// node_modules/vuetify/lib/composables/proxiedModel.mjs
+function useProxiedModel(props, prop, defaultValue) {
+  let transformIn = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : (v) => v;
+  let transformOut = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : (v) => v;
+  const vm = getCurrentInstance("useProxiedModel");
+  const internal = ref(props[prop] !== void 0 ? props[prop] : defaultValue);
+  const kebabProp = toKebabCase(prop);
+  const checkKebab = kebabProp !== prop;
+  const isControlled = checkKebab ? computed(() => {
+    var _a, _b, _c, _d;
+    void props[prop];
+    return !!((((_a = vm.vnode.props) == null ? void 0 : _a.hasOwnProperty(prop)) || ((_b = vm.vnode.props) == null ? void 0 : _b.hasOwnProperty(kebabProp))) && (((_c = vm.vnode.props) == null ? void 0 : _c.hasOwnProperty(`onUpdate:${prop}`)) || ((_d = vm.vnode.props) == null ? void 0 : _d.hasOwnProperty(`onUpdate:${kebabProp}`))));
+  }) : computed(() => {
+    var _a, _b;
+    void props[prop];
+    return !!(((_a = vm.vnode.props) == null ? void 0 : _a.hasOwnProperty(prop)) && ((_b = vm.vnode.props) == null ? void 0 : _b.hasOwnProperty(`onUpdate:${prop}`)));
+  });
+  useToggleScope(() => !isControlled.value, () => {
+    watch(() => props[prop], (val) => {
+      internal.value = val;
+    });
+  });
+  const model = computed({
+    get() {
+      const externalValue = props[prop];
+      return transformIn(isControlled.value ? externalValue : internal.value);
+    },
+    set(internalValue) {
+      const newValue = transformOut(internalValue);
+      const value = toRaw(isControlled.value ? props[prop] : internal.value);
+      if (value === newValue || transformIn(value) === internalValue) {
+        return;
+      }
+      internal.value = newValue;
+      vm == null ? void 0 : vm.emit(`update:${prop}`, newValue);
+    }
+  });
+  Object.defineProperty(model, "externalValue", {
+    get: () => isControlled.value ? props[prop] : internal.value
+  });
+  return model;
+}
+
+export {
+  useToggleScope,
+  useProxiedModel
+};
+//# sourceMappingURL=chunk-PVQHDZXM.js.map

VApp/node_modules/.vite/deps/chunk-PVQHDZXM.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../vuetify/src/composables/toggleScope.ts", "../../vuetify/src/composables/proxiedModel.ts"],
+  "sourcesContent": ["// Utilities\nimport { effectScope, onScopeDispose, watch } from 'vue'\n\n// Types\nimport type { EffectScope, WatchSource } from 'vue'\n\nexport function useToggleScope (source: WatchSource<boolean>, fn: (reset: () => void) => void) {\n  let scope: EffectScope | undefined\n  function start () {\n    scope = effectScope()\n    scope.run(() => fn.length\n      ? fn(() => { scope?.stop(); start() })\n      : (fn as any)()\n    )\n  }\n\n  watch(source, active => {\n    if (active && !scope) {\n      start()\n    } else if (!active) {\n      scope?.stop()\n      scope = undefined\n    }\n  }, { immediate: true })\n\n  onScopeDispose(() => {\n    scope?.stop()\n  })\n}\n", "// Composables\nimport { useToggleScope } from '@/composables/toggleScope'\n\n// Utilities\nimport { computed, ref, toRaw, watch } from 'vue'\nimport { getCurrentInstance, toKebabCase } from '@/util'\n\n// Types\nimport type { Ref } from 'vue'\nimport type { EventProp } from '@/util'\n\ntype InnerVal<T> = T extends any[] ? Readonly<T> : T\n\n// Composables\nexport function useProxiedModel<\n  Props extends object & { [key in Prop as `onUpdate:${Prop}`]: EventProp | undefined },\n  Prop extends Extract<keyof Props, string>,\n  Inner = Props[Prop],\n> (\n  props: Props,\n  prop: Prop,\n  defaultValue?: Props[Prop],\n  transformIn: (value?: Props[Prop]) => Inner = (v: any) => v,\n  transformOut: (value: Inner) => Props[Prop] = (v: any) => v,\n) {\n  const vm = getCurrentInstance('useProxiedModel')\n  const internal = ref(props[prop] !== undefined ? props[prop] : defaultValue) as Ref<Props[Prop]>\n  const kebabProp = toKebabCase(prop)\n  const checkKebab = kebabProp !== prop\n\n  const isControlled = checkKebab\n    ? computed(() => {\n      void props[prop]\n      return !!(\n        (vm.vnode.props?.hasOwnProperty(prop) || vm.vnode.props?.hasOwnProperty(kebabProp)) &&\n        (vm.vnode.props?.hasOwnProperty(`onUpdate:${prop}`) || vm.vnode.props?.hasOwnProperty(`onUpdate:${kebabProp}`))\n      )\n    })\n    : computed(() => {\n      void props[prop]\n      return !!(vm.vnode.props?.hasOwnProperty(prop) && vm.vnode.props?.hasOwnProperty(`onUpdate:${prop}`))\n    })\n\n  useToggleScope(() => !isControlled.value, () => {\n    watch(() => props[prop], val => {\n      internal.value = val\n    })\n  })\n\n  const model = computed({\n    get (): any {\n      const externalValue = props[prop]\n      return transformIn(isControlled.value ? externalValue : internal.value)\n    },\n    set (internalValue) {\n      const newValue = transformOut(internalValue)\n      const value = toRaw(isControlled.value ? props[prop] : internal.value)\n      if (value === newValue || transformIn(value) === internalValue) {\n        return\n      }\n      internal.value = newValue\n      vm?.emit(`update:${prop}`, newValue)\n    },\n  }) as any as Ref<InnerVal<Inner>> & { readonly externalValue: Props[Prop] }\n\n  Object.defineProperty(model, 'externalValue', {\n    get: () => isControlled.value ? props[prop] : internal.value,\n  })\n\n  return model\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;AAMO,SAASA,eAAgBC,QAA8BC,IAAiC;AAC7F,MAAIC;AACJ,WAASC,QAAS;AAChBD,YAAQE,YAAY;AACpBF,UAAMG,IAAI,MAAMJ,GAAGK,SACfL,GAAG,MAAM;AAAEC,qCAAOK;AAAQJ,YAAM;IAAE,CAAC,IAClCF,GAAW,CAChB;EACF;AAEAO,QAAMR,QAAQS,YAAU;AACtB,QAAIA,UAAU,CAACP,OAAO;AACpBC,YAAM;IACR,WAAW,CAACM,QAAQ;AAClBP,qCAAOK;AACPL,cAAQQ;IACV;EACF,GAAG;IAAEC,WAAW;EAAK,CAAC;AAEtBC,iBAAe,MAAM;AACnBV,mCAAOK;EACT,CAAC;AACH;;;ACdO,SAASM,gBAKdC,OACAC,MACAC,cAGA;AAAA,MAFAC,cAA2CC,UAAAC,SAAA,KAAAD,UAAA,CAAA,MAAAE,SAAAF,UAAA,CAAA,IAAIG,OAAWA;AAAC,MAC3DC,eAA2CJ,UAAAC,SAAA,KAAAD,UAAA,CAAA,MAAAE,SAAAF,UAAA,CAAA,IAAIG,OAAWA;AAE1D,QAAME,KAAKC,mBAAmB,iBAAiB;AAC/C,QAAMC,WAAWC,IAAIZ,MAAMC,IAAI,MAAMK,SAAYN,MAAMC,IAAI,IAAIC,YAAY;AAC3E,QAAMW,YAAYC,YAAYb,IAAI;AAClC,QAAMc,aAAaF,cAAcZ;AAEjC,QAAMe,eAAeD,aACjBE,SAAS,MAAM;AA/BrB;AAgCM,SAAKjB,MAAMC,IAAI;AACf,WAAO,CAAC,KACLQ,QAAGS,MAAMlB,UAATS,mBAAgBU,eAAelB,YAASQ,QAAGS,MAAMlB,UAATS,mBAAgBU,eAAeN,mBACvEJ,QAAGS,MAAMlB,UAATS,mBAAgBU,eAAgB,YAAWlB,IAAK,UAAMQ,QAAGS,MAAMlB,UAATS,mBAAgBU,eAAgB,YAAWN,SAAU;EAEhH,CAAC,IACCI,SAAS,MAAM;AAtCrB;AAuCM,SAAKjB,MAAMC,IAAI;AACf,WAAO,CAAC,IAAEQ,QAAGS,MAAMlB,UAATS,mBAAgBU,eAAelB,YAASQ,QAAGS,MAAMlB,UAATS,mBAAgBU,eAAgB,YAAWlB,IAAK;EACpG,CAAC;AAEHmB,iBAAe,MAAM,CAACJ,aAAaK,OAAO,MAAM;AAC9CC,UAAM,MAAMtB,MAAMC,IAAI,GAAGsB,SAAO;AAC9BZ,eAASU,QAAQE;IACnB,CAAC;EACH,CAAC;AAED,QAAMC,QAAQP,SAAS;IACrBQ,MAAY;AACV,YAAMC,gBAAgB1B,MAAMC,IAAI;AAChC,aAAOE,YAAYa,aAAaK,QAAQK,gBAAgBf,SAASU,KAAK;IACxE;IACAM,IAAKC,eAAe;AAClB,YAAMC,WAAWrB,aAAaoB,aAAa;AAC3C,YAAMP,QAAQS,MAAMd,aAAaK,QAAQrB,MAAMC,IAAI,IAAIU,SAASU,KAAK;AACrE,UAAIA,UAAUQ,YAAY1B,YAAYkB,KAAK,MAAMO,eAAe;AAC9D;MACF;AACAjB,eAASU,QAAQQ;AACjBpB,+BAAIsB,KAAM,UAAS9B,IAAK,IAAG4B;IAC7B;EACF,CAAC;AAEDG,SAAOC,eAAeT,OAAO,iBAAiB;IAC5CC,KAAKA,MAAMT,aAAaK,QAAQrB,MAAMC,IAAI,IAAIU,SAASU;EACzD,CAAC;AAED,SAAOG;AACT;",
+  "names": ["useToggleScope", "source", "fn", "scope", "start", "effectScope", "run", "length", "stop", "watch", "active", "undefined", "immediate", "onScopeDispose", "useProxiedModel", "props", "prop", "defaultValue", "transformIn", "arguments", "length", "undefined", "v", "transformOut", "vm", "getCurrentInstance", "internal", "ref", "kebabProp", "toKebabCase", "checkKebab", "isControlled", "computed", "vnode", "hasOwnProperty", "useToggleScope", "value", "watch", "val", "model", "get", "externalValue", "set", "internalValue", "newValue", "toRaw", "emit", "Object", "defineProperty"]
+}

VApp/node_modules/.vite/deps/chunk-QWN5BXRD.js

@@ -0,0 +1,55 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+
+export {
+  __commonJS,
+  __toESM,
+  __publicField,
+  __privateGet,
+  __privateAdd,
+  __privateSet,
+  __privateMethod,
+  __privateWrapper
+};
+//# sourceMappingURL=chunk-QWN5BXRD.js.map

VApp/node_modules/.vite/deps/chunk-QWN5BXRD.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

VApp/node_modules/.vite/deps/chunk-QXA6VMYU.js

@@ -0,0 +1,38 @@
+import {
+  propsFactory
+} from "./chunk-I4KGD5X4.js";
+import {
+  computed,
+  isRef
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/composables/elevation.mjs
+var makeElevationProps = propsFactory({
+  elevation: {
+    type: [Number, String],
+    validator(v) {
+      const value = parseInt(v);
+      return !isNaN(value) && value >= 0 && // Material Design has a maximum elevation of 24
+      // https://material.io/design/environment/elevation.html#default-elevations
+      value <= 24;
+    }
+  }
+}, "elevation");
+function useElevation(props) {
+  const elevationClasses = computed(() => {
+    const elevation = isRef(props) ? props.value : props.elevation;
+    const classes = [];
+    if (elevation == null) return classes;
+    classes.push(`elevation-${elevation}`);
+    return classes;
+  });
+  return {
+    elevationClasses
+  };
+}
+
+export {
+  makeElevationProps,
+  useElevation
+};
+//# sourceMappingURL=chunk-QXA6VMYU.js.map

VApp/node_modules/.vite/deps/chunk-QXA6VMYU.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../vuetify/src/composables/elevation.ts"],
+  "sourcesContent": ["// Utilities\nimport { computed, isRef } from 'vue'\nimport { propsFactory } from '@/util'\n\n// Types\nimport type { Ref } from 'vue'\nexport interface ElevationProps {\n  elevation?: number | string | null\n}\n\n// Composables\nexport const makeElevationProps = propsFactory({\n  elevation: {\n    type: [Number, String],\n    validator (v: any) {\n      const value = parseInt(v)\n\n      return (\n        !isNaN(value) &&\n        value >= 0 &&\n        // Material Design has a maximum elevation of 24\n        // https://material.io/design/environment/elevation.html#default-elevations\n        value <= 24\n      )\n    },\n  },\n}, 'elevation')\n\ntype ElevationData = {\n  elevationClasses: Ref<string[]>\n}\n\nexport function useElevation (props: ElevationProps | Ref<number | string | undefined>): ElevationData {\n  const elevationClasses = computed(() => {\n    const elevation = isRef(props) ? props.value : props.elevation\n    const classes: string[] = []\n\n    if (elevation == null) return classes\n\n    classes.push(`elevation-${elevation}`)\n\n    return classes\n  })\n\n  return { elevationClasses }\n}\n"],
+  "mappings": ";;;;;;;;;AAWO,IAAMA,qBAAqBC,aAAa;EAC7CC,WAAW;IACTC,MAAM,CAACC,QAAQC,MAAM;IACrBC,UAAWC,GAAQ;AACjB,YAAMC,QAAQC,SAASF,CAAC;AAExB,aACE,CAACG,MAAMF,KAAK,KACZA,SAAS;;MAGTA,SAAS;IAEb;EACF;AACF,GAAG,WAAW;AAMP,SAASG,aAAcC,OAAyE;AACrG,QAAMC,mBAAmBC,SAAS,MAAM;AACtC,UAAMZ,YAAYa,MAAMH,KAAK,IAAIA,MAAMJ,QAAQI,MAAMV;AACrD,UAAMc,UAAoB,CAAA;AAE1B,QAAId,aAAa,KAAM,QAAOc;AAE9BA,YAAQC,KAAM,aAAYf,SAAU,EAAC;AAErC,WAAOc;EACT,CAAC;AAED,SAAO;IAAEH;EAAiB;AAC5B;",
+  "names": ["makeElevationProps", "propsFactory", "elevation", "type", "Number", "String", "validator", "v", "value", "parseInt", "isNaN", "useElevation", "props", "elevationClasses", "computed", "isRef", "classes", "push"]
+}

VApp/node_modules/.vite/deps/chunk-VDFYLV2V.js

@@ -0,0 +1,28 @@
+import {
+  computed,
+  onMounted,
+  readonly,
+  shallowRef
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/composables/ssrBoot.mjs
+function useSsrBoot() {
+  const isBooted = shallowRef(false);
+  onMounted(() => {
+    window.requestAnimationFrame(() => {
+      isBooted.value = true;
+    });
+  });
+  const ssrBootStyles = computed(() => !isBooted.value ? {
+    transition: "none !important"
+  } : void 0);
+  return {
+    ssrBootStyles,
+    isBooted: readonly(isBooted)
+  };
+}
+
+export {
+  useSsrBoot
+};
+//# sourceMappingURL=chunk-VDFYLV2V.js.map

VApp/node_modules/.vite/deps/chunk-VDFYLV2V.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../vuetify/src/composables/ssrBoot.ts"],
+  "sourcesContent": ["// Utilities\nimport { computed, onMounted, readonly, shallowRef } from 'vue'\n\n// Composables\nexport function useSsrBoot () {\n  const isBooted = shallowRef(false)\n\n  onMounted(() => {\n    window.requestAnimationFrame(() => {\n      isBooted.value = true\n    })\n  })\n\n  const ssrBootStyles = computed(() => !isBooted.value ? ({\n    transition: 'none !important',\n  }) : undefined)\n\n  return { ssrBootStyles, isBooted: readonly(isBooted) }\n}\n"],
+  "mappings": ";;;;;;;;AAIO,SAASA,aAAc;AAC5B,QAAMC,WAAWC,WAAW,KAAK;AAEjCC,YAAU,MAAM;AACdC,WAAOC,sBAAsB,MAAM;AACjCJ,eAASK,QAAQ;IACnB,CAAC;EACH,CAAC;AAED,QAAMC,gBAAgBC,SAAS,MAAM,CAACP,SAASK,QAAS;IACtDG,YAAY;EACd,IAAKC,MAAS;AAEd,SAAO;IAAEH;IAAeN,UAAUU,SAASV,QAAQ;EAAE;AACvD;",
+  "names": ["useSsrBoot", "isBooted", "shallowRef", "onMounted", "window", "requestAnimationFrame", "value", "ssrBootStyles", "computed", "transition", "undefined", "readonly"]
+}

VApp/node_modules/.vite/deps/chunk-VQPKT5F7.js

@@ -0,0 +1,32 @@
+import {
+  getCurrentInstanceName,
+  propsFactory
+} from "./chunk-I4KGD5X4.js";
+import {
+  computed
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/composables/density.mjs
+var allowedDensities = [null, "default", "comfortable", "compact"];
+var makeDensityProps = propsFactory({
+  density: {
+    type: String,
+    default: "default",
+    validator: (v) => allowedDensities.includes(v)
+  }
+}, "density");
+function useDensity(props) {
+  let name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : getCurrentInstanceName();
+  const densityClasses = computed(() => {
+    return `${name}--density-${props.density}`;
+  });
+  return {
+    densityClasses
+  };
+}
+
+export {
+  makeDensityProps,
+  useDensity
+};
+//# sourceMappingURL=chunk-VQPKT5F7.js.map

VApp/node_modules/.vite/deps/chunk-VQPKT5F7.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../vuetify/src/composables/density.ts"],
+  "sourcesContent": ["// Utilities\nimport { computed } from 'vue'\nimport { getCurrentInstanceName, propsFactory } from '@/util'\n\n// Types\nimport type { PropType } from 'vue'\n\nconst allowedDensities = [null, 'default', 'comfortable', 'compact'] as const\n\n// typeof allowedDensities[number] evalutes to any\n// when generating api types for whatever reason.\nexport type Density = null | 'default' | 'comfortable' | 'compact'\n\nexport interface DensityProps {\n  density?: Density\n}\n\n// Composables\nexport const makeDensityProps = propsFactory({\n  density: {\n    type: String as PropType<Density>,\n    default: 'default',\n    validator: (v: any) => allowedDensities.includes(v),\n  },\n}, 'density')\n\nexport function useDensity (\n  props: DensityProps,\n  name = getCurrentInstanceName(),\n) {\n  const densityClasses = computed(() => {\n    return `${name}--density-${props.density}`\n  })\n\n  return { densityClasses }\n}\n"],
+  "mappings": ";;;;;;;;;AAOA,IAAMA,mBAAmB,CAAC,MAAM,WAAW,eAAe,SAAS;AAW5D,IAAMC,mBAAmBC,aAAa;EAC3CC,SAAS;IACPC,MAAMC;IACNC,SAAS;IACTC,WAAYC,OAAWR,iBAAiBS,SAASD,CAAC;EACpD;AACF,GAAG,SAAS;AAEL,SAASE,WACdC,OAEA;AAAA,MADAC,OAAIC,UAAAC,SAAA,KAAAD,UAAA,CAAA,MAAAE,SAAAF,UAAA,CAAA,IAAGG,uBAAuB;AAE9B,QAAMC,iBAAiBC,SAAS,MAAM;AACpC,WAAQ,GAAEN,IAAK,aAAYD,MAAMR,OAAQ;EAC3C,CAAC;AAED,SAAO;IAAEc;EAAe;AAC1B;",
+  "names": ["allowedDensities", "makeDensityProps", "propsFactory", "density", "type", "String", "default", "validator", "v", "includes", "useDensity", "props", "name", "arguments", "length", "undefined", "getCurrentInstanceName", "densityClasses", "computed"]
+}

VApp/node_modules/.vite/deps/chunk-XCL3R7PH.js

@@ -0,0 +1,431 @@
+import {
+  makePositionProps,
+  usePosition
+} from "./chunk-XJDRWBAV.js";
+import {
+  VProgressCircular
+} from "./chunk-YRMIN6NY.js";
+import {
+  makeGroupItemProps,
+  makeGroupProps,
+  useGroup,
+  useGroupItem
+} from "./chunk-37564NA2.js";
+import {
+  genOverlays,
+  makeVariantProps,
+  useVariant
+} from "./chunk-XQKRKMJT.js";
+import {
+  Ripple
+} from "./chunk-NMCVREUK.js";
+import {
+  makeBorderProps,
+  useBorder
+} from "./chunk-O7K6SSRF.js";
+import {
+  makeElevationProps,
+  useElevation
+} from "./chunk-QXA6VMYU.js";
+import {
+  makeDimensionProps,
+  useDimension
+} from "./chunk-O7EUYO3B.js";
+import {
+  VDefaultsProvider
+} from "./chunk-D42AK3WB.js";
+import {
+  makeRouterProps,
+  useLink
+} from "./chunk-PCNFKUUR.js";
+import {
+  makeLoaderProps,
+  makeLocationProps,
+  useLoader,
+  useLocation
+} from "./chunk-44S2JOLY.js";
+import {
+  makeDensityProps,
+  useDensity
+} from "./chunk-VQPKT5F7.js";
+import {
+  makeRoundedProps,
+  useRounded
+} from "./chunk-24LK52JF.js";
+import {
+  VIcon,
+  makeSizeProps,
+  useSize
+} from "./chunk-IFUDBK56.js";
+import {
+  IconValue
+} from "./chunk-472DNWSX.js";
+import {
+  makeTagProps
+} from "./chunk-DJRL4NAD.js";
+import {
+  makeThemeProps,
+  provideTheme
+} from "./chunk-CYOEVGGH.js";
+import {
+  genericComponent,
+  makeComponentProps,
+  propsFactory,
+  provideDefaults,
+  useRender
+} from "./chunk-I4KGD5X4.js";
+import {
+  computed,
+  createVNode,
+  mergeProps,
+  nextTick,
+  resolveDirective,
+  toRef,
+  watch,
+  withDirectives
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/components/VBtn/VBtn.mjs
+import "C:/Users/Jeremy/Documents/Dev/Projects.cloudsucks.net/Vulture/VApp/node_modules/vuetify/lib/components/VBtn/VBtn.css";
+
+// node_modules/vuetify/lib/components/VBtnToggle/VBtnToggle.mjs
+import "C:/Users/Jeremy/Documents/Dev/Projects.cloudsucks.net/Vulture/VApp/node_modules/vuetify/lib/components/VBtnToggle/VBtnToggle.css";
+
+// node_modules/vuetify/lib/components/VBtnGroup/VBtnGroup.mjs
+import "C:/Users/Jeremy/Documents/Dev/Projects.cloudsucks.net/Vulture/VApp/node_modules/vuetify/lib/components/VBtnGroup/VBtnGroup.css";
+var makeVBtnGroupProps = propsFactory({
+  divided: Boolean,
+  ...makeBorderProps(),
+  ...makeComponentProps(),
+  ...makeDensityProps(),
+  ...makeElevationProps(),
+  ...makeRoundedProps(),
+  ...makeTagProps(),
+  ...makeThemeProps(),
+  ...makeVariantProps()
+}, "VBtnGroup");
+var VBtnGroup = genericComponent()({
+  name: "VBtnGroup",
+  props: makeVBtnGroupProps(),
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    const {
+      themeClasses
+    } = provideTheme(props);
+    const {
+      densityClasses
+    } = useDensity(props);
+    const {
+      borderClasses
+    } = useBorder(props);
+    const {
+      elevationClasses
+    } = useElevation(props);
+    const {
+      roundedClasses
+    } = useRounded(props);
+    provideDefaults({
+      VBtn: {
+        height: "auto",
+        color: toRef(props, "color"),
+        density: toRef(props, "density"),
+        flat: true,
+        variant: toRef(props, "variant")
+      }
+    });
+    useRender(() => {
+      return createVNode(props.tag, {
+        "class": ["v-btn-group", {
+          "v-btn-group--divided": props.divided
+        }, themeClasses.value, borderClasses.value, densityClasses.value, elevationClasses.value, roundedClasses.value, props.class],
+        "style": props.style
+      }, slots);
+    });
+  }
+});
+
+// node_modules/vuetify/lib/components/VBtnToggle/VBtnToggle.mjs
+var VBtnToggleSymbol = Symbol.for("vuetify:v-btn-toggle");
+var makeVBtnToggleProps = propsFactory({
+  ...makeVBtnGroupProps(),
+  ...makeGroupProps()
+}, "VBtnToggle");
+var VBtnToggle = genericComponent()({
+  name: "VBtnToggle",
+  props: makeVBtnToggleProps(),
+  emits: {
+    "update:modelValue": (value) => true
+  },
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    const {
+      isSelected,
+      next,
+      prev,
+      select,
+      selected
+    } = useGroup(props, VBtnToggleSymbol);
+    useRender(() => {
+      const btnGroupProps = VBtnGroup.filterProps(props);
+      return createVNode(VBtnGroup, mergeProps({
+        "class": ["v-btn-toggle", props.class]
+      }, btnGroupProps, {
+        "style": props.style
+      }), {
+        default: () => {
+          var _a;
+          return [(_a = slots.default) == null ? void 0 : _a.call(slots, {
+            isSelected,
+            next,
+            prev,
+            select,
+            selected
+          })];
+        }
+      });
+    });
+    return {
+      next,
+      prev,
+      select
+    };
+  }
+});
+
+// node_modules/vuetify/lib/composables/selectLink.mjs
+function useSelectLink(link, select) {
+  watch(() => {
+    var _a;
+    return (_a = link.isActive) == null ? void 0 : _a.value;
+  }, (isActive) => {
+    if (link.isLink.value && isActive && select) {
+      nextTick(() => {
+        select(true);
+      });
+    }
+  }, {
+    immediate: true
+  });
+}
+
+// node_modules/vuetify/lib/components/VBtn/VBtn.mjs
+var makeVBtnProps = propsFactory({
+  active: {
+    type: Boolean,
+    default: void 0
+  },
+  symbol: {
+    type: null,
+    default: VBtnToggleSymbol
+  },
+  flat: Boolean,
+  icon: [Boolean, String, Function, Object],
+  prependIcon: IconValue,
+  appendIcon: IconValue,
+  block: Boolean,
+  slim: Boolean,
+  stacked: Boolean,
+  ripple: {
+    type: [Boolean, Object],
+    default: true
+  },
+  text: String,
+  ...makeBorderProps(),
+  ...makeComponentProps(),
+  ...makeDensityProps(),
+  ...makeDimensionProps(),
+  ...makeElevationProps(),
+  ...makeGroupItemProps(),
+  ...makeLoaderProps(),
+  ...makeLocationProps(),
+  ...makePositionProps(),
+  ...makeRoundedProps(),
+  ...makeRouterProps(),
+  ...makeSizeProps(),
+  ...makeTagProps({
+    tag: "button"
+  }),
+  ...makeThemeProps(),
+  ...makeVariantProps({
+    variant: "elevated"
+  })
+}, "VBtn");
+var VBtn = genericComponent()({
+  name: "VBtn",
+  directives: {
+    Ripple
+  },
+  props: makeVBtnProps(),
+  emits: {
+    "group:selected": (val) => true
+  },
+  setup(props, _ref) {
+    let {
+      attrs,
+      slots
+    } = _ref;
+    const {
+      themeClasses
+    } = provideTheme(props);
+    const {
+      borderClasses
+    } = useBorder(props);
+    const {
+      colorClasses,
+      colorStyles,
+      variantClasses
+    } = useVariant(props);
+    const {
+      densityClasses
+    } = useDensity(props);
+    const {
+      dimensionStyles
+    } = useDimension(props);
+    const {
+      elevationClasses
+    } = useElevation(props);
+    const {
+      loaderClasses
+    } = useLoader(props);
+    const {
+      locationStyles
+    } = useLocation(props);
+    const {
+      positionClasses
+    } = usePosition(props);
+    const {
+      roundedClasses
+    } = useRounded(props);
+    const {
+      sizeClasses,
+      sizeStyles
+    } = useSize(props);
+    const group = useGroupItem(props, props.symbol, false);
+    const link = useLink(props, attrs);
+    const isActive = computed(() => {
+      var _a;
+      if (props.active !== void 0) {
+        return props.active;
+      }
+      if (link.isLink.value) {
+        return (_a = link.isActive) == null ? void 0 : _a.value;
+      }
+      return group == null ? void 0 : group.isSelected.value;
+    });
+    const isDisabled = computed(() => (group == null ? void 0 : group.disabled.value) || props.disabled);
+    const isElevated = computed(() => {
+      return props.variant === "elevated" && !(props.disabled || props.flat || props.border);
+    });
+    const valueAttr = computed(() => {
+      if (props.value === void 0 || typeof props.value === "symbol") return void 0;
+      return Object(props.value) === props.value ? JSON.stringify(props.value, null, 0) : props.value;
+    });
+    function onClick(e) {
+      var _a;
+      if (isDisabled.value || link.isLink.value && (e.metaKey || e.ctrlKey || e.shiftKey || e.button !== 0 || attrs.target === "_blank")) return;
+      (_a = link.navigate) == null ? void 0 : _a.call(link, e);
+      group == null ? void 0 : group.toggle();
+    }
+    useSelectLink(link, group == null ? void 0 : group.select);
+    useRender(() => {
+      var _a, _b;
+      const Tag = link.isLink.value ? "a" : props.tag;
+      const hasPrepend = !!(props.prependIcon || slots.prepend);
+      const hasAppend = !!(props.appendIcon || slots.append);
+      const hasIcon = !!(props.icon && props.icon !== true);
+      const hasColor = (group == null ? void 0 : group.isSelected.value) && (!link.isLink.value || ((_a = link.isActive) == null ? void 0 : _a.value)) || !group || ((_b = link.isActive) == null ? void 0 : _b.value);
+      return withDirectives(createVNode(Tag, {
+        "type": Tag === "a" ? void 0 : "button",
+        "class": ["v-btn", group == null ? void 0 : group.selectedClass.value, {
+          "v-btn--active": isActive.value,
+          "v-btn--block": props.block,
+          "v-btn--disabled": isDisabled.value,
+          "v-btn--elevated": isElevated.value,
+          "v-btn--flat": props.flat,
+          "v-btn--icon": !!props.icon,
+          "v-btn--loading": props.loading,
+          "v-btn--slim": props.slim,
+          "v-btn--stacked": props.stacked
+        }, themeClasses.value, borderClasses.value, hasColor ? colorClasses.value : void 0, densityClasses.value, elevationClasses.value, loaderClasses.value, positionClasses.value, roundedClasses.value, sizeClasses.value, variantClasses.value, props.class],
+        "style": [hasColor ? colorStyles.value : void 0, dimensionStyles.value, locationStyles.value, sizeStyles.value, props.style],
+        "disabled": isDisabled.value || void 0,
+        "href": link.href.value,
+        "onClick": onClick,
+        "value": valueAttr.value
+      }, {
+        default: () => {
+          var _a2;
+          return [genOverlays(true, "v-btn"), !props.icon && hasPrepend && createVNode("span", {
+            "key": "prepend",
+            "class": "v-btn__prepend"
+          }, [!slots.prepend ? createVNode(VIcon, {
+            "key": "prepend-icon",
+            "icon": props.prependIcon
+          }, null) : createVNode(VDefaultsProvider, {
+            "key": "prepend-defaults",
+            "disabled": !props.prependIcon,
+            "defaults": {
+              VIcon: {
+                icon: props.prependIcon
+              }
+            }
+          }, slots.prepend)]), createVNode("span", {
+            "class": "v-btn__content",
+            "data-no-activator": ""
+          }, [!slots.default && hasIcon ? createVNode(VIcon, {
+            "key": "content-icon",
+            "icon": props.icon
+          }, null) : createVNode(VDefaultsProvider, {
+            "key": "content-defaults",
+            "disabled": !hasIcon,
+            "defaults": {
+              VIcon: {
+                icon: props.icon
+              }
+            }
+          }, {
+            default: () => {
+              var _a3;
+              return [((_a3 = slots.default) == null ? void 0 : _a3.call(slots)) ?? props.text];
+            }
+          })]), !props.icon && hasAppend && createVNode("span", {
+            "key": "append",
+            "class": "v-btn__append"
+          }, [!slots.append ? createVNode(VIcon, {
+            "key": "append-icon",
+            "icon": props.appendIcon
+          }, null) : createVNode(VDefaultsProvider, {
+            "key": "append-defaults",
+            "disabled": !props.appendIcon,
+            "defaults": {
+              VIcon: {
+                icon: props.appendIcon
+              }
+            }
+          }, slots.append)]), !!props.loading && createVNode("span", {
+            "key": "loader",
+            "class": "v-btn__loader"
+          }, [((_a2 = slots.loader) == null ? void 0 : _a2.call(slots)) ?? createVNode(VProgressCircular, {
+            "color": typeof props.loading === "boolean" ? void 0 : props.loading,
+            "indeterminate": true,
+            "size": "23",
+            "width": "2"
+          }, null)])];
+        }
+      }), [[resolveDirective("ripple"), !isDisabled.value && props.ripple, null]]);
+    });
+    return {
+      group
+    };
+  }
+});
+
+export {
+  makeVBtnProps,
+  VBtn
+};
+//# sourceMappingURL=chunk-XCL3R7PH.js.map

VApp/node_modules/.vite/deps/chunk-XJDRWBAV.js

@@ -0,0 +1,34 @@
+import {
+  getCurrentInstanceName,
+  propsFactory
+} from "./chunk-I4KGD5X4.js";
+import {
+  computed
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/composables/position.mjs
+var positionValues = ["static", "relative", "fixed", "absolute", "sticky"];
+var makePositionProps = propsFactory({
+  position: {
+    type: String,
+    validator: (
+      /* istanbul ignore next */
+      (v) => positionValues.includes(v)
+    )
+  }
+}, "position");
+function usePosition(props) {
+  let name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : getCurrentInstanceName();
+  const positionClasses = computed(() => {
+    return props.position ? `${name}--${props.position}` : void 0;
+  });
+  return {
+    positionClasses
+  };
+}
+
+export {
+  makePositionProps,
+  usePosition
+};
+//# sourceMappingURL=chunk-XJDRWBAV.js.map

VApp/node_modules/.vite/deps/chunk-XJDRWBAV.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../vuetify/src/composables/position.ts"],
+  "sourcesContent": ["// Utilities\nimport { computed } from 'vue'\nimport { getCurrentInstanceName, propsFactory } from '@/util'\n\n// Types\nimport type { PropType } from 'vue'\n\nconst positionValues = ['static', 'relative', 'fixed', 'absolute', 'sticky'] as const\n\ntype Position = typeof positionValues[number]\n\nexport interface PositionProps {\n  position: Position | undefined\n}\n\n// Composables\nexport const makePositionProps = propsFactory({\n  position: {\n    type: String as PropType<Position>,\n    validator: /* istanbul ignore next */ (v: any) => positionValues.includes(v),\n  },\n}, 'position')\n\nexport function usePosition (\n  props: PositionProps,\n  name = getCurrentInstanceName(),\n) {\n  const positionClasses = computed(() => {\n    return props.position ? `${name}--${props.position}` : undefined\n  })\n\n  return { positionClasses }\n}\n"],
+  "mappings": ";;;;;;;;;AAOA,IAAMA,iBAAiB,CAAC,UAAU,YAAY,SAAS,YAAY,QAAQ;AASpE,IAAMC,oBAAoBC,aAAa;EAC5CC,UAAU;IACRC,MAAMC;IACNC;;MAAuCC,OAAWP,eAAeQ,SAASD,CAAC;;EAC7E;AACF,GAAG,UAAU;AAEN,SAASE,YACdC,OAEA;AAAA,MADAC,OAAIC,UAAAC,SAAA,KAAAD,UAAA,CAAA,MAAAE,SAAAF,UAAA,CAAA,IAAGG,uBAAuB;AAE9B,QAAMC,kBAAkBC,SAAS,MAAM;AACrC,WAAOP,MAAMP,WAAY,GAAEQ,IAAK,KAAID,MAAMP,QAAS,KAAIW;EACzD,CAAC;AAED,SAAO;IAAEE;EAAgB;AAC3B;",
+  "names": ["positionValues", "makePositionProps", "propsFactory", "position", "type", "String", "validator", "v", "includes", "usePosition", "props", "name", "arguments", "length", "undefined", "getCurrentInstanceName", "positionClasses", "computed"]
+}

VApp/node_modules/.vite/deps/chunk-XQKRKMJT.js

@@ -0,0 +1,66 @@
+import {
+  useColor
+} from "./chunk-ZZ55KHRR.js";
+import {
+  getCurrentInstanceName,
+  propsFactory
+} from "./chunk-I4KGD5X4.js";
+import {
+  Fragment,
+  computed,
+  createVNode,
+  unref
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/composables/variant.mjs
+var allowedVariants = ["elevated", "flat", "tonal", "outlined", "text", "plain"];
+function genOverlays(isClickable, name) {
+  return createVNode(Fragment, null, [isClickable && createVNode("span", {
+    "key": "overlay",
+    "class": `${name}__overlay`
+  }, null), createVNode("span", {
+    "key": "underlay",
+    "class": `${name}__underlay`
+  }, null)]);
+}
+var makeVariantProps = propsFactory({
+  color: String,
+  variant: {
+    type: String,
+    default: "elevated",
+    validator: (v) => allowedVariants.includes(v)
+  }
+}, "variant");
+function useVariant(props) {
+  let name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : getCurrentInstanceName();
+  const variantClasses = computed(() => {
+    const {
+      variant
+    } = unref(props);
+    return `${name}--variant-${variant}`;
+  });
+  const {
+    colorClasses,
+    colorStyles
+  } = useColor(computed(() => {
+    const {
+      variant,
+      color
+    } = unref(props);
+    return {
+      [["elevated", "flat"].includes(variant) ? "background" : "text"]: color
+    };
+  }));
+  return {
+    colorClasses,
+    colorStyles,
+    variantClasses
+  };
+}
+
+export {
+  genOverlays,
+  makeVariantProps,
+  useVariant
+};
+//# sourceMappingURL=chunk-XQKRKMJT.js.map

VApp/node_modules/.vite/deps/chunk-XQKRKMJT.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../vuetify/src/composables/variant.tsx"],
+  "sourcesContent": ["// Composables\nimport { useColor } from '@/composables/color'\n\n// Utilities\nimport { computed, unref } from 'vue'\nimport { getCurrentInstanceName, propsFactory } from '@/util'\n\n// Types\nimport type { PropType } from 'vue'\nimport type { MaybeRef } from '@/util'\n\nexport const allowedVariants = [\n  'elevated',\n  'flat',\n  'tonal',\n  'outlined',\n  'text',\n  'plain',\n] as const\n\nexport type Variant = typeof allowedVariants[number]\n\nexport interface VariantProps {\n  color?: string\n  variant: Variant\n}\n\nexport function genOverlays (isClickable: boolean, name: string) {\n  return (\n    <>\n      { isClickable && <span key=\"overlay\" class={ `${name}__overlay` } /> }\n\n      <span key=\"underlay\" class={ `${name}__underlay` } />\n    </>\n  )\n}\n\nexport const makeVariantProps = propsFactory({\n  color: String,\n  variant: {\n    type: String as PropType<Variant>,\n    default: 'elevated',\n    validator: (v: any) => allowedVariants.includes(v),\n  },\n}, 'variant')\n\nexport function useVariant (\n  props: MaybeRef<VariantProps>,\n  name = getCurrentInstanceName(),\n) {\n  const variantClasses = computed(() => {\n    const { variant } = unref(props)\n    return `${name}--variant-${variant}`\n  })\n\n  const { colorClasses, colorStyles } = useColor(computed(() => {\n    const { variant, color } = unref(props)\n    return {\n      [['elevated', 'flat'].includes(variant) ? 'background' : 'text']: color,\n    }\n  }))\n\n  return { colorClasses, colorStyles, variantClasses }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;AAWO,IAAMA,kBAAkB,CAC7B,YACA,QACA,SACA,YACA,QACA,OAAO;AAUF,SAASC,YAAaC,aAAsBC,MAAc;AAC/D,SAAAC,YAAAC,UAAA,MAAA,CAEMH,eAAWE,YAAA,QAAA;IAAA,OAAA;IAAA,SAAiC,GAAED,IAAK;EAAU,GAAA,IAAA,GAAKC,YAAA,QAAA;IAAA,OAAA;IAAA,SAEtC,GAAED,IAAK;EAAW,GAAA,IAAA,CAAA,CAAA;AAGtD;AAEO,IAAMG,mBAAmBC,aAAa;EAC3CC,OAAOC;EACPC,SAAS;IACPC,MAAMF;IACNG,SAAS;IACTC,WAAYC,OAAWd,gBAAgBe,SAASD,CAAC;EACnD;AACF,GAAG,SAAS;AAEL,SAASE,WACdC,OAEA;AAAA,MADAd,OAAIe,UAAAC,SAAA,KAAAD,UAAA,CAAA,MAAAE,SAAAF,UAAA,CAAA,IAAGG,uBAAuB;AAE9B,QAAMC,iBAAiBC,SAAS,MAAM;AACpC,UAAM;MAAEb;IAAQ,IAAIc,MAAMP,KAAK;AAC/B,WAAQ,GAAEd,IAAK,aAAYO,OAAQ;EACrC,CAAC;AAED,QAAM;IAAEe;IAAcC;EAAY,IAAIC,SAASJ,SAAS,MAAM;AAC5D,UAAM;MAAEb;MAASF;IAAM,IAAIgB,MAAMP,KAAK;AACtC,WAAO;MACL,CAAC,CAAC,YAAY,MAAM,EAAEF,SAASL,OAAO,IAAI,eAAe,MAAM,GAAGF;IACpE;EACF,CAAC,CAAC;AAEF,SAAO;IAAEiB;IAAcC;IAAaJ;EAAe;AACrD;",
+  "names": ["allowedVariants", "genOverlays", "isClickable", "name", "_createVNode", "_Fragment", "makeVariantProps", "propsFactory", "color", "String", "variant", "type", "default", "validator", "v", "includes", "useVariant", "props", "arguments", "length", "undefined", "getCurrentInstanceName", "variantClasses", "computed", "unref", "colorClasses", "colorStyles", "useColor"]
+}

VApp/node_modules/.vite/deps/chunk-XRWT7YWI.js

@@ -0,0 +1,42 @@
+import {
+  propsFactory
+} from "./chunk-I4KGD5X4.js";
+import {
+  Transition,
+  h,
+  mergeProps
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/composables/transition.mjs
+var makeTransitionProps = propsFactory({
+  transition: {
+    type: [Boolean, String, Object],
+    default: "fade-transition",
+    validator: (val) => val !== true
+  }
+}, "transition");
+var MaybeTransition = (props, _ref) => {
+  let {
+    slots
+  } = _ref;
+  const {
+    transition,
+    disabled,
+    ...rest
+  } = props;
+  const {
+    component = Transition,
+    ...customProps
+  } = typeof transition === "object" ? transition : {};
+  return h(component, mergeProps(typeof transition === "string" ? {
+    name: disabled ? "" : transition
+  } : customProps, rest, {
+    disabled
+  }), slots);
+};
+
+export {
+  makeTransitionProps,
+  MaybeTransition
+};
+//# sourceMappingURL=chunk-XRWT7YWI.js.map

VApp/node_modules/.vite/deps/chunk-XRWT7YWI.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../vuetify/src/composables/transition.ts"],
+  "sourcesContent": ["// Utilities\nimport { h, mergeProps, Transition } from 'vue'\nimport { propsFactory } from '@/util'\n\n// Types\nimport type { Component, FunctionalComponent, PropType, TransitionProps } from 'vue'\n\nexport const makeTransitionProps = propsFactory({\n  transition: {\n    type: [Boolean, String, Object] as PropType<string | boolean | TransitionProps & { component?: Component }>,\n    default: 'fade-transition',\n    validator: val => val !== true,\n  },\n}, 'transition')\n\ninterface MaybeTransitionProps extends TransitionProps {\n  transition?: string | boolean | TransitionProps & { component?: any }\n  disabled?: boolean\n}\n\nexport const MaybeTransition: FunctionalComponent<MaybeTransitionProps> = (props, { slots }) => {\n  const { transition, disabled, ...rest } = props\n\n  const { component = Transition, ...customProps } = typeof transition === 'object' ? transition : {}\n\n  return h(\n    component,\n    mergeProps(typeof transition === 'string'\n      ? { name: disabled ? '' : transition }\n      : customProps as any,\n    rest as any,\n    { disabled }),\n    slots\n  )\n}\n"],
+  "mappings": ";;;;;;;;;;AAOO,IAAMA,sBAAsBC,aAAa;EAC9CC,YAAY;IACVC,MAAM,CAACC,SAASC,QAAQC,MAAM;IAC9BC,SAAS;IACTC,WAAWC,SAAOA,QAAQ;EAC5B;AACF,GAAG,YAAY;AAOR,IAAMC,kBAA6DA,CAACC,OAAKC,SAAgB;AAAA,MAAd;IAAEC;EAAM,IAACD;AACzF,QAAM;IAAEV;IAAYY;IAAU,GAAGC;EAAK,IAAIJ;AAE1C,QAAM;IAAEK,YAAYC;IAAY,GAAGC;EAAY,IAAI,OAAOhB,eAAe,WAAWA,aAAa,CAAC;AAElG,SAAOiB,EACLH,WACAI,WAAW,OAAOlB,eAAe,WAC7B;IAAEmB,MAAMP,WAAW,KAAKZ;EAAW,IACnCgB,aACJH,MACA;IAAED;EAAS,CAAC,GACZD,KACF;AACF;",
+  "names": ["makeTransitionProps", "propsFactory", "transition", "type", "Boolean", "String", "Object", "default", "validator", "val", "MaybeTransition", "props", "_ref", "slots", "disabled", "rest", "component", "Transition", "customProps", "h", "mergeProps", "name"]
+}

VApp/node_modules/.vite/deps/chunk-YRMIN6NY.js

@@ -0,0 +1,157 @@
+import {
+  useIntersectionObserver
+} from "./chunk-44S2JOLY.js";
+import {
+  makeSizeProps,
+  useSize
+} from "./chunk-IFUDBK56.js";
+import {
+  useTextColor
+} from "./chunk-ZZ55KHRR.js";
+import {
+  makeTagProps
+} from "./chunk-DJRL4NAD.js";
+import {
+  useResizeObserver
+} from "./chunk-6MYZNPKW.js";
+import {
+  makeThemeProps,
+  provideTheme
+} from "./chunk-CYOEVGGH.js";
+import {
+  convertToUnit,
+  genericComponent,
+  makeComponentProps,
+  propsFactory,
+  useRender
+} from "./chunk-I4KGD5X4.js";
+import {
+  computed,
+  createVNode,
+  ref,
+  toRef,
+  watchEffect
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/components/VProgressCircular/VProgressCircular.mjs
+import "C:/Users/Jeremy/Documents/Dev/Projects.cloudsucks.net/Vulture/VApp/node_modules/vuetify/lib/components/VProgressCircular/VProgressCircular.css";
+var makeVProgressCircularProps = propsFactory({
+  bgColor: String,
+  color: String,
+  indeterminate: [Boolean, String],
+  modelValue: {
+    type: [Number, String],
+    default: 0
+  },
+  rotate: {
+    type: [Number, String],
+    default: 0
+  },
+  width: {
+    type: [Number, String],
+    default: 4
+  },
+  ...makeComponentProps(),
+  ...makeSizeProps(),
+  ...makeTagProps({
+    tag: "div"
+  }),
+  ...makeThemeProps()
+}, "VProgressCircular");
+var VProgressCircular = genericComponent()({
+  name: "VProgressCircular",
+  props: makeVProgressCircularProps(),
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    const MAGIC_RADIUS_CONSTANT = 20;
+    const CIRCUMFERENCE = 2 * Math.PI * MAGIC_RADIUS_CONSTANT;
+    const root = ref();
+    const {
+      themeClasses
+    } = provideTheme(props);
+    const {
+      sizeClasses,
+      sizeStyles
+    } = useSize(props);
+    const {
+      textColorClasses,
+      textColorStyles
+    } = useTextColor(toRef(props, "color"));
+    const {
+      textColorClasses: underlayColorClasses,
+      textColorStyles: underlayColorStyles
+    } = useTextColor(toRef(props, "bgColor"));
+    const {
+      intersectionRef,
+      isIntersecting
+    } = useIntersectionObserver();
+    const {
+      resizeRef,
+      contentRect
+    } = useResizeObserver();
+    const normalizedValue = computed(() => Math.max(0, Math.min(100, parseFloat(props.modelValue))));
+    const width = computed(() => Number(props.width));
+    const size = computed(() => {
+      return sizeStyles.value ? Number(props.size) : contentRect.value ? contentRect.value.width : Math.max(width.value, 32);
+    });
+    const diameter = computed(() => MAGIC_RADIUS_CONSTANT / (1 - width.value / size.value) * 2);
+    const strokeWidth = computed(() => width.value / size.value * diameter.value);
+    const strokeDashOffset = computed(() => convertToUnit((100 - normalizedValue.value) / 100 * CIRCUMFERENCE));
+    watchEffect(() => {
+      intersectionRef.value = root.value;
+      resizeRef.value = root.value;
+    });
+    useRender(() => createVNode(props.tag, {
+      "ref": root,
+      "class": ["v-progress-circular", {
+        "v-progress-circular--indeterminate": !!props.indeterminate,
+        "v-progress-circular--visible": isIntersecting.value,
+        "v-progress-circular--disable-shrink": props.indeterminate === "disable-shrink"
+      }, themeClasses.value, sizeClasses.value, textColorClasses.value, props.class],
+      "style": [sizeStyles.value, textColorStyles.value, props.style],
+      "role": "progressbar",
+      "aria-valuemin": "0",
+      "aria-valuemax": "100",
+      "aria-valuenow": props.indeterminate ? void 0 : normalizedValue.value
+    }, {
+      default: () => [createVNode("svg", {
+        "style": {
+          transform: `rotate(calc(-90deg + ${Number(props.rotate)}deg))`
+        },
+        "xmlns": "http://www.w3.org/2000/svg",
+        "viewBox": `0 0 ${diameter.value} ${diameter.value}`
+      }, [createVNode("circle", {
+        "class": ["v-progress-circular__underlay", underlayColorClasses.value],
+        "style": underlayColorStyles.value,
+        "fill": "transparent",
+        "cx": "50%",
+        "cy": "50%",
+        "r": MAGIC_RADIUS_CONSTANT,
+        "stroke-width": strokeWidth.value,
+        "stroke-dasharray": CIRCUMFERENCE,
+        "stroke-dashoffset": 0
+      }, null), createVNode("circle", {
+        "class": "v-progress-circular__overlay",
+        "fill": "transparent",
+        "cx": "50%",
+        "cy": "50%",
+        "r": MAGIC_RADIUS_CONSTANT,
+        "stroke-width": strokeWidth.value,
+        "stroke-dasharray": CIRCUMFERENCE,
+        "stroke-dashoffset": strokeDashOffset.value
+      }, null)]), slots.default && createVNode("div", {
+        "class": "v-progress-circular__content"
+      }, [slots.default({
+        value: normalizedValue.value
+      })])]
+    }));
+    return {};
+  }
+});
+
+export {
+  VProgressCircular
+};
+//# sourceMappingURL=chunk-YRMIN6NY.js.map

VApp/node_modules/.vite/deps/chunk-ZCXGZYP7.js

@@ -0,0 +1,486 @@
+import {
+  makeDensityProps,
+  useDensity
+} from "./chunk-VQPKT5F7.js";
+import {
+  VIcon
+} from "./chunk-IFUDBK56.js";
+import {
+  VSlideYTransition
+} from "./chunk-JVZUVJAC.js";
+import {
+  MaybeTransition,
+  makeTransitionProps
+} from "./chunk-XRWT7YWI.js";
+import {
+  useTextColor
+} from "./chunk-ZZ55KHRR.js";
+import {
+  IconValue
+} from "./chunk-472DNWSX.js";
+import {
+  useLocale,
+  useRtl
+} from "./chunk-IR5437QA.js";
+import {
+  useProxiedModel,
+  useToggleScope
+} from "./chunk-PVQHDZXM.js";
+import {
+  EventProp,
+  genericComponent,
+  getCurrentInstanceName,
+  getUid,
+  makeComponentProps,
+  propsFactory,
+  useRender,
+  wrapInArray
+} from "./chunk-I4KGD5X4.js";
+import {
+  computed,
+  createVNode,
+  inject,
+  nextTick,
+  onBeforeMount,
+  onBeforeUnmount,
+  onMounted,
+  ref,
+  shallowRef,
+  unref,
+  watch
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/composables/focus.mjs
+var makeFocusProps = propsFactory({
+  focused: Boolean,
+  "onUpdate:focused": EventProp()
+}, "focus");
+function useFocus(props) {
+  let name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : getCurrentInstanceName();
+  const isFocused = useProxiedModel(props, "focused");
+  const focusClasses = computed(() => {
+    return {
+      [`${name}--focused`]: isFocused.value
+    };
+  });
+  function focus() {
+    isFocused.value = true;
+  }
+  function blur() {
+    isFocused.value = false;
+  }
+  return {
+    focusClasses,
+    isFocused,
+    focus,
+    blur
+  };
+}
+
+// node_modules/vuetify/lib/composables/form.mjs
+var FormKey = Symbol.for("vuetify:form");
+var makeFormProps = propsFactory({
+  disabled: Boolean,
+  fastFail: Boolean,
+  readonly: Boolean,
+  modelValue: {
+    type: Boolean,
+    default: null
+  },
+  validateOn: {
+    type: String,
+    default: "input"
+  }
+}, "form");
+function useForm() {
+  return inject(FormKey, null);
+}
+
+// node_modules/vuetify/lib/components/VInput/VInput.mjs
+import "C:/Users/Jeremy/Documents/Dev/Projects.cloudsucks.net/Vulture/VApp/node_modules/vuetify/lib/components/VInput/VInput.css";
+
+// node_modules/vuetify/lib/components/VInput/InputIcon.mjs
+function useInputIcon(props) {
+  const {
+    t
+  } = useLocale();
+  function InputIcon(_ref) {
+    let {
+      name
+    } = _ref;
+    const localeKey = {
+      prepend: "prependAction",
+      prependInner: "prependAction",
+      append: "appendAction",
+      appendInner: "appendAction",
+      clear: "clear"
+    }[name];
+    const listener = props[`onClick:${name}`];
+    const label = listener && localeKey ? t(`$vuetify.input.${localeKey}`, props.label ?? "") : void 0;
+    return createVNode(VIcon, {
+      "icon": props[`${name}Icon`],
+      "aria-label": label,
+      "onClick": listener
+    }, null);
+  }
+  return {
+    InputIcon
+  };
+}
+
+// node_modules/vuetify/lib/components/VMessages/VMessages.mjs
+import "C:/Users/Jeremy/Documents/Dev/Projects.cloudsucks.net/Vulture/VApp/node_modules/vuetify/lib/components/VMessages/VMessages.css";
+var makeVMessagesProps = propsFactory({
+  active: Boolean,
+  color: String,
+  messages: {
+    type: [Array, String],
+    default: () => []
+  },
+  ...makeComponentProps(),
+  ...makeTransitionProps({
+    transition: {
+      component: VSlideYTransition,
+      leaveAbsolute: true,
+      group: true
+    }
+  })
+}, "VMessages");
+var VMessages = genericComponent()({
+  name: "VMessages",
+  props: makeVMessagesProps(),
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    const messages = computed(() => wrapInArray(props.messages));
+    const {
+      textColorClasses,
+      textColorStyles
+    } = useTextColor(computed(() => props.color));
+    useRender(() => createVNode(MaybeTransition, {
+      "transition": props.transition,
+      "tag": "div",
+      "class": ["v-messages", textColorClasses.value, props.class],
+      "style": [textColorStyles.value, props.style],
+      "role": "alert",
+      "aria-live": "polite"
+    }, {
+      default: () => [props.active && messages.value.map((message, i) => createVNode("div", {
+        "class": "v-messages__message",
+        "key": `${i}-${messages.value}`
+      }, [slots.message ? slots.message({
+        message
+      }) : message]))]
+    }));
+    return {};
+  }
+});
+
+// node_modules/vuetify/lib/composables/validation.mjs
+var makeValidationProps = propsFactory({
+  disabled: {
+    type: Boolean,
+    default: null
+  },
+  error: Boolean,
+  errorMessages: {
+    type: [Array, String],
+    default: () => []
+  },
+  maxErrors: {
+    type: [Number, String],
+    default: 1
+  },
+  name: String,
+  label: String,
+  readonly: {
+    type: Boolean,
+    default: null
+  },
+  rules: {
+    type: Array,
+    default: () => []
+  },
+  modelValue: null,
+  validateOn: String,
+  validationValue: null,
+  ...makeFocusProps()
+}, "validation");
+function useValidation(props) {
+  let name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : getCurrentInstanceName();
+  let id = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : getUid();
+  const model = useProxiedModel(props, "modelValue");
+  const validationModel = computed(() => props.validationValue === void 0 ? model.value : props.validationValue);
+  const form = useForm();
+  const internalErrorMessages = ref([]);
+  const isPristine = shallowRef(true);
+  const isDirty = computed(() => !!(wrapInArray(model.value === "" ? null : model.value).length || wrapInArray(validationModel.value === "" ? null : validationModel.value).length));
+  const isDisabled = computed(() => !!(props.disabled ?? (form == null ? void 0 : form.isDisabled.value)));
+  const isReadonly = computed(() => !!(props.readonly ?? (form == null ? void 0 : form.isReadonly.value)));
+  const errorMessages = computed(() => {
+    var _a;
+    return ((_a = props.errorMessages) == null ? void 0 : _a.length) ? wrapInArray(props.errorMessages).concat(internalErrorMessages.value).slice(0, Math.max(0, +props.maxErrors)) : internalErrorMessages.value;
+  });
+  const validateOn = computed(() => {
+    let value = (props.validateOn ?? (form == null ? void 0 : form.validateOn.value)) || "input";
+    if (value === "lazy") value = "input lazy";
+    const set = new Set((value == null ? void 0 : value.split(" ")) ?? []);
+    return {
+      blur: set.has("blur") || set.has("input"),
+      input: set.has("input"),
+      submit: set.has("submit"),
+      lazy: set.has("lazy")
+    };
+  });
+  const isValid = computed(() => {
+    var _a;
+    if (props.error || ((_a = props.errorMessages) == null ? void 0 : _a.length)) return false;
+    if (!props.rules.length) return true;
+    if (isPristine.value) {
+      return internalErrorMessages.value.length || validateOn.value.lazy ? null : true;
+    } else {
+      return !internalErrorMessages.value.length;
+    }
+  });
+  const isValidating = shallowRef(false);
+  const validationClasses = computed(() => {
+    return {
+      [`${name}--error`]: isValid.value === false,
+      [`${name}--dirty`]: isDirty.value,
+      [`${name}--disabled`]: isDisabled.value,
+      [`${name}--readonly`]: isReadonly.value
+    };
+  });
+  const uid = computed(() => props.name ?? unref(id));
+  onBeforeMount(() => {
+    form == null ? void 0 : form.register({
+      id: uid.value,
+      validate,
+      reset,
+      resetValidation
+    });
+  });
+  onBeforeUnmount(() => {
+    form == null ? void 0 : form.unregister(uid.value);
+  });
+  onMounted(async () => {
+    if (!validateOn.value.lazy) {
+      await validate(true);
+    }
+    form == null ? void 0 : form.update(uid.value, isValid.value, errorMessages.value);
+  });
+  useToggleScope(() => validateOn.value.input, () => {
+    watch(validationModel, () => {
+      if (validationModel.value != null) {
+        validate();
+      } else if (props.focused) {
+        const unwatch = watch(() => props.focused, (val) => {
+          if (!val) validate();
+          unwatch();
+        });
+      }
+    });
+  });
+  useToggleScope(() => validateOn.value.blur, () => {
+    watch(() => props.focused, (val) => {
+      if (!val) validate();
+    });
+  });
+  watch([isValid, errorMessages], () => {
+    form == null ? void 0 : form.update(uid.value, isValid.value, errorMessages.value);
+  });
+  function reset() {
+    model.value = null;
+    nextTick(resetValidation);
+  }
+  function resetValidation() {
+    isPristine.value = true;
+    if (!validateOn.value.lazy) {
+      validate(true);
+    } else {
+      internalErrorMessages.value = [];
+    }
+  }
+  async function validate() {
+    let silent = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : false;
+    const results = [];
+    isValidating.value = true;
+    for (const rule of props.rules) {
+      if (results.length >= +(props.maxErrors ?? 1)) {
+        break;
+      }
+      const handler = typeof rule === "function" ? rule : () => rule;
+      const result = await handler(validationModel.value);
+      if (result === true) continue;
+      if (result !== false && typeof result !== "string") {
+        console.warn(`${result} is not a valid value. Rule functions must return boolean true or a string.`);
+        continue;
+      }
+      results.push(result || "");
+    }
+    internalErrorMessages.value = results;
+    isValidating.value = false;
+    isPristine.value = silent;
+    return internalErrorMessages.value;
+  }
+  return {
+    errorMessages,
+    isDirty,
+    isDisabled,
+    isReadonly,
+    isPristine,
+    isValid,
+    isValidating,
+    reset,
+    resetValidation,
+    validate,
+    validationClasses
+  };
+}
+
+// node_modules/vuetify/lib/components/VInput/VInput.mjs
+var makeVInputProps = propsFactory({
+  id: String,
+  appendIcon: IconValue,
+  centerAffix: {
+    type: Boolean,
+    default: true
+  },
+  prependIcon: IconValue,
+  hideDetails: [Boolean, String],
+  hideSpinButtons: Boolean,
+  hint: String,
+  persistentHint: Boolean,
+  messages: {
+    type: [Array, String],
+    default: () => []
+  },
+  direction: {
+    type: String,
+    default: "horizontal",
+    validator: (v) => ["horizontal", "vertical"].includes(v)
+  },
+  "onClick:prepend": EventProp(),
+  "onClick:append": EventProp(),
+  ...makeComponentProps(),
+  ...makeDensityProps(),
+  ...makeValidationProps()
+}, "VInput");
+var VInput = genericComponent()({
+  name: "VInput",
+  props: {
+    ...makeVInputProps()
+  },
+  emits: {
+    "update:modelValue": (value) => true
+  },
+  setup(props, _ref) {
+    let {
+      attrs,
+      slots,
+      emit
+    } = _ref;
+    const {
+      densityClasses
+    } = useDensity(props);
+    const {
+      rtlClasses
+    } = useRtl();
+    const {
+      InputIcon
+    } = useInputIcon(props);
+    const uid = getUid();
+    const id = computed(() => props.id || `input-${uid}`);
+    const messagesId = computed(() => `${id.value}-messages`);
+    const {
+      errorMessages,
+      isDirty,
+      isDisabled,
+      isReadonly,
+      isPristine,
+      isValid,
+      isValidating,
+      reset,
+      resetValidation,
+      validate,
+      validationClasses
+    } = useValidation(props, "v-input", id);
+    const slotProps = computed(() => ({
+      id,
+      messagesId,
+      isDirty,
+      isDisabled,
+      isReadonly,
+      isPristine,
+      isValid,
+      isValidating,
+      reset,
+      resetValidation,
+      validate
+    }));
+    const messages = computed(() => {
+      var _a;
+      if (((_a = props.errorMessages) == null ? void 0 : _a.length) || !isPristine.value && errorMessages.value.length) {
+        return errorMessages.value;
+      } else if (props.hint && (props.persistentHint || props.focused)) {
+        return props.hint;
+      } else {
+        return props.messages;
+      }
+    });
+    useRender(() => {
+      var _a, _b, _c, _d;
+      const hasPrepend = !!(slots.prepend || props.prependIcon);
+      const hasAppend = !!(slots.append || props.appendIcon);
+      const hasMessages = messages.value.length > 0;
+      const hasDetails = !props.hideDetails || props.hideDetails === "auto" && (hasMessages || !!slots.details);
+      return createVNode("div", {
+        "class": ["v-input", `v-input--${props.direction}`, {
+          "v-input--center-affix": props.centerAffix,
+          "v-input--hide-spin-buttons": props.hideSpinButtons
+        }, densityClasses.value, rtlClasses.value, validationClasses.value, props.class],
+        "style": props.style
+      }, [hasPrepend && createVNode("div", {
+        "key": "prepend",
+        "class": "v-input__prepend"
+      }, [(_a = slots.prepend) == null ? void 0 : _a.call(slots, slotProps.value), props.prependIcon && createVNode(InputIcon, {
+        "key": "prepend-icon",
+        "name": "prepend"
+      }, null)]), slots.default && createVNode("div", {
+        "class": "v-input__control"
+      }, [(_b = slots.default) == null ? void 0 : _b.call(slots, slotProps.value)]), hasAppend && createVNode("div", {
+        "key": "append",
+        "class": "v-input__append"
+      }, [props.appendIcon && createVNode(InputIcon, {
+        "key": "append-icon",
+        "name": "append"
+      }, null), (_c = slots.append) == null ? void 0 : _c.call(slots, slotProps.value)]), hasDetails && createVNode("div", {
+        "class": "v-input__details"
+      }, [createVNode(VMessages, {
+        "id": messagesId.value,
+        "active": hasMessages,
+        "messages": messages.value
+      }, {
+        message: slots.message
+      }), (_d = slots.details) == null ? void 0 : _d.call(slots, slotProps.value)])]);
+    });
+    return {
+      reset,
+      resetValidation,
+      validate,
+      isValid,
+      errorMessages
+    };
+  }
+});
+
+export {
+  useInputIcon,
+  makeFocusProps,
+  useFocus,
+  useForm,
+  makeVInputProps,
+  VInput
+};
+//# sourceMappingURL=chunk-ZCXGZYP7.js.map

VApp/node_modules/.vite/deps/chunk-ZZ55KHRR.js

@@ -0,0 +1,79 @@
+import {
+  destructComputed,
+  getForeground,
+  isCssColor,
+  isParsableColor,
+  parseColor
+} from "./chunk-I4KGD5X4.js";
+import {
+  computed,
+  isRef
+} from "./chunk-PD2AWGJV.js";
+
+// node_modules/vuetify/lib/composables/color.mjs
+function useColor(colors) {
+  return destructComputed(() => {
+    const classes = [];
+    const styles = {};
+    if (colors.value.background) {
+      if (isCssColor(colors.value.background)) {
+        styles.backgroundColor = colors.value.background;
+        if (!colors.value.text && isParsableColor(colors.value.background)) {
+          const backgroundColor = parseColor(colors.value.background);
+          if (backgroundColor.a == null || backgroundColor.a === 1) {
+            const textColor = getForeground(backgroundColor);
+            styles.color = textColor;
+            styles.caretColor = textColor;
+          }
+        }
+      } else {
+        classes.push(`bg-${colors.value.background}`);
+      }
+    }
+    if (colors.value.text) {
+      if (isCssColor(colors.value.text)) {
+        styles.color = colors.value.text;
+        styles.caretColor = colors.value.text;
+      } else {
+        classes.push(`text-${colors.value.text}`);
+      }
+    }
+    return {
+      colorClasses: classes,
+      colorStyles: styles
+    };
+  });
+}
+function useTextColor(props, name) {
+  const colors = computed(() => ({
+    text: isRef(props) ? props.value : name ? props[name] : null
+  }));
+  const {
+    colorClasses: textColorClasses,
+    colorStyles: textColorStyles
+  } = useColor(colors);
+  return {
+    textColorClasses,
+    textColorStyles
+  };
+}
+function useBackgroundColor(props, name) {
+  const colors = computed(() => ({
+    background: isRef(props) ? props.value : name ? props[name] : null
+  }));
+  const {
+    colorClasses: backgroundColorClasses,
+    colorStyles: backgroundColorStyles
+  } = useColor(colors);
+  return {
+    backgroundColorClasses,
+    backgroundColorStyles
+  };
+}
+
+export {
+  useColor,
+  useTextColor,
+  useBackgroundColor
+};
+//# sourceMappingURL=chunk-ZZ55KHRR.js.map

VApp/node_modules/.vite/deps/chunk-ZZ55KHRR.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../vuetify/src/composables/color.ts"],
+  "sourcesContent": ["// Utilities\nimport { computed, isRef } from 'vue'\nimport { destructComputed, getForeground, isCssColor, isParsableColor, parseColor } from '@/util'\n\n// Types\nimport type { CSSProperties, Ref } from 'vue'\n\ntype ColorValue = string | false | null | undefined\n\nexport interface TextColorData {\n  textColorClasses: Ref<string[]>\n  textColorStyles: Ref<CSSProperties>\n}\n\nexport interface BackgroundColorData {\n  backgroundColorClasses: Ref<string[]>\n  backgroundColorStyles: Ref<CSSProperties>\n}\n\n// Composables\nexport function useColor (colors: Ref<{ background?: ColorValue, text?: ColorValue }>) {\n  return destructComputed(() => {\n    const classes: string[] = []\n    const styles: CSSProperties = {}\n\n    if (colors.value.background) {\n      if (isCssColor(colors.value.background)) {\n        styles.backgroundColor = colors.value.background\n\n        if (!colors.value.text && isParsableColor(colors.value.background)) {\n          const backgroundColor = parseColor(colors.value.background)\n          if (backgroundColor.a == null || backgroundColor.a === 1) {\n            const textColor = getForeground(backgroundColor)\n\n            styles.color = textColor\n            styles.caretColor = textColor\n          }\n        }\n      } else {\n        classes.push(`bg-${colors.value.background}`)\n      }\n    }\n\n    if (colors.value.text) {\n      if (isCssColor(colors.value.text)) {\n        styles.color = colors.value.text\n        styles.caretColor = colors.value.text\n      } else {\n        classes.push(`text-${colors.value.text}`)\n      }\n    }\n\n    return { colorClasses: classes, colorStyles: styles }\n  })\n}\n\nexport function useTextColor (color: Ref<ColorValue>): TextColorData\nexport function useTextColor <T extends Record<K, ColorValue>, K extends string> (props: T, name: K): TextColorData\nexport function useTextColor <T extends Record<K, ColorValue>, K extends string> (\n  props: T | Ref<ColorValue>,\n  name?: K\n): TextColorData {\n  const colors = computed(() => ({\n    text: isRef(props) ? props.value : (name ? props[name] : null),\n  }))\n\n  const {\n    colorClasses: textColorClasses,\n    colorStyles: textColorStyles,\n  } = useColor(colors)\n\n  return { textColorClasses, textColorStyles }\n}\n\nexport function useBackgroundColor (color: Ref<ColorValue>): BackgroundColorData\nexport function useBackgroundColor <T extends Record<K, ColorValue>, K extends string> (props: T, name: K): BackgroundColorData\nexport function useBackgroundColor <T extends Record<K, ColorValue>, K extends string> (\n  props: T | Ref<ColorValue>,\n  name?: K\n): BackgroundColorData {\n  const colors = computed(() => ({\n    background: isRef(props) ? props.value : (name ? props[name] : null),\n  }))\n\n  const {\n    colorClasses: backgroundColorClasses,\n    colorStyles: backgroundColorStyles,\n  } = useColor(colors)\n\n  return { backgroundColorClasses, backgroundColorStyles }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;AAoBO,SAASA,SAAUC,QAA6D;AACrF,SAAOC,iBAAiB,MAAM;AAC5B,UAAMC,UAAoB,CAAA;AAC1B,UAAMC,SAAwB,CAAC;AAE/B,QAAIH,OAAOI,MAAMC,YAAY;AAC3B,UAAIC,WAAWN,OAAOI,MAAMC,UAAU,GAAG;AACvCF,eAAOI,kBAAkBP,OAAOI,MAAMC;AAEtC,YAAI,CAACL,OAAOI,MAAMI,QAAQC,gBAAgBT,OAAOI,MAAMC,UAAU,GAAG;AAClE,gBAAME,kBAAkBG,WAAWV,OAAOI,MAAMC,UAAU;AAC1D,cAAIE,gBAAgBI,KAAK,QAAQJ,gBAAgBI,MAAM,GAAG;AACxD,kBAAMC,YAAYC,cAAcN,eAAe;AAE/CJ,mBAAOW,QAAQF;AACfT,mBAAOY,aAAaH;UACtB;QACF;MACF,OAAO;AACLV,gBAAQc,KAAM,MAAKhB,OAAOI,MAAMC,UAAW,EAAC;MAC9C;IACF;AAEA,QAAIL,OAAOI,MAAMI,MAAM;AACrB,UAAIF,WAAWN,OAAOI,MAAMI,IAAI,GAAG;AACjCL,eAAOW,QAAQd,OAAOI,MAAMI;AAC5BL,eAAOY,aAAaf,OAAOI,MAAMI;MACnC,OAAO;AACLN,gBAAQc,KAAM,QAAOhB,OAAOI,MAAMI,IAAK,EAAC;MAC1C;IACF;AAEA,WAAO;MAAES,cAAcf;MAASgB,aAAaf;IAAO;EACtD,CAAC;AACH;AAIO,SAASgB,aACdC,OACAC,MACe;AACf,QAAMrB,SAASsB,SAAS,OAAO;IAC7Bd,MAAMe,MAAMH,KAAK,IAAIA,MAAMhB,QAASiB,OAAOD,MAAMC,IAAI,IAAI;EAC3D,EAAE;AAEF,QAAM;IACJJ,cAAcO;IACdN,aAAaO;EACf,IAAI1B,SAASC,MAAM;AAEnB,SAAO;IAAEwB;IAAkBC;EAAgB;AAC7C;AAIO,SAASC,mBACdN,OACAC,MACqB;AACrB,QAAMrB,SAASsB,SAAS,OAAO;IAC7BjB,YAAYkB,MAAMH,KAAK,IAAIA,MAAMhB,QAASiB,OAAOD,MAAMC,IAAI,IAAI;EACjE,EAAE;AAEF,QAAM;IACJJ,cAAcU;IACdT,aAAaU;EACf,IAAI7B,SAASC,MAAM;AAEnB,SAAO;IAAE2B;IAAwBC;EAAsB;AACzD;",
+  "names": ["useColor", "colors", "destructComputed", "classes", "styles", "value", "background", "isCssColor", "backgroundColor", "text", "isParsableColor", "parseColor", "a", "textColor", "getForeground", "color", "caretColor", "push", "colorClasses", "colorStyles", "useTextColor", "props", "name", "computed", "isRef", "textColorClasses", "textColorStyles", "useBackgroundColor", "backgroundColorClasses", "backgroundColorStyles"]
+}

VApp/node_modules/.vite/deps/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}