update

Author: pi0

README.md

@@ -96,81 +96,26 @@ findRoute(router, "GET", "/");
 
 ## Route Patterns
 
-rou3 supports a variety of route patterns, including [URLPattern](https://developer.mozilla.org/en-US/docs/Web/API/URL_Pattern_API)-compatible syntax.
-
-### Static
-
-```
-/path/to/resource
-```
-
-### Named Parameters
-
-`:name` matches a single path segment.
-
-```
-/users/:name        →  /users/foo        → { name: "foo" }
-```
-
-### Wildcards
-
-`**` matches zero or more segments. Use `**:name` to capture the matched path.
-
-```
-/path/**            →  /path/foo/bar     → {}
-/path/**:rest       →  /path/foo/bar     → { rest: "foo/bar" }
-```
-
-### Regex Constraints
-
-`:name(regex)` restricts a named parameter to match only the given pattern.
-
-```
-/users/:id(\d+)          →  /users/123     → { id: "123" }
-                          →  /users/abc     → (no match)
-/files/:ext(png|jpg|gif) →  /files/png     → { ext: "png" }
-                          →  /files/pdf     → (no match)
-```
-
-Regex-constrained and unconstrained params can coexist on the same path node (constrained routes are checked first):
-
-```
-/users/:id(\d+)   +   /users/:slug
-  /users/123  → { id: "123" }
-  /users/abc  → { slug: "abc" }
-```
-
-### Unnamed Regex Groups
-
-`(regex)` without a parameter name captures into auto-indexed keys `_0`, `_1`, etc.
-
-```
-/path/(\d+)              →  /path/123      → { _0: "123" }
-/files/(png|jpg|gif)     →  /files/png     → { _0: "png" }
-```
-
-### Modifiers
-
-- `:name?` — optional (zero or one segment)
-- `:name+` — one or more segments
-- `:name*` — zero or more segments
-
-```
-/users/:id?              →  /users/123     → { id: "123" }
-                          →  /users         → {}
-/files/:path+            →  /files/a/b/c   → { path: "a/b/c" }
-                          →  /files         → (no match)
-/files/:path*            →  /files/a/b/c   → { path: "a/b/c" }
-                          →  /files         → {}
-```
-
-Modifiers can be combined with regex constraints:
-
-```
-/users/:id(\d+)?         →  /users/123     → { id: "123" }
-                          →  /users         → {}
-                          →  /users/abc     → (no match)
-```
+rou3 supports [URLPattern](https://developer.mozilla.org/en-US/docs/Web/API/URL_Pattern_API)-compatible syntax.
+
+| Pattern | Example Match | Params |
+| --- | --- | --- |
+| `/path/to/resource` | `/path/to/resource` | `{}` |
+| `/users/:name` | `/users/foo` | `{ name: "foo" }` |
+| `/path/**` | `/path/foo/bar` | `{}` |
+| `/path/**:rest` | `/path/foo/bar` | `{ rest: "foo/bar" }` |
+| `/users/:id(\\d+)` | `/users/123` | `{ id: "123" }` |
+| `/files/:ext(png\|jpg)` | `/files/png` | `{ ext: "png" }` |
+| `/path/(\\d+)` | `/path/123` | `{ _0: "123" }` |
+| `/users/:id?` | `/users` or `/users/123` | `{}` or `{ id: "123" }` |
+| `/files/:path+` | `/files/a/b/c` | `{ path: "a/b/c" }` |
+| `/files/:path*` | `/files` or `/files/a/b` | `{}` or `{ path: "a/b" }` |
+
+- **Named params** (`:name`) match a single segment.
+- **Wildcards** (`**`) match zero or more segments. Use `**:name` to capture.
+- **Regex constraints** (`:name(regex)`) restrict matching. Constrained and unconstrained params can coexist on the same node (constrained checked first).
+- **Unnamed groups** (`(regex)`) capture into auto-indexed keys `_0`, `_1`, etc.
+- **Modifiers:** `:name?` (optional), `:name+` (one or more), `:name*` (zero or more). Can combine with regex: `:id(\d+)?`.
 
 ## Compiler
 

src/operations/add.ts

@@ -65,7 +65,8 @@ export function addRoute<T>(
       if (segment === "*") {
         paramsMap.push([i, `_${_unnamedParamIndex++}`, true /* optional */]);
       } else if (segment.includes(":", 1) || segment.includes("(")) {
-        const regexp = getParamRegexp(segment);
+        const [regexp, nextIndex] = getParamRegexp(segment, _unnamedParamIndex);
+        _unnamedParamIndex = nextIndex;
         paramsRegexp[i] = regexp;
         node.hasRegexParam = true;
         paramsMap.push([i, regexp, false]);
@@ -125,19 +126,20 @@ function _expandModifiers(segments: string[]): string[] | undefined {
       ];
     }
     const name = m[1].match(/:(\w+)/)?.[1] || "_";
-    const wc = "/" + pre.concat(`**:${name}`).join("/");
-    return m[2] === "+" ? [wc] : [wc, "/" + pre.join("/")];
+    const wc = "/" + [...pre, `**:${name}`, ...suf].join("/");
+    const without = "/" + [...pre, ...suf].join("/");
+    return m[2] === "+" ? [wc] : [wc, without];
   }
 }
 
-function getParamRegexp(segment: string): RegExp {
-  let _i = 0;
+function getParamRegexp(segment: string, unnamedStart = 0): [RegExp, number] {
+  let _i = unnamedStart;
   const regex = segment
     .replace(
       /:(\w+)(?:\(([^)]*)\))?/g,
       (_, id, pattern) => `(?<${id}>${pattern || "[^/]+"})`,
     )
     .replace(/\((?![?<])/g, () => `(?<_${_i++}>`)
     .replace(/\./g, "\\.");
-  return new RegExp(`^${regex}$`);
+  return [new RegExp(`^${regex}$`), _i];
 }

src/regexp.ts

@@ -9,7 +9,7 @@ export function routeToRegExp(route: string = "/"): RegExp {
       reSegments.push(
         segment === "**" ? "?(?<_>.*)" : `?(?<${segment.slice(3)}>.+)`,
       );
-    } else if (segment.includes(":") || segment.includes("(")) {
+    } else if (segment.includes(":") || /(^|[^\\])\(/.test(segment)) {
       const modMatch = segment.match(/^(.*:\w+(?:\([^)]*\))?)([?+*])$/);
       if (modMatch) {
         const [, base, mod] = modMatch;
@@ -24,8 +24,18 @@ export function routeToRegExp(route: string = "/"): RegExp {
           reSegments.push(`?${inner}?`);
           continue;
         }
-        // + or *
-        reSegments.push(mod === "+" ? `?(?<${name}>.+)` : `?(?<${name}>.*)`);
+        // + or * (preserve inline constraint when present)
+        const pattern = base.match(/:(\w+)(?:\(([^)]*)\))?/)?.[2];
+        if (pattern) {
+          const repeated = `${pattern}(?:/${pattern})*`;
+          reSegments.push(
+            mod === "+"
+              ? `?(?<${name}>${repeated})`
+              : `?(?<${name}>${repeated})?`,
+          );
+        } else {
+          reSegments.push(mod === "+" ? `?(?<${name}>.+)` : `?(?<${name}>.*)`);
+        }
         continue;
       }
       reSegments.push(
@@ -34,7 +44,7 @@ export function routeToRegExp(route: string = "/"): RegExp {
             /:(\w+)(?:\(([^)]*)\))?/g,
             (_, id, pattern) => `(?<${id}>${pattern || "[^/]+"})`,
           )
-          .replace(/\((?![?<])/g, () => `(?<_${idCtr++}>`)
+          .replace(/(^|[^\\])\((?![?<])/g, (_, p) => `${p}(?<_${idCtr++}>`)
           .replace(/\./g, "\\."),
       );
     } else {

test/regexp.test.ts

@@ -95,6 +95,17 @@ describe("routeToRegExp", () => {
       regex: /^\/path\/(?<_0>png|jpg|gif)\/?$/,
       match: [["/path/png", { _0: "png" }]],
     },
+    "/path/:id(\\d+)+": {
+      regex: /^\/path\/?(?<id>\d+(?:\/\d+)*)\/?$/,
+      match: [
+        ["/path/123", { id: "123" }],
+        ["/path/123/456", { id: "123/456" }],
+      ],
+    },
+    "/path/:id(\\d+)*": {
+      regex: /^\/path\/?(?<id>\d+(?:\/\d+)*)?\/?$/,
+      match: [["/path/123", { id: "123" }], ["/path"]],
+    },
   } as const;
 
   for (const [route, expected] of Object.entries(routes)) {

test/router.test.ts

@@ -494,6 +494,16 @@ describe("Router lookup", function () {
       "/path/abc/foo": undefined,
     });
 
+    // Multi-unnamed groups across segments
+    testRouter(["/path/(\\d+)/(\\w+)"], undefined, {
+      "/path/123/abc": {
+        data: { path: "/path/(\\d+)/(\\w+)" },
+        params: { _0: "123", _1: "abc" },
+      },
+      "/path/abc/abc": undefined,
+      "/path/123/!": undefined,
+    });
+
     // Coexistence: unnamed regex + unconstrained param
     testRouter(["/path/(\\d+)", "/path/:slug"], undefined, {
       "/path/123": {