dataface 0.1.2__py3-none-any.whl

mdsvg/renderer.py

@@ -0,0 +1,1623 @@
+"""SVG renderer for parsed Markdown AST."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Tuple
+
+# Precise text measurement
+from .fonts import (
+    FontMeasurer,
+    WrapPiece,
+    _cached_measurer,
+    get_default_measurer,
+    get_system_mono_font,
+    split_token_precise,
+    wrap_measured_pieces,
+)
+from .images import ImageSize, ImageUrlMapper, get_image_size
+from .style import Style
+from .types import (
+    Block,
+    Blockquote,
+    CodeBlock,
+    Document,
+    Heading,
+    HorizontalRule,
+    ImageBlock,
+    OrderedList,
+    Paragraph,
+    RawHtmlBlock,
+    Span,
+    SpanType,
+    Table,
+    TableCell,
+    TableRow,
+    UnorderedList,
+)
+from .utils import escape_svg_text, escape_xml, format_number
+
+# --- Raw HTML sanitization ---
+_UNSAFE_TAG_RE = re.compile(
+    r"<\s*/?\s*(script|iframe|object|embed|applet|form|input|textarea|button)\b[^>]*>",
+    re.IGNORECASE,
+)
+_EVENT_ATTR_RE = re.compile(r"\s+on\w+\s*=\s*[\"'][^\"']*[\"']", re.IGNORECASE)
+
+
+def _sanitize_html(html: str) -> str:
+    """Remove dangerous tags and event-handler attributes from HTML."""
+    html = _UNSAFE_TAG_RE.sub("", html)
+    html = _EVENT_ATTR_RE.sub("", html)
+    return html
+
+
+@dataclass
+class RenderResult:
+    """Result of rendering markdown content.
+
+    Contains the rendered SVG content (without wrapper), along with dimensions.
+    This allows callers to compose multiple mdsvg outputs into a larger SVG
+    without needing to regex-strip wrappers.
+
+    Attributes:
+        elements: SVG elements without wrapper or style block.
+        style_block: The <style> block with CSS classes for the rendered content.
+        width: Width of the rendered content in pixels.
+        height: Height of the rendered content in pixels.
+
+    Example:
+        >>> from mdsvg import render_content
+        >>> result = render_content("# Hello", width=400)
+        >>> result.elements     # Just SVG elements (rects, text, etc.)
+        >>> result.style_block  # The <style>...</style> CSS block
+        >>> result.content      # Combined style_block + elements (backwards compatible)
+        >>> result.width        # 400.0
+        >>> result.height       # Actual rendered height
+        >>> result.to_svg()     # Full SVG with wrapper
+
+        # Compose multiple sections with single style block:
+        >>> left = render_content("# Left", width=350)
+        >>> right = render_content("# Right", width=350)
+        >>> combined = f'''
+        ... <svg xmlns="http://www.w3.org/2000/svg" width="750" height="{max(left.height, right.height)}">
+        ...   {left.style_block}
+        ...   <g transform="translate(0, 0)">{left.elements}</g>
+        ...   <g transform="translate(400, 0)">{right.elements}</g>
+        ... </svg>
+        ... '''
+    """
+
+    elements: str
+    style_block: str
+    width: float
+    height: float
+
+    @property
+    def content(self) -> str:
+        """Combined style block and elements for backwards compatibility.
+
+        Returns:
+            String containing the style block followed by SVG elements.
+        """
+        return self.style_block + "\n" + self.elements
+
+    def to_svg(self) -> str:
+        """Wrap content in a complete SVG element.
+
+        Returns:
+            Complete SVG string with xmlns, width, height, and viewBox attributes.
+
+        Example:
+            >>> result = render_content("# Hello", width=400)
+            >>> svg = result.to_svg()
+            >>> with open("output.svg", "w") as f:
+            ...     f.write(svg)
+        """
+        svg_parts = [
+            f'<svg xmlns="http://www.w3.org/2000/svg" '
+            f'width="{format_number(self.width)}" height="{format_number(self.height)}" '
+            f'viewBox="0 0 {format_number(self.width)} {format_number(self.height)}">',
+            self.content,
+            "</svg>",
+        ]
+        return "\n".join(svg_parts)
+
+
+@dataclass
+class RenderContext:
+    """Context passed through rendering for tracking state."""
+
+    x: float
+    y: float
+    width: float
+    style: Style
+    indent: float = 0.0
+
+    def with_offset(self, dx: float = 0, dy: float = 0) -> RenderContext:
+        """Create a new context with offset position."""
+        return RenderContext(
+            x=self.x + dx,
+            y=self.y + dy,
+            width=self.width,
+            style=self.style,
+            indent=self.indent,
+        )
+
+    def with_indent(self, additional_indent: float) -> RenderContext:
+        """Create a new context with additional indentation."""
+        return RenderContext(
+            x=self.x + additional_indent,
+            y=self.y,
+            width=self.width - additional_indent,
+            style=self.style,
+            indent=self.indent + additional_indent,
+        )
+
+
+@dataclass(frozen=True)
+class TableRowLayout:
+    """Measured layout for one rendered table row."""
+
+    cell_lines: tuple[tuple[tuple["TextRun", ...], ...], ...]
+    row_height: float
+
+
+@dataclass(frozen=True)
+class Size:
+    """Rendered width and height."""
+
+    width: float
+    height: float
+
+
+class SVGRenderer:
+    """
+    Renderer that converts Markdown AST to SVG.
+
+    Uses fonttools-backed precise text measurement.
+
+    Example:
+        >>> renderer = SVGRenderer(style=Style())
+        >>> blocks = parse("# Hello\\n\\nWorld")
+        >>> svg = renderer.render(blocks, width=400)
+    """
+
+    def __init__(
+        self,
+        style: Optional[Style] = None,
+        font_path: Optional[str] = None,
+        mono_font_path: Optional[str] = None,
+        # Image options
+        fetch_image_sizes: bool = True,
+        image_base_path: Optional[str] = None,
+        image_url_mapper: Optional[ImageUrlMapper] = None,
+        image_timeout: float = 10.0,
+        # Raw HTML passthrough
+        allow_raw_html: bool = False,
+    ) -> None:
+        """
+        Initialize the renderer.
+
+        Args:
+            style: Style configuration. Uses default style if None.
+            font_path: Path to a TTF/OTF font file for precise measurement.
+                      If None, uses system default font.
+            mono_font_path: Path to a monospace TTF/OTF font file for measuring
+                      inline code. If None, uses the detected system mono font.
+            fetch_image_sizes: If True (default), fetch image dimensions from
+                      local files or remote URLs. Required for accurate layout.
+            image_base_path: Base directory for resolving relative image paths.
+                      Used when fetching local image dimensions.
+            image_url_mapper: Optional function to transform image URLs before
+                      embedding in SVG. Useful for mapping local paths to CDN URLs.
+                      Example: create_prefix_mapper({"/assets/": "https://cdn.example.com/"})
+            image_timeout: Timeout in seconds for fetching remote images (default 10).
+        """
+        self.style = style or Style()
+        self._allow_raw_html = allow_raw_html
+        self._measurer: FontMeasurer
+        self._mono_char_width: Optional[float] = None
+        self._mono_font_path = mono_font_path
+
+        # Image handling
+        self._fetch_image_sizes = fetch_image_sizes
+        self._image_base_path = image_base_path
+        self._image_url_mapper = image_url_mapper
+        self._image_timeout = image_timeout
+        self._image_size_cache: Dict[str, Optional[ImageSize]] = {}
+
+        if font_path:
+            self._measurer = _cached_measurer(font_path)
+            if not self._measurer.is_available:
+                raise RuntimeError(
+                    "Precise text measurement is required, but no FontMeasurer is available"
+                )
+        else:
+            default = get_default_measurer()
+            if default is None or not default.is_available:
+                raise RuntimeError(
+                    "Precise text measurement is required, but no FontMeasurer is available"
+                )
+            self._measurer = default
+
+    def _ensure_mono_char_width(self) -> float:
+        """Load precise monospace measurement on first actual code use."""
+        if self._mono_char_width is not None:
+            return self._mono_char_width
+
+        mono_font_path = self._mono_font_path or get_system_mono_font()
+        if not mono_font_path:
+            raise RuntimeError(
+                "Precise monospace measurement is required, but no monospace FontMeasurer is available"
+            )
+
+        mono_measurer = _cached_measurer(mono_font_path)
+        if not mono_measurer.is_available:
+            raise RuntimeError(
+                "Precise monospace measurement is required, but no monospace FontMeasurer is available"
+            )
+
+        self._mono_char_width = mono_measurer.measure("M", 1.0)
+        return self._mono_char_width
+
+    def _measure_text(
+        self,
+        text: str,
+        font_size: float,
+        is_bold: bool = False,
+        is_italic: bool = False,
+        is_mono: bool = False,
+    ) -> float:
+        """Measure text width using best available method."""
+        width: float
+
+        # Monospace: all characters have identical width, so just multiply
+        if is_mono:
+            width = len(text) * self._ensure_mono_char_width() * font_size
+        else:
+            width = self._measurer.measure(text, font_size)
+            # Apply scaling for bold/italic since FontMeasurer only has regular font
+            # Bold text is typically 10-15% wider, italic ~4% wider
+            if is_bold and is_italic:
+                bold_ratio = (
+                    self.style.bold_char_width_ratio / self.style.char_width_ratio
+                )
+                italic_ratio = (
+                    self.style.italic_char_width_ratio / self.style.char_width_ratio
+                )
+                width *= bold_ratio * italic_ratio
+            elif is_bold:
+                width *= self.style.bold_char_width_ratio / self.style.char_width_ratio
+            elif is_italic:
+                width *= (
+                    self.style.italic_char_width_ratio / self.style.char_width_ratio
+                )
+        return width
+
+    def _render_blocks_to_elements(
+        self,
+        blocks: Document,
+        width: float,
+        padding: float,
+    ) -> Tuple[List[str], float]:
+        """
+        Render blocks to SVG elements and return total height.
+
+        This is the core rendering logic shared by render() and render_content().
+
+        Args:
+            blocks: Document AST to render.
+            width: Width of the SVG in pixels.
+            padding: Padding inside the SVG.
+
+        Returns:
+            Tuple of (svg_elements, total_height).
+        """
+        content_width = width - (padding * 2)
+
+        ctx = RenderContext(
+            x=padding,
+            y=padding,
+            width=content_width,
+            style=self.style,
+        )
+
+        svg_elements: List[str] = []
+        current_y = padding
+
+        for block in blocks:
+            elements, height = self._render_block(
+                block, ctx.with_offset(dy=current_y - ctx.y)
+            )
+            svg_elements.extend(elements)
+            current_y += height + self.style.paragraph_spacing
+
+        # Remove trailing spacing
+        if blocks:
+            current_y -= self.style.paragraph_spacing
+
+        total_height = current_y + padding
+        return svg_elements, total_height
+
+    def render(
+        self,
+        blocks: Document,
+        width: float = 400,
+        padding: float = 0,
+    ) -> str:
+        """
+        Render blocks to an SVG string.
+
+        Args:
+            blocks: Document AST to render.
+            width: Width of the SVG in pixels.
+            padding: Padding inside the SVG.
+
+        Returns:
+            SVG string.
+        """
+        svg_elements, total_height = self._render_blocks_to_elements(
+            blocks, width, padding
+        )
+        svg = self._build_svg(svg_elements, width, total_height)
+        return svg
+
+    def render_content(
+        self,
+        blocks: Document,
+        width: float = 400,
+        padding: float = 0,
+    ) -> RenderResult:
+        """
+        Render blocks and return structured result with content and dimensions.
+
+        Unlike render(), this returns the SVG content without the <svg> wrapper,
+        along with the actual dimensions. This is useful when composing multiple
+        mdsvg outputs into a larger SVG.
+
+        Args:
+            blocks: Document AST to render.
+            width: Width of the SVG in pixels.
+            padding: Padding inside the SVG.
+
+        Returns:
+            RenderResult with content (SVG elements without wrapper),
+            width, and height.
+
+        Example:
+            >>> renderer = SVGRenderer()
+            >>> blocks = parse("# Hello")
+            >>> result = renderer.render_content(blocks, width=400)
+            >>> result.content  # SVG elements without wrapper
+            >>> result.width    # 400.0
+            >>> result.height   # Actual rendered height
+            >>> result.to_svg() # Full SVG with wrapper
+        """
+        svg_elements, total_height = self._render_blocks_to_elements(
+            blocks, width, padding
+        )
+
+        return RenderResult(
+            elements="\n".join(svg_elements),
+            style_block=self._get_style_block(),
+            width=width,
+            height=total_height,
+        )
+
+    def measure(
+        self,
+        blocks: Document,
+        width: float = 400,
+        padding: float = 0,
+    ) -> Size:
+        """
+        Measure the size needed to render blocks.
+
+        Args:
+            blocks: Document AST to measure.
+            width: Width constraint.
+            padding: Padding inside the SVG.
+
+        Returns:
+            Size with width and height.
+        """
+        content_width = width - (padding * 2)
+
+        ctx = RenderContext(
+            x=padding,
+            y=padding,
+            width=content_width,
+            style=self.style,
+        )
+
+        current_y = padding
+
+        for block in blocks:
+            _, height = self._render_block(block, ctx.with_offset(dy=current_y - ctx.y))
+            current_y += height + self.style.paragraph_spacing
+
+        if blocks:
+            current_y -= self.style.paragraph_spacing
+
+        return Size(width=width, height=current_y + padding)
+
+    def _get_style_block(self) -> str:
+        """Generate the CSS style block for SVG rendering.
+
+        Returns:
+            A <style> block string with CSS classes for text, headings, code, etc.
+        """
+        return f"""  <style>
+    .md-text {{ font-family: {self.style.font_family}; fill: {self.style.text_color}; }}
+    .md-mono {{ font-family: {self.style.mono_font_family}; }}
+    .md-heading {{ font-family: {self.style.font_family}; fill: {self.style.get_heading_color()}; font-weight: {self.style.heading_font_weight}; }}
+    .md-code {{ font-family: {self.style.mono_font_family}; fill: {self.style.code_color}; }}
+    .md-link {{ fill: {self.style.link_color}; }}
+    .md-blockquote {{ fill: {self.style.blockquote_color}; }}
+  </style>"""
+
+    def _build_svg(
+        self,
+        elements: List[str],
+        width: float,
+        height: float,
+    ) -> str:
+        """Build the complete SVG document."""
+        svg_parts = [
+            f'<svg xmlns="http://www.w3.org/2000/svg" '
+            f'width="{format_number(width)}" height="{format_number(height)}" '
+            f'viewBox="0 0 {format_number(width)} {format_number(height)}">',
+        ]
+
+        # Add a style block for fonts
+        svg_parts.append(self._get_style_block())
+
+        svg_parts.extend(elements)
+        svg_parts.append("</svg>")
+
+        return "\n".join(svg_parts)
+
+    def _render_block(
+        self,
+        block: Block,
+        ctx: RenderContext,
+    ) -> Tuple[List[str], float]:
+        """Render a block and return SVG elements and height used."""
+        if isinstance(block, Paragraph):
+            return self._render_paragraph(block, ctx)
+        elif isinstance(block, Heading):
+            return self._render_heading(block, ctx)
+        elif isinstance(block, CodeBlock):
+            return self._render_code_block(block, ctx)
+        elif isinstance(block, Blockquote):
+            return self._render_blockquote(block, ctx)
+        elif isinstance(block, UnorderedList):
+            return self._render_unordered_list(block, ctx)
+        elif isinstance(block, OrderedList):
+            return self._render_ordered_list(block, ctx)
+        elif isinstance(block, HorizontalRule):
+            return self._render_horizontal_rule(ctx)
+        elif isinstance(block, Table):
+            return self._render_table(block, ctx)
+        elif isinstance(block, ImageBlock):
+            return self._render_image_block(block, ctx)
+        elif isinstance(block, RawHtmlBlock):
+            return self._render_raw_html_block(block, ctx)
+        else:
+            # Unknown block type
+            return [], 0
+
+    def _render_paragraph(
+        self,
+        para: Paragraph,
+        ctx: RenderContext,
+    ) -> Tuple[List[str], float]:
+        """Render a paragraph."""
+        return self._render_text_block(
+            para.spans,
+            ctx,
+            font_size=self.style.base_font_size,
+            css_class="md-text",
+        )
+
+    def _render_raw_html_block(
+        self,
+        block: RawHtmlBlock,
+        ctx: RenderContext,
+    ) -> Tuple[List[str], float]:
+        """Render a raw HTML block.
+
+        When allow_raw_html is True, wraps in <foreignObject> with XHTML namespace.
+        When False, escapes HTML and renders as a text paragraph.
+        """
+        if not self._allow_raw_html:
+            # Escape and render as plain text paragraph
+            from .types import Paragraph, Span
+
+            escaped = Paragraph(spans=(Span(text=block.html),))
+            return self._render_paragraph(escaped, ctx)
+
+        sanitized = _sanitize_html(block.html)
+        # Estimate height: count lines, use line_height heuristic
+        line_count = max(1, sanitized.count("\n") + 1)
+        line_h = self.style.base_font_size * self.style.line_height
+        fo_height = line_count * line_h + 16  # 16px padding
+        fo_width = ctx.width
+
+        fo = (
+            f'<foreignObject x="{format_number(ctx.x)}" y="{format_number(ctx.y)}" '
+            f'width="{format_number(fo_width)}" height="{format_number(fo_height)}">'
+            f'<div xmlns="http://www.w3.org/1999/xhtml" '
+            f'style="font-family: {self.style.font_family}; '
+            f"font-size: {format_number(self.style.base_font_size)}px; "
+            f'color: {self.style.text_color};">'
+            f"{sanitized}"
+            f"</div>"
+            f"</foreignObject>"
+        )
+        return [fo], fo_height
+
+    def _render_heading(
+        self,
+        heading: Heading,
+        ctx: RenderContext,
+    ) -> Tuple[List[str], float]:
+        """Render a heading."""
+        font_size = self.style.get_heading_size(heading.level)
+
+        # Add top margin
+        margin_top = font_size * self.style.heading_margin_top
+        margin_bottom = font_size * self.style.heading_margin_bottom
+
+        elements, text_height = self._render_text_block(
+            heading.spans,
+            ctx.with_offset(dy=margin_top),
+            font_size=font_size,
+            css_class="md-heading",
+            font_weight=self.style.heading_font_weight,
+            line_height_multiplier=self.style.heading_line_height,
+        )
+
+        return elements, margin_top + text_height + margin_bottom
+
+    def _render_code_block(
+        self,
+        code: CodeBlock,
+        ctx: RenderContext,
+    ) -> Tuple[List[str], float]:
+        """Render a code block with background."""
+        overflow = self.style.code_block_overflow
+
+        if overflow == "wrap":
+            return self._render_code_block_wrapped(code, ctx)
+        elif overflow in {"show", "hide", "ellipsis"}:
+            return self._render_code_block_simple(code, ctx, overflow)
+        else:
+            # Defensive fallback (should be unreachable due to typing)
+            return self._render_code_block_wrapped(code, ctx)
+
+    def _render_code_block_simple(
+        self,
+        code: CodeBlock,
+        ctx: RenderContext,
+        overflow: str,
+    ) -> Tuple[List[str], float]:
+        """Render code block with show/hide/ellipsis overflow."""
+        elements: List[str] = []
+
+        padding = self.style.code_block_padding
+        font_size = self.style.base_font_size * 0.9
+        line_height = font_size * 1.4
+        char_width = font_size * self._ensure_mono_char_width()
+        max_chars = int((ctx.width - padding * 2) / char_width)
+
+        lines = code.code.split("\n")
+
+        # Process lines for ellipsis mode
+        if overflow == "ellipsis":
+            processed_lines = []
+            for line in lines:
+                if len(line) > max_chars and max_chars > 3:
+                    processed_lines.append(line[: max_chars - 3] + "...")
+                else:
+                    processed_lines.append(line)
+            lines = processed_lines
+
+        text_height = len(lines) * line_height
+        total_height = text_height + (padding * 2)
+
+        # For hide mode, add a clipPath
+        clip_id = None
+        if overflow == "hide":
+            clip_id = f"code-clip-{id(code)}"
+            elements.append(
+                f'  <defs><clipPath id="{clip_id}">'
+                f'<rect x="{format_number(ctx.x)}" y="{format_number(ctx.y)}" '
+                f'width="{format_number(ctx.width)}" height="{format_number(total_height)}"/>'
+                f"</clipPath></defs>"
+            )
+
+        # Background rectangle
+        elements.append(
+            f'  <rect x="{format_number(ctx.x)}" y="{format_number(ctx.y)}" '
+            f'width="{format_number(ctx.width)}" height="{format_number(total_height)}" '
+            f'fill="{self.style.code_background}" '
+            f'rx="{format_number(self.style.code_block_border_radius)}"/>'
+        )
+
+        # Code lines (optionally clipped)
+        clip_attr = f' clip-path="url(#{clip_id})"' if clip_id else ""
+        y_offset = ctx.y + padding + font_size
+        for line in lines:
+            if line:  # Don't render empty lines as text elements
+                escaped = escape_xml(line)
+                elements.append(
+                    f'  <text x="{format_number(ctx.x + padding)}" '
+                    f'y="{format_number(y_offset)}" '
+                    f'class="md-mono" font-size="{format_number(font_size)}" '
+                    f'font-weight="400" xml:space="preserve" '
+                    f'fill="{self.style.text_color}"{clip_attr}>{escaped}</text>'
+                )
+            y_offset += line_height
+
+        return elements, total_height
+
+    def _render_code_block_wrapped(
+        self,
+        code: CodeBlock,
+        ctx: RenderContext,
+    ) -> Tuple[List[str], float]:
+        """Render code block with wrapped lines."""
+        elements: List[str] = []
+
+        padding = self.style.code_block_padding
+        font_size = self.style.base_font_size * 0.9
+        line_height = font_size * 1.4
+        char_width = font_size * self._ensure_mono_char_width()
+        max_chars = max(10, int((ctx.width - padding * 2) / char_width))
+
+        # Wrap lines
+        wrapped_lines: List[str] = []
+        for line in code.code.split("\n"):
+            if not line:
+                wrapped_lines.append("")
+            elif len(line) <= max_chars:
+                wrapped_lines.append(line)
+            else:
+                # Wrap long lines
+                while line:
+                    wrapped_lines.append(line[:max_chars])
+                    line = line[max_chars:]
+
+        text_height = len(wrapped_lines) * line_height
+        total_height = text_height + (padding * 2)
+
+        # Background rectangle
+        elements.append(
+            f'  <rect x="{format_number(ctx.x)}" y="{format_number(ctx.y)}" '
+            f'width="{format_number(ctx.width)}" height="{format_number(total_height)}" '
+            f'fill="{self.style.code_background}" '
+            f'rx="{format_number(self.style.code_block_border_radius)}"/>'
+        )
+
+        # Code lines
+        y_offset = ctx.y + padding + font_size
+        for line in wrapped_lines:
+            if line:
+                escaped = escape_xml(line)
+                elements.append(
+                    f'  <text x="{format_number(ctx.x + padding)}" '
+                    f'y="{format_number(y_offset)}" '
+                    f'class="md-mono" font-size="{format_number(font_size)}" '
+                    f'font-weight="400" xml:space="preserve" '
+                    f'fill="{self.style.text_color}">{escaped}</text>'
+                )
+            y_offset += line_height
+
+        return elements, total_height
+
+    def _render_blockquote(
+        self,
+        bq: Blockquote,
+        ctx: RenderContext,
+    ) -> Tuple[List[str], float]:
+        """Render a blockquote with left border."""
+        elements: List[str] = []
+
+        # Create indented context for content
+        indent = self.style.blockquote_padding
+        inner_ctx = ctx.with_indent(indent)
+
+        # Render inner blocks
+        current_y = 0.0
+        inner_elements: List[str] = []
+
+        for block in bq.blocks:
+            block_elements, height = self._render_block(
+                block,
+                inner_ctx.with_offset(dy=current_y),
+            )
+            inner_elements.extend(block_elements)
+            current_y += height + self.style.paragraph_spacing
+
+        if bq.blocks:
+            current_y -= self.style.paragraph_spacing
+
+        total_height = current_y
+
+        # Left border
+        elements.append(
+            f'  <rect x="{format_number(ctx.x)}" y="{format_number(ctx.y)}" '
+            f'width="{format_number(self.style.blockquote_border_width)}" '
+            f'height="{format_number(total_height)}" '
+            f'fill="{self.style.blockquote_border_color}"/>'
+        )
+
+        elements.extend(inner_elements)
+
+        return elements, total_height
+
+    def _render_unordered_list(
+        self,
+        ul: UnorderedList,
+        ctx: RenderContext,
+    ) -> Tuple[List[str], float]:
+        """Render an unordered list."""
+        elements: List[str] = []
+        current_y = 0.0
+
+        bullet_indent = self.style.list_indent
+
+        for item in ul.items:
+            # Render bullet
+            bullet_x = ctx.x + (bullet_indent / 2) - 4
+            bullet_y = (
+                ctx.y
+                + current_y
+                + (self.style.base_font_size * self.style.line_height / 2)
+            )
+
+            elements.append(
+                f'  <circle cx="{format_number(bullet_x)}" '
+                f'cy="{format_number(bullet_y)}" r="3" '
+                f'fill="{self.style.text_color}"/>'
+            )
+
+            # Render item text
+            item_ctx = ctx.with_indent(bullet_indent).with_offset(dy=current_y)
+            item_elements, item_height = self._render_text_block(
+                item.spans,
+                item_ctx,
+                font_size=self.style.base_font_size,
+                css_class="md-text",
+            )
+            elements.extend(item_elements)
+
+            current_y += item_height + self.style.list_item_spacing
+
+        if ul.items:
+            current_y -= self.style.list_item_spacing
+
+        return elements, current_y
+
+    def _render_ordered_list(
+        self,
+        ol: OrderedList,
+        ctx: RenderContext,
+    ) -> Tuple[List[str], float]:
+        """Render an ordered list."""
+        elements: List[str] = []
+        current_y = 0.0
+
+        bullet_indent = self.style.list_indent
+
+        for idx, item in enumerate(ol.items):
+            number = ol.start + idx
+
+            # Render number
+            number_text = f"{number}."
+            number_x = ctx.x + bullet_indent - 8
+            number_y = ctx.y + current_y + self.style.base_font_size
+
+            elements.append(
+                f'  <text x="{format_number(number_x)}" '
+                f'y="{format_number(number_y)}" '
+                f'class="md-text" font-size="{format_number(self.style.base_font_size)}" '
+                f'text-anchor="end">{number_text}</text>'
+            )
+
+            # Render item text
+            item_ctx = ctx.with_indent(bullet_indent).with_offset(dy=current_y)
+            item_elements, item_height = self._render_text_block(
+                item.spans,
+                item_ctx,
+                font_size=self.style.base_font_size,
+                css_class="md-text",
+            )
+            elements.extend(item_elements)
+
+            current_y += item_height + self.style.list_item_spacing
+
+        if ol.items:
+            current_y -= self.style.list_item_spacing
+
+        return elements, current_y
+
+    def _render_horizontal_rule(
+        self,
+        ctx: RenderContext,
+    ) -> Tuple[List[str], float]:
+        """Render a horizontal rule."""
+        height = self.style.hr_height
+        margin = self.style.paragraph_spacing
+
+        y_pos = ctx.y + margin
+
+        element = (
+            f'  <rect x="{format_number(ctx.x)}" '
+            f'y="{format_number(y_pos)}" '
+            f'width="{format_number(ctx.width)}" '
+            f'height="{format_number(height)}" '
+            f'fill="{self.style.hr_color}"/>'
+        )
+
+        return [element], margin + height + margin
+
+    def _render_table(
+        self,
+        table: Table,
+        ctx: RenderContext,
+    ) -> Tuple[List[str], float]:
+        """Render a table."""
+        elements: List[str] = []
+
+        padding = self.style.table_cell_padding
+        font_size = self.style.base_font_size
+
+        # Calculate column widths (equal distribution for now)
+        num_cols = len(table.header.cells)
+        col_width = ctx.width / num_cols if num_cols > 0 else ctx.width
+
+        header_layout = self._measure_table_row_layout(
+            table.header,
+            col_width=col_width,
+            padding=padding,
+            font_size=font_size,
+            is_header=True,
+        )
+        body_layouts = [
+            self._measure_table_row_layout(
+                row,
+                col_width=col_width,
+                padding=padding,
+                font_size=font_size,
+                is_header=False,
+            )
+            for row in table.rows
+        ]
+
+        current_y = ctx.y
+
+        # Render header background
+        elements.append(
+            f'  <rect x="{format_number(ctx.x)}" y="{format_number(current_y)}" '
+            f'width="{format_number(ctx.width)}" height="{format_number(header_layout.row_height)}" '
+            f'fill="{self.style.table_header_background}"/>'
+        )
+
+        # Render header row
+        self._render_table_row(
+            elements,
+            table.header,
+            header_layout.cell_lines,
+            ctx.x,
+            current_y,
+            col_width,
+            padding,
+            font_size,
+            is_header=True,
+        )
+        current_y += header_layout.row_height
+
+        # Render body rows
+        for row, row_layout in zip(table.rows, body_layouts):
+            self._render_table_row(
+                elements,
+                row,
+                row_layout.cell_lines,
+                ctx.x,
+                current_y,
+                col_width,
+                padding,
+                font_size,
+                is_header=False,
+            )
+            current_y += row_layout.row_height
+
+        # Table border
+        total_height = current_y - ctx.y
+        elements.append(
+            f'  <rect x="{format_number(ctx.x)}" y="{format_number(ctx.y)}" '
+            f'width="{format_number(ctx.width)}" height="{format_number(total_height)}" '
+            f'fill="none" stroke="{self.style.table_border_color}"/>'
+        )
+
+        # Column separators
+        col_x = ctx.x
+        for _ in range(num_cols - 1):
+            col_x += col_width
+            elements.append(
+                f'  <line x1="{format_number(col_x)}" y1="{format_number(ctx.y)}" '
+                f'x2="{format_number(col_x)}" y2="{format_number(current_y)}" '
+                f'stroke="{self.style.table_border_color}"/>'
+            )
+
+        # Row separators
+        row_y = ctx.y
+        row_heights = [
+            header_layout.row_height,
+            *[layout.row_height for layout in body_layouts],
+        ]
+        for row_height in row_heights:
+            row_y += row_height
+            if row_y < current_y:
+                elements.append(
+                    f'  <line x1="{format_number(ctx.x)}" y1="{format_number(row_y)}" '
+                    f'x2="{format_number(ctx.x + ctx.width)}" y2="{format_number(row_y)}" '
+                    f'stroke="{self.style.table_border_color}"/>'
+                )
+
+        return elements, total_height
+
+    def _table_cell_runs(
+        self,
+        cell: TableCell,
+        is_header: bool,
+    ) -> List[TextRun]:
+        """Build text runs for a table cell, forcing bold widths for headers."""
+        runs = self._build_text_runs(cell.spans, self.style.base_font_size)
+        if not is_header:
+            return runs
+        return [
+            TextRun(
+                text=run.text,
+                is_bold=True,
+                is_italic=run.is_italic,
+                is_code=run.is_code,
+                is_link=run.is_link,
+                is_image=run.is_image,
+                url=run.url,
+            )
+            for run in runs
+        ]
+
+    def _table_cell_lines_to_inner_svg(
+        self,
+        line_runs: Sequence[TextRun],
+        is_header: bool,
+    ) -> str:
+        """Inline spans for a wrapped table-cell line."""
+        parts: list[str] = []
+        for run in line_runs:
+            if not run.text:
+                continue
+            escaped = escape_svg_text(run.text)
+            style_parts: list[str] = []
+
+            if run.is_bold or is_header:
+                style_parts.append("font-weight: bold")
+
+            if run.is_italic:
+                style_parts.append("font-style: italic")
+
+            if run.is_code:
+                style_parts.append(f"font-family: {self.style.mono_font_family}")
+                style_parts.append(f"fill: {self.style.code_color}")
+
+            if run.is_link:
+                style_parts.append(f"fill: {self.style.link_color}")
+                if self.style.link_underline:
+                    style_parts.append("text-decoration: underline")
+
+            if run.is_image:
+                style_parts.append("font-style: italic")
+                style_parts.append(f"fill: {self.style.code_color}")
+
+            style_attr = f' style="{"; ".join(style_parts)}"' if style_parts else ""
+            if run.is_link and run.url:
+                parts.append(
+                    f'<a href="{escape_svg_text(run.url)}">'
+                    f"<tspan{style_attr}>{escaped}</tspan></a>"
+                )
+            elif style_parts:
+                parts.append(f"<tspan{style_attr}>{escaped}</tspan>")
+            else:
+                parts.append(escaped)
+
+        return "".join(parts)
+
+    def _measure_table_row_layout(
+        self,
+        row: TableRow,
+        col_width: float,
+        padding: float,
+        font_size: float,
+        is_header: bool,
+    ) -> TableRowLayout:
+        """Wrap each cell in a row and return its rendered line layout."""
+        max_width = max(col_width - (padding * 2), 1.0)
+        line_height = font_size * self.style.line_height
+        cell_lines: list[tuple[tuple[TextRun, ...], ...]] = []
+        max_lines = 1
+
+        for cell in row.cells:
+            runs = self._table_cell_runs(cell, is_header=is_header)
+            wrapped = self._wrap_runs(runs, max_width, font_size)
+            if not wrapped:
+                wrapped = [[]]
+            cell_lines.append(
+                tuple(tuple(line_run for line_run in line) for line in wrapped)
+            )
+            max_lines = max(max_lines, len(wrapped))
+
+        row_height = (max_lines * line_height) + (padding * 2)
+        return TableRowLayout(cell_lines=tuple(cell_lines), row_height=row_height)
+
+    def _render_table_row(
+        self,
+        elements: List[str],
+        row: TableRow,
+        cell_lines: Sequence[Sequence[Sequence[TextRun]]],
+        start_x: float,
+        y: float,
+        col_width: float,
+        padding: float,
+        font_size: float,
+        is_header: bool,
+    ) -> None:
+        """Render a single table row."""
+        x = start_x
+        line_height = font_size * self.style.line_height
+
+        for idx, cell in enumerate(row.cells):
+            line_runs = cell_lines[idx]
+
+            # Get alignment
+            align = cell.align
+
+            if align == "center":
+                text_x = x + col_width / 2
+                anchor = "middle"
+            elif align == "right":
+                text_x = x + col_width - padding
+                anchor = "end"
+            else:  # left or default
+                text_x = x + padding
+                anchor = "start"
+
+            css_class = "md-text"
+            weight = "bold" if is_header else "normal"
+
+            text_y = y + padding + font_size
+            for runs in line_runs:
+                inner = self._table_cell_lines_to_inner_svg(runs, is_header=is_header)
+                elements.append(
+                    f'  <text x="{format_number(text_x)}" y="{format_number(text_y)}" '
+                    f'class="{css_class}" font-size="{format_number(font_size)}" '
+                    f'font-weight="{weight}" text-anchor="{anchor}">{inner}</text>'
+                )
+                text_y += line_height
+
+            x += col_width
+
+    def _get_image_size(self, url: str) -> Optional[ImageSize]:
+        """Get image dimensions, using cache to avoid re-fetching."""
+        if url in self._image_size_cache:
+            return self._image_size_cache[url]
+
+        # Skip fetching if enforce_aspect_ratio is set (speed optimization)
+        if self.style.image_enforce_aspect_ratio:
+            return None
+
+        if not self._fetch_image_sizes:
+            return None
+
+        size = get_image_size(
+            url,
+            base_path=self._image_base_path,
+            timeout=self._image_timeout,
+        )
+        self._image_size_cache[url] = size
+        return size
+
+    def _map_image_url(self, url: str) -> str:
+        """Apply URL mapper if configured."""
+        if self._image_url_mapper:
+            return self._image_url_mapper(url)
+        return url
+
+    def _render_image_block(
+        self,
+        img: ImageBlock,
+        ctx: RenderContext,
+    ) -> Tuple[List[str], float]:
+        """Render an image block.
+
+        Image sizing priority:
+        1. Explicit dimensions from markdown: ![alt](url){width=X height=Y}
+        2. Fetched dimensions from the actual image (if fetch_image_sizes=True)
+        3. Style defaults (image_width, image_height)
+        4. Fallback: full width with image_fallback_aspect_ratio
+
+        The preserveAspectRatio attribute ensures the actual image
+        scales proportionally within the allocated space.
+        """
+        # Try to get actual image dimensions
+        actual_size = self._get_image_size(img.url)
+
+        # Determine dimensions using priority order
+        explicit_width = img.width
+        explicit_height = img.height
+
+        # Calculate final width
+        if explicit_width is not None:
+            # Explicit width from markdown
+            img_width = min(ctx.width, explicit_width)
+        elif self.style.image_width is not None:
+            # Style default width
+            img_width = min(ctx.width, self.style.image_width)
+        else:
+            # Full container width
+            img_width = ctx.width
+
+        # Calculate final height
+        if explicit_height is not None:
+            # Explicit height from markdown
+            img_height = explicit_height
+        elif explicit_width is not None and actual_size is not None:
+            # Scale height based on actual aspect ratio
+            img_height = img_width / actual_size.aspect_ratio
+        elif self.style.image_height is not None:
+            # Style default height
+            img_height = self.style.image_height
+        elif actual_size is not None:
+            # Use actual image aspect ratio
+            img_height = img_width / actual_size.aspect_ratio
+        else:
+            # Fallback to configured aspect ratio
+            img_height = img_width / self.style.image_fallback_aspect_ratio
+
+        # Map URL for embedding (e.g., local path -> CDN URL)
+        embed_url = self._map_image_url(img.url)
+
+        element = (
+            f'  <image x="{format_number(ctx.x)}" y="{format_number(ctx.y)}" '
+            f'width="{format_number(img_width)}" height="{format_number(img_height)}" '
+            f'href="{escape_svg_text(embed_url)}" '
+            f'preserveAspectRatio="{self.style.image_preserve_aspect_ratio}"/>'
+        )
+
+        elements = [element]
+
+        # Add alt text as title for accessibility
+        if img.alt:
+            elements.append(f"  <title>{escape_svg_text(img.alt)}</title>")
+
+        return elements, img_height
+
+    def _render_text_block(
+        self,
+        spans: Sequence[Span],
+        ctx: RenderContext,
+        font_size: float,
+        css_class: str,
+        font_weight: str | int = "normal",
+        line_height_multiplier: Optional[float] = None,
+    ) -> Tuple[List[str], float]:
+        """Render a sequence of spans as wrapped text using tspan for proper spacing."""
+        if not spans:
+            return [], 0
+
+        elements: List[str] = []
+        multiplier = (
+            line_height_multiplier
+            if line_height_multiplier is not None
+            else self.style.line_height
+        )
+        line_height = font_size * multiplier
+
+        # Build runs of text with their styles
+        runs = self._build_text_runs(spans, font_size)
+
+        # Wrap and layout text
+        lines = self._wrap_runs(runs, ctx.width, font_size)
+
+        current_y = ctx.y + font_size  # Baseline
+
+        # Calculate x position based on text alignment
+        text_anchor = self.style.get_text_anchor()
+        if self.style.text_align == "center":
+            text_x = ctx.x + ctx.width / 2
+        elif self.style.text_align == "right":
+            text_x = ctx.x + ctx.width
+        else:  # left (default)
+            text_x = ctx.x
+
+        for line_runs in lines:
+            if not line_runs:
+                current_y += line_height
+                continue
+
+            # Build a single <text> element with <tspan> children for proper spacing
+            # This lets the browser handle text positioning correctly
+            tspan_parts: List[str] = []
+
+            for run in line_runs:
+                if not run.text:
+                    continue
+
+                escaped = escape_svg_text(run.text)
+
+                # Build tspan styling
+                style_parts: List[str] = []
+
+                if run.is_bold:
+                    style_parts.append("font-weight: bold")
+                elif font_weight != "normal":
+                    style_parts.append(f"font-weight: {font_weight}")
+
+                if run.is_italic:
+                    style_parts.append("font-style: italic")
+
+                if run.is_code:
+                    style_parts.append(f"font-family: {self.style.mono_font_family}")
+                    style_parts.append(f"fill: {self.style.code_color}")
+
+                if run.is_link:
+                    style_parts.append(f"fill: {self.style.link_color}")
+                    if self.style.link_underline:
+                        style_parts.append("text-decoration: underline")
+
+                # Create tspan element
+                style_attr = f' style="{"; ".join(style_parts)}"' if style_parts else ""
+
+                if run.is_link and run.url:
+                    # Wrap link text in an anchor
+                    tspan_parts.append(
+                        f'<a href="{escape_svg_text(run.url)}">'
+                        f"<tspan{style_attr}>{escaped}</tspan></a>"
+                    )
+                elif style_parts:
+                    tspan_parts.append(f"<tspan{style_attr}>{escaped}</tspan>")
+                else:
+                    # Plain text without tspan wrapper
+                    tspan_parts.append(escaped)
+
+            # Build the complete text element
+            text_content = "".join(tspan_parts)
+            text_element = (
+                f'  <text x="{format_number(text_x)}" y="{format_number(current_y)}" '
+                f'font-size="{format_number(font_size)}" class="{css_class}" '
+                f'text-anchor="{text_anchor}">'
+                f"{text_content}</text>"
+            )
+            elements.append(text_element)
+
+            current_y += line_height
+
+        total_height = len(lines) * line_height
+        return elements, total_height
+
+    def _build_text_runs(
+        self,
+        spans: Sequence[Span],
+        font_size: float,
+    ) -> List[TextRun]:
+        """Convert spans to text runs with computed styles."""
+        runs: List[TextRun] = []
+
+        for span in spans:
+            is_bold = span.span_type in (SpanType.BOLD, SpanType.BOLD_ITALIC)
+            is_italic = span.span_type in (SpanType.ITALIC, SpanType.BOLD_ITALIC)
+            is_code = span.span_type == SpanType.CODE
+            is_link = span.span_type == SpanType.LINK
+            is_image = span.span_type == SpanType.IMAGE
+
+            runs.append(
+                TextRun(
+                    text=span.text,
+                    is_bold=is_bold,
+                    is_italic=is_italic,
+                    is_code=is_code,
+                    is_link=is_link,
+                    is_image=is_image,
+                    url=span.url,
+                )
+            )
+
+        return runs
+
+    def _wrap_runs(
+        self,
+        runs: List[TextRun],
+        max_width: float,
+        font_size: float,
+    ) -> List[List[TextRun]]:
+        """Wrap text runs to fit within max_width."""
+        if not runs:
+            return []
+
+        pieces: List[WrapPiece] = []
+        separator = ""
+        for run in runs:
+            is_bold = run.is_bold
+            is_italic = run.is_italic
+            is_mono = run.is_code
+
+            def measure(
+                text: str,
+                *,
+                _is_bold: bool = is_bold,
+                _is_italic: bool = is_italic,
+                _is_mono: bool = is_mono,
+            ) -> float:
+                return self._measure_text(
+                    text,
+                    font_size,
+                    is_bold=_is_bold,
+                    is_italic=_is_italic,
+                    is_mono=_is_mono,
+                )
+
+            for token in re.findall(r"\S+|\s+", run.text):
+                if token.isspace():
+                    separator = " "
+                    continue
+                separator_width = measure(separator) if separator else 0.0
+                for chunk_index, chunk in enumerate(
+                    split_token_precise(token, max_width, measure)
+                ):
+                    pieces.append(
+                        WrapPiece(
+                            text=chunk,
+                            width=measure(chunk),
+                            separator=separator if chunk_index == 0 else "",
+                            separator_width=(
+                                separator_width if chunk_index == 0 else 0.0
+                            ),
+                            meta=run,
+                        )
+                    )
+                    separator = ""
+
+        wrapped = wrap_measured_pieces(pieces, max_width)
+        lines: List[List[TextRun]] = []
+        for line in wrapped:
+            line_runs: List[TextRun] = []
+            for index, piece in enumerate(line):
+                run = piece.meta
+                assert isinstance(run, TextRun)
+                prefix = piece.separator if index > 0 else ""
+                text = f"{prefix}{piece.text}"
+                if line_runs and line_runs[-1].same_style(run):
+                    line_runs[-1] = line_runs[-1].append(text)
+                else:
+                    line_runs.append(run.with_text(text))
+            if line_runs:
+                lines.append(line_runs)
+        return lines
+
+
+@dataclass
+class TextRun:
+    """A run of text with consistent styling."""
+
+    text: str
+    is_bold: bool = False
+    is_italic: bool = False
+    is_code: bool = False
+    is_link: bool = False
+    is_image: bool = False
+    url: Optional[str] = None
+
+    def same_style(self, other: TextRun) -> bool:
+        """Check if another run has the same styling."""
+        return (
+            self.is_bold == other.is_bold
+            and self.is_italic == other.is_italic
+            and self.is_code == other.is_code
+            and self.is_link == other.is_link
+            and self.url == other.url
+        )
+
+    def with_text(self, text: str) -> TextRun:
+        """Create a copy with different text."""
+        return TextRun(
+            text=text,
+            is_bold=self.is_bold,
+            is_italic=self.is_italic,
+            is_code=self.is_code,
+            is_link=self.is_link,
+            is_image=self.is_image,
+            url=self.url,
+        )
+
+    def append(self, text: str) -> TextRun:
+        """Create a copy with appended text."""
+        return self.with_text(self.text + text)
+
+
+# Convenience functions
+
+
+def render(
+    markdown: str,
+    width: float = 400,
+    padding: float = 20,
+    style: Optional[Style] = None,
+    allow_raw_html: bool = False,
+    font_path: str | None = None,
+    mono_font_path: str | None = None,
+) -> str:
+    """
+    Render Markdown text to SVG.
+
+    This is the main entry point for the library.
+
+    Args:
+        markdown: Markdown text to render.
+        width: Width of the SVG in pixels.
+        padding: Padding inside the SVG.
+        style: Style configuration. Uses default if None.
+        allow_raw_html: If True, render raw HTML blocks via foreignObject.
+        font_path: Path to TTF/OTF font for precise text measurement.
+        mono_font_path: Path to monospace TTF/OTF font for code measurement.
+
+    Returns:
+        SVG string.
+
+    Example:
+        >>> svg = render("# Hello World\\n\\nThis is **bold** text.")
+        >>> with open("output.svg", "w") as f:
+        ...     f.write(svg)
+    """
+    from .parser import parse
+
+    blocks = parse(markdown)
+    renderer = SVGRenderer(
+        style=style,
+        allow_raw_html=allow_raw_html,
+        font_path=font_path,
+        mono_font_path=mono_font_path,
+    )
+    return renderer.render(blocks, width=width, padding=padding)
+
+
+def render_blocks(
+    blocks: Document,
+    width: float = 400,
+    padding: float = 20,
+    style: Optional[Style] = None,
+    allow_raw_html: bool = False,
+    font_path: str | None = None,
+    mono_font_path: str | None = None,
+) -> str:
+    """
+    Render pre-parsed blocks to SVG.
+
+    Args:
+        blocks: Document AST to render.
+        width: Width of the SVG in pixels.
+        padding: Padding inside the SVG.
+        style: Style configuration.
+        allow_raw_html: If True, render raw HTML blocks via foreignObject.
+        font_path: Path to TTF/OTF font for precise text measurement.
+        mono_font_path: Path to monospace TTF/OTF font for code measurement.
+
+    Returns:
+        SVG string.
+    """
+    renderer = SVGRenderer(
+        style=style,
+        allow_raw_html=allow_raw_html,
+        font_path=font_path,
+        mono_font_path=mono_font_path,
+    )
+    return renderer.render(blocks, width=width, padding=padding)
+
+
+def measure(
+    markdown: str,
+    width: float = 400,
+    padding: float = 20,
+    style: Optional[Style] = None,
+    font_path: str | None = None,
+    mono_font_path: str | None = None,
+) -> Size:
+    """
+    Measure the dimensions needed to render Markdown.
+
+    Args:
+        markdown: Markdown text to measure.
+        width: Width constraint.
+        padding: Padding inside the SVG.
+        style: Style configuration.
+        font_path: Path to TTF/OTF font for precise text measurement.
+        mono_font_path: Path to monospace TTF/OTF font for code measurement.
+
+    Returns:
+        Size with width and height.
+
+    Example:
+        >>> size = measure("# Hello\\n\\nLong paragraph...")
+        >>> print(f"Height needed: {size.height}px")
+    """
+    from .parser import parse
+
+    blocks = parse(markdown)
+    renderer = SVGRenderer(
+        style=style,
+        font_path=font_path,
+        mono_font_path=mono_font_path,
+    )
+    return renderer.measure(blocks, width=width, padding=padding)
+
+
+def render_content(
+    markdown: str,
+    width: float = 400,
+    padding: float = 20,
+    style: Optional[Style] = None,
+    allow_raw_html: bool = False,
+    font_path: str | None = None,
+    mono_font_path: str | None = None,
+) -> RenderResult:
+    """
+    Render Markdown and return structured result with content and dimensions.
+
+    Unlike render(), this returns the SVG content without the <svg> wrapper,
+    along with the actual dimensions. This is useful when composing multiple
+    mdsvg outputs into a larger SVG without needing regex-based extraction.
+
+    Args:
+        markdown: Markdown text to render.
+        width: Width of the SVG in pixels.
+        padding: Padding inside the SVG.
+        style: Style configuration. Uses default if None.
+        font_path: Path to TTF/OTF font for precise text measurement.
+        mono_font_path: Path to monospace TTF/OTF font for code measurement.
+
+    Returns:
+        RenderResult with content (SVG elements without wrapper),
+        width, and height.
+
+    Example:
+        >>> from mdsvg import render_content
+        >>> result = render_content("# Hello World", width=400)
+        >>> result.content  # SVG elements without <svg> wrapper
+        >>> result.width    # 400.0
+        >>> result.height   # Actual rendered height
+        >>> result.to_svg() # Full SVG with wrapper (convenience method)
+
+        # Embed in a larger SVG:
+        >>> large_svg = f'''
+        ... <svg xmlns="http://www.w3.org/2000/svg" width="800" height="600">
+        ...   <g transform="translate(50, 100)">
+        ...     {result.content}
+        ...   </g>
+        ... </svg>
+        ... '''
+    """
+    from .parser import parse
+
+    blocks = parse(markdown)
+    renderer = SVGRenderer(
+        style=style,
+        allow_raw_html=allow_raw_html,
+        font_path=font_path,
+        mono_font_path=mono_font_path,
+    )
+    return renderer.render_content(blocks, width=width, padding=padding)