Fix smart dash conversion escaping HTML comments and tags

Protect HTML comments (<!-- -->), multi-line comments, and HTML tags
from -- → en-dash and --- → em-dash conversion using the existing
placeholder mechanism. Bump version to 0.4.1.

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

Author: jdmonaco

mdformat_space_control/__init__.py

@@ -1,6 +1,6 @@
 """An mdformat plugin for space control: EditorConfig indentation, tight lists, frontmatter spacing, smart dash conversion, explicit line breaks, and wikilinks."""
 
-__version__ = "0.4.0"
+__version__ = "0.4.1"
 
 from .config import (
     get_current_file,

mdformat_space_control/plugin.py

@@ -391,7 +391,8 @@ def _convert_dash_sequences(text: str) -> str:
     """Convert markdown dash sequences to Unicode em-dash and en-dash.
 
     Converts ``---`` to em-dash (U+2014) and ``--`` to en-dash (U+2013).
-    Preserves dashes inside fenced code blocks and inline code spans.
+    Preserves dashes inside fenced code blocks, inline code spans,
+    HTML comments, and HTML tags.
     Skips lines that are only dashes (thematic breaks, frontmatter delimiters).
 
     Em-dash is matched first (longer sequence) to prevent ``---`` from being
@@ -400,6 +401,10 @@ def _convert_dash_sequences(text: str) -> str:
     # Patterns for inline code span placeholders
     inline_code_re = re.compile(r"(`+)(.+?)\1")
 
+    # HTML protection patterns
+    html_comment_re = re.compile(r"<!--.*?-->")
+    html_tag_re = re.compile(r"<[^>]+>")
+
     # Dash conversion patterns: negative lookahead/behind prevent matching
     # 4+ dash sequences (e.g., ---- horizontal rules in some contexts)
     em_dash_re = re.compile(r"(?<!-)---(?!-)")
@@ -411,6 +416,7 @@ def _convert_dash_sequences(text: str) -> str:
     lines = text.split("\n")
     result = []
     in_code_block = False
+    in_html_comment = False
 
     for line in lines:
         stripped = line.lstrip()
@@ -419,23 +425,38 @@ def _convert_dash_sequences(text: str) -> str:
             result.append(line)
         elif in_code_block:
             result.append(line)
+        elif in_html_comment:
+            # Inside a multi-line HTML comment, skip dash conversion
+            if "-->" in line:
+                in_html_comment = False
+            result.append(line)
         elif only_dashes_re.match(line):
             result.append(line)
         else:
-            # Protect inline code spans with placeholders
+            # Check for multi-line HTML comment opening (no closing on same line)
+            if "<!--" in line and "-->" not in line:
+                in_html_comment = True
+                result.append(line)
+                continue
+
+            # Protect inline code spans and HTML elements with placeholders
             placeholders = []
 
-            def _save_code_span(m: re.Match) -> str:
+            def _save_placeholder(m: re.Match) -> str:
                 placeholders.append(m.group(0))
                 return f"\x00CODE{len(placeholders) - 1}\x00"
 
-            protected = inline_code_re.sub(_save_code_span, line)
+            protected = inline_code_re.sub(_save_placeholder, line)
+
+            # Protect HTML comments first (longer matches), then tags
+            protected = html_comment_re.sub(_save_placeholder, protected)
+            protected = html_tag_re.sub(_save_placeholder, protected)
 
             # Convert em-dash first (longer match), then en-dash
             protected = em_dash_re.sub("\u2014", protected)
             protected = en_dash_re.sub("\u2013", protected)
 
-            # Restore inline code spans
+            # Restore placeholders
             for i, original in enumerate(placeholders):
                 protected = protected.replace(f"\x00CODE{i}\x00", original)
 

tests/test_dash_conversion.py

@@ -275,3 +275,113 @@ def test_empty_string(self):
         from mdformat_space_control.plugin import _convert_dash_sequences
 
         assert _convert_dash_sequences("") == ""
+
+    def test_html_comment_preserved(self):
+        """Direct function test: HTML comments are preserved."""
+        from mdformat_space_control.plugin import _convert_dash_sequences
+
+        assert _convert_dash_sequences("<!-- comment -->") == "<!-- comment -->"
+
+    def test_html_triple_dash_comment_preserved(self):
+        """Direct function test: triple-dash HTML comments are preserved."""
+        from mdformat_space_control.plugin import _convert_dash_sequences
+
+        assert _convert_dash_sequences("<!--- comment --->") == "<!--- comment --->"
+
+    def test_html_tag_with_dashes_preserved(self):
+        """Direct function test: HTML tags with dash attributes are preserved."""
+        from mdformat_space_control.plugin import _convert_dash_sequences
+
+        text = '<div data-value="test--value">'
+        assert _convert_dash_sequences(text) == text
+
+    def test_html_self_closing_tag_preserved(self):
+        """Direct function test: self-closing HTML tags with dashes preserved."""
+        from mdformat_space_control.plugin import _convert_dash_sequences
+
+        text = '<img alt="a--b" />'
+        assert _convert_dash_sequences(text) == text
+
+    def test_html_comment_with_surrounding_dashes(self):
+        """Direct function test: dashes outside HTML convert, inside preserved."""
+        from mdformat_space_control.plugin import _convert_dash_sequences
+
+        text = "word--word <!-- comment --> word---word"
+        expected = "word\u2013word <!-- comment --> word\u2014word"
+        assert _convert_dash_sequences(text) == expected
+
+    def test_multiline_html_comment_preserved(self):
+        """Direct function test: multi-line HTML comments are preserved."""
+        from mdformat_space_control.plugin import _convert_dash_sequences
+
+        text = "<!--\ncomment with--dashes\n-->"
+        assert _convert_dash_sequences(text) == text
+
+    def test_multiline_html_comment_with_surrounding_text(self):
+        """Direct function test: text around multi-line HTML comment converts."""
+        from mdformat_space_control.plugin import _convert_dash_sequences
+
+        text = "before--after\n<!--\ncomment--here\n-->\nmore--text"
+        expected = "before\u2013after\n<!--\ncomment--here\n-->\nmore\u2013text"
+        assert _convert_dash_sequences(text) == expected
+
+
+class TestDashConversionHTML:
+    """Tests for HTML comment and tag preservation through mdformat."""
+
+    def test_single_line_html_comment(self):
+        """Single-line HTML comment should be preserved."""
+        input_text = "<!-- comment -->\n"
+        result = mdformat.text(input_text, extensions={"space_control"})
+        assert "<!--" in result
+        assert "-->" in result
+        assert "\u2013" not in result
+        assert "\u2014" not in result
+
+    def test_triple_dash_comment(self):
+        """Triple-dash HTML comment should be preserved."""
+        input_text = "<!--- comment --->\n"
+        result = mdformat.text(input_text, extensions={"space_control"})
+        assert "<!---" in result
+        assert "--->" in result
+        assert "\u2014" not in result
+
+    def test_block_level_html_comment(self):
+        """Block-level HTML comment (own paragraph) should be preserved."""
+        input_text = "Text.\n\n<!-- block comment -->\n\nMore text.\n"
+        result = mdformat.text(input_text, extensions={"space_control"})
+        assert "<!-- block comment -->" in result
+
+    def test_inline_html_comment_with_dashes(self):
+        """Dashes outside HTML comment convert; comment preserved."""
+        input_text = "Text--here <!-- comment --> more---text.\n"
+        result = mdformat.text(input_text, extensions={"space_control"})
+        assert "<!-- comment -->" in result
+        assert "\u2013" in result  # en-dash from --
+        assert "\u2014" in result  # em-dash from ---
+
+    def test_multi_line_html_comment(self):
+        """Multi-line HTML comment should be preserved."""
+        input_text = "Text.\n\n<!--\ncomment with--dashes\n-->\n\nMore text.\n"
+        result = mdformat.text(input_text, extensions={"space_control"})
+        assert "\u2013" not in result
+        assert "\u2014" not in result
+
+    def test_html_tag_with_dash_attributes(self):
+        """HTML tags with dash-containing attributes should be preserved."""
+        input_text = '<div data-value="test--value">\n\nContent.\n\n</div>\n'
+        result = mdformat.text(input_text, extensions={"space_control"})
+        assert 'data-value="test--value"' in result
+
+    def test_self_closing_tag_with_dashes(self):
+        """Self-closing HTML tags with dashes should be preserved."""
+        input_text = '<img alt="a--b" />\n'
+        result = mdformat.text(input_text, extensions={"space_control"})
+        assert 'alt="a--b"' in result
+
+    def test_dashes_outside_html_still_convert(self):
+        """Dashes outside HTML elements should still convert normally."""
+        input_text = "word--word and word---word\n"
+        expected = "word\u2013word and word\u2014word\n"
+        result = mdformat.text(input_text, extensions={"space_control"})
+        assert result == expected