@devp0nt/route0 1.0.0-next.76 → 1.0.0-next.78

package/dist/esm/index.js

@@ -1,112 +1,57 @@
 import { parse as parseSearchQuery, stringify as stringifySearchQuery } from "@devp0nt/flat0";
 const escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-const getRouteSegments = (definition) => {
-  if (definition === "" || definition === "/") return [];
-  return definition.split("/").filter(Boolean);
-};
-const getRouteTokens = (definition) => {
-  const segments = getRouteSegments(definition);
-  return segments.map((segment) => {
-    const param = segment.match(/^:([A-Za-z0-9_]+)(\?)?$/);
-    if (param) {
-      return { kind: "param", name: param[1], optional: param[2] === "?" };
-    }
-    if (segment === "*" || segment === "*?") {
-      return { kind: "wildcard", prefix: "", optional: segment.endsWith("?") };
-    }
-    const wildcard = segment.match(/^(.*)\*(\?)?$/);
-    if (wildcard && !segment.includes("\\*")) {
-      return { kind: "wildcard", prefix: wildcard[1], optional: wildcard[2] === "?" };
-    }
-    return { kind: "static", value: segment };
-  });
-};
-const getRouteRegexBaseStrictString = (definition) => {
-  const tokens = getRouteTokens(definition);
-  if (tokens.length === 0) return "";
-  let pattern = "";
-  for (const token of tokens) {
-    if (token.kind === "static") {
-      pattern += `/${escapeRegex(token.value)}`;
-      continue;
-    }
-    if (token.kind === "param") {
-      pattern += token.optional ? "(?:/([^/]+))?" : "/([^/]+)";
-      continue;
-    }
-    if (token.prefix.length > 0) {
-      pattern += `/${escapeRegex(token.prefix)}(.*)`;
-    } else {
-      pattern += "(?:/(.*))?";
-    }
-  }
-  return pattern;
-};
-const getRouteCaptureKeys = (definition) => {
-  const keys = [];
-  for (const token of getRouteTokens(definition)) {
-    if (token.kind === "param") keys.push(token.name);
-    if (token.kind === "wildcard") keys.push("*");
-  }
-  return keys;
-};
-const getPathParamsDefinition = (definition) => {
-  const entries = getRouteTokens(definition).filter((t) => t.kind !== "static").map((t) => t.kind === "param" ? [t.name, !t.optional] : ["*", !t.optional]);
-  return Object.fromEntries(entries);
-};
-const validateRouteDefinition = (definition) => {
-  const segments = getRouteSegments(definition);
-  const wildcardSegments = segments.filter((segment) => segment.includes("*"));
-  if (wildcardSegments.length === 0) return;
-  if (wildcardSegments.length > 1) {
-    throw new Error(`Invalid route definition "${definition}": only one wildcard segment is allowed`);
-  }
-  const wildcardSegmentIndex = segments.findIndex((segment) => segment.includes("*"));
-  const wildcardSegment = segments[wildcardSegmentIndex];
-  if (!wildcardSegment.match(/^(?:\*|\*\?|[^*]+\*|\S+\*\?)$/)) {
-    throw new Error(`Invalid route definition "${definition}": wildcard must be trailing in its segment`);
-  }
-  if (wildcardSegmentIndex !== segments.length - 1) {
-    throw new Error(`Invalid route definition "${definition}": wildcard segment is allowed only at the end`);
-  }
-};
-const stripTrailingWildcard = (definition) => definition.replace(/\*\??$/, "");
-const normalizePathname = (pathname) => {
-  if (pathname.length > 1 && pathname.endsWith("/")) {
-    return pathname.slice(0, -1);
-  }
-  return pathname;
-};
-const getNormalizedPathnameFromInput = (hrefOrHrefRelOrLocation) => {
-  if (hrefOrHrefRelOrLocation instanceof URL) {
-    return normalizePathname(hrefOrHrefRelOrLocation.pathname);
-  }
-  if (typeof hrefOrHrefRelOrLocation !== "string") {
-    if (typeof hrefOrHrefRelOrLocation.pathname === "string") {
-      return normalizePathname(hrefOrHrefRelOrLocation.pathname);
-    }
-    hrefOrHrefRelOrLocation = hrefOrHrefRelOrLocation.href || hrefOrHrefRelOrLocation.hrefRel;
-  }
-  const abs = /^[a-zA-Z][a-zA-Z\d+\-.]*:\/\//.test(hrefOrHrefRelOrLocation);
-  const base = abs ? void 0 : "http://example.com";
-  const url = new URL(hrefOrHrefRelOrLocation, base);
-  return normalizePathname(url.pathname);
+const collapseDuplicateSlashes = (value) => value.replace(/\/{2,}/g, "/");
+const normalizeSlashPath = (value) => {
+  const collapsed = collapseDuplicateSlashes(value);
+  if (collapsed === "" || collapsed === "/") return "/";
+  const withLeadingSlash = collapsed.startsWith("/") ? collapsed : `/${collapsed}`;
+  return withLeadingSlash.length > 1 && withLeadingSlash.endsWith("/") ? withLeadingSlash.slice(0, -1) : withLeadingSlash;
 };
 class Route0 {
   definition;
   params;
   _origin;
   _callable;
-  _regexBaseStrictString;
+  _routeSegments;
+  _routeTokens;
+  _routePatternCandidates;
+  _pathParamsDefinition;
+  _definitionWithoutTrailingWildcard;
+  _routeRegexBaseStringRaw;
   _regexBaseString;
-  _regexStrictString;
   _regexString;
-  _regexStrict;
   _regex;
   _regexAncestor;
+  _regexDescendantMatchers;
   _captureKeys;
   _normalizedDefinition;
   _definitionParts;
+  static _getRouteSegments(definition) {
+    if (definition === "" || definition === "/") return [];
+    return definition.split("/").filter(Boolean);
+  }
+  static _normalizeRouteDefinition(definition) {
+    return normalizeSlashPath(definition);
+  }
+  static _normalizePathname(pathname) {
+    return Route0._normalizeRouteDefinition(pathname);
+  }
+  static _validateRouteDefinition(definition) {
+    const segments = Route0._getRouteSegments(definition);
+    const wildcardSegments = segments.filter((segment) => segment.includes("*"));
+    if (wildcardSegments.length === 0) return;
+    if (wildcardSegments.length > 1) {
+      throw new Error(`Invalid route definition "${definition}": only one wildcard segment is allowed`);
+    }
+    const wildcardSegmentIndex = segments.findIndex((segment) => segment.includes("*"));
+    const wildcardSegment = segments[wildcardSegmentIndex];
+    if (!wildcardSegment.match(/^(?:\*|\*\?|[^*]+\*|\S+\*\?)$/)) {
+      throw new Error(`Invalid route definition "${definition}": wildcard must be trailing in its segment`);
+    }
+    if (wildcardSegmentIndex !== segments.length - 1) {
+      throw new Error(`Invalid route definition "${definition}": wildcard segment is allowed only at the end`);
+    }
+  }
   Infer = null;
   /** Base URL used when generating absolute URLs (`abs: true`). */
   get origin() {
@@ -121,9 +66,10 @@ class Route0 {
     this._origin = origin;
   }
   constructor(definition, config = {}) {
-    validateRouteDefinition(definition);
-    this.definition = definition;
-    this.params = Route0._getParamsDefinitionByDefinition(definition);
+    const normalizedDefinition = Route0._normalizeRouteDefinition(definition);
+    Route0._validateRouteDefinition(normalizedDefinition);
+    this.definition = normalizedDefinition;
+    this.params = this.pathParamsDefinition;
     const { origin } = config;
     if (origin && typeof origin === "string" && origin.length) {
       this._origin = origin;
@@ -151,7 +97,10 @@ class Route0 {
     if (typeof definition === "function" || typeof definition === "object") {
       return definition.clone(config);
     }
-    const original = new Route0(definition, config);
+    const original = new Route0(
+      Route0._normalizeRouteDefinition(definition),
+      config
+    );
     return original._callable;
   }
   /**
@@ -163,25 +112,25 @@ class Route0 {
     if (typeof definition === "function") {
       return definition;
     }
-    const original = typeof definition === "object" ? definition : new Route0(definition);
+    const original = typeof definition === "object" ? definition : new Route0(
+      Route0._normalizeRouteDefinition(definition)
+    );
     return original._callable;
   }
   static _getAbsPath(origin, url) {
     return new URL(url, origin).toString().replace(/\/$/, "");
   }
-  static _getParamsDefinitionByDefinition(definition) {
-    return getPathParamsDefinition(definition);
-  }
   search() {
     return this._callable;
   }
   /** Extends the current route definition by appending a suffix route. */
   extend(suffixDefinition) {
-    const sourceDefinitionWithoutWildcard = stripTrailingWildcard(this.definition);
-    const definition = `${sourceDefinitionWithoutWildcard}/${suffixDefinition}`.replace(/\/{2,}/g, "/");
+    const definition = Route0._normalizeRouteDefinition(`${this.definitionWithoutTrailingWildcard}/${suffixDefinition}`);
     return Route0.create(
       definition,
-      { origin: this._origin }
+      {
+        origin: this._origin
+      }
     );
   }
   // implementation
@@ -253,7 +202,7 @@ class Route0 {
     url = url.replace(/\*/g, () => String(paramsInput["*"] ?? ""));
     const searchString = stringifySearchQuery(searchInput);
     url = [url, searchString].filter(Boolean).join("?");
-    url = url.replace(/\/{2,}/g, "/");
+    url = collapseDuplicateSlashes(url);
     url = absInput ? Route0._getAbsPath(absOriginInput || this.origin, url) : url;
     if (hashInput !== void 0) {
       url = `${url}#${hashInput}`;
@@ -265,42 +214,24 @@ class Route0 {
     return Object.keys(this.params);
   }
   getTokens() {
-    return getRouteTokens(this.definition);
+    return this.routeTokens.map((token) => ({ ...token }));
   }
   /** Clones route with optional config override. */
   clone(config) {
     return Route0.create(this.definition, config);
   }
-  get regexBaseStrictString() {
-    if (this._regexBaseStrictString === void 0) {
-      this._regexBaseStrictString = getRouteRegexBaseStrictString(this.definition);
-    }
-    return this._regexBaseStrictString;
-  }
   get regexBaseString() {
     if (this._regexBaseString === void 0) {
-      this._regexBaseString = this.regexBaseStrictString.replace(/\/+$/, "") + "/?";
+      this._regexBaseString = this.routeRegexBaseStringRaw.replace(/\/+$/, "") + "/?";
     }
     return this._regexBaseString;
   }
-  get regexStrictString() {
-    if (this._regexStrictString === void 0) {
-      this._regexStrictString = `^${this.regexBaseStrictString}$`;
-    }
-    return this._regexStrictString;
-  }
   get regexString() {
     if (this._regexString === void 0) {
       this._regexString = `^${this.regexBaseString}$`;
     }
     return this._regexString;
   }
-  get regexStrict() {
-    if (this._regexStrict === void 0) {
-      this._regexStrict = new RegExp(this.regexStrictString);
-    }
-    return this._regexStrict;
-  }
   get regex() {
     if (this._regex === void 0) {
       this._regex = new RegExp(this.regexString);
@@ -313,12 +244,132 @@ class Route0 {
     }
     return this._regexAncestor;
   }
+  get regexDescendantMatchers() {
+    if (this._regexDescendantMatchers === void 0) {
+      const matchers = [];
+      if (this.definitionParts[0] !== "/") {
+        let pattern = "";
+        const captureKeys = [];
+        for (const part of this.definitionParts) {
+          if (part.startsWith(":")) {
+            pattern += "/([^/]+)";
+            captureKeys.push(part.replace(/^:/, "").replace(/\?$/, ""));
+          } else if (part.includes("*")) {
+            const prefix = part.replace(/\*\??$/, "");
+            pattern += `/${escapeRegex(prefix)}[^/]*`;
+            captureKeys.push("*");
+          } else {
+            pattern += `/${escapeRegex(part)}`;
+          }
+          matchers.push({
+            regex: new RegExp(`^${pattern}/?$`),
+            captureKeys: [...captureKeys]
+          });
+        }
+      }
+      this._regexDescendantMatchers = matchers;
+    }
+    return this._regexDescendantMatchers;
+  }
   get captureKeys() {
     if (this._captureKeys === void 0) {
-      this._captureKeys = getRouteCaptureKeys(this.definition);
+      this._captureKeys = this.routeTokens.filter((token) => token.kind !== "static").map((token) => token.kind === "param" ? token.name : "*");
     }
     return this._captureKeys;
   }
+  get routeSegments() {
+    if (this._routeSegments === void 0) {
+      this._routeSegments = Route0._getRouteSegments(this.definition);
+    }
+    return this._routeSegments;
+  }
+  get routeTokens() {
+    if (this._routeTokens === void 0) {
+      this._routeTokens = this.routeSegments.map((segment) => {
+        const param = segment.match(/^:([A-Za-z0-9_]+)(\?)?$/);
+        if (param) {
+          return { kind: "param", name: param[1], optional: param[2] === "?" };
+        }
+        if (segment === "*" || segment === "*?") {
+          return { kind: "wildcard", prefix: "", optional: segment.endsWith("?") };
+        }
+        const wildcard = segment.match(/^(.*)\*(\?)?$/);
+        if (wildcard && !segment.includes("\\*")) {
+          return { kind: "wildcard", prefix: wildcard[1], optional: wildcard[2] === "?" };
+        }
+        return { kind: "static", value: segment };
+      });
+    }
+    return this._routeTokens;
+  }
+  get routePatternCandidates() {
+    if (this._routePatternCandidates === void 0) {
+      const values = (token) => {
+        if (token.kind === "static") return [token.value];
+        if (token.kind === "param") return token.optional ? ["", "x", "y"] : ["x", "y"];
+        if (token.prefix.length > 0)
+          return [token.prefix, `${token.prefix}-x`, `${token.prefix}/x`, `${token.prefix}/y/z`];
+        return ["", "x", "y", "x/y"];
+      };
+      let acc = [""];
+      for (const token of this.routeTokens) {
+        const next = [];
+        for (const base of acc) {
+          for (const value of values(token)) {
+            if (value === "") {
+              next.push(base);
+            } else if (value.startsWith("/")) {
+              next.push(`${base}${value}`);
+            } else {
+              next.push(`${base}/${value}`);
+            }
+          }
+        }
+        acc = next.length > 512 ? next.slice(0, 512) : next;
+      }
+      this._routePatternCandidates = acc.length === 0 ? ["/"] : Array.from(new Set(acc.map((x) => x === "" ? "/" : collapseDuplicateSlashes(x))));
+    }
+    return this._routePatternCandidates;
+  }
+  get pathParamsDefinition() {
+    if (this._pathParamsDefinition === void 0) {
+      const entries = this.routeTokens.filter((t) => t.kind !== "static").map((t) => t.kind === "param" ? [t.name, !t.optional] : ["*", !t.optional]);
+      this._pathParamsDefinition = Object.fromEntries(entries);
+    }
+    return this._pathParamsDefinition;
+  }
+  get definitionWithoutTrailingWildcard() {
+    if (this._definitionWithoutTrailingWildcard === void 0) {
+      this._definitionWithoutTrailingWildcard = this.definition.replace(/\*\??$/, "");
+    }
+    return this._definitionWithoutTrailingWildcard;
+  }
+  get routeRegexBaseStringRaw() {
+    if (this._routeRegexBaseStringRaw === void 0) {
+      if (this.routeTokens.length === 0) {
+        this._routeRegexBaseStringRaw = "";
+      } else {
+        let pattern = "";
+        for (const token of this.routeTokens) {
+          if (token.kind === "static") {
+            pattern += `/${escapeRegex(token.value)}`;
+            continue;
+          }
+          if (token.kind === "param") {
+            pattern += token.optional ? "(?:/([^/]+))?" : "/([^/]+)";
+            continue;
+          }
+          if (token.prefix.length > 0) {
+            pattern += `/${escapeRegex(token.prefix)}(.*)`;
+          } else {
+            pattern += "(?:/(.*))?";
+          }
+        }
+        this._routeRegexBaseStringRaw = pattern;
+      }
+    }
+    return this._routeRegexBaseStringRaw;
+  }
   get normalizedDefinition() {
     if (this._normalizedDefinition === void 0) {
       this._normalizedDefinition = this.definition.length > 1 && this.definition.endsWith("/") ? this.definition.slice(0, -1) : this.definition;
@@ -333,23 +384,13 @@ class Route0 {
   }
   /** Fast pathname exact match check without building a full location object. */
   isExactPathnameMatch(pathname) {
-    return this.regex.test(normalizePathname(pathname));
+    return this.regex.test(Route0._normalizePathname(pathname));
   }
   /** Fast pathname exact or ancestor match check without building a full location object. */
   isExactOrAncestorPathnameMatch(pathname) {
-    const normalizedPathname = normalizePathname(pathname);
+    const normalizedPathname = Route0._normalizePathname(pathname);
     return this.regex.test(normalizedPathname) || this.regexAncestor.test(normalizedPathname);
   }
-  /** Creates a grouped strict regex pattern string from many routes. */
-  static getRegexStrictStringGroup(routes) {
-    const patterns = routes.map((route) => route.regexStrictString).join("|");
-    return `(${patterns})`;
-  }
-  /** Creates a strict grouped regex from many routes. */
-  static getRegexStrictGroup(routes) {
-    const patterns = Route0.getRegexStrictStringGroup(routes);
-    return new RegExp(`^(${patterns})$`);
-  }
   /** Creates a grouped regex pattern string from many routes. */
   static getRegexStringGroup(routes) {
     const patterns = routes.map((route) => route.regexString).join("|");
@@ -397,10 +438,9 @@ class Route0 {
     const base = abs ? void 0 : "http://example.com";
     const url = new URL(hrefOrHrefRelOrLocation, base);
     const search = parseSearchQuery(url.search);
-    const pathname = normalizePathname(url.pathname);
-    const hrefRel = pathname + url.search + url.hash;
+    const hrefRel = url.pathname + url.search + url.hash;
     const location = {
-      pathname,
+      pathname: url.pathname,
       search,
       searchString: url.search,
       hash: url.hash,
@@ -433,9 +473,8 @@ class Route0 {
     const location = Route0.getLocation(hrefOrHrefRelOrLocation);
     location.route = this.definition;
     location.params = {};
-    const pathname = normalizePathname(location.pathname);
+    const pathname = Route0._normalizePathname(location.pathname);
     const paramNames = this.captureKeys;
-    const defParts = this.definitionParts;
     const exactRe = this.regex;
     const ancestorRe = this.regexAncestor;
     const exactMatch = pathname.match(exactRe);
@@ -455,46 +494,25 @@ class Route0 {
     } else {
       location.params = {};
     }
-    const pathParts = pathname === "/" ? ["/"] : pathname.split("/").filter(Boolean);
-    let isPrefix = true;
-    if (pathParts.length > defParts.length) {
-      isPrefix = false;
-    } else {
-      for (let i = 0; i < pathParts.length; i++) {
-        const defPart = defParts[i];
-        const pathPart = pathParts[i];
-        if (!defPart) {
-          isPrefix = false;
-          break;
-        }
-        if (defPart.startsWith(":")) continue;
-        if (defPart.includes("*")) {
-          const prefix = defPart.replace(/\*\??$/, "");
-          if (pathPart.startsWith(prefix)) continue;
-          isPrefix = false;
-          break;
-        }
-        if (defPart !== pathPart) {
-          isPrefix = false;
-          break;
-        }
+    let descendant = false;
+    let descendantMatch = null;
+    let descendantCaptureKeys = [];
+    if (!exact && !ancestor) {
+      for (const matcher of this.regexDescendantMatchers) {
+        const match = pathname.match(matcher.regex);
+        if (!match) continue;
+        descendant = true;
+        descendantMatch = match;
+        descendantCaptureKeys = matcher.captureKeys;
+        break;
       }
     }
-    const descendant = !exact && isPrefix;
     const unmatched = !exact && !ancestor && !descendant;
-    if (descendant) {
-      const descendantParams = {};
-      for (let i = 0; i < pathParts.length; i++) {
-        const defPart = defParts[i];
-        const pathPart = pathParts[i];
-        if (!defPart || !pathPart) continue;
-        if (defPart.startsWith(":")) {
-          descendantParams[defPart.replace(/^:/, "").replace(/\?$/, "")] = decodeURIComponent(pathPart);
-        } else if (defPart.includes("*")) {
-          descendantParams["*"] = decodeURIComponent(pathPart);
-        }
-      }
-      location.params = descendantParams;
+    if (descendant && descendantMatch) {
+      const values = descendantMatch.slice(1, 1 + descendantCaptureKeys.length);
+      location.params = Object.fromEntries(
+        descendantCaptureKeys.map((key, index) => [key, decodeURIComponent(values[index])])
+      );
     }
     return {
       ...location,
@@ -593,15 +611,18 @@ class Route0 {
   };
   /** True when path structure is equal (param names are ignored). */
   isSame(other) {
-    return getRouteTokens(this.definition).map((t) => {
+    const thisShape = this.routeTokens.map((t) => {
       if (t.kind === "static") return `s:${t.value}`;
       if (t.kind === "param") return `p:${t.optional ? "o" : "r"}`;
       return `w:${t.prefix}:${t.optional ? "o" : "r"}`;
-    }).join("/") === getRouteTokens(other.definition).map((t) => {
+    }).join("/");
+    const otherRoute = Route0.from(other);
+    const otherShape = otherRoute.routeTokens.map((t) => {
       if (t.kind === "static") return `s:${t.value}`;
       if (t.kind === "param") return `p:${t.optional ? "o" : "r"}`;
       return `w:${t.prefix}:${t.optional ? "o" : "r"}`;
     }).join("/");
+    return thisShape === otherShape;
   }
   /** Static convenience wrapper for `isSame`. */
   static isSame(a, b) {
@@ -625,11 +646,21 @@ class Route0 {
     const thisParts = getParts(this.definition);
     const otherParts = getParts(other.definition);
     if (thisParts.length <= otherParts.length) return false;
+    const matchesPatternPart = (patternPart, valuePart) => {
+      if (patternPart.startsWith(":")) return { match: true, wildcard: false };
+      const wildcardIndex = patternPart.indexOf("*");
+      if (wildcardIndex >= 0) {
+        const prefix = patternPart.slice(0, wildcardIndex);
+        return { match: prefix.length === 0 || valuePart.startsWith(prefix), wildcard: true };
+      }
+      return { match: patternPart === valuePart, wildcard: false };
+    };
     for (let i = 0; i < otherParts.length; i++) {
       const otherPart = otherParts[i];
       const thisPart = thisParts[i];
-      if (otherPart.startsWith(":")) continue;
-      if (otherPart !== thisPart) return false;
+      const result = matchesPatternPart(otherPart, thisPart);
+      if (!result.match) return false;
+      if (result.wildcard) return true;
     }
     return true;
   }
@@ -644,58 +675,54 @@ class Route0 {
     const thisParts = getParts(this.definition);
     const otherParts = getParts(other.definition);
     if (thisParts.length >= otherParts.length) return false;
+    const matchesPatternPart = (patternPart, valuePart) => {
+      if (patternPart.startsWith(":")) return { match: true, wildcard: false };
+      const wildcardIndex = patternPart.indexOf("*");
+      if (wildcardIndex >= 0) {
+        const prefix = patternPart.slice(0, wildcardIndex);
+        return { match: prefix.length === 0 || valuePart.startsWith(prefix), wildcard: true };
+      }
+      return { match: patternPart === valuePart, wildcard: false };
+    };
     for (let i = 0; i < thisParts.length; i++) {
       const thisPart = thisParts[i];
       const otherPart = otherParts[i];
-      if (thisPart.startsWith(":")) continue;
-      if (thisPart !== otherPart) return false;
+      const result = matchesPatternPart(thisPart, otherPart);
+      if (!result.match) return false;
+      if (result.wildcard) return true;
     }
     return true;
   }
   /** True when two route patterns can match the same concrete URL. */
-  isConflict(other) {
+  isOverlap(other) {
     if (!other) return false;
-    other = Route0.create(other);
+    const otherRoute = Route0.from(other);
     const thisRegex = this.regex;
-    const otherRegex = other.regex;
-    const makeCandidates = (definition) => {
-      const tokens = getRouteTokens(definition);
-      const values = (token) => {
-        if (token.kind === "static") return [token.value];
-        if (token.kind === "param") return token.optional ? ["", "x"] : ["x"];
-        if (token.prefix.length > 0) return [token.prefix, `${token.prefix}-x`, `${token.prefix}/x/y`];
-        return ["", "x", "x/y"];
-      };
-      let acc = [""];
-      for (const token of tokens) {
-        const next = [];
-        for (const base of acc) {
-          for (const value of values(token)) {
-            if (value === "") {
-              next.push(base);
-            } else if (value.startsWith("/")) {
-              next.push(`${base}${value}`);
-            } else {
-              next.push(`${base}/${value}`);
-            }
-          }
-        }
-        acc = next;
-      }
-      if (acc.length === 0) return ["/"];
-      return Array.from(new Set(acc.map((x) => x === "" ? "/" : x.replace(/\/{2,}/g, "/"))));
-    };
-    const thisCandidates = makeCandidates(this.definition);
-    const otherCandidates = makeCandidates(other.definition);
+    const otherRegex = otherRoute.regex;
+    const thisCandidates = this.routePatternCandidates;
+    const otherCandidates = otherRoute.routePatternCandidates;
     if (thisCandidates.some((path) => otherRegex.test(path))) return true;
     if (otherCandidates.some((path) => thisRegex.test(path))) return true;
     return false;
   }
-  /** True when paths are same or can overlap when optional parts are omitted. */
-  isMayBeSame(other) {
+  /**
+   * True when overlap is not resolvable by route ordering inside one route set.
+   *
+   * Non-conflicting overlap means one route is a strict subset of another
+   * (e.g. `/x/y` is a strict subset of `/x/:id`) and can be safely ordered first.
+   */
+  isConflict(other) {
     if (!other) return false;
-    other = Route0.create(other);
-    return this.isSame(other) || this.isConflict(other);
+    const otherRoute = Route0.from(other);
+    if (!this.isOverlap(otherRoute)) return false;
+    const thisRegex = this.regex;
+    const otherRegex = otherRoute.regex;
+    const thisCandidates = this.routePatternCandidates;
+    const otherCandidates = otherRoute.routePatternCandidates;
+    const thisExclusive = thisCandidates.some((path) => thisRegex.test(path) && !otherRegex.test(path));
+    const otherExclusive = otherCandidates.some((path) => otherRegex.test(path) && !thisRegex.test(path));
+    if (thisExclusive !== otherExclusive) return false;
+    return true;
   }
   /** Specificity comparator used for deterministic route ordering. */
   isMoreSpecificThan(other) {
@@ -723,6 +750,21 @@ class Route0 {
   }
 }
 class Routes {
+  static _getNormalizedPathnameFromInput(hrefOrHrefRelOrLocation) {
+    if (hrefOrHrefRelOrLocation instanceof URL) {
+      return normalizeSlashPath(hrefOrHrefRelOrLocation.pathname);
+    }
+    if (typeof hrefOrHrefRelOrLocation !== "string") {
+      if (typeof hrefOrHrefRelOrLocation.pathname === "string") {
+        return normalizeSlashPath(hrefOrHrefRelOrLocation.pathname);
+      }
+      hrefOrHrefRelOrLocation = hrefOrHrefRelOrLocation.href || hrefOrHrefRelOrLocation.hrefRel;
+    }
+    const abs = /^[a-zA-Z][a-zA-Z\d+\-.]*:\/\//.test(hrefOrHrefRelOrLocation);
+    const base = abs ? void 0 : "http://example.com";
+    const url = new URL(hrefOrHrefRelOrLocation, base);
+    return normalizeSlashPath(url.pathname);
+  }
   _routes;
   _pathsOrdering;
   _keysOrdering;
@@ -786,7 +828,7 @@ class Routes {
   }
   _getLocation(hrefOrHrefRelOrLocation) {
     const input = hrefOrHrefRelOrLocation;
-    const pathname = getNormalizedPathnameFromInput(input);
+    const pathname = Routes._getNormalizedPathnameFromInput(input);
     for (const route of this._ordered) {
       if (!route.isExactPathnameMatch(pathname)) {
         continue;
@@ -808,7 +850,7 @@ class Routes {
     entries.sort(([_keyA, routeA], [_keyB, routeB]) => {
       const partsA = getParts(routeA.definition);
       const partsB = getParts(routeB.definition);
-      if (routeA.isMayBeSame(routeB)) {
+      if (routeA.isOverlap(routeB)) {
         if (routeA.isMoreSpecificThan(routeB)) return -1;
         if (routeB.isMoreSpecificThan(routeA)) return 1;
       }