oasis-editor 0.0.63 → 0.0.65

package/dist/{index-BNRIgieX.js → index-DhCqxHGZ.js}

@@ -2483,7 +2483,7 @@ function OasisEditorAppLazy(props = {}) {
     onCleanup(() => {
       cancelled = true;
     });
-    import("./OasisEditorApp-BG3tA5Y-.js").then((m) => {
+    import("./OasisEditorApp-Bp4TNPC7.js").then((m) => {
       cancelled = true;
       setProgress(1);
       setTimeout(() => setApp(() => m.OasisEditorApp), 180);
@@ -4542,12 +4542,8 @@ function createEditorCommandBus(editor) {
       return editor.commands.canExecute(resolved.name, resolved.payload);
     },
     state(command) {
-      var _a;
       const resolved = resolveCommandRef(command);
-      const registered = editor.commands.get(resolved.name);
-      return ((_a = registered == null ? void 0 : registered.refresh) == null ? void 0 : _a.call(registered, resolved.payload)) ?? {
-        isEnabled: editor.commands.has(resolved.name)
-      };
+      return editor.commands.state(resolved.name, resolved.payload);
     }
   };
 }
@@ -12758,6 +12754,422 @@ function projectHeaderFooterBlocks(blocks, pageIndex, totalPages, measuredHeight
     defaultTabStop
   );
 }
+const MAX_COLUMN_BALANCE_ITERATIONS = 100;
+function projectColumnedBlocksLayout(context2, count, runTrackLayout) {
+  var _a, _b;
+  const { pageSettings, maxPageHeight, pageOffset = 0, existingPages = [] } = context2;
+  const colWidth = ((_a = getPageColumnRects(pageSettings)[0]) == null ? void 0 : _a.width) ?? getPageContentWidth(pageSettings);
+  const runTracks = (blocks, trackHeight) => runTrackLayout({
+    ...context2,
+    blocks,
+    maxPageHeight: trackHeight,
+    contentWidthOverride: colWidth,
+    pageOffset: 0,
+    existingPages: [],
+    reservedHeightByPageIndex: void 0
+  });
+  let tracks = runTracks(context2.blocks, maxPageHeight);
+  if (tracks.length > 1 || tracks.length === 1 && count > 1) {
+    const trailingStart = Math.floor((tracks.length - 1) / count) * count;
+    const trailingTracks = tracks.slice(trailingStart);
+    const firstTrailingBlock = (_b = trailingTracks[0]) == null ? void 0 : _b.blocks[0];
+    const prevTrack = trailingStart > 0 ? tracks[trailingStart - 1] : void 0;
+    const prevLastBlock = prevTrack == null ? void 0 : prevTrack.blocks[prevTrack.blocks.length - 1];
+    const cleanBoundary = firstTrailingBlock != null && (prevLastBlock == null || prevLastBlock.globalIndex !== firstTrailingBlock.globalIndex);
+    if (cleanBoundary) {
+      const startIndex = firstTrailingBlock.globalIndex;
+      const sourceSubset = context2.blocks.slice(startIndex);
+      const sumHeight = trailingTracks.reduce(
+        (sum, track) => sum + track.height,
+        0
+      );
+      let target = Math.max(24, Math.ceil(sumHeight / count));
+      let balanced = runTracks(sourceSubset, target);
+      for (let iteration = 0; balanced.length > count && target < maxPageHeight && iteration < MAX_COLUMN_BALANCE_ITERATIONS; iteration += 1) {
+        target = Math.min(maxPageHeight, Math.ceil(target * 1.05) + 4);
+        balanced = runTracks(sourceSubset, target);
+      }
+      if (balanced.length <= count) {
+        tracks = [...tracks.slice(0, trailingStart), ...balanced];
+      }
+    }
+  }
+  const pages = [...existingPages];
+  const startPageIndex = existingPages.length > 0 ? existingPages[existingPages.length - 1].index + 1 : pageOffset;
+  const physicalPageCount = Math.ceil(tracks.length / count);
+  for (let p = 0; p < physicalPageCount; p += 1) {
+    const pageIndex = startPageIndex + p;
+    const pageTracks = tracks.slice(p * count, p * count + count);
+    const blocks = [];
+    let height = 0;
+    pageTracks.forEach((track, columnIndex) => {
+      for (const block of track.blocks) {
+        block.columnIndex = columnIndex;
+        blocks.push(block);
+      }
+      height = Math.max(height, track.height);
+    });
+    pages.push({
+      id: `page:${pageIndex + 1}`,
+      index: pageIndex,
+      height,
+      maxHeight: maxPageHeight,
+      blocks,
+      pageSettings
+    });
+  }
+  if (pages.length === 0) {
+    pages.push({
+      id: `page:${startPageIndex + 1}`,
+      index: startPageIndex,
+      height: 0,
+      maxHeight: maxPageHeight,
+      blocks: [],
+      pageSettings
+    });
+  }
+  return pages;
+}
+class PaginationTrack {
+  constructor(pageOffset, maxPageHeight, reservedHeightByPageIndex, pageSettings, existingPages) {
+    __publicField(this, "pages");
+    __publicField(this, "blocks");
+    __publicField(this, "height");
+    this.pageOffset = pageOffset;
+    this.maxPageHeight = maxPageHeight;
+    this.reservedHeightByPageIndex = reservedHeightByPageIndex;
+    this.pageSettings = pageSettings;
+    this.pages = [...existingPages];
+    const currentPage = this.pages[this.pages.length - 1];
+    this.blocks = currentPage ? [...currentPage.blocks] : [];
+    this.height = currentPage ? currentPage.height : 0;
+    if (currentPage) {
+      this.pages.pop();
+    }
+  }
+  /** Index of the track currently being filled. */
+  get pageIndex() {
+    return this.pageOffset + this.pages.length;
+  }
+  /** Usable height of a given page, net of any reserved (e.g. footnote) space. */
+  maxHeightForPage(pageIndex) {
+    var _a;
+    return Math.max(
+      24,
+      this.maxPageHeight - (((_a = this.reservedHeightByPageIndex) == null ? void 0 : _a.get(pageIndex)) ?? 0)
+    );
+  }
+  /** Usable height of the track currently being filled. */
+  get currentMaxHeight() {
+    return this.maxHeightForPage(this.pageIndex);
+  }
+  /** Seals the current track into a page and starts a fresh, empty track. */
+  flush() {
+    if (this.blocks.length === 0 && this.pages.length > 0) {
+      return;
+    }
+    const pageIndex = this.pageIndex;
+    this.pages.push({
+      id: `page:${pageIndex + 1}`,
+      index: pageIndex,
+      height: this.height,
+      maxHeight: this.maxHeightForPage(pageIndex),
+      blocks: this.blocks,
+      pageSettings: this.pageSettings
+    });
+    this.blocks = [];
+    this.height = 0;
+  }
+  /** Flushes the trailing track and guarantees at least one page exists. */
+  finalize() {
+    this.flush();
+    if (this.pages.length === 0) {
+      const pageIndex = this.pageOffset;
+      this.pages.push({
+        id: `page:${pageIndex + 1}`,
+        index: pageIndex,
+        height: 0,
+        maxHeight: this.maxHeightForPage(pageIndex),
+        blocks: [],
+        pageSettings: this.pageSettings
+      });
+    }
+    return this.pages;
+  }
+}
+const TEXT_BOX_AUTOFIT_SAFETY_PX$1 = 2;
+function estimateTextBoxAutoFitHeight(textBox, styles, measurer, pageIndex, totalPages, defaultTabStop) {
+  var _a, _b, _c, _d, _e;
+  if (!((_a = textBox.body) == null ? void 0 : _a.autoFit)) {
+    return textBox.height;
+  }
+  const padding = {
+    left: ((_b = textBox.body) == null ? void 0 : _b.paddingLeft) ?? 0,
+    top: ((_c = textBox.body) == null ? void 0 : _c.paddingTop) ?? 0,
+    right: ((_d = textBox.body) == null ? void 0 : _d.paddingRight) ?? 0,
+    bottom: ((_e = textBox.body) == null ? void 0 : _e.paddingBottom) ?? 0
+  };
+  const innerWidth = Math.max(1, textBox.width - padding.left - padding.right);
+  const contentHeight = textBox.blocks.reduce((sum, block) => {
+    if (block.type === "paragraph") {
+      const layout = projectParagraphLayout(
+        block,
+        pageIndex,
+        totalPages,
+        styles,
+        innerWidth,
+        measurer,
+        defaultTabStop
+      );
+      return sum + getProjectedParagraphBlockHeight(block, layout, styles);
+    }
+    if (block.type === "table") {
+      return sum + estimateTableBlockHeight(
+        block,
+        styles,
+        innerWidth,
+        measurer,
+        defaultTabStop
+      );
+    }
+    return sum;
+  }, 0);
+  return Math.max(
+    1,
+    Math.ceil(
+      contentHeight + padding.top + padding.bottom + TEXT_BOX_AUTOFIT_SAFETY_PX$1
+    )
+  );
+}
+function paginateParagraphBlock(track, params, sourceBlock, nextBlock, index) {
+  var _a;
+  const {
+    pageSettings,
+    contentWidth,
+    measurer,
+    styles,
+    totalPages,
+    defaultTabStop,
+    measuredHeights,
+    measuredParagraphLayouts
+  } = params;
+  const pageIndex = track.pageIndex;
+  const projectedParagraphLayout = projectParagraphLayoutWithExclusions(
+    sourceBlock,
+    pageSettings,
+    contentWidth,
+    measurer,
+    pageIndex,
+    totalPages,
+    styles,
+    defaultTabStop,
+    (textBox) => estimateTextBoxAutoFitHeight(
+      textBox,
+      styles,
+      measurer,
+      pageIndex,
+      totalPages,
+      defaultTabStop
+    )
+  );
+  const measuredParagraphLayout = measuredParagraphLayouts == null ? void 0 : measuredParagraphLayouts[sourceBlock.id];
+  const paragraphLayout = measuredParagraphLayout && isMeasuredLayoutCurrent(projectedParagraphLayout, measuredParagraphLayout) ? applyMeasuredLineGeometry(
+    projectedParagraphLayout,
+    measuredParagraphLayout
+  ) : projectedParagraphLayout;
+  let collapseWithPrevious = false;
+  let contextualAdjustedPreviousBlock;
+  let contextualAdjustedAmount = 0;
+  let paragraphTotalHeight = (measuredHeights == null ? void 0 : measuredHeights[sourceBlock.id]) ?? getProjectedParagraphBlockHeight(sourceBlock, paragraphLayout, styles);
+  const paragraphStyle = getEffectiveParagraphStyle(sourceBlock, styles);
+  const nextBlockHeight = (nextBlock == null ? void 0 : nextBlock.type) === "paragraph" ? (measuredHeights == null ? void 0 : measuredHeights[nextBlock.id]) ?? estimateParagraphBlockHeight(
+    nextBlock,
+    styles,
+    contentWidth,
+    measurer,
+    {
+      allowSpacingBefore: !shouldCollapseContextualSpacing(
+        sourceBlock,
+        nextBlock,
+        styles
+      )
+    },
+    defaultTabStop
+  ) : nextBlock ? (measuredHeights == null ? void 0 : measuredHeights[nextBlock.id]) ?? estimateTableBlockHeight(
+    nextBlock,
+    styles,
+    contentWidth,
+    measurer,
+    defaultTabStop
+  ) : 0;
+  if (paragraphStyle.keepWithNext && track.blocks.length > 0 && track.height + paragraphTotalHeight + nextBlockHeight > track.currentMaxHeight && paragraphTotalHeight + nextBlockHeight <= track.currentMaxHeight) {
+    track.flush();
+  }
+  const previousBlock = track.blocks.at(-1);
+  const previousParagraph = (previousBlock == null ? void 0 : previousBlock.blockType) === "paragraph" && ((_a = previousBlock.sourceBlock) == null ? void 0 : _a.type) === "paragraph" ? previousBlock.sourceBlock : void 0;
+  collapseWithPrevious = track.blocks.length > 0 && shouldCollapseContextualSpacing(previousParagraph, sourceBlock, styles);
+  if (collapseWithPrevious && previousBlock && previousParagraph) {
+    const previousStyle = getEffectiveParagraphStyle(previousParagraph, styles);
+    const collapsedSpacingAfter = previousStyle.spacingAfter ?? 0;
+    if (collapsedSpacingAfter > 0) {
+      previousBlock.estimatedHeight = Math.max(
+        0,
+        previousBlock.estimatedHeight - collapsedSpacingAfter
+      );
+      track.height = Math.max(0, track.height - collapsedSpacingAfter);
+      contextualAdjustedPreviousBlock = previousBlock;
+      contextualAdjustedAmount = collapsedSpacingAfter;
+    }
+    paragraphTotalHeight = (measuredHeights == null ? void 0 : measuredHeights[sourceBlock.id]) ?? getProjectedParagraphBlockHeight(
+      sourceBlock,
+      paragraphLayout,
+      styles,
+      false
+    );
+  }
+  if (paragraphStyle.keepLinesTogether && paragraphTotalHeight <= track.currentMaxHeight) {
+    if (track.blocks.length > 0 && track.height + paragraphTotalHeight > track.currentMaxHeight) {
+      track.flush();
+    }
+    const segmentId = `${sourceBlock.id}:segment:0`;
+    const rawMeasuredHeight = getParagraphMeasuredHeight(
+      measuredHeights,
+      sourceBlock.id,
+      segmentId,
+      true,
+      paragraphTotalHeight
+    );
+    const hasMeasuredHeight = (measuredHeights == null ? void 0 : measuredHeights[segmentId]) !== void 0 || (measuredHeights == null ? void 0 : measuredHeights[sourceBlock.id]) !== void 0;
+    const measuredHeight = collapseWithPrevious && hasMeasuredHeight ? Math.max(0, rawMeasuredHeight - (paragraphStyle.spacingBefore ?? 0)) : rawMeasuredHeight;
+    track.blocks.push({
+      blockId: segmentId,
+      sourceBlockId: sourceBlock.id,
+      blockType: sourceBlock.type,
+      paragraphId: sourceBlock.id,
+      globalIndex: index,
+      estimatedHeight: measuredHeight,
+      layout: paragraphLayout,
+      sourceBlock
+    });
+    track.height += measuredHeight;
+    return;
+  }
+  let startLineIndex = 0;
+  let segmentIndex = 0;
+  while (startLineIndex < paragraphLayout.lines.length) {
+    const remainingHeight = track.currentMaxHeight - track.height;
+    let lineEndIndex = startLineIndex;
+    let segmentHeight = 0;
+    while (lineEndIndex < paragraphLayout.lines.length) {
+      const candidateLines = paragraphLayout.lines.slice(
+        startLineIndex,
+        lineEndIndex + 1
+      );
+      const candidateHeight = getParagraphSegmentHeight(
+        sourceBlock,
+        candidateLines,
+        startLineIndex === 0,
+        lineEndIndex === paragraphLayout.lines.length - 1,
+        styles,
+        !collapseWithPrevious
+      );
+      const candidateFitHeight = getParagraphSegmentFitHeight(
+        sourceBlock,
+        candidateHeight,
+        lineEndIndex === paragraphLayout.lines.length - 1,
+        styles
+      );
+      const tolerance = 1.5;
+      if (candidateFitHeight > remainingHeight + tolerance && lineEndIndex === startLineIndex && track.blocks.length > 0) {
+        break;
+      }
+      if (candidateFitHeight > remainingHeight + tolerance && lineEndIndex > startLineIndex) {
+        break;
+      }
+      segmentHeight = candidateHeight;
+      lineEndIndex += 1;
+    }
+    if (lineEndIndex === startLineIndex && track.blocks.length > 0) {
+      if (contextualAdjustedPreviousBlock && contextualAdjustedAmount > 0) {
+        contextualAdjustedPreviousBlock.estimatedHeight += contextualAdjustedAmount;
+        track.height += contextualAdjustedAmount;
+        contextualAdjustedPreviousBlock = void 0;
+        contextualAdjustedAmount = 0;
+      }
+      collapseWithPrevious = false;
+      track.flush();
+      continue;
+    }
+    if (lineEndIndex === startLineIndex) {
+      lineEndIndex = Math.min(paragraphLayout.lines.length, startLineIndex + 1);
+      segmentHeight = getParagraphSegmentHeight(
+        sourceBlock,
+        paragraphLayout.lines.slice(startLineIndex, lineEndIndex),
+        startLineIndex === 0,
+        lineEndIndex === paragraphLayout.lines.length,
+        styles,
+        !collapseWithPrevious
+      );
+    }
+    if (lineEndIndex < paragraphLayout.lines.length) {
+      const widowOrphanAdjusted = applyWidowOrphanControl(
+        sourceBlock,
+        paragraphLayout.lines,
+        startLineIndex,
+        lineEndIndex,
+        styles,
+        !collapseWithPrevious,
+        true,
+        track.blocks.length > 0
+      );
+      lineEndIndex = widowOrphanAdjusted.endLineIndexExclusive;
+      segmentHeight = widowOrphanAdjusted.height;
+      if (lineEndIndex === startLineIndex) {
+        if (contextualAdjustedPreviousBlock && contextualAdjustedAmount > 0) {
+          contextualAdjustedPreviousBlock.estimatedHeight += contextualAdjustedAmount;
+          track.height += contextualAdjustedAmount;
+          contextualAdjustedPreviousBlock = void 0;
+          contextualAdjustedAmount = 0;
+        }
+        collapseWithPrevious = false;
+        track.flush();
+        continue;
+      }
+    }
+    const segmentLayout = createParagraphSegmentLayout(
+      paragraphLayout,
+      startLineIndex,
+      lineEndIndex
+    );
+    const segmentId = `${sourceBlock.id}:segment:${segmentIndex}`;
+    const isWholeParagraphSegment = startLineIndex === 0 && lineEndIndex === paragraphLayout.lines.length;
+    const rawMeasuredHeight = getParagraphMeasuredHeight(
+      measuredHeights,
+      sourceBlock.id,
+      segmentId,
+      isWholeParagraphSegment,
+      segmentHeight
+    );
+    const hasMeasuredHeight = (measuredHeights == null ? void 0 : measuredHeights[segmentId]) !== void 0 || isWholeParagraphSegment && (measuredHeights == null ? void 0 : measuredHeights[sourceBlock.id]) !== void 0;
+    const measuredHeight = collapseWithPrevious && startLineIndex === 0 && hasMeasuredHeight ? Math.max(0, rawMeasuredHeight - (paragraphStyle.spacingBefore ?? 0)) : rawMeasuredHeight;
+    track.blocks.push({
+      blockId: segmentId,
+      sourceBlockId: sourceBlock.id,
+      blockType: sourceBlock.type,
+      paragraphId: sourceBlock.id,
+      globalIndex: index,
+      estimatedHeight: measuredHeight,
+      layout: segmentLayout,
+      sourceBlock
+    });
+    track.height += measuredHeight;
+    startLineIndex = lineEndIndex;
+    segmentIndex += 1;
+    if (startLineIndex < paragraphLayout.lines.length) {
+      track.flush();
+    }
+  }
+}
 function normalizeCellStartPositions(row, starts, legacyStarts) {
   return row.cells.map((_, cellIdx) => {
     var _a, _b;
@@ -12943,125 +13355,283 @@ function positionsFinishedRow(row, ends) {
     }
   );
 }
-const MAX_COLUMN_BALANCE_ITERATIONS = 100;
-function projectColumnedBlocksLayout(context2, count, runTrackLayout) {
-  var _a, _b;
-  const { pageSettings, maxPageHeight, pageOffset = 0, existingPages = [] } = context2;
-  const colWidth = ((_a = getPageColumnRects(pageSettings)[0]) == null ? void 0 : _a.width) ?? getPageContentWidth(pageSettings);
-  const runTracks = (blocks, trackHeight) => runTrackLayout({
-    ...context2,
-    blocks,
-    maxPageHeight: trackHeight,
-    contentWidthOverride: colWidth,
-    pageOffset: 0,
-    existingPages: [],
-    reservedHeightByPageIndex: void 0
-  });
-  let tracks = runTracks(context2.blocks, maxPageHeight);
-  if (tracks.length > 1 || tracks.length === 1 && count > 1) {
-    const trailingStart = Math.floor((tracks.length - 1) / count) * count;
-    const trailingTracks = tracks.slice(trailingStart);
-    const firstTrailingBlock = (_b = trailingTracks[0]) == null ? void 0 : _b.blocks[0];
-    const prevTrack = trailingStart > 0 ? tracks[trailingStart - 1] : void 0;
-    const prevLastBlock = prevTrack == null ? void 0 : prevTrack.blocks[prevTrack.blocks.length - 1];
-    const cleanBoundary = firstTrailingBlock != null && (prevLastBlock == null || prevLastBlock.globalIndex !== firstTrailingBlock.globalIndex);
-    if (cleanBoundary) {
-      const startIndex = firstTrailingBlock.globalIndex;
-      const sourceSubset = context2.blocks.slice(startIndex);
-      const sumHeight = trailingTracks.reduce(
-        (sum, track) => sum + track.height,
-        0
-      );
-      let target = Math.max(24, Math.ceil(sumHeight / count));
-      let balanced = runTracks(sourceSubset, target);
-      for (let iteration = 0; balanced.length > count && target < maxPageHeight && iteration < MAX_COLUMN_BALANCE_ITERATIONS; iteration += 1) {
-        target = Math.min(maxPageHeight, Math.ceil(target * 1.05) + 4);
-        balanced = runTracks(sourceSubset, target);
+function paginateTableBlock(track, params, sourceBlock, index) {
+  const { contentWidth, measurer, styles, defaultTabStop, measuredHeights } = params;
+  const tableHeight = (measuredHeights == null ? void 0 : measuredHeights[sourceBlock.id]) ?? estimateTableBlockHeight(
+    sourceBlock,
+    styles,
+    contentWidth,
+    measurer,
+    defaultTabStop
+  );
+  const maxHeightForCurrentPage = track.currentMaxHeight;
+  const firstRow = sourceBlock.rows[0];
+  const canSplitSingleRow = canSplitTableRow(firstRow);
+  if (!canSplitSingleRow && sourceBlock.rows.length <= 1 || track.height + tableHeight <= maxHeightForCurrentPage) {
+    if (track.blocks.length > 0 && track.height + tableHeight > maxHeightForCurrentPage) {
+      track.flush();
+    }
+    track.blocks.push({
+      blockId: sourceBlock.id,
+      sourceBlockId: sourceBlock.id,
+      blockType: sourceBlock.type,
+      globalIndex: index,
+      estimatedHeight: tableHeight,
+      sourceBlock
+    });
+    track.height += tableHeight;
+    return;
+  }
+  const rowGroups = getTableRowGroups(sourceBlock);
+  const headerRowCount = getRepeatableHeaderRowCount(
+    sourceBlock,
+    getTableHeaderRowCount(sourceBlock),
+    rowGroups
+  );
+  let groupStartIndex = 0;
+  let segmentIndex = 0;
+  let currentCellBlockPositions;
+  while (groupStartIndex < rowGroups.length) {
+    const startRowIndex = rowGroups[groupStartIndex].startRowIndex;
+    const repeatedHeaderRowCount = startRowIndex > 0 ? headerRowCount : 0;
+    const remainingHeight = track.currentMaxHeight - track.height;
+    let groupEndIndex = groupStartIndex;
+    let segmentHeight = 0;
+    let splitEnds;
+    let splitEndPositions;
+    let isLastRowSplit = false;
+    while (groupEndIndex < rowGroups.length) {
+      const candidateEndRowIndex = rowGroups[groupEndIndex].endRowIndexExclusive;
+      let candidateHeight = 0;
+      if (groupEndIndex === groupStartIndex && currentCellBlockPositions) {
+        const firstRow2 = sourceBlock.rows[startRowIndex];
+        const starts = normalizeCellStartPositions(
+          firstRow2,
+          currentCellBlockPositions,
+          void 0
+        );
+        const ends = firstRow2.cells.map((cell) => ({
+          blockIndex: cell.blocks.length
+        }));
+        const slicedFirstRow = buildRowSliceFromPositions(
+          firstRow2,
+          starts,
+          ends
+        );
+        candidateHeight = getTableSegmentHeight(
+          {
+            ...sourceBlock,
+            rows: [slicedFirstRow]
+          },
+          0,
+          1,
+          repeatedHeaderRowCount,
+          styles,
+          contentWidth,
+          measurer,
+          defaultTabStop
+        );
+      } else {
+        candidateHeight = getTableSegmentHeight(
+          sourceBlock,
+          startRowIndex,
+          candidateEndRowIndex,
+          repeatedHeaderRowCount,
+          styles,
+          contentWidth,
+          measurer,
+          defaultTabStop
+        );
       }
-      if (balanced.length <= count) {
-        tracks = [...tracks.slice(0, trailingStart), ...balanced];
+      if (candidateHeight <= remainingHeight) {
+        segmentHeight = candidateHeight;
+        groupEndIndex += 1;
+        continue;
+      }
+      const isSingleRowGroup = candidateEndRowIndex === rowGroups[groupEndIndex].startRowIndex + 1;
+      const targetRow = sourceBlock.rows[rowGroups[groupEndIndex].startRowIndex];
+      const isSplitCandidate = isSingleRowGroup && canSplitTableRow(targetRow);
+      if (isSplitCandidate) {
+        const precedingHeight = groupEndIndex > groupStartIndex ? getTableSegmentHeight(
+          sourceBlock,
+          startRowIndex,
+          rowGroups[groupEndIndex].startRowIndex,
+          repeatedHeaderRowCount,
+          styles,
+          contentWidth,
+          measurer,
+          defaultTabStop
+        ) : 0;
+        const availableForSplitRow = remainingHeight - precedingHeight;
+        if (availableForSplitRow > 0) {
+          const starts = normalizeCellStartPositions(
+            targetRow,
+            groupEndIndex === groupStartIndex ? currentCellBlockPositions : void 0,
+            void 0
+          );
+          const ends = targetRow.cells.map(
+            (_, cellIdx) => findCellSplitEndPosition(
+              targetRow,
+              cellIdx,
+              starts[cellIdx] ?? { blockIndex: 0 },
+              availableForSplitRow,
+              styles,
+              measurer,
+              defaultTabStop,
+              contentWidth,
+              sourceBlock,
+              rowGroups[groupEndIndex].startRowIndex
+            )
+          );
+          const canProgress = positionsProgressed(starts, ends);
+          if (canProgress) {
+            splitEnds = positionsToBlockIndexes(ends);
+            isLastRowSplit = true;
+            const slicedLastRow = buildRowSliceFromPositions(
+              targetRow,
+              starts,
+              ends
+            );
+            const segmentRows = [
+              ...sourceBlock.rows.slice(
+                startRowIndex,
+                rowGroups[groupEndIndex].startRowIndex
+              ),
+              slicedLastRow
+            ];
+            segmentHeight = getTableSegmentHeight(
+              { ...sourceBlock, rows: segmentRows },
+              0,
+              segmentRows.length,
+              repeatedHeaderRowCount,
+              styles,
+              contentWidth,
+              measurer,
+              defaultTabStop
+            );
+            splitEndPositions = ends;
+            groupEndIndex += 1;
+            break;
+          }
+        }
       }
+      break;
     }
-  }
-  const pages = [...existingPages];
-  const startPageIndex = existingPages.length > 0 ? existingPages[existingPages.length - 1].index + 1 : pageOffset;
-  const physicalPageCount = Math.ceil(tracks.length / count);
-  for (let p = 0; p < physicalPageCount; p += 1) {
-    const pageIndex = startPageIndex + p;
-    const pageTracks = tracks.slice(p * count, p * count + count);
-    const blocks = [];
-    let height = 0;
-    pageTracks.forEach((track, columnIndex) => {
-      for (const block of track.blocks) {
-        block.columnIndex = columnIndex;
-        blocks.push(block);
+    if (groupEndIndex === groupStartIndex && track.blocks.length > 0) {
+      track.flush();
+      continue;
+    }
+    if (groupEndIndex === groupStartIndex) {
+      const targetRow = sourceBlock.rows[startRowIndex];
+      const isSingleRowGroup = rowGroups[groupStartIndex].endRowIndexExclusive === startRowIndex + 1;
+      const isSplitCandidate = isSingleRowGroup && canSplitTableRow(targetRow);
+      if (isSplitCandidate) {
+        const starts = normalizeCellStartPositions(
+          targetRow,
+          currentCellBlockPositions,
+          void 0
+        );
+        let ends = starts.map(
+          (start, cellIdx) => findCellSplitEndPosition(
+            targetRow,
+            cellIdx,
+            start,
+            track.currentMaxHeight,
+            styles,
+            measurer,
+            defaultTabStop,
+            contentWidth,
+            sourceBlock,
+            startRowIndex
+          )
+        );
+        if (!positionsProgressed(starts, ends)) {
+          ends = starts.map((start, cellIdx) => ({
+            blockIndex: Math.min(
+              targetRow.cells[cellIdx].blocks.length,
+              start.blockIndex + 1
+            )
+          }));
+        }
+        splitEnds = positionsToBlockIndexes(ends);
+        splitEndPositions = ends;
+        isLastRowSplit = true;
+        const slicedLastRow = buildRowSliceFromPositions(
+          targetRow,
+          starts,
+          ends
+        );
+        segmentHeight = getTableSegmentHeight(
+          { ...sourceBlock, rows: [slicedLastRow] },
+          0,
+          1,
+          repeatedHeaderRowCount,
+          styles,
+          contentWidth,
+          measurer,
+          defaultTabStop
+        );
+        groupEndIndex += 1;
+      } else {
+        groupEndIndex = rowGroups[groupStartIndex].endRowIndexExclusive;
+        segmentHeight = getTableSegmentHeight(
+          sourceBlock,
+          startRowIndex,
+          groupEndIndex,
+          repeatedHeaderRowCount,
+          styles,
+          contentWidth,
+          measurer,
+          defaultTabStop
+        );
       }
-      height = Math.max(height, track.height);
-    });
-    pages.push({
-      id: `page:${pageIndex + 1}`,
-      index: pageIndex,
-      height,
-      maxHeight: maxPageHeight,
-      blocks,
-      pageSettings
-    });
-  }
-  if (pages.length === 0) {
-    pages.push({
-      id: `page:${startPageIndex + 1}`,
-      index: startPageIndex,
-      height: 0,
-      maxHeight: maxPageHeight,
-      blocks: [],
-      pageSettings
+    }
+    const segmentId = `${sourceBlock.id}:segment:${segmentIndex}`;
+    const measuredSegmentHeight = (measuredHeights == null ? void 0 : measuredHeights[segmentId]) ?? segmentHeight;
+    const endRowIndex = rowGroups[groupEndIndex - 1].endRowIndexExclusive;
+    track.blocks.push({
+      blockId: segmentId,
+      sourceBlockId: sourceBlock.id,
+      blockType: sourceBlock.type,
+      globalIndex: index,
+      estimatedHeight: measuredSegmentHeight,
+      tableSegment: {
+        startRowIndex,
+        endRowIndex,
+        repeatedHeaderRowCount,
+        startRowCellBlockStarts: positionsToBlockIndexes(
+          currentCellBlockPositions
+        ),
+        endRowCellBlockEnds: splitEnds,
+        startRowCellBlockPositions: hasPartialPositions(
+          currentCellBlockPositions
+        ) ? currentCellBlockPositions : void 0,
+        endRowCellBlockPositions: hasPartialPositions(splitEndPositions) ? splitEndPositions : void 0
+      },
+      sourceBlock
     });
-  }
-  return pages;
-}
-const TEXT_BOX_AUTOFIT_SAFETY_PX$1 = 2;
-function estimateTextBoxAutoFitHeight(textBox, styles, measurer, pageIndex, totalPages, defaultTabStop) {
-  var _a, _b, _c, _d, _e;
-  if (!((_a = textBox.body) == null ? void 0 : _a.autoFit)) {
-    return textBox.height;
-  }
-  const padding = {
-    left: ((_b = textBox.body) == null ? void 0 : _b.paddingLeft) ?? 0,
-    top: ((_c = textBox.body) == null ? void 0 : _c.paddingTop) ?? 0,
-    right: ((_d = textBox.body) == null ? void 0 : _d.paddingRight) ?? 0,
-    bottom: ((_e = textBox.body) == null ? void 0 : _e.paddingBottom) ?? 0
-  };
-  const innerWidth = Math.max(1, textBox.width - padding.left - padding.right);
-  const contentHeight = textBox.blocks.reduce((sum, block) => {
-    if (block.type === "paragraph") {
-      const layout = projectParagraphLayout(
-        block,
-        pageIndex,
-        totalPages,
-        styles,
-        innerWidth,
-        measurer,
-        defaultTabStop
-      );
-      return sum + getProjectedParagraphBlockHeight(block, layout, styles);
+    track.height += measuredSegmentHeight;
+    segmentIndex += 1;
+    if (isLastRowSplit) {
+      const lastRowIndex = rowGroups[groupEndIndex - 1].startRowIndex;
+      const lastRow = sourceBlock.rows[lastRowIndex];
+      const ends = splitEndPositions ?? (splitEnds == null ? void 0 : splitEnds.map((blockIndex) => ({ blockIndex }))) ?? [];
+      const isFinished = positionsFinishedRow(lastRow, ends);
+      if (isFinished) {
+        currentCellBlockPositions = void 0;
+        groupStartIndex = groupEndIndex;
+      } else {
+        currentCellBlockPositions = ends;
+        groupStartIndex = groupEndIndex - 1;
+      }
+    } else {
+      currentCellBlockPositions = void 0;
+      groupStartIndex = groupEndIndex;
     }
-    if (block.type === "table") {
-      return sum + estimateTableBlockHeight(
-        block,
-        styles,
-        innerWidth,
-        measurer,
-        defaultTabStop
-      );
+    if (groupStartIndex < rowGroups.length) {
+      track.flush();
     }
-    return sum;
-  }, 0);
-  return Math.max(
-    1,
-    Math.ceil(
-      contentHeight + padding.top + padding.bottom + TEXT_BOX_AUTOFIT_SAFETY_PX$1
-    )
-  );
+  }
 }
 function projectBlocksLayout(context2) {
   const columns = context2.pageSettings.columns;
@@ -13075,7 +13645,7 @@ function projectBlocksLayout(context2) {
   return projectColumnTrackLayout(context2);
 }
 function projectColumnTrackLayout(context2) {
-  var _a, _b;
+  var _a;
   const {
     blocks,
     pageSettings,
@@ -13092,565 +13662,36 @@ function projectColumnTrackLayout(context2) {
     contentWidthOverride
   } = context2;
   const contentWidth = contentWidthOverride ?? getPageContentWidth(pageSettings);
-  const pages = [...existingPages];
-  const currentPage = pages[pages.length - 1];
-  let currentBlocks = currentPage ? [...currentPage.blocks] : [];
-  let currentHeight = currentPage ? currentPage.height : 0;
-  const getCurrentPageIndex = () => pageOffset + pages.length;
-  const getMaxHeightForPage = (pageIndex) => Math.max(
-    24,
-    maxPageHeight - ((reservedHeightByPageIndex == null ? void 0 : reservedHeightByPageIndex.get(pageIndex)) ?? 0)
+  const track = new PaginationTrack(
+    pageOffset,
+    maxPageHeight,
+    reservedHeightByPageIndex,
+    pageSettings,
+    existingPages
   );
-  if (currentPage) {
-    pages.pop();
-  }
-  const flushPage = () => {
-    if (currentBlocks.length === 0 && pages.length > 0) {
-      return;
-    }
-    const pageIndex = getCurrentPageIndex();
-    const currentMaxHeight = getMaxHeightForPage(pageIndex);
-    pages.push({
-      id: `page:${pageIndex + 1}`,
-      index: pageIndex,
-      height: currentHeight,
-      maxHeight: currentMaxHeight,
-      blocks: currentBlocks,
-      pageSettings
-    });
-    currentBlocks = [];
-    currentHeight = 0;
+  const params = {
+    pageSettings,
+    contentWidth,
+    measurer,
+    styles,
+    totalPages,
+    defaultTabStop,
+    measuredHeights,
+    measuredParagraphLayouts
   };
   for (let index = 0; index < blocks.length; index += 1) {
     const sourceBlock = blocks[index];
     const nextBlock = blocks[index + 1];
-    if (currentBlocks.length > 0 && (sourceBlock.type === "paragraph" ? getEffectiveParagraphStyle(sourceBlock, styles).pageBreakBefore : (_a = sourceBlock.style) == null ? void 0 : _a.pageBreakBefore)) {
-      flushPage();
+    if (track.blocks.length > 0 && (sourceBlock.type === "paragraph" ? getEffectiveParagraphStyle(sourceBlock, styles).pageBreakBefore : (_a = sourceBlock.style) == null ? void 0 : _a.pageBreakBefore)) {
+      track.flush();
     }
     if (sourceBlock.type === "paragraph") {
-      const pageIndex = pageOffset + pages.length;
-      const projectedParagraphLayout = projectParagraphLayoutWithExclusions(
-        sourceBlock,
-        pageSettings,
-        contentWidth,
-        measurer,
-        pageIndex,
-        totalPages,
-        styles,
-        defaultTabStop,
-        (textBox) => estimateTextBoxAutoFitHeight(
-          textBox,
-          styles,
-          measurer,
-          pageIndex,
-          totalPages,
-          defaultTabStop
-        )
-      );
-      const measuredParagraphLayout = measuredParagraphLayouts == null ? void 0 : measuredParagraphLayouts[sourceBlock.id];
-      const paragraphLayout = measuredParagraphLayout && isMeasuredLayoutCurrent(
-        projectedParagraphLayout,
-        measuredParagraphLayout
-      ) ? applyMeasuredLineGeometry(
-        projectedParagraphLayout,
-        measuredParagraphLayout
-      ) : projectedParagraphLayout;
-      let collapseWithPrevious = false;
-      let contextualAdjustedPreviousBlock;
-      let contextualAdjustedAmount = 0;
-      let paragraphTotalHeight = (measuredHeights == null ? void 0 : measuredHeights[sourceBlock.id]) ?? getProjectedParagraphBlockHeight(sourceBlock, paragraphLayout, styles);
-      const paragraphStyle = getEffectiveParagraphStyle(sourceBlock, styles);
-      const nextBlockHeight = (nextBlock == null ? void 0 : nextBlock.type) === "paragraph" ? (measuredHeights == null ? void 0 : measuredHeights[nextBlock.id]) ?? estimateParagraphBlockHeight(
-        nextBlock,
-        styles,
-        contentWidth,
-        measurer,
-        {
-          allowSpacingBefore: !shouldCollapseContextualSpacing(
-            sourceBlock,
-            nextBlock,
-            styles
-          )
-        },
-        defaultTabStop
-      ) : nextBlock ? (measuredHeights == null ? void 0 : measuredHeights[nextBlock.id]) ?? estimateTableBlockHeight(
-        nextBlock,
-        styles,
-        contentWidth,
-        measurer,
-        defaultTabStop
-      ) : 0;
-      if (paragraphStyle.keepWithNext && currentBlocks.length > 0 && currentHeight + paragraphTotalHeight + nextBlockHeight > getMaxHeightForPage(getCurrentPageIndex()) && paragraphTotalHeight + nextBlockHeight <= getMaxHeightForPage(getCurrentPageIndex())) {
-        flushPage();
-      }
-      const previousBlock = currentBlocks.at(-1);
-      const previousParagraph = (previousBlock == null ? void 0 : previousBlock.blockType) === "paragraph" && ((_b = previousBlock.sourceBlock) == null ? void 0 : _b.type) === "paragraph" ? previousBlock.sourceBlock : void 0;
-      collapseWithPrevious = currentBlocks.length > 0 && shouldCollapseContextualSpacing(previousParagraph, sourceBlock, styles);
-      if (collapseWithPrevious && previousBlock && previousParagraph) {
-        const previousStyle = getEffectiveParagraphStyle(
-          previousParagraph,
-          styles
-        );
-        const collapsedSpacingAfter = previousStyle.spacingAfter ?? 0;
-        if (collapsedSpacingAfter > 0) {
-          previousBlock.estimatedHeight = Math.max(
-            0,
-            previousBlock.estimatedHeight - collapsedSpacingAfter
-          );
-          currentHeight = Math.max(0, currentHeight - collapsedSpacingAfter);
-          contextualAdjustedPreviousBlock = previousBlock;
-          contextualAdjustedAmount = collapsedSpacingAfter;
-        }
-        paragraphTotalHeight = (measuredHeights == null ? void 0 : measuredHeights[sourceBlock.id]) ?? getProjectedParagraphBlockHeight(
-          sourceBlock,
-          paragraphLayout,
-          styles,
-          false
-        );
-      }
-      if (paragraphStyle.keepLinesTogether && paragraphTotalHeight <= getMaxHeightForPage(getCurrentPageIndex())) {
-        if (currentBlocks.length > 0 && currentHeight + paragraphTotalHeight > getMaxHeightForPage(getCurrentPageIndex())) {
-          flushPage();
-        }
-        const segmentId = `${sourceBlock.id}:segment:0`;
-        const rawMeasuredHeight = getParagraphMeasuredHeight(
-          measuredHeights,
-          sourceBlock.id,
-          segmentId,
-          true,
-          paragraphTotalHeight
-        );
-        const hasMeasuredHeight = (measuredHeights == null ? void 0 : measuredHeights[segmentId]) !== void 0 || (measuredHeights == null ? void 0 : measuredHeights[sourceBlock.id]) !== void 0;
-        const measuredHeight = collapseWithPrevious && hasMeasuredHeight ? Math.max(
-          0,
-          rawMeasuredHeight - (paragraphStyle.spacingBefore ?? 0)
-        ) : rawMeasuredHeight;
-        currentBlocks.push({
-          blockId: segmentId,
-          sourceBlockId: sourceBlock.id,
-          blockType: sourceBlock.type,
-          paragraphId: sourceBlock.id,
-          globalIndex: index,
-          estimatedHeight: measuredHeight,
-          layout: paragraphLayout,
-          sourceBlock
-        });
-        currentHeight += measuredHeight;
-        continue;
-      }
-      let startLineIndex = 0;
-      let segmentIndex2 = 0;
-      while (startLineIndex < paragraphLayout.lines.length) {
-        const remainingHeight = getMaxHeightForPage(getCurrentPageIndex()) - currentHeight;
-        let lineEndIndex = startLineIndex;
-        let segmentHeight = 0;
-        while (lineEndIndex < paragraphLayout.lines.length) {
-          const candidateLines = paragraphLayout.lines.slice(
-            startLineIndex,
-            lineEndIndex + 1
-          );
-          const candidateHeight = getParagraphSegmentHeight(
-            sourceBlock,
-            candidateLines,
-            startLineIndex === 0,
-            lineEndIndex === paragraphLayout.lines.length - 1,
-            styles,
-            !collapseWithPrevious
-          );
-          const candidateFitHeight = getParagraphSegmentFitHeight(
-            sourceBlock,
-            candidateHeight,
-            lineEndIndex === paragraphLayout.lines.length - 1,
-            styles
-          );
-          const tolerance = 1.5;
-          if (candidateFitHeight > remainingHeight + tolerance && lineEndIndex === startLineIndex && currentBlocks.length > 0) {
-            break;
-          }
-          if (candidateFitHeight > remainingHeight + tolerance && lineEndIndex > startLineIndex) {
-            break;
-          }
-          segmentHeight = candidateHeight;
-          lineEndIndex += 1;
-        }
-        if (lineEndIndex === startLineIndex && currentBlocks.length > 0) {
-          if (contextualAdjustedPreviousBlock && contextualAdjustedAmount > 0) {
-            contextualAdjustedPreviousBlock.estimatedHeight += contextualAdjustedAmount;
-            currentHeight += contextualAdjustedAmount;
-            contextualAdjustedPreviousBlock = void 0;
-            contextualAdjustedAmount = 0;
-          }
-          collapseWithPrevious = false;
-          flushPage();
-          continue;
-        }
-        if (lineEndIndex === startLineIndex) {
-          lineEndIndex = Math.min(
-            paragraphLayout.lines.length,
-            startLineIndex + 1
-          );
-          segmentHeight = getParagraphSegmentHeight(
-            sourceBlock,
-            paragraphLayout.lines.slice(startLineIndex, lineEndIndex),
-            startLineIndex === 0,
-            lineEndIndex === paragraphLayout.lines.length,
-            styles,
-            !collapseWithPrevious
-          );
-        }
-        if (lineEndIndex < paragraphLayout.lines.length) {
-          const widowOrphanAdjusted = applyWidowOrphanControl(
-            sourceBlock,
-            paragraphLayout.lines,
-            startLineIndex,
-            lineEndIndex,
-            styles,
-            !collapseWithPrevious,
-            true,
-            currentBlocks.length > 0
-          );
-          lineEndIndex = widowOrphanAdjusted.endLineIndexExclusive;
-          segmentHeight = widowOrphanAdjusted.height;
-          if (lineEndIndex === startLineIndex) {
-            if (contextualAdjustedPreviousBlock && contextualAdjustedAmount > 0) {
-              contextualAdjustedPreviousBlock.estimatedHeight += contextualAdjustedAmount;
-              currentHeight += contextualAdjustedAmount;
-              contextualAdjustedPreviousBlock = void 0;
-              contextualAdjustedAmount = 0;
-            }
-            collapseWithPrevious = false;
-            flushPage();
-            continue;
-          }
-        }
-        const segmentLayout = createParagraphSegmentLayout(
-          paragraphLayout,
-          startLineIndex,
-          lineEndIndex
-        );
-        const segmentId = `${sourceBlock.id}:segment:${segmentIndex2}`;
-        const isWholeParagraphSegment = startLineIndex === 0 && lineEndIndex === paragraphLayout.lines.length;
-        const rawMeasuredHeight = getParagraphMeasuredHeight(
-          measuredHeights,
-          sourceBlock.id,
-          segmentId,
-          isWholeParagraphSegment,
-          segmentHeight
-        );
-        const hasMeasuredHeight = (measuredHeights == null ? void 0 : measuredHeights[segmentId]) !== void 0 || isWholeParagraphSegment && (measuredHeights == null ? void 0 : measuredHeights[sourceBlock.id]) !== void 0;
-        const measuredHeight = collapseWithPrevious && startLineIndex === 0 && hasMeasuredHeight ? Math.max(
-          0,
-          rawMeasuredHeight - (paragraphStyle.spacingBefore ?? 0)
-        ) : rawMeasuredHeight;
-        currentBlocks.push({
-          blockId: segmentId,
-          sourceBlockId: sourceBlock.id,
-          blockType: sourceBlock.type,
-          paragraphId: sourceBlock.id,
-          globalIndex: index,
-          estimatedHeight: measuredHeight,
-          layout: segmentLayout,
-          sourceBlock
-        });
-        currentHeight += measuredHeight;
-        startLineIndex = lineEndIndex;
-        segmentIndex2 += 1;
-        if (startLineIndex < paragraphLayout.lines.length) {
-          flushPage();
-        }
-      }
-      continue;
-    }
-    const tableHeight = (measuredHeights == null ? void 0 : measuredHeights[sourceBlock.id]) ?? estimateTableBlockHeight(
-      sourceBlock,
-      styles,
-      contentWidth,
-      measurer,
-      defaultTabStop
-    );
-    const maxHeightForCurrentPage = getMaxHeightForPage(getCurrentPageIndex());
-    const firstRow = sourceBlock.rows[0];
-    const canSplitSingleRow = canSplitTableRow(firstRow);
-    if (!canSplitSingleRow && sourceBlock.rows.length <= 1 || currentHeight + tableHeight <= maxHeightForCurrentPage) {
-      if (currentBlocks.length > 0 && currentHeight + tableHeight > maxHeightForCurrentPage) {
-        flushPage();
-      }
-      currentBlocks.push({
-        blockId: sourceBlock.id,
-        sourceBlockId: sourceBlock.id,
-        blockType: sourceBlock.type,
-        globalIndex: index,
-        estimatedHeight: tableHeight,
-        sourceBlock
-      });
-      currentHeight += tableHeight;
+      paginateParagraphBlock(track, params, sourceBlock, nextBlock, index);
       continue;
     }
-    const rowGroups = getTableRowGroups(sourceBlock);
-    const headerRowCount = getRepeatableHeaderRowCount(
-      sourceBlock,
-      getTableHeaderRowCount(sourceBlock),
-      rowGroups
-    );
-    let groupStartIndex = 0;
-    let segmentIndex = 0;
-    let currentCellBlockPositions;
-    while (groupStartIndex < rowGroups.length) {
-      const startRowIndex = rowGroups[groupStartIndex].startRowIndex;
-      const repeatedHeaderRowCount = startRowIndex > 0 ? headerRowCount : 0;
-      const remainingHeight = getMaxHeightForPage(getCurrentPageIndex()) - currentHeight;
-      let groupEndIndex = groupStartIndex;
-      let segmentHeight = 0;
-      let splitEnds;
-      let splitEndPositions;
-      let isLastRowSplit = false;
-      while (groupEndIndex < rowGroups.length) {
-        const candidateEndRowIndex = rowGroups[groupEndIndex].endRowIndexExclusive;
-        let candidateHeight = 0;
-        if (groupEndIndex === groupStartIndex && currentCellBlockPositions) {
-          const firstRow2 = sourceBlock.rows[startRowIndex];
-          const starts = normalizeCellStartPositions(
-            firstRow2,
-            currentCellBlockPositions,
-            void 0
-          );
-          const ends = firstRow2.cells.map((cell) => ({
-            blockIndex: cell.blocks.length
-          }));
-          const slicedFirstRow = buildRowSliceFromPositions(
-            firstRow2,
-            starts,
-            ends
-          );
-          candidateHeight = getTableSegmentHeight(
-            {
-              ...sourceBlock,
-              rows: [slicedFirstRow]
-            },
-            0,
-            1,
-            repeatedHeaderRowCount,
-            styles,
-            contentWidth,
-            measurer,
-            defaultTabStop
-          );
-        } else {
-          candidateHeight = getTableSegmentHeight(
-            sourceBlock,
-            startRowIndex,
-            candidateEndRowIndex,
-            repeatedHeaderRowCount,
-            styles,
-            contentWidth,
-            measurer,
-            defaultTabStop
-          );
-        }
-        if (candidateHeight <= remainingHeight) {
-          segmentHeight = candidateHeight;
-          groupEndIndex += 1;
-          continue;
-        }
-        const isSingleRowGroup = candidateEndRowIndex === rowGroups[groupEndIndex].startRowIndex + 1;
-        const targetRow = sourceBlock.rows[rowGroups[groupEndIndex].startRowIndex];
-        const isSplitCandidate = isSingleRowGroup && canSplitTableRow(targetRow);
-        if (isSplitCandidate) {
-          const precedingHeight = groupEndIndex > groupStartIndex ? getTableSegmentHeight(
-            sourceBlock,
-            startRowIndex,
-            rowGroups[groupEndIndex].startRowIndex,
-            repeatedHeaderRowCount,
-            styles,
-            contentWidth,
-            measurer,
-            defaultTabStop
-          ) : 0;
-          const availableForSplitRow = remainingHeight - precedingHeight;
-          if (availableForSplitRow > 0) {
-            const starts = normalizeCellStartPositions(
-              targetRow,
-              groupEndIndex === groupStartIndex ? currentCellBlockPositions : void 0,
-              void 0
-            );
-            const ends = targetRow.cells.map(
-              (_, cellIdx) => findCellSplitEndPosition(
-                targetRow,
-                cellIdx,
-                starts[cellIdx] ?? { blockIndex: 0 },
-                availableForSplitRow,
-                styles,
-                measurer,
-                defaultTabStop,
-                contentWidth,
-                sourceBlock,
-                rowGroups[groupEndIndex].startRowIndex
-              )
-            );
-            const canProgress = positionsProgressed(starts, ends);
-            if (canProgress) {
-              splitEnds = positionsToBlockIndexes(ends);
-              isLastRowSplit = true;
-              const slicedLastRow = buildRowSliceFromPositions(
-                targetRow,
-                starts,
-                ends
-              );
-              const segmentRows = [
-                ...sourceBlock.rows.slice(
-                  startRowIndex,
-                  rowGroups[groupEndIndex].startRowIndex
-                ),
-                slicedLastRow
-              ];
-              segmentHeight = getTableSegmentHeight(
-                { ...sourceBlock, rows: segmentRows },
-                0,
-                segmentRows.length,
-                repeatedHeaderRowCount,
-                styles,
-                contentWidth,
-                measurer,
-                defaultTabStop
-              );
-              splitEndPositions = ends;
-              groupEndIndex += 1;
-              break;
-            }
-          }
-        }
-        break;
-      }
-      if (groupEndIndex === groupStartIndex && currentBlocks.length > 0) {
-        flushPage();
-        continue;
-      }
-      if (groupEndIndex === groupStartIndex) {
-        const targetRow = sourceBlock.rows[startRowIndex];
-        const isSingleRowGroup = rowGroups[groupStartIndex].endRowIndexExclusive === startRowIndex + 1;
-        const isSplitCandidate = isSingleRowGroup && canSplitTableRow(targetRow);
-        if (isSplitCandidate) {
-          const starts = normalizeCellStartPositions(
-            targetRow,
-            currentCellBlockPositions,
-            void 0
-          );
-          let ends = starts.map(
-            (start, cellIdx) => findCellSplitEndPosition(
-              targetRow,
-              cellIdx,
-              start,
-              getMaxHeightForPage(getCurrentPageIndex()),
-              styles,
-              measurer,
-              defaultTabStop,
-              contentWidth,
-              sourceBlock,
-              startRowIndex
-            )
-          );
-          if (!positionsProgressed(starts, ends)) {
-            ends = starts.map((start, cellIdx) => ({
-              blockIndex: Math.min(
-                targetRow.cells[cellIdx].blocks.length,
-                start.blockIndex + 1
-              )
-            }));
-          }
-          splitEnds = positionsToBlockIndexes(ends);
-          splitEndPositions = ends;
-          isLastRowSplit = true;
-          const slicedLastRow = buildRowSliceFromPositions(
-            targetRow,
-            starts,
-            ends
-          );
-          segmentHeight = getTableSegmentHeight(
-            { ...sourceBlock, rows: [slicedLastRow] },
-            0,
-            1,
-            repeatedHeaderRowCount,
-            styles,
-            contentWidth,
-            measurer,
-            defaultTabStop
-          );
-          groupEndIndex += 1;
-        } else {
-          groupEndIndex = rowGroups[groupStartIndex].endRowIndexExclusive;
-          segmentHeight = getTableSegmentHeight(
-            sourceBlock,
-            startRowIndex,
-            groupEndIndex,
-            repeatedHeaderRowCount,
-            styles,
-            contentWidth,
-            measurer,
-            defaultTabStop
-          );
-        }
-      }
-      const segmentId = `${sourceBlock.id}:segment:${segmentIndex}`;
-      const measuredSegmentHeight = (measuredHeights == null ? void 0 : measuredHeights[segmentId]) ?? segmentHeight;
-      const endRowIndex = rowGroups[groupEndIndex - 1].endRowIndexExclusive;
-      currentBlocks.push({
-        blockId: segmentId,
-        sourceBlockId: sourceBlock.id,
-        blockType: sourceBlock.type,
-        globalIndex: index,
-        estimatedHeight: measuredSegmentHeight,
-        tableSegment: {
-          startRowIndex,
-          endRowIndex,
-          repeatedHeaderRowCount,
-          startRowCellBlockStarts: positionsToBlockIndexes(
-            currentCellBlockPositions
-          ),
-          endRowCellBlockEnds: splitEnds,
-          startRowCellBlockPositions: hasPartialPositions(
-            currentCellBlockPositions
-          ) ? currentCellBlockPositions : void 0,
-          endRowCellBlockPositions: hasPartialPositions(splitEndPositions) ? splitEndPositions : void 0
-        },
-        sourceBlock
-      });
-      currentHeight += measuredSegmentHeight;
-      segmentIndex += 1;
-      if (isLastRowSplit) {
-        const lastRowIndex = rowGroups[groupEndIndex - 1].startRowIndex;
-        const lastRow = sourceBlock.rows[lastRowIndex];
-        const ends = splitEndPositions ?? (splitEnds == null ? void 0 : splitEnds.map((blockIndex) => ({ blockIndex }))) ?? [];
-        const isFinished = positionsFinishedRow(lastRow, ends);
-        if (isFinished) {
-          currentCellBlockPositions = void 0;
-          groupStartIndex = groupEndIndex;
-        } else {
-          currentCellBlockPositions = ends;
-          groupStartIndex = groupEndIndex - 1;
-        }
-      } else {
-        currentCellBlockPositions = void 0;
-        groupStartIndex = groupEndIndex;
-      }
-      if (groupStartIndex < rowGroups.length) {
-        flushPage();
-      }
-    }
-  }
-  flushPage();
-  if (pages.length === 0) {
-    const pageIndex = pageOffset;
-    const currentMaxHeight = getMaxHeightForPage(pageIndex);
-    pages.push({
-      id: `page:${pageIndex + 1}`,
-      index: pageIndex,
-      height: 0,
-      maxHeight: currentMaxHeight,
-      blocks: [],
-      pageSettings
-    });
+    paginateTableBlock(track, params, sourceBlock, index);
   }
-  return pages;
+  return track.finalize();
 }
 function getProjectedBlocksHeight(blocks) {
   if (!blocks || blocks.length === 0) {