@nsshunt/stsvueutils 1.0.113 → 1.0.115

package/dist/stsvueutils.umd.js

@@ -1594,14 +1594,14 @@ var __privateMethod = (obj, member, method) => {
       const results = [];
       const chunks = arguments_.trim().split(/\s*,\s*/g);
       let matches;
-      for (const chunk2 of chunks) {
-        const number = Number(chunk2);
+      for (const chunk of chunks) {
+        const number = Number(chunk);
         if (!Number.isNaN(number)) {
           results.push(number);
-        } else if (matches = chunk2.match(STRING_REGEX)) {
+        } else if (matches = chunk.match(STRING_REGEX)) {
           results.push(matches[2].replace(ESCAPE_REGEX, (m, escape2, character) => escape2 ? unescape(escape2) : character));
         } else {
-          throw new Error(`Invalid Chalk template style argument: ${chunk2} (in style '${name}')`);
+          throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
         }
       }
       return results;
@@ -1643,27 +1643,27 @@ var __privateMethod = (obj, member, method) => {
     templates = (chalk2, temporary) => {
       const styles2 = [];
       const chunks = [];
-      let chunk2 = [];
+      let chunk = [];
       temporary.replace(TEMPLATE_REGEX, (m, escapeCharacter, inverse, style, close, character) => {
         if (escapeCharacter) {
-          chunk2.push(unescape(escapeCharacter));
+          chunk.push(unescape(escapeCharacter));
         } else if (style) {
-          const string = chunk2.join("");
-          chunk2 = [];
+          const string = chunk.join("");
+          chunk = [];
           chunks.push(styles2.length === 0 ? string : buildStyle(chalk2, styles2)(string));
           styles2.push({ inverse, styles: parseStyle(style) });
         } else if (close) {
           if (styles2.length === 0) {
             throw new Error("Found extraneous } in Chalk template literal");
           }
-          chunks.push(buildStyle(chalk2, styles2)(chunk2.join("")));
-          chunk2 = [];
+          chunks.push(buildStyle(chalk2, styles2)(chunk.join("")));
+          chunk = [];
           styles2.pop();
         } else {
-          chunk2.push(character);
+          chunk.push(character);
         }
       });
-      chunks.push(chunk2.join(""));
+      chunks.push(chunk.join(""));
       if (styles2.length > 0) {
         const errMessage = `Chalk template literal is missing ${styles2.length} closing bracket${styles2.length === 1 ? "" : "s"} (\`}\`)`;
         throw new Error(errMessage);
@@ -2466,4607 +2466,6 @@ var __privateMethod = (obj, member, method) => {
   _SetMessagePort = new WeakMap();
   _AddAsyncRunner = new WeakMap();
   _StopRunners = new WeakMap();
-  const IN_BROWSER = typeof window !== "undefined";
-  const SUPPORTS_INTERSECTION = IN_BROWSER && "IntersectionObserver" in window;
-  function deepEqual(a, b) {
-    if (a === b)
-      return true;
-    if (a instanceof Date && b instanceof Date && a.getTime() !== b.getTime()) {
-      return false;
-    }
-    if (a !== Object(a) || b !== Object(b)) {
-      return false;
-    }
-    const props = Object.keys(a);
-    if (props.length !== Object.keys(b).length) {
-      return false;
-    }
-    return props.every((p) => deepEqual(a[p], b[p]));
-  }
-  function createRange(length) {
-    let start = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
-    return Array.from({
-      length
-    }, (v, k) => start + k);
-  }
-  function convertToUnit(str) {
-    let unit = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "px";
-    if (str == null || str === "") {
-      return void 0;
-    } else if (isNaN(+str)) {
-      return String(str);
-    } else if (!isFinite(+str)) {
-      return void 0;
-    } else {
-      return `${Number(str)}${unit}`;
-    }
-  }
-  function isObject(obj) {
-    return obj !== null && typeof obj === "object" && !Array.isArray(obj);
-  }
-  const keyCodes = Object.freeze({
-    enter: 13,
-    tab: 9,
-    delete: 46,
-    esc: 27,
-    space: 32,
-    up: 38,
-    down: 40,
-    left: 37,
-    right: 39,
-    end: 35,
-    home: 36,
-    del: 46,
-    backspace: 8,
-    insert: 45,
-    pageup: 33,
-    pagedown: 34,
-    shift: 16
-  });
-  const keyValues = Object.freeze({
-    enter: "Enter",
-    tab: "Tab",
-    delete: "Delete",
-    esc: "Escape",
-    space: "Space",
-    up: "ArrowUp",
-    down: "ArrowDown",
-    left: "ArrowLeft",
-    right: "ArrowRight",
-    end: "End",
-    home: "Home",
-    del: "Delete",
-    backspace: "Backspace",
-    insert: "Insert",
-    pageup: "PageUp",
-    pagedown: "PageDown",
-    shift: "Shift"
-  });
-  function has(obj, key) {
-    return key.every((k) => obj.hasOwnProperty(k));
-  }
-  function pick(obj, paths) {
-    const found = {};
-    const keys = new Set(Object.keys(obj));
-    for (const path of paths) {
-      if (keys.has(path)) {
-        found[path] = obj[path];
-      }
-    }
-    return found;
-  }
-  function pickWithRest(obj, paths, exclude) {
-    const found = /* @__PURE__ */ Object.create(null);
-    const rest = /* @__PURE__ */ Object.create(null);
-    for (const key in obj) {
-      if (paths.some((path) => path instanceof RegExp ? path.test(key) : path === key) && !(exclude == null ? void 0 : exclude.some((path) => path === key))) {
-        found[key] = obj[key];
-      } else {
-        rest[key] = obj[key];
-      }
-    }
-    return [found, rest];
-  }
-  function omit(obj, exclude) {
-    const clone = {
-      ...obj
-    };
-    exclude.forEach((prop) => delete clone[prop]);
-    return clone;
-  }
-  const onRE = /^on[^a-z]/;
-  const isOn = (key) => onRE.test(key);
-  const bubblingEvents = ["onAfterscriptexecute", "onAnimationcancel", "onAnimationend", "onAnimationiteration", "onAnimationstart", "onAuxclick", "onBeforeinput", "onBeforescriptexecute", "onChange", "onClick", "onCompositionend", "onCompositionstart", "onCompositionupdate", "onContextmenu", "onCopy", "onCut", "onDblclick", "onFocusin", "onFocusout", "onFullscreenchange", "onFullscreenerror", "onGesturechange", "onGestureend", "onGesturestart", "onGotpointercapture", "onInput", "onKeydown", "onKeypress", "onKeyup", "onLostpointercapture", "onMousedown", "onMousemove", "onMouseout", "onMouseover", "onMouseup", "onMousewheel", "onPaste", "onPointercancel", "onPointerdown", "onPointerenter", "onPointerleave", "onPointermove", "onPointerout", "onPointerover", "onPointerup", "onReset", "onSelect", "onSubmit", "onTouchcancel", "onTouchend", "onTouchmove", "onTouchstart", "onTransitioncancel", "onTransitionend", "onTransitionrun", "onTransitionstart", "onWheel"];
-  function filterInputAttrs(attrs) {
-    const [events, props] = pickWithRest(attrs, [onRE]);
-    const inputEvents = omit(events, bubblingEvents);
-    const [rootAttrs, inputAttrs] = pickWithRest(props, ["class", "style", "id", /^data-/]);
-    Object.assign(rootAttrs, events);
-    Object.assign(inputAttrs, inputEvents);
-    return [rootAttrs, inputAttrs];
-  }
-  function wrapInArray(v) {
-    return v == null ? [] : Array.isArray(v) ? v : [v];
-  }
-  function clamp(value) {
-    let min = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
-    let max = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 1;
-    return Math.max(min, Math.min(max, value));
-  }
-  function getDecimals(value) {
-    const trimmedStr = value.toString().trim();
-    return trimmedStr.includes(".") ? trimmedStr.length - trimmedStr.indexOf(".") - 1 : 0;
-  }
-  function padEnd(str, length) {
-    let char = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "0";
-    return str + char.repeat(Math.max(0, length - str.length));
-  }
-  function chunk(str) {
-    let size = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 1;
-    const chunked = [];
-    let index = 0;
-    while (index < str.length) {
-      chunked.push(str.substr(index, size));
-      index += size;
-    }
-    return chunked;
-  }
-  function mergeDeep() {
-    let source2 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
-    let target = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
-    let arrayFn = arguments.length > 2 ? arguments[2] : void 0;
-    const out = {};
-    for (const key in source2) {
-      out[key] = source2[key];
-    }
-    for (const key in target) {
-      const sourceProperty = source2[key];
-      const targetProperty = target[key];
-      if (isObject(sourceProperty) && isObject(targetProperty)) {
-        out[key] = mergeDeep(sourceProperty, targetProperty, arrayFn);
-        continue;
-      }
-      if (Array.isArray(sourceProperty) && Array.isArray(targetProperty) && arrayFn) {
-        out[key] = arrayFn(sourceProperty, targetProperty);
-        continue;
-      }
-      out[key] = targetProperty;
-    }
-    return out;
-  }
-  function flattenFragments(nodes) {
-    return nodes.map((node) => {
-      if (node.type === vue.Fragment) {
-        return flattenFragments(node.children);
-      } else {
-        return node;
-      }
-    }).flat();
-  }
-  function toKebabCase() {
-    let str = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "";
-    if (toKebabCase.cache.has(str))
-      return toKebabCase.cache.get(str);
-    const kebab = str.replace(/[^a-z]/gi, "-").replace(/\B([A-Z])/g, "-$1").toLowerCase();
-    toKebabCase.cache.set(str, kebab);
-    return kebab;
-  }
-  toKebabCase.cache = /* @__PURE__ */ new Map();
-  function destructComputed(getter) {
-    const refs = vue.reactive({});
-    const base = vue.computed(getter);
-    vue.watchEffect(() => {
-      for (const key in base.value) {
-        refs[key] = base.value[key];
-      }
-    }, {
-      flush: "sync"
-    });
-    return vue.toRefs(refs);
-  }
-  function includes(arr, val) {
-    return arr.includes(val);
-  }
-  const EventProp = () => [Function, Array];
-  function callEvent(handler) {
-    for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
-      args[_key2 - 1] = arguments[_key2];
-    }
-    if (Array.isArray(handler)) {
-      for (const h of handler) {
-        h(...args);
-      }
-    } else if (typeof handler === "function") {
-      handler(...args);
-    }
-  }
-  function matchesSelector(el, selector) {
-    const supportsSelector = IN_BROWSER && typeof CSS !== "undefined" && typeof CSS.supports !== "undefined" && CSS.supports(`selector(${selector})`);
-    if (!supportsSelector)
-      return null;
-    try {
-      return !!el && el.matches(selector);
-    } catch (err) {
-      return null;
-    }
-  }
-  const block = ["top", "bottom"];
-  const inline = ["start", "end", "left", "right"];
-  function parseAnchor(anchor, isRtl) {
-    let [side, align] = anchor.split(" ");
-    if (!align) {
-      align = includes(block, side) ? "start" : includes(inline, side) ? "top" : "center";
-    }
-    return {
-      side: toPhysical(side, isRtl),
-      align: toPhysical(align, isRtl)
-    };
-  }
-  function toPhysical(str, isRtl) {
-    if (str === "start")
-      return isRtl ? "right" : "left";
-    if (str === "end")
-      return isRtl ? "left" : "right";
-    return str;
-  }
-  class Box {
-    constructor(_ref) {
-      let {
-        x,
-        y,
-        width,
-        height
-      } = _ref;
-      this.x = x;
-      this.y = y;
-      this.width = width;
-      this.height = height;
-    }
-    get top() {
-      return this.y;
-    }
-    get bottom() {
-      return this.y + this.height;
-    }
-    get left() {
-      return this.x;
-    }
-    get right() {
-      return this.x + this.width;
-    }
-  }
-  function nullifyTransforms(el) {
-    const rect = el.getBoundingClientRect();
-    const style = getComputedStyle(el);
-    const tx = style.transform;
-    if (tx) {
-      let ta, sx, sy, dx, dy;
-      if (tx.startsWith("matrix3d(")) {
-        ta = tx.slice(9, -1).split(/, /);
-        sx = +ta[0];
-        sy = +ta[5];
-        dx = +ta[12];
-        dy = +ta[13];
-      } else if (tx.startsWith("matrix(")) {
-        ta = tx.slice(7, -1).split(/, /);
-        sx = +ta[0];
-        sy = +ta[3];
-        dx = +ta[4];
-        dy = +ta[5];
-      } else {
-        return new Box(rect);
-      }
-      const to = style.transformOrigin;
-      const x = rect.x - dx - (1 - sx) * parseFloat(to);
-      const y = rect.y - dy - (1 - sy) * parseFloat(to.slice(to.indexOf(" ") + 1));
-      const w = sx ? rect.width / sx : el.offsetWidth + 1;
-      const h = sy ? rect.height / sy : el.offsetHeight + 1;
-      return new Box({
-        x,
-        y,
-        width: w,
-        height: h
-      });
-    } else {
-      return new Box(rect);
-    }
-  }
-  function animate(el, keyframes, options) {
-    if (typeof el.animate === "undefined")
-      return {
-        finished: Promise.resolve()
-      };
-    let animation;
-    try {
-      animation = el.animate(keyframes, options);
-    } catch (err) {
-      return {
-        finished: Promise.resolve()
-      };
-    }
-    if (typeof animation.finished === "undefined") {
-      animation.finished = new Promise((resolve) => {
-        animation.onfinish = () => {
-          resolve(animation);
-        };
-      });
-    }
-    return animation;
-  }
-  const mainTRC = 2.4;
-  const Rco = 0.2126729;
-  const Gco = 0.7151522;
-  const Bco = 0.072175;
-  const normBG = 0.55;
-  const normTXT = 0.58;
-  const revTXT = 0.57;
-  const revBG = 0.62;
-  const blkThrs = 0.03;
-  const blkClmp = 1.45;
-  const deltaYmin = 5e-4;
-  const scaleBoW = 1.25;
-  const scaleWoB = 1.25;
-  const loConThresh = 0.078;
-  const loConFactor = 12.82051282051282;
-  const loConOffset = 0.06;
-  const loClip = 1e-3;
-  function APCAcontrast(text, background) {
-    const Rtxt = (text.r / 255) ** mainTRC;
-    const Gtxt = (text.g / 255) ** mainTRC;
-    const Btxt = (text.b / 255) ** mainTRC;
-    const Rbg = (background.r / 255) ** mainTRC;
-    const Gbg = (background.g / 255) ** mainTRC;
-    const Bbg = (background.b / 255) ** mainTRC;
-    let Ytxt = Rtxt * Rco + Gtxt * Gco + Btxt * Bco;
-    let Ybg = Rbg * Rco + Gbg * Gco + Bbg * Bco;
-    if (Ytxt <= blkThrs)
-      Ytxt += (blkThrs - Ytxt) ** blkClmp;
-    if (Ybg <= blkThrs)
-      Ybg += (blkThrs - Ybg) ** blkClmp;
-    if (Math.abs(Ybg - Ytxt) < deltaYmin)
-      return 0;
-    let outputContrast;
-    if (Ybg > Ytxt) {
-      const SAPC = (Ybg ** normBG - Ytxt ** normTXT) * scaleBoW;
-      outputContrast = SAPC < loClip ? 0 : SAPC < loConThresh ? SAPC - SAPC * loConFactor * loConOffset : SAPC - loConOffset;
-    } else {
-      const SAPC = (Ybg ** revBG - Ytxt ** revTXT) * scaleWoB;
-      outputContrast = SAPC > -loClip ? 0 : SAPC > -loConThresh ? SAPC - SAPC * loConFactor * loConOffset : SAPC + loConOffset;
-    }
-    return outputContrast * 100;
-  }
-  function consoleWarn(message) {
-    vue.warn(`Vuetify: ${message}`);
-  }
-  function isCssColor(color) {
-    return !!color && /^(#|var\(--|(rgb|hsl)a?\()/.test(color);
-  }
-  function isParsableColor(color) {
-    return isCssColor(color) && !/^((rgb|hsl)a?\()?var\(--/.test(color);
-  }
-  const cssColorRe = /^(?<fn>(?:rgb|hsl)a?)\((?<values>.+)\)/;
-  const mappers = {
-    rgb: (r, g, b, a) => ({
-      r,
-      g,
-      b,
-      a
-    }),
-    rgba: (r, g, b, a) => ({
-      r,
-      g,
-      b,
-      a
-    }),
-    hsl: (h, s, l, a) => HSLtoRGB({
-      h,
-      s,
-      l,
-      a
-    }),
-    hsla: (h, s, l, a) => HSLtoRGB({
-      h,
-      s,
-      l,
-      a
-    }),
-    hsv: (h, s, v, a) => HSVtoRGB({
-      h,
-      s,
-      v,
-      a
-    }),
-    hsva: (h, s, v, a) => HSVtoRGB({
-      h,
-      s,
-      v,
-      a
-    })
-  };
-  function parseColor(color) {
-    if (typeof color === "number") {
-      if (isNaN(color) || color < 0 || color > 16777215) {
-        consoleWarn(`'${color}' is not a valid hex color`);
-      }
-      return {
-        r: (color & 16711680) >> 16,
-        g: (color & 65280) >> 8,
-        b: color & 255
-      };
-    } else if (typeof color === "string" && cssColorRe.test(color)) {
-      const {
-        groups
-      } = color.match(cssColorRe);
-      const {
-        fn,
-        values
-      } = groups;
-      const realValues = values.split(/,\s*/).map((v) => {
-        if (v.endsWith("%") && ["hsl", "hsla", "hsv", "hsva"].includes(fn)) {
-          return parseFloat(v) / 100;
-        } else {
-          return parseFloat(v);
-        }
-      });
-      return mappers[fn](...realValues);
-    } else if (typeof color === "string") {
-      let hex = color.startsWith("#") ? color.slice(1) : color;
-      if ([3, 4].includes(hex.length)) {
-        hex = hex.split("").map((char) => char + char).join("");
-      } else if (![6, 8].includes(hex.length)) {
-        consoleWarn(`'${color}' is not a valid hex(a) color`);
-      }
-      const int = parseInt(hex, 16);
-      if (isNaN(int) || int < 0 || int > 4294967295) {
-        consoleWarn(`'${color}' is not a valid hex(a) color`);
-      }
-      return HexToRGB(hex);
-    } else if (typeof color === "object") {
-      if (has(color, ["r", "g", "b"])) {
-        return color;
-      } else if (has(color, ["h", "s", "l"])) {
-        return HSVtoRGB(HSLtoHSV(color));
-      } else if (has(color, ["h", "s", "v"])) {
-        return HSVtoRGB(color);
-      }
-    }
-    throw new TypeError(`Invalid color: ${color == null ? color : String(color) || color.constructor.name}
-Expected #hex, #hexa, rgb(), rgba(), hsl(), hsla(), object or number`);
-  }
-  function HSVtoRGB(hsva) {
-    const {
-      h,
-      s,
-      v,
-      a
-    } = hsva;
-    const f = (n) => {
-      const k = (n + h / 60) % 6;
-      return v - v * s * Math.max(Math.min(k, 4 - k, 1), 0);
-    };
-    const rgb = [f(5), f(3), f(1)].map((v2) => Math.round(v2 * 255));
-    return {
-      r: rgb[0],
-      g: rgb[1],
-      b: rgb[2],
-      a
-    };
-  }
-  function HSLtoRGB(hsla) {
-    return HSVtoRGB(HSLtoHSV(hsla));
-  }
-  function HSLtoHSV(hsl) {
-    const {
-      h,
-      s,
-      l,
-      a
-    } = hsl;
-    const v = l + s * Math.min(l, 1 - l);
-    const sprime = v === 0 ? 0 : 2 - 2 * l / v;
-    return {
-      h,
-      s: sprime,
-      v,
-      a
-    };
-  }
-  function HexToRGB(hex) {
-    hex = parseHex(hex);
-    let [r, g, b, a] = chunk(hex, 2).map((c) => parseInt(c, 16));
-    a = a === void 0 ? a : a / 255;
-    return {
-      r,
-      g,
-      b,
-      a
-    };
-  }
-  function parseHex(hex) {
-    if (hex.startsWith("#")) {
-      hex = hex.slice(1);
-    }
-    hex = hex.replace(/([^0-9a-f])/gi, "F");
-    if (hex.length === 3 || hex.length === 4) {
-      hex = hex.split("").map((x) => x + x).join("");
-    }
-    if (hex.length !== 6) {
-      hex = padEnd(padEnd(hex, 6), 8, "F");
-    }
-    return hex;
-  }
-  function getForeground(color) {
-    const blackContrast = Math.abs(APCAcontrast(parseColor(0), parseColor(color)));
-    const whiteContrast = Math.abs(APCAcontrast(parseColor(16777215), parseColor(color)));
-    return whiteContrast > Math.min(blackContrast, 50) ? "#fff" : "#000";
-  }
-  function propsFactory(props, source2) {
-    return (defaults) => {
-      return Object.keys(props).reduce((obj, prop) => {
-        const isObjectDefinition = typeof props[prop] === "object" && props[prop] != null && !Array.isArray(props[prop]);
-        const definition = isObjectDefinition ? props[prop] : {
-          type: props[prop]
-        };
-        if (defaults && prop in defaults) {
-          obj[prop] = {
-            ...definition,
-            default: defaults[prop]
-          };
-        } else {
-          obj[prop] = definition;
-        }
-        if (source2 && !obj[prop].source) {
-          obj[prop].source = source2;
-        }
-        return obj;
-      }, {});
-    };
-  }
-  const makeComponentProps = propsFactory({
-    class: [String, Array],
-    style: {
-      type: [String, Array, Object],
-      default: null
-    }
-  }, "component");
-  const DefaultsSymbol = Symbol.for("vuetify:defaults");
-  function injectDefaults() {
-    const defaults = vue.inject(DefaultsSymbol);
-    if (!defaults)
-      throw new Error("[Vuetify] Could not find defaults instance");
-    return defaults;
-  }
-  function provideDefaults(defaults, options) {
-    const injectedDefaults = injectDefaults();
-    const providedDefaults = vue.ref(defaults);
-    const newDefaults = vue.computed(() => {
-      const disabled = vue.unref(options == null ? void 0 : options.disabled);
-      if (disabled)
-        return injectedDefaults.value;
-      const scoped = vue.unref(options == null ? void 0 : options.scoped);
-      const reset = vue.unref(options == null ? void 0 : options.reset);
-      const root = vue.unref(options == null ? void 0 : options.root);
-      if (providedDefaults.value == null && !(scoped || reset || root))
-        return injectedDefaults.value;
-      let properties = mergeDeep(providedDefaults.value, {
-        prev: injectedDefaults.value
-      });
-      if (scoped)
-        return properties;
-      if (reset || root) {
-        const len = Number(reset || Infinity);
-        for (let i = 0; i <= len; i++) {
-          if (!properties || !("prev" in properties)) {
-            break;
-          }
-          properties = properties.prev;
-        }
-        if (properties && typeof root === "string" && root in properties) {
-          properties = mergeDeep(mergeDeep(properties, {
-            prev: properties
-          }), properties[root]);
-        }
-        return properties;
-      }
-      return properties.prev ? mergeDeep(properties.prev, properties) : properties;
-    });
-    vue.provide(DefaultsSymbol, newDefaults);
-    return newDefaults;
-  }
-  function propIsDefined(vnode, prop) {
-    var _a, _b;
-    return typeof ((_a = vnode.props) == null ? void 0 : _a[prop]) !== "undefined" || typeof ((_b = vnode.props) == null ? void 0 : _b[toKebabCase(prop)]) !== "undefined";
-  }
-  function internalUseDefaults() {
-    let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
-    let name = arguments.length > 1 ? arguments[1] : void 0;
-    let defaults = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : injectDefaults();
-    const vm = getCurrentInstance("useDefaults");
-    name = name ?? vm.type.name ?? vm.type.__name;
-    if (!name) {
-      throw new Error("[Vuetify] Could not determine component name");
-    }
-    const componentDefaults = vue.computed(() => {
-      var _a;
-      return (_a = defaults.value) == null ? void 0 : _a[props._as ?? name];
-    });
-    const _props = new Proxy(props, {
-      get(target, prop) {
-        var _a, _b, _c, _d;
-        const propValue = Reflect.get(target, prop);
-        if (prop === "class" || prop === "style") {
-          return [(_a = componentDefaults.value) == null ? void 0 : _a[prop], propValue].filter((v) => v != null);
-        } else if (typeof prop === "string" && !propIsDefined(vm.vnode, prop)) {
-          return ((_b = componentDefaults.value) == null ? void 0 : _b[prop]) ?? ((_d = (_c = defaults.value) == null ? void 0 : _c.global) == null ? void 0 : _d[prop]) ?? propValue;
-        }
-        return propValue;
-      }
-    });
-    const _subcomponentDefaults = vue.shallowRef();
-    vue.watchEffect(() => {
-      if (componentDefaults.value) {
-        const subComponents = Object.entries(componentDefaults.value).filter((_ref) => {
-          let [key] = _ref;
-          return key.startsWith(key[0].toUpperCase());
-        });
-        _subcomponentDefaults.value = subComponents.length ? Object.fromEntries(subComponents) : void 0;
-      } else {
-        _subcomponentDefaults.value = void 0;
-      }
-    });
-    function provideSubDefaults() {
-      const injected = injectSelf(DefaultsSymbol, vm);
-      vue.provide(DefaultsSymbol, vue.computed(() => {
-        return _subcomponentDefaults.value ? mergeDeep((injected == null ? void 0 : injected.value) ?? {}, _subcomponentDefaults.value) : injected == null ? void 0 : injected.value;
-      }));
-    }
-    return {
-      props: _props,
-      provideSubDefaults
-    };
-  }
-  function defineComponent(options) {
-    options._setup = options._setup ?? options.setup;
-    if (!options.name) {
-      consoleWarn("The component is missing an explicit name, unable to generate default prop value");
-      return options;
-    }
-    if (options._setup) {
-      options.props = propsFactory(options.props ?? {}, options.name)();
-      const propKeys = Object.keys(options.props).filter((key) => key !== "class" && key !== "style");
-      options.filterProps = function filterProps(props) {
-        return pick(props, propKeys);
-      };
-      options.props._as = String;
-      options.setup = function setup(props, ctx) {
-        const defaults = injectDefaults();
-        if (!defaults.value)
-          return options._setup(props, ctx);
-        const {
-          props: _props,
-          provideSubDefaults
-        } = internalUseDefaults(props, props._as ?? options.name, defaults);
-        const setupBindings = options._setup(_props, ctx);
-        provideSubDefaults();
-        return setupBindings;
-      };
-    }
-    return options;
-  }
-  function genericComponent() {
-    let exposeDefaults = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
-    return (options) => (exposeDefaults ? defineComponent : vue.defineComponent)(options);
-  }
-  const standardEasing = "cubic-bezier(0.4, 0, 0.2, 1)";
-  function getCurrentInstance(name, message) {
-    const vm = vue.getCurrentInstance();
-    if (!vm) {
-      throw new Error(`[Vuetify] ${name} ${message || "must be called from inside a setup function"}`);
-    }
-    return vm;
-  }
-  function getCurrentInstanceName() {
-    let name = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "composables";
-    const vm = getCurrentInstance(name).type;
-    return toKebabCase((vm == null ? void 0 : vm.aliasName) || (vm == null ? void 0 : vm.name));
-  }
-  let _uid = 0;
-  let _map = /* @__PURE__ */ new WeakMap();
-  function getUid() {
-    const vm = getCurrentInstance("getUid");
-    if (_map.has(vm))
-      return _map.get(vm);
-    else {
-      const uid = _uid++;
-      _map.set(vm, uid);
-      return uid;
-    }
-  }
-  getUid.reset = () => {
-    _uid = 0;
-    _map = /* @__PURE__ */ new WeakMap();
-  };
-  function injectSelf(key) {
-    let vm = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : getCurrentInstance("injectSelf");
-    const {
-      provides
-    } = vm;
-    if (provides && key in provides) {
-      return provides[key];
-    }
-    return void 0;
-  }
-  function useRender(render) {
-    const vm = getCurrentInstance("useRender");
-    vm.render = render;
-  }
-  function useColor(colors) {
-    return destructComputed(() => {
-      const classes = [];
-      const styles2 = {};
-      if (colors.value.background) {
-        if (isCssColor(colors.value.background)) {
-          styles2.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);
-              styles2.color = textColor;
-              styles2.caretColor = textColor;
-            }
-          }
-        } else {
-          classes.push(`bg-${colors.value.background}`);
-        }
-      }
-      if (colors.value.text) {
-        if (isCssColor(colors.value.text)) {
-          styles2.color = colors.value.text;
-          styles2.caretColor = colors.value.text;
-        } else {
-          classes.push(`text-${colors.value.text}`);
-        }
-      }
-      return {
-        colorClasses: classes,
-        colorStyles: styles2
-      };
-    });
-  }
-  function useTextColor(props, name) {
-    const colors = vue.computed(() => ({
-      text: vue.isRef(props) ? props.value : name ? props[name] : null
-    }));
-    const {
-      colorClasses: textColorClasses,
-      colorStyles: textColorStyles
-    } = useColor(colors);
-    return {
-      textColorClasses,
-      textColorStyles
-    };
-  }
-  function useBackgroundColor(props, name) {
-    const colors = vue.computed(() => ({
-      background: vue.isRef(props) ? props.value : name ? props[name] : null
-    }));
-    const {
-      colorClasses: backgroundColorClasses,
-      colorStyles: backgroundColorStyles
-    } = useColor(colors);
-    return {
-      backgroundColorClasses,
-      backgroundColorStyles
-    };
-  }
-  const IconValue = [String, Function, Object, Array];
-  const IconSymbol = Symbol.for("vuetify:icons");
-  const 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");
-  const VComponentIcon = genericComponent()({
-    name: "VComponentIcon",
-    props: makeIconProps(),
-    setup(props, _ref) {
-      let {
-        slots
-      } = _ref;
-      return () => {
-        const Icon = props.icon;
-        return vue.createVNode(props.tag, null, {
-          default: () => {
-            var _a;
-            return [props.icon ? vue.createVNode(Icon, null, null) : (_a = slots.default) == null ? void 0 : _a.call(slots)];
-          }
-        });
-      };
-    }
-  });
-  const VSvgIcon = defineComponent({
-    name: "VSvgIcon",
-    inheritAttrs: false,
-    props: makeIconProps(),
-    setup(props, _ref2) {
-      let {
-        attrs
-      } = _ref2;
-      return () => {
-        return vue.createVNode(props.tag, vue.mergeProps(attrs, {
-          "style": null
-        }), {
-          default: () => [vue.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) ? vue.createVNode("path", {
-            "d": path[0],
-            "fill-opacity": path[1]
-          }, null) : vue.createVNode("path", {
-            "d": path
-          }, null)) : vue.createVNode("path", {
-            "d": props.icon
-          }, null)])]
-        });
-      };
-    }
-  });
-  defineComponent({
-    name: "VLigatureIcon",
-    props: makeIconProps(),
-    setup(props) {
-      return () => {
-        return vue.createVNode(props.tag, null, {
-          default: () => [props.icon]
-        });
-      };
-    }
-  });
-  defineComponent({
-    name: "VClassIcon",
-    props: makeIconProps(),
-    setup(props) {
-      return () => {
-        return vue.createVNode(props.tag, {
-          "class": props.icon
-        }, null);
-      };
-    }
-  });
-  const useIcon = (props) => {
-    const icons = vue.inject(IconSymbol);
-    if (!icons)
-      throw new Error("Missing Vuetify Icons provide!");
-    const iconData = vue.computed(() => {
-      var _a;
-      const iconAlias = vue.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
-    };
-  };
-  const predefinedSizes = ["x-small", "small", "default", "large", "x-large"];
-  const 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
-      };
-    });
-  }
-  const makeTagProps = propsFactory({
-    tag: {
-      type: String,
-      default: "div"
-    }
-  }, "tag");
-  const ThemeSymbol = Symbol.for("vuetify:theme");
-  const makeThemeProps = propsFactory({
-    theme: String
-  }, "theme");
-  function provideTheme(props) {
-    getCurrentInstance("provideTheme");
-    const theme = vue.inject(ThemeSymbol, null);
-    if (!theme)
-      throw new Error("Could not find Vuetify theme injection");
-    const name = vue.computed(() => {
-      return props.theme ?? theme.name.value;
-    });
-    const current = vue.computed(() => theme.themes.value[name.value]);
-    const themeClasses = vue.computed(() => theme.isDisabled ? void 0 : `v-theme--${name.value}`);
-    const newTheme = {
-      ...theme,
-      name,
-      current,
-      themeClasses
-    };
-    vue.provide(ThemeSymbol, newTheme);
-    return newTheme;
-  }
-  const makeVIconProps = propsFactory({
-    color: String,
-    disabled: Boolean,
-    start: Boolean,
-    end: Boolean,
-    icon: IconValue,
-    ...makeComponentProps(),
-    ...makeSizeProps(),
-    ...makeTagProps({
-      tag: "i"
-    }),
-    ...makeThemeProps()
-  }, "VIcon");
-  const VIcon = genericComponent()({
-    name: "VIcon",
-    props: makeVIconProps(),
-    setup(props, _ref) {
-      let {
-        attrs,
-        slots
-      } = _ref;
-      const slotIcon = vue.ref();
-      const {
-        themeClasses
-      } = provideTheme(props);
-      const {
-        iconData
-      } = useIcon(vue.computed(() => slotIcon.value || props.icon));
-      const {
-        sizeClasses
-      } = useSize(props);
-      const {
-        textColorClasses,
-        textColorStyles
-      } = useTextColor(vue.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 === vue.Text && node.children && typeof node.children === "string")[0]) == null ? void 0 : _b.children;
-        }
-        const hasClick = !!(attrs.onClick || attrs.onClickOnce);
-        return vue.createVNode(iconData.value.component, {
-          "tag": props.tag,
-          "icon": iconData.value.icon,
-          "class": ["v-icon", "notranslate", themeClasses.value, sizeClasses.value, textColorClasses.value, {
-            "v-icon--clickable": hasClick,
-            "v-icon--disabled": props.disabled,
-            "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": hasClick ? "button" : void 0,
-          "aria-hidden": !hasClick,
-          "tabindex": hasClick ? props.disabled ? -1 : 0 : void 0
-        }, {
-          default: () => [slotValue]
-        });
-      });
-      return {};
-    }
-  });
-  const makeVLabelProps = propsFactory({
-    text: String,
-    onClick: EventProp(),
-    ...makeComponentProps(),
-    ...makeThemeProps()
-  }, "VLabel");
-  const VLabel = genericComponent()({
-    name: "VLabel",
-    props: makeVLabelProps(),
-    setup(props, _ref) {
-      let {
-        slots
-      } = _ref;
-      useRender(() => {
-        var _a;
-        return vue.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 {};
-    }
-  });
-  const allowedDensities = [null, "default", "comfortable", "compact"];
-  const 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 = vue.computed(() => {
-      return `${name}--density-${props.density}`;
-    });
-    return {
-      densityClasses
-    };
-  }
-  function useToggleScope(source2, fn) {
-    let scope;
-    function start() {
-      scope = vue.effectScope();
-      scope.run(() => fn.length ? fn(() => {
-        scope == null ? void 0 : scope.stop();
-        start();
-      }) : fn());
-    }
-    vue.watch(source2, (active) => {
-      if (active && !scope) {
-        start();
-      } else if (!active) {
-        scope == null ? void 0 : scope.stop();
-        scope = void 0;
-      }
-    }, {
-      immediate: true
-    });
-    vue.onScopeDispose(() => {
-      scope == null ? void 0 : scope.stop();
-    });
-  }
-  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 = vue.ref(props[prop] !== void 0 ? props[prop] : defaultValue);
-    const kebabProp = toKebabCase(prop);
-    const checkKebab = kebabProp !== prop;
-    const isControlled = checkKebab ? vue.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}`))));
-    }) : vue.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, () => {
-      vue.watch(() => props[prop], (val) => {
-        internal.value = val;
-      });
-    });
-    const model = vue.computed({
-      get() {
-        const externalValue = props[prop];
-        return transformIn(isControlled.value ? externalValue : internal.value);
-      },
-      set(internalValue) {
-        const newValue = transformOut(internalValue);
-        const value = vue.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;
-  }
-  const VSelectionControlGroupSymbol = Symbol.for("vuetify:selection-control-group");
-  const makeSelectionControlGroupProps = propsFactory({
-    color: String,
-    disabled: {
-      type: Boolean,
-      default: null
-    },
-    defaultsTarget: String,
-    error: Boolean,
-    id: String,
-    inline: Boolean,
-    falseIcon: IconValue,
-    trueIcon: IconValue,
-    ripple: {
-      type: [Boolean, Object],
-      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");
-  const makeVSelectionControlGroupProps = propsFactory({
-    ...makeSelectionControlGroupProps({
-      defaultsTarget: "VSelectionControl"
-    })
-  }, "VSelectionControlGroup");
-  const 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 = vue.computed(() => props.id || `v-selection-control-group-${uid}`);
-      const name = vue.computed(() => props.name || id.value);
-      const updateHandlers = /* @__PURE__ */ new Set();
-      vue.provide(VSelectionControlGroupSymbol, {
-        modelValue,
-        forceUpdate: () => {
-          updateHandlers.forEach((fn) => fn());
-        },
-        onForceUpdate: (cb) => {
-          updateHandlers.add(cb);
-          vue.onScopeDispose(() => {
-            updateHandlers.delete(cb);
-          });
-        }
-      });
-      provideDefaults({
-        [props.defaultsTarget]: {
-          color: vue.toRef(props, "color"),
-          disabled: vue.toRef(props, "disabled"),
-          density: vue.toRef(props, "density"),
-          error: vue.toRef(props, "error"),
-          inline: vue.toRef(props, "inline"),
-          modelValue,
-          multiple: vue.computed(() => !!props.multiple || props.multiple == null && Array.isArray(modelValue.value)),
-          name,
-          falseIcon: vue.toRef(props, "falseIcon"),
-          trueIcon: vue.toRef(props, "trueIcon"),
-          readonly: vue.toRef(props, "readonly"),
-          ripple: vue.toRef(props, "ripple"),
-          type: vue.toRef(props, "type"),
-          valueComparator: vue.toRef(props, "valueComparator")
-        }
-      });
-      useRender(() => {
-        var _a;
-        return vue.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 {};
-    }
-  });
-  const stopSymbol = Symbol("rippleStop");
-  const 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";
-  }
-  const 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
-    };
-  };
-  const 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);
-  }
-  let 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$1(el, binding) {
-    updateRipple(el, binding, false);
-  }
-  function unmounted$1(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);
-  }
-  const Ripple = {
-    mounted: mounted$1,
-    unmounted: unmounted$1,
-    updated
-  };
-  const makeVSelectionControlProps = propsFactory({
-    label: String,
-    baseColor: String,
-    trueValue: null,
-    falseValue: null,
-    value: null,
-    ...makeComponentProps(),
-    ...makeSelectionControlGroupProps()
-  }, "VSelectionControl");
-  function useSelectionControl(props) {
-    const group = vue.inject(VSelectionControlGroupSymbol, void 0);
-    const {
-      densityClasses
-    } = useDensity(props);
-    const modelValue = useProxiedModel(props, "modelValue");
-    const trueValue = vue.computed(() => props.trueValue !== void 0 ? props.trueValue : props.value !== void 0 ? props.value : true);
-    const falseValue = vue.computed(() => props.falseValue !== void 0 ? props.falseValue : false);
-    const isMultiple = vue.computed(() => !!props.multiple || props.multiple == null && Array.isArray(modelValue.value));
-    const model = vue.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(vue.computed(() => {
-      if (props.error || props.disabled)
-        return void 0;
-      return model.value ? props.color : props.baseColor;
-    }));
-    const {
-      backgroundColorClasses,
-      backgroundColorStyles
-    } = useBackgroundColor(vue.computed(() => {
-      return model.value && !props.error && !props.disabled ? props.color : void 0;
-    }));
-    const icon = vue.computed(() => model.value ? props.trueIcon : props.falseIcon);
-    return {
-      group,
-      densityClasses,
-      trueValue,
-      falseValue,
-      model,
-      textColorClasses,
-      textColorStyles,
-      backgroundColorClasses,
-      backgroundColorStyles,
-      icon
-    };
-  }
-  const 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 = vue.shallowRef(false);
-      const isFocusVisible = vue.shallowRef(false);
-      const input = vue.ref();
-      const id = vue.computed(() => props.id || `input-${uid}`);
-      const isInteractive = vue.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) {
-          vue.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 = vue.createVNode("input", vue.mergeProps({
-          "ref": input,
-          "checked": model.value,
-          "disabled": !!props.disabled,
-          "id": id.value,
-          "onBlur": onBlur,
-          "onFocus": onFocus,
-          "onInput": onInput,
-          "aria-disabled": !!props.disabled,
-          "aria-label": props.label,
-          "type": props.type,
-          "value": trueValue.value,
-          "name": props.name,
-          "aria-checked": props.type === "checkbox" ? model.value : void 0
-        }, inputAttrs), null);
-        return vue.createVNode("div", vue.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
-        }), [vue.createVNode("div", {
-          "class": ["v-selection-control__wrapper", textColorClasses.value],
-          "style": textColorStyles.value
-        }, [(_a = slots.default) == null ? void 0 : _a.call(slots, {
-          backgroundColorClasses,
-          backgroundColorStyles
-        }), vue.withDirectives(vue.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
-          }
-        })) ?? vue.createVNode(vue.Fragment, null, [icon.value && vue.createVNode(VIcon, {
-          "key": "icon",
-          "icon": icon.value
-        }, null), inputNode])]), [[vue.resolveDirective("ripple"), props.ripple && [!props.disabled && !props.readonly, null, ["center", "circle"]]]])]), label && vue.createVNode(VLabel, {
-          "for": id.value,
-          "onClick": onClickLabel
-        }, {
-          default: () => [label]
-        })]);
-      });
-      return {
-        isFocused,
-        input
-      };
-    }
-  });
-  const makeVCheckboxBtnProps = propsFactory({
-    indeterminate: Boolean,
-    indeterminateIcon: {
-      type: IconValue,
-      default: "$checkboxIndeterminate"
-    },
-    ...makeVSelectionControlProps({
-      falseIcon: "$checkboxOff",
-      trueIcon: "$checkboxOn"
-    })
-  }, "VCheckboxBtn");
-  const VCheckboxBtn = genericComponent()({
-    name: "VCheckboxBtn",
-    props: makeVCheckboxBtnProps(),
-    emits: {
-      "update:modelValue": (value) => true,
-      "update:indeterminate": (value) => true
-    },
-    setup(props, _ref) {
-      let {
-        slots
-      } = _ref;
-      const indeterminate = useProxiedModel(props, "indeterminate");
-      const model = useProxiedModel(props, "modelValue");
-      function onChange(v) {
-        if (indeterminate.value) {
-          indeterminate.value = false;
-        }
-      }
-      const falseIcon = vue.computed(() => {
-        return indeterminate.value ? props.indeterminateIcon : props.falseIcon;
-      });
-      const trueIcon = vue.computed(() => {
-        return indeterminate.value ? props.indeterminateIcon : props.trueIcon;
-      });
-      useRender(() => {
-        const controlProps = omit(VSelectionControl.filterProps(props), ["modelValue"]);
-        return vue.createVNode(VSelectionControl, vue.mergeProps(controlProps, {
-          "modelValue": model.value,
-          "onUpdate:modelValue": [($event) => model.value = $event, onChange],
-          "class": ["v-checkbox-btn", props.class],
-          "style": props.style,
-          "type": "checkbox",
-          "falseIcon": falseIcon.value,
-          "trueIcon": trueIcon.value,
-          "aria-checked": indeterminate.value ? "mixed" : void 0
-        }), slots);
-      });
-      return {};
-    }
-  });
-  const LocaleSymbol = Symbol.for("vuetify:locale");
-  function useLocale() {
-    const locale = vue.inject(LocaleSymbol);
-    if (!locale)
-      throw new Error("[Vuetify] Could not find injected locale instance");
-    return locale;
-  }
-  function useRtl() {
-    const locale = vue.inject(LocaleSymbol);
-    if (!locale)
-      throw new Error("[Vuetify] Could not find injected rtl instance");
-    return {
-      isRtl: locale.isRtl,
-      rtlClasses: locale.rtlClasses
-    };
-  }
-  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 vue.createVNode(VIcon, {
-        "icon": props[`${name}Icon`],
-        "aria-label": label,
-        "onClick": listener
-      }, null);
-    }
-    return {
-      InputIcon
-    };
-  }
-  const makeTransitionProps$1 = propsFactory({
-    disabled: Boolean,
-    group: Boolean,
-    hideOnLeave: Boolean,
-    leaveAbsolute: Boolean,
-    mode: String,
-    origin: String
-  }, "transition");
-  function createCssTransition(name, origin, mode) {
-    return genericComponent()({
-      name,
-      props: makeTransitionProps$1({
-        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 ? vue.TransitionGroup : vue.Transition;
-          return vue.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 vue.h(vue.Transition, {
-            name: props.disabled ? "" : name,
-            css: !props.disabled,
-            // mode: props.mode, // TODO: vuejs/vue-next#3104
-            ...props.disabled ? {} : functions
-          }, slots.default);
-        };
-      }
-    });
-  }
-  function ExpandTransitionGenerator() {
-    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 = vue.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;
-    }
-  }
-  createCssTransition("fab-transition", "center center", "out-in");
-  createCssTransition("dialog-bottom-transition");
-  createCssTransition("dialog-top-transition");
-  createCssTransition("fade-transition");
-  const VScaleTransition = createCssTransition("scale-transition");
-  createCssTransition("scroll-x-transition");
-  createCssTransition("scroll-x-reverse-transition");
-  createCssTransition("scroll-y-transition");
-  createCssTransition("scroll-y-reverse-transition");
-  createCssTransition("slide-x-transition");
-  createCssTransition("slide-x-reverse-transition");
-  const VSlideYTransition = createCssTransition("slide-y-transition");
-  createCssTransition("slide-y-reverse-transition");
-  createJavascriptTransition("expand-transition", ExpandTransitionGenerator());
-  const VExpandXTransition = createJavascriptTransition("expand-x-transition", ExpandTransitionGenerator("", true));
-  const makeTransitionProps = propsFactory({
-    transition: {
-      type: [Boolean, String, Object],
-      default: "fade-transition",
-      validator: (val) => val !== true
-    }
-  }, "transition");
-  const MaybeTransition = (props, _ref) => {
-    let {
-      slots
-    } = _ref;
-    const {
-      transition,
-      disabled,
-      group,
-      ...rest
-    } = props;
-    const {
-      component = group ? vue.TransitionGroup : vue.Transition,
-      ...customProps
-    } = typeof transition === "object" ? transition : {};
-    return vue.h(component, vue.mergeProps(typeof transition === "string" ? {
-      name: disabled ? "" : transition
-    } : customProps, typeof transition === "string" ? {} : Object.fromEntries(Object.entries({
-      disabled,
-      group
-    }).filter((_ref2) => {
-      let [_, v] = _ref2;
-      return v !== void 0;
-    })), rest), slots);
-  };
-  const makeVMessagesProps = propsFactory({
-    active: Boolean,
-    color: String,
-    messages: {
-      type: [Array, String],
-      default: () => []
-    },
-    ...makeComponentProps(),
-    ...makeTransitionProps({
-      transition: {
-        component: VSlideYTransition,
-        leaveAbsolute: true,
-        group: true
-      }
-    })
-  }, "VMessages");
-  const VMessages = genericComponent()({
-    name: "VMessages",
-    props: makeVMessagesProps(),
-    setup(props, _ref) {
-      let {
-        slots
-      } = _ref;
-      const messages = vue.computed(() => wrapInArray(props.messages));
-      const {
-        textColorClasses,
-        textColorStyles
-      } = useTextColor(vue.computed(() => props.color));
-      useRender(() => vue.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) => vue.createVNode("div", {
-          "class": "v-messages__message",
-          "key": `${i}-${messages.value}`
-        }, [slots.message ? slots.message({
-          message
-        }) : message]))]
-      }));
-      return {};
-    }
-  });
-  const 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 = vue.computed(() => {
-      return {
-        [`${name}--focused`]: isFocused.value
-      };
-    });
-    function focus() {
-      isFocused.value = true;
-    }
-    function blur() {
-      isFocused.value = false;
-    }
-    return {
-      focusClasses,
-      isFocused,
-      focus,
-      blur
-    };
-  }
-  const FormKey = Symbol.for("vuetify:form");
-  function useForm() {
-    return vue.inject(FormKey, null);
-  }
-  const 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 = vue.computed(() => props.validationValue === void 0 ? model.value : props.validationValue);
-    const form = useForm();
-    const internalErrorMessages = vue.ref([]);
-    const isPristine = vue.shallowRef(true);
-    const isDirty = vue.computed(() => !!(wrapInArray(model.value === "" ? null : model.value).length || wrapInArray(validationModel.value === "" ? null : validationModel.value).length));
-    const isDisabled = vue.computed(() => !!(props.disabled ?? (form == null ? void 0 : form.isDisabled.value)));
-    const isReadonly = vue.computed(() => !!(props.readonly ?? (form == null ? void 0 : form.isReadonly.value)));
-    const errorMessages = vue.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 = vue.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 = vue.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 = vue.shallowRef(false);
-    const validationClasses = vue.computed(() => {
-      return {
-        [`${name}--error`]: isValid.value === false,
-        [`${name}--dirty`]: isDirty.value,
-        [`${name}--disabled`]: isDisabled.value,
-        [`${name}--readonly`]: isReadonly.value
-      };
-    });
-    const uid = vue.computed(() => props.name ?? vue.unref(id));
-    vue.onBeforeMount(() => {
-      form == null ? void 0 : form.register({
-        id: uid.value,
-        validate,
-        reset,
-        resetValidation
-      });
-    });
-    vue.onBeforeUnmount(() => {
-      form == null ? void 0 : form.unregister(uid.value);
-    });
-    vue.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, () => {
-      vue.watch(validationModel, () => {
-        if (validationModel.value != null) {
-          validate();
-        } else if (props.focused) {
-          const unwatch = vue.watch(() => props.focused, (val) => {
-            if (!val)
-              validate();
-            unwatch();
-          });
-        }
-      });
-    });
-    useToggleScope(() => validateOn.value.blur, () => {
-      vue.watch(() => props.focused, (val) => {
-        if (!val)
-          validate();
-      });
-    });
-    vue.watch([isValid, errorMessages], () => {
-      form == null ? void 0 : form.update(uid.value, isValid.value, errorMessages.value);
-    });
-    async function reset() {
-      model.value = null;
-      await vue.nextTick();
-      await resetValidation();
-    }
-    async function resetValidation() {
-      isPristine.value = true;
-      if (!validateOn.value.lazy) {
-        await 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
-    };
-  }
-  const 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");
-  const 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 = vue.computed(() => props.id || `input-${uid}`);
-      const messagesId = vue.computed(() => `${id.value}-messages`);
-      const {
-        errorMessages,
-        isDirty,
-        isDisabled,
-        isReadonly,
-        isPristine,
-        isValid,
-        isValidating,
-        reset,
-        resetValidation,
-        validate,
-        validationClasses
-      } = useValidation(props, "v-input", id);
-      const slotProps = vue.computed(() => ({
-        id,
-        messagesId,
-        isDirty,
-        isDisabled,
-        isReadonly,
-        isPristine,
-        isValid,
-        isValidating,
-        reset,
-        resetValidation,
-        validate
-      }));
-      const messages = vue.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 vue.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 && vue.createVNode("div", {
-          "key": "prepend",
-          "class": "v-input__prepend"
-        }, [(_a = slots.prepend) == null ? void 0 : _a.call(slots, slotProps.value), props.prependIcon && vue.createVNode(InputIcon, {
-          "key": "prepend-icon",
-          "name": "prepend"
-        }, null)]), slots.default && vue.createVNode("div", {
-          "class": "v-input__control"
-        }, [(_b = slots.default) == null ? void 0 : _b.call(slots, slotProps.value)]), hasAppend && vue.createVNode("div", {
-          "key": "append",
-          "class": "v-input__append"
-        }, [props.appendIcon && vue.createVNode(InputIcon, {
-          "key": "append-icon",
-          "name": "append"
-        }, null), (_c = slots.append) == null ? void 0 : _c.call(slots, slotProps.value)]), hasDetails && vue.createVNode("div", {
-          "class": "v-input__details"
-        }, [vue.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
-      };
-    }
-  });
-  const makeVCheckboxProps = propsFactory({
-    ...makeVInputProps(),
-    ...omit(makeVCheckboxBtnProps(), ["inline"])
-  }, "VCheckbox");
-  const VCheckbox = genericComponent()({
-    name: "VCheckbox",
-    inheritAttrs: false,
-    props: makeVCheckboxProps(),
-    emits: {
-      "update:modelValue": (value) => true,
-      "update:focused": (focused) => true
-    },
-    setup(props, _ref) {
-      let {
-        attrs,
-        slots
-      } = _ref;
-      const model = useProxiedModel(props, "modelValue");
-      const {
-        isFocused,
-        focus,
-        blur
-      } = useFocus(props);
-      const uid = getUid();
-      const id = vue.computed(() => props.id || `checkbox-${uid}`);
-      useRender(() => {
-        const [rootAttrs, controlAttrs] = filterInputAttrs(attrs);
-        const inputProps = VInput.filterProps(props);
-        const checkboxProps = VCheckboxBtn.filterProps(props);
-        return vue.createVNode(VInput, vue.mergeProps({
-          "class": ["v-checkbox", props.class]
-        }, rootAttrs, inputProps, {
-          "modelValue": model.value,
-          "onUpdate:modelValue": ($event) => model.value = $event,
-          "id": id.value,
-          "focused": isFocused.value,
-          "style": props.style
-        }), {
-          ...slots,
-          default: (_ref2) => {
-            let {
-              id: id2,
-              messagesId,
-              isDisabled,
-              isReadonly,
-              isValid
-            } = _ref2;
-            return vue.createVNode(VCheckboxBtn, vue.mergeProps(checkboxProps, {
-              "id": id2.value,
-              "aria-describedby": messagesId.value,
-              "disabled": isDisabled.value,
-              "readonly": isReadonly.value
-            }, controlAttrs, {
-              "error": isValid.value === false,
-              "modelValue": model.value,
-              "onUpdate:modelValue": ($event) => model.value = $event,
-              "onFocus": focus,
-              "onBlur": blur
-            }), slots);
-          }
-        });
-      });
-      return {};
-    }
-  });
-  const makeVDividerProps = propsFactory({
-    color: String,
-    inset: Boolean,
-    length: [Number, String],
-    thickness: [Number, String],
-    vertical: Boolean,
-    ...makeComponentProps(),
-    ...makeThemeProps()
-  }, "VDivider");
-  const VDivider = genericComponent()({
-    name: "VDivider",
-    props: makeVDividerProps(),
-    setup(props, _ref) {
-      let {
-        attrs
-      } = _ref;
-      const {
-        themeClasses
-      } = provideTheme(props);
-      const {
-        textColorClasses,
-        textColorStyles
-      } = useTextColor(vue.toRef(props, "color"));
-      const dividerStyles = vue.computed(() => {
-        const styles2 = {};
-        if (props.length) {
-          styles2[props.vertical ? "maxHeight" : "maxWidth"] = convertToUnit(props.length);
-        }
-        if (props.thickness) {
-          styles2[props.vertical ? "borderRightWidth" : "borderTopWidth"] = convertToUnit(props.thickness);
-        }
-        return styles2;
-      });
-      useRender(() => vue.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 {};
-    }
-  });
-  const makeVContainerProps = propsFactory({
-    fluid: {
-      type: Boolean,
-      default: false
-    },
-    ...makeComponentProps(),
-    ...makeTagProps()
-  }, "VContainer");
-  const VContainer = genericComponent()({
-    name: "VContainer",
-    props: makeVContainerProps(),
-    setup(props, _ref) {
-      let {
-        slots
-      } = _ref;
-      const {
-        rtlClasses
-      } = useRtl();
-      useRender(() => vue.createVNode(props.tag, {
-        "class": ["v-container", {
-          "v-container--fluid": props.fluid
-        }, rtlClasses.value, props.class],
-        "style": props.style
-      }, slots));
-      return {};
-    }
-  });
-  const breakpoints = ["sm", "md", "lg", "xl", "xxl"];
-  const breakpointProps = (() => {
-    return breakpoints.reduce((props, val) => {
-      props[val] = {
-        type: [Boolean, String, Number],
-        default: false
-      };
-      return props;
-    }, {});
-  })();
-  const offsetProps = (() => {
-    return breakpoints.reduce((props, val) => {
-      const offsetKey = "offset" + vue.capitalize(val);
-      props[offsetKey] = {
-        type: [String, Number],
-        default: null
-      };
-      return props;
-    }, {});
-  })();
-  const orderProps = (() => {
-    return breakpoints.reduce((props, val) => {
-      const orderKey = "order" + vue.capitalize(val);
-      props[orderKey] = {
-        type: [String, Number],
-        default: null
-      };
-      return props;
-    }, {});
-  })();
-  const propMap$1 = {
-    col: Object.keys(breakpointProps),
-    offset: Object.keys(offsetProps),
-    order: Object.keys(orderProps)
-  };
-  function breakpointClass$1(type, prop, val) {
-    let className = type;
-    if (val == null || val === false) {
-      return void 0;
-    }
-    if (prop) {
-      const breakpoint = prop.replace(type, "");
-      className += `-${breakpoint}`;
-    }
-    if (type === "col") {
-      className = "v-" + className;
-    }
-    if (type === "col" && (val === "" || val === true)) {
-      return className.toLowerCase();
-    }
-    className += `-${val}`;
-    return className.toLowerCase();
-  }
-  const ALIGN_SELF_VALUES = ["auto", "start", "end", "center", "baseline", "stretch"];
-  const makeVColProps = propsFactory({
-    cols: {
-      type: [Boolean, String, Number],
-      default: false
-    },
-    ...breakpointProps,
-    offset: {
-      type: [String, Number],
-      default: null
-    },
-    ...offsetProps,
-    order: {
-      type: [String, Number],
-      default: null
-    },
-    ...orderProps,
-    alignSelf: {
-      type: String,
-      default: null,
-      validator: (str) => ALIGN_SELF_VALUES.includes(str)
-    },
-    ...makeComponentProps(),
-    ...makeTagProps()
-  }, "VCol");
-  const VCol = genericComponent()({
-    name: "VCol",
-    props: makeVColProps(),
-    setup(props, _ref) {
-      let {
-        slots
-      } = _ref;
-      const classes = vue.computed(() => {
-        const classList = [];
-        let type;
-        for (type in propMap$1) {
-          propMap$1[type].forEach((prop) => {
-            const value = props[prop];
-            const className = breakpointClass$1(type, prop, value);
-            if (className)
-              classList.push(className);
-          });
-        }
-        const hasColClasses = classList.some((className) => className.startsWith("v-col-"));
-        classList.push({
-          // Default to .v-col if no other col-{bp}-* classes generated nor `cols` specified.
-          "v-col": !hasColClasses || !props.cols,
-          [`v-col-${props.cols}`]: props.cols,
-          [`offset-${props.offset}`]: props.offset,
-          [`order-${props.order}`]: props.order,
-          [`align-self-${props.alignSelf}`]: props.alignSelf
-        });
-        return classList;
-      });
-      return () => {
-        var _a;
-        return vue.h(props.tag, {
-          class: [classes.value, props.class],
-          style: props.style
-        }, (_a = slots.default) == null ? void 0 : _a.call(slots));
-      };
-    }
-  });
-  const ALIGNMENT = ["start", "end", "center"];
-  const SPACE = ["space-between", "space-around", "space-evenly"];
-  function makeRowProps(prefix, def) {
-    return breakpoints.reduce((props, val) => {
-      const prefixKey = prefix + vue.capitalize(val);
-      props[prefixKey] = def();
-      return props;
-    }, {});
-  }
-  const ALIGN_VALUES = [...ALIGNMENT, "baseline", "stretch"];
-  const alignValidator = (str) => ALIGN_VALUES.includes(str);
-  const alignProps = makeRowProps("align", () => ({
-    type: String,
-    default: null,
-    validator: alignValidator
-  }));
-  const JUSTIFY_VALUES = [...ALIGNMENT, ...SPACE];
-  const justifyValidator = (str) => JUSTIFY_VALUES.includes(str);
-  const justifyProps = makeRowProps("justify", () => ({
-    type: String,
-    default: null,
-    validator: justifyValidator
-  }));
-  const ALIGN_CONTENT_VALUES = [...ALIGNMENT, ...SPACE, "stretch"];
-  const alignContentValidator = (str) => ALIGN_CONTENT_VALUES.includes(str);
-  const alignContentProps = makeRowProps("alignContent", () => ({
-    type: String,
-    default: null,
-    validator: alignContentValidator
-  }));
-  const propMap = {
-    align: Object.keys(alignProps),
-    justify: Object.keys(justifyProps),
-    alignContent: Object.keys(alignContentProps)
-  };
-  const classMap = {
-    align: "align",
-    justify: "justify",
-    alignContent: "align-content"
-  };
-  function breakpointClass(type, prop, val) {
-    let className = classMap[type];
-    if (val == null) {
-      return void 0;
-    }
-    if (prop) {
-      const breakpoint = prop.replace(type, "");
-      className += `-${breakpoint}`;
-    }
-    className += `-${val}`;
-    return className.toLowerCase();
-  }
-  const makeVRowProps = propsFactory({
-    dense: Boolean,
-    noGutters: Boolean,
-    align: {
-      type: String,
-      default: null,
-      validator: alignValidator
-    },
-    ...alignProps,
-    justify: {
-      type: String,
-      default: null,
-      validator: justifyValidator
-    },
-    ...justifyProps,
-    alignContent: {
-      type: String,
-      default: null,
-      validator: alignContentValidator
-    },
-    ...alignContentProps,
-    ...makeComponentProps(),
-    ...makeTagProps()
-  }, "VRow");
-  const VRow = genericComponent()({
-    name: "VRow",
-    props: makeVRowProps(),
-    setup(props, _ref) {
-      let {
-        slots
-      } = _ref;
-      const classes = vue.computed(() => {
-        const classList = [];
-        let type;
-        for (type in propMap) {
-          propMap[type].forEach((prop) => {
-            const value = props[prop];
-            const className = breakpointClass(type, prop, value);
-            if (className)
-              classList.push(className);
-          });
-        }
-        classList.push({
-          "v-row--no-gutters": props.noGutters,
-          "v-row--dense": props.dense,
-          [`align-${props.align}`]: props.align,
-          [`justify-${props.justify}`]: props.justify,
-          [`align-content-${props.alignContent}`]: props.alignContent
-        });
-        return classList;
-      });
-      return () => {
-        var _a;
-        return vue.h(props.tag, {
-          class: ["v-row", classes.value, props.class],
-          style: props.style
-        }, (_a = slots.default) == null ? void 0 : _a.call(slots));
-      };
-    }
-  });
-  const makeVRadioProps = propsFactory({
-    ...makeVSelectionControlProps({
-      falseIcon: "$radioOff",
-      trueIcon: "$radioOn"
-    })
-  }, "VRadio");
-  const VRadio = genericComponent()({
-    name: "VRadio",
-    props: makeVRadioProps(),
-    setup(props, _ref) {
-      let {
-        slots
-      } = _ref;
-      useRender(() => vue.createVNode(VSelectionControl, vue.mergeProps(props, {
-        "class": ["v-radio", props.class],
-        "style": props.style,
-        "type": "radio"
-      }), slots));
-      return {};
-    }
-  });
-  const makeVRadioGroupProps = propsFactory({
-    height: {
-      type: [Number, String],
-      default: "auto"
-    },
-    ...makeVInputProps(),
-    ...omit(makeSelectionControlGroupProps(), ["multiple"]),
-    trueIcon: {
-      type: IconValue,
-      default: "$radioOn"
-    },
-    falseIcon: {
-      type: IconValue,
-      default: "$radioOff"
-    },
-    type: {
-      type: String,
-      default: "radio"
-    }
-  }, "VRadioGroup");
-  const VRadioGroup = genericComponent()({
-    name: "VRadioGroup",
-    inheritAttrs: false,
-    props: makeVRadioGroupProps(),
-    emits: {
-      "update:modelValue": (value) => true
-    },
-    setup(props, _ref) {
-      let {
-        attrs,
-        slots
-      } = _ref;
-      const uid = getUid();
-      const id = vue.computed(() => props.id || `radio-group-${uid}`);
-      const model = useProxiedModel(props, "modelValue");
-      useRender(() => {
-        const [rootAttrs, controlAttrs] = filterInputAttrs(attrs);
-        const inputProps = VInput.filterProps(props);
-        const controlProps = VSelectionControl.filterProps(props);
-        const label = slots.label ? slots.label({
-          label: props.label,
-          props: {
-            for: id.value
-          }
-        }) : props.label;
-        return vue.createVNode(VInput, vue.mergeProps({
-          "class": ["v-radio-group", props.class],
-          "style": props.style
-        }, rootAttrs, inputProps, {
-          "modelValue": model.value,
-          "onUpdate:modelValue": ($event) => model.value = $event,
-          "id": id.value
-        }), {
-          ...slots,
-          default: (_ref2) => {
-            let {
-              id: id2,
-              messagesId,
-              isDisabled,
-              isReadonly
-            } = _ref2;
-            return vue.createVNode(vue.Fragment, null, [label && vue.createVNode(VLabel, {
-              "id": id2.value
-            }, {
-              default: () => [label]
-            }), vue.createVNode(VSelectionControlGroup, vue.mergeProps(controlProps, {
-              "id": id2.value,
-              "aria-describedby": messagesId.value,
-              "defaultsTarget": "VRadio",
-              "trueIcon": props.trueIcon,
-              "falseIcon": props.falseIcon,
-              "type": props.type,
-              "disabled": isDisabled.value,
-              "readonly": isReadonly.value,
-              "aria-labelledby": label ? id2.value : void 0,
-              "multiple": false
-            }, controlAttrs, {
-              "modelValue": model.value,
-              "onUpdate:modelValue": ($event) => model.value = $event
-            }), slots)]);
-          }
-        });
-      });
-      return {};
-    }
-  });
-  const 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 = vue.computed(() => {
-      const elevation = vue.isRef(props) ? props.value : props.elevation;
-      const classes = [];
-      if (elevation == null)
-        return classes;
-      classes.push(`elevation-${elevation}`);
-      return classes;
-    });
-    return {
-      elevationClasses
-    };
-  }
-  const makeRoundedProps = propsFactory({
-    rounded: {
-      type: [Boolean, Number, String],
-      default: void 0
-    },
-    tile: Boolean
-  }, "rounded");
-  function useRounded(props) {
-    let name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : getCurrentInstanceName();
-    const roundedClasses = vue.computed(() => {
-      const rounded = vue.isRef(props) ? props.value : props.rounded;
-      const tile = vue.isRef(props) ? props.value : props.tile;
-      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}`);
-        }
-      } else if (tile) {
-        classes.push("rounded-0");
-      }
-      return classes;
-    });
-    return {
-      roundedClasses
-    };
-  }
-  const 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];
-  }
-  const makeSliderProps = propsFactory({
-    disabled: {
-      type: Boolean,
-      default: null
-    },
-    error: Boolean,
-    readonly: {
-      type: Boolean,
-      default: null
-    },
-    max: {
-      type: [Number, String],
-      default: 100
-    },
-    min: {
-      type: [Number, String],
-      default: 0
-    },
-    step: {
-      type: [Number, String],
-      default: 0
-    },
-    thumbColor: String,
-    thumbLabel: {
-      type: [Boolean, String],
-      default: 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");
-  const useSteps = (props) => {
-    const min = vue.computed(() => parseFloat(props.min));
-    const max = vue.computed(() => parseFloat(props.max));
-    const step = vue.computed(() => +props.step > 0 ? parseFloat(props.step) : 0);
-    const decimals = vue.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
-    };
-  };
-  const useSlider = (_ref) => {
-    let {
-      props,
-      steps,
-      onSliderStart,
-      onSliderMove,
-      onSliderEnd,
-      getActiveThumb
-    } = _ref;
-    const {
-      isRtl
-    } = useRtl();
-    const isReversed = vue.toRef(props, "reverse");
-    const vertical = vue.computed(() => props.direction === "vertical");
-    const indexFromEnd = vue.computed(() => vertical.value !== isReversed.value);
-    const {
-      min,
-      max,
-      step,
-      decimals,
-      roundValue
-    } = steps;
-    const thumbSize = vue.computed(() => parseInt(props.thumbSize, 10));
-    const tickSize = vue.computed(() => parseInt(props.tickSize, 10));
-    const trackSize = vue.computed(() => parseInt(props.trackSize, 10));
-    const numTicks = vue.computed(() => (max.value - min.value) / step.value);
-    const disabled = vue.toRef(props, "disabled");
-    const thumbColor = vue.computed(() => props.error || props.disabled ? void 0 : props.thumbColor ?? props.color);
-    const trackColor = vue.computed(() => props.error || props.disabled ? void 0 : props.trackColor ?? props.color);
-    const trackFillColor = vue.computed(() => props.error || props.disabled ? void 0 : props.trackFillColor ?? props.color);
-    const mousePressed = vue.shallowRef(false);
-    const startOffset = vue.shallowRef(0);
-    const trackContainerRef = vue.ref();
-    const activeThumbRef = vue.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 = vue.toRef(props, "showTicks");
-    const parsedTicks = vue.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 = vue.computed(() => parsedTicks.value.some((_ref2) => {
-      let {
-        label
-      } = _ref2;
-      return !!label;
-    }));
-    const data = {
-      activeThumbRef,
-      color: vue.toRef(props, "color"),
-      decimals,
-      disabled,
-      direction: vue.toRef(props, "direction"),
-      elevation: vue.toRef(props, "elevation"),
-      hasLabels,
-      isReversed,
-      indexFromEnd,
-      min,
-      max,
-      mousePressed,
-      numTicks,
-      onSliderMousedown,
-      onSliderTouchstart,
-      parsedTicks,
-      parseMouseMove,
-      position,
-      readonly: vue.toRef(props, "readonly"),
-      rounded: vue.toRef(props, "rounded"),
-      roundValue,
-      showTicks,
-      startOffset,
-      step,
-      thumbSize,
-      thumbColor,
-      thumbLabel: vue.toRef(props, "thumbLabel"),
-      ticks: vue.toRef(props, "ticks"),
-      tickSize,
-      trackColor,
-      trackContainerRef,
-      trackFillColor,
-      trackSize,
-      vertical
-    };
-    vue.provide(VSliderSymbol, data);
-    return data;
-  };
-  const makeVSliderThumbProps = propsFactory({
-    focused: Boolean,
-    max: {
-      type: Number,
-      required: true
-    },
-    min: {
-      type: Number,
-      required: true
-    },
-    modelValue: {
-      type: Number,
-      required: true
-    },
-    position: {
-      type: Number,
-      required: true
-    },
-    ripple: {
-      type: [Boolean, Object],
-      default: true
-    },
-    ...makeComponentProps()
-  }, "VSliderThumb");
-  const VSliderThumb = genericComponent()({
-    name: "VSliderThumb",
-    directives: {
-      Ripple
-    },
-    props: makeVSliderThumbProps(),
-    emits: {
-      "update:modelValue": (v) => true
-    },
-    setup(props, _ref) {
-      let {
-        slots,
-        emit
-      } = _ref;
-      const slider = vue.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 = vue.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 = vue.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 vue.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
-        }, [vue.createVNode("div", {
-          "class": ["v-slider-thumb__surface", textColorClasses.value, elevationClasses.value],
-          "style": {
-            ...textColorStyles.value
-          }
-        }, null), vue.withDirectives(vue.createVNode("div", {
-          "class": ["v-slider-thumb__ripple", textColorClasses.value],
-          "style": textColorStyles.value
-        }, null), [[vue.resolveDirective("ripple"), props.ripple, null, {
-          circle: true,
-          center: true
-        }]]), vue.createVNode(VScaleTransition, {
-          "origin": "bottom center"
-        }, {
-          default: () => {
-            var _a;
-            return [vue.withDirectives(vue.createVNode("div", {
-              "class": "v-slider-thumb__label-container"
-            }, [vue.createVNode("div", {
-              "class": ["v-slider-thumb__label"]
-            }, [vue.createVNode("div", null, [((_a = slots["thumb-label"]) == null ? void 0 : _a.call(slots, {
-              modelValue: props.modelValue
-            })) ?? props.modelValue.toFixed(step.value ? decimals.value : 1)])])]), [[vue.vShow, thumbLabel.value && props.focused || thumbLabel.value === "always"]])];
-          }
-        })]);
-      });
-      return {};
-    }
-  });
-  const makeVSliderTrackProps = propsFactory({
-    start: {
-      type: Number,
-      required: true
-    },
-    stop: {
-      type: Number,
-      required: true
-    },
-    ...makeComponentProps()
-  }, "VSliderTrack");
-  const VSliderTrack = genericComponent()({
-    name: "VSliderTrack",
-    props: makeVSliderTrackProps(),
-    emits: {},
-    setup(props, _ref) {
-      let {
-        slots
-      } = _ref;
-      const slider = vue.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 = vue.computed(() => `inset-${vertical.value ? "block" : "inline"}-${indexFromEnd.value ? "end" : "start"}`);
-      const endDir = vue.computed(() => vertical.value ? "height" : "width");
-      const backgroundStyles = vue.computed(() => {
-        return {
-          [startDir.value]: "0%",
-          [endDir.value]: "100%"
-        };
-      });
-      const trackFillWidth = vue.computed(() => props.stop - props.start);
-      const trackFillStyles = vue.computed(() => {
-        return {
-          [startDir.value]: convertToUnit(props.start, "%"),
-          [endDir.value]: convertToUnit(trackFillWidth.value, "%")
-        };
-      });
-      const computedTicks = vue.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 vue.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"]) && vue.createVNode("div", {
-            "class": "v-slider-track__tick-label"
-          }, [((_a = slots["tick-label"]) == null ? void 0 : _a.call(slots, {
-            tick,
-            index
-          })) ?? tick.label])]);
-        });
-      });
-      useRender(() => {
-        return vue.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]
-        }, [vue.createVNode("div", {
-          "class": ["v-slider-track__background", trackColorClasses.value, {
-            "v-slider-track__background--opacity": !!color.value || !trackFillColor.value
-          }],
-          "style": {
-            ...backgroundStyles.value,
-            ...trackColorStyles.value
-          }
-        }, null), vue.createVNode("div", {
-          "class": ["v-slider-track__fill", trackFillColorClasses.value],
-          "style": {
-            ...trackFillStyles.value,
-            ...trackFillColorStyles.value
-          }
-        }, null), showTicks.value && vue.createVNode("div", {
-          "class": ["v-slider-track__ticks", {
-            "v-slider-track__ticks--always-show": showTicks.value === "always"
-          }]
-        }, [computedTicks.value])]);
-      });
-      return {};
-    }
-  });
-  const makeVSliderProps = propsFactory({
-    ...makeFocusProps(),
-    ...makeSliderProps(),
-    ...makeVInputProps(),
-    modelValue: {
-      type: [Number, String],
-      default: 0
-    }
-  }, "VSlider");
-  const VSlider = genericComponent()({
-    name: "VSlider",
-    props: makeVSliderProps(),
-    emits: {
-      "update:focused": (value) => true,
-      "update:modelValue": (v) => true,
-      start: (value) => true,
-      end: (value) => true
-    },
-    setup(props, _ref) {
-      let {
-        slots,
-        emit
-      } = _ref;
-      const thumbContainerRef = vue.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 = vue.computed(() => position(model.value));
-      useRender(() => {
-        const inputProps = VInput.filterProps(props);
-        const hasPrepend = !!(props.label || slots.label || slots.prepend);
-        return vue.createVNode(VInput, vue.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 vue.createVNode(vue.Fragment, null, [((_a = slots.label) == null ? void 0 : _a.call(slots, slotProps)) ?? (props.label ? vue.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 vue.createVNode("div", {
-              "class": "v-slider__container",
-              "onMousedown": !readonly.value ? onSliderMousedown : void 0,
-              "onTouchstartPassive": !readonly.value ? onSliderTouchstart : void 0
-            }, [vue.createVNode("input", {
-              "id": id.value,
-              "name": props.name || id.value,
-              "disabled": !!props.disabled,
-              "readonly": !!props.readonly,
-              "tabindex": "-1",
-              "value": model.value
-            }, null), vue.createVNode(VSliderTrack, {
-              "ref": trackContainerRef,
-              "start": 0,
-              "stop": trackStop.value
-            }, {
-              "tick-label": slots["tick-label"]
-            }), vue.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 {};
-    }
-  });
-  const makeVCounterProps = propsFactory({
-    active: Boolean,
-    max: [Number, String],
-    value: {
-      type: [Number, String],
-      default: 0
-    },
-    ...makeComponentProps(),
-    ...makeTransitionProps({
-      transition: {
-        component: VSlideYTransition
-      }
-    })
-  }, "VCounter");
-  const VCounter = genericComponent()({
-    name: "VCounter",
-    functional: true,
-    props: makeVCounterProps(),
-    setup(props, _ref) {
-      let {
-        slots
-      } = _ref;
-      const counter = vue.computed(() => {
-        return props.max ? `${props.value} / ${props.max}` : String(props.value);
-      });
-      useRender(() => vue.createVNode(MaybeTransition, {
-        "transition": props.transition
-      }, {
-        default: () => [vue.withDirectives(vue.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]), [[vue.vShow, props.active]])]
-      }));
-      return {};
-    }
-  });
-  const makeVFieldLabelProps = propsFactory({
-    floating: Boolean,
-    ...makeComponentProps()
-  }, "VFieldLabel");
-  const VFieldLabel = genericComponent()({
-    name: "VFieldLabel",
-    props: makeVFieldLabelProps(),
-    setup(props, _ref) {
-      let {
-        slots
-      } = _ref;
-      useRender(() => vue.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 {};
-    }
-  });
-  function useIntersectionObserver(callback, options) {
-    const intersectionRef = vue.ref();
-    const isIntersecting = vue.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);
-      vue.onBeforeUnmount(() => {
-        observer.disconnect();
-      });
-      vue.watch(intersectionRef, (newValue, oldValue) => {
-        if (oldValue) {
-          observer.unobserve(oldValue);
-          isIntersecting.value = false;
-        }
-        if (newValue)
-          observer.observe(newValue);
-      }, {
-        flush: "post"
-      });
-    }
-    return {
-      intersectionRef,
-      isIntersecting
-    };
-  }
-  const oppositeMap = {
-    center: "center",
-    top: "bottom",
-    bottom: "top",
-    left: "right",
-    right: "left"
-  };
-  const 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 = vue.computed(() => {
-      if (!props.location)
-        return {};
-      const {
-        side,
-        align
-      } = parseAnchor(props.location.split(" ").length > 1 ? props.location : `${props.location} center`, isRtl.value);
-      function getOffset2(side2) {
-        return offset ? offset(side2) : 0;
-      }
-      const styles2 = {};
-      if (side !== "center") {
-        if (opposite)
-          styles2[oppositeMap[side]] = `calc(100% - ${getOffset2(side)}px)`;
-        else
-          styles2[side] = 0;
-      }
-      if (align !== "center") {
-        if (opposite)
-          styles2[oppositeMap[align]] = `calc(100% - ${getOffset2(align)}px)`;
-        else
-          styles2[align] = 0;
-      } else {
-        if (side === "center")
-          styles2.top = styles2.left = "50%";
-        else {
-          styles2[{
-            top: "left",
-            bottom: "left",
-            left: "top",
-            right: "top"
-          }[side]] = "50%";
-        }
-        styles2.transform = {
-          top: "translateX(-50%)",
-          bottom: "translateX(-50%)",
-          left: "translateY(-50%)",
-          right: "translateY(-50%)",
-          center: "translate(-50%, -50%)"
-        }[side];
-      }
-      return styles2;
-    });
-    return {
-      locationStyles
-    };
-  }
-  const 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");
-  const 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(vue.computed(() => props.bgColor || props.color));
-      const {
-        backgroundColorClasses: barColorClasses,
-        backgroundColorStyles: barColorStyles
-      } = useBackgroundColor(props, "color");
-      const {
-        roundedClasses
-      } = useRounded(props);
-      const {
-        intersectionRef,
-        isIntersecting
-      } = useIntersectionObserver();
-      const max = vue.computed(() => parseInt(props.max, 10));
-      const height = vue.computed(() => parseInt(props.height, 10));
-      const normalizedBuffer = vue.computed(() => parseFloat(props.bufferValue) / max.value * 100);
-      const normalizedValue = vue.computed(() => parseFloat(progress.value) / max.value * 100);
-      const isReversed = vue.computed(() => isRtl.value !== props.reverse);
-      const transition = vue.computed(() => props.indeterminate ? "fade-transition" : "slide-x-transition");
-      const opacity = vue.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(() => vue.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 && vue.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), vue.createVNode("div", {
-          "class": ["v-progress-linear__background", backgroundColorClasses.value],
-          "style": [backgroundColorStyles.value, {
-            opacity: opacity.value,
-            width: convertToUnit(!props.stream ? 100 : normalizedBuffer.value, "%")
-          }]
-        }, null), vue.createVNode(vue.Transition, {
-          "name": transition.value
-        }, {
-          default: () => [!props.indeterminate ? vue.createVNode("div", {
-            "class": ["v-progress-linear__determinate", barColorClasses.value],
-            "style": [barColorStyles.value, {
-              width: convertToUnit(normalizedValue.value, "%")
-            }]
-          }, null) : vue.createVNode("div", {
-            "class": "v-progress-linear__indeterminate"
-          }, [["long", "short"].map((bar) => vue.createVNode("div", {
-            "key": bar,
-            "class": ["v-progress-linear__indeterminate", bar, barColorClasses.value],
-            "style": barColorStyles.value
-          }, null))])]
-        }), slots.default && vue.createVNode("div", {
-          "class": "v-progress-linear__content"
-        }, [slots.default({
-          value: normalizedValue.value,
-          buffer: normalizedBuffer.value
-        })])]
-      }));
-      return {};
-    }
-  });
-  const makeLoaderProps = propsFactory({
-    loading: [Boolean, String]
-  }, "loader");
-  function useLoader(props) {
-    let name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : getCurrentInstanceName();
-    const loaderClasses = vue.computed(() => ({
-      [`${name}--loading`]: props.loading
-    }));
-    return {
-      loaderClasses
-    };
-  }
-  function LoaderSlot(props, _ref) {
-    var _a;
-    let {
-      slots
-    } = _ref;
-    return vue.createVNode("div", {
-      "class": `${props.name}__loader`
-    }, [((_a = slots.default) == null ? void 0 : _a.call(slots, {
-      color: props.color,
-      isActive: props.active
-    })) || vue.createVNode(VProgressLinear, {
-      "absolute": props.absolute,
-      "active": props.active,
-      "color": props.color,
-      "height": "2",
-      "indeterminate": true
-    }, null)]);
-  }
-  const allowedVariants = ["underlined", "outlined", "filled", "solo", "solo-inverted", "solo-filled", "plain"];
-  const 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");
-  const 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 = vue.computed(() => props.dirty || props.active);
-      const hasLabel = vue.computed(() => !props.singleLine && !!(props.label || slots.label));
-      const uid = getUid();
-      const id = vue.computed(() => props.id || `input-${uid}`);
-      const messagesId = vue.computed(() => `${id.value}-messages`);
-      const labelRef = vue.ref();
-      const floatingLabelRef = vue.ref();
-      const controlRef = vue.ref();
-      const isPlainOrUnderlined = vue.computed(() => ["plain", "underlined"].includes(props.variant));
-      const {
-        backgroundColorClasses,
-        backgroundColorStyles
-      } = useBackgroundColor(vue.toRef(props, "bgColor"));
-      const {
-        textColorClasses,
-        textColorStyles
-      } = useTextColor(vue.computed(() => {
-        return props.error || props.disabled ? void 0 : isActive.value && isFocused.value ? props.color : props.baseColor;
-      }));
-      vue.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 = vue.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 vue.createVNode("div", vue.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), [vue.createVNode("div", {
-          "class": "v-field__overlay"
-        }, null), vue.createVNode(LoaderSlot, {
-          "name": "v-field",
-          "active": !!props.loading,
-          "color": props.error ? "error" : typeof props.loading === "string" ? props.loading : props.color
-        }, {
-          default: slots.loader
-        }), hasPrepend && vue.createVNode("div", {
-          "key": "prepend",
-          "class": "v-field__prepend-inner"
-        }, [props.prependInnerIcon && vue.createVNode(InputIcon, {
-          "key": "prepend-icon",
-          "name": "prependInner"
-        }, null), (_a = slots["prepend-inner"]) == null ? void 0 : _a.call(slots, slotProps.value)]), vue.createVNode("div", {
-          "class": "v-field__field",
-          "data-no-activator": ""
-        }, [["filled", "solo", "solo-inverted", "solo-filled"].includes(props.variant) && hasLabel.value && vue.createVNode(VFieldLabel, {
-          "key": "floating-label",
-          "ref": floatingLabelRef,
-          "class": [textColorClasses.value],
-          "floating": true,
-          "for": id.value,
-          "style": textColorStyles.value
-        }, {
-          default: () => [label()]
-        }), vue.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 && vue.createVNode(VExpandXTransition, {
-          "key": "clear"
-        }, {
-          default: () => [vue.withDirectives(vue.createVNode("div", {
-            "class": "v-field__clearable",
-            "onMousedown": (e) => {
-              e.preventDefault();
-              e.stopPropagation();
-            }
-          }, [slots.clear ? slots.clear() : vue.createVNode(InputIcon, {
-            "name": "clear"
-          }, null)]), [[vue.vShow, props.dirty]])]
-        }), hasAppend && vue.createVNode("div", {
-          "key": "append",
-          "class": "v-field__append-inner"
-        }, [(_c = slots["append-inner"]) == null ? void 0 : _c.call(slots, slotProps.value), props.appendInnerIcon && vue.createVNode(InputIcon, {
-          "key": "append-icon",
-          "name": "appendInner"
-        }, null)]), vue.createVNode("div", {
-          "class": ["v-field__outline", textColorClasses.value],
-          "style": textColorStyles.value
-        }, [isOutlined && vue.createVNode(vue.Fragment, null, [vue.createVNode("div", {
-          "class": "v-field__outline__start"
-        }, null), hasLabel.value && vue.createVNode("div", {
-          "class": "v-field__outline__notch"
-        }, [vue.createVNode(VFieldLabel, {
-          "ref": floatingLabelRef,
-          "floating": true,
-          "for": id.value
-        }, {
-          default: () => [label()]
-        })]), vue.createVNode("div", {
-          "class": "v-field__outline__end"
-        }, null)]), isPlainOrUnderlined.value && hasLabel.value && vue.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);
-  }
-  const 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;
-      }
-    });
-  }
-  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];
-  }
-  const Intersect = {
-    mounted,
-    unmounted
-  };
-  const Intersect$1 = Intersect;
-  const activeTypes = ["color", "file", "time", "date", "datetime-local", "week", "month"];
-  const 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");
-  const VTextField = genericComponent()({
-    name: "VTextField",
-    directives: {
-      Intersect: Intersect$1
-    },
-    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 = vue.computed(() => {
-        return typeof props.counterValue === "function" ? props.counterValue(model.value) : typeof props.counterValue === "number" ? props.counterValue : (model.value ?? "").toString().length;
-      });
-      const max = vue.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 = vue.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 = vue.ref();
-      const vFieldRef = vue.ref();
-      const inputRef = vue.ref();
-      const isActive = vue.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();
-        vue.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];
-          vue.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 vue.createVNode(VInput, vue.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 vue.createVNode(VField, vue.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 = vue.withDirectives(vue.createVNode("input", vue.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), [[vue.resolveDirective("intersect"), {
-                  handler: onIntersect
-                }, null, {
-                  once: true
-                }]]);
-                return vue.createVNode(vue.Fragment, null, [props.prefix && vue.createVNode("span", {
-                  "class": "v-text-field__prefix"
-                }, [vue.createVNode("span", {
-                  "class": "v-text-field__prefix__text"
-                }, [props.prefix])]), slots.default ? vue.createVNode("div", {
-                  "class": fieldClass,
-                  "data-no-activator": ""
-                }, [slots.default(), inputNode]) : vue.cloneVNode(inputNode, {
-                  class: fieldClass
-                }), props.suffix && vue.createVNode("span", {
-                  "class": "v-text-field__suffix"
-                }, [vue.createVNode("span", {
-                  "class": "v-text-field__suffix__text"
-                }, [props.suffix])])]);
-              }
-            });
-          },
-          details: hasDetails ? (slotProps) => {
-            var _a;
-            return vue.createVNode(vue.Fragment, null, [(_a = slots.details) == null ? void 0 : _a.call(slots, slotProps), hasCounter && vue.createVNode(vue.Fragment, null, [vue.createVNode("span", null, null), vue.createVNode(VCounter, {
-              "active": props.persistentCounter || isFocused.value,
-              "value": counterValue.value,
-              "max": max.value
-            }, slots.counter)])]);
-          } : void 0
-        });
-      });
-      return forwardRefs({}, vInputRef, vFieldRef, inputRef);
-    }
-  });
   const _hoisted_1 = /* @__PURE__ */ vue.createElementVNode("div", null, " UXTestForm ", -1);
   const _hoisted_2 = { class: "text-wrap" };
   const _hoisted_3 = { class: "ml-0 text-caption" };
@@ -7127,21 +2526,30 @@ Expected #hex, #hexa, rgb(), rgba(), hsl(), hsla(), object or number`);
         }
       ]);
       return (_ctx, _cache) => {
-        return vue.openBlock(), vue.createBlock(VContainer, { class: "yellowgreen" }, {
+        const _component_v_divider = vue.resolveComponent("v-divider");
+        const _component_v_row = vue.resolveComponent("v-row");
+        const _component_v_col = vue.resolveComponent("v-col");
+        const _component_v_radio = vue.resolveComponent("v-radio");
+        const _component_v_radio_group = vue.resolveComponent("v-radio-group");
+        const _component_v_text_field = vue.resolveComponent("v-text-field");
+        const _component_v_checkbox = vue.resolveComponent("v-checkbox");
+        const _component_v_slider = vue.resolveComponent("v-slider");
+        const _component_v_container = vue.resolveComponent("v-container");
+        return vue.openBlock(), vue.createBlock(_component_v_container, { class: "yellowgreen" }, {
           default: vue.withCtx(() => [
-            vue.createVNode(VRow, null, {
+            vue.createVNode(_component_v_row, null, {
               default: vue.withCtx(() => [
                 _hoisted_1,
-                vue.createVNode(VDivider)
+                vue.createVNode(_component_v_divider)
               ]),
               _: 1
             }),
-            _ctx.showFormValues ? (vue.openBlock(), vue.createBlock(VRow, { key: 0 }, {
+            _ctx.showFormValues ? (vue.openBlock(), vue.createBlock(_component_v_row, { key: 0 }, {
               default: vue.withCtx(() => [
-                vue.createVNode(VCol, { cols: "12" }, {
+                vue.createVNode(_component_v_col, { cols: "12" }, {
                   default: vue.withCtx(() => [
                     (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(formData.value, (formDataElement, index) => {
-                      return vue.openBlock(), vue.createBlock(VRow, {
+                      return vue.openBlock(), vue.createBlock(_component_v_row, {
                         key: index,
                         class: "ml-1 text-caption"
                       }, {
@@ -7157,39 +2565,39 @@ Expected #hex, #hexa, rgb(), rgba(), hsl(), hsla(), object or number`);
               ]),
               _: 1
             })) : vue.createCommentVNode("", true),
-            vue.createVNode(VRow, null, {
+            vue.createVNode(_component_v_row, null, {
               default: vue.withCtx(() => [
-                vue.createVNode(VDivider)
+                vue.createVNode(_component_v_divider)
               ]),
               _: 1
             }),
             (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(formData.value, (formDataElement, index) => {
-              return vue.openBlock(), vue.createBlock(VRow, { key: index }, {
+              return vue.openBlock(), vue.createBlock(_component_v_row, { key: index }, {
                 default: vue.withCtx(() => [
-                  formDataElement.elementType.localeCompare("divider") === 0 ? (vue.openBlock(), vue.createBlock(VCol, {
+                  formDataElement.elementType.localeCompare("divider") === 0 ? (vue.openBlock(), vue.createBlock(_component_v_col, {
                     key: 0,
                     cols: "12",
                     class: "ma-0 pa-0"
                   }, {
                     default: vue.withCtx(() => [
-                      vue.createVNode(VDivider)
+                      vue.createVNode(_component_v_divider)
                     ]),
                     _: 1
                   })) : vue.createCommentVNode("", true),
-                  formDataElement.elementType.localeCompare("radio") === 0 ? (vue.openBlock(), vue.createBlock(VCol, {
+                  formDataElement.elementType.localeCompare("radio") === 0 ? (vue.openBlock(), vue.createBlock(_component_v_col, {
                     key: 1,
                     cols: "12",
                     class: "ma-0 pa-0"
                   }, {
                     default: vue.withCtx(() => [
-                      vue.createVNode(VRadioGroup, {
+                      vue.createVNode(_component_v_radio_group, {
                         modelValue: formDataElement.model,
                         "onUpdate:modelValue": ($event) => formDataElement.model = $event,
                         "hide-details": true
                       }, {
                         default: vue.withCtx(() => [
                           (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(formDataElement.radioGroup, (n) => {
-                            return vue.openBlock(), vue.createBlock(VRadio, {
+                            return vue.openBlock(), vue.createBlock(_component_v_radio, {
                               key: n.key,
                               label: `${n.label}`,
                               value: n.value
@@ -7201,13 +2609,13 @@ Expected #hex, #hexa, rgb(), rgba(), hsl(), hsla(), object or number`);
                     ]),
                     _: 2
                   }, 1024)) : vue.createCommentVNode("", true),
-                  formDataElement.elementType.localeCompare("textField") === 0 ? (vue.openBlock(), vue.createBlock(VCol, {
+                  formDataElement.elementType.localeCompare("textField") === 0 ? (vue.openBlock(), vue.createBlock(_component_v_col, {
                     key: 2,
                     cols: "12",
                     class: "ma-0 pa-0"
                   }, {
                     default: vue.withCtx(() => [
-                      vue.createVNode(VTextField, {
+                      vue.createVNode(_component_v_text_field, {
                         modelValue: formDataElement.model,
                         "onUpdate:modelValue": ($event) => formDataElement.model = $event,
                         label: formDataElement.label,
@@ -7218,13 +2626,13 @@ Expected #hex, #hexa, rgb(), rgba(), hsl(), hsla(), object or number`);
                     ]),
                     _: 2
                   }, 1024)) : vue.createCommentVNode("", true),
-                  formDataElement.elementType.localeCompare("checkbox") === 0 ? (vue.openBlock(), vue.createBlock(VCol, {
+                  formDataElement.elementType.localeCompare("checkbox") === 0 ? (vue.openBlock(), vue.createBlock(_component_v_col, {
                     key: 3,
                     cols: "12",
                     class: "ma-0 pa-0"
                   }, {
                     default: vue.withCtx(() => [
-                      vue.createVNode(VCheckbox, {
+                      vue.createVNode(_component_v_checkbox, {
                         modelValue: formDataElement.model,
                         "onUpdate:modelValue": ($event) => formDataElement.model = $event,
                         "hide-details": true
@@ -7237,7 +2645,7 @@ Expected #hex, #hexa, rgb(), rgba(), hsl(), hsla(), object or number`);
                     ]),
                     _: 2
                   }, 1024)) : vue.createCommentVNode("", true),
-                  formDataElement.elementType.localeCompare("slider") === 0 ? (vue.openBlock(), vue.createBlock(VCol, {
+                  formDataElement.elementType.localeCompare("slider") === 0 ? (vue.openBlock(), vue.createBlock(_component_v_col, {
                     key: 4,
                     cols: "12",
                     class: "mx-3",
@@ -7245,7 +2653,7 @@ Expected #hex, #hexa, rgb(), rgba(), hsl(), hsla(), object or number`);
                   }, {
                     default: vue.withCtx(() => [
                       vue.createElementVNode("div", _hoisted_3, vue.toDisplayString(formDataElement.description), 1),
-                      vue.createVNode(VSlider, {
+                      vue.createVNode(_component_v_slider, {
                         modelValue: formDataElement.model,
                         "onUpdate:modelValue": ($event) => formDataElement.model = $event,
                         class: "align-center",
@@ -7257,7 +2665,7 @@ Expected #hex, #hexa, rgb(), rgba(), hsl(), hsla(), object or number`);
                         "hide-details": ""
                       }, {
                         append: vue.withCtx(() => [
-                          vue.createVNode(VTextField, {
+                          vue.createVNode(_component_v_text_field, {
                             modelValue: formDataElement.model,
                             "onUpdate:modelValue": ($event) => formDataElement.model = $event,
                             "hide-details": "",