web-core-tcm 0.0.62 → 0.0.64

package/dist/node_modules/vue-router/dist/vue-router.js

@@ -1,12 +1,922 @@
-import { d as e } from "./devtools-EWN81iOl.js";
-import { l as f, o as n } from "./devtools-EWN81iOl.js";
-import { inject as o } from "vue";
-function u() {
-  return o(e);
+import { stripBase as xe, NavigationDirection as Z, NavigationType as te, assign as P, computeScrollPosition as re, warn as Ut, normalizeBase as Ve, createHref as Ue, START as he, isArray as ne, mergeOptions as ke, noop as J, isRouteName as He, createRouterError as ae, ErrorTypes as I, routerKey as oe, routeLocationKey as we, isSameRouteRecord as ge, isSameRouteLocationParams as Xe, routerViewLocationKey as ye, viewDepthKey as Ne, matchedRouteKey as Ye, parseQuery as et, stringifyQuery as Oe, useCallbacks as z, START_LOCATION_NORMALIZED as j, isBrowser as Q, applyToParams as de, encodeParam as tt, decode as Se, parseURL as pe, stringifyURL as nt, encodeHash as at, normalizeQuery as rt, isSameRouteLocation as ot, isNavigationFailure as B, extractChangingRecords as it, extractComponentsGuards as me, guardToPromiseFn as W, saveScrollPosition as st, getScrollKey as Ce, getSavedScrollPosition as lt, scrollToPosition as ct } from "./devtools-BLCumUwL.js";
+import { NavigationFailureType as tn, loadRouteLocation as nn, onBeforeRouteLeave as an, onBeforeRouteUpdate as rn } from "./devtools-BLCumUwL.js";
+import { inject as U, computed as $, unref as X, getCurrentInstance as Ft, defineComponent as We, reactive as ut, h as Ke, provide as ve, ref as ft, watch as ht, shallowRef as dt, nextTick as pt, shallowReactive as mt } from "vue";
+let vt = () => location.protocol + "//" + location.host;
+function Fe(e, a) {
+  const { pathname: t, search: o, hash: s } = a, p = e.indexOf("#");
+  if (p > -1) {
+    let g = s.includes(e.slice(p)) ? e.slice(p).length : 1, v = s.slice(g);
+    return v[0] !== "/" && (v = "/" + v), xe(v, "");
+  }
+  return xe(t, e) + o + s;
+}
+function gt(e, a, t, o) {
+  let s = [], p = [], g = null;
+  const v = ({ state: u }) => {
+    const i = Fe(e, location), w = t.value, b = a.value;
+    let k = 0;
+    if (u) {
+      if (t.value = i, a.value = u, g && g === w) {
+        g = null;
+        return;
+      }
+      k = b ? u.position - b.position : 0;
+    } else o(i);
+    s.forEach((N) => {
+      N(t.value, w, {
+        delta: k,
+        type: te.pop,
+        direction: k ? k > 0 ? Z.forward : Z.back : Z.unknown
+      });
+    });
+  };
+  function l() {
+    g = t.value;
+  }
+  function h(u) {
+    s.push(u);
+    const i = () => {
+      const w = s.indexOf(u);
+      w > -1 && s.splice(w, 1);
+    };
+    return p.push(i), i;
+  }
+  function c() {
+    if (document.visibilityState === "hidden") {
+      const { history: u } = window;
+      if (!u.state) return;
+      u.replaceState(P({}, u.state, { scroll: re() }), "");
+    }
+  }
+  function r() {
+    for (const u of p) u();
+    p = [], window.removeEventListener("popstate", v), window.removeEventListener("pagehide", c), document.removeEventListener("visibilitychange", c);
+  }
+  return window.addEventListener("popstate", v), window.addEventListener("pagehide", c), document.addEventListener("visibilitychange", c), {
+    pauseListeners: l,
+    listen: h,
+    destroy: r
+  };
+}
+function Ie(e, a, t, o = !1, s = !1) {
+  return {
+    back: e,
+    current: a,
+    forward: t,
+    replaced: o,
+    position: window.history.length,
+    scroll: s ? re() : null
+  };
+}
+function yt(e) {
+  const { history: a, location: t } = window, o = { value: Fe(e, t) }, s = { value: a.state };
+  s.value || p(o.value, {
+    back: null,
+    current: o.value,
+    forward: null,
+    position: a.length - 1,
+    replaced: !0,
+    scroll: null
+  }, !0);
+  function p(l, h, c) {
+    const r = e.indexOf("#"), u = r > -1 ? (t.host && document.querySelector("base") ? e : e.slice(r)) + l : vt() + e + l;
+    try {
+      a[c ? "replaceState" : "pushState"](h, "", u), s.value = h;
+    } catch (i) {
+      console.error(i), t[c ? "replace" : "assign"](u);
+    }
+  }
+  function g(l, h) {
+    p(l, P({}, a.state, Ie(s.value.back, l, s.value.forward, !0), h, { position: s.value.position }), !0), o.value = l;
+  }
+  function v(l, h) {
+    const c = P({}, s.value, a.state, {
+      forward: l,
+      scroll: re()
+    });
+    p(c.current, c, !0), p(l, P({}, Ie(o.value, l, null), { position: c.position + 1 }, h), !1), o.value = l;
+  }
+  return {
+    location: o,
+    state: s,
+    push: v,
+    replace: g
+  };
+}
+function wt(e) {
+  e = Ve(e);
+  const a = yt(e), t = gt(e, a.state, a.location, a.replace);
+  function o(p, g = !0) {
+    g || t.pauseListeners(), history.go(p);
+  }
+  const s = P({
+    location: "",
+    base: e,
+    go: o,
+    createHref: Ue.bind(null, e)
+  }, a, t);
+  return Object.defineProperty(s, "location", {
+    enumerable: !0,
+    get: () => a.location.value
+  }), Object.defineProperty(s, "state", {
+    enumerable: !0,
+    get: () => a.state.value
+  }), s;
+}
+function zt(e = "") {
+  let a = [], t = [[he, {}]], o = 0;
+  e = Ve(e);
+  function s(v, l = {}) {
+    o++, o !== t.length && t.splice(o), t.push([v, l]);
+  }
+  function p(v, l, { direction: h, delta: c }) {
+    const r = {
+      direction: h,
+      delta: c,
+      type: te.pop
+    };
+    for (const u of a) u(v, l, r);
+  }
+  const g = {
+    location: he,
+    state: {},
+    base: e,
+    createHref: Ue.bind(null, e),
+    replace(v, l) {
+      t.splice(o--, 1), s(v, l);
+    },
+    push(v, l) {
+      s(v, l);
+    },
+    listen(v) {
+      return a.push(v), () => {
+        const l = a.indexOf(v);
+        l > -1 && a.splice(l, 1);
+      };
+    },
+    destroy() {
+      a = [], t = [[he, {}]], o = 0;
+    },
+    go(v, l = !0) {
+      const h = this.location, c = v < 0 ? Z.back : Z.forward;
+      o = Math.max(0, Math.min(o + v, t.length - 1)), l && p(this.location, h, {
+        direction: c,
+        delta: v
+      });
+    }
+  };
+  return Object.defineProperty(g, "location", {
+    enumerable: !0,
+    get: () => t[o][0]
+  }), Object.defineProperty(g, "state", {
+    enumerable: !0,
+    get: () => t[o][1]
+  }), g;
+}
+function Qt(e) {
+  return e = location.host ? e || location.pathname + location.search : "", e.includes("#") || (e += "#"), wt(e);
+}
+let V = /* @__PURE__ */ (function(e) {
+  return e[e.Static = 0] = "Static", e[e.Param = 1] = "Param", e[e.Group = 2] = "Group", e;
+})({});
+var C = /* @__PURE__ */ (function(e) {
+  return e[e.Static = 0] = "Static", e[e.Param = 1] = "Param", e[e.ParamRegExp = 2] = "ParamRegExp", e[e.ParamRegExpEnd = 3] = "ParamRegExpEnd", e[e.EscapeNext = 4] = "EscapeNext", e;
+})(C || {});
+const Rt = {
+  type: V.Static,
+  value: ""
+}, Et = /[a-zA-Z0-9_]/;
+function At(e) {
+  if (!e) return [[]];
+  if (e === "/") return [[Rt]];
+  if (!e.startsWith("/")) throw new Error(`Invalid path "${e}"`);
+  function a(i) {
+    throw new Error(`ERR (${t})/"${h}": ${i}`);
+  }
+  let t = C.Static, o = t;
+  const s = [];
+  let p;
+  function g() {
+    p && s.push(p), p = [];
+  }
+  let v = 0, l, h = "", c = "";
+  function r() {
+    h && (t === C.Static ? p.push({
+      type: V.Static,
+      value: h
+    }) : t === C.Param || t === C.ParamRegExp || t === C.ParamRegExpEnd ? (p.length > 1 && (l === "*" || l === "+") && a(`A repeatable param (${h}) must be alone in its segment. eg: '/:ids+.`), p.push({
+      type: V.Param,
+      value: h,
+      regexp: c,
+      repeatable: l === "*" || l === "+",
+      optional: l === "*" || l === "?"
+    })) : a("Invalid state to consume buffer"), h = "");
+  }
+  function u() {
+    h += l;
+  }
+  for (; v < e.length; ) {
+    if (l = e[v++], l === "\\" && t !== C.ParamRegExp) {
+      o = t, t = C.EscapeNext;
+      continue;
+    }
+    switch (t) {
+      case C.Static:
+        l === "/" ? (h && r(), g()) : l === ":" ? (r(), t = C.Param) : u();
+        break;
+      case C.EscapeNext:
+        u(), t = o;
+        break;
+      case C.Param:
+        l === "(" ? t = C.ParamRegExp : Et.test(l) ? u() : (r(), t = C.Static, l !== "*" && l !== "?" && l !== "+" && v--);
+        break;
+      case C.ParamRegExp:
+        l === ")" ? c[c.length - 1] == "\\" ? c = c.slice(0, -1) + l : t = C.ParamRegExpEnd : c += l;
+        break;
+      case C.ParamRegExpEnd:
+        r(), t = C.Static, l !== "*" && l !== "?" && l !== "+" && v--, c = "";
+        break;
+      default:
+        a("Unknown state");
+        break;
+    }
+  }
+  return t === C.ParamRegExp && a(`Unfinished custom RegExp for param "${h}"`), r(), g(), s;
+}
+const Te = "[^/]+?", bt = {
+  sensitive: !1,
+  strict: !1,
+  start: !0,
+  end: !0
+};
+var T = /* @__PURE__ */ (function(e) {
+  return e[e._multiplier = 10] = "_multiplier", e[e.Root = 90] = "Root", e[e.Segment = 40] = "Segment", e[e.SubSegment = 30] = "SubSegment", e[e.Static = 40] = "Static", e[e.Dynamic = 20] = "Dynamic", e[e.BonusCustomRegExp = 10] = "BonusCustomRegExp", e[e.BonusWildcard = -50] = "BonusWildcard", e[e.BonusRepeatable = -20] = "BonusRepeatable", e[e.BonusOptional = -8] = "BonusOptional", e[e.BonusStrict = 0.7000000000000001] = "BonusStrict", e[e.BonusCaseSensitive = 0.25] = "BonusCaseSensitive", e;
+})(T || {});
+const Pt = /[.+*?^${}()[\]/\\]/g;
+function xt(e, a) {
+  const t = P({}, bt, a), o = [];
+  let s = t.start ? "^" : "";
+  const p = [];
+  for (const h of e) {
+    const c = h.length ? [] : [T.Root];
+    t.strict && !h.length && (s += "/");
+    for (let r = 0; r < h.length; r++) {
+      const u = h[r];
+      let i = T.Segment + (t.sensitive ? T.BonusCaseSensitive : 0);
+      if (u.type === V.Static)
+        r || (s += "/"), s += u.value.replace(Pt, "\\$&"), i += T.Static;
+      else if (u.type === V.Param) {
+        const { value: w, repeatable: b, optional: k, regexp: N } = u;
+        p.push({
+          name: w,
+          repeatable: b,
+          optional: k
+        });
+        const R = N || Te;
+        if (R !== Te) {
+          i += T.BonusCustomRegExp;
+          try {
+            `${R}`;
+          } catch (D) {
+            throw new Error(`Invalid custom RegExp for param "${w}" (${R}): ` + D.message);
+          }
+        }
+        let x = b ? `((?:${R})(?:/(?:${R}))*)` : `(${R})`;
+        r || (x = k && h.length < 2 ? `(?:/${x})` : "/" + x), k && (x += "?"), s += x, i += T.Dynamic, k && (i += T.BonusOptional), b && (i += T.BonusRepeatable), R === ".*" && (i += T.BonusWildcard);
+      }
+      c.push(i);
+    }
+    o.push(c);
+  }
+  if (t.strict && t.end) {
+    const h = o.length - 1;
+    o[h][o[h].length - 1] += T.BonusStrict;
+  }
+  t.strict || (s += "/?"), t.end ? s += "$" : t.strict && !s.endsWith("/") && (s += "(?:/|$)");
+  const g = new RegExp(s, t.sensitive ? "" : "i");
+  function v(h) {
+    const c = h.match(g), r = {};
+    if (!c) return null;
+    for (let u = 1; u < c.length; u++) {
+      const i = c[u] || "", w = p[u - 1];
+      r[w.name] = i && w.repeatable ? i.split("/") : i;
+    }
+    return r;
+  }
+  function l(h) {
+    let c = "", r = !1;
+    for (const u of e) {
+      (!r || !c.endsWith("/")) && (c += "/"), r = !1;
+      for (const i of u) if (i.type === V.Static) c += i.value;
+      else if (i.type === V.Param) {
+        const { value: w, repeatable: b, optional: k } = i, N = w in h ? h[w] : "";
+        if (ne(N) && !b) throw new Error(`Provided param "${w}" is an array but it is not repeatable (* or + modifiers)`);
+        const R = ne(N) ? N.join("/") : N;
+        if (!R) if (k)
+          u.length < 2 && (c.endsWith("/") ? c = c.slice(0, -1) : r = !0);
+        else throw new Error(`Missing required param "${w}"`);
+        c += R;
+      }
+    }
+    return c || "/";
+  }
+  return {
+    re: g,
+    score: o,
+    keys: p,
+    parse: v,
+    stringify: l
+  };
+}
+function kt(e, a) {
+  let t = 0;
+  for (; t < e.length && t < a.length; ) {
+    const o = a[t] - e[t];
+    if (o) return o;
+    t++;
+  }
+  return e.length < a.length ? e.length === 1 && e[0] === T.Static + T.Segment ? -1 : 1 : e.length > a.length ? a.length === 1 && a[0] === T.Static + T.Segment ? 1 : -1 : 0;
+}
+function qe(e, a) {
+  let t = 0;
+  const o = e.score, s = a.score;
+  for (; t < o.length && t < s.length; ) {
+    const p = kt(o[t], s[t]);
+    if (p) return p;
+    t++;
+  }
+  if (Math.abs(s.length - o.length) === 1) {
+    if (_e(o)) return 1;
+    if (_e(s)) return -1;
+  }
+  return s.length - o.length;
+}
+function _e(e) {
+  const a = e[e.length - 1];
+  return e.length > 0 && a[a.length - 1] < 0;
+}
+const Nt = {
+  strict: !1,
+  end: !0,
+  sensitive: !1
+};
+function Ot(e, a, t) {
+  const o = xt(At(e.path), t), s = P(o, {
+    record: e,
+    parent: a,
+    children: [],
+    alias: []
+  });
+  return a && !s.record.aliasOf == !a.record.aliasOf && a.children.push(s), s;
+}
+function St(e, a) {
+  const t = [], o = /* @__PURE__ */ new Map();
+  a = ke(Nt, a);
+  function s(r) {
+    return o.get(r);
+  }
+  function p(r, u, i) {
+    const w = !i, b = Le(r);
+    b.aliasOf = i && i.record;
+    const k = ke(a, r), N = [b];
+    if ("alias" in r) {
+      const D = typeof r.alias == "string" ? [r.alias] : r.alias;
+      for (const G of D) N.push(Le(P({}, b, {
+        components: i ? i.record.components : b.components,
+        path: G,
+        aliasOf: i ? i.record : b
+      })));
+    }
+    let R, x;
+    for (const D of N) {
+      const { path: G } = D;
+      if (u && G[0] !== "/") {
+        const M = u.record.path, L = M[M.length - 1] === "/" ? "" : "/";
+        D.path = u.record.path + (G && L + G);
+      }
+      if (R = Ot(D, u, k), i ? i.alias.push(R) : (x = x || R, x !== R && x.alias.push(R), w && r.name && !$e(R) && g(r.name)), ze(R) && l(R), b.children) {
+        const M = b.children;
+        for (let L = 0; L < M.length; L++) p(M[L], R, i && i.children[L]);
+      }
+      i = i || R;
+    }
+    return x ? () => {
+      g(x);
+    } : J;
+  }
+  function g(r) {
+    if (He(r)) {
+      const u = o.get(r);
+      u && (o.delete(r), t.splice(t.indexOf(u), 1), u.children.forEach(g), u.alias.forEach(g));
+    } else {
+      const u = t.indexOf(r);
+      u > -1 && (t.splice(u, 1), r.record.name && o.delete(r.record.name), r.children.forEach(g), r.alias.forEach(g));
+    }
+  }
+  function v() {
+    return t;
+  }
+  function l(r) {
+    const u = Tt(r, t);
+    t.splice(u, 0, r), r.record.name && !$e(r) && o.set(r.record.name, r);
+  }
+  function h(r, u) {
+    let i, w = {}, b, k;
+    if ("name" in r && r.name) {
+      if (i = o.get(r.name), !i) throw ae(I.MATCHER_NOT_FOUND, { location: r });
+      k = i.record.name, w = P(De(u.params, i.keys.filter((x) => !x.optional).concat(i.parent ? i.parent.keys.filter((x) => x.optional) : []).map((x) => x.name)), r.params && De(r.params, i.keys.map((x) => x.name))), b = i.stringify(w);
+    } else if (r.path != null)
+      b = r.path, i = t.find((x) => x.re.test(b)), i && (w = i.parse(b), k = i.record.name);
+    else {
+      if (i = u.name ? o.get(u.name) : t.find((x) => x.re.test(u.path)), !i) throw ae(I.MATCHER_NOT_FOUND, {
+        location: r,
+        currentLocation: u
+      });
+      k = i.record.name, w = P({}, u.params, r.params), b = i.stringify(w);
+    }
+    const N = [];
+    let R = i;
+    for (; R; )
+      N.unshift(R.record), R = R.parent;
+    return {
+      name: k,
+      path: b,
+      params: w,
+      matched: N,
+      meta: It(N)
+    };
+  }
+  e.forEach((r) => p(r));
+  function c() {
+    t.length = 0, o.clear();
+  }
+  return {
+    addRoute: p,
+    resolve: h,
+    removeRoute: g,
+    clearRoutes: c,
+    getRoutes: v,
+    getRecordMatcher: s
+  };
+}
+function De(e, a) {
+  const t = {};
+  for (const o of a) o in e && (t[o] = e[o]);
+  return t;
+}
+function Le(e) {
+  const a = {
+    path: e.path,
+    redirect: e.redirect,
+    name: e.name,
+    meta: e.meta || {},
+    aliasOf: e.aliasOf,
+    beforeEnter: e.beforeEnter,
+    props: Ct(e),
+    children: e.children || [],
+    instances: {},
+    leaveGuards: /* @__PURE__ */ new Set(),
+    updateGuards: /* @__PURE__ */ new Set(),
+    enterCallbacks: {},
+    components: "components" in e ? e.components || null : e.component && { default: e.component }
+  };
+  return Object.defineProperty(a, "mods", { value: {} }), a;
+}
+function Ct(e) {
+  const a = {}, t = e.props || !1;
+  if ("component" in e) a.default = t;
+  else for (const o in e.components) a[o] = typeof t == "object" ? t[o] : t;
+  return a;
+}
+function $e(e) {
+  for (; e; ) {
+    if (e.record.aliasOf) return !0;
+    e = e.parent;
+  }
+  return !1;
+}
+function It(e) {
+  return e.reduce((a, t) => P(a, t.meta), {});
+}
+function Tt(e, a) {
+  let t = 0, o = a.length;
+  for (; t !== o; ) {
+    const p = t + o >> 1;
+    qe(e, a[p]) < 0 ? o = p : t = p + 1;
+  }
+  const s = _t(e);
+  return s && (o = a.lastIndexOf(s, o - 1)), o;
+}
+function _t(e) {
+  let a = e;
+  for (; a = a.parent; ) if (ze(a) && qe(e, a) === 0) return a;
+}
+function ze({ record: e }) {
+  return !!(e.name || e.components && Object.keys(e.components).length || e.redirect);
+}
+function Be(e) {
+  const a = U(oe), t = U(we);
+  let o = !1, s = null;
+  const p = $(() => {
+    const c = X(e.to);
+    return a.resolve(c);
+  }), g = $(() => {
+    const { matched: c } = p.value, { length: r } = c, u = c[r - 1], i = t.matched;
+    if (!u || !i.length) return -1;
+    const w = i.findIndex(ge.bind(null, u));
+    if (w > -1) return w;
+    const b = Ge(c[r - 2]);
+    return r > 1 && Ge(u) === b && i[i.length - 1].path !== b ? i.findIndex(ge.bind(null, c[r - 2])) : w;
+  }), v = $(() => g.value > -1 && Gt(t.params, p.value.params)), l = $(() => g.value > -1 && g.value === t.matched.length - 1 && Xe(t.params, p.value.params));
+  function h(c = {}) {
+    if (Bt(c)) {
+      const r = a[X(e.replace) ? "replace" : "push"](X(e.to)).catch(J);
+      return e.viewTransition && typeof document < "u" && "startViewTransition" in document && document.startViewTransition(() => r), r;
+    }
+    return Promise.resolve();
+  }
+  return {
+    route: p,
+    href: $(() => p.value.href),
+    isActive: v,
+    isExactActive: l,
+    navigate: h
+  };
+}
+function Dt(e) {
+  return e.length === 1 ? e[0] : e;
+}
+const Lt = /* @__PURE__ */ We({
+  name: "RouterLink",
+  compatConfig: { MODE: 3 },
+  props: {
+    to: {
+      type: [String, Object],
+      required: !0
+    },
+    replace: Boolean,
+    activeClass: String,
+    exactActiveClass: String,
+    custom: Boolean,
+    ariaCurrentValue: {
+      type: String,
+      default: "page"
+    },
+    viewTransition: Boolean
+  },
+  useLink: Be,
+  setup(e, { slots: a }) {
+    const t = ut(Be(e)), { options: o } = U(oe), s = $(() => ({
+      [Me(e.activeClass, o.linkActiveClass, "router-link-active")]: t.isActive,
+      [Me(e.exactActiveClass, o.linkExactActiveClass, "router-link-exact-active")]: t.isExactActive
+    }));
+    return () => {
+      const p = a.default && Dt(a.default(t));
+      return e.custom ? p : Ke("a", {
+        "aria-current": t.isExactActive ? e.ariaCurrentValue : null,
+        href: t.href,
+        onClick: t.navigate,
+        class: s.value
+      }, p);
+    };
+  }
+}), $t = Lt;
+function Bt(e) {
+  if (!(e.metaKey || e.altKey || e.ctrlKey || e.shiftKey) && !e.defaultPrevented && !(e.button !== void 0 && e.button !== 0)) {
+    if (e.currentTarget && e.currentTarget.getAttribute) {
+      const a = e.currentTarget.getAttribute("target");
+      if (/\b_blank\b/i.test(a)) return;
+    }
+    return e.preventDefault && e.preventDefault(), !0;
+  }
+}
+function Gt(e, a) {
+  for (const t in a) {
+    const o = a[t], s = e[t];
+    if (typeof o == "string") {
+      if (o !== s) return !1;
+    } else if (!ne(s) || s.length !== o.length || o.some((p, g) => p !== s[g])) return !1;
+  }
+  return !0;
+}
+function Ge(e) {
+  return e ? e.aliasOf ? e.aliasOf.path : e.path : "";
+}
+const Me = (e, a, t) => e ?? a ?? t, Mt = /* @__PURE__ */ We({
+  name: "RouterView",
+  inheritAttrs: !1,
+  props: {
+    name: {
+      type: String,
+      default: "default"
+    },
+    route: Object
+  },
+  compatConfig: { MODE: 3 },
+  setup(e, { attrs: a, slots: t }) {
+    const o = U(ye), s = $(() => e.route || o.value), p = U(Ne, 0), g = $(() => {
+      let h = X(p);
+      const { matched: c } = s.value;
+      let r;
+      for (; (r = c[h]) && !r.components; ) h++;
+      return h;
+    }), v = $(() => s.value.matched[g.value]);
+    ve(Ne, $(() => g.value + 1)), ve(Ye, v), ve(ye, s);
+    const l = ft();
+    return ht(() => [
+      l.value,
+      v.value,
+      e.name
+    ], ([h, c, r], [u, i, w]) => {
+      c && (c.instances[r] = h, i && i !== c && h && h === u && (c.leaveGuards.size || (c.leaveGuards = i.leaveGuards), c.updateGuards.size || (c.updateGuards = i.updateGuards))), h && c && (!i || !ge(c, i) || !u) && (c.enterCallbacks[r] || []).forEach((b) => b(h));
+    }, { flush: "post" }), () => {
+      const h = s.value, c = e.name, r = v.value, u = r && r.components[c];
+      if (!u) return je(t.default, {
+        Component: u,
+        route: h
+      });
+      const i = r.props[c], w = i ? i === !0 ? h.params : typeof i == "function" ? i(h) : i : null, k = Ke(u, P({}, w, a, {
+        onVnodeUnmounted: (N) => {
+          N.component.isUnmounted && (r.instances[c] = null);
+        },
+        ref: l
+      }));
+      return je(t.default, {
+        Component: k,
+        route: h
+      }) || k;
+    };
+  }
+});
+function je(e, a) {
+  if (!e) return null;
+  const t = e(a);
+  return t.length === 1 ? t[0] : t;
+}
+const jt = Mt;
+function Zt(e) {
+  const a = St(e.routes, e), t = e.parseQuery || et, o = e.stringifyQuery || Oe, s = e.history, p = z(), g = z(), v = z(), l = dt(j);
+  let h = j;
+  Q && e.scrollBehavior && "scrollRestoration" in history && (history.scrollRestoration = "manual");
+  const c = de.bind(null, (n) => "" + n), r = de.bind(null, tt), u = de.bind(null, Se);
+  function i(n, d) {
+    let f, m;
+    return He(n) ? (f = a.getRecordMatcher(n), m = d) : m = n, a.addRoute(m, f);
+  }
+  function w(n) {
+    const d = a.getRecordMatcher(n);
+    d && a.removeRoute(d);
+  }
+  function b() {
+    return a.getRoutes().map((n) => n.record);
+  }
+  function k(n) {
+    return !!a.getRecordMatcher(n);
+  }
+  function N(n, d) {
+    if (d = P({}, d || l.value), typeof n == "string") {
+      const y = pe(t, n, d.path), S = a.resolve({ path: y.path }, d), q = s.createHref(y.fullPath);
+      return P(y, S, {
+        params: u(S.params),
+        hash: Se(y.hash),
+        redirectedFrom: void 0,
+        href: q
+      });
+    }
+    let f;
+    if (n.path != null)
+      f = P({}, n, { path: pe(t, n.path, d.path).path });
+    else {
+      const y = P({}, n.params);
+      for (const S in y) y[S] == null && delete y[S];
+      f = P({}, n, { params: r(y) }), d.params = r(d.params);
+    }
+    const m = a.resolve(f, d), A = n.hash || "";
+    m.params = c(u(m.params));
+    const O = nt(o, P({}, n, {
+      hash: at(A),
+      path: m.path
+    })), E = s.createHref(O);
+    return P({
+      fullPath: O,
+      hash: A,
+      query: o === Oe ? rt(n.query) : n.query || {}
+    }, m, {
+      redirectedFrom: void 0,
+      href: E
+    });
+  }
+  function R(n) {
+    return typeof n == "string" ? pe(t, n, l.value.path) : P({}, n);
+  }
+  function x(n, d) {
+    if (h !== n) return ae(I.NAVIGATION_CANCELLED, {
+      from: d,
+      to: n
+    });
+  }
+  function D(n) {
+    return L(n);
+  }
+  function G(n) {
+    return D(P(R(n), { replace: !0 }));
+  }
+  function M(n, d) {
+    const f = n.matched[n.matched.length - 1];
+    if (f && f.redirect) {
+      const { redirect: m } = f;
+      let A = typeof m == "function" ? m(n, d) : m;
+      return typeof A == "string" && (A = A.includes("?") || A.includes("#") ? A = R(A) : { path: A }, A.params = {}), P({
+        query: n.query,
+        hash: n.hash,
+        params: A.path != null ? {} : n.params
+      }, A);
+    }
+  }
+  function L(n, d) {
+    const f = h = N(n), m = l.value, A = n.state, O = n.force, E = n.replace === !0, y = M(f, m);
+    if (y) return L(P(R(y), {
+      state: typeof y == "object" ? P({}, A, y.state) : A,
+      force: O,
+      replace: E
+    }), d || f);
+    const S = f;
+    S.redirectedFrom = d;
+    let q;
+    return !O && ot(o, m, f) && (q = ae(I.NAVIGATION_DUPLICATED, {
+      to: S,
+      from: m
+    }), Pe(m, m, !0, !1)), (q ? Promise.resolve(q) : Re(S, m)).catch((_) => B(_) ? B(_, I.NAVIGATION_GUARD_REDIRECT) ? _ : ce(_) : le(_, S, m)).then((_) => {
+      if (_) {
+        if (B(_, I.NAVIGATION_GUARD_REDIRECT))
+          return L(P({ replace: E }, R(_.to), {
+            state: typeof _.to == "object" ? P({}, A, _.to.state) : A,
+            force: O
+          }), d || S);
+      } else _ = Ae(S, m, !0, E, A);
+      return Ee(S, m, _), _;
+    });
+  }
+  function Qe(n, d) {
+    const f = x(n, d);
+    return f ? Promise.reject(f) : Promise.resolve();
+  }
+  function ie(n) {
+    const d = ee.values().next().value;
+    return d && typeof d.runWithContext == "function" ? d.runWithContext(n) : n();
+  }
+  function Re(n, d) {
+    let f;
+    const [m, A, O] = it(n, d);
+    f = me(m.reverse(), "beforeRouteLeave", n, d);
+    for (const y of m) y.leaveGuards.forEach((S) => {
+      f.push(W(S, n, d));
+    });
+    const E = Qe.bind(null, n, d);
+    return f.push(E), H(f).then(() => {
+      f = [];
+      for (const y of p.list()) f.push(W(y, n, d));
+      return f.push(E), H(f);
+    }).then(() => {
+      f = me(A, "beforeRouteUpdate", n, d);
+      for (const y of A) y.updateGuards.forEach((S) => {
+        f.push(W(S, n, d));
+      });
+      return f.push(E), H(f);
+    }).then(() => {
+      f = [];
+      for (const y of O) if (y.beforeEnter) if (ne(y.beforeEnter)) for (const S of y.beforeEnter) f.push(W(S, n, d));
+      else f.push(W(y.beforeEnter, n, d));
+      return f.push(E), H(f);
+    }).then(() => (n.matched.forEach((y) => y.enterCallbacks = {}), f = me(O, "beforeRouteEnter", n, d, ie), f.push(E), H(f))).then(() => {
+      f = [];
+      for (const y of g.list()) f.push(W(y, n, d));
+      return f.push(E), H(f);
+    }).catch((y) => B(y, I.NAVIGATION_CANCELLED) ? y : Promise.reject(y));
+  }
+  function Ee(n, d, f) {
+    v.list().forEach((m) => ie(() => m(n, d, f)));
+  }
+  function Ae(n, d, f, m, A) {
+    const O = x(n, d);
+    if (O) return O;
+    const E = d === j, y = Q ? history.state : {};
+    f && (m || E ? s.replace(n.fullPath, P({ scroll: E && y && y.scroll }, A)) : s.push(n.fullPath, A)), l.value = n, Pe(n, d, f, E), ce();
+  }
+  let K;
+  function Ze() {
+    K || (K = s.listen((n, d, f) => {
+      if (!F.listening) return;
+      const m = N(n), A = M(m, F.currentRoute.value);
+      if (A) {
+        L(P(A, {
+          replace: !0,
+          force: !0
+        }), m).catch(J);
+        return;
+      }
+      h = m;
+      const O = l.value;
+      Q && st(Ce(O.fullPath, f.delta), re()), Re(m, O).catch((E) => B(E, I.NAVIGATION_ABORTED | I.NAVIGATION_CANCELLED) ? E : B(E, I.NAVIGATION_GUARD_REDIRECT) ? (L(P(R(E.to), { force: !0 }), m).then((y) => {
+        B(y, I.NAVIGATION_ABORTED | I.NAVIGATION_DUPLICATED) && !f.delta && f.type === te.pop && s.go(-1, !1);
+      }).catch(J), Promise.reject()) : (f.delta && s.go(-f.delta, !1), le(E, m, O))).then((E) => {
+        E = E || Ae(m, O, !1), E && (f.delta && !B(E, I.NAVIGATION_CANCELLED) ? s.go(-f.delta, !1) : f.type === te.pop && B(E, I.NAVIGATION_ABORTED | I.NAVIGATION_DUPLICATED) && s.go(-1, !1)), Ee(m, O, E);
+      }).catch(J);
+    }));
+  }
+  let se = z(), be = z(), Y;
+  function le(n, d, f) {
+    ce(n);
+    const m = be.list();
+    return m.length ? m.forEach((A) => A(n, d, f)) : console.error(n), Promise.reject(n);
+  }
+  function Je() {
+    return Y && l.value !== j ? Promise.resolve() : new Promise((n, d) => {
+      se.add([n, d]);
+    });
+  }
+  function ce(n) {
+    return Y || (Y = !n, Ze(), se.list().forEach(([d, f]) => n ? f(n) : d()), se.reset()), n;
+  }
+  function Pe(n, d, f, m) {
+    const { scrollBehavior: A } = e;
+    if (!Q || !A) return Promise.resolve();
+    const O = !f && lt(Ce(n.fullPath, 0)) || (m || !f) && history.state && history.state.scroll || null;
+    return pt().then(() => A(n, d, O)).then((E) => E && ct(E)).catch((E) => le(E, n, d));
+  }
+  const ue = (n) => s.go(n);
+  let fe;
+  const ee = /* @__PURE__ */ new Set(), F = {
+    currentRoute: l,
+    listening: !0,
+    addRoute: i,
+    removeRoute: w,
+    clearRoutes: a.clearRoutes,
+    hasRoute: k,
+    getRoutes: b,
+    resolve: N,
+    options: e,
+    push: D,
+    replace: G,
+    go: ue,
+    back: () => ue(-1),
+    forward: () => ue(1),
+    beforeEach: p.add,
+    beforeResolve: g.add,
+    afterEach: v.add,
+    onError: be.add,
+    isReady: Je,
+    install(n) {
+      n.component("RouterLink", $t), n.component("RouterView", jt), n.config.globalProperties.$router = F, Object.defineProperty(n.config.globalProperties, "$route", {
+        enumerable: !0,
+        get: () => X(l)
+      }), Q && !fe && l.value === j && (fe = !0, D(s.location).catch((m) => {
+      }));
+      const d = {};
+      for (const m in j) Object.defineProperty(d, m, {
+        get: () => l.value[m],
+        enumerable: !0
+      });
+      n.provide(oe, F), n.provide(we, mt(d)), n.provide(ye, l);
+      const f = n.unmount;
+      ee.add(n), n.unmount = function() {
+        ee.delete(n), ee.size < 1 && (h = j, K && K(), K = null, l.value = j, fe = !1, Y = !1), f();
+      };
+    }
+  };
+  function H(n) {
+    return n.reduce((d, f) => d.then(() => ie(f)), Promise.resolve());
+  }
+  return F;
+}
+function Jt() {
+  return U(oe);
+}
+function Xt(e) {
+  return U(we);
 }
 export {
-  f as matchedRouteKey,
-  n as onBeforeRouteLeave,
-  e as routerKey,
-  u as useRouter
+  tn as NavigationFailureType,
+  $t as RouterLink,
+  jt as RouterView,
+  j as START_LOCATION,
+  zt as createMemoryHistory,
+  Zt as createRouter,
+  St as createRouterMatcher,
+  Qt as createWebHashHistory,
+  wt as createWebHistory,
+  B as isNavigationFailure,
+  nn as loadRouteLocation,
+  Ye as matchedRouteKey,
+  an as onBeforeRouteLeave,
+  rn as onBeforeRouteUpdate,
+  et as parseQuery,
+  we as routeLocationKey,
+  oe as routerKey,
+  ye as routerViewLocationKey,
+  Oe as stringifyQuery,
+  Be as useLink,
+  Xt as useRoute,
+  Jt as useRouter,
+  Ne as viewDepthKey
 };