@devp0nt/route0 1.0.0-next.6 → 1.0.0-next.60

package/dist/esm/index.js

@@ -1,134 +1,724 @@
 class Route0 {
-  pathOriginalDefinition;
+  definition;
   pathDefinition;
   paramsDefinition;
-  queryDefinition;
-  baseUrl;
+  searchDefinition;
+  hasLooseSearch;
+  _baseurl;
+  /** Base URL used when generating absolute URLs (`abs: true`). */
+  get baseurl() {
+    if (!this._baseurl) {
+      throw new Error(
+        "baseurl for route " + this.definition + ' is not set, please provide it like Route0.create(route, {baseurl: "https://example.com"}) in config or set via overrides like routes._.override({baseurl: "https://example.com"})'
+      );
+    }
+    return this._baseurl;
+  }
+  set baseurl(baseurl) {
+    this._baseurl = baseurl;
+  }
   constructor(definition, config = {}) {
-    this.pathOriginalDefinition = definition;
-    this.pathDefinition = Route0._getPathDefinitionByOriginalDefinition(definition);
-    this.paramsDefinition = Route0._getParamsDefinitionByRouteDefinition(definition);
-    this.queryDefinition = Route0._getQueryDefinitionByRouteDefinition(definition);
-    const { baseUrl } = config;
-    if (baseUrl && typeof baseUrl === "string" && baseUrl.length) {
-      this.baseUrl = baseUrl;
+    this.definition = definition;
+    this.pathDefinition = Route0._getPathDefinitionBydefinition(definition);
+    this.paramsDefinition = Route0._getParamsDefinitionBydefinition(definition);
+    this.searchDefinition = Route0._getSearchDefinitionBydefinition(definition);
+    this.hasLooseSearch = Route0._hasLooseSearch(definition);
+    const { baseurl } = config;
+    if (baseurl && typeof baseurl === "string" && baseurl.length) {
+      this._baseurl = baseurl;
     } else {
       const g = globalThis;
-      if (g?.location?.origin) {
-        this.baseUrl = g.location.origin;
+      if (typeof g?.location?.origin === "string" && g.location.origin.length > 0) {
+        this._baseurl = g.location.origin;
       } else {
-        this.baseUrl = "https://example.com";
+        this._baseurl = void 0;
       }
     }
   }
+  /**
+   * Creates a callable route instance.
+   *
+   * If an existing route/callable route is provided, it is cloned.
+   */
   static create(definition, config) {
-    const original = new Route0(
-      definition,
-      config
-    );
+    if (typeof definition === "function") {
+      return definition.clone(config);
+    }
+    if (typeof definition === "object") {
+      return definition.clone(config);
+    }
+    const original = new Route0(definition, config);
     const callable = original.get.bind(original);
-    const proxy = new Proxy(callable, {
-      get(_target, prop, receiver) {
-        const value = original[prop];
-        if (typeof value === "function") {
-          return value.bind(original);
-        }
-        return value;
-      },
-      set(_target, prop, value, receiver) {
-        ;
-        original[prop] = value;
-        return true;
-      },
-      has(_target, prop) {
-        return prop in original;
-      }
+    Object.setPrototypeOf(callable, original);
+    Object.defineProperty(callable, Symbol.toStringTag, {
+      value: original.definition
     });
-    Object.setPrototypeOf(proxy, Route0.prototype);
-    return proxy;
+    return callable;
   }
-  static _splitPathDefinitionAndQueryTailDefinition(pathOriginalDefinition) {
-    const i = pathOriginalDefinition.indexOf("&");
-    if (i === -1) return { pathDefinition: pathOriginalDefinition, queryTailDefinition: "" };
+  /**
+   * Normalizes a definition/route into a callable route.
+   *
+   * Unlike `create`, passing a callable route returns the same instance.
+   */
+  static from(definition) {
+    if (typeof definition === "function") {
+      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: pathOriginalDefinition.slice(0, i),
-      queryTailDefinition: pathOriginalDefinition.slice(i)
+      pathDefinition: definition.slice(0, i),
+      searchTailDefinition: definition.slice(i)
     };
   }
-  static _getAbsPath(baseUrl, pathWithQuery) {
-    return new URL(pathWithQuery, baseUrl).toString().replace(/\/$/, "");
+  static _getAbsPath(baseurl, pathWithSearch) {
+    return new URL(pathWithSearch, baseurl).toString().replace(/\/$/, "");
   }
-  static _getPathDefinitionByOriginalDefinition(pathOriginalDefinition) {
-    const { pathDefinition } = Route0._splitPathDefinitionAndQueryTailDefinition(pathOriginalDefinition);
+  static _getPathDefinitionBydefinition(definition) {
+    const { pathDefinition } = Route0._splitPathDefinitionAndSearchTailDefinition(definition);
     return pathDefinition;
   }
-  static _getParamsDefinitionByRouteDefinition(pathOriginalDefinition) {
-    const { pathDefinition } = Route0._splitPathDefinitionAndQueryTailDefinition(pathOriginalDefinition);
+  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 _getQueryDefinitionByRouteDefinition(pathOriginalDefinition) {
-    const { queryTailDefinition } = Route0._splitPathDefinitionAndQueryTailDefinition(pathOriginalDefinition);
-    if (!queryTailDefinition) {
-      return {};
+  static _getSearchDefinitionBydefinition(definition) {
+    const { searchTailDefinition } = Route0._splitPathDefinitionAndSearchTailDefinition(definition);
+    if (!searchTailDefinition) {
+      return void 0;
     }
-    const keys = queryTailDefinition.split("&").map(Boolean);
-    const queryDefinition = Object.fromEntries(keys.map((k) => [k, true]));
-    return queryDefinition;
-  }
-  static overrideMany(routes, config) {
-    const result = {};
-    for (const [key, value] of Object.entries(routes)) {
-      ;
-      result[key] = value.clone(config);
+    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 result;
+    return searchDefinition;
   }
+  static _hasLooseSearch(definition) {
+    return /&$/.test(definition);
+  }
+  /** Extends the current route definition by appending a suffix route. */
   extend(suffixDefinition) {
-    const { pathDefinition: parentPathDefinition } = Route0._splitPathDefinitionAndQueryTailDefinition(
-      this.pathOriginalDefinition
-    );
-    const { pathDefinition: suffixPathDefinition, queryTailDefinition: suffixQueryTailDefinition } = Route0._splitPathDefinitionAndQueryTailDefinition(suffixDefinition);
+    const { pathDefinition: parentPathDefinition } = Route0._splitPathDefinitionAndSearchTailDefinition(this.definition);
+    const { pathDefinition: suffixPathDefinition, searchTailDefinition: suffixSearchTailDefinition } = Route0._splitPathDefinitionAndSearchTailDefinition(suffixDefinition);
     const pathDefinition = `${parentPathDefinition}/${suffixPathDefinition}`.replace(/\/{2,}/g, "/");
-    const pathOriginalDefinition = `${pathDefinition}${suffixQueryTailDefinition}`;
-    return Route0.create(pathOriginalDefinition, { baseUrl: this.baseUrl });
+    const definition = `${pathDefinition}${suffixSearchTailDefinition}`;
+    return Route0.create(definition, { baseurl: this._baseurl });
   }
   // implementation
   get(...args) {
-    const { queryInput, paramsInput, absInput } = (() => {
+    const { searchInput, paramsInput, absInput, hashInput } = (() => {
       if (args.length === 0) {
-        return { queryInput: {}, paramsInput: {}, absInput: false };
+        return {
+          searchInput: {},
+          paramsInput: {},
+          absInput: false,
+          hashInput: void 0
+        };
       }
       const input = args[0];
       if (typeof input !== "object" || input === null) {
-        return { queryInput: {}, paramsInput: {}, absInput: false };
+        return {
+          searchInput: {},
+          paramsInput: {},
+          absInput: false,
+          hashInput: void 0
+        };
       }
-      const { query, abs, ...params } = input;
-      return { queryInput: query || {}, paramsInput: params, absInput: abs ?? false };
+      const { search, abs, hash, ...params } = input;
+      return {
+        searchInput: search || {},
+        paramsInput: params,
+        absInput: abs ?? false,
+        hashInput: hash
+      };
     })();
-    const neededParamsKeys = Object.keys(this.paramsDefinition);
+    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 = String(this.pathDefinition);
+    let url = this.pathDefinition;
     url = url.replace(/:([A-Za-z0-9_]+)/g, (_m, k) => encodeURIComponent(String(paramsInput?.[k] ?? "")));
-    const queryInputStringified = Object.fromEntries(Object.entries(queryInput).map(([k, v]) => [k, String(v)]));
-    url = [url, new URLSearchParams(queryInputStringified).toString()].filter(Boolean).join("?");
+    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, "/");
-    url = absInput ? Route0._getAbsPath(this.baseUrl, url) : url;
+    url = absInput ? Route0._getAbsPath(this.baseurl, url) : url;
+    if (hashInput !== void 0) {
+      url = `${url}#${hashInput}`;
+    }
     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;
   }
+  /** Clones route with optional config override. */
   clone(config) {
-    return new Route0(this.pathOriginalDefinition, config);
+    return Route0.create(this.definition, config);
+  }
+  getRegexBaseStrictString() {
+    return this.pathDefinition.replace(/:(\w+)/g, "___PARAM___").replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/___PARAM___/g, "([^/]+)");
+  }
+  getRegexBaseString() {
+    return this.getRegexBaseStrictString().replace(/\/+$/, "") + "/?";
+  }
+  getRegexStrictString() {
+    return `^${this.getRegexBaseStrictString()}$`;
+  }
+  getRegexString() {
+    return `^${this.getRegexBaseString()}$`;
+  }
+  getRegexStrict() {
+    return new RegExp(this.getRegexStrictString());
+  }
+  getRegex() {
+    return new RegExp(this.getRegexString());
+  }
+  /** Creates a grouped strict regex pattern string from many routes. */
+  static getRegexStrictStringGroup(routes) {
+    const patterns = routes.map((route) => route.getRegexStrictString()).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.getRegexString()).join("|");
+    return `(${patterns})`;
+  }
+  /** Creates a grouped regex from many routes. */
+  static getRegexGroup(routes) {
+    const patterns = Route0.getRegexStringGroup(routes);
+    return new RegExp(`^(${patterns})$`);
+  }
+  /** Converts any location shape to relative form (removes host/origin fields). */
+  static toRelLocation(location) {
+    return {
+      ...location,
+      abs: false,
+      origin: void 0,
+      href: void 0,
+      port: void 0,
+      host: void 0,
+      hostname: void 0
+    };
+  }
+  /** Converts a location to absolute form using provided base URL. */
+  static toAbsLocation(location, baseurl) {
+    const relLoc = Route0.toRelLocation(location);
+    const url = new URL(relLoc.hrefRel, baseurl);
+    return {
+      ...location,
+      abs: true,
+      origin: url.origin,
+      href: url.href,
+      port: url.port,
+      host: url.host,
+      hostname: url.hostname
+    };
+  }
+  static getLocation(hrefOrHrefRelOrLocation) {
+    if (hrefOrHrefRelOrLocation instanceof URL) {
+      return Route0.getLocation(hrefOrHrefRelOrLocation.href);
+    }
+    if (typeof hrefOrHrefRelOrLocation !== "string") {
+      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);
+    const searchParams = Object.fromEntries(url.searchParams.entries());
+    let pathname = url.pathname;
+    if (pathname.length > 1 && pathname.endsWith("/")) {
+      pathname = pathname.slice(0, -1);
+    }
+    const hrefRel = pathname + url.search + url.hash;
+    const location = {
+      pathname,
+      search: url.search,
+      hash: url.hash,
+      origin: abs ? url.origin : void 0,
+      href: abs ? url.href : void 0,
+      hrefRel,
+      abs,
+      // extra host-related fields (available even for relative with dummy base)
+      host: abs ? url.host : void 0,
+      hostname: abs ? url.hostname : void 0,
+      port: abs ? url.port || void 0 : void 0,
+      // specific to UnknownLocation
+      searchParams,
+      params: void 0,
+      route: void 0,
+      known: false,
+      exact: false,
+      ancestor: false,
+      descendant: false,
+      unmatched: false
+    };
+    return location;
+  }
+  getLocation(hrefOrHrefRelOrLocation) {
+    if (hrefOrHrefRelOrLocation instanceof URL) {
+      return this.getLocation(hrefOrHrefRelOrLocation.href);
+    }
+    if (typeof hrefOrHrefRelOrLocation !== "string") {
+      hrefOrHrefRelOrLocation = hrefOrHrefRelOrLocation.href || hrefOrHrefRelOrLocation.hrefRel;
+    }
+    const location = Route0.getLocation(hrefOrHrefRelOrLocation);
+    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 exactRe = new RegExp(`^${this.getRegexBaseString()}$`);
+    const ancestorRe = new RegExp(`^${this.getRegexBaseString()}(?:/.*)?$`);
+    const exactMatch = pathname.match(exactRe);
+    const ancestorMatch = pathname.match(ancestorRe);
+    const exact = !!exactMatch;
+    const ancestor = !exact && !!ancestorMatch;
+    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] ?? "")]));
+      location.params = params;
+    } else {
+      location.params = {};
+    }
+    const getParts = (path) => path === "/" ? ["/"] : path.split("/").filter(Boolean);
+    const defParts = getParts(def);
+    const pathParts = getParts(pathname);
+    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 !== pathPart) {
+          isPrefix = false;
+          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.slice(1)] = decodeURIComponent(pathPart);
+        }
+      }
+      location.params = descendantParams;
+    }
+    return {
+      ...location,
+      known: true,
+      exact,
+      ancestor,
+      descendant,
+      unmatched
+    };
+  }
+  /**
+   * Safe parser for flat input objects.
+   *
+   * Returns structured success/error result instead of throwing.
+   */
+  safeParseFlatInput(input, loose) {
+    loose ??= this.hasLooseSearch;
+    const paramsKeys = this.getParamsKeys();
+    if (input === void 0) {
+      if (paramsKeys.length) {
+        return {
+          success: false,
+          data: void 0,
+          error: new Error(`Missing params: ${paramsKeys.map((k) => `"${k}"`).join(", ")}`)
+        };
+      }
+      input = {};
+    }
+    if (typeof input !== "object" || input === null) {
+      return {
+        success: false,
+        data: void 0,
+        error: new Error("Invalid input: expected object")
+      };
+    }
+    const inputKeys = Object.keys(input);
+    const notDefinedKeys = paramsKeys.filter((k) => !inputKeys.includes(k));
+    if (notDefinedKeys.length) {
+      return {
+        success: false,
+        data: void 0,
+        error: new Error(`Missing params: ${notDefinedKeys.map((k) => `"${k}"`).join(", ")}`)
+      };
+    }
+    const data = {};
+    const filterKeys = !loose ? [...paramsKeys, ...this.getSearchKeys()] : false;
+    for (const [k, v] of Object.entries(input)) {
+      if (filterKeys && !filterKeys.includes(k)) {
+        continue;
+      }
+      if (typeof v === "string") {
+        data[k] = v;
+      } else if (typeof v === "number") {
+        data[k] = String(v);
+      } else {
+        const isParamKey = paramsKeys.includes(k);
+        return {
+          success: false,
+          data: void 0,
+          error: new Error(
+            `Invalid input: expected string, number,${!isParamKey ? " or undefined," : ""} got ${typeof v} for "${k}"`
+          )
+        };
+      }
+    }
+    return {
+      success: true,
+      data,
+      error: void 0
+    };
+  }
+  /** Throwing variant of `safeParseFlatInput()`. */
+  parseFlatInput(input, loose) {
+    loose ??= this.hasLooseSearch;
+    const result = this.safeParseFlatInput(input, loose);
+    if (result.error) {
+      throw result.error;
+    }
+    return result.data;
+  }
+  /** 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__");
+  }
+  /** Static convenience wrapper for `isSame`. */
+  static isSame(a, b) {
+    if (!a) {
+      if (!b) return true;
+      return false;
+    }
+    if (!b) {
+      return false;
+    }
+    return Route0.create(a).isSame(Route0.create(b));
+  }
+  /** True when current route is more specific/deeper than `other`. */
+  isDescendant(other) {
+    if (!other) return false;
+    other = Route0.create(other);
+    const getParts = (path) => path === "/" ? ["/"] : path.split("/").filter(Boolean);
+    if (other.pathDefinition === "/" && this.pathDefinition !== "/") {
+      return true;
+    }
+    const thisParts = getParts(this.pathDefinition);
+    const otherParts = getParts(other.pathDefinition);
+    if (thisParts.length <= otherParts.length) return 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;
+    }
+    return true;
+  }
+  /** True when current route is broader/shallower than `other`. */
+  isAncestor(other) {
+    if (!other) return false;
+    other = Route0.create(other);
+    const getParts = (path) => path === "/" ? ["/"] : path.split("/").filter(Boolean);
+    if (this.pathDefinition === "/" && other.pathDefinition !== "/") {
+      return true;
+    }
+    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(":")) continue;
+      if (thisPart !== otherPart) return false;
+    }
+    return true;
+  }
+  /** True when two route patterns can match the same concrete URL. */
+  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;
+      }
+    }
+    return true;
+  }
+  /** Specificity comparator used for deterministic route ordering. */
+  isMoreSpecificThan(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);
+    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;
+    }
+    return this.pathDefinition < other.pathDefinition;
+  }
+}
+class Routes {
+  _routes;
+  _pathsOrdering;
+  _keysOrdering;
+  _ordered;
+  _;
+  constructor({
+    routes,
+    isHydrated = false,
+    pathsOrdering,
+    keysOrdering,
+    ordered
+  }) {
+    this._routes = isHydrated ? routes : Routes.hydrate(routes);
+    if (!pathsOrdering || !keysOrdering || !ordered) {
+      const ordering = Routes.makeOrdering(this._routes);
+      this._pathsOrdering = ordering.pathsOrdering;
+      this._keysOrdering = ordering.keysOrdering;
+      this._ordered = this._keysOrdering.map((key) => this._routes[key]);
+    } else {
+      this._pathsOrdering = pathsOrdering;
+      this._keysOrdering = keysOrdering;
+      this._ordered = ordered;
+    }
+    this._ = {
+      routes: this._routes,
+      getLocation: this._getLocation.bind(this),
+      override: this._override.bind(this),
+      pathsOrdering: this._pathsOrdering,
+      keysOrdering: this._keysOrdering,
+      ordered: this._ordered
+    };
+  }
+  /** Creates and hydrates a typed routes collection. */
+  static create(routes, override) {
+    const result = Routes.prettify(new Routes({ routes }));
+    if (!override) {
+      return result;
+    }
+    return result._.override(override);
+  }
+  static prettify(instance) {
+    Object.setPrototypeOf(instance, Routes.prototype);
+    Object.defineProperty(instance, Symbol.toStringTag, {
+      value: "Routes"
+    });
+    Object.assign(instance, {
+      override: instance._override.bind(instance)
+    });
+    Object.assign(instance, instance._routes);
+    return instance;
+  }
+  static hydrate(routes) {
+    const result = {};
+    for (const key in routes) {
+      if (Object.hasOwn(routes, key)) {
+        const value = routes[key];
+        result[key] = typeof value === "string" ? Route0.create(value) : value;
+      }
+    }
+    return result;
+  }
+  _getLocation(hrefOrHrefRelOrLocation) {
+    const input = hrefOrHrefRelOrLocation;
+    for (const route of this._ordered) {
+      const loc = route.getLocation(hrefOrHrefRelOrLocation);
+      if (loc.exact) {
+        return loc;
+      }
+    }
+    return typeof input === "string" ? Route0.getLocation(input) : Route0.getLocation(input);
+  }
+  static makeOrdering(routes) {
+    const hydrated = Routes.hydrate(routes);
+    const entries = Object.entries(hydrated);
+    const getParts = (path) => {
+      if (path === "/") return ["/"];
+      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)) {
+        if (routeA.isMoreSpecificThan(routeB)) return -1;
+        if (routeB.isMoreSpecificThan(routeA)) return 1;
+      }
+      return routeA.pathDefinition.localeCompare(routeB.pathDefinition);
+    });
+    const pathsOrdering = entries.map(([_key, route]) => route.definition);
+    const keysOrdering = entries.map(([_key]) => _key);
+    return { pathsOrdering, keysOrdering };
+  }
+  /** Returns a cloned routes collection with config applied to each route. */
+  _override(config) {
+    const newRoutes = {};
+    for (const key in this._routes) {
+      if (Object.hasOwn(this._routes, key)) {
+        newRoutes[key] = this._routes[key].clone(config);
+      }
+    }
+    const instance = new Routes({
+      routes: newRoutes,
+      isHydrated: true,
+      pathsOrdering: this._pathsOrdering,
+      keysOrdering: this._keysOrdering,
+      ordered: this._keysOrdering.map((key) => newRoutes[key])
+    });
+    return Routes.prettify(instance);
   }
+  static _ = {
+    prettify: Routes.prettify.bind(Routes),
+    hydrate: Routes.hydrate.bind(Routes),
+    makeOrdering: Routes.makeOrdering.bind(Routes)
+  };
 }
 export {
-  Route0
+  Route0,
+  Routes
 };
 //# sourceMappingURL=index.js.map