@manyducks.co/dolla 2.0.0 → 3.1.0

package/dist/router/types.d.ts

@@ -0,0 +1,152 @@
+import type { Setter, Getter, MarkupNode, Renderable, View } from "../core";
+import type { Context } from "../core/context";
+import type { Match } from "./utils";
+export type Stringable = {
+    toString(): string;
+};
+export type LazyLoader<Props = any> = () => Promise<{
+    default: View<Props>;
+} | View<Props>>;
+export interface LazyView<Props = any> {
+    _lazy: true;
+    load: LazyLoader<Props>;
+}
+export interface Route<Data = any> {
+    /**
+     * The path or path fragment to match.
+     */
+    path: string;
+    /**
+     * Path to redirect to when this route is matched, or a callback function that returns such path.
+     */
+    redirect?: string | ((match: Match) => string) | ((match: Match) => Promise<string>);
+    preload?: (match: Match) => Data | Promise<Data>;
+    /**
+     * View to display when this route is matched.
+     */
+    view?: View<{
+        data?: Data;
+        children: Renderable;
+    }> | LazyView<{
+        data?: Data;
+        children: Renderable;
+    }>;
+    errorView?: View<{
+        error: Error;
+    }>;
+    /**
+     * Subroutes.
+     */
+    routes?: Route[];
+    /**
+     * Arbitrary data you'd like to store on this route.
+     * This object is accessible via `match.meta` on the `$router` API while the route is active.
+     *
+     * In the case of nested routes, data from all layers will be merged into a single data object.
+     */
+    meta?: Record<string | symbol, any>;
+}
+export interface RouteLayer {
+    id: string;
+    pattern: string;
+    view: View<any> | LazyView<any>;
+    errorView?: View<{
+        error: Error;
+    }>;
+    preload?: (match: Match) => any | Promise<any>;
+}
+/**
+ * An active route layer whose markup has been initialized into a view.
+ */
+export interface ActiveLayer {
+    id: string;
+    key: string;
+    node: MarkupNode;
+    context: Context;
+    slot: Getter<MarkupNode | undefined>;
+    setSlot: Setter<MarkupNode | undefined>;
+}
+/**
+ * A log for a single step in the route resolution process.
+ */
+export interface JourneyStep {
+    kind: "match" | "redirect" | "miss";
+    message: string;
+}
+export interface NavigateOptions {
+    /**
+     * Preserve existing query params (if any) when navigating. Defaults to false.
+     * If true, all existing query params are preserved and merged with new ones.
+     * If an array of strings is passed only those keys will be preserved, then merged with any new ones.
+     */
+    preserveQuery?: boolean | string[];
+}
+export interface RouterOptions {
+    routes: Route[];
+    /**
+     * When true, the router will construct routes like "https://www.example.com/#/sub/route" which work without any backend intervention.
+     */
+    hash?: boolean;
+    /**
+     * Persist query params between pages when navigating. Pass an array to specify a list of params that will be preserved.
+     * By default all query params are cleared when navigating to a new URL (equivalent to `false`).
+     */
+    preserveQuery?: boolean | string[];
+}
+export interface Router {
+    /**
+     * The current path as it is displayed in the URL bar (e.g. `/users/123/edit`).
+     */
+    path: Getter<string>;
+    /**
+     * The route pattern that was matched (e.g. `/users/{#id}/edit`), or undefined if no route is currently matched.
+     */
+    pattern: Getter<string | undefined>;
+    /**
+     * The extracted route parameters from the path. (e.g. `{ id: "123" }`)
+     */
+    params: Getter<Record<string, string>>;
+    /**
+     * The current query params.
+     */
+    query: Getter<Record<string, string>>;
+    /**
+     * The contents of the `meta` fields of all matched route layers.
+     */
+    meta: Getter<Record<string, string>>;
+    /**
+     * Represents the loading progress of the current navigation from 0 to 1.
+     * Returns 0 when no navigation is pending.
+     */
+    progress: Getter<number>;
+    /**
+     * Update query params without changing the route.
+     */
+    setQuery(params: Record<string, Stringable>): Record<string, string>;
+    /**
+     * Go back in the page history. Equivalent to hitting the back button.
+     * Steps is the number of times to hit the back button. The default is 1.
+     */
+    back(steps?: number): void;
+    /**
+     * Go forward in the page history. Equivalent to hitting the forward button.
+     * Steps is the number of times to hit the forward button. The default is 1.
+     */
+    forward(steps?: number): void;
+    /**
+     * Push a new route into the page history and navigate to it.
+     */
+    push(path: string): void;
+    /**
+     * Replace the current route in the page history and navigate to it.
+     */
+    replace(path: string): void;
+    /**
+     * Prevents attempted navigations if the condition returns true.
+     */
+    block(guard: () => boolean | Promise<boolean>): () => void;
+    /**
+     * Contains `true` when the current route matches `path`.
+     */
+    isActive(path: string, exact?: boolean): Getter<boolean>;
+}

package/dist/router/utils.d.ts

@@ -0,0 +1,99 @@
+import type { JourneyStep, Route, RouteLayer, Stringable } from "./types.js";
+export interface Match {
+    /**
+     * The path string that triggered this match.
+     */
+    path: string;
+    /**
+     * The pattern satisfied by `path`.
+     */
+    pattern: string;
+    /**
+     * Named params as parsed from `path`.
+     */
+    params: Record<string, string>;
+    /**
+     * Query params as parsed from `path`.
+     */
+    query: Record<string, string>;
+    /**
+     * Freeform data you wish to store with this route.
+     * Merged `data` from all matched layers are available on the router's `match.meta`.
+     */
+    meta: Record<any, any>;
+}
+export interface RouteMatch extends Match {
+    layers: RouteLayer[];
+    redirect?: string | ((match: Match) => string) | ((match: Match) => Promise<string>);
+}
+export type RoutePayload = {
+    pattern: string;
+    meta: Record<any, any>;
+    layers?: RouteLayer[];
+    redirect?: string | ((match: Match) => string) | ((match: Match) => Promise<string>);
+};
+export type RouteMatchOptions = {
+    willMatch?: (route: RoutePayload) => boolean;
+};
+/**
+ * Separates a URL path into multiple fragments.
+ *
+ * @param path - A path string (e.g. `"/api/users/5"`)
+ * @returns an array of fragments (e.g. `["api", "users", "5"]`)
+ */
+export declare function splitPath(path: string): string[];
+/**
+ * Joins multiple URL path fragments into a single string.
+ *
+ * @param parts - One or more URL fragments (e.g. `["api", "users", 5]`)
+ * @returns a joined path (e.g. `"api/users/5"`)
+ */
+export declare function joinPath(parts: {
+    toString(): string;
+}[]): string;
+export declare function resolvePath(base: string, part?: string | null): string;
+export declare function parseQueryParams(query: string): Record<string, string>;
+export declare function mergeQueryParams(previous: Record<string, string>, current: Record<string, Stringable>, preserve?: boolean | string[]): URLSearchParams;
+export declare class RouteNode {
+    staticChildren: Map<string, RouteNode>;
+    numericChild: RouteNode | null;
+    paramChild: RouteNode | null;
+    wildcardChild: RouteNode | null;
+    route?: RoutePayload;
+    paramName?: string;
+    numericName?: string;
+}
+export declare function buildRouteTree(routes: Route[]): RouteNode;
+export declare function matchRoute(rootNode: RouteNode, url: string, options?: RouteMatchOptions): RouteMatch | undefined;
+export interface ResolvedRoute {
+    match?: RouteMatch;
+    journey: JourneyStep[];
+}
+/**
+ * Takes a URL and finds a match, following redirects.
+ */
+export declare function resolveRoute(rootNode: RouteNode, path: string, journey?: JourneyStep[]): Promise<ResolvedRoute>;
+/**
+ * Intercepts links within the root node.
+ *
+ * This is adapted from https://github.com/choojs/nanohref/blob/master/index.js
+ *
+ * @param root - Element under which to intercept link clicks
+ * @param callback - Function to call when a click event is intercepted
+ * @param _window - (optional) Override for global window object
+ */
+export declare function catchLinks(root: Element, callback: (href: string, anchor: HTMLAnchorElement) => void, _window?: Window & typeof globalThis): () => void;
+export declare function expandOptionalPaths(path: string): string[];
+/**
+ * Replace route pattern param placeholders with real matched values.
+ */
+export declare function replaceParams(path: string, params: Record<string, string | number>): string;
+export interface HistoryAdapter {
+    getPath(): string;
+    getSearch(): string;
+    getKey(): string;
+    getIndex(): number;
+    push(url: string): void;
+    replace(url: string): void;
+}
+export declare function createHistoryAdapter(useHash: boolean): HistoryAdapter;

package/dist/router/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/router.js

@@ -1,6 +1,429 @@
-import { c as o, u as t } from "./index-DRJlxs-Q.js";
-export {
-  o as createRouter,
-  t as useRouter
+import { a as e, c as t, f as n, h as r, l as i, n as a, p as o, r as s, t as c, u as l } from "./signals-CMJPGr_M.js";
+import { a as u, b as d, d as f, i as p, l as m, m as h, n as g, p as _, s as v, t as y, v as b } from "./context-B5blupD2.js";
+import { c as x } from "./core-JHktdqjt.js";
+//#region src/router/utils.ts
+function S(e) {
+	return e.split("/").map((e) => e.trim()).filter(Boolean);
+}
+function C(e) {
+	let t = e.map((e) => e.toString()).filter(Boolean).join("/");
+	if (!t) return "";
+	let n = t.startsWith("/"), r = t.split("/"), i = [];
+	for (let e of r) e === "" || e === "." || (e === ".." ? i.length > 0 && i[i.length - 1] !== ".." ? i.pop() : n || i.push("..") : i.push(e));
+	let a = i.join("/");
+	return n && (a = "/" + a), a || (n ? "/" : "");
+}
+function w(e, t = null) {
+	return t ?? (t = e, e = ""), t.startsWith("/") ? C([t]) : C([e, t]);
+}
+function T(e) {
+	return Object.fromEntries(new URLSearchParams(e));
+}
+function E(e, t, n) {
+	let r = {};
+	if (n === !0) Object.assign(r, e);
+	else if (i(n)) for (let t of n) t in e && (r[t] = e[t]);
+	return Object.assign(r, t), new URLSearchParams(r);
+}
+var D = class {
+	staticChildren = /* @__PURE__ */ new Map();
+	numericChild = null;
+	paramChild = null;
+	wildcardChild = null;
+	route;
+	paramName;
+	numericName;
 };
-//# sourceMappingURL=router.js.map
+function O(e) {
+	let i = new D(), a = [];
+	function s(e, t) {
+		let n = S(e), r = i;
+		for (let e of n) if (e === "*") r = r.wildcardChild ??= new D();
+		else if (e.charCodeAt(0) === 123) e.charCodeAt(1) === 35 ? (r = r.numericChild ??= new D(), r.numericName = e.slice(2, -1)) : (r = r.paramChild ??= new D(), r.paramName = e.slice(1, -1));
+		else {
+			let t = e.toLowerCase(), n = r.staticChildren.get(t);
+			n || r.staticChildren.set(t, n = new D()), r = n;
+		}
+		r.route = t;
+	}
+	function c(e, i = [], u = []) {
+		t(n(e) && o(e.path), "Invalid route object");
+		let d = i.map((e) => e.path), f = i.at(-1), p = f && e.meta ? {
+			...f.meta,
+			...e.meta
+		} : e.meta || {}, m = d.length ? C([...d, e.path]) : e.path, h = M(m);
+		if (e.redirect) {
+			t(!e.routes && !e.view, "Route cannot mix redirect with view/routes");
+			let n = e.redirect;
+			o(n) && (n = w(C(d), n), n.startsWith("/") || (n = "/" + n));
+			for (let e of h) {
+				let t = {
+					pattern: e,
+					meta: p,
+					redirect: n
+				};
+				s(e, t), o(n) && a.push(t);
+			}
+			return;
+		}
+		t(e.view || e.routes, "Route must have view, redirect, or routes");
+		let g = e.view || ((e) => e.children);
+		if (!l(g) && !g._lazy) throw TypeError(`Expected view function for ${e.path}`);
+		if (e.routes) {
+			let t = {
+				id: r(),
+				pattern: m,
+				view: g,
+				preload: e.preload,
+				errorView: e.errorView
+			};
+			for (let n of e.routes) c(n, [...i, e], [...u, t]);
+		} else for (let t of h) {
+			let n = {
+				id: r(),
+				pattern: t,
+				view: g,
+				preload: e.preload,
+				errorView: e.errorView
+			};
+			s(t, {
+				pattern: t,
+				meta: p,
+				layers: [...u, n]
+			});
+		}
+	}
+	for (let t of e) c(t);
+	for (let e of a) t(k(i, e.redirect, { willMatch: (t) => t !== e }), `Dead redirect: ${e.pattern} -> ${e.redirect}`);
+	return i;
+}
+function k(e, t, n = {}) {
+	let [r, i] = t.split("?"), a = S(r), o = {};
+	function s(e, t) {
+		if (t === a.length) return e.route && (!n.willMatch || n.willMatch(e.route)) ? {
+			path: r || "/",
+			pattern: e.route.pattern,
+			params: { ...o },
+			query: T(i || ""),
+			meta: e.route.meta,
+			layers: e.route.layers ?? [],
+			redirect: e.route.redirect
+		} : e.wildcardChild && e.wildcardChild.route && (!n.willMatch || n.willMatch(e.wildcardChild.route)) ? {
+			path: r || "/",
+			pattern: e.wildcardChild.route.pattern,
+			params: {
+				...o,
+				wildcard: "/"
+			},
+			query: T(i || ""),
+			meta: e.wildcardChild.route.meta,
+			layers: e.wildcardChild.route.layers ?? [],
+			redirect: e.wildcardChild.route.redirect
+		} : void 0;
+		let c = a[t], l = c.toLowerCase(), u = e.staticChildren.get(l);
+		if (u) {
+			let e = s(u, t + 1);
+			if (e) return e;
+		}
+		if (e.numericChild && !isNaN(Number(c))) {
+			o[e.numericChild.numericName] = c;
+			let n = s(e.numericChild, t + 1);
+			if (n) return n;
+			delete o[e.numericChild.numericName];
+		}
+		if (e.paramChild) {
+			o[e.paramChild.paramName] = decodeURIComponent(c);
+			let n = s(e.paramChild, t + 1);
+			if (n) return n;
+			delete o[e.paramChild.paramName];
+		}
+		if (e.wildcardChild && e.wildcardChild.route && (!n.willMatch || n.willMatch(e.wildcardChild.route))) return {
+			path: r || "/",
+			pattern: e.wildcardChild.route.pattern,
+			params: {
+				...o,
+				wildcard: "/" + a.slice(t).map(decodeURIComponent).join("/")
+			},
+			query: T(i || ""),
+			meta: e.wildcardChild.route.meta,
+			layers: e.wildcardChild.route.layers ?? [],
+			redirect: e.wildcardChild.route.redirect
+		};
+	}
+	return s(e, 0);
+}
+async function A(e, n, r = []) {
+	let i = k(e, n);
+	if (!i) return { journey: [...r, {
+		kind: "miss",
+		message: `no match for '${n}'`
+	}] };
+	if (i.redirect != null) {
+		let n = i.redirect;
+		return o(n) ? n = N(n, i.params) : (n = await n(i), t(o(n), "Redirect function must return a path."), n.startsWith("/") || (n = w(i.path, n))), A(e, n, [...r, {
+			kind: "redirect",
+			message: `redirecting '${i.path}' -> '${n}'`
+		}]);
+	}
+	return {
+		match: i,
+		journey: [...r, {
+			kind: "match",
+			message: `matched route '${i.path}'`
+		}]
+	};
+}
+function j(e, t, n = window) {
+	function r(r) {
+		if (r.button && r.button !== 0 || r.ctrlKey || r.metaKey || r.altKey || r.shiftKey || r.defaultPrevented) return;
+		let i = r.target.closest("a");
+		if (!i || !e.contains(i)) return;
+		let a = i.getAttribute("href");
+		a && (n.location.protocol !== i.protocol || n.location.hostname !== i.hostname || n.location.port !== i.port || i.hasAttribute("data-router-ignore") || i.hasAttribute("download") || i.getAttribute("target") === "_blank" || /^[\w-_]+:/.test(a) || (r.preventDefault(), t(a, i)));
+	}
+	return e.addEventListener("click", r), () => e.removeEventListener("click", r);
+}
+function M(e) {
+	let t = S(e), n = [[]];
+	for (let e of t) {
+		let t = e.endsWith("?}"), r = t ? e.replace("?", "") : e;
+		if (t) {
+			let e = n.map((e) => [...e, r]);
+			n.push(...e);
+		} else for (let e of n) e.push(r);
+	}
+	return n.map((e) => "/" + e.join("/")).map((e) => e === "/" ? e : e.replace(/\/$/, ""));
+}
+function N(e, t) {
+	for (let n in t) {
+		let r = String(t[n]);
+		e = e.replace(`{${n}}`, r).replace(`{#${n}}`, r).replace(`{${n}?}`, r).replace(`{#${n}?}`, r);
+	}
+	return e = e.replace(/\{#?[a-zA-Z0-9_]+\?\}/g, ""), e = e.replace(/\/+/g, "/"), e.length > 1 && e.endsWith("/") && (e = e.slice(0, -1)), e;
+}
+function P(e) {
+	let t = window.history.state?.index || 0;
+	window.history.state?.index === void 0 && window.history.replaceState({
+		...window.history.state,
+		key: Date.now().toString(),
+		index: t
+	}, "");
+	let n = e ? () => window.location.hash.slice(1).split("?")[0] || "/" : () => window.location.pathname, i = e ? () => {
+		let e = window.location.hash, t = e.indexOf("?");
+		return t === -1 ? "" : e.slice(t);
+	} : () => window.location.search, a = () => window.history.state?.key || "root";
+	return {
+		getPath: n,
+		getSearch: i,
+		getKey: a,
+		getIndex: () => window.history.state?.index || 0,
+		push: (n) => {
+			t++;
+			let i = e ? "/#" : "";
+			window.history.pushState({
+				key: r(),
+				index: t
+			}, "", i + n);
+		},
+		replace: (n) => {
+			let r = e ? "/#" : "";
+			window.history.replaceState({
+				key: a(),
+				index: t
+			}, "", r + n);
+		}
+	};
+}
+//#endregion
+//#region src/router/store.ts
+function F({ currentMatch: t, setCurrentMatch: n, progress: r, history: i, updateRoute: o, guards: s }) {
+	this.name = "dolla:router";
+	let c = x(this);
+	async function l(e, t) {
+		for (let e of s) if (await e()) return;
+		c.info(`🗺️ navigating to '${e}'${t ? " (replace)" : ""}`);
+		let n = w(i.getPath(), e);
+		t ? i.replace(n) : i.push(n), o();
+	}
+	return {
+		path: a(() => t().path),
+		pattern: a(() => t().pattern),
+		params: a(() => t().params),
+		query: a(() => t().query),
+		meta: a(() => t().meta),
+		progress: r,
+		setQuery(r) {
+			let a = e(t), o = E(a.query, r, !0), s = Object.fromEntries(o);
+			n({
+				...a,
+				query: s
+			});
+			let c = o.size ? "?" + o.toString() : "";
+			return i.replace(a.path + c), s;
+		},
+		back: (e = 1) => window.history.go(-e),
+		forward: (e = 1) => window.history.go(e),
+		push: (e) => l(e, !1),
+		replace: (e) => l(e, !0),
+		block: (e) => (s.add(e), () => s.delete(e)),
+		isActive(e, n = !1) {
+			let r = e === "/" ? "/" : e.replace(/\/$/, ""), i = r === "/" ? "/" : r + "/";
+			return a(() => {
+				let e = t().path, a = e === "/" ? "/" : e.replace(/\/$/, "");
+				return n ? a === r : a === r || a.startsWith(i);
+			});
+		}
+	};
+}
+//#endregion
+//#region src/router/router.ts
+var I = Symbol();
+function L(e) {
+	return {
+		_lazy: !0,
+		load: e
+	};
+}
+function R(t) {
+	return function(n) {
+		"scrollRestoration" in window.history && (window.history.scrollRestoration = "manual");
+		let r = P(!!t.hash), i = /* @__PURE__ */ new Map(), a = r.getKey(), [o, l] = s({
+			path: r.getPath(),
+			pattern: "",
+			params: {},
+			query: Object.fromEntries(new URLSearchParams(r.getSearch())),
+			meta: {}
+		}), [u, S] = s(0), C = O(t.routes), w = /* @__PURE__ */ new Set(), T = g(n);
+		T.name = "dolla:router";
+		let D = x(T), [k, M] = s();
+		n[I] = k;
+		let L = {
+			context: n,
+			slot: k,
+			setSlot: M
+		}, R = [];
+		async function z(u) {
+			i.set(a, window.scrollY);
+			let p = u ?? r.getPath(), { match: m, journey: g } = await A(C, p);
+			if (n[b]) for (let e = 0; e < g.length; e++) {
+				let t = g[e], n = `(update ${e + 1}/${g.length})`;
+				t.kind === "match" ? D.info(`📍 ${n} ${t.message}`) : t.kind === "redirect" ? D.info(`↩️ ${n} ${t.message}`) : D.info(`💀 ${n} ${t.message}`);
+			}
+			if (!m) throw Error(`Failed to match route '${p}'`);
+			let { layers: _, params: v } = m, y = [], x = 0;
+			for (let e = 0; e < _.length; e++) {
+				let t = `${_[e].id}:${N(_[e].pattern, v)}`;
+				y.push(t), x === e && R[e]?.key === t && x++;
+			}
+			let w = [], T = [];
+			for (let e = x; e < _.length; e++) {
+				let t = _[e];
+				t.preload && w.push(Promise.resolve(t.preload(m)).then((t) => {
+					T[e - x] = t;
+				}));
+				let n = t.view;
+				n._lazy && w.push(n.load().then((e) => {
+					t.view = e.default ?? e;
+				}));
+			}
+			let O = null, k = -1;
+			if (w.length > 0) {
+				S(.1);
+				let e = 0, t = .8 / w.length;
+				w.forEach((n) => n.then(() => S(.1 + ++e * t)).catch(() => {}));
+				try {
+					await Promise.all(w);
+				} catch (e) {
+					if (S(0), e instanceof B) return V.replace(e.redirectPath);
+					O = e instanceof Error ? e : Error(String(e)), k = x;
+				}
+			}
+			let j = E(e(o).query, m.query, t.preserveQuery), M = j.toString(), P = m.path + (M ? `?${M}` : "");
+			P !== r.getPath() + r.getSearch() && r.replace(P), c(() => {
+				if (l({
+					...m,
+					query: Object.fromEntries(j)
+				}), !(x === _.length && R.length === _.length)) {
+					R[x] && (R[x].node.unmount(), R.length = x);
+					for (let e = x; e < _.length; e++) {
+						let t = _[e], n = R[e - 1] ?? L, [r, i] = s(), a = t.view, o = {
+							data: T[e - x],
+							children: h(d, { args: [r] })
+						};
+						if (O && e === k) {
+							if (!t.errorView) throw O;
+							a = t.errorView, o = { error: O };
+						}
+						let c = new f(n.context, a, o);
+						if (n.setSlot(c), R.push({
+							id: t.id,
+							key: y[e],
+							node: c,
+							context: c.context,
+							slot: r,
+							setSlot: i
+						}), O && e === k) break;
+					}
+				}
+			}), S(0), requestAnimationFrame(() => {
+				window.scrollTo(0, i.get(r.getKey()) ?? 0), a = r.getKey();
+			});
+		}
+		let V = y(n, F, {
+			currentMatch: o,
+			setCurrentMatch: l,
+			progress: u,
+			history: r,
+			updateRoute: z,
+			guards: w
+		});
+		m(n, () => {
+			let e = !1, t = !1, i = r.getIndex(), a = _(window, "popstate", async () => {
+				if (e) {
+					e = !1;
+					return;
+				}
+				if (t) {
+					t = !1, i = r.getIndex(), z();
+					return;
+				}
+				let n = r.getIndex(), a = i - n;
+				if (w.size > 0) {
+					e = !0, window.history.go(a);
+					let n = !1;
+					for (let e of w) if (await e()) {
+						n = !0;
+						break;
+					}
+					n || (t = !0, window.history.go(-a));
+					return;
+				}
+				i = n, z();
+			}), o = _(window, "beforeunload", (e) => {
+				w.size > 0 && (e.preventDefault(), e.returnValue = "");
+			}), s = j(p(n), V.push);
+			v(n, () => {
+				a(), o(), s();
+			}), z();
+		});
+	};
+}
+function z() {
+	this.name = "dolla:router";
+	let e = this[I];
+	return t(e != null, "Router plugin not found on root."), new d(this, e);
+}
+var B = class extends Error {
+	constructor(e) {
+		super(`Redirecting to ${e}`), this.redirectPath = e, this.name = "RedirectError";
+	}
+};
+//#endregion
+//#region src/router/index.ts
+function V(e) {
+	return u(e, F);
+}
+//#endregion
+export { z as Outlet, B as RedirectError, R as createRouterPlugin, V as getRouter, L as lazy };
+
+//# sourceMappingURL=router.js.map