@stealthscale/provider-router 0.1.0 → 0.4.0

package/dist/index.js

@@ -1,41 +1,65 @@
-import { n as __reExport, t as __exportAll } from "./rolldown-runtime-BBjsoOtd.js";
 import { createElement } from "react";
+import { Link, Navigate, Outlet, Outlet as Outlet$1, RouterContextProvider, RouterProvider, createLink, createMemoryHistory, createRootRoute, createRootRouteWithContext, createRoute, createRoute as createRoute$1, createRouter, isNotFound, isRedirect, lazyRouteComponent, notFound, notFound as notFound$1, redirect, trimPath, useChildMatches, useLinkProps, useLocation, useMatches, useMatches as useMatches$1, useNavigate, useRouteContext, useRouteContext as useRouteContext$1, useRouter, useRouterState } from "@tanstack/react-router";
 import { c } from "react/compiler-runtime";
+import { getRouteSegments, hasMissingPathParams, interpolatePath } from "@tanstack/router-core";
 import { jsx } from "react/jsx-runtime";
-export * from "@tanstack/react-router";
-//#region src/tanstack.ts
-var tanstack_exports = /* @__PURE__ */ __exportAll({});
-import * as import__tanstack_react_router from "@tanstack/react-router";
-__reExport(tanstack_exports, import__tanstack_react_router);
+//#region src/basepath.ts
+/**
+* Derives the path a router mounts its routes under from where the documents are served.
+*/
+/**
+* Path a router mounts under when the application is served at the root of its origin.
+*/
+const ROOT = "/";
+/**
+* Derives the router's base path from the base the bundler was given.
+*
+* @remarks
+*   The bundler's base locates the assets: a path under the application's origin for an ordinary
+*   deployment, an absolute URL for one whose assets are served from another host. The router's
+*   base path locates the documents, which is always a path on the application's origin. A
+*   path-only base locates both, so its path becomes the router's without the trailing slash the
+*   bundler writes. A base naming a host says nothing about the documents, so the router mounts at
+*   the root.
+* @param base - Base the bundler was given, which is `import.meta.env.BASE_URL` in a page.
+* @param documents - Path the documents are served under, for a deployment whose assets are served
+*   from another host. Omitted, the base decides.
+* @returns The path the router mounts under, with a leading slash and no trailing slash.
+*/
+function basepathOf(base, documents) {
+	const trimmed = (documents ?? (base.startsWith("/") ? base : ROOT)).replace(/\/+$/u, "");
+	return trimmed === "" ? ROOT : trimmed;
+}
 //#endregion
 //#region src/compile.ts
 /**
 * Compiles declarations into routes under a parent, without touching the parent.
 */
 /**
-* Reads the page a declaration draws with, loading it on first navigation where it is lazy.
+* Returns the component of a declaration's page, which loads on the first navigation where the page
+* is lazy.
 *
 * @param component - The page, or the importer that resolves to one.
-* @returns The component the route draws.
+* @returns The component the route renders.
 */
 function pageOf(component) {
-	return "load" in component ? (0, tanstack_exports.lazyRouteComponent)(component.load, component.export) : component;
+	return "load" in component ? lazyRouteComponent(component.load, component.export) : component;
 }
 /**
-* Draws a layout around whatever the route below it draws.
+* Returns a component that renders a layout around the route below it.
 *
-* @param drawn - The layout component the caller registered.
+* @param layout - The layout component the caller registered.
 * @param options - The options the declaration stated for this layout.
-* @returns A component the pathless route draws.
+* @returns A component the pathless route renders.
 */
-function framed(drawn, options) {
+function framed(layout, options) {
 	/**
-	* Draws the layout around the route below it.
+	* Renders the layout around the route below it.
 	*
-	* @returns The frame, holding the outlet.
+	* @returns The layout, with the outlet inside it.
 	*/
 	return function Layout() {
-		return createElement(drawn, { options }, createElement(tanstack_exports.Outlet));
+		return createElement(layout, { options }, createElement(Outlet$1));
 	};
 }
 /**
@@ -86,15 +110,15 @@ function freeId(building, under, name) {
 * @param under - The route the outermost layout hangs under.
 * @returns The route the declaration's own route hangs under.
 * @throws {@link Error} Where a layout nothing provides is named, or where one a route above
-*   already draws is named again.
+*   already renders is named again.
 */
 function framing(building, declaration, under) {
 	const names = [...building.applied.get(under) ?? []];
 	let current = under;
 	for (const name of declaration.layout ?? []) {
-		const drawn = building.options.layouts?.[name];
-		if (drawn === void 0) throw new Error(`The route ${declaration.id} names the layout ${name}, which is absent.`);
-		if (names.includes(name)) throw new Error(`The route ${declaration.id} names the layout ${name}, which a route above it already draws.`);
+		const layout = building.options.layouts?.[name];
+		if (layout === void 0) throw new Error(`The route ${declaration.id} names the layout ${name}, which is absent.`);
+		if (names.includes(name)) throw new Error(`The route ${declaration.id} names the layout ${name}, which a route above it already renders.`);
 		names.push(name);
 		const key = JSON.stringify([names, declaration.layoutOptions ?? null]);
 		const built = building.frames.get(current) ?? /* @__PURE__ */ new Map();
@@ -102,8 +126,8 @@ function framing(building, declaration, under) {
 		const existing = built.get(key);
 		const above = current;
 		if (existing === void 0) {
-			const frame = (0, tanstack_exports.createRoute)({
-				component: framed(drawn, declaration.layoutOptions),
+			const frame = createRoute$1({
+				component: framed(layout, declaration.layoutOptions),
 				getParentRoute: () => above,
 				id: freeId(building, above, name)
 			});
@@ -116,17 +140,38 @@ function framing(building, declaration, under) {
 	return current;
 }
 /**
+* Builds the loader options of a route whose declaration states a loader.
+*
+* @remarks
+*   The search is the loader's dependencies, so the router runs the loader again when the search
+*   changes, and keeps one result per search.
+* @param loader - The loader the declaration stated.
+* @returns The options to spread into the route.
+*/
+function loading(loader) {
+	return {
+		loader: ({ abortController, context, deps, params, preload }) => loader({
+			context,
+			params,
+			preload,
+			search: deps.search,
+			signal: abortController.signal
+		}),
+		loaderDeps: ({ search }) => ({ search })
+	};
+}
+/**
 * Builds the route one declaration compiles to.
 *
 * @param building - The state this compilation has built up.
 * @param declaration - The route being compiled.
 * @param under - The route it hangs under, frames included.
-* @returns The route, drawing the declaration's page under the frames it named.
+* @returns The route, which renders the declaration's page inside the frames it named.
 */
 function routeOf(building, declaration, under) {
-	const { errorComponent } = building.options;
-	const { id, navigation, when } = declaration;
-	return (0, tanstack_exports.createRoute)({
+	const { errorComponent, notFoundComponent } = building.options;
+	const { id, loader, navigation, when } = declaration;
+	return createRoute$1({
 		component: pageOf(declaration.component),
 		getParentRoute: () => under,
 		path: declaration.path,
@@ -135,27 +180,29 @@ function routeOf(building, declaration, under) {
 			...navigation === void 0 ? {} : { navigation }
 		} },
 		...errorComponent === void 0 ? {} : { errorComponent: errorComponent(declaration) },
+		...notFoundComponent === void 0 ? {} : { notFoundComponent },
 		...declaration.search === void 0 ? {} : { validateSearch: declaration.search },
-		...when === void 0 ? {} : { beforeLoad: gate(building, declaration, when) }
+		...when === void 0 ? {} : { beforeLoad: gate(building, declaration, when) },
+		...loader === void 0 ? {} : loading(loader)
 	});
 }
 /**
 * Builds the check a route runs before it is entered.
 *
 * @remarks
-*   The evaluator is read once here rather than inside the check, so a declaration stating a
-*   condition with no evaluator is refused while the tree is built rather than on a navigation.
+*   The evaluator is read once, when the route is built, so the compiler refuses a declaration that
+*   states a condition without an evaluator before any navigation.
 * @param building - The state this compilation has built up.
 * @param declaration - The route being compiled.
 * @param when - The condition the declaration stated.
-* @returns The check, which the route runs before it loads.
+* @returns The check, which the route runs with its context before it loads.
 * @throws {@link Error} Where no evaluator was given.
 */
 function gate(building, declaration, when) {
 	const { evaluate } = building.options;
 	if (evaluate === void 0) throw new Error(`The route ${declaration.id} states a condition and no evaluator was given.`);
-	return () => {
-		if (!evaluate(when)) throw (0, tanstack_exports.notFound)();
+	return ({ context, location }) => {
+		if (!evaluate(when, context, location)) throw notFound$1();
 	};
 }
 /**
@@ -189,14 +236,14 @@ function compiledFor(building, declaration, seen) {
 * Refuses a declaration this package cannot honour, before any of them is compiled.
 *
 * @remarks
-*   A screen maps to a route and a route decides the whole screen, so a page drawn beside another
-*   as a pane has no route to be. The library agrees: `Outlet` takes no name, one route matches per
-*   level, and two outlets in one component draw the same child twice.
+*   A matched route renders the whole screen, so a page rendered beside another as a pane has no
+*   route of its own. The library has no named outlet: `Outlet` takes no name, one route matches
+*   per level, and two outlets in one component render the same child twice.
 * @param declarations - The routes to compile.
 * @throws {@link Error} Where one states an outlet.
 */
 function refuse(declarations) {
-	for (const declaration of declarations) if (declaration.outlet !== void 0) throw new Error(`The route ${declaration.id} states the outlet ${declaration.outlet}. A screen is whatever its route draws, so there is no pane to draw a second page in.`);
+	for (const declaration of declarations) if (declaration.outlet !== void 0) throw new Error(`The route ${declaration.id} states the outlet ${declaration.outlet}. A route renders the whole screen, so no pane exists to render a second page in.`);
 }
 /**
 * Indexes declarations by id, refusing a second one that claims an id already taken.
@@ -217,17 +264,18 @@ function indexed(declarations) {
 * Compiles declarations into routes under the parent a caller states.
 *
 * @remarks
-*   Pure with respect to the caller. It creates routes and never mutates the parent, so a second
-*   call returns a second set of routes sharing no object with the first. That is what keeps two
-*   routers in one process from reading each other's tree through the library's process-wide cache.
-*   Compile every contributor's declarations in one call. Two calls under one parent cannot see
-*   each other's paths, and `routeMap` reports the collision once the tree is assembled.
+*   The compiler creates routes and never mutates the parent, so a second call returns a second set
+*   of routes that shares no object with the first. Two routers in one process therefore never read
+*   each other's tree through the library's process-wide cache. Compile every contributor's
+*   declarations in one call: two calls under one parent cannot see each other's paths, and
+*   `routeMap` reports the collision once the tree is assembled.
 * @param declarations - The routes to compile, in any order.
 * @param options - The parent, and what the declarations may name.
 * @returns The routes to place in the parent's own `addChildren` call.
 * @throws {@link Error} Where two declarations share an id, where one names a parent or a layout
-*   nothing provides, where one names a layout a route above it already draws, where parents form a
-*   cycle, where one states a condition and no evaluator was given, or where one states an outlet.
+*   nothing provides, where one names a layout a route above it already renders, where parents form
+*   a cycle, where one states a condition and no evaluator was given, or where one states an
+*   outlet.
 */
 function compileRoutes(declarations, options) {
 	refuse(declarations);
@@ -248,7 +296,7 @@ function compileRoutes(declarations, options) {
 //#endregion
 //#region src/reference.ts
 /**
-* Reads the id a target names.
+* Reads the id of a target.
 *
 * @param to - A reference, or the bare id.
 * @returns The full id the route was declared under.
@@ -259,17 +307,20 @@ function idOf(to) {
 //#endregion
 //#region src/declared.ts
 /**
-* Reads the id and the menu entry a matched route carries, or nothing where it carries neither.
+* Reads the declaration a matched route was compiled from.
+*/
+/**
+* Reads the id and the menu entry a matched route stores, or nothing where it stores neither.
 *
 * @remarks
-*   A route carries its id in `staticData`, which is where the library keeps whatever a route wants
-*   to carry. The compiler writes it for a route built from a declaration and `namedRoute` writes
-*   it for one written in code, so a menu, a breadcrumb or a telemetry hook reads what it needs off
-*   the match either way. The shape is checked rather than trusted, because `staticData` is untyped
-*   by design and a route may carry anything under the same name. The checked object itself is
-*   returned, so every read of one route gives one reference.
+*   A route stores its id in `staticData`, the library's place for data a route is created with.
+*   The compiler writes it for a route built from a declaration, and `namedRoute` writes it for one
+*   written in code, so a menu, a breadcrumb or a telemetry hook reads the id from the match either
+*   way. The function checks the shape, because `staticData` is untyped and a route may store
+*   anything under the same name. It returns the checked object itself, so every read of one route
+*   returns one reference.
 * @param match - A match, as `useMatches` returns one.
-* @returns The id and the menu entry it carries, or nothing.
+* @returns The id and the menu entry, or nothing.
 */
 function declaredOf(match) {
 	const { staticData } = match;
@@ -279,99 +330,147 @@ function declaredOf(match) {
 	return data;
 }
 /**
-* Reads the name the deepest named route the page is on goes by.
+* Reads the id of the deepest named route the page is on.
 *
 * @remarks
-*   The deepest match rather than the first, because a named route nested under another is the page
-*   a person is looking at. A page drawn entirely from unnamed routes returns nothing.
-*   The selector returns the object the route carries rather than a copy of it. A route's static
-*   data is fixed once the tree is built, so the reference is the same one until a different route
-*   matches, and a navigation that left the page alone re-renders nothing.
-* @returns The id and the menu entry, or nothing where no matched route carries either.
+*   The hook reads the deepest match, because a named route nested under another is the page a
+*   person is looking at. A page rendered from unnamed routes alone returns nothing. The selector
+*   returns the object the route stores, not a copy. A route's static data is fixed once the tree
+*   is built, so the reference changes only when a different route matches, and a navigation that
+*   keeps the page does not render it again.
+* @returns The id and the menu entry, or nothing where no matched route has an id.
 */
 function useDeclaredRoute() {
-	const $ = c(2);
-	if ($[0] !== "c34505ba38c7bb5d21152f0227a85b702acb84f4f34b78cbac48bf4ade5e9158") {
-		for (let $i = 0; $i < 2; $i += 1) $[$i] = Symbol.for("react.memo_cache_sentinel");
-		$[0] = "c34505ba38c7bb5d21152f0227a85b702acb84f4f34b78cbac48bf4ade5e9158";
-	}
+	const $ = c(1);
 	let t0;
-	if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
 		t0 = { select: _temp };
-		$[1] = t0;
-	} else t0 = $[1];
-	return (0, tanstack_exports.useMatches)(t0);
+		$[0] = t0;
+	} else t0 = $[0];
+	return useMatches$1(t0);
+}
+function _temp(matches) {
+	return deepestIn(matches)?.declared;
 }
 /**
-* Reads the parameters of the page being drawn, typed by the reference the caller holds.
+* Reads the parameters of the page being rendered, typed by the reference the caller passes.
 *
 * @remarks
-*   A compiled route is outside the tree an application registered, so `useParams` types against a
-*   tree the route is not in. The parameters are read off the match instead, and the reference
-*   carries their names. This checks at run time that the page really is the route the reference
-*   names before it makes the claim.
-*   The selector returns the id and the parameters alone, which are strings. Structural sharing
-*   compares them, so a navigation that changed neither re-renders nothing.
-* @param to - A reference to the route the calling component draws.
-* @returns The parameters the route's path named.
-* @throws {@link Error} Where the page being drawn is not the route the reference names.
+*   A compiled route is outside the tree an application registered, so `useParams` types the
+*   parameters against a tree the route is not in. The hook reads them from the match instead, and
+*   the reference types them. It checks at run time that the page is the route of the reference,
+*   and throws where it is not. The selector returns the id and the parameters alone, which are
+*   strings. Structural sharing compares them, so a navigation that changes neither does not render
+*   the page again.
+* @param to - A reference to the route the calling component renders.
+* @returns The parameters of the route's path.
+* @throws {@link Error} Where the page being rendered is not the route of the reference.
 */
-function _temp(matches) {
-	return declaredIn(matches);
-}
 function useRouteParams(to) {
-	const $ = c(2);
-	if ($[0] !== "c34505ba38c7bb5d21152f0227a85b702acb84f4f34b78cbac48bf4ade5e9158") {
-		for (let $i = 0; $i < 2; $i += 1) $[$i] = Symbol.for("react.memo_cache_sentinel");
-		$[0] = "c34505ba38c7bb5d21152f0227a85b702acb84f4f34b78cbac48bf4ade5e9158";
-	}
+	const $ = c(1);
 	let t0;
-	if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
 		t0 = {
 			select: _temp2,
 			structuralSharing: true
 		};
-		$[1] = t0;
-	} else t0 = $[1];
-	const drawn = (0, tanstack_exports.useMatches)(t0);
-	const wanted = idOf(to);
-	if (drawn.id !== wanted) throw new Error(`The page being drawn is not ${wanted}, so its parameters are not that route's.`);
-	return drawn.params;
+		$[0] = t0;
+	} else t0 = $[0];
+	const current = useMatches$1(t0);
+	if (current === void 0 || current.id !== idOf(to)) throw refused(to, "parameters");
+	return current.params;
+}
+function _temp2(matches) {
+	return paramsIn(matches);
 }
 /**
-* Reads the name the deepest matched route that carries one goes by.
+* Reads the search of the page being rendered, typed by the reference the caller passes.
 *
-* @param matches - Every matched route, outermost first.
-* @returns The id and the menu entry it carries, or nothing where no match carries an id.
-*/
-function _temp2(matches) {
-	return drawnIn(matches);
+* @remarks
+*   A compiled route is outside the tree an application registered, so `useSearch` types the search
+*   against a tree the route is not in. The hook reads it from the match instead, and the reference
+*   types it. It checks at run time that the page is the route of the reference, and throws where
+*   it is not. The value is the match's `_strictSearch`: what the validators of the route and the
+*   routes above it returned. The hook leaves out the keys of the address that the validators left
+*   out, so the page never receives a value the validator refused under the validator's type.
+*   Structural sharing compares the search, so the page does not render again after a navigation
+*   that left it equal.
+* @param to - A reference to the route the calling component renders.
+* @returns The search the route's validator returned.
+* @throws {@link Error} Where the page being rendered is not the route of the reference.
+*/
+function useRouteSearch(to) {
+	const $ = c(1);
+	const declared = useDeclaredRoute();
+	let t0;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t0 = {
+			select: _temp3,
+			structuralSharing: true
+		};
+		$[0] = t0;
+	} else t0 = $[0];
+	const search = useMatches$1(t0);
+	if (declared?.id !== idOf(to)) throw refused(to, "search");
+	return search;
 }
-function declaredIn(matches) {
-	let deepest;
-	for (const match of matches) {
-		const declared = declaredOf(match);
-		if (declared !== void 0) deepest = declared;
-	}
-	return deepest;
+function _temp3(matches) {
+	return searchIn(matches);
 }
 /**
-* Reads the id and the parameters of the deepest matched route that carries an id.
+* Builds the error a hook throws when the page being rendered is not the route of a reference.
+*
+* @param to - The reference the caller passed.
+* @param what - The value the hook was asked for, which the message mentions.
+* @returns The error.
+*/
+function refused(to, what) {
+	return /* @__PURE__ */ new Error(`The page being rendered is not ${idOf(to)}, so it cannot return that route's ${what}.`);
+}
+/**
+* Returns the deepest matched route that has an id, with its declaration.
 *
 * @param matches - Every matched route, outermost first.
-* @returns The id and the parameters, with no id where none of them carries one.
+* @returns The deepest declared match, or nothing where no match has an id.
 */
-function drawnIn(matches) {
-	let deepest = { params: {} };
+function deepestIn(matches) {
+	let deepest;
 	for (const match of matches) {
 		const declared = declaredOf(match);
 		if (declared !== void 0) deepest = {
-			id: declared.id,
-			params: match.params
+			declared,
+			match
 		};
 	}
 	return deepest;
 }
+/**
+* Reads the id and the parameters of the deepest declared match.
+*
+* @param matches - Every matched route, outermost first.
+* @returns The id and the parameters, or nothing where no match has an id.
+*/
+function paramsIn(matches) {
+	const deepest = deepestIn(matches);
+	return deepest === void 0 ? deepest : {
+		id: deepest.declared.id,
+		params: deepest.match.params
+	};
+}
+/**
+* Reads the validated search of the deepest declared match.
+*
+* @remarks
+*   The library's structural sharing compares plain objects and arrays deeply and any other value
+*   by reference, so it shares a search of any values. Its types accept only a selection whose type
+*   excludes functions. The type of a search of unknown values does not, so the function types the
+*   search as strings.
+* @param matches - Every matched route, outermost first.
+* @returns The search, or nothing where no match has an id.
+*/
+function searchIn(matches) {
+	return deepestIn(matches)?.match._strictSearch;
+}
 //#endregion
 //#region src/defaults.ts
 /**
@@ -388,21 +487,188 @@ function drawnIn(matches) {
 *   already replaced.
 *   Scroll position is restored on the way back, because a person returning to a list expects to be
 *   where they left it rather than at the top.
+*   The window is moved in one step, on the way back and to the top of a new page alike. The
+*   library moves it with the page's own scroll behaviour by default, and the foundation sets that
+*   to smooth for a link into the page, so a page opened from a scrolled one glided in from above.
 */
 const routerDefaults = {
 	defaultPreload: "intent",
 	defaultPreloadStaleTime: 0,
-	scrollRestoration: true
+	scrollRestoration: true,
+	scrollRestorationBehavior: "instant"
 };
 //#endregion
+//#region src/href.ts
+/**
+* Resolves a declared route id to the path a link navigates to.
+*/
+/**
+* Resolves a target to a path, with the parameters of the path filled in, for the functions of
+* this package that type their parameters by the target.
+*
+* @remarks
+*   Throwing is deliberate in all three cases. Interpolation otherwise writes `undefined` where a
+*   parameter was not given, and a route that no router has processed has no path at all. A link
+*   that navigates somewhere wrong is worse than one that fails where somebody wrote it. The router
+*   parses a path with parameters into segments, and a path without parameters is its own href.
+* @param map - The map every route is named in.
+* @param to - A reference to the route, or the bare id of one.
+* @param params - The parameters of the path.
+* @returns The path, ready to navigate to.
+* @throws {@link Error} Where the map contains no such id, where no router has processed the tree
+*   the route was placed in, or where a parameter of the path is missing.
+*/
+function resolveHref(map, to, params) {
+	const id = idOf(to);
+	const route = map.get(id);
+	if (route === void 0) throw new Error(`No route is declared with the id ${id}.`);
+	if (route.fullPath === void 0) throw new Error(`The route ${id} has no path yet, because no router has processed the tree it was placed in.`);
+	const path = route.fullPath;
+	const segments = getRouteSegments(route);
+	if (segments === void 0) return path;
+	const given = params ?? {};
+	if (hasMissingPathParams(segments, given)) throw new Error(`The route ${id} names a parameter that was not given.`);
+	return interpolatePath(path, segments, given);
+}
+/**
+* Resolves a declared id to a path, with the parameters of the path filled in.
+*
+* @remarks
+*   The parameters are required where a typed reference's path has a required one, so the compiler
+*   refuses such a call without them. A bare id takes them at will, and the call throws where one
+*   is missing.
+* @param map - The map every route is named in.
+* @param to - A reference to the route, or the bare id of one.
+* @param params - The parameters of the path, typed by the reference where one was given.
+* @returns The path, ready to navigate to.
+* @throws {@link Error} Where the map contains no such id, where no router has processed the tree
+*   the route was placed in, or where a parameter of the path is missing.
+*/
+function routeHref(map, to, ...params) {
+	return resolveHref(map, to, params[0]);
+}
+/**
+* Reads the map every route is named in, from the router's own context.
+*
+* @remarks
+*   The router's own context passes the map to a component, so an application mounts no provider
+*   of this package's own to make a link by id work. Where the route is chosen after the render,
+*   pass the map to `routeHref` inside the event handler, because a hook cannot run there.
+* @returns Every id the router knows, against the route that serves it.
+* @throws {@link Error} Where the router was built without one.
+*/
+function useRouteMap() {
+	const $ = c(1);
+	let t0;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t0 = { strict: false };
+		$[0] = t0;
+	} else t0 = $[0];
+	const context = useRouteContext$1(t0);
+	if (context.routes === void 0) throw new Error("The router context contains no route map, so no id can be resolved. Pass one to routerOptions.");
+	return context.routes;
+}
+/**
+* Resolves a reference to a path, through the map in the router context.
+*
+* @remarks
+*   A hook, so the route has to be known while the component renders. Use `useRouteMap` where the
+*   route is chosen later, such as in the handler of a row a person clicked. The parameters are
+*   required as `routeHref` requires them.
+* @param to - A reference to the route, or the bare id of one.
+* @param params - The parameters of the path, typed by the reference where one was given.
+* @returns The path, ready to navigate to.
+* @throws {@link Error} Where no map is in the router context, where the map contains no such id,
+*   or where a parameter of the path is missing.
+*/
+function useRouteHref(to, ...t0) {
+	const $ = c(4);
+	const params = t0;
+	const t1 = useRouteMap();
+	let t2;
+	if ($[0] !== params[0] || $[1] !== t1 || $[2] !== to) {
+		t2 = resolveHref(t1, to, params[0]);
+		$[0] = params[0];
+		$[1] = t1;
+		$[2] = to;
+		$[3] = t2;
+	} else t2 = $[3];
+	return t2;
+}
+//#endregion
+//#region src/link.tsx
+/**
+* Links to a route by the id a manifest declared it under.
+*
+* @remarks
+*   A declared route is outside the tree an application registered, so `Link` refuses its path at
+*   compile time. This resolves the id at run time and passes the library a plain string, which is
+*   the one place in this package where the compiler does not check a path. The search passes to
+*   the library's `Link` beside the path.
+* @param props - The declared id, its parameters, its search, and whatever else the library's
+*   `Link` takes.
+* @returns An anchor to the resolved path.
+*/
+function RouteLink(props) {
+	const $ = c(15);
+	let params;
+	let rest;
+	let search;
+	let to;
+	if ($[0] !== props) {
+		({params, search, to, ...rest} = props);
+		$[0] = props;
+		$[1] = params;
+		$[2] = rest;
+		$[3] = search;
+		$[4] = to;
+	} else {
+		params = $[1];
+		rest = $[2];
+		search = $[3];
+		to = $[4];
+	}
+	let t0;
+	if ($[5] !== search) {
+		t0 = search === void 0 ? {} : { search };
+		$[5] = search;
+		$[6] = t0;
+	} else t0 = $[6];
+	const t1 = useRouteMap();
+	let t2;
+	if ($[7] !== params || $[8] !== t1 || $[9] !== to) {
+		t2 = resolveHref(t1, to, params);
+		$[7] = params;
+		$[8] = t1;
+		$[9] = to;
+		$[10] = t2;
+	} else t2 = $[10];
+	let t3;
+	if ($[11] !== rest || $[12] !== t0 || $[13] !== t2) {
+		t3 = /* @__PURE__ */ jsx(Link, {
+			...rest,
+			...t0,
+			to: t2
+		});
+		$[11] = rest;
+		$[12] = t0;
+		$[13] = t2;
+		$[14] = t3;
+	} else t3 = $[14];
+	return t3;
+}
+//#endregion
 //#region src/map.ts
 /**
-* Gives a route written in code the id everything else links to it by.
+* Reads the routes of a tree, whoever built them.
+*/
+/**
+* Gives a route written in code the id that everything else links to it by.
 *
 * @remarks
-*   A route carries its id in `staticData`, which is where the compiler writes the id of a route
-*   built from a declaration. One mechanism names both, so a link does not need to know which of
-*   the two it is pointing at.
+*   A route keeps its id in `staticData`, where the compiler writes the id of a route built from a
+*   declaration. The same field identifies both kinds, so a link does not need to know which kind
+*   it points at.
 * @param id - The id to name the route under.
 * @returns The static data to spread into `createRoute`.
 */
@@ -410,16 +676,16 @@ function namedRoute(id) {
 	return { staticData: { declared: { id } } };
 }
 /**
-* Reads every id a tree names, against the route that draws it.
+* Reads every id of a tree, against the route that renders it.
 *
 * @remarks
-*   Derived from the tree rather than collected beside it, so a route written in code and a route
-*   built from a declaration reach the map the same way. The walk also reports two routes that
-*   serve one URL, which a development build reports as a duplicate route and a production build
-*   resolves by keeping the first and dropping the rest in silence.
+*   The map derives from the tree and is not collected beside it, so a route written in code and a
+*   route built from a declaration enter the map the same way. The walk also reports two routes
+*   that serve one URL. A development build reports them as a duplicate route, and a production
+*   build keeps the first and drops the rest without a report.
 * @param tree - The assembled tree, as `createRouter` takes it.
 * @returns Every id, against its route.
-* @throws {@link Error} Where two routes carry one id, or where two serve one path under a shared
+* @throws {@link Error} Where two routes have one id, or where two serve one path under a shared
 *   parent.
 */
 function routeMap(tree) {
@@ -428,11 +694,11 @@ function routeMap(tree) {
 	return named;
 }
 /**
-* Walks a route's descendants, naming each one and refusing a repeated path.
+* Walks a route's descendants, records the id of each one and refuses a repeated path.
 *
 * @param route - The route whose children are read.
 * @param named - The map built so far.
-* @throws {@link Error} Where two routes carry one id, or where two serve one path here.
+* @throws {@link Error} Where two routes have one id, or where two serve one path at this level.
 */
 function collect(route, named) {
 	const claimed = /* @__PURE__ */ new Set();
@@ -446,11 +712,11 @@ function collect(route, named) {
 	}
 }
 /**
-* Records the id a route carries, where it carries one.
+* Records the id of a route that has one.
 *
 * @param route - The route to read.
 * @param named - The map built so far.
-* @throws {@link Error} Where another route already carries the same id.
+* @throws {@link Error} Where another route has the same id already.
 */
 function identify(route, named) {
 	const options = route.options;
@@ -469,17 +735,16 @@ function identify(route, named) {
 *   `/home`.
 */
 function normalised(path) {
-	const trimmed = (0, tanstack_exports.trimPath)(path);
+	const trimmed = trimPath(path);
 	return trimmed === "/" ? trimmed : `/${trimmed}`;
 }
 /**
-* Lists the paths a route's descendants serve at its own level, each written the one way the
+* Lists the paths that a route's descendants serve at its own level, each written the one way the
 * library reads it.
 *
 * @remarks
-*   A pathless route consumes no segment of a URL, so whatever sits below one is served at the
-*   level of the route above it. The walk goes through a pathless route rather than stopping at
-*   it.
+*   A pathless route consumes no segment of a URL, so the routes below one are served at the level
+*   of the route above it. The walk goes through a pathless route and does not stop at it.
 * @param route - The route whose level is being read.
 * @returns One path per descendant served at this level.
 */
@@ -494,13 +759,13 @@ function pathsUnder(route) {
 	return paths;
 }
 /**
-* Reads the children a route holds.
+* Reads the children of a route.
 *
 * @remarks
-*   The library types a route's children as `any`, because a typed tree names each one. Nothing
-*   here reads more than the options every route carries.
+*   The library types a route's children as `any`, because a typed tree types each one. The walk
+*   reads only the options that every route has.
 * @param route - The route to read.
-* @returns Its children, or none where it holds none.
+* @returns Its children, or an empty list where it has none.
 */
 function childrenOf(route) {
 	return route.children ?? [];
@@ -528,138 +793,12 @@ function routerOptions(context) {
 	};
 }
 //#endregion
-//#region src/href.ts
-/**
-* Resolves a declared id to a path, with the parameters the path names filled in.
-*
-* @remarks
-*   Throwing is deliberate in all three cases. Interpolation otherwise returns a path with a
-*   literal `$id` still in it, and a route the library has not worked a full path out for yet
-*   returns the site root. A link that navigates somewhere wrong is worse than one that fails where
-*   somebody wrote it.
-* @param map - The map every route is named in.
-* @param to - A reference to the route, or the bare id one carries.
-* @param params - The parameters the path names, typed by the reference where one was given.
-* @returns The path, ready to navigate to.
-* @throws {@link Error} Where the map holds no such id, where no router has processed the tree the
-*   route was placed in, or where a parameter the path names is missing.
-*/
-function routeHref(map, to, params) {
-	const id = idOf(to);
-	const route = map.get(id);
-	if (route === void 0) throw new Error(`No route is declared with the id ${id}.`);
-	if (route.fullPath === void 0) throw new Error(`The route ${id} has no path yet, because no router has processed the tree it was placed in.`);
-	const { interpolatedPath, isMissingParams } = (0, tanstack_exports.interpolatePath)({
-		params: params ?? {},
-		path: route.fullPath
-	});
-	if (isMissingParams) throw new Error(`The route ${id} names a parameter that was not given.`);
-	return interpolatedPath;
-}
-/**
-* Reads the map every route is named in, from the router's own context.
-*
-* @remarks
-*   The map reaches a component through the router's own context rather than a provider of this
-*   package's own, so an application mounts nothing extra to make a link by id work.
-*   Take the map rather than a resolved path where the route is chosen after the render: a hook
-*   cannot run inside an event handler, and `routeHref` can.
-* @returns Every id the router knows, against the route that serves it.
-* @throws {@link Error} Where the router was built without one.
-*/
-function useRouteMap() {
-	const $ = c(2);
-	if ($[0] !== "f9b02b582b5a25eab6d75eb5816b5bc3afae5d65206cbae9cdf2983138656269") {
-		for (let $i = 0; $i < 2; $i += 1) $[$i] = Symbol.for("react.memo_cache_sentinel");
-		$[0] = "f9b02b582b5a25eab6d75eb5816b5bc3afae5d65206cbae9cdf2983138656269";
-	}
-	let t0;
-	if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
-		t0 = { strict: false };
-		$[1] = t0;
-	} else t0 = $[1];
-	const context = (0, tanstack_exports.useRouteContext)(t0);
-	if (context.routes === void 0) throw new Error("The router context holds no route map, so no id can be resolved. Pass one to routerOptions.");
-	return context.routes;
-}
-/**
-* Resolves a reference to a path, through the map the router context holds.
-*
-* @remarks
-*   A hook, so the route has to be known while the component renders. Use `useRouteMap` where the
-*   route is chosen later, such as in the handler of a row a person clicked.
-* @param to - A reference to the route, or the bare id one carries.
-* @param params - The parameters the path names, typed by the reference where one was given.
-* @returns The path, ready to navigate to.
-* @throws {@link Error} Where no map is in the router context, where it holds no such id, or where
-*   a parameter the path names is missing.
-*/
-function useRouteHref(to, params) {
-	const $ = c(5);
-	if ($[0] !== "f9b02b582b5a25eab6d75eb5816b5bc3afae5d65206cbae9cdf2983138656269") {
-		for (let $i = 0; $i < 5; $i += 1) $[$i] = Symbol.for("react.memo_cache_sentinel");
-		$[0] = "f9b02b582b5a25eab6d75eb5816b5bc3afae5d65206cbae9cdf2983138656269";
-	}
-	const t0 = useRouteMap();
-	let t1;
-	if ($[1] !== params || $[2] !== t0 || $[3] !== to) {
-		t1 = routeHref(t0, to, params);
-		$[1] = params;
-		$[2] = t0;
-		$[3] = to;
-		$[4] = t1;
-	} else t1 = $[4];
-	return t1;
-}
-//#endregion
-//#region src/link.tsx
+//#region src/root.ts
 /**
-* Links to a route by the id a manifest declared it under.
-*
-* @remarks
-*   A declared route is outside the tree an application registered, so `Link` refuses its path at
-*   compile time. This resolves the id at run time and hands the library a plain string, which is
-*   the one place in this package where a path is not checked by the compiler.
-* @param props - The declared id, its parameters, and whatever else the library's `Link` takes.
-* @returns An anchor to the resolved path.
+* Builds the root route an application's tree starts from, typed for this design system's context.
 */
-function RouteLink(t0) {
-	const $ = c(8);
-	if ($[0] !== "3b765330fa72187c6e8334d53589d37c8de26d61a15e49011148486e2debe539") {
-		for (let $i = 0; $i < 8; $i += 1) $[$i] = Symbol.for("react.memo_cache_sentinel");
-		$[0] = "3b765330fa72187c6e8334d53589d37c8de26d61a15e49011148486e2debe539";
-	}
-	let params;
-	let rest;
-	let to;
-	if ($[1] !== t0) {
-		({params, to, ...rest} = t0);
-		$[1] = t0;
-		$[2] = params;
-		$[3] = rest;
-		$[4] = to;
-	} else {
-		params = $[2];
-		rest = $[3];
-		to = $[4];
-	}
-	const t1 = useRouteHref(to, params);
-	let t2;
-	if ($[5] !== rest || $[6] !== t1) {
-		t2 = /* @__PURE__ */ jsx(tanstack_exports.Link, {
-			...rest,
-			to: t1
-		});
-		$[5] = rest;
-		$[6] = t1;
-		$[7] = t2;
-	} else t2 = $[7];
-	return t2;
-}
-//#endregion
-//#region src/root.ts
 /**
-* Builds a root route whose context holds whatever the application states and the route map.
+* Builds a root route whose context contains whatever the application states and the route map.
 *
 * @remarks
 *   Calling the library's `createRootRoute` instead leaves the context typed as empty, and the
@@ -668,22 +807,7 @@ function RouteLink(t0) {
 * @returns The root route factory, to call with the route's own options.
 */
 function createAppRootRoute() {
-	return (0, tanstack_exports.createRootRouteWithContext)();
-}
-__reExport(/* @__PURE__ */ __exportAll({
-	RouteLink: () => RouteLink,
-	compileRoutes: () => compileRoutes,
-	createAppRootRoute: () => createAppRootRoute,
-	declaredOf: () => declaredOf,
-	namedRoute: () => namedRoute,
-	routeHref: () => routeHref,
-	routeMap: () => routeMap,
-	routerDefaults: () => routerDefaults,
-	routerOptions: () => routerOptions,
-	useDeclaredRoute: () => useDeclaredRoute,
-	useRouteHref: () => useRouteHref,
-	useRouteMap: () => useRouteMap,
-	useRouteParams: () => useRouteParams
-}), tanstack_exports);
+	return createRootRouteWithContext();
+}
 //#endregion
-export { RouteLink, compileRoutes, createAppRootRoute, declaredOf, namedRoute, routeHref, routeMap, routerDefaults, routerOptions, useDeclaredRoute, useRouteHref, useRouteMap, useRouteParams };
+export { Navigate, Outlet, RouteLink, RouterContextProvider, RouterProvider, basepathOf, compileRoutes, createAppRootRoute, createLink, createMemoryHistory, createRootRoute, createRoute, createRouter, declaredOf, isNotFound, isRedirect, namedRoute, notFound, redirect, routeHref, routeMap, routerDefaults, routerOptions, useChildMatches, useDeclaredRoute, useLinkProps, useLocation, useMatches, useNavigate, useRouteContext, useRouteHref, useRouteMap, useRouteParams, useRouteSearch, useRouter, useRouterState };