likec4 1.19.1 → 1.20.0

package/__app__/src/chunks/tanstack-router-B9I-d36d.js

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