@extend-ai/react-docx 0.6.0 → 0.6.2

package/dist/index.cjs

@@ -3978,10 +3978,14 @@ function parseParagraphRuns(paragraphXml2, context) {
       }
     }
   });
+  let hyperlinkRangeCursor = 0;
   return runRanges.map((range, runIndex) => {
-    const link = hyperlinkRanges.find(
-      (hyperlinkRange) => range.start >= hyperlinkRange.start && range.end <= hyperlinkRange.end && hyperlinkRange.href
-    )?.href ?? fieldLinksByRun.get(runIndex);
+    while (hyperlinkRangeCursor < hyperlinkRanges.length && hyperlinkRanges[hyperlinkRangeCursor].end <= range.start) {
+      hyperlinkRangeCursor += 1;
+    }
+    const currentHyperlinkRange = hyperlinkRanges[hyperlinkRangeCursor];
+    const hyperlinkHref = currentHyperlinkRange && range.start >= currentHyperlinkRange.start && range.end <= currentHyperlinkRange.end ? currentHyperlinkRange.href : void 0;
+    const link = hyperlinkHref ?? fieldLinksByRun.get(runIndex);
     return {
       xml: paragraphXml2.slice(range.start, range.end),
       start: range.start,
@@ -4577,9 +4581,14 @@ function parseParagraph(paragraphXml2, context) {
     runs
   );
   const contentTokens = [];
+  let formFieldTokenCursor = 0;
   for (const run of runs) {
-    const insideFormField = formFieldTokens.some(
-      (formFieldToken) => run.start >= formFieldToken.start && run.end <= formFieldToken.end
+    while (formFieldTokenCursor < formFieldTokens.length && formFieldTokens[formFieldTokenCursor].end <= run.start) {
+      formFieldTokenCursor += 1;
+    }
+    const currentFormFieldToken = formFieldTokens[formFieldTokenCursor];
+    const insideFormField = Boolean(
+      currentFormFieldToken && run.start >= currentFormFieldToken.start && run.end <= currentFormFieldToken.end
     );
     if (insideFormField) {
       continue;
@@ -7799,107 +7808,6 @@ function parseParagraphsFromClipboard(input) {
   }
 }
 
-// src/docx-import-worker-client.ts
-var import_meta = {};
-var cachedWorker;
-var cachedWorkerUnavailable = false;
-var nextRequestId = 1;
-function resolveWorker() {
-  if (cachedWorkerUnavailable) {
-    return void 0;
-  }
-  if (cachedWorker) {
-    return cachedWorker;
-  }
-  if (typeof window === "undefined" || typeof Worker === "undefined" || typeof URL === "undefined") {
-    cachedWorkerUnavailable = true;
-    return void 0;
-  }
-  try {
-    const workerUrl = new URL(
-      "./docx-import-worker.ts",
-      import_meta.url
-    );
-    cachedWorker = new Worker(workerUrl, {
-      type: "module",
-      name: "docx-import"
-    });
-    return cachedWorker;
-  } catch {
-    cachedWorkerUnavailable = true;
-    cachedWorker = void 0;
-    return void 0;
-  }
-}
-async function importDocxOnMainThread(buffer) {
-  const pkg = await parseDocx(buffer);
-  const model = buildDocModel(pkg);
-  return { pkg, model };
-}
-async function importDocxViaWorker(buffer) {
-  const worker = resolveWorker();
-  if (!worker) {
-    return importDocxOnMainThread(buffer);
-  }
-  const requestId = nextRequestId;
-  nextRequestId += 1;
-  return new Promise((resolve, reject) => {
-    const handleMessage = (event) => {
-      const data = event.data;
-      if (!data || data.requestId !== requestId) {
-        return;
-      }
-      worker.removeEventListener("message", handleMessage);
-      worker.removeEventListener("error", handleError);
-      worker.removeEventListener("messageerror", handleMessageError);
-      if (data.type === "imported") {
-        resolve({ pkg: data.pkg, model: data.model });
-      } else {
-        reject(new Error(data.message));
-      }
-    };
-    const handleError = (event) => {
-      worker.removeEventListener("message", handleMessage);
-      worker.removeEventListener("error", handleError);
-      worker.removeEventListener("messageerror", handleMessageError);
-      const message = event instanceof ErrorEvent && event.message ? event.message : "DOCX import worker crashed";
-      try {
-        worker.terminate();
-      } catch {
-      }
-      if (cachedWorker === worker) {
-        cachedWorker = void 0;
-      }
-      reject(new Error(message));
-    };
-    const handleMessageError = () => {
-      handleError(new Event("messageerror"));
-    };
-    worker.addEventListener("message", handleMessage);
-    worker.addEventListener("error", handleError);
-    worker.addEventListener("messageerror", handleMessageError);
-    const request = {
-      type: "import",
-      requestId,
-      buffer
-    };
-    try {
-      worker.postMessage(request, [buffer]);
-    } catch (error) {
-      worker.removeEventListener("message", handleMessage);
-      worker.removeEventListener("error", handleError);
-      worker.removeEventListener("messageerror", handleMessageError);
-      if (typeof console !== "undefined") {
-        console.warn(
-          "DOCX import worker postMessage failed; falling back to main thread.",
-          error
-        );
-      }
-      importDocxOnMainThread(buffer).then(resolve, reject);
-    }
-  });
-}
-
 // ../serializer/src/index.ts
 var REL_TYPE_IMAGE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
 var REL_TYPE_HYPERLINK = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink";
@@ -9095,6 +9003,9 @@ function paragraphHasExplicitPageBreak(paragraph) {
   return sourceXml.length > 0 && PAGE_BREAK_XML_PATTERN.test(sourceXml);
 }
 function paragraphHasPageBreakBefore(paragraph) {
+  if (paragraph.style?.pageBreakBefore === true) {
+    return true;
+  }
   const sourceXml = paragraph.sourceXml ?? "";
   if (!sourceXml) {
     return false;
@@ -9430,10 +9341,12 @@ function reconcilePageCountCandidateToTargetCountByScalingHeight(options) {
 
 // src/pretext-layout.ts
 var import_pretext = require("@chenglou/pretext");
-var PREPARED_TEXT_CACHE_MAX_ENTRIES = 512;
-var LAYOUT_CACHE_MAX_ENTRIES = 256;
+var PREPARED_TEXT_CACHE_MAX_ENTRIES = 8192;
+var LAYOUT_CACHE_MAX_ENTRIES = 4096;
+var LINE_COUNT_CACHE_MAX_ENTRIES = 16384;
 var preparedTextByKey = /* @__PURE__ */ new Map();
 var layoutByKey = /* @__PURE__ */ new Map();
+var lineCountByKey = /* @__PURE__ */ new Map();
 var fragmentOffsetAdvancesByFragment = /* @__PURE__ */ new WeakMap();
 var graphemeOffsetsByText = /* @__PURE__ */ new Map();
 var measureCanvas;
@@ -9442,6 +9355,24 @@ var graphemeSegmenter;
 function canUsePretext() {
   return typeof OffscreenCanvas !== "undefined" || typeof document !== "undefined";
 }
+function getCachedValue(cache, key) {
+  const cached = cache.get(key);
+  if (cached === void 0) {
+    return void 0;
+  }
+  cache.delete(key);
+  cache.set(key, cached);
+  return cached;
+}
+function trimCache(cache, maxEntries) {
+  while (cache.size > maxEntries) {
+    const firstKey = cache.keys().next().value;
+    if (firstKey === void 0) {
+      break;
+    }
+    cache.delete(firstKey);
+  }
+}
 function getMeasureContext() {
   if (!canUsePretext()) {
     return void 0;
@@ -9628,7 +9559,7 @@ function prepareCached(text, font, wordBreak = "normal") {
     return void 0;
   }
   const cacheKey = `${font}\0${wordBreak}\0${text}`;
-  const cached = preparedTextByKey.get(cacheKey);
+  const cached = getCachedValue(preparedTextByKey, cacheKey);
   if (cached) {
     return cached;
   }
@@ -9638,13 +9569,7 @@ function prepareCached(text, font, wordBreak = "normal") {
       wordBreak
     });
     preparedTextByKey.set(cacheKey, prepared);
-    while (preparedTextByKey.size > PREPARED_TEXT_CACHE_MAX_ENTRIES) {
-      const firstKey = preparedTextByKey.keys().next().value;
-      if (!firstKey) {
-        break;
-      }
-      preparedTextByKey.delete(firstKey);
-    }
+    trimCache(preparedTextByKey, PREPARED_TEXT_CACHE_MAX_ENTRIES);
     return prepared;
   } catch {
     return void 0;
@@ -9655,13 +9580,21 @@ function measurePretextPlainTextLineCount(text, font, containerWidthPx, options)
     return 0;
   }
   const wordBreak = options?.wordBreak ?? "normal";
+  const safeWidth = Math.max(1, Math.round(containerWidthPx));
+  const cacheKey = `line-count\0${font}\0${wordBreak}\0${safeWidth}\0${text}`;
+  const cached = getCachedValue(lineCountByKey, cacheKey);
+  if (cached !== void 0) {
+    return cached;
+  }
   const prepared = prepareCached(text, font, wordBreak);
   if (!prepared) {
     return void 0;
   }
   try {
-    const safeWidth = Math.max(1, Math.round(containerWidthPx));
-    return (0, import_pretext.measureLineStats)(prepared, safeWidth).lineCount;
+    const lineCount = (0, import_pretext.measureLineStats)(prepared, safeWidth).lineCount;
+    lineCountByKey.set(cacheKey, lineCount);
+    trimCache(lineCountByKey, LINE_COUNT_CACHE_MAX_ENTRIES);
+    return lineCount;
   } catch {
     return void 0;
   }
@@ -9921,7 +9854,7 @@ function layoutTextWithPretextAroundExclusions(text, font, containerWidthPx, lin
     safeLineHeightPx,
     normalizedExclusions
   );
-  const cachedLayout = layoutByKey.get(cacheKey);
+  const cachedLayout = getCachedValue(layoutByKey, cacheKey);
   if (cachedLayout) {
     return cachedLayout;
   }
@@ -9995,13 +9928,7 @@ function layoutTextWithPretextAroundExclusions(text, font, containerWidthPx, lin
     exclusions: normalizedExclusions
   };
   layoutByKey.set(cacheKey, nextLayout);
-  while (layoutByKey.size > LAYOUT_CACHE_MAX_ENTRIES) {
-    const firstKey = layoutByKey.keys().next().value;
-    if (!firstKey) {
-      break;
-    }
-    layoutByKey.delete(firstKey);
-  }
+  trimCache(layoutByKey, LAYOUT_CACHE_MAX_ENTRIES);
   return nextLayout;
 }
 function layoutItemsWithPretextAroundExclusions(text, items, containerWidthPx, lineHeightPx, exclusions, fallbackFont) {
@@ -10053,7 +9980,7 @@ function layoutItemsWithPretextAroundExclusions(text, items, containerWidthPx, l
     safeLineHeightPx,
     normalizedExclusions
   );
-  const cachedLayout = layoutByKey.get(cacheKey);
+  const cachedLayout = getCachedValue(layoutByKey, cacheKey);
   if (cachedLayout) {
     return cachedLayout;
   }
@@ -10167,13 +10094,7 @@ function layoutItemsWithPretextAroundExclusions(text, items, containerWidthPx, l
     exclusions: normalizedExclusions
   };
   layoutByKey.set(cacheKey, nextLayout);
-  while (layoutByKey.size > LAYOUT_CACHE_MAX_ENTRIES) {
-    const firstKey = layoutByKey.keys().next().value;
-    if (!firstKey) {
-      break;
-    }
-    layoutByKey.delete(firstKey);
-  }
+  trimCache(layoutByKey, LAYOUT_CACHE_MAX_ENTRIES);
   return nextLayout;
 }
 function resolveOffsetAtPoint(layout, x, y) {
@@ -10466,8 +10387,12 @@ var INITIAL_PAGINATION_PAGE_COUNT_OSCILLATION_DISTINCT_THRESHOLD = 2;
 var INITIAL_PAGINATION_PAGE_COUNT_OSCILLATION_CHANGE_THRESHOLD = 4;
 var INITIAL_PAGINATION_BACKGROUND_REFINEMENT_DELAY_MS = 96;
 var DEFAULT_PAGE_VIRTUALIZATION_OVERSCAN = 2;
+var LARGE_TABLE_PAGE_VIRTUALIZATION_OVERSCAN = 0;
+var LARGE_TABLE_PAGE_ADJACENT_RENDER_COUNT = 1;
 var DEFAULT_PAGE_VIRTUALIZATION_SETTLE_DELAY_MS = 350;
 var ENABLE_TABLE_ROW_SLICING = true;
+var MIN_TABLE_ROW_SLICE_REMAINING_HEIGHT_PX = MIN_PARAGRAPH_LINE_HEIGHT_PX * 2;
+var TABLE_ROW_SLICE_BOUNDARY_TOLERANCE_PX = 2;
 var TOP_AND_BOTTOM_VERTICAL_DRAG_SNAP_PX = 10;
 var HEADER_FOOTER_INACTIVE_OPACITY = 0.5;
 var LETTERHEAD_INDENT_MIN_TWIPS = 900;
@@ -10503,6 +10428,10 @@ var paragraphDropCapBySourceXml = /* @__PURE__ */ new Map();
 var paragraphTrackedMarkupBySourceXml = /* @__PURE__ */ new Map();
 var paragraphMeasureCanvasContext;
 var textWidthByFontAndValue = /* @__PURE__ */ new Map();
+var estimatedTextAdvanceWidthByFontAndValue = /* @__PURE__ */ new Map();
+var pretextWordBreakModeByText = /* @__PURE__ */ new Map();
+var paragraphBaseFontSizePxByParagraph = /* @__PURE__ */ new WeakMap();
+var paragraphDominantFontFamilyByParagraph = /* @__PURE__ */ new WeakMap();
 function setCacheEntry(cache, key, value) {
   if (!cache.has(key) && cache.size >= XML_CACHE_MAX_ENTRIES) {
     const oldestKey = cache.keys().next().value;
@@ -11966,7 +11895,23 @@ function resolvePageContentHeightPxForPageSegments(pageSegments, pageIndex, defa
   );
 }
 function resolveRenderPageContentHeightPxForPageSegments(params) {
-  const resolvedHeightPx = resolvePageContentHeightPxForPageSegments(
+  const firstNodeIndex = params.pageSegments[0]?.nodeIndex ?? 0;
+  const metricsIndex = resolvePaginationSectionMetricsIndexForNodeIndex(
+    params.metricsBySection,
+    firstNodeIndex,
+    0
+  );
+  const sectionHeightMultiplier = Math.max(
+    1,
+    Math.round(
+      params.metricsBySection[metricsIndex]?.pageContentHeightMultiplier ?? 1
+    )
+  );
+  const pageContainsOnlySplitParagraphSegments = documentPageContainsOnlySplitParagraphSegments(params.pageSegments);
+  const measuredHeightPx = params.useMeasuredPageContentHeights === false ? void 0 : params.measuredPageContentHeightsPxByPageIndex?.[params.pageIndex];
+  const measuredHeightMatchesCurrentPage = params.pageIdentityKey === void 0 || params.measuredPageContentIdentityKeysByPageIndex?.[params.pageIndex] === void 0 || params.measuredPageContentIdentityKeysByPageIndex?.[params.pageIndex] === params.pageIdentityKey;
+  const usesMeasuredVisualHeight = Number.isFinite(measuredHeightPx) && measuredHeightMatchesCurrentPage && !pageContainsOnlySplitParagraphSegments;
+  let resolvedHeightPx = resolvePageContentHeightPxForPageSegments(
     params.pageSegments,
     params.pageIndex,
     params.defaultPageContentHeightPx,
@@ -11976,12 +11921,15 @@ function resolveRenderPageContentHeightPxForPageSegments(params) {
     params.pageIdentityKey
   );
   if (params.useMeasuredPageContentHeights === false && Number.isFinite(params.pageContentHeightScale) && Math.abs(params.pageContentHeightScale - 1) >= 1e-3) {
-    return Math.max(
+    resolvedHeightPx = Math.max(
       120,
       Math.round(resolvedHeightPx * params.pageContentHeightScale)
     );
   }
-  return resolvedHeightPx;
+  if (usesMeasuredVisualHeight || sectionHeightMultiplier <= 1) {
+    return resolvedHeightPx;
+  }
+  return Math.max(120, Math.round(resolvedHeightPx / sectionHeightMultiplier));
 }
 function documentPageContainsOnlySplitParagraphSegments(pageSegments) {
   return pageSegments.length > 0 && pageSegments.every(
@@ -12535,7 +12483,9 @@ function firstExplicitFontFamilyInNodeTree(nodes) {
     if (node.type === "table") {
       for (const row of node.rows) {
         for (const cell of row.cells) {
-          const nestedFontFamily = firstExplicitFontFamilyInNodeTree(cell.nodes);
+          const nestedFontFamily = firstExplicitFontFamilyInNodeTree(
+            cell.nodes
+          );
           if (nestedFontFamily) {
             return nestedFontFamily;
           }
@@ -13441,11 +13391,19 @@ function buildParagraphPretextTabSpacerText(widthPx, style, paragraphBaseFontPx)
   while (measuredWidthPx + spacerAdvancePx * 0.5 < safeWidthPx && spacerCount < 64) {
     spacerCount += 1;
     spacerText = spacerCharacter.repeat(spacerCount);
-    measuredWidthPx = measureTextWidthPx2(spacerText, style, paragraphBaseFontPx);
+    measuredWidthPx = measureTextWidthPx2(
+      spacerText,
+      style,
+      paragraphBaseFontPx
+    );
   }
   while (spacerCount > 1) {
     const nextText = spacerCharacter.repeat(spacerCount - 1);
-    const nextWidthPx = measureTextWidthPx2(nextText, style, paragraphBaseFontPx);
+    const nextWidthPx = measureTextWidthPx2(
+      nextText,
+      style,
+      paragraphBaseFontPx
+    );
     if (Math.abs(nextWidthPx - safeWidthPx) >= Math.abs(measuredWidthPx - safeWidthPx)) {
       break;
     }
@@ -13736,7 +13694,20 @@ function buildSyntheticPretextLayoutSource(text, style) {
   };
 }
 function pretextWordBreakModeForText(text) {
-  return KEEP_ALL_SCRIPT_RE.test(text) ? "keep-all" : "normal";
+  const cached = pretextWordBreakModeByText.get(text);
+  if (cached) {
+    return cached;
+  }
+  const mode = KEEP_ALL_SCRIPT_RE.test(text) ? "keep-all" : "normal";
+  setCacheEntry(pretextWordBreakModeByText, text, mode);
+  while (pretextWordBreakModeByText.size > TEXT_MEASURE_CACHE_MAX_ENTRIES) {
+    const firstKey = pretextWordBreakModeByText.keys().next().value;
+    if (!firstKey) {
+      break;
+    }
+    pretextWordBreakModeByText.delete(firstKey);
+  }
+  return mode;
 }
 function sanitizeRenderedPretextFragmentText(text) {
   return text.replace(/\r\n?|\n/g, "");
@@ -14220,36 +14191,55 @@ function estimateTextAdvanceWidthPx(text, style) {
   if (!text) {
     return 0;
   }
-  const normalized = text.replace(/\u00a0/g, " ");
   const fontSizePx = runFontSizePx(style);
+  const normalized = text.includes("\xA0") ? text.replace(/\u00a0/g, " ") : text;
+  const cacheKey = `${fontSizePx}\0${normalized}`;
+  const cached = estimatedTextAdvanceWidthByFontAndValue.get(cacheKey);
+  if (cached !== void 0) {
+    return cached;
+  }
   let total = 0;
-  for (const char of normalized) {
-    if (char === "\n" || char === "\r") {
+  for (let index = 0; index < normalized.length; index += 1) {
+    const code = normalized.charCodeAt(index);
+    if (code === 10 || code === 13) {
       continue;
     }
-    if (char === "	") {
+    if (code === 9) {
       total += fontSizePx * 2;
       continue;
     }
-    if (char === " ") {
+    if (code === 32) {
       total += fontSizePx * 0.33;
       continue;
     }
-    if (/[.,:;'"`!|ilI1]/.test(char)) {
+    if (code === 33 || code === 39 || code === 44 || code === 46 || code === 49 || code === 58 || code === 59 || code === 73 || code === 96 || code === 105 || code === 108 || code === 124) {
       total += fontSizePx * 0.29;
       continue;
     }
-    if (/[A-Z0-9]/.test(char)) {
+    if (code >= 65 && code <= 90 || code >= 48 && code <= 57) {
       total += fontSizePx * 0.6;
       continue;
     }
-    if (/[\u3000-\u9fff]/.test(char)) {
+    if (code >= 12288 && code <= 40959) {
       total += fontSizePx * 0.95;
       continue;
     }
     total += fontSizePx * 0.54;
   }
-  return Math.max(0, Math.round(total));
+  const estimatedWidthPx = Math.max(0, Math.round(total));
+  setCacheEntry(
+    estimatedTextAdvanceWidthByFontAndValue,
+    cacheKey,
+    estimatedWidthPx
+  );
+  while (estimatedTextAdvanceWidthByFontAndValue.size > TEXT_MEASURE_CACHE_MAX_ENTRIES) {
+    const firstKey = estimatedTextAdvanceWidthByFontAndValue.keys().next().value;
+    if (!firstKey) {
+      break;
+    }
+    estimatedTextAdvanceWidthByFontAndValue.delete(firstKey);
+  }
+  return estimatedWidthPx;
 }
 function updateEstimatedLineWidthPxForText(currentLineWidthPx, text, style) {
   if (!text) {
@@ -14555,7 +14545,8 @@ function paragraphHasLastRenderedPageBreak(paragraph) {
   if (cached) {
     return cached.lastRenderedPageBreak;
   }
-  return paragraphHasExplicitPageBreak2(paragraph) ? paragraphBreakFlagsBySourceXml.get(xml)?.lastRenderedPageBreak ?? false : false;
+  paragraphHasExplicitPageBreak2(paragraph);
+  return paragraphBreakFlagsBySourceXml.get(xml)?.lastRenderedPageBreak ?? false;
 }
 function paragraphStartsWithLastRenderedPageBreak(paragraph) {
   const xml = paragraph.sourceXml ?? "";
@@ -14729,7 +14720,8 @@ function paragraphHasPageBreakBefore2(paragraph) {
   if (cached) {
     return cached.pageBreakBefore;
   }
-  return paragraphHasExplicitPageBreak2(paragraph) ? paragraphBreakFlagsBySourceXml.get(xml)?.pageBreakBefore ?? false : false;
+  paragraphHasExplicitPageBreak2(paragraph);
+  return paragraphBreakFlagsBySourceXml.get(xml)?.pageBreakBefore ?? false;
 }
 function sectionBreakAfterParagraphStartsNewPage(paragraph) {
   const xml = paragraph.sourceXml ?? "";
@@ -14909,9 +14901,15 @@ function paragraphDominantFontSizePt(paragraph) {
   return dominantFontSizePt;
 }
 function paragraphBaseFontSizePx(paragraph) {
+  const cached = paragraphBaseFontSizePxByParagraph.get(paragraph);
+  if (cached !== void 0) {
+    return cached;
+  }
   const dominantRunFontSizePt = paragraphDominantFontSizePt(paragraph);
   const fontSizePt = dominantRunFontSizePt && dominantRunFontSizePt > 0 ? dominantRunFontSizePt : Number.isFinite(paragraph.style?.headingLevel) ? DEFAULT_PARAGRAPH_FONT_SIZE_PT + Math.max(0, 6 - (paragraph.style?.headingLevel ?? 6)) : DEFAULT_PARAGRAPH_FONT_SIZE_PT;
-  return Math.max(10, Math.round(fontSizePt * 96 / 72));
+  const baseFontSizePx = Math.max(10, Math.round(fontSizePt * 96 / 72));
+  paragraphBaseFontSizePxByParagraph.set(paragraph, baseFontSizePx);
+  return baseFontSizePx;
 }
 function paragraphMaxFontSizePx(paragraph) {
   const paragraphBaseFontPx = paragraphBaseFontSizePx(paragraph);
@@ -14936,6 +14934,10 @@ function normalizeFontFamilyToken(fontFamily) {
   return normalized || void 0;
 }
 function paragraphDominantFontFamily(paragraph) {
+  const cached = paragraphDominantFontFamilyByParagraph.get(paragraph);
+  if (cached !== void 0) {
+    return cached ?? void 0;
+  }
   const weightByFamily = /* @__PURE__ */ new Map();
   const addWeight = (fontFamily, weight) => {
     const normalizedFamily = normalizeFontFamilyToken(fontFamily);
@@ -14956,6 +14958,7 @@ function paragraphDominantFontFamily(paragraph) {
     addWeight(child.style?.fontFamily, text.length);
   });
   if (weightByFamily.size === 0) {
+    paragraphDominantFontFamilyByParagraph.set(paragraph, null);
     return void 0;
   }
   let dominantFamily;
@@ -14966,6 +14969,7 @@ function paragraphDominantFontFamily(paragraph) {
       dominantWeight = weight;
     }
   }
+  paragraphDominantFontFamilyByParagraph.set(paragraph, dominantFamily ?? null);
   return dominantFamily;
 }
 function singleLineAutoScaleForFontFamily(fontFamily) {
@@ -15303,12 +15307,37 @@ function estimateTabLeaderWrappedLineCountForParagraph(paragraph, maxLineWidthPx
     paragraphBaseFontPx
   );
 }
+var wrappedLineCountByParagraph = /* @__PURE__ */ new WeakMap();
+function cachedWrappedLineCountForParagraph(paragraph, widthPx) {
+  return wrappedLineCountByParagraph.get(paragraph)?.get(widthPx);
+}
+function rememberWrappedLineCountForParagraph(paragraph, widthPx, lineCount) {
+  let countsByWidth = wrappedLineCountByParagraph.get(paragraph);
+  if (!countsByWidth) {
+    countsByWidth = /* @__PURE__ */ new Map();
+    wrappedLineCountByParagraph.set(paragraph, countsByWidth);
+  }
+  countsByWidth.set(widthPx, lineCount);
+  return lineCount;
+}
 function estimateWrappedLineCountForParagraph(paragraph, availableWidthPx) {
   const paragraphBaseFontPx = paragraphBaseFontSizePx(paragraph);
   const maxLineWidthPx = Math.max(
     paragraphBaseFontPx * 2,
     Math.round(availableWidthPx)
   );
+  const cachedLineCount = cachedWrappedLineCountForParagraph(
+    paragraph,
+    maxLineWidthPx
+  );
+  if (cachedLineCount !== void 0) {
+    return cachedLineCount;
+  }
+  const rememberLineCount = (lineCount2) => rememberWrappedLineCountForParagraph(
+    paragraph,
+    maxLineWidthPx,
+    Math.max(1, Math.round(lineCount2))
+  );
   const tabStopsPx = resolveParagraphTabStopsPx(paragraph);
   const useTabLeaderLayout = paragraphUsesTabLeaders(paragraph);
   const anchoredTabLayout = paragraphAnchoredTabLayout(paragraph);
@@ -15349,7 +15378,7 @@ function estimateWrappedLineCountForParagraph(paragraph, availableWidthPx) {
       return layout?.lineCount;
     })();
     if (pretextPlainLineCount) {
-      return Math.max(1, pretextPlainLineCount);
+      return rememberLineCount(pretextPlainLineCount);
     }
   }
   if (useTabLeaderLayout) {
@@ -15359,7 +15388,7 @@ function estimateWrappedLineCountForParagraph(paragraph, availableWidthPx) {
       paragraphBaseFontPx
     );
     if (tabLeaderLineCount !== void 0) {
-      return tabLeaderLineCount;
+      return rememberLineCount(tabLeaderLineCount);
     }
   }
   let lineCount = 1;
@@ -15477,7 +15506,7 @@ function estimateWrappedLineCountForParagraph(paragraph, availableWidthPx) {
       commitToken(token, child.style);
     }
   }
-  return hasVisibleContent ? Math.max(1, lineCount) : 1;
+  return rememberLineCount(hasVisibleContent ? lineCount : 1);
 }
 function paragraphAvailableTextWidthPx(paragraph, availableWidthPx, numberingDefinitions) {
   const safeAvailableWidthPx = Math.max(24, Math.round(availableWidthPx));
@@ -16030,6 +16059,11 @@ function rowHasDeepFlowContent(row) {
   }
   return nestedTableCount > 0 || blockNodeCount >= SPLITTABLE_TABLE_ROW_DEEP_CONTENT_NODE_THRESHOLD;
 }
+function rowHasNestedTableContent(row) {
+  return row.cells.some(
+    (cell) => cell.nodes.some((contentNode) => contentNode.type === "table")
+  );
+}
 function capSplitFriendlyTableRowEstimatePx(row, estimatedRowHeightPx, explicitHeightPx, pageContentHeightPx) {
   if (!rowAllowsPageSplit(row)) {
     return estimatedRowHeightPx;
@@ -16163,6 +16197,280 @@ function estimateTableRowHeightsPx(table, maxAvailableWidthPx, numberingDefiniti
     return Math.max(MIN_PARAGRAPH_LINE_HEIGHT_PX, rowHeightPx);
   });
 }
+function uniqueSortedPixelBoundaries(values) {
+  const sorted = values.filter((value) => Number.isFinite(value)).map((value) => Math.max(0, Math.round(value))).sort((left, right) => left - right);
+  const unique = [];
+  for (const value of sorted) {
+    const previous = unique[unique.length - 1];
+    if (previous === void 0 || Math.abs(previous - value) > TABLE_ROW_SLICE_BOUNDARY_TOLERANCE_PX) {
+      unique.push(value);
+    }
+  }
+  return unique;
+}
+function estimateParagraphBoundaryOffsetsPx(paragraph, availableWidthPx, numberingDefinitions, applyWordTableDefaults, docGridLinePitchPx, paragraphIndex) {
+  const paragraphForLayout = wordLikeTableCellParagraph(
+    paragraph,
+    applyWordTableDefaults
+  );
+  const disableDocGridSnap = paragraphDocGridSnapState(paragraph) === "disable";
+  const paragraphHeightPx = estimateParagraphHeightPx(
+    paragraphForLayout,
+    availableWidthPx,
+    numberingDefinitions,
+    docGridLinePitchPx,
+    disableDocGridSnap
+  );
+  const suppressTopSpacing = paragraphIndex === 0 && suppressFirstTableCellParagraphTopSpacing(paragraph);
+  const beforeSpacingPx = suppressTopSpacing ? 0 : twipsToPixels(paragraphForLayout.style?.spacing?.beforeTwips) ?? 0;
+  const afterSpacingPx = twipsToPixels(paragraphForLayout.style?.spacing?.afterTwips) ?? 0;
+  const topBorderInsetPx = paragraphBorderInsetPx(
+    paragraphForLayout.style?.borders?.top
+  );
+  const bottomBorderInsetPx = paragraphBorderInsetPx(
+    paragraphForLayout.style?.borders?.bottom
+  );
+  const lineHeightPx = Math.max(
+    MIN_PARAGRAPH_LINE_HEIGHT_PX,
+    estimateParagraphLineHeightPx(
+      paragraphForLayout,
+      docGridLinePitchPx,
+      disableDocGridSnap
+    )
+  );
+  const pretextSource = buildParagraphPretextLayoutSource(paragraphForLayout, {
+    allowExplicitLineBreakText: true,
+    expandTabsForLayout: true
+  });
+  const paragraphTextWidthPx = paragraphAvailableTextWidthPx(
+    paragraphForLayout,
+    availableWidthPx,
+    numberingDefinitions
+  );
+  const pretextLayout = pretextSource ? layoutParagraphPretextSource(
+    paragraphForLayout,
+    pretextSource,
+    paragraphTextWidthPx,
+    lineHeightPx,
+    []
+  ) : void 0;
+  const lineTopOffsetsPx = pretextLayout ? pretextLayout.lines.map((line) => Math.max(0, Math.round(line.y))) : Array.from(
+    {
+      length: Math.max(
+        1,
+        paragraphLineCountWithinWidth(
+          paragraphForLayout,
+          availableWidthPx,
+          numberingDefinitions
+        )
+      )
+    },
+    (_, lineIndex) => lineIndex * lineHeightPx
+  );
+  const textTopPx = beforeSpacingPx + topBorderInsetPx;
+  const textHeightPx = pretextLayout ? wrappedPretextParagraphBlockHeightPx(pretextLayout) : lineTopOffsetsPx.length * lineHeightPx;
+  const visualHeightPx = Math.max(
+    1,
+    beforeSpacingPx + topBorderInsetPx + textHeightPx + bottomBorderInsetPx + afterSpacingPx
+  );
+  const heightPx = Math.max(1, paragraphHeightPx, visualHeightPx);
+  const lineBoundariesPx = lineTopOffsetsPx.map(
+    (lineTopPx) => textTopPx + lineTopPx + lineHeightPx
+  );
+  return {
+    heightPx,
+    safeBoundariesPx: uniqueSortedPixelBoundaries([
+      ...lineBoundariesPx,
+      heightPx
+    ])
+  };
+}
+function estimateNestedTableBoundaryOffsetsPx(table, availableWidthPx, numberingDefinitions, docGridLinePitchPx) {
+  const rowHeightsPx = estimateTableRowHeightsPx(
+    table,
+    availableWidthPx,
+    numberingDefinitions,
+    docGridLinePitchPx
+  );
+  const boundariesPx = [];
+  let cursorPx = 0;
+  for (const rowHeightPx of rowHeightsPx) {
+    cursorPx += Math.max(MIN_PARAGRAPH_LINE_HEIGHT_PX, rowHeightPx);
+    boundariesPx.push(cursorPx);
+  }
+  return {
+    heightPx: Math.max(MIN_PARAGRAPH_LINE_HEIGHT_PX, cursorPx),
+    safeBoundariesPx: uniqueSortedPixelBoundaries(boundariesPx)
+  };
+}
+function estimateTableCellSliceBoundaryLayoutPx(params) {
+  const {
+    cell,
+    rowHeightPx,
+    contentWidthPx,
+    tableCellMarginTwips,
+    numberingDefinitions,
+    applyWordTableDefaults,
+    docGridLinePitchPx
+  } = params;
+  const paddingPx = resolveTableSpacingPaddingPx(
+    mergeTableSpacing(tableCellMarginTwips, cell.style?.marginTwips)
+  );
+  const localBoundariesPx = [0, paddingPx.top];
+  let contentCursorPx = paddingPx.top;
+  let paragraphIndex = 0;
+  for (const contentNode of cell.nodes) {
+    const layout = contentNode.type === "paragraph" ? estimateParagraphBoundaryOffsetsPx(
+      contentNode,
+      contentWidthPx,
+      numberingDefinitions,
+      applyWordTableDefaults,
+      docGridLinePitchPx,
+      paragraphIndex++
+    ) : estimateNestedTableBoundaryOffsetsPx(
+      contentNode,
+      contentWidthPx,
+      numberingDefinitions,
+      docGridLinePitchPx
+    );
+    localBoundariesPx.push(
+      ...layout.safeBoundariesPx.map(
+        (boundaryPx) => contentCursorPx + boundaryPx
+      )
+    );
+    contentCursorPx += layout.heightPx;
+  }
+  const contentBottomPx = contentCursorPx + paddingPx.bottom;
+  const contentFlowHeightPx = Math.max(0, contentCursorPx - paddingPx.top);
+  const availableContentHeightPx = Math.max(
+    0,
+    rowHeightPx - paddingPx.top - paddingPx.bottom
+  );
+  const extraVerticalSpacePx = Math.max(
+    0,
+    availableContentHeightPx - contentFlowHeightPx
+  );
+  const verticalOffsetPx = cell.style?.verticalAlign === "center" ? Math.round(extraVerticalSpacePx / 2) : cell.style?.verticalAlign === "bottom" ? extraVerticalSpacePx : 0;
+  return {
+    safeBoundariesPx: uniqueSortedPixelBoundaries(
+      localBoundariesPx.map(
+        (boundaryPx) => Math.min(rowHeightPx, boundaryPx + verticalOffsetPx)
+      )
+    ),
+    contentBottomPx: Math.min(rowHeightPx, contentBottomPx + verticalOffsetPx)
+  };
+}
+function tableCellSliceBoundaryIsSafe(layout, boundaryPx) {
+  if (boundaryPx <= TABLE_ROW_SLICE_BOUNDARY_TOLERANCE_PX) {
+    return true;
+  }
+  if (boundaryPx >= layout.contentBottomPx - TABLE_ROW_SLICE_BOUNDARY_TOLERANCE_PX) {
+    return true;
+  }
+  return layout.safeBoundariesPx.some(
+    (safeBoundaryPx) => Math.abs(safeBoundaryPx - boundaryPx) <= TABLE_ROW_SLICE_BOUNDARY_TOLERANCE_PX
+  );
+}
+function resolveTableRowSliceHeightOnSafeBoundaryPx(params) {
+  const {
+    table,
+    rowIndex,
+    rowHeightPx,
+    rowSliceOffsetPx,
+    preferredSliceHeightPx,
+    maxAvailableWidthPx,
+    numberingDefinitions,
+    docGridLinePitchPx
+  } = params;
+  const row = table.rows[rowIndex];
+  if (!row || !rowHasNestedTableContent(row)) {
+    return preferredSliceHeightPx;
+  }
+  const sliceStartPx = Math.max(0, Math.round(rowSliceOffsetPx));
+  const preferredSliceEndPx = Math.min(
+    rowHeightPx,
+    sliceStartPx + Math.max(0, Math.round(preferredSliceHeightPx))
+  );
+  if (preferredSliceEndPx >= rowHeightPx - TABLE_ROW_SLICE_BOUNDARY_TOLERANCE_PX) {
+    return Math.max(0, rowHeightPx - sliceStartPx);
+  }
+  const columnCount = tableColumnCount(table);
+  const tableWidthPx = twipsToPixels(table.style?.widthTwips);
+  const rawTableColumnWidthsPx = (() => {
+    const definedWidthsTwips = columnWidthsFromTableDefinition(
+      table,
+      columnCount
+    );
+    if (!definedWidthsTwips || definedWidthsTwips.length === 0) {
+      return defaultColumnWidthsPx(columnCount, tableWidthPx);
+    }
+    const widthsPx = definedWidthsTwips.map(
+      (widthTwips) => twipsToPixels(widthTwips) ?? 0
+    );
+    return normalizeColumnWidthsPx(widthsPx, columnCount, tableWidthPx, 1);
+  })();
+  const rawResolvedTableWidthPx = tableWidthPx ?? rawTableColumnWidthsPx.reduce((sum, widthPx) => sum + widthPx, 0);
+  const collapsedHorizontalBorderBleedPx = resolveCollapsedTableHorizontalOuterBleedPx(table, columnCount);
+  const maxTableWidthPx = Number.isFinite(maxAvailableWidthPx) && maxAvailableWidthPx > 0 ? Math.max(
+    120,
+    maxAvailableWidthPx - collapsedHorizontalBorderBleedPx
+  ) : void 0;
+  const resolvedTableWidthPx = clampTableWidthPx(
+    rawResolvedTableWidthPx,
+    maxTableWidthPx
+  );
+  const tableColumnWidthsPx = fitColumnWidthsToWidth(
+    rawTableColumnWidthsPx,
+    resolvedTableWidthPx
+  );
+  const applyWordTableDefaults = tableUsesWordLikeParagraphDefaults(table);
+  const tableCellMarginTwips = table.style?.cellMarginTwips;
+  const cellLayouts = [];
+  const candidateBoundariesPx = [preferredSliceEndPx];
+  let columnCursor = 0;
+  for (const cell of row.cells) {
+    const colSpanValue = cell.style?.gridSpan && cell.style.gridSpan > 1 ? cell.style.gridSpan : 1;
+    const startColumnIndex = columnCursor;
+    const endColumnIndex = Math.min(
+      columnCount - 1,
+      startColumnIndex + colSpanValue - 1
+    );
+    columnCursor += colSpanValue;
+    const spannedWidthPx = tableColumnWidthsPx.slice(startColumnIndex, endColumnIndex + 1).reduce((sum, widthPx) => sum + widthPx, 0);
+    const fallbackCellWidthPx = resolvedTableWidthPx / Math.max(1, columnCount) * colSpanValue;
+    const cellRenderedWidthPx = twipsToPixels(cell.style?.widthTwips) ?? (spannedWidthPx > 0 ? spannedWidthPx : fallbackCellWidthPx);
+    const cellPaddingPx = resolveTableSpacingPaddingPx(
+      mergeTableSpacing(tableCellMarginTwips, cell.style?.marginTwips)
+    );
+    const cellContentWidthPx = Math.max(
+      1,
+      cellRenderedWidthPx - cellPaddingPx.left - cellPaddingPx.right
+    );
+    const cellLayout = estimateTableCellSliceBoundaryLayoutPx({
+      cell,
+      rowHeightPx,
+      contentWidthPx: cellContentWidthPx,
+      tableCellMarginTwips,
+      numberingDefinitions,
+      applyWordTableDefaults,
+      docGridLinePitchPx
+    });
+    cellLayouts.push(cellLayout);
+    candidateBoundariesPx.push(...cellLayout.safeBoundariesPx);
+  }
+  const minimumSliceEndPx = sliceStartPx + Math.max(1, MIN_TABLE_ROW_SLICE_REMAINING_HEIGHT_PX);
+  const candidatesPx = uniqueSortedPixelBoundaries(candidateBoundariesPx).filter(
+    (boundaryPx) => boundaryPx >= minimumSliceEndPx && boundaryPx <= preferredSliceEndPx + TABLE_ROW_SLICE_BOUNDARY_TOLERANCE_PX
+  ).sort((left, right) => right - left);
+  for (const candidatePx of candidatesPx) {
+    if (cellLayouts.every(
+      (layout) => tableCellSliceBoundaryIsSafe(layout, candidatePx)
+    )) {
+      return Math.max(0, candidatePx - sliceStartPx);
+    }
+  }
+  return void 0;
+}
 function estimateTableHeightPx(table, maxAvailableWidthPx, numberingDefinitions, docGridLinePitchPx) {
   const sourceXml = table.sourceXml;
   const widthKey = heightEstimateCacheKeyPx(
@@ -16451,6 +16759,234 @@ function estimateRenderedPageSegmentHeightPx(node, segment, model, availableWidt
     )
   );
 }
+function resolveParagraphColumnRenderLineRange(paragraph, segment, availableWidthPx, numberingDefinitions, docGridLinePitchPx) {
+  const lineHeightPx = Math.max(
+    1,
+    segment.paragraphLineRange?.lineHeightPx ?? estimateParagraphLineHeightPx(paragraph, docGridLinePitchPx)
+  );
+  if (segment.paragraphLineRange) {
+    return {
+      ...segment.paragraphLineRange,
+      lineHeightPx
+    };
+  }
+  const paragraphTextWidthPx = paragraphAvailableTextWidthPx(
+    paragraph,
+    availableWidthPx,
+    numberingDefinitions
+  );
+  const pretextSource = buildParagraphPretextLayoutSource(paragraph, {
+    allowExplicitLineBreakText: true,
+    expandTabsForLayout: true
+  });
+  const pretextLayout = pretextSource ? layoutParagraphPretextSource(
+    paragraph,
+    pretextSource,
+    paragraphTextWidthPx,
+    lineHeightPx,
+    []
+  ) : void 0;
+  const totalLineCount = pretextLayout && pretextLayout.lineCount > 0 ? pretextLayout.lineCount : paragraphLineCountWithinWidth(
+    paragraph,
+    availableWidthPx,
+    numberingDefinitions
+  );
+  return {
+    startLineIndex: 0,
+    endLineIndex: Math.max(1, totalLineCount),
+    totalLineCount: Math.max(1, totalLineCount),
+    lineHeightPx
+  };
+}
+function splitParagraphSegmentForColumnRender(params) {
+  const {
+    paragraph,
+    segment,
+    model,
+    availableWidthPx,
+    availableHeightPx,
+    numberingDefinitions,
+    docGridLinePitchPx
+  } = params;
+  if (segment.tableRowRange || segment.tableRowSlice || paragraphHasExplicitColumnBreak(paragraph)) {
+    return void 0;
+  }
+  const fullLineRange = resolveParagraphColumnRenderLineRange(
+    paragraph,
+    segment,
+    availableWidthPx,
+    numberingDefinitions,
+    docGridLinePitchPx
+  );
+  const startLineIndex = Math.max(0, fullLineRange.startLineIndex);
+  const endLineIndex = Math.max(startLineIndex, fullLineRange.endLineIndex);
+  if (endLineIndex - startLineIndex < 2 || !paragraphCanSplitAcrossPages(paragraph, fullLineRange.totalLineCount)) {
+    return void 0;
+  }
+  const safeAvailableHeightPx = Math.max(0, Math.round(availableHeightPx));
+  let bestSegment;
+  let bestHeightPx = 0;
+  for (let candidateEndLineIndex = startLineIndex + 1; candidateEndLineIndex < endLineIndex; candidateEndLineIndex += 1) {
+    const candidateSegment = {
+      ...segment,
+      paragraphLineRange: {
+        startLineIndex,
+        endLineIndex: candidateEndLineIndex,
+        totalLineCount: fullLineRange.totalLineCount,
+        lineHeightPx: fullLineRange.lineHeightPx
+      }
+    };
+    const candidateHeightPx = estimateRenderedPageSegmentHeightPx(
+      paragraph,
+      candidateSegment,
+      model,
+      availableWidthPx,
+      numberingDefinitions,
+      docGridLinePitchPx
+    );
+    if (candidateHeightPx > safeAvailableHeightPx + PAGE_OVERFLOW_TOLERANCE_PX) {
+      break;
+    }
+    bestSegment = candidateSegment;
+    bestHeightPx = candidateHeightPx;
+  }
+  if (!bestSegment?.paragraphLineRange) {
+    return void 0;
+  }
+  return {
+    currentSegment: bestSegment,
+    currentHeightPx: bestHeightPx,
+    remainderSegment: {
+      ...segment,
+      paragraphLineRange: {
+        startLineIndex: bestSegment.paragraphLineRange.endLineIndex,
+        endLineIndex,
+        totalLineCount: fullLineRange.totalLineCount,
+        lineHeightPx: fullLineRange.lineHeightPx
+      }
+    }
+  };
+}
+function buildRenderColumnSegmentsForPageSection(model, flowSegments, columnWidthsPx, columnHeightPx, numberingDefinitions, docGridLinePitchPxByNodeIndex, measuredParagraphOuterHeightsPxByNodeIndex, balanceColumns = false) {
+  const columnCount = Math.max(1, columnWidthsPx.length);
+  const columns = Array.from(
+    { length: columnCount },
+    () => []
+  );
+  const maxColumnHeightPx = Math.max(120, Math.round(columnHeightPx));
+  const resolveSegmentHeightPx = (segment, columnWidthPx) => {
+    const segmentNode = model.nodes[segment.nodeIndex];
+    if (!segmentNode) {
+      return MIN_PARAGRAPH_LINE_HEIGHT_PX;
+    }
+    const docGridLinePitchPx = docGridLinePitchPxByNodeIndex?.get(
+      segment.nodeIndex
+    );
+    const measuredSegmentHeightPx = segmentNode.type === "paragraph" && !segment.paragraphLineRange && !segment.tableRowRange && !segment.tableRowSlice ? measuredParagraphOuterHeightsPxByNodeIndex?.get(segment.nodeIndex) : void 0;
+    return Number.isFinite(measuredSegmentHeightPx) && measuredSegmentHeightPx > 0 ? Math.max(1, Math.round(measuredSegmentHeightPx)) : estimateRenderedPageSegmentHeightPx(
+      segmentNode,
+      segment,
+      model,
+      columnWidthPx,
+      numberingDefinitions,
+      docGridLinePitchPx
+    );
+  };
+  const safeColumnHeightPx = balanceColumns && columnCount > 1 ? Math.min(
+    maxColumnHeightPx,
+    Math.max(
+      MIN_PARAGRAPH_LINE_HEIGHT_PX * 4,
+      Math.ceil(
+        flowSegments.reduce((totalHeightPx, segment) => {
+          const columnWidthPx = Math.max(
+            120,
+            Math.round(columnWidthsPx[0] ?? 120)
+          );
+          return totalHeightPx + resolveSegmentHeightPx(segment, columnWidthPx);
+        }, 0) / columnCount
+      ) + PAGE_OVERFLOW_TOLERANCE_PX
+    )
+  ) : maxColumnHeightPx;
+  let columnIndex = 0;
+  let consumedHeightPx = 0;
+  const moveToNextColumn = () => {
+    if (columnIndex + 1 >= columnCount) {
+      return false;
+    }
+    columnIndex += 1;
+    consumedHeightPx = 0;
+    return true;
+  };
+  const pushSegment = (segment, heightPx) => {
+    columns[columnIndex]?.push(segment);
+    consumedHeightPx += Math.max(1, Math.round(heightPx));
+  };
+  for (const flowSegment of flowSegments) {
+    let pendingSegment = flowSegment;
+    let splitGuard = 0;
+    while (pendingSegment && splitGuard < 256) {
+      splitGuard += 1;
+      const currentSegment = pendingSegment;
+      const segmentNode = model.nodes[currentSegment.nodeIndex];
+      if (!segmentNode) {
+        columns[columnIndex]?.push(currentSegment);
+        break;
+      }
+      const columnWidthPx = Math.max(
+        120,
+        Math.round(columnWidthsPx[columnIndex] ?? columnWidthsPx[0] ?? 120)
+      );
+      const docGridLinePitchPx = docGridLinePitchPxByNodeIndex?.get(
+        currentSegment.nodeIndex
+      );
+      const segmentHeightPx = resolveSegmentHeightPx(
+        currentSegment,
+        columnWidthPx
+      );
+      const remainingHeightPx = Math.max(
+        0,
+        safeColumnHeightPx - consumedHeightPx
+      );
+      if (segmentHeightPx <= remainingHeightPx + PAGE_OVERFLOW_TOLERANCE_PX || columnIndex + 1 >= columnCount) {
+        pushSegment(currentSegment, segmentHeightPx);
+        pendingSegment = void 0;
+        break;
+      }
+      const splitSegment = segmentNode.type === "paragraph" ? splitParagraphSegmentForColumnRender({
+        paragraph: segmentNode,
+        segment: currentSegment,
+        model,
+        availableWidthPx: columnWidthPx,
+        availableHeightPx: remainingHeightPx,
+        numberingDefinitions,
+        docGridLinePitchPx
+      }) : void 0;
+      if (splitSegment) {
+        pushSegment(splitSegment.currentSegment, splitSegment.currentHeightPx);
+        pendingSegment = splitSegment.remainderSegment;
+        if (!moveToNextColumn()) {
+          const remainderSegment = splitSegment.remainderSegment;
+          const remainderHeightPx = estimateRenderedPageSegmentHeightPx(
+            segmentNode,
+            remainderSegment,
+            model,
+            columnWidthPx,
+            numberingDefinitions,
+            docGridLinePitchPx
+          );
+          pushSegment(remainderSegment, remainderHeightPx);
+          pendingSegment = void 0;
+        }
+        continue;
+      }
+      if (!moveToNextColumn()) {
+        pushSegment(currentSegment, segmentHeightPx);
+        pendingSegment = void 0;
+      }
+    }
+  }
+  return columns;
+}
 function sumEstimatedTableRowHeightsPx(rowHeightsPx, startRowIndex, endRowIndex) {
   let total = 0;
   const clampedStart = Math.max(0, startRowIndex);
@@ -16924,16 +17460,10 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
             const exactSegmentEndLineIndex = resolveMaxPretextLineRangeEndIndexThatFits(
               pretextLayoutForSegmentSplitting,
               lineCursor,
-              Math.min(
-                resolvedParagraphLineCount,
-                lineCursor + linesThatFit
-              ),
+              Math.min(resolvedParagraphLineCount, lineCursor + linesThatFit),
               availableForLinesPx
             );
-            linesThatFit = Math.max(
-              0,
-              exactSegmentEndLineIndex - lineCursor
-            );
+            linesThatFit = Math.max(0, exactSegmentEndLineIndex - lineCursor);
           }
           if (linesThatFit < minLinesPerSegment) {
             if (currentPageSegments.length > 0) {
@@ -16970,10 +17500,7 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
               lineCursor,
               segmentEndLineIndex
             );
-            if (topSpacingPx + resolveSegmentContentHeightPx(
-              lineCursor,
-              segmentEndLineIndex
-            ) + segmentReservePx <= remainingHeightPx2) {
+            if (topSpacingPx + resolveSegmentContentHeightPx(lineCursor, segmentEndLineIndex) + segmentReservePx <= remainingHeightPx2) {
               break;
             }
             linesThatFit -= 1;
@@ -17174,6 +17701,7 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
     let rowStartIndex = 0;
     let rowSliceOffsetPx = 0;
     let repeatedHeaderHeightPxOnThisPage = 0;
+    let tableBreakStartRowCursor = 0;
     while (rowStartIndex < estimatedRowHeightsPx.length) {
       if (currentPageSegments.length === 0) {
         repeatedHeaderHeightPxOnThisPage = 0;
@@ -17208,9 +17736,10 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
         currentPageContentHeightPx - repeatedHeaderHeightPxOnThisPage
       );
       const rowExceedsFreshPageHeightPx = currentRowTotalHeightPx > freshPageAvailableHeightPx + PAGE_OVERFLOW_TOLERANCE_PX;
+      const hasUsableCurrentPageSliceSpace = pageConsumedHeightPx > 0 && remainingHeightPx >= MIN_TABLE_ROW_SLICE_REMAINING_HEIGHT_PX;
       const canSplitCurrentRow = rowSliceOffsetPx > 0 || rowAllowsPageSplit(currentRow) || rowExceedsFreshPageHeightPx;
       const shouldContinueExistingRowSlice = rowSliceOffsetPx > 0;
-      const rowNeedsSliceOnThisPage = ENABLE_TABLE_ROW_SLICING && canSplitCurrentRow && currentRowRemainingHeightPx > remainingHeightPx + PAGE_OVERFLOW_TOLERANCE_PX && (shouldContinueExistingRowSlice || rowExceedsFreshPageHeightPx);
+      const rowNeedsSliceOnThisPage = ENABLE_TABLE_ROW_SLICING && canSplitCurrentRow && currentRowRemainingHeightPx > remainingHeightPx + PAGE_OVERFLOW_TOLERANCE_PX && (shouldContinueExistingRowSlice || rowExceedsFreshPageHeightPx || hasUsableCurrentPageSliceSpace);
       if (canSplitCurrentRow && currentRowRemainingHeightPx > remainingHeightPx + PAGE_OVERFLOW_TOLERANCE_PX && !rowNeedsSliceOnThisPage && currentPageSegments.length > 0) {
         startNextPage();
         pageConsumedHeightPx = 0;
@@ -17238,10 +17767,38 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
           MIN_PARAGRAPH_LINE_HEIGHT_PX,
           Math.round(remainingHeightPx)
         );
-        const sliceHeightPx = Math.max(
+        const preferredSliceHeightPx = Math.max(
           MIN_PARAGRAPH_LINE_HEIGHT_PX,
           Math.min(currentRowRemainingHeightPx, availableSliceHeightPx)
         );
+        const safeSliceHeightPx = resolveTableRowSliceHeightOnSafeBoundaryPx({
+          table: node,
+          rowIndex: rowStartIndex,
+          rowHeightPx: currentRowTotalHeightPx,
+          rowSliceOffsetPx,
+          preferredSliceHeightPx,
+          maxAvailableWidthPx: nodeMetrics.pageContentWidthPx,
+          numberingDefinitions,
+          docGridLinePitchPx: nodeMetrics.docGridLinePitchPx
+        });
+        if (safeSliceHeightPx === void 0 && pageConsumedHeightPx > 0 && currentPageSegments.length > 0) {
+          startNextPage();
+          pageConsumedHeightPx = 0;
+          previousParagraphAfterPx = 0;
+          currentSectionPageFlowOriginPx = 0;
+          currentPageContentHeightPx = resolveMetricsPageContentHeightPx(
+            currentPageIndex,
+            nodeMetrics
+          );
+          continue;
+        }
+        const sliceHeightPx = Math.max(
+          MIN_PARAGRAPH_LINE_HEIGHT_PX,
+          Math.min(
+            currentRowRemainingHeightPx,
+            safeSliceHeightPx ?? preferredSliceHeightPx
+          )
+        );
         currentPageSegments.push({
           nodeIndex,
           tableRowRange: {
@@ -17307,9 +17864,10 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
         pageConsumedHeightPx <= 0
       );
       let rowEndIndex = fittedRowEndIndex;
-      const forcedBreakRowIndex = tableBreakStartRows.find(
-        (breakRowIndex) => breakRowIndex > rowStartIndex
-      );
+      while (tableBreakStartRowCursor < tableBreakStartRows.length && tableBreakStartRows[tableBreakStartRowCursor] <= rowStartIndex) {
+        tableBreakStartRowCursor += 1;
+      }
+      const forcedBreakRowIndex = tableBreakStartRows[tableBreakStartRowCursor];
       if (forcedBreakRowIndex !== void 0) {
         rowEndIndex = Math.min(rowEndIndex, forcedBreakRowIndex);
       }
@@ -17375,6 +17933,19 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
       rowStartIndex = rowEndIndex;
       rowSliceOffsetPx = 0;
       if (rowStartIndex < estimatedRowHeightsPx.length) {
+        const nextRow = node.rows[rowStartIndex];
+        const nextRowHeightPx = Math.max(
+          MIN_PARAGRAPH_LINE_HEIGHT_PX,
+          estimatedRowHeightsPx[rowStartIndex] ?? MIN_PARAGRAPH_LINE_HEIGHT_PX
+        );
+        const remainingHeightAfterSegmentPx = Math.max(
+          0,
+          currentPageContentHeightPx - pageConsumedHeightPx
+        );
+        const canSliceNextRowOnCurrentPage = ENABLE_TABLE_ROW_SLICING && nextRow !== void 0 && rowAllowsPageSplit(nextRow) && !tableBreakStartRows.includes(rowStartIndex) && remainingHeightAfterSegmentPx >= MIN_TABLE_ROW_SLICE_REMAINING_HEIGHT_PX && nextRowHeightPx > remainingHeightAfterSegmentPx + PAGE_OVERFLOW_TOLERANCE_PX;
+        if (canSliceNextRowOnCurrentPage) {
+          continue;
+        }
         startNextPage();
         pageConsumedHeightPx = 0;
         previousParagraphAfterPx = 0;
@@ -24951,32 +25522,22 @@ function useDocxEditor(options = {}) {
         return;
       }
       setIsImporting(true);
-      setStatus(`Loading ${file.name}\u2026`);
-      await new Promise((resolve) => {
-        if (typeof requestAnimationFrame === "function") {
-          requestAnimationFrame(() => {
-            requestAnimationFrame(() => resolve());
-          });
-        } else {
-          setTimeout(resolve, 0);
-        }
-      });
+      setStatus(`Loading ${file.name}...`);
       try {
         const buffer = await file.arrayBuffer();
-        const { pkg, model: nextModel } = await importDocxViaWorker(buffer);
+        const pkg = await parseDocx(buffer);
         await loadEmbeddedFontsFromPackage(pkg);
-        React.startTransition(() => {
-          setModel(nextModel);
-          setDocumentLoadNonce((current) => current + 1);
-          setHistory({ past: [], future: [] });
-          setHistoryRestoreRequest(void 0);
-          setBasePackage(pkg);
-          setFileName(file.name);
-          setSelection({ kind: "paragraph", nodeIndex: 0 });
-          setActiveTextRangeState(void 0);
-          setPendingRunStyle(void 0);
-          setSelectedFormFieldLocation(void 0);
-        });
+        const nextModel = buildDocModel(pkg);
+        setModel(nextModel);
+        setDocumentLoadNonce((current) => current + 1);
+        setHistory({ past: [], future: [] });
+        setHistoryRestoreRequest(void 0);
+        setBasePackage(pkg);
+        setFileName(file.name);
+        setSelection({ kind: "paragraph", nodeIndex: 0 });
+        setActiveTextRangeState(void 0);
+        setPendingRunStyle(void 0);
+        setSelectedFormFieldLocation(void 0);
         setStatus(`Loaded ${file.name}`);
       } catch (error) {
         setStatus(
@@ -29473,7 +30034,7 @@ function DocxEditorViewer({
   style,
   pageBackgroundColor,
   pageGapBackgroundColor,
-  deferInitialPaginationPaint = true,
+  deferInitialPaginationPaint = false,
   loadingState,
   pageVirtualization,
   visiblePageRange,
@@ -29534,6 +30095,10 @@ function DocxEditorViewer({
   const paragraphElementsRef = React.useRef(
     /* @__PURE__ */ new Map()
   );
+  const [
+    measuredParagraphOuterHeightsPxByNodeIndex,
+    setMeasuredParagraphOuterHeightsPxByNodeIndex
+  ] = React.useState(() => /* @__PURE__ */ new Map());
   const tableCellEditorElementsRef = React.useRef(
     /* @__PURE__ */ new Map()
   );
@@ -29808,6 +30373,9 @@ function DocxEditorViewer({
   const paginationMeasurementResumeTimeoutRef = React.useRef(
     null
   );
+  React.useLayoutEffect(() => {
+    setMeasuredParagraphOuterHeightsPxByNodeIndex(/* @__PURE__ */ new Map());
+  }, [editor.documentLoadNonce, paragraphStructureEpoch]);
   const schedulePaginationMeasurementResume = React.useCallback(
     (delayMs) => {
       if (typeof window === "undefined") {
@@ -30020,10 +30588,20 @@ function DocxEditorViewer({
     () => buildPaginationSectionMetrics(documentSections, documentLayout),
     [documentLayout, documentSections]
   );
-  const docGridLinePitchPxByNodeIndex = React.useMemo(() => {
+  const {
+    docGridLinePitchPxByNodeIndex,
+    pageContentWidthPxByNodeIndex,
+    pageContentHeightPxByNodeIndex
+  } = React.useMemo(() => {
     const pitchByNodeIndex = /* @__PURE__ */ new Map();
+    const widthByNodeIndex = /* @__PURE__ */ new Map();
+    const heightByNodeIndex = /* @__PURE__ */ new Map();
     if (editor.model.nodes.length === 0 || paginationSectionMetrics.length === 0) {
-      return pitchByNodeIndex;
+      return {
+        docGridLinePitchPxByNodeIndex: pitchByNodeIndex,
+        pageContentWidthPxByNodeIndex: widthByNodeIndex,
+        pageContentHeightPxByNodeIndex: heightByNodeIndex
+      };
     }
     let currentMetricsIndex = 0;
     for (let nodeIndex = 0; nodeIndex < editor.model.nodes.length; nodeIndex += 1) {
@@ -30032,51 +30610,22 @@ function DocxEditorViewer({
         nodeIndex,
         currentMetricsIndex
       );
-      const docGridLinePitchPx = paginationSectionMetrics[currentMetricsIndex]?.docGridLinePitchPx;
+      const nodeMetrics = paginationSectionMetrics[currentMetricsIndex];
+      const docGridLinePitchPx = nodeMetrics?.docGridLinePitchPx;
       if (Number.isFinite(docGridLinePitchPx) && docGridLinePitchPx > 0) {
         pitchByNodeIndex.set(
           nodeIndex,
           Math.round(docGridLinePitchPx)
         );
       }
-    }
-    return pitchByNodeIndex;
-  }, [editor.model.nodes, paginationSectionMetrics]);
-  const pageContentWidthPxByNodeIndex = React.useMemo(() => {
-    const widthByNodeIndex = /* @__PURE__ */ new Map();
-    if (editor.model.nodes.length === 0 || paginationSectionMetrics.length === 0) {
-      return widthByNodeIndex;
-    }
-    let currentMetricsIndex = 0;
-    for (let nodeIndex = 0; nodeIndex < editor.model.nodes.length; nodeIndex += 1) {
-      currentMetricsIndex = resolvePaginationSectionMetricsIndexForNodeIndex(
-        paginationSectionMetrics,
-        nodeIndex,
-        currentMetricsIndex
-      );
-      const pageContentWidthPx = paginationSectionMetrics[currentMetricsIndex]?.pageContentWidthPx;
+      const pageContentWidthPx = nodeMetrics?.pageContentWidthPx;
       if (Number.isFinite(pageContentWidthPx) && pageContentWidthPx > 0) {
         widthByNodeIndex.set(
           nodeIndex,
           Math.round(pageContentWidthPx)
         );
       }
-    }
-    return widthByNodeIndex;
-  }, [editor.model.nodes, paginationSectionMetrics]);
-  const pageContentHeightPxByNodeIndex = React.useMemo(() => {
-    const heightByNodeIndex = /* @__PURE__ */ new Map();
-    if (editor.model.nodes.length === 0 || paginationSectionMetrics.length === 0) {
-      return heightByNodeIndex;
-    }
-    let currentMetricsIndex = 0;
-    for (let nodeIndex = 0; nodeIndex < editor.model.nodes.length; nodeIndex += 1) {
-      currentMetricsIndex = resolvePaginationSectionMetricsIndexForNodeIndex(
-        paginationSectionMetrics,
-        nodeIndex,
-        currentMetricsIndex
-      );
-      const pageContentHeightPx = paginationSectionMetrics[currentMetricsIndex]?.pageContentHeightPx;
+      const pageContentHeightPx = nodeMetrics?.pageContentHeightPx;
       if (Number.isFinite(pageContentHeightPx) && pageContentHeightPx > 0) {
         heightByNodeIndex.set(
           nodeIndex,
@@ -30084,7 +30633,11 @@ function DocxEditorViewer({
         );
       }
     }
-    return heightByNodeIndex;
+    return {
+      docGridLinePitchPxByNodeIndex: pitchByNodeIndex,
+      pageContentWidthPxByNodeIndex: widthByNodeIndex,
+      pageContentHeightPxByNodeIndex: heightByNodeIndex
+    };
   }, [editor.model.nodes, paginationSectionMetrics]);
   const sectionColumnsBySectionIndex = React.useMemo(
     () => documentSections.map(
@@ -30236,11 +30789,11 @@ function DocxEditorViewer({
         renderPageContentHeightScale: estimatedRenderPageContentHeightScale
       };
     }
-    const pureEstimatedPages = buildEstimatedPages(
-      tableMeasuredRowHeightsForPagination,
-      null
-    );
     if (measuredPageContentHeightByIndex && measuredPageContentHeightByIndex.length > 0) {
+      const pureEstimatedPages = buildEstimatedPages(
+        tableMeasuredRowHeightsForPagination,
+        null
+      );
       const measuredPagesAreOnlySplitParagraphs = estimatedPages.length > 0 && estimatedPages.every(
         (pageSegments) => documentPageContainsOnlySplitParagraphSegments(pageSegments)
       );
@@ -30287,9 +30840,9 @@ function DocxEditorViewer({
       estimatedRenderMeasuredPageContentHeightsPxByPageIndex = bestCandidate.renderMeasuredPageContentHeightsPxByPageIndex;
       estimatedRenderPageContentHeightScale = bestCandidate.renderPageContentHeightScale;
     } else if (!editor.canUndo && !editor.canRedo && targetPageCount !== void 0 && !hasMultiColumnRenderedPageBreakHints) {
-      const pureEstimatedPages2 = buildEstimatedPages(void 0, null);
-      if (Math.abs(pureEstimatedPages2.length - targetPageCount) < Math.abs(estimatedPages.length - targetPageCount)) {
-        estimatedPages = pureEstimatedPages2;
+      const pureEstimatedPages = buildEstimatedPages(void 0, null);
+      if (Math.abs(pureEstimatedPages.length - targetPageCount) < Math.abs(estimatedPages.length - targetPageCount)) {
+        estimatedPages = pureEstimatedPages;
         estimatedPagesUseMeasuredPageContentHeightsForRender = false;
         estimatedRenderMeasuredPageContentHeightsPxByPageIndex = void 0;
         estimatedRenderPageContentHeightScale = void 0;
@@ -30409,9 +30962,9 @@ function DocxEditorViewer({
     ) : void 0;
     let reconciledRenderPageContentHeightScale = reconciledPagesUseMeasuredPageContentHeightsForRender ? void 0 : reconciledCandidate.scale;
     if (!editor.canUndo && !editor.canRedo) {
-      const pureEstimatedPages2 = buildEstimatedPages(void 0, null);
+      const pureEstimatedPages = buildEstimatedPages(void 0, null);
       const pureReconciledCandidate = reconcileCandidatePages(
-        pureEstimatedPages2,
+        pureEstimatedPages,
         void 0,
         null
       );
@@ -30782,7 +31335,7 @@ function DocxEditorViewer({
       Number.isFinite(pageVirtualization?.overscan) ? pageVirtualization?.overscan : DEFAULT_PAGE_VIRTUALIZATION_OVERSCAN
     )
   );
-  const pageVirtualizationOverscan = hasLargeTableLayoutSurface && !Number.isFinite(pageVirtualization?.overscan) ? 0 : rawPageVirtualizationOverscan;
+  const pageVirtualizationOverscan = hasLargeTableLayoutSurface && !Number.isFinite(pageVirtualization?.overscan) ? LARGE_TABLE_PAGE_VIRTUALIZATION_OVERSCAN : rawPageVirtualizationOverscan;
   const webdriverActive = typeof navigator !== "undefined" && navigator.webdriver === true;
   const internalPageVirtualizationRequested = pageVirtualization?.enabled !== false && !hasExternalVisiblePageRange && !hideDocumentUntilPaginationSettled && isInitialPaginationSettled && !deferInternalPageVirtualization && !webdriverActive && pageCount > 1;
   React.useEffect(() => {
@@ -30877,8 +31430,40 @@ function DocxEditorViewer({
       endPageIndex
     };
   }, [internalPageVirtualizationEnabled, internalVirtualItems, pageCount]);
+  const internalRenderVisiblePageRange = React.useMemo(() => {
+    if (!internalVisiblePageRange) {
+      return void 0;
+    }
+    if (!hasLargeTableLayoutSurface || Number.isFinite(pageVirtualization?.overscan)) {
+      return internalVisiblePageRange;
+    }
+    const scrollDirection = internalPageVirtualizer.scrollDirection;
+    const renderPreviousPage = scrollDirection !== "backward";
+    const renderNextPage = scrollDirection === "backward";
+    const startPageIndex = clampNumber(
+      internalVisiblePageRange.startPageIndex - (renderPreviousPage ? LARGE_TABLE_PAGE_ADJACENT_RENDER_COUNT : 0),
+      0,
+      pageCount - 1
+    );
+    const endPageIndex = clampNumber(
+      internalVisiblePageRange.endPageIndex + (renderNextPage ? LARGE_TABLE_PAGE_ADJACENT_RENDER_COUNT : 0),
+      startPageIndex,
+      pageCount - 1
+    );
+    return {
+      startPageIndex,
+      endPageIndex
+    };
+  }, [
+    hasLargeTableLayoutSurface,
+    internalPageVirtualizer.scrollDirection,
+    internalVisiblePageRange,
+    pageCount,
+    pageVirtualization?.overscan
+  ]);
+  const shouldObserveVisiblePageRange = hasLargeTableLayoutSurface || internalVirtualItems.length === 0;
   React.useLayoutEffect(() => {
-    if (!internalPageVirtualizationEnabled || !internalVirtualScrollElement || typeof window === "undefined") {
+    if (!internalPageVirtualizationEnabled || !internalVirtualScrollElement || !shouldObserveVisiblePageRange || typeof window === "undefined") {
       setObservedVisiblePageRange(
         (current) => current === void 0 ? current : void 0
       );
@@ -30892,6 +31477,15 @@ function DocxEditorViewer({
       return;
     }
     let frameId = null;
+    const commitObservedVisiblePageRange = (updater) => {
+      if (hasLargeTableLayoutSurface) {
+        (0, import_react_dom.flushSync)(() => {
+          setObservedVisiblePageRange(updater);
+        });
+        return;
+      }
+      setObservedVisiblePageRange(updater);
+    };
     const syncVisiblePageRange = () => {
       frameId = null;
       const viewportRect = internalVirtualScrollUsesWindow ? {
@@ -30925,7 +31519,7 @@ function DocxEditorViewer({
         lastVisiblePageIndex = pageIndex;
       }
       if (firstVisiblePageIndex === void 0 || lastVisiblePageIndex === void 0) {
-        setObservedVisiblePageRange(
+        commitObservedVisiblePageRange(
           (current) => current === void 0 ? current : void 0
         );
         return;
@@ -30940,7 +31534,7 @@ function DocxEditorViewer({
         startPageIndex,
         pageCount - 1
       );
-      setObservedVisiblePageRange((current) => {
+      commitObservedVisiblePageRange((current) => {
         if (current?.startPageIndex === startPageIndex && current?.endPageIndex === endPageIndex) {
           return current;
         }
@@ -30992,13 +31586,42 @@ function DocxEditorViewer({
       }
     };
   }, [
+    hasLargeTableLayoutSurface,
     internalPageVirtualizationEnabled,
+    internalVirtualItems.length,
     internalVirtualScrollElement,
     internalVirtualScrollUsesWindow,
     pageCount,
-    pageVirtualizationOverscan
+    pageVirtualizationOverscan,
+    shouldObserveVisiblePageRange
   ]);
-  const effectiveVisiblePageRange = visiblePageRange ?? observedVisiblePageRange ?? internalVisiblePageRange ?? (internalPageVirtualizationPending ? {
+  const internalEffectiveRenderVisiblePageRange = React.useMemo(() => {
+    if (!internalRenderVisiblePageRange) {
+      return observedVisiblePageRange;
+    }
+    if (!observedVisiblePageRange || !hasLargeTableLayoutSurface) {
+      return internalRenderVisiblePageRange;
+    }
+    const rangesAreAdjacentOrOverlapping = observedVisiblePageRange.startPageIndex <= internalRenderVisiblePageRange.endPageIndex + 2 && internalRenderVisiblePageRange.startPageIndex <= observedVisiblePageRange.endPageIndex + 2;
+    if (!rangesAreAdjacentOrOverlapping) {
+      return internalRenderVisiblePageRange;
+    }
+    return {
+      startPageIndex: Math.min(
+        internalRenderVisiblePageRange.startPageIndex,
+        observedVisiblePageRange.startPageIndex
+      ),
+      endPageIndex: Math.max(
+        internalRenderVisiblePageRange.endPageIndex,
+        observedVisiblePageRange.endPageIndex
+      )
+    };
+  }, [
+    hasLargeTableLayoutSurface,
+    internalRenderVisiblePageRange,
+    observedVisiblePageRange
+  ]);
+  const effectiveVisiblePageRange = visiblePageRange ?? internalEffectiveRenderVisiblePageRange ?? observedVisiblePageRange ?? (internalPageVirtualizationPending ? {
     startPageIndex: 0,
     endPageIndex: Math.min(
       pageCount - 1,
@@ -31047,6 +31670,43 @@ function DocxEditorViewer({
     }
     return indexes;
   }, [pageCount, visiblePageEndIndex, visiblePageStartIndex]);
+  React.useLayoutEffect(() => {
+    if (typeof window === "undefined") {
+      return;
+    }
+    setMeasuredParagraphOuterHeightsPxByNodeIndex((current) => {
+      const next = new Map(current);
+      let changed = false;
+      paragraphElementsRef.current.forEach((element, nodeIndex) => {
+        if (!element.isConnected || element.dataset.docxParagraphPartialLineRange === "true" || element.closest('[data-docx-header-footer-region="footer"]') || element.closest('[data-docx-header-footer-region="header"]')) {
+          return;
+        }
+        const rect = element.getBoundingClientRect();
+        if (rect.width <= 0 && rect.height <= 0) {
+          return;
+        }
+        const style2 = window.getComputedStyle(element);
+        const marginTop = Number.parseFloat(style2.marginTop || "0");
+        const marginBottom = Number.parseFloat(style2.marginBottom || "0");
+        const outerHeightPx = Math.max(
+          1,
+          Math.round(
+            rect.height + (Number.isFinite(marginTop) ? marginTop : 0) + (Number.isFinite(marginBottom) ? marginBottom : 0)
+          )
+        );
+        if (next.get(nodeIndex) !== outerHeightPx) {
+          next.set(nodeIndex, outerHeightPx);
+          changed = true;
+        }
+      });
+      return changed ? next : current;
+    });
+  }, [
+    editor.documentLoadNonce,
+    pageNodeSegmentIdentityKeysByPage,
+    visiblePageEndIndex,
+    visiblePageStartIndex
+  ]);
   const visibleTableRowIndexesByNodeIndex = React.useMemo(() => {
     const rowsByNodeIndex = /* @__PURE__ */ new Map();
     const addRowIndex = (nodeIndex, rowIndex) => {
@@ -31121,7 +31781,8 @@ function DocxEditorViewer({
     tableMeasuredRowHeights,
     visiblePageIndexes
   ]);
-  const visiblePagesNeedMeasurementUnlock = !hideDocumentUntilPaginationSettled && visiblePagesHavePendingPaginationMeasurements;
+  const allowPostImportPaginationMeasurement = !hasLargeTableLayoutSurface || !internalPageVirtualizationEnabled;
+  const visiblePagesNeedMeasurementUnlock = !hideDocumentUntilPaginationSettled && allowPostImportPaginationMeasurement && visiblePagesHavePendingPaginationMeasurements;
   React.useEffect(() => {
     if (!visiblePagesNeedMeasurementUnlock) {
       return;
@@ -31186,7 +31847,13 @@ function DocxEditorViewer({
         rootElement.querySelectorAll(
           '[data-docx-page-wrapper="true"][data-index]'
         )
-      );
+      ).filter((element) => {
+        const pageIndex = Number.parseInt(
+          element.getAttribute("data-index") ?? "",
+          10
+        );
+        return Number.isFinite(pageIndex) && pageIndex >= visiblePageStartIndex && pageIndex <= visiblePageEndIndex;
+      });
       const nextElements = new Set(pageWrappers);
       observedElements.forEach((element) => {
         if (!nextElements.has(element)) {
@@ -31222,7 +31889,9 @@ function DocxEditorViewer({
     internalPageVirtualizationEnabled,
     internalPageVirtualizer,
     internalVirtualScrollElement,
-    pageCount
+    pageCount,
+    visiblePageEndIndex,
+    visiblePageStartIndex
   ]);
   React.useEffect(() => {
     if (!internalPageVirtualizationEnabled) {
@@ -31735,11 +32404,18 @@ function DocxEditorViewer({
     const nextMeasuredPageDiagnostics = pageNodeSegmentsByPage.map(
       (_, pageIndex) => {
         const pageLayout = pageSectionInfoByIndex[pageIndex]?.layout ?? documentLayout;
-        const pageElement = pageElementsRef.current.get(pageIndex);
         const fallbackHeightPx = Math.max(
           120,
           pageLayout.pageHeightPx - pageLayout.marginsPx.top - pageLayout.marginsPx.bottom
         );
+        const pageIsVisible = pageIndex >= visiblePageStartIndex && pageIndex <= visiblePageEndIndex;
+        if (!pageIsVisible) {
+          return {
+            heightPx: measuredPageContentHeightByIndex?.[pageIndex] ?? fallbackHeightPx,
+            bodyOverrunsFooter: false
+          };
+        }
+        const pageElement = pageElementsRef.current.get(pageIndex);
         if (!pageElement) {
           return {
             heightPx: fallbackHeightPx,
@@ -31932,7 +32608,9 @@ function DocxEditorViewer({
     pageNodeSegmentsByPage,
     pageNodeSegmentIdentityKeysByPage,
     pageSectionInfoByIndex,
-    pageHeaderAndFooterNodes
+    pageHeaderAndFooterNodes,
+    visiblePageEndIndex,
+    visiblePageStartIndex
   ]);
   React.useEffect(() => {
     if (!deferInitialPaginationPaint || isInitialPaginationSettled || disableMeasuredImportPagination) {
@@ -41076,11 +41754,17 @@ function DocxEditorViewer({
       } : void 0,
       outline: "none"
     };
-    const fallbackParagraphRuns = renderInteractiveParagraphRuns(
-      paragraph,
-      `body-cell-${tableIndex}-${rowIndex}-${cellIndex}-${contentIndex}`,
-      location
-    );
+    let fallbackParagraphRuns;
+    const getFallbackParagraphRuns = () => {
+      if (fallbackParagraphRuns === void 0) {
+        fallbackParagraphRuns = renderInteractiveParagraphRuns(
+          paragraph,
+          `body-cell-${tableIndex}-${rowIndex}-${cellIndex}-${contentIndex}`,
+          location
+        );
+      }
+      return fallbackParagraphRuns;
+    };
     const renderedInteractiveParagraphContent = shouldRenderParagraphSegmentWithPretext ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
       "div",
       {
@@ -41118,11 +41802,11 @@ function DocxEditorViewer({
             style: {
               transform: `translateY(-${paragraphSegmentTranslateYPx - paragraphSegmentClipBleedTopPx}px)`
             },
-            children: fallbackParagraphRuns
+            children: getFallbackParagraphRuns()
           }
         )
       }
-    ) : fallbackParagraphRuns;
+    ) : getFallbackParagraphRuns();
     return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
       "div",
       {
@@ -41364,6 +42048,7 @@ function DocxEditorViewer({
           ...resolvedAfterSpacingPx !== void 0 ? { marginBottom: resolvedAfterSpacingPx } : void 0
         } : void 0,
         ...letterheadStyleAdjustments ?? void 0,
+        ...options?.normalizeParagraphHostFontSize ? { fontSize: `${paragraphBaseFontSizePx(node)}px` } : void 0,
         ...options?.suppressLetterheadColumnLayout && options?.isFirstInLetterheadColumn ? { marginTop: 0 } : void 0,
         ...pageAbsoluteAnchorOnlyParagraph ? {
           position: "relative",
@@ -41382,19 +42067,25 @@ function DocxEditorViewer({
         } : void 0,
         outline: "none"
       };
-      const fallbackParagraphRuns = renderInteractiveParagraphRuns(
-        node,
-        `node-${nodeIndex}`,
-        {
-          kind: "paragraph",
-          nodeIndex
-        },
-        {
-          pageFlowTopPx: paragraphPageFlowTopPx,
-          pageLayout: resolvedPageLayout,
-          suppressLikelyFullPageCoverImageKeys: options?.suppressLikelyFullPageCoverImageKeys
+      let fallbackParagraphRuns;
+      const getFallbackParagraphRuns = () => {
+        if (fallbackParagraphRuns === void 0) {
+          fallbackParagraphRuns = renderInteractiveParagraphRuns(
+            node,
+            `node-${nodeIndex}`,
+            {
+              kind: "paragraph",
+              nodeIndex
+            },
+            {
+              pageFlowTopPx: paragraphPageFlowTopPx,
+              pageLayout: resolvedPageLayout,
+              suppressLikelyFullPageCoverImageKeys: options?.suppressLikelyFullPageCoverImageKeys
+            }
+          );
         }
-      );
+        return fallbackParagraphRuns;
+      };
       const renderedInteractiveParagraphContent = shouldRenderParagraphSegmentWithPretext ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
         "div",
         {
@@ -41435,11 +42126,11 @@ function DocxEditorViewer({
               style: {
                 transform: `translateY(-${paragraphSegmentTranslateYPx - paragraphSegmentClipBleedTopPx}px)`
               },
-              children: fallbackParagraphRuns
+              children: getFallbackParagraphRuns()
             }
           )
         }
-      ) : fallbackParagraphRuns;
+      ) : getFallbackParagraphRuns();
       const paragraphDraftHtml = paragraphDraftsRef.current.get(nodeIndex);
       const renderedEditableParagraphHtml = typeof paragraphDraftHtml === "string" ? paragraphDraftHtml : renderStaticHtml(renderedInteractiveParagraphContent);
       return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
@@ -41450,6 +42141,7 @@ function DocxEditorViewer({
           "data-docx-paragraph-node-index": nodeIndex,
           "data-docx-paragraph-start-line": paragraphSegmentStartLine,
           "data-docx-paragraph-end-line": paragraphSegmentEndLine,
+          "data-docx-paragraph-partial-line-range": hasPartialLineRange ? "true" : void 0,
           style: paragraphStyle,
           dangerouslySetInnerHTML: editable ? {
             __html: renderedEditableParagraphHtml
@@ -42487,6 +43179,68 @@ ${currentText.slice(end)}`;
                           })() : void 0;
                           const tableCellDraftHtml = tableCellDraftsRef.current.get(cellDraftKey);
                           const renderedEditableCellHtml = editableCell ? typeof tableCellDraftHtml === "string" ? tableCellDraftHtml : renderStaticHtml(renderedEditableCellContent) : void 0;
+                          const renderStaticCellContent = () => {
+                            let paragraphCursor = 0;
+                            return cell.nodes.map(
+                              (cellContent, contentIndex) => {
+                                if (cellContent.type === "paragraph") {
+                                  const paragraphIndex = paragraphCursor;
+                                  paragraphCursor += 1;
+                                  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                                    "div",
+                                    {
+                                      "data-docx-paragraph-host": "true",
+                                      "data-docx-paragraph-kind": "table-cell",
+                                      "data-docx-table-index": nodeIndex,
+                                      "data-docx-row-index": rowIndex,
+                                      "data-docx-cell-index": cellIndex,
+                                      "data-docx-paragraph-index": paragraphIndex,
+                                      "data-docx-table-paragraph-index": paragraphIndex,
+                                      style: tableCellParagraphBlockStyle(
+                                        cellContent,
+                                        editor.model.metadata.numberingDefinitions,
+                                        headingStyles,
+                                        paragraphIndex,
+                                        applyWordTableDefaults,
+                                        nodeDocGridLinePitchPx
+                                      ),
+                                      children: renderInteractiveParagraphRuns(
+                                        cellContent,
+                                        `body-cell-${nodeIndex}-${rowIndex}-${cellIndex}-${contentIndex}`,
+                                        {
+                                          kind: "table-cell",
+                                          tableIndex: nodeIndex,
+                                          rowIndex,
+                                          cellIndex,
+                                          paragraphIndex
+                                        }
+                                      )
+                                    },
+                                    `body-cell-p-${nodeIndex}-${rowIndex}-${cellIndex}-${contentIndex}`
+                                  );
+                                }
+                                return renderHeaderNode(
+                                  cellContent,
+                                  `body-cell-nested-table-${nodeIndex}-${rowIndex}-${cellIndex}-${contentIndex}`,
+                                  documentContentTheme,
+                                  editor.model.metadata.numberingDefinitions,
+                                  headingStyles,
+                                  spannedWidthPx > 0 ? spannedWidthPx : void 0,
+                                  scrollToBookmark,
+                                  void 0,
+                                  void 0,
+                                  void 0,
+                                  void 0,
+                                  paragraphRunRenderOptions,
+                                  void 0,
+                                  void 0,
+                                  tableCellEditScope,
+                                  void 0,
+                                  embeddedTableResizeController
+                                );
+                              }
+                            );
+                          };
                           return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
                             "td",
                             {
@@ -43372,68 +44126,27 @@ ${currentText.slice(end)}`;
                                     );
                                   })
                                 }
-                              ) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { style: { display: "grid", gap: 4 }, children: (() => {
-                                let paragraphCursor = 0;
-                                return cell.nodes.map(
-                                  (cellContent, contentIndex) => {
-                                    if (cellContent.type === "paragraph") {
-                                      const paragraphIndex = paragraphCursor;
-                                      paragraphCursor += 1;
-                                      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
-                                        "div",
-                                        {
-                                          "data-docx-paragraph-host": "true",
-                                          "data-docx-paragraph-kind": "table-cell",
-                                          "data-docx-table-index": nodeIndex,
-                                          "data-docx-row-index": rowIndex,
-                                          "data-docx-cell-index": cellIndex,
-                                          "data-docx-paragraph-index": paragraphIndex,
-                                          "data-docx-table-paragraph-index": paragraphIndex,
-                                          style: tableCellParagraphBlockStyle(
-                                            cellContent,
-                                            editor.model.metadata.numberingDefinitions,
-                                            headingStyles,
-                                            paragraphIndex,
-                                            applyWordTableDefaults,
-                                            nodeDocGridLinePitchPx
-                                          ),
-                                          children: renderInteractiveParagraphRuns(
-                                            cellContent,
-                                            `body-cell-${nodeIndex}-${rowIndex}-${cellIndex}-${contentIndex}`,
-                                            {
-                                              kind: "table-cell",
-                                              tableIndex: nodeIndex,
-                                              rowIndex,
-                                              cellIndex,
-                                              paragraphIndex
-                                            }
-                                          )
-                                        },
-                                        `body-cell-p-${nodeIndex}-${rowIndex}-${cellIndex}-${contentIndex}`
-                                      );
+                              ) : isSlicedRow && slicedCellViewportHeightPx ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                                "div",
+                                {
+                                  style: {
+                                    height: slicedCellViewportHeightPx,
+                                    overflow: "hidden",
+                                    position: "relative"
+                                  },
+                                  children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                                    "div",
+                                    {
+                                      style: {
+                                        display: "grid",
+                                        gap: 0,
+                                        transform: `translateY(-${tableRowSliceOffsetPx}px)`
+                                      },
+                                      children: renderStaticCellContent()
                                     }
-                                    return renderHeaderNode(
-                                      cellContent,
-                                      `body-cell-nested-table-${nodeIndex}-${rowIndex}-${cellIndex}-${contentIndex}`,
-                                      documentContentTheme,
-                                      editor.model.metadata.numberingDefinitions,
-                                      headingStyles,
-                                      spannedWidthPx > 0 ? spannedWidthPx : void 0,
-                                      scrollToBookmark,
-                                      void 0,
-                                      void 0,
-                                      void 0,
-                                      void 0,
-                                      paragraphRunRenderOptions,
-                                      void 0,
-                                      void 0,
-                                      tableCellEditScope,
-                                      void 0,
-                                      embeddedTableResizeController
-                                    );
-                                  }
-                                );
-                              })() })
+                                  )
+                                }
+                              ) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { style: { display: "grid", gap: 0 }, children: renderStaticCellContent() })
                             },
                             `cell-${nodeIndex}-${rowIndex}-${cellIndex}`
                           );
@@ -44492,8 +45205,11 @@ ${currentText.slice(end)}`;
     () => new Map(endnotes.map((note) => [note.id, note])),
     [endnotes]
   );
-  const pageFootnotesByIndex = React.useMemo(
-    () => pageNodeSegmentsByPage.map((nodeSegments) => {
+  const pageFootnotesByIndex = React.useMemo(() => {
+    if (footnotes.length === 0) {
+      return pageNodeSegmentsByPage.map(() => []);
+    }
+    return pageNodeSegmentsByPage.map((nodeSegments) => {
       const referencedIds = [];
       const seen = /* @__PURE__ */ new Set();
       nodeSegments.forEach((segment) => {
@@ -44515,10 +45231,17 @@ ${currentText.slice(end)}`;
         });
       });
       return referencedIds.map((referenceId) => footnotesById.get(referenceId)).filter((note) => Boolean(note));
-    }),
-    [editor.model.nodes, footnotesById, pageNodeSegmentsByPage]
-  );
+    });
+  }, [
+    editor.model.nodes,
+    footnotes.length,
+    footnotesById,
+    pageNodeSegmentsByPage
+  ]);
   const referencedEndnotes = React.useMemo(() => {
+    if (endnotes.length === 0) {
+      return endnotes;
+    }
     const referencedIds = [];
     const seen = /* @__PURE__ */ new Set();
     editor.model.nodes.forEach((node) => {
@@ -44748,6 +45471,7 @@ ${currentText.slice(end)}`;
           const pageVisible = isPageVisible(pageIndex);
           const pageWrapperWidthPx = showTrackedChangeGutter ? pageLayout.pageWidthPx + TRACKED_CHANGE_GUTTER_WIDTH_PX : pageLayout.pageWidthPx;
           if (!pageVisible) {
+            const placeholderBackgroundColor = pageBackgroundColor ?? editor.model.metadata.documentBackgroundColor ?? pageSurfaceBaseStyle.backgroundColor;
             return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
               "div",
               {
@@ -44765,8 +45489,12 @@ ${currentText.slice(end)}`;
                     "data-docx-page-placeholder": "true",
                     ref: pagePlaceholderRefForIndex(pageIndex),
                     style: {
+                      ...pageSurfaceBaseStyle,
                       height: pageLayout.pageHeightPx,
-                      width: pageLayout.pageWidthPx
+                      minHeight: pageLayout.pageHeightPx,
+                      width: pageLayout.pageWidthPx,
+                      backgroundColor: placeholderBackgroundColor,
+                      pointerEvents: "none"
                     }
                   }
                 )
@@ -45224,6 +45952,14 @@ ${currentText.slice(end)}`;
                                   }
                                 );
                                 const explicitColumnWidthsPx = sectionColumns && sectionColumns.widthsPx?.length === sectionColumns.count ? sectionColumns.widthsPx : void 0;
+                                const flowSegmentsHaveExplicitColumnBreak = flowSegments.some((segment) => {
+                                  if (segment.tableRowRange) {
+                                    return false;
+                                  }
+                                  const segmentNode = editor.model.nodes[segment.nodeIndex];
+                                  return segmentNode?.type === "paragraph" && paragraphHasExplicitColumnBreak(segmentNode);
+                                });
+                                const canUseColumnLineSplitRender = flowSegments.length > 0 && !flowSegmentsHaveExplicitColumnBreak;
                                 const renderSegmentInColumn = (columnSegment, columnContentWidthPx) => {
                                   const columnNode = editor.model.nodes[columnSegment.nodeIndex];
                                   if (!columnNode) {
@@ -45255,7 +45991,8 @@ ${currentText.slice(end)}`;
                                                     suppressParagraphElementTracking: segmentIndex > 0,
                                                     syntheticKeySuffix: `column-break-${segmentIndex}`,
                                                     overrideBeforeSpacingPx: segmentIndex === 0 ? void 0 : 0,
-                                                    overrideAfterSpacingPx: isLastSegment ? void 0 : 0
+                                                    overrideAfterSpacingPx: isLastSegment ? void 0 : 0,
+                                                    normalizeParagraphHostFontSize: true
                                                   }
                                                 )
                                               },
@@ -45276,7 +46013,8 @@ ${currentText.slice(end)}`;
                                     {
                                       pageLayout,
                                       contentWidthPxOverride: columnContentWidthPx,
-                                      suppressLikelyFullPageCoverImageKeys: suppressedLikelyFullPageCoverImageKeys
+                                      suppressLikelyFullPageCoverImageKeys: suppressedLikelyFullPageCoverImageKeys,
+                                      normalizeParagraphHostFontSize: true
                                     }
                                   );
                                   const segmentKeySuffix = columnSegment.tableRowRange ? `rows-${columnSegment.tableRowRange.startRowIndex}-${columnSegment.tableRowRange.endRowIndex}${columnSegment.tableRowSlice ? `-slice-${Math.max(
@@ -45315,7 +46053,91 @@ ${currentText.slice(end)}`;
                                   "div",
                                   {
                                     style: { position: "relative" },
-                                    children: explicitColumnWidthsPx && explicitColumnWidthsPx.length === 2 && flowSegments.length > 0 ? (() => {
+                                    children: canUseColumnLineSplitRender ? (() => {
+                                      const columnWidthsPx = explicitColumnWidthsPx && explicitColumnWidthsPx.length === sectionColumns.count ? explicitColumnWidthsPx : (() => {
+                                        const inferredColumnWidthPx = Math.max(
+                                          120,
+                                          Math.round(
+                                            (pageContentWidthPx - sectionColumns.gapPx * Math.max(
+                                              0,
+                                              sectionColumns.count - 1
+                                            )) / Math.max(1, sectionColumns.count)
+                                          )
+                                        );
+                                        return Array.from(
+                                          { length: sectionColumns.count },
+                                          () => inferredColumnWidthPx
+                                        );
+                                      })();
+                                      const columnSegments = buildRenderColumnSegmentsForPageSection(
+                                        editor.model,
+                                        flowSegments,
+                                        columnWidthsPx,
+                                        pageBodyAvailableHeightPx,
+                                        editor.model.metadata.numberingDefinitions,
+                                        docGridLinePitchPxByNodeIndex,
+                                        measuredParagraphOuterHeightsPxByNodeIndex,
+                                        isLastPage
+                                      );
+                                      return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+                                        overlaySegments.map((overlaySegment) => {
+                                          const overlayNode = editor.model.nodes[overlaySegment.nodeIndex];
+                                          if (!overlayNode) {
+                                            return null;
+                                          }
+                                          return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                                            React.Fragment,
+                                            {
+                                              children: renderDocumentNode(
+                                                overlayNode,
+                                                overlaySegment.nodeIndex,
+                                                overlaySegment.tableRowRange,
+                                                overlaySegment.tableRowSlice,
+                                                overlaySegment.paragraphLineRange,
+                                                {
+                                                  pageLayout,
+                                                  suppressLikelyFullPageCoverImageKeys: suppressedLikelyFullPageCoverImageKeys
+                                                }
+                                              )
+                                            },
+                                            `column-layout-overlay-${pageIndex}-${overlaySegment.nodeIndex}-${segmentIdentityKey(
+                                              overlaySegment
+                                            )}`
+                                          );
+                                        }),
+                                        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                                          "div",
+                                          {
+                                            style: {
+                                              display: "grid",
+                                              gridTemplateColumns: columnWidthsPx.map((widthPx) => `${widthPx}px`).join(" "),
+                                              columnGap: sectionColumns.gapPx,
+                                              alignItems: "start",
+                                              minHeight: pageBodyAvailableHeightPx,
+                                              position: "relative",
+                                              zIndex: 1
+                                            },
+                                            children: columnSegments.map(
+                                              (segmentsForColumn, columnIndex) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                                                "div",
+                                                {
+                                                  style: {
+                                                    minHeight: pageBodyAvailableHeightPx
+                                                  },
+                                                  children: segmentsForColumn.map(
+                                                    (segment) => renderSegmentInColumn(
+                                                      segment,
+                                                      columnWidthsPx[columnIndex]
+                                                    )
+                                                  )
+                                                },
+                                                `column-layout-flow-${pageIndex}-${groupIndex}-${columnIndex}`
+                                              )
+                                            )
+                                          }
+                                        )
+                                      ] });
+                                    })() : explicitColumnWidthsPx && explicitColumnWidthsPx.length === 2 && flowSegments.length > 0 ? (() => {
                                       const [leftColumnWidthPx, rightColumnWidthPx] = explicitColumnWidthsPx;
                                       const prefixHeightsPx = new Array(
                                         flowSegments.length + 1
@@ -47629,6 +48451,7 @@ function buildDocumentPageNodeSegments2(model, pageContentHeightPx, pageContentW
       );
     }
     let rowStartIndex = 0;
+    let tableBreakStartRowCursor = 0;
     while (rowStartIndex < estimatedRowHeightsPx.length) {
       const remainingHeightPx = Math.max(0, currentPageContentHeightPx - pageConsumedHeightPx);
       const fittedRowEndIndex = fitTableRowsWithinHeightPx2(
@@ -47640,9 +48463,10 @@ function buildDocumentPageNodeSegments2(model, pageContentHeightPx, pageContentW
         pageOverflowTolerancePx
       );
       let rowEndIndex = fittedRowEndIndex;
-      const forcedBreakRowIndex = tableBreakStartRows.find(
-        (breakRowIndex) => breakRowIndex > rowStartIndex
-      );
+      while (tableBreakStartRowCursor < tableBreakStartRows.length && tableBreakStartRows[tableBreakStartRowCursor] <= rowStartIndex) {
+        tableBreakStartRowCursor += 1;
+      }
+      const forcedBreakRowIndex = tableBreakStartRows[tableBreakStartRowCursor];
       if (forcedBreakRowIndex !== void 0) {
         rowEndIndex = Math.min(rowEndIndex, forcedBreakRowIndex);
       }