@solidjs/router 0.4.2

package/dist/index.js

@@ -0,0 +1,936 @@
+import { isServer, createComponent as createComponent$1, mergeProps as mergeProps$1, spread, insert, effect, setAttribute, template } from 'solid-js/web';
+import { createSignal, onCleanup, runWithOwner, createMemo, getOwner, createContext, useContext, untrack, useTransition, on, resetErrorBoundaries, createRenderEffect, createComponent, children, createRoot, Show, mergeProps, splitProps } from 'solid-js';
+
+function bindEvent(target, type, handler) {
+  target.addEventListener(type, handler);
+  return () => target.removeEventListener(type, handler);
+}
+
+function intercept([value, setValue], get, set) {
+  return [get ? () => get(value()) : value, set ? v => setValue(set(v)) : setValue];
+}
+
+function querySelector(selector) {
+  // Guard against selector being an invalid CSS selector
+  try {
+    return document.querySelector(selector);
+  } catch (e) {
+    return null;
+  }
+}
+
+function scrollToHash(hash, fallbackTop) {
+  const el = querySelector(`#${hash}`);
+
+  if (el) {
+    el.scrollIntoView();
+  } else if (fallbackTop) {
+    window.scrollTo(0, 0);
+  }
+}
+
+function createIntegration(get, set, init, utils) {
+  let ignore = false;
+
+  const wrap = value => typeof value === "string" ? {
+    value
+  } : value;
+
+  const signal = intercept(createSignal(wrap(get()), {
+    equals: (a, b) => a.value === b.value
+  }), undefined, next => {
+    !ignore && set(next);
+    return next;
+  });
+  init && onCleanup(init((value = get()) => {
+    ignore = true;
+    signal[1](wrap(value));
+    ignore = false;
+  }));
+  return {
+    signal,
+    utils
+  };
+}
+function normalizeIntegration(integration) {
+  if (!integration) {
+    return {
+      signal: createSignal({
+        value: ""
+      })
+    };
+  } else if (Array.isArray(integration)) {
+    return {
+      signal: integration
+    };
+  }
+
+  return integration;
+}
+function staticIntegration(obj) {
+  return {
+    signal: [() => obj, next => Object.assign(obj, next)]
+  };
+}
+function pathIntegration() {
+  return createIntegration(() => ({
+    value: window.location.pathname + window.location.search + window.location.hash,
+    state: history.state
+  }), ({
+    value,
+    replace,
+    scroll,
+    state
+  }) => {
+    if (replace) {
+      window.history.replaceState(state, "", value);
+    } else {
+      window.history.pushState(state, "", value);
+    }
+
+    scrollToHash(window.location.hash.slice(1), scroll);
+  }, notify => bindEvent(window, "popstate", () => notify()), {
+    go: delta => window.history.go(delta)
+  });
+}
+function hashIntegration() {
+  return createIntegration(() => window.location.hash.slice(1), ({
+    value,
+    replace,
+    scroll,
+    state
+  }) => {
+    if (replace) {
+      window.history.replaceState(state, "", "#" + value);
+    } else {
+      window.location.hash = value;
+    }
+
+    const hashIndex = value.indexOf("#");
+    const hash = hashIndex >= 0 ? value.slice(hashIndex + 1) : "";
+    scrollToHash(hash, scroll);
+  }, notify => bindEvent(window, "hashchange", () => notify()), {
+    go: delta => window.history.go(delta),
+    renderPath: path => `#${path}`,
+    parsePath: str => {
+      const to = str.replace(/^.*?#/, ""); // Hash-only hrefs like `#foo` from plain anchors will come in as `/#foo` whereas a link to
+      // `/foo` will be `/#/foo`. Check if the to starts with a `/` and if not append it as a hash
+      // to the current path so we can handle these in-page anchors correctly.
+
+      if (!to.startsWith("/")) {
+        const [, path = "/"] = window.location.hash.split("#", 2);
+        return `${path}#${to}`;
+      }
+
+      return to;
+    }
+  });
+}
+
+const hasSchemeRegex = /^(?:[a-z0-9]+:)?\/\//i;
+const trimPathRegex = /^\/+|\/+$/g;
+
+function normalize(path, omitSlash = false) {
+  const s = path.replace(trimPathRegex, "");
+  return s ? omitSlash || /^[?#]/.test(s) ? s : "/" + s : "";
+}
+
+function resolvePath(base, path, from) {
+  if (hasSchemeRegex.test(path)) {
+    return undefined;
+  }
+
+  const basePath = normalize(base);
+  const fromPath = from && normalize(from);
+  let result = "";
+
+  if (!fromPath || path.startsWith("/")) {
+    result = basePath;
+  } else if (fromPath.toLowerCase().indexOf(basePath.toLowerCase()) !== 0) {
+    result = basePath + fromPath;
+  } else {
+    result = fromPath;
+  }
+
+  return (result || "/") + normalize(path, !result);
+}
+function invariant(value, message) {
+  if (value == null) {
+    throw new Error(message);
+  }
+
+  return value;
+}
+function joinPaths(from, to) {
+  return normalize(from).replace(/\/*(\*.*)?$/g, "") + normalize(to);
+}
+function extractSearchParams(url) {
+  const params = {};
+  url.searchParams.forEach((value, key) => {
+    params[key] = value;
+  });
+  return params;
+}
+function urlDecode(str, isQuery) {
+  return decodeURIComponent(isQuery ? str.replace(/\+/g, " ") : str);
+}
+function createMatcher(path, partial) {
+  const [pattern, splat] = path.split("/*", 2);
+  const segments = pattern.split("/").filter(Boolean);
+  const len = segments.length;
+  return location => {
+    const locSegments = location.split("/").filter(Boolean);
+    const lenDiff = locSegments.length - len;
+
+    if (lenDiff < 0 || lenDiff > 0 && splat === undefined && !partial) {
+      return null;
+    }
+
+    const match = {
+      path: len ? "" : "/",
+      params: {}
+    };
+
+    for (let i = 0; i < len; i++) {
+      const segment = segments[i];
+      const locSegment = locSegments[i];
+
+      if (segment[0] === ":") {
+        match.params[segment.slice(1)] = locSegment;
+      } else if (segment.localeCompare(locSegment, undefined, {
+        sensitivity: "base"
+      }) !== 0) {
+        return null;
+      }
+
+      match.path += `/${locSegment}`;
+    }
+
+    if (splat) {
+      match.params[splat] = lenDiff ? locSegments.slice(-lenDiff).join("/") : "";
+    }
+
+    return match;
+  };
+}
+function scoreRoute(route) {
+  const [pattern, splat] = route.pattern.split("/*", 2);
+  const segments = pattern.split("/").filter(Boolean);
+  return segments.reduce((score, segment) => score + (segment.startsWith(":") ? 2 : 3), segments.length - (splat === undefined ? 0 : 1));
+}
+function createMemoObject(fn) {
+  const map = new Map();
+  const owner = getOwner();
+  return new Proxy({}, {
+    get(_, property) {
+      if (!map.has(property)) {
+        runWithOwner(owner, () => map.set(property, createMemo(() => fn()[property])));
+      }
+
+      return map.get(property)();
+    },
+
+    getOwnPropertyDescriptor() {
+      return {
+        enumerable: true,
+        configurable: true
+      };
+    },
+
+    ownKeys() {
+      return Reflect.ownKeys(fn());
+    }
+
+  });
+}
+function mergeSearchString(search, params) {
+  const merged = new URLSearchParams(search);
+  Object.entries(params).forEach(([key, value]) => {
+    if (value == null || value === "") {
+      merged.delete(key);
+    } else {
+      merged.set(key, String(value));
+    }
+  });
+  const s = merged.toString();
+  return s ? `?${s}` : "";
+}
+function expandOptionals(pattern) {
+  let match = /(\/?\:[^\/]+)\?/.exec(pattern);
+  if (!match) return [pattern];
+  let prefix = pattern.slice(0, match.index);
+  let suffix = pattern.slice(match.index + match[0].length);
+  const prefixes = [prefix, prefix += match[1]]; // This section handles adjacent optional params. We don't actually want all permuations since
+  // that will lead to equivalent routes which have the same number of params. For example
+  // `/:a?/:b?/:c`? only has the unique expansion: `/`, `/:a`, `/:a/:b`, `/:a/:b/:c` and we can
+  // discard `/:b`, `/:c`, `/:b/:c` by building them up in order and not recursing. This also helps
+  // ensure predictability where earlier params have precidence.
+
+  while (match = /^(\/\:[^\/]+)\?/.exec(suffix)) {
+    prefixes.push(prefix += match[1]);
+    suffix = suffix.slice(match[0].length);
+  }
+
+  return expandOptionals(suffix).reduce((results, expansion) => [...results, ...prefixes.map(p => p + expansion)], []);
+}
+
+const MAX_REDIRECTS = 100;
+const RouterContextObj = createContext();
+const RouteContextObj = createContext();
+const useRouter = () => invariant(useContext(RouterContextObj), "Make sure your app is wrapped in a <Router />");
+let TempRoute;
+const useRoute = () => TempRoute || useContext(RouteContextObj) || useRouter().base;
+const useResolvedPath = path => {
+  const route = useRoute();
+  return createMemo(() => route.resolvePath(path()));
+};
+const useHref = to => {
+  const router = useRouter();
+  return createMemo(() => {
+    const to_ = to();
+    return to_ !== undefined ? router.renderPath(to_) : to_;
+  });
+};
+const useNavigate = () => useRouter().navigatorFactory();
+const useLocation = () => useRouter().location;
+const useIsRouting = () => useRouter().isRouting;
+const useMatch = path => {
+  const location = useLocation();
+  const matcher = createMemo(() => createMatcher(path()));
+  return createMemo(() => matcher()(location.pathname));
+};
+const useParams = () => useRoute().params;
+const useRouteData = () => useRoute().data;
+const useSearchParams = () => {
+  const location = useLocation();
+  const navigate = useNavigate();
+
+  const setSearchParams = (params, options) => {
+    const searchString = untrack(() => mergeSearchString(location.search, params));
+    navigate(searchString, {
+      scroll: false,
+      ...options,
+      resolve: true
+    });
+  };
+
+  return [location.query, setSearchParams];
+};
+function createRoutes(routeDef, base = "", fallback) {
+  const {
+    component,
+    data,
+    children
+  } = routeDef;
+  const isLeaf = !children || Array.isArray(children) && !children.length;
+  const shared = {
+    key: routeDef,
+    element: component ? () => createComponent(component, {}) : () => {
+      const {
+        element
+      } = routeDef;
+      return element === undefined && fallback ? createComponent(fallback, {}) : element;
+    },
+    preload: routeDef.component ? component.preload : routeDef.preload,
+    data
+  };
+  return asArray(routeDef.path).reduce((acc, path) => {
+    for (const originalPath of expandOptionals(path)) {
+      const path = joinPaths(base, originalPath);
+      const pattern = isLeaf ? path : path.split("/*", 1)[0];
+      acc.push({ ...shared,
+        originalPath,
+        pattern,
+        matcher: createMatcher(pattern, !isLeaf)
+      });
+    }
+
+    return acc;
+  }, []);
+}
+function createBranch(routes, index = 0) {
+  return {
+    routes,
+    score: scoreRoute(routes[routes.length - 1]) * 10000 - index,
+
+    matcher(location) {
+      const matches = [];
+
+      for (let i = routes.length - 1; i >= 0; i--) {
+        const route = routes[i];
+        const match = route.matcher(location);
+
+        if (!match) {
+          return null;
+        }
+
+        matches.unshift({ ...match,
+          route
+        });
+      }
+
+      return matches;
+    }
+
+  };
+}
+
+function asArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+
+function createBranches(routeDef, base = "", fallback, stack = [], branches = []) {
+  const routeDefs = asArray(routeDef);
+
+  for (let i = 0, len = routeDefs.length; i < len; i++) {
+    const def = routeDefs[i];
+
+    if (def && typeof def === "object" && def.hasOwnProperty("path")) {
+      const routes = createRoutes(def, base, fallback);
+
+      for (const route of routes) {
+        stack.push(route);
+
+        if (def.children) {
+          createBranches(def.children, route.pattern, fallback, stack, branches);
+        } else {
+          const branch = createBranch([...stack], branches.length);
+          branches.push(branch);
+        }
+
+        stack.pop();
+      }
+    }
+  } // Stack will be empty on final return
+
+
+  return stack.length ? branches : branches.sort((a, b) => b.score - a.score);
+}
+function getRouteMatches(branches, location) {
+  for (let i = 0, len = branches.length; i < len; i++) {
+    const match = branches[i].matcher(location);
+
+    if (match) {
+      return match;
+    }
+  }
+
+  return [];
+}
+function createLocation(path, state) {
+  const origin = new URL("http://sar");
+  const url = createMemo(prev => {
+    const path_ = path();
+
+    try {
+      return new URL(path_, origin);
+    } catch (err) {
+      console.error(`Invalid path ${path_}`);
+      return prev;
+    }
+  }, origin, {
+    equals: (a, b) => a.href === b.href
+  });
+  const pathname = createMemo(() => urlDecode(url().pathname));
+  const search = createMemo(() => urlDecode(url().search, true));
+  const hash = createMemo(() => urlDecode(url().hash));
+  const key = createMemo(() => "");
+  return {
+    get pathname() {
+      return pathname();
+    },
+
+    get search() {
+      return search();
+    },
+
+    get hash() {
+      return hash();
+    },
+
+    get state() {
+      return state();
+    },
+
+    get key() {
+      return key();
+    },
+
+    query: createMemoObject(on(search, () => extractSearchParams(url())))
+  };
+}
+function createRouterContext(integration, base = "", data, out) {
+  const {
+    signal: [source, setSource],
+    utils = {}
+  } = normalizeIntegration(integration);
+
+  const parsePath = utils.parsePath || (p => p);
+
+  const renderPath = utils.renderPath || (p => p);
+
+  const basePath = resolvePath("", base);
+  const output = isServer && out ? Object.assign(out, {
+    matches: [],
+    url: undefined
+  }) : undefined;
+
+  if (basePath === undefined) {
+    throw new Error(`${basePath} is not a valid base path`);
+  } else if (basePath && !source().value) {
+    setSource({
+      value: basePath,
+      replace: true,
+      scroll: false
+    });
+  }
+
+  const [isRouting, start] = useTransition();
+  const [reference, setReference] = createSignal(source().value);
+  const [state, setState] = createSignal(source().state);
+  const location = createLocation(reference, state);
+  const referrers = [];
+  const baseRoute = {
+    pattern: basePath,
+    params: {},
+    path: () => basePath,
+    outlet: () => null,
+
+    resolvePath(to) {
+      return resolvePath(basePath, to);
+    }
+
+  };
+
+  if (data) {
+    try {
+      TempRoute = baseRoute;
+      baseRoute.data = data({
+        data: undefined,
+        params: {},
+        location,
+        navigate: navigatorFactory(baseRoute)
+      });
+    } finally {
+      TempRoute = undefined;
+    }
+  }
+
+  function navigateFromRoute(route, to, options) {
+    // Untrack in case someone navigates in an effect - don't want to track `reference` or route paths
+    untrack(() => {
+      if (typeof to === "number") {
+        if (!to) ; else if (utils.go) {
+          utils.go(to);
+        } else {
+          console.warn("Router integration does not support relative routing");
+        }
+
+        return;
+      }
+
+      const {
+        replace,
+        resolve,
+        scroll,
+        state: nextState
+      } = {
+        replace: false,
+        resolve: true,
+        scroll: true,
+        ...options
+      };
+      const resolvedTo = resolve ? route.resolvePath(to) : resolvePath("", to);
+
+      if (resolvedTo === undefined) {
+        throw new Error(`Path '${to}' is not a routable path`);
+      } else if (referrers.length >= MAX_REDIRECTS) {
+        throw new Error("Too many redirects");
+      }
+
+      const current = reference();
+
+      if (resolvedTo !== current || nextState !== state()) {
+        if (isServer) {
+          if (output) {
+            output.url = resolvedTo;
+          }
+
+          setSource({
+            value: resolvedTo,
+            replace,
+            scroll,
+            state: nextState
+          });
+        } else {
+          const len = referrers.push({
+            value: current,
+            replace,
+            scroll,
+            state: state()
+          });
+          start(() => {
+            setReference(resolvedTo);
+            setState(nextState);
+            resetErrorBoundaries();
+          }).then(() => {
+            if (referrers.length === len) {
+              navigateEnd({
+                value: resolvedTo,
+                state: nextState
+              });
+            }
+          });
+        }
+      }
+    });
+  }
+
+  function navigatorFactory(route) {
+    // Workaround for vite issue (https://github.com/vitejs/vite/issues/3803)
+    route = route || useContext(RouteContextObj) || baseRoute;
+    return (to, options) => navigateFromRoute(route, to, options);
+  }
+
+  function navigateEnd(next) {
+    const first = referrers[0];
+
+    if (first) {
+      if (next.value !== first.value || next.state !== first.state) {
+        setSource({ ...next,
+          replace: first.replace,
+          scroll: first.scroll
+        });
+      }
+
+      referrers.length = 0;
+    }
+  }
+
+  createRenderEffect(() => {
+    const {
+      value,
+      state
+    } = source(); // Untrack this whole block so `start` doesn't cause Solid's Listener to be preserved
+
+    untrack(() => {
+      if (value !== reference()) {
+        start(() => {
+          setReference(value);
+          setState(state);
+        });
+      }
+    });
+  });
+
+  if (!isServer) {
+    function isSvg(el) {
+      return el.namespaceURI === "http://www.w3.org/2000/svg";
+    }
+
+    function handleAnchorClick(evt) {
+      if (evt.defaultPrevented || evt.button !== 0 || evt.metaKey || evt.altKey || evt.ctrlKey || evt.shiftKey) return;
+      const a = evt.composedPath().find(el => el instanceof Node && el.nodeName.toUpperCase() === "A");
+      if (!a) return;
+      const svg = isSvg(a);
+      const href = svg ? a.href.baseVal : a.href;
+      const target = svg ? a.target.baseVal : a.target;
+      if (target || !href && !a.hasAttribute("state")) return;
+      const rel = (a.getAttribute("rel") || "").split(/\s+/);
+      if (a.hasAttribute("download") || rel && rel.includes("external")) return;
+      const url = svg ? new URL(href, document.baseURI) : new URL(href);
+      const pathname = urlDecode(url.pathname);
+      if (url.origin !== window.location.origin || basePath && pathname && !pathname.toLowerCase().startsWith(basePath.toLowerCase())) return;
+      const to = parsePath(pathname + urlDecode(url.search, true) + urlDecode(url.hash));
+      const state = a.getAttribute("state");
+      evt.preventDefault();
+      navigateFromRoute(baseRoute, to, {
+        resolve: false,
+        replace: a.hasAttribute("replace"),
+        scroll: !a.hasAttribute("noscroll"),
+        state: state && JSON.parse(state)
+      });
+    }
+
+    document.addEventListener("click", handleAnchorClick);
+    onCleanup(() => document.removeEventListener("click", handleAnchorClick));
+  }
+
+  return {
+    base: baseRoute,
+    out: output,
+    location,
+    isRouting,
+    renderPath,
+    parsePath,
+    navigatorFactory
+  };
+}
+function createRouteContext(router, parent, child, match) {
+  const {
+    base,
+    location,
+    navigatorFactory
+  } = router;
+  const {
+    pattern,
+    element: outlet,
+    preload,
+    data
+  } = match().route;
+  const path = createMemo(() => match().path);
+  const params = createMemoObject(() => match().params);
+  preload && preload();
+  const route = {
+    parent,
+    pattern,
+
+    get child() {
+      return child();
+    },
+
+    path,
+    params,
+    data: parent.data,
+    outlet,
+
+    resolvePath(to) {
+      return resolvePath(base.path(), to, path());
+    }
+
+  };
+
+  if (data) {
+    try {
+      TempRoute = route;
+      route.data = data({
+        data: parent.data,
+        params,
+        location,
+        navigate: navigatorFactory(route)
+      });
+    } finally {
+      TempRoute = undefined;
+    }
+  }
+
+  return route;
+}
+
+const _tmpl$ = /*#__PURE__*/template(`<a></a>`, 2);
+const Router = props => {
+  const {
+    source,
+    url,
+    base,
+    data,
+    out
+  } = props;
+  const integration = source || (isServer ? staticIntegration({
+    value: url || ""
+  }) : pathIntegration());
+  const routerState = createRouterContext(integration, base, data, out);
+  return createComponent$1(RouterContextObj.Provider, {
+    value: routerState,
+
+    get children() {
+      return props.children;
+    }
+
+  });
+};
+const Routes = props => {
+  const router = useRouter();
+  const parentRoute = useRoute();
+  const routeDefs = children(() => props.children);
+  const branches = createMemo(() => createBranches(routeDefs(), joinPaths(parentRoute.pattern, props.base || ""), Outlet));
+  const matches = createMemo(() => getRouteMatches(branches(), router.location.pathname));
+
+  if (router.out) {
+    router.out.matches.push(matches().map(({
+      route,
+      path,
+      params
+    }) => ({
+      originalPath: route.originalPath,
+      pattern: route.pattern,
+      path,
+      params
+    })));
+  }
+
+  const disposers = [];
+  let root;
+  const routeStates = createMemo(on(matches, (nextMatches, prevMatches, prev) => {
+    let equal = prevMatches && nextMatches.length === prevMatches.length;
+    const next = [];
+
+    for (let i = 0, len = nextMatches.length; i < len; i++) {
+      const prevMatch = prevMatches && prevMatches[i];
+      const nextMatch = nextMatches[i];
+
+      if (prev && prevMatch && nextMatch.route.key === prevMatch.route.key) {
+        next[i] = prev[i];
+      } else {
+        equal = false;
+
+        if (disposers[i]) {
+          disposers[i]();
+        }
+
+        createRoot(dispose => {
+          disposers[i] = dispose;
+          next[i] = createRouteContext(router, next[i - 1] || parentRoute, () => routeStates()[i + 1], () => matches()[i]);
+        });
+      }
+    }
+
+    disposers.splice(nextMatches.length).forEach(dispose => dispose());
+
+    if (prev && equal) {
+      return prev;
+    }
+
+    root = next[0];
+    return next;
+  }));
+  return createComponent$1(Show, {
+    get when() {
+      return routeStates() && root;
+    },
+
+    children: route => createComponent$1(RouteContextObj.Provider, {
+      value: route,
+
+      get children() {
+        return route.outlet();
+      }
+
+    })
+  });
+};
+const useRoutes = (routes, base) => {
+  return () => createComponent$1(Routes, {
+    base: base,
+    children: routes
+  });
+};
+const Route = props => {
+  const childRoutes = children(() => props.children);
+  return mergeProps(props, {
+    get children() {
+      return childRoutes();
+    }
+
+  });
+};
+const Outlet = () => {
+  const route = useRoute();
+  return createComponent$1(Show, {
+    get when() {
+      return route.child;
+    },
+
+    children: child => createComponent$1(RouteContextObj.Provider, {
+      value: child,
+
+      get children() {
+        return child.outlet();
+      }
+
+    })
+  });
+};
+
+function LinkBase(props) {
+  const [, rest] = splitProps(props, ["children", "to", "href", "state"]);
+  const href = useHref(() => props.to);
+  return (() => {
+    const _el$ = _tmpl$.cloneNode(true);
+
+    spread(_el$, rest, false, true);
+
+    insert(_el$, () => props.children);
+
+    effect(_p$ => {
+      const _v$ = href() || props.href,
+            _v$2 = JSON.stringify(props.state);
+
+      _v$ !== _p$._v$ && setAttribute(_el$, "href", _p$._v$ = _v$);
+      _v$2 !== _p$._v$2 && setAttribute(_el$, "state", _p$._v$2 = _v$2);
+      return _p$;
+    }, {
+      _v$: undefined,
+      _v$2: undefined
+    });
+
+    return _el$;
+  })();
+}
+
+function Link(props) {
+  const to = useResolvedPath(() => props.href);
+  return createComponent$1(LinkBase, mergeProps$1(props, {
+    get to() {
+      return to();
+    }
+
+  }));
+}
+function NavLink(props) {
+  props = mergeProps({
+    inactiveClass: "inactive",
+    activeClass: "active"
+  }, props);
+  const [, rest] = splitProps(props, ["activeClass", "inactiveClass", "end"]);
+  const location = useLocation();
+  const to = useResolvedPath(() => props.href);
+  const isActive = createMemo(() => {
+    const to_ = to();
+
+    if (to_ === undefined) {
+      return false;
+    }
+
+    const path = to_.split(/[?#]/, 1)[0].toLowerCase();
+    const loc = location.pathname.toLowerCase();
+    return props.end ? path === loc : loc.startsWith(path);
+  });
+  return createComponent$1(LinkBase, mergeProps$1(rest, {
+    get to() {
+      return to();
+    },
+
+    get classList() {
+      return {
+        [props.inactiveClass]: !isActive(),
+        [props.activeClass]: isActive(),
+        ...rest.classList
+      };
+    },
+
+    get ["aria-current"]() {
+      return isActive() ? "page" : undefined;
+    }
+
+  }));
+}
+function Navigate(props) {
+  const navigate = useNavigate();
+  const location = useLocation();
+  const {
+    href,
+    state
+  } = props;
+  const path = typeof href === "function" ? href({
+    navigate,
+    location
+  }) : href;
+  navigate(path, {
+    replace: true,
+    state
+  });
+  return null;
+}
+
+export { Link, NavLink, Navigate, Outlet, Route, Router, Routes, mergeSearchString as _mergeSearchString, createIntegration, hashIntegration, normalizeIntegration, pathIntegration, staticIntegration, useHref, useIsRouting, useLocation, useMatch, useNavigate, useParams, useResolvedPath, useRouteData, useRoutes, useSearchParams };