@tanstack/router-core 1.128.3 → 1.128.6

package/dist/esm/path.d.ts

@@ -1,10 +1,15 @@
 import { MatchLocation } from './RouterProvider.js';
 import { AnyPathParams } from './route.js';
+export declare const SEGMENT_TYPE_PATHNAME = 0;
+export declare const SEGMENT_TYPE_PARAM = 1;
+export declare const SEGMENT_TYPE_WILDCARD = 2;
+export declare 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;
+    readonly hasStaticAfter?: boolean;
 }
 export declare function joinPaths(paths: Array<string | undefined>): string;
 export declare function cleanPath(path: string): string;
@@ -38,7 +43,7 @@ export declare function resolvePath({ basepath, base, to, trailingSlash, caseSen
  * - `/foo/[$]{$foo} - Dynamic route with a static prefix of `$`
  * - `/foo/{$foo}[$]` - Dynamic route with a static suffix of `$`
  */
-export declare function parsePathname(pathname?: string): Array<Segment>;
+export declare function parsePathname(pathname?: string): ReadonlyArray<Segment>;
 interface InterpolatePathOptions {
     path?: string;
     params: Record<string, unknown>;
@@ -54,5 +59,5 @@ type InterPolatePathResult = {
 export declare function interpolatePath({ path, params, leaveWildcards, leaveParams, decodeCharMap, }: InterpolatePathOptions): InterPolatePathResult;
 export declare function matchPathname(basepath: string, currentPathname: string, matchLocation: Pick<MatchLocation, 'to' | 'fuzzy' | 'caseSensitive'>): AnyPathParams | undefined;
 export declare function removeBasepath(basepath: string, pathname: string, caseSensitive?: boolean): string;
-export declare function matchByPath(basepath: string, from: string, matchLocation: Pick<MatchLocation, 'to' | 'caseSensitive' | 'fuzzy'>): Record<string, string> | undefined;
+export declare function matchByPath(basepath: string, from: string, { to, fuzzy, caseSensitive, }: Pick<MatchLocation, 'to' | 'caseSensitive' | 'fuzzy'>): Record<string, string> | undefined;
 export {};

package/dist/esm/path.js

@@ -1,4 +1,8 @@
 import { last } from "./utils.js";
+const SEGMENT_TYPE_PATHNAME = 0;
+const SEGMENT_TYPE_PARAM = 1;
+const SEGMENT_TYPE_WILDCARD = 2;
+const SEGMENT_TYPE_OPTIONAL_PARAM = 3;
 function joinPaths(paths) {
   return cleanPath(
     paths.filter((val) => {
@@ -27,6 +31,44 @@ function removeTrailingSlash(value, basepath) {
 function exactPathTest(pathName1, pathName2, basepath) {
   return removeTrailingSlash(pathName1, basepath) === removeTrailingSlash(pathName2, basepath);
 }
+function segmentToString(segment) {
+  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}`;
+    }
+  }
+  return value;
+}
 function resolvePath({
   basepath,
   base,
@@ -34,72 +76,42 @@ function resolvePath({
   trailingSlash = "never",
   caseSensitive
 }) {
-  var _a, _b;
+  var _a;
   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 && ((_a = last(baseSegments)) == null ? void 0 : _a.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) {
         baseSegments = [toSegment];
-      } else if (index === toSegments.length - 1) {
+      } else if (index === length - 1) {
         baseSegments.push(toSegment);
       } else ;
-    } else if (toSegment.value === "..") {
+    } else if (value === "..") {
       baseSegments.pop();
-    } else if (toSegment.value === ".") ;
+    } else if (value === ".") ;
     else {
       baseSegments.push(toSegment);
     }
-  });
+  }
   if (baseSegments.length > 1) {
-    if (((_b = last(baseSegments)) == null ? void 0 : _b.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,}$/;
 const PARAM_W_CURLY_BRACES_RE = /^(.*?)\{(\$[a-zA-Z_$][a-zA-Z0-9_$]*)\}(.*)$/;
@@ -115,7 +127,7 @@ function parsePathname(pathname) {
   if (pathname.slice(0, 1) === "/") {
     pathname = pathname.substring(1);
     segments.push({
-      type: "pathname",
+      type: SEGMENT_TYPE_PATHNAME,
       value: "/"
     });
   }
@@ -130,7 +142,7 @@ function parsePathname(pathname) {
         const prefix = wildcardBracesMatch[1];
         const suffix = wildcardBracesMatch[2];
         return {
-          type: "wildcard",
+          type: SEGMENT_TYPE_WILDCARD,
           value: "$",
           prefixSegment: prefix || void 0,
           suffixSegment: suffix || void 0
@@ -144,7 +156,7 @@ function parsePathname(pathname) {
         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 || void 0,
@@ -157,7 +169,7 @@ function parsePathname(pathname) {
         const paramName = paramBracesMatch[2];
         const suffix = paramBracesMatch[3];
         return {
-          type: "param",
+          type: SEGMENT_TYPE_PARAM,
           value: "" + paramName,
           prefixSegment: prefix || void 0,
           suffixSegment: suffix || void 0
@@ -166,7 +178,7 @@ function parsePathname(pathname) {
       if (PARAM_RE.test(part)) {
         const paramName = part.substring(1);
         return {
-          type: "param",
+          type: SEGMENT_TYPE_PARAM,
           value: "$" + paramName,
           prefixSegment: void 0,
           suffixSegment: void 0
@@ -174,14 +186,14 @@ function parsePathname(pathname) {
       }
       if (WILDCARD_RE.test(part)) {
         return {
-          type: "wildcard",
+          type: SEGMENT_TYPE_WILDCARD,
           value: "$",
           prefixSegment: void 0,
           suffixSegment: void 0
         };
       }
       return {
-        type: "pathname",
+        type: SEGMENT_TYPE_PATHNAME,
         value: part.includes("%25") ? part.split("%25").map((segment) => decodeURI(segment)).join("%25") : decodeURI(part)
       };
     })
@@ -189,7 +201,7 @@ function parsePathname(pathname) {
   if (pathname.slice(-1) === "/") {
     pathname = pathname.substring(1);
     segments.push({
-      type: "pathname",
+      type: SEGMENT_TYPE_PATHNAME,
       value: "/"
     });
   }
@@ -206,7 +218,7 @@ function interpolatePath({
   function encodeParam(key) {
     const value = params[key];
     const isValueString = typeof value === "string";
-    if (["*", "_splat"].includes(key)) {
+    if (key === "*" || key === "_splat") {
       return isValueString ? encodeURI(value) : value;
     } else {
       return isValueString ? encodePathParam(value, decodeCharMap) : value;
@@ -216,7 +228,10 @@ function interpolatePath({
   const usedParams = {};
   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 || "";
@@ -236,7 +251,7 @@ 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;
@@ -250,11 +265,14 @@ 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 || "";
         const segmentSuffix = segment.suffixSegment || "";
         if (!(key in params) || params[key] == null) {
+          if (leaveWildcards) {
+            return `${segmentPrefix}${key}${segmentSuffix}`;
+          }
           if (segmentPrefix || segmentSuffix) {
             return `${segmentPrefix}${segmentSuffix}`;
           }
@@ -317,120 +335,153 @@ function removeBasepath(basepath, pathname, caseSensitive = false) {
       return pathname;
   }
 }
-function matchByPath(basepath, from, matchLocation) {
+function matchByPath(basepath, from, {
+  to,
+  fuzzy,
+  caseSensitive
+}) {
   if (basepath !== "/" && !from.startsWith(basepath)) {
     return void 0;
   }
-  from = removeBasepath(basepath, from, matchLocation.caseSensitive);
-  const to = removeBasepath(
-    basepath,
-    `${matchLocation.to ?? "$"}`,
-    matchLocation.caseSensitive
-  );
-  const baseSegments = parsePathname(from);
-  const routeSegments = parsePathname(to);
-  if (!from.startsWith("/")) {
-    baseSegments.unshift({
-      type: "pathname",
-      value: "/"
-    });
-  }
-  if (!to.startsWith("/")) {
-    routeSegments.unshift({
-      type: "pathname",
-      value: "/"
-    });
-  }
+  from = removeBasepath(basepath, from, caseSensitive);
+  to = removeBasepath(basepath, `${to ?? "$"}`, caseSensitive);
+  const baseSegments = parsePathname(from.startsWith("/") ? from : `/${from}`);
+  const routeSegments = parsePathname(to.startsWith("/") ? to : `/${to}`);
   const params = {};
-  const isMatch = (() => {
-    var _a, _b;
-    let baseIndex = 0;
-    let routeIndex = 0;
-    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;
-      if (routeSegment) {
-        if (routeSegment.type === "wildcard") {
-          const remainingBaseSegments = baseSegments.slice(baseIndex);
-          let _splat;
-          if (routeSegment.prefixSegment || routeSegment.suffixSegment) {
-            if (!baseSegment) return false;
-            const prefix = routeSegment.prefixSegment || "";
-            const suffix = routeSegment.suffixSegment || "";
-            const baseValue = baseSegment.value;
-            if ("prefixSegment" in routeSegment) {
-              if (!baseValue.startsWith(prefix)) {
-                return false;
-              }
-            }
-            if ("suffixSegment" in routeSegment) {
-              if (!((_a = baseSegments[baseSegments.length - 1]) == null ? void 0 : _a.value.endsWith(suffix))) {
-                return false;
-              }
-            }
-            let rejoinedSplat = decodeURI(
-              joinPaths(remainingBaseSegments.map((d) => d.value))
-            );
-            if (prefix && rejoinedSplat.startsWith(prefix)) {
-              rejoinedSplat = rejoinedSplat.slice(prefix.length);
+  const result = isMatch(
+    baseSegments,
+    routeSegments,
+    params,
+    fuzzy,
+    caseSensitive
+  );
+  return result ? params : void 0;
+}
+function isMatch(baseSegments, routeSegments, params, fuzzy, caseSensitive) {
+  var _a, _b;
+  let baseIndex = 0;
+  let routeIndex = 0;
+  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;
+    if (routeSegment) {
+      if (routeSegment.type === SEGMENT_TYPE_WILDCARD) {
+        const remainingBaseSegments = baseSegments.slice(baseIndex);
+        let _splat;
+        if (routeSegment.prefixSegment || routeSegment.suffixSegment) {
+          if (!baseSegment) return false;
+          const prefix = routeSegment.prefixSegment || "";
+          const suffix = routeSegment.suffixSegment || "";
+          const baseValue = baseSegment.value;
+          if ("prefixSegment" in routeSegment) {
+            if (!baseValue.startsWith(prefix)) {
+              return false;
             }
-            if (suffix && rejoinedSplat.endsWith(suffix)) {
-              rejoinedSplat = rejoinedSplat.slice(
-                0,
-                rejoinedSplat.length - suffix.length
-              );
+          }
+          if ("suffixSegment" in routeSegment) {
+            if (!((_a = baseSegments[baseSegments.length - 1]) == null ? void 0 : _a.value.endsWith(suffix))) {
+              return false;
             }
-            _splat = rejoinedSplat;
-          } else {
-            _splat = decodeURI(
-              joinPaths(remainingBaseSegments.map((d) => d.value))
+          }
+          let rejoinedSplat = decodeURI(
+            joinPaths(remainingBaseSegments.map((d) => d.value))
+          );
+          if (prefix && rejoinedSplat.startsWith(prefix)) {
+            rejoinedSplat = rejoinedSplat.slice(prefix.length);
+          }
+          if (suffix && rejoinedSplat.endsWith(suffix)) {
+            rejoinedSplat = rejoinedSplat.slice(
+              0,
+              rejoinedSplat.length - suffix.length
             );
           }
-          params["*"] = _splat;
-          params["_splat"] = _splat;
-          return true;
+          _splat = rejoinedSplat;
+        } else {
+          _splat = decodeURI(
+            joinPaths(remainingBaseSegments.map((d) => d.value))
+          );
         }
-        if (routeSegment.type === "pathname") {
-          if (routeSegment.value === "/" && !(baseSegment == null ? void 0 : baseSegment.value)) {
-            routeIndex++;
-            continue;
-          }
-          if (baseSegment) {
-            if (matchLocation.caseSensitive) {
-              if (routeSegment.value !== baseSegment.value) {
-                return false;
-              }
-            } else if (routeSegment.value.toLowerCase() !== baseSegment.value.toLowerCase()) {
+        params["*"] = _splat;
+        params["_splat"] = _splat;
+        return true;
+      }
+      if (routeSegment.type === SEGMENT_TYPE_PATHNAME) {
+        if (routeSegment.value === "/" && !(baseSegment == null ? void 0 : 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 === SEGMENT_TYPE_PARAM) {
+        if (!baseSegment) {
+          return false;
         }
-        if (routeSegment.type === "param") {
-          if (!baseSegment) {
+        if (baseSegment.value === "/") {
+          return false;
+        }
+        let _paramValue = "";
+        let matched = false;
+        if (routeSegment.prefixSegment || routeSegment.suffixSegment) {
+          const prefix = routeSegment.prefixSegment || "";
+          const suffix = routeSegment.suffixSegment || "";
+          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;
-          if (routeSegment.prefixSegment || routeSegment.suffixSegment) {
-            const prefix = routeSegment.prefixSegment || "";
-            const suffix = routeSegment.suffixSegment || "";
-            const baseValue = baseSegment.value;
-            if (prefix && !baseValue.startsWith(prefix)) {
-              return false;
-            }
-            if (suffix && !baseValue.endsWith(suffix)) {
-              return 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 {
+          _paramValue = decodeURIComponent(baseSegment.value);
+          matched = true;
+        }
+        if (matched) {
+          params[routeSegment.value.substring(1)] = _paramValue;
+          baseIndex++;
+        }
+        routeIndex++;
+        continue;
+      }
+      if (routeSegment.type === SEGMENT_TYPE_OPTIONAL_PARAM) {
+        if (!baseSegment) {
+          routeIndex++;
+          continue;
+        }
+        if (baseSegment.value === "/") {
+          routeIndex++;
+          continue;
+        }
+        let _paramValue = "";
+        let matched = false;
+        if (routeSegment.prefixSegment || routeSegment.suffixSegment) {
+          const prefix = routeSegment.prefixSegment || "";
+          const suffix = routeSegment.suffixSegment || "";
+          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);
@@ -443,95 +494,58 @@ function matchByPath(basepath, from, matchLocation) {
             }
             _paramValue = decodeURIComponent(paramValue);
             matched = true;
-          } else {
-            _paramValue = decodeURIComponent(baseSegment.value);
-            matched = true;
-          }
-          if (matched) {
-            params[routeSegment.value.substring(1)] = _paramValue;
-            baseIndex++;
-          }
-          routeIndex++;
-          continue;
-        }
-        if (routeSegment.type === "optional-param") {
-          if (!baseSegment) {
-            routeIndex++;
-            continue;
           }
-          if (baseSegment.value === "/") {
-            routeIndex++;
-            continue;
-          }
-          let _paramValue = "";
-          let matched = false;
-          if (routeSegment.prefixSegment || routeSegment.suffixSegment) {
-            const prefix = routeSegment.prefixSegment || "";
-            const suffix = routeSegment.suffixSegment || "";
-            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);
-              }
-              if (suffix && paramValue.endsWith(suffix)) {
-                paramValue = paramValue.slice(
-                  0,
-                  paramValue.length - suffix.length
-                );
-              }
-              _paramValue = decodeURIComponent(paramValue);
-              matched = true;
-            }
-          } else {
-            let shouldMatchOptional = true;
-            for (let lookAhead = routeIndex + 1; lookAhead < routeSegments.length; lookAhead++) {
-              const futureRouteSegment = routeSegments[lookAhead];
-              if ((futureRouteSegment == null ? void 0 : futureRouteSegment.type) === "pathname" && futureRouteSegment.value === baseSegment.value) {
-                shouldMatchOptional = false;
-                break;
-              }
-              if ((futureRouteSegment == null ? void 0 : futureRouteSegment.type) === "param" || (futureRouteSegment == null ? void 0 : futureRouteSegment.type) === "wildcard") {
-                break;
-              }
+        } else {
+          let shouldMatchOptional = true;
+          for (let lookAhead = routeIndex + 1; lookAhead < routeSegments.length; lookAhead++) {
+            const futureRouteSegment = routeSegments[lookAhead];
+            if ((futureRouteSegment == null ? void 0 : futureRouteSegment.type) === SEGMENT_TYPE_PATHNAME && futureRouteSegment.value === baseSegment.value) {
+              shouldMatchOptional = false;
+              break;
             }
-            if (shouldMatchOptional) {
-              _paramValue = decodeURIComponent(baseSegment.value);
-              matched = true;
+            if ((futureRouteSegment == null ? void 0 : futureRouteSegment.type) === SEGMENT_TYPE_PARAM || (futureRouteSegment == null ? void 0 : futureRouteSegment.type) === SEGMENT_TYPE_WILDCARD) {
+              break;
             }
           }
-          if (matched) {
-            params[routeSegment.value.substring(1)] = _paramValue;
-            baseIndex++;
+          if (shouldMatchOptional) {
+            _paramValue = decodeURIComponent(baseSegment.value);
+            matched = true;
           }
-          routeIndex++;
-          continue;
         }
+        if (matched) {
+          params[routeSegment.value.substring(1)] = _paramValue;
+          baseIndex++;
+        }
+        routeIndex++;
+        continue;
       }
-      if (!isLastBaseSegment && isLastRouteSegment) {
-        params["**"] = joinPaths(
-          baseSegments.slice(baseIndex + 1).map((d) => d.value)
-        );
-        return !!matchLocation.fuzzy && (routeSegment == null ? void 0 : routeSegment.value) !== "/";
-      }
-      if (baseIndex < baseSegments.length && routeIndex >= routeSegments.length) {
-        return false;
-      }
-      if (routeIndex < routeSegments.length && baseIndex >= baseSegments.length) {
-        for (let i = routeIndex; i < routeSegments.length; i++) {
-          if (((_b = routeSegments[i]) == null ? void 0 : _b.type) !== "optional-param") {
-            return false;
-          }
+    }
+    if (!isLastBaseSegment && isLastRouteSegment) {
+      params["**"] = joinPaths(
+        baseSegments.slice(baseIndex + 1).map((d) => d.value)
+      );
+      return !!fuzzy && (routeSegment == null ? void 0 : routeSegment.value) !== "/";
+    }
+    if (baseIndex < baseSegments.length && routeIndex >= routeSegments.length) {
+      return false;
+    }
+    if (routeIndex < routeSegments.length && baseIndex >= baseSegments.length) {
+      for (let i = routeIndex; i < routeSegments.length; i++) {
+        if (((_b = routeSegments[i]) == null ? void 0 : _b.type) !== SEGMENT_TYPE_OPTIONAL_PARAM) {
+          return false;
         }
-        break;
       }
       break;
     }
-    return true;
-  })();
-  return isMatch ? params : void 0;
+    break;
+  }
+  return true;
 }
 export {
+  SEGMENT_TYPE_OPTIONAL_PARAM,
+  SEGMENT_TYPE_PARAM,
+  SEGMENT_TYPE_PATHNAME,
+  SEGMENT_TYPE_WILDCARD,
   cleanPath,
   exactPathTest,
   interpolatePath,