"""Deterministic Markdown -> DOCX export with an embedded title font.

The implementation intentionally uses Python's standard library only.  It
builds the small set of OOXML parts required by Word instead of depending on a
desktop Office installation or a document-conversion service.  The bundled
方正小标宋简体 font is validated and embedded according to ECMA-376 so the
recipient's computer does not need the font installed.
"""

from __future__ import annotations

import base64
import binascii
import hashlib
import io
import os
import re
import struct
import uuid
import zipfile
from dataclasses import dataclass
from datetime import UTC, datetime
from pathlib import Path
from xml.sax.saxutils import escape

DOCX_MEDIA_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.document"

TITLE_FONT_FAMILY = "方正小标宋简体"
BODY_FONT_FAMILY = "仿宋"
HEADING_1_FONT_FAMILY = "黑体"
HEADING_2_FONT_FAMILY = "楷体"
TABLE_FONT_FAMILY = "宋体"

TITLE_SIZE_HALF_POINTS = 44  # 二号 / 22 pt
BODY_SIZE_HALF_POINTS = 32  # 三号 / 16 pt
TABLE_SIZE_HALF_POINTS = 28  # 四号 / 14 pt
EXACT_LINE_TWIPS = 579  # 28.95 pt * 20

A4_WIDTH_TWIPS = 11_906
A4_HEIGHT_TWIPS = 16_838
MARGIN_TOP_TWIPS = 2_098  # 3.7 cm
MARGIN_BOTTOM_TWIPS = 1_984  # 3.5 cm
MARGIN_LEFT_TWIPS = 1_587  # 2.8 cm
MARGIN_RIGHT_TWIPS = 1_474  # 2.6 cm
CONTENT_WIDTH_TWIPS = A4_WIDTH_TWIPS - MARGIN_LEFT_TWIPS - MARGIN_RIGHT_TWIPS

_XML_DECL = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>'
_W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
_R_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
_PACKAGE_REL_NS = "http://schemas.openxmlformats.org/package/2006/relationships"

_FONT_DIR = Path(__file__).resolve().parent / "assets" / "fonts"
_BUNDLED_FONT_PATH = _FONT_DIR / "方正小标宋简体.ttf"
_BUNDLED_FONT_SHA256 = "C52D577DD3AA719EF5FB9FF2043B7F7CA36FAE468EF34A47628A3A555D006A49"


class WordExportError(RuntimeError):
    """Base error returned to the Word export API."""


class WordExportFontError(WordExportError):
    """The required server-side font is missing, invalid, or not embeddable."""


@dataclass(slots=True)
class FontAsset:
    data: bytes
    path: Path
    names: frozenset[str]
    fs_type: int
    sha256: str


@dataclass(slots=True)
class ParagraphBlock:
    kind: str
    text: str
    level: int = 0


@dataclass(slots=True)
class TableBlock:
    header: list[str]
    rows: list[list[str]]


@dataclass(slots=True)
class ImageBlock:
    alt: str
    data: bytes
    media_name: str
    width_px: int
    height_px: int


Block = ParagraphBlock | TableBlock | ImageBlock

_EMU_PER_TWIP = 635
_PNG_SIGNATURE = b"\x89PNG\r\n\x1a\n"
_MAX_EMBEDDED_IMAGES = 40
_MAX_EMBEDDED_IMAGE_BYTES = 8 * 1024 * 1024
_EMBEDDED_IMAGE_ID = re.compile(r"^embedded:([A-Za-z0-9_-]{1,80})$")
_DATA_PNG_URI = re.compile(r"^data:image/png;base64,([A-Za-z0-9+/=\s]+)$", re.IGNORECASE)


def _safe_xml_text(value: str) -> str:
    """Remove XML-illegal controls and invisible Word-breaking selectors."""
    value = re.sub(r"[\u0000-\u0008\u000b\u000c\u000e-\u001f]", "", value)
    value = re.sub(r"[\u200b-\u200d\ufeff\ufe00-\ufe0f]", "", value)
    value = value.replace("\u00ad", "").replace("\ufffc", "")
    value = re.sub(r"</?(?:details|summary)\b[^>]*>", "", value, flags=re.I)
    return value


def _xml_attr(value: str) -> str:
    return escape(_safe_xml_text(value), {'"': "&quot;", "'": "&apos;"})


def _decode_name_record(platform_id: int, raw: bytes) -> str | None:
    try:
        if platform_id in {0, 3}:
            return raw.decode("utf-16-be").strip("\x00")
        if platform_id == 1:
            return raw.decode("mac_roman").strip("\x00")
    except (UnicodeDecodeError, LookupError):
        return None
    return None


def _read_sfnt_metadata(data: bytes) -> tuple[frozenset[str], int]:
    if len(data) < 12:
        raise WordExportFontError("Word 标题字体文件不是有效的 OpenType/TrueType 字体。")
    try:
        table_count = struct.unpack_from(">H", data, 4)[0]
        tables: dict[str, tuple[int, int]] = {}
        for index in range(table_count):
            position = 12 + index * 16
            tag, _checksum, offset, length = struct.unpack_from(">4sIII", data, position)
            tag_text = tag.decode("latin-1")
            if offset + length > len(data):
                raise WordExportFontError("Word 标题字体的表目录已损坏。")
            tables[tag_text] = (offset, length)

        if "OS/2" not in tables or "name" not in tables:
            raise WordExportFontError("Word 标题字体缺少 OS/2 或 name 元数据表。")

        os2_offset, os2_length = tables["OS/2"]
        if os2_length < 10:
            raise WordExportFontError("Word 标题字体的 OS/2 元数据无效。")
        fs_type = struct.unpack_from(">H", data, os2_offset + 8)[0]

        name_offset, name_length = tables["name"]
        if name_length < 6:
            raise WordExportFontError("Word 标题字体的 name 元数据无效。")
        name_count, string_offset = struct.unpack_from(">HH", data, name_offset + 2)
        names: set[str] = set()
        for index in range(name_count):
            record_offset = name_offset + 6 + index * 12
            if record_offset + 12 > name_offset + name_length:
                break
            platform_id, _encoding, _language, name_id, length, offset = struct.unpack_from(
                ">HHHHHH", data, record_offset
            )
            if name_id not in {1, 4, 6}:
                continue
            value_start = name_offset + string_offset + offset
            value_end = value_start + length
            if value_end > name_offset + name_length:
                continue
            decoded = _decode_name_record(platform_id, data[value_start:value_end])
            if decoded:
                names.add(decoded)
        return frozenset(names), fs_type
    except struct.error as exc:
        raise WordExportFontError("Word 标题字体文件结构不完整。") from exc


def resolve_title_font_path() -> Path:
    configured = os.getenv("DEERFLOW_WORD_TITLE_FONT_PATH", "").strip()
    return Path(configured).expanduser() if configured else _BUNDLED_FONT_PATH


def load_title_font(path: Path | None = None) -> FontAsset:
    font_path = (path or resolve_title_font_path()).resolve()
    if not font_path.is_file():
        raise WordExportFontError(
            f"服务器缺少“{TITLE_FONT_FAMILY}”字体资源：{font_path}。"
            "请将已授权字体放入后端字体目录后再导出。"
        )
    data = font_path.read_bytes()
    if not data or len(data) > 25 * 1024 * 1024:
        raise WordExportFontError("Word 标题字体文件为空或超过 25 MB 限制。")

    names, fs_type = _read_sfnt_metadata(data)
    accepted_name = TITLE_FONT_FAMILY in names or any("FZXiaoBiaoSong" in name for name in names)
    if not accepted_name:
        readable_names = "、".join(sorted(names)[:6]) or "无法读取"
        raise WordExportFontError(
            f"服务器字体不是“{TITLE_FONT_FAMILY}”（检测到：{readable_names}），已阻止导出。"
        )
    if fs_type & 0x0002:
        raise WordExportFontError(f"“{TITLE_FONT_FAMILY}”授权标志禁止文档嵌入，已阻止导出。")
    if fs_type & 0x0200:
        raise WordExportFontError(f"“{TITLE_FONT_FAMILY}”仅允许位图嵌入，不能用于本次 Word 导出。")

    digest = hashlib.sha256(data).hexdigest().upper()
    if font_path == _BUNDLED_FONT_PATH.resolve() and digest != _BUNDLED_FONT_SHA256:
        raise WordExportFontError("代码仓库中的 Word 标题字体校验和不匹配，已阻止导出。")
    return FontAsset(data=data, path=font_path, names=names, fs_type=fs_type, sha256=digest)


def _obfuscate_font(data: bytes, font_key: str) -> bytes:
    """Apply the ECMA-376 ODTTF XOR obfuscation to the first 32 bytes."""
    key_hex = font_key.replace("-", "")
    if len(key_hex) != 32:
        raise WordExportFontError("生成 Word 嵌入字体密钥失败。")
    key = bytes.fromhex(key_hex)[::-1]
    output = bytearray(data)
    for index in range(min(32, len(output))):
        output[index] ^= key[index % len(key)]
    return bytes(output)


def _strip_inline_markdown(text: str) -> str:
    text = _safe_xml_text(text)
    text = re.sub(r"^\s*#+\s*", "", text)
    text = re.sub(r"!\[([^\]]*)\]\([^)]*\)", r"\1", text)
    text = re.sub(r"\[([^\]]+)\]\([^)]*\)", r"\1", text)
    text = re.sub(r"(?:\*\*|__)(.*?)(?:\*\*|__)", r"\1", text)
    return re.sub(r"[`*_~]", "", text).strip()


def _strip_manual_heading_number(text: str) -> str:
    return re.sub(
        r"^\s*(?:"
        r"[一二三四五六七八九十百千]+[、.．]"
        r"|[（(]\s*[一二三四五六七八九十百千]+\s*[）)]"
        r"|[（(]\s*\d+(?:[.．]\d+)*\s*[）)]"
        r"|\d+(?:[.．]\d+)+(?:[.．、])?"
        r"|\d+[.．、)）]"
        r")\s*",
        "",
        text,
    ).strip()


def _split_table_row(line: str) -> list[str]:
    value = re.sub(r"^\s*\|", "", line)
    value = re.sub(r"\|\s*$", "", value)
    return [part.replace(r"\|", "|").strip() for part in re.split(r"(?<!\\)\|", value)]


def _is_table_separator(line: str) -> bool:
    cells = _split_table_row(line)
    return bool(cells) and all(re.fullmatch(r":?-{3,}:?", cell.replace(" ", "")) for cell in cells)


def _looks_like_table_row(line: str) -> bool:
    return bool(re.match(r"^\s*\|.+", line))


def _is_table_caption(text: str) -> bool:
    return bool(re.match(r"^\s*表\s*(?:\d+|[一二三四五六七八九十百]+|[：:])", _strip_inline_markdown(text)))


def _extract_title(markdown: str, explicit_title: str | None) -> tuple[str | None, list[str]]:
    lines = markdown.replace("\r\n", "\n").replace("\r", "\n").split("\n")
    in_fence = False
    for index, line in enumerate(lines):
        if line.strip().startswith("```"):
            in_fence = not in_fence
            continue
        if not in_fence:
            match = re.match(r"^#\s+(.+)$", line)
            if match:
                del lines[index]
                return _strip_inline_markdown(match.group(1)) or (explicit_title or "").strip() or None, lines
    return (explicit_title or "").strip() or None, lines


def _png_size(data: bytes) -> tuple[int, int]:
    if len(data) < 24 or data[:8] != _PNG_SIGNATURE:
        raise WordExportError("嵌入的流程图不是有效的 PNG 图片。")
    width, height = struct.unpack(">II", data[16:24])
    if width < 1 or height < 1 or width > 20_000 or height > 20_000:
        raise WordExportError("嵌入图片尺寸无效。")
    return width, height


def _decode_png_base64(payload: str) -> bytes:
    try:
        data = base64.b64decode(re.sub(r"\s+", "", payload), validate=False)
    except (ValueError, binascii.Error) as exc:
        raise WordExportError("嵌入图片编码无效。") from exc
    if not data or len(data) > _MAX_EMBEDDED_IMAGE_BYTES:
        raise WordExportError("嵌入图片为空或超过 8 MB 限制。")
    _png_size(data)
    return data


def _resolve_markdown_image(
    alt: str,
    target: str,
    embedded_images: dict[str, str],
    image_index: int,
) -> Block:
    payload: str | None = None
    embedded = _EMBEDDED_IMAGE_ID.match(target.strip())
    if embedded:
        payload = embedded_images.get(embedded.group(1))
    else:
        data_uri = _DATA_PNG_URI.match(target.strip())
        if data_uri:
            payload = data_uri.group(1)
    if not payload:
        return ParagraphBlock("image", f"图片：{alt}|{target}")
    try:
        data = _decode_png_base64(payload)
        width, height = _png_size(data)
    except WordExportError:
        return ParagraphBlock("image", f"图片：{alt}|{target}")
    return ImageBlock(
        alt=alt,
        data=data,
        media_name=f"image{image_index}.png",
        width_px=width,
        height_px=height,
    )


def _parse_markdown(
    markdown: str,
    explicit_title: str | None,
    embedded_images: dict[str, str] | None = None,
) -> tuple[str | None, list[Block]]:
    title, lines = _extract_title(markdown, explicit_title)
    blocks: list[Block] = []
    paragraph_buffer: list[str] = []
    in_fence = False
    images = embedded_images or {}
    image_count = 0

    def flush_paragraph() -> None:
        if paragraph_buffer:
            blocks.append(ParagraphBlock("body", " ".join(paragraph_buffer)))
            paragraph_buffer.clear()

    index = 0
    while index < len(lines):
        raw = lines[index].replace("\t", "    ")
        if raw.strip().startswith("```"):
            flush_paragraph()
            in_fence = not in_fence
            index += 1
            continue
        if in_fence:
            blocks.append(ParagraphBlock("code", raw or " "))
            index += 1
            continue
        if not raw.strip():
            flush_paragraph()
            index += 1
            continue

        heading = re.match(r"^(#{1,6})\s+(.+)$", raw)
        if heading:
            flush_paragraph()
            markdown_level = max(2, len(heading.group(1)))
            section_level = max(0, min(markdown_level - 2, 4))
            blocks.append(ParagraphBlock("heading", _strip_manual_heading_number(heading.group(2)), section_level))
            index += 1
            continue

        if _looks_like_table_row(raw) and index + 1 < len(lines) and _is_table_separator(lines[index + 1]):
            caption: str | None = None
            if paragraph_buffer and _is_table_caption(paragraph_buffer[-1]):
                caption = paragraph_buffer.pop()
            flush_paragraph()
            if caption:
                blocks.append(ParagraphBlock("table_caption", caption))
            header = _split_table_row(raw)
            index += 2
            rows: list[list[str]] = []
            while index < len(lines) and _looks_like_table_row(lines[index]):
                rows.append(_split_table_row(lines[index]))
                index += 1
            blocks.append(TableBlock(header, rows))
            continue

        image = re.match(r'^\s*!\[([^\]]*)\]\(([^)]+)(?:\s+["\'][^"\']*["\'])?\)\s*$', raw)
        if image:
            flush_paragraph()
            alt = image.group(1).strip() or "未命名图片"
            target = image.group(2).strip()
            if image_count >= _MAX_EMBEDDED_IMAGES and (
                _EMBEDDED_IMAGE_ID.match(target) or _DATA_PNG_URI.match(target)
            ):
                blocks.append(ParagraphBlock("image", f"图片：{alt}|{target}"))
            else:
                resolved = _resolve_markdown_image(alt, target, images, image_count + 1)
                if isinstance(resolved, ImageBlock):
                    image_count += 1
                blocks.append(resolved)
            index += 1
            continue

        quote = re.match(r"^>\s?(.*)$", raw)
        if quote:
            flush_paragraph()
            blocks.append(ParagraphBlock("quote", quote.group(1)))
            index += 1
            continue

        ordered = re.match(r"^(\s*)(\d+)[.)、]\s+(.+)$", raw)
        if ordered:
            flush_paragraph()
            blocks.append(ParagraphBlock("ordered_list", ordered.group(3), min(len(ordered.group(1)) // 2, 8)))
            index += 1
            continue

        unordered = re.match(r"^(\s*)[-*+]\s+(.+)$", raw)
        if unordered:
            flush_paragraph()
            blocks.append(ParagraphBlock("unordered_list", unordered.group(2), min(len(unordered.group(1)) // 2, 8)))
            index += 1
            continue

        if re.fullmatch(r"\s*(?:---|\*\*\*|___)\s*", raw):
            flush_paragraph()
            index += 1
            continue

        paragraph_buffer.append(raw.strip())
        index += 1

    flush_paragraph()
    return title, blocks


class _DocumentRelationships:
    def __init__(self) -> None:
        self._hyperlinks: list[tuple[str, str]] = []
        self._images: list[tuple[str, str]] = []
        self._drawing_id = 0

    def add_hyperlink(self, target: str) -> str:
        relation_id = f"rId{100 + len(self._hyperlinks)}"
        self._hyperlinks.append((relation_id, target))
        return relation_id

    def add_image(self, target: str) -> tuple[str, int]:
        self._drawing_id += 1
        relation_id = f"rId{200 + len(self._images)}"
        self._images.append((relation_id, target))
        return relation_id, self._drawing_id

    def xml(self) -> str:
        fixed = [
            ("rId1", "http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles", "styles.xml"),
            ("rId2", "http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering", "numbering.xml"),
            ("rId3", "http://schemas.openxmlformats.org/officeDocument/2006/relationships/settings", "settings.xml"),
            ("rId4", "http://schemas.openxmlformats.org/officeDocument/2006/relationships/fontTable", "fontTable.xml"),
            ("rId5", "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer", "footer1.xml"),
            ("rId6", "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer", "footer2.xml"),
        ]
        relationships = "".join(
            f'<Relationship Id="{relation_id}" Type="{rel_type}" Target="{target}"/>'
            for relation_id, rel_type, target in fixed
        )
        relationships += "".join(
            f'<Relationship Id="{relation_id}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink" Target="{_xml_attr(target)}" TargetMode="External"/>'
            for relation_id, target in self._hyperlinks
        )
        relationships += "".join(
            f'<Relationship Id="{relation_id}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/image" Target="{_xml_attr(target)}"/>'
            for relation_id, target in self._images
        )
        return f'{_XML_DECL}<Relationships xmlns="{_PACKAGE_REL_NS}">{relationships}</Relationships>'


_INLINE_PATTERN = re.compile(
    r"\[([^\]]+)\]\(([^)\s]+)(?:\s+[\"\'][^\"\']*[\"\'])?\)|(`+)([^`]+)\3|\*\*([^*]+)\*\*|__([^_]+)__|\*([^*]+)\*|_([^_]+)_"
)


def _run_xml(
    text: str,
    *,
    font: str = BODY_FONT_FAMILY,
    size: int = BODY_SIZE_HALF_POINTS,
    bold: bool = False,
    italic: bool = False,
    underline: bool = False,
) -> str:
    text = _safe_xml_text(text)
    preserve = text.startswith(" ") or text.endswith(" ") or "  " in text
    properties = (
        f'<w:rFonts w:ascii="{_xml_attr(font)}" w:hAnsi="{_xml_attr(font)}" '
        f'w:eastAsia="{_xml_attr(font)}" w:cs="{_xml_attr(font)}"/>'
        '<w:color w:val="000000"/>'
        f'<w:sz w:val="{size}"/><w:szCs w:val="{size}"/>'
    )
    if bold:
        properties += "<w:b/><w:bCs/>"
    if italic:
        properties += "<w:i/><w:iCs/>"
    if underline:
        properties += '<w:u w:val="single"/>'
    space = ' xml:space="preserve"' if preserve else ""
    return f"<w:r><w:rPr>{properties}</w:rPr><w:t{space}>{escape(text)}</w:t></w:r>"


def _inline_xml(
    text: str,
    relationships: _DocumentRelationships,
    *,
    font: str = BODY_FONT_FAMILY,
    size: int = BODY_SIZE_HALF_POINTS,
) -> str:
    cleaned = _safe_xml_text(text)
    output: list[str] = []
    cursor = 0
    for match in _INLINE_PATTERN.finditer(cleaned):
        if match.start() > cursor:
            output.append(_run_xml(cleaned[cursor : match.start()], font=font, size=size))
        if match.group(1) is not None and match.group(2) is not None:
            relation_id = relationships.add_hyperlink(match.group(2))
            output.append(
                f'<w:hyperlink r:id="{relation_id}" w:history="1">'
                f'{_run_xml(match.group(1), font=font, size=size, underline=True)}</w:hyperlink>'
            )
        elif match.group(4) is not None:
            output.append(_run_xml(match.group(4), font=font, size=size))
        elif match.group(5) is not None:
            output.append(_run_xml(match.group(5), font=font, size=size, bold=True))
        elif match.group(6) is not None:
            output.append(_run_xml(match.group(6), font=font, size=size, bold=True))
        elif match.group(7) is not None:
            output.append(_run_xml(match.group(7), font=font, size=size, italic=True))
        elif match.group(8) is not None:
            output.append(_run_xml(match.group(8), font=font, size=size, italic=True))
        cursor = match.end()
    if cursor < len(cleaned):
        output.append(_run_xml(cleaned[cursor:], font=font, size=size))
    return "".join(output) or _run_xml(" ", font=font, size=size)


def _paragraph_xml(
    style: str,
    children: str,
    *,
    numbering_level: int | None = None,
    numbering_id: int = 1,
    keep_next: bool = False,
    alignment: str | None = None,
) -> str:
    properties = f'<w:pStyle w:val="{style}"/>'
    if numbering_level is not None:
        properties += (
            f'<w:numPr><w:ilvl w:val="{numbering_level}"/><w:numId w:val="{numbering_id}"/></w:numPr>'
        )
    if keep_next:
        properties += "<w:keepNext/>"
    if alignment:
        properties += f'<w:jc w:val="{alignment}"/>'
    return f"<w:p><w:pPr>{properties}</w:pPr>{children}</w:p>"


def _image_extent_emu(width_px: int, height_px: int) -> tuple[int, int]:
    max_width_emu = CONTENT_WIDTH_TWIPS * _EMU_PER_TWIP
    width_emu = max(1, int(width_px * 9525))
    height_emu = max(1, int(height_px * 9525))
    if width_emu > max_width_emu:
        scale = max_width_emu / width_emu
        width_emu = max_width_emu
        height_emu = max(1, int(height_emu * scale))
    return width_emu, height_emu


def _embedded_image_xml(block: ImageBlock, relationships: _DocumentRelationships) -> str:
    relation_id, drawing_id = relationships.add_image(f"media/{block.media_name}")
    cx, cy = _image_extent_emu(block.width_px, block.height_px)
    name = _xml_attr(block.alt or block.media_name)
    drawing = (
        '<w:r><w:drawing><wp:inline distT="0" distB="0" distL="0" distR="0">'
        f'<wp:extent cx="{cx}" cy="{cy}"/>'
        f'<wp:docPr id="{drawing_id}" name="{name}"/>'
        '<a:graphic xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main">'
        '<a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture">'
        '<pic:pic xmlns:pic="http://schemas.openxmlformats.org/drawingml/2006/picture">'
        f'<pic:nvPicPr><pic:cNvPr id="0" name="{name}"/><pic:cNvPicPr/></pic:nvPicPr>'
        f'<pic:blipFill><a:blip r:embed="{relation_id}"/><a:stretch><a:fillRect/></a:stretch></pic:blipFill>'
        "<pic:spPr>"
        f'<a:xfrm><a:off x="0" y="0"/><a:ext cx="{cx}" cy="{cy}"/></a:xfrm>'
        '<a:prstGeom prst="rect"><a:avLst/></a:prstGeom>'
        "</pic:spPr></pic:pic></a:graphicData></a:graphic></wp:inline></w:drawing></w:r>"
    )
    return (
        "<w:p><w:pPr>"
        '<w:pStyle w:val="ImageCaption"/>'
        '<w:jc w:val="center"/>'
        '<w:spacing w:before="160" w:after="160" w:line="240" w:lineRule="auto"/>'
        '<w:ind w:left="0" w:hanging="0" w:firstLineChars="0"/>'
        f"</w:pPr>{drawing}</w:p>"
    )


def _image_paragraph_xml(text: str, relationships: _DocumentRelationships) -> str:
    label, _, target = text.partition("|")
    children = _run_xml(label)
    if target:
        relation_id = relationships.add_hyperlink(target)
        children += (
            f'<w:hyperlink r:id="{relation_id}" w:history="1">'
            f'{_run_xml(f"（{target}）", underline=True)}</w:hyperlink>'
        )
    return _paragraph_xml("ImageCaption", children, alignment="center")


def _cell_xml(text: str, width: int, relationships: _DocumentRelationships, *, header: bool) -> str:
    style = "TableHeader" if header else "TableBody"
    paragraph = _paragraph_xml(
        style,
        _inline_xml(text, relationships, font=TABLE_FONT_FAMILY, size=TABLE_SIZE_HALF_POINTS),
    )
    return (
        "<w:tc>"
        f'<w:tcPr><w:tcW w:w="{width}" w:type="dxa"/><w:vAlign w:val="center"/>'
        '<w:tcMar><w:top w:w="80" w:type="dxa"/><w:left w:w="100" w:type="dxa"/>'
        '<w:bottom w:w="80" w:type="dxa"/><w:right w:w="100" w:type="dxa"/></w:tcMar></w:tcPr>'
        f"{paragraph}</w:tc>"
    )


def _table_xml(block: TableBlock, relationships: _DocumentRelationships) -> str:
    column_count = max(1, len(block.header))
    base_width = CONTENT_WIDTH_TWIPS // column_count
    widths = [base_width] * column_count
    widths[-1] = CONTENT_WIDTH_TWIPS - base_width * (column_count - 1)
    grid = "".join(f'<w:gridCol w:w="{width}"/>' for width in widths)
    border = (
        '<w:top w:val="single" w:sz="4" w:color="000000"/>'
        '<w:left w:val="single" w:sz="4" w:color="000000"/>'
        '<w:bottom w:val="single" w:sz="4" w:color="000000"/>'
        '<w:right w:val="single" w:sz="4" w:color="000000"/>'
        '<w:insideH w:val="single" w:sz="4" w:color="000000"/>'
        '<w:insideV w:val="single" w:sz="4" w:color="000000"/>'
    )
    properties = (
        f'<w:tblPr><w:tblW w:w="{CONTENT_WIDTH_TWIPS}" w:type="dxa"/>'
        '<w:jc w:val="center"/><w:tblLayout w:type="fixed"/>'
        f"<w:tblBorders>{border}</w:tblBorders></w:tblPr>"
    )

    header = list(block.header[:column_count]) + [""] * max(0, column_count - len(block.header))
    header_cells = "".join(
        _cell_xml(header[index], widths[index], relationships, header=True) for index in range(column_count)
    )
    rows = [f"<w:tr><w:trPr><w:tblHeader/><w:cantSplit/></w:trPr>{header_cells}</w:tr>"]
    for source_row in block.rows:
        normalized = list(source_row[:column_count]) + [""] * max(0, column_count - len(source_row))
        cells = "".join(
            _cell_xml(normalized[index], widths[index], relationships, header=False)
            for index in range(column_count)
        )
        rows.append(f"<w:tr><w:trPr><w:cantSplit/></w:trPr>{cells}</w:tr>")
    return f"<w:tbl>{properties}<w:tblGrid>{grid}</w:tblGrid>{''.join(rows)}</w:tbl>"


def _blocks_xml(blocks: list[Block], relationships: _DocumentRelationships) -> str:
    output: list[str] = []
    for block in blocks:
        if isinstance(block, ImageBlock):
            output.append(_embedded_image_xml(block, relationships))
            continue
        if isinstance(block, TableBlock):
            output.append(_table_xml(block, relationships))
            continue
        if block.kind == "heading":
            style = f"Heading{block.level + 1}"
            font = (
                HEADING_1_FONT_FAMILY
                if block.level == 0
                else HEADING_2_FONT_FAMILY
                if block.level == 1
                else BODY_FONT_FAMILY
            )
            output.append(
                _paragraph_xml(
                    style,
                    _inline_xml(block.text, relationships, font=font),
                    numbering_level=block.level,
                    numbering_id=1,
                    keep_next=True,
                )
            )
        elif block.kind == "table_caption":
            output.append(
                _paragraph_xml(
                    "TableCaption",
                    _inline_xml(block.text, relationships, font=HEADING_1_FONT_FAMILY, size=TABLE_SIZE_HALF_POINTS),
                    keep_next=True,
                )
            )
        elif block.kind == "ordered_list":
            output.append(
                _paragraph_xml(
                    "ListText",
                    _inline_xml(block.text, relationships),
                    numbering_level=block.level,
                    numbering_id=2,
                )
            )
        elif block.kind == "unordered_list":
            output.append(
                _paragraph_xml(
                    "ListText",
                    _inline_xml(block.text, relationships),
                    numbering_level=block.level,
                    numbering_id=3,
                )
            )
        elif block.kind == "code":
            output.append(_paragraph_xml("CodeText", _run_xml(block.text)))
        elif block.kind == "quote":
            output.append(_paragraph_xml("QuoteText", _inline_xml(block.text, relationships)))
        elif block.kind == "image":
            output.append(_image_paragraph_xml(block.text, relationships))
        else:
            output.append(_paragraph_xml("BodyText", _inline_xml(block.text, relationships)))
    return "".join(output)


def _font_run_properties(font: str, size: int, *, bold: bool = False) -> str:
    value = (
        f'<w:rFonts w:ascii="{_xml_attr(font)}" w:hAnsi="{_xml_attr(font)}" '
        f'w:eastAsia="{_xml_attr(font)}" w:cs="{_xml_attr(font)}"/>'
        '<w:color w:val="000000"/>'
        f'<w:sz w:val="{size}"/><w:szCs w:val="{size}"/>'
    )
    return value + ("<w:b/><w:bCs/>" if bold else '<w:b w:val="0"/><w:bCs w:val="0"/>')


def _style_xml(
    style_id: str,
    name: str,
    *,
    font: str,
    size: int,
    based_on: str | None = "Normal",
    next_style: str = "BodyText",
    alignment: str = "both",
    first_line_chars: int = 0,
    left: int = 0,
    hanging: int = 0,
    keep_next: bool = False,
    keep_lines: bool = False,
    outline_level: int | None = None,
    bold: bool = False,
) -> str:
    paragraph = (
        f'<w:jc w:val="{alignment}"/><w:spacing w:before="0" w:after="0" '
        f'w:line="{EXACT_LINE_TWIPS}" w:lineRule="exact"/>'
        f'<w:ind w:left="{left}" w:hanging="{hanging}" w:firstLineChars="{first_line_chars}"/>'
    )
    if keep_next:
        paragraph += "<w:keepNext/>"
    if keep_lines:
        paragraph += "<w:keepLines/>"
    if outline_level is not None:
        paragraph += f'<w:outlineLvl w:val="{outline_level}"/>'
    based_on_xml = f'<w:basedOn w:val="{based_on}"/>' if based_on else ""
    return (
        f'<w:style w:type="paragraph" w:styleId="{style_id}"><w:name w:val="{_xml_attr(name)}"/>'
        f'{based_on_xml}<w:next w:val="{next_style}"/><w:qFormat/>'
        f"<w:pPr>{paragraph}</w:pPr><w:rPr>{_font_run_properties(font, size, bold=bold)}</w:rPr></w:style>"
    )


def _styles_xml() -> str:
    defaults = (
        "<w:docDefaults><w:rPrDefault><w:rPr>"
        f"{_font_run_properties(BODY_FONT_FAMILY, BODY_SIZE_HALF_POINTS)}"
        '<w:lang w:val="zh-CN" w:eastAsia="zh-CN"/></w:rPr></w:rPrDefault>'
        '<w:pPrDefault><w:pPr><w:jc w:val="both"/>'
        f'<w:spacing w:before="0" w:after="0" w:line="{EXACT_LINE_TWIPS}" w:lineRule="exact"/>'
        '<w:ind w:firstLineChars="200"/></w:pPr></w:pPrDefault></w:docDefaults>'
    )
    styles = [
        _style_xml(
            "Normal",
            "Normal",
            font=BODY_FONT_FAMILY,
            size=BODY_SIZE_HALF_POINTS,
            based_on=None,
            next_style="BodyText",
            first_line_chars=200,
        ),
        _style_xml(
            "DocumentTitle",
            "Document Title",
            font=TITLE_FONT_FAMILY,
            size=TITLE_SIZE_HALF_POINTS,
            alignment="center",
            keep_next=True,
        ),
        _style_xml(
            "BodyText",
            "Body Text",
            font=BODY_FONT_FAMILY,
            size=BODY_SIZE_HALF_POINTS,
            first_line_chars=200,
        ),
        _style_xml(
            "Heading1",
            "heading 1",
            font=HEADING_1_FONT_FAMILY,
            size=BODY_SIZE_HALF_POINTS,
            alignment="left",
            first_line_chars=200,
            keep_next=True,
            keep_lines=True,
            outline_level=0,
        ),
        _style_xml(
            "Heading2",
            "heading 2",
            font=HEADING_2_FONT_FAMILY,
            size=BODY_SIZE_HALF_POINTS,
            alignment="left",
            first_line_chars=200,
            keep_next=True,
            keep_lines=True,
            outline_level=1,
        ),
    ]
    for level in range(3, 6):
        styles.append(
            _style_xml(
                f"Heading{level}",
                f"heading {level}",
                font=BODY_FONT_FAMILY,
                size=BODY_SIZE_HALF_POINTS,
                alignment="left",
                first_line_chars=200 if level == 3 else 0,
                keep_next=True,
                keep_lines=True,
                outline_level=level - 1,
            )
        )
    styles.extend(
        [
            _style_xml(
                "ListText",
                "List Text",
                font=BODY_FONT_FAMILY,
                size=BODY_SIZE_HALF_POINTS,
                alignment="both",
            ),
            _style_xml(
                "QuoteText",
                "Quote Text",
                font=BODY_FONT_FAMILY,
                size=BODY_SIZE_HALF_POINTS,
                alignment="both",
                first_line_chars=200,
                left=640,
            ),
            _style_xml(
                "CodeText",
                "Code Text",
                font=BODY_FONT_FAMILY,
                size=BODY_SIZE_HALF_POINTS,
                alignment="left",
            ),
            _style_xml(
                "TableCaption",
                "Table Caption",
                font=HEADING_1_FONT_FAMILY,
                size=TABLE_SIZE_HALF_POINTS,
                alignment="center",
                keep_next=True,
            ),
            _style_xml(
                "TableHeader",
                "Table Header",
                font=TABLE_FONT_FAMILY,
                size=TABLE_SIZE_HALF_POINTS,
                alignment="center",
                keep_lines=True,
            ),
            _style_xml(
                "TableBody",
                "Table Body",
                font=TABLE_FONT_FAMILY,
                size=TABLE_SIZE_HALF_POINTS,
                alignment="both",
                keep_lines=True,
            ),
            _style_xml(
                "ImageCaption",
                "Image Caption",
                font=BODY_FONT_FAMILY,
                size=BODY_SIZE_HALF_POINTS,
                alignment="center",
                keep_lines=True,
            ),
        ]
    )
    return f'{_XML_DECL}<w:styles xmlns:w="{_W_NS}">{defaults}{"".join(styles)}</w:styles>'


def _heading_level_xml(level: int, format_value: str, text: str, font: str) -> str:
    restart = f'<w:lvlRestart w:val="{level}"/>' if level > 0 else ""
    first_line_chars = ' w:firstLineChars="200"' if level <= 2 else ""
    return (
        f'<w:lvl w:ilvl="{level}"><w:start w:val="1"/>{restart}<w:numFmt w:val="{format_value}"/>'
        f'<w:lvlText w:val="{_xml_attr(text)}"/><w:lvlJc w:val="left"/>'
        f'<w:pPr><w:ind w:left="0" w:hanging="0"{first_line_chars}/></w:pPr>'
        f'<w:rPr>{_font_run_properties(font, BODY_SIZE_HALF_POINTS)}</w:rPr></w:lvl>'
    )


def _list_abstract_xml(abstract_id: int, *, ordered: bool) -> str:
    levels: list[str] = []
    bullets = ["●", "○", "▪"]
    for level in range(9):
        format_value = "decimal" if ordered else "bullet"
        text = f"%{level + 1}." if ordered else bullets[level % len(bullets)]
        left = 720 * (level + 1)
        levels.append(
            f'<w:lvl w:ilvl="{level}"><w:start w:val="1"/><w:numFmt w:val="{format_value}"/>'
            f'<w:lvlText w:val="{_xml_attr(text)}"/><w:lvlJc w:val="left"/>'
            f'<w:pPr><w:tabs><w:tab w:val="num" w:pos="{left}"/></w:tabs>'
            f'<w:ind w:left="{left}" w:hanging="360"/></w:pPr>'
            f'<w:rPr>{_font_run_properties(BODY_FONT_FAMILY, BODY_SIZE_HALF_POINTS)}</w:rPr></w:lvl>'
        )
    return f'<w:abstractNum w:abstractNumId="{abstract_id}"><w:multiLevelType w:val="multilevel"/>{"".join(levels)}</w:abstractNum>'


def _numbering_xml() -> str:
    heading_levels = "".join(
        [
            _heading_level_xml(0, "chineseCounting", "%1、", HEADING_1_FONT_FAMILY),
            _heading_level_xml(1, "chineseCounting", "(%2)", HEADING_2_FONT_FAMILY),
            _heading_level_xml(2, "decimal", "%3.", BODY_FONT_FAMILY),
            _heading_level_xml(3, "decimal", "（%4）", BODY_FONT_FAMILY),
            _heading_level_xml(4, "decimal", "%5）", BODY_FONT_FAMILY),
        ]
    )
    return (
        f'{_XML_DECL}<w:numbering xmlns:w="{_W_NS}">'
        f'<w:abstractNum w:abstractNumId="0"><w:multiLevelType w:val="multilevel">'
        f"</w:multiLevelType>{heading_levels}</w:abstractNum>"
        f'{_list_abstract_xml(1, ordered=True)}{_list_abstract_xml(2, ordered=False)}'
        '<w:num w:numId="1"><w:abstractNumId w:val="0"/></w:num>'
        '<w:num w:numId="2"><w:abstractNumId w:val="1"/></w:num>'
        '<w:num w:numId="3"><w:abstractNumId w:val="2"/></w:num>'
        "</w:numbering>"
    )


def _footer_xml(alignment: str) -> str:
    run_properties = _font_run_properties(TABLE_FONT_FAMILY, TABLE_SIZE_HALF_POINTS)
    return (
        f'{_XML_DECL}<w:ftr xmlns:w="{_W_NS}" xmlns:r="{_R_NS}">'
        f'<w:p><w:pPr><w:jc w:val="{alignment}"/><w:spacing w:before="0" w:after="0"/></w:pPr>'
        f'<w:r><w:rPr>{run_properties}</w:rPr><w:fldChar w:fldCharType="begin"/></w:r>'
        f'<w:r><w:rPr>{run_properties}</w:rPr><w:instrText xml:space="preserve"> PAGE </w:instrText></w:r>'
        f'<w:r><w:rPr>{run_properties}</w:rPr><w:fldChar w:fldCharType="separate"/></w:r>'
        f'<w:r><w:rPr>{run_properties}</w:rPr><w:t>1</w:t></w:r>'
        f'<w:r><w:rPr>{run_properties}</w:rPr><w:fldChar w:fldCharType="end"/></w:r>'
        "</w:p></w:ftr>"
    )


def _font_table_xml(font_key: str) -> str:
    def font(name: str, *, embedded: bool = False) -> str:
        embed = f'<w:embedRegular r:id="rId1" w:fontKey="{{{font_key}}}"/>' if embedded else ""
        return (
            f'<w:font w:name="{_xml_attr(name)}"><w:family w:val="roman"/>'
            f'<w:charset w:val="86"/>{embed}</w:font>'
        )

    fonts = "".join(
        [
            font(TITLE_FONT_FAMILY, embedded=True),
            font(BODY_FONT_FAMILY),
            font(HEADING_1_FONT_FAMILY),
            font(HEADING_2_FONT_FAMILY),
            font(TABLE_FONT_FAMILY),
        ]
    )
    return f'{_XML_DECL}<w:fonts xmlns:w="{_W_NS}" xmlns:r="{_R_NS}">{fonts}</w:fonts>'


def _font_table_relationships_xml() -> str:
    return (
        f'{_XML_DECL}<Relationships xmlns="{_PACKAGE_REL_NS}">'
        '<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/font" Target="fonts/font1.odttf"/>'
        "</Relationships>"
    )


def _settings_xml() -> str:
    return (
        f'{_XML_DECL}<w:settings xmlns:w="{_W_NS}">'
        '<w:zoom w:percent="100"/><w:evenAndOddHeaders/><w:updateFields w:val="true"/>'
        '<w:compat><w:compatSetting w:name="compatibilityMode" '
        'w:uri="http://schemas.microsoft.com/office/word" w:val="15"/></w:compat>'
        "</w:settings>"
    )


def _document_xml(title: str | None, blocks: list[Block], relationships: _DocumentRelationships) -> str:
    body: list[str] = []
    if title:
        body.append(
            _paragraph_xml(
                "DocumentTitle",
                _run_xml(title, font=TITLE_FONT_FAMILY, size=TITLE_SIZE_HALF_POINTS),
                keep_next=True,
                alignment="center",
            )
        )
    body.append(_blocks_xml(blocks, relationships))
    section = (
        '<w:sectPr><w:footerReference w:type="default" r:id="rId5"/>'
        '<w:footerReference w:type="even" r:id="rId6"/>'
        f'<w:pgSz w:w="{A4_WIDTH_TWIPS}" w:h="{A4_HEIGHT_TWIPS}" w:orient="portrait"/>'
        f'<w:pgMar w:top="{MARGIN_TOP_TWIPS}" w:right="{MARGIN_RIGHT_TWIPS}" '
        f'w:bottom="{MARGIN_BOTTOM_TWIPS}" w:left="{MARGIN_LEFT_TWIPS}" '
        'w:header="720" w:footer="992" w:gutter="0"/>'
        '<w:pgNumType w:start="1" w:fmt="decimal"/><w:cols w:space="720"/></w:sectPr>'
    )
    return (
        f'{_XML_DECL}<w:document xmlns:w="{_W_NS}" xmlns:r="{_R_NS}" '
        'xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing">'
        f"<w:body>{''.join(body)}{section}</w:body></w:document>"
    )


def _content_types_xml() -> str:
    return (
        f'{_XML_DECL}<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">'
        '<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>'
        '<Default Extension="xml" ContentType="application/xml"/>'
        '<Default Extension="odttf" ContentType="application/vnd.openxmlformats-officedocument.obfuscatedFont"/>'
        '<Default Extension="png" ContentType="image/png"/>'
        '<Override PartName="/word/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/>'
        '<Override PartName="/word/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml"/>'
        '<Override PartName="/word/numbering.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml"/>'
        '<Override PartName="/word/settings.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml"/>'
        '<Override PartName="/word/fontTable.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.fontTable+xml"/>'
        '<Override PartName="/word/footer1.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml"/>'
        '<Override PartName="/word/footer2.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml"/>'
        '<Override PartName="/docProps/core.xml" ContentType="application/vnd.openxmlformats-package.core-properties+xml"/>'
        '<Override PartName="/docProps/app.xml" ContentType="application/vnd.openxmlformats-officedocument.extended-properties+xml"/>'
        "</Types>"
    )


def _package_relationships_xml() -> str:
    return (
        f'{_XML_DECL}<Relationships xmlns="{_PACKAGE_REL_NS}">'
        '<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/>'
        '<Relationship Id="rId2" Type="http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties" Target="docProps/core.xml"/>'
        '<Relationship Id="rId3" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties" Target="docProps/app.xml"/>'
        "</Relationships>"
    )


def _core_properties_xml(title: str | None) -> str:
    now = datetime.now(UTC).replace(microsecond=0).isoformat().replace("+00:00", "Z")
    safe_title = escape(title or "Word 文档")
    return (
        f'{_XML_DECL}<cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" '
        'xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/" '
        'xmlns:dcmitype="http://purl.org/dc/dcmitype/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">'
        f"<dc:title>{safe_title}</dc:title><dc:creator>DeerFlow</dc:creator>"
        f'<dcterms:created xsi:type="dcterms:W3CDTF">{now}</dcterms:created>'
        f'<dcterms:modified xsi:type="dcterms:W3CDTF">{now}</dcterms:modified></cp:coreProperties>'
    )


def _app_properties_xml() -> str:
    return (
        f'{_XML_DECL}<Properties xmlns="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties" '
        'xmlns:vt="http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes">'
        "<Application>DeerFlow</Application><AppVersion>1.0</AppVersion></Properties>"
    )


def build_markdown_docx(
    markdown: str,
    title: str | None = None,
    *,
    font_path: Path | None = None,
    embedded_images: dict[str, str] | None = None,
) -> bytes:
    """Build a formal DOCX and embed the validated server-side title font."""
    if not markdown or not markdown.strip():
        raise WordExportError("文档内容为空。")
    if len(markdown) > 2_000_000:
        raise WordExportError("文档内容超过 200 万字符，无法导出。")
    if embedded_images and len(embedded_images) > _MAX_EMBEDDED_IMAGES:
        raise WordExportError("嵌入图片数量超过限制。")

    font = load_title_font(font_path)
    resolved_title, blocks = _parse_markdown(markdown, title, embedded_images)
    relationships = _DocumentRelationships()
    document_xml = _document_xml(resolved_title, blocks, relationships)
    font_key = str(uuid.uuid4()).upper()
    media_files = {
        f"word/media/{block.media_name}": block.data for block in blocks if isinstance(block, ImageBlock)
    }

    output = io.BytesIO()
    with zipfile.ZipFile(output, mode="w", compression=zipfile.ZIP_DEFLATED, compresslevel=6) as archive:
        parts: dict[str, str | bytes] = {
            "[Content_Types].xml": _content_types_xml(),
            "_rels/.rels": _package_relationships_xml(),
            "docProps/core.xml": _core_properties_xml(resolved_title),
            "docProps/app.xml": _app_properties_xml(),
            "word/document.xml": document_xml,
            "word/_rels/document.xml.rels": relationships.xml(),
            "word/styles.xml": _styles_xml(),
            "word/numbering.xml": _numbering_xml(),
            "word/settings.xml": _settings_xml(),
            "word/fontTable.xml": _font_table_xml(font_key),
            "word/_rels/fontTable.xml.rels": _font_table_relationships_xml(),
            # Word applies the default footer to odd pages and the even footer
            # to even pages. The requested placement is odd-left/even-right.
            "word/footer1.xml": _footer_xml("left"),
            "word/footer2.xml": _footer_xml("right"),
            "word/fonts/font1.odttf": _obfuscate_font(font.data, font_key),
            **media_files,
        }
        for name, value in parts.items():
            archive.writestr(name, value.encode("utf-8") if isinstance(value, str) else value)
    return output.getvalue()


__all__ = [
    "DOCX_MEDIA_TYPE",
    "TITLE_FONT_FAMILY",
    "WordExportError",
    "WordExportFontError",
    "build_markdown_docx",
    "load_title_font",
    "resolve_title_font_path",
]