@tanstack/router-core 1.132.0-alpha.8 → 1.132.0

package/dist/esm/router.d.ts

@@ -4,37 +4,38 @@ import { ParsePathnameCache } from './path.js';
 import { SearchParser, SearchSerializer } from './searchParams.js';
 import { AnyRedirect, ResolvedRedirect } from './redirect.js';
 import { HistoryLocation, HistoryState, ParsedHistoryState, RouterHistory } from '@tanstack/history';
-import { Awaitable, ControlledPromise, NoInfer, NonNullableUpdater, PickAsRequired, Updater } from './utils.js';
+import { Awaitable, Constrain, ControlledPromise, NoInfer, NonNullableUpdater, PickAsRequired, Updater } from './utils.js';
 import { ParsedLocation } from './location.js';
-import { AnyContext, AnyRoute, AnyRouteWithContext, MakeRemountDepsOptionsUnion, RouteMask } from './route.js';
+import { AnyContext, AnyRoute, AnyRouteWithContext, MakeRemountDepsOptionsUnion, RouteLike, RouteMask } from './route.js';
 import { FullSearchSchema, RouteById, RoutePaths, RoutesById, RoutesByPath } from './routeInfo.js';
 import { AnyRouteMatch, MakeRouteMatchUnion, MatchRouteOptions } from './Matches.js';
 import { BuildLocationFn, CommitLocationOptions, NavigateFn } from './RouterProvider.js';
 import { Manifest } from './manifest.js';
 import { AnySchema } from './validators.js';
 import { NavigateOptions, ResolveRelativePath, ToOptions } from './link.js';
-import { AnySerializationAdapter } from './ssr/serializer/transformer.js';
-import { AnyRouterConfig } from './config.js';
+import { AnySerializationAdapter, ValidateSerializableInput } from './ssr/serializer/transformer.js';
 export type ControllablePromise<T = any> = Promise<T> & {
     resolve: (value: T) => void;
     reject: (value?: any) => void;
 };
 export type InjectedHtmlEntry = Promise<string>;
-export interface DefaultRegister {
-    router: AnyRouter;
-    config: AnyRouterConfig;
-    ssr: SSROption;
+export interface Register {
 }
-export interface Register extends DefaultRegister {
-}
-export type RegisteredRouter = Register['router'];
+export type RegisteredRouter<TRegister = Register> = TRegister extends {
+    router: infer TRouter;
+} ? TRouter : AnyRouter;
+export type RegisteredConfigType<TRegister, TKey> = TRegister extends {
+    config: infer TConfig;
+} ? TConfig extends {
+    '~types': infer TTypes;
+} ? TKey extends keyof TTypes ? TTypes[TKey] : unknown : unknown : unknown;
 export type DefaultRemountDepsFn<TRouteTree extends AnyRoute> = (opts: MakeRemountDepsOptionsUnion<TRouteTree>) => any;
 export interface DefaultRouterOptionsExtensions {
 }
 export interface RouterOptionsExtensions extends DefaultRouterOptionsExtensions {
 }
 export type SSROption = boolean | 'data-only';
-export interface RouterOptions<TRouteTree extends AnyRoute, TTrailingSlashOption extends TrailingSlashOption, TDefaultStructuralSharingOption extends boolean = false, TRouterHistory extends RouterHistory = RouterHistory, TDehydrated extends Record<string, any> = Record<string, any>> extends RouterOptionsExtensions {
+export interface RouterOptions<TRouteTree extends AnyRoute, TTrailingSlashOption extends TrailingSlashOption, TDefaultStructuralSharingOption extends boolean = false, TRouterHistory extends RouterHistory = RouterHistory, TDehydrated = undefined> extends RouterOptionsExtensions {
     /**
      * The history object that will be used to manage the browser history.
      *
@@ -178,6 +179,18 @@ export interface RouterOptions<TRouteTree extends AnyRoute, TTrailingSlashOption
     /**
      * The basepath for then entire router. This is useful for mounting a router instance at a subpath.
      *
+     * @deprecated - use `rewrite.input` with the new `rewriteBasepath` utility instead:
+     * ```ts
+     * const router = createRouter({
+     *   routeTree,
+     *   rewrite: rewriteBasepath('/basepath')
+     *   // Or wrap existing rewrite functionality
+     *   rewrite: rewriteBasepath('/basepath', {
+     *     output: ({ url }) => {...},
+     *     input: ({ url }) => {...},
+     *   })
+     * })
+     * ```
      * @default '/'
      * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#basepath-property)
      */
@@ -193,6 +206,7 @@ export interface RouterOptions<TRouteTree extends AnyRoute, TTrailingSlashOption
      * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/router-context)
      */
     context?: InferRouterContext<TRouteTree>;
+    additionalContext?: any;
     /**
      * A function that will be called when the router is dehydrated.
      *
@@ -201,7 +215,7 @@ export interface RouterOptions<TRouteTree extends AnyRoute, TTrailingSlashOption
      * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#dehydrate-method)
      * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/external-data-loading#critical-dehydrationhydration)
      */
-    dehydrate?: () => Awaitable<TDehydrated>;
+    dehydrate?: () => Constrain<TDehydrated, ValidateSerializableInput<Register, TDehydrated>>;
     /**
      * A function that will be called when the router is hydrated.
      *
@@ -328,7 +342,44 @@ export interface RouterOptions<TRouteTree extends AnyRoute, TTrailingSlashOption
      */
     disableGlobalCatchBoundary?: boolean;
     serializationAdapters?: ReadonlyArray<AnySerializationAdapter>;
+    /**
+     * Configures how the router will rewrite the location between the actual href and the internal href of the router.
+     *
+     * @default undefined
+     * @description You can provide a custom rewrite pair (in/out) or use the utilities like `rewriteBasepath` as a convenience for common use cases, or even do both!
+     * This is useful for basepath rewriting, shifting data from the origin to the path (for things like )
+     */
+    rewrite?: LocationRewrite;
+    origin?: string;
+    ssr?: {
+        nonce?: string;
+    };
 }
+export type LocationRewrite = {
+    /**
+     * A function that will be called to rewrite the URL before it is interpreted by the router from the history instance.
+     * Utilities like `rewriteBasepath` are provided as a convenience for common use cases.
+     *
+     * @default undefined
+     */
+    input?: LocationRewriteFunction;
+    /**
+     * A function that will be called to rewrite the URL before it is committed to the actual history instance from the router.
+     * Utilities like `rewriteBasepath` are provided as a convenience for common use cases.
+     *
+     * @default undefined
+     */
+    output?: LocationRewriteFunction;
+};
+/**
+ * A function that will be called to rewrite the URL.
+ *
+ * @param url The URL to rewrite.
+ * @returns The rewritten URL (as a URL instance or full href string) or undefined if no rewrite is needed.
+ */
+export type LocationRewriteFunction = ({ url, }: {
+    url: URL;
+}) => undefined | string | URL;
 export interface RouterState<in out TRouteTree extends AnyRoute = AnyRoute, in out TRouteMatch = MakeRouteMatchUnion> {
     status: 'pending' | 'idle';
     loadedAt: number;
@@ -408,7 +459,7 @@ export type RouterContextOptions<TRouteTree extends AnyRoute> = AnyContext exten
 } : {
     context: InferRouterContext<TRouteTree>;
 };
-export type RouterConstructorOptions<TRouteTree extends AnyRoute, TTrailingSlashOption extends TrailingSlashOption, TDefaultStructuralSharingOption extends boolean, TRouterHistory extends RouterHistory, TDehydrated extends Record<string, any>> = Omit<RouterOptions<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated>, 'context'> & RouterContextOptions<TRouteTree>;
+export type RouterConstructorOptions<TRouteTree extends AnyRoute, TTrailingSlashOption extends TrailingSlashOption, TDefaultStructuralSharingOption extends boolean, TRouterHistory extends RouterHistory, TDehydrated extends Record<string, any>> = Omit<RouterOptions<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated>, 'context' | 'serializationAdapters' | 'defaultSsr'> & RouterContextOptions<TRouteTree>;
 export type PreloadRouteFn<TRouteTree extends AnyRoute, TTrailingSlashOption extends TrailingSlashOption, TDefaultStructuralSharingOption extends boolean, TRouterHistory extends RouterHistory> = <TFrom extends RoutePaths<TRouteTree> | string = string, TTo extends string | undefined = undefined, TMaskFrom extends RoutePaths<TRouteTree> | string = TFrom, TMaskTo extends string = ''>(opts: NavigateOptions<RouterCore<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory>, TFrom, TTo, TMaskFrom, TMaskTo>) => Promise<Array<AnyRouteMatch> | undefined>;
 export type MatchRouteFn<TRouteTree extends AnyRoute, TTrailingSlashOption extends TrailingSlashOption, TDefaultStructuralSharingOption extends boolean, TRouterHistory extends RouterHistory> = <TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string | undefined = undefined, TResolved = ResolveRelativePath<TFrom, NoInfer<TTo>>>(location: ToOptions<RouterCore<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory>, TFrom, TTo>, opts?: MatchRouteOptions) => false | RouteById<TRouteTree, TResolved>['types']['allParams'];
 export type UpdateFn<TRouteTree extends AnyRoute, TTrailingSlashOption extends TrailingSlashOption, TDefaultStructuralSharingOption extends boolean, TRouterHistory extends RouterHistory, TDehydrated extends Record<string, any>> = (newOptions: RouterConstructorOptions<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated>) => void;
@@ -495,6 +546,8 @@ export declare class RouterCore<in out TRouteTree extends AnyRoute, in out TTrai
     __store: Store<RouterState<TRouteTree>>;
     options: PickAsRequired<RouterOptions<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated>, 'stringifySearch' | 'parseSearch' | 'context'>;
     history: TRouterHistory;
+    rewrite?: LocationRewrite;
+    origin?: string;
     latestLocation: ParsedLocation<FullSearchSchema<TRouteTree>>;
     basepath: string;
     routeTree: TRouteTree;
@@ -556,31 +609,9 @@ export declare class PathParamError extends Error {
 }
 export declare function lazyFn<T extends Record<string, (...args: Array<any>) => any>, TKey extends keyof T = 'default'>(fn: () => Promise<T>, key?: TKey): (...args: Parameters<T[TKey]>) => Promise<Awaited<ReturnType<T[TKey]>>>;
 export declare function getInitialRouterState(location: ParsedLocation): RouterState<any>;
-interface RouteLike {
-    id: string;
-    isRoot?: boolean;
-    path?: string;
-    fullPath: string;
-    rank?: number;
-    parentRoute?: RouteLike;
-    children?: Array<RouteLike>;
-    options?: {
-        caseSensitive?: boolean;
-    };
-}
-export type ProcessRouteTreeResult<TRouteLike extends RouteLike> = {
-    routesById: Record<string, TRouteLike>;
-    routesByPath: Record<string, TRouteLike>;
-    flatRoutes: Array<TRouteLike>;
-};
-export declare function processRouteTree<TRouteLike extends RouteLike>({ routeTree, initRoute, }: {
-    routeTree: TRouteLike;
-    initRoute?: (route: TRouteLike, index: number) => void;
-}): ProcessRouteTreeResult<TRouteLike>;
-export declare function getMatchedRoutes<TRouteLike extends RouteLike>({ pathname, routePathname, basepath, caseSensitive, routesByPath, routesById, flatRoutes, parseCache, }: {
+export declare function getMatchedRoutes<TRouteLike extends RouteLike>({ pathname, routePathname, caseSensitive, routesByPath, routesById, flatRoutes, parseCache, }: {
     pathname: string;
     routePathname?: string;
-    basepath: string;
     caseSensitive?: boolean;
     routesByPath: Record<string, TRouteLike>;
     routesById: Record<string, TRouteLike>;

package/dist/esm/router.js

@@ -1,8 +1,8 @@
 import { Store, batch } from "@tanstack/store";
-import { createMemoryHistory, createBrowserHistory, parseHref } from "@tanstack/history";
-import invariant from "tiny-invariant";
+import { createBrowserHistory, parseHref } from "@tanstack/history";
 import { createControlledPromise, deepEqual, replaceEqualDeep, last, findLast, functionalUpdate } from "./utils.js";
-import { trimPath, resolvePath, cleanPath, matchPathname, trimPathRight, interpolatePath, joinPaths, trimPathLeft, parsePathname, SEGMENT_TYPE_PARAM, SEGMENT_TYPE_OPTIONAL_PARAM, SEGMENT_TYPE_WILDCARD, SEGMENT_TYPE_PATHNAME } from "./path.js";
+import { processRouteTree } from "./process-route-tree.js";
+import { resolvePath, cleanPath, trimPathRight, trimPath, matchPathname, interpolatePath } from "./path.js";
 import { isNotFound } from "./not-found.js";
 import { setupScrollRestoration } from "./scroll-restoration.js";
 import { defaultParseSearch, defaultStringifySearch } from "./searchParams.js";
@@ -10,6 +10,7 @@ import { rootRouteId } from "./root.js";
 import { redirect, isRedirect } from "./redirect.js";
 import { createLRUCache } from "./lru-cache.js";
 import { loadMatches, loadRouteChunk, routeNeedsPreload } from "./load-matches.js";
+import { rewriteBasepath, composeRewrites, executeRewriteInput, executeRewriteOutput } from "./rewrite.js";
 function defaultSerializeError(err) {
   if (err instanceof Error) {
     const obj = {
@@ -54,7 +55,6 @@ class RouterCore {
           "The notFoundRoute API is deprecated and will be removed in the next major version. See https://tanstack.com/router/v1/docs/framework/react/guide/not-found-errors#migrating-from-notfoundroute for more info."
         );
       }
-      const previousOptions = this.options;
       this.options = {
         ...this.options,
         ...newOptions
@@ -66,24 +66,43 @@ class RouterCore {
           char
         ])
       ) : void 0;
-      if (!this.basepath || newOptions.basepath && newOptions.basepath !== previousOptions.basepath) {
-        if (newOptions.basepath === void 0 || newOptions.basepath === "" || newOptions.basepath === "/") {
-          this.basepath = "/";
+      if (!this.history || this.options.history && this.options.history !== this.history) {
+        if (!this.options.history) {
+          if (!this.isServer) {
+            this.history = createBrowserHistory();
+          }
         } else {
-          this.basepath = `/${trimPath(newOptions.basepath)}`;
+          this.history = this.options.history;
         }
       }
-      if (!this.history || this.options.history && this.options.history !== this.history) {
-        this.history = this.options.history ?? (this.isServer ? createMemoryHistory({
-          initialEntries: [this.basepath || "/"]
-        }) : createBrowserHistory());
+      if (this.options.basepath) {
+        const basepathRewrite = rewriteBasepath({
+          basepath: this.options.basepath
+        });
+        if (this.options.rewrite) {
+          this.rewrite = composeRewrites([basepathRewrite, this.options.rewrite]);
+        } else {
+          this.rewrite = basepathRewrite;
+        }
+      } else {
+        this.rewrite = this.options.rewrite;
+      }
+      this.origin = this.options.origin;
+      if (!this.origin) {
+        if (!this.isServer) {
+          this.origin = window.origin;
+        } else {
+          this.origin = "http://localhost";
+        }
+      }
+      if (this.history) {
         this.updateLatestLocation();
       }
       if (this.options.routeTree !== this.routeTree) {
         this.routeTree = this.options.routeTree;
         this.buildRouteTree();
       }
-      if (!this.__store) {
+      if (!this.__store && this.latestLocation) {
         this.__store = new Store(getInitialRouterState(this.latestLocation), {
           onUpdate: () => {
             this.__store.state = {
@@ -147,19 +166,24 @@ class RouterCore {
     };
     this.parseLocation = (locationToParse, previousLocation) => {
       const parse = ({
-        pathname,
-        search,
-        hash,
+        href,
         state
       }) => {
-        const parsedSearch = this.options.parseSearch(search);
+        const fullUrl = new URL(href, this.origin);
+        const url = executeRewriteInput(this.rewrite, fullUrl);
+        const parsedSearch = this.options.parseSearch(url.search);
         const searchStr = this.options.stringifySearch(parsedSearch);
+        url.search = searchStr;
+        const fullPath = url.href.replace(url.origin, "");
+        const { pathname, hash } = url;
         return {
+          href: fullPath,
+          publicHref: href,
+          url: url.href,
           pathname,
           searchStr,
           search: replaceEqualDeep(previousLocation?.search, parsedSearch),
           hash: hash.split("#").reverse()[0] ?? "",
-          href: `${pathname}${searchStr}${hash}`,
           state: replaceEqualDeep(previousLocation?.state, state)
         };
       };
@@ -179,11 +203,9 @@ class RouterCore {
     };
     this.resolvePathWithBase = (from, path) => {
       const resolvedPath = resolvePath({
-        basepath: this.basepath,
         base: from,
         to: cleanPath(path),
         trailingSlash: this.options.trailingSlash,
-        caseSensitive: this.options.caseSensitive,
         parseCache: this.parsePathnameCache
       });
       return resolvedPath;
@@ -205,7 +227,6 @@ class RouterCore {
       return getMatchedRoutes({
         pathname,
         routePathname,
-        basepath: this.basepath,
         caseSensitive: this.options.caseSensitive,
         routesByPath: this.routesByPath,
         routesById: this.routesById,
@@ -313,13 +334,18 @@ class RouterCore {
         const hashStr = hash ? `#${hash}` : "";
         let nextState = dest.state === true ? currentLocation.state : dest.state ? functionalUpdate(dest.state, currentLocation.state) : {};
         nextState = replaceEqualDeep(currentLocation.state, nextState);
+        const fullPath = `${nextPathname}${searchStr}${hashStr}`;
+        const url = new URL(fullPath, this.origin);
+        const rewrittenUrl = executeRewriteOutput(this.rewrite, url);
         return {
+          publicHref: rewrittenUrl.pathname + rewrittenUrl.search + rewrittenUrl.hash,
+          href: fullPath,
+          url: rewrittenUrl.href,
           pathname: nextPathname,
           search: nextSearch,
           searchStr,
           state: nextState,
           hash: hash ?? "",
-          href: `${nextPathname}${searchStr}${hashStr}`,
           unmaskOnReload: dest.unmaskOnReload
         };
       };
@@ -330,7 +356,6 @@ class RouterCore {
           let params = {};
           const foundMask = this.options.routeMasks?.find((d) => {
             const match = matchPathname(
-              this.basepath,
               next.pathname,
               {
                 to: d.from,
@@ -356,8 +381,7 @@ class RouterCore {
           }
         }
         if (maskedNext) {
-          const maskedFinal = build(maskedDest);
-          next.maskedLocation = maskedFinal;
+          next.maskedLocation = maskedNext;
         }
         return next;
       };
@@ -391,7 +415,7 @@ class RouterCore {
         });
         return isEqual;
       };
-      const isSameUrl = this.latestLocation.href === next.href;
+      const isSameUrl = trimPathRight(this.latestLocation.href) === trimPathRight(next.href);
       const previousCommitPromise = this.commitLocationPromise;
       this.commitLocationPromise = createControlledPromise(() => {
         previousCommitPromise?.resolve();
@@ -427,7 +451,7 @@ class RouterCore {
         nextHistory.state.__hashScrollIntoViewOptions = hashScrollIntoView ?? this.options.defaultHashScrollIntoView ?? true;
         this.shouldViewTransition = viewTransition;
         this.history[next.replace ? "replace" : "push"](
-          nextHistory.href,
+          nextHistory.publicHref,
           nextHistory.state,
           { ignoreBlocker }
         );
@@ -480,7 +504,7 @@ class RouterCore {
       if (reloadDocument) {
         if (!href) {
           const location = this.buildLocation({ to, ...rest });
-          href = this.history.createHref(location.href);
+          href = location.href;
         }
         if (rest.replace) {
           window.location.replace(href);
@@ -827,7 +851,6 @@ class RouterCore {
       const pending = opts?.pending === void 0 ? !this.state.isLoading : opts.pending;
       const baseLocation = pending ? this.latestLocation : this.state.resolvedLocation || this.state.location;
       const match = matchPathname(
-        this.basepath,
         baseLocation.pathname,
         {
           ...opts,
@@ -913,25 +936,6 @@ class RouterCore {
       }
       return rootRouteId;
     })();
-    const parseErrors = matchedRoutes.map((route) => {
-      let parsedParamsError;
-      const parseParams = route.options.params?.parse ?? route.options.parseParams;
-      if (parseParams) {
-        try {
-          const parsedParams = parseParams(routeParams);
-          Object.assign(routeParams, parsedParams);
-        } catch (err) {
-          parsedParamsError = new PathParamError(err.message, {
-            cause: err
-          });
-          if (opts?.throwOnError) {
-            throw parsedParamsError;
-          }
-          return parsedParamsError;
-        }
-      }
-      return;
-    });
     const matches = [];
     const getParentContext = (parentMatch) => {
       const parentMatchId = parentMatch?.id;
@@ -970,7 +974,7 @@ class RouterCore {
         search: preMatchSearch
       }) ?? "";
       const loaderDepsHash = loaderDeps ? JSON.stringify(loaderDeps) : "";
-      const { usedParams, interpolatedPath } = interpolatePath({
+      const { interpolatedPath, usedParams } = interpolatePath({
         path: route.fullPath,
         params: routeParams,
         decodeCharMap: this.pathParamsDecodeCharMap
@@ -986,6 +990,27 @@ class RouterCore {
       const previousMatch = this.state.matches.find(
         (d) => d.routeId === route.id
       );
+      const strictParams = existingMatch?._strictParams ?? usedParams;
+      let paramsError = void 0;
+      if (!existingMatch) {
+        const strictParseParams = route.options.params?.parse ?? route.options.parseParams;
+        if (strictParseParams) {
+          try {
+            Object.assign(
+              strictParams,
+              strictParseParams(strictParams)
+            );
+          } catch (err) {
+            paramsError = new PathParamError(err.message, {
+              cause: err
+            });
+            if (opts?.throwOnError) {
+              throw paramsError;
+            }
+          }
+        }
+      }
+      Object.assign(routeParams, strictParams);
       const cause = previousMatch ? "stay" : "enter";
       let match;
       if (existingMatch) {
@@ -993,7 +1018,7 @@ class RouterCore {
           ...existingMatch,
           cause,
           params: previousMatch ? replaceEqualDeep(previousMatch.params, routeParams) : routeParams,
-          _strictParams: usedParams,
+          _strictParams: strictParams,
           search: previousMatch ? replaceEqualDeep(previousMatch.search, preMatchSearch) : replaceEqualDeep(existingMatch.search, preMatchSearch),
           _strictSearch: strictMatchSearch
         };
@@ -1004,8 +1029,8 @@ class RouterCore {
           index,
           routeId: route.id,
           params: previousMatch ? replaceEqualDeep(previousMatch.params, routeParams) : routeParams,
-          _strictParams: usedParams,
-          pathname: joinPaths([this.basepath, interpolatedPath]),
+          _strictParams: strictParams,
+          pathname: interpolatedPath,
           updatedAt: Date.now(),
           search: previousMatch ? replaceEqualDeep(previousMatch.search, preMatchSearch) : preMatchSearch,
           _strictSearch: strictMatchSearch,
@@ -1013,7 +1038,7 @@ class RouterCore {
           status,
           isFetching: false,
           error: void 0,
-          paramsError: parseErrors[index],
+          paramsError,
           __routeContext: void 0,
           _nonReactive: {
             loadPromise: createControlledPromise()
@@ -1125,139 +1150,9 @@ function validateSearch(validateSearch2, input) {
   }
   return {};
 }
-const REQUIRED_PARAM_BASE_SCORE = 0.5;
-const OPTIONAL_PARAM_BASE_SCORE = 0.4;
-const WILDCARD_PARAM_BASE_SCORE = 0.25;
-const BOTH_PRESENCE_BASE_SCORE = 0.05;
-const PREFIX_PRESENCE_BASE_SCORE = 0.02;
-const SUFFIX_PRESENCE_BASE_SCORE = 0.01;
-const PREFIX_LENGTH_SCORE_MULTIPLIER = 2e-4;
-const SUFFIX_LENGTH_SCORE_MULTIPLIER = 1e-4;
-function handleParam(segment, baseScore) {
-  if (segment.prefixSegment && segment.suffixSegment) {
-    return baseScore + BOTH_PRESENCE_BASE_SCORE + PREFIX_LENGTH_SCORE_MULTIPLIER * segment.prefixSegment.length + SUFFIX_LENGTH_SCORE_MULTIPLIER * segment.suffixSegment.length;
-  }
-  if (segment.prefixSegment) {
-    return baseScore + PREFIX_PRESENCE_BASE_SCORE + PREFIX_LENGTH_SCORE_MULTIPLIER * segment.prefixSegment.length;
-  }
-  if (segment.suffixSegment) {
-    return baseScore + SUFFIX_PRESENCE_BASE_SCORE + SUFFIX_LENGTH_SCORE_MULTIPLIER * segment.suffixSegment.length;
-  }
-  return baseScore;
-}
-function processRouteTree({
-  routeTree,
-  initRoute
-}) {
-  const routesById = {};
-  const routesByPath = {};
-  const recurseRoutes = (childRoutes) => {
-    childRoutes.forEach((childRoute, i) => {
-      initRoute?.(childRoute, i);
-      const existingRoute = routesById[childRoute.id];
-      invariant(
-        !existingRoute,
-        `Duplicate routes found with id: ${String(childRoute.id)}`
-      );
-      routesById[childRoute.id] = childRoute;
-      if (!childRoute.isRoot && childRoute.path) {
-        const trimmedFullPath = trimPathRight(childRoute.fullPath);
-        if (!routesByPath[trimmedFullPath] || childRoute.fullPath.endsWith("/")) {
-          routesByPath[trimmedFullPath] = childRoute;
-        }
-      }
-      const children = childRoute.children;
-      if (children?.length) {
-        recurseRoutes(children);
-      }
-    });
-  };
-  recurseRoutes([routeTree]);
-  const scoredRoutes = [];
-  const routes = Object.values(routesById);
-  routes.forEach((d, i) => {
-    if (d.isRoot || !d.path) {
-      return;
-    }
-    const trimmed = trimPathLeft(d.fullPath);
-    let parsed = parsePathname(trimmed);
-    let skip = 0;
-    while (parsed.length > skip + 1 && parsed[skip]?.value === "/") {
-      skip++;
-    }
-    if (skip > 0) parsed = parsed.slice(skip);
-    let optionalParamCount = 0;
-    let hasStaticAfter = false;
-    const scores = parsed.map((segment, index) => {
-      if (segment.value === "/") {
-        return 0.75;
-      }
-      let baseScore = void 0;
-      if (segment.type === SEGMENT_TYPE_PARAM) {
-        baseScore = REQUIRED_PARAM_BASE_SCORE;
-      } else if (segment.type === SEGMENT_TYPE_OPTIONAL_PARAM) {
-        baseScore = OPTIONAL_PARAM_BASE_SCORE;
-        optionalParamCount++;
-      } else if (segment.type === SEGMENT_TYPE_WILDCARD) {
-        baseScore = WILDCARD_PARAM_BASE_SCORE;
-      }
-      if (baseScore) {
-        for (let i2 = index + 1; i2 < parsed.length; i2++) {
-          const nextSegment = parsed[i2];
-          if (nextSegment.type === SEGMENT_TYPE_PATHNAME && nextSegment.value !== "/") {
-            hasStaticAfter = true;
-            return handleParam(segment, baseScore + 0.2);
-          }
-        }
-        return handleParam(segment, baseScore);
-      }
-      return 1;
-    });
-    scoredRoutes.push({
-      child: d,
-      trimmed,
-      parsed,
-      index: i,
-      scores,
-      optionalParamCount,
-      hasStaticAfter
-    });
-  });
-  const flatRoutes = scoredRoutes.sort((a, b) => {
-    const minLength = Math.min(a.scores.length, b.scores.length);
-    for (let i = 0; i < minLength; i++) {
-      if (a.scores[i] !== b.scores[i]) {
-        return b.scores[i] - a.scores[i];
-      }
-    }
-    if (a.scores.length !== b.scores.length) {
-      if (a.optionalParamCount !== b.optionalParamCount) {
-        if (a.hasStaticAfter === b.hasStaticAfter) {
-          return a.optionalParamCount - b.optionalParamCount;
-        } else if (a.hasStaticAfter && !b.hasStaticAfter) {
-          return -1;
-        } else if (!a.hasStaticAfter && b.hasStaticAfter) {
-          return 1;
-        }
-      }
-      return b.scores.length - a.scores.length;
-    }
-    for (let i = 0; i < minLength; i++) {
-      if (a.parsed[i].value !== b.parsed[i].value) {
-        return a.parsed[i].value > b.parsed[i].value ? 1 : -1;
-      }
-    }
-    return a.index - b.index;
-  }).map((d, i) => {
-    d.child.rank = i;
-    return d.child;
-  });
-  return { routesById, routesByPath, flatRoutes };
-}
 function getMatchedRoutes({
   pathname,
   routePathname,
-  basepath,
   caseSensitive,
   routesByPath,
   routesById,
@@ -1268,7 +1163,6 @@ function getMatchedRoutes({
   const trimmedPath = trimPathRight(pathname);
   const getMatchedParams = (route) => {
     const result = matchPathname(
-      basepath,
       trimmedPath,
       {
         to: route.fullPath,
@@ -1398,7 +1292,6 @@ export {
   getInitialRouterState,
   getLocationChangeInfo,
   getMatchedRoutes,
-  lazyFn,
-  processRouteTree
+  lazyFn
 };
 //# sourceMappingURL=router.js.map