Only relax the indent bound when recompiling list break rules

`_compile_list_break_sc` rewrites the break specs so a list item's own indent
is accepted, by replacing the first literal "3" in each pattern. That assumes
the first "3" is always the leading ` {0,3}` bound. It is, for every rule that
has one -- but a fenced directive's spec has no indent prefix, so its first "3"
is the marker-run quantifier:

    ^(?P<fenced_directive_mark>(?::){3,})\{[a-zA-Z0-9_-]+\}

Inside a `- ` item that becomes `(?::){1,}`, so a single marker opens a
directive. With `FencedDirective(..., markers=":")`, `:{note}` on its own line
is literal text at the top level and inside a `100. ` item, but inside a `- `
item it is swallowed and an admonition is fabricated:

    - item
    :{note}
    lazy

    <ul><li>item</li></ul>
    <section class="admonition note">...<p>lazy</p></section>

Anchor the replacement to the ` {0,3}` substring instead. Rules that have an
indent prefix compile identically to before; rules that don't are left alone.
The default markers are unaffected -- they take the `fenced_code` path, which
registers no `fenced_directive` spec.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: chuenchen309

src/mistune/list_parser.py

@@ -233,8 +233,11 @@ def _build_list_item_source(text: str, src: str, continue_width: int) -> str:
 def _compile_list_break_sc(block: "BlockParser", leading_width: int) -> Pattern[str]:
     pairs = [(name, block.specification[name]) for name in _get_list_break_rules(block)]
     if leading_width < 3:
-        _repl_w = str(leading_width)
-        pairs = [(n, p.replace("3", _repl_w, 1)) for n, p in pairs]
+        # Relax the leading indent bound only. Matching on a bare "3" would
+        # rewrite the first quantifier of any rule that has no indent prefix --
+        # e.g. a fenced directive's "{3,}" marker run.
+        _repl = " {0,%d}" % leading_width
+        pairs = [(n, p.replace(" {0,3}", _repl, 1)) for n, p in pairs]
 
     regex = "|".join(r"(?P<%s>(?<=\n)%s)" % pair for pair in pairs)
     return re.compile(regex, re.M)

tests/test_directives.py

@@ -76,6 +76,29 @@ def test_colon_fenced_toc(self):
         self.assertIn('<a href="#t-1">h1</a>', html)
 
 
+class TestFencedDirectiveInList(BaseTestCase):
+    md = create_markdown(  # type: ignore[list-item]
+        escape=False,
+        plugins=[FencedDirective([Admonition()], markers=":")],
+    )
+
+    def test_marker_run_below_fence_length_is_not_a_directive(self):
+        # A directive needs three or more markers, inside a list item as well
+        # as outside one. The list break rules are recompiled per item, and a
+        # marker run shorter than the fence must stay literal text.
+        for text in (":{note}\nlazy\n", "100. item\n:{note}\nlazy\n"):
+            self.assertNotIn("admonition", self.md(text))
+
+        html = self.md("- item\n:{note}\nlazy\n")
+        self.assertNotIn("admonition", html)
+        self.assertIn(":{note}", html)
+
+    def test_directive_still_breaks_a_list(self):
+        html = self.md("- item\n:::{note}\nbody\n:::\n")
+        self.assertIn('<section class="admonition note">', html)
+        self.assertIn("<p>body</p>", html)
+
+
 class TestDirectiveInclude(BaseTestCase):
     md = create_markdown(escape=False, plugins=[RSTDirective([Include()])])  # type: ignore[list-item]