rxiv-maker 1.16.8__py3-none-any.whl → 1.18.0__py3-none-any.whl

rxiv_maker/exporters/docx_writer.py

@@ -4,6 +4,7 @@ This module handles the actual generation of DOCX files using python-docx,
 writing structured content with formatting, citations, and references.
 """
 
+import base64
 from pathlib import Path
 from typing import Any, Dict, Optional
 
@@ -11,11 +12,12 @@ from docx import Document
 from docx.enum.text import WD_ALIGN_PARAGRAPH, WD_COLOR_INDEX
 from docx.oxml import OxmlElement
 from docx.oxml.ns import qn
-from docx.shared import Inches, Pt
+from docx.shared import Inches, Pt, RGBColor
 from latex2mathml.converter import convert as latex_to_mathml
 from lxml import etree
 
 from ..core.logging_config import get_logger
+from ..utils.author_affiliation_processor import AuthorAffiliationProcessor
 from ..utils.docx_helpers import convert_pdf_to_image
 
 logger = get_logger()
@@ -24,6 +26,29 @@ logger = get_logger()
 class DocxWriter:
     """Writes structured content to DOCX files using python-docx."""
 
+    # Color mapping for different reference types
+    XREF_COLORS = {
+        "fig": WD_COLOR_INDEX.BRIGHT_GREEN,  # Figures (bright green - lighter)
+        "sfig": WD_COLOR_INDEX.TURQUOISE,  # Supplementary figures (turquoise - lighter cyan)
+        "stable": WD_COLOR_INDEX.TURQUOISE,  # Supplementary tables (turquoise - lighter cyan)
+        "table": WD_COLOR_INDEX.BLUE,  # Main tables
+        "eq": WD_COLOR_INDEX.VIOLET,  # Equations
+        "snote": WD_COLOR_INDEX.TURQUOISE,  # Supplementary notes (turquoise - lighter cyan)
+        "cite": WD_COLOR_INDEX.YELLOW,  # Citations (yellow)
+    }
+
+    @staticmethod
+    def get_xref_color(xref_type: str):
+        """Get highlight color for a cross-reference type.
+
+        Args:
+            xref_type: Type of cross-reference (fig, sfig, stable, table, eq, snote, cite)
+
+        Returns:
+            WD_COLOR_INDEX color for the xref type, or YELLOW as default
+        """
+        return DocxWriter.XREF_COLORS.get(xref_type, WD_COLOR_INDEX.YELLOW)
+
     def write(
         self,
         doc_structure: Dict[str, Any],
@@ -32,6 +57,10 @@ class DocxWriter:
         include_footnotes: bool = True,
         base_path: Optional[Path] = None,
         metadata: Optional[Dict[str, Any]] = None,
+        table_map: Optional[Dict[str, int]] = None,
+        figures_at_end: bool = False,
+        hide_highlighting: bool = False,
+        hide_comments: bool = False,
     ) -> Path:
         """Write DOCX file from structured content.
 
@@ -42,6 +71,10 @@ class DocxWriter:
             include_footnotes: Whether to add DOI footnotes
             base_path: Base path for resolving relative figure paths
             metadata: Document metadata (title, authors, affiliations)
+            table_map: Mapping from table labels to numbers (for supplementary tables)
+            figures_at_end: Place main figures at end before SI/bibliography
+            hide_highlighting: Disable colored highlighting on references and citations
+            hide_comments: Exclude all comments (block and inline) from output
 
         Returns:
             Path to created DOCX file
@@ -49,8 +82,14 @@ class DocxWriter:
         self.base_path = base_path or Path.cwd()
         self.bibliography = bibliography
         self.include_footnotes = include_footnotes
+        self.table_map = table_map or {}
+        self.hide_highlighting = hide_highlighting
+        self.hide_comments = hide_comments
         doc = Document()
 
+        # Set default font to Arial for entire document
+        self._set_default_font(doc, "Arial")
+
         # Add title and author information if metadata provided
         if metadata:
             self._add_title_page(doc, metadata)
@@ -69,19 +108,44 @@ class DocxWriter:
         # Store figure map for use in text processing
         self.figure_map = figure_map
 
-        # Process each section INCLUDING figures inline
+        # Collect main figures if figures_at_end is True
+        collected_main_figures = []
+
+        # Process each section
         figure_counter = 0
+        sfigure_counter = 0
         for section in doc_structure["sections"]:
             if section["type"] == "figure":
-                figure_counter += 1
-                self._add_figure(doc, section, figure_number=figure_counter)
+                is_supplementary = section.get("is_supplementary", False)
+                if is_supplementary:
+                    # Supplementary figures always go inline (in SI section)
+                    sfigure_counter += 1
+                    self._add_figure(doc, section, figure_number=sfigure_counter, is_supplementary=True)
+                else:
+                    # Main figures: collect if figures_at_end, otherwise add inline
+                    figure_counter += 1
+                    if figures_at_end:
+                        collected_main_figures.append((section, figure_counter))
+                    else:
+                        self._add_figure(doc, section, figure_number=figure_counter, is_supplementary=False)
             else:
                 self._add_section(doc, section, bibliography, include_footnotes)
 
+        # Add collected main figures at the end (before bibliography)
+        if figures_at_end and collected_main_figures:
+            doc.add_page_break()
+            heading = doc.add_heading("Figures", level=1)
+            for run in heading.runs:
+                run.font.color.rgb = RGBColor(0, 0, 0)  # Ensure black text
+            for section, fig_num in collected_main_figures:
+                self._add_figure(doc, section, figure_number=fig_num, is_supplementary=False)
+
         # Add bibliography section at the end
         if include_footnotes and bibliography:
             doc.add_page_break()
-            doc.add_heading("Bibliography", level=1)
+            heading = doc.add_heading("Bibliography", level=1)
+            for run in heading.runs:
+                run.font.color.rgb = RGBColor(0, 0, 0)  # Ensure black text
 
             # Add numbered bibliography entries
             for num in sorted(bibliography.keys()):
@@ -92,15 +156,15 @@ class DocxWriter:
                 num_run = para.add_run(f"[{num}] ")
                 num_run.bold = True
 
-                # Add formatted bibliography text (slim format)
+                # Add formatted bibliography text (without DOI - added separately below)
                 para.add_run(bib_entry["formatted"])
 
-                # Add DOI as hyperlink with yellow highlighting if present
+                # Add DOI as hyperlink with yellow highlighting if present (unless hide_highlighting is enabled)
                 if bib_entry.get("doi"):
                     doi = bib_entry["doi"]
                     doi_url = f"https://doi.org/{doi}" if not doi.startswith("http") else doi
-                    para.add_run(" ")
-                    self._add_hyperlink(para, doi_url, doi_url, highlight=True)
+                    para.add_run("\nDOI: ")
+                    self._add_hyperlink(para, doi_url, doi_url, highlight=not self.hide_highlighting)
 
                 # Add spacing between entries
                 para.paragraph_format.space_after = Pt(6)
@@ -109,6 +173,38 @@ class DocxWriter:
         doc.save(str(output_path))
         return output_path
 
+    def _set_default_font(self, doc: Document, font_name: str):
+        """Set the default font for the entire document.
+
+        Args:
+            doc: Document object
+            font_name: Font name to use (e.g., "Arial", "Times New Roman")
+        """
+        # Set font on Normal style (base style for most content)
+        style = doc.styles["Normal"]
+        font = style.font
+        font.name = font_name
+        font.size = Pt(10)  # Default body font size
+
+        # Also set on heading styles to ensure consistency
+        for i in range(1, 10):
+            try:
+                heading_style = doc.styles[f"Heading {i}"]
+                heading_style.font.name = font_name
+            except KeyError:
+                # Heading style doesn't exist, skip
+                pass
+
+    def _apply_highlight(self, run, color: WD_COLOR_INDEX):
+        """Apply highlight color to a run, unless highlighting is disabled.
+
+        Args:
+            run: The run object to apply highlighting to
+            color: The WD_COLOR_INDEX color to apply
+        """
+        if not self.hide_highlighting:
+            run.font.highlight_color = color
+
     def _add_title_page(self, doc: Document, metadata: Dict[str, Any]):
         """Add title, author and affiliation information.
 
@@ -144,27 +240,16 @@ class DocxWriter:
         if not authors:
             return  # Nothing more to add
 
-        # Collect unique affiliations and build mapping
-        all_affiliations = []
-        affiliation_map = {}  # Maps affiliation shortname to number
-
-        # Get full affiliation details from metadata
-        affiliation_details = {a.get("shortname"): a for a in metadata.get("affiliations", [])}
-
-        for author in authors:
-            author_affils = author.get("affiliations", [])
-            for affil_shortname in author_affils:
-                if affil_shortname not in affiliation_map:
-                    affiliation_map[affil_shortname] = len(affiliation_map) + 1
-                    # Look up full affiliation info
-                    affil_info = affiliation_details.get(affil_shortname, {})
-                    full_name = affil_info.get("full_name", affil_shortname)
-                    location = affil_info.get("location", "")
-                    # Format: "Full Name, Location" or just "Full Name" if no location
-                    affil_text = f"{full_name}, {location}" if location else full_name
-                    all_affiliations.append(affil_text)
-
-        # Add authors with superscript affiliation numbers
+        # Process author and affiliation metadata using centralized processor
+        processor = AuthorAffiliationProcessor()
+        processed = processor.process(metadata)
+
+        affiliation_map = processed["affiliation_map"]
+        ordered_affiliations = processed["ordered_affiliations"]
+        cofirst_authors = processed["cofirst_authors"]
+        corresponding_authors = processed["corresponding_authors"]
+
+        # Add authors with superscript affiliation numbers and corresponding author markers
         if authors:
             author_para = doc.add_paragraph()
             for i, author in enumerate(authors):
@@ -182,25 +267,94 @@ class DocxWriter:
                     sup_run = author_para.add_run(",".join(affil_nums))
                     sup_run.font.superscript = True
 
+                # Add co-first author marker (dagger) if applicable
+                is_cofirst = author.get("co_first_author", False)
+                if is_cofirst:
+                    cofirst_run = author_para.add_run("†")
+                    cofirst_run.font.superscript = True
+
+                # Add corresponding author marker (asterisk) if applicable
+                is_corresponding = author.get("corresponding_author", False)
+                if is_corresponding:
+                    corr_run = author_para.add_run("*")
+                    corr_run.font.superscript = True
+
             author_para.paragraph_format.space_after = Pt(8)
 
         # Add affiliations
-        if all_affiliations:
-            for i, affil_text in enumerate(all_affiliations, start=1):
+        if ordered_affiliations:
+            for affil_num, _affil_shortname, affil_text in ordered_affiliations:
                 affil_para = doc.add_paragraph()
 
                 # Add superscript number
-                num_run = affil_para.add_run(str(i))
+                num_run = affil_para.add_run(str(affil_num))
                 num_run.font.superscript = True
+                num_run.font.size = Pt(8)
 
                 # Add affiliation text
-                affil_para.add_run(f" {affil_text}")
+                affil_run = affil_para.add_run(f" {affil_text}")
+                affil_run.font.size = Pt(8)
                 affil_para.paragraph_format.space_after = Pt(4)
-                affil_para.runs[1].font.size = Pt(10)
 
             # Extra space after last affiliation
             affil_para.paragraph_format.space_after = Pt(12)
 
+        # Add co-first author information if any (already extracted by processor)
+        if cofirst_authors:
+            cofirst_para = doc.add_paragraph()
+            cofirst_marker = cofirst_para.add_run("†")
+            cofirst_marker.font.superscript = True
+            cofirst_marker.font.size = Pt(8)
+
+            cofirst_label = cofirst_para.add_run(" These authors contributed equally: ")
+            cofirst_label.font.size = Pt(8)
+
+            for i, author in enumerate(cofirst_authors):
+                if i > 0:
+                    sep_run = cofirst_para.add_run(", ")
+                    sep_run.font.size = Pt(8)
+
+                name = author.get("name", "")
+                name_run = cofirst_para.add_run(name)
+                name_run.font.size = Pt(8)
+
+            cofirst_para.paragraph_format.space_after = Pt(12)
+
+        # Add corresponding author information if any (already extracted by processor)
+        if corresponding_authors:
+            corr_para = doc.add_paragraph()
+            corr_marker = corr_para.add_run("*")
+            corr_marker.font.superscript = True
+            corr_marker.font.size = Pt(8)
+
+            corr_label = corr_para.add_run(" Correspondence: ")
+            corr_label.font.size = Pt(8)
+
+            for i, author in enumerate(corresponding_authors):
+                if i > 0:
+                    sep_run = corr_para.add_run("; ")
+                    sep_run.font.size = Pt(8)
+
+                name = author.get("name", "")
+                email = author.get("email", "")
+
+                # Decode email if it's base64 encoded
+                if not email:
+                    email64 = author.get("email64", "")
+                    if email64:
+                        try:
+                            email = base64.b64decode(email64).decode("utf-8")
+                        except Exception:
+                            email = ""
+
+                if email:
+                    info_run = corr_para.add_run(f"{name} ({email})")
+                else:
+                    info_run = corr_para.add_run(name)
+                info_run.font.size = Pt(8)
+
+            corr_para.paragraph_format.space_after = Pt(12)
+
     def _add_section(
         self,
         doc: Document,
@@ -228,6 +382,9 @@ class DocxWriter:
             self._add_list(doc, section)
         elif section_type == "code_block":
             self._add_code_block(doc, section)
+        elif section_type == "comment":
+            if not self.hide_comments:
+                self._add_comment(doc, section)
         elif section_type == "figure":
             self._add_figure(doc, section)
         elif section_type == "table":
@@ -253,6 +410,7 @@ class DocxWriter:
         run = para.add_run(text)
         run.bold = True
         run.font.size = Pt(12)
+        run.font.color.rgb = RGBColor(0, 0, 0)  # Ensure black text
 
     def _add_heading(self, doc: Document, section: Dict[str, Any]):
         """Add heading to document.
@@ -263,7 +421,10 @@ class DocxWriter:
         """
         level = section["level"]
         text = section["text"]
-        doc.add_heading(text, level=level)
+        heading = doc.add_heading(text, level=level)
+        # Ensure heading text is black (not blue)
+        for run in heading.runs:
+            run.font.color.rgb = RGBColor(0, 0, 0)  # Explicitly set to black
 
     def _add_paragraph(
         self,
@@ -310,13 +471,19 @@ class DocxWriter:
                 run.italic = True
             if run_data.get("underline"):
                 run.underline = True
+            if run_data.get("subscript"):
+                run.font.subscript = True
+            if run_data.get("superscript"):
+                run.font.superscript = True
             if run_data.get("code"):
                 run.font.name = "Courier New"
                 run.font.size = Pt(10)
             if run_data.get("xref"):
-                run.font.highlight_color = WD_COLOR_INDEX.YELLOW
+                # Use color based on xref type (fig, sfig, stable, eq, etc.)
+                xref_type = run_data.get("xref_type", "cite")
+                self._apply_highlight(run, self.get_xref_color(xref_type))
             if run_data.get("highlight_yellow"):
-                run.font.highlight_color = WD_COLOR_INDEX.YELLOW
+                self._apply_highlight(run, WD_COLOR_INDEX.YELLOW)
 
         elif run_data["type"] == "hyperlink":
             # Add hyperlink with yellow highlighting
@@ -329,11 +496,20 @@ class DocxWriter:
             latex_content = run_data.get("latex", "")
             self._add_inline_equation(paragraph, latex_content)
 
+        elif run_data["type"] == "inline_comment":
+            # Add inline comment with gray highlighting (unless hide_comments is enabled)
+            if not self.hide_comments:
+                comment_text = run_data["text"]
+                run = paragraph.add_run(f"[Comment: {comment_text}]")
+                self._apply_highlight(run, WD_COLOR_INDEX.GRAY_25)
+                run.italic = True
+                run.font.size = Pt(10)
+
         elif run_data["type"] == "citation":
             cite_num = run_data["number"]
             # Add citation as [NN] inline with yellow highlighting
             run = paragraph.add_run(f"[{cite_num}]")
-            run.font.highlight_color = WD_COLOR_INDEX.YELLOW
+            self._apply_highlight(run, WD_COLOR_INDEX.YELLOW)
             run.font.size = Pt(10)
 
     def _add_list(self, doc: Document, section: Dict[str, Any]):
@@ -362,15 +538,21 @@ class DocxWriter:
                         run.bold = True
                     if run_data.get("italic"):
                         run.italic = True
+                    if run_data.get("subscript"):
+                        run.font.subscript = True
+                    if run_data.get("superscript"):
+                        run.font.superscript = True
                     if run_data.get("code"):
                         run.font.name = "Courier New"
                     if run_data.get("xref"):
-                        run.font.highlight_color = WD_COLOR_INDEX.YELLOW
+                        # Use color based on xref type
+                        xref_type = run_data.get("xref_type", "cite")
+                        self._apply_highlight(run, self.get_xref_color(xref_type))
                     if run_data.get("highlight_yellow"):
-                        run.font.highlight_color = WD_COLOR_INDEX.YELLOW
+                        self._apply_highlight(run, WD_COLOR_INDEX.YELLOW)
                         run.font.size = Pt(10)
                     if run_data.get("highlight_yellow"):
-                        run.font.highlight_color = WD_COLOR_INDEX.YELLOW
+                        self._apply_highlight(run, WD_COLOR_INDEX.YELLOW)
                 elif run_data["type"] == "hyperlink":
                     text = run_data.get("text", "")
                     url = run_data.get("url", "")
@@ -379,11 +561,20 @@ class DocxWriter:
                     # Add inline equation as Office Math
                     latex_content = run_data.get("latex", "")
                     self._add_inline_equation(paragraph, latex_content)
+                elif run_data["type"] == "inline_comment":
+                    # Add inline comment with gray highlighting (unless hide_comments is enabled)
+                    if not self.hide_comments:
+                        comment_text = run_data["text"]
+                        run = paragraph.add_run(f"[Comment: {comment_text}]")
+                        self._apply_highlight(run, WD_COLOR_INDEX.GRAY_25)
+                        run.italic = True
+                        run.font.size = Pt(10)
                 elif run_data["type"] == "citation":
                     cite_num = run_data["number"]
                     run = paragraph.add_run(f"[{cite_num}]")
                     run.bold = True
                     run.font.size = Pt(10)
+                    self._apply_highlight(run, WD_COLOR_INDEX.YELLOW)
 
     def _add_code_block(self, doc: Document, section: Dict[str, Any]):
         """Add code block to document.
@@ -404,6 +595,22 @@ class DocxWriter:
         paragraph_format = paragraph.paragraph_format
         paragraph_format.left_indent = Pt(36)  # Indent code blocks
 
+    def _add_comment(self, doc: Document, section: Dict[str, Any]):
+        """Add comment to document with gray highlighting.
+
+        Args:
+            doc: Document object
+            section: Comment section data with 'text'
+        """
+        comment_text = section["text"]
+        paragraph = doc.add_paragraph()
+
+        # Add comment text with light gray highlighting to distinguish from colored xrefs
+        run = paragraph.add_run(f"[Comment: {comment_text}]")
+        self._apply_highlight(run, WD_COLOR_INDEX.GRAY_25)
+        run.italic = True
+        run.font.size = Pt(10)
+
     def _check_poppler_availability(self) -> bool:
         """Check if poppler is available for PDF conversion.
 
@@ -417,13 +624,16 @@ class DocxWriter:
 
         return result.status == DependencyStatus.AVAILABLE
 
-    def _add_figure(self, doc: Document, section: Dict[str, Any], figure_number: int = None):
+    def _add_figure(
+        self, doc: Document, section: Dict[str, Any], figure_number: int = None, is_supplementary: bool = False
+    ):
         """Add figure to document with caption.
 
         Args:
             doc: Document object
             section: Figure section data with 'path', 'caption', 'label'
             figure_number: Figure number (1-indexed)
+            is_supplementary: Whether this is a supplementary figure
         """
         figure_path = Path(section["path"])
         caption = section.get("caption", "")
@@ -470,19 +680,45 @@ class DocxWriter:
             logger.warning(f"Unsupported image format: {figure_path.suffix}")
 
         if img_source:
-            # Add image
+            # Add image with proper sizing to fit page
             try:
-                doc.add_picture(img_source, width=Inches(6))
-                logger.debug(f"Embedded figure: {figure_path}")
+                from PIL import Image as PILImage
+
+                # Get image dimensions
+                with PILImage.open(img_source) as img:
+                    img_width, img_height = img.size
+                    aspect_ratio = img_width / img_height
+
+                # Page dimensions with margins (Letter size: 8.5 x 11 inches, 1 inch margins)
+                max_width = Inches(6.5)  # 8.5 - 2*1
+                max_height = Inches(9)  # 11 - 2*1
+
+                # Add figure centered
+                # Note: add_picture() creates a paragraph automatically, but we need to add it explicitly
+                # to control alignment
+                fig_para = doc.add_paragraph()
+                fig_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
+
+                # Calculate optimal size maintaining aspect ratio
+                if aspect_ratio > (6.5 / 9):  # Wide image - constrain by width
+                    run = fig_para.add_run()
+                    run.add_picture(img_source, width=max_width)
+                else:  # Tall image - constrain by height
+                    run = fig_para.add_run()
+                    run.add_picture(img_source, height=max_height)
+
+                logger.debug(f"Embedded figure: {figure_path} ({img_width}x{img_height})")
             except Exception as e:
                 logger.warning(f"Failed to embed figure {figure_path}: {e}")
-                # Add placeholder text
+                # Add placeholder text (centered)
                 p = doc.add_paragraph()
+                p.alignment = WD_ALIGN_PARAGRAPH.CENTER
                 run = p.add_run(f"[Figure: {figure_path.name}]")
                 run.italic = True
         else:
-            # Add placeholder if embedding failed
+            # Add placeholder if embedding failed (centered)
             p = doc.add_paragraph()
+            p.alignment = WD_ALIGN_PARAGRAPH.CENTER
             run = p.add_run(f"[Figure: {figure_path.name}]")
             run.italic = True
             logger.warning(f"Could not embed figure: {figure_path}")
@@ -494,15 +730,18 @@ class DocxWriter:
             # Add small space before caption to separate from figure
             caption_para.paragraph_format.space_before = Pt(3)
 
-            # Format as "Figure number: "
+            # Format as "Figure number: " or "Supp. Fig. number: "
             if figure_number:
-                run = caption_para.add_run(f"Figure {figure_number}: ")
+                if is_supplementary:
+                    run = caption_para.add_run(f"Supp. Fig. S{figure_number}. ")
+                else:
+                    run = caption_para.add_run(f"Fig. {figure_number}. ")
                 run.bold = True
-                run.font.size = Pt(7)
+                run.font.size = Pt(8)
             else:
                 run = caption_para.add_run("Figure: ")
                 run.bold = True
-                run.font.size = Pt(7)
+                run.font.size = Pt(8)
 
             # Parse and add caption with inline formatting
             # Import the processor to parse inline formatting
@@ -515,28 +754,43 @@ class DocxWriter:
                 if run_data["type"] == "text":
                     text = run_data["text"]
                     run = caption_para.add_run(text)
-                    run.font.size = Pt(7)
+                    run.font.size = Pt(8)
 
                     # Apply formatting
                     if run_data.get("bold"):
                         run.bold = True
                     if run_data.get("italic"):
                         run.italic = True
+                    if run_data.get("subscript"):
+                        run.font.subscript = True
+                    if run_data.get("superscript"):
+                        run.font.superscript = True
                     if run_data.get("code"):
                         run.font.name = "Courier New"
                     if run_data.get("xref"):
-                        run.font.highlight_color = WD_COLOR_INDEX.YELLOW
+                        # Use color based on xref type
+                        xref_type = run_data.get("xref_type", "cite")
+                        self._apply_highlight(run, self.get_xref_color(xref_type))
                     if run_data.get("highlight_yellow"):
-                        run.font.highlight_color = WD_COLOR_INDEX.YELLOW
+                        self._apply_highlight(run, WD_COLOR_INDEX.YELLOW)
                 elif run_data["type"] == "inline_equation":
                     # Add inline equation as Office Math
                     latex_content = run_data.get("latex", "")
                     self._add_inline_equation(caption_para, latex_content)
+                elif run_data["type"] == "inline_comment":
+                    # Add inline comment with gray highlighting (unless hide_comments is enabled)
+                    if not self.hide_comments:
+                        comment_text = run_data["text"]
+                        run = caption_para.add_run(f"[Comment: {comment_text}]")
+                        self._apply_highlight(run, WD_COLOR_INDEX.GRAY_25)
+                        run.italic = True
+                        run.font.size = Pt(8)
                 elif run_data["type"] == "citation":
                     cite_num = run_data["number"]
                     run = caption_para.add_run(f"[{cite_num}]")
                     run.bold = True
-                    run.font.size = Pt(7)
+                    run.font.size = Pt(8)
+                    self._apply_highlight(run, WD_COLOR_INDEX.YELLOW)
 
             # Add spacing after figure (reduced from 12 to 6 for compactness)
             caption_para.paragraph_format.space_after = Pt(6)
@@ -602,10 +856,16 @@ class DocxWriter:
                                 run.italic = True
                             if run_data.get("underline"):
                                 run.underline = True
+                            if run_data.get("subscript"):
+                                run.font.subscript = True
+                            if run_data.get("superscript"):
+                                run.font.superscript = True
                             if run_data.get("code"):
                                 run.font.name = "Courier New"
                             if run_data.get("xref"):
-                                run.font.highlight_color = WD_COLOR_INDEX.YELLOW
+                                # Use color based on xref type
+                                xref_type = run_data.get("xref_type", "cite")
+                                self._apply_highlight(run, self.get_xref_color(xref_type))
 
         # Add table caption if present
         caption = section.get("caption")
@@ -616,18 +876,30 @@ class DocxWriter:
             # Add small space before caption to separate from table
             caption_para.paragraph_format.space_before = Pt(3)
 
-            # Determine table number from label (e.g., "stable:structural_models" -> "Supp. Table 1")
+            # Determine table number from label using table_map
             if label and label.startswith("stable:"):
-                # Count how many supplementary tables we've seen so far
-                # For now, we'll just format as "Supp. Table: caption"
-                # A more sophisticated approach would track table numbers
-                run = caption_para.add_run("Supp. Table: ")
+                # Extract label name (e.g., "stable:parameters" -> "parameters")
+                label_name = label.split(":", 1)[1] if ":" in label else label
+                # Look up number in table_map
+                table_num = self.table_map.get(label_name)
+                if table_num:
+                    run = caption_para.add_run(f"Supp. Table S{table_num}. ")
+                else:
+                    # Fallback if label not in map
+                    run = caption_para.add_run("Supp. Table: ")
                 run.bold = True
-                run.font.size = Pt(7)
+                run.font.size = Pt(8)
             elif label and label.startswith("table:"):
-                run = caption_para.add_run("Table: ")
+                # Extract label name for main tables
+                label_name = label.split(":", 1)[1] if ":" in label else label
+                # Look up number in table_map (though main tables may not be in map)
+                table_num = self.table_map.get(label_name)
+                if table_num:
+                    run = caption_para.add_run(f"Table {table_num}. ")
+                else:
+                    run = caption_para.add_run("Table: ")
                 run.bold = True
-                run.font.size = Pt(7)
+                run.font.size = Pt(8)
 
             # Parse and add caption with inline formatting
             caption_runs = processor._parse_inline_formatting(caption, {})
@@ -635,17 +907,23 @@ class DocxWriter:
                 if run_data["type"] == "text":
                     text = run_data["text"]
                     run = caption_para.add_run(text)
-                    run.font.size = Pt(7)
+                    run.font.size = Pt(8)
                     if run_data.get("bold"):
                         run.bold = True
                     if run_data.get("italic"):
                         run.italic = True
                     if run_data.get("underline"):
                         run.underline = True
+                    if run_data.get("subscript"):
+                        run.font.subscript = True
+                    if run_data.get("superscript"):
+                        run.font.superscript = True
                     if run_data.get("code"):
                         run.font.name = "Courier New"
                     if run_data.get("xref"):
-                        run.font.highlight_color = WD_COLOR_INDEX.YELLOW
+                        # Use color based on xref type
+                        xref_type = run_data.get("xref_type", "cite")
+                        self._apply_highlight(run, self.get_xref_color(xref_type))
 
             # Add spacing after table (reduced from 12 to 6 for compactness)
             caption_para.paragraph_format.space_after = Pt(6)