translime-sdk 1.0.1

package/dist/preview.cjs

@@ -0,0 +1,3607 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const vuetify = require("vuetify");
+const locale = require("vuetify/locale");
+const components = require("vuetify/components");
+const directives = require("vuetify/directives");
+const md = require("vuetify/iconsets/md");
+const blueprints = require("vuetify/blueprints");
+require("vuetify/styles");
+const previewMock = require("./preview-mock.cjs");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const components__namespace = /* @__PURE__ */ _interopNamespaceDefault(components);
+const directives__namespace = /* @__PURE__ */ _interopNamespaceDefault(directives);
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+function propsFactory(props, source) {
+  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 (source && !obj[prop].source) {
+        obj[prop].source = source;
+      }
+      return obj;
+    }, {});
+  };
+}
+const makeComponentProps = propsFactory({
+  class: [String, Array, Object],
+  style: {
+    type: [String, Array, Object],
+    default: null
+  }
+}, "component");
+function consoleWarn(message) {
+  vue.warn(`Vuetify: ${message}`);
+}
+const IN_BROWSER = typeof window !== "undefined";
+const SUPPORTS_INTERSECTION = IN_BROWSER && "IntersectionObserver" in window;
+const SUPPORTS_MATCH_MEDIA = IN_BROWSER && "matchMedia" in window && typeof window.matchMedia === "function";
+const PREFERS_REDUCED_MOTION = () => SUPPORTS_MATCH_MEDIA && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+function convertToUnit(str) {
+  let unit = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "px";
+  if (str == null || str === "") {
+    return void 0;
+  }
+  const num = Number(str);
+  if (isNaN(num)) {
+    return String(str);
+  } else if (!isFinite(num)) {
+    return void 0;
+  } else {
+    return `${num}${unit}`;
+  }
+}
+function isObject(obj) {
+  return obj !== null && typeof obj === "object" && !Array.isArray(obj);
+}
+function isPlainObject(obj) {
+  let proto;
+  return obj !== null && typeof obj === "object" && ((proto = Object.getPrototypeOf(obj)) === Object.prototype || proto === null);
+}
+function refElement(obj) {
+  if (obj && "$el" in obj) {
+    const el = obj.$el;
+    if (el?.nodeType === Node.TEXT_NODE) {
+      return el.nextElementSibling;
+    }
+    return el;
+  }
+  return obj;
+}
+function has(obj, key) {
+  return key.every((k) => obj.hasOwnProperty(k));
+}
+function pick(obj, paths) {
+  const found = {};
+  for (const key of paths) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      found[key] = obj[key];
+    }
+  }
+  return found;
+}
+function omit(obj, exclude) {
+  const clone = {
+    ...obj
+  };
+  exclude.forEach((prop) => delete clone[prop]);
+  return clone;
+}
+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 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 source = 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 source) {
+    out[key] = source[key];
+  }
+  for (const key in target) {
+    const sourceProperty = source[key];
+    const targetProperty = target[key];
+    if (isPlainObject(sourceProperty) && isPlainObject(targetProperty)) {
+      out[key] = mergeDeep(sourceProperty, targetProperty, arrayFn);
+      continue;
+    }
+    if (arrayFn && Array.isArray(sourceProperty) && Array.isArray(targetProperty)) {
+      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 findChildrenWithProvide(key, vnode) {
+  if (!vnode || typeof vnode !== "object") return [];
+  if (Array.isArray(vnode)) {
+    return vnode.map((child) => findChildrenWithProvide(key, child)).flat(1);
+  } else if (vnode.suspense) {
+    return findChildrenWithProvide(key, vnode.ssContent);
+  } else if (Array.isArray(vnode.children)) {
+    return vnode.children.map((child) => findChildrenWithProvide(key, child)).flat(1);
+  } else if (vnode.component) {
+    if (Object.getOwnPropertyDescriptor(vnode.component.provides, key)) {
+      return [vnode.component];
+    } else if (vnode.component.subTree) {
+      return findChildrenWithProvide(key, vnode.component.subTree).flat(1);
+    }
+  }
+  return [];
+}
+function destructComputed(getter) {
+  const refs = vue.reactive({});
+  vue.watchEffect(() => {
+    const base = getter();
+    for (const key in base) {
+      refs[key] = base[key];
+    }
+  }, {
+    flush: "sync"
+  });
+  const obj = {};
+  for (const key in refs) {
+    obj[key] = vue.toRef(() => refs[key]);
+  }
+  return obj;
+}
+function includes(arr, val) {
+  return arr.includes(val);
+}
+function hasEvent(props, name) {
+  name = "on" + vue.capitalize(name);
+  return !!(props[name] || props[`${name}Once`] || props[`${name}Capture`] || props[`${name}OnceCapture`] || props[`${name}CaptureOnce`]);
+}
+function templateRef() {
+  const el = vue.shallowRef();
+  const fn = (target) => {
+    el.value = target;
+  };
+  Object.defineProperty(fn, "value", {
+    enumerable: true,
+    get: () => el.value,
+    set: (val) => el.value = val
+  });
+  Object.defineProperty(fn, "el", {
+    enumerable: true,
+    get: () => refElement(el.value)
+  });
+  return fn;
+}
+function isPrimitive(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint";
+}
+function onlyDefinedProps(props) {
+  const booleanAttributes = ["checked", "disabled"];
+  return Object.fromEntries(Object.entries(props).filter((_ref) => {
+    let [key, v] = _ref;
+    return booleanAttributes.includes(key) ? !!v : v !== void 0;
+  }));
+}
+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;
+}
+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 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*|\s*\/\s*|\s+/).map((v, i) => {
+      if (v.endsWith("%") || // unitless slv are %
+      i > 0 && i < 3 && ["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 getCurrentInstance(name, message) {
+  const vm = vue.getCurrentInstance();
+  if (!vm) {
+    throw new Error(`[Vuetify] ${name} ${"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?.aliasName || vm?.name);
+}
+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;
+}
+const DefaultsSymbol = /* @__PURE__ */ 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?.disabled);
+    if (disabled) return injectedDefaults.value;
+    const scoped = vue.unref(options?.scoped);
+    const reset = vue.unref(options?.reset);
+    const root = vue.unref(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) {
+  return vnode.props && (typeof vnode.props[prop] !== "undefined" || typeof vnode.props[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(() => defaults.value?.[props._as ?? name]);
+  const _props = new Proxy(props, {
+    get(target, prop) {
+      const propValue = Reflect.get(target, prop);
+      if (prop === "class" || prop === "style") {
+        return [componentDefaults.value?.[prop], propValue].filter((v) => v != null);
+      }
+      if (propIsDefined(vm.vnode, prop)) return propValue;
+      const _componentDefault = componentDefaults.value?.[prop];
+      if (_componentDefault !== void 0) return _componentDefault;
+      const _globalDefault = defaults.value?.global?.[prop];
+      if (_globalDefault !== void 0) return _globalDefault;
+      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?.value ?? {}, _subcomponentDefaults.value) : 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);
+}
+function createSimpleFunctional(klass) {
+  let tag = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "div";
+  let name = arguments.length > 2 ? arguments[2] : void 0;
+  return genericComponent()({
+    name: name ?? vue.capitalize(vue.camelize(klass.replace(/__/g, "-"))),
+    props: {
+      tag: {
+        type: String,
+        default: tag
+      },
+      ...makeComponentProps()
+    },
+    setup(props, _ref) {
+      let {
+        slots
+      } = _ref;
+      return () => {
+        return vue.h(props.tag, {
+          class: [klass, props.class],
+          style: props.style
+        }, slots.default?.());
+      };
+    }
+  });
+}
+function updateRecursionCache(a, b, cache, result) {
+  if (!cache || isPrimitive(a) || isPrimitive(b)) return;
+  const visitedObject = cache.get(a);
+  if (visitedObject) {
+    visitedObject.set(b, result);
+  } else {
+    const newCacheItem = /* @__PURE__ */ new WeakMap();
+    newCacheItem.set(b, result);
+    cache.set(a, newCacheItem);
+  }
+}
+function findCachedComparison(a, b, cache) {
+  if (!cache || isPrimitive(a) || isPrimitive(b)) return null;
+  const r1 = cache.get(a)?.get(b);
+  if (typeof r1 === "boolean") return r1;
+  const r2 = cache.get(b)?.get(a);
+  if (typeof r2 === "boolean") return r2;
+  return null;
+}
+function deepEqual(a, b) {
+  let recursionCache = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : /* @__PURE__ */ new WeakMap();
+  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;
+  }
+  const cachedComparisonResult = findCachedComparison(a, b, recursionCache);
+  if (cachedComparisonResult) {
+    return cachedComparisonResult;
+  }
+  updateRecursionCache(a, b, recursionCache, true);
+  return props.every((p) => deepEqual(a[p], b[p], recursionCache));
+}
+function useRender(render) {
+  const vm = getCurrentInstance("useRender");
+  vm.render = render;
+}
+function useResizeObserver(callback) {
+  let box = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "content";
+  const resizeRef = templateRef();
+  const contentRect = vue.ref();
+  if (IN_BROWSER) {
+    const observer = new ResizeObserver((entries) => {
+      if (!entries.length) return;
+      if (box === "content") {
+        contentRect.value = entries[0].contentRect;
+      } else {
+        contentRect.value = entries[0].target.getBoundingClientRect();
+      }
+    });
+    vue.onBeforeUnmount(() => {
+      observer.disconnect();
+    });
+    vue.watch(() => resizeRef.el, (newValue, oldValue) => {
+      if (oldValue) {
+        observer.unobserve(oldValue);
+        contentRect.value = void 0;
+      }
+      if (newValue) observer.observe(newValue);
+    }, {
+      flush: "post"
+    });
+  }
+  return {
+    resizeRef,
+    contentRect: vue.readonly(contentRect)
+  };
+}
+const VuetifyLayoutKey = /* @__PURE__ */ Symbol.for("vuetify:layout");
+const VuetifyLayoutItemKey = /* @__PURE__ */ Symbol.for("vuetify:layout-item");
+const ROOT_ZINDEX = 1e3;
+const makeLayoutProps = propsFactory({
+  overlaps: {
+    type: Array,
+    default: () => []
+  },
+  fullHeight: Boolean
+}, "layout");
+function useLayout() {
+  const layout = vue.inject(VuetifyLayoutKey);
+  if (!layout) throw new Error("[Vuetify] Could not find injected layout");
+  return {
+    getLayoutItem: layout.getLayoutItem,
+    mainRect: layout.mainRect,
+    mainStyles: layout.mainStyles
+  };
+}
+const generateLayers = (layout, positions, layoutSizes, activeItems) => {
+  let previousLayer = {
+    top: 0,
+    left: 0,
+    right: 0,
+    bottom: 0
+  };
+  const layers = [{
+    id: "",
+    layer: {
+      ...previousLayer
+    }
+  }];
+  for (const id of layout) {
+    const position = positions.get(id);
+    const amount = layoutSizes.get(id);
+    const active = activeItems.get(id);
+    if (!position || !amount || !active) continue;
+    const layer = {
+      ...previousLayer,
+      [position.value]: parseInt(previousLayer[position.value], 10) + (active.value ? parseInt(amount.value, 10) : 0)
+    };
+    layers.push({
+      id,
+      layer
+    });
+    previousLayer = layer;
+  }
+  return layers;
+};
+function createLayout(props) {
+  const parentLayout = vue.inject(VuetifyLayoutKey, null);
+  const rootZIndex = vue.computed(() => parentLayout ? parentLayout.rootZIndex.value - 100 : ROOT_ZINDEX);
+  const registered = vue.ref([]);
+  const positions = vue.reactive(/* @__PURE__ */ new Map());
+  const layoutSizes = vue.reactive(/* @__PURE__ */ new Map());
+  const priorities = vue.reactive(/* @__PURE__ */ new Map());
+  const activeItems = vue.reactive(/* @__PURE__ */ new Map());
+  const disabledTransitions = vue.reactive(/* @__PURE__ */ new Map());
+  const {
+    resizeRef,
+    contentRect: layoutRect
+  } = useResizeObserver();
+  const computedOverlaps = vue.computed(() => {
+    const map = /* @__PURE__ */ new Map();
+    const overlaps = props.overlaps ?? [];
+    for (const overlap of overlaps.filter((item) => item.includes(":"))) {
+      const [top, bottom] = overlap.split(":");
+      if (!registered.value.includes(top) || !registered.value.includes(bottom)) continue;
+      const topPosition = positions.get(top);
+      const bottomPosition = positions.get(bottom);
+      const topAmount = layoutSizes.get(top);
+      const bottomAmount = layoutSizes.get(bottom);
+      if (!topPosition || !bottomPosition || !topAmount || !bottomAmount) continue;
+      map.set(bottom, {
+        position: topPosition.value,
+        amount: parseInt(topAmount.value, 10)
+      });
+      map.set(top, {
+        position: bottomPosition.value,
+        amount: -parseInt(bottomAmount.value, 10)
+      });
+    }
+    return map;
+  });
+  const layers = vue.computed(() => {
+    const uniquePriorities = [...new Set([...priorities.values()].map((p) => p.value))].sort((a, b) => a - b);
+    const layout = [];
+    for (const p of uniquePriorities) {
+      const items2 = registered.value.filter((id) => priorities.get(id)?.value === p);
+      layout.push(...items2);
+    }
+    return generateLayers(layout, positions, layoutSizes, activeItems);
+  });
+  const transitionsEnabled = vue.computed(() => {
+    return !Array.from(disabledTransitions.values()).some((ref) => ref.value);
+  });
+  const mainRect = vue.computed(() => {
+    return layers.value[layers.value.length - 1].layer;
+  });
+  const mainStyles = vue.toRef(() => {
+    return {
+      "--v-layout-left": convertToUnit(mainRect.value.left),
+      "--v-layout-right": convertToUnit(mainRect.value.right),
+      "--v-layout-top": convertToUnit(mainRect.value.top),
+      "--v-layout-bottom": convertToUnit(mainRect.value.bottom),
+      ...transitionsEnabled.value ? void 0 : {
+        transition: "none"
+      }
+    };
+  });
+  const items = vue.computed(() => {
+    return layers.value.slice(1).map((_ref, index) => {
+      let {
+        id
+      } = _ref;
+      const {
+        layer
+      } = layers.value[index];
+      const size = layoutSizes.get(id);
+      const position = positions.get(id);
+      return {
+        id,
+        ...layer,
+        size: Number(size.value),
+        position: position.value
+      };
+    });
+  });
+  const getLayoutItem = (id) => {
+    return items.value.find((item) => item.id === id);
+  };
+  const rootVm = getCurrentInstance("createLayout");
+  const isMounted = vue.shallowRef(false);
+  vue.onMounted(() => {
+    isMounted.value = true;
+  });
+  vue.provide(VuetifyLayoutKey, {
+    register: (vm, _ref2) => {
+      let {
+        id,
+        order,
+        position,
+        layoutSize,
+        elementSize,
+        active,
+        disableTransitions,
+        absolute
+      } = _ref2;
+      priorities.set(id, order);
+      positions.set(id, position);
+      layoutSizes.set(id, layoutSize);
+      activeItems.set(id, active);
+      disableTransitions && disabledTransitions.set(id, disableTransitions);
+      const instances = findChildrenWithProvide(VuetifyLayoutItemKey, rootVm?.vnode);
+      const instanceIndex = instances.indexOf(vm);
+      if (instanceIndex > -1) registered.value.splice(instanceIndex, 0, id);
+      else registered.value.push(id);
+      const index = vue.computed(() => items.value.findIndex((i) => i.id === id));
+      const zIndex = vue.computed(() => rootZIndex.value + layers.value.length * 2 - index.value * 2);
+      const layoutItemStyles = vue.computed(() => {
+        const isHorizontal = position.value === "left" || position.value === "right";
+        const isOppositeHorizontal = position.value === "right";
+        const isOppositeVertical = position.value === "bottom";
+        const size = elementSize.value ?? layoutSize.value;
+        const unit = size === 0 ? "%" : "px";
+        const styles = {
+          [position.value]: 0,
+          zIndex: zIndex.value,
+          transform: `translate${isHorizontal ? "X" : "Y"}(${(active.value ? 0 : -(size === 0 ? 100 : size)) * (isOppositeHorizontal || isOppositeVertical ? -1 : 1)}${unit})`,
+          position: absolute.value || rootZIndex.value !== ROOT_ZINDEX ? "absolute" : "fixed",
+          ...transitionsEnabled.value ? void 0 : {
+            transition: "none"
+          }
+        };
+        if (!isMounted.value) return styles;
+        const item = items.value[index.value];
+        if (!item) consoleWarn(`[Vuetify] Could not find layout item "${id}"`);
+        const overlap = computedOverlaps.value.get(id);
+        if (overlap) {
+          item[overlap.position] += overlap.amount;
+        }
+        return {
+          ...styles,
+          height: isHorizontal ? `calc(100% - ${item.top}px - ${item.bottom}px)` : elementSize.value ? `${elementSize.value}px` : void 0,
+          left: isOppositeHorizontal ? void 0 : `${item.left}px`,
+          right: isOppositeHorizontal ? `${item.right}px` : void 0,
+          top: position.value !== "bottom" ? `${item.top}px` : void 0,
+          bottom: position.value !== "top" ? `${item.bottom}px` : void 0,
+          width: !isHorizontal ? `calc(100% - ${item.left}px - ${item.right}px)` : elementSize.value ? `${elementSize.value}px` : void 0
+        };
+      });
+      const layoutItemScrimStyles = vue.computed(() => ({
+        zIndex: zIndex.value - 1
+      }));
+      return {
+        layoutItemStyles,
+        layoutItemScrimStyles,
+        zIndex
+      };
+    },
+    unregister: (id) => {
+      priorities.delete(id);
+      positions.delete(id);
+      layoutSizes.delete(id);
+      activeItems.delete(id);
+      disabledTransitions.delete(id);
+      registered.value = registered.value.filter((v) => v !== id);
+    },
+    mainRect,
+    mainStyles,
+    getLayoutItem,
+    items,
+    layoutRect,
+    rootZIndex
+  });
+  const layoutClasses = vue.toRef(() => ["v-layout", {
+    "v-layout--full-height": props.fullHeight
+  }]);
+  const layoutStyles = vue.toRef(() => ({
+    zIndex: parentLayout ? rootZIndex.value : void 0,
+    position: parentLayout ? "relative" : void 0,
+    overflow: parentLayout ? "hidden" : void 0
+  }));
+  return {
+    layoutClasses,
+    layoutStyles,
+    getLayoutItem,
+    items,
+    layoutRect,
+    layoutRef: resizeRef
+  };
+}
+function useToggleScope(source, fn) {
+  let scope;
+  function start() {
+    scope = vue.effectScope();
+    scope.run(() => fn.length ? fn(() => {
+      scope?.stop();
+      start();
+    }) : fn());
+  }
+  vue.watch(source, (active) => {
+    if (active && !scope) {
+      start();
+    } else if (!active) {
+      scope?.stop();
+      scope = void 0;
+    }
+  }, {
+    immediate: true
+  });
+  vue.onScopeDispose(() => {
+    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(() => {
+    void props[prop];
+    return !!((vm.vnode.props?.hasOwnProperty(prop) || vm.vnode.props?.hasOwnProperty(kebabProp)) && (vm.vnode.props?.hasOwnProperty(`onUpdate:${prop}`) || vm.vnode.props?.hasOwnProperty(`onUpdate:${kebabProp}`)));
+  }) : vue.computed(() => {
+    void props[prop];
+    return !!(vm.vnode.props?.hasOwnProperty(prop) && vm.vnode.props?.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?.emit(`update:${prop}`, newValue);
+    }
+  });
+  Object.defineProperty(model, "externalValue", {
+    get: () => isControlled.value ? props[prop] : internal.value
+  });
+  return model;
+}
+const LocaleSymbol = /* @__PURE__ */ Symbol.for("vuetify:locale");
+function useRtl() {
+  const locale2 = vue.inject(LocaleSymbol);
+  if (!locale2) throw new Error("[Vuetify] Could not find injected rtl instance");
+  return {
+    isRtl: locale2.isRtl,
+    rtlClasses: locale2.rtlClasses
+  };
+}
+const ThemeSymbol = /* @__PURE__ */ 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.toRef(() => props.theme ?? theme.name.value);
+  const current = vue.toRef(() => theme.themes.value[name.value]);
+  const themeClasses = vue.toRef(() => theme.isDisabled ? void 0 : `${theme.prefix}theme--${name.value}`);
+  const newTheme = {
+    ...theme,
+    name,
+    current,
+    themeClasses
+  };
+  vue.provide(ThemeSymbol, newTheme);
+  return newTheme;
+}
+function useTheme() {
+  getCurrentInstance("useTheme");
+  const theme = vue.inject(ThemeSymbol, null);
+  if (!theme) throw new Error("Could not find Vuetify theme injection");
+  return theme;
+}
+const makeVAppProps = propsFactory({
+  ...makeComponentProps(),
+  ...omit(makeLayoutProps(), ["fullHeight"]),
+  ...makeThemeProps()
+}, "VApp");
+const VApp = genericComponent()({
+  name: "VApp",
+  props: makeVAppProps(),
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    const theme = provideTheme(props);
+    const {
+      layoutClasses,
+      getLayoutItem,
+      items,
+      layoutRef
+    } = createLayout({
+      ...props,
+      fullHeight: true
+    });
+    const {
+      rtlClasses
+    } = useRtl();
+    useRender(() => vue.createElementVNode("div", {
+      "ref": layoutRef,
+      "class": vue.normalizeClass(["v-application", theme.themeClasses.value, layoutClasses.value, rtlClasses.value, props.class]),
+      "style": vue.normalizeStyle([props.style])
+    }, [vue.createElementVNode("div", {
+      "class": "v-application__wrap"
+    }, [slots.default?.()])]));
+    return {
+      getLayoutItem,
+      items,
+      theme
+    };
+  }
+});
+const makeVBannerActionsProps = propsFactory({
+  color: String,
+  density: String,
+  ...makeComponentProps()
+}, "VBannerActions");
+const VBannerActions = genericComponent()({
+  name: "VBannerActions",
+  props: makeVBannerActionsProps(),
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    provideDefaults({
+      VBtn: {
+        color: props.color,
+        density: props.density,
+        slim: true,
+        variant: "text"
+      }
+    });
+    useRender(() => vue.createElementVNode("div", {
+      "class": vue.normalizeClass(["v-banner-actions", props.class]),
+      "style": vue.normalizeStyle(props.style)
+    }, [slots.default?.()]));
+    return {};
+  }
+});
+const VBannerText = createSimpleFunctional("v-banner-text");
+const makeVDefaultsProviderProps = propsFactory({
+  defaults: Object,
+  disabled: Boolean,
+  reset: [Number, String],
+  root: [Boolean, String],
+  scoped: Boolean
+}, "VDefaultsProvider");
+const VDefaultsProvider = genericComponent(false)({
+  name: "VDefaultsProvider",
+  props: makeVDefaultsProviderProps(),
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    const {
+      defaults,
+      disabled,
+      reset,
+      root,
+      scoped
+    } = vue.toRefs(props);
+    provideDefaults(defaults, {
+      reset,
+      root,
+      scoped,
+      disabled
+    });
+    return () => slots.default?.();
+  }
+});
+function useColor(colors) {
+  return destructComputed(() => {
+    const {
+      class: colorClasses,
+      style: colorStyles
+    } = computeColor(colors);
+    return {
+      colorClasses,
+      colorStyles
+    };
+  });
+}
+function useTextColor(color) {
+  const {
+    colorClasses: textColorClasses,
+    colorStyles: textColorStyles
+  } = useColor(() => ({
+    text: vue.toValue(color)
+  }));
+  return {
+    textColorClasses,
+    textColorStyles
+  };
+}
+function useBackgroundColor(color) {
+  const {
+    colorClasses: backgroundColorClasses,
+    colorStyles: backgroundColorStyles
+  } = useColor(() => ({
+    background: vue.toValue(color)
+  }));
+  return {
+    backgroundColorClasses,
+    backgroundColorStyles
+  };
+}
+function computeColor(colors) {
+  const _colors = vue.toValue(colors);
+  const classes = [];
+  const styles = {};
+  if (_colors.background) {
+    if (isCssColor(_colors.background)) {
+      styles.backgroundColor = _colors.background;
+      if (!_colors.text && isParsableColor(_colors.background)) {
+        const backgroundColor = parseColor(_colors.background);
+        if (backgroundColor.a == null || backgroundColor.a === 1) {
+          const textColor = getForeground(backgroundColor);
+          styles.color = textColor;
+          styles.caretColor = textColor;
+        }
+      }
+    } else {
+      classes.push(`bg-${_colors.background}`);
+    }
+  }
+  if (_colors.text) {
+    if (isCssColor(_colors.text)) {
+      styles.color = _colors.text;
+      styles.caretColor = _colors.text;
+    } else {
+      classes.push(`text-${_colors.text}`);
+    }
+  }
+  return {
+    class: classes,
+    style: styles
+  };
+}
+const IconValue = [String, Function, Object, Array];
+const IconSymbol = /* @__PURE__ */ 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, Object, Function],
+    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: () => [props.icon ? vue.createVNode(Icon, null, null) : slots.default?.()]
+      });
+    };
+  }
+});
+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.createElementVNode("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.createElementVNode("path", {
+          "d": path[0],
+          "fill-opacity": path[1]
+        }, null) : vue.createElementVNode("path", {
+          "d": path
+        }, null)) : vue.createElementVNode("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": vue.normalizeClass(props.icon)
+      }, null);
+    };
+  }
+});
+const useIcon = (props) => {
+  const icons = vue.inject(IconSymbol);
+  if (!icons) throw new Error("Missing Vuetify Icons provide!");
+  const iconData = vue.computed(() => {
+    const iconAlias = vue.toValue(props);
+    if (!iconAlias) return {
+      component: VComponentIcon
+    };
+    let icon = iconAlias;
+    if (typeof icon === "string") {
+      icon = icon.trim();
+      if (icon.startsWith("$")) {
+        icon = icons.aliases?.[icon.slice(1)];
+      }
+    }
+    if (!icon) consoleWarn(`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(() => {
+    const size = props.size;
+    let sizeClasses;
+    let sizeStyles;
+    if (includes(predefinedSizes, size)) {
+      sizeClasses = `${name}--size-${size}`;
+    } else if (size) {
+      sizeStyles = {
+        width: convertToUnit(size),
+        height: convertToUnit(size)
+      };
+    }
+    return {
+      sizeClasses,
+      sizeStyles
+    };
+  });
+}
+const makeTagProps = propsFactory({
+  tag: {
+    type: [String, Object, Function],
+    default: "div"
+  }
+}, "tag");
+const makeVIconProps = propsFactory({
+  color: String,
+  disabled: Boolean,
+  start: Boolean,
+  end: Boolean,
+  icon: IconValue,
+  opacity: [String, Number],
+  ...makeComponentProps(),
+  ...makeSizeProps(),
+  ...makeTagProps({
+    tag: "i"
+  }),
+  ...makeThemeProps()
+}, "VIcon");
+const VIcon = genericComponent()({
+  name: "VIcon",
+  props: makeVIconProps(),
+  setup(props, _ref) {
+    let {
+      attrs,
+      slots
+    } = _ref;
+    const slotIcon = vue.shallowRef();
+    const {
+      themeClasses
+    } = useTheme();
+    const {
+      iconData
+    } = useIcon(() => slotIcon.value || props.icon);
+    const {
+      sizeClasses
+    } = useSize(props);
+    const {
+      textColorClasses,
+      textColorStyles
+    } = useTextColor(() => props.color);
+    useRender(() => {
+      const slotValue = slots.default?.();
+      if (slotValue) {
+        slotIcon.value = flattenFragments(slotValue).filter((node) => node.type === vue.Text && node.children && typeof node.children === "string")[0]?.children;
+      }
+      const hasClick = !!(attrs.onClick || attrs.onClickOnce);
+      return vue.createVNode(iconData.value.component, {
+        "tag": props.tag,
+        "icon": iconData.value.icon,
+        "class": vue.normalizeClass(["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": vue.normalizeStyle([{
+          "--v-icon-opacity": props.opacity
+        }, !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 makeDimensionProps = propsFactory({
+  height: [Number, String],
+  maxHeight: [Number, String],
+  maxWidth: [Number, String],
+  minHeight: [Number, String],
+  minWidth: [Number, String],
+  width: [Number, String]
+}, "dimension");
+function useDimension(props) {
+  const dimensionStyles = vue.computed(() => {
+    const styles = {};
+    const height = convertToUnit(props.height);
+    const maxHeight = convertToUnit(props.maxHeight);
+    const maxWidth = convertToUnit(props.maxWidth);
+    const minHeight = convertToUnit(props.minHeight);
+    const minWidth = convertToUnit(props.minWidth);
+    const width = convertToUnit(props.width);
+    if (height != null) styles.height = height;
+    if (maxHeight != null) styles.maxHeight = maxHeight;
+    if (maxWidth != null) styles.maxWidth = maxWidth;
+    if (minHeight != null) styles.minHeight = minHeight;
+    if (minWidth != null) styles.minWidth = minWidth;
+    if (width != null) styles.width = width;
+    return styles;
+  });
+  return {
+    dimensionStyles
+  };
+}
+function useAspectStyles(props) {
+  return {
+    aspectStyles: vue.computed(() => {
+      const ratio = Number(props.aspectRatio);
+      return ratio ? {
+        paddingBottom: String(1 / ratio * 100) + "%"
+      } : void 0;
+    })
+  };
+}
+const makeVResponsiveProps = propsFactory({
+  aspectRatio: [String, Number],
+  contentClass: null,
+  inline: Boolean,
+  ...makeComponentProps(),
+  ...makeDimensionProps()
+}, "VResponsive");
+const VResponsive = genericComponent()({
+  name: "VResponsive",
+  props: makeVResponsiveProps(),
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    const {
+      aspectStyles
+    } = useAspectStyles(props);
+    const {
+      dimensionStyles
+    } = useDimension(props);
+    useRender(() => vue.createElementVNode("div", {
+      "class": vue.normalizeClass(["v-responsive", {
+        "v-responsive--inline": props.inline
+      }, props.class]),
+      "style": vue.normalizeStyle([dimensionStyles.value, props.style])
+    }, [vue.createElementVNode("div", {
+      "class": "v-responsive__sizer",
+      "style": vue.normalizeStyle(aspectStyles.value)
+    }, null), slots.additional?.(), slots.default && vue.createElementVNode("div", {
+      "class": vue.normalizeClass(["v-responsive__content", props.contentClass])
+    }, [slots.default()])]));
+    return {};
+  }
+});
+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) ? false : props.tile;
+    const classes = [];
+    if (tile || rounded === false) {
+      classes.push("rounded-0");
+    } else if (rounded === true || rounded === "") {
+      classes.push(`${name}--rounded`);
+    } else if (typeof rounded === "string" || rounded === 0) {
+      for (const value of String(rounded).split(" ")) {
+        classes.push(`rounded-${value}`);
+      }
+    }
+    return classes;
+  });
+  return {
+    roundedClasses
+  };
+}
+const makeTransitionProps = propsFactory({
+  transition: {
+    type: null,
+    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
+  } = isObject(transition) ? transition : {};
+  let transitionProps;
+  if (isObject(transition)) {
+    transitionProps = vue.mergeProps(customProps, onlyDefinedProps({
+      disabled,
+      group
+    }), rest);
+  } else {
+    transitionProps = vue.mergeProps({
+      name: disabled || !transition ? "" : transition
+    }, rest);
+  }
+  return vue.h(component, transitionProps, slots);
+};
+function mounted$1(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() {
+    let entries = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+    let observer2 = arguments.length > 1 ? arguments[1] : void 0;
+    const _observe = el._observe?.[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$1(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$1(el, binding) {
+  const observe = el._observe?.[binding.instance.$.uid];
+  if (!observe) return;
+  observe.observer.unobserve(el);
+  delete el._observe[binding.instance.$.uid];
+}
+const Intersect = {
+  mounted: mounted$1,
+  unmounted: unmounted$1
+};
+const makeVImgProps = propsFactory({
+  absolute: Boolean,
+  alt: String,
+  cover: Boolean,
+  color: String,
+  draggable: {
+    type: [Boolean, String],
+    default: void 0
+  },
+  eager: Boolean,
+  gradient: String,
+  lazySrc: String,
+  options: {
+    type: Object,
+    // For more information on types, navigate to:
+    // https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API
+    default: () => ({
+      root: void 0,
+      rootMargin: void 0,
+      threshold: void 0
+    })
+  },
+  sizes: String,
+  src: {
+    type: [String, Object],
+    default: ""
+  },
+  crossorigin: String,
+  referrerpolicy: String,
+  srcset: String,
+  position: String,
+  ...makeVResponsiveProps(),
+  ...makeComponentProps(),
+  ...makeRoundedProps(),
+  ...makeTransitionProps()
+}, "VImg");
+const VImg = genericComponent()({
+  name: "VImg",
+  directives: {
+    vIntersect: Intersect
+  },
+  props: makeVImgProps(),
+  emits: {
+    loadstart: (value) => true,
+    load: (value) => true,
+    error: (value) => true
+  },
+  setup(props, _ref) {
+    let {
+      emit,
+      slots
+    } = _ref;
+    const {
+      backgroundColorClasses,
+      backgroundColorStyles
+    } = useBackgroundColor(() => props.color);
+    const {
+      roundedClasses
+    } = useRounded(props);
+    const vm = getCurrentInstance("VImg");
+    const currentSrc = vue.shallowRef("");
+    const image = vue.ref();
+    const state = vue.shallowRef(props.eager ? "loading" : "idle");
+    const naturalWidth = vue.shallowRef();
+    const naturalHeight = vue.shallowRef();
+    const normalisedSrc = vue.computed(() => {
+      return props.src && typeof props.src === "object" ? {
+        src: props.src.src,
+        srcset: props.srcset || props.src.srcset,
+        lazySrc: props.lazySrc || props.src.lazySrc,
+        aspect: Number(props.aspectRatio || props.src.aspect || 0)
+      } : {
+        src: props.src,
+        srcset: props.srcset,
+        lazySrc: props.lazySrc,
+        aspect: Number(props.aspectRatio || 0)
+      };
+    });
+    const aspectRatio = vue.computed(() => {
+      return normalisedSrc.value.aspect || naturalWidth.value / naturalHeight.value || 0;
+    });
+    vue.watch(() => props.src, () => {
+      init(state.value !== "idle");
+    });
+    vue.watch(aspectRatio, (val, oldVal) => {
+      if (!val && oldVal && image.value) {
+        pollForSize(image.value);
+      }
+    });
+    vue.onBeforeMount(() => init());
+    function init(isIntersecting) {
+      if (props.eager && isIntersecting) return;
+      if (SUPPORTS_INTERSECTION && !isIntersecting && !props.eager) return;
+      state.value = "loading";
+      if (normalisedSrc.value.lazySrc) {
+        const lazyImg = new Image();
+        lazyImg.src = normalisedSrc.value.lazySrc;
+        pollForSize(lazyImg, null);
+      }
+      if (!normalisedSrc.value.src) return;
+      vue.nextTick(() => {
+        emit("loadstart", image.value?.currentSrc || normalisedSrc.value.src);
+        setTimeout(() => {
+          if (vm.isUnmounted) return;
+          if (image.value?.complete) {
+            if (!image.value.naturalWidth) {
+              onError();
+            }
+            if (state.value === "error") return;
+            if (!aspectRatio.value) pollForSize(image.value, null);
+            if (state.value === "loading") onLoad();
+          } else {
+            if (!aspectRatio.value) pollForSize(image.value);
+            getSrc();
+          }
+        });
+      });
+    }
+    function onLoad() {
+      if (vm.isUnmounted) return;
+      getSrc();
+      pollForSize(image.value);
+      state.value = "loaded";
+      emit("load", image.value?.currentSrc || normalisedSrc.value.src);
+    }
+    function onError() {
+      if (vm.isUnmounted) return;
+      state.value = "error";
+      emit("error", image.value?.currentSrc || normalisedSrc.value.src);
+    }
+    function getSrc() {
+      const img = image.value;
+      if (img) currentSrc.value = img.currentSrc || img.src;
+    }
+    let timer = -1;
+    vue.onBeforeUnmount(() => {
+      clearTimeout(timer);
+    });
+    function pollForSize(img) {
+      let timeout = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 100;
+      const poll = () => {
+        clearTimeout(timer);
+        if (vm.isUnmounted) return;
+        const {
+          naturalHeight: imgHeight,
+          naturalWidth: imgWidth
+        } = img;
+        if (imgHeight || imgWidth) {
+          naturalWidth.value = imgWidth;
+          naturalHeight.value = imgHeight;
+        } else if (!img.complete && state.value === "loading" && timeout != null) {
+          timer = window.setTimeout(poll, timeout);
+        } else if (img.currentSrc.endsWith(".svg") || img.currentSrc.startsWith("data:image/svg+xml")) {
+          naturalWidth.value = 1;
+          naturalHeight.value = 1;
+        }
+      };
+      poll();
+    }
+    const containClasses = vue.toRef(() => ({
+      "v-img__img--cover": props.cover,
+      "v-img__img--contain": !props.cover
+    }));
+    const __image = () => {
+      if (!normalisedSrc.value.src || state.value === "idle") return null;
+      const img = vue.createElementVNode("img", {
+        "class": vue.normalizeClass(["v-img__img", containClasses.value]),
+        "style": {
+          objectPosition: props.position
+        },
+        "crossorigin": props.crossorigin,
+        "src": normalisedSrc.value.src,
+        "srcset": normalisedSrc.value.srcset,
+        "alt": props.alt,
+        "referrerpolicy": props.referrerpolicy,
+        "draggable": props.draggable,
+        "sizes": props.sizes,
+        "ref": image,
+        "onLoad": onLoad,
+        "onError": onError
+      }, null);
+      const sources = slots.sources?.();
+      return vue.createVNode(MaybeTransition, {
+        "transition": props.transition,
+        "appear": true
+      }, {
+        default: () => [vue.withDirectives(sources ? vue.createElementVNode("picture", {
+          "class": "v-img__picture"
+        }, [sources, img]) : img, [[vue.vShow, state.value === "loaded"]])]
+      });
+    };
+    const __preloadImage = () => vue.createVNode(MaybeTransition, {
+      "transition": props.transition
+    }, {
+      default: () => [normalisedSrc.value.lazySrc && state.value !== "loaded" && vue.createElementVNode("img", {
+        "class": vue.normalizeClass(["v-img__img", "v-img__img--preload", containClasses.value]),
+        "style": {
+          objectPosition: props.position
+        },
+        "crossorigin": props.crossorigin,
+        "src": normalisedSrc.value.lazySrc,
+        "alt": props.alt,
+        "referrerpolicy": props.referrerpolicy,
+        "draggable": props.draggable
+      }, null)]
+    });
+    const __placeholder = () => {
+      if (!slots.placeholder) return null;
+      return vue.createVNode(MaybeTransition, {
+        "transition": props.transition,
+        "appear": true
+      }, {
+        default: () => [(state.value === "loading" || state.value === "error" && !slots.error) && vue.createElementVNode("div", {
+          "class": "v-img__placeholder"
+        }, [slots.placeholder()])]
+      });
+    };
+    const __error = () => {
+      if (!slots.error) return null;
+      return vue.createVNode(MaybeTransition, {
+        "transition": props.transition,
+        "appear": true
+      }, {
+        default: () => [state.value === "error" && vue.createElementVNode("div", {
+          "class": "v-img__error"
+        }, [slots.error()])]
+      });
+    };
+    const __gradient = () => {
+      if (!props.gradient) return null;
+      return vue.createElementVNode("div", {
+        "class": "v-img__gradient",
+        "style": {
+          backgroundImage: `linear-gradient(${props.gradient})`
+        }
+      }, null);
+    };
+    const isBooted = vue.shallowRef(false);
+    {
+      const stop = vue.watch(aspectRatio, (val) => {
+        if (val) {
+          requestAnimationFrame(() => {
+            requestAnimationFrame(() => {
+              isBooted.value = true;
+            });
+          });
+          stop();
+        }
+      });
+    }
+    useRender(() => {
+      const responsiveProps = VResponsive.filterProps(props);
+      return vue.withDirectives(vue.createVNode(VResponsive, vue.mergeProps({
+        "class": ["v-img", {
+          "v-img--absolute": props.absolute,
+          "v-img--booting": !isBooted.value
+        }, backgroundColorClasses.value, roundedClasses.value, props.class],
+        "style": [{
+          width: convertToUnit(props.width === "auto" ? naturalWidth.value : props.width)
+        }, backgroundColorStyles.value, props.style]
+      }, responsiveProps, {
+        "aspectRatio": aspectRatio.value,
+        "aria-label": props.alt,
+        "role": props.alt ? "img" : void 0
+      }), {
+        additional: () => vue.createElementVNode(vue.Fragment, null, [vue.createVNode(__image, null, null), vue.createVNode(__preloadImage, null, null), vue.createVNode(__gradient, null, null), vue.createVNode(__placeholder, null, null), vue.createVNode(__error, null, null)]),
+        default: slots.default
+      }), [[Intersect, {
+        handler: init,
+        options: props.options
+      }, null, {
+        once: true
+      }]]);
+    });
+    return {
+      currentSrc,
+      image,
+      state,
+      naturalWidth,
+      naturalHeight
+    };
+  }
+});
+const makeBorderProps = propsFactory({
+  border: [Boolean, Number, String]
+}, "border");
+function useBorder(props) {
+  let name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : getCurrentInstanceName();
+  const borderClasses = vue.computed(() => {
+    const border = props.border;
+    if (border === true || border === "") {
+      return `${name}--border`;
+    } else if (typeof border === "string" || border === 0) {
+      return String(border).split(" ").map((v) => `border-${v}`);
+    }
+    return [];
+  });
+  return {
+    borderClasses
+  };
+}
+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.toRef(() => {
+    return `${name}--density-${props.density}`;
+  });
+  return {
+    densityClasses
+  };
+}
+const allowedVariants = ["elevated", "flat", "tonal", "outlined", "text", "plain"];
+function genOverlays(isClickable, name) {
+  return vue.createElementVNode(vue.Fragment, null, [isClickable && vue.createElementVNode("span", {
+    "key": "overlay",
+    "class": vue.normalizeClass(`${name}__overlay`)
+  }, null), vue.createElementVNode("span", {
+    "key": "underlay",
+    "class": vue.normalizeClass(`${name}__underlay`)
+  }, null)]);
+}
+const makeVariantProps = propsFactory({
+  color: String,
+  variant: {
+    type: String,
+    default: "elevated",
+    validator: (v) => allowedVariants.includes(v)
+  }
+}, "variant");
+function useVariant(props) {
+  let name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : getCurrentInstanceName();
+  const variantClasses = vue.toRef(() => {
+    const {
+      variant
+    } = vue.toValue(props);
+    return `${name}--variant-${variant}`;
+  });
+  const {
+    colorClasses,
+    colorStyles
+  } = useColor(() => {
+    const {
+      variant,
+      color
+    } = vue.toValue(props);
+    return {
+      [["elevated", "flat"].includes(variant) ? "background" : "text"]: color
+    };
+  });
+  return {
+    colorClasses,
+    colorStyles,
+    variantClasses
+  };
+}
+const makeVAvatarProps = propsFactory({
+  start: Boolean,
+  end: Boolean,
+  icon: IconValue,
+  image: String,
+  text: String,
+  ...makeBorderProps(),
+  ...makeComponentProps(),
+  ...makeDensityProps(),
+  ...makeRoundedProps(),
+  ...makeSizeProps(),
+  ...makeTagProps(),
+  ...makeThemeProps(),
+  ...makeVariantProps({
+    variant: "flat"
+  })
+}, "VAvatar");
+const VAvatar = genericComponent()({
+  name: "VAvatar",
+  props: makeVAvatarProps(),
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    const {
+      themeClasses
+    } = provideTheme(props);
+    const {
+      borderClasses
+    } = useBorder(props);
+    const {
+      colorClasses,
+      colorStyles,
+      variantClasses
+    } = useVariant(props);
+    const {
+      densityClasses
+    } = useDensity(props);
+    const {
+      roundedClasses
+    } = useRounded(props);
+    const {
+      sizeClasses,
+      sizeStyles
+    } = useSize(props);
+    useRender(() => vue.createVNode(props.tag, {
+      "class": vue.normalizeClass(["v-avatar", {
+        "v-avatar--start": props.start,
+        "v-avatar--end": props.end
+      }, themeClasses.value, borderClasses.value, colorClasses.value, densityClasses.value, roundedClasses.value, sizeClasses.value, variantClasses.value, props.class]),
+      "style": vue.normalizeStyle([colorStyles.value, sizeStyles.value, props.style])
+    }, {
+      default: () => [!slots.default ? props.image ? vue.createVNode(VImg, {
+        "key": "image",
+        "src": props.image,
+        "alt": "",
+        "cover": true
+      }, null) : props.icon ? vue.createVNode(VIcon, {
+        "key": "icon",
+        "icon": props.icon
+      }, null) : props.text : vue.createVNode(VDefaultsProvider, {
+        "key": "content-defaults",
+        "defaults": {
+          VImg: {
+            cover: true,
+            src: props.image
+          },
+          VIcon: {
+            icon: props.icon
+          }
+        }
+      }, {
+        default: () => [slots.default()]
+      }), genOverlays(false, "v-avatar")]
+    }));
+    return {};
+  }
+});
+const DisplaySymbol = /* @__PURE__ */ Symbol.for("vuetify:display");
+const makeDisplayProps = propsFactory({
+  mobile: {
+    type: Boolean,
+    default: false
+  },
+  mobileBreakpoint: [Number, String]
+}, "display");
+function useDisplay() {
+  let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {
+    mobile: null
+  };
+  let name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : getCurrentInstanceName();
+  const display = vue.inject(DisplaySymbol);
+  if (!display) throw new Error("Could not find Vuetify display injection");
+  const mobile = vue.computed(() => {
+    if (props.mobile) {
+      return true;
+    } else if (typeof props.mobileBreakpoint === "number") {
+      return display.width.value < props.mobileBreakpoint;
+    } else if (props.mobileBreakpoint) {
+      return display.width.value < display.thresholds.value[props.mobileBreakpoint];
+    } else if (props.mobile === null) {
+      return display.mobile.value;
+    } else {
+      return false;
+    }
+  });
+  const displayClasses = vue.toRef(() => {
+    if (!name) return {};
+    return {
+      [`${name}--mobile`]: mobile.value
+    };
+  });
+  return {
+    ...display,
+    displayClasses,
+    mobile
+  };
+}
+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.toRef(() => {
+    const elevation = vue.isRef(props) ? props.value : props.elevation;
+    if (elevation == null) return [];
+    return [`elevation-${elevation}`];
+  });
+  return {
+    elevationClasses
+  };
+}
+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 getOffset(side2) {
+      return offset ? offset(side2) : 0;
+    }
+    const styles = {};
+    if (side !== "center") {
+      if (opposite) styles[oppositeMap[side]] = `calc(100% - ${getOffset(side)}px)`;
+      else styles[side] = 0;
+    }
+    if (align !== "center") {
+      if (opposite) styles[oppositeMap[align]] = `calc(100% - ${getOffset(align)}px)`;
+      else styles[align] = 0;
+    } else {
+      if (side === "center") styles.top = styles.left = "50%";
+      else {
+        styles[{
+          top: "left",
+          bottom: "left",
+          left: "top",
+          right: "top"
+        }[side]] = "50%";
+      }
+      styles.transform = {
+        top: "translateX(-50%)",
+        bottom: "translateX(-50%)",
+        left: "translateY(-50%)",
+        right: "translateY(-50%)",
+        center: "translate(-50%, -50%)"
+      }[side];
+    }
+    return styles;
+  });
+  return {
+    locationStyles
+  };
+}
+const positionValues = ["static", "relative", "fixed", "absolute", "sticky"];
+const makePositionProps = propsFactory({
+  position: {
+    type: String,
+    validator: (
+      /* istanbul ignore next */
+      (v) => positionValues.includes(v)
+    )
+  }
+}, "position");
+function usePosition(props) {
+  let name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : getCurrentInstanceName();
+  const positionClasses = vue.toRef(() => {
+    return props.position ? `${name}--${props.position}` : void 0;
+  });
+  return {
+    positionClasses
+  };
+}
+const makeVBannerProps = propsFactory({
+  avatar: String,
+  bgColor: String,
+  color: String,
+  icon: IconValue,
+  lines: String,
+  stacked: Boolean,
+  sticky: Boolean,
+  text: String,
+  ...makeBorderProps(),
+  ...makeComponentProps(),
+  ...makeDensityProps(),
+  ...makeDimensionProps(),
+  ...makeDisplayProps({
+    mobile: null
+  }),
+  ...makeElevationProps(),
+  ...makeLocationProps(),
+  ...makePositionProps(),
+  ...makeRoundedProps(),
+  ...makeTagProps(),
+  ...makeThemeProps()
+}, "VBanner");
+const VBanner = genericComponent()({
+  name: "VBanner",
+  props: makeVBannerProps(),
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    const {
+      backgroundColorClasses,
+      backgroundColorStyles
+    } = useBackgroundColor(() => props.bgColor);
+    const {
+      borderClasses
+    } = useBorder(props);
+    const {
+      densityClasses
+    } = useDensity(props);
+    const {
+      displayClasses,
+      mobile
+    } = useDisplay(props);
+    const {
+      dimensionStyles
+    } = useDimension(props);
+    const {
+      elevationClasses
+    } = useElevation(props);
+    const {
+      locationStyles
+    } = useLocation(props);
+    const {
+      positionClasses
+    } = usePosition(props);
+    const {
+      roundedClasses
+    } = useRounded(props);
+    const {
+      themeClasses
+    } = provideTheme(props);
+    const color = vue.toRef(() => props.color);
+    const density = vue.toRef(() => props.density);
+    provideDefaults({
+      VBannerActions: {
+        color,
+        density
+      }
+    });
+    useRender(() => {
+      const hasText = !!(props.text || slots.text);
+      const hasPrependMedia = !!(props.avatar || props.icon);
+      const hasPrepend = !!(hasPrependMedia || slots.prepend);
+      return vue.createVNode(props.tag, {
+        "class": vue.normalizeClass(["v-banner", {
+          "v-banner--stacked": props.stacked || mobile.value,
+          "v-banner--sticky": props.sticky,
+          [`v-banner--${props.lines}-line`]: !!props.lines
+        }, themeClasses.value, backgroundColorClasses.value, borderClasses.value, densityClasses.value, displayClasses.value, elevationClasses.value, positionClasses.value, roundedClasses.value, props.class]),
+        "style": vue.normalizeStyle([backgroundColorStyles.value, dimensionStyles.value, locationStyles.value, props.style]),
+        "role": "banner"
+      }, {
+        default: () => [hasPrepend && vue.createElementVNode("div", {
+          "key": "prepend",
+          "class": "v-banner__prepend"
+        }, [!slots.prepend ? vue.createVNode(VAvatar, {
+          "key": "prepend-avatar",
+          "color": color.value,
+          "density": density.value,
+          "icon": props.icon,
+          "image": props.avatar
+        }, null) : vue.createVNode(VDefaultsProvider, {
+          "key": "prepend-defaults",
+          "disabled": !hasPrependMedia,
+          "defaults": {
+            VAvatar: {
+              color: color.value,
+              density: density.value,
+              icon: props.icon,
+              image: props.avatar
+            }
+          }
+        }, slots.prepend)]), vue.createElementVNode("div", {
+          "class": "v-banner__content"
+        }, [hasText && vue.createVNode(VBannerText, {
+          "key": "text"
+        }, {
+          default: () => [slots.text?.() ?? props.text]
+        }), slots.default?.()]), slots.actions && vue.createVNode(VBannerActions, {
+          "key": "actions"
+        }, slots.actions)]
+      });
+    });
+  }
+});
+const makeVBtnGroupProps = propsFactory({
+  baseColor: String,
+  divided: Boolean,
+  direction: {
+    type: String,
+    default: "horizontal"
+  },
+  ...makeBorderProps(),
+  ...makeComponentProps(),
+  ...makeDensityProps(),
+  ...makeElevationProps(),
+  ...makeRoundedProps(),
+  ...makeTagProps(),
+  ...makeThemeProps(),
+  ...makeVariantProps()
+}, "VBtnGroup");
+const VBtnGroup = genericComponent()({
+  name: "VBtnGroup",
+  props: makeVBtnGroupProps(),
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    const {
+      themeClasses
+    } = provideTheme(props);
+    const {
+      densityClasses
+    } = useDensity(props);
+    const {
+      borderClasses
+    } = useBorder(props);
+    const {
+      elevationClasses
+    } = useElevation(props);
+    const {
+      roundedClasses
+    } = useRounded(props);
+    provideDefaults({
+      VBtn: {
+        height: vue.toRef(() => props.direction === "horizontal" ? "auto" : null),
+        baseColor: vue.toRef(() => props.baseColor),
+        color: vue.toRef(() => props.color),
+        density: vue.toRef(() => props.density),
+        flat: true,
+        variant: vue.toRef(() => props.variant)
+      }
+    });
+    useRender(() => {
+      return vue.createVNode(props.tag, {
+        "class": vue.normalizeClass(["v-btn-group", `v-btn-group--${props.direction}`, {
+          "v-btn-group--divided": props.divided
+        }, themeClasses.value, borderClasses.value, densityClasses.value, elevationClasses.value, roundedClasses.value, props.class]),
+        "style": vue.normalizeStyle(props.style)
+      }, slots);
+    });
+  }
+});
+const makeGroupProps = propsFactory({
+  modelValue: {
+    type: null,
+    default: void 0
+  },
+  multiple: Boolean,
+  mandatory: [Boolean, String],
+  max: Number,
+  selectedClass: String,
+  disabled: Boolean
+}, "group");
+const makeGroupItemProps = propsFactory({
+  value: null,
+  disabled: Boolean,
+  selectedClass: String
+}, "group-item");
+function useGroupItem(props, injectKey) {
+  let required = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : true;
+  const vm = getCurrentInstance("useGroupItem");
+  if (!vm) {
+    throw new Error("[Vuetify] useGroupItem composable must be used inside a component setup function");
+  }
+  const id = vue.useId();
+  vue.provide(/* @__PURE__ */ Symbol.for(`${injectKey.description}:id`), id);
+  const group = vue.inject(injectKey, null);
+  if (!group) {
+    if (!required) return group;
+    throw new Error(`[Vuetify] Could not find useGroup injection with symbol ${injectKey.description}`);
+  }
+  const value = vue.toRef(() => props.value);
+  const disabled = vue.computed(() => !!(group.disabled.value || props.disabled));
+  function register() {
+    group?.register({
+      id,
+      value,
+      disabled
+    }, vm);
+  }
+  function unregister() {
+    group?.unregister(id);
+  }
+  register();
+  vue.onBeforeUnmount(() => unregister());
+  const isSelected = vue.computed(() => {
+    return group.isSelected(id);
+  });
+  const isFirst = vue.computed(() => {
+    return group.items.value[0].id === id;
+  });
+  const isLast = vue.computed(() => {
+    return group.items.value[group.items.value.length - 1].id === id;
+  });
+  const selectedClass = vue.computed(() => isSelected.value && [group.selectedClass.value, props.selectedClass]);
+  vue.watch(isSelected, (value2) => {
+    vm.emit("group:selected", {
+      value: value2
+    });
+  }, {
+    flush: "sync"
+  });
+  return {
+    id,
+    isSelected,
+    isFirst,
+    isLast,
+    toggle: () => group.select(id, !isSelected.value),
+    select: (value2) => group.select(id, value2),
+    selectedClass,
+    value,
+    disabled,
+    group,
+    register,
+    unregister
+  };
+}
+function useGroup(props, injectKey) {
+  let isUnmounted = false;
+  const items = vue.reactive([]);
+  const selected = useProxiedModel(props, "modelValue", [], (v) => {
+    if (v === void 0) return [];
+    return getIds(items, v === null ? [null] : wrapInArray(v));
+  }, (v) => {
+    const arr = getValues(items, v);
+    return props.multiple ? arr : arr[0];
+  });
+  const groupVm = getCurrentInstance("useGroup");
+  function register(item, vm) {
+    const unwrapped = item;
+    const key = /* @__PURE__ */ Symbol.for(`${injectKey.description}:id`);
+    const children = findChildrenWithProvide(key, groupVm?.vnode);
+    const index = children.indexOf(vm);
+    if (vue.unref(unwrapped.value) === void 0) {
+      unwrapped.value = index;
+      unwrapped.useIndexAsValue = true;
+    }
+    if (index > -1) {
+      items.splice(index, 0, unwrapped);
+    } else {
+      items.push(unwrapped);
+    }
+  }
+  function unregister(id) {
+    if (isUnmounted) return;
+    forceMandatoryValue();
+    const index = items.findIndex((item) => item.id === id);
+    items.splice(index, 1);
+  }
+  function forceMandatoryValue() {
+    const item = items.find((item2) => !item2.disabled);
+    if (item && props.mandatory === "force" && !selected.value.length) {
+      selected.value = [item.id];
+    }
+  }
+  vue.onMounted(() => {
+    forceMandatoryValue();
+  });
+  vue.onBeforeUnmount(() => {
+    isUnmounted = true;
+  });
+  vue.onUpdated(() => {
+    for (let i = 0; i < items.length; i++) {
+      if (items[i].useIndexAsValue) {
+        items[i].value = i;
+      }
+    }
+  });
+  function select(id, value) {
+    const item = items.find((item2) => item2.id === id);
+    if (value && item?.disabled) return;
+    if (props.multiple) {
+      const internalValue = selected.value.slice();
+      const index = internalValue.findIndex((v) => v === id);
+      const isSelected = ~index;
+      value = value ?? !isSelected;
+      if (isSelected && props.mandatory && internalValue.length <= 1) return;
+      if (!isSelected && props.max != null && internalValue.length + 1 > props.max) return;
+      if (index < 0 && value) internalValue.push(id);
+      else if (index >= 0 && !value) internalValue.splice(index, 1);
+      selected.value = internalValue;
+    } else {
+      const isSelected = selected.value.includes(id);
+      if (props.mandatory && isSelected) return;
+      if (!isSelected && !value) return;
+      selected.value = value ?? !isSelected ? [id] : [];
+    }
+  }
+  function step(offset) {
+    if (props.multiple) consoleWarn('This method is not supported when using "multiple" prop');
+    if (!selected.value.length) {
+      const item = items.find((item2) => !item2.disabled);
+      item && (selected.value = [item.id]);
+    } else {
+      const currentId = selected.value[0];
+      const currentIndex = items.findIndex((i) => i.id === currentId);
+      let newIndex = (currentIndex + offset) % items.length;
+      let newItem = items[newIndex];
+      while (newItem.disabled && newIndex !== currentIndex) {
+        newIndex = (newIndex + offset) % items.length;
+        newItem = items[newIndex];
+      }
+      if (newItem.disabled) return;
+      selected.value = [items[newIndex].id];
+    }
+  }
+  const state = {
+    register,
+    unregister,
+    selected,
+    select,
+    disabled: vue.toRef(() => props.disabled),
+    prev: () => step(items.length - 1),
+    next: () => step(1),
+    isSelected: (id) => selected.value.includes(id),
+    selectedClass: vue.toRef(() => props.selectedClass),
+    items: vue.toRef(() => items),
+    getItemIndex: (value) => getItemIndex(items, value)
+  };
+  vue.provide(injectKey, state);
+  return state;
+}
+function getItemIndex(items, value) {
+  const ids = getIds(items, [value]);
+  if (!ids.length) return -1;
+  return items.findIndex((item) => item.id === ids[0]);
+}
+function getIds(items, modelValue) {
+  const ids = [];
+  modelValue.forEach((value) => {
+    const item = items.find((item2) => deepEqual(value, item2.value));
+    const itemByIndex = items[value];
+    if (item?.value !== void 0) {
+      ids.push(item.id);
+    } else if (itemByIndex?.useIndexAsValue) {
+      ids.push(itemByIndex.id);
+    }
+  });
+  return ids;
+}
+function getValues(items, ids) {
+  const values = [];
+  ids.forEach((id) => {
+    const itemIndex = items.findIndex((item) => item.id === id);
+    if (~itemIndex) {
+      const item = items[itemIndex];
+      values.push(item.value !== void 0 ? item.value : itemIndex);
+    }
+  });
+  return values;
+}
+const VBtnToggleSymbol = /* @__PURE__ */ Symbol.for("vuetify:v-btn-toggle");
+const makeVBtnToggleProps = propsFactory({
+  ...makeVBtnGroupProps(),
+  ...makeGroupProps()
+}, "VBtnToggle");
+genericComponent()({
+  name: "VBtnToggle",
+  props: makeVBtnToggleProps(),
+  emits: {
+    "update:modelValue": (value) => true
+  },
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    const {
+      isSelected,
+      next,
+      prev,
+      select,
+      selected
+    } = useGroup(props, VBtnToggleSymbol);
+    useRender(() => {
+      const btnGroupProps = VBtnGroup.filterProps(props);
+      return vue.createVNode(VBtnGroup, vue.mergeProps({
+        "class": ["v-btn-toggle", props.class]
+      }, btnGroupProps, {
+        "style": props.style
+      }), {
+        default: () => [slots.default?.({
+          isSelected,
+          next,
+          prev,
+          select,
+          selected
+        })]
+      });
+    });
+    return {
+      next,
+      prev,
+      select
+    };
+  }
+});
+function useIntersectionObserver(callback, options) {
+  const intersectionRef = vue.ref();
+  const isIntersecting = vue.shallowRef(false);
+  if (SUPPORTS_INTERSECTION) {
+    const observer = new IntersectionObserver((entries) => {
+      isIntersecting.value = !!entries.find((entry) => entry.isIntersecting);
+    }, options);
+    vue.onScopeDispose(() => {
+      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 makeVProgressCircularProps = propsFactory({
+  bgColor: String,
+  color: String,
+  indeterminate: [Boolean, String],
+  rounded: Boolean,
+  modelValue: {
+    type: [Number, String],
+    default: 0
+  },
+  rotate: {
+    type: [Number, String],
+    default: 0
+  },
+  width: {
+    type: [Number, String],
+    default: 4
+  },
+  ...makeComponentProps(),
+  ...makeSizeProps(),
+  ...makeTagProps({
+    tag: "div"
+  }),
+  ...makeThemeProps()
+}, "VProgressCircular");
+const VProgressCircular = genericComponent()({
+  name: "VProgressCircular",
+  props: makeVProgressCircularProps(),
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    const MAGIC_RADIUS_CONSTANT = 20;
+    const CIRCUMFERENCE = 2 * Math.PI * MAGIC_RADIUS_CONSTANT;
+    const root = vue.ref();
+    const {
+      themeClasses
+    } = provideTheme(props);
+    const {
+      sizeClasses,
+      sizeStyles
+    } = useSize(props);
+    const {
+      textColorClasses,
+      textColorStyles
+    } = useTextColor(() => props.color);
+    const {
+      textColorClasses: underlayColorClasses,
+      textColorStyles: underlayColorStyles
+    } = useTextColor(() => props.bgColor);
+    const {
+      intersectionRef,
+      isIntersecting
+    } = useIntersectionObserver();
+    const {
+      resizeRef,
+      contentRect
+    } = useResizeObserver();
+    const normalizedValue = vue.toRef(() => clamp(parseFloat(props.modelValue), 0, 100));
+    const width = vue.toRef(() => Number(props.width));
+    const size = vue.toRef(() => {
+      return sizeStyles.value ? Number(props.size) : contentRect.value ? contentRect.value.width : Math.max(width.value, 32);
+    });
+    const diameter = vue.toRef(() => MAGIC_RADIUS_CONSTANT / (1 - width.value / size.value) * 2);
+    const strokeWidth = vue.toRef(() => width.value / size.value * diameter.value);
+    const strokeDashOffset = vue.toRef(() => {
+      const baseLength = (100 - normalizedValue.value) / 100 * CIRCUMFERENCE;
+      return props.rounded && normalizedValue.value > 0 && normalizedValue.value < 100 ? convertToUnit(Math.min(CIRCUMFERENCE - 0.01, baseLength + strokeWidth.value)) : convertToUnit(baseLength);
+    });
+    const startAngle = vue.computed(() => {
+      const baseAngle = Number(props.rotate);
+      return props.rounded ? baseAngle + strokeWidth.value / 2 / CIRCUMFERENCE * 360 : baseAngle;
+    });
+    vue.watchEffect(() => {
+      intersectionRef.value = root.value;
+      resizeRef.value = root.value;
+    });
+    useRender(() => vue.createVNode(props.tag, {
+      "ref": root,
+      "class": vue.normalizeClass(["v-progress-circular", {
+        "v-progress-circular--indeterminate": !!props.indeterminate,
+        "v-progress-circular--visible": isIntersecting.value,
+        "v-progress-circular--disable-shrink": props.indeterminate && (props.indeterminate === "disable-shrink" || PREFERS_REDUCED_MOTION())
+      }, themeClasses.value, sizeClasses.value, textColorClasses.value, props.class]),
+      "style": vue.normalizeStyle([sizeStyles.value, textColorStyles.value, props.style]),
+      "role": "progressbar",
+      "aria-valuemin": "0",
+      "aria-valuemax": "100",
+      "aria-valuenow": props.indeterminate ? void 0 : normalizedValue.value
+    }, {
+      default: () => [vue.createElementVNode("svg", {
+        "style": {
+          transform: `rotate(calc(-90deg + ${startAngle.value}deg))`
+        },
+        "xmlns": "http://www.w3.org/2000/svg",
+        "viewBox": `0 0 ${diameter.value} ${diameter.value}`
+      }, [vue.createElementVNode("circle", {
+        "class": vue.normalizeClass(["v-progress-circular__underlay", underlayColorClasses.value]),
+        "style": vue.normalizeStyle(underlayColorStyles.value),
+        "fill": "transparent",
+        "cx": "50%",
+        "cy": "50%",
+        "r": MAGIC_RADIUS_CONSTANT,
+        "stroke-width": strokeWidth.value,
+        "stroke-dasharray": CIRCUMFERENCE,
+        "stroke-dashoffset": 0
+      }, null), vue.createElementVNode("circle", {
+        "class": "v-progress-circular__overlay",
+        "fill": "transparent",
+        "cx": "50%",
+        "cy": "50%",
+        "r": MAGIC_RADIUS_CONSTANT,
+        "stroke-width": strokeWidth.value,
+        "stroke-dasharray": CIRCUMFERENCE,
+        "stroke-dashoffset": strokeDashOffset.value,
+        "stroke-linecap": props.rounded ? "round" : void 0
+      }, null)]), slots.default && vue.createElementVNode("div", {
+        "class": "v-progress-circular__content"
+      }, [slots.default({
+        value: normalizedValue.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.toRef(() => ({
+    [`${name}--loading`]: props.loading
+  }));
+  return {
+    loaderClasses
+  };
+}
+function useRoute() {
+  const vm = getCurrentInstance("useRoute");
+  return vue.computed(() => vm?.proxy?.$route);
+}
+function useLink(props, attrs) {
+  const RouterLink = vue.resolveDynamicComponent("RouterLink");
+  const isLink = vue.toRef(() => !!(props.href || props.to));
+  const isClickable = vue.computed(() => {
+    return isLink?.value || hasEvent(attrs, "click") || hasEvent(props, "click");
+  });
+  if (typeof RouterLink === "string" || !("useLink" in RouterLink)) {
+    const href2 = vue.toRef(() => props.href);
+    return {
+      isLink,
+      isRouterLink: vue.toRef(() => false),
+      isClickable,
+      href: href2,
+      linkProps: vue.reactive({
+        href: href2
+      })
+    };
+  }
+  const routerLink = RouterLink.useLink({
+    to: vue.toRef(() => props.to || ""),
+    replace: vue.toRef(() => props.replace)
+  });
+  const link = vue.computed(() => props.to ? routerLink : void 0);
+  const route = useRoute();
+  const isActive = vue.computed(() => {
+    if (!link.value) return false;
+    if (!props.exact) return link.value.isActive?.value ?? false;
+    if (!route.value) return link.value.isExactActive?.value ?? false;
+    return link.value.isExactActive?.value && deepEqual(link.value.route.value.query, route.value.query);
+  });
+  const href = vue.computed(() => props.to ? link.value?.route.value.href : props.href);
+  const isRouterLink = vue.toRef(() => !!props.to);
+  return {
+    isLink,
+    isRouterLink,
+    isClickable,
+    isActive,
+    route: link.value?.route,
+    navigate: link.value?.navigate,
+    href,
+    linkProps: vue.reactive({
+      href,
+      "aria-current": vue.toRef(() => isActive.value ? "page" : void 0),
+      "aria-disabled": vue.toRef(() => props.disabled && isLink.value ? "true" : void 0),
+      tabindex: vue.toRef(() => props.disabled && isLink.value ? "-1" : void 0)
+    })
+  };
+}
+const makeRouterProps = propsFactory({
+  href: String,
+  replace: Boolean,
+  to: [String, Object],
+  exact: Boolean
+}, "router");
+function useSelectLink(link, select) {
+  vue.watch(() => link.isActive?.value, (isActive) => {
+    if (link.isLink.value && isActive != null && select) {
+      vue.nextTick(() => {
+        select(isActive);
+      });
+    }
+  }, {
+    immediate: true
+  });
+}
+const stopSymbol = /* @__PURE__ */ 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) {
+  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 (el._ripple?.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) {
+    let value = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+    if (!el?._ripple?.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());
+    requestAnimationFrame(() => {
+      requestAnimationFrame(() => {
+        animation.classList.remove("v-ripple__animation--enter");
+        animation.classList.add("v-ripple__animation--in");
+        transform(animation, `translate(${centerX}, ${centerY}) scale3d(1,1,1)`);
+      });
+    });
+  },
+  hide(el) {
+    if (!el?._ripple?.enabled) return;
+    const ripples2 = el.getElementsByClassName("v-ripple__animation");
+    if (ripples2.length === 0) return;
+    const animation = Array.from(ripples2).findLast((ripple) => !ripple.dataset.isHiding);
+    if (!animation) 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(() => {
+        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 (animation.parentNode?.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?._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(() => {
+      if (element?._ripple?.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?._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?._ripple) return;
+  if (element._ripple.showTimerCommit) {
+    element._ripple.showTimerCommit = null;
+  }
+  window.clearTimeout(element._ripple.showTimer);
+}
+let keyboardRipple = false;
+function keyboardRippleShow(e, keys) {
+  if (!keyboardRipple && keys.includes(e.key)) {
+    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;
+  const bindingValue = isObject(value) ? value : {};
+  if (bindingValue.class) {
+    el._ripple.class = bindingValue.class;
+  }
+  const allowedKeys = bindingValue.keys ?? ["Enter", "Space"];
+  el._ripple.keyDownHandler = (e) => keyboardRippleShow(e, allowedKeys);
+  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", el._ripple.keyDownHandler);
+    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("touchstart", rippleStop);
+  el.removeEventListener("mousedown", rippleStop);
+  el.removeEventListener("touchstart", rippleShow);
+  el.removeEventListener("touchend", rippleHide);
+  el.removeEventListener("touchmove", rippleCancelShow);
+  el.removeEventListener("touchcancel", rippleHide);
+  el.removeEventListener("mousedown", rippleShow);
+  el.removeEventListener("mouseup", rippleHide);
+  el.removeEventListener("mouseleave", rippleHide);
+  if (el._ripple?.keyDownHandler) {
+    el.removeEventListener("keydown", el._ripple.keyDownHandler);
+  }
+  el.removeEventListener("keyup", keyboardRippleHide);
+  el.removeEventListener("blur", focusRippleHide);
+  el.removeEventListener("dragstart", rippleHide);
+}
+function mounted(el, binding) {
+  updateRipple(el, binding, false);
+}
+function unmounted(el) {
+  removeListeners(el);
+  delete el._ripple;
+}
+function updated(el, binding) {
+  if (binding.value === binding.oldValue) {
+    return;
+  }
+  const wasEnabled = isRippleEnabled(binding.oldValue);
+  updateRipple(el, binding, wasEnabled);
+}
+const Ripple = {
+  mounted,
+  unmounted,
+  updated
+};
+const makeVBtnProps = propsFactory({
+  active: {
+    type: Boolean,
+    default: void 0
+  },
+  activeColor: String,
+  baseColor: String,
+  symbol: {
+    type: null,
+    default: VBtnToggleSymbol
+  },
+  flat: Boolean,
+  icon: [Boolean, String, Function, Object],
+  prependIcon: IconValue,
+  appendIcon: IconValue,
+  block: Boolean,
+  readonly: Boolean,
+  slim: Boolean,
+  stacked: Boolean,
+  spaced: String,
+  ripple: {
+    type: [Boolean, Object],
+    default: true
+  },
+  text: {
+    type: [String, Number, Boolean],
+    default: void 0
+  },
+  ...makeBorderProps(),
+  ...makeComponentProps(),
+  ...makeDensityProps(),
+  ...makeDimensionProps(),
+  ...makeElevationProps(),
+  ...makeGroupItemProps(),
+  ...makeLoaderProps(),
+  ...makeLocationProps(),
+  ...makePositionProps(),
+  ...makeRoundedProps(),
+  ...makeRouterProps(),
+  ...makeSizeProps(),
+  ...makeTagProps({
+    tag: "button"
+  }),
+  ...makeThemeProps(),
+  ...makeVariantProps({
+    variant: "elevated"
+  })
+}, "VBtn");
+const VBtn = genericComponent()({
+  name: "VBtn",
+  props: makeVBtnProps(),
+  emits: {
+    "group:selected": (val) => true
+  },
+  setup(props, _ref) {
+    let {
+      attrs,
+      slots
+    } = _ref;
+    const {
+      themeClasses
+    } = provideTheme(props);
+    const {
+      borderClasses
+    } = useBorder(props);
+    const {
+      densityClasses
+    } = useDensity(props);
+    const {
+      dimensionStyles
+    } = useDimension(props);
+    const {
+      elevationClasses
+    } = useElevation(props);
+    const {
+      loaderClasses
+    } = useLoader(props);
+    const {
+      locationStyles
+    } = useLocation(props);
+    const {
+      positionClasses
+    } = usePosition(props);
+    const {
+      roundedClasses
+    } = useRounded(props);
+    const {
+      sizeClasses,
+      sizeStyles
+    } = useSize(props);
+    const group = useGroupItem(props, props.symbol, false);
+    const link = useLink(props, attrs);
+    const isActive = vue.computed(() => {
+      if (props.active !== void 0) {
+        return props.active;
+      }
+      if (link.isRouterLink.value) {
+        return link.isActive?.value;
+      }
+      return group?.isSelected.value;
+    });
+    const color = vue.toRef(() => isActive.value ? props.activeColor ?? props.color : props.color);
+    const variantProps = vue.computed(() => {
+      const showColor = group?.isSelected.value && (!link.isLink.value || link.isActive?.value) || !group || link.isActive?.value;
+      return {
+        color: showColor ? color.value ?? props.baseColor : props.baseColor,
+        variant: props.variant
+      };
+    });
+    const {
+      colorClasses,
+      colorStyles,
+      variantClasses
+    } = useVariant(variantProps);
+    const isDisabled = vue.computed(() => group?.disabled.value || props.disabled);
+    const isElevated = vue.toRef(() => {
+      return props.variant === "elevated" && !(props.disabled || props.flat || props.border);
+    });
+    const valueAttr = vue.computed(() => {
+      if (props.value === void 0 || typeof props.value === "symbol") return void 0;
+      return Object(props.value) === props.value ? JSON.stringify(props.value, null, 0) : props.value;
+    });
+    function onClick(e) {
+      if (isDisabled.value || link.isLink.value && (e.metaKey || e.ctrlKey || e.shiftKey || e.button !== 0 || attrs.target === "_blank")) return;
+      if (link.isRouterLink.value) {
+        link.navigate?.(e);
+      } else {
+        group?.toggle();
+      }
+    }
+    useSelectLink(link, group?.select);
+    useRender(() => {
+      const Tag = link.isLink.value ? "a" : props.tag;
+      const hasPrepend = !!(props.prependIcon || slots.prepend);
+      const hasAppend = !!(props.appendIcon || slots.append);
+      const hasIcon = !!(props.icon && props.icon !== true);
+      return vue.withDirectives(vue.createVNode(Tag, vue.mergeProps(link.linkProps, {
+        "type": Tag === "a" ? void 0 : "button",
+        "class": ["v-btn", group?.selectedClass.value, {
+          "v-btn--active": isActive.value,
+          "v-btn--block": props.block,
+          "v-btn--disabled": isDisabled.value,
+          "v-btn--elevated": isElevated.value,
+          "v-btn--flat": props.flat,
+          "v-btn--icon": !!props.icon,
+          "v-btn--loading": props.loading,
+          "v-btn--readonly": props.readonly,
+          "v-btn--slim": props.slim,
+          "v-btn--stacked": props.stacked
+        }, props.spaced ? ["v-btn--spaced", `v-btn--spaced-${props.spaced}`] : [], themeClasses.value, borderClasses.value, colorClasses.value, densityClasses.value, elevationClasses.value, loaderClasses.value, positionClasses.value, roundedClasses.value, sizeClasses.value, variantClasses.value, props.class],
+        "style": [colorStyles.value, dimensionStyles.value, locationStyles.value, sizeStyles.value, props.style],
+        "aria-busy": props.loading ? true : void 0,
+        "disabled": isDisabled.value && Tag !== "a" || void 0,
+        "tabindex": props.loading || props.readonly ? -1 : void 0,
+        "onClick": onClick,
+        "value": valueAttr.value
+      }), {
+        default: () => [genOverlays(true, "v-btn"), !props.icon && hasPrepend && vue.createElementVNode("span", {
+          "key": "prepend",
+          "class": "v-btn__prepend"
+        }, [!slots.prepend ? vue.createVNode(VIcon, {
+          "key": "prepend-icon",
+          "icon": props.prependIcon
+        }, null) : vue.createVNode(VDefaultsProvider, {
+          "key": "prepend-defaults",
+          "disabled": !props.prependIcon,
+          "defaults": {
+            VIcon: {
+              icon: props.prependIcon
+            }
+          }
+        }, slots.prepend)]), vue.createElementVNode("span", {
+          "class": "v-btn__content",
+          "data-no-activator": ""
+        }, [!slots.default && hasIcon ? vue.createVNode(VIcon, {
+          "key": "content-icon",
+          "icon": props.icon
+        }, null) : vue.createVNode(VDefaultsProvider, {
+          "key": "content-defaults",
+          "disabled": !hasIcon,
+          "defaults": {
+            VIcon: {
+              icon: props.icon
+            }
+          }
+        }, {
+          default: () => [slots.default?.() ?? vue.toDisplayString(props.text)]
+        })]), !props.icon && hasAppend && vue.createElementVNode("span", {
+          "key": "append",
+          "class": "v-btn__append"
+        }, [!slots.append ? vue.createVNode(VIcon, {
+          "key": "append-icon",
+          "icon": props.appendIcon
+        }, null) : vue.createVNode(VDefaultsProvider, {
+          "key": "append-defaults",
+          "disabled": !props.appendIcon,
+          "defaults": {
+            VIcon: {
+              icon: props.appendIcon
+            }
+          }
+        }, slots.append)]), !!props.loading && vue.createElementVNode("span", {
+          "key": "loader",
+          "class": "v-btn__loader"
+        }, [slots.loader?.() ?? vue.createVNode(VProgressCircular, {
+          "color": typeof props.loading === "boolean" ? void 0 : props.loading,
+          "indeterminate": true,
+          "width": "2"
+        }, null)])]
+      }), [[Ripple, !isDisabled.value && props.ripple, "", {
+        center: !!props.icon
+      }]]);
+    });
+    return {
+      group
+    };
+  }
+});
+function useSsrBoot() {
+  const isBooted = vue.shallowRef(false);
+  vue.onMounted(() => {
+    window.requestAnimationFrame(() => {
+      isBooted.value = true;
+    });
+  });
+  const ssrBootStyles = vue.toRef(() => !isBooted.value ? {
+    transition: "none !important"
+  } : void 0);
+  return {
+    ssrBootStyles,
+    isBooted: vue.readonly(isBooted)
+  };
+}
+const makeVMainProps = propsFactory({
+  scrollable: Boolean,
+  ...makeComponentProps(),
+  ...makeDimensionProps(),
+  ...makeTagProps({
+    tag: "main"
+  })
+}, "VMain");
+const VMain = genericComponent()({
+  name: "VMain",
+  props: makeVMainProps(),
+  setup(props, _ref) {
+    let {
+      slots
+    } = _ref;
+    const {
+      dimensionStyles
+    } = useDimension(props);
+    const {
+      mainStyles
+    } = useLayout();
+    const {
+      ssrBootStyles
+    } = useSsrBoot();
+    useRender(() => vue.createVNode(props.tag, {
+      "class": vue.normalizeClass(["v-main", {
+        "v-main--scrollable": props.scrollable
+      }, props.class]),
+      "style": vue.normalizeStyle([mainStyles.value, ssrBootStyles.value, dimensionStyles.value, props.style])
+    }, {
+      default: () => [props.scrollable ? vue.createElementVNode("div", {
+        "class": "v-main__scroller"
+      }, [slots.default?.()]) : slots.default?.()]
+    }));
+    return {};
+  }
+});
+const _hoisted_1 = {
+  key: 1,
+  class: "d-flex align-center justify-center",
+  style: { "height": "200px" }
+};
+const _sfc_main = /* @__PURE__ */ Object.assign({
+  name: "PreviewApp"
+}, {
+  __name: "App",
+  setup(__props, { expose: __expose }) {
+    const currentTheme = vue.ref("light");
+    const pluginComponent = vue.shallowRef(null);
+    const toggleTheme = () => {
+      currentTheme.value = currentTheme.value === "light" ? "dark" : "light";
+    };
+    vue.onMounted(() => {
+      if (window.__PREVIEW_PLUGIN_COMPONENT__) {
+        pluginComponent.value = window.__PREVIEW_PLUGIN_COMPONENT__;
+      }
+    });
+    __expose({
+      setPluginComponent: (component) => {
+        pluginComponent.value = component;
+      }
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(VApp, { theme: currentTheme.value }, {
+        default: vue.withCtx(() => [
+          vue.createVNode(VMain, null, {
+            default: vue.withCtx(() => [
+              vue.createVNode(VBanner, {
+                density: "compact",
+                color: "info",
+                lines: "one"
+              }, {
+                text: vue.withCtx(() => _cache[0] || (_cache[0] = [
+                  vue.createElementVNode("span", { class: "text-caption" }, "Preview 模式 - Electron API 已 mock", -1)
+                ])),
+                actions: vue.withCtx(() => [
+                  vue.createVNode(VBtn, {
+                    variant: "text",
+                    icon: currentTheme.value === "light" ? "dark_mode" : "light_mode",
+                    onClick: toggleTheme
+                  }, null, 8, ["icon"])
+                ]),
+                _: 1
+              }),
+              pluginComponent.value ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(pluginComponent.value), { key: 0 })) : (vue.openBlock(), vue.createElementBlock("div", _hoisted_1, _cache[1] || (_cache[1] = [
+                vue.createElementVNode("span", { class: "text-medium-emphasis" }, "加载中...", -1)
+              ])))
+            ]),
+            _: 1
+          })
+        ]),
+        _: 1
+      }, 8, ["theme"]);
+    };
+  }
+});
+const PreviewApp = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-10207be4"]]);
+async function startPreview(pluginComponent, options = {}) {
+  const { mountId = "app" } = options;
+  previewMock.initPreviewMock();
+  const vuetify$1 = vuetify.createVuetify({
+    components: components__namespace,
+    directives: directives__namespace,
+    locale: {
+      locale: "zhHans",
+      messages: { zhHans: locale.zhHans }
+    },
+    icons: {
+      defaultSet: "md",
+      aliases: md.aliases,
+      sets: { md: md.md }
+    },
+    theme: {
+      defaultTheme: "light",
+      layers: true,
+      themes: {
+        light: {
+          colors: {
+            primary: "#00639b",
+            "on-primary": "#ffffff",
+            "primary-container": "#cee5ff",
+            "on-primary-container": "#004a76",
+            "inverse-primary": "#96cbff",
+            "primary-fixed": "#cee5ff",
+            "primary-fixed-dim": "#96cbff",
+            "on-primary-fixed": "#001d33",
+            "on-primary-fixed-variant": "#004a76",
+            secondary: "#51606f",
+            "on-secondary": "#ffffff",
+            "secondary-container": "#d5e4f7",
+            "on-secondary-container": "#3a4857",
+            "secondary-fixed": "#d5e4f7",
+            "secondary-fixed-dim": "#b9c8da",
+            "on-secondary-fixed": "#0e1d2a",
+            "on-secondary-fixed-variant": "#3a4857",
+            tertiary: "#68587a",
+            "on-tertiary": "#ffffff",
+            "tertiary-container": "#eedbff",
+            "on-tertiary-container": "#504061",
+            "tertiary-fixed": "#eedbff",
+            "tertiary-fixed-dim": "#d3bfe6",
+            "on-tertiary-fixed": "#231533",
+            "on-tertiary-fixed-variant": "#504061",
+            error: "#ba1a1a",
+            "on-error": "#ffffff",
+            "error-container": "#ffdad6",
+            "on-error-container": "#93000a",
+            "surface-dim": "#dadada",
+            surface: "#f9f9f9",
+            "surface-bright": "#f9f9f9",
+            "surface-container-lowest": "#ffffff",
+            "surface-container-low": "#f3f3f3",
+            "surface-container": "#eeeeee",
+            "surface-container-high": "#e8e8e8",
+            "surface-container-highest": "#e2e2e2",
+            "on-surface": "#1b1b1b",
+            "on-surface-variant": "#474747",
+            outline: "#777777",
+            "outline-variant": "#c6c6c6",
+            "inverse-surface": "#303030",
+            "inverse-on-surface": "#f1f1f1",
+            "surface-variant": "#e2e2e2",
+            "surface-tint": "#00639b",
+            background: "#f9f9f9",
+            "on-background": "#1b1b1b",
+            shadow: "#000000",
+            scrim: "#000000"
+          },
+          dark: false
+        },
+        dark: {
+          colors: {
+            primary: "#96cbff",
+            "on-primary": "#003353",
+            "primary-container": "#004a76",
+            "on-primary-container": "#cee5ff",
+            "inverse-primary": "#00639b",
+            "primary-fixed": "#cee5ff",
+            "primary-fixed-dim": "#96cbff",
+            "on-primary-fixed": "#001d33",
+            "on-primary-fixed-variant": "#004a76",
+            secondary: "#b9c8da",
+            "on-secondary": "#233240",
+            "secondary-container": "#3a4857",
+            "on-secondary-container": "#d5e4f7",
+            "secondary-fixed": "#d5e4f7",
+            "secondary-fixed-dim": "#b9c8da",
+            "on-secondary-fixed": "#0e1d2a",
+            "on-secondary-fixed-variant": "#3a4857",
+            tertiary: "#d3bfe6",
+            "on-tertiary": "#382a49",
+            "tertiary-container": "#504061",
+            "on-tertiary-container": "#eedbff",
+            "tertiary-fixed": "#eedbff",
+            "tertiary-fixed-dim": "#d3bfe6",
+            "on-tertiary-fixed": "#231533",
+            "on-tertiary-fixed-variant": "#504061",
+            error: "#ffb4ab",
+            "on-error": "#690005",
+            "error-container": "#93000a",
+            "on-error-container": "#ffdad6",
+            "surface-dim": "#131313",
+            surface: "#131313",
+            "surface-bright": "#393939",
+            "surface-container-lowest": "#0e0e0e",
+            "surface-container-low": "#1b1b1b",
+            "surface-container": "#1f1f1f",
+            "surface-container-high": "#2a2a2a",
+            "surface-container-highest": "#353535",
+            "on-surface": "#e2e2e2",
+            "on-surface-variant": "#c6c6c6",
+            outline: "#919191",
+            "outline-variant": "#474747",
+            "inverse-surface": "#e2e2e2",
+            "inverse-on-surface": "#303030",
+            "surface-variant": "#474747",
+            "surface-tint": "#96cbff",
+            background: "#131313",
+            "on-background": "#e2e2e2",
+            shadow: "#000000",
+            scrim: "#000000"
+          },
+          dark: true
+        }
+      }
+    },
+    defaults: {
+      VBtn: {
+        class: "normal-case"
+      },
+      VSwitch: {
+        color: "primary",
+        hideDetails: true,
+        inset: true,
+        trueIcon: "check"
+      },
+      VCard: {
+        color: "surface-container"
+      }
+    },
+    blueprint: blueprints.md3
+  });
+  window.vuetify$ = {
+    instance: vuetify$1,
+    components: components__namespace,
+    directives: directives__namespace
+  };
+  window.__PREVIEW_PLUGIN_COMPONENT__ = pluginComponent;
+  const app = vue.createApp(PreviewApp);
+  app.use(vuetify$1);
+  let mountEl = document.getElementById(mountId);
+  if (!mountEl) {
+    mountEl = document.createElement("div");
+    mountEl.id = mountId;
+    document.body.appendChild(mountEl);
+  }
+  app.mount(`#${mountId}`);
+  console.log("[Preview] 插件预览模式已启动");
+  return app;
+}
+exports.default = startPreview;
+exports.startPreview = startPreview;
+//# sourceMappingURL=preview.cjs.map