feat(export): Word 文档样式和表格渲染功能

- 添加 eastAsia 字体属性支持，确保中文字符在 run 级样式中正确显示
- 实现 _update_normal_style_if_needed() 函数，自动检测 blocks 中最常用的字体和字号，并应用到 Normal 样式，确保空行样式一致性
- 增强表格渲染功能，支持合并单元格（rowspan/colspan）、列宽、行高和自定义表格样式
- 优化段落渲染逻辑，通过添加带继承样式的空 run 来保留空内容的 block 级样式（字体、字号）
- 更新 _render_table_block() 函数文档，反映新增的表格格式化功能
- 添加列索引偏移跟踪机制，正确处理包含 colspan 的表格单元格填充
- 实现 merge_map 跟踪，防止合并单元格中的重复内容
- 优化 _render_paragraph_block() 中的注释，明确空内容的样式继承逻辑

app/services/export_service.py

@@ -171,9 +171,19 @@ def _apply_run_style(run, style: dict):
         except (ValueError, AttributeError):
             pass
     
-    # 字体名称
+    # 字体名称（支持中文字体 eastAsia）
     if style.get('font_name'):
-        run.font.name = style['font_name']
+        font_name = style['font_name']
+        run.font.name = font_name
+        
+        # 对于中文字体，需要设置 eastAsia 属性
+        try:
+            r = run._element
+            rPr = r.get_or_add_rPr()
+            rFonts = rPr.get_or_add_rFonts()
+            rFonts.set(qn('w:eastAsia'), font_name)
+        except Exception:
+            pass
     
     # 字号
     if style.get('font_size'):
@@ -198,6 +208,10 @@ def blocks_to_docx_bytes(blocks: list[dict], style_map: dict, style_data: dict)
     doc = Document()
     inject_styles_from_json(doc, style_data)
     
+    # 检查 blocks 中是否有常用的字体和字号，用于修改 Normal 样式
+    # 这样可以确保空行在 Word 中显示正确的字体
+    _update_normal_style_if_needed(doc, blocks)
+    
     for block in blocks:
         block_type = block['type']
         
@@ -220,6 +234,90 @@ def blocks_to_docx_bytes(blocks: list[dict], style_map: dict, style_data: dict)
     return docx_bytes
 
 
+def _update_normal_style_if_needed(doc: Document, blocks: list[dict]):
+    """更新 Normal 样式以匹配 blocks 中最常用的字体
+    
+    这样可以确保空行在 Word 中显示正确的字体和字号
+    """
+    # 统计段落中最常用的字体和字号
+    font_counts = {}
+    size_counts = {}
+    
+    for block in blocks:
+        if block['type'] == 'paragraph':
+            style = block.get('style', {})
+            font_name = style.get('font_name')
+            font_size = style.get('font_size')
+            
+            if font_name:
+                font_counts[font_name] = font_counts.get(font_name, 0) + 1
+            if font_size:
+                size_counts[font_size] = size_counts.get(font_size, 0) + 1
+    
+    # 找到最常用的字体和字号
+    most_common_font = max(font_counts.items(), key=lambda x: x[1])[0] if font_counts else None
+    most_common_size = max(size_counts.items(), key=lambda x: x[1])[0] if size_counts else None
+    
+    # 如果找到了常用字体或字号，更新 Normal 样式
+    if most_common_font or most_common_size:
+        try:
+            normal_style = doc.styles['Normal']
+            
+            if most_common_font:
+                # 修改 Normal 样式的字体
+                style_element = normal_style.element
+                rPr = style_element.find(qn('w:rPr'))
+                if rPr is None:
+                    rPr = OxmlElement('w:rPr')
+                    # 插入到第一个子元素之前
+                    if len(style_element):
+                        style_element.insert(0, rPr)
+                    else:
+                        style_element.append(rPr)
+                
+                rFonts = rPr.find(qn('w:rFonts'))
+                if rFonts is None:
+                    rFonts = OxmlElement('w:rFonts')
+                    rPr.append(rFonts)
+                
+                # 设置所有字体属性
+                rFonts.set(qn('w:ascii'), most_common_font)
+                rFonts.set(qn('w:hAnsi'), most_common_font)
+                rFonts.set(qn('w:eastAsia'), most_common_font)
+            
+            if most_common_size:
+                # 修改 Normal 样式的字号
+                style_element = normal_style.element
+                rPr = style_element.find(qn('w:rPr'))
+                if rPr is None:
+                    rPr = OxmlElement('w:rPr')
+                    if len(style_element):
+                        style_element.insert(0, rPr)
+                    else:
+                        style_element.append(rPr)
+                
+                # 删除旧的字号元素
+                old_sz = rPr.find(qn('w:sz'))
+                if old_sz is not None:
+                    rPr.remove(old_sz)
+                old_szCs = rPr.find(qn('w:szCs'))
+                if old_szCs is not None:
+                    rPr.remove(old_szCs)
+                
+                # 添加新的字号元素
+                sz = OxmlElement('w:sz')
+                sz.set(qn('w:val'), str(int(most_common_size * 2)))  # Word 使用半磅
+                rPr.append(sz)
+                
+                szCs = OxmlElement('w:szCs')
+                szCs.set(qn('w:val'), str(int(most_common_size * 2)))
+                rPr.append(szCs)
+                
+        except Exception:
+            # 如果修改样式失败，继续（不影响文档生成）
+            pass
+
+
 def _inject_numbering_via_zip(docx_bytes: bytes, style_data: dict) -> bytes:
     """通过 ZIP 操作注入编号格式到 Word 文档
     
@@ -390,8 +488,9 @@ def _render_paragraph_block(doc: Document, block: dict, style_map: dict):
         # 富文本：应用 run 级样式
         _render_rich_text(para, content, block_style)
     else:
-        # 纯文本：始终添加 run（即使是空内容）
-        # 空行也需要 run 来继承样式，保持正确的上下间距
+        # 纯文本或空内容
+        # 即使是空内容，如果有 block 级样式（字体、字号等），也需要添加空 run 来保存样式
+        # 这样当用户在 Word 中输入文本时，会自动应用这些样式
         run = para.add_run(str(content) if content else '')
         _apply_run_style(run, block_style)
 
@@ -421,7 +520,7 @@ def _render_rich_text(para, segments: list, block_style: dict = None):
 
 
 def _render_table_block(doc: Document, block: dict, style_map: dict):
-    """渲染表格块（支持单元格样式）"""
+    """渲染表格块（支持合并单元格、列宽、行高等）"""
     table_data = block['content']
     if isinstance(table_data, str):
         try:
@@ -433,31 +532,99 @@ def _render_table_block(doc: Document, block: dict, style_map: dict):
     if not rows:
         return
     
-    # 计算表格大小
-    num_rows = len(rows)
-    num_cols = len(rows[0]['cells']) if rows else 0
+    # 使用 col_widths 确定真实列数（而不是第一行的单元格数）
+    col_widths = table_data.get('col_widths', [])
+    if col_widths:
+        num_cols = len(col_widths)
+    else:
+        # 回退：扫描所有行，找到最大的列索引
+        num_cols = 0
+        for row_data in rows:
+            col_index = 0
+            for cell_data in row_data.get('cells', []):
+                colspan = cell_data.get('colspan', 1)
+                col_index += colspan
+            num_cols = max(num_cols, col_index)
+        
+        if num_cols == 0:
+            return
     
-    if num_cols == 0:
-        return
+    num_rows = len(rows)
     
     # 创建表格
     table = doc.add_table(rows=num_rows, cols=num_cols)
-    table.style = 'Table Grid'
     
-    # 填充内容
+    # 应用表格样式
+    table_style = block.get('word_style', 'Table Grid')
+    try:
+        table.style = table_style
+    except KeyError:
+        table.style = 'Table Grid'
+    
+    # 设置列宽
+    if col_widths:
+        for col_idx, width in enumerate(col_widths):
+            if col_idx < len(table.columns):
+                table.columns[col_idx].width = Pt(width)
+    
+    # 填充内容并处理合并单元格
+    merge_map = {}  # {(row, col): (end_row, end_col)} 记录合并区域
+    
     for r_idx, row_data in enumerate(rows):
+        # 设置行高
+        row_height = row_data.get('height')
+        if row_height:
+            table.rows[r_idx].height = Pt(row_height)
+        
         cells_data = row_data.get('cells', [])
-        for c_idx, cell_data in enumerate(cells_data):
-            if c_idx >= num_cols:
+        col_offset = 0  # 当前列偏移（考虑 colspan）
+        
+        for cell_data in cells_data:
+            # 跳过被合并的单元格（rowspan=0 表示这个单元格被上面的单元格合并了）
+            rowspan = cell_data.get('rowspan', 1)
+            if rowspan == 0:
+                col_offset += 1
+                continue
+            
+            colspan = cell_data.get('colspan', 1)
+            
+            # 确保不越界
+            if col_offset >= num_cols:
                 break
             
-            cell = table.rows[r_idx].cells[c_idx]
+            # 获取起始单元格
+            start_cell = table.rows[r_idx].cells[col_offset]
+            
+            # 处理合并单元格
+            if colspan > 1 or rowspan > 1:
+                # 计算结束位置
+                end_col = min(col_offset + colspan - 1, num_cols - 1)
+                end_row = min(r_idx + rowspan - 1, num_rows - 1)
+                
+                # 合并单元格
+                if end_col > col_offset or end_row > r_idx:
+                    try:
+                        end_cell = table.rows[end_row].cells[end_col]
+                        start_cell.merge(end_cell)
+                        merge_map[(r_idx, col_offset)] = (end_row, end_col)
+                    except Exception:
+                        pass  # 合并失败，继续
+            
+            # 设置单元格宽度（如果有）
+            cell_width = cell_data.get('width')
+            if cell_width:
+                try:
+                    start_cell.width = Pt(cell_width)
+                except Exception:
+                    pass
+            
+            # 填充单元格内容
             cell_text = cell_data.get('text', '')
             cell_style = cell_data.get('style', {})
             
             # 清空默认段落
-            cell.text = ''
-            para = cell.paragraphs[0]
+            start_cell.text = ''
+            para = start_cell.paragraphs[0]
             
             # 应用单元格段落级样式（对齐）
             _apply_paragraph_style(para, cell_style)
@@ -471,6 +638,9 @@ def _render_table_block(doc: Document, block: dict, style_map: dict):
                 run = para.add_run(str(cell_text))
                 # 应用单元格 run 级样式
                 _apply_run_style(run, cell_style)
+            
+            # 更新列偏移
+            col_offset += colspan
 
 
 def _render_image_block(doc: Document, block: dict):

app/services/word_parser.py

@@ -4,9 +4,273 @@ import base64
 import io
 from pathlib import Path
 from typing import Optional
+import zipfile
 
 from docx import Document as DocxDocument
 from docx.oxml.ns import qn
+from lxml import etree
+
+
+# 全局缓存：主题字体映射
+_theme_fonts_cache = {}
+# 当前文档的主题字体（用于在解析过程中传递）
+_current_theme_fonts = {}
+
+
+def _load_theme_fonts(docx_path: Path) -> dict:
+    """从 Word 文档中加载主题字体定义
+    
+    Args:
+        docx_path: Word 文档路径
+        
+    Returns:
+        主题字体映射字典，例如: {'minorEastAsia': '宋体', 'majorEastAsia': '黑体'}
+    """
+    # 检查缓存
+    cache_key = str(docx_path)
+    if cache_key in _theme_fonts_cache:
+        return _theme_fonts_cache[cache_key]
+    
+    theme_fonts = {}
+    
+    try:
+        with zipfile.ZipFile(docx_path, 'r') as docx_zip:
+            # 查找主题文件
+            theme_files = [name for name in docx_zip.namelist() 
+                          if 'theme' in name.lower() and name.endswith('.xml')]
+            
+            if not theme_files:
+                return theme_fonts
+            
+            # 读取主题 XML
+            theme_xml = docx_zip.read(theme_files[0])
+            root = etree.fromstring(theme_xml)
+            
+            # 命名空间
+            ns = {'a': 'http://schemas.openxmlformats.org/drawingml/2006/main'}
+            
+            # 解析 majorFont（标题字体）
+            major_font = root.find('.//a:majorFont', ns)
+            if major_font is not None:
+                ea = major_font.find('.//a:ea', ns)
+                if ea is not None and ea.get('typeface'):
+                    theme_fonts['majorEastAsia'] = ea.get('typeface')
+                # 回退到简体中文
+                hans = major_font.find('.//a:font[@script="Hans"]', ns)
+                if hans is not None and hans.get('typeface'):
+                    if 'majorEastAsia' not in theme_fonts:
+                        theme_fonts['majorEastAsia'] = hans.get('typeface')
+            
+            # 解析 minorFont（正文字体）
+            minor_font = root.find('.//a:minorFont', ns)
+            if minor_font is not None:
+                ea = minor_font.find('.//a:ea', ns)
+                if ea is not None and ea.get('typeface'):
+                    theme_fonts['minorEastAsia'] = ea.get('typeface')
+                # 回退到简体中文
+                hans = minor_font.find('.//a:font[@script="Hans"]', ns)
+                if hans is not None and hans.get('typeface'):
+                    if 'minorEastAsia' not in theme_fonts:
+                        theme_fonts['minorEastAsia'] = hans.get('typeface')
+    
+    except Exception:
+        # 如果读取失败，返回空字典
+        pass
+    
+    # 缓存结果
+    _theme_fonts_cache[cache_key] = theme_fonts
+    return theme_fonts
+
+
+def _get_eastasia_font_from_element(element):
+    """从 XML 元素中提取 eastAsia 字体（用于中文字体）
+    
+    Args:
+        element: rPr XML 元素
+        
+    Returns:
+        eastAsia 字体名称或 None
+    """
+    if element is None:
+        return None
+    rFonts = element.find(qn('w:rFonts'))
+    if rFonts is not None:
+        east_asia = rFonts.get(qn('w:eastAsia'))
+        if east_asia:
+            return east_asia
+    return None
+
+
+def _get_font_name(run, theme_fonts: dict = None):
+    """获取 run 的字体名（优先 eastAsia，其次 ascii，支持主题字体）
+    
+    特殊处理：如果 run 只定义了 ascii 字体（如 Times New Roman），
+    但没有定义 eastAsia，则忽略 run 的字体，返回 None 让其从样式继承中文字体。
+    这样可以正确处理混合语言的字体继承。
+    
+    Args:
+        run: python-docx Run 对象
+        theme_fonts: 主题字体映射字典（可选，默认使用全局的 _current_theme_fonts）
+        
+    Returns:
+        字体名称或 None
+    """
+    if theme_fonts is None:
+        theme_fonts = _current_theme_fonts
+    
+    # 1. 尝试从 XML 读取字体
+    if hasattr(run._element, 'rPr'):
+        rPr = run._element.rPr
+        if rPr is not None:
+            rFonts = rPr.find(qn('w:rFonts'))
+            if rFonts is not None:
+                # 1a. 优先 eastAsia（中文字体）
+                east_asia = rFonts.get(qn('w:eastAsia'))
+                if east_asia:
+                    return east_asia
+                
+                # 1b. 主题字体引用
+                if theme_fonts:
+                    east_asia_theme = rFonts.get(qn('w:eastAsiaTheme'))
+                    if east_asia_theme and east_asia_theme in theme_fonts:
+                        return theme_fonts[east_asia_theme]
+                
+                # 1c. 如果只定义了 ascii/hAnsi，没有 eastAsia
+                # 返回 None 让其从样式继承中文字体
+                # 这样可以正确处理 Heading 2 等情况
+                ascii_font = rFonts.get(qn('w:ascii'))
+                hAnsi_font = rFonts.get(qn('w:hAnsi'))
+                if ascii_font or hAnsi_font:
+                    # 有西文字体但没有中文字体，返回 None
+                    # 让 _extract_paragraph_format 从样式提取
+                    return None
+    
+    # 2. 回退到标准 API（ascii 字体）
+    if run.font.name:
+        return run.font.name
+    
+    return None
+
+
+def _get_paragraph_style_font(para):
+    """从段落样式中提取字体（当 run 级别没有字体设置时使用）
+    
+    优先提取 eastAsia（中文字体），如果没有则查找基础样式的 eastAsia
+    
+    Args:
+        para: python-docx 段落对象
+        
+    Returns:
+        字体名称或 None
+    """
+    try:
+        style = para.style
+        if hasattr(style, 'element'):
+            rPr = style.element.find(qn('w:rPr'))
+            if rPr is not None:
+                rFonts = rPr.find(qn('w:rFonts'))
+                if rFonts is not None:
+                    # 优先 eastAsia（中文字体）
+                    east_asia = rFonts.get(qn('w:eastAsia'))
+                    if east_asia:
+                        return east_asia
+            
+            # 如果当前样式没有 eastAsia，查找基础样式的 eastAsia
+            # 这样可以正确处理 Heading 2 等只定义 ascii 但基于 Normal 的样式
+            if hasattr(style, 'base_style') and style.base_style:
+                base_font = _get_paragraph_style_font_recursive(style.base_style)
+                if base_font:
+                    return base_font
+            
+            # 如果没有 eastAsia，回退到 ascii/hAnsi
+            if rPr is not None:
+                rFonts = rPr.find(qn('w:rFonts'))
+                if rFonts is not None:
+                    # 其次 ascii
+                    ascii_font = rFonts.get(qn('w:ascii'))
+                    if ascii_font:
+                        return ascii_font
+                    # 最后 hAnsi
+                    hAnsi = rFonts.get(qn('w:hAnsi'))
+                    if hAnsi:
+                        return hAnsi
+    except Exception:
+        pass
+    
+    return None
+
+
+def _get_paragraph_style_font_recursive(style):
+    """递归查找样式的 eastAsia 字体（用于基础样式查找）
+    
+    Args:
+        style: python-docx Style 对象
+        
+    Returns:
+        eastAsia 字体名称或 None
+    """
+    try:
+        if hasattr(style, 'element'):
+            rPr = style.element.find(qn('w:rPr'))
+            if rPr is not None:
+                rFonts = rPr.find(qn('w:rFonts'))
+                if rFonts is not None:
+                    east_asia = rFonts.get(qn('w:eastAsia'))
+                    if east_asia:
+                        return east_asia
+            
+            # 继续查找基础样式
+            if hasattr(style, 'base_style') and style.base_style:
+                return _get_paragraph_style_font_recursive(style.base_style)
+    except Exception:
+        pass
+    
+    return None
+
+
+def _get_style_formatting(style):
+    """从样式中提取格式属性（加粗、斜体、下划线等）
+    
+    Args:
+        style: python-docx Style 对象
+        
+    Returns:
+        格式属性字典 {'bold': True/False, 'italic': True/False, ...}
+    """
+    formatting = {}
+    
+    if not style or not hasattr(style, 'element'):
+        return formatting
+    
+    try:
+        rPr = style.element.find(qn('w:rPr'))
+        if rPr is not None:
+            # 加粗
+            bold_elem = rPr.find(qn('w:b'))
+            if bold_elem is not None:
+                bold_val = bold_elem.get(qn('w:val'))
+                # w:val 为 None、'1' 或 'true' 表示加粗
+                if bold_val is None or bold_val in ('1', 'true'):
+                    formatting['bold'] = True
+            
+            # 斜体
+            italic_elem = rPr.find(qn('w:i'))
+            if italic_elem is not None:
+                italic_val = italic_elem.get(qn('w:val'))
+                if italic_val is None or italic_val in ('1', 'true'):
+                    formatting['italic'] = True
+            
+            # 下划线
+            underline_elem = rPr.find(qn('w:u'))
+            if underline_elem is not None:
+                underline_val = underline_elem.get(qn('w:val'))
+                # 下划线有多种类型，只要存在就算有下划线
+                if underline_val and underline_val != 'none':
+                    formatting['underline'] = True
+    except Exception:
+        pass
+    
+    return formatting
 
 
 def parse_word_to_blocks(docx_path: Path) -> list[dict]:
@@ -18,10 +282,15 @@ def parse_word_to_blocks(docx_path: Path) -> list[dict]:
     Returns:
         Block 列表，每个 Block 包含 id, block_order, type, level, index, content 等字段
     """
+    global _current_theme_fonts
+    
     doc = DocxDocument(str(docx_path))
     blocks = []
     block_order = 0
     
+    # 加载主题字体并设置为当前主题
+    _current_theme_fonts = _load_theme_fonts(docx_path)
+    
     # 标题计数器（按 level 分别计数）
     heading_counters = {1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0}
     # 其他类型的全局计数器
@@ -77,6 +346,14 @@ def parse_word_to_blocks(docx_path: Path) -> list[dict]:
             level = _identify_heading_level(para, style_name)
             
             if level:
+                # 提取内容（支持富文本）
+                content = _extract_rich_text(para)
+                
+                # 跳过空标题（没有内容的标题）
+                if not content:
+                    # 空标题不添加到 blocks，继续下一个段落
+                    continue
+                
                 # 标题块
                 index = heading_counters[level] * 100  # 稀疏排序：0, 100, 200...
                 heading_counters[level] += 1
@@ -90,9 +367,6 @@ def parse_word_to_blocks(docx_path: Path) -> list[dict]:
                 
                 parent_id = parent_stack[-1]['id'] if parent_stack else None
                 
-                # 提取内容（支持富文本）
-                content = _extract_rich_text(para)
-                
                 # 提取段落级样式
                 para_style = _extract_paragraph_format(para)
                 
@@ -147,6 +421,9 @@ def parse_word_to_blocks(docx_path: Path) -> list[dict]:
                     index = type_counters['paragraph'] * 100
                     type_counters['paragraph'] += 1
                     
+                    # 如果是富文本数组，Block 样式为空；如果是纯文本，Block 有样式
+                    block_style = {} if isinstance(content, list) else para_style
+                    
                     block = {
                         'id': f'block-p-{index}',
                         'block_order': block_order * 100,
@@ -155,7 +432,7 @@ def parse_word_to_blocks(docx_path: Path) -> list[dict]:
                         'index': index,
                         'content': content,
                         'word_style': style_name,
-                        'style': para_style,  # 颗粒度样式
+                        'style': block_style,
                         'metadata': {
                             'parent_heading_id': parent_id
                         }
@@ -301,20 +578,36 @@ def _extract_paragraph_format(para) -> dict:
     if para.runs:
         first_run = para.runs[0]
         
-        # 检查是否整段使用相同字体
-        if first_run.font.name:
-            all_same_font = all(
-                run.font.name == first_run.font.name 
+        # 检查是否整段使用相同字体（支持 eastAsia，忽略 None 值）
+        first_font = _get_font_name(first_run)
+        
+        # 如果所有 runs 都没有字体设置（都是 None），从段落样式提取
+        if first_font is None:
+            # 检查是否所有 runs 都没有字体
+            all_none = all(
+                _get_font_name(run) is None 
                 for run in para.runs if run.text
             )
+            if all_none:
+                # 从段落样式提取字体
+                style_font = _get_paragraph_style_font(para)
+                if style_font:
+                    style['font_name'] = style_font
+        elif first_font:
+            # 如果第一个 run 有字体，检查是否整段统一
+            all_same_font = all(
+                _get_font_name(run) == first_font 
+                for run in para.runs if run.text and _get_font_name(run) is not None
+            )
             if all_same_font:
-                style['font_name'] = first_run.font.name
+                style['font_name'] = first_font
         
-        # 检查是否整段使用相同字号
+        # 检查是否整段使用相同字号（忽略 None 值）
         if first_run.font.size:
+            # 只比较有字号的 runs
             all_same_size = all(
                 run.font.size == first_run.font.size 
-                for run in para.runs if run.text
+                for run in para.runs if run.text and run.font.size is not None
             )
             if all_same_size:
                 style['font_size'] = first_run.font.size.pt
@@ -346,6 +639,18 @@ def _extract_paragraph_format(para) -> dict:
             )
             if all_same_color:
                 style['color'] = first_color
+    else:
+        # 空段落（没有 runs）：从段落样式中提取默认字体和字号
+        style_font = _get_paragraph_style_font(para)
+        if style_font:
+            style['font_name'] = style_font
+        
+        # 尝试从段落样式中提取字号
+        try:
+            if hasattr(para.style, 'font') and para.style.font.size:
+                style['font_size'] = para.style.font.size.pt
+        except Exception:
+            pass
     
     return style
 
@@ -358,49 +663,98 @@ def _extract_rich_text(para) -> str | list:
         
     Returns:
         纯文本字符串 或 富文本片段列表
+        - 纯文本：所有 runs 样式相同，返回字符串
+        - 富文本：runs 样式不同，返回数组，每个元素包含完整样式
     """
     text = para.text.strip()
     if not text:
         return ""
     
-    # 检查是否包含多种格式
-    has_format = False
-    for run in para.runs:
-        if run.text and (run.bold or run.italic or run.font.strike or run.underline or
-                        (run.font.name) or (run.font.color and run.font.color.rgb)):
-            has_format = True
-            break
+    # 没有 runs 或只有一个 run，返回纯文本
+    if not para.runs or len(para.runs) == 0:
+        return text
     
-    if not has_format:
-        # 简单文本
+    # 提取所有 runs 的样式（用于判断是否统一）
+    valid_runs = [run for run in para.runs if run.text]
+    if len(valid_runs) <= 1:
         return text
     
-    # 富文本格式（JSON 数组）
+    # 检查所有 runs 的样式是否完全相同
+    def get_run_style_signature(run):
+        """获取 run 的样式签名，用于比较"""
+        return (
+            _get_font_name(run),
+            run.font.size.pt if run.font.size else None,
+            run.bold,
+            run.italic,
+            run.underline,
+            run.font.strike,
+            str(run.font.color.rgb) if run.font.color and run.font.color.rgb else None
+        )
+    
+    first_sig = get_run_style_signature(valid_runs[0])
+    all_same = all(get_run_style_signature(run) == first_sig for run in valid_runs)
+    
+    if all_same:
+        # 所有 runs 样式相同，返回纯文本
+        return text
+    
+    # 样式不同，返回富文本数组
+    # 每个 run 包含完整样式和 word_style
     segments = []
     for run in para.runs:
         if not run.text:
             continue
         
         style = {}
+        
+        # 字体
+        font_name = _get_font_name(run)
+        if font_name:
+            style['font_name'] = font_name
+        
+        # 字号
+        if run.font.size:
+            style['font_size'] = run.font.size.pt
+        
+        # 加粗
         if run.bold:
             style['bold'] = True
+        
+        # 斜体
         if run.italic:
             style['italic'] = True
+        
+        # 删除线
         if run.font.strike:
             style['strike'] = True
+        
+        # 下划线
         if run.underline:
             style['underline'] = True
-        if run.font.name:
-            style['font_name'] = run.font.name
-        if run.font.size:
-            style['font_size'] = run.font.size.pt
+        
+        # 颜色
         if run.font.color and run.font.color.rgb:
             style['color'] = str(run.font.color.rgb)
         
-        segments.append({
+        # 提取 word_style（字符样式或段落样式）
+        word_style = None
+        if run.style:
+            word_style = run.style.name
+        else:
+            # run 没有独立样式，使用段落样式
+            word_style = para.style.name if para.style else None
+        
+        segment = {
             'text': run.text,
             'style': style
-        })
+        }
+        
+        # 添加 word_style（方案 A：总是添加）
+        if word_style:
+            segment['word_style'] = word_style
+        
+        segments.append(segment)
     
     return segments if segments else text
 
@@ -412,13 +766,42 @@ def _extract_table(table) -> dict:
         table: python-docx 表格对象
         
     Returns:
-        表格数据字典
+        表格数据字典，包含合并单元格和尺寸信息
     """
     rows_data = []
     
-    for row in table.rows:
+    # 提取表格列宽（从 tblGrid）
+    col_widths = []
+    tbl_elem = table._element
+    tbl_grid = tbl_elem.find(qn('w:tblGrid'))
+    if tbl_grid is not None:
+        for grid_col in tbl_grid.findall(qn('w:gridCol')):
+            width = grid_col.get(qn('w:w'))
+            if width:
+                # twips 转 pt (1 pt = 20 twips)
+                col_widths.append(int(width) / 20)
+    
+    # 用于跟踪行合并（vMerge）
+    # col_index -> {start_row, rowspan_count}
+    vmerge_tracking = {}
+    
+    for row_idx, row in enumerate(table.rows):
         cells_data = []
-        for cell in row.cells:
+        
+        # 提取行高
+        row_height = None
+        if row.height:
+            row_height = row.height.pt
+        
+        col_offset = 0  # 当前列偏移（考虑 colspan）
+        seen_cells = set()  # 用于去重（基于对象 ID）
+        
+        for cell_idx, cell in enumerate(row.cells):
+            # 去重：跳过重复的单元格对象（合并单元格会返回同一个对象）
+            cell_id = id(cell)
+            if cell_id in seen_cells:
+                continue
+            seen_cells.add(cell_id)
             # 提取单元格文本
             cell_text = []
             for para in cell.paragraphs:
@@ -428,26 +811,45 @@ def _extract_table(table) -> dict:
             
             # 检测单元格样式（从第一个段落的第一个 run）
             cell_style = {}
+            cell_word_style = None  # 单元格的 word_style
+            
             if cell.paragraphs:
                 first_para = cell.paragraphs[0]
+                
+                # 提取 word_style（段落样式）
+                if first_para.style:
+                    cell_word_style = first_para.style.name
+                    
+                    # 从样式中提取格式（加粗、斜体等）
+                    style_formatting = _get_style_formatting(first_para.style)
+                    # 将样式中定义的格式作为基础
+                    cell_style.update(style_formatting)
+                
                 if first_para.runs:
                     first_run = first_para.runs[0]
                     
-                    # 加粗
-                    if first_run.bold:
+                    # 加粗（run 明确设置会覆盖样式）
+                    if first_run.bold is True:
                         cell_style['bold'] = True
+                    elif first_run.bold is False:
+                        # 明确设置为不加粗，移除样式的加粗
+                        cell_style.pop('bold', None)
+                    # 如果 run.bold 为 None，保持样式中的设置
                     
-                    # 斜体
-                    if first_run.italic:
+                    # 斜体（run 明确设置会覆盖样式）
+                    if first_run.italic is True:
                         cell_style['italic'] = True
+                    elif first_run.italic is False:
+                        cell_style.pop('italic', None)
                     
-                    # 下划线
+                    # 下划线（run 明确设置会覆盖样式）
                     if first_run.underline:
                         cell_style['underline'] = True
                     
                     # 字体
-                    if first_run.font.name:
-                        cell_style['font_name'] = first_run.font.name
+                    font_name = _get_font_name(first_run)
+                    if font_name:
+                        cell_style['font_name'] = font_name
                     
                     # 字号
                     if first_run.font.size:
@@ -471,17 +873,109 @@ def _extract_table(table) -> dict:
             else:
                 text_content = ""
             
-            cells_data.append({
+            # 提取合并信息
+            tc_elem = cell._tc
+            tcPr = tc_elem.find(qn('w:tcPr'))
+            
+            colspan = 1
+            rowspan = 1
+            is_vmerge_continue = False
+            
+            if tcPr is not None:
+                # 列合并 (gridSpan)
+                grid_span = tcPr.find(qn('w:gridSpan'))
+                if grid_span is not None:
+                    colspan = int(grid_span.get(qn('w:val')))
+                
+                # 行合并 (vMerge)
+                v_merge = tcPr.find(qn('w:vMerge'))
+                if v_merge is not None:
+                    v_merge_val = v_merge.get(qn('w:val'))
+                    if v_merge_val == 'restart':
+                        # 行合并起始
+                        vmerge_tracking[col_offset] = {
+                            'start_row': row_idx,
+                            'count': 1
+                        }
+                    elif v_merge_val is None:
+                        # 行合并继续（被合并的单元格）
+                        is_vmerge_continue = True
+                        if col_offset in vmerge_tracking:
+                            vmerge_tracking[col_offset]['count'] += 1
+            
+            # 计算实际的 rowspan
+            if col_offset in vmerge_tracking:
+                if vmerge_tracking[col_offset]['start_row'] == row_idx:
+                    # 这是起始行，后续会更新 rowspan
+                    rowspan = vmerge_tracking[col_offset]['count']
+                elif is_vmerge_continue:
+                    # 这是被合并的单元格，标记为 0（表示被合并）
+                    rowspan = 0
+            
+            # 提取单元格宽度
+            cell_width = None
+            if tcPr is not None:
+                tcW = tcPr.find(qn('w:tcW'))
+                if tcW is not None:
+                    width_val = tcW.get(qn('w:w'))
+                    width_type = tcW.get(qn('w:type'))
+                    if width_val and width_type != 'pct':
+                        # twips 转 pt
+                        cell_width = int(width_val) / 20
+            
+            # 如果没有明确宽度，使用列宽
+            if cell_width is None and col_offset < len(col_widths):
+                if colspan == 1:
+                    cell_width = col_widths[col_offset]
+                else:
+                    # 多列合并，计算总宽度
+                    cell_width = sum(col_widths[col_offset:col_offset + colspan])
+            
+            # 构建单元格数据（方案 D：包含 word_style）
+            cell_data = {
                 'text': text_content,
-                'rowspan': 1,
-                'colspan': 1,
+                'rowspan': rowspan,
+                'colspan': colspan,
                 'style': cell_style
-            })
+            }
+            
+            # 添加 word_style
+            if cell_word_style:
+                cell_data['word_style'] = cell_word_style
+            
+            # 添加尺寸信息
+            if cell_width is not None:
+                cell_data['width'] = round(cell_width, 2)
+            
+            cells_data.append(cell_data)
+            
+            # 更新列偏移
+            col_offset += colspan
         
-        rows_data.append({
+        # 构建行数据
+        row_data = {
             'cells': cells_data
-        })
+        }
+        
+        # 添加行高
+        if row_height is not None:
+            row_data['height'] = round(row_height, 2)
+        
+        rows_data.append(row_data)
+    
+    # 第二遍：更新 rowspan 值
+    for col_idx, info in vmerge_tracking.items():
+        start_row = info['start_row']
+        count = info['count']
+        # 找到起始行的单元格并更新 rowspan
+        if start_row < len(rows_data):
+            for cell in rows_data[start_row]['cells']:
+                # 简化：假设 col_idx 对应 cells 索引（实际可能需要考虑 colspan）
+                if 'rowspan' in cell and cell['rowspan'] > 0:
+                    cell['rowspan'] = count
+                    break
     
     return {
-        'rows': rows_data
+        'rows': rows_data,
+        'col_widths': [round(w, 2) for w in col_widths] if col_widths else None
     }

tmp/default.json

@@ -1,6 +1,6 @@
 {
   "source_file": "default.docx",
-  "total_styles": 27,
+  "total_styles": 28,
   "styles": [
     {
       "name": "Normal",
@@ -2840,7 +2840,7 @@
       "type": "CHARACTER (2)",
       "builtin": false,
       "hidden": false,
-      "quick_style": false,
+      "quick_style": true,
       "priority": 0,
       "base_style": null,
       "next_paragraph_style": null,
@@ -2876,6 +2876,10 @@
               "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}val": "2"
             }
           },
+          "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}qFormat": {
+            "@tag": "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}qFormat",
+            "@attrib": {}
+          },
           "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}uiPriority": {
             "@tag": "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}uiPriority",
             "@attrib": {
@@ -3015,7 +3019,7 @@
       "type": "PARAGRAPH (1)",
       "builtin": false,
       "hidden": false,
-      "quick_style": false,
+      "quick_style": true,
       "priority": 0,
       "base_style": "Normal",
       "next_paragraph_style": "表格正文",
@@ -3068,6 +3072,10 @@
               "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}val": "25"
             }
           },
+          "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}qFormat": {
+            "@tag": "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}qFormat",
+            "@attrib": {}
+          },
           "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}uiPriority": {
             "@tag": "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}uiPriority",
             "@attrib": {
@@ -3148,7 +3156,7 @@
       "type": "CHARACTER (2)",
       "builtin": false,
       "hidden": false,
-      "quick_style": false,
+      "quick_style": true,
       "priority": 0,
       "base_style": null,
       "next_paragraph_style": null,
@@ -3184,6 +3192,10 @@
               "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}val": "24"
             }
           },
+          "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}qFormat": {
+            "@tag": "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}qFormat",
+            "@attrib": {}
+          },
           "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}uiPriority": {
             "@tag": "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}uiPriority",
             "@attrib": {
@@ -3231,7 +3243,7 @@
       "type": "CHARACTER (2)",
       "builtin": false,
       "hidden": false,
-      "quick_style": false,
+      "quick_style": true,
       "priority": 0,
       "base_style": null,
       "next_paragraph_style": null,
@@ -3267,6 +3279,10 @@
               "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}val": "14"
             }
           },
+          "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}qFormat": {
+            "@tag": "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}qFormat",
+            "@attrib": {}
+          },
           "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}uiPriority": {
             "@tag": "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}uiPriority",
             "@attrib": {
@@ -3294,7 +3310,7 @@
       "type": "CHARACTER (2)",
       "builtin": false,
       "hidden": false,
-      "quick_style": false,
+      "quick_style": true,
       "priority": 0,
       "base_style": null,
       "next_paragraph_style": null,
@@ -3330,6 +3346,10 @@
               "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}val": "23"
             }
           },
+          "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}qFormat": {
+            "@tag": "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}qFormat",
+            "@attrib": {}
+          },
           "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}uiPriority": {
             "@tag": "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}uiPriority",
             "@attrib": {
@@ -3350,6 +3370,141 @@
           }
         }
       }
+    },
+    {
+      "name": "表格标题1",
+      "style_id": "28",
+      "type": "PARAGRAPH (1)",
+      "builtin": false,
+      "hidden": false,
+      "quick_style": true,
+      "priority": 0,
+      "base_style": "Normal",
+      "next_paragraph_style": "表格标题1",
+      "font_summary": {
+        "name": "Times New Roman",
+        "size_pt": 9.0,
+        "bold": true,
+        "italic": null,
+        "underline": null,
+        "color_rgb": null,
+        "strike": null,
+        "all_caps": null,
+        "small_caps": null
+      },
+      "paragraph_format_summary": {
+        "alignment": "CENTER (1)",
+        "left_indent_pt": null,
+        "right_indent_pt": null,
+        "first_line_indent_pt": 0.0,
+        "space_before_pt": null,
+        "space_after_pt": 1.2,
+        "line_spacing": 152400.0,
+        "keep_together": null,
+        "keep_with_next": null,
+        "page_break_before": null
+      },
+      "full_xml_definition": {
+        "@tag": "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}style",
+        "@attrib": {
+          "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}type": "paragraph",
+          "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}customStyle": "1",
+          "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}styleId": "28"
+        },
+        "@children": {
+          "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}name": {
+            "@tag": "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}name",
+            "@attrib": {
+              "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}val": "表格标题1"
+            }
+          },
+          "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}basedOn": {
+            "@tag": "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}basedOn",
+            "@attrib": {
+              "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}val": "1"
+            }
+          },
+          "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}qFormat": {
+            "@tag": "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}qFormat",
+            "@attrib": {}
+          },
+          "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}uiPriority": {
+            "@tag": "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}uiPriority",
+            "@attrib": {
+              "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}val": "0"
+            }
+          },
+          "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}pPr": {
+            "@tag": "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}pPr",
+            "@attrib": {},
+            "@children": {
+              "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}snapToGrid": {
+                "@tag": "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}snapToGrid",
+                "@attrib": {
+                  "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}val": "0"
+                }
+              },
+              "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}spacing": {
+                "@tag": "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}spacing",
+                "@attrib": {
+                  "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}after": "24",
+                  "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}line": "240",
+                  "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}lineRule": "exact"
+                }
+              },
+              "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}ind": {
+                "@tag": "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}ind",
+                "@attrib": {
+                  "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}firstLine": "0",
+                  "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}firstLineChars": "0"
+                }
+              },
+              "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}jc": {
+                "@tag": "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}jc",
+                "@attrib": {
+                  "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}val": "center"
+                }
+              }
+            }
+          },
+          "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}rPr": {
+            "@tag": "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}rPr",
+            "@attrib": {},
+            "@children": {
+              "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}rFonts": {
+                "@tag": "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}rFonts",
+                "@attrib": {
+                  "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}hint": "eastAsia",
+                  "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}ascii": "Times New Roman",
+                  "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}hAnsi": "Times New Roman",
+                  "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}eastAsia": "宋体",
+                  "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}cs": "宋体"
+                }
+              },
+              "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}b": {
+                "@tag": "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}b",
+                "@attrib": {}
+              },
+              "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}bCs": {
+                "@tag": "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}bCs",
+                "@attrib": {}
+              },
+              "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}sz": {
+                "@tag": "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}sz",
+                "@attrib": {
+                  "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}val": "18"
+                }
+              },
+              "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}szCs": {
+                "@tag": "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}szCs",
+                "@attrib": {
+                  "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}val": "18"
+                }
+              }
+            }
+          }
+        }
+      }
     }
   ],
   "numbering": {