@stll/folio-core 0.47.7 → 0.48.0

package/dist/layout-engine/measure/measureHelpers.d.ts

@@ -2,8 +2,20 @@ import { RunFormatting } from "../types.js";
 import { FontStyle } from "./measureTypes.js";
 //#region src/layout-engine/measure/measureHelpers.d.ts
 declare const DEFAULT_FONT_SIZE = 11;
-declare const DEFAULT_FONT_FAMILY = "Calibri";
-declare const DOCX_SCRIPT_FONT_SCALE = 0.75;
+/**
+ * The face for text whose run properties name no font anywhere in the cascade:
+ * no `w:rFonts` family or theme reference in the run, its styles or
+ * `w:docDefaults`. ECMA-376 §17.3.2.26 leaves this to the application; its
+ * default is Times New Roman. A document that names a font at any level never
+ * reaches it.
+ */
+declare const DEFAULT_FONT_FAMILY = "Times New Roman";
+/**
+ * Point size of `w:vertAlign="superscript"`/`"subscript"` text: two thirds
+ * of the run's size, truncated to whole half-points (the `w:sz` unit) and
+ * never below one half-point.
+ */
+declare function docxScriptFontSize(fontSize: number): number;
 /**
  * Build a measurement `FontStyle` from a run's formatting. Single source of
  * truth for run → FontStyle so every measurement path (layout line-breaking,
@@ -88,4 +100,4 @@ declare function halfPtToPx(halfPt: number): number;
  */
 declare function pxToHalfPt(px: number): number;
 //#endregion
-export { DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, DOCX_SCRIPT_FONT_SCALE, buildFontString, buildRunFontStyle, clearFontResolvedCache, findCharacterAtX, getResolvedData, getXForCharacter, halfPtToPx, ptToPx, pxToHalfPt, pxToPt, pxToTwips, twipsToPx };
+export { DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, buildFontString, buildRunFontStyle, clearFontResolvedCache, docxScriptFontSize, findCharacterAtX, getResolvedData, getXForCharacter, halfPtToPx, ptToPx, pxToHalfPt, pxToPt, pxToTwips, twipsToPx };

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

@@ -1,6 +1,7 @@
 import { resolveFontFamily } from "../../utils/fontResolver.js";
 import "../../utils/fontWeights.js";
 import { normalizeHorizontalScalePercent } from "../../utils/horizontalScale.js";
+import { eastAsiaHintApplies } from "../../utils/scriptSegments.js";
 import { FONT_KERNING_MODE, getRunFontKerningMode } from "./textMeasurementPolicy.js";
 //#region src/layout-engine/measure/measureHelpers.ts
 /**
@@ -16,8 +17,22 @@ const TWIPS_PER_INCH = 1440;
 const PX_PER_INCH = 96;
 const TWIPS_PER_PX = TWIPS_PER_INCH / PX_PER_INCH;
 const DEFAULT_FONT_SIZE = 11;
-const DEFAULT_FONT_FAMILY = "Calibri";
-const DOCX_SCRIPT_FONT_SCALE = .75;
+/**
+* The face for text whose run properties name no font anywhere in the cascade:
+* no `w:rFonts` family or theme reference in the run, its styles or
+* `w:docDefaults`. ECMA-376 §17.3.2.26 leaves this to the application; its
+* default is Times New Roman. A document that names a font at any level never
+* reaches it.
+*/
+const DEFAULT_FONT_FAMILY = "Times New Roman";
+/**
+* Point size of `w:vertAlign="superscript"`/`"subscript"` text: two thirds
+* of the run's size, truncated to whole half-points (the `w:sz` unit) and
+* never below one half-point.
+*/
+function docxScriptFontSize(fontSize) {
+	return Math.max(1, Math.floor(fontSize * 2 * 2 / 3)) / 2;
+}
 /**
 * Build a measurement `FontStyle` from a run's formatting. Single source of
 * truth for run → FontStyle so every measurement path (layout line-breaking,
@@ -28,13 +43,14 @@ const DOCX_SCRIPT_FONT_SCALE = .75;
 */
 function buildRunFontStyle(run, fallbackFontFamily, fallbackFontSize) {
 	const baseFontSize = run.fontSize ?? fallbackFontSize;
-	const fontSize = run.superscript || run.subscript ? baseFontSize * DOCX_SCRIPT_FONT_SCALE : baseFontSize;
+	const fontSize = run.superscript || run.subscript ? docxScriptFontSize(baseFontSize) : baseFontSize;
 	const horizontalScale = normalizeHorizontalScalePercent(run.horizontalScale);
 	return {
 		fontFamily: run.fontFamily ?? fallbackFontFamily,
 		...run.alternateFontFamily !== void 0 ? { alternateFontFamily: run.alternateFontFamily } : {},
 		...run.eastAsiaFontFamily !== void 0 ? { eastAsiaFontFamily: run.eastAsiaFontFamily } : {},
 		...run.eastAsiaAlternateFontFamily !== void 0 ? { eastAsiaAlternateFontFamily: run.eastAsiaAlternateFontFamily } : {},
+		...eastAsiaHintApplies(run) ? { eastAsiaHint: true } : {},
 		...run.complexScriptFontFamily !== void 0 ? { complexScriptFontFamily: run.complexScriptFontFamily } : {},
 		...run.complexScriptAlternateFontFamily !== void 0 ? { complexScriptAlternateFontFamily: run.complexScriptAlternateFontFamily } : {},
 		...run.complexScriptFontSize !== void 0 ? { complexScriptFontSize: run.complexScriptFontSize } : {},
@@ -107,7 +123,7 @@ function buildFontString(style) {
 	if (style.bold) parts.push("700");
 	const fontSizePx = ptToPx(style.fontSize ?? 11);
 	parts.push(`${fontSizePx}px`);
-	const fontFamily = style.fontFamily ?? "Calibri";
+	const fontFamily = style.fontFamily ?? "Times New Roman";
 	parts.push(getResolvedFallback(fontFamily, style.alternateFontFamily));
 	return parts.join(" ");
 }
@@ -181,4 +197,4 @@ function pxToHalfPt(px) {
 	return pxToPt(px) * 2;
 }
 //#endregion
-export { DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, DOCX_SCRIPT_FONT_SCALE, buildFontString, buildRunFontStyle, clearFontResolvedCache, findCharacterAtX, getResolvedData, getXForCharacter, halfPtToPx, ptToPx, pxToHalfPt, pxToPt, pxToTwips, twipsToPx };
+export { DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, buildFontString, buildRunFontStyle, clearFontResolvedCache, docxScriptFontSize, findCharacterAtX, getResolvedData, getXForCharacter, halfPtToPx, ptToPx, pxToHalfPt, pxToPt, pxToTwips, twipsToPx };

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

@@ -1,7 +1,8 @@
 import { CJK_FALLBACK_FONT_FAMILY, isCjkFont } from "../../utils/fontResolver.js";
 import { getHorizontalScaleFactor } from "../../utils/horizontalScale.js";
 import { inlineImageBoundingBox } from "../../utils/rotationBoundingBox.js";
-import { hasCjk, hasComplexScript } from "../../utils/scriptSegments.js";
+import { hasCjk, hasComplexScript, hasEastAsiaSlotText } from "../../utils/scriptSegments.js";
+import { splitTrailingToken } from "../../utils/trailingText.js";
 import { JUSTIFIED_FINAL_LINE_MAX_SHRINK_RATIO, JUSTIFIED_FINAL_LINE_SPACE_CONTRACTION_RATIO, supportsJustifiedFinalLineContraction } from "../justifiedLineFit.js";
 import { measuredLineAdvance } from "../lineFlow.js";
 import { isFloatingImageRun } from "../types.js";
@@ -10,9 +11,9 @@ import { applyComplexScriptFormatting, hasComplexScriptFormatting } from "./comp
 import { resolveEffectiveLineBreakPolicy } from "./effectiveLineBreakPolicy.js";
 import { getFloatingAvailableWidth, getFloatingMargins } from "./floatingZones.js";
 import { defaultLineBreakProvider, getLineBreakProvider } from "./lineBreakProvider.js";
-import { findGraphemeBreaks, findHyphenationBreaks, findWordBreaks, isBreakChar, isHangingPunctuation } from "./lineBreaks.js";
+import { findGraphemeBreaks, findHyphenationBreaks, findWordBreaks, isBreakBetween, isBreakChar, isHangingPunctuation } from "./lineBreaks.js";
 import { getListMarkerInlineWidth } from "./listMarkerWidth.js";
-import { buildRunFontStyle, ptToPx, twipsToPx } from "./measureHelpers.js";
+import { DEFAULT_FONT_FAMILY, buildRunFontStyle, ptToPx, twipsToPx } from "./measureHelpers.js";
 import { getFontMetrics, measureRun, measureTextWidth } from "./measureProvider.js";
 import { calculateTabWidth, pixelsToTwips } from "./tabCalculator.js";
 import { countCompressibleSpaces } from "./textMeasurementPolicy.js";
@@ -24,11 +25,10 @@ import { countCompressibleSpaces } from "./textMeasurementPolicy.js";
 * Converts runs into measured lines with typography metrics.
 */
 const DEFAULT_FONT_SIZE = 11;
-const DEFAULT_FONT_FAMILY = "Calibri";
 const DEFAULT_LINE_HEIGHT_MULTIPLIER = 1;
 const WIDTH_TOLERANCE = .5;
 const JUSTIFY_SHRINK_TOLERANCE_RATIO = .016;
-const JUSTIFY_SPACE_CONTRACTION_RATIO = .075;
+const JUSTIFY_SPACE_CONTRACTION_RATIO = .25;
 const JUSTIFY_LIST_MARKER_SPACE_CONTRACTION_RATIO = .195;
 const JUSTIFY_DEEP_HANGING_LIST_MARKER_SHRINK_TOLERANCE_RATIO = .022;
 const JUSTIFY_LITERAL_TAB_CONTINUATION_SHRINK_TOLERANCE_RATIO = .017;
@@ -85,9 +85,11 @@ function runToFontStyle(run) {
 * keeps the base style so wrapping is untouched.
 */
 function cjkLineHeightStyle(run, baseStyle) {
-	if (!run.text || !hasCjk(run.text)) return baseStyle;
+	if (!run.text) return baseStyle;
 	const eastAsia = baseStyle.eastAsiaFontFamily;
-	if (eastAsia !== void 0 && isCjkFont(eastAsia)) {
+	const eastAsiaFace = eastAsia !== void 0 && isCjkFont(eastAsia);
+	if (!hasCjk(run.text) && !(eastAsiaFace && hasEastAsiaSlotText(run.text, baseStyle.eastAsiaHint))) return baseStyle;
+	if (eastAsia !== void 0 && eastAsiaFace) {
 		const result = {
 			...baseStyle,
 			fontFamily: eastAsia
@@ -96,7 +98,7 @@ function cjkLineHeightStyle(run, baseStyle) {
 		if (baseStyle.eastAsiaAlternateFontFamily !== void 0) result.alternateFontFamily = baseStyle.eastAsiaAlternateFontFamily;
 		return result;
 	}
-	if (isCjkFont(baseStyle.fontFamily ?? DEFAULT_FONT_FAMILY)) return baseStyle;
+	if (isCjkFont(baseStyle.fontFamily ?? "Times New Roman")) return baseStyle;
 	return {
 		...baseStyle,
 		fontFamily: CJK_FALLBACK_FONT_FAMILY
@@ -153,7 +155,7 @@ const WORD_SINGLE_LINE_FLOOR = 1.15;
 function calculateEmptyParagraphMetrics(fontSize, spacing, fontFamily, attrs) {
 	const result = calculateTypographyMetrics(fontSize, spacing, getFontMetrics({
 		fontSize,
-		fontFamily: fontFamily ?? DEFAULT_FONT_FAMILY,
+		fontFamily: fontFamily ?? "Times New Roman",
 		...attrs?.defaultAlternateFontFamily !== void 0 ? { alternateFontFamily: attrs.defaultAlternateFontFamily } : {}
 	}));
 	const lineRule = spacing?.lineRule ?? "auto";
@@ -432,15 +434,13 @@ function isFinalTextCandidate(block, runIndex, nextBreak) {
 	return true;
 }
 function resolveTextCandidateFit({ block, line, isFirstLine, isFinalCandidate, candidateWidth, candidateSpaceWidth, fallbackTolerancePx, continuationStrategy, finalStrategy }) {
-	if (!isFinalCandidate || !supportsJustifiedFinalLineContraction(block)) return {
+	if (!isFinalCandidate) return {
 		type: "ordinary",
 		tolerancePx: fallbackTolerancePx
 	};
+	if (!supportsJustifiedFinalLineContraction(block)) return admitFinalCandidate(candidateWidth, line.availableWidth, fallbackTolerancePx);
 	const ordinaryTolerancePx = isFirstLine ? fallbackTolerancePx : justifyFitTolerance(line, continuationStrategy, candidateSpaceWidth);
-	if (candidateWidth <= line.availableWidth + ordinaryTolerancePx) return {
-		type: "ordinary",
-		tolerancePx: ordinaryTolerancePx
-	};
+	if (candidateWidth <= line.availableWidth + ordinaryTolerancePx) return admitFinalCandidate(candidateWidth, line.availableWidth, ordinaryTolerancePx);
 	const finalTolerancePx = justifyFitTolerance(line, finalStrategy, candidateSpaceWidth);
 	if (candidateWidth > line.availableWidth + finalTolerancePx) return {
 		type: "final-contraction-rejected",
@@ -455,6 +455,26 @@ function resolveTextCandidateFit({ block, line, isFirstLine, isFinalCandidate, c
 		}
 	};
 }
+/**
+* A paragraph's last line is not stretched, so a final word admitted by space
+* contraction needs an explicit paint plan; otherwise it would paint past the
+* measure. Sub-pixel rounding overflow stays on the ordinary path.
+*/
+function admitFinalCandidate(candidateWidth, availableWidth, tolerancePx) {
+	const contractionPx = candidateWidth - availableWidth;
+	if (contractionPx <= WIDTH_TOLERANCE || contractionPx > tolerancePx) return {
+		type: "ordinary",
+		tolerancePx
+	};
+	return {
+		type: "final-contraction-admitted",
+		tolerancePx,
+		paint: {
+			type: "space-contraction",
+			contractionPx
+		}
+	};
+}
 function compressibleSpaceWidth(text, style) {
 	const count = countCompressibleSpaces(text);
 	return count === 0 ? 0 : count * measureTextWidth(" ", style);
@@ -503,6 +523,21 @@ function measureWordWithTrailingWhitespace(word, style) {
 		fullWordWidth: wordWidth + trailingWhitespaceWidth + boundarySpacing
 	};
 }
+const scaledLetterSpacing = (style) => (style.letterSpacing ?? 0) * getHorizontalScaleFactor(style.horizontalScale);
+/**
+* Character spacing still owed after the last character placed on the line,
+* or 0 when the line has no preceding character at `charIndex` of `runIndex`.
+* Within a run it is the run's own spacing; at a boundary between two text
+* runs it is the preceding run's spacing on its final character.
+*/
+function precedingLetterSpacing({ block, line, runIndex, charIndex, runStyle }) {
+	if (line.fromRun === line.toRun && line.fromChar === line.toChar) return 0;
+	if (line.toRun === runIndex && line.toChar === charIndex) return scaledLetterSpacing(runStyle);
+	if (charIndex !== 0 || line.toRun !== runIndex - 1) return 0;
+	const previousRun = block.runs[runIndex - 1];
+	if (!previousRun || !isTextRun(previousRun) || previousRun.text.length === 0 || line.toChar !== previousRun.text.length) return 0;
+	return scaledLetterSpacing(runToFontStyle(previousRun));
+}
 function trailingCodePoint(text) {
 	if (text.length === 0) return;
 	const trailing = text.charCodeAt(text.length - 1);
@@ -548,6 +583,21 @@ function computeTrailingGlueWidths(block) {
 	}
 	return widths;
 }
+/**
+* First character of the text that follows each run, looking through empty
+* text runs; undefined before a non-text run or at the paragraph end.
+*/
+function computeFollowingTextLeads(block) {
+	const leads = Array.from({ length: block.runs.length }, () => void 0);
+	let lead;
+	for (let index = block.runs.length - 1; index >= 0; index--) {
+		leads[index] = lead;
+		const run = block.runs[index];
+		if (!run || !isTextRun(run)) lead = void 0;
+		else if (run.text) lead = run.text[0];
+	}
+	return leads;
+}
 function computeProtectedCrossRunGlueWidths(block) {
 	const widths = Array.from({ length: block.runs.length }, () => 0);
 	for (let index = 0; index < block.runs.length; index++) {
@@ -558,10 +608,10 @@ function computeProtectedCrossRunGlueWidths(block) {
 			run
 		}).provider;
 		if (!policy.locale?.toLocaleLowerCase().startsWith("cs")) continue;
-		const trailing = /(\S+)(\s*)$/u.exec(run.text ?? "");
-		const token = trailing?.[1];
-		if (!token || token.length !== 1) continue;
-		let separator = trailing[2] ?? "";
+		const trailing = splitTrailingToken(run.text ?? "");
+		if (!trailing || trailing.token.length !== 1) continue;
+		const { token } = trailing;
+		let separator = trailing.separator;
 		let glueWidth = separator.length > 0 ? measureTextWidth(separator, runToFontStyle(run)) : 0;
 		let followingWord = "";
 		let unseparatedFollowingText = false;
@@ -772,7 +822,7 @@ function measureParagraph(block, maxWidth, options) {
 		};
 	}
 	if (runs.length === 0) {
-		const emptyMetrics = calculateEmptyParagraphMetrics(attrs?.defaultFontSize ?? DEFAULT_FONT_SIZE, spacing, attrs?.defaultFontFamily ?? DEFAULT_FONT_FAMILY, attrs);
+		const emptyMetrics = calculateEmptyParagraphMetrics(attrs?.defaultFontSize ?? DEFAULT_FONT_SIZE, spacing, attrs?.defaultFontFamily ?? "Times New Roman", attrs);
 		const outlineLineHeight = attrs?.reserveEmptyOutlineHeight ? emptyMetrics.lineHeight * 2 : emptyMetrics.lineHeight;
 		lines.push({
 			fromRun: 0,
@@ -793,7 +843,7 @@ function measureParagraph(block, maxWidth, options) {
 		};
 	}
 	if (runs.length > 0 && runs.every((run) => isTextRun(run) && isEmptyTextRun(run))) {
-		const emptyMetrics = calculateEmptyParagraphMetrics(attrs?.defaultFontSize ?? DEFAULT_FONT_SIZE, spacing, attrs?.defaultFontFamily ?? DEFAULT_FONT_FAMILY, attrs);
+		const emptyMetrics = calculateEmptyParagraphMetrics(attrs?.defaultFontSize ?? DEFAULT_FONT_SIZE, spacing, attrs?.defaultFontFamily ?? "Times New Roman", attrs);
 		lines.push({
 			fromRun: 0,
 			fromChar: 0,
@@ -813,6 +863,7 @@ function measureParagraph(block, maxWidth, options) {
 	}
 	const trailingGlueWidths = computeTrailingGlueWidths(block);
 	const protectedCrossRunGlueWidths = computeProtectedCrossRunGlueWidths(block);
+	const followingTextLeads = computeFollowingTextLeads(block);
 	let currentLine = {
 		fromRun: 0,
 		fromChar: 0,
@@ -823,6 +874,8 @@ function measureParagraph(block, maxWidth, options) {
 		regularSpaceWidth: 0,
 		maxFontSize: DEFAULT_FONT_SIZE,
 		maxFontMetrics: null,
+		maxTabFontSize: DEFAULT_FONT_SIZE,
+		maxTabFontMetrics: null,
 		maxImageHeightPx: 0,
 		maxExactImageHeightPx: 0,
 		maxMathHeightPx: 0,
@@ -833,9 +886,14 @@ function measureParagraph(block, maxWidth, options) {
 	};
 	const calculateLineTypography = (line) => {
 		const paragraphFontSize = attrs?.defaultFontSize ?? DEFAULT_FONT_SIZE;
-		const paragraphFontFamily = attrs?.defaultFontFamily ?? DEFAULT_FONT_FAMILY;
-		const fontSize = line.maxFontMetrics ? line.maxFontSize : paragraphFontSize;
-		const metrics = line.maxFontMetrics ?? getFontMetrics({
+		const paragraphFontFamily = attrs?.defaultFontFamily ?? "Times New Roman";
+		let lineFontMetrics = line.maxFontMetrics;
+		let fontSize = line.maxFontSize;
+		if (!lineFontMetrics) {
+			lineFontMetrics = line.maxTabFontMetrics;
+			fontSize = lineFontMetrics ? line.maxTabFontSize : paragraphFontSize;
+		}
+		const metrics = lineFontMetrics ?? getFontMetrics({
 			fontSize: paragraphFontSize,
 			fontFamily: paragraphFontFamily,
 			...attrs?.defaultAlternateFontFamily !== void 0 ? { alternateFontFamily: attrs.defaultAlternateFontFamily } : {}
@@ -919,6 +977,8 @@ function measureParagraph(block, maxWidth, options) {
 			regularSpaceWidth: 0,
 			maxFontSize: DEFAULT_FONT_SIZE,
 			maxFontMetrics: null,
+			maxTabFontSize: DEFAULT_FONT_SIZE,
+			maxTabFontMetrics: null,
 			maxImageHeightPx: 0,
 			maxExactImageHeightPx: 0,
 			maxMathHeightPx: 0,
@@ -942,6 +1002,19 @@ function measureParagraph(block, maxWidth, options) {
 		const metrics = getFontMetrics(style);
 		if (metrics.singleLineRatio > currentLine.maxFontMetrics.singleLineRatio) currentLine.maxFontMetrics = metrics;
 	};
+	/**
+	* Track the tallest tab on the line separately from content runs: a tab's
+	* font does not raise a line that carries other content, so a tab run
+	* formatted larger than its neighbouring text (a TOC entry whose tab keeps
+	* the paragraph-mark size) leaves the line at the text's height.
+	*/
+	const updateMaxTabFont = (style) => {
+		const fontSize = style.fontSize ?? DEFAULT_FONT_SIZE;
+		if (!currentLine.maxTabFontMetrics || fontSize > currentLine.maxTabFontSize) {
+			currentLine.maxTabFontSize = fontSize;
+			currentLine.maxTabFontMetrics = getFontMetrics(style);
+		}
+	};
 	let crossRunResume;
 	for (let runIndex = 0; runIndex < runs.length; runIndex++) {
 		if (crossRunResume && runIndex < crossRunResume.runIndex) continue;
@@ -970,7 +1043,7 @@ function measureParagraph(block, maxWidth, options) {
 		}
 		if (isTabRun(run)) {
 			const style = runToFontStyle(run);
-			updateMaxFont(style);
+			updateMaxTabFont(style);
 			const followingWidth = measureInlineWidthAfterTab(runs, runIndex, options?.fieldValues);
 			const decimalPrefixWidth = measureDecimalPrefixWidthAfterTab(runs, runIndex, options?.fieldValues);
 			const lineX = currentLine.width + currentLine.leftOffset;
@@ -987,14 +1060,14 @@ function measureParagraph(block, maxWidth, options) {
 			let tabWidth = tabResult.width;
 			const authoredEndpoint = contentX + tabWidth + followingWidth;
 			const activeContentRightEdge = maxWidth - currentLine.rightOffset;
-			const preservesAuthoredEndStop = tabResult.alignment === "end" && (options?.allowEndTabOverflow === true || authoredEndpoint <= activeContentRightEdge + WIDTH_TOLERANCE);
+			const preservesAuthoredStop = tabResult.alignment === "end" && options?.allowEndTabOverflow === true || tabResult.explicit === true && authoredEndpoint <= activeContentRightEdge + WIDTH_TOLERANCE;
 			const landsOnLeftIndent = tabResult.alignment === "start" && indentLeft > 0 && Math.abs(contentX + tabWidth - indentLeft) <= WIDTH_TOLERANCE;
 			const lineRightEdgeX = indentLeft + (isFirstLine ? firstLineOffset + markerInlineWidth : 0) + currentLine.availableWidth + currentLine.leftOffset;
-			if (!preservesAuthoredEndStop && !landsOnLeftIndent && !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 (preservesAuthoredEndStop) currentLine.availableWidth = Math.max(currentLine.availableWidth, currentLine.width + tabWidth + followingWidth);
+			if (!preservesAuthoredStop && !landsOnLeftIndent && !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 (preservesAuthoredStop) currentLine.availableWidth = Math.max(currentLine.availableWidth, currentLine.width + tabWidth + followingWidth);
 			if (currentLine.width + tabWidth > currentLine.availableWidth + WIDTH_TOLERANCE) {
 				startNewLine(runIndex, 0);
-				updateMaxFont(style);
+				updateMaxTabFont(style);
 			}
 			currentLine.width += tabWidth;
 			currentLine.trailingWhitespaceWidth = 0;
@@ -1098,7 +1171,13 @@ function measureParagraph(block, maxWidth, options) {
 				const nextBreak = wordBreaks[wordBreakIndex] ?? text.length;
 				const word = text.slice(charIndex, nextBreak);
 				const { measuredWord, wordWidth, fullWordWidth } = measureWordWithTrailingWhitespace(word, style);
-				let leadingLetterSpacing = (currentLine.fromRun !== currentLine.toRun || currentLine.fromChar !== currentLine.toChar) && currentLine.toRun === runIndex && currentLine.toChar === charIndex ? (style.letterSpacing ?? 0) * ((style.horizontalScale ?? 100) / 100) : 0;
+				let leadingLetterSpacing = precedingLetterSpacing({
+					block,
+					line: currentLine,
+					runIndex,
+					charIndex,
+					runStyle: style
+				});
 				const hangingPunctuationWidth = trailingHangingPunctuationWidth(measuredWord, style, breakPolicy, effectiveLineBreakPolicy.hangingPunctuation);
 				const isFirstLine = lines.length === 0;
 				const regularSpaceWidth = compressibleSpaceWidth(measuredWord, style);
@@ -1223,7 +1302,7 @@ function measureParagraph(block, maxWidth, options) {
 				}
 				const wordTail = word.at(-1);
 				const protectedGlueWidth = protectedCrossRunGlueWidths[runIndex] ?? 0;
-				const rawGlueWidth = isRunTail && wordTail !== void 0 && (!isBreakChar(wordTail) || protectedGlueWidth > 0) ? Math.max(trailingGlueWidths[runIndex] ?? 0, protectedGlueWidth) : 0;
+				const rawGlueWidth = isRunTail && wordTail !== void 0 && (!isBreakBetween(wordTail, followingTextLeads[runIndex]) || protectedGlueWidth > 0) ? Math.max(trailingGlueWidths[runIndex] ?? 0, protectedGlueWidth) : 0;
 				const glueWidth = rawGlueWidth > 0 && wordWidth + rawGlueWidth <= getPostWrapAvailableWidth() + widthTolerance ? rawGlueWidth : 0;
 				const hangingAllowance = glueWidth === 0 ? hangingPunctuationWidth : 0;
 				const candidateFit = isJustifiedParagraph ? resolveTextCandidateFit({

package/dist/layout-engine/measure/measureTypes.d.ts

@@ -23,6 +23,11 @@ type FontStyle = {
    */
   eastAsiaFontFamily?: string;
   eastAsiaAlternateFontFamily?: string;
+  /**
+   * The run's effective `w:hint="eastAsia"`: the code points it moves measure
+   * with `eastAsiaFontFamily` too.
+   */
+  eastAsiaHint?: boolean;
   /**
    * Complex-script font for Arabic, Hebrew, Indic and South-East Asian code
    * points. Same contract as `eastAsiaFontFamily`, over a different slot.

package/dist/layout-engine/measure/tabCalculator.d.ts

@@ -50,6 +50,8 @@ type TabWidthResult = {
   leader?: TabLeader;
   /** Alignment that was applied */
   alignment: TabAlignment | "default";
+  /** Set when the tab advanced to one of the context's explicit stops. */
+  explicit?: true;
 };
 /** Default tab interval: 720 twips = 0.5 inch */
 declare const DEFAULT_TAB_INTERVAL_TWIPS = 720;

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

@@ -122,7 +122,8 @@ function calculateTabWidth(currentXPx, context, following = {}) {
 	return {
 		width,
 		...nextStop.leader !== void 0 ? { leader: nextStop.leader } : {},
-		alignment: nextStop.val
+		alignment: nextStop.val,
+		...context.explicitStops?.includes(nextStop) === true ? { explicit: true } : {}
 	};
 }
 /**

package/dist/layout-engine/measure/tableCellFloating.d.ts

@@ -22,6 +22,8 @@ type TableCellFloatingImage = {
   distLeft: number;
   distRight: number;
   wrapText?: "bothSides" | "left" | "right" | "largest";
+  /** Authored wrap mode; decides whether and how the picture excludes text. */
+  wrapType?: ImageRun["wrapType"];
   pmStart?: number;
   pmEnd?: number;
 };

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

@@ -53,6 +53,7 @@ function getTableCellFloatingImages(cell, cellMeasure, contentWidth, resolvePosi
 			const distLeft = run.distLeft ?? 12;
 			const distRight = run.distRight ?? 12;
 			const verticalOriginY = run.position?.vertical?.relativeTo === "paragraph" ? placement.top : placement.contentTop;
+			if (run.layoutInCell === false && !resolvePosition) continue;
 			const resolved = run.layoutInCell === false && resolvePosition ? resolvePosition(run, verticalOriginY) : resolveCellScopedPosition({
 				run,
 				paragraphY: verticalOriginY,
@@ -82,6 +83,7 @@ function getTableCellFloatingImages(cell, cellMeasure, contentWidth, resolvePosi
 				distLeft,
 				distRight,
 				wrapText,
+				...run.wrapType !== void 0 ? { wrapType: run.wrapType } : {},
 				...run.pmStart !== void 0 ? { pmStart: run.pmStart } : {},
 				...run.pmEnd !== void 0 ? { pmEnd: run.pmEnd } : {}
 			});
@@ -89,26 +91,56 @@ function getTableCellFloatingImages(cell, cellMeasure, contentWidth, resolvePosi
 	}
 	return result;
 }
+/**
+* The text exclusion one cell-scoped picture casts, in cell content
+* coordinates, or `undefined` when text ignores it.
+*
+* - `wp:wrapNone` (`behind` / `inFront`): text paints over or under the
+*   picture, so nothing is excluded.
+* - `wp:wrapTopAndBottom`: no text beside the picture; lines it overlaps move
+*   below it.
+* - `wp:wrapSquare` and the contour modes: text runs on the picture's open
+*   side. When the picture and its wrap distances cover the cell's content
+*   width there is no open side, and the text moves below the picture as for
+*   `wrapTopAndBottom`.
+*/
+function tableCellFloatingZone(img, contentWidth) {
+	if (img.wrapType === "behind" || img.wrapType === "inFront") return;
+	const rectLeft = img.x - img.distLeft;
+	const rectRight = img.x + img.width + img.distRight;
+	const topY = img.y - img.distTop;
+	const bottomY = img.y + img.height + img.distBottom;
+	const belowPicture = {
+		leftMargin: 0,
+		rightMargin: 0,
+		topY,
+		bottomY,
+		fullWidthBlock: true
+	};
+	if (img.wrapType === "topAndBottom") return belowPicture;
+	let leftMargin = 0;
+	let rightMargin = 0;
+	const wrapText = img.wrapText ?? "bothSides";
+	if (wrapText === "right") leftMargin = rectRight;
+	else if (wrapText === "left") rightMargin = contentWidth - rectLeft;
+	else if (img.side === "left") leftMargin = rectRight;
+	else rightMargin = contentWidth - rectLeft;
+	if (rectRight > 0 && rectLeft < contentWidth && Math.max(leftMargin, rightMargin) >= contentWidth) return belowPicture;
+	const clamped = clampFloatingWrapMargins(leftMargin, rightMargin, contentWidth);
+	return {
+		leftMargin: clamped.leftMargin,
+		rightMargin: clamped.rightMargin,
+		topY,
+		bottomY
+	};
+}
 function buildTableCellFloatingZones(floatingImages, contentWidth) {
-	return floatingImages.map((img) => {
-		const rectRight = img.x + img.width + img.distRight;
-		const rectTop = img.y - img.distTop;
-		const rectBottom = img.y + img.height + img.distBottom;
-		let leftMargin = 0;
-		let rightMargin = 0;
-		const wrapText = img.wrapText ?? "bothSides";
-		if (wrapText === "right") leftMargin = rectRight;
-		else if (wrapText === "left") rightMargin = contentWidth - (img.x - img.distLeft);
-		else if (img.side === "left") leftMargin = rectRight;
-		else rightMargin = contentWidth - (img.x - img.distLeft);
-		const clamped = clampFloatingWrapMargins(leftMargin, rightMargin, contentWidth);
-		return {
-			leftMargin: clamped.leftMargin,
-			rightMargin: clamped.rightMargin,
-			topY: rectTop,
-			bottomY: rectBottom
-		};
-	});
+	const zones = [];
+	for (const img of floatingImages) {
+		const zone = tableCellFloatingZone(img, contentWidth);
+		if (zone !== void 0) zones.push(zone);
+	}
+	return zones;
 }
 //#endregion
 export { buildTableCellFloatingZones, getTableCellContentWidth, getTableCellFloatingImages };

package/dist/layout-engine/measure/tableCellGrid.d.ts

@@ -16,13 +16,38 @@ type BuildTableCellPlacementsOptions = {
   grid: TableCellGrid;
   columnWidths: readonly number[];
   bidi: boolean;
+  /** `w:tblCellSpacing` in pixels; see {@link getTableCellSpacingInsetsX}. */
+  cellSpacing?: number | undefined;
 };
+type TableCellSpacingInsets = {
+  readonly start: number;
+  readonly end: number;
+};
+type TableCellSpacingInsetsY = {
+  readonly top: number;
+  readonly bottom: number;
+};
+/**
+ * Logical inline insets of a cell box inside its grid slot under
+ * `w:tblCellSpacing` (§17.4.43). The spacing separates every cell from its
+ * neighbours and from the table edge: each cell keeps one unit on each side of
+ * its slot, and a slot at the table's leading or trailing grid edge keeps one
+ * more for the edge itself.
+ */
+declare const getTableCellSpacingInsetsX: (cellSpacing: number | undefined, sourceColumn: number, columnSpan: number, columnCount: number) => TableCellSpacingInsets;
+/**
+ * Block-direction insets of a cell box inside the rows it spans, the
+ * `w:tblCellSpacing` counterpart of {@link getTableCellSpacingInsetsX}: one
+ * unit above and below every cell, plus one more at the table's first and
+ * last rows.
+ */
+declare const getTableCellSpacingInsetsY: (cellSpacing: number | undefined, rowIndex: number, rowSpan: number, rowCount: number) => TableCellSpacingInsetsY;
 declare const buildTableCellGrid: (rows: readonly TableRow[], columnCount: number) => TableCellGrid;
 declare const getFirstAvailableColumn: (grid: TableCellGrid, rowIndex: number, startingColumn: number) => number;
 declare const getSourceCellAt: (grid: TableCellGrid, rowIndex: number, columnIndex: number) => TableCell | undefined;
 declare const getSourceCellColumn: (grid: TableCellGrid, cell: TableCell) => number | undefined;
 /** Resolve all source cells to canonical logical columns and physical boxes. */
-declare const buildTableCellPlacements: ({ grid, columnWidths, bidi }: BuildTableCellPlacementsOptions) => TableCellPlacements;
-declare const getTableCellVerticalBorderHeight: (grid: TableCellGrid, cell: TableCell | undefined, rowIndex: number) => number;
+declare const buildTableCellPlacements: ({ grid, columnWidths, bidi, cellSpacing }: BuildTableCellPlacementsOptions) => TableCellPlacements;
+declare const getTableCellVerticalBorderHeight: (grid: TableCellGrid, cell: TableCell | undefined, rowIndex: number, separated?: boolean) => number;
 //#endregion
-export { TableCellGrid, TableCellPlacement, TableCellPlacements, buildTableCellGrid, buildTableCellPlacements, getFirstAvailableColumn, getSourceCellAt, getSourceCellColumn, getTableCellVerticalBorderHeight };
+export { TableCellGrid, TableCellPlacement, TableCellPlacements, TableCellSpacingInsets, TableCellSpacingInsetsY, buildTableCellGrid, buildTableCellPlacements, getFirstAvailableColumn, getSourceCellAt, getSourceCellColumn, getTableCellSpacingInsetsX, getTableCellSpacingInsetsY, getTableCellVerticalBorderHeight };

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

@@ -1,5 +1,41 @@
 import { paintsCssBorder } from "../../utils/borderCss.js";
 //#region src/layout-engine/measure/tableCellGrid.ts
+const spacingUnit = (cellSpacing) => cellSpacing !== void 0 && Number.isFinite(cellSpacing) && cellSpacing > 0 ? cellSpacing : 0;
+/**
+* Logical inline insets of a cell box inside its grid slot under
+* `w:tblCellSpacing` (§17.4.43). The spacing separates every cell from its
+* neighbours and from the table edge: each cell keeps one unit on each side of
+* its slot, and a slot at the table's leading or trailing grid edge keeps one
+* more for the edge itself.
+*/
+const getTableCellSpacingInsetsX = (cellSpacing, sourceColumn, columnSpan, columnCount) => {
+	const unit = spacingUnit(cellSpacing);
+	if (unit === 0) return {
+		start: 0,
+		end: 0
+	};
+	return {
+		start: sourceColumn <= 0 ? unit * 2 : unit,
+		end: sourceColumn + columnSpan >= columnCount ? unit * 2 : unit
+	};
+};
+/**
+* Block-direction insets of a cell box inside the rows it spans, the
+* `w:tblCellSpacing` counterpart of {@link getTableCellSpacingInsetsX}: one
+* unit above and below every cell, plus one more at the table's first and
+* last rows.
+*/
+const getTableCellSpacingInsetsY = (cellSpacing, rowIndex, rowSpan, rowCount) => {
+	const unit = spacingUnit(cellSpacing);
+	if (unit === 0) return {
+		top: 0,
+		bottom: 0
+	};
+	return {
+		top: rowIndex <= 0 ? unit * 2 : unit,
+		bottom: rowIndex + Math.max(1, rowSpan) >= rowCount ? unit * 2 : unit
+	};
+};
 const buildTableCellGrid = (rows, columnCount) => {
 	const occupiedColumnsByRow = /* @__PURE__ */ new Map();
 	const sourceCellsByRow = /* @__PURE__ */ new Map();
@@ -36,7 +72,7 @@ const getFirstAvailableColumn = (grid, rowIndex, startingColumn) => firstAvailab
 const getSourceCellAt = (grid, rowIndex, columnIndex) => grid.sourceCellsByRow.get(rowIndex)?.get(columnIndex);
 const getSourceCellColumn = (grid, cell) => grid.sourceColumnsByCell.get(cell);
 /** Resolve all source cells to canonical logical columns and physical boxes. */
-const buildTableCellPlacements = ({ grid, columnWidths, bidi }) => {
+const buildTableCellPlacements = ({ grid, columnWidths, bidi, cellSpacing }) => {
 	const columnOffsets = [0];
 	for (const columnWidth of columnWidths) columnOffsets.push((columnOffsets.at(-1) ?? 0) + columnWidth);
 	const tableWidth = columnOffsets.at(-1) ?? 0;
@@ -45,8 +81,11 @@ const buildTableCellPlacements = ({ grid, columnWidths, bidi }) => {
 		if (sourceColumn < 0 || sourceColumn >= columnWidths.length) continue;
 		const declaredColumnSpan = Math.max(1, Math.trunc(cell.colSpan ?? 1));
 		const columnSpan = Math.min(declaredColumnSpan, columnWidths.length - sourceColumn);
-		const logicalLeft = columnOffsets.at(sourceColumn) ?? 0;
-		const logicalRight = columnOffsets.at(sourceColumn + columnSpan) ?? logicalLeft;
+		const slotLeft = columnOffsets.at(sourceColumn) ?? 0;
+		const slotRight = columnOffsets.at(sourceColumn + columnSpan) ?? slotLeft;
+		const insets = getTableCellSpacingInsetsX(cellSpacing, sourceColumn, columnSpan, columnWidths.length);
+		const logicalLeft = Math.min(slotRight, slotLeft + insets.start);
+		const logicalRight = Math.max(logicalLeft, slotRight - insets.end);
 		const width = logicalRight - logicalLeft;
 		placements.set(cell, {
 			sourceColumn,
@@ -57,7 +96,8 @@ const buildTableCellPlacements = ({ grid, columnWidths, bidi }) => {
 	}
 	return placements;
 };
-const getTableCellVerticalBorderHeight = (grid, cell, rowIndex) => {
+const getTableCellVerticalBorderHeight = (grid, cell, rowIndex, separated = false) => {
+	if (separated) return (cell?.borders?.top?.width ?? 0) + (cell?.borders?.bottom?.width ?? 0);
 	const sourceColumn = cell ? getSourceCellColumn(grid, cell) : void 0;
 	const aboveBottom = (sourceColumn === void 0 ? void 0 : getSourceCellAt(grid, rowIndex - 1, sourceColumn))?.borders?.bottom;
 	const aboveOwnsEdge = aboveBottom !== void 0 && paintsCssBorder(aboveBottom.style);
@@ -83,4 +123,4 @@ const getOrCreateOccupiedRow = (occupiedColumnsByRow, rowIndex) => {
 	return occupiedColumns;
 };
 //#endregion
-export { buildTableCellGrid, buildTableCellPlacements, getFirstAvailableColumn, getSourceCellAt, getSourceCellColumn, getTableCellVerticalBorderHeight };
+export { buildTableCellGrid, buildTableCellPlacements, getFirstAvailableColumn, getSourceCellAt, getSourceCellColumn, getTableCellSpacingInsetsX, getTableCellSpacingInsetsY, getTableCellVerticalBorderHeight };