MarkdownサブセットをHTMLに変換するコンバータ

import re
import html

def markdown_to_html(markdown_text: str) -> str:
"""MarkdownのサブセットをHTMLに変換します。

サポートされている機能：
  - ヘッダー（# .. ######）
  - 2スペースネストの順序なしリスト
  - フェンスされたコードブロック（```）
  - 段落
  - インライン：***太字+イタリック***、**太字**、*イタリック*
"""

def escape(text: str) -> str:
    # HTMLに敏感な文字をエスケープします。
    return html.escape(text, quote=False)

def process_inline(text: str) -> str:
    """インラインマークダウンを処理します。エスケープ済みのテキストでも機能します。
    マーカー*, **, *** はエスケープされた文字を含まないためです。
    """
    escaped = escape(text)

    # 優先順位：***、次に**、次に*。
    # 非欲張りマッチを使用し、非空白境界を緩やかに要求します。
    # ***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 = []

# 状態トラッカー
in_code_block = False
code_buffer = []

paragraph_buffer = []

# リストスタック：現在開いているインデントレベル（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):
    """`level`個のリストのみが開いた状態になるまでリストを閉じます（level = 開いている<ul>の数）。"""
    while len(list_stack) > level:
        output.append('</li>')
        output.append('</ul>')
        list_stack.pop()
        if list_stack:
            # ネストされたリストを閉じた後、親<li>は開いたままです。
            # 次の兄弟が開始するか、完全に閉じる際に閉じます。
            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]

    # コードブロックの処理
    if in_code_block:
        if line.strip().startswith('```'):
            # コードブロックの終了
            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

    # コードブロックの開始をチェック
    stripped = line.strip()
    if stripped.startswith('```'):
        flush_paragraph()
        close_all_lists()
        in_code_block = True
        i += 1
        continue

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

    # ヘッダー？
    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

    # リスト項目？
    # 先頭のスペース（ネストには偶数である必要がある）と「- 」に一致
    list_match = re.match(r'^( *)- +(.*)$', line)
    if list_match:
        flush_paragraph()
        indent_spaces = len(list_match.group(1))
        # インデントが2の倍数である場合にのみ有効なネストレベルとして扱う
        indent_level = indent_spaces // 2
        content = list_match.group(2)

        # リストスタックを調整
        if not list_stack:
            # 新規開始：最初のリストはレベル0である必要がある
            indent_level = 0
            output.append('<ul>')
            list_stack.append(0)
            output.append(f'<li>{process_inline(content)}')
        else:
            current_depth = len(list_stack) - 1  # トップインデックス
            if indent_level > current_depth:
                # 新しいネストされたリストを開く（一度に1レベル深くするだけ）
                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:
                # 同じレベルの兄弟：前の<li>を閉じる
                output.append('</li>')
                output.append(f'<li>{process_inline(content)}')
            else:
                # デデント：深いリストを閉じる
                while len(list_stack) - 1 > indent_level:
                    output.append('</li>')
                    output.append('</ul>')
                    list_stack.pop()
                    # このネストされたリストが含まれていた親<li>も閉じる
                    output.append('</li>')
                # 現在同じレベル：兄弟を追加
                output.append(f'<li>{process_inline(content)}')
        i += 1
        continue

    # それ以外の場合は、段落行です
    if list_stack:
        close_all_lists()
    paragraph_buffer.append(line.strip())
    i += 1

# 入力の終了：すべてフラッシュ
if in_code_block:
    # 未クローズのコードブロック：持っているものをすべて発行
    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 = '''# Header 1

This is a paragraph with bold and italic text.
This is the same paragraph.

• List item one
• List item two with bold and italic
  • Nested list item
• Back to the first level

def hello():
    print("Hello, World!")

'''
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)