#!/usr/bin/env python3
"""Render a small, self-contained Markdown report to browser-friendly HTML."""
from __future__ import annotations
import argparse
import html
import re
from pathlib import Path
def slugify(text: str, used: set[str]) -> str:
slug = re.sub(r"`([^`]+)`", r"\1", text).strip().lower()
slug = re.sub(r"[^\w\u4e00-\u9fff]+", "-", slug, flags=re.UNICODE).strip("-")
if not slug:
slug = "section"
base = slug
counter = 2
while slug in used:
slug = f"{base}-{counter}"
counter += 1
used.add(slug)
return slug
def parse_inline(text: str) -> str:
parts = re.split(r"(`[^`]*`)", text)
rendered: list[str] = []
for part in parts:
if part.startswith("`") and part.endswith("`"):
rendered.append(f"{html.escape(part[1:-1])}")
continue
escaped = html.escape(part)
escaped = re.sub(
r"\[([^\]]+)\]\(([^)]+)\)",
lambda m: (
f''
f"{html.escape(m.group(1))}"
),
escaped,
)
escaped = re.sub(r"\*\*([^*]+)\*\*", r"\1", escaped)
escaped = re.sub(r"\*([^*]+)\*", r"\1", escaped)
rendered.append(escaped)
return "".join(rendered)
def is_table_separator(line: str) -> bool:
stripped = line.strip()
if "|" not in stripped:
return False
cells = [cell.strip() for cell in stripped.strip("|").split("|")]
return bool(cells) and all(re.fullmatch(r":?-{3,}:?", cell or "") for cell in cells)
def split_table_row(line: str) -> list[str]:
return [cell.strip() for cell in line.strip().strip("|").split("|")]
def render_table(lines: list[str]) -> str:
header = split_table_row(lines[0])
rows = [split_table_row(line) for line in lines[2:]]
thead = "".join(f"
{parse_inline(cell)}
" for cell in header)
body_rows = []
for row in rows:
padded = row + [""] * (len(header) - len(row))
cells = "".join(f"
{parse_inline(cell)}
" for cell in padded[: len(header)])
body_rows.append(f"
{cells}
")
return (
'
'
f"
{thead}
"
f"{''.join(body_rows)}"
"
"
)
def render_markdown(markdown: str) -> tuple[str, list[tuple[int, str, str]]]:
lines = markdown.splitlines()
blocks: list[str] = []
toc: list[tuple[int, str, str]] = []
used_slugs: set[str] = set()
paragraph: list[str] = []
i = 0
def flush_paragraph() -> None:
if paragraph:
text = " ".join(line.strip() for line in paragraph).strip()
if text:
blocks.append(f"
{parse_inline(text)}
")
paragraph.clear()
while i < len(lines):
line = lines[i]
stripped = line.strip()
if not stripped:
flush_paragraph()
i += 1
continue
if stripped.startswith("```"):
flush_paragraph()
language = stripped[3:].strip()
code_lines: list[str] = []
i += 1
while i < len(lines) and not lines[i].strip().startswith("```"):
code_lines.append(lines[i])
i += 1
if i < len(lines):
i += 1
class_name = f' class="language-{html.escape(language, quote=True)}"' if language else ""
blocks.append(f"
{html.escape(chr(10).join(code_lines))}
")
continue
heading = re.match(r"^(#{1,6})\s+(.+)$", stripped)
if heading:
flush_paragraph()
level = len(heading.group(1))
title = heading.group(2).strip()
anchor = slugify(title, used_slugs)
toc.append((level, title, anchor))
blocks.append(
f'#{parse_inline(title)}'
)
i += 1
continue
if stripped.startswith("|") and i + 1 < len(lines) and is_table_separator(lines[i + 1]):
flush_paragraph()
table_lines = [lines[i], lines[i + 1]]
i += 2
while i < len(lines) and lines[i].strip().startswith("|"):
table_lines.append(lines[i])
i += 1
blocks.append(render_table(table_lines))
continue
ordered = re.match(r"^\d+\.\s+(.+)$", stripped)
unordered = re.match(r"^[-*]\s+(.+)$", stripped)
if ordered or unordered:
flush_paragraph()
list_tag = "ol" if ordered else "ul"
item_pattern = r"^\d+\.\s+(.+)$" if ordered else r"^[-*]\s+(.+)$"
items: list[str] = []
while i < len(lines):
item = re.match(item_pattern, lines[i].strip())
if not item:
break
items.append(f"
{parse_inline(item.group(1).strip())}
")
i += 1
blocks.append(f"<{list_tag}>{''.join(items)}")
continue
if stripped.startswith(">"):
flush_paragraph()
quote_lines: list[str] = []
while i < len(lines) and lines[i].strip().startswith(">"):
quote_lines.append(lines[i].strip()[1:].strip())
i += 1
quote = " ".join(quote_lines).strip()
blocks.append(f"