mdsyntax 0.2.0__tar.gz → 0.3.0__tar.gz

{mdsyntax-0.2.0 → mdsyntax-0.3.0}/.github/workflows/ci.yml

@@ -46,7 +46,9 @@ jobs:
           pip install ruff
 
       - name: Run ruff
-        run: ruff check src/
+        run: |
+          ruff check src/ tests/
+          ruff format --check src/ tests/
 
   build:
     runs-on: ubuntu-latest

{mdsyntax-0.2.0 → mdsyntax-0.3.0}/.gitignore

@@ -54,3 +54,6 @@ Thumbs.db
 # Local development
 *.local
 .env
+
+# Claude Code local settings
+.claude/

mdsyntax-0.3.0/CHANGELOG.md

@@ -0,0 +1,81 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.3.0] - 2026-09-06
+
+### Fixed
+
+- Links following bold, italic, or strikethrough text on the same line no longer
+  produce corrupted escape sequences; links are now isolated before emphasis
+  processing
+- URLs containing `__` or `*` (for example `#object.__init__`) are no longer
+  mangled by emphasis rules
+- Code block background no longer disappears mid-line for styles with bold or
+  italic tokens (dracula, one-dark, nord, github-dark, default, ...)
+- CLI reads files and stdin as UTF-8 and writes UTF-8 to stdout, fixing
+  mojibake and `UnicodeEncodeError` on Windows when output is piped
+- CLI reports an unknown `--style` as a one-line error (exit code 2) instead of
+  a traceback; `SyntaxHighlighter` and `MarkdownRenderer` raise `ValueError`
+- 256-color mode (`true_color=False`) no longer emits 24-bit escapes for the
+  code block background, blockquotes, or link URLs
+- Code block padding accounts for wide (CJK, emoji) and combining characters;
+  tabs are expanded to four spaces
+- Spaced asterisks such as `2 * 3 * 4` are no longer rendered as italic
+- Fenced code blocks honour fence length, so a four-backtick fence can contain
+  a three-backtick fence; `~~~` fences are supported
+- Header and blockquote colors are restored after inline code and links
+- Link URLs use a muted color instead of dim, so a link inside bold text no
+  longer switches bold off early
+
+### Changed
+
+- Package version is read from `mdsyntax.__version__` at build time
+- Project metadata (author, URLs) now points at the real repository
+
+## [0.2.0] - 2025-12-31
+
+### Added
+
+- New `Style` class for styling arbitrary text
+  - Static methods: `Style.bold_text()`, `Style.italic_text()`, `Style.color()`, etc.
+  - Chainable API: `style("text").bold().italic().fg("red")`
+- RGB color support via `Style.color(text, fg=(255, 0, 0))`
+- `Ansi` class now exported for direct access to ANSI codes
+
+### Changed
+
+- Switched from `colorama.init(autoreset=True)` to `colorama.just_fix_windows_console()` for better compatibility
+- Code blocks now expand width to fit long lines instead of truncating
+- Use targeted ANSI resets instead of full reset for better style preservation
+
+### Fixed
+
+- Inline code in blockquotes no longer breaks italic styling for subsequent text
+- Code block width now properly constrains content
+
+## [0.1.1] - 2025-12-24
+
+### Changed
+
+- Version bump; no functional changes
+
+## [0.1.0] - 2025-12-24
+
+### Added
+
+- Initial release
+- Markdown rendering with ANSI formatting
+- Syntax highlighting for code blocks (powered by Pygments)
+- Support for headers, bold, italic, strikethrough, inline code
+- Support for lists (ordered, unordered, task lists)
+- Support for blockquotes and horizontal rules
+- Support for links
+- CLI tool (`mdsyntax`)
+- Auto-detection of 24-bit true color support
+- Configurable code block styling and width

{mdsyntax-0.2.0 → mdsyntax-0.3.0}/CONTRIBUTING.md

@@ -6,7 +6,7 @@ Thanks for your interest in contributing!
 
 1. Clone the repository:
    ```bash
-   git clone https://github.com/yourusername/mdsyntax.git
+   git clone https://github.com/Azaias/mdsyntax.git
    cd mdsyntax
    ```
 
@@ -33,8 +33,8 @@ This project uses [ruff](https://github.com/astral-sh/ruff) for linting:
 
 ```bash
 pip install ruff
-ruff check src/
-ruff format src/
+ruff check src/ tests/
+ruff format src/ tests/
 ```
 
 ## Submitting Changes

{mdsyntax-0.2.0 → mdsyntax-0.3.0}/PKG-INFO

@@ -1,11 +1,11 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: mdsyntax
-Version: 0.2.0
+Version: 0.3.0
 Summary: Render markdown with syntax highlighting in the terminal
-Project-URL: Homepage, https://github.com/yourusername/mdsyntax
-Project-URL: Repository, https://github.com/yourusername/mdsyntax
-Project-URL: Issues, https://github.com/yourusername/mdsyntax/issues
-Author-email: Your Name <you@example.com>
+Project-URL: Homepage, https://github.com/Azaias/mdsyntax
+Project-URL: Repository, https://github.com/Azaias/mdsyntax
+Project-URL: Issues, https://github.com/Azaias/mdsyntax/issues
+Author-email: Izaiah Meyer <lolduderlly@gmail.com>
 License-Expression: MIT
 License-File: LICENSE
 Keywords: ansi,cli,console,markdown,syntax-highlighting,terminal
@@ -51,7 +51,7 @@ pip install mdsyntax
 
 ### Python API
 
-```python
+````python
 from mdsyntax import md_print, md_render
 
 # Print directly to terminal
@@ -68,7 +68,7 @@ def greet(name):
 
 # Get ANSI string for further processing
 output = md_render("Some `inline code` here")
-```
+````
 
 ### Command Line
 

{mdsyntax-0.2.0 → mdsyntax-0.3.0}/README.md

@@ -17,7 +17,7 @@ pip install mdsyntax
 
 ### Python API
 
-```python
+````python
 from mdsyntax import md_print, md_render
 
 # Print directly to terminal
@@ -34,7 +34,7 @@ def greet(name):
 
 # Get ANSI string for further processing
 output = md_render("Some `inline code` here")
-```
+````
 
 ### Command Line
 

{mdsyntax-0.2.0 → mdsyntax-0.3.0}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mdsyntax"
-version = "0.2.0"
+dynamic = ["version"]
 description = "Render markdown with syntax highlighting in the terminal"
 readme = "README.md"
 license = "MIT"
 requires-python = ">=3.10"
 authors = [
-    { name = "Your Name", email = "you@example.com" }
+    { name = "Izaiah Meyer", email = "lolduderlly@gmail.com" }
 ]
 keywords = [
     "markdown",
@@ -49,13 +49,16 @@ dev = [
 ]
 
 [project.urls]
-Homepage = "https://github.com/yourusername/mdsyntax"
-Repository = "https://github.com/yourusername/mdsyntax"
-Issues = "https://github.com/yourusername/mdsyntax/issues"
+Homepage = "https://github.com/Azaias/mdsyntax"
+Repository = "https://github.com/Azaias/mdsyntax"
+Issues = "https://github.com/Azaias/mdsyntax/issues"
 
 [project.scripts]
 mdsyntax = "mdsyntax.cli:main"
 
+[tool.hatch.version]
+path = "src/mdsyntax/__init__.py"
+
 [tool.hatch.build.targets.wheel]
 packages = ["src/mdsyntax"]
 

{mdsyntax-0.2.0 → mdsyntax-0.3.0}/src/mdsyntax/__init__.py

@@ -23,7 +23,7 @@ from mdsyntax.renderer import (
     style,
 )
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"
 __all__ = [
     "md_print",
     "md_render",

{mdsyntax-0.2.0 → mdsyntax-0.3.0}/src/mdsyntax/cli.py

@@ -1,16 +1,34 @@
-"""Command-line interface for md-print."""
+"""Command-line interface for mdsyntax."""
 
 from __future__ import annotations
 
 import argparse
 import sys
+from typing import IO
 
 from mdsyntax import __version__, md_print
 from mdsyntax.renderer import SyntaxHighlighter
 
 
+def _use_utf8(stream: IO[str]) -> None:
+    """Switch a text stream to UTF-8 regardless of the platform locale.
+
+    On Windows the default encoding for redirected or piped streams is the
+    legacy code page, which cannot represent the box-drawing and bullet
+    characters this tool emits.  Markdown is UTF-8 in practice, so read it
+    that way too.
+    """
+    try:
+        stream.reconfigure(encoding="utf-8", errors="replace")  # type: ignore[attr-defined]
+    except (AttributeError, ValueError, OSError):
+        pass
+
+
 def main(argv: list[str] | None = None) -> int:
     """Main CLI entry point."""
+    _use_utf8(sys.stdin)
+    _use_utf8(sys.stdout)
+
     parser = argparse.ArgumentParser(
         prog="mdsyntax",
         description="Render markdown with syntax highlighting in the terminal.",
@@ -18,7 +36,7 @@ def main(argv: list[str] | None = None) -> int:
     parser.add_argument(
         "file",
         nargs="?",
-        type=argparse.FileType("r"),
+        type=argparse.FileType("r", encoding="utf-8", errors="replace"),
         default=sys.stdin,
         help="Markdown file to render (default: stdin)",
     )
@@ -68,12 +86,17 @@ def main(argv: list[str] | None = None) -> int:
 
     true_color = None if not args.no_true_color else False
 
-    md_print(
-        text,
-        code_style=args.style,
-        code_width=args.width,
-        true_color=true_color,
-    )
+    try:
+        md_print(
+            text,
+            code_style=args.style,
+            code_width=args.width,
+            true_color=true_color,
+        )
+    except ValueError as exc:
+        print(f"mdsyntax: error: {exc}", file=sys.stderr)
+        print("Run 'mdsyntax --list-styles' to see valid style names.", file=sys.stderr)
+        return 2
 
     return 0
 

{mdsyntax-0.2.0 → mdsyntax-0.3.0}/src/mdsyntax/renderer.py

@@ -7,6 +7,7 @@ from __future__ import annotations
 import os
 import re
 import shutil
+import unicodedata
 from collections.abc import Iterator
 from dataclasses import dataclass, field
 from typing import Literal
@@ -16,6 +17,7 @@ from pygments import highlight
 from pygments.formatters import Terminal256Formatter, TerminalTrueColorFormatter
 from pygments.lexers import TextLexer, get_lexer_by_name, guess_lexer
 from pygments.styles import get_all_styles, get_style_by_name
+from pygments.util import ClassNotFound
 
 just_fix_windows_console()
 
@@ -254,48 +256,104 @@ def _detect_true_color() -> bool:
     return colorterm in ("truecolor", "24bit")
 
 
-def _get_style_bg(style_name: str) -> str:
+_ANSI_RE = re.compile(r"\033\[[0-9;]*m")
+
+_MUTED_RGB = (180, 180, 180)
+
+
+def _rgb_to_256(r: int, g: int, b: int) -> int:
+    """Nearest xterm-256 palette index for an RGB triple."""
+    steps = (0, 95, 135, 175, 215, 255)
+
+    def nearest_step(v: int) -> int:
+        return min(range(6), key=lambda i: abs(steps[i] - v))
+
+    ri, gi, bi = nearest_step(r), nearest_step(g), nearest_step(b)
+    cube = (steps[ri], steps[gi], steps[bi])
+
+    gray_idx = max(0, min(23, round(((r + g + b) / 3 - 8) / 10)))
+    gray = 8 + gray_idx * 10
+
+    def dist(c: tuple[int, int, int]) -> int:
+        return (c[0] - r) ** 2 + (c[1] - g) ** 2 + (c[2] - b) ** 2
+
+    if dist((gray, gray, gray)) < dist(cube):
+        return 232 + gray_idx
+    return 16 + 36 * ri + 6 * gi + bi
+
+
+def _fg_code(rgb: tuple[int, int, int], true_color: bool) -> str:
+    """Foreground escape for an RGB color, degraded to 256 colors if needed."""
+    if true_color:
+        return Ansi.rgb_fg(*rgb)
+    return f"\033[38;5;{_rgb_to_256(*rgb)}m"
+
+
+def _bg_code(rgb: tuple[int, int, int], true_color: bool) -> str:
+    """Background escape for an RGB color, degraded to 256 colors if needed."""
+    if true_color:
+        return Ansi.rgb_bg(*rgb)
+    return f"\033[48;5;{_rgb_to_256(*rgb)}m"
+
+
+def _get_style_bg(style_name: str, true_color: bool = True) -> str:
     """Extract background color from pygments style as ANSI escape."""
     try:
         style = get_style_by_name(style_name)
         bg = style.background_color
         if bg and bg.startswith("#") and len(bg) == 7:
-            r, g, b = int(bg[1:3], 16), int(bg[3:5], 16), int(bg[5:7], 16)
-            return f"\033[48;2;{r};{g};{b}m"
+            rgb = (int(bg[1:3], 16), int(bg[3:5], 16), int(bg[5:7], 16))
+            return _bg_code(rgb, true_color)
     except Exception:
         pass
     return "\033[48;5;236m"  # fallback gray
 
 
-def _visible_len(s: str) -> int:
-    """Length of string excluding ANSI escape sequences."""
-    return len(re.sub(r"\033\[[0-9;]*m", "", s))
+def _is_full_reset(seq: str) -> bool:
+    """True if an SGR escape sequence contains a full attribute reset (SGR 0)."""
+    body = seq[2:-1]
+    params = body.split(";") if body else [""]
+    i = 0
+    while i < len(params):
+        p = params[i]
+        if p in ("", "0", "00"):
+            return True
+        # Skip the arguments of extended color sequences: 38;5;N / 38;2;R;G;B
+        if p in ("38", "48", "58") and i + 1 < len(params):
+            if params[i + 1] == "5":
+                i += 3
+                continue
+            if params[i + 1] == "2":
+                i += 5
+                continue
+        i += 1
+    return False
 
 
-def _truncate_to_width(text: str, width: int, indicator: str = "…") -> str:
-    """Truncate string to visible width, accounting for ANSI codes."""
-    if _visible_len(text) <= width:
-        return text
+def _reapply_after_reset(text: str, codes: str) -> str:
+    """Re-emit ``codes`` after every full SGR reset in ``text``.
 
-    # We need to truncate while preserving ANSI codes
-    result = []
-    visible_count = 0
-    target = width - len(indicator)
-    i = 0
+    Pygments terminates bold/italic tokens with SGR 0, which would otherwise
+    wipe out the code block background for the rest of the line.
+    """
+    return _ANSI_RE.sub(
+        lambda m: m.group(0) + codes if _is_full_reset(m.group(0)) else m.group(0),
+        text,
+    )
+
+
+def _char_width(ch: str) -> int:
+    """Terminal column width of a single character."""
+    if unicodedata.combining(ch) or unicodedata.category(ch) in ("Mn", "Me", "Cf"):
+        return 0
+    if unicodedata.east_asian_width(ch) in ("W", "F"):
+        return 2
+    return 1
 
-    while i < len(text) and visible_count < target:
-        if text[i] == "\033":
-            # Capture entire ANSI sequence
-            end = text.find("m", i)
-            if end != -1:
-                result.append(text[i : end + 1])
-                i = end + 1
-                continue
-        result.append(text[i])
-        visible_count += 1
-        i += 1
 
-    return "".join(result) + indicator
+def _visible_len(s: str) -> int:
+    """Terminal column width of a string, excluding ANSI escape sequences."""
+    return sum(_char_width(ch) for ch in _ANSI_RE.sub("", s))
 
 
 def _pad_to_width(text: str, width: int) -> str:
@@ -304,12 +362,6 @@ def _pad_to_width(text: str, width: int) -> str:
     return text + " " * max(0, padding)
 
 
-def _fit_to_width(text: str, width: int) -> str:
-    """Truncate if too long, then pad to exact width."""
-    truncated = _truncate_to_width(text, width)
-    return _pad_to_width(truncated, width)
-
-
 def _max_visible_width(lines: list[str]) -> int:
     """Get the maximum visible width across all lines."""
     if not lines:
@@ -332,8 +384,15 @@ class SyntaxHighlighter:
         formatter_cls = (
             TerminalTrueColorFormatter if true_color else Terminal256Formatter
         )
-        self.formatter = formatter_cls(style=style)
+        try:
+            self.formatter = formatter_cls(style=style)
+        except ClassNotFound:
+            raise ValueError(
+                f"Unknown syntax highlighting style: {style!r}. "
+                "See SyntaxHighlighter.available_styles() for valid names."
+            ) from None
         self.style = style
+        self.true_color = true_color
 
     def highlight(self, code: str, language: str = "") -> str:
         """Highlight code and return ANSI-formatted string."""
@@ -360,6 +419,19 @@ class SyntaxHighlighter:
         return list(get_all_styles())
 
 
+_FENCE_RE = re.compile(r"^(`{3,}|~{3,})(.*)$")
+
+
+def _closes_fence(line: str, marker: str) -> bool:
+    """True if ``line`` is a closing fence for a block opened with ``marker``.
+
+    Per CommonMark the closing fence must use the same character and be at
+    least as long as the opening fence, with nothing else on the line.
+    """
+    stripped = line.strip()
+    return len(stripped) >= len(marker) and set(stripped) == {marker[0]}
+
+
 # =============================================================================
 # Markdown Rendering
 # =============================================================================
@@ -375,12 +447,15 @@ class MarkdownRenderer:
 
     _highlighter: SyntaxHighlighter = field(init=False, repr=False)
     _code_bg: str = field(init=False, repr=False)
+    _muted_fg: str = field(init=False, repr=False)
 
     def __post_init__(self):
         self._highlighter = SyntaxHighlighter(
             style=self.code_style, true_color=self.true_color
         )
-        self._code_bg = _get_style_bg(self.code_style)
+        true_color = self._highlighter.true_color
+        self._code_bg = _get_style_bg(self.code_style, true_color)
+        self._muted_fg = _fg_code(_MUTED_RGB, true_color)
 
     def render(self, text: str) -> str:
         """Render markdown text to ANSI-formatted string."""
@@ -397,18 +472,19 @@ class MarkdownRenderer:
             line = lines[i]
             stripped = line.strip()
 
-            # Code block
-            if stripped.startswith("```"):
-                lang = stripped[3:].strip()
+            # Fenced code block (``` or ~~~, any length >= 3)
+            if fence := _FENCE_RE.match(stripped):
+                marker = fence.group(1)
+                lang = fence.group(2).strip()
                 code_lines = []
                 i += 1
 
-                while i < len(lines) and not lines[i].strip().startswith("```"):
+                while i < len(lines) and not _closes_fence(lines[i], marker):
                     code_lines.append(lines[i])
                     i += 1
 
                 yield from self._render_code_block(code_lines, lang)
-                i += 1  # skip closing ```
+                i += 1  # skip closing fence
                 continue
 
             yield self._render_line(line)
@@ -427,9 +503,11 @@ class MarkdownRenderer:
         # Highlight code first to measure actual output width
         highlighted_lines: list[str] = []
         if code_lines:
-            code = "\n".join(code_lines)
+            code = "\n".join(line.expandtabs(4) for line in code_lines)
             highlighted = self._highlighter.highlight(code, language)
-            highlighted_lines = highlighted.split("\n")
+            highlighted_lines = [
+                _reapply_after_reset(line, bg) for line in highlighted.split("\n")
+            ]
 
         # Calculate width: use the largest of terminal width, specified width, or content width
         terminal_width = shutil.get_terminal_size().columns
@@ -474,9 +552,9 @@ class MarkdownRenderer:
         # Blockquotes
         if stripped.startswith(">"):
             content = stripped.lstrip(">").strip()
-            rendered = self._render_inline(content, parent_styles=[Ansi.ITALIC])
-            grey = Ansi.rgb_fg(180, 180, 180)
-            return f"{grey}│ {Ansi.ITALIC}{rendered}{Ansi.ITALIC_OFF}{Ansi.RESET}"
+            muted = self._muted_fg
+            rendered = self._render_inline(content, parent_styles=[muted, Ansi.ITALIC])
+            return f"{muted}│ {Ansi.ITALIC}{rendered}{Ansi.RESET}"
 
         # Task lists
         if m := re.match(r"^[-*]\s+\[([ xX])\]\s+(.+)$", stripped):
@@ -511,7 +589,7 @@ class MarkdownRenderer:
         # Visual prefix for h1-h3
         prefix = "█" * (4 - level) + " " if level <= 3 else ""
 
-        rendered_text = self._render_inline(text)
+        rendered_text = self._render_inline(text, parent_styles=[color, Ansi.BOLD])
         return f"{color}{Ansi.BOLD}{prefix}{rendered_text}{Ansi.RESET}"
 
     def _render_inline(self, text: str, parent_styles: list[str] | None = None) -> str:
@@ -519,69 +597,85 @@ class MarkdownRenderer:
         parent_styles = parent_styles or []
         restore = "".join(parent_styles)
 
-        # Order matters: process from most specific to least specific
+        # Fully rendered fragments are swapped out for placeholders so that
+        # neither their source text nor their escape codes are visible to the
+        # emphasis patterns below.  Placeholders contain no markdown syntax.
+        fragments: list[str] = []
 
-        # Inline code first (protects contents from further processing)
-        code_spans: list[str] = []
+        def stash(rendered: str) -> str:
+            fragments.append(rendered)
+            return f"\x00{len(fragments) - 1}\x00"
 
-        def extract_code(m):
-            # Use targeted reset: just reset bg/fg, then restore parent styles
-            code_content = f"{Ansi.BG_BLACK}{Ansi.FG_YELLOW} {m.group(1)} {Ansi.BG_DEFAULT}{Ansi.FG_DEFAULT}{restore}"
-            code_spans.append(code_content)
-            return f"\x00CODE{len(code_spans) - 1}\x00"
+        # Inline code first (protects contents from further processing)
+        def extract_code(m: re.Match[str]) -> str:
+            return stash(
+                f"{Ansi.BG_BLACK}{Ansi.FG_YELLOW} {m.group(1)} "
+                f"{Ansi.BG_DEFAULT}{Ansi.FG_DEFAULT}{restore}"
+            )
 
         text = re.sub(r"`([^`]+)`", extract_code, text)
 
+        # Links next: the URL must never be touched by emphasis rules, and the
+        # link's own escape codes contain "[" which would confuse this pattern
+        # if it ran later.
+        def extract_link(m: re.Match[str]) -> str:
+            label = self._render_inline(
+                m.group(1), parent_styles + [Ansi.UNDERLINE, Ansi.FG_BLUE]
+            )
+            return stash(
+                f"{Ansi.UNDERLINE}{Ansi.FG_BLUE}{label}"
+                f"{Ansi.UNDERLINE_OFF}{Ansi.FG_DEFAULT}{restore}"
+                f"{self._muted_fg} ({m.group(2)}){Ansi.FG_DEFAULT}{restore}"
+            )
+
+        text = re.sub(r"\[([^\]]+)\]\(([^)\s]+)\)", extract_link, text)
+
         # Bold + italic (must come before bold and italic)
         text = re.sub(
-            r"\*\*\*(.+?)\*\*\*",
-            lambda m: f"{Ansi.BOLD}{Ansi.ITALIC}{m.group(1)}{Ansi.ITALIC_OFF}{Ansi.BOLD_OFF}",
+            r"\*\*\*(?!\s)(.+?)(?<!\s)\*\*\*",
+            lambda m: (
+                f"{Ansi.BOLD}{Ansi.ITALIC}{m.group(1)}{Ansi.ITALIC_OFF}{Ansi.BOLD_OFF}"
+            ),
             text,
         )
 
         # Bold
         text = re.sub(
-            r"\*\*(.+?)\*\*",
+            r"\*\*(?!\s)(.+?)(?<!\s)\*\*",
             lambda m: f"{Ansi.BOLD}{m.group(1)}{Ansi.BOLD_OFF}",
             text,
         )
         text = re.sub(
-            r"__(.+?)__",
+            r"__(?!\s)(.+?)(?<!\s)__",
             lambda m: f"{Ansi.BOLD}{m.group(1)}{Ansi.BOLD_OFF}",
             text,
         )
 
-        # Italic with asterisks (works anywhere)
+        # Italic with asterisks; delimiters must hug the text, so "2 * 3 * 4"
+        # is left alone
         text = re.sub(
-            r"(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)",
+            r"(?<!\*)\*(?![\s*])(.+?)(?<![\s*])\*(?!\*)",
             lambda m: f"{Ansi.ITALIC}{m.group(1)}{Ansi.ITALIC_OFF}",
             text,
         )
 
         # Italic with underscores (only at word boundaries)
         text = re.sub(
-            r"(?<!\w)_(?!_)(.+?)(?<!_)_(?!\w)",
+            r"(?<!\w)_(?![\s_])(.+?)(?<![\s_])_(?!\w)",
             lambda m: f"{Ansi.ITALIC}{m.group(1)}{Ansi.ITALIC_OFF}",
             text,
         )
 
         # Strikethrough
         text = re.sub(
-            r"~~(.+?)~~",
+            r"~~(?!\s)(.+?)(?<!\s)~~",
             lambda m: f"{Ansi.STRIKETHROUGH}{m.group(1)}{Ansi.STRIKETHROUGH_OFF}",
             text,
         )
 
-        # Links - use targeted resets
-        text = re.sub(
-            r"\[([^\]]+)\]\(([^)]+)\)",
-            lambda m: f"{Ansi.UNDERLINE}{Ansi.FG_BLUE}{m.group(1)}{Ansi.UNDERLINE_OFF}{Ansi.FG_DEFAULT}{Ansi.DIM} ({m.group(2)}){Ansi.DIM_OFF}{restore}",
-            text,
-        )
-
-        # Restore code spans
-        for i, code in enumerate(code_spans):
-            text = text.replace(f"\x00CODE{i}\x00", code)
+        # Restore stashed fragments
+        for i, fragment in enumerate(fragments):
+            text = text.replace(f"\x00{i}\x00", fragment)
 
         return text
 

{mdsyntax-0.2.0 → mdsyntax-0.3.0}/tests/test_renderer.py

@@ -1,7 +1,10 @@
 """Tests for mdsyntax."""
 
+import io
 import re
 
+import pytest
+
 from mdsyntax import (
     LANG_ALIASES,
     Ansi,
@@ -11,6 +14,8 @@ from mdsyntax import (
     md_render,
     style,
 )
+from mdsyntax.cli import main as cli_main
+from mdsyntax.renderer import _rgb_to_256, _visible_len
 
 
 def strip_ansi(text: str) -> str:
@@ -142,8 +147,8 @@ class TestBlockFormatting:
         # The long line should be fully present (not truncated)
         assert long_line in plain
         # All lines should be padded to the same width (the longest line's width)
-        lines = [l for l in plain.split("\n") if l.strip()]
-        widths = [len(l) for l in lines]
+        lines = [line for line in plain.split("\n") if line.strip()]
+        widths = [len(line) for line in lines]
         assert all(w == widths[0] for w in widths), "All lines should have same width"
         assert widths[0] >= 100, "Width should expand to fit content"
 
@@ -293,3 +298,181 @@ class TestStyleAPI:
     def test_empty_style(self):
         s = Style("plain")
         assert str(s) == "plain"
+
+
+class TestLinksAndEmphasis:
+    """Regression tests: links must be isolated from emphasis processing."""
+
+    @pytest.mark.parametrize(
+        "src",
+        [
+            "**bold** then [x](y)",
+            "*i* then [x](y)",
+            "~~s~~ [x](y)",
+            "**see [x](y) now**",
+        ],
+    )
+    def test_style_before_link_does_not_corrupt_escapes(self, src):
+        result = md_render(src)
+        plain = strip_ansi(result)
+        # No stray ESC bytes may survive stripping well-formed sequences
+        assert "\x1b" not in plain
+        assert "x (y)" in plain
+        assert "[" not in plain and "]" not in plain
+
+    def test_link_inside_bold_keeps_bold_after(self):
+        result = md_render("**see [x](y) now**")
+        # bold is switched on before "see" and only switched off after "now"
+        assert result.index(Ansi.BOLD) < result.index("see")
+        assert result.rindex(Ansi.BOLD_OFF) > result.index("now")
+
+    def test_dunder_in_url_preserved(self):
+        url = "https://docs.python.org/3/reference/datamodel.html#object.__init__"
+        result = md_render(f"[init]({url})")
+        assert url in strip_ansi(result)
+
+    def test_asterisks_in_url_preserved(self):
+        url = "https://example.com/a*b*c"
+        result = md_render(f"[x]({url})")
+        assert url in strip_ansi(result)
+
+    def test_emphasis_inside_link_text(self):
+        result = md_render("[**bold** link](u)")
+        assert "bold link (u)" in strip_ansi(result)
+        assert Ansi.BOLD in result
+
+    def test_spaced_asterisks_are_not_italic(self):
+        result = md_render("2 * 3 * 4 = 24")
+        assert strip_ansi(result) == "2 * 3 * 4 = 24"
+        assert Ansi.ITALIC not in result
+
+    def test_header_color_restored_after_link(self):
+        result = md_render("# Title [l](u) more")
+        # the header color must be re-emitted before the trailing text
+        tail = result[result.index("(u)") :]
+        assert Ansi.FG_CYAN in tail
+        assert "more" in tail
+
+    def test_blockquote_color_restored_after_code(self):
+        renderer = MarkdownRenderer(true_color=True)
+        result = renderer.render("> a `c` b")
+        tail = result[result.index(" c ") :]
+        assert Ansi.rgb_fg(180, 180, 180) in tail
+
+
+class TestCodeBlockRendering:
+    @pytest.mark.parametrize(
+        "code_style", ["default", "nord", "github-dark", "dracula"]
+    )
+    def test_background_survives_pygments_reset(self, code_style):
+        """Pygments emits SGR 0 after bold tokens; bg must be re-applied."""
+        renderer = MarkdownRenderer(
+            code_style=code_style, true_color=True, code_width=40
+        )
+        result = renderer.render("```python\ndef f():\n    return 1\n```")
+        bg = renderer._code_bg
+        for line in result.split("\n"):
+            # every reset that is not the final one must be followed by bg
+            body = line[: -len(Ansi.RESET)]
+            for m in re.finditer(r"\x1b\[[0-9;]*\b0?0m", body):
+                assert body.startswith(bg, m.end()), (code_style, line)
+
+    def test_256_color_mode_emits_no_24bit_escapes(self):
+        renderer = MarkdownRenderer(true_color=False, code_width=20)
+        result = renderer.render("```python\nx = 1\n```\n> quote\n[l](u)")
+        assert "38;2;" not in result
+        assert "48;2;" not in result
+
+    def test_true_color_mode_uses_style_background(self):
+        renderer = MarkdownRenderer(
+            code_style="monokai", true_color=True, code_width=20
+        )
+        result = renderer.render("```\nx\n```")
+        assert Ansi.rgb_bg(39, 40, 34) in result  # monokai #272822
+
+    def test_tabs_expanded(self):
+        result = md_render("```\n\tx\n```", code_width=10)
+        plain = strip_ansi(result)
+        assert "\t" not in plain
+        assert "    x" in plain
+
+    def test_wide_chars_padded_by_column_width(self):
+        result = md_render("```\n漢字\n```", code_width=10)
+        for line in strip_ansi(result).split("\n"):
+            if line:
+                assert _visible_len(line) == 10
+
+    def test_invalid_style_raises_value_error(self):
+        with pytest.raises(ValueError, match="Unknown syntax highlighting style"):
+            MarkdownRenderer(code_style="no-such-style")
+        with pytest.raises(ValueError):
+            SyntaxHighlighter(style="no-such-style")
+
+
+class TestWidthHelpers:
+    def test_visible_len_ignores_ansi(self):
+        assert _visible_len(f"{Ansi.BOLD}abc{Ansi.RESET}") == 3
+
+    def test_visible_len_wide_and_combining(self):
+        assert _visible_len("漢字") == 4
+        assert _visible_len("e\u0301") == 1  # e + combining acute
+
+    def test_rgb_to_256_grays_and_cube(self):
+        assert _rgb_to_256(0, 0, 0) == 16
+        assert _rgb_to_256(255, 255, 255) == 231
+        assert 232 <= _rgb_to_256(128, 128, 128) <= 255
+        assert _rgb_to_256(255, 0, 0) == 196
+
+
+class TestCLI:
+    def test_renders_utf8_file(self, tmp_path, capsys):
+        md = tmp_path / "doc.md"
+        md.write_bytes("# Café — test 🚀\n".encode())
+        assert cli_main([str(md)]) == 0
+        out = strip_ansi(capsys.readouterr().out)
+        assert "Café — test 🚀" in out
+
+    def test_reads_stdin(self, monkeypatch, capsys):
+        monkeypatch.setattr("sys.stdin", io.StringIO("**hi**\n"))
+        assert cli_main([]) == 0
+        assert "hi" in strip_ansi(capsys.readouterr().out)
+
+    def test_list_styles(self, capsys):
+        assert cli_main(["--list-styles"]) == 0
+        assert "monokai" in capsys.readouterr().out
+
+    def test_invalid_style_is_clean_error(self, tmp_path, capsys):
+        md = tmp_path / "doc.md"
+        md.write_text("x\n", encoding="utf-8")
+        assert cli_main(["--style", "nope", str(md)]) == 2
+        captured = capsys.readouterr()
+        assert "Unknown syntax highlighting style" in captured.err
+        assert "Traceback" not in captured.err
+
+    def test_version(self, capsys):
+        with pytest.raises(SystemExit) as exc:
+            cli_main(["--version"])
+        assert exc.value.code == 0
+        assert "mdsyntax" in capsys.readouterr().out
+
+
+class TestFences:
+    def test_longer_fence_can_contain_shorter_fence(self):
+        src = "````markdown\nouter\n```python\ninner\n```\nstill code\n````\nafter"
+        result = md_render(src, code_width=20)
+        plain = strip_ansi(result)
+        lines = [line.rstrip() for line in plain.split("\n")]
+        assert lines[0].strip() == "markdown"  # label, no stray backtick
+        assert "```python" in plain and "inner" in plain and "still code" in plain
+        assert lines[-1] == "after"  # rendered outside the block
+
+    def test_tilde_fence(self):
+        result = md_render("~~~python\nx = 1\n~~~", code_width=20)
+        plain = strip_ansi(result)
+        assert "x = 1" in plain
+        assert "~~~" not in plain
+
+    def test_shorter_fence_does_not_close(self):
+        result = md_render("````\n```\nx\n````", code_width=10)
+        plain = strip_ansi(result)
+        assert "```" in plain and "x" in plain

mdsyntax-0.2.0/CHANGELOG.md

@@ -1,44 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [Unreleased]
-
-## [0.2.0] - 2025-XX-XX
-
-### Added
-
-- New `Style` class for styling arbitrary text
-  - Static methods: `Style.bold_text()`, `Style.italic_text()`, `Style.color()`, etc.
-  - Chainable API: `style("text").bold().italic().fg("red")`
-- RGB color support via `Style.color(text, fg=(255, 0, 0))`
-- `Ansi` class now exported for direct access to ANSI codes
-
-### Changed
-
-- Switched from `colorama.init(autoreset=True)` to `colorama.just_fix_windows_console()` for better compatibility
-- Code blocks now expand width to fit long lines instead of truncating
-- Use targeted ANSI resets instead of full reset for better style preservation
-
-### Fixed
-
-- Inline code in blockquotes no longer breaks italic styling for subsequent text
-- Code block width now properly constrains content
-
-## [0.1.0] - 2025-01-XX
-
-### Added
-
-- Initial release
-- Markdown rendering with ANSI formatting
-- Syntax highlighting for code blocks (powered by Pygments)
-- Support for headers, bold, italic, strikethrough, inline code
-- Support for lists (ordered, unordered, task lists)
-- Support for blockquotes and horizontal rules
-- Support for links
-- CLI tool (`mdsyntax`)
-- Auto-detection of 24-bit true color support
-- Configurable code block styling and width