@visactor/vue-vtable 1.7.5-alpha.1

package/dist/vue-vtable.js

@@ -0,0 +1,4040 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@visactor/vtable')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@visactor/vtable'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.VueVTable = {}, global.VTable));
+})(this, (function (exports, VTable) { 'use strict';
+
+  function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+      Object.keys(e).forEach(function (k) {
+        if (k !== 'default') {
+          var d = Object.getOwnPropertyDescriptor(e, k);
+          Object.defineProperty(n, k, d.get ? d : {
+            enumerable: true,
+            get: function () { return e[k]; }
+          });
+        }
+      });
+    }
+    n.default = e;
+    return Object.freeze(n);
+  }
+
+  var VTable__namespace = /*#__PURE__*/_interopNamespaceDefault(VTable);
+
+  /**
+  * @vue/shared v3.5.0
+  * (c) 2018-present Yuxi (Evan) You and Vue contributors
+  * @license MIT
+  **/
+  /*! #__NO_SIDE_EFFECTS__ */
+  // @__NO_SIDE_EFFECTS__
+  function makeMap(str, expectsLowerCase) {
+    const set = new Set(str.split(","));
+    return expectsLowerCase ? val => set.has(val.toLowerCase()) : val => set.has(val);
+  }
+  const EMPTY_OBJ = !!(process.env.NODE_ENV !== "production") ? Object.freeze({}) : {};
+  const EMPTY_ARR = !!(process.env.NODE_ENV !== "production") ? Object.freeze([]) : [];
+  const NOOP = () => {};
+  const isOn = key => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && (
+  // uppercase letter
+  key.charCodeAt(2) > 122 || key.charCodeAt(2) < 97);
+  const extend = Object.assign;
+  const hasOwnProperty$1 = Object.prototype.hasOwnProperty;
+  const hasOwn = (val, key) => hasOwnProperty$1.call(val, key);
+  const isArray = Array.isArray;
+  const isMap = val => toTypeString(val) === "[object Map]";
+  const isSet = val => toTypeString(val) === "[object Set]";
+  const isFunction$2 = val => typeof val === "function";
+  const isString = val => typeof val === "string";
+  const isSymbol = val => typeof val === "symbol";
+  const isObject = val => val !== null && typeof val === "object";
+  const isPromise = val => {
+    return (isObject(val) || isFunction$2(val)) && isFunction$2(val.then) && isFunction$2(val.catch);
+  };
+  const objectToString = Object.prototype.toString;
+  const toTypeString = value => objectToString.call(value);
+  const toRawType = value => {
+    return toTypeString(value).slice(8, -1);
+  };
+  const isPlainObject = val => toTypeString(val) === "[object Object]";
+  const isIntegerKey = key => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
+  const cacheStringFunction = fn => {
+    const cache = /* @__PURE__ */Object.create(null);
+    return str => {
+      const hit = cache[str];
+      return hit || (cache[str] = fn(str));
+    };
+  };
+  const capitalize = cacheStringFunction(str => {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  });
+  const toHandlerKey = cacheStringFunction(str => {
+    const s = str ? `on${capitalize(str)}` : ``;
+    return s;
+  });
+  const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
+  const def = function (obj, key, value) {
+    let writable = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+    Object.defineProperty(obj, key, {
+      configurable: true,
+      enumerable: false,
+      writable,
+      value
+    });
+  };
+  let _globalThis;
+  const getGlobalThis = () => {
+    return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
+  };
+  function normalizeStyle(value) {
+    if (isArray(value)) {
+      const res = {};
+      for (let i = 0; i < value.length; i++) {
+        const item = value[i];
+        const normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item);
+        if (normalized) {
+          for (const key in normalized) {
+            res[key] = normalized[key];
+          }
+        }
+      }
+      return res;
+    } else if (isString(value) || isObject(value)) {
+      return value;
+    }
+  }
+  const listDelimiterRE = /;(?![^(]*\))/g;
+  const propertyDelimiterRE = /:([^]+)/;
+  const styleCommentRE = /\/\*[^]*?\*\//g;
+  function parseStringStyle(cssText) {
+    const ret = {};
+    cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach(item => {
+      if (item) {
+        const tmp = item.split(propertyDelimiterRE);
+        tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
+      }
+    });
+    return ret;
+  }
+  function normalizeClass(value) {
+    let res = "";
+    if (isString(value)) {
+      res = value;
+    } else if (isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        const normalized = normalizeClass(value[i]);
+        if (normalized) {
+          res += normalized + " ";
+        }
+      }
+    } else if (isObject(value)) {
+      for (const name in value) {
+        if (value[name]) {
+          res += name + " ";
+        }
+      }
+    }
+    return res.trim();
+  }
+
+  /**
+  * @vue/reactivity v3.5.0
+  * (c) 2018-present Yuxi (Evan) You and Vue contributors
+  * @license MIT
+  **/
+  function warn(msg) {
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key2 = 1; _key2 < _len; _key2++) {
+      args[_key2 - 1] = arguments[_key2];
+    }
+  }
+  let activeSub;
+  const pausedQueueEffects = /* @__PURE__ */new WeakSet();
+  class ReactiveEffect {
+    constructor(fn) {
+      this.fn = fn;
+      /**
+       * @internal
+       */
+      this.deps = void 0;
+      /**
+       * @internal
+       */
+      this.depsTail = void 0;
+      /**
+       * @internal
+       */
+      this.flags = 1 | 4;
+      /**
+       * @internal
+       */
+      this.nextEffect = void 0;
+      /**
+       * @internal
+       */
+      this.cleanup = void 0;
+      this.scheduler = void 0;
+    }
+    pause() {
+      this.flags |= 64;
+    }
+    resume() {
+      if (this.flags & 64) {
+        this.flags &= ~64;
+        if (pausedQueueEffects.has(this)) {
+          pausedQueueEffects.delete(this);
+          this.trigger();
+        }
+      }
+    }
+    /**
+     * @internal
+     */
+    notify() {
+      if (this.flags & 2 && !(this.flags & 32)) {
+        return;
+      }
+      if (!(this.flags & 8)) {
+        this.flags |= 8;
+        this.nextEffect = batchedEffect;
+        batchedEffect = this;
+      }
+    }
+    run() {
+      if (!(this.flags & 1)) {
+        return this.fn();
+      }
+      this.flags |= 2;
+      cleanupEffect(this);
+      prepareDeps(this);
+      const prevEffect = activeSub;
+      const prevShouldTrack = shouldTrack;
+      activeSub = this;
+      shouldTrack = true;
+      try {
+        return this.fn();
+      } finally {
+        if (!!(process.env.NODE_ENV !== "production") && activeSub !== this) {
+          warn("Active effect was not restored correctly - this is likely a Vue internal bug.");
+        }
+        cleanupDeps(this);
+        activeSub = prevEffect;
+        shouldTrack = prevShouldTrack;
+        this.flags &= ~2;
+      }
+    }
+    stop() {
+      if (this.flags & 1) {
+        for (let link = this.deps; link; link = link.nextDep) {
+          removeSub(link);
+        }
+        this.deps = this.depsTail = void 0;
+        cleanupEffect(this);
+        this.onStop && this.onStop();
+        this.flags &= ~1;
+      }
+    }
+    trigger() {
+      if (this.flags & 64) {
+        pausedQueueEffects.add(this);
+      } else if (this.scheduler) {
+        this.scheduler();
+      } else {
+        this.runIfDirty();
+      }
+    }
+    /**
+     * @internal
+     */
+    runIfDirty() {
+      if (isDirty(this)) {
+        this.run();
+      }
+    }
+    get dirty() {
+      return isDirty(this);
+    }
+  }
+  let batchDepth = 0;
+  let batchedEffect;
+  function startBatch() {
+    batchDepth++;
+  }
+  function endBatch() {
+    if (--batchDepth > 0) {
+      return;
+    }
+    let error;
+    while (batchedEffect) {
+      let e = batchedEffect;
+      batchedEffect = void 0;
+      while (e) {
+        const next = e.nextEffect;
+        e.nextEffect = void 0;
+        e.flags &= ~8;
+        if (e.flags & 1) {
+          try {
+            e.trigger();
+          } catch (err) {
+            if (!error) error = err;
+          }
+        }
+        e = next;
+      }
+    }
+    if (error) throw error;
+  }
+  function prepareDeps(sub) {
+    for (let link = sub.deps; link; link = link.nextDep) {
+      link.version = -1;
+      link.prevActiveLink = link.dep.activeLink;
+      link.dep.activeLink = link;
+    }
+  }
+  function cleanupDeps(sub) {
+    let head;
+    let tail = sub.depsTail;
+    for (let link = tail; link; link = link.prevDep) {
+      if (link.version === -1) {
+        if (link === tail) tail = link.prevDep;
+        removeSub(link);
+        removeDep(link);
+      } else {
+        head = link;
+      }
+      link.dep.activeLink = link.prevActiveLink;
+      link.prevActiveLink = void 0;
+    }
+    sub.deps = head;
+    sub.depsTail = tail;
+  }
+  function isDirty(sub) {
+    for (let link = sub.deps; link; link = link.nextDep) {
+      if (link.dep.version !== link.version || link.dep.computed && refreshComputed(link.dep.computed) === false || link.dep.version !== link.version) {
+        return true;
+      }
+    }
+    if (sub._dirty) {
+      return true;
+    }
+    return false;
+  }
+  function refreshComputed(computed) {
+    if (computed.flags & 2) {
+      return false;
+    }
+    if (computed.flags & 4 && !(computed.flags & 16)) {
+      return;
+    }
+    computed.flags &= ~16;
+    if (computed.globalVersion === globalVersion) {
+      return;
+    }
+    computed.globalVersion = globalVersion;
+    const dep = computed.dep;
+    computed.flags |= 2;
+    if (dep.version > 0 && !computed.isSSR && !isDirty(computed)) {
+      computed.flags &= ~2;
+      return;
+    }
+    const prevSub = activeSub;
+    const prevShouldTrack = shouldTrack;
+    activeSub = computed;
+    shouldTrack = true;
+    try {
+      prepareDeps(computed);
+      const value = computed.fn();
+      if (dep.version === 0 || hasChanged(value, computed._value)) {
+        computed._value = value;
+        dep.version++;
+      }
+    } catch (err) {
+      dep.version++;
+      throw err;
+    } finally {
+      activeSub = prevSub;
+      shouldTrack = prevShouldTrack;
+      cleanupDeps(computed);
+      computed.flags &= ~2;
+    }
+  }
+  function removeSub(link) {
+    const {
+      dep,
+      prevSub,
+      nextSub
+    } = link;
+    if (prevSub) {
+      prevSub.nextSub = nextSub;
+      link.prevSub = void 0;
+    }
+    if (nextSub) {
+      nextSub.prevSub = prevSub;
+      link.nextSub = void 0;
+    }
+    if (dep.subs === link) {
+      dep.subs = prevSub;
+    }
+    if (!dep.subs && dep.computed) {
+      dep.computed.flags &= ~4;
+      for (let l = dep.computed.deps; l; l = l.nextDep) {
+        removeSub(l);
+      }
+    }
+  }
+  function removeDep(link) {
+    const {
+      prevDep,
+      nextDep
+    } = link;
+    if (prevDep) {
+      prevDep.nextDep = nextDep;
+      link.prevDep = void 0;
+    }
+    if (nextDep) {
+      nextDep.prevDep = prevDep;
+      link.nextDep = void 0;
+    }
+  }
+  let shouldTrack = true;
+  const trackStack = [];
+  function pauseTracking() {
+    trackStack.push(shouldTrack);
+    shouldTrack = false;
+  }
+  function resetTracking() {
+    const last = trackStack.pop();
+    shouldTrack = last === void 0 ? true : last;
+  }
+  function cleanupEffect(e) {
+    const {
+      cleanup
+    } = e;
+    e.cleanup = void 0;
+    if (cleanup) {
+      const prevSub = activeSub;
+      activeSub = void 0;
+      try {
+        cleanup();
+      } finally {
+        activeSub = prevSub;
+      }
+    }
+  }
+  let globalVersion = 0;
+  class Dep {
+    constructor(computed) {
+      this.computed = computed;
+      this.version = 0;
+      /**
+       * Link between this dep and the current active effect
+       */
+      this.activeLink = void 0;
+      /**
+       * Doubly linked list representing the subscribing effects (tail)
+       */
+      this.subs = void 0;
+      if (!!(process.env.NODE_ENV !== "production")) {
+        this.subsHead = void 0;
+      }
+    }
+    track(debugInfo) {
+      if (!activeSub || !shouldTrack) {
+        return;
+      }
+      let link = this.activeLink;
+      if (link === void 0 || link.sub !== activeSub) {
+        link = this.activeLink = {
+          dep: this,
+          sub: activeSub,
+          version: this.version,
+          nextDep: void 0,
+          prevDep: void 0,
+          nextSub: void 0,
+          prevSub: void 0,
+          prevActiveLink: void 0
+        };
+        if (!activeSub.deps) {
+          activeSub.deps = activeSub.depsTail = link;
+        } else {
+          link.prevDep = activeSub.depsTail;
+          activeSub.depsTail.nextDep = link;
+          activeSub.depsTail = link;
+        }
+        if (activeSub.flags & 4) {
+          addSub(link);
+        }
+      } else if (link.version === -1) {
+        link.version = this.version;
+        if (link.nextDep) {
+          const next = link.nextDep;
+          next.prevDep = link.prevDep;
+          if (link.prevDep) {
+            link.prevDep.nextDep = next;
+          }
+          link.prevDep = activeSub.depsTail;
+          link.nextDep = void 0;
+          activeSub.depsTail.nextDep = link;
+          activeSub.depsTail = link;
+          if (activeSub.deps === link) {
+            activeSub.deps = next;
+          }
+        }
+      }
+      if (!!(process.env.NODE_ENV !== "production") && activeSub.onTrack) {
+        activeSub.onTrack(extend({
+          effect: activeSub
+        }, debugInfo));
+      }
+      return link;
+    }
+    trigger(debugInfo) {
+      this.version++;
+      globalVersion++;
+      this.notify(debugInfo);
+    }
+    notify(debugInfo) {
+      startBatch();
+      try {
+        if (!!(process.env.NODE_ENV !== "production")) {
+          for (let head = this.subsHead; head; head = head.nextSub) {
+            if (!!(process.env.NODE_ENV !== "production") && head.sub.onTrigger && !(head.sub.flags & 8)) {
+              head.sub.onTrigger(extend({
+                effect: head.sub
+              }, debugInfo));
+            }
+          }
+        }
+        for (let link = this.subs; link; link = link.prevSub) {
+          link.sub.notify();
+        }
+      } finally {
+        endBatch();
+      }
+    }
+  }
+  function addSub(link) {
+    const computed = link.dep.computed;
+    if (computed && !link.dep.subs) {
+      computed.flags |= 4 | 16;
+      for (let l = computed.deps; l; l = l.nextDep) {
+        addSub(l);
+      }
+    }
+    const currentTail = link.dep.subs;
+    if (currentTail !== link) {
+      link.prevSub = currentTail;
+      if (currentTail) currentTail.nextSub = link;
+    }
+    if (!!(process.env.NODE_ENV !== "production") && link.dep.subsHead === void 0) {
+      link.dep.subsHead = link;
+    }
+    link.dep.subs = link;
+  }
+  const targetMap = /* @__PURE__ */new WeakMap();
+  const ITERATE_KEY = Symbol(!!(process.env.NODE_ENV !== "production") ? "Object iterate" : "");
+  const MAP_KEY_ITERATE_KEY = Symbol(!!(process.env.NODE_ENV !== "production") ? "Map keys iterate" : "");
+  const ARRAY_ITERATE_KEY = Symbol(!!(process.env.NODE_ENV !== "production") ? "Array iterate" : "");
+  function track(target, type, key) {
+    if (shouldTrack && activeSub) {
+      let depsMap = targetMap.get(target);
+      if (!depsMap) {
+        targetMap.set(target, depsMap = /* @__PURE__ */new Map());
+      }
+      let dep = depsMap.get(key);
+      if (!dep) {
+        depsMap.set(key, dep = new Dep());
+      }
+      if (!!(process.env.NODE_ENV !== "production")) {
+        dep.track({
+          target,
+          type,
+          key
+        });
+      } else {
+        dep.track();
+      }
+    }
+  }
+  function trigger(target, type, key, newValue, oldValue, oldTarget) {
+    const depsMap = targetMap.get(target);
+    if (!depsMap) {
+      globalVersion++;
+      return;
+    }
+    let deps = [];
+    if (type === "clear") {
+      deps = [...depsMap.values()];
+    } else {
+      const targetIsArray = isArray(target);
+      const isArrayIndex = targetIsArray && isIntegerKey(key);
+      if (targetIsArray && key === "length") {
+        const newLength = Number(newValue);
+        depsMap.forEach((dep, key2) => {
+          if (key2 === "length" || key2 === ARRAY_ITERATE_KEY || !isSymbol(key2) && key2 >= newLength) {
+            deps.push(dep);
+          }
+        });
+      } else {
+        const push = dep => dep && deps.push(dep);
+        if (key !== void 0) {
+          push(depsMap.get(key));
+        }
+        if (isArrayIndex) {
+          push(depsMap.get(ARRAY_ITERATE_KEY));
+        }
+        switch (type) {
+          case "add":
+            if (!targetIsArray) {
+              push(depsMap.get(ITERATE_KEY));
+              if (isMap(target)) {
+                push(depsMap.get(MAP_KEY_ITERATE_KEY));
+              }
+            } else if (isArrayIndex) {
+              push(depsMap.get("length"));
+            }
+            break;
+          case "delete":
+            if (!targetIsArray) {
+              push(depsMap.get(ITERATE_KEY));
+              if (isMap(target)) {
+                push(depsMap.get(MAP_KEY_ITERATE_KEY));
+              }
+            }
+            break;
+          case "set":
+            if (isMap(target)) {
+              push(depsMap.get(ITERATE_KEY));
+            }
+            break;
+        }
+      }
+    }
+    startBatch();
+    for (const dep of deps) {
+      if (!!(process.env.NODE_ENV !== "production")) {
+        dep.trigger({
+          target,
+          type,
+          key,
+          newValue,
+          oldValue,
+          oldTarget
+        });
+      } else {
+        dep.trigger();
+      }
+    }
+    endBatch();
+  }
+  function reactiveReadArray(array) {
+    const raw = toRaw(array);
+    if (raw === array) return raw;
+    track(raw, "iterate", ARRAY_ITERATE_KEY);
+    return isShallow(array) ? raw : raw.map(toReactive);
+  }
+  function shallowReadArray(arr) {
+    track(arr = toRaw(arr), "iterate", ARRAY_ITERATE_KEY);
+    return arr;
+  }
+  const arrayInstrumentations = {
+    __proto__: null,
+    [Symbol.iterator]() {
+      return iterator(this, Symbol.iterator, toReactive);
+    },
+    concat() {
+      for (var _len2 = arguments.length, args = new Array(_len2), _key3 = 0; _key3 < _len2; _key3++) {
+        args[_key3] = arguments[_key3];
+      }
+      return reactiveReadArray(this).concat(...args.map(x => reactiveReadArray(x)));
+    },
+    entries() {
+      return iterator(this, "entries", value => {
+        value[1] = toReactive(value[1]);
+        return value;
+      });
+    },
+    every(fn, thisArg) {
+      return apply(this, "every", fn, thisArg, void 0, arguments);
+    },
+    filter(fn, thisArg) {
+      return apply(this, "filter", fn, thisArg, v => v.map(toReactive), arguments);
+    },
+    find(fn, thisArg) {
+      return apply(this, "find", fn, thisArg, toReactive, arguments);
+    },
+    findIndex(fn, thisArg) {
+      return apply(this, "findIndex", fn, thisArg, void 0, arguments);
+    },
+    findLast(fn, thisArg) {
+      return apply(this, "findLast", fn, thisArg, toReactive, arguments);
+    },
+    findLastIndex(fn, thisArg) {
+      return apply(this, "findLastIndex", fn, thisArg, void 0, arguments);
+    },
+    // flat, flatMap could benefit from ARRAY_ITERATE but are not straight-forward to implement
+    forEach(fn, thisArg) {
+      return apply(this, "forEach", fn, thisArg, void 0, arguments);
+    },
+    includes() {
+      for (var _len3 = arguments.length, args = new Array(_len3), _key4 = 0; _key4 < _len3; _key4++) {
+        args[_key4] = arguments[_key4];
+      }
+      return searchProxy(this, "includes", args);
+    },
+    indexOf() {
+      for (var _len4 = arguments.length, args = new Array(_len4), _key5 = 0; _key5 < _len4; _key5++) {
+        args[_key5] = arguments[_key5];
+      }
+      return searchProxy(this, "indexOf", args);
+    },
+    join(separator) {
+      return reactiveReadArray(this).join(separator);
+    },
+    // keys() iterator only reads `length`, no optimisation required
+    lastIndexOf() {
+      for (var _len5 = arguments.length, args = new Array(_len5), _key6 = 0; _key6 < _len5; _key6++) {
+        args[_key6] = arguments[_key6];
+      }
+      return searchProxy(this, "lastIndexOf", args);
+    },
+    map(fn, thisArg) {
+      return apply(this, "map", fn, thisArg, void 0, arguments);
+    },
+    pop() {
+      return noTracking(this, "pop");
+    },
+    push() {
+      for (var _len6 = arguments.length, args = new Array(_len6), _key7 = 0; _key7 < _len6; _key7++) {
+        args[_key7] = arguments[_key7];
+      }
+      return noTracking(this, "push", args);
+    },
+    reduce(fn) {
+      for (var _len7 = arguments.length, args = new Array(_len7 > 1 ? _len7 - 1 : 0), _key8 = 1; _key8 < _len7; _key8++) {
+        args[_key8 - 1] = arguments[_key8];
+      }
+      return reduce(this, "reduce", fn, args);
+    },
+    reduceRight(fn) {
+      for (var _len8 = arguments.length, args = new Array(_len8 > 1 ? _len8 - 1 : 0), _key9 = 1; _key9 < _len8; _key9++) {
+        args[_key9 - 1] = arguments[_key9];
+      }
+      return reduce(this, "reduceRight", fn, args);
+    },
+    shift() {
+      return noTracking(this, "shift");
+    },
+    // slice could use ARRAY_ITERATE but also seems to beg for range tracking
+    some(fn, thisArg) {
+      return apply(this, "some", fn, thisArg, void 0, arguments);
+    },
+    splice() {
+      for (var _len9 = arguments.length, args = new Array(_len9), _key10 = 0; _key10 < _len9; _key10++) {
+        args[_key10] = arguments[_key10];
+      }
+      return noTracking(this, "splice", args);
+    },
+    toReversed() {
+      return reactiveReadArray(this).toReversed();
+    },
+    toSorted(comparer) {
+      return reactiveReadArray(this).toSorted(comparer);
+    },
+    toSpliced() {
+      return reactiveReadArray(this).toSpliced(...arguments);
+    },
+    unshift() {
+      for (var _len10 = arguments.length, args = new Array(_len10), _key11 = 0; _key11 < _len10; _key11++) {
+        args[_key11] = arguments[_key11];
+      }
+      return noTracking(this, "unshift", args);
+    },
+    values() {
+      return iterator(this, "values", toReactive);
+    }
+  };
+  function iterator(self, method, wrapValue) {
+    const arr = shallowReadArray(self);
+    const iter = arr[method]();
+    if (arr !== self && !isShallow(self)) {
+      iter._next = iter.next;
+      iter.next = () => {
+        const result = iter._next();
+        if (result.value) {
+          result.value = wrapValue(result.value);
+        }
+        return result;
+      };
+    }
+    return iter;
+  }
+  const arrayProto = Array.prototype;
+  function apply(self, method, fn, thisArg, wrappedRetFn, args) {
+    const arr = shallowReadArray(self);
+    const needsWrap = arr !== self && !isShallow(self);
+    const methodFn = arr[method];
+    if (methodFn !== arrayProto[method]) {
+      const result2 = methodFn.apply(self, args);
+      return needsWrap ? toReactive(result2) : result2;
+    }
+    let wrappedFn = fn;
+    if (arr !== self) {
+      if (needsWrap) {
+        wrappedFn = function (item, index) {
+          return fn.call(this, toReactive(item), index, self);
+        };
+      } else if (fn.length > 2) {
+        wrappedFn = function (item, index) {
+          return fn.call(this, item, index, self);
+        };
+      }
+    }
+    const result = methodFn.call(arr, wrappedFn, thisArg);
+    return needsWrap && wrappedRetFn ? wrappedRetFn(result) : result;
+  }
+  function reduce(self, method, fn, args) {
+    const arr = shallowReadArray(self);
+    let wrappedFn = fn;
+    if (arr !== self) {
+      if (!isShallow(self)) {
+        wrappedFn = function (acc, item, index) {
+          return fn.call(this, acc, toReactive(item), index, self);
+        };
+      } else if (fn.length > 3) {
+        wrappedFn = function (acc, item, index) {
+          return fn.call(this, acc, item, index, self);
+        };
+      }
+    }
+    return arr[method](wrappedFn, ...args);
+  }
+  function searchProxy(self, method, args) {
+    const arr = toRaw(self);
+    track(arr, "iterate", ARRAY_ITERATE_KEY);
+    const res = arr[method](...args);
+    if ((res === -1 || res === false) && isProxy(args[0])) {
+      args[0] = toRaw(args[0]);
+      return arr[method](...args);
+    }
+    return res;
+  }
+  function noTracking(self, method) {
+    let args = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+    pauseTracking();
+    startBatch();
+    const res = toRaw(self)[method].apply(self, args);
+    endBatch();
+    resetTracking();
+    return res;
+  }
+  const isNonTrackableKeys = /* @__PURE__ */makeMap(`__proto__,__v_isRef,__isVue`);
+  const builtInSymbols = new Set( /* @__PURE__ */Object.getOwnPropertyNames(Symbol).filter(key => key !== "arguments" && key !== "caller").map(key => Symbol[key]).filter(isSymbol));
+  function hasOwnProperty(key) {
+    if (!isSymbol(key)) key = String(key);
+    const obj = toRaw(this);
+    track(obj, "has", key);
+    return obj.hasOwnProperty(key);
+  }
+  class BaseReactiveHandler {
+    constructor() {
+      let _isReadonly = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      let _isShallow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      this._isReadonly = _isReadonly;
+      this._isShallow = _isShallow;
+    }
+    get(target, key, receiver) {
+      const isReadonly2 = this._isReadonly,
+        isShallow2 = this._isShallow;
+      if (key === "__v_isReactive") {
+        return !isReadonly2;
+      } else if (key === "__v_isReadonly") {
+        return isReadonly2;
+      } else if (key === "__v_isShallow") {
+        return isShallow2;
+      } else if (key === "__v_raw") {
+        if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactiveMap).get(target) ||
+        // 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(target) === Object.getPrototypeOf(receiver)) {
+          return target;
+        }
+        return;
+      }
+      const targetIsArray = isArray(target);
+      if (!isReadonly2) {
+        let fn;
+        if (targetIsArray && (fn = arrayInstrumentations[key])) {
+          return fn;
+        }
+        if (key === "hasOwnProperty") {
+          return hasOwnProperty;
+        }
+      }
+      const res = Reflect.get(target, key,
+      // if this is a proxy wrapping a ref, return methods using the raw ref
+      // as receiver so that we don't have to call `toRaw` on the ref in all
+      // its class methods
+      isRef(target) ? target : receiver);
+      if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
+        return res;
+      }
+      if (!isReadonly2) {
+        track(target, "get", key);
+      }
+      if (isShallow2) {
+        return res;
+      }
+      if (isRef(res)) {
+        return targetIsArray && isIntegerKey(key) ? res : res.value;
+      }
+      if (isObject(res)) {
+        return isReadonly2 ? readonly(res) : reactive(res);
+      }
+      return res;
+    }
+  }
+  class MutableReactiveHandler extends BaseReactiveHandler {
+    constructor() {
+      let isShallow2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      super(false, isShallow2);
+    }
+    set(target, key, value, receiver) {
+      let oldValue = target[key];
+      if (!this._isShallow) {
+        const isOldValueReadonly = isReadonly(oldValue);
+        if (!isShallow(value) && !isReadonly(value)) {
+          oldValue = toRaw(oldValue);
+          value = toRaw(value);
+        }
+        if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
+          if (isOldValueReadonly) {
+            return false;
+          } else {
+            oldValue.value = value;
+            return true;
+          }
+        }
+      }
+      const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
+      const result = Reflect.set(target, key, value, isRef(target) ? target : receiver);
+      if (target === toRaw(receiver)) {
+        if (!hadKey) {
+          trigger(target, "add", key, value);
+        } else if (hasChanged(value, oldValue)) {
+          trigger(target, "set", key, value, oldValue);
+        }
+      }
+      return result;
+    }
+    deleteProperty(target, key) {
+      const hadKey = hasOwn(target, key);
+      const oldValue = target[key];
+      const result = Reflect.deleteProperty(target, key);
+      if (result && hadKey) {
+        trigger(target, "delete", key, void 0, oldValue);
+      }
+      return result;
+    }
+    has(target, key) {
+      const result = Reflect.has(target, key);
+      if (!isSymbol(key) || !builtInSymbols.has(key)) {
+        track(target, "has", key);
+      }
+      return result;
+    }
+    ownKeys(target) {
+      track(target, "iterate", isArray(target) ? "length" : ITERATE_KEY);
+      return Reflect.ownKeys(target);
+    }
+  }
+  class ReadonlyReactiveHandler extends BaseReactiveHandler {
+    constructor() {
+      let isShallow2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      super(true, isShallow2);
+    }
+    set(target, key) {
+      if (!!(process.env.NODE_ENV !== "production")) {
+        warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target);
+      }
+      return true;
+    }
+    deleteProperty(target, key) {
+      if (!!(process.env.NODE_ENV !== "production")) {
+        warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target);
+      }
+      return true;
+    }
+  }
+  const mutableHandlers = /* @__PURE__ */new MutableReactiveHandler();
+  const readonlyHandlers = /* @__PURE__ */new ReadonlyReactiveHandler();
+  const shallowReadonlyHandlers = /* @__PURE__ */new ReadonlyReactiveHandler(true);
+  const toShallow = value => value;
+  const getProto = v => Reflect.getPrototypeOf(v);
+  function get(target, key) {
+    let isReadonly2 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    let isShallow2 = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+    target = target["__v_raw"];
+    const rawTarget = toRaw(target);
+    const rawKey = toRaw(key);
+    if (!isReadonly2) {
+      if (hasChanged(key, rawKey)) {
+        track(rawTarget, "get", key);
+      }
+      track(rawTarget, "get", rawKey);
+    }
+    const {
+      has: has2
+    } = getProto(rawTarget);
+    const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
+    if (has2.call(rawTarget, key)) {
+      return wrap(target.get(key));
+    } else if (has2.call(rawTarget, rawKey)) {
+      return wrap(target.get(rawKey));
+    } else if (target !== rawTarget) {
+      target.get(key);
+    }
+  }
+  function has(key) {
+    let isReadonly2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    const target = this["__v_raw"];
+    const rawTarget = toRaw(target);
+    const rawKey = toRaw(key);
+    if (!isReadonly2) {
+      if (hasChanged(key, rawKey)) {
+        track(rawTarget, "has", key);
+      }
+      track(rawTarget, "has", rawKey);
+    }
+    return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
+  }
+  function size(target) {
+    let isReadonly2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    target = target["__v_raw"];
+    !isReadonly2 && track(toRaw(target), "iterate", ITERATE_KEY);
+    return Reflect.get(target, "size", target);
+  }
+  function add(value) {
+    let _isShallow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    if (!_isShallow && !isShallow(value) && !isReadonly(value)) {
+      value = toRaw(value);
+    }
+    const target = toRaw(this);
+    const proto = getProto(target);
+    const hadKey = proto.has.call(target, value);
+    if (!hadKey) {
+      target.add(value);
+      trigger(target, "add", value, value);
+    }
+    return this;
+  }
+  function set(key, value) {
+    let _isShallow = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    if (!_isShallow && !isShallow(value) && !isReadonly(value)) {
+      value = toRaw(value);
+    }
+    const target = toRaw(this);
+    const {
+      has: has2,
+      get: get2
+    } = getProto(target);
+    let hadKey = has2.call(target, key);
+    if (!hadKey) {
+      key = toRaw(key);
+      hadKey = has2.call(target, key);
+    } else if (!!(process.env.NODE_ENV !== "production")) {
+      checkIdentityKeys(target, has2, key);
+    }
+    const oldValue = get2.call(target, key);
+    target.set(key, value);
+    if (!hadKey) {
+      trigger(target, "add", key, value);
+    } else if (hasChanged(value, oldValue)) {
+      trigger(target, "set", key, value, oldValue);
+    }
+    return this;
+  }
+  function deleteEntry(key) {
+    const target = toRaw(this);
+    const {
+      has: has2,
+      get: get2
+    } = getProto(target);
+    let hadKey = has2.call(target, key);
+    if (!hadKey) {
+      key = toRaw(key);
+      hadKey = has2.call(target, key);
+    } else if (!!(process.env.NODE_ENV !== "production")) {
+      checkIdentityKeys(target, has2, key);
+    }
+    const oldValue = get2 ? get2.call(target, key) : void 0;
+    const result = target.delete(key);
+    if (hadKey) {
+      trigger(target, "delete", key, void 0, oldValue);
+    }
+    return result;
+  }
+  function clear() {
+    const target = toRaw(this);
+    const hadItems = target.size !== 0;
+    const oldTarget = !!(process.env.NODE_ENV !== "production") ? isMap(target) ? new Map(target) : new Set(target) : void 0;
+    const result = target.clear();
+    if (hadItems) {
+      trigger(target, "clear", void 0, void 0, oldTarget);
+    }
+    return result;
+  }
+  function createForEach(isReadonly2, isShallow2) {
+    return function forEach(callback, thisArg) {
+      const observed = this;
+      const target = observed["__v_raw"];
+      const rawTarget = toRaw(target);
+      const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
+      !isReadonly2 && track(rawTarget, "iterate", ITERATE_KEY);
+      return target.forEach((value, key) => {
+        return callback.call(thisArg, wrap(value), wrap(key), observed);
+      });
+    };
+  }
+  function createIterableMethod(method, isReadonly2, isShallow2) {
+    return function () {
+      const target = this["__v_raw"];
+      const rawTarget = toRaw(target);
+      const targetIsMap = isMap(rawTarget);
+      const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
+      const isKeyOnly = method === "keys" && targetIsMap;
+      const innerIterator = target[method](...arguments);
+      const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
+      !isReadonly2 && track(rawTarget, "iterate", isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
+      return {
+        // iterator protocol
+        next() {
+          const {
+            value,
+            done
+          } = innerIterator.next();
+          return done ? {
+            value,
+            done
+          } : {
+            value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
+            done
+          };
+        },
+        // iterable protocol
+        [Symbol.iterator]() {
+          return this;
+        }
+      };
+    };
+  }
+  function createReadonlyMethod(type) {
+    return function () {
+      if (!!(process.env.NODE_ENV !== "production")) {
+        const key = (arguments.length <= 0 ? undefined : arguments[0]) ? `on key "${arguments.length <= 0 ? undefined : arguments[0]}" ` : ``;
+        warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));
+      }
+      return type === "delete" ? false : type === "clear" ? void 0 : this;
+    };
+  }
+  function createInstrumentations() {
+    const mutableInstrumentations2 = {
+      get(key) {
+        return get(this, key);
+      },
+      get size() {
+        return size(this);
+      },
+      has,
+      add,
+      set,
+      delete: deleteEntry,
+      clear,
+      forEach: createForEach(false, false)
+    };
+    const shallowInstrumentations2 = {
+      get(key) {
+        return get(this, key, false, true);
+      },
+      get size() {
+        return size(this);
+      },
+      has,
+      add(value) {
+        return add.call(this, value, true);
+      },
+      set(key, value) {
+        return set.call(this, key, value, true);
+      },
+      delete: deleteEntry,
+      clear,
+      forEach: createForEach(false, true)
+    };
+    const readonlyInstrumentations2 = {
+      get(key) {
+        return get(this, key, true);
+      },
+      get size() {
+        return size(this, true);
+      },
+      has(key) {
+        return has.call(this, key, true);
+      },
+      add: createReadonlyMethod("add"),
+      set: createReadonlyMethod("set"),
+      delete: createReadonlyMethod("delete"),
+      clear: createReadonlyMethod("clear"),
+      forEach: createForEach(true, false)
+    };
+    const shallowReadonlyInstrumentations2 = {
+      get(key) {
+        return get(this, key, true, true);
+      },
+      get size() {
+        return size(this, true);
+      },
+      has(key) {
+        return has.call(this, key, true);
+      },
+      add: createReadonlyMethod("add"),
+      set: createReadonlyMethod("set"),
+      delete: createReadonlyMethod("delete"),
+      clear: createReadonlyMethod("clear"),
+      forEach: createForEach(true, true)
+    };
+    const iteratorMethods = ["keys", "values", "entries", Symbol.iterator];
+    iteratorMethods.forEach(method => {
+      mutableInstrumentations2[method] = createIterableMethod(method, false, false);
+      readonlyInstrumentations2[method] = createIterableMethod(method, true, false);
+      shallowInstrumentations2[method] = createIterableMethod(method, false, true);
+      shallowReadonlyInstrumentations2[method] = createIterableMethod(method, true, true);
+    });
+    return [mutableInstrumentations2, readonlyInstrumentations2, shallowInstrumentations2, shallowReadonlyInstrumentations2];
+  }
+  const [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = /* @__PURE__ */createInstrumentations();
+  function createInstrumentationGetter(isReadonly2, shallow) {
+    const instrumentations = shallow ? isReadonly2 ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly2 ? readonlyInstrumentations : mutableInstrumentations;
+    return (target, key, receiver) => {
+      if (key === "__v_isReactive") {
+        return !isReadonly2;
+      } else if (key === "__v_isReadonly") {
+        return isReadonly2;
+      } else if (key === "__v_raw") {
+        return target;
+      }
+      return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver);
+    };
+  }
+  const mutableCollectionHandlers = {
+    get: /* @__PURE__ */createInstrumentationGetter(false, false)
+  };
+  const readonlyCollectionHandlers = {
+    get: /* @__PURE__ */createInstrumentationGetter(true, false)
+  };
+  const shallowReadonlyCollectionHandlers = {
+    get: /* @__PURE__ */createInstrumentationGetter(true, true)
+  };
+  function checkIdentityKeys(target, has2, key) {
+    const rawKey = toRaw(key);
+    if (rawKey !== key && has2.call(target, rawKey)) {
+      const type = toRawType(target);
+      warn(`Reactive ${type} contains both the raw and reactive versions of the same object${type === `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();
+  const shallowReactiveMap = /* @__PURE__ */new WeakMap();
+  const readonlyMap = /* @__PURE__ */new WeakMap();
+  const shallowReadonlyMap = /* @__PURE__ */new WeakMap();
+  function targetTypeMap(rawType) {
+    switch (rawType) {
+      case "Object":
+      case "Array":
+        return 1 /* COMMON */;
+      case "Map":
+      case "Set":
+      case "WeakMap":
+      case "WeakSet":
+        return 2 /* COLLECTION */;
+      default:
+        return 0 /* INVALID */;
+    }
+  }
+
+  function getTargetType(value) {
+    return value["__v_skip"] || !Object.isExtensible(value) ? 0 /* INVALID */ : targetTypeMap(toRawType(value));
+  }
+  function reactive(target) {
+    if (isReadonly(target)) {
+      return target;
+    }
+    return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
+  }
+  function readonly(target) {
+    return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
+  }
+  function shallowReadonly(target) {
+    return createReactiveObject(target, true, shallowReadonlyHandlers, shallowReadonlyCollectionHandlers, shallowReadonlyMap);
+  }
+  function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
+    if (!isObject(target)) {
+      if (!!(process.env.NODE_ENV !== "production")) {
+        warn(`value cannot be made ${isReadonly2 ? "readonly" : "reactive"}: ${String(target)}`);
+      }
+      return target;
+    }
+    if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
+      return target;
+    }
+    const existingProxy = proxyMap.get(target);
+    if (existingProxy) {
+      return existingProxy;
+    }
+    const targetType = getTargetType(target);
+    if (targetType === 0 /* INVALID */) {
+      return target;
+    }
+    const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers);
+    proxyMap.set(target, proxy);
+    return proxy;
+  }
+  function isReactive(value) {
+    if (isReadonly(value)) {
+      return isReactive(value["__v_raw"]);
+    }
+    return !!(value && value["__v_isReactive"]);
+  }
+  function isReadonly(value) {
+    return !!(value && value["__v_isReadonly"]);
+  }
+  function isShallow(value) {
+    return !!(value && value["__v_isShallow"]);
+  }
+  function isProxy(value) {
+    return value ? !!value["__v_raw"] : false;
+  }
+  function toRaw(observed) {
+    const raw = observed && observed["__v_raw"];
+    return raw ? toRaw(raw) : observed;
+  }
+  function markRaw(value) {
+    if (Object.isExtensible(value)) {
+      def(value, "__v_skip", true);
+    }
+    return value;
+  }
+  const toReactive = value => isObject(value) ? reactive(value) : value;
+  const toReadonly = value => isObject(value) ? readonly(value) : value;
+  function isRef(r) {
+    return r ? r["__v_isRef"] === true : false;
+  }
+  function ref(value) {
+    return createRef(value, false);
+  }
+  function shallowRef(value) {
+    return createRef(value, true);
+  }
+  function createRef(rawValue, shallow) {
+    if (isRef(rawValue)) {
+      return rawValue;
+    }
+    return new RefImpl(rawValue, shallow);
+  }
+  class RefImpl {
+    constructor(value, isShallow2) {
+      this.dep = new Dep();
+      this["__v_isRef"] = true;
+      this["__v_isShallow"] = false;
+      this._rawValue = isShallow2 ? value : toRaw(value);
+      this._value = isShallow2 ? value : toReactive(value);
+      this["__v_isShallow"] = isShallow2;
+    }
+    get value() {
+      if (!!(process.env.NODE_ENV !== "production")) {
+        this.dep.track({
+          target: this,
+          type: "get",
+          key: "value"
+        });
+      } else {
+        this.dep.track();
+      }
+      return this._value;
+    }
+    set value(newValue) {
+      const oldValue = this._rawValue;
+      const useDirectValue = this["__v_isShallow"] || isShallow(newValue) || isReadonly(newValue);
+      newValue = useDirectValue ? newValue : toRaw(newValue);
+      if (hasChanged(newValue, oldValue)) {
+        this._rawValue = newValue;
+        this._value = useDirectValue ? newValue : toReactive(newValue);
+        if (!!(process.env.NODE_ENV !== "production")) {
+          this.dep.trigger({
+            target: this,
+            type: "set",
+            key: "value",
+            newValue,
+            oldValue
+          });
+        } else {
+          this.dep.trigger();
+        }
+      }
+    }
+  }
+  function unref(ref2) {
+    return isRef(ref2) ? ref2.value : ref2;
+  }
+  const shallowUnwrapHandlers = {
+    get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
+    set: (target, key, value, receiver) => {
+      const oldValue = target[key];
+      if (isRef(oldValue) && !isRef(value)) {
+        oldValue.value = value;
+        return true;
+      } else {
+        return Reflect.set(target, key, value, receiver);
+      }
+    }
+  };
+  function proxyRefs(objectWithRefs) {
+    return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);
+  }
+  class ComputedRefImpl {
+    constructor(fn, setter, isSSR) {
+      this.fn = fn;
+      this.setter = setter;
+      /**
+       * @internal
+       */
+      this._value = void 0;
+      /**
+       * @internal
+       */
+      this.dep = new Dep(this);
+      /**
+       * @internal
+       */
+      this.__v_isRef = true;
+      // TODO isolatedDeclarations "__v_isReadonly"
+      // A computed is also a subscriber that tracks other deps
+      /**
+       * @internal
+       */
+      this.deps = void 0;
+      /**
+       * @internal
+       */
+      this.depsTail = void 0;
+      /**
+       * @internal
+       */
+      this.flags = 16;
+      /**
+       * @internal
+       */
+      this.globalVersion = globalVersion - 1;
+      // for backwards compat
+      this.effect = this;
+      this["__v_isReadonly"] = !setter;
+      this.isSSR = isSSR;
+    }
+    /**
+     * @internal
+     */
+    notify() {
+      if (activeSub !== this) {
+        this.flags |= 16;
+        this.dep.notify();
+      } else if (!!(process.env.NODE_ENV !== "production")) ;
+    }
+    get value() {
+      const link = !!(process.env.NODE_ENV !== "production") ? this.dep.track({
+        target: this,
+        type: "get",
+        key: "value"
+      }) : this.dep.track();
+      refreshComputed(this);
+      if (link) {
+        link.version = this.dep.version;
+      }
+      return this._value;
+    }
+    set value(newValue) {
+      if (this.setter) {
+        this.setter(newValue);
+      } else if (!!(process.env.NODE_ENV !== "production")) {
+        warn("Write operation failed: computed value is readonly");
+      }
+    }
+  }
+  function computed$1(getterOrOptions, debugOptions) {
+    let isSSR = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    let getter;
+    let setter;
+    if (isFunction$2(getterOrOptions)) {
+      getter = getterOrOptions;
+    } else {
+      getter = getterOrOptions.get;
+      setter = getterOrOptions.set;
+    }
+    const cRef = new ComputedRefImpl(getter, setter, isSSR);
+    if (!!(process.env.NODE_ENV !== "production") && debugOptions && !isSSR) {
+      cRef.onTrack = debugOptions.onTrack;
+      cRef.onTrigger = debugOptions.onTrigger;
+    }
+    return cRef;
+  }
+  const INITIAL_WATCHER_VALUE = {};
+  const cleanupMap = /* @__PURE__ */new WeakMap();
+  let activeWatcher = void 0;
+  function onWatcherCleanup(cleanupFn) {
+    let failSilently = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    let owner = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : activeWatcher;
+    if (owner) {
+      let cleanups = cleanupMap.get(owner);
+      if (!cleanups) cleanupMap.set(owner, cleanups = []);
+      cleanups.push(cleanupFn);
+    } else if (!!(process.env.NODE_ENV !== "production") && !failSilently) {
+      warn(`onWatcherCleanup() was called when there was no active watcher to associate with.`);
+    }
+  }
+  function watch$1(source, cb) {
+    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : EMPTY_OBJ;
+    const {
+      immediate,
+      deep,
+      once,
+      scheduler,
+      augmentJob,
+      call
+    } = options;
+    const warnInvalidSource = s => {
+      (options.onWarn || warn)(`Invalid watch source: `, s, `A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.`);
+    };
+    const reactiveGetter = source2 => {
+      if (deep) return source2;
+      if (isShallow(source2) || deep === false || deep === 0) return traverse(source2, 1);
+      return traverse(source2);
+    };
+    let effect;
+    let getter;
+    let cleanup;
+    let boundCleanup;
+    let forceTrigger = false;
+    let isMultiSource = false;
+    if (isRef(source)) {
+      getter = () => source.value;
+      forceTrigger = isShallow(source);
+    } else if (isReactive(source)) {
+      getter = () => reactiveGetter(source);
+      forceTrigger = true;
+    } else if (isArray(source)) {
+      isMultiSource = true;
+      forceTrigger = source.some(s => isReactive(s) || isShallow(s));
+      getter = () => source.map(s => {
+        if (isRef(s)) {
+          return s.value;
+        } else if (isReactive(s)) {
+          return reactiveGetter(s);
+        } else if (isFunction$2(s)) {
+          return call ? call(s, 2) : s();
+        } else {
+          !!(process.env.NODE_ENV !== "production") && warnInvalidSource(s);
+        }
+      });
+    } else if (isFunction$2(source)) {
+      if (cb) {
+        getter = call ? () => call(source, 2) : source;
+      } else {
+        getter = () => {
+          if (cleanup) {
+            pauseTracking();
+            try {
+              cleanup();
+            } finally {
+              resetTracking();
+            }
+          }
+          const currentEffect = activeWatcher;
+          activeWatcher = effect;
+          try {
+            return call ? call(source, 3, [boundCleanup]) : source(boundCleanup);
+          } finally {
+            activeWatcher = currentEffect;
+          }
+        };
+      }
+    } else {
+      getter = NOOP;
+      !!(process.env.NODE_ENV !== "production") && warnInvalidSource(source);
+    }
+    if (cb && deep) {
+      const baseGetter = getter;
+      const depth = deep === true ? Infinity : deep;
+      getter = () => traverse(baseGetter(), depth);
+    }
+    const watchHandle = () => {
+      effect.stop();
+    };
+    if (once) {
+      if (cb) {
+        const _cb = cb;
+        cb = function () {
+          _cb(...arguments);
+          watchHandle();
+        };
+      } else {
+        const _getter = getter;
+        getter = () => {
+          _getter();
+          watchHandle();
+        };
+      }
+    }
+    let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
+    const job = immediateFirstRun => {
+      if (!(effect.flags & 1) || !effect.dirty && !immediateFirstRun) {
+        return;
+      }
+      if (cb) {
+        const newValue = effect.run();
+        if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue))) {
+          if (cleanup) {
+            cleanup();
+          }
+          const currentWatcher = activeWatcher;
+          activeWatcher = effect;
+          try {
+            const args = [newValue,
+            // pass undefined as the old value when it's changed for the first time
+            oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue, boundCleanup];
+            call ? call(cb, 3, args) :
+            // @ts-expect-error
+            cb(...args);
+            oldValue = newValue;
+          } finally {
+            activeWatcher = currentWatcher;
+          }
+        }
+      } else {
+        effect.run();
+      }
+    };
+    if (augmentJob) {
+      augmentJob(job);
+    }
+    effect = new ReactiveEffect(getter);
+    effect.scheduler = scheduler ? () => scheduler(job, false) : job;
+    boundCleanup = fn => onWatcherCleanup(fn, false, effect);
+    cleanup = effect.onStop = () => {
+      const cleanups = cleanupMap.get(effect);
+      if (cleanups) {
+        if (call) {
+          call(cleanups, 4);
+        } else {
+          for (const cleanup2 of cleanups) cleanup2();
+        }
+        cleanupMap.delete(effect);
+      }
+    };
+    if (!!(process.env.NODE_ENV !== "production")) {
+      effect.onTrack = options.onTrack;
+      effect.onTrigger = options.onTrigger;
+    }
+    if (cb) {
+      if (immediate) {
+        job(true);
+      } else {
+        oldValue = effect.run();
+      }
+    } else if (scheduler) {
+      scheduler(job.bind(null, true), true);
+    } else {
+      effect.run();
+    }
+    watchHandle.pause = effect.pause.bind(effect);
+    watchHandle.resume = effect.resume.bind(effect);
+    watchHandle.stop = watchHandle;
+    return watchHandle;
+  }
+  function traverse(value) {
+    let depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Infinity;
+    let seen = arguments.length > 2 ? arguments[2] : undefined;
+    if (depth <= 0 || !isObject(value) || value["__v_skip"]) {
+      return value;
+    }
+    seen = seen || /* @__PURE__ */new Set();
+    if (seen.has(value)) {
+      return value;
+    }
+    seen.add(value);
+    depth--;
+    if (isRef(value)) {
+      traverse(value.value, depth, seen);
+    } else if (isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        traverse(value[i], depth, seen);
+      }
+    } else if (isSet(value) || isMap(value)) {
+      value.forEach(v => {
+        traverse(v, depth, seen);
+      });
+    } else if (isPlainObject(value)) {
+      for (const key in value) {
+        traverse(value[key], depth, seen);
+      }
+      for (const key of Object.getOwnPropertySymbols(value)) {
+        if (Object.prototype.propertyIsEnumerable.call(value, key)) {
+          traverse(value[key], depth, seen);
+        }
+      }
+    }
+    return value;
+  }
+
+  /**
+  * @vue/runtime-core v3.5.0
+  * (c) 2018-present Yuxi (Evan) You and Vue contributors
+  * @license MIT
+  **/
+  const stack = [];
+  function pushWarningContext(vnode) {
+    stack.push(vnode);
+  }
+  function popWarningContext() {
+    stack.pop();
+  }
+  let isWarning = false;
+  function warn$1(msg) {
+    if (isWarning) return;
+    isWarning = true;
+    pauseTracking();
+    const instance = stack.length ? stack[stack.length - 1].component : null;
+    const appWarnHandler = instance && instance.appContext.config.warnHandler;
+    const trace = getComponentTrace();
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+    if (appWarnHandler) {
+      callWithErrorHandling(appWarnHandler, instance, 11, [
+      // eslint-disable-next-line no-restricted-syntax
+      msg + args.map(a => {
+        var _a, _b;
+        return (_b = (_a = a.toString) == null ? void 0 : _a.call(a)) != null ? _b : JSON.stringify(a);
+      }).join(""), instance && instance.proxy, trace.map(_ref => {
+        let {
+          vnode
+        } = _ref;
+        return `at <${formatComponentName(instance, vnode.type)}>`;
+      }).join("\n"), trace]);
+    } else {
+      const warnArgs = [`[Vue warn]: ${msg}`, ...args];
+      if (trace.length &&
+      // avoid spamming console during tests
+      true) {
+        warnArgs.push(`
+`, ...formatTrace(trace));
+      }
+    }
+    resetTracking();
+    isWarning = false;
+  }
+  function getComponentTrace() {
+    let currentVNode = stack[stack.length - 1];
+    if (!currentVNode) {
+      return [];
+    }
+    const normalizedStack = [];
+    while (currentVNode) {
+      const last = normalizedStack[0];
+      if (last && last.vnode === currentVNode) {
+        last.recurseCount++;
+      } else {
+        normalizedStack.push({
+          vnode: currentVNode,
+          recurseCount: 0
+        });
+      }
+      const parentInstance = currentVNode.component && currentVNode.component.parent;
+      currentVNode = parentInstance && parentInstance.vnode;
+    }
+    return normalizedStack;
+  }
+  function formatTrace(trace) {
+    const logs = [];
+    trace.forEach((entry, i) => {
+      logs.push(...(i === 0 ? [] : [`
+`]), ...formatTraceEntry(entry));
+    });
+    return logs;
+  }
+  function formatTraceEntry(_ref2) {
+    let {
+      vnode,
+      recurseCount
+    } = _ref2;
+    const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
+    const isRoot = vnode.component ? vnode.component.parent == null : false;
+    const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`;
+    const close = `>` + postfix;
+    return vnode.props ? [open, ...formatProps(vnode.props), close] : [open + close];
+  }
+  function formatProps(props) {
+    const res = [];
+    const keys = Object.keys(props);
+    keys.slice(0, 3).forEach(key => {
+      res.push(...formatProp(key, props[key]));
+    });
+    if (keys.length > 3) {
+      res.push(` ...`);
+    }
+    return res;
+  }
+  function formatProp(key, value, raw) {
+    if (isString(value)) {
+      value = JSON.stringify(value);
+      return raw ? value : [`${key}=${value}`];
+    } else if (typeof value === "number" || typeof value === "boolean" || value == null) {
+      return raw ? value : [`${key}=${value}`];
+    } else if (isRef(value)) {
+      value = formatProp(key, toRaw(value.value), true);
+      return raw ? value : [`${key}=Ref<`, value, `>`];
+    } else if (isFunction$2(value)) {
+      return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
+    } else {
+      value = toRaw(value);
+      return raw ? value : [`${key}=`, value];
+    }
+  }
+  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",
+    [16]: "app unmount cleanup function"
+  };
+  function callWithErrorHandling(fn, instance, type, args) {
+    try {
+      return args ? fn(...args) : fn();
+    } catch (err) {
+      handleError(err, instance, type);
+    }
+  }
+  function callWithAsyncErrorHandling(fn, instance, type, args) {
+    if (isFunction$2(fn)) {
+      const res = callWithErrorHandling(fn, instance, type, args);
+      if (res && isPromise(res)) {
+        res.catch(err => {
+          handleError(err, instance, type);
+        });
+      }
+      return res;
+    }
+    if (isArray(fn)) {
+      const values = [];
+      for (let i = 0; i < fn.length; i++) {
+        values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));
+      }
+      return values;
+    } else if (!!(process.env.NODE_ENV !== "production")) {
+      warn$1(`Invalid value type passed to callWithAsyncErrorHandling(): ${typeof fn}`);
+    }
+  }
+  function handleError(err, instance, type) {
+    let throwInDev = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+    const contextVNode = instance ? instance.vnode : null;
+    const {
+      errorHandler,
+      throwUnhandledErrorInProduction
+    } = instance && instance.appContext.config || EMPTY_OBJ;
+    if (instance) {
+      let cur = instance.parent;
+      const exposedInstance = instance.proxy;
+      const errorInfo = !!(process.env.NODE_ENV !== "production") ? ErrorTypeStrings$1[type] : `https://vuejs.org/error-reference/#runtime-${type}`;
+      while (cur) {
+        const errorCapturedHooks = cur.ec;
+        if (errorCapturedHooks) {
+          for (let i = 0; i < errorCapturedHooks.length; i++) {
+            if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {
+              return;
+            }
+          }
+        }
+        cur = cur.parent;
+      }
+      if (errorHandler) {
+        pauseTracking();
+        callWithErrorHandling(errorHandler, null, 10, [err, exposedInstance, errorInfo]);
+        resetTracking();
+        return;
+      }
+    }
+    logError(err, type, contextVNode, throwInDev, throwUnhandledErrorInProduction);
+  }
+  function logError(err, type, contextVNode) {
+    let throwInDev = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+    let throwInProd = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+    if (!!(process.env.NODE_ENV !== "production")) {
+      const info = ErrorTypeStrings$1[type];
+      if (contextVNode) {
+        pushWarningContext(contextVNode);
+      }
+      warn$1(`Unhandled error${info ? ` during execution of ${info}` : ``}`);
+      if (contextVNode) {
+        popWarningContext();
+      }
+      if (throwInDev) {
+        throw err;
+      }
+    } else if (throwInProd) {
+      throw err;
+    } else ;
+  }
+  let isFlushing = false;
+  let isFlushPending = false;
+  const queue = [];
+  let flushIndex = 0;
+  const pendingPostFlushCbs = [];
+  let activePostFlushCbs = null;
+  let postFlushIndex = 0;
+  const resolvedPromise = /* @__PURE__ */Promise.resolve();
+  let currentFlushPromise = null;
+  const RECURSION_LIMIT = 100;
+  function nextTick(fn) {
+    const p = currentFlushPromise || resolvedPromise;
+    return fn ? p.then(this ? fn.bind(this) : fn) : p;
+  }
+  function findInsertionIndex(id) {
+    let start = isFlushing ? flushIndex + 1 : 0;
+    let end = queue.length;
+    while (start < end) {
+      const middle = start + end >>> 1;
+      const middleJob = queue[middle];
+      const middleJobId = getId(middleJob);
+      if (middleJobId < id || middleJobId === id && middleJob.flags & 2) {
+        start = middle + 1;
+      } else {
+        end = middle;
+      }
+    }
+    return start;
+  }
+  function queueJob(job) {
+    if (!(job.flags & 1)) {
+      const jobId = getId(job);
+      const lastJob = queue[queue.length - 1];
+      if (!lastJob ||
+      // fast path when the job id is larger than the tail
+      !(job.flags & 2) && jobId >= getId(lastJob)) {
+        queue.push(job);
+      } else {
+        queue.splice(findInsertionIndex(jobId), 0, job);
+      }
+      if (!(job.flags & 4)) {
+        job.flags |= 1;
+      }
+      queueFlush();
+    }
+  }
+  function queueFlush() {
+    if (!isFlushing && !isFlushPending) {
+      isFlushPending = true;
+      currentFlushPromise = resolvedPromise.then(flushJobs);
+    }
+  }
+  function queuePostFlushCb(cb) {
+    if (!isArray(cb)) {
+      if (activePostFlushCbs && cb.id === -1) {
+        activePostFlushCbs.splice(postFlushIndex + 1, 0, cb);
+      } else if (!(cb.flags & 1)) {
+        pendingPostFlushCbs.push(cb);
+        if (!(cb.flags & 4)) {
+          cb.flags |= 1;
+        }
+      }
+    } else {
+      pendingPostFlushCbs.push(...cb);
+    }
+    queueFlush();
+  }
+  function flushPostFlushCbs(seen) {
+    if (pendingPostFlushCbs.length) {
+      const deduped = [...new Set(pendingPostFlushCbs)].sort((a, b) => getId(a) - getId(b));
+      pendingPostFlushCbs.length = 0;
+      if (activePostFlushCbs) {
+        activePostFlushCbs.push(...deduped);
+        return;
+      }
+      activePostFlushCbs = deduped;
+      if (!!(process.env.NODE_ENV !== "production")) {
+        seen = seen || /* @__PURE__ */new Map();
+      }
+      for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
+        const cb = activePostFlushCbs[postFlushIndex];
+        if (!!(process.env.NODE_ENV !== "production") && checkRecursiveUpdates(seen, cb)) {
+          continue;
+        }
+        if (!(cb.flags & 8)) cb();
+        cb.flags &= ~1;
+      }
+      activePostFlushCbs = null;
+      postFlushIndex = 0;
+    }
+  }
+  const getId = job => job.id == null ? job.flags & 2 ? -1 : Infinity : job.id;
+  function flushJobs(seen) {
+    isFlushPending = false;
+    isFlushing = true;
+    if (!!(process.env.NODE_ENV !== "production")) {
+      seen = seen || /* @__PURE__ */new Map();
+    }
+    const check = !!(process.env.NODE_ENV !== "production") ? job => checkRecursiveUpdates(seen, job) : NOOP;
+    try {
+      for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
+        const job = queue[flushIndex];
+        if (job && !(job.flags & 8)) {
+          if (!!(process.env.NODE_ENV !== "production") && check(job)) {
+            continue;
+          }
+          callWithErrorHandling(job, job.i, job.i ? 15 : 14);
+          job.flags &= ~1;
+        }
+      }
+    } finally {
+      flushIndex = 0;
+      queue.length = 0;
+      flushPostFlushCbs(seen);
+      isFlushing = false;
+      currentFlushPromise = null;
+      if (queue.length || pendingPostFlushCbs.length) {
+        flushJobs(seen);
+      }
+    }
+  }
+  function checkRecursiveUpdates(seen, fn) {
+    if (!seen.has(fn)) {
+      seen.set(fn, 1);
+    } else {
+      const count = seen.get(fn);
+      if (count > RECURSION_LIMIT) {
+        const instance = fn.i;
+        const componentName = instance && getComponentName(instance.type);
+        handleError(`Maximum recursive updates exceeded${componentName ? ` in component <${componentName}>` : ``}. 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);
+        return true;
+      } else {
+        seen.set(fn, count + 1);
+      }
+    }
+  }
+  const hmrDirtyComponents = /* @__PURE__ */new Map();
+  if (!!(process.env.NODE_ENV !== "production")) {
+    getGlobalThis().__VUE_HMR_RUNTIME__ = {
+      createRecord: tryWrap(createRecord),
+      rerender: tryWrap(rerender),
+      reload: tryWrap(reload)
+    };
+  }
+  const map = /* @__PURE__ */new Map();
+  function createRecord(id, initialDef) {
+    if (map.has(id)) {
+      return false;
+    }
+    map.set(id, {
+      initialDef: normalizeClassComponent(initialDef),
+      instances: /* @__PURE__ */new Set()
+    });
+    return true;
+  }
+  function normalizeClassComponent(component) {
+    return isClassComponent(component) ? component.__vccOpts : component;
+  }
+  function rerender(id, newRender) {
+    const record = map.get(id);
+    if (!record) {
+      return;
+    }
+    record.initialDef.render = newRender;
+    [...record.instances].forEach(instance => {
+      if (newRender) {
+        instance.render = newRender;
+        normalizeClassComponent(instance.type).render = newRender;
+      }
+      instance.renderCache = [];
+      instance.update();
+    });
+  }
+  function reload(id, newComp) {
+    const record = map.get(id);
+    if (!record) return;
+    newComp = normalizeClassComponent(newComp);
+    updateComponentDef(record.initialDef, newComp);
+    const instances = [...record.instances];
+    for (let i = 0; i < instances.length; i++) {
+      const instance = instances[i];
+      const oldComp = normalizeClassComponent(instance.type);
+      let dirtyInstances = hmrDirtyComponents.get(oldComp);
+      if (!dirtyInstances) {
+        if (oldComp !== record.initialDef) {
+          updateComponentDef(oldComp, newComp);
+        }
+        hmrDirtyComponents.set(oldComp, dirtyInstances = /* @__PURE__ */new Set());
+      }
+      dirtyInstances.add(instance);
+      instance.appContext.propsCache.delete(instance.type);
+      instance.appContext.emitsCache.delete(instance.type);
+      instance.appContext.optionsCache.delete(instance.type);
+      if (instance.ceReload) {
+        dirtyInstances.add(instance);
+        instance.ceReload(newComp.styles);
+        dirtyInstances.delete(instance);
+      } else if (instance.parent) {
+        queueJob(() => {
+          instance.parent.update();
+          dirtyInstances.delete(instance);
+        });
+      } else if (instance.appContext.reload) {
+        instance.appContext.reload();
+      } else if (typeof window !== "undefined") {
+        window.location.reload();
+      } else ;
+      if (instance.root.ce && instance !== instance.root) {
+        instance.root.ce._removeChildStyle(oldComp);
+      }
+    }
+    queuePostFlushCb(() => {
+      hmrDirtyComponents.clear();
+    });
+  }
+  function updateComponentDef(oldComp, newComp) {
+    extend(oldComp, newComp);
+    for (const key in oldComp) {
+      if (key !== "__file" && !(key in newComp)) {
+        delete oldComp[key];
+      }
+    }
+  }
+  function tryWrap(fn) {
+    return (id, arg) => {
+      try {
+        return fn(id, arg);
+      } catch (e) {
+      }
+    };
+  }
+  let devtools$1;
+  let buffer = [];
+  function setDevtoolsHook$1(hook, target) {
+    var _a, _b;
+    devtools$1 = hook;
+    if (devtools$1) {
+      devtools$1.enabled = true;
+      buffer.forEach(_ref3 => {
+        let {
+          event,
+          args
+        } = _ref3;
+        return devtools$1.emit(event, ...args);
+      });
+      buffer = [];
+    } else if (
+    // 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
+    !((_b = (_a = window.navigator) == null ? void 0 : _a.userAgent) == null ? void 0 : _b.includes("jsdom"))) {
+      const replay = target.__VUE_DEVTOOLS_HOOK_REPLAY__ = target.__VUE_DEVTOOLS_HOOK_REPLAY__ || [];
+      replay.push(newHook => {
+        setDevtoolsHook$1(newHook, target);
+      });
+      setTimeout(() => {
+        if (!devtools$1) {
+          target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null;
+          buffer = [];
+        }
+      }, 3e3);
+    } else {
+      buffer = [];
+    }
+  }
+  let currentRenderingInstance = null;
+  let currentScopeId = null;
+  const isTeleport = type => type.__isTeleport;
+  function setTransitionHooks(vnode, hooks) {
+    if (vnode.shapeFlag & 6 && vnode.component) {
+      setTransitionHooks(vnode.component.subTree, hooks);
+    } else if (vnode.shapeFlag & 128) {
+      vnode.ssContent.transition = hooks.clone(vnode.ssContent);
+      vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);
+    } else {
+      vnode.transition = hooks;
+    }
+  }
+
+  /*! #__NO_SIDE_EFFECTS__ */
+  // @__NO_SIDE_EFFECTS__
+  function defineComponent(options, extraOptions) {
+    return isFunction$2(options) ?
+    // #8236: extend call and options.name access are considered side-effects
+    // by Rollup, so we have to wrap it in a pure-annotated IIFE.
+    /* @__PURE__ */
+    (() => extend({
+      name: options.name
+    }, extraOptions, {
+      setup: options
+    }))() : options;
+  }
+  const isAsyncWrapper = i => !!i.type.__asyncLoader;
+  function injectHook(type, hook) {
+    let target = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : currentInstance;
+    let prepend = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+    if (target) {
+      const hooks = target[type] || (target[type] = []);
+      const wrappedHook = hook.__weh || (hook.__weh = function () {
+        pauseTracking();
+        const reset = setCurrentInstance(target);
+        for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+          args[_key3] = arguments[_key3];
+        }
+        const res = callWithAsyncErrorHandling(hook, target, type, args);
+        reset();
+        resetTracking();
+        return res;
+      });
+      if (prepend) {
+        hooks.unshift(wrappedHook);
+      } else {
+        hooks.push(wrappedHook);
+      }
+      return wrappedHook;
+    } else if (!!(process.env.NODE_ENV !== "production")) {
+      const apiName = toHandlerKey(ErrorTypeStrings$1[type].replace(/ hook$/, ""));
+      warn$1(`${apiName} is called when there is no active component instance to be associated with. Lifecycle injection APIs can only be used during execution of setup().` + ` If you are using async setup(), make sure to register lifecycle hooks before the first await statement.`);
+    }
+  }
+  const createHook = lifecycle => function (hook) {
+    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : currentInstance;
+    if (!isInSSRComponentSetup || lifecycle === "sp") {
+      injectHook(lifecycle, function () {
+        return hook(...arguments);
+      }, target);
+    }
+  };
+  const onMounted = createHook("m");
+  const onBeforeUnmount = createHook("bum");
+  const NULL_DYNAMIC_COMPONENT = Symbol.for("v-ndc");
+  function renderSlot(slots, name) {
+    let props = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    let fallback = arguments.length > 3 ? arguments[3] : undefined;
+    let noSlotted = arguments.length > 4 ? arguments[4] : undefined;
+    if (currentRenderingInstance.ce || currentRenderingInstance.parent && isAsyncWrapper(currentRenderingInstance.parent) && currentRenderingInstance.parent.ce) {
+      if (name !== "default") props.name = name;
+      return openBlock(), createBlock(Fragment, null, [createVNode("slot", props, fallback && fallback())], 64);
+    }
+    let slot = slots[name];
+    if (!!(process.env.NODE_ENV !== "production") && slot && slot.length > 1) {
+      warn$1(`SSR-optimized slot function detected in a non-SSR-optimized render function. You need to mark this component with $dynamic-slots in the parent template.`);
+      slot = () => [];
+    }
+    if (slot && slot._c) {
+      slot._d = false;
+    }
+    openBlock();
+    const validSlotContent = slot && ensureValidVNode(slot(props));
+    const rendered = createBlock(Fragment, {
+      key: (props.key ||
+      // slot content array of a dynamic conditional slot may have a branch
+      // key attached in the `createSlots` helper, respect that
+      validSlotContent && validSlotContent.key || `_${name}`) + (
+      // #7256 force differentiate fallback content from actual content
+      !validSlotContent && fallback ? "_fb" : "")
+    }, validSlotContent || (fallback ? fallback() : []), validSlotContent && slots._ === 1 ? 64 : -2);
+    if (!noSlotted && rendered.scopeId) {
+      rendered.slotScopeIds = [rendered.scopeId + "-s"];
+    }
+    if (slot && slot._c) {
+      slot._d = true;
+    }
+    return rendered;
+  }
+  function ensureValidVNode(vnodes) {
+    return vnodes.some(child => {
+      if (!isVNode(child)) return true;
+      if (child.type === Comment) return false;
+      if (child.type === Fragment && !ensureValidVNode(child.children)) return false;
+      return true;
+    }) ? vnodes : null;
+  }
+  const getPublicInstance = i => {
+    if (!i) return null;
+    if (isStatefulComponent(i)) return getComponentPublicInstance(i);
+    return getPublicInstance(i.parent);
+  };
+  const publicPropertiesMap =
+  // Move PURE marker to new line to workaround compiler discarding it
+  // due to type annotation
+  /* @__PURE__ */
+  extend( /* @__PURE__ */Object.create(null), {
+    $: i => i,
+    $el: i => i.vnode.el,
+    $data: i => i.data,
+    $props: i => !!(process.env.NODE_ENV !== "production") ? shallowReadonly(i.props) : i.props,
+    $attrs: i => !!(process.env.NODE_ENV !== "production") ? shallowReadonly(i.attrs) : i.attrs,
+    $slots: i => !!(process.env.NODE_ENV !== "production") ? shallowReadonly(i.slots) : i.slots,
+    $refs: i => !!(process.env.NODE_ENV !== "production") ? shallowReadonly(i.refs) : i.refs,
+    $parent: i => getPublicInstance(i.parent),
+    $root: i => getPublicInstance(i.root),
+    $host: i => i.ce,
+    $emit: i => i.emit,
+    $options: i => __VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type,
+    $forceUpdate: i => i.f || (i.f = () => {
+      queueJob(i.update);
+    }),
+    $nextTick: i => i.n || (i.n = nextTick.bind(i.proxy)),
+    $watch: i => __VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP
+  });
+  const isReservedPrefix = key => key === "_" || key === "$";
+  const hasSetupBinding = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn(state, key);
+  const PublicInstanceProxyHandlers = {
+    get(_ref10, key) {
+      let {
+        _: instance
+      } = _ref10;
+      if (key === "__v_skip") {
+        return true;
+      }
+      const {
+        ctx,
+        setupState,
+        data,
+        props,
+        accessCache,
+        type,
+        appContext
+      } = instance;
+      if (!!(process.env.NODE_ENV !== "production") && key === "__isVue") {
+        return true;
+      }
+      let normalizedProps;
+      if (key[0] !== "$") {
+        const n = accessCache[key];
+        if (n !== void 0) {
+          switch (n) {
+            case 1 /* SETUP */:
+              return setupState[key];
+            case 2 /* DATA */:
+              return data[key];
+            case 4 /* CONTEXT */:
+              return ctx[key];
+            case 3 /* PROPS */:
+              return props[key];
+          }
+        } else if (hasSetupBinding(setupState, key)) {
+          accessCache[key] = 1 /* SETUP */;
+          return setupState[key];
+        } else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
+          accessCache[key] = 2 /* DATA */;
+          return data[key];
+        } else if (
+        // only cache other properties when instance has declared (thus stable)
+        // props
+        (normalizedProps = instance.propsOptions[0]) && hasOwn(normalizedProps, key)) {
+          accessCache[key] = 3 /* PROPS */;
+          return props[key];
+        } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
+          accessCache[key] = 4 /* CONTEXT */;
+          return ctx[key];
+        } else if (!__VUE_OPTIONS_API__ || shouldCacheAccess) {
+          accessCache[key] = 0 /* OTHER */;
+        }
+      }
+
+      const publicGetter = publicPropertiesMap[key];
+      let cssModule, globalProperties;
+      if (publicGetter) {
+        if (key === "$attrs") {
+          track(instance.attrs, "get", "");
+          !!(process.env.NODE_ENV !== "production") && markAttrsAccessed();
+        } else if (!!(process.env.NODE_ENV !== "production") && key === "$slots") {
+          track(instance, "get", key);
+        }
+        return publicGetter(instance);
+      } else if (
+      // css module (injected by vue-loader)
+      (cssModule = type.__cssModules) && (cssModule = cssModule[key])) {
+        return cssModule;
+      } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
+        accessCache[key] = 4 /* CONTEXT */;
+        return ctx[key];
+      } else if (
+      // global properties
+      globalProperties = appContext.config.globalProperties, hasOwn(globalProperties, key)) {
+        {
+          return globalProperties[key];
+        }
+      } else if (!!(process.env.NODE_ENV !== "production") && currentRenderingInstance && (!isString(key) ||
+      // #1091 avoid internal isRef/isVNode checks on component instance leading
+      // to infinite warning loop
+      key.indexOf("__v") !== 0)) {
+        if (data !== EMPTY_OBJ && isReservedPrefix(key[0]) && hasOwn(data, key)) {
+          warn$1(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved character ("$" or "_") and is not proxied on the render context.`);
+        } else if (instance === currentRenderingInstance) {
+          warn$1(`Property ${JSON.stringify(key)} was accessed during render but is not defined on instance.`);
+        }
+      }
+    },
+    set(_ref11, key, value) {
+      let {
+        _: instance
+      } = _ref11;
+      const {
+        data,
+        setupState,
+        ctx
+      } = instance;
+      if (hasSetupBinding(setupState, key)) {
+        setupState[key] = value;
+        return true;
+      } else if (!!(process.env.NODE_ENV !== "production") && setupState.__isScriptSetup && hasOwn(setupState, key)) {
+        warn$1(`Cannot mutate <script setup> binding "${key}" from Options API.`);
+        return false;
+      } else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
+        data[key] = value;
+        return true;
+      } else if (hasOwn(instance.props, key)) {
+        !!(process.env.NODE_ENV !== "production") && warn$1(`Attempting to mutate prop "${key}". Props are readonly.`);
+        return false;
+      }
+      if (key[0] === "$" && key.slice(1) in instance) {
+        !!(process.env.NODE_ENV !== "production") && warn$1(`Attempting to mutate public property "${key}". Properties starting with $ are reserved and readonly.`);
+        return false;
+      } else {
+        if (!!(process.env.NODE_ENV !== "production") && key in instance.appContext.config.globalProperties) {
+          Object.defineProperty(ctx, key, {
+            enumerable: true,
+            configurable: true,
+            value
+          });
+        } else {
+          ctx[key] = value;
+        }
+      }
+      return true;
+    },
+    has(_ref12, key) {
+      let {
+        _: {
+          data,
+          setupState,
+          accessCache,
+          ctx,
+          appContext,
+          propsOptions
+        }
+      } = _ref12;
+      let normalizedProps;
+      return !!accessCache[key] || data !== EMPTY_OBJ && hasOwn(data, key) || hasSetupBinding(setupState, key) || (normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key) || hasOwn(ctx, key) || hasOwn(publicPropertiesMap, key) || hasOwn(appContext.config.globalProperties, key);
+    },
+    defineProperty(target, key, descriptor) {
+      if (descriptor.get != null) {
+        target._.accessCache[key] = 0;
+      } else if (hasOwn(descriptor, "value")) {
+        this.set(target, key, descriptor.value, null);
+      }
+      return Reflect.defineProperty(target, key, descriptor);
+    }
+  };
+  if (!!(process.env.NODE_ENV !== "production") && true) {
+    PublicInstanceProxyHandlers.ownKeys = target => {
+      warn$1(`Avoid app logic that relies on enumerating keys on a component instance. The keys will be empty in production mode to avoid performance overhead.`);
+      return Reflect.ownKeys(target);
+    };
+  }
+  function useSlots() {
+    return getContext().slots;
+  }
+  function getContext() {
+    const i = getCurrentInstance();
+    if (!!(process.env.NODE_ENV !== "production") && !i) {
+      warn$1(`useContext() called without active instance.`);
+    }
+    return i.setupContext || (i.setupContext = createSetupContext(i));
+  }
+  function normalizePropsOrEmits(props) {
+    return isArray(props) ? props.reduce((normalized, p) => (normalized[p] = null, normalized), {}) : props;
+  }
+  let shouldCacheAccess = true;
+  function resolveMergedOptions(instance) {
+    const base = instance.type;
+    const {
+      mixins,
+      extends: extendsOptions
+    } = base;
+    const {
+      mixins: globalMixins,
+      optionsCache: cache,
+      config: {
+        optionMergeStrategies
+      }
+    } = instance.appContext;
+    const cached = cache.get(base);
+    let resolved;
+    if (cached) {
+      resolved = cached;
+    } else if (!globalMixins.length && !mixins && !extendsOptions) {
+      {
+        resolved = base;
+      }
+    } else {
+      resolved = {};
+      if (globalMixins.length) {
+        globalMixins.forEach(m => mergeOptions(resolved, m, optionMergeStrategies, true));
+      }
+      mergeOptions(resolved, base, optionMergeStrategies);
+    }
+    if (isObject(base)) {
+      cache.set(base, resolved);
+    }
+    return resolved;
+  }
+  function mergeOptions(to, from, strats) {
+    let asMixin = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+    const {
+      mixins,
+      extends: extendsOptions
+    } = from;
+    if (extendsOptions) {
+      mergeOptions(to, extendsOptions, strats, true);
+    }
+    if (mixins) {
+      mixins.forEach(m => mergeOptions(to, m, strats, true));
+    }
+    for (const key in from) {
+      if (asMixin && key === "expose") {
+        !!(process.env.NODE_ENV !== "production") && warn$1(`"expose" option is ignored when declared in mixins or extends. It should only be declared in the base component itself.`);
+      } else {
+        const strat = internalOptionMergeStrats[key] || strats && strats[key];
+        to[key] = strat ? strat(to[key], from[key]) : from[key];
+      }
+    }
+    return to;
+  }
+  const internalOptionMergeStrats = {
+    data: mergeDataFn,
+    props: mergeEmitsOrPropsOptions,
+    emits: mergeEmitsOrPropsOptions,
+    // objects
+    methods: mergeObjectOptions,
+    computed: mergeObjectOptions,
+    // lifecycle
+    beforeCreate: mergeAsArray,
+    created: mergeAsArray,
+    beforeMount: mergeAsArray,
+    mounted: mergeAsArray,
+    beforeUpdate: mergeAsArray,
+    updated: mergeAsArray,
+    beforeDestroy: mergeAsArray,
+    beforeUnmount: mergeAsArray,
+    destroyed: mergeAsArray,
+    unmounted: mergeAsArray,
+    activated: mergeAsArray,
+    deactivated: mergeAsArray,
+    errorCaptured: mergeAsArray,
+    serverPrefetch: mergeAsArray,
+    // assets
+    components: mergeObjectOptions,
+    directives: mergeObjectOptions,
+    // watch
+    watch: mergeWatchOptions,
+    // provide / inject
+    provide: mergeDataFn,
+    inject: mergeInject
+  };
+  function mergeDataFn(to, from) {
+    if (!from) {
+      return to;
+    }
+    if (!to) {
+      return from;
+    }
+    return function mergedDataFn() {
+      return extend(isFunction$2(to) ? to.call(this, this) : to, isFunction$2(from) ? from.call(this, this) : from);
+    };
+  }
+  function mergeInject(to, from) {
+    return mergeObjectOptions(normalizeInject(to), normalizeInject(from));
+  }
+  function normalizeInject(raw) {
+    if (isArray(raw)) {
+      const res = {};
+      for (let i = 0; i < raw.length; i++) {
+        res[raw[i]] = raw[i];
+      }
+      return res;
+    }
+    return raw;
+  }
+  function mergeAsArray(to, from) {
+    return to ? [...new Set([].concat(to, from))] : from;
+  }
+  function mergeObjectOptions(to, from) {
+    return to ? extend( /* @__PURE__ */Object.create(null), to, from) : from;
+  }
+  function mergeEmitsOrPropsOptions(to, from) {
+    if (to) {
+      if (isArray(to) && isArray(from)) {
+        return [... /* @__PURE__ */new Set([...to, ...from])];
+      }
+      return extend( /* @__PURE__ */Object.create(null), normalizePropsOrEmits(to), normalizePropsOrEmits(from != null ? from : {}));
+    } else {
+      return from;
+    }
+  }
+  function mergeWatchOptions(to, from) {
+    if (!to) return from;
+    if (!from) return to;
+    const merged = extend( /* @__PURE__ */Object.create(null), to);
+    for (const key in from) {
+      merged[key] = mergeAsArray(to[key], from[key]);
+    }
+    return merged;
+  }
+  let currentApp = null;
+  function inject(key, defaultValue) {
+    let treatDefaultAsFactory = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    const instance = currentInstance || currentRenderingInstance;
+    if (instance || currentApp) {
+      const provides = instance ? instance.parent == null ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : void 0;
+      if (provides && key in provides) {
+        return provides[key];
+      } else if (arguments.length > 1) {
+        return treatDefaultAsFactory && isFunction$2(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue;
+      } else if (!!(process.env.NODE_ENV !== "production")) {
+        warn$1(`injection "${String(key)}" not found.`);
+      }
+    } else if (!!(process.env.NODE_ENV !== "production")) {
+      warn$1(`inject() can only be used inside setup() or functional components.`);
+    }
+  }
+  const internalObjectProto = {};
+  const isInternalObject = obj => Object.getPrototypeOf(obj) === internalObjectProto;
+  const queuePostRenderEffect = queueEffectWithSuspense;
+  const ssrContextKey = Symbol.for("v-scx");
+  const useSSRContext = () => {
+    {
+      const ctx = inject(ssrContextKey);
+      if (!ctx) {
+        !!(process.env.NODE_ENV !== "production") && warn$1(`Server rendering context not provided. Make sure to only call useSSRContext() conditionally in the server build.`);
+      }
+      return ctx;
+    }
+  };
+  function watch(source, cb, options) {
+    if (!!(process.env.NODE_ENV !== "production") && !isFunction$2(cb)) {
+      warn$1(`\`watch(fn, options?)\` signature has been moved to a separate API. Use \`watchEffect(fn, options?)\` instead. \`watch\` now only supports \`watch(source, cb, options?) signature.`);
+    }
+    return doWatch(source, cb, options);
+  }
+  function doWatch(source, cb) {
+    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : EMPTY_OBJ;
+    const {
+      immediate,
+      deep,
+      flush,
+      once
+    } = options;
+    if (!!(process.env.NODE_ENV !== "production") && !cb) {
+      if (immediate !== void 0) {
+        warn$1(`watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.`);
+      }
+      if (deep !== void 0) {
+        warn$1(`watch() "deep" option is only respected when using the watch(source, callback, options?) signature.`);
+      }
+      if (once !== void 0) {
+        warn$1(`watch() "once" option is only respected when using the watch(source, callback, options?) signature.`);
+      }
+    }
+    const baseWatchOptions = extend({}, options);
+    if (!!(process.env.NODE_ENV !== "production")) baseWatchOptions.onWarn = warn$1;
+    let ssrCleanup;
+    if (isInSSRComponentSetup) {
+      if (flush === "sync") {
+        const ctx = useSSRContext();
+        ssrCleanup = ctx.__watcherHandles || (ctx.__watcherHandles = []);
+      } else if (!cb || immediate) {
+        baseWatchOptions.once = true;
+      } else {
+        return {
+          stop: NOOP,
+          resume: NOOP,
+          pause: NOOP
+        };
+      }
+    }
+    const instance = currentInstance;
+    baseWatchOptions.call = (fn, type, args) => callWithAsyncErrorHandling(fn, instance, type, args);
+    let isPre = false;
+    if (flush === "post") {
+      baseWatchOptions.scheduler = job => {
+        queuePostRenderEffect(job, instance && instance.suspense);
+      };
+    } else if (flush !== "sync") {
+      isPre = true;
+      baseWatchOptions.scheduler = (job, isFirstRun) => {
+        if (isFirstRun) {
+          job();
+        } else {
+          queueJob(job);
+        }
+      };
+    }
+    baseWatchOptions.augmentJob = job => {
+      if (cb) {
+        job.flags |= 4;
+      }
+      if (isPre) {
+        job.flags |= 2;
+        if (instance) {
+          job.id = instance.uid;
+          job.i = instance;
+        }
+      }
+    };
+    const watchHandle = watch$1(source, cb, baseWatchOptions);
+    if (ssrCleanup) ssrCleanup.push(watchHandle);
+    return watchHandle;
+  }
+  function instanceWatch(source, value, options) {
+    const publicThis = this.proxy;
+    const getter = isString(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis);
+    let cb;
+    if (isFunction$2(value)) {
+      cb = value;
+    } else {
+      cb = value.handler;
+      options = value;
+    }
+    const reset = setCurrentInstance(this);
+    const res = doWatch(getter, cb.bind(publicThis), options);
+    reset();
+    return res;
+  }
+  function createPathGetter(ctx, path) {
+    const segments = path.split(".");
+    return () => {
+      let cur = ctx;
+      for (let i = 0; i < segments.length && cur; i++) {
+        cur = cur[segments[i]];
+      }
+      return cur;
+    };
+  }
+  function markAttrsAccessed() {
+  }
+  const isSuspense = type => type.__isSuspense;
+  function queueEffectWithSuspense(fn, suspense) {
+    if (suspense && suspense.pendingBranch) {
+      if (isArray(fn)) {
+        suspense.effects.push(...fn);
+      } else {
+        suspense.effects.push(fn);
+      }
+    } else {
+      queuePostFlushCb(fn);
+    }
+  }
+  const Fragment = Symbol.for("v-fgt");
+  const Text$1 = Symbol.for("v-txt");
+  const Comment = Symbol.for("v-cmt");
+  const blockStack = [];
+  let currentBlock = null;
+  function openBlock() {
+    let disableTracking = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    blockStack.push(currentBlock = disableTracking ? null : []);
+  }
+  function closeBlock() {
+    blockStack.pop();
+    currentBlock = blockStack[blockStack.length - 1] || null;
+  }
+  function setupBlock(vnode) {
+    vnode.dynamicChildren = currentBlock || EMPTY_ARR ;
+    closeBlock();
+    if (currentBlock) {
+      currentBlock.push(vnode);
+    }
+    return vnode;
+  }
+  function createElementBlock(type, props, children, patchFlag, dynamicProps, shapeFlag) {
+    return setupBlock(createBaseVNode(type, props, children, patchFlag, dynamicProps, shapeFlag, true));
+  }
+  function createBlock(type, props, children, patchFlag, dynamicProps) {
+    return setupBlock(createVNode(type, props, children, patchFlag, dynamicProps, true));
+  }
+  function isVNode(value) {
+    return value ? value.__v_isVNode === true : false;
+  }
+  const createVNodeWithArgsTransform = function () {
+    for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
+      args[_key7] = arguments[_key7];
+    }
+    return _createVNode(...(args));
+  };
+  const normalizeKey = _ref19 => {
+    let {
+      key
+    } = _ref19;
+    return key != null ? key : null;
+  };
+  const normalizeRef = _ref20 => {
+    let {
+      ref,
+      ref_key,
+      ref_for
+    } = _ref20;
+    if (typeof ref === "number") {
+      ref = "" + ref;
+    }
+    return ref != null ? isString(ref) || isRef(ref) || isFunction$2(ref) ? {
+      i: currentRenderingInstance,
+      r: ref,
+      k: ref_key,
+      f: !!ref_for
+    } : ref : null;
+  };
+  function createBaseVNode(type) {
+    let props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    let children = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+    let patchFlag = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+    let dynamicProps = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
+    let shapeFlag = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : type === Fragment ? 0 : 1;
+    let isBlockNode = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : false;
+    let needFullChildrenNormalization = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : false;
+    const vnode = {
+      __v_isVNode: true,
+      __v_skip: true,
+      type,
+      props,
+      key: props && normalizeKey(props),
+      ref: props && normalizeRef(props),
+      scopeId: currentScopeId,
+      slotScopeIds: null,
+      children,
+      component: null,
+      suspense: null,
+      ssContent: null,
+      ssFallback: null,
+      dirs: null,
+      transition: null,
+      el: null,
+      anchor: null,
+      target: null,
+      targetStart: null,
+      targetAnchor: null,
+      staticCount: 0,
+      shapeFlag,
+      patchFlag,
+      dynamicProps,
+      dynamicChildren: null,
+      appContext: null,
+      ctx: currentRenderingInstance
+    };
+    if (needFullChildrenNormalization) {
+      normalizeChildren(vnode, children);
+      if (shapeFlag & 128) {
+        type.normalize(vnode);
+      }
+    } else if (children) {
+      vnode.shapeFlag |= isString(children) ? 8 : 16;
+    }
+    if (!!(process.env.NODE_ENV !== "production") && vnode.key !== vnode.key) {
+      warn$1(`VNode created with invalid key (NaN). VNode type:`, vnode.type);
+    }
+    if (// avoid a block node from tracking itself
+    !isBlockNode &&
+    // has current parent block
+    currentBlock && (
+    // presence of a patch flag indicates this node needs patching on updates.
+    // component nodes also should always be patched, because even if the
+    // component doesn't need to update, it needs to persist the instance on to
+    // the next vnode so that it can be properly unmounted later.
+    vnode.patchFlag > 0 || shapeFlag & 6) &&
+    // the EVENTS flag is only for hydration and if it is the only flag, the
+    // vnode should not be considered dynamic due to handler caching.
+    vnode.patchFlag !== 32) {
+      currentBlock.push(vnode);
+    }
+    return vnode;
+  }
+  const createVNode = !!(process.env.NODE_ENV !== "production") ? createVNodeWithArgsTransform : _createVNode;
+  function _createVNode(type) {
+    let props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    let children = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+    let patchFlag = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+    let dynamicProps = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
+    let isBlockNode = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;
+    if (!type || type === NULL_DYNAMIC_COMPONENT) {
+      if (!!(process.env.NODE_ENV !== "production") && !type) {
+        warn$1(`Invalid vnode type when creating vnode: ${type}.`);
+      }
+      type = Comment;
+    }
+    if (isVNode(type)) {
+      const cloned = cloneVNode(type, props, true
+      /* mergeRef: true */);
+
+      if (children) {
+        normalizeChildren(cloned, children);
+      }
+      if (!isBlockNode && currentBlock) {
+        if (cloned.shapeFlag & 6) {
+          currentBlock[currentBlock.indexOf(type)] = cloned;
+        } else {
+          currentBlock.push(cloned);
+        }
+      }
+      cloned.patchFlag = -2;
+      return cloned;
+    }
+    if (isClassComponent(type)) {
+      type = type.__vccOpts;
+    }
+    if (props) {
+      props = guardReactiveProps(props);
+      let {
+        class: klass,
+        style
+      } = props;
+      if (klass && !isString(klass)) {
+        props.class = normalizeClass(klass);
+      }
+      if (isObject(style)) {
+        if (isProxy(style) && !isArray(style)) {
+          style = extend({}, style);
+        }
+        props.style = normalizeStyle(style);
+      }
+    }
+    const shapeFlag = isString(type) ? 1 : isSuspense(type) ? 128 : isTeleport(type) ? 64 : isObject(type) ? 4 : isFunction$2(type) ? 2 : 0;
+    if (!!(process.env.NODE_ENV !== "production") && shapeFlag & 4 && isProxy(type)) {
+      type = toRaw(type);
+      warn$1(`Vue received a Component that was made a reactive object. This can lead to unnecessary performance overhead and should be avoided by marking the component with \`markRaw\` or using \`shallowRef\` instead of \`ref\`.`, `
+Component that was made reactive: `, type);
+    }
+    return createBaseVNode(type, props, children, patchFlag, dynamicProps, shapeFlag, isBlockNode, true);
+  }
+  function guardReactiveProps(props) {
+    if (!props) return null;
+    return isProxy(props) || isInternalObject(props) ? extend({}, props) : props;
+  }
+  function cloneVNode(vnode, extraProps) {
+    let mergeRef = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    let cloneTransition = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+    const {
+      props,
+      ref,
+      patchFlag,
+      children,
+      transition
+    } = vnode;
+    const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;
+    const cloned = {
+      __v_isVNode: true,
+      __v_skip: true,
+      type: vnode.type,
+      props: mergedProps,
+      key: mergedProps && normalizeKey(mergedProps),
+      ref: extraProps && extraProps.ref ?
+      // #2078 in the case of <component :is="vnode" ref="extra"/>
+      // if the vnode itself already has a ref, cloneVNode will need to merge
+      // the refs so the single vnode can be set on multiple refs
+      mergeRef && ref ? isArray(ref) ? ref.concat(normalizeRef(extraProps)) : [ref, normalizeRef(extraProps)] : normalizeRef(extraProps) : ref,
+      scopeId: vnode.scopeId,
+      slotScopeIds: vnode.slotScopeIds,
+      children: !!(process.env.NODE_ENV !== "production") && patchFlag === -1 && isArray(children) ? children.map(deepCloneVNode) : children,
+      target: vnode.target,
+      targetStart: vnode.targetStart,
+      targetAnchor: vnode.targetAnchor,
+      staticCount: vnode.staticCount,
+      shapeFlag: vnode.shapeFlag,
+      // if the vnode is cloned with extra props, we can no longer assume its
+      // existing patch flag to be reliable and need to add the FULL_PROPS flag.
+      // note: preserve flag for fragments since they use the flag for children
+      // fast paths only.
+      patchFlag: extraProps && vnode.type !== Fragment ? patchFlag === -1 ? 16 : patchFlag | 16 : patchFlag,
+      dynamicProps: vnode.dynamicProps,
+      dynamicChildren: vnode.dynamicChildren,
+      appContext: vnode.appContext,
+      dirs: vnode.dirs,
+      transition,
+      // These should technically only be non-null on mounted VNodes. However,
+      // they *should* be copied for kept-alive vnodes. So we just always copy
+      // them since them being non-null during a mount doesn't affect the logic as
+      // they will simply be overwritten.
+      component: vnode.component,
+      suspense: vnode.suspense,
+      ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),
+      ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),
+      el: vnode.el,
+      anchor: vnode.anchor,
+      ctx: vnode.ctx,
+      ce: vnode.ce
+    };
+    if (transition && cloneTransition) {
+      setTransitionHooks(cloned, transition.clone(cloned));
+    }
+    return cloned;
+  }
+  function deepCloneVNode(vnode) {
+    const cloned = cloneVNode(vnode);
+    if (isArray(vnode.children)) {
+      cloned.children = vnode.children.map(deepCloneVNode);
+    }
+    return cloned;
+  }
+  function createTextVNode() {
+    let text = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : " ";
+    let flag = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    return createVNode(Text$1, null, text, flag);
+  }
+  function normalizeChildren(vnode, children) {
+    let type = 0;
+    const {
+      shapeFlag
+    } = vnode;
+    if (children == null) {
+      children = null;
+    } else if (isArray(children)) {
+      type = 16;
+    } else if (typeof children === "object") {
+      if (shapeFlag & (1 | 64)) {
+        const slot = children.default;
+        if (slot) {
+          slot._c && (slot._d = false);
+          normalizeChildren(vnode, slot());
+          slot._c && (slot._d = true);
+        }
+        return;
+      } else {
+        type = 32;
+        const slotFlag = children._;
+        if (!slotFlag && !isInternalObject(children)) {
+          children._ctx = currentRenderingInstance;
+        } else if (slotFlag === 3 && currentRenderingInstance) {
+          if (currentRenderingInstance.slots._ === 1) {
+            children._ = 1;
+          } else {
+            children._ = 2;
+            vnode.patchFlag |= 1024;
+          }
+        }
+      }
+    } else if (isFunction$2(children)) {
+      children = {
+        default: children,
+        _ctx: currentRenderingInstance
+      };
+      type = 32;
+    } else {
+      children = String(children);
+      if (shapeFlag & 64) {
+        type = 16;
+        children = [createTextVNode(children)];
+      } else {
+        type = 8;
+      }
+    }
+    vnode.children = children;
+    vnode.shapeFlag |= type;
+  }
+  function mergeProps() {
+    const ret = {};
+    for (let i = 0; i < arguments.length; i++) {
+      const toMerge = i < 0 || arguments.length <= i ? undefined : arguments[i];
+      for (const key in toMerge) {
+        if (key === "class") {
+          if (ret.class !== toMerge.class) {
+            ret.class = normalizeClass([ret.class, toMerge.class]);
+          }
+        } else if (key === "style") {
+          ret.style = normalizeStyle([ret.style, toMerge.style]);
+        } else if (isOn(key)) {
+          const existing = ret[key];
+          const incoming = toMerge[key];
+          if (incoming && existing !== incoming && !(isArray(existing) && existing.includes(incoming))) {
+            ret[key] = existing ? [].concat(existing, incoming) : incoming;
+          }
+        } else if (key !== "") {
+          ret[key] = toMerge[key];
+        }
+      }
+    }
+    return ret;
+  }
+  let currentInstance = null;
+  const getCurrentInstance = () => currentInstance || currentRenderingInstance;
+  let internalSetCurrentInstance;
+  {
+    const g = getGlobalThis();
+    const registerGlobalSetter = (key, setter) => {
+      let setters;
+      if (!(setters = g[key])) setters = g[key] = [];
+      setters.push(setter);
+      return v => {
+        if (setters.length > 1) setters.forEach(set => set(v));else setters[0](v);
+      };
+    };
+    internalSetCurrentInstance = registerGlobalSetter(`__VUE_INSTANCE_SETTERS__`, v => currentInstance = v);
+    registerGlobalSetter(`__VUE_SSR_SETTERS__`, v => isInSSRComponentSetup = v);
+  }
+  const setCurrentInstance = instance => {
+    const prev = currentInstance;
+    internalSetCurrentInstance(instance);
+    instance.scope.on();
+    return () => {
+      instance.scope.off();
+      internalSetCurrentInstance(prev);
+    };
+  };
+  function isStatefulComponent(instance) {
+    return instance.vnode.shapeFlag & 4;
+  }
+  let isInSSRComponentSetup = false;
+  const attrsProxyHandlers = !!(process.env.NODE_ENV !== "production") ? {
+    get(target, key) {
+      track(target, "get", "");
+      return target[key];
+    },
+    set() {
+      warn$1(`setupContext.attrs is readonly.`);
+      return false;
+    },
+    deleteProperty() {
+      warn$1(`setupContext.attrs is readonly.`);
+      return false;
+    }
+  } : {
+    get(target, key) {
+      track(target, "get", "");
+      return target[key];
+    }
+  };
+  function getSlotsProxy(instance) {
+    return new Proxy(instance.slots, {
+      get(target, key) {
+        track(instance, "get", "$slots");
+        return target[key];
+      }
+    });
+  }
+  function createSetupContext(instance) {
+    const expose = exposed => {
+      if (!!(process.env.NODE_ENV !== "production")) {
+        if (instance.exposed) {
+          warn$1(`expose() should be called only once per setup().`);
+        }
+        if (exposed != null) {
+          let exposedType = typeof exposed;
+          if (exposedType === "object") {
+            if (isArray(exposed)) {
+              exposedType = "array";
+            } else if (isRef(exposed)) {
+              exposedType = "ref";
+            }
+          }
+          if (exposedType !== "object") {
+            warn$1(`expose() should be passed a plain object, received ${exposedType}.`);
+          }
+        }
+      }
+      instance.exposed = exposed || {};
+    };
+    if (!!(process.env.NODE_ENV !== "production")) {
+      let attrsProxy;
+      let slotsProxy;
+      return Object.freeze({
+        get attrs() {
+          return attrsProxy || (attrsProxy = new Proxy(instance.attrs, attrsProxyHandlers));
+        },
+        get slots() {
+          return slotsProxy || (slotsProxy = getSlotsProxy(instance));
+        },
+        get emit() {
+          return function (event) {
+            for (var _len8 = arguments.length, args = new Array(_len8 > 1 ? _len8 - 1 : 0), _key8 = 1; _key8 < _len8; _key8++) {
+              args[_key8 - 1] = arguments[_key8];
+            }
+            return instance.emit(event, ...args);
+          };
+        },
+        expose
+      });
+    } else {
+      return {
+        attrs: new Proxy(instance.attrs, attrsProxyHandlers),
+        slots: instance.slots,
+        emit: instance.emit,
+        expose
+      };
+    }
+  }
+  function getComponentPublicInstance(instance) {
+    if (instance.exposed) {
+      return instance.exposeProxy || (instance.exposeProxy = new Proxy(proxyRefs(markRaw(instance.exposed)), {
+        get(target, key) {
+          if (key in target) {
+            return target[key];
+          } else if (key in publicPropertiesMap) {
+            return publicPropertiesMap[key](instance);
+          }
+        },
+        has(target, key) {
+          return key in target || key in publicPropertiesMap;
+        }
+      }));
+    } else {
+      return instance.proxy;
+    }
+  }
+  const classifyRE = /(?:^|[-_])(\w)/g;
+  const classify = str => str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, "");
+  function getComponentName(Component) {
+    let includeInferred = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    return isFunction$2(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;
+  }
+  function formatComponentName(instance, Component) {
+    let isRoot = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    let name = getComponentName(Component);
+    if (!name && Component.__file) {
+      const match = Component.__file.match(/([^/\\]+)\.\w+$/);
+      if (match) {
+        name = match[1];
+      }
+    }
+    if (!name && instance && instance.parent) {
+      const inferFromRegistry = registry => {
+        for (const key in registry) {
+          if (registry[key] === Component) {
+            return key;
+          }
+        }
+      };
+      name = inferFromRegistry(instance.components || instance.parent.type.components) || inferFromRegistry(instance.appContext.components);
+    }
+    return name ? classify(name) : isRoot ? `App` : `Anonymous`;
+  }
+  function isClassComponent(value) {
+    return isFunction$2(value) && "__vccOpts" in value;
+  }
+  const computed = (getterOrOptions, debugOptions) => {
+    const c = computed$1(getterOrOptions, debugOptions, isInSSRComponentSetup);
+    if (!!(process.env.NODE_ENV !== "production")) {
+      const i = getCurrentInstance();
+      if (i && i.appContext.config.warnRecursiveComputed) {
+        c._warnRecursive = true;
+      }
+    }
+    return c;
+  };
+  function initCustomFormatter() {
+    if (!!!(process.env.NODE_ENV !== "production") || typeof window === "undefined") {
+      return;
+    }
+    const vueStyle = {
+      style: "color:#3ba776"
+    };
+    const numberStyle = {
+      style: "color:#1677ff"
+    };
+    const stringStyle = {
+      style: "color:#f5222d"
+    };
+    const keywordStyle = {
+      style: "color:#eb2f96"
+    };
+    const formatter = {
+      __vue_custom_formatter: true,
+      header(obj) {
+        if (!isObject(obj)) {
+          return null;
+        }
+        if (obj.__isVue) {
+          return ["div", vueStyle, `VueInstance`];
+        } else if (isRef(obj)) {
+          return ["div", {}, ["span", vueStyle, genRefFlag(obj)], "<",
+          // avoid debugger accessing value affecting behavior
+          formatValue("_value" in obj ? obj._value : obj), `>`];
+        } else if (isReactive(obj)) {
+          return ["div", {}, ["span", vueStyle, isShallow(obj) ? "ShallowReactive" : "Reactive"], "<", formatValue(obj), `>${isReadonly(obj) ? ` (readonly)` : ``}`];
+        } else if (isReadonly(obj)) {
+          return ["div", {}, ["span", vueStyle, isShallow(obj) ? "ShallowReadonly" : "Readonly"], "<", formatValue(obj), ">"];
+        }
+        return null;
+      },
+      hasBody(obj) {
+        return obj && obj.__isVue;
+      },
+      body(obj) {
+        if (obj && obj.__isVue) {
+          return ["div", {}, ...formatInstance(obj.$)];
+        }
+      }
+    };
+    function formatInstance(instance) {
+      const blocks = [];
+      if (instance.type.props && instance.props) {
+        blocks.push(createInstanceBlock("props", toRaw(instance.props)));
+      }
+      if (instance.setupState !== EMPTY_OBJ) {
+        blocks.push(createInstanceBlock("setup", instance.setupState));
+      }
+      if (instance.data !== EMPTY_OBJ) {
+        blocks.push(createInstanceBlock("data", toRaw(instance.data)));
+      }
+      const computed = extractKeys(instance, "computed");
+      if (computed) {
+        blocks.push(createInstanceBlock("computed", computed));
+      }
+      const injected = extractKeys(instance, "inject");
+      if (injected) {
+        blocks.push(createInstanceBlock("injected", injected));
+      }
+      blocks.push(["div", {}, ["span", {
+        style: keywordStyle.style + ";opacity:0.66"
+      }, "$ (internal): "], ["object", {
+        object: instance
+      }]]);
+      return blocks;
+    }
+    function createInstanceBlock(type, target) {
+      target = extend({}, target);
+      if (!Object.keys(target).length) {
+        return ["span", {}];
+      }
+      return ["div", {
+        style: "line-height:1.25em;margin-bottom:0.6em"
+      }, ["div", {
+        style: "color:#476582"
+      }, type], ["div", {
+        style: "padding-left:1.25em"
+      }, ...Object.keys(target).map(key => {
+        return ["div", {}, ["span", keywordStyle, key + ": "], formatValue(target[key], false)];
+      })]];
+    }
+    function formatValue(v) {
+      let asRaw = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      if (typeof v === "number") {
+        return ["span", numberStyle, v];
+      } else if (typeof v === "string") {
+        return ["span", stringStyle, JSON.stringify(v)];
+      } else if (typeof v === "boolean") {
+        return ["span", keywordStyle, v];
+      } else if (isObject(v)) {
+        return ["object", {
+          object: asRaw ? toRaw(v) : v
+        }];
+      } else {
+        return ["span", stringStyle, String(v)];
+      }
+    }
+    function extractKeys(instance, type) {
+      const Comp = instance.type;
+      if (isFunction$2(Comp)) {
+        return;
+      }
+      const extracted = {};
+      for (const key in instance.ctx) {
+        if (isKeyOfType(Comp, key, type)) {
+          extracted[key] = instance.ctx[key];
+        }
+      }
+      return extracted;
+    }
+    function isKeyOfType(Comp, key, type) {
+      const opts = Comp[type];
+      if (isArray(opts) && opts.includes(key) || isObject(opts) && key in opts) {
+        return true;
+      }
+      if (Comp.extends && isKeyOfType(Comp.extends, key, type)) {
+        return true;
+      }
+      if (Comp.mixins && Comp.mixins.some(m => isKeyOfType(m, key, type))) {
+        return true;
+      }
+    }
+    function genRefFlag(v) {
+      if (isShallow(v)) {
+        return `ShallowRef`;
+      }
+      if (v.effect) {
+        return `ComputedRef`;
+      }
+      return `Ref`;
+    }
+    if (window.devtoolsFormatters) {
+      window.devtoolsFormatters.push(formatter);
+    } else {
+      window.devtoolsFormatters = [formatter];
+    }
+  }
+  !!(process.env.NODE_ENV !== "production") ? warn$1 : NOOP;
+  !!(process.env.NODE_ENV !== "production") || true ? devtools$1 : void 0;
+  !!(process.env.NODE_ENV !== "production") || true ? setDevtoolsHook$1 : NOOP;
+
+  /**
+  * vue v3.5.0
+  * (c) 2018-present Yuxi (Evan) You and Vue contributors
+  * @license MIT
+  **/
+  function initDev() {
+    {
+      initCustomFormatter();
+    }
+  }
+  if (!!(process.env.NODE_ENV !== "production")) {
+    initDev();
+  }
+
+  const isFunction = value => "function" == typeof value;
+  var isFunction$1 = isFunction;
+
+  function flattenVNodes(vnodes) {
+      return vnodes.flatMap(vnode => (Array.isArray(vnode.children) ? flattenVNodes(vnode.children) : vnode));
+  }
+  function isEventProp(key, props) {
+      return key.startsWith('on') && isFunction$1(props[key]);
+  }
+  function createCustomLayout(children) {
+      const componentMap = {
+          Group: VTable__namespace.CustomLayout.Group,
+          Image: VTable__namespace.CustomLayout.Image,
+          Text: VTable__namespace.CustomLayout.Text,
+          Tag: VTable__namespace.CustomLayout.Tag,
+          Radio: VTable__namespace.CustomLayout.Radio,
+          CheckBox: VTable__namespace.CustomLayout.CheckBox
+      };
+      function createComponent(child) {
+          if (!child) {
+              return null;
+          }
+          const { type, props, children: childChildren } = child;
+          const componentName = type?.name || type;
+          const ComponentClass = componentMap[componentName];
+          if (!ComponentClass) {
+              return null;
+          }
+          const component = new ComponentClass({ ...props });
+          bindComponentEvents(component, props);
+          const subChildren = resolveChildren(childChildren);
+          subChildren.forEach((subChild) => {
+              const subComponent = createComponent(subChild);
+              if (subComponent) {
+                  component.add(subComponent);
+              }
+              else if (subChild.type === Symbol.for('v-fgt')) {
+                  subChild.children.forEach((nestedChild) => {
+                      const nestedComponent = createComponent(nestedChild);
+                      if (nestedComponent) {
+                          component.add(nestedComponent);
+                      }
+                  });
+              }
+          });
+          return component;
+      }
+      function resolveChildren(childChildren) {
+          return childChildren?.default?.() || childChildren || [];
+      }
+      function bindComponentEvents(component, props) {
+          Object.keys(props).forEach(key => {
+              if (isEventProp(key, props)) {
+                  const eventName = key.slice(2).toLowerCase();
+                  component.addEventListener(eventName, props[key]);
+              }
+          });
+      }
+      return { rootComponent: createComponent(children) };
+  }
+
+  const EVENT_TYPE = {
+      ...VTable.ListTable.EVENT_TYPE,
+      ...VTable.PivotTable.EVENT_TYPE,
+      ...VTable.PivotChart.EVENT_TYPE
+  };
+  const TABLE_EVENTS = {
+      onClickCell: EVENT_TYPE.CLICK_CELL,
+      onDblClickCell: EVENT_TYPE.DBLCLICK_CELL,
+      onMouseDownCell: EVENT_TYPE.MOUSEDOWN_CELL,
+      onMouseUpCell: EVENT_TYPE.MOUSEUP_CELL,
+      onSelectedCell: EVENT_TYPE.SELECTED_CELL,
+      onKeyDown: EVENT_TYPE.KEYDOWN,
+      onMouseEnterTable: EVENT_TYPE.MOUSEENTER_TABLE,
+      onMouseLeaveTable: EVENT_TYPE.MOUSELEAVE_TABLE,
+      onMouseDownTable: EVENT_TYPE.MOUSEDOWN_TABLE,
+      onMouseMoveCell: EVENT_TYPE.MOUSEMOVE_CELL,
+      onMouseEnterCell: EVENT_TYPE.MOUSEENTER_CELL,
+      onMouseLeaveCell: EVENT_TYPE.MOUSELEAVE_CELL,
+      onContextMenuCell: EVENT_TYPE.CONTEXTMENU_CELL,
+      onResizeColumn: EVENT_TYPE.RESIZE_COLUMN,
+      onResizeColumnEnd: EVENT_TYPE.RESIZE_COLUMN_END,
+      onChangeHeaderPosition: EVENT_TYPE.CHANGE_HEADER_POSITION,
+      onSortClick: EVENT_TYPE.SORT_CLICK,
+      onFreezeClick: EVENT_TYPE.FREEZE_CLICK,
+      onScroll: EVENT_TYPE.SCROLL,
+      onDropdownMenuClick: EVENT_TYPE.DROPDOWN_MENU_CLICK,
+      onMouseOverChartSymbol: EVENT_TYPE.MOUSEOVER_CHART_SYMBOL,
+      onDragSelectEnd: EVENT_TYPE.DRAG_SELECT_END,
+      onDropdownIconClick: EVENT_TYPE.DROPDOWN_ICON_CLICK,
+      onDropdownMenuClear: EVENT_TYPE.DROPDOWN_MENU_CLEAR,
+      onTreeHierarchyStateChange: EVENT_TYPE.TREE_HIERARCHY_STATE_CHANGE,
+      onShowMenu: EVENT_TYPE.SHOW_MENU,
+      onHideMenu: EVENT_TYPE.HIDE_MENU,
+      onIconClick: EVENT_TYPE.ICON_CLICK,
+      onLegendItemClick: EVENT_TYPE.LEGEND_ITEM_CLICK,
+      onLegendItemHover: EVENT_TYPE.LEGEND_ITEM_HOVER,
+      onLegendItemUnHover: EVENT_TYPE.LEGEND_ITEM_UNHOVER,
+      onLegendChange: EVENT_TYPE.LEGEND_CHANGE,
+      onMouseEnterAxis: EVENT_TYPE.MOUSEENTER_AXIS,
+      onMouseLeaveAxis: EVENT_TYPE.MOUSELEAVE_AXIS,
+      onCheckboxStateChange: EVENT_TYPE.CHECKBOX_STATE_CHANGE,
+      onRadioStateChange: EVENT_TYPE.RADIO_STATE_CHANGE,
+      onAfterRender: EVENT_TYPE.AFTER_RENDER,
+      onInitialized: EVENT_TYPE.INITIALIZED,
+      onPivotSortClick: EVENT_TYPE.PIVOT_SORT_CLICK,
+      onDrillMenuClick: EVENT_TYPE.DRILLMENU_CLICK,
+      onVChartEventType: EVENT_TYPE.VCHART_EVENT_TYPE,
+      onChangCellValue: EVENT_TYPE.CHANGE_CELL_VALUE,
+      onMousedownFillHandle: EVENT_TYPE.MOUSEDOWN_FILL_HANDLE,
+      onDragFillHandleEnd: EVENT_TYPE.DRAG_FILL_HANDLE_END,
+      onDblclickFillHandle: EVENT_TYPE.DBLCLICK_FILL_HANDLE,
+      onScrollVerticalEnd: EVENT_TYPE.SCROLL_VERTICAL_END,
+      onScrollHorizontalEnd: EVENT_TYPE.SCROLL_HORIZONTAL_END
+  };
+  const TABLE_EVENTS_KEYS = Object.keys(TABLE_EVENTS);
+
+  var _sfc_main$3 = defineComponent({
+      __name: 'base-table',
+      props: {
+          type: { type: String, required: false },
+          options: { type: null, required: false },
+          records: { type: Array, required: false },
+          width: { type: [Number, String], required: false, default: '100%' },
+          height: { type: [Number, String], required: false, default: '100%' },
+          onReady: { type: Function, required: false },
+          onError: { type: Function, required: false },
+          onClickCell: { type: null, required: false },
+          onDblClickCell: { type: null, required: false },
+          onMouseDownCell: { type: null, required: false },
+          onMouseUpCell: { type: null, required: false },
+          onSelectedCell: { type: null, required: false },
+          onKeyDown: { type: null, required: false },
+          onMouseEnterTable: { type: null, required: false },
+          onMouseLeaveTable: { type: null, required: false },
+          onMouseDownTable: { type: null, required: false },
+          onMouseMoveCell: { type: null, required: false },
+          onMouseEnterCell: { type: null, required: false },
+          onMouseLeaveCell: { type: null, required: false },
+          onContextMenuCell: { type: null, required: false },
+          onResizeColumn: { type: null, required: false },
+          onResizeColumnEnd: { type: null, required: false },
+          onChangeHeaderPosition: { type: null, required: false },
+          onSortClick: { type: null, required: false },
+          onFreezeClick: { type: null, required: false },
+          onScroll: { type: null, required: false },
+          onDropdownMenuClick: { type: null, required: false },
+          onMouseOverChartSymbol: { type: null, required: false },
+          onDragSelectEnd: { type: null, required: false },
+          onDropdownIconClick: { type: null, required: false },
+          onDropdownMenuClear: { type: null, required: false },
+          onTreeHierarchyStateChange: { type: null, required: false },
+          onShowMenu: { type: null, required: false },
+          onHideMenu: { type: null, required: false },
+          onIconClick: { type: null, required: false },
+          onLegendItemClick: { type: null, required: false },
+          onLegendItemHover: { type: null, required: false },
+          onLegendItemUnHover: { type: null, required: false },
+          onLegendChange: { type: null, required: false },
+          onMouseEnterAxis: { type: null, required: false },
+          onMouseLeaveAxis: { type: null, required: false },
+          onCheckboxStateChange: { type: null, required: false },
+          onRadioStateChange: { type: null, required: false },
+          onAfterRender: { type: null, required: false },
+          onInitialized: { type: null, required: false },
+          onPivotSortClick: { type: null, required: false },
+          onDrillMenuClick: { type: null, required: false },
+          onVChartEventType: { type: null, required: false },
+          onChangCellValue: { type: null, required: false },
+          onMousedownFillHandle: { type: null, required: false },
+          onDragFillHandleEnd: { type: null, required: false },
+          onDblclickFillHandle: { type: null, required: false },
+          onScrollVerticalEnd: { type: null, required: false },
+          onScrollHorizontalEnd: { type: null, required: false }
+      },
+      emits: TABLE_EVENTS_KEYS,
+      setup(__props, { expose: __expose, emit: __emit }) {
+          const props = __props;
+          const vTableContainer = ref(null);
+          const vTableInstance = shallowRef(null);
+          __expose({ vTableInstance });
+          const containerWidth = computed(() => (typeof props.width === 'number' ? `${props.width}px` : props.width));
+          const containerHeight = computed(() => (typeof props.height === 'number' ? `${props.height}px` : props.height));
+          const emit = __emit;
+          const bindEvents = (instance) => {
+              TABLE_EVENTS_KEYS.forEach(eventKey => {
+                  const vueEventHandler = (event) => {
+                      emit(eventKey, event);
+                  };
+                  instance.on(TABLE_EVENTS[eventKey], vueEventHandler);
+              });
+          };
+          const createVTable = () => {
+              if (!vTableContainer.value)
+                  return;
+              if (vTableInstance.value) {
+                  vTableInstance.value.release();
+              }
+              const getRecords = () => {
+                  return props.records !== undefined && props.records !== null && props.records.length > 0 ? props.records : props.options.records;
+              };
+              const createTableInstance = (Type, options) => {
+                  vTableInstance.value = new Type(vTableContainer.value, options);
+              };
+              try {
+                  switch (props.type) {
+                      case 'list':
+                          createTableInstance(VTable.ListTable, {
+                              ...props.options,
+                              records: getRecords()
+                          });
+                          break;
+                      case 'pivot':
+                          createTableInstance(VTable.PivotTable, {
+                              ...props.options,
+                              records: getRecords()
+                          });
+                          break;
+                      case 'chart':
+                          createTableInstance(VTable.PivotChart, {
+                              ...props.options,
+                              records: getRecords()
+                          });
+                          break;
+                  }
+                  bindEvents(vTableInstance.value);
+                  props.onReady?.(vTableInstance.value, true);
+              }
+              catch (err) {
+              }
+          };
+          const updateVTable = (newOptions) => {
+              if (!vTableInstance.value)
+                  return;
+              try {
+                  switch (props.type) {
+                      case 'list':
+                          if (vTableInstance.value instanceof VTable.ListTable) {
+                              vTableInstance.value.updateOption(newOptions);
+                          }
+                          break;
+                      case 'pivot':
+                          if (vTableInstance.value instanceof VTable.PivotTable) {
+                              vTableInstance.value.updateOption(newOptions);
+                          }
+                          break;
+                      case 'chart':
+                          if (vTableInstance.value instanceof VTable.PivotChart) {
+                              vTableInstance.value.updateOption(newOptions);
+                          }
+                          break;
+                  }
+              }
+              catch (err) {
+                  props.onError?.(err);
+              }
+          };
+          onMounted(createVTable);
+          onBeforeUnmount(() => vTableInstance.value?.release());
+          watch(() => props.options, (newOptions) => {
+              if (vTableInstance.value) {
+                  updateVTable(newOptions);
+              }
+              else {
+                  createVTable();
+              }
+          }, { deep: true });
+          watch(() => props.records, (newRecords, oldRecords) => {
+              if (vTableInstance.value) {
+                  updateVTable({ ...props.options, records: newRecords });
+              }
+              else {
+                  createVTable();
+              }
+          }, { deep: true });
+          return (_ctx, _cache) => {
+              return (openBlock(), createElementBlock("div", {
+                  ref_key: "vTableContainer",
+                  ref: vTableContainer,
+                  style: normalizeStyle([{ width: containerWidth.value, height: containerHeight.value }, { "position": "relative" }])
+              }, null, 4));
+          };
+      }
+  });
+
+  var _sfc_main$2 = defineComponent({
+      __name: 'list-table',
+      props: {
+          options: { type: Object, required: true },
+          records: { type: Array, required: false },
+          width: { type: [String, Number], required: false },
+          height: { type: [String, Number], required: false }
+      },
+      setup(__props, { expose: __expose }) {
+          const props = __props;
+          const baseTableRef = ref(null);
+          const slots = useSlots();
+          const computedOptions = computed(() => {
+              const flattenedSlots = flattenVNodes(slots.default?.() || []);
+              const slotOptions = extractSlotOptions(flattenedSlots);
+              return {
+                  ...props.options,
+                  columns: slotOptions.columns.length ? slotOptions.columns : props.options.columns,
+                  tooltip: slotOptions.tooltip || props.options.tooltip,
+                  menu: slotOptions.menu || props.options.menu,
+              };
+          });
+          function extractSlotOptions(vnodes) {
+              const options = {
+                  columns: [],
+                  tooltip: {},
+                  menu: {},
+              };
+              const typeMapping = {
+                  ListColumn: 'columns',
+                  Tooltip: 'tooltip',
+                  Menu: 'menu',
+              };
+              vnodes.forEach(vnode => {
+                  const typeName = vnode.type?.name || vnode.type?.__name;
+                  const optionKey = typeMapping[typeName];
+                  if (optionKey) {
+                      if (optionKey === 'columns' && vnode.children) {
+                          vnode.props.customLayout = createCustomLayoutHandler(vnode.children);
+                      }
+                      if (Array.isArray(options[optionKey])) {
+                          options[optionKey].push(vnode.props);
+                      }
+                      else {
+                          options[optionKey] = vnode.props;
+                      }
+                  }
+              });
+              return options;
+          }
+          function createCustomLayoutHandler(children) {
+              return (args) => {
+                  const { table, row, col, rect } = args;
+                  const record = table.getCellOriginRecord(col, row);
+                  const { height, width } = rect ?? table.getCellRect(col, row);
+                  const rootContainer = children.customLayout({ table, row, col, rect, record, height, width })[0];
+                  const { rootComponent } = createCustomLayout(rootContainer);
+                  return {
+                      rootContainer: rootComponent,
+                      renderDefault: false,
+                  };
+              };
+          }
+          __expose({
+              vTableInstance: computed(() => baseTableRef.value?.vTableInstance || null),
+          });
+          return (_ctx, _cache) => {
+              return (openBlock(), createElementBlock(Fragment, null, [
+                  createVNode(_sfc_main$3, mergeProps({
+                      type: "list",
+                      options: computedOptions.value,
+                      records: _ctx.records,
+                      width: _ctx.width,
+                      height: _ctx.height,
+                      ref_key: "baseTableRef",
+                      ref: baseTableRef
+                  }, _ctx.$attrs), null, 16, ["options", "records", "width", "height"]),
+                  renderSlot(_ctx.$slots, "default")
+              ], 64));
+          };
+      }
+  });
+
+  var _sfc_main$1 = defineComponent({
+      __name: 'pivot-table',
+      props: {
+          options: { type: Object, required: true },
+          records: { type: Array, required: false },
+          width: { type: [String, Number], required: false },
+          height: { type: [String, Number], required: false }
+      },
+      setup(__props, { expose: __expose }) {
+          const props = __props;
+          const baseTableRef = shallowRef(null);
+          const slots = useSlots();
+          const computedOptions = computed(() => {
+              const flattenedSlots = flattenVNodes(slots.default?.() || []);
+              const options = {
+                  columns: [],
+                  columnHeaderTitle: [],
+                  rows: [],
+                  rowHeaderTitle: [],
+                  indicators: [],
+                  corner: Object,
+                  tooltip: Object,
+                  menu: Object,
+              };
+              const typeMapping = {
+                  'PivotColumnDimension': 'columns',
+                  'PivotColumnHeaderTitle': 'columnHeaderTitle',
+                  'PivotRowDimension': 'rows',
+                  'PivotRowHeaderTitle': 'rowHeaderTitle',
+                  'PivotCorner': 'corner',
+                  'PivotIndicator': 'indicators',
+                  'Tooltip': 'tooltip',
+                  'Menu': 'menu',
+              };
+              flattenedSlots.forEach(vnode => {
+                  const typeName = vnode.type?.name || vnode.type?.__name;
+                  const optionKey = typeMapping[typeName];
+                  if (optionKey) {
+                      if (Array.isArray(options[optionKey])) {
+                          options[optionKey].push(vnode.props);
+                      }
+                      else {
+                          options[optionKey] = vnode.props;
+                      }
+                  }
+              });
+              return {
+                  ...props.options,
+                  columns: options.columns.length ? options.columns : props.options.columns,
+                  columnHeaderTitle: options.columnHeaderTitle.length ? options.columnHeaderTitle : props.options.columnHeaderTitle,
+                  rows: options.rows.length ? options.rows : props.options.rows,
+                  rowHeaderTitle: options.rowHeaderTitle.length ? options.rowHeaderTitle : props.options.rowHeaderTitle,
+                  indicators: options.indicators.length ? options.indicators : props.options.indicators,
+                  corner: options.corner || props.options.corner,
+                  tooltip: options.tooltip || props.options.tooltip,
+                  menu: options.menu || props.options.menu,
+              };
+          });
+          __expose({ vTableInstance: computed(() => baseTableRef.value?.vTableInstance || null) });
+          return (_ctx, _cache) => {
+              return (openBlock(), createElementBlock(Fragment, null, [
+                  createVNode(_sfc_main$3, mergeProps({
+                      type: "pivot",
+                      options: computedOptions.value,
+                      records: _ctx.records,
+                      width: _ctx.width,
+                      height: _ctx.height,
+                      ref_key: "baseTableRef",
+                      ref: baseTableRef
+                  }, _ctx.$attrs), null, 16, ["options", "records", "width", "height"]),
+                  renderSlot(_ctx.$slots, "default")
+              ], 64));
+          };
+      }
+  });
+
+  var _sfc_main = defineComponent({
+      __name: 'pivot-chart',
+      props: {
+          options: { type: Object, required: true },
+          records: { type: Array, required: false },
+          width: { type: [String, Number], required: false },
+          height: { type: [String, Number], required: false }
+      },
+      setup(__props, { expose: __expose }) {
+          const props = __props;
+          const baseTableRef = shallowRef(null);
+          const slots = useSlots();
+          const computedOptions = computed(() => {
+              const flattenedSlots = flattenVNodes(slots.default?.() || []);
+              const options = {
+                  columns: [],
+                  columnHeaderTitle: [],
+                  rows: [],
+                  rowHeaderTitle: [],
+                  indicators: [],
+                  corner: Object,
+                  tooltip: Object,
+                  menu: Object,
+              };
+              const typeMapping = {
+                  'PivotColumnDimension': 'columns',
+                  'PivotColumnHeaderTitle': 'columnHeaderTitle',
+                  'PivotRowDimension': 'rows',
+                  'PivotRowHeaderTitle': 'rowHeaderTitle',
+                  'PivotCorner': 'corner',
+                  'PivotIndicator': 'indicators',
+                  'Tooltip': 'tooltip',
+                  'Menu': 'menu',
+              };
+              flattenedSlots.forEach(vnode => {
+                  const typeName = vnode.type?.name || vnode.type?.__name;
+                  const optionKey = typeMapping[typeName];
+                  if (optionKey) {
+                      if (Array.isArray(options[optionKey])) {
+                          if (vnode.props.hasOwnProperty('objectHandler')) {
+                              options[optionKey].push(vnode.props.objectHandler);
+                          }
+                          else {
+                              options[optionKey].push(vnode.props);
+                          }
+                      }
+                      else {
+                          options[optionKey] = vnode.props;
+                      }
+                  }
+              });
+              return {
+                  ...props.options,
+                  columns: options.columns.length ? options.columns : props.options.columns,
+                  columnHeaderTitle: options.columnHeaderTitle.length ? options.columnHeaderTitle : props.options.columnHeaderTitle,
+                  rows: options.rows.length ? options.rows : props.options.rows,
+                  rowHeaderTitle: options.rowHeaderTitle.length ? options.rowHeaderTitle : props.options.rowHeaderTitle,
+                  indicators: options.indicators.length ? options.indicators : props.options.indicators,
+                  corner: options.corner || props.options.corner,
+                  tooltip: options.tooltip || props.options.tooltip,
+                  menu: options.menu || props.options.menu,
+              };
+          });
+          __expose({ vTableInstance: computed(() => baseTableRef.value?.vTableInstance || null) });
+          return (_ctx, _cache) => {
+              return (openBlock(), createElementBlock(Fragment, null, [
+                  createVNode(_sfc_main$3, mergeProps({
+                      type: "chart",
+                      options: computedOptions.value,
+                      records: _ctx.records,
+                      width: _ctx.width,
+                      height: _ctx.height,
+                      ref_key: "baseTableRef",
+                      ref: baseTableRef
+                  }, _ctx.$attrs), null, 16, ["options", "records", "width", "height"]),
+                  renderSlot(_ctx.$slots, "default")
+              ], 64));
+          };
+      }
+  });
+
+  const registerChartModule = (name, chart) => {
+      VTable__namespace.register.chartModule(name, chart);
+  };
+
+  function ListColumn(props) {
+      return null;
+  }
+
+  function PivotColumnDimension(props) {
+      return null;
+  }
+
+  function PivotRowDimension(props) {
+      return null;
+  }
+
+  function PivotColumnHeaderTitle(props) {
+      return null;
+  }
+
+  function PivotRowHeaderTitle(props) {
+      return null;
+  }
+
+  function PivotIndicator(props) {
+      return null;
+  }
+
+  function PivotCorner(props) {
+      return null;
+  }
+
+  function Menu(props) {
+      return null;
+  }
+
+  function Tooltip(props) {
+      return null;
+  }
+
+  function Group() {
+      return null;
+  }
+
+  function Image() {
+      return null;
+  }
+
+  function Text() {
+      return null;
+  }
+
+  function Tag(props) {
+      return null;
+  }
+
+  function Radio(props) {
+      return null;
+  }
+
+  function CheckBox(props) {
+      return null;
+  }
+
+  const version = "1.7.4";
+
+  exports.VTable = VTable__namespace;
+  exports.CheckBox = CheckBox;
+  exports.Group = Group;
+  exports.Image = Image;
+  exports.ListColumn = ListColumn;
+  exports.ListTable = _sfc_main$2;
+  exports.Menu = Menu;
+  exports.PivotChart = _sfc_main;
+  exports.PivotColumnDimension = PivotColumnDimension;
+  exports.PivotColumnHeaderTitle = PivotColumnHeaderTitle;
+  exports.PivotCorner = PivotCorner;
+  exports.PivotIndicator = PivotIndicator;
+  exports.PivotRowDimension = PivotRowDimension;
+  exports.PivotRowHeaderTitle = PivotRowHeaderTitle;
+  exports.PivotTable = _sfc_main$1;
+  exports.Radio = Radio;
+  exports.Tag = Tag;
+  exports.Text = Text;
+  exports.Tooltip = Tooltip;
+  exports.registerChartModule = registerChartModule;
+  exports.version = version;
+
+}));