likec4 1.20.1 → 1.20.3

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

@@ -0,0 +1,3032 @@
+import { jsxs as et, jsx as C, Fragment as Ft } from "react/jsx-runtime";
+import * as b from "react";
+import vt, { useRef as Tt } from "react";
+import { flushSync as Bt } from "react-dom";
+const de = "__TSR_index", dt = "popstate", ht = "beforeunload";
+function St(t) {
+  let n = t.getLocation();
+  const e = /* @__PURE__ */ new Set(), r = (i) => {
+    n = t.getLocation(), e.forEach((a) => a({ location: n, action: i }));
+  }, o = (i) => {
+    t.notifyOnIndexChange ?? !0 ? r(i) : n = t.getLocation();
+  }, s = async ({
+    task: i,
+    navigateOpts: a,
+    ...l
+  }) => {
+    var c, d;
+    if (a?.ignoreBlocker ?? !1) {
+      i();
+      return;
+    }
+    const h = ((c = t.getBlockers) == null ? void 0 : c.call(t)) ?? [], f = l.type === "PUSH" || l.type === "REPLACE";
+    if (typeof document < "u" && h.length && f)
+      for (const p of h) {
+        const S = ve(l.path, l.state);
+        if (await p.blockerFn({
+          currentLocation: n,
+          nextLocation: S,
+          action: l.type
+        })) {
+          (d = t.onBlocked) == null || d.call(t);
+          return;
+        }
+      }
+    i();
+  };
+  return {
+    get location() {
+      return n;
+    },
+    get length() {
+      return t.getLength();
+    },
+    subscribers: e,
+    subscribe: (i) => (e.add(i), () => {
+      e.delete(i);
+    }),
+    push: (i, a, l) => {
+      const c = n.state[de];
+      a = tt(c + 1, a), s({
+        task: () => {
+          t.pushState(i, a), r({ type: "PUSH" });
+        },
+        navigateOpts: l,
+        type: "PUSH",
+        path: i,
+        state: a
+      });
+    },
+    replace: (i, a, l) => {
+      const c = n.state[de];
+      a = tt(c, a), s({
+        task: () => {
+          t.replaceState(i, a), r({ type: "REPLACE" });
+        },
+        navigateOpts: l,
+        type: "REPLACE",
+        path: i,
+        state: a
+      });
+    },
+    go: (i, a) => {
+      s({
+        task: () => {
+          t.go(i), o({ type: "GO", index: i });
+        },
+        navigateOpts: a,
+        type: "GO"
+      });
+    },
+    back: (i) => {
+      s({
+        task: () => {
+          t.back(i?.ignoreBlocker ?? !1), o({ type: "BACK" });
+        },
+        navigateOpts: i,
+        type: "BACK"
+      });
+    },
+    forward: (i) => {
+      s({
+        task: () => {
+          t.forward(i?.ignoreBlocker ?? !1), o({ type: "FORWARD" });
+        },
+        navigateOpts: i,
+        type: "FORWARD"
+      });
+    },
+    canGoBack: () => n.state[de] !== 0,
+    createHref: (i) => t.createHref(i),
+    block: (i) => {
+      var a;
+      if (!t.setBlockers) return () => {
+      };
+      const l = ((a = t.getBlockers) == null ? void 0 : a.call(t)) ?? [];
+      return t.setBlockers([...l, i]), () => {
+        var c, d;
+        const u = ((c = t.getBlockers) == null ? void 0 : c.call(t)) ?? [];
+        (d = t.setBlockers) == null || d.call(t, u.filter((h) => h !== i));
+      };
+    },
+    flush: () => {
+      var i;
+      return (i = t.flush) == null ? void 0 : i.call(t);
+    },
+    destroy: () => {
+      var i;
+      return (i = t.destroy) == null ? void 0 : i.call(t);
+    },
+    notify: r
+  };
+}
+function tt(t, n) {
+  return n || (n = {}), {
+    ...n,
+    key: Ot(),
+    [de]: t
+  };
+}
+function _t(t) {
+  const n = t?.window ?? (typeof document < "u" ? window : void 0), e = n.history.pushState, r = n.history.replaceState;
+  let o = [];
+  const s = () => o, i = (v) => o = v, a = t?.createHref ?? ((v) => v), l = t?.parseLocation ?? (() => ve(
+    `${n.location.pathname}${n.location.search}${n.location.hash}`,
+    n.history.state
+  ));
+  let c = l(), d, u = !1, h = !1, f = !1, p = !1;
+  const S = () => c;
+  let y, M;
+  const R = () => {
+    y && (F._ignoreSubscribers = !0, (y.isPush ? n.history.pushState : n.history.replaceState)(
+      y.state,
+      "",
+      y.href
+    ), F._ignoreSubscribers = !1, y = void 0, M = void 0, d = void 0);
+  }, L = (v, _, E) => {
+    const m = a(_);
+    M || (d = c), c = ve(_, E), y = {
+      href: m,
+      state: E,
+      isPush: y?.isPush || v === "push"
+    }, M || (M = Promise.resolve().then(() => R()));
+  }, P = (v) => {
+    c = l(), F.notify({ type: v });
+  }, g = async () => {
+    if (h) {
+      h = !1;
+      return;
+    }
+    const v = l(), _ = v.state[de] - c.state[de], E = _ === 1, m = _ === -1, w = !E && !m || u;
+    u = !1;
+    const k = w ? "GO" : m ? "BACK" : "FORWARD", T = w ? {
+      type: "GO",
+      index: _
+    } : {
+      type: m ? "BACK" : "FORWARD"
+    };
+    if (f)
+      f = !1;
+    else {
+      const I = s();
+      if (typeof document < "u" && I.length) {
+        for (const D of I)
+          if (await D.blockerFn({
+            currentLocation: c,
+            nextLocation: v,
+            action: k
+          })) {
+            h = !0, n.history.go(1), F.notify(T);
+            return;
+          }
+      }
+    }
+    c = l(), F.notify(T);
+  }, x = (v) => {
+    if (p) {
+      p = !1;
+      return;
+    }
+    let _ = !1;
+    const E = s();
+    if (typeof document < "u" && E.length)
+      for (const m of E) {
+        const w = m.enableBeforeUnload ?? !0;
+        if (w === !0) {
+          _ = !0;
+          break;
+        }
+        if (typeof w == "function" && w() === !0) {
+          _ = !0;
+          break;
+        }
+      }
+    if (_)
+      return v.preventDefault(), v.returnValue = "";
+  }, F = St({
+    getLocation: S,
+    getLength: () => n.history.length,
+    pushState: (v, _) => L("push", v, _),
+    replaceState: (v, _) => L("replace", v, _),
+    back: (v) => (v && (f = !0), p = !0, n.history.back()),
+    forward: (v) => {
+      v && (f = !0), p = !0, n.history.forward();
+    },
+    go: (v) => {
+      u = !0, n.history.go(v);
+    },
+    createHref: (v) => a(v),
+    flush: R,
+    destroy: () => {
+      n.history.pushState = e, n.history.replaceState = r, n.removeEventListener(ht, x, {
+        capture: !0
+      }), n.removeEventListener(dt, g);
+    },
+    onBlocked: () => {
+      d && c !== d && (c = d);
+    },
+    getBlockers: s,
+    setBlockers: i,
+    notifyOnIndexChange: !1
+  });
+  return n.addEventListener(ht, x, { capture: !0 }), n.addEventListener(dt, g), n.history.pushState = function(...v) {
+    const _ = e.apply(n.history, v);
+    return F._ignoreSubscribers || P("PUSH"), _;
+  }, n.history.replaceState = function(...v) {
+    const _ = r.apply(n.history, v);
+    return F._ignoreSubscribers || P("REPLACE"), _;
+  }, F;
+}
+function rr(t) {
+  const n = typeof document < "u" ? window : void 0;
+  return _t({
+    window: n,
+    parseLocation: () => {
+      const e = n.location.hash.split("#").slice(1).join("#") ?? "/";
+      return ve(e, n.history.state);
+    },
+    createHref: (e) => `${n.location.pathname}${n.location.search}#${e}`
+  });
+}
+function Dt(t = {
+  initialEntries: ["/"]
+}) {
+  const n = t.initialEntries;
+  let e = t.initialIndex ? Math.min(Math.max(t.initialIndex, 0), n.length - 1) : n.length - 1;
+  const r = n.map(
+    (s, i) => tt(i, void 0)
+  );
+  return St({
+    getLocation: () => ve(n[e], r[e]),
+    getLength: () => n.length,
+    pushState: (s, i) => {
+      e < n.length - 1 && (n.splice(e + 1), r.splice(e + 1)), r.push(i), n.push(s), e = Math.max(n.length - 1, 0);
+    },
+    replaceState: (s, i) => {
+      r[e] = i, n[e] = s;
+    },
+    back: () => {
+      e = Math.max(e - 1, 0);
+    },
+    forward: () => {
+      e = Math.min(e + 1, n.length - 1);
+    },
+    go: (s) => {
+      e = Math.min(Math.max(e + s, 0), n.length - 1);
+    },
+    createHref: (s) => s
+  });
+}
+function ve(t, n) {
+  const e = t.indexOf("#"), r = t.indexOf("?");
+  return {
+    href: t,
+    pathname: t.substring(
+      0,
+      e > 0 ? r > 0 ? Math.min(e, r) : e : r > 0 ? r : t.length
+    ),
+    hash: e > -1 ? t.substring(e) : "",
+    search: r > -1 ? t.slice(r, e === -1 ? void 0 : e) : "",
+    state: n || { [de]: 0 }
+  };
+}
+function Ot() {
+  return (Math.random() + 1).toString(36).substring(7);
+}
+var Vt = !0, We = "Invariant failed";
+function te(t, n) {
+  if (!t) {
+    if (Vt)
+      throw new Error(We);
+    var e = typeof n == "function" ? n() : n, r = e ? "".concat(We, ": ").concat(e) : We;
+    throw new Error(r);
+  }
+}
+var At = !0;
+function Me(t, n) {
+  if (!At) {
+    if (t)
+      return;
+    var e = "Warning: " + n;
+    typeof console < "u" && console.warn(e);
+    try {
+      throw Error(e);
+    } catch {
+    }
+  }
+}
+var st = { exports: {} }, wt = {}, it = { exports: {} }, Pt = {};
+/**
+ * @license React
+ * use-sync-external-store-shim.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Se = vt;
+function Nt(t, n) {
+  return t === n && (t !== 0 || 1 / t === 1 / n) || t !== t && n !== n;
+}
+var $t = typeof Object.is == "function" ? Object.is : Nt, Kt = Se.useState, Ut = Se.useEffect, zt = Se.useLayoutEffect, Wt = Se.useDebugValue;
+function Ht(t, n) {
+  var e = n(), r = Kt({ inst: { value: e, getSnapshot: n } }), o = r[0].inst, s = r[1];
+  return zt(
+    function() {
+      o.value = e, o.getSnapshot = n, He(o) && s({ inst: o });
+    },
+    [t, e, n]
+  ), Ut(
+    function() {
+      return He(o) && s({ inst: o }), t(function() {
+        He(o) && s({ inst: o });
+      });
+    },
+    [t]
+  ), Wt(e), e;
+}
+function He(t) {
+  var n = t.getSnapshot;
+  t = t.value;
+  try {
+    var e = n();
+    return !$t(t, e);
+  } catch {
+    return !0;
+  }
+}
+function jt(t, n) {
+  return n();
+}
+var Gt = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? jt : Ht;
+Pt.useSyncExternalStore = Se.useSyncExternalStore !== void 0 ? Se.useSyncExternalStore : Gt;
+it.exports;
+it.exports = Pt;
+var Xt = it.exports;
+/**
+ * @license React
+ * use-sync-external-store-shim/with-selector.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Ne = vt, qt = Xt;
+function Jt(t, n) {
+  return t === n && (t !== 0 || 1 / t === 1 / n) || t !== t && n !== n;
+}
+var Yt = typeof Object.is == "function" ? Object.is : Jt, Qt = qt.useSyncExternalStore, Zt = Ne.useRef, en = Ne.useEffect, tn = Ne.useMemo, nn = Ne.useDebugValue;
+wt.useSyncExternalStoreWithSelector = function(t, n, e, r, o) {
+  var s = Zt(null);
+  if (s.current === null) {
+    var i = { hasValue: !1, value: null };
+    s.current = i;
+  } else i = s.current;
+  s = tn(
+    function() {
+      function l(f) {
+        if (!c) {
+          if (c = !0, d = f, f = r(f), o !== void 0 && i.hasValue) {
+            var p = i.value;
+            if (o(p, f))
+              return u = p;
+          }
+          return u = f;
+        }
+        if (p = u, Yt(d, f)) return p;
+        var S = r(f);
+        return o !== void 0 && o(p, S) ? (d = f, p) : (d = f, u = S);
+      }
+      var c = !1, d, u, h = e === void 0 ? null : e;
+      return [
+        function() {
+          return l(n());
+        },
+        h === null ? void 0 : function() {
+          return l(h());
+        }
+      ];
+    },
+    [n, e, r, o]
+  );
+  var a = Qt(t, s[0], s[1]);
+  return en(
+    function() {
+      i.hasValue = !0, i.value = a;
+    },
+    [a]
+  ), nn(a), a;
+};
+st.exports;
+st.exports = wt;
+var rn = st.exports;
+const me = /* @__PURE__ */ new WeakMap(), Te = /* @__PURE__ */ new WeakMap(), De = {
+  current: []
+};
+let je = !1, Ce = 0;
+const be = /* @__PURE__ */ new Set(), Ie = /* @__PURE__ */ new Map();
+function bt(t) {
+  const n = Array.from(t).sort((e, r) => e instanceof ge && e.options.deps.includes(r) ? 1 : r instanceof ge && r.options.deps.includes(e) ? -1 : 0);
+  for (const e of n) {
+    if (De.current.includes(e))
+      continue;
+    De.current.push(e), e.recompute();
+    const r = Te.get(e);
+    if (r)
+      for (const o of r) {
+        const s = me.get(o);
+        s && bt(s);
+      }
+  }
+}
+function on(t) {
+  t.listeners.forEach(
+    (n) => n({
+      prevVal: t.prevState,
+      currentVal: t.state
+    })
+  );
+}
+function sn(t) {
+  t.listeners.forEach(
+    (n) => n({
+      prevVal: t.prevState,
+      currentVal: t.state
+    })
+  );
+}
+function Rt(t) {
+  if (Ce > 0 && !Ie.has(t) && Ie.set(t, t.prevState), be.add(t), !(Ce > 0) && !je)
+    try {
+      for (je = !0; be.size > 0; ) {
+        const n = Array.from(be);
+        be.clear();
+        for (const e of n) {
+          const r = Ie.get(e) ?? e.prevState;
+          e.prevState = r, on(e);
+        }
+        for (const e of n) {
+          const r = me.get(e);
+          r && (De.current.push(e), bt(r));
+        }
+        for (const e of n) {
+          const r = me.get(e);
+          if (r)
+            for (const o of r)
+              sn(o);
+        }
+      }
+    } finally {
+      je = !1, De.current = [], Ie.clear();
+    }
+}
+function Ge(t) {
+  Ce++;
+  try {
+    t();
+  } finally {
+    if (Ce--, Ce === 0) {
+      const n = Array.from(be)[0];
+      n && Rt(n);
+    }
+  }
+}
+class nt {
+  constructor(n, e) {
+    this.listeners = /* @__PURE__ */ new Set(), this.subscribe = (r) => {
+      var o, s;
+      this.listeners.add(r);
+      const i = (s = (o = this.options) == null ? void 0 : o.onSubscribe) == null ? void 0 : s.call(o, r, this);
+      return () => {
+        this.listeners.delete(r), i?.();
+      };
+    }, this.setState = (r) => {
+      var o, s, i;
+      this.prevState = this.state, this.state = (o = this.options) != null && o.updateFn ? this.options.updateFn(this.prevState)(r) : r(this.prevState), (i = (s = this.options) == null ? void 0 : s.onUpdate) == null || i.call(s), Rt(this);
+    }, this.prevState = n, this.state = n, this.options = e;
+  }
+}
+class ge {
+  constructor(n) {
+    this.listeners = /* @__PURE__ */ new Set(), this._subscriptions = [], this.lastSeenDepValues = [], this.getDepVals = () => {
+      const e = [], r = [];
+      for (const o of this.options.deps)
+        e.push(o.prevState), r.push(o.state);
+      return this.lastSeenDepValues = r, {
+        prevDepVals: e,
+        currDepVals: r,
+        prevVal: this.prevState ?? void 0
+      };
+    }, this.recompute = () => {
+      var e, r;
+      this.prevState = this.state;
+      const { prevDepVals: o, currDepVals: s, prevVal: i } = this.getDepVals();
+      this.state = this.options.fn({
+        prevDepVals: o,
+        currDepVals: s,
+        prevVal: i
+      }), (r = (e = this.options).onUpdate) == null || r.call(e);
+    }, this.checkIfRecalculationNeededDeeply = () => {
+      for (const s of this.options.deps)
+        s instanceof ge && s.checkIfRecalculationNeededDeeply();
+      let e = !1;
+      const r = this.lastSeenDepValues, { currDepVals: o } = this.getDepVals();
+      for (let s = 0; s < o.length; s++)
+        if (o[s] !== r[s]) {
+          e = !0;
+          break;
+        }
+      e && this.recompute();
+    }, this.mount = () => (this.registerOnGraph(), this.checkIfRecalculationNeededDeeply(), () => {
+      this.unregisterFromGraph();
+      for (const e of this._subscriptions)
+        e();
+    }), this.subscribe = (e) => {
+      var r, o;
+      this.listeners.add(e);
+      const s = (o = (r = this.options).onSubscribe) == null ? void 0 : o.call(r, e, this);
+      return () => {
+        this.listeners.delete(e), s?.();
+      };
+    }, this.options = n, this.state = n.fn({
+      prevDepVals: void 0,
+      prevVal: void 0,
+      currDepVals: this.getDepVals().currDepVals
+    });
+  }
+  registerOnGraph(n = this.options.deps) {
+    for (const e of n)
+      if (e instanceof ge)
+        e.registerOnGraph(), this.registerOnGraph(e.options.deps);
+      else if (e instanceof nt) {
+        let r = me.get(e);
+        r || (r = /* @__PURE__ */ new Set(), me.set(e, r)), r.add(this);
+        let o = Te.get(this);
+        o || (o = /* @__PURE__ */ new Set(), Te.set(this, o)), o.add(e);
+      }
+  }
+  unregisterFromGraph(n = this.options.deps) {
+    for (const e of n)
+      if (e instanceof ge)
+        this.unregisterFromGraph(e.options.deps);
+      else if (e instanceof nt) {
+        const r = me.get(e);
+        r && r.delete(this);
+        const o = Te.get(this);
+        o && o.delete(e);
+      }
+  }
+}
+function an(t, n = (e) => e) {
+  return rn.useSyncExternalStoreWithSelector(
+    t.subscribe,
+    () => t.state,
+    () => t.state,
+    n,
+    cn
+  );
+}
+function cn(t, n) {
+  if (Object.is(t, n))
+    return !0;
+  if (typeof t != "object" || t === null || typeof n != "object" || n === null)
+    return !1;
+  if (t instanceof Map && n instanceof Map) {
+    if (t.size !== n.size) return !1;
+    for (const [r, o] of t)
+      if (!n.has(r) || !Object.is(o, n.get(r))) return !1;
+    return !0;
+  }
+  if (t instanceof Set && n instanceof Set) {
+    if (t.size !== n.size) return !1;
+    for (const r of t)
+      if (!n.has(r)) return !1;
+    return !0;
+  }
+  const e = Object.keys(t);
+  if (e.length !== Object.keys(n).length)
+    return !1;
+  for (let r = 0; r < e.length; r++)
+    if (!Object.prototype.hasOwnProperty.call(n, e[r]) || !Object.is(t[e[r]], n[e[r]]))
+      return !1;
+  return !0;
+}
+const H = "__root__";
+function un(t, n) {
+  let e, r, o, s = "";
+  for (e in t)
+    if ((o = t[e]) !== void 0)
+      if (Array.isArray(o))
+        for (r = 0; r < o.length; r++)
+          s && (s += "&"), s += encodeURIComponent(e) + "=" + encodeURIComponent(o[r]);
+      else
+        s && (s += "&"), s += encodeURIComponent(e) + "=" + encodeURIComponent(o);
+  return "" + s;
+}
+function ft(t) {
+  if (!t) return "";
+  const n = decodeURIComponent(t);
+  return n === "false" ? !1 : n === "true" ? !0 : +n * 0 === 0 && +n + "" === n ? +n : n;
+}
+function ln(t, n) {
+  let e, r;
+  const o = {}, s = t.split("&");
+  for (; e = s.shift(); ) {
+    const i = e.indexOf("=");
+    if (i !== -1) {
+      r = e.slice(0, i), r = decodeURIComponent(r);
+      const a = e.slice(i + 1);
+      o[r] !== void 0 ? o[r] = [].concat(o[r], ft(a)) : o[r] = ft(a);
+    } else
+      r = e, r = decodeURIComponent(r), o[r] = "";
+  }
+  return o;
+}
+const dn = fn(JSON.parse), hn = pn(
+  JSON.stringify,
+  JSON.parse
+);
+function fn(t) {
+  return (n) => {
+    n.substring(0, 1) === "?" && (n = n.substring(1));
+    const e = ln(n);
+    for (const r in e) {
+      const o = e[r];
+      if (typeof o == "string")
+        try {
+          e[r] = t(o);
+        } catch {
+        }
+    }
+    return e;
+  };
+}
+function pn(t, n) {
+  function e(r) {
+    if (typeof r == "object" && r !== null)
+      try {
+        return t(r);
+      } catch {
+      }
+    else if (typeof r == "string" && typeof n == "function")
+      try {
+        return n(r), t(r);
+      } catch {
+      }
+    return r;
+  }
+  return (r) => {
+    r = { ...r }, Object.keys(r).forEach((s) => {
+      const i = r[s];
+      typeof i > "u" || i === void 0 ? delete r[s] : r[s] = e(i);
+    });
+    const o = un(r).toString();
+    return o ? `?${o}` : "";
+  };
+}
+function Le(t) {
+  return t[t.length - 1];
+}
+function mn(t) {
+  return typeof t == "function";
+}
+function ue(t, n) {
+  return mn(t) ? t(n) : t;
+}
+function rt(t, n) {
+  return n.reduce((e, r) => (e[r] = t[r], e), {});
+}
+function X(t, n) {
+  if (t === n)
+    return t;
+  const e = n, r = mt(t) && mt(e);
+  if (r || Oe(t) && Oe(e)) {
+    const o = r ? t : Object.keys(t), s = o.length, i = r ? e : Object.keys(e), a = i.length, l = r ? [] : {};
+    let c = 0;
+    for (let d = 0; d < a; d++) {
+      const u = r ? d : i[d];
+      (!r && o.includes(u) || r) && t[u] === void 0 && e[u] === void 0 ? (l[u] = void 0, c++) : (l[u] = X(t[u], e[u]), l[u] === t[u] && t[u] !== void 0 && c++);
+    }
+    return s === a && c === s ? t : l;
+  }
+  return e;
+}
+function Oe(t) {
+  if (!pt(t))
+    return !1;
+  const n = t.constructor;
+  if (typeof n > "u")
+    return !0;
+  const e = n.prototype;
+  return !(!pt(e) || !e.hasOwnProperty("isPrototypeOf"));
+}
+function pt(t) {
+  return Object.prototype.toString.call(t) === "[object Object]";
+}
+function mt(t) {
+  return Array.isArray(t) && t.length === Object.keys(t).length;
+}
+function gt(t, n) {
+  let e = Object.keys(t);
+  return n && (e = e.filter((r) => t[r] !== void 0)), e;
+}
+function ye(t, n, e) {
+  if (t === n)
+    return !0;
+  if (typeof t != typeof n)
+    return !1;
+  if (Oe(t) && Oe(n)) {
+    const r = e?.ignoreUndefined ?? !0, o = gt(t, r), s = gt(n, r);
+    return !e?.partial && o.length !== s.length ? !1 : s.every((i) => ye(t[i], n[i], e));
+  }
+  return Array.isArray(t) && Array.isArray(n) ? t.length !== n.length ? !1 : !t.some((r, o) => !ye(r, n[o], e)) : !1;
+}
+const Re = typeof window < "u" ? b.useLayoutEffect : b.useEffect;
+function pe(t) {
+  let n, e;
+  const r = new Promise((o, s) => {
+    n = o, e = s;
+  });
+  return r.status = "pending", r.resolve = (o) => {
+    r.status = "resolved", r.value = o, n(o), t?.(o);
+  }, r.reject = (o) => {
+    r.status = "rejected", e(o);
+  }, r;
+}
+function Xe(t) {
+  const n = b.useRef({
+    value: t,
+    prev: null
+  }), e = n.current.value;
+  return t !== e && (n.current = {
+    value: t,
+    prev: e
+  }), n.current.prev;
+}
+function gn(t, n, e = {}, r = {}) {
+  const o = b.useRef(
+    typeof IntersectionObserver == "function"
+  ), s = b.useRef(null);
+  return b.useEffect(() => {
+    if (!(!t.current || !o.current || r.disabled))
+      return s.current = new IntersectionObserver(([i]) => {
+        n(i);
+      }, e), s.current.observe(t.current), () => {
+        var i;
+        (i = s.current) == null || i.disconnect();
+      };
+  }, [n, e, r.disabled, t]), s.current;
+}
+function yn(t) {
+  const n = b.useRef(null);
+  return b.useEffect(() => {
+    t && (typeof t == "function" ? t(n.current) : t.current = n.current);
+  }), n;
+}
+function re(t) {
+  return $e(
+    t.filter((n) => n !== void 0).join("/")
+  );
+}
+function $e(t) {
+  return t.replace(/\/{2,}/g, "/");
+}
+function at(t) {
+  return t === "/" ? t : t.replace(/^\/{1,}/, "");
+}
+function le(t) {
+  return t === "/" ? t : t.replace(/\/{1,}$/, "");
+}
+function vn(t) {
+  return le(at(t));
+}
+function Ve(t, n) {
+  return t.endsWith("/") && t !== "/" && t !== `${n}/` ? t.slice(0, -1) : t;
+}
+function Sn(t, n, e) {
+  return Ve(t, e) === Ve(n, e);
+}
+function _n({
+  basepath: t,
+  base: n,
+  to: e,
+  trailingSlash: r = "never",
+  caseSensitive: o
+}) {
+  var s, i;
+  n = Ae(t, n, o), e = Ae(t, e, o);
+  let a = _e(n);
+  const l = _e(e);
+  a.length > 1 && ((s = Le(a)) == null ? void 0 : s.value) === "/" && a.pop(), l.forEach((d, u) => {
+    d.value === "/" ? u ? u === l.length - 1 && a.push(d) : a = [d] : d.value === ".." ? a.pop() : d.value === "." || a.push(d);
+  }), a.length > 1 && (((i = Le(a)) == null ? void 0 : i.value) === "/" ? r === "never" && a.pop() : r === "always" && a.push({ type: "pathname", value: "/" }));
+  const c = re([t, ...a.map((d) => d.value)]);
+  return $e(c);
+}
+function _e(t) {
+  if (!t)
+    return [];
+  t = $e(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((r) => r === "$" || r === "*" ? {
+      type: "wildcard",
+      value: r
+    } : r.charAt(0) === "$" ? {
+      type: "param",
+      value: r
+    } : {
+      type: "pathname",
+      value: decodeURI(r)
+    })
+  ), t.slice(-1) === "/" && (t = t.substring(1), n.push({
+    type: "pathname",
+    value: "/"
+  })), n;
+}
+function ke({
+  path: t,
+  params: n,
+  leaveWildcards: e,
+  leaveParams: r,
+  decodeCharMap: o
+}) {
+  const s = _e(t), i = {};
+  for (const [a, l] of Object.entries(n)) {
+    const c = typeof l == "string";
+    ["*", "_splat"].includes(a) ? i[a] = c ? encodeURI(l) : l : i[a] = c ? wn(l, o) : l;
+  }
+  return re(
+    s.map((a) => {
+      if (a.type === "wildcard") {
+        const l = i._splat;
+        return e ? `${a.value}${l ?? ""}` : l;
+      }
+      if (a.type === "param") {
+        if (r) {
+          const l = i[a.value];
+          return `${a.value}${l ?? ""}`;
+        }
+        return i[a.value.substring(1)] ?? "undefined";
+      }
+      return a.value;
+    })
+  );
+}
+function wn(t, n) {
+  let e = encodeURIComponent(t);
+  if (n)
+    for (const [r, o] of n)
+      e = e.replaceAll(r, o);
+  return e;
+}
+function Fe(t, n, e) {
+  const r = Pn(t, n, e);
+  if (!(e.to && !r))
+    return r ?? {};
+}
+function Ae(t, n, e = !1) {
+  const r = e ? t : t.toLowerCase(), o = e ? n : n.toLowerCase();
+  switch (!0) {
+    case r === "/":
+      return n;
+    case o === r:
+      return "";
+    case n.length < t.length:
+      return n;
+    case o[r.length] !== "/":
+      return n;
+    case o.startsWith(r):
+      return n.slice(t.length);
+    default:
+      return n;
+  }
+}
+function Pn(t, n, e) {
+  if (t !== "/" && !n.startsWith(t))
+    return;
+  n = Ae(t, n, e.caseSensitive);
+  const r = Ae(
+    t,
+    `${e.to ?? "$"}`,
+    e.caseSensitive
+  ), o = _e(n), s = _e(r);
+  n.startsWith("/") || o.unshift({
+    type: "pathname",
+    value: "/"
+  }), r.startsWith("/") || s.unshift({
+    type: "pathname",
+    value: "/"
+  });
+  const i = {};
+  return (() => {
+    for (let l = 0; l < Math.max(o.length, s.length); l++) {
+      const c = o[l], d = s[l], u = l >= o.length - 1, h = l >= s.length - 1;
+      if (d) {
+        if (d.type === "wildcard") {
+          const f = decodeURI(
+            re(o.slice(l).map((p) => p.value))
+          );
+          return i["*"] = f, i._splat = f, !0;
+        }
+        if (d.type === "pathname") {
+          if (d.value === "/" && !c?.value)
+            return !0;
+          if (c) {
+            if (e.caseSensitive) {
+              if (d.value !== c.value)
+                return !1;
+            } else if (d.value.toLowerCase() !== c.value.toLowerCase())
+              return !1;
+          }
+        }
+        if (!c)
+          return !1;
+        if (d.type === "param") {
+          if (c.value === "/")
+            return !1;
+          c.value.charAt(0) !== "$" && (i[d.value.substring(1)] = decodeURIComponent(
+            c.value
+          ));
+        }
+      }
+      if (!u && h)
+        return i["**"] = re(o.slice(l + 1).map((f) => f.value)), !!e.fuzzy && d?.value !== "/";
+    }
+    return !0;
+  })() ? i : void 0;
+}
+function ce(t) {
+  return !!t?.isRedirect;
+}
+function qe(t) {
+  return !!t?.isRedirect && t.href;
+}
+function ct(t) {
+  const n = t.errorComponent ?? Ke;
+  return /* @__PURE__ */ C(
+    bn,
+    {
+      getResetKey: t.getResetKey,
+      onCatch: t.onCatch,
+      children: ({ error: e, reset: r }) => e ? b.createElement(n, {
+        error: e,
+        reset: r
+      }) : t.children
+    }
+  );
+}
+class bn extends b.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 Ke({ error: t }) {
+  const [n, e] = b.useState(!1);
+  return /* @__PURE__ */ et("div", { style: { padding: ".5rem", maxWidth: "100%" }, children: [
+    /* @__PURE__ */ et("div", { style: { display: "flex", alignItems: "center", gap: ".5rem" }, children: [
+      /* @__PURE__ */ C("strong", { style: { fontSize: "1rem" }, children: "Something went wrong!" }),
+      /* @__PURE__ */ C(
+        "button",
+        {
+          style: {
+            appearance: "none",
+            fontSize: ".6em",
+            border: "1px solid currentColor",
+            padding: ".1rem .2rem",
+            fontWeight: "bold",
+            borderRadius: ".25rem"
+          },
+          onClick: () => e((r) => !r),
+          children: n ? "Hide Error" : "Show Error"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ C("div", { style: { height: ".25rem" } }),
+    n ? /* @__PURE__ */ C("div", { children: /* @__PURE__ */ C(
+      "pre",
+      {
+        style: {
+          fontSize: ".7em",
+          border: "1px solid red",
+          borderRadius: ".25rem",
+          padding: ".3rem",
+          color: "red",
+          overflow: "auto"
+        },
+        children: t.message ? /* @__PURE__ */ C("code", { children: t.message }) : null
+      }
+    ) }) : null
+  ] });
+}
+const Je = b.createContext(null);
+function Ct() {
+  return typeof document > "u" ? Je : window.__TSR_ROUTER_CONTEXT__ ? window.__TSR_ROUTER_CONTEXT__ : (window.__TSR_ROUTER_CONTEXT__ = Je, Je);
+}
+function oe(t) {
+  const n = b.useContext(Ct());
+  return Me(
+    !((t?.warn ?? !0) && !n),
+    "useRouter must be used inside a <RouterProvider> component!"
+  ), n;
+}
+function z(t) {
+  const n = oe({
+    warn: t?.router === void 0
+  }), e = t?.router || n, r = Tt(void 0);
+  return an(e.__store, (o) => {
+    if (t?.select) {
+      if (t.structuralSharing ?? e.options.defaultStructuralSharing) {
+        const s = X(
+          r.current,
+          t.select(o)
+        );
+        return r.current = s, s;
+      }
+      return t.select(o);
+    }
+    return o;
+  });
+}
+function or(t = {}) {
+  if (t.isNotFound = !0, t.throw) throw t;
+  return t;
+}
+function ee(t) {
+  return !!t?.isNotFound;
+}
+function Rn(t) {
+  const n = z({
+    select: (e) => `not-found-${e.location.pathname}-${e.status}`
+  });
+  return /* @__PURE__ */ C(
+    ct,
+    {
+      getResetKey: () => n,
+      onCatch: (e, r) => {
+        var o;
+        if (ee(e))
+          (o = t.onCatch) == null || o.call(t, e, r);
+        else
+          throw e;
+      },
+      errorComponent: ({ error: e }) => {
+        var r;
+        if (ee(e))
+          return (r = t.fallback) == null ? void 0 : r.call(t, e);
+        throw e;
+      },
+      children: t.children
+    }
+  );
+}
+function Cn() {
+  return /* @__PURE__ */ C("p", { children: "Not Found" });
+}
+const Lt = [
+  "component",
+  "errorComponent",
+  "pendingComponent",
+  "notFoundComponent"
+];
+function Ln(t) {
+  var n;
+  for (const e of Lt)
+    if ((n = t.options[e]) != null && n.preload)
+      return !0;
+  return !1;
+}
+function Ye(t, n) {
+  if (t == null) return {};
+  if ("~standard" in t) {
+    const e = t["~standard"].validate(n);
+    if (e instanceof Promise)
+      throw new ot("Async validation not supported");
+    if (e.issues)
+      throw new ot(JSON.stringify(e.issues, void 0, 2));
+    return e.value;
+  }
+  return "parse" in t ? t.parse(n) : typeof t == "function" ? t(n) : {};
+}
+function sr(t) {
+  return new Mn(t);
+}
+class Mn {
+  /**
+   * @deprecated Use the `createRouter` function instead
+   */
+  constructor(n) {
+    this.tempLocationKey = `${Math.round(
+      Math.random() * 1e7
+    )}`, this.resetNextScroll = !0, this.shouldViewTransition = void 0, this.isViewTransitionTypesSupported = void 0, this.subscribers = /* @__PURE__ */ new Set(), this.startReactTransition = (e) => e(), this.update = (e) => {
+      var r;
+      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.pathParamsDecodeCharMap = this.options.pathParamsAllowedCharacters ? new Map(
+        this.options.pathParamsAllowedCharacters.map((s) => [
+          encodeURIComponent(s),
+          s
+        ])
+      ) : void 0, (!this.basepath || e.basepath && e.basepath !== o.basepath) && (e.basepath === void 0 || e.basepath === "" || e.basepath === "/" ? this.basepath = "/" : this.basepath = `/${vn(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 ? Dt({
+        initialEntries: [this.basepath || "/"]
+      }) : _t()), this.latestLocation = this.parseLocation()), this.options.routeTree !== this.routeTree && (this.routeTree = this.options.routeTree, this.buildRouteTree()), this.__store || (this.__store = new nt(En(this.latestLocation), {
+        onUpdate: () => {
+          this.__store.state = {
+            ...this.state,
+            cachedMatches: this.state.cachedMatches.filter(
+              (s) => !["redirected"].includes(s.status)
+            )
+          };
+        }
+      })), typeof window < "u" && "CSS" in window && // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      typeof ((r = window.CSS) == null ? void 0 : r.supports) == "function" && (this.isViewTransitionTypesSupported = window.CSS.supports(
+        "selector(:active-view-transition-type(a)"
+      ));
+    }, this.buildRouteTree = () => {
+      this.routesById = {}, this.routesByPath = {};
+      const e = this.options.notFoundRoute;
+      e && (e.init({
+        originalIndex: 99999999999,
+        defaultSsr: this.options.defaultSsr
+      }), this.routesById[e.id] = e);
+      const r = (i) => {
+        i.forEach((a, l) => {
+          a.init({
+            originalIndex: l,
+            defaultSsr: this.options.defaultSsr
+          });
+          const c = this.routesById[a.id];
+          if (te(
+            !c,
+            `Duplicate routes found with id: ${String(a.id)}`
+          ), this.routesById[a.id] = a, !a.isRoot && a.path) {
+            const u = le(a.fullPath);
+            (!this.routesByPath[u] || a.fullPath.endsWith("/")) && (this.routesByPath[u] = a);
+          }
+          const d = a.children;
+          d?.length && r(d);
+        });
+      };
+      r([this.routeTree]);
+      const o = [];
+      Object.values(this.routesById).forEach((i, a) => {
+        var l;
+        if (i.isRoot || !i.path)
+          return;
+        const c = at(i.fullPath), d = _e(c);
+        for (; d.length > 1 && ((l = d[0]) == null ? void 0 : l.value) === "/"; )
+          d.shift();
+        const u = d.map((h) => h.value === "/" ? 0.75 : h.type === "param" ? 0.5 : h.type === "wildcard" ? 0.25 : 1);
+        o.push({ child: i, trimmed: c, parsed: d, index: a, scores: u });
+      }), this.flatRoutes = o.sort((i, a) => {
+        const l = Math.min(i.scores.length, a.scores.length);
+        for (let c = 0; c < l; c++)
+          if (i.scores[c] !== a.scores[c])
+            return a.scores[c] - i.scores[c];
+        if (i.scores.length !== a.scores.length)
+          return a.scores.length - i.scores.length;
+        for (let c = 0; c < l; c++)
+          if (i.parsed[c].value !== a.parsed[c].value)
+            return i.parsed[c].value > a.parsed[c].value ? 1 : -1;
+        return i.index - a.index;
+      }).map((i, a) => (i.child.rank = a, i.child));
+    }, this.subscribe = (e, r) => {
+      const o = {
+        eventType: e,
+        fn: r
+      };
+      return this.subscribers.add(o), () => {
+        this.subscribers.delete(o);
+      };
+    }, this.emit = (e) => {
+      this.subscribers.forEach((r) => {
+        r.eventType === e.type && r.fn(e);
+      });
+    }, this.parseLocation = (e, r) => {
+      const o = ({
+        pathname: l,
+        search: c,
+        hash: d,
+        state: u
+      }) => {
+        const h = this.options.parseSearch(c), f = this.options.stringifySearch(h);
+        return {
+          pathname: l,
+          searchStr: f,
+          search: X(e?.search, h),
+          hash: d.split("#").reverse()[0] ?? "",
+          href: `${l}${f}${d}`,
+          state: X(e?.state, u)
+        };
+      }, s = o(r ?? this.history.location), { __tempLocation: i, __tempKey: a } = s.state;
+      if (i && (!a || a === this.tempLocationKey)) {
+        const l = o(i);
+        return l.state.key = s.state.key, delete l.state.__tempLocation, {
+          ...l,
+          maskedLocation: s
+        };
+      }
+      return s;
+    }, this.resolvePathWithBase = (e, r) => _n({
+      basepath: this.basepath,
+      base: e,
+      to: $e(r),
+      trailingSlash: this.options.trailingSlash,
+      caseSensitive: this.options.caseSensitive
+    }), this.getMatchedRoutes = (e, r) => {
+      let o = {};
+      const s = le(e.pathname), i = (d) => Fe(this.basepath, s, {
+        to: d.fullPath,
+        caseSensitive: d.options.caseSensitive ?? this.options.caseSensitive,
+        fuzzy: !0
+      });
+      let a = r?.to !== void 0 ? this.routesByPath[r.to] : void 0;
+      a ? o = i(a) : a = this.flatRoutes.find((d) => {
+        const u = i(d);
+        return u ? (o = u, !0) : !1;
+      });
+      let l = a || this.routesById[H];
+      const c = [l];
+      for (; l.parentRoute; )
+        l = l.parentRoute, c.unshift(l);
+      return { matchedRoutes: c, routeParams: o, foundRoute: a };
+    }, this.cancelMatch = (e) => {
+      const r = this.getMatch(e);
+      r && (r.abortController.abort(), clearTimeout(r.pendingTimeout));
+    }, this.cancelMatches = () => {
+      var e;
+      (e = this.state.pendingMatches) == null || e.forEach((r) => {
+        this.cancelMatch(r.id);
+      });
+    }, this.buildLocation = (e) => {
+      const r = (s = {}, i) => {
+        var a, l, c, d, u, h;
+        const f = s._fromLocation ? this.matchRoutes(s._fromLocation, { _buildLocation: !0 }) : this.state.matches, p = s.from != null ? f.find(
+          (m) => Fe(this.basepath, le(m.pathname), {
+            to: s.from,
+            caseSensitive: !1,
+            fuzzy: !1
+          })
+        ) : void 0, S = p?.pathname || this.latestLocation.pathname;
+        te(
+          s.from == null || p != null,
+          "Could not find match for from: " + s.from
+        );
+        const y = (a = this.state.pendingMatches) != null && a.length ? (l = Le(this.state.pendingMatches)) == null ? void 0 : l.search : ((c = Le(f)) == null ? void 0 : c.search) || this.latestLocation.search, M = i?.matchedRoutes.filter(
+          (m) => f.find((w) => w.routeId === m.id)
+        );
+        let R;
+        if (s.to)
+          R = this.resolvePathWithBase(S, `${s.to}`);
+        else {
+          const m = this.routesById[(d = M?.find((w) => {
+            const k = ke({
+              path: w.fullPath,
+              params: i?.routeParams ?? {},
+              decodeCharMap: this.pathParamsDecodeCharMap
+            });
+            return re([this.basepath, k]) === S;
+          })) == null ? void 0 : d.id];
+          R = this.resolvePathWithBase(
+            S,
+            m?.to ?? S
+          );
+        }
+        const L = { ...(u = Le(f)) == null ? void 0 : u.params };
+        let P = (s.params ?? !0) === !0 ? L : {
+          ...L,
+          ...ue(s.params, L)
+        };
+        Object.keys(P).length > 0 && i?.matchedRoutes.map((m) => {
+          var w;
+          return ((w = m.options.params) == null ? void 0 : w.stringify) ?? m.options.stringifyParams;
+        }).filter(Boolean).forEach((m) => {
+          P = { ...P, ...m(P) };
+        }), R = ke({
+          path: R,
+          params: P ?? {},
+          leaveWildcards: !1,
+          leaveParams: e.leaveParams,
+          decodeCharMap: this.pathParamsDecodeCharMap
+        });
+        let g = y;
+        if (e._includeValidateSearch && ((h = this.options.search) != null && h.strict)) {
+          let m = {};
+          i?.matchedRoutes.forEach((w) => {
+            try {
+              w.options.validateSearch && (m = {
+                ...m,
+                ...Ye(w.options.validateSearch, {
+                  ...m,
+                  ...g
+                }) ?? {}
+              });
+            } catch {
+            }
+          }), g = m;
+        }
+        g = ((m) => {
+          const w = i?.matchedRoutes.reduce(
+            (I, D) => {
+              var W;
+              const q = [];
+              if ("search" in D.options)
+                (W = D.options.search) != null && W.middlewares && q.push(...D.options.search.middlewares);
+              else if (D.options.preSearchFilters || D.options.postSearchFilters) {
+                const J = ({
+                  search: j,
+                  next: ne
+                }) => {
+                  let O = j;
+                  "preSearchFilters" in D.options && D.options.preSearchFilters && (O = D.options.preSearchFilters.reduce(
+                    (V, A) => A(V),
+                    j
+                  ));
+                  const K = ne(O);
+                  return "postSearchFilters" in D.options && D.options.postSearchFilters ? D.options.postSearchFilters.reduce(
+                    (V, A) => A(V),
+                    K
+                  ) : K;
+                };
+                q.push(J);
+              }
+              if (e._includeValidateSearch && D.options.validateSearch) {
+                const J = ({ search: j, next: ne }) => {
+                  try {
+                    const O = ne(j);
+                    return {
+                      ...O,
+                      ...Ye(
+                        D.options.validateSearch,
+                        O
+                      ) ?? {}
+                    };
+                  } catch {
+                  }
+                };
+                q.push(J);
+              }
+              return I.concat(q);
+            },
+            []
+          ) ?? [], k = ({ search: I }) => s.search ? s.search === !0 ? I : ue(s.search, I) : {};
+          w.push(k);
+          const T = (I, D) => {
+            if (I >= w.length)
+              return D;
+            const W = w[I];
+            return W({ search: D, next: (J) => T(I + 1, J) });
+          };
+          return T(0, m);
+        })(g), g = X(y, g);
+        const F = this.options.stringifySearch(g), v = s.hash === !0 ? this.latestLocation.hash : s.hash ? ue(s.hash, this.latestLocation.hash) : void 0, _ = v ? `#${v}` : "";
+        let E = s.state === !0 ? this.latestLocation.state : s.state ? ue(s.state, this.latestLocation.state) : {};
+        return E = X(this.latestLocation.state, E), {
+          pathname: R,
+          search: g,
+          searchStr: F,
+          state: E,
+          hash: v ?? "",
+          href: `${R}${F}${_}`,
+          unmaskOnReload: s.unmaskOnReload
+        };
+      }, o = (s = {}, i) => {
+        var a;
+        const l = r(s);
+        let c = i ? r(i) : void 0;
+        if (!c) {
+          let h = {};
+          const f = (a = this.options.routeMasks) == null ? void 0 : a.find((p) => {
+            const S = Fe(this.basepath, l.pathname, {
+              to: p.from,
+              caseSensitive: !1,
+              fuzzy: !1
+            });
+            return S ? (h = S, !0) : !1;
+          });
+          if (f) {
+            const { from: p, ...S } = f;
+            i = {
+              ...rt(e, ["from"]),
+              ...S,
+              params: h
+            }, c = r(i);
+          }
+        }
+        const d = this.getMatchedRoutes(l, s), u = r(s, d);
+        if (c) {
+          const h = this.getMatchedRoutes(c, i), f = r(i, h);
+          u.maskedLocation = f;
+        }
+        return u;
+      };
+      return e.mask ? o(e, {
+        ...rt(e, ["from"]),
+        ...e.mask
+      }) : o(e);
+    }, this.commitLocation = ({
+      viewTransition: e,
+      ignoreBlocker: r,
+      ...o
+    }) => {
+      const s = () => {
+        o.state.key = this.latestLocation.state.key;
+        const l = ye(o.state, this.latestLocation.state);
+        return delete o.state.key, l;
+      }, i = this.latestLocation.href === o.href, a = this.commitLocationPromise;
+      if (this.commitLocationPromise = pe(() => {
+        a?.resolve();
+      }), i && s())
+        this.load();
+      else {
+        let { maskedLocation: l, hashScrollIntoView: c, ...d } = o;
+        l && (d = {
+          ...l,
+          state: {
+            ...l.state,
+            __tempKey: void 0,
+            __tempLocation: {
+              ...d,
+              search: d.searchStr,
+              state: {
+                ...d.state,
+                __tempKey: void 0,
+                __tempLocation: void 0,
+                key: void 0
+              }
+            }
+          }
+        }, (d.unmaskOnReload ?? this.options.unmaskOnReload ?? !1) && (d.state.__tempKey = this.tempLocationKey)), d.state.__hashScrollIntoViewOptions = c ?? this.options.defaultHashScrollIntoView ?? !0, this.shouldViewTransition = e, this.history[o.replace ? "replace" : "push"](
+          d.href,
+          d.state,
+          { ignoreBlocker: r }
+        );
+      }
+      return this.resetNextScroll = o.resetScroll ?? !0, this.history.subscribers.size || this.load(), this.commitLocationPromise;
+    }, this.buildAndCommitLocation = ({
+      replace: e,
+      resetScroll: r,
+      hashScrollIntoView: o,
+      viewTransition: s,
+      ignoreBlocker: i,
+      href: a,
+      ...l
+    } = {}) => {
+      if (a) {
+        const d = this.history.location.state.__TSR_index, u = ve(a, {
+          __TSR_index: e ? d : d + 1
+        });
+        l.to = u.pathname, l.search = this.options.parseSearch(u.search), l.hash = u.hash.slice(1);
+      }
+      const c = this.buildLocation({
+        ...l,
+        _includeValidateSearch: !0
+      });
+      return this.commitLocation({
+        ...c,
+        viewTransition: s,
+        replace: e,
+        resetScroll: r,
+        hashScrollIntoView: o,
+        ignoreBlocker: i
+      });
+    }, this.navigate = ({ to: e, reloadDocument: r, href: o, ...s }) => {
+      if (r) {
+        o || (o = this.buildLocation({ to: e, ...s }).href), s.replace ? window.location.replace(o) : window.location.href = o;
+        return;
+      }
+      return this.buildAndCommitLocation({
+        ...s,
+        href: o,
+        to: e
+      });
+    }, this.load = async (e) => {
+      this.latestLocation = this.parseLocation(this.latestLocation);
+      let r, o, s;
+      for (s = new Promise((i) => {
+        this.startReactTransition(async () => {
+          var a;
+          try {
+            const l = this.latestLocation, c = this.state.resolvedLocation, d = c.href !== l.href, u = c.pathname !== l.pathname;
+            this.cancelMatches();
+            let h;
+            Ge(() => {
+              h = this.matchRoutes(l), this.__store.setState((f) => ({
+                ...f,
+                status: "pending",
+                isLoading: !0,
+                location: l,
+                pendingMatches: h,
+                // If a cached moved to pendingMatches, remove it from cachedMatches
+                cachedMatches: f.cachedMatches.filter((p) => !h.find((S) => S.id === p.id))
+              }));
+            }), this.state.redirect || this.emit({
+              type: "onBeforeNavigate",
+              fromLocation: c,
+              toLocation: l,
+              pathChanged: u,
+              hrefChanged: d
+            }), this.emit({
+              type: "onBeforeLoad",
+              fromLocation: c,
+              toLocation: l,
+              pathChanged: u,
+              hrefChanged: d
+            }), await this.loadMatches({
+              sync: e?.sync,
+              matches: h,
+              location: l,
+              // eslint-disable-next-line @typescript-eslint/require-await
+              onReady: async () => {
+                this.startViewTransition(async () => {
+                  let f, p, S;
+                  Ge(() => {
+                    this.__store.setState((y) => {
+                      const M = y.matches, R = y.pendingMatches || y.matches;
+                      return f = M.filter(
+                        (L) => !R.find((P) => P.id === L.id)
+                      ), p = R.filter(
+                        (L) => !M.find((P) => P.id === L.id)
+                      ), S = M.filter(
+                        (L) => R.find((P) => P.id === L.id)
+                      ), {
+                        ...y,
+                        isLoading: !1,
+                        loadedAt: Date.now(),
+                        matches: R,
+                        pendingMatches: void 0,
+                        cachedMatches: [
+                          ...y.cachedMatches,
+                          ...f.filter((L) => L.status !== "error")
+                        ]
+                      };
+                    }), this.clearExpiredCache();
+                  }), [
+                    [f, "onLeave"],
+                    [p, "onEnter"],
+                    [S, "onStay"]
+                  ].forEach(([y, M]) => {
+                    y.forEach((R) => {
+                      var L, P;
+                      (P = (L = this.looseRoutesById[R.routeId].options)[M]) == null || P.call(L, R);
+                    });
+                  });
+                });
+              }
+            });
+          } catch (l) {
+            qe(l) ? (r = l, this.isServer || this.navigate({
+              ...r,
+              replace: !0,
+              ignoreBlocker: !0
+            })) : ee(l) && (o = l), this.__store.setState((c) => ({
+              ...c,
+              statusCode: r ? r.statusCode : o ? 404 : c.matches.some((d) => d.status === "error") ? 500 : 200,
+              redirect: r
+            }));
+          }
+          this.latestLoadPromise === s && ((a = this.commitLocationPromise) == null || a.resolve(), this.latestLoadPromise = void 0, this.commitLocationPromise = void 0), i();
+        });
+      }), this.latestLoadPromise = s, await s; this.latestLoadPromise && s !== this.latestLoadPromise; )
+        await this.latestLoadPromise;
+    }, this.startViewTransition = (e) => {
+      const r = this.shouldViewTransition ?? this.options.defaultViewTransition;
+      if (delete this.shouldViewTransition, r && typeof document < "u" && "startViewTransition" in document && typeof document.startViewTransition == "function") {
+        let o;
+        typeof r == "object" && this.isViewTransitionTypesSupported ? o = {
+          update: e,
+          types: r.types
+        } : o = e, document.startViewTransition(o);
+      } else
+        e();
+    }, this.updateMatch = (e, r) => {
+      var o;
+      let s;
+      const i = (o = this.state.pendingMatches) == null ? void 0 : o.find((d) => d.id === e), a = this.state.matches.find((d) => d.id === e), l = this.state.cachedMatches.find((d) => d.id === e), c = i ? "pendingMatches" : a ? "matches" : l ? "cachedMatches" : "";
+      return c && this.__store.setState((d) => {
+        var u;
+        return {
+          ...d,
+          [c]: (u = d[c]) == null ? void 0 : u.map(
+            (h) => h.id === e ? s = r(h) : h
+          )
+        };
+      }), s;
+    }, this.getMatch = (e) => [
+      ...this.state.cachedMatches,
+      ...this.state.pendingMatches ?? [],
+      ...this.state.matches
+    ].find((r) => r.id === e), this.loadMatches = async ({
+      location: e,
+      matches: r,
+      preload: o,
+      onReady: s,
+      updateMatch: i = this.updateMatch,
+      sync: a
+    }) => {
+      let l, c = !1;
+      const d = async () => {
+        c || (c = !0, await s?.());
+      }, u = (f) => !!(o && !this.state.matches.find((p) => p.id === f));
+      !this.isServer && !this.state.matches.length && d();
+      const h = (f, p) => {
+        var S, y, M;
+        if (qe(p) && !p.reloadDocument)
+          throw p;
+        if (ce(p) || ee(p)) {
+          if (i(f.id, (R) => ({
+            ...R,
+            status: ce(p) ? "redirected" : ee(p) ? "notFound" : "error",
+            isFetching: !1,
+            error: p,
+            beforeLoadPromise: void 0,
+            loaderPromise: void 0
+          })), p.routeId || (p.routeId = f.routeId), (S = f.beforeLoadPromise) == null || S.resolve(), (y = f.loaderPromise) == null || y.resolve(), (M = f.loadPromise) == null || M.resolve(), ce(p))
+            throw c = !0, p = this.resolveRedirect({ ...p, _fromLocation: e }), p;
+          if (ee(p))
+            throw this._handleNotFound(r, p, {
+              updateMatch: i
+            }), p;
+        }
+      };
+      try {
+        await new Promise((f, p) => {
+          (async () => {
+            var S, y, M;
+            try {
+              const R = (g, x, F) => {
+                var v, _;
+                const { id: E, routeId: m } = r[g], w = this.looseRoutesById[m];
+                if (x instanceof Promise)
+                  throw x;
+                x.routerCode = F, l = l ?? g, h(this.getMatch(E), x);
+                try {
+                  (_ = (v = w.options).onError) == null || _.call(v, x);
+                } catch (k) {
+                  x = k, h(this.getMatch(E), x);
+                }
+                i(E, (k) => {
+                  var T, I;
+                  return (T = k.beforeLoadPromise) == null || T.resolve(), (I = k.loadPromise) == null || I.resolve(), {
+                    ...k,
+                    error: x,
+                    status: "error",
+                    isFetching: !1,
+                    updatedAt: Date.now(),
+                    abortController: new AbortController(),
+                    beforeLoadPromise: void 0
+                  };
+                });
+              };
+              for (const [g, { id: x, routeId: F }] of r.entries()) {
+                const v = this.getMatch(x), _ = (S = r[g - 1]) == null ? void 0 : S.id, E = this.looseRoutesById[F], m = E.options.pendingMs ?? this.options.defaultPendingMs, w = !!(s && !this.isServer && !u(x) && (E.options.loader || E.options.beforeLoad) && typeof m == "number" && m !== 1 / 0 && (E.options.pendingComponent ?? this.options.defaultPendingComponent));
+                let k = !0;
+                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)
+                  (v.beforeLoadPromise || v.loaderPromise) && (w && setTimeout(() => {
+                    try {
+                      d();
+                    } catch {
+                    }
+                  }, m), await v.beforeLoadPromise, k = this.getMatch(x).status !== "success"), k
+                ) {
+                  try {
+                    i(x, (N) => ({
+                      ...N,
+                      loadPromise: pe(() => {
+                        var G;
+                        (G = N.loadPromise) == null || G.resolve();
+                      }),
+                      beforeLoadPromise: pe()
+                    }));
+                    const T = new AbortController();
+                    let I;
+                    w && (I = setTimeout(() => {
+                      try {
+                        d();
+                      } catch {
+                      }
+                    }, m));
+                    const { paramsError: D, searchError: W } = this.getMatch(x);
+                    D && R(g, D, "PARSE_PARAMS"), W && R(g, W, "VALIDATE_SEARCH");
+                    const q = () => _ ? this.getMatch(_).context : this.options.context ?? {};
+                    i(x, (N) => ({
+                      ...N,
+                      isFetching: "beforeLoad",
+                      fetchCount: N.fetchCount + 1,
+                      abortController: T,
+                      pendingTimeout: I,
+                      context: {
+                        ...q(),
+                        ...N.__routeContext
+                      }
+                    }));
+                    const { search: J, params: j, context: ne, cause: O } = this.getMatch(x), K = u(x), V = {
+                      search: J,
+                      abortController: T,
+                      params: j,
+                      preload: K,
+                      context: ne,
+                      location: e,
+                      navigate: (N) => this.navigate({ ...N, _fromLocation: e }),
+                      buildLocation: this.buildLocation,
+                      cause: K ? "preload" : O,
+                      matches: r
+                    }, A = await ((M = (y = E.options).beforeLoad) == null ? void 0 : M.call(y, V)) ?? {};
+                    (ce(A) || ee(A)) && R(g, A, "BEFORE_LOAD"), i(x, (N) => ({
+                      ...N,
+                      __beforeLoadContext: A,
+                      context: {
+                        ...q(),
+                        ...N.__routeContext,
+                        ...A
+                      },
+                      abortController: T
+                    }));
+                  } catch (T) {
+                    R(g, T, "BEFORE_LOAD");
+                  }
+                  i(x, (T) => {
+                    var I;
+                    return (I = T.beforeLoadPromise) == null || I.resolve(), {
+                      ...T,
+                      beforeLoadPromise: void 0,
+                      isFetching: !1
+                    };
+                  });
+                }
+              }
+              const L = r.slice(0, l), P = [];
+              L.forEach(({ id: g, routeId: x }, F) => {
+                P.push(
+                  (async () => {
+                    const { loaderPromise: v } = this.getMatch(g);
+                    let _ = !1, E = !1;
+                    if (v) {
+                      await v;
+                      const m = this.getMatch(g);
+                      m.error && h(m, m.error);
+                    } else {
+                      const m = P[F - 1], w = this.looseRoutesById[x], k = () => {
+                        const {
+                          params: O,
+                          loaderDeps: K,
+                          abortController: V,
+                          context: A,
+                          cause: N
+                        } = this.getMatch(g), G = u(g);
+                        return {
+                          params: O,
+                          deps: K,
+                          preload: !!G,
+                          parentMatchPromise: m,
+                          abortController: V,
+                          context: A,
+                          location: e,
+                          navigate: (Y) => this.navigate({ ...Y, _fromLocation: e }),
+                          cause: G ? "preload" : N,
+                          route: w
+                        };
+                      }, T = Date.now() - this.getMatch(g).updatedAt, I = u(g), D = I ? w.options.preloadStaleTime ?? this.options.defaultPreloadStaleTime ?? 3e4 : w.options.staleTime ?? this.options.defaultStaleTime ?? 0, W = w.options.shouldReload, q = typeof W == "function" ? W(k()) : W;
+                      i(g, (O) => ({
+                        ...O,
+                        loaderPromise: pe(),
+                        preload: !!I && !this.state.matches.find((K) => K.id === g)
+                      }));
+                      const J = async () => {
+                        var O, K, V, A, N, G, Y, xe, Ee;
+                        try {
+                          const ie = async () => {
+                            const U = this.getMatch(g);
+                            U.minPendingPromise && await U.minPendingPromise;
+                          };
+                          try {
+                            this.loadRouteChunk(w), i(g, (fe) => ({
+                              ...fe,
+                              isFetching: "loader"
+                            }));
+                            const U = await ((K = (O = w.options).loader) == null ? void 0 : K.call(O, k()));
+                            h(
+                              this.getMatch(g),
+                              U
+                            ), await w._lazyPromise, await ie();
+                            const Q = (A = (V = w.options).head) == null ? void 0 : A.call(V, {
+                              matches: r,
+                              match: this.getMatch(g),
+                              params: this.getMatch(g).params,
+                              loaderData: U
+                            }), se = Q?.meta, ae = Q?.links, we = Q?.scripts, Pe = (G = (N = w.options).headers) == null ? void 0 : G.call(N, {
+                              loaderData: U
+                            });
+                            i(g, (fe) => ({
+                              ...fe,
+                              error: void 0,
+                              status: "success",
+                              isFetching: !1,
+                              updatedAt: Date.now(),
+                              loaderData: U,
+                              meta: se,
+                              links: ae,
+                              scripts: we,
+                              headers: Pe
+                            }));
+                          } catch (U) {
+                            let Q = U;
+                            await ie(), h(this.getMatch(g), U);
+                            try {
+                              (xe = (Y = w.options).onError) == null || xe.call(Y, U);
+                            } catch (se) {
+                              Q = se, h(
+                                this.getMatch(g),
+                                se
+                              );
+                            }
+                            i(g, (se) => ({
+                              ...se,
+                              error: Q,
+                              status: "error",
+                              isFetching: !1
+                            }));
+                          }
+                          (Ee = this.serverSsr) == null || Ee.onMatchSettled({
+                            router: this,
+                            match: this.getMatch(g)
+                          }), await w._componentsPromise;
+                        } catch (ie) {
+                          i(g, (U) => ({
+                            ...U,
+                            loaderPromise: void 0
+                          })), h(this.getMatch(g), ie);
+                        }
+                      }, { status: j, invalid: ne } = this.getMatch(g);
+                      _ = j === "success" && (ne || (q ?? T > D)), I && w.options.preload === !1 || (_ && !a ? (E = !0, (async () => {
+                        try {
+                          await J();
+                          const { loaderPromise: O, loadPromise: K } = this.getMatch(g);
+                          O?.resolve(), K?.resolve(), i(g, (V) => ({
+                            ...V,
+                            loaderPromise: void 0
+                          }));
+                        } catch (O) {
+                          qe(O) && await this.navigate(O);
+                        }
+                      })()) : (j !== "success" || _ && a) && await J());
+                    }
+                    if (!E) {
+                      const { loaderPromise: m, loadPromise: w } = this.getMatch(g);
+                      m?.resolve(), w?.resolve();
+                    }
+                    return i(g, (m) => ({
+                      ...m,
+                      isFetching: E ? m.isFetching : !1,
+                      loaderPromise: E ? m.loaderPromise : void 0,
+                      invalid: !1
+                    })), this.getMatch(g);
+                  })()
+                );
+              }), await Promise.all(P), f();
+            } catch (R) {
+              p(R);
+            }
+          })();
+        }), await d();
+      } catch (f) {
+        if (ce(f) || ee(f))
+          throw ee(f) && !o && await d(), f;
+      }
+      return r;
+    }, this.invalidate = (e) => {
+      const r = (o) => {
+        var s;
+        return ((s = e?.filter) == null ? void 0 : s.call(e, o)) ?? !0 ? {
+          ...o,
+          invalid: !0,
+          ...o.status === "error" ? { status: "pending", error: void 0 } : {}
+        } : o;
+      };
+      return this.__store.setState((o) => {
+        var s;
+        return {
+          ...o,
+          matches: o.matches.map(r),
+          cachedMatches: o.cachedMatches.map(r),
+          pendingMatches: (s = o.pendingMatches) == null ? void 0 : s.map(r)
+        };
+      }), this.load({ sync: e?.sync });
+    }, this.resolveRedirect = (e) => {
+      const r = e;
+      return r.href || (r.href = this.buildLocation(r).href), r;
+    }, this.clearCache = (e) => {
+      const r = e?.filter;
+      r !== void 0 ? this.__store.setState((o) => ({
+        ...o,
+        cachedMatches: o.cachedMatches.filter(
+          (s) => !r(s)
+        )
+      })) : this.__store.setState((o) => ({
+        ...o,
+        cachedMatches: []
+      }));
+    }, this.clearExpiredCache = () => {
+      const e = (r) => {
+        const o = this.looseRoutesById[r.routeId];
+        if (!o.options.loader)
+          return !0;
+        const s = (r.preload ? o.options.preloadGcTime ?? this.options.defaultPreloadGcTime : o.options.gcTime ?? this.options.defaultGcTime) ?? 5 * 60 * 1e3;
+        return !(r.status !== "error" && Date.now() - r.updatedAt < s);
+      };
+      this.clearCache({ filter: e });
+    }, this.loadRouteChunk = (e) => (e._lazyPromise === void 0 && (e.lazyFn ? e._lazyPromise = e.lazyFn().then((r) => {
+      const { id: o, ...s } = r.options;
+      Object.assign(e.options, s);
+    }) : e._lazyPromise = Promise.resolve()), e._componentsPromise === void 0 && (e._componentsPromise = e._lazyPromise.then(
+      () => Promise.all(
+        Lt.map(async (r) => {
+          const o = e.options[r];
+          o?.preload && await o.preload();
+        })
+      )
+    )), e._componentsPromise), this.preloadRoute = async (e) => {
+      const r = this.buildLocation(e);
+      let o = this.matchRoutes(r, {
+        throwOnError: !0,
+        preload: !0,
+        dest: e
+      });
+      const s = new Set(
+        [...this.state.matches, ...this.state.pendingMatches ?? []].map(
+          (a) => a.id
+        )
+      ), i = /* @__PURE__ */ new Set([
+        ...s,
+        ...this.state.cachedMatches.map((a) => a.id)
+      ]);
+      Ge(() => {
+        o.forEach((a) => {
+          i.has(a.id) || this.__store.setState((l) => ({
+            ...l,
+            cachedMatches: [...l.cachedMatches, a]
+          }));
+        });
+      });
+      try {
+        return o = await this.loadMatches({
+          matches: o,
+          location: r,
+          preload: !0,
+          updateMatch: (a, l) => {
+            s.has(a) ? o = o.map((c) => c.id === a ? l(c) : c) : this.updateMatch(a, l);
+          }
+        }), o;
+      } catch (a) {
+        if (ce(a))
+          return a.reloadDocument ? void 0 : await this.preloadRoute({
+            ...a,
+            _fromLocation: r
+          });
+        console.error(a);
+        return;
+      }
+    }, this.matchRoute = (e, r) => {
+      const o = {
+        ...e,
+        to: e.to ? this.resolvePathWithBase(
+          e.from || "",
+          e.to
+        ) : void 0,
+        params: e.params || {},
+        leaveParams: !0
+      }, s = this.buildLocation(o);
+      if (r?.pending && this.state.status !== "pending")
+        return !1;
+      const a = (r?.pending === void 0 ? !this.state.isLoading : r.pending) ? this.latestLocation : this.state.resolvedLocation, l = Fe(this.basepath, a.pathname, {
+        ...r,
+        to: s.pathname
+      });
+      return !l || e.params && !ye(l, e.params, { partial: !0 }) ? !1 : l && (r?.includeSearch ?? !0) ? ye(a.search, s.search, { partial: !0 }) ? l : !1 : l;
+    }, this._handleNotFound = (e, r, {
+      updateMatch: o = this.updateMatch
+    } = {}) => {
+      const s = Object.fromEntries(
+        e.map((l) => [l.routeId, l])
+      );
+      let i = (r.global ? this.looseRoutesById[H] : this.looseRoutesById[r.routeId]) || this.looseRoutesById[H];
+      for (; !i.options.notFoundComponent && !this.options.defaultNotFoundComponent && i.id !== H; )
+        i = i.parentRoute, te(
+          i,
+          "Found invalid route tree while trying to find not-found handler."
+        );
+      const a = s[i.id];
+      te(a, "Could not find match for route: " + i.id), o(a.id, (l) => ({
+        ...l,
+        status: "notFound",
+        error: r,
+        isFetching: !1
+      })), r.routerCode === "BEFORE_LOAD" && i.parentRoute && (r.routeId = i.parentRoute.id, this._handleNotFound(e, r, {
+        updateMatch: o
+      }));
+    }, 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,
+      caseSensitive: n.caseSensitive ?? !1,
+      notFoundMode: n.notFoundMode ?? "fuzzy",
+      stringifySearch: n.stringifySearch ?? hn,
+      parseSearch: n.parseSearch ?? dn
+    }), typeof document < "u" && (window.__TSR_ROUTER__ = this);
+  }
+  get state() {
+    return this.__store.state;
+  }
+  get looseRoutesById() {
+    return this.routesById;
+  }
+  matchRoutes(n, e, r) {
+    return typeof n == "string" ? this.matchRoutesInternal(
+      {
+        pathname: n,
+        search: e
+      },
+      r
+    ) : this.matchRoutesInternal(n, e);
+  }
+  matchRoutesInternal(n, e) {
+    const { foundRoute: r, matchedRoutes: o, routeParams: s } = this.getMatchedRoutes(
+      n,
+      e?.dest
+    );
+    let i = !1;
+    // If we found a route, and it's not an index route and we have left over path
+    (r ? r.path !== "/" && s["**"] : (
+      // Or if we didn't find a route and we have left over path
+      le(n.pathname)
+    )) && (this.options.notFoundRoute ? o.push(this.options.notFoundRoute) : i = !0);
+    const a = (() => {
+      if (i) {
+        if (this.options.notFoundMode !== "root")
+          for (let u = o.length - 1; u >= 0; u--) {
+            const h = o[u];
+            if (h.children)
+              return h.id;
+          }
+        return H;
+      }
+    })(), l = o.map((u) => {
+      var h;
+      let f;
+      const p = ((h = u.options.params) == null ? void 0 : h.parse) ?? u.options.parseParams;
+      if (p)
+        try {
+          const S = p(s);
+          Object.assign(s, S);
+        } catch (S) {
+          if (f = new xn(S.message, {
+            cause: S
+          }), e?.throwOnError)
+            throw f;
+          return f;
+        }
+    }), c = [], d = (u) => u?.id ? u.context ?? this.options.context ?? {} : this.options.context ?? {};
+    return o.forEach((u, h) => {
+      var f, p, S, y;
+      const M = c[h - 1], [R, L] = (() => {
+        const k = M?.search ?? n.search;
+        try {
+          const T = Ye(u.options.validateSearch, k) ?? {};
+          return [
+            {
+              ...k,
+              ...T
+            },
+            void 0
+          ];
+        } catch (T) {
+          const I = new ot(T.message, {
+            cause: T
+          });
+          if (e?.throwOnError)
+            throw I;
+          return [k, I];
+        }
+      })(), P = ((p = (f = u.options).loaderDeps) == null ? void 0 : p.call(f, {
+        search: R
+      })) ?? "", g = P ? JSON.stringify(P) : "", x = ke({
+        path: u.fullPath,
+        params: s,
+        decodeCharMap: this.pathParamsDecodeCharMap
+      }), F = ke({
+        path: u.id,
+        params: s,
+        leaveWildcards: !0,
+        decodeCharMap: this.pathParamsDecodeCharMap
+      }) + g, v = this.getMatch(F), _ = this.state.matches.find(
+        (k) => k.routeId === u.id
+      ), E = _ ? "stay" : "enter";
+      let m;
+      if (v)
+        m = {
+          ...v,
+          cause: E,
+          params: _ ? X(_.params, s) : s,
+          search: X(_ ? _.search : v.search, R)
+        };
+      else {
+        const k = u.options.loader || u.options.beforeLoad || u.lazyFn || Ln(u) ? "pending" : "success";
+        m = {
+          id: F,
+          index: h,
+          routeId: u.id,
+          params: _ ? X(_.params, s) : s,
+          pathname: re([this.basepath, x]),
+          updatedAt: Date.now(),
+          search: _ ? X(_.search, R) : R,
+          searchError: void 0,
+          status: k,
+          isFetching: !1,
+          error: void 0,
+          paramsError: l[h],
+          __routeContext: {},
+          __beforeLoadContext: {},
+          context: {},
+          abortController: new AbortController(),
+          fetchCount: 0,
+          cause: E,
+          loaderDeps: _ ? X(_.loaderDeps, P) : P,
+          invalid: !1,
+          preload: !1,
+          links: void 0,
+          scripts: void 0,
+          meta: void 0,
+          staticData: u.options.staticData || {},
+          loadPromise: pe(),
+          fullPath: u.fullPath
+        };
+      }
+      m.status === "success" && (m.headers = (y = (S = u.options).headers) == null ? void 0 : y.call(S, {
+        loaderData: m.loaderData
+      })), e?.preload || (m.globalNotFound = a === u.id), m.searchError = L;
+      const w = d(M);
+      m.context = {
+        ...w,
+        ...m.__routeContext,
+        ...m.__beforeLoadContext
+      }, c.push(m);
+    }), c.forEach((u, h) => {
+      var f, p, S, y;
+      const M = this.looseRoutesById[u.routeId];
+      if (!this.getMatch(u.id) && e?._buildLocation !== !0) {
+        const P = c[h - 1], g = d(P), x = {
+          deps: u.loaderDeps,
+          params: u.params,
+          context: g,
+          location: n,
+          navigate: (F) => this.navigate({ ...F, _fromLocation: n }),
+          buildLocation: this.buildLocation,
+          cause: u.cause,
+          abortController: u.abortController,
+          preload: !!u.preload,
+          matches: c
+        };
+        u.__routeContext = ((p = (f = M.options).context) == null ? void 0 : p.call(f, x)) ?? {}, u.context = {
+          ...g,
+          ...u.__routeContext,
+          ...u.__beforeLoadContext
+        };
+      }
+      const L = (y = (S = M.options).head) == null ? void 0 : y.call(S, {
+        matches: c,
+        match: u,
+        params: u.params,
+        loaderData: u.loaderData ?? void 0
+      });
+      u.links = L?.links, u.scripts = L?.scripts, u.meta = L?.meta;
+    }), c;
+  }
+}
+class ot extends Error {
+}
+class xn extends Error {
+}
+function En(t) {
+  return {
+    loadedAt: 0,
+    isLoading: !1,
+    isTransitioning: !1,
+    status: "idle",
+    resolvedLocation: { ...t },
+    location: t,
+    matches: [],
+    pendingMatches: [],
+    cachedMatches: [],
+    statusCode: 200
+  };
+}
+const Ue = b.createContext(void 0), In = b.createContext(
+  void 0
+);
+function he(t) {
+  const n = b.useContext(
+    t.from ? In : Ue
+  );
+  return z({
+    select: (r) => {
+      const o = r.matches.find(
+        (s) => t.from ? t.from === s.routeId : s.id === n
+      );
+      if (te(
+        !((t.shouldThrow ?? !0) && !o),
+        `Could not find ${t.from ? `an active match from "${t.from}"` : "a nearest match!"}`
+      ), o !== void 0)
+        return t.select ? t.select(o) : o;
+    },
+    structuralSharing: t.structuralSharing
+  });
+}
+function kn(t) {
+  return he({
+    from: t.from,
+    strict: t.strict,
+    structuralSharing: t.structuralSharing,
+    select: (n) => t.select ? t.select(n.loaderData) : n.loaderData
+  });
+}
+function Fn(t) {
+  const { select: n, ...e } = t;
+  return he({
+    ...e,
+    select: (r) => n ? n(r.loaderDeps) : r.loaderDeps
+  });
+}
+function Tn(t) {
+  return he({
+    from: t.from,
+    strict: t.strict,
+    structuralSharing: t.structuralSharing,
+    select: (n) => t.select ? t.select(n.params) : n.params
+  });
+}
+function Bn(t) {
+  return he({
+    from: t.from,
+    strict: t.strict,
+    structuralSharing: t.structuralSharing,
+    select: (n) => t.select ? t.select(n.search) : n.search
+  });
+}
+function Dn(t) {
+  const { navigate: n } = oe();
+  return b.useCallback(
+    (e) => n({
+      ...e
+    }),
+    [n]
+  );
+}
+class Mt {
+  /**
+   * @deprecated Use the `createRoute` function instead.
+   */
+  constructor(n) {
+    this.init = (e) => {
+      var r, o;
+      this.originalIndex = e.originalIndex;
+      const s = this.options, i = !s?.path && !s?.id;
+      this.parentRoute = (o = (r = this.options).getParentRoute) == null ? void 0 : o.call(r), i ? this._path = H : te(
+        this.parentRoute,
+        "Child Route instances must pass a 'getParentRoute: () => ParentRoute' option that returns a Route instance."
+      );
+      let a = i ? H : s.path;
+      a && a !== "/" && (a = at(a));
+      const l = s?.id || a;
+      let c = i ? H : re([
+        this.parentRoute.id === H ? "" : this.parentRoute.id,
+        l
+      ]);
+      a === H && (a = "/"), c !== H && (c = re(["/", c]));
+      const d = c === H ? "/" : re([this.parentRoute.fullPath, a]);
+      this._path = a, this._id = c, this._fullPath = d, this._to = d, this._ssr = s?.ssr ?? e.defaultSsr ?? !0;
+    }, 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) => he({
+      select: e?.select,
+      from: this.id,
+      structuralSharing: e?.structuralSharing
+    }), this.useRouteContext = (e) => he({
+      ...e,
+      from: this.id,
+      select: (r) => e?.select ? e.select(r.context) : r.context
+    }), this.useSearch = (e) => Bn({
+      select: e?.select,
+      structuralSharing: e?.structuralSharing,
+      from: this.id
+    }), this.useParams = (e) => Tn({
+      select: e?.select,
+      structuralSharing: e?.structuralSharing,
+      from: this.id
+    }), this.useLoaderDeps = (e) => Fn({ ...e, from: this.id }), this.useLoaderData = (e) => kn({ ...e, from: this.id }), this.useNavigate = () => Dn({ from: this.id }), this.options = n || {}, this.isRoot = !n?.getParentRoute, te(
+      !(n?.id && n?.path),
+      "Route cannot have both an 'id' and a 'path' option."
+    ), this.$$typeof = Symbol.for("react.memo");
+  }
+  get to() {
+    return this._to;
+  }
+  get id() {
+    return this._id;
+  }
+  get path() {
+    return this._path;
+  }
+  get fullPath() {
+    return this._fullPath;
+  }
+  get ssr() {
+    return this._ssr;
+  }
+  addChildren(n) {
+    return this._addFileChildren(n);
+  }
+  _addFileChildren(n) {
+    return Array.isArray(n) && (this.children = n), typeof n == "object" && n !== null && (this.children = Object.values(n)), this;
+  }
+}
+function On(t) {
+  return new Mt(t);
+}
+function ir() {
+  return (t) => An(t);
+}
+class Vn extends Mt {
+  /**
+   * @deprecated `RootRoute` is now an internal implementation detail. Use `createRootRoute()` instead.
+   */
+  constructor(n) {
+    super(n);
+  }
+  addChildren(n) {
+    return super.addChildren(n), this;
+  }
+  _addFileChildren(n) {
+    return super._addFileChildren(n), this;
+  }
+  _addFileTypes() {
+    return this;
+  }
+}
+function An(t) {
+  return new Vn(t);
+}
+function ar(t) {
+  return new Nn(t, {
+    silent: !0
+  }).createRoute;
+}
+class Nn {
+  constructor(n, e) {
+    this.path = n, this.createRoute = (r) => {
+      Me(
+        this.silent,
+        "FileRoute is deprecated and will be removed in the next major version. Use the createFileRoute(path)(options) function instead."
+      );
+      const o = On(r);
+      return o.isRoot = !1, o;
+    }, this.silent = e?.silent;
+  }
+}
+function Be(t) {
+  return /* @__PURE__ */ C(Ft, { children: t.children });
+}
+function xt(t, n, e) {
+  return n.options.notFoundComponent ? /* @__PURE__ */ C(n.options.notFoundComponent, { data: e }) : t.options.defaultNotFoundComponent ? /* @__PURE__ */ C(t.options.defaultNotFoundComponent, { data: e }) : /* @__PURE__ */ C(Cn, {});
+}
+const Et = b.memo(function({
+  matchId: n
+}) {
+  var e, r;
+  const o = oe(), s = z({
+    select: (y) => {
+      var M;
+      return (M = y.matches.find((R) => R.id === n)) == null ? void 0 : M.routeId;
+    }
+  });
+  te(
+    s,
+    `Could not find routeId for matchId "${n}". Please file an issue!`
+  );
+  const i = o.routesById[s], a = i.options.pendingComponent ?? o.options.defaultPendingComponent, l = a ? /* @__PURE__ */ C(a, {}) : null, c = i.options.errorComponent ?? o.options.defaultErrorComponent, d = i.options.onCatch ?? o.options.defaultOnCatch, u = i.isRoot ? (
+    // If it's the root route, use the globalNotFound option, with fallback to the notFoundRoute's component
+    i.options.notFoundComponent ?? ((e = o.options.notFoundRoute) == null ? void 0 : e.options.component)
+  ) : i.options.notFoundComponent, h = (
+    // If we're on the root route, allow forcefully wrapping in suspense
+    (!i.isRoot || i.options.wrapInSuspense) && (i.options.wrapInSuspense ?? a ?? ((r = i.options.errorComponent) == null ? void 0 : r.preload)) ? b.Suspense : Be
+  ), f = c ? ct : Be, p = u ? Rn : Be, S = z({
+    select: (y) => y.loadedAt
+  });
+  return /* @__PURE__ */ C(Ue.Provider, { value: n, children: /* @__PURE__ */ C(h, { fallback: l, children: /* @__PURE__ */ C(
+    f,
+    {
+      getResetKey: () => S,
+      errorComponent: c || Ke,
+      onCatch: (y, M) => {
+        if (ee(y)) throw y;
+        Me(!1, `Error in route match: ${n}`), d?.(y, M);
+      },
+      children: /* @__PURE__ */ C(
+        p,
+        {
+          fallback: (y) => {
+            if (!u || y.routeId && y.routeId !== s || !y.routeId && !i.isRoot)
+              throw y;
+            return b.createElement(u, y);
+          },
+          children: /* @__PURE__ */ C($n, { matchId: n })
+        }
+      )
+    }
+  ) }) });
+}), $n = b.memo(function({
+  matchId: n
+}) {
+  var e, r, o;
+  const s = oe(), { match: i, matchIndex: a, routeId: l } = z({
+    select: (h) => {
+      const f = h.matches.findIndex((y) => y.id === n), p = h.matches[f];
+      return {
+        routeId: p.routeId,
+        matchIndex: f,
+        match: rt(p, ["id", "status", "error"])
+      };
+    },
+    structuralSharing: !0
+  }), c = s.routesById[l], d = b.useMemo(() => {
+    const h = c.options.component ?? s.options.defaultComponent;
+    return h ? /* @__PURE__ */ C(h, {}) : /* @__PURE__ */ C(Kn, {});
+  }, [c.options.component, s.options.defaultComponent]), u = (c.options.errorComponent ?? s.options.defaultErrorComponent) || Ke;
+  if (i.status === "notFound")
+    return te(ee(i.error), "Expected a notFound error"), xt(s, c, i.error);
+  if (i.status === "redirected")
+    throw te(ce(i.error), "Expected a redirect error"), (e = s.getMatch(i.id)) == null ? void 0 : e.loadPromise;
+  if (i.status === "error") {
+    if (s.isServer)
+      return /* @__PURE__ */ C(
+        u,
+        {
+          error: i.error,
+          info: {
+            componentStack: ""
+          }
+        }
+      );
+    throw i.error;
+  }
+  if (i.status === "pending") {
+    const h = c.options.pendingMinMs ?? s.options.defaultPendingMinMs;
+    if (h && !((r = s.getMatch(i.id)) != null && r.minPendingPromise) && !s.isServer) {
+      const f = pe();
+      Promise.resolve().then(() => {
+        s.updateMatch(i.id, (p) => ({
+          ...p,
+          minPendingPromise: f
+        }));
+      }), setTimeout(() => {
+        f.resolve(), s.updateMatch(i.id, (p) => ({
+          ...p,
+          minPendingPromise: void 0
+        }));
+      }, h);
+    }
+    throw (o = s.getMatch(i.id)) == null ? void 0 : o.loadPromise;
+  }
+  return d;
+}), Kn = b.memo(function() {
+  const n = oe(), e = b.useContext(Ue), r = z({
+    select: (c) => {
+      var d;
+      return (d = c.matches.find((u) => u.id === e)) == null ? void 0 : d.routeId;
+    }
+  }), o = n.routesById[r], s = z({
+    select: (c) => {
+      const u = c.matches.find((h) => h.id === e);
+      return te(
+        u,
+        `Could not find parent match for matchId "${e}"`
+      ), u.globalNotFound;
+    }
+  }), i = z({
+    select: (c) => {
+      var d;
+      const u = c.matches, h = u.findIndex((f) => f.id === e);
+      return (d = u[h + 1]) == null ? void 0 : d.id;
+    }
+  });
+  if (s)
+    return xt(n, o, void 0);
+  if (!i)
+    return null;
+  const a = /* @__PURE__ */ C(Et, { matchId: i }), l = n.options.defaultPendingComponent ? /* @__PURE__ */ C(n.options.defaultPendingComponent, {}) : null;
+  return e === H ? /* @__PURE__ */ C(b.Suspense, { fallback: l, children: a }) : a;
+}), Un = "Error preloading route! ☝️";
+function zn(t, n) {
+  const e = oe(), [r, o] = b.useState(!1), s = b.useRef(!1), i = yn(n), {
+    // custom props
+    activeProps: a = () => ({ className: "active" }),
+    inactiveProps: l = () => ({}),
+    activeOptions: c,
+    to: d,
+    preload: u,
+    preloadDelay: h,
+    hashScrollIntoView: f,
+    replace: p,
+    startTransition: S,
+    resetScroll: y,
+    viewTransition: M,
+    // element props
+    children: R,
+    target: L,
+    disabled: P,
+    style: g,
+    className: x,
+    onClick: F,
+    onFocus: v,
+    onMouseEnter: _,
+    onMouseLeave: E,
+    onTouchStart: m,
+    ignoreBlocker: w,
+    ...k
+  } = t, {
+    // prevent these from being returned
+    params: T,
+    search: I,
+    hash: D,
+    state: W,
+    mask: q,
+    reloadDocument: J,
+    ...j
+  } = k, ne = b.useMemo(() => {
+    try {
+      return new URL(`${d}`), "external";
+    } catch {
+    }
+    return "internal";
+  }, [d]), O = z({
+    select: (B) => B.location.search,
+    structuralSharing: !0
+  });
+  t = {
+    from: he({ strict: !1, select: (B) => B.pathname }),
+    ...t
+  };
+  const V = b.useMemo(
+    () => e.buildLocation(t),
+    [e, t, O]
+  ), A = b.useMemo(() => t.reloadDocument ? !1 : u ?? e.options.defaultPreload, [e.options.defaultPreload, u, t.reloadDocument]), N = h ?? e.options.defaultPreloadDelay ?? 0, G = z({
+    select: (B) => {
+      if (c?.exact) {
+        if (!Sn(
+          B.location.pathname,
+          V.pathname,
+          e.basepath
+        ))
+          return !1;
+      } else {
+        const $ = Ve(
+          B.location.pathname,
+          e.basepath
+        ).split("/");
+        if (!Ve(
+          V.pathname,
+          e.basepath
+        ).split("/").every(
+          (It, kt) => It === $[kt]
+        ))
+          return !1;
+      }
+      return (c?.includeSearch ?? !0) && !ye(B.location.search, V.search, {
+        partial: !c?.exact,
+        ignoreUndefined: !c?.explicitUndefined
+      }) ? !1 : c?.includeHash ? B.location.hash === V.hash : !0;
+    }
+  }), Y = b.useCallback(() => {
+    e.preloadRoute(t).catch((B) => {
+      console.warn(B), console.warn(Un);
+    });
+  }, [t, e]), xe = b.useCallback(
+    (B) => {
+      B?.isIntersecting && Y();
+    },
+    [Y]
+  );
+  if (gn(
+    i,
+    xe,
+    { rootMargin: "100px" },
+    { disabled: !!P || A !== "viewport" }
+  ), Re(() => {
+    s.current || !P && A === "render" && (Y(), s.current = !0);
+  }, [P, Y, A]), ne === "external")
+    return {
+      ...j,
+      ref: i,
+      type: ne,
+      href: d,
+      ...R && { children: R },
+      ...L && { target: L },
+      ...P && { disabled: P },
+      ...g && { style: g },
+      ...x && { className: x },
+      ...F && { onClick: F },
+      ...v && { onFocus: v },
+      ..._ && { onMouseEnter: _ },
+      ...E && { onMouseLeave: E },
+      ...m && { onTouchStart: m }
+    };
+  const Ee = (B) => {
+    if (!P && !Wn(B) && !B.defaultPrevented && (!L || L === "_self") && B.button === 0) {
+      B.preventDefault(), Bt(() => {
+        o(!0);
+      });
+      const $ = e.subscribe("onResolved", () => {
+        $(), o(!1);
+      });
+      return e.navigate({
+        ...t,
+        replace: p,
+        resetScroll: y,
+        hashScrollIntoView: f,
+        startTransition: S,
+        viewTransition: M,
+        ignoreBlocker: w
+      });
+    }
+  }, ie = (B) => {
+    P || A && Y();
+  }, U = ie, Q = (B) => {
+    if (P) return;
+    const $ = B.target || {};
+    if (A) {
+      if ($.preloadTimeout)
+        return;
+      $.preloadTimeout = setTimeout(() => {
+        $.preloadTimeout = null, Y();
+      }, N);
+    }
+  }, se = (B) => {
+    if (P) return;
+    const $ = B.target || {};
+    $.preloadTimeout && (clearTimeout($.preloadTimeout), $.preloadTimeout = null);
+  }, ae = (B) => ($) => {
+    var ze;
+    (ze = $.persist) == null || ze.call($), B.filter(Boolean).forEach((lt) => {
+      $.defaultPrevented || lt($);
+    });
+  }, we = G ? ue(a, {}) ?? {} : {}, Pe = G ? {} : ue(l, {}), fe = [
+    x,
+    we.className,
+    Pe.className
+  ].filter(Boolean).join(" "), ut = {
+    ...g,
+    ...we.style,
+    ...Pe.style
+  };
+  return {
+    ...j,
+    ...we,
+    ...Pe,
+    href: P ? void 0 : V.maskedLocation ? e.history.createHref(V.maskedLocation.href) : e.history.createHref(V.href),
+    ref: i,
+    onClick: ae([F, Ee]),
+    onFocus: ae([v, ie]),
+    onMouseEnter: ae([_, Q]),
+    onMouseLeave: ae([E, se]),
+    onTouchStart: ae([m, U]),
+    disabled: !!P,
+    target: L,
+    ...Object.keys(ut).length && { style: ut },
+    ...fe && { className: fe },
+    ...P && {
+      role: "link",
+      "aria-disabled": !0
+    },
+    ...G && { "data-status": "active", "aria-current": "page" },
+    ...r && { "data-transitioning": "transitioning" }
+  };
+}
+const cr = b.forwardRef(
+  (t, n) => {
+    const { _asChild: e, ...r } = t, {
+      type: o,
+      ref: s,
+      ...i
+    } = zn(r, n), a = typeof r.children == "function" ? r.children({
+      isActive: i["data-status"] === "active"
+    }) : r.children;
+    return typeof e > "u" && delete i.disabled, b.createElement(
+      e || "a",
+      {
+        ...i,
+        ref: s
+      },
+      a
+    );
+  }
+);
+function Wn(t) {
+  return !!(t.metaKey || t.altKey || t.ctrlKey || t.shiftKey);
+}
+function Hn() {
+  const t = oe(), n = b.useRef({ router: t, mounted: !1 }), e = z({
+    select: ({ isLoading: u }) => u
+  }), [r, o] = b.useState(!1), s = z({
+    select: (u) => u.matches.some((h) => h.status === "pending"),
+    structuralSharing: !0
+  }), i = Xe(e), a = e || r || s, l = Xe(a), c = e || s, d = Xe(c);
+  return t.isServer || (t.startReactTransition = (u) => {
+    o(!0), b.startTransition(() => {
+      u(), o(!1);
+    });
+  }), b.useEffect(() => {
+    const u = t.history.subscribe(t.load), h = t.buildLocation({
+      to: t.latestLocation.pathname,
+      search: !0,
+      params: !0,
+      hash: !0,
+      state: !0,
+      _includeValidateSearch: !0
+    });
+    return le(t.latestLocation.href) !== le(h.href) && t.commitLocation({ ...h, replace: !0 }), () => {
+      u();
+    };
+  }, [t, t.history]), Re(() => {
+    if (typeof window < "u" && t.clientSsr || n.current.router === t && n.current.mounted)
+      return;
+    n.current = { router: t, mounted: !0 }, (async () => {
+      try {
+        await t.load();
+      } catch (h) {
+        console.error(h);
+      }
+    })();
+  }, [t]), Re(() => {
+    if (i && !e) {
+      const u = t.state.location, h = t.state.resolvedLocation, f = h.pathname !== u.pathname, p = h.href !== u.href;
+      t.emit({
+        type: "onLoad",
+        // When the new URL has committed, when the new matches have been loaded into state.matches
+        fromLocation: h,
+        toLocation: u,
+        pathChanged: f,
+        hrefChanged: p
+      });
+    }
+  }, [i, t, e]), Re(() => {
+    if (d && !c) {
+      const u = t.state.location, h = t.state.resolvedLocation, f = h.pathname !== u.pathname, p = h.href !== u.href;
+      t.emit({
+        type: "onBeforeRouteMount",
+        fromLocation: h,
+        toLocation: u,
+        pathChanged: f,
+        hrefChanged: p
+      });
+    }
+  }, [c, d, t]), Re(() => {
+    if (l && !a) {
+      const u = t.state.location, h = t.state.resolvedLocation, f = h.pathname !== u.pathname, p = h.href !== u.href;
+      if (t.emit({
+        type: "onResolved",
+        fromLocation: h,
+        toLocation: u,
+        pathChanged: f,
+        hrefChanged: p
+      }), t.__store.setState((S) => ({
+        ...S,
+        status: "idle",
+        resolvedLocation: S.location
+      })), typeof document < "u" && document.querySelector) {
+        const S = t.state.location.state.__hashScrollIntoViewOptions ?? !0;
+        if (S && t.state.location.hash !== "") {
+          const y = document.getElementById(t.state.location.hash);
+          y && y.scrollIntoView(S);
+        }
+      }
+    }
+  }, [a, l, t]), null;
+}
+function jn() {
+  const t = oe(), n = t.options.defaultPendingComponent ? /* @__PURE__ */ C(t.options.defaultPendingComponent, {}) : null, e = t.isServer || typeof document < "u" && t.clientSsr ? Be : b.Suspense, r = /* @__PURE__ */ et(e, { fallback: n, children: [
+    /* @__PURE__ */ C(Hn, {}),
+    /* @__PURE__ */ C(Gn, {})
+  ] });
+  return t.options.InnerWrap ? /* @__PURE__ */ C(t.options.InnerWrap, { children: r }) : r;
+}
+function Gn() {
+  const t = z({
+    select: (e) => {
+      var r;
+      return (r = e.matches[0]) == null ? void 0 : r.id;
+    }
+  }), n = z({
+    select: (e) => e.loadedAt
+  });
+  return /* @__PURE__ */ C(Ue.Provider, { value: t, children: /* @__PURE__ */ C(
+    ct,
+    {
+      getResetKey: () => n,
+      errorComponent: Ke,
+      onCatch: (e) => {
+        Me(
+          !1,
+          "The following error wasn't caught by any route! At the very least, consider setting an 'errorComponent' in your RootRoute!"
+        ), Me(!1, e.message || e.toString());
+      },
+      children: t ? /* @__PURE__ */ C(Et, { matchId: t }) : null
+    }
+  ) });
+}
+function Xn({
+  router: t,
+  children: n,
+  ...e
+}) {
+  t.update({
+    ...t.options,
+    ...e,
+    context: {
+      ...t.options.context,
+      ...e.context
+    }
+  });
+  const r = Ct(), o = /* @__PURE__ */ C(r.Provider, { value: t, children: n });
+  return t.options.Wrap ? /* @__PURE__ */ C(t.options.Wrap, { children: o }) : o;
+}
+function ur({ router: t, ...n }) {
+  return /* @__PURE__ */ C(Xn, { router: t, ...n, children: /* @__PURE__ */ C(jn, {}) });
+}
+const qn = typeof window < "u" ? b.useLayoutEffect : b.useEffect, Qe = "window", yt = "___";
+let Ze = /* @__PURE__ */ new WeakSet();
+const Jn = typeof window < "u" && window.sessionStorage, Z = Jn ? (() => {
+  const t = "tsr-scroll-restoration-v2";
+  return {
+    state: JSON.parse(
+      window.sessionStorage.getItem(t) || "null"
+    ) || { cached: {}, next: {} },
+    set: (e) => {
+      Z.state = ue(e, Z.state), window.sessionStorage.setItem(t, JSON.stringify(Z.state));
+    }
+  };
+})() : void 0, Yn = (t) => t.state.key || t.href;
+function Qn(t) {
+  const n = oe();
+  qn(() => {
+    const e = t?.getKey || Yn, { history: r } = window;
+    r.scrollRestoration = "manual";
+    const o = (a) => {
+      if (Ze.has(a.target)) return;
+      Ze.add(a.target);
+      let l = "";
+      if (a.target === document || a.target === window)
+        l = Qe;
+      else {
+        const c = a.target.getAttribute(
+          "data-scroll-restoration-id"
+        );
+        c ? l = `[data-scroll-restoration-id="${c}"]` : l = Zn(a.target);
+      }
+      Z.state.next[l] || Z.set((c) => ({
+        ...c,
+        next: {
+          ...c.next,
+          [l]: {
+            scrollX: NaN,
+            scrollY: NaN
+          }
+        }
+      }));
+    };
+    typeof document < "u" && document.addEventListener("scroll", o, !0);
+    const s = n.subscribe("onBeforeLoad", (a) => {
+      if (a.hrefChanged) {
+        const l = e(a.fromLocation);
+        for (const c in Z.state.next) {
+          const d = Z.state.next[c];
+          if (c === Qe)
+            d.scrollX = window.scrollX || 0, d.scrollY = window.scrollY || 0;
+          else if (c) {
+            const u = document.querySelector(c);
+            d.scrollX = u?.scrollLeft || 0, d.scrollY = u?.scrollTop || 0;
+          }
+          Z.set((u) => {
+            const h = { ...u.next };
+            return delete h[c], {
+              ...u,
+              next: h,
+              cached: {
+                ...u.cached,
+                [[l, c].join(yt)]: d
+              }
+            };
+          });
+        }
+      }
+    }), i = n.subscribe(
+      "onBeforeRouteMount",
+      (a) => {
+        if (a.hrefChanged) {
+          if (!n.resetNextScroll)
+            return;
+          n.resetNextScroll = !0;
+          const l = e(a.toLocation);
+          let c = !1;
+          for (const d in Z.state.cached) {
+            const u = Z.state.cached[d], [h, f] = d.split(yt);
+            if (h === l) {
+              if (f === Qe)
+                c = !0, window.scrollTo({
+                  top: u.scrollY,
+                  left: u.scrollX,
+                  behavior: t?.scrollBehavior
+                });
+              else if (f) {
+                const p = document.querySelector(f);
+                p && (p.scrollLeft = u.scrollX, p.scrollTop = u.scrollY);
+              }
+            }
+          }
+          c || window.scrollTo(0, 0), Z.set((d) => ({ ...d, next: {} })), Ze = /* @__PURE__ */ new WeakSet();
+        }
+      }
+    );
+    return () => {
+      document.removeEventListener("scroll", o), s(), i();
+    };
+  }, [t?.getKey, n]);
+}
+function lr(t) {
+  return Qn(t), null;
+}
+function Zn(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 {
+  cr as L,
+  Kn as O,
+  ur as R,
+  lr as S,
+  ar as a,
+  Tn as b,
+  ir as c,
+  z as d,
+  sr as e,
+  rr as f,
+  _t as g,
+  ee as i,
+  or as n,
+  oe as u,
+  rn as w
+};