@devp0nt/route0 1.0.0-next.9 → 1.0.0

package/dist/esm/index.js

@@ -1,134 +1,937 @@
+import { parse as parseSearchQuery, stringify as stringifySearchQuery } from "@devp0nt/flat0";
+const escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const collapseDuplicateSlashes = (value) => value.replace(/\/{2,}/g, "/");
 class Route0 {
-  pathOriginalDefinition;
-  pathDefinition;
-  paramsDefinition;
-  queryDefinition;
-  baseUrl;
+  definition;
+  params;
+  _origin;
+  _callable;
+  _routeSegments;
+  _routeTokens;
+  _routePatternCandidates;
+  _pathParamsDefinition;
+  _definitionWithoutTrailingWildcard;
+  _routeRegexBaseStringRaw;
+  _regexBaseString;
+  _regexString;
+  _regex;
+  _regexAncestor;
+  _regexDescendantMatchers;
+  _captureKeys;
+  _normalizedDefinition;
+  _definitionParts;
+  static normalizeSlash = (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;
+  };
+  static _getRouteSegments(definition) {
+    if (definition === "" || definition === "/") return [];
+    return definition.split("/").filter(Boolean);
+  }
+  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() {
+    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 = {}) {
-    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;
+    const normalizedDefinition = Route0.normalizeSlash(definition);
+    Route0._validateRouteDefinition(normalizedDefinition);
+    this.definition = normalizedDefinition;
+    this.params = this.pathParamsDefinition;
+    const { origin } = config;
+    if (origin && typeof origin === "string" && origin.length) {
+      this._origin = origin;
     } 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._origin = g.location.origin;
       } else {
-        this.baseUrl = "https://example.com";
+        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,
+      Route0.normalizeSlash(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 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(
+      Route0.normalizeSlash(definition)
+    );
+    return original._callable;
+  }
+  static _getAbsPath(origin, url) {
+    return new URL(url, origin).toString().replace(/\/$/, "");
+  }
+  search() {
+    return this._callable;
+  }
+  /** Extends the current route definition by appending a suffix route. */
+  extend(suffixDefinition) {
+    const definition = Route0.normalizeSlash(`${this.definitionWithoutTrailingWildcard}/${suffixDefinition}`);
+    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]];
         }
-        return value;
-      },
-      set(_target, prop, value, receiver) {
-        ;
-        original[prop] = value;
+        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 = stringifySearchQuery(searchInput, { arrayIndexes: false });
+    url = [url, searchString].filter(Boolean).join("?");
+    url = collapseDuplicateSlashes(url);
+    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);
+  }
+  getTokens() {
+    return this.routeTokens.map((token) => ({ ...token }));
+  }
+  /** Clones route with optional config override. */
+  clone(config) {
+    return Route0.create(this.definition, config);
+  }
+  get regexBaseString() {
+    if (this._regexBaseString === void 0) {
+      if (this.definition === "/") {
+        this._regexBaseString = "/";
+      } else {
+        this._regexBaseString = this.routeRegexBaseStringRaw.replace(/\/+$/, "") + "/?";
+      }
+    }
+    return this._regexBaseString;
+  }
+  get regexString() {
+    if (this._regexString === void 0) {
+      this._regexString = `^${this.regexBaseString}$`;
+    }
+    return this._regexString;
+  }
+  get regex() {
+    if (this._regex === void 0) {
+      this._regex = new RegExp(this.regexString);
+    }
+    return this._regex;
+  }
+  get regexAncestor() {
+    if (this._regexAncestor === void 0) {
+      if (this.definition === "/") {
+        this._regexAncestor = /^\/.+$/;
+      } else {
+        this._regexAncestor = new RegExp(`^${this.regexBaseString}(?:/.*)?$`);
+      }
+    }
+    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 = 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;
+    }
+    return this._normalizedDefinition;
+  }
+  get definitionParts() {
+    if (this._definitionParts === void 0) {
+      this._definitionParts = this.normalizedDefinition === "/" ? ["/"] : this.normalizedDefinition.split("/").filter(Boolean);
+    }
+    return this._definitionParts;
+  }
+  /** Fast pathname exact match check without building a full relation object. */
+  isExact(pathname, normalize = true) {
+    const normalizedPathname = normalize ? Route0.normalizeSlash(pathname) : pathname;
+    return this.regex.test(normalizedPathname);
+  }
+  /** Fast pathname exact or ancestor match check without building a full relation object. */
+  isExactOrAncestor(pathname, normalize = true) {
+    const normalizedPathname = normalize ? Route0.normalizeSlash(pathname) : pathname;
+    return this.regex.test(normalizedPathname) || this.regexAncestor.test(normalizedPathname);
+  }
+  /** True when route is ancestor of pathname (pathname is deeper). */
+  isAncestor(pathname, normalize = true) {
+    const normalizedPathname = normalize ? Route0.normalizeSlash(pathname) : pathname;
+    return !this.regex.test(normalizedPathname) && this.regexAncestor.test(normalizedPathname);
+  }
+  /** True when route is descendant of pathname (pathname is shallower). */
+  isDescendant(pathname, normalize = true) {
+    const normalizedPathname = normalize ? Route0.normalizeSlash(pathname) : pathname;
+    if (this.regex.test(normalizedPathname) || this.regexAncestor.test(normalizedPathname)) {
+      return false;
+    }
+    for (const matcher of this.regexDescendantMatchers) {
+      if (normalizedPathname.match(matcher.regex)) {
         return true;
+      }
+    }
+    return false;
+  }
+  /** Creates a grouped regex pattern string from many routes. */
+  static getRegexStringGroup(routes) {
+    const patterns = routes.map((route) => `(?:${route.regexBaseString})`).join("|");
+    return `^(?:${patterns})$`;
+  }
+  /** Creates a grouped regex from many routes. */
+  static getRegexGroup(routes) {
+    return new RegExp(Route0.getRegexStringGroup(routes));
+  }
+  /** 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 hrefRel = url.pathname + url.search + url.hash;
+    let _search;
+    const location = {
+      pathname: url.pathname,
+      get search() {
+        if (_search === void 0) {
+          _search = parseSearchQuery(url.search);
+        }
+        return _search;
       },
-      has(_target, prop) {
-        return prop in original;
+      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
+    };
+    return location;
+  }
+  getRelation(hrefOrHrefRelOrLocation) {
+    if (hrefOrHrefRelOrLocation instanceof URL) {
+      return this.getRelation(hrefOrHrefRelOrLocation.href);
+    }
+    if (typeof hrefOrHrefRelOrLocation !== "string") {
+      hrefOrHrefRelOrLocation = hrefOrHrefRelOrLocation.href || hrefOrHrefRelOrLocation.hrefRel;
+    }
+    const pathname = Route0.normalizeSlash(new URL(hrefOrHrefRelOrLocation, "http://example.com").pathname);
+    const paramNames = this.captureKeys;
+    const exactRe = this.regex;
+    const exactMatch = pathname.match(exactRe);
+    if (exactMatch) {
+      const values = exactMatch.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)];
+        })
+      );
+      return {
+        type: "exact",
+        route: this.definition,
+        params,
+        exact: true,
+        ancestor: false,
+        descendant: false,
+        unmatched: false
+      };
+    }
+    const ancestorRe = this.regexAncestor;
+    const ancestorMatch = pathname.match(ancestorRe);
+    if (ancestorMatch) {
+      const values = ancestorMatch.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)];
+        })
+      );
+      return {
+        type: "ancestor",
+        route: this.definition,
+        params,
+        exact: false,
+        ancestor: true,
+        descendant: false,
+        unmatched: false
+      };
+    }
+    let descendantMatch = null;
+    let descendantCaptureKeys = [];
+    for (const matcher of this.regexDescendantMatchers) {
+      const match = pathname.match(matcher.regex);
+      if (!match) continue;
+      descendantMatch = match;
+      descendantCaptureKeys = matcher.captureKeys;
+      break;
+    }
+    if (descendantMatch) {
+      const values = descendantMatch.slice(1, 1 + descendantCaptureKeys.length);
+      const params = Object.fromEntries(
+        descendantCaptureKeys.map((key, index) => [key, decodeURIComponent(values[index])])
+      );
+      return {
+        type: "descendant",
+        route: this.definition,
+        params,
+        exact: false,
+        ancestor: false,
+        descendant: true,
+        unmatched: false
+      };
+    }
+    return {
+      type: "unmatched",
+      route: this.definition,
+      params: {},
+      exact: false,
+      ancestor: false,
+      descendant: false,
+      unmatched: true
+    };
+  }
+  _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(", ")}`
+            }
+          ]
+        };
       }
-    });
-    Object.setPrototypeOf(proxy, Route0.prototype);
-    return proxy;
+      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
+    };
   }
-  static _splitPathDefinitionAndQueryTailDefinition(pathOriginalDefinition) {
-    const i = pathOriginalDefinition.indexOf("&");
-    if (i === -1) return { pathDefinition: pathOriginalDefinition, queryTailDefinition: "" };
+  _safeParseSchemaResult(result) {
+    if ("issues" in result) {
+      return {
+        success: false,
+        data: void 0,
+        error: new Error(result.issues?.[0]?.message ?? "Invalid input")
+      };
+    }
     return {
-      pathDefinition: pathOriginalDefinition.slice(0, i),
-      queryTailDefinition: pathOriginalDefinition.slice(i)
+      success: true,
+      data: result.value,
+      error: void 0
     };
   }
-  static _getAbsPath(baseUrl, pathWithQuery) {
-    return new URL(pathWithQuery, baseUrl).toString().replace(/\/$/, "");
+  _parseSchemaResult(result) {
+    const safeResult = this._safeParseSchemaResult(result);
+    if (safeResult.error) {
+      throw safeResult.error;
+    }
+    return safeResult.data;
   }
-  static _getPathDefinitionByOriginalDefinition(pathOriginalDefinition) {
-    const { pathDefinition } = Route0._splitPathDefinitionAndQueryTailDefinition(pathOriginalDefinition);
-    return pathDefinition;
+  /** 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: AnyRoute): boolean {
+  //   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('/')
+  //   const otherRoute = Route0.from(other) as Route0<string, UnknownSearchInput>
+  //   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: AnyRoute | string | undefined, b: AnyRoute | string | undefined): boolean {
+  //   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: AnyRoute | string | undefined): boolean {
+  //   if (!other) return false
+  //   other = Route0.create(other)
+  //   // this is a descendant of other if:
+  //   // - paths are not exactly the same
+  //   // - other's path is a prefix of this path, matching params as wildcards
+  //   const getParts = (path: string) => (path === '/' ? ['/'] : path.split('/').filter(Boolean))
+  //   // Root is ancestor of any non-root; thus any non-root is a descendant of root
+  //   if (other.definition === '/' && this.definition !== '/') {
+  //     return true
+  //   }
+  //   const thisParts = getParts(this.definition)
+  //   const otherParts = getParts(other.definition)
+  //   // A descendant must be deeper
+  //   if (thisParts.length <= otherParts.length) return false
+  //   const matchesPatternPart = (patternPart: string, valuePart: string): { match: boolean; wildcard: boolean } => {
+  //     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]
+  //     const result = matchesPatternPart(otherPart, thisPart)
+  //     if (!result.match) return false
+  //     if (result.wildcard) return true
+  //   }
+  //   // Not equal (depth already ensures not equal)
+  //   return true
+  // }
+  // /** True when current route is broader/shallower than `other`. */
+  // isAncestor(other: AnyRoute | string | undefined): boolean {
+  //   if (!other) return false
+  //   other = Route0.create(other)
+  //   // this is an ancestor of other if:
+  //   // - paths are not exactly the same
+  //   // - this path is a prefix of other path, matching params as wildcards
+  //   const getParts = (path: string) => (path === '/' ? ['/'] : path.split('/').filter(Boolean))
+  //   // Root is ancestor of any non-root path
+  //   if (this.definition === '/' && other.definition !== '/') {
+  //     return true
+  //   }
+  //   const thisParts = getParts(this.definition)
+  //   const otherParts = getParts(other.definition)
+  //   // An ancestor must be shallower
+  //   if (thisParts.length >= otherParts.length) return false
+  //   const matchesPatternPart = (patternPart: string, valuePart: string): { match: boolean; wildcard: boolean } => {
+  //     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]
+  //     const result = matchesPatternPart(thisPart, otherPart)
+  //     if (!result.match) return false
+  //     if (result.wildcard) return true
+  //   }
+  //   // Not equal (depth already ensures not equal)
+  //   return true
+  // }
+  /** True when two route patterns can match the same concrete URL. */
+  isOverlap(other) {
+    if (!other) return false;
+    const otherRoute = Route0.from(other);
+    const thisRegex = this.regex;
+    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;
   }
-  static _getParamsDefinitionByRouteDefinition(pathOriginalDefinition) {
-    const { pathDefinition } = Route0._splitPathDefinitionAndQueryTailDefinition(pathOriginalDefinition);
-    const matches = Array.from(pathDefinition.matchAll(/:([A-Za-z0-9_]+)/g));
-    const paramsDefinition = Object.fromEntries(matches.map((m) => [m[1], true]));
-    return paramsDefinition;
+  /**
+   * 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;
+    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;
   }
-  static _getQueryDefinitionByRouteDefinition(pathOriginalDefinition) {
-    const { queryTailDefinition } = Route0._splitPathDefinitionAndQueryTailDefinition(pathOriginalDefinition);
-    if (!queryTailDefinition) {
-      return {};
+  /** 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;
     }
-    const keys = queryTailDefinition.split("&").map(Boolean);
-    const queryDefinition = Object.fromEntries(keys.map((k) => [k, true]));
-    return queryDefinition;
+    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 overrideMany(routes, config) {
+  static hydrate(routes) {
     const result = {};
-    for (const [key, value] of Object.entries(routes)) {
-      ;
-      result[key] = value.clone(config);
+    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;
   }
-  extend(suffixDefinition) {
-    const { pathDefinition: parentPathDefinition } = Route0._splitPathDefinitionAndQueryTailDefinition(
-      this.pathOriginalDefinition
-    );
-    const { pathDefinition: suffixPathDefinition, queryTailDefinition: suffixQueryTailDefinition } = Route0._splitPathDefinitionAndQueryTailDefinition(suffixDefinition);
-    const pathDefinition = `${parentPathDefinition}/${suffixPathDefinition}`.replace(/\/{2,}/g, "/");
-    const pathOriginalDefinition = `${pathDefinition}${suffixQueryTailDefinition}`;
-    return Route0.create(pathOriginalDefinition, { baseUrl: this.baseUrl });
+  _getLocation(hrefOrHrefRelOrLocation) {
+    const input = hrefOrHrefRelOrLocation;
+    const location = Route0.getLocation(input);
+    for (const route of this._ordered) {
+      if (route.isExact(location.pathname, false)) {
+        const relation = route.getRelation(input);
+        return Object.assign(location, {
+          route: route.definition,
+          params: relation.params
+        });
+      }
+    }
+    return location;
   }
-  // implementation
-  get(...args) {
-    const { queryInput, paramsInput, absInput } = (() => {
-      if (args.length === 0) {
-        return { queryInput: {}, paramsInput: {}, absInput: false };
+  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.isOverlap(routeB)) {
+        if (routeA.isMoreSpecificThan(routeB)) return -1;
+        if (routeB.isMoreSpecificThan(routeA)) return 1;
       }
-      const input = args[0];
-      if (typeof input !== "object" || input === null) {
-        return { queryInput: {}, paramsInput: {}, absInput: false };
+      if (partsA.length !== partsB.length) {
+        return partsA.length - partsB.length;
       }
-      const { query, abs, ...params } = input;
-      return { queryInput: query || {}, paramsInput: params, absInput: abs ?? false };
-    })();
-    const neededParamsKeys = 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);
-    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("?");
-    url = url.replace(/\/{2,}/g, "/");
-    url = absInput ? Route0._getAbsPath(this.baseUrl, url) : url;
-    return url;
-  }
-  getDefinition() {
-    return this.pathDefinition;
+      return routeA.definition.localeCompare(routeB.definition);
+    });
+    const pathsOrdering = entries.map(([_key, route]) => route.definition);
+    const keysOrdering = entries.map(([_key]) => _key);
+    return { pathsOrdering, keysOrdering };
   }
-  clone(config) {
-    return new Route0(this.pathOriginalDefinition, config);
+  /** 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)
+  };
 }
 export {
-  Route0
+  Route0,
+  Routes
 };
 //# sourceMappingURL=index.js.map