@tanstack/react-router 1.97.20 → 1.97.23

package/dist/esm/searchMiddleware.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"searchMiddleware.js","sources":["../../src/searchMiddleware.ts"],"sourcesContent":["import { deepEqual } from './utils'\nimport type { NoInfer, PickOptional } from './utils'\nimport type { SearchMiddleware } from './route'\nimport type { IsRequiredParams } from './link'\n\nexport function retainSearchParams<TSearchSchema extends object>(\n  keys: Array<keyof TSearchSchema> | true,\n): SearchMiddleware<TSearchSchema> {\n  return ({ search, next }) => {\n    const result = next(search)\n    if (keys === true) {\n      return { ...search, ...result }\n    }\n    // add missing keys from search to result\n    keys.forEach((key) => {\n      if (!(key in result)) {\n        result[key] = search[key]\n      }\n    })\n    return result\n  }\n}\n\nexport function stripSearchParams<\n  TSearchSchema,\n  TOptionalProps = PickOptional<NoInfer<TSearchSchema>>,\n  const TValues =\n    | Partial<NoInfer<TOptionalProps>>\n    | Array<keyof TOptionalProps>,\n  const TInput = IsRequiredParams<TSearchSchema> extends never\n    ? TValues | true\n    : TValues,\n>(input: NoInfer<TInput>): SearchMiddleware<TSearchSchema> {\n  return ({ search, next }) => {\n    if (input === true) {\n      return {}\n    }\n    const result = next(search) as Record<string, unknown>\n    if (Array.isArray(input)) {\n      input.forEach((key) => {\n        delete result[key]\n      })\n    } else {\n      Object.entries(input as Record<string, unknown>).forEach(\n        ([key, value]) => {\n          if (deepEqual(result[key], value)) {\n            delete result[key]\n          }\n        },\n      )\n    }\n    return result as any\n  }\n}\n"],"names":[],"mappings":";AAKO,SAAS,mBACd,MACiC;AACjC,SAAO,CAAC,EAAE,QAAQ,WAAW;AACrB,UAAA,SAAS,KAAK,MAAM;AAC1B,QAAI,SAAS,MAAM;AACjB,aAAO,EAAE,GAAG,QAAQ,GAAG,OAAO;AAAA,IAAA;AAG3B,SAAA,QAAQ,CAAC,QAAQ;AAChB,UAAA,EAAE,OAAO,SAAS;AACb,eAAA,GAAG,IAAI,OAAO,GAAG;AAAA,MAAA;AAAA,IAC1B,CACD;AACM,WAAA;AAAA,EACT;AACF;AAEO,SAAS,kBASd,OAAyD;AACzD,SAAO,CAAC,EAAE,QAAQ,WAAW;AAC3B,QAAI,UAAU,MAAM;AAClB,aAAO,CAAC;AAAA,IAAA;AAEJ,UAAA,SAAS,KAAK,MAAM;AACtB,QAAA,MAAM,QAAQ,KAAK,GAAG;AAClB,YAAA,QAAQ,CAAC,QAAQ;AACrB,eAAO,OAAO,GAAG;AAAA,MAAA,CAClB;AAAA,IAAA,OACI;AACE,aAAA,QAAQ,KAAgC,EAAE;AAAA,QAC/C,CAAC,CAAC,KAAK,KAAK,MAAM;AAChB,cAAI,UAAU,OAAO,GAAG,GAAG,KAAK,GAAG;AACjC,mBAAO,OAAO,GAAG;AAAA,UAAA;AAAA,QACnB;AAAA,MAEJ;AAAA,IAAA;AAEK,WAAA;AAAA,EACT;AACF;"}

package/dist/esm/searchParams.d.ts

@@ -1,7 +0,0 @@
-import { AnySchema } from './validators.js';
-export declare const defaultParseSearch: (searchStr: string) => AnySchema;
-export declare const defaultStringifySearch: (search: Record<string, any>) => string;
-export declare function parseSearchWith(parser: (str: string) => any): (searchStr: string) => AnySchema;
-export declare function stringifySearchWith(stringify: (search: any) => string, parser?: (str: string) => any): (search: Record<string, any>) => string;
-export type SearchSerializer = (searchObj: Record<string, any>) => string;
-export type SearchParser = (searchStr: string) => Record<string, any>;

package/dist/esm/searchParams.js

@@ -1,61 +0,0 @@
-import { decode, encode } from "./qss.js";
-const defaultParseSearch = parseSearchWith(JSON.parse);
-const defaultStringifySearch = stringifySearchWith(
-  JSON.stringify,
-  JSON.parse
-);
-function parseSearchWith(parser) {
-  return (searchStr) => {
-    if (searchStr.substring(0, 1) === "?") {
-      searchStr = searchStr.substring(1);
-    }
-    const query = decode(searchStr);
-    for (const key in query) {
-      const value = query[key];
-      if (typeof value === "string") {
-        try {
-          query[key] = parser(value);
-        } catch (err) {
-        }
-      }
-    }
-    return query;
-  };
-}
-function stringifySearchWith(stringify, parser) {
-  function stringifyValue(val) {
-    if (typeof val === "object" && val !== null) {
-      try {
-        return stringify(val);
-      } catch (err) {
-      }
-    } else if (typeof val === "string" && typeof parser === "function") {
-      try {
-        parser(val);
-        return stringify(val);
-      } catch (err) {
-      }
-    }
-    return val;
-  }
-  return (search) => {
-    search = { ...search };
-    Object.keys(search).forEach((key) => {
-      const val = search[key];
-      if (typeof val === "undefined" || val === void 0) {
-        delete search[key];
-      } else {
-        search[key] = stringifyValue(val);
-      }
-    });
-    const searchStr = encode(search).toString();
-    return searchStr ? `?${searchStr}` : "";
-  };
-}
-export {
-  defaultParseSearch,
-  defaultStringifySearch,
-  parseSearchWith,
-  stringifySearchWith
-};
-//# sourceMappingURL=searchParams.js.map

package/dist/esm/searchParams.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"searchParams.js","sources":["../../src/searchParams.ts"],"sourcesContent":["import { decode, encode } from './qss'\nimport type { AnySchema } from './validators'\n\nexport const defaultParseSearch = parseSearchWith(JSON.parse)\nexport const defaultStringifySearch = stringifySearchWith(\n  JSON.stringify,\n  JSON.parse,\n)\n\nexport function parseSearchWith(parser: (str: string) => any) {\n  return (searchStr: string): AnySchema => {\n    if (searchStr.substring(0, 1) === '?') {\n      searchStr = searchStr.substring(1)\n    }\n\n    const query: Record<string, unknown> = decode(searchStr)\n\n    // Try to parse any query params that might be json\n    for (const key in query) {\n      const value = query[key]\n      if (typeof value === 'string') {\n        try {\n          query[key] = parser(value)\n        } catch (err) {\n          //\n        }\n      }\n    }\n\n    return query\n  }\n}\n\nexport function stringifySearchWith(\n  stringify: (search: any) => string,\n  parser?: (str: string) => any,\n) {\n  function stringifyValue(val: any) {\n    if (typeof val === 'object' && val !== null) {\n      try {\n        return stringify(val)\n      } catch (err) {\n        // silent\n      }\n    } else if (typeof val === 'string' && typeof parser === 'function') {\n      try {\n        // Check if it's a valid parseable string.\n        // If it is, then stringify it again.\n        parser(val)\n        return stringify(val)\n      } catch (err) {\n        // silent\n      }\n    }\n    return val\n  }\n\n  return (search: Record<string, any>) => {\n    search = { ...search }\n\n    Object.keys(search).forEach((key) => {\n      const val = search[key]\n      if (typeof val === 'undefined' || val === undefined) {\n        delete search[key]\n      } else {\n        search[key] = stringifyValue(val)\n      }\n    })\n\n    const searchStr = encode(search as Record<string, string>).toString()\n\n    return searchStr ? `?${searchStr}` : ''\n  }\n}\n\nexport type SearchSerializer = (searchObj: Record<string, any>) => string\nexport type SearchParser = (searchStr: string) => Record<string, any>\n"],"names":[],"mappings":";AAGa,MAAA,qBAAqB,gBAAgB,KAAK,KAAK;AACrD,MAAM,yBAAyB;AAAA,EACpC,KAAK;AAAA,EACL,KAAK;AACP;AAEO,SAAS,gBAAgB,QAA8B;AAC5D,SAAO,CAAC,cAAiC;AACvC,QAAI,UAAU,UAAU,GAAG,CAAC,MAAM,KAAK;AACzB,kBAAA,UAAU,UAAU,CAAC;AAAA,IAAA;AAG7B,UAAA,QAAiC,OAAO,SAAS;AAGvD,eAAW,OAAO,OAAO;AACjB,YAAA,QAAQ,MAAM,GAAG;AACnB,UAAA,OAAO,UAAU,UAAU;AACzB,YAAA;AACI,gBAAA,GAAG,IAAI,OAAO,KAAK;AAAA,iBAClB,KAAK;AAAA,QAAA;AAAA,MAEd;AAAA,IACF;AAGK,WAAA;AAAA,EACT;AACF;AAEgB,SAAA,oBACd,WACA,QACA;AACA,WAAS,eAAe,KAAU;AAChC,QAAI,OAAO,QAAQ,YAAY,QAAQ,MAAM;AACvC,UAAA;AACF,eAAO,UAAU,GAAG;AAAA,eACb,KAAK;AAAA,MAAA;AAAA,eAGL,OAAO,QAAQ,YAAY,OAAO,WAAW,YAAY;AAC9D,UAAA;AAGF,eAAO,GAAG;AACV,eAAO,UAAU,GAAG;AAAA,eACb,KAAK;AAAA,MAAA;AAAA,IAEd;AAEK,WAAA;AAAA,EAAA;AAGT,SAAO,CAAC,WAAgC;AAC7B,aAAA,EAAE,GAAG,OAAO;AAErB,WAAO,KAAK,MAAM,EAAE,QAAQ,CAAC,QAAQ;AAC7B,YAAA,MAAM,OAAO,GAAG;AACtB,UAAI,OAAO,QAAQ,eAAe,QAAQ,QAAW;AACnD,eAAO,OAAO,GAAG;AAAA,MAAA,OACZ;AACE,eAAA,GAAG,IAAI,eAAe,GAAG;AAAA,MAAA;AAAA,IAClC,CACD;AAED,UAAM,YAAY,OAAO,MAAgC,EAAE,SAAS;AAE7D,WAAA,YAAY,IAAI,SAAS,KAAK;AAAA,EACvC;AACF;"}

package/dist/esm/serializer.d.ts

@@ -1,15 +0,0 @@
-export interface StartSerializer {
-    stringify: (obj: unknown) => string;
-    parse: (str: string) => unknown;
-    encode: <T>(value: T) => T;
-    decode: <T>(value: T) => T;
-}
-export type SerializerStringifyBy<T, TSerializable> = T extends TSerializable ? T : T extends (...args: Array<any>) => any ? 'Function is not serializable' : {
-    [K in keyof T]: SerializerStringifyBy<T[K], TSerializable>;
-};
-export type SerializerParseBy<T, TSerializable> = T extends TSerializable ? T : T extends React.JSX.Element ? ReadableStream : {
-    [K in keyof T]: SerializerParseBy<T[K], TSerializable>;
-};
-export type Serializable = Date | undefined | Error | FormData;
-export type SerializerStringify<T> = SerializerStringifyBy<T, Serializable>;
-export type SerializerParse<T> = SerializerParseBy<T, Serializable>;

package/dist/esm/validators.d.ts

@@ -1,51 +0,0 @@
-import { SearchSchemaInput } from './route.js';
-export interface StandardSchemaValidatorProps<TInput, TOutput> {
-    readonly types?: StandardSchemaValidatorTypes<TInput, TOutput> | undefined;
-    readonly validate: AnyStandardSchemaValidate;
-}
-export interface StandardSchemaValidator<TInput, TOutput> {
-    readonly '~standard': StandardSchemaValidatorProps<TInput, TOutput>;
-}
-export type AnyStandardSchemaValidator = StandardSchemaValidator<any, any>;
-export interface StandardSchemaValidatorTypes<TInput, TOutput> {
-    readonly input: TInput;
-    readonly output: TOutput;
-}
-export interface AnyStandardSchemaValidateSuccess {
-    readonly value: any;
-    readonly issues?: undefined;
-}
-export interface AnyStandardSchemaValidateFailure {
-    readonly issues: ReadonlyArray<AnyStandardSchemaValidateIssue>;
-}
-export interface AnyStandardSchemaValidateIssue {
-    readonly message: string;
-}
-export interface AnyStandardSchemaValidateInput {
-    readonly value: any;
-}
-export type AnyStandardSchemaValidate = (value: unknown) => (AnyStandardSchemaValidateSuccess | AnyStandardSchemaValidateFailure) | Promise<AnyStandardSchemaValidateSuccess | AnyStandardSchemaValidateFailure>;
-export interface ValidatorObj<TInput, TOutput> {
-    parse: ValidatorFn<TInput, TOutput>;
-}
-export type AnyValidatorObj = ValidatorObj<any, any>;
-export interface ValidatorAdapter<TInput, TOutput> {
-    types: {
-        input: TInput;
-        output: TOutput;
-    };
-    parse: (input: unknown) => TOutput;
-}
-export type AnyValidatorAdapter = ValidatorAdapter<any, any>;
-export type AnyValidatorFn = ValidatorFn<any, any>;
-export type ValidatorFn<TInput, TOutput> = (input: TInput) => TOutput;
-export type Validator<TInput, TOutput> = ValidatorObj<TInput, TOutput> | ValidatorFn<TInput, TOutput> | ValidatorAdapter<TInput, TOutput> | StandardSchemaValidator<TInput, TOutput> | undefined;
-export type AnyValidator = Validator<any, any>;
-export type AnySchema = {};
-export type DefaultValidator = Validator<Record<string, unknown>, AnySchema>;
-export type ResolveSearchValidatorInputFn<TValidator> = TValidator extends (input: infer TSchemaInput) => any ? TSchemaInput extends SearchSchemaInput ? Omit<TSchemaInput, keyof SearchSchemaInput> : ResolveValidatorOutputFn<TValidator> : AnySchema;
-export type ResolveSearchValidatorInput<TValidator> = TValidator extends AnyStandardSchemaValidator ? NonNullable<TValidator['~standard']['types']>['input'] : TValidator extends AnyValidatorAdapter ? TValidator['types']['input'] : TValidator extends AnyValidatorObj ? ResolveSearchValidatorInputFn<TValidator['parse']> : ResolveSearchValidatorInputFn<TValidator>;
-export type ResolveValidatorInputFn<TValidator> = TValidator extends (input: infer TInput) => any ? TInput : undefined;
-export type ResolveValidatorInput<TValidator> = TValidator extends AnyStandardSchemaValidator ? NonNullable<TValidator['~standard']['types']>['input'] : TValidator extends AnyValidatorAdapter ? TValidator['types']['input'] : TValidator extends AnyValidatorObj ? ResolveValidatorInputFn<TValidator['parse']> : ResolveValidatorInputFn<TValidator>;
-export type ResolveValidatorOutputFn<TValidator> = TValidator extends (...args: any) => infer TSchema ? TSchema : AnySchema;
-export type ResolveValidatorOutput<TValidator> = unknown extends TValidator ? TValidator : TValidator extends AnyStandardSchemaValidator ? NonNullable<TValidator['~standard']['types']>['output'] : TValidator extends AnyValidatorAdapter ? TValidator['types']['output'] : TValidator extends AnyValidatorObj ? ResolveValidatorOutputFn<TValidator['parse']> : ResolveValidatorOutputFn<TValidator>;

package/src/defer.ts

@@ -1,52 +0,0 @@
-import { defaultSerializeError } from './router'
-
-export const TSR_DEFERRED_PROMISE = Symbol.for('TSR_DEFERRED_PROMISE')
-
-export type DeferredPromiseState<T> =
-  | {
-      status: 'pending'
-      data?: T
-      error?: unknown
-    }
-  | {
-      status: 'success'
-      data: T
-    }
-  | {
-      status: 'error'
-      data?: T
-      error: unknown
-    }
-
-export type DeferredPromise<T> = Promise<T> & {
-  [TSR_DEFERRED_PROMISE]: DeferredPromiseState<T>
-}
-
-export function defer<T>(
-  _promise: Promise<T>,
-  options?: {
-    serializeError?: typeof defaultSerializeError
-  },
-) {
-  const promise = _promise as DeferredPromise<T>
-  // this is already deferred promise
-  if ((promise as any)[TSR_DEFERRED_PROMISE]) {
-    return promise
-  }
-  promise[TSR_DEFERRED_PROMISE] = { status: 'pending' }
-
-  promise
-    .then((data) => {
-      promise[TSR_DEFERRED_PROMISE].status = 'success'
-      promise[TSR_DEFERRED_PROMISE].data = data
-    })
-    .catch((error) => {
-      promise[TSR_DEFERRED_PROMISE].status = 'error'
-      ;(promise[TSR_DEFERRED_PROMISE] as any).error = {
-        data: (options?.serializeError ?? defaultSerializeError)(error),
-        __isServerError: true,
-      }
-    })
-
-  return promise
-}

package/src/location.ts

@@ -1,13 +0,0 @@
-import type { ParsedHistoryState } from '@tanstack/history'
-import type { AnySchema } from './validators'
-
-export interface ParsedLocation<TSearchObj extends AnySchema = {}> {
-  href: string
-  pathname: string
-  search: TSearchObj
-  searchStr: string
-  state: ParsedHistoryState
-  hash: string
-  maskedLocation?: ParsedLocation<TSearchObj>
-  unmaskOnReload?: boolean
-}

package/src/manifest.ts

@@ -1,32 +0,0 @@
-export type Manifest = {
-  routes: Record<
-    string,
-    {
-      filePath?: string
-      preloads?: Array<string>
-      assets?: Array<RouterManagedTag>
-    }
-  >
-}
-
-export type RouterManagedTag =
-  | {
-      tag: 'title'
-      attrs?: Record<string, any>
-      children: string
-    }
-  | {
-      tag: 'meta' | 'link'
-      attrs?: Record<string, any>
-      children?: never
-    }
-  | {
-      tag: 'script'
-      attrs?: Record<string, any>
-      children?: string
-    }
-  | {
-      tag: 'style'
-      attrs?: Record<string, any>
-      children?: string
-    }

package/src/path.ts

@@ -1,427 +0,0 @@
-import { last } from './utils'
-import type { MatchLocation } from './RouterProvider'
-import type { AnyPathParams } from './route'
-
-export interface Segment {
-  type: 'pathname' | 'param' | 'wildcard'
-  value: string
-}
-
-export function joinPaths(paths: Array<string | undefined>) {
-  return cleanPath(
-    paths
-      .filter((val) => {
-        return val !== undefined
-      })
-      .join('/'),
-  )
-}
-
-export function cleanPath(path: string) {
-  // remove double slashes
-  return path.replace(/\/{2,}/g, '/')
-}
-
-export function trimPathLeft(path: string) {
-  return path === '/' ? path : path.replace(/^\/{1,}/, '')
-}
-
-export function trimPathRight(path: string) {
-  return path === '/' ? path : path.replace(/\/{1,}$/, '')
-}
-
-export function trimPath(path: string) {
-  return trimPathRight(trimPathLeft(path))
-}
-
-export function removeTrailingSlash(value: string, basepath: string): string {
-  if (value.endsWith('/') && value !== '/' && value !== `${basepath}/`) {
-    return value.slice(0, -1)
-  }
-  return value
-}
-
-// intended to only compare path name
-// see the usage in the isActive under useLinkProps
-// /sample/path1 = /sample/path1/
-// /sample/path1/some <> /sample/path1
-export function exactPathTest(
-  pathName1: string,
-  pathName2: string,
-  basepath: string,
-): boolean {
-  return (
-    removeTrailingSlash(pathName1, basepath) ===
-    removeTrailingSlash(pathName2, basepath)
-  )
-}
-
-// When resolving relative paths, we treat all paths as if they are trailing slash
-// documents. All trailing slashes are removed after the path is resolved.
-// Here are a few examples:
-//
-// /a/b/c + ./d = /a/b/c/d
-// /a/b/c + ../d = /a/b/d
-// /a/b/c + ./d/ = /a/b/c/d
-// /a/b/c + ../d/ = /a/b/d
-// /a/b/c + ./ = /a/b/c
-//
-// Absolute paths that start with `/` short circuit the resolution process to the root
-// path.
-//
-// Here are some examples:
-//
-// /a/b/c + /d = /d
-// /a/b/c + /d/ = /d
-// /a/b/c + / = /
-//
-// Non-.-prefixed paths are still treated as relative paths, resolved like `./`
-//
-// Here are some examples:
-//
-// /a/b/c + d = /a/b/c/d
-// /a/b/c + d/ = /a/b/c/d
-// /a/b/c + d/e = /a/b/c/d/e
-interface ResolvePathOptions {
-  basepath: string
-  base: string
-  to: string
-  trailingSlash?: 'always' | 'never' | 'preserve'
-  caseSensitive?: boolean
-}
-
-export function resolvePath({
-  basepath,
-  base,
-  to,
-  trailingSlash = 'never',
-  caseSensitive,
-}: ResolvePathOptions) {
-  base = removeBasepath(basepath, base, caseSensitive)
-  to = removeBasepath(basepath, to, caseSensitive)
-
-  let baseSegments = parsePathname(base)
-  const toSegments = parsePathname(to)
-
-  if (baseSegments.length > 1 && last(baseSegments)?.value === '/') {
-    baseSegments.pop()
-  }
-
-  toSegments.forEach((toSegment, index) => {
-    if (toSegment.value === '/') {
-      if (!index) {
-        // Leading slash
-        baseSegments = [toSegment]
-      } else if (index === toSegments.length - 1) {
-        // Trailing Slash
-        baseSegments.push(toSegment)
-      } else {
-        // ignore inter-slashes
-      }
-    } else if (toSegment.value === '..') {
-      baseSegments.pop()
-    } else if (toSegment.value === '.') {
-      // ignore
-    } else {
-      baseSegments.push(toSegment)
-    }
-  })
-
-  if (baseSegments.length > 1) {
-    if (last(baseSegments)?.value === '/') {
-      if (trailingSlash === 'never') {
-        baseSegments.pop()
-      }
-    } else if (trailingSlash === 'always') {
-      baseSegments.push({ type: 'pathname', value: '/' })
-    }
-  }
-
-  const joined = joinPaths([basepath, ...baseSegments.map((d) => d.value)])
-  return cleanPath(joined)
-}
-
-export function parsePathname(pathname?: string): Array<Segment> {
-  if (!pathname) {
-    return []
-  }
-
-  pathname = cleanPath(pathname)
-
-  const segments: Array<Segment> = []
-
-  if (pathname.slice(0, 1) === '/') {
-    pathname = pathname.substring(1)
-    segments.push({
-      type: 'pathname',
-      value: '/',
-    })
-  }
-
-  if (!pathname) {
-    return segments
-  }
-
-  // Remove empty segments and '.' segments
-  const split = pathname.split('/').filter(Boolean)
-
-  segments.push(
-    ...split.map((part): Segment => {
-      if (part === '$' || part === '*') {
-        return {
-          type: 'wildcard',
-          value: part,
-        }
-      }
-
-      if (part.charAt(0) === '$') {
-        return {
-          type: 'param',
-          value: part,
-        }
-      }
-
-      return {
-        type: 'pathname',
-        value: decodeURI(part),
-      }
-    }),
-  )
-
-  if (pathname.slice(-1) === '/') {
-    pathname = pathname.substring(1)
-    segments.push({
-      type: 'pathname',
-      value: '/',
-    })
-  }
-
-  return segments
-}
-
-interface InterpolatePathOptions {
-  path?: string
-  params: Record<string, unknown>
-  leaveWildcards?: boolean
-  leaveParams?: boolean
-  // Map of encoded chars to decoded chars (e.g. '%40' -> '@') that should remain decoded in path params
-  decodeCharMap?: Map<string, string>
-}
-
-export function interpolatePath({
-  path,
-  params,
-  leaveWildcards,
-  leaveParams,
-  decodeCharMap,
-}: InterpolatePathOptions) {
-  const interpolatedPathSegments = parsePathname(path)
-  const encodedParams: any = {}
-
-  for (const [key, value] of Object.entries(params)) {
-    const isValueString = typeof value === 'string'
-
-    if (['*', '_splat'].includes(key)) {
-      // the splat/catch-all routes shouldn't have the '/' encoded out
-      encodedParams[key] = isValueString ? encodeURI(value) : value
-    } else {
-      encodedParams[key] = isValueString
-        ? encodePathParam(value, decodeCharMap)
-        : value
-    }
-  }
-
-  return joinPaths(
-    interpolatedPathSegments.map((segment) => {
-      if (segment.type === 'wildcard') {
-        const value = encodedParams._splat
-        if (leaveWildcards) return `${segment.value}${value ?? ''}`
-        return value
-      }
-
-      if (segment.type === 'param') {
-        if (leaveParams) {
-          const value = encodedParams[segment.value]
-          return `${segment.value}${value ?? ''}`
-        }
-        return encodedParams![segment.value.substring(1)] ?? 'undefined'
-      }
-
-      return segment.value
-    }),
-  )
-}
-
-function encodePathParam(value: string, decodeCharMap?: Map<string, string>) {
-  let encoded = encodeURIComponent(value)
-  if (decodeCharMap) {
-    for (const [encodedChar, char] of decodeCharMap) {
-      encoded = encoded.replaceAll(encodedChar, char)
-    }
-  }
-  return encoded
-}
-
-export function matchPathname(
-  basepath: string,
-  currentPathname: string,
-  matchLocation: Pick<MatchLocation, 'to' | 'fuzzy' | 'caseSensitive'>,
-): AnyPathParams | undefined {
-  const pathParams = matchByPath(basepath, currentPathname, matchLocation)
-  // const searchMatched = matchBySearch(location.search, matchLocation)
-
-  if (matchLocation.to && !pathParams) {
-    return
-  }
-
-  return pathParams ?? {}
-}
-
-export function removeBasepath(
-  basepath: string,
-  pathname: string,
-  caseSensitive: boolean = false,
-) {
-  // normalize basepath and pathname for case-insensitive comparison if needed
-  const normalizedBasepath = caseSensitive ? basepath : basepath.toLowerCase()
-  const normalizedPathname = caseSensitive ? pathname : pathname.toLowerCase()
-
-  switch (true) {
-    // default behaviour is to serve app from the root - pathname
-    // left untouched
-    case normalizedBasepath === '/':
-      return pathname
-
-    // shortcut for removing the basepath if it matches the pathname
-    case normalizedPathname === normalizedBasepath:
-      return ''
-
-    // in case pathname is shorter than basepath - there is
-    // nothing to remove
-    case pathname.length < basepath.length:
-      return pathname
-
-    // avoid matching partial segments - strict equality handled
-    // earlier, otherwise, basepath separated from pathname with
-    // separator, therefore lack of separator means partial
-    // segment match (`/app` should not match `/application`)
-    case normalizedPathname[normalizedBasepath.length] !== '/':
-      return pathname
-
-    // remove the basepath from the pathname if it starts with it
-    case normalizedPathname.startsWith(normalizedBasepath):
-      return pathname.slice(basepath.length)
-
-    // otherwise, return the pathname as is
-    default:
-      return pathname
-  }
-}
-
-export function matchByPath(
-  basepath: string,
-  from: string,
-  matchLocation: Pick<MatchLocation, 'to' | 'caseSensitive' | 'fuzzy'>,
-): Record<string, string> | undefined {
-  // check basepath first
-  if (basepath !== '/' && !from.startsWith(basepath)) {
-    return undefined
-  }
-  // Remove the base path from the pathname
-  from = removeBasepath(basepath, from, matchLocation.caseSensitive)
-  // Default to to $ (wildcard)
-  const to = removeBasepath(
-    basepath,
-    `${matchLocation.to ?? '$'}`,
-    matchLocation.caseSensitive,
-  )
-
-  // Parse the from and to
-  const baseSegments = parsePathname(from)
-  const routeSegments = parsePathname(to)
-
-  if (!from.startsWith('/')) {
-    baseSegments.unshift({
-      type: 'pathname',
-      value: '/',
-    })
-  }
-
-  if (!to.startsWith('/')) {
-    routeSegments.unshift({
-      type: 'pathname',
-      value: '/',
-    })
-  }
-
-  const params: Record<string, string> = {}
-
-  const isMatch = (() => {
-    for (
-      let i = 0;
-      i < Math.max(baseSegments.length, routeSegments.length);
-      i++
-    ) {
-      const baseSegment = baseSegments[i]
-      const routeSegment = routeSegments[i]
-
-      const isLastBaseSegment = i >= baseSegments.length - 1
-      const isLastRouteSegment = i >= routeSegments.length - 1
-
-      if (routeSegment) {
-        if (routeSegment.type === 'wildcard') {
-          const _splat = decodeURI(
-            joinPaths(baseSegments.slice(i).map((d) => d.value)),
-          )
-          // TODO: Deprecate *
-          params['*'] = _splat
-          params['_splat'] = _splat
-          return true
-        }
-
-        if (routeSegment.type === 'pathname') {
-          if (routeSegment.value === '/' && !baseSegment?.value) {
-            return true
-          }
-
-          if (baseSegment) {
-            if (matchLocation.caseSensitive) {
-              if (routeSegment.value !== baseSegment.value) {
-                return false
-              }
-            } else if (
-              routeSegment.value.toLowerCase() !==
-              baseSegment.value.toLowerCase()
-            ) {
-              return false
-            }
-          }
-        }
-
-        if (!baseSegment) {
-          return false
-        }
-
-        if (routeSegment.type === 'param') {
-          if (baseSegment.value === '/') {
-            return false
-          }
-          if (baseSegment.value.charAt(0) !== '$') {
-            params[routeSegment.value.substring(1)] = decodeURIComponent(
-              baseSegment.value,
-            )
-          }
-        }
-      }
-
-      if (!isLastBaseSegment && isLastRouteSegment) {
-        params['**'] = joinPaths(baseSegments.slice(i + 1).map((d) => d.value))
-        return !!matchLocation.fuzzy && routeSegment?.value !== '/'
-      }
-    }
-
-    return true
-  })()
-
-  return isMatch ? params : undefined
-}