@kitbag/router 0.0.1

package/dist/kitbag-router.umd.cjs

@@ -0,0 +1,4951 @@
+(function(global2, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2["@kitbag/router"] = {}));
+})(this, function(exports2) {
+  "use strict";var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+  function useParam(_param, _defaultValue) {
+    throw "not implemented";
+  }
+  function useParamRaw(_param, _defaultValue) {
+    throw "not implemented";
+  }
+  /**
+  * @vue/shared v3.4.23
+  * (c) 2018-present Yuxi (Evan) You and Vue contributors
+  * @license MIT
+  **/
+  /*! #__NO_SIDE_EFFECTS__ */
+  // @__NO_SIDE_EFFECTS__
+  function makeMap(str, expectsLowerCase) {
+    const set2 = new Set(str.split(","));
+    return expectsLowerCase ? (val) => set2.has(val.toLowerCase()) : (val) => set2.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 = (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(val)) && isFunction(val.then) && isFunction(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 camelizeRE = /-(\w)/g;
+  const camelize = cacheStringFunction((str) => {
+    return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
+  });
+  const capitalize = cacheStringFunction((str) => {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  });
+  const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
+  const def = (obj, key, value) => {
+    Object.defineProperty(obj, key, {
+      configurable: true,
+      enumerable: false,
+      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();
+  }
+  function normalizeProps(props) {
+    if (!props)
+      return null;
+    let { class: klass, style } = props;
+    if (klass && !isString(klass)) {
+      props.class = normalizeClass(klass);
+    }
+    if (style) {
+      props.style = normalizeStyle(style);
+    }
+    return props;
+  }
+  /**
+  * @vue/reactivity v3.4.23
+  * (c) 2018-present Yuxi (Evan) You and Vue contributors
+  * @license MIT
+  **/
+  function warn(msg, ...args) {
+    console.warn(`[Vue warn] ${msg}`, ...args);
+  }
+  let activeEffectScope;
+  function recordEffectScope(effect, scope = activeEffectScope) {
+    if (scope && scope.active) {
+      scope.effects.push(effect);
+    }
+  }
+  let activeEffect;
+  class ReactiveEffect {
+    constructor(fn, trigger2, scheduler, scope) {
+      this.fn = fn;
+      this.trigger = trigger2;
+      this.scheduler = scheduler;
+      this.active = true;
+      this.deps = [];
+      this._dirtyLevel = 4;
+      this._trackId = 0;
+      this._runnings = 0;
+      this._shouldSchedule = false;
+      this._depsLength = 0;
+      recordEffectScope(this, scope);
+    }
+    get dirty() {
+      if (this._dirtyLevel === 2 || this._dirtyLevel === 3) {
+        this._dirtyLevel = 1;
+        pauseTracking();
+        for (let i = 0; i < this._depsLength; i++) {
+          const dep = this.deps[i];
+          if (dep.computed) {
+            triggerComputed(dep.computed);
+            if (this._dirtyLevel >= 4) {
+              break;
+            }
+          }
+        }
+        if (this._dirtyLevel === 1) {
+          this._dirtyLevel = 0;
+        }
+        resetTracking();
+      }
+      return this._dirtyLevel >= 4;
+    }
+    set dirty(v) {
+      this._dirtyLevel = v ? 4 : 0;
+    }
+    run() {
+      this._dirtyLevel = 0;
+      if (!this.active) {
+        return this.fn();
+      }
+      let lastShouldTrack = shouldTrack;
+      let lastEffect = activeEffect;
+      try {
+        shouldTrack = true;
+        activeEffect = this;
+        this._runnings++;
+        preCleanupEffect(this);
+        return this.fn();
+      } finally {
+        postCleanupEffect(this);
+        this._runnings--;
+        activeEffect = lastEffect;
+        shouldTrack = lastShouldTrack;
+      }
+    }
+    stop() {
+      var _a;
+      if (this.active) {
+        preCleanupEffect(this);
+        postCleanupEffect(this);
+        (_a = this.onStop) == null ? void 0 : _a.call(this);
+        this.active = false;
+      }
+    }
+  }
+  function triggerComputed(computed2) {
+    return computed2.value;
+  }
+  function preCleanupEffect(effect2) {
+    effect2._trackId++;
+    effect2._depsLength = 0;
+  }
+  function postCleanupEffect(effect2) {
+    if (effect2.deps.length > effect2._depsLength) {
+      for (let i = effect2._depsLength; i < effect2.deps.length; i++) {
+        cleanupDepEffect(effect2.deps[i], effect2);
+      }
+      effect2.deps.length = effect2._depsLength;
+    }
+  }
+  function cleanupDepEffect(dep, effect2) {
+    const trackId = dep.get(effect2);
+    if (trackId !== void 0 && effect2._trackId !== trackId) {
+      dep.delete(effect2);
+      if (dep.size === 0) {
+        dep.cleanup();
+      }
+    }
+  }
+  let shouldTrack = true;
+  let pauseScheduleStack = 0;
+  const trackStack = [];
+  function pauseTracking() {
+    trackStack.push(shouldTrack);
+    shouldTrack = false;
+  }
+  function resetTracking() {
+    const last = trackStack.pop();
+    shouldTrack = last === void 0 ? true : last;
+  }
+  function pauseScheduling() {
+    pauseScheduleStack++;
+  }
+  function resetScheduling() {
+    pauseScheduleStack--;
+    while (!pauseScheduleStack && queueEffectSchedulers.length) {
+      queueEffectSchedulers.shift()();
+    }
+  }
+  function trackEffect(effect2, dep, debuggerEventExtraInfo) {
+    var _a;
+    if (dep.get(effect2) !== effect2._trackId) {
+      dep.set(effect2, effect2._trackId);
+      const oldDep = effect2.deps[effect2._depsLength];
+      if (oldDep !== dep) {
+        if (oldDep) {
+          cleanupDepEffect(oldDep, effect2);
+        }
+        effect2.deps[effect2._depsLength++] = dep;
+      } else {
+        effect2._depsLength++;
+      }
+      if (!!(process.env.NODE_ENV !== "production")) {
+        (_a = effect2.onTrack) == null ? void 0 : _a.call(effect2, extend({ effect: effect2 }, debuggerEventExtraInfo));
+      }
+    }
+  }
+  const queueEffectSchedulers = [];
+  function triggerEffects(dep, dirtyLevel, debuggerEventExtraInfo) {
+    var _a;
+    pauseScheduling();
+    for (const effect2 of dep.keys()) {
+      let tracking;
+      if (effect2._dirtyLevel < dirtyLevel && (tracking != null ? tracking : tracking = dep.get(effect2) === effect2._trackId)) {
+        effect2._shouldSchedule || (effect2._shouldSchedule = effect2._dirtyLevel === 0);
+        effect2._dirtyLevel = dirtyLevel;
+      }
+      if (effect2._shouldSchedule && (tracking != null ? tracking : tracking = dep.get(effect2) === effect2._trackId)) {
+        if (!!(process.env.NODE_ENV !== "production")) {
+          (_a = effect2.onTrigger) == null ? void 0 : _a.call(effect2, extend({ effect: effect2 }, debuggerEventExtraInfo));
+        }
+        effect2.trigger();
+        if ((!effect2._runnings || effect2.allowRecurse) && effect2._dirtyLevel !== 2) {
+          effect2._shouldSchedule = false;
+          if (effect2.scheduler) {
+            queueEffectSchedulers.push(effect2.scheduler);
+          }
+        }
+      }
+    }
+    resetScheduling();
+  }
+  const createDep = (cleanup, computed2) => {
+    const dep = /* @__PURE__ */ new Map();
+    dep.cleanup = cleanup;
+    dep.computed = computed2;
+    return dep;
+  };
+  const targetMap = /* @__PURE__ */ new WeakMap();
+  const ITERATE_KEY = Symbol(!!(process.env.NODE_ENV !== "production") ? "iterate" : "");
+  const MAP_KEY_ITERATE_KEY = Symbol(!!(process.env.NODE_ENV !== "production") ? "Map key iterate" : "");
+  function track(target, type, key) {
+    if (shouldTrack && activeEffect) {
+      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 = createDep(() => depsMap.delete(key)));
+      }
+      trackEffect(
+        activeEffect,
+        dep,
+        !!(process.env.NODE_ENV !== "production") ? {
+          target,
+          type,
+          key
+        } : void 0
+      );
+    }
+  }
+  function trigger(target, type, key, newValue, oldValue, oldTarget) {
+    const depsMap = targetMap.get(target);
+    if (!depsMap) {
+      return;
+    }
+    let deps = [];
+    if (type === "clear") {
+      deps = [...depsMap.values()];
+    } else if (key === "length" && isArray(target)) {
+      const newLength = Number(newValue);
+      depsMap.forEach((dep, key2) => {
+        if (key2 === "length" || !isSymbol(key2) && key2 >= newLength) {
+          deps.push(dep);
+        }
+      });
+    } else {
+      if (key !== void 0) {
+        deps.push(depsMap.get(key));
+      }
+      switch (type) {
+        case "add":
+          if (!isArray(target)) {
+            deps.push(depsMap.get(ITERATE_KEY));
+            if (isMap(target)) {
+              deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
+            }
+          } else if (isIntegerKey(key)) {
+            deps.push(depsMap.get("length"));
+          }
+          break;
+        case "delete":
+          if (!isArray(target)) {
+            deps.push(depsMap.get(ITERATE_KEY));
+            if (isMap(target)) {
+              deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
+            }
+          }
+          break;
+        case "set":
+          if (isMap(target)) {
+            deps.push(depsMap.get(ITERATE_KEY));
+          }
+          break;
+      }
+    }
+    pauseScheduling();
+    for (const dep of deps) {
+      if (dep) {
+        triggerEffects(
+          dep,
+          4,
+          !!(process.env.NODE_ENV !== "production") ? {
+            target,
+            type,
+            key,
+            newValue,
+            oldValue,
+            oldTarget
+          } : void 0
+        );
+      }
+    }
+    resetScheduling();
+  }
+  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)
+  );
+  const arrayInstrumentations = /* @__PURE__ */ createArrayInstrumentations();
+  function createArrayInstrumentations() {
+    const instrumentations = {};
+    ["includes", "indexOf", "lastIndexOf"].forEach((key) => {
+      instrumentations[key] = function(...args) {
+        const arr = toRaw(this);
+        for (let i = 0, l = this.length; i < l; i++) {
+          track(arr, "get", i + "");
+        }
+        const res = arr[key](...args);
+        if (res === -1 || res === false) {
+          return arr[key](...args.map(toRaw));
+        } else {
+          return res;
+        }
+      };
+    });
+    ["push", "pop", "shift", "unshift", "splice"].forEach((key) => {
+      instrumentations[key] = function(...args) {
+        pauseTracking();
+        pauseScheduling();
+        const res = toRaw(this)[key].apply(this, args);
+        resetScheduling();
+        resetTracking();
+        return res;
+      };
+    });
+    return instrumentations;
+  }
+  function hasOwnProperty(key) {
+    if (!isSymbol(key))
+      key = String(key);
+    const obj = toRaw(this);
+    track(obj, "has", key);
+    return obj.hasOwnProperty(key);
+  }
+  class BaseReactiveHandler {
+    constructor(_isReadonly = false, _isShallow = 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 reciever is a user proxy of the reactive proxy
+        Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) {
+          return target;
+        }
+        return;
+      }
+      const targetIsArray = isArray(target);
+      if (!isReadonly2) {
+        if (targetIsArray && hasOwn(arrayInstrumentations, key)) {
+          return Reflect.get(arrayInstrumentations, key, receiver);
+        }
+        if (key === "hasOwnProperty") {
+          return hasOwnProperty;
+        }
+      }
+      const res = Reflect.get(target, key, 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(isShallow2 = 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, 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(isShallow2 = 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, isReadonly2 = false, isShallow2 = 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, isReadonly2 = 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, isReadonly2 = false) {
+    target = target["__v_raw"];
+    !isReadonly2 && track(toRaw(target), "iterate", ITERATE_KEY);
+    return Reflect.get(target, "size", target);
+  }
+  function add(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) {
+    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(...args) {
+      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](...args);
+      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(...args) {
+      if (!!(process.env.NODE_ENV !== "production")) {
+        const key = args[0] ? `on key "${args[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,
+      set,
+      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;
+      case "Map":
+      case "Set":
+      case "WeakMap":
+      case "WeakSet":
+        return 2;
+      default:
+        return 0;
+    }
+  }
+  function getTargetType(value) {
+    return value["__v_skip"] || !Object.isExtensible(value) ? 0 : 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 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) {
+      return target;
+    }
+    const proxy = new Proxy(
+      target,
+      targetType === 2 ? 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;
+  const COMPUTED_SIDE_EFFECT_WARN = `Computed is still dirty after getter evaluation, likely because a computed is mutating its own dependency in its getter. State mutations in computed getters should be avoided.  Check the docs for more details: https://vuejs.org/guide/essentials/computed.html#getters-should-be-side-effect-free`;
+  class ComputedRefImpl {
+    constructor(getter, _setter, isReadonly2, isSSR) {
+      this.getter = getter;
+      this._setter = _setter;
+      this.dep = void 0;
+      this.__v_isRef = true;
+      this["__v_isReadonly"] = false;
+      this.effect = new ReactiveEffect(
+        () => getter(this._value),
+        () => triggerRefValue(
+          this,
+          this.effect._dirtyLevel === 2 ? 2 : 3
+        )
+      );
+      this.effect.computed = this;
+      this.effect.active = this._cacheable = !isSSR;
+      this["__v_isReadonly"] = isReadonly2;
+    }
+    get value() {
+      const self2 = toRaw(this);
+      if ((!self2._cacheable || self2.effect.dirty) && hasChanged(self2._value, self2._value = self2.effect.run())) {
+        triggerRefValue(self2, 4);
+      }
+      trackRefValue(self2);
+      if (self2.effect._dirtyLevel >= 2) {
+        if (!!(process.env.NODE_ENV !== "production") && this._warnRecursive) {
+          warn(COMPUTED_SIDE_EFFECT_WARN, `
+
+getter: `, this.getter);
+        }
+        triggerRefValue(self2, 2);
+      }
+      return self2._value;
+    }
+    set value(newValue) {
+      this._setter(newValue);
+    }
+    // #region polyfill _dirty for backward compatibility third party code for Vue <= 3.3.x
+    get _dirty() {
+      return this.effect.dirty;
+    }
+    set _dirty(v) {
+      this.effect.dirty = v;
+    }
+    // #endregion
+  }
+  function computed$1(getterOrOptions, debugOptions, isSSR = false) {
+    let getter;
+    let setter;
+    const onlyGetter = isFunction(getterOrOptions);
+    if (onlyGetter) {
+      getter = getterOrOptions;
+      setter = !!(process.env.NODE_ENV !== "production") ? () => {
+        warn("Write operation failed: computed value is readonly");
+      } : NOOP;
+    } else {
+      getter = getterOrOptions.get;
+      setter = getterOrOptions.set;
+    }
+    const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR);
+    if (!!(process.env.NODE_ENV !== "production") && debugOptions && !isSSR) {
+      cRef.effect.onTrack = debugOptions.onTrack;
+      cRef.effect.onTrigger = debugOptions.onTrigger;
+    }
+    return cRef;
+  }
+  function trackRefValue(ref2) {
+    var _a;
+    if (shouldTrack && activeEffect) {
+      ref2 = toRaw(ref2);
+      trackEffect(
+        activeEffect,
+        (_a = ref2.dep) != null ? _a : ref2.dep = createDep(
+          () => ref2.dep = void 0,
+          ref2 instanceof ComputedRefImpl ? ref2 : void 0
+        ),
+        !!(process.env.NODE_ENV !== "production") ? {
+          target: ref2,
+          type: "get",
+          key: "value"
+        } : void 0
+      );
+    }
+  }
+  function triggerRefValue(ref2, dirtyLevel = 4, newVal) {
+    ref2 = toRaw(ref2);
+    const dep = ref2.dep;
+    if (dep) {
+      triggerEffects(
+        dep,
+        dirtyLevel,
+        !!(process.env.NODE_ENV !== "production") ? {
+          target: ref2,
+          type: "set",
+          key: "value",
+          newValue: newVal
+        } : void 0
+      );
+    }
+  }
+  function isRef(r) {
+    return !!(r && r.__v_isRef === true);
+  }
+  function ref(value) {
+    return createRef(value, false);
+  }
+  function createRef(rawValue, shallow) {
+    if (isRef(rawValue)) {
+      return rawValue;
+    }
+    return new RefImpl(rawValue, shallow);
+  }
+  class RefImpl {
+    constructor(value, __v_isShallow) {
+      this.__v_isShallow = __v_isShallow;
+      this.dep = void 0;
+      this.__v_isRef = true;
+      this._rawValue = __v_isShallow ? value : toRaw(value);
+      this._value = __v_isShallow ? value : toReactive(value);
+    }
+    get value() {
+      trackRefValue(this);
+      return this._value;
+    }
+    set value(newVal) {
+      const useDirectValue = this.__v_isShallow || isShallow(newVal) || isReadonly(newVal);
+      newVal = useDirectValue ? newVal : toRaw(newVal);
+      if (hasChanged(newVal, this._rawValue)) {
+        this._rawValue = newVal;
+        this._value = useDirectValue ? newVal : toReactive(newVal);
+        triggerRefValue(this, 4, newVal);
+      }
+    }
+  }
+  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);
+  }
+  /**
+  * @vue/runtime-core v3.4.23
+  * (c) 2018-present Yuxi (Evan) You and Vue contributors
+  * @license MIT
+  **/
+  const stack = [];
+  function pushWarningContext(vnode) {
+    stack.push(vnode);
+  }
+  function popWarningContext() {
+    stack.pop();
+  }
+  function warn$1(msg, ...args) {
+    pauseTracking();
+    const instance = stack.length ? stack[stack.length - 1].component : null;
+    const appWarnHandler = instance && instance.appContext.config.warnHandler;
+    const trace = getComponentTrace();
+    if (appWarnHandler) {
+      callWithErrorHandling(
+        appWarnHandler,
+        instance,
+        11,
+        [
+          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(
+            ({ vnode }) => `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));
+      }
+      console.warn(...warnArgs);
+    }
+    resetTracking();
+  }
+  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({ vnode, recurseCount }) {
+    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(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. This is likely a Vue internals bug. Please open an issue at https://github.com/vuejs/core ."
+  };
+  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(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, throwInDev = true) {
+    const contextVNode = instance ? instance.vnode : null;
+    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;
+      }
+      const appErrorHandler = instance.appContext.config.errorHandler;
+      if (appErrorHandler) {
+        pauseTracking();
+        callWithErrorHandling(
+          appErrorHandler,
+          null,
+          10,
+          [err, exposedInstance, errorInfo]
+        );
+        resetTracking();
+        return;
+      }
+    }
+    logError(err, type, contextVNode, throwInDev);
+  }
+  function logError(err, type, contextVNode, throwInDev = true) {
+    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 {
+        console.error(err);
+      }
+    } else {
+      console.error(err);
+    }
+  }
+  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 = flushIndex + 1;
+    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.pre) {
+        start = middle + 1;
+      } else {
+        end = middle;
+      }
+    }
+    return start;
+  }
+  function queueJob(job) {
+    if (!queue.length || !queue.includes(
+      job,
+      isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex
+    )) {
+      if (job.id == null) {
+        queue.push(job);
+      } else {
+        queue.splice(findInsertionIndex(job.id), 0, job);
+      }
+      queueFlush();
+    }
+  }
+  function queueFlush() {
+    if (!isFlushing && !isFlushPending) {
+      isFlushPending = true;
+      currentFlushPromise = resolvedPromise.then(flushJobs);
+    }
+  }
+  function queuePostFlushCb(cb) {
+    if (!isArray(cb)) {
+      if (!activePostFlushCbs || !activePostFlushCbs.includes(
+        cb,
+        cb.allowRecurse ? postFlushIndex + 1 : postFlushIndex
+      )) {
+        pendingPostFlushCbs.push(cb);
+      }
+    } 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++) {
+        if (!!(process.env.NODE_ENV !== "production") && checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex])) {
+          continue;
+        }
+        activePostFlushCbs[postFlushIndex]();
+      }
+      activePostFlushCbs = null;
+      postFlushIndex = 0;
+    }
+  }
+  const getId = (job) => job.id == null ? Infinity : job.id;
+  const comparator = (a, b) => {
+    const diff = getId(a) - getId(b);
+    if (diff === 0) {
+      if (a.pre && !b.pre)
+        return -1;
+      if (b.pre && !a.pre)
+        return 1;
+    }
+    return diff;
+  };
+  function flushJobs(seen) {
+    isFlushPending = false;
+    isFlushing = true;
+    if (!!(process.env.NODE_ENV !== "production")) {
+      seen = seen || /* @__PURE__ */ new Map();
+    }
+    queue.sort(comparator);
+    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.active !== false) {
+          if (!!(process.env.NODE_ENV !== "production") && check(job)) {
+            continue;
+          }
+          callWithErrorHandling(job, null, 14);
+        }
+      }
+    } 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.ownerInstance;
+        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 Set();
+  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(component2) {
+    return isClassComponent(component2) ? component2.__vccOpts : component2;
+  }
+  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.effect.dirty = true;
+      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 (const instance of instances) {
+      const oldComp = normalizeClassComponent(instance.type);
+      if (!hmrDirtyComponents.has(oldComp)) {
+        if (oldComp !== record.initialDef) {
+          updateComponentDef(oldComp, newComp);
+        }
+        hmrDirtyComponents.add(oldComp);
+      }
+      instance.appContext.propsCache.delete(instance.type);
+      instance.appContext.emitsCache.delete(instance.type);
+      instance.appContext.optionsCache.delete(instance.type);
+      if (instance.ceReload) {
+        hmrDirtyComponents.add(oldComp);
+        instance.ceReload(newComp.styles);
+        hmrDirtyComponents.delete(oldComp);
+      } else if (instance.parent) {
+        instance.parent.effect.dirty = true;
+        queueJob(instance.parent.update);
+      } else if (instance.appContext.reload) {
+        instance.appContext.reload();
+      } else if (typeof window !== "undefined") {
+        window.location.reload();
+      } else {
+        console.warn(
+          "[HMR] Root or manually mounted instance modified. Full reload required."
+        );
+      }
+    }
+    queuePostFlushCb(() => {
+      for (const instance of instances) {
+        hmrDirtyComponents.delete(
+          normalizeClassComponent(instance.type)
+        );
+      }
+    });
+  }
+  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) {
+        console.error(e);
+        console.warn(
+          `[HMR] Something went wrong during Vue component hot-reload. Full reload required.`
+        );
+      }
+    };
+  }
+  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(({ event, args }) => 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
+      !((_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;
+  function markAttrsAccessed() {
+  }
+  const COMPONENTS = "components";
+  function resolveComponent(name, maybeSelfReference) {
+    return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name;
+  }
+  const NULL_DYNAMIC_COMPONENT = Symbol.for("v-ndc");
+  function resolveDynamicComponent(component2) {
+    if (isString(component2)) {
+      return resolveAsset(COMPONENTS, component2, false) || component2;
+    } else {
+      return component2 || NULL_DYNAMIC_COMPONENT;
+    }
+  }
+  function resolveAsset(type, name, warnMissing = true, maybeSelfReference = false) {
+    const instance = currentInstance;
+    if (instance) {
+      const Component = instance.type;
+      if (type === COMPONENTS) {
+        const selfName = getComponentName(
+          Component,
+          false
+        );
+        if (selfName && (selfName === name || selfName === camelize(name) || selfName === capitalize(camelize(name)))) {
+          return Component;
+        }
+      }
+      const res = (
+        // local registration
+        // check instance[type] first which is resolved for options API
+        resolve(instance[type] || Component[type], name) || // global registration
+        resolve(instance.appContext[type], name)
+      );
+      if (!res && maybeSelfReference) {
+        return Component;
+      }
+      if (!!(process.env.NODE_ENV !== "production") && warnMissing && !res) {
+        const extra = type === COMPONENTS ? `
+If this is a native custom element, make sure to exclude it from component resolution via compilerOptions.isCustomElement.` : ``;
+        warn$1(`Failed to resolve ${type.slice(0, -1)}: ${name}${extra}`);
+      }
+      return res;
+    } else if (!!(process.env.NODE_ENV !== "production")) {
+      warn$1(
+        `resolve${capitalize(type.slice(0, -1))} can only be used in render() or setup().`
+      );
+    }
+  }
+  function resolve(registry, name) {
+    return registry && (registry[name] || registry[camelize(name)] || registry[capitalize(camelize(name))]);
+  }
+  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 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;
+    }
+  };
+  const INITIAL_WATCHER_VALUE = {};
+  function watch(source, cb, options) {
+    if (!!(process.env.NODE_ENV !== "production") && !isFunction(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, {
+    immediate,
+    deep,
+    flush,
+    once,
+    onTrack,
+    onTrigger
+  } = EMPTY_OBJ) {
+    if (cb && once) {
+      const _cb = cb;
+      cb = (...args) => {
+        _cb(...args);
+        unwatch();
+      };
+    }
+    if (!!(process.env.NODE_ENV !== "production") && deep !== void 0 && typeof deep === "number") {
+      warn$1(
+        `watch() "deep" option with number value will be used as watch depth in future versions. Please use a boolean instead to avoid potential breakage.`
+      );
+    }
+    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 warnInvalidSource = (s) => {
+      warn$1(
+        `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 instance = currentInstance;
+    const reactiveGetter = (source2) => deep === true ? source2 : (
+      // for deep: false, only traverse root-level properties
+      traverse(source2, deep === false ? 1 : void 0)
+    );
+    let getter;
+    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(s)) {
+          return callWithErrorHandling(s, instance, 2);
+        } else {
+          !!(process.env.NODE_ENV !== "production") && warnInvalidSource(s);
+        }
+      });
+    } else if (isFunction(source)) {
+      if (cb) {
+        getter = () => callWithErrorHandling(source, instance, 2);
+      } else {
+        getter = () => {
+          if (cleanup) {
+            cleanup();
+          }
+          return callWithAsyncErrorHandling(
+            source,
+            instance,
+            3,
+            [onCleanup]
+          );
+        };
+      }
+    } else {
+      getter = NOOP;
+      !!(process.env.NODE_ENV !== "production") && warnInvalidSource(source);
+    }
+    if (cb && deep) {
+      const baseGetter = getter;
+      getter = () => traverse(baseGetter());
+    }
+    let cleanup;
+    let onCleanup = (fn) => {
+      cleanup = effect2.onStop = () => {
+        callWithErrorHandling(fn, instance, 4);
+        cleanup = effect2.onStop = void 0;
+      };
+    };
+    let ssrCleanup;
+    if (isInSSRComponentSetup) {
+      onCleanup = NOOP;
+      if (!cb) {
+        getter();
+      } else if (immediate) {
+        callWithAsyncErrorHandling(cb, instance, 3, [
+          getter(),
+          isMultiSource ? [] : void 0,
+          onCleanup
+        ]);
+      }
+      if (flush === "sync") {
+        const ctx = useSSRContext();
+        ssrCleanup = ctx.__watcherHandles || (ctx.__watcherHandles = []);
+      } else {
+        return NOOP;
+      }
+    }
+    let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
+    const job = () => {
+      if (!effect2.active || !effect2.dirty) {
+        return;
+      }
+      if (cb) {
+        const newValue = effect2.run();
+        if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue)) || false) {
+          if (cleanup) {
+            cleanup();
+          }
+          callWithAsyncErrorHandling(cb, instance, 3, [
+            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,
+            onCleanup
+          ]);
+          oldValue = newValue;
+        }
+      } else {
+        effect2.run();
+      }
+    };
+    job.allowRecurse = !!cb;
+    let scheduler;
+    if (flush === "sync") {
+      scheduler = job;
+    } else if (flush === "post") {
+      scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);
+    } else {
+      job.pre = true;
+      if (instance)
+        job.id = instance.uid;
+      scheduler = () => queueJob(job);
+    }
+    const effect2 = new ReactiveEffect(getter, NOOP, scheduler);
+    const unwatch = () => {
+      effect2.stop();
+    };
+    if (!!(process.env.NODE_ENV !== "production")) {
+      effect2.onTrack = onTrack;
+      effect2.onTrigger = onTrigger;
+    }
+    if (cb) {
+      if (immediate) {
+        job();
+      } else {
+        oldValue = effect2.run();
+      }
+    } else if (flush === "post") {
+      queuePostRenderEffect(
+        effect2.run.bind(effect2),
+        instance && instance.suspense
+      );
+    } else {
+      effect2.run();
+    }
+    if (ssrCleanup)
+      ssrCleanup.push(unwatch);
+    return unwatch;
+  }
+  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(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, path2) {
+    const segments = path2.split(".");
+    return () => {
+      let cur = ctx;
+      for (let i = 0; i < segments.length && cur; i++) {
+        cur = cur[segments[i]];
+      }
+      return cur;
+    };
+  }
+  function traverse(value, depth, currentDepth = 0, seen) {
+    if (!isObject(value) || value["__v_skip"]) {
+      return value;
+    }
+    if (depth && depth > 0) {
+      if (currentDepth >= depth) {
+        return value;
+      }
+      currentDepth++;
+    }
+    seen = seen || /* @__PURE__ */ new Set();
+    if (seen.has(value)) {
+      return value;
+    }
+    seen.add(value);
+    if (isRef(value)) {
+      traverse(value.value, depth, currentDepth, seen);
+    } else if (isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        traverse(value[i], depth, currentDepth, seen);
+      }
+    } else if (isSet(value) || isMap(value)) {
+      value.forEach((v) => {
+        traverse(v, depth, currentDepth, seen);
+      });
+    } else if (isPlainObject(value)) {
+      for (const key in value) {
+        traverse(value[key], depth, currentDepth, seen);
+      }
+    }
+    return value;
+  }
+  /*! #__NO_SIDE_EFFECTS__ */
+  // @__NO_SIDE_EFFECTS__
+  function defineComponent(options, extraOptions) {
+    return isFunction(options) ? (
+      // #8326: 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;
+  /*! #__NO_SIDE_EFFECTS__ */
+  // @__NO_SIDE_EFFECTS__
+  function defineAsyncComponent(source) {
+    if (isFunction(source)) {
+      source = { loader: source };
+    }
+    const {
+      loader,
+      loadingComponent,
+      errorComponent,
+      delay = 200,
+      timeout,
+      // undefined = never times out
+      suspensible = true,
+      onError: userOnError
+    } = source;
+    let pendingRequest = null;
+    let resolvedComp;
+    let retries = 0;
+    const retry = () => {
+      retries++;
+      pendingRequest = null;
+      return load();
+    };
+    const load = () => {
+      let thisRequest;
+      return pendingRequest || (thisRequest = pendingRequest = loader().catch((err) => {
+        err = err instanceof Error ? err : new Error(String(err));
+        if (userOnError) {
+          return new Promise((resolve2, reject) => {
+            const userRetry = () => resolve2(retry());
+            const userFail = () => reject(err);
+            userOnError(err, userRetry, userFail, retries + 1);
+          });
+        } else {
+          throw err;
+        }
+      }).then((comp) => {
+        if (thisRequest !== pendingRequest && pendingRequest) {
+          return pendingRequest;
+        }
+        if (!!(process.env.NODE_ENV !== "production") && !comp) {
+          warn$1(
+            `Async component loader resolved to undefined. If you are using retry(), make sure to return its return value.`
+          );
+        }
+        if (comp && (comp.__esModule || comp[Symbol.toStringTag] === "Module")) {
+          comp = comp.default;
+        }
+        if (!!(process.env.NODE_ENV !== "production") && comp && !isObject(comp) && !isFunction(comp)) {
+          throw new Error(`Invalid async component load result: ${comp}`);
+        }
+        resolvedComp = comp;
+        return comp;
+      }));
+    };
+    return /* @__PURE__ */ defineComponent({
+      name: "AsyncComponentWrapper",
+      __asyncLoader: load,
+      get __asyncResolved() {
+        return resolvedComp;
+      },
+      setup() {
+        const instance = currentInstance;
+        if (resolvedComp) {
+          return () => createInnerComp(resolvedComp, instance);
+        }
+        const onError = (err) => {
+          pendingRequest = null;
+          handleError(
+            err,
+            instance,
+            13,
+            !errorComponent
+          );
+        };
+        if (suspensible && instance.suspense || isInSSRComponentSetup) {
+          return load().then((comp) => {
+            return () => createInnerComp(comp, instance);
+          }).catch((err) => {
+            onError(err);
+            return () => errorComponent ? createVNode(errorComponent, {
+              error: err
+            }) : null;
+          });
+        }
+        const loaded = ref(false);
+        const error = ref();
+        const delayed = ref(!!delay);
+        if (delay) {
+          setTimeout(() => {
+            delayed.value = false;
+          }, delay);
+        }
+        if (timeout != null) {
+          setTimeout(() => {
+            if (!loaded.value && !error.value) {
+              const err = new Error(
+                `Async component timed out after ${timeout}ms.`
+              );
+              onError(err);
+              error.value = err;
+            }
+          }, timeout);
+        }
+        load().then(() => {
+          loaded.value = true;
+          if (instance.parent && isKeepAlive(instance.parent.vnode)) {
+            instance.parent.effect.dirty = true;
+            queueJob(instance.parent.update);
+          }
+        }).catch((err) => {
+          onError(err);
+          error.value = err;
+        });
+        return () => {
+          if (loaded.value && resolvedComp) {
+            return createInnerComp(resolvedComp, instance);
+          } else if (error.value && errorComponent) {
+            return createVNode(errorComponent, {
+              error: error.value
+            });
+          } else if (loadingComponent && !delayed.value) {
+            return createVNode(loadingComponent);
+          }
+        };
+      }
+    });
+  }
+  function createInnerComp(comp, parent) {
+    const { ref: ref22, props, children, ce } = parent.vnode;
+    const vnode = createVNode(comp, props, children);
+    vnode.ref = ref22;
+    vnode.ce = ce;
+    delete parent.vnode.ce;
+    return vnode;
+  }
+  const isKeepAlive = (vnode) => vnode.type.__isKeepAlive;
+  function renderSlot(slots, name, props = {}, fallback, noSlotted) {
+    if (currentRenderingInstance.isCE || currentRenderingInstance.parent && isAsyncWrapper(currentRenderingInstance.parent) && currentRenderingInstance.parent.isCE) {
+      if (name !== "default")
+        props.name = name;
+      return createVNode("slot", props, fallback && fallback());
+    }
+    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}`
+      },
+      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 getExposeProxy(i) || i.proxy;
+    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),
+      $emit: (i) => i.emit,
+      $options: (i) => resolveMergedOptions(i),
+      $forceUpdate: (i) => i.f || (i.f = () => {
+        i.effect.dirty = true;
+        queueJob(i.update);
+      }),
+      $nextTick: (i) => i.n || (i.n = nextTick.bind(i.proxy)),
+      $watch: (i) => instanceWatch.bind(i)
+    })
+  );
+  const isReservedPrefix = (key) => key === "_" || key === "$";
+  const hasSetupBinding = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn(state, key);
+  const PublicInstanceProxyHandlers = {
+    get({ _: instance }, key) {
+      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:
+              return setupState[key];
+            case 2:
+              return data[key];
+            case 4:
+              return ctx[key];
+            case 3:
+              return props[key];
+          }
+        } else if (hasSetupBinding(setupState, key)) {
+          accessCache[key] = 1;
+          return setupState[key];
+        } else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
+          accessCache[key] = 2;
+          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;
+          return props[key];
+        } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
+          accessCache[key] = 4;
+          return ctx[key];
+        } else {
+          accessCache[key] = 0;
+        }
+      }
+      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;
+        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({ _: instance }, key, value) {
+      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({
+      _: { data, setupState, accessCache, ctx, appContext, propsOptions }
+    }, key) {
+      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 normalizePropsOrEmits(props) {
+    return isArray(props) ? props.reduce(
+      (normalized, p) => (normalized[p] = null, normalized),
+      {}
+    ) : props;
+  }
+  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, asMixin = 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(to) ? to.call(this, this) : to,
+        isFunction(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 provide(key, value) {
+    if (!currentInstance) {
+      if (!!(process.env.NODE_ENV !== "production")) {
+        warn$1(`provide() can only be used inside setup().`);
+      }
+    } else {
+      let provides = currentInstance.provides;
+      const parentProvides = currentInstance.parent && currentInstance.parent.provides;
+      if (parentProvides === provides) {
+        provides = currentInstance.provides = Object.create(parentProvides);
+      }
+      provides[key] = value;
+    }
+  }
+  function inject(key, defaultValue, treatDefaultAsFactory = false) {
+    const instance = currentInstance || currentRenderingInstance;
+    if (instance || currentApp) {
+      const provides = instance ? instance.parent == null ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : currentApp._context.provides;
+      if (provides && key in provides) {
+        return provides[key];
+      } else if (arguments.length > 1) {
+        return treatDefaultAsFactory && isFunction(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 = /* @__PURE__ */ Object.create(null);
+  const isInternalObject = (obj) => Object.getPrototypeOf(obj) === internalObjectProto;
+  const queuePostRenderEffect = queueEffectWithSuspense;
+  const isTeleport = (type) => type.__isTeleport;
+  const Fragment = Symbol.for("v-fgt");
+  const Text = Symbol.for("v-txt");
+  const Comment = Symbol.for("v-cmt");
+  const blockStack = [];
+  let currentBlock = null;
+  function openBlock(disableTracking = 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 = (...args) => {
+    return _createVNode(
+      ...args
+    );
+  };
+  const normalizeKey = ({ key }) => key != null ? key : null;
+  const normalizeRef = ({
+    ref: ref3,
+    ref_key,
+    ref_for
+  }) => {
+    if (typeof ref3 === "number") {
+      ref3 = "" + ref3;
+    }
+    return ref3 != null ? isString(ref3) || isRef(ref3) || isFunction(ref3) ? { i: currentRenderingInstance, r: ref3, k: ref_key, f: !!ref_for } : ref3 : null;
+  };
+  function createBaseVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, shapeFlag = type === Fragment ? 0 : 1, isBlockNode = false, needFullChildrenNormalization = 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,
+      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, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = 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(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, mergeRef = false) {
+    const { props, ref: ref3, patchFlag, children } = 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 && ref3 ? isArray(ref3) ? ref3.concat(normalizeRef(extraProps)) : [ref3, normalizeRef(extraProps)] : normalizeRef(extraProps)
+      ) : ref3,
+      scopeId: vnode.scopeId,
+      slotScopeIds: vnode.slotScopeIds,
+      children: !!(process.env.NODE_ENV !== "production") && patchFlag === -1 && isArray(children) ? children.map(deepCloneVNode) : children,
+      target: vnode.target,
+      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: vnode.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
+    };
+    return cloned;
+  }
+  function deepCloneVNode(vnode) {
+    const cloned = cloneVNode(vnode);
+    if (isArray(vnode.children)) {
+      cloned.children = vnode.children.map(deepCloneVNode);
+    }
+    return cloned;
+  }
+  function createTextVNode(text = " ", flag = 0) {
+    return createVNode(Text, 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(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(...args) {
+    const ret = {};
+    for (let i = 0; i < args.length; i++) {
+      const toMerge = args[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((set2) => set2(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;
+  !!(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 getExposeProxy(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;
+        }
+      }));
+    }
+  }
+  const classifyRE = /(?:^|[-_])(\w)/g;
+  const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, "");
+  function getComponentName(Component, includeInferred = true) {
+    return isFunction(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;
+  }
+  function formatComponentName(instance, Component, isRoot = 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(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 h(type, propsOrChildren, children) {
+    const l = arguments.length;
+    if (l === 2) {
+      if (isObject(propsOrChildren) && !isArray(propsOrChildren)) {
+        if (isVNode(propsOrChildren)) {
+          return createVNode(type, null, [propsOrChildren]);
+        }
+        return createVNode(type, propsOrChildren);
+      } else {
+        return createVNode(type, null, propsOrChildren);
+      }
+    } else {
+      if (l > 3) {
+        children = Array.prototype.slice.call(arguments, 2);
+      } else if (l === 3 && isVNode(children)) {
+        children = [children];
+      }
+      return createVNode(type, propsOrChildren, children);
+    }
+  }
+  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 = {
+      header(obj) {
+        if (!isObject(obj)) {
+          return null;
+        }
+        if (obj.__isVue) {
+          return ["div", vueStyle, `VueInstance`];
+        } else if (isRef(obj)) {
+          return [
+            "div",
+            {},
+            ["span", vueStyle, genRefFlag(obj)],
+            "<",
+            formatValue(obj.value),
+            `>`
+          ];
+        } 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 computed2 = extractKeys(instance, "computed");
+      if (computed2) {
+        blocks.push(createInstanceBlock("computed", computed2));
+      }
+      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, asRaw = 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(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.4.23
+  * (c) 2018-present Yuxi (Evan) You and Vue contributors
+  * @license MIT
+  **/
+  function initDev() {
+    {
+      initCustomFormatter();
+    }
+  }
+  if (!!(process.env.NODE_ENV !== "production")) {
+    initDev();
+  }
+  const routerRejectionKey = Symbol();
+  function useRejection() {
+    const rejection = inject(routerRejectionKey);
+    if (!rejection) {
+      throw new Error("Router is not installed");
+    }
+    return rejection;
+  }
+  class DuplicateParamsError extends Error {
+    constructor(paramName) {
+      super(`Invalid Param "${paramName}": Router does not support multiple params by the same name. All param names must be unique.`);
+    }
+  }
+  class NavigationAbortError extends Error {
+  }
+  class RouterNotInstalledError extends Error {
+    constructor() {
+      super("Router not installed");
+    }
+  }
+  class RouterPushError extends Error {
+    constructor(to) {
+      super();
+      __publicField(this, "to");
+      this.to = to;
+    }
+  }
+  class RouterRejectionError extends Error {
+    constructor(type) {
+      super();
+      __publicField(this, "type");
+      this.type = type;
+    }
+  }
+  class UseRouteInvalidError extends Error {
+    constructor(routeName, actualRouteName) {
+      super(`useRoute called with incorrect route. Given ${routeName}, expected ${actualRouteName}`);
+    }
+  }
+  const routerInjectionKey = Symbol();
+  function useRouter() {
+    const router = inject(routerInjectionKey);
+    if (!router) {
+      throw new RouterNotInstalledError();
+    }
+    console.log([router]);
+    return router;
+  }
+  function combineName(parentName, childName) {
+    return [parentName, childName].filter((value) => !!value).join(".");
+  }
+  function useRoute(routeKey) {
+    const router = useRouter();
+    function checkRouteKeyIsValid() {
+      if (!routeKey) {
+        return;
+      }
+      const actualRouteKeys = router.route.matches.map((route) => route.name);
+      const actualRouteKey = getRouteKey(actualRouteKeys);
+      const routeKeyIsValid = actualRouteKey.includes(routeKey);
+      if (!routeKeyIsValid) {
+        throw new UseRouteInvalidError(routeKey, router.route.key);
+      }
+    }
+    watch(router.route, checkRouteKeyIsValid, { immediate: true, deep: true });
+    return router.route;
+  }
+  function getRouteKey(names) {
+    return names.reduce((ancestorNames, name) => {
+      const previous = ancestorNames.pop();
+      const next = name ? [combineName(previous, name)] : [];
+      if (!previous) {
+        return next;
+      }
+      return [
+        ...ancestorNames,
+        previous,
+        ...next
+      ];
+    }, []);
+  }
+  function useRouteParam(_route, _param, _defaultValue) {
+    throw "not implemented";
+  }
+  function useRouteParamRaw(_route, _param, _defaultValue) {
+    throw "not implemented";
+  }
+  const notFoundText = "Not Found";
+  const NotFound = /* @__PURE__ */ defineComponent(() => {
+    return () => h("h1", notFoundText);
+  }, {
+    name: "NotFound",
+    props: []
+  });
+  const depthInjectionKey = Symbol();
+  class InvalidRouteParamValueError extends Error {
+  }
+  function isNotConstructor(value) {
+    return value !== String && value !== Boolean && value !== Number;
+  }
+  function isParamGetter(value) {
+    return typeof value === "function" && isNotConstructor(value);
+  }
+  function isParamGetSet(value) {
+    return typeof value === "object" && "get" in value && typeof value.get === "function" && "set" in value && typeof value.set === "function";
+  }
+  function isParentRoute(value) {
+    return "children" in value;
+  }
+  function isUrl(value) {
+    if (typeof value !== "string") {
+      return false;
+    }
+    const regexPattern = /^(https?:\/\/|\/).*/g;
+    return regexPattern.test(value);
+  }
+  const _hoisted_1$1 = ["href"];
+  const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+    __name: "routerLink",
+    props: {
+      to: { type: [String, Function] },
+      query: {},
+      replace: { type: Boolean }
+    },
+    setup(__props) {
+      const props = __props;
+      const router = useRouter();
+      const resolved = computed(() => {
+        return isUrl(props.to) ? props.to : props.to(router.resolve);
+      });
+      const options = computed(() => {
+        const { to, ...options2 } = props;
+        return options2;
+      });
+      const route = computed(() => {
+        var _a;
+        return (_a = router.find(resolved.value, options.value)) == null ? void 0 : _a.matched;
+      });
+      const match = computed(() => !!route.value && router.route.matches.includes(readonly(route.value)));
+      const exactMatch = computed(() => !!route.value && router.route.matched === route.value);
+      const classes = computed(() => ({
+        "router-link--match": match.value,
+        "router-link--exact-match": exactMatch.value
+      }));
+      const isExternal = computed(() => {
+        const { host } = new URL(resolved.value, window.location.origin);
+        return host !== window.location.host;
+      });
+      function onClick(event) {
+        event.preventDefault();
+        router.push(resolved.value, options.value);
+      }
+      return (_ctx, _cache) => {
+        return openBlock(), createElementBlock("a", {
+          href: resolved.value,
+          class: normalizeClass(classes.value),
+          onClick
+        }, [
+          renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps({ resolved: resolved.value, match: match.value, exactMatch: exactMatch.value, isExternal: isExternal.value })))
+        ], 10, _hoisted_1$1);
+      };
+    }
+  });
+  function useRouterDepth() {
+    return inject(depthInjectionKey, 0);
+  }
+  const _hoisted_1 = { class: "router-view" };
+  const _sfc_main = /* @__PURE__ */ defineComponent({
+    __name: "routerView",
+    setup(__props) {
+      const router = useRouter();
+      const rejection = useRejection();
+      const depth = useRouterDepth();
+      const routerView = resolveComponent("RouterView", true);
+      provide(depthInjectionKey, depth + 1);
+      watch(router.route, (value) => console.log("router.route changed", value), { immediate: true });
+      const component2 = computed(() => {
+        console.log("triggered computed", JSON.stringify(router.route));
+        const routeComponent = router.route.matches[depth].component;
+        console.log(routeComponent);
+        if (routeComponent) {
+          if (typeof routeComponent === "function") {
+            return /* @__PURE__ */ defineAsyncComponent(routeComponent);
+          }
+          return routeComponent;
+        }
+        return routerView;
+      });
+      return (_ctx, _cache) => {
+        return openBlock(), createElementBlock("div", _hoisted_1, [
+          unref(rejection) ? (openBlock(), createBlock(resolveDynamicComponent(unref(rejection).component), { key: 0 })) : (openBlock(), createBlock(resolveDynamicComponent(component2.value), { key: 1 }))
+        ]);
+      };
+    }
+  });
+  function asArray(value) {
+    return Array.isArray(value) ? value : [value];
+  }
+  function createCurrentRoute(fallbackRoute) {
+    const route = reactive(fallbackRoute);
+    const updateRoute = (newRoute) => {
+      route.matched = newRoute.matched;
+      route.matches = newRoute.matches;
+      route.key = newRoute.key;
+      route.query = newRoute.query;
+      route.params = newRoute.params;
+    };
+    return {
+      route,
+      updateRoute
+    };
+  }
+  function createMaybeRelativeUrl(value) {
+    const isRelative = !value.startsWith("http");
+    return isRelative ? createRelativeUrl(value) : createAbsoluteUrl(value);
+  }
+  function createAbsoluteUrl(value) {
+    const { protocol, host, pathname, search, searchParams, hash } = new URL(value, value);
+    return {
+      protocol,
+      host,
+      pathname,
+      search,
+      searchParams,
+      hash
+    };
+  }
+  function createRelativeUrl(value) {
+    const { pathname, search, searchParams, hash } = new URL(value, "https://localhost");
+    return {
+      pathname,
+      search,
+      searchParams,
+      hash
+    };
+  }
+  function createResolvedRouteQuery(query2) {
+    const params = new URLSearchParams(query2);
+    return {
+      get: (key) => params.get(key),
+      getAll: (key) => params.getAll(key)
+    };
+  }
+  function stringHasValue(value) {
+    return typeof value === "string" && value.length > 0;
+  }
+  function getParam(params, param) {
+    return params[param] ?? String;
+  }
+  const optionalKey = Symbol();
+  function isOptionalParam(param) {
+    return optionalKey in param;
+  }
+  function optional(param) {
+    return {
+      [optionalKey]: true,
+      get: (value) => {
+        if (!stringHasValue(value)) {
+          return void 0;
+        }
+        return getParamValue(value, param);
+      },
+      set: (value) => {
+        if (!stringHasValue(value)) {
+          return "";
+        }
+        return setParamValue(value, param);
+      }
+    };
+  }
+  const extras = {
+    invalid: (message) => {
+      throw new InvalidRouteParamValueError(message);
+    }
+  };
+  const stringParam = {
+    get: (value) => {
+      return value;
+    },
+    set: (value, { invalid }) => {
+      if (typeof value !== "string") {
+        throw invalid();
+      }
+      return value;
+    }
+  };
+  const booleanParam = {
+    get: (value, { invalid }) => {
+      if (value === "true") {
+        return true;
+      }
+      if (value === "false") {
+        return false;
+      }
+      throw invalid();
+    },
+    set: (value, { invalid }) => {
+      if (typeof value !== "boolean") {
+        throw invalid();
+      }
+      return value.toString();
+    }
+  };
+  const numberParam = {
+    get: (value, { invalid }) => {
+      const number = Number(value);
+      if (isNaN(number)) {
+        throw invalid();
+      }
+      return number;
+    },
+    set: (value, { invalid }) => {
+      if (typeof value !== "number") {
+        throw invalid();
+      }
+      return value.toString();
+    }
+  };
+  function getParamValue(value, param) {
+    if (value === void 0) {
+      if (isOptionalParam(param)) {
+        return param.get(value, extras);
+      }
+      throw new InvalidRouteParamValueError();
+    }
+    if (param === String) {
+      return stringParam.get(value, extras);
+    }
+    if (param === Boolean) {
+      return booleanParam.get(value, extras);
+    }
+    if (param === Number) {
+      return numberParam.get(value, extras);
+    }
+    if (isParamGetter(param)) {
+      return param(value, extras);
+    }
+    if (isParamGetSet(param)) {
+      return param.get(value, extras);
+    }
+    if (param instanceof RegExp) {
+      if (param.test(value)) {
+        return value;
+      }
+      throw new InvalidRouteParamValueError();
+    }
+    return value;
+  }
+  function setParamValue(value, param) {
+    if (param === Boolean) {
+      return booleanParam.set(value, extras);
+    }
+    if (param === Number) {
+      return numberParam.set(value, extras);
+    }
+    if (isParamGetSet(param)) {
+      return param.set(value, extras);
+    }
+    try {
+      return value.toString();
+    } catch (error) {
+      throw new InvalidRouteParamValueError();
+    }
+  }
+  function generateRoutePathRegexPattern(route) {
+    const routeRegex = replaceParamSyntaxWithCatchAlls(route.path.toString());
+    return new RegExp(`^${routeRegex}$`, "i");
+  }
+  function generateRouteQueryRegexPatterns(route) {
+    const queryParams = new URLSearchParams(route.query.toString());
+    return Array.from(queryParams.entries()).map(([key, value]) => new RegExp(`${key}=${replaceParamSyntaxWithCatchAlls(value)}`, "i"));
+  }
+  function replaceParamSyntaxWithCatchAlls(value) {
+    return [
+      replaceOptionalParamSyntaxWithCatchAll,
+      replaceRequiredParamSyntaxWithCatchAll
+    ].reduce((pattern, regexBuild) => {
+      return regexBuild(pattern);
+    }, value);
+  }
+  function replaceOptionalParamSyntaxWithCatchAll(value) {
+    const optionalParamRegex = /(:\?[\w]+)(?=\W|$)/g;
+    return value.replace(optionalParamRegex, "[^/]*");
+  }
+  function replaceRequiredParamSyntaxWithCatchAll(value) {
+    const requiredParamRegex = /(:[\w]+)(?=\W|$)/g;
+    return value.replace(requiredParamRegex, "[^/]+");
+  }
+  function getParamValueFromUrl(url, path2, paramName) {
+    const regexPattern = getParamRegexPattern(path2, paramName);
+    const [paramValue] = getCaptureGroups(url, regexPattern);
+    return paramValue;
+  }
+  function setParamValueOnUrl(path2, paramReplace) {
+    if (!paramReplace) {
+      return path2;
+    }
+    const { name, param, value } = paramReplace;
+    const regexPattern = getParamRegexPattern(path2, name);
+    const captureGroups = getCaptureGroups(path2, regexPattern);
+    return captureGroups.reduce((url, captureGroup) => {
+      return url.replace(captureGroup, () => setParamValue(value, param));
+    }, path2);
+  }
+  function getParamRegexPattern(path2, paramName) {
+    const regexPattern = [
+      replaceOptionalParamSyntaxWithCaptureGroup,
+      replaceRequiredParamSyntaxWithCaptureGroup,
+      replaceParamSyntaxWithCatchAlls
+    ].reduce((pattern, regexBuild) => {
+      return regexBuild(pattern, paramName);
+    }, path2);
+    return new RegExp(regexPattern, "g");
+  }
+  function replaceOptionalParamSyntaxWithCaptureGroup(path2, paramName) {
+    const optionalParamRegex = new RegExp(`(:\\?${paramName})(?=\\W|$)`, "g");
+    return path2.replace(optionalParamRegex, "([^/]*)");
+  }
+  function replaceRequiredParamSyntaxWithCaptureGroup(path2, paramName) {
+    const requiredParamRegex = new RegExp(`(:${paramName})(?=\\W|$)`, "g");
+    return path2.replace(requiredParamRegex, "([^/]+)");
+  }
+  function getCaptureGroups(value, pattern) {
+    const matches = Array.from(value.matchAll(pattern));
+    return matches.flatMap(([, ...values]) => values.map((value2) => stringHasValue(value2) ? value2 : ""));
+  }
+  function withQuery(url, query2) {
+    if (!query2) {
+      return url;
+    }
+    if (Object.keys(query2).length === 0) {
+      return url;
+    }
+    const queryString = new URLSearchParams(query2).toString();
+    if (url.includes("?")) {
+      return `${url}&${queryString}`;
+    }
+    return `${url}?${queryString}`;
+  }
+  function assembleUrl(route, options = {}) {
+    const { params: paramValues = {}, query: queryValues } = options;
+    const params = Object.entries({ ...route.pathParams, ...route.queryParams });
+    const path2 = route.path.toString();
+    const query2 = route.query.toString();
+    const pathWithQuery = query2.length ? `${path2}?${query2}` : path2;
+    const url = params.reduce((url2, [name, param]) => {
+      return setParamValueOnUrl(url2, { name, param, value: paramValues[name] });
+    }, pathWithQuery);
+    return withQuery(url, queryValues);
+  }
+  function createRouterResolve(routes2) {
+    return (source, paramsOrOptions, maybeOptions) => {
+      if (isUrl(source)) {
+        const options2 = paramsOrOptions ?? {};
+        return withQuery(source, options2.query);
+      }
+      const params = paramsOrOptions ?? {};
+      const options = maybeOptions ?? {};
+      const match = routes2.find((route) => route.key === source);
+      if (!match) {
+        throw `Route not found: "${String(source)}"`;
+      }
+      if (match.matched.disabled) {
+        throw `Route disabled: "${String(source)}"`;
+      }
+      const url = assembleUrl(match, {
+        params,
+        query: options.query
+      });
+      return url;
+    };
+  }
+  const routeParamsAreValid = (route, url) => {
+    try {
+      getRouteParamValues(route, url);
+    } catch {
+      return false;
+    }
+    return true;
+  };
+  const getRouteParamValues = (route, url) => {
+    const { pathname, search } = createMaybeRelativeUrl(url);
+    return {
+      ...getRouteParams(route.pathParams, route.path.toString(), pathname),
+      ...getRouteParams(route.queryParams, route.query.toString(), search)
+    };
+  };
+  const getRouteParams = (paramDefinitions, paramFormat, valueFromUrl) => {
+    const params = {};
+    for (const [key, param] of Object.entries(paramDefinitions)) {
+      const stringValue = getParamValueFromUrl(valueFromUrl, paramFormat, key);
+      const formattedValues = getParamValue(stringValue, param);
+      params[key] = formattedValues;
+    }
+    return params;
+  };
+  const routePathMatches = (route, url) => {
+    const { pathname } = createMaybeRelativeUrl(url);
+    const pathPattern = generateRoutePathRegexPattern(route);
+    return pathPattern.test(pathname);
+  };
+  const routeQueryMatches = (route, url) => {
+    const { search } = createMaybeRelativeUrl(url);
+    const queryPatterns = generateRouteQueryRegexPatterns(route);
+    return queryPatterns.every((pattern) => pattern.test(search));
+  };
+  function getRouteScoreSortMethod(url) {
+    const { searchParams: actualQuery } = createMaybeRelativeUrl(url);
+    const sortBefore = -1;
+    const sortAfter = 1;
+    return (aRoute, bRoute) => {
+      const aRouteQueryScore = countExpectedQueryKeys(aRoute, actualQuery);
+      const bRouteQueryScore = countExpectedQueryKeys(bRoute, actualQuery);
+      if (aRouteQueryScore > bRouteQueryScore) {
+        return sortBefore;
+      }
+      if (aRouteQueryScore < bRouteQueryScore) {
+        return sortAfter;
+      }
+      if (aRoute.depth > bRoute.depth) {
+        return sortBefore;
+      }
+      if (aRoute.depth < bRoute.depth) {
+        return sortAfter;
+      }
+      return 0;
+    };
+  }
+  function countExpectedQueryKeys(route, actualQuery) {
+    const expectedQuery = new URLSearchParams(route.query.toString());
+    const expectedQueryKeys = Array.from(expectedQuery.keys());
+    const missing = expectedQueryKeys.filter((expected) => !actualQuery.has(expected));
+    return expectedQueryKeys.length - missing.length;
+  }
+  function getResolvedRouteForUrl(routes2, url) {
+    const rules = [isNamedRoute, routePathMatches, routeQueryMatches, routeParamsAreValid];
+    const sortByRouteScore = getRouteScoreSortMethod(url);
+    const matches = routes2.filter((route2) => rules.every((test) => test(route2, url))).sort(sortByRouteScore);
+    if (matches.length === 0) {
+      return void 0;
+    }
+    const [route] = matches;
+    const { search } = createMaybeRelativeUrl(url);
+    const query2 = createResolvedRouteQuery(search);
+    const params = getRouteParamValues(route, url);
+    return {
+      matched: route.matched,
+      matches: route.matches,
+      key: route.key,
+      query: query2,
+      params
+    };
+  }
+  const isNamedRoute = (route) => {
+    return "name" in route.matched && !!route.matched.name;
+  };
+  function createRouterFind(routes2) {
+    return (source, params = {}) => {
+      const resolve2 = createRouterResolve(routes2);
+      const url = resolve2(source, params);
+      return getResolvedRouteForUrl(routes2, url);
+    };
+  }
+  function _extends() {
+    _extends = Object.assign ? Object.assign.bind() : function(target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i];
+        for (var key in source) {
+          if (Object.prototype.hasOwnProperty.call(source, key)) {
+            target[key] = source[key];
+          }
+        }
+      }
+      return target;
+    };
+    return _extends.apply(this, arguments);
+  }
+  var Action;
+  (function(Action2) {
+    Action2["Pop"] = "POP";
+    Action2["Push"] = "PUSH";
+    Action2["Replace"] = "REPLACE";
+  })(Action || (Action = {}));
+  var readOnly = process.env.NODE_ENV !== "production" ? function(obj) {
+    return Object.freeze(obj);
+  } : function(obj) {
+    return obj;
+  };
+  function warning(cond, message) {
+    if (!cond) {
+      if (typeof console !== "undefined")
+        console.warn(message);
+      try {
+        throw new Error(message);
+      } catch (e) {
+      }
+    }
+  }
+  var BeforeUnloadEventType = "beforeunload";
+  var HashChangeEventType = "hashchange";
+  var PopStateEventType = "popstate";
+  function createBrowserHistory(options) {
+    if (options === void 0) {
+      options = {};
+    }
+    var _options = options, _options$window = _options.window, window2 = _options$window === void 0 ? document.defaultView : _options$window;
+    var globalHistory = window2.history;
+    function getIndexAndLocation() {
+      var _window$location = window2.location, pathname = _window$location.pathname, search = _window$location.search, hash = _window$location.hash;
+      var state = globalHistory.state || {};
+      return [state.idx, readOnly({
+        pathname,
+        search,
+        hash,
+        state: state.usr || null,
+        key: state.key || "default"
+      })];
+    }
+    var blockedPopTx = null;
+    function handlePop() {
+      if (blockedPopTx) {
+        blockers.call(blockedPopTx);
+        blockedPopTx = null;
+      } else {
+        var nextAction = Action.Pop;
+        var _getIndexAndLocation = getIndexAndLocation(), nextIndex = _getIndexAndLocation[0], nextLocation = _getIndexAndLocation[1];
+        if (blockers.length) {
+          if (nextIndex != null) {
+            var delta = index - nextIndex;
+            if (delta) {
+              blockedPopTx = {
+                action: nextAction,
+                location: nextLocation,
+                retry: function retry() {
+                  go(delta * -1);
+                }
+              };
+              go(delta);
+            }
+          } else {
+            process.env.NODE_ENV !== "production" ? warning(
+              false,
+              // TODO: Write up a doc that explains our blocking strategy in
+              // detail and link to it here so people can understand better what
+              // is going on and how to avoid it.
+              "You are trying to block a POP navigation to a location that was not created by the history library. The block will fail silently in production, but in general you should do all navigation with the history library (instead of using window.history.pushState directly) to avoid this situation."
+            ) : void 0;
+          }
+        } else {
+          applyTx(nextAction);
+        }
+      }
+    }
+    window2.addEventListener(PopStateEventType, handlePop);
+    var action = Action.Pop;
+    var _getIndexAndLocation2 = getIndexAndLocation(), index = _getIndexAndLocation2[0], location = _getIndexAndLocation2[1];
+    var listeners = createEvents();
+    var blockers = createEvents();
+    if (index == null) {
+      index = 0;
+      globalHistory.replaceState(_extends({}, globalHistory.state, {
+        idx: index
+      }), "");
+    }
+    function createHref(to) {
+      return typeof to === "string" ? to : createPath(to);
+    }
+    function getNextLocation(to, state) {
+      if (state === void 0) {
+        state = null;
+      }
+      return readOnly(_extends({
+        pathname: location.pathname,
+        hash: "",
+        search: ""
+      }, typeof to === "string" ? parsePath(to) : to, {
+        state,
+        key: createKey()
+      }));
+    }
+    function getHistoryStateAndUrl(nextLocation, index2) {
+      return [{
+        usr: nextLocation.state,
+        key: nextLocation.key,
+        idx: index2
+      }, createHref(nextLocation)];
+    }
+    function allowTx(action2, location2, retry) {
+      return !blockers.length || (blockers.call({
+        action: action2,
+        location: location2,
+        retry
+      }), false);
+    }
+    function applyTx(nextAction) {
+      action = nextAction;
+      var _getIndexAndLocation3 = getIndexAndLocation();
+      index = _getIndexAndLocation3[0];
+      location = _getIndexAndLocation3[1];
+      listeners.call({
+        action,
+        location
+      });
+    }
+    function push(to, state) {
+      var nextAction = Action.Push;
+      var nextLocation = getNextLocation(to, state);
+      function retry() {
+        push(to, state);
+      }
+      if (allowTx(nextAction, nextLocation, retry)) {
+        var _getHistoryStateAndUr = getHistoryStateAndUrl(nextLocation, index + 1), historyState = _getHistoryStateAndUr[0], url = _getHistoryStateAndUr[1];
+        try {
+          globalHistory.pushState(historyState, "", url);
+        } catch (error) {
+          window2.location.assign(url);
+        }
+        applyTx(nextAction);
+      }
+    }
+    function replace(to, state) {
+      var nextAction = Action.Replace;
+      var nextLocation = getNextLocation(to, state);
+      function retry() {
+        replace(to, state);
+      }
+      if (allowTx(nextAction, nextLocation, retry)) {
+        var _getHistoryStateAndUr2 = getHistoryStateAndUrl(nextLocation, index), historyState = _getHistoryStateAndUr2[0], url = _getHistoryStateAndUr2[1];
+        globalHistory.replaceState(historyState, "", url);
+        applyTx(nextAction);
+      }
+    }
+    function go(delta) {
+      globalHistory.go(delta);
+    }
+    var history = {
+      get action() {
+        return action;
+      },
+      get location() {
+        return location;
+      },
+      createHref,
+      push,
+      replace,
+      go,
+      back: function back() {
+        go(-1);
+      },
+      forward: function forward() {
+        go(1);
+      },
+      listen: function listen(listener) {
+        return listeners.push(listener);
+      },
+      block: function block(blocker) {
+        var unblock = blockers.push(blocker);
+        if (blockers.length === 1) {
+          window2.addEventListener(BeforeUnloadEventType, promptBeforeUnload);
+        }
+        return function() {
+          unblock();
+          if (!blockers.length) {
+            window2.removeEventListener(BeforeUnloadEventType, promptBeforeUnload);
+          }
+        };
+      }
+    };
+    return history;
+  }
+  function createHashHistory(options) {
+    if (options === void 0) {
+      options = {};
+    }
+    var _options2 = options, _options2$window = _options2.window, window2 = _options2$window === void 0 ? document.defaultView : _options2$window;
+    var globalHistory = window2.history;
+    function getIndexAndLocation() {
+      var _parsePath = parsePath(window2.location.hash.substr(1)), _parsePath$pathname = _parsePath.pathname, pathname = _parsePath$pathname === void 0 ? "/" : _parsePath$pathname, _parsePath$search = _parsePath.search, search = _parsePath$search === void 0 ? "" : _parsePath$search, _parsePath$hash = _parsePath.hash, hash = _parsePath$hash === void 0 ? "" : _parsePath$hash;
+      var state = globalHistory.state || {};
+      return [state.idx, readOnly({
+        pathname,
+        search,
+        hash,
+        state: state.usr || null,
+        key: state.key || "default"
+      })];
+    }
+    var blockedPopTx = null;
+    function handlePop() {
+      if (blockedPopTx) {
+        blockers.call(blockedPopTx);
+        blockedPopTx = null;
+      } else {
+        var nextAction = Action.Pop;
+        var _getIndexAndLocation4 = getIndexAndLocation(), nextIndex = _getIndexAndLocation4[0], nextLocation = _getIndexAndLocation4[1];
+        if (blockers.length) {
+          if (nextIndex != null) {
+            var delta = index - nextIndex;
+            if (delta) {
+              blockedPopTx = {
+                action: nextAction,
+                location: nextLocation,
+                retry: function retry() {
+                  go(delta * -1);
+                }
+              };
+              go(delta);
+            }
+          } else {
+            process.env.NODE_ENV !== "production" ? warning(
+              false,
+              // TODO: Write up a doc that explains our blocking strategy in
+              // detail and link to it here so people can understand better
+              // what is going on and how to avoid it.
+              "You are trying to block a POP navigation to a location that was not created by the history library. The block will fail silently in production, but in general you should do all navigation with the history library (instead of using window.history.pushState directly) to avoid this situation."
+            ) : void 0;
+          }
+        } else {
+          applyTx(nextAction);
+        }
+      }
+    }
+    window2.addEventListener(PopStateEventType, handlePop);
+    window2.addEventListener(HashChangeEventType, function() {
+      var _getIndexAndLocation5 = getIndexAndLocation(), nextLocation = _getIndexAndLocation5[1];
+      if (createPath(nextLocation) !== createPath(location)) {
+        handlePop();
+      }
+    });
+    var action = Action.Pop;
+    var _getIndexAndLocation6 = getIndexAndLocation(), index = _getIndexAndLocation6[0], location = _getIndexAndLocation6[1];
+    var listeners = createEvents();
+    var blockers = createEvents();
+    if (index == null) {
+      index = 0;
+      globalHistory.replaceState(_extends({}, globalHistory.state, {
+        idx: index
+      }), "");
+    }
+    function getBaseHref() {
+      var base = document.querySelector("base");
+      var href = "";
+      if (base && base.getAttribute("href")) {
+        var url = window2.location.href;
+        var hashIndex = url.indexOf("#");
+        href = hashIndex === -1 ? url : url.slice(0, hashIndex);
+      }
+      return href;
+    }
+    function createHref(to) {
+      return getBaseHref() + "#" + (typeof to === "string" ? to : createPath(to));
+    }
+    function getNextLocation(to, state) {
+      if (state === void 0) {
+        state = null;
+      }
+      return readOnly(_extends({
+        pathname: location.pathname,
+        hash: "",
+        search: ""
+      }, typeof to === "string" ? parsePath(to) : to, {
+        state,
+        key: createKey()
+      }));
+    }
+    function getHistoryStateAndUrl(nextLocation, index2) {
+      return [{
+        usr: nextLocation.state,
+        key: nextLocation.key,
+        idx: index2
+      }, createHref(nextLocation)];
+    }
+    function allowTx(action2, location2, retry) {
+      return !blockers.length || (blockers.call({
+        action: action2,
+        location: location2,
+        retry
+      }), false);
+    }
+    function applyTx(nextAction) {
+      action = nextAction;
+      var _getIndexAndLocation7 = getIndexAndLocation();
+      index = _getIndexAndLocation7[0];
+      location = _getIndexAndLocation7[1];
+      listeners.call({
+        action,
+        location
+      });
+    }
+    function push(to, state) {
+      var nextAction = Action.Push;
+      var nextLocation = getNextLocation(to, state);
+      function retry() {
+        push(to, state);
+      }
+      process.env.NODE_ENV !== "production" ? warning(nextLocation.pathname.charAt(0) === "/", "Relative pathnames are not supported in hash history.push(" + JSON.stringify(to) + ")") : void 0;
+      if (allowTx(nextAction, nextLocation, retry)) {
+        var _getHistoryStateAndUr3 = getHistoryStateAndUrl(nextLocation, index + 1), historyState = _getHistoryStateAndUr3[0], url = _getHistoryStateAndUr3[1];
+        try {
+          globalHistory.pushState(historyState, "", url);
+        } catch (error) {
+          window2.location.assign(url);
+        }
+        applyTx(nextAction);
+      }
+    }
+    function replace(to, state) {
+      var nextAction = Action.Replace;
+      var nextLocation = getNextLocation(to, state);
+      function retry() {
+        replace(to, state);
+      }
+      process.env.NODE_ENV !== "production" ? warning(nextLocation.pathname.charAt(0) === "/", "Relative pathnames are not supported in hash history.replace(" + JSON.stringify(to) + ")") : void 0;
+      if (allowTx(nextAction, nextLocation, retry)) {
+        var _getHistoryStateAndUr4 = getHistoryStateAndUrl(nextLocation, index), historyState = _getHistoryStateAndUr4[0], url = _getHistoryStateAndUr4[1];
+        globalHistory.replaceState(historyState, "", url);
+        applyTx(nextAction);
+      }
+    }
+    function go(delta) {
+      globalHistory.go(delta);
+    }
+    var history = {
+      get action() {
+        return action;
+      },
+      get location() {
+        return location;
+      },
+      createHref,
+      push,
+      replace,
+      go,
+      back: function back() {
+        go(-1);
+      },
+      forward: function forward() {
+        go(1);
+      },
+      listen: function listen(listener) {
+        return listeners.push(listener);
+      },
+      block: function block(blocker) {
+        var unblock = blockers.push(blocker);
+        if (blockers.length === 1) {
+          window2.addEventListener(BeforeUnloadEventType, promptBeforeUnload);
+        }
+        return function() {
+          unblock();
+          if (!blockers.length) {
+            window2.removeEventListener(BeforeUnloadEventType, promptBeforeUnload);
+          }
+        };
+      }
+    };
+    return history;
+  }
+  function createMemoryHistory(options) {
+    if (options === void 0) {
+      options = {};
+    }
+    var _options3 = options, _options3$initialEntr = _options3.initialEntries, initialEntries = _options3$initialEntr === void 0 ? ["/"] : _options3$initialEntr, initialIndex = _options3.initialIndex;
+    var entries = initialEntries.map(function(entry) {
+      var location2 = readOnly(_extends({
+        pathname: "/",
+        search: "",
+        hash: "",
+        state: null,
+        key: createKey()
+      }, typeof entry === "string" ? parsePath(entry) : entry));
+      process.env.NODE_ENV !== "production" ? warning(location2.pathname.charAt(0) === "/", "Relative pathnames are not supported in createMemoryHistory({ initialEntries }) (invalid entry: " + JSON.stringify(entry) + ")") : void 0;
+      return location2;
+    });
+    var index = clamp(initialIndex == null ? entries.length - 1 : initialIndex, 0, entries.length - 1);
+    var action = Action.Pop;
+    var location = entries[index];
+    var listeners = createEvents();
+    var blockers = createEvents();
+    function createHref(to) {
+      return typeof to === "string" ? to : createPath(to);
+    }
+    function getNextLocation(to, state) {
+      if (state === void 0) {
+        state = null;
+      }
+      return readOnly(_extends({
+        pathname: location.pathname,
+        search: "",
+        hash: ""
+      }, typeof to === "string" ? parsePath(to) : to, {
+        state,
+        key: createKey()
+      }));
+    }
+    function allowTx(action2, location2, retry) {
+      return !blockers.length || (blockers.call({
+        action: action2,
+        location: location2,
+        retry
+      }), false);
+    }
+    function applyTx(nextAction, nextLocation) {
+      action = nextAction;
+      location = nextLocation;
+      listeners.call({
+        action,
+        location
+      });
+    }
+    function push(to, state) {
+      var nextAction = Action.Push;
+      var nextLocation = getNextLocation(to, state);
+      function retry() {
+        push(to, state);
+      }
+      process.env.NODE_ENV !== "production" ? warning(location.pathname.charAt(0) === "/", "Relative pathnames are not supported in memory history.push(" + JSON.stringify(to) + ")") : void 0;
+      if (allowTx(nextAction, nextLocation, retry)) {
+        index += 1;
+        entries.splice(index, entries.length, nextLocation);
+        applyTx(nextAction, nextLocation);
+      }
+    }
+    function replace(to, state) {
+      var nextAction = Action.Replace;
+      var nextLocation = getNextLocation(to, state);
+      function retry() {
+        replace(to, state);
+      }
+      process.env.NODE_ENV !== "production" ? warning(location.pathname.charAt(0) === "/", "Relative pathnames are not supported in memory history.replace(" + JSON.stringify(to) + ")") : void 0;
+      if (allowTx(nextAction, nextLocation, retry)) {
+        entries[index] = nextLocation;
+        applyTx(nextAction, nextLocation);
+      }
+    }
+    function go(delta) {
+      var nextIndex = clamp(index + delta, 0, entries.length - 1);
+      var nextAction = Action.Pop;
+      var nextLocation = entries[nextIndex];
+      function retry() {
+        go(delta);
+      }
+      if (allowTx(nextAction, nextLocation, retry)) {
+        index = nextIndex;
+        applyTx(nextAction, nextLocation);
+      }
+    }
+    var history = {
+      get index() {
+        return index;
+      },
+      get action() {
+        return action;
+      },
+      get location() {
+        return location;
+      },
+      createHref,
+      push,
+      replace,
+      go,
+      back: function back() {
+        go(-1);
+      },
+      forward: function forward() {
+        go(1);
+      },
+      listen: function listen(listener) {
+        return listeners.push(listener);
+      },
+      block: function block(blocker) {
+        return blockers.push(blocker);
+      }
+    };
+    return history;
+  }
+  function clamp(n, lowerBound, upperBound) {
+    return Math.min(Math.max(n, lowerBound), upperBound);
+  }
+  function promptBeforeUnload(event) {
+    event.preventDefault();
+    event.returnValue = "";
+  }
+  function createEvents() {
+    var handlers = [];
+    return {
+      get length() {
+        return handlers.length;
+      },
+      push: function push(fn) {
+        handlers.push(fn);
+        return function() {
+          handlers = handlers.filter(function(handler) {
+            return handler !== fn;
+          });
+        };
+      },
+      call: function call(arg) {
+        handlers.forEach(function(fn) {
+          return fn && fn(arg);
+        });
+      }
+    };
+  }
+  function createKey() {
+    return Math.random().toString(36).substr(2, 8);
+  }
+  function createPath(_ref) {
+    var _ref$pathname = _ref.pathname, pathname = _ref$pathname === void 0 ? "/" : _ref$pathname, _ref$search = _ref.search, search = _ref$search === void 0 ? "" : _ref$search, _ref$hash = _ref.hash, hash = _ref$hash === void 0 ? "" : _ref$hash;
+    if (search && search !== "?")
+      pathname += search.charAt(0) === "?" ? search : "?" + search;
+    if (hash && hash !== "#")
+      pathname += hash.charAt(0) === "#" ? hash : "#" + hash;
+    return pathname;
+  }
+  function parsePath(path2) {
+    var parsedPath = {};
+    if (path2) {
+      var hashIndex = path2.indexOf("#");
+      if (hashIndex >= 0) {
+        parsedPath.hash = path2.substr(hashIndex);
+        path2 = path2.substr(0, hashIndex);
+      }
+      var searchIndex = path2.indexOf("?");
+      if (searchIndex >= 0) {
+        parsedPath.search = path2.substr(searchIndex);
+        path2 = path2.substr(0, searchIndex);
+      }
+      if (path2) {
+        parsedPath.pathname = path2;
+      }
+    }
+    return parsedPath;
+  }
+  function isBrowser() {
+    return typeof window !== "undefined" && typeof window.document !== "undefined";
+  }
+  function createRouterHistory({ mode } = {}) {
+    const history = createHistory(mode);
+    const update = (url, options) => {
+      if (options == null ? void 0 : options.replace) {
+        return history.replace(url);
+      }
+      history.push(url);
+    };
+    const refresh = () => {
+      const url = createPath(history.location);
+      return history.replace(url);
+    };
+    return {
+      forward: history.forward,
+      back: history.back,
+      go: history.go,
+      update,
+      refresh
+    };
+  }
+  function createHistory(mode = "auto") {
+    switch (mode) {
+      case "auto":
+        return isBrowser() ? createBrowserHistory() : createMemoryHistory();
+      case "browser":
+        return createBrowserHistory();
+      case "memory":
+        return createMemoryHistory();
+      case "hash":
+        return createHashHistory();
+      default:
+        const exhaustive = mode;
+        throw new Error(`createHistory missing case for mode: ${exhaustive}`);
+    }
+  }
+  class RouteHooks {
+    constructor() {
+      __publicField(this, "onBeforeRouteEnter", /* @__PURE__ */ new Set());
+      __publicField(this, "onBeforeRouteUpdate", /* @__PURE__ */ new Set());
+      __publicField(this, "onBeforeRouteLeave", /* @__PURE__ */ new Set());
+      __publicField(this, "onAfterRouteEnter", /* @__PURE__ */ new Set());
+      __publicField(this, "onAfterRouteUpdate", /* @__PURE__ */ new Set());
+      __publicField(this, "onAfterRouteLeave", /* @__PURE__ */ new Set());
+    }
+  }
+  function getBeforeRouteHooksFromRoutes(to, from) {
+    const hooks = new RouteHooks();
+    to.matches.forEach((route, depth) => {
+      if (route.onBeforeRouteEnter && isRouteEnter(to, from, depth)) {
+        asArray(route.onBeforeRouteEnter).forEach((hook) => hooks.onBeforeRouteEnter.add(hook));
+      }
+      if (route.onBeforeRouteUpdate && isRouteUpdate(to, from, depth)) {
+        asArray(route.onBeforeRouteUpdate).forEach((hook) => hooks.onBeforeRouteUpdate.add(hook));
+      }
+    });
+    from.matches.forEach((route, depth) => {
+      if (route.onBeforeRouteLeave && isRouteLeave(to, from, depth)) {
+        asArray(route.onBeforeRouteLeave).forEach((hook) => hooks.onBeforeRouteLeave.add(hook));
+      }
+    });
+    return hooks;
+  }
+  function getAfterRouteHooksFromRoutes(to, from) {
+    const hooks = new RouteHooks();
+    to.matches.forEach((route, depth) => {
+      if (route.onAfterRouteEnter && isRouteEnter(to, from, depth)) {
+        asArray(route.onAfterRouteEnter).forEach((hook) => hooks.onAfterRouteEnter.add(hook));
+      }
+      if (route.onAfterRouteUpdate && isRouteUpdate(to, from, depth)) {
+        asArray(route.onAfterRouteUpdate).forEach((hook) => hooks.onAfterRouteUpdate.add(hook));
+      }
+    });
+    from.matches.forEach((route, depth) => {
+      if (route.onAfterRouteLeave && isRouteLeave(to, from, depth)) {
+        asArray(route.onAfterRouteLeave).forEach((hook) => hooks.onAfterRouteLeave.add(hook));
+      }
+    });
+    return hooks;
+  }
+  function createRouteHookRunners() {
+    const reject = (type) => {
+      throw new RouterRejectionError(type);
+    };
+    const push = (...parameters) => {
+      throw new RouterPushError(parameters);
+    };
+    const replace = (source, paramsOrOptions, maybeOptions) => {
+      if (isUrl(source)) {
+        const options2 = paramsOrOptions ?? {};
+        throw new RouterPushError([source, { ...options2, replace: true }]);
+      }
+      const params = paramsOrOptions;
+      const options = maybeOptions ?? {};
+      throw new RouterPushError([source, params, { ...options, replace: true }]);
+    };
+    const abort = () => {
+      throw new NavigationAbortError();
+    };
+    async function runBeforeRouteHooks({ to, from, hooks }) {
+      const { global: global2, component: component2 } = hooks;
+      const route = getBeforeRouteHooksFromRoutes(to, from);
+      const allHooks = [
+        ...global2.onBeforeRouteEnter,
+        ...route.onBeforeRouteEnter,
+        ...global2.onBeforeRouteUpdate,
+        ...route.onBeforeRouteUpdate,
+        ...component2.onBeforeRouteUpdate,
+        ...global2.onBeforeRouteLeave,
+        ...route.onBeforeRouteLeave,
+        ...component2.onBeforeRouteLeave
+      ];
+      try {
+        const results = allHooks.map((callback) => callback(to, {
+          from,
+          reject,
+          push,
+          replace,
+          abort
+        }));
+        await Promise.all(results);
+      } catch (error) {
+        if (error instanceof RouterPushError) {
+          return {
+            status: "PUSH",
+            to: error.to
+          };
+        }
+        if (error instanceof RouterRejectionError) {
+          return {
+            status: "REJECT",
+            type: error.type
+          };
+        }
+        if (error instanceof NavigationAbortError) {
+          return {
+            status: "ABORT"
+          };
+        }
+        throw error;
+      }
+      return {
+        status: "SUCCESS"
+      };
+    }
+    async function runAfterRouteHooks({ to, from, hooks }) {
+      const { global: global2, component: component2 } = hooks;
+      const route = getAfterRouteHooksFromRoutes(to, from);
+      const allHooks = [
+        ...component2.onAfterRouteLeave,
+        ...route.onAfterRouteLeave,
+        ...global2.onAfterRouteLeave,
+        ...component2.onAfterRouteUpdate,
+        ...route.onAfterRouteUpdate,
+        ...global2.onAfterRouteUpdate,
+        ...component2.onAfterRouteEnter,
+        ...route.onAfterRouteEnter,
+        ...global2.onAfterRouteEnter
+      ];
+      try {
+        const results = allHooks.map((callback) => callback(to, {
+          from,
+          reject,
+          push,
+          replace
+        }));
+        await Promise.all(results);
+      } catch (error) {
+        if (error instanceof RouterPushError) {
+          return {
+            status: "PUSH",
+            to: error.to
+          };
+        }
+        if (error instanceof RouterRejectionError) {
+          return {
+            status: "REJECT",
+            type: error.type
+          };
+        }
+        throw error;
+      }
+      return {
+        status: "SUCCESS"
+      };
+    }
+    return {
+      runBeforeRouteHooks,
+      runAfterRouteHooks
+    };
+  }
+  const isRouteEnter = (to, from, depth) => {
+    const toMatches = to.matches;
+    const fromMatches = (from == null ? void 0 : from.matches) ?? [];
+    return toMatches.length < depth || toMatches[depth] !== fromMatches[depth];
+  };
+  const isRouteLeave = (to, from, depth) => {
+    const toMatches = to.matches;
+    const fromMatches = (from == null ? void 0 : from.matches) ?? [];
+    return toMatches.length < depth || toMatches[depth] !== fromMatches[depth];
+  };
+  const isRouteUpdate = (to, from, depth) => {
+    return to.matches[depth] === (from == null ? void 0 : from.matches[depth]);
+  };
+  function getRouteHookCondition(lifecycle) {
+    switch (lifecycle) {
+      case "onBeforeRouteEnter":
+      case "onAfterRouteEnter":
+        return isRouteEnter;
+      case "onBeforeRouteUpdate":
+      case "onAfterRouteUpdate":
+        return isRouteUpdate;
+      case "onBeforeRouteLeave":
+      case "onAfterRouteLeave":
+        return isRouteLeave;
+      default:
+        throw new Error(`No route hook condition for lifecycle: ${lifecycle}`);
+    }
+  }
+  class RouteHookStore {
+    constructor() {
+      __publicField(this, "global", new RouteHooks());
+      __publicField(this, "component", new RouteHooks());
+    }
+    addBeforeRouteHook({ lifecycle, timing, depth, hook }) {
+      const condition = getRouteHookCondition(lifecycle);
+      const store = this[timing][lifecycle];
+      const wrapped = (to, context) => {
+        if (!condition(to, context.from, depth)) {
+          return;
+        }
+        return hook(to, context);
+      };
+      store.add(wrapped);
+      return () => store.delete(wrapped);
+    }
+    addAfterRouteHook({ lifecycle, timing, depth, hook }) {
+      const condition = getRouteHookCondition(lifecycle);
+      const store = this[timing][lifecycle];
+      const wrapped = (to, context) => {
+        if (!condition(to, context.from, depth)) {
+          return;
+        }
+        return hook(to, context);
+      };
+      store.add(wrapped);
+      return () => store.delete(wrapped);
+    }
+  }
+  const routeHookStoreKey = Symbol();
+  function createRouterHooks() {
+    const hooks = new RouteHookStore();
+    const onBeforeRouteEnter = (hook) => {
+      return hooks.addBeforeRouteHook({ lifecycle: "onBeforeRouteEnter", hook, timing: "global", depth: 0 });
+    };
+    const onBeforeRouteUpdate = (hook) => {
+      return hooks.addBeforeRouteHook({ lifecycle: "onBeforeRouteUpdate", hook, timing: "global", depth: 0 });
+    };
+    const onBeforeRouteLeave = (hook) => {
+      return hooks.addBeforeRouteHook({ lifecycle: "onBeforeRouteLeave", hook, timing: "global", depth: 0 });
+    };
+    const onAfterRouteEnter = (hook) => {
+      return hooks.addAfterRouteHook({ lifecycle: "onAfterRouteEnter", hook, timing: "global", depth: 0 });
+    };
+    const onAfterRouteUpdate = (hook) => {
+      return hooks.addAfterRouteHook({ lifecycle: "onAfterRouteUpdate", hook, timing: "global", depth: 0 });
+    };
+    const onAfterRouteLeave = (hook) => {
+      return hooks.addAfterRouteHook({ lifecycle: "onAfterRouteLeave", hook, timing: "global", depth: 0 });
+    };
+    return {
+      onBeforeRouteEnter,
+      onBeforeRouteUpdate,
+      onBeforeRouteLeave,
+      onAfterRouteEnter,
+      onAfterRouteUpdate,
+      onAfterRouteLeave,
+      hooks
+    };
+  }
+  const builtInRejections = ["NotFound"];
+  const builtInRejectionComponents = {
+    NotFound
+  };
+  const isRejectionRouteSymbol = Symbol();
+  function createRouterReject({
+    rejections: customRejectionComponents
+  }) {
+    const getRejectionComponent = (type) => {
+      const components = {
+        ...builtInRejectionComponents,
+        ...customRejectionComponents
+      };
+      return markRaw(components[type]);
+    };
+    const getRejectionRoute = (type) => {
+      const component2 = markRaw(getRejectionComponent(type));
+      const route = {
+        name: type,
+        path: "",
+        component: component2
+      };
+      const resolved = {
+        matched: route,
+        matches: [route],
+        key: type,
+        query: createResolvedRouteQuery(""),
+        params: {},
+        [isRejectionRouteSymbol]: true
+      };
+      return resolved;
+    };
+    const isRejectionRoute = (route) => {
+      return route[isRejectionRouteSymbol] === true;
+    };
+    const setRejection = (type) => {
+      if (!type) {
+        rejection.value = null;
+        return;
+      }
+      const component2 = getRejectionComponent(type);
+      rejection.value = { type, component: component2 };
+    };
+    const rejection = ref(null);
+    return {
+      setRejection,
+      rejection,
+      getRejectionRoute,
+      isRejectionRoute
+    };
+  }
+  function getInitialUrl(initialUrl) {
+    if (initialUrl) {
+      return initialUrl;
+    }
+    if (isBrowser()) {
+      return window.location.toString();
+    }
+    throw new Error("initialUrl must be set if window.location is unavailable");
+  }
+  function createRouter(routes2, options = {}) {
+    const resolve2 = createRouterResolve(routes2);
+    const history = createRouterHistory({ mode: options.historyMode });
+    const { runBeforeRouteHooks, runAfterRouteHooks } = createRouteHookRunners();
+    const {
+      hooks,
+      onBeforeRouteEnter,
+      onAfterRouteUpdate,
+      onBeforeRouteLeave,
+      onAfterRouteEnter,
+      onBeforeRouteUpdate,
+      onAfterRouteLeave
+    } = createRouterHooks();
+    async function update(url, { replace: replace2 } = {}) {
+      const to = getResolvedRouteForUrl(routes2, url) ?? getRejectionRoute("NotFound");
+      const from = route;
+      const beforeResponse = await runBeforeRouteHooks({ to, from, hooks });
+      const setHistory = () => history.update(url, { replace: replace2 });
+      const setRoute = () => updateRoute(to);
+      switch (beforeResponse.status) {
+        case "ABORT":
+          return;
+        case "PUSH":
+          setHistory();
+          push(...beforeResponse.to);
+          return;
+        case "REJECT":
+          setHistory();
+          setRoute();
+          setRejection(beforeResponse.type);
+          break;
+        case "SUCCESS":
+          setHistory();
+          setRoute();
+          setRejection(null);
+          break;
+        default:
+          throw new Error(`Switch is not exhaustive for before hook response status: ${JSON.stringify(beforeResponse)}`);
+      }
+      const afterResponse = await runAfterRouteHooks({ to, from, hooks });
+      switch (afterResponse.status) {
+        case "PUSH":
+          push(...afterResponse.to);
+          break;
+        case "REJECT":
+          setRejection(afterResponse.type);
+          break;
+        case "SUCCESS":
+          break;
+        default:
+          const exhaustive = afterResponse;
+          throw new Error(`Switch is not exhaustive for after hook response status: ${JSON.stringify(exhaustive)}`);
+      }
+    }
+    const push = (source, paramsOrOptions, maybeOptions) => {
+      if (isUrl(source)) {
+        const options3 = { ...paramsOrOptions };
+        const url2 = resolve2(source, options3);
+        return update(url2, { replace: options3.replace });
+      }
+      const options2 = { ...maybeOptions };
+      const params = paramsOrOptions ?? {};
+      const url = resolve2(source, params, options2);
+      return update(url, { replace: options2.replace });
+    };
+    const replace = (source, paramsOrOptions, maybeOptions) => {
+      if (isUrl(source)) {
+        const options3 = { ...paramsOrOptions, replace: true };
+        return push(source, options3);
+      }
+      const params = paramsOrOptions ?? {};
+      const options2 = { ...maybeOptions, replace: true };
+      return push(source, params, options2);
+    };
+    const reject = (type) => {
+      return setRejection(type);
+    };
+    const find = createRouterFind(routes2);
+    const { setRejection, rejection, getRejectionRoute } = createRouterReject(options);
+    const notFoundRoute = getRejectionRoute("NotFound");
+    const { route, updateRoute } = createCurrentRoute(notFoundRoute);
+    const initialUrl = getInitialUrl(options.initialUrl);
+    const initialized = update(initialUrl, { replace: true });
+    function install(app) {
+      app.component("RouterView", _sfc_main);
+      app.component("RouterLink", _sfc_main$1);
+      app.provide(routerInjectionKey, router);
+      app.provide(routerRejectionKey, rejection);
+      app.provide(routeHookStoreKey, hooks);
+    }
+    const router = {
+      route: readonly(route),
+      resolve: resolve2,
+      push,
+      replace,
+      reject,
+      find,
+      refresh: history.refresh,
+      forward: history.forward,
+      back: history.back,
+      go: history.go,
+      install,
+      initialized,
+      onBeforeRouteEnter,
+      onAfterRouteUpdate,
+      onBeforeRouteLeave,
+      onAfterRouteEnter,
+      onBeforeRouteUpdate,
+      onAfterRouteLeave
+    };
+    return router;
+  }
+  function checkDuplicateKeys(aParams, bParams) {
+    const aParamKeys = Object.keys(aParams);
+    const bParamKeys = Object.keys(bParams);
+    const duplicateKey = aParamKeys.find((key) => bParamKeys.includes(key));
+    if (duplicateKey) {
+      return {
+        key: duplicateKey,
+        hasDuplicates: true
+      };
+    }
+    return {
+      key: void 0,
+      hasDuplicates: false
+    };
+  }
+  function getParamsForString(string, params) {
+    const paramPattern = /:\??([\w]+)(?=\W|$)/g;
+    const matches = Array.from(string.matchAll(paramPattern));
+    return matches.reduce((value, [match, paramName]) => {
+      const isOptional = match.startsWith(":?");
+      const param = getParam(params, paramName);
+      if (paramName in value) {
+        throw new DuplicateParamsError(paramName);
+      }
+      value[paramName] = isOptional ? optional(param) : param;
+      return value;
+    }, {});
+  }
+  function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  function hasProperty(value, key, type) {
+    const propertyExists = isRecord(value) && key in value;
+    if (!propertyExists) {
+      return false;
+    }
+    if (type) {
+      return typeof value[key] === typeof type();
+    }
+    return true;
+  }
+  function path(path2, params) {
+    return {
+      path: path2,
+      params: getParamsForString(path2, params),
+      toString: () => path2
+    };
+  }
+  function isPath(value) {
+    return isRecord(value) && typeof value.path === "string";
+  }
+  function toPath(value) {
+    if (isPath(value)) {
+      return value;
+    }
+    return path(value, {});
+  }
+  function combinePath(parentPath, childPath) {
+    const { hasDuplicates, key } = checkDuplicateKeys(parentPath.params, childPath.params);
+    if (hasDuplicates) {
+      throw new DuplicateParamsError(key);
+    }
+    return path(`${parentPath.path}${childPath.path}`, { ...parentPath.params, ...childPath.params });
+  }
+  function query(query2, params) {
+    return {
+      query: query2,
+      params: getParamsForString(query2, params),
+      toString: () => query2
+    };
+  }
+  function isQuery(value) {
+    return isRecord(value) && typeof value.query === "string";
+  }
+  function toQuery(value) {
+    if (value === void 0) {
+      return query("", {});
+    }
+    if (isQuery(value)) {
+      return value;
+    }
+    return query(value, {});
+  }
+  function combineQuery(parentQuery, childQuery) {
+    const { hasDuplicates, key } = checkDuplicateKeys(parentQuery.params, childQuery.params);
+    if (hasDuplicates) {
+      throw new DuplicateParamsError(key);
+    }
+    return query(`${parentQuery.query}${childQuery.query}`, { ...parentQuery.params, ...childQuery.params });
+  }
+  function markRouteRaw(route) {
+    return { ...route, component: route.component ? markRaw(route.component) : route.component };
+  }
+  function createRoutes(routesProps) {
+    const routes2 = routesProps.reduce((routes22, routeProps) => {
+      const route = createRoute(routeProps);
+      if (isParentRoute(routeProps) && routeProps.children) {
+        routes22.push(...routeProps.children.map((childRoute) => ({
+          ...childRoute,
+          key: combineName(route.key, childRoute.key),
+          path: combinePath(route.path, childRoute.path),
+          query: combineQuery(route.query, childRoute.query),
+          matches: [...childRoute.matches, route.matched],
+          depth: childRoute.depth + 1
+        })));
+      }
+      routes22.push(route);
+      return routes22;
+    }, []);
+    routes2.forEach(({ path: path2, query: query2 }) => {
+      const { hasDuplicates, key } = checkDuplicateKeys(path2.params, query2.params);
+      if (hasDuplicates) {
+        throw new DuplicateParamsError(key);
+      }
+    });
+    return routes2;
+  }
+  function createRoute(route) {
+    const path2 = toPath(route.path);
+    const query2 = toQuery(route.query);
+    const rawRoute = markRouteRaw(route);
+    return {
+      matched: rawRoute,
+      matches: [rawRoute],
+      key: route.name,
+      path: path2,
+      query: query2,
+      pathParams: path2.params,
+      queryParams: query2.params,
+      depth: 1,
+      disabled: route.disabled ?? false
+    };
+  }
+  const random = {
+    number(options = {}) {
+      const { min, max } = { min: 0, max: 1, ...options };
+      const randomNumber = Math.floor(Math.random() * (max - min + 1)) + min;
+      return randomNumber;
+    }
+  };
+  const component = { template: "<div>This is component</div>" };
+  const routes = createRoutes([
+    {
+      name: "parentA",
+      path: "/:paramA",
+      children: createRoutes([
+        {
+          name: "childA",
+          path: "/:?paramB",
+          children: createRoutes([
+            {
+              name: "grandChildA",
+              path: "/:paramC",
+              component
+            }
+          ])
+        },
+        {
+          name: "childB",
+          path: "/:paramD",
+          component
+        }
+      ])
+    },
+    {
+      name: "parentB",
+      path: "/parentB",
+      component
+    }
+  ]);
+  exports2.InvalidRouteParamValueError = InvalidRouteParamValueError;
+  exports2.NotFound = NotFound;
+  exports2.RouterLink = _sfc_main$1;
+  exports2.RouterView = _sfc_main;
+  exports2.asArray = asArray;
+  exports2.assembleUrl = assembleUrl;
+  exports2.builtInRejectionComponents = builtInRejectionComponents;
+  exports2.builtInRejections = builtInRejections;
+  exports2.component = component;
+  exports2.countExpectedQueryKeys = countExpectedQueryKeys;
+  exports2.createCurrentRoute = createCurrentRoute;
+  exports2.createMaybeRelativeUrl = createMaybeRelativeUrl;
+  exports2.createResolvedRouteQuery = createResolvedRouteQuery;
+  exports2.createRouteHookRunners = createRouteHookRunners;
+  exports2.createRouter = createRouter;
+  exports2.createRouterFind = createRouterFind;
+  exports2.createRouterHistory = createRouterHistory;
+  exports2.createRouterHooks = createRouterHooks;
+  exports2.createRouterReject = createRouterReject;
+  exports2.createRouterResolve = createRouterResolve;
+  exports2.createRoutes = createRoutes;
+  exports2.depthInjectionKey = depthInjectionKey;
+  exports2.generateRoutePathRegexPattern = generateRoutePathRegexPattern;
+  exports2.generateRouteQueryRegexPatterns = generateRouteQueryRegexPatterns;
+  exports2.getAfterRouteHooksFromRoutes = getAfterRouteHooksFromRoutes;
+  exports2.getBeforeRouteHooksFromRoutes = getBeforeRouteHooksFromRoutes;
+  exports2.getInitialUrl = getInitialUrl;
+  exports2.getParam = getParam;
+  exports2.getParamValue = getParamValue;
+  exports2.getParamValueFromUrl = getParamValueFromUrl;
+  exports2.getParamsForString = getParamsForString;
+  exports2.getResolvedRouteForUrl = getResolvedRouteForUrl;
+  exports2.getRouteHookCondition = getRouteHookCondition;
+  exports2.getRouteParamValues = getRouteParamValues;
+  exports2.getRouteScoreSortMethod = getRouteScoreSortMethod;
+  exports2.hasProperty = hasProperty;
+  exports2.isBrowser = isBrowser;
+  exports2.isParamGetSet = isParamGetSet;
+  exports2.isParamGetter = isParamGetter;
+  exports2.isParentRoute = isParentRoute;
+  exports2.isRecord = isRecord;
+  exports2.isRouteEnter = isRouteEnter;
+  exports2.isRouteLeave = isRouteLeave;
+  exports2.isRouteUpdate = isRouteUpdate;
+  exports2.isUrl = isUrl;
+  exports2.markRouteRaw = markRouteRaw;
+  exports2.optional = optional;
+  exports2.path = path;
+  exports2.query = query;
+  exports2.random = random;
+  exports2.replaceParamSyntaxWithCatchAlls = replaceParamSyntaxWithCatchAlls;
+  exports2.routeHookStoreKey = routeHookStoreKey;
+  exports2.routeParamsAreValid = routeParamsAreValid;
+  exports2.routePathMatches = routePathMatches;
+  exports2.routeQueryMatches = routeQueryMatches;
+  exports2.routerInjectionKey = routerInjectionKey;
+  exports2.routerRejectionKey = routerRejectionKey;
+  exports2.routes = routes;
+  exports2.setParamValue = setParamValue;
+  exports2.setParamValueOnUrl = setParamValueOnUrl;
+  exports2.stringHasValue = stringHasValue;
+  exports2.toPath = toPath;
+  exports2.toQuery = toQuery;
+  exports2.useParam = useParam;
+  exports2.useParamRaw = useParamRaw;
+  exports2.useRejection = useRejection;
+  exports2.useRoute = useRoute;
+  exports2.useRouteParam = useRouteParam;
+  exports2.useRouteParamRaw = useRouteParamRaw;
+  exports2.useRouter = useRouter;
+  exports2.withQuery = withQuery;
+  Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+});