Enhance DOCX to PDF conversion by adding support for last rendered page breaks and adjusting line height calculations; update handling of empty paragraphs and improve proactive page break logic.

Author: shps951023

src/MiniPdf/DocxReader.cs

@@ -447,6 +447,7 @@ internal static DocxDocument Read(Stream stream)
         bool isNumberedList = false;
         bool pageBreakBefore = false;
         bool pageBreakAfter = false;
+        bool hasLastRenderedPageBreak = false;
         bool snapToGrid = true;
         int listLevel = 0;
         string? listText = null;
@@ -778,6 +779,16 @@ internal static DocxDocument Read(Stream stream)
                     continue;
                 }
 
+                // Detect lastRenderedPageBreak: Word's hint that a page break occurred
+                // at this position in the last rendering pass.  Only honour it when the
+                // marker appears before any visible content in the paragraph (i.e. a
+                // paragraph-level page break, not a mid-paragraph line break).
+                if (!hasLastRenderedPageBreak && runs.Count == 0 && images.Count == 0
+                    && child.Element(W + "lastRenderedPageBreak") != null)
+                {
+                    hasLastRenderedPageBreak = true;
+                }
+
                 var run = ReadRun(child, bold, italic, fontSize, color, caps, charSpacing, paragraphFontName, defaultLatinFontName, defaultEastAsiaFontName, styles);
                 if (run != null)
                 {
@@ -852,7 +863,8 @@ internal static DocxDocument Read(Stream stream)
             ParagraphFontName: paragraphFontName,
             KeepNext: keepNext,
             AutoSpaceDE: autoSpaceDE,
-            AutoSpaceDN: autoSpaceDN);
+            AutoSpaceDN: autoSpaceDN,
+            HasLastRenderedPageBreak: hasLastRenderedPageBreak);
     }
 
     /// <summary>
@@ -3507,7 +3519,8 @@ internal sealed record DocxParagraph(
     string? ParagraphFontName = null,
     bool KeepNext = false,
     bool AutoSpaceDE = true,
-    bool AutoSpaceDN = true
+    bool AutoSpaceDN = true,
+    bool HasLastRenderedPageBreak = false
 ) : DocxElement;
 
 /// <summary>Represents a single border edge.</summary>

src/MiniPdf/DocxToPdfConverter.cs

@@ -807,14 +807,22 @@ private static void RenderParagraph(RenderState state, DocxParagraph paragraph)
             var gridPitch = options.GridLinePitch;
             if (paragraph.LineSpacing == 0)
             {
-                // Auto-spaced: use max run font size for grid-snapped height.
+                // Auto-spaced: for fonts that fit in a single grid cell, snap
+                // the line height to the grid pitch.  For larger fonts spanning
+                // multiple cells, keep the raw auto-spacing value (fontSize ×
+                // metricsFactor) — Word advances by the natural line height,
+                // not the full n×gridPitch allocation, so subsequent text
+                // resumes closer to the heading.
                 var maxFs = fontSize;
                 foreach (var run in paragraph.Runs)
                 {
                     var runFs = run.FontSize > 0 ? run.FontSize : fontSize;
                     if (runFs > maxFs) maxFs = runFs;
                 }
-                lineHeight = Math.Max(gridPitch, Compat.Ceiling(maxFs / gridPitch) * gridPitch);
+                if (Compat.Ceiling(maxFs / gridPitch) > 1)
+                    lineHeight = Math.Max(gridPitch, lineHeight);
+                else
+                    lineHeight = gridPitch;
             }
             else if (paragraph.LineSpacingAbsolute && !paragraph.LineSpacingExact)
             {
@@ -838,6 +846,15 @@ private static void RenderParagraph(RenderState state, DocxParagraph paragraph)
             }
         }
 
+        // Force a page break when the paragraph carries Word's lastRenderedPageBreak
+        // hint, indicating that Word placed a break before this paragraph's content.
+        // This must precede the empty-paragraph block so it fires for non-empty
+        // paragraphs that would render visible text.
+        if (paragraph.HasLastRenderedPageBreak && state.CurrentPage != null && !state.IsTopOfPage)
+        {
+            state.ForceNewPage();
+        }
+
         // Handle empty paragraphs before EnsurePage — they don't produce visible content
         // and should not force a new page (avoids spurious trailing pages).
         if (paragraph.Runs.Count == 0 && paragraph.Images.Count == 0 && paragraph.Shading == null
@@ -1226,15 +1243,11 @@ private static void RenderParagraph(RenderState state, DocxParagraph paragraph)
 
             for (var i = 0; i < lines.Count; i++)
             {
-                // Proactive page break: break only when the text's descenders
-                // would clip below the bottom margin.  Text is rendered at the
-                // current Y (baseline); only the descent extends downward.
-                // Using the full lineHeight (which includes inter-line spacing /
-                // grid pitch) is over-conservative and causes premature breaks
-                // that don't match Word/LibreOffice behavior.
-                var pageBreakDescent = runFontSize * (GetFontMetricsFactor(runFontName) - 1f);
+                // Proactive page break: break when the text's descenders would
+                // clip below the bottom margin.
+                var pageBreakThreshold = runFontSize * (GetFontMetricsFactor(runFontName) - 1f);
                 if (state.CurrentPage != null && !state.IsTopOfPage
-                    && state.CurrentY - pageBreakDescent < state.Options.MarginBottom)
+                    && state.CurrentY - pageBreakThreshold < state.Options.MarginBottom)
                 {
                     state.ForceNewPage();
                 }
@@ -3836,7 +3849,11 @@ private static string AddInterScriptSpacing(string text, bool autoSpaceDE = true
         {
             if (autoSpaceDE && ShouldInsertInterScriptSpace(text, i))
             {
-                sb.Append(' ');
+                // Use THIN SPACE so the inter-script gap is not treated as a word
+                // boundary by WordWrap (Split(' ')) and is not expanded by justify
+                // word spacing.  Word's autoSpaceDE is visual spacing only – it does
+                // NOT create a line-break opportunity.
+                sb.Append('\u2009');
             }
             else if (autoSpaceDN && ShouldInsertDigitCjkSpace(text, i))
             {