@boringnode/route-matcher 0.1.1

package/LICENSE.md

@@ -0,0 +1,9 @@
+# The MIT License
+
+Copyright 2026 Romain Lanz, contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,73 @@
+# @boringnode/route-matcher
+
+A small, zero-dependency route parser and indexed route table for Node.js.
+
+```sh
+yarn add @boringnode/route-matcher
+```
+
+## Parse a route
+
+```ts
+import { parseRoute } from '@boringnode/route-matcher'
+
+const tokens = parseRoute('/users/:id.json', {
+  id: { match: /^\d+$/, cast: Number },
+})
+```
+
+Patterns support static segments, required parameters (`:id`), optional parameters (`:id?`),
+parameter suffixes (`:id.json`), and trailing wildcards (`*`). A matcher may constrain a parameter
+with `match` and transform its extracted value with `cast`.
+
+## Match routes
+
+```ts
+import { parseRoute, RouteTable } from '@boringnode/route-matcher'
+
+type Route = { name: string }
+
+const routes = new RouteTable<Route>()
+
+routes.add(parseRoute('/:slug'), { name: 'page' })
+routes.add(parseRoute('/about'), { name: 'about' })
+
+routes.match('/about')
+// { value: { name: 'page' }, params: { slug: 'about' } }
+```
+
+By default, the first registered matching route wins. Route shape does not change precedence: an
+earlier parameter or wildcard route can win over a later static route. The table uses static lookup
+and a private segment index to discard impossible candidates while preserving registration order.
+
+### Specificity precedence
+
+Applications that need the most specific match can opt in when creating the table:
+
+```ts
+const routes = new RouteTable<Route>({ precedence: 'specificity' })
+```
+
+Specificity is compared segment by segment from left to right. Static segments rank above required
+parameters, followed by optional parameters and wildcards. When common segments have equal
+specificity, the longer pattern wins. Equally specific patterns retain registration order.
+
+`match(pathname, true)` decodes parameters with `decodeURIComponent`. Decoding is off by default.
+Invalid percent-encoded values are kept unchanged, and `cast` functions run after decoding.
+Wildcards are returned under `'*'` as an array of path segments. This package matches path strings
+as provided; it does not remove query strings.
+
+For a short-lived list that does not need an index, use `matchRouteTokens`:
+
+```ts
+import { matchRouteTokens, parseRoute } from '@boringnode/route-matcher'
+
+const params = matchRouteTokens('/posts/42', [parseRoute('/posts/:id')])
+// { id: '42' }
+```
+
+`extractRouteParams` is also exported for consumers that keep their own route index.
+
+## License
+
+[MIT](./LICENSE.md)

package/build/index.d.ts

@@ -0,0 +1,42 @@
+type RouteTokenType = 0 | 1 | 2 | 3;
+type RouteMatcher = {
+    match?: RegExp;
+    cast?: (value: string) => any;
+};
+type RouteMatchers = Record<string, RouteMatcher>;
+type RouteToken = {
+    old: string;
+    type: RouteTokenType;
+    val: string;
+    end: string;
+    matcher?: RegExp;
+    cast?: (value: string) => any;
+};
+type RouteParams = Record<string, any>;
+type RouteMatch<T> = {
+    params: RouteParams;
+    value: T;
+};
+type RoutePrecedence = 'registration' | 'specificity';
+type RouteTableOptions = {
+    precedence?: RoutePrecedence;
+};
+
+/**
+ * Parses a route pattern into tokens. A single leading and trailing separator
+ * is stripped for compatibility with established route pattern semantics.
+ */
+declare function parseRoute(pattern: string, matchers?: RouteMatchers): RouteToken[];
+
+declare function extractRouteParams(tokens: RouteToken[], pathname: string, shouldDecodeParams?: boolean): RouteParams;
+/** Matches a transient list of tokenized routes without building an index. */
+declare function matchRouteTokens(pathname: string, routes: RouteToken[][], shouldDecodeParams?: boolean): RouteParams | null;
+/** An indexed route matcher with configurable precedence. */
+declare class RouteTable<T> {
+    #private;
+    constructor(options?: RouteTableOptions);
+    add(tokens: RouteToken[], value: T): this;
+    match(pathname: string, shouldDecodeParams?: boolean): RouteMatch<T> | null;
+}
+
+export { type RouteMatch, type RouteMatcher, type RouteMatchers, type RouteParams, type RoutePrecedence, RouteTable, type RouteTableOptions, type RouteToken, type RouteTokenType, extractRouteParams, matchRouteTokens, parseRoute };

package/build/index.js

@@ -0,0 +1,445 @@
+// src/route_parser.ts
+function stripRouteSeparators(value) {
+  if (value === "/") {
+    return value;
+  }
+  if (value.charCodeAt(0) === 47) {
+    value = value.substring(1);
+  }
+  const lastIndex = value.length - 1;
+  return value.charCodeAt(lastIndex) === 47 ? value.substring(0, lastIndex) : value;
+}
+function parseRoute(pattern, matchers = {}) {
+  if (pattern === "/") {
+    return [{ old: pattern, type: 0, val: pattern, end: "" }];
+  }
+  if (typeof matchers !== "object") {
+    matchers = {};
+  }
+  let remaining = stripRouteSeparators(pattern);
+  let index = -1;
+  let parameterNameEnd = 0;
+  let segmentStart = 0;
+  let remainingLength = remaining.length;
+  const tokens = [];
+  while (++index < remainingLength) {
+    let character = remaining.charCodeAt(index);
+    if (character === 58) {
+      segmentStart = index + 1;
+      let type = 1;
+      parameterNameEnd = 0;
+      let suffix = "";
+      while (index < remainingLength && remaining.charCodeAt(index) !== 47) {
+        character = remaining.charCodeAt(index);
+        if (character === 63) {
+          parameterNameEnd = index;
+          type = 3;
+        } else if (character === 46 && suffix.length === 0) {
+          parameterNameEnd = index;
+          suffix = remaining.substring(index);
+        }
+        index++;
+      }
+      const value2 = remaining.substring(segmentStart, parameterNameEnd || index);
+      const matcher = matchers[value2];
+      tokens.push({
+        old: pattern,
+        type,
+        val: value2,
+        end: suffix,
+        matcher: matcher?.match,
+        cast: matcher?.cast
+      });
+      remaining = remaining.substring(index);
+      remainingLength -= index;
+      index = 0;
+      continue;
+    }
+    if (character === 42) {
+      tokens.push({
+        old: pattern,
+        type: 2,
+        val: remaining.substring(index),
+        end: ""
+      });
+      continue;
+    }
+    segmentStart = index;
+    while (index < remainingLength && remaining.charCodeAt(index) !== 47) {
+      index++;
+    }
+    const value = remaining.substring(segmentStart, index);
+    tokens.push({ old: pattern, type: 0, val: value, end: "" });
+    remaining = remaining.substring(index);
+    remainingLength -= index;
+    index = segmentStart = 0;
+  }
+  return tokens;
+}
+
+// src/route_table.ts
+function createNode() {
+  return { minimumOrder: Number.POSITIVE_INFINITY };
+}
+function splitRoutePath(pathname) {
+  pathname = stripRouteSeparators(pathname);
+  return pathname === "/" ? ["/"] : pathname.split("/");
+}
+function getStaticRouteKey(tokens) {
+  if (!tokens.length || tokens.some((token) => token.type !== 0)) {
+    return null;
+  }
+  return tokens.length === 1 && tokens[0].val === "/" ? "root" : `segments:${tokens.map((token) => token.val).join("/")}`;
+}
+function getStaticRequestKey(normalizedPathname) {
+  return normalizedPathname === "/" ? "root" : `segments:${normalizedPathname}`;
+}
+function getOrCreateChild(children, key) {
+  let child = children.get(key);
+  if (!child) {
+    child = createNode();
+    children.set(key, child);
+  }
+  return child;
+}
+function getTokenSpecificity(type) {
+  if (type === 0) return 3;
+  if (type === 1) return 2;
+  if (type === 3) return 1;
+  return 0;
+}
+function compareRouteSpecificity(a, b) {
+  const length = Math.max(a.length, b.length);
+  for (let index = 0; index < length; index++) {
+    const aSpecificity = a[index] ? getTokenSpecificity(a[index].type) : -1;
+    const bSpecificity = b[index] ? getTokenSpecificity(b[index].type) : -1;
+    if (aSpecificity !== bSpecificity) {
+      return bSpecificity - aSpecificity;
+    }
+  }
+  return 0;
+}
+function matchesSegment(token, segment) {
+  if (token.type === 0) {
+    return token.val === segment;
+  }
+  if (segment === "/") {
+    return token.type > 1;
+  }
+  if (segment === "") {
+    return token.end === "" && (token.matcher ? token.matcher.test(segment) : true);
+  }
+  if (!segment) {
+    return token.end === "";
+  }
+  return segment.endsWith(token.end) && (token.matcher ? token.matcher.test(segment) : true);
+}
+function matchesRoute(tokens, segments) {
+  if (!tokens.length) {
+    return segments.length === 1 && segments[0] === "/";
+  }
+  if (tokens.length !== segments.length && !(tokens.length < segments.length && tokens[tokens.length - 1].type === 2) && !(tokens.length > segments.length && tokens[tokens.length - 1].type === 3)) {
+    return false;
+  }
+  let index = 0;
+  while (index < tokens.length) {
+    if (!matchesSegment(tokens[index], segments[index])) {
+      return false;
+    }
+    index++;
+  }
+  return true;
+}
+function matchesIndexedRoute(route, segments) {
+  if (!route.isStructurallyMatched) {
+    return matchesRoute(route.tokens, segments);
+  }
+  const matcher = route.matcher;
+  if (matcher) {
+    const segment = segments[route.matcherSegmentIndex];
+    if (segment !== void 0 && segment !== "/" && !matcher.test(segment)) {
+      return false;
+    }
+  }
+  for (const { index, matcher: additionalMatcher } of route.additionalMatcherChecks ?? []) {
+    const segment = segments[index];
+    if (segment !== void 0 && segment !== "/" && !additionalMatcher.test(segment)) {
+      return false;
+    }
+  }
+  return true;
+}
+function extractRouteParamsFromSegments(tokens, segments, shouldDecodeParams) {
+  const params = {};
+  let index = 0;
+  while (index < tokens.length) {
+    const token = tokens[index];
+    const segment = segments[index];
+    if (segment === "/") {
+      index++;
+      continue;
+    }
+    if (token.val === "*") {
+      params[token.val] = segments.slice(index).map((value2) => {
+        if (!shouldDecodeParams) {
+          return value2;
+        }
+        try {
+          return decodeURIComponent(value2);
+        } catch {
+          return value2;
+        }
+      });
+      break;
+    }
+    if (segment === void 0 || token.type === 0) {
+      index++;
+      continue;
+    }
+    let value = segment.replace(token.end, "");
+    if (shouldDecodeParams) {
+      try {
+        value = decodeURIComponent(value);
+      } catch {
+      }
+    }
+    params[token.val] = token.cast ? token.cast(value) : value;
+    index++;
+  }
+  return params;
+}
+function extractRouteParams(tokens, pathname, shouldDecodeParams = false) {
+  return extractRouteParamsFromSegments(tokens, splitRoutePath(pathname), shouldDecodeParams);
+}
+function matchRouteTokens(pathname, routes, shouldDecodeParams = false) {
+  const segments = splitRoutePath(pathname);
+  for (const tokens of routes) {
+    if (matchesRoute(tokens, segments)) {
+      return extractRouteParamsFromSegments(tokens, segments, shouldDecodeParams);
+    }
+  }
+  return null;
+}
+var RouteTable = class {
+  #nextOrder = 0;
+  #precedence;
+  #root = createNode();
+  #staticRoutes = /* @__PURE__ */ new Map();
+  #unindexedRoutes = [];
+  constructor(options = {}) {
+    this.#precedence = options.precedence ?? "registration";
+  }
+  add(tokens, value) {
+    const indexedRoute = { order: this.#nextOrder++, tokens, value };
+    const staticKey = getStaticRouteKey(tokens);
+    if (staticKey !== null) {
+      if (!this.#staticRoutes.has(staticKey)) {
+        this.#staticRoutes.set(staticKey, indexedRoute);
+      }
+      return this;
+    }
+    const hasStatefulMatcher = tokens.some((token, index) => {
+      const matcher = token.matcher;
+      const isStateful = matcher && (matcher.global || matcher.sticky || matcher.exec !== RegExp.prototype.exec || matcher.test !== RegExp.prototype.test);
+      if (isStateful) {
+        return true;
+      }
+      if (matcher) {
+        if (!indexedRoute.matcher) {
+          indexedRoute.matcher = matcher;
+          indexedRoute.matcherSegmentIndex = index;
+        } else {
+          indexedRoute.additionalMatcherChecks ||= [];
+          indexedRoute.additionalMatcherChecks.push({ index, matcher });
+        }
+      }
+      return false;
+    });
+    if (!tokens.length || hasStatefulMatcher) {
+      this.#insertCandidate(this.#unindexedRoutes, indexedRoute);
+      return this;
+    }
+    let node = this.#root;
+    node.minimumOrder = Math.min(node.minimumOrder, indexedRoute.order);
+    for (const token of tokens) {
+      if (token.type === 0) {
+        node.literals ||= /* @__PURE__ */ new Map();
+        node = getOrCreateChild(node.literals, token.val);
+      } else if (token.type === 1) {
+        node.parameters ||= /* @__PURE__ */ new Map();
+        node = getOrCreateChild(node.parameters, token.end);
+      } else if (token.type === 3) {
+        node.optionals ||= /* @__PURE__ */ new Map();
+        node = getOrCreateChild(node.optionals, token.end);
+      } else {
+        node.wildcards ||= [];
+        this.#insertCandidate(node.wildcards, indexedRoute);
+        return this;
+      }
+      node.minimumOrder = Math.min(node.minimumOrder, indexedRoute.order);
+    }
+    node.terminals ||= [];
+    indexedRoute.isStructurallyMatched = true;
+    this.#insertCandidate(node.terminals, indexedRoute);
+    return this;
+  }
+  match(pathname, shouldDecodeParams = false) {
+    const normalizedPathname = stripRouteSeparators(pathname);
+    const staticRoute = this.#staticRoutes.get(getStaticRequestKey(normalizedPathname));
+    const registrationPrecedence = this.#precedence === "registration";
+    const cutoff = registrationPrecedence ? staticRoute?.order ?? Number.POSITIVE_INFINITY : Number.POSITIVE_INFINITY;
+    const firstUnindexedRoute = this.#unindexedRoutes[0];
+    if (registrationPrecedence && staticRoute && this.#root.minimumOrder >= cutoff && (!firstUnindexedRoute || firstUnindexedRoute.order >= cutoff)) {
+      return { value: staticRoute.value, params: {} };
+    }
+    const segments = normalizedPathname === "/" ? ["/"] : normalizedPathname.split("/");
+    const candidateLists = [];
+    if (firstUnindexedRoute && (!registrationPrecedence || firstUnindexedRoute.order < cutoff)) {
+      candidateLists.push(this.#unindexedRoutes);
+    }
+    this.#collectCandidates(this.#root, segments, 0, cutoff, candidateLists);
+    if (!registrationPrecedence && staticRoute) {
+      candidateLists.push([staticRoute]);
+    }
+    const candidate = candidateLists.length === 1 ? this.#findCandidateInList(candidateLists[0], segments, cutoff) : this.#findCandidateAcrossLists(candidateLists, segments, cutoff);
+    if (candidate) {
+      return {
+        value: candidate.value,
+        params: extractRouteParamsFromSegments(candidate.tokens, segments, shouldDecodeParams)
+      };
+    }
+    return registrationPrecedence && staticRoute ? { value: staticRoute.value, params: {} } : null;
+  }
+  #findCandidateInList(candidates, segments, cutoff) {
+    for (const candidate of candidates) {
+      if (candidate.order >= cutoff) {
+        break;
+      }
+      if (matchesIndexedRoute(candidate, segments)) {
+        return candidate;
+      }
+    }
+    return void 0;
+  }
+  #findCandidateAcrossLists(candidateLists, segments, cutoff) {
+    const positions = new Uint32Array(candidateLists.length);
+    while (true) {
+      let selectedList = -1;
+      let selectedRoute;
+      for (const [listIndex, candidates] of candidateLists.entries()) {
+        const candidate = candidates[positions[listIndex]];
+        if (candidate && (!selectedRoute || this.#compareRoutes(candidate, selectedRoute) < 0)) {
+          selectedList = listIndex;
+          selectedRoute = candidate;
+        }
+      }
+      if (!selectedRoute || selectedRoute.order >= cutoff) {
+        return void 0;
+      }
+      positions[selectedList]++;
+      if (matchesIndexedRoute(selectedRoute, segments)) {
+        return selectedRoute;
+      }
+    }
+  }
+  #compareRoutes(a, b) {
+    if (this.#precedence === "specificity") {
+      const specificity = compareRouteSpecificity(a.tokens, b.tokens);
+      if (specificity !== 0) return specificity;
+    }
+    return a.order - b.order;
+  }
+  #insertCandidate(candidates, route) {
+    if (this.#precedence === "registration") {
+      candidates.push(route);
+      return;
+    }
+    let start = 0;
+    let end = candidates.length;
+    while (start < end) {
+      const middle = start + end >>> 1;
+      if (this.#compareRoutes(candidates[middle], route) <= 0) {
+        start = middle + 1;
+      } else {
+        end = middle;
+      }
+    }
+    candidates.splice(start, 0, route);
+  }
+  #collectCandidates(node, segments, segmentIndex, cutoff, candidateLists, canMatchTerminal = true) {
+    if (node.minimumOrder >= cutoff) {
+      return;
+    }
+    const wildcards = node.wildcards;
+    if (wildcards?.length && wildcards[0].order < cutoff) {
+      candidateLists.push(wildcards);
+    }
+    if (segmentIndex === segments.length) {
+      this.#collectTerminalCandidates(
+        node,
+        segments,
+        segmentIndex,
+        cutoff,
+        candidateLists,
+        canMatchTerminal
+      );
+      return;
+    }
+    const segment = segments[segmentIndex];
+    this.#collectSegmentCandidates(node, segments, segmentIndex, segment, cutoff, candidateLists);
+  }
+  #collectTerminalCandidates(node, segments, segmentIndex, cutoff, candidateLists, canMatchTerminal) {
+    const terminals = node.terminals;
+    if (canMatchTerminal && terminals?.length && terminals[0].order < cutoff) {
+      candidateLists.push(terminals);
+    }
+    for (const [suffix, optionalChild] of node.optionals ?? []) {
+      if (suffix === "") {
+        this.#collectCandidates(optionalChild, segments, segmentIndex, cutoff, candidateLists);
+      }
+    }
+    for (const [suffix, parameterChild] of node.parameters ?? []) {
+      if (suffix === "") {
+        this.#collectCandidates(
+          parameterChild,
+          segments,
+          segmentIndex,
+          cutoff,
+          candidateLists,
+          false
+        );
+      }
+    }
+  }
+  #collectSegmentCandidates(node, segments, segmentIndex, segment, cutoff, candidateLists) {
+    const literalChild = node.literals?.get(segment);
+    if (literalChild) {
+      this.#collectCandidates(literalChild, segments, segmentIndex + 1, cutoff, candidateLists);
+    }
+    if (segment !== "/") {
+      for (const [suffix, parameterChild] of node.parameters ?? []) {
+        if (segment.endsWith(suffix)) {
+          this.#collectCandidates(
+            parameterChild,
+            segments,
+            segmentIndex + 1,
+            cutoff,
+            candidateLists
+          );
+        }
+      }
+    }
+    for (const [suffix, optionalChild] of node.optionals ?? []) {
+      if (segment === "/" || segment.endsWith(suffix)) {
+        this.#collectCandidates(optionalChild, segments, segmentIndex + 1, cutoff, candidateLists);
+      }
+    }
+  }
+};
+export {
+  RouteTable,
+  extractRouteParams,
+  matchRouteTokens,
+  parseRoute
+};
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/route_parser.ts","../src/route_table.ts"],"sourcesContent":["/*\n * Portions derived from @adonisjs/http-server.\n * Copyright (c) 2023 Harminder Virk. Licensed under the MIT License.\n */\n\nimport type { RouteMatchers, RouteToken } from './types.ts'\n\nexport function stripRouteSeparators(value: string): string {\n  if (value === '/') {\n    return value\n  }\n  if (value.charCodeAt(0) === 47) {\n    value = value.substring(1)\n  }\n\n  const lastIndex = value.length - 1\n  return value.charCodeAt(lastIndex) === 47 ? value.substring(0, lastIndex) : value\n}\n\n/**\n * Parses a route pattern into tokens. A single leading and trailing separator\n * is stripped for compatibility with established route pattern semantics.\n */\nexport function parseRoute(pattern: string, matchers: RouteMatchers = {}): RouteToken[] {\n  if (pattern === '/') {\n    return [{ old: pattern, type: 0, val: pattern, end: '' }]\n  }\n\n  if (typeof matchers !== 'object') {\n    matchers = {}\n  }\n\n  let remaining = stripRouteSeparators(pattern)\n  let index = -1\n  let parameterNameEnd = 0\n  let segmentStart = 0\n  let remainingLength = remaining.length\n  const tokens: RouteToken[] = []\n\n  while (++index < remainingLength) {\n    let character = remaining.charCodeAt(index)\n\n    if (character === 58) {\n      segmentStart = index + 1\n      let type: 1 | 3 = 1\n      parameterNameEnd = 0\n      let suffix = ''\n\n      while (index < remainingLength && remaining.charCodeAt(index) !== 47) {\n        character = remaining.charCodeAt(index)\n        if (character === 63) {\n          parameterNameEnd = index\n          type = 3\n        } else if (character === 46 && suffix.length === 0) {\n          parameterNameEnd = index\n          suffix = remaining.substring(index)\n        }\n        index++\n      }\n\n      const value = remaining.substring(segmentStart, parameterNameEnd || index)\n      const matcher = matchers[value]\n      tokens.push({\n        old: pattern,\n        type,\n        val: value,\n        end: suffix,\n        matcher: matcher?.match,\n        cast: matcher?.cast,\n      })\n\n      remaining = remaining.substring(index)\n      remainingLength -= index\n      index = 0\n      continue\n    }\n\n    if (character === 42) {\n      tokens.push({\n        old: pattern,\n        type: 2,\n        val: remaining.substring(index),\n        end: '',\n      })\n      continue\n    }\n\n    segmentStart = index\n    while (index < remainingLength && remaining.charCodeAt(index) !== 47) {\n      index++\n    }\n\n    const value = remaining.substring(segmentStart, index)\n    tokens.push({ old: pattern, type: 0, val: value, end: '' })\n    remaining = remaining.substring(index)\n    remainingLength -= index\n    index = segmentStart = 0\n  }\n\n  return tokens\n}\n","/*\n * Portions derived from @adonisjs/http-server.\n * Copyright (c) 2023 Harminder Virk. Licensed under the MIT License.\n */\n\nimport { stripRouteSeparators } from './route_parser.ts'\nimport type {\n  RouteMatch,\n  RouteParams,\n  RoutePrecedence,\n  RouteTableOptions,\n  RouteToken,\n  RouteTokenType,\n} from './types.ts'\n\ntype IndexedRoute<T> = {\n  additionalMatcherChecks?: { index: number; matcher: RegExp }[]\n  isStructurallyMatched?: boolean\n  matcher?: RegExp\n  matcherSegmentIndex?: number\n  order: number\n  tokens: RouteToken[]\n  value: T\n}\n\ntype RouteNode<T> = {\n  literals?: Map<string, RouteNode<T>>\n  minimumOrder: number\n  optionals?: Map<string, RouteNode<T>>\n  parameters?: Map<string, RouteNode<T>>\n  terminals?: IndexedRoute<T>[]\n  wildcards?: IndexedRoute<T>[]\n}\n\nfunction createNode<T>(): RouteNode<T> {\n  return { minimumOrder: Number.POSITIVE_INFINITY }\n}\n\nfunction splitRoutePath(pathname: string): string[] {\n  pathname = stripRouteSeparators(pathname)\n  return pathname === '/' ? ['/'] : pathname.split('/')\n}\n\nfunction getStaticRouteKey(tokens: RouteToken[]): string | null {\n  if (!tokens.length || tokens.some((token) => token.type !== 0)) {\n    return null\n  }\n\n  return tokens.length === 1 && tokens[0].val === '/'\n    ? 'root'\n    : `segments:${tokens.map((token) => token.val).join('/')}`\n}\n\nfunction getStaticRequestKey(normalizedPathname: string): string {\n  return normalizedPathname === '/' ? 'root' : `segments:${normalizedPathname}`\n}\n\nfunction getOrCreateChild<T>(children: Map<string, RouteNode<T>>, key: string): RouteNode<T> {\n  let child = children.get(key)\n  if (!child) {\n    child = createNode<T>()\n    children.set(key, child)\n  }\n  return child\n}\n\nfunction getTokenSpecificity(type: RouteTokenType): number {\n  if (type === 0) return 3\n  if (type === 1) return 2\n  if (type === 3) return 1\n  return 0\n}\n\nfunction compareRouteSpecificity(a: RouteToken[], b: RouteToken[]): number {\n  const length = Math.max(a.length, b.length)\n  for (let index = 0; index < length; index++) {\n    const aSpecificity = a[index] ? getTokenSpecificity(a[index].type) : -1\n    const bSpecificity = b[index] ? getTokenSpecificity(b[index].type) : -1\n    if (aSpecificity !== bSpecificity) {\n      return bSpecificity - aSpecificity\n    }\n  }\n  return 0\n}\n\nfunction matchesSegment(token: RouteToken, segment: string | undefined): boolean {\n  if (token.type === 0) {\n    return token.val === segment\n  }\n  if (segment === '/') {\n    return token.type > 1\n  }\n  if (segment === '') {\n    return token.end === '' && (token.matcher ? token.matcher.test(segment) : true)\n  }\n  if (!segment) {\n    return token.end === ''\n  }\n  return segment.endsWith(token.end) && (token.matcher ? token.matcher.test(segment) : true)\n}\n\nfunction matchesRoute(tokens: RouteToken[], segments: string[]): boolean {\n  if (!tokens.length) {\n    return segments.length === 1 && segments[0] === '/'\n  }\n\n  if (\n    tokens.length !== segments.length &&\n    !(tokens.length < segments.length && tokens[tokens.length - 1].type === 2) &&\n    !(tokens.length > segments.length && tokens[tokens.length - 1].type === 3)\n  ) {\n    return false\n  }\n\n  let index = 0\n  while (index < tokens.length) {\n    if (!matchesSegment(tokens[index], segments[index])) {\n      return false\n    }\n    index++\n  }\n\n  return true\n}\n\nfunction matchesIndexedRoute<T>(route: IndexedRoute<T>, segments: string[]): boolean {\n  if (!route.isStructurallyMatched) {\n    return matchesRoute(route.tokens, segments)\n  }\n\n  const matcher = route.matcher\n  if (matcher) {\n    const segment = segments[route.matcherSegmentIndex!]\n    if (segment !== undefined && segment !== '/' && !matcher.test(segment)) {\n      return false\n    }\n  }\n\n  for (const { index, matcher: additionalMatcher } of route.additionalMatcherChecks ?? []) {\n    const segment = segments[index]\n    if (segment !== undefined && segment !== '/' && !additionalMatcher.test(segment)) {\n      return false\n    }\n  }\n  return true\n}\n\nfunction extractRouteParamsFromSegments(\n  tokens: RouteToken[],\n  segments: string[],\n  shouldDecodeParams: boolean\n): RouteParams {\n  const params: RouteParams = {}\n  let index = 0\n\n  while (index < tokens.length) {\n    const token = tokens[index]\n    const segment = segments[index]\n\n    if (segment === '/') {\n      index++\n      continue\n    }\n\n    if (token.val === '*') {\n      params[token.val] = segments.slice(index).map((value) => {\n        if (!shouldDecodeParams) {\n          return value\n        }\n        try {\n          return decodeURIComponent(value)\n        } catch {\n          return value\n        }\n      })\n      break\n    }\n\n    if (segment === undefined || token.type === 0) {\n      index++\n      continue\n    }\n\n    let value = segment.replace(token.end, '')\n    if (shouldDecodeParams) {\n      try {\n        value = decodeURIComponent(value)\n      } catch {}\n    }\n    params[token.val] = token.cast ? token.cast(value) : value\n    index++\n  }\n\n  return params\n}\n\nexport function extractRouteParams(\n  tokens: RouteToken[],\n  pathname: string,\n  shouldDecodeParams: boolean = false\n): RouteParams {\n  return extractRouteParamsFromSegments(tokens, splitRoutePath(pathname), shouldDecodeParams)\n}\n\n/** Matches a transient list of tokenized routes without building an index. */\nexport function matchRouteTokens(\n  pathname: string,\n  routes: RouteToken[][],\n  shouldDecodeParams: boolean = false\n): RouteParams | null {\n  const segments = splitRoutePath(pathname)\n  for (const tokens of routes) {\n    if (matchesRoute(tokens, segments)) {\n      return extractRouteParamsFromSegments(tokens, segments, shouldDecodeParams)\n    }\n  }\n  return null\n}\n\n/** An indexed route matcher with configurable precedence. */\nexport class RouteTable<T> {\n  #nextOrder = 0\n  #precedence: RoutePrecedence\n  #root = createNode<T>()\n  #staticRoutes = new Map<string, IndexedRoute<T>>()\n  #unindexedRoutes: IndexedRoute<T>[] = []\n\n  constructor(options: RouteTableOptions = {}) {\n    this.#precedence = options.precedence ?? 'registration'\n  }\n\n  add(tokens: RouteToken[], value: T): this {\n    const indexedRoute: IndexedRoute<T> = { order: this.#nextOrder++, tokens, value }\n    const staticKey = getStaticRouteKey(tokens)\n\n    if (staticKey !== null) {\n      if (!this.#staticRoutes.has(staticKey)) {\n        this.#staticRoutes.set(staticKey, indexedRoute)\n      }\n      return this\n    }\n\n    const hasStatefulMatcher = tokens.some((token, index) => {\n      const matcher = token.matcher\n      const isStateful =\n        matcher &&\n        (matcher.global ||\n          matcher.sticky ||\n          matcher.exec !== RegExp.prototype.exec ||\n          matcher.test !== RegExp.prototype.test)\n      if (isStateful) {\n        return true\n      }\n      if (matcher) {\n        if (!indexedRoute.matcher) {\n          indexedRoute.matcher = matcher\n          indexedRoute.matcherSegmentIndex = index\n        } else {\n          indexedRoute.additionalMatcherChecks ||= []\n          indexedRoute.additionalMatcherChecks.push({ index, matcher })\n        }\n      }\n      return false\n    })\n\n    if (!tokens.length || hasStatefulMatcher) {\n      this.#insertCandidate(this.#unindexedRoutes, indexedRoute)\n      return this\n    }\n\n    let node = this.#root\n    node.minimumOrder = Math.min(node.minimumOrder, indexedRoute.order)\n    for (const token of tokens) {\n      if (token.type === 0) {\n        node.literals ||= new Map()\n        node = getOrCreateChild(node.literals, token.val)\n      } else if (token.type === 1) {\n        node.parameters ||= new Map()\n        node = getOrCreateChild(node.parameters, token.end)\n      } else if (token.type === 3) {\n        node.optionals ||= new Map()\n        node = getOrCreateChild(node.optionals, token.end)\n      } else {\n        node.wildcards ||= []\n        this.#insertCandidate(node.wildcards, indexedRoute)\n        return this\n      }\n      node.minimumOrder = Math.min(node.minimumOrder, indexedRoute.order)\n    }\n\n    node.terminals ||= []\n    indexedRoute.isStructurallyMatched = true\n    this.#insertCandidate(node.terminals, indexedRoute)\n    return this\n  }\n\n  match(pathname: string, shouldDecodeParams: boolean = false): RouteMatch<T> | null {\n    const normalizedPathname = stripRouteSeparators(pathname)\n    const staticRoute = this.#staticRoutes.get(getStaticRequestKey(normalizedPathname))\n    const registrationPrecedence = this.#precedence === 'registration'\n    const cutoff = registrationPrecedence\n      ? (staticRoute?.order ?? Number.POSITIVE_INFINITY)\n      : Number.POSITIVE_INFINITY\n    const firstUnindexedRoute = this.#unindexedRoutes[0]\n    if (\n      registrationPrecedence &&\n      staticRoute &&\n      this.#root.minimumOrder >= cutoff &&\n      (!firstUnindexedRoute || firstUnindexedRoute.order >= cutoff)\n    ) {\n      return { value: staticRoute.value, params: {} }\n    }\n\n    const segments = normalizedPathname === '/' ? ['/'] : normalizedPathname.split('/')\n    const candidateLists: IndexedRoute<T>[][] = []\n    if (firstUnindexedRoute && (!registrationPrecedence || firstUnindexedRoute.order < cutoff)) {\n      candidateLists.push(this.#unindexedRoutes)\n    }\n    this.#collectCandidates(this.#root, segments, 0, cutoff, candidateLists)\n    if (!registrationPrecedence && staticRoute) {\n      candidateLists.push([staticRoute])\n    }\n\n    const candidate =\n      candidateLists.length === 1\n        ? this.#findCandidateInList(candidateLists[0], segments, cutoff)\n        : this.#findCandidateAcrossLists(candidateLists, segments, cutoff)\n    if (candidate) {\n      return {\n        value: candidate.value,\n        params: extractRouteParamsFromSegments(candidate.tokens, segments, shouldDecodeParams),\n      }\n    }\n    return registrationPrecedence && staticRoute ? { value: staticRoute.value, params: {} } : null\n  }\n\n  #findCandidateInList(\n    candidates: IndexedRoute<T>[],\n    segments: string[],\n    cutoff: number\n  ): IndexedRoute<T> | undefined {\n    for (const candidate of candidates) {\n      if (candidate.order >= cutoff) {\n        break\n      }\n      if (matchesIndexedRoute(candidate, segments)) {\n        return candidate\n      }\n    }\n    return undefined\n  }\n\n  #findCandidateAcrossLists(\n    candidateLists: IndexedRoute<T>[][],\n    segments: string[],\n    cutoff: number\n  ): IndexedRoute<T> | undefined {\n    const positions = new Uint32Array(candidateLists.length)\n    while (true) {\n      let selectedList = -1\n      let selectedRoute: IndexedRoute<T> | undefined\n      for (const [listIndex, candidates] of candidateLists.entries()) {\n        const candidate = candidates[positions[listIndex]]\n        if (candidate && (!selectedRoute || this.#compareRoutes(candidate, selectedRoute) < 0)) {\n          selectedList = listIndex\n          selectedRoute = candidate\n        }\n      }\n\n      if (!selectedRoute || selectedRoute.order >= cutoff) {\n        return undefined\n      }\n      positions[selectedList]++\n\n      if (matchesIndexedRoute(selectedRoute, segments)) {\n        return selectedRoute\n      }\n    }\n  }\n\n  #compareRoutes(a: IndexedRoute<T>, b: IndexedRoute<T>): number {\n    if (this.#precedence === 'specificity') {\n      const specificity = compareRouteSpecificity(a.tokens, b.tokens)\n      if (specificity !== 0) return specificity\n    }\n    return a.order - b.order\n  }\n\n  #insertCandidate(candidates: IndexedRoute<T>[], route: IndexedRoute<T>): void {\n    if (this.#precedence === 'registration') {\n      candidates.push(route)\n      return\n    }\n\n    let start = 0\n    let end = candidates.length\n    while (start < end) {\n      const middle = (start + end) >>> 1\n      if (this.#compareRoutes(candidates[middle], route) <= 0) {\n        start = middle + 1\n      } else {\n        end = middle\n      }\n    }\n    candidates.splice(start, 0, route)\n  }\n\n  #collectCandidates(\n    node: RouteNode<T>,\n    segments: string[],\n    segmentIndex: number,\n    cutoff: number,\n    candidateLists: IndexedRoute<T>[][],\n    canMatchTerminal: boolean = true\n  ): void {\n    if (node.minimumOrder >= cutoff) {\n      return\n    }\n\n    const wildcards = node.wildcards\n    if (wildcards?.length && wildcards[0].order < cutoff) {\n      candidateLists.push(wildcards)\n    }\n\n    if (segmentIndex === segments.length) {\n      this.#collectTerminalCandidates(\n        node,\n        segments,\n        segmentIndex,\n        cutoff,\n        candidateLists,\n        canMatchTerminal\n      )\n      return\n    }\n\n    const segment = segments[segmentIndex]\n    this.#collectSegmentCandidates(node, segments, segmentIndex, segment, cutoff, candidateLists)\n  }\n\n  #collectTerminalCandidates(\n    node: RouteNode<T>,\n    segments: string[],\n    segmentIndex: number,\n    cutoff: number,\n    candidateLists: IndexedRoute<T>[][],\n    canMatchTerminal: boolean\n  ): void {\n    const terminals = node.terminals\n    if (canMatchTerminal && terminals?.length && terminals[0].order < cutoff) {\n      candidateLists.push(terminals)\n    }\n    for (const [suffix, optionalChild] of node.optionals ?? []) {\n      if (suffix === '') {\n        this.#collectCandidates(optionalChild, segments, segmentIndex, cutoff, candidateLists)\n      }\n    }\n    for (const [suffix, parameterChild] of node.parameters ?? []) {\n      if (suffix === '') {\n        this.#collectCandidates(\n          parameterChild,\n          segments,\n          segmentIndex,\n          cutoff,\n          candidateLists,\n          false\n        )\n      }\n    }\n  }\n\n  #collectSegmentCandidates(\n    node: RouteNode<T>,\n    segments: string[],\n    segmentIndex: number,\n    segment: string,\n    cutoff: number,\n    candidateLists: IndexedRoute<T>[][]\n  ): void {\n    const literalChild = node.literals?.get(segment)\n    if (literalChild) {\n      this.#collectCandidates(literalChild, segments, segmentIndex + 1, cutoff, candidateLists)\n    }\n    if (segment !== '/') {\n      for (const [suffix, parameterChild] of node.parameters ?? []) {\n        if (segment.endsWith(suffix)) {\n          this.#collectCandidates(\n            parameterChild,\n            segments,\n            segmentIndex + 1,\n            cutoff,\n            candidateLists\n          )\n        }\n      }\n    }\n    for (const [suffix, optionalChild] of node.optionals ?? []) {\n      if (segment === '/' || segment.endsWith(suffix)) {\n        this.#collectCandidates(optionalChild, segments, segmentIndex + 1, cutoff, candidateLists)\n      }\n    }\n  }\n}\n"],"mappings":"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","names":["value","value"]}

package/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "@boringnode/route-matcher",
+  "description": "A fast, registration-ordered route matcher",
+  "version": "0.1.1",
+  "main": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "type": "module",
+  "files": [
+    "build"
+  ],
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "import": "./build/index.js"
+    }
+  },
+  "scripts": {
+    "build": "yarn clean && tsup-node",
+    "check:package": "yarn build && publint && attw --pack --profile esm-only .",
+    "clean": "del-cli build",
+    "format": "oxfmt --check .",
+    "format:fix": "oxfmt --write .",
+    "lint": "oxlint",
+    "lint:fix": "oxlint --fix",
+    "prepublishOnly": "yarn build",
+    "release": "yarn dlx release-it",
+    "test": "node --import=@poppinss/ts-exec --enable-source-maps bin/test.ts --reporters=dot",
+    "test:coverage": "c8 yarn test",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@adonisjs/tsconfig": "^2.0.0",
+    "@arethetypeswrong/cli": "^0.18.2",
+    "@japa/assert": "^4.2.0",
+    "@japa/expect-type": "^2.0.4",
+    "@japa/runner": "^5.3.0",
+    "@poppinss/matchit": "^3.2.0",
+    "@poppinss/ts-exec": "^1.4.4",
+    "@types/node": "^20.19.24",
+    "c8": "^11.0.0",
+    "del-cli": "^7.0.0",
+    "oxfmt": "^0.56.0",
+    "oxlint": "^1.71.0",
+    "publint": "^0.3.14",
+    "release-it": "^20.2.1",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  },
+  "author": "Romain Lanz <romain.lanz@pm.me>",
+  "license": "MIT",
+  "homepage": "https://github.com/boringnode/route-matcher#readme",
+  "bugs": {
+    "url": "https://github.com/boringnode/route-matcher/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/boringnode/route-matcher.git"
+  },
+  "keywords": [
+    "route",
+    "router",
+    "matcher",
+    "routing"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "tag": "latest"
+  },
+  "release-it": {
+    "git": {
+      "commitMessage": "chore(release): ${version}",
+      "tagAnnotation": "v${version}",
+      "tagName": "v${version}"
+    },
+    "github": {
+      "release": true,
+      "releaseName": "v${version}"
+    },
+    "npm": {
+      "publish": true,
+      "skipChecks": true
+    }
+  },
+  "packageManager": "yarn@4.17.1",
+  "engines": {
+    "node": ">=20.6"
+  }
+}