@devp0nt/route0 1.0.0-next.7 → 1.0.0-next.71

package/dist/cjs/index.cjs

@@ -0,0 +1,795 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+__export(index_exports, {
+  Route0: () => Route0,
+  Routes: () => Routes
+});
+module.exports = __toCommonJS(index_exports);
+var import_flat0 = require("@devp0nt/flat0");
+const escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const getPathSegments = (definition) => {
+  if (definition === "" || definition === "/") return [];
+  return definition.split("/").filter(Boolean);
+};
+const getPathTokens = (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 = getPathTokens(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 getPathTokens(definition)) {
+    if (token.kind === "param") keys.push(token.name);
+    if (token.kind === "wildcard") keys.push("*");
+  }
+  return keys;
+};
+const getPathParamsDefinition = (definition) => {
+  const entries = getPathTokens(definition).filter((t) => t.kind !== "static").map((t) => t.kind === "param" ? [t.name, !t.optional] : ["*", !t.optional]);
+  return Object.fromEntries(entries);
+};
+const validatePathDefinition = (definition) => {
+  const segments = getPathSegments(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(/\*\??$/, "");
+class Route0 {
+  definition;
+  params;
+  _origin;
+  _callable;
+  Infer = null;
+  /** Base URL used when generating absolute URLs (`abs: true`). */
+  get origin() {
+    if (!this._origin) {
+      throw new Error(
+        "origin for route " + this.definition + ' is not set, please provide it like Route0.create(route, {origin: "https://example.com"}) in config or set via clones like routes._.clone({origin: "https://example.com"})'
+      );
+    }
+    return this._origin;
+  }
+  set origin(origin) {
+    this._origin = origin;
+  }
+  constructor(definition, config = {}) {
+    validatePathDefinition(definition);
+    this.definition = definition;
+    this.params = Route0._getParamsDefinitionByDefinition(definition);
+    const { origin } = config;
+    if (origin && typeof origin === "string" && origin.length) {
+      this._origin = origin;
+    } else {
+      const g = globalThis;
+      if (typeof g?.location?.origin === "string" && g.location.origin.length > 0) {
+        this._origin = g.location.origin;
+      } else {
+        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.
+   *
+   * If an existing route/callable route is provided, it is cloned.
+   */
+  static create(definition, config) {
+    if (typeof definition === "function" || typeof definition === "object") {
+      return definition.clone(config);
+    }
+    const original = new Route0(definition, config);
+    return original._callable;
+  }
+  /**
+   * 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);
+    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, "/");
+    return Route0.create(
+      definition,
+      { origin: this._origin }
+    );
+  }
+  // implementation
+  get(...args) {
+    const { searchInput, paramsInput, absInput, absOriginInput, hashInput } = (() => {
+      if (args.length === 0) {
+        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 absOriginInput2 = typeof abs === "string" && abs.length > 0 ? abs : void 0;
+      return {
+        searchInput: searchInput2,
+        paramsInput: paramsInput2,
+        absInput: absOriginInput2 !== void 0 || abs === true,
+        absOriginInput: absOriginInput2,
+        hashInput: hashInput2
+      };
+    })();
+    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 searchString = (0, import_flat0.stringify)(searchInput);
+    url = [url, searchString].filter(Boolean).join("?");
+    url = url.replace(/\/{2,}/g, "/");
+    url = absInput ? Route0._getAbsPath(absOriginInput || this.origin, url) : url;
+    if (hashInput !== void 0) {
+      url = `${url}#${hashInput}`;
+    }
+    return url;
+  }
+  /** Returns path param keys extracted from route definition. */
+  getParamsKeys() {
+    return Object.keys(this.params);
+  }
+  getPathTokens() {
+    return getPathTokens(this.definition);
+  }
+  /** Clones route with optional config override. */
+  clone(config) {
+    return Route0.create(this.definition, config);
+  }
+  getRegexBaseStrictString() {
+    return getPathRegexBaseStrictString(this.definition);
+  }
+  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 origin URL. */
+  static toAbsLocation(location, origin) {
+    const relLoc = Route0.toRelLocation(location);
+    const url = new URL(relLoc.hrefRel, origin);
+    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 search = (0, import_flat0.parse)(url.search);
+    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,
+      searchString: 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
+      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 = 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);
+    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) => {
+          const value = values[i];
+          return [n, value === void 0 ? void 0 : decodeURIComponent(value)];
+        })
+      );
+      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.includes("*")) {
+          const prefix = defPart.replace(/\*\??$/, "");
+          if (pathPart.startsWith(prefix)) continue;
+          isPrefix = false;
+          break;
+        }
+        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.replace(/^:/, "").replace(/\?$/, "")] = decodeURIComponent(pathPart);
+        } else if (defPart.includes("*")) {
+          descendantParams["*"] = decodeURIComponent(pathPart);
+        }
+      }
+      location.params = descendantParams;
+    }
+    return {
+      ...location,
+      known: true,
+      exact,
+      ancestor,
+      descendant,
+      unmatched
+    };
+  }
+  _validateParamsInput(input) {
+    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 (requiredParamsKeys.length) {
+        return {
+          issues: [
+            {
+              message: `Missing params: ${requiredParamsKeys.map((k) => `"${k}"`).join(", ")}`
+            }
+          ]
+        };
+      }
+      input = {};
+    }
+    if (typeof input !== "object" || input === null) {
+      return {
+        issues: [{ message: "Invalid route params: expected object" }]
+      };
+    }
+    const inputObj = input;
+    const inputKeys = Object.keys(inputObj);
+    const notDefinedKeys = requiredParamsKeys.filter((k) => !inputKeys.includes(k));
+    if (notDefinedKeys.length) {
+      return {
+        issues: [
+          {
+            message: `Missing params: ${notDefinedKeys.map((k) => `"${k}"`).join(", ")}`
+          }
+        ]
+      };
+    }
+    const data = {};
+    for (const k of paramsKeys) {
+      const v = inputObj[k];
+      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 route params: expected string, number, got ${typeof v} for "${k}"` }]
+        };
+      }
+    }
+    return {
+      value: data
+    };
+  }
+  _safeParseSchemaResult(result) {
+    if ("issues" in result) {
+      return {
+        success: false,
+        data: void 0,
+        error: new Error(result.issues?.[0]?.message ?? "Invalid input")
+      };
+    }
+    return {
+      success: true,
+      data: result.value,
+      error: void 0
+    };
+  }
+  _parseSchemaResult(result) {
+    const safeResult = this._safeParseSchemaResult(result);
+    if (safeResult.error) {
+      throw safeResult.error;
+    }
+    return safeResult.data;
+  }
+  /** Standard Schema for route params input. */
+  schema = {
+    "~standard": {
+      version: 1,
+      vendor: "route0",
+      validate: (value) => this._validateParamsInput(value),
+      types: void 0
+    },
+    parse: (value) => this._parseSchemaResult(this._validateParamsInput(value)),
+    safeParse: (value) => this._safeParseSchemaResult(this._validateParamsInput(value))
+  };
+  /** True when path structure is equal (param names are ignored). */
+  isSame(other) {
+    return getPathTokens(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("/") === getPathTokens(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) {
+    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.definition === "/" && this.definition !== "/") {
+      return true;
+    }
+    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];
+      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.definition === "/" && other.definition !== "/") {
+      return true;
+    }
+    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];
+      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 thisRegex = this.getRegex();
+    const otherRegex = other.getRegex();
+    const makeCandidates = (definition) => {
+      const tokens = getPathTokens(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);
+    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) {
+    if (!other) return false;
+    other = Route0.create(other);
+    const getParts = (path) => {
+      if (path === "/") return ["/"];
+      return path.split("/").filter(Boolean);
+    };
+    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 thisRank = rank(thisParts[i]);
+      const otherRank = rank(otherParts[i]);
+      if (thisRank > otherRank) return true;
+      if (thisRank < otherRank) return false;
+    }
+    return this.definition < other.definition;
+  }
+}
+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),
+      clone: this._clone.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._.clone(override);
+  }
+  static prettify(instance) {
+    Object.setPrototypeOf(instance, Routes.prototype);
+    Object.defineProperty(instance, Symbol.toStringTag, {
+      value: "Routes"
+    });
+    Object.assign(instance, {
+      clone: instance._clone.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.definition);
+      const partsB = getParts(routeB.definition);
+      if (routeA.isMayBeSame(routeB)) {
+        if (routeA.isMoreSpecificThan(routeB)) return -1;
+        if (routeB.isMoreSpecificThan(routeA)) return 1;
+      }
+      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);
+    return { pathsOrdering, keysOrdering };
+  }
+  /** Returns a cloned routes collection with config applied to each route. */
+  _clone(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)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Route0,
+  Routes
+});
+//# sourceMappingURL=index.cjs.map