@devp0nt/route0 1.0.0-next.67 → 1.0.0-next.68

package/dist/cjs/index.cjs

@@ -22,13 +22,67 @@ __export(index_exports, {
   Routes: () => Routes
 });
 module.exports = __toCommonJS(index_exports);
+const escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const getPathSegments = (definition) => {
+  if (definition === "" || definition === "/") return [];
+  return definition.split("/").filter(Boolean);
+};
+const getRuntimePathTokens = (definition) => {
+  const segments = getPathSegments(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 getPathRegexBaseStrictString = (definition) => {
+  const tokens = getRuntimePathTokens(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 getPathCaptureKeys = (definition) => {
+  const keys = [];
+  for (const token of getRuntimePathTokens(definition)) {
+    if (token.kind === "param") keys.push(token.name);
+    if (token.kind === "wildcard") keys.push("*");
+  }
+  return keys;
+};
+const getPathParamsDefinition = (definition) => {
+  const entries = getRuntimePathTokens(definition).filter((t) => t.kind !== "static").map((t) => t.kind === "param" ? [t.name, !t.optional] : ["*", !t.optional]);
+  return Object.fromEntries(entries);
+};
 class Route0 {
   definition;
-  pathDefinition;
-  paramsDefinition;
-  searchDefinition;
-  hasLooseSearch;
+  params;
   _origin;
+  _callable;
+  Infer = null;
   /** Base URL used when generating absolute URLs (`abs: true`). */
   get origin() {
     if (!this._origin) {
@@ -43,10 +97,7 @@ class Route0 {
   }
   constructor(definition, config = {}) {
     this.definition = definition;
-    this.pathDefinition = Route0._getPathDefinitionBydefinition(definition);
-    this.paramsDefinition = Route0._getParamsDefinitionBydefinition(definition);
-    this.searchDefinition = Route0._getSearchDefinitionBydefinition(definition);
-    this.hasLooseSearch = Route0._hasLooseSearch(definition);
+    this.params = Route0._getParamsDefinitionByDefinition(definition);
     const { origin } = config;
     if (origin && typeof origin === "string" && origin.length) {
       this._origin = origin;
@@ -58,6 +109,12 @@ class Route0 {
         this._origin = void 0;
       }
     }
+    const callable = this.get.bind(this);
+    Object.setPrototypeOf(callable, this);
+    Object.defineProperty(callable, Symbol.toStringTag, {
+      value: this.definition
+    });
+    this._callable = callable;
   }
   /**
    * Creates a callable route instance.
@@ -65,19 +122,11 @@ class Route0 {
    * If an existing route/callable route is provided, it is cloned.
    */
   static create(definition, config) {
-    if (typeof definition === "function") {
-      return definition.clone(config);
-    }
-    if (typeof definition === "object") {
+    if (typeof definition === "function" || typeof definition === "object") {
       return definition.clone(config);
     }
     const original = new Route0(definition, config);
-    const callable = original.get.bind(original);
-    Object.setPrototypeOf(callable, original);
-    Object.defineProperty(callable, Symbol.toStringTag, {
-      value: original.definition
-    });
-    return callable;
+    return original._callable;
   }
   /**
    * Normalizes a definition/route into a callable route.
@@ -89,61 +138,24 @@ class Route0 {
       return definition;
     }
     const original = typeof definition === "object" ? definition : new Route0(definition);
-    const callable = original.get.bind(original);
-    Object.setPrototypeOf(callable, original);
-    Object.defineProperty(callable, Symbol.toStringTag, {
-      value: original.definition
-    });
-    return callable;
-  }
-  static _splitPathDefinitionAndSearchTailDefinition(definition) {
-    const i = definition.indexOf("&");
-    if (i === -1) return { pathDefinition: definition, searchTailDefinition: "" };
-    return {
-      pathDefinition: definition.slice(0, i),
-      searchTailDefinition: definition.slice(i)
-    };
-  }
-  static _getAbsPath(origin, pathWithSearch) {
-    return new URL(pathWithSearch, origin).toString().replace(/\/$/, "");
+    return original._callable;
   }
-  static _getPathDefinitionBydefinition(definition) {
-    const { pathDefinition } = Route0._splitPathDefinitionAndSearchTailDefinition(definition);
-    return pathDefinition;
+  static _getAbsPath(origin, url) {
+    return new URL(url, origin).toString().replace(/\/$/, "");
   }
-  static _getParamsDefinitionBydefinition(definition) {
-    const { pathDefinition } = Route0._splitPathDefinitionAndSearchTailDefinition(definition);
-    const matches = Array.from(pathDefinition.matchAll(/:([A-Za-z0-9_]+)/g));
-    const paramsDefinition = Object.fromEntries(matches.map((m) => [m[1], true]));
-    const keysCount = Object.keys(paramsDefinition).length;
-    if (keysCount === 0) {
-      return void 0;
-    }
-    return paramsDefinition;
-  }
-  static _getSearchDefinitionBydefinition(definition) {
-    const { searchTailDefinition } = Route0._splitPathDefinitionAndSearchTailDefinition(definition);
-    if (!searchTailDefinition) {
-      return void 0;
-    }
-    const keys = searchTailDefinition.split("&").filter(Boolean);
-    const searchDefinition = Object.fromEntries(keys.map((k) => [k, true]));
-    const keysCount = Object.keys(searchDefinition).length;
-    if (keysCount === 0) {
-      return void 0;
-    }
-    return searchDefinition;
+  static _getParamsDefinitionByDefinition(definition) {
+    return getPathParamsDefinition(definition);
   }
-  static _hasLooseSearch(definition) {
-    return definition.endsWith("&");
+  search() {
+    return this._callable;
   }
   /** Extends the current route definition by appending a suffix route. */
   extend(suffixDefinition) {
-    const { pathDefinition: parentPathDefinition } = Route0._splitPathDefinitionAndSearchTailDefinition(this.definition);
-    const { pathDefinition: suffixPathDefinition, searchTailDefinition: suffixSearchTailDefinition } = Route0._splitPathDefinitionAndSearchTailDefinition(suffixDefinition);
-    const pathDefinition = `${parentPathDefinition}/${suffixPathDefinition}`.replace(/\/{2,}/g, "/");
-    const definition = `${pathDefinition}${suffixSearchTailDefinition}`;
-    return Route0.create(definition, { origin: this._origin });
+    const definition = `${this.definition}/${suffixDefinition}`.replace(/\/{2,}/g, "/");
+    return Route0.create(
+      definition,
+      { origin: this._origin }
+    );
   }
   // implementation
   get(...args) {
@@ -157,35 +169,61 @@ class Route0 {
           hashInput: void 0
         };
       }
-      const input = args[0];
-      if (typeof input !== "object" || input === null) {
-        return {
-          searchInput: {},
-          paramsInput: {},
-          absInput: false,
-          absOriginInput: void 0,
-          hashInput: void 0
-        };
+      const [input, abs] = (() => {
+        if (typeof args[0] === "object" && args[0] !== null) {
+          return [args[0], args[1]];
+        }
+        if (typeof args[1] === "object" && args[1] !== null) {
+          return [args[1], args[0]];
+        }
+        if (typeof args[0] === "boolean" || typeof args[0] === "string") {
+          return [{}, args[0]];
+        }
+        if (typeof args[1] === "boolean" || typeof args[1] === "string") {
+          return [{}, args[1]];
+        }
+        return [{}, void 0];
+      })();
+      let searchInput2 = {};
+      let hashInput2 = void 0;
+      const paramsInput2 = {};
+      for (const [key, value] of Object.entries(input)) {
+        if (key === "?" && typeof value === "object" && value !== null) {
+          searchInput2 = value;
+        } else if (key === "#" && (typeof value === "string" || typeof value === "number")) {
+          hashInput2 = String(value);
+        } else if (key in this.params && (typeof value === "string" || typeof value === "number")) {
+          Object.assign(paramsInput2, { [key]: String(value) });
+        }
       }
-      const { search, abs, hash, ...params } = input;
       const absOriginInput2 = typeof abs === "string" && abs.length > 0 ? abs : void 0;
       return {
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-        searchInput: search || {},
-        paramsInput: params,
+        searchInput: searchInput2,
+        paramsInput: paramsInput2,
         absInput: absOriginInput2 !== void 0 || abs === true,
         absOriginInput: absOriginInput2,
-        hashInput: hash
+        hashInput: hashInput2
       };
     })();
-    const neededParamsKeys = this.paramsDefinition ? Object.keys(this.paramsDefinition) : [];
-    const providedParamsKeys = Object.keys(paramsInput);
-    const notProvidedKeys = neededParamsKeys.filter((k) => !providedParamsKeys.includes(k));
-    if (notProvidedKeys.length) {
-      Object.assign(paramsInput, Object.fromEntries(notProvidedKeys.map((k) => [k, "undefined"])));
-    }
-    let url = this.pathDefinition;
-    url = url.replace(/:([A-Za-z0-9_]+)/g, (_m, k) => encodeURIComponent(String(paramsInput?.[k] ?? "")));
+    let url = this.definition;
+    url = url.replace(/\/:([A-Za-z0-9_]+)\?/g, (_m, k) => {
+      const value = paramsInput[k];
+      if (value === void 0) return "";
+      return `/${encodeURIComponent(String(value))}`;
+    });
+    url = url.replace(/:([A-Za-z0-9_]+)(?!\?)/g, (_m, k) => encodeURIComponent(String(paramsInput?.[k] ?? "undefined")));
+    url = url.replace(/\/\*\?/g, () => {
+      const value = paramsInput["*"];
+      if (value === void 0) return "";
+      const stringValue = String(value);
+      return stringValue.startsWith("/") ? stringValue : `/${stringValue}`;
+    });
+    url = url.replace(/\/\*/g, () => {
+      const value = String(paramsInput["*"] ?? "");
+      return value.startsWith("/") ? value : `/${value}`;
+    });
+    url = url.replace(/\*\?/g, () => String(paramsInput["*"] ?? ""));
+    url = url.replace(/\*/g, () => String(paramsInput["*"] ?? ""));
     const searchInputStringified = Object.fromEntries(Object.entries(searchInput).map(([k, v]) => [k, String(v)]));
     url = [url, new URLSearchParams(searchInputStringified).toString()].filter(Boolean).join("?");
     url = url.replace(/\/{2,}/g, "/");
@@ -195,92 +233,16 @@ class Route0 {
     }
     return url;
   }
-  // implementation
-  flat(...args) {
-    const { searchInput, paramsInput, absInput, hashInput } = (() => {
-      if (args.length === 0) {
-        return {
-          searchInput: {},
-          paramsInput: {},
-          absInput: false,
-          hashInput: void 0
-        };
-      }
-      const input = args[0];
-      if (typeof input !== "object" || input === null) {
-        return {
-          searchInput: {},
-          paramsInput: {},
-          absInput: args[1] ?? false,
-          hashInput: void 0
-        };
-      }
-      const loose = args[2] ?? this.hasLooseSearch;
-      const paramsKeys = this.getParamsKeys();
-      const paramsInput2 = paramsKeys.reduce((acc, key) => {
-        if (input[key] !== void 0) {
-          acc[key] = input[key];
-        }
-        return acc;
-      }, {});
-      const searchKeys = this.getSearchKeys();
-      const searchInput2 = Object.keys(input).filter((k) => {
-        if (k === "hash") {
-          return false;
-        }
-        if (searchKeys.includes(k)) {
-          return true;
-        }
-        if (paramsKeys.includes(k)) {
-          return false;
-        }
-        return loose;
-      }).reduce((acc, key) => {
-        acc[key] = input[key];
-        return acc;
-      }, {});
-      const hashInput2 = input.hash;
-      return {
-        searchInput: searchInput2,
-        paramsInput: paramsInput2,
-        absInput: args[1] ?? false,
-        hashInput: hashInput2
-      };
-    })();
-    return this.get({
-      ...paramsInput,
-      search: searchInput,
-      abs: absInput,
-      hash: hashInput
-    });
-  }
-  flatLoose(...args) {
-    return this.flat(args[0], args[1], true);
-  }
-  flatStrict(...args) {
-    return this.flat(args[0], args[1], false);
-  }
   /** Returns path param keys extracted from route definition. */
   getParamsKeys() {
-    return Object.keys(this.paramsDefinition || {});
-  }
-  /** Returns named search keys extracted from route definition. */
-  getSearchKeys() {
-    return Object.keys(this.searchDefinition || {});
-  }
-  /** Returns all flat input keys (`search + params`). */
-  getFlatKeys() {
-    return [...this.getSearchKeys(), ...this.getParamsKeys()];
-  }
-  getDefinition() {
-    return this.pathDefinition;
+    return Object.keys(this.params);
   }
   /** Clones route with optional config override. */
   clone(config) {
     return Route0.create(this.definition, config);
   }
   getRegexBaseStrictString() {
-    return this.pathDefinition.replace(/:(\w+)/g, "___PARAM___").replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/___PARAM___/g, "([^/]+)");
+    return getPathRegexBaseStrictString(this.definition);
   }
   getRegexBaseString() {
     return this.getRegexBaseStrictString().replace(/\/+$/, "") + "/?";
@@ -394,12 +356,8 @@ class Route0 {
     location.route = this.definition;
     location.params = {};
     const pathname = location.pathname.length > 1 && location.pathname.endsWith("/") ? location.pathname.slice(0, -1) : location.pathname;
-    const paramNames = [];
-    const def = this.pathDefinition.length > 1 && this.pathDefinition.endsWith("/") ? this.pathDefinition.slice(0, -1) : this.pathDefinition;
-    def.replace(/:([A-Za-z0-9_]+)/g, (_m, name) => {
-      paramNames.push(String(name));
-      return "";
-    });
+    const paramNames = getPathCaptureKeys(this.definition);
+    const def = this.definition.length > 1 && this.definition.endsWith("/") ? this.definition.slice(0, -1) : this.definition;
     const exactRe = new RegExp(`^${this.getRegexBaseString()}$`);
     const ancestorRe = new RegExp(`^${this.getRegexBaseString()}(?:/.*)?$`);
     const exactMatch = pathname.match(exactRe);
@@ -409,7 +367,12 @@ class Route0 {
     const paramsMatch = exactMatch || (ancestor ? ancestorMatch : null);
     if (paramsMatch) {
       const values = paramsMatch.slice(1, 1 + paramNames.length);
-      const params = Object.fromEntries(paramNames.map((n, i) => [n, decodeURIComponent(values[i] ?? "")]));
+      const params = Object.fromEntries(
+        paramNames.map((n, i) => {
+          const value = values[i];
+          return [n, value === void 0 ? void 0 : decodeURIComponent(value)];
+        })
+      );
       location.params = params;
     } else {
       location.params = {};
@@ -429,6 +392,12 @@ class Route0 {
           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;
@@ -444,7 +413,9 @@ class Route0 {
         const pathPart = pathParts[i];
         if (!defPart || !pathPart) continue;
         if (defPart.startsWith(":")) {
-          descendantParams[defPart.slice(1)] = decodeURIComponent(pathPart);
+          descendantParams[defPart.replace(/^:/, "").replace(/\?$/, "")] = decodeURIComponent(pathPart);
+        } else if (defPart.includes("*")) {
+          descendantParams["*"] = decodeURIComponent(pathPart);
         }
       }
       location.params = descendantParams;
@@ -459,13 +430,16 @@ class Route0 {
     };
   }
   _validateParamsInput(input) {
-    const paramsKeys = this.getParamsKeys();
+    const paramsEntries = Object.entries(this.params);
+    const paramsMap = this.params;
+    const requiredParamsKeys = paramsEntries.filter(([, required]) => required).map(([k]) => k);
+    const paramsKeys = paramsEntries.map(([k]) => k);
     if (input === void 0) {
-      if (paramsKeys.length) {
+      if (requiredParamsKeys.length) {
         return {
           issues: [
             {
-              message: `Missing params: ${paramsKeys.map((k) => `"${k}"`).join(", ")}`
+              message: `Missing params: ${requiredParamsKeys.map((k) => `"${k}"`).join(", ")}`
             }
           ]
         };
@@ -474,12 +448,12 @@ class Route0 {
     }
     if (typeof input !== "object" || input === null) {
       return {
-        issues: [{ message: "Invalid input: expected object" }]
+        issues: [{ message: "Invalid route params: expected object" }]
       };
     }
     const inputObj = input;
     const inputKeys = Object.keys(inputObj);
-    const notDefinedKeys = paramsKeys.filter((k) => !inputKeys.includes(k));
+    const notDefinedKeys = requiredParamsKeys.filter((k) => !inputKeys.includes(k));
     if (notDefinedKeys.length) {
       return {
         issues: [
@@ -492,13 +466,16 @@ class Route0 {
     const data = {};
     for (const k of paramsKeys) {
       const v = inputObj[k];
-      if (typeof v === "string") {
+      const required = paramsMap[k];
+      if (v === void 0 && !required) {
+        data[k] = void 0;
+      } else if (typeof v === "string") {
         data[k] = v;
       } else if (typeof v === "number") {
         data[k] = String(v);
       } else {
         return {
-          issues: [{ message: `Invalid input: expected string, number, got ${typeof v} for "${k}"` }]
+          issues: [{ message: `Invalid route params: expected string, number, got ${typeof v} for "${k}"` }]
         };
       }
     }
@@ -506,58 +483,6 @@ class Route0 {
       value: data
     };
   }
-  _validateSearchInput(input, loose) {
-    if (input === void 0) {
-      input = {};
-    }
-    if (typeof input !== "object" || input === null) {
-      return {
-        issues: [{ message: "Invalid input: expected object" }]
-      };
-    }
-    const inputObj = input;
-    const paramsKeys = this.getParamsKeys();
-    const searchKeys = this.getSearchKeys();
-    const data = {};
-    for (const [k, v] of Object.entries(inputObj)) {
-      if (k === "hash") continue;
-      if (paramsKeys.includes(k)) continue;
-      if (!loose && !searchKeys.includes(k)) continue;
-      if (v === void 0) continue;
-      if (typeof v === "string") {
-        data[k] = v;
-      } else if (typeof v === "number") {
-        data[k] = String(v);
-      } else {
-        return {
-          issues: [{ message: `Invalid input: expected string, number, or undefined, got ${typeof v} for "${k}"` }]
-        };
-      }
-    }
-    return {
-      value: data
-    };
-  }
-  _validateFlatInput(input, loose) {
-    const paramsResult = this._validateParamsInput(input);
-    if ("issues" in paramsResult) {
-      return {
-        issues: paramsResult.issues ?? []
-      };
-    }
-    const searchResult = this._validateSearchInput(input, loose);
-    if ("issues" in searchResult) {
-      return {
-        issues: searchResult.issues ?? []
-      };
-    }
-    return {
-      value: {
-        ...searchResult.value,
-        ...paramsResult.value
-      }
-    };
-  }
   _safeParseSchemaResult(result) {
     if ("issues" in result) {
       return {
@@ -580,7 +505,7 @@ class Route0 {
     return safeResult.data;
   }
   /** Standard Schema for route params input. */
-  paramsInputSchema = {
+  paramsSchema = {
     "~standard": {
       version: 1,
       vendor: "route0",
@@ -590,42 +515,17 @@ class Route0 {
     parse: (value) => this._parseSchemaResult(this._validateParamsInput(value)),
     safeParse: (value) => this._safeParseSchemaResult(this._validateParamsInput(value))
   };
-  /** Standard Schema for strict search input. */
-  strictSearchInputSchema = {
-    "~standard": {
-      version: 1,
-      vendor: "route0",
-      validate: (value) => this._validateSearchInput(value, false),
-      types: void 0
-    },
-    parse: (value) => this._parseSchemaResult(this._validateSearchInput(value, false)),
-    safeParse: (value) => this._safeParseSchemaResult(this._validateSearchInput(value, false))
-  };
-  /** Standard Schema for loose search input. */
-  looseSearchInputSchema = {
-    "~standard": {
-      version: 1,
-      vendor: "route0",
-      validate: (value) => this._validateSearchInput(value, true),
-      types: void 0
-    },
-    parse: (value) => this._parseSchemaResult(this._validateSearchInput(value, true)),
-    safeParse: (value) => this._safeParseSchemaResult(this._validateSearchInput(value, true))
-  };
-  /** Standard Schema for route flat input (uses route default strict/loose mode). */
-  flatInputSchema = {
-    "~standard": {
-      version: 1,
-      vendor: "route0",
-      validate: (value) => this._validateFlatInput(value, this.hasLooseSearch),
-      types: void 0
-    },
-    parse: (value) => this._parseSchemaResult(this._validateFlatInput(value, this.hasLooseSearch)),
-    safeParse: (value) => this._safeParseSchemaResult(this._validateFlatInput(value, this.hasLooseSearch))
-  };
   /** True when path structure is equal (param names are ignored). */
   isSame(other) {
-    return this.pathDefinition.replace(/:([A-Za-z0-9_]+)/g, "__PARAM__") === other.pathDefinition.replace(/:([A-Za-z0-9_]+)/g, "__PARAM__");
+    return getRuntimePathTokens(this.definition).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("/") === getRuntimePathTokens(other.definition).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("/");
   }
   /** Static convenience wrapper for `isSame`. */
   static isSame(a, b) {
@@ -643,11 +543,11 @@ class Route0 {
     if (!other) return false;
     other = Route0.create(other);
     const getParts = (path) => path === "/" ? ["/"] : path.split("/").filter(Boolean);
-    if (other.pathDefinition === "/" && this.pathDefinition !== "/") {
+    if (other.definition === "/" && this.definition !== "/") {
       return true;
     }
-    const thisParts = getParts(this.pathDefinition);
-    const otherParts = getParts(other.pathDefinition);
+    const thisParts = getParts(this.definition);
+    const otherParts = getParts(other.definition);
     if (thisParts.length <= otherParts.length) return false;
     for (let i = 0; i < otherParts.length; i++) {
       const otherPart = otherParts[i];
@@ -662,11 +562,11 @@ class Route0 {
     if (!other) return false;
     other = Route0.create(other);
     const getParts = (path) => path === "/" ? ["/"] : path.split("/").filter(Boolean);
-    if (this.pathDefinition === "/" && other.pathDefinition !== "/") {
+    if (this.definition === "/" && other.definition !== "/") {
       return true;
     }
-    const thisParts = getParts(this.pathDefinition);
-    const otherParts = getParts(other.pathDefinition);
+    const thisParts = getParts(this.definition);
+    const otherParts = getParts(other.definition);
     if (thisParts.length >= otherParts.length) return false;
     for (let i = 0; i < thisParts.length; i++) {
       const thisPart = thisParts[i];
@@ -680,29 +580,46 @@ class Route0 {
   isConflict(other) {
     if (!other) return false;
     other = Route0.create(other);
-    const getParts = (path) => {
-      if (path === "/") return ["/"];
-      return path.split("/").filter(Boolean);
-    };
-    const thisParts = getParts(this.pathDefinition);
-    const otherParts = getParts(other.pathDefinition);
-    if (thisParts.length !== otherParts.length) {
-      return false;
-    }
-    for (let i = 0; i < thisParts.length; i++) {
-      const thisPart = thisParts[i];
-      const otherPart = otherParts[i];
-      if (thisPart.startsWith(":") && otherPart.startsWith(":")) {
-        continue;
-      }
-      if (thisPart.startsWith(":") || otherPart.startsWith(":")) {
-        continue;
-      }
-      if (thisPart !== otherPart) {
-        return false;
+    const thisRegex = this.getRegex();
+    const otherRegex = other.getRegex();
+    const makeCandidates = (definition) => {
+      const tokens = getRuntimePathTokens(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;
       }
-    }
-    return true;
+      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);
+    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) {
+    if (!other) return false;
+    other = Route0.create(other);
+    return this.isSame(other) || this.isConflict(other);
   }
   /** Specificity comparator used for deterministic route ordering. */
   isMoreSpecificThan(other) {
@@ -712,15 +629,21 @@ class Route0 {
       if (path === "/") return ["/"];
       return path.split("/").filter(Boolean);
     };
-    const thisParts = getParts(this.pathDefinition);
-    const otherParts = getParts(other.pathDefinition);
+    const rank = (part) => {
+      if (part.includes("*")) return -1;
+      if (part.startsWith(":") && part.endsWith("?")) return 0;
+      if (part.startsWith(":")) return 1;
+      return 2;
+    };
+    const thisParts = getParts(this.definition);
+    const otherParts = getParts(other.definition);
     for (let i = 0; i < Math.min(thisParts.length, otherParts.length); i++) {
-      const thisIsStatic = !thisParts[i].startsWith(":");
-      const otherIsStatic = !otherParts[i].startsWith(":");
-      if (thisIsStatic && !otherIsStatic) return true;
-      if (!thisIsStatic && otherIsStatic) return false;
+      const thisRank = rank(thisParts[i]);
+      const otherRank = rank(otherParts[i]);
+      if (thisRank > otherRank) return true;
+      if (thisRank < otherRank) return false;
     }
-    return this.pathDefinition < other.pathDefinition;
+    return this.definition < other.definition;
   }
 }
 class Routes {
@@ -803,16 +726,16 @@ class Routes {
       return path.split("/").filter(Boolean);
     };
     entries.sort(([_keyA, routeA], [_keyB, routeB]) => {
-      const partsA = getParts(routeA.pathDefinition);
-      const partsB = getParts(routeB.pathDefinition);
-      if (partsA.length !== partsB.length) {
-        return partsA.length - partsB.length;
-      }
-      if (routeA.isConflict(routeB)) {
+      const partsA = getParts(routeA.definition);
+      const partsB = getParts(routeB.definition);
+      if (routeA.isMayBeSame(routeB)) {
         if (routeA.isMoreSpecificThan(routeB)) return -1;
         if (routeB.isMoreSpecificThan(routeA)) return 1;
       }
-      return routeA.pathDefinition.localeCompare(routeB.pathDefinition);
+      if (partsA.length !== partsB.length) {
+        return partsA.length - partsB.length;
+      }
+      return routeA.definition.localeCompare(routeB.definition);
     });
     const pathsOrdering = entries.map(([_key, route]) => route.definition);
     const keysOrdering = entries.map(([_key]) => _key);