@stealthscale/provider-router 0.1.0 → 0.4.1

package/dist/shared-D7o15Y7B.js

@@ -0,0 +1,813 @@
+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";
+//#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.
+*/
+/**
+* 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 renders.
+*/
+function pageOf(component) {
+	return "load" in component ? lazyRouteComponent(component.load, component.export) : component;
+}
+/**
+* Returns a component that renders a layout around the route below it.
+*
+* @param layout - The layout component the caller registered.
+* @param options - The options the declaration stated for this layout.
+* @returns A component the pathless route renders.
+*/
+function framed(layout, options) {
+	/**
+	* Renders the layout around the route below it.
+	*
+	* @returns The layout, with the outlet inside it.
+	*/
+	return function Layout() {
+		return createElement(layout, { options }, createElement(Outlet));
+	};
+}
+/**
+* Records a route as a child of another, or as one the caller places itself.
+*
+* @param building - The state this compilation has built up.
+* @param under - The route it hangs under.
+* @param route - The route being placed.
+*/
+function place(building, under, route) {
+	if (under === building.options.parent) {
+		building.top.push(route);
+		return;
+	}
+	const siblings = building.children.get(under) ?? [];
+	siblings.push(route);
+	building.children.set(under, siblings);
+}
+/**
+* Returns an id no sibling of a route has used yet.
+*
+* @param building - The state this compilation has built up.
+* @param under - The route the id has to be unique among the children of.
+* @param name - The layout's name, which the id is derived from.
+* @returns The id, suffixed where the plain one is already used.
+*/
+function freeId(building, under, name) {
+	const used = building.taken.get(under) ?? /* @__PURE__ */ new Set();
+	building.taken.set(under, used);
+	let id = `_${name}`;
+	let next = 2;
+	while (used.has(id)) {
+		id = `_${name}${String(next)}`;
+		next += 1;
+	}
+	used.add(id);
+	return id;
+}
+/**
+* Builds the pathless routes a declaration's layouts need, reusing one already built.
+*
+* @remarks
+*   Two declarations share a frame where they name the same layouts with the same options. A frame
+*   is a route, so two declarations wanting different options need two of them. The key is the JSON
+*   of the names and the options together, which no pair of different chains can produce.
+* @param building - The state this compilation has built up.
+* @param declaration - The declaration whose layouts are being built.
+* @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 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 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();
+		building.frames.set(current, built);
+		const existing = built.get(key);
+		const above = current;
+		if (existing === void 0) {
+			const frame = createRoute({
+				component: framed(layout, declaration.layoutOptions),
+				getParentRoute: () => above,
+				id: freeId(building, above, name)
+			});
+			place(building, above, frame);
+			built.set(key, frame);
+			current = frame;
+		} else current = existing;
+		building.applied.set(current, [...names]);
+	}
+	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, which renders the declaration's page inside the frames it named.
+*/
+function routeOf(building, declaration, under) {
+	const { errorComponent, notFoundComponent } = building.options;
+	const { id, loader, navigation, when } = declaration;
+	return createRoute({
+		component: pageOf(declaration.component),
+		getParentRoute: () => under,
+		path: declaration.path,
+		staticData: { declared: {
+			id,
+			...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) },
+		...loader === void 0 ? {} : loading(loader)
+	});
+}
+/**
+* Builds the check a route runs before it is entered.
+*
+* @remarks
+*   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 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 ({ context, location }) => {
+		if (!evaluate(when, context, location)) throw notFound();
+	};
+}
+/**
+* Compiles one declaration, and whatever it nests under, first.
+*
+* @param building - The state this compilation has built up.
+* @param declaration - The route being compiled.
+* @param seen - The ids being compiled further up this chain, which detects a cycle.
+* @returns The route the declaration compiled to.
+* @throws {@link Error} Where a parent is absent or the parents form a cycle.
+*/
+function compiledFor(building, declaration, seen) {
+	const already = building.compiled.get(declaration.id);
+	if (already !== void 0) return already;
+	if (seen.has(declaration.id)) throw new Error(`The route ${declaration.id} nests under itself.`);
+	const above = declaration.parent;
+	let under = building.options.parent;
+	if (above !== void 0) {
+		const owner = building.byId.get(above);
+		if (owner === void 0) throw new Error(`The route ${declaration.id} names the parent ${above}, which is absent.`);
+		under = compiledFor(building, owner, /* @__PURE__ */ new Set([...seen, declaration.id]));
+	}
+	const inside = framing(building, declaration, under);
+	const route = routeOf(building, declaration, inside);
+	place(building, inside, route);
+	building.applied.set(route, building.applied.get(inside) ?? []);
+	building.compiled.set(declaration.id, route);
+	return route;
+}
+/**
+* Refuses a declaration this package cannot honour, before any of them is compiled.
+*
+* @remarks
+*   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 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.
+*
+* @param declarations - The routes to compile.
+* @returns Each declaration against its id.
+* @throws {@link Error} Where two declarations share an id.
+*/
+function indexed(declarations) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const declaration of declarations) {
+		if (byId.has(declaration.id)) throw new Error(`Two routes declare the id ${declaration.id}.`);
+		byId.set(declaration.id, declaration);
+	}
+	return byId;
+}
+/**
+* Compiles declarations into routes under the parent a caller states.
+*
+* @remarks
+*   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 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);
+	const building = {
+		applied: /* @__PURE__ */ new Map(),
+		byId: indexed(declarations),
+		children: /* @__PURE__ */ new Map(),
+		compiled: /* @__PURE__ */ new Map(),
+		frames: /* @__PURE__ */ new Map(),
+		options,
+		taken: /* @__PURE__ */ new Map(),
+		top: []
+	};
+	for (const declaration of declarations) compiledFor(building, declaration, /* @__PURE__ */ new Set());
+	for (const [route, children] of building.children) route.addChildren(children);
+	return building.top;
+}
+//#endregion
+//#region src/reference.ts
+/**
+* Reads the id of a target.
+*
+* @param to - A reference, or the bare id.
+* @returns The full id the route was declared under.
+*/
+function idOf(to) {
+	return typeof to === "string" ? to : to.id;
+}
+//#endregion
+//#region src/declared.ts
+/**
+* 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 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, or nothing.
+*/
+function declaredOf(match) {
+	const { staticData } = match;
+	const data = "declared" in staticData ? staticData.declared : void 0;
+	if (typeof data !== "object" || data === null) return void 0;
+	if (!("id" in data) || typeof data.id !== "string") return void 0;
+	return data;
+}
+/**
+* Reads the id of the deepest named route the page is on.
+*
+* @remarks
+*   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(1);
+	let t0;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t0 = { select: _temp };
+		$[0] = t0;
+	} else t0 = $[0];
+	return useMatches(t0);
+}
+function _temp(matches) {
+	return deepestIn(matches)?.declared;
+}
+/**
+* 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 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 useRouteParams(to) {
+	const $ = c(1);
+	let t0;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t0 = {
+			select: _temp2,
+			structuralSharing: true
+		};
+		$[0] = t0;
+	} else t0 = $[0];
+	const current = useMatches(t0);
+	if (current === void 0 || current.id !== idOf(to)) throw refused(to, "parameters");
+	return current.params;
+}
+function _temp2(matches) {
+	return paramsIn(matches);
+}
+/**
+* Reads the search of the page being rendered, typed by the reference the caller passes.
+*
+* @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(t0);
+	if (declared?.id !== idOf(to)) throw refused(to, "search");
+	return search;
+}
+function _temp3(matches) {
+	return searchIn(matches);
+}
+/**
+* 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 deepest declared match, or nothing where no match has an id.
+*/
+function deepestIn(matches) {
+	let deepest;
+	for (const match of matches) {
+		const declared = declaredOf(match);
+		if (declared !== void 0) deepest = {
+			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
+/**
+* How a router in this design system behaves before an application says otherwise.
+*/
+/**
+* The options every application's router starts from, spread before its own.
+*
+* @remarks
+*   A route preloads on intent, which is when the pointer rests on a link or the link takes focus,
+*   so a page is usually loaded before it is asked for.
+*   A preloaded route never counts as fresh on its own. The query client decides freshness for
+*   everything it loads, and a router keeping its own staleness would serve a copy the client had
+*   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,
+	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(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
+/**
+* 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 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`.
+*/
+function namedRoute(id) {
+	return { staticData: { declared: { id } } };
+}
+/**
+* Reads every id of a tree, against the route that renders it.
+*
+* @remarks
+*   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 have one id, or where two serve one path under a shared
+*   parent.
+*/
+function routeMap(tree) {
+	const named = /* @__PURE__ */ new Map();
+	collect(tree, named);
+	return named;
+}
+/**
+* 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 have one id, or where two serve one path at this level.
+*/
+function collect(route, named) {
+	const claimed = /* @__PURE__ */ new Set();
+	for (const path of pathsUnder(route)) {
+		if (claimed.has(path)) throw new Error(`Two routes serve the path ${path} under the same parent.`);
+		claimed.add(path);
+	}
+	for (const child of childrenOf(route)) {
+		identify(child, named);
+		collect(child, named);
+	}
+}
+/**
+* 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 has the same id already.
+*/
+function identify(route, named) {
+	const options = route.options;
+	const data = "staticData" in options ? options.staticData : void 0;
+	const declared = typeof data === "object" && data !== null ? declaredOf({ staticData: data }) : void 0;
+	if (declared === void 0) return;
+	if (named.has(declared.id)) throw new Error(`Two routes are named ${declared.id}.`);
+	named.set(declared.id, route);
+}
+/**
+* Writes a path the one way the library reads it: the slashes around it trimmed, and one leading
+* slash put back.
+*
+* @remarks
+*   `home`, `/home` and `home/` are one route to the library, so the check reads all three as
+*   `/home`.
+*/
+function normalised(path) {
+	const trimmed = trimPath(path);
+	return trimmed === "/" ? trimmed : `/${trimmed}`;
+}
+/**
+* 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 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.
+*/
+function pathsUnder(route) {
+	const paths = [];
+	for (const child of childrenOf(route)) {
+		const options = child.options;
+		const path = "path" in options ? options.path : void 0;
+		if (typeof path === "string") paths.push(normalised(path));
+		else paths.push(...pathsUnder(child));
+	}
+	return paths;
+}
+/**
+* Reads the children of a route.
+*
+* @remarks
+*   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 an empty list where it has none.
+*/
+function childrenOf(route) {
+	return route.children ?? [];
+}
+//#endregion
+//#region src/options.ts
+/**
+* Collects what every router in this design system starts from, as an object a caller spreads.
+*/
+/**
+* Collects the options every router in this design system starts from.
+*
+* @remarks
+*   An object to spread rather than a factory that calls `createRouter`. The library states
+*   forty-eight router options, and a factory would expose the few it thought of and hide the rest.
+*   Spreading leaves every one of them the caller's to set, the four stated here included.
+* @param context - The context the router hands a loader, holding the route map where a caller compiled
+*   declarations.
+* @returns The options, to spread into `createRouter` before the caller's own.
+*/
+function routerOptions(context) {
+	return {
+		...routerDefaults,
+		context
+	};
+}
+//#endregion
+//#region src/root.ts
+/**
+* Builds the root route an application's tree starts from, typed for this design system's context.
+*/
+/**
+* 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
+*   first sign of it is `createRouter` refusing the options `routerOptions` returned. The error
+*   then names the router rather than the root, which is the file that has to change.
+* @returns The root route factory, to call with the route's own options.
+*/
+function createAppRootRoute() {
+	return createRootRouteWithContext();
+}
+//#endregion
+export { routerDefaults as A, routerOptions as C, routeHref as D, RouteLink as E, compileRoutes as F, basepathOf as I, useDeclaredRoute as M, useRouteParams as N, useRouteHref as O, useRouteSearch as P, createAppRootRoute as S, routeMap as T, useMatches$1 as _, createLink as a, useRouter as b, createRoute$1 as c, isRedirect as d, notFound$1 as f, useLocation as g, useLinkProps as h, RouterProvider as i, declaredOf as j, useRouteMap as k, createRouter as l, useChildMatches as m, Outlet$1 as n, createMemoryHistory as o, redirect as p, RouterContextProvider as r, createRootRoute as s, Navigate as t, isNotFound as u, useNavigate as v, namedRoute as w, useRouterState as x, useRouteContext$1 as y };