Rendering

class HtmlRenderer:
    def __init__(self, options={}):
        """
        Initialize HTML renderer with optional configuration.
        
        Args:
            options (dict): Configuration options including:
                - 'softbreak': String to use for soft line breaks (default: '\n')
                - 'safe': Boolean to enable safe mode, filtering dangerous URLs (default: False)
                - 'sourcepos': Boolean to add source position attributes (default: False)
        """
        
    def render(self, ast):
        """
        Render an AST to HTML.
        
        Args:
            ast (Node): Root node of the AST to render
            
        Returns:
            str: HTML representation of the AST
        """
        
    def tag(self, name, attrs=None, selfclosing=None):
        """
        Add an HTML tag to output buffer.
        
        Args:
            name (str): Tag name
            attrs (list): List of [key, value] attribute pairs (optional)
            selfclosing (bool): Whether tag is self-closing (optional)
        """

class ReStructuredTextRenderer:
    def __init__(self, indent_char=' '):
        """
        Initialize reStructuredText renderer.
        
        Args:
            indent_char (str): Character to use for indentation (default: space)
        """
        
    def render(self, ast):
        """
        Render an AST to reStructuredText.
        
        Args:
            ast (Node): Root node of the AST to render
            
        Returns:
            str: reStructuredText representation of the AST
        """

class Renderer:
    def render(self, ast):
        """
        Render an AST by walking through all nodes.
        
        Args:
            ast (Node): Root node of the AST to render
            
        Returns:
            str: Rendered output (format depends on renderer implementation)
        """
        
    def lit(self, s):
        """
        Concatenate a literal string to the output buffer.
        
        Args:
            s (str): String to add to output
        """
        
    def cr(self):
        """
        Add a newline to output if not already present at the end.
        """
        
    def out(self, s):
        """
        Concatenate a string to output, possibly with escaping.
        
        Args:
            s (str): String to add to output
        """

from commonmark import Parser, HtmlRenderer

parser = Parser()
renderer = HtmlRenderer()

markdown = """
# Title

This is a paragraph with **bold** and *italic* text.

- List item 1
- List item 2
"""

ast = parser.parse(markdown)
html = renderer.render(ast)
print(html)

from commonmark import Parser, HtmlRenderer

parser = Parser()
renderer = HtmlRenderer(options={'softbreak': '<br />\n'})

markdown = "Line 1\nLine 2"
ast = parser.parse(markdown)
html = renderer.render(ast)
print(html)  # Soft breaks rendered as <br /> tags

from commonmark import Parser, ReStructuredTextRenderer

parser = Parser()
renderer = ReStructuredTextRenderer()

markdown = """
# Main Title

## Subtitle

Some text with **bold** formatting.
"""

ast = parser.parse(markdown)
rst = renderer.render(ast)
print(rst)

from commonmark import Parser, ReStructuredTextRenderer

parser = Parser()
renderer = ReStructuredTextRenderer(indent_char='\t')  # Use tabs

markdown = """
- Item 1
  - Nested item
- Item 2
"""

ast = parser.parse(markdown)
rst = renderer.render(ast)
print(rst)  # Uses tab characters for indentation

from commonmark import Parser, HtmlRenderer, ReStructuredTextRenderer

parser = Parser()
html_renderer = HtmlRenderer()
rst_renderer = ReStructuredTextRenderer()

markdown = "# Hello\n*World*"
ast = parser.parse(markdown)

html = html_renderer.render(ast)
rst = rst_renderer.render(ast)

print("HTML:", html)
print("RST:", rst)