likec4 1.18.0 → 1.19.0

package/__app__/src/chunks/tanstack-router-BBWuTKWO.js

@@ -0,0 +1,2373 @@
+import { jsxs as yt, jsx as _, Fragment as Vt } from "react/jsx-runtime";
+import * as L from "react";
+import { flushSync as ae } from "react-dom";
+import { w as ce } from "./likec4-CusAw_j6.js";
+const Nt = "pushstate", $t = "popstate", qt = "beforeunload", Xt = (t) => (t.preventDefault(), t.returnValue = ""), le = () => {
+  removeEventListener(qt, Xt, {
+    capture: !0
+  });
+};
+function Gt(t) {
+  let n = t.getLocation();
+  const e = /* @__PURE__ */ new Set();
+  let o = [];
+  const r = () => {
+    n = t.getLocation(), e.forEach((s) => s());
+  }, a = async (s, i) => {
+    var l;
+    if (!(i?.ignoreBlocker ?? !1) && typeof document < "u" && o.length) {
+      for (const u of o)
+        if (!await u()) {
+          (l = t.onBlocked) == null || l.call(t, r);
+          return;
+        }
+    }
+    s();
+  };
+  return {
+    get location() {
+      return n;
+    },
+    subscribers: e,
+    subscribe: (s) => (e.add(s), () => {
+      e.delete(s);
+    }),
+    push: (s, i, l) => {
+      i = ft(i), a(() => {
+        t.pushState(s, i), r();
+      }, l);
+    },
+    replace: (s, i, l) => {
+      i = ft(i), a(() => {
+        t.replaceState(s, i), r();
+      }, l);
+    },
+    go: (s, i) => {
+      a(() => {
+        t.go(s), r();
+      }, i);
+    },
+    back: (s) => {
+      a(() => {
+        t.back(), r();
+      }, s);
+    },
+    forward: (s) => {
+      a(() => {
+        t.forward(), r();
+      }, s);
+    },
+    createHref: (s) => t.createHref(s),
+    block: (s) => (o.push(s), o.length === 1 && addEventListener(qt, Xt, {
+      capture: !0
+    }), () => {
+      o = o.filter((i) => i !== s), o.length || le();
+    }),
+    flush: () => {
+      var s;
+      return (s = t.flush) == null ? void 0 : s.call(t);
+    },
+    destroy: () => {
+      var s;
+      return (s = t.destroy) == null ? void 0 : s.call(t);
+    },
+    notify: r
+  };
+}
+function ft(t) {
+  return t || (t = {}), {
+    ...t,
+    key: Yt()
+  };
+}
+function Jt(t) {
+  const n = t?.window ?? (typeof document < "u" ? window : void 0), e = n.history.pushState, o = n.history.replaceState, r = t?.createHref ?? ((p) => p), a = t?.parseLocation ?? (() => _t(
+    `${n.location.pathname}${n.location.search}${n.location.hash}`,
+    n.history.state
+  ));
+  let s = a(), i;
+  const l = () => s;
+  let c, u;
+  const d = () => {
+    if (!c)
+      return;
+    (c.isPush ? e : o).call(n.history, c.state, "", c.href), c = void 0, u = void 0, i = void 0;
+  }, h = (p, v, S) => {
+    const b = r(v);
+    u || (i = s), s = _t(v, S), c = {
+      href: b,
+      state: S,
+      isPush: c?.isPush || p === "push"
+    }, u || (u = Promise.resolve().then(() => d()));
+  }, f = () => {
+    s = a(), m.notify();
+  }, m = Gt({
+    getLocation: l,
+    pushState: (p, v) => h("push", p, v),
+    replaceState: (p, v) => h("replace", p, v),
+    back: () => n.history.back(),
+    forward: () => n.history.forward(),
+    go: (p) => n.history.go(p),
+    createHref: (p) => r(p),
+    flush: d,
+    destroy: () => {
+      n.history.pushState = e, n.history.replaceState = o, n.removeEventListener(Nt, f), n.removeEventListener($t, f);
+    },
+    onBlocked: (p) => {
+      i && s !== i && (s = i, p());
+    }
+  });
+  return n.addEventListener(Nt, f), n.addEventListener($t, f), n.history.pushState = function(...p) {
+    const v = e.apply(n.history, p);
+    return f(), v;
+  }, n.history.replaceState = function(...p) {
+    const v = o.apply(n.history, p);
+    return f(), v;
+  }, m;
+}
+function co(t) {
+  const n = typeof document < "u" ? window : void 0;
+  return Jt({
+    window: n,
+    parseLocation: () => {
+      const e = n.location.hash.split("#").slice(1).join("#") ?? "/";
+      return _t(e, n.history.state);
+    },
+    createHref: (e) => `${n.location.pathname}${n.location.search}#${e}`
+  });
+}
+function ue(t = {
+  initialEntries: ["/"]
+}) {
+  const n = t.initialEntries;
+  let e = t.initialIndex ?? n.length - 1, o = {
+    key: Yt()
+  };
+  return Gt({
+    getLocation: () => _t(n[e], o),
+    pushState: (a, s) => {
+      o = s, n.splice, e < n.length - 1 && n.splice(e + 1), n.push(a), e = Math.max(n.length - 1, 0);
+    },
+    replaceState: (a, s) => {
+      o = s, n[e] = a;
+    },
+    back: () => {
+      o = ft(o), e = Math.max(e - 1, 0);
+    },
+    forward: () => {
+      o = ft(o), e = Math.min(e + 1, n.length - 1);
+    },
+    go: (a) => {
+      o = ft(o), e = Math.min(Math.max(e + a, 0), n.length - 1);
+    },
+    createHref: (a) => a
+  });
+}
+function _t(t, n) {
+  const e = t.indexOf("#"), o = t.indexOf("?");
+  return {
+    href: t,
+    pathname: t.substring(
+      0,
+      e > 0 ? o > 0 ? Math.min(e, o) : e : o > 0 ? o : t.length
+    ),
+    hash: e > -1 ? t.substring(e) : "",
+    search: o > -1 ? t.slice(o, e === -1 ? void 0 : e) : "",
+    state: n || {}
+  };
+}
+function Yt() {
+  return (Math.random() + 1).toString(36).substring(7);
+}
+var de = !0, Et = "Invariant failed";
+function H(t, n) {
+  if (!t) {
+    if (de)
+      throw new Error(Et);
+    var e = typeof n == "function" ? n() : n, o = e ? "".concat(Et, ": ").concat(e) : Et;
+    throw new Error(o);
+  }
+}
+var he = !0;
+function ut(t, n) {
+  if (!he) {
+    if (t)
+      return;
+    var e = "Warning: " + n;
+    typeof console < "u" && console.warn(e);
+    try {
+      throw Error(e);
+    } catch {
+    }
+  }
+}
+const xt = L.createContext(null);
+function Qt() {
+  return typeof document > "u" ? xt : window.__TSR_ROUTER_CONTEXT__ ? window.__TSR_ROUTER_CONTEXT__ : (window.__TSR_ROUTER_CONTEXT__ = xt, xt);
+}
+function tt(t) {
+  const n = L.useContext(Qt());
+  return ut(
+    !((t?.warn ?? !0) && !n),
+    "useRouter must be used inside a <RouterProvider> component!"
+  ), n;
+}
+class fe {
+  constructor(n, e) {
+    this.listeners = /* @__PURE__ */ new Set(), this._batching = !1, this._flushing = 0, this.subscribe = (o) => {
+      var r, a;
+      this.listeners.add(o);
+      const s = (a = (r = this.options) == null ? void 0 : r.onSubscribe) == null ? void 0 : a.call(r, o, this);
+      return () => {
+        this.listeners.delete(o), s?.();
+      };
+    }, this.setState = (o) => {
+      var r, a, s;
+      const i = this.state;
+      this.state = (r = this.options) != null && r.updateFn ? this.options.updateFn(i)(o) : o(i), (s = (a = this.options) == null ? void 0 : a.onUpdate) == null || s.call(a), this._flush();
+    }, this._flush = () => {
+      if (this._batching) return;
+      const o = ++this._flushing;
+      this.listeners.forEach((r) => {
+        this._flushing === o && r();
+      });
+    }, this.batch = (o) => {
+      if (this._batching) return o();
+      this._batching = !0, o(), this._batching = !1, this._flush();
+    }, this.state = n, this.options = e;
+  }
+}
+function pe(t, n = (e) => e) {
+  return ce.useSyncExternalStoreWithSelector(
+    t.subscribe,
+    () => t.state,
+    () => t.state,
+    n,
+    me
+  );
+}
+function me(t, n) {
+  if (Object.is(t, n))
+    return !0;
+  if (typeof t != "object" || t === null || typeof n != "object" || n === null)
+    return !1;
+  const e = Object.keys(t);
+  if (e.length !== Object.keys(n).length)
+    return !1;
+  for (let o = 0; o < e.length; o++)
+    if (!Object.prototype.hasOwnProperty.call(n, e[o]) || !Object.is(t[e[o]], n[e[o]]))
+      return !1;
+  return !0;
+}
+const W = "__root__";
+function ve(t, n) {
+  let e, o, r, a = "";
+  for (e in t)
+    if ((r = t[e]) !== void 0)
+      if (Array.isArray(r))
+        for (o = 0; o < r.length; o++)
+          a && (a += "&"), a += encodeURIComponent(e) + "=" + encodeURIComponent(r[o]);
+      else
+        a && (a += "&"), a += encodeURIComponent(e) + "=" + encodeURIComponent(r);
+  return "" + a;
+}
+function At(t) {
+  if (!t) return "";
+  const n = decodeURIComponent(t);
+  return n === "false" ? !1 : n === "true" ? !0 : +n * 0 === 0 && +n + "" === n ? +n : n;
+}
+function ge(t, n) {
+  let e, o;
+  const r = {}, a = t.split("&");
+  for (; e = a.shift(); ) {
+    const s = e.indexOf("=");
+    if (s !== -1) {
+      o = e.slice(0, s);
+      const i = e.slice(s + 1);
+      r[o] !== void 0 ? r[o] = [].concat(r[o], At(i)) : r[o] = At(i);
+    } else
+      o = e, r[o] = "";
+  }
+  return r;
+}
+const ye = Se(JSON.parse), _e = Pe(
+  JSON.stringify,
+  JSON.parse
+);
+function Se(t) {
+  return (n) => {
+    n.substring(0, 1) === "?" && (n = n.substring(1));
+    const e = ge(n);
+    for (const o in e) {
+      const r = e[o];
+      if (typeof r == "string")
+        try {
+          e[o] = t(r);
+        } catch {
+        }
+    }
+    return e;
+  };
+}
+function Pe(t, n) {
+  function e(o) {
+    if (typeof o == "object" && o !== null)
+      try {
+        return t(o);
+      } catch {
+      }
+    else if (typeof o == "string" && typeof n == "function")
+      try {
+        return n(o), t(o);
+      } catch {
+      }
+    return o;
+  }
+  return (o) => {
+    o = { ...o }, Object.keys(o).forEach((a) => {
+      const s = o[a];
+      typeof s > "u" || s === void 0 ? delete o[a] : o[a] = e(s);
+    });
+    const r = ve(o).toString();
+    return r ? `?${r}` : "";
+  };
+}
+function St(t) {
+  return t[t.length - 1];
+}
+function we(t) {
+  return typeof t == "function";
+}
+function it(t, n) {
+  return we(t) ? t(n) : t;
+}
+function pt(t, n) {
+  return n.reduce((e, o) => (e[o] = t[o], e), {});
+}
+function Y(t, n) {
+  if (t === n)
+    return t;
+  const e = n, o = jt(t) && jt(e);
+  if (o || Pt(t) && Pt(e)) {
+    const r = o ? t : Object.keys(t), a = r.length, s = o ? e : Object.keys(e), i = s.length, l = o ? [] : {};
+    let c = 0;
+    for (let u = 0; u < i; u++) {
+      const d = o ? u : s[u];
+      (!o && r.includes(d) || o) && t[d] === void 0 && e[d] === void 0 ? (l[d] = void 0, c++) : (l[d] = Y(t[d], e[d]), l[d] === t[d] && t[d] !== void 0 && c++);
+    }
+    return a === i && c === a ? t : l;
+  }
+  return e;
+}
+function Pt(t) {
+  if (!Kt(t))
+    return !1;
+  const n = t.constructor;
+  if (typeof n > "u")
+    return !0;
+  const e = n.prototype;
+  return !(!Kt(e) || !e.hasOwnProperty("isPrototypeOf"));
+}
+function Kt(t) {
+  return Object.prototype.toString.call(t) === "[object Object]";
+}
+function jt(t) {
+  return Array.isArray(t) && t.length === Object.keys(t).length;
+}
+function lt(t, n, e = !1) {
+  if (t === n)
+    return !0;
+  if (typeof t != typeof n)
+    return !1;
+  if (Pt(t) && Pt(n)) {
+    const o = Object.keys(t).filter((a) => t[a] !== void 0), r = Object.keys(n).filter((a) => n[a] !== void 0);
+    return !e && o.length !== r.length ? !1 : !r.some(
+      (a) => !(a in t) || !lt(t[a], n[a], e)
+    );
+  }
+  return Array.isArray(t) && Array.isArray(n) ? t.length !== n.length ? !1 : !t.some((o, r) => !lt(o, n[r], e)) : !1;
+}
+const It = typeof window < "u" ? L.useLayoutEffect : L.useEffect;
+function ct(t) {
+  let n, e;
+  const o = new Promise((r, a) => {
+    n = r, e = a;
+  });
+  return o.status = "pending", o.resolve = (r) => {
+    o.status = "resolved", o.value = r, n(r), t?.(r);
+  }, o.reject = (r) => {
+    o.status = "rejected", e(r);
+  }, o;
+}
+function Dt(t) {
+  const n = L.useRef({
+    value: t,
+    prev: null
+  }), e = n.current.value;
+  return t !== e && (n.current = {
+    value: t,
+    prev: e
+  }), n.current.prev;
+}
+function nt(t) {
+  return bt(
+    t.filter((n) => n !== void 0).join("/")
+  );
+}
+function bt(t) {
+  return t.replace(/\/{2,}/g, "/");
+}
+function Ot(t) {
+  return t === "/" ? t : t.replace(/^\/{1,}/, "");
+}
+function at(t) {
+  return t === "/" ? t : t.replace(/\/{1,}$/, "");
+}
+function Re(t) {
+  return at(Ot(t));
+}
+function wt(t, n) {
+  return t.endsWith("/") && t !== "/" && t !== `${n}/` ? t.slice(0, -1) : t;
+}
+function be(t, n, e) {
+  return wt(t, e) === wt(n, e);
+}
+function Le({
+  basepath: t,
+  base: n,
+  to: e,
+  trailingSlash: o = "never"
+}) {
+  var r, a;
+  n = Rt(t, n), e = Rt(t, e);
+  let s = dt(n);
+  const i = dt(e);
+  s.length > 1 && ((r = St(s)) == null ? void 0 : r.value) === "/" && s.pop(), i.forEach((c, u) => {
+    c.value === "/" ? u ? u === i.length - 1 && s.push(c) : s = [c] : c.value === ".." ? s.pop() : c.value === "." || s.push(c);
+  }), s.length > 1 && (((a = St(s)) == null ? void 0 : a.value) === "/" ? o === "never" && s.pop() : o === "always" && s.push({ type: "pathname", value: "/" }));
+  const l = nt([t, ...s.map((c) => c.value)]);
+  return bt(l);
+}
+function dt(t) {
+  if (!t)
+    return [];
+  t = bt(t);
+  const n = [];
+  if (t.slice(0, 1) === "/" && (t = t.substring(1), n.push({
+    type: "pathname",
+    value: "/"
+  })), !t)
+    return n;
+  const e = t.split("/").filter(Boolean);
+  return n.push(
+    ...e.map((o) => o === "$" || o === "*" ? {
+      type: "wildcard",
+      value: o
+    } : o.charAt(0) === "$" ? {
+      type: "param",
+      value: o
+    } : {
+      type: "pathname",
+      value: decodeURIComponent(o)
+    })
+  ), t.slice(-1) === "/" && (t = t.substring(1), n.push({
+    type: "pathname",
+    value: "/"
+  })), n;
+}
+function Tt({
+  path: t,
+  params: n,
+  leaveWildcards: e,
+  leaveParams: o
+}) {
+  const r = dt(t), a = {};
+  for (const [s, i] of Object.entries(n)) {
+    const l = typeof i == "string";
+    ["*", "_splat"].includes(s) ? a[s] = l ? encodeURI(i) : i : a[s] = l ? encodeURIComponent(i) : i;
+  }
+  return nt(
+    r.map((s) => {
+      if (s.type === "wildcard") {
+        const i = a._splat;
+        return e ? `${s.value}${i ?? ""}` : i;
+      }
+      if (s.type === "param") {
+        if (o) {
+          const i = a[s.value];
+          return `${s.value}${i ?? ""}`;
+        }
+        return a[s.value.substring(1)] ?? "undefined";
+      }
+      return s.value;
+    })
+  );
+}
+function vt(t, n, e) {
+  const o = Ce(t, n, e);
+  if (!(e.to && !o))
+    return o ?? {};
+}
+function Rt(t, n) {
+  switch (!0) {
+    case t === "/":
+      return n;
+    case n === t:
+      return "";
+    case n.length < t.length:
+      return n;
+    case n[t.length] !== "/":
+      return n;
+    case n.startsWith(t):
+      return n.slice(t.length);
+    default:
+      return n;
+  }
+}
+function Ce(t, n, e) {
+  n = Rt(t, n);
+  const o = Rt(t, `${e.to ?? "$"}`), r = dt(n), a = dt(o);
+  n.startsWith("/") || r.unshift({
+    type: "pathname",
+    value: "/"
+  }), o.startsWith("/") || a.unshift({
+    type: "pathname",
+    value: "/"
+  });
+  const s = {};
+  return (() => {
+    for (let l = 0; l < Math.max(r.length, a.length); l++) {
+      const c = r[l], u = a[l], d = l >= r.length - 1, h = l >= a.length - 1;
+      if (u) {
+        if (u.type === "wildcard") {
+          if (c?.value) {
+            const f = decodeURI(
+              nt(r.slice(l).map((m) => m.value))
+            );
+            return s["*"] = f, s._splat = f, !0;
+          }
+          return !1;
+        }
+        if (u.type === "pathname") {
+          if (u.value === "/" && !c?.value)
+            return !0;
+          if (c) {
+            if (e.caseSensitive) {
+              if (u.value !== c.value)
+                return !1;
+            } else if (u.value.toLowerCase() !== c.value.toLowerCase())
+              return !1;
+          }
+        }
+        if (!c)
+          return !1;
+        if (u.type === "param") {
+          if (c.value === "/")
+            return !1;
+          c.value.charAt(0) !== "$" && (s[u.value.substring(1)] = decodeURIComponent(
+            c.value
+          ));
+        }
+      }
+      if (!d && h)
+        return s["**"] = nt(r.slice(l + 1).map((f) => f.value)), !!e.fuzzy && u?.value !== "/";
+    }
+    return !0;
+  })() ? s : void 0;
+}
+function st(t) {
+  return !!t?.isRedirect;
+}
+function zt(t) {
+  return !!t?.isRedirect && t.href;
+}
+function Bt(t) {
+  const n = t.errorComponent ?? Lt;
+  return /* @__PURE__ */ _(
+    Me,
+    {
+      getResetKey: t.getResetKey,
+      onCatch: t.onCatch,
+      children: ({ error: e, reset: o }) => e ? L.createElement(n, {
+        error: e,
+        reset: o
+      }) : t.children
+    }
+  );
+}
+class Me extends L.Component {
+  constructor() {
+    super(...arguments), this.state = { error: null };
+  }
+  static getDerivedStateFromProps(n) {
+    return { resetKey: n.getResetKey() };
+  }
+  static getDerivedStateFromError(n) {
+    return { error: n };
+  }
+  reset() {
+    this.setState({ error: null });
+  }
+  componentDidUpdate(n, e) {
+    e.error && e.resetKey !== this.state.resetKey && this.reset();
+  }
+  componentDidCatch(n, e) {
+    this.props.onCatch && this.props.onCatch(n, e);
+  }
+  render() {
+    return this.props.children({
+      error: this.state.resetKey !== this.props.getResetKey() ? null : this.state.error,
+      reset: () => {
+        this.reset();
+      }
+    });
+  }
+}
+function Lt({ error: t }) {
+  const [n, e] = L.useState(!1);
+  return /* @__PURE__ */ yt("div", { style: { padding: ".5rem", maxWidth: "100%" }, children: [
+    /* @__PURE__ */ yt("div", { style: { display: "flex", alignItems: "center", gap: ".5rem" }, children: [
+      /* @__PURE__ */ _("strong", { style: { fontSize: "1rem" }, children: "Something went wrong!" }),
+      /* @__PURE__ */ _(
+        "button",
+        {
+          style: {
+            appearance: "none",
+            fontSize: ".6em",
+            border: "1px solid currentColor",
+            padding: ".1rem .2rem",
+            fontWeight: "bold",
+            borderRadius: ".25rem"
+          },
+          onClick: () => e((o) => !o),
+          children: n ? "Hide Error" : "Show Error"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ _("div", { style: { height: ".25rem" } }),
+    n ? /* @__PURE__ */ _("div", { children: /* @__PURE__ */ _(
+      "pre",
+      {
+        style: {
+          fontSize: ".7em",
+          border: "1px solid red",
+          borderRadius: ".25rem",
+          padding: ".3rem",
+          color: "red",
+          overflow: "auto"
+        },
+        children: t.message ? /* @__PURE__ */ _("code", { children: t.message }) : null
+      }
+    ) }) : null
+  ] });
+}
+function D(t) {
+  const n = tt({
+    warn: t?.router === void 0
+  });
+  return pe((t?.router || n).__store, t?.select);
+}
+function lo(t = {}) {
+  if (t.isNotFound = !0, t.throw) throw t;
+  return t;
+}
+function Q(t) {
+  return !!t?.isNotFound;
+}
+function Ee(t) {
+  const n = D({
+    select: (e) => `not-found-${e.location.pathname}-${e.status}`
+  });
+  return /* @__PURE__ */ _(
+    Bt,
+    {
+      getResetKey: () => n,
+      onCatch: (e, o) => {
+        var r;
+        if (Q(e))
+          (r = t.onCatch) == null || r.call(t, e, o);
+        else
+          throw e;
+      },
+      errorComponent: ({ error: e }) => {
+        var o;
+        return (o = t.fallback) == null ? void 0 : o.call(t, e);
+      },
+      children: t.children
+    }
+  );
+}
+function xe() {
+  return /* @__PURE__ */ _("p", { children: "Not Found" });
+}
+const Ie = [
+  "component",
+  "errorComponent",
+  "pendingComponent",
+  "notFoundComponent"
+];
+function uo(t) {
+  return new Te(t);
+}
+class Te {
+  /**
+   * @deprecated Use the `createRouter` function instead
+   */
+  constructor(n) {
+    this.tempLocationKey = `${Math.round(
+      Math.random() * 1e7
+    )}`, this.resetNextScroll = !0, this.shouldViewTransition = void 0, this.subscribers = /* @__PURE__ */ new Set(), this.startReactTransition = (e) => e(), this.update = (e) => {
+      e.notFoundRoute && console.warn(
+        "The notFoundRoute API is deprecated and will be removed in the next major version. See https://tanstack.com/router/v1/docs/guide/not-found-errors#migrating-from-notfoundroute for more info."
+      );
+      const o = this.options;
+      this.options = {
+        ...this.options,
+        ...e
+      }, this.isServer = this.options.isServer ?? typeof document > "u", (!this.basepath || e.basepath && e.basepath !== o.basepath) && (e.basepath === void 0 || e.basepath === "" || e.basepath === "/" ? this.basepath = "/" : this.basepath = `/${Re(e.basepath)}`), // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      (!this.history || this.options.history && this.options.history !== this.history) && (this.history = this.options.history ?? (this.isServer ? ue({
+        initialEntries: [this.basepath || "/"]
+      }) : Jt()), this.latestLocation = this.parseLocation()), this.options.routeTree !== this.routeTree && (this.routeTree = this.options.routeTree, this.buildRouteTree()), this.__store || (this.__store = new fe(Oe(this.latestLocation), {
+        onUpdate: () => {
+          this.__store.state = {
+            ...this.state,
+            cachedMatches: this.state.cachedMatches.filter(
+              (r) => !["redirected"].includes(r.status)
+            )
+          };
+        }
+      }));
+    }, this.buildRouteTree = () => {
+      this.routesById = {}, this.routesByPath = {};
+      const e = this.options.notFoundRoute;
+      e && (e.init({ originalIndex: 99999999999 }), this.routesById[e.id] = e);
+      const o = (s) => {
+        s.forEach((i, l) => {
+          i.init({ originalIndex: l });
+          const c = this.routesById[i.id];
+          if (H(
+            !c,
+            `Duplicate routes found with id: ${String(i.id)}`
+          ), this.routesById[i.id] = i, !i.isRoot && i.path) {
+            const d = at(i.fullPath);
+            (!this.routesByPath[d] || i.fullPath.endsWith("/")) && (this.routesByPath[d] = i);
+          }
+          const u = i.children;
+          u?.length && o(u);
+        });
+      };
+      o([this.routeTree]);
+      const r = [];
+      Object.values(this.routesById).forEach((s, i) => {
+        var l;
+        if (s.isRoot || !s.path)
+          return;
+        const c = Ot(s.fullPath), u = dt(c);
+        for (; u.length > 1 && ((l = u[0]) == null ? void 0 : l.value) === "/"; )
+          u.shift();
+        const d = u.map((h) => h.value === "/" ? 0.75 : h.type === "param" ? 0.5 : h.type === "wildcard" ? 0.25 : 1);
+        r.push({ child: s, trimmed: c, parsed: u, index: i, scores: d });
+      }), this.flatRoutes = r.sort((s, i) => {
+        const l = Math.min(s.scores.length, i.scores.length);
+        for (let c = 0; c < l; c++)
+          if (s.scores[c] !== i.scores[c])
+            return i.scores[c] - s.scores[c];
+        if (s.scores.length !== i.scores.length)
+          return i.scores.length - s.scores.length;
+        for (let c = 0; c < l; c++)
+          if (s.parsed[c].value !== i.parsed[c].value)
+            return s.parsed[c].value > i.parsed[c].value ? 1 : -1;
+        return s.index - i.index;
+      }).map((s, i) => (s.child.rank = i, s.child));
+    }, this.subscribe = (e, o) => {
+      const r = {
+        eventType: e,
+        fn: o
+      };
+      return this.subscribers.add(r), () => {
+        this.subscribers.delete(r);
+      };
+    }, this.emit = (e) => {
+      this.subscribers.forEach((o) => {
+        o.eventType === e.type && o.fn(e);
+      });
+    }, this.parseLocation = (e) => {
+      const o = ({
+        pathname: i,
+        search: l,
+        hash: c,
+        state: u
+      }) => {
+        const d = this.options.parseSearch(l), h = this.options.stringifySearch(d);
+        return {
+          pathname: i,
+          searchStr: h,
+          search: Y(e?.search, d),
+          hash: c.split("#").reverse()[0] ?? "",
+          href: `${i}${h}${c}`,
+          state: Y(e?.state, u)
+        };
+      }, r = o(this.history.location), { __tempLocation: a, __tempKey: s } = r.state;
+      if (a && (!s || s === this.tempLocationKey)) {
+        const i = o(a);
+        return i.state.key = r.state.key, delete i.state.__tempLocation, {
+          ...i,
+          maskedLocation: r
+        };
+      }
+      return r;
+    }, this.resolvePathWithBase = (e, o) => Le({
+      basepath: this.basepath,
+      base: e,
+      to: bt(o),
+      trailingSlash: this.options.trailingSlash
+    }), this.matchRoutes = (e, o, r) => {
+      let a = {};
+      const s = this.flatRoutes.find((f) => {
+        const m = vt(
+          this.basepath,
+          at(e),
+          {
+            to: f.fullPath,
+            caseSensitive: f.options.caseSensitive ?? this.options.caseSensitive,
+            fuzzy: !0
+          }
+        );
+        return m ? (a = m, !0) : !1;
+      });
+      let i = s || this.routesById[W];
+      const l = [i];
+      let c = !1;
+      for (// If we found a route, and it's not an index route and we have left over path
+      (s ? s.path !== "/" && a["**"] : (
+        // Or if we didn't find a route and we have left over path
+        at(e)
+      )) && (this.options.notFoundRoute ? l.push(this.options.notFoundRoute) : c = !0); i.parentRoute; )
+        i = i.parentRoute, l.unshift(i);
+      const u = (() => {
+        if (c) {
+          if (this.options.notFoundMode !== "root")
+            for (let f = l.length - 1; f >= 0; f--) {
+              const m = l[f];
+              if (m.children)
+                return m.id;
+            }
+          return W;
+        }
+      })(), d = l.map((f) => {
+        var m;
+        let p;
+        const v = ((m = f.options.params) == null ? void 0 : m.parse) ?? f.options.parseParams;
+        if (v)
+          try {
+            const S = v(a);
+            Object.assign(a, S);
+          } catch (S) {
+            if (p = new ke(S.message, {
+              cause: S
+            }), r?.throwOnError)
+              throw p;
+            return p;
+          }
+      }), h = [];
+      return l.forEach((f, m) => {
+        var p, v, S, b, g, P, M, k, w, y;
+        const N = h[m - 1], [A, B] = (() => {
+          const x = N?.search ?? o;
+          try {
+            const j = typeof f.options.validateSearch == "object" ? f.options.validateSearch.parse : f.options.validateSearch, z = j?.(x) ?? {};
+            return [
+              {
+                ...x,
+                ...z
+              },
+              void 0
+            ];
+          } catch (j) {
+            const z = new Fe(j.message, {
+              cause: j
+            });
+            if (r?.throwOnError)
+              throw z;
+            return [x, z];
+          }
+        })(), T = ((v = (p = f.options).loaderDeps) == null ? void 0 : v.call(p, {
+          search: A
+        })) ?? "", R = T ? JSON.stringify(T) : "", O = Tt({
+          path: f.fullPath,
+          params: a
+        }), $ = Tt({
+          path: f.id,
+          params: a,
+          leaveWildcards: !0
+        }) + R, K = this.getMatch($), J = this.state.matches.find((x) => x.id === $) ? "stay" : "enter";
+        let E;
+        if (K)
+          E = {
+            ...K,
+            cause: J,
+            params: a
+          };
+        else {
+          const x = f.options.loader || f.options.beforeLoad || f.lazyFn ? "pending" : "success";
+          E = {
+            id: $,
+            index: m,
+            routeId: f.id,
+            params: a,
+            pathname: nt([this.basepath, O]),
+            updatedAt: Date.now(),
+            search: {},
+            searchError: void 0,
+            status: x,
+            isFetching: !1,
+            error: void 0,
+            paramsError: d[m],
+            routeContext: void 0,
+            context: void 0,
+            abortController: new AbortController(),
+            fetchCount: 0,
+            cause: J,
+            loaderDeps: T,
+            invalid: !1,
+            preload: !1,
+            links: (b = (S = f.options).links) == null ? void 0 : b.call(S),
+            scripts: (P = (g = f.options).scripts) == null ? void 0 : P.call(g),
+            staticData: f.options.staticData || {},
+            loadPromise: ct()
+          };
+        }
+        E.status === "success" && (E.meta = (k = (M = f.options).meta) == null ? void 0 : k.call(M, {
+          matches: h,
+          match: E,
+          params: E.params,
+          loaderData: E.loaderData
+        }), E.headers = (y = (w = f.options).headers) == null ? void 0 : y.call(w, {
+          loaderData: E.loaderData
+        })), r?.preload || (E.globalNotFound = u === f.id), E.search = Y(E.search, A), E.searchError = B, h.push(E);
+      }), h;
+    }, this.cancelMatch = (e) => {
+      const o = this.getMatch(e);
+      o && (o.abortController.abort(), clearTimeout(o.pendingTimeout));
+    }, this.cancelMatches = () => {
+      var e;
+      (e = this.state.pendingMatches) == null || e.forEach((o) => {
+        this.cancelMatch(o.id);
+      });
+    }, this.buildLocation = (e) => {
+      const o = (a = {}, s) => {
+        var i, l, c;
+        const u = a._fromLocation != null ? this.matchRoutes(
+          a._fromLocation.pathname,
+          a.fromSearch || a._fromLocation.search
+        ) : this.state.matches, d = a.from != null ? u.find(
+          (R) => vt(this.basepath, at(R.pathname), {
+            to: a.from,
+            caseSensitive: !1,
+            fuzzy: !1
+          })
+        ) : void 0, h = d?.pathname || this.latestLocation.pathname;
+        H(
+          a.from == null || d != null,
+          "Could not find match for from: " + a.from
+        );
+        const f = ((i = St(u)) == null ? void 0 : i.search) || this.latestLocation.search, m = s?.filter(
+          (R) => u.find((O) => O.routeId === R.routeId)
+        ), p = this.routesById[(l = m?.find((R) => R.pathname === h)) == null ? void 0 : l.routeId];
+        let v = a.to ? this.resolvePathWithBase(h, `${a.to}`) : this.resolvePathWithBase(
+          h,
+          p?.to ?? h
+        );
+        const S = { ...(c = St(u)) == null ? void 0 : c.params };
+        let b = (a.params ?? !0) === !0 ? S : { ...S, ...it(a.params, S) };
+        Object.keys(b).length > 0 && s?.map((R) => {
+          var O;
+          const $ = this.looseRoutesById[R.routeId];
+          return ((O = $?.options.params) == null ? void 0 : O.stringify) ?? $.options.stringifyParams;
+        }).filter(Boolean).forEach((R) => {
+          b = { ...b, ...R(b) };
+        }), v = Tt({
+          path: v,
+          params: b ?? {},
+          leaveWildcards: !1,
+          leaveParams: e.leaveParams
+        });
+        const g = m?.map(
+          (R) => this.looseRoutesById[R.routeId].options.preSearchFilters ?? []
+        ).flat().filter(Boolean) ?? [], P = m?.map(
+          (R) => this.looseRoutesById[R.routeId].options.postSearchFilters ?? []
+        ).flat().filter(Boolean) ?? [], M = g.length ? g.reduce((R, O) => O(R), f) : f, k = a.search === !0 ? M : a.search ? it(a.search, M) : g.length ? M : {}, w = P.length ? P.reduce((R, O) => O(R), k) : k, y = Y(f, w), N = this.options.stringifySearch(y), A = a.hash === !0 ? this.latestLocation.hash : a.hash ? it(a.hash, this.latestLocation.hash) : void 0, B = A ? `#${A}` : "";
+        let T = a.state === !0 ? this.latestLocation.state : a.state ? it(a.state, this.latestLocation.state) : {};
+        return T = Y(this.latestLocation.state, T), {
+          pathname: v,
+          search: y,
+          searchStr: N,
+          state: T,
+          hash: A ?? "",
+          href: `${v}${N}${B}`,
+          unmaskOnReload: a.unmaskOnReload
+        };
+      }, r = (a = {}, s) => {
+        var i;
+        const l = o(a);
+        let c = s ? o(s) : void 0;
+        if (!c) {
+          let m = {};
+          const p = (i = this.options.routeMasks) == null ? void 0 : i.find((v) => {
+            const S = vt(this.basepath, l.pathname, {
+              to: v.from,
+              caseSensitive: !1,
+              fuzzy: !1
+            });
+            return S ? (m = S, !0) : !1;
+          });
+          if (p) {
+            const { from: v, ...S } = p;
+            s = {
+              ...pt(e, ["from"]),
+              ...S,
+              params: m
+            }, c = o(s);
+          }
+        }
+        const u = this.matchRoutes(l.pathname, l.search), d = c ? this.matchRoutes(c.pathname, c.search) : void 0, h = c ? o(s, d) : void 0, f = o(a, u);
+        return h && (f.maskedLocation = h), f;
+      };
+      return e.mask ? r(e, {
+        ...pt(e, ["from"]),
+        ...e.mask
+      }) : r(e);
+    }, this.commitLocation = ({
+      viewTransition: e,
+      ignoreBlocker: o,
+      ...r
+    }) => {
+      const a = () => {
+        r.state.key = this.latestLocation.state.key;
+        const l = lt(r.state, this.latestLocation.state);
+        return delete r.state.key, l;
+      }, s = this.latestLocation.href === r.href, i = this.commitLocationPromise;
+      if (this.commitLocationPromise = ct(() => {
+        i?.resolve();
+      }), s && a())
+        this.load();
+      else {
+        let { maskedLocation: l, ...c } = r;
+        l && (c = {
+          ...l,
+          state: {
+            ...l.state,
+            __tempKey: void 0,
+            __tempLocation: {
+              ...c,
+              search: c.searchStr,
+              state: {
+                ...c.state,
+                __tempKey: void 0,
+                __tempLocation: void 0,
+                key: void 0
+              }
+            }
+          }
+        }, (c.unmaskOnReload ?? this.options.unmaskOnReload ?? !1) && (c.state.__tempKey = this.tempLocationKey)), this.shouldViewTransition = e, this.history[r.replace ? "replace" : "push"](
+          c.href,
+          c.state,
+          { ignoreBlocker: o }
+        );
+      }
+      return this.resetNextScroll = r.resetScroll ?? !0, this.history.subscribers.size || this.load(), this.commitLocationPromise;
+    }, this.buildAndCommitLocation = ({
+      replace: e,
+      resetScroll: o,
+      viewTransition: r,
+      ignoreBlocker: a,
+      ...s
+    } = {}) => {
+      const i = this.buildLocation(s);
+      return this.commitLocation({
+        ...i,
+        viewTransition: r,
+        replace: e,
+        resetScroll: o,
+        ignoreBlocker: a
+      });
+    }, this.navigate = ({ from: e, to: o, __isRedirect: r, ...a }) => {
+      const s = String(o);
+      let i;
+      try {
+        new URL(`${s}`), i = !0;
+      } catch {
+      }
+      return H(
+        !i,
+        "Attempting to navigate to external url with router.navigate!"
+      ), this.buildAndCommitLocation({
+        ...a,
+        from: e,
+        to: o
+        // to: toString,
+      });
+    }, this.load = async () => {
+      this.latestLocation = this.parseLocation(this.latestLocation), this.__store.setState((a) => ({
+        ...a,
+        loadedAt: Date.now()
+      }));
+      let e, o;
+      const r = new Promise((a) => {
+        this.startReactTransition(async () => {
+          var s;
+          try {
+            const i = this.latestLocation, l = this.state.resolvedLocation, c = l.href !== i.href;
+            this.cancelMatches();
+            let u;
+            this.__store.batch(() => {
+              u = this.matchRoutes(i.pathname, i.search), this.__store.setState((d) => ({
+                ...d,
+                status: "pending",
+                isLoading: !0,
+                location: i,
+                pendingMatches: u,
+                // If a cached moved to pendingMatches, remove it from cachedMatches
+                cachedMatches: d.cachedMatches.filter((h) => !u.find((f) => f.id === h.id))
+              }));
+            }), this.state.redirect || this.emit({
+              type: "onBeforeNavigate",
+              fromLocation: l,
+              toLocation: i,
+              pathChanged: c
+            }), this.emit({
+              type: "onBeforeLoad",
+              fromLocation: l,
+              toLocation: i,
+              pathChanged: c
+            }), await this.loadMatches({
+              matches: u,
+              location: i,
+              // eslint-disable-next-line @typescript-eslint/require-await
+              onReady: async () => {
+                this.startViewTransition(async () => {
+                  let d, h, f;
+                  this.__store.batch(() => {
+                    this.__store.setState((m) => {
+                      const p = m.matches, v = m.pendingMatches || m.matches;
+                      return d = p.filter(
+                        (S) => !v.find((b) => b.id === S.id)
+                      ), h = v.filter(
+                        (S) => !p.find((b) => b.id === S.id)
+                      ), f = p.filter(
+                        (S) => v.find((b) => b.id === S.id)
+                      ), {
+                        ...m,
+                        isLoading: !1,
+                        matches: v,
+                        pendingMatches: void 0,
+                        cachedMatches: [
+                          ...m.cachedMatches,
+                          ...d.filter((S) => S.status !== "error")
+                        ]
+                      };
+                    }), this.cleanCache();
+                  }), [
+                    [d, "onLeave"],
+                    [h, "onEnter"],
+                    [f, "onStay"]
+                  ].forEach(([m, p]) => {
+                    m.forEach((v) => {
+                      var S, b;
+                      (b = (S = this.looseRoutesById[v.routeId].options)[p]) == null || b.call(S, v);
+                    });
+                  });
+                });
+              }
+            });
+          } catch (i) {
+            zt(i) ? (e = i, this.isServer || this.navigate({ ...i, replace: !0, __isRedirect: !0 })) : Q(i) && (o = i), this.__store.setState((l) => ({
+              ...l,
+              statusCode: e ? e.statusCode : o ? 404 : l.matches.some((c) => c.status === "error") ? 500 : 200,
+              redirect: e
+            }));
+          }
+          this.latestLoadPromise === r && ((s = this.commitLocationPromise) == null || s.resolve(), this.latestLoadPromise = void 0, this.commitLocationPromise = void 0), a();
+        });
+      });
+      for (this.latestLoadPromise = r, await r; this.latestLoadPromise && r !== this.latestLoadPromise; )
+        await this.latestLoadPromise;
+    }, this.startViewTransition = (e) => {
+      var o, r;
+      const a = this.shouldViewTransition ?? this.options.defaultViewTransition;
+      delete this.shouldViewTransition, (r = (o = a && typeof document < "u" ? document : void 0) == null ? void 0 : o.startViewTransition) != null && r.call(o, e) || e();
+    }, this.updateMatch = (e, o) => {
+      var r;
+      let a;
+      const s = (r = this.state.pendingMatches) == null ? void 0 : r.find((c) => c.id === e), i = this.state.matches.find((c) => c.id === e), l = s ? "pendingMatches" : i ? "matches" : "cachedMatches";
+      return this.__store.setState((c) => {
+        var u;
+        return {
+          ...c,
+          [l]: (u = c[l]) == null ? void 0 : u.map(
+            (d) => d.id === e ? a = o(d) : d
+          )
+        };
+      }), a;
+    }, this.getMatch = (e) => [
+      ...this.state.cachedMatches,
+      ...this.state.pendingMatches ?? [],
+      ...this.state.matches
+    ].find((o) => o.id === e), this.loadMatches = async ({
+      location: e,
+      matches: o,
+      preload: r,
+      onReady: a,
+      updateMatch: s = this.updateMatch
+    }) => {
+      let i, l = !1;
+      const c = async () => {
+        l || (l = !0, await a?.());
+      };
+      !this.isServer && !this.state.matches.length && c();
+      const u = (d, h) => {
+        var f, m, p;
+        if (zt(h)) throw h;
+        if (st(h) || Q(h)) {
+          if (s(d.id, (v) => ({
+            ...v,
+            status: st(h) ? "redirected" : Q(h) ? "notFound" : "error",
+            isFetching: !1,
+            error: h,
+            beforeLoadPromise: void 0,
+            loaderPromise: void 0
+          })), h.routeId || (h.routeId = d.routeId), (f = d.beforeLoadPromise) == null || f.resolve(), (m = d.loaderPromise) == null || m.resolve(), (p = d.loadPromise) == null || p.resolve(), st(h))
+            throw l = !0, h = this.resolveRedirect({ ...h, _fromLocation: e }), h;
+          if (Q(h))
+            throw this._handleNotFound(o, h, {
+              updateMatch: s
+            }), h;
+        }
+      };
+      try {
+        await new Promise((d, h) => {
+          (async () => {
+            var f, m, p;
+            try {
+              const v = (g, P, M) => {
+                var k, w;
+                const { id: y, routeId: N } = o[g], A = this.looseRoutesById[N];
+                if (P instanceof Promise)
+                  throw P;
+                P.routerCode = M, i = i ?? g, u(this.getMatch(y), P);
+                try {
+                  (w = (k = A.options).onError) == null || w.call(k, P);
+                } catch (B) {
+                  P = B, u(this.getMatch(y), P);
+                }
+                s(y, (B) => {
+                  var T;
+                  return (T = B.beforeLoadPromise) == null || T.resolve(), {
+                    ...B,
+                    error: P,
+                    status: "error",
+                    isFetching: !1,
+                    updatedAt: Date.now(),
+                    abortController: new AbortController(),
+                    beforeLoadPromise: void 0
+                  };
+                });
+              };
+              for (const [g, { id: P, routeId: M }] of o.entries()) {
+                const k = this.getMatch(P);
+                if (
+                  // If we are in the middle of a load, either of these will be present
+                  // (not to be confused with `loadPromise`, which is always defined)
+                  k.beforeLoadPromise || k.loaderPromise
+                )
+                  await k.beforeLoadPromise;
+                else {
+                  try {
+                    s(P, (I) => ({
+                      ...I,
+                      loadPromise: ct(() => {
+                        var V;
+                        (V = I.loadPromise) == null || V.resolve();
+                      }),
+                      beforeLoadPromise: ct()
+                    }));
+                    const w = this.looseRoutesById[M], y = new AbortController(), N = (f = o[g - 1]) == null ? void 0 : f.id, A = () => N ? this.getMatch(N).context ?? this.options.context ?? {} : this.options.context ?? {}, B = w.options.pendingMs ?? this.options.defaultPendingMs, T = !!(a && !this.isServer && !r && (w.options.loader || w.options.beforeLoad) && typeof B == "number" && B !== 1 / 0 && (w.options.pendingComponent ?? this.options.defaultPendingComponent));
+                    let R;
+                    T && (R = setTimeout(() => {
+                      try {
+                        c();
+                      } catch {
+                      }
+                    }, B));
+                    const { paramsError: O, searchError: $ } = this.getMatch(P);
+                    O && v(g, O, "PARSE_PARAMS"), $ && v(g, $, "VALIDATE_SEARCH");
+                    const K = A();
+                    s(P, (I) => ({
+                      ...I,
+                      isFetching: "beforeLoad",
+                      fetchCount: I.fetchCount + 1,
+                      routeContext: Y(
+                        I.routeContext,
+                        K
+                      ),
+                      context: Y(I.context, K),
+                      abortController: y,
+                      pendingTimeout: R
+                    }));
+                    const { search: J, params: E, routeContext: x, cause: j } = this.getMatch(P), z = {
+                      search: J,
+                      abortController: y,
+                      params: E,
+                      preload: !!r,
+                      context: x,
+                      location: e,
+                      navigate: (I) => this.navigate({ ...I, _fromLocation: e }),
+                      buildLocation: this.buildLocation,
+                      cause: r ? "preload" : j
+                    }, U = await ((p = (m = w.options).beforeLoad) == null ? void 0 : p.call(m, z)) ?? {};
+                    (st(U) || Q(U)) && v(g, U, "BEFORE_LOAD"), s(P, (I) => {
+                      const V = {
+                        ...I.routeContext,
+                        ...U
+                      };
+                      return {
+                        ...I,
+                        routeContext: Y(
+                          I.routeContext,
+                          V
+                        ),
+                        context: Y(I.context, V),
+                        abortController: y
+                      };
+                    });
+                  } catch (w) {
+                    v(g, w, "BEFORE_LOAD");
+                  }
+                  s(P, (w) => {
+                    var y;
+                    return (y = w.beforeLoadPromise) == null || y.resolve(), {
+                      ...w,
+                      beforeLoadPromise: void 0,
+                      isFetching: !1
+                    };
+                  });
+                }
+              }
+              const S = o.slice(0, i), b = [];
+              S.forEach(({ id: g, routeId: P }, M) => {
+                b.push(
+                  (async () => {
+                    const { loaderPromise: k } = this.getMatch(g);
+                    if (k)
+                      await k;
+                    else {
+                      const w = b[M - 1], y = this.looseRoutesById[P], N = () => {
+                        const {
+                          params: x,
+                          loaderDeps: j,
+                          abortController: z,
+                          context: U,
+                          cause: I
+                        } = this.getMatch(g);
+                        return {
+                          params: x,
+                          deps: j,
+                          preload: !!r,
+                          parentMatchPromise: w,
+                          abortController: z,
+                          context: U,
+                          location: e,
+                          navigate: (V) => this.navigate({ ...V, _fromLocation: e }),
+                          cause: r ? "preload" : I,
+                          route: y
+                        };
+                      }, A = Date.now() - this.getMatch(g).updatedAt, B = r ? y.options.preloadStaleTime ?? this.options.defaultPreloadStaleTime ?? 3e4 : y.options.staleTime ?? this.options.defaultStaleTime ?? 0, T = y.options.shouldReload, R = typeof T == "function" ? T(N()) : T;
+                      s(g, (x) => ({
+                        ...x,
+                        loaderPromise: ct(),
+                        preload: !!r && !this.state.matches.find((j) => j.id === g)
+                      }));
+                      const O = async () => {
+                        var x, j, z, U, I, V, mt, et;
+                        try {
+                          const ot = async () => {
+                            const q = this.getMatch(g);
+                            q.minPendingPromise && await q.minPendingPromise;
+                          };
+                          try {
+                            y._lazyPromise = y._lazyPromise || (y.lazyFn ? y.lazyFn().then((C) => {
+                              Object.assign(
+                                y.options,
+                                C.options
+                              );
+                            }) : Promise.resolve());
+                            const q = this.getMatch(g).componentsPromise || y._lazyPromise.then(
+                              () => Promise.all(
+                                Ie.map(async (C) => {
+                                  const rt = y.options[C];
+                                  rt?.preload && await rt.preload();
+                                })
+                              )
+                            );
+                            s(g, (C) => ({
+                              ...C,
+                              isFetching: "loader",
+                              componentsPromise: q
+                            })), await y._lazyPromise;
+                            let X = await ((j = (x = y.options).loader) == null ? void 0 : j.call(x, N()));
+                            this.serializeLoaderData && (X = this.serializeLoaderData(X, {
+                              router: this,
+                              match: this.getMatch(g)
+                            })), u(
+                              this.getMatch(g),
+                              X
+                            ), await ot();
+                            const Z = (U = (z = y.options).meta) == null ? void 0 : U.call(z, {
+                              matches: o,
+                              match: this.getMatch(g),
+                              params: this.getMatch(g).params,
+                              loaderData: X
+                            }), F = (V = (I = y.options).headers) == null ? void 0 : V.call(I, {
+                              loaderData: X
+                            });
+                            s(g, (C) => ({
+                              ...C,
+                              error: void 0,
+                              status: "success",
+                              isFetching: !1,
+                              updatedAt: Date.now(),
+                              loaderData: X,
+                              meta: Z,
+                              headers: F
+                            }));
+                          } catch (q) {
+                            let X = q;
+                            await ot(), u(this.getMatch(g), q);
+                            try {
+                              (et = (mt = y.options).onError) == null || et.call(mt, q);
+                            } catch (Z) {
+                              X = Z, u(
+                                this.getMatch(g),
+                                Z
+                              );
+                            }
+                            s(g, (Z) => ({
+                              ...Z,
+                              error: X,
+                              status: "error",
+                              isFetching: !1
+                            }));
+                          }
+                          await this.getMatch(g).componentsPromise;
+                        } catch (ot) {
+                          u(this.getMatch(g), ot);
+                        }
+                      }, { status: $, invalid: K } = this.getMatch(g);
+                      $ === "success" && (K || (R ?? A > B)) ? (async () => {
+                        try {
+                          await O();
+                        } catch {
+                        }
+                      })() : $ !== "success" && await O();
+                      const { loaderPromise: J, loadPromise: E } = this.getMatch(g);
+                      J?.resolve(), E?.resolve();
+                    }
+                    s(g, (w) => ({
+                      ...w,
+                      isFetching: !1,
+                      loaderPromise: void 0
+                    }));
+                  })()
+                );
+              }), await Promise.all(b), d();
+            } catch (v) {
+              h(v);
+            }
+          })();
+        }), await c();
+      } catch (d) {
+        if (st(d) || Q(d))
+          throw Q(d) && !r && await c(), d;
+      }
+      return o;
+    }, this.invalidate = () => {
+      const e = (o) => ({
+        ...o,
+        invalid: !0,
+        ...o.status === "error" ? { status: "pending", error: void 0 } : {}
+      });
+      return this.__store.setState((o) => {
+        var r;
+        return {
+          ...o,
+          matches: o.matches.map(e),
+          cachedMatches: o.cachedMatches.map(e),
+          pendingMatches: (r = o.pendingMatches) == null ? void 0 : r.map(e)
+        };
+      }), this.load();
+    }, this.resolveRedirect = (e) => {
+      const o = e;
+      return o.href || (o.href = this.buildLocation(o).href), o;
+    }, this.cleanCache = () => {
+      this.__store.setState((e) => ({
+        ...e,
+        cachedMatches: e.cachedMatches.filter((o) => {
+          const r = this.looseRoutesById[o.routeId];
+          if (!r.options.loader)
+            return !1;
+          const a = (o.preload ? r.options.preloadGcTime ?? this.options.defaultPreloadGcTime : r.options.gcTime ?? this.options.defaultGcTime) ?? 5 * 60 * 1e3;
+          return o.status !== "error" && Date.now() - o.updatedAt < a;
+        })
+      }));
+    }, this.preloadRoute = async (e) => {
+      const o = this.buildLocation(e);
+      let r = this.matchRoutes(o.pathname, o.search, {
+        throwOnError: !0,
+        preload: !0
+      });
+      const a = Object.fromEntries(
+        [
+          ...this.state.matches,
+          ...this.state.pendingMatches ?? [],
+          ...this.state.cachedMatches
+        ].map((i) => [i.id, !0])
+      );
+      this.__store.batch(() => {
+        r.forEach((i) => {
+          a[i.id] || this.__store.setState((l) => ({
+            ...l,
+            cachedMatches: [...l.cachedMatches, i]
+          }));
+        });
+      });
+      const s = new Set(
+        [...this.state.matches, ...this.state.pendingMatches ?? []].map(
+          (i) => i.id
+        )
+      );
+      try {
+        return r = await this.loadMatches({
+          matches: r,
+          location: o,
+          preload: !0,
+          updateMatch: (i, l) => {
+            s.has(i) ? r = r.map((c) => c.id === i ? l(c) : c) : this.updateMatch(i, l);
+          }
+        }), r;
+      } catch (i) {
+        if (st(i))
+          return await this.preloadRoute({
+            ...i,
+            _fromLocation: o
+          });
+        console.error(i);
+        return;
+      }
+    }, this.matchRoute = (e, o) => {
+      const r = {
+        ...e,
+        to: e.to ? this.resolvePathWithBase(e.from || "", e.to) : void 0,
+        params: e.params || {},
+        leaveParams: !0
+      }, a = this.buildLocation(r);
+      if (o?.pending && this.state.status !== "pending")
+        return !1;
+      const i = (o?.pending === void 0 ? !this.state.isLoading : o.pending) ? this.latestLocation : this.state.resolvedLocation, l = vt(this.basepath, i.pathname, {
+        ...o,
+        to: a.pathname
+      });
+      return !l || e.params && !lt(l, e.params, !0) ? !1 : l && (o?.includeSearch ?? !0) ? lt(i.search, a.search, !0) ? l : !1 : l;
+    }, this.dehydrate = () => {
+      var e;
+      const o = ((e = this.options.errorSerializer) == null ? void 0 : e.serialize) ?? Be;
+      return {
+        state: {
+          dehydratedMatches: this.state.matches.map((r) => ({
+            ...pt(r, ["id", "status", "updatedAt"]),
+            // If an error occurs server-side during SSRing,
+            // send a small subset of the error to the client
+            error: r.error ? {
+              data: o(r.error),
+              __isServerError: !0
+            } : void 0
+            // NOTE: We don't send the loader data here, because
+            // there is a potential that it needs to be streamed.
+            // Instead, we render it next to the route match in the HTML
+            // which gives us the potential to stream it via suspense.
+          }))
+        },
+        manifest: this.manifest
+      };
+    }, this.hydrate = () => {
+      var e, o, r;
+      let a;
+      typeof document < "u" && (a = this.options.transformer.parse((e = window.__TSR__) == null ? void 0 : e.dehydrated)), H(
+        a,
+        "Expected to find a dehydrated data on window.__TSR__.dehydrated... but we did not. Please file an issue!"
+      ), this.dehydratedData = a.payload, (r = (o = this.options).hydrate) == null || r.call(o, a.payload);
+      const s = a.router.state, i = this.matchRoutes(
+        this.state.location.pathname,
+        this.state.location.search
+      ).map((l) => {
+        const c = s.dehydratedMatches.find(
+          (u) => u.id === l.id
+        );
+        return H(
+          c,
+          `Could not find a client-side match for dehydrated match with id: ${l.id}!`
+        ), {
+          ...l,
+          ...c
+        };
+      });
+      this.__store.setState((l) => ({
+        ...l,
+        matches: i
+      })), this.manifest = a.router.manifest;
+    }, this.injectedHtml = [], this.injectHtml = (e) => {
+      const o = () => (this.injectedHtml = this.injectedHtml.filter((r) => r !== o), e);
+      this.injectedHtml.push(o);
+    }, this.streamedKeys = /* @__PURE__ */ new Set(), this.getStreamedValue = (e) => {
+      var o;
+      if (this.isServer)
+        return;
+      const r = (o = window.__TSR__) == null ? void 0 : o.streamedValues[e];
+      if (r)
+        return r.parsed || (r.parsed = this.options.transformer.parse(r.value)), r.parsed;
+    }, this.streamValue = (e, o) => {
+      var r;
+      ut(
+        !this.streamedKeys.has(e),
+        "Key has already been streamed: " + e
+      ), this.streamedKeys.add(e);
+      const a = `__TSR__.streamedValues['${e}'] = { value: ${(r = this.serializer) == null ? void 0 : r.call(this, this.options.transformer.stringify(o))}}`;
+      this.injectHtml(
+        `<script class='tsr-once'>${a}; __TSR__.cleanScripts()<\/script>`
+      );
+    }, this._handleNotFound = (e, o, {
+      updateMatch: r = this.updateMatch
+    } = {}) => {
+      const a = Object.fromEntries(
+        e.map((l) => [l.routeId, l])
+      );
+      let s = (o.global ? this.looseRoutesById[W] : this.looseRoutesById[o.routeId]) || this.looseRoutesById[W];
+      for (; !s.options.notFoundComponent && !this.options.defaultNotFoundComponent && s.id !== W; )
+        s = s.parentRoute, H(
+          s,
+          "Found invalid route tree while trying to find not-found handler."
+        );
+      const i = a[s.id];
+      H(i, "Could not find match for route: " + s.id), r(i.id, (l) => ({
+        ...l,
+        status: "notFound",
+        error: o,
+        isFetching: !1
+      })), o.routerCode === "BEFORE_LOAD" && s.parentRoute && (o.routeId = s.parentRoute.id, this._handleNotFound(e, o, {
+        updateMatch: r
+      }));
+    }, this.hasNotFoundMatch = () => this.__store.state.matches.some(
+      (e) => e.status === "notFound" || e.globalNotFound
+    ), this.update({
+      defaultPreloadDelay: 50,
+      defaultPendingMs: 1e3,
+      defaultPendingMinMs: 500,
+      context: void 0,
+      ...n,
+      stringifySearch: n.stringifySearch ?? _e,
+      parseSearch: n.parseSearch ?? ye
+    }), typeof document < "u" && (window.__TSR__ROUTER__ = this);
+  }
+  get state() {
+    return this.__store.state;
+  }
+  get looseRoutesById() {
+    return this.routesById;
+  }
+}
+class Fe extends Error {
+}
+class ke extends Error {
+}
+function Oe(t) {
+  return {
+    loadedAt: 0,
+    isLoading: !1,
+    isTransitioning: !1,
+    status: "idle",
+    resolvedLocation: { ...t },
+    location: t,
+    matches: [],
+    pendingMatches: [],
+    cachedMatches: [],
+    statusCode: 200
+  };
+}
+function Be(t) {
+  return t instanceof Error ? {
+    name: t.name,
+    message: t.message
+  } : {
+    data: t
+  };
+}
+function Ht(t) {
+  return !(typeof t == "object" && t && "data" in t) || !("__isServerError" in t && t.__isServerError) || !(typeof t.data == "object" && t.data) ? !1 : t.__isServerError === !0;
+}
+function Wt(t) {
+  if ("name" in t && "message" in t) {
+    const n = new Error(t.message);
+    return n.name = t.name, n;
+  }
+  return t.data;
+}
+const Ct = L.createContext(void 0);
+function ht(t) {
+  const n = L.useContext(Ct);
+  return D({
+    select: (o) => {
+      const r = o.matches.find(
+        (a) => t.from ? t.from === a.routeId : a.id === n
+      );
+      if (H(
+        !((t.shouldThrow ?? !0) && !r),
+        `Could not find ${t.from ? `an active match from "${t.from}"` : "a nearest match!"}`
+      ), r !== void 0)
+        return t.select ? t.select(r) : r;
+    }
+  });
+}
+function Ne(t) {
+  return ht({
+    ...t,
+    select: (n) => typeof t.select == "function" ? t.select(n.loaderDeps) : n.loaderDeps
+  });
+}
+function $e(t) {
+  return ht({
+    ...t,
+    select: (n) => typeof t.select == "function" ? t.select(n.loaderData) : n.loaderData
+  });
+}
+function Ae(t) {
+  return ht({
+    ...t,
+    select: (n) => t.select ? t.select(n.params) : n.params
+  });
+}
+function Ke(t) {
+  return ht({
+    ...t,
+    select: (n) => t.select ? t.select(n.search) : n.search
+  });
+}
+function je(t) {
+  const n = tt();
+  return L.useCallback(
+    (e) => n.navigate({
+      ...e
+    }),
+    [n]
+  );
+}
+class Zt {
+  /**
+   * @deprecated Use the `createRoute` function instead.
+   */
+  constructor(n) {
+    this.init = (e) => {
+      var o, r;
+      this.originalIndex = e.originalIndex;
+      const a = this.options, s = !a?.path && !a?.id;
+      this.parentRoute = (r = (o = this.options) == null ? void 0 : o.getParentRoute) == null ? void 0 : r.call(o), s ? this.path = W : H(
+        this.parentRoute,
+        "Child Route instances must pass a 'getParentRoute: () => ParentRoute' option that returns a Route instance."
+      );
+      let i = s ? W : a.path;
+      i && i !== "/" && (i = Ot(i));
+      const l = a?.id || i;
+      let c = s ? W : nt([
+        this.parentRoute.id === W ? "" : this.parentRoute.id,
+        l
+      ]);
+      i === W && (i = "/"), c !== W && (c = nt(["/", c]));
+      const u = c === W ? "/" : nt([this.parentRoute.fullPath, i]);
+      this.path = i, this.id = c, this.fullPath = u, this.to = u;
+    }, this.updateLoader = (e) => (Object.assign(this.options, e), this), this.update = (e) => (Object.assign(this.options, e), this), this.lazy = (e) => (this.lazyFn = e, this), this.useMatch = (e) => ht({ ...e, from: this.id }), this.useRouteContext = (e) => ht({
+      ...e,
+      from: this.id,
+      select: (o) => e?.select ? e.select(o.context) : o.context
+    }), this.useSearch = (e) => Ke({ ...e, from: this.id }), this.useParams = (e) => Ae({ ...e, from: this.id }), this.useLoaderDeps = (e) => Ne({ ...e, from: this.id }), this.useLoaderData = (e) => $e({ ...e, from: this.id }), this.useNavigate = () => je({ from: this.id }), this.options = n || {}, this.isRoot = !n?.getParentRoute, H(
+      !(n?.id && n?.path),
+      "Route cannot have both an 'id' and a 'path' option."
+    ), this.$$typeof = Symbol.for("react.memo");
+  }
+  addChildren(n) {
+    return this.children = Array.isArray(n) ? n : Object.values(n), this;
+  }
+}
+function De(t) {
+  return new Zt(t);
+}
+function ho() {
+  return (t) => He(t);
+}
+class ze extends Zt {
+  /**
+   * @deprecated `RootRoute` is now an internal implementation detail. Use `createRootRoute()` instead.
+   */
+  constructor(n) {
+    super(n);
+  }
+  addChildren(n) {
+    return super.addChildren(n);
+  }
+}
+function He(t) {
+  return new ze(t);
+}
+function fo(t) {
+  return new We(t, {
+    silent: !0
+  }).createRoute;
+}
+class We {
+  constructor(n, e) {
+    this.path = n, this.createRoute = (o) => {
+      ut(
+        this.silent,
+        "FileRoute is deprecated and will be removed in the next major version. Use the createFileRoute(path)(options) function instead."
+      );
+      const r = De(o);
+      return r.isRoot = !1, r;
+    }, this.silent = e?.silent;
+  }
+}
+const Ue = "Error preloading route! ☝️";
+function Ve(t) {
+  const n = tt(), [e, o] = L.useState(!1), {
+    // custom props
+    activeProps: r = () => ({ className: "active" }),
+    inactiveProps: a = () => ({}),
+    activeOptions: s,
+    hash: i,
+    search: l,
+    params: c,
+    to: u,
+    state: d,
+    mask: h,
+    preload: f,
+    preloadDelay: m,
+    replace: p,
+    startTransition: v,
+    resetScroll: S,
+    viewTransition: b,
+    // element props
+    children: g,
+    target: P,
+    disabled: M,
+    style: k,
+    className: w,
+    onClick: y,
+    onFocus: N,
+    onMouseEnter: A,
+    onMouseLeave: B,
+    onTouchStart: T,
+    ignoreBlocker: R,
+    ...O
+  } = t;
+  let $ = "internal";
+  try {
+    new URL(`${u}`), $ = "external";
+  } catch {
+  }
+  const K = n.buildLocation(t), J = f ?? n.options.defaultPreload, E = m ?? n.options.defaultPreloadDelay ?? 0, x = D({
+    select: (F) => {
+      const C = wt(
+        F.location.pathname,
+        n.basepath
+      ).split("/"), Mt = wt(
+        K.pathname,
+        n.basepath
+      ).split("/").every(
+        (se, ie) => se === C[ie]
+      ), oe = s?.exact ? be(F.location.pathname, K.pathname, n.basepath) : Mt, ne = s?.includeHash ? F.location.hash === K.hash : !0, re = s?.includeSearch ?? !0 ? lt(F.location.search, K.search, !s?.exact) : !0;
+      return oe && ne && re;
+    }
+  });
+  if ($ === "external")
+    return {
+      ...O,
+      type: $,
+      href: u,
+      ...g && { children: g },
+      ...P && { target: P },
+      ...M && { disabled: M },
+      ...k && { style: k },
+      ...w && { className: w },
+      ...y && { onClick: y },
+      ...N && { onFocus: N },
+      ...A && { onMouseEnter: A },
+      ...B && { onMouseLeave: B },
+      ...T && { onTouchStart: T }
+    };
+  const j = (F) => {
+    if (!M && !qe(F) && !F.defaultPrevented && (!P || P === "_self") && F.button === 0) {
+      F.preventDefault(), ae(() => {
+        o(!0);
+      });
+      const C = n.subscribe("onResolved", () => {
+        C(), o(!1);
+      });
+      n.commitLocation({
+        ...K,
+        replace: p,
+        resetScroll: S,
+        startTransition: v,
+        viewTransition: b,
+        ignoreBlocker: R
+      });
+    }
+  }, z = () => {
+    n.preloadRoute(t).catch((F) => {
+      console.warn(F), console.warn(Ue);
+    });
+  }, U = (F) => {
+    M || J && z();
+  }, I = U, V = (F) => {
+    if (M) return;
+    const C = F.target || {};
+    if (J) {
+      if (C.preloadTimeout)
+        return;
+      C.preloadTimeout = setTimeout(() => {
+        C.preloadTimeout = null, z();
+      }, E);
+    }
+  }, mt = (F) => {
+    if (M) return;
+    const C = F.target || {};
+    C.preloadTimeout && (clearTimeout(C.preloadTimeout), C.preloadTimeout = null);
+  }, et = (F) => (C) => {
+    var rt;
+    (rt = C.persist) == null || rt.call(C), F.filter(Boolean).forEach((Mt) => {
+      C.defaultPrevented || Mt(C);
+    });
+  }, ot = x ? it(r, {}) ?? {} : {}, q = x ? {} : it(a, {}), X = [
+    w,
+    ot.className,
+    q.className
+  ].filter(Boolean).join(" "), Z = {
+    ...k,
+    ...ot.style,
+    ...q.style
+  };
+  return {
+    ...ot,
+    ...q,
+    ...O,
+    href: M ? void 0 : K.maskedLocation ? n.history.createHref(K.maskedLocation.href) : n.history.createHref(K.href),
+    onClick: et([y, j]),
+    onFocus: et([N, U]),
+    onMouseEnter: et([A, V]),
+    onMouseLeave: et([B, mt]),
+    onTouchStart: et([T, I]),
+    disabled: !!M,
+    target: P,
+    ...Object.keys(Z).length && { style: Z },
+    ...X && { className: X },
+    ...M && {
+      role: "link",
+      "aria-disabled": !0
+    },
+    ...x && { "data-status": "active", "aria-current": "page" },
+    ...e && { "data-transitioning": "transitioning" }
+  };
+}
+const po = L.forwardRef((t, n) => {
+  const { _asChild: e, ...o } = t, { type: r, ...a } = Ve(o), s = typeof o.children == "function" ? o.children({
+    isActive: a["data-status"] === "active"
+  }) : o.children;
+  return typeof e > "u" && delete a.disabled, L.createElement(
+    e || "a",
+    {
+      ...a,
+      ref: n
+    },
+    s
+  );
+});
+function qe(t) {
+  return !!(t.metaKey || t.altKey || t.ctrlKey || t.shiftKey);
+}
+function Xe() {
+  const t = tt(), n = L.useRef({ router: t, mounted: !1 }), e = D({
+    select: (c) => pt(c, ["isLoading", "location", "resolvedLocation", "isTransitioning"])
+  }), [o, r] = L.useTransition(), a = D({
+    select: (c) => c.matches.some((u) => u.status === "pending")
+  }), s = Dt(e.isLoading), i = e.isLoading || o || a, l = Dt(i);
+  return t.isServer || (t.startReactTransition = r), L.useEffect(() => {
+    const c = t.history.subscribe(t.load), u = t.buildLocation({
+      to: t.latestLocation.pathname,
+      search: !0,
+      params: !0,
+      hash: !0,
+      state: !0
+    });
+    return at(t.latestLocation.href) !== at(u.href) && t.commitLocation({ ...u, replace: !0 }), () => {
+      c();
+    };
+  }, [t, t.history]), It(() => {
+    var c;
+    if ((c = window.__TSR__) != null && c.dehydrated || n.current.router === t && n.current.mounted)
+      return;
+    n.current = { router: t, mounted: !0 }, (async () => {
+      try {
+        await t.load();
+      } catch (d) {
+        console.error(d);
+      }
+    })();
+  }, [t]), It(() => {
+    if (s && !e.isLoading) {
+      const c = t.state.location, u = t.state.resolvedLocation, d = u.href !== c.href;
+      t.emit({
+        type: "onLoad",
+        // When the new URL has committed, when the new matches have been loaded into state.matches
+        fromLocation: u,
+        toLocation: c,
+        pathChanged: d
+      });
+    }
+  }, [s, t, e.isLoading]), It(() => {
+    if (l && !i) {
+      const c = t.state.location, u = t.state.resolvedLocation, d = u.href !== c.href;
+      if (t.emit({
+        type: "onResolved",
+        fromLocation: u,
+        toLocation: c,
+        pathChanged: d
+      }), t.__store.setState((h) => ({
+        ...h,
+        status: "idle",
+        resolvedLocation: h.location
+      })), document.querySelector && t.state.location.hash !== "") {
+        const h = document.getElementById(t.state.location.hash);
+        h && h.scrollIntoView();
+      }
+    }
+  }, [i, l, t]), null;
+}
+function gt(t) {
+  return /* @__PURE__ */ _(Vt, { children: t.children });
+}
+function te(t, n, e) {
+  return n.options.notFoundComponent ? /* @__PURE__ */ _(n.options.notFoundComponent, { data: e }) : t.options.defaultNotFoundComponent ? /* @__PURE__ */ _(t.options.defaultNotFoundComponent, { data: e }) : /* @__PURE__ */ _(xe, {});
+}
+function ee({ matchId: t }) {
+  var n, e;
+  const o = tt(), r = D({
+    select: (p) => {
+      var v;
+      return (v = p.matches.find((S) => S.id === t)) == null ? void 0 : v.routeId;
+    }
+  });
+  H(
+    r,
+    `Could not find routeId for matchId "${t}". Please file an issue!`
+  );
+  const a = o.routesById[r], s = a.options.pendingComponent ?? o.options.defaultPendingComponent, i = s ? /* @__PURE__ */ _(s, {}) : null, l = a.options.errorComponent ?? o.options.defaultErrorComponent, c = a.options.onCatch ?? o.options.defaultOnCatch, u = a.isRoot ? (
+    // If it's the root route, use the globalNotFound option, with fallback to the notFoundRoute's component
+    a.options.notFoundComponent ?? ((n = o.options.notFoundRoute) == null ? void 0 : n.options.component)
+  ) : a.options.notFoundComponent, d = (
+    // If we're on the root route, allow forcefully wrapping in suspense
+    (!a.isRoot || a.options.wrapInSuspense) && (a.options.wrapInSuspense ?? s ?? ((e = a.options.errorComponent) == null ? void 0 : e.preload)) ? L.Suspense : gt
+  ), h = l ? Bt : gt, f = u ? Ee : gt, m = D({
+    select: (p) => p.loadedAt
+  });
+  return /* @__PURE__ */ _(Ct.Provider, { value: t, children: /* @__PURE__ */ _(d, { fallback: i, children: /* @__PURE__ */ _(
+    h,
+    {
+      getResetKey: () => m,
+      errorComponent: l || Lt,
+      onCatch: (p, v) => {
+        if (Q(p)) throw p;
+        ut(!1, `Error in route match: ${t}`), c?.(p, v);
+      },
+      children: /* @__PURE__ */ _(
+        f,
+        {
+          fallback: (p) => {
+            if (!u || p.routeId && p.routeId !== r || !p.routeId && !a.isRoot)
+              throw p;
+            return L.createElement(u, p);
+          },
+          children: /* @__PURE__ */ _(Ge, { matchId: t })
+        }
+      )
+    }
+  ) }) });
+}
+function Ge({ matchId: t }) {
+  var n, e;
+  const o = tt(), r = D({
+    select: (d) => {
+      var h;
+      return (h = d.matches.find((f) => f.id === t)) == null ? void 0 : h.routeId;
+    }
+  }), a = o.routesById[r], s = D({
+    select: (d) => d.matches.findIndex((h) => h.id === t)
+  }), i = D({
+    select: (d) => {
+      const h = d.matches[s];
+      return pt(h, [
+        "id",
+        "status",
+        "error",
+        "loadPromise",
+        "minPendingPromise"
+      ]);
+    }
+  }), l = (a.options.errorComponent ?? o.options.defaultErrorComponent) || Lt;
+  if (i.status === "notFound") {
+    let d;
+    return Ht(i.error) ? d = (((n = o.options.errorSerializer) == null ? void 0 : n.deserialize) ?? Wt)(i.error.data) : d = i.error, H(Q(d), "Expected a notFound error"), te(o, a, d);
+  }
+  if (i.status === "redirected")
+    throw H(st(i.error), "Expected a redirect error"), i.loadPromise;
+  if (i.status === "error") {
+    if (o.isServer)
+      return /* @__PURE__ */ _(
+        l,
+        {
+          error: i.error,
+          info: {
+            componentStack: ""
+          }
+        }
+      );
+    throw Ht(i.error) ? (((e = o.options.errorSerializer) == null ? void 0 : e.deserialize) ?? Wt)(i.error.data) : i.error;
+  }
+  if (i.status === "pending") {
+    const d = a.options.pendingMinMs ?? o.options.defaultPendingMinMs;
+    if (d && !i.minPendingPromise && !o.isServer) {
+      const h = ct();
+      Promise.resolve().then(() => {
+        o.updateMatch(i.id, (f) => ({
+          ...f,
+          minPendingPromise: h
+        }));
+      }), setTimeout(() => {
+        h.resolve(), o.updateMatch(i.id, (f) => ({
+          ...f,
+          minPendingPromise: void 0
+        }));
+      }, d);
+    }
+    throw i.loadPromise;
+  }
+  const c = a.options.component ?? o.options.defaultComponent;
+  return /* @__PURE__ */ yt(Vt, { children: [
+    c ? /* @__PURE__ */ _(c, {}) : /* @__PURE__ */ _(Je, {}),
+    o.AfterEachMatch ? /* @__PURE__ */ _(o.AfterEachMatch, { match: i, matchIndex: s }) : null
+  ] });
+}
+const Je = L.memo(function() {
+  const n = tt(), e = L.useContext(Ct), o = D({
+    select: (c) => {
+      var u;
+      return (u = c.matches.find((d) => d.id === e)) == null ? void 0 : u.routeId;
+    }
+  }), r = n.routesById[o], { parentGlobalNotFound: a } = D({
+    select: (c) => {
+      const d = c.matches.find((h) => h.id === e);
+      return H(
+        d,
+        `Could not find parent match for matchId "${e}"`
+      ), {
+        parentGlobalNotFound: d.globalNotFound
+      };
+    }
+  }), s = D({
+    select: (c) => {
+      var u;
+      const d = c.matches, h = d.findIndex((f) => f.id === e);
+      return (u = d[h + 1]) == null ? void 0 : u.id;
+    }
+  });
+  if (a)
+    return te(n, r, void 0);
+  if (!s)
+    return null;
+  const i = /* @__PURE__ */ _(ee, { matchId: s }), l = n.options.defaultPendingComponent ? /* @__PURE__ */ _(n.options.defaultPendingComponent, {}) : null;
+  return e === W ? /* @__PURE__ */ _(L.Suspense, { fallback: l, children: i }) : i;
+});
+function Ye() {
+  const t = tt(), n = t.options.defaultPendingComponent ? /* @__PURE__ */ _(t.options.defaultPendingComponent, {}) : null, e = t.state.matches.length ? gt : L.Suspense, o = /* @__PURE__ */ yt(e, { fallback: n, children: [
+    /* @__PURE__ */ _(Xe, {}),
+    /* @__PURE__ */ _(Qe, {})
+  ] });
+  return t.options.InnerWrap ? /* @__PURE__ */ _(t.options.InnerWrap, { children: o }) : o;
+}
+function Qe() {
+  const t = D({
+    select: (e) => {
+      var o;
+      return (o = e.matches[0]) == null ? void 0 : o.id;
+    }
+  }), n = D({
+    select: (e) => e.loadedAt
+  });
+  return /* @__PURE__ */ _(Ct.Provider, { value: t, children: /* @__PURE__ */ _(
+    Bt,
+    {
+      getResetKey: () => n,
+      errorComponent: Lt,
+      onCatch: (e) => {
+        ut(
+          !1,
+          "The following error wasn't caught by any route! At the very least, consider setting an 'errorComponent' in your RootRoute!"
+        ), ut(!1, e.message || e.toString());
+      },
+      children: t ? /* @__PURE__ */ _(ee, { matchId: t }) : null
+    }
+  ) });
+}
+function Ze({
+  router: t,
+  children: n,
+  ...e
+}) {
+  t.update({
+    ...t.options,
+    ...e,
+    context: {
+      ...t.options.context,
+      ...e.context
+    }
+  });
+  const o = Qt(), r = /* @__PURE__ */ _(o.Provider, { value: t, children: n });
+  return t.options.Wrap ? /* @__PURE__ */ _(t.options.Wrap, { children: r }) : r;
+}
+function mo({ router: t, ...n }) {
+  return /* @__PURE__ */ _(Ze, { router: t, ...n, children: /* @__PURE__ */ _(Ye, {}) });
+}
+const to = typeof window < "u" ? L.useLayoutEffect : L.useEffect, Ft = "window", Ut = "___";
+let kt = /* @__PURE__ */ new WeakSet();
+const eo = typeof window < "u" && window.sessionStorage, G = eo ? (() => {
+  const t = "tsr-scroll-restoration-v2";
+  return {
+    state: JSON.parse(
+      window.sessionStorage.getItem(t) || "null"
+    ) || { cached: {}, next: {} },
+    set: (e) => {
+      G.state = it(e, G.state), window.sessionStorage.setItem(t, JSON.stringify(G.state));
+    }
+  };
+})() : void 0, oo = (t) => t.state.key || t.href;
+function no(t) {
+  const n = tt();
+  to(() => {
+    const e = t?.getKey || oo, { history: o } = window;
+    o.scrollRestoration = "manual";
+    const r = (i) => {
+      if (kt.has(i.target)) return;
+      kt.add(i.target);
+      let l = "";
+      if (i.target === document || i.target === window)
+        l = Ft;
+      else {
+        const c = i.target.getAttribute(
+          "data-scroll-restoration-id"
+        );
+        c ? l = `[data-scroll-restoration-id="${c}"]` : l = ro(i.target);
+      }
+      G.state.next[l] || G.set((c) => ({
+        ...c,
+        next: {
+          ...c.next,
+          [l]: {
+            scrollX: NaN,
+            scrollY: NaN
+          }
+        }
+      }));
+    };
+    typeof document < "u" && document.addEventListener("scroll", r, !0);
+    const a = n.subscribe("onBeforeLoad", (i) => {
+      if (i.pathChanged) {
+        const l = e(i.fromLocation);
+        for (const c in G.state.next) {
+          const u = G.state.next[c];
+          if (c === Ft)
+            u.scrollX = window.scrollX || 0, u.scrollY = window.scrollY || 0;
+          else if (c) {
+            const d = document.querySelector(c);
+            u.scrollX = d?.scrollLeft || 0, u.scrollY = d?.scrollTop || 0;
+          }
+          G.set((d) => {
+            const h = { ...d.next };
+            return delete h[c], {
+              ...d,
+              next: h,
+              cached: {
+                ...d.cached,
+                [[l, c].join(Ut)]: u
+              }
+            };
+          });
+        }
+      }
+    }), s = n.subscribe("onResolved", (i) => {
+      if (i.pathChanged) {
+        if (!n.resetNextScroll)
+          return;
+        n.resetNextScroll = !0;
+        const l = e(i.toLocation);
+        let c = !1;
+        for (const u in G.state.cached) {
+          const d = G.state.cached[u], [h, f] = u.split(Ut);
+          if (h === l) {
+            if (f === Ft)
+              c = !0, window.scrollTo(d.scrollX, d.scrollY);
+            else if (f) {
+              const m = document.querySelector(f);
+              m && (m.scrollLeft = d.scrollX, m.scrollTop = d.scrollY);
+            }
+          }
+        }
+        c || window.scrollTo(0, 0), G.set((u) => ({ ...u, next: {} })), kt = /* @__PURE__ */ new WeakSet();
+      }
+    });
+    return () => {
+      document.removeEventListener("scroll", r), a(), s();
+    };
+  }, [t?.getKey, n]);
+}
+function vo(t) {
+  return no(t), null;
+}
+function ro(t) {
+  const n = [];
+  let e;
+  for (; e = t.parentNode; )
+    n.unshift(
+      `${t.tagName}:nth-child(${[].indexOf.call(e.children, t) + 1})`
+    ), t = e;
+  return `${n.join(" > ")}`.toLowerCase();
+}
+export {
+  po as L,
+  Je as O,
+  mo as R,
+  vo as S,
+  fo as a,
+  Ae as b,
+  ho as c,
+  D as d,
+  uo as e,
+  co as f,
+  Jt as g,
+  Q as i,
+  lo as n,
+  tt as u
+};