Markdown-Subset-zu-HTML-Konverter

import re
import html

def markdown_to_html(markdown_text: str) -> str:
"""Konvertiert eine Teilmenge von Markdown in HTML.

Unterstützte Funktionen:
  - Überschriften (# .. ######)
  - Ungeordnete Listen mit 2-Leerzeichen-Einrückung
  - Eingefasste Codeblöcke (```)
  - Absätze
  - Inline: ***fett+kursiv***, **fett**, *kursiv*
"""

def escape(text: str) -> str:
    # HTML-sensible Zeichen escapen.
    return html.escape(text, quote=False)

def process_inline(text: str) -> str:
    """Verarbeitet Inline-Markdown. Funktioniert auch mit bereits escapedem Text, da
    die Marker *, ** und *** keine escapeden Zeichen enthalten.
    """
    escaped = escape(text)

    # Reihenfolge der Priorität: ***, dann **, dann *.
    # Nicht-gierige Übereinstimmung verwenden und lose Nicht-Leerzeichen-Grenzen erfordern.
    # ***text***
    escaped = re.sub(
        r'\*\*\*(.+?)\*\*\*',
        r'<strong><em>\1</em></strong>',
        escaped,
    )
    # **text**
    escaped = re.sub(
        r'\*\*(.+?)\*\*',
        r'<strong>\1</strong>',
        escaped,
    )
    # *text*
    escaped = re.sub(
        r'\*(.+?)\*',
        r'<em>\1</em>',
        escaped,
    )
    return escaped

lines = markdown_text.split('\n')
output = []

# Zustandsvariablen
in_code_block = False
code_buffer = []

paragraph_buffer = []

# Listen-Stack: Liste der aktuell offenen Einrückungsebenen (0, 1, 2, ...)
list_stack = []

def flush_paragraph():
    if paragraph_buffer:
        content = ' '.join(paragraph_buffer)
        output.append(f'<p>{process_inline(content)}</p>')
        paragraph_buffer.clear()

def close_lists_to(level):
    """Schließt Listen, bis nur noch `level` Listen offen sind (level = Anzahl der offenen <ul>)."""
    while len(list_stack) > level:
        output.append('</li>')
        output.append('</ul>')
        list_stack.pop()
        if list_stack:
            # Nach dem Schließen einer verschachtelten Liste bleibt das übergeordnete <li> offen;
            # es wird geschlossen, wenn der nächste Geschwister beginnt oder wenn es vollständig geschlossen wird.
            pass

def close_all_lists():
    while list_stack:
        output.append('</li>')
        output.append('</ul>')
        list_stack.pop()

i = 0
while i < len(lines):
    line = lines[i]

    # Codeblock-Verarbeitung
    if in_code_block:
        if line.strip().startswith('```'):
            # Codeblock beenden
            code_content = '\n'.join(code_buffer)
            output.append(f'<pre><code>{escape(code_content)}</code></pre>')
            code_buffer = []
            in_code_block = False
        else:
            code_buffer.append(line)
        i += 1
        continue

    # Prüfung auf Codeblock-Start
    stripped = line.strip()
    if stripped.startswith('```'):
        flush_paragraph()
        close_all_lists()
        in_code_block = True
        i += 1
        continue

    # Leerzeile
    if stripped == '':
        flush_paragraph()
        close_all_lists()
        i += 1
        continue

    # Überschrift?
    header_match = re.match(r'^(#{1,6}) +(.*)$', line)
    if header_match:
        flush_paragraph()
        close_all_lists()
        level = len(header_match.group(1))
        content = header_match.group(2).rstrip()
        output.append(f'<h{level}>{process_inline(content)}</h{level}>')
        i += 1
        continue

    # Listenpunkt?
    # Führende Leerzeichen abgleichen (müssen gerade sein für Verschachtelung) gefolgt von "- "
    list_match = re.match(r'^( *)- +(.*)$', line)
    if list_match:
        flush_paragraph()
        indent_spaces = len(list_match.group(1))
        # Nur als gültige Einrückungsebene behandeln, wenn die Einrückung ein Vielfaches von 2 ist
        indent_level = indent_spaces // 2
        content = list_match.group(2)

        # Listen-Stack anpassen
        if not list_stack:
            # Frisch beginnen: Die erste Liste muss auf Ebene 0 sein
            indent_level = 0
            output.append('<ul>')
            list_stack.append(0)
            output.append(f'<li>{process_inline(content)}')
        else:
            current_depth = len(list_stack) - 1  # oberster Index
            if indent_level > current_depth:
                # Eine neue verschachtelte Liste öffnen (nur eine Ebene tiefer pro Schritt)
                indent_level = current_depth + 1
                output.append('<ul>')
                list_stack.append(indent_level)
                output.append(f'<li>{process_inline(content)}')
            elif indent_level == current_depth:
                # Geschwister auf derselben Ebene: vorheriges <li> schließen
                output.append('</li>')
                output.append(f'<li>{process_inline(content)}')
            else:
                # Einrücken reduzieren: tiefere Listen schließen
                while len(list_stack) - 1 > indent_level:
                    output.append('</li>')
                    output.append('</ul>')
                    list_stack.pop()
                    # Auch das übergeordnete <li> schließen, das diese verschachtelte Liste enthielt
                    output.append('</li>')
                # Jetzt auf derselben Ebene: Geschwister hinzufügen
                output.append(f'<li>{process_inline(content)}')
        i += 1
        continue

    # Andernfalls ist es eine Absatzzeile
    if list_stack:
        close_all_lists()
    paragraph_buffer.append(line.strip())
    i += 1

# Ende der Eingabe: alles leeren
if in_code_block:
    # Nicht geschlossener Codeblock: alles ausgeben, was wir haben
    code_content = '\n'.join(code_buffer)
    output.append(f'<pre><code>{escape(code_content)}</code></pre>')
flush_paragraph()
close_all_lists()

return '\n'.join(output)

if name == 'main':
sample = '''# Überschrift 1

Dies ist ein Absatz mit fettem und kursivem Text.
Dies ist derselbe Absatz.

• Listenpunkt eins
• Listenpunkt zwei mit fett und kursiv
  • Verschachtelter Listenpunkt
• Zurück zur ersten Ebene

def hallo():
    print("Hallo, Welt!")

'''
print(markdown_to_html(sample))

def markdown_to_html(markdown_text: str) -> str:
import re
from html import escape

lines = markdown_text.splitlines()
out = []
paragraph_lines = []
list_stack = []
i = 0
in_code_block = False
code_lines = []

def parse_inline(text: str) -> str:
    parts = []
    i = 0
    n = len(text)
    while i < n:
        if text.startswith('***', i):
            j = text.find('***', i + 3)
            if j != -1:
                inner = parse_inline(text[i + 3:j])
                parts.append(f'<strong><em>{inner}</em></strong>')
                i = j + 3
                continue
        if text.startswith('**', i):
            j = text.find('**', i + 2)
            if j != -1:
                inner = parse_inline(text[i + 2:j])
                parts.append(f'<strong>{inner}</strong>')
                i = j + 2
                continue
        if text.startswith('*', i):
            j = text.find('*', i + 1)
            if j != -1:
                inner = parse_inline(text[i + 1:j])
                parts.append(f'<em>{inner}</em>')
                i = j + 1
                continue
        parts.append(escape(text[i]))
        i += 1
    return ''.join(parts)

def flush_paragraph():
    nonlocal paragraph_lines
    if paragraph_lines:
        text = ' '.join(line.strip() for line in paragraph_lines)
        out.append(f'<p>{parse_inline(text)}</p>')
        paragraph_lines = []

def close_lists_to(level: int):
    while len(list_stack) > level:
        out.append('</li>')
        out.append('</ul>')
        list_stack.pop()

def handle_list_item(indent_spaces: int, content: str):
    level = indent_spaces // 2
    if indent_spaces % 2 != 0:
        return False

    if level > len(list_stack):
        if level != len(list_stack) + 1:
            return False
        out.append('<ul>')
        list_stack.append(True)
    elif level < len(list_stack):
        close_lists_to(level)
        out.append('</li>')
    else:
        if list_stack:
            out.append('</li>')
        else:
            out.append('<ul>')
            list_stack.append(True)

    while len(list_stack) < level + 1:
        out.append('<ul>')
        list_stack.append(True)

    out.append(f'<li>{parse_inline(content)}')
    return True

while i < len(lines):
    line = lines[i]

    if in_code_block:
        if line.startswith('```'):
            out.append(f'<pre><code>{escape("\n".join(code_lines))}</code></pre>')
            code_lines = []
            in_code_block = False
        else:
            code_lines.append(line)
        i += 1
        continue

    if line.startswith('```'):
        flush_paragraph()
        close_lists_to(0)
        in_code_block = True
        code_lines = []
        i += 1
        continue

    if not line.strip():
        flush_paragraph()
        close_lists_to(0)
        i += 1
        continue

    header_match = re.match(r'^(#{1,6})\s+(.*)$', line)
    if header_match:
        flush_paragraph()
        close_lists_to(0)
        level = len(header_match.group(1))
        content = parse_inline(header_match.group(2).strip())
        out.append(f'<h{level}>{content}</h{level}>')
        i += 1
        continue

    list_match = re.match(r'^( *)(- )(.+)$', line)
    if list_match:
        flush_paragraph()
        indent = len(list_match.group(1))
        content = list_match.group(3)
        if handle_list_item(indent, content):
            i += 1
            continue

    if list_stack:
        close_lists_to(0)

    paragraph_lines.append(line)
    i += 1

if in_code_block:
    out.append(f'<pre><code>{escape("\n".join(code_lines))}</code></pre>')

flush_paragraph()
close_lists_to(0)

return '\n'.join(out)