@superdoc-dev/cli 0.8.0-next.72 → 0.8.0-next.73

package/dist/index.js

@@ -65823,7 +65823,7 @@ var init_remark_gfm_BhnWr3yf_es = __esm(() => {
   emptyOptions2 = {};
 });
 
-// ../../packages/superdoc/dist/chunks/SuperConverter-DFi0X147.es.js
+// ../../packages/superdoc/dist/chunks/SuperConverter-ing-1fvK.es.js
 function getExtensionConfigField(extension$1, field, context = { name: "" }) {
   const fieldValue = extension$1.config[field];
   if (typeof fieldValue === "function")
@@ -96179,6 +96179,9 @@ function extractSectionType(elements) {
     return val;
   return "nextPage";
 }
+function extractSectionTypeIsExplicit(elements) {
+  return elements.some((el) => el?.name === "w:type");
+}
 function extractPageSizeAndOrientation(elements) {
   const pgSz = elements.find((el) => el?.name === "w:pgSz");
   if (!pgSz?.attributes)
@@ -96289,6 +96292,7 @@ function extractSectionData(para) {
       footerPx
     };
   const type = extractSectionType(sectPrElements);
+  const typeIsExplicit = extractSectionTypeIsExplicit(sectPrElements);
   const { pageSizePx, orientation } = extractPageSizeAndOrientation(sectPrElements);
   const titlePg = sectPrElements.some((el) => el?.name === "w:titlePg");
   const fallbackMargins = extractFallbackMargins(sectPrElements, headerPx, footerPx);
@@ -96308,6 +96312,7 @@ function extractSectionData(para) {
     bottomPx,
     leftPx,
     type,
+    typeIsExplicit,
     pageSizePx,
     orientation,
     columnsPx,
@@ -96351,6 +96356,7 @@ function createSectionBreakBlock(section, blockIdGen, extraAttrs) {
     attrs: {
       source: "sectPr",
       sectionIndex: section.sectionIndex,
+      ...section.typeIsExplicit ? { typeIsExplicit: true } : {},
       ...extraAttrs
     },
     ...section.pageSize && { pageSize: section.pageSize },
@@ -96376,6 +96382,21 @@ function shouldRequirePageBoundary(current, next) {
 function hasIntrinsicBoundarySignals(_) {
   return false;
 }
+function maybeEmitNextSectionBreakForNode(args2) {
+  const { sectionState, nextBlockId, pushBlock } = args2;
+  if (sectionState.ranges.length === 0)
+    return;
+  if (sectionState.currentSectionIndex >= sectionState.ranges.length - 1)
+    return;
+  const nextSection = sectionState.ranges[sectionState.currentSectionIndex + 1];
+  if (!nextSection)
+    return;
+  if (sectionState.currentNodeIndex !== nextSection.startNodeIndex)
+    return;
+  const currentSection = sectionState.ranges[sectionState.currentSectionIndex];
+  pushBlock(createSectionBreakBlock(nextSection, nextBlockId, shouldRequirePageBoundary(currentSection, nextSection) || hasIntrinsicBoundarySignals(nextSection) ? { requirePageBoundary: true } : undefined));
+  sectionState.currentSectionIndex++;
+}
 function emitPendingSectionBreakForParagraph(args2) {
   const { sectionState, nextBlockId, blocks, recordBlockKind } = args2;
   if (!sectionState || sectionState.ranges.length === 0)
@@ -96409,6 +96430,7 @@ function shouldIgnoreSectionBreak(paragraph2, index2, total, hasBodySectPr) {
 function findParagraphsWithSectPr(doc$2) {
   const paragraphs = [];
   let paragraphIndex = 0;
+  let nodeIndex = 0;
   const getNodeChildren = (node3) => {
     if (Array.isArray(node3.content))
       return node3.content;
@@ -96422,30 +96444,35 @@ function findParagraphsWithSectPr(doc$2) {
     }
     return [];
   };
-  const visitNode = (node3) => {
+  const visitNode = (node3, outerNodeIndex) => {
     if (node3.type === "paragraph") {
       if (hasSectPr(node3))
         paragraphs.push({
           index: paragraphIndex,
+          nodeIndex: outerNodeIndex,
           node: node3
         });
       paragraphIndex++;
       return;
     }
     if (node3.type === "index" || node3.type === "bibliography" || node3.type === "tableOfAuthorities" || node3.type === "documentPartObject" || node3.type === "tableOfContents")
-      getNodeChildren(node3).forEach(visitNode);
+      getNodeChildren(node3).forEach((child) => visitNode(child, outerNodeIndex));
   };
   if (doc$2.content)
-    for (const node3 of doc$2.content)
-      visitNode(node3);
+    for (const node3 of doc$2.content) {
+      visitNode(node3, nodeIndex);
+      nodeIndex++;
+    }
   return {
     paragraphs,
-    totalCount: paragraphIndex
+    totalCount: paragraphIndex,
+    totalNodeCount: nodeIndex
   };
 }
 function buildSectionRangesFromParagraphs(paragraphs, hasBodySectPr) {
   const ranges = [];
   let currentStart = 0;
+  let currentStartNode = 0;
   paragraphs.forEach((item, idx) => {
     if (shouldIgnoreSectionBreak(item.node, idx, paragraphs.length, hasBodySectPr))
       return;
@@ -96456,6 +96483,8 @@ function buildSectionRangesFromParagraphs(paragraphs, hasBodySectPr) {
     const hasAnyMargin = sectionData.headerPx != null || sectionData.footerPx != null || sectionData.topPx != null || sectionData.rightPx != null || sectionData.bottomPx != null || sectionData.leftPx != null;
     const range = {
       sectionIndex: idx,
+      startNodeIndex: currentStartNode,
+      endNodeIndex: item.nodeIndex,
       startParagraphIndex: currentStart,
       endParagraphIndex: item.index,
       sectPr,
@@ -96471,6 +96500,7 @@ function buildSectionRangesFromParagraphs(paragraphs, hasBodySectPr) {
       orientation: sectionData.orientation ?? null,
       columns: sectionData.columnsPx ?? null,
       type: sectionData.type ?? DEFAULT_PARAGRAPH_SECTION_TYPE,
+      typeIsExplicit: sectionData.typeIsExplicit ?? false,
       titlePg: sectionData.titlePg ?? false,
       headerRefs: sectionData.headerRefs,
       footerRefs: sectionData.footerRefs,
@@ -96479,6 +96509,7 @@ function buildSectionRangesFromParagraphs(paragraphs, hasBodySectPr) {
     };
     ranges.push(range);
     currentStart = item.index + 1;
+    currentStartNode = item.nodeIndex + 1;
   });
   return ranges;
 }
@@ -96499,7 +96530,7 @@ function publishSectionMetadata(sectionRanges, options) {
     });
   });
 }
-function createFinalSectionFromBodySectPr(bodySectPr, currentStart, totalParagraphs, sectionIndex) {
+function createFinalSectionFromBodySectPr(bodySectPr, currentStart, totalParagraphs, sectionIndex, nodeBounds) {
   const clampedStart = Math.max(0, Math.min(currentStart, Math.max(totalParagraphs - 1, 0)));
   const bodySectionData = extractSectionData({
     type: "paragraph",
@@ -96508,8 +96539,12 @@ function createFinalSectionFromBodySectPr(bodySectPr, currentStart, totalParagra
   if (!bodySectionData)
     return null;
   const hasAnyMargin = bodySectionData.headerPx != null || bodySectionData.footerPx != null || bodySectionData.topPx != null || bodySectionData.rightPx != null || bodySectionData.bottomPx != null || bodySectionData.leftPx != null;
+  const totalNodes = nodeBounds?.totalNodeCount ?? totalParagraphs;
+  const startNodeIndex = nodeBounds ? Math.max(0, Math.min(nodeBounds.startNodeIndex, Math.max(totalNodes - 1, 0))) : clampedStart;
   return {
     sectionIndex,
+    startNodeIndex,
+    endNodeIndex: Math.max(startNodeIndex, totalNodes - 1),
     startParagraphIndex: clampedStart,
     endParagraphIndex: totalParagraphs - 1,
     sectPr: bodySectPr,
@@ -96525,6 +96560,7 @@ function createFinalSectionFromBodySectPr(bodySectPr, currentStart, totalParagra
     orientation: bodySectionData.orientation ?? null,
     columns: bodySectionData.columnsPx ?? null,
     type: bodySectionData.type ?? DEFAULT_BODY_SECTION_TYPE,
+    typeIsExplicit: bodySectionData.typeIsExplicit ?? false,
     titlePg: bodySectionData.titlePg ?? false,
     headerRefs: bodySectionData.headerRefs,
     footerRefs: bodySectionData.footerRefs,
@@ -96532,9 +96568,13 @@ function createFinalSectionFromBodySectPr(bodySectPr, currentStart, totalParagra
     vAlign: bodySectionData.vAlign
   };
 }
-function createDefaultFinalSection(currentStart, totalParagraphs, sectionIndex) {
+function createDefaultFinalSection(currentStart, totalParagraphs, sectionIndex, nodeBounds) {
+  const totalNodes = nodeBounds?.totalNodeCount ?? totalParagraphs;
+  const startNodeIndex = nodeBounds?.startNodeIndex ?? currentStart;
   return {
     sectionIndex,
+    startNodeIndex,
+    endNodeIndex: Math.max(startNodeIndex, totalNodes - 1),
     startParagraphIndex: currentStart,
     endParagraphIndex: totalParagraphs - 1,
     sectPr: null,
@@ -96543,21 +96583,30 @@ function createDefaultFinalSection(currentStart, totalParagraphs, sectionIndex)
     orientation: null,
     columns: null,
     type: DEFAULT_BODY_SECTION_TYPE,
+    typeIsExplicit: false,
     titlePg: false,
     headerRefs: undefined,
     footerRefs: undefined
   };
 }
 function analyzeSectionRanges(doc$2, bodySectPr) {
-  const { paragraphs, totalCount } = findParagraphsWithSectPr(doc$2);
+  const { paragraphs, totalCount, totalNodeCount } = findParagraphsWithSectPr(doc$2);
   const ranges = buildSectionRangesFromParagraphs(paragraphs, Boolean(bodySectPr));
-  const currentStart = ranges.length > 0 ? ranges[ranges.length - 1].endParagraphIndex + 1 : 0;
+  const last2 = ranges[ranges.length - 1];
+  const currentStart = last2 ? last2.endParagraphIndex + 1 : 0;
+  const currentStartNode = last2 ? last2.endNodeIndex + 1 : 0;
   if (isSectPrElement$1(bodySectPr)) {
-    const finalSection = createFinalSectionFromBodySectPr(bodySectPr, Math.min(currentStart, totalCount), totalCount, ranges.length);
+    const finalSection = createFinalSectionFromBodySectPr(bodySectPr, Math.min(currentStart, totalCount), totalCount, ranges.length, {
+      startNodeIndex: Math.min(currentStartNode, totalNodeCount),
+      totalNodeCount
+    });
     if (finalSection)
       ranges.push(finalSection);
   } else if (ranges.length > 0) {
-    const fallbackFinal = createDefaultFinalSection(Math.min(currentStart, totalCount), totalCount, ranges.length);
+    const fallbackFinal = createDefaultFinalSection(Math.min(currentStart, totalCount), totalCount, ranges.length, {
+      startNodeIndex: Math.min(currentStartNode, totalNodeCount),
+      totalNodeCount
+    });
     if (fallbackFinal) {
       fallbackFinal.type = DEFAULT_PARAGRAPH_SECTION_TYPE;
       ranges.push(fallbackFinal);
@@ -98135,16 +98184,20 @@ function readOddEvenHeadersFlag(editor) {
   return settingsRoot.elements.some((entry) => entry.name === "w:evenAndOddHeaders");
 }
 function createSyntheticRange(bodySectPr, paragraphCount) {
+  const lastIndex = Math.max(paragraphCount - 1, 0);
   return {
     sectionIndex: 0,
+    startNodeIndex: 0,
+    endNodeIndex: lastIndex,
     startParagraphIndex: 0,
-    endParagraphIndex: Math.max(paragraphCount - 1, 0),
+    endParagraphIndex: lastIndex,
     sectPr: bodySectPr ?? null,
     margins: null,
     pageSize: null,
     orientation: null,
     columns: null,
     type: SectionType.CONTINUOUS,
+    typeIsExplicit: false,
     titlePg: false,
     headerRefs: undefined,
     footerRefs: undefined,
@@ -118340,7 +118393,7 @@ var isRegExp = (value) => {
       state.kern = kernNode.attributes["w:val"];
   }
 }, SuperConverter;
-var init_SuperConverter_DFi0X147_es = __esm(() => {
+var init_SuperConverter_ing_1fvK_es = __esm(() => {
   init_rolldown_runtime_Bg48TavK_es();
   init_jszip_C49i9kUs_es();
   init_xml_js_CqGKpaft_es();
@@ -155941,7 +155994,7 @@ var init_SuperConverter_DFi0X147_es = __esm(() => {
   };
 });
 
-// ../../packages/superdoc/dist/chunks/create-headless-toolbar-C9nvGdZQ.es.js
+// ../../packages/superdoc/dist/chunks/create-headless-toolbar-B_1fvPL0.es.js
 function parseSizeUnit(val = "0") {
   const length3 = val.toString() || "0";
   const value = Number.parseFloat(length3);
@@ -158577,8 +158630,8 @@ var CSS_DIMENSION_REGEX, DOM_SIZE_UNITS, Extension = class Extension2 {
     }
   };
 };
-var init_create_headless_toolbar_C9nvGdZQ_es = __esm(() => {
-  init_SuperConverter_DFi0X147_es();
+var init_create_headless_toolbar_B_1fvPL0_es = __esm(() => {
+  init_SuperConverter_ing_1fvK_es();
   init_constants_DrU4EASo_es();
   init_dist_B8HfvhaK_es();
   CSS_DIMENSION_REGEX = /[\d-.]+(\w+)$/;
@@ -207264,7 +207317,7 @@ var init_remark_gfm_eZN6yzWQ_es = __esm(() => {
   init_remark_gfm_BhnWr3yf_es();
 });
 
-// ../../packages/superdoc/dist/chunks/src-JQdl170N.es.js
+// ../../packages/superdoc/dist/chunks/src-4bO9QmBD.es.js
 function deleteProps(obj, propOrProps) {
   const props = typeof propOrProps === "string" ? [propOrProps] : propOrProps;
   const removeNested = (target, pathParts, index2 = 0) => {
@@ -253702,7 +253755,8 @@ function toFlowBlocks(pmDoc, options) {
     sectionState: {
       ranges: sectionRanges,
       currentSectionIndex: 0,
-      currentParagraphIndex: 0
+      currentParagraphIndex: 0,
+      currentNodeIndex: 0
     },
     converters,
     themeColors,
@@ -253711,9 +253765,18 @@ function toFlowBlocks(pmDoc, options) {
     trackedListLastOrdinals: /* @__PURE__ */ new Map
   };
   doc$12.content.forEach((node3) => {
+    maybeEmitNextSectionBreakForNode({
+      sectionState: handlerContext.sectionState,
+      nextBlockId,
+      pushBlock: (block) => {
+        blocks2.push(block);
+        recordBlockKind(block.kind);
+      }
+    });
     const handler2 = nodeHandlers2[node3.type];
     if (handler2)
       handler2(node3, handlerContext);
+    handlerContext.sectionState.currentNodeIndex++;
   });
   if (sectionRanges.length > 0) {
     const lastSectionIndex = sectionRanges.length - 1;
@@ -256201,6 +256264,167 @@ function computeDisplayPageNumber(pages, sections) {
   }
   return result;
 }
+function calculateBalancedColumnHeight(ctx$1, config2 = DEFAULT_BALANCING_CONFIG) {
+  if (ctx$1.columnCount <= 1)
+    return createSingleColumnResult(ctx$1);
+  if (ctx$1.contentBlocks.length === 0)
+    return {
+      targetColumnHeight: 0,
+      columnAssignments: /* @__PURE__ */ new Map,
+      success: true,
+      iterations: 0
+    };
+  const totalHeight = ctx$1.contentBlocks.reduce((sum, b$1) => sum + b$1.measuredHeight, 0);
+  const maxBlockHeight = ctx$1.contentBlocks.reduce((m$1, b$1) => Math.max(m$1, b$1.measuredHeight), 0);
+  if (totalHeight < config2.minColumnHeight * ctx$1.columnCount)
+    return createSingleColumnResult(ctx$1);
+  let lo = Math.max(maxBlockHeight, config2.minColumnHeight);
+  let hi = Math.min(totalHeight, ctx$1.availableHeight);
+  if (lo > hi)
+    lo = hi;
+  let bestResult = null;
+  let bestH = hi;
+  let iterations = 0;
+  while (lo <= hi) {
+    iterations++;
+    const mid = Math.floor((lo + hi) / 2);
+    const sim = simulateBalancedLayout(ctx$1, mid, config2);
+    const maxCol = Math.max(...sim.columnHeights);
+    if (sim.assignments.size === ctx$1.contentBlocks.length && maxCol <= mid) {
+      bestResult = sim;
+      bestH = mid;
+      hi = mid - 1;
+    } else
+      lo = mid + 1;
+    if (iterations >= config2.maxIterations)
+      break;
+  }
+  if (bestResult)
+    return {
+      targetColumnHeight: bestH,
+      columnAssignments: bestResult.assignments,
+      success: true,
+      iterations,
+      blockBreakPoints: bestResult.breakPoints.size > 0 ? bestResult.breakPoints : undefined
+    };
+  return createSequentialResult(ctx$1);
+}
+function simulateBalancedLayout(ctx$1, targetHeight, config2) {
+  const assignments = /* @__PURE__ */ new Map;
+  const breakPoints = /* @__PURE__ */ new Map;
+  const columnHeights = new Array(ctx$1.columnCount).fill(0);
+  let currentColumn = 0;
+  for (let i4 = 0;i4 < ctx$1.contentBlocks.length; i4++) {
+    const block = ctx$1.contentBlocks[i4];
+    const nextBlock = ctx$1.contentBlocks[i4 + 1];
+    if (columnHeights[currentColumn] + block.measuredHeight > targetHeight && currentColumn < ctx$1.columnCount - 1) {
+      if (block.keepWithNext && nextBlock) {
+        const combinedHeight = block.measuredHeight + nextBlock.measuredHeight;
+        if (columnHeights[currentColumn] + combinedHeight <= targetHeight) {
+          assignments.set(block.blockId, currentColumn);
+          columnHeights[currentColumn] += block.measuredHeight;
+          continue;
+        }
+      }
+      if (block.canBreak && block.lineHeights && block.lineHeights.length > 1) {
+        const breakPoint = calculateParagraphBreakPoint(block, targetHeight - columnHeights[currentColumn], block.orphanLines ?? 1, block.widowLines ?? 1);
+        if (breakPoint.canBreak && breakPoint.breakAfterLine >= 0) {
+          const heightBefore = block.lineHeights.slice(0, breakPoint.breakAfterLine + 1).reduce((sum, h$2) => sum + h$2, 0);
+          const heightAfter = block.measuredHeight - heightBefore;
+          breakPoints.set(block.blockId, {
+            blockId: block.blockId,
+            breakAfterLine: breakPoint.breakAfterLine,
+            heightBeforeBreak: heightBefore,
+            heightAfterBreak: heightAfter
+          });
+          assignments.set(block.blockId, currentColumn);
+          columnHeights[currentColumn] += heightBefore;
+          currentColumn++;
+          columnHeights[currentColumn] += heightAfter;
+          continue;
+        }
+      }
+      currentColumn++;
+    }
+    assignments.set(block.blockId, currentColumn);
+    columnHeights[currentColumn] += block.measuredHeight;
+  }
+  return {
+    assignments,
+    columnHeights,
+    hasOverflow: columnHeights.some((h$2) => h$2 > ctx$1.availableHeight),
+    breakPoints
+  };
+}
+function calculateParagraphBreakPoint(block, availableHeight, orphanLines, widowLines) {
+  if (!block.lineHeights || block.lineHeights.length === 0)
+    return {
+      breakAfterLine: -1,
+      canBreak: false
+    };
+  const lines = block.lineHeights;
+  let heightSoFar = 0;
+  for (let i4 = 0;i4 < lines.length; i4++) {
+    heightSoFar += lines[i4];
+    if (heightSoFar > availableHeight) {
+      const linesBeforeBreak = i4;
+      const linesAfterBreak = lines.length - i4;
+      if (linesAfterBreak < widowLines) {
+        const adjustedBreak = Math.max(0, i4 - (widowLines - linesAfterBreak));
+        if (adjustedBreak < orphanLines)
+          return {
+            breakAfterLine: -1,
+            canBreak: false
+          };
+        return {
+          breakAfterLine: adjustedBreak - 1,
+          canBreak: true
+        };
+      }
+      if (linesBeforeBreak < orphanLines)
+        return {
+          breakAfterLine: -1,
+          canBreak: false
+        };
+      return {
+        breakAfterLine: i4 - 1,
+        canBreak: true
+      };
+    }
+  }
+  return {
+    breakAfterLine: lines.length - 1,
+    canBreak: true
+  };
+}
+function createSingleColumnResult(ctx$1) {
+  const assignments = /* @__PURE__ */ new Map;
+  for (const block of ctx$1.contentBlocks)
+    assignments.set(block.blockId, 0);
+  return {
+    targetColumnHeight: ctx$1.availableHeight,
+    columnAssignments: assignments,
+    success: true,
+    iterations: 0
+  };
+}
+function createSequentialResult(ctx$1) {
+  const assignments = /* @__PURE__ */ new Map;
+  const columnHeights = new Array(ctx$1.columnCount).fill(0);
+  let currentColumn = 0;
+  for (const block of ctx$1.contentBlocks) {
+    if (columnHeights[currentColumn] + block.measuredHeight > ctx$1.availableHeight && currentColumn < ctx$1.columnCount - 1)
+      currentColumn++;
+    assignments.set(block.blockId, currentColumn);
+    columnHeights[currentColumn] += block.measuredHeight;
+  }
+  return {
+    targetColumnHeight: Math.max(...columnHeights),
+    columnAssignments: assignments,
+    success: false,
+    iterations: 0
+  };
+}
 function shouldSkipBalancing(ctx$1, config2 = DEFAULT_BALANCING_CONFIG) {
   if (!config2.enabled)
     return true;
@@ -256232,76 +256456,211 @@ function getFragmentHeight(fragment2, measureMap) {
     return sum;
   }
   if (fragment2.kind === "image" || fragment2.kind === "drawing" || fragment2.kind === "table") {
-    if (typeof fragment2.height === "number")
+    if (typeof fragment2.height === "number" && fragment2.height > 0)
       return fragment2.height;
     const measure = measureMap.get(fragment2.blockId);
-    if (measure && typeof measure.height === "number")
-      return measure.height;
+    if (measure) {
+      if (typeof measure.height === "number" && measure.height > 0)
+        return measure.height;
+      if (fragment2.kind === "table" && typeof measure.totalHeight === "number")
+        return measure.totalHeight;
+    }
+    if (typeof fragment2.height === "number")
+      return fragment2.height;
   }
   return 0;
 }
-function balancePageColumns(fragments, columns, margins, topMargin, availableHeight, measureMap) {
-  if (columns.count <= 1 || fragments.length === 0)
-    return;
-  const columnX = (columnIndex) => {
-    return margins.left + columnIndex * (columns.width + columns.gap);
-  };
-  const rowMap = /* @__PURE__ */ new Map;
-  fragments.forEach((fragment2, idx) => {
-    const y$1 = Math.round(fragment2.y);
-    if (!rowMap.has(y$1))
-      rowMap.set(y$1, []);
-    const height = getFragmentHeight(fragment2, measureMap);
-    rowMap.get(y$1).push({
-      fragment: fragment2,
-      height,
-      originalIndex: idx
-    });
-  });
-  const sortedRows = [...rowMap.entries()].sort((a2, b$1) => a2[0] - b$1[0]);
-  let totalHeight = 0;
-  const contentBlocks = [];
-  for (const [, rowFragments] of sortedRows) {
-    const maxHeight = Math.max(...rowFragments.map((f2) => f2.height));
-    totalHeight += maxHeight;
-    contentBlocks.push({
-      blockId: rowFragments[0]?.fragment.blockId ?? `row-${contentBlocks.length}`,
-      measuredHeight: maxHeight,
-      canBreak: false,
-      keepWithNext: false,
-      keepTogether: true
-    });
+function getBalancingHeight(fragment2, measureMap, sectPrMarkerBlockIds) {
+  if (fragment2.kind === "para" && sectPrMarkerBlockIds && sectPrMarkerBlockIds.has(fragment2.blockId))
+    return 0;
+  return getFragmentHeight(fragment2, measureMap);
+}
+function balanceSectionOnPage(args$1) {
+  const { sectionColumns, sectionHasExplicitColumnBreak, sectionIndex, blockSectionMap, fragments } = args$1;
+  if (sectionColumns.count <= 1)
+    return null;
+  if (sectionHasExplicitColumnBreak)
+    return null;
+  if (sectionColumns.equalWidth === false && Array.isArray(sectionColumns.widths) && sectionColumns.widths.length > 0)
+    return null;
+  const sectionFragments = fragments.filter((f2) => blockSectionMap.get(f2.blockId) === sectionIndex);
+  if (sectionFragments.length === 0)
+    return null;
+  const columnCount = sectionColumns.count;
+  const columnGap = sectionColumns.gap;
+  const columnWidth = sectionColumns.width ?? 0;
+  if (columnWidth <= 0)
+    return null;
+  let sectionTopY = Number.POSITIVE_INFINITY;
+  for (const f2 of sectionFragments)
+    if (f2.y < sectionTopY)
+      sectionTopY = f2.y;
+  if (!Number.isFinite(sectionTopY))
+    sectionTopY = args$1.topMargin;
+  const remainingHeight = args$1.availableHeight - (sectionTopY - args$1.topMargin);
+  if (remainingHeight <= 0)
+    return null;
+  let precedingHeightBeforeTable = 0;
+  for (const f2 of sectionFragments) {
+    if (f2.kind === "table")
+      break;
+    precedingHeightBeforeTable += getBalancingHeight(f2, args$1.measureMap, args$1.sectPrMarkerBlockIds);
   }
+  const splitResult = splitDominantTableAtRowBoundary({
+    sectionFragments,
+    fragments,
+    columnCount,
+    measureMap: args$1.measureMap,
+    sectPrMarkerBlockIds: args$1.sectPrMarkerBlockIds,
+    precedingHeight: precedingHeightBeforeTable
+  });
+  const ordered = [...sectionFragments].sort((a2, b$1) => {
+    if (a2.x !== b$1.x)
+      return a2.x - b$1.x;
+    return a2.y - b$1.y;
+  });
+  const contentBlocks = ordered.map((f2, i4) => ({
+    blockId: `${f2.blockId}#${i4}`,
+    measuredHeight: getBalancingHeight(f2, args$1.measureMap, args$1.sectPrMarkerBlockIds),
+    canBreak: false,
+    keepWithNext: false,
+    keepTogether: true
+  }));
   if (shouldSkipBalancing({
-    columnCount: columns.count,
-    columnWidth: columns.width,
-    columnGap: columns.gap,
-    availableHeight,
+    columnCount,
+    columnWidth,
+    columnGap,
+    availableHeight: remainingHeight,
     contentBlocks
-  }))
-    return;
-  const targetHeight = totalHeight / columns.count;
-  if (targetHeight < DEFAULT_BALANCING_CONFIG.minColumnHeight)
-    return;
-  let currentColumn = 0;
-  let currentColumnHeight = 0;
-  let currentY = topMargin;
-  for (const [, rowFragments] of sortedRows) {
-    const rowHeight = Math.max(...rowFragments.map((f2) => f2.height));
-    if (currentColumnHeight > 0 && currentColumnHeight + rowHeight >= targetHeight && currentColumn < columns.count - 1) {
-      currentColumn++;
-      currentColumnHeight = 0;
-      currentY = topMargin;
-    }
-    const colX = columnX(currentColumn);
-    for (const info of rowFragments) {
-      info.fragment.x = colX;
-      info.fragment.y = currentY;
-      info.fragment.width = columns.width;
+  })) {
+    splitResult?.rollback();
+    return null;
+  }
+  const result = calculateBalancedColumnHeight({
+    columnCount,
+    columnWidth,
+    columnGap,
+    availableHeight: remainingHeight,
+    contentBlocks
+  }, DEFAULT_BALANCING_CONFIG);
+  const columnX = (columnIndex) => args$1.margins.left + columnIndex * (columnWidth + columnGap);
+  const colCursors = new Array(columnCount).fill(sectionTopY);
+  let maxY = sectionTopY;
+  for (let i4 = 0;i4 < ordered.length; i4++) {
+    const f2 = ordered[i4];
+    const block = contentBlocks[i4];
+    const col = result.columnAssignments.get(block.blockId) ?? 0;
+    f2.x = columnX(col);
+    f2.y = colCursors[col];
+    f2.width = columnWidth;
+    colCursors[col] += block.measuredHeight;
+    if (colCursors[col] > maxY)
+      maxY = colCursors[col];
+  }
+  return { maxY };
+}
+function splitDominantTableAtRowBoundary(args$1) {
+  const { sectionFragments, fragments, columnCount, measureMap, sectPrMarkerBlockIds } = args$1;
+  const precedingHeight = Math.max(0, args$1.precedingHeight ?? 0);
+  if (columnCount <= 1)
+    return null;
+  const tables = sectionFragments.filter((f2) => f2.kind === "table");
+  if (tables.length !== 1)
+    return null;
+  const table2 = tables[0];
+  const fromRow = table2.fromRow ?? 0;
+  const toRow = table2.toRow ?? fromRow;
+  if (toRow - fromRow < 2)
+    return null;
+  const measure = measureMap.get(table2.blockId);
+  if (!measure || measure.kind !== "table" || !Array.isArray(measure.rows))
+    return null;
+  const totalSectionHeight = sectionFragments.reduce((sum, f2) => sum + getBalancingHeight(f2, measureMap, sectPrMarkerBlockIds), 0);
+  if (totalSectionHeight <= 0)
+    return null;
+  const target = Math.max(1, totalSectionHeight / columnCount - precedingHeight);
+  if (getBalancingHeight(table2, measureMap, sectPrMarkerBlockIds) <= target + 1)
+    return null;
+  let running = 0;
+  let splitRow = fromRow + 1;
+  for (let r$1 = fromRow;r$1 < toRow - 1; r$1++) {
+    const h$2 = measure.rows[r$1]?.height ?? 0;
+    if (running + h$2 >= target) {
+      splitRow = r$1 + 1;
+      break;
     }
-    currentColumnHeight += rowHeight;
-    currentY += rowHeight;
+    running += h$2;
+    splitRow = r$1 + 2;
   }
+  if (splitRow <= fromRow || splitRow >= toRow)
+    return null;
+  const firstHalfRows = measure.rows.slice(fromRow, splitRow);
+  const secondHalfRows = measure.rows.slice(splitRow, toRow);
+  const firstHalfHeight = firstHalfRows.reduce((s2, r$1) => s2 + (r$1.height ?? 0), 0);
+  const secondHalfHeight = secondHalfRows.reduce((s2, r$1) => s2 + (r$1.height ?? 0), 0);
+  const makeRowBoundaries = (rows, startIndex) => {
+    const out = [];
+    let y$1 = 0.5;
+    for (let i4 = 0;i4 < rows.length; i4++) {
+      const h$2 = rows[i4].height ?? 0;
+      out.push({
+        index: startIndex + i4,
+        y: y$1,
+        height: h$2,
+        minHeight: h$2,
+        resizable: true
+      });
+      y$1 += h$2;
+    }
+    return out;
+  };
+  const originalMetadata = table2.metadata;
+  const firstMetadata = originalMetadata ? {
+    ...originalMetadata,
+    rowBoundaries: makeRowBoundaries(firstHalfRows, 0)
+  } : undefined;
+  const secondMetadata = originalMetadata ? {
+    ...originalMetadata,
+    rowBoundaries: makeRowBoundaries(secondHalfRows, 0)
+  } : undefined;
+  const originalToRow = table2.toRow;
+  const originalHeight = table2.height;
+  const originalContinuesOnNext = table2.continuesOnNext ?? false;
+  table2.toRow = splitRow;
+  table2.height = firstHalfHeight;
+  table2.continuesOnNext = true;
+  if (firstMetadata)
+    table2.metadata = firstMetadata;
+  const secondHalf = {
+    ...table2,
+    fromRow: splitRow,
+    toRow,
+    height: secondHalfHeight,
+    continuesFromPrev: true,
+    continuesOnNext: originalContinuesOnNext,
+    metadata: secondMetadata ?? table2.metadata
+  };
+  const fragIdx = fragments.indexOf(table2);
+  if (fragIdx >= 0)
+    fragments.splice(fragIdx + 1, 0, secondHalf);
+  const sectIdx = sectionFragments.indexOf(table2);
+  if (sectIdx >= 0)
+    sectionFragments.splice(sectIdx + 1, 0, secondHalf);
+  return {
+    applied: true,
+    rollback: () => {
+      table2.toRow = originalToRow;
+      table2.height = originalHeight;
+      table2.continuesOnNext = originalContinuesOnNext;
+      table2.metadata = originalMetadata;
+      const fIdx = fragments.indexOf(secondHalf);
+      if (fIdx >= 0)
+        fragments.splice(fIdx, 1);
+      const sIdx = sectionFragments.indexOf(secondHalf);
+      if (sIdx >= 0)
+        sectionFragments.splice(sIdx, 1);
+    }
+  };
 }
 function resolvePageNumberTokens(layout, blocks2, measures, numberingCtx) {
   const affectedBlockIds = /* @__PURE__ */ new Set;
@@ -257130,6 +257489,48 @@ function layoutDocument(blocks2, measures, options = {}) {
       right: activeRightMargin
     }, activePageSize.w);
   };
+  const balancingMeasureMap = /* @__PURE__ */ new Map;
+  const blockSectionMap = /* @__PURE__ */ new Map;
+  const sectionColumnsMap = /* @__PURE__ */ new Map;
+  const sectionHasExplicitColumnBreak = /* @__PURE__ */ new Set;
+  const sectionEndBreakType = /* @__PURE__ */ new Map;
+  const sectionTypeIsExplicit = /* @__PURE__ */ new Map;
+  let lastSectionIdx = null;
+  const sectPrMarkerBlockIds = /* @__PURE__ */ new Set;
+  let documentHasExplicitColumnBreak = false;
+  let documentHasAnySectionBreak = false;
+  const alreadyBalancedSections = /* @__PURE__ */ new Set;
+  let currentSectionIdx = null;
+  blocks2.forEach((block, idx) => {
+    const measure = measures[idx];
+    if (measure)
+      balancingMeasureMap.set(block.id, measure);
+    const blockWithAttrs = block;
+    const attrSectionIdx = blockWithAttrs.attrs?.sectionIndex;
+    if (block.kind === "sectionBreak") {
+      documentHasAnySectionBreak = true;
+      if (typeof attrSectionIdx === "number") {
+        currentSectionIdx = attrSectionIdx;
+        lastSectionIdx = attrSectionIdx;
+        if (block.columns)
+          sectionColumnsMap.set(attrSectionIdx, cloneColumnLayout(block.columns));
+        if (typeof block.type === "string")
+          sectionEndBreakType.set(attrSectionIdx, block.type);
+        if (typeof blockWithAttrs.attrs?.typeIsExplicit === "boolean")
+          sectionTypeIsExplicit.set(attrSectionIdx, blockWithAttrs.attrs.typeIsExplicit);
+      }
+    }
+    if (currentSectionIdx !== null) {
+      blockSectionMap.set(block.id, currentSectionIdx);
+      if (block.kind === "columnBreak") {
+        sectionHasExplicitColumnBreak.add(currentSectionIdx);
+        documentHasExplicitColumnBreak = true;
+      }
+    } else if (block.kind === "columnBreak")
+      documentHasExplicitColumnBreak = true;
+    if (block.kind === "paragraph" && blockWithAttrs.attrs?.sectPrMarker === true)
+      sectPrMarkerBlockIds.add(block.id);
+  });
   const anchoredByParagraph = collectAnchoredDrawings(blocks2, measures);
   const anchoredTables = collectAnchoredTables(blocks2, measures);
   const anchoredTablesByParagraph = anchoredTables.byParagraph;
@@ -257352,7 +257753,47 @@ function layoutDocument(blocks2, measures, options = {}) {
         let state = paginator.ensurePage();
         const columnIndexBefore = state.columnIndex;
         const newColumns = updatedState.pendingColumns;
-        if (columnIndexBefore >= newColumns.count)
+        let endingSectionIndex = null;
+        for (let i4 = state.page.fragments.length - 1;i4 >= 0; i4--) {
+          const mapped = blockSectionMap.get(state.page.fragments[i4].blockId);
+          if (typeof mapped === "number" && mapped !== metadataIndex) {
+            endingSectionIndex = mapped;
+            break;
+          }
+        }
+        const endingSectionColumns = endingSectionIndex !== null ? sectionColumnsMap.get(endingSectionIndex) : undefined;
+        const willBalance = endingSectionIndex !== null && !!endingSectionColumns && endingSectionColumns.count > 1 && !sectionHasExplicitColumnBreak.has(endingSectionIndex);
+        let balanceResult = null;
+        if (willBalance) {
+          const activeRegionTop = state.constraintBoundaries[state.constraintBoundaries.length - 1]?.y ?? activeTopMargin;
+          const availableHeight = activePageSize.h - activeBottomMargin - activeRegionTop;
+          const normalized = normalizeColumns(endingSectionColumns, activePageSize.w - (activeLeftMargin + activeRightMargin));
+          balanceResult = balanceSectionOnPage({
+            fragments: state.page.fragments,
+            sectionIndex: endingSectionIndex,
+            sectionColumns: {
+              count: normalized.count,
+              gap: normalized.gap,
+              width: normalized.width,
+              widths: endingSectionColumns.widths,
+              equalWidth: endingSectionColumns.equalWidth
+            },
+            sectionHasExplicitColumnBreak: false,
+            blockSectionMap,
+            margins: { left: activeLeftMargin },
+            topMargin: activeRegionTop,
+            columnWidth: normalized.width,
+            availableHeight,
+            measureMap: balancingMeasureMap,
+            sectPrMarkerBlockIds
+          });
+          if (balanceResult) {
+            state.cursorY = balanceResult.maxY;
+            state.maxCursorY = balanceResult.maxY;
+            alreadyBalancedSections.add(endingSectionIndex);
+          }
+        }
+        if (balanceResult === null && columnIndexBefore >= newColumns.count)
           state = paginator.startNewPage();
         startMidPageRegion(state, newColumns);
       }
@@ -257716,46 +258157,74 @@ function layoutDocument(blocks2, measures, options = {}) {
       for (const fragment2 of page.fragments)
         fragment2.y += yOffset;
   }
-  if (activeColumns.count > 1) {
-    const contentWidth = pageSize.w - (activeLeftMargin + activeRightMargin);
-    const normalizedCols = normalizeColumns(activeColumns, contentWidth);
-    const measureMap = /* @__PURE__ */ new Map;
-    const blockSectionMap = /* @__PURE__ */ new Map;
-    const sectionColumnsMap = /* @__PURE__ */ new Map;
-    blocks2.forEach((block, idx) => {
-      const measure = measures[idx];
-      if (measure)
-        measureMap.set(block.id, measure);
-      const sectionIdx = block.attrs?.sectionIndex;
-      if (typeof sectionIdx === "number") {
-        blockSectionMap.set(block.id, sectionIdx);
-        if (block.kind === "sectionBreak" && block.columns)
-          sectionColumnsMap.set(sectionIdx, cloneColumnLayout(block.columns));
-      }
-    });
-    for (const page of pages)
-      if (page === pages[pages.length - 1] && page.fragments.length > 0) {
-        const finalSectionColumns = sectionColumnsMap.get(activeSectionIndex) ?? activeColumns;
-        if (finalSectionColumns?.equalWidth === false && Array.isArray(finalSectionColumns.widths) && finalSectionColumns.widths.length > 0)
-          continue;
-        if (new Set(page.fragments.map((f2) => Math.round(f2.x))).size > 1)
-          continue;
-        if (new Set(page.fragments.map((f2) => Math.round(f2.width))).size > 1)
-          continue;
-        const fragmentSections = /* @__PURE__ */ new Set;
-        for (const f2 of page.fragments) {
-          const section = blockSectionMap.get(f2.blockId);
-          if (section !== undefined)
-            fragmentSections.add(section);
-        }
-        const fragmentsToBalance = fragmentSections.size > 1 ? page.fragments.filter((f2) => {
-          return blockSectionMap.get(f2.blockId) === activeSectionIndex;
-        }) : page.fragments;
-        if (fragmentsToBalance.length > 0) {
-          const availableHeight = pageSize.h - activeBottomMargin - activeTopMargin;
-          balancePageColumns(fragmentsToBalance, normalizedCols, { left: activeLeftMargin }, activeTopMargin, availableHeight, measureMap);
+  const FALLBACK_SECTION_IDX = -1;
+  if (sectionColumnsMap.size === 0 && !documentHasAnySectionBreak && activeColumns.count > 1 && !documentHasExplicitColumnBreak) {
+    sectionColumnsMap.set(FALLBACK_SECTION_IDX, cloneColumnLayout(activeColumns));
+    for (const block of blocks2)
+      blockSectionMap.set(block.id, FALLBACK_SECTION_IDX);
+  }
+  for (const [sectionIdx, sectionCols] of sectionColumnsMap) {
+    if (sectionCols.count <= 1)
+      continue;
+    if (sectionHasExplicitColumnBreak.has(sectionIdx))
+      continue;
+    if (alreadyBalancedSections.has(sectionIdx))
+      continue;
+    if (sectionIdx !== FALLBACK_SECTION_IDX) {
+      const endBreakType = sectionEndBreakType.get(sectionIdx);
+      const typeIsExplicit = sectionTypeIsExplicit.get(sectionIdx) === true;
+      const isLast = lastSectionIdx !== null && sectionIdx === lastSectionIdx;
+      const bodyExplicitContinuousIdx = lastSectionIdx !== null && sectionTypeIsExplicit.get(lastSectionIdx) === true && sectionEndBreakType.get(lastSectionIdx) === "continuous" ? lastSectionIdx : null;
+      const isExplicitNonContinuous = typeIsExplicit && (endBreakType === "nextPage" || endBreakType === "evenPage" || endBreakType === "oddPage");
+      let sectionPagesCount = 0;
+      for (const p$12 of pages)
+        if (p$12.fragments.some((f2) => blockSectionMap.get(f2.blockId) === sectionIdx)) {
+          sectionPagesCount += 1;
+          if (sectionPagesCount > 1)
+            break;
         }
-      }
+      const isMultiPage = sectionPagesCount > 1;
+      if (isMultiPage && !isLast)
+        continue;
+      const allowedByMidDocContinuous = endBreakType === "continuous" && !isLast;
+      const allowedByBodyExplicitContinuous = bodyExplicitContinuousIdx !== null && sectionIdx === bodyExplicitContinuousIdx - 1 && !isExplicitNonContinuous;
+      if (!allowedByMidDocContinuous && !allowedByBodyExplicitContinuous && !isMultiPage)
+        continue;
+    }
+    let lastPageForSection = null;
+    for (const p$12 of pages)
+      if (p$12.fragments.some((f2) => blockSectionMap.get(f2.blockId) === sectionIdx))
+        lastPageForSection = p$12;
+    if (!lastPageForSection)
+      continue;
+    const sectionPageSize = lastPageForSection.size ?? pageSize;
+    const sectionPageMargins = lastPageForSection.margins;
+    const sectionLeftMargin = sectionPageMargins?.left ?? activeLeftMargin;
+    const sectionRightMargin = sectionPageMargins?.right ?? activeRightMargin;
+    const sectionTopMarginPx = sectionPageMargins?.top ?? activeTopMargin;
+    const sectionBottomMargin = sectionPageMargins?.bottom ?? activeBottomMargin;
+    const sectionContentWidth = sectionPageSize.w - (sectionLeftMargin + sectionRightMargin);
+    const sectionAvailableHeight = sectionPageSize.h - sectionBottomMargin - sectionTopMarginPx;
+    const normalized = normalizeColumns(sectionCols, sectionContentWidth);
+    balanceSectionOnPage({
+      fragments: lastPageForSection.fragments,
+      sectionIndex: sectionIdx,
+      sectionColumns: {
+        count: normalized.count,
+        gap: normalized.gap,
+        width: normalized.width,
+        widths: sectionCols.widths,
+        equalWidth: sectionCols.equalWidth
+      },
+      sectionHasExplicitColumnBreak: false,
+      blockSectionMap,
+      margins: { left: sectionLeftMargin },
+      topMargin: sectionTopMarginPx,
+      columnWidth: normalized.width,
+      availableHeight: sectionAvailableHeight,
+      measureMap: balancingMeasureMap,
+      sectPrMarkerBlockIds
+    });
   }
   for (const state of states) {
     const boundaries = state.constraintBoundaries;
@@ -267357,12 +267826,43 @@ async function measureParagraphBlock(block, maxWidth) {
     if (lineToTrim.naturalWidth != null && typeof lineToTrim.naturalWidth === "number")
       lineToTrim.naturalWidth = roundValue(Math.max(0, lineToTrim.naturalWidth - delta));
   };
-  const getAlignmentStopForOrdinal = (ordinal) => {
+  const tabSegmentInfo = /* @__PURE__ */ new Map;
+  {
+    let segmentTabRunIndices = [];
+    const closeSegment = () => {
+      const total = segmentTabRunIndices.length;
+      segmentTabRunIndices.forEach((runIdx, ord) => {
+        tabSegmentInfo.set(runIdx, {
+          localOrdinal: ord,
+          segmentTotal: total
+        });
+      });
+      segmentTabRunIndices = [];
+    };
+    for (let i4 = 0;i4 < runsToProcess.length; i4++) {
+      const r$1 = runsToProcess[i4];
+      if (isLineBreakRun(r$1) || r$1.kind === "break" && r$1.breakType === "line")
+        closeSegment();
+      else if (isTabRun(r$1))
+        segmentTabRunIndices.push(i4);
+    }
+    closeSegment();
+  }
+  const getAlignmentStopForOrdinal = (ordinal, runIdx) => {
     if (alignmentTabStopsPx.length === 0 || totalTabRuns === 0 || !Number.isFinite(ordinal))
       return null;
-    if (ordinal < 0 || ordinal >= totalTabRuns)
+    let scopeOrdinal = ordinal;
+    let scopeTotal = totalTabRuns;
+    if (runIdx !== undefined) {
+      const info = tabSegmentInfo.get(runIdx);
+      if (info) {
+        scopeOrdinal = info.localOrdinal;
+        scopeTotal = info.segmentTotal;
+      }
+    }
+    if (scopeOrdinal < 0 || scopeOrdinal >= scopeTotal)
       return null;
-    const remainingTabs = totalTabRuns - ordinal - 1;
+    const remainingTabs = scopeTotal - scopeOrdinal - 1;
     const targetIndex = alignmentTabStopsPx.length - 1 - remainingTabs;
     if (targetIndex < 0 || targetIndex >= alignmentTabStopsPx.length)
       return null;
@@ -267476,16 +267976,16 @@ async function measureParagraphBlock(block, maxWidth) {
       let target;
       const resolvedTabIndex = typeof run2.tabIndex === "number" && Number.isFinite(run2.tabIndex) ? run2.tabIndex : sequentialTabIndex;
       sequentialTabIndex = Math.max(sequentialTabIndex, resolvedTabIndex + 1);
-      const forcedAlignment = getAlignmentStopForOrdinal(resolvedTabIndex);
+      const greedy = getNextTabStopPx(absCurrentX, tabStops, tabStopCursor);
+      const forcedAlignment = greedy.stop?.source === "default" ? getAlignmentStopForOrdinal(resolvedTabIndex, runIndex) : null;
       if (forcedAlignment && forcedAlignment.stop.pos > absCurrentX + TAB_EPSILON) {
         stop = forcedAlignment.stop;
         target = forcedAlignment.stop.pos;
         tabStopCursor = forcedAlignment.index + 1;
       } else {
-        const nextStop = getNextTabStopPx(absCurrentX, tabStops, tabStopCursor);
-        target = nextStop.target;
-        tabStopCursor = nextStop.nextIndex;
-        stop = nextStop.stop;
+        target = greedy.target;
+        tabStopCursor = greedy.nextIndex;
+        stop = greedy.stop;
       }
       const maxAbsWidth = currentLine.maxWidth + effectiveIndent;
       const clampedTarget = Math.min(target, maxAbsWidth);
@@ -287413,7 +287913,16 @@ menclose::after {
       misses: this.#misses
     };
   }
-}, MIN_BORDER_SIZE_PX2 = 0.5, MAX_BORDER_SIZE_PX2 = 100, borderSizeToPx = (size$1) => eighthPointsToPixels(size$1, { clamp: true }), clampPixelBorderWidth = (width) => Math.min(MAX_BORDER_SIZE_PX2, Math.max(MIN_BORDER_SIZE_PX2, width)), resolveBorderWidth = (size$1, unit) => {
+}, MIN_BORDER_SIZE_PX2 = 0.5, MAX_BORDER_SIZE_PX2 = 100, borderSizeToPx = (size$1) => {
+  if (!isFiniteNumber(size$1))
+    return;
+  if (size$1 <= 0)
+    return 0;
+  const width = eighthPointsToPixels(size$1);
+  if (width == null)
+    return;
+  return clampPixelBorderWidth(width);
+}, clampPixelBorderWidth = (width) => Math.min(MAX_BORDER_SIZE_PX2, Math.max(MIN_BORDER_SIZE_PX2, width)), resolveBorderWidth = (size$1, unit) => {
   if (unit === "eighthPoints")
     return borderSizeToPx(size$1);
   return clampPixelBorderWidth(size$1);
@@ -290699,12 +291208,43 @@ menclose::after {
     stop,
     index: index2
   })).filter(({ stop }) => stop.val === "end" || stop.val === "center" || stop.val === "decimal");
-  const getAlignmentStopForOrdinal = (ordinal) => {
+  const tabSegmentInfo = /* @__PURE__ */ new Map;
+  {
+    let segmentTabRunIndices = [];
+    const closeSegment = () => {
+      const total = segmentTabRunIndices.length;
+      segmentTabRunIndices.forEach((runIdx, ord) => {
+        tabSegmentInfo.set(runIdx, {
+          localOrdinal: ord,
+          segmentTotal: total
+        });
+      });
+      segmentTabRunIndices = [];
+    };
+    for (let i4 = 0;i4 < runs2.length; i4++) {
+      const r$1 = runs2[i4];
+      if (r$1.kind === "lineBreak" || r$1.kind === "break" && r$1.breakType === "line")
+        closeSegment();
+      else if (r$1.kind === "tab")
+        segmentTabRunIndices.push(i4);
+    }
+    closeSegment();
+  }
+  const getAlignmentStopForOrdinal = (ordinal, runIdx) => {
     if (alignmentTabStopsPx.length === 0 || totalTabRuns === 0 || !Number.isFinite(ordinal))
       return null;
-    if (ordinal < 0 || ordinal >= totalTabRuns)
+    let scopeOrdinal = ordinal;
+    let scopeTotal = totalTabRuns;
+    if (runIdx !== undefined) {
+      const info = tabSegmentInfo.get(runIdx);
+      if (info) {
+        scopeOrdinal = info.localOrdinal;
+        scopeTotal = info.segmentTotal;
+      }
+    }
+    if (scopeOrdinal < 0 || scopeOrdinal >= scopeTotal)
       return null;
-    const remainingTabs = totalTabRuns - ordinal - 1;
+    const remainingTabs = scopeTotal - scopeOrdinal - 1;
     const targetIndex = alignmentTabStopsPx.length - 1 - remainingTabs;
     if (targetIndex < 0 || targetIndex >= alignmentTabStopsPx.length)
       return null;
@@ -290729,21 +291269,21 @@ menclose::after {
     const leaders = [];
     const effectiveIndent = lineIndex === 0 ? indentLeft + rawFirstLineOffset : indentLeft;
     const maxAbsWidth = typeof line.maxWidth === "number" && Number.isFinite(line.maxWidth) ? line.maxWidth + effectiveIndent : Number.POSITIVE_INFINITY;
-    const applyTab = (startRunIndex, startChar, run2, tabOrdinal) => {
+    const applyTab = (startRunIndex, startChar, run2, tabOrdinal, tabRunIdx) => {
       const originX = cursorX;
       const absCurrentX = cursorX + effectiveIndent;
       let stop;
       let target;
-      const forcedAlignment = typeof tabOrdinal === "number" && Number.isFinite(tabOrdinal) ? getAlignmentStopForOrdinal(tabOrdinal) : null;
+      const greedy = getNextTabStopPx$1(absCurrentX, tabStops, tabStopCursor);
+      const forcedAlignment = greedy.stop?.source === "default" && typeof tabOrdinal === "number" && Number.isFinite(tabOrdinal) ? getAlignmentStopForOrdinal(tabOrdinal, tabRunIdx) : null;
       if (forcedAlignment && forcedAlignment.stop.pos > absCurrentX + TAB_EPSILON$1) {
         stop = forcedAlignment.stop;
         target = forcedAlignment.stop.pos;
         tabStopCursor = forcedAlignment.index + 1;
       } else {
-        const next2 = getNextTabStopPx$1(absCurrentX, tabStops, tabStopCursor);
-        stop = next2.stop;
-        target = next2.target;
-        tabStopCursor = next2.nextIndex;
+        stop = greedy.stop;
+        target = greedy.target;
+        tabStopCursor = greedy.nextIndex;
       }
       const clampedTarget = Number.isFinite(maxAbsWidth) ? Math.min(target, maxAbsWidth) : target;
       const relativeTarget = clampedTarget - effectiveIndent;
@@ -290788,7 +291328,7 @@ menclose::after {
         continue;
       if (run2.kind === "tab") {
         const ordinal = consumeTabOrdinal(run2.tabIndex);
-        applyTab(runIndex + 1, 0, run2, ordinal);
+        applyTab(runIndex + 1, 0, run2, ordinal, runIndex);
         continue;
       }
       const text5 = runText(run2);
@@ -298527,12 +299067,12 @@ menclose::after {
     return;
   console.log(...args$1);
 }, HEADER_FOOTER_INIT_BUDGET_MS = 200, MAX_ZOOM_WARNING_THRESHOLD = 10, MAX_SELECTION_RECTS_PER_USER = 100, SEMANTIC_RESIZE_DEBOUNCE_MS = 120, MIN_SEMANTIC_CONTENT_WIDTH_PX = 1, GLOBAL_PERFORMANCE, PresentationEditor, ICONS, TEXTS, tableActionsOptions;
-var init_src_JQdl170N_es = __esm(() => {
+var init_src_4bO9QmBD_es = __esm(() => {
   init_rolldown_runtime_Bg48TavK_es();
-  init_SuperConverter_DFi0X147_es();
+  init_SuperConverter_ing_1fvK_es();
   init_jszip_C49i9kUs_es();
   init_uuid_qzgm05fK_es();
-  init_create_headless_toolbar_C9nvGdZQ_es();
+  init_create_headless_toolbar_B_1fvPL0_es();
   init_constants_DrU4EASo_es();
   init_dist_B8HfvhaK_es();
   init_unified_Dsuw2be5_es();
@@ -326089,7 +326629,10 @@ function print() { __p += __j.call(arguments, '') }
         const separatorPositions = this.getColumnSeparatorPositions(columns, leftMargin, contentWidth);
         if (separatorPositions.length === 0)
           continue;
+        const fragmentsInRegion = page.fragments.filter((f2) => f2.y >= yStart - 0.5 && f2.y < yEnd + 0.5);
         for (const separatorX of separatorPositions) {
+          if (!fragmentsInRegion.some((f2) => f2.x >= separatorX))
+            continue;
           const separatorEl = this.doc.createElement("div");
           separatorEl.dataset.superdocColumnSeparator = "true";
           separatorEl.style.position = "absolute";
@@ -335938,11 +336481,11 @@ function print() { __p += __j.call(arguments, '') }
   ];
 });
 
-// ../../packages/superdoc/dist/chunks/create-super-doc-ui-_B0b9R4K.es.js
+// ../../packages/superdoc/dist/chunks/create-super-doc-ui-CPZeYqzS.es.js
 var MOD_ALIASES, ALT_ALIASES, CTRL_ALIASES, SHIFT_ALIASES, BUILTIN_CONTEXT_MENU_GROUPS, BUILTIN_GROUP_ORDER, RESERVED_PROXY_PROPERTY_NAMES, ALL_TOOLBAR_COMMAND_IDS, EMPTY_ACTIVE_IDS;
-var init_create_super_doc_ui__B0b9R4K_es = __esm(() => {
-  init_SuperConverter_DFi0X147_es();
-  init_create_headless_toolbar_C9nvGdZQ_es();
+var init_create_super_doc_ui_CPZeYqzS_es = __esm(() => {
+  init_SuperConverter_ing_1fvK_es();
+  init_create_headless_toolbar_B_1fvPL0_es();
   MOD_ALIASES = new Set([
     "Mod",
     "Meta",
@@ -335984,16 +336527,16 @@ var init_zipper_BxRAi0_5_es = __esm(() => {
 
 // ../../packages/superdoc/dist/super-editor.es.js
 var init_super_editor_es = __esm(() => {
-  init_src_JQdl170N_es();
-  init_SuperConverter_DFi0X147_es();
+  init_src_4bO9QmBD_es();
+  init_SuperConverter_ing_1fvK_es();
   init_jszip_C49i9kUs_es();
   init_xml_js_CqGKpaft_es();
-  init_create_headless_toolbar_C9nvGdZQ_es();
+  init_create_headless_toolbar_B_1fvPL0_es();
   init_constants_DrU4EASo_es();
   init_dist_B8HfvhaK_es();
   init_unified_Dsuw2be5_es();
   init_DocxZipper_CUX64E5K_es();
-  init_create_super_doc_ui__B0b9R4K_es();
+  init_create_super_doc_ui_CPZeYqzS_es();
   init_ui_CGB3qmy3_es();
   init_eventemitter3_UwU_CLPU_es();
   init_errors_C_DoKMoN_es();

package/package.json

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