docxodus 7.0.1 → 8.0.0

package/dist/pagination.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pagination.d.ts","sourceRoot":"","sources":["../src/pagination.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"pagination.d.ts","sourceRoot":"","sources":["../src/pagination.ts"],"names":[],"mappings":"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"}

package/dist/pagination.js

@@ -82,6 +82,7 @@ export class PaginationEngine {
         this.cssPrefix = options.cssPrefix ?? "page-";
         this.showPageNumbers = options.showPageNumbers ?? true;
         this.pageGap = options.pageGap ?? 20;
+        this.fragmentParagraphs = options.fragmentParagraphs ?? false;
         this.hfRegistry = new Map();
         this.footnoteRegistry = new Map();
     }
@@ -161,6 +162,443 @@ export class PaginationEngine {
         }
         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
+     * rows because wrapping and collapsed borders change the height of a fragment.
+     */
+    measureElement(element, dims) {
+        const measurementHost = document.createElement("div");
+        measurementHost.style.position = "absolute";
+        measurementHost.style.visibility = "hidden";
+        measurementHost.style.left = "-9999px";
+        measurementHost.style.width = `${dims.contentWidth}pt`;
+        const measuredElement = element.cloneNode(true);
+        measurementHost.appendChild(measuredElement);
+        this.stagingElement.appendChild(measurementHost);
+        const rect = measuredElement.getBoundingClientRect();
+        const style = window.getComputedStyle(measuredElement);
+        const measured = {
+            element,
+            heightPt: pxToPt(rect.height),
+            marginTopPt: pxToPt(parseFloat(style.marginTop) || 0),
+            marginBottomPt: pxToPt(parseFloat(style.marginBottom) || 0),
+            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`),
+        };
+        this.stagingElement.removeChild(measurementHost);
+        return measured;
+    }
+    /**
+     * Returns the contiguous keep-with-next chain beginning at a block.
+     *
+     * A hard page break or a page-break-before directive is stronger than a
+     * keep-with-next directive, so it terminates the chain. The caller only
+     * keeps a chain together when the whole chain can fit on a fresh page.
+     */
+    getKeepWithNextChain(blocks, startIndex) {
+        const firstBlock = blocks[startIndex];
+        if (!firstBlock)
+            return [];
+        const chain = [firstBlock];
+        let lastIndex = startIndex;
+        while (blocks[lastIndex].keepWithNext) {
+            const nextBlock = blocks[lastIndex + 1];
+            if (!nextBlock || nextBlock.isPageBreak || nextBlock.pageBreakBefore) {
+                break;
+            }
+            chain.push(nextBlock);
+            lastIndex++;
+        }
+        return chain;
+    }
+    /**
+     * Measures the visible body height of a keep-with-next chain using the same
+     * collapsed-margin rules as normal block placement. The trailing margin is
+     * intentionally excluded, matching the individual block fit check.
+     */
+    measureKeepWithNextChainBodyHeight(chain, previousMarginBottomPt, isFirstOnPage) {
+        const firstBlock = chain[0];
+        if (!firstBlock)
+            return 0;
+        const firstMarginTop = isFirstOnPage
+            ? firstBlock.marginTopPt
+            : Math.max(firstBlock.marginTopPt, previousMarginBottomPt) - previousMarginBottomPt;
+        let bodyHeight = firstMarginTop + firstBlock.heightPt;
+        for (let index = 1; index < chain.length; index++) {
+            const previousBlock = chain[index - 1];
+            const block = chain[index];
+            bodyHeight += Math.max(previousBlock.marginBottomPt, block.marginTopPt) + block.heightPt;
+        }
+        return bodyHeight;
+    }
+    /**
+     * Finds footnote references introduced by a sequence of blocks, preserving
+     * document order and excluding references already assigned to the page.
+     */
+    collectNewFootnoteIds(blocks, existingFootnoteIds) {
+        const knownIds = new Set(existingFootnoteIds);
+        const newIds = [];
+        for (const block of blocks) {
+            for (const id of this.extractFootnoteRefs(block.element)) {
+                if (!knownIds.has(id)) {
+                    knownIds.add(id);
+                    newIds.push(id);
+                }
+            }
+        }
+        return newIds;
+    }
+    /**
+     * The shortest body available to a section's first, default, or even page.
+     * A row fragment must fit every variant, otherwise a later header/footer could
+     * send it through the oversized-block fallback again.
+     */
+    smallestEffectiveContentHeight(dims, sectionIndex) {
+        return Math.min(this.getEffectiveHeights(dims, sectionIndex, 1, 1).contentHeight, this.getEffectiveHeights(dims, sectionIndex, 2, 1).contentHeight, this.getEffectiveHeights(dims, sectionIndex, 2, 2).contentHeight);
+    }
+    /**
+     * Builds a clone of a simple table wrapper containing a contiguous run of rows.
+     * Complex table features are deliberately rejected by the caller: a split across
+     * merged cells, nested tables, or footnotes cannot be made correct by cloning rows.
+     */
+    createSimpleTableFragment(wrapper, table, body, rows, retainAnchor) {
+        const wrapperClone = wrapper.cloneNode(false);
+        const tableClone = table.cloneNode(false);
+        // The eligibility gate permits only colgroups alongside the body. Keep each
+        // colgroup so fixed and proportional column widths remain stable per fragment.
+        for (const child of Array.from(table.children)) {
+            if (child !== body) {
+                tableClone.appendChild(child.cloneNode(true));
+            }
+        }
+        const bodyClone = body.cloneNode(false);
+        for (const row of rows) {
+            bodyClone.appendChild(row.cloneNode(true));
+        }
+        tableClone.appendChild(bodyClone);
+        if (!retainAnchor) {
+            wrapperClone.removeAttribute("data-anchor");
+            tableClone.removeAttribute("data-anchor");
+        }
+        wrapperClone.appendChild(tableClone);
+        return wrapperClone;
+    }
+    /**
+     * Splits an oversized, ordinary table at row boundaries. This only participates
+     * in the existing oversized-block fallback; unsupported tables keep the previous
+     * overflow behavior rather than risking broken table semantics.
+     */
+    trySplitSimpleOversizedTable(block, dims, sectionIndex) {
+        const wrapper = block.element;
+        if (wrapper.tagName !== "DIV" ||
+            wrapper.children.length !== 1 ||
+            block.keepWithNext ||
+            block.keepLines ||
+            block.pageBreakBefore ||
+            block.isPageBreak) {
+            return null;
+        }
+        const table = wrapper.firstElementChild;
+        if (!(table instanceof HTMLTableElement)) {
+            return null;
+        }
+        const body = table.tBodies.length === 1 ? table.tBodies[0] : null;
+        if (!body ||
+            table.tHead ||
+            table.tFoot ||
+            body.rows.length < 2 ||
+            Array.from(table.children).some(child => child !== body && child.tagName !== "COLGROUP") ||
+            table.querySelector("table, [rowspan], [colspan], [data-footnote-id]") ||
+            wrapper.querySelector("[data-footnote-id]")) {
+            return null;
+        }
+        const rows = Array.from(body.rows);
+        const minimumContentHeight = this.smallestEffectiveContentHeight(dims, sectionIndex);
+        // Use the source's full vertical margins while forming groups. Continuation
+        // fragments later clear their joining margins, so this conservative bound
+        // cannot create a fragment that overflows a header/footer variant.
+        const maximumFragmentHeight = minimumContentHeight - block.marginTopPt - block.marginBottomPt;
+        if (maximumFragmentHeight <= 0) {
+            return null;
+        }
+        const groups = [];
+        let start = 0;
+        while (start < rows.length) {
+            let end = start;
+            while (end < rows.length) {
+                const candidate = this.createSimpleTableFragment(wrapper, table, body, rows.slice(start, end + 1), start === 0);
+                const measured = this.measureElement(candidate, dims);
+                if (measured.heightPt > maximumFragmentHeight) {
+                    break;
+                }
+                end++;
+            }
+            // Even a one-row fragment cannot fit. Preserve the established overflow
+            // fallback rather than looping or clipping a partially split row.
+            if (end === start) {
+                return null;
+            }
+            groups.push(rows.slice(start, end));
+            start = end;
+        }
+        if (groups.length < 2) {
+            return null;
+        }
+        const fragments = [];
+        for (let index = 0; index < groups.length; index++) {
+            const isFirst = index === 0;
+            const isLast = index === groups.length - 1;
+            const fragment = this.createSimpleTableFragment(wrapper, table, body, groups[index], isFirst);
+            // Keep the source's outer spacing only at the table's real boundaries.
+            // Continuation margins would otherwise add blank space at the top/bottom
+            // of every paginated fragment.
+            if (!isFirst) {
+                fragment.style.setProperty("margin-top", "0", "important");
+            }
+            if (!isLast) {
+                fragment.style.setProperty("margin-bottom", "0", "important");
+            }
+            const measured = this.measureElement(fragment, dims);
+            if (measured.heightPt + measured.marginTopPt + measured.marginBottomPt >
+                minimumContentHeight) {
+                return null;
+            }
+            fragments.push({
+                ...measured,
+                keepWithNext: false,
+                keepLines: false,
+                pageBreakBefore: false,
+                isPageBreak: false,
+            });
+        }
+        return fragments;
+    }
+    /**
+     * A DOM endpoint that can finish a paragraph fragment. Endpoints are chosen
+     * after whitespace or at a run boundary so the paginator never deliberately
+     * cuts through an ordinary word merely to fill a little more of a page.
+     */
+    paragraphFragmentEndpoints(paragraph) {
+        const endpoints = [];
+        const walker = document.createTreeWalker(paragraph, NodeFilter.SHOW_TEXT);
+        let textNode;
+        while ((textNode = walker.nextNode())) {
+            const text = textNode.data;
+            if (text.length === 0)
+                continue;
+            // A whitespace boundary preserves normal word wrapping. Always retain the
+            // end of a run too: adjacent runs can change formatting without containing
+            // a whitespace character between them.
+            const whitespace = /\s+/g;
+            let match;
+            while ((match = whitespace.exec(text)) !== null) {
+                endpoints.push({ node: textNode, offset: match.index + match[0].length });
+            }
+            if (endpoints.length === 0 || endpoints[endpoints.length - 1].node !== textNode ||
+                endpoints[endpoints.length - 1].offset !== text.length) {
+                endpoints.push({ node: textNode, offset: text.length });
+            }
+        }
+        return endpoints;
+    }
+    /**
+     * Whether a range contains visible text after ignoring bidi/zero-width marks.
+     * Paragraph fragmentation deliberately excludes non-textual descendants, so
+     * this is enough to reject empty head or tail fragments.
+     */
+    hasVisibleFragmentText(fragment) {
+        return (fragment.textContent || "")
+            .replace(/[\u200B-\u200F\uFEFF]/g, "")
+            .trim()
+            .length > 0;
+    }
+    /**
+     * Phase one only handles text-like paragraph descendants. Objects, explicit
+     * line breaks, list markers, notes, and out-of-flow/inline-block content all
+     * require their own line-layout rules and retain the established whole-block
+     * fallback instead of risking broken content or duplicate anchors.
+     */
+    canFragmentParagraph(block) {
+        if (!this.fragmentParagraphs || block.element.tagName !== "P") {
+            return false;
+        }
+        const paragraph = block.element;
+        if (block.keepWithNext ||
+            block.keepLines ||
+            block.pageBreakBefore ||
+            block.isPageBreak ||
+            paragraph.dataset.widowControl === "true" ||
+            paragraph.hasAttribute("contenteditable")) {
+            return false;
+        }
+        // The outer paragraph may carry its source identity. Descendant identities
+        // are not safe to duplicate in a continuation fragment, so reject them.
+        const unsupportedDescendants = [
+            "br",
+            "img",
+            "picture",
+            "svg",
+            "math",
+            "canvas",
+            "video",
+            "audio",
+            "iframe",
+            "object",
+            "embed",
+            "input",
+            "button",
+            "select",
+            "textarea",
+            "table",
+            "ol",
+            "ul",
+            "li",
+            "dl",
+            "div",
+            "p",
+            "section",
+            "article",
+            "aside",
+            "figure",
+            "fieldset",
+            "details",
+            "[data-footnote-id]",
+            "[data-list-marker]",
+            "[data-anchor]",
+            "[id]",
+            "[contenteditable]",
+        ].join(", ");
+        if (paragraph.querySelector(unsupportedDescendants)) {
+            return false;
+        }
+        const paragraphStyle = window.getComputedStyle(paragraph);
+        if (paragraphStyle.display !== "block" ||
+            paragraphStyle.position !== "static" ||
+            paragraphStyle.float !== "none" ||
+            paragraphStyle.whiteSpace !== "normal" ||
+            paragraphStyle.breakBefore !== "auto" ||
+            paragraphStyle.breakAfter !== "auto" ||
+            paragraphStyle.breakInside === "avoid" ||
+            paragraphStyle.pageBreakBefore !== "auto" ||
+            paragraphStyle.pageBreakAfter !== "auto" ||
+            paragraphStyle.pageBreakInside === "avoid") {
+            return false;
+        }
+        // A range clone preserves nested inline formatting exactly. Anything that
+        // establishes its own box/layout context is intentionally deferred until a
+        // future fragmenter can model it accurately.
+        for (const descendant of Array.from(paragraph.querySelectorAll("*"))) {
+            const style = window.getComputedStyle(descendant);
+            if (style.display !== "inline" ||
+                style.position !== "static" ||
+                style.float !== "none" ||
+                style.whiteSpace !== "normal") {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Builds one range-cloned paragraph fragment. Only the leading fragment keeps
+     * the source paragraph's addressability; continuations must not duplicate an
+     * id/data-anchor in the rendered document.
+     */
+    createParagraphFragment(paragraph, range, retainSourceIdentity, isFinalFragment) {
+        const fragment = paragraph.cloneNode(false);
+        const contents = range.cloneContents();
+        fragment.appendChild(contents);
+        if (!retainSourceIdentity) {
+            fragment.removeAttribute("id");
+            fragment.removeAttribute("data-anchor");
+            // A continuation starts with a normal line rather than repeating a first-
+            // line/hanging indent. Keep the side margin so paragraph alignment remains.
+            fragment.style.setProperty("margin-top", "0", "important");
+            fragment.style.setProperty("text-indent", "0", "important");
+        }
+        if (!isFinalFragment) {
+            // The original bottom spacing belongs after the complete paragraph, not
+            // between synthetic page fragments.
+            fragment.style.setProperty("margin-bottom", "0", "important");
+        }
+        return fragment;
+    }
+    /**
+     * Splits a simple paragraph at the largest DOM Range endpoint that fits the
+     * currently available body space. The caller then processes the tail normally,
+     * allowing it to fragment again on later pages when necessary.
+     */
+    tryFragmentParagraph(block, dims, availableHeightPt, effectiveMarginTopPt) {
+        if (!this.canFragmentParagraph(block) || availableHeightPt <= effectiveMarginTopPt) {
+            return null;
+        }
+        const paragraph = block.element;
+        const endpoints = this.paragraphFragmentEndpoints(paragraph);
+        // The final endpoint is the full paragraph and cannot leave a tail. A
+        // single text run with no earlier whitespace remains an overflow fallback.
+        if (endpoints.length < 2) {
+            return null;
+        }
+        let low = 0;
+        let high = endpoints.length - 2;
+        let best = null;
+        // Fragment height is monotonic for the deliberately narrow eligible subset,
+        // so binary search avoids measuring every word in long body paragraphs.
+        while (low <= high) {
+            const middle = Math.floor((low + high) / 2);
+            const endpoint = endpoints[middle];
+            const headRange = document.createRange();
+            headRange.setStart(paragraph, 0);
+            headRange.setEnd(endpoint.node, endpoint.offset);
+            const headContents = headRange.cloneContents();
+            if (!this.hasVisibleFragmentText(headContents)) {
+                low = middle + 1;
+                continue;
+            }
+            const head = this.createParagraphFragment(paragraph, headRange, true, false);
+            const measured = this.measureElement(head, dims);
+            if (effectiveMarginTopPt + measured.heightPt <= availableHeightPt) {
+                best = { endpoint, element: head, measured };
+                low = middle + 1;
+            }
+            else {
+                high = middle - 1;
+            }
+        }
+        if (!best) {
+            return null;
+        }
+        const tailRange = document.createRange();
+        tailRange.setStart(best.endpoint.node, best.endpoint.offset);
+        tailRange.setEnd(paragraph, paragraph.childNodes.length);
+        const tailContents = tailRange.cloneContents();
+        if (!this.hasVisibleFragmentText(tailContents)) {
+            return null;
+        }
+        const tail = this.createParagraphFragment(paragraph, tailRange, false, true);
+        const tailMeasured = this.measureElement(tail, dims);
+        return [
+            {
+                ...best.measured,
+                element: best.element,
+                keepWithNext: false,
+                keepLines: false,
+                pageBreakBefore: false,
+                isPageBreak: false,
+            },
+            {
+                ...tailMeasured,
+                element: tail,
+                keepWithNext: false,
+                keepLines: false,
+                pageBreakBefore: false,
+                isPageBreak: false,
+            },
+        ];
+    }
     /**
      * Parses the header/footer registry from the staging element.
      * Also measures heights during parsing for lazy-loading compatibility.
@@ -625,7 +1063,8 @@ export class PaginationEngine {
             currentFootnoteHeight = this.measureContinuationHeight(currentContinuation, dims.contentWidth);
         }
         const finishPage = () => {
-            if (currentContent.length === 0 && !currentContinuation)
+            const hasCurrentContinuation = (currentContinuation?.remainingElements.length ?? 0) > 0;
+            if (currentContent.length === 0 && !hasCurrentContinuation)
                 return;
             const page = this.createPage(dims, pageNumber, sectionIndex, currentContent, pageInSection, currentFootnoteIds, currentFootnoteHeight, currentContinuation, currentPartialFootnotes.length > 0 ? currentPartialFootnotes : undefined);
             pages.push(page);
@@ -652,7 +1091,6 @@ export class PaginationEngine {
         };
         for (let i = 0; i < blocks.length; i++) {
             const block = blocks[i];
-            const nextBlock = blocks[i + 1];
             // Handle explicit page breaks
             if (block.isPageBreak) {
                 finishPage();
@@ -662,10 +1100,50 @@ export class PaginationEngine {
             if (block.pageBreakBefore && currentContent.length > 0) {
                 finishPage();
             }
+            // A series of keep-with-next blocks is one indivisible placement unit
+            // when it can fit a new page. The former one-block lookahead was never
+            // applied to the placement decision, and it could not preserve a chain of
+            // headings/paragraphs. Do not force an oversized chain to a fresh page:
+            // its members retain the established greedy/overflow behavior instead.
+            const previousBlock = blocks[i - 1];
+            const startsKeepChain = !previousBlock ||
+                !previousBlock.keepWithNext ||
+                previousBlock.isPageBreak ||
+                block.pageBreakBefore;
+            // A footnote continuation also occupies this page even when its body has
+            // no blocks yet. In that case a feasible chain may need to move past the
+            // continuation as a unit.
+            const pageHasOccupiedSpace = currentContent.length > 0 || currentFootnoteHeight > 0;
+            if (pageHasOccupiedSpace && block.keepWithNext && startsKeepChain) {
+                const keepChain = this.getKeepWithNextChain(blocks, i);
+                if (keepChain.length > 1) {
+                    const newChainFootnoteIds = this.collectNewFootnoteIds(keepChain, currentFootnoteIds);
+                    let additionalChainFootnoteHeight = 0;
+                    if (newChainFootnoteIds.length > 0 && this.footnoteRegistry.size > 0) {
+                        const totalChainFootnoteHeight = this.measureFootnotesHeight([...currentFootnoteIds, ...newChainFootnoteIds], dims.contentWidth, currentContinuation);
+                        additionalChainFootnoteHeight = Math.max(0, totalChainFootnoteHeight - currentFootnoteHeight);
+                    }
+                    const currentChainHeight = this.measureKeepWithNextChainBodyHeight(keepChain, prevMarginBottomPt, currentContent.length === 0) +
+                        additionalChainFootnoteHeight;
+                    const currentAvailableHeight = remainingHeight - currentFootnoteHeight;
+                    if (currentChainHeight > currentAvailableHeight) {
+                        const nextPageHeights = this.getEffectiveHeights(dims, sectionIndex, pageInSection + 1, pageNumber + 1);
+                        const freshChainBodyHeight = this.measureKeepWithNextChainBodyHeight(keepChain, 0, true);
+                        // finishPage transfers this continuation to the new page's
+                        // currentContinuation state, so include it in the destination
+                        // page's footnote reservation before deciding to move the chain.
+                        const freshChainFootnoteHeight = this.measureFootnotesHeight(newChainFootnoteIds, dims.contentWidth, nextPageContinuation);
+                        if (freshChainBodyHeight + freshChainFootnoteHeight <=
+                            nextPageHeights.contentHeight) {
+                            finishPage();
+                        }
+                    }
+                }
+            }
             // Extract footnote references from this block
-            const blockFootnoteIds = this.extractFootnoteRefs(block.element);
+            const allBlockFootnoteIds = this.extractFootnoteRefs(block.element);
             // Only count new footnotes (not already on this page)
-            const newFootnoteIds = blockFootnoteIds.filter(id => !currentFootnoteIds.includes(id));
+            const newFootnoteIds = this.collectNewFootnoteIds([block], currentFootnoteIds);
             // Calculate additional footnote height if this block is added
             let additionalFootnoteHeight = 0;
             if (newFootnoteIds.length > 0 && this.footnoteRegistry.size > 0) {
@@ -688,20 +1166,24 @@ export class PaginationEngine {
             // bottom margin extends beyond the content area and is clipped by overflow:hidden.
             // It is still tracked in remainingHeight for correct margin collapsing with the next block.
             const blockSpace = effectiveMarginTop + block.heightPt + additionalFootnoteHeight;
-            // Calculate needed height (including keepWithNext)
-            let neededHeight = blockSpace;
-            if (block.keepWithNext && nextBlock && !nextBlock.isPageBreak) {
-                // For keepWithNext, include the next block with collapsed margins
-                const collapsedMargin = Math.max(block.marginBottomPt, nextBlock.marginTopPt);
-                neededHeight = effectiveMarginTop + block.heightPt + collapsedMargin +
-                    nextBlock.heightPt + additionalFootnoteHeight;
-            }
             // Effective remaining height (content area minus footnotes already on page)
             const effectiveRemainingHeight = remainingHeight - currentFootnoteHeight;
             // Calculate maximum footnote area for this page (can expand into body content space)
             const bodyContentUsed = effectiveContentHeight - remainingHeight;
             const maxFootnoteArea = effectiveContentHeight * MAX_FOOTNOTE_AREA_RATIO;
             const maxFootnoteExpansion = Math.max(0, maxFootnoteArea - currentFootnoteHeight);
+            // A paragraph that cannot fit as a whole may still have a simple text-only
+            // prefix that fits this page. Fragment before the ordinary next-page or
+            // oversized fallback so the cloned head participates in the same margin
+            // and footnote accounting as every other block.
+            if (blockSpace > effectiveRemainingHeight) {
+                const paragraphFragments = this.tryFragmentParagraph(block, dims, effectiveRemainingHeight, effectiveMarginTop);
+                if (paragraphFragments) {
+                    blocks.splice(i, 1, ...paragraphFragments);
+                    i--;
+                    continue;
+                }
+            }
             // Check if block fits on current page (including its footnotes)
             if (blockSpace <= effectiveRemainingHeight) {
                 // Block fits with current footnote allocation
@@ -752,10 +1234,12 @@ export class PaginationEngine {
                                         footnoteId,
                                         fittingElements: fits
                                     });
-                                    nextPageContinuation = {
-                                        footnoteId,
-                                        remainingElements: overflow
-                                    };
+                                    if (overflow.length > 0) {
+                                        nextPageContinuation = {
+                                            footnoteId,
+                                            remainingElements: overflow
+                                        };
+                                    }
                                     currentFootnoteHeight = availableForFootnotes;
                                 }
                                 else {
@@ -802,14 +1286,14 @@ export class PaginationEngine {
                     else {
                         // Still doesn't fit - start new page
                         finishPage();
-                        const newPageFootnoteHeight = blockFootnoteIds.length > 0
-                            ? this.measureFootnotesHeight(blockFootnoteIds, dims.contentWidth, currentContinuation)
+                        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));
                         remainingHeight = effectiveContentHeight - newPageSpace;
                         prevMarginBottomPt = block.marginBottomPt;
-                        currentFootnoteIds = [...blockFootnoteIds];
+                        currentFootnoteIds = [...allBlockFootnoteIds];
                         currentFootnoteHeight = newPageFootnoteHeight;
                     }
                 }
@@ -818,26 +1302,38 @@ export class PaginationEngine {
                     finishPage();
                     // On new page, recalculate footnote height for just this block's footnotes
                     // (plus any continuation from previous page)
-                    const newPageFootnoteHeight = blockFootnoteIds.length > 0
-                        ? this.measureFootnotesHeight(blockFootnoteIds, dims.contentWidth, currentContinuation)
+                    const newPageFootnoteHeight = allBlockFootnoteIds.length > 0
+                        ? this.measureFootnotesHeight(allBlockFootnoteIds, dims.contentWidth, currentContinuation)
                         : (currentContinuation ? this.measureContinuationHeight(currentContinuation, dims.contentWidth) : 0);
                     // Include full top margin
                     const newPageSpace = block.marginTopPt + block.heightPt + block.marginBottomPt;
                     currentContent.push(block.element.cloneNode(true));
                     remainingHeight = effectiveContentHeight - newPageSpace;
                     prevMarginBottomPt = block.marginBottomPt;
-                    currentFootnoteIds = [...blockFootnoteIds];
+                    currentFootnoteIds = [...allBlockFootnoteIds];
                     currentFootnoteHeight = newPageFootnoteHeight;
                 }
             }
             else {
-                // Block is taller than a page - add it and let it overflow
-                // (In a more sophisticated implementation, we would split the block)
+                // Block is taller than a page. Ordinary tables can be split at complete
+                // row boundaries; every other block retains the established overflow path.
+                const tableFragments = this.trySplitSimpleOversizedTable(block, dims, sectionIndex);
+                if (tableFragments) {
+                    if (currentContent.length > 0 || currentContinuation) {
+                        finishPage();
+                    }
+                    blocks.splice(i, 1, ...tableFragments);
+                    i--;
+                    continue;
+                }
+                // Unsupported oversized blocks are intentionally left intact. Splitting
+                // arbitrary HTML, merged tables, or footnote-bearing tables would be less
+                // correct than the prior clipped fallback.
                 if (currentContent.length > 0) {
                     finishPage();
                 }
                 currentContent.push(block.element.cloneNode(true));
-                currentFootnoteIds = [...blockFootnoteIds];
+                currentFootnoteIds = [...allBlockFootnoteIds];
                 finishPage();
             }
         }
@@ -1014,7 +1510,13 @@ export function paginateHtml(html, container, options = {}) {
     if (!pageContainer) {
         throw new Error("Pagination container element not found");
     }
-    const engine = new PaginationEngine(staging, pageContainer, options);
+    // This convenience function is the read-only HTML viewer path. Keep the
+    // lower-level engine conservative by default, while enabling paragraph
+    // fragmentation here unless a caller deliberately opts out.
+    const engine = new PaginationEngine(staging, pageContainer, {
+        ...options,
+        fragmentParagraphs: options.fragmentParagraphs ?? true,
+    });
     return engine.paginate();
 }
 //# sourceMappingURL=pagination.js.map