@uva-glass/component-library 1.65.0 → 2.0.0

package/dist/chunk-7R3XDUXW-C-tvzxWq.js

@@ -0,0 +1,1685 @@
+import * as c from "react";
+var U = {}, ae;
+function be() {
+  if (ae) return U;
+  ae = 1, Object.defineProperty(U, "__esModule", { value: !0 }), U.parse = u, U.serialize = l;
+  const e = /^[\u0021-\u003A\u003C\u003E-\u007E]+$/, t = /^[\u0021-\u003A\u003C-\u007E]*$/, n = /^([.]?[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)([.][a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)*$/i, i = /^[\u0020-\u003A\u003D-\u007E]*$/, r = Object.prototype.toString, a = /* @__PURE__ */ (() => {
+    const h = function() {
+    };
+    return h.prototype = /* @__PURE__ */ Object.create(null), h;
+  })();
+  function u(h, d) {
+    const f = new a(), g = h.length;
+    if (g < 2)
+      return f;
+    const v = (d == null ? void 0 : d.decode) || m;
+    let p = 0;
+    do {
+      const w = h.indexOf("=", p);
+      if (w === -1)
+        break;
+      const x = h.indexOf(";", p), E = x === -1 ? g : x;
+      if (w > E) {
+        p = h.lastIndexOf(";", w - 1) + 1;
+        continue;
+      }
+      const R = s(h, p, w), A = o(h, w, R), $ = h.slice(R, A);
+      if (f[$] === void 0) {
+        let D = s(h, w + 1, E), S = o(h, E, D);
+        const I = v(h.slice(D, S));
+        f[$] = I;
+      }
+      p = E + 1;
+    } while (p < g);
+    return f;
+  }
+  function s(h, d, f) {
+    do {
+      const g = h.charCodeAt(d);
+      if (g !== 32 && g !== 9)
+        return d;
+    } while (++d < f);
+    return f;
+  }
+  function o(h, d, f) {
+    for (; d > f; ) {
+      const g = h.charCodeAt(--d);
+      if (g !== 32 && g !== 9)
+        return d + 1;
+    }
+    return f;
+  }
+  function l(h, d, f) {
+    const g = (f == null ? void 0 : f.encode) || encodeURIComponent;
+    if (!e.test(h))
+      throw new TypeError(`argument name is invalid: ${h}`);
+    const v = g(d);
+    if (!t.test(v))
+      throw new TypeError(`argument val is invalid: ${d}`);
+    let p = h + "=" + v;
+    if (!f)
+      return p;
+    if (f.maxAge !== void 0) {
+      if (!Number.isInteger(f.maxAge))
+        throw new TypeError(`option maxAge is invalid: ${f.maxAge}`);
+      p += "; Max-Age=" + f.maxAge;
+    }
+    if (f.domain) {
+      if (!n.test(f.domain))
+        throw new TypeError(`option domain is invalid: ${f.domain}`);
+      p += "; Domain=" + f.domain;
+    }
+    if (f.path) {
+      if (!i.test(f.path))
+        throw new TypeError(`option path is invalid: ${f.path}`);
+      p += "; Path=" + f.path;
+    }
+    if (f.expires) {
+      if (!y(f.expires) || !Number.isFinite(f.expires.valueOf()))
+        throw new TypeError(`option expires is invalid: ${f.expires}`);
+      p += "; Expires=" + f.expires.toUTCString();
+    }
+    if (f.httpOnly && (p += "; HttpOnly"), f.secure && (p += "; Secure"), f.partitioned && (p += "; Partitioned"), f.priority)
+      switch (typeof f.priority == "string" ? f.priority.toLowerCase() : void 0) {
+        case "low":
+          p += "; Priority=Low";
+          break;
+        case "medium":
+          p += "; Priority=Medium";
+          break;
+        case "high":
+          p += "; Priority=High";
+          break;
+        default:
+          throw new TypeError(`option priority is invalid: ${f.priority}`);
+      }
+    if (f.sameSite)
+      switch (typeof f.sameSite == "string" ? f.sameSite.toLowerCase() : f.sameSite) {
+        case !0:
+        case "strict":
+          p += "; SameSite=Strict";
+          break;
+        case "lax":
+          p += "; SameSite=Lax";
+          break;
+        case "none":
+          p += "; SameSite=None";
+          break;
+        default:
+          throw new TypeError(`option sameSite is invalid: ${f.sameSite}`);
+      }
+    return p;
+  }
+  function m(h) {
+    if (h.indexOf("%") === -1)
+      return h;
+    try {
+      return decodeURIComponent(h);
+    } catch {
+      return h;
+    }
+  }
+  function y(h) {
+    return r.call(h) === "[object Date]";
+  }
+  return U;
+}
+be();
+/**
+ * react-router v7.0.1
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+var ie = "popstate";
+function Pe(e = {}) {
+  let { initialEntries: t = ["/"], initialIndex: n, v5Compat: i = !1 } = e, r;
+  r = t.map(
+    (d, f) => m(
+      d,
+      typeof d == "string" ? null : d.state,
+      f === 0 ? "default" : void 0
+    )
+  );
+  let a = o(
+    n ?? r.length - 1
+  ), u = "POP", s = null;
+  function o(d) {
+    return Math.min(Math.max(d, 0), r.length - 1);
+  }
+  function l() {
+    return r[a];
+  }
+  function m(d, f = null, g) {
+    let v = j(
+      r ? l().pathname : "/",
+      d,
+      f,
+      g
+    );
+    return L(
+      v.pathname.charAt(0) === "/",
+      `relative pathnames are not supported in memory history: ${JSON.stringify(
+        d
+      )}`
+    ), v;
+  }
+  function y(d) {
+    return typeof d == "string" ? d : F(d);
+  }
+  return {
+    get index() {
+      return a;
+    },
+    get action() {
+      return u;
+    },
+    get location() {
+      return l();
+    },
+    createHref: y,
+    createURL(d) {
+      return new URL(y(d), "http://localhost");
+    },
+    encodeLocation(d) {
+      let f = typeof d == "string" ? M(d) : d;
+      return {
+        pathname: f.pathname || "",
+        search: f.search || "",
+        hash: f.hash || ""
+      };
+    },
+    push(d, f) {
+      u = "PUSH";
+      let g = m(d, f);
+      a += 1, r.splice(a, r.length, g), i && s && s({ action: u, location: g, delta: 1 });
+    },
+    replace(d, f) {
+      u = "REPLACE";
+      let g = m(d, f);
+      r[a] = g, i && s && s({ action: u, location: g, delta: 0 });
+    },
+    go(d) {
+      u = "POP";
+      let f = o(a + d), g = r[f];
+      a = f, s && s({ action: u, location: g, delta: d });
+    },
+    listen(d) {
+      return s = d, () => {
+        s = null;
+      };
+    }
+  };
+}
+function Le(e = {}) {
+  function t(i, r) {
+    let { pathname: a, search: u, hash: s } = i.location;
+    return j(
+      "",
+      { pathname: a, search: u, hash: s },
+      // state defaults to `null` because `window.history.state` does
+      r.state && r.state.usr || null,
+      r.state && r.state.key || "default"
+    );
+  }
+  function n(i, r) {
+    return typeof r == "string" ? r : F(r);
+  }
+  return $e(
+    t,
+    n,
+    null,
+    e
+  );
+}
+function C(e, t) {
+  if (e === !1 || e === null || typeof e > "u")
+    throw new Error(t);
+}
+function L(e, t) {
+  if (!e) {
+    typeof console < "u" && console.warn(t);
+    try {
+      throw new Error(t);
+    } catch {
+    }
+  }
+}
+function ke() {
+  return Math.random().toString(36).substring(2, 10);
+}
+function oe(e, t) {
+  return {
+    usr: e.state,
+    key: e.key,
+    idx: t
+  };
+}
+function j(e, t, n = null, i) {
+  return {
+    pathname: typeof e == "string" ? e : e.pathname,
+    search: "",
+    hash: "",
+    ...typeof t == "string" ? M(t) : t,
+    state: n,
+    // TODO: This could be cleaned up.  push/replace should probably just take
+    // full Locations now and avoid the need to run through this flow at all
+    // But that's a pretty big refactor to the current test suite so going to
+    // keep as is for the time being and just let any incoming keys take precedence
+    key: t && t.key || i || ke()
+  };
+}
+function F({
+  pathname: e = "/",
+  search: t = "",
+  hash: n = ""
+}) {
+  return t && t !== "?" && (e += t.charAt(0) === "?" ? t : "?" + t), n && n !== "#" && (e += n.charAt(0) === "#" ? n : "#" + n), e;
+}
+function M(e) {
+  let t = {};
+  if (e) {
+    let n = e.indexOf("#");
+    n >= 0 && (t.hash = e.substring(n), e = e.substring(0, n));
+    let i = e.indexOf("?");
+    i >= 0 && (t.search = e.substring(i), e = e.substring(0, i)), e && (t.pathname = e);
+  }
+  return t;
+}
+function $e(e, t, n, i = {}) {
+  let { window: r = document.defaultView, v5Compat: a = !1 } = i, u = r.history, s = "POP", o = null, l = m();
+  l == null && (l = 0, u.replaceState({ ...u.state, idx: l }, ""));
+  function m() {
+    return (u.state || { idx: null }).idx;
+  }
+  function y() {
+    s = "POP";
+    let v = m(), p = v == null ? null : v - l;
+    l = v, o && o({ action: s, location: g.location, delta: p });
+  }
+  function h(v, p) {
+    s = "PUSH";
+    let w = j(g.location, v, p);
+    l = m() + 1;
+    let x = oe(w, l), E = g.createHref(w);
+    try {
+      u.pushState(x, "", E);
+    } catch (R) {
+      if (R instanceof DOMException && R.name === "DataCloneError")
+        throw R;
+      r.location.assign(E);
+    }
+    a && o && o({ action: s, location: g.location, delta: 1 });
+  }
+  function d(v, p) {
+    s = "REPLACE";
+    let w = j(g.location, v, p);
+    l = m();
+    let x = oe(w, l), E = g.createHref(w);
+    u.replaceState(x, "", E), a && o && o({ action: s, location: g.location, delta: 0 });
+  }
+  function f(v) {
+    let p = r.location.origin !== "null" ? r.location.origin : r.location.href, w = typeof v == "string" ? v : F(v);
+    return w = w.replace(/ $/, "%20"), C(
+      p,
+      `No window.location.(origin|href) available to create URL for href: ${w}`
+    ), new URL(w, p);
+  }
+  let g = {
+    get action() {
+      return s;
+    },
+    get location() {
+      return e(r, u);
+    },
+    listen(v) {
+      if (o)
+        throw new Error("A history only accepts one active listener");
+      return r.addEventListener(ie, y), o = v, () => {
+        r.removeEventListener(ie, y), o = null;
+      };
+    },
+    createHref(v) {
+      return t(r, v);
+    },
+    createURL: f,
+    encodeLocation(v) {
+      let p = f(v);
+      return {
+        pathname: p.pathname,
+        search: p.search,
+        hash: p.hash
+      };
+    },
+    push: h,
+    replace: d,
+    go(v) {
+      return u.go(v);
+    }
+  };
+  return g;
+}
+function ce(e, t, n = "/") {
+  return Ie(e, t, n, !1);
+}
+function Ie(e, t, n, i) {
+  let r = typeof t == "string" ? M(t) : t, a = T(r.pathname || "/", n);
+  if (a == null)
+    return null;
+  let u = fe(e);
+  Te(u);
+  let s = null;
+  for (let o = 0; s == null && o < u.length; ++o) {
+    let l = _e(a);
+    s = He(
+      u[o],
+      l,
+      i
+    );
+  }
+  return s;
+}
+function fe(e, t = [], n = [], i = "") {
+  let r = (a, u, s) => {
+    let o = {
+      relativePath: s === void 0 ? a.path || "" : s,
+      caseSensitive: a.caseSensitive === !0,
+      childrenIndex: u,
+      route: a
+    };
+    o.relativePath.startsWith("/") && (C(
+      o.relativePath.startsWith(i),
+      `Absolute route path "${o.relativePath}" nested under path "${i}" is not valid. An absolute child route path must start with the combined path of all its parent routes.`
+    ), o.relativePath = o.relativePath.slice(i.length));
+    let l = P([i, o.relativePath]), m = n.concat(o);
+    a.children && a.children.length > 0 && (C(
+      // Our types know better, but runtime JS may not!
+      // @ts-expect-error
+      a.index !== !0,
+      `Index routes must not have child routes. Please remove all child routes from route path "${l}".`
+    ), fe(a.children, t, m, l)), !(a.path == null && !a.index) && t.push({
+      path: l,
+      score: Ue(l, a.index),
+      routesMeta: m
+    });
+  };
+  return e.forEach((a, u) => {
+    var s;
+    if (a.path === "" || !((s = a.path) != null && s.includes("?")))
+      r(a, u);
+    else
+      for (let o of de(a.path))
+        r(a, u, o);
+  }), t;
+}
+function de(e) {
+  let t = e.split("/");
+  if (t.length === 0) return [];
+  let [n, ...i] = t, r = n.endsWith("?"), a = n.replace(/\?$/, "");
+  if (i.length === 0)
+    return r ? [a, ""] : [a];
+  let u = de(i.join("/")), s = [];
+  return s.push(
+    ...u.map(
+      (o) => o === "" ? a : [a, o].join("/")
+    )
+  ), r && s.push(...u), s.map(
+    (o) => e.startsWith("/") && o === "" ? "/" : o
+  );
+}
+function Te(e) {
+  e.sort(
+    (t, n) => t.score !== n.score ? n.score - t.score : Be(
+      t.routesMeta.map((i) => i.childrenIndex),
+      n.routesMeta.map((i) => i.childrenIndex)
+    )
+  );
+}
+var De = /^:[\w-]+$/, Ne = 3, Ae = 2, Fe = 1, Me = 10, Oe = -2, le = (e) => e === "*";
+function Ue(e, t) {
+  let n = e.split("/"), i = n.length;
+  return n.some(le) && (i += Oe), t && (i += Ae), n.filter((r) => !le(r)).reduce(
+    (r, a) => r + (De.test(a) ? Ne : a === "" ? Fe : Me),
+    i
+  );
+}
+function Be(e, t) {
+  return e.length === t.length && e.slice(0, -1).every((i, r) => i === t[r]) ? (
+    // If two routes are siblings, we should try to match the earlier sibling
+    // first. This allows people to have fine-grained control over the matching
+    // behavior by simply putting routes with identical paths in the order they
+    // want them tried.
+    e[e.length - 1] - t[t.length - 1]
+  ) : (
+    // Otherwise, it doesn't really make sense to rank non-siblings by index,
+    // so they sort equally.
+    0
+  );
+}
+function He(e, t, n = !1) {
+  let { routesMeta: i } = e, r = {}, a = "/", u = [];
+  for (let s = 0; s < i.length; ++s) {
+    let o = i[s], l = s === i.length - 1, m = a === "/" ? t : t.slice(a.length) || "/", y = J(
+      { path: o.relativePath, caseSensitive: o.caseSensitive, end: l },
+      m
+    ), h = o.route;
+    if (!y && l && n && !i[i.length - 1].route.index && (y = J(
+      {
+        path: o.relativePath,
+        caseSensitive: o.caseSensitive,
+        end: !1
+      },
+      m
+    )), !y)
+      return null;
+    Object.assign(r, y.params), u.push({
+      // TODO: Can this as be avoided?
+      params: r,
+      pathname: P([a, y.pathname]),
+      pathnameBase: Je(
+        P([a, y.pathnameBase])
+      ),
+      route: h
+    }), y.pathnameBase !== "/" && (a = P([a, y.pathnameBase]));
+  }
+  return u;
+}
+function J(e, t) {
+  typeof e == "string" && (e = { path: e, caseSensitive: !1, end: !0 });
+  let [n, i] = We(
+    e.path,
+    e.caseSensitive,
+    e.end
+  ), r = t.match(n);
+  if (!r) return null;
+  let a = r[0], u = a.replace(/(.)\/+$/, "$1"), s = r.slice(1);
+  return {
+    params: i.reduce(
+      (l, { paramName: m, isOptional: y }, h) => {
+        if (m === "*") {
+          let f = s[h] || "";
+          u = a.slice(0, a.length - f.length).replace(/(.)\/+$/, "$1");
+        }
+        const d = s[h];
+        return y && !d ? l[m] = void 0 : l[m] = (d || "").replace(/%2F/g, "/"), l;
+      },
+      {}
+    ),
+    pathname: a,
+    pathnameBase: u,
+    pattern: e
+  };
+}
+function We(e, t = !1, n = !0) {
+  L(
+    e === "*" || !e.endsWith("*") || e.endsWith("/*"),
+    `Route path "${e}" will be treated as if it were "${e.replace(/\*$/, "/*")}" because the \`*\` character must always follow a \`/\` in the pattern. To get rid of this warning, please change the route path to "${e.replace(/\*$/, "/*")}".`
+  );
+  let i = [], r = "^" + e.replace(/\/*\*?$/, "").replace(/^\/*/, "/").replace(/[\\.*+^${}|()[\]]/g, "\\$&").replace(
+    /\/:([\w-]+)(\?)?/g,
+    (u, s, o) => (i.push({ paramName: s, isOptional: o != null }), o ? "/?([^\\/]+)?" : "/([^\\/]+)")
+  );
+  return e.endsWith("*") ? (i.push({ paramName: "*" }), r += e === "*" || e === "/*" ? "(.*)$" : "(?:\\/(.+)|\\/*)$") : n ? r += "\\/*$" : e !== "" && e !== "/" && (r += "(?:(?=\\/|$))"), [new RegExp(r, t ? void 0 : "i"), i];
+}
+function _e(e) {
+  try {
+    return e.split("/").map((t) => decodeURIComponent(t).replace(/\//g, "%2F")).join("/");
+  } catch (t) {
+    return L(
+      !1,
+      `The URL path "${e}" could not be decoded because it is is a malformed URL segment. This is probably due to a bad percent encoding (${t}).`
+    ), e;
+  }
+}
+function T(e, t) {
+  if (t === "/") return e;
+  if (!e.toLowerCase().startsWith(t.toLowerCase()))
+    return null;
+  let n = t.endsWith("/") ? t.length - 1 : t.length, i = e.charAt(n);
+  return i && i !== "/" ? null : e.slice(n) || "/";
+}
+function ze(e, t = "/") {
+  let {
+    pathname: n,
+    search: i = "",
+    hash: r = ""
+  } = typeof e == "string" ? M(e) : e;
+  return {
+    pathname: n ? n.startsWith("/") ? n : Ve(n, t) : t,
+    search: Ke(i),
+    hash: qe(r)
+  };
+}
+function Ve(e, t) {
+  let n = t.replace(/\/+$/, "").split("/");
+  return e.split("/").forEach((r) => {
+    r === ".." ? n.length > 1 && n.pop() : r !== "." && n.push(r);
+  }), n.length > 1 ? n.join("/") : "/";
+}
+function G(e, t, n, i) {
+  return `Cannot include a '${e}' character in a manually specified \`to.${t}\` field [${JSON.stringify(
+    i
+  )}].  Please separate it out to the \`to.${n}\` field. Alternatively you may provide the full path as a string in <Link to="..."> and the router will parse it for you.`;
+}
+function je(e) {
+  return e.filter(
+    (t, n) => n === 0 || t.route.path && t.route.path.length > 0
+  );
+}
+function he(e) {
+  let t = je(e);
+  return t.map(
+    (n, i) => i === t.length - 1 ? n.pathname : n.pathnameBase
+  );
+}
+function me(e, t, n, i = !1) {
+  let r;
+  typeof e == "string" ? r = M(e) : (r = { ...e }, C(
+    !r.pathname || !r.pathname.includes("?"),
+    G("?", "pathname", "search", r)
+  ), C(
+    !r.pathname || !r.pathname.includes("#"),
+    G("#", "pathname", "hash", r)
+  ), C(
+    !r.search || !r.search.includes("#"),
+    G("#", "search", "hash", r)
+  ));
+  let a = e === "" || r.pathname === "", u = a ? "/" : r.pathname, s;
+  if (u == null)
+    s = n;
+  else {
+    let y = t.length - 1;
+    if (!i && u.startsWith("..")) {
+      let h = u.split("/");
+      for (; h[0] === ".."; )
+        h.shift(), y -= 1;
+      r.pathname = h.join("/");
+    }
+    s = y >= 0 ? t[y] : "/";
+  }
+  let o = ze(r, s), l = u && u !== "/" && u.endsWith("/"), m = (a || u === ".") && n.endsWith("/");
+  return !o.pathname.endsWith("/") && (l || m) && (o.pathname += "/"), o;
+}
+var P = (e) => e.join("/").replace(/\/\/+/g, "/"), Je = (e) => e.replace(/\/+$/, "").replace(/^\/*/, "/"), Ke = (e) => !e || e === "?" ? "" : e.startsWith("?") ? e : "?" + e, qe = (e) => !e || e === "#" ? "" : e.startsWith("#") ? e : "#" + e;
+function Ye(e) {
+  return e != null && typeof e.status == "number" && typeof e.statusText == "string" && typeof e.internal == "boolean" && "data" in e;
+}
+var pe = [
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE"
+];
+new Set(
+  pe
+);
+var Ge = [
+  "GET",
+  ...pe
+];
+new Set(Ge);
+var O = c.createContext(null);
+O.displayName = "DataRouter";
+var K = c.createContext(null);
+K.displayName = "DataRouterState";
+var ge = c.createContext({
+  isTransitioning: !1
+});
+ge.displayName = "ViewTransition";
+var Xe = c.createContext(
+  /* @__PURE__ */ new Map()
+);
+Xe.displayName = "Fetchers";
+var Qe = c.createContext(null);
+Qe.displayName = "Await";
+var b = c.createContext(
+  null
+);
+b.displayName = "Navigation";
+var q = c.createContext(
+  null
+);
+q.displayName = "Location";
+var k = c.createContext({
+  outlet: null,
+  matches: [],
+  isDataRoute: !1
+});
+k.displayName = "Route";
+var Q = c.createContext(null);
+Q.displayName = "RouteError";
+function Ze(e, { relative: t } = {}) {
+  C(
+    H(),
+    // TODO: This error is probably because they somehow have 2 versions of the
+    // router loaded. We can help them understand how to avoid that.
+    "useHref() may be used only in the context of a <Router> component."
+  );
+  let { basename: n, navigator: i } = c.useContext(b), { hash: r, pathname: a, search: u } = W(e, { relative: t }), s = a;
+  return n !== "/" && (s = a === "/" ? n : P([n, a])), i.createHref({ pathname: s, search: u, hash: r });
+}
+function H() {
+  return c.useContext(q) != null;
+}
+function N() {
+  return C(
+    H(),
+    // TODO: This error is probably because they somehow have 2 versions of the
+    // router loaded. We can help them understand how to avoid that.
+    "useLocation() may be used only in the context of a <Router> component."
+  ), c.useContext(q).location;
+}
+var ye = "You should call navigate() in a React.useEffect(), not when your component is first rendered.";
+function ve(e) {
+  c.useContext(b).static || c.useLayoutEffect(e);
+}
+function et() {
+  let { isDataRoute: e } = c.useContext(k);
+  return e ? ht() : tt();
+}
+function tt() {
+  C(
+    H(),
+    // TODO: This error is probably because they somehow have 2 versions of the
+    // router loaded. We can help them understand how to avoid that.
+    "useNavigate() may be used only in the context of a <Router> component."
+  );
+  let e = c.useContext(O), { basename: t, navigator: n } = c.useContext(b), { matches: i } = c.useContext(k), { pathname: r } = N(), a = JSON.stringify(he(i)), u = c.useRef(!1);
+  return ve(() => {
+    u.current = !0;
+  }), c.useCallback(
+    (o, l = {}) => {
+      if (L(u.current, ye), !u.current) return;
+      if (typeof o == "number") {
+        n.go(o);
+        return;
+      }
+      let m = me(
+        o,
+        JSON.parse(a),
+        r,
+        l.relative === "path"
+      );
+      e == null && t !== "/" && (m.pathname = m.pathname === "/" ? t : P([t, m.pathname])), (l.replace ? n.replace : n.push)(
+        m,
+        l.state,
+        l
+      );
+    },
+    [
+      t,
+      n,
+      a,
+      r,
+      e
+    ]
+  );
+}
+c.createContext(null);
+function W(e, { relative: t } = {}) {
+  let { matches: n } = c.useContext(k), { pathname: i } = N(), r = JSON.stringify(he(n));
+  return c.useMemo(
+    () => me(
+      e,
+      JSON.parse(r),
+      i,
+      t === "path"
+    ),
+    [e, r, i, t]
+  );
+}
+function nt(e, t, n, i) {
+  C(
+    H(),
+    // TODO: This error is probably because they somehow have 2 versions of the
+    // router loaded. We can help them understand how to avoid that.
+    "useRoutes() may be used only in the context of a <Router> component."
+  );
+  let { navigator: r } = c.useContext(b), { matches: a } = c.useContext(k), u = a[a.length - 1], s = u ? u.params : {};
+  u && u.pathname;
+  let o = u ? u.pathnameBase : "/";
+  u && u.route;
+  let l = N(), m;
+  m = l;
+  let y = m.pathname || "/", h = y;
+  if (o !== "/") {
+    let g = o.replace(/^\//, "").split("/");
+    h = "/" + y.replace(/^\//, "").split("/").slice(g.length).join("/");
+  }
+  let d = ce(e, { pathname: h });
+  return lt(
+    d && d.map(
+      (g) => Object.assign({}, g, {
+        params: Object.assign({}, s, g.params),
+        pathname: P([
+          o,
+          // Re-encode pathnames that were decoded inside matchRoutes
+          r.encodeLocation ? r.encodeLocation(g.pathname).pathname : g.pathname
+        ]),
+        pathnameBase: g.pathnameBase === "/" ? o : P([
+          o,
+          // Re-encode pathnames that were decoded inside matchRoutes
+          r.encodeLocation ? r.encodeLocation(g.pathnameBase).pathname : g.pathnameBase
+        ])
+      })
+    ),
+    a,
+    n,
+    i
+  );
+}
+function rt() {
+  let e = dt(), t = Ye(e) ? `${e.status} ${e.statusText}` : e instanceof Error ? e.message : JSON.stringify(e), n = e instanceof Error ? e.stack : null, r = { padding: "0.5rem", backgroundColor: "rgba(200,200,200, 0.5)" };
+  return /* @__PURE__ */ c.createElement(c.Fragment, null, /* @__PURE__ */ c.createElement("h2", null, "Unexpected Application Error!"), /* @__PURE__ */ c.createElement("h3", { style: { fontStyle: "italic" } }, t), n ? /* @__PURE__ */ c.createElement("pre", { style: r }, n) : null, null);
+}
+var at = /* @__PURE__ */ c.createElement(rt, null), it = class extends c.Component {
+  constructor(e) {
+    super(e), this.state = {
+      location: e.location,
+      revalidation: e.revalidation,
+      error: e.error
+    };
+  }
+  static getDerivedStateFromError(e) {
+    return { error: e };
+  }
+  static getDerivedStateFromProps(e, t) {
+    return t.location !== e.location || t.revalidation !== "idle" && e.revalidation === "idle" ? {
+      error: e.error,
+      location: e.location,
+      revalidation: e.revalidation
+    } : {
+      error: e.error !== void 0 ? e.error : t.error,
+      location: t.location,
+      revalidation: e.revalidation || t.revalidation
+    };
+  }
+  componentDidCatch(e, t) {
+    console.error(
+      "React Router caught the following error during render",
+      e,
+      t
+    );
+  }
+  render() {
+    return this.state.error !== void 0 ? /* @__PURE__ */ c.createElement(k.Provider, { value: this.props.routeContext }, /* @__PURE__ */ c.createElement(
+      Q.Provider,
+      {
+        value: this.state.error,
+        children: this.props.component
+      }
+    )) : this.props.children;
+  }
+};
+function ot({ routeContext: e, match: t, children: n }) {
+  let i = c.useContext(O);
+  return i && i.static && i.staticContext && (t.route.errorElement || t.route.ErrorBoundary) && (i.staticContext._deepestRenderedBoundaryId = t.route.id), /* @__PURE__ */ c.createElement(k.Provider, { value: e }, n);
+}
+function lt(e, t = [], n = null, i = null) {
+  if (e == null) {
+    if (!n)
+      return null;
+    if (n.errors)
+      e = n.matches;
+    else if (t.length === 0 && !n.initialized && n.matches.length > 0)
+      e = n.matches;
+    else
+      return null;
+  }
+  let r = e, a = n == null ? void 0 : n.errors;
+  if (a != null) {
+    let o = r.findIndex(
+      (l) => l.route.id && (a == null ? void 0 : a[l.route.id]) !== void 0
+    );
+    C(
+      o >= 0,
+      `Could not find a matching route for errors on route IDs: ${Object.keys(
+        a
+      ).join(",")}`
+    ), r = r.slice(
+      0,
+      Math.min(r.length, o + 1)
+    );
+  }
+  let u = !1, s = -1;
+  if (n)
+    for (let o = 0; o < r.length; o++) {
+      let l = r[o];
+      if ((l.route.HydrateFallback || l.route.hydrateFallbackElement) && (s = o), l.route.id) {
+        let { loaderData: m, errors: y } = n, h = l.route.loader && !m.hasOwnProperty(l.route.id) && (!y || y[l.route.id] === void 0);
+        if (l.route.lazy || h) {
+          u = !0, s >= 0 ? r = r.slice(0, s + 1) : r = [r[0]];
+          break;
+        }
+      }
+    }
+  return r.reduceRight((o, l, m) => {
+    let y, h = !1, d = null, f = null;
+    n && (y = a && l.route.id ? a[l.route.id] : void 0, d = l.route.errorElement || at, u && (s < 0 && m === 0 ? (mt(
+      "route-fallback",
+      !1,
+      "No `HydrateFallback` element provided to render during initial hydration"
+    ), h = !0, f = null) : s === m && (h = !0, f = l.route.hydrateFallbackElement || null)));
+    let g = t.concat(r.slice(0, m + 1)), v = () => {
+      let p;
+      return y ? p = d : h ? p = f : l.route.Component ? p = /* @__PURE__ */ c.createElement(l.route.Component, null) : l.route.element ? p = l.route.element : p = o, /* @__PURE__ */ c.createElement(
+        ot,
+        {
+          match: l,
+          routeContext: {
+            outlet: o,
+            matches: g,
+            isDataRoute: n != null
+          },
+          children: p
+        }
+      );
+    };
+    return n && (l.route.ErrorBoundary || l.route.errorElement || m === 0) ? /* @__PURE__ */ c.createElement(
+      it,
+      {
+        location: n.location,
+        revalidation: n.revalidation,
+        component: d,
+        error: y,
+        children: v(),
+        routeContext: { outlet: null, matches: g, isDataRoute: !0 }
+      }
+    ) : v();
+  }, null);
+}
+function Z(e) {
+  return `${e} must be used within a data router.  See https://reactrouter.com/en/main/routers/picking-a-router.`;
+}
+function ut(e) {
+  let t = c.useContext(O);
+  return C(t, Z(e)), t;
+}
+function st(e) {
+  let t = c.useContext(K);
+  return C(t, Z(e)), t;
+}
+function ct(e) {
+  let t = c.useContext(k);
+  return C(t, Z(e)), t;
+}
+function ee(e) {
+  let t = ct(e), n = t.matches[t.matches.length - 1];
+  return C(
+    n.route.id,
+    `${e} can only be used on routes that contain a unique "id"`
+  ), n.route.id;
+}
+function ft() {
+  return ee(
+    "useRouteId"
+    /* UseRouteId */
+  );
+}
+function dt() {
+  var i;
+  let e = c.useContext(Q), t = st(
+    "useRouteError"
+    /* UseRouteError */
+  ), n = ee(
+    "useRouteError"
+    /* UseRouteError */
+  );
+  return e !== void 0 ? e : (i = t.errors) == null ? void 0 : i[n];
+}
+function ht() {
+  let { router: e } = ut(
+    "useNavigate"
+    /* UseNavigateStable */
+  ), t = ee(
+    "useNavigate"
+    /* UseNavigateStable */
+  ), n = c.useRef(!1);
+  return ve(() => {
+    n.current = !0;
+  }), c.useCallback(
+    async (r, a = {}) => {
+      L(n.current, ye), n.current && (typeof r == "number" ? e.navigate(r) : await e.navigate(r, { fromRouteId: t, ...a }));
+    },
+    [e, t]
+  );
+}
+var ue = {};
+function mt(e, t, n) {
+  ue[e] || (ue[e] = !0, L(!1, n));
+}
+c.memo(pt);
+function pt({
+  routes: e,
+  future: t,
+  state: n
+}) {
+  return nt(e, void 0, n, t);
+}
+function qt({
+  basename: e,
+  children: t,
+  initialEntries: n,
+  initialIndex: i
+}) {
+  let r = c.useRef();
+  r.current == null && (r.current = Pe({
+    initialEntries: n,
+    initialIndex: i,
+    v5Compat: !0
+  }));
+  let a = r.current, [u, s] = c.useState({
+    action: a.action,
+    location: a.location
+  }), o = c.useCallback(
+    (l) => {
+      c.startTransition(() => s(l));
+    },
+    [s]
+  );
+  return c.useLayoutEffect(() => a.listen(o), [a, o]), /* @__PURE__ */ c.createElement(
+    we,
+    {
+      basename: e,
+      children: t,
+      location: u.location,
+      navigationType: u.action,
+      navigator: a
+    }
+  );
+}
+function we({
+  basename: e = "/",
+  children: t = null,
+  location: n,
+  navigationType: i = "POP",
+  navigator: r,
+  static: a = !1
+}) {
+  C(
+    !H(),
+    "You cannot render a <Router> inside another <Router>. You should never have more than one in your app."
+  );
+  let u = e.replace(/^\/*/, "/"), s = c.useMemo(
+    () => ({
+      basename: u,
+      navigator: r,
+      static: a,
+      future: {}
+    }),
+    [u, r, a]
+  );
+  typeof n == "string" && (n = M(n));
+  let {
+    pathname: o = "/",
+    search: l = "",
+    hash: m = "",
+    state: y = null,
+    key: h = "default"
+  } = n, d = c.useMemo(() => {
+    let f = T(o, u);
+    return f == null ? null : {
+      location: {
+        pathname: f,
+        search: l,
+        hash: m,
+        state: y,
+        key: h
+      },
+      navigationType: i
+    };
+  }, [u, o, l, m, y, h, i]);
+  return L(
+    d != null,
+    `<Router basename="${u}"> is not able to match the URL "${o}${l}${m}" because it does not start with the basename, so the <Router> won't render anything.`
+  ), d == null ? null : /* @__PURE__ */ c.createElement(b.Provider, { value: s }, /* @__PURE__ */ c.createElement(q.Provider, { children: t, value: d }));
+}
+var z = "get", V = "application/x-www-form-urlencoded";
+function Y(e) {
+  return e != null && typeof e.tagName == "string";
+}
+function gt(e) {
+  return Y(e) && e.tagName.toLowerCase() === "button";
+}
+function yt(e) {
+  return Y(e) && e.tagName.toLowerCase() === "form";
+}
+function vt(e) {
+  return Y(e) && e.tagName.toLowerCase() === "input";
+}
+function wt(e) {
+  return !!(e.metaKey || e.altKey || e.ctrlKey || e.shiftKey);
+}
+function xt(e, t) {
+  return e.button === 0 && // Ignore everything but left clicks
+  (!t || t === "_self") && // Let browser handle "target=_blank" etc.
+  !wt(e);
+}
+var _ = null;
+function Ct() {
+  if (_ === null)
+    try {
+      new FormData(
+        document.createElement("form"),
+        // @ts-expect-error if FormData supports the submitter parameter, this will throw
+        0
+      ), _ = !1;
+    } catch {
+      _ = !0;
+    }
+  return _;
+}
+var Et = /* @__PURE__ */ new Set([
+  "application/x-www-form-urlencoded",
+  "multipart/form-data",
+  "text/plain"
+]);
+function X(e) {
+  return e != null && !Et.has(e) ? (L(
+    !1,
+    `"${e}" is not a valid \`encType\` for \`<Form>\`/\`<fetcher.Form>\` and will default to "${V}"`
+  ), null) : e;
+}
+function Rt(e, t) {
+  let n, i, r, a, u;
+  if (yt(e)) {
+    let s = e.getAttribute("action");
+    i = s ? T(s, t) : null, n = e.getAttribute("method") || z, r = X(e.getAttribute("enctype")) || V, a = new FormData(e);
+  } else if (gt(e) || vt(e) && (e.type === "submit" || e.type === "image")) {
+    let s = e.form;
+    if (s == null)
+      throw new Error(
+        'Cannot submit a <button> or <input type="submit"> without a <form>'
+      );
+    let o = e.getAttribute("formaction") || s.getAttribute("action");
+    if (i = o ? T(o, t) : null, n = e.getAttribute("formmethod") || s.getAttribute("method") || z, r = X(e.getAttribute("formenctype")) || X(s.getAttribute("enctype")) || V, a = new FormData(s, e), !Ct()) {
+      let { name: l, type: m, value: y } = e;
+      if (m === "image") {
+        let h = l ? `${l}.` : "";
+        a.append(`${h}x`, "0"), a.append(`${h}y`, "0");
+      } else l && a.append(l, y);
+    }
+  } else {
+    if (Y(e))
+      throw new Error(
+        'Cannot submit element that is not <form>, <button>, or <input type="submit|image">'
+      );
+    n = z, i = null, r = V, u = e;
+  }
+  return a && r === "text/plain" && (u = a, a = void 0), { action: i, method: n.toLowerCase(), encType: r, formData: a, body: u };
+}
+function te(e, t) {
+  if (e === !1 || e === null || typeof e > "u")
+    throw new Error(t);
+}
+async function St(e, t) {
+  if (e.id in t)
+    return t[e.id];
+  try {
+    let n = await import(
+      /* @vite-ignore */
+      /* webpackIgnore: true */
+      e.module
+    );
+    return t[e.id] = n, n;
+  } catch (n) {
+    return console.error(
+      `Error loading route module \`${e.module}\`, reloading page...`
+    ), console.error(n), window.__reactRouterContext && window.__reactRouterContext.isSpaMode, window.location.reload(), new Promise(() => {
+    });
+  }
+}
+function bt(e) {
+  return e == null ? !1 : e.href == null ? e.rel === "preload" && typeof e.imageSrcSet == "string" && typeof e.imageSizes == "string" : typeof e.rel == "string" && typeof e.href == "string";
+}
+async function Pt(e, t, n) {
+  let i = await Promise.all(
+    e.map(async (r) => {
+      let a = t.routes[r.route.id];
+      if (a) {
+        let u = await St(a, n);
+        return u.links ? u.links() : [];
+      }
+      return [];
+    })
+  );
+  return It(
+    i.flat(1).filter(bt).filter((r) => r.rel === "stylesheet" || r.rel === "preload").map(
+      (r) => r.rel === "stylesheet" ? { ...r, rel: "prefetch", as: "style" } : { ...r, rel: "prefetch" }
+    )
+  );
+}
+function se(e, t, n, i, r, a) {
+  let u = (o, l) => n[l] ? o.route.id !== n[l].route.id : !0, s = (o, l) => {
+    var m;
+    return (
+      // param change, /users/123 -> /users/456
+      n[l].pathname !== o.pathname || // splat param changed, which is not present in match.path
+      // e.g. /files/images/avatar.jpg -> files/finances.xls
+      ((m = n[l].route.path) == null ? void 0 : m.endsWith("*")) && n[l].params["*"] !== o.params["*"]
+    );
+  };
+  return a === "assets" ? t.filter(
+    (o, l) => u(o, l) || s(o, l)
+  ) : a === "data" ? t.filter((o, l) => {
+    var y;
+    let m = i.routes[o.route.id];
+    if (!m || !m.hasLoader)
+      return !1;
+    if (u(o, l) || s(o, l))
+      return !0;
+    if (o.route.shouldRevalidate) {
+      let h = o.route.shouldRevalidate({
+        currentUrl: new URL(
+          r.pathname + r.search + r.hash,
+          window.origin
+        ),
+        currentParams: ((y = n[0]) == null ? void 0 : y.params) || {},
+        nextUrl: new URL(e, window.origin),
+        nextParams: o.params,
+        defaultShouldRevalidate: !0
+      });
+      if (typeof h == "boolean")
+        return h;
+    }
+    return !0;
+  }) : [];
+}
+function Lt(e, t) {
+  return kt(
+    e.map((n) => {
+      let i = t.routes[n.route.id];
+      if (!i) return [];
+      let r = [i.module];
+      return i.imports && (r = r.concat(i.imports)), r;
+    }).flat(1)
+  );
+}
+function kt(e) {
+  return [...new Set(e)];
+}
+function $t(e) {
+  let t = {}, n = Object.keys(e).sort();
+  for (let i of n)
+    t[i] = e[i];
+  return t;
+}
+function It(e, t) {
+  let n = /* @__PURE__ */ new Set();
+  return new Set(t), e.reduce((i, r) => {
+    let a = JSON.stringify($t(r));
+    return n.has(a) || (n.add(a), i.push({ key: a, link: r })), i;
+  }, []);
+}
+function Tt(e) {
+  let t = typeof e == "string" ? new URL(
+    e,
+    // This can be called during the SSR flow via PrefetchPageLinksImpl so
+    // don't assume window is available
+    typeof window > "u" ? "server://singlefetch/" : window.location.origin
+  ) : e;
+  return t.pathname === "/" ? t.pathname = "_root.data" : t.pathname = `${t.pathname.replace(/\/$/, "")}.data`, t;
+}
+function Dt() {
+  let e = c.useContext(O);
+  return te(
+    e,
+    "You must render this element inside a <DataRouterContext.Provider> element"
+  ), e;
+}
+function Nt() {
+  let e = c.useContext(K);
+  return te(
+    e,
+    "You must render this element inside a <DataRouterStateContext.Provider> element"
+  ), e;
+}
+var ne = c.createContext(void 0);
+ne.displayName = "FrameworkContext";
+function xe() {
+  let e = c.useContext(ne);
+  return te(
+    e,
+    "You must render this element inside a <HydratedRouter> element"
+  ), e;
+}
+function At(e, t) {
+  let n = c.useContext(ne), [i, r] = c.useState(!1), [a, u] = c.useState(!1), { onFocus: s, onBlur: o, onMouseEnter: l, onMouseLeave: m, onTouchStart: y } = t, h = c.useRef(null);
+  c.useEffect(() => {
+    if (e === "render" && u(!0), e === "viewport") {
+      let g = (p) => {
+        p.forEach((w) => {
+          u(w.isIntersecting);
+        });
+      }, v = new IntersectionObserver(g, { threshold: 0.5 });
+      return h.current && v.observe(h.current), () => {
+        v.disconnect();
+      };
+    }
+  }, [e]), c.useEffect(() => {
+    if (i) {
+      let g = setTimeout(() => {
+        u(!0);
+      }, 100);
+      return () => {
+        clearTimeout(g);
+      };
+    }
+  }, [i]);
+  let d = () => {
+    r(!0);
+  }, f = () => {
+    r(!1), u(!1);
+  };
+  return n ? e !== "intent" ? [a, h, {}] : [
+    a,
+    h,
+    {
+      onFocus: B(s, d),
+      onBlur: B(o, f),
+      onMouseEnter: B(l, d),
+      onMouseLeave: B(m, f),
+      onTouchStart: B(y, d)
+    }
+  ] : [!1, h, {}];
+}
+function B(e, t) {
+  return (n) => {
+    e && e(n), n.defaultPrevented || t(n);
+  };
+}
+function Ft({
+  page: e,
+  ...t
+}) {
+  let { router: n } = Dt(), i = c.useMemo(
+    () => ce(n.routes, e, n.basename),
+    [n.routes, e, n.basename]
+  );
+  return i ? /* @__PURE__ */ c.createElement(Ot, { page: e, matches: i, ...t }) : (console.warn(`Tried to prefetch ${e} but no routes matched.`), null);
+}
+function Mt(e) {
+  let { manifest: t, routeModules: n } = xe(), [i, r] = c.useState([]);
+  return c.useEffect(() => {
+    let a = !1;
+    return Pt(e, t, n).then(
+      (u) => {
+        a || r(u);
+      }
+    ), () => {
+      a = !0;
+    };
+  }, [e, t, n]), i;
+}
+function Ot({
+  page: e,
+  matches: t,
+  ...n
+}) {
+  let i = N(), { manifest: r, routeModules: a } = xe(), { loaderData: u, matches: s } = Nt(), o = c.useMemo(
+    () => se(
+      e,
+      t,
+      s,
+      r,
+      i,
+      "data"
+    ),
+    [e, t, s, r, i]
+  ), l = c.useMemo(
+    () => se(
+      e,
+      t,
+      s,
+      r,
+      i,
+      "assets"
+    ),
+    [e, t, s, r, i]
+  ), m = c.useMemo(() => {
+    if (e === i.pathname + i.search + i.hash)
+      return [];
+    let d = /* @__PURE__ */ new Set(), f = !1;
+    if (t.forEach((v) => {
+      var w;
+      let p = r.routes[v.route.id];
+      !p || !p.hasLoader || (!o.some((x) => x.route.id === v.route.id) && v.route.id in u && ((w = a[v.route.id]) != null && w.shouldRevalidate) || p.hasClientLoader ? f = !0 : d.add(v.route.id));
+    }), d.size === 0)
+      return [];
+    let g = Tt(e);
+    return f && d.size > 0 && g.searchParams.set(
+      "_routes",
+      t.filter((v) => d.has(v.route.id)).map((v) => v.route.id).join(",")
+    ), [g.pathname + g.search];
+  }, [
+    u,
+    i,
+    r,
+    o,
+    t,
+    e,
+    a
+  ]), y = c.useMemo(
+    () => Lt(l, r),
+    [l, r]
+  ), h = Mt(l);
+  return /* @__PURE__ */ c.createElement(c.Fragment, null, m.map((d) => /* @__PURE__ */ c.createElement("link", { key: d, rel: "prefetch", as: "fetch", href: d, ...n })), y.map((d) => /* @__PURE__ */ c.createElement("link", { key: d, rel: "modulepreload", href: d, ...n })), h.map(({ key: d, link: f }) => (
+    // these don't spread `linkProps` because they are full link descriptors
+    // already with their own props
+    /* @__PURE__ */ c.createElement("link", { key: d, ...f })
+  )));
+}
+function Ut(...e) {
+  return (t) => {
+    e.forEach((n) => {
+      typeof n == "function" ? n(t) : n != null && (n.current = t);
+    });
+  };
+}
+var Ce = typeof window < "u" && typeof window.document < "u" && typeof window.document.createElement < "u";
+try {
+  Ce && (window.__reactRouterVersion = "7.0.1");
+} catch {
+}
+function Yt({
+  basename: e,
+  children: t,
+  window: n
+}) {
+  let i = c.useRef();
+  i.current == null && (i.current = Le({ window: n, v5Compat: !0 }));
+  let r = i.current, [a, u] = c.useState({
+    action: r.action,
+    location: r.location
+  }), s = c.useCallback(
+    (o) => {
+      c.startTransition(() => u(o));
+    },
+    [u]
+  );
+  return c.useLayoutEffect(() => r.listen(s), [r, s]), /* @__PURE__ */ c.createElement(
+    we,
+    {
+      basename: e,
+      children: t,
+      location: a.location,
+      navigationType: a.action,
+      navigator: r
+    }
+  );
+}
+var Ee = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i, Re = c.forwardRef(
+  function({
+    onClick: t,
+    discover: n = "render",
+    prefetch: i = "none",
+    relative: r,
+    reloadDocument: a,
+    replace: u,
+    state: s,
+    target: o,
+    to: l,
+    preventScrollReset: m,
+    viewTransition: y,
+    ...h
+  }, d) {
+    let { basename: f } = c.useContext(b), g = typeof l == "string" && Ee.test(l), v, p = !1;
+    if (typeof l == "string" && g && (v = l, Ce))
+      try {
+        let S = new URL(window.location.href), I = l.startsWith("//") ? new URL(S.protocol + l) : new URL(l), re = T(I.pathname, f);
+        I.origin === S.origin && re != null ? l = re + I.search + I.hash : p = !0;
+      } catch {
+        L(
+          !1,
+          `<Link to="${l}"> contains an invalid URL which will probably break when clicked - please update to a valid URL path.`
+        );
+      }
+    let w = Ze(l, { relative: r }), [x, E, R] = At(
+      i,
+      h
+    ), A = _t(l, {
+      replace: u,
+      state: s,
+      target: o,
+      preventScrollReset: m,
+      relative: r,
+      viewTransition: y
+    });
+    function $(S) {
+      t && t(S), S.defaultPrevented || A(S);
+    }
+    let D = (
+      // eslint-disable-next-line jsx-a11y/anchor-has-content
+      /* @__PURE__ */ c.createElement(
+        "a",
+        {
+          ...h,
+          ...R,
+          href: v || w,
+          onClick: p || a ? t : $,
+          ref: Ut(d, E),
+          target: o,
+          "data-discover": !g && n === "render" ? "true" : void 0
+        }
+      )
+    );
+    return x && !g ? /* @__PURE__ */ c.createElement(c.Fragment, null, D, /* @__PURE__ */ c.createElement(Ft, { page: w })) : D;
+  }
+);
+Re.displayName = "Link";
+var Bt = c.forwardRef(
+  function({
+    "aria-current": t = "page",
+    caseSensitive: n = !1,
+    className: i = "",
+    end: r = !1,
+    style: a,
+    to: u,
+    viewTransition: s,
+    children: o,
+    ...l
+  }, m) {
+    let y = W(u, { relative: l.relative }), h = N(), d = c.useContext(K), { navigator: f, basename: g } = c.useContext(b), v = d != null && // Conditional usage is OK here because the usage of a data router is static
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    Kt(y) && s === !0, p = f.encodeLocation ? f.encodeLocation(y).pathname : y.pathname, w = h.pathname, x = d && d.navigation && d.navigation.location ? d.navigation.location.pathname : null;
+    n || (w = w.toLowerCase(), x = x ? x.toLowerCase() : null, p = p.toLowerCase()), x && g && (x = T(x, g) || x);
+    const E = p !== "/" && p.endsWith("/") ? p.length - 1 : p.length;
+    let R = w === p || !r && w.startsWith(p) && w.charAt(E) === "/", A = x != null && (x === p || !r && x.startsWith(p) && x.charAt(p.length) === "/"), $ = {
+      isActive: R,
+      isPending: A,
+      isTransitioning: v
+    }, D = R ? t : void 0, S;
+    typeof i == "function" ? S = i($) : S = [
+      i,
+      R ? "active" : null,
+      A ? "pending" : null,
+      v ? "transitioning" : null
+    ].filter(Boolean).join(" ");
+    let I = typeof a == "function" ? a($) : a;
+    return /* @__PURE__ */ c.createElement(
+      Re,
+      {
+        ...l,
+        "aria-current": D,
+        className: S,
+        ref: m,
+        style: I,
+        to: u,
+        viewTransition: s
+      },
+      typeof o == "function" ? o($) : o
+    );
+  }
+);
+Bt.displayName = "NavLink";
+var Ht = c.forwardRef(
+  ({
+    discover: e = "render",
+    fetcherKey: t,
+    navigate: n,
+    reloadDocument: i,
+    replace: r,
+    state: a,
+    method: u = z,
+    action: s,
+    onSubmit: o,
+    relative: l,
+    preventScrollReset: m,
+    viewTransition: y,
+    ...h
+  }, d) => {
+    let f = jt(), g = Jt(s, { relative: l }), v = u.toLowerCase() === "get" ? "get" : "post", p = typeof s == "string" && Ee.test(s), w = (x) => {
+      if (o && o(x), x.defaultPrevented) return;
+      x.preventDefault();
+      let E = x.nativeEvent.submitter, R = (E == null ? void 0 : E.getAttribute("formmethod")) || u;
+      f(E || x.currentTarget, {
+        fetcherKey: t,
+        method: R,
+        navigate: n,
+        replace: r,
+        state: a,
+        relative: l,
+        preventScrollReset: m,
+        viewTransition: y
+      });
+    };
+    return /* @__PURE__ */ c.createElement(
+      "form",
+      {
+        ref: d,
+        method: v,
+        action: g,
+        onSubmit: i ? o : w,
+        ...h,
+        "data-discover": !p && e === "render" ? "true" : void 0
+      }
+    );
+  }
+);
+Ht.displayName = "Form";
+function Wt(e) {
+  return `${e} must be used within a data router.  See https://reactrouter.com/en/main/routers/picking-a-router.`;
+}
+function Se(e) {
+  let t = c.useContext(O);
+  return C(t, Wt(e)), t;
+}
+function _t(e, {
+  target: t,
+  replace: n,
+  state: i,
+  preventScrollReset: r,
+  relative: a,
+  viewTransition: u
+} = {}) {
+  let s = et(), o = N(), l = W(e, { relative: a });
+  return c.useCallback(
+    (m) => {
+      if (xt(m, t)) {
+        m.preventDefault();
+        let y = n !== void 0 ? n : F(o) === F(l);
+        s(e, {
+          replace: y,
+          state: i,
+          preventScrollReset: r,
+          relative: a,
+          viewTransition: u
+        });
+      }
+    },
+    [
+      o,
+      s,
+      l,
+      n,
+      i,
+      t,
+      e,
+      r,
+      a,
+      u
+    ]
+  );
+}
+var zt = 0, Vt = () => `__${String(++zt)}__`;
+function jt() {
+  let { router: e } = Se(
+    "useSubmit"
+    /* UseSubmit */
+  ), { basename: t } = c.useContext(b), n = ft();
+  return c.useCallback(
+    async (i, r = {}) => {
+      let { action: a, method: u, encType: s, formData: o, body: l } = Rt(
+        i,
+        t
+      );
+      if (r.navigate === !1) {
+        let m = r.fetcherKey || Vt();
+        await e.fetch(m, n, r.action || a, {
+          preventScrollReset: r.preventScrollReset,
+          formData: o,
+          body: l,
+          formMethod: r.method || u,
+          formEncType: r.encType || s,
+          flushSync: r.flushSync
+        });
+      } else
+        await e.navigate(r.action || a, {
+          preventScrollReset: r.preventScrollReset,
+          formData: o,
+          body: l,
+          formMethod: r.method || u,
+          formEncType: r.encType || s,
+          replace: r.replace,
+          state: r.state,
+          fromRouteId: n,
+          flushSync: r.flushSync,
+          viewTransition: r.viewTransition
+        });
+    },
+    [e, t, n]
+  );
+}
+function Jt(e, { relative: t } = {}) {
+  let { basename: n } = c.useContext(b), i = c.useContext(k);
+  C(i, "useFormAction must be used inside a RouteContext");
+  let [r] = i.matches.slice(-1), a = { ...W(e || ".", { relative: t }) }, u = N();
+  if (e == null) {
+    a.search = u.search;
+    let s = new URLSearchParams(a.search), o = s.getAll("index");
+    if (o.some((m) => m === "")) {
+      s.delete("index"), o.filter((y) => y).forEach((y) => s.append("index", y));
+      let m = s.toString();
+      a.search = m ? `?${m}` : "";
+    }
+  }
+  return (!e || e === ".") && r.route.index && (a.search = a.search ? a.search.replace(/^\?/, "?index&") : "?index"), n !== "/" && (a.pathname = a.pathname === "/" ? n : P([n, a.pathname])), F(a);
+}
+function Kt(e, t = {}) {
+  let n = c.useContext(ge);
+  C(
+    n != null,
+    "`useViewTransitionState` must be used within `react-router-dom`'s `RouterProvider`.  Did you accidentally import `RouterProvider` from `react-router`?"
+  );
+  let { basename: i } = Se(
+    "useViewTransitionState"
+    /* useViewTransitionState */
+  ), r = W(e, { relative: t.relative });
+  if (!n.isTransitioning)
+    return !1;
+  let a = T(n.currentLocation.pathname, i) || n.currentLocation.pathname, u = T(n.nextLocation.pathname, i) || n.nextLocation.pathname;
+  return J(r.pathname, u) != null || J(r.pathname, a) != null;
+}
+new TextEncoder();
+export {
+  Yt as B,
+  Re as L,
+  qt as M,
+  Bt as N,
+  N as u
+};
+//# sourceMappingURL=chunk-7R3XDUXW-C-tvzxWq.js.map