@stll/folio-core 0.4.0 → 0.5.0

package/dist/layout-engine/measure/measureParagraph.js

@@ -22,8 +22,10 @@ const DEFAULT_FONT_FAMILY = "Calibri";
 const DEFAULT_LINE_HEIGHT_MULTIPLIER = 1;
 const WIDTH_TOLERANCE = .5;
 const JUSTIFY_SHRINK_TOLERANCE_RATIO = .016;
+const JUSTIFY_LITERAL_TAB_CONTINUATION_SHRINK_TOLERANCE_RATIO = .017;
 const JUSTIFY_PROSE_SHRINK_TOLERANCE_RATIO = .025;
 const JUSTIFY_HANGING_TAB_SHRINK_TOLERANCE_RATIO = .021;
+const DEFAULT_LIST_HANGING_INDENT_PX = 24;
 const ALL_CAPS_RATIO_THRESHOLD = .8;
 /**
 * Find the longest prefix of `text` that fits within `maxWidth` pixels.
@@ -270,8 +272,16 @@ function hasFollowingTabOnLine(runs, tabIndex) {
 	}
 	return false;
 }
-function canClampTabToRightEdge(alignment, currentLineWidth) {
-	if (alignment === "start" || alignment === "default") return currentLineWidth > WIDTH_TOLERANCE;
+function hasPriorTabOnLine(runs, tabIndex) {
+	for (let i = tabIndex - 1; i >= 0; i--) {
+		const prior = runs[i];
+		if (!prior || isLineBreakRun(prior) || isImageRun(prior) && isBlockLayoutImageRun(prior)) break;
+		if (isTabRun(prior)) return true;
+	}
+	return false;
+}
+function canClampTabToRightEdge(alignment, currentLineWidth, hasPriorTab, followingWidth, availableWidth) {
+	if (alignment === "start" || alignment === "default") return currentLineWidth > WIDTH_TOLERANCE && (hasPriorTab || followingWidth <= availableWidth);
 	return true;
 }
 /**
@@ -319,10 +329,18 @@ function uppercaseLetterRatio(text) {
 	}
 	return letters === 0 ? 0 : uppercase / letters;
 }
-function justifyShrinkToleranceRatio(block) {
+function justifyShrinkToleranceRatio(block, isFirstLine, regularSpaceCount, nonBreakingSpaceCount) {
+	if (block.attrs?.listMarker !== void 0) {
+		if ((block.attrs.indent?.hanging ?? 0) <= DEFAULT_LIST_HANGING_INDENT_PX) return JUSTIFY_SHRINK_TOLERANCE_RATIO;
+		if (isFirstLine) return JUSTIFY_HANGING_TAB_SHRINK_TOLERANCE_RATIO;
+		const totalSpaces = regularSpaceCount + nonBreakingSpaceCount;
+		if (totalSpaces === 0) return JUSTIFY_PROSE_SHRINK_TOLERANCE_RATIO;
+		return Math.max(JUSTIFY_SHRINK_TOLERANCE_RATIO, JUSTIFY_PROSE_SHRINK_TOLERANCE_RATIO * (regularSpaceCount / totalSpaces));
+	}
 	const hasTabStops = (block.attrs?.tabs?.length ?? 0) > 0;
 	const hasTabRuns = block.runs.some(isTabRun);
-	if (hasTabStops || hasTabRuns) return (block.attrs?.indent?.firstLine ?? 0) === 0 ? JUSTIFY_HANGING_TAB_SHRINK_TOLERANCE_RATIO : JUSTIFY_SHRINK_TOLERANCE_RATIO;
+	if (!isFirstLine && hasTabRuns && !hasTabStops) return JUSTIFY_LITERAL_TAB_CONTINUATION_SHRINK_TOLERANCE_RATIO;
+	if ((isFirstLine || hasTabStops) && (hasTabStops || hasTabRuns)) return (block.attrs?.indent?.firstLine ?? 0) === 0 ? JUSTIFY_HANGING_TAB_SHRINK_TOLERANCE_RATIO : JUSTIFY_SHRINK_TOLERANCE_RATIO;
 	if (uppercaseLetterRatio(block.runs.map((run) => isTextRun(run) ? run.text ?? "" : "").join("")) > ALL_CAPS_RATIO_THRESHOLD) return JUSTIFY_SHRINK_TOLERANCE_RATIO;
 	return JUSTIFY_PROSE_SHRINK_TOLERANCE_RATIO;
 }
@@ -412,7 +430,6 @@ function measureParagraph(block, maxWidth, options) {
 	const attrs = block.attrs;
 	const spacing = attrs?.spacing;
 	const isJustifiedParagraph = attrs?.alignment === "justify";
-	const justifyToleranceRatio = justifyShrinkToleranceRatio(block);
 	const floatingZones = options?.floatingZones;
 	const paragraphYOffset = options?.paragraphYOffset ?? 0;
 	const indent = attrs?.indent;
@@ -506,6 +523,9 @@ function measureParagraph(block, maxWidth, options) {
 		toRun: 0,
 		toChar: 0,
 		width: 0,
+		trailingWhitespaceWidth: 0,
+		regularSpaceCount: 0,
+		nonBreakingSpaceCount: 0,
 		maxFontSize: DEFAULT_FONT_SIZE,
 		maxFontMetrics: null,
 		maxImageHeightPx: 0,
@@ -552,7 +572,7 @@ function measureParagraph(block, maxWidth, options) {
 			fromChar: currentLine.fromChar,
 			toRun: currentLine.toRun,
 			toChar: currentLine.toChar,
-			width: currentLine.width,
+			width: Math.max(0, currentLine.width - currentLine.trailingWhitespaceWidth),
 			...finalTypography
 		};
 		if (currentLine.leftOffset > 0) line.leftOffset = currentLine.leftOffset;
@@ -572,17 +592,21 @@ function measureParagraph(block, maxWidth, options) {
 		const estimatedLineHeight = ptToPx(DEFAULT_FONT_SIZE) * DEFAULT_LINE_HEIGHT_MULTIPLIER;
 		skipObstructingFloats(estimatedLineHeight, bodyContentWidth);
 		const floatingMargins = getFloatingMargins(cumulativeHeight, estimatedLineHeight, floatingZones, paragraphYOffset);
+		const adjustedWidth = Math.max(1, getFloatingAvailableWidth(floatingMargins, bodyContentWidth));
 		currentLine = {
 			fromRun: runIndex,
 			fromChar: charIndex,
 			toRun: runIndex,
 			toChar: charIndex,
 			width: 0,
+			trailingWhitespaceWidth: 0,
+			regularSpaceCount: 0,
+			nonBreakingSpaceCount: 0,
 			maxFontSize: DEFAULT_FONT_SIZE,
 			maxFontMetrics: null,
 			maxImageHeightPx: 0,
 			maxMathHeightPx: 0,
-			availableWidth: Math.max(1, getFloatingAvailableWidth(floatingMargins, bodyContentWidth)),
+			availableWidth: adjustedWidth,
 			leftOffset: floatingMargins.leftMargin,
 			rightOffset: floatingMargins.rightMargin,
 			...floatingMargins.segments?.length ? { segmentZones: floatingMargins.segments } : {}
@@ -620,6 +644,7 @@ function measureParagraph(block, maxWidth, options) {
 			const contentX = indentLeft + (isFirstLine ? firstLineOffset + markerInlineWidth : 0) + lineX;
 			const tabResult = calculateTabWidth(contentX, {
 				...attrs?.tabs !== void 0 ? { explicitStops: attrs.tabs } : {},
+				...attrs?.defaultTabStopTwips !== void 0 ? { defaultTabInterval: attrs.defaultTabStopTwips } : {},
 				leftIndent: pixelsToTwips(indentLeft)
 			}, {
 				followingWidth,
@@ -627,12 +652,13 @@ function measureParagraph(block, maxWidth, options) {
 			});
 			let tabWidth = tabResult.width;
 			const lineRightEdgeX = indentLeft + (isFirstLine ? firstLineOffset + markerInlineWidth : 0) + currentLine.availableWidth + currentLine.leftOffset;
-			if (!hasFollowingTabOnLine(runs, runIndex) && canClampTabToRightEdge(tabResult.alignment, currentLine.width) && (tabWidth > 0 || followingWidth > 0) && contentX + tabWidth + followingWidth > lineRightEdgeX + WIDTH_TOLERANCE) tabWidth = Math.max(1, lineRightEdgeX - contentX - followingWidth);
+			if (!hasFollowingTabOnLine(runs, runIndex) && canClampTabToRightEdge(tabResult.alignment, currentLine.width, hasPriorTabOnLine(runs, runIndex), followingWidth, currentLine.availableWidth) && (tabWidth > 0 || followingWidth > 0) && contentX + tabWidth + followingWidth > lineRightEdgeX + WIDTH_TOLERANCE) tabWidth = Math.max(1, lineRightEdgeX - contentX - followingWidth);
 			if (currentLine.width + tabWidth > currentLine.availableWidth + WIDTH_TOLERANCE) {
 				startNewLine(runIndex, 0);
 				updateMaxFont(style);
 			}
 			currentLine.width += tabWidth;
+			currentLine.trailingWhitespaceWidth = 0;
 			currentLine.toRun = runIndex;
 			currentLine.toChar = 1;
 			continue;
@@ -662,6 +688,7 @@ function measureParagraph(block, maxWidth, options) {
 			const imageFootprintPx = imageHeight + (run.distTop ?? 0) + (run.distBottom ?? 0);
 			if (imageFootprintPx > currentLine.maxImageHeightPx) currentLine.maxImageHeightPx = imageFootprintPx;
 			currentLine.width += imageWidth;
+			currentLine.trailingWhitespaceWidth = 0;
 			currentLine.toRun = runIndex;
 			currentLine.toChar = 1;
 			continue;
@@ -676,6 +703,7 @@ function measureParagraph(block, maxWidth, options) {
 				updateMaxFont(style);
 			}
 			currentLine.width += fieldWidth;
+			currentLine.trailingWhitespaceWidth = 0;
 			currentLine.toRun = runIndex;
 			currentLine.toChar = 1;
 			continue;
@@ -696,6 +724,7 @@ function measureParagraph(block, maxWidth, options) {
 			}
 			if (mathFootprintPx > currentLine.maxMathHeightPx) currentLine.maxMathHeightPx = mathFootprintPx;
 			currentLine.width += mathWidth;
+			currentLine.trailingWhitespaceWidth = 0;
 			currentLine.toRun = runIndex;
 			currentLine.toChar = 1;
 			continue;
@@ -720,13 +749,17 @@ function measureParagraph(block, maxWidth, options) {
 					break;
 				}
 				const word = text.slice(charIndex, nextBreak);
-				const wordWidth = measureTextWidth(word, style);
-				const widthTolerance = isJustifiedParagraph ? Math.max(WIDTH_TOLERANCE, currentLine.availableWidth * justifyToleranceRatio) : WIDTH_TOLERANCE;
+				const measuredWord = trimTrailingSpacesAndTabs(word);
+				const wordWidth = measureTextWidth(measuredWord, style);
+				const fullWordWidth = measureTextWidth(word, style);
+				const regularSpaces = measuredWord.split(" ").length - 1;
+				const nonBreakingSpaces = measuredWord.split("\xA0").length - 1;
+				const widthTolerance = isJustifiedParagraph ? Math.max(WIDTH_TOLERANCE, currentLine.availableWidth * justifyShrinkToleranceRatio(block, lines.length === 0, currentLine.regularSpaceCount + regularSpaces, currentLine.nonBreakingSpaceCount + nonBreakingSpaces)) : WIDTH_TOLERANCE;
 				if (wordWidth > currentLine.availableWidth + widthTolerance) {
 					let chunkStart = 0;
-					while (chunkStart < word.length) {
+					while (chunkStart < measuredWord.length) {
 						const spaceLeft = currentLine.availableWidth - currentLine.width + WIDTH_TOLERANCE;
-						let bestEnd = findMaxFittingLength(word.slice(chunkStart), style, spaceLeft);
+						let bestEnd = findMaxFittingLength(measuredWord.slice(chunkStart), style, spaceLeft);
 						if (bestEnd === 0) {
 							if (currentLine.width > 0) {
 								startNewLine(runIndex, charIndex + chunkStart);
@@ -736,16 +769,26 @@ function measureParagraph(block, maxWidth, options) {
 							bestEnd = 1;
 						}
 						const chunkEnd = chunkStart + bestEnd;
-						const chunkWidth = measureTextWidth(word.slice(chunkStart, chunkEnd), style);
+						const chunk = measuredWord.slice(chunkStart, chunkEnd);
+						const chunkWidth = measureTextWidth(chunk, style);
 						currentLine.width += chunkWidth;
+						currentLine.trailingWhitespaceWidth = chunkWidth - measureTextWidth(trimTrailingSpacesAndTabs(chunk), style);
+						currentLine.regularSpaceCount += chunk.split(" ").length - 1;
+						currentLine.nonBreakingSpaceCount += chunk.split("\xA0").length - 1;
 						currentLine.toRun = runIndex;
 						currentLine.toChar = charIndex + chunkEnd;
 						chunkStart = chunkEnd;
-						if (chunkStart < word.length) {
+						if (chunkStart < measuredWord.length) {
 							startNewLine(runIndex, charIndex + chunkStart);
 							updateMaxFont(lineHeightStyle);
 						}
 					}
+					const trailingWhitespaceWidth = fullWordWidth - wordWidth;
+					currentLine.width += trailingWhitespaceWidth;
+					currentLine.trailingWhitespaceWidth = trailingWhitespaceWidth;
+					currentLine.regularSpaceCount += word.split(" ").length - 1;
+					currentLine.nonBreakingSpaceCount += word.split("\xA0").length - 1;
+					currentLine.toChar = nextBreak;
 					charIndex = nextBreak;
 					continue;
 				}
@@ -755,7 +798,10 @@ function measureParagraph(block, maxWidth, options) {
 					startNewLine(runIndex, charIndex);
 					updateMaxFont(lineHeightStyle);
 				}
-				currentLine.width += wordWidth;
+				currentLine.width += fullWordWidth;
+				currentLine.trailingWhitespaceWidth = fullWordWidth - wordWidth;
+				currentLine.regularSpaceCount += word.split(" ").length - 1;
+				currentLine.nonBreakingSpaceCount += word.split("\xA0").length - 1;
 				currentLine.toRun = runIndex;
 				currentLine.toChar = nextBreak;
 				charIndex = nextBreak;

package/dist/layout-engine/paginator.d.ts

@@ -27,7 +27,8 @@ type PaginatorOptions = {
     w: number;
     h: number;
   }; /** Page margins. */
-  margins: PageMargins;
+  margins: PageMargins; /** Swap left/right margins on even physical pages. */
+  mirrorMargins?: boolean;
   /**
    * Margins applied only to the very first page (page 1) of the paginator.
    * Used when a `<w:titlePg/>`-enabled section needs different margins for

package/dist/layout-engine/paginator.js

@@ -46,7 +46,7 @@ function createPaginator(options) {
 	}
 	function currentPageUsesActiveLayout(state) {
 		if (pendingPageSize || pendingMargins) return false;
-		return arePageSizesEqual(state.page.size, pageSize) && areMarginsEqual(state.page.margins, margins);
+		return arePageSizesEqual(state.page.size, pageSize) && areMarginsEqual(state.page.margins, getPageMargins(state.page.number));
 	}
 	if (getContentHeight() <= 0) panic("Paginator: page size and margins yield no content area");
 	let columnWidth = calculateColumnWidth(pageSize.w, margins.left, margins.right, columns);
@@ -62,14 +62,20 @@ function createPaginator(options) {
 		recalculateColumnWidth();
 	}
 	function getPageMargins(pageNumber) {
-		return pageNumber === 1 && options.firstPageMargins ? { ...options.firstPageMargins } : { ...margins };
+		const pageMargins = pageNumber === 1 && options.firstPageMargins ? { ...options.firstPageMargins } : { ...margins };
+		if (options.mirrorMargins === true && pageNumber % 2 === 0) return {
+			...pageMargins,
+			left: pageMargins.right,
+			right: pageMargins.left
+		};
+		return pageMargins;
 	}
 	let columnRegionTop = margins.top;
 	/**
 	* Get X position for a given column index.
 	*/
 	function getColumnX(columnIndex) {
-		return margins.left + columnIndex * (columnWidth + columns.gap);
+		return (states.at(-1)?.page.margins.left ?? getPageMargins(1).left) + columnIndex * (columnWidth + columns.gap);
 	}
 	/**
 	* Create a new page and add it to the list.

package/dist/layout-engine/textBoxGroup.d.ts

@@ -0,0 +1,7 @@
+import { TextBoxBlock } from "./types.js";
+
+//#region src/layout-engine/textBoxGroup.d.ts
+declare const setTextBoxGroupId: (textBox: TextBoxBlock, groupId: string) => void;
+declare const getTextBoxGroupId: (textBox: TextBoxBlock) => string | undefined;
+//#endregion
+export { getTextBoxGroupId, setTextBoxGroupId };

package/dist/layout-engine/textBoxGroup.js

@@ -0,0 +1,8 @@
+//#region src/layout-engine/textBoxGroup.ts
+const textBoxGroupIds = /* @__PURE__ */ new WeakMap();
+const setTextBoxGroupId = (textBox, groupId) => {
+	textBoxGroupIds.set(textBox, groupId);
+};
+const getTextBoxGroupId = (textBox) => textBoxGroupIds.get(textBox);
+//#endregion
+export { getTextBoxGroupId, setTextBoxGroupId };

package/dist/layout-engine/types.d.ts

@@ -3,7 +3,7 @@ import { ImagePosition, ImageWrap, SdtProperties, SdtType, TableWidthType } from
 
 //#region src/layout-engine/types.d.ts
 declare namespace types_d_exports {
-  export { BlockId, BorderStyle, CellBorderSpec, CellBorders, ColumnBreakBlock, ColumnBreakMeasure, ColumnLayout, DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, DocumentPosition, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, FieldRun, FloatingTablePosition, FlowBlock, FootnoteContent, Fragment, FragmentBase, HeaderFooterContent, HeaderFooterContentHeights, HeaderFooterLayout, HitTestResult, HyperlinkInfo, ImageBlock, ImageFragment, ImageMeasure, ImageRun, ImageRunPosition, Layout, LayoutOptions, LineBreakRun, ListNumPr, MathRun, Measure, MeasuredLine, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, floatingTextBoxReservesBand, floatingTextBoxWrapsText, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun };
+  export { BlockId, BorderStyle, CellBorderSpec, CellBorders, ColumnBreakBlock, ColumnBreakMeasure, ColumnLayout, DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, DocumentPosition, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, FieldRun, FloatingTablePosition, FlowBlock, FootnoteContent, Fragment, FragmentBase, HeaderFooterContent, HeaderFooterContentHeights, HeaderFooterLayout, HitTestResult, HyperlinkInfo, ImageBlock, ImageFragment, ImageMeasure, ImageRun, ImageRunPosition, Layout, LayoutOptions, LineBreakRun, ListNumPr, MathRun, Measure, MeasuredLine, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, floatingTextBoxReservesBand, floatingTextBoxWrapsText, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, tableColumnsArePinned };
 }
 /**
  * Unique identifier for a block in the document.
@@ -304,7 +304,8 @@ type ParagraphAttrs = {
   keepNext?: boolean;
   keepLines?: boolean;
   widowControl?: boolean;
-  pageBreakBefore?: boolean;
+  pageBreakBefore?: boolean; /** Word's cached pagination hint (`w:lastRenderedPageBreak`). */
+  renderedPageBreakBefore?: boolean;
   styleId?: string;
   contextualSpacing?: boolean;
   /**
@@ -459,7 +460,14 @@ type TableBlock = {
   rows: TableRow[];
   columnWidths?: number[]; /** Table width value (twips for dxa, 50ths of percent for pct). */
   width?: number; /** Table width type ('auto', 'pct', 'dxa', 'nil'). */
-  widthType?: TableWidthType; /** Table horizontal alignment */
+  widthType?: TableWidthType;
+  /**
+   * Table layout algorithm (`w:tblLayout`). "fixed" pins columns to their grid
+   * widths; "autofit" (the default when absent) lets Word size columns to
+   * content. Consulted alongside `widthType` to decide whether `w:noWrap` cells
+   * can be honored (see `tableColumnsArePinned`).
+   */
+  layout?: "fixed" | "autofit"; /** Table horizontal alignment */
   justification?: "left" | "center" | "right"; /** Table indent from left margin (in pixels, from w:tblInd) */
   indent?: number; /** Right-to-left column order (w:bidiVisual): logical column 0 paints on the right. */
   bidi?: boolean; /** Floating table properties (pixel values). */
@@ -903,7 +911,8 @@ type LayoutOptions = {
   headerContentHeights?: HeaderFooterContentHeights; /** Footer content heights by variant. */
   footerContentHeights?: HeaderFooterContentHeights; /** Whether section has different first page header/footer. */
   titlePage?: boolean; /** Whether section has different even/odd headers/footers. */
-  evenAndOddHeaders?: boolean; /** Per-page footnote reserved heights (pageNumber → height in pixels). */
+  evenAndOddHeaders?: boolean; /** Swap left/right margins on even physical pages. */
+  mirrorMargins?: boolean; /** Per-page footnote reserved heights (pageNumber → height in pixels). */
   footnoteReservedHeights?: Map<number, number>;
   /**
    * Footnote content heights keyed by internal footnote id (the OOXML
@@ -970,10 +979,8 @@ type HeaderFooterContent = {
   visualTop?: number; /** Bottom-most visual extent relative to the nominal flow origin. */
   visualBottom?: number;
   /**
-   * Flow-only bounds used by `computeHeaderFooterMarginExtender` to push
-   * body margins clear of HF overflow. Excludes `behindDoc` images that
-   * the renderer paints behind body content; including them would reserve
-   * a full-page letterhead as body push-down.
+   * Flow-only bounds for consumers that need to distinguish normal
+   * header/footer flow from floating or `behindDoc` artwork.
    */
   marginPushTop?: number;
   marginPushBottom?: number;
@@ -1031,5 +1038,19 @@ declare function floatingTextBoxWrapsText(block: TextBoxFlowAttrs): boolean;
  * Ported from eigenpal #694.
  */
 declare function floatingTextBoxReservesBand(block: TextBoxFlowAttrs): boolean;
+/**
+ * A table's columns are pinned when the layout engine cannot widen a column to
+ * fit content that overflows it: either the layout is explicitly fixed
+ * (`w:tblLayout w:type="fixed"`) or an explicit total width (`w:tblW` `dxa`/
+ * `pct`) is fully consumed by the grid.
+ *
+ * In OOXML, `w:noWrap` (§17.4.30) asks Word not to soft-wrap a cell, but Word
+ * can only honor it by widening the column. When the columns are pinned it
+ * cannot, so overflowing content wraps despite `w:noWrap`. An auto-width table
+ * (`w:tblW` `auto`/`nil`/absent with autofit layout) lets Word widen the column
+ * instead, so there `w:noWrap` genuinely keeps content on one line. Measurement
+ * and the painter both consult this so their line count and `white-space` agree.
+ */
+declare function tableColumnsArePinned(table: TableBlock): boolean;
 //#endregion
-export { BlockId, BorderStyle, CellBorderSpec, CellBorders, ColumnBreakBlock, ColumnBreakMeasure, ColumnLayout, DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, DocumentPosition, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, FieldRun, FloatingTablePosition, FlowBlock, FootnoteContent, Fragment, FragmentBase, HeaderFooterContent, HeaderFooterContentHeights, HeaderFooterLayout, HitTestResult, HyperlinkInfo, ImageBlock, ImageFragment, ImageMeasure, ImageRun, ImageRunPosition, Layout, LayoutOptions, LineBreakRun, ListNumPr, MathRun, Measure, MeasuredLine, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, floatingTextBoxReservesBand, floatingTextBoxWrapsText, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, types_d_exports };
+export { BlockId, BorderStyle, CellBorderSpec, CellBorders, ColumnBreakBlock, ColumnBreakMeasure, ColumnLayout, DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, DocumentPosition, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, FieldRun, FloatingTablePosition, FlowBlock, FootnoteContent, Fragment, FragmentBase, HeaderFooterContent, HeaderFooterContentHeights, HeaderFooterLayout, HitTestResult, HyperlinkInfo, ImageBlock, ImageFragment, ImageMeasure, ImageRun, ImageRunPosition, Layout, LayoutOptions, LineBreakRun, ListNumPr, MathRun, Measure, MeasuredLine, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, floatingTextBoxReservesBand, floatingTextBoxWrapsText, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, tableColumnsArePinned, types_d_exports };

package/dist/layout-engine/types.js

@@ -11,7 +11,8 @@ var types_exports = /* @__PURE__ */ __exportAll({
 	floatingTextBoxWrapsText: () => floatingTextBoxWrapsText,
 	isFloatingImageRun: () => isFloatingImageRun,
 	isFloatingTextBoxBlock: () => isFloatingTextBoxBlock,
-	isTextWrappingFloatingImageRun: () => isTextWrappingFloatingImageRun
+	isTextWrappingFloatingImageRun: () => isTextWrappingFloatingImageRun,
+	tableColumnsArePinned: () => tableColumnsArePinned
 });
 /** Default internal margins for text boxes (OOXML defaults in pixels) */
 const DEFAULT_TEXTBOX_MARGINS = {
@@ -96,5 +97,22 @@ function floatingTextBoxWrapsText(block) {
 function floatingTextBoxReservesBand(block) {
 	return isFloatingTextBoxBlock(block) && block.wrapType === "topAndBottom";
 }
+/**
+* A table's columns are pinned when the layout engine cannot widen a column to
+* fit content that overflows it: either the layout is explicitly fixed
+* (`w:tblLayout w:type="fixed"`) or an explicit total width (`w:tblW` `dxa`/
+* `pct`) is fully consumed by the grid.
+*
+* In OOXML, `w:noWrap` (§17.4.30) asks Word not to soft-wrap a cell, but Word
+* can only honor it by widening the column. When the columns are pinned it
+* cannot, so overflowing content wraps despite `w:noWrap`. An auto-width table
+* (`w:tblW` `auto`/`nil`/absent with autofit layout) lets Word widen the column
+* instead, so there `w:noWrap` genuinely keeps content on one line. Measurement
+* and the painter both consult this so their line count and `white-space` agree.
+*/
+function tableColumnsArePinned(table) {
+	if (table.layout === "fixed") return true;
+	return table.widthType === "dxa" || table.widthType === "pct";
+}
 //#endregion
-export { DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, floatingTextBoxReservesBand, floatingTextBoxWrapsText, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, types_exports };
+export { DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, floatingTextBoxReservesBand, floatingTextBoxWrapsText, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, tableColumnsArePinned, types_exports };

package/dist/layout-painter/renderPage.d.ts

@@ -42,6 +42,20 @@ type PageFloatingImage = {
    */
   behindDoc: boolean;
 };
+type FloatingTableBandOptions = {
+  contentX: number;
+  tableWidth: number;
+  contentWidth: number;
+  distLeft: number;
+  distRight: number;
+};
+declare const floatingTableReservesBand: ({
+  contentX,
+  tableWidth,
+  contentWidth,
+  distLeft,
+  distRight
+}: FloatingTableBandOptions) => boolean;
 /**
  * CSS class names for page elements
  */
@@ -276,4 +290,4 @@ declare function findPageShellForPmPos(container: HTMLElement, pmPos: number): {
   isExact: boolean;
 } | null;
 //#endregion
-export { AnchoredImagePosition, FootnoteRenderItem, type HeaderFooterContent, HeaderFooterLayoutInfo, PAGE_CLASS_NAMES, PAINTER_PAINTED_EVENT, PageFloatingImage, PageGeometry, PainterPaintedDetail, type RenderContext, RenderPageOptions, applySectionHeaderFooterOptions, calculateFootnoteAreaRenderHeight, computePageFingerprint, emuToPixels, findPageShellForPmPos, getDefaultPageFontFamily, isFloatingImageRun, renderAllPagesNow, renderFloatingImagesLayer, renderFootnoteArea, renderPage, renderPages, resolveAnchoredImagePosition, resolveHeaderFooterFloatLeft };
+export { AnchoredImagePosition, FootnoteRenderItem, type HeaderFooterContent, HeaderFooterLayoutInfo, PAGE_CLASS_NAMES, PAINTER_PAINTED_EVENT, PageFloatingImage, PageGeometry, PainterPaintedDetail, type RenderContext, RenderPageOptions, applySectionHeaderFooterOptions, calculateFootnoteAreaRenderHeight, computePageFingerprint, emuToPixels, findPageShellForPmPos, floatingTableReservesBand, getDefaultPageFontFamily, isFloatingImageRun, renderAllPagesNow, renderFloatingImagesLayer, renderFootnoteArea, renderPage, renderPages, resolveAnchoredImagePosition, resolveHeaderFooterFloatLeft };

package/dist/layout-painter/renderPage.js

@@ -19,6 +19,11 @@ import { panic } from "better-result";
 * Renders a single page from Layout data to DOM elements.
 * Each page contains positioned fragments within a content area.
 */
+const floatingTableReservesBand = ({ contentX, tableWidth, contentWidth, distLeft, distRight }) => {
+	const leftClearance = Math.max(0, contentX - distLeft);
+	const rightClearance = Math.max(0, contentWidth - contentX - tableWidth - distRight);
+	return Math.max(leftClearance, rightClearance) < 24;
+};
 /**
 * CSS class names for page elements
 */
@@ -874,7 +879,8 @@ function renderPage(page, context, options = {}) {
 			...img.wrapType !== void 0 ? { wrapType: img.wrapType } : {}
 		});
 	}
-	if (options.blockLookup) for (const fragment of page.fragments) {
+	if (options.blockLookup) for (let fragmentIndex = 0; fragmentIndex < page.fragments.length; fragmentIndex++) {
+		const fragment = page.fragments[fragmentIndex];
 		if (fragment.kind !== "table") continue;
 		const blockData = options.blockLookup.get(String(fragment.blockId));
 		if (blockData?.block.kind !== "table") continue;
@@ -886,9 +892,8 @@ function renderPage(page, context, options = {}) {
 		const distBottom = floating.bottomFromText ?? 0;
 		const distLeft = floating.leftFromText ?? 12;
 		const distRight = floating.rightFromText ?? 12;
-		const side = contentX < contentWidth / 2 ? "left" : "right";
-		floatingRects.push({
-			side,
+		const rect = {
+			side: contentX < contentWidth / 2 ? "left" : "right",
 			x: contentX,
 			y: contentY,
 			width: fragment.width,
@@ -897,7 +902,19 @@ function renderPage(page, context, options = {}) {
 			distBottom,
 			distLeft,
 			distRight
+		};
+		if (floatingTableReservesBand({
+			contentX,
+			tableWidth: fragment.width,
+			contentWidth,
+			distLeft,
+			distRight
+		})) rect.wrapType = "topAndBottom";
+		if (floating.vertAnchor === "text") scopedFloatingRects.push({
+			startsAtFragmentIndex: fragmentIndex,
+			rect
 		});
+		else floatingRects.push(rect);
 	}
 	if (options.blockLookup) for (let fragmentIndex = 0; fragmentIndex < page.fragments.length; fragmentIndex++) {
 		const fragment = page.fragments[fragmentIndex];
@@ -1557,22 +1574,21 @@ function renderPages(pages, container, options = {}) {
 	const pageShells = [];
 	for (let i = 0; i < pages.length; i++) {
 		const page = pages[i];
+		let pageEl;
 		if (!useVirtualization) {
 			const { context, pageOptions } = buildPageRenderArgs(page, totalPages, options);
-			const pageEl = renderPage(page, context, pageOptions);
-			container.insertBefore(pageEl, overlayBefore);
-			pageShells.push(pageEl);
+			pageEl = renderPage(page, context, pageOptions);
 		} else {
 			const doc = options.document ?? document;
-			const pageEl = doc.createElement("div");
+			pageEl = doc.createElement("div");
 			pageEl.className = options.pageClassName ?? PAGE_CLASS_NAMES.page;
 			pageEl.dataset["pageNumber"] = String(page.number);
 			pageEl.dataset["pageIndex"] = String(i);
 			applyPageStyles(pageEl, page.size.w, page.size.h, options);
 			syncPageBorderOverlay(pageEl, page, options, doc);
-			container.insertBefore(pageEl, overlayBefore);
-			pageShells.push(pageEl);
 		}
+		container.insertBefore(pageEl, overlayBefore);
+		pageShells.push(pageEl);
 	}
 	if (!useVirtualization) {
 		emitPainterPainted(container);
@@ -1820,4 +1836,4 @@ function depopulatePageShell(shell, pageDataMap) {
 	}
 }
 //#endregion
-export { PAGE_CLASS_NAMES, PAINTER_PAINTED_EVENT, applySectionHeaderFooterOptions, calculateFootnoteAreaRenderHeight, computePageFingerprint, emuToPixels, findPageShellForPmPos, getDefaultPageFontFamily, isFloatingImageRun, renderAllPagesNow, renderFloatingImagesLayer, renderFootnoteArea, renderPage, renderPages, resolveAnchoredImagePosition, resolveHeaderFooterFloatLeft };
+export { PAGE_CLASS_NAMES, PAINTER_PAINTED_EVENT, applySectionHeaderFooterOptions, calculateFootnoteAreaRenderHeight, computePageFingerprint, emuToPixels, findPageShellForPmPos, floatingTableReservesBand, getDefaultPageFontFamily, isFloatingImageRun, renderAllPagesNow, renderFloatingImagesLayer, renderFootnoteArea, renderPage, renderPages, resolveAnchoredImagePosition, resolveHeaderFooterFloatLeft };

package/dist/layout-painter/renderParagraph.js

@@ -330,8 +330,8 @@ function renderTabRun(run, doc, width, leader) {
 	} else span.textContent = "\xA0";
 	return span;
 }
-function canClampTabToRightEdge(alignment, hasPriorRenderedContent) {
-	if (alignment === "start" || alignment === "default") return hasPriorRenderedContent;
+function canClampTabToRightEdge(alignment, hasPriorRenderedContent, hasPriorTab, isLastLine) {
+	if (alignment === "start" || alignment === "default") return hasPriorRenderedContent && (hasPriorTab || isLastLine);
 	return true;
 }
 function applyTabUnderline(element, run) {
@@ -905,24 +905,32 @@ function renderLine(block, line, alignment, doc, options) {
 		lineEl.append(emptySpan);
 		return lineEl;
 	}
+	const hasTabRuns = runsForLine.some(isTabRun);
 	if (alignment === "justify" && options) {
 		if (!options.isLastLine || options.paragraphEndsWithLineBreak) {
-			const overfullPx = line.width - options.availableWidth;
+			const firstLineIndentPx = options.isFirstLine ? options.firstLineIndentPx ?? 0 : 0;
+			const firstLineHangingPx = Math.max(0, -firstLineIndentPx);
+			const justifyCapacityPx = options.availableWidth + firstLineHangingPx;
+			const overfullPx = line.width - justifyCapacityPx;
 			const shrinkableSpaces = countShrinkableSpaces(runsForLine);
 			if (overfullPx > RIGHT_EDGE_EPSILON_PX && shrinkableSpaces > 0) {
 				lineEl.style.textAlign = "left";
 				lineEl.style.textAlignLast = "auto";
 				lineEl.style.wordSpacing = `${-overfullPx / shrinkableSpaces}px`;
+			} else if (hasTabRuns && shrinkableSpaces > 0 && -overfullPx > RIGHT_EDGE_EPSILON_PX) {
+				lineEl.style.textAlign = "left";
+				lineEl.style.textAlignLast = "auto";
+				lineEl.style.wordSpacing = `${-overfullPx / shrinkableSpaces}px`;
 			} else {
 				lineEl.style.textAlign = "justify";
 				lineEl.style.textAlignLast = "justify";
 			}
-			lineEl.style.width = `${options.availableWidth}px`;
+			const listFirstLineOffset = options.isFirstLine && block.attrs?.listMarker && !block.attrs.listMarkerHidden ? options.firstLineIndentPx ?? 0 : 0;
+			lineEl.style.width = `${options.availableWidth - listFirstLineOffset}px`;
 		}
 	}
 	lineEl.style.whiteSpace = "pre";
 	lineEl.style.overflow = "visible";
-	const hasTabRuns = runsForLine.some(isTabRun);
 	let tabContext;
 	const measureText = createTextMeasurer(doc);
 	if (hasTabRuns) {
@@ -930,6 +938,7 @@ function renderLine(block, line, alignment, doc, options) {
 		const leftIndentTwips = options?.leftIndentPx ? Math.round(options.leftIndentPx * 15) : 0;
 		tabContext = {
 			...explicitStops !== void 0 ? { explicitStops } : {},
+			...block.attrs?.defaultTabStopTwips !== void 0 ? { defaultTabInterval: block.attrs.defaultTabStopTwips } : {},
 			leftIndent: leftIndentTwips
 		};
 	}
@@ -992,7 +1001,7 @@ function renderLine(block, line, alignment, doc, options) {
 				break;
 			}
 			let tabWidth = tabResult.width;
-			if (lineRightEdgeX !== void 0 && canClampTabToRightEdge(tabResult.alignment, i > 0) && currentX + tabWidth + followingWidthForCheck > lineRightEdgeX) tabWidth = Math.max(1, lineRightEdgeX - currentX - followingWidthForCheck);
+			if (lineRightEdgeX !== void 0 && canClampTabToRightEdge(tabResult.alignment, i > 0, runsForLine.slice(0, i).some(isTabRun), options?.isLastLine === true) && currentX + tabWidth + followingWidthForCheck > lineRightEdgeX) tabWidth = Math.max(1, lineRightEdgeX - currentX - followingWidthForCheck);
 			const tabEl = renderTabRun(run, doc, tabWidth, tabResult.leader);
 			lineEl.append(tabEl);
 			currentX += tabWidth;
@@ -1240,7 +1249,7 @@ function renderParagraphFragment(fragment, block, measure, context, options = {}
 			} else if (indentLeft > 0) lineEl.style.paddingLeft = `${indentLeft}px`;
 			else if (hasFirstLine && !isFlexLine) lineEl.style.textIndent = `${indent.firstLine ?? 0}px`;
 		} else if (indentLeft > 0) lineEl.style.paddingLeft = `${indentLeft}px`;
-		else if (hasHanging) lineEl.style.paddingLeft = `${indent.hanging ?? 0}px`;
+		else if (hasHanging && indentLeft === 0) lineEl.style.paddingLeft = `${indent.hanging ?? 0}px`;
 		if (indentRight > 0) lineEl.style.paddingRight = `${indentRight}px`;
 		if (isFirstLine && block.attrs?.listMarker && !block.attrs.listMarkerHidden) {
 			const hanging = indent?.hanging ?? 0;
@@ -1259,7 +1268,8 @@ function renderParagraphFragment(fragment, block, measure, context, options = {}
 			const markerFontFamily = block.attrs.listMarkerFontFamily ?? firstTextRun?.fontFamily ?? block.attrs.defaultFontFamily;
 			const markerFontSize = block.attrs.listMarkerFontSize ?? firstTextRun?.fontSize ?? block.attrs.defaultFontSize;
 			const marker = renderListMarker(block.attrs.listMarker, getListMarkerInlineWidth(block), doc, markerFontFamily, markerFontSize, block.attrs.listMarkerRevision, block.attrs.listMarkerSecondSlotOffsetTwips);
-			if (markerStart < 0 && indentLeft > 0) marker.style.marginLeft = `${markerStart}px`;
+			const markerMarginLeft = markerStart - Math.min(indentLeft, 0);
+			if (markerMarginLeft < 0 && indentLeft !== 0) marker.style.marginLeft = `${markerMarginLeft}px`;
 			lineEl.prepend(marker);
 		}
 		fragmentEl.append(lineEl);