Fix quadratic processing time in fenced_code preprocessor (up to ~10x faster)

Author: deadstrobe5

docs/changelog.md

@@ -22,6 +22,8 @@ See the [Contributing Guide](contributing.md) for details.
   with the closer, dropping text.
 * Fix the unused part of a partially consumed closing delimiter run being classified using the replacement
   placeholder instead of the text that preceded it.
+* Fix quadratic processing time in the `fenced_code` extension for documents
+  with many fenced code blocks (#1660).
 
 ## [3.11.3] - 2026-11-05
 

markdown/extensions/fenced_code.py

@@ -102,6 +102,9 @@ def run(self, lines: list[str]) -> list[str]:
             self.checked_for_deps = True
 
         text = "\n".join(lines)
+        # Collect the output in pieces, as rebuilding the full text after each block is quadratic.
+        pieces: list[str] = []
+        last = 0
         index = 0
         while 1:
             m = self.FENCED_BLOCK_RE.search(text, index)
@@ -164,12 +167,13 @@ def run(self, lines: list[str]) -> list[str]:
                     code = f'<pre{id_attr}{class_attr}><code{lang_attr}{kv_pairs}>{code}</code></pre>'
 
                 placeholder = self.md.htmlStash.store(code)
-                text = f'{text[:m.start()]}\n{placeholder}\n{text[m.end():]}'
+                pieces.append(f'{text[last:m.start()]}\n{placeholder}\n')
                 # Continue from after the replaced text in the next iteration.
-                index = m.start() + 1 + len(placeholder)
+                index = last = m.end()
             else:
                 break
-        return text.split("\n")
+        pieces.append(text[last:])
+        return "".join(pieces).split("\n")
 
     def handle_attrs(
         self, attrs: Iterable[tuple[str, str | None]]

tests/test_syntax/extensions/test_fenced_code.py

@@ -455,6 +455,77 @@ def testFencedCodeMismatchedCurlyInAttrs(self):
             extensions=['fenced_code', 'attr_list']
         )
 
+    def testMultipleFencedBlocks(self):
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                Text before.
+
+                ```python
+                first = 1
+                ```
+
+                Text between.
+
+                ~~~
+                second
+                ~~~
+
+                Text after.
+                '''
+            ),
+            self.dedent(
+                '''
+                <p>Text before.</p>
+                <pre><code class="language-python">first = 1
+                </code></pre>
+                <p>Text between.</p>
+                <pre><code>second
+                </code></pre>
+                <p>Text after.</p>
+                '''
+            ),
+            extensions=['fenced_code']
+        )
+
+    def testAdjacentFencedBlocks(self):
+        # The second block opens on the line right after the first one closes.
+        self.assertMarkdownRenders(
+            self.dedent(
+                '''
+                ```
+                first
+                ```
+                ~~~
+                second
+                ~~~
+                '''
+            ),
+            self.dedent(
+                '''
+                <pre><code>first
+                </code></pre>
+                <pre><code>second
+                </code></pre>
+                '''
+            ),
+            extensions=['fenced_code']
+        )
+
+    def testFencedBlockAtEndWithoutNewline(self):
+        self.assertMarkdownRenders(
+            'Text.\n\n```\ncode\n```',
+            '<p>Text.</p>\n<pre><code>code\n</code></pre>',
+            extensions=['fenced_code']
+        )
+
+    def testManyFencedBlocks(self):
+        self.assertMarkdownRenders(
+            '\n\n'.join(f'Paragraph {i}.\n\n```\nblock {i}\n```' for i in range(50)),
+            '\n'.join(f'<p>Paragraph {i}.</p>\n<pre><code>block {i}\n</code></pre>' for i in range(50)),
+            extensions=['fenced_code']
+        )
+
 
 class TestFencedCodeWithCodehilite(TestCase):