mikuru 1.0.14 → 1.0.16

package/dist/router/index.js

@@ -1,50 +1,235 @@
-import { effect, ref, unwrap } from "../runtime/index.js";
+import { effect, inject, provide, ref, unwrap } from "../runtime/index.js";
+export const NavigationFailureType = {
+    aborted: "aborted",
+    cancelled: "cancelled",
+    duplicated: "duplicated"
+};
+export function defineRoutes(routes) {
+    return routes;
+}
 const notFoundRoute = { path: "/:pathMatch(.*)*", name: "not-found" };
+const routerKey = Symbol.for("mikuru.router");
+const routerErrorNotifiers = new WeakMap();
+const routerReadyTrackers = new WeakMap();
+const maxNavigationRedirects = 20;
+export function provideRouter(router) {
+    provide(routerKey, router);
+}
+export function useRouter() {
+    const router = inject(routerKey);
+    if (!router) {
+        throw new Error("No router was provided. Call provideRouter(router) in an ancestor component.");
+    }
+    return router;
+}
+export function useRoute() {
+    const router = useRouter();
+    return new Proxy({}, {
+        get(_target, key) {
+            return router.currentRoute.value[key];
+        },
+        has(_target, key) {
+            return key in router.currentRoute.value;
+        },
+        ownKeys() {
+            return Reflect.ownKeys(router.currentRoute.value);
+        },
+        getOwnPropertyDescriptor(_target, key) {
+            return Object.getOwnPropertyDescriptor(router.currentRoute.value, key);
+        }
+    });
+}
+export function isNavigationFailure(value, type) {
+    const failure = value;
+    const isFailure = !!failure &&
+        typeof failure === "object" &&
+        typeof failure.type === "string" &&
+        typeof failure.message === "string" &&
+        !!failure.to &&
+        !!failure.from;
+    return isFailure && (!type || failure.type === type);
+}
 export function createRouter(options) {
     const history = options.history ?? createWebHashHistory();
-    const routes = options.notFound ? [...options.routes, { ...notFoundRoute, component: options.notFound }] : options.routes.slice();
-    const matcher = createMatcher(routes);
+    const routes = options.routes.slice();
+    const fallbackRoute = options.notFound ? { ...notFoundRoute, component: options.notFound } : undefined;
+    const loadingComponent = options.loadingComponent;
+    const errorComponent = options.errorComponent;
+    const queryCodec = {
+        parseQuery: options.parseQuery ?? parseRouteQuery,
+        stringifyQuery: options.stringifyQuery ?? stringifyRouteQuery
+    };
+    let matcher = createMatcher(readMatcherRoutes());
     const beforeGuards = [];
     const afterHooks = [];
-    const initial = resolveLocation(history.location(), matcher);
+    const errorHandlers = [];
+    const initial = resolveRouteTarget(history.location());
     const currentRoute = ref(initial);
+    const pendingReady = new Set();
     let listeningStop;
     let navigationId = 0;
-    async function navigate(to, replace) {
-        const target = resolveLocation(stringifyLocation(to), matcher);
+    async function navigate(to, replace, redirectCount = 0) {
         const from = currentRoute.value;
-        const id = ++navigationId;
-        for (const guard of beforeGuards) {
-            const result = await guard(target, from);
-            if (id !== navigationId)
-                return currentRoute.value;
-            if (result === false)
-                return from;
-            if (typeof result === "string" || (result && typeof result === "object")) {
-                return navigate(result, true);
+        let target = from;
+        try {
+            target = resolveRouteTarget(to, from.path);
+            const id = ++navigationId;
+            if (target.fullPath === from.fullPath) {
+                return createNavigationFailure(NavigationFailureType.duplicated, target, from);
+            }
+            const guards = [...beforeGuards, ...readBeforeEnterGuards(target.matchedRecords)];
+            for (const guard of guards) {
+                const result = await guard(target, from);
+                if (id !== navigationId)
+                    return createNavigationFailure(NavigationFailureType.cancelled, target, from);
+                if (result === false) {
+                    const failure = createNavigationFailure(NavigationFailureType.aborted, target, from);
+                    for (const hook of afterHooks)
+                        hook(target, from, failure);
+                    return failure;
+                }
+                if (typeof result === "string" || (result && typeof result === "object")) {
+                    if (redirectCount >= maxNavigationRedirects) {
+                        throw new Error("Too many navigation guard redirects.");
+                    }
+                    return navigate(result, true, redirectCount + 1);
+                }
+            }
+            if (replace)
+                history.replace(target.fullPath);
+            else
+                history.push(target.fullPath);
+            currentRoute.value = target;
+            for (const hook of afterHooks) {
+                hook(target, from);
             }
+            await trackReady(handleScroll(target, from));
+            return target;
         }
-        if (replace)
-            history.replace(target.fullPath);
-        else
-            history.push(target.fullPath);
-        currentRoute.value = target;
-        for (const hook of afterHooks) {
-            hook(target, from);
+        catch (error) {
+            notifyRouterError(error, target, from);
+            throw error;
+        }
+    }
+    async function preload(to) {
+        const from = currentRoute.value;
+        let target = from;
+        try {
+            target = resolveRouteTarget(to, from.path);
+            await trackReady(Promise.all(target.matchedRecords.map((record) => record.component ? resolveRouteComponent(record) : Promise.resolve())));
+            return target;
+        }
+        catch (error) {
+            notifyRouterError(error, target, from);
+            throw error;
         }
-        return target;
     }
     function syncFromHistory() {
-        currentRoute.value = resolveLocation(history.location(), matcher);
+        currentRoute.value = resolveRouteTarget(history.location());
     }
-    return {
+    function syncCurrentRoute() {
+        currentRoute.value = resolveRouteTarget(currentRoute.value.fullPath, currentRoute.value.path);
+    }
+    function readMatcherRoutes() {
+        return fallbackRoute ? [...routes, fallbackRoute] : routes;
+    }
+    function resolveRouteTarget(to, basePath) {
+        let target = resolveLocation(stringifyLocation(to, matcher, basePath, queryCodec.stringifyQuery), matcher, queryCodec.parseQuery);
+        for (let redirects = 0; redirects < 10; redirects += 1) {
+            const redirect = target.matched?.redirect;
+            if (!redirect)
+                return target;
+            const next = typeof redirect === "function" ? redirect(target) : redirect;
+            target = resolveLocation(stringifyLocation(next, matcher, target.path, queryCodec.stringifyQuery), matcher, queryCodec.parseQuery);
+        }
+        throw new Error("Too many route redirects.");
+    }
+    function replaceMatcher(nextRoutes = routes) {
+        matcher = createMatcher(fallbackRoute ? [...nextRoutes, fallbackRoute] : nextRoutes);
+    }
+    function addRoute(parentOrRecord, record) {
+        if (typeof parentOrRecord !== "string") {
+            const nextRoutes = [...routes, parentOrRecord];
+            replaceMatcher(nextRoutes);
+            routes.push(parentOrRecord);
+            syncCurrentRoute();
+            return () => {
+                if (parentOrRecord.name)
+                    removeRoute(parentOrRecord.name);
+                else if (removeRouteRecord(routes, parentOrRecord)) {
+                    replaceMatcher();
+                    syncCurrentRoute();
+                }
+            };
+        }
+        if (!record) {
+            throw new Error("router.addRoute(parentName, record) requires a route record.");
+        }
+        const parent = matcher.byName.get(parentOrRecord)?.record;
+        if (!parent) {
+            throw new Error(`Unknown route name: ${parentOrRecord}`);
+        }
+        const nextChildren = [...(parent.children ?? []), record];
+        const previousChildren = parent.children;
+        parent.children = nextChildren;
+        try {
+            replaceMatcher();
+        }
+        catch (error) {
+            parent.children = previousChildren;
+            replaceMatcher();
+            throw error;
+        }
+        syncCurrentRoute();
+        return () => {
+            if (record.name)
+                removeRoute(record.name);
+            else if (parent.children && removeRouteRecord(parent.children, record))
+                syncCurrentRoute();
+        };
+    }
+    function removeRoute(name) {
+        if (!matcher.byName.has(name))
+            return false;
+        const removed = removeRouteByName(routes, name);
+        if (!removed)
+            return false;
+        replaceMatcher();
+        syncCurrentRoute();
+        return true;
+    }
+    async function handleScroll(to, from) {
+        if (history.mode === "memory")
+            return;
+        if (options.scrollBehavior) {
+            const position = await options.scrollBehavior(to, from);
+            if (!position)
+                return;
+            scrollToPosition(position);
+            return;
+        }
+        const metaScroll = to.meta.scroll;
+        if (metaScroll !== undefined) {
+            const position = typeof metaScroll === "function" ? await metaScroll(to, from) : metaScroll;
+            if (!position)
+                return;
+            scrollToPosition(position);
+            return;
+        }
+        scrollToDefaultPosition(to);
+    }
+    function trackReady(promise) {
+        pendingReady.add(promise);
+        return promise.finally(() => pendingReady.delete(promise));
+    }
+    const router = {
         currentRoute,
         routes,
         push(to) {
-            return navigate(to, false);
+            return trackReady(navigate(to, false));
         },
         replace(to) {
-            return navigate(to, true);
+            return trackReady(navigate(to, true));
         },
         back() {
             history.back();
@@ -53,7 +238,11 @@ export function createRouter(options) {
             history.forward();
         },
         resolve(to) {
-            return resolveLocation(stringifyLocation(to), matcher);
+            return resolveRouteTarget(to, currentRoute.value.path);
+        },
+        preload,
+        isReady() {
+            return Promise.all(Array.from(pendingReady)).then(() => undefined);
         },
         beforeEach(guard) {
             beforeGuards.push(guard);
@@ -63,6 +252,15 @@ export function createRouter(options) {
             afterHooks.push(hook);
             return () => removeItem(afterHooks, hook);
         },
+        onError(handler) {
+            errorHandlers.push(handler);
+            return () => removeItem(errorHandlers, handler);
+        },
+        addRoute,
+        removeRoute,
+        hasRoute(name) {
+            return matcher.byName.has(name);
+        },
         listen() {
             if (listeningStop)
                 return listeningStop;
@@ -74,9 +272,26 @@ export function createRouter(options) {
             };
         },
         createHref(to) {
-            return history.createHref(stringifyLocation(to));
-        }
+            return history.createHref(stringifyLocation(to, matcher, currentRoute.value.path, queryCodec.stringifyQuery));
+        },
+        loadingComponent,
+        errorComponent
     };
+    routerErrorNotifiers.set(router, notifyRouterError);
+    routerReadyTrackers.set(router, trackReady);
+    return router;
+    function notifyRouterError(error, to, from) {
+        for (const handler of errorHandlers) {
+            try {
+                handler(error, to, from);
+            }
+            catch (handlerError) {
+                setTimeout(() => {
+                    throw handlerError;
+                });
+            }
+        }
+    }
 }
 export function createWebHistory(base = "") {
     const normalizedBase = normalizeBase(base);
@@ -186,18 +401,55 @@ export const RouterView = {
         const anchor = document.createComment("mikuru-router-view");
         const cleanup = [];
         let child;
+        let renderId = 0;
         target.appendChild(anchor);
         const stop = effect(() => {
             const router = getRouterProp(props);
             const route = router.currentRoute.value;
-            const component = route.matched?.component;
+            const depth = Number(unwrap(props.depth) ?? 0);
+            const record = route.matchedRecords[depth];
+            const id = ++renderId;
             child?.unmount();
             child = undefined;
-            if (!component)
+            if (!record?.component)
                 return;
-            const fragment = document.createDocumentFragment();
-            child = component.mount(fragment, { route, router, __mikuru_context: props.__mikuru_context });
-            anchor.parentNode?.insertBefore(fragment, anchor);
+            if (isLazyRouteComponent(record.component)) {
+                const loadingComponent = record.loadingComponent ?? router.loadingComponent;
+                if (loadingComponent) {
+                    const fragment = anchor.ownerDocument.createDocumentFragment();
+                    child = loadingComponent.mount(fragment, { route, router, __mikuru_context: props.__mikuru_context });
+                    anchor.parentNode?.insertBefore(fragment, anchor);
+                }
+            }
+            const componentPromise = resolveRouteComponent(record);
+            void (routerReadyTrackers.get(router)?.(componentPromise) ?? componentPromise).catch(() => undefined);
+            void componentPromise
+                .then((component) => {
+                if (id !== renderId)
+                    return;
+                child?.unmount();
+                child = undefined;
+                const fragment = anchor.ownerDocument.createDocumentFragment();
+                child = component.mount(fragment, createRouteComponentProps(record, route, router, props.__mikuru_context));
+                anchor.parentNode?.insertBefore(fragment, anchor);
+            })
+                .catch((error) => {
+                if (id !== renderId)
+                    return;
+                child?.unmount();
+                child = undefined;
+                routerErrorNotifiers.get(router)?.(error, route);
+                const errorComponent = record.errorComponent ?? router.errorComponent;
+                if (!errorComponent) {
+                    setTimeout(() => {
+                        throw error;
+                    });
+                    return;
+                }
+                const fragment = anchor.ownerDocument.createDocumentFragment();
+                child = errorComponent.mount(fragment, { error, route, router, __mikuru_context: props.__mikuru_context });
+                anchor.parentNode?.insertBefore(fragment, anchor);
+            });
         });
         cleanup.push(stop, () => child?.unmount(), () => anchor.remove());
         return {
@@ -213,25 +465,51 @@ export const RouterLink = {
     mount(target, props = {}) {
         const anchor = document.createElement("a");
         const cleanup = [];
-        const text = () => String(unwrap(props.label) ?? unwrap(props.childrenText) ?? unwrap(props.to) ?? "");
+        const hasChildren = typeof props.children === "function";
+        const text = () => {
+            const label = unwrap(props.label) ?? unwrap(props.childrenText);
+            if (label !== undefined)
+                return String(label);
+            const to = readToProp(props);
+            if (typeof to === "string")
+                return to;
+            if ("name" in to)
+                return to.name;
+            return to.path;
+        };
         const navigate = (event) => {
             const router = getRouterProp(props);
-            const to = String(unwrap(props.to) ?? "/");
             event.preventDefault();
-            void (unwrap(props.replace) ? router.replace(to) : router.push(to));
+            void (unwrap(props.replace) ? router.replace(readToProp(props)) : router.push(readToProp(props)));
+        };
+        const preload = () => {
+            if (!unwrap(props.preload))
+                return;
+            const router = getRouterProp(props);
+            void router.preload(readToProp(props)).catch(() => undefined);
         };
         anchor.addEventListener("click", navigate);
+        anchor.addEventListener("mouseenter", preload);
+        anchor.addEventListener("focus", preload);
         cleanup.push(() => anchor.removeEventListener("click", navigate));
+        cleanup.push(() => anchor.removeEventListener("mouseenter", preload));
+        cleanup.push(() => anchor.removeEventListener("focus", preload));
+        if (hasChildren) {
+            const cleanupResult = props.children(anchor, {});
+            if (cleanupResult)
+                cleanup.push(cleanupResult);
+        }
         const stop = effect(() => {
             const router = getRouterProp(props);
-            const to = stringifyLocation(String(unwrap(props.to) ?? "/"));
+            const to = readToProp(props);
             const targetRoute = router.resolve(to);
             const activeClass = String(unwrap(props.activeClass) ?? "router-link-active");
             const exactActiveClass = String(unwrap(props.exactActiveClass) ?? "router-link-exact-active");
             const isExactActive = router.currentRoute.value.fullPath === targetRoute.fullPath;
             const isActive = isExactActive || isPathActive(router.currentRoute.value.path, targetRoute.path);
             anchor.href = router.createHref(to);
-            anchor.textContent = text();
+            if (!hasChildren)
+                anchor.textContent = text();
             anchor.classList.toggle(activeClass, isActive);
             anchor.classList.toggle(exactActiveClass, isExactActive);
             if (isExactActive) {
@@ -255,38 +533,191 @@ export const RouterLink = {
 function getRouterProp(props) {
     const router = unwrap(props.router);
     if (!router || typeof router !== "object" || !("currentRoute" in router)) {
-        throw new Error("RouterView and RouterLink require a router prop.");
+        const contextRouter = injectRouterFromContext(props.__mikuru_context);
+        if (contextRouter)
+            return contextRouter;
+        throw new Error("RouterView and RouterLink require a router prop or provided router context.");
     }
     return router;
 }
+function injectRouterFromContext(context) {
+    for (let current = context; current; current = current.parent) {
+        const router = current.provides?.get(routerKey);
+        if (router && typeof router === "object" && "currentRoute" in router) {
+            return router;
+        }
+    }
+    return undefined;
+}
+async function resolveRouteComponent(record) {
+    if (record.__mikuru_resolvedComponent)
+        return record.__mikuru_resolvedComponent;
+    const component = record.component;
+    if (!component) {
+        throw new Error(`Route ${record.path} does not have a component.`);
+    }
+    if (isRouteComponent(component)) {
+        record.__mikuru_resolvedComponent = component;
+        return component;
+    }
+    const loaded = await component();
+    const resolved = isRouteComponent(loaded) ? loaded : loaded.default;
+    if (!isRouteComponent(resolved)) {
+        throw new Error(`Lazy route component for ${record.path} did not resolve to a component.`);
+    }
+    record.__mikuru_resolvedComponent = resolved;
+    return resolved;
+}
+function isRouteComponent(component) {
+    return !!component && typeof component === "object" && typeof component.mount === "function";
+}
+function isLazyRouteComponent(component) {
+    return typeof component === "function";
+}
+function createRouteComponentProps(record, route, router, context) {
+    return {
+        ...resolveRouteProps(record, route),
+        route,
+        router,
+        __mikuru_context: context
+    };
+}
+function resolveRouteProps(record, route) {
+    if (record.props === true)
+        return { ...route.params };
+    if (typeof record.props === "function")
+        return record.props(route) ?? {};
+    if (record.props && typeof record.props === "object")
+        return { ...record.props };
+    return {};
+}
+function compileRoutePath(path) {
+    const keys = [];
+    const normalized = normalizePath(path);
+    if (normalized === "/")
+        return { keys, pattern: /^\/$/ };
+    const source = normalized
+        .split("/")
+        .filter(Boolean)
+        .map((segment) => compileRouteSegment(segment, keys))
+        .join("");
+    return { keys, pattern: new RegExp(`^${source}$`) };
+}
+function compileRouteSegment(segment, keys) {
+    const param = parseRouteParamSegment(segment);
+    if (!param)
+        return `/${escapeRegExp(segment)}`;
+    keys.push({ name: param.name, repeat: param.repeat });
+    if (param.pattern === ".*") {
+        return param.optional ? "(?:/(.*))?" : "/(.*)";
+    }
+    if (param.repeat) {
+        const repeated = "([^/]+(?:/[^/]+)*)";
+        return param.optional ? `(?:/${repeated})?` : `/${repeated}`;
+    }
+    return param.optional ? "(?:/([^/]+))?" : "/([^/]+)";
+}
+function parseRouteParamSegment(segment) {
+    const match = /^:([^()+*?]+)(?:\((\.\*)\))?([?+*])?$/.exec(segment);
+    if (!match)
+        return undefined;
+    const modifier = match[3] ?? "";
+    return {
+        name: match[1],
+        pattern: match[2],
+        optional: modifier === "?" || modifier === "*",
+        repeat: modifier === "+" || modifier === "*" || match[2] === ".*"
+    };
+}
+function stringifyRoutePath(path, params) {
+    const normalized = normalizePath(path);
+    if (normalized === "/")
+        return "/";
+    const segments = normalized.split("/").filter(Boolean);
+    const resolved = [];
+    for (const segment of segments) {
+        const param = parseRouteParamSegment(segment);
+        if (!param) {
+            resolved.push(segment);
+            continue;
+        }
+        const value = params[param.name];
+        if (value === undefined) {
+            if (param.optional)
+                continue;
+            throw new Error(`Missing route param: ${param.name}`);
+        }
+        const values = Array.isArray(value) ? value : [value];
+        if (values.length === 0) {
+            if (param.optional)
+                continue;
+            throw new Error(`Missing route param: ${param.name}`);
+        }
+        if (values.length > 1 && !param.repeat) {
+            throw new Error(`Route param is not repeatable: ${param.name}`);
+        }
+        resolved.push(...values.map((item) => encodeURIComponent(String(item))));
+    }
+    return normalizePath(resolved.join("/"));
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function createMatcher(routes) {
-    return routes.map((record) => {
-        const keys = [];
-        const source = record.path
-            .replace(/\/:([^/(]+)\(\.\*\)\*/g, (_match, key) => {
-            keys.push(key);
-            return "/(.*)";
-        })
-            .replace(/:([^/]+)/g, (_match, key) => {
-            keys.push(key);
-            return "([^/]+)";
-        });
-        return {
+    const compiled = [];
+    const byName = new Map();
+    function addCompiledRoute(record, path, parents, registerName) {
+        const compiledPath = compileRoutePath(path);
+        const route = {
             record,
-            keys,
-            pattern: new RegExp(`^${source.replace(/\//g, "\\/")}$`)
+            records: [...parents, record],
+            path,
+            keys: compiledPath.keys,
+            pattern: compiledPath.pattern
         };
+        compiled.push(route);
+        if (registerName && record.name) {
+            if (byName.has(record.name)) {
+                throw new Error(`Duplicate route name: ${record.name}`);
+            }
+            byName.set(record.name, route);
+        }
+        return route;
+    }
+    function addRoute(record, parentPath, parents, registerNames = true) {
+        const path = joinRoutePath(parentPath, record.path);
+        const paths = [path, ...readAliases(record).map((alias) => joinRoutePath(parentPath, alias))];
+        paths.forEach((routePath, index) => {
+            addCompiledRoute(record, routePath, parents, registerNames && index === 0);
+        });
+        paths.forEach((routePath, index) => {
+            for (const child of record.children ?? []) {
+                addRoute(child, routePath, [...parents, record], registerNames && index === 0);
+            }
+        });
+    }
+    for (const route of routes) {
+        addRoute(route, "", []);
+    }
+    compiled.sort((left, right) => {
+        if (left.path !== right.path)
+            return 0;
+        return right.records.length - left.records.length;
     });
+    return { routes: compiled, byName };
 }
-function resolveLocation(raw, matcher) {
+function resolveLocation(raw, matcher, parseQuery = parseRouteQuery) {
     const fullPath = normalizePath(raw);
-    const parsed = parsePath(fullPath);
-    const matched = matcher.find((route) => route.pattern.test(parsed.path));
+    const parsed = parsePath(fullPath, parseQuery);
+    const matched = matcher.routes.find((route) => route.pattern.test(parsed.path));
     const params = {};
     if (matched) {
         const match = matched.pattern.exec(parsed.path);
         matched.keys.forEach((key, index) => {
-            params[key] = decodeURIComponent(match?.[index + 1] ?? "");
+            const value = match?.[index + 1];
+            if (value === undefined || value === "")
+                return;
+            params[key.name] = key.repeat ? value.split("/").map((part) => decodeURIComponent(part)) : decodeURIComponent(value);
         });
     }
     return {
@@ -296,11 +727,12 @@ function resolveLocation(raw, matcher) {
         hash: parsed.hash,
         params,
         matched: matched?.record,
+        matchedRecords: matched?.records ?? [],
         name: matched?.record.name,
-        meta: matched?.record.meta ?? {}
+        meta: mergeMeta(matched?.records ?? [])
     };
 }
-function parsePath(fullPath) {
+function parsePath(fullPath, parseQuery = parseRouteQuery) {
     const [pathAndQuery, rawHash = ""] = fullPath.split("#", 2);
     const [path = "/", rawQuery = ""] = pathAndQuery.split("?", 2);
     return {
@@ -309,15 +741,29 @@ function parsePath(fullPath) {
         hash: rawHash ? `#${rawHash}` : ""
     };
 }
-function stringifyLocation(to) {
+function stringifyLocation(to, matcher, basePath, stringifyQuery = stringifyRouteQuery) {
     if (typeof to === "string")
-        return normalizePath(to);
-    const path = normalizePath(to.path);
+        return stringifyPathLocation(to, basePath);
+    const path = "name" in to ? stringifyNamedLocation(to, matcher) : normalizeRelativePath(to.path, basePath);
     const query = stringifyQuery(to.query ?? {});
     const hash = to.hash ? (to.hash.startsWith("#") ? to.hash : `#${to.hash}`) : "";
     return `${path}${query}${hash}`;
 }
-function parseQuery(raw) {
+function stringifyPathLocation(raw, basePath) {
+    const [pathAndQuery, rawHash = ""] = raw.split("#", 2);
+    const [path = "/", rawQuery = ""] = pathAndQuery.split("?", 2);
+    const query = rawQuery ? `?${rawQuery}` : "";
+    const hash = rawHash ? `#${rawHash}` : "";
+    return `${normalizeRelativePath(path, basePath)}${query}${hash}`;
+}
+function stringifyNamedLocation(to, matcher) {
+    const route = matcher?.byName.get(to.name);
+    if (!route) {
+        throw new Error(`Unknown route name: ${to.name}`);
+    }
+    return stringifyRoutePath(route.path, to.params ?? {});
+}
+export function parseRouteQuery(raw) {
     const query = {};
     const search = new URLSearchParams(raw);
     for (const [key, value] of search) {
@@ -331,7 +777,7 @@ function parseQuery(raw) {
     }
     return query;
 }
-function stringifyQuery(query) {
+export function stringifyRouteQuery(query) {
     const search = new URLSearchParams();
     for (const [key, value] of Object.entries(query)) {
         if (Array.isArray(value)) {
@@ -349,11 +795,109 @@ function normalizePath(path) {
     const normalized = path.trim() || "/";
     return normalized.startsWith("/") ? normalized : `/${normalized}`;
 }
+function normalizeRelativePath(path, basePath) {
+    const normalized = path.trim() || "/";
+    if (!isRelativePath(normalized))
+        return normalizePath(normalized);
+    const segments = normalizePath(basePath ?? "/")
+        .split("/")
+        .filter(Boolean);
+    for (const segment of normalized.split("/")) {
+        if (!segment || segment === ".")
+            continue;
+        if (segment === "..")
+            segments.pop();
+        else
+            segments.push(segment);
+    }
+    return normalizePath(segments.map((segment) => encodeURIComponent(decodeURIComponent(segment))).join("/"));
+}
+function isRelativePath(path) {
+    return path === "." || path === ".." || path.startsWith("./") || path.startsWith("../");
+}
 function normalizeBase(base) {
     if (!base)
         return "/";
     return base.endsWith("/") ? base : `${base}/`;
 }
+function joinRoutePath(parentPath, path) {
+    if (path.startsWith("/"))
+        return normalizePath(path);
+    if (!parentPath)
+        return normalizePath(path);
+    if (!path)
+        return parentPath;
+    return normalizePath(`${parentPath.replace(/\/$/, "")}/${path}`);
+}
+function readToProp(props) {
+    return unwrap(props.to) ?? "/";
+}
+function readAliases(record) {
+    if (!record.alias)
+        return [];
+    return Array.isArray(record.alias) ? record.alias : [record.alias];
+}
+function mergeMeta(records) {
+    return records.reduce((meta, record) => ({ ...meta, ...(record.meta ?? {}) }), {});
+}
+function readBeforeEnterGuards(records) {
+    return records.flatMap((record) => {
+        if (!record.beforeEnter)
+            return [];
+        return Array.isArray(record.beforeEnter) ? record.beforeEnter : [record.beforeEnter];
+    });
+}
+function removeRouteByName(routes, name) {
+    for (let index = 0; index < routes.length; index += 1) {
+        const route = routes[index];
+        if (!route)
+            continue;
+        if (route.name === name) {
+            routes.splice(index, 1);
+            return true;
+        }
+        if (route.children && removeRouteByName(route.children, name)) {
+            return true;
+        }
+    }
+    return false;
+}
+function removeRouteRecord(routes, record) {
+    const index = routes.indexOf(record);
+    if (index >= 0) {
+        routes.splice(index, 1);
+        return true;
+    }
+    for (const route of routes) {
+        if (route.children && removeRouteRecord(route.children, record)) {
+            return true;
+        }
+    }
+    return false;
+}
+function createNavigationFailure(type, to, from) {
+    return {
+        type,
+        to,
+        from,
+        message: `Navigation ${type} from ${from.fullPath} to ${to.fullPath}.`
+    };
+}
+function scrollToDefaultPosition(to) {
+    if (to.hash) {
+        const id = decodeURIComponent(to.hash.slice(1));
+        const element = globalThis.document?.getElementById?.(id);
+        if (element) {
+            element.scrollIntoView();
+            return;
+        }
+    }
+    scrollToPosition({ left: 0, top: 0 });
+}
+function scrollToPosition(position) {
+    const scrollTo = globalThis.scrollTo ?? globalThis.window?.scrollTo;
+    scrollTo?.call(globalThis.window ?? globalThis, position);
+}
 function stripBase(path, base) {
     if (base === "/")
         return path;