@stll/folio-core 0.48.0 → 0.50.0

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

@@ -0,0 +1,145 @@
+import { getHorizontalScaleFactor } from "../../utils/horizontalScale.js";
+import { defaultLineBreakProvider, getLineBreakProvider } from "./lineBreakProvider.js";
+import { findGraphemeBreaks, isHangingPunctuation } from "./lineBreaks.js";
+import { twipsToPx } from "./measureHelpers.js";
+import { measureTextWidth } from "./measureProvider.js";
+import { WIDTH_TOLERANCE, isTextRun, runToFontStyle } from "./paragraphMeasureShared.js";
+//#region src/layout-engine/measure/lineFitting.ts
+/**
+* Line-fitting helpers: character-level fit search, the hyphenation zone,
+* final-candidate admission, and the trailing whitespace, letter-spacing and
+* hanging-punctuation widths a line break may exclude.
+*/
+/**
+* Find the longest prefix of `text` that fits within `maxWidth` pixels.
+* Returns the number of characters that fit (at least 1 if `forceMin` is true).
+*/
+function findMaxFittingLength(text, style, maxWidth, forceMin = false, policy) {
+	const boundaries = findGraphemeBreaks(text, policy);
+	let lo = 0;
+	let hi = boundaries.length - 1;
+	let best = 0;
+	while (lo <= hi) {
+		const mid = Math.floor((lo + hi) / 2);
+		const boundary = boundaries[mid];
+		if (measureTextWidth(text.slice(0, boundary), style) <= maxWidth) {
+			best = boundary;
+			lo = mid + 1;
+		} else hi = mid - 1;
+	}
+	return forceMin && best === 0 ? boundaries.at(0) ?? 0 : best;
+}
+function exceedsHyphenationZone(line, zoneTwips) {
+	if (line.width <= 0) return true;
+	const visibleWidth = Math.max(0, line.width - line.trailingWhitespaceWidth);
+	return Math.max(0, line.availableWidth - visibleWidth) > twipsToPx(zoneTwips) + WIDTH_TOLERANCE;
+}
+const isIgnorableFinalTailRun = (run) => run.kind === "renderedPageBreak" || isTextRun(run) && run.text.length === 0;
+function isFinalTextCandidate(block, runIndex, nextBreak) {
+	const currentRun = block.runs[runIndex];
+	if (!currentRun || !isTextRun(currentRun) || nextBreak !== currentRun.text.length) return false;
+	for (let index = runIndex + 1; index < block.runs.length; index += 1) {
+		const run = block.runs[index];
+		if (run && isIgnorableFinalTailRun(run)) continue;
+		return false;
+	}
+	return true;
+}
+/**
+* Fit of a text candidate on a justified line: the paragraph's final word may
+* be admitted by shrinking spaces, which then needs a paint plan.
+*/
+function resolveTextCandidateFit(isFinalCandidate, candidateWidth, availableWidth, tolerancePx) {
+	if (!isFinalCandidate) return {
+		type: "ordinary",
+		tolerancePx
+	};
+	return admitFinalCandidate(candidateWidth, availableWidth, tolerancePx);
+}
+/**
+* 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 <= .5 || contractionPx > tolerancePx) return {
+		type: "ordinary",
+		tolerancePx
+	};
+	return {
+		type: "final-contraction-admitted",
+		tolerancePx,
+		paint: {
+			type: "space-contraction",
+			contractionPx
+		}
+	};
+}
+function trimTrailingSpacesAndTabs(text) {
+	let end = text.length;
+	while (end > 0) {
+		const char = text[end - 1];
+		if (char !== " " && char !== "	") break;
+		end--;
+	}
+	return text.slice(0, end);
+}
+function measureWordWithTrailingWhitespace(word, style) {
+	const measuredWord = trimTrailingSpacesAndTabs(word);
+	const wordWidth = measureTextWidth(measuredWord, style);
+	const trailingWhitespace = word.slice(measuredWord.length);
+	if (trailingWhitespace.length === 0) return {
+		measuredWord,
+		wordWidth,
+		fullWordWidth: wordWidth
+	};
+	if (style.kerning || trailingWhitespace.includes("	")) return {
+		measuredWord,
+		wordWidth,
+		fullWordWidth: measureTextWidth(word, style)
+	};
+	const trailingWhitespaceWidth = measureTextWidth(trailingWhitespace, style);
+	const boundarySpacing = measuredWord.length > 0 ? (style.letterSpacing ?? 0) * getHorizontalScaleFactor(style.horizontalScale) : 0;
+	return {
+		measuredWord,
+		wordWidth,
+		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);
+	const preceding = text.charCodeAt(text.length - 2);
+	const start = trailing >= 56320 && trailing <= 57343 && preceding >= 55296 && preceding <= 56319 ? text.length - 2 : text.length - 1;
+	return text.slice(start);
+}
+const usesDefaultHangingPunctuationClassifier = () => {
+	return (getLineBreakProvider().isHangingPunctuation ?? defaultLineBreakProvider.isHangingPunctuation) === defaultLineBreakProvider.isHangingPunctuation;
+};
+function trailingHangingPunctuationWidth(text, style, policy, enabled) {
+	if (!enabled || text.length === 0) return 0;
+	const trailing = trailingCodePoint(text);
+	if (usesDefaultHangingPunctuationClassifier() && !isHangingPunctuation(trailing ?? "", policy)) return 0;
+	const lastStart = findGraphemeBreaks(text, policy).at(-2) ?? 0;
+	const lastGrapheme = text.slice(lastStart);
+	if (!isHangingPunctuation(lastGrapheme, policy)) return 0;
+	return measureTextWidth(lastGrapheme, style);
+}
+//#endregion
+export { exceedsHyphenationZone, findMaxFittingLength, isFinalTextCandidate, isIgnorableFinalTailRun, measureWordWithTrailingWhitespace, precedingLetterSpacing, resolveTextCandidateFit, trailingHangingPunctuationWidth, trimTrailingSpacesAndTabs };

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

@@ -0,0 +1,44 @@
+import { ParagraphAttrs, ParagraphSpacing, TextRun } from "../types.js";
+import { FontMetrics, FontStyle } from "./measureTypes.js";
+import { LineTypography } from "./paragraphMeasureShared.js";
+//#region src/layout-engine/measure/lineTypography.d.ts
+/**
+ * Line-HEIGHT style for a text run. Word derives a CJK line's height from an
+ * East-Asian face, not the run's ascii font: real documents routinely put CJK
+ * glyphs in runs whose ascii/eastAsia fonts are Latin (e.g. `w:eastAsia`
+ * "Century"), and Word font-links those glyphs to the default East-Asian face
+ * and uses its taller single-line height (≈1.303 vs the ≈1.15 Latin default).
+ *
+ * When the run holds CJK text, swap `fontFamily` to the face whose
+ * `singleLineRatio` Word would actually use: the run's `w:eastAsia` font when
+ * it is a real CJK face, the run's own ascii font when THAT is a CJK face, or
+ * `CJK_FALLBACK_FONT_FAMILY` otherwise. Non-CJK runs return `baseStyle`
+ * unchanged, so Latin-only documents are unaffected by construction.
+ *
+ * The result feeds `updateMaxFont` (line height) ONLY — width measurement
+ * keeps the base style so wrapping is untouched.
+ */
+declare function cjkLineHeightStyle(run: TextRun, baseStyle: FontStyle): FontStyle;
+/** Pick the dominant typography metrics for a run containing complex script. */
+declare function complexScriptLineHeightStyle(run: TextRun, baseStyle: FontStyle): FontStyle;
+/**
+ * Calculate typography metrics from font size and spacing settings
+ *
+ * @param fontSize - Font size in points
+ * @param spacing - Paragraph spacing settings
+ * @param metrics - Pre-calculated font metrics (in pixels)
+ */
+declare function calculateTypographyMetrics(fontSize: number, spacing?: ParagraphSpacing, metrics?: FontMetrics | null): LineTypography;
+/**
+ * Calculate metrics for an empty paragraph.
+ *
+ * Word renders an empty paragraph as a single readable line — its line
+ * height never collapses below 1.15 × font size, even when the doc
+ * explicitly writes `<w:line w:val="240"/>` (1.0×). The floor is scoped to
+ * `auto`/`atLeast` line rules; `exact` means exact (per OOXML §17.3.1.33)
+ * and stays untouched.
+ */
+declare function calculateEmptyParagraphMetrics(fontSize: number, spacing?: ParagraphSpacing, fontFamily?: string, attrs?: ParagraphAttrs): LineTypography;
+declare function applyDocumentGrid(typography: LineTypography, attrs: ParagraphAttrs | undefined, spacing: ParagraphSpacing | undefined): LineTypography;
+//#endregion
+export { applyDocumentGrid, calculateEmptyParagraphMetrics, calculateTypographyMetrics, cjkLineHeightStyle, complexScriptLineHeightStyle };

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

@@ -0,0 +1,124 @@
+import { CJK_FALLBACK_FONT_FAMILY, isCjkFont } from "../../utils/fontResolver.js";
+import { hasCjk, hasComplexScript, hasEastAsiaSlotText } from "../../utils/scriptSegments.js";
+import { applyComplexScriptFormatting, hasComplexScriptFormatting } from "./complexScriptFormatting.js";
+import { ptToPx } from "./measureHelpers.js";
+import { getFontMetrics } from "./measureProvider.js";
+import "./paragraphMeasureShared.js";
+//#region src/layout-engine/measure/lineTypography.ts
+/**
+* Line height and typography metrics: font-driven line heights, East Asian
+* and complex-script line height styles, empty-paragraph metrics, and
+* document-grid line pitch.
+*/
+/**
+* Line-HEIGHT style for a text run. Word derives a CJK line's height from an
+* East-Asian face, not the run's ascii font: real documents routinely put CJK
+* glyphs in runs whose ascii/eastAsia fonts are Latin (e.g. `w:eastAsia`
+* "Century"), and Word font-links those glyphs to the default East-Asian face
+* and uses its taller single-line height (≈1.303 vs the ≈1.15 Latin default).
+*
+* When the run holds CJK text, swap `fontFamily` to the face whose
+* `singleLineRatio` Word would actually use: the run's `w:eastAsia` font when
+* it is a real CJK face, the run's own ascii font when THAT is a CJK face, or
+* `CJK_FALLBACK_FONT_FAMILY` otherwise. Non-CJK runs return `baseStyle`
+* unchanged, so Latin-only documents are unaffected by construction.
+*
+* The result feeds `updateMaxFont` (line height) ONLY — width measurement
+* keeps the base style so wrapping is untouched.
+*/
+function cjkLineHeightStyle(run, baseStyle) {
+	if (!run.text) return baseStyle;
+	const eastAsia = baseStyle.eastAsiaFontFamily;
+	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
+		};
+		delete result.alternateFontFamily;
+		if (baseStyle.eastAsiaAlternateFontFamily !== void 0) result.alternateFontFamily = baseStyle.eastAsiaAlternateFontFamily;
+		return result;
+	}
+	if (isCjkFont(baseStyle.fontFamily ?? "Times New Roman")) return baseStyle;
+	return {
+		...baseStyle,
+		fontFamily: CJK_FALLBACK_FONT_FAMILY
+	};
+}
+/** Pick the dominant typography metrics for a run containing complex script. */
+function complexScriptLineHeightStyle(run, baseStyle) {
+	if (!hasComplexScriptFormatting(run) || !run.forceComplexScript && !hasComplexScript(run.text)) return baseStyle;
+	const complexStyle = applyComplexScriptFormatting(baseStyle, run);
+	return (complexStyle.fontSize ?? 11) >= (baseStyle.fontSize ?? 11) ? complexStyle : baseStyle;
+}
+/**
+* Calculate typography metrics from font size and spacing settings
+*
+* @param fontSize - Font size in points
+* @param spacing - Paragraph spacing settings
+* @param metrics - Pre-calculated font metrics (in pixels)
+*/
+function calculateTypographyMetrics(fontSize, spacing, metrics) {
+	const fontSizePx = ptToPx(fontSize);
+	const ascent = metrics?.ascent ?? fontSizePx * .8;
+	const descent = metrics?.descent ?? fontSizePx * .2;
+	const singleLineBase = fontSizePx * (metrics?.singleLineRatio ?? 1.15);
+	let lineHeight;
+	if (spacing?.lineRule === "exact" && spacing.line !== void 0) lineHeight = spacing.line;
+	else if (spacing?.lineRule === "atLeast" && spacing.line !== void 0) {
+		const defaultHeight = singleLineBase * 1;
+		lineHeight = Math.max(spacing.line, defaultHeight);
+	} else if (spacing?.line !== void 0 && spacing.lineUnit === "multiplier") lineHeight = singleLineBase * spacing.line;
+	else if (spacing?.line !== void 0 && spacing.lineUnit === "px") lineHeight = spacing.line;
+	else lineHeight = singleLineBase * 1;
+	return {
+		ascent,
+		descent,
+		lineHeight
+	};
+}
+/**
+* Word's "single line spacing" floor (≈ 1.15×) applied to empty paragraphs
+* with `auto`/`atLeast` line rules. Without this, narrow-metric fonts
+* (Arial Narrow, OS/2 ratio ≈ 1.117) collapse empty rows visibly tighter
+* than Word renders them. See eigenpal #391/#394.
+*/
+const WORD_SINGLE_LINE_FLOOR = 1.15;
+/**
+* Calculate metrics for an empty paragraph.
+*
+* Word renders an empty paragraph as a single readable line — its line
+* height never collapses below 1.15 × font size, even when the doc
+* explicitly writes `<w:line w:val="240"/>` (1.0×). The floor is scoped to
+* `auto`/`atLeast` line rules; `exact` means exact (per OOXML §17.3.1.33)
+* and stays untouched.
+*/
+function calculateEmptyParagraphMetrics(fontSize, spacing, fontFamily, attrs) {
+	const result = calculateTypographyMetrics(fontSize, spacing, getFontMetrics({
+		fontSize,
+		fontFamily: fontFamily ?? "Times New Roman",
+		...attrs?.defaultAlternateFontFamily !== void 0 ? { alternateFontFamily: attrs.defaultAlternateFontFamily } : {}
+	}));
+	const lineRule = spacing?.lineRule ?? "auto";
+	if (lineRule === "auto" || lineRule === "atLeast") {
+		const floor = ptToPx(fontSize) * WORD_SINGLE_LINE_FLOOR;
+		if (result.lineHeight < floor) return applyDocumentGrid({
+			...result,
+			lineHeight: floor
+		}, attrs, spacing);
+	}
+	return applyDocumentGrid(result, attrs, spacing);
+}
+function applyDocumentGrid(typography, attrs, spacing) {
+	const pitch = attrs?.documentGridLinePitch;
+	if (pitch === void 0 || pitch <= 0 || attrs?.snapToGrid === false) return typography;
+	if (spacing?.lineRule === "exact") return typography;
+	const lineHeight = Math.ceil(typography.lineHeight / pitch - 1e-9) * pitch;
+	return lineHeight === typography.lineHeight ? typography : {
+		...typography,
+		lineHeight
+	};
+}
+//#endregion
+export { applyDocumentGrid, calculateEmptyParagraphMetrics, calculateTypographyMetrics, cjkLineHeightStyle, complexScriptLineHeightStyle };

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

@@ -1,14 +1,16 @@
 import { hasPageBreakBefore } from "../keep-together.js";
 import { recordMeasureBlock, recordMeasureBlockError } from "../layoutInstrumentation.js";
 import { isParagraphFrameTextBox } from "../paragraphFrame.js";
+import { resolveTableSpacing } from "../paragraphSpacing.js";
 import { sectionStartAdvanceOf } from "../section-breaks.js";
 import { bandFragmentX, bandTopContentY, isPageFrameRelativeAnchor } from "../textBoxFlow.js";
 import { getTextBoxGroupId } from "../textBoxGroup.js";
 import { DEFAULT_TEXTBOX_MARGINS, floatingTextBoxReservesBand, floatingTextBoxWrapsText, resolveTableCellPadding, resolveTableWidthPx, tableColumnsArePinned } from "../types.js";
 import { getCachedParagraphMeasure, setCachedParagraphMeasure } from "./cache.js";
+import { findClearLineY } from "./floatingLineClearance.js";
 import { resolveFloatingTablePageX } from "./floatingTablePosition.js";
 import { getHyphenationDictionaryMisses } from "./hyphenationDictionaries.js";
-import { findClearLineY, measureParagraph } from "./measureParagraph.js";
+import { measureParagraph } from "./measureParagraph.js";
 import { buildTableCellFloatingZones, getTableCellFloatingImages } from "./tableCellFloating.js";
 import { createTableCellFlowState, finishTableCellFlow, placeTableCellBlock } from "./tableCellFlow.js";
 import { buildTableCellGrid, getFirstAvailableColumn, getTableCellSpacingInsetsX, getTableCellSpacingInsetsY, getTableCellVerticalBorderHeight } from "./tableCellGrid.js";
@@ -97,6 +99,7 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 		}
 	}
 	const cellGrid = buildTableCellGrid(tableBlock.rows, columnWidths.length);
+	const spacingRows = resolveTableSpacing(tableBlock).rows;
 	const cellSpacing = tableBlock.cellSpacing;
 	const bordersSeparated = (cellSpacing ?? 0) > 0;
 	const rowCount = tableBlock.rows.length;
@@ -104,7 +107,7 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 	const rows = tableBlock.rows.map((row, rowIdx) => {
 		let columnIndex = getFirstAvailableColumn(cellGrid, rowIdx, row.gridBefore ?? 0);
 		return {
-			cells: row.cells.map((cell) => {
+			cells: row.cells.map((cell, cellIdx) => {
 				const colSpan = cell.colSpan ?? 1;
 				let cellWidth = 0;
 				for (let c = 0; c < colSpan && columnIndex + c < columnWidths.length; c++) cellWidth += columnWidths[columnIndex + c] ?? 0;
@@ -121,7 +124,7 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 					width: cellWidth,
 					height: 0
 				};
-				if (!keepSingleLine) wrapTableCellParagraphsAroundFloats(cell, cellMeasure, cellContentWidth, fieldValues);
+				if (!keepSingleLine) wrapTableCellParagraphsAroundFloats(spacingRows[rowIdx]?.cells[cellIdx] ?? cell, cellMeasure, cellContentWidth, fieldValues);
 				if (cell.colSpan !== void 0) cellMeasure.colSpan = cell.colSpan;
 				if (cell.rowSpan !== void 0) cellMeasure.rowSpan = cell.rowSpan;
 				return cellMeasure;
@@ -141,7 +144,7 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 			}));
 			continue;
 		}
-		const sourceRowCells = tableBlock.rows[rowIdx]?.cells;
+		const sourceRowCells = spacingRows[rowIdx]?.cells;
 		let maxCellHeightWithBorders = 0;
 		let maxCellInsets = 0;
 		for (let cellIdx = 0; cellIdx < row.cells.length; cellIdx++) {

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

@@ -6,6 +6,7 @@ import { buildFontString, getResolvedData, ptToPx } from "./measureHelpers.js";
 import { setMeasureProvider } from "./measureProvider.js";
 import { canPrefetchMeasurement, prefetchMeasurement } from "./measureWorker.js";
 import { WORKER_FONT_FINGERPRINT_TEXT, countCodePoints } from "./measureWorkerProtocol.js";
+import { SMALL_CAPS_SCALE, smallCapsMask, smallCapsSegments } from "./smallCapsCasing.js";
 import { getFontKerningMode } from "./textMeasurementPolicy.js";
 import { panic } from "better-result";
 //#region src/layout-engine/measure/measureContainer.ts
@@ -136,6 +137,7 @@ function canvasMeasureTextWidth(text, sourceStyle) {
 	if (!text) return 0;
 	const style = sourceStyle.forceComplexScript ? applyComplexScriptFormatting(sourceStyle, sourceStyle) : sourceStyle;
 	const measuredText = applyTextTransform(text, style);
+	if (!sourceStyle.forceComplexScript && style.fontVariant === "small-caps") return measureSmallCapsWidth(measuredText, style);
 	if (!sourceStyle.forceComplexScript && !style.letterSpacing && needsPerScriptFonts(style, measuredText)) return measureMixedScriptWidth(measuredText, style);
 	const ctx = getCanvasContext();
 	const font = buildFontString(style);
@@ -228,6 +230,38 @@ function measureMixedScriptWidth(measuredText, style) {
 	return width * horizontalScale;
 }
 /**
+* Width of a `w:smallCaps` run: its lowercase letters (and the whitespace
+* that follows them — see smallCapsCasing.ts) draw at `SMALL_CAPS_SCALE` of
+* the run's size, everything else at full size. A small segment is measured
+* at that literal, smaller font string — not the full-size advance scaled by
+* arithmetic — so hinting and sub-pixel snapping agree with the painted DOM
+* span, which sets this same font-size. Each segment still recurses into
+* {@link canvasMeasureTextWidth} (so one that itself needs the East-Asian or
+* complex-script font still gets it); letter spacing and horizontal scale
+* apply once over the whole string, as {@link measureMixedScriptWidth} does
+* for a script split.
+*/
+function measureSmallCapsWidth(measuredText, style) {
+	const letterSpacing = style.letterSpacing ?? 0;
+	const horizontalScale = getHorizontalScaleFactor(style.horizontalScale);
+	const segmentStyle = { ...style };
+	delete segmentStyle.fontVariant;
+	delete segmentStyle.letterSpacing;
+	delete segmentStyle.horizontalScale;
+	const smallSegmentStyle = {
+		...segmentStyle,
+		fontSize: (segmentStyle.fontSize ?? 11) * SMALL_CAPS_SCALE
+	};
+	let glyphWidth = 0;
+	for (const segment of smallCapsSegments(measuredText)) glyphWidth += canvasMeasureTextWidth(segment.text, segment.small ? smallSegmentStyle : segmentStyle);
+	let width = glyphWidth;
+	if (letterSpacing) {
+		const codePoints = countCodePoints(measuredText);
+		if (codePoints > 1) width += letterSpacing * (codePoints - 1);
+	}
+	return width * horizontalScale;
+}
+/**
 * Speculatively enqueue the slice lengths that a subsequent
 * `findMaxFittingLength` binary search is likely to probe. We pick the
 * geometric series (full, half, quarter, eighth) which covers the
@@ -293,18 +327,26 @@ function canvasMeasureRun(text, sourceStyle) {
 		...style.eastAsiaAlternateFontFamily !== void 0 ? { alternateFontFamily: style.eastAsiaAlternateFontFamily } : {}
 	}) : void 0;
 	const complexScriptFont = hasComplexScriptFormatting(style) && !style.letterSpacing ? buildFontString(scriptStyle(style, SCRIPT_CLASS.complex)) : void 0;
+	const smallCapsFont = style.fontVariant === "small-caps" ? buildFontString({
+		...style,
+		fontSize: (style.fontSize ?? 11) * SMALL_CAPS_SCALE
+	}) : void 0;
 	const letterSpacing = style.letterSpacing ?? 0;
 	const scale = getHorizontalScaleFactor(style.horizontalScale);
 	const charWidths = [];
 	let totalWidth = 0;
+	const smallCapsAt = smallCapsFont !== void 0 ? smallCapsMask(text) : void 0;
 	let offset = 0;
+	let codePointIndex = 0;
 	for (const char of text) {
 		const cp = char.codePointAt(0);
-		const measured = applyTextTransform(char, style);
-		if (eastAsiaFont !== void 0 || complexScriptFont !== void 0) {
+		const isSmallCap = smallCapsAt?.[codePointIndex] ?? false;
+		const measured = isSmallCap ? char.toLocaleUpperCase() : applyTextTransform(char, style);
+		if (isSmallCap && smallCapsFont !== void 0) ctx.font = smallCapsFont;
+		else if (eastAsiaFont !== void 0 || complexScriptFont !== void 0) {
 			const script = scriptClassOf(cp, style.eastAsiaHint);
 			ctx.font = (script === SCRIPT_CLASS.eastAsia ? eastAsiaFont : void 0) ?? (script === SCRIPT_CLASS.complex ? complexScriptFont : void 0) ?? baseFont;
-		}
+		} else if (smallCapsFont !== void 0) ctx.font = baseFont;
 		let charWidth = ctx.measureText(measured).width;
 		if (letterSpacing && offset + char.length < text.length) charWidth += letterSpacing;
 		charWidth *= scale;
@@ -312,6 +354,7 @@ function canvasMeasureRun(text, sourceStyle) {
 		if (char.length === 2) charWidths.push(0);
 		totalWidth += charWidth;
 		offset += char.length;
+		codePointIndex += 1;
 	}
 	return {
 		width: totalWidth,

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

@@ -34,6 +34,18 @@ function docxScriptFontSize(fontSize) {
 	return Math.max(1, Math.floor(fontSize * 2 * 2 / 3)) / 2;
 }
 /**
+* The `textTransform`/`fontVariant` a run's caps toggles contribute.
+*
+* `w:caps` wins when both are set: full-size capitals, never synthesized
+* small ones (matching the else-if in formatToStyle.ts's live editor
+* styling).
+*/
+function capsStyleOf(run) {
+	if (run.allCaps) return { textTransform: "uppercase" };
+	if (run.smallCaps) return { fontVariant: "small-caps" };
+	return {};
+}
+/**
 * Build a measurement `FontStyle` from a run's formatting. Single source of
 * truth for run → FontStyle so every measurement path (layout line-breaking,
 * click-to-position, selection rects) carries the same fields — notably
@@ -61,8 +73,7 @@ function buildRunFontStyle(run, fallbackFontFamily, fallbackFontSize) {
 		...run.bold !== void 0 ? { bold: run.bold } : {},
 		...run.italic !== void 0 ? { italic: run.italic } : {},
 		...run.letterSpacing !== void 0 ? { letterSpacing: run.letterSpacing } : {},
-		...run.allCaps ? { textTransform: "uppercase" } : {},
-		...run.smallCaps ? { fontVariant: "small-caps" } : {},
+		...capsStyleOf(run),
 		...horizontalScale !== void 0 ? { horizontalScale } : {},
 		kerning: getRunFontKerningMode(run, fallbackFontSize) === FONT_KERNING_MODE.enabled
 	};
@@ -119,7 +130,6 @@ function clearFontResolvedCache() {
 function buildFontString(style) {
 	const parts = [];
 	if (style.italic) parts.push("italic");
-	if (style.fontVariant) parts.push(style.fontVariant);
 	if (style.bold) parts.push("700");
 	const fontSizePx = ptToPx(style.fontSize ?? 11);
 	parts.push(`${fontSizePx}px`);

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

@@ -1,6 +1,7 @@
 import { ParagraphBlock, ParagraphMeasure, TextRun } from "../types.js";
 import { FloatingImageZone } from "./floatingZones.js";
 import { clampFloatingWrapMargins } from "./clampFloatingWrapMargins.js";
+import { MIN_WRAP_SEGMENT_WIDTH, findClearLineY } from "./floatingLineClearance.js";
 //#region src/layout-engine/measure/measureParagraph.d.ts
 /**
  * Options for paragraph measurement
@@ -16,26 +17,6 @@ type MeasureParagraphOptions = {
   /** Header/footer tabs may be authored in the page margin, beyond body width. */
   allowEndTabOverflow?: boolean;
 };
-/**
- * Minimum horizontal room a line must offer before we treat it as usable for
- * body text. Below this threshold the line is bumped past obstructing floats
- * via `findClearLineY` instead of being rendered into the unusable sliver.
- * Without this guard, a near-full-width float (e.g. floating table) produces
- * a ~2px segment that collapses every wrap line to one glyph per row.
- */
-declare const MIN_WRAP_SEGMENT_WIDTH = 24;
-/**
- * Find the next vertical position at or below `startY` where the available
- * text width is at least `minWidth`. Used to skip lines past stacked floats
- * when there is no horizontal room for meaningful text at the current Y.
- *
- * Returns `startY` if the current position already has enough room, otherwise
- * the lowest `bottomY` of any zone currently obstructing the line. The caller
- * is expected to re-query margins at the returned Y.
- *
- * Coordinates are absolute (i.e., already include any paragraphYOffset).
- */
-declare function findClearLineY(startY: number, lineHeight: number, zones: FloatingImageZone[] | undefined, contentWidth: number, minWidth: number): number;
 /**
  * Measure a paragraph block and compute line breaks
  *