oasis-editor 0.0.112 → 0.0.113

package/dist/{index-AX7m_SeX.js → index-DSDwe-yy.js}

@@ -2539,7 +2539,7 @@ function OasisEditorAppLazy(props = {}) {
     onCleanup(() => {
       cancelled = true;
     });
-    import("./OasisEditorApp-p9k7O_1i.js").then((m) => {
+    import("./OasisEditorApp-BKPrQtm5.js").then((m) => {
       cancelled = true;
       setProgress(1);
       setTimeout(() => setApp(() => m.OasisEditorApp), 180);
@@ -16271,6 +16271,30 @@ class PaginationTrack {
     return this.pages;
   }
 }
+function paginateSegments(track, sourceId, segmenter) {
+  var _a, _b;
+  let segmentIndex = 0;
+  while (segmenter.hasMore()) {
+    const segmentId = `${sourceId}:segment:${segmentIndex}`;
+    const remaining = track.currentMaxHeight - track.height;
+    let block = segmenter.fit(segmentId, remaining);
+    if (block === null && track.blocks.length > 0) {
+      (_a = segmenter.onBeforeFlush) == null ? void 0 : _a.call(segmenter);
+      track.flush();
+      continue;
+    }
+    if (block === null) {
+      block = segmenter.force(segmentId);
+    }
+    track.blocks.push(block);
+    track.height += block.estimatedHeight;
+    (_b = segmenter.onAfterPush) == null ? void 0 : _b.call(segmenter, block, segmentIndex);
+    segmentIndex += 1;
+    if (segmenter.hasMore()) {
+      track.flush();
+    }
+  }
+}
 const TEXT_BOX_AUTOFIT_SAFETY_PX$1 = 2;
 const PARAGRAPH_FIT_HEIGHT_TOLERANCE_PX = 1.5;
 function registerParagraphFloatingExclusions(options) {
@@ -16457,93 +16481,13 @@ function paginateParagraphBlock(track, params, sourceBlock, nextBlock, index) {
     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
-      );
-      if (candidateFitHeight > remainingHeight + PARAGRAPH_FIT_HEIGHT_TOLERANCE_PX && lineEndIndex === startLineIndex && track.blocks.length > 0) {
-        break;
-      }
-      if (candidateFitHeight > remainingHeight + PARAGRAPH_FIT_HEIGHT_TOLERANCE_PX && 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 buildSegmentBlock = (originalStart, lineEndIndex, segmentHeight, segmentId) => {
     const segmentLayout = createParagraphSegmentLayout(
       paragraphLayout,
-      startLineIndex,
+      originalStart,
       lineEndIndex
     );
-    const segmentId = `${sourceBlock.id}:segment:${segmentIndex}`;
-    const isWholeParagraphSegment = startLineIndex === 0 && lineEndIndex === paragraphLayout.lines.length;
+    const isWholeParagraphSegment = originalStart === 0 && lineEndIndex === paragraphLayout.lines.length;
     const rawMeasuredHeight = getParagraphMeasuredHeight(
       measuredHeights,
       sourceBlock.id,
@@ -16552,8 +16496,8 @@ function paginateParagraphBlock(track, params, sourceBlock, nextBlock, index) {
       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({
+    const measuredHeight = collapseWithPrevious && originalStart === 0 && hasMeasuredHeight ? Math.max(0, rawMeasuredHeight - (paragraphStyle.spacingBefore ?? 0)) : rawMeasuredHeight;
+    return {
       blockId: segmentId,
       sourceBlockId: sourceBlock.id,
       blockType: sourceBlock.type,
@@ -16562,23 +16506,111 @@ function paginateParagraphBlock(track, params, sourceBlock, nextBlock, index) {
       estimatedHeight: measuredHeight,
       layout: segmentLayout,
       sourceBlock
-    });
-    track.height += measuredHeight;
-    if (startLineIndex === 0) {
-      registerParagraphFloatingExclusions({
-        track,
-        layout: segmentLayout,
-        blockTop: track.height - measuredHeight + (paragraphStyle.spacingBefore ?? 0),
-        params,
-        resolveTextBoxHeight
-      });
-    }
-    startLineIndex = lineEndIndex;
-    segmentIndex += 1;
-    if (startLineIndex < paragraphLayout.lines.length) {
-      track.flush();
+    };
+  };
+  paginateSegments(track, sourceBlock.id, {
+    hasMore: () => startLineIndex < paragraphLayout.lines.length,
+    fit(segmentId, remaining) {
+      const originalStart = startLineIndex;
+      let lineEndIndex = originalStart;
+      let segmentHeight = 0;
+      while (lineEndIndex < paragraphLayout.lines.length) {
+        const candidateLines = paragraphLayout.lines.slice(
+          originalStart,
+          lineEndIndex + 1
+        );
+        const candidateHeight = getParagraphSegmentHeight(
+          sourceBlock,
+          candidateLines,
+          originalStart === 0,
+          lineEndIndex === paragraphLayout.lines.length - 1,
+          styles,
+          !collapseWithPrevious
+        );
+        const candidateFitHeight = getParagraphSegmentFitHeight(
+          sourceBlock,
+          candidateHeight,
+          lineEndIndex === paragraphLayout.lines.length - 1,
+          styles
+        );
+        if (candidateFitHeight > remaining + PARAGRAPH_FIT_HEIGHT_TOLERANCE_PX && lineEndIndex === originalStart && track.blocks.length > 0) {
+          break;
+        }
+        if (candidateFitHeight > remaining + PARAGRAPH_FIT_HEIGHT_TOLERANCE_PX && lineEndIndex > originalStart) {
+          break;
+        }
+        segmentHeight = candidateHeight;
+        lineEndIndex += 1;
+      }
+      if (lineEndIndex === originalStart) return null;
+      if (lineEndIndex < paragraphLayout.lines.length) {
+        const widowOrphanAdjusted = applyWidowOrphanControl(
+          sourceBlock,
+          paragraphLayout.lines,
+          originalStart,
+          lineEndIndex,
+          styles,
+          !collapseWithPrevious,
+          true,
+          track.blocks.length > 0
+        );
+        lineEndIndex = widowOrphanAdjusted.endLineIndexExclusive;
+        segmentHeight = widowOrphanAdjusted.height;
+        if (lineEndIndex === originalStart) return null;
+      }
+      const block = buildSegmentBlock(
+        originalStart,
+        lineEndIndex,
+        segmentHeight,
+        segmentId
+      );
+      startLineIndex = lineEndIndex;
+      return block;
+    },
+    force(segmentId) {
+      const originalStart = startLineIndex;
+      const lineEndIndex = Math.min(
+        paragraphLayout.lines.length,
+        originalStart + 1
+      );
+      const segmentHeight = getParagraphSegmentHeight(
+        sourceBlock,
+        paragraphLayout.lines.slice(originalStart, lineEndIndex),
+        originalStart === 0,
+        lineEndIndex === paragraphLayout.lines.length,
+        styles,
+        !collapseWithPrevious
+      );
+      const block = buildSegmentBlock(
+        originalStart,
+        lineEndIndex,
+        segmentHeight,
+        segmentId
+      );
+      startLineIndex = lineEndIndex;
+      return block;
+    },
+    onBeforeFlush() {
+      if (contextualAdjustedPreviousBlock && contextualAdjustedAmount > 0) {
+        contextualAdjustedPreviousBlock.estimatedHeight += contextualAdjustedAmount;
+        track.height += contextualAdjustedAmount;
+        contextualAdjustedPreviousBlock = void 0;
+        contextualAdjustedAmount = 0;
+      }
+      collapseWithPrevious = false;
+    },
+    onAfterPush(block, si) {
+      if (si === 0) {
+        registerParagraphFloatingExclusions({
+          track,
+          layout: block.layout,
+          blockTop: track.height - block.estimatedHeight + (paragraphStyle.spacingBefore ?? 0),
+          params,
+          resolveTextBoxHeight
+        });
+      }
     }
-  }
+  });
 }
 function normalizeCellStartPositions(row, starts, legacyStarts) {
   return row.cells.map((_, cellIdx) => {
@@ -16867,139 +16899,192 @@ function paginateTableBlock(track, params, sourceBlock, index) {
     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
-        );
+  const buildTableBlock = (segmentId, startRowIndex, groupEndIndex, repeatedHeaderRowCount, segmentHeight, splitEnds, splitEndPositions, startCellPositions) => {
+    const endRowIndex = rowGroups[groupEndIndex - 1].endRowIndexExclusive;
+    const measuredSegmentHeight = (measuredHeights == null ? void 0 : measuredHeights[segmentId]) ?? segmentHeight;
+    return {
+      blockId: segmentId,
+      sourceBlockId: sourceBlock.id,
+      blockType: sourceBlock.type,
+      globalIndex: index,
+      estimatedHeight: measuredSegmentHeight,
+      tableSegment: {
+        startRowIndex,
+        endRowIndex,
+        repeatedHeaderRowCount,
+        startRowCellBlockStarts: positionsToBlockIndexes(startCellPositions),
+        endRowCellBlockEnds: splitEnds,
+        startRowCellBlockPositions: hasPartialPositions(startCellPositions) ? startCellPositions : void 0,
+        endRowCellBlockPositions: hasPartialPositions(splitEndPositions) ? splitEndPositions : void 0
+      },
+      sourceBlock
+    };
+  };
+  const advanceCursor = (groupEndIndex, isLastRowSplit, splitEnds, splitEndPositions) => {
+    if (isLastRowSplit) {
+      const lastRowIndex = rowGroups[groupEndIndex - 1].startRowIndex;
+      const lastRow = sourceBlock.rows[lastRowIndex];
+      const ends = splitEndPositions ?? (splitEnds == null ? void 0 : splitEnds.map((blockIndex) => ({ blockIndex }))) ?? [];
+      if (positionsFinishedRow(lastRow, ends)) {
+        currentCellBlockPositions = void 0;
+        groupStartIndex = groupEndIndex;
       } else {
-        candidateHeight = getTableSegmentHeight(
-          sourceBlock,
-          startRowIndex,
-          candidateEndRowIndex,
-          repeatedHeaderRowCount,
-          styles,
-          contentWidth,
-          measurer,
-          defaultTabStop
-        );
-      }
-      if (candidateHeight <= remainingHeight) {
-        segmentHeight = candidateHeight;
-        groupEndIndex += 1;
-        continue;
+        currentCellBlockPositions = ends;
+        groupStartIndex = groupEndIndex - 1;
       }
-      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) {
+    } else {
+      currentCellBlockPositions = void 0;
+      groupStartIndex = groupEndIndex;
+    }
+  };
+  paginateSegments(track, sourceBlock.id, {
+    hasMore: () => groupStartIndex < rowGroups.length,
+    fit(segmentId, remaining) {
+      const startRowIndex = rowGroups[groupStartIndex].startRowIndex;
+      const repeatedHeaderRowCount = startRowIndex > 0 ? headerRowCount : 0;
+      const startCellPositions = currentCellBlockPositions;
+      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(
-            targetRow,
-            groupEndIndex === groupStartIndex ? currentCellBlockPositions : void 0,
+            firstRow2,
+            currentCellBlockPositions,
             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 ends = firstRow2.cells.map((cell) => ({
+            blockIndex: cell.blocks.length
+          }));
+          const slicedFirstRow = buildRowSliceFromPositions(
+            firstRow2,
+            starts,
+            ends
           );
-          const canProgress = positionsProgressed(starts, ends);
-          if (canProgress) {
-            splitEnds = positionsToBlockIndexes(ends);
-            isLastRowSplit = true;
-            const slicedLastRow = buildRowSliceFromPositions(
+          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 <= remaining) {
+          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 = remaining - precedingHeight;
+          if (availableForSplitRow > 0) {
+            const starts = normalizeCellStartPositions(
               targetRow,
-              starts,
-              ends
+              groupEndIndex === groupStartIndex ? currentCellBlockPositions : void 0,
+              void 0
             );
-            const segmentRows = [
-              ...sourceBlock.rows.slice(
-                startRowIndex,
+            const ends = targetRow.cells.map(
+              (_, cellIdx) => findCellSplitEndPosition(
+                targetRow,
+                cellIdx,
+                starts[cellIdx] ?? { blockIndex: 0 },
+                availableForSplitRow,
+                styles,
+                measurer,
+                defaultTabStop,
+                contentWidth,
+                sourceBlock,
                 rowGroups[groupEndIndex].startRowIndex
-              ),
-              slicedLastRow
-            ];
-            segmentHeight = getTableSegmentHeight(
-              { ...sourceBlock, rows: segmentRows },
-              0,
-              segmentRows.length,
-              repeatedHeaderRowCount,
-              styles,
-              contentWidth,
-              measurer,
-              defaultTabStop
+              )
             );
-            splitEndPositions = ends;
-            groupEndIndex += 1;
-            break;
+            if (positionsProgressed(starts, ends)) {
+              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;
       }
-      break;
-    }
-    if (groupEndIndex === groupStartIndex && track.blocks.length > 0) {
-      track.flush();
-      continue;
-    }
-    if (groupEndIndex === groupStartIndex) {
+      if (groupEndIndex === groupStartIndex) return null;
+      const block = buildTableBlock(
+        segmentId,
+        startRowIndex,
+        groupEndIndex,
+        repeatedHeaderRowCount,
+        segmentHeight,
+        splitEnds,
+        splitEndPositions,
+        startCellPositions
+      );
+      advanceCursor(groupEndIndex, isLastRowSplit, splitEnds, splitEndPositions);
+      return block;
+    },
+    force(segmentId) {
+      const startRowIndex = rowGroups[groupStartIndex].startRowIndex;
+      const repeatedHeaderRowCount = startRowIndex > 0 ? headerRowCount : 0;
+      const startCellPositions = currentCellBlockPositions;
+      let groupEndIndex = groupStartIndex;
+      let segmentHeight = 0;
+      let splitEnds;
+      let splitEndPositions;
+      let isLastRowSplit = false;
       const targetRow = sourceBlock.rows[startRowIndex];
       const isSingleRowGroup = rowGroups[groupStartIndex].endRowIndexExclusive === startRowIndex + 1;
       const isSplitCandidate = isSingleRowGroup && canSplitTableRow(targetRow);
@@ -17034,11 +17119,7 @@ function paginateTableBlock(track, params, sourceBlock, index) {
         splitEnds = positionsToBlockIndexes(ends);
         splitEndPositions = ends;
         isLastRowSplit = true;
-        const slicedLastRow = buildRowSliceFromPositions(
-          targetRow,
-          starts,
-          ends
-        );
+        const slicedLastRow = buildRowSliceFromPositions(targetRow, starts, ends);
         segmentHeight = getTableSegmentHeight(
           { ...sourceBlock, rows: [slicedLastRow] },
           0,
@@ -17063,53 +17144,20 @@ function paginateTableBlock(track, params, sourceBlock, index) {
           defaultTabStop
         );
       }
-    }
-    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: {
+      const block = buildTableBlock(
+        segmentId,
         startRowIndex,
-        endRowIndex,
+        groupEndIndex,
         repeatedHeaderRowCount,
-        startRowCellBlockStarts: positionsToBlockIndexes(
-          currentCellBlockPositions
-        ),
-        endRowCellBlockEnds: splitEnds,
-        startRowCellBlockPositions: hasPartialPositions(
-          currentCellBlockPositions
-        ) ? currentCellBlockPositions : void 0,
-        endRowCellBlockPositions: hasPartialPositions(splitEndPositions) ? splitEndPositions : void 0
-      },
-      sourceBlock
-    });
-    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 (groupStartIndex < rowGroups.length) {
-      track.flush();
+        segmentHeight,
+        splitEnds,
+        splitEndPositions,
+        startCellPositions
+      );
+      advanceCursor(groupEndIndex, isLastRowSplit, splitEnds, splitEndPositions);
+      return block;
     }
-  }
+  });
 }
 function projectBlocksLayout(context2) {
   const columns = context2.pageSettings.columns;
@@ -17519,6 +17567,19 @@ function applyCanvasTextFeatureHints(ctx, styles, fontSizePx) {
     featureCtx.textRendering = (styles == null ? void 0 : styles.ligatures) && styles.ligatures !== "none" ? "optimizeLegibility" : "optimizeSpeed";
   }
 }
+function resolveCanvasRunPaintStyle(styles) {
+  const fontSize = (styles == null ? void 0 : styles.fontSize) ?? DEFAULT_FONT_SIZE_PX;
+  const fontFamily = resolveCanvasFontFamily(styles == null ? void 0 : styles.fontFamily);
+  const fontWeight = (styles == null ? void 0 : styles.bold) ? "700" : "400";
+  const fontStyle = (styles == null ? void 0 : styles.italic) ? "italic" : "normal";
+  const renderMetrics = resolveCanvasTextRenderMetrics(styles, fontSize);
+  return {
+    font: `${fontStyle} ${fontWeight} ${renderMetrics.fontSize}px ${fontFamily}`,
+    fillStyle: (styles == null ? void 0 : styles.color) ?? "#000000",
+    renderMetrics,
+    scale: (styles == null ? void 0 : styles.characterScale) && styles.characterScale > 0 ? styles.characterScale / 100 : 1
+  };
+}
 function resolveVerticalMode(direction) {
   switch (direction) {
     case "tbRl":
@@ -17649,10 +17710,8 @@ function layoutStackedGlyphs(paragraph, state, box, startColumn, columnsRtl = tr
       state.document.styles
     );
     const fontSize = styles.fontSize ?? DEFAULT_FONT_SIZE_PX;
-    const metrics = resolveCanvasTextRenderMetrics(styles, fontSize);
+    const { font, fillStyle: color } = resolveCanvasRunPaintStyle(styles);
     const glyphHeight = fontSize * STACK_LINE_FACTOR;
-    const font = `${styles.italic ? "italic" : "normal"} ${styles.bold ? "700" : "400"} ${metrics.fontSize}px ${resolveCanvasFontFamily(styles.fontFamily)}`;
-    const color = styles.color ?? "#000000";
     for (const char of run.text) {
       if (char === "\n") {
         newColumn();
@@ -20490,13 +20549,10 @@ function drawParagraph(ctx, paragraph, lines, state, originX, originY, onUpdate,
         (_b = paragraph.style) == null ? void 0 : _b.styleId,
         state.document.styles
       );
-      const prefixFontSize = prefixStyles.fontSize ?? DEFAULT_FONT_SIZE_PX;
-      const prefixWeight = prefixStyles.bold ? "700" : "400";
-      const prefixStyle = prefixStyles.italic ? "italic" : "normal";
-      const prefixFamily = resolveCanvasFontFamily(prefixStyles.fontFamily);
+      const { font: prefixFont, fillStyle: prefixFillStyle } = resolveCanvasRunPaintStyle(prefixStyles);
       ctx.save();
-      ctx.font = `${prefixStyle} ${prefixWeight} ${prefixFontSize}px ${prefixFamily}`;
-      ctx.fillStyle = prefixStyles.color ?? "#000000";
+      ctx.font = prefixFont;
+      ctx.fillStyle = prefixFillStyle;
       const first = line.slots[0];
       const gap = ctx.measureText(`${listPrefix} `).width;
       const labelInset = getListLabelInset(paragraph, state.document.styles);
@@ -20524,12 +20580,9 @@ function drawParagraph(ctx, paragraph, lines, state, originX, originY, onUpdate,
       const metricFamily = resolveMetricCompatibleFamily(
         styles.fontFamily ?? "Calibri"
       );
-      const fontFamily = resolveCanvasFontFamily(styles.fontFamily);
-      const fontWeight = styles.bold ? "700" : "400";
-      const fontStyle = styles.italic ? "italic" : "normal";
-      const renderMetrics = resolveCanvasTextRenderMetrics(styles, fontSize);
+      const { font, renderMetrics } = resolveCanvasRunPaintStyle(styles);
       ctx.save();
-      ctx.font = `${fontStyle} ${fontWeight} ${renderMetrics.fontSize}px ${fontFamily}`;
+      ctx.font = font;
       applyCanvasTextFeatureHints(ctx, styles, fontSize);
       logCanvasFontUse({
         requestedFamily: styles.fontFamily,
@@ -20698,18 +20751,10 @@ function drawParagraph(ctx, paragraph, lines, state, originX, originY, onUpdate,
           state.document.styles
         );
         if (!styles.hidden) {
-          const fontSize = styles.fontSize ?? DEFAULT_FONT_SIZE_PX;
-          const fontFamily = resolveCanvasFontFamily(styles.fontFamily);
-          const fontWeight = styles.bold ? "700" : "400";
-          const fontStyle = styles.italic ? "italic" : "normal";
-          const renderMetrics = resolveCanvasTextRenderMetrics(
-            styles,
-            fontSize
-          );
-          const scale = styles.characterScale && styles.characterScale > 0 ? styles.characterScale / 100 : 1;
+          const { font, fillStyle, renderMetrics, scale } = resolveCanvasRunPaintStyle(styles);
           ctx.save();
-          ctx.font = `${fontStyle} ${fontWeight} ${renderMetrics.fontSize}px ${fontFamily}`;
-          ctx.fillStyle = styles.color ?? "#000000";
+          ctx.font = font;
+          ctx.fillStyle = fillStyle;
           drawStyledText(
             ctx,
             "-",
@@ -21248,18 +21293,14 @@ function drawDropCapForParagraph(options) {
     return;
   }
   const style2 = dropCap.style;
-  const fontSize = (style2 == null ? void 0 : style2.fontSize) ?? DEFAULT_FONT_SIZE_PX;
-  const bodyLineHeight = ((_a = lines[0]) == null ? void 0 : _a.height) ?? fontSize;
-  const renderMetrics = resolveCanvasTextRenderMetrics(style2, fontSize);
-  const fontWeight = (style2 == null ? void 0 : style2.bold) ? "700" : "400";
-  const fontStyle = (style2 == null ? void 0 : style2.italic) ? "italic" : "normal";
-  const fontFamily = resolveCanvasFontFamily(style2 == null ? void 0 : style2.fontFamily);
+  const { font, fillStyle, renderMetrics } = resolveCanvasRunPaintStyle(style2);
+  const bodyLineHeight = ((_a = lines[0]) == null ? void 0 : _a.height) ?? ((style2 == null ? void 0 : style2.fontSize) ?? DEFAULT_FONT_SIZE_PX);
   const glyphWidth = measureDropCapWidth(dropCap);
   const x = dropCap.type === "margin" ? originX - glyphWidth : originX;
   const baselineY = paragraphTop + (dropCap.lines - 0.2) * bodyLineHeight + renderMetrics.baselineOffset;
   ctx.save();
-  ctx.font = `${fontStyle} ${fontWeight} ${renderMetrics.fontSize}px ${fontFamily}`;
-  ctx.fillStyle = (style2 == null ? void 0 : style2.color) ?? "#000000";
+  ctx.font = font;
+  ctx.fillStyle = fillStyle;
   ctx.textBaseline = "alphabetic";
   ctx.fillText(dropCap.text, x, baselineY);
   ctx.restore();
@@ -42671,13 +42712,13 @@ export {
   setStyleProperty as af,
   memo as ag,
   template as ah,
-  useI18n as ai,
-  createEffect as aj,
-  insert as ak,
-  use as al,
-  addEventListener as am,
-  Dialog as an,
-  delegateEvents as ao,
+  addEventListener as ai,
+  insert as aj,
+  delegateEvents as ak,
+  useI18n as al,
+  createEffect as am,
+  use as an,
+  Dialog as ao,
   className as ap,
   For as aq,
   UNDERLINE_STYLE_OPTIONS as ar,