gemi 0.1.1 → 0.2.0

package/dist/client/index.js

@@ -0,0 +1,1641 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+var _i, _n, _t, _e, _s, _l, _o, _d, _p, _g, _r, r_fn, _R, R_fn, _b, b_fn, _u, u_fn, _m, m_fn, _a, a_fn, _P, P_fn, _E, E_fn, _S, S_fn, _O, O_fn, _k, k_fn, _x, x_fn, _h, h_fn, _f, f_fn, _T, T_fn, _A, A_fn, _y, y_fn, _w, w_fn, _c, c_fn, _C, C_fn, _a2, _i2, _n2, _t2, _e2, _s2, _l2, _b2;
+import { jsx, Fragment, jsxs } from "react/jsx-runtime";
+import { createContext, useContext, useState, startTransition, useEffect, useRef, lazy, Suspense } from "react";
+const ServerDataContext = createContext({});
+const ServerDataProvider = (props) => {
+  let _value = props.value;
+  if (props.value) {
+    _value = props.value;
+  } else {
+    _value = window.__GEMI_DATA__;
+  }
+  return /* @__PURE__ */ jsx(ServerDataContext.Provider, { value: _value, children: props.children });
+};
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function(n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t)
+        ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
+var Action;
+(function(Action2) {
+  Action2["Pop"] = "POP";
+  Action2["Push"] = "PUSH";
+  Action2["Replace"] = "REPLACE";
+})(Action || (Action = {}));
+var readOnly = process.env.NODE_ENV !== "production" ? function(obj) {
+  return Object.freeze(obj);
+} : function(obj) {
+  return obj;
+};
+function warning(cond, message) {
+  {
+    if (typeof console !== "undefined")
+      console.warn(message);
+    try {
+      throw new Error(message);
+    } catch (e) {
+    }
+  }
+}
+var BeforeUnloadEventType = "beforeunload";
+var PopStateEventType = "popstate";
+function createBrowserHistory(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  var _options = options, _options$window = _options.window, window2 = _options$window === void 0 ? document.defaultView : _options$window;
+  var globalHistory = window2.history;
+  function getIndexAndLocation() {
+    var _window$location = window2.location, pathname = _window$location.pathname, search = _window$location.search, hash = _window$location.hash;
+    var state = globalHistory.state || {};
+    return [state.idx, readOnly({
+      pathname,
+      search,
+      hash,
+      state: state.usr || null,
+      key: state.key || "default"
+    })];
+  }
+  var blockedPopTx = null;
+  function handlePop() {
+    if (blockedPopTx) {
+      blockers.call(blockedPopTx);
+      blockedPopTx = null;
+    } else {
+      var nextAction = Action.Pop;
+      var _getIndexAndLocation = getIndexAndLocation(), nextIndex = _getIndexAndLocation[0], nextLocation = _getIndexAndLocation[1];
+      if (blockers.length) {
+        if (nextIndex != null) {
+          var delta = index - nextIndex;
+          if (delta) {
+            blockedPopTx = {
+              action: nextAction,
+              location: nextLocation,
+              retry: function retry() {
+                go(delta * -1);
+              }
+            };
+            go(delta);
+          }
+        } else {
+          process.env.NODE_ENV !== "production" ? warning(
+            false,
+            // TODO: Write up a doc that explains our blocking strategy in
+            // detail and link to it here so people can understand better what
+            // is going on and how to avoid it.
+            "You are trying to block a POP navigation to a location that was not created by the history library. The block will fail silently in production, but in general you should do all navigation with the history library (instead of using window.history.pushState directly) to avoid this situation."
+          ) : void 0;
+        }
+      } else {
+        applyTx(nextAction);
+      }
+    }
+  }
+  window2.addEventListener(PopStateEventType, handlePop);
+  var action = Action.Pop;
+  var _getIndexAndLocation2 = getIndexAndLocation(), index = _getIndexAndLocation2[0], location = _getIndexAndLocation2[1];
+  var listeners = createEvents();
+  var blockers = createEvents();
+  if (index == null) {
+    index = 0;
+    globalHistory.replaceState(_extends({}, globalHistory.state, {
+      idx: index
+    }), "");
+  }
+  function createHref(to) {
+    return typeof to === "string" ? to : createPath(to);
+  }
+  function getNextLocation(to, state) {
+    if (state === void 0) {
+      state = null;
+    }
+    return readOnly(_extends({
+      pathname: location.pathname,
+      hash: "",
+      search: ""
+    }, typeof to === "string" ? parsePath(to) : to, {
+      state,
+      key: createKey()
+    }));
+  }
+  function getHistoryStateAndUrl(nextLocation, index2) {
+    return [{
+      usr: nextLocation.state,
+      key: nextLocation.key,
+      idx: index2
+    }, createHref(nextLocation)];
+  }
+  function allowTx(action2, location2, retry) {
+    return !blockers.length || (blockers.call({
+      action: action2,
+      location: location2,
+      retry
+    }), false);
+  }
+  function applyTx(nextAction) {
+    action = nextAction;
+    var _getIndexAndLocation3 = getIndexAndLocation();
+    index = _getIndexAndLocation3[0];
+    location = _getIndexAndLocation3[1];
+    listeners.call({
+      action,
+      location
+    });
+  }
+  function push(to, state) {
+    var nextAction = Action.Push;
+    var nextLocation = getNextLocation(to, state);
+    function retry() {
+      push(to, state);
+    }
+    if (allowTx(nextAction, nextLocation, retry)) {
+      var _getHistoryStateAndUr = getHistoryStateAndUrl(nextLocation, index + 1), historyState = _getHistoryStateAndUr[0], url = _getHistoryStateAndUr[1];
+      try {
+        globalHistory.pushState(historyState, "", url);
+      } catch (error) {
+        window2.location.assign(url);
+      }
+      applyTx(nextAction);
+    }
+  }
+  function replace(to, state) {
+    var nextAction = Action.Replace;
+    var nextLocation = getNextLocation(to, state);
+    function retry() {
+      replace(to, state);
+    }
+    if (allowTx(nextAction, nextLocation, retry)) {
+      var _getHistoryStateAndUr2 = getHistoryStateAndUrl(nextLocation, index), historyState = _getHistoryStateAndUr2[0], url = _getHistoryStateAndUr2[1];
+      globalHistory.replaceState(historyState, "", url);
+      applyTx(nextAction);
+    }
+  }
+  function go(delta) {
+    globalHistory.go(delta);
+  }
+  var history = {
+    get action() {
+      return action;
+    },
+    get location() {
+      return location;
+    },
+    createHref,
+    push,
+    replace,
+    go,
+    back: function back() {
+      go(-1);
+    },
+    forward: function forward() {
+      go(1);
+    },
+    listen: function listen(listener) {
+      return listeners.push(listener);
+    },
+    block: function block(blocker) {
+      var unblock = blockers.push(blocker);
+      if (blockers.length === 1) {
+        window2.addEventListener(BeforeUnloadEventType, promptBeforeUnload);
+      }
+      return function() {
+        unblock();
+        if (!blockers.length) {
+          window2.removeEventListener(BeforeUnloadEventType, promptBeforeUnload);
+        }
+      };
+    }
+  };
+  return history;
+}
+function promptBeforeUnload(event) {
+  event.preventDefault();
+  event.returnValue = "";
+}
+function createEvents() {
+  var handlers = [];
+  return {
+    get length() {
+      return handlers.length;
+    },
+    push: function push(fn) {
+      handlers.push(fn);
+      return function() {
+        handlers = handlers.filter(function(handler) {
+          return handler !== fn;
+        });
+      };
+    },
+    call: function call(arg) {
+      handlers.forEach(function(fn) {
+        return fn && fn(arg);
+      });
+    }
+  };
+}
+function createKey() {
+  return Math.random().toString(36).substr(2, 8);
+}
+function createPath(_ref) {
+  var _ref$pathname = _ref.pathname, pathname = _ref$pathname === void 0 ? "/" : _ref$pathname, _ref$search = _ref.search, search = _ref$search === void 0 ? "" : _ref$search, _ref$hash = _ref.hash, hash = _ref$hash === void 0 ? "" : _ref$hash;
+  if (search && search !== "?")
+    pathname += search.charAt(0) === "?" ? search : "?" + search;
+  if (hash && hash !== "#")
+    pathname += hash.charAt(0) === "#" ? hash : "#" + hash;
+  return pathname;
+}
+function parsePath(path) {
+  var parsedPath = {};
+  if (path) {
+    var hashIndex = path.indexOf("#");
+    if (hashIndex >= 0) {
+      parsedPath.hash = path.substr(hashIndex);
+      path = path.substr(0, hashIndex);
+    }
+    var searchIndex = path.indexOf("?");
+    if (searchIndex >= 0) {
+      parsedPath.search = path.substr(searchIndex);
+      path = path.substr(0, searchIndex);
+    }
+    if (path) {
+      parsedPath.pathname = path;
+    }
+  }
+  return parsedPath;
+}
+class Subject {
+  constructor(initialValue) {
+    __publicField(this, "subscribers", /* @__PURE__ */ new Set());
+    __publicField(this, "value");
+    this.value = initialValue;
+  }
+  subscribe(subscriber) {
+    this.subscribers.add(subscriber);
+    return () => {
+      this.subscribers.delete(subscriber);
+    };
+  }
+  next(value) {
+    this.value = value;
+    this.subscribers.forEach((subscriber) => subscriber(value));
+  }
+  getValue() {
+    return this.value;
+  }
+}
+var R = class {
+  constructor(t, r, n, o, c, l) {
+    __publicField(this, "type", 3);
+    __publicField(this, "name", "");
+    __publicField(this, "prefix", "");
+    __publicField(this, "value", "");
+    __publicField(this, "suffix", "");
+    __publicField(this, "modifier", 3);
+    this.type = t, this.name = r, this.prefix = n, this.value = o, this.suffix = c, this.modifier = l;
+  }
+  hasCustomName() {
+    return this.name !== "" && typeof this.name != "number";
+  }
+}, be = /[$_\p{ID_Start}]/u, Pe = /[$_\u200C\u200D\p{ID_Continue}]/u, M = ".*";
+function Re(e, t) {
+  return /^[\x00-\x7F]*$/.test(e);
+}
+function v(e, t = false) {
+  let r = [], n = 0;
+  for (; n < e.length; ) {
+    let o = e[n], c = function(l) {
+      if (!t)
+        throw new TypeError(l);
+      r.push({ type: "INVALID_CHAR", index: n, value: e[n++] });
+    };
+    if (o === "*") {
+      r.push({ type: "ASTERISK", index: n, value: e[n++] });
+      continue;
+    }
+    if (o === "+" || o === "?") {
+      r.push({ type: "OTHER_MODIFIER", index: n, value: e[n++] });
+      continue;
+    }
+    if (o === "\\") {
+      r.push({ type: "ESCAPED_CHAR", index: n++, value: e[n++] });
+      continue;
+    }
+    if (o === "{") {
+      r.push({ type: "OPEN", index: n, value: e[n++] });
+      continue;
+    }
+    if (o === "}") {
+      r.push({ type: "CLOSE", index: n, value: e[n++] });
+      continue;
+    }
+    if (o === ":") {
+      let l = "", s = n + 1;
+      for (; s < e.length; ) {
+        let i = e.substr(s, 1);
+        if (s === n + 1 && be.test(i) || s !== n + 1 && Pe.test(i)) {
+          l += e[s++];
+          continue;
+        }
+        break;
+      }
+      if (!l) {
+        c(`Missing parameter name at ${n}`);
+        continue;
+      }
+      r.push({ type: "NAME", index: n, value: l }), n = s;
+      continue;
+    }
+    if (o === "(") {
+      let l = 1, s = "", i = n + 1, a = false;
+      if (e[i] === "?") {
+        c(`Pattern cannot start with "?" at ${i}`);
+        continue;
+      }
+      for (; i < e.length; ) {
+        if (!Re(e[i])) {
+          c(`Invalid character '${e[i]}' at ${i}.`), a = true;
+          break;
+        }
+        if (e[i] === "\\") {
+          s += e[i++] + e[i++];
+          continue;
+        }
+        if (e[i] === ")") {
+          if (l--, l === 0) {
+            i++;
+            break;
+          }
+        } else if (e[i] === "(" && (l++, e[i + 1] !== "?")) {
+          c(`Capturing groups are not allowed at ${i}`), a = true;
+          break;
+        }
+        s += e[i++];
+      }
+      if (a)
+        continue;
+      if (l) {
+        c(`Unbalanced pattern at ${n}`);
+        continue;
+      }
+      if (!s) {
+        c(`Missing pattern at ${n}`);
+        continue;
+      }
+      r.push({ type: "REGEX", index: n, value: s }), n = i;
+      continue;
+    }
+    r.push({ type: "CHAR", index: n, value: e[n++] });
+  }
+  return r.push({ type: "END", index: n, value: "" }), r;
+}
+function D(e, t = {}) {
+  let r = v(e);
+  t.delimiter ?? (t.delimiter = "/#?"), t.prefixes ?? (t.prefixes = "./");
+  let n = `[^${S(t.delimiter)}]+?`, o = [], c = 0, l = 0, i = /* @__PURE__ */ new Set(), a = (h) => {
+    if (l < r.length && r[l].type === h)
+      return r[l++].value;
+  }, f = () => a("OTHER_MODIFIER") ?? a("ASTERISK"), d = (h) => {
+    let u = a(h);
+    if (u !== void 0)
+      return u;
+    let { type: p, index: A } = r[l];
+    throw new TypeError(`Unexpected ${p} at ${A}, expected ${h}`);
+  }, T = () => {
+    let h = "", u;
+    for (; u = a("CHAR") ?? a("ESCAPED_CHAR"); )
+      h += u;
+    return h;
+  }, Se = (h) => h, L = t.encodePart || Se, I = "", U = (h) => {
+    I += h;
+  }, $ = () => {
+    I.length && (o.push(new R(3, "", "", L(I), "", 3)), I = "");
+  }, V = (h, u, p, A, Y) => {
+    let g = 3;
+    switch (Y) {
+      case "?":
+        g = 1;
+        break;
+      case "*":
+        g = 0;
+        break;
+      case "+":
+        g = 2;
+        break;
+    }
+    if (!u && !p && g === 3) {
+      U(h);
+      return;
+    }
+    if ($(), !u && !p) {
+      if (!h)
+        return;
+      o.push(new R(3, "", "", L(h), "", g));
+      return;
+    }
+    let m;
+    p ? p === "*" ? m = M : m = p : m = n;
+    let O = 2;
+    m === n ? (O = 1, m = "") : m === M && (O = 0, m = "");
+    let P;
+    if (u ? P = u : p && (P = c++), i.has(P))
+      throw new TypeError(`Duplicate name '${P}'.`);
+    i.add(P), o.push(new R(O, P, L(h), m, L(A), g));
+  };
+  for (; l < r.length; ) {
+    let h = a("CHAR"), u = a("NAME"), p = a("REGEX");
+    if (!u && !p && (p = a("ASTERISK")), u || p) {
+      let g = h ?? "";
+      t.prefixes.indexOf(g) === -1 && (U(g), g = ""), $();
+      let m = f();
+      V(g, u, p, "", m);
+      continue;
+    }
+    let A = h ?? a("ESCAPED_CHAR");
+    if (A) {
+      U(A);
+      continue;
+    }
+    if (a("OPEN")) {
+      let g = T(), m = a("NAME"), O = a("REGEX");
+      !m && !O && (O = a("ASTERISK"));
+      let P = T();
+      d("CLOSE");
+      let xe = f();
+      V(g, m, O, P, xe);
+      continue;
+    }
+    $(), d("END");
+  }
+  return o;
+}
+function S(e) {
+  return e.replace(/([.+*?^${}()[\]|/\\])/g, "\\$1");
+}
+function X(e) {
+  return e && e.ignoreCase ? "ui" : "u";
+}
+function Z(e, t, r) {
+  return F(D(e, r), t, r);
+}
+function k(e) {
+  switch (e) {
+    case 0:
+      return "*";
+    case 1:
+      return "?";
+    case 2:
+      return "+";
+    case 3:
+      return "";
+  }
+}
+function F(e, t, r = {}) {
+  r.delimiter ?? (r.delimiter = "/#?"), r.prefixes ?? (r.prefixes = "./"), r.sensitive ?? (r.sensitive = false), r.strict ?? (r.strict = false), r.end ?? (r.end = true), r.start ?? (r.start = true), r.endsWith = "";
+  let n = r.start ? "^" : "";
+  for (let s of e) {
+    if (s.type === 3) {
+      s.modifier === 3 ? n += S(s.value) : n += `(?:${S(s.value)})${k(s.modifier)}`;
+      continue;
+    }
+    t && t.push(s.name);
+    let i = `[^${S(r.delimiter)}]+?`, a = s.value;
+    if (s.type === 1 ? a = i : s.type === 0 && (a = M), !s.prefix.length && !s.suffix.length) {
+      s.modifier === 3 || s.modifier === 1 ? n += `(${a})${k(s.modifier)}` : n += `((?:${a})${k(s.modifier)})`;
+      continue;
+    }
+    if (s.modifier === 3 || s.modifier === 1) {
+      n += `(?:${S(s.prefix)}(${a})${S(s.suffix)})`, n += k(s.modifier);
+      continue;
+    }
+    n += `(?:${S(s.prefix)}`, n += `((?:${a})(?:`, n += S(s.suffix), n += S(s.prefix), n += `(?:${a}))*)${S(s.suffix)})`, s.modifier === 0 && (n += "?");
+  }
+  let o = `[${S(r.endsWith)}]|$`, c = `[${S(r.delimiter)}]`;
+  if (r.end)
+    return r.strict || (n += `${c}?`), r.endsWith.length ? n += `(?=${o})` : n += "$", new RegExp(n, X(r));
+  r.strict || (n += `(?:${c}(?=${o}))?`);
+  let l = false;
+  if (e.length) {
+    let s = e[e.length - 1];
+    s.type === 3 && s.modifier === 3 && (l = r.delimiter.indexOf(s) > -1);
+  }
+  return l || (n += `(?=${c}|${o})`), new RegExp(n, X(r));
+}
+var x = { delimiter: "", prefixes: "", sensitive: true, strict: true }, B = { delimiter: ".", prefixes: "", sensitive: true, strict: true }, q = { delimiter: "/", prefixes: "/", sensitive: true, strict: true };
+function J(e, t) {
+  return e.length ? e[0] === "/" ? true : !t || e.length < 2 ? false : (e[0] == "\\" || e[0] == "{") && e[1] == "/" : false;
+}
+function Q(e, t) {
+  return e.startsWith(t) ? e.substring(t.length, e.length) : e;
+}
+function Ee(e, t) {
+  return e.endsWith(t) ? e.substr(0, e.length - t.length) : e;
+}
+function W(e) {
+  return !e || e.length < 2 ? false : e[0] === "[" || (e[0] === "\\" || e[0] === "{") && e[1] === "[";
+}
+var ee = ["ftp", "file", "http", "https", "ws", "wss"];
+function N(e) {
+  if (!e)
+    return true;
+  for (let t of ee)
+    if (e.test(t))
+      return true;
+  return false;
+}
+function te(e, t) {
+  if (e = Q(e, "#"), t || e === "")
+    return e;
+  let r = new URL("https://example.com");
+  return r.hash = e, r.hash ? r.hash.substring(1, r.hash.length) : "";
+}
+function re(e, t) {
+  if (e = Q(e, "?"), t || e === "")
+    return e;
+  let r = new URL("https://example.com");
+  return r.search = e, r.search ? r.search.substring(1, r.search.length) : "";
+}
+function ne(e, t) {
+  return t || e === "" ? e : W(e) ? j(e) : z(e);
+}
+function se(e, t) {
+  if (t || e === "")
+    return e;
+  let r = new URL("https://example.com");
+  return r.password = e, r.password;
+}
+function ie(e, t) {
+  if (t || e === "")
+    return e;
+  let r = new URL("https://example.com");
+  return r.username = e, r.username;
+}
+function ae(e, t, r) {
+  if (r || e === "")
+    return e;
+  if (t && !ee.includes(t))
+    return new URL(`${t}:${e}`).pathname;
+  let n = e[0] == "/";
+  return e = new URL(n ? e : "/-" + e, "https://example.com").pathname, n || (e = e.substring(2, e.length)), e;
+}
+function oe(e, t, r) {
+  return _(t) === e && (e = ""), r || e === "" ? e : K(e);
+}
+function ce(e, t) {
+  return e = Ee(e, ":"), t || e === "" ? e : y(e);
+}
+function _(e) {
+  switch (e) {
+    case "ws":
+    case "http":
+      return "80";
+    case "wws":
+    case "https":
+      return "443";
+    case "ftp":
+      return "21";
+    default:
+      return "";
+  }
+}
+function y(e) {
+  if (e === "")
+    return e;
+  if (/^[-+.A-Za-z0-9]*$/.test(e))
+    return e.toLowerCase();
+  throw new TypeError(`Invalid protocol '${e}'.`);
+}
+function le(e) {
+  if (e === "")
+    return e;
+  let t = new URL("https://example.com");
+  return t.username = e, t.username;
+}
+function fe(e) {
+  if (e === "")
+    return e;
+  let t = new URL("https://example.com");
+  return t.password = e, t.password;
+}
+function z(e) {
+  if (e === "")
+    return e;
+  if (/[\t\n\r #%/:<>?@[\]^\\|]/g.test(e))
+    throw new TypeError(`Invalid hostname '${e}'`);
+  let t = new URL("https://example.com");
+  return t.hostname = e, t.hostname;
+}
+function j(e) {
+  if (e === "")
+    return e;
+  if (/[^0-9a-fA-F[\]:]/g.test(e))
+    throw new TypeError(`Invalid IPv6 hostname '${e}'`);
+  return e.toLowerCase();
+}
+function K(e) {
+  if (e === "" || /^[0-9]*$/.test(e) && parseInt(e) <= 65535)
+    return e;
+  throw new TypeError(`Invalid port '${e}'.`);
+}
+function he(e) {
+  if (e === "")
+    return e;
+  let t = new URL("https://example.com");
+  return t.pathname = e[0] !== "/" ? "/-" + e : e, e[0] !== "/" ? t.pathname.substring(2, t.pathname.length) : t.pathname;
+}
+function ue(e) {
+  return e === "" ? e : new URL(`data:${e}`).pathname;
+}
+function de(e) {
+  if (e === "")
+    return e;
+  let t = new URL("https://example.com");
+  return t.search = e, t.search.substring(1, t.search.length);
+}
+function pe(e) {
+  if (e === "")
+    return e;
+  let t = new URL("https://example.com");
+  return t.hash = e, t.hash.substring(1, t.hash.length);
+}
+var H = (_a2 = class {
+  constructor(t) {
+    __privateAdd(this, _r);
+    __privateAdd(this, _R);
+    __privateAdd(this, _b);
+    __privateAdd(this, _u);
+    __privateAdd(this, _m);
+    __privateAdd(this, _a);
+    __privateAdd(this, _P);
+    __privateAdd(this, _E);
+    __privateAdd(this, _S);
+    __privateAdd(this, _O);
+    __privateAdd(this, _k);
+    __privateAdd(this, _x);
+    __privateAdd(this, _h);
+    __privateAdd(this, _f);
+    __privateAdd(this, _T);
+    __privateAdd(this, _A);
+    __privateAdd(this, _y);
+    __privateAdd(this, _w);
+    __privateAdd(this, _c);
+    __privateAdd(this, _C);
+    __privateAdd(this, _i, void 0);
+    __privateAdd(this, _n, []);
+    __privateAdd(this, _t, {});
+    __privateAdd(this, _e, 0);
+    __privateAdd(this, _s, 1);
+    __privateAdd(this, _l, 0);
+    __privateAdd(this, _o, 0);
+    __privateAdd(this, _d, 0);
+    __privateAdd(this, _p, 0);
+    __privateAdd(this, _g, false);
+    __privateSet(this, _i, t);
+  }
+  get result() {
+    return __privateGet(this, _t);
+  }
+  parse() {
+    for (__privateSet(this, _n, v(__privateGet(this, _i), true)); __privateGet(this, _e) < __privateGet(this, _n).length; __privateSet(this, _e, __privateGet(this, _e) + __privateGet(this, _s))) {
+      if (__privateSet(this, _s, 1), __privateGet(this, _n)[__privateGet(this, _e)].type === "END") {
+        if (__privateGet(this, _o) === 0) {
+          __privateMethod(this, _b, b_fn).call(this), __privateMethod(this, _f, f_fn).call(this) ? __privateMethod(this, _r, r_fn).call(this, 9, 1) : __privateMethod(this, _h, h_fn).call(this) ? __privateMethod(this, _r, r_fn).call(this, 8, 1) : __privateMethod(this, _r, r_fn).call(this, 7, 0);
+          continue;
+        } else if (__privateGet(this, _o) === 2) {
+          __privateMethod(this, _u, u_fn).call(this, 5);
+          continue;
+        }
+        __privateMethod(this, _r, r_fn).call(this, 10, 0);
+        break;
+      }
+      if (__privateGet(this, _d) > 0)
+        if (__privateMethod(this, _A, A_fn).call(this))
+          __privateSet(this, _d, __privateGet(this, _d) - 1);
+        else
+          continue;
+      if (__privateMethod(this, _T, T_fn).call(this)) {
+        __privateSet(this, _d, __privateGet(this, _d) + 1);
+        continue;
+      }
+      switch (__privateGet(this, _o)) {
+        case 0:
+          __privateMethod(this, _P, P_fn).call(this) && __privateMethod(this, _u, u_fn).call(this, 1);
+          break;
+        case 1:
+          if (__privateMethod(this, _P, P_fn).call(this)) {
+            __privateMethod(this, _C, C_fn).call(this);
+            let t = 7, r = 1;
+            __privateMethod(this, _E, E_fn).call(this) ? (t = 2, r = 3) : __privateGet(this, _g) && (t = 2), __privateMethod(this, _r, r_fn).call(this, t, r);
+          }
+          break;
+        case 2:
+          __privateMethod(this, _S, S_fn).call(this) ? __privateMethod(this, _u, u_fn).call(this, 3) : (__privateMethod(this, _x, x_fn).call(this) || __privateMethod(this, _h, h_fn).call(this) || __privateMethod(this, _f, f_fn).call(this)) && __privateMethod(this, _u, u_fn).call(this, 5);
+          break;
+        case 3:
+          __privateMethod(this, _O, O_fn).call(this) ? __privateMethod(this, _r, r_fn).call(this, 4, 1) : __privateMethod(this, _S, S_fn).call(this) && __privateMethod(this, _r, r_fn).call(this, 5, 1);
+          break;
+        case 4:
+          __privateMethod(this, _S, S_fn).call(this) && __privateMethod(this, _r, r_fn).call(this, 5, 1);
+          break;
+        case 5:
+          __privateMethod(this, _y, y_fn).call(this) ? __privateSet(this, _p, __privateGet(this, _p) + 1) : __privateMethod(this, _w, w_fn).call(this) && __privateSet(this, _p, __privateGet(this, _p) - 1), __privateMethod(this, _k, k_fn).call(this) && !__privateGet(this, _p) ? __privateMethod(this, _r, r_fn).call(this, 6, 1) : __privateMethod(this, _x, x_fn).call(this) ? __privateMethod(this, _r, r_fn).call(this, 7, 0) : __privateMethod(this, _h, h_fn).call(this) ? __privateMethod(this, _r, r_fn).call(this, 8, 1) : __privateMethod(this, _f, f_fn).call(this) && __privateMethod(this, _r, r_fn).call(this, 9, 1);
+          break;
+        case 6:
+          __privateMethod(this, _x, x_fn).call(this) ? __privateMethod(this, _r, r_fn).call(this, 7, 0) : __privateMethod(this, _h, h_fn).call(this) ? __privateMethod(this, _r, r_fn).call(this, 8, 1) : __privateMethod(this, _f, f_fn).call(this) && __privateMethod(this, _r, r_fn).call(this, 9, 1);
+          break;
+        case 7:
+          __privateMethod(this, _h, h_fn).call(this) ? __privateMethod(this, _r, r_fn).call(this, 8, 1) : __privateMethod(this, _f, f_fn).call(this) && __privateMethod(this, _r, r_fn).call(this, 9, 1);
+          break;
+        case 8:
+          __privateMethod(this, _f, f_fn).call(this) && __privateMethod(this, _r, r_fn).call(this, 9, 1);
+          break;
+      }
+    }
+    __privateGet(this, _t).hostname !== void 0 && __privateGet(this, _t).port === void 0 && (__privateGet(this, _t).port = "");
+  }
+}, _i = new WeakMap(), _n = new WeakMap(), _t = new WeakMap(), _e = new WeakMap(), _s = new WeakMap(), _l = new WeakMap(), _o = new WeakMap(), _d = new WeakMap(), _p = new WeakMap(), _g = new WeakMap(), _r = new WeakSet(), r_fn = function(t, r) {
+  var _a3, _b3, _c2;
+  switch (__privateGet(this, _o)) {
+    case 0:
+      break;
+    case 1:
+      __privateGet(this, _t).protocol = __privateMethod(this, _c, c_fn).call(this);
+      break;
+    case 2:
+      break;
+    case 3:
+      __privateGet(this, _t).username = __privateMethod(this, _c, c_fn).call(this);
+      break;
+    case 4:
+      __privateGet(this, _t).password = __privateMethod(this, _c, c_fn).call(this);
+      break;
+    case 5:
+      __privateGet(this, _t).hostname = __privateMethod(this, _c, c_fn).call(this);
+      break;
+    case 6:
+      __privateGet(this, _t).port = __privateMethod(this, _c, c_fn).call(this);
+      break;
+    case 7:
+      __privateGet(this, _t).pathname = __privateMethod(this, _c, c_fn).call(this);
+      break;
+    case 8:
+      __privateGet(this, _t).search = __privateMethod(this, _c, c_fn).call(this);
+      break;
+    case 9:
+      __privateGet(this, _t).hash = __privateMethod(this, _c, c_fn).call(this);
+      break;
+  }
+  __privateGet(this, _o) !== 0 && t !== 10 && ([1, 2, 3, 4].includes(__privateGet(this, _o)) && [6, 7, 8, 9].includes(t) && ((_a3 = __privateGet(this, _t)).hostname ?? (_a3.hostname = "")), [1, 2, 3, 4, 5, 6].includes(__privateGet(this, _o)) && [8, 9].includes(t) && ((_b3 = __privateGet(this, _t)).pathname ?? (_b3.pathname = __privateGet(this, _g) ? "/" : "")), [1, 2, 3, 4, 5, 6, 7].includes(__privateGet(this, _o)) && t === 9 && ((_c2 = __privateGet(this, _t)).search ?? (_c2.search = ""))), __privateMethod(this, _R, R_fn).call(this, t, r);
+}, _R = new WeakSet(), R_fn = function(t, r) {
+  __privateSet(this, _o, t), __privateSet(this, _l, __privateGet(this, _e) + r), __privateSet(this, _e, __privateGet(this, _e) + r), __privateSet(this, _s, 0);
+}, _b = new WeakSet(), b_fn = function() {
+  __privateSet(this, _e, __privateGet(this, _l)), __privateSet(this, _s, 0);
+}, _u = new WeakSet(), u_fn = function(t) {
+  __privateMethod(this, _b, b_fn).call(this), __privateSet(this, _o, t);
+}, _m = new WeakSet(), m_fn = function(t) {
+  return t < 0 && (t = __privateGet(this, _n).length - t), t < __privateGet(this, _n).length ? __privateGet(this, _n)[t] : __privateGet(this, _n)[__privateGet(this, _n).length - 1];
+}, _a = new WeakSet(), a_fn = function(t, r) {
+  let n = __privateMethod(this, _m, m_fn).call(this, t);
+  return n.value === r && (n.type === "CHAR" || n.type === "ESCAPED_CHAR" || n.type === "INVALID_CHAR");
+}, _P = new WeakSet(), P_fn = function() {
+  return __privateMethod(this, _a, a_fn).call(this, __privateGet(this, _e), ":");
+}, _E = new WeakSet(), E_fn = function() {
+  return __privateMethod(this, _a, a_fn).call(this, __privateGet(this, _e) + 1, "/") && __privateMethod(this, _a, a_fn).call(this, __privateGet(this, _e) + 2, "/");
+}, _S = new WeakSet(), S_fn = function() {
+  return __privateMethod(this, _a, a_fn).call(this, __privateGet(this, _e), "@");
+}, _O = new WeakSet(), O_fn = function() {
+  return __privateMethod(this, _a, a_fn).call(this, __privateGet(this, _e), ":");
+}, _k = new WeakSet(), k_fn = function() {
+  return __privateMethod(this, _a, a_fn).call(this, __privateGet(this, _e), ":");
+}, _x = new WeakSet(), x_fn = function() {
+  return __privateMethod(this, _a, a_fn).call(this, __privateGet(this, _e), "/");
+}, _h = new WeakSet(), h_fn = function() {
+  if (__privateMethod(this, _a, a_fn).call(this, __privateGet(this, _e), "?"))
+    return true;
+  if (__privateGet(this, _n)[__privateGet(this, _e)].value !== "?")
+    return false;
+  let t = __privateMethod(this, _m, m_fn).call(this, __privateGet(this, _e) - 1);
+  return t.type !== "NAME" && t.type !== "REGEX" && t.type !== "CLOSE" && t.type !== "ASTERISK";
+}, _f = new WeakSet(), f_fn = function() {
+  return __privateMethod(this, _a, a_fn).call(this, __privateGet(this, _e), "#");
+}, _T = new WeakSet(), T_fn = function() {
+  return __privateGet(this, _n)[__privateGet(this, _e)].type == "OPEN";
+}, _A = new WeakSet(), A_fn = function() {
+  return __privateGet(this, _n)[__privateGet(this, _e)].type == "CLOSE";
+}, _y = new WeakSet(), y_fn = function() {
+  return __privateMethod(this, _a, a_fn).call(this, __privateGet(this, _e), "[");
+}, _w = new WeakSet(), w_fn = function() {
+  return __privateMethod(this, _a, a_fn).call(this, __privateGet(this, _e), "]");
+}, _c = new WeakSet(), c_fn = function() {
+  let t = __privateGet(this, _n)[__privateGet(this, _e)], r = __privateMethod(this, _m, m_fn).call(this, __privateGet(this, _l)).index;
+  return __privateGet(this, _i).substring(r, t.index);
+}, _C = new WeakSet(), C_fn = function() {
+  let t = {};
+  Object.assign(t, x), t.encodePart = y;
+  let r = Z(__privateMethod(this, _c, c_fn).call(this), void 0, t);
+  __privateSet(this, _g, N(r));
+}, _a2);
+var G = ["protocol", "username", "password", "hostname", "port", "pathname", "search", "hash"], E = "*";
+function ge(e, t) {
+  if (typeof e != "string")
+    throw new TypeError("parameter 1 is not of type 'string'.");
+  let r = new URL(e, t);
+  return { protocol: r.protocol.substring(0, r.protocol.length - 1), username: r.username, password: r.password, hostname: r.hostname, port: r.port, pathname: r.pathname, search: r.search !== "" ? r.search.substring(1, r.search.length) : void 0, hash: r.hash !== "" ? r.hash.substring(1, r.hash.length) : void 0 };
+}
+function b(e, t) {
+  return t ? C(e) : e;
+}
+function w(e, t, r) {
+  let n;
+  if (typeof t.baseURL == "string")
+    try {
+      n = new URL(t.baseURL), t.protocol === void 0 && (e.protocol = b(n.protocol.substring(0, n.protocol.length - 1), r)), !r && t.protocol === void 0 && t.hostname === void 0 && t.port === void 0 && t.username === void 0 && (e.username = b(n.username, r)), !r && t.protocol === void 0 && t.hostname === void 0 && t.port === void 0 && t.username === void 0 && t.password === void 0 && (e.password = b(n.password, r)), t.protocol === void 0 && t.hostname === void 0 && (e.hostname = b(n.hostname, r)), t.protocol === void 0 && t.hostname === void 0 && t.port === void 0 && (e.port = b(n.port, r)), t.protocol === void 0 && t.hostname === void 0 && t.port === void 0 && t.pathname === void 0 && (e.pathname = b(n.pathname, r)), t.protocol === void 0 && t.hostname === void 0 && t.port === void 0 && t.pathname === void 0 && t.search === void 0 && (e.search = b(n.search.substring(1, n.search.length), r)), t.protocol === void 0 && t.hostname === void 0 && t.port === void 0 && t.pathname === void 0 && t.search === void 0 && t.hash === void 0 && (e.hash = b(n.hash.substring(1, n.hash.length), r));
+    } catch {
+      throw new TypeError(`invalid baseURL '${t.baseURL}'.`);
+    }
+  if (typeof t.protocol == "string" && (e.protocol = ce(t.protocol, r)), typeof t.username == "string" && (e.username = ie(t.username, r)), typeof t.password == "string" && (e.password = se(t.password, r)), typeof t.hostname == "string" && (e.hostname = ne(t.hostname, r)), typeof t.port == "string" && (e.port = oe(t.port, e.protocol, r)), typeof t.pathname == "string") {
+    if (e.pathname = t.pathname, n && !J(e.pathname, r)) {
+      let o = n.pathname.lastIndexOf("/");
+      o >= 0 && (e.pathname = b(n.pathname.substring(0, o + 1), r) + e.pathname);
+    }
+    e.pathname = ae(e.pathname, e.protocol, r);
+  }
+  return typeof t.search == "string" && (e.search = re(t.search, r)), typeof t.hash == "string" && (e.hash = te(t.hash, r)), e;
+}
+function C(e) {
+  return e.replace(/([+*?:{}()\\])/g, "\\$1");
+}
+function Oe(e) {
+  return e.replace(/([.+*?^${}()[\]|/\\])/g, "\\$1");
+}
+function ke(e, t) {
+  t.delimiter ?? (t.delimiter = "/#?"), t.prefixes ?? (t.prefixes = "./"), t.sensitive ?? (t.sensitive = false), t.strict ?? (t.strict = false), t.end ?? (t.end = true), t.start ?? (t.start = true), t.endsWith = "";
+  let r = ".*", n = `[^${Oe(t.delimiter)}]+?`, o = /[$_\u200C\u200D\p{ID_Continue}]/u, c = "";
+  for (let l = 0; l < e.length; ++l) {
+    let s = e[l];
+    if (s.type === 3) {
+      if (s.modifier === 3) {
+        c += C(s.value);
+        continue;
+      }
+      c += `{${C(s.value)}}${k(s.modifier)}`;
+      continue;
+    }
+    let i = s.hasCustomName(), a = !!s.suffix.length || !!s.prefix.length && (s.prefix.length !== 1 || !t.prefixes.includes(s.prefix)), f = l > 0 ? e[l - 1] : null, d = l < e.length - 1 ? e[l + 1] : null;
+    if (!a && i && s.type === 1 && s.modifier === 3 && d && !d.prefix.length && !d.suffix.length)
+      if (d.type === 3) {
+        let T = d.value.length > 0 ? d.value[0] : "";
+        a = o.test(T);
+      } else
+        a = !d.hasCustomName();
+    if (!a && !s.prefix.length && f && f.type === 3) {
+      let T = f.value[f.value.length - 1];
+      a = t.prefixes.includes(T);
+    }
+    a && (c += "{"), c += C(s.prefix), i && (c += `:${s.name}`), s.type === 2 ? c += `(${s.value})` : s.type === 1 ? i || (c += `(${n})`) : s.type === 0 && (!i && (!f || f.type === 3 || f.modifier !== 3 || a || s.prefix !== "") ? c += "*" : c += `(${r})`), s.type === 1 && i && s.suffix.length && o.test(s.suffix[0]) && (c += "\\"), c += C(s.suffix), a && (c += "}"), s.modifier !== 3 && (c += k(s.modifier));
+  }
+  return c;
+}
+var me = (_b2 = class {
+  constructor(t = {}, r, n) {
+    __privateAdd(this, _i2, void 0);
+    __privateAdd(this, _n2, {});
+    __privateAdd(this, _t2, {});
+    __privateAdd(this, _e2, {});
+    __privateAdd(this, _s2, {});
+    __privateAdd(this, _l2, false);
+    try {
+      let o;
+      if (typeof r == "string" ? o = r : n = r, typeof t == "string") {
+        let i = new H(t);
+        if (i.parse(), t = i.result, o === void 0 && typeof t.protocol != "string")
+          throw new TypeError("A base URL must be provided for a relative constructor string.");
+        t.baseURL = o;
+      } else {
+        if (!t || typeof t != "object")
+          throw new TypeError("parameter 1 is not of type 'string' and cannot convert to dictionary.");
+        if (o)
+          throw new TypeError("parameter 1 is not of type 'string'.");
+      }
+      typeof n > "u" && (n = { ignoreCase: false });
+      let c = { ignoreCase: n.ignoreCase === true }, l = { pathname: E, protocol: E, username: E, password: E, hostname: E, port: E, search: E, hash: E };
+      __privateSet(this, _i2, w(l, t, true)), _(__privateGet(this, _i2).protocol) === __privateGet(this, _i2).port && (__privateGet(this, _i2).port = "");
+      let s;
+      for (s of G) {
+        if (!(s in __privateGet(this, _i2)))
+          continue;
+        let i = {}, a = __privateGet(this, _i2)[s];
+        switch (__privateGet(this, _t2)[s] = [], s) {
+          case "protocol":
+            Object.assign(i, x), i.encodePart = y;
+            break;
+          case "username":
+            Object.assign(i, x), i.encodePart = le;
+            break;
+          case "password":
+            Object.assign(i, x), i.encodePart = fe;
+            break;
+          case "hostname":
+            Object.assign(i, B), W(a) ? i.encodePart = j : i.encodePart = z;
+            break;
+          case "port":
+            Object.assign(i, x), i.encodePart = K;
+            break;
+          case "pathname":
+            N(__privateGet(this, _n2).protocol) ? (Object.assign(i, q, c), i.encodePart = he) : (Object.assign(i, x, c), i.encodePart = ue);
+            break;
+          case "search":
+            Object.assign(i, x, c), i.encodePart = de;
+            break;
+          case "hash":
+            Object.assign(i, x, c), i.encodePart = pe;
+            break;
+        }
+        try {
+          __privateGet(this, _s2)[s] = D(a, i), __privateGet(this, _n2)[s] = F(__privateGet(this, _s2)[s], __privateGet(this, _t2)[s], i), __privateGet(this, _e2)[s] = ke(__privateGet(this, _s2)[s], i), __privateSet(this, _l2, __privateGet(this, _l2) || __privateGet(this, _s2)[s].some((f) => f.type === 2));
+        } catch {
+          throw new TypeError(`invalid ${s} pattern '${__privateGet(this, _i2)[s]}'.`);
+        }
+      }
+    } catch (o) {
+      throw new TypeError(`Failed to construct 'URLPattern': ${o.message}`);
+    }
+  }
+  test(t = {}, r) {
+    let n = { pathname: "", protocol: "", username: "", password: "", hostname: "", port: "", search: "", hash: "" };
+    if (typeof t != "string" && r)
+      throw new TypeError("parameter 1 is not of type 'string'.");
+    if (typeof t > "u")
+      return false;
+    try {
+      typeof t == "object" ? n = w(n, t, false) : n = w(n, ge(t, r), false);
+    } catch {
+      return false;
+    }
+    let o;
+    for (o of G)
+      if (!__privateGet(this, _n2)[o].exec(n[o]))
+        return false;
+    return true;
+  }
+  exec(t = {}, r) {
+    let n = { pathname: "", protocol: "", username: "", password: "", hostname: "", port: "", search: "", hash: "" };
+    if (typeof t != "string" && r)
+      throw new TypeError("parameter 1 is not of type 'string'.");
+    if (typeof t > "u")
+      return;
+    try {
+      typeof t == "object" ? n = w(n, t, false) : n = w(n, ge(t, r), false);
+    } catch {
+      return null;
+    }
+    let o = {};
+    r ? o.inputs = [t, r] : o.inputs = [t];
+    let c;
+    for (c of G) {
+      let l = __privateGet(this, _n2)[c].exec(n[c]);
+      if (!l)
+        return null;
+      let s = {};
+      for (let [i, a] of __privateGet(this, _t2)[c].entries())
+        if (typeof a == "string" || typeof a == "number") {
+          let f = l[i + 1];
+          s[a] = f;
+        }
+      o[c] = { input: n[c] ?? "", groups: s };
+    }
+    return o;
+  }
+  static compareComponent(t, r, n) {
+    let o = (i, a) => {
+      for (let f of ["type", "modifier", "prefix", "value", "suffix"]) {
+        if (i[f] < a[f])
+          return -1;
+        if (i[f] === a[f])
+          continue;
+        return 1;
+      }
+      return 0;
+    }, c = new R(3, "", "", "", "", 3), l = new R(0, "", "", "", "", 3), s = (i, a) => {
+      let f = 0;
+      for (; f < Math.min(i.length, a.length); ++f) {
+        let d = o(i[f], a[f]);
+        if (d)
+          return d;
+      }
+      return i.length === a.length ? 0 : o(i[f] ?? c, a[f] ?? c);
+    };
+    return !__privateGet(r, _e2)[t] && !__privateGet(n, _e2)[t] ? 0 : __privateGet(r, _e2)[t] && !__privateGet(n, _e2)[t] ? s(__privateGet(r, _s2)[t], [l]) : !__privateGet(r, _e2)[t] && __privateGet(n, _e2)[t] ? s([l], __privateGet(n, _s2)[t]) : s(__privateGet(r, _s2)[t], __privateGet(n, _s2)[t]);
+  }
+  get protocol() {
+    return __privateGet(this, _e2).protocol;
+  }
+  get username() {
+    return __privateGet(this, _e2).username;
+  }
+  get password() {
+    return __privateGet(this, _e2).password;
+  }
+  get hostname() {
+    return __privateGet(this, _e2).hostname;
+  }
+  get port() {
+    return __privateGet(this, _e2).port;
+  }
+  get pathname() {
+    return __privateGet(this, _e2).pathname;
+  }
+  get search() {
+    return __privateGet(this, _e2).search;
+  }
+  get hash() {
+    return __privateGet(this, _e2).hash;
+  }
+  get hasRegExpGroups() {
+    return __privateGet(this, _l2);
+  }
+}, _i2 = new WeakMap(), _n2 = new WeakMap(), _t2 = new WeakMap(), _e2 = new WeakMap(), _s2 = new WeakMap(), _l2 = new WeakMap(), _b2);
+if (!globalThis.URLPattern) {
+  globalThis.URLPattern = me;
+}
+const ClientRouterContext = createContext(
+  {}
+);
+const ClientRouterProvider = (props) => {
+  const {
+    children,
+    pathname,
+    currentPath,
+    is404,
+    routeManifest,
+    pageData,
+    params
+  } = props;
+  const [parameters, setParameters] = useState(params);
+  const pageDataRef = useRef(pageData);
+  const scrollHistoryRef = useRef(/* @__PURE__ */ new Map());
+  const initalViewEntries = is404 ? ["404"] : routeManifest[pathname] ?? ["404"];
+  const viewEntriesSubject = useRef(new Subject(initalViewEntries));
+  const locationSubject = useRef(
+    new Subject({
+      hash: "",
+      pathname: currentPath,
+      search: "",
+      state: {},
+      key: ""
+    })
+  );
+  const [history] = useState(() => {
+    let history2 = null;
+    if (typeof window !== "undefined") {
+      history2 = createBrowserHistory();
+    }
+    return history2;
+  });
+  const handleScroll = () => {
+    scrollHistoryRef.current.set(
+      locationSubject.current.getValue().pathname,
+      window.scrollY
+    );
+  };
+  useEffect(() => {
+    history == null ? void 0 : history.listen(({ location }) => {
+      locationSubject.current.next(structuredClone(location));
+      viewEntriesSubject.current.next(
+        (() => {
+          var _a3, _b3;
+          if (((_a3 = location.state) == null ? void 0 : _a3.status) === 404) {
+            return ["404"];
+          }
+          for (const [route, views] of Object.entries(routeManifest)) {
+            const urlPattern = new me({ pathname: route });
+            if (urlPattern.test({ pathname: location.pathname })) {
+              setParameters(
+                (_b3 = urlPattern.exec({ pathname: location.pathname })) == null ? void 0 : _b3.pathname.groups
+              );
+              return views;
+            }
+          }
+          return [];
+        })()
+      );
+    });
+    window.addEventListener("scrollend", handleScroll);
+    return () => {
+      window.removeEventListener("scroll", handleScroll);
+    };
+  }, []);
+  const updatePageData = (newPageData) => {
+    var _a3;
+    const [key, value] = Object.entries(newPageData)[0];
+    if (!((_a3 = pageDataRef.current) == null ? void 0 : _a3[key])) {
+      pageDataRef.current[key] = {};
+    }
+    pageDataRef.current[key] = value;
+  };
+  const getPageData = (key) => {
+    return pageDataRef.current[locationSubject.current.getValue().pathname][key];
+  };
+  return /* @__PURE__ */ jsx(
+    ClientRouterContext.Provider,
+    {
+      value: {
+        history,
+        params: parameters,
+        locationSubject: locationSubject.current,
+        getScrollPosition: (path) => {
+          return scrollHistoryRef.current.get(path) || 0;
+        },
+        viewEntriesSubject: viewEntriesSubject.current,
+        updatePageData,
+        getPageData
+      },
+      children
+    }
+  );
+};
+function useLocationChange(cb) {
+  const { locationSubject } = useContext(ClientRouterContext);
+  useEffect(() => {
+    cb(locationSubject.getValue());
+    return locationSubject.subscribe(cb);
+  }, []);
+}
+function useLocation() {
+  const { locationSubject } = useContext(ClientRouterContext);
+  const [location, setLocation] = useState(locationSubject.getValue());
+  useLocationChange((newLocation) => {
+    setLocation(newLocation);
+  });
+  return location;
+}
+function useParams() {
+  const { params } = useContext(ClientRouterContext);
+  return params;
+}
+function useRouter() {
+  const { updatePageData, history } = useContext(ClientRouterContext);
+  return {
+    push: async (to, state) => {
+      var _a3;
+      let path = "";
+      if (typeof to === "string") {
+        path = `${to}?json=true`;
+      } else {
+        const { hash, pathname, search } = to;
+        const urlSearchParams = new URLSearchParams(search);
+        urlSearchParams.set("json", "true");
+        path = `${pathname}${urlSearchParams.toString()}${hash}`;
+      }
+      const res = await fetch(path);
+      if (res.ok) {
+        const { data } = await res.json();
+        const is404 = ((_a3 = Object.values(data[to])[0]) == null ? void 0 : _a3.status) === 404;
+        updatePageData(data);
+        history == null ? void 0 : history.push(to, is404 ? { status: 404 } : state);
+        window.scrollTo(0, 0);
+      }
+    }
+  };
+}
+const Link = (props) => {
+  const { href, onClick, ...rest } = props;
+  const { push } = useRouter();
+  let path = "";
+  if (typeof href === "string") {
+    path = `${href}`;
+  } else {
+    const { hash, pathname, search } = href;
+    const urlSearchParams = new URLSearchParams(search);
+    path = `${pathname}${urlSearchParams.toString()}${hash}`;
+  }
+  return /* @__PURE__ */ jsx(
+    "a",
+    {
+      href: path,
+      onClick: (e) => {
+        e.preventDefault();
+        onClick == null ? void 0 : onClick(e);
+        startTransition(() => {
+          push(href);
+        });
+      },
+      ...rest
+    }
+  );
+};
+const ComponentsContext = createContext({ components: {} });
+const Route = (props) => {
+  const { componentPath } = props;
+  const { components } = useContext(ComponentsContext);
+  const { viewEntriesSubject, getPageData, history } = useContext(ClientRouterContext);
+  const [render, setRender] = useState(
+    viewEntriesSubject.getValue().includes(componentPath)
+  );
+  const [data, setData] = useState(getPageData(componentPath));
+  useEffect(() => {
+    return viewEntriesSubject.subscribe((viewEntries) => {
+      setRender(viewEntries.includes(componentPath));
+    });
+  }, [componentPath]);
+  useEffect(() => {
+    return history == null ? void 0 : history.listen(() => {
+      setData(getPageData(componentPath));
+    });
+  }, []);
+  if (!render)
+    return null;
+  const Component = components == null ? void 0 : components[`./views/${componentPath}.tsx`];
+  return /* @__PURE__ */ jsx(Component, { ...data, children: props.children });
+};
+const Routes = (props) => {
+  const { componentTree } = props;
+  return /* @__PURE__ */ jsx(Fragment, { children: componentTree.map((node, i) => {
+    if (typeof node === "undefined") {
+      return null;
+    }
+    if (typeof node === "string") {
+      return /* @__PURE__ */ jsxs(Suspense, { children: [
+        /* @__PURE__ */ jsx(Route, { componentPath: node }, node),
+        ";"
+      ] });
+    }
+    if (Array.isArray(node)) {
+      const [path, subtree2] = node;
+      return /* @__PURE__ */ jsx(Suspense, { children: /* @__PURE__ */ jsx(Route, { componentPath: path, children: /* @__PURE__ */ jsx(Routes, { componentTree: subtree2 }) }, i) }, i);
+    }
+    const [[first, subtree]] = Object.entries(node);
+    return /* @__PURE__ */ jsx(Route, { componentPath: String(first), children: /* @__PURE__ */ jsx(Routes, { componentTree: subtree }) }, i);
+  }) });
+};
+const ClientRouter = (props) => {
+  const { routeManifest, router, componentTree, pageData } = useContext(ServerDataContext);
+  const components = Object.entries(props.components).reduce(
+    (acc, [path, importer]) => {
+      return {
+        ...acc,
+        [path]: lazy(
+          importer
+        )
+      };
+    },
+    {}
+  );
+  const RootLayout = components["./views/RootLayout.tsx"];
+  return /* @__PURE__ */ jsx(
+    ClientRouterProvider,
+    {
+      params: router.params,
+      pageData,
+      is404: router.is404,
+      pathname: router.pathname,
+      currentPath: router.currentPath,
+      routeManifest,
+      children: /* @__PURE__ */ jsx(ComponentsContext.Provider, { value: { components }, children: /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx("div", { children: "Loading..." }), children: /* @__PURE__ */ jsx(RootLayout, { children: /* @__PURE__ */ jsx(Routes, { componentTree }) }) }) })
+    }
+  );
+};
+const Main = (props) => {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(Fragment, {}),
+    /* @__PURE__ */ jsx(ServerDataProvider, { children: /* @__PURE__ */ jsx(ClientRouter, { components: props.components }) })
+  ] });
+};
+const Root = (props) => {
+  const { title, meta = [], link = [] } = props.head;
+  return /* @__PURE__ */ jsxs("html", { children: [
+    /* @__PURE__ */ jsxs("head", { children: [
+      props.styles.map((style) => {
+        return /* @__PURE__ */ jsx("link", { rel: "stylesheet", href: `/${style}` }, style);
+      }),
+      /* @__PURE__ */ jsx("title", { children: title }),
+      meta.map((meta2, i) => {
+        return /* @__PURE__ */ jsx("meta", { ...meta2 }, i);
+      }),
+      link.map((link2, i) => {
+        return /* @__PURE__ */ jsx("link", { ...link2 }, i);
+      })
+    ] }),
+    /* @__PURE__ */ jsx("body", { children: /* @__PURE__ */ jsx("div", { id: "root", children: /* @__PURE__ */ jsx(ServerDataProvider, { value: props.data, children: /* @__PURE__ */ jsx(ClientRouter, { components: globalThis.components }) }) }) })
+  ] });
+};
+function useUser() {
+  const { auth } = useContext(ServerDataContext);
+  const [user, setUser] = useState((auth == null ? void 0 : auth.user) ?? {});
+  useEffect(() => {
+    if (auth == null ? void 0 : auth.user) {
+      setUser(auth == null ? void 0 : auth.user);
+    }
+  }, [auth == null ? void 0 : auth.user]);
+  return user;
+}
+function useQuery(url) {
+  const [data, setData] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  useEffect(() => {
+  }, [url]);
+  return { data, loading, error };
+}
+function useMutation(url, options = { method: "POST" }) {
+  const { method } = options;
+  const [isPending, setIsPending] = useState(false);
+  const [data, setData] = useState(null);
+  return {
+    data,
+    isPending,
+    trigger: async (args) => {
+      setIsPending(true);
+      const response = await fetch(`/api${url}`, {
+        method,
+        headers: {
+          "Content-Type": "application/json"
+        },
+        ...args ? { body: JSON.stringify(args) } : {}
+      });
+      const data2 = await response.json();
+      setData(data2);
+      setIsPending(false);
+      return data2;
+    }
+  };
+}
+class InputSubject {
+  constructor(initialValue, type, autoFocus = false, validateFn) {
+    __publicField(this, "type");
+    __publicField(this, "state", {
+      isDirty: false,
+      value: null,
+      error: null,
+      isFocused: false,
+      isTouched: false,
+      isInvalid: false
+    });
+    __publicField(this, "subscribers", /* @__PURE__ */ new Set());
+    __publicField(this, "validateFn");
+    __publicField(this, "subscribe", (fn) => {
+      this.subscribers.add(fn);
+      return () => {
+        this.subscribers.delete(fn);
+      };
+    });
+    __publicField(this, "getState", () => {
+      return this.state;
+    });
+    __publicField(this, "next", (state) => {
+      this.state = {
+        ...this.state,
+        ...state,
+        isInvalid: !!state.error
+      };
+      this.subscribers.forEach((subscriber) => {
+        subscriber(this.state);
+      });
+    });
+    this.state.isFocused = autoFocus;
+    this.state.value = initialValue;
+    this.validateFn = validateFn ?? (() => null);
+    this.type = type;
+  }
+}
+const FormContext = createContext({});
+const inputTypeInitialValueMap = {
+  text: "",
+  number: 0,
+  checkbox: false,
+  email: "",
+  password: ""
+};
+function Form(props) {
+  const { onSubmit, schema, ...rest } = props;
+  const inputSubjectsRef = useRef(/* @__PURE__ */ new Map());
+  const getInputValueSubject = (props2) => {
+    if (!inputSubjectsRef.current.has(props2.name)) {
+      const initialValue = props2.value ?? props2.defaultValue ?? (inputTypeInitialValueMap == null ? void 0 : inputTypeInitialValueMap[props2.type]) ?? "";
+      inputSubjectsRef.current.set(
+        props2.name,
+        new InputSubject(
+          initialValue,
+          props2.type ?? "text",
+          props2.autoFocus,
+          props2.validate
+        )
+      );
+    }
+    return inputSubjectsRef.current.get(props2.name);
+  };
+  const getInputValueSubjectByName = (name) => {
+    return inputSubjectsRef.current.get(name);
+  };
+  const validateSingleField = (name, value) => {
+    let values = {};
+    for (const [name2, inputSubject2] of inputSubjectsRef.current.entries()) {
+      const { value: value2 } = inputSubject2.getState();
+      values[name2] = value2;
+    }
+    values[name] = value;
+    const inputSubject = inputSubjectsRef.current.get(name);
+    if (inputSubject) {
+      const error = inputSubject.validateFn(value);
+      if (error) {
+        return error;
+      }
+      if (schema) {
+        const result = schema.safeParse(values);
+        if (!result.success) {
+          for (let schemaError of result.error.errors) {
+            if (schemaError.path[0] === name) {
+              return schemaError.message;
+            }
+          }
+        }
+      }
+    }
+    return null;
+  };
+  const beforeSubmit = () => {
+    let values = {};
+    let errors = {};
+    for (const [name, inputSubject] of inputSubjectsRef.current.entries()) {
+      const { value } = inputSubject.getState();
+      const error = inputSubject.validateFn(values[name]);
+      values[name] = value;
+      errors[name] = error;
+    }
+    if (schema) {
+      const result = schema.safeParse(values);
+      if (!result.success) {
+        result.error.errors.reverse().forEach((schemaError) => {
+          errors[String(schemaError.path[0])] = schemaError.message;
+        });
+      }
+    }
+    for (const [name, inputSubject] of inputSubjectsRef.current.entries()) {
+      const error = errors[name] ? errors[name] : null;
+      inputSubject == null ? void 0 : inputSubject.next({ error, isTouched: true });
+    }
+    return {
+      errors,
+      values
+    };
+  };
+  const reset = () => {
+    for (const [, inputSubject] of inputSubjectsRef.current.entries()) {
+      inputSubject.next({
+        error: null,
+        isDirty: false,
+        isTouched: false,
+        isInvalid: false,
+        value: (inputTypeInitialValueMap == null ? void 0 : inputTypeInitialValueMap[inputSubject.type]) ?? ""
+      });
+    }
+  };
+  return /* @__PURE__ */ jsx(
+    FormContext.Provider,
+    {
+      value: {
+        getInputValueSubject,
+        getInputValueSubjectByName,
+        validateSingleField
+      },
+      children: /* @__PURE__ */ jsx(
+        "form",
+        {
+          ...rest,
+          onSubmit: (e) => {
+            e.preventDefault();
+            const { errors, values } = beforeSubmit();
+            const hasErrors = Object.values(errors).some((error) => error);
+            if (!hasErrors) {
+              onSubmit(e, { values, reset });
+            }
+          }
+        }
+      )
+    }
+  );
+}
+const MutationContext = createContext({
+  isPending: false,
+  result: null
+});
+const Mutation = (props) => {
+  const [isPending, setIsPending] = useState(false);
+  const formRef = useRef(null);
+  const [result, setResult] = useState(null);
+  const [formError, setFormError] = useState(null);
+  const [validationErrors, setValidationErrors] = useState({});
+  const action = async (e) => {
+    e.preventDefault();
+    const formData = new FormData(formRef.current);
+    setIsPending(true);
+    setResult(null);
+    try {
+      const res = await fetch(`/api${props.url}`, {
+        method: "POST",
+        body: formData
+      });
+      const data = await res.json();
+      if (!res.ok) {
+        if ("error" in data) {
+          if (data.error.kind === "validation_error") {
+            setValidationErrors(data.error.messages);
+          }
+          if (data.error.kind === "form_error") {
+            console.log(data.error.message);
+            setFormError(data.error.message);
+          }
+        }
+      } else {
+        if (props.onSuccess) {
+          props.onSuccess(data);
+        }
+        setResult(data);
+      }
+    } catch (err) {
+      console.log(err);
+    }
+    setIsPending(false);
+  };
+  return /* @__PURE__ */ jsx(
+    MutationContext.Provider,
+    {
+      value: { isPending, result, validationErrors, formError },
+      children: /* @__PURE__ */ jsx("form", { ref: formRef, onSubmit: action, children: props.children })
+    }
+  );
+};
+function useMutationStatus() {
+  const { isPending } = useContext(MutationContext);
+  return { isPending };
+}
+const ValidationErrors = (props) => {
+  var _a3;
+  const {
+    render = (props2) => /* @__PURE__ */ jsx("div", { ...props2 }),
+    name
+  } = props;
+  const { validationErrors } = useContext(MutationContext);
+  const Comp = render;
+  if (((_a3 = validationErrors[name]) == null ? void 0 : _a3.length) > 0) {
+    return /* @__PURE__ */ jsx(Fragment, { children: validationErrors[name].map((error) => {
+      return /* @__PURE__ */ jsx(Comp, { className: props.className, children: error }, error);
+    }) });
+  }
+  return null;
+};
+const FormError = (props) => {
+  const { formError } = useContext(MutationContext);
+  if (formError) {
+    return /* @__PURE__ */ jsx("div", { ...props, children: formError });
+  }
+  return null;
+};
+export {
+  Form,
+  FormError,
+  Link,
+  Main,
+  Mutation,
+  Root,
+  ValidationErrors,
+  useLocation,
+  useMutation,
+  useMutationStatus,
+  useParams,
+  useQuery,
+  useRouter,
+  useUser
+};