@argon-router/core 0.11.1 → 1.0.0-rc.0

package/dist/index.js

@@ -1,1173 +1,1174 @@
-import { createEffect, createStore, createEvent, attach, sample, split, scopeBind, withFactory } from "effector";
-import queryString from "query-string";
-import { or, not } from "patronum";
-function createRoute(config) {
-  let asyncImport;
-  const openFx = createEffect(async (payload) => {
-    await waitForAsyncBundleFx();
-    await beforeOpenFx();
-    const parent = config.parent;
-    if (parent) {
-      await parent.internal.openFx({
-        ...payload ?? {
-          params: {}
-        },
-        navigate: false
-      });
-    }
-    return payload;
+import { createEffect as D, attach as B, createStore as $, createEvent as f, sample as i, withFactory as E, scopeBind as _, split as ee } from "effector";
+import { createAction as T, createAsyncAction as te } from "effector-action";
+import { compile as Q } from "@argon-router/paths";
+import H from "query-string";
+import { or as K, not as ne } from "patronum";
+function V(e, t) {
+  var n = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var r = Object.getOwnPropertySymbols(e);
+    t && (r = r.filter(function(a) {
+      return Object.getOwnPropertyDescriptor(e, a).enumerable;
+    })), n.push.apply(n, r);
+  }
+  return n;
+}
+function A(e) {
+  for (var t = 1; t < arguments.length; t++) {
+    var n = arguments[t] != null ? arguments[t] : {};
+    t % 2 ? V(Object(n), !0).forEach(function(r) {
+      re(e, r, n[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(n)) : V(Object(n)).forEach(function(r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(n, r));
+    });
+  }
+  return e;
+}
+function re(e, t, n) {
+  return (t = oe(t)) in e ? Object.defineProperty(e, t, { value: n, enumerable: !0, configurable: !0, writable: !0 }) : e[t] = n, e;
+}
+function oe(e) {
+  var t = ae(e, "string");
+  return typeof t == "symbol" ? t : t + "";
+}
+function ae(e, t) {
+  if (typeof e != "object" || !e) return e;
+  var n = e[Symbol.toPrimitive];
+  if (n !== void 0) {
+    var r = n.call(e, t);
+    if (typeof r != "object") return r;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (t === "string" ? String : Number)(e);
+}
+function we() {
+  var e;
+  let t = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, n;
+  const r = (e = t.beforeOpen) !== null && e !== void 0 ? e : [], a = D(async (d) => {
+    await h(), await q();
+    const k = t.parent;
+    return k && await k.internal.openFx(A(A({}, d ?? {
+      params: {}
+    }), {}, {
+      navigate: !1
+    })), d;
   }, {
     name: "openFx",
-    sid: "awhgwd"
-  });
-  const $params = createStore({}, {
+    sid: "sf5hhk"
+  }), s = D(async (d) => {
+    const k = t.parent;
+    return k && await k.internal.forceOpenParentFx(A(A({}, d ?? {
+      params: {}
+    }), {}, {
+      navigate: !1
+    })), d;
+  }, {
+    name: "forceOpenParentFx",
+    sid: "acd7wj"
+  }), g = B({
+    and: {
+      effect: a
+    },
+    or: {
+      name: "navigatedFx",
+      sid: "ci6eci"
+    }
+  }), v = $({}, {
     name: "$params",
-    sid: "-oahffx"
-  });
-  const $isOpened = createStore(false, {
+    sid: "p3bnh9"
+  }), y = $(!1, {
     name: "$isOpened",
-    sid: "-6l68oe"
-  });
-  const $isPending = openFx.pending;
-  const open = createEvent({
+    sid: "o5kkev"
+  }), p = a.pending, l = f({
     name: "open",
-    sid: "gjsrgc"
-  });
-  const close = createEvent({
+    sid: "-bhgc3p"
+  }), P = f({
     name: "close",
-    sid: "-yagmc8"
-  });
-  const opened = createEvent({
+    sid: "vypd6z"
+  }), O = f({
     name: "opened",
-    sid: "x0iwhi"
-  });
-  const openedOnServer = createEvent({
+    sid: "-uyucke"
+  }), x = f({
     name: "openedOnServer",
-    sid: "346r3u"
-  });
-  const openedOnClient = createEvent({
+    sid: "mewjoi"
+  }), o = f({
     name: "openedOnClient",
-    sid: "31q95t"
-  });
-  const navigated = createEvent({
+    sid: "63cfjt"
+  }), u = f({
     name: "navigated",
-    sid: "-t30l0x"
-  });
-  const closed = createEvent({
+    sid: "mycajg"
+  }), b = f({
     name: "closed",
-    sid: "uue4ce"
-  });
-  const waitForAsyncBundleFx = createEffect(() => asyncImport == null ? void 0 : asyncImport(), {
+    sid: "5idv7d"
+  }), h = D(() => {
+    var d;
+    return (d = n) === null || d === void 0 ? void 0 : d();
+  }, {
     name: "waitForAsyncBundleFx",
-    sid: "-nml5ho"
-  });
-  const beforeOpenFx = createEffect(async () => {
-    for (const fx of config.beforeOpen ?? []) {
-      await fx();
-    }
+    sid: "-6s0q41"
+  }), q = D(async () => {
+    for (const d of r)
+      await d();
   }, {
     name: "beforeOpenFx",
-    sid: "-vqlnbm"
-  });
-  const navigatedFx = attach({
-    and: {
-      effect: openFx
-    },
-    or: {
-      name: "navigatedFx",
-      sid: "a4yadj"
-    }
-  });
-  const defaultParams = {};
-  sample({
+    sid: "7f9gfq"
+  }), R = {};
+  return i({
     and: [{
-      clock: open,
-      target: openFx
+      clock: l,
+      target: a
     }],
     or: {
-      sid: "ynxuww"
+      sid: "-yxhjaa"
     }
-  });
-  sample({
+  }), i({
     and: [{
-      clock: navigated,
-      fn: (payload) => ({
-        navigate: false,
-        ...payload
-      }),
-      target: navigatedFx
+      clock: u,
+      fn: (d) => A({
+        navigate: !1
+      }, d),
+      target: g
     }],
     or: {
-      sid: "z28ica"
+      sid: "-yj6vuw"
     }
-  });
-  sample({
+  }), i({
     and: [{
-      clock: navigatedFx.doneData,
-      fn: (payload) => {
-        if (!payload) {
-          return defaultParams;
-        }
-        return "params" in payload ? {
-          ...payload.params
-        } : defaultParams;
+      clock: g.done,
+      fn: (d) => {
+        let {
+          params: k
+        } = d;
+        return k;
       },
-      target: $params
-    }],
-    or: {
-      sid: "z5j9wg"
-    }
-  });
-  sample({
-    and: [{
-      clock: navigatedFx.failData,
-      fn: () => defaultParams,
-      target: $params
+      target: s
     }],
     or: {
-      sid: "-z1vw16"
+      sid: "-yfw4aq"
     }
-  });
-  split({
+  }), E({
+    sid: "-y11o9z",
+    fn: () => T({
+      clock: s.doneData,
+      target: {
+        $params: v
+      },
+      fn: (d, k) => k ? d.$params("params" in k ? A({}, k.params) : R) : d.$params(R)
+    }),
+    name: "none",
+    method: "createAction"
+  }), i({
     and: [{
-      source: navigatedFx.doneData,
-      match: () => typeof window === "undefined" ? "server" : "client",
-      cases: {
-        server: openedOnServer,
-        client: openedOnClient
-      }
+      clock: g.failData,
+      fn: () => R,
+      target: v
     }],
     or: {
-      sid: "-yyl4h0"
+      sid: "-xhsvic"
     }
-  });
-  sample({
+  }), E({
+    sid: "-x2yfhl",
+    fn: () => T({
+      clock: s.doneData,
+      target: {
+        openedOnServer: x,
+        openedOnClient: o
+      },
+      fn: (d, k) => typeof window > "u" ? d.openedOnServer(k) : d.openedOnClient(k)
+    }),
+    name: "none",
+    method: "createAction"
+  }), i({
     and: [{
-      clock: [openedOnClient, openedOnServer],
-      target: opened
+      clock: [o, x],
+      target: O
     }],
     or: {
-      sid: "-yhji2t"
+      sid: "-w72d2n"
     }
-  });
-  sample({
+  }), i({
     and: [{
-      clock: close,
-      target: closed
+      clock: P,
+      target: b
     }],
     or: {
-      sid: "-y38unf"
+      sid: "-w4be3u"
     }
-  });
-  sample({
+  }), i({
     and: [{
-      clock: [opened.map(() => true), closed.map(() => false)],
-      target: $isOpened
+      clock: [O.map(() => !0), b.map(() => !1)],
+      target: y
     }],
     or: {
-      sid: "-y0hvom"
+      sid: "-ls2oed"
     }
-  });
-  return {
-    $params,
-    $isOpened,
-    $isPending,
-    open,
-    closed,
-    opened,
-    openedOnClient,
-    openedOnServer,
-    ...config,
+  }), A(A({
+    $params: v,
+    $isOpened: y,
+    $isPending: p,
+    // @ts-expect-error :((
+    open: l,
+    closed: b,
+    opened: O,
+    openedOnClient: o,
+    openedOnServer: x
+  }, t), {}, {
     internal: {
-      navigated,
-      close,
-      openFx,
-      setAsyncImport: (value) => asyncImport = value
+      navigated: u,
+      close: P,
+      openFx: a,
+      forceOpenParentFx: s,
+      setAsyncImport: (d) => n = d
     },
     "@@unitShape": () => ({
-      params: $params,
-      isPending: $isPending,
-      isOpened: $isOpened,
-      onOpen: open
+      params: v,
+      isPending: p,
+      isOpened: y,
+      // @ts-expect-error :((
+      onOpen: l
     })
-  };
+  });
 }
-function isForRouteActive(forRoutes, activeRoutes) {
-  for (const route of forRoutes) {
-    if (activeRoutes.includes(route)) {
-      return true;
-    }
+function W(e, t) {
+  var n = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var r = Object.getOwnPropertySymbols(e);
+    t && (r = r.filter(function(a) {
+      return Object.getOwnPropertyDescriptor(e, a).enumerable;
+    })), n.push.apply(n, r);
   }
-  return false;
+  return n;
+}
+function G(e) {
+  for (var t = 1; t < arguments.length; t++) {
+    var n = arguments[t] != null ? arguments[t] : {};
+    t % 2 ? W(Object(n), !0).forEach(function(r) {
+      se(e, r, n[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(n)) : W(Object(n)).forEach(function(r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(n, r));
+    });
+  }
+  return e;
+}
+function se(e, t, n) {
+  return (t = ce(t)) in e ? Object.defineProperty(e, t, { value: n, enumerable: !0, configurable: !0, writable: !0 }) : e[t] = n, e;
+}
+function ce(e) {
+  var t = ie(e, "string");
+  return typeof t == "symbol" ? t : t + "";
 }
-function trackQueryControlsFactory(_ref) {
+function ie(e, t) {
+  if (typeof e != "object" || !e) return e;
+  var n = e[Symbol.toPrimitive];
+  if (n !== void 0) {
+    var r = n.call(e, t);
+    if (typeof r != "object") return r;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (t === "string" ? String : Number)(e);
+}
+function L(e, t) {
+  for (const n of e)
+    if (t.includes(n))
+      return !0;
+  return !1;
+}
+function ue(e) {
   let {
-    $query,
-    navigate
-  } = _ref;
-  return trackQueryFactory({
-    $activeRoutes: createStore([], {
+    $query: t,
+    navigate: n
+  } = e;
+  return X({
+    $activeRoutes: $([], {
       name: "$activeRoutes",
-      sid: "ni3bf8"
+      sid: "og6k7m"
     }),
-    $query,
-    navigate
+    $query: t,
+    navigate: n
   });
 }
-function trackQueryFactory(_ref2) {
+function X(e) {
   let {
-    $activeRoutes,
-    $query,
-    navigate
-  } = _ref2;
-  return (config) => {
+    $activeRoutes: t,
+    $query: n,
+    navigate: r
+  } = e;
+  return (a) => {
     const {
-      parameters,
-      forRoutes
-    } = config;
-    const $entered = createStore(false, {
+      check: s,
+      parameters: g,
+      forRoutes: v
+    } = a, y = $(!1, {
       name: "$entered",
-      sid: "-i5493b"
-    });
-    const entered = createEvent({
+      sid: "-792y0u"
+    }), p = f({
       name: "entered",
-      sid: "9i8bun"
-    });
-    const exited = createEvent({
+      sid: "agbkn1"
+    }), l = f({
       name: "exited",
-      sid: "-p2hcsy"
-    });
-    const enter = createEvent({
+      sid: "-o4e40k"
+    }), P = f({
       name: "enter",
-      sid: "30cmky"
-    });
-    const exit = createEvent({
+      sid: "3yfvdc"
+    }), O = f({
       name: "exit",
-      sid: "-2657ec"
-    });
-    const changeEntered = createEvent({
+      sid: "-181yly"
+    }), x = f({
       name: "changeEntered",
-      sid: "-5jm7r1"
+      sid: "-4liyyn"
     });
-    sample({
+    return i({
       and: [{
-        clock: changeEntered,
-        target: $entered
+        clock: x,
+        target: y
       }],
       or: {
-        sid: "-j6nk9y"
+        sid: "-iu0amn"
       }
-    });
-    sample({
+    }), s ? i({
       and: [{
+        clock: s,
         source: {
-          activeRoutes: $activeRoutes,
-          query: $query
+          activeRoutes: t,
+          query: n
         },
-        filter: (_ref3) => {
+        filter: (o) => {
           let {
-            activeRoutes,
-            query
-          } = _ref3;
-          return (!forRoutes || isForRouteActive(forRoutes, activeRoutes)) && parameters.safeParse(query).success;
+            activeRoutes: u,
+            query: b
+          } = o;
+          return (!v || L(v, u)) && g.safeParse(b).success;
         },
-        fn: (_ref4) => {
+        fn: (o) => {
           let {
-            query
-          } = _ref4;
-          return parameters.safeParse(query).data;
+            query: u
+          } = o;
+          return g.safeParse(u).data;
         },
-        target: [entered, changeEntered.prepend(() => true)]
+        target: [p, x.prepend(() => !0)]
       }],
       or: {
-        sid: "-iscwuk"
+        sid: "-iqpj0r"
       }
-    });
-    sample({
+    }) : i({
       and: [{
         source: {
-          activeRoutes: $activeRoutes,
-          query: $query,
-          entered: $entered
+          activeRoutes: t,
+          query: n
+        },
+        filter: (o) => {
+          let {
+            activeRoutes: u,
+            query: b
+          } = o;
+          return (!v || L(v, u)) && g.safeParse(b).success;
         },
-        filter: (_ref5) => {
+        fn: (o) => {
           let {
-            activeRoutes,
-            query,
-            entered: entered2
-          } = _ref5;
-          return entered2 && !((!forRoutes || isForRouteActive(forRoutes, activeRoutes)) && parameters.safeParse(query).success);
+            query: u
+          } = o;
+          return g.safeParse(u).data;
         },
-        target: [exited.prepend(() => void 0), changeEntered.prepend(() => false)]
+        target: [p, x.prepend(() => !0)]
       }],
       or: {
-        sid: "-ibv31q"
+        sid: "-i9nwmk"
       }
-    });
-    sample({
+    }), i({
       and: [{
-        clock: enter,
-        source: $query,
-        fn: (query, payload) => {
-          return {
-            query: {
-              ...query,
-              ...payload
-            }
-          };
+        source: {
+          activeRoutes: t,
+          query: n,
+          entered: y
         },
-        target: navigate
+        filter: (o) => {
+          let {
+            activeRoutes: u,
+            query: b,
+            entered: h
+          } = o;
+          return h && !((!v || L(v, u)) && g.safeParse(b).success);
+        },
+        target: [l.prepend(() => {
+        }), x.prepend(() => !1)]
       }],
       or: {
         sid: "-hsmaa3"
       }
-    });
-    sample({
+    }), i({
       and: [{
-        clock: exit,
-        source: $query,
-        fn: (query, payload) => {
-          if (payload && payload.ignoreParams) {
-            const copy = {};
-            for (const key of payload.ignoreParams) {
-              if (query[key]) {
-                copy[key] = query[key];
-              }
-            }
+        clock: P,
+        source: n,
+        fn: (o, u) => ({
+          query: G(G({}, o), u)
+        }),
+        target: r
+      }],
+      or: {
+        sid: "-w2mjl9"
+      }
+    }), i({
+      and: [{
+        clock: O,
+        source: n,
+        fn: (o, u) => {
+          if (u && u.ignoreParams) {
+            const b = {};
+            for (const h of u.ignoreParams)
+              o[h] && (b[h] = o[h]);
             return {
-              query: copy
+              query: b
             };
           }
           return {
             query: {}
           };
         },
-        target: navigate
+        target: r
       }],
       or: {
-        sid: "-whgzm0"
-      }
-    });
-    return {
-      enter,
-      entered,
-      exited,
-      exit
-    };
-  };
-}
-function prepareParser(tokens) {
-  return (input) => {
-    const rawTokens = input.split("/").map((part) => part.trim()).filter((part) => part !== "");
-    let params = null;
-    function setKey(key, value) {
-      if (!params) {
-        params = {};
+        sid: "-vlkx72"
       }
-      params[key] = value;
-    }
-    if (tokens.length === 0) {
-      return rawTokens.length === 0 ? {
-        path: input,
-        params: null
-      } : null;
-    }
-    for (let i = 0; i < tokens.length; i++) {
-      const token = tokens[i];
-      switch (token.type) {
-        case "const": {
-          if (token.name !== rawTokens.shift()) {
-            return null;
-          }
-          continue;
-        }
-        case "parameter": {
-          const {
-            arrayProps,
-            genericProps,
-            required
-          } = token.payload;
-          if (arrayProps) {
-            const array = [];
-            let rawToken2;
-            while (true) {
-              rawToken2 = rawTokens.shift();
-              if (!rawToken2) {
-                break;
-              }
-              switch (genericProps == null ? void 0 : genericProps.type) {
-                case "number": {
-                  if (isNaN(+rawToken2)) {
-                    return null;
-                  }
-                  array.push(+rawToken2);
-                  break;
-                }
-                case "union": {
-                  if (!genericProps.items.includes(rawToken2)) {
-                    return null;
-                  }
-                  array.push(rawToken2);
-                  break;
-                }
-                default: {
-                  array.push(rawToken2);
-                  break;
-                }
-              }
-              if (array.length >= (arrayProps.max ?? Infinity)) {
-                break;
-              }
-            }
-            if (array.length < (arrayProps.min ?? 0)) {
-              return null;
-            }
-            if (rawTokens.length > 0 && !tokens[i + 1]) {
-              return null;
-            }
-            setKey(token.name, array);
-            break;
-          }
-          const rawToken = rawTokens.shift();
-          if (required && !rawToken) {
-            return null;
-          }
-          if (!rawToken) {
-            setKey(token.name, void 0);
-            continue;
-          }
-          switch (genericProps == null ? void 0 : genericProps.type) {
-            case "number": {
-              if (isNaN(+rawToken)) {
-                return null;
-              }
-              setKey(token.name, +rawToken);
-              break;
-            }
-            case "union": {
-              if (!genericProps.items.includes(rawToken)) {
-                return null;
-              }
-              setKey(token.name, rawToken);
-              break;
-            }
-            default: {
-              setKey(token.name, rawToken);
-              break;
-            }
-          }
-        }
-      }
-    }
-    if (rawTokens.length > 0) {
-      return null;
-    }
-    return {
-      path: input,
-      params
+    }), {
+      enter: P,
+      entered: p,
+      exited: l,
+      exit: O
     };
   };
 }
-function getTokenParameters(params) {
-  if (!params) {
-    return null;
+function J(e, t) {
+  var n = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var r = Object.getOwnPropertySymbols(e);
+    t && (r = r.filter(function(a) {
+      return Object.getOwnPropertyDescriptor(e, a).enumerable;
+    })), n.push.apply(n, r);
   }
-  const name = params[1];
-  let genericProps;
-  let arrayProps;
-  let modificator;
-  for (const parameter of params.slice(2)) {
-    if (!parameter) {
-      continue;
-    }
-    if (parameter.includes("<")) {
-      genericProps = parameter.replaceAll(/\s/g, "").replace("<", "").replace(">", "");
-      continue;
-    }
-    if (parameter.includes("{")) {
-      arrayProps = parameter.replace("{", "").replace("}", "").split(",").map((item) => parseInt(item));
-    }
-    if (["*", "?", "+"].includes(parameter)) {
-      modificator = parameter;
-      continue;
-    }
+  return n;
+}
+function N(e) {
+  for (var t = 1; t < arguments.length; t++) {
+    var n = arguments[t] != null ? arguments[t] : {};
+    t % 2 ? J(Object(n), !0).forEach(function(r) {
+      de(e, r, n[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(n)) : J(Object(n)).forEach(function(r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(n, r));
+    });
   }
-  return {
-    name,
-    genericProps,
-    arrayProps,
-    modificator
-  };
+  return e;
 }
-function prepareBuilder(tokens) {
-  return (params) => {
-    const result = [];
-    if (tokens.length === 0) {
-      return "/";
-    }
-    for (const token of tokens) {
-      switch (token.type) {
-        case "const": {
-          result.push(token.name);
-          break;
-        }
-        case "parameter": {
-          if (!params[token.name]) {
-            continue;
-          }
-          if (Array.isArray(params[token.name])) {
-            for (const param of params[token.name]) {
-              result.push(param.toString());
-            }
-          } else {
-            result.push(params[token.name].toString());
-          }
-          break;
-        }
-      }
-    }
-    return `/${result.join("/")}`;
-  };
+function de(e, t, n) {
+  return (t = le(t)) in e ? Object.defineProperty(e, t, { value: n, enumerable: !0, configurable: !0, writable: !0 }) : e[t] = n, e;
 }
-function compile(path) {
-  const tokens = [];
-  const regexp = /:(\w+)(<[\s?\w|]+>)?({\d+\,\d+})?([+*?])?/;
-  const parsedTokens = path.split("/").filter(Boolean);
-  for (let i = 0; i < parsedTokens.length; i++) {
-    const parsedToken = parsedTokens[i];
-    if (!parsedToken) {
-      continue;
-    }
-    const parameters = getTokenParameters(parsedToken.match(regexp));
-    if (!parameters) {
-      tokens.push({
-        type: "const",
-        name: parsedToken,
-        payload: void 0
-      });
-      continue;
-    }
-    const {
-      arrayProps,
-      genericProps,
-      modificator,
-      name
-    } = parameters;
-    if (!name) {
-      throw new Error(`Invalid path: "${path}". Name for argument must be provided`);
-    }
-    const token = {
-      type: "parameter",
-      name,
-      payload: {
-        required: true
-      }
-    };
-    if (genericProps && genericProps === "number") {
-      token.payload.genericProps = {
-        type: "number"
-      };
-    }
-    if (genericProps && genericProps.includes("|")) {
-      token.payload.genericProps = {
-        type: "union",
-        items: genericProps.split("|")
-      };
-    }
-    switch (modificator) {
-      case "*": {
-        token.payload.arrayProps = {};
-        break;
-      }
-      case "+": {
-        token.payload.arrayProps = {
-          min: 1
-        };
-        break;
-      }
-      case "?": {
-        token.payload.required = false;
-        break;
-      }
-    }
-    if (arrayProps) {
-      token.payload.arrayProps = {
-        ...token.payload.arrayProps,
-        min: arrayProps[0],
-        max: arrayProps[1]
-      };
-    }
-    tokens.push(token);
+function le(e) {
+  var t = pe(e, "string");
+  return typeof t == "symbol" ? t : t + "";
+}
+function pe(e, t) {
+  if (typeof e != "object" || !e) return e;
+  var n = e[Symbol.toPrimitive];
+  if (n !== void 0) {
+    var r = n.call(e, t);
+    if (typeof r != "object") return r;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
   }
-  return {
-    /**
-     * @param input Input path
-     * @returns `{ path: string; params: Params }` | `null`
-     */
-    parse: prepareParser(tokens),
-    /**
-     * @param params Route parameters
-     * @returns string
-     */
-    build: prepareBuilder(tokens)
-  };
+  return (t === "string" ? String : Number)(e);
 }
-function createRouterControls() {
-  const $history = createStore(null, {
+function fe() {
+  const e = $(null, {
     and: {
       serialize: "ignore"
     },
     name: "$history",
-    sid: "-ld7lzl"
-  });
-  const $locationState = createStore({
+    sid: "-kw5zle"
+  }), t = $({
     query: {},
     path: null
   }, {
     name: "$locationState",
-    sid: "-4u3w85"
-  });
-  const $query = $locationState.map((state) => state.query);
-  const $path = $locationState.map((state) => state.path);
-  const setHistory = createEvent({
+    sid: "-2xxend"
+  }), n = $(null, {
+    name: "$subscription",
+    sid: "27a2zr"
+  }), r = t.map((o) => o.query), a = t.map((o) => o.path), s = f({
     name: "setHistory",
-    sid: "-ormmkk"
-  });
-  const navigate = createEvent({
+    sid: "-lxcw7e"
+  }), g = f({
     name: "navigate",
-    sid: "tawqep"
-  });
-  const back = createEvent({
+    sid: "w56grv"
+  }), v = f({
     name: "back",
-    sid: "bxy8rt"
-  });
-  const forward = createEvent({
+    sid: "es7z4z"
+  }), y = f({
     name: "forward",
-    sid: "-bpmzb1"
-  });
-  const locationUpdated = createEvent({
+    sid: "12ktc8"
+  }), p = f({
     name: "locationUpdated",
-    sid: "lkzldx"
-  });
-  const navigateFx = attach({
+    sid: "yd7e16"
+  }), l = B({
     and: {
-      source: $history,
-      effect: (history, _ref) => {
+      source: e,
+      effect: (o, u) => {
         let {
-          path,
-          query,
-          replace
-        } = _ref;
-        if (!history) {
+          path: b,
+          query: h,
+          replace: q
+        } = u;
+        if (!o)
           throw new Error("history not found");
-        }
-        const payload = {
-          pathname: path,
-          search: `?${queryString.stringify(query)}`
+        const R = {
+          pathname: b,
+          search: "?".concat(H.stringify(h))
         };
-        if (replace) {
-          history.replace(payload);
-        } else {
-          history.push(payload);
-        }
+        q ? o.replace(R) : o.push(R);
       }
     },
     or: {
       name: "navigateFx",
-      sid: "-ov1xn7"
+      sid: "-m0s7a1"
     }
-  });
-  const subscribeHistoryFx = createEffect((history) => {
-    const historyLocationUpdated = scopeBind(locationUpdated);
-    historyLocationUpdated({
-      pathname: history.location.pathname,
-      query: {
-        ...queryString.parse(history.location.search)
+  }), P = E({
+    sid: "-jbr50m",
+    fn: () => te({
+      target: {
+        locationUpdated: p,
+        $subscription: n
+      },
+      source: {
+        $subscription: n
+      },
+      fn: async (o, u, b) => {
+        if (!b)
+          throw Error("Cannot initialize router controls with empty history adapter. Please provide some provider or check your code for passing of nullable value");
+        const h = await u();
+        h.subscription && h.subscription.unsubscribe(), o.locationUpdated({
+          pathname: b.location.pathname,
+          query: N({}, H.parse(b.location.search))
+        }), o.$subscription(b.listen((q) => {
+          o.locationUpdated({
+            pathname: q.pathname,
+            query: N({}, H.parse(q.search))
+          });
+        }));
       }
-    });
-    if (!history) {
-      throw new Error();
-    }
-    history.listen((_ref2) => {
-      let {
-        location
-      } = _ref2;
-      historyLocationUpdated({
-        pathname: location.pathname,
-        query: {
-          ...queryString.parse(location.search)
-        }
-      });
-    });
-  }, {
+    }),
     name: "subscribeHistoryFx",
-    sid: "-m60vds"
+    method: "createAsyncAction"
+  }), O = B({
+    and: {
+      source: e,
+      effect: (o) => {
+        if (!o)
+          throw new Error("history not found");
+        o.goBack();
+      }
+    },
+    or: {
+      name: "goBackFx",
+      sid: "k3gxue"
+    }
+  }), x = B({
+    and: {
+      source: e,
+      effect: (o) => {
+        if (!o)
+          throw new Error("history not found");
+        o.goForward();
+      }
+    },
+    or: {
+      name: "goForwardFx",
+      sid: "1m1c40"
+    }
   });
-  sample({
+  return i({
     and: [{
-      clock: setHistory,
-      target: $history
+      clock: s,
+      target: e
     }],
     or: {
-      sid: "ii4q"
+      sid: "1ycdhl"
     }
-  });
-  sample({
+  }), i({
     and: [{
-      clock: $history,
+      clock: e,
       filter: Boolean,
-      target: subscribeHistoryFx
+      target: P
     }],
     or: {
-      sid: "39h3j"
+      sid: "213cge"
     }
-  });
-  sample({
+  }), i({
     and: [{
-      clock: locationUpdated,
-      fn: (location) => ({
-        path: location.pathname,
-        query: location.query
+      clock: p,
+      fn: (o) => ({
+        path: o.pathname,
+        query: o.query
       }),
-      target: $locationState
+      target: t
     }],
     or: {
-      sid: "i3x4a"
+      sid: "2fxsh5"
     }
-  });
-  sample({
+  }), i({
     and: [{
-      clock: navigate,
-      source: $path,
-      fn: (path, payload) => ({
-        path,
-        ...payload
-      }),
-      target: navigateFx
+      clock: g,
+      source: a,
+      fn: (o, u) => N({
+        path: o
+      }, u),
+      target: l
     }],
     or: {
-      sid: "ylqx4"
+      sid: "2wfm9z"
     }
-  });
-  return {
-    $history,
-    $locationState,
-    $query,
-    $path,
-    setHistory,
-    navigate,
-    back,
-    forward,
-    locationUpdated,
-    trackQuery: trackQueryControlsFactory({
-      $query,
-      navigate
+  }), i({
+    and: [{
+      clock: v,
+      target: O
+    }],
+    or: {
+      sid: "3btuw3"
+    }
+  }), i({
+    and: [{
+      clock: y,
+      target: x
+    }],
+    or: {
+      sid: "3ektuw"
+    }
+  }), {
+    $history: e,
+    $locationState: t,
+    $query: r,
+    $path: a,
+    setHistory: s,
+    navigate: g,
+    back: v,
+    forward: y,
+    locationUpdated: p,
+    trackQuery: ue({
+      $query: r,
+      navigate: g
     })
   };
 }
-function createRouter(config) {
-  const {
-    base = "/",
-    routes
-  } = config;
+const U = {
+  route(e) {
+    return U.pathRoute(e) || U.pathlessRoute(e);
+  },
+  pathRoute(e) {
+    return typeof e == "object" && e !== null && "@@type" in e && e["@@type"] === "path-route";
+  },
+  pathlessRoute(e) {
+    return typeof e == "object" && e !== null && "@@type" in e && e["@@type"] === "pathless-route";
+  },
+  router(e) {
+    return typeof e == "object" && e !== null && "@@type" in e && e["@@type"] === "router";
+  }
+}, C = {
+  pathlessRoute(e) {
+    return "route" in e;
+  },
+  pathRoute(e) {
+    return !this.pathlessRoute(e) && !this.router(e);
+  },
+  router(e) {
+    return U.router(e);
+  }
+};
+function Oe(e) {
+  var t;
   const {
-    $path,
-    $query,
-    back,
-    forward,
-    navigate,
-    setHistory,
-    locationUpdated
-  } = createRouterControls();
-  const mappedRoutes = routes.map((route) => {
-    let internalRoute = route;
-    const path = [];
-    path.unshift(internalRoute.path);
-    while (internalRoute.parent) {
-      internalRoute = internalRoute.parent;
-      if (internalRoute.path !== "/") {
-        path.unshift(internalRoute.path);
-      }
+    base: n = "/",
+    routes: r
+  } = e, {
+    $path: a,
+    $query: s,
+    $history: g,
+    back: v,
+    forward: y,
+    navigate: p,
+    setHistory: l,
+    locationUpdated: P
+  } = (t = e.controls) !== null && t !== void 0 ? t : fe();
+  function O(c) {
+    return n === "/" ? c : c === "/" ? n : "".concat(n).concat(c);
+  }
+  const x = f({
+    name: "connectToParentRouter",
+    sid: "t0jaae"
+  });
+  let o = null;
+  const u = [];
+  function b(c) {
+    if (C.pathlessRoute(c)) {
+      const {
+        build: I,
+        parse: Z
+      } = Q(O(c.path));
+      return {
+        route: c.route,
+        path: c.path,
+        build: I,
+        parse: Z
+      };
     }
-    const joinedPath = base === "/" ? path.join("") : [base, ...path].join("");
-    const {
-      build,
-      parse
-    } = compile(joinedPath);
+    if (C.router(c))
+      return i({
+        and: [{
+          clock: l,
+          target: c.setHistory
+        }],
+        or: {
+          sid: "ez3kyw"
+        }
+      }), null;
+    let m = c;
+    const j = [];
+    for (j.unshift(m.path); m.parent && !U.pathlessRoute(m.parent); )
+      m = m.parent, m.path !== "/" && j.unshift(m.path);
+    const F = O(j.join("")), {
+      build: w,
+      parse: S
+    } = Q(F);
     return {
-      route,
-      path: joinedPath,
-      build,
-      parse
+      route: c,
+      path: F,
+      build: w,
+      parse: S
     };
-  });
-  const $activeRoutes = $path.map((path) => {
-    const result = [];
-    if (!path) {
-      return result;
-    }
+  }
+  const h = r.reduce((c, m) => {
+    const j = b(m);
+    return j && (u.push(j), c.push(j)), C.router(m) && u.push(...m.knownRoutes), c;
+  }, []), q = a.map((c) => {
+    const m = [];
+    if (!c)
+      return m;
     for (const {
-      route,
-      parse
-    } of mappedRoutes) {
-      if (parse(path)) {
-        result.push(route);
-      }
-    }
-    return result;
-  });
-  const openRoutesByPathFx = attach({
+      route: j,
+      parse: F
+    } of h)
+      F(c) && m.push(j);
+    return m;
+  }), R = B({
     and: {
       source: {
-        query: $query,
-        path: $path
+        query: s,
+        path: a
       },
-      effect: async (_ref) => {
+      effect: (c) => {
         let {
-          query,
-          path
-        } = _ref;
+          query: m,
+          path: j
+        } = c;
         for (const {
-          route,
-          parse
-        } of mappedRoutes) {
-          const matchResult = parse(path);
-          const [routeClosed, routeNavigated] = [scopeBind(route.internal.close), scopeBind(route.internal.navigated)];
-          if (!matchResult) {
-            routeClosed();
-          } else {
-            routeNavigated({
-              query,
-              params: matchResult.params
-            });
-          }
+          route: F,
+          parse: w
+        } of h) {
+          const S = w(j), [z, I] = [_(F.internal.close), _(F.internal.navigated)];
+          S ? I({
+            query: m,
+            params: S.params
+          }) : z();
         }
       }
     },
     or: {
       name: "openRoutesByPathFx",
-      sid: "-3zl7vq"
+      sid: "-bl0nuq"
     }
   });
-  for (const {
-    route,
-    build
-  } of mappedRoutes) {
-    sample({
-      and: [{
-        clock: route.internal.openFx.doneData,
-        filter: (payload) => (payload == null ? void 0 : payload.navigate) !== false,
-        fn: (payload) => {
-          return {
-            path: build(payload && "params" in payload ? payload.params : void 0),
-            query: (payload == null ? void 0 : payload.query) ?? {},
-            replace: payload == null ? void 0 : payload.replace
-          };
+  function d(c) {
+    let {
+      route: m,
+      build: j
+    } = c;
+    E({
+      sid: "t83mj3",
+      fn: () => T({
+        clock: m.internal.openFx.doneData,
+        target: {
+          navigate: p
         },
-        target: navigate
-      }],
-      or: {
-        sid: "exzzqg"
-      }
+        fn: (F, w) => {
+          var S;
+          if (w?.navigate === !1)
+            return;
+          const z = {
+            path: j(w && "params" in w ? w.params : void 0),
+            query: (S = w?.query) !== null && S !== void 0 ? S : {},
+            replace: w?.replace
+          };
+          return F.navigate(z);
+        }
+      }),
+      name: "none",
+      method: "createAction"
     });
   }
-  sample({
+  for (const c of h)
+    d(c);
+  return i({
     and: [{
-      clock: locationUpdated,
-      fn: (location) => ({
-        path: location.pathname,
-        query: location.query
+      clock: P,
+      fn: (c) => ({
+        path: c.pathname,
+        query: c.query
       }),
-      target: openRoutesByPathFx
+      target: R
     }],
     or: {
-      sid: "ficdn3"
+      sid: "ukhip5"
     }
-  });
-  return {
-    $query,
-    $path,
-    $activeRoutes,
-    back,
-    forward,
-    navigate,
-    routes,
-    setHistory,
-    mappedRoutes,
-    trackQuery: trackQueryFactory({
-      $activeRoutes,
-      $query,
-      navigate
+  }), {
+    "@@type": "router",
+    $query: s,
+    $path: a,
+    $history: g,
+    $activeRoutes: q,
+    back: v,
+    forward: y,
+    navigate: p,
+    setHistory: l,
+    ownRoutes: h,
+    knownRoutes: u,
+    internal: {
+      connectToParentRouter: x,
+      get parent() {
+        return o;
+      },
+      set parent(c) {
+        o = c;
+      },
+      base: n
+    },
+    trackQuery: X({
+      $activeRoutes: q,
+      $query: s,
+      navigate: p
     }),
+    registerRoute: (c) => {
+      const m = b(c);
+      m && (u.push(m), h.push(m), d(m)), C.router(c) && u.push(...c.knownRoutes);
+    },
     "@@unitShape": () => ({
-      query: $query,
-      path: $path,
-      activeRoutes: $activeRoutes,
-      onBack: back,
-      onForward: forward,
-      onNavigate: navigate
+      query: s,
+      path: a,
+      activeRoutes: q,
+      onBack: v,
+      onForward: y,
+      onNavigate: p
     })
   };
 }
-function createVirtualRoute() {
-  let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+function Y() {
+  let e = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
   const {
-    beforeOpen,
-    $isPending = createStore(false, {
+    $isPending: t = $(!1, {
       name: "$isPending",
-      sid: "-f18bwu"
+      sid: "-t8kzqo"
     }),
-    transformer = (payload) => payload ?? null
-  } = options;
-  const $params = createStore(null, {
+    transformer: n = (O) => O ?? null
+  } = e, r = $(null, {
     name: "$params",
-    sid: "v2ropa"
-  });
-  const $isOpened = createStore(false, {
+    sid: "gvf0vg"
+  }), a = $(!1, {
     name: "$isOpened",
-    sid: "mzzqqr"
-  });
-  const open = createEvent({
+    sid: "8sn2wx"
+  }), s = f({
     name: "open",
-    sid: "f33vnd"
-  });
-  const opened = createEvent({
+    sid: "vr7tj"
+  }), g = f({
     name: "opened",
-    sid: "-efpvez"
-  });
-  const openedOnServer = createEvent({
+    sid: "-sn2j8t"
+  }), v = f({
     name: "openedOnServer",
-    sid: "o8st20"
-  });
-  const openedOnClient = createEvent({
+    sid: "a1g586"
+  }), y = f({
     name: "openedOnClient",
-    sid: "xaagqn"
-  });
-  const close = createEvent({
+    sid: "j2xswt"
+  }), p = f({
     name: "close",
-    sid: "-20upkw"
-  });
-  const closed = createEvent({
+    sid: "-g87deq"
+  }), l = f({
     name: "closed",
-    sid: "avevxu"
-  });
-  const cancelled = createEvent({
+    sid: "-3bxrw0"
+  }), P = f({
     name: "cancelled",
-    sid: "808tq5"
+    sid: "3qu86e"
   });
-  sample({
+  return i({
     and: [{
-      clock: open,
-      target: [opened]
+      clock: s,
+      target: [g]
     }],
     or: {
-      sid: "p3r2ad"
+      sid: "on98hj"
     }
-  });
-  sample({
+  }), i({
     and: [{
-      clock: open,
-      fn: transformer,
-      target: $params
+      clock: s,
+      fn: n,
+      target: r
     }],
     or: {
-      sid: "p6i196"
+      sid: "oq07gc"
     }
-  });
-  split({
+  }), ee({
     and: [{
-      source: opened,
-      match: () => typeof window === "undefined" ? "server" : "client",
+      source: g,
+      match: () => typeof window > "u" ? "server" : "client",
       cases: {
-        server: openedOnServer,
-        client: openedOnClient
+        server: v,
+        client: y
       }
     }],
     or: {
-      sid: "plch9x"
+      sid: "p4unh3"
     }
-  });
-  sample({
+  }), i({
     and: [{
-      clock: close,
-      target: closed
+      clock: p,
+      target: l
     }],
     or: {
-      sid: "q1ub2r"
+      sid: "plch9x"
     }
-  });
-  sample({
+  }), i({
     and: [{
-      clock: [opened.map(() => true), closed.map(() => false)],
-      target: $isOpened
+      clock: [g.map(() => !0), l.map(() => !1)],
+      target: a
     }],
     or: {
-      sid: "q4la1k"
+      sid: "po3g8q"
     }
-  });
-  return {
-    $params,
-    $isOpened,
-    $isPending,
-    open,
-    opened,
-    openedOnClient,
-    openedOnServer,
-    close,
-    closed,
-    cancelled,
+  }), {
+    "@@type": "pathless-route",
+    $params: r,
+    $isOpened: a,
+    $isPending: t,
+    open: s,
+    opened: g,
+    openedOnClient: y,
+    openedOnServer: v,
+    close: p,
+    closed: l,
+    cancelled: P,
     path: "",
-    beforeOpen,
     "@@unitShape": () => ({
-      params: $params,
-      isOpened: $isOpened,
-      isPending: $isPending,
-      onOpen: open,
-      onClose: close
+      params: r,
+      isOpened: a,
+      isPending: t,
+      onOpen: s,
+      onClose: p
     })
   };
 }
-function chainRoute(props) {
+function ke(e) {
   const {
-    route,
-    beforeOpen,
-    openOn,
-    cancelOn
-  } = props;
-  let asyncImport;
-  const waitForAsyncBundleFx = createEffect(() => asyncImport == null ? void 0 : asyncImport(), {
+    route: t,
+    beforeOpen: n,
+    openOn: r,
+    cancelOn: a
+  } = e;
+  let s;
+  const g = D(() => {
+    var l;
+    return (l = s) === null || l === void 0 ? void 0 : l();
+  }, {
     name: "waitForAsyncBundleFx",
-    sid: "qdkcuo"
-  });
-  const openFx = createEffect(async (payload) => {
-    await waitForAsyncBundleFx();
-    for (const trigger of [].concat(beforeOpen)) {
-      await trigger(payload);
-    }
+    sid: "t7u37u"
+  }), v = D(async (l) => {
+    await g();
+    for (const P of [].concat(n))
+      await P(l);
   }, {
     name: "openFx",
-    sid: "-fwntqy"
+    sid: "-34g13p"
+  }), y = (l) => l ? "params" in l ? l.params : {} : {}, p = Y({
+    transformer: y
   });
-  const transformer = (payload) => {
-    if (!payload) {
-      return null;
+  return i({
+    and: [{
+      clock: t.opened,
+      target: v
+    }],
+    or: {
+      sid: "-1tngcz"
     }
-    return "params" in payload ? payload.params : null;
-  };
-  const virtualRoute = createVirtualRoute({
-    transformer
-  });
-  sample({
+  }), i({
     and: [{
-      clock: route.opened,
-      target: openFx
+      clock: t.opened,
+      fn: y,
+      target: p.$params
     }],
     or: {
-      sid: "-s9xf6p"
+      sid: "-1qwhe6"
     }
-  });
-  sample({
+  }), r && i({
     and: [{
-      clock: route.opened,
-      fn: transformer,
-      target: virtualRoute.$params
+      clock: r,
+      source: p.$params,
+      fn: (l) => ({
+        params: l
+      }),
+      target: p.open
     }],
     or: {
-      sid: "-1u78yc"
+      sid: "-1bi8qc"
     }
-  });
-  if (openOn) {
-    sample({
-      and: [{
-        clock: openOn,
-        source: virtualRoute.$params,
-        fn: (params) => params,
-        target: virtualRoute.open
-      }],
-      or: {
-        sid: "-1qcor3"
-      }
-    });
-  }
-  if (cancelOn) {
-    sample({
-      and: [{
-        clock: [route.closed].concat(cancelOn),
-        target: virtualRoute.close
-      }],
-      or: {
-        sid: "-19uuy9"
-      }
-    });
-    sample({
-      and: [{
-        clock: [].concat(cancelOn),
-        target: virtualRoute.cancelled
-      }],
-      or: {
-        sid: "-vk7iv"
-      }
-    });
-  }
-  return Object.assign(virtualRoute, {
+  }), a && (i({
+    and: [{
+      clock: [t.closed].concat(a),
+      target: p.close
+    }],
+    or: {
+      sid: "-v0exi"
+    }
+  }), i({
+    and: [{
+      clock: [].concat(a),
+      target: p.cancelled
+    }],
+    or: {
+      sid: "-s9fyp"
+    }
+  })), Object.assign(p, {
     internal: {
-      setAsyncImport: (value) => asyncImport = value
+      setAsyncImport: (l) => s = l
     }
   });
 }
-function group(routes) {
-  const virtual = createVirtualRoute({
-    $isPending: withFactory({
+function Pe(e) {
+  const t = Y({
+    $isPending: E({
       sid: "-u1putn",
-      fn: () => or(...routes.map((route) => route.$isPending)),
+      fn: () => K(...e.map((n) => n.$isPending)),
       name: "$isPending",
       method: "or"
     })
   });
-  sample({
+  return i({
     and: [{
-      clock: routes.map((route) => route.$isOpened),
-      filter: withFactory({
+      clock: e.map((n) => n.$isOpened),
+      filter: E({
         sid: "76kf3k",
-        fn: () => or(...routes.map((route) => route.$isOpened)),
+        fn: () => K(...e.map((n) => n.$isOpened)),
         name: "filter",
         method: "or"
       }),
-      fn: () => void 0,
-      target: virtual.open
+      fn: () => {
+      },
+      target: t.open
     }],
     or: {
       sid: "-xmoke0"
     }
-  });
-  sample({
+  }), i({
     and: [{
-      clock: routes.map((route) => route.$isOpened),
-      filter: withFactory({
+      clock: e.map((n) => n.$isOpened),
+      filter: E({
         sid: "ahvrux",
-        fn: () => not(withFactory({
+        fn: () => ne(E({
           sid: "xs5yb9",
-          fn: () => or(...routes.map((route) => route.$isOpened)),
+          fn: () => K(...e.map((n) => n.$isOpened)),
           name: "fn",
           method: "or"
         })),
         name: "filter",
         method: "not"
       }),
-      fn: () => void 0,
-      target: virtual.close
+      fn: () => {
+      },
+      target: t.close
     }],
     or: {
       sid: "-x7abrw"
     }
-  });
-  return virtual;
+  }), t;
+}
+function je(e) {
+  return {
+    location: e.location,
+    push: e.push.bind(e),
+    replace: e.replace.bind(e),
+    goBack: e.back.bind(e),
+    goForward: e.forward.bind(e),
+    listen: (t) => {
+      const n = e.listen((r) => {
+        let {
+          location: a
+        } = r;
+        return t(a);
+      });
+      return Object.assign(n, {
+        unsubscribe: n
+      });
+    }
+  };
+}
+function M(e) {
+  const t = new URL(decodeURIComponent(e.search));
+  return {
+    pathname: t.pathname,
+    search: t.search,
+    hash: t.hash
+  };
+}
+function xe(e) {
+  return {
+    location: M(e.location),
+    push: (t) => {
+      if (typeof t == "string") {
+        const s = new URL(e.location.pathname);
+        s.search = t, e.push(s.toString());
+      } else {
+        var n, r, a;
+        const s = new URL(e.location.pathname);
+        s.search = "".concat((n = t.pathname) !== null && n !== void 0 ? n : "").concat((r = t.search) !== null && r !== void 0 ? r : "").concat((a = t.hash) !== null && a !== void 0 ? a : ""), e.push(s.toString());
+      }
+    },
+    replace: (t) => {
+      if (typeof t == "string") {
+        const s = new URL(e.location.pathname);
+        s.search = t, e.replace(s.toString());
+      } else {
+        var n, r, a;
+        const s = new URL(e.location.pathname);
+        s.search = "".concat((n = t.pathname) !== null && n !== void 0 ? n : "").concat((r = t.search) !== null && r !== void 0 ? r : "").concat((a = t.hash) !== null && a !== void 0 ? a : ""), e.replace(s.toString());
+      }
+    },
+    goBack: () => {
+      e.back();
+    },
+    goForward: () => {
+      e.forward();
+    },
+    listen: (t) => {
+      const n = e.listen((r) => {
+        let {
+          location: a
+        } = r;
+        return t(M(a));
+      });
+      return Object.assign(n, {
+        unsubscribe: n
+      });
+    }
+  };
 }
 export {
-  chainRoute,
-  createRoute,
-  createRouter,
-  createRouterControls,
-  createVirtualRoute,
-  group
+  ke as chainRoute,
+  we as createRoute,
+  Oe as createRouter,
+  fe as createRouterControls,
+  Y as createVirtualRoute,
+  Pe as group,
+  je as historyAdapter,
+  U as is,
+  xe as queryAdapter
 };