@birthday8/doc-mcp 1.0.0 → 1.0.2

package/python/docx_converter.py

@@ -4,13 +4,230 @@ from docx.enum.text import WD_PARAGRAPH_ALIGNMENT, WD_LINE_SPACING
 from docx.enum.section import WD_SECTION
 from docx.oxml.ns import qn
 from docx.oxml import OxmlElement
+from docx.enum.shape import WD_INLINE_SHAPE
 from bs4 import BeautifulSoup
 import os
 import re
+import json
+
+# 尝试导入 math2docx
+try:
+    import math2docx
+
+    HAS_MATH2DOCX = True
+except ImportError:
+    HAS_MATH2DOCX = False
+    print("Warning: math2docx not installed. Formula support will be limited.")
+
+# ==================== 预编译正则表达式 ====================
+# 样式解析相关
+TEXT_ALIGN_RE = re.compile(r"text-align:\s*([^;]+)")
+LINE_HEIGHT_RE = re.compile(r"line-height:\s*([^;]+)")
+COLOR_RE = re.compile(r"(?<!background-)color:\s*([^;]+)")
+BACKGROUND_COLOR_RE = re.compile(r"background-color:\s*([^;]+)")
+FONT_FAMILY_RE = re.compile(r"font-family:\s*([^;]+)")
+FONT_SIZE_RE = re.compile(r"font-size:\s*([^;]+)")
+FONT_WEIGHT_RE = re.compile(r"font-weight:\s*([^;]+)")
+FONT_STYLE_RE = re.compile(r"font-style:\s*([^;]+)")
+TEXT_DECORATION_RE = re.compile(r"text-decoration:\s*([^;]+)")
+MARGIN_RE = re.compile(r"margin(?:-(top|bottom|left|right))?:\s*([^;]+)")
+PADDING_RE = re.compile(r"padding(?:-(top|bottom|left|right))?:\s*([^;]+)")
+
+# 公式相关
+LATEX_FORMULA_RE = re.compile(r"\$\$(.*?)\$\$|\$(.*?)\$")
+
+
+# ==================== 常量配置 ====================
+class ConverterConfig:
+    """转换器配置常量"""
+
+    DEFAULT_FONT = "微软雅黑"
+    DEFAULT_SIZE = 12
+
+    # 页面设置
+    PAGE_HEIGHT_CM = 29.7
+    PAGE_WIDTH_CM = 21.0
+    MARGIN_CM = 2.54
+
+    # 字体大小映射
+    HEADING_SIZES = {
+        1: 18,
+        2: 16,
+        3: 14,
+        4: 14,
+        5: 14,
+        6: 14,
+    }
+
+    # 标题颜色
+    HEADING_COLORS = {
+        1: RGBColor(74, 63, 107),
+        2: RGBColor(91, 78, 140),
+        3: RGBColor(107, 91, 149),
+        4: RGBColor(122, 104, 161),
+        5: RGBColor(137, 117, 173),
+        6: RGBColor(152, 130, 185),
+    }
+
+    # 特殊类名颜色
+    CLASS_COLORS = {
+        "red": RGBColor(255, 0, 0),
+        "blue": RGBColor(0, 0, 255),
+        "green": RGBColor(0, 128, 0),
+        "purple": RGBColor(128, 0, 128),
+    }
+
+    # 提示框颜色
+    INFO_COLORS = {
+        "bg": "E3F2FD",
+        "border": "2196F3",
+    }
+    WARNING_COLORS = {
+        "bg": "FFF3CD",
+        "border": "FFC107",
+    }
+    SUCCESS_COLORS = {
+        "bg": "D4EDDA",
+        "border": "28A745",
+    }
+
+    # 颜色映射
+    COLOR_MAP = {
+        "red": "FF0000",
+        "green": "008000",
+        "blue": "0000FF",
+        "yellow": "FFFF00",
+        "orange": "FFA500",
+        "purple": "800080",
+        "pink": "FFC0CB",
+        "brown": "A52A2A",
+        "gray": "808080",
+        "black": "000000",
+        "white": "FFFFFF",
+    }
+
+
+def add_image(doc, image_path, width=None, height=None, align="center"):
+    """添加图片到文档
+
+    Args:
+        doc: Word文档对象
+        image_path: 图片路径（绝对路径或相对于html文件的路径）
+        width: 图片宽度（英寸，可选）
+        height: 图片高度（英寸，可选）
+        align: 对齐方式（'left', 'center', 'right'）
+    """
+    # 检查文件是否存在
+    if not os.path.exists(image_path):
+        print(f"Warning: Image file not found: {image_path}")
+        # 添加占位文本
+        para = doc.add_paragraph()
+        run = para.add_run(f"[图片: {os.path.basename(image_path)}]")
+        run.font.color.rgb = RGBColor(150, 150, 150)
+        return False
+
+    try:
+        # 创建段落并设置对齐
+        para = doc.add_paragraph()
+        if align == "center":
+            para.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
+        elif align == "right":
+            para.alignment = WD_PARAGRAPH_ALIGNMENT.RIGHT
+        else:
+            para.alignment = WD_PARAGRAPH_ALIGNMENT.LEFT
+
+        # 添加图片
+        if width and height:
+            run = para.add_run()
+            run.add_picture(image_path, width=Inches(width), height=Inches(height))
+        elif width:
+            run = para.add_run()
+            run.add_picture(image_path, width=Inches(width))
+        elif height:
+            run = para.add_run()
+            run.add_picture(image_path, height=Inches(height))
+        else:
+            run = para.add_run()
+            run.add_picture(image_path)
+
+        return True
+
+    except Exception as e:
+        print(f"Warning: Failed to add image {image_path}: {e}")
+        import traceback
+
+        traceback.print_exc()
+        # 添加占位文本
+        para = doc.add_paragraph()
+        run = para.add_run(f"[图片: {os.path.basename(image_path)}]")
+        run.font.color.rgb = RGBColor(150, 150, 150)
+        return False
+
+
+def latex_to_unicode_formula(latex_formula):
+    """将 LaTeX 公式转换为 Unicode 数学符号"""
+    # 简单的 LaTeX 到 Unicode 转换映射
+    conversions = {
+        r"\^2": "²",
+        r"\^3": "³",
+        r"\_2": "₂",
+        r"\_3": "₃",
+        r"\\cdot": "·",
+        r"\\times": "×",
+        r"\\div": "÷",
+        r"\\neq": "≠",
+        r"\\leq": "≤",
+        r"\\geq": "≥",
+        r"\\pm": "±",
+        r"\\sqrt": "√",
+        r"\\pi": "π",
+        r"\\alpha": "α",
+        r"\\beta": "β",
+        r"\\gamma": "γ",
+        r"\\delta": "δ",
+        r"\\theta": "θ",
+        r"\\lambda": "λ",
+        r"\\mu": "μ",
+        r"\\sigma": "σ",
+        r"\\phi": "φ",
+        r"\\omega": "ω",
+        r"\\infty": "∞",
+    }
+
+    result = latex_formula
+    for latex, unicode_char in conversions.items():
+        result = result.replace(latex, unicode_char)
+
+    return result
+
+
+def add_native_formula(
+    para,
+    latex_formula,
+    color=None,
+    font_name=None,
+    font_size=None,
+    bold=False,
+    italic=False,
+):
+    """添加 Word 原生公式"""
+    if HAS_MATH2DOCX:
+        try:
+            # 添加公式
+            math2docx.add_math(para, latex_formula)
+            return True
+        except Exception as e:
+            print(f"Warning: Failed to add native formula: {e}")
+            import traceback
+
+            traceback.print_exc()
+            return False
+    return False
+
 
 def parse_color(color_str):
     """解析颜色字符串为RGBColor"""
-    if not color_str or not color_str.startswith('#'):
+    if not color_str or not color_str.startswith("#"):
         return None
     try:
         r = int(color_str[1:3], 16)
@@ -20,185 +237,112 @@ def parse_color(color_str):
     except:
         return None
 
-def set_font(run, font_name='微软雅黑', size=12, color=None, bold=False, italic=False, 
-            underline=False, strike=False, highlight_color=None):
+
+def set_font(
+    run,
+    font_name="微软雅黑",
+    size=12,
+    color=None,
+    bold=False,
+    italic=False,
+    underline=False,
+    strike=False,
+    highlight_color=None,
+):
     """设置字体样式"""
     run.font.name = font_name
-    run._element.rPr.rFonts.set(qn('w:eastAsia'), font_name)
+    run._element.rPr.rFonts.set(qn("w:eastAsia"), font_name)
     run.font.size = Pt(size)
     run.font.bold = bold
     run.font.italic = italic
-    
+
     if color:
         run.font.color.rgb = color
-    
+
     if underline:
         run.font.underline = True
-    
+
     if strike:
         run.font.strike = True
-    
+
     if highlight_color:
         from docx.enum.text import WD_COLOR_INDEX
+
         color_map = {
-            'yellow': WD_COLOR_INDEX.YELLOW,
-            'green': WD_COLOR_INDEX.BRIGHT_GREEN,
-            'cyan': WD_COLOR_INDEX.CYAN,
-            'magenta': WD_COLOR_INDEX.MAGENTA,
-            'blue': WD_COLOR_INDEX.TURQUOISE,
-            'red': WD_COLOR_INDEX.RED,
-            'darkblue': WD_COLOR_INDEX.BLUE,
-            'orange': WD_COLOR_INDEX.ORANGE,
-            'gray': WD_COLOR_INDEX.GRAY_25,
+            "yellow": WD_COLOR_INDEX.YELLOW,
+            "green": WD_COLOR_INDEX.BRIGHT_GREEN,
+            "cyan": WD_COLOR_INDEX.CYAN,
+            "magenta": WD_COLOR_INDEX.MAGENTA,
+            "blue": WD_COLOR_INDEX.TURQUOISE,
+            "red": WD_COLOR_INDEX.RED,
+            "darkblue": WD_COLOR_INDEX.BLUE,
+            "orange": WD_COLOR_INDEX.ORANGE,
+            "gray": WD_COLOR_INDEX.GRAY_25,
         }
         if highlight_color in color_map:
             run.font.highlight_color = color_map[highlight_color]
 
-def process_inline_elements(element, parent_run=None):
-    """处理内联元素"""
-    from docx.text.paragraph import Paragraph
-    
-    runs = []
-    
-    for child in element.children:
-        if child.name is None:  # 文本节点
-            text = str(child).strip()
-            if text:
-                if parent_run:
-                    parent_run.add_text(text)
-                else:
-                    runs.append({'text': text})
-        elif child.name == 'strong' or child.name == 'b':
-            if parent_run:
-                parent_run.bold = True
-                process_inline_elements(child, parent_run)
-            else:
-                runs.append({'text': child.get_text(), 'bold': True})
-        elif child.name == 'em' or child.name == 'i':
-            if parent_run:
-                parent_run.italic = True
-                process_inline_elements(child, parent_run)
-            else:
-                runs.append({'text': child.get_text(), 'italic': True})
-        elif child.name == 'u':
-            if parent_run:
-                parent_run.underline = True
-                process_inline_elements(child, parent_run)
-            else:
-                runs.append({'text': child.get_text(), 'underline': True})
-        elif child.name == 's' or child.name == 'del':
-            if parent_run:
-                parent_run.strike = True
-                process_inline_elements(child, parent_run)
-            else:
-                runs.append({'text': child.get_text(), 'strike': True})
-        elif child.name == 'sup':
-            if parent_run:
-                parent_run.font.superscript = True
-                process_inline_elements(child, parent_run)
-            else:
-                runs.append({'text': child.get_text(), 'superscript': True})
-        elif child.name == 'sub':
-            if parent_run:
-                parent_run.font.subscript = True
-                process_inline_elements(child, parent_run)
-            else:
-                runs.append({'text': child.get_text(), 'subscript': True})
-        elif child.name == 'code':
-            code_text = child.get_text()
-            if parent_run:
-                parent_run.font.name = 'Consolas'
-                parent_run.font.size = Pt(10)
-                parent_run.add_text(code_text)
-            else:
-                runs.append({'text': code_text, 'font': 'Consolas', 'size': 10})
-        elif child.name == 'a':
-            link_text = child.get_text()
-            href = child.get('href', '')
-            if parent_run:
-                parent_run.add_text(link_text)
-            else:
-                runs.append({'text': link_text, 'link': href})
-        elif child.name == 'span':
-            style = child.get('style', '')
-            color_match = re.search(r'color:\s*([^;]+)', style)
-            bg_match = re.search(r'background(?:-color)?:\s*([^;]+)', style)
-            
-            props = {'text': child.get_text()}
-            if color_match:
-                color = parse_color(color_match.group(1).strip())
-                if color:
-                    props['color'] = color
-            if bg_match:
-                bg_color = bg_match.group(1).strip()
-                if bg_color.startswith('#'):
-                    bg_rgb = parse_color(bg_color)
-                    if bg_rgb:
-                        props['highlight'] = str(bg_rgb)
-            
-            if parent_run:
-                if 'color' in props:
-                    parent_run.font.color.rgb = props['color']
-                process_inline_elements(child, parent_run)
-            else:
-                runs.append(props)
-        else:
-            process_inline_elements(child, parent_run)
-    
-    return runs
 
 def _apply_highlight(run, bg_color):
     """为run应用背景色/高亮"""
     from docx.enum.text import WD_COLOR_INDEX
-    
+
     # 颜色名称到WD_COLOR_INDEX的映射（只使用可用的枚举值）
     color_map = {
-        'yellow': WD_COLOR_INDEX.YELLOW,
-        'green': WD_COLOR_INDEX.GREEN,
-        'brightgreen': WD_COLOR_INDEX.BRIGHT_GREEN,
-        'blue': WD_COLOR_INDEX.BLUE,
-        'darkblue': WD_COLOR_INDEX.DARK_BLUE,
-        'red': WD_COLOR_INDEX.RED,
-        'darkred': WD_COLOR_INDEX.DARK_RED,
-        'darkyellow': WD_COLOR_INDEX.DARK_YELLOW,
-        'lightgray': WD_COLOR_INDEX.GRAY_25,
-        'gray': WD_COLOR_INDEX.GRAY_50,
-        'black': WD_COLOR_INDEX.BLACK,
-        'white': WD_COLOR_INDEX.WHITE,
-        'pink': WD_COLOR_INDEX.PINK,
-        'teal': WD_COLOR_INDEX.TEAL,
-        'turquoise': WD_COLOR_INDEX.TURQUOISE,
-        'violet': WD_COLOR_INDEX.VIOLET,
-        'cyan': WD_COLOR_INDEX.TURQUOISE,
-        'magenta': WD_COLOR_INDEX.VIOLET,
+        "yellow": WD_COLOR_INDEX.YELLOW,
+        "green": WD_COLOR_INDEX.GREEN,
+        "brightgreen": WD_COLOR_INDEX.BRIGHT_GREEN,
+        "blue": WD_COLOR_INDEX.BLUE,
+        "darkblue": WD_COLOR_INDEX.DARK_BLUE,
+        "red": WD_COLOR_INDEX.RED,
+        "darkred": WD_COLOR_INDEX.DARK_RED,
+        "darkyellow": WD_COLOR_INDEX.DARK_YELLOW,
+        "lightgray": WD_COLOR_INDEX.GRAY_25,
+        "gray": WD_COLOR_INDEX.GRAY_50,
+        "black": WD_COLOR_INDEX.BLACK,
+        "white": WD_COLOR_INDEX.WHITE,
+        "pink": WD_COLOR_INDEX.PINK,
+        "teal": WD_COLOR_INDEX.TEAL,
+        "turquoise": WD_COLOR_INDEX.TURQUOISE,
+        "violet": WD_COLOR_INDEX.VIOLET,
+        "cyan": WD_COLOR_INDEX.TURQUOISE,
+        "magenta": WD_COLOR_INDEX.VIOLET,
     }
-    
+
     # 标准化颜色名称
     bg_lower = bg_color.lower().strip()
-    
+
     if bg_lower in color_map:
         # 使用预定义的高亮色
         run.font.highlight_color = color_map[bg_lower]
-    elif bg_lower.startswith('#'):
+    elif bg_lower.startswith("#"):
         # 十六进制颜色，直接使用字符串
-        shading_elm = OxmlElement('w:shd')
-        shading_elm.set(qn('w:fill'), bg_lower[1:].upper())
+        shading_elm = OxmlElement("w:shd")
+        shading_elm.set(qn("w:fill"), bg_lower[1:].upper())
         run._element.get_or_add_rPr().append(shading_elm)
     else:
         # 尝试其他常见颜色名称映射到相近的预定义颜色
         similar_colors = {
-            'lightblue': WD_COLOR_INDEX.TURQUOISE,
-            'lightyellow': WD_COLOR_INDEX.YELLOW,
-            'lightgreen': WD_COLOR_INDEX.BRIGHT_GREEN,
-            'orange': WD_COLOR_INDEX.YELLOW,  # 橙色映射到黄色
-            'purple': WD_COLOR_INDEX.VIOLET,
-            'brown': WD_COLOR_INDEX.DARK_YELLOW,
+            "lightblue": WD_COLOR_INDEX.TURQUOISE,
+            "lightyellow": WD_COLOR_INDEX.YELLOW,
+            "lightgreen": WD_COLOR_INDEX.BRIGHT_GREEN,
+            "orange": WD_COLOR_INDEX.YELLOW,  # 橙色映射到黄色
+            "purple": WD_COLOR_INDEX.VIOLET,
+            "brown": WD_COLOR_INDEX.DARK_YELLOW,
         }
         if bg_lower in similar_colors:
             run.font.highlight_color = similar_colors[bg_lower]
 
-def process_paragraph(paragraph, doc, default_font='微软雅黑', default_size=12, 
-                     indent=None, align=None, line_spacing=None):
+
+def process_paragraph(
+    paragraph,
+    doc,
+    default_font="微软雅黑",
+    default_size=12,
+    indent=None,
+    align=None,
+    line_spacing=None,
+):
     """处理段落及其内联元素"""
     para = doc.add_paragraph()
 
@@ -211,7 +355,7 @@ def process_paragraph(paragraph, doc, default_font='微软雅黑', default_size=
         para.paragraph_format.first_line_indent = Inches(indent)
     else:
         # 从data-indent属性读取缩进（单位：em）
-        data_indent = paragraph.get('data-indent', '')
+        data_indent = paragraph.get("data-indent", "")
         if data_indent:
             try:
                 em_count = float(data_indent)
@@ -224,247 +368,551 @@ def process_paragraph(paragraph, doc, default_font='微软雅黑', default_size=
     if line_spacing:
         para.paragraph_format.line_spacing = line_spacing
 
+    # 解析段落的样式（包括行距和段距）
+    style = paragraph.get("style", "")
+
+    # 解析对齐方式
+    text_align_match = TEXT_ALIGN_RE.search(style)
+    if text_align_match:
+        align_str = text_align_match.group(1).strip().lower()
+        if align_str == "left":
+            para.alignment = WD_PARAGRAPH_ALIGNMENT.LEFT
+        elif align_str == "center":
+            para.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
+        elif align_str == "right":
+            para.alignment = WD_PARAGRAPH_ALIGNMENT.RIGHT
+        elif align_str == "justify":
+            para.alignment = WD_PARAGRAPH_ALIGNMENT.JUSTIFY
+
+    # 解析行距
+    line_height_match = LINE_HEIGHT_RE.search(style)
+    if line_height_match:
+        line_height_str = line_height_match.group(1).strip()
+        if line_height_str.endswith("pt"):
+            # 固定行距
+            para.paragraph_format.line_spacing = float(line_height_str[:-2])
+        elif line_height_str.endswith("px"):
+            # px转换为pt
+            para.paragraph_format.line_spacing = float(line_height_str[:-2]) * 0.75
+        elif line_height_str.endswith("em"):
+            # em转换为pt（基于段落字号）
+            para.paragraph_format.line_spacing = para_size * float(line_height_str[:-2])
+        else:
+            # 尝试作为倍数处理
+            try:
+                line_spacing_value = float(line_height_str)
+                para.paragraph_format.line_spacing = line_spacing_value
+            except:
+                pass
+
+    # 解析段后距
+    margin_bottom_match = MARGIN_RE.search(style)
+    if margin_bottom_match:
+        margin_bottom_str = margin_bottom_match.group(2).strip()
+        if margin_bottom_str.endswith("pt"):
+            para.paragraph_format.space_after = Pt(float(margin_bottom_str[:-2]))
+        elif margin_bottom_str.endswith("px"):
+            # px转换为pt
+            para.paragraph_format.space_after = Pt(float(margin_bottom_str[:-2]) * 0.75)
+        elif margin_bottom_str.endswith("em"):
+            # em转换为pt（基于段落字号）
+            para.paragraph_format.space_after = Pt(
+                para_size * float(margin_bottom_str[:-2])
+            )
+        else:
+            # 尝试作为pt处理
+            try:
+                para.paragraph_format.space_after = Pt(float(margin_bottom_str))
+            except:
+                pass
+
+    # 解析段前距
+    margin_top_match = MARGIN_RE.search(style)
+    if margin_top_match:
+        margin_top_str = margin_top_match.group(2).strip()
+        if margin_top_str.endswith("pt"):
+            para.paragraph_format.space_before = Pt(float(margin_top_str[:-2]))
+        elif margin_top_str.endswith("px"):
+            # px转换为pt
+            para.paragraph_format.space_before = Pt(float(margin_top_str[:-2]) * 0.75)
+        elif margin_top_str.endswith("em"):
+            # em转换为pt（基于段落字号）
+            para.paragraph_format.space_before = Pt(
+                para_size * float(margin_top_str[:-2])
+            )
+        else:
+            # 尝试作为pt处理
+            try:
+                para.paragraph_format.space_before = Pt(float(margin_top_str))
+            except:
+                pass
+
+    # 解析段落的字号
+    para_size = default_size
+    style = paragraph.get("style", "")
+    size_match = FONT_SIZE_RE.search(style)
+    if size_match:
+        size_str = size_match.group(1).strip()
+        # 处理不同单位：pt, px, em等
+        if size_str.endswith("pt"):
+            para_size = float(size_str[:-2])
+        elif size_str.endswith("px"):
+            # px转换为pt (1px ≈ 0.75pt)
+            para_size = float(size_str[:-2]) * 0.75
+        elif size_str.endswith("em"):
+            # em转换为pt (假设基础字号为12pt)
+            para_size = float(size_str[:-2]) * 12
+        else:
+            # 尝试直接解析为数字
+            try:
+                para_size = float(size_str)
+            except:
+                pass
+
     # 处理段落内容 - 递归处理所有子元素
-    _process_element_to_runs(paragraph, para, default_font, default_size)
+    _process_element_to_runs(paragraph, para, default_font, para_size)
 
     return para
 
-def _process_element_to_runs(element, para, default_font='微软雅黑', default_size=12, 
-                              bold=False, italic=False, underline=False, strike=False,
-                              color=None, bg_color=None, font_name=None, font_size=None):
+
+def _process_element_to_runs(
+    element,
+    para,
+    default_font="微软雅黑",
+    default_size=12,
+    bold=False,
+    italic=False,
+    underline=False,
+    strike=False,
+    color=None,
+    bg_color=None,
+    font_name=None,
+    font_size=None,
+):
     """递归处理元素，为不同格式的文本创建独立的runs"""
     current_font = font_name or default_font
     current_size = font_size or default_size
-    
+
     for child in element.children:
         if child.name is None:  # 文本节点
             text = str(child)
             # 去除多余空白但保留单个空格
             if text:
                 # 替换换行和制表符为空格，然后合并多个空格
-                text = ' '.join(text.replace('\n', ' ').replace('\t', ' ').split())
+                text = " ".join(text.replace("\n", " ").replace("\t", " ").split())
                 if text:  # 再次检查，因为去除空白后可能为空
                     run = para.add_run(text)
-                    set_font(run, font_name=current_font, size=current_size, 
-                            bold=bold, italic=italic, underline=underline, strike=strike)
+                    set_font(
+                        run,
+                        font_name=current_font,
+                        size=current_size,
+                        bold=bold,
+                        italic=italic,
+                        underline=underline,
+                        strike=strike,
+                    )
                     if color:
                         run.font.color.rgb = color
                     # 应用背景色
                     if bg_color:
                         _apply_highlight(run, bg_color)
-        elif child.name == 'strong' or child.name == 'b':
-            _process_element_to_runs(child, para, default_font, default_size,
-                                    bold=True, italic=italic, underline=underline, strike=strike,
-                                    color=color, bg_color=bg_color)
-        elif child.name == 'em' or child.name == 'i':
-            _process_element_to_runs(child, para, default_font, default_size,
-                                    bold=bold, italic=True, underline=underline, strike=strike,
-                                    color=color, bg_color=bg_color)
-        elif child.name == 'u':
-            _process_element_to_runs(child, para, default_font, default_size,
-                                    bold=bold, italic=italic, underline=True, strike=strike,
-                                    color=color, bg_color=bg_color)
-        elif child.name == 's' or child.name == 'del':
-            _process_element_to_runs(child, para, default_font, default_size,
-                                    bold=bold, italic=italic, underline=underline, strike=True,
-                                    color=color, bg_color=bg_color)
-        elif child.name == 'sup':
+        elif child.name == "math" or child.name == "latex":
+            # 处理 LaTeX 公式标签，添加 Word 原生公式
+            # 注意：公式不会继承父级样式（颜色、加粗、斜体等），这是 Word OMML 的限制
+            latex_formula = child.get_text().strip()
+            if latex_formula and HAS_MATH2DOCX:
+                # 添加原生公式（不传递样式参数）
+                if add_native_formula(para, latex_formula):
+                    continue  # 成功添加原生公式，跳过后续处理
+                # 如果失败，回退到文本显示
+            # 回退方案：显示为代码文本
+            run = para.add_run(latex_formula)
+            set_font(run, font_name="Consolas", size=10, color=RGBColor(0, 0, 128))
+        elif child.name == "strong" or child.name == "b":
+            _process_element_to_runs(
+                child,
+                para,
+                default_font,
+                default_size,
+                bold=True,
+                italic=italic,
+                underline=underline,
+                strike=strike,
+                color=color,
+                bg_color=bg_color,
+            )
+        elif child.name == "em" or child.name == "i":
+            _process_element_to_runs(
+                child,
+                para,
+                default_font,
+                default_size,
+                bold=bold,
+                italic=True,
+                underline=underline,
+                strike=strike,
+                color=color,
+                bg_color=bg_color,
+            )
+        elif child.name == "u":
+            _process_element_to_runs(
+                child,
+                para,
+                default_font,
+                default_size,
+                bold=bold,
+                italic=italic,
+                underline=True,
+                strike=strike,
+                color=color,
+                bg_color=bg_color,
+            )
+        elif child.name == "s" or child.name == "del":
+            _process_element_to_runs(
+                child,
+                para,
+                default_font,
+                default_size,
+                bold=bold,
+                italic=italic,
+                underline=underline,
+                strike=True,
+                color=color,
+                bg_color=bg_color,
+            )
+        elif child.name == "sup":
             for sub_child in child.children:
                 if sub_child.name is None:
                     run = para.add_run(str(sub_child))
-                    set_font(run, font_name=current_font, size=current_size,
-                            bold=bold, italic=italic, underline=underline, strike=strike)
+                    set_font(
+                        run,
+                        font_name=current_font,
+                        size=current_size,
+                        bold=bold,
+                        italic=italic,
+                        underline=underline,
+                        strike=strike,
+                    )
                     run.font.superscript = True
                     if color:
                         run.font.color.rgb = color
+                    if bg_color:
+                        _apply_highlight(run, bg_color)
                 else:
-                    _process_element_to_runs(child, para, default_font, default_size,
-                                            bold=bold, italic=italic, underline=underline, strike=strike,
-                                            color=color, bg_color=bg_color)
-        elif child.name == 'sub':
+                    # 处理嵌套元素，但保持上标
+                    _process_element_to_runs(
+                        sub_child,
+                        para,
+                        default_font,
+                        default_size,
+                        bold=bold,
+                        italic=italic,
+                        underline=underline,
+                        strike=strike,
+                        color=color,
+                        bg_color=bg_color,
+                    )
+                    # 为嵌套元素添加的上标
+                    for run in (
+                        para.runs[
+                            len(list(para.runs)) - len(sub_child.find_all(True)) :
+                        ]
+                        if para.runs
+                        else []
+                    ):
+                        run.font.superscript = True
+        elif child.name == "sub":
             for sub_child in child.children:
                 if sub_child.name is None:
                     run = para.add_run(str(sub_child))
-                    set_font(run, font_name=current_font, size=current_size,
-                            bold=bold, italic=italic, underline=underline, strike=strike)
+                    set_font(
+                        run,
+                        font_name=current_font,
+                        size=current_size,
+                        bold=bold,
+                        italic=italic,
+                        underline=underline,
+                        strike=strike,
+                    )
                     run.font.subscript = True
                     if color:
                         run.font.color.rgb = color
+                    if bg_color:
+                        _apply_highlight(run, bg_color)
                 else:
-                    _process_element_to_runs(child, para, default_font, default_size,
-                                            bold=bold, italic=italic, underline=underline, strike=strike,
-                                            color=color, bg_color=bg_color)
-        elif child.name == 'code':
+                    # 处理嵌套元素，但保持下标
+                    _process_element_to_runs(
+                        sub_child,
+                        para,
+                        default_font,
+                        default_size,
+                        bold=bold,
+                        italic=italic,
+                        underline=underline,
+                        strike=strike,
+                        color=color,
+                        bg_color=bg_color,
+                    )
+                    # 为嵌套元素添加的下标
+                    for run in (
+                        para.runs[
+                            len(list(para.runs)) - len(sub_child.find_all(True)) :
+                        ]
+                        if para.runs
+                        else []
+                    ):
+                        run.font.subscript = True
+        elif child.name == "code":
             code_text = child.get_text()
             run = para.add_run(code_text)
-            set_font(run, font_name='Consolas', size=10)
-        elif child.name == 'a':
+            set_font(run, font_name="Consolas", size=10)
+        elif child.name == "a":
             link_text = child.get_text()
             run = para.add_run(link_text)
             set_font(run, font_name=current_font, size=current_size)
             run.font.underline = True
             run.font.color.rgb = RGBColor(0, 0, 255)
-        elif child.name == 'span':
+        elif child.name == "span":
             # 处理span的样式
-            style = child.get('style', '')
-            classes = child.get('class', [])
-            
+            style = child.get("style", "")
+            classes = child.get("class", [])
+
             span_color = color
             span_bg = bg_color
-            
+            span_font = current_font  # 使用当前字体（继承父级）
+            span_size = current_size  # 使用当前字号（继承父级）
+
             # 解析style中的颜色
-            color_match = re.search(r'color:\s*([^;]+)', style)
+            color_match = COLOR_RE.search(style)
             if color_match:
                 parsed = parse_color(color_match.group(1).strip())
                 if parsed:
                     span_color = parsed
-            
+
+            # 解析 font-family
+            font_match = FONT_FAMILY_RE.search(style)
+            if font_match:
+                font_family = font_match.group(1).strip()
+                # 去除引号
+                font_family = font_family.strip("'\"").strip()
+                if font_family:
+                    span_font = font_family
+
+            # 解析 font-size
+            size_match = FONT_SIZE_RE.search(style)
+            if size_match:
+                size_str = size_match.group(1).strip()
+                # 处理不同单位：pt, px, em等
+                if size_str.endswith("pt"):
+                    span_size = float(size_str[:-2])
+                elif size_str.endswith("px"):
+                    # px转换为pt (1px ≈ 0.75pt)
+                    span_size = float(size_str[:-2]) * 0.75
+                elif size_str.endswith("em"):
+                    # em转换为pt (基于默认12pt)
+                    span_size = float(size_str[:-2]) * 12
+                else:
+                    # 尝试直接解析为数字
+                    try:
+                        span_size = float(size_str)
+                    except:
+                        pass
+
             # 解析class中的颜色
-            if 'red' in classes:
-                span_color = RGBColor(255, 0, 0)
-            elif 'blue' in classes:
-                span_color = RGBColor(0, 0, 255)
-            elif 'green' in classes:
-                span_color = RGBColor(0, 128, 0)
-            elif 'purple' in classes:
-                span_color = RGBColor(128, 0, 128)
-            
+            class_set = set(classes)  # 转换为集合提高查找性能
+            if "red" in class_set:
+                span_color = ConverterConfig.CLASS_COLORS["red"]
+            elif "blue" in class_set:
+                span_color = ConverterConfig.CLASS_COLORS["blue"]
+            elif "green" in class_set:
+                span_color = ConverterConfig.CLASS_COLORS["green"]
+            elif "purple" in class_set:
+                span_color = ConverterConfig.CLASS_COLORS["purple"]
+
             # 背景色
-            bg_match = re.search(r'background(?:-color)?:\s*([^;]+)', style)
+            bg_match = BACKGROUND_COLOR_RE.search(style)
             if bg_match:
                 span_bg = bg_match.group(1).strip()
-            if 'highlight' in classes:
-                span_bg = 'yellow'
-            
-            _process_element_to_runs(child, para, default_font, default_size,
-                                    bold=bold, italic=italic, underline=underline, strike=strike,
-                                    color=span_color, bg_color=span_bg, 
-                                    font_name=current_font, font_size=current_size)
+            if "highlight" in class_set:
+                span_bg = "yellow"
+
+            _process_element_to_runs(
+                child,
+                para,
+                default_font,
+                default_size,
+                bold=bold,
+                italic=italic,
+                underline=underline,
+                strike=strike,
+                color=span_color,
+                bg_color=span_bg,
+                font_name=span_font,
+                font_size=span_size,
+            )
         else:
             # 其他标签递归处理
-            _process_element_to_runs(child, para, default_font, default_size,
-                                    bold=bold, italic=italic, underline=underline, strike=strike,
-                                    color=color, bg_color=bg_color)
+            _process_element_to_runs(
+                child,
+                para,
+                default_font,
+                default_size,
+                bold=bold,
+                italic=italic,
+                underline=underline,
+                strike=strike,
+                color=color,
+                bg_color=bg_color,
+            )
 
-def process_list_items(items, doc, ordered=False, default_font='微软雅黑', default_size=12, level=0):
+
+def process_list_items(
+    items, doc, ordered=False, default_font="微软雅黑", default_size=12, level=0
+):
     """处理列表项，支持嵌套"""
     for item in items:
         # 创建列表项段落
         if ordered:
-            para = doc.add_paragraph(style='List Number')
+            para = doc.add_paragraph(style="List Number")
         else:
-            para = doc.add_paragraph(style='List Bullet')
-        
+            para = doc.add_paragraph(style="List Bullet")
+
         # 设置缩进：每级增加 0.25 英寸
         para.paragraph_format.left_indent = Inches(0.25 * (level + 1))
-        
+
         # 查找嵌套列表
-        nested_ul = item.find('ul', recursive=False)
-        nested_ol = item.find('ol', recursive=False)
-        
+        nested_ul = item.find("ul", recursive=False)
+        nested_ol = item.find("ol", recursive=False)
+
         # 处理列表项的文本内容（排除嵌套列表）
         # 创建一个临时副本用于提取文本
-        item_copy = BeautifulSoup(str(item), 'html.parser').find('li')
+        item_copy = BeautifulSoup(str(item), "html.parser").find("li")
         if item_copy:
             # 移除嵌套列表
-            for nested in item_copy.find_all(['ul', 'ol'], recursive=False):
+            for nested in item_copy.find_all(["ul", "ol"], recursive=False):
                 nested.decompose()
-            
+
             # 处理剩余内容
             if item_copy.get_text().strip():
                 _process_element_to_runs(item_copy, para, default_font, default_size)
-        
+
         # 递归处理嵌套列表
         if nested_ul:
-            nested_items = nested_ul.find_all('li', recursive=False)
-            process_list_items(nested_items, doc, ordered=False, 
-                             default_font=default_font, default_size=default_size, level=level+1)
+            nested_items = nested_ul.find_all("li", recursive=False)
+            process_list_items(
+                nested_items,
+                doc,
+                ordered=False,
+                default_font=default_font,
+                default_size=default_size,
+                level=level + 1,
+            )
         if nested_ol:
-            nested_items = nested_ol.find_all('li', recursive=False)
-            process_list_items(nested_items, doc, ordered=True, 
-                             default_font=default_font, default_size=default_size, level=level+1)
+            nested_items = nested_ol.find_all("li", recursive=False)
+            process_list_items(
+                nested_items,
+                doc,
+                ordered=True,
+                default_font=default_font,
+                default_size=default_size,
+                level=level + 1,
+            )
+
 
 def _parse_style(style_str):
     """解析style字符串为字典"""
     styles = {}
     if not style_str:
         return styles
-    for item in style_str.split(';'):
-        if ':' in item:
-            key, value = item.split(':', 1)
+    for item in style_str.split(";"):
+        if ":" in item:
+            key, value = item.split(":", 1)
             styles[key.strip()] = value.strip()
     return styles
 
+
 def _apply_cell_style(cell_elem, style_dict):
     """应用单元格样式"""
     # 背景色
-    bg_color = style_dict.get('background-color', '')
+    bg_color = style_dict.get("background-color", "")
     if bg_color:
         # 处理颜色值
-        if bg_color.startswith('#'):
-            shading_elm = OxmlElement('w:shd')
-            shading_elm.set(qn('w:fill'), bg_color[1:].upper())
+        if bg_color.startswith("#"):
+            shading_elm = OxmlElement("w:shd")
+            shading_elm.set(qn("w:fill"), bg_color[1:].upper())
             cell_elem._element.get_or_add_tcPr().append(shading_elm)
-    
+
     # 文字颜色
-    color = style_dict.get('color', '')
+    color = style_dict.get("color", "")
     if color:
-        rgb = parse_color(color) if color.startswith('#') else None
+        rgb = parse_color(color) if color.startswith("#") else None
         if rgb:
             for run in cell_elem.paragraphs[0].runs:
                 run.font.color.rgb = rgb
 
-def process_table(table, doc, default_font='微软雅黑', default_size=11):
+
+def process_table(table, doc, default_font="微软雅黑", default_size=11):
     """处理表格，支持内联样式"""
-    rows = table.find_all('tr')
+    rows = table.find_all("tr")
     if not rows:
         return
-    
+
     # 获取列数
-    cols = max(len(row.find_all(['td', 'th'])) for row in rows)
-    
+    cols = max(len(row.find_all(["td", "th"])) for row in rows)
+
     # 创建表格
     word_table = doc.add_table(rows=len(rows), cols=cols)
-    word_table.style = 'Table Grid'
-    
+    word_table.style = "Table Grid"
+
     for row_idx, row in enumerate(rows):
         # 处理行样式（如背景色）
-        row_style = _parse_style(row.get('style', ''))
-        row_bg = row_style.get('background-color', '')
-        
-        cells = row.find_all(['td', 'th'])
+        row_style = _parse_style(row.get("style", ""))
+        row_bg = row_style.get("background-color", "")
+
+        cells = row.find_all(["td", "th"])
         for col_idx, cell in enumerate(cells):
             if col_idx < cols:
                 cell_elem = word_table.rows[row_idx].cells[col_idx]
-                cell_elem.paragraphs[0].text = cell.get_text().strip()
-                
+
                 # 解析单元格样式
-                cell_style = _parse_style(cell.get('style', ''))
-                
+                cell_style = _parse_style(cell.get("style", ""))
+
+                # 清空默认段落
+                cell_elem.paragraphs[0].clear()
+
+                # 使用 _process_element_to_runs 处理单元格内容，保留格式
+                _process_element_to_runs(
+                    cell,
+                    cell_elem.paragraphs[0],
+                    default_font=default_font,
+                    default_size=default_size,
+                )
+
                 # 表头加粗
-                if cell.name == 'th':
+                if cell.name == "th":
                     for run in cell_elem.paragraphs[0].runs:
                         run.font.bold = True
-                
+
                 # 设置单元格对齐
-                align = cell_style.get('text-align', 'center')
-                if align == 'center':
+                align = cell_style.get("text-align", "center")
+                if align == "center":
                     cell_elem.paragraphs[0].alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
-                elif align == 'left':
+                elif align == "left":
                     cell_elem.paragraphs[0].alignment = WD_PARAGRAPH_ALIGNMENT.LEFT
-                elif align == 'right':
+                elif align == "right":
                     cell_elem.paragraphs[0].alignment = WD_PARAGRAPH_ALIGNMENT.RIGHT
-                
+
                 # 应用单元格样式（背景色、文字颜色）
                 _apply_cell_style(cell_elem, cell_style)
-                
+
                 # 如果行有背景色且单元格没有单独设置，应用行背景色
-                if row_bg and not cell_style.get('background-color'):
-                    if row_bg.startswith('#'):
-                        shading_elm = OxmlElement('w:shd')
-                        shading_elm.set(qn('w:fill'), row_bg[1:].upper())
+                if row_bg and not cell_style.get("background-color"):
+                    if row_bg.startswith("#"):
+                        shading_elm = OxmlElement("w:shd")
+                        shading_elm.set(qn("w:fill"), row_bg[1:].upper())
                         cell_elem._element.get_or_add_tcPr().append(shading_elm)
 
+
 def set_section_columns(section, cols_num=2, space=720):
     """设置节的多栏布局
 
@@ -474,11 +922,12 @@ def set_section_columns(section, cols_num=2, space=720):
         space: 栏间距（单位：twips，1英寸=1440twips），默认720（0.5英寸）
     """
     sectPr = section._sectPr
-    cols = OxmlElement('w:cols')
-    cols.set(qn('w:num'), str(cols_num))
-    cols.set(qn('w:space'), str(space))
+    cols = OxmlElement("w:cols")
+    cols.set(qn("w:num"), str(cols_num))
+    cols.set(qn("w:space"), str(space))
     sectPr.append(cols)
 
+
 def add_columns_section(doc, cols_num=2, space=720):
     """添加连续分节符并设置多栏布局（不换页）
 
@@ -496,312 +945,655 @@ def add_columns_section(doc, cols_num=2, space=720):
     set_section_columns(section, cols_num, space)
     return section
 
+
 def _process_blockquote(blockquote_elem, doc, level=0):
     """递归处理嵌套引用"""
-    # 获取当前引用的直接文本内容（不包括嵌套引用）
-    direct_text = ''
+    # 检查是否有直接内容（不包括嵌套引用）
+    has_content = False
     for child in blockquote_elem.children:
         if child.name is None:  # 文本节点
-            direct_text += str(child)
-        elif child.name != 'blockquote':  # 其他非引用标签
-            direct_text += child.get_text()
-
-    direct_text = ' '.join(direct_text.split())
+            if str(child).strip():
+                has_content = True
+                break
+        elif child.name != "blockquote" and child.get_text().strip():
+            has_content = True
+            break
 
-    # 如果有直接文本，创建段落
-    if direct_text:
+    # 如果有直接内容，创建段落
+    if has_content:
         para = doc.add_paragraph()
-        run = para.add_run(direct_text)
-        set_font(run, italic=True, color=RGBColor(100, 100, 100))
         # 根据层级设置缩进
         para.paragraph_format.left_indent = Inches(0.3 * level)
         para.paragraph_format.right_indent = Inches(0.5)
         # 添加灰色左边框
-        pBdr = OxmlElement('w:pBdr')
-        left_border = OxmlElement('w:left')
-        left_border.set(qn('w:val'), 'single')
-        left_border.set(qn('w:sz'), '18')
-        left_border.set(qn('w:color'), 'CCCCCC')
+        pBdr = OxmlElement("w:pBdr")
+        left_border = OxmlElement("w:left")
+        left_border.set(qn("w:val"), "single")
+        left_border.set(qn("w:sz"), "18")
+        left_border.set(qn("w:color"), "CCCCCC")
         pBdr.append(left_border)
         para.paragraph_format._element.get_or_add_pPr().append(pBdr)
 
+        # 创建一个临时元素来包含所有非blockquote的子元素
+        from bs4 import BeautifulSoup
+
+        temp_soup = BeautifulSoup("<div></div>", "html.parser")
+        temp_div = temp_soup.div
+
+        # 复制所有非blockquote的子元素
+        for child in blockquote_elem.children:
+            if child.name != "blockquote":
+                temp_div.append(
+                    child.__copy__() if hasattr(child, "__copy__") else child
+                )
+
+        # 使用 _process_element_to_runs 处理格式化内容
+        # 注意：引用内容默认斜体和灰色
+        _process_element_to_runs(
+            temp_div,
+            para,
+            default_font="微软雅黑",
+            default_size=12,
+            italic=True,
+            color=RGBColor(100, 100, 100),
+        )
+
     # 递归处理嵌套引用
-    nested_quotes = blockquote_elem.find_all('blockquote', recursive=False)
+    nested_quotes = blockquote_elem.find_all("blockquote", recursive=False)
     for nested in nested_quotes:
         _process_blockquote(nested, doc, level + 1)
 
+
 def add_page_break(doc):
     """添加分页符"""
     doc.add_page_break()
 
+
 def add_horizontal_rule(doc):
     """添加水平线"""
     para = doc.add_paragraph()
     para.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
-    run = para.add_run('_' * 50)
+    run = para.add_run("_" * 50)
     run.font.color.rgb = RGBColor(200, 200, 200)
 
-def convert_html_to_docx(html_file, output_file, default_font='微软雅黑', default_size=12):
+
+# ==================== 辅助函数 ====================
+def _init_document(default_font, default_size):
+    """初始化Word文档"""
+    doc = Document()
+    doc.styles["Normal"].font.name = default_font
+    doc.styles["Normal"]._element.rPr.rFonts.set(qn("w:eastAsia"), default_font)
+    doc.styles["Normal"].font.size = Pt(default_size)
+
+    # 处理页面设置
+    section = doc.sections[0]
+    section.page_height = Cm(ConverterConfig.PAGE_HEIGHT_CM)
+    section.page_width = Cm(ConverterConfig.PAGE_WIDTH_CM)
+    section.left_margin = Cm(ConverterConfig.MARGIN_CM)
+    section.right_margin = Cm(ConverterConfig.MARGIN_CM)
+    section.top_margin = Cm(ConverterConfig.MARGIN_CM)
+    section.bottom_margin = Cm(ConverterConfig.MARGIN_CM)
+
+    return doc
+
+
+def _read_html_file(html_file):
+    """读取HTML文件"""
+    with open(html_file, "r", encoding="utf-8") as f:
+        return f.read()
+
+
+def _parse_html(html_content):
+    """解析HTML内容"""
+    return BeautifulSoup(html_content, "html.parser")
+
+
+def _process_heading(element, doc, default_font):
+    """处理标题元素"""
+    level = int(element.name[1])
+    heading = doc.add_heading(element.get_text().strip(), level=level)
+    heading.alignment = WD_PARAGRAPH_ALIGNMENT.LEFT
+
+    # 标题样式
+    for run in heading.runs:
+        run.font.name = default_font
+        run._element.rPr.rFonts.set(qn("w:eastAsia"), default_font)
+        run.font.size = Pt(ConverterConfig.HEADING_SIZES.get(level, 14))
+        run.font.bold = True
+        run.font.color.rgb = ConverterConfig.HEADING_COLORS.get(
+            level, RGBColor(107, 91, 149)
+        )
+        if level == 1:
+            heading.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
+
+
+def _process_paragraph_element(element, doc, default_font, default_size):
+    """处理段落元素"""
+    classes = element.get("class", [])
+    class_set = set(classes)
+
+    if "center" in class_set:
+        para = process_paragraph(element, doc, align=WD_PARAGRAPH_ALIGNMENT.CENTER)
+    elif "right" in class_set:
+        para = process_paragraph(element, doc, align=WD_PARAGRAPH_ALIGNMENT.RIGHT)
+    elif "dialogue" in class_set:
+        para = process_paragraph(element, doc, indent=0.5, line_spacing=1.5)
+        for run in para.runs:
+            set_font(run, italic=True, color=RGBColor(107, 91, 122))
+    elif "quote" in class_set or element.get("style", "").find("background") != -1:
+        para = process_paragraph(element, doc)
+        para.paragraph_format.left_indent = Inches(1)
+        para.paragraph_format.right_indent = Inches(1)
+        from docx.enum.text import WD_BORDER
+
+        for border in para.paragraph_format._element.xpath("./w:pBdr"):
+            border.getparent().remove(border)
+        # 添加边框效果（使用浅灰色背景模拟）
+        shading_elm = OxmlElement("w:shd")
+        shading_elm.set(qn("w:fill"), "F5F5F5")
+        para.paragraph_format._element.get_or_add_pPr().append(shading_elm)
+    else:
+        process_paragraph(element, doc, indent=0.5, line_spacing=1.5)
+
+
+def _process_list_element(element, doc, ordered):
+    """处理列表元素"""
+    items = element.find_all("li", recursive=False)
+    process_list_items(items, doc, ordered=ordered)
+
+
+def _process_image_element(element, doc, html_file):
+    """处理图片元素"""
+    src = element.get("src", "")
+    if src:
+        # 解析宽度、高度和对齐方式
+        width = element.get("width")
+        height = element.get("height")
+        style = element.get("style", "")
+        align = element.get("align", "center")
+
+        # 从 style 中提取对齐方式
+        if "text-align: right" in style or "float: right" in style:
+            align = "right"
+        elif "text-align: left" in style or "float: left" in style:
+            align = "left"
+        elif "text-align: center" in style:
+            align = "center"
+
+        # 处理宽度高度（支持像素转英寸）
+        width_inch = None
+        height_inch = None
+        if width:
+            try:
+                width_px = float(width)
+                width_inch = width_px / 96  # 假设96 DPI
+            except:
+                pass
+        if height:
+            try:
+                height_px = float(height)
+                height_inch = height_px / 96
+            except:
+                pass
+
+        # 处理相对路径（相对于HTML文件）
+        html_dir = os.path.dirname(html_file)
+        image_path = os.path.join(html_dir, src) if not os.path.isabs(src) else src
+
+        # 添加图片
+        add_image(doc, image_path, width_inch, height_inch, align)
+
+
+def _process_div_element(element, doc, default_font, default_size):
+    """处理div元素"""
+    classes = element.get("class", [])
+    class_set = set(classes)
+
+    if "chapter" in class_set:
+        # 处理章节
+        h2 = element.find("h2")
+        if h2:
+            heading = doc.add_heading(h2.get_text().strip(), level=2)
+            for run in heading.runs:
+                run.font.color.rgb = RGBColor(91, 78, 140)
+                run.font.size = Pt(16)
+                run.font.name = default_font
+                run._element.rPr.rFonts.set(qn("w:eastAsia"), default_font)
+
+        paragraphs = element.find_all("p")
+        for p in paragraphs:
+            first_span = p.find("span", class_="first-line")
+            if first_span:
+                # 处理首字下沉效果
+                para = doc.add_paragraph()
+                para.paragraph_format.first_line_indent = Inches(0)
+
+                first_char_run = para.add_run(first_span.text)
+                set_font(
+                    first_char_run, size=20, bold=True, color=RGBColor(102, 126, 234)
+                )
+                remaining_text = p.get_text().replace(first_span.text, "", 1)
+                run = para.add_run(remaining_text)
+                set_font(run)
+            else:
+                process_paragraph(p, doc, indent=0.5, line_spacing=1.5)
+
+    elif "ending" in class_set:
+        para = process_paragraph(element, doc, align=WD_PARAGRAPH_ALIGNMENT.CENTER)
+        for run in para.runs:
+            set_font(run, italic=True, size=14, color=RGBColor(91, 78, 140))
+
+    elif "page-break" in class_set:
+        add_page_break(doc)
+
+    elif "columns" in class_set:
+        # 处理多栏布局（使用连续分节符，不换页）
+        cols_num = int(element.get("data-cols", "2"))
+        # 添加连续分节符并设置栏数
+        add_columns_section(doc, cols_num)
+        # 处理其中的段落
+        for p in element.find_all("p", recursive=False):
+            process_paragraph(
+                p, doc, default_font=default_font, default_size=default_size
+            )
+
+    elif "info" in class_set or "warning" in class_set or "success" in class_set:
+        # 处理提示框
+        para = doc.add_paragraph()
+        para.paragraph_format.right_indent = Inches(0.3)
+
+        # 设置背景色和左边框颜色
+        if "info" in class_set:
+            bg_color = ConverterConfig.INFO_COLORS["bg"]
+            border_color = ConverterConfig.INFO_COLORS["border"]
+        elif "warning" in class_set:
+            bg_color = ConverterConfig.WARNING_COLORS["bg"]
+            border_color = ConverterConfig.WARNING_COLORS["border"]
+        else:  # success
+            bg_color = ConverterConfig.SUCCESS_COLORS["bg"]
+            border_color = ConverterConfig.SUCCESS_COLORS["border"]
+
+        # 处理内容
+        _process_element_to_runs(element, para, default_font, default_size)
+
+        # 添加背景色
+        shading_elm = OxmlElement("w:shd")
+        shading_elm.set(qn("w:fill"), bg_color)
+        para.paragraph_format._element.get_or_add_pPr().append(shading_elm)
+
+        # 添加左边框
+        pPr = para.paragraph_format._element.get_or_add_pPr()
+        pBdr = OxmlElement("w:pBdr")
+        left = OxmlElement("w:left")
+        left.set(qn("w:val"), "single")
+        left.set(qn("w:sz"), "4")
+        left.set(qn("w:color"), border_color)
+        pBdr.append(left)
+        pPr.append(pBdr)
+
+        para.paragraph_format.space_after = Pt(6)
+
+
+def _process_horizontal_rule_element(element, doc):
+    """处理水平线元素"""
+    classes = element.get("class", [])
+    style = element.get("style", "")
+    class_set = set(classes)
+    if "page-break" in class_set or "page-break-after" in style:
+        add_page_break(doc)
+    else:
+        add_horizontal_rule(doc)
+
+
+def _process_elements(soup, doc, html_file, default_font, default_size):
+    """处理所有HTML元素"""
+    for element in soup.body.find_all(recursive=False):
+        if element.name in ["h1", "h2", "h3", "h4", "h5", "h6"]:
+            _process_heading(element, doc, default_font)
+        elif element.name == "p":
+            _process_paragraph_element(element, doc, default_font, default_size)
+        elif element.name == "ul":
+            _process_list_element(element, doc, ordered=False)
+        elif element.name == "ol":
+            _process_list_element(element, doc, ordered=True)
+        elif element.name == "table":
+            process_table(element, doc)
+        elif element.name == "img":
+            _process_image_element(element, doc, html_file)
+        elif element.name == "div":
+            _process_div_element(element, doc, default_font, default_size)
+        elif element.name == "hr":
+            _process_horizontal_rule_element(element, doc)
+
+
+def convert_html_to_docx(
+    html_file, output_file, default_font="微软雅黑", default_size=12
+):
     """将HTML文件转换为DOCX文件"""
     # 读取HTML文件
-    with open(html_file, 'r', encoding='utf-8') as f:
+    with open(html_file, "r", encoding="utf-8") as f:
         html_content = f.read()
-    
+
     # 解析HTML
-    soup = BeautifulSoup(html_content, 'html.parser')
-    
+    soup = BeautifulSoup(html_content, "html.parser")
+
     # 创建Word文档
     doc = Document()
-    
+
     # 设置默认字体
-    doc.styles['Normal'].font.name = default_font
-    doc.styles['Normal']._element.rPr.rFonts.set(qn('w:eastAsia'), default_font)
-    doc.styles['Normal'].font.size = Pt(default_size)
-    
+    doc.styles["Normal"].font.name = default_font
+    doc.styles["Normal"]._element.rPr.rFonts.set(qn("w:eastAsia"), default_font)
+    doc.styles["Normal"].font.size = Pt(default_size)
+
     # 处理页面设置
     section = doc.sections[0]
-    section.page_height = Cm(29.7)
-    section.page_width = Cm(21)
-    section.left_margin = Cm(2.54)
-    section.right_margin = Cm(2.54)
-    section.top_margin = Cm(2.54)
-    section.bottom_margin = Cm(2.54)
-    
+    section.page_height = Cm(ConverterConfig.PAGE_HEIGHT_CM)
+    section.page_width = Cm(ConverterConfig.PAGE_WIDTH_CM)
+    section.left_margin = Cm(ConverterConfig.MARGIN_CM)
+    section.right_margin = Cm(ConverterConfig.MARGIN_CM)
+    section.top_margin = Cm(ConverterConfig.MARGIN_CM)
+    section.bottom_margin = Cm(ConverterConfig.MARGIN_CM)
+
     # 遍历所有顶级元素
     for element in soup.body.find_all(recursive=False):
-        if element.name in ['h1', 'h2', 'h3', 'h4', 'h5', 'h6']:
+        if element.name in ["h1", "h2", "h3", "h4", "h5", "h6"]:
             level = int(element.name[1])
             heading = doc.add_heading(element.get_text().strip(), level=level)
             heading.alignment = WD_PARAGRAPH_ALIGNMENT.LEFT
-            
+
             # 标题样式
             for run in heading.runs:
                 run.font.name = default_font
-                run._element.rPr.rFonts.set(qn('w:eastAsia'), default_font)
+                run._element.rPr.rFonts.set(qn("w:eastAsia"), default_font)
+                run.font.size = Pt(ConverterConfig.HEADING_SIZES.get(level, 14))
+                run.font.bold = True
+                run.font.color.rgb = ConverterConfig.HEADING_COLORS.get(
+                    level, RGBColor(107, 91, 149)
+                )
                 if level == 1:
-                    run.font.size = Pt(18)
-                    run.font.bold = True
-                    run.font.color.rgb = RGBColor(74, 63, 107)
                     heading.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
-                elif level == 2:
-                    run.font.size = Pt(16)
-                    run.font.bold = True
-                    run.font.color.rgb = RGBColor(91, 78, 140)
-                else:
-                    run.font.size = Pt(14)
-                    run.font.bold = True
-        
-        elif element.name == 'p':
+
+        elif element.name == "p":
             # 检查特殊段落样式
-            classes = element.get('class', [])
-            
-            if 'center' in classes:
-                para = process_paragraph(element, doc, align=WD_PARAGRAPH_ALIGNMENT.CENTER)
-            elif 'right' in classes:
-                para = process_paragraph(element, doc, align=WD_PARAGRAPH_ALIGNMENT.RIGHT)
-            elif 'dialogue' in classes:
+            classes = element.get("class", [])
+            class_set = set(classes)  # 转换为集合提高查找性能
+
+            if "center" in class_set:
+                para = process_paragraph(
+                    element, doc, align=WD_PARAGRAPH_ALIGNMENT.CENTER
+                )
+            elif "right" in class_set:
+                para = process_paragraph(
+                    element, doc, align=WD_PARAGRAPH_ALIGNMENT.RIGHT
+                )
+            elif "dialogue" in class_set:
                 para = process_paragraph(element, doc, indent=0.5, line_spacing=1.5)
                 for run in para.runs:
                     set_font(run, italic=True, color=RGBColor(107, 91, 122))
-            elif 'quote' in classes or element.get('style', '').find('background') != -1:
+            elif (
+                "quote" in class_set
+                or element.get("style", "").find("background") != -1
+            ):
                 para = process_paragraph(element, doc)
                 para.paragraph_format.left_indent = Inches(1)
                 para.paragraph_format.right_indent = Inches(1)
                 from docx.enum.text import WD_BORDER
-                for border in para.paragraph_format._element.xpath('./w:pBdr'):
+
+                for border in para.paragraph_format._element.xpath("./w:pBdr"):
                     border.getparent().remove(border)
                 # 添加边框效果（使用浅灰色背景模拟）
-                shading_elm = OxmlElement('w:shd')
-                shading_elm.set(qn('w:fill'), 'F5F5F5')
+                shading_elm = OxmlElement("w:shd")
+                shading_elm.set(qn("w:fill"), "F5F5F5")
                 para.paragraph_format._element.get_or_add_pPr().append(shading_elm)
             else:
                 process_paragraph(element, doc, indent=0.5, line_spacing=1.5)
-        
-        elif element.name == 'ul':
-            items = element.find_all('li', recursive=False)
+
+        elif element.name == "ul":
+            items = element.find_all("li", recursive=False)
             process_list_items(items, doc, ordered=False)
-        
-        elif element.name == 'ol':
-            items = element.find_all('li', recursive=False)
+
+        elif element.name == "ol":
+            items = element.find_all("li", recursive=False)
             process_list_items(items, doc, ordered=True)
-        
-        elif element.name == 'blockquote':
+
+        elif element.name == "blockquote":
             # 递归处理嵌套引用
             _process_blockquote(element, doc, level=0)
-        
-        elif element.name == 'pre':
+
+        elif element.name == "pre":
             code_text = element.get_text()
             para = doc.add_paragraph()
             para.paragraph_format.left_indent = Inches(0.5)
             run = para.add_run(code_text)
-            set_font(run, font_name='Consolas', size=10, color=RGBColor(0, 0, 128))
+            set_font(run, font_name="Consolas", size=10, color=RGBColor(0, 0, 128))
             # 添加灰色背景
-            shading_elm = OxmlElement('w:shd')
-            shading_elm.set(qn('w:fill'), 'F0F0F0')
+            shading_elm = OxmlElement("w:shd")
+            shading_elm.set(qn("w:fill"), "F0F0F0")
             para.paragraph_format._element.get_or_add_pPr().append(shading_elm)
-        
-        elif element.name == 'hr':
+
+        elif element.name == "hr":
             # 检查是否有分页符class或style
-            classes = element.get('class', [])
-            style = element.get('style', '')
-            if 'page-break' in classes or 'page-break-after' in style:
+            classes = element.get("class", [])
+            style = element.get("style", "")
+            class_set = set(classes)
+            if "page-break" in class_set or "page-break-after" in style:
                 add_page_break(doc)
             else:
                 add_horizontal_rule(doc)
-        
-        elif element.name == 'table':
+
+        elif element.name == "table":
             process_table(element, doc)
-        
-        elif element.name == 'div':
+
+        elif element.name == "img":
+            # 处理图片
+            src = element.get("src", "")
+            alt = element.get("alt", "")
+
+            if src:
+                # 解析宽度、高度和对齐方式
+                width = element.get("width")
+                height = element.get("height")
+                style = element.get("style", "")
+                align = element.get("align", "center")
+
+                # 从 style 中提取对齐方式
+                if "text-align: right" in style or "float: right" in style:
+                    align = "right"
+                elif "text-align: left" in style or "float: left" in style:
+                    align = "left"
+                elif "text-align: center" in style:
+                    align = "center"
+
+                # 处理宽度高度（支持像素转英寸）
+                width_inch = None
+                height_inch = None
+                if width:
+                    try:
+                        width_px = float(width)
+                        width_inch = width_px / 96  # 假设96 DPI
+                    except:
+                        pass
+                if height:
+                    try:
+                        height_px = float(height)
+                        height_inch = height_px / 96
+                    except:
+                        pass
+
+                # 处理相对路径（相对于HTML文件）
+                html_dir = os.path.dirname(html_file)
+                image_path = (
+                    os.path.join(html_dir, src) if not os.path.isabs(src) else src
+                )
+
+                # 添加图片
+                add_image(doc, image_path, width_inch, height_inch, align)
+
+        elif element.name == "div":
             # 检查是否是特殊div
-            classes = element.get('class', [])
-            if 'chapter' in classes:
+            classes = element.get("class", [])
+            class_set = set(classes)
+
+            if "chapter" in class_set:
                 # 处理章节
-                h2 = element.find('h2')
+                h2 = element.find("h2")
                 if h2:
                     heading = doc.add_heading(h2.get_text().strip(), level=2)
                     for run in heading.runs:
                         run.font.color.rgb = RGBColor(91, 78, 140)
                         run.font.size = Pt(16)
                         run.font.name = default_font
-                        run._element.rPr.rFonts.set(qn('w:eastAsia'), default_font)
-                
-                paragraphs = element.find_all('p')
+                        run._element.rPr.rFonts.set(qn("w:eastAsia"), default_font)
+
+                paragraphs = element.find_all("p")
                 for p in paragraphs:
-                    first_span = p.find('span', class_='first-line')
+                    first_span = p.find("span", class_="first-line")
                     if first_span:
                         para = doc.add_paragraph()
                         first_char_run = para.add_run(first_span.text)
-                        set_font(first_char_run, size=20, bold=True, color=RGBColor(102, 126, 234))
-                        remaining_text = p.get_text().replace(first_span.text, '', 1)
+                        set_font(
+                            first_char_run,
+                            size=20,
+                            bold=True,
+                            color=RGBColor(102, 126, 234),
+                        )
+                        remaining_text = p.get_text().replace(first_span.text, "", 1)
                         run = para.add_run(remaining_text)
                         set_font(run)
                     else:
                         process_paragraph(p, doc, indent=0.5, line_spacing=1.5)
-            
-            elif 'ending' in classes:
-                para = process_paragraph(element, doc, align=WD_PARAGRAPH_ALIGNMENT.CENTER)
+
+            elif "ending" in class_set:
+                para = process_paragraph(
+                    element, doc, align=WD_PARAGRAPH_ALIGNMENT.CENTER
+                )
                 for run in para.runs:
                     set_font(run, italic=True, size=14, color=RGBColor(91, 78, 140))
-            
-            elif 'page-break' in classes:
+
+            elif "page-break" in class_set:
                 add_page_break(doc)
 
-            elif 'columns' in classes:
+            elif "columns" in class_set:
                 # 处理多栏布局（使用连续分节符，不换页）
-                cols_num = int(element.get('data-cols', '2'))
+                cols_num = int(element.get("data-cols", "2"))
                 # 添加连续分节符并设置栏数
                 add_columns_section(doc, cols_num)
                 # 处理其中的段落
-                for p in element.find_all('p', recursive=False):
-                    process_paragraph(p, doc, default_font=default_font, default_size=default_size)
+                for p in element.find_all("p", recursive=False):
+                    process_paragraph(
+                        p, doc, default_font=default_font, default_size=default_size
+                    )
 
-            elif 'info' in classes or 'warning' in classes or 'success' in classes:
+            elif (
+                "info" in class_set or "warning" in class_set or "success" in class_set
+            ):
                 # 处理提示框
                 para = doc.add_paragraph()
                 para.paragraph_format.right_indent = Inches(0.3)
-                
+
                 # 设置背景色和左边框颜色
-                if 'info' in classes:
-                    bg_color = 'E3F2FD'  # 浅蓝
-                    border_color = '2196F3'  # 蓝色
-                elif 'warning' in classes:
-                    bg_color = 'FFF3CD'  # 浅黄
-                    border_color = 'FFC107'  # 黄色
+                if "info" in class_set:
+                    bg_color = ConverterConfig.INFO_COLORS["bg"]
+                    border_color = ConverterConfig.INFO_COLORS["border"]
+                elif "warning" in class_set:
+                    bg_color = ConverterConfig.WARNING_COLORS["bg"]
+                    border_color = ConverterConfig.WARNING_COLORS["border"]
                 else:  # success
-                    bg_color = 'D4EDDA'  # 浅绿
-                    border_color = '28A745'  # 绿色
-                
+                    bg_color = ConverterConfig.SUCCESS_COLORS["bg"]
+                    border_color = ConverterConfig.SUCCESS_COLORS["border"]
+
                 # 处理内容
                 _process_element_to_runs(element, para, default_font, default_size)
-                
+
                 # 添加背景色
-                shading_elm = OxmlElement('w:shd')
-                shading_elm.set(qn('w:fill'), bg_color)
+                shading_elm = OxmlElement("w:shd")
+                shading_elm.set(qn("w:fill"), bg_color)
                 para.paragraph_format._element.get_or_add_pPr().append(shading_elm)
-                
+
                 # 添加左边框
-                pBdr = OxmlElement('w:pBdr')
-                left_border = OxmlElement('w:left')
-                left_border.set(qn('w:val'), 'single')
-                left_border.set(qn('w:sz'), '24')  # 边框粗细
-                left_border.set(qn('w:color'), border_color)
+                pBdr = OxmlElement("w:pBdr")
+                left_border = OxmlElement("w:left")
+                left_border.set(qn("w:val"), "single")
+                left_border.set(qn("w:sz"), "24")  # 边框粗细
+                left_border.set(qn("w:color"), border_color)
                 pBdr.append(left_border)
                 para.paragraph_format._element.get_or_add_pPr().append(pBdr)
-            
+
             else:
                 # 处理普通div，检查是否有内联样式（如提示框）
-                style = element.get('style', '')
+                style = element.get("style", "")
                 style_dict = _parse_style(style)
-                
+
                 # 检查是否有背景色和左边框（提示框特征）
-                bg_color = style_dict.get('background-color', '')
-                border_left = style_dict.get('border-left', '')
-                
+                bg_color = style_dict.get("background-color", "")
+                border_left = style_dict.get("border-left", "")
+
                 if bg_color and border_left:
                     # 这是提示框
                     para = doc.add_paragraph()
                     para.paragraph_format.right_indent = Inches(0.3)
-                    
+
                     # 处理内容
                     _process_element_to_runs(element, para, default_font, default_size)
-                    
+
                     # 添加背景色
-                    if bg_color.startswith('#'):
-                        shading_elm = OxmlElement('w:shd')
-                        shading_elm.set(qn('w:fill'), bg_color[1:].upper())
-                        para.paragraph_format._element.get_or_add_pPr().append(shading_elm)
-                    
+                    if bg_color.startswith("#"):
+                        shading_elm = OxmlElement("w:shd")
+                        shading_elm.set(qn("w:fill"), bg_color[1:].upper())
+                        para.paragraph_format._element.get_or_add_pPr().append(
+                            shading_elm
+                        )
+
                     # 解析左边框颜色
-                    border_color = ''
-                    if 'solid' in border_left:
+                    border_color = ""
+                    if "solid" in border_left:
                         parts = border_left.split()
                         for i, part in enumerate(parts):
-                            if part.startswith('#'):
+                            if part.startswith("#"):
                                 border_color = part[1:]
                                 break
-                    
+
                     # 添加左边框
                     if border_color:
-                        pBdr = OxmlElement('w:pBdr')
-                        left_border = OxmlElement('w:left')
-                        left_border.set(qn('w:val'), 'single')
-                        left_border.set(qn('w:sz'), '24')
-                        left_border.set(qn('w:color'), border_color.upper())
+                        pBdr = OxmlElement("w:pBdr")
+                        left_border = OxmlElement("w:left")
+                        left_border.set(qn("w:val"), "single")
+                        left_border.set(qn("w:sz"), "24")
+                        left_border.set(qn("w:color"), border_color.upper())
                         pBdr.append(left_border)
                         para.paragraph_format._element.get_or_add_pPr().append(pBdr)
                 else:
                     # 普通div，处理其中的段落
-                    for p in element.find_all('p', recursive=False):
+                    for p in element.find_all("p", recursive=False):
                         process_paragraph(p, doc)
-        
-        elif element.name == 'img':
-            src = element.get('src', '')
-            alt = element.get('alt', '图片')
+
+        elif element.name == "img":
+            src = element.get("src", "")
+            alt = element.get("alt", "图片")
             if src and os.path.exists(src):
                 try:
                     doc.add_picture(src, width=Inches(5))
                     last_para = doc.paragraphs[-1]
                     last_para.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
                 except:
-                    para = doc.add_paragraph(f'[图片: {alt}]')
+                    para = doc.add_paragraph(f"[图片: {alt}]")
                     para.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
             else:
-                para = doc.add_paragraph(f'[图片: {alt} - 路径: {src}]')
+                para = doc.add_paragraph(f"[图片: {alt} - 路径: {src}]")
                 para.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
-    
+
     # 保存文档
     doc.save(output_file)
-    print(f"转换完成！文件已保存为 {output_file}")
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     import sys
-    
-    if len(sys.argv) > 2:
-        html_file = sys.argv[1]
-        output_file = sys.argv[2]
-    else:
-        html_file = r'C:\Users\birth\Desktop\tmp\test\sample.html'
-        output_file = r'C:\Users\birth\Desktop\tmp\test\sample.docx'
-    
-    convert_html_to_docx(html_file, output_file)
+
+    if len(sys.argv) != 3:
+        print("用法: python docx_converter.py <html_file> <output_file>")
+        sys.exit(1)
+
+    html_file = sys.argv[1]
+    output_file = sys.argv[2]
+
+    convert_html_to_docx(html_file, output_file)