fix: escape literal emphasis markers in MarkdownRenderer

MarkdownRenderer.text() only escaped backticks, so a text token that is a
literal "*"/"_" emphasis delimiter was emitted unescaped and re-parsed as
emphasis on the round-trip. This silently changed the document's meaning,
violating the invariant asserted by TestMarkdownRendererRoundTrip
("reformatting valid Markdown must not change its meaning").

An escaped marker in the source (``\*not emphasis\*``) is stored by the
inline parser as bare "*" text tokens (the backslash is consumed and the
parser's internal no-emphasis flag is dropped before the AST). Re-emitting
those tokens without a backslash let them pair up again:

    reformat(r"\*not emphasis\*")  ->  "*not emphasis*"
    html(reformat(...))            ->  "<p><em>not emphasis</em></p>"   # was <p>*not emphasis*</p>

The same happened for "_", "**"/"__", and unmatched leftover markers.

Fix: in text(), if a text token consists entirely of "*"/"_" it is a
literal delimiter (an escaped marker or an unmatched leftover), so
backslash-escape each character. Prose punctuation such as "2 * 3" or
"snake_case" always arrives mixed with other characters, so it is left
untouched and is not over-escaped (guarded by the existing
test_prose_not_over_escaped and a new test_real_emphasis_not_over_escaped).

Added test_escaped_emphasis_markers and test_real_emphasis_not_over_escaped
to TestMarkdownRendererRoundTrip. The regression test fails without the
source change (asserts <em>...</em> reappears) and passes with it; full
suite 1122 passed, ruff check/format and mypy clean.

Author: Sanjays2402

docs/changes.rst

@@ -3,6 +3,12 @@ Changelog
 
 Here is the full history of mistune v3.
 
+Unreleased
+----------
+
+* Escape literal ``*``/``_`` emphasis markers in the Markdown renderer so
+  round-tripping escaped text does not re-introduce emphasis.
+
 Version 3.3.2
 -------------
 

src/mistune/renderers/markdown.py

@@ -40,9 +40,18 @@ def render_children(self, token: Dict[str, Any], state: BlockState) -> str:
         return self.render_tokens(children, state)
 
     def text(self, token: Dict[str, Any], state: BlockState) -> str:
+        raw = cast(str, token["raw"])
+        # a text token that is made up entirely of "*"/"_" is a literal
+        # emphasis delimiter -- either an escaped marker from the source
+        # (``\*``) or an unmatched leftover -- so every character must stay
+        # escaped, or it would re-parse as emphasis on the round-trip. Prose
+        # punctuation such as ``2 * 3`` or ``snake_case`` arrives mixed with
+        # other characters and is left untouched.
+        if raw and all(c in "*_" for c in raw):
+            return "".join("\\" + c for c in raw)
         # a backtick always opens a code span, so it must stay escaped to
         # survive a re-parse as literal text.
-        return cast(str, token["raw"]).replace("`", "\\`")
+        return raw.replace("`", "\\`")
 
     def emphasis(self, token: Dict[str, Any], state: BlockState) -> str:
         return "*" + self.render_children(token, state) + "*"

tests/test_renderers.py

@@ -46,6 +46,35 @@ def test_escaped_marker_inside_list_item(self):
     def test_escaped_backtick(self):
         self.assert_round_trip(r"\`not code\`" + "\n")
 
+    def test_escaped_emphasis_markers(self):
+        # an escaped "*"/"_" is a literal delimiter, not emphasis; re-emitting
+        # it unescaped would turn plain text back into <em>/<strong>
+        for text in (
+            r"\*not emphasis\*" + "\n",
+            r"\_not emphasis\_" + "\n",
+            r"\*\*not strong\*\*" + "\n",
+            r"\_\_not strong\_\_" + "\n",
+            r"a word\_with\_underscores" + "\n",
+            r"2 \* 3 \* 4" + "\n",
+            r"trailing star\*" + "\n",
+            r"\*leading star" + "\n",
+        ):
+            self.assert_round_trip(text)
+
+    def test_real_emphasis_not_over_escaped(self):
+        # genuine emphasis must survive untouched, and prose punctuation with
+        # spaces around a "*"/"_" must not gain stray backslashes
+        for text in (
+            "*emphasis*\n",
+            "**strong**\n",
+            "***both***\n",
+            "_under_ and __strong__\n",
+            "a *b* and _c_ mixed\n",
+            "2 * 3 = 6 and 4 * 5\n",
+            "snake_case_variable\n",
+        ):
+            self.assert_round_trip(text)
+
     def test_codespan_containing_backticks(self):
         # the delimiter must grow past any backtick run inside the code span,
         # and pad away a leading/trailing backtick, or the re-parse breaks