Address review feedback on inline processor fix

Author: aryansk

docs/changelog.md

@@ -12,10 +12,14 @@ See the [Contributing Guide](contributing.md) for details.
 
 ## [Unreleased]
 
+### Changed
+
+* Inline processors now resume searching after the previous match, improving
+  performance for repeated inline patterns (#1619).
+
 ### Fixed
 
 * Fix an issue with excessive backtracking when matching inline code blocks (#1617).
-* Fix quadratic rendering time when a paragraph contains many inline links (#1619).
 
 ## [3.10.3] - 2026-07-30
 

tests/test_apis.py

@@ -725,13 +725,48 @@ def testInlineProcessorDoesntCrashWithWrongAtomicString(self):
             '<div><p>a &lt;b&gt;atomic&lt;/b&gt; c</p></div>'
         )
 
+    def testInlineProcessorAdvancesSearchIndex(self):
+        """Test that repeated matches resume after the previous match."""
+        pattern = _InlineProcessorThatRecordsSearchIndex(r'x', self.md)
+        self.md.inlinePatterns.register(pattern, 'record-search-index', 1000)
+
+        self.assertEqual(self.md.convert('xxxx'), '<p>xxxx</p>')
+        self.assertEqual(pattern.start_indices[0], 0)
+        self.assertGreater(pattern.start_indices[1], pattern.start_indices[0])
+
 
 class _InlineProcessorThatReturnsAtomicString(inlinepatterns.InlineProcessor):
     """ Return a simple text of `group(1)` of a Pattern. """
     def handleMatch(self, m, data):
         return markdown.util.AtomicString('<b>atomic</b>'), m.start(0), m.end(0)
 
 
+class _RecordingPattern:
+    """Proxy a compiled pattern while recording the search offsets."""
+
+    def __init__(self, pattern, start_indices):
+        self.pattern = pattern
+        self.start_indices = start_indices
+
+    def finditer(self, data, start_index=0):
+        self.start_indices.append(start_index)
+        return self.pattern.finditer(data, start_index)
+
+
+class _InlineProcessorThatRecordsSearchIndex(inlinepatterns.InlineProcessor):
+    """Record each offset passed to the processor's compiled expression."""
+
+    def __init__(self, pattern, md):
+        super().__init__(pattern, md)
+        self.start_indices = []
+
+    def getCompiledRegExp(self):
+        return _RecordingPattern(self.compiled_re, self.start_indices)
+
+    def handleMatch(self, m, data):
+        return m.group(0), m.start(0), m.end(0)
+
+
 class TestConfigParsing(unittest.TestCase):
     def assertParses(self, value, result):
         self.assertIs(markdown.util.parseBoolValue(value, False), result)

tests/test_syntax/inline/test_links.py

@@ -21,8 +21,6 @@
 
 from markdown.test_tools import TestCase
 
-import time
-
 
 class TestInlineLinks(TestCase):
 
@@ -436,21 +434,3 @@ def test_ref_round_brackets(self):
                 """
             )
         )
-
-    def test_many_repeated_links(self):
-        # Regression test for #1619: rendering many inline links in one
-        # paragraph used to rescan the unprocessed text from the start after
-        # every match, making conversion quadratic in the number of links.
-        from markdown import Markdown
-
-        text = "[link](x)" * 8192
-        start = time.monotonic()
-        html = Markdown().convert(text)
-        elapsed = time.monotonic() - start
-
-        # The old implementation takes several seconds (or more on slow CI)
-        # for this input; the linear implementation finishes well under a
-        # second on any machine. Allow a generous ceiling to avoid flakes.
-        self.assertLess(elapsed, 5)
-        self.assertEqual(html.count("<a "), 8192)
-        self.assertEqual(html.count("</a>"), 8192)