Stop definition list nesting short of the recursion limit

DefListProcessor.run calls parseBlocks on the definition content, which
can contain further definitions, so a document of flat term/definition
pairs without blank lines nests once per pair and raises an uncaught
RecursionError from only ~5 KB of input.

DefListProcessor.test now declines to run near the recursion limit, the
same guard BlockquoteProcessor already uses; the remaining markers are
kept as text.

Fixes #1700.

Author: rahul05ranjan

docs/changelog.md

@@ -24,6 +24,9 @@ See the [Contributing Guide](contributing.md) for details.
   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).
+* Stop definition list nesting short of the recursion limit, so deeply nested
+  definitions are kept as text instead of raising an uncaught
+  `RecursionError` (#1700).
 
 ## [3.11.3] - 2026-11-05
 

markdown/extensions/def_list.py

@@ -23,6 +23,7 @@
 
 from . import Extension
 from ..blockprocessors import BlockProcessor, ListIndentProcessor
+from .. import util
 import xml.etree.ElementTree as etree
 import re
 
@@ -34,7 +35,10 @@ class DefListProcessor(BlockProcessor):
     NO_INDENT_RE = re.compile(r'^[ ]{0,3}[^ :]')
 
     def test(self, parent: etree.Element, block: str) -> bool:
-        return bool(self.RE.search(block))
+        # A definition calls `parseBlocks` on its content, which can contain
+        # further definitions, so the nesting has to stop short of the
+        # interpreter's limit, as it does for blockquotes and lists.
+        return bool(self.RE.search(block)) and not util.nearing_recursion_limit()
 
     def run(self, parent: etree.Element, blocks: list[str]) -> bool | None:
 

tests/test_syntax/extensions/test_def_list.py

@@ -19,7 +19,8 @@
 License: BSD (see LICENSE.md for details).
 """
 
-from markdown.test_tools import TestCase
+import markdown
+from markdown.test_tools import TestCase, recursionlimit
 
 
 class TestDefList(TestCase):
@@ -321,3 +322,46 @@ def test_def_list_nested_admontions(self):
             ),
             extensions=['def_list', 'admonition']
         )
+
+
+class TestDefListNestingLimit(TestCase):
+
+    # A definition calls `parseBlocks` on its content, which can contain
+    # further definitions, so the nesting has to stop short of the
+    # interpreter's limit. The remaining markers are kept as text, the same
+    # way a blockquote or a list keeps its markers.
+
+    def test_nesting_stops_short_of_the_recursion_limit(self):
+        # Ten levels of definitions is more than the limit below allows to nest.
+        with recursionlimit(120):
+            result = markdown.markdown('term\n: definition\n' * 10, extensions=['def_list'])
+
+        self.assertLess(result.count('<dl>'), 10)
+        self.assertIn('term', result)
+
+    def test_deeply_nested_definitions_do_not_raise(self):
+        # Around 5 KB of input, which raised `RecursionError` before the limit was applied.
+        result = markdown.markdown('term\n: definition\n' * 600, extensions=['def_list'])
+
+        self.assertIn('<dl>', result)
+        self.assertIn('term', result)
+
+    def test_shallow_definition_nesting_still_nests(self):
+        self.assertMarkdownRenders(
+            'term\n: definition\nterm2\n: definition2',
+            self.dedent(
+                """
+                <dl>
+                <dt>term</dt>
+                <dd>
+                <dl>
+                <dt>definition</dt>
+                <dt>term2</dt>
+                <dd>definition2</dd>
+                </dl>
+                </dd>
+                </dl>
+                """
+            ),
+            extensions=['def_list']
+        )