fix(matcher): finalize param token before processing escaped colon (#2654)

babu-ch · posva · web-flow · commit 20521b033352 · 2026-04-22T16:38:10.000+02:00
Co-authored-by: Eduardo San Martin Morote &lt;posva13@gmail.com&gt;
diff --git a/packages/router/__tests__/matcher/pathParser.spec.ts b/packages/router/__tests__/matcher/pathParser.spec.ts
@@ -30,6 +30,132 @@ describe('Path parser', () => {
       ])
     })
 
+    it('escapes non-colon char after param', () => {
+      expect(tokenizePath('/:foo\\-abc')).toEqual([
+        [
+          {
+            type: TokenType.Param,
+            value: 'foo',
+            regexp: '',
+            repeatable: false,
+            optional: false,
+          },
+          { type: TokenType.Static, value: '-abc' },
+        ],
+      ])
+    })
+
+    it('escapes ) inside custom re to allow nested groups', () => {
+      expect(tokenizePath('/:id((?:a-[^/]+\\)?)')).toEqual([
+        [
+          {
+            type: TokenType.Param,
+            value: 'id',
+            regexp: '(?:a-[^/]+)?',
+            repeatable: false,
+            optional: false,
+          },
+        ],
+      ])
+    })
+
+    it('escapes + after empty custom re', () => {
+      expect(tokenizePath('/:p()\\+')).toEqual([
+        [
+          {
+            type: TokenType.Param,
+            value: 'p',
+            regexp: '',
+            repeatable: false,
+            optional: false,
+          },
+          { type: TokenType.Static, value: '+' },
+        ],
+      ])
+    })
+
+    it('escapes + after param', () => {
+      expect(tokenizePath('/:p\\+')).toEqual([
+        [
+          {
+            type: TokenType.Param,
+            value: 'p',
+            regexp: '',
+            repeatable: false,
+            optional: false,
+          },
+          { type: TokenType.Static, value: '+' },
+        ],
+      ])
+    })
+
+    it('escapes : after optional param with custom re', () => {
+      expect(tokenizePath('/:foo([^:]+)?\\:abc')).toEqual([
+        [
+          {
+            type: TokenType.Param,
+            value: 'foo',
+            regexp: '[^:]+',
+            repeatable: false,
+            optional: true,
+          },
+          { type: TokenType.Static, value: ':abc' },
+        ],
+      ])
+    })
+
+    it('escapes : after param', () => {
+      expect(tokenizePath('/:foo\\:abc')).toEqual([
+        [
+          {
+            type: TokenType.Param,
+            value: 'foo',
+            regexp: '',
+            repeatable: false,
+            optional: false,
+          },
+          { type: TokenType.Static, value: ':abc' },
+        ],
+      ])
+    })
+
+    it('escapes : after param with custom re', () => {
+      expect(tokenizePath('/:foo([^:]+)\\:abc')).toEqual([
+        [
+          {
+            type: TokenType.Param,
+            value: 'foo',
+            regexp: '[^:]+',
+            repeatable: false,
+            optional: false,
+          },
+          { type: TokenType.Static, value: ':abc' },
+        ],
+      ])
+    })
+
+    it('escapes : between two params', () => {
+      expect(tokenizePath('/:foo([^:]+)\\::bar')).toEqual([
+        [
+          {
+            type: TokenType.Param,
+            value: 'foo',
+            regexp: '[^:]+',
+            repeatable: false,
+            optional: false,
+          },
+          { type: TokenType.Static, value: ':' },
+          {
+            type: TokenType.Param,
+            value: 'bar',
+            regexp: '',
+            repeatable: false,
+            optional: false,
+          },
+        ],
+      ])
+    })
+
     // not sure how useful this is and if it's worth supporting because of the
     // cost to support the ranking as well
     it.skip('groups', () => {
@@ -808,6 +934,24 @@ describe('Path parser', () => {
       })
     })
 
+    it('param followed by escaped colon and static', () => {
+      matchParams('/:foo\\:abc', '/section:abc', { foo: 'section' })
+      matchParams('/:foo\\:abc', '/sectionabc', null)
+    })
+
+    it('param with custom re followed by escaped colon and another param', () => {
+      matchParams('/:foo([^:]+)\\::bar', '/section:aaabbbccc', {
+        foo: 'section',
+        bar: 'aaabbbccc',
+      })
+    })
+
+    it('escaped + becomes part of static path, not a repeat modifier', () => {
+      matchParams('/:p\\+', '/abc+', { p: 'abc' })
+      matchParams('/:p\\+', '/abc', null)
+      matchParams('/:p()\\+', '/abc+', { p: 'abc' })
+    })
+
     // end of parsing urls
   })
 
diff --git a/packages/router/src/matcher/pathTokenizer.ts b/packages/router/src/matcher/pathTokenizer.ts
@@ -118,15 +118,12 @@ export function tokenizePath(path: string): Array<Token[]> {
   while (i < path.length) {
     char = path[i++]
 
-    if (char === '\\' && state !== TokenizerState.ParamRegExp) {
-      previousState = state
-      state = TokenizerState.EscapeNext
-      continue
-    }
-
     switch (state) {
       case TokenizerState.Static:
-        if (char === '/') {
+        if (char === '\\') {
+          previousState = state
+          state = TokenizerState.EscapeNext
+        } else if (char === '/') {
           if (buffer) {
             consumeBuffer()
           }
