docxodus 9.8.0 → 9.9.0

package/dist/editor.bundle.js

@@ -259,6 +259,9 @@ var DocxodusEditor = (() => {
   }
 
   // src/pagination.ts
+  function samePageBox(a, b) {
+    return a.pageWidth === b.pageWidth && a.pageHeight === b.pageHeight && a.marginTop === b.marginTop && a.marginRight === b.marginRight && a.marginBottom === b.marginBottom && a.marginLeft === b.marginLeft;
+  }
   var MAX_FOOTNOTE_AREA_RATIO = 0.6;
   var MIN_BODY_CONTENT_HEIGHT = 72;
   var PaginationEngine = class {
@@ -304,16 +307,43 @@ var DocxodusEditor = (() => {
       );
       this.pageNumbering = this.parsePageNumbering(sections);
       const sectionsToProcess = sections.length > 0 ? Array.from(sections) : [this.stagingElement];
+      const runs = [];
       for (const section of sectionsToProcess) {
-        const sectionIndex = parseInt(section.dataset.sectionIndex || "0", 10);
         const dims = parseSectionDimensions(section);
+        const previous = runs[runs.length - 1];
+        if (previous && section.dataset.sectionType === "continuous" && samePageBox(previous.dims, dims)) {
+          previous.sections.push(section);
+        } else {
+          runs.push({
+            sections: [section],
+            sectionIndex: parseInt(section.dataset.sectionIndex || "0", 10),
+            dims
+          });
+        }
+      }
+      for (const run of runs) {
         this.stagingElement.style.visibility = "hidden";
         this.stagingElement.style.position = "absolute";
         this.stagingElement.style.left = "-9999px";
         this.stagingElement.style.display = "block";
-        section.style.width = `${dims.contentWidth}pt`;
-        const blocks = this.measureBlocks(section, dims);
-        const sectionPages = this.flowToPages(blocks, dims, pageNumber, sectionIndex);
+        const blocks = [];
+        for (const section of run.sections) {
+          section.style.width = `${run.dims.contentWidth}pt`;
+          const columnCount = parseInt(section.dataset.cols || "1", 10);
+          if (columnCount > 1) {
+            const gap = parseFloat(section.dataset.colGap || "");
+            blocks.push(...this.buildColumnBlocks(
+              section,
+              run.dims,
+              run.sectionIndex,
+              columnCount,
+              Number.isFinite(gap) ? gap : 36
+            ));
+          } else {
+            blocks.push(...this.measureBlocks(section, run.dims));
+          }
+        }
+        const sectionPages = this.flowToPages(blocks, run.dims, pageNumber, run.sectionIndex);
         pages.push(...sectionPages);
         pageNumber += sectionPages.length;
       }
@@ -402,11 +432,70 @@ var DocxodusEditor = (() => {
           keepWithNext: child.dataset.keepWithNext === "true",
           keepLines: child.dataset.keepLines === "true",
           pageBreakBefore: child.dataset.pageBreakBefore === "true",
-          isPageBreak
+          isPageBreak,
+          isWordParagraph: this.isWordParagraphElement(child)
         });
       }
       return blocks;
     }
+    /**
+     * Flows a multi-column (`w:cols`) section's children into CSS-multicol container
+     * blocks. Word lays such a section out as N columns inside the same body extent;
+     * a balanced `column-count` container reproduces that geometry, and the paginator
+     * then places each container as one ordinary measured block. A container grows
+     * greedily until its balanced height would exceed the smallest page body available
+     * to the section, so a long columned section still splits across pages at block
+     * boundaries. Each child lands in exactly one container, so anchors never
+     * duplicate. An explicit page break child passes through as its own block, which
+     * ends the current container and lets the normal flow logic turn the page.
+     */
+    buildColumnBlocks(section, dims, sectionIndex, columnCount, columnGapPt) {
+      const children = Array.from(section.children);
+      const blocks = [];
+      const maxFragmentHeight = this.smallestEffectiveContentHeight(dims, sectionIndex);
+      const isBreak = (child) => child.dataset.pageBreak === "true" || child.classList.contains(`${this.cssPrefix}break`);
+      const makeContainer = (slice) => {
+        const container = document.createElement("div");
+        container.style.columnCount = String(columnCount);
+        container.style.columnGap = `${columnGapPt}pt`;
+        for (const child of slice) {
+          container.appendChild(child.cloneNode(true));
+        }
+        return container;
+      };
+      let start2 = 0;
+      while (start2 < children.length) {
+        if (isBreak(children[start2])) {
+          blocks.push(this.measureElement(children[start2], dims));
+          start2++;
+          continue;
+        }
+        let end = start2 + 1;
+        let container = makeContainer(children.slice(start2, end));
+        let measured = this.measureElement(container, dims);
+        while (end < children.length && !isBreak(children[end])) {
+          const candidate = makeContainer(children.slice(start2, end + 1));
+          const candidateMeasured = this.measureElement(candidate, dims);
+          if (candidateMeasured.heightPt > maxFragmentHeight) break;
+          container = candidate;
+          measured = candidateMeasured;
+          end++;
+        }
+        blocks.push({
+          element: container,
+          heightPt: measured.heightPt,
+          marginTopPt: measured.marginTopPt,
+          marginBottomPt: measured.marginBottomPt,
+          keepWithNext: false,
+          keepLines: false,
+          pageBreakBefore: false,
+          isPageBreak: false,
+          isWordParagraph: false
+        });
+        start2 = end;
+      }
+      return blocks;
+    }
     /**
      * Measures one element in the same hidden staging context used for the source blocks.
      * This is intentionally DOM-based: table row heights cannot be inferred from individual
@@ -431,7 +520,8 @@ var DocxodusEditor = (() => {
         keepWithNext: element.dataset.keepWithNext === "true",
         keepLines: element.dataset.keepLines === "true",
         pageBreakBefore: element.dataset.pageBreakBefore === "true",
-        isPageBreak: element.dataset.pageBreak === "true" || element.classList.contains(`${this.cssPrefix}break`)
+        isPageBreak: element.dataset.pageBreak === "true" || element.classList.contains(`${this.cssPrefix}break`),
+        isWordParagraph: this.isWordParagraphElement(element)
       };
       this.stagingElement.removeChild(measurementHost);
       return measured;
@@ -463,10 +553,15 @@ var DocxodusEditor = (() => {
      * collapsed-margin rules as normal block placement. The trailing margin is
      * intentionally excluded, matching the individual block fit check.
      */
-    measureKeepWithNextChainBodyHeight(chain, previousMarginBottomPt, isFirstOnPage) {
+    measureKeepWithNextChainBodyHeight(chain, previousMarginBottomPt, isFirstOnPage, pageInSection) {
       const firstBlock = chain[0];
       if (!firstBlock) return 0;
-      const firstMarginTop = isFirstOnPage ? firstBlock.marginTopPt : Math.max(firstBlock.marginTopPt, previousMarginBottomPt) - previousMarginBottomPt;
+      const firstMarginTop = this.effectiveBlockMarginTop(
+        firstBlock,
+        previousMarginBottomPt,
+        isFirstOnPage,
+        pageInSection
+      );
       let bodyHeight = firstMarginTop + firstBlock.heightPt;
       for (let index = 1; index < chain.length; index++) {
         const previousBlock = chain[index - 1];
@@ -475,6 +570,35 @@ var DocxodusEditor = (() => {
       }
       return bodyHeight;
     }
+    /** Word paragraphs render as `p`, or as `h1`–`h6` when their style has an outline level. */
+    isWordParagraphElement(element) {
+      return element.tagName === "P" || /^H[1-6]$/.test(element.tagName);
+    }
+    shouldSuppressPageTopSpacing(block, isFirstOnPage, pageInSection) {
+      return isFirstOnPage && pageInSection > 1 && block.isWordParagraph === true;
+    }
+    /**
+     * Resolves the part of a block's top margin that consumes the current page.
+     *
+     * In Word's native DOCX layout, paragraph space-before is suppressed when a paragraph is the
+     * first body block on a later page of the SAME section. The first page of a document/section is
+     * the exception and keeps its spacing. Tables and other block margins are not paragraph spacing,
+     * so they continue to use the ordinary CSS collapsing rule.
+     */
+    effectiveBlockMarginTop(block, previousMarginBottomPt, isFirstOnPage, pageInSection) {
+      if (this.shouldSuppressPageTopSpacing(block, isFirstOnPage, pageInSection)) {
+        return 0;
+      }
+      return isFirstOnPage ? block.marginTopPt : Math.max(block.marginTopPt, previousMarginBottomPt) - previousMarginBottomPt;
+    }
+    /** Clone a source block with the same page-top spacing decision used by the height budget. */
+    cloneBlockForPage(block, isFirstOnPage, pageInSection) {
+      const clone = block.element.cloneNode(true);
+      if (this.shouldSuppressPageTopSpacing(block, isFirstOnPage, pageInSection)) {
+        clone.style.setProperty("margin-top", "0", "important");
+      }
+      return clone;
+    }
     /**
      * Finds footnote references introduced by a sequence of blocks, preserving
      * document order and excluding references already assigned to the page.
@@ -1280,7 +1404,8 @@ var DocxodusEditor = (() => {
             const currentChainHeight = this.measureKeepWithNextChainBodyHeight(
               keepChain,
               prevMarginBottomPt,
-              currentContent.length === 0
+              currentContent.length === 0,
+              pageInSection
             ) + additionalChainFootnoteHeight;
             const currentAvailableHeight = remainingHeight - currentFootnoteHeight;
             if (currentChainHeight > currentAvailableHeight) {
@@ -1293,7 +1418,8 @@ var DocxodusEditor = (() => {
               const freshChainBodyHeight = this.measureKeepWithNextChainBodyHeight(
                 keepChain,
                 0,
-                true
+                true,
+                pageInSection + 1
               );
               const freshChainFootnoteHeight = this.measureFootnotesHeight(
                 newChainFootnoteIds,
@@ -1319,10 +1445,12 @@ var DocxodusEditor = (() => {
           additionalFootnoteHeight = totalFootnoteHeight - currentFootnoteHeight;
         }
         const isFirstOnPage = currentContent.length === 0;
-        let effectiveMarginTop = block.marginTopPt;
-        if (!isFirstOnPage) {
-          effectiveMarginTop = Math.max(block.marginTopPt, prevMarginBottomPt) - prevMarginBottomPt;
-        }
+        const effectiveMarginTop = this.effectiveBlockMarginTop(
+          block,
+          prevMarginBottomPt,
+          isFirstOnPage,
+          pageInSection
+        );
         const blockSpace = effectiveMarginTop + block.heightPt + additionalFootnoteHeight;
         const effectiveRemainingHeight = remainingHeight - currentFootnoteHeight;
         const bodyContentUsed = effectiveContentHeight - remainingHeight;
@@ -1342,19 +1470,19 @@ var DocxodusEditor = (() => {
           }
         }
         if (blockSpace <= effectiveRemainingHeight) {
-          currentContent.push(block.element.cloneNode(true));
+          currentContent.push(this.cloneBlockForPage(block, isFirstOnPage, pageInSection));
           remainingHeight -= effectiveMarginTop + block.heightPt + block.marginBottomPt;
           prevMarginBottomPt = block.marginBottomPt;
           if (newFootnoteIds.length > 0) {
             currentFootnoteIds.push(...newFootnoteIds);
             currentFootnoteHeight += additionalFootnoteHeight;
           }
-        } else if (block.heightPt + block.marginTopPt <= effectiveContentHeight) {
+        } else if (block.heightPt + this.effectiveBlockMarginTop(block, 0, true, pageInSection + 1) <= effectiveContentHeight) {
           const blockSpaceWithoutFootnotes = effectiveMarginTop + block.heightPt;
           const minBodySpaceNeeded = bodyContentUsed + blockSpaceWithoutFootnotes + MIN_BODY_CONTENT_HEIGHT;
           const canExpandFootnotes = minBodySpaceNeeded <= effectiveContentHeight;
           if (newFootnoteIds.length > 0 && blockSpaceWithoutFootnotes <= effectiveRemainingHeight) {
-            currentContent.push(block.element.cloneNode(true));
+            currentContent.push(this.cloneBlockForPage(block, isFirstOnPage, pageInSection));
             remainingHeight -= effectiveMarginTop + block.heightPt + block.marginBottomPt;
             prevMarginBottomPt = block.marginBottomPt;
             const availableForFootnotes = Math.min(
@@ -1401,7 +1529,7 @@ var DocxodusEditor = (() => {
             const expandedFootnoteSpace = Math.min(maxFootnoteArea, additionalFootnoteHeight + currentFootnoteHeight);
             const bodySpaceAfterExpansion = effectiveContentHeight - expandedFootnoteSpace;
             if (blockSpaceWithoutFootnotes <= bodySpaceAfterExpansion - bodyContentUsed) {
-              currentContent.push(block.element.cloneNode(true));
+              currentContent.push(this.cloneBlockForPage(block, isFirstOnPage, pageInSection));
               remainingHeight = bodySpaceAfterExpansion - bodyContentUsed - blockSpaceWithoutFootnotes;
               prevMarginBottomPt = block.marginBottomPt;
               currentFootnoteIds.push(...newFootnoteIds);
@@ -1409,8 +1537,14 @@ var DocxodusEditor = (() => {
             } else {
               finishPage();
               const newPageFootnoteHeight = allBlockFootnoteIds.length > 0 ? this.measureFootnotesHeight(allBlockFootnoteIds, dims.contentWidth, currentContinuation) : currentContinuation ? this.measureContinuationHeight(currentContinuation, dims.contentWidth) : 0;
-              const newPageSpace = block.marginTopPt + block.heightPt + block.marginBottomPt;
-              currentContent.push(block.element.cloneNode(true));
+              const newPageMarginTop = this.effectiveBlockMarginTop(
+                block,
+                0,
+                true,
+                pageInSection
+              );
+              const newPageSpace = newPageMarginTop + block.heightPt + block.marginBottomPt;
+              currentContent.push(this.cloneBlockForPage(block, true, pageInSection));
               remainingHeight = effectiveContentHeight - newPageSpace;
               prevMarginBottomPt = block.marginBottomPt;
               currentFootnoteIds = [...currentFootnoteIds, ...allBlockFootnoteIds];
@@ -1419,8 +1553,14 @@ var DocxodusEditor = (() => {
           } else {
             finishPage();
             const newPageFootnoteHeight = allBlockFootnoteIds.length > 0 ? this.measureFootnotesHeight(allBlockFootnoteIds, dims.contentWidth, currentContinuation) : currentContinuation ? this.measureContinuationHeight(currentContinuation, dims.contentWidth) : 0;
-            const newPageSpace = block.marginTopPt + block.heightPt + block.marginBottomPt;
-            currentContent.push(block.element.cloneNode(true));
+            const newPageMarginTop = this.effectiveBlockMarginTop(
+              block,
+              0,
+              true,
+              pageInSection
+            );
+            const newPageSpace = newPageMarginTop + block.heightPt + block.marginBottomPt;
+            currentContent.push(this.cloneBlockForPage(block, true, pageInSection));
             remainingHeight = effectiveContentHeight - newPageSpace;
             prevMarginBottomPt = block.marginBottomPt;
             currentFootnoteIds = [...currentFootnoteIds, ...allBlockFootnoteIds];
@@ -1439,7 +1579,7 @@ var DocxodusEditor = (() => {
           if (currentContent.length > 0) {
             finishPage();
           }
-          currentContent.push(block.element.cloneNode(true));
+          currentContent.push(this.cloneBlockForPage(block, true, pageInSection));
           currentFootnoteIds = [...currentFootnoteIds, ...allBlockFootnoteIds];
           finishPage();
         }
@@ -7969,6 +8109,7 @@ var DocxodusEditor = (() => {
   color: var(--dxr-ink);
   background: var(--dxr-desk);
   -webkit-text-size-adjust: 100%;
+  text-size-adjust: 100%;
 }
 .dxr *, .dxr *::before, .dxr *::after { box-sizing: border-box; }
 

package/dist/embed.bundle.js

@@ -1426,6 +1426,9 @@ function applyZoom(el, scale, naturalPt) {
 }
 
 // src/pagination.ts
+function samePageBox(a, b) {
+  return a.pageWidth === b.pageWidth && a.pageHeight === b.pageHeight && a.marginTop === b.marginTop && a.marginRight === b.marginRight && a.marginBottom === b.marginBottom && a.marginLeft === b.marginLeft;
+}
 var MAX_FOOTNOTE_AREA_RATIO = 0.6;
 var MIN_BODY_CONTENT_HEIGHT = 72;
 var PaginationEngine = class {
@@ -1471,16 +1474,43 @@ var PaginationEngine = class {
     );
     this.pageNumbering = this.parsePageNumbering(sections);
     const sectionsToProcess = sections.length > 0 ? Array.from(sections) : [this.stagingElement];
+    const runs = [];
     for (const section of sectionsToProcess) {
-      const sectionIndex = parseInt(section.dataset.sectionIndex || "0", 10);
       const dims = parseSectionDimensions(section);
+      const previous = runs[runs.length - 1];
+      if (previous && section.dataset.sectionType === "continuous" && samePageBox(previous.dims, dims)) {
+        previous.sections.push(section);
+      } else {
+        runs.push({
+          sections: [section],
+          sectionIndex: parseInt(section.dataset.sectionIndex || "0", 10),
+          dims
+        });
+      }
+    }
+    for (const run of runs) {
       this.stagingElement.style.visibility = "hidden";
       this.stagingElement.style.position = "absolute";
       this.stagingElement.style.left = "-9999px";
       this.stagingElement.style.display = "block";
-      section.style.width = `${dims.contentWidth}pt`;
-      const blocks = this.measureBlocks(section, dims);
-      const sectionPages = this.flowToPages(blocks, dims, pageNumber, sectionIndex);
+      const blocks = [];
+      for (const section of run.sections) {
+        section.style.width = `${run.dims.contentWidth}pt`;
+        const columnCount = parseInt(section.dataset.cols || "1", 10);
+        if (columnCount > 1) {
+          const gap = parseFloat(section.dataset.colGap || "");
+          blocks.push(...this.buildColumnBlocks(
+            section,
+            run.dims,
+            run.sectionIndex,
+            columnCount,
+            Number.isFinite(gap) ? gap : 36
+          ));
+        } else {
+          blocks.push(...this.measureBlocks(section, run.dims));
+        }
+      }
+      const sectionPages = this.flowToPages(blocks, run.dims, pageNumber, run.sectionIndex);
       pages.push(...sectionPages);
       pageNumber += sectionPages.length;
     }
@@ -1569,11 +1599,70 @@ var PaginationEngine = class {
         keepWithNext: child.dataset.keepWithNext === "true",
         keepLines: child.dataset.keepLines === "true",
         pageBreakBefore: child.dataset.pageBreakBefore === "true",
-        isPageBreak
+        isPageBreak,
+        isWordParagraph: this.isWordParagraphElement(child)
       });
     }
     return blocks;
   }
+  /**
+   * Flows a multi-column (`w:cols`) section's children into CSS-multicol container
+   * blocks. Word lays such a section out as N columns inside the same body extent;
+   * a balanced `column-count` container reproduces that geometry, and the paginator
+   * then places each container as one ordinary measured block. A container grows
+   * greedily until its balanced height would exceed the smallest page body available
+   * to the section, so a long columned section still splits across pages at block
+   * boundaries. Each child lands in exactly one container, so anchors never
+   * duplicate. An explicit page break child passes through as its own block, which
+   * ends the current container and lets the normal flow logic turn the page.
+   */
+  buildColumnBlocks(section, dims, sectionIndex, columnCount, columnGapPt) {
+    const children = Array.from(section.children);
+    const blocks = [];
+    const maxFragmentHeight = this.smallestEffectiveContentHeight(dims, sectionIndex);
+    const isBreak = (child) => child.dataset.pageBreak === "true" || child.classList.contains(`${this.cssPrefix}break`);
+    const makeContainer = (slice) => {
+      const container = document.createElement("div");
+      container.style.columnCount = String(columnCount);
+      container.style.columnGap = `${columnGapPt}pt`;
+      for (const child of slice) {
+        container.appendChild(child.cloneNode(true));
+      }
+      return container;
+    };
+    let start2 = 0;
+    while (start2 < children.length) {
+      if (isBreak(children[start2])) {
+        blocks.push(this.measureElement(children[start2], dims));
+        start2++;
+        continue;
+      }
+      let end = start2 + 1;
+      let container = makeContainer(children.slice(start2, end));
+      let measured = this.measureElement(container, dims);
+      while (end < children.length && !isBreak(children[end])) {
+        const candidate = makeContainer(children.slice(start2, end + 1));
+        const candidateMeasured = this.measureElement(candidate, dims);
+        if (candidateMeasured.heightPt > maxFragmentHeight) break;
+        container = candidate;
+        measured = candidateMeasured;
+        end++;
+      }
+      blocks.push({
+        element: container,
+        heightPt: measured.heightPt,
+        marginTopPt: measured.marginTopPt,
+        marginBottomPt: measured.marginBottomPt,
+        keepWithNext: false,
+        keepLines: false,
+        pageBreakBefore: false,
+        isPageBreak: false,
+        isWordParagraph: false
+      });
+      start2 = end;
+    }
+    return blocks;
+  }
   /**
    * Measures one element in the same hidden staging context used for the source blocks.
    * This is intentionally DOM-based: table row heights cannot be inferred from individual
@@ -1598,7 +1687,8 @@ var PaginationEngine = class {
       keepWithNext: element.dataset.keepWithNext === "true",
       keepLines: element.dataset.keepLines === "true",
       pageBreakBefore: element.dataset.pageBreakBefore === "true",
-      isPageBreak: element.dataset.pageBreak === "true" || element.classList.contains(`${this.cssPrefix}break`)
+      isPageBreak: element.dataset.pageBreak === "true" || element.classList.contains(`${this.cssPrefix}break`),
+      isWordParagraph: this.isWordParagraphElement(element)
     };
     this.stagingElement.removeChild(measurementHost);
     return measured;
@@ -1630,10 +1720,15 @@ var PaginationEngine = class {
    * collapsed-margin rules as normal block placement. The trailing margin is
    * intentionally excluded, matching the individual block fit check.
    */
-  measureKeepWithNextChainBodyHeight(chain, previousMarginBottomPt, isFirstOnPage) {
+  measureKeepWithNextChainBodyHeight(chain, previousMarginBottomPt, isFirstOnPage, pageInSection) {
     const firstBlock = chain[0];
     if (!firstBlock) return 0;
-    const firstMarginTop = isFirstOnPage ? firstBlock.marginTopPt : Math.max(firstBlock.marginTopPt, previousMarginBottomPt) - previousMarginBottomPt;
+    const firstMarginTop = this.effectiveBlockMarginTop(
+      firstBlock,
+      previousMarginBottomPt,
+      isFirstOnPage,
+      pageInSection
+    );
     let bodyHeight = firstMarginTop + firstBlock.heightPt;
     for (let index = 1; index < chain.length; index++) {
       const previousBlock = chain[index - 1];
@@ -1642,6 +1737,35 @@ var PaginationEngine = class {
     }
     return bodyHeight;
   }
+  /** Word paragraphs render as `p`, or as `h1`–`h6` when their style has an outline level. */
+  isWordParagraphElement(element) {
+    return element.tagName === "P" || /^H[1-6]$/.test(element.tagName);
+  }
+  shouldSuppressPageTopSpacing(block, isFirstOnPage, pageInSection) {
+    return isFirstOnPage && pageInSection > 1 && block.isWordParagraph === true;
+  }
+  /**
+   * Resolves the part of a block's top margin that consumes the current page.
+   *
+   * In Word's native DOCX layout, paragraph space-before is suppressed when a paragraph is the
+   * first body block on a later page of the SAME section. The first page of a document/section is
+   * the exception and keeps its spacing. Tables and other block margins are not paragraph spacing,
+   * so they continue to use the ordinary CSS collapsing rule.
+   */
+  effectiveBlockMarginTop(block, previousMarginBottomPt, isFirstOnPage, pageInSection) {
+    if (this.shouldSuppressPageTopSpacing(block, isFirstOnPage, pageInSection)) {
+      return 0;
+    }
+    return isFirstOnPage ? block.marginTopPt : Math.max(block.marginTopPt, previousMarginBottomPt) - previousMarginBottomPt;
+  }
+  /** Clone a source block with the same page-top spacing decision used by the height budget. */
+  cloneBlockForPage(block, isFirstOnPage, pageInSection) {
+    const clone = block.element.cloneNode(true);
+    if (this.shouldSuppressPageTopSpacing(block, isFirstOnPage, pageInSection)) {
+      clone.style.setProperty("margin-top", "0", "important");
+    }
+    return clone;
+  }
   /**
    * Finds footnote references introduced by a sequence of blocks, preserving
    * document order and excluding references already assigned to the page.
@@ -2447,7 +2571,8 @@ var PaginationEngine = class {
           const currentChainHeight = this.measureKeepWithNextChainBodyHeight(
             keepChain,
             prevMarginBottomPt,
-            currentContent.length === 0
+            currentContent.length === 0,
+            pageInSection
           ) + additionalChainFootnoteHeight;
           const currentAvailableHeight = remainingHeight - currentFootnoteHeight;
           if (currentChainHeight > currentAvailableHeight) {
@@ -2460,7 +2585,8 @@ var PaginationEngine = class {
             const freshChainBodyHeight = this.measureKeepWithNextChainBodyHeight(
               keepChain,
               0,
-              true
+              true,
+              pageInSection + 1
             );
             const freshChainFootnoteHeight = this.measureFootnotesHeight(
               newChainFootnoteIds,
@@ -2486,10 +2612,12 @@ var PaginationEngine = class {
         additionalFootnoteHeight = totalFootnoteHeight - currentFootnoteHeight;
       }
       const isFirstOnPage = currentContent.length === 0;
-      let effectiveMarginTop = block.marginTopPt;
-      if (!isFirstOnPage) {
-        effectiveMarginTop = Math.max(block.marginTopPt, prevMarginBottomPt) - prevMarginBottomPt;
-      }
+      const effectiveMarginTop = this.effectiveBlockMarginTop(
+        block,
+        prevMarginBottomPt,
+        isFirstOnPage,
+        pageInSection
+      );
       const blockSpace = effectiveMarginTop + block.heightPt + additionalFootnoteHeight;
       const effectiveRemainingHeight = remainingHeight - currentFootnoteHeight;
       const bodyContentUsed = effectiveContentHeight - remainingHeight;
@@ -2509,19 +2637,19 @@ var PaginationEngine = class {
         }
       }
       if (blockSpace <= effectiveRemainingHeight) {
-        currentContent.push(block.element.cloneNode(true));
+        currentContent.push(this.cloneBlockForPage(block, isFirstOnPage, pageInSection));
         remainingHeight -= effectiveMarginTop + block.heightPt + block.marginBottomPt;
         prevMarginBottomPt = block.marginBottomPt;
         if (newFootnoteIds.length > 0) {
           currentFootnoteIds.push(...newFootnoteIds);
           currentFootnoteHeight += additionalFootnoteHeight;
         }
-      } else if (block.heightPt + block.marginTopPt <= effectiveContentHeight) {
+      } else if (block.heightPt + this.effectiveBlockMarginTop(block, 0, true, pageInSection + 1) <= effectiveContentHeight) {
         const blockSpaceWithoutFootnotes = effectiveMarginTop + block.heightPt;
         const minBodySpaceNeeded = bodyContentUsed + blockSpaceWithoutFootnotes + MIN_BODY_CONTENT_HEIGHT;
         const canExpandFootnotes = minBodySpaceNeeded <= effectiveContentHeight;
         if (newFootnoteIds.length > 0 && blockSpaceWithoutFootnotes <= effectiveRemainingHeight) {
-          currentContent.push(block.element.cloneNode(true));
+          currentContent.push(this.cloneBlockForPage(block, isFirstOnPage, pageInSection));
           remainingHeight -= effectiveMarginTop + block.heightPt + block.marginBottomPt;
           prevMarginBottomPt = block.marginBottomPt;
           const availableForFootnotes = Math.min(
@@ -2568,7 +2696,7 @@ var PaginationEngine = class {
           const expandedFootnoteSpace = Math.min(maxFootnoteArea, additionalFootnoteHeight + currentFootnoteHeight);
           const bodySpaceAfterExpansion = effectiveContentHeight - expandedFootnoteSpace;
           if (blockSpaceWithoutFootnotes <= bodySpaceAfterExpansion - bodyContentUsed) {
-            currentContent.push(block.element.cloneNode(true));
+            currentContent.push(this.cloneBlockForPage(block, isFirstOnPage, pageInSection));
             remainingHeight = bodySpaceAfterExpansion - bodyContentUsed - blockSpaceWithoutFootnotes;
             prevMarginBottomPt = block.marginBottomPt;
             currentFootnoteIds.push(...newFootnoteIds);
@@ -2576,8 +2704,14 @@ var PaginationEngine = class {
           } else {
             finishPage();
             const newPageFootnoteHeight = allBlockFootnoteIds.length > 0 ? this.measureFootnotesHeight(allBlockFootnoteIds, dims.contentWidth, currentContinuation) : currentContinuation ? this.measureContinuationHeight(currentContinuation, dims.contentWidth) : 0;
-            const newPageSpace = block.marginTopPt + block.heightPt + block.marginBottomPt;
-            currentContent.push(block.element.cloneNode(true));
+            const newPageMarginTop = this.effectiveBlockMarginTop(
+              block,
+              0,
+              true,
+              pageInSection
+            );
+            const newPageSpace = newPageMarginTop + block.heightPt + block.marginBottomPt;
+            currentContent.push(this.cloneBlockForPage(block, true, pageInSection));
             remainingHeight = effectiveContentHeight - newPageSpace;
             prevMarginBottomPt = block.marginBottomPt;
             currentFootnoteIds = [...currentFootnoteIds, ...allBlockFootnoteIds];
@@ -2586,8 +2720,14 @@ var PaginationEngine = class {
         } else {
           finishPage();
           const newPageFootnoteHeight = allBlockFootnoteIds.length > 0 ? this.measureFootnotesHeight(allBlockFootnoteIds, dims.contentWidth, currentContinuation) : currentContinuation ? this.measureContinuationHeight(currentContinuation, dims.contentWidth) : 0;
-          const newPageSpace = block.marginTopPt + block.heightPt + block.marginBottomPt;
-          currentContent.push(block.element.cloneNode(true));
+          const newPageMarginTop = this.effectiveBlockMarginTop(
+            block,
+            0,
+            true,
+            pageInSection
+          );
+          const newPageSpace = newPageMarginTop + block.heightPt + block.marginBottomPt;
+          currentContent.push(this.cloneBlockForPage(block, true, pageInSection));
           remainingHeight = effectiveContentHeight - newPageSpace;
           prevMarginBottomPt = block.marginBottomPt;
           currentFootnoteIds = [...currentFootnoteIds, ...allBlockFootnoteIds];
@@ -2606,7 +2746,7 @@ var PaginationEngine = class {
         if (currentContent.length > 0) {
           finishPage();
         }
-        currentContent.push(block.element.cloneNode(true));
+        currentContent.push(this.cloneBlockForPage(block, true, pageInSection));
         currentFootnoteIds = [...currentFootnoteIds, ...allBlockFootnoteIds];
         finishPage();
       }
@@ -9136,6 +9276,7 @@ var RIBBON_CSS = `
   color: var(--dxr-ink);
   background: var(--dxr-desk);
   -webkit-text-size-adjust: 100%;
+  text-size-adjust: 100%;
 }
 .dxr *, .dxr *::before, .dxr *::after { box-sizing: border-box; }