@alchemy.run/sigil 0.0.0-alpha.4 → 0.0.0-alpha.6

package/dist/router.js

@@ -0,0 +1,709 @@
+import { f as Text, n as useInput, t as useFocus } from "./use-focus-BzqAJi0n.js";
+import { Children, Fragment, createContext, isValidElement, startTransition, useCallback, useContext, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+import { Fragment as Fragment$1, jsx } from "react/jsx-runtime";
+//#region src/router/history.ts
+/**
+Splits a path string into its pathname and search parts.
+*/
+const parsePath = (path) => {
+	const parsedPath = {};
+	if (path) {
+		const searchIndex = path.indexOf("?");
+		if (searchIndex >= 0) {
+			parsedPath.search = path.slice(searchIndex);
+			path = path.slice(0, searchIndex);
+		}
+		if (path) parsedPath.pathname = path;
+	}
+	return parsedPath;
+};
+/**
+Joins a `Path` back into a single string.
+*/
+const createPath = ({ pathname = "/", search = "" }) => pathname + (search && search !== "?" ? search.startsWith("?") ? search : `?${search}` : "");
+const createMemoryHistory = ({ initialEntries = ["/"], initialIndex } = {}) => {
+	let keyCounter = 0;
+	const createKey = () => `k${keyCounter++}`;
+	const createLocation = (to, state = null) => {
+		const path = typeof to === "string" ? parsePath(to) : to;
+		const location = {
+			pathname: path.pathname ?? "/",
+			search: path.search ?? "",
+			state,
+			key: createKey()
+		};
+		if (!location.pathname.startsWith("/")) throw new Error(`Route pathnames must be absolute, but "${location.pathname}" was used to initialize the navigation stack.`);
+		return location;
+	};
+	const entries = initialEntries.map((entry) => createLocation(entry, typeof entry === "string" ? null : entry.state ?? null));
+	let index = Math.min(Math.max(initialIndex ?? entries.length - 1, 0), entries.length - 1);
+	let action = "POP";
+	let listener = null;
+	return {
+		get index() {
+			return index;
+		},
+		get action() {
+			return action;
+		},
+		get location() {
+			return entries[index];
+		},
+		get canGoBack() {
+			return index > 0;
+		},
+		get canGoForward() {
+			return index < entries.length - 1;
+		},
+		push(to, state) {
+			action = "PUSH";
+			const nextLocation = createLocation(to, state);
+			index += 1;
+			entries.splice(index, entries.length, nextLocation);
+			listener?.({
+				action,
+				location: nextLocation,
+				delta: 1
+			});
+		},
+		replace(to, state) {
+			action = "REPLACE";
+			const nextLocation = createLocation(to, state);
+			entries[index] = nextLocation;
+			listener?.({
+				action,
+				location: nextLocation,
+				delta: 0
+			});
+		},
+		go(delta) {
+			action = "POP";
+			const nextIndex = Math.min(Math.max(index + delta, 0), entries.length - 1);
+			const actualDelta = nextIndex - index;
+			index = nextIndex;
+			listener?.({
+				action,
+				location: entries[index],
+				delta: actualDelta
+			});
+		},
+		listen(newListener) {
+			if (listener) throw new Error("A memory history only supports one listener at a time.");
+			listener = newListener;
+			return () => {
+				listener = null;
+			};
+		}
+	};
+};
+//#endregion
+//#region src/router/matcher.ts
+const joinPaths = (paths) => paths.join("/").replace(/\/\/+/g, "/");
+const normalizePathname = (pathname) => pathname.replace(/\/+$/, "").replace(/^\/*/, "/");
+const normalizeSearch = (search) => !search || search === "?" ? "" : search.startsWith("?") ? search : `?${search}`;
+/**
+Matches a set of (possibly nested) routes against a location and returns the
+chain of matches from the root route down to the leaf, or `null` if nothing
+matches.
+*/
+function matchRoutes(routes, locationArg) {
+	const pathname = (typeof locationArg === "string" ? parsePath(locationArg) : locationArg).pathname ?? "/";
+	const branches = flattenRoutes(routes);
+	rankRouteBranches(branches);
+	let matches = null;
+	for (let index = 0; matches == null && index < branches.length; index++) matches = matchRouteBranch(branches[index], pathname);
+	return matches;
+}
+function flattenRoutes(routes, branches = [], parentsMeta = [], parentPath = "", hasParentOptionalSegments = false) {
+	const flattenRoute = (route, index, insideOptional, relativePath = route.path ?? "") => {
+		const meta = {
+			relativePath,
+			childrenIndex: index,
+			route
+		};
+		if (meta.relativePath.startsWith("/")) {
+			if (!meta.relativePath.startsWith(parentPath)) {
+				if (insideOptional) return;
+				throw new Error(`Absolute route path "${meta.relativePath}" nested under path "${parentPath}" is not valid. An absolute child route path must start with the combined path of all its parent routes.`);
+			}
+			meta.relativePath = meta.relativePath.slice(parentPath.length);
+		}
+		const path = joinPaths([parentPath, meta.relativePath]);
+		const routesMeta = parentsMeta.concat(meta);
+		if (route.children && route.children.length > 0) {
+			if (route.index) throw new Error(`Index routes must not have child routes. Please remove all child routes from route path "${path}".`);
+			flattenRoutes(route.children, branches, routesMeta, path, insideOptional);
+		}
+		if (route.path == null && !route.index) return;
+		branches.push({
+			path,
+			score: computeScore(path, route.index),
+			routesMeta
+		});
+	};
+	routes.forEach((route, index) => {
+		if (route.path === "" || !route.path?.includes("?")) flattenRoute(route, index, hasParentOptionalSegments);
+		else for (const exploded of explodeOptionalSegments(route.path)) flattenRoute(route, index, true, exploded);
+	});
+	return branches;
+}
+function explodeOptionalSegments(path) {
+	const segments = path.split("/");
+	if (segments.length === 0) return [];
+	const [first = "", ...rest] = segments;
+	const isOptional = first.endsWith("?");
+	const required = first.replace(/\?$/, "");
+	if (rest.length === 0) return isOptional ? [required, ""] : [required];
+	const restExploded = explodeOptionalSegments(rest.join("/"));
+	const result = [];
+	result.push(...restExploded.map((subpath) => subpath === "" ? required : [required, subpath].join("/")));
+	if (isOptional) result.push(...restExploded);
+	return result.map((exploded) => path.startsWith("/") && exploded === "" ? "/" : exploded);
+}
+const paramRe = /^:[\w-]+$/;
+const dynamicSegmentValue = 3;
+const indexRouteValue = 2;
+const emptySegmentValue = 1;
+const staticSegmentValue = 10;
+const splatPenalty = -2;
+const isSplat = (segment) => segment === "*";
+function computeScore(path, index) {
+	const segments = path.split("/");
+	let initialScore = segments.length;
+	if (segments.some(isSplat)) initialScore += splatPenalty;
+	if (index) initialScore += indexRouteValue;
+	return segments.filter((segment) => !isSplat(segment)).reduce((score, segment) => score + (paramRe.test(segment) ? dynamicSegmentValue : segment === "" ? emptySegmentValue : staticSegmentValue), initialScore);
+}
+function rankRouteBranches(branches) {
+	branches.sort((a, b) => a.score !== b.score ? b.score - a.score : compareIndexes(a.routesMeta.map((meta) => meta.childrenIndex), b.routesMeta.map((meta) => meta.childrenIndex)));
+}
+function compareIndexes(a, b) {
+	return a.length === b.length && a.slice(0, -1).every((n, index) => n === b[index]) ? a[a.length - 1] - b[b.length - 1] : 0;
+}
+function matchRouteBranch(branch, pathname) {
+	const { routesMeta } = branch;
+	const matchedParams = {};
+	let matchedPathname = "/";
+	const matches = [];
+	for (let index = 0; index < routesMeta.length; index++) {
+		const meta = routesMeta[index];
+		const end = index === routesMeta.length - 1;
+		const remainingPathname = matchedPathname === "/" ? pathname : pathname.slice(matchedPathname.length) || "/";
+		const match = matchPath({
+			path: meta.relativePath,
+			end
+		}, remainingPathname);
+		if (!match) return null;
+		Object.assign(matchedParams, match.params);
+		matches.push({
+			params: matchedParams,
+			pathname: joinPaths([matchedPathname, match.pathname]),
+			pathnameBase: normalizePathname(joinPaths([matchedPathname, match.pathnameBase])),
+			route: meta.route
+		});
+		if (match.pathnameBase !== "/") matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);
+	}
+	return matches;
+}
+/**
+Matches a single path pattern against a pathname. Returns the match with
+extracted params, or `null` if the pattern does not match.
+*/
+function matchPath(pattern, pathname) {
+	if (typeof pattern === "string") pattern = {
+		path: pattern,
+		end: true
+	};
+	const [matcher, compiledParams] = compilePath(pattern.path, pattern.end);
+	const match = pathname.match(matcher);
+	if (!match) return null;
+	const matchedPathname = match[0];
+	let pathnameBase = matchedPathname.replace(/(.)\/+$/, "$1");
+	const captureGroups = match.slice(1);
+	return {
+		params: compiledParams.reduce((memo, { paramName, isOptional }, index) => {
+			const value = captureGroups[index];
+			if (paramName === "*") {
+				const splatValue = value || "";
+				pathnameBase = matchedPathname.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\/+$/, "$1");
+			}
+			memo[paramName] = isOptional && !value ? void 0 : value || "";
+			return memo;
+		}, {}),
+		pathname: matchedPathname,
+		pathnameBase,
+		pattern
+	};
+}
+function compilePath(path, end = true) {
+	if (path !== "*" && path.endsWith("*") && !path.endsWith("/*")) throw new Error(`Route path "${path}" is invalid because the \`*\` character must always follow a \`/\` in the pattern. Please change the route path to "${path.replace(/\*$/, "/*")}".`);
+	const params = [];
+	let regexpSource = "^" + path.replace(/\/*\*?$/, "").replace(/^\/*/, "/").replace(/[\\.*+^${}|()[\]]/g, "\\$&").replace(/\/:([\w-]+)(\?)?/g, (_, paramName, isOptional) => {
+		params.push({
+			paramName,
+			isOptional: isOptional != null
+		});
+		return isOptional ? "/?([^\\/]+)?" : "/([^\\/]+)";
+	}).replace(/\/([\w-]+)\?(\/|$)/g, "(/$1)?$2");
+	if (path.endsWith("*")) {
+		params.push({ paramName: "*" });
+		regexpSource += path === "*" || path === "/*" ? "(.*)$" : "(?:\\/(.+)|\\/*)$";
+	} else if (end) regexpSource += "\\/*$";
+	else if (path !== "" && path !== "/") regexpSource += "(?:(?=\\/|$))";
+	return [new RegExp(regexpSource), params];
+}
+/**
+Interpolates params into a route path pattern.
+
+```ts
+generatePath("/users/:id", { id: "42" }); // "/users/42"
+```
+*/
+function generatePath(originalPath, params = {}) {
+	const path = originalPath;
+	if (path.endsWith("*") && path !== "*" && !path.endsWith("/*")) throw new Error(`Route path "${path}" is invalid because the \`*\` character must always follow a \`/\` in the pattern. Please change the route path to "${path.replace(/\*$/, "/*")}".`);
+	return (path.startsWith("/") ? "/" : "") + path.split(/\/+/).map((segment, index, array) => {
+		if (index === array.length - 1 && segment === "*") return params["*"] ?? "";
+		const keyMatch = segment.match(/^:([\w-]+)(\??)$/);
+		if (keyMatch) {
+			const key = keyMatch[1];
+			const optional = keyMatch[2];
+			const param = params[key];
+			if (optional !== "?" && param == null) throw new Error(`Missing ":${key}" param`);
+			return param ?? "";
+		}
+		return segment.replace(/\?$/g, "");
+	}).filter((segment) => !!segment).join("/");
+}
+/**
+Resolves a `To` value against a starting pathname, handling `.` and `..`
+segments.
+*/
+function resolvePath(to, fromPathname = "/") {
+	const { pathname: toPathname, search = "" } = typeof to === "string" ? parsePath(to) : to;
+	return {
+		pathname: toPathname ? toPathname.startsWith("/") ? toPathname : resolvePathname(toPathname, fromPathname) : fromPathname,
+		search: normalizeSearch(search)
+	};
+}
+function resolvePathname(relativePath, fromPathname) {
+	const segments = fromPathname.replace(/\/+$/, "").split("/");
+	for (const segment of relativePath.split("/")) if (segment === "..") {
+		if (segments.length > 1) segments.pop();
+	} else if (segment !== ".") segments.push(segment);
+	return segments.length > 1 ? segments.join("/") : "/";
+}
+function getPathContributingMatches(matches) {
+	return matches.filter((match, index) => index === 0 || match.route.path && match.route.path.length > 0);
+}
+function getResolveToMatches(matches) {
+	const pathMatches = getPathContributingMatches(matches);
+	return pathMatches.map((match, index) => index === pathMatches.length - 1 ? match.pathname : match.pathnameBase);
+}
+function resolveTo(toArg, routePathnames, locationPathname) {
+	const to = typeof toArg === "string" ? parsePath(toArg) : { ...toArg };
+	if (to.pathname?.includes("?")) throw new Error(`Cannot include a '?' character in a manually specified \`to.pathname\` field [${JSON.stringify(to)}]. Please separate it out to the \`to.search\` field.`);
+	const isEmptyPath = toArg === "" || to.pathname === "";
+	const toPathname = isEmptyPath ? "/" : to.pathname;
+	let from;
+	if (toPathname == null) from = locationPathname;
+	else {
+		let routePathnameIndex = routePathnames.length - 1;
+		if (toPathname.startsWith("..")) {
+			const toSegments = toPathname.split("/");
+			while (toSegments[0] === "..") {
+				toSegments.shift();
+				routePathnameIndex -= 1;
+			}
+			to.pathname = toSegments.join("/");
+		}
+		from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : "/";
+	}
+	const path = resolvePath(to, from);
+	const hasExplicitTrailingSlash = toPathname && toPathname !== "/" && toPathname.endsWith("/");
+	const hasCurrentTrailingSlash = (isEmptyPath || toPathname === ".") && locationPathname.endsWith("/");
+	if (!path.pathname.endsWith("/") && (hasExplicitTrailingSlash || hasCurrentTrailingSlash)) path.pathname += "/";
+	return path;
+}
+//#endregion
+//#region src/router/context.ts
+const NavigationContext = createContext(null);
+const LocationContext = createContext(null);
+const RouteContext = createContext({
+	outlet: null,
+	matches: []
+});
+const OutletContext = createContext(null);
+//#endregion
+//#region src/router/hooks.tsx
+/** @jsxImportSource react */
+const warned = /* @__PURE__ */ new Set();
+const warnOnce = (key, message) => {
+	if (!warned.has(key)) {
+		warned.add(key);
+		console.warn(message);
+	}
+};
+/**
+Returns `true` when rendered inside a `<MemoryRouter>`. Useful for components
+that optionally integrate with routing.
+*/
+const useInRouterContext = () => useContext(LocationContext) != null;
+/**
+Returns the current `Location`.
+*/
+const useLocation = () => {
+	const locationContext = useContext(LocationContext);
+	if (!locationContext) throw new Error("useLocation() may be used only in the context of a <MemoryRouter> component.");
+	return locationContext.location;
+};
+/**
+Returns the type of navigation that produced the current location: `"POP"`,
+`"PUSH"`, or `"REPLACE"`.
+*/
+const useNavigationType = () => {
+	const locationContext = useContext(LocationContext);
+	if (!locationContext) throw new Error("useNavigationType() may be used only in the context of a <MemoryRouter> component.");
+	return locationContext.navigationType;
+};
+const useNavigationContext = (hookName) => {
+	const navigationContext = useContext(NavigationContext);
+	if (!navigationContext) throw new Error(`${hookName} may be used only in the context of a <MemoryRouter> component.`);
+	return navigationContext;
+};
+/**
+Returns a stable function for imperative navigation.
+*/
+const useNavigate = () => {
+	const { navigator } = useNavigationContext("useNavigate()");
+	const { matches } = useContext(RouteContext);
+	const { pathname: locationPathname } = useLocation();
+	const routePathnamesJson = JSON.stringify(getResolveToMatches(matches));
+	const activeRef = useRef(false);
+	useLayoutEffect(() => {
+		activeRef.current = true;
+	});
+	return useCallback((to, options = {}) => {
+		if (!activeRef.current) return;
+		if (typeof to === "number") {
+			navigator.go(to);
+			return;
+		}
+		const path = resolveTo(to, JSON.parse(routePathnamesJson), locationPathname);
+		(options.replace ? navigator.replace : navigator.push)(path, options.state);
+	}, [
+		navigator,
+		routePathnamesJson,
+		locationPathname
+	]);
+};
+/**
+Returns whether the navigation stack has entries behind/ahead of the current
+one — i.e. whether `navigate(-1)` / `navigate(1)` will move anywhere. Handy
+for "Esc goes back, unless at root" bindings.
+*/
+const useNavigationStack = () => {
+	const { navigator } = useNavigationContext("useNavigationStack()");
+	useLocation();
+	return {
+		canGoBack: navigator.canGoBack(),
+		canGoForward: navigator.canGoForward()
+	};
+};
+/**
+Returns the params from all dynamic segments matched by the current route and
+its ancestors.
+*/
+const useParams = () => {
+	const { matches } = useContext(RouteContext);
+	const routeMatch = matches[matches.length - 1];
+	return routeMatch ? routeMatch.params : {};
+};
+/**
+Matches a path pattern against the current location's pathname. Returns the
+match (with params) or `null`.
+*/
+const useMatch = (pattern) => {
+	const { pathname } = useLocation();
+	return matchPath(pattern, pathname);
+};
+/**
+Resolves a `To` value against the current route, exactly as `useNavigate`
+would. Useful for building navigation UI.
+*/
+const useResolvedPath = (to) => {
+	const { matches } = useContext(RouteContext);
+	const { pathname: locationPathname } = useLocation();
+	return resolveTo(to, getResolveToMatches(matches), locationPathname);
+};
+/**
+Returns the element for the child route at this level of the route hierarchy,
+or `null` if there is none. Used internally by `<Outlet>`.
+*/
+const useOutlet = (context) => {
+	const { outlet } = useContext(RouteContext);
+	if (outlet) return /* @__PURE__ */ jsx(OutletContext.Provider, {
+		value: context,
+		children: outlet
+	});
+	return outlet;
+};
+/**
+Returns the value passed to the nearest parent `<Outlet context={...}>`.
+*/
+const useOutletContext = () => useContext(OutletContext);
+/**
+Creates a `URLSearchParams` from common initializer shapes, including
+`{ key: ["a", "b"] }` for repeated keys.
+*/
+const createSearchParams = (init = "") => new URLSearchParams(typeof init === "string" || Array.isArray(init) || init instanceof URLSearchParams ? init : Object.keys(init).flatMap((key) => {
+	const value = init[key];
+	return Array.isArray(value) ? value.map((v) => [key, v]) : [[key, value]];
+}));
+/**
+Returns the current location's search params and a setter that navigates to
+the same pathname with the new params.
+*/
+const useSearchParams = (defaultInit) => {
+	const defaultSearchParamsRef = useRef(createSearchParams(defaultInit));
+	const hasSetSearchParamsRef = useRef(false);
+	const location = useLocation();
+	const searchParams = useMemo(() => {
+		const params = createSearchParams(location.search);
+		if (!hasSetSearchParamsRef.current) {
+			for (const key of defaultSearchParamsRef.current.keys()) if (!params.has(key)) for (const value of defaultSearchParamsRef.current.getAll(key)) params.append(key, value);
+		}
+		return params;
+	}, [location.search]);
+	const navigate = useNavigate();
+	return [searchParams, useCallback((nextInit, navigateOptions) => {
+		const newSearchParams = createSearchParams(typeof nextInit === "function" ? nextInit(new URLSearchParams(searchParams)) : nextInit);
+		hasSetSearchParamsRef.current = true;
+		navigate(`?${newSearchParams.toString()}`, navigateOptions);
+	}, [navigate, searchParams])];
+};
+/**
+Matches a set of route objects against the current location (or an override)
+and returns the rendered element tree. The plain-object alternative to
+`<Routes>`.
+*/
+const useRoutes = (routes, locationArg) => {
+	if (!useInRouterContext()) throw new Error("useRoutes() may be used only in the context of a <MemoryRouter> component.");
+	const { matches: parentMatches } = useContext(RouteContext);
+	const routeMatch = parentMatches[parentMatches.length - 1];
+	const parentParams = routeMatch ? routeMatch.params : {};
+	const parentPathnameBase = routeMatch ? routeMatch.pathnameBase : "/";
+	const parentRoute = routeMatch?.route;
+	const locationFromContext = useLocation();
+	let location;
+	if (locationArg) {
+		const parsedLocationArg = typeof locationArg === "string" ? parsePath(locationArg) : locationArg;
+		if (parentPathnameBase !== "/" && !parsedLocationArg.pathname?.startsWith(parentPathnameBase)) throw new Error(`When overriding the location using \`<Routes location>\` or \`useRoutes(routes, location)\`, the location pathname must begin with the portion of the pathname that was matched by all parent routes. The current pathname base is "${parentPathnameBase}" but pathname "${parsedLocationArg.pathname}" was given in the \`location\` prop.`);
+		location = parsedLocationArg;
+	} else location = locationFromContext;
+	const pathname = location.pathname ?? "/";
+	let remainingPathname = pathname;
+	if (parentPathnameBase !== "/") {
+		const parentSegments = parentPathnameBase.replace(/^\//, "").split("/");
+		remainingPathname = `/${pathname.replace(/^\//, "").split("/").slice(parentSegments.length).join("/")}`;
+	}
+	const matches = matchRoutes(routes, { pathname: remainingPathname });
+	const parentPath = parentRoute?.path ?? "";
+	if (parentRoute && !parentPath.endsWith("*")) warnOnce(`descendant-routes:${routeMatch.pathname}`, `You rendered descendant <Routes> (or called useRoutes()) at "${routeMatch.pathname}" (under <Route path="${parentPath}">) but the parent route path has no trailing "*". This means if you navigate deeper, the parent won't match anymore and therefore the child routes will never render. Please change the parent to <Route path="${parentPath === "/" ? "*" : `${parentPath}/*`}">.`);
+	if (matches == null && !parentRoute) warnOnce(`no-match:${pathname}${location.search ?? ""}`, `No routes matched location "${pathname}${location.search ?? ""}".`);
+	return renderMatches(matches && matches.map((match) => ({
+		...match,
+		params: {
+			...parentParams,
+			...match.params
+		},
+		pathname: joinPaths([parentPathnameBase, match.pathname]),
+		pathnameBase: match.pathnameBase === "/" ? parentPathnameBase : joinPaths([parentPathnameBase, match.pathnameBase])
+	})), parentMatches);
+};
+function renderMatches(matches, parentMatches) {
+	if (matches == null) return null;
+	return matches.reduceRight((outlet, match, index) => {
+		const matchesUpToHere = parentMatches.concat(matches.slice(0, index + 1));
+		return /* @__PURE__ */ jsx(RouteContext.Provider, {
+			value: {
+				outlet,
+				matches: matchesUpToHere
+			},
+			children: match.route.element ?? outlet
+		});
+	}, null);
+}
+//#endregion
+//#region src/router/components.tsx
+/** @jsxImportSource react */
+/**
+The routing container for a Sigil app. Stores the navigation stack in memory —
+routes aren't URLs, they're screen states.
+
+```tsx
+<MemoryRouter>
+<Routes>
+<Route path="/" element={<Home />} />
+<Route path="/settings" element={<Settings />} />
+</Routes>
+</MemoryRouter>
+```
+*/
+function MemoryRouter({ initialEntries, initialIndex, children }) {
+	const historyRef = useRef(null);
+	historyRef.current ??= createMemoryHistory({
+		initialEntries,
+		initialIndex
+	});
+	const history = historyRef.current;
+	const [state, setState] = useState({
+		action: history.action,
+		location: history.location
+	});
+	useLayoutEffect(() => history.listen(({ action, location }) => {
+		startTransition(() => {
+			setState({
+				action,
+				location
+			});
+		});
+	}), [history]);
+	const navigator = useMemo(() => ({
+		push: (to, historyState) => history.push(to, historyState),
+		replace: (to, historyState) => history.replace(to, historyState),
+		go: (delta) => history.go(delta),
+		canGoBack: () => history.canGoBack,
+		canGoForward: () => history.canGoForward
+	}), [history]);
+	const navigationContext = useMemo(() => ({ navigator }), [navigator]);
+	const locationContext = useMemo(() => ({
+		location: state.location,
+		navigationType: state.action
+	}), [state]);
+	return /* @__PURE__ */ jsx(NavigationContext.Provider, {
+		value: navigationContext,
+		children: /* @__PURE__ */ jsx(LocationContext.Provider, {
+			value: locationContext,
+			children
+		})
+	});
+}
+/**
+Declares a route. Only valid as a child of `<Routes>` or another `<Route>`.
+*/
+function Route(_props) {
+	throw new Error("A <Route> is only ever to be used as the child of a <Routes> element, never rendered directly. Please wrap your <Route> in a <Routes>.");
+}
+function createRoutesFromChildren(children) {
+	const routes = [];
+	Children.forEach(children, (element) => {
+		if (!isValidElement(element)) return;
+		if (element.type === Fragment) {
+			routes.push(...createRoutesFromChildren(element.props.children));
+			return;
+		}
+		if (element.type !== Route) throw new Error(`[${typeof element.type === "string" ? element.type : element.type.name ?? "unknown"}] is not a <Route> component. All component children of <Routes> must be a <Route> or <React.Fragment>.`);
+		const props = element.props;
+		const route = {
+			path: props.path,
+			index: props.index,
+			element: props.element
+		};
+		if (props.children) route.children = createRoutesFromChildren(props.children);
+		routes.push(route);
+	});
+	return routes;
+}
+/**
+Renders the branch of child `<Route>` elements that best matches the current
+location.
+*/
+function Routes({ children, location }) {
+	return useRoutes(createRoutesFromChildren(children), location);
+}
+/**
+Renders the matching child route of a parent route, or nothing if no child
+matches.
+*/
+function Outlet(props) {
+	return useOutlet(props.context);
+}
+/**
+Navigates as soon as it renders. The component form of `useNavigate`, for
+declarative redirects:
+
+```tsx
+<Route path="/" element={<Navigate to="/home" replace />} />
+```
+*/
+function Navigate({ to, replace, state }) {
+	const navigate = useNavigate();
+	const { pathname, search } = useResolvedPath(to);
+	useEffect(() => {
+		navigate({
+			pathname,
+			search
+		}, {
+			replace,
+			state
+		});
+	}, [
+		navigate,
+		pathname,
+		search,
+		replace,
+		state
+	]);
+	return null;
+}
+/**
+A focusable navigation element — the terminal's `<a>` tag. Focus it with
+<kbd>Tab</kbd> and activate it with <kbd>Enter</kbd>. By default the focused
+link renders inverse; pass a function as `children` (or any `Text` props) to
+customize.
+
+```tsx
+<Link to="/settings">Settings</Link>
+```
+*/
+function Link({ to, replace = false, state, autoFocus = false, id, children, ...textProps }) {
+	const navigate = useNavigate();
+	const path = useResolvedPath(to);
+	const { pathname: locationPathname } = useLocation();
+	const { isFocused } = useFocus({
+		autoFocus,
+		id
+	});
+	const toPathname = normalizePathname(path.pathname);
+	const isActive = locationPathname === toPathname || locationPathname.startsWith(toPathname) && locationPathname.charAt(toPathname.length) === "/";
+	const activate = useCallback(() => {
+		navigate({
+			pathname: path.pathname,
+			search: path.search
+		}, {
+			replace,
+			state
+		});
+	}, [
+		navigate,
+		path.pathname,
+		path.search,
+		replace,
+		state
+	]);
+	useInput((_input, key) => {
+		if (key.return) activate();
+	}, { isActive: isFocused });
+	if (typeof children === "function") return /* @__PURE__ */ jsx(Fragment$1, { children: children({
+		isFocused,
+		isActive
+	}) });
+	return /* @__PURE__ */ jsx(Text, {
+		inverse: isFocused,
+		...textProps,
+		children
+	});
+}
+//#endregion
+export { Link, MemoryRouter, Navigate, Outlet, Route, Routes, createPath, createSearchParams, generatePath, matchPath, matchRoutes, parsePath, resolvePath, useInRouterContext, useLocation, useMatch, useNavigate, useNavigationStack, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRoutes, useSearchParams };