@wdslib/web-design/dist/web-design.js

This template should help get you started developing with Vue 3 and TypeScript in Vite. The template uses Vue 3 `<script setup>` SFCs, check out the [script setup docs](https://v3.vuejs.org/api/sfc-script-setup.html#sfc-script-setup) to learn more.

var M6 = Object.defineProperty, V6 = Object.defineProperties;
var S6 = Object.getOwnPropertyDescriptors;
var q6 = Object.getOwnPropertySymbols;
var T6 = Object.prototype.hasOwnProperty, R6 = Object.prototype.propertyIsEnumerable;
var O6 = (e, t, o) => t in e ? M6(e, t, { enumerable: !0, configurable: !0, writable: !0, value: o }) : e[t] = o, o6 = (e, t) => {
  for (var o in t || (t = {}))
    T6.call(t, o) && O6(e, o, t[o]);
  if (q6)
    for (var o of q6(t))
      R6.call(t, o) && O6(e, o, t[o]);
  return e;
}, c6 = (e, t) => V6(e, S6(t));
/**
* @vue/shared v3.4.38
* (c) 2018-present Yuxi (Evan) You and Vue contributors
* @license MIT
**/
/*! #__NO_SIDE_EFFECTS__ */
// @__NO_SIDE_EFFECTS__
function makeMap(e, t) {
  const o = new Set(e.split(","));
  return (n) => o.has(n);
}
const EMPTY_OBJ = process.env.NODE_ENV !== "production" ? Object.freeze({}) : {}, EMPTY_ARR = process.env.NODE_ENV !== "production" ? Object.freeze([]) : [], NOOP = () => {
}, NO = () => !1, isOn = (e) => e.charCodeAt(0) === 111 && e.charCodeAt(1) === 110 && // uppercase letter
(e.charCodeAt(2) > 122 || e.charCodeAt(2) < 97), isModelListener = (e) => e.startsWith("onUpdate:"), extend = Object.assign, remove = (e, t) => {
  const o = e.indexOf(t);
  o > -1 && e.splice(o, 1);
}, hasOwnProperty$1 = Object.prototype.hasOwnProperty, hasOwn = (e, t) => hasOwnProperty$1.call(e, t), isArray = Array.isArray, isMap = (e) => toTypeString(e) === "[object Map]", isSet = (e) => toTypeString(e) === "[object Set]", isFunction = (e) => typeof e == "function", isString = (e) => typeof e == "string", isSymbol = (e) => typeof e == "symbol", isObject = (e) => e !== null && typeof e == "object", isPromise = (e) => (isObject(e) || isFunction(e)) && isFunction(e.then) && isFunction(e.catch), objectToString = Object.prototype.toString, toTypeString = (e) => objectToString.call(e), toRawType = (e) => toTypeString(e).slice(8, -1), isPlainObject = (e) => toTypeString(e) === "[object Object]", isIntegerKey = (e) => isString(e) && e !== "NaN" && e[0] !== "-" && "" + parseInt(e, 10) === e, isReservedProp = /* @__PURE__ */ makeMap(
  // the leading comma is intentional so empty string "" is also included
  ",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"
), isBuiltInDirective = /* @__PURE__ */ makeMap(
  "bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo"
), cacheStringFunction = (e) => {
  const t = /* @__PURE__ */ Object.create(null);
  return (o) => t[o] || (t[o] = e(o));
}, camelizeRE = /-(\w)/g, camelize = cacheStringFunction((e) => e.replace(camelizeRE, (t, o) => o ? o.toUpperCase() : "")), hyphenateRE = /\B([A-Z])/g, hyphenate = cacheStringFunction(
  (e) => e.replace(hyphenateRE, "-$1").toLowerCase()
), capitalize = cacheStringFunction((e) => e.charAt(0).toUpperCase() + e.slice(1)), toHandlerKey = cacheStringFunction((e) => e ? `on${capitalize(e)}` : ""), hasChanged = (e, t) => !Object.is(e, t), invokeArrayFns = (e, ...t) => {
  for (let o = 0; o < e.length; o++)
    e[o](...t);
}, def = (e, t, o, n = !1) => {
  Object.defineProperty(e, t, {
    configurable: !0,
    enumerable: !1,
    writable: n,
    value: o
  });
}, looseToNumber = (e) => {
  const t = parseFloat(e);
  return isNaN(t) ? e : t;
}, toNumber = (e) => {
  const t = isString(e) ? Number(e) : NaN;
  return isNaN(t) ? e : t;
};
let _globalThis;
const getGlobalThis = () => _globalThis || (_globalThis = typeof globalThis != "undefined" ? globalThis : typeof self != "undefined" ? self : typeof window != "undefined" ? window : typeof global != "undefined" ? global : {});
function normalizeStyle(e) {
  if (isArray(e)) {
    const t = {};
    for (let o = 0; o < e.length; o++) {
      const n = e[o], r = isString(n) ? parseStringStyle(n) : normalizeStyle(n);
      if (r)
        for (const s in r)
          t[s] = r[s];
    }
    return t;
  } else if (isString(e) || isObject(e))
    return e;
}
const listDelimiterRE = /;(?![^(]*\))/g, propertyDelimiterRE = /:([^]+)/, styleCommentRE = /\/\*[^]*?\*\//g;
function parseStringStyle(e) {
  const t = {};
  return e.replace(styleCommentRE, "").split(listDelimiterRE).forEach((o) => {
    if (o) {
      const n = o.split(propertyDelimiterRE);
      n.length > 1 && (t[n[0].trim()] = n[1].trim());
    }
  }), t;
}
function normalizeClass(e) {
  let t = "";
  if (isString(e))
    t = e;
  else if (isArray(e))
    for (let o = 0; o < e.length; o++) {
      const n = normalizeClass(e[o]);
      n && (t += n + " ");
    }
  else if (isObject(e))
    for (const o in e)
      e[o] && (t += o + " ");
  return t.trim();
}
const specialBooleanAttrs = "itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly", isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);
function includeBooleanAttr(e) {
  return !!e || e === "";
}
const isRef$1 = (e) => !!(e && e.__v_isRef === !0), toDisplayString = (e) => isString(e) ? e : e == null ? "" : isArray(e) || isObject(e) && (e.toString === objectToString || !isFunction(e.toString)) ? isRef$1(e) ? toDisplayString(e.value) : JSON.stringify(e, replacer, 2) : String(e), replacer = (e, t) => isRef$1(t) ? replacer(e, t.value) : isMap(t) ? {
  [`Map(${t.size})`]: [...t.entries()].reduce(
    (o, [n, r], s) => (o[stringifySymbol(n, s) + " =>"] = r, o),
    {}
  )
} : isSet(t) ? {
  [`Set(${t.size})`]: [...t.values()].map((o) => stringifySymbol(o))
} : isSymbol(t) ? stringifySymbol(t) : isObject(t) && !isArray(t) && !isPlainObject(t) ? String(t) : t, stringifySymbol = (e, t = "") => {
  var o;
  return (
    // Symbol.description in es2019+ so we need to cast here to pass
    // the lib: es2016 check
    isSymbol(e) ? `Symbol(${(o = e.description) != null ? o : t})` : e
  );
};
/**
* @vue/reactivity v3.4.38
* (c) 2018-present Yuxi (Evan) You and Vue contributors
* @license MIT
**/
function warn$2(e, ...t) {
  console.warn(`[Vue warn] ${e}`, ...t);
}
let activeEffectScope;
class EffectScope {
  constructor(t = !1) {
    this.detached = t, this._active = !0, this.effects = [], this.cleanups = [], this.parent = activeEffectScope, !t && activeEffectScope && (this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(
      this
    ) - 1);
  }
  get active() {
    return this._active;
  }
  run(t) {
    if (this._active) {
      const o = activeEffectScope;
      try {
        return activeEffectScope = this, t();
      } finally {
        activeEffectScope = o;
      }
    } else process.env.NODE_ENV !== "production" && warn$2("cannot run an inactive effect scope.");
  }
  /**
   * This should only be called on non-detached scopes
   * @internal
   */
  on() {
    activeEffectScope = this;
  }
  /**
   * This should only be called on non-detached scopes
   * @internal
   */
  off() {
    activeEffectScope = this.parent;
  }
  stop(t) {
    if (this._active) {
      let o, n;
      for (o = 0, n = this.effects.length; o < n; o++)
        this.effects[o].stop();
      for (o = 0, n = this.cleanups.length; o < n; o++)
        this.cleanups[o]();
      if (this.scopes)
        for (o = 0, n = this.scopes.length; o < n; o++)
          this.scopes[o].stop(!0);
      if (!this.detached && this.parent && !t) {
        const r = this.parent.scopes.pop();
        r && r !== this && (this.parent.scopes[this.index] = r, r.index = this.index);
      }
      this.parent = void 0, this._active = !1;
    }
  }
}
function recordEffectScope(e, t = activeEffectScope) {
  t && t.active && t.effects.push(e);
}
function getCurrentScope() {
  return activeEffectScope;
}
let activeEffect;
class ReactiveEffect {
  constructor(t, o, n, r) {
    this.fn = t, this.trigger = o, this.scheduler = n, this.active = !0, this.deps = [], this._dirtyLevel = 4, this._trackId = 0, this._runnings = 0, this._shouldSchedule = !1, this._depsLength = 0, recordEffectScope(this, r);
  }
  get dirty() {
    if (this._dirtyLevel === 2 || this._dirtyLevel === 3) {
      this._dirtyLevel = 1, pauseTracking();
      for (let t = 0; t < this._depsLength; t++) {
        const o = this.deps[t];
        if (o.computed && (triggerComputed(o.computed), this._dirtyLevel >= 4))
          break;
      }
      this._dirtyLevel === 1 && (this._dirtyLevel = 0), resetTracking();
    }
    return this._dirtyLevel >= 4;
  }
  set dirty(t) {
    this._dirtyLevel = t ? 4 : 0;
  }
  run() {
    if (this._dirtyLevel = 0, !this.active)
      return this.fn();
    let t = shouldTrack, o = activeEffect;
    try {
      return shouldTrack = !0, activeEffect = this, this._runnings++, preCleanupEffect(this), this.fn();
    } finally {
      postCleanupEffect(this), this._runnings--, activeEffect = o, shouldTrack = t;
    }
  }
  stop() {
    this.active && (preCleanupEffect(this), postCleanupEffect(this), this.onStop && this.onStop(), this.active = !1);
  }
}
function triggerComputed(e) {
  return e.value;
}
function preCleanupEffect(e) {
  e._trackId++, e._depsLength = 0;
}
function postCleanupEffect(e) {
  if (e.deps.length > e._depsLength) {
    for (let t = e._depsLength; t < e.deps.length; t++)
      cleanupDepEffect(e.deps[t], e);
    e.deps.length = e._depsLength;
  }
}
function cleanupDepEffect(e, t) {
  const o = e.get(t);
  o !== void 0 && t._trackId !== o && (e.delete(t), e.size === 0 && e.cleanup());
}
let shouldTrack = !0, pauseScheduleStack = 0;
const trackStack = [];
function pauseTracking() {
  trackStack.push(shouldTrack), shouldTrack = !1;
}
function resetTracking() {
  const e = trackStack.pop();
  shouldTrack = e === void 0 ? !0 : e;
}
function pauseScheduling() {
  pauseScheduleStack++;
}
function resetScheduling() {
  for (pauseScheduleStack--; !pauseScheduleStack && queueEffectSchedulers.length; )
    queueEffectSchedulers.shift()();
}
function trackEffect(e, t, o) {
  var n;
  if (t.get(e) !== e._trackId) {
    t.set(e, e._trackId);
    const r = e.deps[e._depsLength];
    r !== t ? (r && cleanupDepEffect(r, e), e.deps[e._depsLength++] = t) : e._depsLength++, process.env.NODE_ENV !== "production" && ((n = e.onTrack) == null || n.call(e, extend({ effect: e }, o)));
  }
}
const queueEffectSchedulers = [];
function triggerEffects(e, t, o) {
  var n;
  pauseScheduling();
  for (const r of e.keys()) {
    let s;
    r._dirtyLevel < t && (s != null ? s : s = e.get(r) === r._trackId) && (r._shouldSchedule || (r._shouldSchedule = r._dirtyLevel === 0), r._dirtyLevel = t), r._shouldSchedule && (s != null ? s : s = e.get(r) === r._trackId) && (process.env.NODE_ENV !== "production" && ((n = r.onTrigger) == null || n.call(r, extend({ effect: r }, o))), r.trigger(), (!r._runnings || r.allowRecurse) && r._dirtyLevel !== 2 && (r._shouldSchedule = !1, r.scheduler && queueEffectSchedulers.push(r.scheduler)));
  }
  resetScheduling();
}
const createDep = (e, t) => {
  const o = /* @__PURE__ */ new Map();
  return o.cleanup = e, o.computed = t, o;
}, targetMap = /* @__PURE__ */ new WeakMap(), ITERATE_KEY = Symbol(process.env.NODE_ENV !== "production" ? "iterate" : ""), MAP_KEY_ITERATE_KEY = Symbol(process.env.NODE_ENV !== "production" ? "Map key iterate" : "");
function track(e, t, o) {
  if (shouldTrack && activeEffect) {
    let n = targetMap.get(e);
    n || targetMap.set(e, n = /* @__PURE__ */ new Map());
    let r = n.get(o);
    r || n.set(o, r = createDep(() => n.delete(o))), trackEffect(
      activeEffect,
      r,
      process.env.NODE_ENV !== "production" ? {
        target: e,
        type: t,
        key: o
      } : void 0
    );
  }
}
function trigger(e, t, o, n, r, s) {
  const i = targetMap.get(e);
  if (!i)
    return;
  let a = [];
  if (t === "clear")
    a = [...i.values()];
  else if (o === "length" && isArray(e)) {
    const l = Number(n);
    i.forEach((f, g) => {
      (g === "length" || !isSymbol(g) && g >= l) && a.push(f);
    });
  } else
    switch (o !== void 0 && a.push(i.get(o)), t) {
      case "add":
        isArray(e) ? isIntegerKey(o) && a.push(i.get("length")) : (a.push(i.get(ITERATE_KEY)), isMap(e) && a.push(i.get(MAP_KEY_ITERATE_KEY)));
        break;
      case "delete":
        isArray(e) || (a.push(i.get(ITERATE_KEY)), isMap(e) && a.push(i.get(MAP_KEY_ITERATE_KEY)));
        break;
      case "set":
        isMap(e) && a.push(i.get(ITERATE_KEY));
        break;
    }
  pauseScheduling();
  for (const l of a)
    l && triggerEffects(
      l,
      4,
      process.env.NODE_ENV !== "production" ? {
        target: e,
        type: t,
        key: o,
        newValue: n,
        oldValue: r,
        oldTarget: s
      } : void 0
    );
  resetScheduling();
}
const isNonTrackableKeys = /* @__PURE__ */ makeMap("__proto__,__v_isRef,__isVue"), builtInSymbols = new Set(
  /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((e) => e !== "arguments" && e !== "caller").map((e) => Symbol[e]).filter(isSymbol)
), arrayInstrumentations = /* @__PURE__ */ createArrayInstrumentations();
function createArrayInstrumentations() {
  const e = {};
  return ["includes", "indexOf", "lastIndexOf"].forEach((t) => {
    e[t] = function(...o) {
      const n = toRaw(this);
      for (let s = 0, i = this.length; s < i; s++)
        track(n, "get", s + "");
      const r = n[t](...o);
      return r === -1 || r === !1 ? n[t](...o.map(toRaw)) : r;
    };
  }), ["push", "pop", "shift", "unshift", "splice"].forEach((t) => {
    e[t] = function(...o) {
      pauseTracking(), pauseScheduling();
      const n = toRaw(this)[t].apply(this, o);
      return resetScheduling(), resetTracking(), n;
    };
  }), e;
}
function hasOwnProperty(e) {
  isSymbol(e) || (e = String(e));
  const t = toRaw(this);
  return track(t, "has", e), t.hasOwnProperty(e);
}
class BaseReactiveHandler {
  constructor(t = !1, o = !1) {
    this._isReadonly = t, this._isShallow = o;
  }
  get(t, o, n) {
    const r = this._isReadonly, s = this._isShallow;
    if (o === "__v_isReactive")
      return !r;
    if (o === "__v_isReadonly")
      return r;
    if (o === "__v_isShallow")
      return s;
    if (o === "__v_raw")
      return n === (r ? s ? shallowReadonlyMap : readonlyMap : s ? shallowReactiveMap : reactiveMap).get(t) || // receiver is not the reactive proxy, but has the same prototype
      // this means the receiver is a user proxy of the reactive proxy
      Object.getPrototypeOf(t) === Object.getPrototypeOf(n) ? t : void 0;
    const i = isArray(t);
    if (!r) {
      if (i && hasOwn(arrayInstrumentations, o))
        return Reflect.get(arrayInstrumentations, o, n);
      if (o === "hasOwnProperty")
        return hasOwnProperty;
    }
    const a = Reflect.get(t, o, n);
    return (isSymbol(o) ? builtInSymbols.has(o) : isNonTrackableKeys(o)) || (r || track(t, "get", o), s) ? a : isRef(a) ? i && isIntegerKey(o) ? a : a.value : isObject(a) ? r ? readonly(a) : reactive(a) : a;
  }
}
class MutableReactiveHandler extends BaseReactiveHandler {
  constructor(t = !1) {
    super(!1, t);
  }
  set(t, o, n, r) {
    let s = t[o];
    if (!this._isShallow) {
      const l = isReadonly(s);
      if (!isShallow(n) && !isReadonly(n) && (s = toRaw(s), n = toRaw(n)), !isArray(t) && isRef(s) && !isRef(n))
        return l ? !1 : (s.value = n, !0);
    }
    const i = isArray(t) && isIntegerKey(o) ? Number(o) < t.length : hasOwn(t, o), a = Reflect.set(t, o, n, r);
    return t === toRaw(r) && (i ? hasChanged(n, s) && trigger(t, "set", o, n, s) : trigger(t, "add", o, n)), a;
  }
  deleteProperty(t, o) {
    const n = hasOwn(t, o), r = t[o], s = Reflect.deleteProperty(t, o);
    return s && n && trigger(t, "delete", o, void 0, r), s;
  }
  has(t, o) {
    const n = Reflect.has(t, o);
    return (!isSymbol(o) || !builtInSymbols.has(o)) && track(t, "has", o), n;
  }
  ownKeys(t) {
    return track(
      t,
      "iterate",
      isArray(t) ? "length" : ITERATE_KEY
    ), Reflect.ownKeys(t);
  }
}
class ReadonlyReactiveHandler extends BaseReactiveHandler {
  constructor(t = !1) {
    super(!0, t);
  }
  set(t, o) {
    return process.env.NODE_ENV !== "production" && warn$2(
      `Set operation on key "${String(o)}" failed: target is readonly.`,
      t
    ), !0;
  }
  deleteProperty(t, o) {
    return process.env.NODE_ENV !== "production" && warn$2(
      `Delete operation on key "${String(o)}" failed: target is readonly.`,
      t
    ), !0;
  }
}
const mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler(), readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler(), shallowReactiveHandlers = /* @__PURE__ */ new MutableReactiveHandler(
  !0
), shallowReadonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler(!0), toShallow = (e) => e, getProto = (e) => Reflect.getPrototypeOf(e);
function get(e, t, o = !1, n = !1) {
  e = e.__v_raw;
  const r = toRaw(e), s = toRaw(t);
  o || (hasChanged(t, s) && track(r, "get", t), track(r, "get", s));
  const { has: i } = getProto(r), a = n ? toShallow : o ? toReadonly : toReactive;
  if (i.call(r, t))
    return a(e.get(t));
  if (i.call(r, s))
    return a(e.get(s));
  e !== r && e.get(t);
}
function has(e, t = !1) {
  const o = this.__v_raw, n = toRaw(o), r = toRaw(e);
  return t || (hasChanged(e, r) && track(n, "has", e), track(n, "has", r)), e === r ? o.has(e) : o.has(e) || o.has(r);
}
function size(e, t = !1) {
  return e = e.__v_raw, !t && track(toRaw(e), "iterate", ITERATE_KEY), Reflect.get(e, "size", e);
}
function add(e, t = !1) {
  !t && !isShallow(e) && !isReadonly(e) && (e = toRaw(e));
  const o = toRaw(this);
  return getProto(o).has.call(o, e) || (o.add(e), trigger(o, "add", e, e)), this;
}
function set(e, t, o = !1) {
  !o && !isShallow(t) && !isReadonly(t) && (t = toRaw(t));
  const n = toRaw(this), { has: r, get: s } = getProto(n);
  let i = r.call(n, e);
  i ? process.env.NODE_ENV !== "production" && checkIdentityKeys(n, r, e) : (e = toRaw(e), i = r.call(n, e));
  const a = s.call(n, e);
  return n.set(e, t), i ? hasChanged(t, a) && trigger(n, "set", e, t, a) : trigger(n, "add", e, t), this;
}
function deleteEntry(e) {
  const t = toRaw(this), { has: o, get: n } = getProto(t);
  let r = o.call(t, e);
  r ? process.env.NODE_ENV !== "production" && checkIdentityKeys(t, o, e) : (e = toRaw(e), r = o.call(t, e));
  const s = n ? n.call(t, e) : void 0, i = t.delete(e);
  return r && trigger(t, "delete", e, void 0, s), i;
}
function clear() {
  const e = toRaw(this), t = e.size !== 0, o = process.env.NODE_ENV !== "production" ? isMap(e) ? new Map(e) : new Set(e) : void 0, n = e.clear();
  return t && trigger(e, "clear", void 0, void 0, o), n;
}
function createForEach(e, t) {
  return function(n, r) {
    const s = this, i = s.__v_raw, a = toRaw(i), l = t ? toShallow : e ? toReadonly : toReactive;
    return !e && track(a, "iterate", ITERATE_KEY), i.forEach((f, g) => n.call(r, l(f), l(g), s));
  };
}
function createIterableMethod(e, t, o) {
  return function(...n) {
    const r = this.__v_raw, s = toRaw(r), i = isMap(s), a = e === "entries" || e === Symbol.iterator && i, l = e === "keys" && i, f = r[e](...n), g = o ? toShallow : t ? toReadonly : toReactive;
    return !t && track(
      s,
      "iterate",
      l ? MAP_KEY_ITERATE_KEY : ITERATE_KEY
    ), {
      // iterator protocol
      next() {
        const { value: d, done: v } = f.next();
        return v ? { value: d, done: v } : {
          value: a ? [g(d[0]), g(d[1])] : g(d),
          done: v
        };
      },
      // iterable protocol
      [Symbol.iterator]() {
        return this;
      }
    };
  };
}
function createReadonlyMethod(e) {
  return function(...t) {
    if (process.env.NODE_ENV !== "production") {
      const o = t[0] ? `on key "${t[0]}" ` : "";
      warn$2(
        `${capitalize(e)} operation ${o}failed: target is readonly.`,
        toRaw(this)
      );
    }
    return e === "delete" ? !1 : e === "clear" ? void 0 : this;
  };
}
function createInstrumentations() {
  const e = {
    get(s) {
      return get(this, s);
    },
    get size() {
      return size(this);
    },
    has,
    add,
    set,
    delete: deleteEntry,
    clear,
    forEach: createForEach(!1, !1)
  }, t = {
    get(s) {
      return get(this, s, !1, !0);
    },
    get size() {
      return size(this);
    },
    has,
    add(s) {
      return add.call(this, s, !0);
    },
    set(s, i) {
      return set.call(this, s, i, !0);
    },
    delete: deleteEntry,
    clear,
    forEach: createForEach(!1, !0)
  }, o = {
    get(s) {
      return get(this, s, !0);
    },
    get size() {
      return size(this, !0);
    },
    has(s) {
      return has.call(this, s, !0);
    },
    add: createReadonlyMethod("add"),
    set: createReadonlyMethod("set"),
    delete: createReadonlyMethod("delete"),
    clear: createReadonlyMethod("clear"),
    forEach: createForEach(!0, !1)
  }, n = {
    get(s) {
      return get(this, s, !0, !0);
    },
    get size() {
      return size(this, !0);
    },
    has(s) {
      return has.call(this, s, !0);
    },
    add: createReadonlyMethod("add"),
    set: createReadonlyMethod("set"),
    delete: createReadonlyMethod("delete"),
    clear: createReadonlyMethod("clear"),
    forEach: createForEach(!0, !0)
  };
  return [
    "keys",
    "values",
    "entries",
    Symbol.iterator
  ].forEach((s) => {
    e[s] = createIterableMethod(s, !1, !1), o[s] = createIterableMethod(s, !0, !1), t[s] = createIterableMethod(s, !1, !0), n[s] = createIterableMethod(
      s,
      !0,
      !0
    );
  }), [
    e,
    o,
    t,
    n
  ];
}
const [
  mutableInstrumentations,
  readonlyInstrumentations,
  shallowInstrumentations,
  shallowReadonlyInstrumentations
] = /* @__PURE__ */ createInstrumentations();
function createInstrumentationGetter(e, t) {
  const o = t ? e ? shallowReadonlyInstrumentations : shallowInstrumentations : e ? readonlyInstrumentations : mutableInstrumentations;
  return (n, r, s) => r === "__v_isReactive" ? !e : r === "__v_isReadonly" ? e : r === "__v_raw" ? n : Reflect.get(
    hasOwn(o, r) && r in n ? o : n,
    r,
    s
  );
}
const mutableCollectionHandlers = {
  get: /* @__PURE__ */ createInstrumentationGetter(!1, !1)
}, shallowCollectionHandlers = {
  get: /* @__PURE__ */ createInstrumentationGetter(!1, !0)
}, readonlyCollectionHandlers = {
  get: /* @__PURE__ */ createInstrumentationGetter(!0, !1)
}, shallowReadonlyCollectionHandlers = {
  get: /* @__PURE__ */ createInstrumentationGetter(!0, !0)
};
function checkIdentityKeys(e, t, o) {
  const n = toRaw(o);
  if (n !== o && t.call(e, n)) {
    const r = toRawType(e);
    warn$2(
      `Reactive ${r} contains both the raw and reactive versions of the same object${r === "Map" ? " as keys" : ""}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`
    );
  }
}
const reactiveMap = /* @__PURE__ */ new WeakMap(), shallowReactiveMap = /* @__PURE__ */ new WeakMap(), readonlyMap = /* @__PURE__ */ new WeakMap(), shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
function targetTypeMap(e) {
  switch (e) {
    case "Object":
    case "Array":
      return 1;
    case "Map":
    case "Set":
    case "WeakMap":
    case "WeakSet":
      return 2;
    default:
      return 0;
  }
}
function getTargetType(e) {
  return e.__v_skip || !Object.isExtensible(e) ? 0 : targetTypeMap(toRawType(e));
}
function reactive(e) {
  return isReadonly(e) ? e : createReactiveObject(
    e,
    !1,
    mutableHandlers,
    mutableCollectionHandlers,
    reactiveMap
  );
}
function shallowReactive(e) {
  return createReactiveObject(
    e,
    !1,
    shallowReactiveHandlers,
    shallowCollectionHandlers,
    shallowReactiveMap
  );
}
function readonly(e) {
  return createReactiveObject(
    e,
    !0,
    readonlyHandlers,
    readonlyCollectionHandlers,
    readonlyMap
  );
}
function shallowReadonly(e) {
  return createReactiveObject(
    e,
    !0,
    shallowReadonlyHandlers,
    shallowReadonlyCollectionHandlers,
    shallowReadonlyMap
  );
}
function createReactiveObject(e, t, o, n, r) {
  if (!isObject(e))
    return process.env.NODE_ENV !== "production" && warn$2(
      `value cannot be made ${t ? "readonly" : "reactive"}: ${String(
        e
      )}`
    ), e;
  if (e.__v_raw && !(t && e.__v_isReactive))
    return e;
  const s = r.get(e);
  if (s)
    return s;
  const i = getTargetType(e);
  if (i === 0)
    return e;
  const a = new Proxy(
    e,
    i === 2 ? n : o
  );
  return r.set(e, a), a;
}
function isReactive(e) {
  return isReadonly(e) ? isReactive(e.__v_raw) : !!(e && e.__v_isReactive);
}
function isReadonly(e) {
  return !!(e && e.__v_isReadonly);
}
function isShallow(e) {
  return !!(e && e.__v_isShallow);
}
function isProxy(e) {
  return e ? !!e.__v_raw : !1;
}
function toRaw(e) {
  const t = e && e.__v_raw;
  return t ? toRaw(t) : e;
}
function markRaw(e) {
  return Object.isExtensible(e) && def(e, "__v_skip", !0), e;
}
const toReactive = (e) => isObject(e) ? reactive(e) : e, toReadonly = (e) => isObject(e) ? readonly(e) : e, COMPUTED_SIDE_EFFECT_WARN = "Computed is still dirty after getter evaluation, likely because a computed is mutating its own dependency in its getter. State mutations in computed getters should be avoided.  Check the docs for more details: https://vuejs.org/guide/essentials/computed.html#getters-should-be-side-effect-free";
class ComputedRefImpl {
  constructor(t, o, n, r) {
    this.getter = t, this._setter = o, this.dep = void 0, this.__v_isRef = !0, this.__v_isReadonly = !1, this.effect = new ReactiveEffect(
      () => t(this._value),
      () => triggerRefValue(
        this,
        this.effect._dirtyLevel === 2 ? 2 : 3
      )
    ), this.effect.computed = this, this.effect.active = this._cacheable = !r, this.__v_isReadonly = n;
  }
  get value() {
    const t = toRaw(this);
    return (!t._cacheable || t.effect.dirty) && hasChanged(t._value, t._value = t.effect.run()) && triggerRefValue(t, 4), trackRefValue(t), t.effect._dirtyLevel >= 2 && (process.env.NODE_ENV !== "production" && this._warnRecursive && warn$2(COMPUTED_SIDE_EFFECT_WARN, `

getter: `, this.getter), triggerRefValue(t, 2)), t._value;
  }
  set value(t) {
    this._setter(t);
  }
  // #region polyfill _dirty for backward compatibility third party code for Vue <= 3.3.x
  get _dirty() {
    return this.effect.dirty;
  }
  set _dirty(t) {
    this.effect.dirty = t;
  }
  // #endregion
}
function computed$1(e, t, o = !1) {
  let n, r;
  const s = isFunction(e);
  s ? (n = e, r = process.env.NODE_ENV !== "production" ? () => {
    warn$2("Write operation failed: computed value is readonly");
  } : NOOP) : (n = e.get, r = e.set);
  const i = new ComputedRefImpl(n, r, s || !r, o);
  return process.env.NODE_ENV !== "production" && t && !o && (i.effect.onTrack = t.onTrack, i.effect.onTrigger = t.onTrigger), i;
}
function trackRefValue(e) {
  var t;
  shouldTrack && activeEffect && (e = toRaw(e), trackEffect(
    activeEffect,
    (t = e.dep) != null ? t : e.dep = createDep(
      () => e.dep = void 0,
      e instanceof ComputedRefImpl ? e : void 0
    ),
    process.env.NODE_ENV !== "production" ? {
      target: e,
      type: "get",
      key: "value"
    } : void 0
  ));
}
function triggerRefValue(e, t = 4, o, n) {
  e = toRaw(e);
  const r = e.dep;
  r && triggerEffects(
    r,
    t,
    process.env.NODE_ENV !== "production" ? {
      target: e,
      type: "set",
      key: "value",
      newValue: o,
      oldValue: n
    } : void 0
  );
}
function isRef(e) {
  return !!(e && e.__v_isRef === !0);
}
function ref(e) {
  return createRef(e, !1);
}
function shallowRef(e) {
  return createRef(e, !0);
}
function createRef(e, t) {
  return isRef(e) ? e : new RefImpl(e, t);
}
class RefImpl {
  constructor(t, o) {
    this.__v_isShallow = o, this.dep = void 0, this.__v_isRef = !0, this._rawValue = o ? t : toRaw(t), this._value = o ? t : toReactive(t);
  }
  get value() {
    return trackRefValue(this), this._value;
  }
  set value(t) {
    const o = this.__v_isShallow || isShallow(t) || isReadonly(t);
    if (t = o ? t : toRaw(t), hasChanged(t, this._rawValue)) {
      const n = this._rawValue;
      this._rawValue = t, this._value = o ? t : toReactive(t), triggerRefValue(this, 4, t, n);
    }
  }
}
function unref(e) {
  return isRef(e) ? e.value : e;
}
const shallowUnwrapHandlers = {
  get: (e, t, o) => unref(Reflect.get(e, t, o)),
  set: (e, t, o, n) => {
    const r = e[t];
    return isRef(r) && !isRef(o) ? (r.value = o, !0) : Reflect.set(e, t, o, n);
  }
};
function proxyRefs(e) {
  return isReactive(e) ? e : new Proxy(e, shallowUnwrapHandlers);
}
/**
* @vue/runtime-core v3.4.38
* (c) 2018-present Yuxi (Evan) You and Vue contributors
* @license MIT
**/
const stack = [];
function pushWarningContext(e) {
  stack.push(e);
}
function popWarningContext() {
  stack.pop();
}
let isWarning = !1;
function warn$1(e, ...t) {
  if (isWarning) return;
  isWarning = !0, pauseTracking();
  const o = stack.length ? stack[stack.length - 1].component : null, n = o && o.appContext.config.warnHandler, r = getComponentTrace();
  if (n)
    callWithErrorHandling(
      n,
      o,
      11,
      [
        // eslint-disable-next-line no-restricted-syntax
        e + t.map((s) => {
          var i, a;
          return (a = (i = s.toString) == null ? void 0 : i.call(s)) != null ? a : JSON.stringify(s);
        }).join(""),
        o && o.proxy,
        r.map(
          ({ vnode: s }) => `at <${formatComponentName(o, s.type)}>`
        ).join(`
`),
        r
      ]
    );
  else {
    const s = [`[Vue warn]: ${e}`, ...t];
    r.length && s.push(`
`, ...formatTrace(r)), console.warn(...s);
  }
  resetTracking(), isWarning = !1;
}
function getComponentTrace() {
  let e = stack[stack.length - 1];
  if (!e)
    return [];
  const t = [];
  for (; e; ) {
    const o = t[0];
    o && o.vnode === e ? o.recurseCount++ : t.push({
      vnode: e,
      recurseCount: 0
    });
    const n = e.component && e.component.parent;
    e = n && n.vnode;
  }
  return t;
}
function formatTrace(e) {
  const t = [];
  return e.forEach((o, n) => {
    t.push(...n === 0 ? [] : [`
`], ...formatTraceEntry(o));
  }), t;
}
function formatTraceEntry({ vnode: e, recurseCount: t }) {
  const o = t > 0 ? `... (${t} recursive calls)` : "", n = e.component ? e.component.parent == null : !1, r = ` at <${formatComponentName(
    e.component,
    e.type,
    n
  )}`, s = ">" + o;
  return e.props ? [r, ...formatProps(e.props), s] : [r + s];
}
function formatProps(e) {
  const t = [], o = Object.keys(e);
  return o.slice(0, 3).forEach((n) => {
    t.push(...formatProp(n, e[n]));
  }), o.length > 3 && t.push(" ..."), t;
}
function formatProp(e, t, o) {
  return isString(t) ? (t = JSON.stringify(t), o ? t : [`${e}=${t}`]) : typeof t == "number" || typeof t == "boolean" || t == null ? o ? t : [`${e}=${t}`] : isRef(t) ? (t = formatProp(e, toRaw(t.value), !0), o ? t : [`${e}=Ref<`, t, ">"]) : isFunction(t) ? [`${e}=fn${t.name ? `<${t.name}>` : ""}`] : (t = toRaw(t), o ? t : [`${e}=`, t]);
}
function assertNumber(e, t) {
  process.env.NODE_ENV !== "production" && e !== void 0 && (typeof e != "number" ? warn$1(`${t} is not a valid number - got ${JSON.stringify(e)}.`) : isNaN(e) && warn$1(`${t} is NaN - the duration expression might be incorrect.`));
}
const ErrorTypeStrings$1 = {
  sp: "serverPrefetch hook",
  bc: "beforeCreate hook",
  c: "created hook",
  bm: "beforeMount hook",
  m: "mounted hook",
  bu: "beforeUpdate hook",
  u: "updated",
  bum: "beforeUnmount hook",
  um: "unmounted hook",
  a: "activated hook",
  da: "deactivated hook",
  ec: "errorCaptured hook",
  rtc: "renderTracked hook",
  rtg: "renderTriggered hook",
  0: "setup function",
  1: "render function",
  2: "watcher getter",
  3: "watcher callback",
  4: "watcher cleanup function",
  5: "native event handler",
  6: "component event handler",
  7: "vnode hook",
  8: "directive hook",
  9: "transition hook",
  10: "app errorHandler",
  11: "app warnHandler",
  12: "ref function",
  13: "async component loader",
  14: "scheduler flush",
  15: "component update"
};
function callWithErrorHandling(e, t, o, n) {
  try {
    return n ? e(...n) : e();
  } catch (r) {
    handleError(r, t, o);
  }
}
function callWithAsyncErrorHandling(e, t, o, n) {
  if (isFunction(e)) {
    const r = callWithErrorHandling(e, t, o, n);
    return r && isPromise(r) && r.catch((s) => {
      handleError(s, t, o);
    }), r;
  }
  if (isArray(e)) {
    const r = [];
    for (let s = 0; s < e.length; s++)
      r.push(callWithAsyncErrorHandling(e[s], t, o, n));
    return r;
  } else process.env.NODE_ENV !== "production" && warn$1(
    `Invalid value type passed to callWithAsyncErrorHandling(): ${typeof e}`
  );
}
function handleError(e, t, o, n = !0) {
  const r = t ? t.vnode : null;
  if (t) {
    let s = t.parent;
    const i = t.proxy, a = process.env.NODE_ENV !== "production" ? ErrorTypeStrings$1[o] : `https://vuejs.org/error-reference/#runtime-${o}`;
    for (; s; ) {
      const f = s.ec;
      if (f) {
        for (let g = 0; g < f.length; g++)
          if (f[g](e, i, a) === !1)
            return;
      }
      s = s.parent;
    }
    const l = t.appContext.config.errorHandler;
    if (l) {
      pauseTracking(), callWithErrorHandling(
        l,
        null,
        10,
        [e, i, a]
      ), resetTracking();
      return;
    }
  }
  logError(e, o, r, n);
}
function logError(e, t, o, n = !0) {
  if (process.env.NODE_ENV !== "production") {
    const r = ErrorTypeStrings$1[t];
    if (o && pushWarningContext(o), warn$1(`Unhandled error${r ? ` during execution of ${r}` : ""}`), o && popWarningContext(), n)
      throw e;
    console.error(e);
  } else
    console.error(e);
}
let isFlushing = !1, isFlushPending = !1;
const queue = [];
let flushIndex = 0;
const pendingPostFlushCbs = [];
let activePostFlushCbs = null, postFlushIndex = 0;
const resolvedPromise = /* @__PURE__ */ Promise.resolve();
let currentFlushPromise = null;
const RECURSION_LIMIT = 100;
function nextTick(e) {
  const t = currentFlushPromise || resolvedPromise;
  return e ? t.then(this ? e.bind(this) : e) : t;
}
function findInsertionIndex(e) {
  let t = flushIndex + 1, o = queue.length;
  for (; t < o; ) {
    const n = t + o >>> 1, r = queue[n], s = getId(r);
    s < e || s === e && r.pre ? t = n + 1 : o = n;
  }
  return t;
}
function queueJob(e) {
  (!queue.length || !queue.includes(
    e,
    isFlushing && e.allowRecurse ? flushIndex + 1 : flushIndex
  )) && (e.id == null ? queue.push(e) : queue.splice(findInsertionIndex(e.id), 0, e), queueFlush());
}
function queueFlush() {
  !isFlushing && !isFlushPending && (isFlushPending = !0, currentFlushPromise = resolvedPromise.then(flushJobs));
}
function invalidateJob(e) {
  const t = queue.indexOf(e);
  t > flushIndex && queue.splice(t, 1);
}
function queuePostFlushCb(e) {
  isArray(e) ? pendingPostFlushCbs.push(...e) : (!activePostFlushCbs || !activePostFlushCbs.includes(
    e,
    e.allowRecurse ? postFlushIndex + 1 : postFlushIndex
  )) && pendingPostFlushCbs.push(e), queueFlush();
}
function flushPreFlushCbs(e, t, o = isFlushing ? flushIndex + 1 : 0) {
  for (process.env.NODE_ENV !== "production" && (t = t || /* @__PURE__ */ new Map()); o < queue.length; o++) {
    const n = queue[o];
    if (n && n.pre) {
      if (e && n.id !== e.uid || process.env.NODE_ENV !== "production" && checkRecursiveUpdates(t, n))
        continue;
      queue.splice(o, 1), o--, n();
    }
  }
}
function flushPostFlushCbs(e) {
  if (pendingPostFlushCbs.length) {
    const t = [...new Set(pendingPostFlushCbs)].sort(
      (o, n) => getId(o) - getId(n)
    );
    if (pendingPostFlushCbs.length = 0, activePostFlushCbs) {
      activePostFlushCbs.push(...t);
      return;
    }
    for (activePostFlushCbs = t, process.env.NODE_ENV !== "production" && (e = e || /* @__PURE__ */ new Map()), postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
      const o = activePostFlushCbs[postFlushIndex];
      process.env.NODE_ENV !== "production" && checkRecursiveUpdates(e, o) || o.active !== !1 && o();
    }
    activePostFlushCbs = null, postFlushIndex = 0;
  }
}
const getId = (e) => e.id == null ? 1 / 0 : e.id, comparator = (e, t) => {
  const o = getId(e) - getId(t);
  if (o === 0) {
    if (e.pre && !t.pre) return -1;
    if (t.pre && !e.pre) return 1;
  }
  return o;
};
function flushJobs(e) {
  isFlushPending = !1, isFlushing = !0, process.env.NODE_ENV !== "production" && (e = e || /* @__PURE__ */ new Map()), queue.sort(comparator);
  const t = process.env.NODE_ENV !== "production" ? (o) => checkRecursiveUpdates(e, o) : NOOP;
  try {
    for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
      const o = queue[flushIndex];
      if (o && o.active !== !1) {
        if (process.env.NODE_ENV !== "production" && t(o))
          continue;
        callWithErrorHandling(
          o,
          o.i,
          o.i ? 15 : 14
        );
      }
    }
  } finally {
    flushIndex = 0, queue.length = 0, flushPostFlushCbs(e), isFlushing = !1, currentFlushPromise = null, (queue.length || pendingPostFlushCbs.length) && flushJobs(e);
  }
}
function checkRecursiveUpdates(e, t) {
  if (!e.has(t))
    e.set(t, 1);
  else {
    const o = e.get(t);
    if (o > RECURSION_LIMIT) {
      const n = t.i, r = n && getComponentName(n.type);
      return handleError(
        `Maximum recursive updates exceeded${r ? ` in component <${r}>` : ""}. This means you have a reactive effect that is mutating its own dependencies and thus recursively triggering itself. Possible sources include component template, render function, updated hook or watcher source function.`,
        null,
        10
      ), !0;
    } else
      e.set(t, o + 1);
  }
}
let isHmrUpdating = !1;
const hmrDirtyComponents = /* @__PURE__ */ new Map();
process.env.NODE_ENV !== "production" && (getGlobalThis().__VUE_HMR_RUNTIME__ = {
  createRecord: tryWrap(createRecord),
  rerender: tryWrap(rerender),
  reload: tryWrap(reload)
});
const map = /* @__PURE__ */ new Map();
function registerHMR(e) {
  const t = e.type.__hmrId;
  let o = map.get(t);
  o || (createRecord(t, e.type), o = map.get(t)), o.instances.add(e);
}
function unregisterHMR(e) {
  map.get(e.type.__hmrId).instances.delete(e);
}
function createRecord(e, t) {
  return map.has(e) ? !1 : (map.set(e, {
    initialDef: normalizeClassComponent(t),
    instances: /* @__PURE__ */ new Set()
  }), !0);
}
function normalizeClassComponent(e) {
  return isClassComponent(e) ? e.__vccOpts : e;
}
function rerender(e, t) {
  const o = map.get(e);
  o && (o.initialDef.render = t, [...o.instances].forEach((n) => {
    t && (n.render = t, normalizeClassComponent(n.type).render = t), n.renderCache = [], isHmrUpdating = !0, n.effect.dirty = !0, n.update(), isHmrUpdating = !1;
  }));
}
function reload(e, t) {
  const o = map.get(e);
  if (!o) return;
  t = normalizeClassComponent(t), updateComponentDef(o.initialDef, t);
  const n = [...o.instances];
  for (let r = 0; r < n.length; r++) {
    const s = n[r], i = normalizeClassComponent(s.type);
    let a = hmrDirtyComponents.get(i);
    a || (i !== o.initialDef && updateComponentDef(i, t), hmrDirtyComponents.set(i, a = /* @__PURE__ */ new Set())), a.add(s), s.appContext.propsCache.delete(s.type), s.appContext.emitsCache.delete(s.type), s.appContext.optionsCache.delete(s.type), s.ceReload ? (a.add(s), s.ceReload(t.styles), a.delete(s)) : s.parent ? (s.parent.effect.dirty = !0, queueJob(() => {
      s.parent.update(), a.delete(s);
    })) : s.appContext.reload ? s.appContext.reload() : typeof window != "undefined" ? window.location.reload() : console.warn(
      "[HMR] Root or manually mounted instance modified. Full reload required."
    );
  }
  queuePostFlushCb(() => {
    hmrDirtyComponents.clear();
  });
}
function updateComponentDef(e, t) {
  extend(e, t);
  for (const o in e)
    o !== "__file" && !(o in t) && delete e[o];
}
function tryWrap(e) {
  return (t, o) => {
    try {
      return e(t, o);
    } catch (n) {
      console.error(n), console.warn(
        "[HMR] Something went wrong during Vue component hot-reload. Full reload required."
      );
    }
  };
}
let devtools$1, buffer = [], devtoolsNotInstalled = !1;
function emit$1(e, ...t) {
  devtools$1 ? devtools$1.emit(e, ...t) : devtoolsNotInstalled || buffer.push({ event: e, args: t });
}
function setDevtoolsHook$1(e, t) {
  var o, n;
  devtools$1 = e, devtools$1 ? (devtools$1.enabled = !0, buffer.forEach(({ event: r, args: s }) => devtools$1.emit(r, ...s)), buffer = []) : /* handle late devtools injection - only do this if we are in an actual */ /* browser environment to avoid the timer handle stalling test runner exit */ /* (#4815) */ typeof window != "undefined" && // some envs mock window but not fully
  window.HTMLElement && // also exclude jsdom
  // eslint-disable-next-line no-restricted-syntax
  !((n = (o = window.navigator) == null ? void 0 : o.userAgent) != null && n.includes("jsdom")) ? ((t.__VUE_DEVTOOLS_HOOK_REPLAY__ = t.__VUE_DEVTOOLS_HOOK_REPLAY__ || []).push((s) => {
    setDevtoolsHook$1(s, t);
  }), setTimeout(() => {
    devtools$1 || (t.__VUE_DEVTOOLS_HOOK_REPLAY__ = null, devtoolsNotInstalled = !0, buffer = []);
  }, 3e3)) : (devtoolsNotInstalled = !0, buffer = []);
}
function devtoolsInitApp(e, t) {
  emit$1("app:init", e, t, {
    Fragment,
    Text,
    Comment,
    Static
  });
}
function devtoolsUnmountApp(e) {
  emit$1("app:unmount", e);
}
const devtoolsComponentAdded = /* @__PURE__ */ createDevtoolsComponentHook(
  "component:added"
  /* COMPONENT_ADDED */
), devtoolsComponentUpdated = /* @__PURE__ */ createDevtoolsComponentHook(
  "component:updated"
  /* COMPONENT_UPDATED */
), _devtoolsComponentRemoved = /* @__PURE__ */ createDevtoolsComponentHook(
  "component:removed"
  /* COMPONENT_REMOVED */
), devtoolsComponentRemoved = (e) => {
  devtools$1 && typeof devtools$1.cleanupBuffer == "function" && // remove the component if it wasn't buffered
  !devtools$1.cleanupBuffer(e) && _devtoolsComponentRemoved(e);
};
/*! #__NO_SIDE_EFFECTS__ */
// @__NO_SIDE_EFFECTS__
function createDevtoolsComponentHook(e) {
  return (t) => {
    emit$1(
      e,
      t.appContext.app,
      t.uid,
      t.parent ? t.parent.uid : void 0,
      t
    );
  };
}
const devtoolsPerfStart = /* @__PURE__ */ createDevtoolsPerformanceHook(
  "perf:start"
  /* PERFORMANCE_START */
), devtoolsPerfEnd = /* @__PURE__ */ createDevtoolsPerformanceHook(
  "perf:end"
  /* PERFORMANCE_END */
);
function createDevtoolsPerformanceHook(e) {
  return (t, o, n) => {
    emit$1(e, t.appContext.app, t.uid, t, o, n);
  };
}
function devtoolsComponentEmit(e, t, o) {
  emit$1(
    "component:emit",
    e.appContext.app,
    e,
    t,
    o
  );
}
let currentRenderingInstance = null, currentScopeId = null;
function setCurrentRenderingInstance(e) {
  const t = currentRenderingInstance;
  return currentRenderingInstance = e, currentScopeId = e && e.type.__scopeId || null, t;
}
function withCtx(e, t = currentRenderingInstance, o) {
  if (!t || e._n)
    return e;
  const n = (...r) => {
    n._d && setBlockTracking(-1);
    const s = setCurrentRenderingInstance(t);
    let i;
    try {
      i = e(...r);
    } finally {
      setCurrentRenderingInstance(s), n._d && setBlockTracking(1);
    }
    return process.env.NODE_ENV !== "production" && devtoolsComponentUpdated(t), i;
  };
  return n._n = !0, n._c = !0, n._d = !0, n;
}
function validateDirectiveName(e) {
  isBuiltInDirective(e) && warn$1("Do not use built-in directive ids as custom directive id: " + e);
}
function withDirectives(e, t) {
  if (currentRenderingInstance === null)
    return process.env.NODE_ENV !== "production" && warn$1("withDirectives can only be used inside render functions."), e;
  const o = getComponentPublicInstance(currentRenderingInstance), n = e.dirs || (e.dirs = []);
  for (let r = 0; r < t.length; r++) {
    let [s, i, a, l = EMPTY_OBJ] = t[r];
    s && (isFunction(s) && (s = {
      mounted: s,
      updated: s
    }), s.deep && traverse(i), n.push({
      dir: s,
      instance: o,
      value: i,
      oldValue: void 0,
      arg: a,
      modifiers: l
    }));
  }
  return e;
}
function invokeDirectiveHook(e, t, o, n) {
  const r = e.dirs, s = t && t.dirs;
  for (let i = 0; i < r.length; i++) {
    const a = r[i];
    s && (a.oldValue = s[i].value);
    let l = a.dir[n];
    l && (pauseTracking(), callWithAsyncErrorHandling(l, o, 8, [
      e.el,
      a,
      e,
      t
    ]), resetTracking());
  }
}
const leaveCbKey = Symbol("_leaveCb"), enterCbKey = Symbol("_enterCb");
function useTransitionState() {
  const e = {
    isMounted: !1,
    isLeaving: !1,
    isUnmounting: !1,
    leavingVNodes: /* @__PURE__ */ new Map()
  };
  return onMounted(() => {
    e.isMounted = !0;
  }), onBeforeUnmount(() => {
    e.isUnmounting = !0;
  }), e;
}
const TransitionHookValidator = [Function, Array], BaseTransitionPropsValidators = {
  mode: String,
  appear: Boolean,
  persisted: Boolean,
  // enter
  onBeforeEnter: TransitionHookValidator,
  onEnter: TransitionHookValidator,
  onAfterEnter: TransitionHookValidator,
  onEnterCancelled: TransitionHookValidator,
  // leave
  onBeforeLeave: TransitionHookValidator,
  onLeave: TransitionHookValidator,
  onAfterLeave: TransitionHookValidator,
  onLeaveCancelled: TransitionHookValidator,
  // appear
  onBeforeAppear: TransitionHookValidator,
  onAppear: TransitionHookValidator,
  onAfterAppear: TransitionHookValidator,
  onAppearCancelled: TransitionHookValidator
}, recursiveGetSubtree = (e) => {
  const t = e.subTree;
  return t.component ? recursiveGetSubtree(t.component) : t;
}, BaseTransitionImpl = {
  name: "BaseTransition",
  props: BaseTransitionPropsValidators,
  setup(e, { slots: t }) {
    const o = getCurrentInstance(), n = useTransitionState();
    return () => {
      const r = t.default && getTransitionRawChildren(t.default(), !0);
      if (!r || !r.length)
        return;
      let s = r[0];
      if (r.length > 1) {
        let v = !1;
        for (const O of r)
          if (O.type !== Comment) {
            if (process.env.NODE_ENV !== "production" && v) {
              warn$1(
                "<transition> can only be used on a single element or component. Use <transition-group> for lists."
              );
              break;
            }
            if (s = O, v = !0, process.env.NODE_ENV === "production") break;
          }
      }
      const i = toRaw(e), { mode: a } = i;
      if (process.env.NODE_ENV !== "production" && a && a !== "in-out" && a !== "out-in" && a !== "default" && warn$1(`invalid <transition> mode: ${a}`), n.isLeaving)
        return emptyPlaceholder(s);
      const l = getKeepAliveChild(s);
      if (!l)
        return emptyPlaceholder(s);
      let f = resolveTransitionHooks(
        l,
        i,
        n,
        o,
        // #11061, ensure enterHooks is fresh after clone
        (v) => f = v
      );
      setTransitionHooks(l, f);
      const g = o.subTree, d = g && getKeepAliveChild(g);
      if (d && d.type !== Comment && !isSameVNodeType(l, d) && recursiveGetSubtree(o).type !== Comment) {
        const v = resolveTransitionHooks(
          d,
          i,
          n,
          o
        );
        if (setTransitionHooks(d, v), a === "out-in" && l.type !== Comment)
          return n.isLeaving = !0, v.afterLeave = () => {
            n.isLeaving = !1, o.update.active !== !1 && (o.effect.dirty = !0, o.update());
          }, emptyPlaceholder(s);
        a === "in-out" && l.type !== Comment && (v.delayLeave = (O, M, R) => {
          const Y = getLeavingNodesForType(
            n,
            d
          );
          Y[String(d.key)] = d, O[leaveCbKey] = () => {
            M(), O[leaveCbKey] = void 0, delete f.delayedLeave;
          }, f.delayedLeave = R;
        });
      }
      return s;
    };
  }
}, BaseTransition = BaseTransitionImpl;
function getLeavingNodesForType(e, t) {
  const { leavingVNodes: o } = e;
  let n = o.get(t.type);
  return n || (n = /* @__PURE__ */ Object.create(null), o.set(t.type, n)), n;
}
function resolveTransitionHooks(e, t, o, n, r) {
  const {
    appear: s,
    mode: i,
    persisted: a = !1,
    onBeforeEnter: l,
    onEnter: f,
    onAfterEnter: g,
    onEnterCancelled: d,
    onBeforeLeave: v,
    onLeave: O,
    onAfterLeave: M,
    onLeaveCancelled: R,
    onBeforeAppear: Y,
    onAppear: H,
    onAfterAppear: j,
    onAppearCancelled: P
  } = t, L = String(e.key), F = getLeavingNodesForType(o, e), U = (T, $) => {
    T && callWithAsyncErrorHandling(
      T,
      n,
      9,
      $
    );
  }, k = (T, $) => {
    const Q = $[1];
    U(T, $), isArray(T) ? T.every((C) => C.length <= 1) && Q() : T.length <= 1 && Q();
  }, Z = {
    mode: i,
    persisted: a,
    beforeEnter(T) {
      let $ = l;
      if (!o.isMounted)
        if (s)
          $ = Y || l;
        else
          return;
      T[leaveCbKey] && T[leaveCbKey](
        !0
        /* cancelled */
      );
      const Q = F[L];
      Q && isSameVNodeType(e, Q) && Q.el[leaveCbKey] && Q.el[leaveCbKey](), U($, [T]);
    },
    enter(T) {
      let $ = f, Q = g, C = d;
      if (!o.isMounted)
        if (s)
          $ = H || f, Q = j || g, C = P || d;
        else
          return;
      let W = !1;
      const X = T[enterCbKey] = (t6) => {
        W || (W = !0, t6 ? U(C, [T]) : U(Q, [T]), Z.delayedLeave && Z.delayedLeave(), T[enterCbKey] = void 0);
      };
      $ ? k($, [T, X]) : X();
    },
    leave(T, $) {
      const Q = String(e.key);
      if (T[enterCbKey] && T[enterCbKey](
        !0
        /* cancelled */
      ), o.isUnmounting)
        return $();
      U(v, [T]);
      let C = !1;
      const W = T[leaveCbKey] = (X) => {
        C || (C = !0, $(), X ? U(R, [T]) : U(M, [T]), T[leaveCbKey] = void 0, F[Q] === e && delete F[Q]);
      };
      F[Q] = e, O ? k(O, [T, W]) : W();
    },
    clone(T) {
      const $ = resolveTransitionHooks(
        T,
        t,
        o,
        n,
        r
      );
      return r && r($), $;
    }
  };
  return