oasis-editor 0.0.112 → 0.0.114

package/dist/{index-AX7m_SeX.js → index-CwpzM--5.js}

@@ -2539,7 +2539,7 @@ function OasisEditorAppLazy(props = {}) {
     onCleanup(() => {
       cancelled = true;
     });
-    import("./OasisEditorApp-p9k7O_1i.js").then((m) => {
+    import("./OasisEditorApp-XloOiKSu.js").then((m) => {
       cancelled = true;
       setProgress(1);
       setTimeout(() => setApp(() => m.OasisEditorApp), 180);
@@ -3057,6 +3057,88 @@ function createStore(...[store, options]) {
   }
   return [wrappedStore, setStore];
 }
+const $ROOT = Symbol("store-root");
+function applyState(target, parent, property, merge, key) {
+  const previous = parent[property];
+  if (target === previous) return;
+  const isArray = Array.isArray(target);
+  if (property !== $ROOT && (!isWrappable(target) || !isWrappable(previous) || isArray !== Array.isArray(previous) || key && target[key] !== previous[key])) {
+    setProperty(parent, property, target);
+    return;
+  }
+  if (isArray) {
+    if (target.length && previous.length && (!merge || key && target[0] && target[0][key] != null)) {
+      let i, j, start, end, newEnd, item, newIndicesNext, keyVal;
+      for (start = 0, end = Math.min(previous.length, target.length); start < end && (previous[start] === target[start] || key && previous[start] && target[start] && previous[start][key] && previous[start][key] === target[start][key]); start++) {
+        applyState(target[start], previous, start, merge, key);
+      }
+      const temp = new Array(target.length), newIndices = /* @__PURE__ */ new Map();
+      for (end = previous.length - 1, newEnd = target.length - 1; end >= start && newEnd >= start && (previous[end] === target[newEnd] || key && previous[end] && target[newEnd] && previous[end][key] && previous[end][key] === target[newEnd][key]); end--, newEnd--) {
+        temp[newEnd] = previous[end];
+      }
+      if (start > newEnd || start > end) {
+        for (j = start; j <= newEnd; j++) setProperty(previous, j, target[j]);
+        for (; j < target.length; j++) {
+          setProperty(previous, j, temp[j]);
+          applyState(target[j], previous, j, merge, key);
+        }
+        if (previous.length > target.length) setProperty(previous, "length", target.length);
+        return;
+      }
+      newIndicesNext = new Array(newEnd + 1);
+      for (j = newEnd; j >= start; j--) {
+        item = target[j];
+        keyVal = key && item ? item[key] : item;
+        i = newIndices.get(keyVal);
+        newIndicesNext[j] = i === void 0 ? -1 : i;
+        newIndices.set(keyVal, j);
+      }
+      for (i = start; i <= end; i++) {
+        item = previous[i];
+        keyVal = key && item ? item[key] : item;
+        j = newIndices.get(keyVal);
+        if (j !== void 0 && j !== -1) {
+          temp[j] = previous[i];
+          j = newIndicesNext[j];
+          newIndices.set(keyVal, j);
+        }
+      }
+      for (j = start; j < target.length; j++) {
+        if (j in temp) {
+          setProperty(previous, j, temp[j]);
+          applyState(target[j], previous, j, merge, key);
+        } else setProperty(previous, j, target[j]);
+      }
+    } else {
+      for (let i = 0, len = target.length; i < len; i++) {
+        applyState(target[i], previous, i, merge, key);
+      }
+    }
+    if (previous.length > target.length) setProperty(previous, "length", target.length);
+    return;
+  }
+  const targetKeys = Object.keys(target);
+  for (let i = 0, len = targetKeys.length; i < len; i++) {
+    applyState(target[targetKeys[i]], previous, targetKeys[i], merge, key);
+  }
+  const previousKeys = Object.keys(previous);
+  for (let i = 0, len = previousKeys.length; i < len; i++) {
+    if (target[previousKeys[i]] === void 0) setProperty(previous, previousKeys[i], void 0);
+  }
+}
+function reconcile(value, options = {}) {
+  const {
+    merge,
+    key = "id"
+  } = options, v = unwrap(value);
+  return (state) => {
+    if (!isWrappable(state) || !isWrappable(v)) return v;
+    const res = applyState(v, {
+      [$ROOT]: state
+    }, $ROOT, merge, key);
+    return res === void 0 ? state : res;
+  };
+}
 function assertNever(value, label = "value") {
   const tag = value && typeof value === "object" && "type" in value ? value.type : value;
   throw new Error(`Unhandled ${label}: ${String(tag)}`);
@@ -16271,6 +16353,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 +16563,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 +16578,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 +16588,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 +16981,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
+          );
+          candidateHeight = getTableSegmentHeight(
+            { ...sourceBlock, rows: [slicedFirstRow] },
+            0,
+            1,
+            repeatedHeaderRowCount,
+            styles,
+            contentWidth,
+            measurer,
+            defaultTabStop
+          );
+        } else {
+          candidateHeight = getTableSegmentHeight(
+            sourceBlock,
+            startRowIndex,
+            candidateEndRowIndex,
+            repeatedHeaderRowCount,
+            styles,
+            contentWidth,
+            measurer,
+            defaultTabStop
           );
-          const canProgress = positionsProgressed(starts, ends);
-          if (canProgress) {
-            splitEnds = positionsToBlockIndexes(ends);
-            isLastRowSplit = true;
-            const slicedLastRow = buildRowSliceFromPositions(
+        }
+        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 +17201,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 +17226,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 +17649,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 +17792,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();
@@ -17998,7 +18139,8 @@ function buildCanvasTableLayout(options) {
       const isStacked = verticalMode === "stack";
       const isFitText = !!((_w = cell.style) == null ? void 0 : _w.fitText) && !isRotated && !isStacked;
       const explicitRowHeightPx = parseDimensionToPx(effectiveRow.height);
-      const wrapWidth = isRotated || ((_x = cell.style) == null ? void 0 : _x.noWrap) ? isRotated && explicitRowHeightPx !== null && explicitRowHeightPx > 0 ? Math.max(
+      const hasExplicitRowHeight = explicitRowHeightPx !== null && explicitRowHeightPx > 0;
+      const wrapWidth = isRotated || ((_x = cell.style) == null ? void 0 : _x.noWrap) ? isRotated && hasExplicitRowHeight ? Math.max(
         MIN_TABLE_CELL_CONTENT_WIDTH_PX,
         explicitRowHeightPx - borders.top.width - borders.bottom.width - padding.top - padding.bottom
       ) : NO_WRAP_WIDTH_PX : contentWidthPx;
@@ -18040,7 +18182,6 @@ function buildCanvasTableLayout(options) {
             spacingBefore,
             spacingAfter
           });
-          const hasExplicitRowHeight = explicitRowHeightPx !== null && explicitRowHeightPx > 0;
           const paragraphStyleSize = ((_A = (_z = paragraph.runs[0]) == null ? void 0 : _z.styles) == null ? void 0 : _A.fontSize) ?? DEFAULT_FONT_SIZE_PX;
           contentNaturalHeightPx = Math.max(
             contentNaturalHeightPx,
@@ -18103,7 +18244,6 @@ function buildCanvasTableLayout(options) {
         });
         if (isRotated) {
           const lineThickness = projected.lines.length > 0 ? Math.max(...projected.lines.map((line) => line.height)) : paragraphHeight;
-          const hasExplicitRowHeight = explicitRowHeightPx !== null && explicitRowHeightPx > 0;
           const flowLength = projected.lines.length ? Math.max(
             ...projected.lines.map((line) => {
               const last = line.slots[line.slots.length - 1];
@@ -18273,6 +18413,35 @@ function PageBreak(props) {
     return _el$;
   })();
 }
+const HEX6_PATTERN = /^[0-9a-fA-F]{6}$/;
+function stripHashPrefix(color) {
+  return color.trim().replace(/^#/, "");
+}
+function normalizeHex6(color) {
+  if (!color) {
+    return null;
+  }
+  const body = stripHashPrefix(color);
+  return HEX6_PATTERN.test(body) ? body.toUpperCase() : null;
+}
+function parseHexColorToRgb255(color) {
+  if (!color) {
+    return null;
+  }
+  const normalized = stripHashPrefix(color);
+  if (!HEX6_PATTERN.test(normalized)) {
+    return null;
+  }
+  return [
+    Number.parseInt(normalized.slice(0, 2), 16),
+    Number.parseInt(normalized.slice(2, 4), 16),
+    Number.parseInt(normalized.slice(4, 6), 16)
+  ];
+}
+function rgb255ToHex(r, g2, b) {
+  const toHex2 = (value) => Math.max(0, Math.min(255, Math.round(value))).toString(16).padStart(2, "0");
+  return `#${toHex2(r)}${toHex2(g2)}${toHex2(b)}`;
+}
 const imageCache = /* @__PURE__ */ new Map();
 function getCachedCanvasImage(src, onUpdate) {
   const cached = imageCache.get(src);
@@ -19817,6 +19986,39 @@ function buildPresetPath(preset, x, y, width, height) {
   }
   return path;
 }
+const DEG_TO_RAD = Math.PI / 180;
+const CANVAS_DASH_DASHED = [5, 3];
+const CANVAS_DASH_DOTTED = [1, 3];
+function drawEdge(ctx, border, x1, y1, x2, y2) {
+  if (!border || border.type === "none" || border.width <= 0) {
+    return;
+  }
+  ctx.save();
+  ctx.beginPath();
+  ctx.strokeStyle = border.color;
+  ctx.lineWidth = border.width;
+  if (border.type === "dashed") {
+    ctx.setLineDash(CANVAS_DASH_DASHED);
+  } else if (border.type === "dotted") {
+    ctx.setLineDash(CANVAS_DASH_DOTTED);
+  } else {
+    ctx.setLineDash([]);
+  }
+  ctx.moveTo(x1, y1);
+  ctx.lineTo(x2, y2);
+  ctx.stroke();
+  ctx.restore();
+}
+function drawBorderBox(ctx, left, top, width, height, borders) {
+  const right = left + width;
+  const bottom = top + height;
+  drawEdge(ctx, borders.top, left, top, right, top);
+  drawEdge(ctx, borders.right, right, top, right, bottom);
+  drawEdge(ctx, borders.bottom, left, bottom, right, bottom);
+  drawEdge(ctx, borders.left, left, top, left, bottom);
+  drawEdge(ctx, borders.topLeftToBottomRight, left, top, right, bottom);
+  drawEdge(ctx, borders.topRightToBottomLeft, right, top, left, bottom);
+}
 const TEXT_BOX_AUTOFIT_MEASURE_HEIGHT = 1e5;
 const TEXT_BOX_AUTOFIT_SAFETY_PX = 2;
 function getTextBoxPadding(textBox) {
@@ -20001,7 +20203,7 @@ function paintTextBox(ctx, textBox, state, x, y, width, height, pageIndex, onUpd
   if (rotation) {
     ctx.save();
     ctx.translate(x + width / 2, y + height / 2);
-    ctx.rotate(rotation * Math.PI / 180);
+    ctx.rotate(rotation * DEG_TO_RAD);
     ctx.translate(-(x + width / 2), -(y + height / 2));
   }
   drawTextBoxShape(ctx, textBox, x, y, width, height);
@@ -20203,6 +20405,8 @@ function isDoubleUnderlineStyle(underlineStyle) {
 function isWavyUnderlineStyle(underlineStyle) {
   return underlineStyle === "wave" || underlineStyle === "wavyHeavy";
 }
+const WAVY_UNDERLINE_AMPLITUDE_PX = 1.5;
+const WAVY_UNDERLINE_WAVELENGTH_PX = 4;
 function underlineStyleLineWidthPx(underlineStyle) {
   switch (underlineStyle) {
     case "thick":
@@ -20268,42 +20472,12 @@ function underlineStyleDashArray(underlineStyle) {
       return void 0;
   }
 }
-const CANVAS_DASH_DASHED = [5, 3];
-const CANVAS_DASH_DOTTED = [1, 3];
-function drawEdge(ctx, border, x1, y1, x2, y2) {
-  if (!border || border.type === "none" || border.width <= 0) {
-    return;
-  }
-  ctx.save();
-  ctx.beginPath();
-  ctx.strokeStyle = border.color;
-  ctx.lineWidth = border.width;
-  if (border.type === "dashed") {
-    ctx.setLineDash(CANVAS_DASH_DASHED);
-  } else if (border.type === "dotted") {
-    ctx.setLineDash(CANVAS_DASH_DOTTED);
-  } else {
-    ctx.setLineDash([]);
-  }
-  ctx.moveTo(x1, y1);
-  ctx.lineTo(x2, y2);
-  ctx.stroke();
-  ctx.restore();
-}
-function drawBorderBox(ctx, left, top, width, height, borders) {
-  const right = left + width;
-  const bottom = top + height;
-  drawEdge(ctx, borders.top, left, top, right, top);
-  drawEdge(ctx, borders.right, right, top, right, bottom);
-  drawEdge(ctx, borders.bottom, left, bottom, right, bottom);
-  drawEdge(ctx, borders.left, left, top, left, bottom);
-  drawEdge(ctx, borders.topLeftToBottomRight, left, top, right, bottom);
-  drawEdge(ctx, borders.topRightToBottomLeft, right, top, left, bottom);
-}
 const DOUBLE_STRIKE_OFFSET_PX = 1.3;
 const DOUBLE_UNDERLINE_OFFSET_PX = 1.5;
-const WAVY_UNDERLINE_AMPLITUDE_PX = 1.5;
-const WAVY_UNDERLINE_WAVELENGTH_PX = 4;
+function hexToRgba(color, alpha) {
+  const [r, g2, b] = parseHexColorToRgb255(color) ?? [0, 0, 0];
+  return `rgba(${r},${g2},${b},${alpha})`;
+}
 const canvasTextLogger = createEditorLogger("canvas-text");
 const loggedCanvasFontKeys = /* @__PURE__ */ new Set();
 const MAX_CANVAS_FONT_LOGS = 40;
@@ -20382,7 +20556,7 @@ function drawImageFragment(ctx, img, image, x, y) {
     if (hasTransform) {
       ctx.translate(x + width / 2, y + height / 2);
       if (rotation) {
-        ctx.rotate(rotation * Math.PI / 180);
+        ctx.rotate(rotation * DEG_TO_RAD);
       }
       ctx.scale(flipH ? -1 : 1, flipV ? -1 : 1);
       ctx.translate(-(x + width / 2), -(y + height / 2));
@@ -20416,7 +20590,7 @@ function drawImageFragment(ctx, img, image, x, y) {
   ctx.save();
   ctx.translate(x + width / 2, y + height / 2);
   if (rotation) {
-    ctx.rotate(rotation * Math.PI / 180);
+    ctx.rotate(rotation * DEG_TO_RAD);
   }
   ctx.scale(flipH ? -1 : 1, flipV ? -1 : 1);
   ctx.drawImage(img, sx, sy, sw, sh, -width / 2, -height / 2, width, height);
@@ -20490,13 +20664,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 +20695,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 +20866,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,
             "-",
@@ -20737,11 +20897,11 @@ function drawParagraph(ctx, paragraph, lines, state, originX, originY, onUpdate,
     }
   }
 }
-function drawFragmentHighlight(ctx, line, fragment, originX, originY, color) {
+function drawFragmentColorRect(ctx, line, fragment, originX, originY, color, alpha) {
   const bounds = resolveFragmentPaintBounds(line, fragment);
   if (!bounds) return;
   ctx.save();
-  ctx.globalAlpha = 0.35;
+  if (alpha !== void 0) ctx.globalAlpha = alpha;
   ctx.fillStyle = color;
   ctx.fillRect(
     originX + bounds.left,
@@ -20751,6 +20911,9 @@ function drawFragmentHighlight(ctx, line, fragment, originX, originY, color) {
   );
   ctx.restore();
 }
+function drawFragmentHighlight(ctx, line, fragment, originX, originY, color) {
+  drawFragmentColorRect(ctx, line, fragment, originX, originY, color, 0.35);
+}
 function resolveFragmentPaintBounds(line, fragment) {
   const slotByOffset = new Map(
     line.slots.map((slot) => [slot.offset, slot])
@@ -20773,17 +20936,7 @@ function resolveFragmentPaintBounds(line, fragment) {
   };
 }
 function drawFragmentShading(ctx, line, fragment, originX, originY, color) {
-  const bounds = resolveFragmentPaintBounds(line, fragment);
-  if (!bounds) return;
-  ctx.save();
-  ctx.fillStyle = color;
-  ctx.fillRect(
-    originX + bounds.left,
-    originY + line.top + 2,
-    Math.max(0, bounds.right - bounds.left),
-    Math.max(2, line.height - 4)
-  );
-  ctx.restore();
+  drawFragmentColorRect(ctx, line, fragment, originX, originY, color);
 }
 function getRenderedChar(char, styles) {
   return styles.allCaps ? char.toUpperCase() : char;
@@ -20813,16 +20966,12 @@ function resolveCanvasTextFill(ctx, styles, line, fragment, originX, originY) {
   const cx = (x0 + x1) / 2;
   const cy = (y0 + y1) / 2;
   const angleDeg = fill.angle ?? 0;
-  const rad = angleDeg * Math.PI / 180;
+  const rad = angleDeg * DEG_TO_RAD;
   const dx = Math.cos(rad) * (x1 - x0) / 2;
   const dy = Math.sin(rad) * (y1 - y0) / 2;
   const gradient = ctx.createLinearGradient(cx - dx, cy - dy, cx + dx, cy + dy);
   for (const stop of fill.stops) {
-    const alpha = stop.alpha ?? 1;
-    const r = Number.parseInt(stop.color.slice(1, 3), 16);
-    const g2 = Number.parseInt(stop.color.slice(3, 5), 16);
-    const b = Number.parseInt(stop.color.slice(5, 7), 16);
-    gradient.addColorStop(stop.position, `rgba(${r},${g2},${b},${alpha})`);
+    gradient.addColorStop(stop.position, hexToRgba(stop.color, stop.alpha ?? 1));
   }
   return gradient;
 }
@@ -20843,23 +20992,15 @@ function drawStyledText(ctx, text, x, y, scale, styles) {
   ctx.save();
   if (styles.textShadow) {
     const ts = styles.textShadow;
-    const dirRad = ts.dirDeg * Math.PI / 180;
+    const dirRad = ts.dirDeg * DEG_TO_RAD;
     const distPx = ts.distPt * PX_PER_POINT;
-    const alpha = ts.alpha ?? 1;
-    const r = Number.parseInt(ts.color.slice(1, 3), 16);
-    const g2 = Number.parseInt(ts.color.slice(3, 5), 16);
-    const b = Number.parseInt(ts.color.slice(5, 7), 16);
-    ctx.shadowColor = `rgba(${r},${g2},${b},${alpha})`;
+    ctx.shadowColor = hexToRgba(ts.color, ts.alpha ?? 1);
     ctx.shadowBlur = ts.blurPt * PX_PER_POINT;
     ctx.shadowOffsetX = Math.cos(dirRad) * distPx;
     ctx.shadowOffsetY = Math.sin(dirRad) * distPx;
   } else if (styles.glow) {
     const gl = styles.glow;
-    const alpha = gl.alpha ?? 0.7;
-    const r = Number.parseInt(gl.color.slice(1, 3), 16);
-    const g2 = Number.parseInt(gl.color.slice(3, 5), 16);
-    const b = Number.parseInt(gl.color.slice(5, 7), 16);
-    ctx.shadowColor = `rgba(${r},${g2},${b},${alpha})`;
+    ctx.shadowColor = hexToRgba(gl.color, gl.alpha ?? 0.7);
     ctx.shadowBlur = gl.radiusPt * PX_PER_POINT;
     ctx.shadowOffsetX = 0;
     ctx.shadowOffsetY = 0;
@@ -21248,18 +21389,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();
@@ -34388,35 +34525,6 @@ function applyDocGridLinePitch(blocks, linePitchPx, mode, docGridType, settings)
     }
   }
 }
-const HEX6_PATTERN = /^[0-9a-fA-F]{6}$/;
-function stripHashPrefix(color) {
-  return color.trim().replace(/^#/, "");
-}
-function normalizeHex6(color) {
-  if (!color) {
-    return null;
-  }
-  const body = stripHashPrefix(color);
-  return HEX6_PATTERN.test(body) ? body.toUpperCase() : null;
-}
-function parseHexColorToRgb255(color) {
-  if (!color) {
-    return null;
-  }
-  const normalized = stripHashPrefix(color);
-  if (!HEX6_PATTERN.test(normalized)) {
-    return null;
-  }
-  return [
-    Number.parseInt(normalized.slice(0, 2), 16),
-    Number.parseInt(normalized.slice(2, 4), 16),
-    Number.parseInt(normalized.slice(4, 6), 16)
-  ];
-}
-function rgb255ToHex(r, g2, b) {
-  const toHex2 = (value) => Math.max(0, Math.min(255, Math.round(value))).toString(16).padStart(2, "0");
-  return `#${toHex2(r)}${toHex2(g2)}${toHex2(b)}`;
-}
 const VML_FRACTION_DENOMINATOR = 65536;
 function emuToPx(value) {
   const emu = parseOptionalInt$1(value);
@@ -36741,41 +36849,15 @@ async function importDocxToEditorDocument(buffer, options = {}) {
   );
   const hasAssets = Object.keys(assets.assets).length > 0;
   const finalize = (doc2) => {
-    if (docSettings.defaultTabStop !== void 0) {
-      doc2.settings = {
-        ...doc2.settings ?? {},
-        defaultTabStop: docSettings.defaultTabStop
-      };
-    }
-    if (docSettings.allowSpaceOfSameStyleInTable) {
-      doc2.settings = {
-        ...doc2.settings ?? {},
-        allowSpaceOfSameStyleInTable: true
-      };
-    }
-    if (docSettings.autoHyphenation) {
-      doc2.settings = {
-        ...doc2.settings ?? {},
-        autoHyphenation: true
-      };
-    }
-    if (docSettings.doNotHyphenateCaps) {
-      doc2.settings = {
-        ...doc2.settings ?? {},
-        doNotHyphenateCaps: true
-      };
-    }
-    if (docSettings.consecutiveHyphenLimit !== void 0) {
-      doc2.settings = {
-        ...doc2.settings ?? {},
-        consecutiveHyphenLimit: docSettings.consecutiveHyphenLimit
-      };
-    }
-    if (docSettings.hyphenationZone !== void 0) {
-      doc2.settings = {
-        ...doc2.settings ?? {},
-        hyphenationZone: docSettings.hyphenationZone
-      };
+    const settingsPatch = {};
+    if (docSettings.defaultTabStop !== void 0) settingsPatch.defaultTabStop = docSettings.defaultTabStop;
+    if (docSettings.allowSpaceOfSameStyleInTable) settingsPatch.allowSpaceOfSameStyleInTable = true;
+    if (docSettings.autoHyphenation) settingsPatch.autoHyphenation = true;
+    if (docSettings.doNotHyphenateCaps) settingsPatch.doNotHyphenateCaps = true;
+    if (docSettings.consecutiveHyphenLimit !== void 0) settingsPatch.consecutiveHyphenLimit = docSettings.consecutiveHyphenLimit;
+    if (docSettings.hyphenationZone !== void 0) settingsPatch.hyphenationZone = docSettings.hyphenationZone;
+    if (Object.keys(settingsPatch).length > 0) {
+      doc2.settings = { ...doc2.settings ?? {}, ...settingsPatch };
     }
     if (fontTable) {
       doc2.fontTable = fontTable;
@@ -36863,8 +36945,19 @@ function buildEditorComments(ranges, bodies) {
   }
   return order.length > 0 ? { items, order } : void 0;
 }
-function remapImportedFootnoteRefsInSections(sections, byDocxId) {
+function walkSectionBlocks(sections, visit) {
   var _a, _b, _c, _d, _e, _f;
+  for (const section of sections) {
+    section.blocks.forEach(visit);
+    (_a = section.header) == null ? void 0 : _a.forEach(visit);
+    (_b = section.firstPageHeader) == null ? void 0 : _b.forEach(visit);
+    (_c = section.evenPageHeader) == null ? void 0 : _c.forEach(visit);
+    (_d = section.footer) == null ? void 0 : _d.forEach(visit);
+    (_e = section.firstPageFooter) == null ? void 0 : _e.forEach(visit);
+    (_f = section.evenPageFooter) == null ? void 0 : _f.forEach(visit);
+  }
+}
+function remapImportedFootnoteRefsInSections(sections, byDocxId) {
   const remapBlock = (block) => {
     if (block.type === "paragraph") {
       block.runs.forEach((run, index) => {
@@ -36898,18 +36991,9 @@ function remapImportedFootnoteRefsInSections(sections, byDocxId) {
       }
     }
   };
-  for (const section of sections) {
-    section.blocks.forEach(remapBlock);
-    (_a = section.header) == null ? void 0 : _a.forEach(remapBlock);
-    (_b = section.firstPageHeader) == null ? void 0 : _b.forEach(remapBlock);
-    (_c = section.evenPageHeader) == null ? void 0 : _c.forEach(remapBlock);
-    (_d = section.footer) == null ? void 0 : _d.forEach(remapBlock);
-    (_e = section.firstPageFooter) == null ? void 0 : _e.forEach(remapBlock);
-    (_f = section.evenPageFooter) == null ? void 0 : _f.forEach(remapBlock);
-  }
+  walkSectionBlocks(sections, remapBlock);
 }
 function remapImportedEndnoteRefsInSections(sections, byDocxId) {
-  var _a, _b, _c, _d, _e, _f;
   const remapBlock = (block) => {
     if (block.type === "paragraph") {
       block.runs.forEach((run, index) => {
@@ -36943,15 +37027,7 @@ function remapImportedEndnoteRefsInSections(sections, byDocxId) {
       }
     }
   };
-  for (const section of sections) {
-    section.blocks.forEach(remapBlock);
-    (_a = section.header) == null ? void 0 : _a.forEach(remapBlock);
-    (_b = section.firstPageHeader) == null ? void 0 : _b.forEach(remapBlock);
-    (_c = section.evenPageHeader) == null ? void 0 : _c.forEach(remapBlock);
-    (_d = section.footer) == null ? void 0 : _d.forEach(remapBlock);
-    (_e = section.firstPageFooter) == null ? void 0 : _e.forEach(remapBlock);
-    (_f = section.evenPageFooter) == null ? void 0 : _f.forEach(remapBlock);
-  }
+  walkSectionBlocks(sections, remapBlock);
 }
 let nextRequestId = 1;
 function canUseDocxWorker() {
@@ -36967,7 +37043,7 @@ function importDocxInWorker(buffer, options = {}) {
     const worker = new Worker(
       new URL(
         /* @vite-ignore */
-        "" + new URL("assets/importDocxWorker-Bz2kZOBO.js", import.meta.url).href,
+        "" + new URL("assets/importDocxWorker-D0F0jbcF.js", import.meta.url).href,
         import.meta.url
       ),
       {
@@ -42625,7 +42701,7 @@ export {
   resolveImageSrc as Z,
   listKindForTag as _,
   getPageContentWidth as a,
-  getPresetPathSegments as a$,
+  resolveFloatingObjectRect as a$,
   collectInlineRuns as a0,
   parseParagraphStyle as a1,
   getRunImage as a2,
@@ -42636,33 +42712,33 @@ export {
   getCaretRectFromSnapshot as a7,
   getParagraphRectFromSnapshot as a8,
   createComponent as a9,
-  enablePreciseFontMode as aA,
-  TWIPS_PER_POINT as aB,
-  PX_PER_INCH as aC,
-  TWIPS_PER_INCH as aD,
-  normalizeHex6 as aE,
-  TABLE_CONDITIONAL_FLAG_ATTRIBUTES as aF,
-  TABLE_BORDER_EDGE_KEYS as aG,
-  resolveEffectiveParagraphStyle as aH,
-  resolveEffectiveTextStyleForParagraph as aI,
-  EMU_PER_PT as aJ,
-  OOXML_ROTATION_UNITS as aK,
-  OOXML_PERCENT_DENOMINATOR as aL,
-  parseHexColorToRgb255 as aM,
-  EMU_PER_PX as aN,
-  getRunFootnoteReference as aO,
-  getRunEndnoteReference as aP,
-  iterateFootnoteReferenceRuns as aQ,
-  iterateEndnoteReferenceRuns as aR,
-  imageContentTypeDefaults as aS,
-  getRunFieldChar as aT,
-  getRunFieldInstruction as aU,
-  createEditorRun as aV,
-  JSZip as aW,
-  imageExtensionFromMime as aX,
-  pxToPt as aY,
-  resolveFloatingObjectRect as aZ,
-  getTextBoxFloatingGeometry as a_,
+  setPreciseFontPreference as aA,
+  setWelcomeSeen as aB,
+  enablePreciseFontMode as aC,
+  TWIPS_PER_POINT as aD,
+  PX_PER_INCH as aE,
+  TWIPS_PER_INCH as aF,
+  normalizeHex6 as aG,
+  TABLE_CONDITIONAL_FLAG_ATTRIBUTES as aH,
+  TABLE_BORDER_EDGE_KEYS as aI,
+  resolveEffectiveParagraphStyle as aJ,
+  resolveEffectiveTextStyleForParagraph as aK,
+  EMU_PER_PT as aL,
+  OOXML_ROTATION_UNITS as aM,
+  OOXML_PERCENT_DENOMINATOR as aN,
+  parseHexColorToRgb255 as aO,
+  EMU_PER_PX as aP,
+  getRunFootnoteReference as aQ,
+  getRunEndnoteReference as aR,
+  iterateFootnoteReferenceRuns as aS,
+  iterateEndnoteReferenceRuns as aT,
+  imageContentTypeDefaults as aU,
+  getRunFieldChar as aV,
+  getRunFieldInstruction as aW,
+  createEditorRun as aX,
+  JSZip as aY,
+  imageExtensionFromMime as aZ,
+  pxToPt as a_,
   CaretOverlay as aa,
   Show as ab,
   createRenderEffect as ac,
@@ -42671,155 +42747,159 @@ 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,
   Tabs as as,
-  onMount as at,
-  onCleanup as au,
-  PluginUiHost as av,
-  OasisEditorEditor as aw,
-  OasisBrandMark as ax,
-  setPreciseFontPreference as ay,
-  setWelcomeSeen as az,
+  createStore as at,
+  reconcile as au,
+  onMount as av,
+  onCleanup as aw,
+  PluginUiHost as ax,
+  OasisEditorEditor as ay,
+  OasisBrandMark as az,
   getPageBodyTop as b,
-  createFootnoteReferenceRun as b$,
-  buildListLabels as b0,
-  getImageFloatingGeometry as b1,
-  textStyleToFontSizePt as b2,
-  PX_PER_POINT as b3,
-  DEFAULT_FONT_SIZE_PX as b4,
-  resolveOpenTypeFeatureTags as b5,
-  rgb255ToHex as b6,
-  isDoubleUnderlineStyle as b7,
-  isWavyUnderlineStyle as b8,
-  underlineStyleLineWidthPx as b9,
-  getDocumentParagraphs as bA,
-  getDocumentPageSettings as bB,
-  getTableCellContentWidthForParagraph as bC,
-  layoutMetricsEpoch as bD,
-  bumpLayoutMetricsEpoch as bE,
-  createCanvasLayoutSnapshotProvider as bF,
-  on as bG,
-  debounce as bH,
-  unwrap as bI,
-  perfTimer as bJ,
-  getRunTextBox as bK,
-  createEditorDocument as bL,
-  resolveResizedDimensions as bM,
-  resolveTextBoxRenderHeight as bN,
-  getToolbarStyleState as bO,
-  getCachedCanvasImage as bP,
-  measureParagraphMinContentWidthPx as bQ,
-  getEditableBlocksForZone as bR,
-  findParagraphLocation as bS,
-  createSectionBoundaryParagraph as bT,
-  normalizePageSettings as bU,
-  DEFAULT_EDITOR_PAGE_SETTINGS as bV,
-  markStart as bW,
-  markEnd as bX,
-  getParagraphEntries as bY,
-  getParagraphById as bZ,
-  createEditorFootnote as b_,
-  underlineStyleDashArray as ba,
-  resolveListLabel as bb,
-  getListLabelInset as bc,
-  getAlignedListLabelInset as bd,
-  getParagraphBorderInsets as be,
-  buildSegmentTable as bf,
-  buildCanvasTableLayout as bg,
-  resolveCanvasTableWidth as bh,
-  resolveFloatingTableRect as bi,
-  normalizeFamily as bj,
-  ROBOTO_FONT_FILES as bk,
-  loadFontAsset as bl,
-  OFFICE_COMPAT_FONT_FAMILIES as bm,
-  BinaryReader as bn,
-  buildSfnt as bo,
-  defaultFontDecoderRegistry as bp,
-  SfntFontProgram as bq,
-  collectPdfFontFamilies as br,
-  outlineFrom as bs,
-  getPageHeaderZoneTop as bt,
-  getPageColumnRects as bu,
-  findFootnoteReference as bv,
-  FOOTNOTE_MARKER_GUTTER_PX as bw,
-  resolveImporterForFile as bx,
-  getDocumentSectionsCanonical as by,
-  getDocumentParagraphsCanonical as bz,
+  markEnd as b$,
+  getTextBoxFloatingGeometry as b0,
+  getPresetPathSegments as b1,
+  buildListLabels as b2,
+  getImageFloatingGeometry as b3,
+  textStyleToFontSizePt as b4,
+  PX_PER_POINT as b5,
+  DEFAULT_FONT_SIZE_PX as b6,
+  resolveOpenTypeFeatureTags as b7,
+  rgb255ToHex as b8,
+  isDoubleUnderlineStyle as b9,
+  FOOTNOTE_MARKER_GUTTER_PX as bA,
+  resolveImporterForFile as bB,
+  getDocumentSectionsCanonical as bC,
+  getDocumentParagraphsCanonical as bD,
+  getDocumentParagraphs as bE,
+  getDocumentPageSettings as bF,
+  getTableCellContentWidthForParagraph as bG,
+  layoutMetricsEpoch as bH,
+  bumpLayoutMetricsEpoch as bI,
+  createCanvasLayoutSnapshotProvider as bJ,
+  on as bK,
+  debounce as bL,
+  unwrap as bM,
+  perfTimer as bN,
+  getRunTextBox as bO,
+  createEditorDocument as bP,
+  resolveResizedDimensions as bQ,
+  resolveTextBoxRenderHeight as bR,
+  getToolbarStyleState as bS,
+  getCachedCanvasImage as bT,
+  measureParagraphMinContentWidthPx as bU,
+  getEditableBlocksForZone as bV,
+  findParagraphLocation as bW,
+  createSectionBoundaryParagraph as bX,
+  normalizePageSettings as bY,
+  DEFAULT_EDITOR_PAGE_SETTINGS as bZ,
+  markStart as b_,
+  isWavyUnderlineStyle as ba,
+  underlineStyleLineWidthPx as bb,
+  WAVY_UNDERLINE_WAVELENGTH_PX as bc,
+  WAVY_UNDERLINE_AMPLITUDE_PX as bd,
+  underlineStyleDashArray as be,
+  resolveListLabel as bf,
+  getListLabelInset as bg,
+  getAlignedListLabelInset as bh,
+  getParagraphBorderInsets as bi,
+  buildSegmentTable as bj,
+  buildCanvasTableLayout as bk,
+  resolveCanvasTableWidth as bl,
+  resolveFloatingTableRect as bm,
+  normalizeFamily as bn,
+  ROBOTO_FONT_FILES as bo,
+  loadFontAsset as bp,
+  OFFICE_COMPAT_FONT_FAMILIES as bq,
+  BinaryReader as br,
+  buildSfnt as bs,
+  defaultFontDecoderRegistry as bt,
+  SfntFontProgram as bu,
+  collectPdfFontFamilies as bv,
+  outlineFrom as bw,
+  getPageHeaderZoneTop as bx,
+  getPageColumnRects as by,
+  findFootnoteReference as bz,
   getPageBodyBottom as c,
-  registerToolbarRenderer as c$,
-  renumberFootnotes as c0,
-  getHeadingLevel as c1,
-  preciseFontModeVersion as c2,
-  isPreciseFontModeEnabled as c3,
-  resolveNamedTextStyle as c4,
-  togglePreciseFontMode as c5,
-  nextFontSizePt as c6,
-  previousFontSizePt as c7,
-  fontSizePtToPx as c8,
-  createDefaultToolbarPreset as c9,
-  GridPicker as cA,
-  IconButton as cB,
-  Menu as cC,
-  OASIS_BUILTIN_COMMANDS as cD,
-  OASIS_MENU_ITEMS as cE,
-  OASIS_TOOLBAR_ITEMS as cF,
-  OasisEditorAppLazy as cG,
-  OasisEditorContainer as cH,
-  PluginCollection as cI,
-  Popover as cJ,
-  RIBBON_TABS as cK,
-  Select as cL,
-  SelectField as cM,
-  Separator as cN,
-  SidePanel as cO,
-  SidePanelBody as cP,
-  SidePanelFooter as cQ,
-  SidePanelHeader as cR,
-  SplitButton as cS,
-  StyleGallery as cT,
-  TextField as cU,
-  Button$1 as cV,
-  buildRibbonTabDefinitions as cW,
-  createEditorCommandBus as cX,
-  createOasisEditor as cY,
-  createOasisEditorContainer as cZ,
-  mount as c_,
-  MenuRegistry as ca,
-  createToolbarRegistry as cb,
-  Editor as cc,
-  resolveCommandRef as cd,
-  commandRefName as ce,
-  createOasisEditorClient as cf,
-  createEditorZoom as cg,
-  startLongTaskObserver as ch,
-  installGlobalReport as ci,
-  applyStoredPreciseFontPreference as cj,
-  getWelcomeSeen as ck,
-  isLocalFontAccessSupported as cl,
-  EDITOR_SCROLL_PADDING_PX as cm,
-  Toolbar as cn,
-  OasisEditorLoading as co,
-  I18nProvider as cp,
-  createTranslator as cq,
-  createEditorLogger as cr,
-  registerDomStatsSurface as cs,
-  Button as ct,
-  Checkbox as cu,
-  ColorPicker as cv,
-  CommandRegistry as cw,
-  DEFAULT_PALETTE as cx,
-  DialogFooter as cy,
-  FloatingActionButton as cz,
+  createEditorCommandBus as c$,
+  getParagraphEntries as c0,
+  getParagraphById as c1,
+  createEditorFootnote as c2,
+  createFootnoteReferenceRun as c3,
+  renumberFootnotes as c4,
+  getHeadingLevel as c5,
+  preciseFontModeVersion as c6,
+  isPreciseFontModeEnabled as c7,
+  resolveNamedTextStyle as c8,
+  togglePreciseFontMode as c9,
+  CommandRegistry as cA,
+  DEFAULT_PALETTE as cB,
+  DialogFooter as cC,
+  FloatingActionButton as cD,
+  GridPicker as cE,
+  IconButton as cF,
+  Menu as cG,
+  OASIS_BUILTIN_COMMANDS as cH,
+  OASIS_MENU_ITEMS as cI,
+  OASIS_TOOLBAR_ITEMS as cJ,
+  OasisEditorAppLazy as cK,
+  OasisEditorContainer as cL,
+  PluginCollection as cM,
+  Popover as cN,
+  RIBBON_TABS as cO,
+  Select as cP,
+  SelectField as cQ,
+  Separator as cR,
+  SidePanel as cS,
+  SidePanelBody as cT,
+  SidePanelFooter as cU,
+  SidePanelHeader as cV,
+  SplitButton as cW,
+  StyleGallery as cX,
+  TextField as cY,
+  Button$1 as cZ,
+  buildRibbonTabDefinitions as c_,
+  nextFontSizePt as ca,
+  previousFontSizePt as cb,
+  fontSizePtToPx as cc,
+  createDefaultToolbarPreset as cd,
+  MenuRegistry as ce,
+  createToolbarRegistry as cf,
+  Editor as cg,
+  resolveCommandRef as ch,
+  commandRefName as ci,
+  createOasisEditorClient as cj,
+  createEditorZoom as ck,
+  startLongTaskObserver as cl,
+  installGlobalReport as cm,
+  applyStoredPreciseFontPreference as cn,
+  getWelcomeSeen as co,
+  isLocalFontAccessSupported as cp,
+  EDITOR_SCROLL_PADDING_PX as cq,
+  Toolbar as cr,
+  OasisEditorLoading as cs,
+  I18nProvider as ct,
+  createTranslator as cu,
+  createEditorLogger as cv,
+  registerDomStatsSurface as cw,
+  Button as cx,
+  Checkbox as cy,
+  ColorPicker as cz,
   domTextMeasurer as d,
+  createOasisEditor as d0,
+  createOasisEditorContainer as d1,
+  mount as d2,
+  registerToolbarRenderer as d3,
   estimateTableBlockHeight as e,
   getFootnoteDisplayMarker as f,
   getProjectedParagraphBlockHeight as g,