fix: escape a literal backslash in a text token

MarkdownRenderer.text() re-emitted a literal backslash bare, so a re-parse
consumed it as an escape for whatever followed. KaTeX's "\\(2^n\\)" came back
as "(2^n)", and a backslash ending a line turned into a hard line break.

Escape it first, ahead of the "*"/"_" and backtick escapes, the way
_escape_title() already does for the same reason. The escape is unconditional:
parse_escape gives each escaped character its own text token, so by then there
is no following character to condition on, and a lookahead rule misses the
reported case entirely.

The cost is a backslash that would not have been consumed being doubled too,
so a Windows path is re-emitted with doubled separators. One of the 652
bundled CommonMark examples changes this way. Over that corpus, meaning-
changing round-trips drop from 85 to 79 with none newly broken.

Reported by kbulygin on #480.

Author: hdimer

src/mistune/renderers/markdown.py

@@ -45,6 +45,10 @@ def render_children(self, token: Dict[str, Any], state: BlockState) -> str:
 
     def text(self, token: Dict[str, Any], state: BlockState) -> str:
         raw = cast(str, token["raw"])
+        # a backslash in a text token is literal and must stay escaped, or the
+        # re-parse consumes it (``\\(`` comes back as ``(``). Each escape is its
+        # own token, so there is no neighbour here to make this conditional on.
+        raw = raw.replace("\\", "\\\\")
         # "*"/"_" in a text token are literal -- an escaped marker from the
         # source (``\*``) or an unmatched leftover -- and must stay escaped, or
         # they would re-parse as emphasis on the round-trip.

tests/test_renderers.py

@@ -46,6 +46,18 @@ def test_escaped_marker_inside_list_item(self):
     def test_escaped_backtick(self):
         self.assert_round_trip(r"\`not code\`" + "\n")
 
+    def test_escaped_backslash(self):
+        # a literal backslash was re-emitted bare and the re-parse consumed it
+        # as an escape for the character behind it: KaTeX's "\\(...\\)" came back
+        # as plain "(...)", and one ending a line became a hard line break
+        for text in (
+            r"(2) \\(2^n\\)" + "\n",
+            r"a *b* c \\(d\\) e" + "\n",
+            r"escaped \\\\ pair" + "\n",
+            "para line one " + r"\\" + "\nline two\n",
+        ):
+            self.assert_round_trip(text)
+
     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>