@tanstack/router-core 1.128.4 → 1.128.6

package/src/path.ts

@@ -2,13 +2,22 @@ import { last } from './utils'
 import type { MatchLocation } from './RouterProvider'
 import type { AnyPathParams } from './route'
 
+export const SEGMENT_TYPE_PATHNAME = 0
+export const SEGMENT_TYPE_PARAM = 1
+export const SEGMENT_TYPE_WILDCARD = 2
+export const SEGMENT_TYPE_OPTIONAL_PARAM = 3
+
 export interface Segment {
-  type: 'pathname' | 'param' | 'wildcard' | 'optional-param'
-  value: string
-  prefixSegment?: string
-  suffixSegment?: string
+  readonly type:
+    | typeof SEGMENT_TYPE_PATHNAME
+    | typeof SEGMENT_TYPE_PARAM
+    | typeof SEGMENT_TYPE_WILDCARD
+    | typeof SEGMENT_TYPE_OPTIONAL_PARAM
+  readonly value: string
+  readonly prefixSegment?: string
+  readonly suffixSegment?: string
   // Indicates if there is a static segment after this required/optional param
-  hasStaticAfter?: boolean
+  readonly hasStaticAfter?: boolean
 }
 
 export function joinPaths(paths: Array<string | undefined>) {
@@ -94,6 +103,51 @@ interface ResolvePathOptions {
   caseSensitive?: boolean
 }
 
+function segmentToString(segment: Segment): string {
+  const { type, value } = segment
+  if (type === SEGMENT_TYPE_PATHNAME) {
+    return value
+  }
+
+  const { prefixSegment, suffixSegment } = segment
+
+  if (type === SEGMENT_TYPE_PARAM) {
+    const param = value.substring(1)
+    if (prefixSegment && suffixSegment) {
+      return `${prefixSegment}{$${param}}${suffixSegment}`
+    } else if (prefixSegment) {
+      return `${prefixSegment}{$${param}}`
+    } else if (suffixSegment) {
+      return `{$${param}}${suffixSegment}`
+    }
+  }
+
+  if (type === SEGMENT_TYPE_OPTIONAL_PARAM) {
+    const param = value.substring(1)
+    if (prefixSegment && suffixSegment) {
+      return `${prefixSegment}{-$${param}}${suffixSegment}`
+    } else if (prefixSegment) {
+      return `${prefixSegment}{-$${param}}`
+    } else if (suffixSegment) {
+      return `{-$${param}}${suffixSegment}`
+    }
+    return `{-$${param}}`
+  }
+
+  if (type === SEGMENT_TYPE_WILDCARD) {
+    if (prefixSegment && suffixSegment) {
+      return `${prefixSegment}{$}${suffixSegment}`
+    } else if (prefixSegment) {
+      return `${prefixSegment}{$}`
+    } else if (suffixSegment) {
+      return `{$}${suffixSegment}`
+    }
+  }
+
+  // This case should never happen, should we throw instead?
+  return value
+}
+
 export function resolvePath({
   basepath,
   base,
@@ -104,79 +158,48 @@ export function resolvePath({
   base = removeBasepath(basepath, base, caseSensitive)
   to = removeBasepath(basepath, to, caseSensitive)
 
-  let baseSegments = parsePathname(base)
+  let baseSegments = parsePathname(base).slice()
   const toSegments = parsePathname(to)
 
   if (baseSegments.length > 1 && last(baseSegments)?.value === '/') {
     baseSegments.pop()
   }
 
-  toSegments.forEach((toSegment, index) => {
-    if (toSegment.value === '/') {
+  for (let index = 0, length = toSegments.length; index < length; index++) {
+    const toSegment = toSegments[index]!
+    const value = toSegment.value
+    if (value === '/') {
       if (!index) {
         // Leading slash
         baseSegments = [toSegment]
-      } else if (index === toSegments.length - 1) {
+      } else if (index === length - 1) {
         // Trailing Slash
         baseSegments.push(toSegment)
       } else {
         // ignore inter-slashes
       }
-    } else if (toSegment.value === '..') {
+    } else if (value === '..') {
       baseSegments.pop()
-    } else if (toSegment.value === '.') {
+    } else if (value === '.') {
       // ignore
     } else {
       baseSegments.push(toSegment)
     }
-  })
+  }
 
   if (baseSegments.length > 1) {
-    if (last(baseSegments)?.value === '/') {
+    if (last(baseSegments)!.value === '/') {
       if (trailingSlash === 'never') {
         baseSegments.pop()
       }
     } else if (trailingSlash === 'always') {
-      baseSegments.push({ type: 'pathname', value: '/' })
+      baseSegments.push({ type: SEGMENT_TYPE_PATHNAME, value: '/' })
     }
   }
 
-  const segmentValues = baseSegments.map((segment) => {
-    if (segment.type === 'param') {
-      const param = segment.value.substring(1)
-      if (segment.prefixSegment && segment.suffixSegment) {
-        return `${segment.prefixSegment}{$${param}}${segment.suffixSegment}`
-      } else if (segment.prefixSegment) {
-        return `${segment.prefixSegment}{$${param}}`
-      } else if (segment.suffixSegment) {
-        return `{$${param}}${segment.suffixSegment}`
-      }
-    }
-    if (segment.type === 'optional-param') {
-      const param = segment.value.substring(1)
-      if (segment.prefixSegment && segment.suffixSegment) {
-        return `${segment.prefixSegment}{-$${param}}${segment.suffixSegment}`
-      } else if (segment.prefixSegment) {
-        return `${segment.prefixSegment}{-$${param}}`
-      } else if (segment.suffixSegment) {
-        return `{-$${param}}${segment.suffixSegment}`
-      }
-      return `{-$${param}}`
-    }
-
-    if (segment.type === 'wildcard') {
-      if (segment.prefixSegment && segment.suffixSegment) {
-        return `${segment.prefixSegment}{$}${segment.suffixSegment}`
-      } else if (segment.prefixSegment) {
-        return `${segment.prefixSegment}{$}`
-      } else if (segment.suffixSegment) {
-        return `{$}${segment.suffixSegment}`
-      }
-    }
-    return segment.value
-  })
+  const segmentValues = baseSegments.map(segmentToString)
   const joined = joinPaths([basepath, ...segmentValues])
-  return cleanPath(joined)
+  return joined
 }
 
 const PARAM_RE = /^\$.{1,}$/ // $paramName
@@ -204,7 +227,7 @@ const WILDCARD_W_CURLY_BRACES_RE = /^(.*?)\{\$\}(.*)$/ // prefix{$}suffix
  * - `/foo/[$]{$foo} - Dynamic route with a static prefix of `$`
  * - `/foo/{$foo}[$]` - Dynamic route with a static suffix of `$`
  */
-export function parsePathname(pathname?: string): Array<Segment> {
+export function parsePathname(pathname?: string): ReadonlyArray<Segment> {
   if (!pathname) {
     return []
   }
@@ -216,7 +239,7 @@ export function parsePathname(pathname?: string): Array<Segment> {
   if (pathname.slice(0, 1) === '/') {
     pathname = pathname.substring(1)
     segments.push({
-      type: 'pathname',
+      type: SEGMENT_TYPE_PATHNAME,
       value: '/',
     })
   }
@@ -236,7 +259,7 @@ export function parsePathname(pathname?: string): Array<Segment> {
         const prefix = wildcardBracesMatch[1]
         const suffix = wildcardBracesMatch[2]
         return {
-          type: 'wildcard',
+          type: SEGMENT_TYPE_WILDCARD,
           value: '$',
           prefixSegment: prefix || undefined,
           suffixSegment: suffix || undefined,
@@ -252,7 +275,7 @@ export function parsePathname(pathname?: string): Array<Segment> {
         const paramName = optionalParamBracesMatch[2]!
         const suffix = optionalParamBracesMatch[3]
         return {
-          type: 'optional-param',
+          type: SEGMENT_TYPE_OPTIONAL_PARAM,
           value: paramName, // Now just $paramName (no prefix)
           prefixSegment: prefix || undefined,
           suffixSegment: suffix || undefined,
@@ -266,7 +289,7 @@ export function parsePathname(pathname?: string): Array<Segment> {
         const paramName = paramBracesMatch[2]
         const suffix = paramBracesMatch[3]
         return {
-          type: 'param',
+          type: SEGMENT_TYPE_PARAM,
           value: '' + paramName,
           prefixSegment: prefix || undefined,
           suffixSegment: suffix || undefined,
@@ -277,7 +300,7 @@ export function parsePathname(pathname?: string): Array<Segment> {
       if (PARAM_RE.test(part)) {
         const paramName = part.substring(1)
         return {
-          type: 'param',
+          type: SEGMENT_TYPE_PARAM,
           value: '$' + paramName,
           prefixSegment: undefined,
           suffixSegment: undefined,
@@ -287,7 +310,7 @@ export function parsePathname(pathname?: string): Array<Segment> {
       // Check for bare wildcard: $ (without curly braces)
       if (WILDCARD_RE.test(part)) {
         return {
-          type: 'wildcard',
+          type: SEGMENT_TYPE_WILDCARD,
           value: '$',
           prefixSegment: undefined,
           suffixSegment: undefined,
@@ -296,7 +319,7 @@ export function parsePathname(pathname?: string): Array<Segment> {
 
       // Handle regular pathname segment
       return {
-        type: 'pathname',
+        type: SEGMENT_TYPE_PATHNAME,
         value: part.includes('%25')
           ? part
               .split('%25')
@@ -310,7 +333,7 @@ export function parsePathname(pathname?: string): Array<Segment> {
   if (pathname.slice(-1) === '/') {
     pathname = pathname.substring(1)
     segments.push({
-      type: 'pathname',
+      type: SEGMENT_TYPE_PATHNAME,
       value: '/',
     })
   }
@@ -345,7 +368,7 @@ export function interpolatePath({
     const value = params[key]
     const isValueString = typeof value === 'string'
 
-    if (['*', '_splat'].includes(key)) {
+    if (key === '*' || key === '_splat') {
       // the splat/catch-all routes shouldn't have the '/' encoded out
       return isValueString ? encodeURI(value) : value
     } else {
@@ -360,7 +383,11 @@ export function interpolatePath({
   const usedParams: Record<string, unknown> = {}
   const interpolatedPath = joinPaths(
     interpolatedPathSegments.map((segment) => {
-      if (segment.type === 'wildcard') {
+      if (segment.type === SEGMENT_TYPE_PATHNAME) {
+        return segment.value
+      }
+
+      if (segment.type === SEGMENT_TYPE_WILDCARD) {
         usedParams._splat = params._splat
         const segmentPrefix = segment.prefixSegment || ''
         const segmentSuffix = segment.suffixSegment || ''
@@ -386,7 +413,7 @@ export function interpolatePath({
         return `${segmentPrefix}${value}${segmentSuffix}`
       }
 
-      if (segment.type === 'param') {
+      if (segment.type === SEGMENT_TYPE_PARAM) {
         const key = segment.value.substring(1)
         if (!isMissingParams && !(key in params)) {
           isMissingParams = true
@@ -402,7 +429,7 @@ export function interpolatePath({
         return `${segmentPrefix}${encodeParam(key) ?? 'undefined'}${segmentSuffix}`
       }
 
-      if (segment.type === 'optional-param') {
+      if (segment.type === SEGMENT_TYPE_OPTIONAL_PARAM) {
         const key = segment.value.substring(1)
 
         const segmentPrefix = segment.prefixSegment || ''
@@ -410,6 +437,9 @@ export function interpolatePath({
 
         // Check if optional parameter is missing or undefined
         if (!(key in params) || params[key] == null) {
+          if (leaveWildcards) {
+            return `${segmentPrefix}${key}${segmentSuffix}`
+          }
           // For optional params with prefix/suffix, keep the prefix/suffix but omit the param
           if (segmentPrefix || segmentSuffix) {
             return `${segmentPrefix}${segmentSuffix}`
@@ -502,165 +532,217 @@ export function removeBasepath(
 export function matchByPath(
   basepath: string,
   from: string,
-  matchLocation: Pick<MatchLocation, 'to' | 'caseSensitive' | 'fuzzy'>,
+  {
+    to,
+    fuzzy,
+    caseSensitive,
+  }: 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)
+  from = removeBasepath(basepath, from, caseSensitive)
   // Default to to $ (wildcard)
-  const to = removeBasepath(
-    basepath,
-    `${matchLocation.to ?? '$'}`,
-    matchLocation.caseSensitive,
-  )
+  to = removeBasepath(basepath, `${to ?? '$'}`, caseSensitive)
 
   // Parse the from and to
-  const baseSegments = parsePathname(from)
-  const routeSegments = parsePathname(to)
+  const baseSegments = parsePathname(from.startsWith('/') ? from : `/${from}`)
+  const routeSegments = parsePathname(to.startsWith('/') ? to : `/${to}`)
 
-  if (!from.startsWith('/')) {
-    baseSegments.unshift({
-      type: 'pathname',
-      value: '/',
-    })
-  }
+  const params: Record<string, string> = {}
 
-  if (!to.startsWith('/')) {
-    routeSegments.unshift({
-      type: 'pathname',
-      value: '/',
-    })
-  }
+  const result = isMatch(
+    baseSegments,
+    routeSegments,
+    params,
+    fuzzy,
+    caseSensitive,
+  )
 
-  const params: Record<string, string> = {}
+  return result ? params : undefined
+}
 
-  const isMatch = (() => {
-    let baseIndex = 0
-    let routeIndex = 0
+function isMatch(
+  baseSegments: ReadonlyArray<Segment>,
+  routeSegments: ReadonlyArray<Segment>,
+  params: Record<string, string>,
+  fuzzy?: boolean,
+  caseSensitive?: boolean,
+): boolean {
+  let baseIndex = 0
+  let routeIndex = 0
 
-    while (
-      baseIndex < baseSegments.length ||
-      routeIndex < routeSegments.length
-    ) {
-      const baseSegment = baseSegments[baseIndex]
-      const routeSegment = routeSegments[routeIndex]
+  while (baseIndex < baseSegments.length || routeIndex < routeSegments.length) {
+    const baseSegment = baseSegments[baseIndex]
+    const routeSegment = routeSegments[routeIndex]
 
-      const isLastBaseSegment = baseIndex >= baseSegments.length - 1
-      const isLastRouteSegment = routeIndex >= routeSegments.length - 1
+    const isLastBaseSegment = baseIndex >= baseSegments.length - 1
+    const isLastRouteSegment = routeIndex >= routeSegments.length - 1
 
-      if (routeSegment) {
-        if (routeSegment.type === 'wildcard') {
-          // Capture all remaining segments for a wildcard
-          const remainingBaseSegments = baseSegments.slice(baseIndex)
+    if (routeSegment) {
+      if (routeSegment.type === SEGMENT_TYPE_WILDCARD) {
+        // Capture all remaining segments for a wildcard
+        const remainingBaseSegments = baseSegments.slice(baseIndex)
 
-          let _splat: string
+        let _splat: string
 
-          // If this is a wildcard with prefix/suffix, we need to handle the first segment specially
-          if (routeSegment.prefixSegment || routeSegment.suffixSegment) {
-            if (!baseSegment) return false
+        // If this is a wildcard with prefix/suffix, we need to handle the first segment specially
+        if (routeSegment.prefixSegment || routeSegment.suffixSegment) {
+          if (!baseSegment) return false
 
-            const prefix = routeSegment.prefixSegment || ''
-            const suffix = routeSegment.suffixSegment || ''
+          const prefix = routeSegment.prefixSegment || ''
+          const suffix = routeSegment.suffixSegment || ''
 
-            // Check if the base segment starts with prefix and ends with suffix
-            const baseValue = baseSegment.value
-            if ('prefixSegment' in routeSegment) {
-              if (!baseValue.startsWith(prefix)) {
-                return false
-              }
+          // Check if the base segment starts with prefix and ends with suffix
+          const baseValue = baseSegment.value
+          if ('prefixSegment' in routeSegment) {
+            if (!baseValue.startsWith(prefix)) {
+              return false
             }
-            if ('suffixSegment' in routeSegment) {
-              if (
-                !baseSegments[baseSegments.length - 1]?.value.endsWith(suffix)
-              ) {
-                return false
-              }
+          }
+          if ('suffixSegment' in routeSegment) {
+            if (
+              !baseSegments[baseSegments.length - 1]?.value.endsWith(suffix)
+            ) {
+              return false
             }
+          }
 
-            let rejoinedSplat = decodeURI(
-              joinPaths(remainingBaseSegments.map((d) => d.value)),
-            )
-
-            // Remove the prefix and suffix from the rejoined splat
-            if (prefix && rejoinedSplat.startsWith(prefix)) {
-              rejoinedSplat = rejoinedSplat.slice(prefix.length)
-            }
+          let rejoinedSplat = decodeURI(
+            joinPaths(remainingBaseSegments.map((d) => d.value)),
+          )
 
-            if (suffix && rejoinedSplat.endsWith(suffix)) {
-              rejoinedSplat = rejoinedSplat.slice(
-                0,
-                rejoinedSplat.length - suffix.length,
-              )
-            }
+          // Remove the prefix and suffix from the rejoined splat
+          if (prefix && rejoinedSplat.startsWith(prefix)) {
+            rejoinedSplat = rejoinedSplat.slice(prefix.length)
+          }
 
-            _splat = rejoinedSplat
-          } else {
-            // If no prefix/suffix, just rejoin the remaining segments
-            _splat = decodeURI(
-              joinPaths(remainingBaseSegments.map((d) => d.value)),
+          if (suffix && rejoinedSplat.endsWith(suffix)) {
+            rejoinedSplat = rejoinedSplat.slice(
+              0,
+              rejoinedSplat.length - suffix.length,
             )
           }
 
-          // TODO: Deprecate *
-          params['*'] = _splat
-          params['_splat'] = _splat
-          return true
+          _splat = rejoinedSplat
+        } else {
+          // If no prefix/suffix, just rejoin the remaining segments
+          _splat = decodeURI(
+            joinPaths(remainingBaseSegments.map((d) => d.value)),
+          )
         }
 
-        if (routeSegment.type === 'pathname') {
-          if (routeSegment.value === '/' && !baseSegment?.value) {
-            routeIndex++
-            continue
-          }
+        // TODO: Deprecate *
+        params['*'] = _splat
+        params['_splat'] = _splat
+        return true
+      }
 
-          if (baseSegment) {
-            if (matchLocation.caseSensitive) {
-              if (routeSegment.value !== baseSegment.value) {
-                return false
-              }
-            } else if (
-              routeSegment.value.toLowerCase() !==
-              baseSegment.value.toLowerCase()
-            ) {
+      if (routeSegment.type === SEGMENT_TYPE_PATHNAME) {
+        if (routeSegment.value === '/' && !baseSegment?.value) {
+          routeIndex++
+          continue
+        }
+
+        if (baseSegment) {
+          if (caseSensitive) {
+            if (routeSegment.value !== baseSegment.value) {
               return false
             }
-            baseIndex++
-            routeIndex++
-            continue
-          } else {
+          } else if (
+            routeSegment.value.toLowerCase() !== baseSegment.value.toLowerCase()
+          ) {
             return false
           }
+          baseIndex++
+          routeIndex++
+          continue
+        } else {
+          return false
         }
+      }
 
-        if (routeSegment.type === 'param') {
-          if (!baseSegment) {
+      if (routeSegment.type === SEGMENT_TYPE_PARAM) {
+        if (!baseSegment) {
+          return false
+        }
+
+        if (baseSegment.value === '/') {
+          return false
+        }
+
+        let _paramValue = ''
+        let matched = false
+
+        // If this param has prefix/suffix, we need to extract the actual parameter value
+        if (routeSegment.prefixSegment || routeSegment.suffixSegment) {
+          const prefix = routeSegment.prefixSegment || ''
+          const suffix = routeSegment.suffixSegment || ''
+
+          // Check if the base segment starts with prefix and ends with suffix
+          const baseValue = baseSegment.value
+          if (prefix && !baseValue.startsWith(prefix)) {
             return false
           }
-
-          if (baseSegment.value === '/') {
+          if (suffix && !baseValue.endsWith(suffix)) {
             return false
           }
 
-          let _paramValue = ''
-          let matched = false
+          let paramValue = baseValue
+          if (prefix && paramValue.startsWith(prefix)) {
+            paramValue = paramValue.slice(prefix.length)
+          }
+          if (suffix && paramValue.endsWith(suffix)) {
+            paramValue = paramValue.slice(0, paramValue.length - suffix.length)
+          }
+
+          _paramValue = decodeURIComponent(paramValue)
+          matched = true
+        } else {
+          // If no prefix/suffix, just decode the base segment value
+          _paramValue = decodeURIComponent(baseSegment.value)
+          matched = true
+        }
 
-          // If this param has prefix/suffix, we need to extract the actual parameter value
-          if (routeSegment.prefixSegment || routeSegment.suffixSegment) {
-            const prefix = routeSegment.prefixSegment || ''
-            const suffix = routeSegment.suffixSegment || ''
+        if (matched) {
+          params[routeSegment.value.substring(1)] = _paramValue
+          baseIndex++
+        }
 
-            // Check if the base segment starts with prefix and ends with suffix
-            const baseValue = baseSegment.value
-            if (prefix && !baseValue.startsWith(prefix)) {
-              return false
-            }
-            if (suffix && !baseValue.endsWith(suffix)) {
-              return false
-            }
+        routeIndex++
+        continue
+      }
 
+      if (routeSegment.type === SEGMENT_TYPE_OPTIONAL_PARAM) {
+        // Optional parameters can be missing - don't fail the match
+        if (!baseSegment) {
+          // No base segment for optional param - skip this route segment
+          routeIndex++
+          continue
+        }
+
+        if (baseSegment.value === '/') {
+          // Skip slash segments for optional params
+          routeIndex++
+          continue
+        }
+
+        let _paramValue = ''
+        let matched = false
+
+        // If this optional param has prefix/suffix, we need to extract the actual parameter value
+        if (routeSegment.prefixSegment || routeSegment.suffixSegment) {
+          const prefix = routeSegment.prefixSegment || ''
+          const suffix = routeSegment.suffixSegment || ''
+
+          // Check if the base segment starts with prefix and ends with suffix
+          const baseValue = baseSegment.value
+          if (
+            (!prefix || baseValue.startsWith(prefix)) &&
+            (!suffix || baseValue.endsWith(suffix))
+          ) {
             let paramValue = baseValue
             if (prefix && paramValue.startsWith(prefix)) {
               paramValue = paramValue.slice(prefix.length)
@@ -674,146 +756,81 @@ export function matchByPath(
 
             _paramValue = decodeURIComponent(paramValue)
             matched = true
-          } else {
-            // If no prefix/suffix, just decode the base segment value
-            _paramValue = decodeURIComponent(baseSegment.value)
-            matched = true
-          }
-
-          if (matched) {
-            params[routeSegment.value.substring(1)] = _paramValue
-            baseIndex++
           }
-
-          routeIndex++
-          continue
-        }
-
-        if (routeSegment.type === 'optional-param') {
-          // Optional parameters can be missing - don't fail the match
-          if (!baseSegment) {
-            // No base segment for optional param - skip this route segment
-            routeIndex++
-            continue
-          }
-
-          if (baseSegment.value === '/') {
-            // Skip slash segments for optional params
-            routeIndex++
-            continue
-          }
-
-          let _paramValue = ''
-          let matched = false
-
-          // If this optional param has prefix/suffix, we need to extract the actual parameter value
-          if (routeSegment.prefixSegment || routeSegment.suffixSegment) {
-            const prefix = routeSegment.prefixSegment || ''
-            const suffix = routeSegment.suffixSegment || ''
-
-            // Check if the base segment starts with prefix and ends with suffix
-            const baseValue = baseSegment.value
+        } else {
+          // For optional params without prefix/suffix, we need to check if the current
+          // base segment should match this optional param or a later route segment
+
+          // Look ahead to see if there's a later route segment that matches the current base segment
+          let shouldMatchOptional = true
+          for (
+            let lookAhead = routeIndex + 1;
+            lookAhead < routeSegments.length;
+            lookAhead++
+          ) {
+            const futureRouteSegment = routeSegments[lookAhead]
             if (
-              (!prefix || baseValue.startsWith(prefix)) &&
-              (!suffix || baseValue.endsWith(suffix))
-            ) {
-              let paramValue = baseValue
-              if (prefix && paramValue.startsWith(prefix)) {
-                paramValue = paramValue.slice(prefix.length)
-              }
-              if (suffix && paramValue.endsWith(suffix)) {
-                paramValue = paramValue.slice(
-                  0,
-                  paramValue.length - suffix.length,
-                )
-              }
-
-              _paramValue = decodeURIComponent(paramValue)
-              matched = true
-            }
-          } else {
-            // For optional params without prefix/suffix, we need to check if the current
-            // base segment should match this optional param or a later route segment
-
-            // Look ahead to see if there's a later route segment that matches the current base segment
-            let shouldMatchOptional = true
-            for (
-              let lookAhead = routeIndex + 1;
-              lookAhead < routeSegments.length;
-              lookAhead++
+              futureRouteSegment?.type === SEGMENT_TYPE_PATHNAME &&
+              futureRouteSegment.value === baseSegment.value
             ) {
-              const futureRouteSegment = routeSegments[lookAhead]
-              if (
-                futureRouteSegment?.type === 'pathname' &&
-                futureRouteSegment.value === baseSegment.value
-              ) {
-                // The current base segment matches a future pathname segment,
-                // so we should skip this optional parameter
-                shouldMatchOptional = false
-                break
-              }
-
-              // If we encounter a required param or wildcard, stop looking ahead
-              if (
-                futureRouteSegment?.type === 'param' ||
-                futureRouteSegment?.type === 'wildcard'
-              ) {
-                break
-              }
+              // The current base segment matches a future pathname segment,
+              // so we should skip this optional parameter
+              shouldMatchOptional = false
+              break
             }
 
-            if (shouldMatchOptional) {
-              // If no prefix/suffix, just decode the base segment value
-              _paramValue = decodeURIComponent(baseSegment.value)
-              matched = true
+            // If we encounter a required param or wildcard, stop looking ahead
+            if (
+              futureRouteSegment?.type === SEGMENT_TYPE_PARAM ||
+              futureRouteSegment?.type === SEGMENT_TYPE_WILDCARD
+            ) {
+              break
             }
           }
 
-          if (matched) {
-            params[routeSegment.value.substring(1)] = _paramValue
-            baseIndex++
+          if (shouldMatchOptional) {
+            // If no prefix/suffix, just decode the base segment value
+            _paramValue = decodeURIComponent(baseSegment.value)
+            matched = true
           }
+        }
 
-          routeIndex++
-          continue
+        if (matched) {
+          params[routeSegment.value.substring(1)] = _paramValue
+          baseIndex++
         }
-      }
 
-      if (!isLastBaseSegment && isLastRouteSegment) {
-        params['**'] = joinPaths(
-          baseSegments.slice(baseIndex + 1).map((d) => d.value),
-        )
-        return !!matchLocation.fuzzy && routeSegment?.value !== '/'
+        routeIndex++
+        continue
       }
+    }
 
-      // If we have base segments left but no route segments, it's not a match
-      if (
-        baseIndex < baseSegments.length &&
-        routeIndex >= routeSegments.length
-      ) {
-        return false
-      }
+    if (!isLastBaseSegment && isLastRouteSegment) {
+      params['**'] = joinPaths(
+        baseSegments.slice(baseIndex + 1).map((d) => d.value),
+      )
+      return !!fuzzy && routeSegment?.value !== '/'
+    }
 
-      // If we have route segments left but no base segments, check if remaining are optional
-      if (
-        routeIndex < routeSegments.length &&
-        baseIndex >= baseSegments.length
-      ) {
-        // Check if all remaining route segments are optional
-        for (let i = routeIndex; i < routeSegments.length; i++) {
-          if (routeSegments[i]?.type !== 'optional-param') {
-            return false
-          }
+    // If we have base segments left but no route segments, it's not a match
+    if (baseIndex < baseSegments.length && routeIndex >= routeSegments.length) {
+      return false
+    }
+
+    // If we have route segments left but no base segments, check if remaining are optional
+    if (routeIndex < routeSegments.length && baseIndex >= baseSegments.length) {
+      // Check if all remaining route segments are optional
+      for (let i = routeIndex; i < routeSegments.length; i++) {
+        if (routeSegments[i]?.type !== SEGMENT_TYPE_OPTIONAL_PARAM) {
+          return false
         }
-        // All remaining are optional, so we can finish
-        break
       }
-
+      // All remaining are optional, so we can finish
       break
     }
 
-    return true
-  })()
+    break
+  }
 
-  return isMatch ? params : undefined
+  return true
 }