\n"]
for i, h in enumerate(headers):
align = aligns[i] if i < len(aligns) else None
style = f' style="text-align:{align}"' if align else ""
out.append(f" {_parse_inline(h, ref_links)}\n")
out.append("
\n\n")
if body_lines:
out.append("\n")
for line in body_lines:
cells = _parse_table_row(line)
out.append("
\n")
for i, cell in enumerate(cells):
align = aligns[i] if i < len(aligns) else None
style = f' style="text-align:{align}"' if align else ""
out.append(f" {_parse_inline(cell, ref_links)}\n")
out.append("
\n")
out.append("\n")
out.append("
\n")
return "".join(out)
# ── List parser ───────────────────────────────────────────────────────────────
def _detect_list_type(
line: str,
) -> tuple[bool, int, int] | None:
"""Detect whether a line starts a list item.
Returns:
(ordered, base_indent, start_num) or None if not a list item.
"""
ol_m = _OL_ITEM_RE.match(line)
if ol_m:
return True, len(ol_m.group(1)), int(ol_m.group(2))
ul_m = _UL_ITEM_RE.match(line)
if ul_m:
return False, len(ul_m.group(1)), 1
return None
def _blank_continues_list(
lines: list[str],
idx: int,
ordered: bool,
base_indent: int,
) -> bool:
"""Check whether a blank line at *idx* is followed by list continuation."""
if idx + 1 >= len(lines):
return False
next_line = lines[idx + 1]
if _BLANK_RE.match(next_line):
return False
# Same-level item?
if ordered:
m = _OL_ITEM_RE.match(next_line)
if m and len(m.group(1)) == base_indent:
return True
else:
m = _UL_ITEM_RE.match(next_line)
if m and len(m.group(1)) == base_indent:
return True
# Indented continuation / nested content
next_indent = len(next_line) - len(next_line.lstrip())
return next_indent > base_indent
def _match_same_level_item(
line: str,
ordered: bool,
base_indent: int,
) -> str | None:
"""If *line* is a same-level list item, return its content text."""
if ordered:
m = _OL_ITEM_RE.match(line)
if m and len(m.group(1)) == base_indent:
return m.group(4)
else:
m = _UL_ITEM_RE.match(line)
if m and len(m.group(1)) == base_indent:
return m.group(3)
return None
def _collect_list_items(
lines: list[str],
start_idx: int,
ordered: bool,
base_indent: int,
) -> tuple[list[list[str]], int]:
"""Collect raw item line groups from a list block.
Returns:
(items, next_idx) where each item is a list of content lines.
"""
idx = start_idx
items: list[list[str]] = []
current: list[str] = []
while idx < len(lines):
line = lines[idx]
# Blank line — may separate items or end the list
if _BLANK_RE.match(line):
if _blank_continues_list(lines, idx, ordered, base_indent):
current.append("")
idx += 1
continue
break
# Same-level item starts a new entry
content = _match_same_level_item(line, ordered, base_indent)
if content is not None:
if current:
items.append(current)
current = [content]
idx += 1
continue
# Nested / continuation line
indent = len(line) - len(line.lstrip())
if indent > base_indent and current:
dedented = line[base_indent + 2 :] if len(line) > base_indent + 2 else ""
current.append(dedented)
idx += 1
continue
break
if current:
items.append(current)
return items, idx
def _render_list_item(
item_lines: list[str],
ref_links: dict[str, tuple[str, str | None]],
) -> str:
"""Render a single
element, recursing for nested sub-lists."""
# Detect task list marker
task_class = ""
task_checkbox = ""
first_line = item_lines[0]
task_m = _TASK_LIST_RE.match(first_line)
if task_m:
checked = task_m.group(1) in ("x", "X")
task_class = ' class="task-list-item"'
task_checkbox = (
'" + task_checkbox
if has_sublist:
first = _parse_inline(item_lines[0], ref_links)
sub_html = _parse_blocks(item_lines[1:], ref_links)
return open_tag + first + sub_html + "
\n"
content = "\n".join(item_lines).strip()
return open_tag + _parse_inline(content, ref_links) + "\n"
def _parse_list_block(
lines: list[str],
start_idx: int,
ref_links: dict[str, tuple[str, str | None]],
) -> tuple[str, int]:
"""Parse a list block starting at *start_idx*. Returns (html, next_idx)."""
info = _detect_list_type(lines[start_idx])
if info is None:
return "", start_idx
ordered, base_indent, start_num = info
items, idx = _collect_list_items(lines, start_idx, ordered, base_indent)
tag = "ol" if ordered else "ul"
start_attr = f' start="{start_num}"' if ordered and start_num != 1 else ""
parts: list[str] = [f"<{tag}{start_attr}>\n"]
for item_lines in items:
parts.append(_render_list_item(item_lines, ref_links))
parts.append(f"\n")
return "".join(parts), idx
# ── Block-level try-parse helpers ────────────────────────────────────────────
_BlockResult = tuple[str, int, bool]
"""(html, new_idx, consumed_para) returned by each _try_parse_* helper."""
def _try_parse_hr(
lines: list[str],
idx: int,
ref_links: dict[str, tuple[str, str | None]],
para_lines: list[str],
) -> _BlockResult | None:
"""Try to parse a thematic break."""
if para_lines:
return None
if _THEMATIC_BREAK_RE.match(lines[idx]):
return "\n", idx + 1, False
return None
def _try_parse_atx_heading(
lines: list[str],
idx: int,
ref_links: dict[str, tuple[str, str | None]],
para_lines: list[str],
) -> _BlockResult | None:
"""Try to parse an ATX heading."""
if para_lines:
return None
m = _ATX_HEADING_RE.match(lines[idx])
if not m:
return None
level = len(m.group(1))
content = re.sub(r"\s+#+\s*$", "", m.group(2).strip())
tag = f"h{level}"
h = f"<{tag}>{_parse_inline(content, ref_links)}\n"
return h, idx + 1, False
def _try_parse_setext_heading(
lines: list[str],
idx: int,
ref_links: dict[str, tuple[str, str | None]],
para_lines: list[str],
) -> _BlockResult | None:
"""Try to parse a Setext heading (requires accumulated paragraph lines)."""
if not para_lines:
return None
line = lines[idx]
if not _SETEXT_HEADING_RE.match(line):
return None
level = 1 if line.strip().startswith("=") else 2
content = "\n".join(para_lines)
tag = f"h{level}"
h = f"<{tag}>{_parse_inline(content.strip(), ref_links)}\n"
return h, idx + 1, True # consumed_para=True
def _try_parse_code_fence(
lines: list[str],
idx: int,
ref_links: dict[str, tuple[str, str | None]],
para_lines: list[str],
) -> _BlockResult | None:
"""Try to parse a fenced code block."""
if para_lines:
return None
m = _FENCED_CODE_RE.match(lines[idx])
if not m:
return None
fence_indent = len(m.group(1))
fence_char = m.group(2)[0]
fence_len = len(m.group(2))
lang = m.group(3).strip()
code_lines: list[str] = []
j = idx + 1
close_re = re.compile(
r"^ {0,3}" + re.escape(fence_char) + r"{" + str(fence_len) + r",}\s*$"
)
while j < len(lines):
cl = lines[j]
if close_re.match(cl):
j += 1
break
code_lines.append(_strip_fence_indent(cl, fence_indent))
j += 1
code = "\n".join(code_lines)
if code and not code.endswith("\n"):
code += "\n"
escaped_code = html.escape(code, quote=False)
lang_attr = f' class="language-{html.escape(lang, quote=True)}"' if lang else ""
h = f"
{escaped_code}
\n"
return h, j, False
def _strip_fence_indent(line: str, indent: int) -> str:
"""Remove up to *indent* leading spaces from *line*."""
if indent <= 0:
return line
for _ in range(indent):
if line.startswith(" "):
line = line[1:]
else:
break
return line
def _try_parse_indent_code(
lines: list[str],
idx: int,
ref_links: dict[str, tuple[str, str | None]],
para_lines: list[str],
) -> _BlockResult | None:
"""Try to parse an indented code block (4-space indent)."""
if para_lines:
return None
if not _INDENT_CODE_RE.match(lines[idx]):
return None
code_lines: list[str] = []
j = idx
while j < len(lines):
ic_m = _INDENT_CODE_RE.match(lines[j])
if ic_m:
code_lines.append(ic_m.group(1))
j += 1
elif _BLANK_RE.match(lines[j]):
if j + 1 < len(lines) and _INDENT_CODE_RE.match(lines[j + 1]):
code_lines.append("")
j += 1
else:
break
else:
break
# Remove trailing blank lines
while code_lines and code_lines[-1] == "":
code_lines.pop()
escaped_code = html.escape("\n".join(code_lines), quote=False)
h = f"
{escaped_code}
\n"
return h, j, False
def _try_parse_blockquote(
lines: list[str],
idx: int,
ref_links: dict[str, tuple[str, str | None]],
para_lines: list[str],
) -> _BlockResult | None:
"""Try to parse a block quote (can interrupt a paragraph)."""
if not _BLOCK_QUOTE_RE.match(lines[idx]):
return None
bq_lines: list[str] = []
j = idx
while j < len(lines):
bq_match = _BLOCK_QUOTE_RE.match(lines[j])
if bq_match:
bq_lines.append(bq_match.group(1))
j += 1
elif _BLANK_RE.match(lines[j]):
if j + 1 < len(lines) and _BLOCK_QUOTE_RE.match(lines[j + 1]):
bq_lines.append("")
j += 1
else:
break
elif lines[j].strip():
# Lazy continuation
bq_lines.append(lines[j])
j += 1
else:
break
inner = _parse_blocks(bq_lines, ref_links)
h = "
\n" + inner + "
\n"
return h, j, False
def _try_parse_list(
lines: list[str],
idx: int,
ref_links: dict[str, tuple[str, str | None]],
para_lines: list[str],
) -> _BlockResult | None:
"""Try to parse an ordered or unordered list."""
if para_lines:
return None
if not (_UL_ITEM_RE.match(lines[idx]) or _OL_ITEM_RE.match(lines[idx])):
return None
list_html, new_idx = _parse_list_block(lines, idx, ref_links)
return list_html, new_idx, False
def _try_parse_table(
lines: list[str],
idx: int,
ref_links: dict[str, tuple[str, str | None]],
para_lines: list[str],
) -> _BlockResult | None:
"""Try to parse a GFM table."""
if para_lines:
return None
line = lines[idx]
if "|" not in line or idx + 1 >= len(lines):
return None
if not _TABLE_DELIM_RE.match(lines[idx + 1]):
return None
header_line = line
align_line = lines[idx + 1]
body: list[str] = []
j = idx + 2
while j < len(lines):
tl = lines[j]
if "|" in tl and not _BLANK_RE.match(tl):
body.append(tl)
j += 1
else:
break
h = _render_table(header_line, align_line, body, ref_links)
return h, j, False
# Ordered list of try-parse functions used by the block dispatcher.
_BLOCK_PARSERS = (
_try_parse_hr,
_try_parse_atx_heading,
_try_parse_setext_heading,
_try_parse_code_fence,
_try_parse_indent_code,
_try_parse_blockquote,
_try_parse_list,
_try_parse_table,
)
# ── Block parser ──────────────────────────────────────────────────────────────
def _collect_ref_links(
lines: list[str],
) -> dict[str, tuple[str, str | None]]:
"""First pass: collect reference link definitions."""
refs: dict[str, tuple[str, str | None]] = {}
for line in lines:
m = _REF_LINK_RE.match(line)
if m:
key = m.group(1).strip().lower()
url = m.group(2)
title = m.group(3)
refs[key] = (url, title)
return refs
def _parse_blocks(
lines: list[str],
ref_links: dict[str, tuple[str, str | None]],
) -> str:
"""Parse block-level Markdown elements from a list of lines."""
out: list[str] = []
idx = 0
para_lines: list[str] = []
def flush_paragraph() -> None:
if para_lines:
text = "\n".join(para_lines)
out.append("
" + _parse_inline(text.strip(), ref_links) + "
\n")
para_lines.clear()
while idx < len(lines):
line = lines[idx]
# Skip reference link definitions (already collected)
if _REF_LINK_RE.match(line):
flush_paragraph()
idx += 1
continue
# Blank line
if _BLANK_RE.match(line):
flush_paragraph()
idx += 1
continue
# Try each block-level parser in priority order
result = _dispatch_block(lines, idx, ref_links, para_lines)
if result is not None:
block_html, idx, consumed_para = result
if consumed_para:
para_lines.clear()
else:
flush_paragraph()
out.append(block_html)
continue
# Paragraph accumulation
para_lines.append(line)
idx += 1
flush_paragraph()
return "".join(out)
def _dispatch_block(
lines: list[str],
idx: int,
ref_links: dict[str, tuple[str, str | None]],
para_lines: list[str],
) -> _BlockResult | None:
"""Try each registered block parser; return first match or None."""
for try_fn in _BLOCK_PARSERS:
result = try_fn(lines, idx, ref_links, para_lines)
if result is not None:
return result
return None
# ── Public API ────────────────────────────────────────────────────────────────
def render(text: str) -> str:
"""Convert Markdown text to HTML.
Args:
text: Markdown source string.
Returns:
HTML string.
"""
# Normalize line endings
text = text.replace("\r\n", "\n").replace("\r", "\n")
# Split into lines
lines = text.split("\n")
# Remove trailing newline that produces empty last element
if lines and lines[-1] == "":
lines.pop()
# First pass: collect reference link definitions
ref_links = _collect_ref_links(lines)
# Second pass: parse blocks
return _parse_blocks(lines, ref_links)