@superdoc-dev/cli 0.3.0-next.49 → 0.3.0-next.50

package/dist/index.js

@@ -148850,7 +148850,7 @@ var init_remark_gfm_CjV8kaUy_es = __esm(() => {
   init_remark_gfm_z_sDF4ss_es();
 });
 
-// ../../packages/superdoc/dist/chunks/src-BeJRbQ1S.es.js
+// ../../packages/superdoc/dist/chunks/src-BS_QWHti.es.js
 function deleteProps(obj, propOrProps) {
   const props = typeof propOrProps === "string" ? [propOrProps] : propOrProps;
   const removeNested = (target, pathParts, index2 = 0) => {
@@ -186456,6 +186456,266 @@ function layoutDrawingBlock({ block, measure, columns, ensurePage, advanceColumn
   state.page.fragments.push(fragment2);
   state.cursorY += requiredHeight;
 }
+function describeCellRenderBlocks(cellMeasure, cellBlock, cellPadding) {
+  const measuredBlocks = cellMeasure.blocks;
+  const blockDataArray = cellBlock?.blocks;
+  if (!measuredBlocks || measuredBlocks.length === 0) {
+    if (cellMeasure.paragraph)
+      return buildSingleParagraphBlock(cellMeasure.paragraph, cellBlock?.paragraph, cellPadding);
+    return [];
+  }
+  const result = [];
+  let globalLine = 0;
+  const blockCount = measuredBlocks.length;
+  for (let i4 = 0;i4 < blockCount; i4++) {
+    const measure = measuredBlocks[i4];
+    const data = i4 < (blockDataArray?.length ?? 0) ? blockDataArray[i4] : undefined;
+    const isFirstBlock = i4 === 0;
+    const isLastBlock = i4 === blockCount - 1;
+    if (measure.kind === "paragraph") {
+      const paraMeasure = measure;
+      const paraData = data?.kind === "paragraph" ? data : undefined;
+      const lines = paraMeasure.lines ?? [];
+      const lineHeights = lines.map((l) => l.lineHeight);
+      const sumLines = sumArray(lineHeights);
+      const spacingBefore = effectiveTableCellSpacing(paraData?.attrs?.spacing?.before, isFirstBlock, cellPadding.top);
+      const rawAfter = paraData?.attrs?.spacing?.after;
+      const spacingAfter = isLastBlock ? 0 : typeof rawAfter === "number" && rawAfter > 0 ? rawAfter : 0;
+      const startLine = globalLine;
+      globalLine += lines.length;
+      result.push({
+        kind: "paragraph",
+        globalStartLine: startLine,
+        globalEndLine: globalLine,
+        lineHeights,
+        totalHeight: paraMeasure.totalHeight ?? sumLines,
+        visibleHeight: sumLines,
+        isFirstBlock,
+        isLastBlock,
+        spacingBefore,
+        spacingAfter
+      });
+    } else if (measure.kind === "table") {
+      const tableMeasure = measure;
+      const lineHeights = [];
+      for (const row2 of tableMeasure.rows)
+        for (const seg of getEmbeddedRowLines(row2))
+          lineHeights.push(seg.lineHeight);
+      const startLine = globalLine;
+      globalLine += lineHeights.length;
+      const sumLines = sumArray(lineHeights);
+      result.push({
+        kind: "table",
+        globalStartLine: startLine,
+        globalEndLine: globalLine,
+        lineHeights,
+        totalHeight: sumLines,
+        visibleHeight: sumLines,
+        isFirstBlock,
+        isLastBlock,
+        spacingBefore: 0,
+        spacingAfter: 0
+      });
+    } else {
+      const blockHeight = "height" in measure ? measure.height : 0;
+      if (blockHeight > 0) {
+        const outOfFlow = isAnchoredOutOfFlow(data);
+        const startLine = globalLine;
+        globalLine += 1;
+        result.push({
+          kind: "other",
+          globalStartLine: startLine,
+          globalEndLine: globalLine,
+          lineHeights: [blockHeight],
+          totalHeight: outOfFlow ? 0 : blockHeight,
+          visibleHeight: outOfFlow ? 0 : blockHeight,
+          isFirstBlock,
+          isLastBlock,
+          spacingBefore: 0,
+          spacingAfter: 0
+        });
+      }
+    }
+  }
+  return result;
+}
+function computeCellSliceContentHeight(blocks2, fromLine, toLine) {
+  let height = 0;
+  for (const block of blocks2) {
+    if (block.globalEndLine <= fromLine || block.globalStartLine >= toLine)
+      continue;
+    const localStart = Math.max(0, fromLine - block.globalStartLine);
+    const localEnd = Math.min(block.lineHeights.length, toLine - block.globalStartLine);
+    const rendersEntireBlock = localStart === 0 && localEnd >= block.lineHeights.length;
+    if (block.kind === "paragraph") {
+      if (localStart === 0)
+        height += block.spacingBefore;
+      let sliceLineSum = 0;
+      for (let i4 = localStart;i4 < localEnd; i4++)
+        sliceLineSum += block.lineHeights[i4];
+      if (rendersEntireBlock) {
+        height += Math.max(sliceLineSum, block.totalHeight);
+        height += block.spacingAfter;
+      } else
+        height += sliceLineSum;
+    } else {
+      if (block.visibleHeight === 0)
+        continue;
+      for (let i4 = localStart;i4 < localEnd; i4++)
+        height += block.lineHeights[i4];
+    }
+  }
+  return height;
+}
+function createCellSliceCursor(blocks2, startLine) {
+  let blockIdx = 0;
+  let startedFromLine0 = false;
+  let blockLineSum = 0;
+  while (blockIdx < blocks2.length && blocks2[blockIdx].globalEndLine <= startLine)
+    blockIdx++;
+  if (blockIdx < blocks2.length) {
+    const block = blocks2[blockIdx];
+    startedFromLine0 = startLine <= block.globalStartLine;
+    if (!startedFromLine0)
+      for (let li2 = 0;li2 < startLine - block.globalStartLine; li2++)
+        blockLineSum += block.lineHeights[li2] ?? 0;
+  }
+  return {
+    advanceLine(globalLineIndex) {
+      while (blockIdx < blocks2.length && blocks2[blockIdx].globalEndLine <= globalLineIndex) {
+        blockIdx++;
+        startedFromLine0 = true;
+        blockLineSum = 0;
+      }
+      if (blockIdx >= blocks2.length)
+        return 0;
+      const block = blocks2[blockIdx];
+      const localLine = globalLineIndex - block.globalStartLine;
+      const lineHeight = block.lineHeights[localLine] ?? 0;
+      let cost = 0;
+      if (localLine === 0 && startedFromLine0 && block.kind === "paragraph")
+        cost += block.spacingBefore;
+      if (block.kind === "paragraph" || block.visibleHeight > 0)
+        cost += lineHeight;
+      blockLineSum += lineHeight;
+      const isBlockComplete = localLine === block.lineHeights.length - 1;
+      if (isBlockComplete && startedFromLine0 && block.kind === "paragraph") {
+        cost += Math.max(0, block.totalHeight - blockLineSum);
+        cost += block.spacingAfter;
+      }
+      if (isBlockComplete) {
+        blockIdx++;
+        startedFromLine0 = true;
+        blockLineSum = 0;
+      }
+      return cost;
+    },
+    minSegmentCost(globalLineIndex) {
+      const block = findBlockForLine(blocks2, globalLineIndex);
+      if (!block)
+        return 0;
+      const localLine = globalLineIndex - block.globalStartLine;
+      const lineHeight = block.lineHeights[localLine] ?? 0;
+      let cost = 0;
+      if (localLine === 0 && block.kind === "paragraph")
+        cost += block.spacingBefore;
+      if (block.kind === "paragraph" || block.visibleHeight > 0)
+        cost += lineHeight;
+      if (block.lineHeights.length === 1 && block.kind === "paragraph") {
+        cost += Math.max(0, block.totalHeight - lineHeight);
+        cost += block.spacingAfter;
+      }
+      return cost;
+    }
+  };
+}
+function computeFullCellContentHeight(cellMeasure, cellBlock, cellPadding) {
+  const measuredBlocks = cellMeasure.blocks;
+  const blockDataArray = cellBlock?.blocks;
+  if (!measuredBlocks || measuredBlocks.length === 0) {
+    if (cellMeasure.paragraph) {
+      const pm = cellMeasure.paragraph;
+      let sumLines = 0;
+      for (const l of pm.lines)
+        sumLines += l.lineHeight;
+      const paraData = cellBlock?.paragraph;
+      const spacingBefore = effectiveTableCellSpacing(paraData?.attrs?.spacing?.before, true, cellPadding.top);
+      const spacingAfter = effectiveTableCellSpacing(paraData?.attrs?.spacing?.after, true, cellPadding.bottom);
+      return spacingBefore + Math.max(sumLines, pm.totalHeight ?? sumLines) + spacingAfter;
+    }
+    return 0;
+  }
+  let height = 0;
+  const blockCount = measuredBlocks.length;
+  for (let i4 = 0;i4 < blockCount; i4++) {
+    const measure = measuredBlocks[i4];
+    const data = i4 < (blockDataArray?.length ?? 0) ? blockDataArray[i4] : undefined;
+    const isFirstBlock = i4 === 0;
+    const isLastBlock = i4 === blockCount - 1;
+    if (measure.kind === "paragraph") {
+      const pm = measure;
+      const paraData = data?.kind === "paragraph" ? data : undefined;
+      let sumLines = 0;
+      for (const l of pm.lines ?? [])
+        sumLines += l.lineHeight;
+      height += effectiveTableCellSpacing(paraData?.attrs?.spacing?.before, isFirstBlock, cellPadding.top);
+      height += Math.max(sumLines, pm.totalHeight ?? sumLines);
+      if (!isLastBlock) {
+        const rawAfter = paraData?.attrs?.spacing?.after;
+        if (typeof rawAfter === "number" && rawAfter > 0)
+          height += rawAfter;
+      } else
+        height += effectiveTableCellSpacing(paraData?.attrs?.spacing?.after, true, cellPadding.bottom);
+    } else if (measure.kind === "table") {
+      const tm = measure;
+      for (const row2 of tm.rows)
+        height += row2.height;
+    } else {
+      const blockHeight = "height" in measure ? measure.height : 0;
+      if (blockHeight > 0 && !isAnchoredOutOfFlow(data))
+        height += blockHeight;
+    }
+  }
+  return height;
+}
+function buildSingleParagraphBlock(paraMeasure, paraData, cellPadding) {
+  const lines = paraMeasure.lines ?? [];
+  if (lines.length === 0)
+    return [];
+  const lineHeights = lines.map((l) => l.lineHeight);
+  const sumLines = sumArray(lineHeights);
+  return [{
+    kind: "paragraph",
+    globalStartLine: 0,
+    globalEndLine: lines.length,
+    lineHeights,
+    totalHeight: paraMeasure.totalHeight ?? sumLines,
+    visibleHeight: sumLines,
+    isFirstBlock: true,
+    isLastBlock: true,
+    spacingBefore: effectiveTableCellSpacing(paraData?.attrs?.spacing?.before, true, cellPadding.top),
+    spacingAfter: 0
+  }];
+}
+function isAnchoredOutOfFlow(block) {
+  if (!block || typeof block !== "object")
+    return false;
+  const b$1 = block;
+  if (!b$1.anchor?.isAnchored)
+    return false;
+  return (b$1.wrap?.type ?? "Inline") !== "Inline";
+}
+function findBlockForLine(blocks2, globalLineIndex) {
+  for (const block of blocks2)
+    if (globalLineIndex >= block.globalStartLine && globalLineIndex < block.globalEndLine)
+      return block;
+}
+function sumArray(arr) {
+  let total = 0;
+  for (const v of arr)
+    total += v;
+  return total;
+}
 function getTableIndentWidth(attrs) {
   if (!attrs)
     return 0;
@@ -186599,34 +186859,24 @@ function sumRowHeights(rows, fromRow, toRow) {
     total += rows[i4].height;
   return total;
 }
-function calculateFragmentHeight(fragment2, measure, _headerCount, borderCollapse) {
+function computeFragmentHeight(measure, fromRow, toRow, repeatHeaderCount, borderCollapse, partialRow) {
   let height = 0;
   let rowCount = 0;
-  if (fragment2.repeatHeaderCount && fragment2.repeatHeaderCount > 0) {
-    height += sumRowHeights(measure.rows, 0, fragment2.repeatHeaderCount);
-    rowCount += fragment2.repeatHeaderCount;
+  if (repeatHeaderCount > 0) {
+    height += sumRowHeights(measure.rows, 0, repeatHeaderCount);
+    rowCount += repeatHeaderCount;
   }
-  const bodyRowCount = fragment2.toRow - fragment2.fromRow;
-  height += sumRowHeights(measure.rows, fragment2.fromRow, fragment2.toRow);
-  rowCount += bodyRowCount;
-  const cellSpacingPx = measure.cellSpacingPx ?? 0;
-  if (rowCount > 0 && cellSpacingPx > 0)
-    height += (rowCount + 1) * cellSpacingPx;
-  if (rowCount > 0 && measure.tableBorderWidths && borderCollapse === "separate") {
-    const borderWidthV = measure.tableBorderWidths.top + measure.tableBorderWidths.bottom;
-    height += borderWidthV;
+  for (let i4 = fromRow;i4 < toRow && i4 < measure.rows.length; i4++) {
+    if (partialRow && partialRow.rowIndex === i4)
+      height += partialRow.partialHeight;
+    else
+      height += measure.rows[i4].height;
+    rowCount++;
   }
-  return height;
-}
-function calculateBodyFragmentHeight(measure, fromRow, toRow, borderCollapse) {
-  const rowCount = toRow - fromRow;
-  if (rowCount <= 0)
-    return 0;
-  let height = sumRowHeights(measure.rows, fromRow, toRow);
   const cellSpacingPx = measure.cellSpacingPx ?? 0;
-  if (cellSpacingPx > 0)
+  if (rowCount > 0 && cellSpacingPx > 0)
     height += (rowCount + 1) * cellSpacingPx;
-  if (measure.tableBorderWidths && borderCollapse === "separate")
+  if (rowCount > 0 && measure.tableBorderWidths && borderCollapse === "separate")
     height += measure.tableBorderWidths.top + measure.tableBorderWidths.bottom;
   return height;
 }
@@ -186684,8 +186934,9 @@ function getRowContentHeight(blockRow, rowMeasure) {
     const cell2 = rowMeasure.cells[cellIdx];
     const cellPadding = getCellPadding(cellIdx, blockRow);
     const paddingTotal = cellPadding.top + cellPadding.bottom;
-    const linesHeight = getCellLines(cell2).reduce((sum, line) => sum + (line.lineHeight || 0), 0);
-    contentHeight = Math.max(contentHeight, linesHeight + paddingTotal);
+    const cellBlock = blockRow?.cells?.[cellIdx];
+    const sliceHeight = computeFullCellContentHeight(cell2, cellBlock, cellPadding);
+    contentHeight = Math.max(contentHeight, sliceHeight + paddingTotal);
   }
   return contentHeight;
 }
@@ -186807,19 +187058,21 @@ function computePartialRow(rowIndex, blockRow, measure, availableHeight, fromLin
     const startLine = startLines[cellIdx] || 0;
     const cellPadding = cellPaddings[cellIdx];
     const availableForLines = Math.max(0, availableHeight - (cellPadding.top + cellPadding.bottom));
+    const cellBlock = blockRow?.cells?.[cellIdx];
+    const cursor = createCellSliceCursor(describeCellRenderBlocks(cell2, cellBlock, cellPadding), startLine);
     const lines = getCellLines(cell2);
     let cumulativeHeight = 0;
     let cutLine = startLine;
     for (let i4 = startLine;i4 < lines.length; i4++) {
-      const lineHeight = lines[i4].lineHeight || 0;
-      if (cumulativeHeight + lineHeight > availableForLines) {
-        if (cumulativeHeight === 0 && i4 === startLine && availableForLines > 0 && fullPageHeight != null && lineHeight > fullPageHeight) {
-          cumulativeHeight += Math.min(lineHeight, availableForLines);
+      const lineCost = cursor.advanceLine(i4);
+      if (cumulativeHeight + lineCost > availableForLines) {
+        if (cumulativeHeight === 0 && i4 === startLine && availableForLines > 0 && fullPageHeight != null && cursor.minSegmentCost(i4) > fullPageHeight) {
+          cumulativeHeight += Math.min(lineCost, availableForLines);
           cutLine = i4 + 1;
         }
         break;
       }
-      cumulativeHeight += lineHeight;
+      cumulativeHeight += lineCost;
       cutLine = i4 + 1;
     }
     toLineByCell.push(cutLine);
@@ -186867,12 +187120,12 @@ function findSplitPoint(block, measure, startRow, availableHeight, fullPageHeigh
         if (rs > 1)
           maxRowspanEnd = Math.max(maxRowspanEnd, i4 + rs);
       }
-    if (calculateBodyFragmentHeight(measure, startRow, i4 + 1, borderCollapse) <= availableHeight) {
+    if (computeFragmentHeight(measure, startRow, i4 + 1, 0, borderCollapse) <= availableHeight) {
       lastFitRow = i4 + 1;
       if (maxRowspanEnd <= i4 + 1)
         lastCleanFitRow = i4 + 1;
     } else {
-      let remainingHeight = availableHeight - calculateBodyFragmentHeight(measure, startRow, lastFitRow, borderCollapse);
+      let remainingHeight = availableHeight - computeFragmentHeight(measure, startRow, lastFitRow, 0, borderCollapse);
       if (lastFitRow === startRow) {
         const cellSpacingPx = measure.cellSpacingPx ?? 0;
         const topBorderPx = borderCollapse === "separate" && measure.tableBorderWidths ? measure.tableBorderWidths.top : 0;
@@ -186983,7 +187236,9 @@ function layoutTableBlock({ block, measure, columnWidth, ensurePage, advanceColu
     return;
   }
   const headerCount = countHeaderRows(block);
-  const headerHeight = headerCount > 0 ? sumRowHeights(measure.rows, 0, headerCount) : 0;
+  const headerPrefixHeights = [0];
+  for (let i4 = 0;i4 < headerCount; i4 += 1)
+    headerPrefixHeights.push(headerPrefixHeights[i4] + (measure.rows[i4]?.height ?? 0));
   let state = ensurePage();
   const availableHeight = state.contentBottom - state.cursorY;
   const hasPriorFragments = state.page.fragments.length > 0;
@@ -187037,30 +187292,44 @@ function layoutTableBlock({ block, measure, columnWidth, ensurePage, advanceColu
     return;
   }
   const borderCollapse = block.attrs?.borderCollapse ?? (block.attrs?.cellSpacing != null ? "separate" : "collapse");
+  const getRepeatedHeaderHeight = (repeatCount) => {
+    return headerPrefixHeights[Math.max(0, Math.min(repeatCount, headerCount))] ?? 0;
+  };
+  let samePagePartialContinuation = false;
+  let retryWithoutHeaders = false;
   while (currentRow < block.rows.length || pendingPartialRow !== null) {
     state = ensurePage();
     const availableHeight$1 = state.contentBottom - state.cursorY;
     let repeatHeaderCount = 0;
-    if (currentRow === 0 && !pendingPartialRow)
+    if (retryWithoutHeaders) {
+      repeatHeaderCount = 0;
+      retryWithoutHeaders = false;
+    } else if (currentRow === 0 && !pendingPartialRow)
       repeatHeaderCount = 0;
-    else if (headerCount > 0 && headerHeight <= availableHeight$1)
-      repeatHeaderCount = headerCount;
-    else if (headerCount > 0 && headerHeight > availableHeight$1)
+    else if (samePagePartialContinuation)
       repeatHeaderCount = 0;
+    else {
+      const candidateRepeatHeaderCount = pendingPartialRow && pendingPartialRow.rowIndex < headerCount ? pendingPartialRow.rowIndex : headerCount;
+      const candidateHeaderHeight = getRepeatedHeaderHeight(candidateRepeatHeaderCount);
+      if (candidateRepeatHeaderCount > 0 && candidateHeaderHeight < availableHeight$1)
+        repeatHeaderCount = candidateRepeatHeaderCount;
+    }
+    samePagePartialContinuation = false;
     if (repeatHeaderCount > 0 && !pendingPartialRow) {
       const bodyRow = block.rows[currentRow];
       const bodyRowHeight = measure.rows[currentRow]?.height || 0;
       const bodyCantSplit = bodyRow?.attrs?.tableRowProperties?.cantSplit === true;
-      const spaceWithHeaders = availableHeight$1 - headerHeight;
+      const spaceWithHeaders = availableHeight$1 - getRepeatedHeaderHeight(repeatHeaderCount);
       if (bodyCantSplit && bodyRowHeight > spaceWithHeaders && bodyRowHeight <= availableHeight$1)
         repeatHeaderCount = 0;
     }
-    const availableForBody = repeatHeaderCount > 0 ? availableHeight$1 - headerHeight : availableHeight$1;
-    const fullPageHeight = state.contentBottom - (state.topMargin ?? 0);
+    const repeatedHeaderHeight = getRepeatedHeaderHeight(repeatHeaderCount);
+    const availableForBody = availableHeight$1 - repeatedHeaderHeight;
+    const fullPageHeightForBody = state.contentBottom - (state.topMargin ?? 0) - repeatedHeaderHeight;
     if (pendingPartialRow !== null) {
       const rowIndex = pendingPartialRow.rowIndex;
       const fromLineByCell = pendingPartialRow.toLineByCell;
-      const continuationPartialRow = computePartialRow(rowIndex, block.rows[rowIndex], measure, availableForBody, fromLineByCell, fullPageHeight);
+      const continuationPartialRow = computePartialRow(rowIndex, block.rows[rowIndex], measure, availableForBody, fromLineByCell, fullPageHeightForBody);
       const madeProgress = continuationPartialRow.toLineByCell.some((toLine, idx) => toLine > (fromLineByCell[idx] || 0));
       const hasRemainingLinesAfterContinuation = continuationPartialRow.toLineByCell.some((toLine, idx) => {
         return toLine < getCellTotalLines(measure.rows[rowIndex].cells[idx]);
@@ -187068,7 +187337,7 @@ function layoutTableBlock({ block, measure, columnWidth, ensurePage, advanceColu
       const hadRemainingLinesBefore = fromLineByCell.some((fromLine, idx) => {
         return fromLine < getCellTotalLines(measure.rows[rowIndex].cells[idx]);
       });
-      const fragmentHeight$1 = continuationPartialRow.partialHeight + (repeatHeaderCount > 0 ? headerHeight : 0);
+      const fragmentHeight$1 = computeFragmentHeight(measure, rowIndex, rowIndex + 1, repeatHeaderCount, borderCollapse, continuationPartialRow);
       if (fragmentHeight$1 > 0 && madeProgress) {
         const { x: x$1, width: width$1 } = resolveTableFrame(columnX(state.columnIndex), columnWidth, Math.min(columnWidth, measure.totalWidth || columnWidth), block.attrs);
         const scaledWidths$1 = rescaleColumnWidths(measure.columnWidths, measure.totalWidth, width$1);
@@ -187096,22 +187365,34 @@ function layoutTableBlock({ block, measure, columnWidth, ensurePage, advanceColu
         currentRow = rowIndex + 1;
         pendingPartialRow = null;
       } else if (!madeProgress && hadRemainingLinesBefore)
-        state = advanceColumn(state);
-      else
+        if (repeatHeaderCount > 0)
+          retryWithoutHeaders = true;
+        else
+          state = advanceColumn(state);
+      else {
         pendingPartialRow = continuationPartialRow;
+        samePagePartialContinuation = true;
+      }
       isTableContinuation = true;
       continue;
     }
     const bodyStartRow = currentRow;
-    const { endRow, partialRow, forcePageBreak } = findSplitPoint(block, measure, bodyStartRow, availableForBody, fullPageHeight);
+    const { endRow, partialRow, forcePageBreak } = findSplitPoint(block, measure, bodyStartRow, availableForBody, fullPageHeightForBody);
     if (endRow === bodyStartRow && partialRow === null && state.page.fragments.length > 0) {
       state = advanceColumn(state);
       continue;
     }
     if (endRow === bodyStartRow && partialRow === null) {
-      const forcedPartialRow = computePartialRow(bodyStartRow, block.rows[bodyStartRow], measure, availableForBody, undefined, fullPageHeight);
+      const forcedPartialRow = computePartialRow(bodyStartRow, block.rows[bodyStartRow], measure, availableForBody, undefined, fullPageHeightForBody);
+      if (!forcedPartialRow.toLineByCell.some((cutLine) => cutLine > 0)) {
+        if (repeatHeaderCount > 0)
+          retryWithoutHeaders = true;
+        else
+          state = advanceColumn(state);
+        continue;
+      }
       const forcedEndRow = bodyStartRow + 1;
-      const fragmentHeight$1 = forcedPartialRow.partialHeight + (repeatHeaderCount > 0 ? headerHeight : 0);
+      const fragmentHeight$1 = computeFragmentHeight(measure, bodyStartRow, forcedEndRow, repeatHeaderCount, borderCollapse, forcedPartialRow);
       const { x: x$1, width: width$1 } = resolveTableFrame(columnX(state.columnIndex), columnWidth, Math.min(columnWidth, measure.totalWidth || columnWidth), block.attrs);
       const scaledWidths$1 = rescaleColumnWidths(measure.columnWidths, measure.totalWidth, width$1);
       const fragment$1 = {
@@ -187134,18 +187415,11 @@ function layoutTableBlock({ block, measure, columnWidth, ensurePage, advanceColu
       state.page.fragments.push(fragment$1);
       state.cursorY += fragmentHeight$1;
       pendingPartialRow = forcedPartialRow;
+      samePagePartialContinuation = true;
       isTableContinuation = true;
       continue;
     }
-    let fragmentHeight;
-    if (partialRow)
-      fragmentHeight = sumRowHeights(measure.rows, bodyStartRow, endRow - 1) + partialRow.partialHeight + (repeatHeaderCount > 0 ? headerHeight : 0);
-    else
-      fragmentHeight = calculateFragmentHeight({
-        fromRow: bodyStartRow,
-        toRow: endRow,
-        repeatHeaderCount
-      }, measure, headerCount, borderCollapse);
+    const fragmentHeight = computeFragmentHeight(measure, bodyStartRow, endRow, repeatHeaderCount, borderCollapse, partialRow);
     const { x, width } = resolveTableFrame(columnX(state.columnIndex), columnWidth, Math.min(columnWidth, measure.totalWidth || columnWidth), block.attrs);
     const scaledWidths = rescaleColumnWidths(measure.columnWidths, measure.totalWidth, width);
     const fragment2 = {
@@ -187177,6 +187451,8 @@ function layoutTableBlock({ block, measure, columnWidth, ensurePage, advanceColu
     isTableContinuation = true;
     if (forcePageBreak && currentRow < block.rows.length)
       state = advanceColumn(state);
+    else if (pendingPartialRow)
+      samePagePartialContinuation = true;
   }
 }
 function createAnchoredTableFragment(block, measure, x, y$1) {
@@ -196115,22 +196391,28 @@ function selectionToRects(layout, blocks2, measures, from$1, to, geometryHelper)
             const cellX = calculateCellX(cellIdx, cellMeasure);
             const cellBlocks = getCellBlocks(cell2);
             const cellBlockMeasures = getCellMeasures(cellMeasure);
+            const cellRenderBlocks = describeCellRenderBlocks(cellMeasure, cell2, padding);
+            const totalCellLines = cellRenderBlocks.length > 0 ? cellRenderBlocks[cellRenderBlocks.length - 1].globalEndLine : 0;
+            const cellAllowedStart = partialRowData?.fromLineByCell?.[cellIdx] ?? 0;
+            const rawCellAllowedEnd = partialRowData?.toLineByCell?.[cellIdx];
+            const cellAllowedEnd = rawCellAllowedEnd == null || rawCellAllowedEnd === -1 ? totalCellLines : rawCellAllowedEnd;
             const renderedBlocks = [];
             let cumulativeLine = 0;
-            for (let i4 = 0;i4 < Math.min(cellBlocks.length, cellBlockMeasures.length); i4 += 1) {
+            const blockCount = Math.min(cellBlocks.length, cellBlockMeasures.length);
+            for (let i4 = 0;i4 < blockCount; i4 += 1) {
               const paraBlock = cellBlocks[i4];
               const paraMeasure = cellBlockMeasures[i4];
-              if (!paraBlock || !paraMeasure || paraBlock.kind !== "paragraph" || paraMeasure.kind !== "paragraph")
+              if (!paraBlock || !paraMeasure || paraBlock.kind !== "paragraph" || paraMeasure.kind !== "paragraph") {
+                if (paraMeasure)
+                  cumulativeLine += countBlockSegments(paraMeasure);
                 continue;
+              }
               const lineCount = paraMeasure.lines.length;
               const blockStart = cumulativeLine;
               const blockEnd = cumulativeLine + lineCount;
               cumulativeLine = blockEnd;
-              const allowedStart = partialRowData?.fromLineByCell?.[cellIdx] ?? 0;
-              const rawAllowedEnd = partialRowData?.toLineByCell?.[cellIdx];
-              const allowedEnd = rawAllowedEnd == null || rawAllowedEnd === -1 ? cumulativeLine : rawAllowedEnd;
-              const renderStartGlobal = Math.max(blockStart, allowedStart);
-              const renderEndGlobal = Math.min(blockEnd, allowedEnd);
+              const renderStartGlobal = Math.max(blockStart, cellAllowedStart);
+              const renderEndGlobal = Math.min(blockEnd, cellAllowedEnd);
               if (renderStartGlobal >= renderEndGlobal)
                 continue;
               const startLine = renderStartGlobal - blockStart;
@@ -196141,21 +196423,25 @@ function selectionToRects(layout, blocks2, measures, from$1, to, geometryHelper)
                 if (typeof totalHeight === "number" && totalHeight > height)
                   height = totalHeight;
                 const isFirstBlock = i4 === 0;
-                const isLastBlock = i4 === cellBlocks.length - 1;
                 const spacingBefore = paraBlock.attrs?.spacing?.before;
                 height += effectiveTableCellSpacing(spacingBefore, isFirstBlock, padding.top);
-                const spacingAfter = paraBlock.attrs?.spacing?.after;
-                height += effectiveTableCellSpacing(spacingAfter, isLastBlock, padding.bottom);
+                if (!(i4 === blockCount - 1)) {
+                  const spacingAfter = paraBlock.attrs?.spacing?.after;
+                  if (typeof spacingAfter === "number" && spacingAfter > 0)
+                    height += spacingAfter;
+                }
               }
               renderedBlocks.push({
                 block: paraBlock,
                 measure: paraMeasure,
                 startLine,
                 endLine,
-                height
+                height,
+                originalBlockIndex: i4,
+                globalBlockStart: blockStart
               });
             }
-            const contentHeight = renderedBlocks.reduce((acc, info) => acc + info.height, 0);
+            const contentHeight = computeCellSliceContentHeight(cellRenderBlocks, cellAllowedStart, cellAllowedEnd);
             const contentAreaHeight = Math.max(0, rowHeight - (padding.top + padding.bottom));
             const freeSpace = Math.max(0, contentAreaHeight - contentHeight);
             let verticalOffset = 0;
@@ -196165,7 +196451,22 @@ function selectionToRects(layout, blocks2, measures, from$1, to, geometryHelper)
             else if (vAlign === "bottom")
               verticalOffset = freeSpace;
             let blockTopCursor = padding.top + verticalOffset;
-            renderedBlocks.forEach((info, blockIndex$1) => {
+            let prevBlockGlobalEndLine = cellAllowedStart;
+            renderedBlocks.forEach((info) => {
+              for (const rb of cellRenderBlocks) {
+                if (rb.kind === "paragraph")
+                  continue;
+                if (rb.visibleHeight === 0)
+                  continue;
+                if (rb.globalEndLine <= prevBlockGlobalEndLine)
+                  continue;
+                if (rb.globalStartLine >= info.globalBlockStart)
+                  break;
+                const localStart = Math.max(0, cellAllowedStart - rb.globalStartLine);
+                const localEnd = Math.min(rb.lineHeights.length, cellAllowedEnd - rb.globalStartLine);
+                for (let li2 = localStart;li2 < localEnd; li2++)
+                  blockTopCursor += rb.lineHeights[li2];
+              }
               const paragraphMarkerWidth = info.measure.marker?.markerWidth ?? 0;
               const cellIsListItem = isListItem2(paragraphMarkerWidth, info.block);
               const alignmentOverride = cellIsListItem ? "left" : undefined;
@@ -196173,7 +196474,7 @@ function selectionToRects(layout, blocks2, measures, from$1, to, geometryHelper)
               const cellWordLayout = getWordLayoutConfig(info.block);
               const intersectingLines = findLinesIntersectingRange(info.block, info.measure, from$1, to);
               const rawSpacingBefore = info.block.attrs?.spacing?.before;
-              const effectiveSpacingBeforePx = info.startLine === 0 ? effectiveTableCellSpacing(rawSpacingBefore, blockIndex$1 === 0, padding.top) : 0;
+              const effectiveSpacingBeforePx = info.startLine === 0 ? effectiveTableCellSpacing(rawSpacingBefore, info.originalBlockIndex === 0, padding.top) : 0;
               intersectingLines.forEach(({ line, index: index2 }) => {
                 if (index2 < info.startLine || index2 >= info.endLine)
                   return;
@@ -196212,6 +196513,7 @@ function selectionToRects(layout, blocks2, measures, from$1, to, geometryHelper)
                 });
               });
               blockTopCursor += info.height;
+              prevBlockGlobalEndLine = info.globalBlockStart + info.endLine;
             });
           }
           return rowOffset + rowHeight;
@@ -220568,6 +220870,16 @@ var Node$13 = class Node$14 {
   if (!cell2)
     return [];
   return cell2.blocks ?? (cell2.paragraph ? [cell2.paragraph] : []);
+}, countBlockSegments = (measure) => {
+  if (measure.kind === "paragraph")
+    return measure.lines?.length ?? 0;
+  if (measure.kind === "table") {
+    let count = 0;
+    for (const row2 of measure.rows)
+      count += getEmbeddedRowLines(row2).length;
+    return count;
+  }
+  return (typeof measure.height === "number" ? measure.height : 0) > 0 ? 1 : 0;
 }, sumLineHeights = (measure, fromLine, toLine) => {
   let height = 0;
   for (let i4 = fromLine;i4 < toLine && i4 < measure.lines.length; i4 += 1)
@@ -229286,7 +229598,7 @@ var Node$13 = class Node$14 {
     return false;
   return Boolean(checker(attrs));
 }, SuperToolbar, ICONS, TEXTS, tableActionsOptions;
-var init_src_BeJRbQ1S_es = __esm(() => {
+var init_src_BS_QWHti_es = __esm(() => {
   init_rolldown_runtime_B2q5OVn9_es();
   init_SuperConverter_DvkQFRg9_es();
   init_jszip_ChlR43oI_es();
@@ -262649,7 +262961,7 @@ var init_zipper_DqXT7uTa_es = __esm(() => {
 
 // ../../packages/superdoc/dist/super-editor.es.js
 var init_super_editor_es = __esm(() => {
-  init_src_BeJRbQ1S_es();
+  init_src_BS_QWHti_es();
   init_SuperConverter_DvkQFRg9_es();
   init_jszip_ChlR43oI_es();
   init_xml_js_BtmJ6bNs_es();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superdoc-dev/cli",
-  "version": "0.3.0-next.49",
+  "version": "0.3.0-next.50",
   "type": "module",
   "bin": {
     "superdoc": "./dist/index.js"
@@ -21,20 +21,20 @@
     "@types/node": "22.19.2",
     "typescript": "^5.9.2",
     "@superdoc/document-api": "0.0.1",
-    "@superdoc/pm-adapter": "0.0.0",
+    "superdoc": "1.20.0",
     "@superdoc/super-editor": "0.0.1",
-    "superdoc": "1.20.0"
+    "@superdoc/pm-adapter": "0.0.0"
   },
   "module": "src/index.ts",
   "publishConfig": {
     "access": "public"
   },
   "optionalDependencies": {
-    "@superdoc-dev/cli-darwin-arm64": "0.3.0-next.49",
-    "@superdoc-dev/cli-darwin-x64": "0.3.0-next.49",
-    "@superdoc-dev/cli-linux-x64": "0.3.0-next.49",
-    "@superdoc-dev/cli-linux-arm64": "0.3.0-next.49",
-    "@superdoc-dev/cli-windows-x64": "0.3.0-next.49"
+    "@superdoc-dev/cli-darwin-arm64": "0.3.0-next.50",
+    "@superdoc-dev/cli-darwin-x64": "0.3.0-next.50",
+    "@superdoc-dev/cli-linux-arm64": "0.3.0-next.50",
+    "@superdoc-dev/cli-windows-x64": "0.3.0-next.50",
+    "@superdoc-dev/cli-linux-x64": "0.3.0-next.50"
   },
   "scripts": {
     "predev": "node scripts/ensure-superdoc-build.js",